Revert "Simplify arch target handling"

This reverts commit 6713fb26cbcadf525cd75e47d7d0cbc23d282b3e.

Change-Id: Ic473cea2563b0b37dc08b0bc5d3a0ac8c4b6afe6

1 files changed, 291 insertions, 155 deletions

diff --git a/android/arch.go b/android/arch.go
index 184b1629..48cc0ab7 100644
--- a/android/arch.go
+++ b/android/arch.go
@@ -28,6 +28,8 @@ func init() {
 	RegisterBottomUpMutator("defaults_deps", defaultsDepsMutator)
 	RegisterTopDownMutator("defaults", defaultsMutator)
 
+	RegisterBottomUpMutator("host_or_device", HostOrDeviceMutator)
+	RegisterBottomUpMutator("host_type", HostTypeMutator)
 	RegisterBottomUpMutator("arch", ArchMutator)
 }
 
@@ -331,115 +333,218 @@ func (a ArchType) String() string {
 	return a.Name
 }
 
-var BuildOs = func() OsType {
-	switch runtime.GOOS {
-	case "linux":
-		return Linux
-	case "darwin":
-		return Darwin
+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("unsupported OS: %s", runtime.GOOS))
+		panic(fmt.Sprintf("unexpected HostOrDevice value %d", hod))
 	}
-}()
+}
 
-var (
-	osTypeList []OsType
+func (hod HostOrDevice) Property() string {
+	switch hod {
+	case Device:
+		return "android"
+	case Host:
+		return "host"
+	default:
+		panic(fmt.Sprintf("unexpected HostOrDevice value %d", hod))
+	}
+}
 
-	NoOsType OsType
-	Linux    = NewOsType("linux", Host)
-	Darwin   = NewOsType("darwin", Host)
-	Windows  = NewOsType("windows", HostCross)
-	Android  = NewOsType("android", Device)
-)
+func (hod HostOrDevice) Host() bool {
+	if hod == 0 {
+		panic("HostOrDevice unset")
+	}
+	return hod == Host
+}
 
-type OsType struct {
-	Name, Field string
-	Class       OsClass
+func (hod HostOrDevice) Device() bool {
+	if hod == 0 {
+		panic("HostOrDevice unset")
+	}
+	return hod == Device
 }
 
-type OsClass int
+var hostOrDeviceName = map[HostOrDevice]string{
+	Device: "device",
+	Host:   "host",
+}
+
+type HostType int
 
 const (
-	Device OsClass = iota
-	Host
-	HostCross
+	NoHostType HostType = iota
+	Linux
+	Darwin
+	Windows
 )
 
-func (os OsType) String() string {
-	return os.Name
+func CurrentHostType() HostType {
+	switch runtime.GOOS {
+	case "linux":
+		return Linux
+	case "darwin":
+		return Darwin
+	default:
+		panic(fmt.Sprintf("unsupported OS: %s", runtime.GOOS))
+	}
 }
 
-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
+	}
 
-func (target Target) String() string {
-	return target.Os.String() + "_" + target.Arch.String()
+	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 ArchMutator(mctx BottomUpMutatorContext) {
+func HostTypeMutator(mctx BottomUpMutatorContext) {
 	var module Module
 	var ok bool
 	if module, ok = mctx.Module().(Module); !ok {
 		return
 	}
 
-	osClasses := module.base().OsClassSupported()
+	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])
+	}
+}
 
-	if len(osClasses) == 0 {
+func ArchMutator(mctx BottomUpMutatorContext) {
+	var module Module
+	var ok bool
+	if module, ok = mctx.Module().(Module); !ok {
 		return
 	}
 
-	var moduleTargets []Target
+	moduleArches := []Arch{}
+	multilib := module.base().commonProperties.Compile_multilib
 
-	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...)
+	}
+
+	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...)
 	}
 
-	targetNames := make([]string, len(moduleTargets))
+	if len(moduleArches) == 0 {
+		return
+	}
 
-	for i, target := range moduleTargets {
-		targetNames[i] = target.String()
+	archNames := []string{}
+	for _, arch := range moduleArches {
+		archNames = append(archNames, arch.String())
 	}
 
-	modules := mctx.CreateVariations(targetNames...)
+	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 @@ 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.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 @@ func (a *ModuleBase) setArchProperties(ctx BottomUpMutatorContext) {
 		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 @@ func (a *ModuleBase) setArchProperties(ctx BottomUpMutatorContext) {
 		//     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 hod.Host() {
+			field := ht.Field()
+			prefix := "target." + ht.String()
+			a.appendProperties(ctx, genProps, archProps.Target, field, prefix)
 
-		if (os.Class == Host || os.Class == HostCross) && os != Windows {
-			field := "Not_windows"
-			prefix := "target.not_windows"
+			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 @@ 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 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 @@ 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
+		}
 	}
 }
 
@@ -706,84 +824,104 @@ func forEachInterface(v reflect.Value, f func(reflect.Value)) {
 	}
 }
 
-// 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
-
-	targets := make(map[OsClass][]Target)
-	var targetErr error
+// Get a list of HostTypes from the product variables
+func decodeHostTypesProductVariables(variables productVariables) ([]HostType, error) {
+	ret := []HostType{CurrentHostType()}
 
-	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
-		}
+	return ret, nil
+}
 
-		targets[os.Class] = append(targets[os.Class],
-			Target{
-				Os:   os,
-				Arch: arch,
-			})
+// 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")
 	}
 
-	if variables.HostArch == nil {
-		return nil, fmt.Errorf("No host primary architecture set")
+	hostArch, err := decodeArch(*variables.HostArch, nil, nil, nil)
+	if err != nil {
+		return nil, nil, err
 	}
 
-	addTarget(BuildOs, *variables.HostArch, nil, nil, nil)
+	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, nil, fmt.Errorf("No cross-host primary architecture set")
 		}
 
-		if variables.CrossHostArch == nil || *variables.CrossHostArch == "" {
-			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
 		}
 
-		addTarget(crossHostOs, *variables.CrossHostArch, nil, nil, nil)
+		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 @@ func decodeMegaDevice() ([]Target, error) {
 		{"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 @@ func decodeMegaDevice() ([]Target, error) {
 			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 @@ func decodeArch(arch string, archVariant, cpuVariant *string, abi *[]string) (Ar
 	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
 }