WebSVN – QNX 8.QNX8 LLVM/Clang compiler suite – Diff – /cross-build.sh

 #!/bin/sh
 # LLVM/Clang toolchain cross-compilation script for QNX 8.0 by Pierre-Marie Baty <pm@pmbaty.com>
 # NOTE TO SELF: DO NOT USE $0 AS THIS SCRIPT CAN BE RUN *OR* SOURCED! (see build-llvm.sh in the VM)
+export QNXSDK_VERSION="8.0.0" # version of the QNX SDK in use, in <major>.<minor>.<revision> format
-export QNXSDK_PATH="../qnx800"
+export QNXSDK_PATH="../qnx800" # relative location from the path of this script where to find the QNX platform SDK
-export QNXSDK_HOSTPATH="host/linux/x86_64"
+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
-export QNXSDK_TARGETPATH="target/qnx"
+export QNXSDK_TARGETPATH="target/qnx" # relative location in QNXSDK_PATH of the tree containing the QNX8 system header files
-export BUILD_DIR_NAME="llvm-build"
+export BUILD_DIR_NAME="llvm-build" # name of the directory on the build host's desktop where the LLVM sources will be built
+export BUILD_TARGET_ARCH="x86_64" # CPU architecture to build LLVM for, either "x86_64" or "aarch64"
-export LLVM_VERSION="18.1.4"
+export LLVM_VERSION="18.1.4" # version of LLVM that will be built
-export LLVM_SOURCES_FILE="llvmorg-${LLVM_VERSION}.tar.gz" # name of file containing LLVM version LLVM_VERSION sources
+export LLVM_SOURCES_FILE="llvmorg-${LLVM_VERSION}.tar.gz" # name of the file containing LLVM version LLVM_VERSION sources
 export LLVM_SOURCES_URL="https://github.com/llvm/llvm-project/archive/refs/tags/${LLVM_SOURCES_FILE}" # download URL of LLVM_SOURCES_FILE
 export LLVM_SOURCES_DIR="llvm-project-llvmorg-${LLVM_VERSION}" # name of directory created when extracting LLVM_SOURCES_FILE
-# target triple settings
-export TARGET_ARCH="x86_64"
-#export TARGET_ARCH="aarch64"
-test "${TARGET_ARCH}" = "x86_64" && export TARGET_VENDOR="pc" || export TARGET_VENDOR="unknown"
-export TARGET_KERNEL="nto"
-export TARGET_SYSTEM="qnx8.0.0"
 # see where we are
 export CURRENT_DIR="$(pwd)"
 # verify we're a x86_64 Linux host
 fi
 # verify that we have the QNX platform SDK
 if [ ! -d "${QNXSDK_PATH}/${QNXSDK_HOSTPATH}" ] || [ ! -d "${QNXSDK_PATH}/${QNXSDK_TARGETPATH}" ]; then
         echo ""
-        echo "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 ${TARGET_ARCH} platform. Please deploy these directories and try again." | fold -s -w 79
+        echo "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." | fold -s -w 79
         echo ""
         exit 1
 fi
 # verify that we have wget, python3, cmake, gcc, g++ and ninja
         echo ""
         exit 1
 fi
 # construct the target triple (actually a quadruple)
+export TARGET_ARCH="${BUILD_TARGET_ARCH}"
+test "${BUILD_TARGET_ARCH}" = "x86_64" && export TARGET_VENDOR="pc" || export TARGET_VENDOR="unknown"
+export TARGET_KERNEL="nto"
+export TARGET_SYSTEM="qnx${QNXSDK_VERSION}"
 export TARGET_TRIPLE="${TARGET_ARCH}-${TARGET_VENDOR}-${TARGET_KERNEL}-${TARGET_SYSTEM}"
 echo "Will build LLVM for ${TARGET_TRIPLE}"
-# change to an immediately visible path
+# change to an immediately visible path, i.e. the user's desktop (failsafe to $HOME if xdg-user-dir is unavailable)
+STAGING_PATH="$(xdg-user-dir DESKTOP 2>/dev/null || echo "${HOME}")"
-cd ~/Desktop
+cd "${STAGING_PATH}"
-# create a symlink in /tmp that will lead to the QNX platform SDK so as to avoid spaces in paths
+# 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
 # (this is totally prohibitive with the official QNX toolchain)
