From 51a1e1cf59c4b555e7738134fd9a5918cf3f8c51 Mon Sep 17 00:00:00 2001 From: Jingwen Chen Date: Thu, 20 May 2021 13:40:14 +0000 Subject: [PATCH] bp2build: generate arm toolchain flags into @soong_injection. Other architectures will come later. Bug: 187084665 Test: TH Change-Id: Ifcc6773625e56b1fc20260d840380e7ee4ecee7f --- cc/config/arm_device.go | 71 +++++++++++++++++-------------------- cc/config/bp2build.go | 61 +++++++++++++++++++++----------- cc/config/bp2build_test.go | 72 ++++++++++++++++++++++++++------------ cc/config/clang.go | 10 +++--- cc/config/global.go | 28 +++++++-------- 5 files changed, 141 insertions(+), 101 deletions(-) diff --git a/cc/config/arm_device.go b/cc/config/arm_device.go index a402f8f7a..439084e3b 100644 --- a/cc/config/arm_device.go +++ b/cc/config/arm_device.go @@ -163,56 +163,49 @@ var ( ) 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 @@ type toolchainArm struct { } func (t *toolchainArm) Name() string { - return "arm" + return name } func (t *toolchainArm) GccRoot() string { @@ -259,7 +252,7 @@ func (t *toolchainArm) GccRoot() string { } func (t *toolchainArm) GccTriple() string { - return "arm-linux-androideabi" + return gccTriple } func (t *toolchainArm) GccVersion() string { @@ -272,7 +265,7 @@ func (t *toolchainArm) IncludeFlags() string { 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 (t *toolchainArm) ClangInstructionSetFlags(isa string) (string, error) { } 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 16892e654..19571f10d 100644 --- a/cc/config/bp2build.go +++ b/cc/config/bp2build.go @@ -22,29 +22,34 @@ import ( ) // 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 @@ func BazelCcToolchainVars() string { // 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 @@ func BazelCcToolchainVars() string { 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 @@ func BazelCcToolchainVars() string { // 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 @@ func expandVar(toExpand string, exportedVars map[string]variableValue) []string 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 7744b4bfa..a4745e609 100644 --- a/cc/config/bp2build_test.go +++ b/cc/config/bp2build_test.go @@ -20,54 +20,80 @@ import ( 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 @@ func TestExpandVars(t *testing.T) { 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 4fbb9c33e..c484fc921 100644 --- a/cc/config/clang.go +++ b/cc/config/clang.go @@ -98,7 +98,7 @@ var ClangTidyDisableChecks = []string{ } 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 @@ func init() { "-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 @@ func init() { "-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 @@ func init() { // 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 d6eba0fb1..d458311ee 100644 --- a/cc/config/global.go +++ b/cc/config/global.go @@ -165,13 +165,13 @@ func init() { 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 @@ func init() { "-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 @@ func init() { // 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 @@ func init() { } }) - 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 @@ func init() { "frameworks/native/opengl/include", "frameworks/av/include", } - exportedVars.Set("CommonGlobalIncludes", commonGlobalIncludes) + exportedStringListVars.Set("CommonGlobalIncludes", commonGlobalIncludes) pctx.PrefixedExistentPathsForSourcesVariable("CommonGlobalIncludes", "-I", commonGlobalIncludes) pctx.SourcePathVariable("ClangDefaultBase", ClangDefaultBase)