Add toolchain cflags that are always used

Some cflags are part of the toolchain selection and should not be
removed by no_default_compiler_flags = true, for example -m32 for x86
compiles.  Removing all the cflags results in hacks such as in crt.mk
where the bare minimum cflags are reinserted.

Add new toolchain interface functions ToolchainCflags, ToolchainLdflags
and ToolchainClangCflags that will always be used.

Change-Id: I0ba02d7611e2afb9ad913319740e00c1bb2d654c

3 files changed, 44 insertions, 9 deletions

diff --git a/cc/arm_device.go b/cc/arm_device.go
index f1688114..8fe5ce64 100644
--- a/cc/arm_device.go
+++ b/cc/arm_device.go
@@ -8,6 +8,10 @@ import (
 )
 
 var (
+	armToolchainCflags = []string{
+		"-mthumb-interwork",
+	}
+
 	armCflags = []string{
 		"-fno-exceptions", // from build/core/combo/select.mk
 		"-Wno-multichar",  // from build/core/combo/select.mk
@@ -26,8 +30,6 @@ var (
 		"-fno-builtin-sin",
 		"-fno-strict-volatile-bitfields",
 
-		"-mthumb-interwork",
-
 		// TARGET_RELEASE_CFLAGS
 		"-DNDEBUG",
 		"-g",
@@ -139,6 +141,7 @@ func init() {
 
 	pctx.StaticVariable("armGccTriple", "arm-linux-androideabi")
 
+	pctx.StaticVariable("armToolchainCflags", strings.Join(armToolchainCflags, " "))
 	pctx.StaticVariable("armCflags", strings.Join(armCflags, " "))
 	pctx.StaticVariable("armLdflags", strings.Join(armLdflags, " "))
 	pctx.StaticVariable("armCppflags", strings.Join(armCppflags, " "))
@@ -168,6 +171,7 @@ func init() {
 	pctx.StaticVariable("armCortexA15Cflags", strings.Join(armCpuVariantCflags["cortex-a15"], " "))
 
 	// Clang cflags
+	pctx.StaticVariable("armToolchainClangCflags", strings.Join(clangFilterUnknownCflags(armToolchainCflags), " "))
 	pctx.StaticVariable("armClangCflags", strings.Join(clangFilterUnknownCflags(armCflags), " "))
 	pctx.StaticVariable("armClangLdflags", strings.Join(clangFilterUnknownCflags(armLdflags), " "))
 	pctx.StaticVariable("armClangCppflags", strings.Join(clangFilterUnknownCflags(armCppflags), " "))
@@ -233,7 +237,8 @@ var (
 
 type toolchainArm struct {
 	toolchain32Bit
-	cflags, ldflags, clangCflags string
+	ldflags                               string
+	toolchainCflags, toolchainClangCflags string
 }
 
 func (t *toolchainArm) Name() string {
@@ -252,8 +257,12 @@ func (t *toolchainArm) GccVersion() string {
 	return "${armGccVersion}"
 }
 
+func (t *toolchainArm) ToolchainCflags() string {
+	return t.toolchainCflags
+}
+
 func (t *toolchainArm) Cflags() string {
-	return t.cflags
+	return "${armCflags}"
 }
 
 func (t *toolchainArm) Cppflags() string {
@@ -283,8 +292,12 @@ func (t *toolchainArm) ClangTriple() string {
 	return "${armGccTriple}"
 }
 
+func (t *toolchainArm) ToolchainClangCflags() string {
+	return t.toolchainClangCflags
+}
+
 func (t *toolchainArm) ClangCflags() string {
-	return t.clangCflags
+	return "${armClangCflags}"
 }
 
 func (t *toolchainArm) ClangCppflags() string {
@@ -317,8 +330,8 @@ func armToolchainFactory(arch common.Arch) Toolchain {
 	}
 
 	return &toolchainArm{
-		cflags: strings.Join([]string{
-			"${armCflags}",
+		toolchainCflags: strings.Join([]string{
+			"${armToolchainCflags}",
 			armArchVariantCflagsVar[arch.ArchVariant],
 			armCpuVariantCflagsVar[arch.CpuVariant],
 		}, " "),
@@ -326,8 +339,8 @@ func armToolchainFactory(arch common.Arch) Toolchain {
 			"${armLdflags}",
 			fixCortexA8,
 		}, " "),
-		clangCflags: strings.Join([]string{
-			"${armClangCflags}",
+		toolchainClangCflags: strings.Join([]string{
+			"${armToolchainClangCflags}",
 			armClangArchVariantCflagsVar[arch.ArchVariant],
 			armClangCpuVariantCflagsVar[arch.CpuVariant],
 		}, " "),
diff --git a/cc/cc.go b/cc/cc.go
index 42b0f2e5..b1bc069b 100644
--- a/cc/cc.go
+++ b/cc/cc.go
@@ -590,6 +590,13 @@ func (c *CCBase) collectFlags(ctx common.AndroidModuleContext, toolchain Toolcha
 		}
 	}
 
+	if flags.Clang {
+		flags.GlobalFlags = append(flags.GlobalFlags, toolchain.ToolchainClangCflags())
+	} else {
+		flags.GlobalFlags = append(flags.GlobalFlags, toolchain.ToolchainCflags())
+		flags.LdFlags = append(flags.LdFlags, toolchain.ToolchainLdflags())
+	}
+
 	flags = c.ccModuleType().flags(ctx, flags)
 
 	if c.Properties.Sdk_version == "" {
diff --git a/cc/toolchain.go b/cc/toolchain.go
index 8a8fc2d5..71a89794 100644
--- a/cc/toolchain.go
+++ b/cc/toolchain.go
@@ -39,6 +39,8 @@ type Toolchain interface {
 	GccRoot() string
 	GccTriple() string
 	GccVersion() string
+	ToolchainCflags() string
+	ToolchainLdflags() string
 	Cflags() string
 	Cppflags() string
 	Ldflags() string
@@ -46,6 +48,7 @@ type Toolchain interface {
 	InstructionSetFlags(string) (string, error)
 
 	ClangTriple() string
+	ToolchainClangCflags() string
 	ClangCflags() string
 	ClangCppflags() string
 	ClangLdflags() string
@@ -71,6 +74,18 @@ func (toolchainBase) ClangInstructionSetFlags(s string) (string, error) {
 	return "", nil
 }
 
+func (toolchainBase) ToolchainCflags() string {
+	return ""
+}
+
+func (toolchainBase) ToolchainLdflags() string {
+	return ""
+}
+
+func (toolchainBase) ToolchainClangCflags() string {
+	return ""
+}
+
 type toolchain64Bit struct {
 	toolchainBase
 }