+if [ ! -L /tmp/qnxsdk ] || [ ! "$(readlink /tmp/qnxsdk)" = "$(realpath "${CURRENT_DIR}/${QNXSDK_PATH}")" ]; then
+        echo "Creating symlink to QNX toolchain in /tmp/qnxsdk..."
-test -L /tmp/qnxsdk && rm /tmp/qnxsdk
+        rm -rf /tmp/qnxsdk 2>/dev/null
-ln -fs "${CURRENT_DIR}/${QNXSDK_PATH}" /tmp/qnxsdk
+        ln -fs "$(realpath "${CURRENT_DIR}/${QNXSDK_PATH}")" /tmp/qnxsdk || exit 1
+fi
 # setup the environment
 export QNX_HOST="/tmp/qnxsdk/${QNXSDK_HOSTPATH}"
 export QNX_TARGET="/tmp/qnxsdk/${QNXSDK_TARGETPATH}"
 export MAKEFLAGS="-I${QNX_TARGET}/usr/include"
 export PATH="${QNX_HOST}/usr/bin:${PATH}"
-#export PYTHONDONTWRITEBYTECODE="1"
-#export PYTHONPATH=""
 # download the LLVM source package and unpack it if not done yet
 if [ ! -d "${LLVM_SOURCES_DIR}" ]; then
         if [ ! -f "${CURRENT_DIR}/${LLVM_SOURCES_FILE}" ]; then
                 echo "Downloading LLVM ${LLVM_VERSION} sources from LLVM GitHub..."
 # create the QNX CMake toolchain file
 echo '# '${TARGET_TRIPLE}' CMake toolchain file by Pierre-Marie Baty <pm@pmbaty.com>
 SET(CMAKE_SYSTEM_NAME "QNX")
-SET(CMAKE_SYSTEM_VERSION "8.0.0")
+SET(CMAKE_SYSTEM_VERSION "'${QNXSDK_VERSION}'")
 SET(QNX "1")
 SET(QNXNTO "1")
-if ("$ENV{QNX_HOST}" STREQUAL "")
-        message(FATAL_ERROR "the QNX_HOST environment variable is not set")
-endif()
 SET(QNX_HOST "$ENV{QNX_HOST}")
-if ("$ENV{QNX_TARGET}" STREQUAL "")
-        message(FATAL_ERROR "the QNX_TARGET environment variable is not set")
-endif()
 SET(QNX_TARGET "$ENV{QNX_TARGET}")
 SET(QNX_PROCESSOR "'${TARGET_ARCH}'")
 SET(CMAKE_ASM_COMPILER "${QNX_HOST}/usr/bin/'${TARGET_TRIPLE}'-gcc")
 SET(CMAKE_ASM_COMPILER_TARGET "gcc_nto${QNX_PROCESSOR}")
 SET(CMAKE_C_COMPILER_TARGET "gcc_nto${QNX_PROCESSOR}")
 SET(CMAKE_C_FLAGS_DEBUG "-g")
 SET(CMAKE_C_FLAGS_MINSIZEREL "-Os -DNDEBUG")
 SET(CMAKE_C_FLAGS_RELEASE "-O3 -DNDEBUG")
 SET(CMAKE_C_FLAGS_RELWITHDEBINFO "-O2 -g")
