Subversion Repositories QNX 8.QNX8 GNU binutils

Rev

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

  1. #!/bin/sh
  2. # GNU binutils 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="binutils-build" # name of the directory on the build host's desktop where the GNU binutils sources will be built
  12. export BUILD_TARGET_ARCHS="x86_64 aarch64" # space-separated list of CPU architectures to build the GNU binutils for, among "x86_64" and "aarch64"
  13.  
  14. export BINUTILS_VERSION="2.41" # version of GNU binutils that will be built. Should match the Win32 and Linux tools.
  15.  
  16. export BINUTILS_SOURCES_FILE="binutils-${BINUTILS_VERSION}.tar.gz" # name of the file containing GNU binutils version BINUTILS_VERSION sources
  17. export BINUTILS_SOURCES_URL="https://ftp.gnu.org/gnu/binutils/${BINUTILS_SOURCES_FILE}" # download URL of BINUTILS_SOURCES_FILE
  18. export BINUTILS_SOURCES_DIR="binutils-${BINUTILS_VERSION}" # name of directory created when extracting BINUTILS_SOURCES_FILE
  19.  
  20. export REQUIRED_TOOLS="wget python3 gcc g++ make m4" # list of build tools required to build all this on the build host
  21.  
  22. # see where we are
  23. export CURRENT_DIR="$(pwd)"
  24.  
  25. print_error_and_die()
  26. {
  27.         # a handy function that does what it says. Args: error strings to print, one line per argument
  28.         test -z "${COLUMNS}" && COLUMNS=80
  29.         echo ""
  30.         while [ -n "${1}" ]; do
  31.                 echo "${1}"|fold -s -w "${COLUMNS}"
  32.                 shift
  33.         done
  34.         echo ""
  35.         exit 1
  36. }
  37.  
  38. # verify we're a x86_64 Linux host
  39. if [ ! "$(uname)" = "Linux" ] || [ ! "$(uname -m)" = "x86_64" ]; then
  40.         print_error_and_die "Error: this script requires a x86_64 Linux machine (possibly a virtual machine) as the build host."
  41. fi
  42.  
  43. # verify that we have the required tools
  44. for REQUIRED_TOOL in ${REQUIRED_TOOLS}; do
  45.         "${REQUIRED_TOOL}" --version > /dev/null 2>&1 || print_error_and_die \
  46.                 "Error: this script requires at the very least the following tools installed:" \
  47.                 "       $(echo "${REQUIRED_TOOLS}"|sed 's/ /\n  /g')" \
  48.                 "Please install them (possibly as binary packages with apt-get) and try again." \
  49.                 "More specifically, the following tool was not found: '${REQUIRED_TOOL}'"
  50. done
  51.  
  52. # verify that we have the QNX platform SDK
  53. if [ ! -d "${QNXSDK_PATH}/${QNXSDK_HOSTPATH}" ] || [ ! -d "${QNXSDK_PATH}/${QNXSDK_TARGETPATH}" ]; then
  54.         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."
  55. fi
  56.  
  57. # 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)
  58. STAGING_PATH="$(xdg-user-dir DESKTOP 2>/dev/null || echo "${HOME}")"
  59. test -d "${STAGING_PATH}" || STAGING_PATH="${HOME}"
  60. cd "${STAGING_PATH}"
  61.  
  62. # are we running the Windows Subsystem for Linux, instead of a real Linux ?
  63. if [ -n "${WSL_DISTRO_NAME}" ]; then
  64.         # yes. In order to avoid the horrible 9p protocol for file interchange between NTFS and ext4 (a remarkably bad idea by Microsoft),
  65.         # use the copy of the QNX SDP that our caller is supposed to have put in our $HOME in the WSL2 filesystem. The speed gain is considerable.
  66.         QNXSDK_CANONICAL_PATH="${HOME}/$(basename "${QNXSDK_PATH}")"
  67.         if [ ! -d "${QNXSDK_CANONICAL_PATH}/${QNXSDK_HOSTPATH}" ] || [ ! -d "${QNXSDK_CANONICAL_PATH}/${QNXSDK_TARGETPATH}" ]; then
  68.                 print_error_and_die "Error: the QNX SDP hasn't been deployed to ${QNXSDK_CANONICAL_PATH}. Please do so and run this script again."
  69.         fi
  70. else
  71.         # we're not in WSL. We can expect reasonably good file access speeds to the QNX SDP that's bundled with this repository, so just use it.
  72.         QNXSDK_CANONICAL_PATH="$(realpath "${CURRENT_DIR}/${QNXSDK_PATH}")"
  73. fi
  74.  
  75. # 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)
  76. if [ ! -e "${QNXSDK_CANONICAL_PATH}/${QNXSDK_HOSTPATH}/usr/bin/ntox86_64-gcc" ] || [ ! -e "${QNXSDK_CANONICAL_PATH}/${QNXSDK_TARGETPATH}/usr/include/readline.h" ]; then
  77.         print_error_and_die \
  78.                 "Error: the toolchain platform-specific symbolic links have not been deployed in this QNX SDK. Please run" \
  79.                 "(on a POSIX machine:)" \
  80.                 "       cd ${QNXSDK_CANONICAL_PATH}" \
  81.                 "       find . -name symlinks.lst -exec ./symlinks.sh {} create \\; && printf 'present' > .symlinks-state" \
  82.                 "(else on a Windows machine:)" \
  83.                 "       cd ${QNXSDK_CANONICAL_PATH}" \
  84.                 "       host\\win64\\x86_64\\usr\\bin\\busybox.exe sh -c \"find . -name symlinks.lst -exec ./symlinks.sh {} create \\; && printf 'present' > .symlinks-state\"" \
  85.                 "Note that this step WILL take time on a Win32 machine, but is only done once."
  86. fi
  87.  
  88. # 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
  89. # (this is totally prohibitive with the official QNX toolchain)
  90. if [ ! -L /tmp/qnxsdk ] || [ ! "$(readlink /tmp/qnxsdk)" = "${QNXSDK_CANONICAL_PATH}" ]; then
  91.         echo "Creating symlink to QNX toolchain in /tmp/qnxsdk..."
  92.         rm -rf /tmp/qnxsdk 2>/dev/null
  93.         ln -fs "${QNXSDK_CANONICAL_PATH}" /tmp/qnxsdk || exit 1
  94. fi
  95.  
  96. # setup the environment
  97. export QNX_HOST="/tmp/qnxsdk/${QNXSDK_HOSTPATH}"
  98. export QNX_TARGET="/tmp/qnxsdk/${QNXSDK_TARGETPATH}"
  99. export MAKEFLAGS="-I${QNX_TARGET}/usr/include"
  100. export PATH="${QNX_HOST}/usr/bin:${PATH}"
  101.  
  102. # print the build environment
  103. echo "QNX_HOST=${QNX_HOST}"
  104. echo "QNX_TARGET=${QNX_TARGET}"
  105. echo "MAKEFLAGS=${MAKEFLAGS}"
  106.  
  107. # download the involved source packages and unpack them if not done yet
  108. download_and_unpack_if_necessary()
  109. {
  110.         # helper function that downloads a sources tarball, extracts it and patches it if necessary
  111.         # args: <sources dirname> <sources filename> <download URL> [optional patchset URL]
  112.         test -d "${1}" && return 0 # if sources directory already exists, nothing to do
  113.         if [ ! -s "${CURRENT_DIR}/${2}" ]; then # if sources archive isn't a nonempty file...
  114.                 echo "Downloading ${1} sources from ${3}..."
  115.                 if ! wget -O "${CURRENT_DIR}/${2}" "${3}"; then
  116.                         # remove output file in case an error occurs
  117.                         rm -f "${CURRENT_DIR}/${2}"
  118.                         exit 1
  119.                 fi
  120.         fi
  121.         echo "Extracting ${1} sources..."
  122.         cd "$(dirname "${1}")"
  123.         if echo "${2}"|grep -q "\.tar\.bz2$"; then
  124.                 # BZip2 tarball
  125.                 tar xjf "${CURRENT_DIR}/${2}" || exit 1
  126.         elif echo "${2}"|grep -q "\.tar\.xz$"; then
  127.                 # XZ tarball
  128.                 tar xJf "${CURRENT_DIR}/${2}" || exit 1
  129.         elif echo "${2}"|grep -q "\.tar\.gz$"; then
  130.                 # GZipped tarball
  131.                 tar xzf "${CURRENT_DIR}/${2}" || exit 1
  132.         else
  133.                 echo "Error: unsupported file extension. Please improve the download_and_unpack_if_necessary() shell function to support it."
  134.                 exit 1
  135.         fi
  136.         # make sure the expected directory is here after extraction
  137.         if [ ! -d "${1}" ]; then
  138.                 echo "Error: couldn't find ${1} in extracted sources."
  139.                 exit 1
  140.         fi
  141.         # do we have a patchset to apply ?
  142.         if [ -n "${4}" ]; then
  143.                 echo "Downloading ${1} patchset from ${4}..."
  144.                 wget -O "${CURRENT_DIR}/${2}.patchset" "${4}" || exit 1
  145.                 echo "Applying patchset..."
  146.                 OLDDIR="$(pwd)"
  147.                 cd "${1}"
  148.                 patch -N -Z -p1 < "${CURRENT_DIR}/${2}.patchset" || exit 1
  149.                 cd "${OLDDIR}"
  150.                 unset OLDDIR
  151.         fi
  152.         return 0
  153. }
  154. download_and_unpack_if_necessary "${BINUTILS_SOURCES_DIR}" "${BINUTILS_SOURCES_FILE}" "${BINUTILS_SOURCES_URL}" || exit 1
  155.  
  156. # change directory to the binutils sources
  157. cd "${BINUTILS_SOURCES_DIR}" || exit 1
  158.  
  159. backup_and_patch_if_necessary()
  160. {
  161.         # handy function that patches a file in the current directory with a given sed replacement regex if necessary, creating backups
  162.         # args: <file pathname> <grep_string_to_test_for_presence_of_patch> <sed regex>
  163.         _PATCHEE_PATHNAME="${1}"
  164.         _PATCHED_PATTERN="${2}"
  165.         # test if already patched
  166.         grep -q "${_PATCHED_PATTERN}" "${_PATCHEE_PATHNAME}" && return
  167.         # tell what we're about to do
  168.         echo "Patching ${_PATCHEE_PATHNAME}..."
  169.         _DOTTED_NAME="$(echo "${_PATCHEE_PATHNAME}"|tr '/' '.')"
  170.         # have a backup first
  171.         test -f "${CURRENT_DIR}/${_DOTTED_NAME} [ORIGINAL]" || cp "${_PATCHEE_PATHNAME}" "${CURRENT_DIR}/${_DOTTED_NAME} [ORIGINAL]" || exit 1
  172.         # perform the patch
  173.         cp -f "${CURRENT_DIR}/${_DOTTED_NAME} [ORIGINAL]" "${CURRENT_DIR}/${_DOTTED_NAME} [PATCHED]" || exit 1
  174.         while [ -n "${3}" ]; do
  175.                 sed -E -i "${3}" "${CURRENT_DIR}/${_DOTTED_NAME} [PATCHED]"
  176.                 shift
  177.         done
  178.         # verify that we did it successfully
  179.         if ! grep -q "${_PATCHED_PATTERN}" "${CURRENT_DIR}/${_DOTTED_NAME} [PATCHED]"; then
  180.                 echo "Error: the file ${_PATCHEE_PATHNAME} could not be patched. Please investigate and fix manually." | fold -s -w 79; exit 1
  181.         fi
  182.         # and put the patched file in place
  183.         cp -f "${CURRENT_DIR}/${_DOTTED_NAME} [PATCHED]" "${_PATCHEE_PATHNAME}" || exit 1
  184. }
  185. backup_and_replace()
  186. {
  187.         # handy function that replaces a file in the current directory with a given replacement, creating backups
  188.         # args: <file pathname> <replacement pathname>
  189.         # tell what we're about to do
  190.         echo "Replacing ${1}..."
  191.         # have a backup first
  192.         test -f "${CURRENT_DIR}/$(echo "${1}"|tr '/' '.') [ORIGINAL]" || test -e "${1}" && cp "${1}" "${CURRENT_DIR}/$(echo "${1}"|tr '/' '.') [ORIGINAL]"
  193.         # perform the replacement
  194.         cp -f "${2}" "${1}" || exit 1
  195. }
  196.  
  197. # patch libiberty/pex-unix.c
  198. # replace:
  199. #       defined(HAVE_SPAWNVE)
  200. # with:
  201. #       !defined(__QNXNTO__) && defined(HAVE_SPAWNVE)
  202. # RATIONALE: QNX exposes the same spawnve() functions which were invented by Microsoft. Autoconf mistakenly believes it's a Cygwin system.
  203. # Moreover the flags _P_NOWAIT and _P_NOWAITO don't have the same meaning on QNX: the second one doesn't create zombies waiting for their exit
  204. # status to be read, whereas on Microsoft they're the same. This prevents process created with this flag (as libiberty does) from being wait()ed.
  205. # Fix that by declaring that we want to use the traditional POSIX fork/exec scheme, which QNX supports as well.
  206. backup_and_patch_if_necessary "libiberty/pex-unix.c" __QNXNTO__ \
  207.         's@defined\(HAVE_SPAWNVE\)@\!defined\(__QNXNTO__\) \&\& defined\(HAVE_SPAWNVE\)@g'
  208.  
  209. # patch bfd/config.bfd
  210. # RATIONALE: insert x86_64 and aarch64 QNX definitions for the BFD library
  211. backup_and_replace "bfd/config.bfd" "${CURRENT_DIR}/bfd.config.bfd"
  212.  
  213. # patch ld/configure.tgt
  214. # RATIONALE: insert x86_64 and aarch64 QNX definitions for the GNU linker
  215. backup_and_replace "ld/configure.tgt" "${CURRENT_DIR}/ld.configure.tgt"
  216.  
  217. # patch ld/emulparams/aarch64nto.sh
  218. # RATIONALE: insert aarch64 QNX particularities for the GNU linker
  219. backup_and_replace "ld/emulparams/aarch64nto.sh" "${CURRENT_DIR}/ld.emulparams.aarch64nto.sh"
  220.  
  221. # patch ld/emulparams/elf_x86_64nto.sh
  222. # RATIONALE: insert aarch64 QNX particularities for the GNU linker
  223. backup_and_replace "ld/emulparams/elf_x86_64.sh" "${CURRENT_DIR}/ld.emulparams.elf_x86_64.sh"
  224.  
  225. # patch ld/emulparams/i386nto.sh
  226. # RATIONALE: insert i386 QNX particularities for the GNU linker
  227. backup_and_replace "ld/emulparams/i386nto.sh" "${CURRENT_DIR}/ld.emulparams.i386nto.sh"
  228.  
  229. # patch ld/emultempl/nto.em
  230. # RATIONALE: insert i386 QNX particularities for the GNU linker
  231. backup_and_replace "ld/emultempl/nto.em" "${CURRENT_DIR}/ld.emultempl.nto.em"
  232.  
  233. # define the tools to use when compiling intermediary programs on the build host
  234. export AR_FOR_BUILD="/usr/bin/ar"
  235. export AS_FOR_BUILD="/usr/bin/as"
  236. export LD_FOR_BUILD="/usr/bin/ld"
  237. export NM_FOR_BUILD="/usr/bin/nm"
  238. export RANLIB_FOR_BUILD="/usr/bin/ranlib"
  239. export CC_FOR_BUILD="/usr/bin/gcc"; CFLAGS_FOR_BUILD="-fuse-ld=${LD_FOR_BUILD}"
  240. export CXX_FOR_BUILD="/usr/bin/g++"; CXXFLAGS_FOR_BUILD="-fuse-ld=${LD_FOR_BUILD}"
  241.  
  242. # now, for each target arch the native binutils should support...
  243. for BUILD_TARGET_ARCH in ${BUILD_TARGET_ARCHS}; do
  244.  
  245.         # construct the target triple (actually a quadruple)
  246.         TARGET_ARCH="${BUILD_TARGET_ARCH}"
  247.         test "${BUILD_TARGET_ARCH}" = "x86_64" && TARGET_VENDOR="pc" || TARGET_VENDOR="unknown"
  248.         TARGET_KERNEL="nto"
  249.         TARGET_SYSTEM="qnx${QNXSDK_VERSION}"
  250.         export TARGET_TRIPLE="${TARGET_ARCH}-${TARGET_VENDOR}-${TARGET_KERNEL}-${TARGET_SYSTEM}"
  251.         echo "Will build for ${TARGET_TRIPLE}"
  252.  
  253.         # create the build directory
  254.         echo "Wiping out build directory..."
  255.         test -e ".build/${TARGET_TRIPLE}" && rm -rf ".build/${TARGET_TRIPLE}"
  256.         mkdir -p ".build/${TARGET_TRIPLE}" || exit 1
  257.         ln -fs "${BINUTILS_SOURCES_DIR}/.build" "../${BUILD_DIR_NAME}"
  258.         cd ".build/${TARGET_TRIPLE}"
  259.  
  260.         # configure and build the GNU binutils. Note that since these are low level tools, we want static binaries as much as possible.
  261.         # NOTE: in this context, --host means the machine the built program is expected to RUN on, and --target the machine the built program will FOCUS on.
  262.         ../../configure \
  263.                         --with-sysroot="${QNX_TARGET}" \
  264.                 --prefix="$(dirname "$(dirname "${QNX_HOST}")")/qnx$(echo "${QNXSDK_VERSION}"|awk -F. '{print $1}')/${BUILD_TARGET_ARCH}/usr" \
  265.                 --host="x86_64-pc-nto-qnx${QNXSDK_VERSION}" \
  266.                 --target="${TARGET_TRIPLE}" \
  267.                 --disable-shared \
  268.                 --disable-nls \
  269.                 --enable-static-link \
  270.                 --disable-shared-plugins \
  271.                 --disable-dynamicplugin \
  272.                 --disable-pie \
  273.                 --enable-static=yes \
  274.                 --enable-shared=no \
  275.                         --enable-threads \
  276.                         --disable-bootstrap \
  277.                 --disable-doc \
  278.                 --with-bugurl="pm@pmbaty.com" \
  279.                 || exit 1
  280.  
  281.         # and build the whole shit
  282.         make -j 4 MAKEINFO=/bin/true || exit 1
  283.  
  284.         # now gather all the binutils in one place on the hypervisor's filesystem and name them appropriately
  285.         test -e "${CURRENT_DIR}/binutils-build" || mkdir -p "${CURRENT_DIR}/binutils-build"
  286.         rm "${CURRENT_DIR}/binutils-build/${TARGET_TRIPLE}-"* 2>/dev/null
  287.         VERSION="$(grep PACKAGE_VERSION opcodes/config.h|awk -F'"' '{print $2}')"
  288.         VERSION_MAJ="$(echo "${VERSION}"|cut -d . -f 1)"; test -z "${VERSION_MAJ}" && VERSION_MAJ="0"
  289.         VERSION_MIN="$(echo "${VERSION}"|cut -d . -f 2)"; test -z "${VERSION_MIN}" && VERSION_MIN="0"
  290.         VERSION_REV="$(echo "${VERSION}"|cut -d . -f 3)"; test -z "${VERSION_REV}" && VERSION_REV="0"
  291.         for TOOL in \
  292.                         binutils/addr2line:addr2line \
  293.                         binutils/ar:ar \
  294.                         gas/as-new:as \
  295.                         binutils/cxxfilt:c++filt \
  296.                         binutils/elfedit:elfedit \
  297.                         gprof/gprof:gprof \
  298.                         ld/ld-new:ld.bfd \
  299.                         binutils/nm-new:nm \
  300.                         binutils/objcopy:objcopy \
  301.                         binutils/objdump:objdump \
  302.                         binutils/ranlib:ranlib \
  303.                         binutils/readelf:readelf \
  304.                         binutils/size:size \
  305.                         binutils/strings:strings \
  306.                         binutils/strip-new:strip \
  307.         ; do
  308.                 SRC="$(echo "${TOOL}"|cut -d : -f 1)"
  309.                 TGT="$(echo "${TOOL}"|cut -d : -f 2)"
  310.                 cp "${SRC}" "${CURRENT_DIR}/binutils-build/${TARGET_TRIPLE}-${TGT}-${VERSION_MAJ}.${VERSION_MIN}.${VERSION_REV}" || exit 1
  311.         done
  312.  
  313.         # return to the sources dir and proceed to the next arch
  314.         cd ../..
  315. done
  316.  
  317. test -z "${WSL_DISTRO_NAME}" && /bin/printf "\n\xf0\x9f\x8d\xba\x20\x43\x68\x65\x65\x72\x73\x2e\n"
  318. exit 0
  319.