tequilaOS/platform_build_soong
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Snap for 11975806 from be0f95b374 to 24Q3-release

Browse source 
Change-Id: I9e762f31971c4bf692a091c1d7b0f36e55725cd5
This commit is contained in:
Android Build Coastguard Worker 2024-06-15 21:00:26 +00:00
commit 94287ec7ee
4 changed files with 16 additions and 98 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

80
android/config.go
View file

@ -22,7 +22,6 @@ import (
"fmt"
"os"
"path/filepath"
"reflect"
"runtime"
"strconv"
"strings"
@ -37,9 +36,7 @@ import (
"github.com/google/blueprint/proptools"
"android/soong/android/soongconfig"
"android/soong/bazel"
"android/soong/remoteexec"
"android/soong/starlark_fmt"
)
// Bool re-exports proptools.Bool for the android package.
@ -418,7 +415,7 @@ func loadFromConfigFile(configurable *ProductVariables, filename string) error {
proptools.StringPtr(String(configurable.Platform_sdk_codename))
}
return saveToBazelConfigFile(configurable, filepath.Dir(filename))
return nil
}
// atomically writes the config file in case two copies of soong_build are running simultaneously
@ -452,81 +449,6 @@ func saveToConfigFile(config *ProductVariables, filename string) error {
return nil
}
type productVariableStarlarkRepresentation struct {
soongType string
selectable bool
archVariant bool
}
func saveToBazelConfigFile(config *ProductVariables, outDir string) error {
dir := filepath.Join(outDir, bazel.SoongInjectionDirName, "product_config")
err := createDirIfNonexistent(dir, os.ModePerm)
if err != nil {
return fmt.Errorf("Could not create dir %s: %s", dir, err)
}
allProductVariablesType := reflect.TypeOf((*ProductVariables)(nil)).Elem()
productVariablesInfo := make(map[string]productVariableStarlarkRepresentation)
p := variableProperties{}
t := reflect.TypeOf(p.Product_variables)
for i := 0; i < t.NumField(); i++ {
f := t.Field(i)
archVariant := proptools.HasTag(f, "android", "arch_variant")
if mainProductVariablesStructField, ok := allProductVariablesType.FieldByName(f.Name); ok {
productVariablesInfo[f.Name] = productVariableStarlarkRepresentation{
soongType: stringRepresentationOfSimpleType(mainProductVariablesStructField.Type),
selectable: true,
archVariant: archVariant,
}
} else {
panic("Unknown variable " + f.Name)
}
}
err = pathtools.WriteFileIfChanged(filepath.Join(dir, "product_variable_constants.bzl"), []byte(fmt.Sprintf(`
# product_var_constant_info is a map of product variables to information about them. The fields are:
# - soongType: The type of the product variable as it appears in soong's ProductVariables struct.
# examples are string, bool, int, *bool, *string, []string, etc. This may be an overly
# conservative estimation of the type, for example a *bool could oftentimes just be a
# bool that defaults to false.
# - selectable: if this product variable can be selected on in Android.bp/build files. This means
# it's listed in the "variableProperties" soong struct. Currently all variables in
# this list are selectable because we only need the selectable ones at the moment,
# but the list may be expanded later.
# - archVariant: If the variable is tagged as arch variant in the "variableProperties" struct.
product_var_constant_info = %s
product_var_constraints = [k for k, v in product_var_constant_info.items() if v.selectable]
arch_variant_product_var_constraints = [k for k, v in product_var_constant_info.items() if v.selectable and v.archVariant]
`, starlark_fmt.PrintAny(productVariablesInfo, 0))), 0644)
if err != nil {
return fmt.Errorf("Could not write .bzl config file %s", err)
}
err = pathtools.WriteFileIfChanged(filepath.Join(dir, "BUILD"),
[]byte(bazel.GeneratedBazelFileWarning), 0644)
if err != nil {
return fmt.Errorf("Could not write BUILD config file %s", err)
}
return nil
}
func stringRepresentationOfSimpleType(ty reflect.Type) string {
switch ty.Kind() {
case reflect.String:
return "string"
case reflect.Bool:
return "bool"
case reflect.Int:
return "int"
case reflect.Slice:
return "[]" + stringRepresentationOfSimpleType(ty.Elem())
case reflect.Pointer:
return "*" + stringRepresentationOfSimpleType(ty.Elem())
default:
panic("unimplemented type: " + ty.Kind().String())
}
}
// NullConfig returns a mostly empty Config for use by standalone tools like dexpreopt_gen that
// use the android package.
func NullConfig(outDir, soongOutDir string) Config {

12
android/testing.go
View file

@ -1014,10 +1014,18 @@ func (m TestingModule) VariablesForTestsRelativeToTop() map[string]string {
return normalizeStringMapRelativeToTop(m.config, m.module.VariablesForTests())
}
// OutputFiles calls OutputFileProducer.OutputFiles on the encapsulated module, exits the test
// immediately if there is an error and otherwise returns the result of calling Paths.RelativeToTop
// OutputFiles first checks if module base outputFiles property has any output
// files can be used to return.
// If not, it calls OutputFileProducer.OutputFiles on the
// encapsulated module, exits the test immediately if there is an error and
// otherwise returns the result of calling Paths.RelativeToTop
// on the returned Paths.
func (m TestingModule) OutputFiles(t *testing.T, tag string) Paths {
// TODO: add non-empty-string tag case and remove OutputFileProducer part
if tag == "" && m.module.base().outputFiles.DefaultOutputFiles != nil {
return m.module.base().outputFiles.DefaultOutputFiles.RelativeToTop()
}
producer, ok := m.module.(OutputFileProducer)
if !ok {
t.Fatalf("%q must implement OutputFileProducer\n", m.module.Name())

11
cc/compiler.go
View file

@ -172,12 +172,6 @@ type BaseCompilerProperties struct {
Target_api *string
}
Debug, Release struct {
// list of module-specific flags that will be used for C and C++ compiles in debug or
// release builds
Cflags []string `android:"arch_variant"`
} `android:"arch_variant"`
Target struct {
Vendor, Product struct {
// list of source files that should only be used in vendor or
@ -479,11 +473,6 @@ func (compiler *baseCompiler) compilerFlags(ctx ModuleContext, flags Flags, deps
ctx.ModuleErrorf("%s", err)
}
CheckBadCompilerFlags(ctx, "release.cflags", compiler.Properties.Release.Cflags)
// TODO: debug
flags.Local.CFlags = append(flags.Local.CFlags, esc(compiler.Properties.Release.Cflags)...)
if !ctx.DeviceConfig().BuildBrokenClangCFlags() && len(compiler.Properties.Clang_cflags) != 0 {
ctx.PropertyErrorf("clang_cflags", "property is deprecated, see Changes.md file")
} else {

11
cc/lto.go
View file

@ -54,6 +54,9 @@ type LTOProperties struct {
// Use -fwhole-program-vtables cflag.
Whole_program_vtables *bool
// Use --lto-O0 flag.
Lto_O0 *bool
}
type lto struct {
@ -106,12 +109,8 @@ func (lto *lto) flags(ctx ModuleContext, flags Flags) Flags {
ltoCFlags := []string{"-flto=thin", "-fsplit-lto-unit"}
var ltoLdFlags []string
// The module did not explicitly turn on LTO. Only leverage LTO's
// better dead code elimination and CFG simplification, but do
// not perform costly optimizations for a balance between compile
// time, binary size and performance.
// Apply the same for Eng builds as well.
if !lto.ThinLTO() || ctx.Config().Eng() {
// Do not perform costly LTO optimizations for Eng builds.
if Bool(lto.Properties.Lto_O0) || ctx.Config().Eng() {
ltoLdFlags = append(ltoLdFlags, "-Wl,--lto-O0")
}