2019-08-28 03:03:00 +08:00
|
|
|
// Copyright 2019 The Android Open Source Project
|
|
|
|
//
|
|
|
|
// 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 rust
|
|
|
|
|
|
|
|
import (
|
2019-10-19 05:18:45 +08:00
|
|
|
"fmt"
|
2019-08-28 03:03:00 +08:00
|
|
|
"strings"
|
|
|
|
|
|
|
|
"github.com/google/blueprint"
|
|
|
|
"github.com/google/blueprint/proptools"
|
|
|
|
|
|
|
|
"android/soong/android"
|
|
|
|
"android/soong/cc"
|
|
|
|
"android/soong/rust/config"
|
|
|
|
)
|
|
|
|
|
|
|
|
var pctx = android.NewPackageContext("android/soong/rust")
|
|
|
|
|
|
|
|
func init() {
|
|
|
|
// Only allow rust modules to be defined for certain projects
|
|
|
|
|
|
|
|
android.AddNeverAllowRules(
|
|
|
|
android.NeverAllow().
|
2019-09-18 23:42:54 +08:00
|
|
|
NotIn(config.RustAllowedPaths...).
|
|
|
|
ModuleType(config.RustModuleTypes...))
|
2019-08-28 03:03:00 +08:00
|
|
|
|
|
|
|
android.RegisterModuleType("rust_defaults", defaultsFactory)
|
|
|
|
android.PreDepsMutators(func(ctx android.RegisterMutatorsContext) {
|
|
|
|
ctx.BottomUp("rust_libraries", LibraryMutator).Parallel()
|
2020-04-09 21:56:02 +08:00
|
|
|
ctx.BottomUp("rust_begin", BeginMutator).Parallel()
|
2019-08-28 03:03:00 +08:00
|
|
|
})
|
|
|
|
pctx.Import("android/soong/rust/config")
|
2020-07-08 20:39:44 +08:00
|
|
|
pctx.ImportAs("ccConfig", "android/soong/cc/config")
|
2019-08-28 03:03:00 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
type Flags struct {
|
2020-06-16 22:26:57 +08:00
|
|
|
GlobalRustFlags []string // Flags that apply globally to rust
|
|
|
|
GlobalLinkFlags []string // Flags that apply globally to linker
|
|
|
|
RustFlags []string // Flags that apply to rust
|
|
|
|
LinkFlags []string // Flags that apply to linker
|
2020-06-22 19:28:02 +08:00
|
|
|
ClippyFlags []string // Flags that apply to clippy-driver, during the linting
|
2019-09-21 02:00:37 +08:00
|
|
|
Toolchain config.Toolchain
|
2020-04-09 21:56:02 +08:00
|
|
|
Coverage bool
|
2020-06-22 19:28:02 +08:00
|
|
|
Clippy bool
|
2019-08-28 03:03:00 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
type BaseProperties struct {
|
|
|
|
AndroidMkRlibs []string
|
|
|
|
AndroidMkDylibs []string
|
|
|
|
AndroidMkProcMacroLibs []string
|
|
|
|
AndroidMkSharedLibs []string
|
|
|
|
AndroidMkStaticLibs []string
|
2020-07-10 09:03:28 +08:00
|
|
|
|
2020-08-01 01:40:31 +08:00
|
|
|
SubName string `blueprint:"mutated"`
|
|
|
|
|
2020-07-10 09:03:28 +08:00
|
|
|
PreventInstall bool
|
|
|
|
HideFromMake bool
|
2019-08-28 03:03:00 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
type Module struct {
|
|
|
|
android.ModuleBase
|
|
|
|
android.DefaultableModuleBase
|
|
|
|
|
|
|
|
Properties BaseProperties
|
|
|
|
|
|
|
|
hod android.HostOrDeviceSupported
|
|
|
|
multilib android.Multilib
|
|
|
|
|
|
|
|
compiler compiler
|
2020-04-09 21:56:02 +08:00
|
|
|
coverage *coverage
|
2020-06-22 19:28:02 +08:00
|
|
|
clippy *clippy
|
2019-08-28 03:03:00 +08:00
|
|
|
cachedToolchain config.Toolchain
|
2020-07-08 20:39:44 +08:00
|
|
|
sourceProvider SourceProvider
|
2019-08-28 03:03:00 +08:00
|
|
|
subAndroidMkOnce map[subAndroidMkProvider]bool
|
2020-07-08 20:39:44 +08:00
|
|
|
|
2020-08-01 01:40:31 +08:00
|
|
|
outputFile android.OptionalPath
|
|
|
|
generatedFile android.OptionalPath
|
2019-08-28 03:03:00 +08:00
|
|
|
}
|
|
|
|
|
2020-07-10 09:03:28 +08:00
|
|
|
func (mod *Module) OutputFiles(tag string) (android.Paths, error) {
|
|
|
|
switch tag {
|
|
|
|
case "":
|
|
|
|
if mod.sourceProvider != nil {
|
|
|
|
return mod.sourceProvider.Srcs(), nil
|
|
|
|
} else {
|
|
|
|
if mod.outputFile.Valid() {
|
|
|
|
return android.Paths{mod.outputFile.Path()}, nil
|
|
|
|
}
|
|
|
|
return android.Paths{}, nil
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
return nil, fmt.Errorf("unsupported module reference tag %q", tag)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-11-19 08:00:16 +08:00
|
|
|
var _ android.ImageInterface = (*Module)(nil)
|
|
|
|
|
|
|
|
func (mod *Module) ImageMutatorBegin(ctx android.BaseModuleContext) {}
|
|
|
|
|
|
|
|
func (mod *Module) CoreVariantNeeded(ctx android.BaseModuleContext) bool {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
2020-01-22 07:53:22 +08:00
|
|
|
func (mod *Module) RamdiskVariantNeeded(android.BaseModuleContext) bool {
|
|
|
|
return mod.InRamdisk()
|
|
|
|
}
|
|
|
|
|
2019-11-19 08:00:16 +08:00
|
|
|
func (mod *Module) RecoveryVariantNeeded(android.BaseModuleContext) bool {
|
|
|
|
return mod.InRecovery()
|
|
|
|
}
|
|
|
|
|
|
|
|
func (mod *Module) ExtraImageVariations(android.BaseModuleContext) []string {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (c *Module) SetImageVariation(ctx android.BaseModuleContext, variant string, module android.Module) {
|
|
|
|
}
|
|
|
|
|
2019-10-19 05:49:46 +08:00
|
|
|
func (mod *Module) BuildStubs() bool {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (mod *Module) HasStubsVariants() bool {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (mod *Module) SelectedStl() string {
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
|
2019-11-22 04:30:50 +08:00
|
|
|
func (mod *Module) NonCcVariants() bool {
|
|
|
|
if mod.compiler != nil {
|
2020-07-31 23:01:18 +08:00
|
|
|
if _, ok := mod.compiler.(libraryInterface); ok {
|
|
|
|
return false
|
2019-11-22 04:30:50 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
panic(fmt.Errorf("NonCcVariants called on non-library module: %q", mod.BaseModuleName()))
|
|
|
|
}
|
|
|
|
|
2019-10-19 05:49:46 +08:00
|
|
|
func (mod *Module) ApiLevel() string {
|
|
|
|
panic(fmt.Errorf("Called ApiLevel on Rust module %q; stubs libraries are not yet supported.", mod.BaseModuleName()))
|
|
|
|
}
|
|
|
|
|
|
|
|
func (mod *Module) Static() bool {
|
|
|
|
if mod.compiler != nil {
|
|
|
|
if library, ok := mod.compiler.(libraryInterface); ok {
|
|
|
|
return library.static()
|
|
|
|
}
|
|
|
|
}
|
2020-07-31 23:01:18 +08:00
|
|
|
return false
|
2019-10-19 05:49:46 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
func (mod *Module) Shared() bool {
|
|
|
|
if mod.compiler != nil {
|
|
|
|
if library, ok := mod.compiler.(libraryInterface); ok {
|
2020-07-31 23:01:18 +08:00
|
|
|
return library.shared()
|
2019-10-19 05:49:46 +08:00
|
|
|
}
|
|
|
|
}
|
2020-07-31 23:01:18 +08:00
|
|
|
return false
|
2019-10-19 05:49:46 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
func (mod *Module) Toc() android.OptionalPath {
|
|
|
|
if mod.compiler != nil {
|
|
|
|
if _, ok := mod.compiler.(libraryInterface); ok {
|
|
|
|
return android.OptionalPath{}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
panic(fmt.Errorf("Toc() called on non-library module: %q", mod.BaseModuleName()))
|
|
|
|
}
|
|
|
|
|
2020-01-22 07:53:22 +08:00
|
|
|
func (mod *Module) OnlyInRamdisk() bool {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2019-10-19 05:49:46 +08:00
|
|
|
func (mod *Module) OnlyInRecovery() bool {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2020-04-08 00:50:32 +08:00
|
|
|
func (mod *Module) UseSdk() bool {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2019-10-19 05:49:46 +08:00
|
|
|
func (mod *Module) UseVndk() bool {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (mod *Module) MustUseVendorVariant() bool {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (mod *Module) IsVndk() bool {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (mod *Module) HasVendorVariant() bool {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (mod *Module) SdkVersion() string {
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
|
2020-04-08 00:50:32 +08:00
|
|
|
func (mod *Module) AlwaysSdk() bool {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
Don't create version variants for SDK variants
When a lib has sdk_version set, an SDK variant and a platform variant
are created by the sdkMutator. Then by the versionMutator, if the
library had 'stubs.versions' property, one or more versioned variants
and one impl variant are created for each of the two (SDK and platform)
variants. As a concrete example,
cc_library {
name: "foo",
sdk_version: "current",
stubs: { versions: ["1", "2"], },
}
would create 6 variants:
1) (sdk: "", version: "")
2) (sdk: "", version: "1")
3) (sdk: "", version: "2")
4) (sdk: "sdk", version: "")
5) (sdk: "sdk", version: "1")
6) (sdk: "sdk", version: "2")
This is somewhat uncessary because the need for the SDK mutator is to
have the platform variant (sdk:"") of a lib where sdk_version is unset,
which actually makes sens for the impl variant (version:""), but not
the versioned variants (version:"1" or version:"2").
This is not only unncessary, but also causes duplicate module
definitions in the Make side when doing an unbundled build. Specifically,
The #1 and #4 above both are emitted to Make and get the same name
"foo".
To fix the problem and not to create unnecessary variants, the versioned
variants are no longer created for the sdk variant. So, foo now has
the following variants only.
1) (sdk: "", version: "") // not emitted to Make (by versionMutator)
2) (sdk: "", version: "1") // not emitted to Make (by versionMutator)
3) (sdk: "", version: "2") // emitted to Make (by versionMutator)
4) (sdk: "sdk", version: "") // not emitted to Make (by versionMutator)
Bug: 159106705
Test: Add sdk_version:"minimum" to libnativehelper in libnativehelper/Android.bp.
m SOONG_ALLOW_MISSING_DEPENDENCIES=true TARGET_BUILD_UNBUNDLED=true libnativehelper
Change-Id: I6f02f4189e5504286174ccff1642166da82d00c9
2020-06-16 20:58:53 +08:00
|
|
|
func (mod *Module) IsSdkVariant() bool {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2019-10-19 05:49:46 +08:00
|
|
|
func (mod *Module) ToolchainLibrary() bool {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (mod *Module) NdkPrebuiltStl() bool {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (mod *Module) StubDecorator() bool {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2019-08-28 03:03:00 +08:00
|
|
|
type Deps struct {
|
|
|
|
Dylibs []string
|
|
|
|
Rlibs []string
|
2020-06-30 05:34:06 +08:00
|
|
|
Rustlibs []string
|
2019-08-28 03:03:00 +08:00
|
|
|
ProcMacros []string
|
|
|
|
SharedLibs []string
|
|
|
|
StaticLibs []string
|
|
|
|
|
|
|
|
CrtBegin, CrtEnd string
|
|
|
|
}
|
|
|
|
|
|
|
|
type PathDeps struct {
|
|
|
|
DyLibs RustLibraries
|
|
|
|
RLibs RustLibraries
|
|
|
|
SharedLibs android.Paths
|
|
|
|
StaticLibs android.Paths
|
|
|
|
ProcMacros RustLibraries
|
|
|
|
linkDirs []string
|
|
|
|
depFlags []string
|
|
|
|
//ReexportedDeps android.Paths
|
2019-09-21 02:00:37 +08:00
|
|
|
|
2020-07-25 04:05:01 +08:00
|
|
|
// Used by bindgen modules which call clang
|
|
|
|
depClangFlags []string
|
|
|
|
depIncludePaths android.Paths
|
|
|
|
depSystemIncludePaths android.Paths
|
|
|
|
|
2020-04-09 21:56:02 +08:00
|
|
|
coverageFiles android.Paths
|
|
|
|
|
2019-09-21 02:00:37 +08:00
|
|
|
CrtBegin android.OptionalPath
|
|
|
|
CrtEnd android.OptionalPath
|
2020-05-16 08:36:30 +08:00
|
|
|
|
|
|
|
// Paths to generated source files
|
|
|
|
SrcDeps android.Paths
|
2019-08-28 03:03:00 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
type RustLibraries []RustLibrary
|
|
|
|
|
|
|
|
type RustLibrary struct {
|
|
|
|
Path android.Path
|
|
|
|
CrateName string
|
|
|
|
}
|
|
|
|
|
|
|
|
type compiler interface {
|
|
|
|
compilerFlags(ctx ModuleContext, flags Flags) Flags
|
|
|
|
compilerProps() []interface{}
|
|
|
|
compile(ctx ModuleContext, flags Flags, deps PathDeps) android.Path
|
|
|
|
compilerDeps(ctx DepsContext, deps Deps) Deps
|
|
|
|
crateName() string
|
|
|
|
|
2019-12-13 11:36:05 +08:00
|
|
|
inData() bool
|
2019-08-28 03:03:00 +08:00
|
|
|
install(ctx ModuleContext, path android.Path)
|
|
|
|
relativeInstallPath() string
|
2020-04-09 21:56:02 +08:00
|
|
|
|
|
|
|
nativeCoverage() bool
|
2020-08-01 01:40:31 +08:00
|
|
|
|
|
|
|
Disabled() bool
|
|
|
|
SetDisabled()
|
2020-04-09 21:56:02 +08:00
|
|
|
}
|
|
|
|
|
2020-06-26 00:34:12 +08:00
|
|
|
type exportedFlagsProducer interface {
|
|
|
|
exportedLinkDirs() []string
|
|
|
|
exportedDepFlags() []string
|
|
|
|
exportLinkDirs(...string)
|
|
|
|
exportDepFlags(...string)
|
|
|
|
}
|
|
|
|
|
|
|
|
type flagExporter struct {
|
|
|
|
depFlags []string
|
|
|
|
linkDirs []string
|
|
|
|
}
|
|
|
|
|
|
|
|
func (flagExporter *flagExporter) exportedLinkDirs() []string {
|
|
|
|
return flagExporter.linkDirs
|
|
|
|
}
|
|
|
|
|
|
|
|
func (flagExporter *flagExporter) exportedDepFlags() []string {
|
|
|
|
return flagExporter.depFlags
|
|
|
|
}
|
|
|
|
|
|
|
|
func (flagExporter *flagExporter) exportLinkDirs(dirs ...string) {
|
|
|
|
flagExporter.linkDirs = android.FirstUniqueStrings(append(flagExporter.linkDirs, dirs...))
|
|
|
|
}
|
|
|
|
|
|
|
|
func (flagExporter *flagExporter) exportDepFlags(flags ...string) {
|
|
|
|
flagExporter.depFlags = android.FirstUniqueStrings(append(flagExporter.depFlags, flags...))
|
|
|
|
}
|
|
|
|
|
|
|
|
var _ exportedFlagsProducer = (*flagExporter)(nil)
|
|
|
|
|
|
|
|
func NewFlagExporter() *flagExporter {
|
|
|
|
return &flagExporter{
|
|
|
|
depFlags: []string{},
|
|
|
|
linkDirs: []string{},
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-04-09 21:56:02 +08:00
|
|
|
func (mod *Module) isCoverageVariant() bool {
|
|
|
|
return mod.coverage.Properties.IsCoverageVariant
|
|
|
|
}
|
|
|
|
|
|
|
|
var _ cc.Coverage = (*Module)(nil)
|
|
|
|
|
|
|
|
func (mod *Module) IsNativeCoverageNeeded(ctx android.BaseModuleContext) bool {
|
|
|
|
return mod.coverage != nil && mod.coverage.Properties.NeedCoverageVariant
|
|
|
|
}
|
|
|
|
|
|
|
|
func (mod *Module) PreventInstall() {
|
|
|
|
mod.Properties.PreventInstall = true
|
|
|
|
}
|
|
|
|
|
|
|
|
func (mod *Module) HideFromMake() {
|
|
|
|
mod.Properties.HideFromMake = true
|
|
|
|
}
|
|
|
|
|
|
|
|
func (mod *Module) MarkAsCoverageVariant(coverage bool) {
|
|
|
|
mod.coverage.Properties.IsCoverageVariant = coverage
|
|
|
|
}
|
|
|
|
|
|
|
|
func (mod *Module) EnableCoverageIfNeeded() {
|
|
|
|
mod.coverage.Properties.CoverageEnabled = mod.coverage.Properties.NeedCoverageBuild
|
2019-08-28 03:03:00 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
func defaultsFactory() android.Module {
|
|
|
|
return DefaultsFactory()
|
|
|
|
}
|
|
|
|
|
|
|
|
type Defaults struct {
|
|
|
|
android.ModuleBase
|
|
|
|
android.DefaultsModuleBase
|
|
|
|
}
|
|
|
|
|
|
|
|
func DefaultsFactory(props ...interface{}) android.Module {
|
|
|
|
module := &Defaults{}
|
|
|
|
|
|
|
|
module.AddProperties(props...)
|
|
|
|
module.AddProperties(
|
|
|
|
&BaseProperties{},
|
|
|
|
&BaseCompilerProperties{},
|
|
|
|
&BinaryCompilerProperties{},
|
|
|
|
&LibraryCompilerProperties{},
|
|
|
|
&ProcMacroCompilerProperties{},
|
|
|
|
&PrebuiltProperties{},
|
2020-07-08 20:39:44 +08:00
|
|
|
&SourceProviderProperties{},
|
2019-11-01 11:56:47 +08:00
|
|
|
&TestProperties{},
|
2020-04-09 21:56:02 +08:00
|
|
|
&cc.CoverageProperties{},
|
2020-06-22 19:28:02 +08:00
|
|
|
&ClippyProperties{},
|
2019-08-28 03:03:00 +08:00
|
|
|
)
|
|
|
|
|
|
|
|
android.InitDefaultsModule(module)
|
|
|
|
return module
|
|
|
|
}
|
|
|
|
|
|
|
|
func (mod *Module) CrateName() string {
|
2019-11-01 10:38:29 +08:00
|
|
|
return mod.compiler.crateName()
|
2019-08-28 03:03:00 +08:00
|
|
|
}
|
|
|
|
|
2019-10-19 05:18:45 +08:00
|
|
|
func (mod *Module) CcLibrary() bool {
|
|
|
|
if mod.compiler != nil {
|
|
|
|
if _, ok := mod.compiler.(*libraryDecorator); ok {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (mod *Module) CcLibraryInterface() bool {
|
|
|
|
if mod.compiler != nil {
|
2020-07-31 23:01:18 +08:00
|
|
|
// use build{Static,Shared}() instead of {static,shared}() here because this might be called before
|
|
|
|
// VariantIs{Static,Shared} is set.
|
|
|
|
if lib, ok := mod.compiler.(libraryInterface); ok && (lib.buildShared() || lib.buildStatic()) {
|
2019-10-19 05:18:45 +08:00
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2019-11-07 11:15:49 +08:00
|
|
|
func (mod *Module) IncludeDirs() android.Paths {
|
2019-10-19 05:18:45 +08:00
|
|
|
if mod.compiler != nil {
|
2019-10-19 05:49:46 +08:00
|
|
|
if library, ok := mod.compiler.(*libraryDecorator); ok {
|
2019-11-07 11:15:49 +08:00
|
|
|
return library.includeDirs
|
2019-10-19 05:18:45 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
panic(fmt.Errorf("IncludeDirs called on non-library module: %q", mod.BaseModuleName()))
|
|
|
|
}
|
|
|
|
|
|
|
|
func (mod *Module) SetStatic() {
|
|
|
|
if mod.compiler != nil {
|
2019-10-19 05:49:46 +08:00
|
|
|
if library, ok := mod.compiler.(libraryInterface); ok {
|
|
|
|
library.setStatic()
|
2019-10-19 05:18:45 +08:00
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
panic(fmt.Errorf("SetStatic called on non-library module: %q", mod.BaseModuleName()))
|
|
|
|
}
|
|
|
|
|
|
|
|
func (mod *Module) SetShared() {
|
|
|
|
if mod.compiler != nil {
|
2019-10-19 05:49:46 +08:00
|
|
|
if library, ok := mod.compiler.(libraryInterface); ok {
|
|
|
|
library.setShared()
|
2019-10-19 05:18:45 +08:00
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
panic(fmt.Errorf("SetShared called on non-library module: %q", mod.BaseModuleName()))
|
|
|
|
}
|
|
|
|
|
|
|
|
func (mod *Module) SetBuildStubs() {
|
|
|
|
panic("SetBuildStubs not yet implemented for rust modules")
|
|
|
|
}
|
|
|
|
|
|
|
|
func (mod *Module) SetStubsVersions(string) {
|
|
|
|
panic("SetStubsVersions not yet implemented for rust modules")
|
|
|
|
}
|
|
|
|
|
2020-02-26 21:45:42 +08:00
|
|
|
func (mod *Module) StubsVersion() string {
|
|
|
|
panic("SetStubsVersions not yet implemented for rust modules")
|
|
|
|
}
|
|
|
|
|
2019-10-19 05:18:45 +08:00
|
|
|
func (mod *Module) BuildStaticVariant() bool {
|
|
|
|
if mod.compiler != nil {
|
2019-10-19 05:49:46 +08:00
|
|
|
if library, ok := mod.compiler.(libraryInterface); ok {
|
|
|
|
return library.buildStatic()
|
2019-10-19 05:18:45 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
panic(fmt.Errorf("BuildStaticVariant called on non-library module: %q", mod.BaseModuleName()))
|
|
|
|
}
|
|
|
|
|
|
|
|
func (mod *Module) BuildSharedVariant() bool {
|
|
|
|
if mod.compiler != nil {
|
2019-10-19 05:49:46 +08:00
|
|
|
if library, ok := mod.compiler.(libraryInterface); ok {
|
|
|
|
return library.buildShared()
|
2019-10-19 05:18:45 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
panic(fmt.Errorf("BuildSharedVariant called on non-library module: %q", mod.BaseModuleName()))
|
|
|
|
}
|
|
|
|
|
|
|
|
// Rust module deps don't have a link order (?)
|
|
|
|
func (mod *Module) SetDepsInLinkOrder([]android.Path) {}
|
|
|
|
|
|
|
|
func (mod *Module) GetDepsInLinkOrder() []android.Path {
|
|
|
|
return []android.Path{}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (mod *Module) GetStaticVariant() cc.LinkableInterface {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (mod *Module) Module() android.Module {
|
|
|
|
return mod
|
|
|
|
}
|
|
|
|
|
|
|
|
func (mod *Module) StubsVersions() []string {
|
|
|
|
// For now, Rust has no stubs versions.
|
|
|
|
if mod.compiler != nil {
|
2020-06-26 00:34:12 +08:00
|
|
|
if _, ok := mod.compiler.(libraryInterface); ok {
|
2019-10-19 05:18:45 +08:00
|
|
|
return []string{}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
panic(fmt.Errorf("StubsVersions called on non-library module: %q", mod.BaseModuleName()))
|
|
|
|
}
|
|
|
|
|
|
|
|
func (mod *Module) OutputFile() android.OptionalPath {
|
|
|
|
return mod.outputFile
|
|
|
|
}
|
|
|
|
|
|
|
|
func (mod *Module) InRecovery() bool {
|
|
|
|
// For now, Rust has no notion of the recovery image
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
func (mod *Module) HasStaticVariant() bool {
|
|
|
|
if mod.GetStaticVariant() != nil {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2020-04-09 21:56:02 +08:00
|
|
|
func (mod *Module) CoverageFiles() android.Paths {
|
|
|
|
if mod.compiler != nil {
|
2020-06-25 15:47:46 +08:00
|
|
|
if !mod.compiler.nativeCoverage() {
|
|
|
|
return android.Paths{}
|
|
|
|
}
|
2020-04-09 21:56:02 +08:00
|
|
|
if library, ok := mod.compiler.(*libraryDecorator); ok {
|
|
|
|
if library.coverageFile != nil {
|
|
|
|
return android.Paths{library.coverageFile}
|
|
|
|
}
|
|
|
|
return android.Paths{}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
panic(fmt.Errorf("CoverageFiles called on non-library module: %q", mod.BaseModuleName()))
|
|
|
|
}
|
|
|
|
|
2019-10-19 05:18:45 +08:00
|
|
|
var _ cc.LinkableInterface = (*Module)(nil)
|
|
|
|
|
2019-08-28 03:03:00 +08:00
|
|
|
func (mod *Module) Init() android.Module {
|
|
|
|
mod.AddProperties(&mod.Properties)
|
|
|
|
|
|
|
|
if mod.compiler != nil {
|
|
|
|
mod.AddProperties(mod.compiler.compilerProps()...)
|
|
|
|
}
|
2020-04-09 21:56:02 +08:00
|
|
|
if mod.coverage != nil {
|
|
|
|
mod.AddProperties(mod.coverage.props()...)
|
|
|
|
}
|
2020-06-22 19:28:02 +08:00
|
|
|
if mod.clippy != nil {
|
|
|
|
mod.AddProperties(mod.clippy.props()...)
|
|
|
|
}
|
2020-07-08 20:39:44 +08:00
|
|
|
if mod.sourceProvider != nil {
|
|
|
|
mod.AddProperties(mod.sourceProvider.sourceProviderProps()...)
|
|
|
|
}
|
2020-04-09 21:56:02 +08:00
|
|
|
|
2019-08-28 03:03:00 +08:00
|
|
|
android.InitAndroidArchModule(mod, mod.hod, mod.multilib)
|
|
|
|
|
|
|
|
android.InitDefaultableModule(mod)
|
|
|
|
|
2019-09-07 06:29:52 +08:00
|
|
|
// Explicitly disable unsupported targets.
|
|
|
|
android.AddLoadHook(mod, func(ctx android.LoadHookContext) {
|
|
|
|
disableTargets := struct {
|
|
|
|
Target struct {
|
|
|
|
Linux_bionic struct {
|
|
|
|
Enabled *bool
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}{}
|
|
|
|
disableTargets.Target.Linux_bionic.Enabled = proptools.BoolPtr(false)
|
|
|
|
|
|
|
|
ctx.AppendProperties(&disableTargets)
|
|
|
|
})
|
|
|
|
|
2019-08-28 03:03:00 +08:00
|
|
|
return mod
|
|
|
|
}
|
|
|
|
|
|
|
|
func newBaseModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
|
|
|
|
return &Module{
|
|
|
|
hod: hod,
|
|
|
|
multilib: multilib,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
|
|
|
|
module := newBaseModule(hod, multilib)
|
2020-04-09 21:56:02 +08:00
|
|
|
module.coverage = &coverage{}
|
2020-06-22 19:28:02 +08:00
|
|
|
module.clippy = &clippy{}
|
2019-08-28 03:03:00 +08:00
|
|
|
return module
|
|
|
|
}
|
|
|
|
|
|
|
|
type ModuleContext interface {
|
|
|
|
android.ModuleContext
|
|
|
|
ModuleContextIntf
|
|
|
|
}
|
|
|
|
|
|
|
|
type BaseModuleContext interface {
|
|
|
|
android.BaseModuleContext
|
|
|
|
ModuleContextIntf
|
|
|
|
}
|
|
|
|
|
|
|
|
type DepsContext interface {
|
|
|
|
android.BottomUpMutatorContext
|
|
|
|
ModuleContextIntf
|
|
|
|
}
|
|
|
|
|
|
|
|
type ModuleContextIntf interface {
|
2020-06-24 17:32:48 +08:00
|
|
|
RustModule() *Module
|
2019-08-28 03:03:00 +08:00
|
|
|
toolchain() config.Toolchain
|
|
|
|
}
|
|
|
|
|
|
|
|
type depsContext struct {
|
|
|
|
android.BottomUpMutatorContext
|
|
|
|
}
|
|
|
|
|
|
|
|
type moduleContext struct {
|
|
|
|
android.ModuleContext
|
|
|
|
}
|
|
|
|
|
2020-06-24 17:32:48 +08:00
|
|
|
type baseModuleContext struct {
|
|
|
|
android.BaseModuleContext
|
2020-04-09 21:56:02 +08:00
|
|
|
}
|
|
|
|
|
2020-06-24 17:32:48 +08:00
|
|
|
func (ctx *moduleContext) RustModule() *Module {
|
|
|
|
return ctx.Module().(*Module)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ctx *moduleContext) toolchain() config.Toolchain {
|
|
|
|
return ctx.RustModule().toolchain(ctx)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ctx *depsContext) RustModule() *Module {
|
|
|
|
return ctx.Module().(*Module)
|
2020-04-09 21:56:02 +08:00
|
|
|
}
|
|
|
|
|
2020-06-24 17:32:48 +08:00
|
|
|
func (ctx *depsContext) toolchain() config.Toolchain {
|
|
|
|
return ctx.RustModule().toolchain(ctx)
|
2019-08-28 03:03:00 +08:00
|
|
|
}
|
|
|
|
|
2020-06-24 17:32:48 +08:00
|
|
|
func (ctx *baseModuleContext) RustModule() *Module {
|
|
|
|
return ctx.Module().(*Module)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ctx *baseModuleContext) toolchain() config.Toolchain {
|
|
|
|
return ctx.RustModule().toolchain(ctx)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (mod *Module) nativeCoverage() bool {
|
|
|
|
return mod.compiler != nil && mod.compiler.nativeCoverage()
|
2019-08-28 03:03:00 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
func (mod *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
|
|
|
|
if mod.cachedToolchain == nil {
|
|
|
|
mod.cachedToolchain = config.FindToolchain(ctx.Os(), ctx.Arch())
|
|
|
|
}
|
|
|
|
return mod.cachedToolchain
|
|
|
|
}
|
|
|
|
|
|
|
|
func (d *Defaults) GenerateAndroidBuildActions(ctx android.ModuleContext) {
|
|
|
|
}
|
|
|
|
|
|
|
|
func (mod *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
|
|
|
|
ctx := &moduleContext{
|
|
|
|
ModuleContext: actx,
|
|
|
|
}
|
|
|
|
|
|
|
|
toolchain := mod.toolchain(ctx)
|
|
|
|
|
|
|
|
if !toolchain.Supported() {
|
|
|
|
// This toolchain's unsupported, there's nothing to do for this mod.
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
deps := mod.depsToPaths(ctx)
|
|
|
|
flags := Flags{
|
|
|
|
Toolchain: toolchain,
|
|
|
|
}
|
|
|
|
|
|
|
|
if mod.compiler != nil {
|
|
|
|
flags = mod.compiler.compilerFlags(ctx, flags)
|
2020-04-09 21:56:02 +08:00
|
|
|
}
|
|
|
|
if mod.coverage != nil {
|
|
|
|
flags, deps = mod.coverage.flags(ctx, flags, deps)
|
|
|
|
}
|
2020-06-22 19:28:02 +08:00
|
|
|
if mod.clippy != nil {
|
|
|
|
flags, deps = mod.clippy.flags(ctx, flags, deps)
|
|
|
|
}
|
2020-04-09 21:56:02 +08:00
|
|
|
|
2020-08-01 01:40:31 +08:00
|
|
|
// SourceProvider needs to call generateSource() before compiler calls compile() so it can provide the source.
|
|
|
|
// TODO(b/162588681) This shouldn't have to run for every variant.
|
|
|
|
if mod.sourceProvider != nil {
|
|
|
|
generatedFile := mod.sourceProvider.generateSource(ctx, deps)
|
|
|
|
mod.generatedFile = android.OptionalPathForPath(generatedFile)
|
|
|
|
mod.sourceProvider.setSubName(ctx.ModuleSubDir())
|
|
|
|
}
|
|
|
|
|
|
|
|
if mod.compiler != nil && !mod.compiler.Disabled() {
|
2019-08-28 03:03:00 +08:00
|
|
|
outputFile := mod.compiler.compile(ctx, flags, deps)
|
2020-08-01 01:40:31 +08:00
|
|
|
|
2019-08-28 03:03:00 +08:00
|
|
|
mod.outputFile = android.OptionalPathForPath(outputFile)
|
2020-08-01 01:40:31 +08:00
|
|
|
if mod.outputFile.Valid() && !mod.Properties.PreventInstall {
|
2020-04-09 21:56:02 +08:00
|
|
|
mod.compiler.install(ctx, mod.outputFile.Path())
|
|
|
|
}
|
2019-08-28 03:03:00 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (mod *Module) deps(ctx DepsContext) Deps {
|
|
|
|
deps := Deps{}
|
|
|
|
|
|
|
|
if mod.compiler != nil {
|
|
|
|
deps = mod.compiler.compilerDeps(ctx, deps)
|
2020-08-01 01:40:31 +08:00
|
|
|
}
|
|
|
|
if mod.sourceProvider != nil {
|
2020-07-08 20:39:44 +08:00
|
|
|
deps = mod.sourceProvider.sourceProviderDeps(ctx, deps)
|
2019-08-28 03:03:00 +08:00
|
|
|
}
|
|
|
|
|
2020-04-09 21:56:02 +08:00
|
|
|
if mod.coverage != nil {
|
|
|
|
deps = mod.coverage.deps(ctx, deps)
|
|
|
|
}
|
|
|
|
|
2019-08-28 03:03:00 +08:00
|
|
|
deps.Rlibs = android.LastUniqueStrings(deps.Rlibs)
|
|
|
|
deps.Dylibs = android.LastUniqueStrings(deps.Dylibs)
|
2020-06-30 05:34:06 +08:00
|
|
|
deps.Rustlibs = android.LastUniqueStrings(deps.Rustlibs)
|
2019-08-28 03:03:00 +08:00
|
|
|
deps.ProcMacros = android.LastUniqueStrings(deps.ProcMacros)
|
|
|
|
deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
|
|
|
|
deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
|
|
|
|
|
|
|
|
return deps
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
type dependencyTag struct {
|
|
|
|
blueprint.BaseDependencyTag
|
|
|
|
name string
|
|
|
|
library bool
|
|
|
|
proc_macro bool
|
|
|
|
}
|
|
|
|
|
|
|
|
var (
|
2019-10-25 11:47:54 +08:00
|
|
|
rlibDepTag = dependencyTag{name: "rlibTag", library: true}
|
|
|
|
dylibDepTag = dependencyTag{name: "dylib", library: true}
|
|
|
|
procMacroDepTag = dependencyTag{name: "procMacro", proc_macro: true}
|
|
|
|
testPerSrcDepTag = dependencyTag{name: "rust_unit_tests"}
|
2019-08-28 03:03:00 +08:00
|
|
|
)
|
|
|
|
|
2020-06-30 05:34:06 +08:00
|
|
|
type autoDep struct {
|
|
|
|
variation string
|
|
|
|
depTag dependencyTag
|
|
|
|
}
|
|
|
|
|
|
|
|
var (
|
|
|
|
rlibAutoDep = autoDep{variation: "rlib", depTag: rlibDepTag}
|
|
|
|
dylibAutoDep = autoDep{variation: "dylib", depTag: dylibDepTag}
|
|
|
|
)
|
|
|
|
|
|
|
|
type autoDeppable interface {
|
|
|
|
autoDep() autoDep
|
|
|
|
}
|
|
|
|
|
2020-04-09 21:56:02 +08:00
|
|
|
func (mod *Module) begin(ctx BaseModuleContext) {
|
|
|
|
if mod.coverage != nil {
|
|
|
|
mod.coverage.begin(ctx)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-08-28 03:03:00 +08:00
|
|
|
func (mod *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
|
|
|
|
var depPaths PathDeps
|
|
|
|
|
|
|
|
directRlibDeps := []*Module{}
|
|
|
|
directDylibDeps := []*Module{}
|
|
|
|
directProcMacroDeps := []*Module{}
|
2019-10-19 05:49:46 +08:00
|
|
|
directSharedLibDeps := [](cc.LinkableInterface){}
|
|
|
|
directStaticLibDeps := [](cc.LinkableInterface){}
|
2020-07-23 04:09:13 +08:00
|
|
|
directSrcProvidersDeps := []*Module{}
|
|
|
|
directSrcDeps := [](android.SourceFileProducer){}
|
2019-08-28 03:03:00 +08:00
|
|
|
|
|
|
|
ctx.VisitDirectDeps(func(dep android.Module) {
|
|
|
|
depName := ctx.OtherModuleName(dep)
|
|
|
|
depTag := ctx.OtherModuleDependencyTag(dep)
|
2020-07-31 23:01:18 +08:00
|
|
|
if rustDep, ok := dep.(*Module); ok && !rustDep.CcLibraryInterface() {
|
2019-08-28 03:03:00 +08:00
|
|
|
//Handle Rust Modules
|
2019-09-14 05:23:15 +08:00
|
|
|
|
2019-08-28 03:03:00 +08:00
|
|
|
switch depTag {
|
|
|
|
case dylibDepTag:
|
|
|
|
dylib, ok := rustDep.compiler.(libraryInterface)
|
|
|
|
if !ok || !dylib.dylib() {
|
|
|
|
ctx.ModuleErrorf("mod %q not an dylib library", depName)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
directDylibDeps = append(directDylibDeps, rustDep)
|
|
|
|
mod.Properties.AndroidMkDylibs = append(mod.Properties.AndroidMkDylibs, depName)
|
|
|
|
case rlibDepTag:
|
|
|
|
rlib, ok := rustDep.compiler.(libraryInterface)
|
|
|
|
if !ok || !rlib.rlib() {
|
|
|
|
ctx.ModuleErrorf("mod %q not an rlib library", depName)
|
|
|
|
return
|
|
|
|
}
|
2020-04-09 21:56:02 +08:00
|
|
|
depPaths.coverageFiles = append(depPaths.coverageFiles, rustDep.CoverageFiles()...)
|
2019-08-28 03:03:00 +08:00
|
|
|
directRlibDeps = append(directRlibDeps, rustDep)
|
|
|
|
mod.Properties.AndroidMkRlibs = append(mod.Properties.AndroidMkRlibs, depName)
|
|
|
|
case procMacroDepTag:
|
|
|
|
directProcMacroDeps = append(directProcMacroDeps, rustDep)
|
|
|
|
mod.Properties.AndroidMkProcMacroLibs = append(mod.Properties.AndroidMkProcMacroLibs, depName)
|
2020-07-23 04:09:13 +08:00
|
|
|
case android.SourceDepTag:
|
|
|
|
// Since these deps are added in path_properties.go via AddDependencies, we need to ensure the correct
|
|
|
|
// OS/Arch variant is used.
|
|
|
|
var helper string
|
|
|
|
if ctx.Host() {
|
|
|
|
helper = "missing 'host_supported'?"
|
|
|
|
} else {
|
|
|
|
helper = "device module defined?"
|
|
|
|
}
|
|
|
|
|
|
|
|
if dep.Target().Os != ctx.Os() {
|
|
|
|
ctx.ModuleErrorf("OS mismatch on dependency %q (%s)", dep.Name(), helper)
|
|
|
|
return
|
|
|
|
} else if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
|
|
|
|
ctx.ModuleErrorf("Arch mismatch on dependency %q (%s)", dep.Name(), helper)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
directSrcProvidersDeps = append(directSrcProvidersDeps, rustDep)
|
2019-08-28 03:03:00 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
//Append the dependencies exportedDirs
|
2020-06-26 00:34:12 +08:00
|
|
|
if lib, ok := rustDep.compiler.(exportedFlagsProducer); ok {
|
|
|
|
depPaths.linkDirs = append(depPaths.linkDirs, lib.exportedLinkDirs()...)
|
2019-08-28 03:03:00 +08:00
|
|
|
depPaths.depFlags = append(depPaths.depFlags, lib.exportedDepFlags()...)
|
|
|
|
}
|
|
|
|
|
|
|
|
if depTag == dylibDepTag || depTag == rlibDepTag || depTag == procMacroDepTag {
|
2020-08-01 01:40:31 +08:00
|
|
|
linkFile := rustDep.outputFile
|
|
|
|
if !linkFile.Valid() {
|
|
|
|
ctx.ModuleErrorf("Invalid output file when adding dep %q to %q",
|
|
|
|
depName, ctx.ModuleName())
|
|
|
|
return
|
|
|
|
}
|
2019-08-28 03:03:00 +08:00
|
|
|
linkDir := linkPathFromFilePath(linkFile.Path())
|
2020-06-26 00:34:12 +08:00
|
|
|
if lib, ok := mod.compiler.(exportedFlagsProducer); ok {
|
|
|
|
lib.exportLinkDirs(linkDir)
|
2019-08-28 03:03:00 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-07-31 23:01:18 +08:00
|
|
|
} else if ccDep, ok := dep.(cc.LinkableInterface); ok {
|
2019-10-19 05:49:46 +08:00
|
|
|
//Handle C dependencies
|
|
|
|
if _, ok := ccDep.(*Module); !ok {
|
|
|
|
if ccDep.Module().Target().Os != ctx.Os() {
|
|
|
|
ctx.ModuleErrorf("OS mismatch between %q and %q", ctx.ModuleName(), depName)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if ccDep.Module().Target().Arch.ArchType != ctx.Arch().ArchType {
|
|
|
|
ctx.ModuleErrorf("Arch mismatch between %q and %q", ctx.ModuleName(), depName)
|
|
|
|
return
|
|
|
|
}
|
2019-09-14 05:23:15 +08:00
|
|
|
}
|
2019-08-28 03:03:00 +08:00
|
|
|
linkFile := ccDep.OutputFile()
|
|
|
|
linkPath := linkPathFromFilePath(linkFile.Path())
|
|
|
|
libName := libNameFromFilePath(linkFile.Path())
|
2020-02-07 02:22:43 +08:00
|
|
|
depFlag := "-l" + libName
|
|
|
|
|
2019-08-28 03:03:00 +08:00
|
|
|
if !linkFile.Valid() {
|
|
|
|
ctx.ModuleErrorf("Invalid output file when adding dep %q to %q", depName, ctx.ModuleName())
|
|
|
|
}
|
|
|
|
|
|
|
|
exportDep := false
|
|
|
|
switch depTag {
|
2019-10-19 05:18:45 +08:00
|
|
|
case cc.StaticDepTag:
|
2020-02-07 02:22:43 +08:00
|
|
|
depFlag = "-lstatic=" + libName
|
2019-08-28 03:03:00 +08:00
|
|
|
depPaths.linkDirs = append(depPaths.linkDirs, linkPath)
|
2020-02-07 02:22:43 +08:00
|
|
|
depPaths.depFlags = append(depPaths.depFlags, depFlag)
|
2020-07-25 04:05:01 +08:00
|
|
|
depPaths.depIncludePaths = append(depPaths.depIncludePaths, ccDep.IncludeDirs()...)
|
|
|
|
if mod, ok := ccDep.(*cc.Module); ok {
|
|
|
|
depPaths.depSystemIncludePaths = append(depPaths.depSystemIncludePaths, mod.ExportedSystemIncludeDirs()...)
|
|
|
|
depPaths.depClangFlags = append(depPaths.depClangFlags, mod.ExportedFlags()...)
|
|
|
|
}
|
2020-04-09 21:56:02 +08:00
|
|
|
depPaths.coverageFiles = append(depPaths.coverageFiles, ccDep.CoverageFiles()...)
|
2019-08-28 03:03:00 +08:00
|
|
|
directStaticLibDeps = append(directStaticLibDeps, ccDep)
|
|
|
|
mod.Properties.AndroidMkStaticLibs = append(mod.Properties.AndroidMkStaticLibs, depName)
|
2019-10-19 05:18:45 +08:00
|
|
|
case cc.SharedDepTag:
|
2020-02-07 02:22:43 +08:00
|
|
|
depFlag = "-ldylib=" + libName
|
2019-08-28 03:03:00 +08:00
|
|
|
depPaths.linkDirs = append(depPaths.linkDirs, linkPath)
|
2020-02-07 02:22:43 +08:00
|
|
|
depPaths.depFlags = append(depPaths.depFlags, depFlag)
|
2020-07-25 04:05:01 +08:00
|
|
|
depPaths.depIncludePaths = append(depPaths.depIncludePaths, ccDep.IncludeDirs()...)
|
|
|
|
if mod, ok := ccDep.(*cc.Module); ok {
|
|
|
|
depPaths.depSystemIncludePaths = append(depPaths.depSystemIncludePaths, mod.ExportedSystemIncludeDirs()...)
|
|
|
|
depPaths.depClangFlags = append(depPaths.depClangFlags, mod.ExportedFlags()...)
|
|
|
|
}
|
2019-08-28 03:03:00 +08:00
|
|
|
directSharedLibDeps = append(directSharedLibDeps, ccDep)
|
|
|
|
mod.Properties.AndroidMkSharedLibs = append(mod.Properties.AndroidMkSharedLibs, depName)
|
|
|
|
exportDep = true
|
2019-10-19 05:18:45 +08:00
|
|
|
case cc.CrtBeginDepTag:
|
2019-09-21 02:00:37 +08:00
|
|
|
depPaths.CrtBegin = linkFile
|
2019-10-19 05:18:45 +08:00
|
|
|
case cc.CrtEndDepTag:
|
2019-09-21 02:00:37 +08:00
|
|
|
depPaths.CrtEnd = linkFile
|
2019-08-28 03:03:00 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Make sure these dependencies are propagated
|
2020-06-26 00:34:12 +08:00
|
|
|
if lib, ok := mod.compiler.(exportedFlagsProducer); ok && exportDep {
|
|
|
|
lib.exportLinkDirs(linkPath)
|
|
|
|
lib.exportDepFlags(depFlag)
|
2019-08-28 03:03:00 +08:00
|
|
|
}
|
|
|
|
}
|
2020-07-31 23:01:18 +08:00
|
|
|
|
|
|
|
if srcDep, ok := dep.(android.SourceFileProducer); ok {
|
|
|
|
switch depTag {
|
|
|
|
case android.SourceDepTag:
|
|
|
|
// These are usually genrules which don't have per-target variants.
|
|
|
|
directSrcDeps = append(directSrcDeps, srcDep)
|
|
|
|
}
|
|
|
|
}
|
2019-08-28 03:03:00 +08:00
|
|
|
})
|
|
|
|
|
|
|
|
var rlibDepFiles RustLibraries
|
|
|
|
for _, dep := range directRlibDeps {
|
|
|
|
rlibDepFiles = append(rlibDepFiles, RustLibrary{Path: dep.outputFile.Path(), CrateName: dep.CrateName()})
|
|
|
|
}
|
|
|
|
var dylibDepFiles RustLibraries
|
|
|
|
for _, dep := range directDylibDeps {
|
|
|
|
dylibDepFiles = append(dylibDepFiles, RustLibrary{Path: dep.outputFile.Path(), CrateName: dep.CrateName()})
|
|
|
|
}
|
|
|
|
var procMacroDepFiles RustLibraries
|
|
|
|
for _, dep := range directProcMacroDeps {
|
|
|
|
procMacroDepFiles = append(procMacroDepFiles, RustLibrary{Path: dep.outputFile.Path(), CrateName: dep.CrateName()})
|
|
|
|
}
|
|
|
|
|
|
|
|
var staticLibDepFiles android.Paths
|
|
|
|
for _, dep := range directStaticLibDeps {
|
|
|
|
staticLibDepFiles = append(staticLibDepFiles, dep.OutputFile().Path())
|
|
|
|
}
|
|
|
|
|
|
|
|
var sharedLibDepFiles android.Paths
|
|
|
|
for _, dep := range directSharedLibDeps {
|
|
|
|
sharedLibDepFiles = append(sharedLibDepFiles, dep.OutputFile().Path())
|
|
|
|
}
|
|
|
|
|
2020-07-23 04:09:13 +08:00
|
|
|
var srcProviderDepFiles android.Paths
|
|
|
|
for _, dep := range directSrcProvidersDeps {
|
|
|
|
srcs, _ := dep.OutputFiles("")
|
|
|
|
srcProviderDepFiles = append(srcProviderDepFiles, srcs...)
|
|
|
|
}
|
|
|
|
for _, dep := range directSrcDeps {
|
|
|
|
srcs := dep.Srcs()
|
|
|
|
srcProviderDepFiles = append(srcProviderDepFiles, srcs...)
|
|
|
|
}
|
|
|
|
|
2019-08-28 03:03:00 +08:00
|
|
|
depPaths.RLibs = append(depPaths.RLibs, rlibDepFiles...)
|
|
|
|
depPaths.DyLibs = append(depPaths.DyLibs, dylibDepFiles...)
|
|
|
|
depPaths.SharedLibs = append(depPaths.SharedLibs, sharedLibDepFiles...)
|
|
|
|
depPaths.StaticLibs = append(depPaths.StaticLibs, staticLibDepFiles...)
|
|
|
|
depPaths.ProcMacros = append(depPaths.ProcMacros, procMacroDepFiles...)
|
2020-07-23 04:09:13 +08:00
|
|
|
depPaths.SrcDeps = append(depPaths.SrcDeps, srcProviderDepFiles...)
|
2019-08-28 03:03:00 +08:00
|
|
|
|
|
|
|
// Dedup exported flags from dependencies
|
|
|
|
depPaths.linkDirs = android.FirstUniqueStrings(depPaths.linkDirs)
|
|
|
|
depPaths.depFlags = android.FirstUniqueStrings(depPaths.depFlags)
|
2020-07-25 04:05:01 +08:00
|
|
|
depPaths.depClangFlags = android.FirstUniqueStrings(depPaths.depClangFlags)
|
|
|
|
depPaths.depIncludePaths = android.FirstUniquePaths(depPaths.depIncludePaths)
|
|
|
|
depPaths.depSystemIncludePaths = android.FirstUniquePaths(depPaths.depSystemIncludePaths)
|
2019-08-28 03:03:00 +08:00
|
|
|
|
|
|
|
return depPaths
|
|
|
|
}
|
|
|
|
|
2019-12-13 11:36:05 +08:00
|
|
|
func (mod *Module) InstallInData() bool {
|
|
|
|
if mod.compiler == nil {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
return mod.compiler.inData()
|
|
|
|
}
|
|
|
|
|
2019-08-28 03:03:00 +08:00
|
|
|
func linkPathFromFilePath(filepath android.Path) string {
|
|
|
|
return strings.Split(filepath.String(), filepath.Base())[0]
|
|
|
|
}
|
2020-02-07 01:05:10 +08:00
|
|
|
|
2019-08-28 03:03:00 +08:00
|
|
|
func libNameFromFilePath(filepath android.Path) string {
|
2020-02-07 01:05:10 +08:00
|
|
|
libName := strings.TrimSuffix(filepath.Base(), filepath.Ext())
|
2019-10-19 05:49:46 +08:00
|
|
|
if strings.HasPrefix(libName, "lib") {
|
|
|
|
libName = libName[3:]
|
2019-08-28 03:03:00 +08:00
|
|
|
}
|
|
|
|
return libName
|
|
|
|
}
|
2020-02-07 01:05:10 +08:00
|
|
|
|
2019-08-28 03:03:00 +08:00
|
|
|
func (mod *Module) DepsMutator(actx android.BottomUpMutatorContext) {
|
|
|
|
ctx := &depsContext{
|
|
|
|
BottomUpMutatorContext: actx,
|
|
|
|
}
|
|
|
|
|
|
|
|
deps := mod.deps(ctx)
|
2019-10-19 05:49:46 +08:00
|
|
|
commonDepVariations := []blueprint.Variation{}
|
2020-04-10 11:57:24 +08:00
|
|
|
if cc.VersionVariantAvailable(mod) {
|
|
|
|
commonDepVariations = append(commonDepVariations,
|
|
|
|
blueprint.Variation{Mutator: "version", Variation: ""})
|
|
|
|
}
|
2019-08-28 03:03:00 +08:00
|
|
|
if !mod.Host() {
|
2019-10-19 05:49:46 +08:00
|
|
|
commonDepVariations = append(commonDepVariations,
|
2019-11-19 08:00:16 +08:00
|
|
|
blueprint.Variation{Mutator: "image", Variation: android.CoreVariation})
|
2019-08-28 03:03:00 +08:00
|
|
|
}
|
2019-10-19 05:49:46 +08:00
|
|
|
actx.AddVariationDependencies(
|
|
|
|
append(commonDepVariations, []blueprint.Variation{
|
2020-07-31 23:01:18 +08:00
|
|
|
{Mutator: "rust_libraries", Variation: "rlib"}}...),
|
2019-10-19 05:49:46 +08:00
|
|
|
rlibDepTag, deps.Rlibs...)
|
|
|
|
actx.AddVariationDependencies(
|
|
|
|
append(commonDepVariations, []blueprint.Variation{
|
2020-07-31 23:01:18 +08:00
|
|
|
{Mutator: "rust_libraries", Variation: "dylib"}}...),
|
2019-10-19 05:49:46 +08:00
|
|
|
dylibDepTag, deps.Dylibs...)
|
|
|
|
|
2020-06-30 05:34:06 +08:00
|
|
|
if deps.Rustlibs != nil {
|
|
|
|
autoDep := mod.compiler.(autoDeppable).autoDep()
|
|
|
|
actx.AddVariationDependencies(
|
|
|
|
append(commonDepVariations, []blueprint.Variation{
|
2020-07-31 23:01:18 +08:00
|
|
|
{Mutator: "rust_libraries", Variation: autoDep.variation}}...),
|
2020-06-30 05:34:06 +08:00
|
|
|
autoDep.depTag, deps.Rustlibs...)
|
|
|
|
}
|
|
|
|
|
2019-10-19 05:49:46 +08:00
|
|
|
actx.AddVariationDependencies(append(commonDepVariations,
|
|
|
|
blueprint.Variation{Mutator: "link", Variation: "shared"}),
|
|
|
|
cc.SharedDepTag, deps.SharedLibs...)
|
|
|
|
actx.AddVariationDependencies(append(commonDepVariations,
|
|
|
|
blueprint.Variation{Mutator: "link", Variation: "static"}),
|
|
|
|
cc.StaticDepTag, deps.StaticLibs...)
|
2019-09-24 01:10:40 +08:00
|
|
|
|
2019-09-21 02:00:37 +08:00
|
|
|
if deps.CrtBegin != "" {
|
2019-10-19 05:49:46 +08:00
|
|
|
actx.AddVariationDependencies(commonDepVariations, cc.CrtBeginDepTag, deps.CrtBegin)
|
2019-09-21 02:00:37 +08:00
|
|
|
}
|
|
|
|
if deps.CrtEnd != "" {
|
2019-10-19 05:49:46 +08:00
|
|
|
actx.AddVariationDependencies(commonDepVariations, cc.CrtEndDepTag, deps.CrtEnd)
|
2019-09-21 02:00:37 +08:00
|
|
|
}
|
|
|
|
|
2019-09-24 01:10:40 +08:00
|
|
|
// proc_macros are compiler plugins, and so we need the host arch variant as a dependendcy.
|
2019-10-17 02:03:10 +08:00
|
|
|
actx.AddFarVariationDependencies(ctx.Config().BuildOSTarget.Variations(), procMacroDepTag, deps.ProcMacros...)
|
2019-08-28 03:03:00 +08:00
|
|
|
}
|
|
|
|
|
2020-04-09 21:56:02 +08:00
|
|
|
func BeginMutator(ctx android.BottomUpMutatorContext) {
|
|
|
|
if mod, ok := ctx.Module().(*Module); ok && mod.Enabled() {
|
|
|
|
mod.beginMutator(ctx)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (mod *Module) beginMutator(actx android.BottomUpMutatorContext) {
|
|
|
|
ctx := &baseModuleContext{
|
|
|
|
BaseModuleContext: actx,
|
|
|
|
}
|
|
|
|
|
|
|
|
mod.begin(ctx)
|
|
|
|
}
|
|
|
|
|
2019-08-28 03:03:00 +08:00
|
|
|
func (mod *Module) Name() string {
|
|
|
|
name := mod.ModuleBase.Name()
|
|
|
|
if p, ok := mod.compiler.(interface {
|
|
|
|
Name(string) string
|
|
|
|
}); ok {
|
|
|
|
name = p.Name(name)
|
|
|
|
}
|
|
|
|
return name
|
|
|
|
}
|
|
|
|
|
2020-05-16 08:36:30 +08:00
|
|
|
var _ android.HostToolProvider = (*Module)(nil)
|
|
|
|
|
|
|
|
func (mod *Module) HostToolPath() android.OptionalPath {
|
|
|
|
if !mod.Host() {
|
|
|
|
return android.OptionalPath{}
|
|
|
|
}
|
|
|
|
if _, ok := mod.compiler.(*binaryDecorator); ok {
|
|
|
|
return mod.outputFile
|
|
|
|
}
|
|
|
|
return android.OptionalPath{}
|
|
|
|
}
|
|
|
|
|
2019-08-28 03:03:00 +08:00
|
|
|
var Bool = proptools.Bool
|
|
|
|
var BoolDefault = proptools.BoolDefault
|
|
|
|
var String = proptools.String
|
|
|
|
var StringPtr = proptools.StringPtr
|
2020-07-10 09:03:28 +08:00
|
|
|
|
|
|
|
var _ android.OutputFileProducer = (*Module)(nil)
|