Merge "bp2build: generate arm toolchain flags into @soong_injection." (857d0375) · Commits · e / os / android_build_soong

cc/config/arm_device.go

+32 −39

Original line number	Diff line number	Diff line
		@@ -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 {

cc/config/bp2build.go

+40 −19

Original line number	Diff line number	Diff line
		@@ -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 exportedStringVariables) Set(k string, v string) {
		m[k] = v
		}

		func (m exportedVariablesMap) Set(k string, v variableValue) {
		// Convenience function to declare a static variable and export it to Bazel's cc_toolchain.
		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 staticVariableExportedToBazel(name string, value []string) {
		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,10 +154,13 @@ func expandVar(toExpand string, exportedVars map[string]variableValue) []string
		newSeenVars[k] = true
		}
		newSeenVars[variable] = true
		unexpandedVars := exportedVars[variable]
		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)...)
		}
		}
		return ret
		}

cc/config/bp2build_test.go

+49 −23

Original line number	Diff line number	Diff line
		@@ -21,53 +21,79 @@ import (
		func TestExpandVars(t *testing.T) {
		testCases := []struct {
		description string
		exportedVars map[string]variableValue
		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))
		}

cc/config/clang.go

+5 −5

Original line number	Diff line number	Diff line
		@@ -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",

cc/config/global.go

+14 −14

Original line number	Diff line number	Diff line
		@@ -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)