From 54c7112c4325426eabda5fa96a8d3c4f61cb8cc7 Mon Sep 17 00:00:00 2001 From: Colin Cross Date: Wed, 1 Jun 2016 17:09:44 -0700 Subject: [PATCH] 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: Iae677eff61a851b65a7192a47f2dc17c1abb4160 --- android/androidmk.go | 53 +++-- android/arch.go | 466 +++++++++++++++-------------------------- android/config.go | 23 +- android/module.go | 107 +++++----- android/paths.go | 2 +- cc/arm64_device.go | 2 +- cc/arm_device.go | 2 +- cc/cc.go | 39 ++-- cc/makevars.go | 81 +++---- cc/mips64_device.go | 2 +- cc/mips_device.go | 2 +- cc/stl.go | 18 +- cc/toolchain.go | 22 +- cc/x86_64_device.go | 2 +- cc/x86_darwin_host.go | 4 +- cc/x86_device.go | 2 +- cc/x86_linux_host.go | 4 +- cc/x86_windows_host.go | 4 +- genrule/genrule.go | 3 +- 19 files changed, 362 insertions(+), 476 deletions(-) diff --git a/android/androidmk.go b/android/androidmk.go index 603b37de7..8d2951db4 100644 --- a/android/androidmk.go +++ b/android/androidmk.go @@ -149,27 +149,21 @@ func translateAndroidMkModule(ctx blueprint.SingletonContext, w io.Writer, mod b 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 @@ func translateAndroidMkModule(ctx blueprint.SingletonContext, w io.Writer, mod b 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 @@ func translateAndroidMkModule(ctx blueprint.SingletonContext, w io.Writer, mod b } } + 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 48cc0ab71..184b1629e 100644 --- a/android/arch.go +++ b/android/arch.go @@ -28,8 +28,6 @@ func init() { RegisterBottomUpMutator("defaults_deps", defaultsDepsMutator) RegisterTopDownMutator("defaults", defaultsMutator) - RegisterBottomUpMutator("host_or_device", HostOrDeviceMutator) - RegisterBottomUpMutator("host_type", HostTypeMutator) RegisterBottomUpMutator("arch", ArchMutator) } @@ -333,75 +331,7 @@ func (a ArchType) String() string { 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 @@ func CurrentHostType() HostType { 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,32 @@ func ArchMutator(mctx BottomUpMutatorContext) { 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 { + multilib := module.base().commonProperties.Compile_multilib + targets, err := decodeMultilib(multilib, mctx.AConfig().Targets[class]) + 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 +543,8 @@ func (a *ModuleBase) appendProperties(ctx BottomUpMutatorContext, // 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 +613,19 @@ func (a *ModuleBase) setArchProperties(ctx BottomUpMutatorContext) { 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 +639,29 @@ func (a *ModuleBase) setArchProperties(ctx BottomUpMutatorContext) { // 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 +677,8 @@ func (a *ModuleBase) setArchProperties(ctx BottomUpMutatorContext) { // 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 +688,6 @@ func (a *ModuleBase) setArchProperties(ctx BottomUpMutatorContext) { 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 +706,84 @@ func forEachInterface(v reflect.Value, f func(reflect.Value)) { } } -// 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 +831,7 @@ func decodeMegaDevice() ([]Arch, error) { {"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 +840,10 @@ func decodeMegaDevice() ([]Arch, error) { return nil, err } arch.Native = false - ret = append(ret, arch) + ret = append(ret, Target{ + Os: Android, + Arch: arch, + }) } return ret, nil @@ -1035,33 +900,32 @@ func decodeArch(arch string, archVariant, cpuVariant *string, abi *[]string) (Ar 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 ee95d2efd..5024bcee6 100644 --- a/android/config.go +++ b/android/config.go @@ -54,8 +54,8 @@ type config struct { 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 @@ func NewConfig(srcDir, buildDir string) (Config, error) { 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 @@ func (c *config) SanitizeDevice() []string { } 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 18555234a..0e608d77e 100644 --- a/android/module.go +++ b/android/module.go @@ -48,9 +48,9 @@ type ModuleBuildParams struct { } type androidBaseContext interface { + Target() Target Arch() Arch - HostOrDevice() HostOrDevice - HostType() HostType + Os() OsType Host() bool Device() bool Darwin() bool @@ -90,7 +90,7 @@ type Module interface { base() *ModuleBase Enabled() bool - HostOrDevice() HostOrDevice + Target() Target InstallInData() bool } @@ -115,14 +115,8 @@ type commonProperties struct { // 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 @@ const ( 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 @@ func (a *ModuleBase) base() *ModuleBase { 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) DeviceSupported() bool { 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) generateModuleTarget(ctx blueprint.ModuleContext) { 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 @@ func (a *ModuleBase) GenerateBuildActions(ctx blueprint.ModuleContext) { } type androidBaseContextImpl struct { - arch Arch - hod HostOrDevice - ht HostType + target Target debug bool config Config proprietary bool @@ -494,28 +497,28 @@ func (a *androidModuleContext) AddMissingDependencies(deps []string) { } } +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 910ebd28e..35ed18010 100644 --- a/android/paths.go +++ b/android/paths.go @@ -629,7 +629,7 @@ func PathForModuleInstall(ctx ModuleContext, paths ...string) OutputPath { } 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 4e412876f..8e7c57b0a 100644 --- a/cc/arm64_device.go +++ b/cc/arm64_device.go @@ -208,5 +208,5 @@ func arm64ToolchainFactory(arch android.Arch) Toolchain { } 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 766eea613..1624cfcc9 100644 --- a/cc/arm_device.go +++ b/cc/arm_device.go @@ -392,5 +392,5 @@ func armToolchainFactory(arch android.Arch) Toolchain { } func init() { - registerDeviceToolchainFactory(android.Arm, armToolchainFactory) + registerToolchainFactory(android.Android, android.Arm, armToolchainFactory) } diff --git a/cc/cc.go b/cc/cc.go index bac3e88e5..3cc0d0da2 100644 --- a/cc/cc.go +++ b/cc/cc.go @@ -118,7 +118,7 @@ var ( ) 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) GenerateAndroidBuildActions(actx android.ModuleContext) { 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 @@ func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps { 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 @@ func (compiler *baseCompiler) flags(ctx ModuleContext, flags Flags) Flags { 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 @@ func (compiler *baseCompiler) flags(ctx ModuleContext, flags Flags) Flags { 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 @@ func (compiler *baseCompiler) flags(ctx ModuleContext, flags Flags) Flags { 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 @@ func (library *libraryCompiler) flags(ctx ModuleContext, flags Flags) Flags { // 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 @@ func (binary *binaryLinker) begin(ctx BaseModuleContext) { 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 @@ func (binary *binaryLinker) flags(ctx ModuleContext, flags Flags) Flags { 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 @@ func (binary *binaryLinker) flags(ctx ModuleContext, flags Flags) Flags { // 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 @@ func (binary *binaryLinker) link(ctx ModuleContext, 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 @@ func (test *testLinker) flags(ctx ModuleContext, flags Flags) Flags { 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 863e3dcc7..f107eff81 100644 --- a/cc/makevars.go +++ b/cc/makevars.go @@ -41,49 +41,54 @@ func makeVarsProvider(ctx android.MakeVarsContext) { 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 @@ func makeVarsToolchain(ctx android.MakeVarsContext, secondPrefix string, 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 @@ func makeVarsToolchain(ctx android.MakeVarsContext, secondPrefix string, 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 @@ func makeVarsToolchain(ctx android.MakeVarsContext, secondPrefix string, 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 04e31a957..474f284ae 100644 --- a/cc/mips64_device.go +++ b/cc/mips64_device.go @@ -200,5 +200,5 @@ func mips64ToolchainFactory(arch android.Arch) Toolchain { } 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 0dbbbd7b0..f9dc5c689 100644 --- a/cc/mips_device.go +++ b/cc/mips_device.go @@ -248,5 +248,5 @@ func mipsToolchainFactory(arch android.Arch) Toolchain { } func init() { - registerDeviceToolchainFactory(android.Mips, mipsToolchainFactory) + registerToolchainFactory(android.Android, android.Mips, mipsToolchainFactory) } diff --git a/cc/stl.go b/cc/stl.go index cdc887ebb..c5dbae366 100644 --- a/cc/stl.go +++ b/cc/stl.go @@ -52,7 +52,7 @@ func (stl *stl) begin(ctx BaseModuleContext) { 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 @@ func (stl *stl) begin(ctx BaseModuleContext) { 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 @@ func (stl *stl) flags(ctx ModuleContext, flags Flags) Flags { 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 @@ func (stl *stl) flags(ctx ModuleContext, flags Flags) Flags { 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 @@ func (stl *stl) flags(ctx ModuleContext, flags Flags) Flags { 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 @@ func init() { "-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 efb795363..87657ef53 100644 --- a/cc/toolchain.go +++ b/cc/toolchain.go @@ -22,23 +22,13 @@ import ( 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 9a0d66322..986dc8665 100644 --- a/cc/x86_64_device.go +++ b/cc/x86_64_device.go @@ -263,5 +263,5 @@ func x86_64ToolchainFactory(arch android.Arch) Toolchain { } 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 f3cf1c970..987b1dd1f 100644 --- a/cc/x86_darwin_host.go +++ b/cc/x86_darwin_host.go @@ -280,6 +280,6 @@ func darwinX8664ToolchainFactory(arch android.Arch) Toolchain { } 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 e47c6fb6b..f16e68b34 100644 --- a/cc/x86_device.go +++ b/cc/x86_device.go @@ -286,5 +286,5 @@ func x86ToolchainFactory(arch android.Arch) Toolchain { } 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 a75de9002..b2d846251 100644 --- a/cc/x86_linux_host.go +++ b/cc/x86_linux_host.go @@ -254,6 +254,6 @@ func linuxX8664ToolchainFactory(arch android.Arch) Toolchain { } 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 9f5cdc426..cc0ef668e 100644 --- a/cc/x86_windows_host.go +++ b/cc/x86_windows_host.go @@ -199,6 +199,6 @@ func windowsX8664ToolchainFactory(arch android.Arch) Toolchain { } 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 a195b24ff..a50af1c64 100644 --- a/genrule/genrule.go +++ b/genrule/genrule.go @@ -97,8 +97,7 @@ func genruleDepsMutator(ctx android.BottomUpMutatorContext) { 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) } }