Add soong_build primary builder

Initial build logic for building android with soong. It can build a variety of C and C++ files for arm/arm64 and host. Change-Id: I10eb37c2c2a50be6af1bb5fd568c0962b9476bf0
2015-01-30 17:27:36 -08:00
parent e441b9df9a
commit 3f40fa460d
30 changed files with 6178 additions and 3 deletions
--- a/common/module.go
+++ b/common/module.go
@@ -0,0 +1,327 @@
+// Copyright 2015 Google Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package common
+
+import (
+	"blueprint"
+	"path/filepath"
+)
+
+var (
+	DeviceSharedLibrary = "shared_library"
+	DeviceStaticLibrary = "static_library"
+	DeviceExecutable    = "executable"
+	HostSharedLibrary   = "host_shared_library"
+	HostStaticLibrary   = "host_static_library"
+	HostExecutable      = "host_executable"
+)
+
+type AndroidModuleContext interface {
+	blueprint.ModuleContext
+
+	Arch() Arch
+	InstallFile(installPath, srcPath string)
+	CheckbuildFile(srcPath string)
+}
+
+type AndroidModule interface {
+	blueprint.Module
+
+	GenerateAndroidBuildActions(AndroidModuleContext)
+
+	base() *AndroidModuleBase
+	Disabled() bool
+	HostOrDevice() HostOrDevice
+}
+
+type AndroidDynamicDepender interface {
+	AndroidDynamicDependencies(ctx AndroidDynamicDependerModuleContext) []string
+}
+
+type AndroidDynamicDependerModuleContext interface {
+	blueprint.DynamicDependerModuleContext
+}
+
+type commonProperties struct {
+	Name         string
+	Deps         []string
+	ResourceDirs []string
+
+	// disabled: don't emit any build rules for this module
+	Disabled bool `android:"arch_variant"`
+
+	// multilib: control whether this module compiles for 32-bit, 64-bit, or both.  Possible values
+	// are "32" (compile for 32-bit only), "64" (compile for 64-bit only), "both" (compile for both
+	// architectures), or "first" (compile for 64-bit on a 64-bit platform, and 32-bit on a 32-bit
+	// platform
+	Compile_multilib string
+
+	// Set by ArchMutator
+	CompileArch Arch `blueprint:"mutated"`
+
+	// Set by InitAndroidModule
+	HostOrDeviceSupported HostOrDeviceSupported `blueprint:"mutated"`
+}
+
+type hostAndDeviceProperties struct {
+	Host_supported   bool
+	Device_supported bool
+}
+
+func InitAndroidModule(m AndroidModule, hod HostOrDeviceSupported, defaultMultilib string,
+	propertyStructs ...interface{}) (blueprint.Module, []interface{}) {
+
+	base := m.base()
+	base.module = m
+	base.commonProperties.HostOrDeviceSupported = hod
+
+	if hod == HostAndDeviceSupported {
+		// Default to module to device supported, host not supported, can override in module
+		// properties
+		base.hostAndDeviceProperties.Device_supported = true
+		propertyStructs = append(propertyStructs, &base.hostAndDeviceProperties)
+	}
+
+	return InitArchModule(m, defaultMultilib, propertyStructs...)
+}
+
+// A AndroidModuleBase object contains the properties that are common to all Android
+// modules.  It should be included as an anonymous field in every module
+// struct definition.  InitAndroidModule should then be called from the module's
+// factory function, and the return values from InitAndroidModule should be
+// returned from the factory function.
+//
+// The AndroidModuleBase type is responsible for implementing the
+// GenerateBuildActions method to support the blueprint.Module interface. This
+// method will then call the module's GenerateAndroidBuildActions method once
+// for each build variant that is to be built. GenerateAndroidBuildActions is
+// passed a AndroidModuleContext rather than the usual blueprint.ModuleContext.
+// AndroidModuleContext exposes extra functionality specific to the Android build
+// system including details about the particular build variant that is to be
+// generated.
+//
+// For example:
+//
+//     import (
+//         "android/soong/common"
+//         "blueprint"
+//     )
+//
+//     type myModule struct {
+//         common.AndroidModuleBase
+//         properties struct {
+//             MyProperty string
+//         }
+//     }
+//
+//     func NewMyModule() (blueprint.Module, []interface{}) {
+//         m := &myModule{}
+//         return common.InitAndroidModule(m, &m.properties)
+//     }
+//
+//     func (m *myModule) GenerateAndroidBuildActions(ctx common.AndroidModuleContext) {
+//         // Get the CPU architecture for the current build variant.
+//         variantArch := ctx.Arch()
+//
+//         // ...
+//     }
+type AndroidModuleBase struct {
+	// Putting the curiously recurring thing pointing to the thing that contains
+	// the thing pattern to good use.
+	module AndroidModule
+
+	commonProperties        commonProperties
+	hostAndDeviceProperties hostAndDeviceProperties
+	generalProperties       []interface{}
+	archProperties          []*archProperties
+
+	noAddressSanitizer bool
+	installFiles       []string
+	checkbuildFiles    []string
+}
+
+func (a *AndroidModuleBase) base() *AndroidModuleBase {
+	return a
+}
+
+func (a *AndroidModuleBase) SetArch(arch Arch) {
+	a.commonProperties.CompileArch = arch
+}
+
+func (a *AndroidModuleBase) HostOrDevice() HostOrDevice {
+	return a.commonProperties.CompileArch.HostOrDevice
+}
+
+func (a *AndroidModuleBase) HostSupported() bool {
+	return a.commonProperties.HostOrDeviceSupported == HostSupported ||
+		a.commonProperties.HostOrDeviceSupported == HostAndDeviceSupported &&
+			a.hostAndDeviceProperties.Host_supported
+}
+
+func (a *AndroidModuleBase) DeviceSupported() bool {
+	return a.commonProperties.HostOrDeviceSupported == DeviceSupported ||
+		a.commonProperties.HostOrDeviceSupported == HostAndDeviceSupported &&
+			a.hostAndDeviceProperties.Device_supported
+}
+
+func (a *AndroidModuleBase) Disabled() bool {
+	return a.commonProperties.Disabled
+}
+
+func (a *AndroidModuleBase) computeInstallDeps(
+	ctx blueprint.ModuleContext) []string {
+
+	result := []string{}
+	ctx.VisitDepsDepthFirstIf(isFileInstaller,
+		func(m blueprint.Module) {
+			fileInstaller := m.(fileInstaller)
+			files := fileInstaller.filesToInstall()
+			result = append(result, files...)
+		})
+
+	return result
+}
+
+func (a *AndroidModuleBase) filesToInstall() []string {
+	return a.installFiles
+}
+
+func (p *AndroidModuleBase) NoAddressSanitizer() bool {
+	return p.noAddressSanitizer
+}
+
+func (p *AndroidModuleBase) resourceDirs() []string {
+	return p.commonProperties.ResourceDirs
+}
+
+func (a *AndroidModuleBase) generateModuleTarget(ctx blueprint.ModuleContext) {
+	if a != ctx.FinalModule().(AndroidModule).base() {
+		return
+	}
+
+	allInstalledFiles := []string{}
+	ctx.VisitAllModuleVariants(func(module blueprint.Module) {
+		if androidModule, ok := module.(AndroidModule); ok {
+			files := androidModule.base().installFiles
+			allInstalledFiles = append(allInstalledFiles, files...)
+		}
+	})
+
+	if len(allInstalledFiles) > 0 {
+		ctx.Build(pctx, blueprint.BuildParams{
+			Rule:    blueprint.Phony,
+			Outputs: []string{ctx.ModuleName()},
+			Inputs:  allInstalledFiles,
+		})
+	}
+}
+
+func (a *AndroidModuleBase) DynamicDependencies(ctx blueprint.DynamicDependerModuleContext) []string {
+	actx := &androidDynamicDependerContext{
+		DynamicDependerModuleContext: ctx,
+		module: a,
+	}
+
+	if dynamic, ok := a.module.(AndroidDynamicDepender); ok {
+		return dynamic.AndroidDynamicDependencies(actx)
+	}
+
+	return nil
+}
+
+func (a *AndroidModuleBase) GenerateBuildActions(ctx blueprint.ModuleContext) {
+	androidCtx := &androidModuleContext{
+		ModuleContext: ctx,
+		installDeps:   a.computeInstallDeps(ctx),
+		installFiles:  a.installFiles,
+		arch:          a.commonProperties.CompileArch,
+	}
+
+	if a.commonProperties.Disabled {
+		return
+	}
+
+	a.module.GenerateAndroidBuildActions(androidCtx)
+	if ctx.Failed() {
+		return
+	}
+
+	a.generateModuleTarget(ctx)
+	if ctx.Failed() {
+		return
+	}
+}
+
+type androidModuleContext struct {
+	blueprint.ModuleContext
+	arch            Arch
+	installDeps     []string
+	installFiles    []string
+	checkbuildFiles []string
+}
+
+func (a *androidModuleContext) Build(pctx *blueprint.PackageContext, params blueprint.BuildParams) {
+	params.Optional = true
+	a.ModuleContext.Build(pctx, params)
+}
+
+func (a *androidModuleContext) Arch() Arch {
+	return a.arch
+}
+
+func (a *androidModuleContext) InstallFile(installPath, srcPath string) {
+	var fullInstallPath string
+	if a.arch.HostOrDevice.Device() {
+		// TODO: replace unset with a device name once we have device targeting
+		fullInstallPath = filepath.Join("out/target/product/unset/system", installPath,
+			filepath.Base(srcPath))
+	} else {
+		// TODO: replace unset with a host name
+		fullInstallPath = filepath.Join("out/host/unset/", installPath, filepath.Base(srcPath))
+	}
+
+	a.ModuleContext.Build(pctx, blueprint.BuildParams{
+		Rule:      Cp,
+		Outputs:   []string{fullInstallPath},
+		Inputs:    []string{srcPath},
+		OrderOnly: a.installDeps,
+	})
+
+	a.installFiles = append(a.installFiles, fullInstallPath)
+	a.checkbuildFiles = append(a.checkbuildFiles, srcPath)
+}
+
+func (a *androidModuleContext) CheckbuildFile(srcPath string) {
+	a.checkbuildFiles = append(a.checkbuildFiles, srcPath)
+}
+
+type androidDynamicDependerContext struct {
+	blueprint.DynamicDependerModuleContext
+	module *AndroidModuleBase
+}
+
+type fileInstaller interface {
+	filesToInstall() []string
+}
+
+func isFileInstaller(m blueprint.Module) bool {
+	_, ok := m.(fileInstaller)
+	return ok
+}
+
+func isAndroidModule(m blueprint.Module) bool {
+	_, ok := m.(AndroidModule)
+	return ok
+}