mirror of
https://git.busybox.net/buildroot.git
synced 2024-11-26 15:03:27 +08:00
8d33993395
check_fortran will display an error message if there is no Fortran
compiler in the toolchain. In the past, running into this error message
would be unlikely, since the Fortran test was only execuded when
BR2_TOOLCHAIN_HAS_FORTRAN was set.
However, since commit c7f641cbaa (toolchain/toolchain-external: always
call checks with dependencies), the Fortran check is unconditional. The
error itself benign, and the macro will handle the situation correctly,
since that is what it is designed to do. However, the error message
looks ugly and can be confusing.
[...]
>>> toolchain-external-custom Extracting
>>> toolchain-external-custom Patching
>>> toolchain-external-custom Configuring
/bin/bash: line 1: .../bin/aarch64-linux-gfortran: No such file or directory
>>> toolchain-external-custom Building
... everything continues normally ...
Let's suppress the error message, since triggerig the error is an
integral part of how the test works and doesn't mean that anything is
wrong.
Signed-off-by: Markus Mayer <mmayer@broadcom.com>
Signed-off-by: Yann E. MORIN <yann.morin.1998@free.fr>
557 lines
21 KiB
Makefile
557 lines
21 KiB
Makefile
# This Makefile fragment declares toolchain related helper functions.
|
|
|
|
# The copy_toolchain_lib_root function copies a toolchain library and
|
|
# its symbolic links from the sysroot directory to the target
|
|
# directory. Note that this function is used both by the external
|
|
# toolchain logic, and the glibc package, so care must be taken when
|
|
# changing this function.
|
|
#
|
|
# $1: library name pattern (can include glob wildcards)
|
|
#
|
|
copy_toolchain_lib_root = \
|
|
LIBPATTERN="$(strip $1)"; \
|
|
LIBPATHS=`find $(STAGING_DIR)/ -name "$${LIBPATTERN}" 2>/dev/null` ; \
|
|
for LIBPATH in $${LIBPATHS} ; do \
|
|
while true ; do \
|
|
LIBNAME=`basename $${LIBPATH}`; \
|
|
DESTDIR=`echo $${LIBPATH} | sed "s,^$(STAGING_DIR)/,," | xargs dirname` ; \
|
|
mkdir -p $(TARGET_DIR)/$${DESTDIR}; \
|
|
rm -fr $(TARGET_DIR)/$${DESTDIR}/$${LIBNAME}; \
|
|
if test -h $${LIBPATH} ; then \
|
|
cp -d $${LIBPATH} $(TARGET_DIR)/$${DESTDIR}/$${LIBNAME}; \
|
|
OLD_LIBPATH="$${LIBPATH}"; \
|
|
LIBPATH="`readlink -f $${LIBPATH}`"; \
|
|
if [ "$${LIBPATH}" = "" ]; then \
|
|
echo "LIBPATH empty after trying to resolve symlink $${OLD_LIBPATH}" 1>&2; \
|
|
exit 1; \
|
|
fi; \
|
|
elif test -f $${LIBPATH}; then \
|
|
$(INSTALL) -D -m0755 $${LIBPATH} $(TARGET_DIR)/$${DESTDIR}/$${LIBNAME}; \
|
|
break ; \
|
|
else \
|
|
exit -1; \
|
|
fi; \
|
|
done; \
|
|
done
|
|
|
|
#
|
|
# Copy the full external toolchain sysroot directory to the staging
|
|
# dir. The operation of this function is rendered a little bit
|
|
# complicated by the support for multilib toolchains.
|
|
#
|
|
# We start by copying etc, 'lib', sbin, usr and usr/'lib' from the
|
|
# sysroot of the selected architecture variant (as pointed to by
|
|
# ARCH_SYSROOT_DIR). This allows to import into the staging directory
|
|
# the C library and companion libraries for the correct architecture
|
|
# variant. 'lib' may not be literally 'lib' but could be something else,
|
|
# e.g. lib32-fp (as determined by ARCH_LIB_DIR) and we only want to copy
|
|
# that lib directory and no other. When copying usr, we therefore need
|
|
# to be extra careful not to include usr/lib* but we _do_ want to
|
|
# include usr/libexec.
|
|
# We are selective in the directories we copy since other directories
|
|
# might exist for other architecture variants (on Codesourcery
|
|
# toolchain, the sysroot for the default architecture variant contains
|
|
# the armv4t and thumb2 subdirectories, which are the sysroot for the
|
|
# corresponding architecture variants), and we don't want to import
|
|
# them.
|
|
#
|
|
# If ARCH_LIB_DIR is not a singular directory component, e.g.
|
|
# 'lib32/octeon2', then symbolic links in ARCH_LIB_DIR and
|
|
# usr/ARCH_LIB_DIR may be broken because Buildroot will flatten the
|
|
# directory structure (e.g. lib32/octeon2/foo is actually stored in
|
|
# lib/foo). This is only relevant for links that contain one or more ../
|
|
# components, as links to the current directory are always fine.
|
|
# We need to fix the broken links by removing the right amount of ../
|
|
# dots from the link destination.
|
|
# Once the link destination is valid again, it can be simplified to
|
|
# remove the dependency on intermediate directory symlinks.
|
|
#
|
|
# It is possible that ARCH_LIB_DIR does not contain the dynamic loader
|
|
# (ld*.so or similar) because it (or the main symlink to it) normally
|
|
# resides in /lib while ARCH_LIB_DIR may be something else (e.g. lib64,
|
|
# lib/<tuple>, ...). Therefore, copy the dynamic loader separately.
|
|
#
|
|
# Then, if the selected architecture variant is not the default one
|
|
# (i.e, if SYSROOT_DIR != ARCH_SYSROOT_DIR), then we :
|
|
#
|
|
# * Import the header files from the default architecture
|
|
# variant. Header files are typically shared between the sysroots
|
|
# for the different architecture variants. If we use the
|
|
# non-default one, header files were not copied by the previous
|
|
# step, so we copy them here from the sysroot of the default
|
|
# architecture variant.
|
|
#
|
|
# * Create a symbolic link that matches the name of the subdirectory
|
|
# for the architecture variant in the original sysroot. This is
|
|
# required as the compiler will by default look in
|
|
# sysroot_dir/arch_variant/ for libraries and headers, when the
|
|
# non-default architecture variant is used. Without this, the
|
|
# compiler fails to find libraries and headers.
|
|
#
|
|
# Some toolchains (i.e Linaro binary toolchains) store support
|
|
# libraries (libstdc++, libgcc_s) outside of the sysroot, so we simply
|
|
# copy all the libraries from the "support lib directory" into our
|
|
# sysroot.
|
|
#
|
|
# Note that the 'locale' directories are not copied. They are huge
|
|
# (400+MB) in CodeSourcery toolchains, and they are not really useful.
|
|
#
|
|
# $1: main sysroot directory of the toolchain
|
|
# $2: arch specific sysroot directory of the toolchain
|
|
# $3: arch specific subdirectory in the sysroot
|
|
# $4: directory of libraries ('lib', 'lib32' or 'lib64')
|
|
# $5: support lib directories (for toolchains storing libgcc_s,
|
|
# libstdc++ and other gcc support libraries outside of the
|
|
# sysroot)
|
|
copy_toolchain_sysroot = \
|
|
SYSROOT_DIR="$(strip $1)"; \
|
|
ARCH_SYSROOT_DIR="$(strip $2)"; \
|
|
ARCH_SUBDIR="$(strip $3)"; \
|
|
ARCH_LIB_DIR="$(strip $4)" ; \
|
|
SUPPORT_LIB_DIR="$(strip $5)" ; \
|
|
for i in etc $${ARCH_LIB_DIR} sbin usr usr/$${ARCH_LIB_DIR}; do \
|
|
if [ ! -d $${ARCH_SYSROOT_DIR}/$$i ] ; then \
|
|
continue ; \
|
|
fi ; \
|
|
if [ "$$i" = "usr" ]; then \
|
|
rsync -au --chmod=u=rwX,go=rX --exclude 'locale/' \
|
|
--include '/libexec*/' --exclude '/lib*/' \
|
|
$${ARCH_SYSROOT_DIR}/$$i/ $(STAGING_DIR)/$$i/ ; \
|
|
else \
|
|
rsync -au --chmod=u=rwX,go=rX --exclude 'locale/' \
|
|
$${ARCH_SYSROOT_DIR}/$$i/ $(STAGING_DIR)/$$i/ ; \
|
|
fi ; \
|
|
done ; \
|
|
for link in $$(find $(STAGING_DIR) -type l); do \
|
|
target=$$(readlink $${link}) ; \
|
|
if [ "$${target}" == "$${target$(SHARP_SIGN)/}" ] ; then \
|
|
continue ; \
|
|
fi ; \
|
|
relpath="$(call relpath_prefix,$${target$(SHARP_SIGN)/})" ; \
|
|
echo "Fixing symlink $${link} from $${target} to $${relpath}$${target$(SHARP_SIGN)/}" ; \
|
|
ln -sf $${relpath}$${target$(SHARP_SIGN)/} $${link} ; \
|
|
done ; \
|
|
relpath="$(call relpath_prefix,$${ARCH_LIB_DIR})" ; \
|
|
if [ "$${relpath}" != "" ]; then \
|
|
for i in $$(find -H $(STAGING_DIR)/$${ARCH_LIB_DIR} $(STAGING_DIR)/usr/$${ARCH_LIB_DIR} -type l -xtype l); do \
|
|
LINKTARGET=`readlink $$i` ; \
|
|
NEWLINKTARGET=$${LINKTARGET\#$$relpath} ; \
|
|
ln -sf $${NEWLINKTARGET} $$i ; \
|
|
$(call simplify_symlink,$$i,$(STAGING_DIR)) ; \
|
|
done ; \
|
|
fi ; \
|
|
if [[ ! $$(find $(STAGING_DIR)/lib -name 'ld*.so.*' -print -quit) ]]; then \
|
|
find $${ARCH_SYSROOT_DIR}/lib -name 'ld*.so.*' -print0 | xargs -0 -I % cp % $(STAGING_DIR)/lib/; \
|
|
fi ; \
|
|
if [ `readlink -f $${SYSROOT_DIR}` != `readlink -f $${ARCH_SYSROOT_DIR}` ] ; then \
|
|
if [ ! -d $${ARCH_SYSROOT_DIR}/usr/include ] ; then \
|
|
cp -a $${SYSROOT_DIR}/usr/include $(STAGING_DIR)/usr ; \
|
|
fi ; \
|
|
mkdir -p `dirname $(STAGING_DIR)/$${ARCH_SUBDIR}` ; \
|
|
relpath="$(call relpath_prefix,$${ARCH_SUBDIR})./" ; \
|
|
ln -s $${relpath} $(STAGING_DIR)/$${ARCH_SUBDIR} ; \
|
|
echo "Symlinking $(STAGING_DIR)/$${ARCH_SUBDIR} -> $${relpath}" ; \
|
|
fi ; \
|
|
if test -n "$${SUPPORT_LIB_DIR}" ; then \
|
|
cp -a $${SUPPORT_LIB_DIR}/* $(STAGING_DIR)/lib/ ; \
|
|
fi ; \
|
|
find $(STAGING_DIR) -type d -print0 | xargs -0 chmod 755
|
|
|
|
#
|
|
# Check the specified kernel headers version actually matches the
|
|
# version in the toolchain.
|
|
#
|
|
# $1: build directory
|
|
# $2: sysroot directory
|
|
# $3: kernel version string, in the form: X.Y
|
|
# $4: test to do for the latest kernel version, 'strict' or 'loose'
|
|
# always 'strict' if this is not the latest version.
|
|
#
|
|
check_kernel_headers_version = \
|
|
if ! support/scripts/check-kernel-headers.sh $(1) $(2) $(3) \
|
|
$(if $(BR2_TOOLCHAIN_HEADERS_LATEST),$(4),strict); \
|
|
then \
|
|
exit 1; \
|
|
fi
|
|
|
|
#
|
|
# Check the specific gcc version actually matches the version in the
|
|
# toolchain
|
|
#
|
|
# $1: path to gcc
|
|
# $2: expected gcc version
|
|
#
|
|
check_gcc_version = \
|
|
expected_version="$(strip $2)" ; \
|
|
if [ -z "$${expected_version}" ]; then \
|
|
exit 0 ; \
|
|
fi; \
|
|
real_version=`$(1) -dumpversion` ; \
|
|
if [[ ! "$${real_version}." =~ ^$${expected_version}\. ]] ; then \
|
|
printf "Incorrect selection of gcc version: expected %s.x, got %s\n" \
|
|
"$${expected_version}" "$${real_version}" ; \
|
|
exit 1 ; \
|
|
fi
|
|
|
|
#
|
|
# Check the availability of a particular glibc feature. This function
|
|
# is used to check toolchain options that are always supported by
|
|
# glibc, so we simply check that the corresponding option is properly
|
|
# enabled.
|
|
#
|
|
# $1: Buildroot option name
|
|
# $2: feature description
|
|
#
|
|
check_glibc_feature = \
|
|
if [ "$($(1))" != "y" ] ; then \
|
|
echo "$(2) available in C library, please enable $(1)" ; \
|
|
exit 1 ; \
|
|
fi
|
|
|
|
#
|
|
# Check the availability of RPC support in a glibc toolchain
|
|
#
|
|
# $1: sysroot directory
|
|
#
|
|
check_glibc_rpc_feature = \
|
|
IS_IN_LIBC=`test -f $(1)/usr/include/rpc/rpc.h && echo y` ; \
|
|
if [ "$(BR2_TOOLCHAIN_HAS_NATIVE_RPC)" != "y" -a "$${IS_IN_LIBC}" = "y" ] ; then \
|
|
echo "RPC support available in C library, please enable BR2_TOOLCHAIN_EXTERNAL_INET_RPC" ; \
|
|
exit 1 ; \
|
|
fi ; \
|
|
if [ "$(BR2_TOOLCHAIN_HAS_NATIVE_RPC)" = "y" -a "$${IS_IN_LIBC}" != "y" ] ; then \
|
|
echo "RPC support not available in C library, please disable BR2_TOOLCHAIN_EXTERNAL_INET_RPC" ; \
|
|
exit 1 ; \
|
|
fi
|
|
|
|
#
|
|
# Check the correctness of a glibc external toolchain configuration.
|
|
# 1. Check that the C library selected in Buildroot matches the one
|
|
# of the external toolchain
|
|
# 2. Check that all the C library-related features are enabled in the
|
|
# config, since glibc always supports all of them
|
|
#
|
|
# $1: sysroot directory
|
|
#
|
|
check_glibc = \
|
|
SYSROOT_DIR="$(strip $1)"; \
|
|
if test `find -L $${SYSROOT_DIR}/ -maxdepth 2 -name 'ld-linux*.so.*' -o -name 'ld.so.*' -o -name 'ld64.so.*' | wc -l` -eq 0 ; then \
|
|
echo "Incorrect selection of the C library"; \
|
|
exit -1; \
|
|
fi; \
|
|
$(call check_glibc_feature,BR2_USE_MMU,MMU support) ;\
|
|
$(call check_glibc_rpc_feature,$${SYSROOT_DIR})
|
|
|
|
#
|
|
# Check that the selected C library really is musl
|
|
#
|
|
# $1: cross-gcc path
|
|
# $2: cross-readelf path
|
|
check_musl = \
|
|
__CROSS_CC=$(strip $1) ; \
|
|
libc_a_path=`$${__CROSS_CC} -print-file-name=libc.a` ; \
|
|
if ! strings $${libc_a_path} | grep -q MUSL_LOCPATH ; then \
|
|
echo "Incorrect selection of the C library" ; \
|
|
exit -1; \
|
|
fi
|
|
|
|
#
|
|
# Check the conformity of Buildroot configuration with regard to the
|
|
# uClibc configuration of the external toolchain, for a particular
|
|
# feature.
|
|
#
|
|
# If 'Buildroot option name' ($2) is empty it means the uClibc option
|
|
# is mandatory.
|
|
#
|
|
# $1: uClibc macro name
|
|
# $2: Buildroot option name
|
|
# $3: uClibc config file
|
|
# $4: feature description
|
|
#
|
|
check_uclibc_feature = \
|
|
IS_IN_LIBC=`grep -q "\#define $(1) 1" $(3) && echo y` ; \
|
|
if [ -z "$(2)" ] ; then \
|
|
if [ "$${IS_IN_LIBC}" != "y" ] ; then \
|
|
echo "$(4) not available in C library, toolchain unsuitable for Buildroot" ; \
|
|
exit 1 ; \
|
|
fi ; \
|
|
else \
|
|
if [ "$($(2))" != "y" -a "$${IS_IN_LIBC}" = "y" ] ; then \
|
|
echo "$(4) available in C library, please enable $(2)" ; \
|
|
exit 1 ; \
|
|
fi ; \
|
|
if [ "$($(2))" = "y" -a "$${IS_IN_LIBC}" != "y" ] ; then \
|
|
echo "$(4) not available in C library, please disable $(2)" ; \
|
|
exit 1 ; \
|
|
fi ; \
|
|
fi
|
|
|
|
#
|
|
# Check the correctness of a uclibc external toolchain configuration
|
|
# 1. Check that the C library selected in Buildroot matches the one
|
|
# of the external toolchain
|
|
# 2. Check that the features enabled in the Buildroot configuration
|
|
# match the features available in the uClibc of the external
|
|
# toolchain
|
|
#
|
|
# $1: sysroot directory
|
|
#
|
|
check_uclibc = \
|
|
SYSROOT_DIR="$(strip $1)"; \
|
|
if ! test -f $${SYSROOT_DIR}/usr/include/bits/uClibc_config.h ; then \
|
|
echo "Incorrect selection of the C library"; \
|
|
exit -1; \
|
|
fi; \
|
|
UCLIBC_CONFIG_FILE=$${SYSROOT_DIR}/usr/include/bits/uClibc_config.h ; \
|
|
$(call check_uclibc_feature,__ARCH_USE_MMU__,BR2_USE_MMU,$${UCLIBC_CONFIG_FILE},MMU support) ;\
|
|
$(call check_uclibc_feature,__UCLIBC_HAS_LFS__,,$${UCLIBC_CONFIG_FILE},Large file support) ;\
|
|
$(call check_uclibc_feature,__UCLIBC_HAS_IPV6__,,$${UCLIBC_CONFIG_FILE},IPv6 support) ;\
|
|
$(call check_uclibc_feature,__UCLIBC_HAS_RPC__,BR2_TOOLCHAIN_HAS_NATIVE_RPC,$${UCLIBC_CONFIG_FILE},RPC support) ;\
|
|
$(call check_uclibc_feature,__UCLIBC_HAS_LOCALE__,BR2_ENABLE_LOCALE,$${UCLIBC_CONFIG_FILE},Locale support) ;\
|
|
$(call check_uclibc_feature,__UCLIBC_HAS_WCHAR__,BR2_USE_WCHAR,$${UCLIBC_CONFIG_FILE},Wide char support) ;\
|
|
$(call check_uclibc_feature,__UCLIBC_HAS_THREADS__,BR2_TOOLCHAIN_HAS_THREADS,$${UCLIBC_CONFIG_FILE},Thread support) ;\
|
|
$(call check_uclibc_feature,__PTHREADS_DEBUG_SUPPORT__,BR2_TOOLCHAIN_HAS_THREADS_DEBUG,$${UCLIBC_CONFIG_FILE},Thread debugging support) ;\
|
|
$(call check_uclibc_feature,__UCLIBC_HAS_THREADS_NATIVE__,BR2_TOOLCHAIN_HAS_THREADS_NPTL,$${UCLIBC_CONFIG_FILE},NPTL thread support)
|
|
|
|
#
|
|
# Check that the Buildroot configuration of the ABI matches the
|
|
# configuration of the external toolchain.
|
|
#
|
|
# $1: cross-gcc path
|
|
# $2: cross-readelf path
|
|
#
|
|
check_arm_abi = \
|
|
__CROSS_CC=$(strip $1) ; \
|
|
EXT_TOOLCHAIN_TARGET=`LANG=C $${__CROSS_CC} -v 2>&1 | grep ^Target | cut -f2 -d ' '` ; \
|
|
if ! echo $${EXT_TOOLCHAIN_TARGET} | grep -qE 'eabi(hf)?$$' ; then \
|
|
echo "External toolchain uses the unsuported OABI" ; \
|
|
exit 1 ; \
|
|
fi ; \
|
|
if ! echo 'int main(void) {}' | $${__CROSS_CC} -x c -o $(BUILD_DIR)/.br-toolchain-test.tmp - ; then \
|
|
rm -f $(BUILD_DIR)/.br-toolchain-test.tmp*; \
|
|
abistr_$(BR2_ARM_EABI)='EABI'; \
|
|
abistr_$(BR2_ARM_EABIHF)='EABIhf'; \
|
|
echo "Incorrect ABI setting: $${abistr_y} selected, but toolchain is incompatible"; \
|
|
exit 1 ; \
|
|
fi ; \
|
|
rm -f $(BUILD_DIR)/.br-toolchain-test.tmp*
|
|
|
|
#
|
|
# Check that the external toolchain supports C++
|
|
#
|
|
# $1: cross-g++ path
|
|
#
|
|
check_cplusplus = \
|
|
__CROSS_CXX=$(strip $1) ; \
|
|
__HAS_CXX=`$${__CROSS_CXX} -v > /dev/null 2>&1 && echo y`; \
|
|
if [ "$${__HAS_CXX}" != "y" -a "$(BR2_INSTALL_LIBSTDCPP)" = y ] ; then \
|
|
echo "C++ support is selected but is not available in external toolchain" ; \
|
|
exit 1 ; \
|
|
elif [ "$${__HAS_CXX}" = "y" -a "$(BR2_INSTALL_LIBSTDCPP)" != y ] ; then \
|
|
echo "C++ support is not selected but is available in external toolchain" ; \
|
|
exit 1 ; \
|
|
fi \
|
|
|
|
#
|
|
#
|
|
# Check that the external toolchain supports D language
|
|
#
|
|
# $1: cross-gdc path
|
|
#
|
|
check_dlang = \
|
|
__CROSS_GDC=$(strip $1) ; \
|
|
__o=$(BUILD_DIR)/.br-toolchain-test-dlang.tmp ; \
|
|
__HAS_DLANG=`printf 'import std.stdio;\nvoid main() { writeln("Hello World!"); }\n' | \
|
|
$${__CROSS_GDC} -x d -o $${__o} - >/dev/null 2>&1 && echo y`; \
|
|
rm -f $${__o}* ; \
|
|
if [ "$${__HAS_DLANG}" != "y" -a "$(BR2_TOOLCHAIN_HAS_DLANG)" = y ] ; then \
|
|
echo "D language support is selected but is not available in external toolchain" ; \
|
|
exit 1 ; \
|
|
elif [ "$${__HAS_DLANG}" = "y" -a "$(BR2_TOOLCHAIN_HAS_DLANG)" != y ] ; then \
|
|
echo "D language support is not selected but is available in external toolchain" ; \
|
|
exit 1 ; \
|
|
fi \
|
|
|
|
#
|
|
#
|
|
# Check that the external toolchain supports Fortran
|
|
#
|
|
# $1: cross-gfortran path
|
|
#
|
|
check_fortran = \
|
|
__CROSS_FC=$(strip $1) ; \
|
|
__o=$(BUILD_DIR)/.br-toolchain-test-fortran.tmp ; \
|
|
__HAS_FORTRAN=`printf 'program hello\n\tprint *, "Hello Fortran!\\\n"\nend program hello\n' | \
|
|
$${__CROSS_FC} -x f95 -ffree-form -o $${__o} - 2>/dev/null && echo y`; \
|
|
rm -f $${__o}* ; \
|
|
if [ "$${__HAS_FORTRAN}" != "y" -a "$(BR2_TOOLCHAIN_HAS_FORTRAN)" = y ] ; then \
|
|
echo "Fortran support is selected but is not available in external toolchain" ; \
|
|
exit 1 ; \
|
|
elif [ "$${__HAS_FORTRAN}" = "y" -a "$(BR2_TOOLCHAIN_HAS_FORTRAN)" != y ] ; then \
|
|
echo "Fortran support is not selected but is available in external toolchain" ; \
|
|
exit 1 ; \
|
|
fi \
|
|
|
|
#
|
|
#
|
|
# Check that the external toolchain supports OpenMP
|
|
#
|
|
# $1: cross-gcc path
|
|
#
|
|
check_openmp = \
|
|
__CROSS_CC=$(strip $1) ; \
|
|
__o=$(BUILD_DIR)/.br-toolchain-test-openmp.tmp ; \
|
|
__HAS_OPENMP=`printf '\#include <omp.h>\nint main(void) { return omp_get_thread_num(); }' | \
|
|
$${__CROSS_CC} -fopenmp -x c -o $${__o} - >/dev/null 2>&1 && echo y` ; \
|
|
rm -f $${__o}* ; \
|
|
if [ "$${__HAS_OPENMP}" != "y" -a "$(BR2_TOOLCHAIN_HAS_OPENMP)" = y ] ; then \
|
|
echo "OpenMP support is selected but is not available in external toolchain"; \
|
|
exit 1 ; \
|
|
elif [ "$${__HAS_OPENMP}" = "y" -a "$(BR2_TOOLCHAIN_HAS_OPENMP)" != y ] ; then \
|
|
echo "OpenMP support is not selected but is available in external toolchain"; \
|
|
exit 1 ; \
|
|
fi \
|
|
|
|
#
|
|
# Check that the cross-compiler given in the configuration exists
|
|
#
|
|
# $1: cross-gcc path
|
|
#
|
|
check_cross_compiler_exists = \
|
|
__CROSS_CC=$(strip $1) ; \
|
|
$${__CROSS_CC} -v > /dev/null 2>&1 ; \
|
|
if test $$? -ne 0 ; then \
|
|
echo "Cannot execute cross-compiler '$${__CROSS_CC}'" ; \
|
|
exit 1 ; \
|
|
fi
|
|
|
|
#
|
|
# Check for toolchains known not to work with Buildroot.
|
|
# - For the Angstrom toolchains, we check by looking at the vendor part of
|
|
# the host tuple.
|
|
# - Exclude distro-class toolchains which are not relocatable.
|
|
# - Exclude broken toolchains which return "libc.a" with -print-file-name.
|
|
# - Exclude toolchains used with wrong toolchain cflags or broken toolchains
|
|
# which return "libc.a" with -print-file-name and toolchain cflags.
|
|
# - Exclude toolchains which doesn't support --sysroot option.
|
|
#
|
|
# $1: cross-gcc path
|
|
# $1: toolchain cflags
|
|
#
|
|
check_unusable_toolchain = \
|
|
__CROSS_CC=$(strip $1) ; \
|
|
__TOOLCHAIN_CFLAGS=$(strip $2) ; \
|
|
vendor=`$${__CROSS_CC} -dumpmachine | cut -f2 -d'-'` ; \
|
|
if test "$${vendor}" = "angstrom" ; then \
|
|
echo "Angstrom toolchains are not pure toolchains: they contain" ; \
|
|
echo "many other libraries than just the C library, which makes" ; \
|
|
echo "them unsuitable as external toolchains for build systems" ; \
|
|
echo "such as Buildroot." ; \
|
|
exit 1 ; \
|
|
fi; \
|
|
with_sysroot=`$${__CROSS_CC} -v 2>&1 |sed -r -e '/.* --with-sysroot=([^[:space:]]+)[[:space:]].*/!d; s//\1/'`; \
|
|
if test "$${with_sysroot}" = "/" ; then \
|
|
echo "Distribution toolchains are unsuitable for use by Buildroot," ; \
|
|
echo "as they were configured in a way that makes them non-relocatable,"; \
|
|
echo "and contain a lot of pre-built libraries that would conflict with"; \
|
|
echo "the ones Buildroot wants to build."; \
|
|
exit 1; \
|
|
fi; \
|
|
libc_a_path=`$${__CROSS_CC} -print-file-name=libc.a` ; \
|
|
if test "$${libc_a_path}" = "libc.a" ; then \
|
|
echo "Unable to detect the toolchain sysroot, Buildroot cannot use this toolchain." ; \
|
|
exit 1 ; \
|
|
fi ; \
|
|
libc_a_archsysroot_path=`$${__CROSS_CC} $${__TOOLCHAIN_CFLAGS} -print-file-name=libc.a` ; \
|
|
if test "$${libc_a_archsysroot_path}" = "libc.a" ; then \
|
|
echo "Unable to detect the toolchain architecture sysroot." ; \
|
|
echo "Please check the Target Architecture Variant selected, the toolchains may not support it." ; \
|
|
echo "Buildroot cannot use this toolchain." ; \
|
|
exit 1 ; \
|
|
fi; \
|
|
sysroot_dir="$(call toolchain_find_sysroot,$${__CROSS_CC})" ; \
|
|
if test -z "$${sysroot_dir}" ; then \
|
|
echo "External toolchain doesn't support --sysroot. Cannot use." ; \
|
|
exit 1 ; \
|
|
fi
|
|
|
|
#
|
|
# Check if the toolchain has SSP (stack smashing protector) support
|
|
#
|
|
# $1: cross-gcc path
|
|
# $2: gcc ssp option
|
|
#
|
|
check_toolchain_ssp = \
|
|
__CROSS_CC=$(strip $1) ; \
|
|
__HAS_SSP=`echo 'void main(){}' | $${__CROSS_CC} -Werror -fstack-protector -x c - -o $(BUILD_DIR)/.br-toolchain-test.tmp >/dev/null 2>&1 && echo y` ; \
|
|
if [ "$(BR2_TOOLCHAIN_HAS_SSP)" != "y" -a "$${__HAS_SSP}" = "y" ] ; then \
|
|
echo "SSP support available in this toolchain, please enable BR2_TOOLCHAIN_EXTERNAL_HAS_SSP" ; \
|
|
exit 1 ; \
|
|
fi ; \
|
|
if [ "$(BR2_TOOLCHAIN_HAS_SSP)" = "y" -a "$${__HAS_SSP}" != "y" ] ; then \
|
|
echo "SSP support not available in this toolchain, please disable BR2_TOOLCHAIN_EXTERNAL_HAS_SSP" ; \
|
|
exit 1 ; \
|
|
fi ; \
|
|
__SSP_OPTION=$(2); \
|
|
if [ -n "$${__SSP_OPTION}" ] ; then \
|
|
if ! echo 'void main(){}' | $${__CROSS_CC} -Werror $${__SSP_OPTION} -x c - -o $(BUILD_DIR)/.br-toolchain-test.tmp >/dev/null 2>&1 ; then \
|
|
echo "SSP option $${__SSP_OPTION} not available in this toolchain, please select another SSP level" ; \
|
|
exit 1 ; \
|
|
fi; \
|
|
fi; \
|
|
rm -f $(BUILD_DIR)/.br-toolchain-test.tmp*
|
|
|
|
#
|
|
# Generate gdbinit file for use with Buildroot
|
|
#
|
|
gen_gdbinit_file = \
|
|
mkdir -p $(STAGING_DIR)/usr/share/buildroot/ ; \
|
|
echo "add-auto-load-safe-path $(STAGING_DIR)" > $(STAGING_DIR)/usr/share/buildroot/gdbinit ; \
|
|
echo "set sysroot $(STAGING_DIR)" >> $(STAGING_DIR)/usr/share/buildroot/gdbinit
|
|
|
|
# Given a path, determine the relative prefix (../) needed to return to the
|
|
# root level. Note that the last component is treated as a file component; use a
|
|
# trailing slash to force treating it as a directory. Examples:
|
|
# relpath_prefix(lib32) = ""
|
|
# relpath_prefix(lib32/octeon2) = "../"
|
|
# relpath_prefix(lib32/octeon2/) = "../../"
|
|
#
|
|
# $1: input path
|
|
define relpath_prefix
|
|
$$( \
|
|
prefix="" ; \
|
|
nbslashs=`printf $1 | sed 's%[^/]%%g' | wc -c` ; \
|
|
for slash in `seq 1 $${nbslashs}` ; do \
|
|
prefix=$${prefix}"../" ; \
|
|
done ; \
|
|
printf "$$prefix" ; \
|
|
)
|
|
endef
|
|
|
|
# Replace the destination of a symbolic link with a simpler version
|
|
# For example,
|
|
# usr/lib/libfoo.so -> ../../lib32/libfoo.so.1
|
|
# becomes
|
|
# usr/lib/libfoo.so -> ../../lib/libfoo.so.1
|
|
# since 'lib32' is a symlink to 'lib'.
|
|
#
|
|
# Likewise,
|
|
# usr/lib/octeon2/libbar.so -> ../../../lib32/octeon2/libbar.so.1
|
|
# becomes
|
|
# usr/lib/octeon2/libbar.so -> ../../lib/libbar.so.1
|
|
# assuming lib32->lib and lib/octeon2->lib.
|
|
#
|
|
# $1: symlink
|
|
# $2: base path
|
|
define simplify_symlink
|
|
( \
|
|
FULL_SRC="$$(readlink -f $$(dirname $1))/$$(basename $1)" ; \
|
|
FULL_DEST="$$(readlink -f $1)" ; \
|
|
FULL_BASE="$$(readlink -f $2)" ; \
|
|
REL_SRC="$${FULL_SRC#$${FULL_BASE}/}" ; \
|
|
REL_DEST="$${FULL_DEST#$${FULL_BASE}/}" ; \
|
|
DOTS="$(call relpath_prefix,$${REL_SRC})" ; \
|
|
ln -sf "$${DOTS}$${REL_DEST}" "$${FULL_SRC}" ; \
|
|
)
|
|
endef
|