toolchain/helpers.mk

   1 # This Makefile fragment declares toolchain related helper functions.
   2
   3 # The copy_toolchain_lib_root function copies a toolchain library and
   4 # its symbolic links from the sysroot directory to the target
   5 # directory. Note that this function is used both by the external
   6 # toolchain logic, and the glibc package, so care must be taken when
   7 # changing this function.
   8 #
   9 # Most toolchains (CodeSourcery ones) have their libraries either in
  10 # /lib or /usr/lib relative to their ARCH_SYSROOT_DIR, so we search
  11 # libraries in:
  12 #
  13 #  $${ARCH_LIB_DIR}
  14 #  usr/$${ARCH_LIB_DIR}
  15 #
  16 # Buildroot toolchains, however, have basic libraries in /lib, and
  17 # libstdc++/libgcc_s in /usr/<target-name>/lib(64), so we also need to
  18 # search libraries in:
  19 #
  20 #  usr/$(TOOLCHAIN_EXTERNAL_PREFIX)/$${ARCH_LIB_DIR}
  21 #
  22 # Linaro toolchains have most libraries in lib/<target-name>/, so we
  23 # need to search libraries in:
  24 #
  25 #  $${ARCH_LIB_DIR}/$(TOOLCHAIN_EXTERNAL_PREFIX)
  26 #
  27 # And recent Linaro toolchains have the GCC support libraries
  28 # (libstdc++, libgcc_s, etc.) into a separate directory, outside of
  29 # the sysroot, that we called the "SUPPORT_LIB_DIR", into which we
  30 # need to search as well.
  31 #
  32 # Thanks to ARCH_LIB_DIR we also take into account toolchains that
  33 # have the libraries in lib64 and usr/lib64.
  34 #
  35 # Please be very careful to check the major toolchain sources:
  36 # Buildroot, Crosstool-NG, CodeSourcery and Linaro before doing any
  37 # modification on the below logic.
  38 #
  39 # $1: arch specific sysroot directory
  40 # $2: support libraries directory (can be empty)
  41 # $3: library directory ('lib' or 'lib64') from which libraries must be copied
  42 # $4: library name
  43 # $5: destination directory of the libary, relative to $(TARGET_DIR)
  44 #
  45 copy_toolchain_lib_root = \
  46         ARCH_SYSROOT_DIR="$(strip $1)"; \
  47         SUPPORT_LIB_DIR="$(strip $2)" ; \
  48         ARCH_LIB_DIR="$(strip $3)" ; \
  49         LIB="$(strip $4)"; \
  50         DESTDIR="$(strip $5)" ; \
  51 \
  52         for dir in \
  53                 $${ARCH_SYSROOT_DIR}/$${ARCH_LIB_DIR}/$(TOOLCHAIN_EXTERNAL_PREFIX) \
  54                 $${ARCH_SYSROOT_DIR}/usr/$(TOOLCHAIN_EXTERNAL_PREFIX)/$${ARCH_LIB_DIR} \
  55                 $${ARCH_SYSROOT_DIR}/$${ARCH_LIB_DIR} \
  56                 $${ARCH_SYSROOT_DIR}/usr/$${ARCH_LIB_DIR} \
  57                 $${SUPPORT_LIB_DIR} ; do \
  58                 LIBSPATH=`find $${dir} -maxdepth 1 -name "$${LIB}" 2>/dev/null` ; \
  59                 if test -n "$${LIBSPATH}" ; then \
  60                         break ; \
  61                 fi \
  62         done ; \
  63         mkdir -p $(TARGET_DIR)/$${DESTDIR}; \
  64         for LIBPATH in $${LIBSPATH} ; do \
  65                 while true ; do \
  66                         LIBNAME=`basename $${LIBPATH}`; \
  67                         LIBDIR=`dirname $${LIBPATH}` ; \
  68                         LINKTARGET=`readlink $${LIBPATH}` ; \
  69                         rm -fr $(TARGET_DIR)/$${DESTDIR}/$${LIBNAME}; \
  70                         if test -h $${LIBPATH} ; then \
  71                                 ln -sf `basename $${LINKTARGET}` $(TARGET_DIR)/$${DESTDIR}/$${LIBNAME} ; \
  72                         elif test -f $${LIBPATH}; then \
  73                                 $(INSTALL) -D -m0755 $${LIBPATH} $(TARGET_DIR)/$${DESTDIR}/$${LIBNAME}; \
  74                         else \
  75                                 exit -1; \
  76                         fi; \
  77                         if test -z "$${LINKTARGET}" ; then \
  78                                 break ; \
  79                         fi ; \
  80                         LIBPATH="`readlink -f $${LIBPATH}`"; \
  81                 done; \
  82         done; \
  83 \
  84         echo -n
  85
  86 #
  87 # Copy the full external toolchain sysroot directory to the staging
  88 # dir. The operation of this function is rendered a little bit
  89 # complicated by the support for multilib toolchains.
  90 #
  91 # We start by copying etc, lib, sbin and usr from the sysroot of the
  92 # selected architecture variant (as pointed by ARCH_SYSROOT_DIR). This
  93 # allows to import into the staging directory the C library and
  94 # companion libraries for the correct architecture variant. We
  95 # explictly only copy etc, lib, sbin and usr since other directories
  96 # might exist for other architecture variants (on Codesourcery
  97 # toolchain, the sysroot for the default architecture variant contains
  98 # the armv4t and thumb2 subdirectories, which are the sysroot for the
  99 # corresponding architecture variants), and we don't want to import
 100 # them.
 101 #
 102 # Then, if the selected architecture variant is not the default one
 103 # (i.e, if SYSROOT_DIR != ARCH_SYSROOT_DIR), then we :
 104 #
 105 #  * Import the header files from the default architecture
 106 #    variant. Header files are typically shared between the sysroots
 107 #    for the different architecture variants. If we use the
 108 #    non-default one, header files were not copied by the previous
 109 #    step, so we copy them here from the sysroot of the default
 110 #    architecture variant.
 111 #
 112 #  * Create a symbolic link that matches the name of the subdirectory
 113 #    for the architecture variant in the original sysroot. This is
 114 #    required as the compiler will by default look in
 115 #    sysroot_dir/arch_variant/ for libraries and headers, when the
 116 #    non-default architecture variant is used. Without this, the
 117 #    compiler fails to find libraries and headers.
 118 #
 119 # Some toolchains (i.e Linaro binary toolchains) store support
 120 # libraries (libstdc++, libgcc_s) outside of the sysroot, so we simply
 121 # copy all the libraries from the "support lib directory" into our
 122 # sysroot.
 123 #
 124 # Note that the 'locale' directories are not copied. They are huge
 125 # (400+MB) in CodeSourcery toolchains, and they are not really useful.
 126 #
 127 # $1: main sysroot directory of the toolchain
 128 # $2: arch specific sysroot directory of the toolchain
 129 # $3: arch specific subdirectory in the sysroot
 130 # $4: directory of libraries ('lib', 'lib32' or 'lib64')
 131 # $5: support lib directories (for toolchains storing libgcc_s,
 132 #     libstdc++ and other gcc support libraries outside of the
 133 #     sysroot)
 134 copy_toolchain_sysroot = \
 135         SYSROOT_DIR="$(strip $1)"; \
 136         ARCH_SYSROOT_DIR="$(strip $2)"; \
 137         ARCH_SUBDIR="$(strip $3)"; \
 138         ARCH_LIB_DIR="$(strip $4)" ; \
 139         SUPPORT_LIB_DIR="$(strip $5)" ; \
 140         for i in etc $${ARCH_LIB_DIR} sbin usr usr/$${ARCH_LIB_DIR}; do \
 141                 if [ -d $${ARCH_SYSROOT_DIR}/$$i ] ; then \
 142                         rsync -au --chmod=u=rwX,go=rX --exclude 'usr/lib/locale' \
 143                                 --exclude lib --exclude lib32 --exclude lib64 \
 144                                 $${ARCH_SYSROOT_DIR}/$$i/ $(STAGING_DIR)/$$i/ ; \
 145                 fi ; \
 146         done ; \
 147         if [ `readlink -f $${SYSROOT_DIR}` != `readlink -f $${ARCH_SYSROOT_DIR}` ] ; then \
 148                 if [ ! -d $${ARCH_SYSROOT_DIR}/usr/include ] ; then \
 149                         cp -a $${SYSROOT_DIR}/usr/include $(STAGING_DIR)/usr ; \
 150                 fi ; \
 151                 mkdir -p `dirname $(STAGING_DIR)/$${ARCH_SUBDIR}` ; \
 152                 relpath="./" ; \
 153                 nbslashs=`echo -n $${ARCH_SUBDIR} | sed 's%[^/]%%g' | wc -c` ; \
 154                 for slash in `seq 1 $${nbslashs}` ; do \
 155                         relpath=$${relpath}"../" ; \
 156                 done ; \
 157                 ln -s $${relpath} $(STAGING_DIR)/$${ARCH_SUBDIR} ; \
 158                 echo "Symlinking $(STAGING_DIR)/$${ARCH_SUBDIR} -> $${relpath}" ; \
 159         fi ; \
 160         if test -n "$${SUPPORT_LIB_DIR}" ; then \
 161                 cp -a $${SUPPORT_LIB_DIR}/* $(STAGING_DIR)/lib/ ; \
 162         fi ; \
 163         find $(STAGING_DIR) -type d | xargs chmod 755
 164
 165 #
 166 # Check the specified kernel headers version actually matches the
 167 # version in the toolchain.
 168 #
 169 # $1: sysroot directory
 170 # $2: kernel version string, in the form: X.Y
 171 #
 172 check_kernel_headers_version = \
 173         if ! support/scripts/check-kernel-headers.sh $(1) $(2); then \
 174                 exit 1; \
 175         fi
 176
 177 #
 178 # Check the availability of a particular glibc feature. This function
 179 # is used to check toolchain options that are always supported by
 180 # glibc, so we simply check that the corresponding option is properly
 181 # enabled.
 182 #
 183 # $1: Buildroot option name
 184 # $2: feature description
 185 #
 186 check_glibc_feature = \
 187         if [ "$($(1))" != "y" ] ; then \
 188                 echo "$(2) available in C library, please enable $(1)" ; \
 189                 exit 1 ; \
 190         fi
 191
 192 #
 193 # Check the availability of RPC support in a glibc toolchain
 194 #
 195 # $1: sysroot directory
 196 #
 197 check_glibc_rpc_feature = \
 198         IS_IN_LIBC=`test -f $(1)/usr/include/rpc/rpc.h && echo y` ; \
 199         if [ "$(BR2_TOOLCHAIN_HAS_NATIVE_RPC)" != "y" -a "$${IS_IN_LIBC}" = "y" ] ; then \
 200                 echo "RPC support available in C library, please enable BR2_TOOLCHAIN_EXTERNAL_INET_RPC" ; \
 201                 exit 1 ; \
 202         fi ; \
 203         if [ "$(BR2_TOOLCHAIN_HAS_NATIVE_RPC)" = "y" -a "$${IS_IN_LIBC}" != "y" ] ; then \
 204                 echo "RPC support not available in C library, please disable BR2_TOOLCHAIN_EXTERNAL_INET_RPC" ; \
 205                 exit 1 ; \
 206         fi
 207
 208 #
 209 # Check the correctness of a glibc external toolchain configuration.
 210 #  1. Check that the C library selected in Buildroot matches the one
 211 #     of the external toolchain
 212 #  2. Check that all the C library-related features are enabled in the
 213 #     config, since glibc always supports all of them
 214 #
 215 # $1: sysroot directory
 216 #
 217 check_glibc = \
 218         SYSROOT_DIR="$(strip $1)"; \
 219         if test `find $${SYSROOT_DIR}/ -maxdepth 2 -name 'ld-linux*.so.*' -o -name 'ld.so.*' -o -name 'ld64.so.*' | wc -l` -eq 0 ; then \
 220                 echo "Incorrect selection of the C library"; \
 221                 exit -1; \
 222         fi; \
 223         $(call check_glibc_feature,BR2_USE_MMU,MMU support) ;\
 224         $(call check_glibc_rpc_feature,$${SYSROOT_DIR})
 225
 226 #
 227 # Check that the selected C library really is musl
 228 #
 229 # $1: sysroot directory
 230 check_musl = \
 231         SYSROOT_DIR="$(strip $1)"; \
 232         if test ! -f $${SYSROOT_DIR}/lib/libc.so -o -e $${SYSROOT_DIR}/lib/libm.so ; then \
 233                 echo "Incorrect selection of the C library" ; \
 234                 exit -1; \
 235         fi
 236
 237 #
 238 # Check the conformity of Buildroot configuration with regard to the
 239 # uClibc configuration of the external toolchain, for a particular
 240 # feature.
 241 #
 242 # If 'Buildroot option name' ($2) is empty it means the uClibc option
 243 # is mandatory.
 244 #
 245 # $1: uClibc macro name
 246 # $2: Buildroot option name
 247 # $3: uClibc config file
 248 # $4: feature description
 249 #
 250 check_uclibc_feature = \
 251         IS_IN_LIBC=`grep -q "\#define $(1) 1" $(3) && echo y` ; \
 252         if [ -z "$(2)" ] ; then \
 253                 if [ "$${IS_IN_LIBC}" != "y" ] ; then \
 254                         echo "$(4) not available in C library, toolchain unsuitable for Buildroot" ; \
 255                         exit 1 ; \
 256                 fi ; \
 257         else \
 258                 if [ "$($(2))" != "y" -a "$${IS_IN_LIBC}" = "y" ] ; then \
 259                         echo "$(4) available in C library, please enable $(2)" ; \
 260                         exit 1 ; \
 261                 fi ; \
 262                 if [ "$($(2))" = "y" -a "$${IS_IN_LIBC}" != "y" ] ; then \
 263                         echo "$(4) not available in C library, please disable $(2)" ; \
 264                         exit 1 ; \
 265                 fi ; \
 266         fi
 267
 268 #
 269 # Check the correctness of a uclibc external toolchain configuration
 270 #  1. Check that the C library selected in Buildroot matches the one
 271 #     of the external toolchain
 272 #  2. Check that the features enabled in the Buildroot configuration
 273 #     match the features available in the uClibc of the external
 274 #     toolchain
 275 #
 276 # $1: sysroot directory
 277 #
 278 check_uclibc = \
 279         SYSROOT_DIR="$(strip $1)"; \
 280         if ! test -f $${SYSROOT_DIR}/usr/include/bits/uClibc_config.h ; then \
 281                 echo "Incorrect selection of the C library"; \
 282                 exit -1; \
 283         fi; \
 284         UCLIBC_CONFIG_FILE=$${SYSROOT_DIR}/usr/include/bits/uClibc_config.h ; \
 285         $(call check_uclibc_feature,__ARCH_USE_MMU__,BR2_USE_MMU,$${UCLIBC_CONFIG_FILE},MMU support) ;\
 286         $(call check_uclibc_feature,__UCLIBC_HAS_LFS__,,$${UCLIBC_CONFIG_FILE},Large file support) ;\
 287         $(call check_uclibc_feature,__UCLIBC_HAS_IPV6__,,$${UCLIBC_CONFIG_FILE},IPv6 support) ;\
 288         $(call check_uclibc_feature,__UCLIBC_HAS_RPC__,BR2_TOOLCHAIN_HAS_NATIVE_RPC,$${UCLIBC_CONFIG_FILE},RPC support) ;\
 289         $(call check_uclibc_feature,__UCLIBC_HAS_LOCALE__,BR2_ENABLE_LOCALE,$${UCLIBC_CONFIG_FILE},Locale support) ;\
 290         $(call check_uclibc_feature,__UCLIBC_HAS_WCHAR__,BR2_USE_WCHAR,$${UCLIBC_CONFIG_FILE},Wide char support) ;\
 291         $(call check_uclibc_feature,__UCLIBC_HAS_THREADS__,BR2_TOOLCHAIN_HAS_THREADS,$${UCLIBC_CONFIG_FILE},Thread support) ;\
 292         $(call check_uclibc_feature,__PTHREADS_DEBUG_SUPPORT__,BR2_TOOLCHAIN_HAS_THREADS_DEBUG,$${UCLIBC_CONFIG_FILE},Thread debugging support) ;\
 293         $(call check_uclibc_feature,__UCLIBC_HAS_THREADS_NATIVE__,BR2_TOOLCHAIN_HAS_THREADS_NPTL,$${UCLIBC_CONFIG_FILE},NPTL thread support) ;\
 294         $(call check_uclibc_feature,__UCLIBC_HAS_SSP__,BR2_TOOLCHAIN_HAS_SSP,$${UCLIBC_CONFIG_FILE},Stack Smashing Protection support)
 295
 296 #
 297 # Check that the Buildroot configuration of the ABI matches the
 298 # configuration of the external toolchain.
 299 #
 300 # $1: cross-gcc path
 301 # $2: cross-readelf path
 302 #
 303 check_arm_abi = \
 304         __CROSS_CC=$(strip $1) ; \
 305         __CROSS_READELF=$(strip $2) ; \
 306         EXT_TOOLCHAIN_TARGET=`LANG=C $${__CROSS_CC} -v 2>&1 | grep ^Target | cut -f2 -d ' '` ; \
 307         if ! echo $${EXT_TOOLCHAIN_TARGET} | grep -qE 'eabi(hf)?$$' ; then \
 308                 echo "External toolchain uses the unsuported OABI" ; \
 309                 exit 1 ; \
 310         fi ; \
 311         if ! echo 'int main(void) {}' | $${__CROSS_CC} -x c -o $(BUILD_DIR)/.br-toolchain-test.tmp - ; then \
 312                 rm -f $(BUILD_DIR)/.br-toolchain-test.tmp*; \
 313                 abistr_$(BR2_ARM_EABI)='EABI'; \
 314                 abistr_$(BR2_ARM_EABIHF)='EABIhf'; \
 315                 echo "Incorrect ABI setting: $${abistr_y} selected, but toolchain is incompatible"; \
 316                 exit 1 ; \
 317         fi ; \
 318         rm -f $(BUILD_DIR)/.br-toolchain-test.tmp*
 319
 320 #
 321 # Check that the external toolchain supports C++
 322 #
 323 # $1: cross-g++ path
 324 #
 325 check_cplusplus = \
 326         __CROSS_CXX=$(strip $1) ; \
 327         $${__CROSS_CXX} -v > /dev/null 2>&1 ; \
 328         if test $$? -ne 0 ; then \
 329                 echo "C++ support is selected but is not available in external toolchain" ; \
 330                 exit 1 ; \
 331         fi
 332
 333 #
 334 # Check that the cross-compiler given in the configuration exists
 335 #
 336 # $1: cross-gcc path
 337 #
 338 check_cross_compiler_exists = \
 339         __CROSS_CC=$(strip $1) ; \
 340         $${__CROSS_CC} -v > /dev/null 2>&1 ; \
 341         if test $$? -ne 0 ; then \
 342                 echo "Cannot execute cross-compiler '$${__CROSS_CC}'" ; \
 343                 exit 1 ; \
 344         fi
 345
 346 #
 347 # Check for toolchains known not to work with Buildroot. For now, we
 348 # only check for Angstrom toolchains, by looking at the vendor part of
 349 # the host tuple.
 350 #
 351 # $1: cross-gcc path
 352 #
 353 check_unusable_toolchain = \
 354         __CROSS_CC=$(strip $1) ; \
 355         vendor=`$${__CROSS_CC} -dumpmachine | cut -f2 -d'-'` ; \
 356         if test "$${vendor}" = "angstrom" ; then \
 357                 echo "Angstrom toolchains are not pure toolchains: they contain" ; \
 358                 echo "many other libraries than just the C library, which makes" ; \
 359                 echo "them unsuitable as external toolchains for build systems" ; \
 360                 echo "such as Buildroot." ; \
 361                 exit 1 ; \
 362         fi; \
 363         with_sysroot=`$${__CROSS_CC} -v 2>&1 |sed -r -e '/.* --with-sysroot=([^[:space:]]+)[[:space:]].*/!d; s//\1/'`; \
 364         if test "$${with_sysroot}"  = "/" ; then \
 365                 echo "Distribution toolchains are unsuitable for use by Buildroot," ; \
 366                 echo "as they were configured in a way that makes them non-relocatable,"; \
 367                 echo "and contain a lot of pre-built libraries that would conflict with"; \
 368                 echo "the ones Buildroot wants to build."; \
 369                 exit 1; \
 370         fi
 371
 372 #
 373 # Generate gdbinit file for use with Buildroot
 374 #
 375 gen_gdbinit_file = \
 376         mkdir -p $(STAGING_DIR)/usr/share/buildroot/ ; \
 377         echo "set sysroot $(STAGING_DIR)" > $(STAGING_DIR)/usr/share/buildroot/gdbinit