This is the first set of build system changes to support

architecture versions other than ARMv5TE.

The general approach is to provide TARGET_ARCH_VERSION, to complement
TARGET_ARCH. This defaults to the current armv5te. The variable
values should match the architectures as defined by gcc.

There is a block of defines for each supported architecture version
(currently ARMv5TE and ARMv4). Each block defines a set of features
using ARCH_ARM_HAVE_<x> variables. It also specifies a set of c
preprocessor defines to pass to the compiler. Finally it defines a
default CPU. (As for architecture versions, the default CPU should
match a CPU that gcc knows about.)

Support is added for architectures that do not support THUMB. Specifically
we change the 'thumb compile' target to simply compile as ARM code
instead, and we change the interworking flag passed to the compiler.

Finally, we ensure that the system/core/include/arch/linux-arm directory
is added to the default include path, which allows the use of asm/macros.h
header file described in review #1626. The way in which this done is
considerably unclean/hacky, if someone can suggest a better way please
let me know.

1 files changed, 84 insertions, 9 deletions

diff --git a/core/combo/linux-arm.mk b/core/combo/linux-arm.mk
index adb82d3a40..94dcd0341f 100644
--- a/core/combo/linux-arm.mk
+++ b/core/combo/linux-arm.mk
@@ -1,6 +1,58 @@
 # Configuration for Linux on ARM.
 # Included by combo/select.make
 
+# You can set TARGET_ARCH_VERSION to use an arch version other
+# than ARMv5TE
+ifeq ($(strip $(TARGET_ARCH_VERSION)),)
+TARGET_ARCH_VERSION := armv5te
+endif
+
+# This set of if blocks sets makefile variables similar to preprocesser
+# defines in system/core/include/arch/<combo>/AndroidConfig.h. Their
+# purpose is to allow module Android.mk files to selctively compile
+# different versions of code based upon the funtionality and 
+# instructions available in a given architecture version.
+#
+# The blocks also define specific arch_version_cflags, which 
+# include defines, and compiler settings for the given architecture
+# version.
+#
+# Note: Hard coding the 'tune' value here is probably not ideal,
+# and a better solution should be found in the future.
+#
+# With two or three different versions this if block approach is
+# fine. If/when this becomes large, please change this to include
+# architecture versions specific Makefiles which define these
+# variables.
+# 
+ifeq ($(TARGET_ARCH_VERSION),armv5te)
+ARCH_ARM_HAVE_THUMB_SUPPORT := true
+ARCH_ARM_HAVE_FAST_INTERWORKING := true
+ARCH_ARM_HAVE_64BIT_DATA := true
+ARCH_ARM_HAVE_HALFWORD_MULTIPLY := true
+ARCH_ARM_HAVE_CLZ := true
+ARCH_ARM_HAVE_FFS := true
+
+arch_version_cflags := -march=armv5te -mtune=xscale  -D__ARM_ARCH_5__ \
+	-D__ARM_ARCH_5T__ -D__ARM_ARCH_5TE__
+else
+ifeq ($(TARGET_ARCH_VERSION),armv4)
+$(warning ARMv4 support is currently a work in progress. It does not work right now!)
+ARCH_ARM_HAVE_THUMB_SUPPORT := false
+ARCH_ARM_HAVE_THUMB_INTERWORKING := false
+ARCH_ARM_HAVE_64BIT_DATA := false
+ARCH_ARM_HAVE_HALFWORD_MULTIPLY := false
+ARCH_ARM_HAVE_CLZ := false
+ARCH_ARM_HAVE_FFS := false
+
+DEFAULT_TARGET_CPU := arm920
+
+arch_version_cflags := -march=armv4 -mtune=arm920 -D__ARM_ARCH_4__
+else
+$(error Unknown ARM architecture version: $(TARGET_ARCH_VERSION))
+endif
+endif
+
 # You can set TARGET_TOOLS_PREFIX to get gcc from somewhere else
 ifeq ($(strip $($(combo_target)TOOLS_PREFIX)),)
 $(combo_target)TOOLS_PREFIX := \
