Remove "exported" ninja variables (8982b1c4) · Commits · e / os / android_build_soong

android/Android.bp

+0 −1

Original line number	Diff line number	Diff line
		@@ -41,7 +41,6 @@ bootstrap_go_package {
		"buildinfo_prop.go",
		"config.go",
		"test_config.go",
		"config_bp2build.go",
		"configured_jars.go",
		"csuite_config.go",
		"deapexer.go",

android/config_bp2build.go

deleted100644 → 0

+0 −157

Original line number	Diff line number	Diff line
		// Copyright 2021 Google Inc. All rights reserved.
		//
		// Licensed under the Apache License, Version 2.0 (the "License");
		// you may not use this file except in compliance with the License.
		// You may obtain a copy of the License at
		//
		// http://www.apache.org/licenses/LICENSE-2.0
		//
		// Unless required by applicable law or agreed to in writing, software
		// distributed under the License is distributed on an "AS IS" BASIS,
		// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		// See the License for the specific language governing permissions and
		// limitations under the License.

		package android

		import (
		"strings"

		"github.com/google/blueprint"
		)

		// ExportedVariables is a collection of interdependent configuration variables
		type ExportedVariables struct {
		// Maps containing toolchain variables that are independent of the
		// environment variables of the build.
		exportedStringVars ExportedStringVariables
		exportedStringListVars ExportedStringListVariables
		exportedStringListDictVars ExportedStringListDictVariables

		exportedVariableReferenceDictVars ExportedVariableReferenceDictVariables

		/// Maps containing variables that are dependent on the build config.
		exportedConfigDependingVars ExportedConfigDependingVariables

		pctx PackageContext
		}

		// NewExportedVariables creats an empty ExportedVariables struct with non-nil maps
		func NewExportedVariables(pctx PackageContext) ExportedVariables {
		return ExportedVariables{
		exportedStringVars: ExportedStringVariables{},
		exportedStringListVars: ExportedStringListVariables{},
		exportedStringListDictVars: ExportedStringListDictVariables{},
		exportedVariableReferenceDictVars: ExportedVariableReferenceDictVariables{},
		exportedConfigDependingVars: ExportedConfigDependingVariables{},
		pctx: pctx,
		}
		}

		// ExportStringStaticVariable declares a static string variable and exports it to
		// Bazel's toolchain.
		func (ev ExportedVariables) ExportStringStaticVariable(name string, value string) {
		ev.pctx.StaticVariable(name, value)
		ev.exportedStringVars.set(name, value)
		}

		// ExportStringListStaticVariable declares a static variable and exports it to
		// Bazel's toolchain.
		func (ev ExportedVariables) ExportStringListStaticVariable(name string, value []string) {
		ev.pctx.StaticVariable(name, strings.Join(value, " "))
		ev.exportedStringListVars.set(name, value)
		}

		// ExportVariableConfigMethod declares a variable whose value is evaluated at
		// runtime via a function with access to the Config and exports it to Bazel's
		// toolchain.
		func (ev ExportedVariables) ExportVariableConfigMethod(name string, method interface{}) blueprint.Variable {
		ev.exportedConfigDependingVars.set(name, method)
		return ev.pctx.VariableConfigMethod(name, method)
		}

		// ExportSourcePathVariable declares a static "source path" variable and exports
		// it to Bazel's toolchain.
		func (ev ExportedVariables) ExportSourcePathVariable(name string, value string) {
		ev.pctx.SourcePathVariable(name, value)
		ev.exportedStringVars.set(name, value)
		}

		// ExportVariableFuncVariable declares a variable whose value is evaluated at
		// runtime via a function and exports it to Bazel's toolchain.
		func (ev ExportedVariables) ExportVariableFuncVariable(name string, f func() string) {
		ev.exportedConfigDependingVars.set(name, func(config Config) string {
		return f()
		})
		ev.pctx.VariableFunc(name, func(PackageVarContext) string {
		return f()
		})
		}

		// ExportString only exports a variable to Bazel, but does not declare it in Soong
		func (ev ExportedVariables) ExportString(name string, value string) {
		ev.exportedStringVars.set(name, value)
		}

		// ExportStringList only exports a variable to Bazel, but does not declare it in Soong
		func (ev ExportedVariables) ExportStringList(name string, value []string) {
		ev.exportedStringListVars.set(name, value)
		}

		// ExportStringListDict only exports a variable to Bazel, but does not declare it in Soong
		func (ev ExportedVariables) ExportStringListDict(name string, value map[string][]string) {
		ev.exportedStringListDictVars.set(name, value)
		}

		// ExportVariableReferenceDict only exports a variable to Bazel, but does not declare it in Soong
		func (ev ExportedVariables) ExportVariableReferenceDict(name string, value map[string]string) {
		ev.exportedVariableReferenceDictVars.set(name, value)
		}

		// ExportedConfigDependingVariables is a mapping of variable names to functions
		// of type func(config Config) string which return the runtime-evaluated string
		// value of a particular variable
		type ExportedConfigDependingVariables map[string]interface{}

		func (m ExportedConfigDependingVariables) set(k string, v interface{}) {
		m[k] = v
		}

		// ExportedStringVariables is a mapping of variable names to string values
		type ExportedStringVariables map[string]string

		func (m ExportedStringVariables) set(k string, v string) {
		m[k] = v
		}

		// ExportedStringListVariables is a mapping of variable names to a list of strings
		type ExportedStringListVariables map[string][]string

		func (m ExportedStringListVariables) set(k string, v []string) {
		m[k] = v
		}

		// ExportedStringListDictVariables is a mapping from variable names to a
		// dictionary which maps keys to lists of strings
		type ExportedStringListDictVariables map[string]map[string][]string

		func (m ExportedStringListDictVariables) set(k string, v map[string][]string) {
		m[k] = v
		}

		// ExportedVariableReferenceDictVariables is a mapping from variable names to a
		// dictionary which references previously defined variables. This is used to
		// create a Starlark output such as:
		//
		// string_var1 = "string1
		// var_ref_dict_var1 = {
		// "key1": string_var1
		// }
		//
		// This type of variable collection must be expanded last so that it recognizes
		// previously defined variables.
		type ExportedVariableReferenceDictVariables map[string]map[string]string

		func (m ExportedVariableReferenceDictVariables) set(k string, v map[string]string) {
		m[k] = v
		}

android/defs.go

+1 −5

Original line number	Diff line number	Diff line
		@@ -21,7 +21,6 @@ import (

		var (
		pctx = NewPackageContext("android/soong/android")
		exportedVars = NewExportedVariables(pctx)

		cpPreserveSymlinks = pctx.VariableConfigMethod("cpPreserveSymlinks",
		Config.CpPreserveSymlinksFlags)
		@@ -130,9 +129,6 @@ func init() {
		pctx.VariableFunc("RBEWrapper", func(ctx PackageVarContext) string {
		return ctx.Config().RBEWrapper()
		})

		exportedVars.ExportStringList("NeverAllowNotInIncludeDir", neverallowNotInIncludeDir)
		exportedVars.ExportStringList("NeverAllowNoUseIncludeDir", neverallowNoUseIncludeDir)
		}

		// GlobToListFileRule creates a rule that writes a list of files matching a pattern to a file.

cc/config/arm64_device.go

+13 −19

Original line number	Diff line number	Diff line
		@@ -91,16 +91,14 @@ var (
		)

		func init() {
		exportedVars.ExportStringListStaticVariable("Arm64Ldflags", arm64Ldflags)
		pctx.StaticVariable("Arm64Ldflags", strings.Join(arm64Ldflags, " "))

		exportedVars.ExportStringList("Arm64Lldflags", arm64Lldflags)
		pctx.VariableFunc("Arm64Lldflags", func(ctx android.PackageVarContext) string {
		maxPageSizeFlag := "-Wl,-z,max-page-size=" + ctx.Config().MaxPageSizeSupported()
		flags := append(arm64Lldflags, maxPageSizeFlag)
		return strings.Join(flags, " ")
		})

		exportedVars.ExportStringList("Arm64Cflags", arm64Cflags)
		pctx.VariableFunc("Arm64Cflags", func(ctx android.PackageVarContext) string {
		flags := arm64Cflags
		if ctx.Config().NoBionicPageSizeMacro() {
		@@ -109,25 +107,21 @@ func init() {
		return strings.Join(flags, " ")
		})

		exportedVars.ExportStringListStaticVariable("Arm64Cppflags", arm64Cppflags)
		pctx.StaticVariable("Arm64Cppflags", strings.Join(arm64Cppflags, " "))

		exportedVars.ExportVariableReferenceDict("Arm64ArchVariantCflags", arm64ArchVariantCflagsVar)
		exportedVars.ExportVariableReferenceDict("Arm64CpuVariantCflags", arm64CpuVariantCflagsVar)
		exportedVars.ExportVariableReferenceDict("Arm64CpuVariantLdflags", arm64CpuVariantLdflags)
		pctx.StaticVariable("Arm64Armv8ACflags", strings.Join(arm64ArchVariantCflags["armv8-a"], " "))
		pctx.StaticVariable("Arm64Armv8ABranchProtCflags", strings.Join(arm64ArchVariantCflags["armv8-a-branchprot"], " "))
		pctx.StaticVariable("Arm64Armv82ACflags", strings.Join(arm64ArchVariantCflags["armv8-2a"], " "))
		pctx.StaticVariable("Arm64Armv82ADotprodCflags", strings.Join(arm64ArchVariantCflags["armv8-2a-dotprod"], " "))
		pctx.StaticVariable("Arm64Armv9ACflags", strings.Join(arm64ArchVariantCflags["armv9-a"], " "))

		exportedVars.ExportStringListStaticVariable("Arm64Armv8ACflags", arm64ArchVariantCflags["armv8-a"])
		exportedVars.ExportStringListStaticVariable("Arm64Armv8ABranchProtCflags", arm64ArchVariantCflags["armv8-a-branchprot"])
		exportedVars.ExportStringListStaticVariable("Arm64Armv82ACflags", arm64ArchVariantCflags["armv8-2a"])
		exportedVars.ExportStringListStaticVariable("Arm64Armv82ADotprodCflags", arm64ArchVariantCflags["armv8-2a-dotprod"])
		exportedVars.ExportStringListStaticVariable("Arm64Armv9ACflags", arm64ArchVariantCflags["armv9-a"])
		pctx.StaticVariable("Arm64CortexA53Cflags", strings.Join(arm64CpuVariantCflags["cortex-a53"], " "))
		pctx.StaticVariable("Arm64CortexA55Cflags", strings.Join(arm64CpuVariantCflags["cortex-a55"], " "))
		pctx.StaticVariable("Arm64KryoCflags", strings.Join(arm64CpuVariantCflags["kryo"], " "))
		pctx.StaticVariable("Arm64ExynosM1Cflags", strings.Join(arm64CpuVariantCflags["exynos-m1"], " "))
		pctx.StaticVariable("Arm64ExynosM2Cflags", strings.Join(arm64CpuVariantCflags["exynos-m2"], " "))

		exportedVars.ExportStringListStaticVariable("Arm64CortexA53Cflags", arm64CpuVariantCflags["cortex-a53"])
		exportedVars.ExportStringListStaticVariable("Arm64CortexA55Cflags", arm64CpuVariantCflags["cortex-a55"])
		exportedVars.ExportStringListStaticVariable("Arm64KryoCflags", arm64CpuVariantCflags["kryo"])
		exportedVars.ExportStringListStaticVariable("Arm64ExynosM1Cflags", arm64CpuVariantCflags["exynos-m1"])
		exportedVars.ExportStringListStaticVariable("Arm64ExynosM2Cflags", arm64CpuVariantCflags["exynos-m2"])

		exportedVars.ExportStringListStaticVariable("Arm64FixCortexA53Ldflags", []string{"-Wl,--fix-cortex-a53-843419"})
		pctx.StaticVariable("Arm64FixCortexA53Ldflags", "-Wl,--fix-cortex-a53-843419")
		}

		var (

cc/config/arm64_linux_host.go

+3 −3

Original line number	Diff line number	Diff line
		@@ -61,9 +61,9 @@ var (
		)

		func init() {
		exportedVars.ExportStringListStaticVariable("LinuxBionicArm64Cflags", linuxCrossCflags)
		exportedVars.ExportStringListStaticVariable("LinuxBionicArm64Ldflags", linuxCrossLdflags)
		exportedVars.ExportStringListStaticVariable("LinuxBionicArm64Lldflags", linuxCrossLldflags)
		pctx.StaticVariable("LinuxBionicArm64Cflags", strings.Join(linuxCrossCflags, " "))
		pctx.StaticVariable("LinuxBionicArm64Ldflags", strings.Join(linuxCrossLdflags, " "))
		pctx.StaticVariable("LinuxBionicArm64Lldflags", strings.Join(linuxCrossLldflags, " "))
		}

		// toolchain config for ARM64 Linux CrossHost. Almost everything is the same as the ARM64 Android