rule ArchitectureSetup architecture { # ArchitectureSetup ; # # 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 ; } 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-address-of-packed-member -Wno-unused-private-field -Wno-cast-align -Wno-gnu-designator -Wno-builtin-requires-header ; HAIKU_WARNING_C++FLAGS_$(architecture) += -Wno-address-of-packed-member -Wno-unused-private-field -Wno-cast-align -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=deprecated -Wno-error=deprecated-declarations -Wno-error=cpp -Wno-error=trigraphs -Wno-error=register ; # These currently generate too many "false positives." #HAIKU_WERROR_FLAGS_$(architecture) += -Wno-error=address-of-packed-member ; # 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 = init_term_dyn.o crti.o crtn.o ; HAIKU_LIBRARY_BEGIN_GLUE_CODE_$(architecture) = crti.o <$(architecture)>crtbeginS.o init_term_dyn.o ; HAIKU_LIBRARY_END_GLUE_CODE_$(architecture) = <$(architecture)>crtendS.o crtn.o ; HAIKU_EXECUTABLE_BEGIN_GLUE_CODE_$(architecture) = crti.o <$(architecture)>crtbeginS.o start_dyn.o 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 = input_server ; } else { HAIKU_LIBRARY_NAME_MAP_$(architecture)_input_server = <$(architecture)>input_server ; } } rule KernelArchitectureSetup architecture { # KernelArchitectureSetup ; # # 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. 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 pxe_ia32 ; HAIKU_ANYBOOT_LEGACY = 1 ; 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 ; } 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_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 ; } } 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 ; # kernel add-on glue code HAIKU_KERNEL_ADDON_BEGIN_GLUE_CODE = <$(architecture)>crtbeginS.o haiku_version_glue.o ; HAIKU_KERNEL_ADDON_END_GLUE_CODE = <$(architecture)>crtendS.o ; } rule ArchitectureSetupWarnings architecture { # ArchitectureSetupWarnings ; # # 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 = 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 devices ; EnableWerror src add-ons input_server filters ; EnableWerror src add-ons input_server methods pen ; EnableWerror src add-ons input_server methods t9 ; EnableWerror src add-ons kernel bluetooth ; EnableWerror src add-ons kernel bus_managers acpi ; EnableWerror src add-ons kernel bus_managers agp_gart ; EnableWerror src add-ons kernel bus_managers ata ; EnableWerror src add-ons kernel bus_managers config_manager ; EnableWerror src add-ons kernel bus_managers firewire ; EnableWerror src add-ons kernel bus_managers ide ; EnableWerror src add-ons kernel bus_managers isa ; EnableWerror src add-ons kernel bus_managers pci ; EnableWerror src add-ons kernel bus_managers ps2 ; EnableWerror src add-ons kernel bus_managers random ; EnableWerror src add-ons kernel bus_managers scsi ; EnableWerror src add-ons kernel bus_managers tty ; EnableWerror src add-ons kernel bus_managers usb ; EnableWerror src add-ons kernel bus_managers virtio ; EnableWerror src add-ons kernel busses agp_gart ; EnableWerror src add-ons kernel busses ata ; # EnableWerror src add-ons kernel busses i2c ; # EnableWerror src add-ons kernel busses mmc ; # EnableWerror src add-ons kernel busses random ; EnableWerror src add-ons kernel busses scsi ; EnableWerror src add-ons kernel busses usb ; # EnableWerror src add-ons kernel busses virtio ; 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 ; 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 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 demultiplexer ; EnableWerror src add-ons media media-add-ons dvb ; EnableWerror src add-ons media media-add-ons esound_sink ; EnableWerror src add-ons media media-add-ons finepix_webcam ; EnableWerror src add-ons media media-add-ons firewire_dv ; EnableWerror src add-ons media media-add-ons legacy ; EnableWerror src add-ons media media-add-ons mixer ; EnableWerror src add-ons media media-add-ons multi_audio ; EnableWerror src add-ons media media-add-ons opensound ; EnableWerror src add-ons media media-add-ons radeon ; EnableWerror src add-ons media media-add-ons reader ; EnableWerror src add-ons media media-add-ons tone_producer_demo ; EnableWerror src add-ons media media-add-ons usb_vision ; EnableWerror src add-ons media media-add-ons usb_webcam ; EnableWerror src add-ons media media-add-ons video_mixer ; EnableWerror src add-ons media media-add-ons video_producer_demo ; EnableWerror src add-ons media media-add-ons videowindow ; EnableWerror src add-ons media media-add-ons writer ; 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 desklink ; EnableWerror src bin multiuser ; EnableWerror src bin package ; EnableWerror src bin package_repo ; EnableWerror src bin pkgman ; 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 : # [ : = $(TARGET_PACKAGING_ARCH) ] ; # # Returns one of the two given values depending on whether # 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 : # : [ : = $(TARGET_PACKAGING_ARCH) ] ; # # Returns with their grist set to either or # depending on whether 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 : # [ : = $(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, are returned with their grist set # to , otherwise are returned with their grist set to # ! respectively (if # is empty). architecture ?= $(TARGET_PACKAGING_ARCH) ; local secondaryGrist = $(gristPrefix)!$(architecture) ; secondaryGrist ?= $(architecture) ; return [ MultiArchConditionalGristFiles $(files) : $(gristPrefix) : $(secondaryGrist) : $(architecture) ] ; } rule MultiArchSubDirSetup architectures { # MultiArchSubDirSetup ; # # For each of the given packaging architectures that are # in the packaging architectures configured for the build (or all configured # packaging architectures, if 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=) ; 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) ; }