1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072 |
- // 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 (
- "fmt"
- "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().
- NotIn(config.RustAllowedPaths...).
- ModuleType(config.RustModuleTypes...))
- android.RegisterModuleType("rust_defaults", defaultsFactory)
- android.PreDepsMutators(func(ctx android.RegisterMutatorsContext) {
- ctx.BottomUp("rust_libraries", LibraryMutator).Parallel()
- ctx.BottomUp("rust_begin", BeginMutator).Parallel()
- })
- pctx.Import("android/soong/rust/config")
- pctx.ImportAs("ccConfig", "android/soong/cc/config")
- }
- type Flags struct {
- 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
- ClippyFlags []string // Flags that apply to clippy-driver, during the linting
- Toolchain config.Toolchain
- Coverage bool
- Clippy bool
- }
- type BaseProperties struct {
- AndroidMkRlibs []string
- AndroidMkDylibs []string
- AndroidMkProcMacroLibs []string
- AndroidMkSharedLibs []string
- AndroidMkStaticLibs []string
- SubName string `blueprint:"mutated"`
- PreventInstall bool
- HideFromMake bool
- }
- type Module struct {
- android.ModuleBase
- android.DefaultableModuleBase
- Properties BaseProperties
- hod android.HostOrDeviceSupported
- multilib android.Multilib
- compiler compiler
- coverage *coverage
- clippy *clippy
- cachedToolchain config.Toolchain
- sourceProvider SourceProvider
- subAndroidMkOnce map[SubAndroidMkProvider]bool
- outputFile android.OptionalPath
- generatedFile android.OptionalPath
- }
- func (mod *Module) OutputFiles(tag string) (android.Paths, error) {
- switch tag {
- case "":
- if mod.sourceProvider != nil && (mod.compiler == nil || mod.compiler.Disabled()) {
- 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)
- }
- }
- var _ android.ImageInterface = (*Module)(nil)
- func (mod *Module) ImageMutatorBegin(ctx android.BaseModuleContext) {}
- func (mod *Module) CoreVariantNeeded(ctx android.BaseModuleContext) bool {
- return true
- }
- func (mod *Module) RamdiskVariantNeeded(android.BaseModuleContext) bool {
- return mod.InRamdisk()
- }
- 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) {
- }
- func (mod *Module) BuildStubs() bool {
- return false
- }
- func (mod *Module) HasStubsVariants() bool {
- return false
- }
- func (mod *Module) SelectedStl() string {
- return ""
- }
- func (mod *Module) NonCcVariants() bool {
- if mod.compiler != nil {
- if _, ok := mod.compiler.(libraryInterface); ok {
- return false
- }
- }
- panic(fmt.Errorf("NonCcVariants called on non-library module: %q", mod.BaseModuleName()))
- }
- 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()
- }
- }
- return false
- }
- func (mod *Module) Shared() bool {
- if mod.compiler != nil {
- if library, ok := mod.compiler.(libraryInterface); ok {
- return library.shared()
- }
- }
- return false
- }
- 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()))
- }
- func (mod *Module) OnlyInRamdisk() bool {
- return false
- }
- func (mod *Module) OnlyInRecovery() bool {
- return false
- }
- func (mod *Module) UseSdk() bool {
- return false
- }
- 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 ""
- }
- func (mod *Module) AlwaysSdk() bool {
- return false
- }
- func (mod *Module) IsSdkVariant() bool {
- return false
- }
- func (mod *Module) ToolchainLibrary() bool {
- return false
- }
- func (mod *Module) NdkPrebuiltStl() bool {
- return false
- }
- func (mod *Module) StubDecorator() bool {
- return false
- }
- type Deps struct {
- Dylibs []string
- Rlibs []string
- Rustlibs []string
- 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
- // Used by bindgen modules which call clang
- depClangFlags []string
- depIncludePaths android.Paths
- depSystemIncludePaths android.Paths
- coverageFiles android.Paths
- CrtBegin android.OptionalPath
- CrtEnd android.OptionalPath
- // Paths to generated source files
- SrcDeps android.Paths
- }
- 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
- inData() bool
- install(ctx ModuleContext, path android.Path)
- relativeInstallPath() string
- nativeCoverage() bool
- Disabled() bool
- SetDisabled()
- }
- 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{},
- }
- }
- 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
- }
- 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{},
- &SourceProviderProperties{},
- &TestProperties{},
- &cc.CoverageProperties{},
- &ClippyProperties{},
- )
- android.InitDefaultsModule(module)
- return module
- }
- func (mod *Module) CrateName() string {
- return mod.compiler.crateName()
- }
- 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 {
- // 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()) {
- return true
- }
- }
- return false
- }
- func (mod *Module) IncludeDirs() android.Paths {
- if mod.compiler != nil {
- if library, ok := mod.compiler.(*libraryDecorator); ok {
- return library.includeDirs
- }
- }
- panic(fmt.Errorf("IncludeDirs called on non-library module: %q", mod.BaseModuleName()))
- }
- func (mod *Module) SetStatic() {
- if mod.compiler != nil {
- if library, ok := mod.compiler.(libraryInterface); ok {
- library.setStatic()
- return
- }
- }
- panic(fmt.Errorf("SetStatic called on non-library module: %q", mod.BaseModuleName()))
- }
- func (mod *Module) SetShared() {
- if mod.compiler != nil {
- if library, ok := mod.compiler.(libraryInterface); ok {
- library.setShared()
- 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")
- }
- func (mod *Module) StubsVersion() string {
- panic("SetStubsVersions not yet implemented for rust modules")
- }
- func (mod *Module) BuildStaticVariant() bool {
- if mod.compiler != nil {
- if library, ok := mod.compiler.(libraryInterface); ok {
- return library.buildStatic()
- }
- }
- panic(fmt.Errorf("BuildStaticVariant called on non-library module: %q", mod.BaseModuleName()))
- }
- func (mod *Module) BuildSharedVariant() bool {
- if mod.compiler != nil {
- if library, ok := mod.compiler.(libraryInterface); ok {
- return library.buildShared()
- }
- }
- 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 {
- if _, ok := mod.compiler.(libraryInterface); ok {
- 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
- }
- func (mod *Module) CoverageFiles() android.Paths {
- if mod.compiler != nil {
- if !mod.compiler.nativeCoverage() {
- return android.Paths{}
- }
- 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()))
- }
- var _ cc.LinkableInterface = (*Module)(nil)
- func (mod *Module) Init() android.Module {
- mod.AddProperties(&mod.Properties)
- if mod.compiler != nil {
- mod.AddProperties(mod.compiler.compilerProps()...)
- }
- if mod.coverage != nil {
- mod.AddProperties(mod.coverage.props()...)
- }
- if mod.clippy != nil {
- mod.AddProperties(mod.clippy.props()...)
- }
- if mod.sourceProvider != nil {
- mod.AddProperties(mod.sourceProvider.SourceProviderProps()...)
- }
- android.InitAndroidArchModule(mod, mod.hod, mod.multilib)
- android.InitDefaultableModule(mod)
- // 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)
- })
- 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)
- module.coverage = &coverage{}
- module.clippy = &clippy{}
- return module
- }
- type ModuleContext interface {
- android.ModuleContext
- ModuleContextIntf
- }
- type BaseModuleContext interface {
- android.BaseModuleContext
- ModuleContextIntf
- }
- type DepsContext interface {
- android.BottomUpMutatorContext
- ModuleContextIntf
- }
- type ModuleContextIntf interface {
- RustModule() *Module
- toolchain() config.Toolchain
- }
- type depsContext struct {
- android.BottomUpMutatorContext
- }
- type moduleContext struct {
- android.ModuleContext
- }
- type baseModuleContext struct {
- android.BaseModuleContext
- }
- 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)
- }
- func (ctx *depsContext) toolchain() config.Toolchain {
- return ctx.RustModule().toolchain(ctx)
- }
- 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()
- }
- 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)
- }
- if mod.coverage != nil {
- flags, deps = mod.coverage.flags(ctx, flags, deps)
- }
- if mod.clippy != nil {
- flags, deps = mod.clippy.flags(ctx, flags, deps)
- }
- // 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() {
- outputFile := mod.compiler.compile(ctx, flags, deps)
- mod.outputFile = android.OptionalPathForPath(outputFile)
- if mod.outputFile.Valid() && !mod.Properties.PreventInstall {
- mod.compiler.install(ctx, mod.outputFile.Path())
- }
- }
- }
- func (mod *Module) deps(ctx DepsContext) Deps {
- deps := Deps{}
- if mod.compiler != nil {
- deps = mod.compiler.compilerDeps(ctx, deps)
- }
- if mod.sourceProvider != nil {
- deps = mod.sourceProvider.SourceProviderDeps(ctx, deps)
- }
- if mod.coverage != nil {
- deps = mod.coverage.deps(ctx, deps)
- }
- deps.Rlibs = android.LastUniqueStrings(deps.Rlibs)
- deps.Dylibs = android.LastUniqueStrings(deps.Dylibs)
- deps.Rustlibs = android.LastUniqueStrings(deps.Rustlibs)
- 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 (
- customBindgenDepTag = dependencyTag{name: "customBindgenTag"}
- 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"}
- )
- 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
- }
- func (mod *Module) begin(ctx BaseModuleContext) {
- if mod.coverage != nil {
- mod.coverage.begin(ctx)
- }
- }
- func (mod *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
- var depPaths PathDeps
- directRlibDeps := []*Module{}
- directDylibDeps := []*Module{}
- directProcMacroDeps := []*Module{}
- directSharedLibDeps := [](cc.LinkableInterface){}
- directStaticLibDeps := [](cc.LinkableInterface){}
- directSrcProvidersDeps := []*Module{}
- directSrcDeps := [](android.SourceFileProducer){}
- ctx.VisitDirectDeps(func(dep android.Module) {
- depName := ctx.OtherModuleName(dep)
- depTag := ctx.OtherModuleDependencyTag(dep)
- if rustDep, ok := dep.(*Module); ok && !rustDep.CcLibraryInterface() {
- //Handle Rust Modules
- 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
- }
- depPaths.coverageFiles = append(depPaths.coverageFiles, rustDep.CoverageFiles()...)
- 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)
- 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)
- }
- //Append the dependencies exportedDirs, except for proc-macros which target a different arch/OS
- if lib, ok := rustDep.compiler.(exportedFlagsProducer); ok && depTag != procMacroDepTag {
- depPaths.linkDirs = append(depPaths.linkDirs, lib.exportedLinkDirs()...)
- depPaths.depFlags = append(depPaths.depFlags, lib.exportedDepFlags()...)
- }
- if depTag == dylibDepTag || depTag == rlibDepTag || depTag == procMacroDepTag {
- linkFile := rustDep.outputFile
- if !linkFile.Valid() {
- ctx.ModuleErrorf("Invalid output file when adding dep %q to %q",
- depName, ctx.ModuleName())
- return
- }
- linkDir := linkPathFromFilePath(linkFile.Path())
- if lib, ok := mod.compiler.(exportedFlagsProducer); ok {
- lib.exportLinkDirs(linkDir)
- }
- }
- } else if ccDep, ok := dep.(cc.LinkableInterface); ok {
- //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
- }
- }
- linkFile := ccDep.OutputFile()
- linkPath := linkPathFromFilePath(linkFile.Path())
- libName := libNameFromFilePath(linkFile.Path())
- depFlag := "-l" + libName
- if !linkFile.Valid() {
- ctx.ModuleErrorf("Invalid output file when adding dep %q to %q", depName, ctx.ModuleName())
- }
- exportDep := false
- switch {
- case cc.IsStaticDepTag(depTag):
- depFlag = "-lstatic=" + libName
- depPaths.linkDirs = append(depPaths.linkDirs, linkPath)
- depPaths.depFlags = append(depPaths.depFlags, depFlag)
- 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()...)
- }
- depPaths.coverageFiles = append(depPaths.coverageFiles, ccDep.CoverageFiles()...)
- directStaticLibDeps = append(directStaticLibDeps, ccDep)
- mod.Properties.AndroidMkStaticLibs = append(mod.Properties.AndroidMkStaticLibs, depName)
- case cc.IsSharedDepTag(depTag):
- depFlag = "-ldylib=" + libName
- depPaths.linkDirs = append(depPaths.linkDirs, linkPath)
- depPaths.depFlags = append(depPaths.depFlags, depFlag)
- 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()...)
- }
- directSharedLibDeps = append(directSharedLibDeps, ccDep)
- mod.Properties.AndroidMkSharedLibs = append(mod.Properties.AndroidMkSharedLibs, depName)
- exportDep = true
- case depTag == cc.CrtBeginDepTag:
- depPaths.CrtBegin = linkFile
- case depTag == cc.CrtEndDepTag:
- depPaths.CrtEnd = linkFile
- }
- // Make sure these dependencies are propagated
- if lib, ok := mod.compiler.(exportedFlagsProducer); ok && exportDep {
- lib.exportLinkDirs(linkPath)
- lib.exportDepFlags(depFlag)
- }
- }
- 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)
- }
- }
- })
- 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())
- }
- 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...)
- }
- 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...)
- depPaths.SrcDeps = append(depPaths.SrcDeps, srcProviderDepFiles...)
- // Dedup exported flags from dependencies
- depPaths.linkDirs = android.FirstUniqueStrings(depPaths.linkDirs)
- depPaths.depFlags = android.FirstUniqueStrings(depPaths.depFlags)
- depPaths.depClangFlags = android.FirstUniqueStrings(depPaths.depClangFlags)
- depPaths.depIncludePaths = android.FirstUniquePaths(depPaths.depIncludePaths)
- depPaths.depSystemIncludePaths = android.FirstUniquePaths(depPaths.depSystemIncludePaths)
- return depPaths
- }
- func (mod *Module) InstallInData() bool {
- if mod.compiler == nil {
- return false
- }
- return mod.compiler.inData()
- }
- func linkPathFromFilePath(filepath android.Path) string {
- return strings.Split(filepath.String(), filepath.Base())[0]
- }
- func libNameFromFilePath(filepath android.Path) string {
- libName := strings.TrimSuffix(filepath.Base(), filepath.Ext())
- if strings.HasPrefix(libName, "lib") {
- libName = libName[3:]
- }
- return libName
- }
- func (mod *Module) DepsMutator(actx android.BottomUpMutatorContext) {
- ctx := &depsContext{
- BottomUpMutatorContext: actx,
- }
- deps := mod.deps(ctx)
- commonDepVariations := []blueprint.Variation{}
- if cc.VersionVariantAvailable(mod) {
- commonDepVariations = append(commonDepVariations,
- blueprint.Variation{Mutator: "version", Variation: ""})
- }
- if !mod.Host() {
- commonDepVariations = append(commonDepVariations,
- blueprint.Variation{Mutator: "image", Variation: android.CoreVariation})
- }
- actx.AddVariationDependencies(
- append(commonDepVariations, []blueprint.Variation{
- {Mutator: "rust_libraries", Variation: "rlib"}}...),
- rlibDepTag, deps.Rlibs...)
- actx.AddVariationDependencies(
- append(commonDepVariations, []blueprint.Variation{
- {Mutator: "rust_libraries", Variation: "dylib"}}...),
- dylibDepTag, deps.Dylibs...)
- if deps.Rustlibs != nil {
- autoDep := mod.compiler.(autoDeppable).autoDep()
- actx.AddVariationDependencies(
- append(commonDepVariations, []blueprint.Variation{
- {Mutator: "rust_libraries", Variation: autoDep.variation}}...),
- autoDep.depTag, deps.Rustlibs...)
- }
- 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...)
- crtVariations := append(cc.GetCrtVariations(ctx, mod), commonDepVariations...)
- if deps.CrtBegin != "" {
- actx.AddVariationDependencies(crtVariations, cc.CrtBeginDepTag, deps.CrtBegin)
- }
- if deps.CrtEnd != "" {
- actx.AddVariationDependencies(crtVariations, cc.CrtEndDepTag, deps.CrtEnd)
- }
- if mod.sourceProvider != nil {
- if bindgen, ok := mod.sourceProvider.(*bindgenDecorator); ok &&
- bindgen.Properties.Custom_bindgen != "" {
- actx.AddFarVariationDependencies(ctx.Config().BuildOSTarget.Variations(), customBindgenDepTag,
- bindgen.Properties.Custom_bindgen)
- }
- }
- // proc_macros are compiler plugins, and so we need the host arch variant as a dependendcy.
- actx.AddFarVariationDependencies(ctx.Config().BuildOSTarget.Variations(), procMacroDepTag, deps.ProcMacros...)
- }
- 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)
- }
- 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
- }
- func (mod *Module) disableClippy() {
- if mod.clippy != nil {
- mod.clippy.Properties.Clippy_lints = proptools.StringPtr("none")
- }
- }
- var _ android.HostToolProvider = (*Module)(nil)
- func (mod *Module) HostToolPath() android.OptionalPath {
- if !mod.Host() {
- return android.OptionalPath{}
- }
- if binary, ok := mod.compiler.(*binaryDecorator); ok {
- return android.OptionalPathForPath(binary.baseCompiler.path)
- }
- return android.OptionalPath{}
- }
- var Bool = proptools.Bool
- var BoolDefault = proptools.BoolDefault
- var String = proptools.String
- var StringPtr = proptools.StringPtr
- var _ android.OutputFileProducer = (*Module)(nil)
|