More work towards hybrid support

* All packaging architecture dependent variables do now have a
  respective suffix and are set up for each configured packaging
  architecture, save for the kernel and boot loader variables, which
  are still only set up for the primary architecture.
  For convenience TARGET_PACKAGING_ARCH, TARGET_ARCH, TARGET_LIBSUPC++,
  and TARGET_LIBSTDC++ are set to the respective values for the primary
  packaging architecture by default.
* Introduce a set of MultiArch* rules to help with building targets for
  multiple packaging architectures. Generally the respective targets are
  (additionally) gristed with the packaging architecture. For libraries
  the additional grist is usually omitted for the primary architecture
  (e.g. libroot.so and <x86>libroot.so for x86_gcc2/x86 hybrid), so that
  Jamfiles for targets built only for the primary architecture don't
  need to be changed.
* Add multi-arch build support for all targets needed for the stage 1
  cross devel package as well as for libbe (untested).

Jamfile

@@ -4,7 +4,12 @@ NotFile doc_files ;
 Depends files : doc_files ;
 
 # Prepare the optional build features before parsing the Jamfile tree.
-include [ FDirName $(HAIKU_BUILD_RULES_DIR) BuildFeatures ] ;
+local architectureObject ;
+for architectureObject in [ MultiArchSubDirSetup ] {
+	on $(architectureObject) {
+		include [ FDirName $(HAIKU_BUILD_RULES_DIR) BuildFeatures ] ;
+	}
+}
 
 # Include packages that are required by all images.
 if ! $(HAIKU_BOOTSTRAP_BUILD) {

Jamrules

@@ -29,42 +29,8 @@ if ! $(buildConfig) {
 LOCATE on BuildConfig = $(HAIKU_BUILD_OUTPUT_DIR) ;
 include BuildConfig ;
 
-# Set simplified variables for primary architecture.
+# set HAIKU_PACKAGING_ARCH, the primary packaging architecture
 HAIKU_PACKAGING_ARCH = $(HAIKU_PACKAGING_ARCHS[1]) ;
-local variable ;
-for variable in
-	HAIKU_GCC_RAW_VERSION
-	HAIKU_GCC_MACHINE
-	HAIKU_GCC_LIB_DIR
-	HAIKU_GCC_HEADERS_DIR
-	HAIKU_GCC_LIBGCC
-	HAIKU_GCC_LIBGCC_OBJECTS
-	HAIKU_CPU
-	HAIKU_STATIC_LIBSTDC++
-	HAIKU_SHARED_LIBSTDC++
-	HAIKU_STATIC_LIBSUPC++
-	HAIKU_SHARED_LIBSUPC++
-	HAIKU_C++_HEADERS_DIR
-	HAIKU_KERNEL_LIBGCC
-	HAIKU_KERNEL_LIBSUPC++
-	HAIKU_BOOT_LIBGCC
-	HAIKU_BOOT_LIBSUPC++
-	HAIKU_AR
-	HAIKU_CC
-	HAIKU_LD
-	HAIKU_OBJCOPY
-	HAIKU_RANLIB
-	HAIKU_ELFEDIT
-	HAIKU_STRIP
-	HAIKU_CPPFLAGS
-	HAIKU_CCFLAGS
-	HAIKU_C++FLAGS
-	HAIKU_LDFLAGS
-	HAIKU_ARFLAGS
-	HAIKU_UNARFLAGS
-	HAIKU_USE_GCC_GRAPHITE {
-	$(variable) = $($(variable)_$(HAIKU_PACKAGING_ARCH)) ;
-}
 
 # The build setup and rules are neatly organized in several files. Include
 # them now. Start with the side-effect-less rules, since they are the most
@@ -73,6 +39,7 @@ for variable in
 # optional user-defined UserBuildConfig is included thereafter.
 include [ FDirName $(HAIKU_BUILD_RULES_DIR) HelperRules ] ;
 include [ FDirName $(HAIKU_BUILD_RULES_DIR) MathRules ] ;
+include [ FDirName $(HAIKU_BUILD_RULES_DIR) ArchitectureRules ] ;
 include [ FDirName $(HAIKU_BUILD_RULES_DIR) BeOSRules ] ;
 include [ FDirName $(HAIKU_BUILD_RULES_DIR) LocaleRules ] ;
 include [ FDirName $(HAIKU_BUILD_RULES_DIR) CommandLineArguments ] ;

build/jam/ArchitectureRules

@@ -0,0 +1,777 @@
+rule ArchitectureSetup architecture
+{
+	# ArchitectureSetup <architecture> ;
+	#
+	# Initializes all global packaging architecture dependent variables for the
+	# given packaging architecture. Also sets HAIKU_ARCH (to the primary
+	# architecture), if this is the first invocation of the rule, and adds
+	# the architecture to HAIKU_ARCHS, if not yet contained.
+
+	# analyze GCC version
+	local gccVersion
+		= [ FAnalyzeGCCVersion HAIKU_GCC_RAW_VERSION_$(architecture) ] ;
+	HAIKU_GCC_VERSION_$(architecture) = $(gccVersion) ;
+
+	# enable GCC -pipe option, if requested
+	local gccBaseFlags ;
+	if $(HAIKU_USE_GCC_PIPE) = 1 {
+		gccBaseFlags = -pipe ;
+	}
+
+	# disable strict aliasing on anything newer than gcc 2 as it may lead to
+	# unexpected results. also disable the tree-vrp (value range propagation)
+	# optimization for now as with the current gcc4 version we are using this
+	# results in some broken code.
+	# TODO: remove the -fno-strict-aliasing option when all code has been
+	#		analyzed/fixed with regard to aliasing.
+	# TODO: retest/remove the -fno-tree-vrp option as soon as we have updated
+	#		our gcc4 compiler. See this discussion on some issues:
+	# http://www.freelists.org/post/haiku-development/hrev45320-Yet-another-nonobvious-effect-of-ftreevrp-optimization
+	if $(gccVersion[1]) >= 3 {
+		gccBaseFlags += -fno-strict-aliasing -fno-tree-vrp ;
+	}
+
+	# disable array bounds warnings on gcc 4.6 or newer since they trigger
+	# too many false positives. Coverity does a better job of this kind of
+	# analysis anyways.
+	if $(gccVersion[1]) >= 4 {
+		gccBaseFlags += -Wno-array-bounds ;
+	}
+
+	# activating graphite optimizations
+	if $(HAIKU_USE_GCC_GRAPHITE_$(architecture)) = 1 {
+		gccBaseFlags += -floop-interchange -ftree-loop-distribution
+			-floop-strip-mine -floop-block ;
+	}
+	HAIKU_GCC_BASE_FLAGS_$(architecture) = $(gccBaseFlags) ;
+
+	# override gcc 2.95.3's header directory -- strictly necessary only when
+	# using the BeOS native compiler (since its headers are incompatible), but
+	# it doesn't harm for the cross-compiler either.
+	if $(gccVersion[1]) = 2 {
+		HAIKU_GCC_HEADERS_DIR_$(architecture)
+			= [ FDirName $(HAIKU_TOP) headers build gcc-2.95.3 ] ;
+	}
+
+	# initial state for flags etc.
+	HAIKU_C++_$(architecture) ?= $(HAIKU_CC_$(architecture)) ;
+	HAIKU_LINK_$(architecture) = $(HAIKU_CC_$(architecture)) ;
+	HAIKU_LINKFLAGS_$(architecture) = $(gccBaseFlags) ;
+
+	HAIKU_HDRS_$(architecture) = [ FStandardHeaders $(architecture) ] ;
+	HAIKU_CCFLAGS_$(architecture) += $(gccBaseFlags) -nostdinc ;
+	HAIKU_C++FLAGS_$(architecture) += $(gccBaseFlags) -nostdinc ;
+
+	local cpu = $(HAIKU_CPU_$(architecture)) ;
+	switch $(cpu) {
+		case ppc :
+			HAIKU_DEFINES_$(architecture) += __POWERPC__ ;
+
+		case arm :
+			HAIKU_DEFINES_$(architecture) += __ARM__ ;
+
+		case x86 :
+			HAIKU_DEFINES_$(architecture) += __INTEL__ ;
+
+		case m68k :
+			HAIKU_DEFINES_$(architecture) += __M68K__ ;
+
+		case mipsel :
+			HAIKU_DEFINES_$(architecture) += __MIPSEL__ ;
+
+		case * :
+			Exit "Currently unsupported target CPU:" $(cpu) ;
+	}
+
+	# strip is required
+	if ! $(HAIKU_STRIP_$(architecture)) {
+		Exit "HAIKU_STRIP_$(architecture) not set. Please re-run configure." ;
+	}
+
+	HAIKU_ARCH_$(architecture) = $(cpu) ;
+	HAIKU_ARCH ?= $(cpu) ;
+		# Set only, if not set yet. This way HAIKU_ARCH is set to the primary
+		# architecture.
+	if ! $(cpu) in $(HAIKU_ARCHS) {
+		HAIKU_ARCHS += $(cpu) ;
+	}
+	HAIKU_DEFINES_$(architecture) += ARCH_$(cpu) ;
+
+	# directories
+	HAIKU_ARCH_OBJECT_DIR_$(architecture)
+		= [ FDirName $(HAIKU_OBJECT_BASE_DIR) $(architecture) ] ;
+	HAIKU_COMMON_DEBUG_OBJECT_DIR_$(architecture)
+		= [ FDirName $(HAIKU_ARCH_OBJECT_DIR_$(architecture)) common ] ;
+	HAIKU_DEBUG_0_OBJECT_DIR_$(architecture)
+		= [ FDirName $(HAIKU_ARCH_OBJECT_DIR_$(architecture)) release ] ;
+
+	local level ;
+	for level in $(HAIKU_DEBUG_LEVELS[2-]) {
+		HAIKU_DEBUG_$(level)_OBJECT_DIR_$(architecture)
+			= [ FDirName $(HAIKU_ARCH_OBJECT_DIR_$(architecture))
+				debug_$(level) ] ;
+	}
+
+	# set variables for gcc header options
+	SetIncludePropertiesVariables HAIKU : _$(architecture) ;
+
+	# assembler flags
+	HAIKU_ASFLAGS_$(architecture) = ;
+
+	# C/C++ flags
+	if $(gccVersion[1]) >= 4 {
+		HAIKU_C++FLAGS_$(architecture) += -Wno-deprecated ;
+	}
+
+	switch $(cpu) {
+		case x86* :
+			# Enable use of the gcc built-in atomic functions instead of
+			# atomic_*(). The former are inlined and have thus less overhead.
+			# They are not available with gcc 2, but the header will take care
+			# of that.
+			HAIKU_DEFINES_$(architecture) += B_USE_BUILTIN_ATOMIC_FUNCTIONS ;
+	}
+
+	# warning flags
+	HAIKU_WARNING_CCFLAGS_$(architecture)
+		= -Wall -Wno-trigraphs -Wmissing-prototypes
+		-Wpointer-arith -Wcast-align -Wsign-compare -Wno-multichar ;
+	HAIKU_WARNING_C++FLAGS_$(architecture) = -Wall -Wno-trigraphs
+		-Wno-ctor-dtor-privacy -Woverloaded-virtual -Wpointer-arith -Wcast-align
+		-Wsign-compare -Wno-multichar ;
+
+	# debug flags
+	local debugFlags = -ggdb ;
+
+	# debug 0: suppress asserts
+	HAIKU_DEBUG_0_CCFLAGS_$(architecture) = [ FDefines NDEBUG=$(NDEBUG) ] ;
+	HAIKU_DEBUG_0_C++FLAGS_$(architecture) = [ FDefines NDEBUG=$(NDEBUG) ] ;
+
+	local level ;
+	for level in $(HAIKU_DEBUG_LEVELS[2-]) {
+		local flags = $(debugFlags) [ FDefines DEBUG=$(level) ] ;
+		HAIKU_DEBUG_$(level)_CCFLAGS_$(architecture) = $(flags) ;
+		HAIKU_DEBUG_$(level)_C++FLAGS_$(architecture) = $(flags) ;
+	}
+
+	if $(gccVersion[1]) >= 3 {
+		# TODO: Temporary work-around. Should be defined in the compiler specs
+		HAIKU_LINKFLAGS_$(architecture) += -Xlinker --no-undefined ;
+	} else {
+		HAIKU_DEFINES_$(architecture) += _BEOS_R5_COMPATIBLE_ ;
+	}
+
+	# private shared kernel/libroot headers
+	HAIKU_PRIVATE_SYSTEM_HEADERS_$(architecture)
+		= [ PrivateHeaders $(DOT) system system/arch/$(cpu) ] ;
+
+	# Add some grist to the libgcc objects
+	HAIKU_GCC_LIBGCC_OBJECTS_$(architecture)
+		= $(HAIKU_GCC_LIBGCC_OBJECTS_$(architecture):G=libgcc!$(architecture)) ;
+
+	# the C++ standard library
+	HAIKU_BUILD_SHARED_LIBSTDC++_$(architecture) = ;
+	if $(HAIKU_SHARED_LIBSTDC++_$(architecture)) {
+		HAIKU_LIBSTDC++_$(architecture)
+			= $(HAIKU_SHARED_LIBSTDC++_$(architecture)) ;
+	} else {
+		# no shared library available with the compiler -- build it
+		if $(gccVersion[1]) = 2 {
+			HAIKU_LIBSTDC++_$(architecture) = libstdc++.r4.so ;
+		} else {
+			HAIKU_LIBSTDC++_$(architecture) = <$(architecture)>libstdc++.so ;
+		}
+		HAIKU_SHARED_LIBSTDC++_$(architecture)
+			= $(HAIKU_LIBSTDC++_$(architecture)) ;
+		HAIKU_BUILD_SHARED_LIBSTDC++_$(architecture) = 1 ;
+	}
+
+	# the C++ support (runtime) library
+	HAIKU_BUILD_SHARED_LIBSUPC++_$(architecture) = ;
+	if $(HAIKU_SHARED_LIBSUPC++_$(architecture)) {
+		HAIKU_LIBSUPC++_$(architecture)
+			= $(HAIKU_SHARED_LIBSUPC++_$(architecture)) ;
+	} else {
+		# no shared library available with the compiler -- build it for gcc 4
+		if $(gccVersion[1]) != 2 {
+			HAIKU_SHARED_LIBSUPC++_$(architecture)
+				= <$(architecture)>libsupc++.so ;
+			HAIKU_BUILD_SHARED_LIBSUPC++_$(architecture) = 1 ;
+		}
+
+		HAIKU_LIBSUPC++_$(architecture)
+			= $(HAIKU_SHARED_LIBSUPC++_$(architecture)) ;
+	}
+
+	# library and executable glue code
+	local commonGlueCode =
+		<src!system!glue!$(architecture)>init_term_dyn.o
+		<src!system!glue!arch!$(HAIKU_ARCH)!$(architecture)>crti.o
+		<src!system!glue!arch!$(HAIKU_ARCH)!$(architecture)>crtn.o
+		;
+	HAIKU_LIBRARY_BEGIN_GLUE_CODE_$(architecture) =
+		<src!system!glue!arch!$(HAIKU_ARCH)!$(architecture)>crti.o
+		<$(architecture)>crtbegin.o
+		<src!system!glue!$(architecture)>init_term_dyn.o
+		;
+	HAIKU_LIBRARY_END_GLUE_CODE_$(architecture) =
+		<$(architecture)>crtend.o
+		<src!system!glue!arch!$(HAIKU_ARCH)!$(architecture)>crtn.o
+		;
+	HAIKU_EXECUTABLE_BEGIN_GLUE_CODE_$(architecture) =
+		<src!system!glue!arch!$(HAIKU_ARCH)!$(architecture)>crti.o
+		<$(architecture)>crtbegin.o
+		<src!system!glue!$(architecture)>start_dyn.o
+		<src!system!glue!$(architecture)>init_term_dyn.o
+		;
+	HAIKU_EXECUTABLE_END_GLUE_CODE_$(architecture)
+		= $(HAIKU_LIBRARY_END_GLUE_CODE_$(architecture)) ;
+
+	SEARCH on <$(architecture)>crtbegin.o <$(architecture)>crtend.o
+		= $(HAIKU_GCC_LIB_DIR_$(architecture)) ;
+
+	# init library name map
+	local i ;
+	for i in be bnetapi debug device game GL locale mail media midi midi2
+			network opengl package root screensaver textencoding tracker
+			translation z {
+		HAIKU_LIBRARY_NAME_MAP_$(architecture)_$(i) = lib$(i).so ;
+	}
+	HAIKU_LIBRARY_NAME_MAP_$(architecture)_libstdc++
+		= $(HAIKU_LIBSTDC++_$(architecture)) ;
+	HAIKU_LIBRARY_NAME_MAP_$(architecture)_libsupc++
+		= $(HAIKU_LIBSUPC++_$(architecture)) ;
+	HAIKU_LIBRARY_NAME_MAP_$(architecture)_input_server
+		= <nogrist>input_server ;
+	HAIKU_LIBRARY_NAME_MAP_$(architecture)_localestub
+		= <$(architecture)>liblocalestub.a ;
+}
+
+
+rule KernelArchitectureSetup architecture
+{
+	# KernelArchitectureSetup <architecture> ;
+	#
+	# Initializes the global kernel and boot loader related variables. Those
+	# don't have a packaging architecture suffix, since they are only set for
+	# the primary packaging architecture. <architecture> is the primary
+	# packaging architecture (supplied for convenience).
+
+	HAIKU_KERNEL_ARCH = $(HAIKU_ARCH) ;
+
+	local gccVersion = $(HAIKU_GCC_VERSION_$(architecture)) ;
+	local cpu = $(HAIKU_CPU_$(architecture)) ;
+
+	switch $(cpu) {
+		case ppc :
+			HAIKU_BOOT_PLATFORM ?= openfirmware ;
+			HAIKU_BOOT_FLOPPY_IMAGE_SIZE = 1440 ; # in kB
+			# offset in floppy image (>= sizeof(haiku_loader))
+			HAIKU_BOOT_ARCHIVE_IMAGE_OFFSET = 192 ; # in kB - unused yet
+
+		case arm :
+			HAIKU_BOOT_PLATFORM ?= u-boot ;
+			HAIKU_BOOT_BOARD ?= verdex ;
+			HAIKU_BOOT_FLOPPY_IMAGE_SIZE = 1440 ;
+				# in kB (there is not really a floppy on the gumstix ;) )
+			# offset in floppy image (>= sizeof(haiku_loader))
+			HAIKU_BOOT_ARCHIVE_IMAGE_OFFSET = 192 ; # in kB - unused yet
+
+		case x86 :
+			HAIKU_BOOT_PLATFORM = bios_ia32 ;
+			HAIKU_BOOT_FLOPPY_IMAGE_SIZE = 2880 ; # in kB
+			# offset in floppy image (>= sizeof(haiku_loader))
+			HAIKU_BOOT_ARCHIVE_IMAGE_OFFSET = 300 ; # in kB
+
+			# yasm is required for target arch x86
+			if ! $(HAIKU_YASM) {
+				Exit "HAIKU_YASM not set. Please re-run configure." ;
+			}
+
+		case x86_64 :
+			# x86_64 completely shares the x86 bootloader.
+			HAIKU_BOOT_PLATFORM = bios_ia32 ;
+			HAIKU_BOOT_FLOPPY_IMAGE_SIZE = 2880 ; # in kB
+			# offset in floppy image (>= sizeof(haiku_loader))
+			HAIKU_BOOT_ARCHIVE_IMAGE_OFFSET = 300 ; # in kB
+
+			# x86_64 kernel source is under arch/x86.
+			HAIKU_KERNEL_ARCH = x86 ;
+
+			# yasm is required for target arch x86_64
+			if ! $(HAIKU_YASM) {
+				Exit "HAIKU_YASM not set. Please re-run configure." ;
+			}
+
+		case m68k :
+			HAIKU_BOOT_PLATFORM ?= atari_m68k ;
+			switch $(HAIKU_BOOT_PLATFORM) {
+				case atari_m68k :
+				{
+					HAIKU_BOOT_FLOPPY_IMAGE_SIZE = 1440 ; # in kB
+				}
+				case amiga_m68k :
+				{
+					# for now we have trouble reading from double-sided images
+					HAIKU_BOOT_FLOPPY_IMAGE_SIZE = 880 ; # in kB
+				}
+			}
+			# offset in floppy image (>= sizeof(haiku_loader))
+			HAIKU_BOOT_ARCHIVE_IMAGE_OFFSET = 260 ; # in kB
+
+		case mipsel :
+			# RouterBOARD firmware (ELF image over TFTP)
+			HAIKU_BOOT_PLATFORM = routerboard_mipsel ;
+			# offset in floppy image (>= sizeof(haiku_loader))
+			HAIKU_BOOT_ARCHIVE_IMAGE_OFFSET = 192 ; # in kB
+
+		case * :
+			Exit "Currently unsupported target CPU:" $(cpu) ;
+	}
+
+	# Include embedded board-specific file.
+	if $(HAIKU_BOOT_BOARD) {
+		include [ FDirName $(HAIKU_BUILD_RULES_DIR) board $(HAIKU_BOOT_BOARD)
+			BoardSetup ] ;
+	}
+
+	# private kernel headers to be used when compiling kernel code
+	HAIKU_PRIVATE_KERNEL_HEADERS =
+		[ PrivateHeaders $(DOT) kernel libroot shared
+			kernel/boot/platform/$(HAIKU_BOOT_PLATFORM) ]
+		[ ArchHeaders $(HAIKU_KERNEL_ARCH) ]
+		[ FDirName $(HAIKU_COMMON_DEBUG_OBJECT_DIR_$(architecture)) system
+			kernel ]
+		$(HAIKU_PRIVATE_SYSTEM_HEADERS_$(architecture))
+		;
+
+	# C/C++ flags
+	local gccBaseFlags = $(HAIKU_GCC_BASE_FLAGS_$(architecture))
+		-finline -fno-builtin ;
+
+	if $(gccVersion[1]) >= 4 {
+		gccBaseFlags += -ffreestanding ;
+	}
+
+	local g++BaseFlags = $(gccBaseFlags) -fno-exceptions ;
+
+	if $(gccVersion[1]) >= 3 {
+		g++BaseFlags += -fno-use-cxa-atexit ;
+	}
+
+	HAIKU_KERNEL_CCFLAGS = $(HAIKU_CCFLAGS_$(architecture)) $(gccBaseFlags) ;
+	HAIKU_KERNEL_C++FLAGS = $(HAIKU_C++FLAGS_$(architecture)) $(g++BaseFlags) ;
+	HAIKU_BOOT_CCFLAGS = $(HAIKU_CCFLAGS_$(architecture)) $(gccBaseFlags) ;
+	HAIKU_BOOT_C++FLAGS = $(HAIKU_C++FLAGS_$(architecture)) $(g++BaseFlags) ;
+	HAIKU_BOOT_LINKFLAGS = ;
+
+	HAIKU_KERNEL_PIC_CCFLAGS = -fno-pic ;
+	HAIKU_KERNEL_PIC_LINKFLAGS = ;
+	HAIKU_KERNEL_ADDON_LINKFLAGS = ;
+
+	switch $(cpu) {
+		case ppc :
+			# Build a position independent PPC kernel. We need to be able to
+			# relocate the kernel, since the virtual address space layout at
+			# boot time is not fixed.
+			HAIKU_KERNEL_PIC_CCFLAGS = -fPIE ;
+			HAIKU_KERNEL_PIC_LINKFLAGS = -shared -fPIE ;
+
+		case m68k :
+			# We don't want to have to handle emulating missing FPU opcodes for
+			# 040 and 060 in the kernel.
+			HAIKU_KERNEL_CCFLAGS += -m68020-60 ;
+			HAIKU_KERNEL_C++FLAGS += -m68020-60 ;
+
+		case x86 :
+			HAIKU_KERNEL_CCFLAGS += -march=pentium ;
+			HAIKU_KERNEL_C++FLAGS += -march=pentium ;
+
+		case x86_64 :
+			# Kernel lives in the top 2GB of the address space, use kernel code
+			# model.
+			HAIKU_KERNEL_PIC_CCFLAGS += -mcmodel=kernel ;
+
+			# Disable the red zone, which cannot be used in kernel code due to
+			# interrupts, and always enable the frame pointer so stack traces
+			# are correct.
+			HAIKU_KERNEL_CCFLAGS += -mno-red-zone -fno-omit-frame-pointer ;
+			HAIKU_KERNEL_C++FLAGS += -mno-red-zone -fno-omit-frame-pointer ;
+			HAIKU_KERNEL_PIC_LINKFLAGS += -z max-page-size=0x1000 ;
+			HAIKU_KERNEL_ADDON_LINKFLAGS += -z max-page-size=0x1000 ;
+
+			# Bootloader is 32-bit.
+			HAIKU_BOOT_LINKFLAGS += -m elf_i386_haiku ;
+			HAIKU_BOOT_CCFLAGS += -m32 -march=pentium ;
+			HAIKU_BOOT_C++FLAGS += -m32 -march=pentium ;
+	}
+
+	# warning flags
+	HAIKU_KERNEL_WARNING_CCFLAGS = -Wall -Wno-trigraphs -Wmissing-prototypes
+		-Wno-multichar ;
+	HAIKU_KERNEL_WARNING_C++FLAGS = -Wall -Wno-trigraphs -Wno-multichar ;
+
+	# debug flags
+	local level ;
+	for level in $(HAIKU_DEBUG_LEVELS) {
+		local flags = $(HAIKU_DEBUG_FLAGS) [ FDefines DEBUG=$(level) ] ;
+		HAIKU_KERNEL_DEBUG_$(level)_CCFLAGS
+			= $(HAIKU_DEBUG_$(level)_CCFLAGS_$(architecture)) ;
+		HAIKU_KERNEL_DEBUG_$(level)_C++FLAGS
+			= $(HAIKU_DEBUG_$(level)_C++FLAGS_$(architecture)) ;
+	}
+
+	# defines
+	HAIKU_KERNEL_DEFINES += _KERNEL_MODE ;
+
+	HAIKU_DEFINES_$(architecture)
+		+= BOOT_ARCHIVE_IMAGE_OFFSET=$(HAIKU_BOOT_ARCHIVE_IMAGE_OFFSET) ;
+		# TODO: That doesn't need to be a general define. It's just needed for
+		# compiling (part of) the boot loader.
+
+	# kernel add-on glue code
+	HAIKU_KERNEL_ADDON_BEGIN_GLUE_CODE = <$(architecture)>crtbegin.o
+		<src!system!glue!$(architecture)>haiku_version_glue.o ;
+	HAIKU_KERNEL_ADDON_END_GLUE_CODE
+		= $(HAIKU_GCC_LIBGCC_$(architecture)) <$(architecture)>crtend.o ;
+}
+
+
+rule ArchitectureSetupWarnings architecture
+{
+	# ArchitectureSetupWarnings <architecture> ;
+	#
+	# Sets up compiler warnings and error flags for various subdirectories for
+	# the given packaging architecture.
+
+	local cpu = $(HAIKU_CPU_$(architecture)) ;
+	switch $(cpu) {
+		case arm :
+			return ;
+				# we use #warning as placeholders for things to write...
+		case m68k :
+			return ;
+				# we use #warning as placeholders for things to write...
+		case mipsel :
+			return ;
+				# we use #warning as placeholders for things to write...
+	}
+
+
+	# enable -Werror for certain parts of the source tree
+	HAIKU_WERRORFLAGS = ;
+	local gccVersion = $(HAIKU_GCC_VERSION_$(architecture)) ;
+	if $(gccVersion[1]) >= 4 {
+		# -Wuninitialized gives too many false positives.
+		HAIKU_WERRORFLAGS = -Wno-error=uninitialized ;
+
+		# TODO: remove the -Wno-unused-but-set-variable option
+		HAIKU_WERRORFLAGS += -Wno-unused-but-set-variable ;
+	}
+
+	HAIKU_WERROR_ARCH = $(architecture) ;
+
+	rule EnableWerror dirTokens : scope {
+		AppendToConfigVar TARGET_WARNING_CCFLAGS_$(HAIKU_WERROR_ARCH)
+			: HAIKU_TOP $(dirTokens)
+			: -Werror $(HAIKU_WERRORFLAGS) : $(scope) ;
+		AppendToConfigVar TARGET_WARNING_C++FLAGS_$(HAIKU_WERROR_ARCH)
+			: HAIKU_TOP $(dirTokens)
+			: -Werror $(HAIKU_WERRORFLAGS) : $(scope) ;
+	}
+
+	# Work-around for GCC 2 problem -- despite -Wno-multichar it reports
+	# multichar warnings in headers/private/kernel/debugger_keymaps.h included
+	# by src/system/kernel/arch/x86/arch_debug_console.cpp.
+	if $(gccVersion[1]) = 2 {
+		local file = <src!system!kernel!arch!x86>arch_debug_console.o ;
+		TARGET_WARNING_C++FLAGS_$(architecture) on $(file)
+			= [ on $(file) return $(TARGET_WARNING_C++FLAGS_$(architecture)) ] ;
+	}
+
+	EnableWerror src add-ons accelerants 3dfx ;
+	EnableWerror src add-ons accelerants ati ;
+	EnableWerror src add-ons accelerants common ;
+	EnableWerror src add-ons accelerants et6x00 ;
+#	EnableWerror src add-ons accelerants intel_extreme ;
+#	EnableWerror src add-ons accelerants matrox ;
+	EnableWerror src add-ons accelerants neomagic ;
+#	EnableWerror src add-ons accelerants nvidia ;
+	EnableWerror src add-ons accelerants nvidia_gpgpu ;
+#	EnableWerror src add-ons accelerants radeon ;
+#	EnableWerror src add-ons accelerants radeon_hd ;
+	EnableWerror src add-ons accelerants s3 ;
+	EnableWerror src add-ons accelerants skeleton ;
+	EnableWerror src add-ons accelerants vesa ;
+	EnableWerror src add-ons accelerants via ;
+	EnableWerror src add-ons accelerants vmware ;
+	EnableWerror src add-ons bluetooth ;
+	EnableWerror src add-ons decorators ;
+	EnableWerror src add-ons disk_systems ;
+	EnableWerror src add-ons input_server devices ;
+#	EnableWerror src add-ons input_server filters ;
+#	EnableWerror src add-ons input_server methods ;
+	EnableWerror src add-ons kernel bluetooth ;
+#	EnableWerror src add-ons kernel bus_managers acpi ;
+	EnableWerror src add-ons kernel bus_managers agp_gart ;
+	EnableWerror src add-ons kernel bus_managers ata ;
+	EnableWerror src add-ons kernel bus_managers config_manager ;
+#	EnableWerror src add-ons kernel bus_managers firewire ;
+	EnableWerror src add-ons kernel bus_managers isa ;
+	EnableWerror src add-ons kernel bus_managers pci ;
+#	EnableWerror src add-ons kernel bus_managers ps2 ; # gcc2
+	EnableWerror src add-ons kernel bus_managers scsi ;
+	EnableWerror src add-ons kernel bus_managers usb ;
+	EnableWerror src add-ons kernel busses agp_gart ;
+	EnableWerror src add-ons kernel busses ata ;
+	EnableWerror src add-ons kernel busses scsi ;
+	EnableWerror src add-ons kernel busses usb ;
+	EnableWerror src add-ons kernel console ;
+	EnableWerror src add-ons kernel cpu ;
+#	EnableWerror src add-ons kernel debugger ; # gcc2
+#	EnableWerror src add-ons kernel drivers audio ;
+	EnableWerror src add-ons kernel drivers bluetooth ;
+	EnableWerror src add-ons kernel drivers bus ;
+	EnableWerror src add-ons kernel drivers common ;
+	EnableWerror src add-ons kernel drivers disk ;
+	EnableWerror src add-ons kernel drivers dvb ;
+#	EnableWerror src add-ons kernel drivers graphics ;
+#	EnableWerror src add-ons kernel drivers input ;
+	EnableWerror src add-ons kernel drivers joystick ;
+	EnableWerror src add-ons kernel drivers midi ;
+	EnableWerror src add-ons kernel drivers misc ;
+#	EnableWerror src add-ons kernel drivers network ;
+	EnableWerror src add-ons kernel drivers ports ;
+#	EnableWerror src add-ons kernel drivers power ;
+	EnableWerror src add-ons kernel drivers printer ;
+	EnableWerror src add-ons kernel drivers random ;
+	EnableWerror src add-ons kernel drivers tty ;
+	EnableWerror src add-ons kernel drivers video ;
+	EnableWerror src add-ons kernel file_systems bfs ;
+	EnableWerror src add-ons kernel file_systems cdda ;
+#	EnableWerror src add-ons kernel file_systems ext2 ;
+#	EnableWerror src add-ons kernel file_systems fat ;
+#	EnableWerror src add-ons kernel file_systems googlefs ;
+	EnableWerror src add-ons kernel file_systems iso9660 ;
+	EnableWerror src add-ons kernel file_systems layers ;
+	EnableWerror src add-ons kernel file_systems netfs ;
+	EnableWerror src add-ons kernel file_systems nfs ;
+	EnableWerror src add-ons kernel file_systems nfs4 ;
+#	EnableWerror src add-ons kernel file_systems ntfs ;
+	EnableWerror src add-ons kernel file_systems packagefs ;
+	EnableWerror src add-ons kernel file_systems ramfs ;
+#	EnableWerror src add-ons kernel file_systems reiserfs ;
+	EnableWerror src add-ons kernel file_systems udf ;
+	EnableWerror src add-ons kernel file_systems userlandfs ;
+	EnableWerror src add-ons kernel generic ;
+#	EnableWerror src add-ons kernel network datalink_protocols ;
+	EnableWerror src add-ons kernel network devices ;
+	EnableWerror src add-ons kernel network dns_resolver ;
+	EnableWerror src add-ons kernel network notifications ;
+	EnableWerror src add-ons kernel network ppp ;
+	EnableWerror src add-ons kernel network protocols ;
+#	EnableWerror src add-ons kernel network stack ;
+	EnableWerror src add-ons kernel partitioning_systems ;
+	EnableWerror src add-ons locale ;
+	EnableWerror src add-ons mail_daemon ;
+	EnableWerror src add-ons media media-add-ons demultiplexer ;
+	EnableWerror src add-ons media media-add-ons dvb ;
+	EnableWerror src add-ons media media-add-ons esound_sink ;
+	EnableWerror src add-ons media media-add-ons finepix_webcam ;
+	EnableWerror src add-ons media media-add-ons firewire_dv ;
+	EnableWerror src add-ons media media-add-ons legacy ;
+	EnableWerror src add-ons media media-add-ons mixer ;
+	EnableWerror src add-ons media media-add-ons multi_audio ;
+	EnableWerror src add-ons media media-add-ons opensound ;
+	EnableWerror src add-ons media media-add-ons radeon ;
+	EnableWerror src add-ons media media-add-ons reader ;
+	EnableWerror src add-ons media media-add-ons tone_producer_demo ;
+	EnableWerror src add-ons media media-add-ons usb_vision ;
+#	EnableWerror src add-ons media media-add-ons usb_webcam ;
+	EnableWerror src add-ons media media-add-ons video_mixer ;
+#	EnableWerror src add-ons media media-add-ons video_producer_demo ;
+	EnableWerror src add-ons media media-add-ons videowindow ;
+	EnableWerror src add-ons media media-add-ons writer ;
+	EnableWerror src add-ons media plugins ac3_decoder ;
+	EnableWerror src add-ons media plugins aiff_reader ;
+	EnableWerror src add-ons media plugins ape_reader ;
+#	EnableWerror src add-ons media plugins asf_reader ;
+	EnableWerror src add-ons media plugins au_reader ;
+#	EnableWerror src add-ons media plugins avi_reader ;
+#	EnableWerror src add-ons media plugins ffmpeg ;
+#	EnableWerror src add-ons media plugins matroska ;
+#	EnableWerror src add-ons media plugins mov_reader ;
+	EnableWerror src add-ons media plugins mp3_decoder ;
+#	EnableWerror src add-ons media plugins mp3_reader ;
+	EnableWerror src add-ons media plugins mp4_reader ;
+	EnableWerror src add-ons media plugins musepack ;
+#	EnableWerror src add-ons media plugins ogg ;
+#	EnableWerror src add-ons media plugins raw_decoder ;
+#	EnableWerror src add-ons media plugins speex ;
+	EnableWerror src add-ons media plugins theora ;
+	EnableWerror src add-ons media plugins vorbis ;
+#	EnableWerror src add-ons media plugins wav_reader ;
+	EnableWerror src add-ons media plugins xvid_decoder ;
+	EnableWerror src add-ons opengl ;
+	EnableWerror src add-ons print ;
+	EnableWerror src add-ons screen_savers ;
+	EnableWerror src add-ons tracker ;
+	EnableWerror src add-ons translators bmp ;
+#	EnableWerror src add-ons translators exr ;
+	EnableWerror src add-ons translators gif ;
+#	EnableWerror src add-ons translators hpgs ;
+	EnableWerror src add-ons translators hvif ;
+	EnableWerror src add-ons translators ico ;
+#	EnableWerror src add-ons translators jpeg ; # gcc2
+	EnableWerror src add-ons translators jpeg2000 ;
+	EnableWerror src add-ons translators pcx ;
+#	EnableWerror src add-ons translators png ; # gcc2
+	EnableWerror src add-ons translators ppm ;
+	EnableWerror src add-ons translators raw ;
+	EnableWerror src add-ons translators rtf ;
+	EnableWerror src add-ons translators sgi ;
+	EnableWerror src add-ons translators shared ;
+#	EnableWerror src add-ons translators stxt ;
+	EnableWerror src add-ons translators tga ;
+	EnableWerror src add-ons translators tiff ;
+#	EnableWerror src add-ons translators wonderbrush ;
+	EnableWerror src add-ons print ;
+	EnableWerror src bin package ;
+	EnableWerror src apps ;
+	EnableWerror src kits ;
+	EnableWerror src preferences ;
+	EnableWerror src servers ;
+	EnableWerror src system kernel ;
+	EnableWerror src system libroot add-ons ;
+	EnableWerror src system libroot posix locale ;
+	EnableWerror src system libroot posix wchar ;
+	EnableWerror src system runtime_loader ;
+}
+
+
+rule MultiArchIfPrimary ifValue : elseValue
+{
+	# MultiArchIfPrimary <ifValue> : <elseValue> ;
+	#
+	# Returns one of the two given values depending on whether
+	# TARGET_PACKAGING_ARCH is currently set to the primary packaging
+	# architecture.
+
+	if $(TARGET_PACKAGING_ARCH) = $(TARGET_PACKAGING_ARCHS[1]) {
+		return $(ifValue) ;
+	}
+	return $(elseValue) ;
+}
+
+
+rule MultiArchConditionalGristFiles files : primaryGrist : secondaryGrist
+{
+	# MultiArchConditionalGristFiles <files> : <primaryGrist>
+	#	: <secondaryGrist> ;
+	#
+	# Returns <files> with their grist set to either <primaryGrist> or
+	# <secondaryGrist> depending on whether TARGET_PACKAGING_ARCH is currently
+	# set to the primary packaging architecture.
+
+	local grist = [ MultiArchIfPrimary $(primaryGrist) : $(secondaryGrist) ] ;
+	return $(files:G=$(grist:E=)) ;
+}
+
+
+rule MultiArchDefaultGristFiles files : gristPrefix
+{
+	# MultiArchDefaultGristFiles <files> : <gristPrefix> ;
+	#
+	# Convenient shorthand for MultiArchConditionalGristFiles for the common
+	# case that for a secondary packaging architecture the packaging
+	# architecture name shall be appended to the grist while it shall be omitted
+	# for the primary packaging architecture. IOW, if TARGET_PACKAGING_ARCH is
+	# currently set to the primary packaging architecture <files> are returned
+	# with their grist set to <gristPrefix>, otherwise <files> are returned with
+	# their grist set to <gristPrefix>!<arch> (<arch> being the name of the
+	# packaging architecture) respectively <arch> (if <gristPrefix> is empty).
+
+	local secondaryGrist = $(gristPrefix)!$(TARGET_PACKAGING_ARCH) ;
+	secondaryGrist ?= $(TARGET_PACKAGING_ARCH) ;
+
+	return [ MultiArchConditionalGristFiles $(files) : $(gristPrefix) :
+		$(secondaryGrist) ] ;
+}
+
+
+rule MultiArchSubDirSetup architectures
+{
+	# MultiArchSubDirSetup <architectures> ;
+	#
+	# For each of the given packaging architectures <architectures> that are
+	# in the packaging architectures configured for the build (or all configured
+	# packaging architectures, if <architectures> is empty) an object is
+	# prepared that can be used for an "on ... { ... }" block to set up subdir
+	# variables for the respective packaging architecture. Most notably
+	# TARGET_PACKAGING_ARCH, TARGET_ARCH, TARGET_LIBSUPC++, and TARGET_LIBSTDC++
+	# are set to the values for the respective packaging architecture. The
+	# per-subdir variables SOURCE_GRIST, LOCATE_TARGET, LOCATE_SOURCE,
+	# SEARCH_SOURCE, *_LOCATE_TARGET, are reset. All SUBDIR* and config
+	# variables are set to the values they had when this rule was invoked.
+
+	local result ;
+	architectures ?= $(TARGET_PACKAGING_ARCHS) ;
+	local architecture ;
+	for architecture in $(architectures) {
+		if ! $(architecture) in $(TARGET_PACKAGING_ARCHS) {
+			continue ;
+		}
+
+		local architectureObject = $(architecture:G=<arch-object>) ;
+		result += $(architectureObject) ;
+
+		# Set the variables that default to the values of the respective
+		# variables for the primary architecture.
+		TARGET_PACKAGING_ARCH on $(architectureObject) = $(architecture) ;
+
+		local var ;
+		for var in TARGET_ARCH TARGET_LIBSUPC++ TARGET_LIBSTDC++ {
+			$(var) on $(architectureObject) = $($(var)_$(architecture)) ;
+		}
+
+		# Clone the current config variable values and the variables SubDir
+		# resets.
+		for var in $(AUTO_SET_UP_CONFIG_VARIABLES) SUBDIR$(SUBDIRRESET) {
+			$(var) on $(architectureObject) = $($(var)) ;
+		}
+
+		# adjust SOURCE_GRIST
+		SOURCE_GRIST on $(architectureObject)
+			= $(SOURCE_GRIST:E=)!$(architecture) ;
+
+		# Adjust the subdir's object dirs that are architecture dependent. To
+		# avoid duplicating the code from SetupObjectsDir, we call it. Since it
+		# sets global variables, we set these variables on our object, call
+		# SetupObjectsDir in an "on" block, and grab the new variable values.
+		local hostTarget = HOST TARGET ;
+		local objectDirVars =
+			COMMON_ARCH COMMON_DEBUG DEBUG_$(HAIKU_DEBUG_LEVELS)
+			;
+		objectDirVars =
+			COMMON_PLATFORM_LOCATE_TARGET
+			$(hostTarget)_$(objectDirVars)_LOCATE_TARGET
+			LOCATE_TARGET
+			LOCATE_SOURCE
+			SEARCH_SOURCE
+			;
+
+		for var in $(objectDirVars) {
+			$(var) on $(architectureObject) = ;
+		}
+
+		on $(architectureObject) {
+			SetupObjectsDir ;
+
+			for var in $(objectDirVars) {
+				$(var) on $(architectureObject) = $($(var)) ;
+			}
+		}
+	}
+
+	return $(result) ;
+}

build/jam/BeOSRules

@@ -232,9 +232,11 @@ rule ResComp
 			cc = $(HOST_CC) ;
 			localIncludesOption = $(HOST_LOCAL_INCLUDES_OPTION) ;
 		} else {
-			defines += $(TARGET_DEFINES) ;
+			defines += $(TARGET_DEFINES_$(TARGET_PACKAGING_ARCH))
-			cc = $(TARGET_CC) ;
+				$(TARGET_DEFINES) ;
-			localIncludesOption = $(TARGET_LOCAL_INCLUDES_OPTION) ;
+			cc = $(TARGET_CC_$(TARGET_PACKAGING_ARCH)) ;
+			localIncludesOption
+				= $(TARGET_LOCAL_INCLUDES_OPTION_$(TARGET_PACKAGING_ARCH)) ;
 		}
 	}
 

