# Maintainer: Martell Malone <martellmalone@gmail.com>
# Maintainer: Alexey Pavlov <alexpux@gmail.com>
# Contributor: Ray Donnelly <mingw.android@gmail.com>
# Contributor: Mateusz Mikuła <mati865@gmail.com>
# Contributor: wirx6 <wirx654@gmail.com>
# Contributor: Yuui Tanabe <yuuitanabe@163.com>
# Contributor: Oscar Fuentes <ofv@wanadoo.es>
# Contributor: Adrian Pop <adrian.pop@liu.se>

if [[ $MINGW_PACKAGE_PREFIX == *-clang-* ]]; then
  _clangprefix=1
  _compiler=clang
  if [[ ${CARCH} != i686 ]]; then
    _pgo=1
  fi
else
  _compiler=clang
fi

_realname=clang
pkgbase=mingw-w64-${_realname}
pkgname=("${MINGW_PACKAGE_PREFIX}-${_realname}"
         "${MINGW_PACKAGE_PREFIX}-clang-libs"
         "${MINGW_PACKAGE_PREFIX}-clang-analyzer"
         "${MINGW_PACKAGE_PREFIX}-clang-tools-extra"
         "${MINGW_PACKAGE_PREFIX}-compiler-rt"
         $( (( _clangprefix )) && echo "${MINGW_PACKAGE_PREFIX}-gcc-compat" )
         "${MINGW_PACKAGE_PREFIX}-lld"
         "${MINGW_PACKAGE_PREFIX}-llvm"
         "${MINGW_PACKAGE_PREFIX}-llvm-libs")
_version=17.0.6
_rc=
_tag=llvmorg-${_version}${_rc}
pkgver=${_version}${_rc/-/}
pkgrel=7
pkgdesc="C language family frontend for LLVM (mingw-w64)"
arch=('any')
mingw_arch=('mingw32' 'mingw64' 'ucrt64' 'clang64' 'clang32' 'clangarm64')
url="https://llvm.org/"
license=("spdx:Apache-2.0 WITH LLVM-exception")
groups=($( (( _clangprefix )) && echo "${MINGW_PACKAGE_PREFIX}-toolchain"))
makedepends=("${MINGW_PACKAGE_PREFIX}-cmake"
             "${MINGW_PACKAGE_PREFIX}-z3"
             "${MINGW_PACKAGE_PREFIX}-libffi"
             "${MINGW_PACKAGE_PREFIX}-ninja"
             "${MINGW_PACKAGE_PREFIX}-pkgconf"
             "${MINGW_PACKAGE_PREFIX}-python-sphinx"
             "${MINGW_PACKAGE_PREFIX}-python"
             "${MINGW_PACKAGE_PREFIX}-libunwind"
             $([[ "$_compiler" == "clang" ]] && echo \
               "${MINGW_PACKAGE_PREFIX}-clang" || echo \
               "${MINGW_PACKAGE_PREFIX}-gcc")
             $((( _clangprefix )) && echo \
               "${MINGW_PACKAGE_PREFIX}-compiler-rt" \
               "${MINGW_PACKAGE_PREFIX}-libc++")
             "git"
             )
_url=https://github.com/llvm/llvm-project/releases/download/${_tag}
source=("${_url}/llvm-${pkgver}.src.tar.xz"{,.sig}
        "${_url}/clang-${pkgver}.src.tar.xz"{,.sig}
        "${_url}/clang-tools-extra-${pkgver}.src.tar.xz"{,.sig}
        "${_url}/compiler-rt-${pkgver}.src.tar.xz"{,.sig}
        "${_url}/lld-${pkgver}.src.tar.xz"{,.sig}
        "${_url}/cmake-${pkgver}.src.tar.xz"{,.sig}
        "${_url}/third-party-${pkgver}.src.tar.xz"{,.sig}
        "0001-Fix-GetHostTriple-for-mingw-w64-in-msys.patch"
        "0002-Fix-Findzstd-on-MINGW.patch"
        "0003-add-pthread-as-system-lib-for-mingw.patch"
        "0004-enable-emutls-for-mingw.patch"
        "0101-link-pthread-with-mingw.patch"
        "0102-Rename-flang-new-flang-experimental-exec-to-flang.patch"
        "0303-ignore-new-bfd-options.patch"
        # Objective C: Use C++ mode unconditionally on MinGW
        "1d5106d69cf475215887c42834158d710e586f1b.patch"
        # Objective C: Mark instance variable offsets with DllExport/DllImport when targetting COFF
        "b81ba52e15d95c3353489d4ce2f61c3771714c28.patch"
        # Objective C: Work around type encodings which include '=' causing lld to fail
        "c65ae76326040369bcd3a85678ab76e402140036.patch"
        "10b78cc8cea65e7e77d227af4027963f39402724.patch"
        "1709e8c656de69f6d823a3ae6773bf815e373909.patch"
        "9e3d915d8ebf86e24c9ff58766be8e7c6aa7b0c0.patch")
