.github/workflows/build.yml

@@ -4,9 +4,6 @@ on: [push]
 
 jobs:
   XTChain:
-    strategy:
-      matrix:
-        target: [linux, windows]
     runs-on: oscw
     container:
       image: codingworkshop/oscw-runner:latest
@@ -14,10 +11,10 @@ jobs:
       - name: Clone repository
         uses: actions/checkout@v3
       - name: Build XTChain
-        run: ./build.sh --jobs=10 --target=${{ matrix.target }}
+        run: CORES=10 ./build-linux.sh
       - name: Publish binaries
         if: startsWith(github.ref, 'refs/tags/')
         env:
           OSCW_GITHUB_USERNAME: ${{ secrets.OSCW_GITHUB_USERNAME }}
           OSCW_GITHUB_PASSWORD: ${{ secrets.OSCW_GITHUB_PASSWORD }}
-        run: github_publish $OSCW_GITHUB_USERNAME $OSCW_GITHUB_PASSWORD $(ls xtchain-*-${{ matrix.target }}.*)
+        run: github_publish $OSCW_GITHUB_USERNAME $OSCW_GITHUB_PASSWORD $(ls xtchain-*-linux.tar.zst)

README.md

@@ -22,19 +22,22 @@
 ---
 
 ## XT Toolchain
-This is a LLVM/Clang/LLD based toolchain. It currently supports C and C++, and provides
+This is a LLVM/Clang/LLD based mingw-w64 toolchain. It currently supports C and C++, and provides
 a variety of tools including IDL, message and resource compilers. The XT Toolchain is also the
 official build environment for compiling XT software, including the XT OS. Currently, it is
-targeted at Linux and Windows host systems.
+targeted at Linux host only, however it should be possible to build it in MSYS2 as well.
 
-Benefits of a LLVM based toolchain are:
+Benefits of a LLVM based MinGW toolchain are:
  * Single toolchain targeting all architectures (i686, x86_64, armv7 and aarch64),
  * Support for generating debug info in PDB format,
  * Support for targeting ARM/AARCH64 architectures and ability to produce Windows ARM binaries.
 
 This software includes:
  * CMake
+ * GNU Assembler
  * LLVM
+ * Make
+ * Mingw-w64
  * Ninja
  * Wine
 

build-linux.sh

