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
diff --git a/cc/compiler.go b/cc/compiler.go
index 69ead30..81ac035 100644
--- a/cc/compiler.go
+++ b/cc/compiler.go
@@ -392,7 +392,7 @@
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 @@
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 @@
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" {
diff --git a/cc/config/arm64_device.go b/cc/config/arm64_device.go
index af6361b..a9dbbe9 100644
--- a/cc/config/arm64_device.go
+++ b/cc/config/arm64_device.go
@@ -48,12 +48,12 @@
"-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 @@
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 @@
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 @@
toolchainBionic
toolchain64Bit
- ldflags string
- lldflags string
- toolchainClangCflags string
+ ldflags string
+ lldflags string
+ toolchainCflags string
}
func (t *toolchainArm64) Name() string {
@@ -181,24 +179,24 @@
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 @@
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 @@
"${config.Arm64Lldflags}",
extraLdflags,
}, " "),
- toolchainClangCflags: strings.Join(toolchainClangCflags, " "),
+ toolchainCflags: strings.Join(toolchainCflags, " "),
}
}
diff --git a/cc/config/arm64_fuchsia_device.go b/cc/config/arm64_fuchsia_device.go
index a6b5e8c..5ab27a0 100644
--- a/cc/config/arm64_fuchsia_device.go
+++ b/cc/config/arm64_fuchsia_device.go
@@ -42,47 +42,31 @@
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"
}
diff --git a/cc/config/arm64_linux_host.go b/cc/config/arm64_linux_host.go
index 83bd799..fa0ee64 100644
--- 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 @@
// 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 @@
"-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 @@
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 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 @@
"${config.LinuxBionicArm64Ldflags}",
extraLdflags,
}, " ")
- ret.toolchainArm64.toolchainClangCflags = strings.Join(toolchainClangCflags, " ")
+ ret.toolchainArm64.toolchainCflags = strings.Join(toolchainCflags, " ")
return &ret
}
diff --git a/cc/config/arm_device.go b/cc/config/arm_device.go
index 3c27730..80ca78e 100644
--- a/cc/config/arm_device.go
+++ b/cc/config/arm_device.go
@@ -23,7 +23,6 @@
var (
armToolchainCflags = []string{
- "-mthumb-interwork",
"-msoft-float",
}
@@ -38,7 +37,7 @@
"-Wl,-m,armelf",
}
- armLldflags = ClangFilterUnknownLldflags(armLdflags)
+ armLldflags = armLdflags
armArmCflags = []string{
"-fstrict-aliasing",
@@ -49,7 +48,7 @@
"-Os",
}
- armClangArchVariantCflags = map[string][]string{
+ armArchVariantCflags = map[string][]string{
"armv7-a": []string{
"-march=armv7-a",
"-mfloat-abi=softfp",
@@ -72,7 +71,7 @@
},
}
- armClangCpuVariantCflags = map[string][]string{
+ armCpuVariantCflags = map[string][]string{
"cortex-a7": []string{
"-mcpu=cortex-a7",
"-mfpu=neon-vfpv4",
@@ -181,42 +180,40 @@
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 @@
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 @@
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 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 @@
"${config.ArmLdflags}",
fixCortexA8,
}, " "),
- lldflags: "${config.ArmLldflags}",
- toolchainClangCflags: strings.Join(toolchainClangCflags, " "),
+ lldflags: "${config.ArmLldflags}",
+ toolchainCflags: strings.Join(toolchainCflags, " "),
}
}
diff --git a/cc/config/clang.go b/cc/config/clang.go
index c484fc9..2f88327 100644
--- a/cc/config/clang.go
+++ b/cc/config/clang.go
@@ -80,12 +80,6 @@
"--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 @@
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
diff --git a/cc/config/global.go b/cc/config/global.go
index 4957767..136fcff 100644
--- a/cc/config/global.go
+++ b/cc/config/global.go
@@ -36,7 +36,6 @@
// Make paths in deps files relative
"-no-canonical-prefixes",
- "-fno-canonical-system-headers",
"-DNDEBUG",
"-UDEBUG",
@@ -61,8 +60,6 @@
commonGlobalConlyflags = []string{}
deviceGlobalCflags = []string{
- "-fdiagnostics-color",
-
"-ffunction-sections",
"-fdata-sections",
"-fno-short-enums",
@@ -101,7 +98,7 @@
"-Wl,--icf=safe",
}
- deviceGlobalLldflags = append(ClangFilterUnknownLldflags(deviceGlobalLdflags),
+ deviceGlobalLldflags = append(deviceGlobalLdflags,
[]string{
"-fuse-ld=lld",
}...)
@@ -177,7 +174,7 @@
// 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 @@
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 @@
// 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.
diff --git a/cc/config/toolchain.go b/cc/config/toolchain.go
index ab09751..ff556f1 100644
--- a/cc/config/toolchain.go
+++ b/cc/config/toolchain.go
@@ -82,14 +82,14 @@
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 @@
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 @@
return ""
}
-func (toolchainBase) ClangAsflags() string {
+func (toolchainBase) Asflags() string {
return ""
}
diff --git a/cc/config/x86_64_device.go b/cc/config/x86_64_device.go
index 54dc6d5..ec8bab2 100644
--- a/cc/config/x86_64_device.go
+++ b/cc/config/x86_64_device.go
@@ -32,8 +32,6 @@
"-Wl,--hash-style=gnu",
}
- x86_64Lldflags = ClangFilterUnknownLldflags(x86_64Ldflags)
-
x86_64ArchVariantCflags = map[string][]string{
"": []string{
"-march=x86-64",
@@ -102,13 +100,11 @@
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 @@
// 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 @@
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 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, " "),
}
}
diff --git a/cc/config/x86_64_fuchsia_device.go b/cc/config/x86_64_fuchsia_device.go
index d6837c8..86558a6 100644
--- a/cc/config/x86_64_fuchsia_device.go
+++ b/cc/config/x86_64_fuchsia_device.go
@@ -46,18 +46,6 @@
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 @@
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 @@
return "-f elf64 -m amd64"
}
-func (t *toolchainFuchsiaX8664) ToolchainClangCflags() string {
+func (t *toolchainFuchsiaX8664) ToolchainCflags() string {
return "-mssse3"
}
diff --git a/cc/config/x86_darwin_host.go b/cc/config/x86_darwin_host.go
index 4e3e2a6..1afae09 100644
--- a/cc/config/x86_darwin_host.go
+++ b/cc/config/x86_darwin_host.go
@@ -26,8 +26,6 @@
var (
darwinCflags = []string{
- "-fdiagnostics-color",
-
"-fPIC",
"-funwind-tables",
@@ -41,6 +39,9 @@
"-DMACOSX_DEPLOYMENT_TARGET=${macMinVersion}",
"-m64",
+
+ "-integrated-as",
+ "-fstack-protector-strong",
}
darwinLdflags = []string{
@@ -50,15 +51,6 @@
"-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 @@
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 @@
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}"
}
diff --git a/cc/config/x86_device.go b/cc/config/x86_device.go
index 1507d98..a95ac6f 100644
--- a/cc/config/x86_device.go
+++ b/cc/config/x86_device.go
@@ -21,16 +21,14 @@
)
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 @@
"-Wl,--hash-style=gnu",
}
- x86Lldflags = ClangFilterUnknownLldflags(x86Ldflags)
-
x86ArchVariantCflags = map[string][]string{
"": []string{
"-march=prescott",
@@ -49,35 +45,27 @@
},
"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 @@
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 @@
// 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 @@
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 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, " "),
}
}
diff --git a/cc/config/x86_linux_bionic_host.go b/cc/config/x86_linux_bionic_host.go
index e7e5f2d..4b7ba6a 100644
--- a/cc/config/x86_linux_bionic_host.go
+++ b/cc/config/x86_linux_bionic_host.go
@@ -21,9 +21,7 @@
)
var (
- linuxBionicCflags = ClangFilterUnknownCflags([]string{
- "-fdiagnostics-color",
-
+ linuxBionicCflags = []string{
"-Wa,--noexecstack",
"-fPIC",
@@ -34,21 +32,17 @@
// 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 @@
// 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 @@
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 @@
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"
}
diff --git a/cc/config/x86_linux_host.go b/cc/config/x86_linux_host.go
index c406c88..fedb36d 100644
--- a/cc/config/x86_linux_host.go
+++ b/cc/config/x86_linux_host.go
@@ -22,8 +22,6 @@
var (
linuxCflags = []string{
- "-fdiagnostics-color",
-
"-Wa,--noexecstack",
"-fPIC",
@@ -36,6 +34,10 @@
//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 @@
"-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 @@
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 @@
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 @@
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 @@
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}"
}
diff --git a/cc/config/x86_windows_host.go b/cc/config/x86_windows_host.go
index b77df79..d3b15fc 100644
--- a/cc/config/x86_windows_host.go
+++ b/cc/config/x86_windows_host.go
@@ -44,32 +44,28 @@
"--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 @@
"-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 @@
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 @@
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}"
}
diff --git a/cc/linker.go b/cc/linker.go
index 13df232..a712391 100644
--- a/cc/linker.go
+++ b/cc/linker.go
@@ -479,9 +479,9 @@
}
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 @@
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
diff --git a/cc/makevars.go b/cc/makevars.go
index 2b326ef..2122181 100644
--- a/cc/makevars.go
+++ b/cc/makevars.go
@@ -212,13 +212,13 @@
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 @@
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,
}, " "))
diff --git a/cc/object.go b/cc/object.go
index 9f2db2e..ac5e41d 100644
--- a/cc/object.go
+++ b/cc/object.go
@@ -224,7 +224,7 @@
}
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())