Rev 15 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed
| Rev | Author | Line No. | Line |
|---|---|---|---|
| 1 | pmbaty | 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 | |||
| 2 | pmbaty | 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" |
||
| 1 | pmbaty | 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 | |||
| 3 | pmbaty | 20 | export REQUIRED_TOOLS="wget python3 gcc g++ make m4" # list of build tools required to build all this on the build host |
| 21 | |||
| 1 | pmbaty | 22 | # see where we are |
| 23 | export CURRENT_DIR="$(pwd)" |
||
| 24 | |||
| 3 | pmbaty | 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 |
||
| 1 | pmbaty | 29 | echo "" |
| 3 | pmbaty | 30 | while [ -n "${1}" ]; do |
| 31 | echo "${1}"|fold -s -w "${COLUMNS}" |
||
| 32 | shift |
||
| 33 | done |
||
| 1 | pmbaty | 34 | echo "" |
| 35 | exit 1 |
||
| 3 | pmbaty | 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." |
||
| 1 | pmbaty | 41 | fi |
| 42 | |||
| 3 | pmbaty | 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 |
||
| 1 | pmbaty | 51 | |
| 15 | pmbaty | 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 | |||
| 13 | pmbaty | 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) |
| 19 | pmbaty | 76 | if [ ! -e "${QNXSDK_CANONICAL_PATH}/${QNXSDK_HOSTPATH}/usr/bin/ntox86_64-gcc" ] || [ ! -e "${QNXSDK_CANONICAL_PATH}/${QNXSDK_TARGETPATH}/usr/include/readline.h" ]; then |
| 3 | pmbaty | 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:)" \ |
||
| 15 | pmbaty | 80 | " cd ${QNXSDK_CANONICAL_PATH}" \ |
| 3 | pmbaty | 81 | " find . -name symlinks.lst -exec ./symlinks.sh {} create \\; && printf 'present' > .symlinks-state" \ |
| 82 | "(else on a Windows machine:)" \ |
||
| 15 | pmbaty | 83 | " cd ${QNXSDK_CANONICAL_PATH}" \ |
| 3 | pmbaty | 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." |
||
| 1 | pmbaty | 86 | fi |
| 87 | |||
| 15 | pmbaty | 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 |
| 1 | pmbaty | 89 | # (this is totally prohibitive with the official QNX toolchain) |
| 15 | pmbaty | 90 | if [ ! -L /tmp/qnxsdk ] || [ ! "$(readlink /tmp/qnxsdk)" = "${QNXSDK_CANONICAL_PATH}" ]; then |
| 1 | pmbaty | 91 | echo "Creating symlink to QNX toolchain in /tmp/qnxsdk..." |
| 92 | rm -rf /tmp/qnxsdk 2>/dev/null |
||
| 15 | pmbaty | 93 | ln -fs "${QNXSDK_CANONICAL_PATH}" /tmp/qnxsdk || exit 1 |
| 1 | pmbaty | 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 | |||
| 2 | pmbaty | 102 | # print the build environment |
| 103 | echo "QNX_HOST=${QNX_HOST}" |
||
| 104 | echo "QNX_TARGET=${QNX_TARGET}" |
||
| 105 | echo "MAKEFLAGS=${MAKEFLAGS}" |
||
| 106 | |||
| 1 | pmbaty | 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 |
||
| 2 | pmbaty | 157 | cd "${BINUTILS_SOURCES_DIR}" || exit 1 |
| 1 | pmbaty | 158 | |
| 159 | backup_and_patch_if_necessary() |
||
| 160 | { |
||
| 2 | pmbaty | 161 | # handy function that patches a file in the current directory with a given sed replacement regex if necessary, creating backups |
| 1 | pmbaty | 162 | # args: <file pathname> <grep_string_to_test_for_presence_of_patch> <sed regex> |
| 3 | pmbaty | 163 | _PATCHEE_PATHNAME="${1}" |
| 164 | _PATCHED_PATTERN="${2}" |
||
| 1 | pmbaty | 165 | # test if already patched |
| 3 | pmbaty | 166 | grep -q "${_PATCHED_PATTERN}" "${_PATCHEE_PATHNAME}" && return |
| 1 | pmbaty | 167 | # tell what we're about to do |
| 3 | pmbaty | 168 | echo "Patching ${_PATCHEE_PATHNAME}..." |
| 169 | _DOTTED_NAME="$(echo "${_PATCHEE_PATHNAME}"|tr '/' '.')" |
||
| 1 | pmbaty | 170 | # have a backup first |
| 3 | pmbaty | 171 | test -f "${CURRENT_DIR}/${_DOTTED_NAME} [ORIGINAL]" || cp "${_PATCHEE_PATHNAME}" "${CURRENT_DIR}/${_DOTTED_NAME} [ORIGINAL]" || exit 1 |
| 1 | pmbaty | 172 | # perform the patch |
| 3 | pmbaty | 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 |
||
| 1 | pmbaty | 178 | # verify that we did it successfully |
| 3 | pmbaty | 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 |
||
| 1 | pmbaty | 181 | fi |
| 182 | # and put the patched file in place |
||
| 3 | pmbaty | 183 | cp -f "${CURRENT_DIR}/${_DOTTED_NAME} [PATCHED]" "${_PATCHEE_PATHNAME}" || exit 1 |
| 1 | pmbaty | 184 | } |
| 185 | backup_and_replace() |
||
| 186 | { |
||
| 2 | pmbaty | 187 | # handy function that replaces a file in the current directory with a given replacement, creating backups |
| 1 | pmbaty | 188 | # args: <file pathname> <replacement pathname> |
| 189 | # tell what we're about to do |
||
| 190 | echo "Replacing ${1}..." |
||
| 191 | # have a backup first |
||
| 2 | pmbaty | 192 | test -f "${CURRENT_DIR}/$(echo "${1}"|tr '/' '.') [ORIGINAL]" || test -e "${1}" && cp "${1}" "${CURRENT_DIR}/$(echo "${1}"|tr '/' '.') [ORIGINAL]" |
| 1 | pmbaty | 193 | # perform the replacement |
| 2 | pmbaty | 194 | cp -f "${2}" "${1}" || exit 1 |
| 1 | pmbaty | 195 | } |
| 196 | |||
| 197 | # patch libiberty/pex-unix.c |
||
| 3 | pmbaty | 198 | # replace: |
| 199 | # defined(HAVE_SPAWNVE) |
||
| 200 | # with: |
||
| 201 | # !defined(__QNXNTO__) && defined(HAVE_SPAWNVE) |
||
| 1 | pmbaty | 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. |
||
| 3 | pmbaty | 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' |
||
| 1 | pmbaty | 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 |
||
| 4 | pmbaty | 214 | # RATIONALE: insert x86_64 and aarch64 QNX definitions for the GNU linker |
| 1 | pmbaty | 215 | backup_and_replace "ld/configure.tgt" "${CURRENT_DIR}/ld.configure.tgt" |
| 216 | |||
| 4 | pmbaty | 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 |
||
| 8 | pmbaty | 223 | backup_and_replace "ld/emulparams/elf_x86_64.sh" "${CURRENT_DIR}/ld.emulparams.elf_x86_64.sh" |
| 4 | pmbaty | 224 | |
| 19 | pmbaty | 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 | |||
| 1 | pmbaty | 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 | |||
| 2 | pmbaty | 242 | # now, for each target arch the native binutils should support... |
| 243 | for BUILD_TARGET_ARCH in ${BUILD_TARGET_ARCHS}; do |
||
| 1 | pmbaty | 244 | |
| 2 | pmbaty | 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}" |
||
| 1 | pmbaty | 252 | |
| 2 | pmbaty | 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 \ |
||
| 4 | pmbaty | 263 | --with-sysroot="${QNX_TARGET}" \ |
| 19 | pmbaty | 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 \ |
||
| 4 | pmbaty | 275 | --enable-threads \ |
| 276 | --disable-bootstrap \ |
||
| 19 | pmbaty | 277 | --disable-doc \ |
| 278 | --with-bugurl="pm@pmbaty.com" \ |
||
| 279 | || exit 1 |
||
| 2 | pmbaty | 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 \ |
||
| 1 | pmbaty | 307 | ; do |
| 2 | pmbaty | 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 ../.. |
||
| 1 | pmbaty | 315 | done |
| 316 | |||
| 15 | pmbaty | 317 | test -z "${WSL_DISTRO_NAME}" && /bin/printf "\n\xf0\x9f\x8d\xba\x20\x43\x68\x65\x65\x72\x73\x2e\n" |
| 1 | pmbaty | 318 | exit 0 |