build/jam/BootRules

@@ -24,8 +24,9 @@ rule SetupBoot
         ASFLAGS on $(object) = $(TARGET_BOOT_CCFLAGS) ;
 
 		# override warning flags
-		TARGET_WARNING_CCFLAGS on $(object) = $(TARGET_KERNEL_WARNING_CCFLAGS) ;
+		TARGET_WARNING_CCFLAGS_$(TARGET_PACKAGING_ARCH) on $(object)
-		TARGET_WARNING_C++FLAGS on $(object)
+			= $(TARGET_KERNEL_WARNING_CCFLAGS) ;
+		TARGET_WARNING_C++FLAGS_$(TARGET_PACKAGING_ARCH) on $(object)
 			= $(TARGET_KERNEL_WARNING_C++FLAGS) ;
 	}
 }
@@ -40,7 +41,7 @@ rule BootLd
 {
 	# BootLd <name> : <objs> : <linkerscript> : <args> ;
 
-	LINK on $(1) = $(TARGET_LD) ;
+	LINK on $(1) = $(TARGET_LD_$(TARGET_PACKAGING_ARCH)) ;
 
 	LINKFLAGS on $(1) = $(4) ;
 	if $(3) { LINKFLAGS on $(1) += --script=$(3) ; }
@@ -125,5 +126,5 @@ actions BootStaticLibraryObjects
 	# Force recreation of the archive to avoid build errors caused by
 	# stale dependencies after renaming or deleting object files.
 	$(RM) "$(1)"
-	$(HAIKU_AR) -r "$(1)" "$(2)" ;
+	$(HAIKU_AR_$(TARGET_PACKAGING_ARCH)) -r "$(1)" "$(2)" ;
 }

