// Copyright 2015 Google Inc. All rights reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package android import ( "encoding" "encoding/json" "fmt" "reflect" "runtime" "sort" "strings" "android/soong/bazel" "android/soong/starlark_fmt" "github.com/google/blueprint" "github.com/google/blueprint/bootstrap" "github.com/google/blueprint/proptools" ) /* Example blueprints file containing all variant property groups, with comment listing what type of variants get properties in that group: module { arch: { arm: { // Host or device variants with arm architecture }, arm64: { // Host or device variants with arm64 architecture }, x86: { // Host or device variants with x86 architecture }, x86_64: { // Host or device variants with x86_64 architecture }, }, multilib: { lib32: { // Host or device variants for 32-bit architectures }, lib64: { // Host or device variants for 64-bit architectures }, }, target: { android: { // Device variants (implies Bionic) }, host: { // Host variants }, bionic: { // Bionic (device and host) variants }, linux_bionic: { // Bionic host variants }, linux: { // Bionic (device and host) and Linux glibc variants }, linux_glibc: { // Linux host variants (using non-Bionic libc) }, darwin: { // Darwin host variants }, windows: { // Windows host variants }, not_windows: { // Non-windows host variants }, android_arm: { // Any _ combination restricts to that os and arch }, }, } */ // An Arch indicates a single CPU architecture. type Arch struct { // The type of the architecture (arm, arm64, x86, or x86_64). ArchType ArchType // The variant of the architecture, for example "armv7-a" or "armv7-a-neon" for arm. ArchVariant string // The variant of the CPU, for example "cortex-a53" for arm64. CpuVariant string // The list of Android app ABIs supported by the CPU architecture, for example "arm64-v8a". Abi []string // The list of arch-specific features supported by the CPU architecture, for example "neon". ArchFeatures []string } // String returns the Arch as a string. The value is used as the name of the variant created // by archMutator. func (a Arch) String() string { s := a.ArchType.String() if a.ArchVariant != "" { s += "_" + a.ArchVariant } if a.CpuVariant != "" { s += "_" + a.CpuVariant } return s } // ArchType is used to define the 4 supported architecture types (arm, arm64, x86, x86_64), as // well as the "common" architecture used for modules that support multiple architectures, for // example Java modules. type ArchType struct { // Name is the name of the architecture type, "arm", "arm64", "x86", or "x86_64". Name string // Field is the name of the field used in properties that refer to the architecture, e.g. "Arm64". Field string // Multilib is either "lib32" or "lib64" for 32-bit or 64-bit architectures. Multilib string } // String returns the name of the ArchType. func (a ArchType) String() string { return a.Name } const COMMON_VARIANT = "common" var ( archTypeList []ArchType Arm = newArch("arm", "lib32") Arm64 = newArch("arm64", "lib64") Riscv64 = newArch("riscv64", "lib64") X86 = newArch("x86", "lib32") X86_64 = newArch("x86_64", "lib64") Common = ArchType{ Name: COMMON_VARIANT, } ) var archTypeMap = map[string]ArchType{} func newArch(name, multilib string) ArchType { archType := ArchType{ Name: name, Field: proptools.FieldNameForProperty(name), Multilib: multilib, } archTypeList = append(archTypeList, archType) archTypeMap[name] = archType return archType } // ArchTypeList returns a slice copy of the 4 supported ArchTypes for arm, // arm64, x86 and x86_64. func ArchTypeList() []ArchType { return append([]ArchType(nil), archTypeList...) } // MarshalText allows an ArchType to be serialized through any encoder that supports // encoding.TextMarshaler. func (a ArchType) MarshalText() ([]byte, error) { return []byte(a.String()), nil } var _ encoding.TextMarshaler = ArchType{} // UnmarshalText allows an ArchType to be deserialized through any decoder that supports // encoding.TextUnmarshaler. func (a *ArchType) UnmarshalText(text []byte) error { if u, ok := archTypeMap[string(text)]; ok { *a = u return nil } return fmt.Errorf("unknown ArchType %q", text) } var _ encoding.TextUnmarshaler = &ArchType{} // OsClass is an enum that describes whether a variant of a module runs on the host, on the device, // or is generic. type OsClass int const ( // Generic is used for variants of modules that are not OS-specific. Generic OsClass = iota // Device is used for variants of modules that run on the device. Device // Host is used for variants of modules that run on the host. Host ) // String returns the OsClass as a string. func (class OsClass) String() string { switch class { case Generic: return "generic" case Device: return "device" case Host: return "host" default: panic(fmt.Errorf("unknown class %d", class)) } } // OsType describes an OS variant of a module. type OsType struct { // Name is the name of the OS. It is also used as the name of the property in Android.bp // files. Name string // Field is the name of the OS converted to an exported field name, i.e. with the first // character capitalized. Field string // Class is the OsClass of the OS. Class OsClass // DefaultDisabled is set when the module variants for the OS should not be created unless // the module explicitly requests them. This is used to limit Windows cross compilation to // only modules that need it. DefaultDisabled bool } // String returns the name of the OsType. func (os OsType) String() string { return os.Name } // Bionic returns true if the OS uses the Bionic libc runtime, i.e. if the OS is Android or // is Linux with Bionic. func (os OsType) Bionic() bool { return os == Android || os == LinuxBionic } // Linux returns true if the OS uses the Linux kernel, i.e. if the OS is Android or is Linux // with or without the Bionic libc runtime. func (os OsType) Linux() bool { return os == Android || os == Linux || os == LinuxBionic || os == LinuxMusl } // newOsType constructs an OsType and adds it to the global lists. func newOsType(name string, class OsClass, defDisabled bool, archTypes ...ArchType) OsType { checkCalledFromInit() os := OsType{ Name: name, Field: proptools.FieldNameForProperty(name), Class: class, DefaultDisabled: defDisabled, } osTypeList = append(osTypeList, os) if _, found := commonTargetMap[name]; found { panic(fmt.Errorf("Found Os type duplicate during OsType registration: %q", name)) } else { commonTargetMap[name] = Target{Os: os, Arch: CommonArch} } osArchTypeMap[os] = archTypes return os } // osByName returns the OsType that has the given name, or NoOsType if none match. func osByName(name string) OsType { for _, os := range osTypeList { if os.Name == name { return os } } return NoOsType } var ( // osTypeList contains a list of all the supported OsTypes, including ones not supported // by the current build host or the target device. osTypeList []OsType // commonTargetMap maps names of OsTypes to the corresponding common Target, i.e. the // Target with the same OsType and the common ArchType. commonTargetMap = make(map[string]Target) // osArchTypeMap maps OsTypes to the list of supported ArchTypes for that OS. osArchTypeMap = map[OsType][]ArchType{} // NoOsType is a placeholder for when no OS is needed. NoOsType OsType // Linux is the OS for the Linux kernel plus the glibc runtime. Linux = newOsType("linux_glibc", Host, false, X86, X86_64) // LinuxMusl is the OS for the Linux kernel plus the musl runtime. LinuxMusl = newOsType("linux_musl", Host, false, X86, X86_64, Arm64, Arm) // Darwin is the OS for MacOS/Darwin host machines. Darwin = newOsType("darwin", Host, false, Arm64, X86_64) // LinuxBionic is the OS for the Linux kernel plus the Bionic libc runtime, but without the // rest of Android. LinuxBionic = newOsType("linux_bionic", Host, false, Arm64, X86_64) // Windows the OS for Windows host machines. Windows = newOsType("windows", Host, true, X86, X86_64) // Android is the OS for target devices that run all of Android, including the Linux kernel // and the Bionic libc runtime. Android = newOsType("android", Device, false, Arm, Arm64, Riscv64, X86, X86_64) // CommonOS is a pseudo OSType for a common OS variant, which is OsType agnostic and which // has dependencies on all the OS variants. CommonOS = newOsType("common_os", Generic, false) // CommonArch is the Arch for all modules that are os-specific but not arch specific, // for example most Java modules. CommonArch = Arch{ArchType: Common} ) // OsTypeList returns a slice copy of the supported OsTypes. func OsTypeList() []OsType { return append([]OsType(nil), osTypeList...) } // Target specifies the OS and architecture that a module is being compiled for. type Target struct { // Os the OS that the module is being compiled for (e.g. "linux_glibc", "android"). Os OsType // Arch is the architecture that the module is being compiled for. Arch Arch // NativeBridge is NativeBridgeEnabled if the architecture is supported using NativeBridge // (i.e. arm on x86) for this device. NativeBridge NativeBridgeSupport // NativeBridgeHostArchName is the name of the real architecture that is used to implement // the NativeBridge architecture. For example, for arm on x86 this would be "x86". NativeBridgeHostArchName string // NativeBridgeRelativePath is the name of the subdirectory that will contain NativeBridge // libraries and binaries. NativeBridgeRelativePath string // HostCross is true when the target cannot run natively on the current build host. // For example, linux_glibc_x86 returns true on a regular x86/i686/Linux machines, but returns false // on Mac (different OS), or on 64-bit only i686/Linux machines (unsupported arch). HostCross bool } // NativeBridgeSupport is an enum that specifies if a Target supports NativeBridge. type NativeBridgeSupport bool const ( NativeBridgeDisabled NativeBridgeSupport = false NativeBridgeEnabled NativeBridgeSupport = true ) // String returns the OS and arch variations used for the Target. func (target Target) String() string { return target.OsVariation() + "_" + target.ArchVariation() } // OsVariation returns the name of the variation used by the osMutator for the Target. func (target Target) OsVariation() string { return target.Os.String() } // ArchVariation returns the name of the variation used by the archMutator for the Target. func (target Target) ArchVariation() string { var variation string if target.NativeBridge { variation = "native_bridge_" } variation += target.Arch.String() return variation } // Variations returns a list of blueprint.Variations for the osMutator and archMutator for the // Target. func (target Target) Variations() []blueprint.Variation { return []blueprint.Variation{ {Mutator: "os", Variation: target.OsVariation()}, {Mutator: "arch", Variation: target.ArchVariation()}, } } // osMutator splits an arch-specific module into a variant for each OS that is enabled for the // module. It uses the HostOrDevice value passed to InitAndroidArchModule and the // device_supported and host_supported properties to determine which OsTypes are enabled for this // module, then searches through the Targets to determine which have enabled Targets for this // module. func osMutator(bpctx blueprint.BottomUpMutatorContext) { var module Module var ok bool if module, ok = bpctx.Module().(Module); !ok { // The module is not a Soong module, it is a Blueprint module. if bootstrap.IsBootstrapModule(bpctx.Module()) { // Bootstrap Go modules are always the build OS or linux bionic. config := bpctx.Config().(Config) osNames := []string{config.BuildOSTarget.OsVariation()} for _, hostCrossTarget := range config.Targets[LinuxBionic] { if hostCrossTarget.Arch.ArchType == config.BuildOSTarget.Arch.ArchType { osNames = append(osNames, hostCrossTarget.OsVariation()) } } osNames = FirstUniqueStrings(osNames) bpctx.CreateVariations(osNames...) } return } // Bootstrap Go module support above requires this mutator to be a // blueprint.BottomUpMutatorContext because android.BottomUpMutatorContext // filters out non-Soong modules. Now that we've handled them, create a // normal android.BottomUpMutatorContext. mctx := bottomUpMutatorContextFactory(bpctx, module, false, false) base := module.base() // Nothing to do for modules that are not architecture specific (e.g. a genrule). if !base.ArchSpecific() { return } // Collect a list of OSTypes supported by this module based on the HostOrDevice value // passed to InitAndroidArchModule and the device_supported and host_supported properties. var moduleOSList []OsType for _, os := range osTypeList { for _, t := range mctx.Config().Targets[os] { if base.supportsTarget(t) { moduleOSList = append(moduleOSList, os) break } } } // If there are no supported OSes then disable the module. if len(moduleOSList) == 0 { base.Disable() return } // Convert the list of supported OsTypes to the variation names. osNames := make([]string, len(moduleOSList)) for i, os := range moduleOSList { osNames[i] = os.String() } createCommonOSVariant := base.commonProperties.CreateCommonOSVariant if createCommonOSVariant { // A CommonOS variant was requested so add it to the list of OS variants to // create. It needs to be added to the end because it needs to depend on the // the other variants in the list returned by CreateVariations(...) and inter // variant dependencies can only be created from a later variant in that list to // an earlier one. That is because variants are always processed in the order in // which they are returned from CreateVariations(...). osNames = append(osNames, CommonOS.Name) moduleOSList = append(moduleOSList, CommonOS) } // Create the variations, annotate each one with which OS it was created for, and // squash the appropriate OS-specific properties into the top level properties. modules := mctx.CreateVariations(osNames...) for i, m := range modules { m.base().commonProperties.CompileOS = moduleOSList[i] m.base().setOSProperties(mctx) } if createCommonOSVariant { // A CommonOS variant was requested so add dependencies from it (the last one in // the list) to the OS type specific variants. last := len(modules) - 1 commonOSVariant := modules[last] commonOSVariant.base().commonProperties.CommonOSVariant = true for _, module := range modules[0:last] { // Ignore modules that are enabled. Note, this will only avoid adding // dependencies on OsType variants that are explicitly disabled in their // properties. The CommonOS variant will still depend on disabled variants // if they are disabled afterwards, e.g. in archMutator if if module.Enabled() { mctx.AddInterVariantDependency(commonOsToOsSpecificVariantTag, commonOSVariant, module) } } } } type archDepTag struct { blueprint.BaseDependencyTag name string } // Identifies the dependency from CommonOS variant to the os specific variants. var commonOsToOsSpecificVariantTag = archDepTag{name: "common os to os specific"} // Get the OsType specific variants for the current CommonOS variant. // // The returned list will only contain enabled OsType specific variants of the // module referenced in the supplied context. An empty list is returned if there // are no enabled variants or the supplied context is not for an CommonOS // variant. func GetOsSpecificVariantsOfCommonOSVariant(mctx BaseModuleContext) []Module { var variants []Module mctx.VisitDirectDeps(func(m Module) { if mctx.OtherModuleDependencyTag(m) == commonOsToOsSpecificVariantTag { if m.Enabled() { variants = append(variants, m) } } }) return variants } var DarwinUniversalVariantTag = archDepTag{name: "darwin universal binary"} // archMutator splits a module into a variant for each Target requested by the module. Target selection // for a module is in three levels, OsClass, multilib, and then Target. // OsClass selection is determined by: // - The HostOrDeviceSupported value passed in to InitAndroidArchModule by the module type factory, which selects // whether the module type can compile for host, device or both. // - The host_supported and device_supported properties on the module. // // If host is supported for the module, the Host and HostCross OsClasses are selected. If device is supported // for the module, the Device OsClass is selected. // Within each selected OsClass, the multilib selection is determined by: // - The compile_multilib property if it set (which may be overridden by target.android.compile_multilib or // target.host.compile_multilib). // - The default multilib passed to InitAndroidArchModule if compile_multilib was not set. // // Valid multilib values include: // // "both": compile for all Targets supported by the OsClass (generally x86_64 and x86, or arm64 and arm). // "first": compile for only a single preferred Target supported by the OsClass. This is generally x86_64 or arm64, // but may be arm for a 32-bit only build. // "32": compile for only a single 32-bit Target supported by the OsClass. // "64": compile for only a single 64-bit Target supported by the OsClass. // "common": compile a for a single Target that will work on all Targets supported by the OsClass (for example Java). // "common_first": compile a for a Target that will work on all Targets supported by the OsClass // (same as "common"), plus a second Target for the preferred Target supported by the OsClass // (same as "first"). This is used for java_binary that produces a common .jar and a wrapper // executable script. // // Once the list of Targets is determined, the module is split into a variant for each Target. // // Modules can be initialized with InitAndroidMultiTargetsArchModule, in which case they will be split by OsClass, // but will have a common Target that is expected to handle all other selected Targets via ctx.MultiTargets(). func archMutator(bpctx blueprint.BottomUpMutatorContext) { var module Module var ok bool if module, ok = bpctx.Module().(Module); !ok { if bootstrap.IsBootstrapModule(bpctx.Module()) { // Bootstrap Go modules are always the build architecture. bpctx.CreateVariations(bpctx.Config().(Config).BuildOSTarget.ArchVariation()) } return } // Bootstrap Go module support above requires this mutator to be a // blueprint.BottomUpMutatorContext because android.BottomUpMutatorContext // filters out non-Soong modules. Now that we've handled them, create a // normal android.BottomUpMutatorContext. mctx := bottomUpMutatorContextFactory(bpctx, module, false, false) base := module.base() if !base.ArchSpecific() { return } os := base.commonProperties.CompileOS if os == CommonOS { // Make sure that the target related properties are initialized for the // CommonOS variant. addTargetProperties(module, commonTargetMap[os.Name], nil, true) // Do not create arch specific variants for the CommonOS variant. return } osTargets := mctx.Config().Targets[os] image := base.commonProperties.ImageVariation // Filter NativeBridge targets unless they are explicitly supported. // Skip creating native bridge variants for non-core modules. if os == Android && !(base.IsNativeBridgeSupported() && image == CoreVariation) { var targets []Target for _, t := range osTargets { if !t.NativeBridge { targets = append(targets, t) } } osTargets = targets } // only the primary arch in the ramdisk / vendor_ramdisk / recovery partition if os == Android && (module.InstallInRecovery() || module.InstallInRamdisk() || module.InstallInVendorRamdisk() || module.InstallInDebugRamdisk()) { osTargets = []Target{osTargets[0]} } // Windows builds always prefer 32-bit prefer32 := os == Windows // Determine the multilib selection for this module. ignorePrefer32OnDevice := mctx.Config().IgnorePrefer32OnDevice() multilib, extraMultilib := decodeMultilib(base, os, ignorePrefer32OnDevice) // Convert the multilib selection into a list of Targets. targets, err := decodeMultilibTargets(multilib, osTargets, prefer32) if err != nil { mctx.ModuleErrorf("%s", err.Error()) } // If there are no supported targets disable the module. if len(targets) == 0 { base.Disable() return } // If the module is using extraMultilib, decode the extraMultilib selection into // a separate list of Targets. var multiTargets []Target if extraMultilib != "" { multiTargets, err = decodeMultilibTargets(extraMultilib, osTargets, prefer32) if err != nil { mctx.ModuleErrorf("%s", err.Error()) } multiTargets = filterHostCross(multiTargets, targets[0].HostCross) } // Recovery is always the primary architecture, filter out any other architectures. // Common arch is also allowed if image == RecoveryVariation { primaryArch := mctx.Config().DevicePrimaryArchType() targets = filterToArch(targets, primaryArch, Common) multiTargets = filterToArch(multiTargets, primaryArch, Common) } // If there are no supported targets disable the module. if len(targets) == 0 { base.Disable() return } // Convert the targets into a list of arch variation names. targetNames := make([]string, len(targets)) for i, target := range targets { targetNames[i] = target.ArchVariation() } // Create the variations, annotate each one with which Target it was created for, and // squash the appropriate arch-specific properties into the top level properties. modules := mctx.CreateVariations(targetNames...) for i, m := range modules { addTargetProperties(m, targets[i], multiTargets, i == 0) m.base().setArchProperties(mctx) // Install support doesn't understand Darwin+Arm64 if os == Darwin && targets[i].HostCross { m.base().commonProperties.SkipInstall = true } } // Create a dependency for Darwin Universal binaries from the primary to secondary // architecture. The module itself will be responsible for calling lipo to merge the outputs. if os == Darwin { if multilib == "darwin_universal" && len(modules) == 2 { mctx.AddInterVariantDependency(DarwinUniversalVariantTag, modules[1], modules[0]) } else if multilib == "darwin_universal_common_first" && len(modules) == 3 { mctx.AddInterVariantDependency(DarwinUniversalVariantTag, modules[2], modules[1]) } } } // addTargetProperties annotates a variant with the Target is is being compiled for, the list // of additional Targets it is supporting (if any), and whether it is the primary Target for // the module. func addTargetProperties(m Module, target Target, multiTargets []Target, primaryTarget bool) { m.base().commonProperties.CompileTarget = target m.base().commonProperties.CompileMultiTargets = multiTargets m.base().commonProperties.CompilePrimary = primaryTarget } // decodeMultilib returns the appropriate compile_multilib property for the module, or the default // multilib from the factory's call to InitAndroidArchModule if none was set. For modules that // called InitAndroidMultiTargetsArchModule it always returns "common" for multilib, and returns // the actual multilib in extraMultilib. func decodeMultilib(base *ModuleBase, os OsType, ignorePrefer32OnDevice bool) (multilib, extraMultilib string) { // First check the "android.compile_multilib" or "host.compile_multilib" properties. switch os.Class { case Device: multilib = String(base.commonProperties.Target.Android.Compile_multilib) case Host: multilib = String(base.commonProperties.Target.Host.Compile_multilib) } // If those aren't set, try the "compile_multilib" property. if multilib == "" { multilib = String(base.commonProperties.Compile_multilib) } // If that wasn't set, use the default multilib set by the factory. if multilib == "" { multilib = base.commonProperties.Default_multilib } // If a device is configured with multiple targets, this option // force all device targets that prefer32 to be compiled only as // the first target. if ignorePrefer32OnDevice && os.Class == Device && (multilib == "prefer32" || multilib == "first_prefer32") { multilib = "first" } if base.commonProperties.UseTargetVariants { // Darwin has the concept of "universal binaries" which is implemented in Soong by // building both x86_64 and arm64 variants, and having select module types know how to // merge the outputs of their corresponding variants together into a final binary. Most // module types don't need to understand this logic, as we only build a small portion // of the tree for Darwin, and only module types writing macho files need to do the // merging. // // This logic is not enabled for: // "common", as it's not an arch-specific variant // "32", as Darwin never has a 32-bit variant // !UseTargetVariants, as the module has opted into handling the arch-specific logic on // its own. if os == Darwin && multilib != "common" && multilib != "32" { if multilib == "common_first" { multilib = "darwin_universal_common_first" } else { multilib = "darwin_universal" } } return multilib, "" } else { // For app modules a single arch variant will be created per OS class which is expected to handle all the // selected arches. Return the common-type as multilib and any Android.bp provided multilib as extraMultilib if multilib == base.commonProperties.Default_multilib { multilib = "first" } return base.commonProperties.Default_multilib, multilib } } // filterToArch takes a list of Targets and an ArchType, and returns a modified list that contains // only Targets that have the specified ArchTypes. func filterToArch(targets []Target, archs ...ArchType) []Target { for i := 0; i < len(targets); i++ { found := false for _, arch := range archs { if targets[i].Arch.ArchType == arch { found = true break } } if !found { targets = append(targets[:i], targets[i+1:]...) i-- } } return targets } // filterHostCross takes a list of Targets and a hostCross value, and returns a modified list // that contains only Targets that have the specified HostCross. func filterHostCross(targets []Target, hostCross bool) []Target { for i := 0; i < len(targets); i++ { if targets[i].HostCross != hostCross { targets = append(targets[:i], targets[i+1:]...) i-- } } return targets } // archPropRoot is a struct type used as the top level of the arch-specific properties. It // contains the "arch", "multilib", and "target" property structs. It is used to split up the // property structs to limit how much is allocated when a single arch-specific property group is // used. The types are interface{} because they will hold instances of runtime-created types. type archPropRoot struct { Arch, Multilib, Target interface{} } // archPropTypeDesc holds the runtime-created types for the property structs to instantiate to // create an archPropRoot property struct. type archPropTypeDesc struct { arch, multilib, target reflect.Type } // createArchPropTypeDesc takes a reflect.Type that is either a struct or a pointer to a struct, and // returns lists of reflect.Types that contains the arch-variant properties inside structs for each // arch, multilib and target property. // // This is a relatively expensive operation, so the results are cached in the global // archPropTypeMap. It is constructed entirely based on compile-time data, so there is no need // to isolate the results between multiple tests running in parallel. func createArchPropTypeDesc(props reflect.Type) []archPropTypeDesc { // Each property struct shard will be nested many times under the runtime generated arch struct, // which can hit the limit of 64kB for the name of runtime generated structs. They are nested // 97 times now, which may grow in the future, plus there is some overhead for the containing // type. This number may need to be reduced if too many are added, but reducing it too far // could cause problems if a single deeply nested property no longer fits in the name. const maxArchTypeNameSize = 500 // Convert the type to a new set of types that contains only the arch-specific properties // (those that are tagged with `android:"arch_variant"`), and sharded into multiple types // to keep the runtime-generated names under the limit. propShards, _ := proptools.FilterPropertyStructSharded(props, maxArchTypeNameSize, filterArchStruct) // If the type has no arch-specific properties there is nothing to do. if len(propShards) == 0 { return nil } var ret []archPropTypeDesc for _, props := range propShards { // variantFields takes a list of variant property field names and returns a list the // StructFields with the names and the type of the current shard. variantFields := func(names []string) []reflect.StructField { ret := make([]reflect.StructField, len(names)) for i, name := range names { ret[i].Name = name ret[i].Type = props } return ret } // Create a type that contains the properties in this shard repeated for each // architecture, architecture variant, and architecture feature. archFields := make([]reflect.StructField, len(archTypeList)) for i, arch := range archTypeList { var variants []string for _, archVariant := range archVariants[arch] { archVariant := variantReplacer.Replace(archVariant) variants = append(variants, proptools.FieldNameForProperty(archVariant)) } for _, cpuVariant := range cpuVariants[arch] { cpuVariant := variantReplacer.Replace(cpuVariant) variants = append(variants, proptools.FieldNameForProperty(cpuVariant)) } for _, feature := range archFeatures[arch] { feature := variantReplacer.Replace(feature) variants = append(variants, proptools.FieldNameForProperty(feature)) } // Create the StructFields for each architecture variant architecture feature // (e.g. "arch.arm.cortex-a53" or "arch.arm.neon"). fields := variantFields(variants) // Create the StructField for the architecture itself (e.g. "arch.arm"). The special // "BlueprintEmbed" name is used by Blueprint to put the properties in the // parent struct. fields = append([]reflect.StructField{{ Name: "BlueprintEmbed", Type: props, Anonymous: true, }}, fields...) archFields[i] = reflect.StructField{ Name: arch.Field, Type: reflect.StructOf(fields), } } // Create the type of the "arch" property struct for this shard. archType := reflect.StructOf(archFields) // Create the type for the "multilib" property struct for this shard, containing the // "multilib.lib32" and "multilib.lib64" property structs. multilibType := reflect.StructOf(variantFields([]string{"Lib32", "Lib64"})) // Start with a list of the special targets targets := []string{ "Host", "Android64", "Android32", "Bionic", "Glibc", "Musl", "Linux", "Host_linux", "Not_windows", "Arm_on_x86", "Arm_on_x86_64", "Native_bridge", } for _, os := range osTypeList { // Add all the OSes. targets = append(targets, os.Field) // Add the OS/Arch combinations, e.g. "android_arm64". for _, archType := range osArchTypeMap[os] { targets = append(targets, GetCompoundTargetField(os, archType)) // Also add the special "linux_", "bionic_" , "glibc_", and // "musl_" property structs. if os.Linux() { target := "Linux_" + archType.Name if !InList(target, targets) { targets = append(targets, target) } } if os.Linux() && os.Class == Host { target := "Host_linux_" + archType.Name if !InList(target, targets) { targets = append(targets, target) } } if os.Bionic() { target := "Bionic_" + archType.Name if !InList(target, targets) { targets = append(targets, target) } } if os == Linux { target := "Glibc_" + archType.Name if !InList(target, targets) { targets = append(targets, target) } } if os == LinuxMusl { target := "Musl_" + archType.Name if !InList(target, targets) { targets = append(targets, target) } } } } // Create the type for the "target" property struct for this shard. targetType := reflect.StructOf(variantFields(targets)) // Return a descriptor of the 3 runtime-created types. ret = append(ret, archPropTypeDesc{ arch: reflect.PtrTo(archType), multilib: reflect.PtrTo(multilibType), target: reflect.PtrTo(targetType), }) } return ret } // variantReplacer converts architecture variant or architecture feature names into names that // are valid for an Android.bp file. var variantReplacer = strings.NewReplacer("-", "_", ".", "_") // filterArchStruct returns true if the given field is an architecture specific property. func filterArchStruct(field reflect.StructField, prefix string) (bool, reflect.StructField) { if proptools.HasTag(field, "android", "arch_variant") { // The arch_variant field isn't necessary past this point // Instead of wasting space, just remove it. Go also has a // 16-bit limit on structure name length. The name is constructed // based on the Go source representation of the structure, so // the tag names count towards that length. androidTag := field.Tag.Get("android") values := strings.Split(androidTag, ",") if string(field.Tag) != `android:"`+strings.Join(values, ",")+`"` { panic(fmt.Errorf("unexpected tag format %q", field.Tag)) } // these tags don't need to be present in the runtime generated struct type. values = RemoveListFromList(values, []string{"arch_variant", "variant_prepend", "path"}) if len(values) > 0 { panic(fmt.Errorf("unknown tags %q in field %q", values, prefix+field.Name)) } field.Tag = `` return true, field } return false, field } // archPropTypeMap contains a cache of the results of createArchPropTypeDesc for each type. It is // shared across all Contexts, but is constructed based only on compile-time information so there // is no risk of contaminating one Context with data from another. var archPropTypeMap OncePer // initArchModule adds the architecture-specific property structs to a Module. func initArchModule(m Module) { base := m.base() if len(base.archProperties) != 0 { panic(fmt.Errorf("module %s already has archProperties", m.Name())) } getStructType := func(properties interface{}) reflect.Type { propertiesValue := reflect.ValueOf(properties) t := propertiesValue.Type() if propertiesValue.Kind() != reflect.Ptr { panic(fmt.Errorf("properties must be a pointer to a struct, got %T", propertiesValue.Interface())) } propertiesValue = propertiesValue.Elem() if propertiesValue.Kind() != reflect.Struct { panic(fmt.Errorf("properties must be a pointer to a struct, got a pointer to %T", propertiesValue.Interface())) } return t } for _, properties := range m.GetProperties() { t := getStructType(properties) // Get or create the arch-specific property struct types for this property struct type. archPropTypes := archPropTypeMap.Once(NewCustomOnceKey(t), func() interface{} { return createArchPropTypeDesc(t) }).([]archPropTypeDesc) // Instantiate one of each arch-specific property struct type and add it to the // properties for the Module. var archProperties []interface{} for _, t := range archPropTypes { archProperties = append(archProperties, &archPropRoot{ Arch: reflect.Zero(t.arch).Interface(), Multilib: reflect.Zero(t.multilib).Interface(), Target: reflect.Zero(t.target).Interface(), }) } base.archProperties = append(base.archProperties, archProperties) m.AddProperties(archProperties...) } } func maybeBlueprintEmbed(src reflect.Value) reflect.Value { // If the value of the field is a struct (as opposed to a pointer to a struct) then step // into the BlueprintEmbed field. if src.Kind() == reflect.Struct { return src.FieldByName("BlueprintEmbed") } else { return src } } // Merges the property struct in srcValue into dst. func mergePropertyStruct(ctx ArchVariantContext, dst interface{}, srcValue reflect.Value) { src := maybeBlueprintEmbed(srcValue).Interface() // order checks the `android:"variant_prepend"` tag to handle properties where the // arch-specific value needs to come before the generic value, for example for lists of // include directories. order := func(property string, dstField, srcField reflect.StructField, dstValue, srcValue interface{}) (proptools.Order, error) { if proptools.HasTag(dstField, "android", "variant_prepend") { return proptools.Prepend, nil } else { return proptools.Append, nil } } // Squash the located property struct into the destination property struct. err := proptools.ExtendMatchingProperties([]interface{}{dst}, src, nil, order) if err != nil { if propertyErr, ok := err.(*proptools.ExtendPropertyError); ok { ctx.PropertyErrorf(propertyErr.Property, "%s", propertyErr.Err.Error()) } else { panic(err) } } } // Returns the immediate child of the input property struct that corresponds to // the sub-property "field". func getChildPropertyStruct(ctx ArchVariantContext, src reflect.Value, field, userFriendlyField string) (reflect.Value, bool) { // Step into non-nil pointers to structs in the src value. if src.Kind() == reflect.Ptr { if src.IsNil() { return reflect.Value{}, false } src = src.Elem() } // Find the requested field in the src struct. child := src.FieldByName(proptools.FieldNameForProperty(field)) if !child.IsValid() { ctx.ModuleErrorf("field %q does not exist", userFriendlyField) return reflect.Value{}, false } if child.IsZero() { return reflect.Value{}, false } return child, true } // Squash the appropriate OS-specific property structs into the matching top level property structs // based on the CompileOS value that was annotated on the variant. func (m *ModuleBase) setOSProperties(ctx BottomUpMutatorContext) { os := m.commonProperties.CompileOS for i := range m.archProperties { genProps := m.GetProperties()[i] if m.archProperties[i] == nil { continue } for _, archProperties := range m.archProperties[i] { archPropValues := reflect.ValueOf(archProperties).Elem() targetProp := archPropValues.FieldByName("Target").Elem() // Handle host-specific properties in the form: // target: { // host: { // key: value, // }, // }, if os.Class == Host { field := "Host" prefix := "target.host" if hostProperties, ok := getChildPropertyStruct(ctx, targetProp, field, prefix); ok { mergePropertyStruct(ctx, genProps, hostProperties) } } // Handle target OS generalities of the form: // target: { // bionic: { // key: value, // }, // } if os.Linux() { field := "Linux" prefix := "target.linux" if linuxProperties, ok := getChildPropertyStruct(ctx, targetProp, field, prefix); ok { mergePropertyStruct(ctx, genProps, linuxProperties) } } if os.Linux() && os.Class == Host { field := "Host_linux" prefix := "target.host_linux" if linuxProperties, ok := getChildPropertyStruct(ctx, targetProp, field, prefix); ok { mergePropertyStruct(ctx, genProps, linuxProperties) } } if os.Bionic() { field := "Bionic" prefix := "target.bionic" if bionicProperties, ok := getChildPropertyStruct(ctx, targetProp, field, prefix); ok { mergePropertyStruct(ctx, genProps, bionicProperties) } } if os == Linux { field := "Glibc" prefix := "target.glibc" if bionicProperties, ok := getChildPropertyStruct(ctx, targetProp, field, prefix); ok { mergePropertyStruct(ctx, genProps, bionicProperties) } } if os == LinuxMusl { field := "Musl" prefix := "target.musl" if bionicProperties, ok := getChildPropertyStruct(ctx, targetProp, field, prefix); ok { mergePropertyStruct(ctx, genProps, bionicProperties) } } // Handle target OS properties in the form: // target: { // linux_glibc: { // key: value, // }, // not_windows: { // key: value, // }, // android { // key: value, // }, // }, field := os.Field prefix := "target." + os.Name if osProperties, ok := getChildPropertyStruct(ctx, targetProp, field, prefix); ok { mergePropertyStruct(ctx, genProps, osProperties) } if os.Class == Host && os != Windows { field := "Not_windows" prefix := "target.not_windows" if notWindowsProperties, ok := getChildPropertyStruct(ctx, targetProp, field, prefix); ok { mergePropertyStruct(ctx, genProps, notWindowsProperties) } } // Handle 64-bit device properties in the form: // target { // android64 { // key: value, // }, // android32 { // key: value, // }, // }, // WARNING: this is probably not what you want to use in your blueprints file, it selects // options for all targets on a device that supports 64-bit binaries, not just the targets // that are being compiled for 64-bit. Its expected use case is binaries like linker and // debuggerd that need to know when they are a 32-bit process running on a 64-bit device if os.Class == Device { if ctx.Config().Android64() { field := "Android64" prefix := "target.android64" if android64Properties, ok := getChildPropertyStruct(ctx, targetProp, field, prefix); ok { mergePropertyStruct(ctx, genProps, android64Properties) } } else { field := "Android32" prefix := "target.android32" if android32Properties, ok := getChildPropertyStruct(ctx, targetProp, field, prefix); ok { mergePropertyStruct(ctx, genProps, android32Properties) } } } } } } // Returns the struct containing the properties specific to the given // architecture type. These look like this in Blueprint files: // // arch: { // arm64: { // key: value, // }, // }, // // This struct will also contain sub-structs containing to the architecture/CPU // variants and features that themselves contain properties specific to those. func getArchTypeStruct(ctx ArchVariantContext, archProperties interface{}, archType ArchType) (reflect.Value, bool) { archPropValues := reflect.ValueOf(archProperties).Elem() archProp := archPropValues.FieldByName("Arch").Elem() prefix := "arch." + archType.Name return getChildPropertyStruct(ctx, archProp, archType.Name, prefix) } // Returns the struct containing the properties specific to a given multilib // value. These look like this in the Blueprint file: // // multilib: { // lib32: { // key: value, // }, // }, func getMultilibStruct(ctx ArchVariantContext, archProperties interface{}, archType ArchType) (reflect.Value, bool) { archPropValues := reflect.ValueOf(archProperties).Elem() multilibProp := archPropValues.FieldByName("Multilib").Elem() return getChildPropertyStruct(ctx, multilibProp, archType.Multilib, "multilib."+archType.Multilib) } func GetCompoundTargetField(os OsType, arch ArchType) string { return os.Field + "_" + arch.Name } // Returns the structs corresponding to the properties specific to the given // architecture and OS in archProperties. func getArchProperties(ctx BaseMutatorContext, archProperties interface{}, arch Arch, os OsType, nativeBridgeEnabled bool) []reflect.Value { result := make([]reflect.Value, 0) archPropValues := reflect.ValueOf(archProperties).Elem() targetProp := archPropValues.FieldByName("Target").Elem() archType := arch.ArchType if arch.ArchType != Common { archStruct, ok := getArchTypeStruct(ctx, archProperties, arch.ArchType) if ok { result = append(result, archStruct) // Handle arch-variant-specific properties in the form: // arch: { // arm: { // variant: { // key: value, // }, // }, // }, v := variantReplacer.Replace(arch.ArchVariant) if v != "" { prefix := "arch." + archType.Name + "." + v if variantProperties, ok := getChildPropertyStruct(ctx, archStruct, v, prefix); ok { result = append(result, variantProperties) } } // Handle cpu-variant-specific properties in the form: // arch: { // arm: { // variant: { // key: value, // }, // }, // }, if arch.CpuVariant != arch.ArchVariant { c := variantReplacer.Replace(arch.CpuVariant) if c != "" { prefix := "arch." + archType.Name + "." + c if cpuVariantProperties, ok := getChildPropertyStruct(ctx, archStruct, c, prefix); ok { result = append(result, cpuVariantProperties) } } } // Handle arch-feature-specific properties in the form: // arch: { // arm: { // feature: { // key: value, // }, // }, // }, for _, feature := range arch.ArchFeatures { prefix := "arch." + archType.Name + "." + feature if featureProperties, ok := getChildPropertyStruct(ctx, archStruct, feature, prefix); ok { result = append(result, featureProperties) } } } if multilibProperties, ok := getMultilibStruct(ctx, archProperties, archType); ok { result = append(result, multilibProperties) } // Handle combined OS-feature and arch specific properties in the form: // target: { // bionic_x86: { // key: value, // }, // } if os.Linux() { field := "Linux_" + arch.ArchType.Name userFriendlyField := "target.linux_" + arch.ArchType.Name if linuxProperties, ok := getChildPropertyStruct(ctx, targetProp, field, userFriendlyField); ok { result = append(result, linuxProperties) } } if os.Bionic() { field := "Bionic_" + archType.Name userFriendlyField := "target.bionic_" + archType.Name if bionicProperties, ok := getChildPropertyStruct(ctx, targetProp, field, userFriendlyField); ok { result = append(result, bionicProperties) } } // Handle combined OS and arch specific properties in the form: // target: { // linux_glibc_x86: { // key: value, // }, // linux_glibc_arm: { // key: value, // }, // android_arm { // key: value, // }, // android_x86 { // key: value, // }, // }, field := GetCompoundTargetField(os, archType) userFriendlyField := "target." + os.Name + "_" + archType.Name if osArchProperties, ok := getChildPropertyStruct(ctx, targetProp, field, userFriendlyField); ok { result = append(result, osArchProperties) } if os == Linux { field := "Glibc_" + archType.Name userFriendlyField := "target.glibc_" + "_" + archType.Name if osArchProperties, ok := getChildPropertyStruct(ctx, targetProp, field, userFriendlyField); ok { result = append(result, osArchProperties) } } if os == LinuxMusl { field := "Musl_" + archType.Name userFriendlyField := "target.musl_" + "_" + archType.Name if osArchProperties, ok := getChildPropertyStruct(ctx, targetProp, field, userFriendlyField); ok { result = append(result, osArchProperties) } } } // Handle arm on x86 properties in the form: // target { // arm_on_x86 { // key: value, // }, // arm_on_x86_64 { // key: value, // }, // }, if os.Class == Device { if arch.ArchType == X86 && (hasArmAbi(arch) || hasArmAndroidArch(ctx.Config().Targets[Android])) { field := "Arm_on_x86" userFriendlyField := "target.arm_on_x86" if armOnX86Properties, ok := getChildPropertyStruct(ctx, targetProp, field, userFriendlyField); ok { result = append(result, armOnX86Properties) } } if arch.ArchType == X86_64 && (hasArmAbi(arch) || hasArmAndroidArch(ctx.Config().Targets[Android])) { field := "Arm_on_x86_64" userFriendlyField := "target.arm_on_x86_64" if armOnX8664Properties, ok := getChildPropertyStruct(ctx, targetProp, field, userFriendlyField); ok { result = append(result, armOnX8664Properties) } } if os == Android && nativeBridgeEnabled { userFriendlyField := "Native_bridge" prefix := "target.native_bridge" if nativeBridgeProperties, ok := getChildPropertyStruct(ctx, targetProp, userFriendlyField, prefix); ok { result = append(result, nativeBridgeProperties) } } } return result } // Squash the appropriate arch-specific property structs into the matching top level property // structs based on the CompileTarget value that was annotated on the variant. func (m *ModuleBase) setArchProperties(ctx BottomUpMutatorContext) { arch := m.Arch() os := m.Os() for i := range m.archProperties { genProps := m.GetProperties()[i] if m.archProperties[i] == nil { continue } propStructs := make([]reflect.Value, 0) for _, archProperty := range m.archProperties[i] { propStructShard := getArchProperties(ctx, archProperty, arch, os, m.Target().NativeBridge == NativeBridgeEnabled) propStructs = append(propStructs, propStructShard...) } for _, propStruct := range propStructs { mergePropertyStruct(ctx, genProps, propStruct) } } } // determineBuildOS stores the OS and architecture used for host targets used during the build into // config based on the runtime OS and architecture determined by Go and the product configuration. func determineBuildOS(config *config) { config.BuildOS = func() OsType { switch runtime.GOOS { case "linux": if Bool(config.productVariables.HostMusl) { return LinuxMusl } return Linux case "darwin": return Darwin default: panic(fmt.Sprintf("unsupported OS: %s", runtime.GOOS)) } }() config.BuildArch = func() ArchType { switch runtime.GOARCH { case "amd64": return X86_64 default: panic(fmt.Sprintf("unsupported Arch: %s", runtime.GOARCH)) } }() } // Convert the arch product variables into a list of targets for each OsType. func decodeTargetProductVariables(config *config) (map[OsType][]Target, error) { variables := config.productVariables targets := make(map[OsType][]Target) var targetErr error type targetConfig struct { os OsType archName string archVariant *string cpuVariant *string abi []string nativeBridgeEnabled NativeBridgeSupport nativeBridgeHostArchName *string nativeBridgeRelativePath *string } addTarget := func(target targetConfig) { if targetErr != nil { return } arch, err := decodeArch(target.os, target.archName, target.archVariant, target.cpuVariant, target.abi) if err != nil { targetErr = err return } nativeBridgeRelativePathStr := String(target.nativeBridgeRelativePath) nativeBridgeHostArchNameStr := String(target.nativeBridgeHostArchName) // Use guest arch as relative install path by default if target.nativeBridgeEnabled && nativeBridgeRelativePathStr == "" { nativeBridgeRelativePathStr = arch.ArchType.String() } // A target is considered as HostCross if it's a host target which can't run natively on // the currently configured build machine (either because the OS is different or because of // the unsupported arch) hostCross := false if target.os.Class == Host { var osSupported bool if target.os == config.BuildOS { osSupported = true } else if config.BuildOS.Linux() && target.os.Linux() { // LinuxBionic and Linux are compatible osSupported = true } else { osSupported = false } var archSupported bool if arch.ArchType == Common { archSupported = true } else if arch.ArchType.Name == *variables.HostArch { archSupported = true } else if variables.HostSecondaryArch != nil && arch.ArchType.Name == *variables.HostSecondaryArch { archSupported = true } else { archSupported = false } if !osSupported || !archSupported { hostCross = true } } targets[target.os] = append(targets[target.os], Target{ Os: target.os, Arch: arch, NativeBridge: target.nativeBridgeEnabled, NativeBridgeHostArchName: nativeBridgeHostArchNameStr, NativeBridgeRelativePath: nativeBridgeRelativePathStr, HostCross: hostCross, }) } if variables.HostArch == nil { return nil, fmt.Errorf("No host primary architecture set") } // The primary host target, which must always exist. addTarget(targetConfig{os: config.BuildOS, archName: *variables.HostArch, nativeBridgeEnabled: NativeBridgeDisabled}) // An optional secondary host target. if variables.HostSecondaryArch != nil && *variables.HostSecondaryArch != "" { addTarget(targetConfig{os: config.BuildOS, archName: *variables.HostSecondaryArch, nativeBridgeEnabled: NativeBridgeDisabled}) } // Optional cross-compiled host targets, generally Windows. if String(variables.CrossHost) != "" { crossHostOs := osByName(*variables.CrossHost) if crossHostOs == NoOsType { return nil, fmt.Errorf("Unknown cross host OS %q", *variables.CrossHost) } if String(variables.CrossHostArch) == "" { return nil, fmt.Errorf("No cross-host primary architecture set") } // The primary cross-compiled host target. addTarget(targetConfig{os: crossHostOs, archName: *variables.CrossHostArch, nativeBridgeEnabled: NativeBridgeDisabled}) // An optional secondary cross-compiled host target. if variables.CrossHostSecondaryArch != nil && *variables.CrossHostSecondaryArch != "" { addTarget(targetConfig{os: crossHostOs, archName: *variables.CrossHostSecondaryArch, nativeBridgeEnabled: NativeBridgeDisabled}) } } // Optional device targets if variables.DeviceArch != nil && *variables.DeviceArch != "" { // The primary device target. addTarget(targetConfig{ os: Android, archName: *variables.DeviceArch, archVariant: variables.DeviceArchVariant, cpuVariant: variables.DeviceCpuVariant, abi: variables.DeviceAbi, nativeBridgeEnabled: NativeBridgeDisabled, }) // An optional secondary device target. if variables.DeviceSecondaryArch != nil && *variables.DeviceSecondaryArch != "" { addTarget(targetConfig{ os: Android, archName: *variables.DeviceSecondaryArch, archVariant: variables.DeviceSecondaryArchVariant, cpuVariant: variables.DeviceSecondaryCpuVariant, abi: variables.DeviceSecondaryAbi, nativeBridgeEnabled: NativeBridgeDisabled, }) } // An optional NativeBridge device target. if variables.NativeBridgeArch != nil && *variables.NativeBridgeArch != "" { addTarget(targetConfig{ os: Android, archName: *variables.NativeBridgeArch, archVariant: variables.NativeBridgeArchVariant, cpuVariant: variables.NativeBridgeCpuVariant, abi: variables.NativeBridgeAbi, nativeBridgeEnabled: NativeBridgeEnabled, nativeBridgeHostArchName: variables.DeviceArch, nativeBridgeRelativePath: variables.NativeBridgeRelativePath, }) } // An optional secondary NativeBridge device target. if variables.DeviceSecondaryArch != nil && *variables.DeviceSecondaryArch != "" && variables.NativeBridgeSecondaryArch != nil && *variables.NativeBridgeSecondaryArch != "" { addTarget(targetConfig{ os: Android, archName: *variables.NativeBridgeSecondaryArch, archVariant: variables.NativeBridgeSecondaryArchVariant, cpuVariant: variables.NativeBridgeSecondaryCpuVariant, abi: variables.NativeBridgeSecondaryAbi, nativeBridgeEnabled: NativeBridgeEnabled, nativeBridgeHostArchName: variables.DeviceSecondaryArch, nativeBridgeRelativePath: variables.NativeBridgeSecondaryRelativePath, }) } } if targetErr != nil { return nil, targetErr } return targets, nil } // hasArmAbi returns true if arch has at least one arm ABI func hasArmAbi(arch Arch) bool { return PrefixInList(arch.Abi, "arm") } // hasArmAndroidArch returns true if targets has at least // one arm Android arch (possibly native bridged) func hasArmAndroidArch(targets []Target) bool { for _, target := range targets { if target.Os == Android && (target.Arch.ArchType == Arm || target.Arch.ArchType == Arm64) { return true } } return false } // archConfig describes a built-in configuration. type archConfig struct { Arch string `json:"arch"` ArchVariant string `json:"arch_variant"` CpuVariant string `json:"cpu_variant"` Abi []string `json:"abis"` } // getNdkAbisConfig returns the list of archConfigs that are used for building // the API stubs and static libraries that are included in the NDK. func getNdkAbisConfig() []archConfig { return []archConfig{ {"arm64", "armv8-a-branchprot", "", []string{"arm64-v8a"}}, {"arm", "armv7-a-neon", "", []string{"armeabi-v7a"}}, {"riscv64", "", "", []string{"riscv64"}}, {"x86_64", "", "", []string{"x86_64"}}, {"x86", "", "", []string{"x86"}}, } } // getAmlAbisConfig returns a list of archConfigs for the ABIs supported by mainline modules. func getAmlAbisConfig() []archConfig { return []archConfig{ {"arm64", "armv8-a", "", []string{"arm64-v8a"}}, {"arm", "armv7-a-neon", "", []string{"armeabi-v7a"}}, {"x86_64", "", "", []string{"x86_64"}}, {"x86", "", "", []string{"x86"}}, } } // decodeArchSettings converts a list of archConfigs into a list of Targets for the given OsType. func decodeAndroidArchSettings(archConfigs []archConfig) ([]Target, error) { var ret []Target for _, config := range archConfigs { arch, err := decodeArch(Android, config.Arch, &config.ArchVariant, &config.CpuVariant, config.Abi) if err != nil { return nil, err } ret = append(ret, Target{ Os: Android, Arch: arch, }) } return ret, nil } // decodeArch converts a set of strings from product variables into an Arch struct. func decodeArch(os OsType, arch string, archVariant, cpuVariant *string, abi []string) (Arch, error) { // Verify the arch is valid archType, ok := archTypeMap[arch] if !ok { return Arch{}, fmt.Errorf("unknown arch %q", arch) } a := Arch{ ArchType: archType, ArchVariant: String(archVariant), CpuVariant: String(cpuVariant), Abi: abi, } // Convert generic arch variants into the empty string. if a.ArchVariant == a.ArchType.Name || a.ArchVariant == "generic" { a.ArchVariant = "" } // Convert generic CPU variants into the empty string. if a.CpuVariant == a.ArchType.Name || a.CpuVariant == "generic" { a.CpuVariant = "" } if a.ArchVariant != "" { if validArchVariants := archVariants[archType]; !InList(a.ArchVariant, validArchVariants) { return Arch{}, fmt.Errorf("[%q] unknown arch variant %q, support variants: %q", archType, a.ArchVariant, validArchVariants) } } if a.CpuVariant != "" { if validCpuVariants := cpuVariants[archType]; !InList(a.CpuVariant, validCpuVariants) { return Arch{}, fmt.Errorf("[%q] unknown cpu variant %q, support variants: %q", archType, a.CpuVariant, validCpuVariants) } } // Filter empty ABIs out of the list. for i := 0; i < len(a.Abi); i++ { if a.Abi[i] == "" { a.Abi = append(a.Abi[:i], a.Abi[i+1:]...) i-- } } // Set ArchFeatures from the arch type. for Android OS, other os-es do not specify features if os == Android { if featureMap, ok := androidArchFeatureMap[archType]; ok { a.ArchFeatures = featureMap[a.ArchVariant] } } return a, nil } // filterMultilibTargets takes a list of Targets and a multilib value and returns a new list of // Targets containing only those that have the given multilib value. func filterMultilibTargets(targets []Target, multilib string) []Target { var ret []Target for _, t := range targets { if t.Arch.ArchType.Multilib == multilib { ret = append(ret, t) } } return ret } // getCommonTargets returns the set of Os specific common architecture targets for each Os in a list // of targets. func getCommonTargets(targets []Target) []Target { var ret []Target set := make(map[string]bool) for _, t := range targets { if _, found := set[t.Os.String()]; !found { set[t.Os.String()] = true common := commonTargetMap[t.Os.String()] common.HostCross = t.HostCross ret = append(ret, common) } } return ret } // FirstTarget takes a list of Targets and a list of multilib values and returns a list of Targets // that contains zero or one Target for each OsType and HostCross, selecting the one that matches // the earliest filter. func FirstTarget(targets []Target, filters ...string) []Target { // find the first target from each OS var ret []Target type osHostCross struct { os OsType hostCross bool } set := make(map[osHostCross]bool) for _, filter := range filters { buildTargets := filterMultilibTargets(targets, filter) for _, t := range buildTargets { key := osHostCross{t.Os, t.HostCross} if _, found := set[key]; !found { set[key] = true ret = append(ret, t) } } } return ret } // decodeMultilibTargets uses the module's multilib setting to select one or more targets from a // list of Targets. func decodeMultilibTargets(multilib string, targets []Target, prefer32 bool) ([]Target, error) { var buildTargets []Target switch multilib { case "common": buildTargets = getCommonTargets(targets) case "common_first": buildTargets = getCommonTargets(targets) if prefer32 { buildTargets = append(buildTargets, FirstTarget(targets, "lib32", "lib64")...) } else { buildTargets = append(buildTargets, FirstTarget(targets, "lib64", "lib32")...) } case "both": if prefer32 { buildTargets = append(buildTargets, filterMultilibTargets(targets, "lib32")...) buildTargets = append(buildTargets, filterMultilibTargets(targets, "lib64")...) } else { buildTargets = append(buildTargets, filterMultilibTargets(targets, "lib64")...) buildTargets = append(buildTargets, filterMultilibTargets(targets, "lib32")...) } case "32": buildTargets = filterMultilibTargets(targets, "lib32") case "64": buildTargets = filterMultilibTargets(targets, "lib64") case "first": if prefer32 { buildTargets = FirstTarget(targets, "lib32", "lib64") } else { buildTargets = FirstTarget(targets, "lib64", "lib32") } case "first_prefer32": buildTargets = FirstTarget(targets, "lib32", "lib64") case "prefer32": buildTargets = filterMultilibTargets(targets, "lib32") if len(buildTargets) == 0 { buildTargets = filterMultilibTargets(targets, "lib64") } case "darwin_universal": buildTargets = filterMultilibTargets(targets, "lib64") // Reverse the targets so that the first architecture can depend on the second // architecture module in order to merge the outputs. reverseSliceInPlace(buildTargets) case "darwin_universal_common_first": archTargets := filterMultilibTargets(targets, "lib64") reverseSliceInPlace(archTargets) buildTargets = append(getCommonTargets(targets), archTargets...) default: return nil, fmt.Errorf(`compile_multilib must be "both", "first", "32", "64", "prefer32" or "first_prefer32" found %q`, multilib) } return buildTargets, nil } func (m *ModuleBase) getArchPropertySet(propertySet interface{}, archType ArchType) interface{} { archString := archType.Field for i := range m.archProperties { if m.archProperties[i] == nil { // Skip over nil properties continue } // Not archProperties are usable; this function looks for properties of a very specific // form, and ignores the rest. for _, archProperty := range m.archProperties[i] { // archPropValue is a property struct, we are looking for the form: // `arch: { arm: { key: value, ... }}` archPropValue := reflect.ValueOf(archProperty).Elem() // Unwrap src so that it should looks like a pointer to `arm: { key: value, ... }` src := archPropValue.FieldByName("Arch").Elem() // Step into non-nil pointers to structs in the src value. if src.Kind() == reflect.Ptr { if src.IsNil() { continue } src = src.Elem() } // Find the requested field (e.g. arm, x86) in the src struct. src = src.FieldByName(archString) // We only care about structs. if !src.IsValid() || src.Kind() != reflect.Struct { continue } // If the value of the field is a struct then step into the // BlueprintEmbed field. The special "BlueprintEmbed" name is // used by createArchPropTypeDesc to embed the arch properties // in the parent struct, so the src arch prop should be in this // field. // // See createArchPropTypeDesc for more details on how Arch-specific // module properties are processed from the nested props and written // into the module's archProperties. src = src.FieldByName("BlueprintEmbed") // Clone the destination prop, since we want a unique prop struct per arch. propertySetClone := reflect.New(reflect.ValueOf(propertySet).Elem().Type()).Interface() // Copy the located property struct into the cloned destination property struct. err := proptools.ExtendMatchingProperties([]interface{}{propertySetClone}, src.Interface(), nil, proptools.OrderReplace) if err != nil { // This is fine, it just means the src struct doesn't match the type of propertySet. continue } return propertySetClone } } // No property set was found specific to the given arch, so return an empty // property set. return reflect.New(reflect.ValueOf(propertySet).Elem().Type()).Interface() } // getMultilibPropertySet returns a property set struct matching the type of // `propertySet`, containing multilib-specific module properties for the given architecture. // If no multilib-specific properties exist for the given architecture, returns an empty property // set matching `propertySet`'s type. func (m *ModuleBase) getMultilibPropertySet(propertySet interface{}, archType ArchType) interface{} { // archType.Multilib is lowercase (for example, lib32) but property struct field is // capitalized, such as Lib32, so use strings.Title to capitalize it. multiLibString := strings.Title(archType.Multilib) for i := range m.archProperties { if m.archProperties[i] == nil { // Skip over nil properties continue } // Not archProperties are usable; this function looks for properties of a very specific // form, and ignores the rest. for _, archProperties := range m.archProperties[i] { // archPropValue is a property struct, we are looking for the form: // `multilib: { lib32: { key: value, ... }}` archPropValue := reflect.ValueOf(archProperties).Elem() // Unwrap src so that it should looks like a pointer to `lib32: { key: value, ... }` src := archPropValue.FieldByName("Multilib").Elem() // Step into non-nil pointers to structs in the src value. if src.Kind() == reflect.Ptr { if src.IsNil() { // Ignore nil pointers. continue } src = src.Elem() } // Find the requested field (e.g. lib32) in the src struct. src = src.FieldByName(multiLibString) // We only care about valid struct pointers. if !src.IsValid() || src.Kind() != reflect.Ptr || src.Elem().Kind() != reflect.Struct { continue } // Get the zero value for the requested property set. propertySetClone := reflect.New(reflect.ValueOf(propertySet).Elem().Type()).Interface() // Copy the located property struct into the "zero" property set struct. err := proptools.ExtendMatchingProperties([]interface{}{propertySetClone}, src.Interface(), nil, proptools.OrderReplace) if err != nil { // This is fine, it just means the src struct doesn't match. continue } return propertySetClone } } // There were no multilib properties specifically matching the given archtype. // Return zeroed value. return reflect.New(reflect.ValueOf(propertySet).Elem().Type()).Interface() } // ArchVariantContext defines the limited context necessary to retrieve arch_variant properties. type ArchVariantContext interface { ModuleErrorf(fmt string, args ...interface{}) PropertyErrorf(property, fmt string, args ...interface{}) } // ArchVariantProperties represents a map of arch-variant config strings to a property interface{}. type ArchVariantProperties map[string]interface{} // ConfigurationAxisToArchVariantProperties represents a map of bazel.ConfigurationAxis to // ArchVariantProperties, such that each independent arch-variant axis maps to the // configs/properties for that axis. type ConfigurationAxisToArchVariantProperties map[bazel.ConfigurationAxis]ArchVariantProperties // GetArchVariantProperties returns a ConfigurationAxisToArchVariantProperties where the // arch-variant properties correspond to the values of the properties of the 'propertySet' struct // that are specific to that axis/configuration. Each axis is independent, containing // non-overlapping configs that correspond to the various "arch-variant" support, at this time: // // arches (including multilib) // oses // arch+os combinations // // For example, passing a struct { Foo bool, Bar string } will return an interface{} that can be // type asserted back into the same struct, containing the config-specific property value specified // by the module if defined. // // Arch-specific properties may come from an arch stanza or a multilib stanza; properties // in these stanzas are combined. // For example: `arch: { x86: { Foo: ["bar"] } }, multilib: { lib32: {` Foo: ["baz"] } }` // will result in `Foo: ["bar", "baz"]` being returned for architecture x86, if the given // propertyset contains `Foo []string`. func (m *ModuleBase) GetArchVariantProperties(ctx ArchVariantContext, propertySet interface{}) ConfigurationAxisToArchVariantProperties { // Return value of the arch types to the prop values for that arch. axisToProps := ConfigurationAxisToArchVariantProperties{} // Nothing to do for non-arch-specific modules. if !m.ArchSpecific() { return axisToProps } dstType := reflect.ValueOf(propertySet).Type() var archProperties []interface{} // First find the property set in the module that corresponds to the requested // one. m.archProperties[i] corresponds to m.GetProperties()[i]. for i, generalProp := range m.GetProperties() { srcType := reflect.ValueOf(generalProp).Type() if srcType == dstType { archProperties = m.archProperties[i] axisToProps[bazel.NoConfigAxis] = ArchVariantProperties{"": generalProp} break } } if archProperties == nil { // This module does not have the property set requested return axisToProps } archToProp := ArchVariantProperties{} // For each arch type (x86, arm64, etc.) for _, arch := range ArchTypeList() { // Arch properties are sometimes sharded (see createArchPropTypeDesc() ). // Iterate over every shard and extract a struct with the same type as the // input one that contains the data specific to that arch. propertyStructs := make([]reflect.Value, 0) archFeaturePropertyStructs := make(map[string][]reflect.Value, 0) for _, archProperty := range archProperties { archTypeStruct, ok := getArchTypeStruct(ctx, archProperty, arch) if ok { propertyStructs = append(propertyStructs, archTypeStruct) // For each feature this arch supports (arm: neon, x86: ssse3, sse4, ...) for _, feature := range archFeatures[arch] { prefix := "arch." + arch.Name + "." + feature if featureProperties, ok := getChildPropertyStruct(ctx, archTypeStruct, feature, prefix); ok { archFeaturePropertyStructs[feature] = append(archFeaturePropertyStructs[feature], featureProperties) } } } multilibStruct, ok := getMultilibStruct(ctx, archProperty, arch) if ok { propertyStructs = append(propertyStructs, multilibStruct) } } archToProp[arch.Name] = mergeStructs(ctx, propertyStructs, propertySet) // In soong, if multiple features match the current configuration, they're // all used. In bazel, we have to have unambiguous select() statements, so // we can't have two features that are both active in the same select(). // One alternative is to split out each feature into a separate select(), // but then it's difficult to support exclude_srcs, which may need to // exclude things from the regular arch select() statement if a certain // feature is active. Instead, keep the features in the same select // statement as the arches, but emit the power set of all possible // combinations of features, so that bazel can match the most precise one. allFeatures := make([]string, 0, len(archFeaturePropertyStructs)) for feature := range archFeaturePropertyStructs { allFeatures = append(allFeatures, feature) } for _, features := range bazel.PowerSetWithoutEmptySet(allFeatures) { sort.Strings(features) propsForCurrentFeatureSet := make([]reflect.Value, 0) propsForCurrentFeatureSet = append(propsForCurrentFeatureSet, propertyStructs...) for _, feature := range features { propsForCurrentFeatureSet = append(propsForCurrentFeatureSet, archFeaturePropertyStructs[feature]...) } archToProp[arch.Name+"-"+strings.Join(features, "-")] = mergeStructs(ctx, propsForCurrentFeatureSet, propertySet) } } axisToProps[bazel.ArchConfigurationAxis] = archToProp osToProp := ArchVariantProperties{} archOsToProp := ArchVariantProperties{} linuxStructs := getTargetStructs(ctx, archProperties, "Linux") bionicStructs := getTargetStructs(ctx, archProperties, "Bionic") hostStructs := getTargetStructs(ctx, archProperties, "Host") hostLinuxStructs := getTargetStructs(ctx, archProperties, "Host_linux") hostNotWindowsStructs := getTargetStructs(ctx, archProperties, "Not_windows") // For android, linux, ... for _, os := range osTypeList { if os == CommonOS { // It looks like this OS value is not used in Blueprint files continue } osStructs := make([]reflect.Value, 0) osSpecificStructs := getTargetStructs(ctx, archProperties, os.Field) if os.Class == Host { osStructs = append(osStructs, hostStructs...) } if os.Linux() { osStructs = append(osStructs, linuxStructs...) } if os.Bionic() { osStructs = append(osStructs, bionicStructs...) } if os.Linux() && os.Class == Host { osStructs = append(osStructs, hostLinuxStructs...) } if os == LinuxMusl { osStructs = append(osStructs, getTargetStructs(ctx, archProperties, "Musl")...) } if os == Linux { osStructs = append(osStructs, getTargetStructs(ctx, archProperties, "Glibc")...) } osStructs = append(osStructs, osSpecificStructs...) if os.Class == Host && os != Windows { osStructs = append(osStructs, hostNotWindowsStructs...) } osToProp[os.Name] = mergeStructs(ctx, osStructs, propertySet) // For arm, x86, ... for _, arch := range osArchTypeMap[os] { osArchStructs := make([]reflect.Value, 0) // Auto-combine with Linux_ and Bionic_ targets. This potentially results in // repetition and select() bloat, but use of Linux_* and Bionic_* targets is rare. // TODO(b/201423152): Look into cleanup. if os.Linux() { targetField := "Linux_" + arch.Name targetStructs := getTargetStructs(ctx, archProperties, targetField) osArchStructs = append(osArchStructs, targetStructs...) } if os.Bionic() { targetField := "Bionic_" + arch.Name targetStructs := getTargetStructs(ctx, archProperties, targetField) osArchStructs = append(osArchStructs, targetStructs...) } if os == LinuxMusl { targetField := "Musl_" + arch.Name targetStructs := getTargetStructs(ctx, archProperties, targetField) osArchStructs = append(osArchStructs, targetStructs...) } if os == Linux { targetField := "Glibc_" + arch.Name targetStructs := getTargetStructs(ctx, archProperties, targetField) osArchStructs = append(osArchStructs, targetStructs...) } targetField := GetCompoundTargetField(os, arch) targetName := fmt.Sprintf("%s_%s", os.Name, arch.Name) targetStructs := getTargetStructs(ctx, archProperties, targetField) osArchStructs = append(osArchStructs, targetStructs...) archOsToProp[targetName] = mergeStructs(ctx, osArchStructs, propertySet) } } axisToProps[bazel.OsConfigurationAxis] = osToProp axisToProps[bazel.OsArchConfigurationAxis] = archOsToProp return axisToProps } // Returns a struct matching the propertySet interface, containing properties specific to the targetName // For example, given these arguments: // // propertySet = BaseCompilerProperties // targetName = "android_arm" // // And given this Android.bp fragment: // // target: // android_arm: { // srcs: ["foo.c"], // } // android_arm64: { // srcs: ["bar.c"], // } // } // // This would return a BaseCompilerProperties with BaseCompilerProperties.Srcs = ["foo.c"] func getTargetStructs(ctx ArchVariantContext, archProperties []interface{}, targetName string) []reflect.Value { var propertyStructs []reflect.Value for _, archProperty := range archProperties { archPropValues := reflect.ValueOf(archProperty).Elem() targetProp := archPropValues.FieldByName("Target").Elem() targetStruct, ok := getChildPropertyStruct(ctx, targetProp, targetName, targetName) if ok { propertyStructs = append(propertyStructs, targetStruct) } else { return []reflect.Value{} } } return propertyStructs } func mergeStructs(ctx ArchVariantContext, propertyStructs []reflect.Value, propertySet interface{}) interface{} { // Create a new instance of the requested property set value := reflect.New(reflect.ValueOf(propertySet).Elem().Type()).Interface() // Merge all the structs together for _, propertyStruct := range propertyStructs { mergePropertyStruct(ctx, value, propertyStruct) } return value } func printArchTypeStarlarkDict(dict map[ArchType][]string) string { valDict := make(map[string]string, len(dict)) for k, v := range dict { valDict[k.String()] = starlark_fmt.PrintStringList(v, 1) } return starlark_fmt.PrintDict(valDict, 0) } func printArchTypeNestedStarlarkDict(dict map[ArchType]map[string][]string) string { valDict := make(map[string]string, len(dict)) for k, v := range dict { valDict[k.String()] = starlark_fmt.PrintStringListDict(v, 1) } return starlark_fmt.PrintDict(valDict, 0) } func printArchConfigList(arches []archConfig) string { jsonOut, err := json.MarshalIndent(arches, "", starlark_fmt.Indention(1)) if err != nil { panic(fmt.Errorf("Error converting arch configs %#v to json: %q", arches, err)) } return fmt.Sprintf("json.decode('''%s''')", string(jsonOut)) } func StarlarkArchConfigurations() string { return fmt.Sprintf(` _arch_to_variants = %s _arch_to_cpu_variants = %s _arch_to_features = %s _android_arch_feature_for_arch_variant = %s _aml_arches = %s _ndk_arches = %s arch_to_variants = _arch_to_variants arch_to_cpu_variants = _arch_to_cpu_variants arch_to_features = _arch_to_features android_arch_feature_for_arch_variants = _android_arch_feature_for_arch_variant aml_arches = _aml_arches ndk_arches = _ndk_arches `, printArchTypeStarlarkDict(archVariants), printArchTypeStarlarkDict(cpuVariants), printArchTypeStarlarkDict(archFeatures), printArchTypeNestedStarlarkDict(androidArchFeatureMap), printArchConfigList(getAmlAbisConfig()), printArchConfigList(getNdkAbisConfig()), ) }