b6c24e6b40
* Rename the "tun" network device to "tunnel". FreeBSD calls theirs "tuntap" but speaks of both TUN and TAP devices as interfaces for tunnels. The other BSDs seem to do likewise. * Fold the "tun" driver into the "tunnel" network device. The network device now publishes entries in devfs when interfaces are created, and unpublishes them when interfaces are destroyed. This removes the need for the driver and device to communicate through a file descriptor, and thus allows the receive queue to be totally eliminated, massively simplifying that logic. * Use standard net-stack FIFOs instead of TCP BufferQueue, which is specialized to TCP's needs in far too many ways. Thanks to the previous commit adding support for interrupting semaphore waits, we can use the FIFO wait mechanisms, too. * Restructure the TAP logic, and generate MAC addresses more like Linux does. * Actually set type = IFT_TUN, and use the "loopback" frame handler instead of the "ethernet" frame handler. This allows significant cleanup of the header handling logic. * In TUN mode, reject packets that don't look like IP packets. * Delete "tunconfig"; it was mostly stubs and is now unnecessary. TUN mode tested and confirmed as working by kallisti5 with OpenVPN. TAP mode partially tested, but not yet confirmed as working. Fixes #18673. Change-Id: Ibd803139474e8db556a4f567901da15ee4083621 Reviewed-on: https://review.haiku-os.org/c/haiku/+/7143 Reviewed-by: Alex von Gluck IV <kallisti5@unixzen.com>
945 lines
34 KiB
Plaintext
945 lines
34 KiB
Plaintext
rule ArchitectureSetup architecture
|
|
{
|
|
# ArchitectureSetup <architecture> ;
|
|
#
|
|
# Initializes all global packaging architecture dependent variables for the
|
|
# given packaging architecture. Also sets HAIKU_ARCH (to the primary
|
|
# architecture), if this is the first invocation of the rule, and adds
|
|
# the architecture to HAIKU_ARCHS, if not yet contained.
|
|
|
|
# enable GCC -pipe option, if requested
|
|
local ccBaseFlags ;
|
|
if $(HAIKU_USE_GCC_PIPE) = 1 {
|
|
ccBaseFlags = -pipe ;
|
|
}
|
|
|
|
if $(HAIKU_CC_IS_LEGACY_GCC_$(architecture)) != 1 {
|
|
# disable strict aliasing on anything newer than gcc 2 as it may lead to
|
|
# unexpected results.
|
|
# TODO: remove the -fno-strict-aliasing option when all code has been
|
|
# analyzed/fixed with regard to aliasing.
|
|
ccBaseFlags += -fno-strict-aliasing ;
|
|
|
|
# Without this flag, GCC deletes many null-pointer checks that are
|
|
# technically undefined behavior (e.g. passing NULL to strdup, among
|
|
# others), which breaks both the kernel and various applications. See:
|
|
# - https://freelists.org/post/haiku-development/hrev45320-Yet-another-nonobvious-effect-of-ftreevrp-optimization
|
|
# - https://dev.haiku-os.org/ticket/13285#comment:8 (& subsequent comments)
|
|
# - https://dev.haiku-os.org/ticket/10803#comment:4 (& subsequent comments)
|
|
# Note that the Linux also does the same:
|
|
# - https://github.com/torvalds/linux/commit/a3ca86aea507904
|
|
ccBaseFlags += -fno-delete-null-pointer-checks ;
|
|
|
|
# disable some builtins that are incompatible with our definitions
|
|
ccBaseFlags += -fno-builtin-fork -fno-builtin-vfork ;
|
|
}
|
|
|
|
# default architecture tuning
|
|
local cpu = $(HAIKU_CPU_$(architecture)) ;
|
|
local archFlags ;
|
|
switch $(cpu) {
|
|
case ppc : archFlags += -mcpu=440fp ;
|
|
case arm : archFlags += -march=armv7-a -mfloat-abi=hard ;
|
|
case arm64 : archFlags += -march=armv8.2-a+fp16 ;
|
|
case x86 : archFlags += -march=pentium ;
|
|
case riscv64 : archFlags += -march=rv64gc ;
|
|
}
|
|
if $(HAIKU_CC_IS_CLANG_$(architecture)) = 1 {
|
|
# TODO: These should be included in Clang's compiler specs.
|
|
ccBaseFlags += -fPIC ;
|
|
HAIKU_LINKFLAGS_$(architecture) += -shared ;
|
|
|
|
# lld doesn't currently implement R_RISCV_ALIGN relaxation
|
|
if $(cpu) = riscv64 {
|
|
ccBaseFlags += -mno-relax ;
|
|
}
|
|
}
|
|
ccBaseFlags += $(archFlags) ;
|
|
|
|
# activating graphite optimizations
|
|
if $(HAIKU_USE_GCC_GRAPHITE_$(architecture)) = 1 {
|
|
ccBaseFlags += -floop-nest-optimize -fgraphite-identity ;
|
|
}
|
|
|
|
# initial state for flags etc.
|
|
HAIKU_C++_$(architecture) ?= $(HAIKU_CC_$(architecture)) ;
|
|
HAIKU_LINK_$(architecture) ?= $(HAIKU_CC_$(architecture)) ;
|
|
|
|
HAIKU_CCFLAGS_$(architecture) += $(ccBaseFlags) -nostdinc ;
|
|
HAIKU_C++FLAGS_$(architecture) += $(ccBaseFlags) -nostdinc ;
|
|
HAIKU_LINKFLAGS_$(architecture) += $(ccBaseFlags) ;
|
|
HAIKU_ASFLAGS_$(architecture) += $(archFlags) -nostdinc ;
|
|
|
|
# strip is required
|
|
if ! $(HAIKU_STRIP_$(architecture)) {
|
|
Exit "HAIKU_STRIP_$(architecture) not set. Please re-run configure." ;
|
|
}
|
|
|
|
HAIKU_ARCH_$(architecture) = $(cpu) ;
|
|
HAIKU_ARCH ?= $(cpu) ;
|
|
# Set only, if not set yet. This way HAIKU_ARCH is set to the primary
|
|
# architecture.
|
|
if ! $(cpu) in $(HAIKU_ARCHS) {
|
|
HAIKU_ARCHS += $(cpu) ;
|
|
}
|
|
HAIKU_DEFINES_$(architecture) += ARCH_$(cpu) ;
|
|
|
|
# directories
|
|
HAIKU_ARCH_OBJECT_DIR_$(architecture)
|
|
= [ FDirName $(HAIKU_OBJECT_BASE_DIR) $(architecture) ] ;
|
|
HAIKU_COMMON_DEBUG_OBJECT_DIR_$(architecture)
|
|
= [ FDirName $(HAIKU_ARCH_OBJECT_DIR_$(architecture)) common ] ;
|
|
HAIKU_DEBUG_0_OBJECT_DIR_$(architecture)
|
|
= [ FDirName $(HAIKU_ARCH_OBJECT_DIR_$(architecture)) release ] ;
|
|
|
|
local level ;
|
|
for level in $(HAIKU_DEBUG_LEVELS[2-]) {
|
|
HAIKU_DEBUG_$(level)_OBJECT_DIR_$(architecture)
|
|
= [ FDirName $(HAIKU_ARCH_OBJECT_DIR_$(architecture))
|
|
debug_$(level) ] ;
|
|
}
|
|
|
|
# set variables for gcc header options
|
|
SetIncludePropertiesVariables HAIKU : _$(architecture) ;
|
|
|
|
# warning flags
|
|
HAIKU_WARNING_CCFLAGS_$(architecture) = -Wall
|
|
-Wno-multichar
|
|
-Wpointer-arith -Wsign-compare
|
|
-Wmissing-prototypes ;
|
|
HAIKU_WARNING_C++FLAGS_$(architecture) = -Wall
|
|
-Wno-multichar
|
|
-Wpointer-arith -Wsign-compare
|
|
-Wno-ctor-dtor-privacy -Woverloaded-virtual ;
|
|
|
|
# disable some Clang warnings that are not very useful
|
|
if $(HAIKU_CC_IS_CLANG_$(architecture)) = 1 {
|
|
HAIKU_WARNING_CCFLAGS_$(architecture) +=
|
|
-Wno-unused-private-field -Wno-gnu-designator
|
|
-Wno-builtin-requires-header ;
|
|
HAIKU_WARNING_C++FLAGS_$(architecture) +=
|
|
-Wno-unused-private-field -Wno-gnu-designator
|
|
-Wno-builtin-requires-header ;
|
|
}
|
|
|
|
HAIKU_WERROR_FLAGS_$(architecture) = ;
|
|
|
|
if $(HAIKU_CC_IS_LEGACY_GCC_$(architecture)) != 1 {
|
|
# TODO: Remove all these.
|
|
HAIKU_WERROR_FLAGS_$(architecture) += -Wno-error=unused-but-set-variable
|
|
-Wno-error=cpp -Wno-error=register ;
|
|
# These currently generate too many "false positives."
|
|
HAIKU_WERROR_FLAGS_$(architecture) += -Wno-error=address-of-packed-member
|
|
-Wno-error=stringop-overread -Wno-error=array-bounds ;
|
|
# But these can stay.
|
|
HAIKU_WERROR_FLAGS_$(architecture) += -Wno-error=cast-align
|
|
-Wno-error=format-truncation ;
|
|
}
|
|
|
|
# debug flags
|
|
local debugFlags = -ggdb ;
|
|
|
|
# debug 0: suppress asserts
|
|
HAIKU_DEBUG_0_CCFLAGS_$(architecture) = [ FDefines NDEBUG=$(NDEBUG) ] ;
|
|
HAIKU_DEBUG_0_C++FLAGS_$(architecture) = [ FDefines NDEBUG=$(NDEBUG) ] ;
|
|
|
|
local level ;
|
|
for level in $(HAIKU_DEBUG_LEVELS[2-]) {
|
|
local flags = $(debugFlags) [ FDefines DEBUG=$(level) ] ;
|
|
HAIKU_DEBUG_$(level)_CCFLAGS_$(architecture) = $(flags) ;
|
|
HAIKU_DEBUG_$(level)_C++FLAGS_$(architecture) = $(flags) ;
|
|
}
|
|
|
|
# TODO: Temporary work-around. Should be defined in the compiler specs
|
|
HAIKU_LINKFLAGS_$(architecture) += -Xlinker --no-undefined ;
|
|
|
|
if $(HAIKU_CC_IS_LEGACY_GCC_$(architecture)) = 1 {
|
|
HAIKU_DEFINES_$(architecture) += _BEOS_R5_COMPATIBLE_ ;
|
|
}
|
|
|
|
# private shared kernel/libroot headers
|
|
HAIKU_PRIVATE_SYSTEM_HEADERS_$(architecture)
|
|
= [ PrivateHeaders $(DOT) system system/arch/$(cpu) ] ;
|
|
|
|
# library and executable glue code
|
|
local commonGlueCode =
|
|
<src!system!glue!$(architecture)>init_term_dyn.o
|
|
<src!system!glue!arch!$(cpu)!$(architecture)>crti.o
|
|
<src!system!glue!arch!$(cpu)!$(architecture)>crtn.o
|
|
;
|
|
HAIKU_LIBRARY_BEGIN_GLUE_CODE_$(architecture) =
|
|
<src!system!glue!arch!$(cpu)!$(architecture)>crti.o
|
|
<$(architecture)>crtbeginS.o
|
|
<src!system!glue!$(architecture)>init_term_dyn.o
|
|
;
|
|
HAIKU_LIBRARY_END_GLUE_CODE_$(architecture) =
|
|
<$(architecture)>crtendS.o
|
|
<src!system!glue!arch!$(cpu)!$(architecture)>crtn.o
|
|
;
|
|
HAIKU_EXECUTABLE_BEGIN_GLUE_CODE_$(architecture) =
|
|
<src!system!glue!arch!$(cpu)!$(architecture)>crti.o
|
|
<$(architecture)>crtbeginS.o
|
|
<src!system!glue!$(architecture)>start_dyn.o
|
|
<src!system!glue!$(architecture)>init_term_dyn.o
|
|
;
|
|
HAIKU_EXECUTABLE_END_GLUE_CODE_$(architecture)
|
|
= $(HAIKU_LIBRARY_END_GLUE_CODE_$(architecture)) ;
|
|
|
|
SEARCH on <$(architecture)>crtbeginS.o <$(architecture)>crtendS.o
|
|
= $(HAIKU_GCC_LIB_DIR_$(architecture)) ;
|
|
|
|
# init library name map
|
|
local libraryGrist = "" ;
|
|
if $(architecture) != $(HAIKU_PACKAGING_ARCHS[1]) {
|
|
libraryGrist = $(architecture) ;
|
|
}
|
|
local i ;
|
|
for i in be bnetapi debug device game locale mail media midi midi2
|
|
network package root screensaver textencoding tracker
|
|
translation z {
|
|
local library = lib$(i).so ;
|
|
HAIKU_LIBRARY_NAME_MAP_$(architecture)_$(i)
|
|
= $(library:G=$(libraryGrist)) ;
|
|
}
|
|
HAIKU_LIBRARY_NAME_MAP_$(architecture)_localestub
|
|
= <$(architecture)>liblocalestub.a ;
|
|
HAIKU_LIBRARY_NAME_MAP_$(architecture)_shared
|
|
= <$(architecture)>libshared.a ;
|
|
if $(architecture) = $(HAIKU_PACKAGING_ARCHS[1]) {
|
|
HAIKU_LIBRARY_NAME_MAP_$(architecture)_input_server
|
|
= <nogrist>input_server ;
|
|
} else {
|
|
HAIKU_LIBRARY_NAME_MAP_$(architecture)_input_server
|
|
= <$(architecture)>input_server ;
|
|
}
|
|
}
|
|
|
|
|
|
rule KernelArchitectureSetup architecture
|
|
{
|
|
# KernelArchitectureSetup <architecture> ;
|
|
#
|
|
# Initializes the global kernel and boot loader related variables. Those
|
|
# don't have a packaging architecture suffix, since they are only set for
|
|
# the primary packaging architecture. <architecture> is the primary
|
|
# packaging architecture (supplied for convenience).
|
|
|
|
HAIKU_KERNEL_ARCH = $(HAIKU_ARCH) ;
|
|
HAIKU_KERNEL_ARCH_DIR = $(HAIKU_KERNEL_ARCH) ;
|
|
|
|
local cpu = $(HAIKU_CPU_$(architecture)) ;
|
|
|
|
switch $(cpu) {
|
|
case ppc :
|
|
HAIKU_KERNEL_PLATFORM ?= openfirmware ;
|
|
HAIKU_BOOT_TARGETS += openfirmware ;
|
|
|
|
HAIKU_BOOT_FLOPPY_IMAGE_SIZE = 1440 ; # in kB
|
|
# offset in floppy image (>= sizeof(haiku_loader))
|
|
HAIKU_BOOT_ARCHIVE_IMAGE_OFFSET = 384 ; # in kB
|
|
|
|
case sparc :
|
|
HAIKU_KERNEL_PLATFORM ?= openfirmware ;
|
|
HAIKU_BOOT_TARGETS += openfirmware ;
|
|
|
|
HAIKU_BOOT_FLOPPY_IMAGE_SIZE = 1440 ; # in kB
|
|
# offset in floppy image (>= sizeof(haiku_loader))
|
|
HAIKU_BOOT_ARCHIVE_IMAGE_OFFSET = 384 ; # in kB
|
|
|
|
case arm :
|
|
HAIKU_KERNEL_PLATFORM ?= efi ;
|
|
HAIKU_BOOT_TARGETS += efi ;
|
|
|
|
# SOC's like allwinner need an offset to skip the hardcoded initial loader
|
|
HAIKU_BOOT_SDIMAGE_BEGIN = 20475 ; # in KiB
|
|
|
|
HAIKU_BOOT_FLOPPY_IMAGE_SIZE = 1440 ;
|
|
# offset in floppy image (>= sizeof(haiku_loader))
|
|
HAIKU_BOOT_ARCHIVE_IMAGE_OFFSET = 192 ; # in kB - unused yet
|
|
HAIKU_BOOT_LOADER_BASE ?= 0x1000000 ;
|
|
|
|
case arm64 :
|
|
HAIKU_KERNEL_PLATFORM ?= efi ;
|
|
HAIKU_BOOT_TARGETS += efi ;
|
|
|
|
HAIKU_BOOT_SDIMAGE_BEGIN = 2 ; # in KiB
|
|
|
|
HAIKU_BOOT_FLOPPY_IMAGE_SIZE = 1440 ;
|
|
# offset in floppy image (>= sizeof(haiku_loader))
|
|
HAIKU_BOOT_ARCHIVE_IMAGE_OFFSET = 192 ; # in kB - unused yet
|
|
HAIKU_BOOT_LOADER_BASE ?= 0x1000000 ;
|
|
|
|
case x86 :
|
|
HAIKU_KERNEL_PLATFORM ?= bios_ia32 ;
|
|
HAIKU_BOOT_TARGETS += bios_ia32 efi pxe_ia32 ;
|
|
|
|
HAIKU_BOOT_FLOPPY_IMAGE_SIZE = 2880 ; # in kB
|
|
# offset in floppy image (>= sizeof(haiku_loader))
|
|
HAIKU_BOOT_ARCHIVE_IMAGE_OFFSET = 384 ; # in kB
|
|
|
|
# nasm is required for target arch x86
|
|
if ! $(HAIKU_NASM) {
|
|
Exit "HAIKU_NASM not set. Please re-run configure." ;
|
|
}
|
|
|
|
case riscv64 :
|
|
HAIKU_KERNEL_PLATFORM ?= efi ;
|
|
HAIKU_BOOT_TARGETS += efi riscv ;
|
|
|
|
HAIKU_BOOT_SDIMAGE_BEGIN = 2 ; # KiB
|
|
|
|
HAIKU_BOOT_FLOPPY_IMAGE_SIZE = 1440 ;
|
|
# offset in floppy image (>= sizeof(haiku_loader))
|
|
HAIKU_BOOT_ARCHIVE_IMAGE_OFFSET = 192 ; # in kB - unused yet
|
|
HAIKU_BOOT_LOADER_BASE ?= 0x1000000 ;
|
|
|
|
case x86_64 :
|
|
# x86_64 completely shares the x86 bootloader for MBR.
|
|
HAIKU_KERNEL_PLATFORM ?= bios_ia32 ;
|
|
HAIKU_BOOT_TARGETS += bios_ia32 efi pxe_ia32 ;
|
|
|
|
HAIKU_BOOT_FLOPPY_IMAGE_SIZE = 2880 ; # in kB
|
|
# offset in floppy image (>= sizeof(haiku_loader))
|
|
HAIKU_BOOT_ARCHIVE_IMAGE_OFFSET = 384 ; # in kB
|
|
|
|
# x86_64 kernel source is under arch/x86.
|
|
HAIKU_KERNEL_ARCH_DIR = x86 ;
|
|
|
|
# nasm is required for target arch x86_64
|
|
if ! $(HAIKU_NASM) {
|
|
Exit "HAIKU_NASM not set. Please re-run configure." ;
|
|
}
|
|
|
|
case m68k :
|
|
HAIKU_KERNEL_PLATFORM ?= atari_m68k ;
|
|
HAIKU_BOOT_TARGETS += amiga_m68k atari_m68k next_m68k ;
|
|
switch $(HAIKU_KERNEL_PLATFORM) {
|
|
case atari_m68k :
|
|
{
|
|
HAIKU_BOOT_FLOPPY_IMAGE_SIZE = 1440 ; # in kB
|
|
}
|
|
case amiga_m68k :
|
|
{
|
|
# for now we have trouble reading from double-sided images
|
|
HAIKU_BOOT_FLOPPY_IMAGE_SIZE = 880 ; # in kB
|
|
}
|
|
case next_m68k :
|
|
{
|
|
HAIKU_BOOT_FLOPPY_IMAGE_SIZE = 1440 ; # in kB
|
|
}
|
|
}
|
|
# offset in floppy image (>= sizeof(haiku_loader))
|
|
HAIKU_BOOT_ARCHIVE_IMAGE_OFFSET = 260 ; # in kB
|
|
HAIKU_CONTAINER_STRIP_EXECUTABLES on
|
|
$(HAIKU_FLOPPY_BOOT_IMAGE_CONTAINER_NAME) = 1 ;
|
|
|
|
case * :
|
|
Exit "Currently unsupported target CPU:" $(cpu) ;
|
|
}
|
|
|
|
# private kernel headers to be used when compiling kernel code
|
|
HAIKU_PRIVATE_KERNEL_HEADERS =
|
|
[ PrivateHeaders $(DOT) kernel libroot shared
|
|
kernel/boot/platform/$(HAIKU_KERNEL_PLATFORM) ]
|
|
[ ArchHeaders $(HAIKU_KERNEL_ARCH_DIR) ]
|
|
[ FDirName $(HAIKU_COMMON_DEBUG_OBJECT_DIR_$(architecture)) system
|
|
kernel ]
|
|
$(HAIKU_PRIVATE_SYSTEM_HEADERS_$(architecture))
|
|
;
|
|
|
|
# C/C++ flags
|
|
local ccBaseFlags = -finline -fno-builtin -Wno-main ;
|
|
|
|
if $(HAIKU_CC_IS_LEGACY_GCC_$(architecture)) != 1 {
|
|
if $(HAIKU_CC_IS_CLANG_$(architecture)) != 1 {
|
|
# Clang does not yet understand this flag.
|
|
ccBaseFlags += -fno-semantic-interposition ;
|
|
}
|
|
|
|
ccBaseFlags += -ffreestanding ;
|
|
|
|
# Since GCC 13, autovectorization generates code which causes problems
|
|
# in various virtual machines (bare metal is apparently unaffected.)
|
|
# Until this can be resolved, disable for the kernel. (See #18593.)
|
|
ccBaseFlags += -fno-tree-vectorize ;
|
|
}
|
|
|
|
local c++BaseFlags = $(ccBaseFlags) -fno-exceptions ;
|
|
|
|
if $(HAIKU_CC_IS_LEGACY_GCC_$(architecture)) != 1
|
|
&& $(HAIKU_CC_IS_CLANG_$(architecture)) != 1 {
|
|
c++BaseFlags += -fno-use-cxa-atexit ;
|
|
}
|
|
|
|
HAIKU_KERNEL_CCFLAGS = $(HAIKU_CCFLAGS_$(architecture)) $(ccBaseFlags) ;
|
|
HAIKU_KERNEL_C++FLAGS = $(HAIKU_C++FLAGS_$(architecture)) $(c++BaseFlags) ;
|
|
HAIKU_KERNEL_PIC_CCFLAGS = ;
|
|
HAIKU_KERNEL_PIC_LINKFLAGS = ;
|
|
HAIKU_KERNEL_ADDON_LINKFLAGS = ;
|
|
|
|
# Common boot-related cflags which apply to all loaders
|
|
HAIKU_BOOT_CCFLAGS = $(HAIKU_CCFLAGS_$(architecture)) $(ccBaseFlags) ;
|
|
HAIKU_BOOT_C++FLAGS = $(HAIKU_C++FLAGS_$(architecture)) $(c++BaseFlags) ;
|
|
HAIKU_BOOT_OPTIM = -Os ;
|
|
HAIKU_BOOT_LINKFLAGS = ;
|
|
HAIKU_BOOT_LDFLAGS = -Bstatic ;
|
|
|
|
# Remove -fPIC and other unwanted options from the BOOT flags (they are sometimes
|
|
# added to force PIC in general.)
|
|
local fixedBootCCFlags ;
|
|
local fixedBootC++Flags ;
|
|
for flag in $(HAIKU_BOOT_CCFLAGS) {
|
|
if $(flag) = "-fpic" || $(flag) = "-fPIC" {
|
|
continue ;
|
|
}
|
|
fixedBootCCFlags += $(flag) ;
|
|
}
|
|
for flag in $(HAIKU_BOOT_C++FLAGS) {
|
|
if $(flag) = "-fpic" || $(flag) = "-fPIC" {
|
|
continue ;
|
|
}
|
|
fixedBootC++Flags += $(flag) ;
|
|
}
|
|
HAIKU_BOOT_CCFLAGS = $(fixedBootCCFlags) ;
|
|
HAIKU_BOOT_C++FLAGS = $(fixedBootC++Flags) ;
|
|
|
|
# Any special kernel base addresses
|
|
if $(HAIKU_BOOT_LOADER_BASE) {
|
|
HAIKU_BOOT_LDFLAGS +=
|
|
--defsym BOOT_LOADER_BASE=$(HAIKU_BOOT_LOADER_BASE) ;
|
|
}
|
|
|
|
switch $(cpu) {
|
|
case arm :
|
|
HAIKU_KERNEL_PIC_LINKFLAGS += -z max-page-size=0x1000 ;
|
|
HAIKU_KERNEL_ADDON_LINKFLAGS += -z max-page-size=0x1000 ;
|
|
HAIKU_KERNEL_PIC_CCFLAGS = -fpic ;
|
|
HAIKU_KERNEL_PIC_LINKFLAGS = -shared ;
|
|
|
|
case arm64 :
|
|
HAIKU_KERNEL_PIC_LINKFLAGS += -z max-page-size=0x1000 ;
|
|
HAIKU_KERNEL_ADDON_LINKFLAGS += -z max-page-size=0x1000 ;
|
|
HAIKU_KERNEL_PIC_CCFLAGS = -fpic ;
|
|
HAIKU_KERNEL_PIC_LINKFLAGS = -shared ;
|
|
|
|
case m68k :
|
|
# We don't want to have to handle emulating missing FPU opcodes for
|
|
# 040 and 060 in the kernel.
|
|
HAIKU_KERNEL_CCFLAGS += -m68020-60 ;
|
|
HAIKU_KERNEL_C++FLAGS += -m68020-60 ;
|
|
|
|
case ppc :
|
|
# Build a position independent PPC kernel. We need to be able to
|
|
# relocate the kernel, since the virtual address space layout at
|
|
# boot time is not fixed.
|
|
HAIKU_KERNEL_PIC_CCFLAGS = -fPIE ;
|
|
HAIKU_KERNEL_PIC_LINKFLAGS = -shared -fPIE ;
|
|
|
|
case riscv64 :
|
|
# Kernel lives within any single 2 GiB address space.
|
|
# Default is medlow (-2GiB / +2GiB)
|
|
HAIKU_KERNEL_CCFLAGS += -mcmodel=medany -fpic ;
|
|
HAIKU_KERNEL_C++FLAGS += -mcmodel=medany -fpic ;
|
|
HAIKU_KERNEL_PIC_LINKFLAGS = -shared ;
|
|
|
|
case sparc :
|
|
# The medlow code model is enough (64-bit addresses, programs must
|
|
# be linked in the low 32 bits of memory. Programs can be
|
|
# statically or dynamically linked.)
|
|
HAIKU_KERNEL_CCFLAGS += -mcmodel=medlow ;
|
|
HAIKU_KERNEL_C++FLAGS += -mcmodel=medlow ;
|
|
|
|
# Unfortunately it's not easy to make the kernel be
|
|
# position-independant, on sparc, that requires relocation support
|
|
# in the ELF loader to fill in the plt section.
|
|
HAIKU_KERNEL_PIC_CCFLAGS = -fPIE ;
|
|
HAIKU_KERNEL_PIC_LINKFLAGS = -shared -fPIE ;
|
|
|
|
case x86 :
|
|
HAIKU_KERNEL_PIC_CCFLAGS = -fno-pic ;
|
|
HAIKU_KERNEL_CCFLAGS += -march=pentium ;
|
|
HAIKU_KERNEL_C++FLAGS += -march=pentium ;
|
|
|
|
case x86_64 :
|
|
# Kernel lives in the top 2GB of the address space, use kernel code
|
|
# model.
|
|
HAIKU_KERNEL_PIC_CCFLAGS = -fno-pic -mcmodel=kernel ;
|
|
|
|
# Disable the red zone, which cannot be used in kernel code due to
|
|
# interrupts, and always enable the frame pointer so stack traces
|
|
# are correct.
|
|
HAIKU_KERNEL_CCFLAGS += -mno-red-zone -fno-omit-frame-pointer ;
|
|
HAIKU_KERNEL_C++FLAGS += -mno-red-zone -fno-omit-frame-pointer ;
|
|
HAIKU_KERNEL_PIC_LINKFLAGS += -z max-page-size=0x1000 ;
|
|
HAIKU_KERNEL_ADDON_LINKFLAGS += -z max-page-size=0x1000 ;
|
|
|
|
if x86 in $(HAIKU_ARCHS[2-]) || x86_gcc2 in $(HAIKU_ARCHS[2-]) {
|
|
Echo "Enable kernel ia32 compatibility" ;
|
|
HAIKU_KERNEL_DEFINES += _COMPAT_MODE ;
|
|
HAIKU_KERNEL_COMPAT_MODE = 1 ;
|
|
}
|
|
}
|
|
|
|
# bootloader-centric flags
|
|
HAIKU_BOOT_CCFLAGS
|
|
+= -DBOOT_ARCHIVE_IMAGE_OFFSET=$(HAIKU_BOOT_ARCHIVE_IMAGE_OFFSET) ;
|
|
HAIKU_BOOT_C++FLAGS
|
|
+= -DBOOT_ARCHIVE_IMAGE_OFFSET=$(HAIKU_BOOT_ARCHIVE_IMAGE_OFFSET) ;
|
|
|
|
local bootTarget ;
|
|
for bootTarget in $(HAIKU_BOOT_TARGETS) {
|
|
switch $(bootTarget) {
|
|
case efi :
|
|
# efi bootloader is PIC
|
|
HAIKU_BOOT_$(bootTarget:U)_CCFLAGS += -fpic -fno-stack-protector
|
|
-fPIC -fshort-wchar -Wno-error=unused-variable -Wno-error=main ;
|
|
HAIKU_BOOT_$(bootTarget:U)_C++FLAGS += -fpic -fno-stack-protector
|
|
-fPIC -fshort-wchar -Wno-error=unused-variable -Wno-error=main ;
|
|
switch $(cpu) {
|
|
case x86 :
|
|
if $(HAIKU_CC_IS_CLANG_$(architecture)) != 1 {
|
|
HAIKU_BOOT_$(bootTarget:U)_CCFLAGS += -maccumulate-outgoing-args ;
|
|
HAIKU_BOOT_$(bootTarget:U)_C++FLAGS += -maccumulate-outgoing-args ;
|
|
}
|
|
case x86_64 :
|
|
HAIKU_BOOT_$(bootTarget:U)_CCFLAGS += -mno-red-zone ;
|
|
HAIKU_BOOT_$(bootTarget:U)_C++FLAGS += -mno-red-zone ;
|
|
if $(HAIKU_CC_IS_CLANG_$(architecture)) != 1 {
|
|
HAIKU_BOOT_$(bootTarget:U)_CCFLAGS += -maccumulate-outgoing-args ;
|
|
HAIKU_BOOT_$(bootTarget:U)_C++FLAGS += -maccumulate-outgoing-args ;
|
|
}
|
|
case arm :
|
|
HAIKU_BOOT_$(bootTarget:U)_CCFLAGS += -mfloat-abi=soft ;
|
|
HAIKU_BOOT_$(bootTarget:U)_C++FLAGS += -mfloat-abi=soft ;
|
|
|
|
# Remove any previous -mfloat-abi=hard setting from compiler flags
|
|
local fixedBootCCFlags ;
|
|
local fixedBootC++Flags ;
|
|
for flag in $(HAIKU_BOOT_CCFLAGS) {
|
|
if $(flag) = "-mfloat-abi=hard" {
|
|
continue ;
|
|
}
|
|
fixedBootCCFlags += $(flag) ;
|
|
}
|
|
for flag in $(HAIKU_BOOT_C++FLAGS) {
|
|
if $(flag) = "-mfloat-abi=hard" {
|
|
continue ;
|
|
}
|
|
fixedBootC++Flags += $(flag) ;
|
|
}
|
|
HAIKU_BOOT_CCFLAGS = $(fixedBootCCFlags) ;
|
|
HAIKU_BOOT_C++FLAGS = $(fixedBootC++Flags) ;
|
|
}
|
|
HAIKU_BOOT_$(bootTarget:U)_LDFLAGS = -Bstatic -Bsymbolic
|
|
-nostdlib -znocombreloc -no-undefined ;
|
|
case bios_ia32 :
|
|
# bios_ia32 is non-PIC
|
|
HAIKU_BOOT_$(bootTarget:U)_CCFLAGS += -fno-pic -march=pentium ;
|
|
HAIKU_BOOT_$(bootTarget:U)_C++FLAGS += -fno-pic -march=pentium ;
|
|
if $(HAIKU_CC_IS_CLANG_$(architecture)) = 1 {
|
|
HAIKU_BOOT_$(bootTarget:U)_LDFLAGS += -m elf_i386 ;
|
|
} else {
|
|
HAIKU_BOOT_$(bootTarget:U)_LDFLAGS += -m elf_i386_haiku ;
|
|
}
|
|
if $(HAIKU_CC_IS_LEGACY_GCC_$(architecture)) != 1 {
|
|
HAIKU_BOOT_$(bootTarget:U)_CCFLAGS += -Wno-error=main -m32 ;
|
|
HAIKU_BOOT_$(bootTarget:U)_C++FLAGS += -Wno-error=main -m32 ;
|
|
}
|
|
case pxe_ia32 :
|
|
# pxe_ia32 is non-PIC
|
|
HAIKU_BOOT_$(bootTarget:U)_CCFLAGS += -fno-pic -march=pentium ;
|
|
HAIKU_BOOT_$(bootTarget:U)_C++FLAGS += -fno-pic -march=pentium ;
|
|
if $(HAIKU_CC_IS_CLANG_$(architecture)) = 1 {
|
|
HAIKU_BOOT_$(bootTarget:U)_LDFLAGS += -m elf_i386 ;
|
|
} else {
|
|
HAIKU_BOOT_$(bootTarget:U)_LDFLAGS += -m elf_i386_haiku ;
|
|
}
|
|
if $(HAIKU_CC_IS_LEGACY_GCC_$(architecture)) != 1 {
|
|
HAIKU_BOOT_$(bootTarget:U)_CCFLAGS += -Wno-error=main -m32 ;
|
|
HAIKU_BOOT_$(bootTarget:U)_C++FLAGS += -Wno-error=main -m32 ;
|
|
}
|
|
case *_m68k :
|
|
# TODO: make sure all m68k bootloaders are non-PIC
|
|
HAIKU_BOOT_$(bootTarget:U)_CCFLAGS += -fno-pic -Wno-error=main ;
|
|
HAIKU_BOOT_$(bootTarget:U)_C++FLAGS += -fno-pic -Wno-error=main ;
|
|
switch $(cpu) {
|
|
case m68k :
|
|
# use only common instructions by default
|
|
HAIKU_BOOT_$(bootTarget:U)_CCFLAGS += -m68020-60 ;
|
|
HAIKU_BOOT_$(bootTarget:U)_C++FLAGS += -m68020-60 ;
|
|
# TODO: coldfire (FireBee)
|
|
}
|
|
case riscv :
|
|
HAIKU_BOOT_$(bootTarget:U)_CCFLAGS += -mcmodel=medany -fno-omit-frame-pointer -fno-plt -fno-pic -fno-semantic-interposition ;
|
|
HAIKU_BOOT_$(bootTarget:U)_C++FLAGS += -mcmodel=medany -fno-omit-frame-pointer -fno-plt -fno-pic -fno-semantic-interposition ;
|
|
case openfirmware :
|
|
HAIKU_BOOT_$(bootTarget:U)_CCFLAGS += -fno-pic -fno-semantic-interposition -Wno-error=main -Wstack-usage=1023 ;
|
|
HAIKU_BOOT_$(bootTarget:U)_C++FLAGS += -fno-pic -fno-semantic-interposition -Wno-error=main -Wstack-usage=1023 ;
|
|
case * :
|
|
# all other bootloaders are non-PIC
|
|
HAIKU_BOOT_$(bootTarget:U)_CCFLAGS += -fno-pic -Wno-error=main ;
|
|
HAIKU_BOOT_$(bootTarget:U)_C++FLAGS += -fno-pic -Wno-error=main ;
|
|
}
|
|
}
|
|
|
|
# warning flags
|
|
HAIKU_KERNEL_WARNING_CCFLAGS = $(HAIKU_WARNING_CCFLAGS_$(architecture)) ;
|
|
HAIKU_KERNEL_WARNING_C++FLAGS = $(HAIKU_WARNING_C++FLAGS_$(architecture)) ;
|
|
|
|
# debug flags
|
|
local level ;
|
|
for level in $(HAIKU_DEBUG_LEVELS) {
|
|
local flags = $(HAIKU_DEBUG_FLAGS) [ FDefines DEBUG=$(level) ] ;
|
|
HAIKU_KERNEL_DEBUG_$(level)_CCFLAGS
|
|
= $(HAIKU_DEBUG_$(level)_CCFLAGS_$(architecture)) ;
|
|
HAIKU_KERNEL_DEBUG_$(level)_C++FLAGS
|
|
= $(HAIKU_DEBUG_$(level)_C++FLAGS_$(architecture)) ;
|
|
}
|
|
|
|
# defines
|
|
HAIKU_KERNEL_DEFINES += _KERNEL_MODE ;
|
|
HAIKU_BOOT_DEFINES += _BOOT_MODE ;
|
|
|
|
# kernel add-on glue code
|
|
HAIKU_KERNEL_ADDON_BEGIN_GLUE_CODE = <$(architecture)>crtbeginS.o
|
|
<src!system!glue!$(architecture)>haiku_version_glue.o ;
|
|
HAIKU_KERNEL_ADDON_END_GLUE_CODE = <$(architecture)>crtendS.o ;
|
|
}
|
|
|
|
|
|
rule ArchitectureSetupWarnings architecture
|
|
{
|
|
# ArchitectureSetupWarnings <architecture> ;
|
|
#
|
|
# Sets up compiler warnings and error flags for various subdirectories for
|
|
# the given packaging architecture.
|
|
|
|
if $(HAIKU_CC_IS_CLANG_$(architecture)) = 1 {
|
|
AppendToConfigVar CCFLAGS :
|
|
HAIKU_TOP src system libroot posix glibc :
|
|
-fgnu89-inline -fheinous-gnu-extensions : global ;
|
|
}
|
|
|
|
local cpu = $(HAIKU_CPU_$(architecture)) ;
|
|
switch $(cpu) {
|
|
case arm :
|
|
return ;
|
|
# we use #warning as placeholders for things to write...
|
|
case m68k :
|
|
return ;
|
|
# we use #warning as placeholders for things to write...
|
|
case ppc :
|
|
return ;
|
|
# we use #warning as placeholders for things to write...
|
|
}
|
|
|
|
# enable -Werror for certain parts of the source tree
|
|
HAIKU_WERROR_ARCH = $(architecture) ;
|
|
|
|
rule EnableWerror dirTokens : scope {
|
|
# Clang gives way more warnings than GCC, so that code won't compile
|
|
# with -Werror when using Clang.
|
|
if $(HAIKU_CC_IS_CLANG_$(architecture)) != 1 {
|
|
SetConfigVar WARNINGS : HAIKU_TOP $(dirTokens) : treatAsErrors
|
|
: $(scope) ;
|
|
}
|
|
}
|
|
|
|
rule EnableStackProtector dirTokens : scope {
|
|
# enable stack protector, if requested
|
|
if $(HAIKU_USE_STACK_PROTECTOR) = 1 {
|
|
AppendToConfigVar CCFLAGS : HAIKU_TOP $(dirTokens) :
|
|
-fstack-protector : $(scope) ;
|
|
AppendToConfigVar C++FLAGS : HAIKU_TOP $(dirTokens) :
|
|
-fstack-protector : $(scope) ;
|
|
}
|
|
}
|
|
|
|
# Work-around for GCC 2 problem -- despite -Wno-multichar it reports
|
|
# multichar warnings in headers/private/kernel/debugger_keymaps.h included
|
|
# by src/system/kernel/arch/x86/arch_debug_console.cpp.
|
|
if $(HAIKU_CC_IS_LEGACY_GCC_$(architecture)) = 1 {
|
|
local file = <src!system!kernel!arch!x86>arch_debug_console.o ;
|
|
WARNINGS on $(file) = $(WARNINGS) ;
|
|
}
|
|
|
|
EnableWerror src add-ons accelerants ;
|
|
EnableWerror src add-ons bluetooth ;
|
|
EnableWerror src add-ons decorators ;
|
|
EnableWerror src add-ons disk_systems ;
|
|
EnableWerror src add-ons input_server ;
|
|
EnableWerror src add-ons kernel bluetooth ;
|
|
EnableWerror src add-ons kernel bus_managers ;
|
|
EnableWerror src add-ons kernel busses ;
|
|
EnableWerror src add-ons kernel console ;
|
|
EnableWerror src add-ons kernel cpu ;
|
|
EnableWerror src add-ons kernel debugger ;
|
|
# EnableWerror src add-ons kernel drivers audio ;
|
|
EnableWerror src add-ons kernel drivers bluetooth ;
|
|
EnableWerror src add-ons kernel drivers bus ;
|
|
EnableWerror src add-ons kernel drivers common ;
|
|
EnableWerror src add-ons kernel drivers disk ;
|
|
EnableWerror src add-ons kernel drivers dvb ;
|
|
# EnableWerror src add-ons kernel drivers graphics ;
|
|
EnableWerror src add-ons kernel drivers graphics intel_extreme ;
|
|
EnableWerror src add-ons kernel drivers input ;
|
|
EnableWerror src add-ons kernel drivers joystick ;
|
|
EnableWerror src add-ons kernel drivers midi ;
|
|
EnableWerror src add-ons kernel drivers misc ;
|
|
EnableWerror src add-ons kernel drivers network ether 3com ;
|
|
# EnableWerror src add-ons kernel drivers network ether atheros813x ;
|
|
# EnableWerror src add-ons kernel drivers network ether atheros81xx ;
|
|
# EnableWerror src add-ons kernel drivers network ether attansic_l1 ;
|
|
# EnableWerror src add-ons kernel drivers network ether attansic_l2 ;
|
|
# EnableWerror src add-ons kernel drivers network ether broadcom440x ;
|
|
# EnableWerror src add-ons kernel drivers network ether broadcom570x ;
|
|
# EnableWerror src add-ons kernel drivers network ether dec21xxx ;
|
|
EnableWerror src add-ons kernel drivers network ether etherpci ;
|
|
# EnableWerror src add-ons kernel drivers network ether intel22x ;
|
|
# EnableWerror src add-ons kernel drivers network ether ipro100 ;
|
|
# EnableWerror src add-ons kernel drivers network ether ipro1000 ;
|
|
# EnableWerror src add-ons kernel drivers network ether jmicron2x0 ;
|
|
# EnableWerror src add-ons kernel drivers network ether marvell_yukon ;
|
|
# EnableWerror src add-ons kernel drivers network ether nforce ;
|
|
# EnableWerror src add-ons kernel drivers network ether pcnet ;
|
|
EnableWerror src add-ons kernel drivers network ether pegasus ;
|
|
EnableWerror src add-ons kernel drivers network ether rdc ;
|
|
# EnableWerror src add-ons kernel drivers network ether rtl8139 ;
|
|
# EnableWerror src add-ons kernel drivers network ether rtl81xx ;
|
|
EnableWerror src add-ons kernel drivers network ether sis19x ;
|
|
# EnableWerror src add-ons kernel drivers network ether sis900 ;
|
|
# EnableWerror src add-ons kernel drivers network ether syskonnect ;
|
|
EnableWerror src add-ons kernel drivers network ether usb_asix ;
|
|
EnableWerror src add-ons kernel drivers network ether usb_davicom ;
|
|
EnableWerror src add-ons kernel drivers network ether usb_ecm ;
|
|
EnableWerror src add-ons kernel drivers network ether usb_rndis ;
|
|
EnableWerror src add-ons kernel drivers network ether via_rhine ;
|
|
EnableWerror src add-ons kernel drivers network ether virtio ;
|
|
# EnableWerror src add-ons kernel drivers network ether vt612x ;
|
|
EnableWerror src add-ons kernel drivers network ether wb840 ;
|
|
# EnableWerror src add-ons kernel drivers network wlan ;
|
|
EnableWerror src add-ons kernel drivers network wwan ;
|
|
EnableWerror src add-ons kernel drivers ports ;
|
|
EnableWerror src add-ons kernel drivers power ;
|
|
EnableWerror src add-ons kernel drivers printer ;
|
|
EnableWerror src add-ons kernel drivers random ;
|
|
EnableWerror src add-ons kernel drivers tty ;
|
|
EnableWerror src add-ons kernel drivers video ;
|
|
EnableWerror src add-ons kernel file_systems bfs ;
|
|
EnableWerror src add-ons kernel file_systems cdda ;
|
|
EnableWerror src add-ons kernel file_systems ext2 ;
|
|
EnableWerror src add-ons kernel file_systems fat ;
|
|
EnableWerror src add-ons kernel file_systems googlefs ;
|
|
EnableWerror src add-ons kernel file_systems iso9660 ;
|
|
EnableWerror src add-ons kernel file_systems layers ;
|
|
# EnableWerror src add-ons kernel file_systems netfs ;
|
|
EnableWerror src add-ons kernel file_systems nfs ;
|
|
EnableWerror src add-ons kernel file_systems nfs4 ;
|
|
# EnableWerror src add-ons kernel file_systems ntfs ;
|
|
EnableWerror src add-ons kernel file_systems packagefs ;
|
|
EnableWerror src add-ons kernel file_systems ramfs ;
|
|
EnableWerror src add-ons kernel file_systems reiserfs ;
|
|
EnableWerror src add-ons kernel file_systems udf ;
|
|
EnableWerror src add-ons kernel file_systems userlandfs ;
|
|
EnableWerror src add-ons kernel file_systems xfs ;
|
|
EnableWerror src add-ons kernel generic ;
|
|
EnableWerror src add-ons kernel network ;
|
|
EnableWerror src add-ons kernel partitioning_systems ;
|
|
EnableWerror src add-ons kernel power ;
|
|
EnableWerror src add-ons locale ;
|
|
EnableWerror src add-ons mail_daemon ;
|
|
EnableWerror src add-ons media media-add-ons ;
|
|
EnableWerror src add-ons media plugins ape_reader ;
|
|
EnableWerror src add-ons media plugins au_reader ;
|
|
EnableWerror src add-ons media plugins ffmpeg ;
|
|
EnableWerror src add-ons media plugins raw_decoder ;
|
|
EnableWerror src add-ons print ;
|
|
EnableWerror src add-ons screen_savers ;
|
|
EnableWerror src add-ons tracker ;
|
|
EnableWerror src add-ons translators bmp ;
|
|
EnableWerror src add-ons translators exr ;
|
|
EnableWerror src add-ons translators gif ;
|
|
EnableWerror src add-ons translators hvif ;
|
|
EnableWerror src add-ons translators ico ;
|
|
EnableWerror src add-ons translators jpeg ;
|
|
# EnableWerror src add-ons translators jpeg2000 ;
|
|
EnableWerror src add-ons translators pcx ;
|
|
EnableWerror src add-ons translators png ;
|
|
EnableWerror src add-ons translators ppm ;
|
|
EnableWerror src add-ons translators raw ;
|
|
EnableWerror src add-ons translators rtf ;
|
|
EnableWerror src add-ons translators sgi ;
|
|
EnableWerror src add-ons translators shared ;
|
|
EnableWerror src add-ons translators stxt ;
|
|
EnableWerror src add-ons translators tga ;
|
|
EnableWerror src add-ons translators tiff ;
|
|
EnableWerror src add-ons translators wonderbrush ;
|
|
EnableWerror src add-ons print ;
|
|
EnableWerror src bin debug strace ;
|
|
EnableWerror src bin desklink ;
|
|
EnableWerror src bin listusb ;
|
|
EnableWerror src bin multiuser ;
|
|
EnableWerror src bin package ;
|
|
EnableWerror src bin package_repo ;
|
|
EnableWerror src bin pkgman ;
|
|
EnableWerror src bin writembr ;
|
|
EnableWerror src libs bsd ;
|
|
EnableWerror src apps ;
|
|
EnableWerror src kits ;
|
|
EnableWerror src preferences ;
|
|
EnableWerror src servers ;
|
|
EnableWerror src system boot ;
|
|
EnableWerror src system kernel ;
|
|
EnableWerror src system libroot add-ons ;
|
|
EnableWerror src system libroot os ;
|
|
EnableWerror src system libroot posix locale ;
|
|
EnableWerror src system libroot posix wchar ;
|
|
EnableWerror src system runtime_loader ;
|
|
|
|
EnableStackProtector src apps ;
|
|
EnableStackProtector src kits ;
|
|
EnableStackProtector src preferences ;
|
|
EnableStackProtector src servers ;
|
|
EnableStackProtector src system kernel ;
|
|
}
|
|
|
|
|
|
rule MultiArchIfPrimary ifValue : elseValue : architecture
|
|
{
|
|
# MultiArchIfPrimary <ifValue> : <elseValue>
|
|
# [ : <architecture> = $(TARGET_PACKAGING_ARCH) ] ;
|
|
#
|
|
# Returns one of the two given values depending on whether
|
|
# <architecture> is the primary packaging architecture.
|
|
|
|
architecture ?= $(TARGET_PACKAGING_ARCH) ;
|
|
|
|
if $(architecture) = $(TARGET_PACKAGING_ARCHS[1]) {
|
|
return $(ifValue) ;
|
|
}
|
|
return $(elseValue) ;
|
|
}
|
|
|
|
|
|
rule MultiArchConditionalGristFiles files : primaryGrist : secondaryGrist
|
|
: architecture
|
|
{
|
|
# MultiArchConditionalGristFiles <files> : <primaryGrist>
|
|
# : <secondaryGrist> [ : <architecture> = $(TARGET_PACKAGING_ARCH) ] ;
|
|
#
|
|
# Returns <files> with their grist set to either <primaryGrist> or
|
|
# <secondaryGrist> depending on whether <architecture> is the primary
|
|
# packaging architecture.
|
|
|
|
architecture ?= $(TARGET_PACKAGING_ARCH) ;
|
|
|
|
local grist = [ MultiArchIfPrimary $(primaryGrist) : $(secondaryGrist)
|
|
: $(architecture) ] ;
|
|
return $(files:G=$(grist:E=)) ;
|
|
}
|
|
|
|
|
|
rule MultiArchDefaultGristFiles files : gristPrefix : architecture
|
|
{
|
|
# MultiArchDefaultGristFiles <files> : <gristPrefix>
|
|
# [ : <architecture> = $(TARGET_PACKAGING_ARCH) ] ;
|
|
#
|
|
# Convenient shorthand for MultiArchConditionalGristFiles for the common
|
|
# case that for a secondary packaging architecture the packaging
|
|
# architecture name shall be appended to the grist while it shall be omitted
|
|
# for the primary packaging architecture. IOW, if architecture is the
|
|
# primary packaging architecture, <files> are returned with their grist set
|
|
# to <gristPrefix>, otherwise <files> are returned with their grist set to
|
|
# <gristPrefix>!<architecture> respectively <architecture> (if <gristPrefix>
|
|
# is empty).
|
|
|
|
architecture ?= $(TARGET_PACKAGING_ARCH) ;
|
|
|
|
local secondaryGrist = $(gristPrefix)!$(architecture) ;
|
|
secondaryGrist ?= $(architecture) ;
|
|
|
|
return [ MultiArchConditionalGristFiles $(files) : $(gristPrefix) :
|
|
$(secondaryGrist) : $(architecture) ] ;
|
|
}
|
|
|
|
|
|
rule MultiArchSubDirSetup architectures
|
|
{
|
|
# MultiArchSubDirSetup <architectures> ;
|
|
#
|
|
# For each of the given packaging architectures <architectures> that are
|
|
# in the packaging architectures configured for the build (or all configured
|
|
# packaging architectures, if <architectures> is empty) an object is
|
|
# prepared that can be used for an "on ... { ... }" block to set up subdir
|
|
# variables for the respective packaging architecture. Most notably
|
|
# TARGET_PACKAGING_ARCH, TARGET_ARCH are set to the values for the
|
|
# respective packaging architecture. The per-subdir variables SOURCE_GRIST,
|
|
# LOCATE_TARGET, LOCATE_SOURCE, SEARCH_SOURCE, *_LOCATE_TARGET, are reset.
|
|
# All SUBDIR* and config variables are set to the values they had when this
|
|
# rule was invoked.
|
|
|
|
local result ;
|
|
architectures ?= $(TARGET_PACKAGING_ARCHS) ;
|
|
local architecture ;
|
|
for architecture in $(architectures) {
|
|
if ! $(architecture) in $(TARGET_PACKAGING_ARCHS) {
|
|
continue ;
|
|
}
|
|
|
|
local architectureObject = $(architecture:G=<arch-object>) ;
|
|
result += $(architectureObject) ;
|
|
|
|
# Set the variables that default to the values of the respective
|
|
# variables for the primary architecture.
|
|
TARGET_PACKAGING_ARCH on $(architectureObject) = $(architecture) ;
|
|
|
|
local var ;
|
|
for var in TARGET_ARCH {
|
|
$(var) on $(architectureObject) = $($(var)_$(architecture)) ;
|
|
}
|
|
|
|
# Clone the current config variable values and the variables SubDir
|
|
# resets.
|
|
for var in $(AUTO_SET_UP_CONFIG_VARIABLES) SUBDIR$(SUBDIRRESET) {
|
|
$(var) on $(architectureObject) = $($(var)) ;
|
|
}
|
|
|
|
# adjust SOURCE_GRIST and HDRGRIST
|
|
SOURCE_GRIST on $(architectureObject)
|
|
= $(SOURCE_GRIST:E=)!$(architecture) ;
|
|
|
|
HDRGRIST on $(architectureObject)
|
|
= $(HDRGRIST:E=)!$(architecture) ;
|
|
|
|
# Adjust the subdir's object dirs that are architecture dependent. To
|
|
# avoid duplicating the code from SetupObjectsDir, we call it. Since it
|
|
# sets global variables, we set these variables on our object, call
|
|
# SetupObjectsDir in an "on" block, and grab the new variable values.
|
|
local hostTarget = HOST TARGET ;
|
|
local objectDirVars =
|
|
COMMON_ARCH COMMON_DEBUG DEBUG_$(HAIKU_DEBUG_LEVELS)
|
|
;
|
|
objectDirVars =
|
|
COMMON_PLATFORM_LOCATE_TARGET
|
|
$(hostTarget)_$(objectDirVars)_LOCATE_TARGET
|
|
LOCATE_TARGET
|
|
LOCATE_SOURCE
|
|
SEARCH_SOURCE
|
|
;
|
|
|
|
for var in $(objectDirVars) {
|
|
$(var) on $(architectureObject) = ;
|
|
}
|
|
|
|
on $(architectureObject) {
|
|
SetupObjectsDir ;
|
|
|
|
for var in $(objectDirVars) {
|
|
$(var) on $(architectureObject) = $($(var)) ;
|
|
}
|
|
}
|
|
}
|
|
|
|
return $(result) ;
|
|
}
|