# Some patch notes :)
#0001-0099 -> llvm
#0101-0199 -> clang
#0201-0299 -> rt
#0301-0399 -> lld
#0401-0499 -> clang-tools-extra
sha256sums=('b638167da139126ca11917b6880207cc6e8f9d1cbb1a48d87d017f697ef78188'
            'SKIP'
            'a78f668a726ae1d3d9a7179996d97b12b90fb76ab9442a43110b972ff7ad9029'
            'SKIP'
            'aa774642415d338d7b77a66fcbad6fd1f77f382dabcb67422a6230614eff1ab9'
            'SKIP'
            '11b8d09dcf92a0f91c5c82defb5ad9ff4acf5cf073a80c317204baa922d136b4'
            'SKIP'
            '4ac13125616dc44905b85820aa403d27ec1226329b7f674daeb5f5584c6f0b22'
            'SKIP'
            '807f069c54dc20cb47b21c1f6acafdd9c649f3ae015609040d6182cab01140f4'
            'SKIP'
            '3054d0a9c9375dab1a4539cc2cc45ab340341c5d71475f9599ba7752e222947b'
            'SKIP'
            'eb03df53671df6627768141b3aaa76abe176a14e5e47911c97bec544387c4aff'
            '70930739511f0934bafad518cd02acbccd03915ca4c6bec4b272eb5bcec33e1e'
            '7f0c64cd87b61e894be632f180ae5291e1aa9f1d9d382608f659067eeeda7146'
            '5f86e542dd1ec92b2fe06ee59061c3e23512df7bafabe82206f2b7d80b81836b'
            '715cb8862753854b2d9256e0b70003e2d1f57083d83eaeaf5a095fc72b8a4e26'
            '2770cadf8ccf6b31aece6aee8f76dceb71e6e9d01fdf3be74c3743480ce34899'
            'de631ab199a6fe83b3f695350bffaad067a2f95fc2ba9c8fe57dc85665d3653c'
            '65b50e18793686ec6620896155797ad2cc93d00f8a458c735a524a8c73d67980'
            'b23427a58ddf2f8fd16605ab9cc89d1233a409ee0a208f6d8d1a34204f716426'
            'a92baac68b7e7deb81edf197fee4e2ffb03a71488a05e7145bdd12f51d443d5a'
            'b7f484b02c79dfaac81243b085dd4196a7f46226ac64e0ba1690c41391a4a157'
            '0f3dcb8b2d5f90f8ff2e77896d3b0ef6c87af8214e679917898e35dd678daef5'
            'e745aa71c903445c86639507256a5ca775e69b569b58f2ff48d6047703cfc81a')
validpgpkeys=('B6C8F98282B944E3B0D5C2530FC3042E345AD05D'  # Hans Wennborg, Google.
              '474E22316ABF4785A88C6E8EA2C794A986419D8A'  # Tom Stellard
              'D574BD5D1D0E98895E3BF90044F2485E45D59042') # Tobias Hieta
noextract=(clang-${pkgver}.src.tar.xz)

apply_patch_with_msg() {
  for _patch in "$@"
  do
    msg2 "Applying ${_patch}"
    patch -Nbp1 -i "${srcdir}/${_patch}"
  done
}

revert_patch_with_msg() {
  for _patch in "$@"
  do
    msg2 "Reverting ${_patch}"
    patch -Rbp1 -i "${srcdir}/${_patch}"
  done
}

