helpers.mk 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316
  1. # This Makefile fragment declares helper functions, usefull to handle
  2. # non- buildroot-built toolchains, eg. purely external toolchains or
  3. # toolchains (internally) built using crosstool-NG.
  4. #
  5. # Copy a toolchain library and its symbolic links from the sysroot
  6. # directory to the target directory. Also optionaly strips the
  7. # library.
  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. for LIBPATH in $${LIBSPATH} ; do \
  64. LIBNAME=`basename $${LIBPATH}`; \
  65. LIBDIR=`dirname $${LIBPATH}` ; \
  66. while test \! -z "$${LIBNAME}" ; do \
  67. LIBPATH=$${LIBDIR}/$${LIBNAME} ; \
  68. rm -fr $(TARGET_DIR)/$${DESTDIR}/$${LIBNAME}; \
  69. mkdir -p $(TARGET_DIR)/$${DESTDIR}; \
  70. if test -h $${LIBPATH} ; then \
  71. cp -d $${LIBPATH} $(TARGET_DIR)/$${DESTDIR}/; \
  72. elif test -f $${LIBPATH}; then \
  73. $(INSTALL) -D -m0755 $${LIBPATH} $(TARGET_DIR)/$${DESTDIR}/$${LIBNAME}; \
  74. else \
  75. exit -1; \
  76. fi; \
  77. LIBNAME="`readlink $${LIBPATH}`"; \
  78. done; \
  79. done; \
  80. \
  81. echo -n
  82. #
  83. # Copy the full external toolchain sysroot directory to the staging
  84. # dir. The operation of this function is rendered a little bit
  85. # complicated by the support for multilib toolchains.
  86. #
  87. # We start by copying etc, lib, sbin and usr from the sysroot of the
  88. # selected architecture variant (as pointed by ARCH_SYSROOT_DIR). This
  89. # allows to import into the staging directory the C library and
  90. # companion libraries for the correct architecture variant. We
  91. # explictly only copy etc, lib, sbin and usr since other directories
  92. # might exist for other architecture variants (on Codesourcery
  93. # toolchain, the sysroot for the default architecture variant contains
  94. # the armv4t and thumb2 subdirectories, which are the sysroot for the
  95. # corresponding architecture variants), and we don't want to import
  96. # them.
  97. #
  98. # Then, if the selected architecture variant is not the default one
  99. # (i.e, if SYSROOT_DIR != ARCH_SYSROOT_DIR), then we :
  100. #
  101. # * Import the header files from the default architecture
  102. # variant. Header files are typically shared between the sysroots
  103. # for the different architecture variants. If we use the
  104. # non-default one, header files were not copied by the previous
  105. # step, so we copy them here from the sysroot of the default
  106. # architecture variant.
  107. #
  108. # * Create a symbolic link that matches the name of the subdirectory
  109. # for the architecture variant in the original sysroot. This is
  110. # required as the compiler will by default look in
  111. # sysroot_dir/arch_variant/ for libraries and headers, when the
  112. # non-default architecture variant is used. Without this, the
  113. # compiler fails to find libraries and headers.
  114. #
  115. # Some toolchains (i.e Linaro binary toolchains) store support
  116. # libraries (libstdc++, libgcc_s) outside of the sysroot, so we simply
  117. # copy all the libraries from the "support lib directory" into our
  118. # sysroot.
  119. #
  120. # Note that the 'locale' directories are not copied. They are huge
  121. # (400+MB) in CodeSourcery toolchains, and they are not really useful.
  122. #
  123. # $1: main sysroot directory of the toolchain
  124. # $2: arch specific sysroot directory of the toolchain
  125. # $3: arch specific subdirectory in the sysroot
  126. # $4: directory of libraries ('lib', 'lib32' or 'lib64')
  127. # $5: support lib directories (for toolchains storing libgcc_s,
  128. # libstdc++ and other gcc support libraries outside of the
  129. # sysroot)
  130. copy_toolchain_sysroot = \
  131. SYSROOT_DIR="$(strip $1)"; \
  132. ARCH_SYSROOT_DIR="$(strip $2)"; \
  133. ARCH_SUBDIR="$(strip $3)"; \
  134. ARCH_LIB_DIR="$(strip $4)" ; \
  135. SUPPORT_LIB_DIR="$(strip $5)" ; \
  136. for i in etc $${ARCH_LIB_DIR} sbin usr usr/$${ARCH_LIB_DIR}; do \
  137. if [ -d $${ARCH_SYSROOT_DIR}/$$i ] ; then \
  138. rsync -au --chmod=Du+w --exclude 'usr/lib/locale' \
  139. --exclude lib --exclude lib32 --exclude lib64 \
  140. $${ARCH_SYSROOT_DIR}/$$i/ $(STAGING_DIR)/$$i/ ; \
  141. fi ; \
  142. done ; \
  143. if [ `readlink -f $${SYSROOT_DIR}` != `readlink -f $${ARCH_SYSROOT_DIR}` ] ; then \
  144. if [ ! -d $${ARCH_SYSROOT_DIR}/usr/include ] ; then \
  145. cp -a $${SYSROOT_DIR}/usr/include $(STAGING_DIR)/usr ; \
  146. fi ; \
  147. mkdir -p `dirname $(STAGING_DIR)/$${ARCH_SUBDIR}` ; \
  148. relpath="./" ; \
  149. nbslashs=`echo -n $${ARCH_SUBDIR} | sed 's%[^/]%%g' | wc -c` ; \
  150. for slash in `seq 1 $${nbslashs}` ; do \
  151. relpath=$${relpath}"../" ; \
  152. done ; \
  153. ln -s $${relpath} $(STAGING_DIR)/$${ARCH_SUBDIR} ; \
  154. echo "Symlinking $(STAGING_DIR)/$${ARCH_SUBDIR} -> $${relpath}" ; \
  155. fi ; \
  156. if test -n "$${SUPPORT_LIB_DIR}" ; then \
  157. cp -a $${SUPPORT_LIB_DIR}/* $(STAGING_DIR)/lib/ ; \
  158. fi ; \
  159. find $(STAGING_DIR) -type d | xargs chmod 755
  160. #
  161. # Check the availability of a particular glibc feature. This function
  162. # is used to check toolchain options that are always supported by
  163. # glibc, so we simply check that the corresponding option is properly
  164. # enabled.
  165. #
  166. # $1: Buildroot option name
  167. # $2: feature description
  168. #
  169. check_glibc_feature = \
  170. if [ "$($(1))" != "y" ] ; then \
  171. echo "$(2) available in C library, please enable $(1)" ; \
  172. exit 1 ; \
  173. fi
  174. #
  175. # Check the availability of RPC support in a glibc toolchain
  176. #
  177. # $1: sysroot directory
  178. #
  179. check_glibc_rpc_feature = \
  180. IS_IN_LIBC=`test -f $(1)/usr/include/rpc/rpc.h && echo y` ; \
  181. if [ "$(BR2_TOOLCHAIN_HAS_NATIVE_RPC)" != "y" -a "$${IS_IN_LIBC}" = "y" ] ; then \
  182. echo "RPC support available in C library, please enable BR2_TOOLCHAIN_HAS_NATIVE_RPC" ; \
  183. exit 1 ; \
  184. fi ; \
  185. if [ "$(BR2_TOOLCHAIN_HAS_NATIVE_RPC)" = "y" -a "$${IS_IN_LIBC}" != "y" ] ; then \
  186. echo "RPC support not available in C library, please disable BR2_TOOLCHAIN_HAS_NATIVE_RPC" ; \
  187. exit 1 ; \
  188. fi
  189. #
  190. # Check the correctness of a glibc external toolchain configuration.
  191. # 1. Check that the C library selected in Buildroot matches the one
  192. # of the external toolchain
  193. # 2. Check that all the C library-related features are enabled in the
  194. # config, since glibc always supports all of them
  195. #
  196. # $1: sysroot directory
  197. #
  198. check_glibc = \
  199. SYSROOT_DIR="$(strip $1)"; \
  200. if test `find $${SYSROOT_DIR}/ -maxdepth 2 -name 'ld-linux*.so.*' -o -name 'ld.so.*' | wc -l` -eq 0 ; then \
  201. echo "Incorrect selection of the C library"; \
  202. exit -1; \
  203. fi; \
  204. $(call check_glibc_feature,BR2_LARGEFILE,Large file support) ;\
  205. $(call check_glibc_feature,BR2_INET_IPV6,IPv6 support) ;\
  206. $(call check_glibc_feature,BR2_ENABLE_LOCALE,Locale support) ;\
  207. $(call check_glibc_feature,BR2_USE_MMU,MMU support) ;\
  208. $(call check_glibc_feature,BR2_USE_WCHAR,Wide char support) ;\
  209. $(call check_glibc_rpc_feature,$${SYSROOT_DIR})
  210. #
  211. # Check the conformity of Buildroot configuration with regard to the
  212. # uClibc configuration of the external toolchain, for a particular
  213. # feature.
  214. #
  215. # $1: uClibc macro name
  216. # $2: Buildroot option name
  217. # $3: uClibc config file
  218. # $4: feature description
  219. #
  220. check_uclibc_feature = \
  221. IS_IN_LIBC=`grep -q "\#define $(1) 1" $(3) && echo y` ; \
  222. if [ "$($(2))" != "y" -a "$${IS_IN_LIBC}" = "y" ] ; then \
  223. echo "$(4) available in C library, please enable $(2)" ; \
  224. exit 1 ; \
  225. fi ; \
  226. if [ "$($(2))" = "y" -a "$${IS_IN_LIBC}" != "y" ] ; then \
  227. echo "$(4) not available in C library, please disable $(2)" ; \
  228. exit 1 ; \
  229. fi
  230. #
  231. # Check the correctness of a uclibc external toolchain configuration
  232. # 1. Check that the C library selected in Buildroot matches the one
  233. # of the external toolchain
  234. # 2. Check that the features enabled in the Buildroot configuration
  235. # match the features available in the uClibc of the external
  236. # toolchain
  237. #
  238. # $1: sysroot directory
  239. #
  240. check_uclibc = \
  241. SYSROOT_DIR="$(strip $1)"; \
  242. if ! test -f $${SYSROOT_DIR}/usr/include/bits/uClibc_config.h ; then \
  243. echo "Incorrect selection of the C library"; \
  244. exit -1; \
  245. fi; \
  246. UCLIBC_CONFIG_FILE=$${SYSROOT_DIR}/usr/include/bits/uClibc_config.h ; \
  247. $(call check_uclibc_feature,__ARCH_USE_MMU__,BR2_USE_MMU,$${UCLIBC_CONFIG_FILE},MMU support) ;\
  248. $(call check_uclibc_feature,__UCLIBC_HAS_LFS__,BR2_LARGEFILE,$${UCLIBC_CONFIG_FILE},Large file support) ;\
  249. $(call check_uclibc_feature,__UCLIBC_HAS_IPV6__,BR2_INET_IPV6,$${UCLIBC_CONFIG_FILE},IPv6 support) ;\
  250. $(call check_uclibc_feature,__UCLIBC_HAS_RPC__,BR2_TOOLCHAIN_HAS_NATIVE_RPC,$${UCLIBC_CONFIG_FILE},RPC support) ;\
  251. $(call check_uclibc_feature,__UCLIBC_HAS_LOCALE__,BR2_ENABLE_LOCALE,$${UCLIBC_CONFIG_FILE},Locale support) ;\
  252. $(call check_uclibc_feature,__UCLIBC_HAS_WCHAR__,BR2_USE_WCHAR,$${UCLIBC_CONFIG_FILE},Wide char support) ;\
  253. $(call check_uclibc_feature,__UCLIBC_HAS_THREADS__,BR2_TOOLCHAIN_HAS_THREADS,$${UCLIBC_CONFIG_FILE},Thread support) ;\
  254. $(call check_uclibc_feature,__PTHREADS_DEBUG_SUPPORT__,BR2_TOOLCHAIN_HAS_THREADS_DEBUG,$${UCLIBC_CONFIG_FILE},Thread debugging support)
  255. #
  256. # Check that the Buildroot configuration of the ABI matches the
  257. # configuration of the external toolchain.
  258. #
  259. # $1: cross-gcc path
  260. #
  261. check_arm_abi = \
  262. __CROSS_CC=$(strip $1) ; \
  263. __CROSS_READELF=$(strip $2) ; \
  264. EXT_TOOLCHAIN_TARGET=`LANG=C $${__CROSS_CC} -v 2>&1 | grep ^Target | cut -f2 -d ' '` ; \
  265. if ! echo $${EXT_TOOLCHAIN_TARGET} | grep -qE 'eabi(hf)?$$' ; then \
  266. echo "External toolchain uses the unsuported OABI" ; \
  267. exit 1 ; \
  268. fi ; \
  269. EXT_TOOLCHAIN_CRT1=`LANG=C $${__CROSS_CC} -print-file-name=crt1.o` ; \
  270. if $${__CROSS_READELF} -A $${EXT_TOOLCHAIN_CRT1} | grep -q "Tag_ABI_VFP_args:" ; then \
  271. EXT_TOOLCHAIN_ABI="eabihf" ; \
  272. else \
  273. EXT_TOOLCHAIN_ABI="eabi" ; \
  274. fi ; \
  275. if [ "$(BR2_ARM_EABI)" = "y" -a "$${EXT_TOOLCHAIN_ABI}" = "eabihf" ] ; then \
  276. echo "Incorrect ABI setting: EABI selected, but toolchain uses EABIhf" ; \
  277. exit 1 ; \
  278. fi ; \
  279. if [ "$(BR2_ARM_EABIHF)" = "y" -a "$${EXT_TOOLCHAIN_ABI}" = "eabi" ] ; then \
  280. echo "Incorrect ABI setting: EABIhf selected, but toolchain uses EABI" ; \
  281. exit 1 ; \
  282. fi
  283. #
  284. # Check that the external toolchain supports C++
  285. #
  286. # $1: cross-g++ path
  287. #
  288. check_cplusplus = \
  289. __CROSS_CXX=$(strip $1) ; \
  290. $${__CROSS_CXX} -v > /dev/null 2>&1 ; \
  291. if test $$? -ne 0 ; then \
  292. echo "C++ support is selected but is not available in external toolchain" ; \
  293. exit 1 ; \
  294. fi
  295. #
  296. # Check that the cross-compiler given in the configuration exists
  297. #
  298. # $1: cross-gcc path
  299. #
  300. check_cross_compiler_exists = \
  301. __CROSS_CC=$(strip $1) ; \
  302. $${__CROSS_CC} -v > /dev/null 2>&1 ; \
  303. if test $$? -ne 0 ; then \
  304. echo "Cannot execute cross-compiler '$${__CROSS_CC}'" ; \
  305. exit 1 ; \
  306. fi