Add missing cmake patch

Reviewed-on: xt-sys/xtchain#6
Reviewed-by: Rafal Kupiec <belliash@noreply.codingworkshop.git>
Co-authored-by: Aiken Harris <harraiken@noreply.codingworkshop.git>
Co-committed-by: Aiken Harris <harraiken@noreply.codingworkshop.git>

README.md

@@ -14,8 +14,8 @@
   <a href="https://github.com/sponsors/xt-sys/">
     <img alt="Sponsors" src="https://img.shields.io/badge/Sponsor-%E2%9D%A4-red?logo=GitHub">
   </a>
-  <a href="https://discord.com/invite/3zgjQDVmAe">
+  <a href="https://discord.com/invite/zBzJ5qMGX7">
-    <img alt="Discord" src="https://img.shields.io/discord/723186294540206100?label=Chat">
+    <img alt="Discord" src="https://img.shields.io/badge/Chat-Join%20Discord-success">
   </a>
 </p>
 

build-linux.sh

@@ -16,19 +16,14 @@ WRKDIR="$(pwd)"
 ARCHS="aarch64 armv7 i686 x86_64"
 GENERIC="generic-w64-mingw32"
 
-# Binutils Settings
-BINUTILSDIR="${SRCDIR}/binutils"
-BINUTILSTAG="binutils-2_41"
-BINUTILSVCS="git://sourceware.org/git/binutils-gdb.git"
-
 # CMake Settings
 CMAKEDIR="${SRCDIR}/cmake"
-CMAKETAG="v3.27.6"
+CMAKETAG="v3.31.3"
 CMAKEVCS="https://gitlab.kitware.com/cmake/cmake.git"
 
 # LLVM Settings
 LLVMDIR="${SRCDIR}/llvm"
-LLVMTAG="llvmorg-17.0.6"
+LLVMTAG="llvmorg-19.1.6"
 LLVMVCS="https://github.com/llvm/llvm-project.git"
 
 # Make Settings
@@ -45,13 +40,13 @@ MINGWVCS="https://github.com/mirror/mingw-w64.git"
 
 # Ninja Settings
 NINJADIR="${SRCDIR}/ninja"
-NINJATAG="v1.11.1"
+NINJATAG="v1.12.1"
 NINJAVCS="https://github.com/ninja-build/ninja.git"
 
 # Wine Settings
 WINEDIR="${SRCDIR}/wine"
-WINETAG="wine-8.17"
+WINETAG="wine-9.8"
-WINEVCS="git://source.winehq.org/git/wine.git"
+WINEVCS="https://github.com/wine-mirror/wine.git"
 
 
 # This function applies a patches to the 3rd party project
@@ -79,50 +74,6 @@ apply_patches()
     fi
 }
 
