Merge branch 'llvm_toolchain' into master

.build.yml

@@ -0,0 +1,8 @@
+kind: pipeline
+type: exec
+name: XT Toolchain Pipeline
+
+steps:
+- name: Compile XT Toolchain
+  commands:
+    - sh build-linux.sh

README.md

@@ -1,15 +1,29 @@
 ## XT Toolchain
-This is an the XT toolchain based on MinGW-W64. 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. It can be used to build both Windows and XT software, including XT OS.
+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 host only, however it should be possible to build it in MSYS2 as well.
 
-This repository contains 2 branches:
+Benefits of a LLVM based MinGW toolchain are:
- * gnu-toolchain: This is the GCC/Binutils based mingw-w64 toolchain.
+ * Single toolchain targeting all architectures (i686, x86_64, armv7 and aarch64),
- * llvm-toolchain: This is the LLVM/Clang/LLD based mingw-w64 toolchain.
+ * 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
+ * LLVM
+ * Make
+ * Mingw-w64
+ * NASM
+ * Ninja
+ * Wine
+
+This software is based on [LLVM MinGW Toolchain](https://github.com/mstorsjo/llvm-mingw).
 
 ## Licensing
-The XTchain project includes the scripts for building and assembling a toolchain as well as other
+The XTchain project includes the scripts for building and assembling a toolchain as well as wrappers
-scripts and wrappers. These are licensed under the GPLv3 license. It covers only mentioned
+for LLVM tools and environmental shell. These are licensed under the GPLv3 license. It covers only
-components that are provided by XTchain directly. For more information on that, refer to
+mentioned components that are provided by XTchain directly. For more information on that, refer to
 the COPYING.md file. The final pre-built toolchain is covered by the licenses of the individual,
 external projects. The full list of software incorporated into this toolchain is available in the
-README.md file in the corresponding branch.
+README.md file.

build-linux.sh

@@ -0,0 +1,709 @@
+#!/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.23.1"
+CMAKEVCS="https://gitlab.kitware.com/cmake/cmake.git"
+
+# LLVM Settings
+LLVMDIR="${SRCDIR}/llvm"
+LLVMTAG="llvmorg-11.0.0"
+LLVMVCS="https://github.com/llvm/llvm-project.git"
+
+# Make Settings
+MAKEDIR="${SRCDIR}/make"
+MAKETAG="4.3"
+MAKEVCS="git://git.savannah.gnu.org/make"
+
+# Mingw-w64 Settings
+MINGWDIR="${SRCDIR}/mingw-w64"
+MINGWLIB="ucrt"
+MINGWTAG="v8.0.0"
+MINGWNTV="0x601"
+MINGWVCS="https://github.com/mirror/mingw-w64.git"
+
+# NASM Settings
+NASMDIR="${SRCDIR}/nasm"
+NASMTAG="nasm-2.15.05"
+NASMVCS="https://github.com/netwide-assembler/nasm.git"
+
+# Ninja Settings
+NINJADIR="${SRCDIR}/ninja"
+NINJATAG="v1.11.0"
+NINJAVCS="https://github.com/ninja-build/ninja.git"
+
+# Wine Settings
+WINEDIR="${SRCDIR}/wine"
+WINETAG="wine-7.9"
+WINEVCS="git://source.winehq.org/git/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 ${CMAKEVCS} ${CMAKEDIR}
+        cd ${CMAKEDIR}
+        git checkout tags/${CMAKETAG}
+        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 lldb; do
+        if [ ! -e ${UTIL} ]; then
+            ln -sf ../../${UTIL} .
+        fi
+    done
+    mkdir -p ${LLVMDIR}/llvm/build
+    cd ${LLVMDIR}/llvm/build
+    cmake \
+        -DCMAKE_BUILD_TYPE="Release" \
+        -DCMAKE_INSTALL_PREFIX=${BINDIR} \
+        -DLLDB_ENABLE_CURSES=FALSE \
+        -DLLDB_ENABLE_LIBEDIT=FALSE \
+        -DLLDB_ENABLE_LUA=FALSE \
+        -DLLDB_ENABLE_PYTHON=FALSE \
+        -DLLDB_INCLUDE_TESTS=FALSE \
+        -DLLVM_ENABLE_ASSERTIONS=FALSE \
+        -DLLVM_INSTALL_TOOLCHAIN_ONLY=TRUE \
+        -DLLVM_TARGETS_TO_BUILD="$(echo ${LLVM_ARCHS[@]} | tr ' ' ';')" \
+        -DLLVM_TOOLCHAIN_TOOLS="clang;llvm-addr2line;llvm-ar;llvm-as;llvm-cov;llvm-cvtres;llvm-dlltool;llvm-nm;llvm-objdump;llvm-objcopy;llvm-pdbutil;llvm-profdata;llvm-ranlib;llvm-rc;llvm-readobj;llvm-strings;llvm-strip;llvm-symbolizer" \
+        ..
+        make -j${CORES} install/strip
+        cd ${WRKDIR}
+}
+
+# This function compiles and install LIBCXX
+llvm_build_libcxx()
+{
+    echo ">>> Building LLVM libraries (libcxx) ..."
+    for ARCH in ${ARCHS}; do
+        [ -z ${CLEAN} ] || rm -rf ${LLVMDIR}/libcxx/build-${ARCH}
+        mkdir -p ${LLVMDIR}/libcxx/build-${ARCH}
+        cd ${LLVMDIR}/libcxx/build-${ARCH}
+        cmake \
+            -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_CXX_COMPILER="${BINDIR}/bin/${ARCH}-w64-mingw32-clang++" \
+            -DCMAKE_CXX_COMPILER_WORKS=1 \
+            -DCMAKE_CROSSCOMPILING=TRUE \
+            -DCMAKE_RANLIB="${BINDIR}/bin/llvm-ranlib" \
+            -DCMAKE_SHARED_LINKER_FLAGS="-lunwind" \
+            -DCMAKE_SYSTEM_NAME="Windows" \
+            -DLLVM_PATH="${LLVMDIR}/llvm" \
+            -DLIBCXX_CXX_ABI="libcxxabi" \
+            -DLIBCXX_CXX_ABI_INCLUDE_PATHS="../../libcxxabi/include" \
+            -DLIBCXX_CXX_ABI_LIBRARY_PATH="../../libcxxabi/build-${ARCH}/lib" \
+            -DLIBCXX_ENABLE_ABI_LINKER_SCRIPT=FALSE \
+            -DLIBCXX_ENABLE_EXCEPTIONS=TRUE \
+            -DLIBCXX_ENABLE_EXPERIMENTAL_LIBRARY=FALSE \
+            -DLIBCXX_ENABLE_FILESYSTEM=FALSE \
+            -DLIBCXX_ENABLE_MONOTONIC_CLOCK=TRUE \
+            -DLIBCXX_ENABLE_SHARED=TRUE \
+            -DLIBCXX_ENABLE_STATIC=TRUE \
+            -DLIBCXX_ENABLE_STATIC_ABI_LIBRARY=TRUE \
+            -DLIBCXX_ENABLE_THREADS=TRUE \
+            -DLIBCXX_HAS_WIN32_THREAD_API=TRUE \
+            -DLIBCXX_HAVE_CXX_ATOMICS_WITHOUT_LIB=TRUE \
+            -DLIBCXX_INCLUDE_TESTS=FALSE \
+            -DLIBCXX_INSTALL_HEADERS=TRUE \
+            -DLIBCXX_LIBDIR_SUFFIX="" \
+            -DLIBCXX_USE_COMPILER_RT=TRUE \
+            ..
+        make -j${CORES}
+        make install
+        ${BINDIR}/bin/llvm-ar qcsL \
+            ${BINDIR}/${ARCH}-w64-mingw32/lib/libc++.dll.a \
+            ${BINDIR}/${ARCH}-w64-mingw32/lib/libunwind.dll.a
+        ${BINDIR}/bin/llvm-ar qcsL \
+            ${BINDIR}/${ARCH}-w64-mingw32/lib/libc++.a \
+            ${BINDIR}/${ARCH}-w64-mingw32/lib/libunwind.a
+        if [ ! -e ${BINDIR}/${ARCH}-w64-mingw32/bin ]; then
+            mkdir -p ${BINDIR}/${ARCH}-w64-mingw32/bin
+        fi
+        cp lib/libc++.dll ${BINDIR}/${ARCH}-w64-mingw32/bin/
+    done
+    cd ${WRKDIR}
+}
+
+# This function compiles LIBCXXABI
+llvm_build_libcxxabi()
+{
+    echo ">>> Building LLVM libraries (libcxxabi) ..."
+    for ARCH in ${ARCHS}; do
+        [ -z ${CLEAN} ] || rm -rf ${LLVMDIR}/libcxxabi/build-${ARCH}
+        mkdir -p ${LLVMDIR}/libcxxabi/build-${ARCH}
+        cd ${LLVMDIR}/libcxxabi/build-${ARCH}
+        cmake \
+            -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_CROSSCOMPILING=TRUE \
+            -DCMAKE_CXX_COMPILER="${BINDIR}/bin/${ARCH}-w64-mingw32-clang++" \
+            -DCMAKE_CXX_COMPILER_WORKS=1 \
+            -DCMAKE_CXX_FLAGS="-D_LIBCPP_HAS_THREAD_API_WIN32 -D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS" \
+            -DCMAKE_RANLIB="${BINDIR}/bin/llvm-ranlib" \
+            -DCMAKE_SYSTEM_NAME="Windows" \
+            -DLLVM_PATH="${LLVMDIR}/llvm" \
+            -DLIBCXXABI_ENABLE_EXCEPTIONS=TRUE \
+            -DLIBCXXABI_ENABLE_NEW_DELETE_DEFINITIONS=FALSE \
+            -DLIBCXXABI_ENABLE_SHARED=FALSE \
+            -DLIBCXXABI_ENABLE_THREADS=TRUE \
+            -DLIBCXXABI_LIBCXX_INCLUDES="../../libcxx/include" \
+            -DLIBCXXABI_LIBDIR_SUFFIX="" \
+            -DLIBCXXABI_TARGET_TRIPLE="${ARCH}-w64-mingw32" \
+            -DLIBCXXABI_USE_COMPILER_RT=TRUE \
+            ..
+        make -j${CORES}
+    done
+    cd ${WRKDIR}
+}
+
+# This function compiles and installs LIBUNWIND
+llvm_build_libunwind()
+{
+    echo ">>> Building LLVM libraries (libunwind) ..."
+    for ARCH in ${ARCHS}; do
+        [ -z ${CLEAN} ] || rm -rf ${LLVMDIR}/libunwind/build-${ARCH}
+        mkdir -p ${LLVMDIR}/libunwind/build-${ARCH}
+        cd ${LLVMDIR}/libunwind/build-${ARCH}
+        cmake \
+            -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="-Wno-dll-attribute-on-redeclaration" \
+            -DCMAKE_CROSSCOMPILING=TRUE \
+            -DCMAKE_CXX_COMPILER="${BINDIR}/bin/${ARCH}-w64-mingw32-clang++" \
+            -DCMAKE_CXX_COMPILER_WORKS=1 \
+            -DCMAKE_CXX_FLAGS="-Wno-dll-attribute-on-redeclaration" \
+            -DCMAKE_SYSTEM_NAME="Windows" \
+            -DCMAKE_RANLIB="${BINDIR}/bin/llvm-ranlib" \
+            -DLLVM_COMPILER_CHECKED=TRUE \
+            -DLLVM_PATH="${LLVMDIR}/llvm" \
+            -DLIBUNWIND_ENABLE_CROSS_UNWINDING=FALSE \
+            -DLIBUNWIND_ENABLE_SHARED=TRUE \
+            -DLIBUNWIND_ENABLE_STATIC=TRUE \
+            -DLIBUNWIND_ENABLE_THREADS=TRUE \
+            -DLIBUNWIND_USE_COMPILER_RT=TRUE \
+            ..
+        make -j${CORES}
+        make install
+        if [ ! -e ${BINDIR}/${ARCH}-w64-mingw32/bin ]; then
+            mkdir -p ${BINDIR}/${ARCH}-w64-mingw32/bin
+        fi
+        cp lib/libunwind.dll ${BINDIR}/${ARCH}-w64-mingw32/bin/
+    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}
+        case ${ARCH} in
+            "armv7")
+                BARCH="armv7"
+                LARCH="arm"
+                ;;
+            "i686")
+                if [ ! -e ${BINDIR}/i386-w64-mingw32 ]; then
+                    ln -sf i686-w64-mingw32 ${BINDIR}/i386-w64-mingw32
+                fi
+                BARCH="i386"
+                LARCH="i386"
+                ;;
+            *)
+                BARCH="${ARCH}"
+                LARCH="${ARCH}"
+                ;;
+        esac
+        cmake \
+            -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_TARGET="${BARCH}-windows-gnu" \
+            -DCMAKE_C_COMPILER_WORKS=1 \
+            -DCMAKE_CXX_COMPILER="${BINDIR}/bin/${ARCH}-w64-mingw32-clang++" \
+            -DCMAKE_CXX_COMPILER_WORKS=1 \
+            -DCMAKE_RANLIB="${BINDIR}/bin/llvm-ranlib" \
+            -DCMAKE_SYSTEM_NAME="Windows" \
+            -DCOMPILER_RT_DEFAULT_TARGET_ONLY=TRUE \
+            -DCOMPILER_RT_USE_BUILTINS_LIBRARY=TRUE \
+            -DSANITIZER_CXX_ABI=libc++ \
+            ../lib/builtins
+            make -j${CORES}
+            mkdir -p ${BINDIR}/lib/clang/${LLVMTAG#*-}/lib/windows
+            for LIB in lib/windows/libclang_rt.*.a; do
+                cp ${LIB} ${BINDIR}/lib/clang/${LLVMTAG#*-}/lib/windows/$(basename ${LIB} | sed s/${BARCH}/${LARCH}/)
+            done
+    done
+    cd ${WRKDIR}
+}
+
+# This function downloads LLVM from VCS
+llvm_fetch()
+{
+    if [ ! -d ${LLVMDIR} ]; then
+        echo ">>> Downloading LLVM ..."
+        git clone ${LLVMVCS} ${LLVMDIR}
+        cd ${LLVMDIR}
+        git checkout tags/${LLVMTAG}
+        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 ${MAKEVCS} ${MAKEDIR}
+        cd ${MAKEDIR}
+        git checkout tags/${MAKETAG}
+        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} \
+            ${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
+            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 genlib 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 ${MINGWVCS} ${MINGWDIR}
+        cd ${MINGWDIR}
+        git checkout tags/${MINGWTAG}
+        apply_patches ${MINGWDIR##*/} ${MINGWTAG}
+        cd ${WRKDIR}
+    fi
+}
+
+# This function compiles and installs NASM
+nasm_build()
+{
+    cd ${NASMDIR}
+    ./autogen.sh
+    ./configure
+    make -j${CORES}
+    install nasm ndisasm ${BINDIR}/bin/
+    cd ${WRKDIR}
+}
+
+# This function downloads NASM from VCS
+nasm_fetch()
+{
+    if [ ! -d ${NASMDIR} ]; then
+        echo ">>> Downloading NASM ..."
+        git clone ${NASMVCS} ${NASMDIR}
+        cd ${NASMDIR}
+        git checkout tags/${NASMTAG}
+        apply_patches ${NASMDIR##*/} ${NASMTAG##*-}
+        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 ${NINJAVCS} ${NINJADIR}
+        cd ${NINJADIR}
+        git checkout tags/${NINJATAG}
+        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-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 ${WINEVCS} ${WINEDIR}
+        cd ${WINEDIR}
+        git checkout tags/${WINETAG}
+        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 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 if script launched as root
+if [ "$(whoami)" = "root" ]; then
+    echo "This script cannot be run as root!"
+    exit 1
+fi
+
+# Check number of CPU cores available
+: ${CORES:=$(sysctl -n hw.ncpu 2>/dev/null)}
+: ${CORES:=$(nproc 2>/dev/null)}
+: ${CORES:=1}
+
+# Create working directories
+mkdir -p ${BINDIR}
+mkdir -p ${SRCDIR}
+
+# XTchain
+xtchain_build
+
+# Download LLVM
+llvm_fetch
+
+# Build and install LLVM
+llvm_build
+
+# Download NASM
+nasm_fetch
+
+# Build and install NASM
+nasm_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 Mingw-W64 libraries
+mingw_build_libs
+
+# Build and install Mingw-W64 tools
+mingw_build_tools
+
+# Build LLVM libraries
+llvm_build_libunwind
+llvm_build_libcxxabi
+llvm_build_libcxx
+
+# 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/{clang-{check,exdef-mapping,import-test,offload-*,rename,scan-deps},hmaptool,ld64.lld,wasm-ld}
+
+# Save XT Toolchain version
+cd ${WRKDIR}
+: ${XTCVER:=$(git describe --exact-match --tags 2>/dev/null)}
+: ${XTCVER:=DEV}
+echo "${XTCVER}" > ${BINDIR}/Version
+
+# Prepare archive
+echo ">>> Creating toolchain archive ..."
+tar -I 'zstd -19' -cpf xtchain-${XTCVER}-linux.tar.zst -C ${BINDIR} .

patches/cmake/v3.23.1/001-add-xtc-version-suffix.patch

@@ -0,0 +1,13 @@
+diff --git a/Source/CMakeVersion.cmake b/Source/CMakeVersion.cmake
+index 818109f0b7..749377d193 100644
+--- a/Source/CMakeVersion.cmake
++++ b/Source/CMakeVersion.cmake
+@@ -7,7 +7,7 @@ set(CMake_VERSION_IS_DIRTY 0)
+ 
+ # Start with the full version number used in tags.  It has no dev info.
+ set(CMake_VERSION
+-  "${CMake_VERSION_MAJOR}.${CMake_VERSION_MINOR}.${CMake_VERSION_PATCH}")
++  "${CMake_VERSION_MAJOR}.${CMake_VERSION_MINOR}.${CMake_VERSION_PATCH}-XTC")
+ if(DEFINED CMake_VERSION_RC)
+   set(CMake_VERSION "${CMake_VERSION}-rc${CMake_VERSION_RC}")
+ endif()

patches/make/4.3/001-fix-find_in_given_path.patch

@@ -0,0 +1,13 @@
+diff --git a/src/job.c b/src/job.c
+index d6e28d3..f8f6950 100644
+--- a/src/job.c
++++ b/src/job.c
+@@ -2391,7 +2391,7 @@ child_execute_job (struct childbase *child, int good_stdin, char **argv)
+           }
+       }
+ 
+-    cmd = (char *)find_in_given_path (argv[0], p, 0);
++    cmd = (char *)find_in_given_path (argv[0], p, 0, false);
+   }
+ 
+   if (!cmd)

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/xtchain

