40182b6ff3
android.ModuleBase already calls aconfigUpdateAndroidBuildActions() that is the same with CollectDependencyAconfigFiles(). Remove the CollectDependencyAconfigFiles() to avoid duplication with aconfigUpdateAndroidBuildActions(). To make the aconfig information available in GenerateAndroidBuildActions() of all modules, call aconfigUpdateAndroidBuildActions() before calling GenerateAndroidBuildActions() of each module. Also, we don't need SetAconfigFileMkEntries(), which is a duplicate of aconfigUpdateAndroidMkData() Bug: 335363964 Test: diff `adb shell printflags` before and after the change. Change-Id: I52808e442e9fed7db1eae7b7c5ed0b1c5ba74f5d
262 lines
8.3 KiB
Go
262 lines
8.3 KiB
Go
// Copyright 2017 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 python
|
||
|
||
// This file contains the module types for building Python binary.
|
||
|
||
import (
|
||
"fmt"
|
||
"path/filepath"
|
||
"strings"
|
||
|
||
"android/soong/android"
|
||
)
|
||
|
||
func init() {
|
||
registerPythonBinaryComponents(android.InitRegistrationContext)
|
||
}
|
||
|
||
func registerPythonBinaryComponents(ctx android.RegistrationContext) {
|
||
ctx.RegisterModuleType("python_binary_host", PythonBinaryHostFactory)
|
||
}
|
||
|
||
type BinaryProperties struct {
|
||
// the name of the source file that is the main entry point of the program.
|
||
// this file must also be listed in srcs.
|
||
// If left unspecified, module name is used instead.
|
||
// If name doesn’t match any filename in srcs, main must be specified.
|
||
Main *string
|
||
|
||
// set the name of the output binary.
|
||
Stem *string `android:"arch_variant"`
|
||
|
||
// append to the name of the output binary.
|
||
Suffix *string `android:"arch_variant"`
|
||
|
||
// list of compatibility suites (for example "cts", "vts") that the module should be
|
||
// installed into.
|
||
Test_suites []string `android:"arch_variant"`
|
||
|
||
// whether to use `main` when starting the executable. The default is true, when set to
|
||
// false it will act much like the normal `python` executable, but with the sources and
|
||
// libraries automatically included in the PYTHONPATH.
|
||
Autorun *bool `android:"arch_variant"`
|
||
|
||
// Flag to indicate whether or not to create test config automatically. If AndroidTest.xml
|
||
// doesn't exist next to the Android.bp, this attribute doesn't need to be set to true
|
||
// explicitly.
|
||
Auto_gen_config *bool
|
||
}
|
||
|
||
type PythonBinaryModule struct {
|
||
PythonLibraryModule
|
||
binaryProperties BinaryProperties
|
||
|
||
// (.intermediate) module output path as installation source.
|
||
installSource android.Path
|
||
|
||
// Final installation path.
|
||
installedDest android.Path
|
||
|
||
androidMkSharedLibs []string
|
||
}
|
||
|
||
var _ android.AndroidMkEntriesProvider = (*PythonBinaryModule)(nil)
|
||
var _ android.Module = (*PythonBinaryModule)(nil)
|
||
|
||
type IntermPathProvider interface {
|
||
IntermPathForModuleOut() android.OptionalPath
|
||
}
|
||
|
||
func NewBinary(hod android.HostOrDeviceSupported) *PythonBinaryModule {
|
||
return &PythonBinaryModule{
|
||
PythonLibraryModule: *newModule(hod, android.MultilibFirst),
|
||
}
|
||
}
|
||
|
||
func PythonBinaryHostFactory() android.Module {
|
||
return NewBinary(android.HostSupported).init()
|
||
}
|
||
|
||
func (p *PythonBinaryModule) init() android.Module {
|
||
p.AddProperties(&p.properties, &p.protoProperties)
|
||
p.AddProperties(&p.binaryProperties)
|
||
android.InitAndroidArchModule(p, p.hod, p.multilib)
|
||
android.InitDefaultableModule(p)
|
||
return p
|
||
}
|
||
|
||
func (p *PythonBinaryModule) GenerateAndroidBuildActions(ctx android.ModuleContext) {
|
||
p.PythonLibraryModule.GenerateAndroidBuildActions(ctx)
|
||
p.buildBinary(ctx)
|
||
p.installedDest = ctx.InstallFile(installDir(ctx, "bin", "", ""),
|
||
p.installSource.Base(), p.installSource)
|
||
}
|
||
|
||
func (p *PythonBinaryModule) buildBinary(ctx android.ModuleContext) {
|
||
embeddedLauncher := p.isEmbeddedLauncherEnabled()
|
||
depsSrcsZips := p.collectPathsFromTransitiveDeps(ctx, embeddedLauncher)
|
||
main := ""
|
||
if p.autorun() {
|
||
main = p.getPyMainFile(ctx, p.srcsPathMappings)
|
||
}
|
||
|
||
var launcherPath android.OptionalPath
|
||
if embeddedLauncher {
|
||
ctx.VisitDirectDepsWithTag(launcherTag, func(m android.Module) {
|
||
if provider, ok := m.(IntermPathProvider); ok {
|
||
if launcherPath.Valid() {
|
||
panic(fmt.Errorf("launcher path was found before: %q",
|
||
launcherPath))
|
||
}
|
||
launcherPath = provider.IntermPathForModuleOut()
|
||
}
|
||
})
|
||
}
|
||
srcsZips := make(android.Paths, 0, len(depsSrcsZips)+1)
|
||
if embeddedLauncher {
|
||
srcsZips = append(srcsZips, p.precompiledSrcsZip)
|
||
} else {
|
||
srcsZips = append(srcsZips, p.srcsZip)
|
||
}
|
||
srcsZips = append(srcsZips, depsSrcsZips...)
|
||
p.installSource = registerBuildActionForParFile(ctx, embeddedLauncher, launcherPath,
|
||
p.getHostInterpreterName(ctx, p.properties.Actual_version),
|
||
main, p.getStem(ctx), srcsZips)
|
||
|
||
var sharedLibs []string
|
||
// if embedded launcher is enabled, we need to collect the shared library dependencies of the
|
||
// launcher
|
||
for _, dep := range ctx.GetDirectDepsWithTag(launcherSharedLibTag) {
|
||
sharedLibs = append(sharedLibs, ctx.OtherModuleName(dep))
|
||
}
|
||
p.androidMkSharedLibs = sharedLibs
|
||
}
|
||
|
||
func (p *PythonBinaryModule) AndroidMkEntries() []android.AndroidMkEntries {
|
||
entries := android.AndroidMkEntries{OutputFile: android.OptionalPathForPath(p.installSource)}
|
||
|
||
entries.Class = "EXECUTABLES"
|
||
|
||
entries.ExtraEntries = append(entries.ExtraEntries,
|
||
func(ctx android.AndroidMkExtraEntriesContext, entries *android.AndroidMkEntries) {
|
||
entries.AddCompatibilityTestSuites(p.binaryProperties.Test_suites...)
|
||
})
|
||
|
||
entries.Required = append(entries.Required, "libc++")
|
||
entries.ExtraEntries = append(entries.ExtraEntries,
|
||
func(ctx android.AndroidMkExtraEntriesContext, entries *android.AndroidMkEntries) {
|
||
path, file := filepath.Split(p.installedDest.String())
|
||
stem := strings.TrimSuffix(file, filepath.Ext(file))
|
||
|
||
entries.SetString("LOCAL_MODULE_SUFFIX", filepath.Ext(file))
|
||
entries.SetString("LOCAL_MODULE_PATH", path)
|
||
entries.SetString("LOCAL_MODULE_STEM", stem)
|
||
entries.AddStrings("LOCAL_SHARED_LIBRARIES", p.androidMkSharedLibs...)
|
||
entries.SetBool("LOCAL_CHECK_ELF_FILES", false)
|
||
})
|
||
|
||
return []android.AndroidMkEntries{entries}
|
||
}
|
||
|
||
func (p *PythonBinaryModule) DepsMutator(ctx android.BottomUpMutatorContext) {
|
||
p.PythonLibraryModule.DepsMutator(ctx)
|
||
|
||
if p.isEmbeddedLauncherEnabled() {
|
||
p.AddDepsOnPythonLauncherAndStdlib(ctx, pythonLibTag, launcherTag, launcherSharedLibTag, p.autorun(), ctx.Target())
|
||
}
|
||
}
|
||
|
||
// HostToolPath returns a path if appropriate such that this module can be used as a host tool,
|
||
// fulfilling the android.HostToolProvider interface.
|
||
func (p *PythonBinaryModule) HostToolPath() android.OptionalPath {
|
||
// TODO: This should only be set when building host binaries -- tests built for device would be
|
||
// setting this incorrectly.
|
||
return android.OptionalPathForPath(p.installedDest)
|
||
}
|
||
|
||
// OutputFiles returns output files based on given tag, returns an error if tag is unsupported.
|
||
func (p *PythonBinaryModule) OutputFiles(tag string) (android.Paths, error) {
|
||
switch tag {
|
||
case "":
|
||
return android.Paths{p.installSource}, nil
|
||
default:
|
||
return nil, fmt.Errorf("unsupported module reference tag %q", tag)
|
||
}
|
||
}
|
||
|
||
func (p *PythonBinaryModule) isEmbeddedLauncherEnabled() bool {
|
||
return BoolDefault(p.properties.Embedded_launcher, true)
|
||
}
|
||
|
||
func (b *PythonBinaryModule) autorun() bool {
|
||
return BoolDefault(b.binaryProperties.Autorun, true)
|
||
}
|
||
|
||
// get host interpreter name.
|
||
func (p *PythonBinaryModule) getHostInterpreterName(ctx android.ModuleContext,
|
||
actualVersion string) string {
|
||
var interp string
|
||
switch actualVersion {
|
||
case pyVersion2:
|
||
interp = "python2.7"
|
||
case pyVersion3:
|
||
interp = "python3"
|
||
default:
|
||
panic(fmt.Errorf("unknown Python actualVersion: %q for module: %q.",
|
||
actualVersion, ctx.ModuleName()))
|
||
}
|
||
|
||
return interp
|
||
}
|
||
|
||
// find main program path within runfiles tree.
|
||
func (p *PythonBinaryModule) getPyMainFile(ctx android.ModuleContext,
|
||
srcsPathMappings []pathMapping) string {
|
||
var main string
|
||
if String(p.binaryProperties.Main) == "" {
|
||
main = ctx.ModuleName() + pyExt
|
||
} else {
|
||
main = String(p.binaryProperties.Main)
|
||
}
|
||
|
||
for _, path := range srcsPathMappings {
|
||
if main == path.src.Rel() {
|
||
return path.dest
|
||
}
|
||
}
|
||
ctx.PropertyErrorf("main", "%q is not listed in srcs.", main)
|
||
|
||
return ""
|
||
}
|
||
|
||
func (p *PythonBinaryModule) getStem(ctx android.ModuleContext) string {
|
||
stem := ctx.ModuleName()
|
||
if String(p.binaryProperties.Stem) != "" {
|
||
stem = String(p.binaryProperties.Stem)
|
||
}
|
||
|
||
return stem + String(p.binaryProperties.Suffix)
|
||
}
|
||
|
||
func installDir(ctx android.ModuleContext, dir, dir64, relative string) android.InstallPath {
|
||
if ctx.Arch().ArchType.Multilib == "lib64" && dir64 != "" {
|
||
dir = dir64
|
||
}
|
||
if !ctx.Host() && ctx.Config().HasMultilibConflict(ctx.Arch().ArchType) {
|
||
dir = filepath.Join(dir, ctx.Arch().ArchType.String())
|
||
}
|
||
return android.PathForModuleInstall(ctx, dir, relative)
|
||
}
|