-# This function compiles and installs GNU BINUTILS
-binutils_build()
-{
-    echo ">>> Building BINUTILS ..."
-    for ARCH in ${ARCHS}; do
-        [ -z ${CLEAN} ] || rm -rf ${BINUTILSDIR}/build-${ARCH}
-        mkdir -p ${BINUTILSDIR}/build-${ARCH}
-        cd ${BINUTILSDIR}/build-${ARCH}
-        case ${ARCH} in
-            "armv7")
-                TARGET="arm"
-                ;;
-            *)
-                TARGET="${ARCH}"
-                ;;
-        esac
-        ../configure \
-            --target=${TARGET}-w64-mingw32 \
-            --disable-binutils \
-            --disable-gdb \
-            --disable-gprof \
-            --disable-ld \
-            --disable-multilib \
-            --disable-nls \
-            --disable-werror \
-            --with-zlib=yes
-        make -j${CORES}
-        cp ${BINUTILSDIR}/build-${ARCH}/gas/as-new ${BINDIR}/bin/${ARCH}-w64-mingw32-gas
-    done
-    cd ${WRKDIR}
-}
-
-# This function downloads GNU BINUTILS from VCS
-binutils_fetch()
-{
-    if [ ! -d ${BINUTILSDIR} ]; then
-        echo ">>> Downloading BINUTILS ..."
-        git clone --depth 1 --branch ${BINUTILSTAG} ${BINUTILSVCS} ${BINUTILSDIR}
-        cd ${BINUTILSDIR}
-        apply_patches ${BINUTILSDIR##*/} ${BINUTILSTAG##*-}
-        cd ${WRKDIR}
-    fi
-}
-
 # This function compiles and installs CMAKE
 cmake_build()
 {
@@ -412,7 +363,7 @@ mingw_build_libs()
 # This function compiles and installs MINGW tools
 mingw_build_tools()
 {
-    for TOOL in gendef genidl genlib genpeimg widl; do
+    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}
@@ -519,7 +470,7 @@ xtchain_build()
         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 xtcspecc; do
+        for EXEC in bin2c exetool windres xtcspecc; do
             if [ ! -e ${BINDIR}/bin/${EXEC} ]; then
                 gcc ${WRKDIR}/tools/${EXEC}.c -o ${BINDIR}/bin/${EXEC}
             fi
@@ -575,12 +526,6 @@ mingw_build_libs
 # Build and install Mingw-W64 tools
 mingw_build_tools
 
-# Download Binutils
-binutils_fetch
-
-# Build and install Binutils
-binutils_build
-
 # Download Wine
 wine_fetch
 

build-windows.sh

@@ -1,699 +0,0 @@
-#!/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"
-
-# Binutils Settings
-BINUTILSDIR="${SRCDIR}/binutils"
-BINUTILSTAG="binutils-2_41"
-BINUTILSVCS="git://sourceware.org/git/binutils-gdb.git"
-
-# CMake Settings
-CMAKEDIR="${SRCDIR}/cmake"
-CMAKETAG="v3.27.6"
-CMAKEVCS="https://gitlab.kitware.com/cmake/cmake.git"
-
-# LLVM Settings
-LLVMDIR="${SRCDIR}/llvm"
-LLVMTAG="llvmorg-17.0.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.11.1"
-NINJAVCS="https://github.com/ninja-build/ninja.git"
-
-# Wine Settings
-WINEDIR="${SRCDIR}/wine"
-WINETAG="wine-8.17"
-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 GNU BINUTILS
-binutils_build_OLD()
-{
-    echo ">>> Building BINUTILS ..."
-    for ARCH in ${ARCHS}; do
-        [ -z ${CLEAN} ] || rm -rf ${BINUTILSDIR}/build-${ARCH}
-        mkdir -p ${BINUTILSDIR}/build-${ARCH}
-        cd ${BINUTILSDIR}/build-${ARCH}
-        case ${ARCH} in
-            "armv7")
-                TARGET="arm"
-                ;;
-            *)
-                TARGET="${ARCH}"
-                ;;
-        esac
-        ../configure \
-            --target=${TARGET}-w64-mingw32 \
-            --disable-binutils \
-            --disable-gdb \
-            --disable-gprof \
-            --disable-ld \
-            --disable-multilib \
-            --disable-nls \
-            --disable-werror \
-            --with-zlib=yes
-        make -j${CORES}
-        cp ${BINUTILSDIR}/build-${ARCH}/gas/as-new ${BINDIR}/bin/${ARCH}-w64-mingw32-gas
-    done
-    cd ${WRKDIR}
-}
-
-# This function downloads GNU BINUTILS from VCS
-binutils_fetch()
-{
-    if [ ! -d ${BINUTILSDIR} ]; then
-        echo ">>> Downloading BINUTILS ..."
-        git clone --depth 1 --branch ${BINUTILSTAG} ${BINUTILSVCS} ${BINUTILSDIR}
-        cd ${BINUTILSDIR}
-        apply_patches ${BINUTILSDIR##*/} ${BINUTILSTAG##*-}
-        cd ${WRKDIR}
-    fi
-}
-
-# This function compiles and installs CMAKE
-cmake_build_OLD()
-{
-    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_OLD()
-{
-    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_OLD()
-{
-    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_OLD()
-{
-    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_OLD()
-{
-    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 install MINGW libraries
-mingw_build_libs_OLD()
-{
-    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_OLD()
-{
-    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 --depth 1 --branch ${MINGWTAG} ${MINGWVCS} ${MINGWDIR}
-        cd ${MINGWDIR}
-        apply_patches ${MINGWDIR##*/} ${MINGWTAG}
-        cd ${WRKDIR}
-    fi
-}
-
-# This function compiles and installs NINJA
-ninja_build_OLD()
-{
-    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_OLD()
-{
-    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_OLD()
-{
-    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 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}/
-}
-
-
-
-
-
-
-
-
-
-# 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 \
-        -DLLVM_HOST_TRIPLE="x86_64-w64-mingw32" \
-        -DCMAKE_C_COMPILER=x86_64-w64-mingw32-gcc \
-        -DCMAKE_CXX_COMPILER=x86_64-w64-mingw32-g++ \
-        -DCMAKE_RC_COMPILER=x86_64-w64-mingw32-windres \
-        -DCMAKE_SYSTEM_NAME=Windows \
-        -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 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 \
-            --disable-dependency-tracking \
-            --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 installs XTCHAIN tools
-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 bin2c exetool xtcspecc; do
-            if [ ! -e ${BINDIR}/bin/${EXEC}.exe ]; then
-                x86_64-w64-mingw32-gcc ${WRKDIR}/tools/${EXEC}.c -o ${BINDIR}/bin/${EXEC}.exe
-            fi
-            cp ${BINDIR}/bin/${EXEC}.exe ${BINDIR}/bin/${ARCH}-w64-mingw32-${EXEC}.exe
-        done
-    done
-}
-
-
-# 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
-exit 1
-
-# 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 Binutils
-binutils_fetch
-
-# Build and install Binutils
-binutils_build
-
-# 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} .

patches/binutils/2_41/001-add-arm-architectures.patch

@@ -1,30 +0,0 @@
-diff --git a/bfd/config.bfd b/bfd/config.bfd
-index bdee53957c0..04fff6e7df4 100644
---- a/bfd/config.bfd
-+++ b/bfd/config.bfd
-@@ -407,6 +407,12 @@ case "${targ}" in
-     targ_selvecs="arm_pe_le_vec arm_pe_be_vec arm_pei_le_vec arm_pei_be_vec"
-     targ_underscore=yes
-     ;;
-+  arm-*-mingw*)
-+    targ_defvec=arm_pe_le_vec
-+    targ_selvecs="arm_pe_le_vec arm_pe_be_vec arm_pei_le_vec arm_pei_be_vec"
-+    targ_underscore=no
-+    targ_cflags="-DARM_COFF_BUGFIX"
-+    ;;
-   arm-*-phoenix*)
-     targ_defvec=arm_elf32_le_vec
-     targ_selvecs=arm_elf32_be_vec
-diff --git a/gas/configure.tgt b/gas/configure.tgt
-index 3429f850d05..fa735da7ce6 100644
---- a/gas/configure.tgt
-+++ b/gas/configure.tgt
-@@ -164,7 +164,7 @@ case ${generic_target} in
-   arm-*-nto*)				fmt=elf ;;
-   arm-wince-pe | arm-*-wince | arm*-*-mingw32ce* | arm*-*-cegcc*)
- 					fmt=coff em=wince-pe ;;
--  arm-*-pe)				fmt=coff em=pe ;;
-+  arm-*-pe | arm-*-mingw*)	fmt=coff em=pe ;;
-   arm-*-fuchsia*)			fmt=elf ;;
-   arm-*-haiku*)				fmt=elf em=haiku ;;
- 

patches/cmake/v3.31.3/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()

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[])
+{
+    char *dir;
+    char *basename;
+    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;
+}