@@ -0,0 +1,566 @@
+#!/bin/bash
+# PROJECT:     XTchain
+# LICENSE:     See the COPYING.md in the top level directory
+# FILE:        build-linux.sh
+# DESCRIPTION: Toolchain building and assembly script
+# DEVELOPERS:  Rafal Kupiec <belliash@codingworkshop.eu.org>
+
+
+# Working Directories
+BINDIR="$(pwd)/binaries"
+PCHDIR="$(pwd)/patches"
+SRCDIR="$(pwd)/sources"
+WRKDIR="$(pwd)"
+
+# Architecture Settings
+ARCHS="aarch64 armv7 i686 x86_64"
+GENERIC="generic-w64-mingw32"
+
+# CMake Settings
+CMAKEDIR="${SRCDIR}/cmake"
+CMAKETAG="v3.31.3"
+CMAKEVCS="https://gitlab.kitware.com/cmake/cmake.git"
+
+# LLVM Settings
+LLVMDIR="${SRCDIR}/llvm"
+LLVMTAG="llvmorg-19.1.6"
+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"
+NINJAVCS="https://github.com/ninja-build/ninja.git"
+
+# Wine Settings
+WINEDIR="${SRCDIR}/wine"
+WINETAG="wine-9.8"
+WINEVCS="https://github.com/wine-mirror/wine.git"
+
+
+# This function applies a patches to the 3rd party project
+apply_patches()
+{
+    local PACKAGE="${1}"
+    local VERSION="${2}"
+    if [ -d "${PCHDIR}/${PACKAGE}/${VERSION}" ]; then
+        PATCHES="$(find ${PCHDIR}/${PACKAGE}/${VERSION} -name '*.diff' -o -name '*.patch' | sort -n)"
+        echo ">>> Applying custom patches ..."
+        for PATCH in ${PATCHES}; do
+            if [ -f "${PATCH}" ] && [ -r "${PATCH}" ]; then
+                for PREFIX in {0..5}; do
+                    if patch -i${PATCH} -p${PREFIX} --silent --dry-run >/dev/null; then
+                        patch -i${PATCH} -p${PREFIX} --silent
+                        echo ">>> Patch ${PATCH} applied ..."
+                        break;
+                    elif [ ${PREFIX} -ge 5 ]; then
+                        echo "Patch ${PATCH} does not fit. Failed applying patch ..."
+                        return 1
+                    fi
+                done
+            fi
+        done
+    fi
+}
+
+# This function compiles and installs CMAKE
+cmake_build()
+{
+    echo ">>> Building CMAKE ..."
+    [ -z ${CLEAN} ] || rm -rf ${CMAKEDIR}/build-${GENERIC}
+    mkdir -p ${CMAKEDIR}/build-${GENERIC}
+    cd ${CMAKEDIR}/build-${GENERIC}
+    ../bootstrap \
+        --prefix=${BINDIR} \
+        --parallel=${CORES} \
+        -- -DCMAKE_USE_OPENSSL=OFF
+    make -j${CORES}
+    make install
+    cd ${WRKDIR}
+}
+
+# This function downloads CMAKE from VCS
+cmake_fetch()
+{
+    if [ ! -d ${CMAKEDIR} ]; then
+        echo ">>> Downloading CMAKE ..."
+        git clone --depth 1 --branch ${CMAKETAG} ${CMAKEVCS} ${CMAKEDIR}
+        cd ${CMAKEDIR}
+        apply_patches ${CMAKEDIR##*/} ${CMAKETAG}
+        cd ${WRKDIR}
+    fi
+}
+
+# This function compiles and install LLVM
+llvm_build()
+{
+    echo ">>> Building LLVM ..."
+    [ -z ${CLEAN} ] || rm -rf ${LLVMDIR}/llvm/build
+    LLVM_ARCHS=()
+    for ARCH in ${ARCHS}; do
+        case ${ARCH} in
+            "aarch64")
+                LLVM_ARCHS+=( "AArch64" )
+                ;;
+            "armv7")
+                LLVM_ARCHS+=( "ARM" )
+                ;;
+            "i686"|"x86_64")
+                LLVM_ARCHS+=( "X86" )
+                ;;
+        esac
+    done
+    LLVM_ARCHS=( $(for ARCH in ${LLVM_ARCHS[@]}; do echo ${ARCH}; done | sort -u) )
+    cd ${LLVMDIR}/llvm/tools
+    for UTIL in clang lld; do
+        if [ ! -e ${UTIL} ]; then
+            ln -sf ../../${UTIL} .
+        fi
+    done
+    mkdir -p ${LLVMDIR}/llvm/build
+    cd ${LLVMDIR}/llvm/build
+    cmake -G Ninja \
+        -DCMAKE_BUILD_TYPE="Release" \
+        -DCMAKE_INSTALL_PREFIX=${BINDIR} \
+        -DLLDB_INCLUDE_TESTS=FALSE \
+        -DLLVM_ENABLE_ASSERTIONS=FALSE \
+        -DLLVM_ENABLE_PROJECTS="clang;clang-tools-extra;lld;lldb" \
+        -DLLVM_INSTALL_TOOLCHAIN_ONLY=ON \
+        -DLLVM_LINK_LLVM_DYLIB=ON \
+        -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" \
+        ..
+        ninja install/strip
+        cd ${WRKDIR}
+}
+
+# This function compiles and install LIBCXX & LIBUNWIND
+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
+        echo ">>> Downloading LLVM ..."
+        git clone --depth 1 --branch ${LLVMTAG} ${LLVMVCS} ${LLVMDIR}
+        cd ${LLVMDIR}
+        apply_patches ${LLVMDIR##*/} ${LLVMTAG##*-}
+        cd ${WRKDIR}
+    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()
+{
+    echo ">>> Building NINJA ..."
+    [ -z ${CLEAN} ] || rm -rf ${NINJADIR}/build-${GENERIC}
+    mkdir -p ${NINJADIR}/build-${GENERIC}
+    cd ${NINJADIR}/build-${GENERIC}
+    ../configure.py --bootstrap
+    install ninja ${BINDIR}/bin/
+    cd ${WRKDIR}
+}
+
+# This function downloads NINJA from VCS
+ninja_fetch()
+{
+    if [ ! -d ${NINJADIR} ]; then
+        echo ">>> Downloading NINJA ..."
+        git clone --depth 1 --branch ${NINJATAG} ${NINJAVCS} ${NINJADIR}
+        cd ${NINJADIR}
+        apply_patches ${NINJADIR##*/} ${NINJATAG}
+        cd ${WRKDIR}
+    fi
+}
+
+# This function compiles and install WINE tools
+wine_build()
+{
+    echo ">>> Building Wine ..."
+    mkdir -p ${WINEDIR}/build
+    cd ${WINEDIR}/build
+    ../configure \
+        -enable-win64 \
+        --without-freetype \
+        --without-x
+    for TOOL in winedump wmc wrc; do
+        make -j${CORES} 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}
+}
+
+# This function downloads WINE from VCS
+wine_fetch()
+{
+    if [ ! -d ${WINEDIR} ]; then
+        echo ">>> Downloading WINE ..."
+        git clone --depth 1 --branch ${WINETAG} ${WINEVCS} ${WINEDIR}
+        cd ${WINEDIR}
+        apply_patches ${WINEDIR##*/} ${WINETAG##*-}
+        cd ${WRKDIR}
+    fi
+}
+
+# This function installs XTCHAIN scripts, wrappers and symlinks
+xtchain_build()
+{
+    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
+            ln -sf ../${GENERIC}/bin/clang-target-wrapper ${BINDIR}/bin/${ARCH}-w64-mingw32-${EXEC}
+        done
+        for EXEC in addr2line ar as nm objcopy pdbutil ranlib rc strings strip; do
+            ln -sf llvm-${EXEC} ${BINDIR}/bin/${ARCH}-w64-mingw32-${EXEC}
+        done
+        for EXEC in dlltool ld objdump; do
+            ln -sf ../${GENERIC}/bin/${EXEC}-wrapper ${BINDIR}/bin/${ARCH}-w64-mingw32-${EXEC}
+        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}
+        done
+    done
+    cp ${WRKDIR}/scripts/xtclib ${BINDIR}/lib/xtchain/
+    cp ${WRKDIR}/scripts/xtchain ${BINDIR}/
+}
+
+
+# Exit immediately on any failure
+set -e
+
+# Check number of CPU cores available
+if [[ ! -n ${CORES} ]]; then
+	: ${CORES:=$(sysctl -n hw.ncpu 2>/dev/null)}
+	: ${CORES:=$(nproc 2>/dev/null)}
+	: ${CORES:=1}
+fi
+
+# Create working directories
+mkdir -p ${BINDIR}
+mkdir -p ${SRCDIR}
+
+# XTchain
+xtchain_build
+
+# Download LLVM
+llvm_fetch
+
+# Build and install LLVM
+llvm_build
+
+# Download Mingw-W64
+mingw_fetch
+
+# Build and install Mingw-W64 headers
+mingw_build_headers
+
+# 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} .

build.sh

@@ -1,482 +0,0 @@
-#!/bin/bash
-# PROJECT:     XTchain
-# LICENSE:     See the COPYING.md in the top level directory
-# FILE:        build.sh
-# DESCRIPTION: Toolchain crosscompilation and assembly script
-# DEVELOPERS:  Rafal Kupiec <belliash@codingworkshop.eu.org>
-#              Aiken Harris <harraiken91@gmail.com>
-
-# Working Directories
-BINDIR="$(pwd)/binaries"
-PCHDIR="$(pwd)/patches"
-SRCDIR="$(pwd)/sources"
-WRKDIR="$(pwd)"
-
-# Architecture Settings
-ARCHS="aarch64 armv7 i686 x86_64"
-
-# Default Configuration
-BUILD_JOBS=0
-BUILD_MINIMAL=0
-CLEAN_BUILD=0
-ENABLE_LLVM_ASSEMBLY=0
-LLVM_DYNAMIC_LINK=ON
-SYSTEM_NAME=Linux
-TARGET_SYSTEM=linux
-
-# CMake Settings
-CMAKEDIR="${SRCDIR}/cmake"
-CMAKETAG="v4.0.3"
-CMAKEVCS="https://gitlab.kitware.com/cmake/cmake.git"
-
-# LLVM Settings
-LLVMDIR="${SRCDIR}/llvm"
-LLVMTAG="llvmorg-20.1.7"
-LLVMVCS="https://github.com/llvm/llvm-project.git"
-
-# Ninja Settings
-NINJADIR="${SRCDIR}/ninja"
-NINJATAG="v1.13.0"
-NINJAVCS="https://github.com/ninja-build/ninja.git"
-
-# Wine Settings
-WINEDIR="${SRCDIR}/wine"
-WINETAG="wine-10.11"
-WINEVCS="https://github.com/wine-mirror/wine.git"
-
-
-
-# This function applies a patches to the 3rd party project
-apply_patches()
-{
-    local PACKAGE="${1}"
-    local VERSION="${2}"
-    if [ -d "${PCHDIR}/${PACKAGE}/${VERSION}" ]; then
-        PATCHES="$(find ${PCHDIR}/${PACKAGE}/${VERSION} -name '*.diff' -o -name '*.patch' | sort -n)"
-        echo ">>> Applying custom patches ..."
-        for PATCH in ${PATCHES}; do
-            if [ -f "${PATCH}" ] && [ -r "${PATCH}" ]; then
-                for PREFIX in {0..5}; do
-                    if patch -i${PATCH} -p${PREFIX} --silent --dry-run >/dev/null; then
-                        patch -i${PATCH} -p${PREFIX} --silent
-                        echo ">>> Patch ${PATCH} applied ..."
-                        break;
-                    elif [ ${PREFIX} -ge 5 ]; then
-                        echo "Patch ${PATCH} does not fit. Failed applying patch ..."
-                        return 1
-                    fi
-                done
-            fi
-        done
-    fi
-}
-
-# This function compiles and installs CMAKE
-cmake_build()
-{
-    local CMAKE_PARAMETERS=""
-
-    # Clean old build if necessary
-    [ "${CLEAN_BUILD}" -eq 1 ] && rm -rf ${WINEDIR}/build-${SYSTEM_NAME}
-
-    # 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 ..."
-    mkdir -p ${CMAKEDIR}/build-${SYSTEM_NAME}
-    cd ${CMAKEDIR}/build-${SYSTEM_NAME}
-    cmake \
-        -DCMAKE_BUILD_TYPE=Release \
-        -DCMAKE_FIND_ROOT_PATH_MODE_INCLUDE=ONLY \
-        -DCMAKE_FIND_ROOT_PATH_MODE_LIBRARY=ONLY \
-        -DCMAKE_FIND_ROOT_PATH_MODE_PROGRAM=NEVER \
-        -DCMAKE_INSTALL_PREFIX=${BINDIR} \
-        -DCMAKE_SYSTEM_NAME=${SYSTEM_NAME} \
-        -DCMAKE_USE_OPENSSL=OFF \
-        ${CMAKE_PARAMETERS} \
-        ..
-    cmake --build .
-    cmake --install .
-    cd ${WRKDIR}
-}
-
-# This function downloads CMAKE from VCS
-cmake_fetch()
-{
-    if [ ! -d ${CMAKEDIR} ]; then
-        echo ">>> Downloading CMAKE ..."
-        git clone --depth 1 --branch ${CMAKETAG} ${CMAKEVCS} ${CMAKEDIR}
-        cd ${CMAKEDIR}
-        apply_patches ${CMAKEDIR##*/} ${CMAKETAG}
-        cd ${WRKDIR}
-    fi
-}
-
-# This function compiles and install LLVM
-llvm_build()
-{
-    local CMAKE_PARAMETERS=""
-    local LLVM_ARCHS=()
-
-    # Clean old build if necessary
-    [ "${CLEAN_BUILD}" -eq 1 ] && rm -rf ${LLVMDIR}/llvm/build-${SYSTEM_NAME}
-
-    # Set supported architectures
-    for ARCH in ${ARCHS}; do
-        case ${ARCH} in
-            "aarch64")
-                LLVM_ARCHS+=( "AArch64" )
-                ;;
-            "armv7")
-                LLVM_ARCHS+=( "ARM" )
-                ;;
-            "i686"|"x86_64")
-                LLVM_ARCHS+=( "X86" )
-                ;;
-        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
-            ln -sf ../../${UTIL} .
-        fi
-    done
-    mkdir -p ${LLVMDIR}/llvm/build-${SYSTEM_NAME}
-    cd ${LLVMDIR}/llvm/build-${SYSTEM_NAME}
-    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} \
-        -DCMAKE_SYSTEM_NAME="${SYSTEM_NAME}" \
-        -DLLDB_INCLUDE_TESTS=OFF \
-        -DLLVM_ENABLE_ASSERTIONS=OFF \
-        -DLLVM_ENABLE_PROJECTS="clang;clang-tools-extra;lld;lldb" \
-        -DLLVM_INSTALL_TOOLCHAIN_ONLY=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-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}
-}
-
-# This function downloads LLVM from VCS
-llvm_fetch()
-{
-    if [ ! -d ${LLVMDIR} ]; then
-        echo ">>> Downloading LLVM ..."
-        git clone --depth 1 --branch ${LLVMTAG} ${LLVMVCS} ${LLVMDIR}
-        cd ${LLVMDIR}
-        apply_patches ${LLVMDIR##*/} ${LLVMTAG##*-}
-        cd ${WRKDIR}
-    fi
-}
-
-# This function compiles and installs NINJA
-ninja_build()
-{
-    local EXTENSION=""
-    local NINJA_CXX_COMPILER=""
-    local NINJA_PLATFORM=""
-
-    # Clean old build if necessary
-    [ "${CLEAN_BUILD}" -eq 1 ] && rm -rf ${NINJADIR}/build-${SYSTEM_NAME}
-
-    # Additional, target-specific configuration options
-    case "${SYSTEM_NAME}" in
-        Windows)
-            EXTENSION=".exe"
-            NINJA_CXX_COMPILER="${SYSTEM_HOST}-g++"
-            NINJA_PLATFORM="mingw"
-            ;;
-        *)
-            NINJA_CXX_COMPILER="clang++"
-            NINJA_PLATFORM="linux"
-            ;;
-    esac
-
-    # Build Ninja
-    echo ">>> Building NINJA ..."
-    mkdir -p ${NINJADIR}/build-${SYSTEM_NAME}
-    cd ${NINJADIR}/build-${SYSTEM_NAME}
-    CXX=${NINJA_CXX_COMPILER} ../configure.py --platform=${NINJA_PLATFORM}
-    ninja
-    install ninja${EXTENSION} ${BINDIR}/bin/
-    cd ${WRKDIR}
-}
-
-# This function downloads NINJA from VCS
-ninja_fetch()
-{
-    if [ ! -d ${NINJADIR} ]; then
-        echo ">>> Downloading NINJA ..."
-        git clone --depth 1 --branch ${NINJATAG} ${NINJAVCS} ${NINJADIR}
-        cd ${NINJADIR}
-        apply_patches ${NINJADIR##*/} ${NINJATAG}
-        cd ${WRKDIR}
-    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] [--minimal] [--static-llvm] [--target={linux,windows}]"
-    exit 1
-}
-
-# This function compiles and install WINE tools
-wine_build()
-{
-    local CONFIGURE_PARAMETERS=""
-    local EXTENSION=""
-
-    # Clean old build if necessary
-    [ "${CLEAN_BUILD}" -eq 1 ] && rm -rf ${WINEDIR}/{build-${SYSTEM_NAME},build-tools}
-
-    # Additional, target-specific configuration options
-    case "${SYSTEM_NAME}" in
-        Windows)
-            CONFIGURE_PARAMETERS="${CONFIGURE_PARAMETERS} --host=${SYSTEM_HOST}"
-            EXTENSION=".exe"
-            ;;
-    esac
-
-    # Build Wine (first configuration builds makedep)
-    echo ">>> Building Wine ..."
-    mkdir -p ${WINEDIR}/{build-${SYSTEM_NAME},build-tools}
-    cd ${WINEDIR}/build-tools
-    ../configure \
-        --enable-win64 \
-        --without-freetype \
-        --without-x
-    cd ${WINEDIR}/build-${SYSTEM_NAME}
-    ../configure \
-        --enable-tools \
-        --enable-win64 \
-        --with-wine-tools=${WINEDIR}/build-tools \
-        --without-freetype \
-        --without-x \
-        ${CONFIGURE_PARAMETERS}
-    for TOOL in widl wmc wrc; do
-        make -j20 tools/${TOOL}/all
-        cp tools/${TOOL}/${TOOL}${EXTENSION} ${BINDIR}/bin/
-    done
-    cd ${WRKDIR}
-}
-
-# This function downloads WINE from VCS
-wine_fetch()
-{
-    if [ ! -d ${WINEDIR} ]; then
-        echo ">>> Downloading WINE ..."
-        git clone --depth 1 --branch ${WINETAG} ${WINEVCS} ${WINEDIR}
-        cd ${WINEDIR}
-        apply_patches ${WINEDIR##*/} ${WINETAG##*-}
-        cd ${WRKDIR}
-    fi
-}
-
-# This function installs XTCHAIN tools and scripts
-xtchain_build()
-{
-    # Target-specific configuration options
-    case "${SYSTEM_NAME}" in
-        Windows)
-            CCOMPILER="${SYSTEM_HOST}-gcc"
-            EXTENSION=".ps1"
-            ;;
-        *)
-            CCOMPILER="clang"
-            EXTENSION=""
-    esac
-
-    # Build XTchain tools
-    echo ">>> Building XTchain tools ..."
-    mkdir -p ${BINDIR}/bin
-    mkdir -p ${BINDIR}/lib/xtchain
-    for EXEC in bin2c exetool xtcspecc; do
-        if [ ! -e ${BINDIR}/bin/${EXEC} ]; then
-            ${CCOMPILER} ${WRKDIR}/tools/${EXEC}.c -o ${BINDIR}/bin/${EXEC}
-        fi
-    done
-    cp ${WRKDIR}/scripts/xtclib${EXTENSION} ${BINDIR}/lib/xtchain/
-    cp ${WRKDIR}/scripts/xtchain${EXTENSION} ${BINDIR}/
-}
-
-# This function generates XTCHAIN version file and produces tarball archive
-xtchain_tarball()
-{
-    local EXTENSION=""
-
-    # Additional, target-specific configuration options
-    case "${SYSTEM_NAME}" in
-        Windows)
-            EXTENSION=".exe"
-            ;;
-    esac
-
-    # 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}}
-    for EXEC in amdgpu-arch clang-check clang-exdef-mapping clang-import-test clang-offload-* clang-rename clang-scan-deps diagtool hmaptool ld64.lld modularize nxptx-arch wasm-ld; do
-        rm -f ${BINDIR}/bin/${EXEC}${EXTENSION}
-    done
-
-    # Generate version file
-    cd ${WRKDIR}
-    : ${XTCVER:=$(git describe --exact-match --tags 2>/dev/null)}
-    : ${XTCVER:=DEVEL}
-    [ ${BUILD_MINIMAL} -eq 1 ] && XTCVER="${XTCVER}-min"
-    echo "${XTCVER}" > ${BINDIR}/Version
-
-    # Build tarball
-    echo ">>> Creating toolchain archive ..."
-    tar -I 'zstd -19' -cpf xtchain-${XTCVER}-${TARGET_SYSTEM}.tar.zst -C ${BINDIR} .
-}
-
-
-
-# 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#*=}"
-            ;;
-        --minimal)
-            BUILD_MINIMAL=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 [ ${BUILD_JOBS} -eq 0 ]; then
-    unset BUILD_JOBS
-    : ${BUILD_JOBS:=$(sysctl -n hw.ncpu 2>/dev/null)}
-    : ${BUILD_JOBS:=$(nproc 2>/dev/null)}
-    : ${BUILD_JOBS:=1}
-fi
-
-# Create working directories
-mkdir -p ${BINDIR}
-mkdir -p ${SRCDIR}
-
-# Build XTchain tools
-#xtchain_build
-
-# Download and build Wine tools
-#wine_fetch
-#wine_build
-
-if [ ${BUILD_MINIMAL} -eq 0 ]; then
-    # Download and build LLVM
-    #llvm_fetch
-    #llvm_build
-
-    # Download and build CMake
-    #cmake_fetch
-    #cmake_build
-
-    # Download and build Ninja
-    #ninja_fetch
-    #ninja_build
-fi
-
-# Generate tarball archive
-#xtchain_tarball

