Simplify arch target handling
Soong's multi-architecture building has grown complex, with the
combination of HostOrDevice+HostType+Arch necessary to determine how to
build a variant of a module, and three separate mutators to split each
into its variations.
Combine HostOrDevice+HostType into Os, which will be Linux, Darwin,
Windows, or Android. Store Os+Arch as a single Target.
Change-Id: I92f2e2dac53617d595a35cc285d2bd348baa0fbd
diff --git a/android/androidmk.go b/android/androidmk.go
index 603b37d..8d2951d 100644
--- a/android/androidmk.go
+++ b/android/androidmk.go
@@ -149,27 +149,21 @@
name += "_" + data.SubName
}
- hostCross := false
- if amod.Host() && amod.HostType() != CurrentHostType() {
- hostCross = true
- }
-
if data.Custom != nil {
prefix := ""
- 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 {
+ switch amod.Os().Class {
+ case Host:
+ prefix = "HOST_"
+ case HostCross:
+ prefix = "HOST_CROSS_"
+ case Device:
prefix = "TARGET_"
- if amod.Arch().ArchType != ctx.Config().(Config).DeviceArches[0].ArchType {
- prefix = "2ND_" + prefix
- }
+
+ }
+
+ config := ctx.Config().(Config)
+ if amod.Arch().ArchType != config.Targets[amod.Os().Class][0].Arch.ArchType {
+ prefix = "2ND_" + prefix
}
return data.Custom(w, name, prefix)
@@ -191,15 +185,15 @@
fmt.Fprintln(w, "LOCAL_PREBUILT_MODULE_FILE :=", data.OutputFile.String())
archStr := amod.Arch().ArchType.String()
- 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 {
+ 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:
fmt.Fprintln(w, "LOCAL_MODULE_TARGET_ARCH :=", archStr)
if len(amod.commonProperties.Logtags) > 0 {
@@ -207,6 +201,11 @@
}
}
+ 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 48cc0ab..0673249 100644
--- a/android/arch.go
+++ b/android/arch.go
@@ -28,8 +28,6 @@
RegisterBottomUpMutator("defaults_deps", defaultsDepsMutator)
RegisterTopDownMutator("defaults", defaultsMutator)
- RegisterBottomUpMutator("host_or_device", HostOrDeviceMutator)
- RegisterBottomUpMutator("host_type", HostTypeMutator)
RegisterBottomUpMutator("arch", ArchMutator)
}
@@ -333,75 +331,7 @@
return a.Name
}
-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 {
+var BuildOs = func() OsType {
switch runtime.GOOS {
case "linux":
return Linux
@@ -410,98 +340,71 @@
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
}
-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))
- }
+type OsClass int
+
+const (
+ Device OsClass = iota
+ Host
+ HostCross
+)
+
+func (os OsType) String() string {
+ return os.Name
}
-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))
+func NewOsType(name string, class OsClass) OsType {
+ os := OsType{
+ Name: name,
+ Field: strings.Title(name),
+ Class: class,
}
+ osTypeList = append(osTypeList, os)
+ return os
+}
+
+func osByName(name string) OsType {
+ for _, os := range osTypeList {
+ if os.Name == name {
+ return os
+ }
+ }
+
+ return NoOsType
}
var (
- commonArch = Arch{
- ArchType: Common,
+ commonTarget = Target{
+ Os: Android,
+ Arch: Arch{
+ ArchType: Common,
+ },
}
)
-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])
- }
+type Target struct {
+ Os OsType
+ Arch Arch
}
-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 (target Target) String() string {
+ return target.Os.String() + "_" + target.Arch.String()
}
func ArchMutator(mctx BottomUpMutatorContext) {
@@ -511,40 +414,36 @@
return
}
- moduleArches := []Arch{}
- multilib := module.base().commonProperties.Compile_multilib
+ osClasses := module.base().OsClassSupported()
- 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())
- }
-
- moduleArches = append(moduleArches, hostModuleArches...)
- }
-
- if module.base().DeviceSupported() && module.base().HostOrDevice().Device() {
- deviceModuleArches, err := decodeMultilib(multilib, mctx.Config().(Config).DeviceArches)
- if err != nil {
- mctx.ModuleErrorf("%s", err.Error())
- }
-
- moduleArches = append(moduleArches, deviceModuleArches...)
- }
-
- if len(moduleArches) == 0 {
+ if len(osClasses) == 0 {
return
}
- archNames := []string{}
- for _, arch := range moduleArches {
- archNames = append(archNames, arch.String())
+ var moduleTargets []Target
+
+ for _, class := range osClasses {
+ targets := mctx.AConfig().Targets[class]
+ if len(targets) == 0 {
+ continue
+ }
+ multilib := module.base().commonProperties.Compile_multilib
+ targets, err := decodeMultilib(multilib, targets)
+ if err != nil {
+ mctx.ModuleErrorf("%s", err.Error())
+ }
+ moduleTargets = append(moduleTargets, targets...)
}
- modules := mctx.CreateVariations(archNames...)
+ targetNames := make([]string, len(moduleTargets))
+ for i, target := range moduleTargets {
+ targetNames[i] = target.String()
+ }
+
+ modules := mctx.CreateVariations(targetNames...)
for i, m := range modules {
- m.(Module).base().SetArch(moduleArches[i])
+ m.(Module).base().SetTarget(moduleTargets[i])
m.(Module).base().setArchProperties(mctx)
}
}
@@ -648,9 +547,8 @@
// Rewrite the module's properties structs to contain arch-specific values.
func (a *ModuleBase) setArchProperties(ctx BottomUpMutatorContext) {
- arch := a.commonProperties.CompileArch
- hod := a.commonProperties.CompileHostOrDevice
- ht := a.commonProperties.CompileHostType
+ arch := a.Arch()
+ os := a.Os()
if arch.ArchType == Common {
return
@@ -719,18 +617,19 @@
prefix = "multilib." + t.Multilib
a.appendProperties(ctx, genProps, archProps.Multilib, field, prefix)
- // Handle host-or-device-specific properties in the form:
+ // Handle host-specific properties in the form:
// target: {
// host: {
// key: value,
// },
// },
- hodProperty := hod.Property()
- field = proptools.FieldNameForProperty(hodProperty)
- prefix = "target." + hodProperty
- a.appendProperties(ctx, genProps, archProps.Target, field, prefix)
+ if os.Class == Host || os.Class == HostCross {
+ field = "Host"
+ prefix = "target.host"
+ a.appendProperties(ctx, genProps, archProps.Target, field, prefix)
+ }
- // Handle host target properties in the form:
+ // Handle target OS properties in the form:
// target: {
// linux: {
// key: value,
@@ -744,22 +643,29 @@
// linux_arm: {
// key: value,
// },
+ // android {
+ // key: value,
+ // },
+ // android_arm {
+ // key: value,
+ // },
+ // android_x86 {
+ // key: value,
+ // },
// },
- if hod.Host() {
- field := ht.Field()
- prefix := "target." + ht.String()
- a.appendProperties(ctx, genProps, archProps.Target, field, prefix)
+ // },
+ field = os.Field
+ prefix = "target." + os.Name
+ 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)
+ field = os.Field + "_" + t.Name
+ prefix = "target." + os.Name + "_" + 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)
- }
+ if (os.Class == Host || os.Class == HostCross) && os != Windows {
+ field := "Not_windows"
+ prefix := "target.not_windows"
+ a.appendProperties(ctx, genProps, archProps.Target, field, prefix)
}
// Handle 64-bit device properties in the form:
@@ -775,8 +681,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 hod.Device() {
- if true /* && target_is_64_bit */ {
+ if os.Class == Device {
+ if ctx.AConfig().Android64() {
field := "Android64"
prefix := "target.android64"
a.appendProperties(ctx, genProps, archProps.Target, field, prefix)
@@ -786,26 +692,6 @@
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
- }
}
}
@@ -824,104 +710,84 @@
}
}
-// Get a list of HostTypes from the product variables
-func decodeHostTypesProductVariables(variables productVariables) ([]HostType, error) {
- ret := []HostType{CurrentHostType()}
+// 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
- 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)
+ targets := make(map[OsClass][]Target)
+ var targetErr error
+
+ addTarget := func(os OsType, archName string, archVariant, cpuVariant *string, abi *[]string) {
+ if targetErr != nil {
+ return
}
+
+ 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, nil, fmt.Errorf("No host primary architecture set")
+ return nil, fmt.Errorf("No host primary architecture set")
}
- hostArch, err := decodeArch(*variables.HostArch, nil, nil, nil)
- if err != nil {
- return nil, nil, err
- }
-
- hostArches := []Arch{hostArch}
+ addTarget(BuildOs, *variables.HostArch, nil, nil, nil)
if variables.HostSecondaryArch != nil && *variables.HostSecondaryArch != "" {
- 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,
+ addTarget(BuildOs, *variables.HostSecondaryArch, nil, nil, nil)
}
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, nil, fmt.Errorf("No cross-host primary architecture set")
+ return nil, fmt.Errorf("No cross-host primary architecture set")
}
- crossHostArch, err := decodeArch(*variables.CrossHostArch, nil, nil, nil)
- if err != nil {
- return nil, nil, err
- }
-
- crossHostArches := []Arch{crossHostArch}
+ addTarget(crossHostOs, *variables.CrossHostArch, nil, nil, nil)
if variables.CrossHostSecondaryArch != nil && *variables.CrossHostSecondaryArch != "" {
- 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)
+ addTarget(crossHostOs, *variables.CrossHostSecondaryArch, nil, nil, nil)
}
}
if variables.DeviceArch == nil {
- return nil, nil, fmt.Errorf("No device primary architecture set")
+ return nil, fmt.Errorf("No device primary architecture set")
}
- deviceArch, err := decodeArch(*variables.DeviceArch, variables.DeviceArchVariant,
+ addTarget(Android, *variables.DeviceArch, variables.DeviceArchVariant,
variables.DeviceCpuVariant, variables.DeviceAbi)
- if err != nil {
- return nil, nil, err
- }
-
- deviceArches := []Arch{deviceArch}
if variables.DeviceSecondaryArch != nil && *variables.DeviceSecondaryArch != "" {
- deviceSecondaryArch, err := decodeArch(*variables.DeviceSecondaryArch,
+ addTarget(Android, *variables.DeviceSecondaryArch,
variables.DeviceSecondaryArchVariant, variables.DeviceSecondaryCpuVariant,
variables.DeviceSecondaryAbi)
- if err != nil {
- return nil, nil, err
+
+ deviceArches := targets[Device]
+ if deviceArches[0].Arch.ArchType.Multilib == deviceArches[1].Arch.ArchType.Multilib {
+ deviceArches[1].Arch.Native = false
}
- if deviceArch.ArchType.Multilib == deviceSecondaryArch.ArchType.Multilib {
- deviceSecondaryArch.Native = false
- }
- deviceArches = append(deviceArches, deviceSecondaryArch)
}
- return hostTypeArches, deviceArches, nil
+ if targetErr != nil {
+ return nil, targetErr
+ }
+
+ return targets, nil
}
-func decodeMegaDevice() ([]Arch, error) {
+func decodeMegaDevice() ([]Target, error) {
archSettings := []struct {
arch string
archVariant string
@@ -969,7 +835,7 @@
{"x86_64", "silvermont", "", []string{"x86_64"}},
}
- var ret []Arch
+ var ret []Target
for _, config := range archSettings {
arch, err := decodeArch(config.arch, &config.archVariant,
@@ -978,7 +844,10 @@
return nil, err
}
arch.Native = false
- ret = append(ret, arch)
+ ret = append(ret, Target{
+ Os: Android,
+ Arch: arch,
+ })
}
return ret, nil
@@ -1035,33 +904,32 @@
return a, nil
}
-// 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{}
+// 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{}
switch multilib {
case "common":
- buildArches = append(buildArches, commonArch)
+ buildTargets = append(buildTargets, commonTarget)
case "both":
- buildArches = append(buildArches, arches...)
+ buildTargets = append(buildTargets, targets...)
case "first":
- buildArches = append(buildArches, arches[0])
+ buildTargets = append(buildTargets, targets[0])
case "32":
- for _, a := range arches {
- if a.ArchType.Multilib == "lib32" {
- buildArches = append(buildArches, a)
+ for _, t := range targets {
+ if t.Arch.ArchType.Multilib == "lib32" {
+ buildTargets = append(buildTargets, t)
}
}
case "64":
- for _, a := range arches {
- if a.ArchType.Multilib == "lib64" {
- buildArches = append(buildArches, a)
+ for _, t := range targets {
+ if t.Arch.ArchType.Multilib == "lib64" {
+ buildTargets = append(buildTargets, t)
}
}
default:
return nil, fmt.Errorf(`compile_multilib must be "both", "first", "32", or "64", found %q`,
multilib)
- //buildArches = append(buildArches, arches[0])
}
- return buildArches, nil
+ return buildTargets, nil
}
diff --git a/android/config.go b/android/config.go
index ee95d2e..5024bce 100644
--- a/android/config.go
+++ b/android/config.go
@@ -54,8 +54,8 @@
ConfigFileName string
ProductVariablesFileName string
- DeviceArches []Arch
- HostArches map[HostType][]Arch
+ Targets map[OsClass][]Target
+ BuildOsVariant string
srcDir string // the path of the root source directory
buildDir string // the path of the build output directory
@@ -175,20 +175,21 @@
config.inMake = true
}
- hostArches, deviceArches, err := decodeArchProductVariables(config.ProductVariables)
+ targets, err := decodeTargetProductVariables(config)
if err != nil {
return Config{}, err
}
if Bool(config.Mega_device) {
- deviceArches, err = decodeMegaDevice()
+ deviceTargets, err := decodeMegaDevice()
if err != nil {
return Config{}, err
}
+ targets[Device] = deviceTargets
}
- config.HostArches = hostArches
- config.DeviceArches = deviceArches
+ config.Targets = targets
+ config.BuildOsVariant = targets[Host][0].String()
return config, nil
}
@@ -325,3 +326,13 @@
}
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 1855523..0e608d7 100644
--- a/android/module.go
+++ b/android/module.go
@@ -48,9 +48,9 @@
}
type androidBaseContext interface {
+ Target() Target
Arch() Arch
- HostOrDevice() HostOrDevice
- HostType() HostType
+ Os() OsType
Host() bool
Device() bool
Darwin() bool
@@ -90,7 +90,7 @@
base() *ModuleBase
Enabled() bool
- HostOrDevice() HostOrDevice
+ Target() Target
InstallInData() bool
}
@@ -115,14 +115,8 @@
// file
Logtags []string
- // Set by HostOrDeviceMutator
- CompileHostOrDevice HostOrDevice `blueprint:"mutated"`
-
- // Set by HostTypeMutator
- CompileHostType HostType `blueprint:"mutated"`
-
- // Set by ArchMutator
- CompileArch Arch `blueprint:"mutated"`
+ // Set by TargetMutator
+ CompileTarget Target `blueprint:"mutated"`
// Set by InitAndroidModule
HostOrDeviceSupported HostOrDeviceSupported `blueprint:"mutated"`
@@ -142,6 +136,16 @@
MultilibDefault Multilib = ""
)
+type HostOrDeviceSupported int
+
+const (
+ _ HostOrDeviceSupported = iota
+ HostSupported
+ DeviceSupported
+ HostAndDeviceSupported
+ HostAndDeviceDefault
+)
+
func InitAndroidModule(m Module,
propertyStructs ...interface{}) (blueprint.Module, []interface{}) {
@@ -241,38 +245,45 @@
return a
}
-func (a *ModuleBase) SetHostOrDevice(hod HostOrDevice) {
- a.commonProperties.CompileHostOrDevice = hod
+func (a *ModuleBase) SetTarget(target Target) {
+ a.commonProperties.CompileTarget = target
}
-func (a *ModuleBase) SetHostType(ht HostType) {
- a.commonProperties.CompileHostType = ht
+func (a *ModuleBase) Target() Target {
+ return a.commonProperties.CompileTarget
}
-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) Os() OsType {
+ return a.Target().Os
}
func (a *ModuleBase) Host() bool {
- return a.HostOrDevice().Host()
+ return a.Os().Class == Host || a.Os().Class == HostCross
}
func (a *ModuleBase) Arch() Arch {
- return a.commonProperties.CompileArch
+ return a.Target().Arch
}
-func (a *ModuleBase) HostSupported() bool {
- return a.commonProperties.HostOrDeviceSupported == HostSupported ||
- a.commonProperties.HostOrDeviceSupported == HostAndDeviceSupported &&
- a.hostAndDeviceProperties.Host_supported
+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) DeviceSupported() bool {
@@ -283,11 +294,7 @@
func (a *ModuleBase) Enabled() bool {
if a.commonProperties.Enabled == nil {
- if a.HostSupported() && a.HostOrDevice().Host() && a.HostType() == Windows {
- return false
- } else {
- return true
- }
+ return a.Os().Class != HostCross
}
return *a.commonProperties.Enabled
}
@@ -376,9 +383,7 @@
func (a *ModuleBase) androidBaseContextFactory(ctx blueprint.BaseModuleContext) androidBaseContextImpl {
return androidBaseContextImpl{
- arch: a.commonProperties.CompileArch,
- hod: a.commonProperties.CompileHostOrDevice,
- ht: a.commonProperties.CompileHostType,
+ target: a.commonProperties.CompileTarget,
proprietary: a.commonProperties.Proprietary,
config: ctx.Config().(Config),
installInData: a.module.InstallInData(),
@@ -413,9 +418,7 @@
}
type androidBaseContextImpl struct {
- arch Arch
- hod HostOrDevice
- ht HostType
+ target Target
debug bool
config Config
proprietary bool
@@ -494,28 +497,28 @@
}
}
+func (a *androidBaseContextImpl) Target() Target {
+ return a.target
+}
+
func (a *androidBaseContextImpl) Arch() Arch {
- return a.arch
+ return a.target.Arch
}
-func (a *androidBaseContextImpl) HostOrDevice() HostOrDevice {
- return a.hod
-}
-
-func (a *androidBaseContextImpl) HostType() HostType {
- return a.ht
+func (a *androidBaseContextImpl) Os() OsType {
+ return a.target.Os
}
func (a *androidBaseContextImpl) Host() bool {
- return a.hod.Host()
+ return a.target.Os.Class == Host || a.target.Os.Class == HostCross
}
func (a *androidBaseContextImpl) Device() bool {
- return a.hod.Device()
+ return a.target.Os.Class == Device
}
func (a *androidBaseContextImpl) Darwin() bool {
- return a.hod.Host() && a.ht == Darwin
+ return a.target.Os == Darwin
}
func (a *androidBaseContextImpl) Debug() bool {
diff --git a/android/paths.go b/android/paths.go
index 910ebd2..35ed180 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.HostType().String() + "-x86"}
+ outPaths = []string{"host", ctx.Os().String() + "-x86"}
}
if ctx.Debug() {
outPaths = append([]string{"debug"}, outPaths...)
diff --git a/cc/arm64_device.go b/cc/arm64_device.go
index 4e41287..8e7c57b 100644
--- a/cc/arm64_device.go
+++ b/cc/arm64_device.go
@@ -208,5 +208,5 @@
}
func init() {
- registerDeviceToolchainFactory(android.Arm64, arm64ToolchainFactory)
+ registerToolchainFactory(android.Android, android.Arm64, arm64ToolchainFactory)
}
diff --git a/cc/arm_device.go b/cc/arm_device.go
index 766eea6..1624cfc 100644
--- a/cc/arm_device.go
+++ b/cc/arm_device.go
@@ -392,5 +392,5 @@
}
func init() {
- registerDeviceToolchainFactory(android.Arm, armToolchainFactory)
+ registerToolchainFactory(android.Android, android.Arm, armToolchainFactory)
}
diff --git a/cc/cc.go b/cc/cc.go
index bac3e88..3cc0d0d 100644
--- a/cc/cc.go
+++ b/cc/cc.go
@@ -118,7 +118,7 @@
)
func init() {
- if android.CurrentHostType() == android.Linux {
+ if android.BuildOs == android.Linux {
commonGlobalCflags = append(commonGlobalCflags, "-fdebug-prefix-map=/proc/self/cwd=")
}
@@ -729,11 +729,10 @@
func (c *Module) toolchain(ctx BaseModuleContext) Toolchain {
if c.cachedToolchain == nil {
arch := ctx.Arch()
- hod := ctx.HostOrDevice()
- ht := ctx.HostType()
- factory := toolchainFactories[hod][ht][arch.ArchType]
+ os := ctx.Os()
+ factory := toolchainFactories[os][arch.ArchType]
if factory == nil {
- ctx.ModuleErrorf("Toolchain not found for %s %s arch %q", hod.String(), ht.String(), arch.String())
+ ctx.ModuleErrorf("Toolchain not found for %s arch %q", os.String(), arch.String())
return nil
}
c.cachedToolchain = factory(arch)
@@ -905,8 +904,13 @@
return
}
- if a.HostOrDevice() != ctx.HostOrDevice() {
- ctx.ModuleErrorf("host/device mismatch between %q and %q", ctx.ModuleName(), name)
+ if a.Target().Os != ctx.Os() {
+ ctx.ModuleErrorf("OS mismatch between %q and %q", ctx.ModuleName(), name)
+ return
+ }
+
+ if a.Target().Arch.ArchType != ctx.Arch().ArchType {
+ ctx.ModuleErrorf("Arch mismatch between %q and %q", ctx.ModuleName(), name)
return
}
@@ -1081,6 +1085,11 @@
flags.LdFlags = append(flags.LdFlags, target, gccPrefix)
}
+ hod := "host"
+ if ctx.Os().Class == android.Device {
+ hod = "device"
+ }
+
if !ctx.noDefaultCompilerFlags() {
flags.GlobalFlags = append(flags.GlobalFlags, instructionSetFlags)
@@ -1090,7 +1099,7 @@
flags.GlobalFlags = append(flags.GlobalFlags,
toolchain.ClangCflags(),
"${commonClangGlobalCflags}",
- fmt.Sprintf("${%sClangGlobalCflags}", ctx.HostOrDevice()))
+ fmt.Sprintf("${%sClangGlobalCflags}", hod))
flags.ConlyFlags = append(flags.ConlyFlags, "${clangExtraConlyflags}")
} else {
@@ -1098,7 +1107,7 @@
flags.GlobalFlags = append(flags.GlobalFlags,
toolchain.Cflags(),
"${commonGlobalCflags}",
- fmt.Sprintf("${%sGlobalCflags}", ctx.HostOrDevice()))
+ fmt.Sprintf("${%sGlobalCflags}", hod))
}
if Bool(ctx.AConfig().ProductVariables.Brillo) {
@@ -1410,7 +1419,7 @@
// MinGW spits out warnings about -fPIC even for -fpie?!) being ignored because
// all code is position independent, and then those warnings get promoted to
// errors.
- if ctx.HostType() != android.Windows {
+ if ctx.Os() != android.Windows {
flags.CFlags = append(flags.CFlags, "-fPIC")
}
@@ -1863,7 +1872,7 @@
static := Bool(binary.Properties.Static_executable)
if ctx.Host() {
- if ctx.HostType() == android.Linux {
+ if ctx.Os() == android.Linux {
if binary.Properties.Static_executable == nil && Bool(ctx.AConfig().ProductVariables.HostStaticBinaries) {
static = true
}
@@ -1883,7 +1892,7 @@
if ctx.Host() && !binary.staticBinary() {
flags.LdFlags = append(flags.LdFlags, "-pie")
- if ctx.HostType() == android.Windows {
+ if ctx.Os() == android.Windows {
flags.LdFlags = append(flags.LdFlags, "-Wl,-e_mainCRTStartup")
}
}
@@ -1891,7 +1900,7 @@
// MinGW spits out warnings about -fPIC even for -fpie?!) being ignored because
// all code is position independent, and then those warnings get promoted to
// errors.
- if ctx.HostType() != android.Windows {
+ if ctx.Os() != android.Windows {
flags.CFlags = append(flags.CFlags, "-fpie")
}
@@ -1945,7 +1954,7 @@
fileName := binary.getStem(ctx) + flags.Toolchain.ExecutableSuffix()
outputFile := android.PathForModuleOut(ctx, fileName)
ret := outputFile
- if ctx.HostOrDevice().Host() {
+ if ctx.Os().Class == android.Host {
binary.hostToolPath = android.OptionalPathForPath(outputFile)
}
@@ -2052,7 +2061,7 @@
if ctx.Host() {
flags.CFlags = append(flags.CFlags, "-O0", "-g")
- switch ctx.HostType() {
+ switch ctx.Os() {
case android.Windows:
flags.CFlags = append(flags.CFlags, "-DGTEST_OS_WINDOWS")
case android.Linux:
diff --git a/cc/makevars.go b/cc/makevars.go
index 863e3dc..f107eff 100644
--- a/cc/makevars.go
+++ b/cc/makevars.go
@@ -41,49 +41,54 @@
ctx.Strict("GLOBAL_CPPFLAGS_NO_OVERRIDE", "")
ctx.Strict("GLOBAL_CLANG_CPPFLAGS_NO_OVERRIDE", "")
- hostType := android.CurrentHostType()
- arches := ctx.Config().HostArches[hostType]
- makeVarsToolchain(ctx, "", android.Host, hostType, arches[0])
- if len(arches) > 1 {
- makeVarsToolchain(ctx, "2ND_", android.Host, hostType, arches[1])
+ hostTargets := ctx.Config().Targets[android.Host]
+ makeVarsToolchain(ctx, "", hostTargets[0])
+ if len(hostTargets) > 1 {
+ makeVarsToolchain(ctx, "2ND_", hostTargets[1])
}
- if winArches, ok := ctx.Config().HostArches[android.Windows]; ok {
- makeVarsToolchain(ctx, "", android.Host, android.Windows, winArches[0])
- if len(winArches) > 1 {
- makeVarsToolchain(ctx, "2ND_", android.Host, android.Windows, winArches[1])
+ crossTargets := ctx.Config().Targets[android.HostCross]
+ if len(crossTargets) > 0 {
+ makeVarsToolchain(ctx, "", crossTargets[0])
+ if len(crossTargets) > 1 {
+ makeVarsToolchain(ctx, "2ND_", crossTargets[1])
}
}
- arches = ctx.Config().DeviceArches
- makeVarsToolchain(ctx, "", android.Device, android.NoHostType, arches[0])
- if len(arches) > 1 {
- makeVarsToolchain(ctx, "2ND_", android.Device, android.NoHostType, arches[1])
+ deviceTargets := ctx.Config().Targets[android.Device]
+ makeVarsToolchain(ctx, "", deviceTargets[0])
+ if len(deviceTargets) > 1 {
+ makeVarsToolchain(ctx, "2ND_", deviceTargets[1])
}
}
func makeVarsToolchain(ctx android.MakeVarsContext, secondPrefix string,
- hod android.HostOrDevice, ht android.HostType, arch android.Arch) {
+ target android.Target) {
var typePrefix string
- if hod.Host() {
- if ht == android.Windows {
- typePrefix = "HOST_CROSS_"
- } else {
- typePrefix = "HOST_"
- }
- } else {
+ switch target.Os.Class {
+ case android.Host:
+ typePrefix = "HOST_"
+ case android.HostCross:
+ typePrefix = "HOST_CROSS_"
+ case android.Device:
typePrefix = "TARGET_"
}
makePrefix := secondPrefix + typePrefix
- toolchain := toolchainFactories[hod][ht][arch.ArchType](arch)
+ toolchain := toolchainFactories[target.Os][target.Arch.ArchType](target.Arch)
var productExtraCflags string
var productExtraLdflags string
- if hod.Device() && Bool(ctx.Config().ProductVariables.Brillo) {
+
+ hod := "host"
+ if target.Os.Class == android.Device {
+ hod = "device"
+ }
+
+ if target.Os.Class == android.Device && Bool(ctx.Config().ProductVariables.Brillo) {
productExtraCflags += "-D__BRILLO__"
}
- if hod.Host() && Bool(ctx.Config().ProductVariables.HostStaticBinaries) {
+ if target.Os.Class == android.Host && Bool(ctx.Config().ProductVariables.HostStaticBinaries) {
productExtraLdflags += "-static"
}
@@ -108,23 +113,29 @@
ctx.Strict(makePrefix+"SYSTEMCPP_LDFLAGS", toolchain.SystemCppLdflags())
includeFlags, err := ctx.Eval(toolchain.IncludeFlags())
- if err != nil { panic(err) }
+ if err != nil {
+ panic(err)
+ }
ctx.StrictRaw(makePrefix+"C_INCLUDES", strings.Replace(includeFlags, "-isystem ", "", -1))
- if arch.ArchType == android.Arm {
+ if target.Arch.ArchType == android.Arm {
flags, err := toolchain.InstructionSetFlags("arm")
- if err != nil { panic(err) }
+ if err != nil {
+ panic(err)
+ }
ctx.Strict(makePrefix+"arm_CFLAGS", flags)
flags, err = toolchain.InstructionSetFlags("thumb")
- if err != nil { panic(err) }
+ if err != nil {
+ panic(err)
+ }
ctx.Strict(makePrefix+"thumb_CFLAGS", flags)
}
if toolchain.ClangSupported() {
clangPrefix := secondPrefix + "CLANG_" + typePrefix
clangExtras := "-target " + toolchain.ClangTriple()
- if ht != android.Darwin {
+ if target.Os != android.Darwin {
clangExtras += " -B" + filepath.Join(toolchain.GccRoot(), toolchain.GccTriple(), "bin")
}
@@ -148,19 +159,19 @@
clangExtras,
}, " "))
- if hod.Device() {
- ctx.Strict(secondPrefix + "ADDRESS_SANITIZER_RUNTIME_LIBRARY", strings.TrimSuffix(toolchain.AddressSanitizerRuntimeLibrary(), ".so"))
+ if target.Os.Class == android.Device {
+ ctx.Strict(secondPrefix+"ADDRESS_SANITIZER_RUNTIME_LIBRARY", strings.TrimSuffix(toolchain.AddressSanitizerRuntimeLibrary(), ".so"))
}
// This is used by external/gentoo/...
- ctx.Strict("CLANG_CONFIG_" + arch.ArchType.Name + "_" + typePrefix + "TRIPLE",
+ ctx.Strict("CLANG_CONFIG_"+target.Arch.ArchType.Name+"_"+typePrefix+"TRIPLE",
toolchain.ClangTriple())
}
ctx.Strict(makePrefix+"CC", gccCmd(toolchain, "gcc"))
ctx.Strict(makePrefix+"CXX", gccCmd(toolchain, "g++"))
- if ht == android.Darwin {
+ if target.Os == android.Darwin {
ctx.Strict(makePrefix+"AR", "${macArPath}")
} else {
ctx.Strict(makePrefix+"AR", gccCmd(toolchain, "ar"))
@@ -168,11 +179,11 @@
ctx.Strict(makePrefix+"NM", gccCmd(toolchain, "nm"))
}
- if ht == android.Windows {
+ if target.Os == android.Windows {
ctx.Strict(makePrefix+"OBJDUMP", gccCmd(toolchain, "objdump"))
}
- if hod.Device() {
+ if target.Os.Class == android.Device {
ctx.Strict(makePrefix+"OBJCOPY", gccCmd(toolchain, "objcopy"))
ctx.Strict(makePrefix+"LD", gccCmd(toolchain, "ld"))
ctx.Strict(makePrefix+"STRIP", gccCmd(toolchain, "strip"))
diff --git a/cc/mips64_device.go b/cc/mips64_device.go
index 04e31a9..474f284 100644
--- a/cc/mips64_device.go
+++ b/cc/mips64_device.go
@@ -200,5 +200,5 @@
}
func init() {
- registerDeviceToolchainFactory(android.Mips64, mips64ToolchainFactory)
+ registerToolchainFactory(android.Android, android.Mips64, mips64ToolchainFactory)
}
diff --git a/cc/mips_device.go b/cc/mips_device.go
index 0dbbbd7..f9dc5c6 100644
--- a/cc/mips_device.go
+++ b/cc/mips_device.go
@@ -248,5 +248,5 @@
}
func init() {
- registerDeviceToolchainFactory(android.Mips, mipsToolchainFactory)
+ registerToolchainFactory(android.Android, android.Mips, mipsToolchainFactory)
}
diff --git a/cc/stl.go b/cc/stl.go
index cdc887e..c5dbae3 100644
--- a/cc/stl.go
+++ b/cc/stl.go
@@ -52,7 +52,7 @@
ctx.ModuleErrorf("stl: %q is not a supported STL with sdk_version set", stl.Properties.Stl)
return ""
}
- } else if ctx.HostType() == android.Windows {
+ } else if ctx.Os() == android.Windows {
switch stl.Properties.Stl {
case "libc++", "libc++_static", "libstdc++", "":
// libc++ is not supported on mingw
@@ -60,7 +60,7 @@
case "none":
return ""
default:
- ctx.ModuleErrorf("stl: %q is not a supported STL", stl.Properties.Stl)
+ ctx.ModuleErrorf("stl: %q is not a supported STL for windows", stl.Properties.Stl)
return ""
}
} else {
@@ -133,9 +133,9 @@
flags.LdFlags = append(flags.LdFlags, "-nodefaultlibs")
flags.LdFlags = append(flags.LdFlags, "-lpthread", "-lm")
if ctx.staticBinary() {
- flags.LdFlags = append(flags.LdFlags, hostStaticGccLibs[ctx.HostType()]...)
+ flags.LdFlags = append(flags.LdFlags, hostStaticGccLibs[ctx.Os()]...)
} else {
- flags.LdFlags = append(flags.LdFlags, hostDynamicGccLibs[ctx.HostType()]...)
+ flags.LdFlags = append(flags.LdFlags, hostDynamicGccLibs[ctx.Os()]...)
}
} else {
if ctx.Arch().ArchType == android.Arm {
@@ -167,9 +167,9 @@
flags.CppFlags = append(flags.CppFlags, "-nostdinc++")
flags.LdFlags = append(flags.LdFlags, "-nodefaultlibs")
if ctx.staticBinary() {
- flags.LdFlags = append(flags.LdFlags, hostStaticGccLibs[ctx.HostType()]...)
+ flags.LdFlags = append(flags.LdFlags, hostStaticGccLibs[ctx.Os()]...)
} else {
- flags.LdFlags = append(flags.LdFlags, hostDynamicGccLibs[ctx.HostType()]...)
+ flags.LdFlags = append(flags.LdFlags, hostDynamicGccLibs[ctx.Os()]...)
}
}
default:
@@ -179,10 +179,10 @@
return flags
}
-var hostDynamicGccLibs, hostStaticGccLibs map[android.HostType][]string
+var hostDynamicGccLibs, hostStaticGccLibs map[android.OsType][]string
func init() {
- hostDynamicGccLibs = map[android.HostType][]string{
+ hostDynamicGccLibs = map[android.OsType][]string{
android.Linux: []string{"-lgcc_s", "-lgcc", "-lc", "-lgcc_s", "-lgcc"},
android.Darwin: []string{"-lc", "-lSystem"},
android.Windows: []string{"-lmsvcr110", "-lmingw32", "-lgcc", "-lmoldname",
@@ -190,7 +190,7 @@
"-lkernel32", "-lmingw32", "-lgcc", "-lmoldname", "-lmingwex",
"-lmsvcrt"},
}
- hostStaticGccLibs = map[android.HostType][]string{
+ hostStaticGccLibs = map[android.OsType][]string{
android.Linux: []string{"-Wl,--start-group", "-lgcc", "-lgcc_eh", "-lc", "-Wl,--end-group"},
android.Darwin: []string{"NO_STATIC_HOST_BINARIES_ON_DARWIN"},
android.Windows: []string{"NO_STATIC_HOST_BINARIES_ON_WINDOWS"},
diff --git a/cc/toolchain.go b/cc/toolchain.go
index efb7953..87657ef 100644
--- a/cc/toolchain.go
+++ b/cc/toolchain.go
@@ -22,23 +22,13 @@
type toolchainFactory func(arch android.Arch) Toolchain
-var toolchainFactories = map[android.HostOrDevice]map[android.HostType]map[android.ArchType]toolchainFactory{
- android.Host: map[android.HostType]map[android.ArchType]toolchainFactory{
- android.Linux: make(map[android.ArchType]toolchainFactory),
- android.Darwin: make(map[android.ArchType]toolchainFactory),
- android.Windows: make(map[android.ArchType]toolchainFactory),
- },
- android.Device: map[android.HostType]map[android.ArchType]toolchainFactory{
- android.NoHostType: make(map[android.ArchType]toolchainFactory),
- },
-}
+var toolchainFactories = make(map[android.OsType]map[android.ArchType]toolchainFactory)
-func registerDeviceToolchainFactory(arch android.ArchType, factory toolchainFactory) {
- toolchainFactories[android.Device][android.NoHostType][arch] = factory
-}
-
-func registerHostToolchainFactory(ht android.HostType, arch android.ArchType, factory toolchainFactory) {
- toolchainFactories[android.Host][ht][arch] = factory
+func registerToolchainFactory(os android.OsType, arch android.ArchType, factory toolchainFactory) {
+ if toolchainFactories[os] == nil {
+ toolchainFactories[os] = make(map[android.ArchType]toolchainFactory)
+ }
+ toolchainFactories[os][arch] = factory
}
type Toolchain interface {
diff --git a/cc/x86_64_device.go b/cc/x86_64_device.go
index 9a0d663..986dc86 100644
--- a/cc/x86_64_device.go
+++ b/cc/x86_64_device.go
@@ -263,5 +263,5 @@
}
func init() {
- registerDeviceToolchainFactory(android.X86_64, x86_64ToolchainFactory)
+ registerToolchainFactory(android.Android, android.X86_64, x86_64ToolchainFactory)
}
diff --git a/cc/x86_darwin_host.go b/cc/x86_darwin_host.go
index f3cf1c9..987b1dd 100644
--- a/cc/x86_darwin_host.go
+++ b/cc/x86_darwin_host.go
@@ -280,6 +280,6 @@
}
func init() {
- registerHostToolchainFactory(android.Darwin, android.X86, darwinX86ToolchainFactory)
- registerHostToolchainFactory(android.Darwin, android.X86_64, darwinX8664ToolchainFactory)
+ registerToolchainFactory(android.Darwin, android.X86, darwinX86ToolchainFactory)
+ registerToolchainFactory(android.Darwin, android.X86_64, darwinX8664ToolchainFactory)
}
diff --git a/cc/x86_device.go b/cc/x86_device.go
index e47c6fb..f16e68b 100644
--- a/cc/x86_device.go
+++ b/cc/x86_device.go
@@ -286,5 +286,5 @@
}
func init() {
- registerDeviceToolchainFactory(android.X86, x86ToolchainFactory)
+ registerToolchainFactory(android.Android, android.X86, x86ToolchainFactory)
}
diff --git a/cc/x86_linux_host.go b/cc/x86_linux_host.go
index a75de90..b2d8462 100644
--- a/cc/x86_linux_host.go
+++ b/cc/x86_linux_host.go
@@ -254,6 +254,6 @@
}
func init() {
- registerHostToolchainFactory(android.Linux, android.X86, linuxX86ToolchainFactory)
- registerHostToolchainFactory(android.Linux, android.X86_64, linuxX8664ToolchainFactory)
+ registerToolchainFactory(android.Linux, android.X86, linuxX86ToolchainFactory)
+ registerToolchainFactory(android.Linux, android.X86_64, linuxX8664ToolchainFactory)
}
diff --git a/cc/x86_windows_host.go b/cc/x86_windows_host.go
index 9f5cdc4..cc0ef66 100644
--- a/cc/x86_windows_host.go
+++ b/cc/x86_windows_host.go
@@ -199,6 +199,6 @@
}
func init() {
- registerHostToolchainFactory(android.Windows, android.X86, windowsX86ToolchainFactory)
- registerHostToolchainFactory(android.Windows, android.X86_64, windowsX8664ToolchainFactory)
+ registerToolchainFactory(android.Windows, android.X86, windowsX86ToolchainFactory)
+ registerToolchainFactory(android.Windows, android.X86_64, windowsX8664ToolchainFactory)
}
diff --git a/genrule/genrule.go b/genrule/genrule.go
index a195b24..a50af1c 100644
--- a/genrule/genrule.go
+++ b/genrule/genrule.go
@@ -97,8 +97,7 @@
if g, ok := ctx.Module().(*generator); ok {
if g.properties.Tool != "" {
ctx.AddFarVariationDependencies([]blueprint.Variation{
- {"host_or_device", android.Host.String()},
- {"host_type", android.CurrentHostType().String()},
+ {"arch", ctx.AConfig().BuildOsVariant},
}, nil, g.properties.Tool)
}
}