@@ -20,11 +72,19 @@ TARGET_arm_release_CFLAGS :=    -fomit-frame-pointer \
                                 -funswitch-loops     \
                                 -finline-limit=300
 
+# Modules can choose to compile some source as thumb. As 
+# non-thumb enabled targets are supported, this is treated
+# as a 'hint'. If thumb is not enabled, these files are just
+# compiled as ARM.
+ifeq ($(ARCH_ARM_HAVE_THUMB_SUPPORT),true)
 TARGET_thumb_release_CFLAGS :=  -mthumb \
                                 -Os \
                                 -fomit-frame-pointer \
                                 -fno-strict-aliasing \
                                 -finline-limit=64
+else
+TARGET_thumb_release_CFLAGS := $(TARGET_arm_release_CFLAGS)
+endif
 
 # When building for debug, compile everything as arm.
 TARGET_arm_debug_CFLAGS := $(TARGET_arm_release_CFLAGS) -fno-omit-frame-pointer -fno-strict-aliasing
@@ -41,21 +101,27 @@ TARGET_thumb_debug_CFLAGS := $(TARGET_thumb_release_CFLAGS) -marm -fno-omit-fram
 ##TARGET_arm_release_CFLAGS := $(TARGET_arm_release_CFLAGS) -fno-omit-frame-pointer
 ##TARGET_thumb_release_CFLAGS := $(TARGET_thumb_release_CFLAGS) -marm -fno-omit-frame-pointer
 
-## on some hosts, the target cross-compiler is not available so do not run this command
-ifneq ($(wildcard $($(combo_target)CC)),)
-$(combo_target)LIBGCC := $(shell $($(combo_target)CC) -mthumb-interwork -print-libgcc-file-name)
-endif
+android_config_h := $(call select-android-config-h,linux-arm)
+arch_include_dir := $(dir $(android_config_h))
 
 $(combo_target)GLOBAL_CFLAGS += \
-			-march=armv5te -mtune=xscale \
 			-msoft-float -fpic \
-			-mthumb-interwork \
 			-ffunction-sections \
 			-funwind-tables \
 			-fstack-protector \
-			-D__ARM_ARCH_5__ -D__ARM_ARCH_5T__ \
-			-D__ARM_ARCH_5E__ -D__ARM_ARCH_5TE__ \
-			-include $(call select-android-config-h,linux-arm)
+			$(arch_version_cflags) \
+			-include $(android_config_h) \
+			-I $(arch_include_dir)
+
+# We only need thumb interworking in cases where thumb support
+# is available in the architecture, and just to be sure, (and
+# since sometimes thumb-interwork appears to be default), we
+# specifically disable when thumb support is unavailable.
+ifeq ($(ARCH_ARM_HAVE_THUMB_SUPPORT),true)
+$(combo_target)GLOBAL_CFLAGS +=	-mthumb-interwork
+else
+$(combo_target)GLOBAL_CFLAGS +=	-mno-thumb-interwork
+endif
 
 $(combo_target)GLOBAL_CPPFLAGS += -fvisibility-inlines-hidden
 
@@ -74,6 +140,15 @@ libm_root := bionic/libm
 libstdc++_root := bionic/libstdc++
 libthread_db_root := bionic/libthread_db
 
+
+## on some hosts, the target cross-compiler is not available so do not run this command
+ifneq ($(wildcard $($(combo_target)CC)),)
+# We compile with the global cflags to ensure that 
+# any flags which affect libgcc are correctly taken
+# into account.
+$(combo_target)LIBGCC := $(shell $($(combo_target)CC) $($(combo_target)GLOBAL_CFLAGS) -print-libgcc-file-name)
+endif
+
 # unless CUSTOM_KERNEL_HEADERS is defined, we're going to use
 # symlinks located in out/ to point to the appropriate kernel
 # headers. see 'config/kernel_headers.make' for more details