@@ -0,0 +1,50 @@
+#!/usr/bin/env bash
+# PROJECT:     XTchain
+# LICENSE:     See the COPYING.md in the top level directory
+# FILE:        scripts/xtchain
+# DESCRIPTION: XTchain Entry Script
+# DEVELOPERS:  Rafal Kupiec <belliash@codingworkshop.eu.org>
+
+
+# Check if script launched as root
+if [ "$(whoami)" = "root" ]; then
+    echo "This script cannot be run as root!"
+    exit 1
+fi
+
+# Get the absolute path to the XTchain
+export XTCDIR="$(realpath $(dirname ${0}))"
+
+# Read the XTchain version
+export XTCVER="$(cat ${XTCDIR}/Version)"
+
+# Load the library
+source ${XTCDIR}/lib/xtchain/xtclib
+
+# Set the target architecture
+: ${TARGET:=${1}}
+: ${TARGET:=amd64}
+
+# Save the source directory
+export SRCDIR="${2:-${PWD}}"
+
+# Make sure the compiler flags are clean
+export HOST=
+export CFLAGS=
+export CXXFLAGS=
+export LDFLAGS=
+
+# Update PATH
+export PATH="${XTCDIR}/bin:${PATH}"
+
+# Display banner
+version
+
+# Invoke shell with fancy prompt
+export PFMAT1="\[\033[0;1;97;44m\]"
+export PFMAT2="\[\033[0;34;104m\]"
+export PFMAT3="\[\033[0;1;97;104m\]"
+export PFMAT4="\[\033[0;94;49m\]"
+export PFMAT5="\[\033[1;38;5;74m\]"
+export PROMPT="\n${PFMAT1} XT Toolchain ${PFMAT2}${PFMAT3} \w ${PFMAT4}${PFMAT5} "
+bash --rcfile <(echo 'source ~/.bashrc && export PS1="${PROMPT}" && cd ${SRCDIR}')