prepare() {
  cd "${srcdir}"
  plain "Extracting clang-${pkgver}.src.tar.xz due to symlink(s) without pre-existing target(s)"
  tar -xJf ${srcdir}/clang-${pkgver}.src.tar.xz -C ${srcdir} || true

  # Rename Directories
  for pkg in llvm clang clang-tools-extra compiler-rt lld cmake third-party; do
    mv ${pkg}-$pkgver.src ${pkg}
  done

  # Backports for llvm-windres, for improved compat with binutils 3.26+
  # https://github.com/msys2/MINGW-packages/pull/19157#issuecomment-1825285063
  apply_patch_with_msg \
    "10b78cc8cea65e7e77d227af4027963f39402724.patch" \
    "1709e8c656de69f6d823a3ae6773bf815e373909.patch" \
    "9e3d915d8ebf86e24c9ff58766be8e7c6aa7b0c0.patch"

  # Objective C patches
  apply_patch_with_msg \
    "1d5106d69cf475215887c42834158d710e586f1b.patch" \
    "b81ba52e15d95c3353489d4ce2f61c3771714c28.patch" \
    "c65ae76326040369bcd3a85678ab76e402140036.patch"

  # Patch llvm
  cd "${srcdir}/llvm"
  apply_patch_with_msg \
    "0001-Fix-GetHostTriple-for-mingw-w64-in-msys.patch" \
    "0002-Fix-Findzstd-on-MINGW.patch"

  if (( ! _clangprefix )); then
    apply_patch_with_msg \
      "0003-add-pthread-as-system-lib-for-mingw.patch" \
      "0004-enable-emutls-for-mingw.patch"
  fi

  # Patch clang
  cd "${srcdir}/clang"

  if (( ! _clangprefix )); then
    apply_patch_with_msg \
      "0101-link-pthread-with-mingw.patch"
  fi
  # https://reviews.llvm.org/D143592
  apply_patch_with_msg \
    "0102-Rename-flang-new-flang-experimental-exec-to-flang.patch"

  # Patch lld
  cd "${srcdir}/lld"

  apply_patch_with_msg \
    "0303-ignore-new-bfd-options.patch"

  # Patch clang-tools-extra
  cd "${srcdir}/clang-tools-extra"
}