build/jam/BuildFeatures

@@ -4,10 +4,13 @@
 # for an optional package.
 
 
-# Add the target architecture as a build feature.
+local architecture = $(TARGET_PACKAGING_ARCH) ;
-EnableBuildFeatures $(HAIKU_ARCH) ;
 
-if $(HAIKU_GCC_VERSION[1]) = 2 {
+
+# Add the target architecture as a build feature.
+EnableBuildFeatures $(TARGET_ARCH_$(architecture)) ;
+
+if $(TARGET_GCC_VERSION_$(architecture)[1]) = 2 {
 	EnableBuildFeatures gcc2 ;
 }
 
@@ -122,7 +125,7 @@ if ! 1 {
 
 # LLVM
 if $(TARGET_ARCH) = x86 {
-	if $(HAIKU_GCC_VERSION[1]) >= 4 {
+	if $(TARGET_GCC_VERSION_$(architecture)[1]) >= 4 {
 		HAIKU_LLVM_FILE = llvm-3.2-x86-gcc4-2012-12-21.zip ;
 		local zipFile = [ DownloadFile $(HAIKU_LLVM_FILE)
 			: $(baseURL)/$(HAIKU_LLVM_FILE) ] ;
@@ -395,11 +398,13 @@ if $(TARGET_ARCH) = x86 {
 if $(HAIKU_BUILD_FEATURE_WEBKIT) {
 	if $(TARGET_ARCH) != x86 && $(TARGET_ARCH) != x86_64 {
 		Echo "WebKit support not available on $(TARGET_ARCH)" ;
-	} else if $(HAIKU_GCC_VERSION[1]) < 4 {
+	} else if $(TARGET_GCC_VERSION_$(architecture)[1]) < 4 {
 		if ! $(isHybridBuild) {
-			Echo "WebKit support not available on gcc $(HAIKU_GCC_VERSION[1])" ;
+			Echo "WebKit support not available on gcc"
+				"$(TARGET_GCC_VERSION_$(architecture)[1])" ;
 		} else {
-			Echo "WebKit to be utilized by gcc4 inside $(HAIKU_ALTERNATIVE_GCC_OUTPUT_DIR)" ;
+			Echo "WebKit to be utilized by gcc4 inside"
+				"$(HAIKU_ALTERNATIVE_GCC_OUTPUT_DIR)" ;
 		}
 	} else {
 		local zipFile = [ DownloadFile $(HAIKU_WEBKIT_FILE)

build/jam/FileRules

@@ -203,7 +203,8 @@ rule UnarchiveObjects
 
 actions UnarchiveObjects
 {
-	( cd $(1[1]:D) && $(TARGET_AR) $(TARGET_UNARFLAGS) "$(2)" $(1:BS) )
+	( cd $(1[1]:D) && $(TARGET_AR_$(TARGET_PACKAGING_ARCH)) \
+		$(TARGET_UNARFLAGS_$(TARGET_PACKAGING_ARCH)) "$(2)" $(1:BS) )
 }
 
 

build/jam/HaikuPackages

@@ -1,7 +1,6 @@
 # The packages we build. Each is defined in its own file in the packages/
 # subdirectory.
 local packages =
-	HaikuCrossDevel
 	HaikuDevel
 	HaikuLoader
 	HaikuUserguide
@@ -15,11 +14,26 @@ if $(HAIKU_BOOTSTRAP_BUILD) {
 	packages += Haiku ;
 }
 
+local archDependentPackages =
+	HaikuCrossDevel
+	;
+
 
 packages = $(packages:G=package-rules) ;
-SEARCH on $(packages) = [ FDirName $(HAIKU_BUILD_RULES_DIR) packages ] ;
+archDependentPackages = $(archDependentPackages:G=package-rules) ;
+SEARCH on $(packages) $(archDependentPackages)
+	= [ FDirName $(HAIKU_BUILD_RULES_DIR) packages ] ;
 
 local package ;
 for package in $(packages) {
 	include $(package) ;
 }
+
+for package in $(archDependentPackages) {
+	local architectureObject ;
+	for architectureObject in [ MultiArchSubDirSetup ] {
+		on $(architectureObject) {
+			include $(package) ;
+		}
+	}
+}

build/jam/HeadersRules

@@ -71,11 +71,13 @@ rule ObjectSysHdrs
 					[ FSysIncludes $(sysHeaders)
 						: $(HOST_SYSTEM_INCLUDES_OPTION) ] ;
 			} else {
+				local architecture = $(TARGET_PACKAGING_ARCH) ;
 				fileHeaders =
-					[ FIncludes $(HDRS) : $(TARGET_LOCAL_INCLUDES_OPTION) ]
+					[ FIncludes $(HDRS)
-					$(TARGET_INCLUDES_SEPARATOR)
+						: $(TARGET_LOCAL_INCLUDES_OPTION_$(architecture)) ]
+					$(TARGET_INCLUDES_SEPARATOR_$(architecture))
 					[ FSysIncludes $(sysHeaders)
-						: $(TARGET_SYSTEM_INCLUDES_OPTION) ] ;
+						: $(TARGET_SYSTEM_INCLUDES_OPTION_$(architecture)) ] ;
 			}
 
 			ASHDRS on $(file) = $(fileHeaders) ;
@@ -408,7 +410,8 @@ rule UsePrivateKernelHeaders
 
 rule UsePrivateSystemHeaders
 {
-	UseHeaders $(TARGET_PRIVATE_SYSTEM_HEADERS) : true ;
+	UseHeaders $(TARGET_PRIVATE_SYSTEM_HEADERS_$(TARGET_PACKAGING_ARCH))
+		: true ;
 }
 
 
@@ -440,7 +443,7 @@ rule FStandardOSHeaders
 }
 
 
-rule FStandardHeaders
+rule FStandardHeaders architecture
 {
 	local osIncludes = add-ons add-ons/file_system add-ons/graphics
 					   add-ons/input_server add-ons/registrar
@@ -453,14 +456,14 @@ rule FStandardHeaders
 
 	# The C++ headers. If specified, we use the compiler headers, otherwise
 	# the ones that come with our libstdc++.
-	if $(HAIKU_C++_HEADERS_DIR) {
+	if $(HAIKU_C++_HEADERS_DIR_$(architecture)) {
-		headers += $(HAIKU_C++_HEADERS_DIR) ;
+		headers += $(HAIKU_C++_HEADERS_DIR_$(architecture)) ;
 	} else {
 		headers += [ FDirName $(HAIKU_TOP) headers cpp ] ;
 	}
 
 	# GCC headers
-	headers += $(HAIKU_GCC_HEADERS_DIR) ;
+	headers += $(HAIKU_GCC_HEADERS_DIR_$(architecture)) ;
 
 	# Use headers directory, to allow to do things like include <posix/string.h>
 	headers += [ FDirName $(HAIKU_TOP) headers ] ;

build/jam/HelperRules

@@ -267,19 +267,19 @@ rule FAnalyzeGCCVersion
 	return $(version) ;
 }
 
-rule SetIncludePropertiesVariables
+rule SetIncludePropertiesVariables prefix : suffix
 {
-	# SetIncludePropertiesVariables <varPrefix> ;
+	# SetIncludePropertiesVariables <prefix> : <suffix> ;
 	#
-	local prefix = $(1) ;
+	suffix = $(suffix:E=) ;
-	if $($(prefix)_GCC_VERSION[1]) < 4 {
+	if $($(prefix)_GCC_VERSION$(suffix)[1]) < 4 {
-		$(prefix)_INCLUDES_SEPARATOR = -I- ;
+		$(prefix)_INCLUDES_SEPARATOR$(suffix) = -I- ;
-		$(prefix)_LOCAL_INCLUDES_OPTION = -I ;
+		$(prefix)_LOCAL_INCLUDES_OPTION$(suffix) = -I ;
-		$(prefix)_SYSTEM_INCLUDES_OPTION = -I ;
+		$(prefix)_SYSTEM_INCLUDES_OPTION$(suffix) = -I ;
 	} else {
-		$(prefix)_INCLUDES_SEPARATOR = ;
+		$(prefix)_INCLUDES_SEPARATOR$(suffix) = ;
-		$(prefix)_LOCAL_INCLUDES_OPTION = "-iquote " ;
+		$(prefix)_LOCAL_INCLUDES_OPTION$(suffix) = "-iquote " ;
-		$(prefix)_SYSTEM_INCLUDES_OPTION = "-I " ;
+		$(prefix)_SYSTEM_INCLUDES_OPTION$(suffix) = "-I " ;
 	}
 }
 

build/jam/KernelRules

@@ -23,8 +23,9 @@ rule SetupKernel
 		ObjectDefines $(object) : $(TARGET_KERNEL_DEFINES) ;
 
 		# override warning flags
-		TARGET_WARNING_CCFLAGS on $(object) = $(TARGET_KERNEL_WARNING_CCFLAGS) ;
+		TARGET_WARNING_CCFLAGS_$(TARGET_PACKAGING_ARCH) on $(object)
-		TARGET_WARNING_C++FLAGS on $(object)
+			= $(TARGET_KERNEL_WARNING_CCFLAGS) ;
+		TARGET_WARNING_C++FLAGS_$(TARGET_PACKAGING_ARCH) on $(object)
 			= $(TARGET_KERNEL_WARNING_C++FLAGS) ;
 	}
 }
@@ -39,7 +40,7 @@ rule KernelLd
 {
 	# KernelLd <name> : <objs> : <linkerscript> : <args> ;
 
-	LINK on $(1) = $(TARGET_LD) ;
+	LINK on $(1) = $(TARGET_LD_$(TARGET_PACKAGING_ARCH)) ;
 
 	LINKFLAGS on $(1) = $(4) ;
 	if $(3) { LINKFLAGS on $(1) += --script=$(3) ; }
@@ -92,7 +93,7 @@ actions KernelSo1
 	$(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR)
 
 	$(2[1]) --data $(2[2]) $(1) &&
-	$(HAIKU_ELFEDIT) --output-type dyn $(1)
+	$(HAIKU_ELFEDIT_$(TARGET_PACKAGING_ARCH)) --output-type dyn $(1)
 }
 
 rule KernelAddon
@@ -187,5 +188,5 @@ actions KernelStaticLibraryObjects
 	# Force recreation of the archive to avoid build errors caused by
 	# stale dependencies after renaming or deleting object files.
 	$(RM) "$(1)"
-	$(HAIKU_AR) -r "$(1)" "$(2)" ;
+	$(HAIKU_AR_$(TARGET_PACKAGING_ARCH)) -r "$(1)" "$(2)" ;
 }

build/jam/LocaleRules

@@ -32,13 +32,17 @@ rule ExtractCatalogEntries target : sources : signature : regexp
 			localIncludesOption = $(HOST_LOCAL_INCLUDES_OPTION) ;
 			systemIncludesOption = $(HOST_SYSTEM_INCLUDES_OPTION) ;
 		} else {
-			sysHeaders += $(TARGET_HDRS) ;
+			sysHeaders += $(TARGET_HDRS_$(TARGET_PACKAGING_ARCH)) ;
-			defines += $(TARGET_DEFINES) ;
+			defines += $(TARGET_DEFINES_$(TARGET_PACKAGING_ARCH))
-			cc = $(TARGET_CC) ;
+				$(TARGET_DEFINES) ;
-			
+			cc = $(TARGET_CC_$(TARGET_PACKAGING_ARCH)) ;
-			includesSeparator = $(TARGET_INCLUDES_SEPARATOR) ;
+
-			localIncludesOption = $(TARGET_LOCAL_INCLUDES_OPTION) ;
+			includesSeparator
-			systemIncludesOption = $(TARGET_SYSTEM_INCLUDES_OPTION) ;
+				= $(TARGET_INCLUDES_SEPARATOR_$(TARGET_PACKAGING_ARCH)) ;
+			localIncludesOption
+				= $(TARGET_LOCAL_INCLUDES_OPTION_$(TARGET_PACKAGING_ARCH)) ;
+			systemIncludesOption
+				= $(TARGET_SYSTEM_INCLUDES_OPTION_$(TARGET_PACKAGING_ARCH)) ;
 		}
 	}
 

build/jam/MainBuildRules

@@ -9,15 +9,10 @@ rule AddSharedObjectGlueCode
 	on $(1) {
 		platform = $(PLATFORM) ;
 		if $(platform) = haiku {
-			local stdLibs = libroot.so ;
+			local stdLibs = [ MultiArchDefaultGristFiles libroot.so ] ;
-			local beginGlue ;
+			local type = EXECUTABLE ;
-			local endGlue ;
+			if $(2) != true {
-			if $(2) = true {
+				type = LIBRARY ;
-				beginGlue += $(HAIKU_EXECUTABLE_BEGIN_GLUE_CODE) ;
-				endGlue += $(HAIKU_EXECUTABLE_END_GLUE_CODE) ;
-			} else {
-				beginGlue += $(HAIKU_LIBRARY_BEGIN_GLUE_CODE) ;
-				endGlue += $(HAIKU_LIBRARY_END_GLUE_CODE) ;
 
 				# special case for libroot: don't link it against itself
 				if $(DONT_LINK_AGAINST_LIBROOT) {
@@ -25,6 +20,11 @@ rule AddSharedObjectGlueCode
 				}
 			}
 
+			local beginGlue
+				= $(HAIKU_$(type)_BEGIN_GLUE_CODE_$(TARGET_PACKAGING_ARCH)) ;
+			local endGlue
+				= $(HAIKU_$(type)_END_GLUE_CODE_$(TARGET_PACKAGING_ARCH)) ;
+
 			LINK_BEGIN_GLUE on $(1) = $(beginGlue) ;
 			LINK_END_GLUE on $(1) = $(endGlue) ;
 
@@ -199,9 +199,9 @@ rule Ld
 			LINK on $(target) = $(HOST_LD) ;
 			LINKFLAGS on $(target) = $(HOST_LDFLAGS) $(LINKFLAGS) $(linkerFlags) ;
 		} else {
-			LINK on $(target) = $(TARGET_LD) ;
+			LINK on $(target) = $(TARGET_LD_$(TARGET_PACKAGING_ARCH)) ;
-			LINKFLAGS on $(target) = $(TARGET_LDFLAGS) $(LINKFLAGS)
+			LINKFLAGS on $(target) = $(TARGET_LDFLAGS_$(TARGET_PACKAGING_ARCH))
-				$(linkerFlags) ;
+				$(LINKFLAGS) $(linkerFlags) ;
 		}
 
 		NEEDLIBS on $(target) = $(NEEDLIBS) ;
@@ -265,8 +265,9 @@ rule CreateAsmStructOffsetsHeader header : source
 			}
 
 		} else {
-			sysHeaders += $(TARGET_HDRS) ;
+			sysHeaders += $(TARGET_HDRS_$(TARGET_PACKAGING_ARCH)) ;
-			defines += $(TARGET_DEFINES) ;
+			defines += $(TARGET_DEFINES_$(TARGET_PACKAGING_ARCH))
+				$(TARGET_DEFINES) ;
 		}
 
 		# optimization flags
@@ -299,18 +300,22 @@ rule CreateAsmStructOffsetsHeader header : source
 		} else {
 			# warning flags
 			if $(WARNINGS) != 0 {
-				flags += $(TARGET_WARNING_C++FLAGS) ;
+				flags += $(TARGET_WARNING_C++FLAGS_$(TARGET_PACKAGING_ARCH)) ;
 			}
 
 			# debug and other flags
-			flags += $(TARGET_C++FLAGS) $(TARGET_DEBUG_$(DEBUG)_C++FLAGS)
+			flags += $(TARGET_C++FLAGS_$(TARGET_PACKAGING_ARCH))
+				$(TARGET_DEBUG_$(DEBUG)_C++FLAGS_$(TARGET_PACKAGING_ARCH))
 				$(SUBDIRC++FLAGS) $(C++FLAGS) ;
 
-			C++ on $(header) = $(TARGET_C++) ;
+			C++ on $(header) = $(TARGET_C++_$(TARGET_PACKAGING_ARCH)) ;
 
-			includesSeparator = $(TARGET_INCLUDES_SEPARATOR) ;
+			includesSeparator
-			localIncludesOption = $(TARGET_LOCAL_INCLUDES_OPTION) ;
+				= $(TARGET_INCLUDES_SEPARATOR_$(TARGET_PACKAGING_ARCH)) ;
-			systemIncludesOption = $(TARGET_SYSTEM_INCLUDES_OPTION) ;
+			localIncludesOption
+				= $(TARGET_LOCAL_INCLUDES_OPTION_$(TARGET_PACKAGING_ARCH)) ;
+			systemIncludesOption
+				= $(TARGET_SYSTEM_INCLUDES_OPTION_$(TARGET_PACKAGING_ARCH)) ;
 		}
 	}
 
@@ -318,6 +323,7 @@ rule CreateAsmStructOffsetsHeader header : source
 	# for non-PODs. Since we're using the same compiler for the whole kernel and
 	# don't do virtual inheritence, that works well enough.
 	flags += -Wno-invalid-offsetof ;
+		# TODO: Rather get rid of the respective offsetof() instances.
 
 	# locate object, search for source, and set on target variables
 
@@ -366,8 +372,9 @@ rule MergeObjectFromObjects
 			LINK on $(1) = $(HOST_LD) ;
 			LINKFLAGS on $(target) = $(HOST_LDFLAGS) ;
 		} else {
-			LINK on $(1) = $(TARGET_LD) ;
+			LINK on $(1) = $(TARGET_LD_$(TARGET_PACKAGING_ARCH)) ;
-			LINKFLAGS on $(target) = $(TARGET_LDFLAGS) ;
+			LINKFLAGS on $(target)
+				= $(TARGET_LDFLAGS_$(TARGET_PACKAGING_ARCH)) ;
 		}
 	}
 
