| #!/bin/bash |
| |
| SCRIPT_NAME="$(basename "$0")" |
| SCRIPT_DIR="$(cd $(dirname "$0"); pwd)" |
| INVOCATION_DIR="$(pwd)" |
| |
| # Things we want to build |
| HOST_LIBS="gmp mpfr mpc" |
| TOOLS="binutils gcc" |
| |
| ALL_GNU_TOOLS="ar as gcc ld nm objcopy objdump ranlib readelf" |
| |
| SUPPORTED_OSES="none linux fuchsia darwin" |
| SUPPORTED_ARCHES="arm aarch64 x86_64" |
| |
| ### Start of configuration options |
| ## In the configuration options below, all arch/os suffixes relate to the |
| ## target. e.g., "CONFIG_GCC_fuchsia" provides options that should be |
| ## used when building executables that will run on fuchsia, regardless |
| ## of the architecture. "CONFIG_GCC_aarch64_fuchsia" would give options that |
| ## should be used when building executables that will run on aarch64-fuchsia. |
| ## Uses ':' as an option delimiter, to facilitate the use of spaces inside |
| ## some options (e.g., CFLAGS). |
| # GMP |
| CONFIG_GMP_HOST_fuchsia="--with-pic=yes" |
| |
| # MPFR |
| CONFIG_MPFR="--with-pic=yes: \ |
| --with-gmp=" |
| |
| # MPC |
| CONFIG_MPC="--with-gmp=: \ |
| --with-mpfr=" |
| |
| # BINUTILS |
| CONFIG_BINUTILS="--with-included-gettext: \ |
| --disable-werror: \ |
| --enable-initfini-array" |
| CONFIG_BINUTILS_TARGET_none="--enable-gold" |
| CONFIG_BINUTILS_TARGET_x86_64_fuchsia="--enable-gold=default" |
| CONFIG_BINUTILS_TARGET_aarch64_fuchsia="--enable-gold" |
| CONFIG_BINUTILS_TARGET_fuchsia="--enable-plugins: \ |
| --enable-relro" |
| CONFIG_BINUTILS_TARGET_x86_64_none="--enable-targets=x86_64-pep" |
| |
| # GDB |
| CONFIG_GDB="--with-included-gettext:--disable-werror" |
| CONFIG_GDB_TARGET_aarch64_none="--enable-targets=arm-eabi" |
| |
| # GCC |
| CONFIG_GCC="--with-included-gettext: \ |
| --disable-werror: \ |
| --enable-initfini-array: \ |
| --enable-languages=c,c++:\ |
| --with-gmp=: \ |
| --with-mpfr=: \ |
| --with-mpc=" |
| CONFIG_GCC_TARGET_none="--disable-libstdcxx: \ |
| --disable-libssp: \ |
| --disable-libquadmath" |
| CONFIG_GCC_TARGET_fuchsia="--enable-default-pie: \ |
| --disable-multilib" |
| CONFIG_GCC_TARGET_arm="--with-cpu=arm926ej-s: \ |
| --with-fpu=vfp" |
| CONFIG_GCC_TOOLS_llvm="CXXFLAGS=-fbracket-depth=1024 -g -O2" |
| ### End of configuration options |
| |
| |
| usage() |
| { |
| echo "Usage: $SCRIPT_NAME [OPTION]..." |
| echo "Build a set of compiler tools." |
| echo "Options:" |
| echo " --force Build even if configuration is not supported." |
| echo " --help Produce this message" |
| echo " --host <ARCH-OS> Specify type of host where the tools will run." |
| echo " (default is to use the current build machine)" |
| echo " -j <#> Specify number of parallel build instances" |
| echo " --list-supported List all supported configurations and exit" |
| echo " --make-link <LINK> Create a link in the current directory to the" |
| echo " installation directory" |
| echo " --outdir <DIR> Generate output in specified directory" |
| echo " --strip Strip all binaries" |
| echo " --sysroot <DIR> Specify the location of the sysroot to be" |
| echo " used for non-native builds" |
| echo " --target <ARCH-OS> Specify type of target the tools will generate" |
| echo " code for" |
| } |
| |
| die() |
| { |
| echo "$SCRIPT_NAME: $1" >&2 |
| shift |
| while [ ! -z "$1" ] |
| do |
| echo "$1" >&2 |
| shift |
| done |
| exit 1 |
| } |
| |
| gather_host_info() |
| { |
| # Determine build machine attributes |
| BUILD_ARCH="$(uname -m)" |
| BUILD_OS="$(uname | tr '[:upper:]' '[:lower:]')" |
| BUILD="$BUILD_ARCH-$BUILD_OS" |
| |
| case "$BUILD_OS" in |
| linux) |
| PARALLEL_BUILDS="$(grep processor /proc/cpuinfo | wc -l)" |
| ;; |
| darwin) |
| PARALLEL_BUILDS="$(sysctl -n hw.ncpu)" |
| ;; |
| # No fallback case needed - we'll just build with "-j". |
| esac |
| |
| if cc --version | grep -q "LLVM" |
| then |
| HOST_TOOLS="llvm" |
| fi |
| } |
| |
| verify_arch_os_tuple() |
| { |
| tuple_to_check="$1" |
| |
| for arch in $SUPPORTED_ARCHES |
| do |
| for os in $SUPPORTED_OSES |
| do |
| if [ "$arch-$os" == "$tuple_to_check" ] |
| then |
| return |
| fi |
| done |
| done |
| |
| die "Unrecognized arch-os pair '$tuple_to_check'" \ |
| "Use --list-supported to show all supported configurations" |
| } |
| |
| split_arch_os() |
| { |
| local tuple="$1" |
| |
| RESULT_ARCH="$(echo "$tuple" | sed -E -e 's/([^-]+)-[^-]+$/\1/')" |
| RESULT_OS="$(echo "$tuple" | sed -E -e 's/[^-]+-([^-]+)$/\1/')" |
| } |
| |
| is_configuration_supported() |
| { |
| split_arch_os "$TARGET" |
| local target_arch="$RESULT_ARCH" |
| local target_os="$RESULT_OS" |
| split_arch_os "$HOST" |
| local host_arch="$RESULT_ARCH" |
| local host_os="$RESULT_OS" |
| |
| if [ "$BUILD" == "$HOST" ] |
| then |
| # Simple (not Canadian) cross-compiler |
| if [ "$target_os" == "none" ] || [ "$target_os" == "fuchsia" ] |
| then |
| return 0 |
| fi |
| elif [ "$HOST" == "$TARGET" ] && [ "$target_os" == "fuchsia" ] |
| then |
| # Build a natively-running fuchsia compiler |
| if [ "$target_arch" == "arm" ] |
| then |
| # ARM native builds don't work at the moment -- we need |
| # synchronization primitive support for pre-v6 architectures. |
| return 1 |
| fi |
| return 0 |
| elif [ "$host_os" == "fuchsia" ] && [ "$target_os" == "none" ] |
| then |
| return 0 |
| fi |
| return 1 |
| } |
| |
| list_all_supported() |
| { |
| local host_arch |
| local host_os |
| local target_arch |
| local target_os |
| |
| for host_arch in $SUPPORTED_ARCHES |
| do |
| for host_os in $SUPPORTED_OSES |
| do |
| for target_arch in $SUPPORTED_ARCHES |
| do |
| for target_os in $SUPPORTED_OSES |
| do |
| HOST="$host_arch-$host_os" |
| TARGET="$target_arch-$target_os" |
| if is_configuration_supported |
| then |
| echo " $HOST -> $TARGET" |
| fi |
| done |
| done |
| done |
| done |
| } |
| |
| get_argument() |
| { |
| if echo "$1" | grep -q "=" |
| then |
| RESULT=$(echo "$1" | sed -E -e 's/^[^=]+.*=//') |
| else |
| if [ -z "$2" ] |
| then |
| die "Argument required for option '$1'" |
| fi |
| SKIP_EXTRA_ARG="yes" |
| RESULT="$2" |
| fi |
| } |
| |
| process_opts() |
| { |
| local force="" |
| |
| # Set defaults |
| OUT_DIR="$INVOCATION_DIR" |
| HOST="$BUILD" |
| MAKE_LINK="" |
| STRIP="" |
| |
| while [ ! -z "$1" ] |
| do |
| SKIP_EXTRA_ARG="" |
| case "$1" in |
| --force) |
| force="yes" |
| ;; |
| --help) |
| usage |
| exit 0 |
| ;; |
| --host | --host=*) |
| get_argument $* |
| HOST="$RESULT" |
| verify_arch_os_tuple "$HOST" |
| ;; |
| -j | -j=*) |
| get_argument $* |
| NUM_PARALLEL_BUILDS="$RESULT" |
| ;; |
| --list-supported) |
| echo "All supported configurations are (host -> target):" |
| list_all_supported |
| exit 0 |
| ;; |
| --make-link | --make-link=*) |
| get_argument $* |
| MAKE_LINK="$RESULT" |
| ;; |
| --outdir | --outdir=*) |
| get_argument $* |
| OUT_DIR="$RESULT" |
| ;; |
| --strip) |
| STRIP="yes" |
| ;; |
| --sysroot | --sysroot=*) |
| get_argument $* |
| SYSROOT="$RESULT" |
| [ -d "$SYSROOT" ] || \ |
| die "Sysroot directory $SYSROOT does not appear to exist" |
| ;; |
| --target | --target=*) |
| get_argument $* |
| TARGET="$RESULT" |
| verify_arch_os_tuple "$TARGET" |
| ;; |
| *) |
| die "Unrecognized option '$1'. Use '--help' for usage." |
| ;; |
| esac |
| shift |
| if [ -n "$SKIP_EXTRA_ARG" ] |
| then |
| shift |
| fi |
| done |
| |
| # Post-processing |
| if [ -z "$TARGET" ] |
| then |
| die "--target required" |
| fi |
| |
| if ! is_configuration_supported && [ -z "$force" ] |
| then |
| die "Configuration not supported. Use --force to try anyway." |
| fi |
| |
| if [ -z "$SYSROOT" ] && [ -z "$force" ] |
| then |
| if [ "$BUILD" != "$HOST" ] |
| then |
| die "Sysroot expected when host differs from build system. Use --force to try anyway." |
| fi |
| |
| split_arch_os "$TARGET" |
| local target_os="$RESULT_OS" |
| if [ "$BUILD" != "$TARGET" ] && [ "$target_os" != "none" ] |
| then |
| die "Sysroot expected when target OS differs build OS. Use --force to try anyway." |
| fi |
| fi |
| |
| mkdir -p "$OUT_DIR" || die "Unable to create directory $OUT_DIR" |
| ARCHIVE_DIR="$OUT_DIR/archives" |
| mkdir -p "$ARCHIVE_DIR" || die "Unable to create directory $ARCHIVE_DIR" |
| } |
| |
| get_tool_verinfo() |
| { |
| . ${SCRIPT_DIR}/toolvers |
| GNU_MIRROR="https://mirrors.kernel.org/gnu" |
| BINUTILS_REPO="$GNU_MIRROR/binutils/binutils-$BINUTILS_VER.tar.bz2" |
| GCC_REPO="$GNU_MIRROR/gcc/gcc-$GCC_VER/gcc-$GCC_VER.tar.bz2" |
| GDB_REPO="$GNU_MIRROR/gdb/gdb-$GDB_VER.tar.xz" |
| GMP_REPO="$GNU_MIRROR/gmp/gmp-$GMP_VER.tar.bz2" |
| MPC_REPO="$GNU_MIRROR/mpc/mpc-$MPC_VER.tar.gz" |
| MPFR_REPO="$GNU_MIRROR/mpfr/mpfr-$MPFR_VER.tar.bz2" |
| } |
| |
| get_component_attribute() |
| { |
| local component="$1" |
| local suffix="$2" |
| local component_uppercase="$(echo "$component" \ |
| | tr '[:lower:]' '[:upper:]')" |
| local var_name="${component_uppercase}_${suffix}" |
| |
| RESULT="${!var_name}" |
| } |
| |
| # Use the "standard" set of tools except for native builds of a bare- |
| # metal toolset, for which we also build gdb. |
| build_tool_list() |
| { |
| split_arch_os "$TARGET" |
| local target_arch="$RESULT_ARCH" |
| local target_os="$RESULT_OS" |
| |
| if [ "$BUILD" == "$HOST" ] && [ "$target_os" == "none" ] |
| then |
| RESULT="$TOOLS gdb" |
| else |
| RESULT="$TOOLS" |
| fi |
| } |
| |
| maybe_download_sources() |
| { |
| build_tool_list |
| local all_tools="$RESULT" |
| local component |
| for component in $all_tools $HOST_LIBS |
| do |
| get_component_attribute "$component" "REPO" |
| local component_repo="$RESULT" |
| local component_tarfile="$(basename "$component_repo")" |
| get_component_attribute "$component" "VER" |
| local component_ver="$RESULT" |
| local component_source_dir="$OUT_DIR/$component-$component_ver" |
| if [ ! -f "$component_source_dir/.extracted" ] |
| then |
| # Download tarfile |
| if [ ! -f "$ARCHIVE_DIR/$component_tarfile" ] |
| then |
| echo "Fetching $component-$component_ver" |
| wget -P "$ARCHIVE_DIR" -N "$component_repo" \ |
| || die "Failed to retrieve from $component_repo" |
| fi |
| |
| echo "Checking $component_tarfile integrity" |
| get_component_attribute "$component" "HASH" |
| local component_hash="$RESULT" |
| [ "$(shasum -a 256 -b "$ARCHIVE_DIR/$component_tarfile" \ |
| | cut -f1 -d' ')" \ |
| == "$component_hash" ] || \ |
| die "$component_tarfile failed integrity check" |
| |
| echo "Extracting $component_tarfile" |
| pushd "$OUT_DIR" > /dev/null || die "Unable to change to $OUT_DIR" |
| rm -rf "$component_source_dir" \ |
| || die "Failed removing $component_source_dir" |
| tar xf "$ARCHIVE_DIR/$component_tarfile" \ |
| || die "Failed extracting $component_tarfile" |
| |
| local patch_filename="$SCRIPT_DIR/patches/${component}-patch.txt" |
| if [ -f "$patch_filename" ] |
| then |
| echo "Patching $component" |
| local src_dir="${component}-${component_ver}" |
| patch -d "${src_dir}" -p1 < "$patch_filename" \ |
| || die "Failed to patch '${src_dir}'" |
| fi |
| |
| touch "${component_source_dir}/.extracted" \ |
| || die "Failed to create ${component_source_dir}/.extracted" |
| popd > /dev/null || die "popd failed" |
| fi |
| done |
| } |
| |
| get_build_dir() |
| { |
| local component="$1" |
| local is_host_lib="$2" # If set, the TARGET is not applicable |
| |
| get_component_attribute "$component" "VER" |
| local component_ver="$RESULT" |
| if [ "$HOST" == "$TARGET" ] || [ "$is_host_lib" != "0" ] |
| then |
| RESULT="$OUT_DIR/build/${component}-${component_ver}_${HOST}" |
| else |
| RESULT="$OUT_DIR/build/${component}-${component_ver}_${HOST}_to_${TARGET}" |
| fi |
| } |
| |
| # Determine where the tools will be installed. |
| get_install_dir() |
| { |
| canonicalize_target_name "$TARGET" |
| local normalized_target="$RESULT" |
| |
| get_component_attribute "gcc" "VER" |
| local gcc_ver="$RESULT" |
| |
| if [ "$HOST" == "$TARGET" ] |
| then |
| RESULT="$OUT_DIR/$normalized_target-$gcc_ver-native" |
| else |
| canonicalize_target_name "$HOST" |
| local normalized_host="$RESULT" |
| split_arch_os "$normalized_host" |
| local normalized_host_arch="$RESULT_ARCH" |
| # The output dir has an uppercase OS name. |
| local normalized_host_os="$(echo ${RESULT_OS:0:1} | tr '[:lower:]' '[:upper:]')${RESULT_OS:1}" |
| RESULT="$OUT_DIR/$normalized_target-$gcc_ver-$normalized_host_os-$normalized_host_arch" |
| fi |
| } |
| |
| get_host_lib_install_dir() |
| { |
| local lib_name="$1" |
| |
| get_component_attribute "$lib_name" "VER" |
| local lib_ver="$RESULT" |
| RESULT="$OUT_DIR/host_libs/${HOST}/${lib_name}-${lib_ver}" |
| } |
| |
| init_config_options() |
| { |
| CONFIG_OPTIONS="$(echo "$*" | sed -E -e 's/ +/ /g')" |
| } |
| |
| add_config_options() |
| { |
| local config_var_name="CONFIG_$1" |
| if [ ! -z "${!config_var_name}" ] |
| then |
| if [ -z "$CONFIG_OPTIONS" ] |
| then |
| CONFIG_OPTIONS="${!config_var_name}" |
| else |
| CONFIG_OPTIONS="${CONFIG_OPTIONS}:${!config_var_name}" |
| fi |
| CONFIG_OPTIONS=$(echo "${CONFIG_OPTIONS}" \ |
| | sed -E -e "s/[ \t\n]*:[ \t\n]*/:/g") |
| fi |
| } |
| |
| fix_lib_configs() |
| { |
| for host_lib in $HOST_LIBS |
| do |
| get_host_lib_install_dir "$host_lib" |
| local install_dir="$RESULT" |
| local escaped_dir="$(echo "$install_dir" | sed -E -e 's/\//\\\//g')" |
| CONFIG_OPTIONS="$(echo $CONFIG_OPTIONS \ |
| | sed -E -e "s/(--with-${host_lib}=)/\1${escaped_dir}/g")" |
| done |
| } |
| |
| # Add a flag into the configuration options. If the flag is already present |
| # in the configuration option string, inserts the value into the |
| add_to_flags() |
| { |
| local flagname="$1" |
| local flagvalue="$2" |
| |
| # This test assumes that the configuration option will not be at the start |
| # of the string. |
| if $(echo $CONFIG_OPTIONS | grep -q ":${flagname}=") |
| then |
| CONFIG_OPTIONS=$(echo $CONFIG_OPTIONS \ |
| | sed -E -e "s/${flagname}=/${flagname}=${flagvalue} /") |
| else |
| CONFIG_OPTIONS="$CONFIG_OPTIONS:${flagname}=${flagvalue}" |
| fi |
| } |
| |
| # Add extra flags needed to build as needed for the build/host/target |
| # combo (e.g., CFLAGS, CFLAGS_FOR_TARGET...) |
| add_cross_build_options() |
| { |
| local tool |
| local uppercase_tool |
| if [ "$BUILD" != "$HOST" ] |
| then |
| add_to_flags "CC_FOR_BUILD" "gcc" |
| fi |
| |
| if [ "$BUILD" != "$TARGET" ] |
| then |
| split_arch_os "$TARGET" |
| local target_os="$RESULT_OS" |
| canonicalize_target_name "$TARGET" |
| local normalized_target="$RESULT" |
| |
| if ! [ -z "$SYSROOT" ] && [ "$target_os" != "none" ] |
| then |
| CONFIG_OPTIONS="$CONFIG_OPTIONS:--with-sysroot=${SYSROOT}" |
| fi |
| # Specify target-specific tools. Surprisingly, when gcc builds |
| # libgcc if these aren't specified it will use the unprefixed |
| # tools even if the prefixed tools are in the PATH. |
| local tool |
| for tool in $ALL_GNU_TOOLS |
| do |
| uppercase_tool="$(echo "$tool" | tr '[:lower:]' '[:upper:]')" |
| add_to_flags "${uppercase_tool}_FOR_TARGET" "${normalized_target}-${tool}" |
| done |
| add_to_flags "CC_FOR_TARGET" "${normalized_target}-gcc" |
| add_to_flags "CXX_FOR_TARGET" "${normalized_target}-g++" |
| fi |
| } |
| |
| # Build the configuration options for a specific module, including relevant |
| # environment variables of the forms: |
| # CONFIG_<module> |
| # CONFIG_<module>_{HOST|TARGET}_<arch> |
| # CONFIG_<module>_{HOST|TARGET}_<os> |
| # CONFIG_<module>_{HOST|TARGET}<arch>_<os> |
| # CONFIG_<module>_TOOLS_<host-tools> |
| build_config_options() |
| { |
| local component="$1" |
| local is_host_lib="$2" # If set, the TARGET is not applicable |
| local install_dir="$3" |
| |
| local uppercase_component="$(echo "$component" \ |
| | tr '[:lower:]' '[:upper:]')" |
| |
| split_arch_os "$HOST" |
| local host_arch="$RESULT_ARCH" |
| local host_os="$RESULT_OS" |
| split_arch_os "$TARGET" |
| local target_arch="$RESULT_ARCH" |
| local target_os="$RESULT_OS" |
| |
| init_config_options "--prefix=$install_dir" |
| if [ "$HOST" != "$BUILD" ] |
| then |
| canonicalize_target_name "$HOST" |
| CONFIG_OPTIONS="$CONFIG_OPTIONS:--host=${RESULT}" |
| fi |
| if [ "$TARGET" != "$HOST" ] && [ "$is_host_lib" == "0" ] |
| then |
| canonicalize_target_name "$TARGET" |
| CONFIG_OPTIONS="$CONFIG_OPTIONS:--target=${RESULT}" |
| fi |
| add_config_options "$uppercase_component" |
| add_config_options "${uppercase_component}_HOST_${host_arch}" |
| add_config_options "${uppercase_component}_HOST_${host_os}" |
| add_config_options "${uppercase_component}_HOST_${host_arch}_${host_os}" |
| if [ "$is_host_lib" == "0" ] |
| then |
| add_config_options "${uppercase_component}_TARGET_${target_arch}" |
| add_config_options "${uppercase_component}_TARGET_${target_os}" |
| add_config_options "${uppercase_component}_TARGET_${target_arch}_${target_os}" |
| fi |
| |
| # Apply options that are specific to the host compiler, if we will |
| # be using it (if we're doing a cross-compilation then we are |
| # using a compiler that we built, and these options aren't relevant). |
| if [ "$HOST" == "$BUILD" ] && [ ! -z "$HOST_TOOLS" ] |
| then |
| add_config_options "${uppercase_component}_TOOLS_${HOST_TOOLS}" |
| fi |
| |
| # Fix references to libraries (gmp, etc.) |
| fix_lib_configs |
| |
| # Indicate location of sysroot |
| if [ "$is_host_lib" == "0" ] |
| then |
| add_cross_build_options |
| fi |
| } |
| |
| canonicalize_target_name() |
| { |
| RESULT="$(echo "$1" \ |
| | sed -E -e 's/arm-none/arm-eabi/' \ |
| | sed -E -e 's/([a-zA-Z0-9_]+)-none/\1-elf/')" |
| } |
| |
| do_configure() |
| { |
| local install_dir="$1" |
| |
| build_config_options "$component" "$is_host_lib" "$install_dir" |
| (IFS=':' && "$OUT_DIR/${component}-${component_ver}/configure" \ |
| $CONFIG_OPTIONS) |
| if [ "$?" != "0" ] |
| then |
| die "Failed to configure $component" |
| fi |
| } |
| |
| build_component() |
| { |
| local component="$1" |
| # Host libraries don't have a separate host/target -- they are built for a |
| # single architecture. So, we can ignore the TARGET. |
| local is_host_lib="$2" |
| |
| get_component_attribute "$component" "VER" |
| local component_ver="$RESULT" |
| get_build_dir "$component" "$is_host_lib" |
| local build_dir="$RESULT" |
| if [ "$is_host_lib" == "0" ] |
| then |
| get_install_dir |
| else |
| get_host_lib_install_dir "$component" |
| fi |
| local install_dir="$RESULT" |
| if [ ! -f $build_dir/built.txt ] |
| then |
| mkdir -p "$build_dir" || die "Unable to create directory $build_dir" |
| pushd "$build_dir" > /dev/null || die "Unable to pushd $build_dir" |
| echo "Configuring $component" |
| do_configure "$install_dir" |
| echo "Building $component" |
| make -j ${NUM_PARALLEL_BUILDS} || die "Failed to build $component" |
| echo "Installing $component" |
| make -j ${NUM_PARALLEL_BUILDS} install || die "Failed to install $component" |
| touch built.txt || die "Failed to create $build_dir/built.txt" |
| popd > /dev/null || die "Unable to popd" |
| fi |
| } |
| |
| build_components() |
| { |
| maybe_download_sources |
| get_install_dir |
| local install_dir="$RESULT" |
| |
| # Mucking with the path makes configuration significantly easier. |
| if [ "$BUILD" == "$HOST" ] |
| then |
| export PATH="$PATH:${install_dir}/bin" |
| fi |
| |
| local lib |
| for lib in $HOST_LIBS |
| do |
| build_component $lib 1 |
| done |
| build_tool_list |
| local all_tools="$RESULT" |
| for tool in $all_tools |
| do |
| build_component $tool 0 |
| done |
| |
| if [ -n "$STRIP" ] |
| then |
| if [ "$BUILD" == "$HOST" ] |
| then |
| local strip_util="strip" |
| else |
| local strip_util="${HOST}-strip" |
| fi |
| local filename |
| for filename in $(find "${install_dir}/bin" -type f) \ |
| $(find "${install_dir}/libexec" -type f) |
| do |
| (file "${filename}" | grep -q ELF) && ${strip_util} "${filename}" |
| done |
| fi |
| } |
| |
| gather_host_info |
| process_opts $* |
| get_tool_verinfo |
| if [ "$BUILD" != "$HOST" ] |
| then |
| # First, build a BUILD->HOST cross-compiler |
| ORIG_TARGET="$TARGET" |
| TARGET="$HOST" |
| HOST="$BUILD" |
| build_components |
| HOST="$TARGET" |
| TARGET="$ORIG_TARGET" |
| if [ "$HOST" != "$TARGET" ] |
| then |
| # Canadian cross-compile, also build a BUILD->TARGET cross-compiler |
| ORIG_HOST="$HOST" |
| HOST="$BUILD" |
| build_components |
| HOST="$ORIG_HOST" |
| fi |
| fi |
| build_components |
| # In certain unnamed environments, we may need an architecture- |
| # independent way to find the results of a build. To help, we |
| # optionally create a link to the installation in the cwd. |
| if [ -n "$MAKE_LINK" ] |
| then |
| get_install_dir |
| ln -fns "$RESULT" "$MAKE_LINK" || die "Failed to make '$MAKE_LINK' link" |
| fi |
| exit 0 |
| |