Revert "Simplify arch target handling"
This reverts commit 6713fb26cbcadf525cd75e47d7d0cbc23d282b3e.
Change-Id: Ic473cea2563b0b37dc08b0bc5d3a0ac8c4b6afe6
diff --git a/android/androidmk.go b/android/androidmk.go
index 8d2951d..603b37d 100644
--- a/android/androidmk.go
+++ b/android/androidmk.go
@@ -149,21 +149,27 @@
name += "_" + data.SubName
}
+ hostCross := false
+ if amod.Host() && amod.HostType() != CurrentHostType() {
+ hostCross = true
+ }
+
if data.Custom != nil {
prefix := ""
- switch amod.Os().Class {
- case Host:
- prefix = "HOST_"
- case HostCross:
- prefix = "HOST_CROSS_"
- case Device:
+ if amod.Host() {
+ if hostCross {
+ prefix = "HOST_CROSS_"
+ } else {
+ prefix = "HOST_"
+ }
+ if amod.Arch().ArchType != ctx.Config().(Config).HostArches[amod.HostType()][0].ArchType {
+ prefix = "2ND_" + prefix
+ }
+ } else {
prefix = "TARGET_"
-
- }
-
- config := ctx.Config().(Config)
- if amod.Arch().ArchType != config.Targets[amod.Os().Class][0].Arch.ArchType {
- prefix = "2ND_" + prefix
+ if amod.Arch().ArchType != ctx.Config().(Config).DeviceArches[0].ArchType {
+ prefix = "2ND_" + prefix
+ }
}
return data.Custom(w, name, prefix)
@@ -185,15 +191,15 @@
fmt.Fprintln(w, "LOCAL_PREBUILT_MODULE_FILE :=", data.OutputFile.String())
archStr := amod.Arch().ArchType.String()
- host := false
- switch amod.Os().Class {
- case Host:
- fmt.Fprintln(w, "LOCAL_MODULE_HOST_ARCH :=", archStr)
- host = true
- case HostCross:
- fmt.Fprintln(w, "LOCAL_MODULE_HOST_CROSS_ARCH :=", archStr)
- host = true
- case Device:
+ if amod.Host() {
+ if hostCross {
+ fmt.Fprintln(w, "LOCAL_MODULE_HOST_CROSS_ARCH :=", archStr)
+ } else {
+ fmt.Fprintln(w, "LOCAL_MODULE_HOST_ARCH :=", archStr)
+ }
+ fmt.Fprintln(w, "LOCAL_MODULE_HOST_OS :=", amod.HostType().String())
+ fmt.Fprintln(w, "LOCAL_IS_HOST_MODULE := true")
+ } else {
fmt.Fprintln(w, "LOCAL_MODULE_TARGET_ARCH :=", archStr)
if len(amod.commonProperties.Logtags) > 0 {
@@ -201,11 +207,6 @@
}
}
- if host {
- fmt.Fprintln(w, "LOCAL_MODULE_HOST_OS :=", amod.Os().String())
- fmt.Fprintln(w, "LOCAL_IS_HOST_MODULE := true")
- }
-
for _, extra := range data.Extra {
err = extra(w, data.OutputFile.Path())
if err != nil {
diff --git a/android/arch.go b/android/arch.go
index 184b162..48cc0ab 100644
--- a/android/arch.go
+++ b/android/arch.go
@@ -28,6 +28,8 @@
RegisterBottomUpMutator("defaults_deps", defaultsDepsMutator)
RegisterTopDownMutator("defaults", defaultsMutator)
+ RegisterBottomUpMutator("host_or_device", HostOrDeviceMutator)
+ RegisterBottomUpMutator("host_type", HostTypeMutator)
RegisterBottomUpMutator("arch", ArchMutator)
}
@@ -331,7 +333,75 @@
return a.Name
}
-var BuildOs = func() OsType {
+type HostOrDeviceSupported int
+
+const (
+ _ HostOrDeviceSupported = iota
+ HostSupported
+ DeviceSupported
+ HostAndDeviceSupported
+ HostAndDeviceDefault
+)
+
+type HostOrDevice int
+
+const (
+ _ HostOrDevice = iota
+ Host
+ Device
+)
+
+func (hod HostOrDevice) String() string {
+ switch hod {
+ case Device:
+ return "device"
+ case Host:
+ return "host"
+ default:
+ panic(fmt.Sprintf("unexpected HostOrDevice value %d", hod))
+ }
+}
+
+func (hod HostOrDevice) Property() string {
+ switch hod {
+ case Device:
+ return "android"
+ case Host:
+ return "host"
+ default:
+ panic(fmt.Sprintf("unexpected HostOrDevice value %d", hod))
+ }
+}
+
+func (hod HostOrDevice) Host() bool {
+ if hod == 0 {
+ panic("HostOrDevice unset")
+ }
+ return hod == Host
+}
+
+func (hod HostOrDevice) Device() bool {
+ if hod == 0 {
+ panic("HostOrDevice unset")
+ }
+ return hod == Device
+}
+
+var hostOrDeviceName = map[HostOrDevice]string{
+ Device: "device",
+ Host: "host",
+}
+
+type HostType int
+
+const (
+ NoHostType HostType = iota
+ Linux
+ Darwin
+ Windows
+)
+
+func CurrentHostType() HostType {
switch runtime.GOOS {
case "linux":
return Linux
@@ -340,71 +410,98 @@
default:
panic(fmt.Sprintf("unsupported OS: %s", runtime.GOOS))
}
-}()
-
-var (
- osTypeList []OsType
-
- NoOsType OsType
- Linux = NewOsType("linux", Host)
- Darwin = NewOsType("darwin", Host)
- Windows = NewOsType("windows", HostCross)
- Android = NewOsType("android", Device)
-)
-
-type OsType struct {
- Name, Field string
- Class OsClass
}
-type OsClass int
-
-const (
- Device OsClass = iota
- Host
- HostCross
-)
-
-func (os OsType) String() string {
- return os.Name
-}
-
-func NewOsType(name string, class OsClass) OsType {
- os := OsType{
- Name: name,
- Field: strings.Title(name),
- Class: class,
+func (ht HostType) String() string {
+ switch ht {
+ case Linux:
+ return "linux"
+ case Darwin:
+ return "darwin"
+ case Windows:
+ return "windows"
+ default:
+ panic(fmt.Sprintf("unexpected HostType value %d", ht))
}
- osTypeList = append(osTypeList, os)
- return os
}
-func osByName(name string) OsType {
- for _, os := range osTypeList {
- if os.Name == name {
- return os
- }
+func (ht HostType) Field() string {
+ switch ht {
+ case Linux:
+ return "Linux"
+ case Darwin:
+ return "Darwin"
+ case Windows:
+ return "Windows"
+ default:
+ panic(fmt.Sprintf("unexpected HostType value %d", ht))
}
-
- return NoOsType
}
var (
- commonTarget = Target{
- Os: Android,
- Arch: Arch{
- ArchType: Common,
- },
+ commonArch = Arch{
+ ArchType: Common,
}
)
-type Target struct {
- Os OsType
- Arch Arch
+func HostOrDeviceMutator(mctx BottomUpMutatorContext) {
+ var module Module
+ var ok bool
+ if module, ok = mctx.Module().(Module); !ok {
+ return
+ }
+
+ hods := []HostOrDevice{}
+
+ if module.base().HostSupported() {
+ hods = append(hods, Host)
+ }
+
+ if module.base().DeviceSupported() {
+ hods = append(hods, Device)
+ }
+
+ if len(hods) == 0 {
+ return
+ }
+
+ hodNames := []string{}
+ for _, hod := range hods {
+ hodNames = append(hodNames, hod.String())
+ }
+
+ modules := mctx.CreateVariations(hodNames...)
+ for i, m := range modules {
+ m.(Module).base().SetHostOrDevice(hods[i])
+ }
}
-func (target Target) String() string {
- return target.Os.String() + "_" + target.Arch.String()
+func HostTypeMutator(mctx BottomUpMutatorContext) {
+ var module Module
+ var ok bool
+ if module, ok = mctx.Module().(Module); !ok {
+ return
+ }
+
+ if !module.base().HostSupported() || !module.base().HostOrDevice().Host() {
+ return
+ }
+
+ buildTypes, err := decodeHostTypesProductVariables(mctx.Config().(Config).ProductVariables)
+ if err != nil {
+ mctx.ModuleErrorf("%s", err.Error())
+ return
+ }
+
+ typeNames := []string{}
+ for _, ht := range buildTypes {
+ typeNames = append(typeNames, ht.String())
+ }
+
+ modules := mctx.CreateVariations(typeNames...)
+ for i, m := range modules {
+ m.(Module).base().SetHostType(buildTypes[i])
+ }
}
func ArchMutator(mctx BottomUpMutatorContext) {
@@ -414,32 +511,40 @@
return
}
- osClasses := module.base().OsClassSupported()
+ moduleArches := []Arch{}
+ multilib := module.base().commonProperties.Compile_multilib
- if len(osClasses) == 0 {
- return
- }
-
- var moduleTargets []Target
-
- for _, class := range osClasses {
- multilib := module.base().commonProperties.Compile_multilib
- targets, err := decodeMultilib(multilib, mctx.AConfig().Targets[class])
+ if module.base().HostSupported() && module.base().HostOrDevice().Host() {
+ hostModuleArches, err := decodeMultilib(multilib, mctx.Config().(Config).HostArches[module.base().HostType()])
if err != nil {
mctx.ModuleErrorf("%s", err.Error())
}
- moduleTargets = append(moduleTargets, targets...)
+
+ moduleArches = append(moduleArches, hostModuleArches...)
}
- targetNames := make([]string, len(moduleTargets))
+ if module.base().DeviceSupported() && module.base().HostOrDevice().Device() {
+ deviceModuleArches, err := decodeMultilib(multilib, mctx.Config().(Config).DeviceArches)
+ if err != nil {
+ mctx.ModuleErrorf("%s", err.Error())
+ }
- for i, target := range moduleTargets {
- targetNames[i] = target.String()
+ moduleArches = append(moduleArches, deviceModuleArches...)
}
- modules := mctx.CreateVariations(targetNames...)
+ if len(moduleArches) == 0 {
+ return
+ }
+
+ archNames := []string{}
+ for _, arch := range moduleArches {
+ archNames = append(archNames, arch.String())
+ }
+
+ modules := mctx.CreateVariations(archNames...)
+
for i, m := range modules {
- m.(Module).base().SetTarget(moduleTargets[i])
+ m.(Module).base().SetArch(moduleArches[i])
m.(Module).base().setArchProperties(mctx)
}
}
@@ -543,8 +648,9 @@
// Rewrite the module's properties structs to contain arch-specific values.
func (a *ModuleBase) setArchProperties(ctx BottomUpMutatorContext) {
- arch := a.Arch()
- os := a.Os()
+ arch := a.commonProperties.CompileArch
+ hod := a.commonProperties.CompileHostOrDevice
+ ht := a.commonProperties.CompileHostType
if arch.ArchType == Common {
return
@@ -613,19 +719,18 @@
prefix = "multilib." + t.Multilib
a.appendProperties(ctx, genProps, archProps.Multilib, field, prefix)
- // Handle host-specific properties in the form:
+ // Handle host-or-device-specific properties in the form:
// target: {
// host: {
// key: value,
// },
// },
- if os.Class == Host || os.Class == HostCross {
- field = "Host"
- prefix = "target.host"
- a.appendProperties(ctx, genProps, archProps.Target, field, prefix)
- }
+ hodProperty := hod.Property()
+ field = proptools.FieldNameForProperty(hodProperty)
+ prefix = "target." + hodProperty
+ a.appendProperties(ctx, genProps, archProps.Target, field, prefix)
- // Handle target OS properties in the form:
+ // Handle host target properties in the form:
// target: {
// linux: {
// key: value,
@@ -639,29 +744,22 @@
// linux_arm: {
// key: value,
// },
- // android {
- // key: value,
- // },
- // android_arm {
- // key: value,
- // },
- // android_x86 {
- // key: value,
- // },
// },
- // },
- field = os.Field
- prefix = "target." + os.Name
- a.appendProperties(ctx, genProps, archProps.Target, field, prefix)
-
- field = os.Field + "_" + t.Name
- prefix = "target." + os.Name + "_" + t.Name
- a.appendProperties(ctx, genProps, archProps.Target, field, prefix)
-
- if (os.Class == Host || os.Class == HostCross) && os != Windows {
- field := "Not_windows"
- prefix := "target.not_windows"
+ if hod.Host() {
+ field := ht.Field()
+ prefix := "target." + ht.String()
a.appendProperties(ctx, genProps, archProps.Target, field, prefix)
+
+ t := arch.ArchType
+ field = ht.Field() + "_" + t.Name
+ prefix = "target." + ht.String() + "_" + t.Name
+ a.appendProperties(ctx, genProps, archProps.Target, field, prefix)
+
+ if ht != Windows {
+ field := "Not_windows"
+ prefix := "target.not_windows"
+ a.appendProperties(ctx, genProps, archProps.Target, field, prefix)
+ }
}
// Handle 64-bit device properties in the form:
@@ -677,8 +775,8 @@
// 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.AConfig().Android64() {
+ if hod.Device() {
+ if true /* && target_is_64_bit */ {
field := "Android64"
prefix := "target.android64"
a.appendProperties(ctx, genProps, archProps.Target, field, prefix)
@@ -688,6 +786,26 @@
a.appendProperties(ctx, genProps, archProps.Target, field, prefix)
}
}
+
+ // Handle device architecture properties in the form:
+ // target {
+ // android_arm {
+ // key: value,
+ // },
+ // android_x86 {
+ // key: value,
+ // },
+ // },
+ if hod.Device() {
+ t := arch.ArchType
+ field := "Android_" + t.Name
+ prefix := "target.android_" + t.Name
+ a.appendProperties(ctx, genProps, archProps.Target, field, prefix)
+ }
+
+ if ctx.Failed() {
+ return
+ }
}
}
@@ -706,84 +824,104 @@
}
}
-// Convert the arch product variables into a list of targets for each os class structs
-func decodeTargetProductVariables(config Config) (map[OsClass][]Target, error) {
- variables := config.ProductVariables
+// Get a list of HostTypes from the product variables
+func decodeHostTypesProductVariables(variables productVariables) ([]HostType, error) {
+ ret := []HostType{CurrentHostType()}
- targets := make(map[OsClass][]Target)
- var targetErr error
-
- addTarget := func(os OsType, archName string, archVariant, cpuVariant *string, abi *[]string) {
- if targetErr != nil {
- return
+ if variables.CrossHost != nil && *variables.CrossHost != "" {
+ switch *variables.CrossHost {
+ case "windows":
+ ret = append(ret, Windows)
+ default:
+ return nil, fmt.Errorf("Unsupported secondary host: %s", *variables.CrossHost)
}
-
- arch, err := decodeArch(archName, archVariant, cpuVariant, abi)
- if err != nil {
- targetErr = err
- return
- }
-
- targets[os.Class] = append(targets[os.Class],
- Target{
- Os: os,
- Arch: arch,
- })
}
+ return ret, nil
+}
+
+// Convert the arch product variables into a list of host and device Arch structs
+func decodeArchProductVariables(variables productVariables) (map[HostType][]Arch, []Arch, error) {
if variables.HostArch == nil {
- return nil, fmt.Errorf("No host primary architecture set")
+ return nil, nil, fmt.Errorf("No host primary architecture set")
}
- addTarget(BuildOs, *variables.HostArch, nil, nil, nil)
+ hostArch, err := decodeArch(*variables.HostArch, nil, nil, nil)
+ if err != nil {
+ return nil, nil, err
+ }
+
+ hostArches := []Arch{hostArch}
if variables.HostSecondaryArch != nil && *variables.HostSecondaryArch != "" {
- addTarget(BuildOs, *variables.HostSecondaryArch, nil, nil, nil)
+ hostSecondaryArch, err := decodeArch(*variables.HostSecondaryArch, nil, nil, nil)
+ if err != nil {
+ return nil, nil, err
+ }
+ hostArches = append(hostArches, hostSecondaryArch)
+ }
+
+ hostTypeArches := map[HostType][]Arch{
+ CurrentHostType(): hostArches,
}
if variables.CrossHost != nil && *variables.CrossHost != "" {
- crossHostOs := osByName(*variables.CrossHost)
- if crossHostOs == NoOsType {
- return nil, fmt.Errorf("Unknown cross host OS %q", *variables.CrossHost)
- }
-
if variables.CrossHostArch == nil || *variables.CrossHostArch == "" {
- return nil, fmt.Errorf("No cross-host primary architecture set")
+ return nil, nil, fmt.Errorf("No cross-host primary architecture set")
}
- addTarget(crossHostOs, *variables.CrossHostArch, nil, nil, nil)
+ crossHostArch, err := decodeArch(*variables.CrossHostArch, nil, nil, nil)
+ if err != nil {
+ return nil, nil, err
+ }
+
+ crossHostArches := []Arch{crossHostArch}
if variables.CrossHostSecondaryArch != nil && *variables.CrossHostSecondaryArch != "" {
- addTarget(crossHostOs, *variables.CrossHostSecondaryArch, nil, nil, nil)
+ crossHostSecondaryArch, err := decodeArch(*variables.CrossHostSecondaryArch, nil, nil, nil)
+ if err != nil {
+ return nil, nil, err
+ }
+ crossHostArches = append(crossHostArches, crossHostSecondaryArch)
+ }
+
+ switch *variables.CrossHost {
+ case "windows":
+ hostTypeArches[Windows] = crossHostArches
+ default:
+ return nil, nil, fmt.Errorf("Unsupported cross-host: %s", *variables.CrossHost)
}
}
if variables.DeviceArch == nil {
- return nil, fmt.Errorf("No device primary architecture set")
+ return nil, nil, fmt.Errorf("No device primary architecture set")
}
- addTarget(Android, *variables.DeviceArch, variables.DeviceArchVariant,
+ deviceArch, err := decodeArch(*variables.DeviceArch, variables.DeviceArchVariant,
variables.DeviceCpuVariant, variables.DeviceAbi)
+ if err != nil {
+ return nil, nil, err
+ }
+
+ deviceArches := []Arch{deviceArch}
if variables.DeviceSecondaryArch != nil && *variables.DeviceSecondaryArch != "" {
- addTarget(Android, *variables.DeviceSecondaryArch,
+ deviceSecondaryArch, err := decodeArch(*variables.DeviceSecondaryArch,
variables.DeviceSecondaryArchVariant, variables.DeviceSecondaryCpuVariant,
variables.DeviceSecondaryAbi)
-
- deviceArches := targets[Device]
- if deviceArches[0].Arch.ArchType.Multilib == deviceArches[1].Arch.ArchType.Multilib {
- deviceArches[1].Arch.Native = false
+ if err != nil {
+ return nil, nil, err
}
+ if deviceArch.ArchType.Multilib == deviceSecondaryArch.ArchType.Multilib {
+ deviceSecondaryArch.Native = false
+ }
+ deviceArches = append(deviceArches, deviceSecondaryArch)
}
- if targetErr != nil {
- return nil, targetErr
- }
-
- return targets, nil
+ return hostTypeArches, deviceArches, nil
}
-func decodeMegaDevice() ([]Target, error) {
+func decodeMegaDevice() ([]Arch, error) {
archSettings := []struct {
arch string
archVariant string
@@ -831,7 +969,7 @@
{"x86_64", "silvermont", "", []string{"x86_64"}},
}
- var ret []Target
+ var ret []Arch
for _, config := range archSettings {
arch, err := decodeArch(config.arch, &config.archVariant,
@@ -840,10 +978,7 @@
return nil, err
}
arch.Native = false
- ret = append(ret, Target{
- Os: Android,
- Arch: arch,
- })
+ ret = append(ret, arch)
}
return ret, nil
@@ -900,32 +1035,33 @@
return a, nil
}
-// Use the module multilib setting to select one or more targets from a target list
-func decodeMultilib(multilib string, targets []Target) ([]Target, error) {
- buildTargets := []Target{}
+// Use the module multilib setting to select one or more arches from an arch list
+func decodeMultilib(multilib string, arches []Arch) ([]Arch, error) {
+ buildArches := []Arch{}
switch multilib {
case "common":
- buildTargets = append(buildTargets, commonTarget)
+ buildArches = append(buildArches, commonArch)
case "both":
- buildTargets = append(buildTargets, targets...)
+ buildArches = append(buildArches, arches...)
case "first":
- buildTargets = append(buildTargets, targets[0])
+ buildArches = append(buildArches, arches[0])
case "32":
- for _, t := range targets {
- if t.Arch.ArchType.Multilib == "lib32" {
- buildTargets = append(buildTargets, t)
+ for _, a := range arches {
+ if a.ArchType.Multilib == "lib32" {
+ buildArches = append(buildArches, a)
}
}
case "64":
- for _, t := range targets {
- if t.Arch.ArchType.Multilib == "lib64" {
- buildTargets = append(buildTargets, t)
+ for _, a := range arches {
+ if a.ArchType.Multilib == "lib64" {
+ buildArches = append(buildArches, a)
}
}
default:
return nil, fmt.Errorf(`compile_multilib must be "both", "first", "32", or "64", found %q`,
multilib)
+ //buildArches = append(buildArches, arches[0])
}
- return buildTargets, nil
+ return buildArches, nil
}
diff --git a/android/config.go b/android/config.go
index 5024bce..ee95d2e 100644
--- a/android/config.go
+++ b/android/config.go
@@ -54,8 +54,8 @@
ConfigFileName string
ProductVariablesFileName string
- Targets map[OsClass][]Target
- BuildOsVariant string
+ DeviceArches []Arch
+ HostArches map[HostType][]Arch
srcDir string // the path of the root source directory
buildDir string // the path of the build output directory
@@ -175,21 +175,20 @@
config.inMake = true
}
- targets, err := decodeTargetProductVariables(config)
+ hostArches, deviceArches, err := decodeArchProductVariables(config.ProductVariables)
if err != nil {
return Config{}, err
}
if Bool(config.Mega_device) {
- deviceTargets, err := decodeMegaDevice()
+ deviceArches, err = decodeMegaDevice()
if err != nil {
return Config{}, err
}
- targets[Device] = deviceTargets
}
- config.Targets = targets
- config.BuildOsVariant = targets[Host][0].String()
+ config.HostArches = hostArches
+ config.DeviceArches = deviceArches
return config, nil
}
@@ -326,13 +325,3 @@
}
return *c.ProductVariables.SanitizeDevice
}
-
-func (c *config) Android64() bool {
- for _, t := range c.Targets[Device] {
- if t.Arch.ArchType.Multilib == "lib64" {
- return true
- }
- }
-
- return false
-}
diff --git a/android/module.go b/android/module.go
index 0e608d7..1855523 100644
--- a/android/module.go
+++ b/android/module.go
@@ -48,9 +48,9 @@
}
type androidBaseContext interface {
- Target() Target
Arch() Arch
- Os() OsType
+ HostOrDevice() HostOrDevice
+ HostType() HostType
Host() bool
Device() bool
Darwin() bool
@@ -90,7 +90,7 @@
base() *ModuleBase
Enabled() bool
- Target() Target
+ HostOrDevice() HostOrDevice
InstallInData() bool
}
@@ -115,8 +115,14 @@
// file
Logtags []string
- // Set by TargetMutator
- CompileTarget Target `blueprint:"mutated"`
+ // Set by HostOrDeviceMutator
+ CompileHostOrDevice HostOrDevice `blueprint:"mutated"`
+
+ // Set by HostTypeMutator
+ CompileHostType HostType `blueprint:"mutated"`
+
+ // Set by ArchMutator
+ CompileArch Arch `blueprint:"mutated"`
// Set by InitAndroidModule
HostOrDeviceSupported HostOrDeviceSupported `blueprint:"mutated"`
@@ -136,16 +142,6 @@
MultilibDefault Multilib = ""
)
-type HostOrDeviceSupported int
-
-const (
- _ HostOrDeviceSupported = iota
- HostSupported
- DeviceSupported
- HostAndDeviceSupported
- HostAndDeviceDefault
-)
-
func InitAndroidModule(m Module,
propertyStructs ...interface{}) (blueprint.Module, []interface{}) {
@@ -245,45 +241,38 @@
return a
}
-func (a *ModuleBase) SetTarget(target Target) {
- a.commonProperties.CompileTarget = target
+func (a *ModuleBase) SetHostOrDevice(hod HostOrDevice) {
+ a.commonProperties.CompileHostOrDevice = hod
}
-func (a *ModuleBase) Target() Target {
- return a.commonProperties.CompileTarget
+func (a *ModuleBase) SetHostType(ht HostType) {
+ a.commonProperties.CompileHostType = ht
}
-func (a *ModuleBase) Os() OsType {
- return a.Target().Os
+func (a *ModuleBase) SetArch(arch Arch) {
+ a.commonProperties.CompileArch = arch
+}
+
+func (a *ModuleBase) HostOrDevice() HostOrDevice {
+ return a.commonProperties.CompileHostOrDevice
+}
+
+func (a *ModuleBase) HostType() HostType {
+ return a.commonProperties.CompileHostType
}
func (a *ModuleBase) Host() bool {
- return a.Os().Class == Host || a.Os().Class == HostCross
+ return a.HostOrDevice().Host()
}
func (a *ModuleBase) Arch() Arch {
- return a.Target().Arch
+ return a.commonProperties.CompileArch
}
-func (a *ModuleBase) OsClassSupported() []OsClass {
- switch a.commonProperties.HostOrDeviceSupported {
- case HostSupported:
- // TODO(ccross): explicitly mark host cross support
- return []OsClass{Host, HostCross}
- case DeviceSupported:
- return []OsClass{Device}
- case HostAndDeviceSupported:
- var supported []OsClass
- if a.hostAndDeviceProperties.Host_supported {
- supported = append(supported, Host, HostCross)
- }
- if a.hostAndDeviceProperties.Device_supported {
- supported = append(supported, Device)
- }
- return supported
- default:
- return nil
- }
+func (a *ModuleBase) HostSupported() bool {
+ return a.commonProperties.HostOrDeviceSupported == HostSupported ||
+ a.commonProperties.HostOrDeviceSupported == HostAndDeviceSupported &&
+ a.hostAndDeviceProperties.Host_supported
}
func (a *ModuleBase) DeviceSupported() bool {
@@ -294,7 +283,11 @@
func (a *ModuleBase) Enabled() bool {
if a.commonProperties.Enabled == nil {
- return a.Os().Class != HostCross
+ if a.HostSupported() && a.HostOrDevice().Host() && a.HostType() == Windows {
+ return false
+ } else {
+ return true
+ }
}
return *a.commonProperties.Enabled
}
@@ -383,7 +376,9 @@
func (a *ModuleBase) androidBaseContextFactory(ctx blueprint.BaseModuleContext) androidBaseContextImpl {
return androidBaseContextImpl{
- target: a.commonProperties.CompileTarget,
+ arch: a.commonProperties.CompileArch,
+ hod: a.commonProperties.CompileHostOrDevice,
+ ht: a.commonProperties.CompileHostType,
proprietary: a.commonProperties.Proprietary,
config: ctx.Config().(Config),
installInData: a.module.InstallInData(),
@@ -418,7 +413,9 @@
}
type androidBaseContextImpl struct {
- target Target
+ arch Arch
+ hod HostOrDevice
+ ht HostType
debug bool
config Config
proprietary bool
@@ -497,28 +494,28 @@
}
}
-func (a *androidBaseContextImpl) Target() Target {
- return a.target
-}
-
func (a *androidBaseContextImpl) Arch() Arch {
- return a.target.Arch
+ return a.arch
}
-func (a *androidBaseContextImpl) Os() OsType {
- return a.target.Os
+func (a *androidBaseContextImpl) HostOrDevice() HostOrDevice {
+ return a.hod
+}
+
+func (a *androidBaseContextImpl) HostType() HostType {
+ return a.ht
}
func (a *androidBaseContextImpl) Host() bool {
- return a.target.Os.Class == Host || a.target.Os.Class == HostCross
+ return a.hod.Host()
}
func (a *androidBaseContextImpl) Device() bool {
- return a.target.Os.Class == Device
+ return a.hod.Device()
}
func (a *androidBaseContextImpl) Darwin() bool {
- return a.target.Os == Darwin
+ return a.hod.Host() && a.ht == Darwin
}
func (a *androidBaseContextImpl) Debug() bool {
diff --git a/android/paths.go b/android/paths.go
index 35ed180..910ebd2 100644
--- a/android/paths.go
+++ b/android/paths.go
@@ -629,7 +629,7 @@
}
outPaths = []string{"target", "product", ctx.AConfig().DeviceName(), partition}
} else {
- outPaths = []string{"host", ctx.Os().String() + "-x86"}
+ outPaths = []string{"host", ctx.HostType().String() + "-x86"}
}
if ctx.Debug() {
outPaths = append([]string{"debug"}, outPaths...)