scripts/clang-target-wrapper

@@ -0,0 +1,42 @@
+#!/bin/sh
+# PROJECT:     XTchain
+# LICENSE:     See the COPYING.md in the top level directory
+# FILE:        scripts/clang-target-wrapper
+# DESCRIPTION: CLANG Wrapper
+# DEVELOPERS:  Martin Storsjo <martin@martin.st>
+#              Rafal Kupiec <belliash@codingworkshop.eu.org>
+
+
+# Set basic variables
+DIR="$(cd $(dirname $0) && pwd)"
+CLANG="$DIR/clang"
+BASENAME="$(basename $0)"
+TARGET="${BASENAME%-*}"
+EXECUTABLE="${BASENAME##*-}"
+DEFAULT_TARGET="x86_64-w64-mingw32"
+ARCH="${TARGET%%-*}"
+
+# Set proper target
+if [ "${TARGET}" = "${BASENAME}" ]; then
+    TARGET="${DEFAULT_TARGET}"
+fi
+
+# Set lang-specific flags
+case ${EXECUTABLE} in
+    "clang++"|"g++"|"c++")
+        FLAGS="$FLAGS --driver-mode=g++"
+        ;;
+    *)
+        FLAGS=""
+        ;;
+esac
+
+# Set compiler flags
+FLAGS="${FLAGS} -target ${TARGET}"
+FLAGS="${FLAGS} -rtlib=compiler-rt"
+FLAGS="${FLAGS} -stdlib=libc++"
+FLAGS="${FLAGS} -fuse-ld=lld"
+FLAGS="${FLAGS} -Qunused-arguments"
+
+# Launch the compiler
+$CLANG $FLAGS "$@"