@@ -469,12 +476,12 @@ rule LinkAgainst
 
 	on $(target) {
 		# map libraries, if desired and target platform is Haiku
-		if $(PLATFORM) != host && $(mapLibs) = true
+		local map = $(TARGET_LIBRARY_NAME_MAP_$(TARGET_PACKAGING_ARCH)) ;
-				&& $(TARGET_LIBRARY_NAME_MAP) {
+		if $(PLATFORM) != host && $(mapLibs) = true && $(map) {
 			local mappedLibs ;
 
 			for i in $(libs) {
-				local mapped = $($(TARGET_LIBRARY_NAME_MAP)_$(i)) ;
+				local mapped = $($(map)_$(i)) ;
 				mapped ?= $(i) ;
 				mappedLibs += $(mapped) ;
 			}

build/jam/MiscRules

@@ -10,15 +10,21 @@ rule SetupObjectsDir
 	if $(relPath) = . {
 		relPath = ;
 	}
-	COMMON_PLATFORM_LOCATE_TARGET =
+
-		[ FDirName $(HAIKU_COMMON_PLATFORM_OBJECT_DIR) $(relPath) ] ;
+	COMMON_PLATFORM_LOCATE_TARGET
+		= [ FDirName $(HAIKU_COMMON_PLATFORM_OBJECT_DIR) $(relPath) ] ;
+	HOST_COMMON_ARCH_LOCATE_TARGET
+		= [ FDirName $(HOST_COMMON_ARCH_OBJECT_DIR) $(relPath) ] ;
+	TARGET_COMMON_ARCH_LOCATE_TARGET
+		= [ FDirName $(TARGET_COMMON_ARCH_OBJECT_DIR) $(relPath) ] ;
 
 	local var ;
-	for var in COMMON_ARCH COMMON_DEBUG DEBUG_$(HAIKU_DEBUG_LEVELS) {
+	for var in COMMON_DEBUG DEBUG_$(HAIKU_DEBUG_LEVELS) {
 		HOST_$(var)_LOCATE_TARGET
 			= [ FDirName $(HOST_$(var)_OBJECT_DIR) $(relPath) ] ;
 		TARGET_$(var)_LOCATE_TARGET
-			= [ FDirName $(TARGET_$(var)_OBJECT_DIR) $(relPath) ] ;
+			= [ FDirName $(TARGET_$(var)_OBJECT_DIR_$(TARGET_PACKAGING_ARCH))
+				$(relPath) ] ;
 	}
 
 	LOCATE_TARGET = $(COMMON_PLATFORM_LOCATE_TARGET) ;
@@ -71,58 +77,62 @@ rule SubIncludeGPL
 # pragma mark - MakeLocate variants
 
 
-rule MakeLocateCommonPlatform
+rule MakeLocateCommonPlatform files : subdir
 {
 	# The file is shared between all target platforms.
-	MakeLocate $(1) : $(COMMON_PLATFORM_LOCATE_TARGET) ;
+	MakeLocate $(files)
+		: [ FDirName $(COMMON_PLATFORM_LOCATE_TARGET) $(subdir) ] ;
 }
 
-rule MakeLocatePlatform
+rule MakeLocatePlatform files : subdir
 {
 	# The file is specific for the target platform, but
 	# architecture independent. Usually the right rule for generated
 	# sources, though sometimes sources can be architecture specific.
-	local files = $(1) ;
 	local file ;
 	for file in $(files) {
+		local directory ;
 		if [ on $(file) return $(PLATFORM) ] = host {
-			MakeLocate $(file) : $(HOST_COMMON_ARCH_LOCATE_TARGET) ;
+			directory = $(HOST_COMMON_ARCH_LOCATE_TARGET) ;
 		} else {
-			MakeLocate $(file) : $(TARGET_COMMON_ARCH_LOCATE_TARGET) ;
+			directory = $(TARGET_COMMON_ARCH_LOCATE_TARGET) ;
 		}
+		MakeLocate $(file) : [ FDirName $(directory) $(subdir) ] ;
 	}
 }
 
-rule MakeLocateArch
+rule MakeLocateArch files : subdir
 {
 	# The file is platform+architecture specific, but is debug
 	# level independent. This is usually the right rule for generated
 	# architecture specific data or source files.
-	local files = $(1) ;
 	local file ;
 	for file in $(files) {
+		local directory ;
 		if [ on $(file) return $(PLATFORM) ] = host {
-			MakeLocate $(file) : $(HOST_COMMON_DEBUG_LOCATE_TARGET) ;
+			directory = $(HOST_COMMON_DEBUG_LOCATE_TARGET) ;
 		} else {
-			MakeLocate $(file) : $(TARGET_COMMON_DEBUG_LOCATE_TARGET) ;
+			directory = $(TARGET_COMMON_DEBUG_LOCATE_TARGET) ;
 		}
+		MakeLocate $(file) : [ FDirName $(directory) $(subdir) ] ;
 	}
 }
 
-rule MakeLocateDebug
+rule MakeLocateDebug files : subdir
 {
 	# The file is platform+architecture+debug level specific.
 	# That's what should be used for compiled code.
-	local files = $(1) ;
 	local file ;
 	for file in $(files) {
+		local directory ;
 		on $(file) {
 			if $(PLATFORM) = host {
-				MakeLocate $(file) : $(HOST_DEBUG_$(DEBUG)_LOCATE_TARGET) ;
+				directory = $(HOST_DEBUG_$(DEBUG)_LOCATE_TARGET) ;
 			} else {
-				MakeLocate $(file) : $(TARGET_DEBUG_$(DEBUG)_LOCATE_TARGET) ;
+				directory = $(TARGET_DEBUG_$(DEBUG)_LOCATE_TARGET) ;
 			}
 		}
+		MakeLocate $(file) : [ FDirName $(directory) $(subdir) ] ;
 	}
 }
 

build/jam/OptionalPackages

@@ -48,7 +48,7 @@ if [ IsOptionalHaikuImagePackageAdded BeOSCompatibility ] {
 	if $(TARGET_ARCH) != x86 {
 		Echo "No optional package BeOSCompatibility available for"
 			"$(TARGET_ARCH)" ;
-	} else if $(HAIKU_GCC_VERSION[1]) >= 4 {
+	} else if $(TARGET_GCC_VERSION_$(TARGET_PACKAGING_ARCH)[1]) >= 4 {
 		Echo "No optional package BeOSCompatibility available for gcc4" ;
 	} else {
 		Echo "Warning: Adding BeOS compatibility symlinks. This will go away."
@@ -83,9 +83,9 @@ if [ IsOptionalHaikuImagePackageAdded Bluetooth ] {
 # 	AddSymlinkToHaikuImage home config settings deskbar menu Preferences
 # 		: /boot/system/preferences/Bluetooth ;
 # 	if [ IsOptionalHaikuImagePackageAdded DevelopmentMin ]
-# 		&& $(HAIKU_GCC_VERSION[1]) in 2 4 {
+# 		&& $(TARGET_GCC_VERSION_$(TARGET_PACKAGING_ARCH)[1]) in 2 4 {
 # 		local arch = $(TARGET_ARCH) ;
-# 		local abi = gcc$(HAIKU_GCC_VERSION[1]) ;
+# 		local abi = gcc$(TARGET_GCC_VERSION_$(TARGET_PACKAGING_ARCH)[1]) ;
 # 		AddSymlinkToHaikuImage system develop lib
 # 			: /system/lib libbluetooth.so ;
 # 	}
@@ -201,7 +201,7 @@ if [ IsOptionalHaikuImagePackageAdded NetFS ] {
 if [ IsOptionalHaikuImagePackageAdded UserlandFS ] {
 # TODO: Make this an actual package!
 # 	local arch = $(TARGET_ARCH) ;
-# 	local abi = gcc$(HAIKU_GCC_VERSION[1]) ;
+# 	local abi = gcc$(TARGET_GCC_VERSION_$(TARGET_PACKAGING_ARCH)[1]) ;
 # 
 # 	# kernel module
 # 	AddFilesToHaikuImage system add-ons kernel file_systems
@@ -220,9 +220,9 @@ if [ IsOptionalHaikuImagePackageAdded UserlandFS ] {
 # 
 # 	# development goodies
 # 	if [ IsOptionalHaikuImagePackageAdded DevelopmentMin ] {
-# 		if ! ( $(HAIKU_GCC_VERSION[1]) in 2 4 ) {
+# 		if ! ( $(TARGET_GCC_VERSION_$(TARGET_PACKAGING_ARCH)[1]) in 2 4 ) {
 # 			Exit "Optional package UserlandFS: Unsupported GCC version:"
-# 				$(HAIKU_GCC_VERSION[1]) ;
+# 				$(TARGET_GCC_VERSION_$(TARGET_PACKAGING_ARCH)[1]) ;
 # 		}
 # 
 # 		# library symlinks
@@ -255,9 +255,9 @@ if [ IsOptionalHaikuImagePackageAdded WebPositive ] {
 # TODO: Make this an actual package!
 # 	if $(TARGET_ARCH) != x86  && $(TARGET_ARCH) != x86_64 {
 # 		Echo "No optional package WebPositive available for $(TARGET_ARCH)" ;
-# 	} else if $(HAIKU_GCC_VERSION[1]) < 4 {
+# 	} else if $(TARGET_GCC_VERSION_$(TARGET_PACKAGING_ARCH)[1]) < 4 {
 # 		Echo "No optional package WebPositive available for gcc2" ;
-# 	} else if $(HAIKU_GCC_VERSION[1]) >= 4 {
+# 	} else if $(TARGET_GCC_VERSION_$(TARGET_PACKAGING_ARCH)[1]) >= 4 {
 # 		# TODO: Either we build a separate package for WebPositive or we
 # 		# incorporate it in haiku.hpkg.
 # 		AddFilesToHaikuHybridImage apps : WebPositive ;

build/jam/OverriddenJamRules

@@ -22,8 +22,8 @@ rule Link
 		LINK on $(1) = $(HOST_LINK) ;
 	 	LINKFLAGS on $(1) = $(HOST_LINKFLAGS) [ on $(1) return $(LINKFLAGS) ] ;
 	} else {
-		LINK on $(1) = $(TARGET_LINK) ;
+		LINK on $(1) = $(TARGET_LINK_$(TARGET_PACKAGING_ARCH)) ;
-	 	LINKFLAGS on $(1) = $(TARGET_LINKFLAGS)
+	 	LINKFLAGS on $(1) = $(TARGET_LINKFLAGS_$(TARGET_PACKAGING_ARCH))
 			[ on $(1) return $(LINKFLAGS) ] ;
 	}
 
@@ -106,8 +106,9 @@ rule Object
 			}
 
 		} else {
-			sysHeaders += $(TARGET_HDRS) ;
+			sysHeaders += $(TARGET_HDRS_$(TARGET_PACKAGING_ARCH)) ;
-			defines += $(TARGET_DEFINES) ;
+			defines += $(TARGET_DEFINES_$(TARGET_PACKAGING_ARCH))
+				$(TARGET_DEFINES) ;
 		}
 	}
 
@@ -194,13 +195,17 @@ rule As
 		systemIncludesOption = $(HOST_SYSTEM_INCLUDES_OPTION) ;
 
 	} else {
-		flags = [ on $(1) return $(TARGET_ASFLAGS) $(ASFLAGS) ] ;
+		flags = [ on $(1) return $(TARGET_ASFLAGS_$(architecture))
+			$(ASFLAGS) ] ;
 
-		CC on $(1) = $(TARGET_CC) ;
+		CC on $(1) = $(TARGET_CC_$(TARGET_PACKAGING_ARCH)) ;
 
-		includesSeparator = $(TARGET_INCLUDES_SEPARATOR) ;
+		includesSeparator
-		localIncludesOption = $(TARGET_LOCAL_INCLUDES_OPTION) ;
+			= $(TARGET_INCLUDES_SEPARATOR_$(TARGET_PACKAGING_ARCH)) ;
-		systemIncludesOption = $(TARGET_SYSTEM_INCLUDES_OPTION) ;
+		localIncludesOption
+			= $(TARGET_LOCAL_INCLUDES_OPTION_$(TARGET_PACKAGING_ARCH)) ;
+		systemIncludesOption
+			= $(TARGET_SYSTEM_INCLUDES_OPTION_$(TARGET_PACKAGING_ARCH)) ;
 	}
 
 	Depends $(<) : $(>) ;
@@ -294,18 +299,22 @@ rule Cc
 		} else {
 			# warning flags
 			if $(WARNINGS) != 0 {
-				flags += $(TARGET_WARNING_CCFLAGS) ;
+				flags += $(TARGET_WARNING_CCFLAGS_$(TARGET_PACKAGING_ARCH)) ;
 			}
 
 			# debug and other flags
-			flags += $(TARGET_CCFLAGS) $(TARGET_DEBUG_$(DEBUG)_CCFLAGS)
+			flags += $(TARGET_CCFLAGS_$(TARGET_PACKAGING_ARCH))
+				$(TARGET_DEBUG_$(DEBUG)_CCFLAGS_$(TARGET_PACKAGING_ARCH))
 				$(SUBDIRCCFLAGS) $(CCFLAGS) ;
 
-			CC on $(1) = $(TARGET_CC) ;
+			CC on $(1) = $(TARGET_CC_$(TARGET_PACKAGING_ARCH)) ;
 
-			includesSeparator = $(TARGET_INCLUDES_SEPARATOR) ;
+			includesSeparator
-			localIncludesOption = $(TARGET_LOCAL_INCLUDES_OPTION) ;
+				= $(TARGET_INCLUDES_SEPARATOR_$(TARGET_PACKAGING_ARCH)) ;
-			systemIncludesOption = $(TARGET_SYSTEM_INCLUDES_OPTION) ;
+			localIncludesOption
+				= $(TARGET_LOCAL_INCLUDES_OPTION_$(TARGET_PACKAGING_ARCH)) ;
+			systemIncludesOption
+				= $(TARGET_SYSTEM_INCLUDES_OPTION_$(TARGET_PACKAGING_ARCH)) ;
 		}
 
 		CCFLAGS on $(<) = $(flags) ;
@@ -361,18 +370,22 @@ rule C++
 		} else {
 			# warning flags
 			if $(WARNINGS) != 0 {
-				flags += $(TARGET_WARNING_C++FLAGS) ;
+				flags += $(TARGET_WARNING_C++FLAGS_$(TARGET_PACKAGING_ARCH)) ;
 			}
 
 			# debug and other flags
-			flags += $(TARGET_C++FLAGS) $(TARGET_DEBUG_$(DEBUG)_C++FLAGS)
+			flags += $(TARGET_C++FLAGS_$(TARGET_PACKAGING_ARCH))
+				$(TARGET_DEBUG_$(DEBUG)_C++FLAGS_$(TARGET_PACKAGING_ARCH))
 				$(SUBDIRC++FLAGS) $(C++FLAGS) ;
 
-			C++ on $(1) = $(TARGET_C++) ;
+			C++ on $(1) = $(TARGET_C++_$(TARGET_PACKAGING_ARCH)) ;
 
-			includesSeparator = $(TARGET_INCLUDES_SEPARATOR) ;
+			includesSeparator
-			localIncludesOption = $(TARGET_LOCAL_INCLUDES_OPTION) ;
+				= $(TARGET_INCLUDES_SEPARATOR_$(TARGET_PACKAGING_ARCH)) ;
-			systemIncludesOption = $(TARGET_SYSTEM_INCLUDES_OPTION) ;
+			localIncludesOption
+				= $(TARGET_LOCAL_INCLUDES_OPTION_$(TARGET_PACKAGING_ARCH)) ;
+			systemIncludesOption
+				= $(TARGET_SYSTEM_INCLUDES_OPTION_$(TARGET_PACKAGING_ARCH)) ;
 		}
 
 		C++FLAGS on $(<) = $(flags) ;
@@ -424,8 +437,9 @@ rule LibraryFromObjects
 			AR on $(_l) = $(HOST_AR) $(HOST_ARFLAGS) ;
 			RANLIB on $(_l) = $(HOST_RANLIB) ;
 		} else {
-			AR on $(_l) = $(TARGET_AR) $(TARGET_ARFLAGS) ;
+			AR on $(_l) = $(TARGET_AR_$(TARGET_PACKAGING_ARCH))
-			RANLIB on $(_l) = $(TARGET_RANLIB) ;
+				$(TARGET_ARFLAGS_$(TARGET_PACKAGING_ARCH)) ;
+			RANLIB on $(_l) = $(TARGET_RANLIB_$(TARGET_PACKAGING_ARCH)) ;
 		}
 
 		# library depends on its member objects
@@ -660,11 +674,13 @@ rule ObjectHdrs
 					[ FSysIncludes $(SYSHDRS)
 						: $(HOST_SYSTEM_INCLUDES_OPTION) ] ;
 			} else {
+				local architecture = $(TARGET_PACKAGING_ARCH) ;
 				fileHeaders =
-					[ FIncludes $(localHeaders) : $(TARGET_LOCAL_INCLUDES_OPTION) ]
+					[ FIncludes $(localHeaders)
-					$(TARGET_INCLUDES_SEPARATOR)
+						: $(TARGET_LOCAL_INCLUDES_OPTION_$(architecture)) ]
+					$(TARGET_INCLUDES_SEPARATOR_$(architecture))
 					[ FSysIncludes $(SYSHDRS)
-						: $(TARGET_SYSTEM_INCLUDES_OPTION) ] ;
+						: $(TARGET_SYSTEM_INCLUDES_OPTION_$(architecture)) ] ;
 			}
 
 			ASHDRS on $(file) = $(fileHeaders) ;

build/jam/PackageRules

@@ -29,17 +29,17 @@ rule HaikuPackage package
 }
 
 
