bp2build: generate arm toolchain flags into @soong_injection.
Other architectures will come later.
Bug: 187084665
Test: TH
Change-Id: Ifcc6773625e56b1fc20260d840380e7ee4ecee7f
diff --git a/cc/config/arm_device.go b/cc/config/arm_device.go
index a402f8f..439084e 100644
--- a/cc/config/arm_device.go
+++ b/cc/config/arm_device.go
@@ -163,56 +163,49 @@
)
const (
+ name = "arm"
armGccVersion = "4.9"
+ gccTriple = "arm-linux-androideabi"
+ clangTriple = "armv7a-linux-androideabi"
)
func init() {
pctx.StaticVariable("armGccVersion", armGccVersion)
- pctx.SourcePathVariable("ArmGccRoot",
- "prebuilts/gcc/${HostPrebuiltTag}/arm/arm-linux-androideabi-${armGccVersion}")
+ pctx.SourcePathVariable("ArmGccRoot", "prebuilts/gcc/${HostPrebuiltTag}/arm/arm-linux-androideabi-${armGccVersion}")
- pctx.StaticVariable("ArmLdflags", strings.Join(armLdflags, " "))
- pctx.StaticVariable("ArmLldflags", strings.Join(armLldflags, " "))
+ // Just exported. Not created as a Ninja static variable.
+ exportedStringVars.Set("ArmClangTriple", clangTriple)
+
+ exportStringListStaticVariable("ArmLdflags", armLdflags)
+ exportStringListStaticVariable("ArmLldflags", armLldflags)
// Clang cflags
- pctx.StaticVariable("ArmToolchainClangCflags", strings.Join(ClangFilterUnknownCflags(armToolchainCflags), " "))
- pctx.StaticVariable("ArmClangCflags", strings.Join(ClangFilterUnknownCflags(armCflags), " "))
- pctx.StaticVariable("ArmClangLdflags", strings.Join(ClangFilterUnknownCflags(armLdflags), " "))
- pctx.StaticVariable("ArmClangLldflags", strings.Join(ClangFilterUnknownCflags(armLldflags), " "))
- pctx.StaticVariable("ArmClangCppflags", strings.Join(ClangFilterUnknownCflags(armCppflags), " "))
+ exportStringListStaticVariable("ArmToolchainClangCflags", ClangFilterUnknownCflags(armToolchainCflags))
+ exportStringListStaticVariable("ArmClangCflags", ClangFilterUnknownCflags(armCflags))
+ exportStringListStaticVariable("ArmClangLdflags", ClangFilterUnknownCflags(armLdflags))
+ exportStringListStaticVariable("ArmClangLldflags", ClangFilterUnknownCflags(armLldflags))
+ exportStringListStaticVariable("ArmClangCppflags", ClangFilterUnknownCflags(armCppflags))
// Clang ARM vs. Thumb instruction set cflags
- pctx.StaticVariable("ArmClangArmCflags", strings.Join(ClangFilterUnknownCflags(armArmCflags), " "))
- pctx.StaticVariable("ArmClangThumbCflags", strings.Join(ClangFilterUnknownCflags(armThumbCflags), " "))
+ exportStringListStaticVariable("ArmClangArmCflags", ClangFilterUnknownCflags(armArmCflags))
+ exportStringListStaticVariable("ArmClangThumbCflags", ClangFilterUnknownCflags(armThumbCflags))
// Clang arch variant cflags
- pctx.StaticVariable("ArmClangArmv7ACflags",
- strings.Join(armClangArchVariantCflags["armv7-a"], " "))
- pctx.StaticVariable("ArmClangArmv7ANeonCflags",
- strings.Join(armClangArchVariantCflags["armv7-a-neon"], " "))
- pctx.StaticVariable("ArmClangArmv8ACflags",
- strings.Join(armClangArchVariantCflags["armv8-a"], " "))
- pctx.StaticVariable("ArmClangArmv82ACflags",
- strings.Join(armClangArchVariantCflags["armv8-2a"], " "))
+ exportStringListStaticVariable("ArmClangArmv7ACflags", armClangArchVariantCflags["armv7-a"])
+ exportStringListStaticVariable("ArmClangArmv7ANeonCflags", armClangArchVariantCflags["armv7-a-neon"])
+ exportStringListStaticVariable("ArmClangArmv8ACflags", armClangArchVariantCflags["armv8-a"])
+ exportStringListStaticVariable("ArmClangArmv82ACflags", armClangArchVariantCflags["armv8-2a"])
// Clang cpu variant cflags
- pctx.StaticVariable("ArmClangGenericCflags",
- strings.Join(armClangCpuVariantCflags[""], " "))
- pctx.StaticVariable("ArmClangCortexA7Cflags",
- strings.Join(armClangCpuVariantCflags["cortex-a7"], " "))
- pctx.StaticVariable("ArmClangCortexA8Cflags",
- strings.Join(armClangCpuVariantCflags["cortex-a8"], " "))
- pctx.StaticVariable("ArmClangCortexA15Cflags",
- strings.Join(armClangCpuVariantCflags["cortex-a15"], " "))
- pctx.StaticVariable("ArmClangCortexA53Cflags",
- strings.Join(armClangCpuVariantCflags["cortex-a53"], " "))
- pctx.StaticVariable("ArmClangCortexA55Cflags",
- strings.Join(armClangCpuVariantCflags["cortex-a55"], " "))
- pctx.StaticVariable("ArmClangKraitCflags",
- strings.Join(armClangCpuVariantCflags["krait"], " "))
- pctx.StaticVariable("ArmClangKryoCflags",
- strings.Join(armClangCpuVariantCflags["kryo"], " "))
+ 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"])
}
var (
@@ -251,7 +244,7 @@
}
func (t *toolchainArm) Name() string {
- return "arm"
+ return name
}
func (t *toolchainArm) GccRoot() string {
@@ -259,7 +252,7 @@
}
func (t *toolchainArm) GccTriple() string {
- return "arm-linux-androideabi"
+ return gccTriple
}
func (t *toolchainArm) GccVersion() string {
@@ -272,7 +265,7 @@
func (t *toolchainArm) ClangTriple() string {
// http://b/72619014 work around llvm LTO bug.
- return "armv7a-linux-androideabi"
+ return clangTriple
}
func (t *toolchainArm) ndkTriple() string {
@@ -312,7 +305,7 @@
}
func (toolchainArm) LibclangRuntimeLibraryArch() string {
- return "arm"
+ return name
}
func armToolchainFactory(arch android.Arch) Toolchain {
diff --git a/cc/config/bp2build.go b/cc/config/bp2build.go
index 16892e6..19571f1 100644
--- a/cc/config/bp2build.go
+++ b/cc/config/bp2build.go
@@ -22,29 +22,34 @@
)
// Helpers for exporting cc configuration information to Bazel.
-
var (
// Map containing toolchain variables that are independent of the
// environment variables of the build.
- exportedVars = exportedVariablesMap{}
+ exportedStringListVars = exportedStringListVariables{}
+ exportedStringVars = exportedStringVariables{}
)
-// variableValue is a string slice because the exported variables are all lists
-// of string, and it's simpler to manipulate string lists before joining them
-// into their final string representation.
-type variableValue []string
+type exportedStringVariables map[string]string
+type exportedStringListVariables map[string][]string
-// envDependentVariable is a toolchain variable computed based on an environment variable.
-type exportedVariablesMap map[string]variableValue
-
-func (m exportedVariablesMap) Set(k string, v variableValue) {
+func (m exportedStringVariables) Set(k string, v string) {
m[k] = v
}
// Convenience function to declare a static variable and export it to Bazel's cc_toolchain.
-func staticVariableExportedToBazel(name string, value []string) {
+func exportStringStaticVariable(name string, value string) {
+ pctx.StaticVariable(name, value)
+ exportedStringVars.Set(name, value)
+}
+
+func (m exportedStringListVariables) Set(k string, v []string) {
+ m[k] = v
+}
+
+// Convenience function to declare a static variable and export it to Bazel's cc_toolchain.
+func exportStringListStaticVariable(name string, value []string) {
pctx.StaticVariable(name, strings.Join(value, " "))
- exportedVars.Set(name, variableValue(value))
+ exportedStringListVars.Set(name, value)
}
// BazelCcToolchainVars generates bzl file content containing variables for
@@ -64,12 +69,12 @@
// For each exported variable, recursively expand elements in the variableValue
// list to ensure that interpolated variables are expanded according to their values
- // in the exportedVars scope.
- for _, k := range android.SortedStringKeys(exportedVars) {
- variableValue := exportedVars[k]
+ // in the variable scope.
+ for _, k := range android.SortedStringKeys(exportedStringListVars) {
+ variableValue := exportedStringListVars[k]
var expandedVars []string
for _, v := range variableValue {
- expandedVars = append(expandedVars, expandVar(v, exportedVars)...)
+ expandedVars = append(expandedVars, expandVar(v, exportedStringVars, exportedStringListVars)...)
}
// Build the list for this variable.
list := "["
@@ -83,9 +88,22 @@
ret += "\n"
}
+ for _, k := range android.SortedStringKeys(exportedStringVars) {
+ variableValue := exportedStringVars[k]
+ expandedVar := expandVar(variableValue, exportedStringVars, exportedStringListVars)
+ if len(expandedVar) > 1 {
+ panic(fmt.Errorf("%s expands to more than one string value: %s", variableValue, expandedVar))
+ }
+ ret += fmt.Sprintf("_%s = \"%s\"\n", k, validateCharacters(expandedVar[0]))
+ ret += "\n"
+ }
+
// Build the exported constants struct.
ret += "constants = struct(\n"
- for _, k := range android.SortedStringKeys(exportedVars) {
+ for _, k := range android.SortedStringKeys(exportedStringVars) {
+ ret += fmt.Sprintf(" %s = _%s,\n", k, k)
+ }
+ for _, k := range android.SortedStringKeys(exportedStringListVars) {
ret += fmt.Sprintf(" %s = _%s,\n", k, k)
}
ret += ")"
@@ -99,7 +117,7 @@
// string slice than to handle a pass-by-referenced map, which would make it
// quite complex to track depth-first interpolations. It's also unlikely the
// interpolation stacks are deep (n > 1).
-func expandVar(toExpand string, exportedVars map[string]variableValue) []string {
+func expandVar(toExpand string, stringScope exportedStringVariables, stringListScope exportedStringListVariables) []string {
// e.g. "${ClangExternalCflags}"
r := regexp.MustCompile(`\${([a-zA-Z0-9_]+)}`)
@@ -136,8 +154,11 @@
newSeenVars[k] = true
}
newSeenVars[variable] = true
- unexpandedVars := exportedVars[variable]
- for _, unexpandedVar := range unexpandedVars {
+ if unexpandedVars, ok := stringListScope[variable]; ok {
+ for _, unexpandedVar := range unexpandedVars {
+ ret = append(ret, expandVarInternal(unexpandedVar, newSeenVars)...)
+ }
+ } else if unexpandedVar, ok := stringScope[variable]; ok {
ret = append(ret, expandVarInternal(unexpandedVar, newSeenVars)...)
}
}
diff --git a/cc/config/bp2build_test.go b/cc/config/bp2build_test.go
index 7744b4b..a4745e6 100644
--- a/cc/config/bp2build_test.go
+++ b/cc/config/bp2build_test.go
@@ -20,54 +20,80 @@
func TestExpandVars(t *testing.T) {
testCases := []struct {
- description string
- exportedVars map[string]variableValue
- toExpand string
- expectedValues []string
+ description string
+ stringScope exportedStringVariables
+ stringListScope exportedStringListVariables
+ toExpand string
+ expectedValues []string
}{
{
- description: "single level expansion",
- exportedVars: map[string]variableValue{
- "foo": variableValue([]string{"bar"}),
+ description: "no expansion for non-interpolated value",
+ toExpand: "foo",
+ expectedValues: []string{"foo"},
+ },
+ {
+ description: "single level expansion for string var",
+ stringScope: exportedStringVariables{
+ "foo": "bar",
},
toExpand: "${foo}",
expectedValues: []string{"bar"},
},
{
+ description: "single level expansion string list var",
+ stringListScope: exportedStringListVariables{
+ "foo": []string{"bar"},
+ },
+ toExpand: "${foo}",
+ expectedValues: []string{"bar"},
+ },
+ {
+ description: "mixed level expansion for string list var",
+ stringScope: exportedStringVariables{
+ "foo": "${bar}",
+ "qux": "hello",
+ },
+ stringListScope: exportedStringListVariables{
+ "bar": []string{"baz", "${qux}"},
+ },
+ toExpand: "${foo}",
+ expectedValues: []string{"baz", "hello"},
+ },
+ {
description: "double level expansion",
- exportedVars: map[string]variableValue{
- "foo": variableValue([]string{"${bar}"}),
- "bar": variableValue([]string{"baz"}),
+ stringListScope: exportedStringListVariables{
+ "foo": []string{"${bar}"},
+ "bar": []string{"baz"},
},
toExpand: "${foo}",
expectedValues: []string{"baz"},
},
{
description: "double level expansion with a literal",
- exportedVars: map[string]variableValue{
- "a": variableValue([]string{"${b}", "c"}),
- "b": variableValue([]string{"d"}),
+ stringListScope: exportedStringListVariables{
+ "a": []string{"${b}", "c"},
+ "b": []string{"d"},
},
toExpand: "${a}",
expectedValues: []string{"d", "c"},
},
{
description: "double level expansion, with two variables in a string",
- exportedVars: map[string]variableValue{
- "a": variableValue([]string{"${b} ${c}"}),
- "b": variableValue([]string{"d"}),
- "c": variableValue([]string{"e"}),
+ stringListScope: exportedStringListVariables{
+ "a": []string{"${b} ${c}"},
+ "b": []string{"d"},
+ "c": []string{"e"},
},
toExpand: "${a}",
expectedValues: []string{"d", "e"},
},
{
description: "triple level expansion with two variables in a string",
- exportedVars: map[string]variableValue{
- "a": variableValue([]string{"${b} ${c}"}),
- "b": variableValue([]string{"${c}", "${d}"}),
- "c": variableValue([]string{"${d}"}),
- "d": variableValue([]string{"foo"}),
+ stringListScope: exportedStringListVariables{
+ "a": []string{"${b} ${c}"},
+ "b": []string{"${c}", "${d}"},
+ "c": []string{"${d}"},
+ "d": []string{"foo"},
},
toExpand: "${a}",
expectedValues: []string{"foo", "foo", "foo"},
@@ -76,7 +102,7 @@
for _, testCase := range testCases {
t.Run(testCase.description, func(t *testing.T) {
- output := expandVar(testCase.toExpand, testCase.exportedVars)
+ output := expandVar(testCase.toExpand, testCase.stringScope, testCase.stringListScope)
if len(output) != len(testCase.expectedValues) {
t.Errorf("Expected %d values, got %d", len(testCase.expectedValues), len(output))
}
diff --git a/cc/config/clang.go b/cc/config/clang.go
index 4fbb9c3..c484fc9 100644
--- a/cc/config/clang.go
+++ b/cc/config/clang.go
@@ -98,7 +98,7 @@
}
func init() {
- staticVariableExportedToBazel("ClangExtraCflags", []string{
+ exportStringListStaticVariable("ClangExtraCflags", []string{
"-D__compiler_offsetof=__builtin_offsetof",
// Emit address-significance table which allows linker to perform safe ICF. Clang does
@@ -153,7 +153,7 @@
"-D__ANDROID_UNAVAILABLE_SYMBOLS_ARE_WEAK__",
})
- staticVariableExportedToBazel("ClangExtraCppflags", []string{
+ exportStringListStaticVariable("ClangExtraCppflags", []string{
// -Wimplicit-fallthrough is not enabled by -Wall.
"-Wimplicit-fallthrough",
@@ -164,9 +164,9 @@
"-Wno-gnu-include-next",
})
- staticVariableExportedToBazel("ClangExtraTargetCflags", []string{"-nostdlibinc"})
+ exportStringListStaticVariable("ClangExtraTargetCflags", []string{"-nostdlibinc"})
- staticVariableExportedToBazel("ClangExtraNoOverrideCflags", []string{
+ exportStringListStaticVariable("ClangExtraNoOverrideCflags", []string{
"-Werror=address-of-temporary",
// Bug: http://b/29823425 Disable -Wnull-dereference until the
// new cases detected by this warning in Clang r271374 are
@@ -205,7 +205,7 @@
// Extra cflags for external third-party projects to disable warnings that
// are infeasible to fix in all the external projects and their upstream repos.
- staticVariableExportedToBazel("ClangExtraExternalCflags", []string{
+ exportStringListStaticVariable("ClangExtraExternalCflags", []string{
"-Wno-enum-compare",
"-Wno-enum-compare-switch",
diff --git a/cc/config/global.go b/cc/config/global.go
index d6eba0f..d458311 100644
--- a/cc/config/global.go
+++ b/cc/config/global.go
@@ -165,13 +165,13 @@
commonGlobalCflags = append(commonGlobalCflags, "-fdebug-prefix-map=/proc/self/cwd=")
}
- staticVariableExportedToBazel("CommonGlobalConlyflags", commonGlobalConlyflags)
- staticVariableExportedToBazel("DeviceGlobalCppflags", deviceGlobalCppflags)
- staticVariableExportedToBazel("DeviceGlobalLdflags", deviceGlobalLdflags)
- staticVariableExportedToBazel("DeviceGlobalLldflags", deviceGlobalLldflags)
- staticVariableExportedToBazel("HostGlobalCppflags", hostGlobalCppflags)
- staticVariableExportedToBazel("HostGlobalLdflags", hostGlobalLdflags)
- staticVariableExportedToBazel("HostGlobalLldflags", hostGlobalLldflags)
+ exportStringListStaticVariable("CommonGlobalConlyflags", commonGlobalConlyflags)
+ exportStringListStaticVariable("DeviceGlobalCppflags", deviceGlobalCppflags)
+ exportStringListStaticVariable("DeviceGlobalLdflags", deviceGlobalLdflags)
+ exportStringListStaticVariable("DeviceGlobalLldflags", deviceGlobalLldflags)
+ exportStringListStaticVariable("HostGlobalCppflags", hostGlobalCppflags)
+ exportStringListStaticVariable("HostGlobalLdflags", hostGlobalLdflags)
+ exportStringListStaticVariable("HostGlobalLldflags", hostGlobalLldflags)
// Export the static default CommonClangGlobalCflags to Bazel.
// TODO(187086342): handle cflags that are set in VariableFuncs.
@@ -183,7 +183,7 @@
"-ftrivial-auto-var-init=zero",
"-enable-trivial-auto-var-init-zero-knowing-it-will-be-removed-from-clang",
}...)
- exportedVars.Set("CommonClangGlobalCflags", variableValue(commonClangGlobalCFlags))
+ exportedStringListVars.Set("CommonClangGlobalCflags", commonClangGlobalCFlags)
pctx.VariableFunc("CommonClangGlobalCflags", func(ctx android.PackageVarContext) string {
flags := ClangFilterUnknownCflags(commonGlobalCflags)
@@ -208,7 +208,7 @@
// Export the static default DeviceClangGlobalCflags to Bazel.
// TODO(187086342): handle cflags that are set in VariableFuncs.
deviceClangGlobalCflags := append(ClangFilterUnknownCflags(deviceGlobalCflags), "${ClangExtraTargetCflags}")
- exportedVars.Set("DeviceClangGlobalCflags", variableValue(deviceClangGlobalCflags))
+ exportedStringListVars.Set("DeviceClangGlobalCflags", deviceClangGlobalCflags)
pctx.VariableFunc("DeviceClangGlobalCflags", func(ctx android.PackageVarContext) string {
if ctx.Config().Fuchsia() {
@@ -218,10 +218,10 @@
}
})
- staticVariableExportedToBazel("HostClangGlobalCflags", ClangFilterUnknownCflags(hostGlobalCflags))
- staticVariableExportedToBazel("NoOverrideClangGlobalCflags", append(ClangFilterUnknownCflags(noOverrideGlobalCflags), "${ClangExtraNoOverrideCflags}"))
- staticVariableExportedToBazel("CommonClangGlobalCppflags", append(ClangFilterUnknownCflags(commonGlobalCppflags), "${ClangExtraCppflags}"))
- staticVariableExportedToBazel("ClangExternalCflags", []string{"${ClangExtraExternalCflags}"})
+ exportStringListStaticVariable("HostClangGlobalCflags", ClangFilterUnknownCflags(hostGlobalCflags))
+ exportStringListStaticVariable("NoOverrideClangGlobalCflags", append(ClangFilterUnknownCflags(noOverrideGlobalCflags), "${ClangExtraNoOverrideCflags}"))
+ exportStringListStaticVariable("CommonClangGlobalCppflags", append(ClangFilterUnknownCflags(commonGlobalCppflags), "${ClangExtraCppflags}"))
+ exportStringListStaticVariable("ClangExternalCflags", []string{"${ClangExtraExternalCflags}"})
// Everything in these lists is a crime against abstraction and dependency tracking.
// Do not add anything to this list.
@@ -236,7 +236,7 @@
"frameworks/native/opengl/include",
"frameworks/av/include",
}
- exportedVars.Set("CommonGlobalIncludes", commonGlobalIncludes)
+ exportedStringListVars.Set("CommonGlobalIncludes", commonGlobalIncludes)
pctx.PrefixedExistentPathsForSourcesVariable("CommonGlobalIncludes", "-I", commonGlobalIncludes)
pctx.SourcePathVariable("ClangDefaultBase", ClangDefaultBase)