scripts/dlltool-wrapper

@@ -0,0 +1,42 @@
+#!/bin/sh
+# PROJECT:     XTchain
+# LICENSE:     See the COPYING.md in the top level directory
+# FILE:        scripts/dlltool-wrapper
+# DESCRIPTION: DLLTOOL Wrapper
+# DEVELOPERS:  Martin Storsjo <martin@martin.st>
+#              Rafal Kupiec <belliash@codingworkshop.eu.org>
+
+
+# Set basic variables
+DIR="$(cd $(dirname $0) && pwd)"
+BASENAME="$(basename $0)"
+TARGET="${BASENAME%-*}"
+DEFAULT_TARGET="x86_64-w64-mingw32"
+
+# Update PATH
+export PATH="$DIR":"$PATH"
+
+# Set proper target
+if [ "${TARGET}" = "${BASENAME}" ]; then
+    TARGET="${DEFAULT_TARGET}"
+fi
+
+# Set target machine
+ARCH="${TARGET%%-*}"
+case $ARCH in
+    aarch64)
+        M="arm64"
+        ;;
+    armv7)
+        M="arm"
+        ;;
+    i686)
+        M="i386"
+        ;;
+    x86_64)
+        M="i386:x86-64"
+        ;;
+esac
+
+# Launch the utility
+llvm-dlltool -m ${M} "$@"

