buildroot/package/Makefile.in

469 lines
15 KiB
Makefile
Raw Normal View History

2007-08-22 19:47:22 +08:00
ifndef MAKE
MAKE := make
endif
ifndef HOSTMAKE
HOSTMAKE = $(MAKE)
endif
HOSTMAKE := $(shell which $(HOSTMAKE) || type -p $(HOSTMAKE) || echo make)
# If BR2_JLEVEL is 0, scale the maximum concurrency with the number of
# CPUs. An additional job is used in order to keep processors busy
# while waiting on I/O.
# If the number of processors is not available, assume one.
ifeq ($(BR2_JLEVEL),0)
PARALLEL_JOBS := $(shell echo \
$$((1 + `getconf _NPROCESSORS_ONLN 2>/dev/null || echo 1`)))
else
PARALLEL_JOBS := $(BR2_JLEVEL)
endif
# Only build one job at a time, *and* to not randomise goals and
# prerequisites ordering in make 4.4+
MAKE1 := $(HOSTMAKE) -j1 $(if $(findstring --shuffle,$(MAKEFLAGS)),--shuffle=none)
packages: fix and improve support for top-level parallel make The boost and jack2 packages fail to build when PARALLEL_JOBS is empty so instead of using an empty PARALLEL_JOBS don't use it in the MAKE variable when top-level parallel make is being used. To simplify the use of top-level parallel make, check the MAKEFLAGS variable to know automatically if the -j option is being used, also use the "=" operator instead of the ":=" operator because the MAKEFLAGS variable can be checked only in a "recursively expanded variable". The "override" keyword must be used in order to change the automatic variable "MAKE". When the top-parallel make is being used the sub-make are called without specifying the "-j" option in order to let GNU make share the job slots specified in the top make. This is done because GNU make is able to share the job slots available between each instance of make so if you want to increase the number of jobs you just need to increase the <jobs> value in the top make -j<jobs> command. If we specify the -j<jobs> option in each instance of make, it is less efficient, e.g. in a processor with 8 cores we specify -j9 in each instance: the number of processes goes up to 81 because each sub-make can execute 9 processes. The excessive number of processes is not a good thing because in my tests even -j16 is slower than -j9. Instead if we don't specify the -j<jobs> option in the sub-make, the top make share the job slots automatically between each instance, so the number of process in this examples goes up to 9 that is faster than using up to 81 processes. e.g. when the -j3 option is specified only in the top make: possible state n. 1: process 1 - <packagea>-build process 2 - <packagea>-build process 3 - <packagea>-build possible state n. 2: process 1 - <packagea>-extract process 2 - <packageb>-configure process 3 - <packagec>-build possible state n. 3: process 1 - <packagea>-build make -j1 process 2 - <packageb>-build make -j1 process 3 - <packagec>-build make -j1 Signed-off-by: Fabio Porcedda <fabio.porcedda@gmail.com> Acked-by: Arnout Vandecappelle (Essensium/Mind) <arnout@mind.be> Signed-off-by: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
2015-07-01 16:10:46 +08:00
override MAKE = $(HOSTMAKE) \
$(if $(findstring j,$(filter-out --%,$(MAKEFLAGS))),,-j$(PARALLEL_JOBS))
ifeq ($(BR2_TOOLCHAIN_BUILDROOT),y)
TARGET_VENDOR = $(call qstrip,$(BR2_TOOLCHAIN_BUILDROOT_VENDOR))
else
TARGET_VENDOR = buildroot
endif
# Sanity checks
ifeq ($(TARGET_VENDOR),)
$(error BR2_TOOLCHAIN_BUILDROOT_VENDOR is not allowed to be empty)
endif
ifeq ($(TARGET_VENDOR),unknown)
$(error BR2_TOOLCHAIN_BUILDROOT_VENDOR cannot be 'unknown'. \
It might be confused with the native toolchain)
endif
# Compute GNU_TARGET_NAME
# FDPIC on ARM requires a special target name: it has no OS field and must
# use the suffix -uclinuxfdpiceabi.
ifeq ($(BR2_arm)$(BR2_armeb):$(BR2_BINFMT_FDPIC),y:y)
GNU_TARGET_NAME = $(ARCH)-$(TARGET_VENDOR)-uclinuxfdpiceabi
else
GNU_TARGET_NAME = $(ARCH)-$(TARGET_VENDOR)-$(TARGET_OS)-$(LIBC)$(ABI)
endif
# FLAT binary format needs uclinux, except RISC-V which needs the
# regular linux name.
ifeq ($(BR2_BINFMT_FLAT):$(BR2_riscv),y:)
TARGET_OS = uclinux
else
TARGET_OS = linux
endif
ifeq ($(BR2_TOOLCHAIN_USES_UCLIBC),y)
LIBC = uclibc
else ifeq ($(BR2_TOOLCHAIN_USES_MUSL),y)
LIBC = musl
else ifeq ($(BR2_TOOLCHAIN_USES_GLIBC),y)
LIBC = gnu
else ifeq ($(BR_BUILDING),y)
# This happens if there is a bug in Buildroot that allows an
# architecture configuration that isn't supported by any library.
$(error No C library enabled, this is not possible.)
endif
# The ABI suffix is a bit special on ARM, as it needs to be
# -uclibcgnueabi for uClibc EABI, and -gnueabi for glibc EABI.
# This means that the LIBC and ABI aren't strictly orthogonal,
# which explains why we need the test on LIBC below.
ifeq ($(BR2_arm)$(BR2_armeb),y)
ifeq ($(LIBC),uclibc)
ABI = gnueabi
else
ABI = eabi
endif
ifeq ($(BR2_ARM_EABIHF),y)
ABI := $(ABI)hf
arch: improve ARM floating point support and add support for EABIhf This commit introduces the support for the EABIhf ABI, next to the existing support we have for EABI and OABI (even though OABI support is deprecated). EABIhf allows to improve performance of floating point workload by using floating point registers to transfer floating point arguments when calling functions, instead of using integer registers to do, as is done in the 'softfp' floating point model of EABI. In addition to this, this commit introduces a list of options for the floating point support: * Software floating point * VFP * VFPv3 * VFPv3-D16 * VFPv4 * VFPv4-D16 and it introduces some logic to make sure the options are only visible when it makes sense, depending on the ARM core being selected. This is however made complicated by the fact that certain VFP capabilities are mandatory on some cores, but optional on some other cores. The kconfig logic tries to achieve the following goals: * Hide options that are definitely not possible. * Use safe default values (i.e for Cortex-A5 and A7, the presence of the VFPv4 unit is optional, so we default on software floating point on these cores).. * Show the available possibilities, even if some of them are not necessarily working on a particular core (again, for the Cortex-A5 and A7 cores, there is no way of knowing whether the particular variant used by the user has VFPv4 or not, so we select software floating point by default, but still show VFP/VFPv3/VFPv4 options). It is worth noting that this commit doesn't add support for all possible -mfpu= values on ARM. We haven't added support for fpa, fpe2, fpe3, maverick (those four are only used on very old ARM cores), for vfpv3-fp16, vfpv3-d16-fp16, vfpv3xd, vfpv3xd-fp16, neon-fp16, vfpv4-sp-d16. They can be added quite easily if needed thanks to the new organization of the Config.in options. Signed-off-by: Thomas Petazzoni <thomas.petazzoni@free-electrons.com> Signed-off-by: Peter Korsgaard <jacmet@sunsite.dk>
2013-07-16 16:03:14 +08:00
endif
endif
# For FSL PowerPC there's SPE
ifeq ($(BR2_POWERPC_CPU_HAS_SPE),y)
ABI = spe
# MPC8540s are e500v1 with single precision FP
ifeq ($(BR2_powerpc_8540),y)
TARGET_ABI += -mabi=spe -mfloat-gprs=single -Wa,-me500
endif
ifeq ($(BR2_powerpc_8548),y)
TARGET_ABI += -mabi=spe -mfloat-gprs=double -Wa,-me500x2
endif
ifeq ($(BR2_powerpc_e500mc),y)
TARGET_ABI += -mabi=spe -mfloat-gprs=double -Wa,-me500mc
endif
endif
# Use longcalls option for Xtensa globally.
# The 'longcalls' option allows calls across a greater range of addresses,
# and is required for some packages. While this option can degrade both
# code size and performance, the linker can usually optimize away the
# overhead when a call ends up within a certain range.
#
# Use auto-litpools for Xtensa globally.
# Collecting literals into separate section can be advantageous if that
# section is placed into DTCM at link time. This is applicable for code
# running on bare metal, but makes no sense under linux, where userspace
# is isolated from the physical memory details. OTOH placing literals into
# separate section breaks build of huge source files, because l32r
# instruction can only access literals in 256 KBytes range.
#
ifeq ($(BR2_xtensa),y)
TARGET_ABI += -mlongcalls -mauto-litpools
endif
STAGING_SUBDIR = $(GNU_TARGET_NAME)/sysroot
STAGING_DIR = $(HOST_DIR)/$(STAGING_SUBDIR)
ifeq ($(BR2_OPTIMIZE_0),y)
TARGET_OPTIMIZATION = -O0
endif
ifeq ($(BR2_OPTIMIZE_1),y)
TARGET_OPTIMIZATION = -O1
endif
ifeq ($(BR2_OPTIMIZE_2),y)
TARGET_OPTIMIZATION = -O2
endif
ifeq ($(BR2_OPTIMIZE_3),y)
TARGET_OPTIMIZATION = -O3
endif
ifeq ($(BR2_OPTIMIZE_G),y)
TARGET_OPTIMIZATION = -Og
endif
ifeq ($(BR2_OPTIMIZE_S),y)
TARGET_OPTIMIZATION = -Os
endif
ifeq ($(BR2_OPTIMIZE_FAST),y)
TARGET_OPTIMIZATION = -Ofast
endif
ifeq ($(BR2_ENABLE_DEBUG),)
TARGET_DEBUGGING = -g0
endif
ifeq ($(BR2_DEBUG_1),y)
TARGET_DEBUGGING = -g1
endif
ifeq ($(BR2_DEBUG_2),y)
TARGET_DEBUGGING = -g2
endif
ifeq ($(BR2_DEBUG_3),y)
TARGET_DEBUGGING = -g3
endif
TARGET_LDFLAGS = $(call qstrip,$(BR2_TARGET_LDFLAGS))
# musl's dynamic loader doesn't support DT_TEXTREL, which results in a runtime
# crash if it gets used. The "-z text" linker option issues a build-time error
# when DT_TEXREL is used, so we capture the problem earlier.
#
# See also: https://www.openwall.com/lists/musl/2020/09/25/4
#
package/Makefile.in: work around buggy buildsystems wrt LDFLAGS Some buildsystems (or their use of it by packages) will cause flags in LDFLAGS to be re-orderded, or even dropped, causing some incomprehensible mayhem... For example, gpsd [0] has this in its SConscript [1](typoes not mines, for once): 591 # scons uses gcc, or clang, to link. Thus LDFLAGS does not serve its 592 # traditional function of providing arguments to ln. LDFLAGS set in the 593 # environment before running scons get moved into CCFLAGS by scons. 594 # LDFLAGS set while running scons get ignored. [--SNIP--] 611 for i in ["ARFLAGS", 612 "CCFLAGS", 613 "CFLAGS", 614 "CPPFLAGS", 615 "CXXFLAGS", 616 "LDFLAGS", 617 "LINKFLAGS", 618 "SHLINKFLAGS", 619 ]: 620 if i in os.environ: 621 # MergeFlags() puts the options where scons wants them, not 622 # where you asked them to go. 623 env.MergeFlags(Split(os.getenv(i))) So, when LDFLAGS (our TARGET_LDFLAGS) contains "-z text" (without the quotes), that gets turned into a command line like (line-splitted for readability): [...]/buildroot/output/host/bin/aarch64_be-buildroot-linux-musl-gcc \ -o gpsd-3.25/drivers/driver_rtcm2.os \ -c \ --sysroot=[...]/buildroot/output/host/aarch64_be-buildroot-linux-musl/sysroot \ -O3 -g0 \ -z \ -fPIC -D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 \ gpsd-3.25/drivers/driver_rtcm2.c Notice how there is a lone "-z" without any following keyword. This then causes a build failure that looks totally unrelated [2]: In file included from gpsd-3.25/drivers/../include/gpsd.h:36, from gpsd-3.25/drivers/driver_rtcm2.c:65: gpsd-3.25/drivers/../include/os_compat.h:40:8: error: redefinition of ‘struct timespec’ 40 | struct timespec { | ^~~~~~~~ In file included from [...]/buildroot/output/host/aarch64_be-buildroot-linux-musl/sysroot/usr/include/sys/select.h:16, from gpsd-3.25/drivers/../include/gpsd.h:31: [...]/buildroot/output/host/aarch64_be-buildroot-linux-musl/sysroot/usr/include/bits/alltypes.h:237:8: note: originally defined here 237 | struct timespec { time_t tv_sec; int :8*(sizeof(time_t)-sizeof(long))*(__BYTE_ORDER==4321); long tv_nsec; int :8*(sizeof(time_t)-sizeof(long))*(__BYTE_ORDER!=4321); }; | ^~~~~~~~ gpsd-3.25/drivers/../include/os_compat.h:48:5: error: conflicting types for ‘clock_gettime’; have ‘int(clockid_t, struct timespec *)’ {aka ‘int(int, struct timespec *)’} 48 | int clock_gettime(clockid_t, struct timespec *); | ^~~~~~~~~~~~~ In file included from gpsd-3.25/drivers/../include/gpsd.h:33: [...]/buildroot/output/host/aarch64_be-buildroot-linux-musl/sysroot/usr/include/time.h:104:5: note: previous declaration of ‘clock_gettime’ with type ‘int(clockid_t, struct timespec *)’ {aka ‘int(int, struct timespec *)’} 104 | int clock_gettime (clockid_t, struct timespec *); | ^~~~~~~~~~~~~ scons: *** [gpsd-3.25/drivers/driver_rtcm2.os] Error 1 scons: building terminated because of errors. make[1]: *** [package/pkg-generic.mk:289: [...]/buildroot/output/build/gpsd-3.25/.stamp_built] Error 2 make: *** [Makefile:83: _all] Error 2 Although undocumented, neither in gcc not ld (clang unchecked by lack of a clang toolchain here, and by lack of clang knowledge), -z accepts the keyword to be snatch-glued onto it, like -zkeyword, rather than be spearated with a space. So, use that to pass -ztext. Fixes: http://autobuild.buildroot.org/results/c03/c039989947b960ac6af17c87090366abc26dcb6d/ http://autobuild.buildroot.net/results/bc35d3e7b0e8c59c776652070650af3c749250ee/ [0] Our other scons-based package, mongodb, does not build for another reason that probably hides the same issue as seen with gpsd. [1] As explained in gpsd's SConscript (se above), Scons does play tricks with variables: https://scons.org/doc/production/HTML/scons-man.html#f-MergeFlags https://scons.org/doc/production/HTML/scons-man.html#f-ParseFlags Quoting: Flag values are translated according to the prefix found, and added to the following construction variables: [...] -Wl, LINKFLAGS [...] - CCFLAGS [...] Any other strings not associated with options are assumed to be the names of libraries and added to the $LIBS construction variable. So in our case, it finds that -z is an unknown option that matches the '-' prefix, so it is added to CFLAGS, while 'text' is a string on its own, so added to LIBS, and thus it would try to link with -ltext (supposedly, because we do not even go that far). Funnily enough, we can se that "-Wl," is a known option prefix, that is added to LINKFLAGS (to properly be used with gcc or clang, not ld). As a consequence, gpsd's buildsystem does drop -ztext from the link flags, and only passes it to the compile flags, which brings us back to before we banned textrels in a1a2f498d7ec (package/Makefile.in: ban textrels on musl toolchains). Fixing gpsd is a task for another, separate patch... [2] I spent quite some time to look at recent, time-related changes in Buildroot, especially due to the infamous time64_t issues... Alas, that was not related, and only a git-bisect pinpointed the actual issue. Poor polar bears... Signed-off-by: Yann E. MORIN <yann.morin@orange.com> Cc: J. Neuschäfer <j.neuschaefer@gmx.net> Reviewed-by: J. Neuschäfer <j.neuschaefer@gmx.net> Signed-off-by: Thomas Petazzoni <thomas.petazzoni@bootlin.com>
2024-08-09 21:08:22 +08:00
# NOTE: We're using "-ztext" instead of "-Wl,-z,text" here, because some
# packages pass TARGET_LDFLAGS directly to ld rather than gcc, and ld doesn't
# support -Wl,[...]. -z is supported by both gcc and clang, so it probably
# won't cause us problems.
package/Makefile.in: work around buggy buildsystems wrt LDFLAGS Some buildsystems (or their use of it by packages) will cause flags in LDFLAGS to be re-orderded, or even dropped, causing some incomprehensible mayhem... For example, gpsd [0] has this in its SConscript [1](typoes not mines, for once): 591 # scons uses gcc, or clang, to link. Thus LDFLAGS does not serve its 592 # traditional function of providing arguments to ln. LDFLAGS set in the 593 # environment before running scons get moved into CCFLAGS by scons. 594 # LDFLAGS set while running scons get ignored. [--SNIP--] 611 for i in ["ARFLAGS", 612 "CCFLAGS", 613 "CFLAGS", 614 "CPPFLAGS", 615 "CXXFLAGS", 616 "LDFLAGS", 617 "LINKFLAGS", 618 "SHLINKFLAGS", 619 ]: 620 if i in os.environ: 621 # MergeFlags() puts the options where scons wants them, not 622 # where you asked them to go. 623 env.MergeFlags(Split(os.getenv(i))) So, when LDFLAGS (our TARGET_LDFLAGS) contains "-z text" (without the quotes), that gets turned into a command line like (line-splitted for readability): [...]/buildroot/output/host/bin/aarch64_be-buildroot-linux-musl-gcc \ -o gpsd-3.25/drivers/driver_rtcm2.os \ -c \ --sysroot=[...]/buildroot/output/host/aarch64_be-buildroot-linux-musl/sysroot \ -O3 -g0 \ -z \ -fPIC -D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 \ gpsd-3.25/drivers/driver_rtcm2.c Notice how there is a lone "-z" without any following keyword. This then causes a build failure that looks totally unrelated [2]: In file included from gpsd-3.25/drivers/../include/gpsd.h:36, from gpsd-3.25/drivers/driver_rtcm2.c:65: gpsd-3.25/drivers/../include/os_compat.h:40:8: error: redefinition of ‘struct timespec’ 40 | struct timespec { | ^~~~~~~~ In file included from [...]/buildroot/output/host/aarch64_be-buildroot-linux-musl/sysroot/usr/include/sys/select.h:16, from gpsd-3.25/drivers/../include/gpsd.h:31: [...]/buildroot/output/host/aarch64_be-buildroot-linux-musl/sysroot/usr/include/bits/alltypes.h:237:8: note: originally defined here 237 | struct timespec { time_t tv_sec; int :8*(sizeof(time_t)-sizeof(long))*(__BYTE_ORDER==4321); long tv_nsec; int :8*(sizeof(time_t)-sizeof(long))*(__BYTE_ORDER!=4321); }; | ^~~~~~~~ gpsd-3.25/drivers/../include/os_compat.h:48:5: error: conflicting types for ‘clock_gettime’; have ‘int(clockid_t, struct timespec *)’ {aka ‘int(int, struct timespec *)’} 48 | int clock_gettime(clockid_t, struct timespec *); | ^~~~~~~~~~~~~ In file included from gpsd-3.25/drivers/../include/gpsd.h:33: [...]/buildroot/output/host/aarch64_be-buildroot-linux-musl/sysroot/usr/include/time.h:104:5: note: previous declaration of ‘clock_gettime’ with type ‘int(clockid_t, struct timespec *)’ {aka ‘int(int, struct timespec *)’} 104 | int clock_gettime (clockid_t, struct timespec *); | ^~~~~~~~~~~~~ scons: *** [gpsd-3.25/drivers/driver_rtcm2.os] Error 1 scons: building terminated because of errors. make[1]: *** [package/pkg-generic.mk:289: [...]/buildroot/output/build/gpsd-3.25/.stamp_built] Error 2 make: *** [Makefile:83: _all] Error 2 Although undocumented, neither in gcc not ld (clang unchecked by lack of a clang toolchain here, and by lack of clang knowledge), -z accepts the keyword to be snatch-glued onto it, like -zkeyword, rather than be spearated with a space. So, use that to pass -ztext. Fixes: http://autobuild.buildroot.org/results/c03/c039989947b960ac6af17c87090366abc26dcb6d/ http://autobuild.buildroot.net/results/bc35d3e7b0e8c59c776652070650af3c749250ee/ [0] Our other scons-based package, mongodb, does not build for another reason that probably hides the same issue as seen with gpsd. [1] As explained in gpsd's SConscript (se above), Scons does play tricks with variables: https://scons.org/doc/production/HTML/scons-man.html#f-MergeFlags https://scons.org/doc/production/HTML/scons-man.html#f-ParseFlags Quoting: Flag values are translated according to the prefix found, and added to the following construction variables: [...] -Wl, LINKFLAGS [...] - CCFLAGS [...] Any other strings not associated with options are assumed to be the names of libraries and added to the $LIBS construction variable. So in our case, it finds that -z is an unknown option that matches the '-' prefix, so it is added to CFLAGS, while 'text' is a string on its own, so added to LIBS, and thus it would try to link with -ltext (supposedly, because we do not even go that far). Funnily enough, we can se that "-Wl," is a known option prefix, that is added to LINKFLAGS (to properly be used with gcc or clang, not ld). As a consequence, gpsd's buildsystem does drop -ztext from the link flags, and only passes it to the compile flags, which brings us back to before we banned textrels in a1a2f498d7ec (package/Makefile.in: ban textrels on musl toolchains). Fixing gpsd is a task for another, separate patch... [2] I spent quite some time to look at recent, time-related changes in Buildroot, especially due to the infamous time64_t issues... Alas, that was not related, and only a git-bisect pinpointed the actual issue. Poor polar bears... Signed-off-by: Yann E. MORIN <yann.morin@orange.com> Cc: J. Neuschäfer <j.neuschaefer@gmx.net> Reviewed-by: J. Neuschäfer <j.neuschaefer@gmx.net> Signed-off-by: Thomas Petazzoni <thomas.petazzoni@bootlin.com>
2024-08-09 21:08:22 +08:00
#
# We're using "-ztext" instead of "-z text" here, because some buildsystems
# (like scons, for gpsd) will reorder and/or drop LDFLAGS, causing a lone
# "-z" to be passed and the "text" keyword to be dropped otherwise. Both
# gcc and ld supports that, so it probably won't cause us problems.
ifeq ($(BR2_TOOLCHAIN_USES_MUSL):$(BR2_STATIC_LIBS),y:)
package/Makefile.in: work around buggy buildsystems wrt LDFLAGS Some buildsystems (or their use of it by packages) will cause flags in LDFLAGS to be re-orderded, or even dropped, causing some incomprehensible mayhem... For example, gpsd [0] has this in its SConscript [1](typoes not mines, for once): 591 # scons uses gcc, or clang, to link. Thus LDFLAGS does not serve its 592 # traditional function of providing arguments to ln. LDFLAGS set in the 593 # environment before running scons get moved into CCFLAGS by scons. 594 # LDFLAGS set while running scons get ignored. [--SNIP--] 611 for i in ["ARFLAGS", 612 "CCFLAGS", 613 "CFLAGS", 614 "CPPFLAGS", 615 "CXXFLAGS", 616 "LDFLAGS", 617 "LINKFLAGS", 618 "SHLINKFLAGS", 619 ]: 620 if i in os.environ: 621 # MergeFlags() puts the options where scons wants them, not 622 # where you asked them to go. 623 env.MergeFlags(Split(os.getenv(i))) So, when LDFLAGS (our TARGET_LDFLAGS) contains "-z text" (without the quotes), that gets turned into a command line like (line-splitted for readability): [...]/buildroot/output/host/bin/aarch64_be-buildroot-linux-musl-gcc \ -o gpsd-3.25/drivers/driver_rtcm2.os \ -c \ --sysroot=[...]/buildroot/output/host/aarch64_be-buildroot-linux-musl/sysroot \ -O3 -g0 \ -z \ -fPIC -D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 \ gpsd-3.25/drivers/driver_rtcm2.c Notice how there is a lone "-z" without any following keyword. This then causes a build failure that looks totally unrelated [2]: In file included from gpsd-3.25/drivers/../include/gpsd.h:36, from gpsd-3.25/drivers/driver_rtcm2.c:65: gpsd-3.25/drivers/../include/os_compat.h:40:8: error: redefinition of ‘struct timespec’ 40 | struct timespec { | ^~~~~~~~ In file included from [...]/buildroot/output/host/aarch64_be-buildroot-linux-musl/sysroot/usr/include/sys/select.h:16, from gpsd-3.25/drivers/../include/gpsd.h:31: [...]/buildroot/output/host/aarch64_be-buildroot-linux-musl/sysroot/usr/include/bits/alltypes.h:237:8: note: originally defined here 237 | struct timespec { time_t tv_sec; int :8*(sizeof(time_t)-sizeof(long))*(__BYTE_ORDER==4321); long tv_nsec; int :8*(sizeof(time_t)-sizeof(long))*(__BYTE_ORDER!=4321); }; | ^~~~~~~~ gpsd-3.25/drivers/../include/os_compat.h:48:5: error: conflicting types for ‘clock_gettime’; have ‘int(clockid_t, struct timespec *)’ {aka ‘int(int, struct timespec *)’} 48 | int clock_gettime(clockid_t, struct timespec *); | ^~~~~~~~~~~~~ In file included from gpsd-3.25/drivers/../include/gpsd.h:33: [...]/buildroot/output/host/aarch64_be-buildroot-linux-musl/sysroot/usr/include/time.h:104:5: note: previous declaration of ‘clock_gettime’ with type ‘int(clockid_t, struct timespec *)’ {aka ‘int(int, struct timespec *)’} 104 | int clock_gettime (clockid_t, struct timespec *); | ^~~~~~~~~~~~~ scons: *** [gpsd-3.25/drivers/driver_rtcm2.os] Error 1 scons: building terminated because of errors. make[1]: *** [package/pkg-generic.mk:289: [...]/buildroot/output/build/gpsd-3.25/.stamp_built] Error 2 make: *** [Makefile:83: _all] Error 2 Although undocumented, neither in gcc not ld (clang unchecked by lack of a clang toolchain here, and by lack of clang knowledge), -z accepts the keyword to be snatch-glued onto it, like -zkeyword, rather than be spearated with a space. So, use that to pass -ztext. Fixes: http://autobuild.buildroot.org/results/c03/c039989947b960ac6af17c87090366abc26dcb6d/ http://autobuild.buildroot.net/results/bc35d3e7b0e8c59c776652070650af3c749250ee/ [0] Our other scons-based package, mongodb, does not build for another reason that probably hides the same issue as seen with gpsd. [1] As explained in gpsd's SConscript (se above), Scons does play tricks with variables: https://scons.org/doc/production/HTML/scons-man.html#f-MergeFlags https://scons.org/doc/production/HTML/scons-man.html#f-ParseFlags Quoting: Flag values are translated according to the prefix found, and added to the following construction variables: [...] -Wl, LINKFLAGS [...] - CCFLAGS [...] Any other strings not associated with options are assumed to be the names of libraries and added to the $LIBS construction variable. So in our case, it finds that -z is an unknown option that matches the '-' prefix, so it is added to CFLAGS, while 'text' is a string on its own, so added to LIBS, and thus it would try to link with -ltext (supposedly, because we do not even go that far). Funnily enough, we can se that "-Wl," is a known option prefix, that is added to LINKFLAGS (to properly be used with gcc or clang, not ld). As a consequence, gpsd's buildsystem does drop -ztext from the link flags, and only passes it to the compile flags, which brings us back to before we banned textrels in a1a2f498d7ec (package/Makefile.in: ban textrels on musl toolchains). Fixing gpsd is a task for another, separate patch... [2] I spent quite some time to look at recent, time-related changes in Buildroot, especially due to the infamous time64_t issues... Alas, that was not related, and only a git-bisect pinpointed the actual issue. Poor polar bears... Signed-off-by: Yann E. MORIN <yann.morin@orange.com> Cc: J. Neuschäfer <j.neuschaefer@gmx.net> Reviewed-by: J. Neuschäfer <j.neuschaefer@gmx.net> Signed-off-by: Thomas Petazzoni <thomas.petazzoni@bootlin.com>
2024-08-09 21:08:22 +08:00
TARGET_LDFLAGS += -ztext
endif
# By design, _FORTIFY_SOURCE requires gcc optimization to be enabled.
# Therefore, we need to pass _FORTIFY_SOURCE and the optimization level
# through the same mechanism, i.e currently through CFLAGS. Passing
# _FORTIFY_SOURCE through the wrapper and the optimization level
# through CFLAGS would not work, because CFLAGS are sometimes
# ignored/overridden by packages, but the flags passed by the wrapper
# are enforced: this would cause _FORTIFY_SOURCE to be used without any
# optimization level, leading to a build / configure failure. So we keep
# passing _FORTIFY_SOURCE and the optimization level both through CFLAGS.
ifeq ($(BR2_FORTIFY_SOURCE_1),y)
TARGET_HARDENED += -D_FORTIFY_SOURCE=1
else ifeq ($(BR2_FORTIFY_SOURCE_2),y)
TARGET_HARDENED += -D_FORTIFY_SOURCE=2
else ifeq ($(BR2_FORTIFY_SOURCE_3),y)
TARGET_HARDENED += -D_FORTIFY_SOURCE=3
endif
TARGET_CPPFLAGS += -D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64
Config.in: introduce BR2_TIME_BITS_64 option for Y2038 compatibility Y2038 is now almost only 15 years away, and embedded systems built today are potentially going to still be operational in 15 years, and even though they are supposed to receive updates by then, we all know how things go, and potentially some of these embedded systems will not receive any update. In 2038, the signed 32-bit representation of time_t used on 32-bit architectures will overflow, causing all time-related functions to go back in time in a surprising way. The Linux kernel has already been modified to support a 64-bit representation of time_t on 32-bit architectures, but from a C library perspective, the situation varies: - glibc uses this 64-bit time_t representation on 32-bit systems since glibc 2.34, but only if -D_TIME_BITS=64 is specified. Therefore, this commit adds an option to add this flag globally to the build, when glibc is the C library and the architecture is not 64-bit. - musl uses unconditionally a 64-bit time_t representation on 32-bit systems since musl 1.2.0. So there is nothing to do here since Buildroot has been using a musl >= 1.2.0, used since Buildroot 2020.05. No Buildroot option is needed here. - uClibc-ng does not support a 64-bit time_t representation on 32-bit systems, so systems using uClibc-ng will not be Y2038 compliant, at least for now. No Buildroot option is needed here. It should be noted that being Y2038-compliant will only work if all application/library code is correct. For example if an application/library stores a timestamp in an "int" instead of using the proper time_t type, then the mechanisms described above will not fix this, and the application/library will continue to be broken in terms of Y2038 support. Possible discussions points about this patch: - Should we have an option at all, or should we unconditionally pass -D_TIME_BITS=64, like we have been doing for _FILE_OFFSET_BITS=64 for quite some time. The reasoning for having an option is that the mechanism is itself opt-in in glibc, and generally relatively new, so it seemed logical for now to make it optional as well in Buildroot. - Should we show something (a Config.in comment?) in the musl and uClibc-ng case to let the user know that the code is Y2038 compliant (musl) or not Y2038 compliant (uClibc-ng). Or should this discussion be part of the Buildroot documentation? Signed-off-by: Thomas Petazzoni <thomas.petazzoni@bootlin.com>
2022-10-13 05:50:08 +08:00
ifeq ($(BR2_TIME_BITS_64),y)
TARGET_CPPFLAGS += -D_TIME_BITS=64
endif
TARGET_CFLAGS = $(TARGET_CPPFLAGS) $(TARGET_ABI) $(TARGET_OPTIMIZATION) $(TARGET_DEBUGGING) $(TARGET_HARDENED)
TARGET_CXXFLAGS = $(TARGET_CFLAGS)
TARGET_FCFLAGS = $(TARGET_ABI) $(TARGET_OPTIMIZATION) $(TARGET_DEBUGGING)
# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=79509
ifeq ($(BR2_m68k_cf),y)
TARGET_CFLAGS += -fno-dwarf2-cfi-asm
TARGET_CXXFLAGS += -fno-dwarf2-cfi-asm
endif
ifeq ($(BR2_BINFMT_FLAT),y)
ifeq ($(BR2_riscv),y)
TARGET_CFLAGS += -fPIC
endif
ELF2FLT_FLAGS = $(if $($(PKG)_FLAT_STACKSIZE),\
-Wl$(comma)-elf2flt="-r -s$($(PKG)_FLAT_STACKSIZE)",\
-Wl$(comma)-elf2flt=-r)
TARGET_CFLAGS += $(ELF2FLT_FLAGS)
TARGET_CXXFLAGS += $(ELF2FLT_FLAGS)
TARGET_FCFLAGS += $(ELF2FLT_FLAGS)
TARGET_LDFLAGS += $(ELF2FLT_FLAGS)
endif
ifeq ($(BR2_TOOLCHAIN_BUILDROOT),y)
TARGET_CROSS = $(HOST_DIR)/bin/$(GNU_TARGET_NAME)-
else
TARGET_CROSS = $(HOST_DIR)/bin/$(TOOLCHAIN_EXTERNAL_PREFIX)-
endif
# gcc-4.7 and later ships with wrappers that will automatically pass
# arguments to the binutils tools. Those are paths to necessary linker
# plugins.
ifeq ($(BR2_TOOLCHAIN_GCC_AT_LEAST_4_7),y)
TARGET_GCC_WRAPPERS_PREFIX = gcc-
endif
# Define TARGET_xx variables for all common binutils/gcc
TARGET_AR = $(TARGET_CROSS)$(TARGET_GCC_WRAPPERS_PREFIX)ar
TARGET_AS = $(TARGET_CROSS)as
TARGET_CC = $(TARGET_CROSS)gcc
TARGET_CPP = $(TARGET_CROSS)cpp
TARGET_CXX = $(TARGET_CROSS)g++
TARGET_FC = $(TARGET_CROSS)gfortran
TARGET_LD = $(TARGET_CROSS)ld
TARGET_NM = $(TARGET_CROSS)$(TARGET_GCC_WRAPPERS_PREFIX)nm
TARGET_RANLIB = $(TARGET_CROSS)$(TARGET_GCC_WRAPPERS_PREFIX)ranlib
TARGET_READELF = $(TARGET_CROSS)readelf
TARGET_OBJCOPY = $(TARGET_CROSS)objcopy
TARGET_OBJDUMP = $(TARGET_CROSS)objdump
ifeq ($(BR2_STRIP_strip),y)
STRIP_STRIP_DEBUG := --strip-debug
TARGET_STRIP = $(TARGET_CROSS)strip
STRIPCMD = $(TARGET_CROSS)strip --remove-section=.comment --remove-section=.note
else
TARGET_STRIP = /bin/true
STRIPCMD = $(TARGET_STRIP)
endif
INSTALL := $(shell which install || type -p install)
UNZIP := $(shell which unzip || type -p unzip) -q
APPLY_PATCHES = TAR="$(TAR)" PATH=$(HOST_DIR)/bin:$$PATH support/scripts/apply-patches.sh $(if $(QUIET),-s)
HOST_CPPFLAGS = -I$(HOST_DIR)/include
HOST_CFLAGS ?= -O2
HOST_CFLAGS += $(HOST_CPPFLAGS)
HOST_CXXFLAGS += $(HOST_CFLAGS)
HOST_LDFLAGS += -L$(HOST_DIR)/lib -Wl,-rpath,$(HOST_DIR)/lib
# host-intltool should be executed with the system perl, so we save
# the path to the system perl, before a host-perl built by Buildroot
# might get installed into $(HOST_DIR)/bin and therefore appears
# in our PATH. This system perl will be used as INTLTOOL_PERL.
export PERL=$(shell which perl)
# host-intltool needs libxml-parser-perl, which Buildroot installs in
# $(HOST_DIR)/lib/perl, so we must make sure that the system perl
# finds this perl module by exporting the proper value for PERL5LIB.
export PERL5LIB=$(HOST_DIR)/lib/perl
TARGET_MAKE_ENV = \
GIT_DIR=. \
PATH=$(BR_PATH)
TARGET_CONFIGURE_OPTS = \
$(TARGET_MAKE_ENV) \
AR="$(TARGET_AR)" \
AS="$(TARGET_AS)" \
LD="$(TARGET_LD)" \
NM="$(TARGET_NM)" \
CC="$(TARGET_CC)" \
GCC="$(TARGET_CC)" \
CPP="$(TARGET_CPP)" \
CXX="$(TARGET_CXX)" \
FC="$(TARGET_FC)" \
F77="$(TARGET_FC)" \
RANLIB="$(TARGET_RANLIB)" \
READELF="$(TARGET_READELF)" \
STRIP="$(TARGET_STRIP)" \
OBJCOPY="$(TARGET_OBJCOPY)" \
OBJDUMP="$(TARGET_OBJDUMP)" \
AR_FOR_BUILD="$(HOSTAR)" \
AS_FOR_BUILD="$(HOSTAS)" \
CC_FOR_BUILD="$(HOSTCC)" \
GCC_FOR_BUILD="$(HOSTCC)" \
CXX_FOR_BUILD="$(HOSTCXX)" \
LD_FOR_BUILD="$(HOSTLD)" \
CPPFLAGS_FOR_BUILD="$(HOST_CPPFLAGS)" \
CFLAGS_FOR_BUILD="$(HOST_CFLAGS)" \
CXXFLAGS_FOR_BUILD="$(HOST_CXXFLAGS)" \
LDFLAGS_FOR_BUILD="$(HOST_LDFLAGS)" \
FCFLAGS_FOR_BUILD="$(HOST_FCFLAGS)" \
DEFAULT_ASSEMBLER="$(TARGET_AS)" \
DEFAULT_LINKER="$(TARGET_LD)" \
CPPFLAGS="$(TARGET_CPPFLAGS)" \
CFLAGS="$(TARGET_CFLAGS)" \
CXXFLAGS="$(TARGET_CXXFLAGS)" \
LDFLAGS="$(TARGET_LDFLAGS)" \
FCFLAGS="$(TARGET_FCFLAGS)" \
FFLAGS="$(TARGET_FCFLAGS)" \
PKG_CONFIG="$(PKG_CONFIG_HOST_BINARY)" \
STAGING_DIR="$(STAGING_DIR)" \
INTLTOOL_PERL=$(PERL)
HOST_MAKE_ENV = \
GIT_DIR=. \
PATH=$(BR_PATH) \
PKG_CONFIG="$(PKG_CONFIG_HOST_BINARY)" \
PKG_CONFIG_SYSROOT_DIR="/" \
PKG_CONFIG_ALLOW_SYSTEM_CFLAGS=1 \
PKG_CONFIG_ALLOW_SYSTEM_LIBS=1 \
PKG_CONFIG_LIBDIR="$(HOST_DIR)/lib/pkgconfig:$(HOST_DIR)/share/pkgconfig"
HOST_CONFIGURE_OPTS = \
$(HOST_MAKE_ENV) \
AR="$(HOSTAR)" \
AS="$(HOSTAS)" \
LD="$(HOSTLD)" \
NM="$(HOSTNM)" \
CC="$(HOSTCC)" \
GCC="$(HOSTCC)" \
CXX="$(HOSTCXX)" \
CPP="$(HOSTCPP)" \
OBJCOPY="$(HOSTOBJCOPY)" \
RANLIB="$(HOSTRANLIB)" \
CPPFLAGS="$(HOST_CPPFLAGS)" \
CFLAGS="$(HOST_CFLAGS)" \
CXXFLAGS="$(HOST_CXXFLAGS)" \
LDFLAGS="$(HOST_LDFLAGS)" \
INTLTOOL_PERL=$(PERL)
# This is extra environment we can not export ourselves (eg. because some
# packages use that variable internally, eg. uboot), so we have to
# explicitly pass it to user-supplied external hooks (eg. post-build,
# post-images)
EXTRA_ENV = \
PATH=$(BR_PATH) \
BR2_DL_DIR=$(BR2_DL_DIR) \
BUILD_DIR=$(BUILD_DIR) \
CONFIG_DIR=$(CONFIG_DIR) \
O=$(CANONICAL_O) \
PARALLEL_JOBS=$(PARALLEL_JOBS)
################################################################################
# settings we need to pass to configure
# does unaligned access trap?
BR2_AC_CV_TRAP_CHECK = ac_cv_lbl_unaligned_fail=yes
ifeq ($(BR2_i386),y)
BR2_AC_CV_TRAP_CHECK = ac_cv_lbl_unaligned_fail=no
endif
ifeq ($(BR2_x86_64),y)
BR2_AC_CV_TRAP_CHECK = ac_cv_lbl_unaligned_fail=no
endif
ifeq ($(BR2_m68k),y)
BR2_AC_CV_TRAP_CHECK = ac_cv_lbl_unaligned_fail=no
endif
ifeq ($(BR2_powerpc)$(BR2_powerpc64)$(BR2_powerpc64le),y)
BR2_AC_CV_TRAP_CHECK = ac_cv_lbl_unaligned_fail=no
endif
ifeq ($(BR2_ENDIAN),"BIG")
BR2_AC_CV_C_BIGENDIAN = ac_cv_c_bigendian=yes
else
BR2_AC_CV_C_BIGENDIAN = ac_cv_c_bigendian=no
endif
# AM_GNU_GETTEXT misdetects musl gettext support.
# musl currently implements api level 1 and 2 (basic + ngettext)
# http://www.openwall.com/lists/musl/2015/04/16/3
#
# These autoconf variables should only be pre-seeded when the minimal
# gettext implementation of musl is used. When the full blown
# implementation provided by gettext libintl is used, auto-detection
# works fine, and pre-seeding those values is actually wrong.
ifeq ($(BR2_TOOLCHAIN_USES_MUSL):$(BR2_PACKAGE_GETTEXT_PROVIDES_LIBINTL),y:)
BR2_GT_CV_FUNC_GNUGETTEXT_LIBC = \
gt_cv_func_gnugettext1_libc=yes \
gt_cv_func_gnugettext2_libc=yes
endif
TARGET_CONFIGURE_ARGS = \
$(BR2_AC_CV_TRAP_CHECK) \
ac_cv_func_mmap_fixed_mapped=yes \
ac_cv_func_memcmp_working=yes \
Adding Central config.cache options The following changes allow for use of a central configure cache file. This speeds up configuration of packages. Its use is configurable at the top level (BR2_CONFIG_CACHE - default n). Old style makefiles can use it if they use the following MACRO in makefiles: $(AUTO_CONFIGURE_TARGET) see my change to directfb.mk. New style Autotools.in will use it if you set the global option. However you can enable the global option and on a per package overrule it by doing the following: $(PKGNAME)_USE_CONFIG_CACHE = NO see fontconfig.mk for an example of this. Finally I have removed a few config variable settings which indicated no CXX compiler as this is wrong and breaks the build when using this central cache. Config.in | 8 ++++++++ package/Makefile.autotools.in | 5 ++++- package/Makefile.in | 28 +++++++++++++++++++++++++++- package/atk/atk.mk | 2 +- package/directfb/directfb.mk | 7 +------ package/fontconfig/fontconfig.mk | 3 +++ package/libglib2/libglib2.mk | 2 +- package/libgtk2/libgtk2.mk | 1 - 8 files changed, 45 insertions(+), 11 deletions(-) I would appreciate feedback on this change (I have been testing for 2-3 weeks) But I can never test all cases! If you enable the BR2_CONFIG_CACHE option some Makefile.autotools.in based packages may now break - I cannot build them all. In this case you may need to remove config options that are being hardcoded all over the place (like gtk saying we have 2 CXX compiler) or disable the use of CONFIG CACHE file like I have done in fontconfig. I can build all packages required to get WebKit on DirectFB up and running and it runs fine. I will try to resolve any issues this creates as fast as I can. Signed-off-by: Daniel Laird <daniel.j.laird@nxp.com>
2008-11-28 22:20:47 +08:00
ac_cv_have_decl_malloc=yes \
gl_cv_func_malloc_0_nonnull=yes \
ac_cv_func_malloc_0_nonnull=yes \
ac_cv_func_calloc_0_nonnull=yes \
ac_cv_func_realloc_0_nonnull=yes \
lt_cv_sys_lib_search_path_spec="" \
$(BR2_AC_CV_C_BIGENDIAN) \
$(BR2_GT_CV_FUNC_GNUGETTEXT_LIBC)
################################################################################
system: introduce BR2_SYSTEM_ENABLE_NLS Until now, the option BR2_ENABLE_LOCALE was more-or-less controlling whether NLS support was enabled in packages. More precisely, if BR2_ENABLE_LOCALE=y, we were not doing anything (so some packages could have NLS support enabled, some not). And only when BR2_ENABLE_LOCALE was disabled we were explicitly passing --disable-nls to packages. This doesn't make much sense, and there is no reason to tie NLS support to locale support. You may want locale support, but not necessarily NLS support. Therefore, this commit introduces BR2_SYSTEM_ENABLE_NLS, which allows to enable/disable NLS support globally. When this option is enabled, we pass --enable-nls to packages, otherwise we pass --disable-nls. In addition, when this option is enabled and the C library doesn't provide a full-blown implementation of gettext, we select the gettext package, which will provide the full blown implementation. It is worth mentioning that this commit has a visible impact for users: - Prior to this commit, as soon as BR2_ENABLE_LOCALE=y, packages *could* provide NLS support. It was up to each package to decide whether they wanted to provide NLS support or not (we were not passing --enable-nls nor --disable-nls). - After this commit, it's BR2_SYSTEM_ENABLE_NLS that controls whether NLS is enabled or disabled, and this option is disabled by default. Bottom line: with the default of BR2_SYSTEM_ENABLE_NLS disabled, some packages may lose NLS support that they used to provide. But we believe it's a reasonable default behavior for Buildroot, where generally NLS support is not necessary. Signed-off-by: Thomas Petazzoni <thomas.petazzoni@free-electrons.com> Reviewed-by: Arnout Vandecappelle (Essensium/Mind) <arnout@mind.be> Signed-off-by: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
2017-07-04 22:47:49 +08:00
ifeq ($(BR2_SYSTEM_ENABLE_NLS),y)
NLS_OPTS = --enable-nls
TARGET_NLS_DEPENDENCIES = host-gettext
ifeq ($(BR2_PACKAGE_GETTEXT_PROVIDES_LIBINTL),y)
TARGET_NLS_DEPENDENCIES += gettext
TARGET_NLS_LIBS += -lintl
endif
else
NLS_OPTS = --disable-nls
endif
core: alternate solution to disable C++ Some packages that use libtool really need some love to be able to disable C++ support. This is because libtool will want to call AC_PROG_CXXCPP as soon as CXX is set non-empty to something different from 'no'. Then, AC_PROG_CXXCPP will want a C++ preprocessor that works on valid input *and* fail on invalid input. So, providing 'false' as the C++ compiler will then require that we do have a working C++ preprocessor. Which is totally counter-productive since we do not have a C++ compiler to start with... bd39d11d2e (core/infra: fix build on toolchain without C++) was a previous attempt at fixing this, by using the host's C++ preprocessor. However, that is very incorrect (that's my code, I can say so!) because the set of defines will most probably be different for the host and the target, thus causing all sorts of trouble. For example, on ARM we'd have to include different headers for soft-float vs hard-float, which is decided based on a macro, which is not defined for x86, and thus may redirect to the wrong (and missing) header. Instead, we notice that libtool uses the magic value 'no' to decide that a C++ compiler is not available, in which case it skips the call to AC_PROG_CXXCPP. Given that 'no' is not provided by any package in Debian and derivatives, as well as in Fedora, we can assume that no system will have an executable called 'no'. Hence, we use that as a magic value to disable C++ detection altogether. Fixes: #10846 (again) Reported-by: Damien Riegel <damien.riegel@savoirfairelinux.com> Signed-off-by: "Yann E. MORIN" <yann.morin.1998@free.fr> Cc: Damien Riegel <damien.riegel@savoirfairelinux.com> Cc: Peter Seiderer <ps.report@gmx.net> Cc: Vivien Didelot <vivien.didelot@savoirfairelinux.com> Cc: Peter Korsgaard <peter@korsgaard.com> Cc: Thomas Petazzoni <thomas.petazzoni@bootlin.com> Tested-by: Peter Seiderer <ps.report@gmx.net> Signed-off-by: Peter Korsgaard <peter@korsgaard.com>
2018-03-27 19:00:22 +08:00
# We need anything that is invalid. Traditionally, we'd have used 'false' (and
# we did so in the past). However, that breaks libtool for packages that have
# optional C++ support (e.g. gnutls), because libtool will *require* a *valid*
# C++ preprocessor as long as CXX is not 'no'.
# Now, whether we use 'no' or 'false' for CXX as the same side effect: it is an
# invalid C++ compiler, and thus will cause detection of C++ to fail (which is
# expected and what we want), while at the same time taming libtool into
# silence.
ifneq ($(BR2_INSTALL_LIBSTDCPP),y)
core: alternate solution to disable C++ Some packages that use libtool really need some love to be able to disable C++ support. This is because libtool will want to call AC_PROG_CXXCPP as soon as CXX is set non-empty to something different from 'no'. Then, AC_PROG_CXXCPP will want a C++ preprocessor that works on valid input *and* fail on invalid input. So, providing 'false' as the C++ compiler will then require that we do have a working C++ preprocessor. Which is totally counter-productive since we do not have a C++ compiler to start with... bd39d11d2e (core/infra: fix build on toolchain without C++) was a previous attempt at fixing this, by using the host's C++ preprocessor. However, that is very incorrect (that's my code, I can say so!) because the set of defines will most probably be different for the host and the target, thus causing all sorts of trouble. For example, on ARM we'd have to include different headers for soft-float vs hard-float, which is decided based on a macro, which is not defined for x86, and thus may redirect to the wrong (and missing) header. Instead, we notice that libtool uses the magic value 'no' to decide that a C++ compiler is not available, in which case it skips the call to AC_PROG_CXXCPP. Given that 'no' is not provided by any package in Debian and derivatives, as well as in Fedora, we can assume that no system will have an executable called 'no'. Hence, we use that as a magic value to disable C++ detection altogether. Fixes: #10846 (again) Reported-by: Damien Riegel <damien.riegel@savoirfairelinux.com> Signed-off-by: "Yann E. MORIN" <yann.morin.1998@free.fr> Cc: Damien Riegel <damien.riegel@savoirfairelinux.com> Cc: Peter Seiderer <ps.report@gmx.net> Cc: Vivien Didelot <vivien.didelot@savoirfairelinux.com> Cc: Peter Korsgaard <peter@korsgaard.com> Cc: Thomas Petazzoni <thomas.petazzoni@bootlin.com> Tested-by: Peter Seiderer <ps.report@gmx.net> Signed-off-by: Peter Korsgaard <peter@korsgaard.com>
2018-03-27 19:00:22 +08:00
TARGET_CONFIGURE_OPTS += CXX=no
endif
ifeq ($(BR2_STATIC_LIBS),y)
SHARED_STATIC_LIBS_OPTS = --enable-static --disable-shared
TARGET_CFLAGS += -static
TARGET_CXXFLAGS += -static
TARGET_FCFLAGS += -static
TARGET_LDFLAGS += -static
else ifeq ($(BR2_SHARED_LIBS),y)
SHARED_STATIC_LIBS_OPTS = --disable-static --enable-shared
else ifeq ($(BR2_SHARED_STATIC_LIBS),y)
SHARED_STATIC_LIBS_OPTS = --enable-static --enable-shared
endif
# Used by our binutils patches.
export BR_COMPILER_PARANOID_UNSAFE_PATH=enabled
include package/pkg-download.mk
include package/pkg-autotools.mk
include package/pkg-cmake.mk
include package/pkg-luarocks.mk
include package/pkg-perl.mk
include package/pkg-python.mk
include package/pkg-virtual.mk
include package/pkg-generic.mk
infra: introduce a kconfig-package infrastructure There are several packages that have a configuration file managed by kconfig: uclibc, busybox, linux and barebox. All these packages need some make targets to handle the kconfig specificities: creating a configuration (menuconfig, ...) and saving it back (update-config, ...) These targets should be the same for each of these packages, but unfortunately they are not. Especially with respect to saving back the configuration to the original config file, there are many differences. A previous set of patches fixed these targets for the uclibc package. This patch extracts these targets into a common kconfig-package infrastructure, with the goals of: - aligning the behavior of all kconfig-based packages - removing code duplication In order to use this infrastructure, a package should at a minimum specify FOO_KCONFIG_FILE and eval the kconfig-package macro. The supported configuration editors can be set with FOO_KCONFIG_EDITORS and defaults to menuconfig only. Additionally, a package can specify FOO_KCONFIG_OPT for extra options to pass to the invocation of the kconfig editors, and FOO_KCONFIG_FIXUP_CMDS for a list of shell commands used to fixup the .config file after a configuration has been created/edited. Signed-off-by: Thomas De Schampheleire <thomas.de.schampheleire@gmail.com> [yann.morin.1998@free.fr: add missing 4th argument when calling to inner-kconfig-package (namely, 'target'] Signed-off-by: "Yann E. MORIN" <yann.morin.1998@free.fr> Signed-off-by: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
2014-08-03 23:32:40 +08:00
include package/pkg-kconfig.mk
include package/pkg-rebar.mk
include package/pkg-kernel-module.mk
include package/pkg-waf.mk
include package/pkg-golang.mk
include package/pkg-meson.mk
package/pkg-qmake: new qmake package infrastructure This provides generic functions for Qt5 qmake based packages. It will make it possible to remove lots of redefinition of QT5_xxx_{CONFIGURE|BUILD|INSTALL_STAGING}_CMDS. Additionally it provides a generic target install method which will make most of the package specific commands obsolete. This is done by re-running the install step of the qmake generated Makefile with the package build directory prepended (to the staging/host path). Even though this does create lengthy pathes it allows for easy separation of the staging files from the host destined files by just omitting the resulting BUILD_DIR+HOST_DIR path from the following rsync call to the real target folder. The cleanup of many files we dont want in target is deferred to the target-finalize step. In addition to what's being removed already, we also have to cleanup some Qt5 specific files (prl) and the documentation directory. This approach was chosen over copying all files recorded in the pkg-files-list after some discussion which Thomas Petazzoni summed up: "We don't yet use pkg-files-list really as part of the build process anywhere, I feel a bit more comfortable at this point with what Andreas is proposing." Thanks to this infrastructure, it will be possible to get rid of the many conditional install commands because qmake already takes care of this when generating the Makefile install targets with the given or autodetected configure options of each package. However, custom install steps may have to remain in cases where a particular Buildroot option has no corresponding setting in the packages configuration options. Signed-off-by: Andreas Naumann <anaumann@ultratronik.de> Signed-off-by: Thomas Petazzoni <thomas.petazzoni@bootlin.com>
2020-02-18 05:23:24 +08:00
include package/pkg-qmake.mk
include package/pkg-cargo.mk