Remove clang indirection without affecting build.ninja

Remove cflags that are not handled by clang from the global defaults, and remove calls to ClangFilterUnknownCflags. Squash lists of clang-specific default flags into the main default flags lists. Rename Toolchain.Clang*flags to Toolchain.*flags. Rename Go variables with Clang in the name that have no non-Clang equivalent. Remove unused ninja variables. Bug: 68947919 Test: no change to build.ninja for aosp_cf_x86_64_phone-userdebug or aosp_crosshatch-userdebug Change-Id: Id287945315d53e5eaef197adbbb4f1302f2e3680
2021-07-14 17:03:16 -07:00
parent 1c19b81e3d
commit 33bac24bb9
19 changed files with 234 additions and 355 deletions
--- a/cc/compiler.go
+++ b/cc/compiler.go
@@ -392,7 +392,7 @@ func (compiler *baseCompiler) compilerFlags(ctx ModuleContext, flags Flags, deps
 	if flags.RequiredInstructionSet != "" {
 		instructionSet = flags.RequiredInstructionSet
 	}
-	instructionSetFlags, err := tc.ClangInstructionSetFlags(instructionSet)
+	instructionSetFlags, err := tc.InstructionSetFlags(instructionSet)
 	if err != nil {
 		ctx.ModuleErrorf("%s", err)
 	}
@@ -437,10 +437,10 @@ func (compiler *baseCompiler) compilerFlags(ctx ModuleContext, flags Flags, deps
 	flags.Global.ConlyFlags = append([]string{"${config.CommonGlobalConlyflags}"}, flags.Global.ConlyFlags...)
 	flags.Global.CppFlags = append([]string{fmt.Sprintf("${config.%sGlobalCppflags}", hod)}, flags.Global.CppFlags...)

-	flags.Global.AsFlags = append(flags.Global.AsFlags, tc.ClangAsflags())
+	flags.Global.AsFlags = append(flags.Global.AsFlags, tc.Asflags())
 	flags.Global.CppFlags = append([]string{"${config.CommonClangGlobalCppflags}"}, flags.Global.CppFlags...)
 	flags.Global.CommonFlags = append(flags.Global.CommonFlags,
-		tc.ClangCflags(),
+		tc.Cflags(),
 		"${config.CommonClangGlobalCflags}",
 		fmt.Sprintf("${config.%sClangGlobalCflags}", hod))

@@ -458,11 +458,11 @@ func (compiler *baseCompiler) compilerFlags(ctx ModuleContext, flags Flags, deps

 	flags.Global.AsFlags = append(flags.Global.AsFlags, "-D__ASSEMBLY__")

-	flags.Global.CppFlags = append(flags.Global.CppFlags, tc.ClangCppflags())
+	flags.Global.CppFlags = append(flags.Global.CppFlags, tc.Cppflags())

 	flags.Global.YasmFlags = append(flags.Global.YasmFlags, tc.YasmFlags())

-	flags.Global.CommonFlags = append(flags.Global.CommonFlags, tc.ToolchainClangCflags())
+	flags.Global.CommonFlags = append(flags.Global.CommonFlags, tc.ToolchainCflags())

 	cStd := config.CStdVersion
 	if String(compiler.Properties.C_std) == "experimental" {
--- a/cc/config/arm64_device.go
+++ b/cc/config/arm64_device.go
@@ -48,12 +48,12 @@ var (
 		"-Wl,-z,separate-code",
 	}

-	arm64Lldflags = append(ClangFilterUnknownLldflags(arm64Ldflags),
+	arm64Lldflags = append(arm64Ldflags,
 		"-Wl,-z,max-page-size=4096")

 	arm64Cppflags = []string{}

-	arm64ClangCpuVariantCflags = map[string][]string{
+	arm64CpuVariantCflags = map[string][]string{
 		"cortex-a53": []string{
 			"-mcpu=cortex-a53",
 		},
@@ -99,10 +99,8 @@ func init() {
 	pctx.StaticVariable("Arm64Ldflags", strings.Join(arm64Ldflags, " "))
 	pctx.StaticVariable("Arm64Lldflags", strings.Join(arm64Lldflags, " "))

-	pctx.StaticVariable("Arm64ClangCflags", strings.Join(ClangFilterUnknownCflags(arm64Cflags), " "))
-	pctx.StaticVariable("Arm64ClangLdflags", strings.Join(ClangFilterUnknownCflags(arm64Ldflags), " "))
-	pctx.StaticVariable("Arm64ClangLldflags", strings.Join(ClangFilterUnknownCflags(arm64Lldflags), " "))
-	pctx.StaticVariable("Arm64ClangCppflags", strings.Join(ClangFilterUnknownCflags(arm64Cppflags), " "))
+	pctx.StaticVariable("Arm64ClangCflags", strings.Join(arm64Cflags, " "))
+	pctx.StaticVariable("Arm64ClangCppflags", strings.Join(arm64Cppflags, " "))

 	pctx.StaticVariable("Arm64ClangArmv8ACflags", strings.Join(arm64ArchVariantCflags["armv8-a"], " "))
 	pctx.StaticVariable("Arm64ClangArmv8ABranchProtCflags", strings.Join(arm64ArchVariantCflags["armv8-a-branchprot"], " "))
@@ -110,30 +108,30 @@ func init() {
 	pctx.StaticVariable("Arm64ClangArmv82ADotprodCflags", strings.Join(arm64ArchVariantCflags["armv8-2a-dotprod"], " "))

 	pctx.StaticVariable("Arm64ClangCortexA53Cflags",
-		strings.Join(arm64ClangCpuVariantCflags["cortex-a53"], " "))
+		strings.Join(arm64CpuVariantCflags["cortex-a53"], " "))

 	pctx.StaticVariable("Arm64ClangCortexA55Cflags",
-		strings.Join(arm64ClangCpuVariantCflags["cortex-a55"], " "))
+		strings.Join(arm64CpuVariantCflags["cortex-a55"], " "))

 	pctx.StaticVariable("Arm64ClangKryoCflags",
-		strings.Join(arm64ClangCpuVariantCflags["kryo"], " "))
+		strings.Join(arm64CpuVariantCflags["kryo"], " "))

 	pctx.StaticVariable("Arm64ClangExynosM1Cflags",
-		strings.Join(arm64ClangCpuVariantCflags["exynos-m1"], " "))
+		strings.Join(arm64CpuVariantCflags["exynos-m1"], " "))

 	pctx.StaticVariable("Arm64ClangExynosM2Cflags",
-		strings.Join(arm64ClangCpuVariantCflags["exynos-m2"], " "))
+		strings.Join(arm64CpuVariantCflags["exynos-m2"], " "))
 }

 var (
-	arm64ClangArchVariantCflagsVar = map[string]string{
+	arm64ArchVariantCflagsVar = map[string]string{
 		"armv8-a":            "${config.Arm64ClangArmv8ACflags}",
 		"armv8-a-branchprot": "${config.Arm64ClangArmv8ABranchProtCflags}",
 		"armv8-2a":           "${config.Arm64ClangArmv82ACflags}",
 		"armv8-2a-dotprod":   "${config.Arm64ClangArmv82ADotprodCflags}",
 	}

-	arm64ClangCpuVariantCflagsVar = map[string]string{
+	arm64CpuVariantCflagsVar = map[string]string{
 		"":           "",
 		"cortex-a53": "${config.Arm64ClangCortexA53Cflags}",
 		"cortex-a55": "${config.Arm64ClangCortexA55Cflags}",
@@ -152,9 +150,9 @@ type toolchainArm64 struct {
 	toolchainBionic
 	toolchain64Bit

-	ldflags              string
-	lldflags             string
-	toolchainClangCflags string
+	ldflags         string
+	lldflags        string
+	toolchainCflags string
 }

 func (t *toolchainArm64) Name() string {
@@ -181,24 +179,24 @@ func (t *toolchainArm64) ClangTriple() string {
 	return t.GccTriple()
 }

-func (t *toolchainArm64) ClangCflags() string {
+func (t *toolchainArm64) Cflags() string {
 	return "${config.Arm64ClangCflags}"
 }

-func (t *toolchainArm64) ClangCppflags() string {
+func (t *toolchainArm64) Cppflags() string {
 	return "${config.Arm64ClangCppflags}"
 }

-func (t *toolchainArm64) ClangLdflags() string {
+func (t *toolchainArm64) Ldflags() string {
 	return t.ldflags
 }

-func (t *toolchainArm64) ClangLldflags() string {
+func (t *toolchainArm64) Lldflags() string {
 	return t.lldflags
 }

-func (t *toolchainArm64) ToolchainClangCflags() string {
-	return t.toolchainClangCflags
+func (t *toolchainArm64) ToolchainCflags() string {
+	return t.toolchainCflags
 }

 func (toolchainArm64) LibclangRuntimeLibraryArch() string {
@@ -216,9 +214,9 @@ func arm64ToolchainFactory(arch android.Arch) Toolchain {
 		panic(fmt.Sprintf("Unknown ARM architecture version: %q", arch.ArchVariant))
 	}

-	toolchainClangCflags := []string{arm64ClangArchVariantCflagsVar[arch.ArchVariant]}
-	toolchainClangCflags = append(toolchainClangCflags,
-		variantOrDefault(arm64ClangCpuVariantCflagsVar, arch.CpuVariant))
+	toolchainCflags := []string{arm64ArchVariantCflagsVar[arch.ArchVariant]}
+	toolchainCflags = append(toolchainCflags,
+		variantOrDefault(arm64CpuVariantCflagsVar, arch.CpuVariant))

 	var extraLdflags string
 	switch arch.CpuVariant {
@@ -235,7 +233,7 @@ func arm64ToolchainFactory(arch android.Arch) Toolchain {
 			"${config.Arm64Lldflags}",
 			extraLdflags,
 		}, " "),
-		toolchainClangCflags: strings.Join(toolchainClangCflags, " "),
+		toolchainCflags: strings.Join(toolchainCflags, " "),
 	}
 }

--- a/cc/config/arm64_fuchsia_device.go
+++ b/cc/config/arm64_fuchsia_device.go
@@ -42,47 +42,31 @@ func (t *toolchainFuchsiaArm64) GccVersion() string {
 	return arm64GccVersion
 }

-func (t *toolchainFuchsiaArm64) Cflags() string {
-	return ""
-}
-
-func (t *toolchainFuchsiaArm64) Cppflags() string {
-	return ""
-}
-
-func (t *toolchainFuchsiaArm64) Ldflags() string {
-	return "-Wl,--fix-cortex-a53-843419"
-}
-
 func (t *toolchainFuchsiaArm64) IncludeFlags() string {
 	return ""
 }

-func (t *toolchainFuchsiaArm64) ToolchainCflags() string {
-	return "-mcpu=cortex-a53"
-}
-
 func (t *toolchainFuchsiaArm64) ClangTriple() string {
 	return "arm64-fuchsia-android"
 }

-func (t *toolchainFuchsiaArm64) ClangCppflags() string {
+func (t *toolchainFuchsiaArm64) Cppflags() string {
 	return "-Wno-error=deprecated-declarations"
 }

-func (t *toolchainFuchsiaArm64) ClangLdflags() string {
+func (t *toolchainFuchsiaArm64) Ldflags() string {
 	return "--target=arm64-fuchsia --sysroot=" + fuchsiaArm64SysRoot + " -L" + fuchsiaArm64PrebuiltLibsRoot + "/aarch64-fuchsia/lib " + "-Lprebuilts/fuchsia_sdk/arch/arm64/dist/"
 }

-func (t *toolchainFuchsiaArm64) ClangLldflags() string {
+func (t *toolchainFuchsiaArm64) Lldflags() string {
 	return "--target=arm64-fuchsia --sysroot=" + fuchsiaArm64SysRoot + " -L" + fuchsiaArm64PrebuiltLibsRoot + "/aarch64-fuchsia/lib " + "-Lprebuilts/fuchsia_sdk/arch/arm64/dist/"
 }

-func (t *toolchainFuchsiaArm64) ClangCflags() string {
+func (t *toolchainFuchsiaArm64) Cflags() string {
 	return "--target=arm64-fuchsia --sysroot=" + fuchsiaArm64SysRoot + " -I" + fuchsiaArm64SysRoot + "/include"
 }

-func (t *toolchainFuchsiaArm64) ToolchainClangCflags() string {
+func (t *toolchainFuchsiaArm64) ToolchainCflags() string {
 	return "-march=armv8-a"
 }

--- a/cc/config/arm64_linux_host.go
+++ b/cc/config/arm64_linux_host.go
@@ -15,14 +15,15 @@
 package config

 import (
-	"android/soong/android"
 	"strings"
+
+	"android/soong/android"
 )

 var (
 	// This is a host toolchain but flags for device toolchain are required
 	// as the flags are actually for Bionic-based builds.
-	linuxCrossCflags = ClangFilterUnknownCflags(append(deviceGlobalCflags,
+	linuxCrossCflags = append(deviceGlobalCflags,
 		// clang by default enables PIC when the clang triple is set to *-android.
 		// See toolchain/llvm-project/clang/lib/Driver/ToolChains/CommonArgs.cpp#920.
 		// However, for this host target, we don't set "-android" to avoid __ANDROID__ macro
@@ -33,9 +34,9 @@ var (
 		// This is normally in ClangExtraTargetCflags, but that's for device and we need
 		// the same for host
 		"-nostdlibinc",
-	))
+	)

-	linuxCrossLdflags = ClangFilterUnknownCflags([]string{
+	linuxCrossLdflags = []string{
 		"-Wl,-z,noexecstack",
 		"-Wl,-z,relro",
 		"-Wl,-z,now",
@@ -44,7 +45,7 @@ var (
 		"-Wl,--fatal-warnings",
 		"-Wl,--hash-style=gnu",
 		"-Wl,--no-undefined-version",
-	})
+	}

 	// Embed the linker into host bionic binaries. This is needed to support host bionic,
 	// as the linux kernel requires that the ELF interpreter referenced by PT_INTERP be
@@ -73,7 +74,7 @@ func (toolchainLinuxArm64) ClangTriple() string {
 	return "aarch64-linux"
 }

-func (toolchainLinuxArm64) ClangCflags() string {
+func (toolchainLinuxArm64) Cflags() string {
 	// The inherited flags + extra flags
 	return "${config.Arm64ClangCflags} ${config.LinuxBionicArm64Cflags}"
 }
@@ -84,7 +85,7 @@ func (toolchainLinuxArm64) CrtBeginSharedBinary() []string {

 func linuxArm64ToolchainFactory(arch android.Arch) Toolchain {
 	archVariant := "armv8-a" // for host, default to armv8-a
-	toolchainClangCflags := []string{arm64ClangArchVariantCflagsVar[archVariant]}
+	toolchainCflags := []string{arm64ArchVariantCflagsVar[archVariant]}

 	// We don't specify CPU architecture for host. Conservatively assume
 	// the host CPU needs the fix
@@ -103,7 +104,7 @@ func linuxArm64ToolchainFactory(arch android.Arch) Toolchain {
 		"${config.LinuxBionicArm64Ldflags}",
 		extraLdflags,
 	}, " ")
-	ret.toolchainArm64.toolchainClangCflags = strings.Join(toolchainClangCflags, " ")
+	ret.toolchainArm64.toolchainCflags = strings.Join(toolchainCflags, " ")
 	return &ret
 }

--- a/cc/config/arm_device.go
+++ b/cc/config/arm_device.go
@@ -23,7 +23,6 @@ import (

 var (
 	armToolchainCflags = []string{
-		"-mthumb-interwork",
 		"-msoft-float",
 	}

@@ -38,7 +37,7 @@ var (
 		"-Wl,-m,armelf",
 	}

-	armLldflags = ClangFilterUnknownLldflags(armLdflags)
+	armLldflags = armLdflags

 	armArmCflags = []string{
 		"-fstrict-aliasing",
@@ -49,7 +48,7 @@ var (
 		"-Os",
 	}

-	armClangArchVariantCflags = map[string][]string{
+	armArchVariantCflags = map[string][]string{
 		"armv7-a": []string{
 			"-march=armv7-a",
 			"-mfloat-abi=softfp",
@@ -72,7 +71,7 @@ var (
 		},
 	}

-	armClangCpuVariantCflags = map[string][]string{
+	armCpuVariantCflags = map[string][]string{
 		"cortex-a7": []string{
 			"-mcpu=cortex-a7",
 			"-mfpu=neon-vfpv4",
@@ -181,42 +180,40 @@ func init() {
 	exportStringListStaticVariable("ArmLldflags", armLldflags)

 	// Clang cflags
-	exportStringListStaticVariable("ArmToolchainClangCflags", ClangFilterUnknownCflags(armToolchainCflags))
-	exportStringListStaticVariable("ArmClangCflags", ClangFilterUnknownCflags(armCflags))
-	exportStringListStaticVariable("ArmClangLdflags", ClangFilterUnknownCflags(armLdflags))
-	exportStringListStaticVariable("ArmClangLldflags", ClangFilterUnknownCflags(armLldflags))
-	exportStringListStaticVariable("ArmClangCppflags", ClangFilterUnknownCflags(armCppflags))
+	exportStringListStaticVariable("ArmToolchainClangCflags", armToolchainCflags)
+	exportStringListStaticVariable("ArmClangCflags", armCflags)
+	exportStringListStaticVariable("ArmClangCppflags", armCppflags)

 	// Clang ARM vs. Thumb instruction set cflags
-	exportStringListStaticVariable("ArmClangArmCflags", ClangFilterUnknownCflags(armArmCflags))
-	exportStringListStaticVariable("ArmClangThumbCflags", ClangFilterUnknownCflags(armThumbCflags))
+	exportStringListStaticVariable("ArmClangArmCflags", armArmCflags)
+	exportStringListStaticVariable("ArmClangThumbCflags", armThumbCflags)

 	// Clang arch variant cflags
-	exportStringListStaticVariable("ArmClangArmv7ACflags", armClangArchVariantCflags["armv7-a"])
-	exportStringListStaticVariable("ArmClangArmv7ANeonCflags", armClangArchVariantCflags["armv7-a-neon"])
-	exportStringListStaticVariable("ArmClangArmv8ACflags", armClangArchVariantCflags["armv8-a"])
-	exportStringListStaticVariable("ArmClangArmv82ACflags", armClangArchVariantCflags["armv8-2a"])
+	exportStringListStaticVariable("ArmClangArmv7ACflags", armArchVariantCflags["armv7-a"])
+	exportStringListStaticVariable("ArmClangArmv7ANeonCflags", armArchVariantCflags["armv7-a-neon"])
+	exportStringListStaticVariable("ArmClangArmv8ACflags", armArchVariantCflags["armv8-a"])
+	exportStringListStaticVariable("ArmClangArmv82ACflags", armArchVariantCflags["armv8-2a"])

 	// Clang cpu variant cflags
-	exportStringListStaticVariable("ArmClangGenericCflags", armClangCpuVariantCflags[""])
-	exportStringListStaticVariable("ArmClangCortexA7Cflags", armClangCpuVariantCflags["cortex-a7"])
-	exportStringListStaticVariable("ArmClangCortexA8Cflags", armClangCpuVariantCflags["cortex-a8"])
-	exportStringListStaticVariable("ArmClangCortexA15Cflags", armClangCpuVariantCflags["cortex-a15"])
-	exportStringListStaticVariable("ArmClangCortexA53Cflags", armClangCpuVariantCflags["cortex-a53"])
-	exportStringListStaticVariable("ArmClangCortexA55Cflags", armClangCpuVariantCflags["cortex-a55"])
-	exportStringListStaticVariable("ArmClangKraitCflags", armClangCpuVariantCflags["krait"])
-	exportStringListStaticVariable("ArmClangKryoCflags", armClangCpuVariantCflags["kryo"])
+	exportStringListStaticVariable("ArmClangGenericCflags", armCpuVariantCflags[""])
+	exportStringListStaticVariable("ArmClangCortexA7Cflags", armCpuVariantCflags["cortex-a7"])
+	exportStringListStaticVariable("ArmClangCortexA8Cflags", armCpuVariantCflags["cortex-a8"])
+	exportStringListStaticVariable("ArmClangCortexA15Cflags", armCpuVariantCflags["cortex-a15"])
+	exportStringListStaticVariable("ArmClangCortexA53Cflags", armCpuVariantCflags["cortex-a53"])
+	exportStringListStaticVariable("ArmClangCortexA55Cflags", armCpuVariantCflags["cortex-a55"])
+	exportStringListStaticVariable("ArmClangKraitCflags", armCpuVariantCflags["krait"])
+	exportStringListStaticVariable("ArmClangKryoCflags", armCpuVariantCflags["kryo"])
 }

 var (
-	armClangArchVariantCflagsVar = map[string]string{
+	armArchVariantCflagsVar = map[string]string{
 		"armv7-a":      "${config.ArmClangArmv7ACflags}",
 		"armv7-a-neon": "${config.ArmClangArmv7ANeonCflags}",
 		"armv8-a":      "${config.ArmClangArmv8ACflags}",
 		"armv8-2a":     "${config.ArmClangArmv82ACflags}",
 	}

-	armClangCpuVariantCflagsVar = map[string]string{
+	armCpuVariantCflagsVar = map[string]string{
 		"":               "${config.ArmClangGenericCflags}",
 		"cortex-a7":      "${config.ArmClangCortexA7Cflags}",
 		"cortex-a8":      "${config.ArmClangCortexA8Cflags}",
@@ -239,9 +236,9 @@ var (
 type toolchainArm struct {
 	toolchainBionic
 	toolchain32Bit
-	ldflags              string
-	lldflags             string
-	toolchainClangCflags string
+	ldflags         string
+	lldflags        string
+	toolchainCflags string
 }

 func (t *toolchainArm) Name() string {
@@ -274,34 +271,34 @@ func (t *toolchainArm) ndkTriple() string {
 	return t.GccTriple()
 }

-func (t *toolchainArm) ToolchainClangCflags() string {
-	return t.toolchainClangCflags
+func (t *toolchainArm) ToolchainCflags() string {
+	return t.toolchainCflags
 }

-func (t *toolchainArm) ClangCflags() string {
+func (t *toolchainArm) Cflags() string {
 	return "${config.ArmClangCflags}"
 }

-func (t *toolchainArm) ClangCppflags() string {
+func (t *toolchainArm) Cppflags() string {
 	return "${config.ArmClangCppflags}"
 }

-func (t *toolchainArm) ClangLdflags() string {
+func (t *toolchainArm) Ldflags() string {
 	return t.ldflags
 }

-func (t *toolchainArm) ClangLldflags() string {
+func (t *toolchainArm) Lldflags() string {
 	return t.lldflags // TODO: handle V8 cases
 }

-func (t *toolchainArm) ClangInstructionSetFlags(isa string) (string, error) {
+func (t *toolchainArm) InstructionSetFlags(isa string) (string, error) {
 	switch isa {
 	case "arm":
 		return "${config.ArmClangArmCflags}", nil
 	case "thumb", "":
 		return "${config.ArmClangThumbCflags}", nil
 	default:
-		return t.toolchainBase.ClangInstructionSetFlags(isa)
+		return t.toolchainBase.InstructionSetFlags(isa)
 	}
 }

@@ -311,13 +308,13 @@ func (toolchainArm) LibclangRuntimeLibraryArch() string {

 func armToolchainFactory(arch android.Arch) Toolchain {
 	var fixCortexA8 string
-	toolchainClangCflags := make([]string, 2, 3)
+	toolchainCflags := make([]string, 2, 3)

-	toolchainClangCflags[0] = "${config.ArmToolchainClangCflags}"
-	toolchainClangCflags[1] = armClangArchVariantCflagsVar[arch.ArchVariant]
+	toolchainCflags[0] = "${config.ArmToolchainClangCflags}"
+	toolchainCflags[1] = armArchVariantCflagsVar[arch.ArchVariant]

-	toolchainClangCflags = append(toolchainClangCflags,
-		variantOrDefault(armClangCpuVariantCflagsVar, arch.CpuVariant))
+	toolchainCflags = append(toolchainCflags,
+		variantOrDefault(armCpuVariantCflagsVar, arch.CpuVariant))

 	switch arch.ArchVariant {
 	case "armv7-a-neon":
@@ -341,8 +338,8 @@ func armToolchainFactory(arch android.Arch) Toolchain {
 			"${config.ArmLdflags}",
 			fixCortexA8,
 		}, " "),
-		lldflags:             "${config.ArmLldflags}",
-		toolchainClangCflags: strings.Join(toolchainClangCflags, " "),
+		lldflags:        "${config.ArmLldflags}",
+		toolchainCflags: strings.Join(toolchainCflags, " "),
 	}
 }

--- a/cc/config/clang.go
+++ b/cc/config/clang.go
@@ -80,12 +80,6 @@ var ClangUnknownCflags = sorted([]string{
 	"--enable-stdcall-fixup",
 })

-// Ldflags that should be filtered out when linking with clang lld
-var ClangUnknownLldflags = sorted([]string{
-	"-Wl,--fix-cortex-a8",
-	"-Wl,--no-fix-cortex-a8",
-})
-
 var ClangLibToolingUnknownCflags = sorted([]string{})

 // List of tidy checks that should be disabled globally. When the compiler is
@@ -255,26 +249,10 @@ func ClangRewriteTidyChecks(checks []string) []string {
 	return result
 }

-func ClangFilterUnknownLldflags(lldflags []string) []string {
-	result, _ := android.FilterList(lldflags, ClangUnknownLldflags)
-	return result
-}
-
 func ClangLibToolingFilterUnknownCflags(libToolingFlags []string) []string {
 	return android.RemoveListFromList(libToolingFlags, ClangLibToolingUnknownCflags)
 }

-func inListSorted(s string, list []string) bool {
-	for _, l := range list {
-		if s == l {
-			return true
-		} else if s < l {
-			return false
-		}
-	}
-	return false
-}
-
 func sorted(list []string) []string {
 	sort.Strings(list)
 	return list
--- a/cc/config/global.go
+++ b/cc/config/global.go
@@ -36,7 +36,6 @@ var (

 		// Make paths in deps files relative
 		"-no-canonical-prefixes",
-		"-fno-canonical-system-headers",

 		"-DNDEBUG",
 		"-UDEBUG",
@@ -61,8 +60,6 @@ var (
 	commonGlobalConlyflags = []string{}

 	deviceGlobalCflags = []string{
-		"-fdiagnostics-color",
-
 		"-ffunction-sections",
 		"-fdata-sections",
 		"-fno-short-enums",
@@ -101,7 +98,7 @@ var (
 		"-Wl,--icf=safe",
 	}

-	deviceGlobalLldflags = append(ClangFilterUnknownLldflags(deviceGlobalLdflags),
+	deviceGlobalLldflags = append(deviceGlobalLdflags,
 		[]string{
 			"-fuse-ld=lld",
 		}...)
@@ -177,7 +174,7 @@ func init() {
 	// Export the static default CommonClangGlobalCflags to Bazel.
 	// TODO(187086342): handle cflags that are set in VariableFuncs.
 	commonClangGlobalCFlags := append(
-		ClangFilterUnknownCflags(commonGlobalCflags),
+		commonGlobalCflags,
 		[]string{
 			"${ClangExtraCflags}",
 			// Default to zero initialization.
@@ -187,7 +184,7 @@ func init() {
 	exportedStringListVars.Set("CommonClangGlobalCflags", commonClangGlobalCFlags)

 	pctx.VariableFunc("CommonClangGlobalCflags", func(ctx android.PackageVarContext) string {
-		flags := ClangFilterUnknownCflags(commonGlobalCflags)
+		flags := commonGlobalCflags
 		flags = append(flags, "${ClangExtraCflags}")

 		// http://b/131390872
@@ -208,20 +205,20 @@ func init() {

 	// Export the static default DeviceClangGlobalCflags to Bazel.
 	// TODO(187086342): handle cflags that are set in VariableFuncs.
-	deviceClangGlobalCflags := append(ClangFilterUnknownCflags(deviceGlobalCflags), "${ClangExtraTargetCflags}")
+	deviceClangGlobalCflags := append(deviceGlobalCflags, "${ClangExtraTargetCflags}")
 	exportedStringListVars.Set("DeviceClangGlobalCflags", deviceClangGlobalCflags)

 	pctx.VariableFunc("DeviceClangGlobalCflags", func(ctx android.PackageVarContext) string {
 		if ctx.Config().Fuchsia() {
-			return strings.Join(ClangFilterUnknownCflags(deviceGlobalCflags), " ")
+			return strings.Join(deviceGlobalCflags, " ")
 		} else {
 			return strings.Join(deviceClangGlobalCflags, " ")
 		}
 	})

-	exportStringListStaticVariable("HostClangGlobalCflags", ClangFilterUnknownCflags(hostGlobalCflags))
-	exportStringListStaticVariable("NoOverrideClangGlobalCflags", append(ClangFilterUnknownCflags(noOverrideGlobalCflags), "${ClangExtraNoOverrideCflags}"))
-	exportStringListStaticVariable("CommonClangGlobalCppflags", append(ClangFilterUnknownCflags(commonGlobalCppflags), "${ClangExtraCppflags}"))
+	exportStringListStaticVariable("HostClangGlobalCflags", hostGlobalCflags)
+	exportStringListStaticVariable("NoOverrideClangGlobalCflags", append(noOverrideGlobalCflags, "${ClangExtraNoOverrideCflags}"))
+	exportStringListStaticVariable("CommonClangGlobalCppflags", append(commonGlobalCppflags, "${ClangExtraCppflags}"))
 	exportStringListStaticVariable("ClangExternalCflags", []string{"${ClangExtraExternalCflags}"})

 	// Everything in these lists is a crime against abstraction and dependency tracking.
--- a/cc/config/toolchain.go
+++ b/cc/config/toolchain.go
@@ -82,14 +82,14 @@ type Toolchain interface {
 	IncludeFlags() string

 	ClangTriple() string
-	ToolchainClangCflags() string
-	ToolchainClangLdflags() string
-	ClangAsflags() string
-	ClangCflags() string
-	ClangCppflags() string
-	ClangLdflags() string
-	ClangLldflags() string
-	ClangInstructionSetFlags(string) (string, error)
+	ToolchainCflags() string
+	ToolchainLdflags() string
+	Asflags() string
+	Cflags() string
+	Cppflags() string
+	Ldflags() string
+	Lldflags() string
+	InstructionSetFlags(string) (string, error)

 	ndkTriple() string

@@ -136,18 +136,18 @@ func NDKTriple(toolchain Toolchain) string {
 	return triple
 }

-func (toolchainBase) ClangInstructionSetFlags(s string) (string, error) {
+func (toolchainBase) InstructionSetFlags(s string) (string, error) {
 	if s != "" {
 		return "", fmt.Errorf("instruction_set: %s is not a supported instruction set", s)
 	}
 	return "", nil
 }

-func (toolchainBase) ToolchainClangCflags() string {
+func (toolchainBase) ToolchainCflags() string {
 	return ""
 }

-func (toolchainBase) ToolchainClangLdflags() string {
+func (toolchainBase) ToolchainLdflags() string {
 	return ""
 }

@@ -159,7 +159,7 @@ func (toolchainBase) ExecutableSuffix() string {
 	return ""
 }

-func (toolchainBase) ClangAsflags() string {
+func (toolchainBase) Asflags() string {
 	return ""
 }

--- a/cc/config/x86_64_device.go
+++ b/cc/config/x86_64_device.go
@@ -32,8 +32,6 @@ var (
 		"-Wl,--hash-style=gnu",
 	}

-	x86_64Lldflags = ClangFilterUnknownLldflags(x86_64Ldflags)
-
 	x86_64ArchVariantCflags = map[string][]string{
 		"": []string{
 			"-march=x86-64",
@@ -102,13 +100,11 @@ func init() {
 	pctx.StaticVariable("X86_64ToolchainLdflags", "-m64")

 	pctx.StaticVariable("X86_64Ldflags", strings.Join(x86_64Ldflags, " "))
-	pctx.StaticVariable("X86_64Lldflags", strings.Join(x86_64Lldflags, " "))
+	pctx.StaticVariable("X86_64Lldflags", strings.Join(x86_64Ldflags, " "))

 	// Clang cflags
-	pctx.StaticVariable("X86_64ClangCflags", strings.Join(ClangFilterUnknownCflags(x86_64Cflags), " "))
-	pctx.StaticVariable("X86_64ClangLdflags", strings.Join(ClangFilterUnknownCflags(x86_64Ldflags), " "))
-	pctx.StaticVariable("X86_64ClangLldflags", strings.Join(ClangFilterUnknownCflags(x86_64Lldflags), " "))
-	pctx.StaticVariable("X86_64ClangCppflags", strings.Join(ClangFilterUnknownCflags(x86_64Cppflags), " "))
+	pctx.StaticVariable("X86_64ClangCflags", strings.Join(x86_64Cflags, " "))
+	pctx.StaticVariable("X86_64ClangCppflags", strings.Join(x86_64Cppflags, " "))

 	// Yasm flags
 	pctx.StaticVariable("X86_64YasmFlags", "-f elf64 -m amd64")
@@ -118,14 +114,14 @@ func init() {
 	// Architecture variant cflags
 	for variant, cflags := range x86_64ArchVariantCflags {
 		pctx.StaticVariable("X86_64"+variant+"VariantClangCflags",
-			strings.Join(ClangFilterUnknownCflags(cflags), " "))
+			strings.Join(cflags, " "))
 	}
 }

 type toolchainX86_64 struct {
 	toolchainBionic
 	toolchain64Bit
-	toolchainClangCflags string
+	toolchainCflags string
 }

 func (t *toolchainX86_64) Name() string {
@@ -152,27 +148,27 @@ func (t *toolchainX86_64) ClangTriple() string {
 	return t.GccTriple()
 }

-func (t *toolchainX86_64) ToolchainClangLdflags() string {
+func (t *toolchainX86_64) ToolchainLdflags() string {
 	return "${config.X86_64ToolchainLdflags}"
 }

-func (t *toolchainX86_64) ToolchainClangCflags() string {
-	return t.toolchainClangCflags
+func (t *toolchainX86_64) ToolchainCflags() string {
+	return t.toolchainCflags
 }

-func (t *toolchainX86_64) ClangCflags() string {
+func (t *toolchainX86_64) Cflags() string {
 	return "${config.X86_64ClangCflags}"
 }

-func (t *toolchainX86_64) ClangCppflags() string {
+func (t *toolchainX86_64) Cppflags() string {
 	return "${config.X86_64ClangCppflags}"
 }

-func (t *toolchainX86_64) ClangLdflags() string {
+func (t *toolchainX86_64) Ldflags() string {
 	return "${config.X86_64Ldflags}"
 }

-func (t *toolchainX86_64) ClangLldflags() string {
+func (t *toolchainX86_64) Lldflags() string {
 	return "${config.X86_64Lldflags}"
 }

@@ -185,17 +181,17 @@ func (toolchainX86_64) LibclangRuntimeLibraryArch() string {
 }

 func x86_64ToolchainFactory(arch android.Arch) Toolchain {
-	toolchainClangCflags := []string{
+	toolchainCflags := []string{
 		"${config.X86_64ToolchainCflags}",
 		"${config.X86_64" + arch.ArchVariant + "VariantClangCflags}",
 	}

 	for _, feature := range arch.ArchFeatures {
-		toolchainClangCflags = append(toolchainClangCflags, x86_64ArchFeatureCflags[feature]...)
+		toolchainCflags = append(toolchainCflags, x86_64ArchFeatureCflags[feature]...)
 	}

 	return &toolchainX86_64{
-		toolchainClangCflags: strings.Join(toolchainClangCflags, " "),
+		toolchainCflags: strings.Join(toolchainCflags, " "),
 	}
 }

--- a/cc/config/x86_64_fuchsia_device.go
+++ b/cc/config/x86_64_fuchsia_device.go
@@ -46,18 +46,6 @@ func (t *toolchainFuchsiaX8664) GccVersion() string {
 	return x86_64GccVersion
 }

-func (t *toolchainFuchsiaX8664) Cflags() string {
-	return ""
-}
-
-func (t *toolchainFuchsiaX8664) Cppflags() string {
-	return ""
-}
-
-func (t *toolchainFuchsiaX8664) Ldflags() string {
-	return ""
-}
-
 func (t *toolchainFuchsiaX8664) IncludeFlags() string {
 	return ""
 }
@@ -66,20 +54,20 @@ func (t *toolchainFuchsiaX8664) ClangTriple() string {
 	return "x86_64-fuchsia-android"
 }

-func (t *toolchainFuchsiaX8664) ClangCppflags() string {
+func (t *toolchainFuchsiaX8664) Cppflags() string {
 	return "-Wno-error=deprecated-declarations"
 }

-func (t *toolchainFuchsiaX8664) ClangLdflags() string {
+func (t *toolchainFuchsiaX8664) Ldflags() string {
 	return "--target=x86_64-fuchsia --sysroot=" + fuchsiaSysRoot + " -L" + fuchsiaPrebuiltLibsRoot + "/x86_64-fuchsia/lib " + "-Lprebuilts/fuchsia_sdk/arch/x64/dist/"

 }

-func (t *toolchainFuchsiaX8664) ClangLldflags() string {
+func (t *toolchainFuchsiaX8664) Lldflags() string {
 	return "--target=x86_64-fuchsia --sysroot=" + fuchsiaSysRoot + " -L" + fuchsiaPrebuiltLibsRoot + "/x86_64-fuchsia/lib " + "-Lprebuilts/fuchsia_sdk/arch/x64/dist/"
 }

-func (t *toolchainFuchsiaX8664) ClangCflags() string {
+func (t *toolchainFuchsiaX8664) Cflags() string {
 	return "--target=x86_64-fuchsia --sysroot=" + fuchsiaSysRoot + " -I" + fuchsiaSysRoot + "/include"
 }

@@ -87,7 +75,7 @@ func (t *toolchainFuchsiaX8664) YasmFlags() string {
 	return "-f elf64 -m amd64"
 }

-func (t *toolchainFuchsiaX8664) ToolchainClangCflags() string {
+func (t *toolchainFuchsiaX8664) ToolchainCflags() string {
 	return "-mssse3"
 }

--- a/cc/config/x86_darwin_host.go
+++ b/cc/config/x86_darwin_host.go
@@ -26,8 +26,6 @@ import (

 var (
 	darwinCflags = []string{
-		"-fdiagnostics-color",
-
 		"-fPIC",
 		"-funwind-tables",

@@ -41,6 +39,9 @@ var (
 		"-DMACOSX_DEPLOYMENT_TARGET=${macMinVersion}",

 		"-m64",
+
+		"-integrated-as",
+		"-fstack-protector-strong",
 	}

 	darwinLdflags = []string{
@@ -50,15 +51,6 @@ var (
 		"-m64",
 	}

-	darwinClangCflags = append(ClangFilterUnknownCflags(darwinCflags), []string{
-		"-integrated-as",
-		"-fstack-protector-strong",
-	}...)
-
-	darwinClangLdflags = ClangFilterUnknownCflags(darwinLdflags)
-
-	darwinClangLldflags = ClangFilterUnknownLldflags(darwinClangLdflags)
-
 	darwinSupportedSdkVersions = []string{
 		"10.10",
 		"10.11",
@@ -115,9 +107,9 @@ func init() {

 	pctx.StaticVariable("DarwinGccTriple", "i686-apple-darwin11")

-	pctx.StaticVariable("DarwinClangCflags", strings.Join(darwinClangCflags, " "))
-	pctx.StaticVariable("DarwinClangLdflags", strings.Join(darwinClangLdflags, " "))
-	pctx.StaticVariable("DarwinClangLldflags", strings.Join(darwinClangLldflags, " "))
+	pctx.StaticVariable("DarwinClangCflags", strings.Join(darwinCflags, " "))
+	pctx.StaticVariable("DarwinClangLdflags", strings.Join(darwinLdflags, " "))
+	pctx.StaticVariable("DarwinClangLldflags", strings.Join(darwinLdflags, " "))

 	pctx.StaticVariable("DarwinYasmFlags", "-f macho -m amd64")
 }
@@ -213,19 +205,19 @@ func (t *toolchainDarwin) ClangTriple() string {
 	return "x86_64-apple-darwin"
 }

-func (t *toolchainDarwin) ClangCflags() string {
+func (t *toolchainDarwin) Cflags() string {
 	return "${config.DarwinClangCflags}"
 }

-func (t *toolchainDarwin) ClangCppflags() string {
+func (t *toolchainDarwin) Cppflags() string {
 	return ""
 }

-func (t *toolchainDarwin) ClangLdflags() string {
+func (t *toolchainDarwin) Ldflags() string {
 	return "${config.DarwinClangLdflags}"
 }

-func (t *toolchainDarwin) ClangLldflags() string {
+func (t *toolchainDarwin) Lldflags() string {
 	return "${config.DarwinClangLldflags}"
 }

--- a/cc/config/x86_device.go
+++ b/cc/config/x86_device.go
@@ -21,16 +21,14 @@ import (
 )

 var (
-	x86Cflags = []string{}
-
-	x86ClangCflags = append(x86Cflags, []string{
+	x86Cflags = []string{
 		"-msse3",

 		// -mstackrealign is needed to realign stack in native code
 		// that could be called from JNI, so that movaps instruction
 		// will work on assumed stack aligned local variables.
 		"-mstackrealign",
-	}...)
+	}

 	x86Cppflags = []string{}

@@ -38,8 +36,6 @@ var (
 		"-Wl,--hash-style=gnu",
 	}

-	x86Lldflags = ClangFilterUnknownLldflags(x86Ldflags)
-
 	x86ArchVariantCflags = map[string][]string{
 		"": []string{
 			"-march=prescott",
@@ -49,35 +45,27 @@ var (
 		},
 		"atom": []string{
 			"-march=atom",
-			"-mfpmath=sse",
 		},
 		"broadwell": []string{
 			"-march=broadwell",
-			"-mfpmath=sse",
 		},
 		"haswell": []string{
 			"-march=core-avx2",
-			"-mfpmath=sse",
 		},
 		"ivybridge": []string{
 			"-march=core-avx-i",
-			"-mfpmath=sse",
 		},
 		"sandybridge": []string{
 			"-march=corei7",
-			"-mfpmath=sse",
 		},
 		"silvermont": []string{
 			"-march=slm",
-			"-mfpmath=sse",
 		},
 		"skylake": []string{
 			"-march=skylake",
-			"-mfpmath=sse",
 		},
 		"stoneyridge": []string{
 			"-march=bdver4",
-			"-mfpmath=sse",
 		},
 	}

@@ -113,13 +101,12 @@ func init() {
 	pctx.StaticVariable("X86ToolchainLdflags", "-m32")

 	pctx.StaticVariable("X86Ldflags", strings.Join(x86Ldflags, " "))
-	pctx.StaticVariable("X86Lldflags", strings.Join(x86Lldflags, " "))
+	pctx.StaticVariable("X86Lldflags", strings.Join(x86Ldflags, " "))

 	// Clang cflags
-	pctx.StaticVariable("X86ClangCflags", strings.Join(ClangFilterUnknownCflags(x86ClangCflags), " "))
-	pctx.StaticVariable("X86ClangLdflags", strings.Join(ClangFilterUnknownCflags(x86Ldflags), " "))
-	pctx.StaticVariable("X86ClangLldflags", strings.Join(ClangFilterUnknownCflags(x86Lldflags), " "))
-	pctx.StaticVariable("X86ClangCppflags", strings.Join(ClangFilterUnknownCflags(x86Cppflags), " "))
+	pctx.StaticVariable("X86ClangLldflags", strings.Join(x86Ldflags, " "))
+	pctx.StaticVariable("X86ClangCflags", strings.Join(x86Cflags, " "))
+	pctx.StaticVariable("X86ClangCppflags", strings.Join(x86Cppflags, " "))

 	// Yasm flags
 	pctx.StaticVariable("X86YasmFlags", "-f elf32 -m x86")
@@ -129,14 +116,14 @@ func init() {
 	// Architecture variant cflags
 	for variant, cflags := range x86ArchVariantCflags {
 		pctx.StaticVariable("X86"+variant+"VariantClangCflags",
-			strings.Join(ClangFilterUnknownCflags(cflags), " "))
+			strings.Join(cflags, " "))
 	}
 }

 type toolchainX86 struct {
 	toolchainBionic
 	toolchain32Bit
-	toolchainClangCflags string
+	toolchainCflags string
 }

 func (t *toolchainX86) Name() string {
@@ -163,27 +150,27 @@ func (t *toolchainX86) ClangTriple() string {
 	return "i686-linux-android"
 }

-func (t *toolchainX86) ToolchainClangLdflags() string {
+func (t *toolchainX86) ToolchainLdflags() string {
 	return "${config.X86ToolchainLdflags}"
 }

-func (t *toolchainX86) ToolchainClangCflags() string {
-	return t.toolchainClangCflags
+func (t *toolchainX86) ToolchainCflags() string {
+	return t.toolchainCflags
 }

-func (t *toolchainX86) ClangCflags() string {
+func (t *toolchainX86) Cflags() string {
 	return "${config.X86ClangCflags}"
 }

-func (t *toolchainX86) ClangCppflags() string {
+func (t *toolchainX86) Cppflags() string {
 	return "${config.X86ClangCppflags}"
 }

-func (t *toolchainX86) ClangLdflags() string {
+func (t *toolchainX86) Ldflags() string {
 	return "${config.X86Ldflags}"
 }

-func (t *toolchainX86) ClangLldflags() string {
+func (t *toolchainX86) Lldflags() string {
 	return "${config.X86Lldflags}"
 }

@@ -196,17 +183,17 @@ func (toolchainX86) LibclangRuntimeLibraryArch() string {
 }

 func x86ToolchainFactory(arch android.Arch) Toolchain {
-	toolchainClangCflags := []string{
+	toolchainCflags := []string{
 		"${config.X86ToolchainCflags}",
 		"${config.X86" + arch.ArchVariant + "VariantClangCflags}",
 	}

 	for _, feature := range arch.ArchFeatures {
-		toolchainClangCflags = append(toolchainClangCflags, x86ArchFeatureCflags[feature]...)
+		toolchainCflags = append(toolchainCflags, x86ArchFeatureCflags[feature]...)
 	}

 	return &toolchainX86{
-		toolchainClangCflags: strings.Join(toolchainClangCflags, " "),
+		toolchainCflags: strings.Join(toolchainCflags, " "),
 	}
 }

--- a/cc/config/x86_linux_bionic_host.go
+++ b/cc/config/x86_linux_bionic_host.go
@@ -21,9 +21,7 @@ import (
 )

 var (
-	linuxBionicCflags = ClangFilterUnknownCflags([]string{
-		"-fdiagnostics-color",
-
+	linuxBionicCflags = []string{
 		"-Wa,--noexecstack",

 		"-fPIC",
@@ -34,21 +32,17 @@ var (

 		// From x86_64_device
 		"-ffunction-sections",
-		"-finline-functions",
-		"-finline-limit=300",
 		"-fno-short-enums",
-		"-funswitch-loops",
 		"-funwind-tables",
-		"-fno-canonical-system-headers",

 		// Tell clang where the gcc toolchain is
 		"--gcc-toolchain=${LinuxBionicGccRoot}",

 		// This is normally in ClangExtraTargetCflags, but this is considered host
 		"-nostdlibinc",
-	})
+	}

-	linuxBionicLdflags = ClangFilterUnknownCflags([]string{
+	linuxBionicLdflags = []string{
 		"-Wl,-z,noexecstack",
 		"-Wl,-z,relro",
 		"-Wl,-z,now",
@@ -60,9 +54,7 @@ var (

 		// Use the device gcc toolchain
 		"--gcc-toolchain=${LinuxBionicGccRoot}",
-	})
-
-	linuxBionicLldflags = ClangFilterUnknownLldflags(linuxBionicLdflags)
+	}

 	// Embed the linker into host bionic binaries. This is needed to support host bionic,
 	// as the linux kernel requires that the ELF interpreter referenced by PT_INTERP be
@@ -78,7 +70,7 @@ var (
 func init() {
 	pctx.StaticVariable("LinuxBionicCflags", strings.Join(linuxBionicCflags, " "))
 	pctx.StaticVariable("LinuxBionicLdflags", strings.Join(linuxBionicLdflags, " "))
-	pctx.StaticVariable("LinuxBionicLldflags", strings.Join(linuxBionicLldflags, " "))
+	pctx.StaticVariable("LinuxBionicLldflags", strings.Join(linuxBionicLdflags, " "))

 	// Use the device gcc toolchain for now
 	pctx.StaticVariable("LinuxBionicGccRoot", "${X86_64GccRoot}")
@@ -114,29 +106,29 @@ func (t *toolchainLinuxBionic) ClangTriple() string {
 	return "x86_64-linux-android"
 }

-func (t *toolchainLinuxBionic) ClangCflags() string {
+func (t *toolchainLinuxBionic) Cflags() string {
 	return "${config.LinuxBionicCflags}"
 }

-func (t *toolchainLinuxBionic) ClangCppflags() string {
+func (t *toolchainLinuxBionic) Cppflags() string {
 	return ""
 }

-func (t *toolchainLinuxBionic) ClangLdflags() string {
+func (t *toolchainLinuxBionic) Ldflags() string {
 	return "${config.LinuxBionicLdflags}"
 }

-func (t *toolchainLinuxBionic) ClangLldflags() string {
+func (t *toolchainLinuxBionic) Lldflags() string {
 	return "${config.LinuxBionicLldflags}"
 }

-func (t *toolchainLinuxBionic) ToolchainClangCflags() string {
+func (t *toolchainLinuxBionic) ToolchainCflags() string {
 	return "-m64 -march=x86-64" +
 		// TODO: We're not really android, but we don't have a triple yet b/31393676
 		" -U__ANDROID__"
 }

-func (t *toolchainLinuxBionic) ToolchainClangLdflags() string {
+func (t *toolchainLinuxBionic) ToolchainLdflags() string {
 	return "-m64"
 }

--- a/cc/config/x86_linux_host.go
+++ b/cc/config/x86_linux_host.go
@@ -22,8 +22,6 @@ import (

 var (
 	linuxCflags = []string{
-		"-fdiagnostics-color",
-
 		"-Wa,--noexecstack",

 		"-fPIC",
@@ -36,6 +34,10 @@ var (
 		//See bug 12708004.
 		"-D__STDC_FORMAT_MACROS",
 		"-D__STDC_CONSTANT_MACROS",
+
+		"--gcc-toolchain=${LinuxGccRoot}",
+		"--sysroot ${LinuxGccRoot}/sysroot",
+		"-fstack-protector-strong",
 	}

 	linuxLdflags = []string{
@@ -43,12 +45,14 @@ var (
 		"-Wl,-z,relro",
 		"-Wl,-z,now",
 		"-Wl,--no-undefined-version",
+
+		"--gcc-toolchain=${LinuxGccRoot}",
+		"--sysroot ${LinuxGccRoot}/sysroot",
 	}

 	// Extended cflags
 	linuxX86Cflags = []string{
 		"-msse3",
-		"-mfpmath=sse",
 		"-m32",
 		"-march=prescott",
 		"-D_FILE_OFFSET_BITS=64",
@@ -61,40 +65,17 @@ var (

 	linuxX86Ldflags = []string{
 		"-m32",
+		"-B${LinuxGccRoot}/lib/gcc/${LinuxGccTriple}/${LinuxGccVersion}/32",
+		"-L${LinuxGccRoot}/lib/gcc/${LinuxGccTriple}/${LinuxGccVersion}/32",
+		"-L${LinuxGccRoot}/${LinuxGccTriple}/lib32",
 	}

 	linuxX8664Ldflags = []string{
 		"-m64",
-	}
-
-	linuxClangCflags = append(ClangFilterUnknownCflags(linuxCflags), []string{
-		"--gcc-toolchain=${LinuxGccRoot}",
-		"--sysroot ${LinuxGccRoot}/sysroot",
-		"-fstack-protector-strong",
-	}...)
-
-	linuxClangLdflags = append(ClangFilterUnknownCflags(linuxLdflags), []string{
-		"--gcc-toolchain=${LinuxGccRoot}",
-		"--sysroot ${LinuxGccRoot}/sysroot",
-	}...)
-
-	linuxClangLldflags = ClangFilterUnknownLldflags(linuxClangLdflags)
-
-	linuxX86ClangLdflags = append(ClangFilterUnknownCflags(linuxX86Ldflags), []string{
-		"-B${LinuxGccRoot}/lib/gcc/${LinuxGccTriple}/${LinuxGccVersion}/32",
-		"-L${LinuxGccRoot}/lib/gcc/${LinuxGccTriple}/${LinuxGccVersion}/32",
-		"-L${LinuxGccRoot}/${LinuxGccTriple}/lib32",
-	}...)
-
-	linuxX86ClangLldflags = ClangFilterUnknownLldflags(linuxX86ClangLdflags)
-
-	linuxX8664ClangLdflags = append(ClangFilterUnknownCflags(linuxX8664Ldflags), []string{
 		"-B${LinuxGccRoot}/lib/gcc/${LinuxGccTriple}/${LinuxGccVersion}",
 		"-L${LinuxGccRoot}/lib/gcc/${LinuxGccTriple}/${LinuxGccVersion}",
 		"-L${LinuxGccRoot}/${LinuxGccTriple}/lib64",
-	}...)
-
-	linuxX8664ClangLldflags = ClangFilterUnknownLldflags(linuxX8664ClangLdflags)
+	}

 	linuxAvailableLibraries = addPrefix([]string{
 		"c",
@@ -130,18 +111,16 @@ func init() {

 	pctx.StaticVariable("LinuxGccTriple", "x86_64-linux")

-	pctx.StaticVariable("LinuxClangCflags", strings.Join(linuxClangCflags, " "))
-	pctx.StaticVariable("LinuxClangLdflags", strings.Join(linuxClangLdflags, " "))
-	pctx.StaticVariable("LinuxClangLldflags", strings.Join(linuxClangLldflags, " "))
+	pctx.StaticVariable("LinuxClangCflags", strings.Join(linuxCflags, " "))
+	pctx.StaticVariable("LinuxClangLdflags", strings.Join(linuxLdflags, " "))
+	pctx.StaticVariable("LinuxClangLldflags", strings.Join(linuxLdflags, " "))

-	pctx.StaticVariable("LinuxX86ClangCflags",
-		strings.Join(ClangFilterUnknownCflags(linuxX86Cflags), " "))
-	pctx.StaticVariable("LinuxX8664ClangCflags",
-		strings.Join(ClangFilterUnknownCflags(linuxX8664Cflags), " "))
-	pctx.StaticVariable("LinuxX86ClangLdflags", strings.Join(linuxX86ClangLdflags, " "))
-	pctx.StaticVariable("LinuxX86ClangLldflags", strings.Join(linuxX86ClangLldflags, " "))
-	pctx.StaticVariable("LinuxX8664ClangLdflags", strings.Join(linuxX8664ClangLdflags, " "))
-	pctx.StaticVariable("LinuxX8664ClangLldflags", strings.Join(linuxX8664ClangLldflags, " "))
+	pctx.StaticVariable("LinuxX86ClangCflags", strings.Join(linuxX86Cflags, " "))
+	pctx.StaticVariable("LinuxX8664ClangCflags", strings.Join(linuxX8664Cflags, " "))
+	pctx.StaticVariable("LinuxX86ClangLdflags", strings.Join(linuxX86Ldflags, " "))
+	pctx.StaticVariable("LinuxX86ClangLldflags", strings.Join(linuxX86Ldflags, " "))
+	pctx.StaticVariable("LinuxX8664ClangLdflags", strings.Join(linuxX8664Ldflags, " "))
+	pctx.StaticVariable("LinuxX8664ClangLldflags", strings.Join(linuxX8664Ldflags, " "))
 	// Yasm flags
 	pctx.StaticVariable("LinuxX86YasmFlags", "-f elf32 -m x86")
 	pctx.StaticVariable("LinuxX8664YasmFlags", "-f elf64 -m amd64")
@@ -189,11 +168,11 @@ func (t *toolchainLinuxX86) ClangTriple() string {
 	return "i686-linux-gnu"
 }

-func (t *toolchainLinuxX86) ClangCflags() string {
+func (t *toolchainLinuxX86) Cflags() string {
 	return "${config.LinuxClangCflags} ${config.LinuxX86ClangCflags}"
 }

-func (t *toolchainLinuxX86) ClangCppflags() string {
+func (t *toolchainLinuxX86) Cppflags() string {
 	return ""
 }

@@ -201,27 +180,27 @@ func (t *toolchainLinuxX8664) ClangTriple() string {
 	return "x86_64-linux-gnu"
 }

-func (t *toolchainLinuxX8664) ClangCflags() string {
+func (t *toolchainLinuxX8664) Cflags() string {
 	return "${config.LinuxClangCflags} ${config.LinuxX8664ClangCflags}"
 }

-func (t *toolchainLinuxX8664) ClangCppflags() string {
+func (t *toolchainLinuxX8664) Cppflags() string {
 	return ""
 }

-func (t *toolchainLinuxX86) ClangLdflags() string {
+func (t *toolchainLinuxX86) Ldflags() string {
 	return "${config.LinuxClangLdflags} ${config.LinuxX86ClangLdflags}"
 }

-func (t *toolchainLinuxX86) ClangLldflags() string {
+func (t *toolchainLinuxX86) Lldflags() string {
 	return "${config.LinuxClangLldflags} ${config.LinuxX86ClangLldflags}"
 }

-func (t *toolchainLinuxX8664) ClangLdflags() string {
+func (t *toolchainLinuxX8664) Ldflags() string {
 	return "${config.LinuxClangLdflags} ${config.LinuxX8664ClangLdflags}"
 }

-func (t *toolchainLinuxX8664) ClangLldflags() string {
+func (t *toolchainLinuxX8664) Lldflags() string {
 	return "${config.LinuxClangLldflags} ${config.LinuxX8664ClangLldflags}"
 }

--- a/cc/config/x86_windows_host.go
+++ b/cc/config/x86_windows_host.go
@@ -44,32 +44,28 @@ var (

 		"--sysroot ${WindowsGccRoot}/${WindowsGccTriple}",
 	}
-	windowsClangCflags = append(ClangFilterUnknownCflags(windowsCflags), []string{}...)

 	windowsIncludeFlags = []string{
 		"-isystem ${WindowsGccRoot}/${WindowsGccTriple}/include",
 	}

-	windowsClangCppflags = []string{}
+	windowsCppflags = []string{}

-	windowsX86ClangCppflags = []string{
+	windowsX86Cppflags = []string{
 		// Use SjLj exceptions for 32-bit.  libgcc_eh implements SjLj
 		// exception model for 32-bit.
 		"-fsjlj-exceptions",
 	}

-	windowsX8664ClangCppflags = []string{}
+	windowsX8664Cppflags = []string{}

 	windowsLdflags = []string{
-		"--enable-stdcall-fixup",
 		"-Wl,--dynamicbase",
 		"-Wl,--nxcompat",
 	}
-	windowsLldflags = []string{
+	windowsLldflags = append(windowsLdflags, []string{
 		"-Wl,--Xlink=-Brepro", // Enable deterministic build
-	}
-	windowsClangLdflags  = append(ClangFilterUnknownCflags(windowsLdflags), []string{}...)
-	windowsClangLldflags = append(ClangFilterUnknownLldflags(windowsClangLdflags), windowsLldflags...)
+	}...)

 	windowsX86Cflags = []string{
 		"-m32",
@@ -84,28 +80,24 @@ var (
 		"-Wl,--large-address-aware",
 		"-L${WindowsGccRoot}/${WindowsGccTriple}/lib32",
 		"-static-libgcc",
-	}
-	windowsX86ClangLdflags = append(ClangFilterUnknownCflags(windowsX86Ldflags), []string{
+
 		"-B${WindowsGccRoot}/${WindowsGccTriple}/bin",
 		"-B${WindowsGccRoot}/lib/gcc/${WindowsGccTriple}/4.8.3/32",
 		"-L${WindowsGccRoot}/lib/gcc/${WindowsGccTriple}/4.8.3/32",
 		"-B${WindowsGccRoot}/${WindowsGccTriple}/lib32",
-	}...)
-	windowsX86ClangLldflags = ClangFilterUnknownLldflags(windowsX86ClangLdflags)
+	}

 	windowsX8664Ldflags = []string{
 		"-m64",
 		"-L${WindowsGccRoot}/${WindowsGccTriple}/lib64",
 		"-Wl,--high-entropy-va",
 		"-static-libgcc",
-	}
-	windowsX8664ClangLdflags = append(ClangFilterUnknownCflags(windowsX8664Ldflags), []string{
+
 		"-B${WindowsGccRoot}/${WindowsGccTriple}/bin",
 		"-B${WindowsGccRoot}/lib/gcc/${WindowsGccTriple}/4.8.3",
 		"-L${WindowsGccRoot}/lib/gcc/${WindowsGccTriple}/4.8.3",
 		"-B${WindowsGccRoot}/${WindowsGccTriple}/lib64",
-	}...)
-	windowsX8664ClangLldflags = ClangFilterUnknownLldflags(windowsX8664ClangLdflags)
+	}

 	windowsAvailableLibraries = addPrefix([]string{
 		"gdi32",
@@ -138,21 +130,19 @@ func init() {

 	pctx.StaticVariable("WindowsGccTriple", "x86_64-w64-mingw32")

-	pctx.StaticVariable("WindowsClangCflags", strings.Join(windowsClangCflags, " "))
-	pctx.StaticVariable("WindowsClangLdflags", strings.Join(windowsClangLdflags, " "))
-	pctx.StaticVariable("WindowsClangLldflags", strings.Join(windowsClangLldflags, " "))
-	pctx.StaticVariable("WindowsClangCppflags", strings.Join(windowsClangCppflags, " "))
+	pctx.StaticVariable("WindowsClangCflags", strings.Join(windowsCflags, " "))
+	pctx.StaticVariable("WindowsClangLdflags", strings.Join(windowsLdflags, " "))
+	pctx.StaticVariable("WindowsClangLldflags", strings.Join(windowsLldflags, " "))
+	pctx.StaticVariable("WindowsClangCppflags", strings.Join(windowsCppflags, " "))

-	pctx.StaticVariable("WindowsX86ClangCflags",
-		strings.Join(ClangFilterUnknownCflags(windowsX86Cflags), " "))
-	pctx.StaticVariable("WindowsX8664ClangCflags",
-		strings.Join(ClangFilterUnknownCflags(windowsX8664Cflags), " "))
-	pctx.StaticVariable("WindowsX86ClangLdflags", strings.Join(windowsX86ClangLdflags, " "))
-	pctx.StaticVariable("WindowsX86ClangLldflags", strings.Join(windowsX86ClangLldflags, " "))
-	pctx.StaticVariable("WindowsX8664ClangLdflags", strings.Join(windowsX8664ClangLdflags, " "))
-	pctx.StaticVariable("WindowsX8664ClangLldflags", strings.Join(windowsX8664ClangLldflags, " "))
-	pctx.StaticVariable("WindowsX86ClangCppflags", strings.Join(windowsX86ClangCppflags, " "))
-	pctx.StaticVariable("WindowsX8664ClangCppflags", strings.Join(windowsX8664ClangCppflags, " "))
+	pctx.StaticVariable("WindowsX86ClangCflags", strings.Join(windowsX86Cflags, " "))
+	pctx.StaticVariable("WindowsX8664ClangCflags", strings.Join(windowsX8664Cflags, " "))
+	pctx.StaticVariable("WindowsX86ClangLdflags", strings.Join(windowsX86Ldflags, " "))
+	pctx.StaticVariable("WindowsX86ClangLldflags", strings.Join(windowsX86Ldflags, " "))
+	pctx.StaticVariable("WindowsX8664ClangLdflags", strings.Join(windowsX8664Ldflags, " "))
+	pctx.StaticVariable("WindowsX8664ClangLldflags", strings.Join(windowsX8664Ldflags, " "))
+	pctx.StaticVariable("WindowsX86ClangCppflags", strings.Join(windowsX86Cppflags, " "))
+	pctx.StaticVariable("WindowsX8664ClangCppflags", strings.Join(windowsX8664Cppflags, " "))

 	pctx.StaticVariable("WindowsIncludeFlags", strings.Join(windowsIncludeFlags, " "))
 	// Yasm flags
@@ -214,35 +204,35 @@ func (t *toolchainWindowsX8664) ClangTriple() string {
 	return "x86_64-pc-windows-gnu"
 }

-func (t *toolchainWindowsX86) ClangCflags() string {
+func (t *toolchainWindowsX86) Cflags() string {
 	return "${config.WindowsClangCflags} ${config.WindowsX86ClangCflags}"
 }

-func (t *toolchainWindowsX8664) ClangCflags() string {
+func (t *toolchainWindowsX8664) Cflags() string {
 	return "${config.WindowsClangCflags} ${config.WindowsX8664ClangCflags}"
 }

-func (t *toolchainWindowsX86) ClangCppflags() string {
+func (t *toolchainWindowsX86) Cppflags() string {
 	return "${config.WindowsClangCppflags} ${config.WindowsX86ClangCppflags}"
 }

-func (t *toolchainWindowsX8664) ClangCppflags() string {
+func (t *toolchainWindowsX8664) Cppflags() string {
 	return "${config.WindowsClangCppflags} ${config.WindowsX8664ClangCppflags}"
 }

-func (t *toolchainWindowsX86) ClangLdflags() string {
+func (t *toolchainWindowsX86) Ldflags() string {
 	return "${config.WindowsClangLdflags} ${config.WindowsX86ClangLdflags}"
 }

-func (t *toolchainWindowsX86) ClangLldflags() string {
+func (t *toolchainWindowsX86) Lldflags() string {
 	return "${config.WindowsClangLldflags} ${config.WindowsX86ClangLldflags}"
 }

-func (t *toolchainWindowsX8664) ClangLdflags() string {
+func (t *toolchainWindowsX8664) Ldflags() string {
 	return "${config.WindowsClangLdflags} ${config.WindowsX8664ClangLdflags}"
 }

-func (t *toolchainWindowsX8664) ClangLldflags() string {
+func (t *toolchainWindowsX8664) Lldflags() string {
 	return "${config.WindowsClangLldflags} ${config.WindowsX8664ClangLldflags}"
 }

--- a/cc/linker.go
+++ b/cc/linker.go
@@ -479,9 +479,9 @@ func (linker *baseLinker) linkerFlags(ctx ModuleContext, flags Flags) Flags {
 	}

 	if linker.useClangLld(ctx) {
-		flags.Global.LdFlags = append(flags.Global.LdFlags, toolchain.ClangLldflags())
+		flags.Global.LdFlags = append(flags.Global.LdFlags, toolchain.Lldflags())
 	} else {
-		flags.Global.LdFlags = append(flags.Global.LdFlags, toolchain.ClangLdflags())
+		flags.Global.LdFlags = append(flags.Global.LdFlags, toolchain.Ldflags())
 	}

 	if !ctx.toolchain().Bionic() && !ctx.Fuchsia() {
@@ -535,7 +535,7 @@ func (linker *baseLinker) linkerFlags(ctx ModuleContext, flags Flags) Flags {
 		flags.Global.LdFlags = append(flags.Global.LdFlags, "-Wl,--hash-style=both")
 	}

-	flags.Global.LdFlags = append(flags.Global.LdFlags, toolchain.ToolchainClangLdflags())
+	flags.Global.LdFlags = append(flags.Global.LdFlags, toolchain.ToolchainLdflags())

 	if Bool(linker.Properties.Group_static_libs) {
 		flags.GroupStaticLibs = true
--- a/cc/makevars.go
+++ b/cc/makevars.go
@@ -212,13 +212,13 @@ func makeVarsToolchain(ctx android.MakeVarsContext, secondPrefix string,
 	ctx.StrictRaw(makePrefix+"C_SYSTEM_INCLUDES", strings.Join(systemIncludes, " "))

 	if target.Arch.ArchType == android.Arm {
-		flags, err := toolchain.ClangInstructionSetFlags("arm")
+		flags, err := toolchain.InstructionSetFlags("arm")
 		if err != nil {
 			panic(err)
 		}
 		ctx.Strict(makePrefix+"arm_CFLAGS", flags)

-		flags, err = toolchain.ClangInstructionSetFlags("thumb")
+		flags, err = toolchain.InstructionSetFlags("thumb")
 		if err != nil {
 			panic(err)
 		}
@@ -230,29 +230,29 @@ func makeVarsToolchain(ctx android.MakeVarsContext, secondPrefix string,

 	ctx.Strict(clangPrefix+"TRIPLE", toolchain.ClangTriple())
 	ctx.Strict(clangPrefix+"GLOBAL_CFLAGS", strings.Join([]string{
-		toolchain.ClangCflags(),
+		toolchain.Cflags(),
 		"${config.CommonClangGlobalCflags}",
 		fmt.Sprintf("${config.%sClangGlobalCflags}", hod),
-		toolchain.ToolchainClangCflags(),
+		toolchain.ToolchainCflags(),
 		clangExtras,
 		productExtraCflags,
 	}, " "))
 	ctx.Strict(clangPrefix+"GLOBAL_CPPFLAGS", strings.Join([]string{
 		"${config.CommonClangGlobalCppflags}",
 		fmt.Sprintf("${config.%sGlobalCppflags}", hod),
-		toolchain.ClangCppflags(),
+		toolchain.Cppflags(),
 	}, " "))
 	ctx.Strict(clangPrefix+"GLOBAL_LDFLAGS", strings.Join([]string{
 		fmt.Sprintf("${config.%sGlobalLdflags}", hod),
-		toolchain.ClangLdflags(),
-		toolchain.ToolchainClangLdflags(),
+		toolchain.Ldflags(),
+		toolchain.ToolchainLdflags(),
 		productExtraLdflags,
 		clangExtras,
 	}, " "))
 	ctx.Strict(clangPrefix+"GLOBAL_LLDFLAGS", strings.Join([]string{
 		fmt.Sprintf("${config.%sGlobalLldflags}", hod),
-		toolchain.ClangLldflags(),
-		toolchain.ToolchainClangLdflags(),
+		toolchain.Lldflags(),
+		toolchain.ToolchainLdflags(),
 		productExtraLdflags,
 		clangExtras,
 	}, " "))
--- a/cc/object.go
+++ b/cc/object.go
@@ -224,7 +224,7 @@ func (object *objectLinker) linkerDeps(ctx DepsContext, deps Deps) Deps {
 }

 func (object *objectLinker) linkerFlags(ctx ModuleContext, flags Flags) Flags {
-	flags.Global.LdFlags = append(flags.Global.LdFlags, ctx.toolchain().ToolchainClangLdflags())
+	flags.Global.LdFlags = append(flags.Global.LdFlags, ctx.toolchain().ToolchainLdflags())

 	if lds := android.OptionalPathForModuleSrc(ctx, object.Properties.Linker_script); lds.Valid() {
 		flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,-T,"+lds.String())
--- a/rust/bindgen.go
+++ b/rust/bindgen.go
@@ -144,8 +144,8 @@ func (b *bindgenDecorator) GenerateSource(ctx ModuleContext, deps PathDeps) andr

 	// Toolchain clang flags
 	cflags = append(cflags, "-target "+ccToolchain.ClangTriple())
-	cflags = append(cflags, strings.ReplaceAll(ccToolchain.ClangCflags(), "${config.", "${cc_config."))
-	cflags = append(cflags, strings.ReplaceAll(ccToolchain.ToolchainClangCflags(), "${config.", "${cc_config."))
+	cflags = append(cflags, strings.ReplaceAll(ccToolchain.Cflags(), "${config.", "${cc_config."))
+	cflags = append(cflags, strings.ReplaceAll(ccToolchain.ToolchainCflags(), "${config.", "${cc_config."))

 	// Dependency clang flags and include paths
 	cflags = append(cflags, deps.depClangFlags...)