scripts/ld-wrapper

@@ -0,0 +1,42 @@
+#!/bin/sh
+# PROJECT:     XTchain
+# LICENSE:     See the COPYING.md in the top level directory
+# FILE:        scripts/ld-wrapper
+# DESCRIPTION: LLD Wrapper
+# DEVELOPERS:  Martin Storsjo <martin@martin.st>
+#              Rafal Kupiec <belliash@codingworkshop.eu.org>
+
+
+# Set basic variables
+DIR="$(cd $(dirname $0) && pwd)"
+BASENAME="$(basename $0)"
+TARGET="${BASENAME%-*}"
+DEFAULT_TARGET="x86_64-w64-mingw32"
+
+# Update PATH
+export PATH="${DIR}":"${PATH}"
+
+# Set proper target
+if [ "${TARGET}" = "${BASENAME}" ]; then
+    TARGET="${DEFAULT_TARGET}"
+fi
+
+# Set target machine
+ARCH="${TARGET%%-*}"
+case ${ARCH} in
+    aarch64)
+        M="arm64pe"
+        ;;
+    armv7)
+        M="thumb2pe"
+        ;;
+    i686)
+        M="i386pe"
+        ;;
+    x86_64)
+        M="i386pep"
+        ;;
+esac
+
+# Launch the linker
+ld.lld -m ${M} "$@"