scripts/xtclib

@@ -0,0 +1,74 @@
+#!/usr/bin/env bash
+# PROJECT:     XTchain
+# LICENSE:     See the COPYING.md in the top level directory
+# FILE:        scripts/xtclib
+# DESCRIPTION: XTchain library
+# DEVELOPERS:  Rafal Kupiec <belliash@codingworkshop.eu.org>
+
+
+# Sets the target architecture
+charch()
+{
+    if [ "x${1}" == "x" ]; then
+        echo "Syntax: charch [architecture]"
+        return
+    fi
+    case ${1} in
+        "aarch64"|"arm64")
+            export TARGET="aarch64"
+            ;;
+        "arm"|"armv7")
+            export TARGET="armv7"
+            ;;
+        "i386"|"i486"|"i586"|"i686"|"x86")
+            export TARGET="i686"
+            ;;
+        "amd64"|"x64"|"x86_64")
+            export TARGET="amd64"
+            ;;
+        *)
+            export TARGET="UNKNOWN"
+    esac
+    echo "Target Architecture: ${TARGET}"
+}
+export -f charch
+
+# Sets the build type
+chbuild()
+{
+    if [ "x${1}" == "x" ]; then
+        echo "Syntax: chbuild [DEBUG|RELEASE]"
+        return
+    fi
+    case ${1} in
+        [Rr][Ee][Ll][Ee][Aa][Ss][Ee])
+            export BUILD_TYPE="RELEASE"
+            ;;
+        *)
+            export BUILD_TYPE="DEBUG"
+    esac
+    echo "Target build type: ${BUILD_TYPE}"
+}
+export -f chbuild
+
+# Displays version banner
+version()
+{
+    echo "###############################################################################"
+    echo "#                        XT Toolchain v${XTCVER} for Linux                          #"
+    echo "#               by Rafal Kupiec <belliash@codingworkshop.eu.org>              #"
+    echo "###############################################################################"
+    echo
+    echo
+    echo "LLVM Compiler Version: $(${XTCDIR}/bin/clang --version | grep 'clang version' | cut -d' ' -f3)"
+    echo "LLVM Windres Utility Version: $(${XTCDIR}/bin/i686-w64-mingw32-windres -V | cut -d' ' -f6)"
+    echo "Mingw IDL Compiler Version: $(${XTCDIR}/bin/i686-w64-mingw32-widl -V | grep 'version' | cut -d' ' -f5)"
+    echo "Wine Message Compiler Version: $(${XTCDIR}/bin/wmc -V | grep 'version' | cut -d' ' -f5)"
+    echo "Wine Resource Compiler Version: $(${XTCDIR}/bin/wrc --version | grep 'version' | cut -d' ' -f5)"
+    echo
+    charch ${TARGET}
+    chbuild DEBUG
+    echo
+    echo
+}
+export -f version

