diff options
40 files changed, 825 insertions, 666 deletions
diff --git a/android/module.go b/android/module.go index 6a2cc897c..11f63bd49 100644 --- a/android/module.go +++ b/android/module.go @@ -2866,18 +2866,31 @@ func isUnqualifiedModuleName(module string) bool { return strings.IndexByte(module, '/') == -1 } +// sourceOrOutputDependencyTag is the dependency tag added automatically by pathDepsMutator for any +// module reference in a property annotated with `android:"path"` or passed to ExtractSourceDeps +// or ExtractSourcesDeps. +// +// If uniquely identifies the dependency that was added as it contains both the module name used to +// add the dependency as well as the tag. That makes it very simple to find the matching dependency +// in GetModuleFromPathDep as all it needs to do is find the dependency whose tag matches the tag +// used to add it. It does not need to check that the module name as returned by one of +// Module.Name(), BaseModuleContext.OtherModuleName() or ModuleBase.BaseModuleName() matches the +// name supplied in the tag. That means it does not need to handle differences in module names +// caused by prebuilt_ prefix, or fully qualified module names. type sourceOrOutputDependencyTag struct { blueprint.BaseDependencyTag + + // The name of the module. + moduleName string + + // The tag that will be passed to the module's OutputFileProducer.OutputFiles(tag) method. tag string } -func sourceOrOutputDepTag(tag string) blueprint.DependencyTag { - return sourceOrOutputDependencyTag{tag: tag} +func sourceOrOutputDepTag(moduleName, tag string) blueprint.DependencyTag { + return sourceOrOutputDependencyTag{moduleName: moduleName, tag: tag} } -// Deprecated, use IsSourceDepTagWithOutputTag(tag, "") instead. -var SourceDepTag = sourceOrOutputDepTag("") - // IsSourceDepTag returns true if the supplied blueprint.DependencyTag is one that was used to add // dependencies by either ExtractSourceDeps, ExtractSourcesDeps or automatically for properties // tagged with `android:"path"`. @@ -2908,7 +2921,7 @@ func ExtractSourcesDeps(ctx BottomUpMutatorContext, srcFiles []string) { ctx.ModuleErrorf("found source dependency duplicate: %q!", s) } else { set[s] = true - ctx.AddDependency(ctx.Module(), sourceOrOutputDepTag(t), m) + ctx.AddDependency(ctx.Module(), sourceOrOutputDepTag(m, t), m) } } } @@ -2921,7 +2934,7 @@ func ExtractSourcesDeps(ctx BottomUpMutatorContext, srcFiles []string) { func ExtractSourceDeps(ctx BottomUpMutatorContext, s *string) { if s != nil { if m, t := SrcIsModuleWithTag(*s); m != "" { - ctx.AddDependency(ctx.Module(), sourceOrOutputDepTag(t), m) + ctx.AddDependency(ctx.Module(), sourceOrOutputDepTag(m, t), m) } } } diff --git a/android/path_properties.go b/android/path_properties.go index 44467730d..397688064 100644 --- a/android/path_properties.go +++ b/android/path_properties.go @@ -51,7 +51,7 @@ func addPathDepsForProps(ctx BottomUpMutatorContext, props []interface{}) { // Add dependencies to anything that is a module reference. for _, s := range pathProperties { if m, t := SrcIsModuleWithTag(s); m != "" { - ctx.AddDependency(ctx.Module(), sourceOrOutputDepTag(t), m) + ctx.AddDependency(ctx.Module(), sourceOrOutputDepTag(m, t), m) } } } diff --git a/android/paths.go b/android/paths.go index 99d5ba7bc..bec8a51a2 100644 --- a/android/paths.go +++ b/android/paths.go @@ -88,7 +88,8 @@ func GlobFiles(ctx EarlyModulePathContext, globPattern string, excludes []string // the Path methods that rely on module dependencies having been resolved. type ModuleWithDepsPathContext interface { EarlyModulePathContext - GetDirectDepWithTag(name string, tag blueprint.DependencyTag) blueprint.Module + VisitDirectDepsBlueprint(visit func(blueprint.Module)) + OtherModuleDependencyTag(m blueprint.Module) blueprint.DependencyTag } // ModuleMissingDepsPathContext is a subset of *ModuleContext methods required by @@ -484,10 +485,27 @@ func getPathsFromModuleDep(ctx ModuleWithDepsPathContext, path, moduleName, tag // // If tag is "" then the returned module will be the dependency that was added for ":moduleName". // Otherwise, it is the dependency that was added for ":moduleName{tag}". -// -// TODO(b/193228441) Make this handle fully qualified names, e.g. //namespace:moduleName. func GetModuleFromPathDep(ctx ModuleWithDepsPathContext, moduleName, tag string) blueprint.Module { - return ctx.GetDirectDepWithTag(moduleName, sourceOrOutputDepTag(tag)) + var found blueprint.Module + // The sourceOrOutputDepTag uniquely identifies the module dependency as it contains both the + // module name and the tag. Dependencies added automatically for properties tagged with + // `android:"path"` are deduped so are guaranteed to be unique. It is possible for duplicate + // dependencies to be added manually using ExtractSourcesDeps or ExtractSourceDeps but even then + // it will always be the case that the dependencies will be identical, i.e. the same tag and same + // moduleName referring to the same dependency module. + // + // It does not matter whether the moduleName is a fully qualified name or if the module + // dependency is a prebuilt module. All that matters is the same information is supplied to + // create the tag here as was supplied to create the tag when the dependency was added so that + // this finds the matching dependency module. + expectedTag := sourceOrOutputDepTag(moduleName, tag) + ctx.VisitDirectDepsBlueprint(func(module blueprint.Module) { + depTag := ctx.OtherModuleDependencyTag(module) + if depTag == expectedTag { + found = module + } + }) + return found } // PathsAndMissingDepsForModuleSrcExcludes returns a Paths{} containing the resolved references in diff --git a/android/paths_test.go b/android/paths_test.go index 7675905fc..f4e4ce16e 100644 --- a/android/paths_test.go +++ b/android/paths_test.go @@ -1390,7 +1390,6 @@ func TestPathForModuleSrc(t *testing.T) { }), }, { - // TODO(b/193228441): Fix broken test. name: "output file provider, fully qualified name", bp: ` test { @@ -1398,6 +1397,10 @@ func TestPathForModuleSrc(t *testing.T) { src: "//other:b", srcs: ["//other:c"], }`, + src: "out/soong/.intermediates/other/b/gen/b", + rel: "gen/b", + srcs: []string{"out/soong/.intermediates/other/c/gen/c"}, + rels: []string{"gen/c"}, preparer: FixtureAddTextFile("other/Android.bp", ` soong_namespace {} @@ -1411,10 +1414,6 @@ func TestPathForModuleSrc(t *testing.T) { outs: ["gen/c"], } `), - errorHandler: FixtureExpectsAllErrorsToMatchAPattern([]string{ - `"foo": missing dependencies: //other:b, is the property annotated with android:"path"`, - `"foo": missing dependency on "//other:c", is the property annotated with android:"path"`, - }), }, } diff --git a/android/soong_config_modules_test.go b/android/soong_config_modules_test.go index 8f252d944..b2f8eaad8 100644 --- a/android/soong_config_modules_test.go +++ b/android/soong_config_modules_test.go @@ -313,6 +313,51 @@ func TestSoongConfigModule(t *testing.T) { }) } +func TestNonExistentPropertyInSoongConfigModule(t *testing.T) { + bp := ` + soong_config_module_type { + name: "acme_test", + module_type: "test", + config_namespace: "acme", + bool_variables: ["feature1"], + properties: ["made_up_property"], + } + + acme_test { + name: "foo", + cflags: ["-DGENERIC"], + soong_config_variables: { + feature1: { + made_up_property: true, + }, + }, + } + ` + + fixtureForVendorVars := func(vars map[string]map[string]string) FixturePreparer { + return FixtureModifyProductVariables(func(variables FixtureProductVariables) { + variables.VendorVars = vars + }) + } + + GroupFixturePreparers( + fixtureForVendorVars(map[string]map[string]string{"acme": {"feature1": "1"}}), + PrepareForTestWithDefaults, + FixtureRegisterWithContext(func(ctx RegistrationContext) { + ctx.RegisterModuleType("soong_config_module_type_import", soongConfigModuleTypeImportFactory) + ctx.RegisterModuleType("soong_config_module_type", soongConfigModuleTypeFactory) + ctx.RegisterModuleType("soong_config_string_variable", soongConfigStringVariableDummyFactory) + ctx.RegisterModuleType("soong_config_bool_variable", soongConfigBoolVariableDummyFactory) + ctx.RegisterModuleType("test_defaults", soongConfigTestDefaultsModuleFactory) + ctx.RegisterModuleType("test", soongConfigTestModuleFactory) + }), + FixtureWithRootAndroidBp(bp), + ).ExtendWithErrorHandler(FixtureExpectsAllErrorsToMatchAPattern([]string{ + // TODO(b/171232169): improve the error message for non-existent properties + `unrecognized property "soong_config_variables`, + })).RunTest(t) +} + func testConfigWithVendorVars(buildDir, bp string, fs map[string][]byte, vendorVars map[string]map[string]string) Config { config := TestConfig(buildDir, nil, bp, fs) diff --git a/apex/platform_bootclasspath_test.go b/apex/platform_bootclasspath_test.go index 279cf54de..7209c0275 100644 --- a/apex/platform_bootclasspath_test.go +++ b/apex/platform_bootclasspath_test.go @@ -398,6 +398,7 @@ func TestPlatformBootclasspath_AlwaysUsePrebuiltSdks(t *testing.T) { name: "foo", prefer: false, shared_library: false, + permitted_packages: ["foo"], public: { jars: ["sdk_library/public/foo-stubs.jar"], stub_srcs: ["sdk_library/public/foo_stub_sources"], diff --git a/cc/builder.go b/cc/builder.go index bde8c9647..b0842ec72 100644 --- a/cc/builder.go +++ b/cc/builder.go @@ -500,10 +500,10 @@ func transformSourceToObj(ctx android.ModuleContext, subdir string, srcFiles and sAbiDumpFiles = make(android.Paths, 0, len(srcFiles)) } - cflags += " ${config.NoOverrideClangGlobalCflags}" - toolingCflags += " ${config.NoOverrideClangGlobalCflags}" - cppflags += " ${config.NoOverrideClangGlobalCflags}" - toolingCppflags += " ${config.NoOverrideClangGlobalCflags}" + cflags += " ${config.NoOverrideGlobalCflags}" + toolingCflags += " ${config.NoOverrideGlobalCflags}" + cppflags += " ${config.NoOverrideGlobalCflags}" + toolingCppflags += " ${config.NoOverrideGlobalCflags}" for i, srcFile := range srcFiles { objFile := android.ObjPathWithExt(ctx, subdir, srcFile, "o") diff --git a/cc/cc_test.go b/cc/cc_test.go index 0a74e5824..0a3acb95f 100644 --- a/cc/cc_test.go +++ b/cc/cc_test.go @@ -4038,14 +4038,14 @@ func TestIncludeDirectoryOrdering(t *testing.T) { } want := []string{ - "${config.ArmClangThumbCflags}", - "${config.ArmClangCflags}", - "${config.CommonClangGlobalCflags}", - "${config.DeviceClangGlobalCflags}", - "${config.ClangExternalCflags}", - "${config.ArmToolchainClangCflags}", - "${config.ArmClangArmv7ANeonCflags}", - "${config.ArmClangGenericCflags}", + "${config.ArmThumbCflags}", + "${config.ArmCflags}", + "${config.CommonGlobalCflags}", + "${config.DeviceGlobalCflags}", + "${config.ExternalCflags}", + "${config.ArmToolchainCflags}", + "${config.ArmArmv7ANeonCflags}", + "${config.ArmGenericCflags}", "android_arm_export_include_dirs", "lib32_export_include_dirs", "arm_export_include_dirs", @@ -4076,7 +4076,7 @@ func TestIncludeDirectoryOrdering(t *testing.T) { "defaults/cc/common/ndk_libandroid_support", "out/soong/ndk/sysroot/usr/include", "out/soong/ndk/sysroot/usr/include/arm-linux-androideabi", - "${config.NoOverrideClangGlobalCflags}", + "${config.NoOverrideGlobalCflags}", } android.AssertArrayString(t, "includes", want, includes) diff --git a/cc/compiler.go b/cc/compiler.go index 69ead3089..b01ba4326 100644 --- a/cc/compiler.go +++ b/cc/compiler.go @@ -392,7 +392,7 @@ func (compiler *baseCompiler) compilerFlags(ctx ModuleContext, flags Flags, deps if flags.RequiredInstructionSet != "" { instructionSet = flags.RequiredInstructionSet } - instructionSetFlags, err := tc.ClangInstructionSetFlags(instructionSet) + instructionSetFlags, err := tc.InstructionSetFlags(instructionSet) if err != nil { ctx.ModuleErrorf("%s", err) } @@ -437,15 +437,15 @@ func (compiler *baseCompiler) compilerFlags(ctx ModuleContext, flags Flags, deps flags.Global.ConlyFlags = append([]string{"${config.CommonGlobalConlyflags}"}, flags.Global.ConlyFlags...) flags.Global.CppFlags = append([]string{fmt.Sprintf("${config.%sGlobalCppflags}", hod)}, flags.Global.CppFlags...) - flags.Global.AsFlags = append(flags.Global.AsFlags, tc.ClangAsflags()) - flags.Global.CppFlags = append([]string{"${config.CommonClangGlobalCppflags}"}, flags.Global.CppFlags...) + flags.Global.AsFlags = append(flags.Global.AsFlags, tc.Asflags()) + flags.Global.CppFlags = append([]string{"${config.CommonGlobalCppflags}"}, flags.Global.CppFlags...) flags.Global.CommonFlags = append(flags.Global.CommonFlags, - tc.ClangCflags(), - "${config.CommonClangGlobalCflags}", - fmt.Sprintf("${config.%sClangGlobalCflags}", hod)) + tc.Cflags(), + "${config.CommonGlobalCflags}", + fmt.Sprintf("${config.%sGlobalCflags}", hod)) if isThirdParty(modulePath) { - flags.Global.CommonFlags = append(flags.Global.CommonFlags, "${config.ClangExternalCflags}") + flags.Global.CommonFlags = append(flags.Global.CommonFlags, "${config.ExternalCflags}") } if tc.Bionic() { @@ -458,11 +458,11 @@ func (compiler *baseCompiler) compilerFlags(ctx ModuleContext, flags Flags, deps flags.Global.AsFlags = append(flags.Global.AsFlags, "-D__ASSEMBLY__") - flags.Global.CppFlags = append(flags.Global.CppFlags, tc.ClangCppflags()) + flags.Global.CppFlags = append(flags.Global.CppFlags, tc.Cppflags()) flags.Global.YasmFlags = append(flags.Global.YasmFlags, tc.YasmFlags()) - flags.Global.CommonFlags = append(flags.Global.CommonFlags, tc.ToolchainClangCflags()) + flags.Global.CommonFlags = append(flags.Global.CommonFlags, tc.ToolchainCflags()) cStd := config.CStdVersion if String(compiler.Properties.C_std) == "experimental" { diff --git a/cc/config/arm64_device.go b/cc/config/arm64_device.go index af6361bff..812a245d2 100644 --- a/cc/config/arm64_device.go +++ b/cc/config/arm64_device.go @@ -48,12 +48,12 @@ var ( "-Wl,-z,separate-code", } - arm64Lldflags = append(ClangFilterUnknownLldflags(arm64Ldflags), + arm64Lldflags = append(arm64Ldflags, "-Wl,-z,max-page-size=4096") arm64Cppflags = []string{} - arm64ClangCpuVariantCflags = map[string][]string{ + arm64CpuVariantCflags = map[string][]string{ "cortex-a53": []string{ "-mcpu=cortex-a53", }, @@ -99,52 +99,50 @@ func init() { pctx.StaticVariable("Arm64Ldflags", strings.Join(arm64Ldflags, " ")) pctx.StaticVariable("Arm64Lldflags", strings.Join(arm64Lldflags, " ")) - pctx.StaticVariable("Arm64ClangCflags", strings.Join(ClangFilterUnknownCflags(arm64Cflags), " ")) - pctx.StaticVariable("Arm64ClangLdflags", strings.Join(ClangFilterUnknownCflags(arm64Ldflags), " ")) - pctx.StaticVariable("Arm64ClangLldflags", strings.Join(ClangFilterUnknownCflags(arm64Lldflags), " ")) - pctx.StaticVariable("Arm64ClangCppflags", strings.Join(ClangFilterUnknownCflags(arm64Cppflags), " ")) + pctx.StaticVariable("Arm64Cflags", strings.Join(arm64Cflags, " ")) + pctx.StaticVariable("Arm64Cppflags", strings.Join(arm64Cppflags, " ")) - pctx.StaticVariable("Arm64ClangArmv8ACflags", strings.Join(arm64ArchVariantCflags["armv8-a"], " ")) - pctx.StaticVariable("Arm64ClangArmv8ABranchProtCflags", strings.Join(arm64ArchVariantCflags["armv8-a-branchprot"], " ")) - pctx.StaticVariable("Arm64ClangArmv82ACflags", strings.Join(arm64ArchVariantCflags["armv8-2a"], " ")) - pctx.StaticVariable("Arm64ClangArmv82ADotprodCflags", strings.Join(arm64ArchVariantCflags["armv8-2a-dotprod"], " ")) + 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("Arm64ClangCortexA53Cflags", - strings.Join(arm64ClangCpuVariantCflags["cortex-a53"], " ")) + pctx.StaticVariable("Arm64CortexA53Cflags", + strings.Join(arm64CpuVariantCflags["cortex-a53"], " ")) - pctx.StaticVariable("Arm64ClangCortexA55Cflags", - strings.Join(arm64ClangCpuVariantCflags["cortex-a55"], " ")) + pctx.StaticVariable("Arm64CortexA55Cflags", + strings.Join(arm64CpuVariantCflags["cortex-a55"], " ")) - pctx.StaticVariable("Arm64ClangKryoCflags", - strings.Join(arm64ClangCpuVariantCflags["kryo"], " ")) + pctx.StaticVariable("Arm64KryoCflags", + strings.Join(arm64CpuVariantCflags["kryo"], " ")) - pctx.StaticVariable("Arm64ClangExynosM1Cflags", - strings.Join(arm64ClangCpuVariantCflags["exynos-m1"], " ")) + pctx.StaticVariable("Arm64ExynosM1Cflags", + strings.Join(arm64CpuVariantCflags["exynos-m1"], " ")) - pctx.StaticVariable("Arm64ClangExynosM2Cflags", - strings.Join(arm64ClangCpuVariantCflags["exynos-m2"], " ")) + pctx.StaticVariable("Arm64ExynosM2Cflags", + strings.Join(arm64CpuVariantCflags["exynos-m2"], " ")) } var ( - arm64ClangArchVariantCflagsVar = map[string]string{ - "armv8-a": "${config.Arm64ClangArmv8ACflags}", - "armv8-a-branchprot": "${config.Arm64ClangArmv8ABranchProtCflags}", - "armv8-2a": "${config.Arm64ClangArmv82ACflags}", - "armv8-2a-dotprod": "${config.Arm64ClangArmv82ADotprodCflags}", + arm64ArchVariantCflagsVar = map[string]string{ + "armv8-a": "${config.Arm64Armv8ACflags}", + "armv8-a-branchprot": "${config.Arm64Armv8ABranchProtCflags}", + "armv8-2a": "${config.Arm64Armv82ACflags}", + "armv8-2a-dotprod": "${config.Arm64Armv82ADotprodCflags}", } - arm64ClangCpuVariantCflagsVar = map[string]string{ + arm64CpuVariantCflagsVar = map[string]string{ "": "", - "cortex-a53": "${config.Arm64ClangCortexA53Cflags}", - "cortex-a55": "${config.Arm64ClangCortexA55Cflags}", - "cortex-a72": "${config.Arm64ClangCortexA53Cflags}", - "cortex-a73": "${config.Arm64ClangCortexA53Cflags}", - "cortex-a75": "${config.Arm64ClangCortexA55Cflags}", - "cortex-a76": "${config.Arm64ClangCortexA55Cflags}", - "kryo": "${config.Arm64ClangKryoCflags}", - "kryo385": "${config.Arm64ClangCortexA53Cflags}", - "exynos-m1": "${config.Arm64ClangExynosM1Cflags}", - "exynos-m2": "${config.Arm64ClangExynosM2Cflags}", + "cortex-a53": "${config.Arm64CortexA53Cflags}", + "cortex-a55": "${config.Arm64CortexA55Cflags}", + "cortex-a72": "${config.Arm64CortexA53Cflags}", + "cortex-a73": "${config.Arm64CortexA53Cflags}", + "cortex-a75": "${config.Arm64CortexA55Cflags}", + "cortex-a76": "${config.Arm64CortexA55Cflags}", + "kryo": "${config.Arm64KryoCflags}", + "kryo385": "${config.Arm64CortexA53Cflags}", + "exynos-m1": "${config.Arm64ExynosM1Cflags}", + "exynos-m2": "${config.Arm64ExynosM2Cflags}", } ) @@ -152,9 +150,9 @@ type toolchainArm64 struct { toolchainBionic toolchain64Bit - ldflags string - lldflags string - toolchainClangCflags string + ldflags string + lldflags string + toolchainCflags string } func (t *toolchainArm64) Name() string { @@ -181,24 +179,24 @@ func (t *toolchainArm64) ClangTriple() string { return t.GccTriple() } -func (t *toolchainArm64) ClangCflags() string { - return "${config.Arm64ClangCflags}" +func (t *toolchainArm64) Cflags() string { + return "${config.Arm64Cflags}" } -func (t *toolchainArm64) ClangCppflags() string { - return "${config.Arm64ClangCppflags}" +func (t *toolchainArm64) Cppflags() string { + return "${config.Arm64Cppflags}" } -func (t *toolchainArm64) ClangLdflags() string { +func (t *toolchainArm64) Ldflags() string { return t.ldflags } -func (t *toolchainArm64) ClangLldflags() string { +func (t *toolchainArm64) Lldflags() string { return t.lldflags } -func (t *toolchainArm64) ToolchainClangCflags() string { - return t.toolchainClangCflags +func (t *toolchainArm64) ToolchainCflags() string { + return t.toolchainCflags } func (toolchainArm64) LibclangRuntimeLibraryArch() string { @@ -216,9 +214,9 @@ func arm64ToolchainFactory(arch android.Arch) Toolchain { panic(fmt.Sprintf("Unknown ARM architecture version: %q", arch.ArchVariant)) } - toolchainClangCflags := []string{arm64ClangArchVariantCflagsVar[arch.ArchVariant]} - toolchainClangCflags = append(toolchainClangCflags, - variantOrDefault(arm64ClangCpuVariantCflagsVar, arch.CpuVariant)) + toolchainCflags := []string{arm64ArchVariantCflagsVar[arch.ArchVariant]} + toolchainCflags = append(toolchainCflags, + variantOrDefault(arm64CpuVariantCflagsVar, arch.CpuVariant)) var extraLdflags string switch arch.CpuVariant { @@ -235,7 +233,7 @@ func arm64ToolchainFactory(arch android.Arch) Toolchain { "${config.Arm64Lldflags}", extraLdflags, }, " "), - toolchainClangCflags: strings.Join(toolchainClangCflags, " "), + toolchainCflags: strings.Join(toolchainCflags, " "), } } diff --git a/cc/config/arm64_fuchsia_device.go b/cc/config/arm64_fuchsia_device.go index a6b5e8c67..5ab27a03c 100644 --- a/cc/config/arm64_fuchsia_device.go +++ b/cc/config/arm64_fuchsia_device.go @@ -42,47 +42,31 @@ func (t *toolchainFuchsiaArm64) GccVersion() string { return arm64GccVersion } -func (t *toolchainFuchsiaArm64) Cflags() string { - return "" -} - -func (t *toolchainFuchsiaArm64) Cppflags() string { - return "" -} - -func (t *toolchainFuchsiaArm64) Ldflags() string { - return "-Wl,--fix-cortex-a53-843419" -} - func (t *toolchainFuchsiaArm64) IncludeFlags() string { return "" } -func (t *toolchainFuchsiaArm64) ToolchainCflags() string { - return "-mcpu=cortex-a53" -} - func (t *toolchainFuchsiaArm64) ClangTriple() string { return "arm64-fuchsia-android" } -func (t *toolchainFuchsiaArm64) ClangCppflags() string { +func (t *toolchainFuchsiaArm64) Cppflags() string { return "-Wno-error=deprecated-declarations" } -func (t *toolchainFuchsiaArm64) ClangLdflags() string { +func (t *toolchainFuchsiaArm64) Ldflags() string { return "--target=arm64-fuchsia --sysroot=" + fuchsiaArm64SysRoot + " -L" + fuchsiaArm64PrebuiltLibsRoot + "/aarch64-fuchsia/lib " + "-Lprebuilts/fuchsia_sdk/arch/arm64/dist/" } -func (t *toolchainFuchsiaArm64) ClangLldflags() string { +func (t *toolchainFuchsiaArm64) Lldflags() string { return "--target=arm64-fuchsia --sysroot=" + fuchsiaArm64SysRoot + " -L" + fuchsiaArm64PrebuiltLibsRoot + "/aarch64-fuchsia/lib " + "-Lprebuilts/fuchsia_sdk/arch/arm64/dist/" } -func (t *toolchainFuchsiaArm64) ClangCflags() string { +func (t *toolchainFuchsiaArm64) Cflags() string { return "--target=arm64-fuchsia --sysroot=" + fuchsiaArm64SysRoot + " -I" + fuchsiaArm64SysRoot + "/include" } -func (t *toolchainFuchsiaArm64) ToolchainClangCflags() string { +func (t *toolchainFuchsiaArm64) ToolchainCflags() string { return "-march=armv8-a" } diff --git a/cc/config/arm64_linux_host.go b/cc/config/arm64_linux_host.go index 83bd7997b..853d818f1 100644 --- a/cc/config/arm64_linux_host.go +++ b/cc/config/arm64_linux_host.go @@ -15,14 +15,15 @@ package config import ( - "android/soong/android" "strings" + + "android/soong/android" ) var ( // This is a host toolchain but flags for device toolchain are required // as the flags are actually for Bionic-based builds. - linuxCrossCflags = ClangFilterUnknownCflags(append(deviceGlobalCflags, + linuxCrossCflags = append(deviceGlobalCflags, // clang by default enables PIC when the clang triple is set to *-android. // See toolchain/llvm-project/clang/lib/Driver/ToolChains/CommonArgs.cpp#920. // However, for this host target, we don't set "-android" to avoid __ANDROID__ macro @@ -33,9 +34,9 @@ var ( // This is normally in ClangExtraTargetCflags, but that's for device and we need // the same for host "-nostdlibinc", - )) + ) - linuxCrossLdflags = ClangFilterUnknownCflags([]string{ + linuxCrossLdflags = []string{ "-Wl,-z,noexecstack", "-Wl,-z,relro", "-Wl,-z,now", @@ -44,7 +45,7 @@ var ( "-Wl,--fatal-warnings", "-Wl,--hash-style=gnu", "-Wl,--no-undefined-version", - }) + } // Embed the linker into host bionic binaries. This is needed to support host bionic, // as the linux kernel requires that the ELF interpreter referenced by PT_INTERP be @@ -73,9 +74,9 @@ func (toolchainLinuxArm64) ClangTriple() string { return "aarch64-linux" } -func (toolchainLinuxArm64) ClangCflags() string { +func (toolchainLinuxArm64) Cflags() string { // The inherited flags + extra flags - return "${config.Arm64ClangCflags} ${config.LinuxBionicArm64Cflags}" + return "${config.Arm64Cflags} ${config.LinuxBionicArm64Cflags}" } func (toolchainLinuxArm64) CrtBeginSharedBinary() []string { @@ -84,7 +85,7 @@ func (toolchainLinuxArm64) CrtBeginSharedBinary() []string { func linuxArm64ToolchainFactory(arch android.Arch) Toolchain { archVariant := "armv8-a" // for host, default to armv8-a - toolchainClangCflags := []string{arm64ClangArchVariantCflagsVar[archVariant]} + toolchainCflags := []string{arm64ArchVariantCflagsVar[archVariant]} // We don't specify CPU architecture for host. Conservatively assume // the host CPU needs the fix @@ -103,7 +104,7 @@ func linuxArm64ToolchainFactory(arch android.Arch) Toolchain { "${config.LinuxBionicArm64Ldflags}", extraLdflags, }, " ") - ret.toolchainArm64.toolchainClangCflags = strings.Join(toolchainClangCflags, " ") + ret.toolchainArm64.toolchainCflags = strings.Join(toolchainCflags, " ") return &ret } diff --git a/cc/config/arm_device.go b/cc/config/arm_device.go index 3c2773021..b5afe408f 100644 --- a/cc/config/arm_device.go +++ b/cc/config/arm_device.go @@ -23,7 +23,6 @@ import ( var ( armToolchainCflags = []string{ - "-mthumb-interwork", "-msoft-float", } @@ -38,7 +37,7 @@ var ( "-Wl,-m,armelf", } - armLldflags = ClangFilterUnknownLldflags(armLdflags) + armLldflags = armLdflags armArmCflags = []string{ "-fstrict-aliasing", @@ -49,7 +48,7 @@ var ( "-Os", } - armClangArchVariantCflags = map[string][]string{ + armArchVariantCflags = map[string][]string{ "armv7-a": []string{ "-march=armv7-a", "-mfloat-abi=softfp", @@ -72,7 +71,7 @@ var ( }, } - armClangCpuVariantCflags = map[string][]string{ + armCpuVariantCflags = map[string][]string{ "cortex-a7": []string{ "-mcpu=cortex-a7", "-mfpu=neon-vfpv4", @@ -181,67 +180,65 @@ func init() { exportStringListStaticVariable("ArmLldflags", armLldflags) // Clang cflags - exportStringListStaticVariable("ArmToolchainClangCflags", ClangFilterUnknownCflags(armToolchainCflags)) - exportStringListStaticVariable("ArmClangCflags", ClangFilterUnknownCflags(armCflags)) - exportStringListStaticVariable("ArmClangLdflags", ClangFilterUnknownCflags(armLdflags)) - exportStringListStaticVariable("ArmClangLldflags", ClangFilterUnknownCflags(armLldflags)) - exportStringListStaticVariable("ArmClangCppflags", ClangFilterUnknownCflags(armCppflags)) + exportStringListStaticVariable("ArmToolchainCflags", armToolchainCflags) + exportStringListStaticVariable("ArmCflags", armCflags) + exportStringListStaticVariable("ArmCppflags", armCppflags) // Clang ARM vs. Thumb instruction set cflags - exportStringListStaticVariable("ArmClangArmCflags", ClangFilterUnknownCflags(armArmCflags)) - exportStringListStaticVariable("ArmClangThumbCflags", ClangFilterUnknownCflags(armThumbCflags)) + exportStringListStaticVariable("ArmArmCflags", armArmCflags) + exportStringListStaticVariable("ArmThumbCflags", armThumbCflags) // Clang arch variant cflags - exportStringListStaticVariable("ArmClangArmv7ACflags", armClangArchVariantCflags["armv7-a"]) - exportStringListStaticVariable("ArmClangArmv7ANeonCflags", armClangArchVariantCflags["armv7-a-neon"]) - exportStringListStaticVariable("ArmClangArmv8ACflags", armClangArchVariantCflags["armv8-a"]) - exportStringListStaticVariable("ArmClangArmv82ACflags", armClangArchVariantCflags["armv8-2a"]) + exportStringListStaticVariable("ArmArmv7ACflags", armArchVariantCflags["armv7-a"]) + exportStringListStaticVariable("ArmArmv7ANeonCflags", armArchVariantCflags["armv7-a-neon"]) + exportStringListStaticVariable("ArmArmv8ACflags", armArchVariantCflags["armv8-a"]) + exportStringListStaticVariable("ArmArmv82ACflags", armArchVariantCflags["armv8-2a"]) // Clang cpu variant cflags - 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"]) + exportStringListStaticVariable("ArmGenericCflags", armCpuVariantCflags[""]) + exportStringListStaticVariable("ArmCortexA7Cflags", armCpuVariantCflags["cortex-a7"]) + exportStringListStaticVariable("ArmCortexA8Cflags", armCpuVariantCflags["cortex-a8"]) + exportStringListStaticVariable("ArmCortexA15Cflags", armCpuVariantCflags["cortex-a15"]) + exportStringListStaticVariable("ArmCortexA53Cflags", armCpuVariantCflags["cortex-a53"]) + exportStringListStaticVariable("ArmCortexA55Cflags", armCpuVariantCflags["cortex-a55"]) + exportStringListStaticVariable("ArmKraitCflags", armCpuVariantCflags["krait"]) + exportStringListStaticVariable("ArmKryoCflags", armCpuVariantCflags["kryo"]) } var ( - armClangArchVariantCflagsVar = map[string]string{ - "armv7-a": "${config.ArmClangArmv7ACflags}", - "armv7-a-neon": "${config.ArmClangArmv7ANeonCflags}", - "armv8-a": "${config.ArmClangArmv8ACflags}", - "armv8-2a": "${config.ArmClangArmv82ACflags}", + armArchVariantCflagsVar = map[string]string{ + "armv7-a": "${config.ArmArmv7ACflags}", + "armv7-a-neon": "${config.ArmArmv7ANeonCflags}", + "armv8-a": "${config.ArmArmv8ACflags}", + "armv8-2a": "${config.ArmArmv82ACflags}", } - armClangCpuVariantCflagsVar = map[string]string{ - "": "${config.ArmClangGenericCflags}", - "cortex-a7": "${config.ArmClangCortexA7Cflags}", - "cortex-a8": "${config.ArmClangCortexA8Cflags}", - "cortex-a15": "${config.ArmClangCortexA15Cflags}", - "cortex-a53": "${config.ArmClangCortexA53Cflags}", - "cortex-a53.a57": "${config.ArmClangCortexA53Cflags}", - "cortex-a55": "${config.ArmClangCortexA55Cflags}", - "cortex-a72": "${config.ArmClangCortexA53Cflags}", - "cortex-a73": "${config.ArmClangCortexA53Cflags}", - "cortex-a75": "${config.ArmClangCortexA55Cflags}", - "cortex-a76": "${config.ArmClangCortexA55Cflags}", - "krait": "${config.ArmClangKraitCflags}", - "kryo": "${config.ArmClangKryoCflags}", - "kryo385": "${config.ArmClangCortexA53Cflags}", - "exynos-m1": "${config.ArmClangCortexA53Cflags}", - "exynos-m2": "${config.ArmClangCortexA53Cflags}", + armCpuVariantCflagsVar = map[string]string{ + "": "${config.ArmGenericCflags}", + "cortex-a7": "${config.ArmCortexA7Cflags}", + "cortex-a8": "${config.ArmCortexA8Cflags}", + "cortex-a15": "${config.ArmCortexA15Cflags}", + "cortex-a53": "${config.ArmCortexA53Cflags}", + "cortex-a53.a57": "${config.ArmCortexA53Cflags}", + "cortex-a55": "${config.ArmCortexA55Cflags}", + "cortex-a72": "${config.ArmCortexA53Cflags}", + "cortex-a73": "${config.ArmCortexA53Cflags}", + "cortex-a75": "${config.ArmCortexA55Cflags}", + "cortex-a76": "${config.ArmCortexA55Cflags}", + "krait": "${config.ArmKraitCflags}", + "kryo": "${config.ArmKryoCflags}", + "kryo385": "${config.ArmCortexA53Cflags}", + "exynos-m1": "${config.ArmCortexA53Cflags}", + "exynos-m2": "${config.ArmCortexA53Cflags}", } ) type toolchainArm struct { toolchainBionic toolchain32Bit - ldflags string - lldflags string - toolchainClangCflags string + ldflags string + lldflags string + toolchainCflags string } func (t *toolchainArm) Name() string { @@ -274,34 +271,34 @@ func (t *toolchainArm) ndkTriple() string { return t.GccTriple() } -func (t *toolchainArm) ToolchainClangCflags() string { - return t.toolchainClangCflags +func (t *toolchainArm) ToolchainCflags() string { + return t.toolchainCflags } -func (t *toolchainArm) ClangCflags() string { - return "${config.ArmClangCflags}" +func (t *toolchainArm) Cflags() string { + return "${config.ArmCflags}" } -func (t *toolchainArm) ClangCppflags() string { - return "${config.ArmClangCppflags}" +func (t *toolchainArm) Cppflags() string { + return "${config.ArmCppflags}" } -func (t *toolchainArm) ClangLdflags() string { +func (t *toolchainArm) Ldflags() string { return t.ldflags } -func (t *toolchainArm) ClangLldflags() string { +func (t *toolchainArm) Lldflags() string { return t.lldflags // TODO: handle V8 cases } -func (t *toolchainArm) ClangInstructionSetFlags(isa string) (string, error) { +func (t *toolchainArm) InstructionSetFlags(isa string) (string, error) { switch isa { case "arm": - return "${config.ArmClangArmCflags}", nil + return "${config.ArmArmCflags}", nil case "thumb", "": - return "${config.ArmClangThumbCflags}", nil + return "${config.ArmThumbCflags}", nil default: - return t.toolchainBase.ClangInstructionSetFlags(isa) + return t.toolchainBase.InstructionSetFlags(isa) } } @@ -311,13 +308,13 @@ func (toolchainArm) LibclangRuntimeLibraryArch() string { func armToolchainFactory(arch android.Arch) Toolchain { var fixCortexA8 string - toolchainClangCflags := make([]string, 2, 3) + toolchainCflags := make([]string, 2, 3) - toolchainClangCflags[0] = "${config.ArmToolchainClangCflags}" - toolchainClangCflags[1] = armClangArchVariantCflagsVar[arch.ArchVariant] + toolchainCflags[0] = "${config.ArmToolchainCflags}" + toolchainCflags[1] = armArchVariantCflagsVar[arch.ArchVariant] - toolchainClangCflags = append(toolchainClangCflags, - variantOrDefault(armClangCpuVariantCflagsVar, arch.CpuVariant)) + toolchainCflags = append(toolchainCflags, + variantOrDefault(armCpuVariantCflagsVar, arch.CpuVariant)) switch arch.ArchVariant { case "armv7-a-neon": @@ -341,8 +338,8 @@ func armToolchainFactory(arch android.Arch) Toolchain { "${config.ArmLdflags}", fixCortexA8, }, " "), - lldflags: "${config.ArmLldflags}", - toolchainClangCflags: strings.Join(toolchainClangCflags, " "), + lldflags: "${config.ArmLldflags}", + toolchainCflags: strings.Join(toolchainCflags, " "), } } diff --git a/cc/config/bp2build.go b/cc/config/bp2build.go index 19571f10d..e7e94a8a1 100644 --- a/cc/config/bp2build.go +++ b/cc/config/bp2build.go @@ -118,7 +118,7 @@ func BazelCcToolchainVars() string { // quite complex to track depth-first interpolations. It's also unlikely the // interpolation stacks are deep (n > 1). func expandVar(toExpand string, stringScope exportedStringVariables, stringListScope exportedStringListVariables) []string { - // e.g. "${ClangExternalCflags}" + // e.g. "${ExternalCflags}" r := regexp.MustCompile(`\${([a-zA-Z0-9_]+)}`) // Internal recursive function. diff --git a/cc/config/clang.go b/cc/config/clang.go index c484fc921..9cfe28f28 100644 --- a/cc/config/clang.go +++ b/cc/config/clang.go @@ -15,9 +15,10 @@ package config import ( - "android/soong/android" "sort" "strings" + + "android/soong/android" ) // Cflags that should be filtered out when compiling with clang @@ -80,12 +81,6 @@ var ClangUnknownCflags = sorted([]string{ "--enable-stdcall-fixup", }) -// Ldflags that should be filtered out when linking with clang lld -var ClangUnknownLldflags = sorted([]string{ - "-Wl,--fix-cortex-a8", - "-Wl,--no-fix-cortex-a8", -}) - var ClangLibToolingUnknownCflags = sorted([]string{}) // List of tidy checks that should be disabled globally. When the compiler is @@ -153,80 +148,6 @@ func init() { "-D__ANDROID_UNAVAILABLE_SYMBOLS_ARE_WEAK__", }) - exportStringListStaticVariable("ClangExtraCppflags", []string{ - // -Wimplicit-fallthrough is not enabled by -Wall. - "-Wimplicit-fallthrough", - - // Enable clang's thread-safety annotations in libcxx. - "-D_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS", - - // libc++'s math.h has an #include_next outside of system_headers. - "-Wno-gnu-include-next", - }) - - exportStringListStaticVariable("ClangExtraTargetCflags", []string{"-nostdlibinc"}) - - 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 - // fixed. - //"-Werror=null-dereference", - "-Werror=return-type", - - // http://b/72331526 Disable -Wtautological-* until the instances detected by these - // new warnings are fixed. - "-Wno-tautological-constant-compare", - "-Wno-tautological-type-limit-compare", - // http://b/145210666 - "-Wno-reorder-init-list", - // http://b/145211066 - "-Wno-implicit-int-float-conversion", - // New warnings to be fixed after clang-r377782. - "-Wno-int-in-bool-context", // http://b/148287349 - "-Wno-sizeof-array-div", // http://b/148815709 - "-Wno-tautological-overlap-compare", // http://b/148815696 - // New warnings to be fixed after clang-r383902. - "-Wno-deprecated-copy", // http://b/153746672 - "-Wno-range-loop-construct", // http://b/153747076 - "-Wno-misleading-indentation", // http://b/153746954 - "-Wno-zero-as-null-pointer-constant", // http://b/68236239 - "-Wno-deprecated-anon-enum-enum-conversion", // http://b/153746485 - "-Wno-deprecated-enum-enum-conversion", // http://b/153746563 - "-Wno-string-compare", // http://b/153764102 - "-Wno-enum-enum-conversion", // http://b/154138986 - "-Wno-enum-float-conversion", // http://b/154255917 - "-Wno-pessimizing-move", // http://b/154270751 - // New warnings to be fixed after clang-r399163 - "-Wno-non-c-typedef-for-linkage", // http://b/161304145 - // New warnings to be fixed after clang-r407598 - "-Wno-string-concatenation", // http://b/175068488 - }) - - // Extra cflags for external third-party projects to disable warnings that - // are infeasible to fix in all the external projects and their upstream repos. - exportStringListStaticVariable("ClangExtraExternalCflags", []string{ - "-Wno-enum-compare", - "-Wno-enum-compare-switch", - - // http://b/72331524 Allow null pointer arithmetic until the instances detected by - // this new warning are fixed. - "-Wno-null-pointer-arithmetic", - - // Bug: http://b/29823425 Disable -Wnull-dereference until the - // new instances detected by this warning are fixed. - "-Wno-null-dereference", - - // http://b/145211477 - "-Wno-pointer-compare", - // http://b/145211022 - "-Wno-xor-used-as-pow", - // http://b/145211022 - "-Wno-final-dtor-non-final-class", - - // http://b/165945989 - "-Wno-psabi", - }) } func ClangFilterUnknownCflags(cflags []string) []string { @@ -255,26 +176,10 @@ func ClangRewriteTidyChecks(checks []string) []string { return result } -func ClangFilterUnknownLldflags(lldflags []string) []string { - result, _ := android.FilterList(lldflags, ClangUnknownLldflags) - return result -} - func ClangLibToolingFilterUnknownCflags(libToolingFlags []string) []string { return android.RemoveListFromList(libToolingFlags, ClangLibToolingUnknownCflags) } -func inListSorted(s string, list []string) bool { - for _, l := range list { - if s == l { - return true - } else if s < l { - return false - } - } - return false -} - func sorted(list []string) []string { sort.Strings(list) return list diff --git a/cc/config/global.go b/cc/config/global.go index 495776795..bcee06afa 100644 --- a/cc/config/global.go +++ b/cc/config/global.go @@ -36,7 +36,6 @@ var ( // Make paths in deps files relative "-no-canonical-prefixes", - "-fno-canonical-system-headers", "-DNDEBUG", "-UDEBUG", @@ -61,8 +60,6 @@ var ( commonGlobalConlyflags = []string{} deviceGlobalCflags = []string{ - "-fdiagnostics-color", - "-ffunction-sections", "-fdata-sections", "-fno-short-enums", @@ -78,6 +75,7 @@ var ( "-Werror=address", "-Werror=sequence-point", "-Werror=format-security", + "-nostdlibinc", } deviceGlobalCppflags = []string{ @@ -101,7 +99,7 @@ var ( "-Wl,--icf=safe", } - deviceGlobalLldflags = append(ClangFilterUnknownLldflags(deviceGlobalLdflags), + deviceGlobalLldflags = append(deviceGlobalLdflags, []string{ "-fuse-ld=lld", }...) @@ -116,6 +114,15 @@ var ( commonGlobalCppflags = []string{ "-Wsign-promo", + + // -Wimplicit-fallthrough is not enabled by -Wall. + "-Wimplicit-fallthrough", + + // Enable clang's thread-safety annotations in libcxx. + "-D_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS", + + // libc++'s math.h has an #include_next outside of system_headers. + "-Wno-gnu-include-next", } noOverrideGlobalCflags = []string{ @@ -133,6 +140,66 @@ var ( // http://b/161386391 for -Wno-pointer-to-int-cast "-Wno-pointer-to-int-cast", "-Werror=fortify-source", + + "-Werror=address-of-temporary", + // Bug: http://b/29823425 Disable -Wnull-dereference until the + // new cases detected by this warning in Clang r271374 are + // fixed. + //"-Werror=null-dereference", + "-Werror=return-type", + + // http://b/72331526 Disable -Wtautological-* until the instances detected by these + // new warnings are fixed. + "-Wno-tautological-constant-compare", + "-Wno-tautological-type-limit-compare", + // http://b/145210666 + "-Wno-reorder-init-list", + // http://b/145211066 + "-Wno-implicit-int-float-conversion", + // New warnings to be fixed after clang-r377782. + "-Wno-int-in-bool-context", // http://b/148287349 + "-Wno-sizeof-array-div", // http://b/148815709 + "-Wno-tautological-overlap-compare", // http://b/148815696 + // New warnings to be fixed after clang-r383902. + "-Wno-deprecated-copy", // http://b/153746672 + "-Wno-range-loop-construct", // http://b/153747076 + "-Wno-misleading-indentation", // http://b/153746954 + "-Wno-zero-as-null-pointer-constant", // http://b/68236239 + "-Wno-deprecated-anon-enum-enum-conversion", // http://b/153746485 + "-Wno-deprecated-enum-enum-conversion", // http://b/153746563 + "-Wno-string-compare", // http://b/153764102 + "-Wno-enum-enum-conversion", // http://b/154138986 + "-Wno-enum-float-conversion", // http://b/154255917 + "-Wno-pessimizing-move", // http://b/154270751 + // New warnings to be fixed after clang-r399163 + "-Wno-non-c-typedef-for-linkage", // http://b/161304145 + // New warnings to be fixed after clang-r407598 + "-Wno-string-concatenation", // http://b/175068488 + } + + // Extra cflags for external third-party projects to disable warnings that + // are infeasible to fix in all the external projects and their upstream repos. + extraExternalCflags = []string{ + "-Wno-enum-compare", + "-Wno-enum-compare-switch", + + // http://b/72331524 Allow null pointer arithmetic until the instances detected by + // this new warning are fixed. + "-Wno-null-pointer-arithmetic", + + // Bug: http://b/29823425 Disable -Wnull-dereference until the + // new instances detected by this warning are fixed. + "-Wno-null-dereference", + + // http://b/145211477 + "-Wno-pointer-compare", + // http://b/145211022 + "-Wno-xor-used-as-pow", + // http://b/145211022 + "-Wno-final-dtor-non-final-class", + + // http://b/165945989 + "-Wno-psabi", } IllegalFlags = []string{ @@ -174,20 +241,20 @@ func init() { exportStringListStaticVariable("HostGlobalLdflags", hostGlobalLdflags) exportStringListStaticVariable("HostGlobalLldflags", hostGlobalLldflags) - // Export the static default CommonClangGlobalCflags to Bazel. + // Export the static default CommonGlobalCflags to Bazel. // TODO(187086342): handle cflags that are set in VariableFuncs. - commonClangGlobalCFlags := append( - ClangFilterUnknownCflags(commonGlobalCflags), + bazelCommonGlobalCflags := append( + commonGlobalCflags, []string{ "${ClangExtraCflags}", // Default to zero initialization. "-ftrivial-auto-var-init=zero", "-enable-trivial-auto-var-init-zero-knowing-it-will-be-removed-from-clang", }...) - exportedStringListVars.Set("CommonClangGlobalCflags", commonClangGlobalCFlags) + exportedStringListVars.Set("CommonGlobalCflags", bazelCommonGlobalCflags) - pctx.VariableFunc("CommonClangGlobalCflags", func(ctx android.PackageVarContext) string { - flags := ClangFilterUnknownCflags(commonGlobalCflags) + pctx.VariableFunc("CommonGlobalCflags", func(ctx android.PackageVarContext) string { + flags := commonGlobalCflags flags = append(flags, "${ClangExtraCflags}") // http://b/131390872 @@ -206,23 +273,18 @@ func init() { return strings.Join(flags, " ") }) - // Export the static default DeviceClangGlobalCflags to Bazel. + // Export the static default DeviceGlobalCflags to Bazel. // TODO(187086342): handle cflags that are set in VariableFuncs. - deviceClangGlobalCflags := append(ClangFilterUnknownCflags(deviceGlobalCflags), "${ClangExtraTargetCflags}") - exportedStringListVars.Set("DeviceClangGlobalCflags", deviceClangGlobalCflags) + exportedStringListVars.Set("DeviceGlobalCflags", deviceGlobalCflags) - pctx.VariableFunc("DeviceClangGlobalCflags", func(ctx android.PackageVarContext) string { - if ctx.Config().Fuchsia() { - return strings.Join(ClangFilterUnknownCflags(deviceGlobalCflags), " ") - } else { - return strings.Join(deviceClangGlobalCflags, " ") - } + pctx.VariableFunc("DeviceGlobalCflags", func(ctx android.PackageVarContext) string { + return strings.Join(deviceGlobalCflags, " ") }) - exportStringListStaticVariable("HostClangGlobalCflags", ClangFilterUnknownCflags(hostGlobalCflags)) - exportStringListStaticVariable("NoOverrideClangGlobalCflags", append(ClangFilterUnknownCflags(noOverrideGlobalCflags), "${ClangExtraNoOverrideCflags}")) - exportStringListStaticVariable("CommonClangGlobalCppflags", append(ClangFilterUnknownCflags(commonGlobalCppflags), "${ClangExtraCppflags}")) - exportStringListStaticVariable("ClangExternalCflags", []string{"${ClangExtraExternalCflags}"}) + exportStringListStaticVariable("HostGlobalCflags", hostGlobalCflags) + exportStringListStaticVariable("NoOverrideGlobalCflags", noOverrideGlobalCflags) + exportStringListStaticVariable("CommonGlobalCppflags", commonGlobalCppflags) + exportStringListStaticVariable("ExternalCflags", extraExternalCflags) // Everything in these lists is a crime against abstraction and dependency tracking. // Do not add anything to this list. diff --git a/cc/config/toolchain.go b/cc/config/toolchain.go index ab09751ac..ff556f179 100644 --- a/cc/config/toolchain.go +++ b/cc/config/toolchain.go @@ -82,14 +82,14 @@ type Toolchain interface { IncludeFlags() string ClangTriple() string - ToolchainClangCflags() string - ToolchainClangLdflags() string - ClangAsflags() string - ClangCflags() string - ClangCppflags() string - ClangLdflags() string - ClangLldflags() string - ClangInstructionSetFlags(string) (string, error) + ToolchainCflags() string + ToolchainLdflags() string + Asflags() string + Cflags() string + Cppflags() string + Ldflags() string + Lldflags() string + InstructionSetFlags(string) (string, error) ndkTriple() string @@ -136,18 +136,18 @@ func NDKTriple(toolchain Toolchain) string { return triple } -func (toolchainBase) ClangInstructionSetFlags(s string) (string, error) { +func (toolchainBase) InstructionSetFlags(s string) (string, error) { if s != "" { return "", fmt.Errorf("instruction_set: %s is not a supported instruction set", s) } return "", nil } -func (toolchainBase) ToolchainClangCflags() string { +func (toolchainBase) ToolchainCflags() string { return "" } -func (toolchainBase) ToolchainClangLdflags() string { +func (toolchainBase) ToolchainLdflags() string { return "" } @@ -159,7 +159,7 @@ func (toolchainBase) ExecutableSuffix() string { return "" } -func (toolchainBase) ClangAsflags() string { +func (toolchainBase) Asflags() string { return "" } diff --git a/cc/config/x86_64_device.go b/cc/config/x86_64_device.go index 54dc6d523..c4f47a724 100644 --- a/cc/config/x86_64_device.go +++ b/cc/config/x86_64_device.go @@ -32,8 +32,6 @@ var ( "-Wl,--hash-style=gnu", } - x86_64Lldflags = ClangFilterUnknownLldflags(x86_64Ldflags) - x86_64ArchVariantCflags = map[string][]string{ "": []string{ "-march=x86-64", @@ -102,13 +100,11 @@ func init() { pctx.StaticVariable("X86_64ToolchainLdflags", "-m64") pctx.StaticVariable("X86_64Ldflags", strings.Join(x86_64Ldflags, " ")) - pctx.StaticVariable("X86_64Lldflags", strings.Join(x86_64Lldflags, " ")) + pctx.StaticVariable("X86_64Lldflags", strings.Join(x86_64Ldflags, " ")) // Clang cflags - pctx.StaticVariable("X86_64ClangCflags", strings.Join(ClangFilterUnknownCflags(x86_64Cflags), " ")) - pctx.StaticVariable("X86_64ClangLdflags", strings.Join(ClangFilterUnknownCflags(x86_64Ldflags), " ")) - pctx.StaticVariable("X86_64ClangLldflags", strings.Join(ClangFilterUnknownCflags(x86_64Lldflags), " ")) - pctx.StaticVariable("X86_64ClangCppflags", strings.Join(ClangFilterUnknownCflags(x86_64Cppflags), " ")) + pctx.StaticVariable("X86_64Cflags", strings.Join(x86_64Cflags, " ")) + pctx.StaticVariable("X86_64Cppflags", strings.Join(x86_64Cppflags, " ")) // Yasm flags pctx.StaticVariable("X86_64YasmFlags", "-f elf64 -m amd64") @@ -117,15 +113,15 @@ func init() { // Architecture variant cflags for variant, cflags := range x86_64ArchVariantCflags { - pctx.StaticVariable("X86_64"+variant+"VariantClangCflags", - strings.Join(ClangFilterUnknownCflags(cflags), " ")) + pctx.StaticVariable("X86_64"+variant+"VariantCflags", + strings.Join(cflags, " ")) } } type toolchainX86_64 struct { toolchainBionic toolchain64Bit - toolchainClangCflags string + toolchainCflags string } func (t *toolchainX86_64) Name() string { @@ -152,27 +148,27 @@ func (t *toolchainX86_64) ClangTriple() string { return t.GccTriple() } -func (t *toolchainX86_64) ToolchainClangLdflags() string { +func (t *toolchainX86_64) ToolchainLdflags() string { return "${config.X86_64ToolchainLdflags}" } -func (t *toolchainX86_64) ToolchainClangCflags() string { - return t.toolchainClangCflags +func (t *toolchainX86_64) ToolchainCflags() string { + return t.toolchainCflags } -func (t *toolchainX86_64) ClangCflags() string { - return "${config.X86_64ClangCflags}" +func (t *toolchainX86_64) Cflags() string { + return "${config.X86_64Cflags}" } -func (t *toolchainX86_64) ClangCppflags() string { - return "${config.X86_64ClangCppflags}" +func (t *toolchainX86_64) Cppflags() string { + return "${config.X86_64Cppflags}" } -func (t *toolchainX86_64) ClangLdflags() string { +func (t *toolchainX86_64) Ldflags() string { return "${config.X86_64Ldflags}" } -func (t *toolchainX86_64) ClangLldflags() string { +func (t *toolchainX86_64) Lldflags() string { return "${config.X86_64Lldflags}" } @@ -185,17 +181,17 @@ func (toolchainX86_64) LibclangRuntimeLibraryArch() string { } func x86_64ToolchainFactory(arch android.Arch) Toolchain { - toolchainClangCflags := []string{ + toolchainCflags := []string{ "${config.X86_64ToolchainCflags}", - "${config.X86_64" + arch.ArchVariant + "VariantClangCflags}", + "${config.X86_64" + arch.ArchVariant + "VariantCflags}", } for _, feature := range arch.ArchFeatures { - toolchainClangCflags = append(toolchainClangCflags, x86_64ArchFeatureCflags[feature]...) + toolchainCflags = append(toolchainCflags, x86_64ArchFeatureCflags[feature]...) } return &toolchainX86_64{ - toolchainClangCflags: strings.Join(toolchainClangCflags, " "), + toolchainCflags: strings.Join(toolchainCflags, " "), } } diff --git a/cc/config/x86_64_fuchsia_device.go b/cc/config/x86_64_fuchsia_device.go index d6837c8b4..86558a6cc 100644 --- a/cc/config/x86_64_fuchsia_device.go +++ b/cc/config/x86_64_fuchsia_device.go @@ -46,18 +46,6 @@ func (t *toolchainFuchsiaX8664) GccVersion() string { return x86_64GccVersion } -func (t *toolchainFuchsiaX8664) Cflags() string { - return "" -} - -func (t *toolchainFuchsiaX8664) Cppflags() string { - return "" -} - -func (t *toolchainFuchsiaX8664) Ldflags() string { - return "" -} - func (t *toolchainFuchsiaX8664) IncludeFlags() string { return "" } @@ -66,20 +54,20 @@ func (t *toolchainFuchsiaX8664) ClangTriple() string { return "x86_64-fuchsia-android" } -func (t *toolchainFuchsiaX8664) ClangCppflags() string { +func (t *toolchainFuchsiaX8664) Cppflags() string { return "-Wno-error=deprecated-declarations" } -func (t *toolchainFuchsiaX8664) ClangLdflags() string { +func (t *toolchainFuchsiaX8664) Ldflags() string { return "--target=x86_64-fuchsia --sysroot=" + fuchsiaSysRoot + " -L" + fuchsiaPrebuiltLibsRoot + "/x86_64-fuchsia/lib " + "-Lprebuilts/fuchsia_sdk/arch/x64/dist/" } -func (t *toolchainFuchsiaX8664) ClangLldflags() string { +func (t *toolchainFuchsiaX8664) Lldflags() string { return "--target=x86_64-fuchsia --sysroot=" + fuchsiaSysRoot + " -L" + fuchsiaPrebuiltLibsRoot + "/x86_64-fuchsia/lib " + "-Lprebuilts/fuchsia_sdk/arch/x64/dist/" } -func (t *toolchainFuchsiaX8664) ClangCflags() string { +func (t *toolchainFuchsiaX8664) Cflags() string { return "--target=x86_64-fuchsia --sysroot=" + fuchsiaSysRoot + " -I" + fuchsiaSysRoot + "/include" } @@ -87,7 +75,7 @@ func (t *toolchainFuchsiaX8664) YasmFlags() string { return "-f elf64 -m amd64" } -func (t *toolchainFuchsiaX8664) ToolchainClangCflags() string { +func (t *toolchainFuchsiaX8664) ToolchainCflags() string { return "-mssse3" } diff --git a/cc/config/x86_darwin_host.go b/cc/config/x86_darwin_host.go index 4e3e2a69d..d8e70e1e7 100644 --- a/cc/config/x86_darwin_host.go +++ b/cc/config/x86_darwin_host.go @@ -26,8 +26,6 @@ import ( var ( darwinCflags = []string{ - "-fdiagnostics-color", - "-fPIC", "-funwind-tables", @@ -41,6 +39,9 @@ var ( "-DMACOSX_DEPLOYMENT_TARGET=${macMinVersion}", "-m64", + + "-integrated-as", + "-fstack-protector-strong", } darwinLdflags = []string{ @@ -50,15 +51,6 @@ var ( "-m64", } - darwinClangCflags = append(ClangFilterUnknownCflags(darwinCflags), []string{ - "-integrated-as", - "-fstack-protector-strong", - }...) - - darwinClangLdflags = ClangFilterUnknownCflags(darwinLdflags) - - darwinClangLldflags = ClangFilterUnknownLldflags(darwinClangLdflags) - darwinSupportedSdkVersions = []string{ "10.10", "10.11", @@ -115,9 +107,9 @@ func init() { pctx.StaticVariable("DarwinGccTriple", "i686-apple-darwin11") - pctx.StaticVariable("DarwinClangCflags", strings.Join(darwinClangCflags, " ")) - pctx.StaticVariable("DarwinClangLdflags", strings.Join(darwinClangLdflags, " ")) - pctx.StaticVariable("DarwinClangLldflags", strings.Join(darwinClangLldflags, " ")) + pctx.StaticVariable("DarwinCflags", strings.Join(darwinCflags, " ")) + pctx.StaticVariable("DarwinLdflags", strings.Join(darwinLdflags, " ")) + pctx.StaticVariable("DarwinLldflags", strings.Join(darwinLdflags, " ")) pctx.StaticVariable("DarwinYasmFlags", "-f macho -m amd64") } @@ -213,20 +205,20 @@ func (t *toolchainDarwin) ClangTriple() string { return "x86_64-apple-darwin" } -func (t *toolchainDarwin) ClangCflags() string { - return "${config.DarwinClangCflags}" +func (t *toolchainDarwin) Cflags() string { + return "${config.DarwinCflags}" } -func (t *toolchainDarwin) ClangCppflags() string { +func (t *toolchainDarwin) Cppflags() string { return "" } -func (t *toolchainDarwin) ClangLdflags() string { - return "${config.DarwinClangLdflags}" +func (t *toolchainDarwin) Ldflags() string { + return "${config.DarwinLdflags}" } -func (t *toolchainDarwin) ClangLldflags() string { - return "${config.DarwinClangLldflags}" +func (t *toolchainDarwin) Lldflags() string { + return "${config.DarwinLldflags}" } func (t *toolchainDarwin) YasmFlags() string { diff --git a/cc/config/x86_device.go b/cc/config/x86_device.go index 1507d9813..5e510a494 100644 --- a/cc/config/x86_device.go +++ b/cc/config/x86_device.go @@ -21,16 +21,14 @@ import ( ) var ( - x86Cflags = []string{} - - x86ClangCflags = append(x86Cflags, []string{ + x86Cflags = []string{ "-msse3", // -mstackrealign is needed to realign stack in native code // that could be called from JNI, so that movaps instruction // will work on assumed stack aligned local variables. "-mstackrealign", - }...) + } x86Cppflags = []string{} @@ -38,8 +36,6 @@ var ( "-Wl,--hash-style=gnu", } - x86Lldflags = ClangFilterUnknownLldflags(x86Ldflags) - x86ArchVariantCflags = map[string][]string{ "": []string{ "-march=prescott", @@ -49,35 +45,27 @@ var ( }, "atom": []string{ "-march=atom", - "-mfpmath=sse", }, "broadwell": []string{ "-march=broadwell", - "-mfpmath=sse", }, "haswell": []string{ "-march=core-avx2", - "-mfpmath=sse", }, "ivybridge": []string{ "-march=core-avx-i", - "-mfpmath=sse", }, "sandybridge": []string{ "-march=corei7", - "-mfpmath=sse", }, "silvermont": []string{ "-march=slm", - "-mfpmath=sse", }, "skylake": []string{ "-march=skylake", - "-mfpmath=sse", }, "stoneyridge": []string{ "-march=bdver4", - "-mfpmath=sse", }, } @@ -113,13 +101,11 @@ func init() { pctx.StaticVariable("X86ToolchainLdflags", "-m32") pctx.StaticVariable("X86Ldflags", strings.Join(x86Ldflags, " ")) - pctx.StaticVariable("X86Lldflags", strings.Join(x86Lldflags, " ")) + pctx.StaticVariable("X86Lldflags", strings.Join(x86Ldflags, " ")) // Clang cflags - pctx.StaticVariable("X86ClangCflags", strings.Join(ClangFilterUnknownCflags(x86ClangCflags), " ")) - pctx.StaticVariable("X86ClangLdflags", strings.Join(ClangFilterUnknownCflags(x86Ldflags), " ")) - pctx.StaticVariable("X86ClangLldflags", strings.Join(ClangFilterUnknownCflags(x86Lldflags), " ")) - pctx.StaticVariable("X86ClangCppflags", strings.Join(ClangFilterUnknownCflags(x86Cppflags), " ")) + pctx.StaticVariable("X86Cflags", strings.Join(x86Cflags, " ")) + pctx.StaticVariable("X86Cppflags", strings.Join(x86Cppflags, " ")) // Yasm flags pctx.StaticVariable("X86YasmFlags", "-f elf32 -m x86") @@ -128,15 +114,15 @@ func init() { // Architecture variant cflags for variant, cflags := range x86ArchVariantCflags { - pctx.StaticVariable("X86"+variant+"VariantClangCflags", - strings.Join(ClangFilterUnknownCflags(cflags), " ")) + pctx.StaticVariable("X86"+variant+"VariantCflags", + strings.Join(cflags, " ")) } } type toolchainX86 struct { toolchainBionic toolchain32Bit - toolchainClangCflags string + toolchainCflags string } func (t *toolchainX86) Name() string { @@ -163,27 +149,27 @@ func (t *toolchainX86) ClangTriple() string { return "i686-linux-android" } -func (t *toolchainX86) ToolchainClangLdflags() string { +func (t *toolchainX86) ToolchainLdflags() string { return "${config.X86ToolchainLdflags}" } -func (t *toolchainX86) ToolchainClangCflags() string { - return t.toolchainClangCflags +func (t *toolchainX86) ToolchainCflags() string { + return t.toolchainCflags } -func (t *toolchainX86) ClangCflags() string { - return "${config.X86ClangCflags}" +func (t *toolchainX86) Cflags() string { + return "${config.X86Cflags}" } -func (t *toolchainX86) ClangCppflags() string { - return "${config.X86ClangCppflags}" +func (t *toolchainX86) Cppflags() string { + return "${config.X86Cppflags}" } -func (t *toolchainX86) ClangLdflags() string { +func (t *toolchainX86) Ldflags() string { return "${config.X86Ldflags}" } -func (t *toolchainX86) ClangLldflags() string { +func (t *toolchainX86) Lldflags() string { return "${config.X86Lldflags}" } @@ -196,17 +182,17 @@ func (toolchainX86) LibclangRuntimeLibraryArch() string { } func x86ToolchainFactory(arch android.Arch) Toolchain { - toolchainClangCflags := []string{ + toolchainCflags := []string{ "${config.X86ToolchainCflags}", - "${config.X86" + arch.ArchVariant + "VariantClangCflags}", + "${config.X86" + arch.ArchVariant + "VariantCflags}", } for _, feature := range arch.ArchFeatures { - toolchainClangCflags = append(toolchainClangCflags, x86ArchFeatureCflags[feature]...) + toolchainCflags = append(toolchainCflags, x86ArchFeatureCflags[feature]...) } return &toolchainX86{ - toolchainClangCflags: strings.Join(toolchainClangCflags, " "), + toolchainCflags: strings.Join(toolchainCflags, " "), } } diff --git a/cc/config/x86_linux_bionic_host.go b/cc/config/x86_linux_bionic_host.go index e7e5f2dab..4b7ba6a85 100644 --- a/cc/config/x86_linux_bionic_host.go +++ b/cc/config/x86_linux_bionic_host.go @@ -21,9 +21,7 @@ import ( ) var ( - linuxBionicCflags = ClangFilterUnknownCflags([]string{ - "-fdiagnostics-color", - + linuxBionicCflags = []string{ "-Wa,--noexecstack", "-fPIC", @@ -34,21 +32,17 @@ var ( // From x86_64_device "-ffunction-sections", - "-finline-functions", - "-finline-limit=300", "-fno-short-enums", - "-funswitch-loops", "-funwind-tables", - "-fno-canonical-system-headers", // Tell clang where the gcc toolchain is "--gcc-toolchain=${LinuxBionicGccRoot}", // This is normally in ClangExtraTargetCflags, but this is considered host "-nostdlibinc", - }) + } - linuxBionicLdflags = ClangFilterUnknownCflags([]string{ + linuxBionicLdflags = []string{ "-Wl,-z,noexecstack", "-Wl,-z,relro", "-Wl,-z,now", @@ -60,9 +54,7 @@ var ( // Use the device gcc toolchain "--gcc-toolchain=${LinuxBionicGccRoot}", - }) - - linuxBionicLldflags = ClangFilterUnknownLldflags(linuxBionicLdflags) + } // Embed the linker into host bionic binaries. This is needed to support host bionic, // as the linux kernel requires that the ELF interpreter referenced by PT_INTERP be @@ -78,7 +70,7 @@ var ( func init() { pctx.StaticVariable("LinuxBionicCflags", strings.Join(linuxBionicCflags, " ")) pctx.StaticVariable("LinuxBionicLdflags", strings.Join(linuxBionicLdflags, " ")) - pctx.StaticVariable("LinuxBionicLldflags", strings.Join(linuxBionicLldflags, " ")) + pctx.StaticVariable("LinuxBionicLldflags", strings.Join(linuxBionicLdflags, " ")) // Use the device gcc toolchain for now pctx.StaticVariable("LinuxBionicGccRoot", "${X86_64GccRoot}") @@ -114,29 +106,29 @@ func (t *toolchainLinuxBionic) ClangTriple() string { return "x86_64-linux-android" } -func (t *toolchainLinuxBionic) ClangCflags() string { +func (t *toolchainLinuxBionic) Cflags() string { return "${config.LinuxBionicCflags}" } -func (t *toolchainLinuxBionic) ClangCppflags() string { +func (t *toolchainLinuxBionic) Cppflags() string { return "" } -func (t *toolchainLinuxBionic) ClangLdflags() string { +func (t *toolchainLinuxBionic) Ldflags() string { return "${config.LinuxBionicLdflags}" } -func (t *toolchainLinuxBionic) ClangLldflags() string { +func (t *toolchainLinuxBionic) Lldflags() string { return "${config.LinuxBionicLldflags}" } -func (t *toolchainLinuxBionic) ToolchainClangCflags() string { +func (t *toolchainLinuxBionic) ToolchainCflags() string { return "-m64 -march=x86-64" + // TODO: We're not really android, but we don't have a triple yet b/31393676 " -U__ANDROID__" } -func (t *toolchainLinuxBionic) ToolchainClangLdflags() string { +func (t *toolchainLinuxBionic) ToolchainLdflags() string { return "-m64" } diff --git a/cc/config/x86_linux_host.go b/cc/config/x86_linux_host.go index c406c885f..85d95d80f 100644 --- a/cc/config/x86_linux_host.go +++ b/cc/config/x86_linux_host.go @@ -22,8 +22,6 @@ import ( var ( linuxCflags = []string{ - "-fdiagnostics-color", - "-Wa,--noexecstack", "-fPIC", @@ -36,6 +34,10 @@ var ( //See bug 12708004. "-D__STDC_FORMAT_MACROS", "-D__STDC_CONSTANT_MACROS", + + "--gcc-toolchain=${LinuxGccRoot}", + "--sysroot ${LinuxGccRoot}/sysroot", + "-fstack-protector-strong", } linuxLdflags = []string{ @@ -43,12 +45,14 @@ var ( "-Wl,-z,relro", "-Wl,-z,now", "-Wl,--no-undefined-version", + + "--gcc-toolchain=${LinuxGccRoot}", + "--sysroot ${LinuxGccRoot}/sysroot", } // Extended cflags linuxX86Cflags = []string{ "-msse3", - "-mfpmath=sse", "-m32", "-march=prescott", "-D_FILE_OFFSET_BITS=64", @@ -61,40 +65,17 @@ var ( linuxX86Ldflags = []string{ "-m32", - } - - linuxX8664Ldflags = []string{ - "-m64", - } - - linuxClangCflags = append(ClangFilterUnknownCflags(linuxCflags), []string{ - "--gcc-toolchain=${LinuxGccRoot}", - "--sysroot ${LinuxGccRoot}/sysroot", - "-fstack-protector-strong", - }...) - - linuxClangLdflags = append(ClangFilterUnknownCflags(linuxLdflags), []string{ - "--gcc-toolchain=${LinuxGccRoot}", - "--sysroot ${LinuxGccRoot}/sysroot", - }...) - - linuxClangLldflags = ClangFilterUnknownLldflags(linuxClangLdflags) - - linuxX86ClangLdflags = append(ClangFilterUnknownCflags(linuxX86Ldflags), []string{ "-B${LinuxGccRoot}/lib/gcc/${LinuxGccTriple}/${LinuxGccVersion}/32", "-L${LinuxGccRoot}/lib/gcc/${LinuxGccTriple}/${LinuxGccVersion}/32", "-L${LinuxGccRoot}/${LinuxGccTriple}/lib32", - }...) - - linuxX86ClangLldflags = ClangFilterUnknownLldflags(linuxX86ClangLdflags) + } - linuxX8664ClangLdflags = append(ClangFilterUnknownCflags(linuxX8664Ldflags), []string{ + linuxX8664Ldflags = []string{ + "-m64", "-B${LinuxGccRoot}/lib/gcc/${LinuxGccTriple}/${LinuxGccVersion}", "-L${LinuxGccRoot}/lib/gcc/${LinuxGccTriple}/${LinuxGccVersion}", "-L${LinuxGccRoot}/${LinuxGccTriple}/lib64", - }...) - - linuxX8664ClangLldflags = ClangFilterUnknownLldflags(linuxX8664ClangLdflags) + } linuxAvailableLibraries = addPrefix([]string{ "c", @@ -130,18 +111,16 @@ func init() { pctx.StaticVariable("LinuxGccTriple", "x86_64-linux") - pctx.StaticVariable("LinuxClangCflags", strings.Join(linuxClangCflags, " ")) - pctx.StaticVariable("LinuxClangLdflags", strings.Join(linuxClangLdflags, " ")) - pctx.StaticVariable("LinuxClangLldflags", strings.Join(linuxClangLldflags, " ")) - - pctx.StaticVariable("LinuxX86ClangCflags", - strings.Join(ClangFilterUnknownCflags(linuxX86Cflags), " ")) - pctx.StaticVariable("LinuxX8664ClangCflags", - strings.Join(ClangFilterUnknownCflags(linuxX8664Cflags), " ")) - pctx.StaticVariable("LinuxX86ClangLdflags", strings.Join(linuxX86ClangLdflags, " ")) - pctx.StaticVariable("LinuxX86ClangLldflags", strings.Join(linuxX86ClangLldflags, " ")) - pctx.StaticVariable("LinuxX8664ClangLdflags", strings.Join(linuxX8664ClangLdflags, " ")) - pctx.StaticVariable("LinuxX8664ClangLldflags", strings.Join(linuxX8664ClangLldflags, " ")) + pctx.StaticVariable("LinuxCflags", strings.Join(linuxCflags, " ")) + pctx.StaticVariable("LinuxLdflags", strings.Join(linuxLdflags, " ")) + pctx.StaticVariable("LinuxLldflags", strings.Join(linuxLdflags, " ")) + + pctx.StaticVariable("LinuxX86Cflags", strings.Join(linuxX86Cflags, " ")) + pctx.StaticVariable("LinuxX8664Cflags", strings.Join(linuxX8664Cflags, " ")) + pctx.StaticVariable("LinuxX86Ldflags", strings.Join(linuxX86Ldflags, " ")) + pctx.StaticVariable("LinuxX86Lldflags", strings.Join(linuxX86Ldflags, " ")) + pctx.StaticVariable("LinuxX8664Ldflags", strings.Join(linuxX8664Ldflags, " ")) + pctx.StaticVariable("LinuxX8664Lldflags", strings.Join(linuxX8664Ldflags, " ")) // Yasm flags pctx.StaticVariable("LinuxX86YasmFlags", "-f elf32 -m x86") pctx.StaticVariable("LinuxX8664YasmFlags", "-f elf64 -m amd64") @@ -189,11 +168,11 @@ func (t *toolchainLinuxX86) ClangTriple() string { return "i686-linux-gnu" } -func (t *toolchainLinuxX86) ClangCflags() string { - return "${config.LinuxClangCflags} ${config.LinuxX86ClangCflags}" +func (t *toolchainLinuxX86) Cflags() string { + return "${config.LinuxCflags} ${config.LinuxX86Cflags}" } -func (t *toolchainLinuxX86) ClangCppflags() string { +func (t *toolchainLinuxX86) Cppflags() string { return "" } @@ -201,28 +180,28 @@ func (t *toolchainLinuxX8664) ClangTriple() string { return "x86_64-linux-gnu" } -func (t *toolchainLinuxX8664) ClangCflags() string { - return "${config.LinuxClangCflags} ${config.LinuxX8664ClangCflags}" +func (t *toolchainLinuxX8664) Cflags() string { + return "${config.LinuxCflags} ${config.LinuxX8664Cflags}" } -func (t *toolchainLinuxX8664) ClangCppflags() string { +func (t *toolchainLinuxX8664) Cppflags() string { return "" } -func (t *toolchainLinuxX86) ClangLdflags() string { - return "${config.LinuxClangLdflags} ${config.LinuxX86ClangLdflags}" +func (t *toolchainLinuxX86) Ldflags() string { + return "${config.LinuxLdflags} ${config.LinuxX86Ldflags}" } -func (t *toolchainLinuxX86) ClangLldflags() string { - return "${config.LinuxClangLldflags} ${config.LinuxX86ClangLldflags}" +func (t *toolchainLinuxX86) Lldflags() string { + return "${config.LinuxLldflags} ${config.LinuxX86Lldflags}" } -func (t *toolchainLinuxX8664) ClangLdflags() string { - return "${config.LinuxClangLdflags} ${config.LinuxX8664ClangLdflags}" +func (t *toolchainLinuxX8664) Ldflags() string { + return "${config.LinuxLdflags} ${config.LinuxX8664Ldflags}" } -func (t *toolchainLinuxX8664) ClangLldflags() string { - return "${config.LinuxClangLldflags} ${config.LinuxX8664ClangLldflags}" +func (t *toolchainLinuxX8664) Lldflags() string { + return "${config.LinuxLldflags} ${config.LinuxX8664Lldflags}" } func (t *toolchainLinuxX86) YasmFlags() string { diff --git a/cc/config/x86_windows_host.go b/cc/config/x86_windows_host.go index b77df7906..d9a7537f3 100644 --- a/cc/config/x86_windows_host.go +++ b/cc/config/x86_windows_host.go @@ -44,32 +44,28 @@ var ( "--sysroot ${WindowsGccRoot}/${WindowsGccTriple}", } - windowsClangCflags = append(ClangFilterUnknownCflags(windowsCflags), []string{}...) windowsIncludeFlags = []string{ "-isystem ${WindowsGccRoot}/${WindowsGccTriple}/include", } - windowsClangCppflags = []string{} + windowsCppflags = []string{} - windowsX86ClangCppflags = []string{ + windowsX86Cppflags = []string{ // Use SjLj exceptions for 32-bit. libgcc_eh implements SjLj // exception model for 32-bit. "-fsjlj-exceptions", } - windowsX8664ClangCppflags = []string{} + windowsX8664Cppflags = []string{} windowsLdflags = []string{ - "--enable-stdcall-fixup", "-Wl,--dynamicbase", "-Wl,--nxcompat", } - windowsLldflags = []string{ + windowsLldflags = append(windowsLdflags, []string{ "-Wl,--Xlink=-Brepro", // Enable deterministic build - } - windowsClangLdflags = append(ClangFilterUnknownCflags(windowsLdflags), []string{}...) - windowsClangLldflags = append(ClangFilterUnknownLldflags(windowsClangLdflags), windowsLldflags...) + }...) windowsX86Cflags = []string{ "-m32", @@ -84,28 +80,24 @@ var ( "-Wl,--large-address-aware", "-L${WindowsGccRoot}/${WindowsGccTriple}/lib32", "-static-libgcc", - } - windowsX86ClangLdflags = append(ClangFilterUnknownCflags(windowsX86Ldflags), []string{ + "-B${WindowsGccRoot}/${WindowsGccTriple}/bin", "-B${WindowsGccRoot}/lib/gcc/${WindowsGccTriple}/4.8.3/32", "-L${WindowsGccRoot}/lib/gcc/${WindowsGccTriple}/4.8.3/32", "-B${WindowsGccRoot}/${WindowsGccTriple}/lib32", - }...) - windowsX86ClangLldflags = ClangFilterUnknownLldflags(windowsX86ClangLdflags) + } windowsX8664Ldflags = []string{ "-m64", "-L${WindowsGccRoot}/${WindowsGccTriple}/lib64", "-Wl,--high-entropy-va", "-static-libgcc", - } - windowsX8664ClangLdflags = append(ClangFilterUnknownCflags(windowsX8664Ldflags), []string{ + "-B${WindowsGccRoot}/${WindowsGccTriple}/bin", "-B${WindowsGccRoot}/lib/gcc/${WindowsGccTriple}/4.8.3", "-L${WindowsGccRoot}/lib/gcc/${WindowsGccTriple}/4.8.3", "-B${WindowsGccRoot}/${WindowsGccTriple}/lib64", - }...) - windowsX8664ClangLldflags = ClangFilterUnknownLldflags(windowsX8664ClangLdflags) + } windowsAvailableLibraries = addPrefix([]string{ "gdi32", @@ -138,21 +130,19 @@ func init() { pctx.StaticVariable("WindowsGccTriple", "x86_64-w64-mingw32") - pctx.StaticVariable("WindowsClangCflags", strings.Join(windowsClangCflags, " ")) - pctx.StaticVariable("WindowsClangLdflags", strings.Join(windowsClangLdflags, " ")) - pctx.StaticVariable("WindowsClangLldflags", strings.Join(windowsClangLldflags, " ")) - pctx.StaticVariable("WindowsClangCppflags", strings.Join(windowsClangCppflags, " ")) - - pctx.StaticVariable("WindowsX86ClangCflags", - strings.Join(ClangFilterUnknownCflags(windowsX86Cflags), " ")) - pctx.StaticVariable("WindowsX8664ClangCflags", - strings.Join(ClangFilterUnknownCflags(windowsX8664Cflags), " ")) - pctx.StaticVariable("WindowsX86ClangLdflags", strings.Join(windowsX86ClangLdflags, " ")) - pctx.StaticVariable("WindowsX86ClangLldflags", strings.Join(windowsX86ClangLldflags, " ")) - pctx.StaticVariable("WindowsX8664ClangLdflags", strings.Join(windowsX8664ClangLdflags, " ")) - pctx.StaticVariable("WindowsX8664ClangLldflags", strings.Join(windowsX8664ClangLldflags, " ")) - pctx.StaticVariable("WindowsX86ClangCppflags", strings.Join(windowsX86ClangCppflags, " ")) - pctx.StaticVariable("WindowsX8664ClangCppflags", strings.Join(windowsX8664ClangCppflags, " ")) + pctx.StaticVariable("WindowsCflags", strings.Join(windowsCflags, " ")) + pctx.StaticVariable("WindowsLdflags", strings.Join(windowsLdflags, " ")) + pctx.StaticVariable("WindowsLldflags", strings.Join(windowsLldflags, " ")) + pctx.StaticVariable("WindowsCppflags", strings.Join(windowsCppflags, " ")) + + pctx.StaticVariable("WindowsX86Cflags", strings.Join(windowsX86Cflags, " ")) + pctx.StaticVariable("WindowsX8664Cflags", strings.Join(windowsX8664Cflags, " ")) + pctx.StaticVariable("WindowsX86Ldflags", strings.Join(windowsX86Ldflags, " ")) + pctx.StaticVariable("WindowsX86Lldflags", strings.Join(windowsX86Ldflags, " ")) + pctx.StaticVariable("WindowsX8664Ldflags", strings.Join(windowsX8664Ldflags, " ")) + pctx.StaticVariable("WindowsX8664Lldflags", strings.Join(windowsX8664Ldflags, " ")) + pctx.StaticVariable("WindowsX86Cppflags", strings.Join(windowsX86Cppflags, " ")) + pctx.StaticVariable("WindowsX8664Cppflags", strings.Join(windowsX8664Cppflags, " ")) pctx.StaticVariable("WindowsIncludeFlags", strings.Join(windowsIncludeFlags, " ")) // Yasm flags @@ -214,36 +204,36 @@ func (t *toolchainWindowsX8664) ClangTriple() string { return "x86_64-pc-windows-gnu" } -func (t *toolchainWindowsX86) ClangCflags() string { - return "${config.WindowsClangCflags} ${config.WindowsX86ClangCflags}" +func (t *toolchainWindowsX86) Cflags() string { + return "${config.WindowsCflags} ${config.WindowsX86Cflags}" } -func (t *toolchainWindowsX8664) ClangCflags() string { - return "${config.WindowsClangCflags} ${config.WindowsX8664ClangCflags}" +func (t *toolchainWindowsX8664) Cflags() string { + return "${config.WindowsCflags} ${config.WindowsX8664Cflags}" } -func (t *toolchainWindowsX86) ClangCppflags() string { - return "${config.WindowsClangCppflags} ${config.WindowsX86ClangCppflags}" +func (t *toolchainWindowsX86) Cppflags() string { + return "${config.WindowsCppflags} ${config.WindowsX86Cppflags}" } -func (t *toolchainWindowsX8664) ClangCppflags() string { - return "${config.WindowsClangCppflags} ${config.WindowsX8664ClangCppflags}" +func (t *toolchainWindowsX8664) Cppflags() string { + return "${config.WindowsCppflags} ${config.WindowsX8664Cppflags}" } -func (t *toolchainWindowsX86) ClangLdflags() string { - return "${config.WindowsClangLdflags} ${config.WindowsX86ClangLdflags}" +func (t *toolchainWindowsX86) Ldflags() string { + return "${config.WindowsLdflags} ${config.WindowsX86Ldflags}" } -func (t *toolchainWindowsX86) ClangLldflags() string { - return "${config.WindowsClangLldflags} ${config.WindowsX86ClangLldflags}" +func (t *toolchainWindowsX86) Lldflags() string { + return "${config.WindowsLldflags} ${config.WindowsX86Lldflags}" } -func (t *toolchainWindowsX8664) ClangLdflags() string { - return "${config.WindowsClangLdflags} ${config.WindowsX8664ClangLdflags}" +func (t *toolchainWindowsX8664) Ldflags() string { + return "${config.WindowsLdflags} ${config.WindowsX8664Ldflags}" } -func (t *toolchainWindowsX8664) ClangLldflags() string { - return "${config.WindowsClangLldflags} ${config.WindowsX8664ClangLldflags}" +func (t *toolchainWindowsX8664) Lldflags() string { + return "${config.WindowsLldflags} ${config.WindowsX8664Lldflags}" } func (t *toolchainWindowsX86) YasmFlags() string { diff --git a/cc/linker.go b/cc/linker.go index 13df23296..a712391c2 100644 --- a/cc/linker.go +++ b/cc/linker.go @@ -479,9 +479,9 @@ func (linker *baseLinker) linkerFlags(ctx ModuleContext, flags Flags) Flags { } if linker.useClangLld(ctx) { - flags.Global.LdFlags = append(flags.Global.LdFlags, toolchain.ClangLldflags()) + flags.Global.LdFlags = append(flags.Global.LdFlags, toolchain.Lldflags()) } else { - flags.Global.LdFlags = append(flags.Global.LdFlags, toolchain.ClangLdflags()) + flags.Global.LdFlags = append(flags.Global.LdFlags, toolchain.Ldflags()) } if !ctx.toolchain().Bionic() && !ctx.Fuchsia() { @@ -535,7 +535,7 @@ func (linker *baseLinker) linkerFlags(ctx ModuleContext, flags Flags) Flags { flags.Global.LdFlags = append(flags.Global.LdFlags, "-Wl,--hash-style=both") } - flags.Global.LdFlags = append(flags.Global.LdFlags, toolchain.ToolchainClangLdflags()) + flags.Global.LdFlags = append(flags.Global.LdFlags, toolchain.ToolchainLdflags()) if Bool(linker.Properties.Group_static_libs) { flags.GroupStaticLibs = true diff --git a/cc/makevars.go b/cc/makevars.go index 2b326ef4f..393170a81 100644 --- a/cc/makevars.go +++ b/cc/makevars.go @@ -92,8 +92,8 @@ func makeVarsProvider(ctx android.MakeVarsContext) { ctx.Strict("RS_LLVM_AS", "${config.RSLLVMPrebuiltsPath}/llvm-as") ctx.Strict("RS_LLVM_LINK", "${config.RSLLVMPrebuiltsPath}/llvm-link") - ctx.Strict("CLANG_EXTERNAL_CFLAGS", "${config.ClangExternalCflags}") - ctx.Strict("GLOBAL_CLANG_CFLAGS_NO_OVERRIDE", "${config.NoOverrideClangGlobalCflags}") + ctx.Strict("CLANG_EXTERNAL_CFLAGS", "${config.ExternalCflags}") + ctx.Strict("GLOBAL_CLANG_CFLAGS_NO_OVERRIDE", "${config.NoOverrideGlobalCflags}") ctx.Strict("GLOBAL_CLANG_CPPFLAGS_NO_OVERRIDE", "") ctx.Strict("BOARD_VNDK_VERSION", ctx.DeviceConfig().VndkVersion()) @@ -212,13 +212,13 @@ func makeVarsToolchain(ctx android.MakeVarsContext, secondPrefix string, ctx.StrictRaw(makePrefix+"C_SYSTEM_INCLUDES", strings.Join(systemIncludes, " ")) if target.Arch.ArchType == android.Arm { - flags, err := toolchain.ClangInstructionSetFlags("arm") + flags, err := toolchain.InstructionSetFlags("arm") if err != nil { panic(err) } ctx.Strict(makePrefix+"arm_CFLAGS", flags) - flags, err = toolchain.ClangInstructionSetFlags("thumb") + flags, err = toolchain.InstructionSetFlags("thumb") if err != nil { panic(err) } @@ -230,29 +230,29 @@ func makeVarsToolchain(ctx android.MakeVarsContext, secondPrefix string, ctx.Strict(clangPrefix+"TRIPLE", toolchain.ClangTriple()) ctx.Strict(clangPrefix+"GLOBAL_CFLAGS", strings.Join([]string{ - toolchain.ClangCflags(), - "${config.CommonClangGlobalCflags}", - fmt.Sprintf("${config.%sClangGlobalCflags}", hod), - toolchain.ToolchainClangCflags(), + toolchain.Cflags(), + "${config.CommonGlobalCflags}", + fmt.Sprintf("${config.%sGlobalCflags}", hod), + toolchain.ToolchainCflags(), clangExtras, productExtraCflags, }, " ")) ctx.Strict(clangPrefix+"GLOBAL_CPPFLAGS", strings.Join([]string{ - "${config.CommonClangGlobalCppflags}", + "${config.CommonGlobalCppflags}", fmt.Sprintf("${config.%sGlobalCppflags}", hod), - toolchain.ClangCppflags(), + toolchain.Cppflags(), }, " ")) ctx.Strict(clangPrefix+"GLOBAL_LDFLAGS", strings.Join([]string{ fmt.Sprintf("${config.%sGlobalLdflags}", hod), - toolchain.ClangLdflags(), - toolchain.ToolchainClangLdflags(), + toolchain.Ldflags(), + toolchain.ToolchainLdflags(), productExtraLdflags, clangExtras, }, " ")) ctx.Strict(clangPrefix+"GLOBAL_LLDFLAGS", strings.Join([]string{ fmt.Sprintf("${config.%sGlobalLldflags}", hod), - toolchain.ClangLldflags(), - toolchain.ToolchainClangLdflags(), + toolchain.Lldflags(), + toolchain.ToolchainLdflags(), productExtraLdflags, clangExtras, }, " ")) diff --git a/cc/object.go b/cc/object.go index 5ded0e94c..0f983c861 100644 --- a/cc/object.go +++ b/cc/object.go @@ -231,7 +231,7 @@ func (object *objectLinker) linkerDeps(ctx DepsContext, deps Deps) Deps { } func (object *objectLinker) linkerFlags(ctx ModuleContext, flags Flags) Flags { - flags.Global.LdFlags = append(flags.Global.LdFlags, ctx.toolchain().ToolchainClangLdflags()) + flags.Global.LdFlags = append(flags.Global.LdFlags, ctx.toolchain().ToolchainLdflags()) if lds := android.OptionalPathForModuleSrc(ctx, object.Properties.Linker_script); lds.Valid() { flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,-T,"+lds.String()) diff --git a/java/dexpreopt_bootjars.go b/java/dexpreopt_bootjars.go index 19c65cac7..dff9543e4 100644 --- a/java/dexpreopt_bootjars.go +++ b/java/dexpreopt_bootjars.go @@ -154,12 +154,23 @@ import ( // PRODUCT_BOOT_JARS_EXTRA variables. The AOSP makefiles specify some common Framework libraries, // but more product-specific libraries can be added in the product makefiles. // -// Each component of the PRODUCT_BOOT_JARS and PRODUCT_BOOT_JARS_EXTRA variables is either a simple -// name (if the library is a part of the Platform), or a colon-separated pair <apex, name> (if the -// library is a part of a non-updatable APEX). +// Each component of the PRODUCT_BOOT_JARS and PRODUCT_BOOT_JARS_EXTRA variables is a +// colon-separated pair <apex>:<library>, where <apex> is the variant name of a non-updatable APEX, +// "platform" if the library is a part of the platform in the system partition, or "system_ext" if +// it's in the system_ext partition. +// +// In these variables APEXes are identified by their "variant names", i.e. the names they get +// mounted as in /apex on device. In Soong modules that is the name set in the "apex_name" +// properties, which default to the "name" values. For example, many APEXes have both +// com.android.xxx and com.google.android.xxx modules in Soong, but take the same place +// /apex/com.android.xxx at runtime. In these cases the variant name is always com.android.xxx, +// regardless which APEX goes into the product. See also android.ApexInfo.ApexVariationName and +// apex.apexBundleProperties.Apex_name. // // A related variable PRODUCT_UPDATABLE_BOOT_JARS contains bootclasspath libraries that are in -// updatable APEXes. They are not included in the boot image. +// APEXes. They are not included in the boot image. The only exception here is core-icu4j.jar that +// has been historically part of the boot image and is now in a non updatable apex; it is treated +// as being part of PRODUCT_BOOT_JARS and is in the boot image. // // One exception to the above rules are "coverage" builds (a special build flavor which requires // setting environment variable EMMA_INSTRUMENT_FRAMEWORK=true). In coverage builds the Java code in diff --git a/java/java.go b/java/java.go index e74185ec5..bd059b563 100644 --- a/java/java.go +++ b/java/java.go @@ -580,6 +580,10 @@ type librarySdkMemberProperties struct { JarToExport android.Path `android:"arch_variant"` AidlIncludeDirs android.Paths + + // The list of permitted packages that need to be passed to the prebuilts as they are used to + // create the updatable-bcp-packages.txt file. + PermittedPackages []string } func (p *librarySdkMemberProperties) PopulateFromVariant(ctx android.SdkMemberContext, variant android.Module) { @@ -588,6 +592,8 @@ func (p *librarySdkMemberProperties) PopulateFromVariant(ctx android.SdkMemberCo p.JarToExport = ctx.MemberType().(*librarySdkMemberType).jarToExportGetter(ctx, j) p.AidlIncludeDirs = j.AidlIncludeDirs() + + p.PermittedPackages = j.PermittedPackagesForUpdatableBootJars() } func (p *librarySdkMemberProperties) AddToPropertySet(ctx android.SdkMemberContext, propertySet android.BpPropertySet) { @@ -606,6 +612,10 @@ func (p *librarySdkMemberProperties) AddToPropertySet(ctx android.SdkMemberConte propertySet.AddProperty("jars", []string{snapshotRelativeJavaLibPath}) } + if len(p.PermittedPackages) > 0 { + propertySet.AddProperty("permitted_packages", p.PermittedPackages) + } + // Do not copy anything else to the snapshot. if memberType.onlyCopyJarToSnapshot { return @@ -1126,6 +1136,10 @@ type ImportProperties struct { Installable *bool + // If not empty, classes are restricted to the specified packages and their sub-packages. + // This information is used to generate the updatable-bcp-packages.txt file. + Permitted_packages []string + // List of shared java libs that this module has dependencies to Libs []string @@ -1178,6 +1192,12 @@ type Import struct { minSdkVersion android.SdkSpec } +var _ PermittedPackagesForUpdatableBootJars = (*Import)(nil) + +func (j *Import) PermittedPackagesForUpdatableBootJars() []string { + return j.properties.Permitted_packages +} + func (j *Import) SdkVersion(ctx android.EarlyModuleContext) android.SdkSpec { return android.SdkSpecFrom(ctx, String(j.properties.Sdk_version)) } diff --git a/java/sdk_library.go b/java/sdk_library.go index 2b7185759..d1b4a4727 100644 --- a/java/sdk_library.go +++ b/java/sdk_library.go @@ -1897,6 +1897,10 @@ type sdkLibraryImportProperties struct { // If set to true, compile dex files for the stubs. Defaults to false. Compile_dex *bool + + // If not empty, classes are restricted to the specified packages and their sub-packages. + // This information is used to generate the updatable-bcp-packages.txt file. + Permitted_packages []string } type SdkLibraryImport struct { @@ -1995,6 +1999,12 @@ func sdkLibraryImportFactory() android.Module { return module } +var _ PermittedPackagesForUpdatableBootJars = (*SdkLibraryImport)(nil) + +func (module *SdkLibraryImport) PermittedPackagesForUpdatableBootJars() []string { + return module.properties.Permitted_packages +} + func (module *SdkLibraryImport) Prebuilt() *android.Prebuilt { return &module.prebuilt } @@ -2510,6 +2520,8 @@ type sdkLibrarySdkMemberProperties struct { // The paths to the doctag files to add to the prebuilt. Doctag_paths android.Paths + + Permitted_packages []string } type scopeProperties struct { @@ -2550,6 +2562,7 @@ func (s *sdkLibrarySdkMemberProperties) PopulateFromVariant(ctx android.SdkMembe s.Shared_library = proptools.BoolPtr(sdk.sharedLibrary()) s.Compile_dex = sdk.dexProperties.Compile_dex s.Doctag_paths = sdk.doctagPaths + s.Permitted_packages = sdk.PermittedPackagesForUpdatableBootJars() } func (s *sdkLibrarySdkMemberProperties) AddToPropertySet(ctx android.SdkMemberContext, propertySet android.BpPropertySet) { @@ -2562,6 +2575,9 @@ func (s *sdkLibrarySdkMemberProperties) AddToPropertySet(ctx android.SdkMemberCo if s.Compile_dex != nil { propertySet.AddProperty("compile_dex", *s.Compile_dex) } + if len(s.Permitted_packages) > 0 { + propertySet.AddProperty("permitted_packages", s.Permitted_packages) + } for _, apiScope := range allApiScopes { if properties, ok := s.Scopes[apiScope]; ok { diff --git a/rust/bindgen.go b/rust/bindgen.go index f9e6cd0a3..3470e51fe 100644 --- a/rust/bindgen.go +++ b/rust/bindgen.go @@ -137,15 +137,15 @@ func (b *bindgenDecorator) GenerateSource(ctx ModuleContext, deps PathDeps) andr implicits = append(implicits, deps.depGeneratedHeaders...) // Default clang flags - cflags = append(cflags, "${cc_config.CommonClangGlobalCflags}") + cflags = append(cflags, "${cc_config.CommonGlobalCflags}") if ctx.Device() { - cflags = append(cflags, "${cc_config.DeviceClangGlobalCflags}") + cflags = append(cflags, "${cc_config.DeviceGlobalCflags}") } // Toolchain clang flags cflags = append(cflags, "-target "+ccToolchain.ClangTriple()) - cflags = append(cflags, strings.ReplaceAll(ccToolchain.ClangCflags(), "${config.", "${cc_config.")) - cflags = append(cflags, strings.ReplaceAll(ccToolchain.ToolchainClangCflags(), "${config.", "${cc_config.")) + cflags = append(cflags, strings.ReplaceAll(ccToolchain.Cflags(), "${config.", "${cc_config.")) + cflags = append(cflags, strings.ReplaceAll(ccToolchain.ToolchainCflags(), "${config.", "${cc_config.")) // Dependency clang flags and include paths cflags = append(cflags, deps.depClangFlags...) diff --git a/rust/config/x86_darwin_host.go b/rust/config/x86_darwin_host.go index ddd93e889..8ff0dd4be 100644 --- a/rust/config/x86_darwin_host.go +++ b/rust/config/x86_darwin_host.go @@ -78,7 +78,7 @@ func (t *toolchainDarwin) ProcMacroSuffix() string { func (t *toolchainDarwinX8664) ToolchainLinkFlags() string { // Prepend the lld flags from cc_config so we stay in sync with cc - return "${cc_config.DarwinClangLldflags} ${config.DarwinToolchainLinkFlags} ${config.DarwinToolchainX8664LinkFlags}" + return "${cc_config.DarwinLldflags} ${config.DarwinToolchainLinkFlags} ${config.DarwinToolchainX8664LinkFlags}" } func (t *toolchainDarwinX8664) ToolchainRustFlags() string { diff --git a/rust/config/x86_device.go b/rust/config/x86_device.go index aae11252f..5ae30e7d3 100644 --- a/rust/config/x86_device.go +++ b/rust/config/x86_device.go @@ -65,7 +65,7 @@ func (t *toolchainX86) RustTriple() string { func (t *toolchainX86) ToolchainLinkFlags() string { // Prepend the lld flags from cc_config so we stay in sync with cc - return "${config.DeviceGlobalLinkFlags} ${cc_config.X86ClangLldflags} ${config.X86ToolchainLinkFlags}" + return "${config.DeviceGlobalLinkFlags} ${cc_config.X86Lldflags} ${config.X86ToolchainLinkFlags}" } func (t *toolchainX86) ToolchainRustFlags() string { diff --git a/rust/config/x86_linux_host.go b/rust/config/x86_linux_host.go index b63e14d25..a9fdaed45 100644 --- a/rust/config/x86_linux_host.go +++ b/rust/config/x86_linux_host.go @@ -79,7 +79,7 @@ func (t *toolchainLinuxX8664) RustTriple() string { func (t *toolchainLinuxX8664) ToolchainLinkFlags() string { // Prepend the lld flags from cc_config so we stay in sync with cc - return "${cc_config.LinuxClangLldflags} ${cc_config.LinuxX8664ClangLldflags} " + + return "${cc_config.LinuxLldflags} ${cc_config.LinuxX8664Lldflags} " + "${config.LinuxToolchainLinkFlags} ${config.LinuxToolchainX8664LinkFlags}" } @@ -117,7 +117,7 @@ func (t *toolchainLinuxX86) RustTriple() string { func (t *toolchainLinuxX86) ToolchainLinkFlags() string { // Prepend the lld flags from cc_config so we stay in sync with cc - return "${cc_config.LinuxClangLldflags} ${cc_config.LinuxX86ClangLldflags} " + + return "${cc_config.LinuxLldflags} ${cc_config.LinuxX86Lldflags} " + "${config.LinuxToolchainLinkFlags} ${config.LinuxToolchainX86LinkFlags}" } diff --git a/sdk/bootclasspath_fragment_sdk_test.go b/sdk/bootclasspath_fragment_sdk_test.go index a458cba7d..1d2ab4218 100644 --- a/sdk/bootclasspath_fragment_sdk_test.go +++ b/sdk/bootclasspath_fragment_sdk_test.go @@ -327,6 +327,7 @@ java_import { visibility: ["//visibility:public"], apex_available: ["myapex"], jars: ["java/mybootlib.jar"], + permitted_packages: ["mybootlib"], } java_sdk_library_import { @@ -336,6 +337,7 @@ java_sdk_library_import { apex_available: ["myapex"], shared_library: true, compile_dex: true, + permitted_packages: ["myothersdklibrary"], public: { jars: ["sdk_library/public/myothersdklibrary-stubs.jar"], stub_srcs: ["sdk_library/public/myothersdklibrary_stub_sources"], @@ -409,6 +411,7 @@ java_import { visibility: ["//visibility:public"], apex_available: ["myapex"], jars: ["java/mybootlib.jar"], + permitted_packages: ["mybootlib"], } java_sdk_library_import { @@ -418,6 +421,7 @@ java_sdk_library_import { apex_available: ["myapex"], shared_library: true, compile_dex: true, + permitted_packages: ["myothersdklibrary"], public: { jars: ["sdk_library/public/myothersdklibrary-stubs.jar"], stub_srcs: ["sdk_library/public/myothersdklibrary_stub_sources"], @@ -509,6 +513,12 @@ sdk_snapshot { out/soong/.intermediates/frameworks/base/boot/platform-bootclasspath/android_common/hiddenapi-monolithic/index-from-classes.csv snapshot/hiddenapi/index.csv `, rule) + + // Make sure that the permitted packages from the prebuilts end up in the + // updatable-bcp-packages.txt file. + rule = module.Output("updatable-bcp-packages.txt") + expectedContents := `'mybootlib\nmyothersdklibrary\n'` + android.AssertStringEquals(t, "updatable-bcp-packages.txt", expectedContents, rule.Args["content"]) }), snapshotTestPreparer(checkSnapshotWithSourcePreferred, preparerForSnapshot), snapshotTestPreparer(checkSnapshotPreferredWithSource, preparerForSnapshot), @@ -779,6 +789,7 @@ func TestSnapshotWithBootclasspathFragment_HiddenAPI(t *testing.T) { srcs: ["Test.java"], compile_dex: true, public: {enabled: true}, + permitted_packages: ["mysdklibrary"], } `), ).RunTest(t) @@ -822,6 +833,7 @@ java_import { visibility: ["//visibility:public"], apex_available: ["myapex"], jars: ["java/mybootlib.jar"], + permitted_packages: ["mybootlib"], } java_sdk_library_import { @@ -831,6 +843,7 @@ java_sdk_library_import { apex_available: ["//apex_available:platform"], shared_library: true, compile_dex: true, + permitted_packages: ["mysdklibrary"], public: { jars: ["sdk_library/public/mysdklibrary-stubs.jar"], stub_srcs: ["sdk_library/public/mysdklibrary_stub_sources"], diff --git a/sdk/java_sdk_test.go b/sdk/java_sdk_test.go index a2cfe6d16..813dcfd6d 100644 --- a/sdk/java_sdk_test.go +++ b/sdk/java_sdk_test.go @@ -175,6 +175,7 @@ func TestSnapshotWithJavaHeaderLibrary(t *testing.T) { sdk_version: "none", compile_dex: true, host_supported: true, + permitted_packages: ["pkg.myjavalib"], } `) @@ -188,6 +189,7 @@ java_import { visibility: ["//visibility:public"], apex_available: ["//apex_available:platform"], jars: ["java/myjavalib.jar"], + permitted_packages: ["pkg.myjavalib"], } `), checkVersionedAndroidBpContents(` @@ -199,6 +201,7 @@ java_import { visibility: ["//visibility:public"], apex_available: ["//apex_available:platform"], jars: ["java/myjavalib.jar"], + permitted_packages: ["pkg.myjavalib"], } sdk_snapshot { @@ -437,6 +440,7 @@ func TestSnapshotWithJavaBootLibrary(t *testing.T) { system_modules: "none", sdk_version: "none", compile_dex: true, + permitted_packages: ["pkg.myjavalib"], } `) @@ -450,6 +454,7 @@ java_import { visibility: ["//visibility:public"], apex_available: ["//apex_available:platform"], jars: ["java/myjavalib.jar"], + permitted_packages: ["pkg.myjavalib"], } `), checkVersionedAndroidBpContents(` @@ -461,6 +466,7 @@ java_import { visibility: ["//visibility:public"], apex_available: ["//apex_available:platform"], jars: ["java/myjavalib.jar"], + permitted_packages: ["pkg.myjavalib"], } module_exports_snapshot { @@ -1045,6 +1051,7 @@ func TestSnapshotWithJavaSdkLibrary(t *testing.T) { shared_library: false, stubs_library_visibility: ["//other"], stubs_source_visibility: ["//another"], + permitted_packages: ["pkg.myjavalib"], } `) @@ -1058,6 +1065,7 @@ java_sdk_library_import { visibility: ["//visibility:public"], apex_available: ["//apex_available:anyapex"], shared_library: false, + permitted_packages: ["pkg.myjavalib"], public: { jars: ["sdk_library/public/myjavalib-stubs.jar"], stub_srcs: ["sdk_library/public/myjavalib_stub_sources"], @@ -1090,6 +1098,7 @@ java_sdk_library_import { visibility: ["//visibility:public"], apex_available: ["//apex_available:anyapex"], shared_library: false, + permitted_packages: ["pkg.myjavalib"], public: { jars: ["sdk_library/public/myjavalib-stubs.jar"], stub_srcs: ["sdk_library/public/myjavalib_stub_sources"], diff --git a/ui/build/config.go b/ui/build/config.go index 737062732..cd6d549ea 100644 --- a/ui/build/config.go +++ b/ui/build/config.go @@ -345,12 +345,7 @@ func storeConfigMetrics(ctx Context, config Config) { return } - b := &smpb.BuildConfig{ - ForceUseGoma: proto.Bool(config.ForceUseGoma()), - UseGoma: proto.Bool(config.UseGoma()), - UseRbe: proto.Bool(config.UseRBE()), - } - ctx.Metrics.BuildConfig(b) + ctx.Metrics.BuildConfig(buildConfig(config)) s := &smpb.SystemResourceInfo{ TotalPhysicalMemory: proto.Uint64(config.TotalRAM()), @@ -359,6 +354,16 @@ func storeConfigMetrics(ctx Context, config Config) { ctx.Metrics.SystemResourceInfo(s) } +func buildConfig(config Config) *smpb.BuildConfig { + return &smpb.BuildConfig{ + ForceUseGoma: proto.Bool(config.ForceUseGoma()), + UseGoma: proto.Bool(config.UseGoma()), + UseRbe: proto.Bool(config.UseRBE()), + BazelAsNinja: proto.Bool(config.UseBazel()), + BazelMixedBuild: proto.Bool(config.bazelBuildMode() == mixedBuild), + } +} + // getConfigArgs processes the command arguments based on the build action and creates a set of new // arguments to be accepted by Config. func getConfigArgs(action BuildAction, dir string, ctx Context, args []string) []string { diff --git a/ui/build/config_test.go b/ui/build/config_test.go index 7b14c4703..7d4c76b83 100644 --- a/ui/build/config_test.go +++ b/ui/build/config_test.go @@ -26,7 +26,10 @@ import ( "testing" "android/soong/ui/logger" + smpb "android/soong/ui/metrics/metrics_proto" "android/soong/ui/status" + + "github.com/golang/protobuf/proto" ) func testContext() Context { @@ -995,3 +998,111 @@ func TestGetConfigArgsBuildModulesInDirectories(t *testing.T) { }) } } + +func TestBuildConfig(t *testing.T) { + tests := []struct { + name string + environ Environment + useBazel bool + expectedBuildConfig *smpb.BuildConfig + }{ + { + name: "none set", + environ: Environment{}, + expectedBuildConfig: &smpb.BuildConfig{ + ForceUseGoma: proto.Bool(false), + UseGoma: proto.Bool(false), + UseRbe: proto.Bool(false), + BazelAsNinja: proto.Bool(false), + BazelMixedBuild: proto.Bool(false), + }, + }, + { + name: "force use goma", + environ: Environment{"FORCE_USE_GOMA=1"}, + expectedBuildConfig: &smpb.BuildConfig{ + ForceUseGoma: proto.Bool(true), + UseGoma: proto.Bool(false), + UseRbe: proto.Bool(false), + BazelAsNinja: proto.Bool(false), + BazelMixedBuild: proto.Bool(false), + }, + }, + { + name: "use goma", + environ: Environment{"USE_GOMA=1"}, + expectedBuildConfig: &smpb.BuildConfig{ + ForceUseGoma: proto.Bool(false), + UseGoma: proto.Bool(true), + UseRbe: proto.Bool(false), + BazelAsNinja: proto.Bool(false), + BazelMixedBuild: proto.Bool(false), + }, + }, + { + name: "use rbe", + environ: Environment{"USE_RBE=1"}, + expectedBuildConfig: &smpb.BuildConfig{ + ForceUseGoma: proto.Bool(false), + UseGoma: proto.Bool(false), + UseRbe: proto.Bool(true), + BazelAsNinja: proto.Bool(false), + BazelMixedBuild: proto.Bool(false), + }, + }, + { + name: "use bazel as ninja", + environ: Environment{}, + useBazel: true, + expectedBuildConfig: &smpb.BuildConfig{ + ForceUseGoma: proto.Bool(false), + UseGoma: proto.Bool(false), + UseRbe: proto.Bool(false), + BazelAsNinja: proto.Bool(true), + BazelMixedBuild: proto.Bool(false), + }, + }, + { + name: "bazel mixed build", + environ: Environment{"USE_BAZEL_ANALYSIS=1"}, + expectedBuildConfig: &smpb.BuildConfig{ + ForceUseGoma: proto.Bool(false), + UseGoma: proto.Bool(false), + UseRbe: proto.Bool(false), + BazelAsNinja: proto.Bool(false), + BazelMixedBuild: proto.Bool(true), + }, + }, + { + name: "all set", + environ: Environment{ + "FORCE_USE_GOMA=1", + "USE_GOMA=1", + "USE_RBE=1", + "USE_BAZEL_ANALYSIS=1", + }, + useBazel: true, + expectedBuildConfig: &smpb.BuildConfig{ + ForceUseGoma: proto.Bool(true), + UseGoma: proto.Bool(true), + UseRbe: proto.Bool(true), + BazelAsNinja: proto.Bool(true), + BazelMixedBuild: proto.Bool(true), + }, + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + c := &configImpl{ + environ: &tc.environ, + useBazel: tc.useBazel, + } + config := Config{c} + actualBuildConfig := buildConfig(config) + if expected := tc.expectedBuildConfig; !proto.Equal(expected, actualBuildConfig) { + t.Errorf("Expected build config != actual build config: %#v != %#v", *expected, *actualBuildConfig) + } + }) + } +} diff --git a/ui/metrics/metrics_proto/metrics.pb.go b/ui/metrics/metrics_proto/metrics.pb.go index fc2cfa492..106333707 100644 --- a/ui/metrics/metrics_proto/metrics.pb.go +++ b/ui/metrics/metrics_proto/metrics.pb.go @@ -433,9 +433,14 @@ func (m *MetricsBase) GetBazelRuns() []*PerfInfo { } type BuildConfig struct { - UseGoma *bool `protobuf:"varint,1,opt,name=use_goma,json=useGoma" json:"use_goma,omitempty"` - UseRbe *bool `protobuf:"varint,2,opt,name=use_rbe,json=useRbe" json:"use_rbe,omitempty"` - ForceUseGoma *bool `protobuf:"varint,3,opt,name=force_use_goma,json=forceUseGoma" json:"force_use_goma,omitempty"` + UseGoma *bool `protobuf:"varint,1,opt,name=use_goma,json=useGoma" json:"use_goma,omitempty"` + UseRbe *bool `protobuf:"varint,2,opt,name=use_rbe,json=useRbe" json:"use_rbe,omitempty"` + ForceUseGoma *bool `protobuf:"varint,3,opt,name=force_use_goma,json=forceUseGoma" json:"force_use_goma,omitempty"` + // Whether the Bazel is acting as the Ninja executor for this build. + BazelAsNinja *bool `protobuf:"varint,4,opt,name=bazel_as_ninja,json=bazelAsNinja" json:"bazel_as_ninja,omitempty"` + // Whether build is occurring in a mixed build mode, where Bazel maintains the + // definition and build of some modules in cooperation with Soong. + BazelMixedBuild *bool `protobuf:"varint,5,opt,name=bazel_mixed_build,json=bazelMixedBuild" json:"bazel_mixed_build,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` @@ -487,6 +492,20 @@ func (m *BuildConfig) GetForceUseGoma() bool { return false } +func (m *BuildConfig) GetBazelAsNinja() bool { + if m != nil && m.BazelAsNinja != nil { + return *m.BazelAsNinja + } + return false +} + +func (m *BuildConfig) GetBazelMixedBuild() bool { + if m != nil && m.BazelMixedBuild != nil { + return *m.BazelMixedBuild + } + return false +} + type SystemResourceInfo struct { // The total physical memory in bytes. TotalPhysicalMemory *uint64 `protobuf:"varint,1,opt,name=total_physical_memory,json=totalPhysicalMemory" json:"total_physical_memory,omitempty"` @@ -990,92 +1009,94 @@ func init() { } var fileDescriptor_6039342a2ba47b72 = []byte{ - // 1380 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x57, 0xef, 0x52, 0x1b, 0x37, - 0x10, 0x8f, 0xc1, 0x60, 0x7b, 0xfd, 0x07, 0x23, 0xa0, 0x5c, 0x48, 0xd2, 0x52, 0xb7, 0x49, 0x99, - 0x4e, 0x43, 0x32, 0x34, 0xc3, 0x64, 0x98, 0x4c, 0xa7, 0xe0, 0xd0, 0x34, 0x65, 0xc0, 0x8c, 0x08, - 0x69, 0xda, 0x7e, 0x50, 0xe5, 0xb3, 0x0c, 0x97, 0xdc, 0x9d, 0x6e, 0x24, 0x1d, 0xc5, 0x79, 0xb3, - 0x7e, 0xee, 0x4b, 0xf4, 0x05, 0xfa, 0x04, 0x7d, 0x81, 0x8e, 0x56, 0x77, 0xe6, 0x20, 0x6e, 0xc2, - 0xe4, 0xdb, 0xe9, 0xb7, 0xbf, 0xdf, 0x6a, 0xb5, 0xd2, 0xee, 0xda, 0xd0, 0x8c, 0x84, 0x51, 0x81, - 0xaf, 0xd7, 0x13, 0x25, 0x8d, 0x24, 0x0b, 0x5a, 0xca, 0xf8, 0x84, 0xf5, 0xd3, 0x20, 0x1c, 0xb0, - 0xcc, 0xd4, 0xf9, 0xbb, 0x01, 0xf5, 0x7d, 0xf7, 0xbd, 0xc3, 0xb5, 0x20, 0x0f, 0x61, 0xd1, 0x11, - 0x06, 0xdc, 0x08, 0x66, 0x82, 0x48, 0x68, 0xc3, 0xa3, 0xc4, 0x2b, 0xad, 0x96, 0xd6, 0xa6, 0x29, - 0x41, 0xdb, 0x53, 0x6e, 0xc4, 0x8b, 0xdc, 0x42, 0x6e, 0x42, 0xd5, 0x29, 0x82, 0x81, 0x37, 0xb5, - 0x5a, 0x5a, 0xab, 0xd1, 0x0a, 0xae, 0x9f, 0x0f, 0xc8, 0x16, 0xdc, 0x4c, 0x42, 0x6e, 0x86, 0x52, - 0x45, 0xec, 0x4c, 0x28, 0x1d, 0xc8, 0x98, 0xf9, 0x72, 0x20, 0x62, 0x1e, 0x09, 0x6f, 0x1a, 0xb9, - 0xcb, 0x39, 0xe1, 0xa5, 0xb3, 0x77, 0x33, 0x33, 0xb9, 0x0b, 0x2d, 0xc3, 0xd5, 0x89, 0x30, 0x2c, - 0x51, 0x72, 0x90, 0xfa, 0xc6, 0x2b, 0xa3, 0xa0, 0xe9, 0xd0, 0x43, 0x07, 0x92, 0x01, 0x2c, 0x66, - 0x34, 0x17, 0xc4, 0x19, 0x57, 0x01, 0x8f, 0x8d, 0x37, 0xb3, 0x5a, 0x5a, 0x6b, 0x6d, 0xdc, 0x5f, - 0x9f, 0x70, 0xe6, 0xf5, 0xc2, 0x79, 0xd7, 0x77, 0xac, 0xe5, 0xa5, 0x13, 0x6d, 0x4d, 0xef, 0x1e, - 0x3c, 0xa3, 0xc4, 0xf9, 0x2b, 0x1a, 0x48, 0x0f, 0xea, 0xd9, 0x2e, 0x5c, 0xf9, 0xa7, 0xde, 0x2c, - 0x3a, 0xbf, 0xfb, 0x41, 0xe7, 0xdb, 0xca, 0x3f, 0xdd, 0xaa, 0x1c, 0x1f, 0xec, 0x1d, 0xf4, 0x7e, - 0x3e, 0xa0, 0xe0, 0x5c, 0x58, 0x90, 0xac, 0xc3, 0x42, 0xc1, 0xe1, 0x38, 0xea, 0x0a, 0x1e, 0x71, - 0xfe, 0x82, 0x98, 0x07, 0xf0, 0x0d, 0x64, 0x61, 0x31, 0x3f, 0x49, 0xc7, 0xf4, 0x2a, 0xd2, 0xdb, - 0xce, 0xd2, 0x4d, 0xd2, 0x9c, 0xbd, 0x07, 0xb5, 0x53, 0xa9, 0xb3, 0x60, 0x6b, 0x1f, 0x15, 0x6c, - 0xd5, 0x3a, 0xc0, 0x50, 0x29, 0x34, 0xd1, 0xd9, 0x46, 0x3c, 0x70, 0x0e, 0xe1, 0xa3, 0x1c, 0xd6, - 0xad, 0x93, 0x8d, 0x78, 0x80, 0x3e, 0x97, 0xa1, 0x82, 0x3e, 0xa5, 0xf6, 0xea, 0x78, 0x86, 0x59, - 0xbb, 0xec, 0x69, 0xd2, 0xc9, 0x36, 0x93, 0x9a, 0x89, 0x73, 0xa3, 0xb8, 0xd7, 0x40, 0x73, 0xdd, - 0x99, 0x77, 0x2d, 0x34, 0xe6, 0xf8, 0x4a, 0x6a, 0x6d, 0x5d, 0x34, 0x2f, 0x38, 0x5d, 0x8b, 0xf5, - 0x34, 0xb9, 0x07, 0x73, 0x05, 0x0e, 0x86, 0xdd, 0x72, 0xcf, 0x67, 0xcc, 0xc2, 0x40, 0xee, 0xc3, - 0x42, 0x81, 0x37, 0x3e, 0xe2, 0x9c, 0x4b, 0xec, 0x98, 0x5b, 0x88, 0x5b, 0xa6, 0x86, 0x0d, 0x02, - 0xe5, 0xb5, 0x5d, 0xdc, 0x32, 0x35, 0x4f, 0x03, 0x45, 0xbe, 0x83, 0xba, 0x16, 0x26, 0x4d, 0x98, - 0x91, 0x32, 0xd4, 0xde, 0xfc, 0xea, 0xf4, 0x5a, 0x7d, 0xe3, 0xce, 0xc4, 0x14, 0x1d, 0x0a, 0x35, - 0x7c, 0x1e, 0x0f, 0x25, 0x05, 0x54, 0xbc, 0xb0, 0x02, 0xb2, 0x05, 0xb5, 0x37, 0xdc, 0x04, 0x4c, - 0xa5, 0xb1, 0xf6, 0xc8, 0x75, 0xd4, 0x55, 0xcb, 0xa7, 0x69, 0xac, 0xc9, 0x13, 0x00, 0xc7, 0x44, - 0xf1, 0xc2, 0x75, 0xc4, 0x35, 0xb4, 0xe6, 0xea, 0x38, 0x88, 0x5f, 0x73, 0xa7, 0x5e, 0xbc, 0x96, - 0x1a, 0x05, 0xa8, 0xfe, 0x16, 0x66, 0x8c, 0x34, 0x3c, 0xf4, 0x96, 0x56, 0x4b, 0x1f, 0x16, 0x3a, - 0x2e, 0x79, 0x09, 0x93, 0x5a, 0x91, 0xf7, 0x09, 0xba, 0xb8, 0x37, 0xd1, 0xc5, 0x91, 0xc5, 0xb0, - 0x24, 0xb3, 0x17, 0x46, 0xe7, 0xf5, 0x55, 0x88, 0x74, 0xa1, 0xe1, 0x54, 0xbe, 0x8c, 0x87, 0xc1, - 0x89, 0xb7, 0x8c, 0x0e, 0x57, 0x27, 0x3a, 0x44, 0x61, 0x17, 0x79, 0xb4, 0xde, 0xbf, 0x58, 0x90, - 0x15, 0xc0, 0xa7, 0x8f, 0x2d, 0xca, 0xc3, 0x3b, 0x1e, 0xaf, 0xc9, 0x2f, 0xb0, 0xa8, 0x47, 0xda, - 0x88, 0x88, 0x29, 0xa1, 0x65, 0xaa, 0x7c, 0xc1, 0x82, 0x78, 0x28, 0xbd, 0x9b, 0xb8, 0xd1, 0x57, - 0x93, 0x23, 0x47, 0x01, 0xcd, 0xf8, 0x98, 0x06, 0xa2, 0xdf, 0xc1, 0xc8, 0x17, 0xd0, 0xcc, 0x63, - 0x8f, 0x22, 0x1e, 0x0f, 0xbc, 0x15, 0xdc, 0xbb, 0x91, 0x85, 0x86, 0x98, 0xbd, 0xab, 0x3e, 0x7f, - 0x2b, 0x42, 0x77, 0x57, 0xb7, 0xae, 0x75, 0x57, 0x28, 0xb0, 0x77, 0xd5, 0x79, 0x08, 0x8d, 0x4b, - 0x4d, 0xad, 0x0a, 0xe5, 0xe3, 0xa3, 0x5d, 0xda, 0xbe, 0x41, 0x9a, 0x50, 0xb3, 0x5f, 0x4f, 0x77, - 0x77, 0x8e, 0x9f, 0xb5, 0x4b, 0xa4, 0x02, 0xb6, 0x11, 0xb6, 0xa7, 0x3a, 0x4f, 0xa0, 0x8c, 0xcf, - 0xbe, 0x0e, 0x79, 0x19, 0xb7, 0x6f, 0x58, 0xeb, 0x36, 0xdd, 0x6f, 0x97, 0x48, 0x0d, 0x66, 0xb6, - 0xe9, 0xfe, 0xe6, 0xa3, 0xf6, 0x94, 0xc5, 0x5e, 0x3d, 0xde, 0x6c, 0x4f, 0x13, 0x80, 0xd9, 0x57, - 0x8f, 0x37, 0xd9, 0xe6, 0xa3, 0x76, 0xb9, 0x73, 0x02, 0xf5, 0x42, 0x96, 0xed, 0x9c, 0x48, 0xb5, - 0x60, 0x27, 0x32, 0xe2, 0x38, 0x4d, 0xaa, 0xb4, 0x92, 0x6a, 0xf1, 0x4c, 0x46, 0xdc, 0x96, 0x95, - 0x35, 0xa9, 0xbe, 0xc0, 0x09, 0x52, 0xa5, 0xb3, 0xa9, 0x16, 0xb4, 0x2f, 0xc8, 0x97, 0xd0, 0x1a, - 0x4a, 0x9b, 0xe6, 0xb1, 0x72, 0x1a, 0xed, 0x0d, 0x44, 0x8f, 0x9d, 0xbc, 0x23, 0x81, 0xbc, 0x9b, - 0x65, 0xb2, 0x01, 0x4b, 0xf8, 0xdc, 0x58, 0x72, 0x3a, 0xd2, 0x81, 0xcf, 0x43, 0x16, 0x89, 0x48, - 0xaa, 0x11, 0x6e, 0x5e, 0xa6, 0x0b, 0x68, 0x3c, 0xcc, 0x6c, 0xfb, 0x68, 0xb2, 0x43, 0x87, 0x9f, - 0xf1, 0x20, 0xe4, 0xfd, 0x50, 0xd8, 0x4e, 0xab, 0x31, 0x9e, 0x19, 0xda, 0x1c, 0xa3, 0xdd, 0x24, - 0xd5, 0x9d, 0x7f, 0x4b, 0x50, 0xcd, 0x33, 0x4c, 0x08, 0x94, 0x07, 0x42, 0xfb, 0xe8, 0xb6, 0x46, - 0xf1, 0xdb, 0x62, 0xf8, 0x80, 0xdc, 0x3c, 0xc4, 0x6f, 0x72, 0x07, 0x40, 0x1b, 0xae, 0x0c, 0x0e, - 0x55, 0x3c, 0x47, 0x99, 0xd6, 0x10, 0xb1, 0xb3, 0x94, 0xdc, 0x82, 0x9a, 0x12, 0x3c, 0x74, 0xd6, - 0x32, 0x5a, 0xab, 0x16, 0x40, 0xe3, 0xe7, 0x00, 0x2e, 0x78, 0x9b, 0x08, 0x9c, 0x6d, 0xe5, 0x9d, - 0x29, 0xaf, 0x44, 0x6b, 0x0e, 0x3d, 0xd6, 0x82, 0xfc, 0x0e, 0xcb, 0x89, 0x92, 0xbe, 0xd0, 0x5a, - 0xe8, 0x2b, 0xcf, 0x73, 0x16, 0x1f, 0xca, 0xda, 0xe4, 0x87, 0xe2, 0x34, 0x97, 0xde, 0xe7, 0xd2, - 0xd8, 0x51, 0x11, 0xee, 0xfc, 0x39, 0x0d, 0x0b, 0x13, 0xe8, 0xe3, 0xc3, 0x96, 0x0a, 0x87, 0x5d, - 0x83, 0x76, 0xaa, 0x85, 0xc2, 0xd3, 0xb0, 0x28, 0xb0, 0xed, 0x15, 0x93, 0x51, 0xa6, 0x2d, 0x8b, - 0xdb, 0x43, 0xed, 0x23, 0x6a, 0x27, 0x5b, 0x56, 0x53, 0x45, 0xae, 0x4b, 0x4f, 0xdb, 0x59, 0x0a, - 0xec, 0xdb, 0x00, 0x11, 0x3f, 0x67, 0x4a, 0x6b, 0xf6, 0xa6, 0x9f, 0xa7, 0x29, 0xe2, 0xe7, 0x54, - 0xeb, 0xbd, 0x3e, 0xf9, 0x1a, 0xe6, 0xa3, 0x20, 0x96, 0x8a, 0x25, 0xfc, 0x44, 0xb0, 0x21, 0x4f, - 0x43, 0xa3, 0x5d, 0xb6, 0xe8, 0x1c, 0x1a, 0x0e, 0xf9, 0x89, 0xf8, 0x01, 0x61, 0xe4, 0xf2, 0xd7, - 0x57, 0xb8, 0xb3, 0x19, 0xd7, 0x1a, 0x0a, 0xdc, 0x4f, 0xa1, 0x1e, 0x48, 0x16, 0xc4, 0x49, 0x6a, - 0xec, 0xb6, 0x15, 0x77, 0x77, 0x81, 0x7c, 0x6e, 0x91, 0xbd, 0x3e, 0x59, 0x85, 0x46, 0x20, 0x99, - 0x4c, 0x4d, 0x46, 0xa8, 0x22, 0x01, 0x02, 0xd9, 0x43, 0x68, 0xaf, 0x4f, 0x9e, 0xc0, 0xca, 0x99, - 0x0c, 0xd3, 0xd8, 0x70, 0x35, 0xb2, 0xed, 0xc9, 0x88, 0x73, 0xc3, 0xf4, 0x1f, 0x81, 0xf1, 0x4f, - 0x85, 0xc6, 0x11, 0x5d, 0xa6, 0xde, 0x98, 0xd1, 0x75, 0x84, 0xa3, 0xcc, 0x4e, 0xbe, 0x87, 0xdb, - 0x41, 0xfc, 0x1e, 0x3d, 0xa0, 0x7e, 0xa5, 0xc0, 0xb9, 0xe2, 0xa1, 0xf3, 0x4f, 0x09, 0x5a, 0xfb, - 0x72, 0x90, 0x86, 0xe2, 0xc5, 0x28, 0x71, 0xd7, 0xf6, 0x5b, 0xde, 0x2d, 0x5d, 0x92, 0xf1, 0xfa, - 0x5a, 0x1b, 0x0f, 0x26, 0x8f, 0xf5, 0x4b, 0x52, 0xd7, 0x3c, 0x5d, 0xc9, 0x15, 0x06, 0x7c, 0xff, - 0x02, 0x25, 0x9f, 0x41, 0x3d, 0x42, 0x0d, 0x33, 0xa3, 0x24, 0xaf, 0x03, 0x88, 0xc6, 0x6e, 0x6c, - 0x65, 0xc7, 0x69, 0xc4, 0xe4, 0x90, 0x39, 0xd0, 0x5d, 0x79, 0x93, 0x36, 0xe2, 0x34, 0xea, 0x0d, - 0xdd, 0x7e, 0xba, 0xf3, 0x20, 0x6b, 0x21, 0x99, 0xd7, 0x4b, 0x7d, 0xa8, 0x06, 0x33, 0x47, 0xbd, - 0xde, 0x81, 0x6d, 0x58, 0x55, 0x28, 0xef, 0x6f, 0xef, 0xed, 0xb6, 0xa7, 0x3a, 0x21, 0xac, 0x74, - 0x55, 0x60, 0x6c, 0x49, 0x1f, 0x6b, 0xa1, 0x7e, 0x92, 0xa9, 0x8a, 0xc5, 0x28, 0x1f, 0x10, 0x93, - 0x5e, 0xea, 0x16, 0x54, 0xf2, 0x01, 0x34, 0xf5, 0x9e, 0x79, 0x51, 0xf8, 0x61, 0x43, 0x73, 0x41, - 0xa7, 0x0f, 0xb7, 0x26, 0xec, 0xa6, 0x2f, 0xe6, 0x51, 0xd9, 0x4f, 0x5f, 0x6b, 0xaf, 0x84, 0xf5, - 0x37, 0x39, 0xb3, 0xff, 0x1f, 0x2d, 0x45, 0x71, 0xe7, 0xaf, 0x12, 0xcc, 0xbf, 0x33, 0xfd, 0x88, - 0x07, 0x95, 0x3c, 0x6f, 0x25, 0xcc, 0x5b, 0xbe, 0xb4, 0xf3, 0x2b, 0xfb, 0x79, 0xe8, 0x0e, 0xd4, - 0xa4, 0xe3, 0xb5, 0x7d, 0xf3, 0xae, 0x25, 0xf2, 0x30, 0x94, 0x3e, 0xf3, 0x65, 0x1a, 0x9b, 0xac, - 0xd4, 0xe6, 0xd0, 0xb0, 0x6d, 0xf1, 0xae, 0x85, 0x6d, 0x05, 0x17, 0xb9, 0x3a, 0x78, 0x9b, 0xb7, - 0xa5, 0xd6, 0x05, 0xf5, 0x28, 0x78, 0x2b, 0xec, 0xef, 0x31, 0x5b, 0x93, 0xa7, 0x82, 0x27, 0x8e, - 0xe6, 0x2a, 0xae, 0x1e, 0xf1, 0xf3, 0x1f, 0x05, 0x4f, 0x2c, 0x67, 0x67, 0xe9, 0xd7, 0x6c, 0xe4, - 0x67, 0xe7, 0x66, 0xf8, 0x97, 0xe4, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xcb, 0xfb, 0x8e, 0xf5, - 0xa2, 0x0c, 0x00, 0x00, + // 1423 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x57, 0xdd, 0x52, 0x1b, 0xc7, + 0x12, 0xb6, 0x40, 0x20, 0xa9, 0xf5, 0x83, 0x18, 0xe0, 0xb0, 0xc6, 0xf6, 0x39, 0x1c, 0xc5, 0x76, + 0xa8, 0x54, 0x8c, 0x5d, 0xc4, 0x45, 0xb9, 0x28, 0x57, 0x2a, 0x20, 0x13, 0xc7, 0xa1, 0x84, 0xa8, + 0xc1, 0x38, 0x4e, 0x72, 0x31, 0x19, 0xad, 0x46, 0xb0, 0xf6, 0xee, 0xce, 0xd6, 0xcc, 0x2c, 0x01, + 0xbf, 0x99, 0xaf, 0xf3, 0x12, 0x79, 0x81, 0x3c, 0x41, 0x5e, 0x20, 0x35, 0x3d, 0xbb, 0x62, 0xc1, + 0x8a, 0x4d, 0xf9, 0x4e, 0xfb, 0xf5, 0xf7, 0xf5, 0x76, 0xf7, 0xf4, 0x74, 0xaf, 0xa0, 0x19, 0x09, + 0xa3, 0x02, 0x5f, 0xaf, 0x27, 0x4a, 0x1a, 0x49, 0x16, 0xb4, 0x94, 0xf1, 0x31, 0x1b, 0xa4, 0x41, + 0x38, 0x64, 0x99, 0xa9, 0xf3, 0x67, 0x03, 0xea, 0x3d, 0xf7, 0x7b, 0x87, 0x6b, 0x41, 0x1e, 0xc1, + 0xa2, 0x23, 0x0c, 0xb9, 0x11, 0xcc, 0x04, 0x91, 0xd0, 0x86, 0x47, 0x89, 0x57, 0x5a, 0x2d, 0xad, + 0x4d, 0x53, 0x82, 0xb6, 0x67, 0xdc, 0x88, 0x97, 0xb9, 0x85, 0xdc, 0x84, 0xaa, 0x53, 0x04, 0x43, + 0x6f, 0x6a, 0xb5, 0xb4, 0x56, 0xa3, 0x15, 0x7c, 0x7e, 0x31, 0x24, 0x5b, 0x70, 0x33, 0x09, 0xb9, + 0x19, 0x49, 0x15, 0xb1, 0x53, 0xa1, 0x74, 0x20, 0x63, 0xe6, 0xcb, 0xa1, 0x88, 0x79, 0x24, 0xbc, + 0x69, 0xe4, 0x2e, 0xe7, 0x84, 0x57, 0xce, 0xde, 0xcd, 0xcc, 0xe4, 0x1e, 0xb4, 0x0c, 0x57, 0xc7, + 0xc2, 0xb0, 0x44, 0xc9, 0x61, 0xea, 0x1b, 0xaf, 0x8c, 0x82, 0xa6, 0x43, 0x0f, 0x1c, 0x48, 0x86, + 0xb0, 0x98, 0xd1, 0x5c, 0x10, 0xa7, 0x5c, 0x05, 0x3c, 0x36, 0xde, 0xcc, 0x6a, 0x69, 0xad, 0xb5, + 0xf1, 0x60, 0x7d, 0x42, 0xce, 0xeb, 0x85, 0x7c, 0xd7, 0x77, 0xac, 0xe5, 0x95, 0x13, 0x6d, 0x4d, + 0xef, 0xee, 0x3f, 0xa7, 0xc4, 0xf9, 0x2b, 0x1a, 0x48, 0x1f, 0xea, 0xd9, 0x5b, 0xb8, 0xf2, 0x4f, + 0xbc, 0x59, 0x74, 0x7e, 0xef, 0x93, 0xce, 0xb7, 0x95, 0x7f, 0xb2, 0x55, 0x39, 0xda, 0xdf, 0xdb, + 0xef, 0xff, 0xb4, 0x4f, 0xc1, 0xb9, 0xb0, 0x20, 0x59, 0x87, 0x85, 0x82, 0xc3, 0x71, 0xd4, 0x15, + 0x4c, 0x71, 0xfe, 0x82, 0x98, 0x07, 0xf0, 0x35, 0x64, 0x61, 0x31, 0x3f, 0x49, 0xc7, 0xf4, 0x2a, + 0xd2, 0xdb, 0xce, 0xd2, 0x4d, 0xd2, 0x9c, 0xbd, 0x07, 0xb5, 0x13, 0xa9, 0xb3, 0x60, 0x6b, 0x9f, + 0x15, 0x6c, 0xd5, 0x3a, 0xc0, 0x50, 0x29, 0x34, 0xd1, 0xd9, 0x46, 0x3c, 0x74, 0x0e, 0xe1, 0xb3, + 0x1c, 0xd6, 0xad, 0x93, 0x8d, 0x78, 0x88, 0x3e, 0x97, 0xa1, 0x82, 0x3e, 0xa5, 0xf6, 0xea, 0x98, + 0xc3, 0xac, 0x7d, 0xec, 0x6b, 0xd2, 0xc9, 0x5e, 0x26, 0x35, 0x13, 0x67, 0x46, 0x71, 0xaf, 0x81, + 0xe6, 0xba, 0x33, 0xef, 0x5a, 0x68, 0xcc, 0xf1, 0x95, 0xd4, 0xda, 0xba, 0x68, 0x5e, 0x70, 0xba, + 0x16, 0xeb, 0x6b, 0x72, 0x1f, 0xe6, 0x0a, 0x1c, 0x0c, 0xbb, 0xe5, 0xda, 0x67, 0xcc, 0xc2, 0x40, + 0x1e, 0xc0, 0x42, 0x81, 0x37, 0x4e, 0x71, 0xce, 0x15, 0x76, 0xcc, 0x2d, 0xc4, 0x2d, 0x53, 0xc3, + 0x86, 0x81, 0xf2, 0xda, 0x2e, 0x6e, 0x99, 0x9a, 0x67, 0x81, 0x22, 0xdf, 0x42, 0x5d, 0x0b, 0x93, + 0x26, 0xcc, 0x48, 0x19, 0x6a, 0x6f, 0x7e, 0x75, 0x7a, 0xad, 0xbe, 0x71, 0x67, 0x62, 0x89, 0x0e, + 0x84, 0x1a, 0xbd, 0x88, 0x47, 0x92, 0x02, 0x2a, 0x5e, 0x5a, 0x01, 0xd9, 0x82, 0xda, 0x5b, 0x6e, + 0x02, 0xa6, 0xd2, 0x58, 0x7b, 0xe4, 0x3a, 0xea, 0xaa, 0xe5, 0xd3, 0x34, 0xd6, 0xe4, 0x29, 0x80, + 0x63, 0xa2, 0x78, 0xe1, 0x3a, 0xe2, 0x1a, 0x5a, 0x73, 0x75, 0x1c, 0xc4, 0x6f, 0xb8, 0x53, 0x2f, + 0x5e, 0x4b, 0x8d, 0x02, 0x54, 0x7f, 0x03, 0x33, 0x46, 0x1a, 0x1e, 0x7a, 0x4b, 0xab, 0xa5, 0x4f, + 0x0b, 0x1d, 0x97, 0xbc, 0x82, 0x49, 0xa3, 0xc8, 0xfb, 0x0f, 0xba, 0xb8, 0x3f, 0xd1, 0xc5, 0xa1, + 0xc5, 0xf0, 0x4a, 0x66, 0x1d, 0x46, 0xe7, 0xf5, 0x55, 0x88, 0x74, 0xa1, 0xe1, 0x54, 0xbe, 0x8c, + 0x47, 0xc1, 0xb1, 0xb7, 0x8c, 0x0e, 0x57, 0x27, 0x3a, 0x44, 0x61, 0x17, 0x79, 0xb4, 0x3e, 0xb8, + 0x78, 0x20, 0x2b, 0x80, 0xad, 0x8f, 0x23, 0xca, 0xc3, 0x33, 0x1e, 0x3f, 0x93, 0x9f, 0x61, 0x51, + 0x9f, 0x6b, 0x23, 0x22, 0xa6, 0x84, 0x96, 0xa9, 0xf2, 0x05, 0x0b, 0xe2, 0x91, 0xf4, 0x6e, 0xe2, + 0x8b, 0xbe, 0x9c, 0x1c, 0x39, 0x0a, 0x68, 0xc6, 0xc7, 0x32, 0x10, 0xfd, 0x01, 0x46, 0xbe, 0x80, + 0x66, 0x1e, 0x7b, 0x14, 0xf1, 0x78, 0xe8, 0xad, 0xe0, 0xbb, 0x1b, 0x59, 0x68, 0x88, 0xd9, 0xb3, + 0x1a, 0xf0, 0x77, 0x22, 0x74, 0x67, 0x75, 0xeb, 0x5a, 0x67, 0x85, 0x02, 0x7b, 0x56, 0x9d, 0x47, + 0xd0, 0xb8, 0x34, 0xd4, 0xaa, 0x50, 0x3e, 0x3a, 0xdc, 0xa5, 0xed, 0x1b, 0xa4, 0x09, 0x35, 0xfb, + 0xeb, 0xd9, 0xee, 0xce, 0xd1, 0xf3, 0x76, 0x89, 0x54, 0xc0, 0x0e, 0xc2, 0xf6, 0x54, 0xe7, 0x29, + 0x94, 0xb1, 0xed, 0xeb, 0x90, 0x5f, 0xe3, 0xf6, 0x0d, 0x6b, 0xdd, 0xa6, 0xbd, 0x76, 0x89, 0xd4, + 0x60, 0x66, 0x9b, 0xf6, 0x36, 0x1f, 0xb7, 0xa7, 0x2c, 0xf6, 0xfa, 0xc9, 0x66, 0x7b, 0x9a, 0x00, + 0xcc, 0xbe, 0x7e, 0xb2, 0xc9, 0x36, 0x1f, 0xb7, 0xcb, 0x9d, 0xf7, 0x25, 0xa8, 0x17, 0xca, 0x6c, + 0x17, 0x45, 0xaa, 0x05, 0x3b, 0x96, 0x11, 0xc7, 0x75, 0x52, 0xa5, 0x95, 0x54, 0x8b, 0xe7, 0x32, + 0xe2, 0xf6, 0x5e, 0x59, 0x93, 0x1a, 0x08, 0x5c, 0x21, 0x55, 0x3a, 0x9b, 0x6a, 0x41, 0x07, 0x82, + 0xdc, 0x85, 0xd6, 0x48, 0xda, 0x3a, 0x8f, 0x95, 0xd3, 0x68, 0x6f, 0x20, 0x7a, 0x94, 0xc9, 0xef, + 0x42, 0xcb, 0xd5, 0x85, 0x6b, 0x86, 0xbd, 0x89, 0xbb, 0xa2, 0x4a, 0x1b, 0x88, 0x6e, 0xeb, 0x7d, + 0x8b, 0x91, 0xaf, 0x60, 0xde, 0xb1, 0xa2, 0xe0, 0x4c, 0x0c, 0x5d, 0xc1, 0x70, 0x4f, 0x54, 0xe9, + 0x1c, 0x1a, 0x7a, 0x16, 0xc7, 0x88, 0x3b, 0x12, 0xc8, 0x87, 0x07, 0x47, 0x36, 0x60, 0x09, 0x3b, + 0x98, 0x25, 0x27, 0xe7, 0x3a, 0xf0, 0x79, 0xc8, 0x22, 0x11, 0x49, 0x75, 0x8e, 0xe9, 0x94, 0xe9, + 0x02, 0x1a, 0x0f, 0x32, 0x5b, 0x0f, 0x4d, 0x76, 0x8f, 0xf1, 0x53, 0x1e, 0x84, 0x7c, 0x10, 0x0a, + 0x3b, 0xbc, 0x35, 0x66, 0x38, 0x43, 0x9b, 0x63, 0xb4, 0x9b, 0xa4, 0xba, 0xf3, 0x77, 0x09, 0xaa, + 0xf9, 0xa1, 0x11, 0x02, 0xe5, 0xa1, 0xd0, 0x3e, 0xba, 0xad, 0x51, 0xfc, 0x6d, 0x31, 0xec, 0x49, + 0xb7, 0x62, 0xf1, 0x37, 0xb9, 0x03, 0xa0, 0x0d, 0x57, 0x06, 0xf7, 0x34, 0x56, 0xa6, 0x4c, 0x6b, + 0x88, 0xd8, 0xf5, 0x4c, 0x6e, 0x41, 0x4d, 0x09, 0x1e, 0x3a, 0x6b, 0x19, 0xad, 0x55, 0x0b, 0xa0, + 0xf1, 0xff, 0x00, 0x2e, 0x78, 0x5b, 0x5a, 0x2c, 0x43, 0x79, 0x67, 0xca, 0x2b, 0xd1, 0x9a, 0x43, + 0x8f, 0xb4, 0x20, 0xbf, 0xc1, 0x72, 0xa2, 0xa4, 0x2f, 0xb4, 0x16, 0xfa, 0x4a, 0xc7, 0xcf, 0x62, + 0xef, 0xad, 0x4d, 0xee, 0x3d, 0xa7, 0xb9, 0xd4, 0xf2, 0x4b, 0x63, 0x47, 0x45, 0xb8, 0xf3, 0x7e, + 0x1a, 0x16, 0x26, 0xd0, 0xc7, 0xc9, 0x96, 0x0a, 0xc9, 0xae, 0x41, 0x3b, 0xd5, 0x42, 0x61, 0x36, + 0x2c, 0x0a, 0xec, 0xc4, 0xc6, 0x62, 0x94, 0x69, 0xcb, 0xe2, 0x36, 0xa9, 0x1e, 0xa2, 0x76, 0x59, + 0x66, 0xd7, 0xb4, 0xc8, 0x75, 0xe5, 0x69, 0x3b, 0x4b, 0x81, 0x7d, 0x1b, 0x20, 0xe2, 0x67, 0x4c, + 0x69, 0xcd, 0xde, 0x0e, 0xf2, 0x32, 0x45, 0xfc, 0x8c, 0x6a, 0xbd, 0x37, 0xb0, 0x4d, 0x13, 0x05, + 0xb1, 0x54, 0x2c, 0xe1, 0xc7, 0x82, 0x8d, 0x78, 0x1a, 0x1a, 0xed, 0xaa, 0x45, 0xe7, 0xd0, 0x70, + 0xc0, 0x8f, 0xc5, 0xf7, 0x08, 0x23, 0x97, 0xbf, 0xb9, 0xc2, 0x9d, 0xcd, 0xb8, 0xd6, 0x50, 0xe0, + 0xfe, 0x17, 0xea, 0x81, 0x64, 0x41, 0x9c, 0xa4, 0xc6, 0xbe, 0xb6, 0xe2, 0xce, 0x2e, 0x90, 0x2f, + 0x2c, 0xb2, 0x37, 0x20, 0xab, 0xd0, 0x08, 0x24, 0x93, 0xa9, 0xc9, 0x08, 0x55, 0x24, 0x40, 0x20, + 0xfb, 0x08, 0xed, 0x0d, 0xc8, 0x53, 0x58, 0x39, 0x95, 0x61, 0x1a, 0x1b, 0xae, 0xce, 0xed, 0xc4, + 0x33, 0xe2, 0xcc, 0x30, 0xfd, 0x7b, 0x60, 0xfc, 0x13, 0xa1, 0x71, 0xeb, 0x97, 0xa9, 0x37, 0x66, + 0x74, 0x1d, 0xe1, 0x30, 0xb3, 0x93, 0xef, 0xe0, 0x76, 0x10, 0x7f, 0x44, 0x0f, 0xa8, 0x5f, 0x29, + 0x70, 0xae, 0x78, 0xe8, 0xfc, 0x55, 0x82, 0x56, 0x4f, 0x0e, 0xd3, 0x50, 0xbc, 0x3c, 0x4f, 0xdc, + 0xb1, 0xfd, 0x9a, 0x0f, 0x60, 0x57, 0x64, 0x3c, 0xbe, 0xd6, 0xc6, 0xc3, 0xc9, 0x5f, 0x0a, 0x97, + 0xa4, 0x6e, 0x1e, 0xbb, 0x2b, 0x57, 0xf8, 0x66, 0x18, 0x5c, 0xa0, 0xe4, 0x7f, 0x50, 0x8f, 0x50, + 0xc3, 0xcc, 0x79, 0x92, 0xdf, 0x03, 0x88, 0xc6, 0x6e, 0xec, 0x14, 0x88, 0xd3, 0x88, 0xc9, 0x11, + 0x73, 0xa0, 0x3b, 0xf2, 0x26, 0x6d, 0xc4, 0x69, 0xd4, 0x1f, 0xb9, 0xf7, 0xe9, 0xce, 0xc3, 0x6c, + 0x28, 0x65, 0x5e, 0x2f, 0x8d, 0xb6, 0x1a, 0xcc, 0x1c, 0xf6, 0xfb, 0xfb, 0x76, 0x06, 0x56, 0xa1, + 0xdc, 0xdb, 0xde, 0xdb, 0x6d, 0x4f, 0x75, 0x42, 0x58, 0xe9, 0xaa, 0xc0, 0xd8, 0x2b, 0x7d, 0xa4, + 0x85, 0xfa, 0x51, 0xa6, 0x2a, 0x16, 0xe7, 0xf9, 0xce, 0x99, 0xd4, 0xa9, 0x5b, 0x50, 0xc9, 0x77, + 0xda, 0xd4, 0x47, 0x56, 0x50, 0xe1, 0x5b, 0x89, 0xe6, 0x82, 0xce, 0x00, 0x6e, 0x4d, 0x78, 0x9b, + 0xbe, 0x58, 0x71, 0x65, 0x3f, 0x7d, 0xa3, 0xbd, 0x12, 0xde, 0xbf, 0xc9, 0x95, 0xfd, 0xf7, 0x68, + 0x29, 0x8a, 0x3b, 0x7f, 0x94, 0x60, 0xfe, 0x83, 0x85, 0x4a, 0x3c, 0xa8, 0xe4, 0x75, 0x2b, 0x61, + 0xdd, 0xf2, 0x47, 0xbb, 0x12, 0xb3, 0x2f, 0x4e, 0x97, 0x50, 0x93, 0x8e, 0x9f, 0x6d, 0xcf, 0xbb, + 0x91, 0xc8, 0xc3, 0x50, 0xfa, 0xcc, 0x97, 0x69, 0x6c, 0xb2, 0xab, 0x36, 0x87, 0x86, 0x6d, 0x8b, + 0x77, 0x2d, 0x6c, 0x6f, 0x70, 0x91, 0xab, 0x83, 0x77, 0xf9, 0x58, 0x6a, 0x5d, 0x50, 0x0f, 0x83, + 0x77, 0xc2, 0x7e, 0xe2, 0xd9, 0x3b, 0x79, 0x22, 0x78, 0xe2, 0x68, 0xee, 0xc6, 0xd5, 0x23, 0x7e, + 0xf6, 0x83, 0xe0, 0x89, 0xe5, 0xec, 0x2c, 0xfd, 0x92, 0x7d, 0x45, 0x64, 0x79, 0x33, 0xfc, 0x97, + 0xf3, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xe9, 0x63, 0x09, 0x14, 0xf5, 0x0c, 0x00, 0x00, } diff --git a/ui/metrics/metrics_proto/metrics.proto b/ui/metrics/metrics_proto/metrics.proto index 91d8dd9b7..b284bf982 100644 --- a/ui/metrics/metrics_proto/metrics.proto +++ b/ui/metrics/metrics_proto/metrics.proto @@ -116,6 +116,13 @@ message BuildConfig { optional bool use_rbe = 2; optional bool force_use_goma = 3; + + // Whether the Bazel is acting as the Ninja executor for this build. + optional bool bazel_as_ninja = 4; + + // Whether build is occurring in a mixed build mode, where Bazel maintains the + // definition and build of some modules in cooperation with Soong. + optional bool bazel_mixed_build = 5; } message SystemResourceInfo { |