-rule PreprocessPackageInfo source : directory
+rule PreprocessPackageInfo source : directory : architecture
 {
 	source = $(source:G=package-info-source) ;
 	SEARCH on $(source) +=
-		[ FDirName $(HAIKU_PACKAGE_INFOS_DIR) $(HAIKU_PACKAGING_ARCH) ]
+		[ FDirName $(HAIKU_PACKAGE_INFOS_DIR) $(architecture) ]
 		[ FDirName $(HAIKU_PACKAGE_INFOS_DIR) any ]
 		[ FDirName $(HAIKU_PACKAGE_INFOS_DIR) generic ] 
 	;
 
 	local target = $(source:BSG=package-info)-package-info ;
-	local defines = HAIKU_PACKAGING_ARCH=$(HAIKU_PACKAGING_ARCH) ;
+	local defines = HAIKU_PACKAGING_ARCH=$(architecture) ;
 	if $(HAIKU_BOOTSTRAP_BUILD) {
 		defines += HAIKU_BOOTSTRAP_BUILD ;
 		target = $(target)-bootstrap ;
@@ -64,14 +64,17 @@ actions PreprocessPackageInfo1
 
 rule BuildHaikuPackage package : packageInfo
 {
+	local architecture = $(HAIKU_PACKAGING_ARCH) ;
 	local grist = [ FHaikuPackageGrist $(package) ] ;
 
-	local tempDir = [ FDirName $(HAIKU_PACKAGES_BUILD_DIR) $(grist) ] ;
+	local tempDir
+		= [ FDirName $(HAIKU_PACKAGES_BUILD_DIR_$(architecture)) $(grist) ] ;
 	local scriptDir = [ FDirName $(tempDir) scripts ] ;
 
 	#  build the package info and locate the package
-	packageInfo = [ PreprocessPackageInfo $(packageInfo) : $(tempDir) ] ;
+	packageInfo = [ PreprocessPackageInfo $(packageInfo) : $(tempDir)
-	MakeLocate $(package) : $(HAIKU_PACKAGES_DIR) ;
+		: $(architecture) ] ;
+	MakeLocate $(package) : $(HAIKU_PACKAGES_DIR_$(architecture)) ;
 	Depends $(package) : $(packageInfo) ;
 
 	# prepare the script that initializes the shell variables
@@ -89,7 +92,7 @@ rule BuildHaikuPackage package : packageInfo
 		: [ on $(package) return $(HAIKU_PACKAGE_COMPRESSION_LEVEL) ] ;
 	AddVariableToScript $(script) : updateOnly
 		: [ on $(package) return $(HAIKU_CONTAINER_UPDATE_ONLY) ] ;
-	AddVariableToScript $(script) : cc : $(TARGET_CC) ;
+	AddVariableToScript $(script) : cc : $(TARGET_CC_$(architecture)) ;
 	AddTargetVariableToScript $(script) : <build>addattr ;
 	AddTargetVariableToScript $(script) : <build>copyattr ;
 	AddTargetVariableToScript $(script) : <mimedb>mime_db : mimeDB ;

build/jam/RepositoryRules

@@ -78,7 +78,7 @@ rule AddRepositoryPackages repository : architecture : packages : sourcePackages
 rule PackageRepository repository : architecture : anyPackages : packages
 	: sourcePackages : debugInfoPackages
 {
-	if $(architecture) != $(HAIKU_PACKAGING_ARCH) {
+	if $(architecture) != $(HAIKU_PACKAGING_ARCHS[1]) {
 		return ;
 	}
 
@@ -136,19 +136,20 @@ rule RemotePackageRepository repository : architecture : repositoryUrl
 
 	# build package list file
 	local packageListFile = $(repository:G=repository-package-list)-packages ;
-	MakeLocate $(packageListFile) : $(HAIKU_PACKAGE_REPOSITORIES_DIR) ;
+	local repositoriesDir = $(HAIKU_PACKAGE_REPOSITORIES_DIR_$(architecture)) ;
+	MakeLocate $(packageListFile) : $(repositoriesDir) ;
 	GeneratedRepositoryPackageList $(packageListFile) : $(repository) ;
 
 	# build package list checksum file
 	local packagesChecksumFile
 		= $(repository:G=repository-package-checksum)-checksum ;
-	MakeLocate $(packagesChecksumFile) : $(HAIKU_PACKAGE_REPOSITORIES_DIR) ;
+	MakeLocate $(packagesChecksumFile) : $(repositoriesDir) ;
 	Depends $(packagesChecksumFile) : $(packageListFile) ;
 	ChecksumFileSHA256 $(packagesChecksumFile) : $(packageListFile) ;
 
 	# download repository info file
 	local repositoryInfo = $(repository:G=repository-info)-info ;
-	MakeLocate $(repositoryInfo) : $(HAIKU_PACKAGE_REPOSITORIES_DIR) ;
+	MakeLocate $(repositoryInfo) : $(repositoriesDir) ;
 	local repoUrl = [ on $(repository) return $(HAIKU_REPOSITORY_URL) ] ;
 	DownloadLocatedFile $(repositoryInfo)
 		: "$(repoUrl)/`cat $source`/repo.info"
@@ -156,7 +157,7 @@ rule RemotePackageRepository repository : architecture : repositoryUrl
 
 	# download repository file
 	local repositoryFile = $(repository:G=repository-cache) ;
-	MakeLocate $(repositoryFile) : $(HAIKU_PACKAGE_REPOSITORIES_DIR) ;
+	MakeLocate $(repositoryFile) : $(repositoriesDir) ;
 	local repoUrl = [ on $(repository) return $(HAIKU_REPOSITORY_URL) ] ;
 	DownloadLocatedFile $(repositoryFile)
 		: "$(repoUrl)/`cat $source`/repo"
@@ -164,7 +165,7 @@ rule RemotePackageRepository repository : architecture : repositoryUrl
 
 	# build repository config file
 	local repositoryConfig = $(repository:G=repository-config)-config ;
-	MakeLocate $(repositoryConfig) : $(HAIKU_PACKAGE_REPOSITORIES_DIR) ;
+	MakeLocate $(repositoryConfig) : $(repositoriesDir) ;
 	RepositoryConfig $(repositoryConfig) : $(repositoryInfo)
 		: $(packagesChecksumFile) : $(repository) ;
 
@@ -314,9 +315,10 @@ OUTPUT_DIRECTORY="$(HAIKU_REPOSITORY_BUILD_DIRECTORY)"
 EOF
 
 	# If we have cross tools, add the cross tools directory.
-	gcc=$(HAIKU_CC)
+	gcc=$(HAIKU_CC_$(HAIKU_PACKAGING_ARCH))
 	if [[ "$gcc" = /* ]]; then
-		if [ `basename $gcc` = $(HAIKU_GCC_MACHINE)-gcc ]; then
+		if [ `basename $gcc` = \
+				$(HAIKU_GCC_MACHINE_$(HAIKU_PACKAGING_ARCH))-gcc ]; then
 			dir=`dirname $gcc`
 			dir=`dirname $dir`
 			echo CROSS_TOOLS="$dir" >> $(1)
@@ -344,17 +346,18 @@ rule BootstrapPackageRepository repository : architecture
 		return ;
 	}
 	HAIKU_REPOSITORY_HAIKU_CROSS_DEVEL_PACKAGE on $(stage1PackageTargets)
-		= haiku_cross_devel_sysroot_stage1_$(HAIKU_PACKAGING_ARCH).hpkg ;
+		= haiku_cross_devel_sysroot_stage1_$(architecture).hpkg ;
 
 	# add stage 2 packages
 	local stage2PackageTargets = [ AddRepositoryPackages $(repository)
 		: $(architecture) : $(packagesStage2) : $(sourcePackages)
 		: $(debugInfoPackages) ] ;
 	HAIKU_REPOSITORY_HAIKU_CROSS_DEVEL_PACKAGE on $(stage2PackageTargets)
-		= haiku_cross_devel_sysroot_$(HAIKU_PACKAGING_ARCH).hpkg ;
+		= haiku_cross_devel_sysroot_$(architecture).hpkg ;
 
 	# prepare the config file for the HaikuPorts cross build
-	local outputDir = [ FDirName $(HAIKU_PACKAGE_REPOSITORIES_DIR)
+	local outputDir = [ FDirName
+		$(HAIKU_PACKAGE_REPOSITORIES_DIR_$(architecture))
 		$(repository:G=)-build ] ;
 	local configFile = haikuports.conf ;
 	configFile = $(configFile:G=repository-config-$(repository:G=)) ;
@@ -362,6 +365,7 @@ rule BootstrapPackageRepository repository : architecture
 	NoUpdate $(configFile) ;
 	Depends $(configFile) : <build>package <build>mimeset <mimedb>mime_db ;
 	HAIKU_REPOSITORY_BUILD_DIRECTORY on $(configFile) = $(outputDir) ;
+	HAIKU_PACKAGING_ARCH on $(configFile) = $(architecture) ;
 	BuildBootstrapRepositoryConfig $(configFile)
 		: <build>package <build>mimeset <mimedb>mime_db ;
 

build/jam/UserBuildConfig.ReadMe

@@ -20,7 +20,7 @@ Exit You must NOT copy UserBuildConfig.ReadMe directly but use parts of it! ;
 #	CCFLAGS C++FLAGS DEBUG DEFINES HDRS LINKFLAGS OPTIM OPTIMIZE SYSHDRS
 #	WARNINGS
 #	HOST_WARNING_CCFLAGS HOST_WARNING_C++FLAGS
-#	TARGET_WARNING_CCFLAGS TARGET_WARNING_C++FLAGS
+#	TARGET_WARNING_CCFLAGS_<packageArch> TARGET_WARNING_C++FLAGS_<packageArch>
 #	PLATFORM SUPPORTED_PLATFORMS
 #
 # The following examples would work analogously for any of these variables.

build/jam/board/beagle/BoardSetup

@@ -64,7 +64,7 @@ HAIKU_BOARD_SDIMAGE_FILES =
 
 HAIKU_KERNEL_CCFLAGS += -mcpu=cortex-a8 -mfpu=vfp -mfloat-abi=soft ;
 HAIKU_KERNEL_C++FLAGS += -mcpu=cortex-a8 -mfpu=vfp -mfloat-abi=soft ;
-HAIKU_CCFLAGS += -mcpu=cortex-a8 -mfpu=vfp -mfloat-abi=soft ;
+HAIKU_CCFLAGS_$(HAIKU_PACKAGING_ARCH)
-HAIKU_C++FLAGS += -mcpu=cortex-a8 -mfpu=vfp -mfloat-abi=soft ;
+	+= -mcpu=cortex-a8 -mfpu=vfp -mfloat-abi=soft ;
-
+HAIKU_C++FLAGS_$(HAIKU_PACKAGING_ARCH)
-
+	+= -mcpu=cortex-a8 -mfpu=vfp -mfloat-abi=soft ;

build/jam/board/neo_freerunner/BoardSetup

@@ -71,15 +71,15 @@ HAIKU_BOARD_SDIMAGE_FILES =
 
 HAIKU_KERNEL_CCFLAGS += -mcpu=arm920t ;
 HAIKU_KERNEL_C++FLAGS += -mcpu=arm920t ;
-HAIKU_CCFLAGS += -mcpu=arm920t ;
+HAIKU_CCFLAGS_$(HAIKU_PACKAGING_ARCH) += -mcpu=arm920t ;
-HAIKU_C++FLAGS += -mcpu=arm920t ;
+HAIKU_C++FLAGS_$(HAIKU_PACKAGING_ARCH) += -mcpu=arm920t ;
 
 # Workaround for ld using 32k for alignment despite forcing it in the config...
 # should definitely not be needed!
 HAIKU_KERNEL_LINKFLAGS +=
 	-Wl,-z -Wl,max-page-size=0x1000
 	-Wl,-z -Wl,common-page-size=0x1000 ;
-HAIKU_LINKFLAGS +=
+HAIKU_LINKFLAGS_$(HAIKU_PACKAGING_ARCH) +=
 	-Wl,-z -Wl,max-page-size=0x1000
 	-Wl,-z -Wl,common-page-size=0x1000 ;
 

build/jam/board/overo/BoardSetup

@@ -60,7 +60,7 @@ HAIKU_BOARD_SDIMAGE_FILES =
 
 HAIKU_KERNEL_CCFLAGS += -mcpu=cortex-a8 -mfpu=vfp -mfloat-abi=soft ;
 HAIKU_KERNEL_C++FLAGS += -mcpu=cortex-a8 -mfpu=vfp -mfloat-abi=soft ;
-HAIKU_CCFLAGS += -mcpu=cortex-a8 -mfpu=vfp -mfloat-abi=soft ;
+HAIKU_CCFLAGS_$(HAIKU_PACKAGING_ARCH)
-HAIKU_C++FLAGS += -mcpu=cortex-a8 -mfpu=vfp -mfloat-abi=soft ;
+	+= -mcpu=cortex-a8 -mfpu=vfp -mfloat-abi=soft ;
-
+HAIKU_C++FLAGS_$(HAIKU_PACKAGING_ARCH)
-
+	+= -mcpu=cortex-a8 -mfpu=vfp -mfloat-abi=soft ;

build/jam/board/raspberry_pi/BoardSetup

@@ -48,15 +48,15 @@ HAIKU_BOARD_SDIMAGE_SIZE = 256 ;
 
 HAIKU_KERNEL_CCFLAGS += -mtune=arm1176jzf-s ;
 HAIKU_KERNEL_C++FLAGS += -mtune=arm1176jzf-s ;
-HAIKU_CCFLAGS += -mtune=arm1176jzf-s ;
+HAIKU_CCFLAGS_$(HAIKU_PACKAGING_ARCH) += -mtune=arm1176jzf-s ;
-HAIKU_C++FLAGS += -mtune=arm1176jzf-s ;
+HAIKU_C++FLAGS_$(HAIKU_PACKAGING_ARCH) += -mtune=arm1176jzf-s ;
 
 # Workaround for ld using 32k for alignment despite forcing it in the config...
 # should definitely not be needed!
 HAIKU_KERNEL_LINKFLAGS +=
 	-Wl,-z -Wl,max-page-size=0x1000
 	-Wl,-z -Wl,common-page-size=0x1000 ;
-HAIKU_LINKFLAGS +=
+HAIKU_LINKFLAGS_$(HAIKU_PACKAGING_ARCH) +=
 	-Wl,-z -Wl,max-page-size=0x1000
 	-Wl,-z -Wl,common-page-size=0x1000 ;
 

build/jam/board/sam460ex/BoardSetup

@@ -34,6 +34,5 @@ HAIKU_KERNEL_PIC_CCFLAGS += -mcpu=440fp -mtune=440fp ;
 HAIKU_KERNEL_PIC_C++FLAGS += -mcpu=440fp -mtune=440fp ;
 HAIKU_KERNEL_CCFLAGS += -mcpu=440fp -mtune=440fp ;
 HAIKU_KERNEL_C++FLAGS += -mcpu=440fp -mtune=440fp ;
-HAIKU_CCFLAGS += -mcpu=440fp -mtune=440fp ;
+HAIKU_CCFLAGS_$(HAIKU_PACKAGING_ARCH) += -mcpu=440fp -mtune=440fp ;
-HAIKU_C++FLAGS += -mcpu=440fp -mtune=440fp ;
+HAIKU_C++FLAGS_$(HAIKU_PACKAGING_ARCH) += -mcpu=440fp -mtune=440fp ;
-

build/jam/board/verdex/BoardSetup

@@ -70,15 +70,14 @@ HAIKU_BOARD_SDIMAGE_FILES =
 
 HAIKU_KERNEL_CCFLAGS += -mcpu=xscale ;
 HAIKU_KERNEL_C++FLAGS += -mcpu=xscale ;
-HAIKU_CCFLAGS += -mcpu=xscale ;
+HAIKU_CCFLAGS_$(HAIKU_PACKAGING_ARCH) += -mcpu=xscale ;
-HAIKU_C++FLAGS += -mcpu=xscale ;
+HAIKU_C++FLAGS_$(HAIKU_PACKAGING_ARCH) += -mcpu=xscale ;
 
 # Workaround for ld using 32k for alignment despite forcing it in the config...
 # should definitely not be needed!
 HAIKU_KERNEL_LINKFLAGS +=
 	-Wl,-z -Wl,max-page-size=0x1000
 	-Wl,-z -Wl,common-page-size=0x1000 ;
-HAIKU_LINKFLAGS +=
+HAIKU_LINKFLAGS_$(HAIKU_PACKAGING_ARCH) +=
 	-Wl,-z -Wl,max-page-size=0x1000
 	-Wl,-z -Wl,common-page-size=0x1000 ;
-

build/jam/images/HaikuImage

@@ -73,7 +73,8 @@ SYSTEM_LIBS = [ FFilterByBuildFeatures
 	<revisioned>libroot.so
 	libscreensaver.so
 	libtextencoding.so libtiff.so libtracker.so libtranslation.so
-	$(HAIKU_SHARED_LIBSTDC++) $(HAIKU_SHARED_LIBSUPC++)
+	$(HAIKU_SHARED_LIBSTDC++_$(HAIKU_PACKAGING_ARCH))
+	$(HAIKU_SHARED_LIBSUPC++_$(HAIKU_PACKAGING_ARCH))
 ] ;
 PRIVATE_SYSTEM_LIBS = [ FFilterByBuildFeatures
 	libalm.so

build/jam/images/HaikuImageBootstrap

@@ -69,7 +69,8 @@ SYSTEM_LIBS = [ FFilterByBuildFeatures
 	<revisioned>libroot.so
 	libscreensaver.so
 	libtextencoding.so libtracker.so libtranslation.so
-	$(HAIKU_SHARED_LIBSTDC++) $(HAIKU_SHARED_LIBSUPC++)
+	$(HAIKU_SHARED_LIBSTDC++_$(HAIKU_PACKAGING_ARCH))
+	$(HAIKU_SHARED_LIBSUPC++_$(HAIKU_PACKAGING_ARCH))
 ] ;
 PRIVATE_SYSTEM_LIBS = [ FFilterByBuildFeatures
 	libalm.so

build/jam/packages/Haiku

@@ -1,3 +1,6 @@
+local architecture = $(HAIKU_PACKAGING_ARCHS[1]) ;
+
+
 local haikuPackage = haiku.hpkg ;
 HaikuPackage $(haikuPackage) ;
 
@@ -89,7 +92,7 @@ AddLibrariesToPackage lib : $(SYSTEM_LIBS) $(PRIVATE_SYSTEM_LIBS) ;
 # libnetwork.so replaces quite a few libraries
 SYSTEM_LIBS_LIBNETWORK_ALIASES = libsocket.so libbind.so libnet.so ;
 
-if $(HAIKU_GCC_VERSION[1]) = 2 {
+if $(HAIKU_GCC_VERSION_$(architecture)[1]) = 2 {
 	local lib ;
 	for lib in $(SYSTEM_LIBS_LIBNETWORK_ALIASES) {
 		AddSymlinkToPackage lib : libnetwork.so : $(lib) ;

build/jam/packages/HaikuBootstrap

@@ -1,3 +1,6 @@
+local architecture = $(HAIKU_PACKAGING_ARCHS[1]) ;
+
+
 local haikuPackage = haiku.hpkg ;
 HaikuPackage $(haikuPackage) ;
 
@@ -88,7 +91,7 @@ AddLibrariesToPackage lib : $(SYSTEM_LIBS) $(PRIVATE_SYSTEM_LIBS) ;
 # libnetwork.so replaces quite a few libraries
 SYSTEM_LIBS_LIBNETWORK_ALIASES = libsocket.so libbind.so libnet.so ;
 
-if $(HAIKU_GCC_VERSION[1]) = 2 {
+if $(HAIKU_GCC_VERSION_$(architecture)[1]) = 2 {
 	local lib ;
 	for lib in $(SYSTEM_LIBS_LIBNETWORK_ALIASES) {
 		AddSymlinkToPackage lib : libnetwork.so : $(lib) ;

build/jam/packages/HaikuCrossDevel

@@ -4,44 +4,54 @@
 # The main use of this package is to provide HaikuPorter with a development
 # environment for a cross-build Haiku platform.
 
+local architecture = $(TARGET_PACKAGING_ARCH) ;
+local isPrimaryArchitecture = [ MultiArchIfPrimary 1 : ] ;
+
+
 local additionalLibraries_stage1 ;
-local additionalLibraries = libbe.so libnetwork.so libpackage.so ;
+local additionalLibraries
+	= [ MultiArchDefaultGristFiles libbe.so libnetwork.so libpackage.so ] ;
 
 local stage ;
 for stage in _stage1 "" {
 	# first create the actual cross development package
 
 	local haikuCrossDevelSysrootPackage
-		= haiku_cross_devel_sysroot$(stage)_$(HAIKU_PACKAGING_ARCH).hpkg ;
+		= haiku_cross_devel_sysroot$(stage)_$(architecture).hpkg ;
 	HaikuPackage $(haikuCrossDevelSysrootPackage) ;
 
 	local developCrossLibDirTokens = develop lib ;
 
 	# glue code
 	AddFilesToPackage $(developCrossLibDirTokens) :
-		<src!system!glue!arch!$(TARGET_ARCH)>crti.o
+		<src!system!glue!arch!$(TARGET_ARCH)!$(architecture)>crti.o
-		<src!system!glue!arch!$(TARGET_ARCH)>crtn.o
+		<src!system!glue!arch!$(TARGET_ARCH)!$(architecture)>crtn.o
-		<src!system!glue>init_term_dyn.o
+		<src!system!glue!$(architecture)>init_term_dyn.o
-		<src!system!glue>start_dyn.o
+		<src!system!glue!$(architecture)>start_dyn.o
-		<src!system!glue>haiku_version_glue.o
+		<src!system!glue!$(architecture)>haiku_version_glue.o
-	;
+		;
 
 	# kernel
-	AddFilesToPackage $(developCrossLibDirTokens) : kernel.so : _KERNEL_ ;
+	if $(isPrimaryArchitecture) {
+		AddFilesToPackage $(developCrossLibDirTokens) : kernel.so : _KERNEL_ ;
+	}
 
 	# libraries
 	AddLibrariesToPackage $(developCrossLibDirTokens) :
-		libbsd.so
+		[ MultiArchDefaultGristFiles libbsd.so ]
-		<revisioned>libroot.so
+		[ MultiArchDefaultGristFiles libroot.so : revisioned ]
-		$(HAIKU_SHARED_LIBSTDC++) $(HAIKU_SHARED_LIBSUPC++)
+		$(HAIKU_SHARED_LIBSTDC++_$(architecture))
+		$(HAIKU_SHARED_LIBSUPC++_$(architecture))
 		$(additionalLibraries$(stage))
-	;
+		;
 
 	# static libraries
-	AddFilesToPackage $(developCrossLibDirTokens) : liblocalestub.a ;
+	AddFilesToPackage $(developCrossLibDirTokens)
+		: <$(architecture)>liblocalestub.a ;
 
 	# the POSIX error code mapper library
-	AddFilesToPackage $(developCrossLibDirTokens) : libposix_error_mapper.a ;
+	AddFilesToPackage $(developCrossLibDirTokens)
+		: [ MultiArchDefaultGristFiles libposix_error_mapper.a ] ;
 
 	# headers
 	local developCrossHeadersDirTokens = develop headers ;
@@ -58,7 +68,7 @@ for stage in _stage1 "" {
 	}
 
 	# cpp headers
-	if $(HAIKU_GCC_VERSION[1]) = 2 {
+	if $(HAIKU_GCC_VERSION_$(architecture)[1]) = 2 {
 		# GCC 2 only -- for GCC 4 they come with the DevelopmentBase package
 		CopyDirectoryToPackage $(developCrossHeadersDirTokens) c++
 			: [ FDirName $(HAIKU_TOP) headers cpp ] : 2.95.3 ;
@@ -73,7 +83,7 @@ for stage in _stage1 "" {
 	# it when needed.
 
 	local haikuCrossDevelPackage 
-		= haiku_cross_devel$(stage)_$(HAIKU_PACKAGING_ARCH).hpkg ;
+		= haiku_cross_devel$(stage)_$(architecture).hpkg ;
 	HaikuPackage $(haikuCrossDevelPackage) ;
 
 	# add the wrapped package

build/jam/packages/HaikuDevel

@@ -1,3 +1,6 @@
+local architecture = $(HAIKU_PACKAGING_ARCHS[1]) ;
+
+
 local haikuDevelPackage = haiku_devel.hpkg ;
 HaikuPackage $(haikuDevelPackage) ;
 
@@ -6,12 +9,12 @@ local developDirTokens = develop ;
 
 # glue code
 AddFilesToPackage $(developDirTokens) lib :
-	<src!system!glue!arch!$(arch)>crti.o
+	<src!system!glue!arch!$(arch)!$(architecture)>crti.o
-	<src!system!glue!arch!$(arch)>crtn.o
+	<src!system!glue!arch!$(arch)!$(architecture)>crtn.o
-	<src!system!glue>init_term_dyn.o
+	<src!system!glue!$(architecture)>init_term_dyn.o
-	<src!system!glue>start_dyn.o
+	<src!system!glue!$(architecture)>start_dyn.o
-	<src!system!glue>haiku_version_glue.o
+	<src!system!glue!$(architecture)>haiku_version_glue.o
-;
+	;
 
 # kernel
 AddFilesToPackage $(developDirTokens) lib : kernel.so : _KERNEL_ ;
@@ -33,7 +36,7 @@ for lib in $(SYSTEM_LIBS) $(developmentLibs) {
 }
 
 # static libraries
-AddFilesToPackage $(developDirTokens) lib : liblocalestub.a ;
+AddFilesToPackage $(developDirTokens) lib : <$(architecture)>liblocalestub.a ;
 
 # the POSIX error code mapper library
 AddFilesToPackage $(developDirTokens) lib : libposix_error_mapper.a ;
@@ -73,7 +76,7 @@ if ! $(HAIKU_BOOTSTRAP_BUILD) {
 }
 
 # cpp headers
-if $(HAIKU_GCC_VERSION[1]) = 2 {
+if $(HAIKU_GCC_VERSION_$(architecture)[1]) = 2 {
 	# GCC 2 only -- for GCC 4 they come with the DevelopmentBase package
 	CopyDirectoryToPackage $(developDirTokens) headers c++
 		: [ FDirName $(HAIKU_TOP) headers cpp ] : 2.95.3 ;

src/add-ons/disk_systems/bfs/Jamfile

@@ -13,7 +13,7 @@ Addon <disk_system>bfs :
 
 	bfs_disk_system.cpp
 
-	: be $(HAIKU_LOCALE_LIBS) $(TARGET_LIBSUPC++) libshared.a
+	: be localestub $(TARGET_LIBSUPC++) libshared.a
 ;
 
 DoCatalogs <disk_system>bfs :

src/add-ons/disk_systems/intel/Jamfile

@@ -23,7 +23,7 @@ Addon <disk_system>intel :
 	# kernel sources
 	PartitionMap.cpp
 
-	: be libshared.a $(HAIKU_LOCALE_LIBS) $(TARGET_LIBSUPC++)
+	: be libshared.a localestub $(TARGET_LIBSUPC++)
 ;
 
 DoCatalogs <disk_system>intel :

src/add-ons/disk_systems/ntfs/Jamfile

@@ -11,7 +11,7 @@ Addon <disk_system>ntfs :
 	NTFSAddOn.cpp
 	InitializeParameterEditor.cpp
 
-	: be $(HAIKU_LOCALE_LIBS) $(TARGET_LIBSUPC++) libshared.a
+	: be localestub $(TARGET_LIBSUPC++) libshared.a
 ;
 
 DoCatalogs <disk_system>ntfs :

src/add-ons/input_server/devices/keyboard/Jamfile

@@ -14,7 +14,7 @@ Addon <input>keyboard :
 	TeamMonitorWindow.cpp
 	TeamListItem.cpp
 
-	: input_server be libshared.a $(HAIKU_LOCALE_LIBS) $(TARGET_LIBSUPC++) ;
+	: input_server be libshared.a localestub $(TARGET_LIBSUPC++) ;
 
 DoCatalogs <input>keyboard :
 	x-vnd.Haiku-KeyboardInputServerDevice

src/add-ons/input_server/methods/canna/lib/Jamfile

@@ -3,8 +3,9 @@ SubDir HAIKU_TOP src add-ons input_server methods canna lib ;
 SetSubDirSupportedPlatformsBeOSCompatible ;
 
 # filter warnings we don't want here
-TARGET_WARNING_CCFLAGS = [ FFilter $(TARGET_WARNING_CCFLAGS)
+TARGET_WARNING_CCFLAGS_$(TARGET_PACKAGING_ARCH)
-	: -Wmissing-prototypes ] ;
+	= [ FFilter $(TARGET_WARNING_CCFLAGS_$(TARGET_PACKAGING_ARCH))
+		: -Wmissing-prototypes ] ;
 
 SubDirCcFlags -x c++ -ansi -trigraphs -funsigned-char -funsigned-bitfields -w -Wno-multichar -Wno-ctor-dtor-privacy -pedantic -Wno-long-long -Woverloaded-virtual -D_BUILDING_CANNALIB -D_WCHAR_T ;
 

src/add-ons/input_server/methods/canna/rk/Jamfile

@@ -3,8 +3,9 @@ SubDir HAIKU_TOP src add-ons input_server methods canna rk ;
 SetSubDirSupportedPlatformsBeOSCompatible ;
 
 # filter warnings we don't want here
-TARGET_WARNING_CCFLAGS = [ FFilter $(TARGET_WARNING_CCFLAGS)
+TARGET_WARNING_CCFLAGS_$(TARGET_PACKAGING_ARCH)
-        : -Wmissing-prototypes ] ;
+	= [ FFilter $(TARGET_WARNING_CCFLAGS_$(TARGET_PACKAGING_ARCH))
+		: -Wmissing-prototypes ] ;
 
 SubDirCcFlags -x c++ -ansi -trigraphs -funsigned-char -funsigned-bitfields -w -Wno-multichar -Wno-ctor-dtor-privacy -pedantic -Wno-long-long -Woverloaded-virtual -D_BUILDING_CANNALIB -D_WCHAR_T ;
 

src/add-ons/kernel/bus_managers/pci/Jamfile

@@ -17,7 +17,8 @@ KernelAddon pci :
 
 # pci_info.cpp currently needs pcihdr.h so we make its path available and adds dependency
 ObjectHdrs [ FGristFiles pci_info$(SUFOBJ) ]
-	: [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR) apps devices ] ;
+	: [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR_$(TARGET_PACKAGING_ARCH)) apps
+		devices ] ;
 Includes [ FGristFiles pci_info.cpp ] : <src!apps!devices>pcihdr.h ;
 
 SubInclude HAIKU_TOP src add-ons kernel bus_managers pci arch

src/add-ons/kernel/drivers/network/3com/dev/mii/Jamfile

@@ -17,7 +17,7 @@ KernelStaticLibrary 3com_mii.a
 	;
 
 ObjectHdrs [ FGristFiles bmtphy$(SUFOBJ) ukphy$(SUFOBJ) ]
-	: [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR) libs compat
+	: [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR_$(TARGET_PACKAGING_ARCH)) libs
-			freebsd_network ] ;
+		compat freebsd_network ] ;
 Includes [ FGristFiles bmtphy.c ukphy.c ]
 	: <src!libs!compat!freebsd_network>miidevs.h ;

src/add-ons/kernel/drivers/network/3com/dev/xl/Jamfile

@@ -16,7 +16,7 @@ KernelAddon 3com :
 	;
 
 ObjectHdrs [ FGristFiles xlphy$(SUFOBJ) ]
-	: [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR) libs compat
+	: [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR_$(TARGET_PACKAGING_ARCH)) libs
-			freebsd_network ] ;
+		compat freebsd_network ] ;
 Includes [ FGristFiles xlphy.c ]
 	: <src!libs!compat!freebsd_network>miidevs.h ;

src/add-ons/kernel/drivers/network/attansic_l1/dev/mii/Jamfile

@@ -14,7 +14,7 @@ KernelStaticLibrary atl1_mii.a
 	;
 
 ObjectHdrs [ FGristFiles atphy$(SUFOBJ) ]
-	: [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR) libs compat
+	: [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR_$(TARGET_PACKAGING_ARCH)) libs
-			freebsd_network ] ;
+		compat freebsd_network ] ;
 Includes [ FGristFiles atphy.c ]
 	: <src!libs!compat!freebsd_network>miidevs.h ;

src/add-ons/kernel/drivers/network/broadcom440x/dev/mii/Jamfile

@@ -14,5 +14,6 @@ KernelStaticLibrary broadcom440x_mii.a
 	;
 
 ObjectHdrs [ FGristFiles bmtphy$(SUFOBJ) ]
-	: [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR) libs compat freebsd_network ] ;
+	: [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR_$(TARGET_PACKAGING_ARCH)) libs
+		compat freebsd_network ] ;
 Includes [ FGristFiles bmtphy.c ] : <src!libs!compat!freebsd_network>miidevs.h ;

src/add-ons/kernel/drivers/network/broadcom570x/dev/bge/Jamfile

@@ -16,5 +16,6 @@ KernelAddon broadcom570x :
 	;
 
 ObjectHdrs [ FGristFiles if_bge$(SUFOBJ) ]
-	: [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR) libs compat freebsd_network ] ;
+	: [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR_$(TARGET_PACKAGING_ARCH)) libs
+		compat freebsd_network ] ;
 Includes [ FGristFiles if_bge.c ] : <src!libs!compat!freebsd_network>miidevs.h ;

src/add-ons/kernel/drivers/network/broadcom570x/dev/mii/Jamfile

@@ -16,5 +16,6 @@ KernelStaticLibrary broadcom570x_mii.a
 	;
 
 ObjectHdrs [ FGristFiles brgphy$(SUFOBJ) ]
-	: [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR) libs compat freebsd_network ] ;
+	: [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR_$(TARGET_PACKAGING_ARCH)) libs
+		compat freebsd_network ] ;
 Includes [ FGristFiles brgphy.c ] : <src!libs!compat!freebsd_network>miidevs.h ;

src/add-ons/kernel/drivers/network/dec21xxx/dev/dc/Jamfile

@@ -18,6 +18,7 @@ KernelAddon dec21xxx :
 	;
 
 ObjectHdrs [ FGristFiles dcphy$(SUFOBJ)	pnphy$(SUFOBJ) ]
-	: [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR) libs compat freebsd_network ] ;
+	: [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR_$(TARGET_PACKAGING_ARCH)) libs
+		compat freebsd_network ] ;
 Includes [ FGristFiles dcphy.c pnphy.c ]
 	: <src!libs!compat!freebsd_network>miidevs.h ;

src/add-ons/kernel/drivers/network/dec21xxx/dev/de/Jamfile

@@ -15,4 +15,5 @@ KernelStaticLibrary dec21xxx_de.a
 	;
 
 ObjectHdrs [ FGristFiles if_de$(SUFOBJ) ]
-	: [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR) libs compat freebsd_network ] ;
+	: [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR_$(TARGET_PACKAGING_ARCH)) libs
+		compat freebsd_network ] ;

src/add-ons/kernel/drivers/network/dec21xxx/dev/mii/Jamfile

@@ -18,6 +18,7 @@ KernelStaticLibrary dec21xxx_mii.a
 	;
 
 ObjectHdrs [ FGristFiles acphy$(SUFOBJ) amphy$(SUFOBJ) ukphy$(SUFOBJ) ]
-	: [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR) libs compat freebsd_network ] ;
+	: [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR_$(TARGET_PACKAGING_ARCH)) libs
+		compat freebsd_network ] ;
 Includes [ FGristFiles acphy.c amphy.c amphy.c ]
 	: <src!libs!compat!freebsd_network>miidevs.h ;

src/add-ons/kernel/drivers/network/ipro100/dev/fxp/Jamfile

@@ -16,5 +16,6 @@ KernelAddon ipro100 :
 	;
 
 ObjectHdrs [ FGristFiles inphy$(SUFOBJ) ]
-	: [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR) libs compat freebsd_network ] ;
+	: [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR_$(TARGET_PACKAGING_ARCH)) libs
+		compat freebsd_network ] ;
 Includes [ FGristFiles inphy.c ] : <src!libs!compat!freebsd_network>miidevs.h ;

src/add-ons/kernel/drivers/network/jmicron2x0/dev/mii/Jamfile

@@ -14,5 +14,6 @@ KernelStaticLibrary jmicron2x0_mii.a
 	;
 
 ObjectHdrs [ FGristFiles jmphy$(SUFOBJ) ]
-	: [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR) libs compat freebsd_network ] ;
+	: [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR_$(TARGET_PACKAGING_ARCH)) libs
+		compat freebsd_network ] ;
 Includes [ FGristFiles jmphy.c ] : <src!libs!compat!freebsd_network>miidevs.h ;

src/add-ons/kernel/drivers/network/marvell_yukon/dev/mii/Jamfile

@@ -16,5 +16,6 @@ KernelStaticLibrary marvell_yukon_mii.a
 	;
 
 ObjectHdrs [ FGristFiles e1000phy$(SUFOBJ) ]
-        : [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR) libs compat freebsd_network ] ;
+	: [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR_$(TARGET_PACKAGING_ARCH)) libs
+		compat freebsd_network ] ;
 Includes [ FGristFiles e1000phy.c ] : <src!libs!compat!freebsd_network>miidevs.h ;

src/add-ons/kernel/drivers/network/nforce/dev/mii/Jamfile

@@ -16,5 +16,6 @@ KernelStaticLibrary nforce_mii.a
 	;
 
 ObjectHdrs [ FGristFiles ciphy$(SUFOBJ) ]
-	: [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR) libs compat freebsd_network ] ;
+	: [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR_$(TARGET_PACKAGING_ARCH)) libs
+		compat freebsd_network ] ;
 Includes [ FGristFiles ciphy.c ] : <src!libs!compat!freebsd_network>miidevs.h ;

src/add-ons/kernel/drivers/network/pegasus/Jamfile

@@ -15,5 +15,6 @@ KernelAddon pegasus :
 
 # driver.c currently needs usbdevs.h so we make its path available and adds dependency
 ObjectHdrs [ FGristFiles driver$(SUFOBJ) if_aue$(SUFOBJ) ]
-	: [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR) apps devices ] ;
+	: [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR_$(TARGET_PACKAGING_ARCH)) apps
+		devices ] ;
 Includes [ FGristFiles driver.c if_aue.c ] : <src!apps!devices>usbdevs.h ;

src/add-ons/kernel/drivers/network/rdc/dev/mii/Jamfile

@@ -14,5 +14,6 @@ KernelStaticLibrary rdc_mii.a
 	;
 
 ObjectHdrs [ FGristFiles rdcphy$(SUFOBJ) ]
-	: [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR) libs compat freebsd_network ] ;
+	: [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR_$(TARGET_PACKAGING_ARCH)) libs
+		compat freebsd_network ] ;
 Includes [ FGristFiles rdcphy.c ] : <src!libs!compat!freebsd_network>miidevs.h ;

src/add-ons/kernel/drivers/network/rtl8139/dev/mii/Jamfile

@@ -13,6 +13,7 @@ KernelStaticLibrary rtl8139_mii.a :
 	rlphy.c
 ;
 
-ObjectHdrs [ FGristFiles rlphy$(SUFOBJ) ] : [ FDirName
+ObjectHdrs [ FGristFiles rlphy$(SUFOBJ) ]
-		$(TARGET_COMMON_DEBUG_OBJECT_DIR) libs compat freebsd_network ] ;
+	: [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR_$(TARGET_PACKAGING_ARCH)) libs
+		compat freebsd_network ] ;
 Includes [ FGristFiles rlphy.c ] : <src!libs!compat!freebsd_network>miidevs.h ;

src/add-ons/kernel/drivers/network/rtl81xx/dev/mii/Jamfile

@@ -17,7 +17,8 @@ KernelStaticLibrary rtl81xx_mii.a :
 SEARCH on [ FGristFiles rlphy.c ] = [ FDirName $(HAIKU_TOP) src add-ons kernel
 		drivers network rtl8139 dev mii ] ;
 
-ObjectHdrs [ FGristFiles rgephy$(SUFOBJ) rlphy$(SUFOBJ) ] : [ FDirName
+ObjectHdrs [ FGristFiles rgephy$(SUFOBJ) rlphy$(SUFOBJ) ]
-		$(TARGET_COMMON_DEBUG_OBJECT_DIR) libs compat freebsd_network ] ;
+	: [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR_$(TARGET_PACKAGING_ARCH)) libs
+		compat freebsd_network ] ;
 Includes [ FGristFiles rgephy.c rlphy.c ]
 	: <src!libs!compat!freebsd_network>miidevs.h ;

src/add-ons/kernel/drivers/network/syskonnect/dev/mii/Jamfile

@@ -17,6 +17,7 @@ KernelStaticLibrary syskonnect_mii.a
 	;
 
 ObjectHdrs [ FGristFiles e1000phy$(SUFOBJ) ukphy$(SUFOBJ) xmphy$(SUFOBJ) ]
-        : [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR) libs compat freebsd_network ] ;
+	: [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR_$(TARGET_PACKAGING_ARCH)) libs
+		compat freebsd_network ] ;
 Includes [ FGristFiles e1000phy.c ukphy.c xmphy.c ] : <src!libs!compat!freebsd_network>miidevs.h ;
 

src/add-ons/kernel/drivers/network/via_rhine/dev/mii/Jamfile

@@ -16,6 +16,7 @@ KernelStaticLibrary via_rhine_mii.a
 	;
 
 ObjectHdrs [ FGristFiles ciphy$(SUFOBJ) ukphy$(SUFOBJ) ]
-        : [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR) libs compat freebsd_network ] ;
+	: [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR_$(TARGET_PACKAGING_ARCH)) libs
+		compat freebsd_network ] ;
 Includes [ FGristFiles ciphy.c ukphy.c ] : <src!libs!compat!freebsd_network>miidevs.h ;
 

src/add-ons/kernel/drivers/network/vt612x/dev/mii/Jamfile

@@ -16,6 +16,7 @@ KernelStaticLibrary vt612x_mii.a
 	;
 
 ObjectHdrs [ FGristFiles ciphy$(SUFOBJ) ukphy$(SUFOBJ) ]
-        : [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR) libs compat freebsd_network ] ;
+	: [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR_$(TARGET_PACKAGING_ARCH)) libs
+		compat freebsd_network ] ;
 Includes [ FGristFiles ciphy.c ukphy.c ] : <src!libs!compat!freebsd_network>miidevs.h ;
 

src/add-ons/kernel/file_systems/bindfs/Jamfile

@@ -16,7 +16,7 @@ HAIKU_BIND_FS_SOURCES =
 KernelAddon bindfs
 	:
 	$(HAIKU_BIND_FS_SOURCES)
-	: $(HAIKU_KERNEL_LIBSUPC++)
+	: $(TARGET_KERNEL_LIBSUPC++)
 ;
 
 

src/add-ons/kernel/file_systems/packagefs/Jamfile

@@ -123,7 +123,7 @@ KernelAddon packagefs
 	$(HAIKU_PACKAGE_FS_PACKAGE_READER_SOURCES_V1)
 	$(libSharedSources)
 
-	: $(HAIKU_STATIC_LIBSUPC++) kernel_libz.a
+	: $(TARGET_KERNEL_LIBSUPC++) kernel_libz.a
 ;
 
 

src/add-ons/kernel/file_systems/ramfs/Jamfile

@@ -45,5 +45,5 @@ KernelAddon ramfs
 	  SymLink.cpp
 	  Volume.cpp
 
-	: $(HAIKU_KERNEL_LIBSUPC++)
+	: $(TARGET_KERNEL_LIBSUPC++)
 ;

src/add-ons/kernel/file_systems/reiserfs/Jamfile

@@ -28,5 +28,5 @@ KernelAddon reiserfs
 	VNode.cpp
 	Volume.cpp
 
-	: $(HAIKU_KERNEL_LIBSUPC++)
+	: $(TARGET_KERNEL_LIBSUPC++)
 ;

src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/Jamfile

@@ -41,5 +41,5 @@ KernelAddon userlandfs
 	  UserlandFS.cpp
 	  Volume.cpp
 
-	: $(HAIKU_KERNEL_LIBSUPC++)
+	: $(TARGET_KERNEL_LIBSUPC++)
 ;

src/add-ons/mail_daemon/inbound_filters/match_header/Jamfile

@@ -13,7 +13,7 @@ Addon MatchHeader
 	RuleFilter.cpp
 	StringMatcher.cpp
 	:
-	be libmail.so $(TARGET_LIBSUPC++) $(HAIKU_LOCALE_LIBS)
+	be libmail.so $(TARGET_LIBSUPC++) localestub
 	;
 
 DoCatalogs MatchHeader

src/add-ons/mail_daemon/inbound_filters/notifier/Jamfile

@@ -11,7 +11,7 @@ Addon NewMailNotification :
 	filter.cpp
 	ConfigView.cpp
 	:
-	be libmail.so $(HAIKU_LOCALE_LIBS) $(TARGET_LIBSUPC++)
+	be libmail.so localestub $(TARGET_LIBSUPC++)
 	;
 
 DoCatalogs NewMailNotification :

src/add-ons/mail_daemon/inbound_filters/spam_filter/Jamfile

@@ -12,7 +12,7 @@ Addon SpamFilter :
 	SpamFilterConfig.cpp
 	SpamFilter.cpp
 	:
-	be libmail.so $(HAIKU_LOCALE_LIBS) $(TARGET_LIBSUPC++)
+	be libmail.so localestub $(TARGET_LIBSUPC++)
 	;
 
 DoCatalogs SpamFilter

src/add-ons/mail_daemon/inbound_protocols/imap/Jamfile

@@ -42,7 +42,7 @@ Addon IMAP
 	:
 	$(sources)
 	:
-	be libmail.so $(HAIKU_LOCALE_LIBS) $(TARGET_NETWORK_LIBS) libalm.so
+	be libmail.so localestub $(TARGET_NETWORK_LIBS) libalm.so
 		libshared.a $(TARGET_LIBSUPC++) $(TARGET_LIBSTDC++)
 ;
 

src/add-ons/mail_daemon/inbound_protocols/pop3/Jamfile

@@ -33,7 +33,7 @@ AddResources POP3 : POP3.rdef ;
 
 Addon POP3
 	: $(sources)
-	: be libbnetapi.so libmail.so $(HAIKU_LOCALE_LIBS)
+	: be libbnetapi.so libmail.so localestub
 		[ BuildFeatureAttribute openssl : libraries ] $(TARGET_LIBSUPC++)
 		$(TARGET_NETWORK_LIBS)
 ;

src/add-ons/mail_daemon/outbound_filters/fortune/Jamfile

@@ -12,7 +12,7 @@ Addon Fortune :
 	ConfigView.cpp
 	filter.cpp
 	:
-	be libmail.so $(HAIKU_LOCALE_LIBS) $(TARGET_LIBSUPC++)
+	be libmail.so localestub $(TARGET_LIBSUPC++)
 ;
 
 DoCatalogs Fortune :

src/add-ons/mail_daemon/outbound_protocols/smtp/Jamfile

@@ -30,7 +30,7 @@ AddResources SMTP : SMTP.rdef ;
 Addon SMTP
 	: $(sources)
 	: be libmail.so $(TARGET_NETWORK_LIBS) $(TARGET_LIBSTDC++)
-		$(HAIKU_LOCALE_LIBS) [ BuildFeatureAttribute openssl : libraries ]
+		localestub [ BuildFeatureAttribute openssl : libraries ]
 ;
 
 DoCatalogs SMTP :

src/add-ons/media/media-add-ons/mixer/Jamfile

@@ -15,7 +15,7 @@ Addon mixer.media_addon :
 	MixerSettings.cpp
 	MixerUtils.cpp
 	Resampler.cpp
-	: be media $(TARGET_LIBSUPC++) $(HAIKU_LOCALE_LIBS)
+	: be media $(TARGET_LIBSUPC++) localestub
 ;
 
 DoCatalogs mixer.media_addon

src/add-ons/media/media-add-ons/multi_audio/Jamfile

@@ -17,7 +17,7 @@ Addon hmulti_audio.media_addon :
 	MultiAudioUtility.cpp
 	Resampler.cpp
 	TimeComputer.cpp
-	: be media $(TARGET_LIBSUPC++) $(HAIKU_LOCALE_LIBS)
+	: be media $(TARGET_LIBSUPC++) localestub
 ;
 
 DoCatalogs hmulti_audio.media_addon

src/add-ons/screen_savers/butterfly/Jamfile

@@ -7,7 +7,7 @@ AddResources Butterfly : Butterfly.rdef ;
 
 ScreenSaver Butterfly :
 	Butterfly.cpp
-	: be screensaver $(HAIKU_LOCALE_LIBS) $(TARGET_LIBSUPC++)
+	: be screensaver localestub $(TARGET_LIBSUPC++)
 ;
 
 DoCatalogs Butterfly :

src/add-ons/screen_savers/debugnow/Jamfile

@@ -9,7 +9,7 @@ AddResources DebugNow : DebugNow.rdef ;
 
 ScreenSaver DebugNow :
 	DebugNow.cpp : 
-	be libscreensaver.so $(HAIKU_LOCALE_LIBS) $(TARGET_LIBSUPC++)
+	be libscreensaver.so localestub $(TARGET_LIBSUPC++)
 ;
 
 DoCatalogs DebugNow :

src/add-ons/screen_savers/flurry/Jamfile

@@ -21,7 +21,7 @@ Includes [ FGristFiles $(sources) ] :
 
 ScreenSaver Flurry :
 	$(sources) :
-	be screensaver GL libshared.a $(HAIKU_LOCALE_LIBS) $(TARGET_LIBSUPC++)
+	be screensaver GL libshared.a localestub $(TARGET_LIBSUPC++)
 	[ BuildFeatureAttribute glu : library ]
 ;
 

src/add-ons/screen_savers/glife/Jamfile

@@ -25,7 +25,7 @@ AddResources GLife : GLife.rdef ;
 
 ScreenSaver GLife :
 	$(sources) : 
-	be screensaver GL $(HAIKU_LOCALE_LIBS) $(TARGET_LIBSUPC++)
+	be screensaver GL localestub $(TARGET_LIBSUPC++)
 	[ BuildFeatureAttribute glu : library ]
 ;
 

src/add-ons/screen_savers/gravity/Jamfile

@@ -3,7 +3,7 @@ UseBuildFeatureHeaders glu ;
 UseBuildFeatureHeaders mesa ;
 
 # For GCC2
-if $(HAIKU_GCC_VERSION[1]) < 3 {
+if $(TARGET_GCC_VERSION_$(TARGET_PACKAGING_ARCH)[1]) < 3 {
     SubDirC++Flags --no-warnings ;
 }
 
@@ -28,7 +28,7 @@ Includes [ FGristFiles $(sources) ] :
 ScreenSaver Gravity :
 	$(sources)
 	:
-	be screensaver GL $(HAIKU_LOCALE_LIBS) $(TARGET_LIBSTDC++)
+	be screensaver GL localestub $(TARGET_LIBSTDC++)
 	[ BuildFeatureAttribute glu : library ]
 ;
 

src/add-ons/screen_savers/haiku/Jamfile

@@ -9,7 +9,7 @@ AddResources Haiku : ScreenSaver.rdef ;
 
 Addon Haiku :
 	ScreenSaver.cpp
-	: be screensaver $(HAIKU_LOCALE_LIBS) $(TARGET_LIBSUPC++)
+	: be screensaver localestub $(TARGET_LIBSUPC++)
 ;
 
 DoCatalogs Haiku :

src/add-ons/screen_savers/icons/Jamfile

@@ -7,7 +7,7 @@ AddResources Icons : Icons.rdef ;
 
 ScreenSaver Icons :
 	IconDisplay.cpp IconsSaver.cpp :
-	be libscreensaver.so $(HAIKU_LOCALE_LIBS) $(TARGET_LIBSUPC++)
+	be libscreensaver.so localestub $(TARGET_LIBSUPC++)
 ;
 
 DoCatalogs Icons :

src/add-ons/screen_savers/ifs/Jamfile

@@ -8,7 +8,7 @@ ScreenSaver IFS :
 	IFS.cpp
 	IFSSaver.cpp
 
-	: be libscreensaver.so $(HAIKU_LOCALE_LIBS) $(TARGET_LIBSUPC++)
+	: be libscreensaver.so localestub $(TARGET_LIBSUPC++)
 ;
 
 DoCatalogs IFS :

src/add-ons/screen_savers/leaves/Jamfile

@@ -4,7 +4,7 @@ AddResources Leaves : Leaves.rdef ;
 
 ScreenSaver Leaves :
 	Leaves.cpp :
-	be screensaver $(TARGET_LIBSUPC++) $(HAIKU_LOCALE_LIBS)
+	be screensaver $(TARGET_LIBSUPC++) localestub
 ;
 
 DoCatalogs Leaves :

src/add-ons/screen_savers/message/Jamfile

@@ -11,7 +11,7 @@ AddResources Message : Message.rdef ;
 
 ScreenSaver Message :
 	Message.cpp : 
-	be libscreensaver.so $(HAIKU_LOCALE_LIBS) $(TARGET_LIBSUPC++) ;
+	be libscreensaver.so localestub $(TARGET_LIBSUPC++) ;
 
 DoCatalogs Message :
 	x-vnd.Haiku-MessageScreensaver

src/add-ons/screen_savers/simpleclock/Jamfile

@@ -7,7 +7,7 @@ AddResources Message : SimpleClock.rdef ;
 ScreenSaver SimpleClock :
 	SimpleClock.cpp
 
-	: be libscreensaver.so $(HAIKU_LOCALE_LIBS) $(TARGET_LIBSUPC++)
+	: be libscreensaver.so localestub $(TARGET_LIBSUPC++)
 ;
 
 DoCatalogs SimpleClock :

src/add-ons/screen_savers/spider/Jamfile

@@ -9,7 +9,7 @@ ScreenSaver Spider :
 	PolygonQueue.cpp
 	SpiderSaver.cpp
 
-	: be libscreensaver.so $(HAIKU_LOCALE_LIBS) $(TARGET_LIBSUPC++)
+	: be libscreensaver.so localestub $(TARGET_LIBSUPC++)
 ;
 
 DoCatalogs Spider :

src/add-ons/tracker/zipomatic/Jamfile

@@ -9,7 +9,7 @@ Application ZipOMatic-Z :
 	ZipOMaticWindow.cpp
 	ZipperThread.cpp
 
-	: be tracker $(TARGET_LIBSUPC++) $(HAIKU_LOCALE_LIBS)
+	: be tracker $(TARGET_LIBSUPC++) localestub
 	: ZipOMatic.rdef
 ;
 

src/add-ons/translators/bmp/Jamfile

@@ -11,7 +11,7 @@ Translator BMPTranslator :
 	BMPTranslator.cpp
 	BMPView.cpp
 	: be translation libtranslatorsutils.a $(TARGET_LIBSUPC++)
-	$(HAIKU_LOCALE_LIBS)
+	localestub
 	: true
 ;
 

src/add-ons/translators/exr/Jamfile

@@ -16,7 +16,7 @@ Translator EXRTranslator :
 	EXRTranslator.cpp
 	IStreamWrapper.cpp
 	: be translation libilmimf.so $(TARGET_LIBSTDC++) libtranslatorsutils.a 
-	$(HAIKU_LOCALE_LIBS)
+	localestub
 	: true
 ;
 

src/add-ons/translators/exr/openexr/half/Jamfile

@@ -2,12 +2,12 @@ SubDir HAIKU_TOP src add-ons translators exr openexr half ;
 
 SubDirSysHdrs [ FDirName $(SUBDIR) ] ;
 
-if $(HAIKU_LIBSTDC++) = libstdc++.r4.so {
+if $(TARGET_PACKAGING_ARCH) = x86_gcc2 {
 	SubDirC++Flags -Dios_base=ios -ftemplate-depth-24 ;
 }
 
 StaticLibrary libhalf.a :
-eLut.cpp
+	eLut.cpp
-half.cpp
+	half.cpp
-toFloat.cpp
+	toFloat.cpp
-;
+	;

src/add-ons/translators/exr/openexr/ilmimf/Jamfile

@@ -7,7 +7,7 @@ SubDirSysHdrs [ FDirName $(SUBDIR) $(DOTDOT) ilmthread ] ;
 SubDirSysHdrs [ FDirName $(SUBDIR) $(DOTDOT) imath ] ;
 SubDirHdrs [ FDirName $(SUBDIR) $(DOTDOT) config ] ;
 
-if $(HAIKU_LIBSTDC++) = libstdc++.r4.so {
+if $(TARGET_PACKAGING_ARCH) = x86_gcc2 {
 	SubDirC++Flags -Dios_base=ios -ftemplate-depth-24 ;
 }
 
@@ -18,65 +18,65 @@ Includes [ FGristFiles ImfPxr24Compressor.cpp ImfZipCompressor.cpp ]
 
 #StaticLibrary libilmimf.a :
 SharedLibrary libilmimf.so :
-b44ExpLogTable.cpp
+	b44ExpLogTable.cpp
-ImfAttribute.cpp
+	ImfAttribute.cpp
-ImfB44Compressor.cpp
+	ImfB44Compressor.cpp
-ImfBoxAttribute.cpp
+	ImfBoxAttribute.cpp
-ImfChannelListAttribute.cpp
+	ImfChannelListAttribute.cpp
-ImfChannelList.cpp
+	ImfChannelList.cpp
-ImfChromaticitiesAttribute.cpp
+	ImfChromaticitiesAttribute.cpp
-ImfChromaticities.cpp
+	ImfChromaticities.cpp
-ImfCompressionAttribute.cpp
+	ImfCompressionAttribute.cpp
-ImfCompressor.cpp
+	ImfCompressor.cpp
-ImfConvert.cpp
+	ImfConvert.cpp
-ImfCRgbaFile.cpp
+	ImfCRgbaFile.cpp
-ImfDoubleAttribute.cpp
+	ImfDoubleAttribute.cpp
-ImfEnvmapAttribute.cpp
+	ImfEnvmapAttribute.cpp
-ImfEnvmap.cpp
+	ImfEnvmap.cpp
-ImfFloatAttribute.cpp
+	ImfFloatAttribute.cpp
-ImfFrameBuffer.cpp
+	ImfFrameBuffer.cpp
-ImfFramesPerSecond.cpp
+	ImfFramesPerSecond.cpp
-ImfHeader.cpp
+	ImfHeader.cpp
-ImfHuf.cpp
+	ImfHuf.cpp
-ImfInputFile.cpp
+	ImfInputFile.cpp
-ImfIntAttribute.cpp
+	ImfIntAttribute.cpp
-ImfIO.cpp
+	ImfIO.cpp
-ImfKeyCodeAttribute.cpp
+	ImfKeyCodeAttribute.cpp
-ImfKeyCode.cpp
+	ImfKeyCode.cpp
-ImfLineOrderAttribute.cpp
+	ImfLineOrderAttribute.cpp
-ImfLut.cpp
+	ImfLut.cpp
-ImfMatrixAttribute.cpp
+	ImfMatrixAttribute.cpp
-ImfMisc.cpp
+	ImfMisc.cpp
-ImfOpaqueAttribute.cpp
+	ImfOpaqueAttribute.cpp
-ImfOutputFile.cpp
+	ImfOutputFile.cpp
-ImfPizCompressor.cpp
+	ImfPizCompressor.cpp
-ImfPreviewImageAttribute.cpp
+	ImfPreviewImageAttribute.cpp
-ImfPreviewImage.cpp
+	ImfPreviewImage.cpp
-ImfPxr24Compressor.cpp
+	ImfPxr24Compressor.cpp
-ImfRationalAttribute.cpp
+	ImfRationalAttribute.cpp
-ImfRational.cpp
+	ImfRational.cpp
-ImfRgbaFile.cpp
+	ImfRgbaFile.cpp
-ImfRgbaYca.cpp
+	ImfRgbaYca.cpp
-ImfRleCompressor.cpp
+	ImfRleCompressor.cpp
-ImfScanLineInputFile.cpp
+	ImfScanLineInputFile.cpp
-ImfStandardAttributes.cpp
+	ImfStandardAttributes.cpp
-ImfStdIO.cpp
+	ImfStdIO.cpp
-ImfStringAttribute.cpp
+	ImfStringAttribute.cpp
-ImfTestFile.cpp
+	ImfTestFile.cpp
-ImfThreading.cpp
+	ImfThreading.cpp
-ImfTileDescriptionAttribute.cpp
+	ImfTileDescriptionAttribute.cpp
-ImfTiledInputFile.cpp
+	ImfTiledInputFile.cpp
-ImfTiledMisc.cpp
+	ImfTiledMisc.cpp
-ImfTiledOutputFile.cpp
+	ImfTiledOutputFile.cpp
-ImfTiledRgbaFile.cpp
+	ImfTiledRgbaFile.cpp
-ImfTileOffsets.cpp
+	ImfTileOffsets.cpp
-ImfTimeCodeAttribute.cpp
+	ImfTimeCodeAttribute.cpp
-ImfTimeCode.cpp
+	ImfTimeCode.cpp
-ImfVecAttribute.cpp
+	ImfVecAttribute.cpp
-ImfVersion.cpp
+	ImfVersion.cpp
-ImfWav.cpp
+	ImfWav.cpp
-ImfZipCompressor.cpp
+	ImfZipCompressor.cpp
-: libhalf.a libiex.a libimath.a libilmthread.a $(TARGET_LIBSTDC++)
+	: libhalf.a libiex.a libimath.a libilmthread.a $(TARGET_LIBSTDC++)
-	[ BuildFeatureAttribute zlib : library ]
+		[ BuildFeatureAttribute zlib : library ]
-;
+	;
 

src/add-ons/translators/exr/openexr/imath/Jamfile

@@ -4,16 +4,16 @@ SubDirSysHdrs [ FDirName $(SUBDIR) ] ;
 SubDirSysHdrs [ FDirName $(SUBDIR) $(DOTDOT) half ] ;
 SubDirSysHdrs [ FDirName $(SUBDIR) $(DOTDOT) iex ] ;
 
-if $(HAIKU_LIBSTDC++) = libstdc++.r4.so {
+if $(TARGET_PACKAGING_ARCH) = x86_gcc2 {
-        SubDirC++Flags -Dios_base=ios -ftemplate-depth-24 ;
+	SubDirC++Flags -Dios_base=ios -ftemplate-depth-24 ;
 }
 
 StaticLibrary libimath.a :
-ImathBox.cpp
+	ImathBox.cpp
-ImathColorAlgo.cpp
+	ImathColorAlgo.cpp
-ImathFun.cpp
+	ImathFun.cpp
-ImathMatrixAlgo.cpp
+	ImathMatrixAlgo.cpp
-ImathRandom.cpp
+	ImathRandom.cpp
-ImathShear.cpp
+	ImathShear.cpp
-ImathVec.cpp
+	ImathVec.cpp
-;
+	;

src/add-ons/translators/gif/Jamfile

@@ -18,7 +18,7 @@ Translator GIFTranslator :
 	SavePalette.cpp
 	SFHash.cpp
 	:
-	be translation $(TARGET_LIBSUPC++) $(HAIKU_LOCALE_LIBS)
+	be translation $(TARGET_LIBSUPC++) localestub
 	: true
 ;
 

src/add-ons/translators/hpgs/Jamfile

@@ -54,7 +54,7 @@ Translator HPGSTranslator :
 	: be translation libtextencoding.so
 		[ BuildFeatureAttribute libpng : library ]
 		[ BuildFeatureAttribute zlib : library ]
-		libtranslatorsutils.a $(TARGET_LIBSUPC++) $(HAIKU_LOCALE_LIBS)
+		libtranslatorsutils.a $(TARGET_LIBSUPC++) localestub
 	: true
 ;
 

src/add-ons/translators/hvif/Jamfile

@@ -9,7 +9,7 @@ Translator HVIFTranslator :
 	HVIFTranslator.cpp
 	HVIFView.cpp
 	: be translation libtranslatorsutils.a $(TARGET_LIBSUPC++)
-	$(HAIKU_LOCALE_LIBS)
+	localestub
 	: true
 ;
 

src/add-ons/translators/icns/Jamfile

@@ -77,7 +77,7 @@ Translator ICNSTranslator :
 
 	: be translation libtranslatorsutils.a $(TARGET_LIBSUPC++)
 	[ BuildFeatureAttribute libpng : library ]
-	$(HAIKU_LOCALE_LIBS)
+	localestub
 	: true
 ;
 

src/add-ons/translators/ico/Jamfile

@@ -13,7 +13,7 @@ Translator ICOTranslator :
 	ConfigView.cpp
 	ICO.cpp
 	: be translation libtranslatorsutils.a $(TARGET_LIBSUPC++)
-	$(HAIKU_LOCALE_LIBS)
+	localestub
 	: true
 ;
 

src/add-ons/translators/jpeg/Jamfile

@@ -24,7 +24,7 @@ Translator JPEGTranslator :
 	JPEGTranslator.cpp
 	: be translation libtranslatorsutils.a
 	[ BuildFeatureAttribute jpeg : library ]
-	$(TARGET_LIBSTDC++) $(HAIKU_LOCALE_LIBS)
+	$(TARGET_LIBSTDC++) localestub
 	: true
 ;
 

src/add-ons/translators/jpeg2000/Jamfile

@@ -72,7 +72,7 @@ Translator JPEG2000Translator :
 	$(jasper_files)
 
 	: be translation libtranslatorsutils.a $(TARGET_LIBSUPC++)
-	$(HAIKU_LOCALE_LIBS)
+	localestub
 	: true
 ;
 

src/add-ons/translators/pcx/Jamfile

@@ -12,7 +12,7 @@ Translator PCXTranslator :
 	PCXTranslator.cpp
 	ConfigView.cpp
 	PCX.cpp
-	: be translation libtranslatorsutils.a $(TARGET_LIBSUPC++) $(HAIKU_LOCALE_LIBS)
+	: be translation libtranslatorsutils.a $(TARGET_LIBSUPC++) localestub
 	: true
 ;
 

src/add-ons/translators/png/Jamfile

@@ -8,7 +8,7 @@ SubDirHdrs [ FDirName $(SUBDIR) $(DOTDOT) shared ] ;
 
 AddResources PNGTranslator : PNGTranslator.rdef ;
 
-if $(HAIKU_GCC_VERSION[1]) = 2 {
+if $(TARGET_GCC_VERSION_$(TARGET_PACKAGING_ARCH)[1]) = 2 {
 	SubDirCcFlags -DPNG_NO_PEDANTIC_WARNINGS ;
 }
 
@@ -24,7 +24,7 @@ Translator PNGTranslator :
 		[ BuildFeatureAttribute libpng : library ]
 		[ BuildFeatureAttribute zlib : library ]
 		$(TARGET_LIBSUPC++) libtranslatorsutils.a
-		$(HAIKU_LOCALE_LIBS)
+		localestub
 	: true
 ;