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