openkylin
/
platform_build_soong
mirror of https://gitee.com/openkylin/platform_build_soong.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

Revert "Simplify arch target handling" 

This reverts commit 6713fb26cbcadf525cd75e47d7d0cbc23d282b3e.

Change-Id: Ic473cea2563b0b37dc08b0bc5d3a0ac8c4b6afe6
This commit is contained in:
Colin Cross 2016-06-03 01:50:47 +00:00
parent 54c7112c43
commit b9db480385
19 changed files with 474 additions and 360 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

53
android/androidmk.go
View File

@ -149,21 +149,27 @@ 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 := ""
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 @@ 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()
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 @@ 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 {

462
android/arch.go
View File

@ -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,7 +333,75 @@ func (a ArchType) String() string {
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 @@ var BuildOs = func() OsType {
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 @@ func ArchMutator(mctx BottomUpMutatorContext) {
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 @@ 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 (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 @@ 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
// 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 @@ 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
}

23
android/config.go
View File

@ -54,8 +54,8 @@ type config struct {
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 @@ func NewConfig(srcDir, buildDir string) (Config, error) {
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 @@ 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
}

107
android/module.go
View File

@ -48,9 +48,9 @@ type ModuleBuildParams struct {
}
type androidBaseContext interface {
Target() Target
Arch() Arch
Os() OsType
HostOrDevice() HostOrDevice
HostType() HostType
Host() bool
Device() bool
Darwin() bool
@ -90,7 +90,7 @@ type Module interface {
base() *ModuleBase
Enabled() bool
Target() Target
HostOrDevice() HostOrDevice
InstallInData() bool
}
@ -115,8 +115,14 @@ type commonProperties struct {
// 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 @@ const (
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 @@ func (a *ModuleBase) base() *ModuleBase {
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) DeviceSupported() bool {
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) generateModuleTarget(ctx blueprint.ModuleContext) {
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 @@ func (a *ModuleBase) GenerateBuildActions(ctx blueprint.ModuleContext) {
}
type androidBaseContextImpl struct {
target Target
arch Arch
hod HostOrDevice
ht HostType
debug bool
config Config
proprietary bool
@ -497,28 +494,28 @@ func (a *androidModuleContext) AddMissingDependencies(deps []string) {
}
}
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 {

2
android/paths.go
View File

@ -629,7 +629,7 @@ func PathForModuleInstall(ctx ModuleContext, paths ...string) OutputPath {
}
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...)

2
cc/arm64_device.go
View File

@ -208,5 +208,5 @@ func arm64ToolchainFactory(arch android.Arch) Toolchain {
}
func init() {
registerToolchainFactory(android.Android, android.Arm64, arm64ToolchainFactory)
registerDeviceToolchainFactory(android.Arm64, arm64ToolchainFactory)
}

2
cc/arm_device.go
View File

@ -392,5 +392,5 @@ func armToolchainFactory(arch android.Arch) Toolchain {
}
func init() {
registerToolchainFactory(android.Android, android.Arm, armToolchainFactory)
registerDeviceToolchainFactory(android.Arm, armToolchainFactory)
}

39
cc/cc.go
View File

@ -118,7 +118,7 @@ var (
)
func init() {
if android.BuildOs == android.Linux {
if android.CurrentHostType() == android.Linux {
commonGlobalCflags = append(commonGlobalCflags, "-fdebug-prefix-map=/proc/self/cwd=")
}
@ -729,10 +729,11 @@ func (c *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
func (c *Module) toolchain(ctx BaseModuleContext) Toolchain {
if c.cachedToolchain == nil {
arch := ctx.Arch()
os := ctx.Os()
factory := toolchainFactories[os][arch.ArchType]
hod := ctx.HostOrDevice()
ht := ctx.HostType()
factory := toolchainFactories[hod][ht][arch.ArchType]
if factory == nil {
ctx.ModuleErrorf("Toolchain not found for %s arch %q", os.String(), arch.String())
ctx.ModuleErrorf("Toolchain not found for %s %s arch %q", hod.String(), ht.String(), arch.String())
return nil
}
c.cachedToolchain = factory(arch)
@ -904,13 +905,8 @@ func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
return
}
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)
if a.HostOrDevice() != ctx.HostOrDevice() {
ctx.ModuleErrorf("host/device mismatch between %q and %q", ctx.ModuleName(), name)
return
}
@ -1085,11 +1081,6 @@ 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)
@ -1099,7 +1090,7 @@ func (compiler *baseCompiler) flags(ctx ModuleContext, flags Flags) Flags {
flags.GlobalFlags = append(flags.GlobalFlags,
toolchain.ClangCflags(),
"${commonClangGlobalCflags}",
fmt.Sprintf("${%sClangGlobalCflags}", hod))
fmt.Sprintf("${%sClangGlobalCflags}", ctx.HostOrDevice()))
flags.ConlyFlags = append(flags.ConlyFlags, "${clangExtraConlyflags}")
} else {
@ -1107,7 +1098,7 @@ func (compiler *baseCompiler) flags(ctx ModuleContext, flags Flags) Flags {
flags.GlobalFlags = append(flags.GlobalFlags,
toolchain.Cflags(),
"${commonGlobalCflags}",
fmt.Sprintf("${%sGlobalCflags}", hod))
fmt.Sprintf("${%sGlobalCflags}", ctx.HostOrDevice()))
}
if Bool(ctx.AConfig().ProductVariables.Brillo) {
@ -1419,7 +1410,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.Os() != android.Windows {
if ctx.HostType() != android.Windows {
flags.CFlags = append(flags.CFlags, "-fPIC")
}
@ -1872,7 +1863,7 @@ func (binary *binaryLinker) begin(ctx BaseModuleContext) {
static := Bool(binary.Properties.Static_executable)
if ctx.Host() {
if ctx.Os() == android.Linux {
if ctx.HostType() == android.Linux {
if binary.Properties.Static_executable == nil && Bool(ctx.AConfig().ProductVariables.HostStaticBinaries) {
static = true
}
@ -1892,7 +1883,7 @@ func (binary *binaryLinker) flags(ctx ModuleContext, flags Flags) Flags {
if ctx.Host() && !binary.staticBinary() {
flags.LdFlags = append(flags.LdFlags, "-pie")
if ctx.Os() == android.Windows {
if ctx.HostType() == android.Windows {
flags.LdFlags = append(flags.LdFlags, "-Wl,-e_mainCRTStartup")
}
}
@ -1900,7 +1891,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.Os() != android.Windows {
if ctx.HostType() != android.Windows {
flags.CFlags = append(flags.CFlags, "-fpie")
}
@ -1954,7 +1945,7 @@ func (binary *binaryLinker) link(ctx ModuleContext,
fileName := binary.getStem(ctx) + flags.Toolchain.ExecutableSuffix()
outputFile := android.PathForModuleOut(ctx, fileName)
ret := outputFile
if ctx.Os().Class == android.Host {
if ctx.HostOrDevice().Host() {
binary.hostToolPath = android.OptionalPathForPath(outputFile)
}
@ -2061,7 +2052,7 @@ func (test *testLinker) flags(ctx ModuleContext, flags Flags) Flags {
if ctx.Host() {
flags.CFlags = append(flags.CFlags, "-O0", "-g")
switch ctx.Os() {
switch ctx.HostType() {
case android.Windows:
flags.CFlags = append(flags.CFlags, "-DGTEST_OS_WINDOWS")
case android.Linux:

81
cc/makevars.go
View File

@ -41,54 +41,49 @@ func makeVarsProvider(ctx android.MakeVarsContext) {
ctx.Strict("GLOBAL_CPPFLAGS_NO_OVERRIDE", "")
ctx.Strict("GLOBAL_CLANG_CPPFLAGS_NO_OVERRIDE", "")
hostTargets := ctx.Config().Targets[android.Host]
makeVarsToolchain(ctx, "", hostTargets[0])
if len(hostTargets) > 1 {
makeVarsToolchain(ctx, "2ND_", hostTargets[1])
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])
}
crossTargets := ctx.Config().Targets[android.HostCross]
if len(crossTargets) > 0 {
makeVarsToolchain(ctx, "", crossTargets[0])
if len(crossTargets) > 1 {
makeVarsToolchain(ctx, "2ND_", crossTargets[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])
}
}
deviceTargets := ctx.Config().Targets[android.Device]
makeVarsToolchain(ctx, "", deviceTargets[0])
if len(deviceTargets) > 1 {
makeVarsToolchain(ctx, "2ND_", deviceTargets[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])
}
}
func makeVarsToolchain(ctx android.MakeVarsContext, secondPrefix string,
target android.Target) {
hod android.HostOrDevice, ht android.HostType, arch android.Arch) {
var typePrefix string
switch target.Os.Class {
case android.Host:
typePrefix = "HOST_"
case android.HostCross:
typePrefix = "HOST_CROSS_"
case android.Device:
if hod.Host() {
if ht == android.Windows {
typePrefix = "HOST_CROSS_"
} else {
typePrefix = "HOST_"
}
} else {
typePrefix = "TARGET_"
}
makePrefix := secondPrefix + typePrefix
toolchain := toolchainFactories[target.Os][target.Arch.ArchType](target.Arch)
toolchain := toolchainFactories[hod][ht][arch.ArchType](arch)
var productExtraCflags string
var productExtraLdflags string
hod := "host"
if target.Os.Class == android.Device {
hod = "device"
}
if target.Os.Class == android.Device && Bool(ctx.Config().ProductVariables.Brillo) {
if hod.Device() && Bool(ctx.Config().ProductVariables.Brillo) {
productExtraCflags += "-D__BRILLO__"
}
if target.Os.Class == android.Host && Bool(ctx.Config().ProductVariables.HostStaticBinaries) {
if hod.Host() && Bool(ctx.Config().ProductVariables.HostStaticBinaries) {
productExtraLdflags += "-static"
}
@ -113,29 +108,23 @@ 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 target.Arch.ArchType == android.Arm {
if 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 target.Os != android.Darwin {
if ht != android.Darwin {
clangExtras += " -B" + filepath.Join(toolchain.GccRoot(), toolchain.GccTriple(), "bin")
}
@ -159,19 +148,19 @@ func makeVarsToolchain(ctx android.MakeVarsContext, secondPrefix string,
clangExtras,
}, " "))
if target.Os.Class == android.Device {
ctx.Strict(secondPrefix+"ADDRESS_SANITIZER_RUNTIME_LIBRARY", strings.TrimSuffix(toolchain.AddressSanitizerRuntimeLibrary(), ".so"))
if hod.Device() {
ctx.Strict(secondPrefix + "ADDRESS_SANITIZER_RUNTIME_LIBRARY", strings.TrimSuffix(toolchain.AddressSanitizerRuntimeLibrary(), ".so"))
}
// This is used by external/gentoo/...
ctx.Strict("CLANG_CONFIG_"+target.Arch.ArchType.Name+"_"+typePrefix+"TRIPLE",
ctx.Strict("CLANG_CONFIG_" + arch.ArchType.Name + "_" + typePrefix + "TRIPLE",
toolchain.ClangTriple())
}
ctx.Strict(makePrefix+"CC", gccCmd(toolchain, "gcc"))
ctx.Strict(makePrefix+"CXX", gccCmd(toolchain, "g++"))
if target.Os == android.Darwin {
if ht == android.Darwin {
ctx.Strict(makePrefix+"AR", "${macArPath}")
} else {
ctx.Strict(makePrefix+"AR", gccCmd(toolchain, "ar"))
@ -179,11 +168,11 @@ func makeVarsToolchain(ctx android.MakeVarsContext, secondPrefix string,
ctx.Strict(makePrefix+"NM", gccCmd(toolchain, "nm"))
}
if target.Os == android.Windows {
if ht == android.Windows {
ctx.Strict(makePrefix+"OBJDUMP", gccCmd(toolchain, "objdump"))
}
if target.Os.Class == android.Device {
if hod.Device() {
ctx.Strict(makePrefix+"OBJCOPY", gccCmd(toolchain, "objcopy"))
ctx.Strict(makePrefix+"LD", gccCmd(toolchain, "ld"))
ctx.Strict(makePrefix+"STRIP", gccCmd(toolchain, "strip"))

2
cc/mips64_device.go
View File

@ -200,5 +200,5 @@ func mips64ToolchainFactory(arch android.Arch) Toolchain {
}
func init() {
registerToolchainFactory(android.Android, android.Mips64, mips64ToolchainFactory)
registerDeviceToolchainFactory(android.Mips64, mips64ToolchainFactory)
}

2
cc/mips_device.go
View File

@ -248,5 +248,5 @@ func mipsToolchainFactory(arch android.Arch) Toolchain {
}
func init() {
registerToolchainFactory(android.Android, android.Mips, mipsToolchainFactory)
registerDeviceToolchainFactory(android.Mips, mipsToolchainFactory)
}

18
cc/stl.go
View File

@ -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.Os() == android.Windows {
} else if ctx.HostType() == 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 for windows", stl.Properties.Stl)
ctx.ModuleErrorf("stl: %q is not a supported STL", 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.Os()]...)
flags.LdFlags = append(flags.LdFlags, hostStaticGccLibs[ctx.HostType()]...)
} else {
flags.LdFlags = append(flags.LdFlags, hostDynamicGccLibs[ctx.Os()]...)
flags.LdFlags = append(flags.LdFlags, hostDynamicGccLibs[ctx.HostType()]...)
}
} 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.Os()]...)
flags.LdFlags = append(flags.LdFlags, hostStaticGccLibs[ctx.HostType()]...)
} else {
flags.LdFlags = append(flags.LdFlags, hostDynamicGccLibs[ctx.Os()]...)
flags.LdFlags = append(flags.LdFlags, hostDynamicGccLibs[ctx.HostType()]...)
}
}
default:
@ -179,10 +179,10 @@ func (stl *stl) flags(ctx ModuleContext, flags Flags) Flags {
return flags
}
var hostDynamicGccLibs, hostStaticGccLibs map[android.OsType][]string
var hostDynamicGccLibs, hostStaticGccLibs map[android.HostType][]string
func init() {
hostDynamicGccLibs = map[android.OsType][]string{
hostDynamicGccLibs = map[android.HostType][]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.OsType][]string{
hostStaticGccLibs = map[android.HostType][]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"},

22
cc/toolchain.go
View File

@ -22,13 +22,23 @@ import (
type toolchainFactory func(arch android.Arch) Toolchain
var toolchainFactories = make(map[android.OsType]map[android.ArchType]toolchainFactory)
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),
},
}
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
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
}
type Toolchain interface {

2
cc/x86_64_device.go
View File

@ -263,5 +263,5 @@ func x86_64ToolchainFactory(arch android.Arch) Toolchain {
}
func init() {
registerToolchainFactory(android.Android, android.X86_64, x86_64ToolchainFactory)
registerDeviceToolchainFactory(android.X86_64, x86_64ToolchainFactory)
}

4
cc/x86_darwin_host.go
View File

@ -280,6 +280,6 @@ func darwinX8664ToolchainFactory(arch android.Arch) Toolchain {
}
func init() {
registerToolchainFactory(android.Darwin, android.X86, darwinX86ToolchainFactory)
registerToolchainFactory(android.Darwin, android.X86_64, darwinX8664ToolchainFactory)
registerHostToolchainFactory(android.Darwin, android.X86, darwinX86ToolchainFactory)
registerHostToolchainFactory(android.Darwin, android.X86_64, darwinX8664ToolchainFactory)
}

2
cc/x86_device.go
View File

@ -286,5 +286,5 @@ func x86ToolchainFactory(arch android.Arch) Toolchain {
}
func init() {
registerToolchainFactory(android.Android, android.X86, x86ToolchainFactory)
registerDeviceToolchainFactory(android.X86, x86ToolchainFactory)
}

4
cc/x86_linux_host.go
View File

@ -254,6 +254,6 @@ func linuxX8664ToolchainFactory(arch android.Arch) Toolchain {
}
func init() {
registerToolchainFactory(android.Linux, android.X86, linuxX86ToolchainFactory)
registerToolchainFactory(android.Linux, android.X86_64, linuxX8664ToolchainFactory)
registerHostToolchainFactory(android.Linux, android.X86, linuxX86ToolchainFactory)
registerHostToolchainFactory(android.Linux, android.X86_64, linuxX8664ToolchainFactory)
}

4
cc/x86_windows_host.go
View File

@ -199,6 +199,6 @@ func windowsX8664ToolchainFactory(arch android.Arch) Toolchain {
}
func init() {
registerToolchainFactory(android.Windows, android.X86, windowsX86ToolchainFactory)
registerToolchainFactory(android.Windows, android.X86_64, windowsX8664ToolchainFactory)
registerHostToolchainFactory(android.Windows, android.X86, windowsX86ToolchainFactory)
registerHostToolchainFactory(android.Windows, android.X86_64, windowsX8664ToolchainFactory)
}

3
genrule/genrule.go
View File

@ -97,7 +97,8 @@ func genruleDepsMutator(ctx android.BottomUpMutatorContext) {
if g, ok := ctx.Module().(*generator); ok {
if g.properties.Tool != "" {
ctx.AddFarVariationDependencies([]blueprint.Variation{
{"arch", ctx.AConfig().BuildOsVariant},
{"host_or_device", android.Host.String()},
{"host_type", android.CurrentHostType().String()},
}, nil, g.properties.Tool)
}
}