build/jam/BuildSetup

   1 # Variable naming conventions:
   2 # TARGET_*:     A build system variable specifying a property for building for
   3 #                       the target platform (usually Haiku). E.g. TARGET_CC specifies the
   4 #                       compiler when building a target for the target platform.
   5 # HOST_*:       A build system variable specifying a property of the platform
   6 #                       hosting the build. E.g. HOST_CC specifies the compiler when
   7 #                       building a target for the host platform (a build tool for
   8 #                       instance).
   9 # HAIKU_*:      A build system variable specifying a build system property. Usually
  10 #                       directory paths and the like.
  11
  12
  13 # The Haiku (base) version. For development builds the revision will be
  14 # attached.
  15 HAIKU_VERSION = r1~alpha4_pm ;
  16
  17
  18 #pragma mark - container settings
  19
  20 # Haiku image
  21 HAIKU_IMAGE_CONTAINER_NAME = haiku-image-container ;
  22 HAIKU_CONTAINER_GRIST on $(HAIKU_IMAGE_CONTAINER_NAME) = HaikuImage ;
  23 HAIKU_INCLUDE_IN_CONTAINER_VAR on $(HAIKU_IMAGE_CONTAINER_NAME)
  24         = HAIKU_INCLUDE_IN_IMAGE ;
  25 HAIKU_INSTALL_TARGETS_VAR on $(HAIKU_IMAGE_CONTAINER_NAME)
  26         = HAIKU_IMAGE_INSTALL_TARGETS ;
  27 HAIKU_CONTAINER_SYSTEM_DIR_TOKENS on $(HAIKU_IMAGE_CONTAINER_NAME)
  28         = system non-packaged ;
  29
  30 # network boot archive
  31 HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME = haiku-netboot-archive-container ;
  32 HAIKU_CONTAINER_GRIST on $(HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME)
  33         = NetBootArchive ;
  34 # HAIKU_INCLUDE_IN_CONTAINER_VAR -- update only mode not supported
  35 HAIKU_INSTALL_TARGETS_VAR on $(HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME)
  36         = HAIKU_NET_BOOT_ARCHIVE_INSTALL_TARGETS ;
  37 HAIKU_CONTAINER_SYSTEM_DIR_TOKENS on $(HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME)
  38         = system ;
  39
  40 # boot floppy
  41 HAIKU_FLOPPY_BOOT_IMAGE_CONTAINER_NAME = haiku-boot-floppy-container ;
  42 HAIKU_CONTAINER_GRIST on $(HAIKU_FLOPPY_BOOT_IMAGE_CONTAINER_NAME)
  43         = FloppyBootImage ;
  44 # HAIKU_INCLUDE_IN_CONTAINER_VAR -- update only mode not supported
  45 HAIKU_INSTALL_TARGETS_VAR on $(HAIKU_FLOPPY_BOOT_IMAGE_CONTAINER_NAME)
  46         = HAIKU_FLOPPY_BOOT_IMAGE_INSTALL_TARGETS ;
  47 HAIKU_CONTAINER_SYSTEM_DIR_TOKENS on $(HAIKU_FLOPPY_BOOT_IMAGE_CONTAINER_NAME)
  48         = system ;
  49
  50 # boot CD image
  51 HAIKU_CD_BOOT_IMAGE_CONTAINER_NAME = haiku-boot-cd-container ;
  52 HAIKU_CONTAINER_GRIST on $(HAIKU_CD_BOOT_IMAGE_CONTAINER_NAME) = CDBootImage ;
  53 # HAIKU_INCLUDE_IN_CONTAINER_VAR -- update only mode not supported
  54 HAIKU_INSTALL_TARGETS_VAR on $(HAIKU_CD_BOOT_IMAGE_CONTAINER_NAME)
  55         = HAIKU_CD_BOOT_IMAGE_INSTALL_TARGETS ;
  56 HAIKU_CONTAINER_SYSTEM_DIR_TOKENS on $(HAIKU_CD_BOOT_IMAGE_CONTAINER_NAME)
  57         = system ;
  58
  59 # boot CD for PPC image
  60 HAIKU_CD_BOOT_PPC_IMAGE_CONTAINER_NAME = haiku-boot-cd-ppc-container ;
  61 HAIKU_CONTAINER_GRIST on $(HAIKU_CD_BOOT_PPC_IMAGE_CONTAINER_NAME)
  62         = CDBootPPCImage ;
  63 # HAIKU_INCLUDE_IN_CONTAINER_VAR -- update only mode not supported
  64 HAIKU_INSTALL_TARGETS_VAR on $(HAIKU_CD_BOOT_PPC_IMAGE_CONTAINER_NAME)
  65         = HAIKU_CD_BOOT_PPC_IMAGE_INSTALL_TARGETS ;
  66 HAIKU_CONTAINER_SYSTEM_DIR_TOKENS on $(HAIKU_CD_BOOT_PPC_IMAGE_CONTAINER_NAME)
  67         = system ;
  68
  69 # Haiku image/install defaults
  70 HAIKU_DEFAULT_IMAGE_NAME = haiku.image ;
  71 HAIKU_DEFAULT_IMAGE_DIR = $(HAIKU_OUTPUT_DIR) ;
  72 HAIKU_DEFAULT_VMWARE_IMAGE_NAME = haiku.vmdk ;
  73 HAIKU_DEFAULT_INSTALL_DIR = /Haiku ;
  74 HAIKU_DEFAULT_IMAGE_SIZE ?= 300 ; # 300 MB
  75 HAIKU_DEFAULT_IMAGE_LABEL ?= Haiku ;
  76
  77 # Haiku CD defaults
  78 HAIKU_DEFAULT_CD_NAME = haiku-cd.iso ;
  79 HAIKU_DEFAULT_CD_DIR = $(HAIKU_OUTPUT_DIR) ;
  80 HAIKU_DEFAULT_CD_LABEL = Haiku ;
  81
  82 # Haiku Anyboot defaults
  83 HAIKU_DEFAULT_ANYBOOT_NAME = haiku-anyboot.iso ;
  84 HAIKU_DEFAULT_ANYBOOT_DIR = $(HAIKU_OUTPUT_DIR) ;
  85 HAIKU_DEFAULT_ANYBOOT_LABEL ?= Haiku ;
  86
  87 # Haiku MMC defaults
  88 HAIKU_DEFAULT_MMC_IMAGE_NAME = haiku-mmc.image ;
  89 HAIKU_DEFAULT_MMC_DIR = $(HAIKU_OUTPUT_DIR) ;
  90 HAIKU_DEFAULT_MMC_LABEL ?= Haiku ;
  91
  92 # analyze and optionally replace jam's target parameters
  93 ProcessCommandLineArguments ;
  94
  95
  96 # supported debug levels
  97 HAIKU_DEBUG_LEVELS = 0 1 2 3 4 5 ;
  98
  99 # BeOS, BONE, Dan0 compatible platforms
 100 HAIKU_BEOS_COMPATIBLE_PLATFORMS = haiku r5 bone dano haiku_host ;
 101 HAIKU_BONE_COMPATIBLE_PLATFORMS = haiku bone dano haiku_host ;
 102 HAIKU_DANO_COMPATIBLE_PLATFORMS = haiku dano haiku_host ;
 103 HAIKU_HAIKU_COMPATIBLE_PLATFORMS = haiku haiku_host ;
 104
 105 # configuration header directories
 106 HAIKU_CONFIG_HEADERS = [ FDirName $(HAIKU_TOP) build user_config_headers ]
 107         [ FDirName $(HAIKU_TOP) build config_headers ] ;
 108
 109
 110 # object directories common to all architectures
 111 HAIKU_OBJECT_BASE_DIR = [ FDirName $(HAIKU_OBJECT_DIR) haiku ] ;
 112 HAIKU_COMMON_ARCH_OBJECT_DIR = [ FDirName $(HAIKU_OBJECT_BASE_DIR) common ] ;
 113
 114
 115 #pragma mark - haiku target platform settings
 116
 117
 118 local architecture ;
 119 for architecture in $(HAIKU_PACKAGING_ARCHS) {
 120         ArchitectureSetup $(architecture) ;
 121 }
 122
 123 # TODO: Might not be needed anymore.
 124 if $(HAIKU_HOST_BUILD_ONLY) = 1 {
 125         HAIKU_GCC_VERSION = 0 0 0 ;
 126 }
 127
 128 if $(HAIKU_PACKAGING_ARCH) {
 129         KernelArchitectureSetup $(HAIKU_PACKAGING_ARCH) ;
 130 }
 131
 132 # define primary packaging architecture macro
 133 HAIKU_DEFINES = __HAIKU_PRIMARY_PACKAGING_ARCH=\\\"$(HAIKU_PACKAGING_ARCH)\\\" ;
 134
 135
 136 # distro compatibility level defines
 137 HAIKU_DISTRO_COMPATIBILITY ?= "default" ;
 138 switch $(HAIKU_DISTRO_COMPATIBILITY) {
 139         case official :
 140                 HAIKU_DEFINES += HAIKU_DISTRO_COMPATIBILITY_OFFICIAL ;
 141                 HAIKU_INCLUDE_TRADEMARKS = "" ;
 142         case compatible :
 143                 HAIKU_DEFINES += HAIKU_DISTRO_COMPATIBILITY_COMPATIBLE ;
 144                 HAIKU_INCLUDE_TRADEMARKS = "" ;
 145         case "default" :
 146                 HAIKU_DEFINES += HAIKU_DISTRO_COMPATIBILITY_DEFAULT ;
 147                 HAIKU_INCLUDE_TRADEMARKS = ;
 148         case * :
 149                 Exit "Invalid value for HAIKU_DISTRO_COMPATIBILITY:"
 150                         $(HAIKU_DISTRO_COMPATIBILITY) ;
 151 }
 152
 153 # If the environment variable HAIKU_INCLUDE_PATENTED_CODE is defined, we define
 154 # an equally named macro to the variable value. Some components use the macro
 155 # to allow compilation of code known to implemented patented ideas and/or
 156 # techniques, for example the Freetype bytecode hinter or sub-pixel rendering as
 157 # well as some problematic media codecs.
 158 if $(HAIKU_INCLUDE_PATENTED_CODE) {
 159         HAIKU_DEFINES
 160                 += HAIKU_INCLUDE_PATENTED_CODE=$(HAIKU_INCLUDE_PATENTED_CODE) ;
 161 }
 162
 163 # network libraries
 164 HAIKU_NETWORK_LIBS = network ;
 165 HAIKU_NETAPI_LIB = bnetapi ;
 166 HAIKU_SELECT_UNAME_ETC_LIB = ;  # libroot, against which we link anyway
 167
 168 HAIKU_EXECUTABLE_MIME_TYPE = "application/x-vnd.Be-elfexecutable" ;
 169
 170 # TODO: The version stuff should probably go into a separate file and be made
 171 # available as macro, too.
 172 # Set our version number if not already set and mark it as a developer build
 173 if ! $(HAIKU_BUILD_VERSION) {
 174         HAIKU_BUILD_VERSION ?= "1 0 0 a 1" ;
 175         HAIKU_BUILD_DESCRIPTION ?= "Developer Build" ;
 176 }
 177
 178 # If HAIKU_BUILD_VERSION is set, but HAIKU_BUILD_DESCRIPTION isn't, mark it as
 179 # an unknown build.
 180 HAIKU_BUILD_DESCRIPTION ?= "Unknown Build" ;
 181
 182
 183 #pragma mark - host platform settings
 184
 185
 186 # determine the endianness of the host
 187 switch $(HOST_GCC_MACHINE) {
 188         case amd64-*    : HAIKU_HOST_IS_BIG_ENDIAN = 0 ;
 189         case i?86-*             : HAIKU_HOST_IS_BIG_ENDIAN = 0 ;
 190         case powerpc-*  : HAIKU_HOST_IS_BIG_ENDIAN = 1 ;
 191         case x86_64-*   : HAIKU_HOST_IS_BIG_ENDIAN = 0 ;
 192
 193         # the following are rather unlikely as hosts ...
 194         case arm-*              : HAIKU_HOST_IS_BIG_ENDIAN = 0 ;
 195         case armv7l-*   : HAIKU_HOST_IS_BIG_ENDIAN = 0 ;
 196         case armv7hl-*  : HAIKU_HOST_IS_BIG_ENDIAN = 0 ;
 197         case armv7b-*   : HAIKU_HOST_IS_BIG_ENDIAN = 1 ;
 198         case aarch64-*  : HAIKU_HOST_IS_BIG_ENDIAN = 0 ;
 199         case m68k-*             : HAIKU_HOST_IS_BIG_ENDIAN = 1 ;
 200         case *                  : Exit "Unsupported gcc host machine:" $(HOST_GCC_MACHINE) ;
 201 }
 202
 203 # analyze the host gcc machine spec to find out about 64-bitness
 204 HOST_PLATFORM_IS_64_BIT = ;
 205 switch $(HOST_GCC_MACHINE) {
 206         case amd64-* :                          HOST_PLATFORM_IS_64_BIT = 1 ;
 207         case i686-apple-darwin10 :      HOST_PLATFORM_IS_64_BIT = 1 ;
 208         case i686-apple-darwin11 :      HOST_PLATFORM_IS_64_BIT = 1 ;
 209         case x86_64-* :                         HOST_PLATFORM_IS_64_BIT = 1 ;
 210         case aarch64-* :                        HOST_PLATFORM_IS_64_BIT = 1 ;
 211 }
 212
 213 # If HAIKU_HOST_USE_32BIT is set, add the required gcc base flag (the LD flag
 214 # is set later), or, if the architecture isn't actually 64 bit, clear
 215 # HAIKU_HOST_USE_32BIT.
 216 # Afterwards HOST_PLATFORM_IS_64_BIT will indicate whether the architecture is
 217 # effectively (i.e. when using the compiler/linker flags) 64 bit and
 218 # HAIKU_HOST_USE_32BIT will be set, iff the architecture is really 64 bit and
 219 # 32 bit mode was requested.
 220 if $(HAIKU_HOST_USE_32BIT) = 1 {
 221         if $(HOST_PLATFORM_IS_64_BIT) {
 222                 # enable GCC -m32 option
 223                 HOST_GCC_BASE_FLAGS = -m32 ;
 224                 HOST_PLATFORM_IS_64_BIT = ;
 225         } else {
 226                 HAIKU_HOST_USE_32BIT = 0 ;
 227         }
 228 }
 229
 230
 231 # save jam's variables for the build platform
 232 HOST_AR                         ?= $(AR) ;
 233 HOST_CC                         ?= $(CC) ;
 234 HOST_C++                        ?= $(C++) ;
 235 HOST_LINK                       ?= $(LINK) ;
 236 HOST_RANLIB                     ?= $(RANLIB) ;
 237 HOST_CPPFLAGS           ?= $(CPPFLAGS) ;
 238 HOST_CCFLAGS            ?= $(HOST_GCC_BASE_FLAGS) $(CCFLAGS) ;
 239 HOST_C++FLAGS           ?= $(HOST_GCC_BASE_FLAGS) $(C++FLAGS) ;
 240 HOST_LDFLAGS            ?= $(LDFLAGS) ;
 241 HOST_LINKFLAGS          ?= $(HOST_GCC_BASE_FLAGS) $(LINKFLAGS) ;
 242 HOST_DEFINES            ?= $(DEFINES) ;
 243 HOST_HDRS                       ?= $(HDRS) ;
 244
 245
 246 # split up HOST_AR into the command name and flags
 247 HOST_AR                         = [ Match "([^ ]*) *(.*)" : $(HOST_AR[1]) ]
 248                                           $(HOST_AR[2-]) ;
 249 HOST_ARFLAGS            = $(HOST_AR[2-]) ;
 250 HOST_AR                         = $(HOST_AR[1]) ;
 251 HOST_UNARFLAGS          ?= x ;
 252
 253 # check the host platform compatibility
 254 SetPlatformCompatibilityFlagVariables HOST_PLATFORM : HOST : host
 255         : linux openbsd freebsd darwin sunos cygwin ;
 256 HOST_PLATFORM_(host)_COMPATIBLE = 1 ;
 257
 258 if $(HOST_PLATFORM) = linux || $(HOST_PLATFORM) = freebsd
 259         || $(HOST_PLATFORM) = darwin || $(HOST_PLATFORM) = cygwin
 260         || $(HOST_PLATFORM) = sunos || $(HOST_PLATFORM) = openbsd {
 261         # don't use lex: otherwise rc will not work correctly
 262         if $(LEX) = lex {
 263                 LEX = flex ;
 264         }
 265 }
 266
 267 if $(HOST_PLATFORM) = cygwin {
 268         HOST_LINKFLAGS += -Xlinker --allow-multiple-definition -Xlinker
 269                 --enable-auto-import ;
 270 }
 271
 272 HOST_CPU ?= $(OSPLAT:L) ;
 273
 274 # Jam doesn't know x86_64, so override HOST_CPU, if 64 bit.
 275 if $(HOST_CPU) = x86 && $(HOST_PLATFORM_IS_64_BIT) {
 276         HOST_CPU = x86_64 ;
 277 }
 278
 279 HOST_ARCH ?= $(HOST_CPU) ;
 280 HOST_ARCHS = $(HOST_ARCH) ;
 281 HOST_KERNEL_ARCH = host ;
 282
 283 # analyze GCC version
 284 HOST_GCC_VERSION = [ FAnalyzeGCCVersion HOST_GCC_RAW_VERSION ] ;
 285
 286 # set packaging architecture
 287 HOST_PACKAGING_ARCH             ?= $(HOST_CPU) ;
 288 if $(HOST_PACKAGING_ARCH) = x86 && $(HOST_GCC_VERSION[1]) = 2 {
 289         HOST_PACKAGING_ARCH = x86_gcc2 ;
 290 }
 291 HOST_PACKAGING_ARCHS = $(HOST_PACKAGING_ARCH) ;
 292
 293 # directories
 294 HOST_OBJECT_BASE_DIR = [ FDirName $(HAIKU_OBJECT_DIR) $(HOST_PLATFORM) ] ;
 295 HOST_COMMON_ARCH_OBJECT_DIR = [ FDirName $(HOST_OBJECT_BASE_DIR) common ] ;
 296 HOST_ARCH_OBJECT_DIR
 297         = [ FDirName $(HOST_OBJECT_BASE_DIR) $(HOST_PACKAGING_ARCH) ] ;
 298 HOST_COMMON_DEBUG_OBJECT_DIR = [ FDirName $(HOST_ARCH_OBJECT_DIR) common ] ;
 299 HOST_DEBUG_0_OBJECT_DIR = [ FDirName $(HOST_ARCH_OBJECT_DIR) release ] ;
 300
 301 local level ;
 302 for level in $(HAIKU_DEBUG_LEVELS[2-]) {
 303         HOST_DEBUG_$(level)_OBJECT_DIR
 304                 = [ FDirName $(HOST_ARCH_OBJECT_DIR) debug_$(level) ] ;
 305 }
 306
 307 # set variables for gcc header options
 308 SetIncludePropertiesVariables HOST ;
 309
 310 # assembler flags
 311 HOST_ASFLAGS = ;
 312
 313 # C/C++ flags
 314 HOST_CCFLAGS += -Wno-multichar ;
 315 HOST_C++FLAGS += -Wno-multichar ;
 316
 317 if $(HOST_PLATFORM) != cygwin {
 318         HOST_PIC_CCFLAGS += -fPIC ;
 319         HOST_PIC_C++FLAGS += -fPIC ;
 320 }
 321
 322 if $(HOST_GCC_VERSION[1]) >= 3 {
 323         HOST_GCC_BASE_FLAGS += -fno-strict-aliasing -fno-tree-vrp ;
 324 }
 325
 326 HOST_KERNEL_CCFLAGS += $(HOST_GCC_BASE_FLAGS) -finline -fno-builtin
 327         -D_KERNEL_MODE ;
 328 HOST_KERNEL_C++FLAGS += $(HOST_GCC_BASE_FLAGS) -finline -fno-builtin
 329         -fno-exceptions -D_KERNEL_MODE ;
 330 HOST_KERNEL_DEFINES += _KERNEL_MODE ;
 331
 332 HOST_KERNEL_PIC_CCFLAGS = -fno-pic ;
 333 HOST_KERNEL_PIC_LINKFLAGS = ;
 334 if $(HOST_ARCH) = ppc {
 335         # Build a position independent PPC kernel. We need to be able to relocate
 336         # the kernel, since the virtual address space layout at boot time is not
 337         # fixed.
 338         HOST_KERNEL_PIC_CCFLAGS = -fPIE ;
 339         HOST_KERNEL_PIC_LINKFLAGS = -shared -fPIE ;
 340 }
 341 if $(HOST_ARCH) = m68k {
 342         # Build a position independent M68K kernel. We need to be able to relocate
 343         # the kernel, since the virtual address space layout at boot time is not
 344         # fixed.
 345         HOST_KERNEL_PIC_CCFLAGS = $(HAIKU_KERNEL_PIC_CCFLAGS) ;
 346         HOST_KERNEL_PIC_LINKFLAGS = $(HAIKU_KERNEL_PIC_LINKFLAGS) ;
 347 }
 348
 349 if $(HOST_PLATFORM) != darwin {
 350         # fix for new changes to DSO linking policies
 351         HOST_LINKFLAGS += -Xlinker --no-as-needed ;
 352 }
 353
 354
 355 # warning flags
 356 HOST_WARNING_CCFLAGS = -Wall -Wno-trigraphs -Wmissing-prototypes -Wpointer-arith
 357         -Wcast-align -Wsign-compare ;
 358 HOST_WARNING_C++FLAGS = -Wall -Wno-trigraphs -Wno-ctor-dtor-privacy
 359         -Woverloaded-virtual -Wpointer-arith -Wcast-align -Wsign-compare ;
 360
 361 HOST_KERNEL_WARNING_CCFLAGS = -Wall -Wno-trigraphs -Wmissing-prototypes ;
 362 HOST_KERNEL_WARNING_C++FLAGS = -Wall -Wno-trigraphs ;
 363
 364 HOST_WERROR_FLAGS = ;
 365
 366 # debug flags
 367 local hostDebugFlags ;
 368 switch $(HOST_PLATFORM) {
 369         case haiku              : hostDebugFlags ?= -ggdb ;
 370         case haiku_host : hostDebugFlags ?= -ggdb ;
 371         case linux              : hostDebugFlags ?= -ggdb ;
 372         case freebsd    : hostDebugFlags ?= -ggdb ;
 373         case darwin             : hostDebugFlags ?= -ggdb ;
 374         case *                  : hostDebugFlags ?= -g ;
 375 }
 376
 377 # debug 0: suppress asserts
 378 HOST_DEBUG_0_CCFLAGS = [ FDefines NDEBUG=$(NDEBUG) ] ;
 379 HOST_DEBUG_0_C++FLAGS = [ FDefines NDEBUG=$(NDEBUG) ] ;
 380
 381 HOST_KERNEL_DEBUG_0_CCFLAGS = [ FDefines NDEBUG=$(NDEBUG) ] ;
 382 HOST_KERNEL_DEBUG_0_C++FLAGS = [ FDefines NDEBUG=$(NDEBUG) ] ;
 383
 384 local level ;
 385 for level in $(HAIKU_DEBUG_LEVELS[2-]) {
 386         local flags = $(hostDebugFlags) [ FDefines DEBUG=$(level) ] ;
 387         HOST_DEBUG_$(level)_CCFLAGS                     = $(flags) ;
 388         HOST_DEBUG_$(level)_C++FLAGS            = $(flags) ;
 389         HOST_KERNEL_DEBUG_$(level)_CCFLAGS      = $(flags) ;
 390         HOST_KERNEL_DEBUG_$(level)_C++FLAGS     = $(flags) ;
 391 }
 392
 393 # ld flags
 394 if $(HAIKU_HOST_USE_32BIT) = 1 {
 395         HOST_LDFLAGS += -melf_i386 ;
 396 }
 397
 398 # private kernel headers do be used when compiling kernel code
 399 HOST_PRIVATE_KERNEL_HEADERS = ;
 400
 401 # private shared kernel/libroot headers
 402 HOST_PRIVATE_SYSTEM_HEADERS = ;
 403
 404 # under BeOS use copyattr instead of cp
 405 if $(HOST_PLATFORM_BEOS_COMPATIBLE)
 406 {
 407         CP = copyattr --data ;
 408 }
 409
 410 HOST_DEFINES += ARCH_$(HOST_CPU) ;
 411 HOST_DEFINES += _NO_INLINE_ASM ;
 412
 413 # for builds of tools in the current environment
 414 HOST_BUILD_COMPATIBILITY_LIB_DIR = [ FDirName $(HOST_OBJECT_BASE_DIR) lib ] ;
 415
 416 # For the generic attributes emulation: Target rm_attrs -- rm replacement that
 417 # also removes the attributes.
 418 HOST_RM_ATTRS_TARGET = ;
 419
 420 HOST_LIBROOT = libroot_build_function_remapper.a libroot_build.so ;
 421 HOST_STATIC_LIBROOT = libroot_build_function_remapper.a libroot_build.a ;
 422 HOST_LIBBE = libbe_build.so ;
 423
 424 if $(HOST_PLATFORM_BEOS_COMPATIBLE) {
 425         # the C++ standard and support libraries
 426         if $(HOST_GCC_VERSION[1]) < 3 {
 427                 HOST_LIBSTDC++ = stdc++.r4 ;
 428                 HOST_LIBSUPC++ = ;
 429         } else {
 430                 HOST_LIBSTDC++ = stdc++ ;
 431                 HOST_LIBSUPC++ = supc++ ;
 432         }
 433
 434         HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR
 435                 = "export LIBRARY_PATH=$LIBRARY_PATH:$(HOST_BUILD_COMPATIBILITY_LIB_DIR)" ;
 436         HOST_PTHREAD_LINKFLAGS = ;
 437         HOST_LIBRARY_NAME_MAP_input_server = /system/servers/input_server ;
 438         HOST_DEFINES += __STDC_FORMAT_MACROS __STDC_LIMIT_MACROS ;
 439
 440         local compatibilityHeader = -include [ FDirName $(HAIKU_TOP) headers build
 441                 HaikuBuildCompatibility.h ] ;
 442         HOST_CCFLAGS += $(compatibilityHeader) ;
 443         HOST_C++FLAGS += $(compatibilityHeader) ;
 444 } else {
 445         HOST_LINKFLAGS += -lm ;
 446         HOST_LIBSTDC++ = stdc++ ;
 447         if $(HOST_PLATFORM) = cygwin {
 448                 HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR
 449                         = "export PATH=$PATH:$(HOST_BUILD_COMPATIBILITY_LIB_DIR)" ;
 450         } else if $(HOST_PLATFORM) = darwin {
 451                 HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR
 452                         = "export DYLD_LIBRARY_PATH=$DYLD_LIBRARY_PATH:$(HOST_BUILD_COMPATIBILITY_LIB_DIR)" ;
 453         } else {
 454                 HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR
 455                         = "export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$(HOST_BUILD_COMPATIBILITY_LIB_DIR)" ;
 456         }
 457
 458         if $(HOST_PLATFORM) = cygwin {
 459                 # not needed
 460                 HOST_PTHREAD_LINKFLAGS = ;
 461         } else if $(HOST_PLATFORM) = freebsd {
 462                 HOST_PTHREAD_LINKFLAGS = -pthread ;
 463         } else {
 464                 HOST_PTHREAD_LINKFLAGS = -pthread ;
 465         }
 466
 467         # the C++ support library
 468         if $(HOST_GCC_VERSION[1]) < 3 {
 469                 HOST_LIBSUPC++ = ;
 470         } else {
 471                 HOST_LIBSUPC++ = supc++ ;
 472         }
 473
 474         if $(HOST_PLATFORM) = darwin {
 475                 # part of the C++ runtime lives in libstdc++ on Darwin
 476                 HOST_LIBSUPC++ = gcc_s.1 stdc++ ;
 477                 HOST_LIBSTDC++ = ;
 478         } else if $(HOST_PLATFORM) = freebsd {
 479                 if $(HOST_CPU) = x86_64 {
 480                         # amd64 FreeBSD 8 doesn't come without a shared libsupc++, and the
 481                         # static one prevents us from building shared libraries. So we have
 482                         # to work around by using the shared libstdc++.
 483                         HOST_LIBSUPC++ = stdc++ ;
 484                         HOST_LIBSTDC++ = ;
 485                 }
 486         }
 487
 488         # Unlike glibc FreeBSD's libc doesn't have built-in regex support.
 489         if $(HOST_PLATFORM) = freebsd {
 490                 HOST_LIBROOT += /usr/lib/libgnuregex.so ;
 491                 HOST_STATIC_LIBROOT += /usr/lib/libgnuregex.so ;
 492         } else if $(HOST_PLATFORM) = darwin {
 493                 HOST_LIBROOT += libgnuregex_build.so ;
 494                 HOST_STATIC_LIBROOT += libgnuregex_build.so ;
 495         }
 496
 497         # The BeOS compilers define __INTEL__ respectively __POWERPC__. On the
 498         # build platform we need to make sure, this is also defined.
 499         if $(HOST_CPU) = x86 {
 500                 HOST_DEFINES += __INTEL__ ;
 501         } else if $(HOST_CPU) = x86_64 {
 502                 HOST_DEFINES += __x86_64__ ;
 503         } else if $(HOST_CPU) = ppc {
 504                 HOST_DEFINES += __POWERPC__ ;
 505         } else if $(HOST_CPU) = m68k {
 506                 HOST_DEFINES += __M68K__ ;
 507         }
 508
 509         # Supposing this is a glibc platform, let's try to get features like large
 510         # file support, ISO C 99 definitions, etc. On some platforms we need to
 511         # request 64 bit off_t support explicitely.
 512         HOST_DEFINES += _GNU_SOURCE _FILE_OFFSET_BITS=64 __STDC_FORMAT_MACROS
 513                 __STDC_LIMIT_MACROS ;
 514
 515         # On Linux with xattr support we can use it for our attribute emulation,
 516         # which is somewhat more robust.
 517         if $(HAIKU_HOST_USE_XATTR) = 1 {
 518                 HOST_DEFINES += HAIKU_HOST_USE_XATTR ;
 519         } else {
 520                 # Otherwise the generic attribute emulation is used, which uses a
 521                 # directory per file to store its attribute. We need to redefine RM so
 522                 # that the attributes are removed as well. We use a wrapper script,
 523                 # which invokes a build tool. If the build tool hasn't been built yet,
 524                 # the normal "rm" is used and the attributes are leaked (likely there
 525                 # aren't any yet).
 526                 RM = $(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR) ";"
 527                         [ FDirName $(HAIKU_TOP) build scripts rm_attrs ]
 528                         [ FDirName $(HAIKU_OBJECT_DIR) $(HOST_PLATFORM) $(HOST_ARCH) release
 529                                 tools rm_attrs ] -f ;
 530                         # assumes that rm_attrs is built with debugging disabled
 531                 HOST_RM_ATTRS_TARGET = <build>rm_attrs ;
 532
 533                 # If specified, use xattr support to tag files with unique IDs.
 534                 if $(HAIKU_HOST_USE_XATTR_REF) = 1 {
 535                         HOST_DEFINES += HAIKU_HOST_USE_XATTR_REF ;
 536                 }
 537         }
 538 }
 539
 540 # network libraries
 541 if $(HOST_PLATFORM_HAIKU_COMPATIBLE) {
 542         HOST_NETWORK_LIBS = network ;
 543         HOST_NETAPI_LIB = bnetapi ;
 544         HOST_SELECT_UNAME_ETC_LIB = ;   # libroot
 545 } else if $(HOST_PLATFORM_BONE_COMPATIBLE) {
 546         HOST_NETWORK_LIBS = socket bind ;
 547         HOST_NETAPI_LIB = bnetapi ;
 548         HOST_SELECT_UNAME_ETC_LIB = ;   # libroot
 549 } else if $(HOST_PLATFORM_BEOS_COMPATIBLE) {
 550         HOST_NETWORK_LIBS = net ;
 551         HOST_NETAPI_LIB = netapi ;
 552         HOST_SELECT_UNAME_ETC_LIB = net ;
 553 } else if $(HOST_PLATFORM) = "sunos" {
 554         HOST_NETWORK_LIBS = xnet ;
 555         HOST_NETAPI_LIB = ;
 556         HOST_SELECT_UNAME_ETC_LIB = ;
 557 } else {
 558         # Linux,...
 559         HOST_NETWORK_LIBS = ;
 560         HOST_NETAPI_LIB = ;
 561         HOST_SELECT_UNAME_ETC_LIB = ;
 562 }
 563
 564 # define the executable MIME type
 565 HOST_EXECUTABLE_MIME_TYPE = "application/x-vnd.Be-elfexecutable" ;
 566
 567 if $(METROWERKS) {
 568         # at least parts of Haiku still can be compiled with
 569         # the Metrowerks compiler on BeOS/PPC
 570         HOST_EXECUTABLE_MIME_TYPE = "application/x-be-executable" ;
 571 }
 572
 573 # Be API compatibility
 574 HOST_BE_API_HEADERS = ;
 575 HOST_BE_API_CCFLAGS = ;
 576 HOST_BE_API_C++FLAGS = ;
 577
 578 # Add directory with system headers we need when building something for the host
 579 # platform, e.g. containing missing POSIX/GNU headers.
 580 HOST_HDRS += [ FDirName $(HAIKU_TOP) headers build host $(HOST_PLATFORM) ] ;
 581
 582 if $(HOST_PLATFORM) = freebsd {
 583         # FreeBSD's gcc doesn't include /usr/local/* in its search paths,
 584         # though that's where most things from ports wind up being installed.
 585         HOST_HDRS += /usr/local/include ;
 586         HOST_LINKFLAGS += -L/usr/local/lib ;
 587 }
 588
 589 if $(HOST_PLATFORM) = darwin {
 590         HOST_HDRS += [ FDirName $(HAIKU_TOP) src build libgnuregex ] ;
 591
 592         # Mac OS X users may be using macports libraries, in which case the headers
 593         # and the libs are located in /opt/local/.
 594         HOST_HDRS += /opt/local/include ;
 595         HOST_LINKFLAGS += -L/opt/local/lib ;
 596
 597         # Mac OS X users may be using homebrew libraries, in which case the headers
 598         # and the libs are locted in the /usr/local/.
 599         HOST_HDRS += /usr/local/include ;
 600         HOST_LINKFLAGS += -L/usr/local/lib ;
 601 }
 602
 603 HOST_BE_API_HEADERS =
 604         [ FDirName $(HAIKU_TOP) headers build ]
 605         [ FDirName $(HAIKU_TOP) headers build os ]
 606         [ FDirName $(HAIKU_TOP) headers build os add-ons registrar ]
 607         [ FDirName $(HAIKU_TOP) headers build os app ]
 608         [ FDirName $(HAIKU_TOP) headers build os bluetooth ]
 609         [ FDirName $(HAIKU_TOP) headers build os drivers ]
 610         [ FDirName $(HAIKU_TOP) headers build os kernel ]
 611         [ FDirName $(HAIKU_TOP) headers build os interface ]
 612         [ FDirName $(HAIKU_TOP) headers build os locale ]
 613         [ FDirName $(HAIKU_TOP) headers build os storage ]
 614         [ FDirName $(HAIKU_TOP) headers build os support ]
 615         [ FDirName $(HAIKU_TOP) headers build private ]
 616 ;
 617 if ! $(HOST_PLATFORM_BEOS_COMPATIBLE) {
 618         HOST_BE_API_CCFLAGS = -include BeOSBuildCompatibility.h ;
 619         HOST_BE_API_C++FLAGS = $(HOST_BE_API_CCFLAGS) ;
 620 }
 621
 622
 623 #pragma mark - target platform settings
 624
 625
 626 # check the target platform compatibility
 627 SetPlatformCompatibilityFlagVariables TARGET_PLATFORM : TARGET : target ;
 628
 629 # check the compatibility between host and target platform
 630 if $(TARGET_PLATFORM) != haiku {
 631         if ! $(HOST_PLATFORM_($(TARGET_PLATFORM))_COMPATIBLE) {
 632                 Exit ERROR: The host platform is not compatible with target platform
 633                         $(TARGET_PLATFORM). ;
 634         }
 635 }
 636
 637
 638 # Haiku architecture is undefined on host-only builds
 639 # set here to host arch to prevent recusive loops.
 640 if $(HAIKU_HOST_BUILD_ONLY) = 1 {
 641         HAIKU_ARCH = $(HOST_ARCH) ;
 642         HAIKU_KERNEL_ARCH = $(HOST_ARCH) ;
 643 }
 644
 645 # Set TARGET_* variables either from HAIKU_* or HOST_* depending on the
 646 # specified TARGET_PLATFORM. Some variables are package architecture dependent
 647 # and their name gets a respective suffix. A few variables exist both with and
 648 # without suffix. The latter is either equivalent to the variable with the
 649 # primary architecture suffix (e.g. TARGET_ARCH) or is (additionally) applicable
 650 # for all architectures (e.g. TARGET_DEFINES).
 651
 652 local buildVars =
 653         ARCH ARCHS KERNEL_ARCH PACKAGING_ARCH PACKAGING_ARCHS
 654
 655         DEFINES
 656         KERNEL_DEFINES
 657
 658         KERNEL_CCFLAGS KERNEL_C++FLAGS
 659         KERNEL_PIC_CCFLAGS KERNEL_PIC_LINKFLAGS KERNEL_ADDON_LINKFLAGS
 660         BOOT_CCFLAGS BOOT_C++FLAGS BOOT_LINKFLAGS BOOT_LDFLAGS
 661
 662         KERNEL_WARNING_CCFLAGS KERNEL_WARNING_C++FLAGS
 663
 664         KERNEL_DEBUG_$(HAIKU_DEBUG_LEVELS)_CCFLAGS
 665         KERNEL_DEBUG_$(HAIKU_DEBUG_LEVELS)_C++FLAGS
 666
 667         PRIVATE_KERNEL_HEADERS
 668
 669         NETWORK_LIBS NETAPI_LIB SELECT_UNAME_ETC_LIB
 670
 671         EXECUTABLE_MIME_TYPE
 672
 673         OBJECT_BASE_DIR COMMON_ARCH_OBJECT_DIR
 674         ;
 675
 676 local archDependentBuildVars =
 677         ARCH CPU GCC_VERSION
 678
 679         AR CC C++ ELFEDIT LD OBJCOPY RANLIB STRIP
 680
 681         ARFLAGS ASFLAGS UNARFLAGS CPPFLAGS CCFLAGS C++FLAGS HDRS LDFLAGS
 682         LINK LINKFLAGS
 683
 684         WARNING_CCFLAGS WARNING_C++FLAGS WERROR_FLAGS
 685
 686         DEBUG_$(HAIKU_DEBUG_LEVELS)_CCFLAGS DEBUG_$(HAIKU_DEBUG_LEVELS)_C++FLAGS
 687
 688         INCLUDES_SEPARATOR LOCAL_INCLUDES_OPTION SYSTEM_INCLUDES_OPTION
 689
 690         PRIVATE_SYSTEM_HEADERS
 691
 692         ARCH_OBJECT_DIR COMMON_DEBUG_OBJECT_DIR
 693         DEBUG_$(HAIKU_DEBUG_LEVELS)_OBJECT_DIR
 694         ;
 695
 696 if $(TARGET_PLATFORM) = haiku {
 697         local var ;
 698         for var in $(buildVars) {
 699                 TARGET_$(var) = $(HAIKU_$(var)) ;
 700         }
 701
 702         for var in $(archDependentBuildVars)_$(TARGET_PACKAGING_ARCHS) {
 703                 TARGET_$(var) = $(HAIKU_$(var)) ;
 704         }
 705
 706         TARGET_BOOT_LIBGCC              = $(HAIKU_BOOT_LIBGCC_$(TARGET_PACKAGING_ARCH)) ;
 707         TARGET_BOOT_LIBSUPC++   = $(HAIKU_BOOT_LIBSUPC++_$(TARGET_PACKAGING_ARCH)) ;
 708
 709         TARGET_BOOT_PLATFORM    ?= $(HAIKU_BOOT_PLATFORM) ;
 710
 711         local architecture ;
 712         for architecture in $(TARGET_PACKAGING_ARCHS) {
 713                 TARGET_DEFINES_$(architecture) = $(HAIKU_DEFINES_$(architecture)) ;
 714                 TARGET_LIBRARY_NAME_MAP_$(architecture)
 715                         = HAIKU_LIBRARY_NAME_MAP_$(architecture) ;
 716         }
 717 } else {
 718         local var ;
 719         for var in $(buildVars) {
 720                 TARGET_$(var) = $(HOST_$(var)) ;
 721         }
 722
 723         for var in $(archDependentBuildVars) {
 724                 TARGET_$(var)_$(TARGET_PACKAGING_ARCH) = $(HOST_$(var)) ;
 725         }
 726
 727         TARGET_BOOT_LIBGCC                      = ;
 728         TARGET_BOOT_LIBSUPC++           = ;
 729
 730         TARGET_BOOT_PLATFORM            = ;
 731
 732         TARGET_DEFINES_$(TARGET_PACKAGING_ARCH) = ;
 733                 # all flags are in TARGET_DEFINES
 734
 735         TARGET_LIBRARY_NAME_MAP_$(TARGET_PACKAGING_ARCH) = HOST_LIBRARY_NAME_MAP ;
 736 }
 737
 738 # define macro, for identifying the platform
 739 switch $(TARGET_PLATFORM) {
 740         case r5                 : TARGET_DEFINES        += HAIKU_TARGET_PLATFORM_BEOS ;
 741         case bone               : TARGET_DEFINES        += HAIKU_TARGET_PLATFORM_BONE ;
 742         case dano               : TARGET_DEFINES        += HAIKU_TARGET_PLATFORM_DANO ;
 743         case haiku_host : TARGET_DEFINES        += HAIKU_TARGET_PLATFORM_HAIKU ;
 744         case haiku              : TARGET_DEFINES        += HAIKU_TARGET_PLATFORM_HAIKU ;
 745         case linux              : TARGET_DEFINES        += HAIKU_TARGET_PLATFORM_LINUX ;
 746         case freebsd    : TARGET_DEFINES        += HAIKU_TARGET_PLATFORM_FREEBSD ;
 747         case darwin             : TARGET_DEFINES        += HAIKU_TARGET_PLATFORM_DARWIN ;
 748         case cygwin             : TARGET_DEFINES        += HAIKU_TARGET_PLATFORM_CYGWIN ;
 749         case sunos              : TARGET_DEFINES        += HAIKU_TARGET_PLATFORM_SUNOS ;
 750         case libbe_test : TARGET_DEFINES        += HAIKU_TARGET_PLATFORM_LIBBE_TEST ;
 751 }
 752
 753 # define macro, for identifying the host platform
 754 switch $(HOST_PLATFORM) {
 755         case r5                 : HOST_DEFINES  += HAIKU_HOST_PLATFORM_BEOS ;
 756         case bone               : HOST_DEFINES  += HAIKU_HOST_PLATFORM_BONE ;
 757         case dano               : HOST_DEFINES  += HAIKU_HOST_PLATFORM_DANO ;
 758         case haiku_host : HOST_DEFINES  += HAIKU_HOST_PLATFORM_HAIKU ;
 759         case linux              : HOST_DEFINES  += HAIKU_HOST_PLATFORM_LINUX ;
 760         case freebsd    : HOST_DEFINES  += HAIKU_HOST_PLATFORM_FREEBSD ;
 761         case darwin             : HOST_DEFINES  += HAIKU_HOST_PLATFORM_DARWIN ;
 762         case cygwin             : HOST_DEFINES  += HAIKU_HOST_PLATFORM_CYGWIN ;
 763         case sunos              : HOST_DEFINES  += HAIKU_HOST_PLATFORM_SUNOS ;
 764 }
 765
 766 # define host platform 64 bit macro
 767 if $(HOST_PLATFORM_IS_64_BIT) {
 768         HOST_DEFINES += HAIKU_HOST_PLATFORM_64_BIT ;
 769 }
 770
 771 # define Haiku packaging architecture macro for host build
 772 HOST_DEFINES += HAIKU_PACKAGING_ARCH=\\\"$(HAIKU_PACKAGING_ARCH)\\\" ;
 773
 774
 775 #pragma mark -
 776
 777 # In case we build for a BeOS compatible platform, but not for Haiku, we
 778 # include the HaikuBuildCompatibility.h header and link against
 779 # libhaikucompat.a.
 780
 781 if ! $(TARGET_PLATFORM_HAIKU_COMPATIBLE) && $(TARGET_PLATFORM_BEOS_COMPATIBLE) {
 782         # headers and flags
 783         local compatibilityHeader = -include [ FDirName $(HAIKU_TOP) headers build
 784                 HaikuBuildCompatibility.h ] ;
 785         TARGET_CCFLAGS_$(TARGET_PACKAGING_ARCH) += $(compatibilityHeader) ;
 786         TARGET_C++FLAGS_$(TARGET_PACKAGING_ARCH) += $(compatibilityHeader) ;
 787
 788         # compatibility library
 789         TARGET_HAIKU_COMPATIBILITY_LIBS = libhaikucompat.a ;
 790 }
 791
 792 # special target libbe_test
 793
 794 if $(TARGET_PLATFORM) = libbe_test {
 795         # headers and flags
 796         TARGET_HDRS_$(TARGET_PACKAGING_ARCH) +=
 797                 [ PublicHeaders $(DOT) app drivers game interface kernel locale storage
 798                         support ]
 799                 [ PrivateHeaders $(DOT) ] ;
 800         TARGET_DEFINES += __HAIKU__ ;
 801
 802         TARGET_PRIVATE_SYSTEM_HEADERS_$(TARGET_PACKAGING_ARCH) =
 803                 [ PrivateHeaders $(DOT) system system/arch/$(TARGET_ARCH) ] ;
 804
 805         # directories
 806         TARGET_OBJECT_BASE_DIR
 807                 = [ FDirName $(HAIKU_OBJECT_DIR) $(TARGET_PLATFORM) ] ;
 808         TARGET_COMMON_ARCH_OBJECT_DIR
 809                 = [ FDirName $(TARGET_OBJECT_BASE_DIR) common ] ;
 810         TARGET_ARCH_OBJECT_DIR_$(TARGET_PACKAGING_ARCH)
 811                 = [ FDirName $(TARGET_OBJECT_BASE_DIR) $(TARGET_ARCH) ] ;
 812         TARGET_COMMON_DEBUG_OBJECT_DIR_$(TARGET_PACKAGING_ARCH)
 813                 = [ FDirName $(TARGET_ARCH_OBJECT_DIR_$(TARGET_PACKAGING_ARCH))
 814                         common ] ;
 815         TARGET_DEBUG_0_OBJECT_DIR_$(TARGET_PACKAGING_ARCH)
 816                 = [ FDirName $(TARGET_ARCH_OBJECT_DIR_$(TARGET_PACKAGING_ARCH))
 817                         release ] ;
 818
 819         local level ;
 820         for level in $(HAIKU_DEBUG_LEVELS[2-]) {
 821                 TARGET_DEBUG_$(level)_OBJECT_DIR_$(TARGET_PACKAGING_ARCH)
 822                         = [ FDirName $(TARGET_ARCH_OBJECT_DIR_$(TARGET_PACKAGING_ARCH))
 823                                 debug_$(level) ] ;
 824         }
 825
 826         # library name map
 827         TARGET_LIBRARY_NAME_MAP_$(TARGET_PACKAGING_ARCH) = LIBBE_LIBRARY_NAME_MAP ;
 828         LIBBE_LIBRARY_NAME_MAP_be = libbe_test.so ;
 829 }
 830
 831
 832 #pragma mark - common stuff
 833
 834
 835 # start with a clean state
 836 CCFLAGS = ;
 837 C++FLAGS = ;
 838 DEFINES = ;
 839
 840 # Set CC, C++, LINK to invalid values, so that we realize early, that we use
 841 # the wrong compiler.
 842 CC = bad-cc ;
 843 C++ = bad-c++ ;
 844 LINK = bad-link ;
 845
 846
 847 # Defaults for warnings, optimization, and debugging.
 848 #
 849 WARNINGS ?= 1 ;
 850 OPTIM ?= -O2 ;
 851 DEBUG ?= 0 ;
 852
 853
 854 # Set a sane default for whether this is a CI build.
 855 HAIKU_CONTINUOUS_INTEGRATION_BUILD ?= 0 ;
 856
 857
 858 # Set the defaults for PLATFORM and SUPPORTED_PLATFORMS. PLATFORM is only
 859 # overridden for targets to be built for the host platform. SUPPORTED_PLATFORMS
 860 # can be overridden by the author of a component.
 861 PLATFORM = $(TARGET_PLATFORM) ;
 862 SUPPORTED_PLATFORMS = haiku ;
 863
 864
 865 # Define two pseudo targets for the target and buildhost platform. The main
 866 # build rules (Cc, C++, As, ...) depend on these pseude targets such that global
 867 # initializations that are required before anything is built for a specific
 868 # platform can be forced by depending the pseudo target for the platform on the
 869 # initializations.
 870 # This is currently used to unpack the external headers from the
 871 # gcc_syslibs_devel build feature before anything is built for the target
 872 # platform.
 873 NotFile $(TARGET_PLATFORM) ;
 874 NotFile host ;
 875
 876
 877 # Instructs the Library rule to not make its object files temporary.
 878 # This is needed as some objects are used in a static library and for an
 879 # executable.
 880 KEEPOBJS = true ;
 881
 882
 883 # Set permissions to how they should be on the image.
 884 EXEMODE         = 755 ;
 885 FILEMODE        = 644 ;
 886 SHELLMODE       = 755 ;
 887
 888
 889 # output directories
 890 # TODO: Review this.
 891 HAIKU_DOCUMENTATION_DIR ?= [ FDirName $(HAIKU_OUTPUT_DIR) documentation ] ;
 892 HAIKU_DOCUMENTATION_OBJECT_DIR ?= [ FDirName $(HAIKU_COMMON_PLATFORM_OBJECT_DIR)
 893         documentation ] ;
 894
 895 # TODO: Rethink test stuff.
 896 HAIKU_TEST_DIR                  ?= [ FDirName $(HAIKU_OUTPUT_DIR) tests
 897         $(TARGET_PLATFORM) $(HAIKU_ARCH) ] ;
 898 HAIKU_APP_TEST_DIR              ?= [ FDirName $(HAIKU_TEST_DIR) apps ] ;
 899 HAIKU_APP_TEST_LIB_DIR  ?= [ FDirName $(HAIKU_APP_TEST_DIR) lib ] ;
 900 HAIKU_TMP_DIR                   ?= [ FDirName $(HAIKU_OUTPUT_DIR) tmp ] ;
 901
 902 local architecture ;
 903 for architecture in $(HAIKU_PACKAGING_ARCHS) {
 904         local baseDir
 905                 = [ FDirName $(TARGET_OBJECT_BASE_DIR) $(architecture) packaging ] ;
 906         HAIKU_PACKAGES_DIR_$(architecture) = [ FDirName $(baseDir) packages ] ;
 907         HAIKU_PACKAGES_BUILD_DIR_$(architecture)
 908                 = [ FDirName $(baseDir) packages_build ] ;
 909         HAIKU_PACKAGE_REPOSITORIES_DIR_$(architecture)
 910                 = [ FDirName $(baseDir) repositories ] ;
 911 }
 912
 913
 914 HAIKU_PACKAGE_INFOS_DIR                 = [ FDirName $(HAIKU_TOP) src data
 915                                                                         package_infos ] ;
 916
 917 TARGET_TEST_DIR                         ?= [ FDirName $(HAIKU_TEST_DIR)
 918                                                                         $(TARGET_PLATFORM) ] ;
 919 TARGET_UNIT_TEST_DIR            ?= [ FDirName $(TARGET_TEST_DIR) unittests ] ;
 920 TARGET_UNIT_TEST_LIB_DIR        ?= [ FDirName $(TARGET_UNIT_TEST_DIR) lib ] ;
 921
 922 # automatically setup the objects directory per subdirectory
 923 SUBDIRRULES += SetupObjectsDir ;
 924
 925 # Add the standard (userland) warning flags variables to the ones restored in
 926 # every subdirectory. Thus we can easily meddle with them in subdirectories
 927 # with imported sources.
 928 AUTO_SET_UP_CONFIG_VARIABLES +=
 929         HOST_WARNING_CCFLAGS HOST_WARNING_C++FLAGS
 930         TARGET_WARNING_CCFLAGS_$(TARGET_PACKAGING_ARCHS)
 931         TARGET_WARNING_C++FLAGS_$(TARGET_PACKAGING_ARCHS)
 932         ;
 933
 934 # also add PLATFORM and SUPPORTED_PLATFORMS
 935 AUTO_SET_UP_CONFIG_VARIABLES += PLATFORM SUPPORTED_PLATFORMS ;
 936
 937
 938 # set up warnings
 939 local architecture ;
 940 for architecture in $(TARGET_PACKAGING_ARCHS) {
 941         ArchitectureSetupWarnings $(architecture) ;
 942 }
 943
 944
 945 # set up architecture build features
 946 local architecture ;
 947 for architecture in $(TARGET_PACKAGING_ARCHS) {
 948         InitArchitectureBuildFeatures $(architecture) ;
 949 }
 950
 951
 952 # The following directories cannot currently be compiled with DEBUG=1
 953 SetConfigVar DEBUG : HAIKU_TOP src add-ons disk_systems bfs : 0 : local ;
 954 SetConfigVar DEBUG : HAIKU_TOP src add-ons kernel drivers audio hda : 0 : local ;
 955 SetConfigVar DEBUG : HAIKU_TOP src add-ons kernel drivers audio ac97 auich : 0 : local ; # fails with gcc4 only
 956 SetConfigVar DEBUG : HAIKU_TOP src add-ons kernel drivers audio ac97 auvia : 0 : local ; # fails with gcc4 only
 957 SetConfigVar DEBUG : HAIKU_TOP src add-ons kernel drivers audio ac97 sis7018 : 0 : local ;
 958 SetConfigVar DEBUG : HAIKU_TOP src add-ons kernel file_systems btrfs : 0 : local ;
 959 SetConfigVar DEBUG : HAIKU_TOP src add-ons kernel file_systems ntfs libntfs : 0 : local ;
 960 SetConfigVar DEBUG : HAIKU_TOP src add-ons kernel file_systems udf : 0 : local ;
 961 SetConfigVar DEBUG : HAIKU_TOP src add-ons kernel file_systems userlandfs server : 0 : local ; # fails with gcc2 only
 962 SetConfigVar DEBUG : HAIKU_TOP src add-ons kernel file_systems userlandfs server haiku : 0 : local ; # fails with gcc2 only
 963 SetConfigVar DEBUG : HAIKU_TOP src add-ons media media-add-ons dvb : 0 : local ;
 964 SetConfigVar DEBUG : HAIKU_TOP src add-ons print drivers gutenprint : 0 : local ;
 965 SetConfigVar DEBUG : HAIKU_TOP src servers input : 0 : local ;
 966 SetConfigVar DEBUG : HAIKU_TOP src servers media_addon : 0 : local ;
 967 SetConfigVar DEBUG : HAIKU_TOP src system boot loader file_systems bfs : 0 : local ;