xref: /haiku/build/jam/BuildSetup (revision 4796acbc8c8fa3a5325a27722746b999009988d1)
1
2# Variable naming conventions:
3# TARGET_*:	A build system variable specifying a property for building for
4#			the target platform (usually Haiku). E.g. TARGET_CC specifies the
5#			compiler when building a target for the target platform.
6# HOST_*:	A build system variable specifying a property of the platform
7#			hosting the build. E.g. HOST_CC specifies the compiler when
8#			building a target for the host platform (a build tool for
9#			instance).
10# HAIKU_*:	A build system variable specifying a build system property. Usually
11#			directory paths and the like.
12
13
14#pragma mark - container settings
15
16# Haiku image
17HAIKU_IMAGE_CONTAINER_NAME = haiku-image-container ;
18HAIKU_CONTAINER_GRIST on $(HAIKU_IMAGE_CONTAINER_NAME) = HaikuImage ;
19HAIKU_INCLUDE_IN_CONTAINER_VAR on $(HAIKU_IMAGE_CONTAINER_NAME)
20	= HAIKU_INCLUDE_IN_IMAGE ;
21HAIKU_INSTALL_TARGETS_VAR on $(HAIKU_IMAGE_CONTAINER_NAME)
22	= HAIKU_IMAGE_INSTALL_TARGETS ;
23HAIKU_CONTAINER_SYSTEM_DIR_TOKENS on $(HAIKU_IMAGE_CONTAINER_NAME) = system ;
24
25# network boot archive
26HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME = haiku-netboot-archive-container ;
27HAIKU_CONTAINER_GRIST on $(HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME)
28	= NetBootArchive ;
29# HAIKU_INCLUDE_IN_CONTAINER_VAR -- update only mode not supported
30HAIKU_INSTALL_TARGETS_VAR on $(HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME)
31	= HAIKU_NET_BOOT_ARCHIVE_INSTALL_TARGETS ;
32HAIKU_CONTAINER_SYSTEM_DIR_TOKENS on $(HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME)
33	= system ;
34
35# boot floppy
36HAIKU_FLOPPY_BOOT_IMAGE_CONTAINER_NAME = haiku-boot-floppy-container ;
37HAIKU_CONTAINER_GRIST on $(HAIKU_FLOPPY_BOOT_IMAGE_CONTAINER_NAME)
38	= FloppyBootImage ;
39# HAIKU_INCLUDE_IN_CONTAINER_VAR -- update only mode not supported
40HAIKU_INSTALL_TARGETS_VAR on $(HAIKU_FLOPPY_BOOT_IMAGE_CONTAINER_NAME)
41	= HAIKU_FLOPPY_BOOT_IMAGE_INSTALL_TARGETS ;
42HAIKU_CONTAINER_SYSTEM_DIR_TOKENS on $(HAIKU_FLOPPY_BOOT_IMAGE_CONTAINER_NAME)
43	= system ;
44
45# boot CD image
46HAIKU_CD_BOOT_IMAGE_CONTAINER_NAME = haiku-boot-cd-container ;
47HAIKU_CONTAINER_GRIST on $(HAIKU_CD_BOOT_IMAGE_CONTAINER_NAME) = CDBootImage ;
48# HAIKU_INCLUDE_IN_CONTAINER_VAR -- update only mode not supported
49HAIKU_INSTALL_TARGETS_VAR on $(HAIKU_CD_BOOT_IMAGE_CONTAINER_NAME)
50	= HAIKU_CD_BOOT_IMAGE_INSTALL_TARGETS ;
51HAIKU_CONTAINER_SYSTEM_DIR_TOKENS on $(HAIKU_CD_BOOT_IMAGE_CONTAINER_NAME)
52	= system ;
53
54# boot CD for PPC image
55HAIKU_CD_BOOT_PPC_IMAGE_CONTAINER_NAME = haiku-boot-cd-ppc-container ;
56HAIKU_CONTAINER_GRIST on $(HAIKU_CD_BOOT_PPC_IMAGE_CONTAINER_NAME)
57	= CDBootPPCImage ;
58# HAIKU_INCLUDE_IN_CONTAINER_VAR -- update only mode not supported
59HAIKU_INSTALL_TARGETS_VAR on $(HAIKU_CD_BOOT_PPC_IMAGE_CONTAINER_NAME)
60	= HAIKU_CD_BOOT_PPC_IMAGE_INSTALL_TARGETS ;
61HAIKU_CONTAINER_SYSTEM_DIR_TOKENS on $(HAIKU_CD_BOOT_PPC_IMAGE_CONTAINER_NAME)
62	= system ;
63
64# Haiku image/install defaults
65HAIKU_DEFAULT_IMAGE_NAME = haiku.image ;
66HAIKU_DEFAULT_IMAGE_DIR = $(HAIKU_OUTPUT_DIR) ;
67HAIKU_DEFAULT_VMWARE_IMAGE_NAME = haiku.vmdk ;
68HAIKU_DEFAULT_INSTALL_DIR = /Haiku ;
69HAIKU_DEFAULT_IMAGE_SIZE ?= 230 ; # 230 MB
70HAIKU_DEFAULT_IMAGE_LABEL ?= Haiku ;
71
72# Haiku CD defaults
73HAIKU_DEFAULT_CD_NAME = haiku-cd.iso ;
74HAIKU_DEFAULT_CD_DIR = $(HAIKU_OUTPUT_DIR) ;
75HAIKU_DEFAULT_CD_LABEL = Haiku ;
76
77# Haiku Anyboot defaults
78HAIKU_DEFAULT_ANYBOOT_NAME = haiku-anyboot.image ;
79HAIKU_DEFAULT_ANYBOOT_DIR = $(HAIKU_OUTPUT_DIR) ;
80HAIKU_DEFAULT_ANYBOOT_LABEL ?= Haiku ;
81
82# analyze and optionally replace jam's target parameters
83ProcessCommandLineArguments ;
84
85
86# include libgccObjects
87{
88	local libgccObjects = [ GLOB $(HAIKU_BUILD_OUTPUT_DIR) : libgccObjects ] ;
89
90	if ! $(libgccObjects) {
91		ECHO "No `libgccObjects' found in"
92			"$(HAIKU_BUILD_OUTPUT_DIR)!" ;
93		EXIT "Please run ./configure in the source tree's root directory"
94			"again!" ;
95	}
96
97	LOCATE on libgccObjects = $(HAIKU_BUILD_OUTPUT_DIR) ;
98
99	include libgccObjects ;
100}
101
102
103# supported debug levels
104HAIKU_DEBUG_LEVELS = 0 1 2 3 4 5 ;
105
106# BeOS, BONE, Dan0 compatible platforms
107HAIKU_BEOS_COMPATIBLE_PLATFORMS = haiku r5 bone dano haiku_host ;
108HAIKU_BONE_COMPATIBLE_PLATFORMS = haiku bone dano haiku_host ;
109HAIKU_DANO_COMPATIBLE_PLATFORMS = haiku dano haiku_host ;
110HAIKU_HAIKU_COMPATIBLE_PLATFORMS = haiku haiku_host ;
111
112# configuration header directories
113HAIKU_CONFIG_HEADERS = [ FDirName $(HAIKU_TOP) build user_config_headers ]
114	[ FDirName $(HAIKU_TOP) build config_headers ] ;
115
116
117#pragma mark -
118
119# haiku target platform settings
120
121# analyze GCC version
122HAIKU_GCC_VERSION = [ FAnalyzeGCCVersion HAIKU_GCC_RAW_VERSION ] ;
123
124# enable GCC -pipe option, if requested
125if $(HAIKU_USE_GCC_PIPE) = 1 {
126	HAIKU_GCC_BASE_FLAGS = -pipe ;
127}
128
129# disable strict aliasing on anything newer than gcc 2 as it may lead to
130# unexpected results. also disable the tree-vrp (value range propagation)
131# optimization for now as with the current gcc4 version we are using this
132# results in some broken code.
133# TODO: remove the -fno-strict-aliasing option when all code has been
134#		analyzed/fixed with regard to aliasing.
135# TODO: retest/remove the -fno-tree-vrp option as soon as we have updated our
136#		gcc4 compiler.
137if $(HAIKU_GCC_VERSION[1]) >= 3 {
138	HAIKU_GCC_BASE_FLAGS += -fno-strict-aliasing -fno-tree-vrp ;
139}
140
141if $(HOST_GCC_VERSION[1]) >= 3 {
142	HOST_GCC_BASE_FLAGS += -fno-strict-aliasing -fno-tree-vrp ;
143}
144
145# override gcc 2.95.3's header directory -- strictly necessary only when using
146# the BeOS native compiler (since its headers are incompatible), but it doesn't
147# harm for the cross-compiler either.
148if $(HAIKU_GCC_VERSION[1]) = 2 {
149	HAIKU_GCC_HEADERS_DIR = [ FDirName $(HAIKU_TOP) headers build gcc-2.95.3 ] ;
150}
151
152# initial state for flags etc.
153HAIKU_C++ ?= $(HAIKU_CC) ;
154HAIKU_LINK = $(HAIKU_CC) ;
155HAIKU_LINKFLAGS = $(HAIKU_GCC_BASE_FLAGS) ;
156
157HAIKU_HDRS = [ FStandardHeaders ] ;
158HAIKU_CCFLAGS = $(HAIKU_GCC_BASE_FLAGS) -nostdinc ;
159HAIKU_C++FLAGS = $(HAIKU_GCC_BASE_FLAGS) -nostdinc ;
160HAIKU_KERNEL_CCFLAGS = $(HAIKU_GCC_BASE_FLAGS) ;
161HAIKU_KERNEL_C++FLAGS = $(HAIKU_GCC_BASE_FLAGS) ;
162HAIKU_DEFINES = __HAIKU__ ;
163HAIKU_NO_WERROR ?= 0 ;
164
165# distro compatibility level defines
166HAIKU_DISTRO_COMPATIBILITY ?= "default" ;
167switch $(HAIKU_DISTRO_COMPATIBILITY) {
168	case official	: {
169		HAIKU_DEFINES += HAIKU_DISTRO_COMPATIBILITY_OFFICIAL ;
170		HAIKU_INCLUDE_TRADEMARKS = "" ;
171	}
172	case compatible	: {
173		HAIKU_DEFINES += HAIKU_DISTRO_COMPATIBILITY_COMPATIBLE ;
174		HAIKU_INCLUDE_TRADEMARKS = "" ;
175	}
176	case "default"	: {
177		HAIKU_DEFINES += HAIKU_DISTRO_COMPATIBILITY_DEFAULT ;
178		HAIKU_INCLUDE_TRADEMARKS = ;
179	}
180	case *			: Exit "Invalid value for HAIKU_DISTRO_COMPATIBILITY:"
181						$(HAIKU_DISTRO_COMPATIBILITY) ;
182}
183
184# analyze the gcc machine spec to determine HAIKU_CPU
185switch $(HAIKU_GCC_MACHINE) {
186	case i?86-*		: HAIKU_CPU = x86 ;
187	case x86_64-*		: HAIKU_CPU = x86_64 ;
188	case powerpc-*	: HAIKU_CPU = ppc ;
189	case m68k-*		: HAIKU_CPU = m68k ;
190	case mipsel-*	: HAIKU_CPU = mipsel ;
191	case arm-*		: HAIKU_CPU = arm ;
192	case *			: Exit "Unsupported gcc target machine:"
193						$(HAIKU_GCC_MACHINE) ;
194}
195
196# determine the endianness of the host
197switch $(HOST_GCC_MACHINE) {
198	case amd64-*	: HAIKU_HOST_IS_BIG_ENDIAN = 0 ;
199	case i?86-*		: HAIKU_HOST_IS_BIG_ENDIAN = 0 ;
200	case powerpc-*	: HAIKU_HOST_IS_BIG_ENDIAN = 1 ;
201	case x86_64-*	: HAIKU_HOST_IS_BIG_ENDIAN = 0 ;
202
203	# the following are rather unlikely as hosts ...
204	case arm-*		: HAIKU_HOST_IS_BIG_ENDIAN = 0 ;
205	case m68k-*		: HAIKU_HOST_IS_BIG_ENDIAN = 1 ;
206	case mipsel-*	: HAIKU_HOST_IS_BIG_ENDIAN = 0 ;
207	case *			: Exit "Unsupported gcc host machine:" $(HOST_GCC_MACHINE) ;
208}
209
210switch $(HAIKU_CPU) {
211	case ppc :
212	{
213		HAIKU_DEFINES += __POWERPC__ ;
214		HAIKU_BOOT_PLATFORM = openfirmware ;
215		HAIKU_BOOT_FLOPPY_IMAGE_SIZE = 1440 ; # in kB
216		# offset in floppy image (>= sizeof(haiku_loader))
217		HAIKU_BOOT_ARCHIVE_IMAGE_OFFSET = 192 ; # in kB - unused yet
218	}
219	case arm :
220	{
221		HAIKU_DEFINES += __ARM__ ;
222		HAIKU_BOOT_PLATFORM = u-boot ;
223		HAIKU_BOOT_BOARD ?= verdex ;
224		HAIKU_BOOT_FLOPPY_IMAGE_SIZE = 1440 ;
225			# in kB (there is not really a floppy on the gumstix ;) )
226		# offset in floppy image (>= sizeof(haiku_loader))
227		HAIKU_BOOT_ARCHIVE_IMAGE_OFFSET = 192 ; # in kB - unused yet
228		HAIKU_NO_WERROR = 1 ;
229			# we use #warning as placeholders for things to write...
230	}
231	case x86 :
232	{
233		HAIKU_DEFINES += __INTEL__ ;
234		HAIKU_BOOT_PLATFORM = bios_ia32 ;
235		HAIKU_BOOT_FLOPPY_IMAGE_SIZE = 2880 ; # in kB
236		# offset in floppy image (>= sizeof(haiku_loader))
237		HAIKU_BOOT_ARCHIVE_IMAGE_OFFSET = 300 ; # in kB
238
239		# yasm is required for target arch x86
240		if ! $(HAIKU_YASM) {
241			Exit "HAIKU_YASM not set. Please re-run configure." ;
242		}
243	}
244	case x86_64 :
245	{
246		HAIKU_DEFINES += __x86_64__ ;
247		HAIKU_BOOT_PLATFORM = bios_ia32 ;
248		HAIKU_BOOT_FLOPPY_IMAGE_SIZE = 2880 ; # in kB
249		# offset in floppy image (>= sizeof(haiku_loader))
250		HAIKU_BOOT_ARCHIVE_IMAGE_OFFSET = 300 ; # in kB
251
252		# yasm is required for target arch x86_64
253		if ! $(HAIKU_YASM) {
254			Exit "HAIKU_YASM not set. Please re-run configure." ;
255		}
256	}
257	case m68k :
258	{
259		HAIKU_DEFINES += __M68K__ ;
260		HAIKU_BOOT_PLATFORM ?= atari_m68k ;
261		switch $(HAIKU_BOOT_PLATFORM) {
262			case atari_m68k :
263			{
264				HAIKU_BOOT_FLOPPY_IMAGE_SIZE = 1440 ; # in kB
265			}
266			case amiga_m68k :
267			{
268				# for now we have trouble reading from double-sided images
269				HAIKU_BOOT_FLOPPY_IMAGE_SIZE = 880 ; # in kB
270			}
271		}
272		# offset in floppy image (>= sizeof(haiku_loader))
273		HAIKU_BOOT_ARCHIVE_IMAGE_OFFSET = 300 ; # in kB
274		HAIKU_NO_WERROR = 1 ;
275			# we use #warning as placeholders for things to write...
276	}
277	case mipsel :
278	{
279		HAIKU_DEFINES += __MIPSEL__ ;
280		# RouterBOARD firmware (ELF image over TFTP)
281		HAIKU_BOOT_PLATFORM = routerboard_mipsel ;
282		# offset in floppy image (>= sizeof(haiku_loader))
283		HAIKU_BOOT_ARCHIVE_IMAGE_OFFSET = 192 ; # in kB
284		HAIKU_NO_WERROR = 1 ;
285			# we use #warning as placeholders for things to write...
286	}
287	case * :
288		Exit "Currently unsupported target CPU:" $(HAIKU_CPU) ;
289}
290HAIKU_ARCH ?= $(HAIKU_CPU) ;
291HAIKU_ARCH_MACRO_DEFINE = ARCH_$(HAIKU_ARCH) ;
292HAIKU_DEFINES += $(HAIKU_ARCH_MACRO_DEFINE) ;
293HAIKU_DEFINES += BOOT_ARCHIVE_IMAGE_OFFSET=$(HAIKU_BOOT_ARCHIVE_IMAGE_OFFSET) ;
294HAIKU_ATA_STACK ?= 1 ;
295
296# directories
297HAIKU_OBJECT_BASE_DIR = [ FDirName $(HAIKU_OBJECT_DIR) haiku ] ;
298HAIKU_COMMON_ARCH_OBJECT_DIR = [ FDirName $(HAIKU_OBJECT_BASE_DIR) common ] ;
299HAIKU_ARCH_OBJECT_DIR = [ FDirName $(HAIKU_OBJECT_BASE_DIR) $(HAIKU_ARCH) ] ;
300HAIKU_COMMON_DEBUG_OBJECT_DIR = [ FDirName $(HAIKU_ARCH_OBJECT_DIR) common ] ;
301HAIKU_DEBUG_0_OBJECT_DIR = [ FDirName $(HAIKU_ARCH_OBJECT_DIR) release ] ;
302
303local level ;
304for level in $(HAIKU_DEBUG_LEVELS[2-]) {
305	HAIKU_DEBUG_$(level)_OBJECT_DIR
306		= [ FDirName $(HAIKU_ARCH_OBJECT_DIR) debug_$(level) ] ;
307}
308
309# set variables for gcc header options
310SetIncludePropertiesVariables HAIKU ;
311
312# assembler flags
313HAIKU_ASFLAGS = ;
314
315# C/C++ flags
316HAIKU_KERNEL_CCFLAGS += -finline -fno-builtin ;
317HAIKU_KERNEL_C++FLAGS += -finline -fno-builtin -fno-exceptions ;
318HAIKU_KERNEL_DEFINES += _KERNEL_MODE ;
319
320if $(HAIKU_GCC_VERSION[1]) >= 3 {
321	HAIKU_KERNEL_C++FLAGS += -fno-use-cxa-atexit ;
322}
323
324if $(HAIKU_GCC_VERSION[1]) >= 4 {
325	HAIKU_C++FLAGS += -Wno-deprecated ;
326
327	if $(HAIKU_GCC_VERSION[2]) >= 3 {
328		HAIKU_KERNEL_CCFLAGS += -ffreestanding ;
329		HAIKU_KERNEL_C++FLAGS += -ffreestanding ;
330	}
331}
332
333HAIKU_KERNEL_PIC_CCFLAGS = -fno-pic ;
334HAIKU_KERNEL_PIC_LINKFLAGS = ;
335
336switch $(HAIKU_ARCH) {
337	case ppc :
338	{
339		# Build a position independent PPC kernel. We need to be able to
340		# relocate the kernel, since the virtual address space layout at boot
341		# time is not fixed.
342		HAIKU_KERNEL_PIC_CCFLAGS = -fPIE ;
343		HAIKU_KERNEL_PIC_LINKFLAGS = -shared -fPIE ;
344	}
345
346	case m68k :
347	{
348		# We don't want to have to handle emulating missing FPU opcodes for 040
349		# and 060 in the kernel.
350		HAIKU_KERNEL_CCFLAGS += -m68020-60 ;
351		HAIKU_KERNEL_C++FLAGS += -m68020-60 ;
352	}
353	case x86 :
354	{
355		HAIKU_CCFLAGS += -march=pentium ;
356		HAIKU_C++FLAGS += -march=pentium ;
357		HAIKU_KERNEL_CCFLAGS += -march=pentium ;
358		HAIKU_KERNEL_C++FLAGS += -march=pentium ;
359
360		# Enable use of the gcc built-in atomic functions instead of atomic_*().
361		# The former are inlined and have thus less overhead. They are not
362		# available with gcc 2, but the header will take care of that.
363		HAIKU_DEFINES += B_USE_BUILTIN_ATOMIC_FUNCTIONS ;
364	}
365	case x86_64 :
366	{
367		# Enable use of the gcc built-in atomic functions instead of atomic_*().
368		# The former are inlined and have thus less overhead.
369		HAIKU_DEFINES += B_USE_BUILTIN_ATOMIC_FUNCTIONS ;
370	}
371}
372
373# If the environment variable HAIKU_INCLUDE_PATENTED_CODE is defined, we
374# define an equally named macro to the variable value. Some components use the
375# macro to allow compilation of code known to implemented patented ideas and/or
376# techniques, for example the Freetype bytecode hinter or sub-pixel rendering
377# as well as some problematic media codecs.
378if $(HAIKU_INCLUDE_PATENTED_CODE) {
379	HAIKU_DEFINES
380		+= HAIKU_INCLUDE_PATENTED_CODE=$(HAIKU_INCLUDE_PATENTED_CODE) ;
381}
382
383# warning flags
384HAIKU_WARNING_CCFLAGS = -Wall -Wno-trigraphs -Wmissing-prototypes
385	-Wpointer-arith -Wcast-align -Wsign-compare -Wno-multichar ;
386HAIKU_WARNING_C++FLAGS = -Wall -Wno-trigraphs -Wno-ctor-dtor-privacy
387	-Woverloaded-virtual -Wpointer-arith -Wcast-align -Wsign-compare
388	-Wno-multichar ;
389
390HAIKU_KERNEL_WARNING_CCFLAGS = -Wall -Wno-trigraphs -Wmissing-prototypes
391	-Wno-multichar ;
392HAIKU_KERNEL_WARNING_C++FLAGS = -Wall -Wno-trigraphs -Wno-multichar ;
393
394# debug flags
395HAIKU_DEBUG_FLAGS ?= -ggdb ;
396
397# debug 0: suppress asserts
398HAIKU_DEBUG_0_CCFLAGS = [ FDefines NDEBUG=$(NDEBUG) ] ;
399HAIKU_DEBUG_0_C++FLAGS = [ FDefines NDEBUG=$(NDEBUG) ] ;
400
401HAIKU_KERNEL_DEBUG_0_CCFLAGS = [ FDefines NDEBUG=$(NDEBUG) ] ;
402HAIKU_KERNEL_DEBUG_0_C++FLAGS = [ FDefines NDEBUG=$(NDEBUG) ] ;
403
404local level ;
405for level in $(HAIKU_DEBUG_LEVELS[2-]) {
406	local flags = $(HAIKU_DEBUG_FLAGS) [ FDefines DEBUG=$(level) ] ;
407	HAIKU_DEBUG_$(level)_CCFLAGS			= $(flags) ;
408	HAIKU_DEBUG_$(level)_C++FLAGS			= $(flags) ;
409	HAIKU_KERNEL_DEBUG_$(level)_CCFLAGS		= $(flags) ;
410	HAIKU_KERNEL_DEBUG_$(level)_C++FLAGS	= $(flags) ;
411}
412
413if $(HAIKU_GCC_VERSION[1]) >= 3 {
414	# TODO: Temporary work-around. Should be defined in the compiler specs
415	HAIKU_LINKFLAGS += -Xlinker --no-undefined ;
416} else {
417	HAIKU_DEFINES += _BEOS_R5_COMPATIBLE_ ;
418}
419
420# private shared kernel/libroot headers
421HAIKU_PRIVATE_SYSTEM_HEADERS =
422	[ PrivateHeaders $(DOT) system system/arch/$(HAIKU_ARCH) ]
423;
424
425# private kernel headers to be used when compiling kernel code
426HAIKU_PRIVATE_KERNEL_HEADERS =
427	[ PrivateHeaders $(DOT) kernel libroot shared
428		kernel/boot/platform/$(HAIKU_BOOT_PLATFORM) ]
429	[ ArchHeaders $(HAIKU_ARCH) ]
430	[ FDirName $(HAIKU_COMMON_DEBUG_OBJECT_DIR) system kernel ]
431	$(HAIKU_PRIVATE_SYSTEM_HEADERS)
432;
433
434# Add some grist to the libgcc objects
435HAIKU_GCC_LIBGCC_OBJECTS = $(HAIKU_GCC_LIBGCC_OBJECTS:G=libgcc) ;
436
437# the C++ standard library
438HAIKU_BUILD_SHARED_LIBSTDC++ = ;
439if $(HAIKU_SHARED_LIBSTDC++) {
440	HAIKU_LIBSTDC++ = $(HAIKU_SHARED_LIBSTDC++) ;
441} else {
442	# no shared library available with the compiler -- build it
443	if $(HAIKU_GCC_VERSION[1]) = 2 {
444		HAIKU_LIBSTDC++ = libstdc++.r4.so ;
445	} else {
446		HAIKU_LIBSTDC++ = libstdc++.so ;
447	}
448	HAIKU_SHARED_LIBSTDC++ = $(HAIKU_LIBSTDC++) ;
449	HAIKU_BUILD_SHARED_LIBSTDC++ = 1 ;
450}
451
452# the C++ support (runtime) library
453HAIKU_BUILD_SHARED_LIBSUPC++ = ;
454if $(HAIKU_SHARED_LIBSUPC++) {
455	HAIKU_LIBSUPC++ = $(HAIKU_SHARED_LIBSUPC++) ;
456} else {
457	# no shared library available with the compiler -- build it for gcc 4
458	if $(HAIKU_GCC_VERSION[1]) != 2 {
459		HAIKU_SHARED_LIBSUPC++ = libsupc++.so ;
460		HAIKU_BUILD_SHARED_LIBSUPC++ = 1 ;
461	}
462
463	HAIKU_LIBSUPC++ = $(HAIKU_SHARED_LIBSUPC++) ;
464}
465
466
467# network libraries
468HAIKU_NETWORK_LIBS = network ;
469HAIKU_NETAPI_LIB = bnetapi ;
470HAIKU_SELECT_UNAME_ETC_LIB = ;	# libroot, against which we link anyway
471
472
473# locale libraries
474HAIKU_LOCALE_LIBS = liblocale.so liblocalestub.a ;
475
476
477# library and executable glue code
478local commonGlueCode =
479	<src!system!glue>init_term_dyn.o
480	<src!system!glue!arch!$(HAIKU_ARCH)>crti.o
481	<src!system!glue!arch!$(HAIKU_ARCH)>crtn.o
482;
483HAIKU_LIBRARY_BEGIN_GLUE_CODE =
484	<src!system!glue!arch!$(HAIKU_ARCH)>crti.o
485	crtbegin.o
486	<src!system!glue>init_term_dyn.o
487;
488HAIKU_LIBRARY_END_GLUE_CODE =
489	crtend.o
490	<src!system!glue!arch!$(HAIKU_ARCH)>crtn.o
491;
492HAIKU_EXECUTABLE_BEGIN_GLUE_CODE =
493	<src!system!glue!arch!$(HAIKU_ARCH)>crti.o
494	crtbegin.o
495	<src!system!glue>start_dyn.o
496	<src!system!glue>init_term_dyn.o
497;
498HAIKU_EXECUTABLE_END_GLUE_CODE = $(HAIKU_LIBRARY_END_GLUE_CODE) ;
499HAIKU_KERNEL_ADDON_BEGIN_GLUE_CODE = crtbegin.o
500	<src!system!glue>haiku_version_glue.o ;
501HAIKU_KERNEL_ADDON_END_GLUE_CODE = $(HAIKU_GCC_LIBGCC) crtend.o ;
502
503SEARCH on crtbegin.o crtend.o = $(HAIKU_GCC_LIB_DIR) ;
504
505HAIKU_EXECUTABLE_MIME_TYPE = "application/x-vnd.Be-elfexecutable" ;
506
507# TODO: The version stuff should probably go into a separate file and be made
508# available as macro, too.
509# Set our version number if not already set and mark it as a developer build
510if ! $(HAIKU_BUILD_VERSION) {
511	HAIKU_BUILD_VERSION ?= "1 0 0 a 1" ;
512	HAIKU_BUILD_DESCRIPTION ?= "Developer Build" ;
513}
514
515# If HAIKU_BUILD_VERSION is set, but HAIKU_BUILD_DESCRIPTION isn't, mark it as
516# an unknown build.
517HAIKU_BUILD_DESCRIPTION ?= "Unknown Build" ;
518
519# init library name map
520{
521	local i ;
522	for i in be bnetapi debug game GL locale mail media midi midi2 network
523			opengl package root screensaver textencoding tracker translation
524			z {
525		HAIKU_LIBRARY_NAME_MAP_$(i) = lib$(i).so ;
526	}
527	HAIKU_LIBRARY_NAME_MAP_libstdc++ = $(HAIKU_LIBSTDC++) ;
528	HAIKU_LIBRARY_NAME_MAP_libsupc++ = $(HAIKU_LIBSUPC++) ;
529	HAIKU_LIBRARY_NAME_MAP_input_server = <nogrist>input_server ;
530}
531
532
533#pragma mark -
534
535# host platform settings
536
537# analyze the host gcc machine spec to find out about 64-bitness
538HOST_PLATFORM_IS_64_BIT = ;
539switch $(HOST_GCC_MACHINE) {
540	case amd64-* :				HOST_PLATFORM_IS_64_BIT = 1 ;
541	case i686-apple-darwin10 :	HOST_PLATFORM_IS_64_BIT = 1 ;
542	case x86_64-* :				HOST_PLATFORM_IS_64_BIT = 1 ;
543}
544
545# If HAIKU_HOST_USE_32BIT is set, add the required gcc base flag (the LD flag
546# is set later), or, if the architecture isn't actually 64 bit, clear
547# HAIKU_HOST_USE_32BIT.
548# Afterwards HOST_PLATFORM_IS_64_BIT will indicate whether the architecture is
549# effectively (i.e. when using the compiler/linker flags) 64 bit and
550# HAIKU_HOST_USE_32BIT will be set, iff the architecture is really 64 bit and
551# 32 bit mode was requested.
552if $(HAIKU_HOST_USE_32BIT) = 1 {
553	if $(HOST_PLATFORM_IS_64_BIT) {
554		# enable GCC -m32 option
555		HOST_GCC_BASE_FLAGS = -m32 ;
556		HOST_PLATFORM_IS_64_BIT = ;
557	} else {
558		HAIKU_HOST_USE_32BIT = 0 ;
559	}
560}
561
562
563# save jam's variables for the build platform
564HOST_AR				?= $(AR) ;
565HOST_CC				?= $(CC) ;
566HOST_C++			?= $(C++) ;
567HOST_LINK			?= $(LINK) ;
568HOST_RANLIB			?= $(RANLIB) ;
569HOST_CPPFLAGS		?= $(CPPFLAGS) ;
570HOST_CCFLAGS		?= $(HOST_GCC_BASE_FLAGS) $(CCFLAGS) ;
571HOST_C++FLAGS		?= $(HOST_GCC_BASE_FLAGS) $(C++FLAGS) ;
572HOST_LDFLAGS		?= $(LDFLAGS) ;
573HOST_LINKFLAGS		?= $(HOST_GCC_BASE_FLAGS) $(LINKFLAGS) ;
574HOST_DEFINES		?= $(DEFINES) ;
575HOST_HDRS			?= $(HDRS) ;
576
577
578# split up HOST_AR into the command name and flags
579HOST_AR				= [ Match "([^ ]*) *(.*)" : $(HOST_AR[1]) ]
580					  $(HOST_AR[2-]) ;
581HOST_ARFLAGS		= $(HOST_AR[2-]) ;
582HOST_AR				= $(HOST_AR[1]) ;
583HOST_UNARFLAGS		?= x ;
584
585# check the host platform compatibility
586SetPlatformCompatibilityFlagVariables HOST_PLATFORM : HOST : host
587	: linux openbsd freebsd darwin sunos cygwin ;
588
589if $(HOST_PLATFORM) = linux || $(HOST_PLATFORM) = freebsd
590	|| $(HOST_PLATFORM) = darwin || $(HOST_PLATFORM) = cygwin
591	|| $(HOST_PLATFORM) = sunos || $(HOST_PLATFORM) = openbsd {
592	# don't use lex: otherwise rc will not work correctly
593	if $(LEX) = lex {
594		LEX = flex ;
595	}
596}
597
598if $(HOST_PLATFORM) = cygwin {
599	HOST_LINKFLAGS += -Xlinker --allow-multiple-definition -Xlinker
600		--enable-auto-import ;
601}
602
603HOST_CPU	?= $(OSPLAT:L) ;
604
605# Jam doesn't know x86_64, so override HOST_CPU, if 64 bit.
606if $(HOST_CPU) = x86 && $(HOST_PLATFORM_IS_64_BIT) {
607	HOST_CPU = x86_64 ;
608}
609
610HOST_ARCH				?= $(HOST_CPU) ;
611HOST_ARCH_MACRO_DEFINE	= ARCH_$(HOST_CPU) ;
612
613
614# directories
615HOST_OBJECT_BASE_DIR = [ FDirName $(HAIKU_OBJECT_DIR) $(HOST_PLATFORM) ] ;
616HOST_COMMON_ARCH_OBJECT_DIR = [ FDirName $(HOST_OBJECT_BASE_DIR) common ] ;
617HOST_ARCH_OBJECT_DIR = [ FDirName $(HOST_OBJECT_BASE_DIR) $(HOST_ARCH) ] ;
618HOST_COMMON_DEBUG_OBJECT_DIR = [ FDirName $(HOST_ARCH_OBJECT_DIR) common ] ;
619HOST_DEBUG_0_OBJECT_DIR = [ FDirName $(HOST_ARCH_OBJECT_DIR) release ] ;
620
621local level ;
622for level in $(HAIKU_DEBUG_LEVELS[2-]) {
623	HOST_DEBUG_$(level)_OBJECT_DIR
624		= [ FDirName $(HOST_ARCH_OBJECT_DIR) debug_$(level) ] ;
625}
626
627# analyze GCC version
628HOST_GCC_VERSION = [ FAnalyzeGCCVersion HOST_GCC_RAW_VERSION ] ;
629
630# set variables for gcc header options
631SetIncludePropertiesVariables HOST ;
632
633# assembler flags
634HOST_ASFLAGS = ;
635
636# C/C++ flags
637HOST_CCFLAGS += -Wno-multichar ;
638HOST_C++FLAGS += -Wno-multichar ;
639
640if $(HOST_PLATFORM) != cygwin {
641	HOST_PIC_CCFLAGS += -fPIC ;
642	HOST_PIC_C++FLAGS += -fPIC ;
643}
644
645HOST_KERNEL_CCFLAGS += $(HOST_GCC_BASE_FLAGS) -finline -fno-builtin
646	-D_KERNEL_MODE ;
647HOST_KERNEL_C++FLAGS += $(HOST_GCC_BASE_FLAGS) -finline -fno-builtin
648	-fno-exceptions -D_KERNEL_MODE ;
649HOST_KERNEL_DEFINES += _KERNEL_MODE ;
650
651HOST_KERNEL_PIC_CCFLAGS = -fno-pic ;
652HOST_KERNEL_PIC_LINKFLAGS = ;
653if $(HOST_ARCH) = ppc {
654	# Build a position independent PPC kernel. We need to be able to relocate
655	# the kernel, since the virtual address space layout at boot time is not
656	# fixed.
657	HOST_KERNEL_PIC_CCFLAGS = -fPIE ;
658	HOST_KERNEL_PIC_LINKFLAGS = -shared -fPIE ;
659}
660if $(HOST_ARCH) = m68k {
661	# Build a position independent M68K kernel. We need to be able to relocate
662	# the kernel, since the virtual address space layout at boot time is not
663	# fixed.
664	HOST_KERNEL_PIC_CCFLAGS = $(HAIKU_KERNEL_PIC_CCFLAGS) ;
665	HOST_KERNEL_PIC_LINKFLAGS = $(HAIKU_KERNEL_PIC_LINKFLAGS) ;
666}
667
668# warning flags
669HOST_WARNING_CCFLAGS = -Wall -Wno-trigraphs -Wmissing-prototypes -Wpointer-arith
670	-Wcast-align -Wsign-compare ;
671HOST_WARNING_C++FLAGS = -Wall -Wno-trigraphs -Wno-ctor-dtor-privacy
672	-Woverloaded-virtual -Wpointer-arith -Wcast-align -Wsign-compare ;
673
674HOST_KERNEL_WARNING_CCFLAGS = -Wall -Wno-trigraphs -Wmissing-prototypes ;
675HOST_KERNEL_WARNING_C++FLAGS = -Wall -Wno-trigraphs ;
676
677# debug flags
678switch $(HOST_PLATFORM) {
679	case haiku	: HOST_DEBUG_FLAGS ?= -ggdb ;
680	case haiku_host	: HOST_DEBUG_FLAGS ?= -ggdb ;
681	case linux	: HOST_DEBUG_FLAGS ?= -ggdb ;
682	case freebsd	: HOST_DEBUG_FLAGS ?= -ggdb ;
683	case darwin	: HOST_DEBUG_FLAGS ?= -ggdb ;
684	case *		: HOST_DEBUG_FLAGS ?= -g ;
685}
686
687# debug 0: suppress asserts
688HOST_DEBUG_0_CCFLAGS = [ FDefines NDEBUG=$(NDEBUG) ] ;
689HOST_DEBUG_0_C++FLAGS = [ FDefines NDEBUG=$(NDEBUG) ] ;
690
691HOST_KERNEL_DEBUG_0_CCFLAGS = [ FDefines NDEBUG=$(NDEBUG) ] ;
692HOST_KERNEL_DEBUG_0_C++FLAGS = [ FDefines NDEBUG=$(NDEBUG) ] ;
693
694local level ;
695for level in $(HAIKU_DEBUG_LEVELS[2-]) {
696	local flags = $(HOST_DEBUG_FLAGS) [ FDefines DEBUG=$(level) ] ;
697	HOST_DEBUG_$(level)_CCFLAGS			= $(flags) ;
698	HOST_DEBUG_$(level)_C++FLAGS		= $(flags) ;
699	HOST_KERNEL_DEBUG_$(level)_CCFLAGS	= $(flags) ;
700	HOST_KERNEL_DEBUG_$(level)_C++FLAGS	= $(flags) ;
701}
702
703# ld flags
704if $(HAIKU_HOST_USE_32BIT) = 1 {
705	HOST_LDFLAGS += -melf_i386 ;
706}
707
708# private kernel headers do be used when compiling kernel code
709HOST_PRIVATE_KERNEL_HEADERS = ;
710
711# private shared kernel/libroot headers
712HOST_PRIVATE_SYSTEM_HEADERS = ;
713
714# under BeOS use copyattr instead of cp
715if $(HOST_PLATFORM_BEOS_COMPATIBLE)
716{
717	CP = copyattr --data ;
718}
719
720HOST_DEFINES += $(HOST_ARCH_MACRO_DEFINE) ;
721HOST_DEFINES += _NO_INLINE_ASM ;
722
723if $(HOST_PLATFORM_BEOS_COMPATIBLE) {
724	# TODO: That's obviously not correct, but in the way the COMPILE_FOR_R5
725	# macro is used, it actually seems to mean r5/bone/dano.
726	# TODO: Deprecated. Remove!
727	HOST_DEFINES += COMPILE_FOR_R5 ;
728}
729
730# for builds of tools in the current environment
731HOST_BUILD_COMPATIBILITY_LIB_DIR = [ FDirName $(HOST_OBJECT_BASE_DIR) lib ] ;
732
733# For the generic attributes emulation: Target rm_attrs -- rm replacement that
734# also removes the attributes.
735HOST_RM_ATTRS_TARGET = ;
736
737if $(HOST_PLATFORM_BEOS_COMPATIBLE) {
738	# the C++ standard and support libraries
739	if $(HOST_GCC_VERSION[1]) < 3 {
740		HOST_LIBSTDC++ = stdc++.r4 ;
741		HOST_LIBSUPC++ = ;
742	} else {
743		HOST_LIBSTDC++ = stdc++ ;
744		HOST_LIBSUPC++ = supc++ ;
745	}
746
747	HOST_LIBROOT = root ;
748	HOST_STATIC_LIBROOT = $(HOST_LIBROOT) ;
749	HOST_LIBBE = be ;
750	HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR = "export LIBRARY_PATH=$LIBRARY_PATH:$(HOST_BUILD_COMPATIBILITY_LIB_DIR)"  ;
751	HOST_LIBRARY_NAME_MAP_input_server = /system/servers/input_server ;
752	HOST_DEFINES += __STDC_FORMAT_MACROS __STDC_LIMIT_MACROS ;
753
754	local compatibilityHeader = -include [ FDirName $(HAIKU_TOP) headers build
755		HaikuBuildCompatibility.h ] ;
756	HOST_CCFLAGS += $(compatibilityHeader) ;
757	HOST_C++FLAGS += $(compatibilityHeader) ;
758
759	# compatibility library
760	HOST_HAIKU_COMPATIBILITY_LIBS = libhaikucompat.a ;
761} else {
762	HOST_LIBSTDC++ = stdc++ ;
763	HOST_LIBROOT = libroot_build_function_remapper.a libroot_build.so ;
764	HOST_STATIC_LIBROOT = libroot_build.a ;
765	HOST_LIBBE = libbe_build.so ;
766	if $(HOST_PLATFORM) = cygwin {
767		HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR
768			= "export PATH=$PATH:$(HOST_BUILD_COMPATIBILITY_LIB_DIR)" ;
769	} else if $(HOST_PLATFORM) = darwin {
770		HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR
771			= "export DYLD_LIBRARY_PATH=$DYLD_LIBRARY_PATH:$(HOST_BUILD_COMPATIBILITY_LIB_DIR)" ;
772	} else {
773		HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR
774			= "export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$(HOST_BUILD_COMPATIBILITY_LIB_DIR)" ;
775	}
776
777	# the C++ support library
778	if $(HOST_GCC_VERSION[1]) < 3 {
779		HOST_LIBSUPC++ = ;
780	} else {
781		HOST_LIBSUPC++ = supc++ ;
782	}
783
784	if $(HOST_PLATFORM) = darwin {
785		# part of the C++ runtime lives in libstdc++ on Darwin
786		HOST_LIBSUPC++ = gcc_s.1 stdc++ ;
787		HOST_LIBSTDC++ = ;
788	} else if $(HOST_PLATFORM) = freebsd {
789		if $(HOST_CPU) = x86_64 {
790			# amd64 FreeBSD 8 doesn't come without a shared libsupc++, and the
791			# static one prevents us from building shared libraries. So we have
792			# to work around by using the shared libstdc++.
793			HOST_LIBSUPC++ = stdc++ ;
794			HOST_LIBSTDC++ = ;
795		}
796	}
797
798	# Unlike glibc FreeBSD's libc doesn't have built-in regex support.
799	if $(HOST_PLATFORM) = freebsd {
800		HOST_LIBROOT += /usr/lib/libgnuregex.so ;
801		HOST_STATIC_LIBROOT += /usr/lib/libgnuregex.so ;
802	} else if $(HOST_PLATFORM) = darwin {
803		HOST_LIBROOT += /opt/local/lib/libgnuregex.dylib ;
804		HOST_STATIC_LIBROOT += /opt/local/lib/libgnuregex.dylib ;
805	}
806
807	# The BeOS compilers define __INTEL__ respectively __POWERPC__. On the
808	# build platform we need to make sure, this is also defined.
809	if $(HOST_CPU) = x86 {
810		HOST_DEFINES += __INTEL__ ;
811	} else if $(HOST_CPU) = x86_64 {
812		HOST_DEFINES += __x86_64__ ;
813	} else if $(HOST_CPU) = ppc {
814		HOST_DEFINES += __POWERPC__ ;
815	} else if $(HOST_CPU) = m68k {
816		HOST_DEFINES += __M68K__ ;
817	} else if $(HOST_CPU) = mipsel {
818		HOST_DEFINES += __MIPSEL__ ;
819	}
820
821	# Supposing this is a glibc platform, let's try to get features like large
822	# file support, ISO C 99 definitions, etc. On some platforms we need to
823	# request 64 bit off_t support explicitely.
824	HOST_DEFINES += _GNU_SOURCE _FILE_OFFSET_BITS=64 __STDC_FORMAT_MACROS
825		__STDC_LIMIT_MACROS ;
826
827	# On Linux with xattr support we can use it for our attribute emulation,
828	# which is somewhat more robust.
829	if $(HAIKU_HOST_USE_XATTR) = 1 {
830		HOST_DEFINES += HAIKU_HOST_USE_XATTR ;
831	} else {
832		# Otherwise the generic attribute emulation is used, which uses a
833		# directory per file to store its attribute. We need to redefine RM so
834		# that the attributes are removed as well. We use a wrapper script,
835		# which invokes a build tool. If the build tool hasn't been built yet,
836		# the normal "rm" is used and the attributes are leaked (likely there
837		# aren't any yet).
838		RM = $(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR) ";"
839			[ FDirName $(HAIKU_TOP) build scripts rm_attrs ]
840			[ FDirName $(HAIKU_OBJECT_DIR) $(HOST_PLATFORM) $(HOST_ARCH) release
841				tools rm_attrs ] -f ;
842			# assumes that rm_attrs is built with debugging disabled
843		HOST_RM_ATTRS_TARGET = <build>rm_attrs ;
844	}
845}
846
847# network libraries
848if $(HOST_PLATFORM_HAIKU_COMPATIBLE) {
849	HOST_NETWORK_LIBS = network ;
850	HOST_NETAPI_LIB = bnetapi ;
851	HOST_SELECT_UNAME_ETC_LIB = ;	# libroot
852} else if $(HOST_PLATFORM_BONE_COMPATIBLE) {
853	HOST_NETWORK_LIBS = socket bind ;
854	HOST_NETAPI_LIB = bnetapi ;
855	HOST_SELECT_UNAME_ETC_LIB = ;	# libroot
856} else if $(HOST_PLATFORM_BEOS_COMPATIBLE) {
857	HOST_NETWORK_LIBS = net ;
858	HOST_NETAPI_LIB = netapi ;
859	HOST_SELECT_UNAME_ETC_LIB = net ;
860} else if $(HOST_PLATFORM) = "sunos" {
861	HOST_NETWORK_LIBS = xnet ;
862	HOST_NETAPI_LIB = ;
863	HOST_SELECT_UNAME_ETC_LIB = ;
864} else {
865	# Linux,...
866	HOST_NETWORK_LIBS = ;
867	HOST_NETAPI_LIB = ;
868	HOST_SELECT_UNAME_ETC_LIB = ;
869}
870
871# define the executable MIME type
872HOST_EXECUTABLE_MIME_TYPE = "application/x-vnd.Be-elfexecutable" ;
873
874if $(METROWERKS) {
875	# at least parts of Haiku still can be compiled with
876	# the Metrowerks compiler on BeOS/PPC
877	HOST_EXECUTABLE_MIME_TYPE = "application/x-be-executable" ;
878}
879
880# Be API compatibility
881HOST_BE_API_HEADERS = ;
882HOST_BE_API_CCFLAGS = ;
883HOST_BE_API_C++FLAGS = ;
884
885if ! $(HOST_PLATFORM_BEOS_COMPATIBLE) {
886	HOST_BE_API_HEADERS =
887		[ FDirName $(HAIKU_TOP) headers build ]
888		[ FDirName $(HAIKU_TOP) headers build os ]
889		[ FDirName $(HAIKU_TOP) headers build os app ]
890		[ FDirName $(HAIKU_TOP) headers build os drivers ]
891		[ FDirName $(HAIKU_TOP) headers build os kernel ]
892		[ FDirName $(HAIKU_TOP) headers build os interface ]
893		[ FDirName $(HAIKU_TOP) headers build os opengl ]
894		[ FDirName $(HAIKU_TOP) headers build os storage ]
895		[ FDirName $(HAIKU_TOP) headers build os support ]
896		[ FDirName $(HAIKU_TOP) headers build private ]
897	;
898	HOST_BE_API_CCFLAGS = -include BeOSBuildCompatibility.h ;
899	HOST_BE_API_C++FLAGS = $(HOST_BE_API_CCFLAGS) ;
900}
901
902# Add directory with system headers we need when building something for the host
903# platform, e.g. containing missing POSIX/GNU headers.
904HOST_HDRS += [ FDirName $(HAIKU_TOP) headers build host $(HOST_PLATFORM) ] ;
905
906# For all versions of BeOS also add the common beos directory.
907if $(HOST_PLATFORM) in r5 bone dano {
908	HOST_HDRS += [ FDirName $(HAIKU_TOP) headers build host beos_common ] ;
909}
910
911
912#pragma mark -
913
914# target platform settings
915
916# check the target platform compatibility
917SetPlatformCompatibilityFlagVariables TARGET_PLATFORM : TARGET : target ;
918
919# check the compatibility between host and target platform
920if $(TARGET_PLATFORM) != haiku {
921	if ! $(HOST_PLATFORM_($(TARGET_PLATFORM))_COMPATIBLE) {
922		Exit ERROR: The host platform is not compatible with target platform
923			$(TARGET_PLATFORM). ;
924	}
925}
926
927# Set TARGET_* variables either from HAIKU_* or HOST_* depending on the
928# specified TARGET_PLATFORM.
929
930local buildVars =
931	ARCH CPU GCC_VERSION
932
933	AR CC C++ LD OBJCOPY RANLIB
934
935	INCLUDES_SEPARATOR LOCAL_INCLUDES_OPTION SYSTEM_INCLUDES_OPTION
936
937	HDRS CPPFLAGS CCFLAGS C++FLAGS LDFLAGS LINK LINKFLAGS DEFINES
938	ARFLAGS UNARFLAGS
939	KERNEL_DEFINES
940
941	KERNEL_CCFLAGS KERNEL_C++FLAGS
942	KERNEL_PIC_CCFLAGS KERNEL_PIC_LINKFLAGS
943	WARNING_CCFLAGS WARNING_C++FLAGS
944
945	KERNEL_WARNING_CCFLAGS KERNEL_WARNING_C++FLAGS
946
947	DEBUG_FLAGS
948
949	DEBUG_$(HAIKU_DEBUG_LEVELS)_CCFLAGS DEBUG_$(HAIKU_DEBUG_LEVELS)_C++FLAGS
950
951	KERNEL_DEBUG_$(HAIKU_DEBUG_LEVELS)_CCFLAGS
952	KERNEL_DEBUG_$(HAIKU_DEBUG_LEVELS)_C++FLAGS
953
954	PRIVATE_KERNEL_HEADERS
955	PRIVATE_SYSTEM_HEADERS
956
957	LIBSTDC++ LIBSUPC++
958	STATIC_LIBSTDC++ STATIC_LIBSUPC++
959
960	NETWORK_LIBS NETAPI_LIB SELECT_UNAME_ETC_LIB
961
962	ARCH_MACRO_DEFINE EXECUTABLE_MIME_TYPE
963
964	OBJECT_BASE_DIR COMMON_ARCH_OBJECT_DIR COMMON_DEBUG_OBJECT_DIR
965	DEBUG_$(HAIKU_DEBUG_LEVELS)_OBJECT_DIR
966;
967
968if $(TARGET_PLATFORM) = haiku {
969	local var ;
970	for var in $(buildVars) {
971		TARGET_$(var) = $(HAIKU_$(var)) ;
972	}
973
974	TARGET_GCC_LIB_DIR			= $(HAIKU_GCC_LIB_DIR) ;
975	TARGET_GCC_HEADERS_DIR		= $(HAIKU_GCC_HEADERS_DIR) ;
976	TARGET_GCC_LIBGCC			= $(HAIKU_GCC_LIBGCC) ;
977	TARGET_GCC_LIBGCC_OBJECTS	= $(HAIKU_GCC_LIBGCC_OBJECTS) ;
978
979	TARGET_BOOT_PLATFORM		?= $(HAIKU_BOOT_PLATFORM) ;
980	TARGET_BOOT_BOARD			?= $(HAIKU_BOOT_BOARD) ;
981
982	TARGET_LIBRARY_NAME_MAP		= HAIKU_LIBRARY_NAME_MAP ;
983
984} else {
985	local var ;
986	for var in $(buildVars) {
987		TARGET_$(var) = $(HOST_$(var)) ;
988	}
989
990	TARGET_GCC_LIB_DIR			= ;
991	TARGET_GCC_HEADERS_DIR		= ;
992	TARGET_GCC_LIBGCC			= ;
993	TARGET_GCC_LIBGCC_OBJECTS	= ;
994
995	TARGET_BOOT_PLATFORM		= ;
996	TARGET_BOOT_BOARD			= ;
997
998	TARGET_LIBRARY_NAME_MAP		= HOST_LIBRARY_NAME_MAP ;
999}
1000
1001# define macro, for identifying the platform
1002switch $(TARGET_PLATFORM) {
1003	case r5			: TARGET_DEFINES	+= HAIKU_TARGET_PLATFORM_BEOS ;
1004	case bone		: TARGET_DEFINES	+= HAIKU_TARGET_PLATFORM_BONE ;
1005	case dano		: TARGET_DEFINES	+= HAIKU_TARGET_PLATFORM_DANO ;
1006	case haiku_host	: TARGET_DEFINES	+= HAIKU_TARGET_PLATFORM_HAIKU ;
1007	case haiku		: TARGET_DEFINES	+= HAIKU_TARGET_PLATFORM_HAIKU ;
1008	case linux		: TARGET_DEFINES	+= HAIKU_TARGET_PLATFORM_LINUX ;
1009	case freebsd	: TARGET_DEFINES	+= HAIKU_TARGET_PLATFORM_FREEBSD ;
1010	case darwin		: TARGET_DEFINES	+= HAIKU_TARGET_PLATFORM_DARWIN ;
1011	case cygwin		: TARGET_DEFINES	+= HAIKU_TARGET_PLATFORM_CYGWIN ;
1012	case sunos		: TARGET_DEFINES	+= HAIKU_TARGET_PLATFORM_SUNOS ;
1013	case libbe_test	: TARGET_DEFINES	+= HAIKU_TARGET_PLATFORM_LIBBE_TEST ;
1014}
1015
1016# define macro, for identifying the host platform
1017switch $(HOST_PLATFORM) {
1018	case r5			: HOST_DEFINES	+= HAIKU_HOST_PLATFORM_BEOS ;
1019	case bone		: HOST_DEFINES	+= HAIKU_HOST_PLATFORM_BONE ;
1020	case dano		: HOST_DEFINES	+= HAIKU_HOST_PLATFORM_DANO ;
1021	case haiku_host	: HOST_DEFINES	+= HAIKU_HOST_PLATFORM_HAIKU ;
1022	case linux		: HOST_DEFINES	+= HAIKU_HOST_PLATFORM_LINUX ;
1023	case freebsd	: HOST_DEFINES	+= HAIKU_HOST_PLATFORM_FREEBSD ;
1024	case darwin		: HOST_DEFINES	+= HAIKU_HOST_PLATFORM_DARWIN ;
1025	case cygwin		: HOST_DEFINES	+= HAIKU_HOST_PLATFORM_CYGWIN ;
1026	case sunos		: HOST_DEFINES	+= HAIKU_HOST_PLATFORM_SUNOS ;
1027}
1028
1029# define host platform 64 bit macro
1030if $(HOST_PLATFORM_IS_64_BIT) {
1031	HOST_DEFINES += HAIKU_HOST_PLATFORM_64_BIT ;
1032}
1033
1034#pragma mark -
1035
1036# In case we build for a BeOS compatible platform, but not for Haiku, we
1037# include the HaikuBuildCompatibility.h header and link against
1038# libhaikucompat.a.
1039
1040if ! $(TARGET_PLATFORM_HAIKU_COMPATIBLE) && $(TARGET_PLATFORM_BEOS_COMPATIBLE) {
1041	# headers and flags
1042	local compatibilityHeader = -include [ FDirName $(HAIKU_TOP) headers build
1043		HaikuBuildCompatibility.h ] ;
1044	TARGET_CCFLAGS += $(compatibilityHeader) ;
1045	TARGET_C++FLAGS += $(compatibilityHeader) ;
1046
1047	# compatibility library
1048	TARGET_HAIKU_COMPATIBILITY_LIBS = libhaikucompat.a ;
1049}
1050
1051# special target libbe_test
1052
1053if $(TARGET_PLATFORM) = libbe_test {
1054	# headers and flags
1055	TARGET_HDRS +=
1056		[ PublicHeaders $(DOT) app drivers game interface kernel storage
1057			support ]
1058		[ PrivateHeaders $(DOT) ] ;
1059	TARGET_DEFINES += __HAIKU__ ;
1060
1061	TARGET_PRIVATE_SYSTEM_HEADERS =
1062		[ PrivateHeaders $(DOT) system system/arch/$(TARGET_ARCH) ] ;
1063
1064	# directories
1065	TARGET_OBJECT_BASE_DIR
1066		= [ FDirName $(HAIKU_OBJECT_DIR) $(TARGET_PLATFORM) ] ;
1067	TARGET_COMMON_ARCH_OBJECT_DIR
1068		= [ FDirName $(TARGET_OBJECT_BASE_DIR) common ] ;
1069	TARGET_ARCH_OBJECT_DIR
1070		= [ FDirName $(TARGET_OBJECT_BASE_DIR) $(TARGET_ARCH) ] ;
1071	TARGET_COMMON_DEBUG_OBJECT_DIR
1072		= [ FDirName $(TARGET_ARCH_OBJECT_DIR) common ] ;
1073	TARGET_DEBUG_0_OBJECT_DIR
1074		= [ FDirName $(TARGET_ARCH_OBJECT_DIR) release ] ;
1075
1076	local level ;
1077	for level in $(HAIKU_DEBUG_LEVELS[2-]) {
1078		TARGET_DEBUG_$(level)_OBJECT_DIR
1079			= [ FDirName $(TARGET_ARCH_OBJECT_DIR) debug_$(level) ] ;
1080	}
1081
1082	# library name map
1083	TARGET_LIBRARY_NAME_MAP = LIBBE_LIBRARY_NAME_MAP ;
1084	LIBBE_LIBRARY_NAME_MAP_be = libbe_test.so ;
1085}
1086
1087
1088#pragma mark -
1089
1090# common stuff
1091
1092# start with a clean state
1093CCFLAGS = ;
1094C++FLAGS = ;
1095DEFINES = ;
1096
1097# Set CC, C++, LINK to invalid values, so that we realize early, that we use
1098# the wrong compiler.
1099CC = bad-cc ;
1100C++ = bad-c++ ;
1101LINK = bad-link ;
1102
1103# Allow compiling unit tests on Zeta. Instead of fixing the PostMessage()
1104# issues, they deprecated that nice function. This will enable it again:
1105C++FLAGS += -D_ZETA_USING_DEPRECATED_API_=1 ;
1106# Same for buggy find_directory threadsafety fixes
1107C++FLAGS += -D_ZETA_TS_FIND_DIR_=1 ;
1108	# TODO: Doesn't really belong here.
1109
1110
1111# Defaults for warnings, optimization, and debugging.
1112#
1113WARNINGS ?= 1 ;
1114OPTIM ?= -O2 ;
1115DEBUG ?= 0 ;
1116
1117
1118# Set the defaults for PLATFORM and SUPPORTED_PLATFORMS. PLATFORM is only
1119# overridden for targets to be built for the host platform. SUPPORTED_PLATFORMS
1120# can be overridden by the author of a component.
1121PLATFORM = $(TARGET_PLATFORM) ;
1122SUPPORTED_PLATFORMS = haiku ;
1123
1124
1125# Instructs the Library rule to not make its object files temporary.
1126# This is needed as some objects are used in a static library and for an
1127# executable.
1128KEEPOBJS = true ;
1129
1130
1131# Set permissions to how they should be on the image.
1132EXEMODE		= 755 ;
1133FILEMODE	= 644 ;
1134SHELLMODE	= 755 ;
1135
1136
1137# output directories
1138# TODO: Review this.
1139HAIKU_DOCUMENTATION_DIR ?= [ FDirName $(HAIKU_OUTPUT_DIR) documentation ] ;
1140HAIKU_DOCUMENTATION_OBJECT_DIR ?= [ FDirName $(HAIKU_COMMON_PLATFORM_OBJECT_DIR)
1141	documentation ] ;
1142
1143# TODO: Rethink test stuff.
1144HAIKU_TEST_DIR			?= [ FDirName $(HAIKU_OUTPUT_DIR) tests
1145	$(TARGET_PLATFORM) $(HAIKU_ARCH) ] ;
1146HAIKU_APP_TEST_DIR		?= [ FDirName $(HAIKU_TEST_DIR) apps ] ;
1147HAIKU_APP_TEST_LIB_DIR 	?= [ FDirName $(HAIKU_APP_TEST_DIR) lib ] ;
1148HAIKU_TMP_DIR			?= [ FDirName $(HAIKU_OUTPUT_DIR) tmp ] ;
1149
1150HAIKU_PACKAGE_DIR ?= [ FDirName $(HAIKU_OUTPUT_DIR) packages ] ;
1151HAIKU_PACKAGE_OBJECT_DIR ?= [ FDirName $(HAIKU_OBJECT_DIR) packages ] ;
1152	# TODO: Remove those together with the obsolete package rules!
1153
1154HAIKU_PACKAGES_DIR			= [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR)
1155								packages ] ;
1156HAIKU_PACKAGES_BUILD_DIR	= [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR)
1157								packages_build ] ;
1158HAIKU_PACKAGE_INFOS_DIR		= [ FDirName $(HAIKU_TOP) src data package_infos ] ;
1159
1160TARGET_TEST_DIR				?= [ FDirName $(HAIKU_TEST_DIR)
1161									$(TARGET_PLATFORM) ] ;
1162TARGET_UNIT_TEST_DIR		?= [ FDirName $(TARGET_TEST_DIR) unittests ] ;
1163TARGET_UNIT_TEST_LIB_DIR	?= [ FDirName $(TARGET_UNIT_TEST_DIR) lib ] ;
1164
1165# automatically setup the objects directory per subdirectory
1166SUBDIRRULES += SetupObjectsDir ;
1167
1168# Add the standard (userland) warning flags variables to the ones restored in
1169# every subdirectory. Thus we can easily meddle with them in subdirectories
1170# with imported sources.
1171AUTO_SET_UP_CONFIG_VARIABLES +=
1172	HOST_WARNING_CCFLAGS HOST_WARNING_C++FLAGS
1173	TARGET_WARNING_CCFLAGS TARGET_WARNING_C++FLAGS
1174
1175	# also add PLATFORM and SUPPORTED_PLATFORMS
1176	PLATFORM SUPPORTED_PLATFORMS
1177;
1178
1179
1180# enable -Werror for certain parts of the source tree
1181
1182if $(HAIKU_GCC_VERSION[1]) = 2 {
1183	rule EnableWerror dirTokens : scope {
1184		AppendToConfigVar CCFLAGS : HAIKU_TOP $(dirTokens) : -Werror
1185			: $(scope) ;
1186		AppendToConfigVar C++FLAGS : HAIKU_TOP $(dirTokens) : -Werror
1187			: $(scope) ;
1188	}
1189} else {
1190	# -Wuninitialized gives too many false positives.
1191	rule EnableWerror dirTokens : scope {
1192		AppendToConfigVar CCFLAGS : HAIKU_TOP $(dirTokens)
1193			: -Werror -Wno-error=uninitialized : $(scope) ;
1194		AppendToConfigVar C++FLAGS : HAIKU_TOP $(dirTokens)
1195			: -Werror -Wno-error=uninitialized : $(scope) ;
1196	}
1197}
1198
1199# Work-around for GCC 2 problem -- despite -Wno-multichar it reports
1200# multichar warnings in headers/private/kernel/debugger_keymaps.h included by
1201# src/system/kernel/arch/x86/arch_debug_console.cpp.
1202if $(HAIKU_GCC_VERSION[1]) = 2 {
1203	local file = <src!system!kernel!arch!x86>arch_debug_console.o ;
1204	C++FLAGS on $(file) = [ on $(file) return $(C++FLAGS) ] ;
1205}
1206
1207if $(HAIKU_NO_WERROR) != 1 {
1208	EnableWerror src add-ons accelerants 3dfx ;
1209	EnableWerror src add-ons accelerants ati ;
1210	EnableWerror src add-ons accelerants common ;
1211	EnableWerror src add-ons accelerants et6x00 ;
1212#	EnableWerror src add-ons accelerants intel_extreme ;
1213#	EnableWerror src add-ons accelerants matrox ;
1214	EnableWerror src add-ons accelerants neomagic ;
1215#	EnableWerror src add-ons accelerants nvidia ;
1216	EnableWerror src add-ons accelerants nvidia_gpgpu ;
1217#	EnableWerror src add-ons accelerants radeon ;
1218	EnableWerror src add-ons accelerants radeon_hd ;
1219	EnableWerror src add-ons accelerants s3 ;
1220	EnableWerror src add-ons accelerants skeleton ;
1221	EnableWerror src add-ons accelerants vesa ;
1222	EnableWerror src add-ons accelerants via ;
1223	EnableWerror src add-ons accelerants vmware ;
1224	EnableWerror src add-ons bluetooth ;
1225	EnableWerror src add-ons decorators ;
1226	EnableWerror src add-ons disk_systems ;
1227	EnableWerror src add-ons input_server devices ;
1228#	EnableWerror src add-ons input_server filters ;
1229#	EnableWerror src add-ons input_server methods ;
1230	EnableWerror src add-ons kernel bluetooth ;
1231#	EnableWerror src add-ons kernel bus_managers acpi ;
1232	EnableWerror src add-ons kernel bus_managers agp_gart ;
1233	EnableWerror src add-ons kernel bus_managers ata ;
1234	EnableWerror src add-ons kernel bus_managers config_manager ;
1235	EnableWerror src add-ons kernel bus_managers firewire ;
1236	EnableWerror src add-ons kernel bus_managers isa ;
1237	EnableWerror src add-ons kernel bus_managers pci ;
1238#	EnableWerror src add-ons kernel bus_managers ps2 ; # gcc2
1239	EnableWerror src add-ons kernel bus_managers scsi ;
1240	EnableWerror src add-ons kernel bus_managers usb ;
1241	EnableWerror src add-ons kernel busses agp_gart ;
1242	EnableWerror src add-ons kernel busses ata ;
1243	EnableWerror src add-ons kernel busses scsi ;
1244	EnableWerror src add-ons kernel busses usb ;
1245	EnableWerror src add-ons kernel console ;
1246	EnableWerror src add-ons kernel cpu ;
1247#	EnableWerror src add-ons kernel debugger ; # gcc2
1248#	EnableWerror src add-ons kernel drivers audio ;
1249	EnableWerror src add-ons kernel drivers bluetooth ;
1250	EnableWerror src add-ons kernel drivers bus ;
1251	EnableWerror src add-ons kernel drivers common ;
1252	EnableWerror src add-ons kernel drivers disk ;
1253	EnableWerror src add-ons kernel drivers dvb ;
1254#	EnableWerror src add-ons kernel drivers graphics ;
1255#	EnableWerror src add-ons kernel drivers input ;
1256	EnableWerror src add-ons kernel drivers joystick ;
1257	EnableWerror src add-ons kernel drivers midi ;
1258	EnableWerror src add-ons kernel drivers misc ;
1259#	EnableWerror src add-ons kernel drivers network ;
1260	EnableWerror src add-ons kernel drivers ports ;
1261#	EnableWerror src add-ons kernel drivers power ;
1262	EnableWerror src add-ons kernel drivers printer ;
1263	EnableWerror src add-ons kernel drivers random ;
1264	EnableWerror src add-ons kernel drivers tty ;
1265	EnableWerror src add-ons kernel drivers video ;
1266	EnableWerror src add-ons kernel file_systems bfs ;
1267	EnableWerror src add-ons kernel file_systems cdda ;
1268#	EnableWerror src add-ons kernel file_systems ext2 ;
1269#	EnableWerror src add-ons kernel file_systems fat ;
1270#	EnableWerror src add-ons kernel file_systems googlefs ;
1271	EnableWerror src add-ons kernel file_systems iso9660 ;
1272	EnableWerror src add-ons kernel file_systems layers ;
1273	EnableWerror src add-ons kernel file_systems netfs ;
1274	EnableWerror src add-ons kernel file_systems nfs ;
1275#	EnableWerror src add-ons kernel file_systems ntfs ;
1276	EnableWerror src add-ons kernel file_systems packagefs ;
1277	EnableWerror src add-ons kernel file_systems ramfs ;
1278#	EnableWerror src add-ons kernel file_systems reiserfs ;
1279	EnableWerror src add-ons kernel file_systems udf ;
1280	EnableWerror src add-ons kernel file_systems userlandfs ;
1281	EnableWerror src add-ons kernel generic ;
1282#	EnableWerror src add-ons kernel network datalink_protocols ;
1283	EnableWerror src add-ons kernel network devices ;
1284	EnableWerror src add-ons kernel network notifications ;
1285	EnableWerror src add-ons kernel network ppp ;
1286	EnableWerror src add-ons kernel network protocols ;
1287#	EnableWerror src add-ons kernel network stack ;
1288	EnableWerror src add-ons kernel partitioning_systems ;
1289	EnableWerror src add-ons locale ;
1290	EnableWerror src add-ons mail_daemon ;
1291	EnableWerror src add-ons media media-add-ons demultiplexer ;
1292	EnableWerror src add-ons media media-add-ons dvb ;
1293	EnableWerror src add-ons media media-add-ons esound_sink ;
1294	EnableWerror src add-ons media media-add-ons finepix_webcam ;
1295	EnableWerror src add-ons media media-add-ons firewire_dv ;
1296	EnableWerror src add-ons media media-add-ons legacy ;
1297	EnableWerror src add-ons media media-add-ons mixer ;
1298	EnableWerror src add-ons media media-add-ons multi_audio ;
1299	EnableWerror src add-ons media media-add-ons opensound ;
1300	EnableWerror src add-ons media media-add-ons radeon ;
1301	EnableWerror src add-ons media media-add-ons reader ;
1302	EnableWerror src add-ons media media-add-ons tone_producer_demo ;
1303	EnableWerror src add-ons media media-add-ons usb_vision ;
1304#	EnableWerror src add-ons media media-add-ons usb_webcam ;
1305	EnableWerror src add-ons media media-add-ons video_mixer ;
1306#	EnableWerror src add-ons media media-add-ons video_producer_demo ;
1307	EnableWerror src add-ons media media-add-ons videowindow ;
1308	EnableWerror src add-ons media media-add-ons writer ;
1309	EnableWerror src add-ons media plugins ac3_decoder ;
1310	EnableWerror src add-ons media plugins aiff_reader ;
1311	EnableWerror src add-ons media plugins ape_reader ;
1312#	EnableWerror src add-ons media plugins asf_reader ;
1313	EnableWerror src add-ons media plugins au_reader ;
1314#	EnableWerror src add-ons media plugins avi_reader ;
1315#	EnableWerror src add-ons media plugins ffmpeg ;
1316#	EnableWerror src add-ons media plugins matroska ;
1317#	EnableWerror src add-ons media plugins mov_reader ;
1318	EnableWerror src add-ons media plugins mp3_decoder ;
1319#	EnableWerror src add-ons media plugins mp3_reader ;
1320	EnableWerror src add-ons media plugins mp4_reader ;
1321	EnableWerror src add-ons media plugins musepack ;
1322#	EnableWerror src add-ons media plugins ogg ;
1323#	EnableWerror src add-ons media plugins raw_decoder ;
1324#	EnableWerror src add-ons media plugins speex ;
1325	EnableWerror src add-ons media plugins theora ;
1326	EnableWerror src add-ons media plugins vorbis ;
1327#	EnableWerror src add-ons media plugins wav_reader ;
1328	EnableWerror src add-ons media plugins xvid_decoder ;
1329	EnableWerror src add-ons opengl ;
1330	EnableWerror src add-ons print ;
1331	EnableWerror src add-ons screen_savers ;
1332	EnableWerror src add-ons tracker ;
1333	EnableWerror src add-ons translators bmp ;
1334#	EnableWerror src add-ons translators exr ;
1335	EnableWerror src add-ons translators gif ;
1336	EnableWerror src add-ons translators hpgs ;
1337	EnableWerror src add-ons translators hvif ;
1338	EnableWerror src add-ons translators ico ;
1339#	EnableWerror src add-ons translators jpeg ; # gcc2
1340	EnableWerror src add-ons translators jpeg2000 ;
1341	EnableWerror src add-ons translators pcx ;
1342#	EnableWerror src add-ons translators png ; # gcc2
1343	EnableWerror src add-ons translators ppm ;
1344	EnableWerror src add-ons translators raw ;
1345	EnableWerror src add-ons translators rtf ;
1346	EnableWerror src add-ons translators sgi ;
1347	EnableWerror src add-ons translators shared ;
1348	EnableWerror src add-ons translators stxt ;
1349	EnableWerror src add-ons translators tga ;
1350	EnableWerror src add-ons translators tiff ;
1351	EnableWerror src add-ons translators wonderbrush ;
1352	EnableWerror src add-ons print ;
1353	EnableWerror src bin package ;
1354	EnableWerror src apps ;
1355	EnableWerror src kits ;
1356	EnableWerror src preferences ;
1357	EnableWerror src servers ;
1358	EnableWerror src system kernel ;
1359	EnableWerror src system runtime_loader ;
1360}
1361
1362