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         CP = copyattr --data ;
 407 }
 408
 409 HOST_DEFINES += ARCH_$(HOST_CPU) ;
 410 HOST_DEFINES += _NO_INLINE_ASM ;
 411
 412 # for builds of tools in the current environment
 413 HOST_BUILD_COMPATIBILITY_LIB_DIR = [ FDirName $(HOST_OBJECT_BASE_DIR) lib ] ;
 414
 415 # For the generic attributes emulation: Target rm_attrs -- rm replacement that
 416 # also removes the attributes.
 417 HOST_RM_ATTRS_TARGET = ;
 418
 419 HOST_LIBROOT = libroot_build_function_remapper.a libroot_build.so ;
 420 HOST_STATIC_LIBROOT = libroot_build_function_remapper.a libroot_build.a ;
 421 HOST_LIBBE = libbe_build.so ;
 422
 423 if $(HOST_PLATFORM_BEOS_COMPATIBLE) {
 424         # the C++ standard and support libraries
 425         if $(HOST_GCC_VERSION[1]) < 3 {
 426                 HOST_LIBSTDC++ = stdc++.r4 ;
 427                 HOST_LIBSUPC++ = ;
 428         } else {
 429                 HOST_LIBSTDC++ = stdc++ ;
 430                 HOST_LIBSUPC++ = supc++ ;
 431         }
 432
 433         HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR
 434                 = "export LIBRARY_PATH=$LIBRARY_PATH:$(HOST_BUILD_COMPATIBILITY_LIB_DIR)" ;
 435         HOST_PTHREAD_LINKFLAGS = ;
 436         HOST_LIBRARY_NAME_MAP_input_server = /system/servers/input_server ;
 437         HOST_DEFINES += __STDC_FORMAT_MACROS __STDC_LIMIT_MACROS ;
 438
 439         local compatibilityHeader = -include [ FDirName $(HAIKU_TOP) headers build
 440                 HaikuBuildCompatibility.h ] ;
 441         HOST_CCFLAGS += $(compatibilityHeader) ;
 442         HOST_C++FLAGS += $(compatibilityHeader) ;
 443 } else {
 444         HOST_LINKFLAGS += -lm ;
 445         HOST_LIBSTDC++ = stdc++ ;
 446         if $(HOST_PLATFORM) = cygwin {
 447                 HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR
 448                         = "export PATH=$PATH:$(HOST_BUILD_COMPATIBILITY_LIB_DIR)" ;
 449         } else if $(HOST_PLATFORM) = darwin {
 450                 HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR
 451                         = "export DYLD_LIBRARY_PATH=$DYLD_LIBRARY_PATH:$(HOST_BUILD_COMPATIBILITY_LIB_DIR)" ;
 452         } else {
 453                 HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR
 454                         = "export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$(HOST_BUILD_COMPATIBILITY_LIB_DIR)" ;
 455         }
 456
 457         if $(HOST_PLATFORM) = cygwin {
 458                 # not needed
 459                 HOST_PTHREAD_LINKFLAGS = ;
 460         } else if $(HOST_PLATFORM) = freebsd {
 461                 HOST_PTHREAD_LINKFLAGS = -pthread ;
 462         } else {
 463                 HOST_PTHREAD_LINKFLAGS = -pthread ;
 464         }
 465
 466         # the C++ support library
 467         if $(HOST_GCC_VERSION[1]) < 3 {
 468                 HOST_LIBSUPC++ = ;
 469         } else {
 470                 HOST_LIBSUPC++ = supc++ ;
 471         }
 472
 473         if $(HOST_PLATFORM) = darwin {
 474                 # part of the C++ runtime lives in libstdc++ on Darwin
 475                 HOST_LIBSUPC++ = gcc_s.1 stdc++ ;
 476                 HOST_LIBSTDC++ = ;
 477         } else if $(HOST_PLATFORM) = freebsd {
 478                 if $(HOST_CPU) = x86_64 {
 479                         # amd64 FreeBSD 8 doesn't come without a shared libsupc++, and the
 480                         # static one prevents us from building shared libraries. So we have
 481                         # to work around by using the shared libstdc++.
 482                         HOST_LIBSUPC++ = stdc++ ;
 483                         HOST_LIBSTDC++ = ;
 484                 }
 485         }
 486
 487         # The BeOS compilers define __INTEL__ respectively __POWERPC__. On the
 488         # build platform we need to make sure, this is also defined.
 489         if $(HOST_CPU) = x86 {
 490                 HOST_DEFINES += __INTEL__ ;
 491         } else if $(HOST_CPU) = x86_64 {
 492                 HOST_DEFINES += __x86_64__ ;
 493         } else if $(HOST_CPU) = ppc {
 494                 HOST_DEFINES += __POWERPC__ ;
 495         } else if $(HOST_CPU) = m68k {
 496                 HOST_DEFINES += __M68K__ ;
 497         }
 498
 499         # Supposing this is a glibc platform, let's try to get features like large
 500         # file support, ISO C 99 definitions, etc. On some platforms we need to
 501         # request 64 bit off_t support explicitely.
 502         HOST_DEFINES += _GNU_SOURCE _FILE_OFFSET_BITS=64 __STDC_FORMAT_MACROS
 503                 __STDC_LIMIT_MACROS ;
 504 }
 505
 506 if $(HAIKU_HOST_USE_XATTR) = 1 {
 507         HOST_DEFINES += HAIKU_HOST_USE_XATTR ;
 508 } else {
 509         # Otherwise the generic attribute emulation is used, which uses a
 510         # directory per file to store its attribute. We need to redefine RM so
 511         # that the attributes are removed as well. We use a wrapper script,
 512         # which invokes a build tool. If the build tool hasn't been built yet,
 513         # the normal "rm" is used and the attributes are leaked (likely there
 514         # aren't any yet).
 515         RM = $(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR) ";"
 516                 [ FDirName $(HAIKU_TOP) build scripts rm_attrs ]
 517                 [ FDirName $(HAIKU_OBJECT_DIR) $(HOST_PLATFORM) $(HOST_ARCH) release
 518                         tools rm_attrs ] -f ;
 519                 # assumes that rm_attrs is built with debugging disabled
 520         HOST_RM_ATTRS_TARGET = <build>rm_attrs ;
 521
 522         # If specified, use xattr support to tag files with unique IDs.
 523         if $(HAIKU_HOST_USE_XATTR_REF) = 1 {
 524                 HOST_DEFINES += HAIKU_HOST_USE_XATTR_REF ;
 525         }
 526 }
 527
 528 # network libraries
 529 if $(HOST_PLATFORM_HAIKU_COMPATIBLE) {
 530         HOST_NETWORK_LIBS = network ;
 531         HOST_NETAPI_LIB = bnetapi ;
 532         HOST_SELECT_UNAME_ETC_LIB = ;   # libroot
 533 } else if $(HOST_PLATFORM) = "sunos" {
 534         HOST_NETWORK_LIBS = xnet ;
 535         HOST_NETAPI_LIB = ;
 536         HOST_SELECT_UNAME_ETC_LIB = ;
 537 } else {
 538         # Linux,...
 539         HOST_NETWORK_LIBS = ;
 540         HOST_NETAPI_LIB = ;
 541         HOST_SELECT_UNAME_ETC_LIB = ;
 542 }
 543
 544 # define the executable MIME type
 545 HOST_EXECUTABLE_MIME_TYPE = "application/x-vnd.Be-elfexecutable" ;
 546
 547 if $(METROWERKS) {
 548         # at least parts of Haiku still can be compiled with
 549         # the Metrowerks compiler on BeOS/PPC
 550         HOST_EXECUTABLE_MIME_TYPE = "application/x-be-executable" ;
 551 }
 552
 553 # Be API compatibility
 554 HOST_BE_API_HEADERS = ;
 555 HOST_BE_API_CCFLAGS = ;
 556 HOST_BE_API_C++FLAGS = ;
 557
 558 # Add directory with system headers we need when building something for the host
 559 # platform, e.g. containing missing POSIX/GNU headers.
 560 HOST_HDRS += [ FDirName $(HAIKU_TOP) headers build host $(HOST_PLATFORM) ] ;
 561
 562 if $(HOST_PLATFORM) = freebsd {
 563         # FreeBSD's gcc doesn't include /usr/local/* in its search paths,
 564         # though that's where most things from ports wind up being installed.
 565         HOST_HDRS += /usr/local/include /usr/include/gnu ;
 566         HOST_LINKFLAGS += -L/usr/local/lib ;
 567 }
 568
 569 if $(HOST_PLATFORM) = darwin {
 570         # Mac OS X users may be using macports libraries, in which case the headers
 571         # and the libs are located in /opt/local/.
 572         HOST_HDRS += /opt/local/include ;
 573         HOST_LINKFLAGS += -L/opt/local/lib ;
 574
 575         # Mac OS X users may be using homebrew libraries, in which case the headers
 576         # and the libs are locted in the /usr/local/.
 577         HOST_HDRS += /usr/local/include ;
 578         HOST_LINKFLAGS += -L/usr/local/lib ;
 579 }
 580
 581 HOST_BE_API_HEADERS =
 582         [ FDirName $(HAIKU_TOP) headers build ]
 583         [ FDirName $(HAIKU_TOP) headers build os ]
 584         [ FDirName $(HAIKU_TOP) headers build os add-ons registrar ]
 585         [ FDirName $(HAIKU_TOP) headers build os app ]
 586         [ FDirName $(HAIKU_TOP) headers build os bluetooth ]
 587         [ FDirName $(HAIKU_TOP) headers build os drivers ]
 588         [ FDirName $(HAIKU_TOP) headers build os kernel ]
 589         [ FDirName $(HAIKU_TOP) headers build os interface ]
 590         [ FDirName $(HAIKU_TOP) headers build os locale ]
 591         [ FDirName $(HAIKU_TOP) headers build os storage ]
 592         [ FDirName $(HAIKU_TOP) headers build os support ]
 593         [ FDirName $(HAIKU_TOP) headers build private ]
 594 ;
 595 if ! $(HOST_PLATFORM_HAIKU_COMPATIBLE) {
 596         HOST_BE_API_CCFLAGS = -include BeOSBuildCompatibility.h ;
 597         HOST_BE_API_C++FLAGS = $(HOST_BE_API_CCFLAGS) ;
 598 }
 599
 600
 601 #pragma mark - target platform settings
 602
 603
 604 # check the target platform compatibility
 605 SetPlatformCompatibilityFlagVariables TARGET_PLATFORM : TARGET : target ;
 606
 607 # Haiku architecture is undefined on host-only builds
 608 # set here to host arch to prevent recusive loops.
 609 if $(HAIKU_HOST_BUILD_ONLY) = 1 {
 610         HAIKU_ARCH = $(HOST_ARCH) ;
 611         HAIKU_KERNEL_ARCH = $(HOST_ARCH) ;
 612 }
 613
 614 # Set TARGET_* variables either from HAIKU_* or HOST_* depending on the
 615 # specified TARGET_PLATFORM. Some variables are package architecture dependent
 616 # and their name gets a respective suffix. A few variables exist both with and
 617 # without suffix. The latter is either equivalent to the variable with the
 618 # primary architecture suffix (e.g. TARGET_ARCH) or is (additionally) applicable
 619 # for all architectures (e.g. TARGET_DEFINES).
 620
 621 local buildVars =
 622         ARCH ARCHS KERNEL_ARCH PACKAGING_ARCH PACKAGING_ARCHS
 623
 624         DEFINES
 625         KERNEL_DEFINES
 626
 627         KERNEL_CCFLAGS KERNEL_C++FLAGS
 628         KERNEL_PIC_CCFLAGS KERNEL_PIC_LINKFLAGS KERNEL_ADDON_LINKFLAGS
 629         BOOT_CCFLAGS BOOT_C++FLAGS BOOT_LINKFLAGS BOOT_LDFLAGS
 630
 631         KERNEL_WARNING_CCFLAGS KERNEL_WARNING_C++FLAGS
 632
 633         KERNEL_DEBUG_$(HAIKU_DEBUG_LEVELS)_CCFLAGS
 634         KERNEL_DEBUG_$(HAIKU_DEBUG_LEVELS)_C++FLAGS
 635
 636         PRIVATE_KERNEL_HEADERS
 637
 638         NETWORK_LIBS NETAPI_LIB SELECT_UNAME_ETC_LIB
 639
 640         EXECUTABLE_MIME_TYPE
 641
 642         OBJECT_BASE_DIR COMMON_ARCH_OBJECT_DIR
 643         ;
 644
 645 local archDependentBuildVars =
 646         ARCH CPU GCC_VERSION
 647
 648         AR CC C++ ELFEDIT LD OBJCOPY RANLIB STRIP
 649
 650         ARFLAGS ASFLAGS UNARFLAGS CPPFLAGS CCFLAGS C++FLAGS HDRS LDFLAGS
 651         LINK LINKFLAGS
 652
 653         WARNING_CCFLAGS WARNING_C++FLAGS WERROR_FLAGS
 654
 655         DEBUG_$(HAIKU_DEBUG_LEVELS)_CCFLAGS DEBUG_$(HAIKU_DEBUG_LEVELS)_C++FLAGS
 656
 657         INCLUDES_SEPARATOR LOCAL_INCLUDES_OPTION SYSTEM_INCLUDES_OPTION
 658
 659         PRIVATE_SYSTEM_HEADERS
 660
 661         ARCH_OBJECT_DIR COMMON_DEBUG_OBJECT_DIR
 662         DEBUG_$(HAIKU_DEBUG_LEVELS)_OBJECT_DIR
 663         ;
 664
 665 # target platform setup
 666 local var ;
 667 for var in $(buildVars) {
 668         TARGET_$(var) = $(HAIKU_$(var)) ;
 669 }
 670
 671 for var in $(archDependentBuildVars)_$(TARGET_PACKAGING_ARCHS) {
 672         TARGET_$(var) = $(HAIKU_$(var)) ;
 673 }
 674
 675 TARGET_BOOT_LIBGCC              = $(HAIKU_BOOT_LIBGCC_$(TARGET_PACKAGING_ARCH)) ;
 676 TARGET_BOOT_LIBSUPC++   = $(HAIKU_BOOT_LIBSUPC++_$(TARGET_PACKAGING_ARCH)) ;
 677
 678 TARGET_BOOT_PLATFORM    ?= $(HAIKU_BOOT_PLATFORM) ;
 679
 680 local architecture ;
 681 for architecture in $(TARGET_PACKAGING_ARCHS) {
 682         TARGET_DEFINES_$(architecture) = $(HAIKU_DEFINES_$(architecture)) ;
 683         TARGET_LIBRARY_NAME_MAP_$(architecture)
 684                 = HAIKU_LIBRARY_NAME_MAP_$(architecture) ;
 685 }
 686
 687 # define macro, for identifying the platform
 688 switch $(TARGET_PLATFORM) {
 689         case haiku              : TARGET_DEFINES        += HAIKU_TARGET_PLATFORM_HAIKU ;
 690         case libbe_test : TARGET_DEFINES        += HAIKU_TARGET_PLATFORM_LIBBE_TEST ;
 691 }
 692
 693 # define macro, for identifying the host platform
 694 switch $(HOST_PLATFORM) {
 695         case haiku_host : HOST_DEFINES  += HAIKU_HOST_PLATFORM_HAIKU ;
 696         case linux              : HOST_DEFINES  += HAIKU_HOST_PLATFORM_LINUX ;
 697         case freebsd    : HOST_DEFINES  += HAIKU_HOST_PLATFORM_FREEBSD ;
 698         case darwin             : HOST_DEFINES  += HAIKU_HOST_PLATFORM_DARWIN ;
 699         case cygwin             : HOST_DEFINES  += HAIKU_HOST_PLATFORM_CYGWIN ;
 700         case sunos              : HOST_DEFINES  += HAIKU_HOST_PLATFORM_SUNOS ;
 701 }
 702
 703 # define host platform 64 bit macro
 704 if $(HOST_PLATFORM_IS_64_BIT) {
 705         HOST_DEFINES += HAIKU_HOST_PLATFORM_64_BIT ;
 706 }
 707
 708 # define Haiku packaging architecture macro for host build
 709 HOST_DEFINES += HAIKU_PACKAGING_ARCH=\\\"$(HAIKU_PACKAGING_ARCH)\\\" ;
 710
 711
 712 #pragma mark -
 713
 714 # special target libbe_test
 715
 716 if $(TARGET_PLATFORM) = libbe_test {
 717         # headers and flags
 718         TARGET_HDRS_$(TARGET_PACKAGING_ARCH) +=
 719                 [ PublicHeaders $(DOT) app drivers game interface kernel locale storage
 720                         support ]
 721                 [ PrivateHeaders $(DOT) ] ;
 722         TARGET_DEFINES += __HAIKU__ ;
 723
 724         TARGET_PRIVATE_SYSTEM_HEADERS_$(TARGET_PACKAGING_ARCH) =
 725                 [ PrivateHeaders $(DOT) system system/arch/$(TARGET_ARCH) ] ;
 726
 727         # directories
 728         TARGET_OBJECT_BASE_DIR
 729                 = [ FDirName $(HAIKU_OBJECT_DIR) $(TARGET_PLATFORM) ] ;
 730         TARGET_COMMON_ARCH_OBJECT_DIR
 731                 = [ FDirName $(TARGET_OBJECT_BASE_DIR) common ] ;
 732         TARGET_ARCH_OBJECT_DIR_$(TARGET_PACKAGING_ARCH)
 733                 = [ FDirName $(TARGET_OBJECT_BASE_DIR) $(TARGET_ARCH) ] ;
 734         TARGET_COMMON_DEBUG_OBJECT_DIR_$(TARGET_PACKAGING_ARCH)
 735                 = [ FDirName $(TARGET_ARCH_OBJECT_DIR_$(TARGET_PACKAGING_ARCH))
 736                         common ] ;
 737         TARGET_DEBUG_0_OBJECT_DIR_$(TARGET_PACKAGING_ARCH)
 738                 = [ FDirName $(TARGET_ARCH_OBJECT_DIR_$(TARGET_PACKAGING_ARCH))
 739                         release ] ;
 740
 741         local level ;
 742         for level in $(HAIKU_DEBUG_LEVELS[2-]) {
 743                 TARGET_DEBUG_$(level)_OBJECT_DIR_$(TARGET_PACKAGING_ARCH)
 744                         = [ FDirName $(TARGET_ARCH_OBJECT_DIR_$(TARGET_PACKAGING_ARCH))
 745                                 debug_$(level) ] ;
 746         }
 747
 748         # library name map
 749         TARGET_LIBRARY_NAME_MAP_$(TARGET_PACKAGING_ARCH) = LIBBE_LIBRARY_NAME_MAP ;
 750         LIBBE_LIBRARY_NAME_MAP_be = libbe_test.so ;
 751 }
 752
 753
 754 #pragma mark - common stuff
 755
 756
 757 # start with a clean state
 758 CCFLAGS = ;
 759 C++FLAGS = ;
 760 DEFINES = ;
 761
 762 # Set CC, C++, LINK to invalid values, so that we realize early, that we use
 763 # the wrong compiler.
 764 CC = bad-cc ;
 765 C++ = bad-c++ ;
 766 LINK = bad-link ;
 767
 768
 769 # Defaults for warnings, optimization, and debugging.
 770 #
 771 WARNINGS ?= 1 ;
 772 OPTIM ?= -O2 ;
 773 DEBUG ?= 0 ;
 774
 775
 776 # Set a sane default for whether this is a CI build.
 777 HAIKU_CONTINUOUS_INTEGRATION_BUILD ?= 0 ;
 778
 779
 780 # Set the defaults for PLATFORM and SUPPORTED_PLATFORMS. PLATFORM is only
 781 # overridden for targets to be built for the host platform. SUPPORTED_PLATFORMS
 782 # can be overridden by the author of a component.
 783 PLATFORM = $(TARGET_PLATFORM) ;
 784 SUPPORTED_PLATFORMS = haiku ;
 785
 786
 787 # Define two pseudo targets for the target and buildhost platform. The main
 788 # build rules (Cc, C++, As, ...) depend on these pseude targets such that global
 789 # initializations that are required before anything is built for a specific
 790 # platform can be forced by depending the pseudo target for the platform on the
 791 # initializations.
 792 # This is currently used to unpack the external headers from the
 793 # gcc_syslibs_devel build feature before anything is built for the target
 794 # platform.
 795 NotFile $(TARGET_PLATFORM) ;
 796 NotFile host ;
 797
 798
 799 # Instructs the Library rule to not make its object files temporary.
 800 # This is needed as some objects are used in a static library and for an
 801 # executable.
 802 KEEPOBJS = true ;
 803
 804
 805 # Set permissions to how they should be on the image.
 806 EXEMODE         = 755 ;
 807 FILEMODE        = 644 ;
 808 SHELLMODE       = 755 ;
 809
 810
 811 # output directories
 812 # TODO: Review this.
 813 HAIKU_DOCUMENTATION_DIR ?= [ FDirName $(HAIKU_OUTPUT_DIR) documentation ] ;
 814 HAIKU_DOCUMENTATION_OBJECT_DIR ?= [ FDirName $(HAIKU_COMMON_PLATFORM_OBJECT_DIR)
 815         documentation ] ;
 816
 817 # TODO: Rethink test stuff.
 818 HAIKU_TEST_DIR                  ?= [ FDirName $(HAIKU_OUTPUT_DIR) tests
 819         $(TARGET_PLATFORM) $(HAIKU_ARCH) ] ;
 820 HAIKU_APP_TEST_DIR              ?= [ FDirName $(HAIKU_TEST_DIR) apps ] ;
 821 HAIKU_APP_TEST_LIB_DIR  ?= [ FDirName $(HAIKU_APP_TEST_DIR) lib ] ;
 822 HAIKU_TMP_DIR                   ?= [ FDirName $(HAIKU_OUTPUT_DIR) tmp ] ;
 823
 824 local architecture ;
 825 for architecture in $(HAIKU_PACKAGING_ARCHS) {
 826         local baseDir
 827                 = [ FDirName $(TARGET_OBJECT_BASE_DIR) $(architecture) packaging ] ;
 828         HAIKU_PACKAGES_DIR_$(architecture) = [ FDirName $(baseDir) packages ] ;
 829         HAIKU_PACKAGES_BUILD_DIR_$(architecture)
 830                 = [ FDirName $(baseDir) packages_build ] ;
 831         HAIKU_PACKAGE_REPOSITORIES_DIR_$(architecture)
 832                 = [ FDirName $(baseDir) repositories ] ;
 833 }
 834
 835
 836 HAIKU_PACKAGE_INFOS_DIR                 = [ FDirName $(HAIKU_TOP) src data
 837                                                                         package_infos ] ;
 838
 839 TARGET_TEST_DIR                         ?= [ FDirName $(HAIKU_TEST_DIR)
 840                                                                         $(TARGET_PLATFORM) ] ;
 841 TARGET_UNIT_TEST_DIR            ?= [ FDirName $(TARGET_TEST_DIR) unittests ] ;
 842 TARGET_UNIT_TEST_LIB_DIR        ?= [ FDirName $(TARGET_UNIT_TEST_DIR) lib ] ;
 843
 844 # automatically setup the objects directory per subdirectory
 845 SUBDIRRULES += SetupObjectsDir ;
 846
 847 # Add the standard (userland) warning flags variables to the ones restored in
 848 # every subdirectory. Thus we can easily meddle with them in subdirectories
 849 # with imported sources.
 850 AUTO_SET_UP_CONFIG_VARIABLES +=
 851         HOST_WARNING_CCFLAGS HOST_WARNING_C++FLAGS
 852         TARGET_WARNING_CCFLAGS_$(TARGET_PACKAGING_ARCHS)
 853         TARGET_WARNING_C++FLAGS_$(TARGET_PACKAGING_ARCHS)
 854         ;
 855
 856 # also add PLATFORM and SUPPORTED_PLATFORMS
 857 AUTO_SET_UP_CONFIG_VARIABLES += PLATFORM SUPPORTED_PLATFORMS ;
 858
 859
 860 # set up warnings
 861 local architecture ;
 862 for architecture in $(TARGET_PACKAGING_ARCHS) {
 863         ArchitectureSetupWarnings $(architecture) ;
 864 }
 865
 866
 867 # set up architecture build features
 868 local architecture ;
 869 for architecture in $(TARGET_PACKAGING_ARCHS) {
 870         InitArchitectureBuildFeatures $(architecture) ;
 871 }
 872
 873
 874 # The following directories cannot currently be compiled with DEBUG=1
 875 SetConfigVar DEBUG : HAIKU_TOP src add-ons disk_systems bfs : 0 : local ;
 876 SetConfigVar DEBUG : HAIKU_TOP src add-ons kernel drivers audio hda : 0 : local ;
 877 SetConfigVar DEBUG : HAIKU_TOP src add-ons kernel drivers audio ac97 auich : 0 : local ; # fails with gcc4 only
 878 SetConfigVar DEBUG : HAIKU_TOP src add-ons kernel drivers audio ac97 auvia : 0 : local ; # fails with gcc4 only
 879 SetConfigVar DEBUG : HAIKU_TOP src add-ons kernel drivers audio ac97 sis7018 : 0 : local ;
 880 SetConfigVar DEBUG : HAIKU_TOP src add-ons kernel file_systems btrfs : 0 : local ;
 881 SetConfigVar DEBUG : HAIKU_TOP src add-ons kernel file_systems ntfs libntfs : 0 : local ;
 882 SetConfigVar DEBUG : HAIKU_TOP src add-ons kernel file_systems udf : 0 : local ;
 883 SetConfigVar DEBUG : HAIKU_TOP src add-ons kernel file_systems userlandfs server : 0 : local ; # fails with gcc2 only
 884 SetConfigVar DEBUG : HAIKU_TOP src add-ons kernel file_systems userlandfs server haiku : 0 : local ; # fails with gcc2 only
 885 SetConfigVar DEBUG : HAIKU_TOP src add-ons media media-add-ons dvb : 0 : local ;
 886 SetConfigVar DEBUG : HAIKU_TOP src add-ons print drivers gutenprint : 0 : local ;
 887 SetConfigVar DEBUG : HAIKU_TOP src servers input : 0 : local ;
 888 SetConfigVar DEBUG : HAIKU_TOP src servers media_addon : 0 : local ;
 889 SetConfigVar DEBUG : HAIKU_TOP src system boot loader file_systems bfs : 0 : local ;