build() {
  cd "${srcdir}"

  case "${CARCH}" in
    i?86|armv7)
      # lld needs all the address space it can get.
      LDFLAGS+=" -Wl,--large-address-aware"
      ;;
  esac

  local -a platform_config
  local -a common_cmake_args

  # Include location of libffi headers in CPPFLAGS
  FFI_INCLUDE_DIR="$(pkg-config --cflags libffi)"
  FFI_INCLUDE_DIR=$(echo $FFI_INCLUDE_DIR | sed 's|-I||g')

  if check_option "debug" "y"; then
    common_cmake_args+=(-DCMAKE_BUILD_TYPE=Debug
                        -DLLVM_ENABLE_ASSERTIONS=ON)
    VERBOSE="VERBOSE=1"
  else
    common_cmake_args+=(-DCMAKE_BUILD_TYPE=Release
                        -DLLVM_ENABLE_ASSERTIONS=OFF
                        -DLLVM_ENABLE_DUMP=ON)
  fi
  common_cmake_args+=(-Wno-dev
    -DCMAKE_INSTALL_PREFIX=${MINGW_PREFIX}
    -DCMAKE_SYSTEM_IGNORE_PATH=/usr/lib
    -DLLVM_HOST_TRIPLE="${CARCH}-w64-windows-gnu"
    -DPython3_EXECUTABLE=${MINGW_PREFIX}/bin/python.exe
    -DPython3_FIND_REGISTRY=NEVER
    -DPython3_ROOT_DIR=${MINGW_PREFIX}
    -DFFI_INCLUDE_DIR="${FFI_INCLUDE_DIR}"
    -DLLVM_ENABLE_FFI=ON
    -DLLVM_INCLUDE_EXAMPLES=OFF
    -DLLVM_INCLUDE_BENCHMARKS=OFF
    -DLLVM_INCLUDE_TESTS=OFF
    -DLLVM_BUILD_LLVM_DYLIB=ON
    -DLLVM_BUILD_STATIC=OFF
    -DLLVM_LINK_LLVM_DYLIB=ON
    -DLLVM_ENABLE_THREADS=ON)

  if [ "${_compiler}" == "clang" ]; then
    export CC='clang'
    export CXX='clang++'
  fi

  if (( _pgo )); then
    # Build Clang with instrumentation.
    mkdir -p "${srcdir}"/build-${MSYSTEM}-instrument && cd "${srcdir}"/build-${MSYSTEM}-instrument
    ${MINGW_PREFIX}/bin/cmake.exe \
      -GNinja \
      -DDEFAULT_SYSROOT=${MINGW_PREFIX} \
      -DLLVM_ENABLE_PROJECTS="clang;compiler-rt" \
      -DLLVM_BUILD_INSTRUMENTED=IR \
      -DLLVM_TARGETS_TO_BUILD=Native \
      -DLLVM_NATIVE_TOOL_DIR=${MINGW_PREFIX}/bin \
      -DCLANG_DEFAULT_RTLIB=compiler-rt \
      -DCLANG_DEFAULT_UNWINDLIB=libunwind \
      -DCLANG_DEFAULT_CXX_STDLIB=libc++ \
      -DCOMPILER_RT_BUILD_SANITIZERS=OFF \
      -DCOMPILER_RT_BUILD_PROFILE=OFF \
      "${common_cmake_args[@]}" \
      ../llvm
    ${MINGW_PREFIX}/bin/cmake --build . --target compiler-rt --target clang
    # Use that to build part of llvm to generate a profile.
    mkdir -p "${srcdir}"/build-${MSYSTEM}-train && cd "${srcdir}"/build-${MSYSTEM}-train
    ${MINGW_PREFIX}/bin/cmake.exe \
      -GNinja \
      -DCMAKE_C_COMPILER="${srcdir}"/build-${MSYSTEM}-instrument/bin/clang.exe \
      -DCMAKE_CXX_COMPILER="${srcdir}"/build-${MSYSTEM}-instrument/bin/clang++.exe \
      -DLLVM_ENABLE_PROJECTS="clang" \
      -DLLVM_TARGETS_TO_BUILD=Native \
      -DLLVM_NATIVE_TOOL_DIR=${MINGW_PREFIX}/bin \
      "${common_cmake_args[@]}" \
      ../llvm
    # Drop profiles generated from running cmake; those are not representative.
    rm "${srcdir}"/build-${MSYSTEM}-instrument/profiles/*.profraw
    ${MINGW_PREFIX}/bin/cmake --build . --target clangSema
    # Save Profile data
    ${MINGW_PREFIX}/bin/llvm-profdata merge -output="${srcdir}"/profdata "${srcdir}"/build-${MSYSTEM}-instrument/profiles/*.profraw
    common_cmake_args+=("-DLLVM_PROFDATA_FILE="${srcdir}"/profdata")
  fi

  if (( _clangprefix )); then
    # A bit hacky but it works
    local _clang_links="clang++;clang-cpp;as;c++;cc;cpp;${MINGW_CHOST}-cc;${MINGW_CHOST}-c++;${MINGW_CHOST}-clang;${MINGW_CHOST}-clang++"

    platform_config+=(-DCLANG_DEFAULT_RTLIB=compiler-rt
      -DCOMPILER_RT_USE_BUILTINS_LIBRARY=ON
      -DCLANG_DEFAULT_UNWINDLIB=libunwind
      -DCLANG_DEFAULT_CXX_STDLIB=libc++
      -DLLVM_ENABLE_LIBCXX=ON
      -DCLANG_DEFAULT_LINKER=lld
      -DLLVM_ENABLE_LLD=ON
      -DCLANG_LINKS_TO_CREATE="${_clang_links}"
      -DLLVM_INSTALL_BINUTILS_SYMLINKS=ON)
  fi

  local _projects="clang;clang-tools-extra;compiler-rt;lld"

  case "${CARCH}" in
    x86_64|i?86)
      platform_config+=(-DCOMPILER_RT_BUILD_SANITIZERS=$( (( _clangprefix )) && echo "ON" || echo "OFF"))
      ;;
    armv7|aarch64)
      platform_config+=(-DCOMPILER_RT_BUILD_MEMPROF=OFF
        -DCOMPILER_RT_BUILD_SANITIZERS=OFF
        -DCOMPILER_RT_BUILD_XRAY=OFF)
      ;;
  esac

  # List of targets to build in CMake style
  # For more info see: https://github.com/msys2/MINGW-packages/discussions/9765
  if [ "${_compiler}" == "clang" ]; then
    platform_config+=(-DLLVM_TARGETS_TO_BUILD="all")
  else
    platform_config+=(-DLLVM_TARGETS_TO_BUILD="AArch64;AMDGPU;ARM;AVR;BPF;Mips;MSP430;NVPTX;RISCV;WebAssembly;X86")
  fi

  mkdir -p "${srcdir}"/build-${MSYSTEM} && cd "${srcdir}"/build-${MSYSTEM}

  MSYS2_ARG_CONV_EXCL="-DCMAKE_INSTALL_PREFIX=" \
  ${MINGW_PREFIX}/bin/cmake.exe \
    -GNinja \
    -DLIBCLANG_BUILD_STATIC=ON \
    -DLLD_DEFAULT_LD_LLD_IS_MINGW=ON \
    -DLLVM_ENABLE_PROJECTS="${_projects}" \
    -DLLVM_ENABLE_SPHINX=ON \
    -DLLVM_ENABLE_RTTI=ON \
    -DLLVM_INSTALL_UTILS=ON \
    "${common_cmake_args[@]}" \
    "${platform_config[@]}" \
    ../llvm

  ${MINGW_PREFIX}/bin/cmake.exe --build .

  # Disable automatic installation of components that go into subpackages
  # -i.orig to check what has been removed in-case it starts dropping more than it should
  #
  sed -i.orig '/\(clang\|lld\)\/cmake_install.cmake/d' tools/cmake_install.cmake
  sed -i.orig '/\(extra\|scan-build\|scan-build-py\|scan-view\)\/cmake_install.cmake/d' tools/clang/tools/cmake_install.cmake
  sed -i.orig '/compiler-rt\/cmake_install.cmake/d' projects/cmake_install.cmake
}

check() {
 cd "${srcdir}"/build-${MSYSTEM}
 # Remove || true once testcase doesn't cause failures.
#  make check || true
#  make check-clang || true
  ${MINGW_PREFIX}/bin/cmake.exe -DLLVM_INCLUDE_TESTS=ON ../llvm
  ${MINGW_PREFIX}/bin/cmake.exe --build .
  ${MINGW_PREFIX}/bin/cmake.exe --build . -- check-lld || true
}

package_clang() {
  pkgdesc="C language family frontend for LLVM (mingw-w64)"
  url="https://clang.llvm.org/"
  depends=("${MINGW_PACKAGE_PREFIX}-llvm=${pkgver}"
           "${MINGW_PACKAGE_PREFIX}-clang-libs=${pkgver}"
           $( ((_clangprefix)) && echo \
             "${MINGW_PACKAGE_PREFIX}-compiler-rt=${pkgver}" \
             "${MINGW_PACKAGE_PREFIX}-crt" \
             "${MINGW_PACKAGE_PREFIX}-headers" \
             "${MINGW_PACKAGE_PREFIX}-lld=${pkgver}" \
             "${MINGW_PACKAGE_PREFIX}-winpthreads" \
             || echo "${MINGW_PACKAGE_PREFIX}-gcc"))
  provides=($( (( _clangprefix )) && echo \
             "${MINGW_PACKAGE_PREFIX}-cc" \
             || true ))

  DESTDIR="${pkgdir}" ${MINGW_PREFIX}/bin/cmake --install "${srcdir}/build-${MSYSTEM}/tools/clang"

  install -Dm644 "${srcdir}/clang/LICENSE.TXT" "${pkgdir}"${MINGW_PREFIX}/share/licenses/clang/LICENSE

  # Runtime libraries
  rm -rf "${srcdir}/clang-libs"
  mkdir -p "${srcdir}/clang-libs/${MINGW_PREFIX}/bin"
  mv -f "${pkgdir}${MINGW_PREFIX}"/bin/libclang{,-cpp}.dll "${srcdir}/clang-libs/${MINGW_PREFIX}/bin"
}

package_clang-libs() {
  pkgdesc="Clang runtime libraries (mingw-w64)"
  url="https://clang.llvm.org/"
  depends=("${MINGW_PACKAGE_PREFIX}-gcc-libs"
           "${MINGW_PACKAGE_PREFIX}-llvm-libs=${pkgver}")
  conflicts=("${MINGW_PACKAGE_PREFIX}-clang<17.0.6")

  cp -r "${srcdir}/clang-libs/${MINGW_PREFIX}" "${pkgdir}${MINGW_PREFIX}"

  install -Dm644 "${srcdir}/clang/LICENSE.TXT" "${pkgdir}"${MINGW_PREFIX}/share/licenses/clang-libs/LICENSE
}

package_clang-analyzer() {
  pkgdesc="A source code analysis framework (mingw-w64)"
  url="https://clang-analyzer.llvm.org/"
  depends=("${MINGW_PACKAGE_PREFIX}-clang=${pkgver}"
           "${MINGW_PACKAGE_PREFIX}-python")

  local _analyzer
  for _analyzer in scan-build scan-build-py scan-view; do
    DESTDIR="${pkgdir}" ${MINGW_PREFIX}/bin/cmake --install "${srcdir}/build-${MSYSTEM}/tools/clang/tools/${_analyzer}"
  done

  # Compile Python scripts
  ${MINGW_PREFIX}/bin/python -m compileall -o 0 -o 1 "${pkgdir}"${MINGW_PREFIX}/lib/libscanbuild

  install -Dm644 "${srcdir}/clang/LICENSE.TXT" "${pkgdir}"${MINGW_PREFIX}/share/licenses/clang-analyzer/LICENSE
}

package_clang-tools-extra() {
  pkgdesc="Extra tools built using Clang's tooling APIs (mingw-w64)"
  url="https://clang.llvm.org/"
  depends=("${MINGW_PACKAGE_PREFIX}-clang=${pkgver}")

  DESTDIR="${pkgdir}" ${MINGW_PREFIX}/bin/cmake --install "${srcdir}/build-${MSYSTEM}/tools/clang/tools/extra"
}

package_compiler-rt() {
  pkgdesc="Runtime libraries for Clang and LLVM (mingw-w64)"
  url="https://compiler-rt.llvm.org/"
  depends=($( (( _clangprefix )) || echo "${MINGW_PACKAGE_PREFIX}-gcc-libs"))

  DESTDIR="${pkgdir}" ${MINGW_PREFIX}/bin/cmake --install "${srcdir}/build-${MSYSTEM}/projects/compiler-rt"
  mkdir -p "${pkgdir}${MINGW_PREFIX}/bin/"
  find "${pkgdir}${MINGW_PREFIX}/lib/clang/${_version%.[0-9].*}/lib/windows/" \
    -name '*.dll' -exec mv '{}' "${pkgdir}${MINGW_PREFIX}/bin/" \;
  # remove bin dir we created if it is still empty
  rmdir "${pkgdir}${MINGW_PREFIX}/bin/" 2>/dev/null || true
}

package_gcc-compat() {
  pkgdesc="GCC compatibility aliases for Clang (mingw-w64)"
  url="https://clang.llvm.org/"
  depends=("${MINGW_PACKAGE_PREFIX}-clang=${pkgver}-${pkgrel}")
  provides=("${MINGW_PACKAGE_PREFIX}-gcc")
  conflicts=("${MINGW_PACKAGE_PREFIX}-gcc")

  mkdir -p "${pkgdir}${MINGW_PREFIX}/bin"
  local _alias
  for _alias in gcc g++ ${MINGW_CHOST}-gcc ${MINGW_CHOST}-g++; do
    cp -f "${srcdir}/build-${MSYSTEM}/bin/clang.exe" "${pkgdir}${MINGW_PREFIX}/bin/${_alias}.exe"
  done
}

package_lld() {
  pkgdesc="Linker tools for LLVM (mingw-w64)"
  url="https://lld.llvm.org/"
  depends=("${MINGW_PACKAGE_PREFIX}-gcc-libs"
           "${MINGW_PACKAGE_PREFIX}-llvm-libs=${pkgver}"
           "${MINGW_PACKAGE_PREFIX}-zlib"
           "${MINGW_PACKAGE_PREFIX}-zstd")
  provides=($( (( _clangprefix )) && echo \
             "${MINGW_PACKAGE_PREFIX}-binutils" \
             || true))

  DESTDIR="${pkgdir}" ${MINGW_PREFIX}/bin/cmake --install "${srcdir}/build-${MSYSTEM}/tools/lld"
  if (( _clangprefix )); then
    install -Dm755 "${pkgdir}${MINGW_PREFIX}/bin/lld.exe" "${pkgdir}${MINGW_PREFIX}/bin/ld.exe"
  fi
}

package_llvm() {
  pkgdesc="Low Level Virtual Machine (mingw-w64)"
  depends=("${MINGW_PACKAGE_PREFIX}-llvm-libs")

  cd "${srcdir}"/llvm

  DESTDIR="${pkgdir}" ${MINGW_PREFIX}/bin/cmake --install "${srcdir}/build-${MSYSTEM}"

  install -Dm644 "${srcdir}/llvm/LICENSE.TXT" "${pkgdir}${MINGW_PREFIX}/share/licenses/llvm/LICENSE"

  # Runtime libraries
  rm -rf "${srcdir}/llvm-libs"
  mkdir -p "${srcdir}/llvm-libs/${MINGW_PREFIX}/bin"
  mv -f "${pkgdir}${MINGW_PREFIX}"/bin/lib{LLVM-*,LTO,Remarks}.dll "${srcdir}/llvm-libs/${MINGW_PREFIX}/bin"

  # Provide gcov on CLANG*
  if [[ ${MINGW_PACKAGE_PREFIX} == *-clang-* ]]; then
    cp "${pkgdir}"${MINGW_PREFIX}/bin/llvm-cov.exe "${pkgdir}"${MINGW_PREFIX}/bin/gcov.exe
  fi

  # Install CMake stuff
  install -d "${pkgdir}"${MINGW_PREFIX}/share/llvm/cmake/{modules,platforms}
  install -Dm644 "${srcdir}"/llvm/cmake/modules/*.cmake "${pkgdir}"${MINGW_PREFIX}/share/llvm/cmake/modules/
  install -Dm644 "${srcdir}"/llvm/cmake/platforms/*.cmake "${pkgdir}"${MINGW_PREFIX}/share/llvm/cmake/platforms/

  # fix cmake files.
  local PREFIX_WIN=$(cygpath -wm ${MINGW_PREFIX})
  sed -e "s|${PREFIX_WIN}|${MINGW_PREFIX}|g" -i ${pkgdir}/${MINGW_PREFIX}/lib/cmake/llvm/LLVMExports.cmake
}

package_llvm-libs() {
  pkgdesc="Low Level Virtual Machine Runtime Libraries (mingw-w64)"
  depends=("${MINGW_PACKAGE_PREFIX}-libffi"
           "${MINGW_PACKAGE_PREFIX}-gcc-libs"
           "${MINGW_PACKAGE_PREFIX}-zlib"
           "${MINGW_PACKAGE_PREFIX}-libxml2"
           "${MINGW_PACKAGE_PREFIX}-zstd")
  conflicts=("${MINGW_PACKAGE_PREFIX}-llvm<16.0.2-2")

  cp -r "${srcdir}/llvm-libs/${MINGW_PREFIX}" "${pkgdir}${MINGW_PREFIX}"

  install -Dm644 "${srcdir}/llvm/LICENSE.TXT" "${pkgdir}${MINGW_PREFIX}/share/licenses/llvm-libs/LICENSE"
}

# template start; name=mingw-w64-splitpkg-wrappers; version=1.0;
# vim: set ft=bash :

# generate wrappers
for _name in "${pkgname[@]}"; do
  _short="package_${_name#${MINGW_PACKAGE_PREFIX}-}"
  _func="$(declare -f "${_short}")"
  eval "${_func/#${_short}/package_${_name}}"
done
# template end;