tools/windres.c

@@ -0,0 +1,558 @@
+/**
+ * PROJECT:     XTchain
+ * LICENSE:     See COPYING.md in the top level directory
+ * FILE:        tools/windres.c
+ * DESCRIPTION: WINDRES compatible interface to LLVM
+ * DEVELOPERS:  Josh de Kock <josh@itanimul.li>
+ *              Martin Storsjo <martin@martin.st>
+ *              Rafal Kupiec <belliash@codingworkshop.eu.org>
+ */
+
+#include "xtchain.h"
+
+#define WINDRES_VERSION "1.0"
+
+#ifndef DEFAULT_TARGET
+#define DEFAULT_TARGET "x86_64-w64-mingw32"
+#endif
+
+#include <stdarg.h>
+
+#define _tspawnvp_escape _spawnvp
+
+#include <sys/wait.h>
+#include <errno.h>
+
+#define _P_WAIT 0
+
+static
+int
+_spawnvp(int mode,
+         const char *filename,
+         const char * const *argv)
+{
+    pid_t pid;
+
+    if(!(pid = fork()))
+    {
+        execvp(filename, (char **) argv);
+        perror(filename);
+        exit(1);
+    }
+
+    int stat = 0;
+
+    if(waitpid(pid, &stat, 0) == -1)
+    {
+        return -1;
+    }
+
+    if(WIFEXITED(stat))
+    {
+        return WEXITSTATUS(stat);
+    }
+    errno = EIO;
+
+    return -1;
+}
+
+static
+const
+char *unescape_cpp(const char *str)
+{
+    char *out = strdup(str);
+    int len = strlen(str);
+    int i, outpos = 0;
+
+    for(i = 0; i < len - 1; i++)
+    {
+        if(str[i] == '\\' && str[i + 1] == '"')
+        {
+            continue;
+        }
+        out[outpos++] = str[i];
+    }
+
+    while(i < len)
+    {
+        out[outpos++] = str[i++];
+    }
+
+    out[outpos++] = '\0';
+
+    return out;
+}
+
+static
+void print_version(void)
+{
+    printf("XTchain windres (GNU windres compatible) %s\n", WINDRES_VERSION);
+    exit(0);
+}
+
+static
+void print_help(void)
+{
+    printf(
+    "usage: llvm-windres <OPTION> [INPUT-FILE] [OUTPUT-FILE]\n"
+    "\n"
+    "LLVM Tool to manipulate Windows resources with a GNU windres interface.\n"
+    "\n"
+    "Options:\n"
+    "  -i, --input <arg>          Name of the input file.\n"
+    "  -o, --output <arg>         Name of the output file.\n"
+    "  -J, --input-format <arg>   Input format to read.\n"
+    "  -O, --output-format <arg>  Output format to generate.\n"
+    "  --preprocessor <arg>       Custom preprocessor command.\n"
+    "  --preprocessor-arg <arg>   Preprocessor command arguments.\n"
+    "  -F, --target <arg>         Target for COFF objects to be compiled for.\n"
+    "  -I, --include-dir <arg>    Include directory to pass to preprocessor and resource compiler.\n"
+    "  -D, --define <arg[=val]>   Define to pass to preprocessor.\n"
+    "  -U, --undefine <arg[=val]> Undefine to pass to preprocessor.\n"
+    "  -c, --codepage <arg>       Default codepage to use when reading an rc file (0x0-0xffff).\n"
+    "  -l, --language <arg>       Specify default language (0x0-0xffff).\n"
+    "      --use-temp-file        Use a temporary file for the preprocessing output.\n"
+    "  -v, --verbose              Enable verbose output.\n"
+    "  -V, --version              Display version.\n"
+    "  -h, --help                 Display this message and exit.\n"
+    "Input Formats:\n"
+    "  rc                         Text Windows Resource\n"
+    "  res                        Binary Windows Resource\n"
+    "Output Formats:\n"
+    "  res                        Binary Windows Resource\n"
+    "  coff                       COFF object\n"
+    "Targets:\n"
+    "  pe-x86-64\n"
+    "  pei-x86-64\n"
+    "  pe-i386\n"
+    "  pei-i386\n");
+    exit(0);
+}
+
+static
+void error(const char *basename,
+           const char *fmt,
+           ...)
+{
+    fprintf(stderr, _T(TS": error: "), basename);
+    va_list ap;
+    va_start(ap, fmt);
+    vfprintf(stderr, fmt, ap);
+    fprintf(stderr, _T("\n"));
+    va_end(ap);
+    exit(1);
+}
+
+static
+void print_argv(const char **exec_argv)
+{
+    while(*exec_argv)
+    {
+        fprintf(stderr, _T(TS" "), *exec_argv);
+        exec_argv++;
+    }
+
+    fprintf(stderr, _T("\n"));
+}
+
+static
+void check_num_args(int arg,
+                    int max_arg)
+{
+    if(arg > max_arg)
+    {
+        fprintf(stderr, "Too many options added\n");
+        abort();
+    }
+}
+
+int main(int argc,
+         char* argv[])
+{
+    const char *dir;
+    const char *basename;
+    const char *target;
+
+    split_argv(argv[0], &dir, &basename, &target, NULL);
+
+    if (!target)
+        target = _T(DEFAULT_TARGET);
+
+    const char *bfd_target = NULL;
+    const char *input = _T("-");
+    const char *output = _T("/dev/stdout");
+    const char *input_format = _T("rc");
+    const char *output_format = _T("coff");
+    const char **includes = malloc(argc * sizeof(*includes));
+    int nb_includes = 0;
+    const char *codepage = _T("1252");
+    const char *language = NULL;
+    const char **cpp_options = malloc(argc * sizeof(*cpp_options));
+    int nb_cpp_options = 0;
+    int verbose = 0;
+
+#define _tcslen_const(a) (sizeof(a)/sizeof(char) - 1)
+
+#define _tcsstart(a, b) !strncmp(a, b, _tcslen_const(b))
+
+#define IF_MATCH_EITHER(short, long) \
+    if(!strcmp(argv[i], _T(short)) || !strcmp(argv[i], _T(long)))
+
+#define IF_MATCH_THREE(first, second, third) \
+    if(!strcmp(argv[i], _T(first)) || !strcmp(argv[i], _T(second)) || !strcmp(argv[i], _T(third)))
+
+#define OPTION(short, long, var) \
+    if(_tcsstart(argv[i], _T(short)) && argv[i][_tcslen_const(_T(short))]) { \
+        var = argv[i] + _tcslen_const(_T(short)); \
+    } else if(_tcsstart(argv[i], _T(long "="))) { \
+        var = strchr(argv[i], '=') + 1; \
+    } else IF_MATCH_EITHER(short, long) { \
+        if(i + 1 < argc) \
+            var = argv[++i]; \
+        else \
+            error(basename, _T(TS" missing argument"), argv[i]); \
+    }
+
+#define SEPARATE_ARG(var) do { \
+        if(i + 1 < argc) \
+            var = argv[++i]; \
+        else \
+            error(basename, _T(TS" missing argument"), argv[i]); \
+    } while (0)
+
+#define SEPARATE_ARG_PREFIX(var, prefix) do { \
+        if(i + 1 < argc) \
+            var = concat(_T(prefix), argv[++i]); \
+        else \
+            error(basename, _T(TS" missing argument"), argv[i]); \
+    } while (0)
+
+    for(int i = 1; i < argc; i++)
+    {
+        OPTION("-i", "--input", input)
+        else OPTION("-o", "--output", output)
+        else OPTION("-J", "--input-format", input_format)
+        else OPTION("-O", "--output-format", output_format)
+        else OPTION("-F", "--target", bfd_target)
+        else IF_MATCH_THREE("-I", "--include-dir", "--include") {
+            SEPARATE_ARG(includes[nb_includes++]);
+        }
+        else if(_tcsstart(argv[i], _T("--include-dir=")) ||
+                _tcsstart(argv[i], _T("--include=")))
+        {
+            includes[nb_includes++] = strchr(argv[i], '=') + 1;
+        }
+        else if(_tcsstart(argv[i], _T("-I")))
+        {
+            includes[nb_includes++] = argv[i] + 2;
+        }
+        else OPTION("-c", "--codepage", codepage)
+        else OPTION("-l", "--language", language)
+        else if(!strcmp(argv[i], _T("--preprocessor")))
+        {
+            error(basename, _T("ENOSYS"));
+        }
+        else if(_tcsstart(argv[i], _T("--preprocessor-arg=")))
+        {
+            cpp_options[nb_cpp_options++] = strchr(argv[i], '=') + 1;
+        }
+        else if(!strcmp(argv[i], _T("--preprocessor-arg")))
+        {
+            SEPARATE_ARG(cpp_options[nb_cpp_options++]);
+        }
+        else IF_MATCH_EITHER("-D", "--define")
+        {
+            SEPARATE_ARG_PREFIX(cpp_options[nb_cpp_options++], "-D");
+        }
+        else if(_tcsstart(argv[i], _T("-D")))
+        {
+            cpp_options[nb_cpp_options++] = argv[i];
+        }
+        else IF_MATCH_EITHER("-U", "--undefine")
+        {
+            SEPARATE_ARG_PREFIX(cpp_options[nb_cpp_options++], "-U");
+        }
+        else if(_tcsstart(argv[i], _T("-U")))
+        {
+            cpp_options[nb_cpp_options++] = argv[i];
+        }
+        else IF_MATCH_EITHER("-v", "--verbose")
+        {
+            verbose = 1;
+        }
+        else IF_MATCH_EITHER("-V", "--version")
+        {
+            print_version();
+        }
+        else IF_MATCH_EITHER("-h", "--help")
+        {
+            print_help();
+        }
+        else if(!strcmp(argv[i], _T("--use-temp-file")))
+        {
+            // No-op, we use a temp file by default.
+        }
+        else if(_tcsstart(argv[i], _T("-")))
+        {
+            error(basename, _T("unrecognized option: `"TS"'"), argv[i]);
+        }
+        else
+        {
+            if(!strcmp(input, _T("-")))
+            {
+                input = argv[i];
+            }
+            else if(!strcmp(output, _T("/dev/stdout")))
+            {
+                output = argv[i];
+            }
+            else
+            {
+                error(basename, _T("rip: `"TS"'"), argv[i]);
+            }
+        }
+    }
+
+    if(bfd_target)
+    {
+        if(!strcmp(bfd_target, _T("pe-x86-64")) ||
+           !strcmp(bfd_target, _T("pei-x86-64")))
+        {
+           target = _T("x86_64-w64-mingw32");
+        }
+        else if(!strcmp(bfd_target, _T("pe-i386")) ||
+                !strcmp(bfd_target, _T("pei-i386")))
+        {
+            target = _T("i686-w64-mingw32");
+        }
+        else
+        {
+            error(basename, _T("unsupported target: `"TS"'"), bfd_target);
+        }
+    }
+
+    char *arch = strdup(target);
+    char *dash = strchr(arch, '-');
+    if(dash)
+    {
+        *dash = '\0';
+    }
+
+    const char *machine = _T("unknown");
+
+    if(!strcmp(arch, _T("i686")))
+    {
+        machine = _T("X86");
+    }
+    else if(!strcmp(arch, _T("x86_64")))
+    {
+        machine = _T("X64");
+    }
+    else if(!strcmp(arch, _T("armv7")))
+    {
+        machine = _T("ARM");
+    }
+    else if(!strcmp(arch, _T("aarch64")))
+    {
+        machine = _T("ARM64");
+    }
+
+    const char *CC = concat(target, _T("-clang"));
+    const char **rc_options = malloc(2 * argc * sizeof(*cpp_options));
+    int nb_rc_options = 0;
+
+    for(int i = 0; i < nb_includes; i++)
+    {
+        cpp_options[nb_cpp_options++] = concat(_T("-I"), includes[i]);
+        rc_options[nb_rc_options++] = _T("-I");
+        rc_options[nb_rc_options++] = includes[i];
+    }
+
+    for(int i = 0; i < nb_cpp_options; i++)
+    {
+        cpp_options[i] = unescape_cpp(cpp_options[i]);
+    }
+
+    const char *preproc_rc = concat(output, _T(".preproc.rc"));
+    const char *res = concat(output, _T(".out.res"));
+
+    char *inputdir = strdup(input);
+    {
+        char *sep = _tcsrchrs(inputdir, '/', '\\');
+        if(sep)
+        {
+            *sep = '\0';
+        }
+        else
+        {
+            inputdir = strdup(_T("."));
+        }
+    }
+
+    int max_arg = 2 * argc + 20;
+    const char **exec_argv = malloc((max_arg + 1) * sizeof(*exec_argv));
+    int arg = 0;
+
+    if(!_tcsicmp(input_format, _T("rc")))
+    {
+        exec_argv[arg++] = concat(dir, CC);
+        exec_argv[arg++] = _T("-E");
+
+        for(int i = 0; i < nb_cpp_options; i++)
+        {
+            exec_argv[arg++] = cpp_options[i];
+        }
+
+        exec_argv[arg++] = _T("-xc");
+        exec_argv[arg++] = _T("-DRC_INVOKED=1");
+        exec_argv[arg++] = input;
+        exec_argv[arg++] = _T("-o");
+        exec_argv[arg++] = preproc_rc;
+        exec_argv[arg] = NULL;
+
+        check_num_args(arg, max_arg);
+
+        if(verbose)
+        {
+            print_argv(exec_argv);
+        }
+
+        int ret = _tspawnvp_escape(_P_WAIT, exec_argv[0], exec_argv);
+
+        if(ret == -1)
+        {
+            perror(exec_argv[0]);
+            return 1;
+        }
+
+        if(ret != 0)
+        {
+            error(basename, _T("preprocessor failed"));
+            return ret;
+        }
+
+        arg = 0;
+        exec_argv[arg++] = concat(dir, _T("llvm-rc"));
+
+        for(int i = 0; i < nb_rc_options; i++)
+        {
+            exec_argv[arg++] = rc_options[i];
+        }
+
+        exec_argv[arg++] = _T("-I");
+        exec_argv[arg++] = inputdir;
+        exec_argv[arg++] = preproc_rc;
+        exec_argv[arg++] = _T("-c");
+        exec_argv[arg++] = codepage;
+
+        if(language)
+        {
+            exec_argv[arg++] = _T("-l");
+            exec_argv[arg++] = language;
+        }
+
+        exec_argv[arg++] = _T("-fo");
+
+        if(!_tcsicmp(output_format, _T("res")))
+        {
+            exec_argv[arg++] = output;
+        }
+        else
+        {
+            exec_argv[arg++] = res;
+        }
+
+        exec_argv[arg] = NULL;
+        check_num_args(arg, max_arg);
+
+        if(verbose)
+        {
+            print_argv(exec_argv);
+        }
+
+        ret = _tspawnvp_escape(_P_WAIT, exec_argv[0], exec_argv);
+
+        if(ret == -1)
+        {
+            perror(exec_argv[0]);
+            return 1;
+        }
+
+        if(ret != 0)
+        {
+            error(basename, _T("llvm-rc failed"));
+            if(!verbose)
+            {
+                unlink(preproc_rc);
+            }
+            return ret;
+        }
+
+        if(!_tcsicmp(output_format, _T("res")))
+        {
+            // All done
+        }
+        else if(!_tcsicmp(output_format, _T("coff")))
+        {
+            arg = 0;
+            exec_argv[arg++] = concat(dir, _T("llvm-cvtres"));
+            exec_argv[arg++] = res;
+            exec_argv[arg++] = concat(_T("-machine:"), machine);
+            exec_argv[arg++] = concat(_T("-out:"), output);
+            exec_argv[arg] = NULL;
+
+            check_num_args(arg, max_arg);
+            if(verbose)
+            {
+                print_argv(exec_argv);
+            }
+
+            int ret = _tspawnvp_escape(_P_WAIT, exec_argv[0], exec_argv);
+            if(ret == -1)
+            {
+                perror(exec_argv[0]);
+                return 1;
+            }
+
+            if(!verbose)
+            {
+                unlink(preproc_rc);
+                unlink(res);
+            }
+
+            return ret;
+        } else {
+            error(basename, _T("invalid output format: `"TS"'"), output_format);
+        }
+    }
+    else if(!_tcsicmp(input_format, _T("res")))
+    {
+        exec_argv[arg++] = concat(dir, _T("llvm-cvtres"));
+        exec_argv[arg++] = input;
+        exec_argv[arg++] = concat(_T("-machine:"), machine);
+        exec_argv[arg++] = concat(_T("-out:"), output);
+        exec_argv[arg] = NULL;
+
+        check_num_args(arg, max_arg);
+
+        if(verbose)
+        {
+            print_argv(exec_argv);
+        }
+
+        int ret = _tspawnvp_escape(_P_WAIT, exec_argv[0], exec_argv);
+        if(ret == -1)
+        {
+            perror(exec_argv[0]);
+            return 1;
+        }
+
+        return ret;
+    }
+    else
+    {
+        error(basename, _T("invalid input format: `"TS"'"), input_format);
+    }
+
+    return 0;
+}