-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")
+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")
 SET(CMAKE_CXX_COMPILER "${QNX_HOST}/usr/bin/'${TARGET_TRIPLE}'-g++")
 SET(CMAKE_CXX_COMPILER_TARGET "gcc_nto${QNX_PROCESSOR}")
 SET(CMAKE_CXX_FLAGS_DEBUG "-g")
 SET(CMAKE_CXX_FLAGS_MINSIZEREL "-Os -DNDEBUG")
 SET(CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG")
 SET(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g")
-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")
+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")
 SET(CMAKE_LINKER "${QNX_HOST}/usr/bin/'${TARGET_TRIPLE}'-ld.bfd")
 SET(CMAKE_SHARED_LINKER_FLAGS "-lsocket")
 SET(CMAKE_EXE_LINKER_FLAGS "-lsocket")
 SET(CMAKE_RANLIB "${QNX_HOST}/usr/bin/'${TARGET_TRIPLE}'-ranlib")
+SET(CMAKE_NM "${QNX_HOST}/usr/bin/'${TARGET_TRIPLE}'-nm")
 SET(CMAKE_AR "${QNX_HOST}/usr/bin/'${TARGET_TRIPLE}'-ar")
 SET(CMAKE_FIND_ROOT_PATH "${QNX_TARGET}")
 SET(CMAKE_FIND_ROOT_PATH_HOST_PROGRAM NEVER)
 SET(CMAKE_FIND_ROOT_PATH_HOST_LIBRARY ONLY)
 SET(CMAKE_FIND_ROOT_PATH_HOST_INCLUDE ONLY)
 ' > "${TARGET_TRIPLE}.cmake"
+backup_and_patch_if_necessary()
+{
+        # handy function that patches a file in LLVM_SOURCES_DIR with a given sed replacement regex if necessary, creating backups
+        # args: <file pathname> <grep_string_to_test_for_presence_of_patch> <sed regex>
+        # test if already patched
+        grep -q "${2}" "../${LLVM_SOURCES_DIR}/${1}" && return
+        # tell what we're about to do
+        echo "Patching ${1}..."
+        # have a backup first
+        test -f "${CURRENT_DIR}/$(echo "${1}"|tr '/' '.') [BEFORE PATCH]" || cp "../${LLVM_SOURCES_DIR}/${1}" "${CURRENT_DIR}/$(echo "${1}"|tr '/' '.') [BEFORE PATCH]"
+        # perform the patch
+        sed -E "${3}" "${CURRENT_DIR}/$(echo "${1}"|tr '/' '.') [BEFORE PATCH]" > "${CURRENT_DIR}/$(echo "${1}"|tr '/' '.') [AFTER PATCH]"
+        # verify that we did it successfully
+        if ! grep -q "${2}" "${CURRENT_DIR}/$(echo "${1}"|tr '/' '.') [AFTER PATCH]"; then
+                echo "Error: the file ${1} could not be patched. Please investigate and fix manually." | fold -s -w 79; exit 1
+        fi
+        # and put the patched file in place
+        cp -f "${CURRENT_DIR}/$(echo "${1}"|tr '/' '.') [AFTER PATCH]" "../${LLVM_SOURCES_DIR}/${1}" || exit 1
+}
 # patch llvm/Support/Unix/Path.inc if not done yet
-if ! grep -q __QNXNTO__ "../${LLVM_SOURCES_DIR}/llvm/lib/Support/Unix/Path.inc"; then
+# replace "defined(__FreeBSD_kernel__)" with "(defined(__FreeBSD_kernel__) || defined(__QNXNTO__))"
+# 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.
+# 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,
+# 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).
+# 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
+# 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.
+# 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.
+# FIXME: these hacks should be moved elsewhere not to pollute the QNX8 platform SDK -- it *SHOULD* be possible to build without devs
-        echo "Patching llvm/lib/Support/Unix/Path.inc..."
+backup_and_patch_if_necessary "llvm/lib/Support/Unix/Path.inc" __QNXNTO__ 's/defined\(__FreeBSD_kernel__\)/\(defined\(__FreeBSD_kernel__\) \|\| \defined\(__QNXNTO__\)\)/g'
-        # have a backup first
+# patch lldb/Source/Host/common/Host.cpp if not done yet
+# replace "defined(SIGINFO)" with "(defined(SIGINFO) && !defined(__QNXNTO__))"
+# RATIONALE: the QNX people defined SIGINFO to the value of SIGUSR1 for a mysterious reason, defeating the purpose of SIGUSR1
+# which should be a User-Definable signal as mandated by POSIX. Consequently, userland code that enumerates POSIX signals
+# hits twice the same value and all is left to solve this problem is to filter either one out. Since SIGINFO, contrarily to SIGUSR1,
+# is an optional signal, this is the value that will be left out - even if on QNX nobody can actually use SIGUSR1's value.
-        test -f "${CURRENT_DIR}/Path [BEFORE PATCH].inc" || cp "../${LLVM_SOURCES_DIR}/llvm/lib/Support/Unix/Path.inc" "${CURRENT_DIR}/Path [BEFORE PATCH].inc"
+backup_and_patch_if_necessary "lldb/source/Host/common/Host.cpp" __QNXNTO__ 's/defined\(SIGINFO\)/\(defined\(SIGINFO\) \&\& \!defined\(__QNXNTO__\)\)/g'
-        # replace "defined(__FreeBSD_kernel__)" with "(defined(__FreeBSD_kernel__) || defined(__QNXNTO__))"
+# FIXME: another patch is needed for LLDB. Basically, the ptrace() POSIX system call doesn't exist on QNX. Instead
-        # 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.
+# QNX use their own debug utility: pdebug. Note the /proc filesystem can be used to access a debuggee's virtual memory space.
-        # 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,
-        # 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).
-        # 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
-        # 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.
-        # 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.
+# in lldb/source/Host/posix/ProcessLauncherPosixFork.cpp line 196:
-        # FIXME: these hacks should be moved elsewhere not to pollute the QNX8 platform SDK -- it *SHOULD* be possible to build without devs
+#   if (ptrace(PT_TRACE_ME, 0, nullptr, 0) == -1) // <--- undefined: ptrace, PT_TRACE_ME
-        sed 's/defined(__FreeBSD_kernel__)/(defined(__FreeBSD_kernel__) || defined(__QNXNTO__))/g' "${CURRENT_DIR}/Path [BEFORE PATCH].inc" > "${CURRENT_DIR}/Path [AFTER PATCH].inc"
-        # verify that we did it successfully
-        if ! grep -q __QNXNTO__ "${CURRENT_DIR}/Path [AFTER PATCH].inc"; then
+#    -D LLVM_ENABLE_PROJECTS="clang;lld;lldb" \
-                echo "Error: the LLVM support library source file llvm/Support/Unix/Path.inc could not be patched to support QNX neutrino. Please investigate and fix manually." | fold -s -w 79
-                exit 1
-        fi
-        # and put the patched file in place
+# patch compiler-rt/lib/builtins/enable_execute_stack.c if not done yet
-        cp -f "${CURRENT_DIR}/Path [AFTER PATCH].inc" "../${LLVM_SOURCES_DIR}/llvm/lib/Support/Unix/Path.inc" || exit 1
+# replace "#include "int_lib.h"" with "#ifdef __QNXNTO__\n#define _QNX_SOURCE 1\n#endif\n#include "int_lib.h""
-fi
+# 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.
+# 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.
+# 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
+# when building compiler-rt specifically, the CMAKE_C_FLAGS directive is ignored. Patching the source file seems like the best option to fix that.
+backup_and_patch_if_necessary "compiler-rt/lib/builtins/enable_execute_stack.c" __QNXNTO__ 's/#include "int_lib.h"/#ifdef __QNXNTO__\n#define _QNX_SOURCE 1\n#endif\n#include "int_lib.h"/g'
 # now configure LLVM
 echo "Configuring LLVM build..."
 cmake \
     -D CMAKE_TOOLCHAIN_FILE="${TARGET_TRIPLE}.cmake" \
     -D CMAKE_BUILD_TYPE="MinSizeRel" \
-    -D CMAKE_INSTALL_PREFIX="/tmp/qnxsdk/host/qnx8" \
+    -D CMAKE_INSTALL_PREFIX="/tmp/qnxsdk/host/qnx$(echo "${QNXSDK_VERSION}"|awk -F. '{print $1}')/${BUILD_TARGET_ARCH}" \
     -D CMAKE_STAGING_PREFIX="/usr/bin" \
     -D LLVM_HOST_TRIPLE="${TARGET_TRIPLE}" \
-    -D LLVM_ENABLE_PROJECTS="clang;lld;lldb" \
+    -D LLVM_ENABLE_PROJECTS="clang;lld" \
-    -D LLVM_ENABLE_RUNTIMES="compiler-rt;libcxx;libcxxabi" \
+    -D LLVM_ENABLE_RUNTIMES="compiler-rt;libcxx;libcxxabi;libunwind" \
     -D LLVM_TARGETS_TO_BUILD="AArch64;X86" \
     -G Ninja \
     "../${LLVM_SOURCES_DIR}/llvm" || exit 1
 # hijack the "bin" and "lib/clang" output directories and redirect them to the hypervisor's filesystem

Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

QNX 8.QNX8 LLVM/Clang compiler suite/cross-build.sh – Rev 6 → 7