Rev 26 | Rev 28 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed
| Rev | Author | Line No. | Line |
|---|---|---|---|
| 2 | pmbaty | 1 | #!/bin/sh |
| 3 | pmbaty | 2 | # LLVM/Clang toolchain cross-compilation script for QNX 8.0 by Pierre-Marie Baty <pm@pmbaty.com> |
| 2 | pmbaty | 3 | |
| 3 | pmbaty | 4 | # NOTE TO SELF: DO NOT USE $0 AS THIS SCRIPT CAN BE RUN *OR* SOURCED! (see build-llvm.sh in the VM) |
| 5 | |||
| 7 | pmbaty | 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 | |||
| 13 | pmbaty | 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) |
| 7 | pmbaty | 15 | export LLVM_SOURCES_FILE="llvmorg-${LLVM_VERSION}.tar.gz" # name of the file containing LLVM version LLVM_VERSION sources |
| 2 | pmbaty | 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 | |||
| 21 | pmbaty | 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") |
| 14 | pmbaty | 20 | export LLVM_RUNTIMES_TO_BUILD="compiler-rt" # semicolon-separated list of LLVM runtimes to build (full list: "compiler-rt;libc;libcxx;libcxxabi;libunwind;openmp") |
| 13 | pmbaty | 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 | |||
| 2 | pmbaty | 25 | # see where we are |
| 26 | export CURRENT_DIR="$(pwd)" |
||
| 27 | |||
| 13 | pmbaty | 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 |
||
| 2 | pmbaty | 32 | echo "" |
| 13 | pmbaty | 33 | while [ -n "${1}" ]; do |
| 34 | echo "${1}"|fold -s -w "${COLUMNS}" |
||
| 35 | shift |
||
| 36 | done |
||
| 2 | pmbaty | 37 | echo "" |
| 38 | exit 1 |
||
| 13 | pmbaty | 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." |
||
| 2 | pmbaty | 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 |
||
| 19 | pmbaty | 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." |
| 2 | pmbaty | 49 | fi |
| 50 | |||
| 13 | pmbaty | 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 |
||
| 2 | pmbaty | 59 | |
| 20 | pmbaty | 60 | # verify that the symlinks are deployed in the SDK -- just test one of them in each relevant directory ($QNX_HOST for the tools, $QNX_TARGET for the sysroot) |
| 61 | if [ ! -e "${QNXSDK_PATH}/${QNXSDK_HOSTPATH}/usr/bin/gcc" ] || [ ! -e "${QNXSDK_PATH}/${QNXSDK_TARGETPATH}/usr/include/readline.h" ]; then |
||
| 13 | pmbaty | 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." |
||
| 2 | pmbaty | 71 | fi |
| 72 | |||
| 27 | pmbaty | 73 | # change to an immediately visible path, i.e. the user's desktop (failsafe to $HOME if xdg-user-dir is unavailable or points to a nonexistent directory) |
| 74 | STAGING_PATH="$(xdg-user-dir DESKTOP 2>/dev/null || echo "${HOME}")" |
||
| 75 | test -d "${STAGING_PATH}" || STAGING_PATH="${HOME}" |
||
| 76 | cd "${STAGING_PATH}" |
||
| 77 | |||
| 25 | pmbaty | 78 | # are we running the Windows Subsystem for Linux, instead of a real Linux ? |
| 79 | if [ -n "${WSL_DISTRO_NAME}" ]; then |
||
| 80 | # yes. In order to avoid the horrible 9p protocol for file interchange between NTFS and ext4 (a remarkably bad idea by Microsoft), |
||
| 81 | # have a copy of $QNX_HOST and $QNX_TARGET in the WSL2 filesystem. The speed gain is considerable. |
||
| 26 | pmbaty | 82 | # NOTE: we do this all over each time the mtime of these directories change, so BEWARE! |
| 27 | pmbaty | 83 | QNXSDK_CANONICAL_PATH="~/$(basename "${QNXSDK_PATH}")" |
| 84 | if [ ! -d "${QNXSDK_CANONICAL_PATH}/${QNXSDK_HOSTPATH}" ] || [ "${CURRENT_DIR}/${QNXSDK_PATH}/${QNXSDK_HOSTPATH}" -nt "${QNXSDK_CANONICAL_PATH}/${QNXSDK_HOSTPATH}" ]; then |
||
| 85 | mkdir -p "$(dirname "${QNXSDK_CANONICAL_PATH}/${QNXSDK_HOSTPATH}")" 2>/dev/null |
||
| 25 | pmbaty | 86 | echo "Deploying QNX ${QNXSDK_VERSION} HOST SDK to WSL2 ext4 filesystem, please wait..." |
| 27 | pmbaty | 87 | echo "This operation *WILL* take time, but is only done once - as long as this QNX SDP directory doesn't change and that your WSL's /tmp directory is preserved." |
| 88 | cp -R "${CURRENT_DIR}/${QNXSDK_PATH}/${QNXSDK_HOSTPATH}" "$(dirname "${QNXSDK_CANONICAL_PATH}/${QNXSDK_HOSTPATH}")" || exit 1 |
||
| 25 | pmbaty | 89 | fi |
| 27 | pmbaty | 90 | if [ ! -d "${QNXSDK_CANONICAL_PATH}/${QNXSDK_TARGETPATH}" ] || [ "${CURRENT_DIR}/${QNXSDK_PATH}/${QNXSDK_TARGETPATH}" -nt "${QNXSDK_CANONICAL_PATH}/${QNXSDK_TARGETPATH}" ]; then |
| 91 | mkdir -p "$(dirname "${QNXSDK_CANONICAL_PATH}/${QNXSDK_TARGETPATH}")" 2>/dev/null |
||
| 25 | pmbaty | 92 | echo "Deploying QNX ${QNXSDK_VERSION} TARGET SDK to WSL2 ext4 filesystem, please wait..." |
| 27 | pmbaty | 93 | echo "This operation *WILL* take time, but is only done once - as long as this QNX SDP directory doesn't change and that your WSL /tmp directory is preserved." |
| 94 | cp -R "${CURRENT_DIR}/${QNXSDK_PATH}/${QNXSDK_TARGETPATH}" "$(dirname "${QNXSDK_CANONICAL_PATH}/${QNXSDK_TARGETPATH}")" || exit 1 |
||
| 25 | pmbaty | 95 | fi |
| 96 | else |
||
| 27 | pmbaty | 97 | # we're not in WSL. We can expect reasonably good file access speeds to the QNX SDP that's bundled with this repository. |
| 98 | QNXSDK_CANONICAL_PATH="$(realpath "${CURRENT_DIR}/${QNXSDK_PATH}")" |
||
| 7 | pmbaty | 99 | fi |
| 2 | pmbaty | 100 | |
| 27 | pmbaty | 101 | # 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 |
| 102 | # (this is totally prohibitive with the official QNX toolchain) |
||
| 103 | if [ ! -L /tmp/qnxsdk ] || [ ! "$(readlink /tmp/qnxsdk)" = "${QNXSDK_CANONICAL_PATH}" ]; then |
||
| 104 | echo "Creating symlink to QNX toolchain in /tmp/qnxsdk..." |
||
| 105 | rm -rf /tmp/qnxsdk 2>/dev/null |
||
| 106 | ln -fs "${QNXSDK_CANONICAL_PATH}" /tmp/qnxsdk || exit 1 |
||
| 107 | fi |
||
| 108 | |||
| 2 | pmbaty | 109 | # setup the environment |
| 110 | export QNX_HOST="/tmp/qnxsdk/${QNXSDK_HOSTPATH}" |
||
| 111 | export QNX_TARGET="/tmp/qnxsdk/${QNXSDK_TARGETPATH}" |
||
| 112 | export MAKEFLAGS="-I${QNX_TARGET}/usr/include" |
||
| 113 | export PATH="${QNX_HOST}/usr/bin:${PATH}" |
||
| 114 | |||
| 13 | pmbaty | 115 | # print the build environment |
| 116 | echo "QNX_HOST=${QNX_HOST}" |
||
| 117 | echo "QNX_TARGET=${QNX_TARGET}" |
||
| 118 | echo "MAKEFLAGS=${MAKEFLAGS}" |
||
| 119 | |||
| 120 | # construct the target triple (actually a quadruple) |
||
| 121 | export TARGET_ARCH="${BUILD_TARGET_ARCH}" |
||
| 122 | test "${BUILD_TARGET_ARCH}" = "x86_64" && export TARGET_VENDOR="pc" || export TARGET_VENDOR="unknown" |
||
| 123 | export TARGET_KERNEL="nto" |
||
| 124 | export TARGET_SYSTEM="qnx${QNXSDK_VERSION}" |
||
| 125 | export TARGET_TRIPLE="${TARGET_ARCH}-${TARGET_VENDOR}-${TARGET_KERNEL}-${TARGET_SYSTEM}" |
||
| 126 | echo "Will build for ${TARGET_TRIPLE}" |
||
| 127 | |||
| 10 | pmbaty | 128 | # download the involved source packages and unpack them if not done yet |
| 129 | download_and_unpack_if_necessary() |
||
| 130 | { |
||
| 131 | # helper function that downloads a sources tarball, extracts it and patches it if necessary |
||
| 11 | pmbaty | 132 | # args: <sources dirname> <sources filename> <download URL> [optional patchset URL] |
| 133 | test -d "${1}" && return 0 # if sources directory already exists, nothing to do |
||
| 134 | if [ ! -s "${CURRENT_DIR}/${2}" ]; then # if sources archive isn't a nonempty file... |
||
| 135 | echo "Downloading ${1} sources from ${3}..." |
||
| 136 | if ! wget -O "${CURRENT_DIR}/${2}" "${3}"; then |
||
| 137 | # remove output file in case an error occurs |
||
| 138 | rm -f "${CURRENT_DIR}/${2}" |
||
| 10 | pmbaty | 139 | exit 1 |
| 140 | fi |
||
| 141 | fi |
||
| 11 | pmbaty | 142 | echo "Extracting ${1} sources..." |
| 143 | cd "$(dirname "${1}")" |
||
| 144 | if echo "${2}"|grep -q "\.tar\.bz2$"; then |
||
| 145 | # BZip2 tarball |
||
| 146 | tar xjf "${CURRENT_DIR}/${2}" || exit 1 |
||
| 147 | elif echo "${2}"|grep -q "\.tar\.xz$"; then |
||
| 148 | # XZ tarball |
||
| 149 | tar xJf "${CURRENT_DIR}/${2}" || exit 1 |
||
| 150 | elif echo "${2}"|grep -q "\.tar\.gz$"; then |
||
| 151 | # GZipped tarball |
||
| 152 | tar xzf "${CURRENT_DIR}/${2}" || exit 1 |
||
| 153 | else |
||
| 13 | pmbaty | 154 | print_error_and_die "Error: unsupported file extension. Please improve the download_and_unpack_if_necessary() shell function to support it." |
| 11 | pmbaty | 155 | fi |
| 156 | # make sure the expected directory is here after extraction |
||
| 157 | if [ ! -d "${1}" ]; then |
||
| 13 | pmbaty | 158 | print_error_and_die "Error: couldn't find ${1} in extracted sources." |
| 11 | pmbaty | 159 | fi |
| 160 | # do we have a patchset to apply ? |
||
| 161 | if [ -n "${4}" ]; then |
||
| 162 | echo "Downloading ${1} patchset from ${4}..." |
||
| 163 | wget -O "${CURRENT_DIR}/${2}.patchset" "${4}" || exit 1 |
||
| 164 | echo "Applying patchset..." |
||
| 165 | OLDDIR="$(pwd)" |
||
| 166 | cd "${1}" |
||
| 167 | patch -N -Z -p1 < "${CURRENT_DIR}/${2}.patchset" || exit 1 |
||
| 168 | cd "${OLDDIR}" |
||
| 169 | unset OLDDIR |
||
| 170 | fi |
||
| 10 | pmbaty | 171 | return 0 |
| 172 | } |
||
| 173 | download_and_unpack_if_necessary "${LLVM_SOURCES_DIR}" "${LLVM_SOURCES_FILE}" "${LLVM_SOURCES_URL}" || exit 1 |
||
| 174 | |||
| 2 | pmbaty | 175 | # create the build directory |
| 176 | echo "Wiping out build directory..." |
||
| 177 | test -e "${BUILD_DIR_NAME}" && rm -rf "${BUILD_DIR_NAME}" |
||
| 178 | mkdir "${BUILD_DIR_NAME}" || exit 1 |
||
| 179 | cd "${BUILD_DIR_NAME}" || exit 1 |
||
| 180 | |||
| 181 | # create the QNX CMake toolchain file |
||
| 8 | pmbaty | 182 | test -e "${TARGET_TRIPLE}.cmake" || echo '# '${TARGET_TRIPLE}' CMake toolchain file by Pierre-Marie Baty <pm@pmbaty.com> |
| 2 | pmbaty | 183 | |
| 184 | SET(CMAKE_SYSTEM_NAME "QNX") |
||
| 7 | pmbaty | 185 | SET(CMAKE_SYSTEM_VERSION "'${QNXSDK_VERSION}'") |
| 2 | pmbaty | 186 | |
| 187 | SET(QNX "1") |
||
| 188 | SET(QNXNTO "1") |
||
| 189 | SET(QNX_HOST "$ENV{QNX_HOST}") |
||
| 190 | SET(QNX_TARGET "$ENV{QNX_TARGET}") |
||
| 191 | SET(QNX_PROCESSOR "'${TARGET_ARCH}'") |
||
| 192 | |||
| 193 | SET(CMAKE_ASM_COMPILER "${QNX_HOST}/usr/bin/'${TARGET_TRIPLE}'-gcc") |
||
| 194 | SET(CMAKE_ASM_COMPILER_TARGET "gcc_nto${QNX_PROCESSOR}") |
||
| 195 | |||
| 196 | SET(CMAKE_C_COMPILER "${QNX_HOST}/usr/bin/'${TARGET_TRIPLE}'-gcc") |
||
| 197 | SET(CMAKE_C_COMPILER_TARGET "gcc_nto${QNX_PROCESSOR}") |
||
| 198 | SET(CMAKE_C_FLAGS_DEBUG "-g") |
||
| 199 | SET(CMAKE_C_FLAGS_MINSIZEREL "-Os -DNDEBUG") |
||
| 200 | SET(CMAKE_C_FLAGS_RELEASE "-O3 -DNDEBUG") |
||
| 201 | SET(CMAKE_C_FLAGS_RELWITHDEBINFO "-O2 -g") |
||
| 7 | pmbaty | 202 | 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") |
| 2 | pmbaty | 203 | |
| 204 | SET(CMAKE_CXX_COMPILER "${QNX_HOST}/usr/bin/'${TARGET_TRIPLE}'-g++") |
||
| 205 | SET(CMAKE_CXX_COMPILER_TARGET "gcc_nto${QNX_PROCESSOR}") |
||
| 206 | SET(CMAKE_CXX_FLAGS_DEBUG "-g") |
||
| 207 | SET(CMAKE_CXX_FLAGS_MINSIZEREL "-Os -DNDEBUG") |
||
| 208 | SET(CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG") |
||
| 209 | SET(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g") |
||
| 7 | pmbaty | 210 | 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") |
| 2 | pmbaty | 211 | |
| 212 | SET(CMAKE_LINKER "${QNX_HOST}/usr/bin/'${TARGET_TRIPLE}'-ld.bfd") |
||
| 4 | pmbaty | 213 | SET(CMAKE_SHARED_LINKER_FLAGS "-lsocket") |
| 2 | pmbaty | 214 | SET(CMAKE_EXE_LINKER_FLAGS "-lsocket") |
| 215 | |||
| 216 | SET(CMAKE_RANLIB "${QNX_HOST}/usr/bin/'${TARGET_TRIPLE}'-ranlib") |
||
| 217 | |||
| 7 | pmbaty | 218 | SET(CMAKE_NM "${QNX_HOST}/usr/bin/'${TARGET_TRIPLE}'-nm") |
| 219 | |||
| 2 | pmbaty | 220 | SET(CMAKE_AR "${QNX_HOST}/usr/bin/'${TARGET_TRIPLE}'-ar") |
| 221 | |||
| 222 | SET(CMAKE_FIND_ROOT_PATH "${QNX_TARGET}") |
||
| 223 | SET(CMAKE_FIND_ROOT_PATH_HOST_PROGRAM NEVER) |
||
| 224 | SET(CMAKE_FIND_ROOT_PATH_HOST_LIBRARY ONLY) |
||
| 225 | SET(CMAKE_FIND_ROOT_PATH_HOST_INCLUDE ONLY) |
||
| 226 | ' > "${TARGET_TRIPLE}.cmake" |
||
| 227 | |||
| 7 | pmbaty | 228 | backup_and_patch_if_necessary() |
| 229 | { |
||
| 230 | # handy function that patches a file in LLVM_SOURCES_DIR with a given sed replacement regex if necessary, creating backups |
||
| 11 | pmbaty | 231 | # args: <file pathname> <grep_string_to_test_for_presence_of_patch> <sed regex> [<second regex> [...]] |
| 232 | _PATCHEE_PATHNAME="${1}" |
||
| 233 | _PATCHED_PATTERN="${2}" |
||
| 7 | pmbaty | 234 | # test if already patched |
| 11 | pmbaty | 235 | grep -q "${_PATCHED_PATTERN}" "../${LLVM_SOURCES_DIR}/${_PATCHEE_PATHNAME}" && return |
| 7 | pmbaty | 236 | # tell what we're about to do |
| 11 | pmbaty | 237 | echo "Patching ${_PATCHEE_PATHNAME}..." |
| 238 | _DOTTED_NAME="$(echo "${_PATCHEE_PATHNAME}"|tr '/' '.')" |
||
| 7 | pmbaty | 239 | # have a backup first |
| 11 | pmbaty | 240 | test -f "${CURRENT_DIR}/${_DOTTED_NAME} [ORIGINAL]" || cp "../${LLVM_SOURCES_DIR}/${_PATCHEE_PATHNAME}" "${CURRENT_DIR}/${_DOTTED_NAME} [ORIGINAL]" || exit 1 |
| 7 | pmbaty | 241 | # perform the patch |
| 11 | pmbaty | 242 | cp -f "${CURRENT_DIR}/${_DOTTED_NAME} [ORIGINAL]" "${CURRENT_DIR}/${_DOTTED_NAME} [PATCHED]" || exit 1 |
| 243 | while [ -n "${3}" ]; do |
||
| 244 | sed -E -i "${3}" "${CURRENT_DIR}/${_DOTTED_NAME} [PATCHED]" |
||
| 245 | shift |
||
| 246 | done |
||
| 7 | pmbaty | 247 | # verify that we did it successfully |
| 11 | pmbaty | 248 | if ! grep -q "${_PATCHED_PATTERN}" "${CURRENT_DIR}/${_DOTTED_NAME} [PATCHED]"; then |
| 13 | pmbaty | 249 | print_error_and_die "Error: the file ${_PATCHEE_PATHNAME} could not be patched. Please investigate and fix manually." |
| 7 | pmbaty | 250 | fi |
| 251 | # and put the patched file in place |
||
| 11 | pmbaty | 252 | cp -f "${CURRENT_DIR}/${_DOTTED_NAME} [PATCHED]" "../${LLVM_SOURCES_DIR}/${_PATCHEE_PATHNAME}" || exit 1 |
| 7 | pmbaty | 253 | } |
| 254 | |||
| 13 | pmbaty | 255 | # patch llvm/lib/Support/Unix/Path.inc if not done yet |
| 256 | # replace: |
||
| 257 | # defined(__FreeBSD_kernel__) |
||
| 258 | # with: |
||
| 259 | # (defined(__FreeBSD_kernel__) || defined(__QNXNTO__)) |
||
| 7 | pmbaty | 260 | # 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. |
| 261 | # 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, |
||
| 262 | # 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). |
||
| 263 | # 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 |
||
| 264 | # 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. |
||
| 265 | # 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. |
||
| 266 | # FIXME: these hacks should be moved elsewhere not to pollute the QNX8 platform SDK -- it *SHOULD* be possible to build without devs |
||
| 11 | pmbaty | 267 | backup_and_patch_if_necessary "llvm/lib/Support/Unix/Path.inc" __QNXNTO__ \ |
| 13 | pmbaty | 268 | 's@defined\(__FreeBSD_kernel__\)@\(defined\(__FreeBSD_kernel__\) \|\| \defined\(__QNXNTO__\)\)@g' |
| 6 | pmbaty | 269 | |
| 22 | pmbaty | 270 | # -- 20240621 -- DISABLED -- the only other place (aside from llvm/lib/Support) where getMainExecutable() is defined is in ClangLinkerWrapper.cpp which is the LLD wrapper frontend. |
| 271 | # -- 20240621 -- DISABLED -- actually llvm/lib/Support/Unix/Path.inc defines *getMainExecutableImpl* and not getMainExecutable, despite what the function comments say. So the code is right. |
||
| 272 | # -- 20240621 -- DISABLED -- This block can be removed after a few successful thorough rebuilds. |
||
| 273 | ## LLVM 16: patch llvm/lib/Support/Path.cpp if not done yet |
||
| 274 | ## replace: |
||
| 275 | ## std::string getMainExecutable |
||
| 276 | ## with: |
||
| 277 | ## #if 0 |
||
| 278 | ## std::string getMainExecutable |
||
| 279 | ## and: |
||
| 280 | ## TempFile::TempFile(StringRef Name, int FD) |
||
| 281 | ## with: |
||
| 282 | ## #endif |
||
| 283 | ## TempFile::TempFile(StringRef Name, int FD) |
||
| 284 | ## 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? |
||
| 285 | ## 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. |
||
| 286 | ## This patch restores a working state (ante D109977). |
||
| 287 | #test "$(echo "${LLVM_VERSION}"|cut -d . -f 1)" -lt 17 && backup_and_patch_if_necessary "llvm/lib/Support/Path.cpp" "#if 0" \ |
||
| 288 | # 's@std::string getMainExecutable@#if 0\nstd::string getMainExecutable@' \ |
||
| 289 | # 's@TempFile::TempFile\(StringRef Name, int FD\)@#endif\nTempFile::TempFile\(StringRef Name, int FD\)@' |
||
| 6 | pmbaty | 290 | |
| 16 | pmbaty | 291 | # Clang front-end patches |
| 292 | if echo "${LLVM_PROJECTS_TO_BUILD}"|tr ';' '\n'|grep -q "clang"; then |
||
| 293 | |||
| 294 | # patch clang/lib/Frontend/InitPreprocessor.cpp |
||
| 295 | # replace: |
||
| 296 | # TI.getTargetDefines(LangOpts, Builder); |
||
| 297 | # with: |
||
| 298 | # TI.getTargetDefines(LangOpts, Builder); |
||
| 299 | # #ifdef __QNXNTO__ |
||
| 300 | # Builder.defineMacro("__QNXNTO__", "1"); |
||
| 301 | # Builder.defineMacro("__QNX__", "800"); // <-- set to QNX SDK version, without the intermediary dots |
||
| 18 | pmbaty | 302 | # Builder.defineMacro("__X86_64__", "1"); // <-- set to either __X86_64__ or __AARCH64EL__ depending on the build target |
| 16 | pmbaty | 303 | # Builder.defineMacro("__LITTLEENDIAN__", "1"); |
| 304 | # Builder.defineMacro("__ELF__", "1"); |
||
| 305 | # #endif |
||
| 306 | # RATIONALE: this adds the QNX-specific implicit preprocessor definitions. This is not the orthodox way of doing it. But we're in a hurry. |
||
| 18 | pmbaty | 307 | test "${BUILD_TARGET_ARCH}" = "x86_64" && PLATORM_NATIVE_ARCH_DEFINE="__X86_64__" || PLATORM_NATIVE_ARCH_DEFINE="__AARCH64EL__" |
| 16 | pmbaty | 308 | backup_and_patch_if_necessary "clang/lib/Frontend/InitPreprocessor.cpp" __QNXNTO__ \ |
| 18 | pmbaty | 309 | 's@TI\.getTargetDefines\(LangOpts, Builder\);@TI\.getTargetDefines\(LangOpts, Builder\);\n#ifdef __QNXNTO__\n Builder.defineMacro\("__QNXNTO__", "1"\);\n Builder.defineMacro("__QNX__", "'$(echo "${QNXSDK_VERSION}"|tr -d '.')'");\n Builder.defineMacro\("'${PLATORM_NATIVE_ARCH_DEFINE}'", "1"\);\n Builder.defineMacro\("__LITTLEENDIAN__", "1"\);\n Builder.defineMacro\("__ELF__", "1"\);\n#endif@' |
| 16 | pmbaty | 310 | fi |
| 311 | |||
| 13 | pmbaty | 312 | # LLDB patches |
| 313 | if echo "${LLVM_PROJECTS_TO_BUILD}"|tr ';' '\n'|grep -q "lldb"; then |
||
| 6 | pmbaty | 314 | |
| 13 | pmbaty | 315 | # patch lldb/Source/Host/common/Host.cpp if not done yet |
| 316 | # replace: |
||
| 317 | # defined(SIGINFO) |
||
| 318 | # with: |
||
| 319 | # (defined(SIGINFO) && !defined(__QNXNTO__)) |
||
| 320 | # 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, |
||
| 321 | # 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 |
||
| 322 | # 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, |
||
| 323 | # 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 |
||
| 324 | # expect the value of SIGUSR1 for SIGINFO. |
||
| 325 | backup_and_patch_if_necessary "lldb/source/Host/common/Host.cpp" __QNXNTO__ \ |
||
| 326 | 's@defined\(SIGINFO\)@\(defined\(SIGINFO\) \&\& \!defined\(__QNXNTO__\)\)@g' |
||
| 327 | |||
| 328 | # FIXME: another patch is needed for LLDB. Basically, the ptrace() POSIX system call doesn't exist on QNX. Instead |
||
| 329 | # QNX use their own debug utility: pdebug. Note the /proc filesystem can be used to access a debuggee's virtual memory space. |
||
| 330 | # in lldb/source/Host/posix/ProcessLauncherPosixFork.cpp line 196: |
||
| 331 | # if (ptrace(PT_TRACE_ME, 0, nullptr, 0) == -1) // <--- undefined: ptrace, PT_TRACE_ME |
||
| 332 | fi |
||
| 6 | pmbaty | 333 | |
| 13 | pmbaty | 334 | # compiler-rt patches |
| 335 | if echo "${LLVM_RUNTIMES_TO_BUILD}"|tr ';' '\n'|grep -q "compiler-rt"; then |
||
| 6 | pmbaty | 336 | |
| 13 | pmbaty | 337 | # patch compiler-rt/lib/builtins/enable_execute_stack.c if not done yet |
| 338 | # replace: |
||
| 339 | # #include "int_lib.h" |
||
| 340 | # with: |
||
| 341 | # #ifdef __QNXNTO__ |
||
| 342 | # #define _QNX_SOURCE 1 |
||
| 343 | # #endif |
||
| 344 | # #include "int_lib.h" |
||
| 345 | # 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. |
||
| 346 | # 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. |
||
| 347 | # 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 |
||
| 348 | # when building compiler-rt specifically, the CMAKE_C_FLAGS directive is ignored. Patching the source file seems like the best option to fix that. |
||
| 349 | backup_and_patch_if_necessary "compiler-rt/lib/builtins/enable_execute_stack.c" __QNXNTO__ \ |
||
| 350 | 's@#include "int_lib.h"@#ifdef __QNXNTO__\n#define _QNX_SOURCE 1\n#endif\n#include "int_lib.h"@' |
||
| 8 | pmbaty | 351 | |
| 13 | pmbaty | 352 | # patch compiler-rt/lib/profile/InstrProfilingUtil.c |
| 353 | # replace: |
||
| 354 | # #include <sys/mman.h> |
||
| 355 | # with: |
||
| 356 | # #ifdef __QNXNTO__ |
||
| 357 | # #include <devs/sys/mman.h> |
||
| 358 | # #endif |
||
| 359 | # #include <sys/mman.h> |
||
| 360 | # 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 |
||
| 361 | # 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. |
||
| 362 | backup_and_patch_if_necessary "compiler-rt/lib/profile/InstrProfilingUtil.c" __QNXNTO__ \ |
||
| 363 | 's@#include <sys/mman.h>@#ifdef __QNXNTO__\n#include <devs/sys/mman.h>\n#endif\n#include <sys/mman.h>@' |
||
| 10 | pmbaty | 364 | |
| 13 | pmbaty | 365 | # patch compiler-rt/lib/orc/endianness.h |
| 366 | # replace: |
||
| 367 | # #elif defined(__MVS__) |
||
| 368 | # with: |
||
| 369 | # #elif defined(__QNXNTO__) |
||
| 370 | # #define BYTE_ORDER __BYTE_ORDER__ |
||
| 371 | # #elif defined(__MVS__) |
||
| 372 | # 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) |
||
| 373 | # 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. |
||
| 374 | backup_and_patch_if_necessary "compiler-rt/lib/orc/endianness.h" __QNXNTO__ \ |
||
| 375 | 's@#elif defined\(__MVS__\)@#elif defined\(__QNXNTO__\)\n#define BYTE_ORDER __BYTE_ORDER__\n#elif defined\(__MVS__\)@' |
||
| 376 | fi |
||
| 11 | pmbaty | 377 | |
| 13 | pmbaty | 378 | # libunwind patches |
| 379 | if echo "${LLVM_RUNTIMES_TO_BUILD}"|tr ';' '\n'|grep -q "libunwind"; then |
||
| 11 | pmbaty | 380 | |
| 13 | pmbaty | 381 | # patch libunwind/src/libunwind.cpp |
| 382 | # replace: |
||
| 383 | # #include <libunwind.h>: |
||
| 384 | # with: |
||
| 385 | # #ifdef __QNXNTO__ |
||
| 386 | # #define _QNX_SOURCE 1 |
||
| 387 | # #endif |
||
| 388 | # #include <libunwind.h> |
||
| 389 | # RATIONALE: the pthreads implementation in QNX 'steals' things from the POSIX.1 standard and hides them behind the __EXT_QNX macro, |
||
| 390 | # which is defined when either _QNX_SOURCE or __EXT without anything else is defined. This is not correct and low-level libraries |
||
| 391 | # 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 |
||
| 392 | # platform SDK: /usr/include/link.h, which defines Elf types as Elf64/Elf32 types depending on the architecture and adds some glue. |
||
| 393 | backup_and_patch_if_necessary "libunwind/src/libunwind.cpp" __QNXNTO__ \ |
||
| 394 | 's@#include <libunwind.h>@#ifdef __QNXNTO__\n#define _QNX_SOURCE 1\n#endif\n#include <libunwind.h>@' |
||
| 395 | fi |
||
| 11 | pmbaty | 396 | |
| 13 | pmbaty | 397 | # libc++ patches |
| 398 | if echo "${LLVM_PROJECTS_TO_BUILD}"|tr ';' '\n'|grep -q "libcxx"; then |
||
| 12 | pmbaty | 399 | |
| 13 | pmbaty | 400 | # patch libcxx/include/__config |
| 401 | # replace: |
||
| 402 | # # define _LIBCPP_HAS_THREAD_API_WIN32 |
||
| 403 | # with: |
||
| 404 | # # define _LIBCPP_HAS_THREAD_API_WIN32 |
||
| 405 | # # elif defined(__QNXNTO__) |
||
| 406 | # # define _LIBCPP_HAS_THREAD_API_PTHREAD |
||
| 407 | # # define _LIBCPP_HAS_COND_CLOCKWAIT |
||
| 408 | # # define _LIBCPP_HAS_CLOCK_GETTIME |
||
| 409 | # 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 |
||
| 410 | # 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). |
||
| 411 | backup_and_patch_if_necessary "libcxx/include/__config" __QNXNTO__ \ |
||
| 412 | '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@' |
||
| 413 | |||
| 414 | # patch libcxx/include/__locale |
||
| 415 | # replace: |
||
| 416 | # # include <__support/openbsd/xlocale.h> |
||
| 417 | # with: |
||
| 418 | # # include <__support/openbsd/xlocale.h> |
||
| 419 | # #elif defined(__QNXNTO__) |
||
| 420 | # # include <__support/qnx/xlocale.h> |
||
| 421 | # and: |
||
| 422 | # #elif defined(__MVS__) |
||
| 423 | # with: |
||
| 424 | # #elif defined(__QNXNTO__) |
||
| 425 | # typedef short mask; |
||
| 426 | # static const mask space = (_CN|_SP|_XS); |
||
| 427 | # static const mask print = (_DI|_LO|_PU|_SP|_UP|_XA); |
||
| 428 | # static const mask cntrl = _BB; |
||
| 429 | # static const mask upper = _UP; |
||
| 430 | # static const mask lower = _LO; |
||
| 431 | # static const mask alpha = (_LO|_UP|_XA); |
||
| 432 | # static const mask digit = _DI; |
||
| 433 | # static const mask punct = _PU; |
||
| 434 | # static const mask xdigit = _XD; |
||
| 435 | # static const mask blank = (_SP|_XB); |
||
| 436 | # static const mask __regex_word = 0x1000; |
||
| 437 | # #elif defined(__MVS__) |
||
| 438 | # RATIONALE: add QNX-specific locale C++ bindings and definitions |
||
| 439 | backup_and_patch_if_necessary "libcxx/include/__locale" __QNXNTO__ \ |
||
| 440 | 's@# include <__support/openbsd/xlocale.h>@# include <__support/openbsd/xlocale.h>\n#elif defined\(__QNXNTO__\)\n# include <__support/qnx/xlocale.h>@' \ |
||
| 441 | '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__\)@' |
||
| 442 | |||
| 443 | # patch libcxx/include/CMakeLists.txt |
||
| 444 | # replace: |
||
| 445 | # __support/openbsd/xlocale.h |
||
| 446 | # with: |
||
| 447 | # __support/openbsd/xlocale.h |
||
| 448 | # __support/qnx/xlocale.h |
||
| 449 | # RATIONALE: add QNX-specific locale C++ bindings and definitions |
||
| 450 | backup_and_patch_if_necessary "libcxx/include/CMakeLists.txt" qnx/xlocale.h \ |
||
| 451 | 's@ __support/openbsd/xlocale.h@ __support/openbsd/xlocale.h\n __support/qnx/xlocale.h@' |
||
| 452 | |||
| 453 | # add __support/qnx/xlocale.h to the libc++ source tree |
||
| 454 | # RATIONALE: add QNX-specific locale C++ bindings and definitions |
||
| 455 | test -d "../${LLVM_SOURCES_DIR}/libcxx/include/__support/qnx" || mkdir "../${LLVM_SOURCES_DIR}/libcxx/include/__support/qnx" || exit 1 |
||
| 456 | 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 |
||
| 457 | |||
| 458 | # patch libcxx/include/locale |
||
| 459 | # replace: |
||
| 460 | # !defined(__BIONIC__) && !defined(_NEWLIB_VERSION) && !defined(__EMSCRIPTEN__) |
||
| 461 | # with: |
||
| 462 | # !defined(__BIONIC__) && !defined(_NEWLIB_VERSION) && !defined(__EMSCRIPTEN__) && !defined(__QNXNTO__) |
||
| 463 | # RATIONALE: QNX doesn't have catopen() to open a "message catalog" |
||
| 464 | backup_and_patch_if_necessary "libcxx/include/locale" __QNXNTO__ \ |
||
| 465 | 's@\!defined\(__BIONIC__\) \&\& \!defined\(_NEWLIB_VERSION\) \&\& \!defined\(__EMSCRIPTEN__\)@!defined\(__BIONIC__\) \&\& !defined\(_NEWLIB_VERSION\) \&\& !defined\(__EMSCRIPTEN__\) \&\& !defined\(__QNXNTO__\)@' |
||
| 466 | |||
| 467 | # patch libcxx/include/setjmp.h |
||
| 468 | # replace: |
||
| 469 | # #endif // __cplusplus |
||
| 470 | # with: |
||
| 471 | # #ifdef __QNXNTO__ |
||
| 472 | # #undef longjmp |
||
| 473 | # [[noreturn]] inline void longjmp(jmp_buf env, int val) { ::siglongjmp(env, val); } |
||
| 474 | # #endif // __QNXNTO__ |
||
| 475 | # |
||
| 476 | # #endif // __cplusplus |
||
| 477 | # 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) |
||
| 478 | # 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 !? |
||
| 479 | backup_and_patch_if_necessary "libcxx/include/setjmp.h" __QNXNTO__ \ |
||
| 480 | '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@' |
||
| 481 | fi |
||
| 12 | pmbaty | 482 | |
| 13 | pmbaty | 483 | # polly patches |
| 484 | if echo "${LLVM_PROJECTS_TO_BUILD}"|tr ';' '\n'|grep -q "polly"; then |
||
| 485 | |||
| 486 | # patch polly/lib/External/isl/imath/imath.c |
||
| 487 | # replace: |
||
| 488 | # /* Select min/max. */ |
||
| 489 | # with: |
||
| 490 | # #ifdef __QNXNTO__ |
||
| 491 | # #undef MIN |
||
| 492 | # #undef MAX |
||
| 493 | # #endif // __QNXNTO__ |
||
| 494 | # /* Select min/max. */ |
||
| 495 | # 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. |
||
| 496 | backup_and_patch_if_necessary "polly/lib/External/isl/imath/imath.c" __QNXNTO__ \ |
||
| 497 | 's@\/\* Select min\/max. \*\/@#ifdef __QNXNTO__\n#undef MIN\n#undef MAX\n#endif\n\/\* Select min\/max. \*\/@' |
||
| 498 | fi |
||
| 499 | |||
| 500 | # now configure LLVM... |
||
| 2 | pmbaty | 501 | echo "Configuring LLVM build..." |
| 9 | pmbaty | 502 | export CCACHE_DIR="$(realpath "../${LLVM_SOURCES_DIR}/.ccache")" |
| 2 | pmbaty | 503 | cmake \ |
| 504 | -D CMAKE_TOOLCHAIN_FILE="${TARGET_TRIPLE}.cmake" \ |
||
| 13 | pmbaty | 505 | -D CMAKE_BUILD_TYPE="${LLVM_BUILD_CONFIGURATION_TYPE}" \ |
| 506 | -D CMAKE_INSTALL_PREFIX="/usr/bin" \ |
||
| 507 | -D CMAKE_STAGING_PREFIX="${CURRENT_DIR}/llvm-build/${BUILD_TARGET_ARCH}" \ |
||
| 9 | pmbaty | 508 | -D CMAKE_C_COMPILER_LAUNCHER="ccache" \ |
| 509 | -D CMAKE_CXX_COMPILER_LAUNCHER="ccache" \ |
||
| 2 | pmbaty | 510 | -D LLVM_HOST_TRIPLE="${TARGET_TRIPLE}" \ |
| 13 | pmbaty | 511 | -D LLVM_ENABLE_PROJECTS="${LLVM_PROJECTS_TO_BUILD}" \ |
| 512 | -D LLVM_ENABLE_RUNTIMES="${LLVM_RUNTIMES_TO_BUILD}" \ |
||
| 2 | pmbaty | 513 | -D LLVM_TARGETS_TO_BUILD="AArch64;X86" \ |
| 16 | pmbaty | 514 | -D DEFAULT_SYSROOT="../../../../../${QNXSDK_TARGETPATH}/${BUILD_TARGET_ARCH}" \ |
| 515 | -D CLANG_DEFAULT_LINKER="lld" \ |
||
| 516 | -D CLANG_DEFAULT_CXX_STDLIB="libc++" \ |
||
| 8 | pmbaty | 517 | -D COMPILER_RT_BUILD_SANITIZERS="OFF" \ |
| 12 | pmbaty | 518 | -D COMPILER_RT_BUILD_XRAY="OFF" \ |
| 13 | pmbaty | 519 | -D COMPILER_RT_BUILD_MEMPROF="OFF" \ |
| 520 | -D COMPILER_RT_BUILD_LIBFUZZER="OFF" \ |
||
| 521 | -D COMPILER_RT_BUILD_PROFILE="OFF" \ |
||
| 2 | pmbaty | 522 | -G Ninja \ |
| 523 | "../${LLVM_SOURCES_DIR}/llvm" || exit 1 |
||
| 524 | |||
| 525 | # and do the Lord's work. https://youtu.be/jcyYmCnkbEE |
||
| 526 | echo "Building LLVM..." |
||
| 13 | pmbaty | 527 | cmake --build . --target install || exit 1 |
| 2 | pmbaty | 528 | |
| 13 | pmbaty | 529 | /bin/printf "\n\xF0\x9F\x8D\xBE\x20\x43\x68\x61\x6d\x70\x61\x67\x6e\x65\x2e\n" |
| 2 | pmbaty | 530 | exit 0 |
| 13 | pmbaty | 531 | |
| 532 | # TODO optional: port compiler_rt sanitizer bindings and build sanitizers, xray, memprof, libfuzzer and profile |
||
| 533 | # TODO optional: port lldb bindings and build lldb |