aa5b377ee9
Still fall back to the hardcoded list for what to put in LOCAL_SHARED_LIBRARIES, because I couldn't figure out a good way to get those modules at the moment. Bug: 259718110 Test: Presubmits Change-Id: Ia992ffea8819d8c67280b08bc45505f77af09de0
274 lines
8.7 KiB
Go
274 lines
8.7 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 `android:"arch_variant"`
|
||
|
||
// 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)
|
||
android.InitBazelModule(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()
|
||
}
|
||
})
|
||
|
||
// TODO: get the list of shared libraries directly from the launcher module somehow
|
||
var sharedLibs []string
|
||
sharedLibs = append(sharedLibs, "libsqlite")
|
||
if ctx.Target().Os.Bionic() {
|
||
sharedLibs = append(sharedLibs, "libc", "libdl", "libm")
|
||
}
|
||
if ctx.Target().Os == android.LinuxMusl && !ctx.Config().HostStaticBinaries() {
|
||
sharedLibs = append(sharedLibs, "libc_musl")
|
||
}
|
||
switch p.properties.Actual_version {
|
||
case pyVersion2:
|
||
sharedLibs = append(sharedLibs, "libc++")
|
||
case pyVersion3:
|
||
if ctx.Device() {
|
||
sharedLibs = append(sharedLibs, "liblog")
|
||
}
|
||
}
|
||
p.androidMkSharedLibs = sharedLibs
|
||
}
|
||
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)
|
||
}
|
||
|
||
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, 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 Bool(p.properties.Embedded_launcher)
|
||
}
|
||
|
||
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)
|
||
}
|