tools/xtchain.h

@@ -0,0 +1,162 @@
+/**
+ * PROJECT:     XTchain
+ * LICENSE:     See COPYING.md in the top level directory
+ * FILE:        tools/xtchain.h
+ * DESCRIPTION: Common header for XTchain tools
+ * DEVELOPERS:  Martin Storsjo <martin@martin.st>
+ *              Rafal Kupiec <belliash@codingworkshop.eu.org>
+ */
+
+#ifdef UNICODE
+#define _UNICODE
+#endif
+
+#include <ctype.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#define _T(x) x
+
+#ifdef _UNICODE
+#define TS "%ls"
+#else
+#define TS "%s"
+#endif
+
+static
+inline
+int
+_tcsicmp(const char *a,
+         const char *b)
+{
+    while(*a && tolower(*a) == tolower(*b))
+    {
+        a++;
+        b++;
+    }
+
+    return *a - *b;
+}
+
+static
+inline
+char *
+concat(const char *prefix,
+       const char *suffix)
+{
+    int prefixlen = strlen(prefix);
+    int suffixlen = strlen(suffix);
+
+    char *buf = malloc((prefixlen + suffixlen + 1) * sizeof(*buf));
+
+    strcpy(buf, prefix);
+    strcpy(buf + prefixlen, suffix);
+
+    return buf;
+}
+
+static
+inline
+char *
+_tcsrchrs(const char *str,
+          char char1,
+          char char2)
+{
+    char *ptr1 = strrchr(str, char1);
+    char *ptr2 = strrchr(str, char2);
+
+    if(!ptr1)
+    {
+        return ptr2;
+    }
+
+    if(!ptr2)
+    {
+        return ptr1;
+    }
+
+    if(ptr1 < ptr2)
+    {
+        return ptr2;
+    }
+
+    return ptr1;
+}
+
+static
+inline
+void
+split_argv(const char *argv0,
+           char **dir_ptr,
+           char **basename_ptr,
+           char **target_ptr,
+           char **exe_ptr)
+{
+    const char *sep = _tcsrchrs(argv0, '/', '\\');
+    char *dir = strdup(_T(""));
+    const char *basename = argv0;
+
+    if(sep)
+    {
+        dir = strdup(argv0);
+        dir[sep + 1 - argv0] = '\0';
+        basename = sep + 1;
+    }
+
+    basename = strdup(basename);
+    char *period = strchr(basename, '.');
+
+    if(period)
+    {
+        *period = '\0';
+    }
+
+    char *target = strdup(basename);
+    char *dash = strrchr(target, '-');
+    const char *exe = basename;
+
+    if(dash)
+    {
+        *dash = '\0';
+        exe = dash + 1;
+    }
+    else
+    {
+        target = NULL;
+    }
+
+    if(dir_ptr)
+    {
+        *dir_ptr = dir;
+    }
+
+    if(basename_ptr)
+    {
+        *basename_ptr = basename;
+    }
+
+    if(target_ptr)
+    {
+        *target_ptr = target;
+    }
+
+    if(exe_ptr)
+    {
+        *exe_ptr = exe;
+    }
+}
+
+static
+inline
+int
+run_final(const char *executable,
+          const char *const *argv)
+{
+    execvp(executable, (char **) argv);
+    perror(executable);
+
+    return 1;
+}