Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Rev 12 | Rev 14 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. #!/bin/sh
  2. # LLVM/Clang toolchain cross-compilation script for QNX 8.0 by Pierre-Marie Baty <pm@pmbaty.com>
  3.  
  4. # NOTE TO SELF: DO NOT USE $0 AS THIS SCRIPT CAN BE RUN *OR* SOURCED! (see build-llvm.sh in the VM)
  5.  
  6. export QNXSDK_VERSION="8.0.0" # version of the QNX SDK in use, in <major>.<minor>.<revision> format
  7. export QNXSDK_PATH="../qnx800" # relative location from the path of this script where to find the QNX platform SDK
  8. export QNXSDK_HOSTPATH="host/linux/x86_64" # relative location in QNXSDK_PATH of the tree containing the build tools that are runnable on the build host
  9. export QNXSDK_TARGETPATH="target/qnx" # relative location in QNXSDK_PATH of the tree containing the QNX8 system header files
  10.  
  11. export BUILD_DIR_NAME="llvm-build" # name of the directory on the build host's desktop where the LLVM sources will be built
  12. export BUILD_TARGET_ARCH="x86_64" # CPU architecture to build LLVM for, either "x86_64" or "aarch64"
  13.  
  14. export LLVM_VERSION="16.0.6" # version of LLVM that will be built (ideally the same version as the libc++ supplied by QNX in their platform SDK)
  15. export LLVM_SOURCES_FILE="llvmorg-${LLVM_VERSION}.tar.gz" # name of the file containing LLVM version LLVM_VERSION sources
  16. export LLVM_SOURCES_URL="https://github.com/llvm/llvm-project/archive/refs/tags/${LLVM_SOURCES_FILE}" # download URL of LLVM_SOURCES_FILE
  17. export LLVM_SOURCES_DIR="llvm-project-llvmorg-${LLVM_VERSION}" # name of directory created when extracting LLVM_SOURCES_FILE
  18.  
  19. export LLVM_PROJECTS_TO_BUILD="clang;polly;lld" # semicolon-separated list of LLVM projects to build (full list: "clang;clang-tools-extra;cross-project-tests;libc;libclc;lld;lldb;openmp;polly;pstl")
  20. export LLVM_RUNTIMES_TO_BUILD="compiler-rt;libunwind" # semicolon-separated list of LLVM runtimes to build (full list: "compiler-rt;libc;libcxx;libcxxabi;libunwind;openmp")
  21. export LLVM_BUILD_CONFIGURATION_TYPE="MinSizeRel" # build configuration, one of "Debug", "Release", "RelWithDebugInfo" or "MinSizeRel"
  22.  
  23. export REQUIRED_TOOLS="wget python3 cmake gcc g++ ninja ccache" # list of build tools required to build all this on the build host
  24.  
  25. # see where we are
  26. export CURRENT_DIR="$(pwd)"
  27.  
  28. print_error_and_die()
  29. {
  30.         # a handy function that does what it says. Args: error strings to print, one line per argument
  31.         test -z "${COLUMNS}" && COLUMNS=80
  32.         echo ""
  33.         while [ -n "${1}" ]; do
  34.                 echo "${1}"|fold -s -w "${COLUMNS}"
  35.                 shift
  36.         done
  37.         echo ""
  38.         exit 1
  39. }
  40.  
  41. # verify we're a x86_64 Linux host
  42. if [ ! "$(uname)" = "Linux" ] || [ ! "$(uname -m)" = "x86_64" ]; then
  43.         print_error_and_die "Error: this script requires a x86_64 Linux machine (possibly a virtual machine) as the build host."
  44. fi
  45.  
  46. # verify that we have the QNX platform SDK
  47. if [ ! -d "${QNXSDK_PATH}/${QNXSDK_HOSTPATH}" ] || [ ! -d "${QNXSDK_PATH}/${QNXSDK_TARGETPATH}" ]; then
  48.         print_error_and_die "Error: the ${QNXSDK_PATH} path doesn't contain a QNX SDK. It must contain the 'host' and 'target' directories of the QNX SDP for the targeted version of QNX and the ${BUILD_TARGET_ARCH} platform. Please deploy these directories and try again."
  49. fi
  50.  
  51. # verify that we have the required tools
  52. for REQUIRED_TOOL in ${REQUIRED_TOOLS}; do
  53.         "${REQUIRED_TOOL}" --version > /dev/null 2>&1 || print_error_and_die \
  54.                 "Error: this script requires at the very least the following tools installed:" \
  55.                 "       $(echo "${REQUIRED_TOOLS}"|sed 's/ /\n  /g')" \
  56.                 "Please install them (possibly as binary packages with apt-get) and try again." \
  57.                 "More specifically, the following tool was not found: '${REQUIRED_TOOL}'"
  58. done
  59.  
  60. # verify that the symlinks are deployed in the SDK -- just test one of them
  61. if [ ! -e "${QNXSDK_PATH}/${QNXSDK_TARGETPATH}/usr/include/readline.h" ]; then
  62.         print_error_and_die \
  63.                 "Error: the toolchain platform-specific symbolic links have not been deployed in this QNX SDK. Please run" \
  64.                 "(on a POSIX machine:)" \
  65.                 "       cd ${QNXSDK_PATH}" \
  66.                 "       find . -name symlinks.lst -exec ./symlinks.sh {} create \\; && printf 'present' > .symlinks-state" \
  67.                 "(else on a Windows machine:)" \
  68.                 "       cd ${QNXSDK_PATH}" \
  69.                 "       host\\win64\\x86_64\\usr\\bin\\busybox.exe sh -c \"find . -name symlinks.lst -exec ./symlinks.sh {} create \\; && printf 'present' > .symlinks-state\"" \
  70.                 "Note that this step WILL take time on a Win32 machine, but is only done once."
  71. fi
  72.  
  73. # create a symlink in /tmp that will lead to the QNX platform SDK so as to avoid spaces in paths if it doesn't exist already
  74. # (this is totally prohibitive with the official QNX toolchain)
  75. if [ ! -L /tmp/qnxsdk ] || [ ! "$(readlink /tmp/qnxsdk)" = "$(realpath "${CURRENT_DIR}/${QNXSDK_PATH}")" ]; then
  76.         echo "Creating symlink to QNX toolchain in /tmp/qnxsdk..."
  77.         rm -rf /tmp/qnxsdk 2>/dev/null
  78.         ln -fs "$(realpath "${CURRENT_DIR}/${QNXSDK_PATH}")" /tmp/qnxsdk || exit 1
  79. fi
  80.  
  81. # setup the environment
  82. export QNX_HOST="/tmp/qnxsdk/${QNXSDK_HOSTPATH}"
  83. export QNX_TARGET="/tmp/qnxsdk/${QNXSDK_TARGETPATH}"
  84. export MAKEFLAGS="-I${QNX_TARGET}/usr/include"
  85. export PATH="${QNX_HOST}/usr/bin:${PATH}"
  86.  
  87. # print the build environment
  88. echo "QNX_HOST=${QNX_HOST}"
  89. echo "QNX_TARGET=${QNX_TARGET}"
  90. echo "MAKEFLAGS=${MAKEFLAGS}"
  91.  
  92. # construct the target triple (actually a quadruple)
  93. export TARGET_ARCH="${BUILD_TARGET_ARCH}"
  94. test "${BUILD_TARGET_ARCH}" = "x86_64" && export TARGET_VENDOR="pc" || export TARGET_VENDOR="unknown"
  95. export TARGET_KERNEL="nto"
  96. export TARGET_SYSTEM="qnx${QNXSDK_VERSION}"
  97. export TARGET_TRIPLE="${TARGET_ARCH}-${TARGET_VENDOR}-${TARGET_KERNEL}-${TARGET_SYSTEM}"
  98. echo "Will build for ${TARGET_TRIPLE}"
  99.  
  100. # change to an immediately visible path, i.e. the user's desktop (failsafe to $HOME if xdg-user-dir is unavailable)
  101. STAGING_PATH="$(xdg-user-dir DESKTOP 2>/dev/null || echo "${HOME}")"
  102. cd "${STAGING_PATH}"
  103.  
  104. # download the involved source packages and unpack them if not done yet
  105. download_and_unpack_if_necessary()
  106. {
  107.         # helper function that downloads a sources tarball, extracts it and patches it if necessary
  108.         # args: <sources dirname> <sources filename> <download URL> [optional patchset URL]
  109.         test -d "${1}" && return 0 # if sources directory already exists, nothing to do
  110.         if [ ! -s "${CURRENT_DIR}/${2}" ]; then # if sources archive isn't a nonempty file...
  111.                 echo "Downloading ${1} sources from ${3}..."
  112.                 if ! wget -O "${CURRENT_DIR}/${2}" "${3}"; then
  113.                         # remove output file in case an error occurs
  114.                         rm -f "${CURRENT_DIR}/${2}"
  115.                         exit 1
  116.                 fi
  117.         fi
  118.         echo "Extracting ${1} sources..."
  119.         cd "$(dirname "${1}")"
  120.         if echo "${2}"|grep -q "\.tar\.bz2$"; then
  121.                 # BZip2 tarball
  122.                 tar xjf "${CURRENT_DIR}/${2}" || exit 1
  123.         elif echo "${2}"|grep -q "\.tar\.xz$"; then
  124.                 # XZ tarball
  125.                 tar xJf "${CURRENT_DIR}/${2}" || exit 1
  126.         elif echo "${2}"|grep -q "\.tar\.gz$"; then
  127.                 # GZipped tarball
  128.                 tar xzf "${CURRENT_DIR}/${2}" || exit 1
  129.         else
  130.                 print_error_and_die "Error: unsupported file extension. Please improve the download_and_unpack_if_necessary() shell function to support it."
  131.         fi
  132.         # make sure the expected directory is here after extraction
  133.         if [ ! -d "${1}" ]; then
  134.                 print_error_and_die "Error: couldn't find ${1} in extracted sources."
  135.         fi
  136.         # do we have a patchset to apply ?
  137.         if [ -n "${4}" ]; then
  138.                 echo "Downloading ${1} patchset from ${4}..."
  139.                 wget -O "${CURRENT_DIR}/${2}.patchset" "${4}" || exit 1
  140.                 echo "Applying patchset..."
  141.                 OLDDIR="$(pwd)"
  142.                 cd "${1}"
  143.                 patch -N -Z -p1 < "${CURRENT_DIR}/${2}.patchset" || exit 1
  144.                 cd "${OLDDIR}"
  145.                 unset OLDDIR
  146.         fi
  147.         return 0
  148. }
  149. download_and_unpack_if_necessary "${LLVM_SOURCES_DIR}" "${LLVM_SOURCES_FILE}" "${LLVM_SOURCES_URL}" || exit 1
  150.  
  151. # create the build directory
  152. echo "Wiping out build directory..."
  153. test -e "${BUILD_DIR_NAME}" && rm -rf "${BUILD_DIR_NAME}"
  154. mkdir "${BUILD_DIR_NAME}" || exit 1
  155. cd "${BUILD_DIR_NAME}" || exit 1
  156.  
  157. # create the QNX CMake toolchain file
  158. test -e "${TARGET_TRIPLE}.cmake" || echo '# '${TARGET_TRIPLE}' CMake toolchain file by Pierre-Marie Baty <pm@pmbaty.com>
  159.  
  160. SET(CMAKE_SYSTEM_NAME "QNX")
  161. SET(CMAKE_SYSTEM_VERSION "'${QNXSDK_VERSION}'")
  162.  
  163. SET(QNX "1")
  164. SET(QNXNTO "1")
  165. SET(QNX_HOST "$ENV{QNX_HOST}")
  166. SET(QNX_TARGET "$ENV{QNX_TARGET}")
  167. SET(QNX_PROCESSOR "'${TARGET_ARCH}'")
  168.  
  169. SET(CMAKE_ASM_COMPILER "${QNX_HOST}/usr/bin/'${TARGET_TRIPLE}'-gcc")
  170. SET(CMAKE_ASM_COMPILER_TARGET "gcc_nto${QNX_PROCESSOR}")
  171.  
  172. SET(CMAKE_C_COMPILER "${QNX_HOST}/usr/bin/'${TARGET_TRIPLE}'-gcc")
  173. SET(CMAKE_C_COMPILER_TARGET "gcc_nto${QNX_PROCESSOR}")
  174. SET(CMAKE_C_FLAGS_DEBUG "-g")
  175. SET(CMAKE_C_FLAGS_MINSIZEREL "-Os -DNDEBUG")
  176. SET(CMAKE_C_FLAGS_RELEASE "-O3 -DNDEBUG")
  177. SET(CMAKE_C_FLAGS_RELWITHDEBINFO "-O2 -g")
  178. SET(CMAKE_C_FLAGS "-D_QNX_SOURCE=1 -I${QNX_TARGET}/usr/include/devs/include_'${TARGET_ARCH}' -I${QNX_TARGET}/usr/include/devs -DDONT_DEFINE_BSD -DDONT_DEFINE___FreeBSD_kernel__ -DDONT_DEFINE_FSCALE -DDONT_DEFINE_MACHINE")
  179.  
  180. SET(CMAKE_CXX_COMPILER "${QNX_HOST}/usr/bin/'${TARGET_TRIPLE}'-g++")
  181. SET(CMAKE_CXX_COMPILER_TARGET "gcc_nto${QNX_PROCESSOR}")
  182. SET(CMAKE_CXX_FLAGS_DEBUG "-g")
  183. SET(CMAKE_CXX_FLAGS_MINSIZEREL "-Os -DNDEBUG")
  184. SET(CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG")
  185. SET(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g")
  186. SET(CMAKE_CXX_FLAGS "-D_QNX_SOURCE=1 -I${QNX_TARGET}/usr/include/devs/include_'${TARGET_ARCH}' -I${QNX_TARGET}/usr/include/devs -DDONT_DEFINE_BSD -DDONT_DEFINE___FreeBSD_kernel__ -DDONT_DEFINE_FSCALE -DDONT_DEFINE_MACHINE")
  187.  
  188. SET(CMAKE_LINKER "${QNX_HOST}/usr/bin/'${TARGET_TRIPLE}'-ld.bfd")
  189. SET(CMAKE_SHARED_LINKER_FLAGS "-lsocket")
  190. SET(CMAKE_EXE_LINKER_FLAGS "-lsocket")
  191.  
  192. SET(CMAKE_RANLIB "${QNX_HOST}/usr/bin/'${TARGET_TRIPLE}'-ranlib")
  193.  
  194. SET(CMAKE_NM "${QNX_HOST}/usr/bin/'${TARGET_TRIPLE}'-nm")
  195.  
  196. SET(CMAKE_AR "${QNX_HOST}/usr/bin/'${TARGET_TRIPLE}'-ar")
  197.  
  198. SET(CMAKE_FIND_ROOT_PATH "${QNX_TARGET}")
  199. SET(CMAKE_FIND_ROOT_PATH_HOST_PROGRAM NEVER)
  200. SET(CMAKE_FIND_ROOT_PATH_HOST_LIBRARY ONLY)
  201. SET(CMAKE_FIND_ROOT_PATH_HOST_INCLUDE ONLY)
  202. ' > "${TARGET_TRIPLE}.cmake"
  203.  
  204. backup_and_patch_if_necessary()
  205. {
  206.         # handy function that patches a file in LLVM_SOURCES_DIR with a given sed replacement regex if necessary, creating backups
  207.         # args: <file pathname> <grep_string_to_test_for_presence_of_patch> <sed regex> [<second regex> [...]]
  208.         _PATCHEE_PATHNAME="${1}"
  209.         _PATCHED_PATTERN="${2}"
  210.         # test if already patched
  211.         grep -q "${_PATCHED_PATTERN}" "../${LLVM_SOURCES_DIR}/${_PATCHEE_PATHNAME}" && return
  212.         # tell what we're about to do
  213.         echo "Patching ${_PATCHEE_PATHNAME}..."
  214.         _DOTTED_NAME="$(echo "${_PATCHEE_PATHNAME}"|tr '/' '.')"
  215.         # have a backup first
  216.         test -f "${CURRENT_DIR}/${_DOTTED_NAME} [ORIGINAL]" || cp "../${LLVM_SOURCES_DIR}/${_PATCHEE_PATHNAME}" "${CURRENT_DIR}/${_DOTTED_NAME} [ORIGINAL]" || exit 1
  217.         # perform the patch
  218.         cp -f "${CURRENT_DIR}/${_DOTTED_NAME} [ORIGINAL]" "${CURRENT_DIR}/${_DOTTED_NAME} [PATCHED]" || exit 1
  219.         while [ -n "${3}" ]; do
  220.                 sed -E -i "${3}" "${CURRENT_DIR}/${_DOTTED_NAME} [PATCHED]"
  221.                 shift
  222.         done
  223.         # verify that we did it successfully
  224.         if ! grep -q "${_PATCHED_PATTERN}" "${CURRENT_DIR}/${_DOTTED_NAME} [PATCHED]"; then
  225.                 print_error_and_die "Error: the file ${_PATCHEE_PATHNAME} could not be patched. Please investigate and fix manually."
  226.         fi
  227.         # and put the patched file in place
  228.         cp -f "${CURRENT_DIR}/${_DOTTED_NAME} [PATCHED]" "../${LLVM_SOURCES_DIR}/${_PATCHEE_PATHNAME}" || exit 1
  229. }
  230.  
  231. # patch llvm/lib/Support/Unix/Path.inc if not done yet
  232. # replace:
  233. #       defined(__FreeBSD_kernel__)
  234. # with:
  235. #       (defined(__FreeBSD_kernel__) || defined(__QNXNTO__))
  236. # RATIONALE: the concerned parts of the QNX platform SDK (/usr/include/devs/*) are actually largely based on FreeBSD code, to conveniently use the FreeBSD network stack.
  237. # NONETHELESS, QNX *IS NOT* FreeBSD and "__FreeBSD_kernel__" *SHOULD NOT* be defined, else userland code may falsely assume a genuine FreeBSD include tree to be available,
  238. # which leads to compilation errors caused by include files assumed to be there whereas they are in fact nowhere to be found (ex: /usr/include/sys/user.h, among others).
  239. # The QNX8 platform SDK has thus been patched to NOT define __FreeBSD_kernel__ when the -DDONT_DEFINE___FreeBSD_kernel__ flag is passed, and the feature tests in Path.inc
  240. # that branch into FreeBSD APIs (which ones *are* exposed in the QNX libc since QNX largely shares FreeBSD code) are about to be patched right now to accept __QNXNTO__ too.
  241. # Additionally, support for statfs()/fstatfs() has been restored in the QNX8 platform SDK in /usr/include/devs/sys/mount.h where it was claimed but absent from the QNX8 libc.
  242. # FIXME: these hacks should be moved elsewhere not to pollute the QNX8 platform SDK -- it *SHOULD* be possible to build without devs
  243. backup_and_patch_if_necessary "llvm/lib/Support/Unix/Path.inc" __QNXNTO__ \
  244.         's@defined\(__FreeBSD_kernel__\)@\(defined\(__FreeBSD_kernel__\) \|\| \defined\(__QNXNTO__\)\)@g'
  245.  
  246. # LLVM 16: patch llvm/lib/Support/Path.cpp if not done yet
  247. # replace:
  248. #       std::string getMainExecutable
  249. # with:
  250. #       #if 0
  251. #       std::string getMainExecutable
  252. # and:
  253. #       TempFile::TempFile(StringRef Name, int FD)
  254. # with:
  255. #       #endif
  256. #       TempFile::TempFile(StringRef Name, int FD)
  257. # RATIONALE: std::string getMainExecutable(const char *Argv0, void *MainAddr) is already defined in llvm/lib/Support/Unix/Path.inc, this looks like a LLVM bug?
  258. # Specifically read the following patch list: https://reviews.llvm.org/D109977 -- it looks like the implementation of this diff in LLVM 16.0.6 is incomplete.
  259. # This patch restores a working state (ante D109977).
  260. test "$(echo "${LLVM_VERSION}"|cut -d . -f 1)" -lt 17 && backup_and_patch_if_necessary "llvm/lib/Support/Path.cpp" "#if 0" \
  261.         's@std::string getMainExecutable@#if 0\nstd::string getMainExecutable@' \
  262.         's@TempFile::TempFile\(StringRef Name, int FD\)@#endif\nTempFile::TempFile\(StringRef Name, int FD\)@'
  263.  
  264. # LLDB patches
  265. if echo "${LLVM_PROJECTS_TO_BUILD}"|tr ';' '\n'|grep -q "lldb"; then
  266.  
  267.         # patch lldb/Source/Host/common/Host.cpp if not done yet
  268.         # replace:
  269.         #       defined(SIGINFO)
  270.         # with:
  271.         #       (defined(SIGINFO) && !defined(__QNXNTO__))
  272.         # RATIONALE: once upon a time (probably in the early steps of the design of their OS), the QNX people defined SIGINFO to the value of SIGUSR1 for a mysterious reason,
  273.         # defeating the purpose of SIGUSR1 completely, which should be a User-Definable signal as mandated by POSIX. Consequently, any userland code that enumerates POSIX signals
  274.         # hits the same value twice, and all is left to solve this problem is to filter either one out. Since SIGINFO, contrarily to SIGUSR1, is an optional signal,
  275.         # this is the value that will be left out. It is not possible to correct this in the platform SDK since all the precompiled userland programs supplied by QNX
  276.         # expect the value of SIGUSR1 for SIGINFO.
  277.         backup_and_patch_if_necessary "lldb/source/Host/common/Host.cpp" __QNXNTO__ \
  278.                 's@defined\(SIGINFO\)@\(defined\(SIGINFO\) \&\& \!defined\(__QNXNTO__\)\)@g'
  279.        
  280.         # FIXME: another patch is needed for LLDB. Basically, the ptrace() POSIX system call doesn't exist on QNX. Instead
  281.         # QNX use their own debug utility: pdebug. Note the /proc filesystem can be used to access a debuggee's virtual memory space.
  282.         # in lldb/source/Host/posix/ProcessLauncherPosixFork.cpp line 196:
  283.         #   if (ptrace(PT_TRACE_ME, 0, nullptr, 0) == -1) // <--- undefined: ptrace, PT_TRACE_ME
  284. fi
  285.  
  286. # compiler-rt patches
  287. if echo "${LLVM_RUNTIMES_TO_BUILD}"|tr ';' '\n'|grep -q "compiler-rt"; then
  288.  
  289.         # patch compiler-rt/lib/builtins/enable_execute_stack.c if not done yet
  290.         # replace:
  291.         #       #include "int_lib.h"
  292.         # with:
  293.         #       #ifdef __QNXNTO__
  294.         #       #define _QNX_SOURCE 1
  295.         #       #endif
  296.         #       #include "int_lib.h"
  297.         # RATIONALE: the QNX people decided to hide most of the UNIX APIs of their libc behind a mandatory _QNX_SOURCE definition to separate the Neutrino primitives from the rest maybe.
  298.         # This name does not "enforce" any standard at all (like _POSIX_SOURCE and similar names), it's just a convenient hack for the QNX people to hide stuff.
  299.         # To put things back on track and expose the POSIX interfaces of their libc to the world, _QNX_SOURCE has been added to the toolchain CMake file, but it happens that
  300.         # when building compiler-rt specifically, the CMAKE_C_FLAGS directive is ignored. Patching the source file seems like the best option to fix that.
  301.         backup_and_patch_if_necessary "compiler-rt/lib/builtins/enable_execute_stack.c" __QNXNTO__ \
  302.                 's@#include "int_lib.h"@#ifdef __QNXNTO__\n#define _QNX_SOURCE 1\n#endif\n#include "int_lib.h"@'
  303.  
  304.         # patch compiler-rt/lib/profile/InstrProfilingUtil.c
  305.         # replace:
  306.         #       #include <sys/mman.h>
  307.         # with:
  308.         #       #ifdef __QNXNTO__
  309.         #       #include <devs/sys/mman.h>
  310.         #       #endif
  311.         #       #include <sys/mman.h>
  312.         # RATIONALE: QNX doesn't define MADV_DONTNEED (but does so for POSIX_MADV_DONTNEED), unfortunately compiler-rt needs the former. By luck, its value is defined in
  313.         # the extra platform headers they borrowed from FreeBSD, i.e. devs/sys/mman.h, and it has the same value, so include both to fix the problem.
  314.         backup_and_patch_if_necessary "compiler-rt/lib/profile/InstrProfilingUtil.c" __QNXNTO__ \
  315.                 's@#include <sys/mman.h>@#ifdef __QNXNTO__\n#include <devs/sys/mman.h>\n#endif\n#include <sys/mman.h>@'
  316.  
  317.         # patch compiler-rt/lib/orc/endianness.h
  318.         # replace:
  319.         #       #elif defined(__MVS__)
  320.         # with:
  321.         #       #elif defined(__QNXNTO__)
  322.         #       #define BYTE_ORDER __BYTE_ORDER__
  323.         #       #elif defined(__MVS__)
  324.         # RATIONALE: QNX doesn't provide a <machine/endian.h> header directly: the user must specify the machine-specific include path (e.g. -isystem ${QNX_TARGET}/usr/include/devs/include_x86_64)
  325.         # Instead of going through platform detection logic, we supply the only definition this file needs, which is opportunisticly the same one that GCC and Clang provide implicitly.
  326.         backup_and_patch_if_necessary "compiler-rt/lib/orc/endianness.h" __QNXNTO__ \
  327.                 's@#elif defined\(__MVS__\)@#elif defined\(__QNXNTO__\)\n#define BYTE_ORDER __BYTE_ORDER__\n#elif defined\(__MVS__\)@'
  328. fi
  329.  
  330. # libunwind patches
  331. if echo "${LLVM_RUNTIMES_TO_BUILD}"|tr ';' '\n'|grep -q "libunwind"; then
  332.  
  333.         # patch libunwind/src/libunwind.cpp
  334.         # replace:
  335.         #       #include <libunwind.h>:
  336.         # with:
  337.         #       #ifdef __QNXNTO__
  338.         #       #define _QNX_SOURCE 1
  339.         #       #endif
  340.         #       #include <libunwind.h>
  341.         # RATIONALE: the pthreads implementation in QNX 'steals' things from the POSIX.1 standard and hides them behind the __EXT_QNX macro,
  342.         # which is defined when either _QNX_SOURCE or __EXT without anything else is defined. This is not correct and low-level libraries
  343.         # such as libunwind that do not define either of those fail to build. Also note that a FreeBSD-compatible header was added to the QNX8
  344.         # platform SDK: /usr/include/link.h, which defines Elf types as Elf64/Elf32 types depending on the architecture and adds some glue.
  345.         backup_and_patch_if_necessary "libunwind/src/libunwind.cpp" __QNXNTO__ \
  346.                 's@#include <libunwind.h>@#ifdef __QNXNTO__\n#define _QNX_SOURCE 1\n#endif\n#include <libunwind.h>@'
  347. fi
  348.  
  349. # libc++ patches
  350. if echo "${LLVM_PROJECTS_TO_BUILD}"|tr ';' '\n'|grep -q "libcxx"; then
  351.  
  352.         # patch libcxx/include/__config
  353.         # replace:
  354.         #       #      define _LIBCPP_HAS_THREAD_API_WIN32
  355.         # with:
  356.         #       #      define _LIBCPP_HAS_THREAD_API_WIN32
  357.         #       #    elif defined(__QNXNTO__)
  358.         #       #      define _LIBCPP_HAS_THREAD_API_PTHREAD
  359.         #       #      define _LIBCPP_HAS_COND_CLOCKWAIT
  360.         #       #      define _LIBCPP_HAS_CLOCK_GETTIME
  361.         # RATIONALE: simply bring QNX among the list of systems known by libc++ to expose a pthreads API; while we're at it inform it that pthread_cond_clockwait() is available
  362.         # and that the standard POSIX clock_gettime() is available to return a realtime wall clock value in nanoseconds (this might not be the optimal way of getting it though).
  363.         backup_and_patch_if_necessary "libcxx/include/__config" __QNXNTO__ \
  364.                 's@#      define _LIBCPP_HAS_THREAD_API_WIN32@#      define _LIBCPP_HAS_THREAD_API_WIN32\n#    elif defined(__QNXNTO__)\n#      define _LIBCPP_HAS_THREAD_API_PTHREAD\n#      define _LIBCPP_HAS_COND_CLOCKWAIT\n#      define _LIBCPP_HAS_CLOCK_GETTIME@'
  365.        
  366.         # patch libcxx/include/__locale
  367.         # replace:
  368.         #       # include <__support/openbsd/xlocale.h>
  369.         # with:
  370.         #       # include <__support/openbsd/xlocale.h>
  371.         #       #elif defined(__QNXNTO__)
  372.         #       # include <__support/qnx/xlocale.h>
  373.         # and:
  374.         #       #elif defined(__MVS__)
  375.         # with:
  376.         #       #elif defined(__QNXNTO__)
  377.         #           typedef short mask;
  378.         #           static const mask space  = (_CN|_SP|_XS);
  379.         #           static const mask print  = (_DI|_LO|_PU|_SP|_UP|_XA);
  380.         #           static const mask cntrl  = _BB;
  381.         #           static const mask upper  = _UP;
  382.         #           static const mask lower  = _LO;
  383.         #           static const mask alpha  = (_LO|_UP|_XA);
  384.         #           static const mask digit  = _DI;
  385.         #           static const mask punct  = _PU;
  386.         #           static const mask xdigit = _XD;
  387.         #           static const mask blank  = (_SP|_XB);
  388.         #           static const mask __regex_word = 0x1000;
  389.         #       #elif defined(__MVS__)
  390.         # RATIONALE: add QNX-specific locale C++ bindings and definitions
  391.         backup_and_patch_if_necessary "libcxx/include/__locale" __QNXNTO__ \
  392.                 's@# include <__support/openbsd/xlocale.h>@# include <__support/openbsd/xlocale.h>\n#elif defined\(__QNXNTO__\)\n# include <__support/qnx/xlocale.h>@' \
  393.                 's@#elif defined\(__MVS__\)@#elif defined\(__QNXNTO__\)\n    typedef short mask;\n    static const mask space  = \(_CN\|_SP\|_XS\);\n    static const mask print  = \(_DI\|_LO\|_PU\|_SP\|_UP\|_XA\);\n    static const mask cntrl  = _BB;\n    static const mask upper  = _UP;\n    static const mask lower  = _LO;\n    static const mask alpha  = \(_LO\|_UP\|_XA\);\n    static const mask digit  = _DI;\n    static const mask punct  = _PU;\n    static const mask xdigit = _XD;\n    static const mask blank  = \(_SP\|_XB\);\n    static const mask __regex_word = 0x1000;\n#elif defined\(__MVS__\)@'
  394.        
  395.         # patch libcxx/include/CMakeLists.txt
  396.         # replace:
  397.         #         __support/openbsd/xlocale.h
  398.         # with:
  399.         #         __support/openbsd/xlocale.h
  400.         #         __support/qnx/xlocale.h
  401.         # RATIONALE: add QNX-specific locale C++ bindings and definitions
  402.         backup_and_patch_if_necessary "libcxx/include/CMakeLists.txt" qnx/xlocale.h \
  403.                 's@  __support/openbsd/xlocale.h@  __support/openbsd/xlocale.h\n  __support/qnx/xlocale.h@'
  404.        
  405.         # add __support/qnx/xlocale.h to the libc++ source tree
  406.         # RATIONALE: add QNX-specific locale C++ bindings and definitions
  407.         test -d "../${LLVM_SOURCES_DIR}/libcxx/include/__support/qnx" || mkdir "../${LLVM_SOURCES_DIR}/libcxx/include/__support/qnx" || exit 1
  408.         test -f "../${LLVM_SOURCES_DIR}/libcxx/include/__support/qnx/xlocale.h" || cp "${QNX_TARGET}/usr/include/c++/v1/__support/qnx/xlocale.h" "../${LLVM_SOURCES_DIR}/libcxx/include/__support/qnx/xlocale.h" || exit 1
  409.        
  410.         # patch libcxx/include/locale
  411.         # replace:
  412.         #       !defined(__BIONIC__) && !defined(_NEWLIB_VERSION) && !defined(__EMSCRIPTEN__)
  413.         # with:
  414.         #       !defined(__BIONIC__) && !defined(_NEWLIB_VERSION) && !defined(__EMSCRIPTEN__) && !defined(__QNXNTO__)
  415.         # RATIONALE: QNX doesn't have catopen() to open a "message catalog"
  416.         backup_and_patch_if_necessary "libcxx/include/locale" __QNXNTO__ \
  417.                 's@\!defined\(__BIONIC__\) \&\& \!defined\(_NEWLIB_VERSION\) \&\& \!defined\(__EMSCRIPTEN__\)@!defined\(__BIONIC__\) \&\& !defined\(_NEWLIB_VERSION\) \&\& !defined\(__EMSCRIPTEN__\) \&\& !defined\(__QNXNTO__\)@'
  418.        
  419.         # patch libcxx/include/setjmp.h
  420.         # replace:
  421.         #       #endif // __cplusplus
  422.         # with:
  423.         #       #ifdef __QNXNTO__
  424.         #       #undef longjmp
  425.         #       [[noreturn]] inline void longjmp(jmp_buf env, int val) { ::siglongjmp(env, val); }
  426.         #       #endif // __QNXNTO__
  427.         #      
  428.         #       #endif // __cplusplus
  429.         # RATIONALE: restore the thread signal mask when calling longjmp() by calling siglongjmp() instead (not sure why, but that's how they do it in the libc++ 16.0.6 they ship with their SDK)
  430.         # FIXME: is this a good idea really? It looks like by calling siglongjmp() instead of longjmp() after setjmp() the QNX people did a broken implementation !?
  431.         backup_and_patch_if_necessary "libcxx/include/setjmp.h" __QNXNTO__ \
  432.                 's@#endif // __cplusplus@#ifdef __QNXNTO__\n#undef longjmp\n\[\[noreturn\]\] inline void longjmp\(jmp_buf env, int val\) { ::siglongjmp\(env, val\); }\n#endif // __QNXNTO_\n\n#endif // __cplusplus@'
  433. fi
  434.  
  435. # polly patches
  436. if echo "${LLVM_PROJECTS_TO_BUILD}"|tr ';' '\n'|grep -q "polly"; then
  437.  
  438.         # patch polly/lib/External/isl/imath/imath.c
  439.         # replace:
  440.         #       /* Select min/max. */
  441.         # with:
  442.         #       #ifdef __QNXNTO__
  443.         #       #undef MIN
  444.         #       #undef MAX
  445.         #       #endif // __QNXNTO__
  446.         #       /* Select min/max. */
  447.         # RATIONALE: QNX already defines MIN/MAX as macros, but polly intends to define them as inline functions. Perhaps this could be avoided by passing _POSIX_SOURCE instead of _QNX_SOURCE.
  448.         backup_and_patch_if_necessary "polly/lib/External/isl/imath/imath.c" __QNXNTO__ \
  449.                 's@\/\* Select min\/max. \*\/@#ifdef __QNXNTO__\n#undef MIN\n#undef MAX\n#endif\n\/\* Select min\/max. \*\/@'
  450. fi
  451.  
  452. # now configure LLVM...
  453. echo "Configuring LLVM build..."
  454. export CCACHE_DIR="$(realpath "../${LLVM_SOURCES_DIR}/.ccache")"
  455. cmake \
  456.     -D CMAKE_TOOLCHAIN_FILE="${TARGET_TRIPLE}.cmake" \
  457.     -D CMAKE_BUILD_TYPE="${LLVM_BUILD_CONFIGURATION_TYPE}" \
  458.     -D CMAKE_INSTALL_PREFIX="/usr/bin" \
  459.     -D CMAKE_STAGING_PREFIX="${CURRENT_DIR}/llvm-build/${BUILD_TARGET_ARCH}" \
  460.     -D CMAKE_C_COMPILER_LAUNCHER="ccache" \
  461.     -D CMAKE_CXX_COMPILER_LAUNCHER="ccache" \
  462.     -D LLVM_HOST_TRIPLE="${TARGET_TRIPLE}" \
  463.     -D LLVM_ENABLE_PROJECTS="${LLVM_PROJECTS_TO_BUILD}" \
  464.     -D LLVM_ENABLE_RUNTIMES="${LLVM_RUNTIMES_TO_BUILD}" \
  465.     -D LLVM_TARGETS_TO_BUILD="AArch64;X86" \
  466.     -D COMPILER_RT_BUILD_SANITIZERS="OFF" \
  467.     -D COMPILER_RT_BUILD_XRAY="OFF" \
  468.     -D COMPILER_RT_BUILD_MEMPROF="OFF" \
  469.     -D COMPILER_RT_BUILD_LIBFUZZER="OFF" \
  470.     -D COMPILER_RT_BUILD_PROFILE="OFF" \
  471.     -G Ninja \
  472.     "../${LLVM_SOURCES_DIR}/llvm" || exit 1
  473.  
  474. # and do the Lord's work. https://youtu.be/jcyYmCnkbEE
  475. echo "Building LLVM..."
  476. cmake --build . --target install || exit 1
  477.  
  478. /bin/printf "\n\xF0\x9F\x8D\xBE\x20\x43\x68\x61\x6d\x70\x61\x67\x6e\x65\x2e\n"
  479. exit 0
  480.  
  481. # TODO optional: port compiler_rt sanitizer bindings and build sanitizers, xray, memprof, libfuzzer and profile
  482. # TODO optional: port lldb bindings and build lldb
  483.