scripts/objdump-wrapper

@@ -0,0 +1,46 @@
+#!/bin/sh
+# PROJECT:     XTchain
+# LICENSE:     See the COPYING.md in the top level directory
+# FILE:        scripts/objdump-wrapper
+# DESCRIPTION: OBJDUMP Wrapper
+# DEVELOPERS:  Martin Storsjo <martin@martin.st>
+#              Rafal Kupiec <belliash@codingworkshop.eu.org>
+
+
+# Set basic variables
+DIR="$(cd $(dirname $0) && pwd)"
+
+# Update PATH
+export PATH="$DIR":"$PATH"
+
+# Libtool can try to run objdump -f and wants to see certain strings in
+# the output, to accept it being a valid windows (import) library
+if [ "$1" = "-f" ]; then
+    llvm-readobj $2 | while read -r line; do
+        case $line in
+        File:*)
+            file=$(echo $line | awk '{print $2}')
+            ;;
+        Format:*)
+            format=$(echo $line | awk '{print $2}')
+            case $format in
+            COFF-i386)
+                format=pe-i386
+                ;;
+            COFF-x86-64)
+                format=pe-x86-64
+                ;;
+            COFF-ARM*)
+                # This is wrong; modern COFF armv7 isn't pe-arm-wince, and
+                # arm64 definitely isn't, but libtool wants to see this
+                # string (or some of the others) in order to accept it.
+                format=pe-arm-wince
+                ;;
+            esac
+            echo $file: file format $format
+            ;;
+        esac
+    done
+else
+    llvm-objdump "$@"
+fi

scripts/xtclib

@@ -4,20 +4,8 @@
 # FILE:        scripts/xtclib
 # DESCRIPTION: XTchain library
 # DEVELOPERS:  Rafal Kupiec <belliash@codingworkshop.eu.org>
-#              Aiken Harris <harraiken91@gmail.com>
 
 
-# Prints XTChain banner
-banner()
-{
-    local XTC_BANNER="XT Toolchain v${XTCVER} for Linux"
-
-    printf "###############################################################################\n\n"
-    printf "%*s\n\n" $(( (${#XTC_BANNER} + 80) / 2)) "${XTC_BANNER}"
-    printf "###############################################################################\n\n\n"
-}
-export -f banner
-
 # Sets the target architecture
 charch()
 {
@@ -66,67 +54,51 @@ export -f chbuild
 # Prints help
 help()
 {
-    banner
+	version
-    echo "XTChain defines an internal list of commands:"
+	echo "XTChain defines an internal list of commands:"
-    echo " * banner          - prints XTChain banner"
+	echo " * charch [arch]   - sets the target CPU architecture [aarch64/armv7/i686/amd64]"
-    echo " * charch [arch]   - sets the target CPU architecture [aarch64/armv7/i686/amd64]"
+	echo " * chbuild [type]  - sets build type [debug/release]"
-    echo " * chbuild [type]  - sets build type [debug/release]"
+	echo " * help            - prints this message"
-    echo " * help            - prints this message"
+	echo " * version         - prints XTChain and its components version"
-    echo " * version         - prints XTChain and its components version"
+	echo " * xbuild          - builds an application with a Ninja build system"
-    echo " * xbuild          - builds an application with a Ninja build system"
 }
 export -f help
 
 # Displays version banner
 version()
 {
-    local XTCHAIN_EXTTOOLS=false
+    echo "###############################################################################"
-
+    echo "#                        XT Toolchain v${XTCVER} for Linux                        #"
-    if [ ! -f ${XTCDIR}/bin/clang ] || [ "$(which clang)" != "${XTCDIR}/bin/clang" ] || [ $(echo ${XTCVER} | grep "min") ]; then
+    echo "#               by Rafal Kupiec <belliash@codingworkshop.eu.org>              #"
-        XTCHAIN_EXTTOOLS=true
+    echo "###############################################################################"
-        for TOOL in {clang,clang++,cmake,lld-link,ninja}; do
+    echo
-            which ${TOOL} &> /dev/null
+    echo
-            if [ $? -ne 0 ]; then
+    echo "LLVM Compiler Version: $(${XTCDIR}/bin/clang --version | grep 'clang version' | cut -d' ' -f3)"
-                echo "ERROR: You are using minimal version of XTChain and '${TOOL}' has been not found in your system!"
+    echo "LLVM Windres Utility Version: $(${XTCDIR}/bin/i686-w64-mingw32-windres -V | cut -d' ' -f6)"
-                echo "ERROR: Please install all required tools."
+    echo "Mingw IDL Compiler Version: $(${XTCDIR}/bin/i686-w64-mingw32-widl -V | grep 'version' | cut -d' ' -f5)"
-                exit 1
+    echo "Wine Message Compiler Version: $(${XTCDIR}/bin/wmc -V | grep 'version' | cut -d' ' -f5)"
-            fi
+    echo "Wine Resource Compiler Version: $(${XTCDIR}/bin/wrc --version | grep 'version' | cut -d' ' -f5)"
-        done
+    echo
-    fi
-
-    banner
-    echo -en "\nLLVM/Clang Compiler: $(clang --version | grep 'clang version' | cut -d' ' -f3) ($(which clang))"
-    echo -en "\nLLVM/LLD Linker: $(lld-link --version | cut -d' ' -f2) ($(which lld-link))"
-    echo -en "\nWine IDL Compiler: $(widl -V | grep 'version' | cut -d' ' -f5) ($(which widl))"
-    echo -en "\nWine Message Compiler: $(wmc -V | grep 'version' | cut -d' ' -f5) ($(which wmc))"
-    echo -en "\nWine Resource Compiler: $(wrc --version | grep 'version' | cut -d' ' -f5) ($(which wrc))"
-    echo -en "\nXT Resource Compiler: $(windres -V | cut -d' ' -f6) ($(which windres))"
-    echo -en "\nXT SPEC Compiler: $(xtcspecc --help | grep Version | cut -d' ' -f5) ($(which xtcspecc))"
-    echo -en "\nCMake Build System: $(cmake --version | grep 'cmake version' | cut -d' ' -f3) ($(which cmake))"
-    echo -en "\nNinja Build System: $(ninja --version) ($(which ninja))"
-    echo -en "\n\n"
-
     charch ${TARGET:-amd64}
     chbuild ${BUILD_TYPE:-DEBUG}
-
+    echo
-    echo -en "\n\nFor a list of all supported commands, type 'help'"
+    echo
-    echo -en "\n-------------------------------------------------\n\n"
 }
 export -f version
 
 # Builds application (wrapper to Ninja)
 xbuild()
 {
-        if [ ! -f build.arch ]; then
+	if [ ! -f build.arch ]; then
-                ninja "$@"
+		ninja "$@"
-        else
+	else
-                ARCH=$(cat build.arch)
+		ARCH=$(cat build.arch)
-                if [ x"${ARCH}" != x"${TARGET}" ]; then
+		if [ x"${ARCH}" != x"${TARGET}" ]; then
-                        echo "Build is configured for '${ARCH}' while current target set to '${TARGET}'!"
+			echo "Build is configured for '${ARCH}' while current target set to '${TARGET}'!"
-                        echo "Cannot continue until conflict is resolved ..."
+			echo "Cannot continue until conflict is resolved ..."
-                        return 1
+			return 1
-                fi
+		fi
-                ninja "$@"
+		ninja "$@"
-        fi
+	fi
 }
 export -f xbuild