blob: 78a793de94a0d0c49d268e8b39ef673218f6c30a [file] [log] [blame]
Ivan Lozanoffee3342019-08-27 12:03:00 -07001// Copyright 2019 The Android Open Source Project
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15package rust
16
17import (
Ivan Lozano183a3212019-10-18 14:18:45 -070018 "fmt"
Ivan Lozanoffee3342019-08-27 12:03:00 -070019 "strings"
20
21 "github.com/google/blueprint"
22 "github.com/google/blueprint/proptools"
23
24 "android/soong/android"
Thiébaud Weksteene4dd14b2021-04-14 11:18:47 +020025 "android/soong/bloaty"
Ivan Lozanoffee3342019-08-27 12:03:00 -070026 "android/soong/cc"
Thiébaud Weksteen31f1bb82020-08-27 13:37:29 +020027 cc_config "android/soong/cc/config"
Ivan Lozanoffee3342019-08-27 12:03:00 -070028 "android/soong/rust/config"
29)
30
31var pctx = android.NewPackageContext("android/soong/rust")
32
33func init() {
34 // Only allow rust modules to be defined for certain projects
Ivan Lozanoffee3342019-08-27 12:03:00 -070035
36 android.AddNeverAllowRules(
37 android.NeverAllow().
Ivan Lozanoe169ad72019-09-18 08:42:54 -070038 NotIn(config.RustAllowedPaths...).
39 ModuleType(config.RustModuleTypes...))
Ivan Lozanoffee3342019-08-27 12:03:00 -070040
41 android.RegisterModuleType("rust_defaults", defaultsFactory)
42 android.PreDepsMutators(func(ctx android.RegisterMutatorsContext) {
43 ctx.BottomUp("rust_libraries", LibraryMutator).Parallel()
Ivan Lozano2b081132020-09-08 12:46:52 -040044 ctx.BottomUp("rust_stdlinkage", LibstdMutator).Parallel()
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -040045 ctx.BottomUp("rust_begin", BeginMutator).Parallel()
Ivan Lozano6cd99e62020-02-11 08:24:25 -050046
47 })
48 android.PostDepsMutators(func(ctx android.RegisterMutatorsContext) {
49 ctx.BottomUp("rust_sanitizers", rustSanitizerRuntimeMutator).Parallel()
Ivan Lozanoffee3342019-08-27 12:03:00 -070050 })
51 pctx.Import("android/soong/rust/config")
Thiébaud Weksteen682c9d72020-08-31 10:06:16 +020052 pctx.ImportAs("cc_config", "android/soong/cc/config")
Ivan Lozanoffee3342019-08-27 12:03:00 -070053}
54
55type Flags struct {
Ivan Lozano8a23fa42020-06-16 10:26:57 -040056 GlobalRustFlags []string // Flags that apply globally to rust
57 GlobalLinkFlags []string // Flags that apply globally to linker
58 RustFlags []string // Flags that apply to rust
59 LinkFlags []string // Flags that apply to linker
Thiébaud Weksteen92f703b2020-06-22 13:28:02 +020060 ClippyFlags []string // Flags that apply to clippy-driver, during the linting
Dan Albert06feee92021-03-19 15:06:02 -070061 RustdocFlags []string // Flags that apply to rustdoc
Ivan Lozanof1c84332019-09-20 11:00:37 -070062 Toolchain config.Toolchain
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -040063 Coverage bool
Thiébaud Weksteen92f703b2020-06-22 13:28:02 +020064 Clippy bool
Ivan Lozanoffee3342019-08-27 12:03:00 -070065}
66
67type BaseProperties struct {
68 AndroidMkRlibs []string
69 AndroidMkDylibs []string
70 AndroidMkProcMacroLibs []string
71 AndroidMkSharedLibs []string
72 AndroidMkStaticLibs []string
Ivan Lozano43845682020-07-09 21:03:28 -040073
Ivan Lozano6a884432020-12-02 09:15:16 -050074 ImageVariationPrefix string `blueprint:"mutated"`
75 VndkVersion string `blueprint:"mutated"`
76 SubName string `blueprint:"mutated"`
77
Ivan Lozanoc08897c2021-04-02 12:41:32 -040078 // SubName is used by CC for tracking image variants / SDK versions. RustSubName is used for Rust-specific
79 // subnaming which shouldn't be visible to CC modules (such as the rlib stdlinkage subname). This should be
80 // appended before SubName.
81 RustSubName string `blueprint:"mutated"`
82
Ivan Lozano6a884432020-12-02 09:15:16 -050083 // Set by imageMutator
Ivan Lozanoe6d30982021-02-05 10:57:43 -050084 CoreVariantNeeded bool `blueprint:"mutated"`
85 VendorRamdiskVariantNeeded bool `blueprint:"mutated"`
86 ExtraVariants []string `blueprint:"mutated"`
87
88 // Make this module available when building for vendor ramdisk.
89 // On device without a dedicated recovery partition, the module is only
90 // available after switching root into
91 // /first_stage_ramdisk. To expose the module before switching root, install
92 // the recovery variant instead (TODO(b/165791368) recovery not yet supported)
93 Vendor_ramdisk_available *bool
Ivan Lozano26ecd6c2020-07-31 13:40:31 -040094
Ivan Lozano3e9f9e42020-12-04 15:05:43 -050095 // Minimum sdk version that the artifact should support when it runs as part of mainline modules(APEX).
96 Min_sdk_version *string
97
Ivan Lozano43845682020-07-09 21:03:28 -040098 PreventInstall bool
99 HideFromMake bool
Ivan Lozanoffee3342019-08-27 12:03:00 -0700100}
101
102type Module struct {
103 android.ModuleBase
104 android.DefaultableModuleBase
Jiyong Park99644e92020-11-17 22:21:02 +0900105 android.ApexModuleBase
Ivan Lozanoffee3342019-08-27 12:03:00 -0700106
Ivan Lozano6a884432020-12-02 09:15:16 -0500107 VendorProperties cc.VendorProperties
108
Ivan Lozanoffee3342019-08-27 12:03:00 -0700109 Properties BaseProperties
110
111 hod android.HostOrDeviceSupported
112 multilib android.Multilib
113
Ivan Lozano6a884432020-12-02 09:15:16 -0500114 makeLinkType string
115
Ivan Lozanoffee3342019-08-27 12:03:00 -0700116 compiler compiler
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400117 coverage *coverage
Thiébaud Weksteen92f703b2020-06-22 13:28:02 +0200118 clippy *clippy
Ivan Lozano6cd99e62020-02-11 08:24:25 -0500119 sanitize *sanitize
Ivan Lozanoffee3342019-08-27 12:03:00 -0700120 cachedToolchain config.Toolchain
Ivan Lozano4fef93c2020-07-08 08:39:44 -0400121 sourceProvider SourceProvider
Andrei Homescuc7767922020-08-05 06:36:19 -0700122 subAndroidMkOnce map[SubAndroidMkProvider]bool
Ivan Lozano4fef93c2020-07-08 08:39:44 -0400123
Jiyong Parke54f07e2021-04-07 15:08:04 +0900124 // Unstripped output. This is usually used when this module is linked to another module
125 // as a library. The stripped output which is used for installation can be found via
126 // compiler.strippedOutputFile if it exists.
127 unstrippedOutputFile android.OptionalPath
Dan Albert06feee92021-03-19 15:06:02 -0700128 docTimestampFile android.OptionalPath
Jiyong Park99644e92020-11-17 22:21:02 +0900129
130 hideApexVariantFromMake bool
Ivan Lozanoffee3342019-08-27 12:03:00 -0700131}
132
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500133func (mod *Module) Header() bool {
134 //TODO: If Rust libraries provide header variants, this needs to be updated.
135 return false
136}
137
138func (mod *Module) SetPreventInstall() {
139 mod.Properties.PreventInstall = true
140}
141
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500142func (mod *Module) SetHideFromMake() {
143 mod.Properties.HideFromMake = true
144}
145
146func (mod *Module) SanitizePropDefined() bool {
Ivan Lozano6cd99e62020-02-11 08:24:25 -0500147 // Because compiler is not set for some Rust modules where sanitize might be set, check that compiler is also not
148 // nil since we need compiler to actually sanitize.
149 return mod.sanitize != nil && mod.compiler != nil
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500150}
151
152func (mod *Module) IsDependencyRoot() bool {
153 if mod.compiler != nil {
154 return mod.compiler.isDependencyRoot()
155 }
156 panic("IsDependencyRoot called on a non-compiler Rust module")
157}
158
159func (mod *Module) IsPrebuilt() bool {
160 if _, ok := mod.compiler.(*prebuiltLibraryDecorator); ok {
161 return true
162 }
163 return false
164}
165
Ivan Lozano43845682020-07-09 21:03:28 -0400166func (mod *Module) OutputFiles(tag string) (android.Paths, error) {
167 switch tag {
168 case "":
Andrei Homescu5db69cc2020-08-06 15:27:45 -0700169 if mod.sourceProvider != nil && (mod.compiler == nil || mod.compiler.Disabled()) {
Ivan Lozano43845682020-07-09 21:03:28 -0400170 return mod.sourceProvider.Srcs(), nil
171 } else {
Jiyong Parke54f07e2021-04-07 15:08:04 +0900172 if mod.OutputFile().Valid() {
173 return android.Paths{mod.OutputFile().Path()}, nil
Ivan Lozano43845682020-07-09 21:03:28 -0400174 }
175 return android.Paths{}, nil
176 }
177 default:
178 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
179 }
180}
181
Ivan Lozano52767be2019-10-18 14:49:46 -0700182func (mod *Module) SelectedStl() string {
183 return ""
184}
185
Ivan Lozano2b262972019-11-21 12:30:50 -0800186func (mod *Module) NonCcVariants() bool {
187 if mod.compiler != nil {
Ivan Lozano89435d12020-07-31 11:01:18 -0400188 if _, ok := mod.compiler.(libraryInterface); ok {
189 return false
Ivan Lozano2b262972019-11-21 12:30:50 -0800190 }
191 }
192 panic(fmt.Errorf("NonCcVariants called on non-library module: %q", mod.BaseModuleName()))
193}
194
Ivan Lozano52767be2019-10-18 14:49:46 -0700195func (mod *Module) Static() bool {
196 if mod.compiler != nil {
197 if library, ok := mod.compiler.(libraryInterface); ok {
198 return library.static()
199 }
200 }
Ivan Lozano89435d12020-07-31 11:01:18 -0400201 return false
Ivan Lozano52767be2019-10-18 14:49:46 -0700202}
203
204func (mod *Module) Shared() bool {
205 if mod.compiler != nil {
206 if library, ok := mod.compiler.(libraryInterface); ok {
Ivan Lozano89435d12020-07-31 11:01:18 -0400207 return library.shared()
Ivan Lozano52767be2019-10-18 14:49:46 -0700208 }
209 }
Ivan Lozano89435d12020-07-31 11:01:18 -0400210 return false
Ivan Lozano52767be2019-10-18 14:49:46 -0700211}
212
213func (mod *Module) Toc() android.OptionalPath {
214 if mod.compiler != nil {
215 if _, ok := mod.compiler.(libraryInterface); ok {
216 return android.OptionalPath{}
217 }
218 }
219 panic(fmt.Errorf("Toc() called on non-library module: %q", mod.BaseModuleName()))
220}
221
Colin Crossc511bc52020-04-07 16:50:32 +0000222func (mod *Module) UseSdk() bool {
223 return false
224}
225
Ivan Lozano6a884432020-12-02 09:15:16 -0500226// Returns true if the module is using VNDK libraries instead of the libraries in /system/lib or /system/lib64.
227// "product" and "vendor" variant modules return true for this function.
228// When BOARD_VNDK_VERSION is set, vendor variants of "vendor_available: true", "vendor: true",
229// "soc_specific: true" and more vendor installed modules are included here.
230// When PRODUCT_PRODUCT_VNDK_VERSION is set, product variants of "vendor_available: true" or
231// "product_specific: true" modules are included here.
Ivan Lozano52767be2019-10-18 14:49:46 -0700232func (mod *Module) UseVndk() bool {
Ivan Lozano6a884432020-12-02 09:15:16 -0500233 return mod.Properties.VndkVersion != ""
Ivan Lozano52767be2019-10-18 14:49:46 -0700234}
235
236func (mod *Module) MustUseVendorVariant() bool {
Ivan Lozanoc08897c2021-04-02 12:41:32 -0400237 return true
238}
239
240func (mod *Module) SubName() string {
241 return mod.Properties.SubName
Ivan Lozano52767be2019-10-18 14:49:46 -0700242}
243
244func (mod *Module) IsVndk() bool {
Ivan Lozano6a884432020-12-02 09:15:16 -0500245 // TODO(b/165791368)
Ivan Lozano52767be2019-10-18 14:49:46 -0700246 return false
247}
248
Ivan Lozanof9e21722020-12-02 09:00:51 -0500249func (mod *Module) IsVndkExt() bool {
250 return false
251}
252
Colin Cross127bb8b2020-12-16 16:46:01 -0800253func (c *Module) IsVndkPrivate() bool {
254 return false
255}
256
257func (c *Module) IsLlndk() bool {
258 return false
259}
260
261func (c *Module) IsLlndkPublic() bool {
Ivan Lozanof9e21722020-12-02 09:00:51 -0500262 return false
263}
264
Ivan Lozano3a7d0002021-03-30 12:19:36 -0400265func (m *Module) IsLlndkHeaders() bool {
266 return false
267}
268
269func (m *Module) IsLlndkLibrary() bool {
270 return false
271}
272
273func (mod *Module) KernelHeadersDecorator() bool {
274 return false
275}
276
277func (m *Module) HasLlndkStubs() bool {
278 return false
279}
280
Ivan Lozano52767be2019-10-18 14:49:46 -0700281func (mod *Module) SdkVersion() string {
282 return ""
283}
284
Jiyong Parkfdaa5f72021-03-19 22:18:04 +0900285func (mod *Module) MinSdkVersion() string {
286 return ""
287}
288
Colin Crossc511bc52020-04-07 16:50:32 +0000289func (mod *Module) AlwaysSdk() bool {
290 return false
291}
292
Jiyong Park2286afd2020-06-16 21:58:53 +0900293func (mod *Module) IsSdkVariant() bool {
294 return false
295}
296
Colin Cross1348ce32020-10-01 13:37:16 -0700297func (mod *Module) SplitPerApiLevel() bool {
298 return false
299}
300
Ivan Lozanoffee3342019-08-27 12:03:00 -0700301type Deps struct {
Ivan Lozano63bb7682021-03-23 15:53:44 -0400302 Dylibs []string
303 Rlibs []string
304 Rustlibs []string
305 Stdlibs []string
306 ProcMacros []string
307 SharedLibs []string
308 StaticLibs []string
309 WholeStaticLibs []string
310 HeaderLibs []string
Ivan Lozanoffee3342019-08-27 12:03:00 -0700311
312 CrtBegin, CrtEnd string
313}
314
315type PathDeps struct {
Ivan Lozanoec6e9912021-01-21 15:23:29 -0500316 DyLibs RustLibraries
317 RLibs RustLibraries
318 SharedLibs android.Paths
319 SharedLibDeps android.Paths
320 StaticLibs android.Paths
321 ProcMacros RustLibraries
Ivan Lozano3dfa12d2021-02-04 11:29:41 -0500322
323 // depFlags and depLinkFlags are rustc and linker (clang) flags.
324 depFlags []string
325 depLinkFlags []string
326
327 // linkDirs are link paths passed via -L to rustc. linkObjects are objects passed directly to the linker.
328 // Both of these are exported and propagate to dependencies.
329 linkDirs []string
330 linkObjects []string
Ivan Lozanof1c84332019-09-20 11:00:37 -0700331
Ivan Lozano45901ed2020-07-24 16:05:01 -0400332 // Used by bindgen modules which call clang
333 depClangFlags []string
334 depIncludePaths android.Paths
Ivan Lozanoddd0bdb2020-08-28 17:00:26 -0400335 depGeneratedHeaders android.Paths
Ivan Lozano45901ed2020-07-24 16:05:01 -0400336 depSystemIncludePaths android.Paths
337
Ivan Lozanof1c84332019-09-20 11:00:37 -0700338 CrtBegin android.OptionalPath
339 CrtEnd android.OptionalPath
Chih-Hung Hsiehbbd25ae2020-05-15 17:36:30 -0700340
341 // Paths to generated source files
Ivan Lozano9d74a522020-12-01 09:25:22 -0500342 SrcDeps android.Paths
343 srcProviderFiles android.Paths
Ivan Lozanoffee3342019-08-27 12:03:00 -0700344}
345
346type RustLibraries []RustLibrary
347
348type RustLibrary struct {
349 Path android.Path
350 CrateName string
351}
352
353type compiler interface {
Thiébaud Weksteenee6a89b2021-02-25 16:30:57 +0100354 initialize(ctx ModuleContext)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700355 compilerFlags(ctx ModuleContext, flags Flags) Flags
356 compilerProps() []interface{}
357 compile(ctx ModuleContext, flags Flags, deps PathDeps) android.Path
358 compilerDeps(ctx DepsContext, deps Deps) Deps
359 crateName() string
Dan Albert06feee92021-03-19 15:06:02 -0700360 rustdoc(ctx ModuleContext, flags Flags, deps PathDeps) android.OptionalPath
Ivan Lozanoffee3342019-08-27 12:03:00 -0700361
Thiébaud Weksteenee6a89b2021-02-25 16:30:57 +0100362 // Output directory in which source-generated code from dependencies is
363 // copied. This is equivalent to Cargo's OUT_DIR variable.
364 CargoOutDir() android.OptionalPath
Dan Albert06feee92021-03-19 15:06:02 -0700365
Chih-Hung Hsieh9a4a7ba2019-12-12 19:36:05 -0800366 inData() bool
Thiébaud Weksteenfabaff62020-08-27 13:48:36 +0200367 install(ctx ModuleContext)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700368 relativeInstallPath() string
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400369
370 nativeCoverage() bool
Ivan Lozano26ecd6c2020-07-31 13:40:31 -0400371
372 Disabled() bool
373 SetDisabled()
Ivan Lozano042504f2020-08-18 14:31:23 -0400374
Ivan Lozanodd055472020-09-28 13:22:45 -0400375 stdLinkage(ctx *depsContext) RustLinkage
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500376 isDependencyRoot() bool
Jiyong Parke54f07e2021-04-07 15:08:04 +0900377
378 strippedOutputFilePath() android.OptionalPath
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400379}
380
Matthew Maurerbb3add12020-06-25 09:34:12 -0700381type exportedFlagsProducer interface {
Matthew Maurerbb3add12020-06-25 09:34:12 -0700382 exportLinkDirs(...string)
Ivan Lozano2093af22020-08-25 12:48:19 -0400383 exportLinkObjects(...string)
Matthew Maurerbb3add12020-06-25 09:34:12 -0700384}
385
386type flagExporter struct {
Ivan Lozano2093af22020-08-25 12:48:19 -0400387 linkDirs []string
388 linkObjects []string
Matthew Maurerbb3add12020-06-25 09:34:12 -0700389}
390
Matthew Maurerbb3add12020-06-25 09:34:12 -0700391func (flagExporter *flagExporter) exportLinkDirs(dirs ...string) {
392 flagExporter.linkDirs = android.FirstUniqueStrings(append(flagExporter.linkDirs, dirs...))
393}
394
Ivan Lozano2093af22020-08-25 12:48:19 -0400395func (flagExporter *flagExporter) exportLinkObjects(flags ...string) {
396 flagExporter.linkObjects = android.FirstUniqueStrings(append(flagExporter.linkObjects, flags...))
397}
398
Colin Cross0de8a1e2020-09-18 14:15:30 -0700399func (flagExporter *flagExporter) setProvider(ctx ModuleContext) {
400 ctx.SetProvider(FlagExporterInfoProvider, FlagExporterInfo{
Colin Cross0de8a1e2020-09-18 14:15:30 -0700401 LinkDirs: flagExporter.linkDirs,
402 LinkObjects: flagExporter.linkObjects,
403 })
404}
405
Matthew Maurerbb3add12020-06-25 09:34:12 -0700406var _ exportedFlagsProducer = (*flagExporter)(nil)
407
408func NewFlagExporter() *flagExporter {
Colin Cross0de8a1e2020-09-18 14:15:30 -0700409 return &flagExporter{}
Matthew Maurerbb3add12020-06-25 09:34:12 -0700410}
411
Colin Cross0de8a1e2020-09-18 14:15:30 -0700412type FlagExporterInfo struct {
413 Flags []string
414 LinkDirs []string // TODO: this should be android.Paths
415 LinkObjects []string // TODO: this should be android.Paths
416}
417
418var FlagExporterInfoProvider = blueprint.NewProvider(FlagExporterInfo{})
419
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400420func (mod *Module) isCoverageVariant() bool {
421 return mod.coverage.Properties.IsCoverageVariant
422}
423
424var _ cc.Coverage = (*Module)(nil)
425
426func (mod *Module) IsNativeCoverageNeeded(ctx android.BaseModuleContext) bool {
427 return mod.coverage != nil && mod.coverage.Properties.NeedCoverageVariant
428}
429
430func (mod *Module) PreventInstall() {
431 mod.Properties.PreventInstall = true
432}
433
434func (mod *Module) HideFromMake() {
435 mod.Properties.HideFromMake = true
436}
437
438func (mod *Module) MarkAsCoverageVariant(coverage bool) {
439 mod.coverage.Properties.IsCoverageVariant = coverage
440}
441
442func (mod *Module) EnableCoverageIfNeeded() {
443 mod.coverage.Properties.CoverageEnabled = mod.coverage.Properties.NeedCoverageBuild
Ivan Lozanoffee3342019-08-27 12:03:00 -0700444}
445
446func defaultsFactory() android.Module {
447 return DefaultsFactory()
448}
449
450type Defaults struct {
451 android.ModuleBase
452 android.DefaultsModuleBase
453}
454
455func DefaultsFactory(props ...interface{}) android.Module {
456 module := &Defaults{}
457
458 module.AddProperties(props...)
459 module.AddProperties(
460 &BaseProperties{},
Ivan Lozano6a884432020-12-02 09:15:16 -0500461 &cc.VendorProperties{},
Jakub Kotur1d640d02021-01-06 12:40:43 +0100462 &BenchmarkProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -0400463 &BindgenProperties{},
Ivan Lozanoffee3342019-08-27 12:03:00 -0700464 &BaseCompilerProperties{},
465 &BinaryCompilerProperties{},
466 &LibraryCompilerProperties{},
467 &ProcMacroCompilerProperties{},
468 &PrebuiltProperties{},
Ivan Lozano4fef93c2020-07-08 08:39:44 -0400469 &SourceProviderProperties{},
Chih-Hung Hsieh41805be2019-10-31 20:56:47 -0700470 &TestProperties{},
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400471 &cc.CoverageProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -0400472 &cc.RustBindgenClangProperties{},
Thiébaud Weksteen92f703b2020-06-22 13:28:02 +0200473 &ClippyProperties{},
Ivan Lozano6cd99e62020-02-11 08:24:25 -0500474 &SanitizeProperties{},
Ivan Lozanoffee3342019-08-27 12:03:00 -0700475 )
476
477 android.InitDefaultsModule(module)
478 return module
479}
480
481func (mod *Module) CrateName() string {
Ivan Lozanoad8b18b2019-10-31 19:38:29 -0700482 return mod.compiler.crateName()
Ivan Lozanoffee3342019-08-27 12:03:00 -0700483}
484
Ivan Lozano183a3212019-10-18 14:18:45 -0700485func (mod *Module) CcLibrary() bool {
486 if mod.compiler != nil {
487 if _, ok := mod.compiler.(*libraryDecorator); ok {
488 return true
489 }
490 }
491 return false
492}
493
494func (mod *Module) CcLibraryInterface() bool {
495 if mod.compiler != nil {
Ivan Lozano89435d12020-07-31 11:01:18 -0400496 // use build{Static,Shared}() instead of {static,shared}() here because this might be called before
497 // VariantIs{Static,Shared} is set.
498 if lib, ok := mod.compiler.(libraryInterface); ok && (lib.buildShared() || lib.buildStatic()) {
Ivan Lozano183a3212019-10-18 14:18:45 -0700499 return true
500 }
501 }
502 return false
503}
504
Ivan Lozanoe0833b12019-11-06 19:15:49 -0800505func (mod *Module) IncludeDirs() android.Paths {
Ivan Lozano183a3212019-10-18 14:18:45 -0700506 if mod.compiler != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700507 if library, ok := mod.compiler.(*libraryDecorator); ok {
Ivan Lozanoe0833b12019-11-06 19:15:49 -0800508 return library.includeDirs
Ivan Lozano183a3212019-10-18 14:18:45 -0700509 }
510 }
511 panic(fmt.Errorf("IncludeDirs called on non-library module: %q", mod.BaseModuleName()))
512}
513
514func (mod *Module) SetStatic() {
515 if mod.compiler != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700516 if library, ok := mod.compiler.(libraryInterface); ok {
517 library.setStatic()
Ivan Lozano183a3212019-10-18 14:18:45 -0700518 return
519 }
520 }
521 panic(fmt.Errorf("SetStatic called on non-library module: %q", mod.BaseModuleName()))
522}
523
524func (mod *Module) SetShared() {
525 if mod.compiler != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700526 if library, ok := mod.compiler.(libraryInterface); ok {
527 library.setShared()
Ivan Lozano183a3212019-10-18 14:18:45 -0700528 return
529 }
530 }
531 panic(fmt.Errorf("SetShared called on non-library module: %q", mod.BaseModuleName()))
532}
533
Ivan Lozano183a3212019-10-18 14:18:45 -0700534func (mod *Module) BuildStaticVariant() bool {
535 if mod.compiler != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700536 if library, ok := mod.compiler.(libraryInterface); ok {
537 return library.buildStatic()
Ivan Lozano183a3212019-10-18 14:18:45 -0700538 }
539 }
540 panic(fmt.Errorf("BuildStaticVariant called on non-library module: %q", mod.BaseModuleName()))
541}
542
543func (mod *Module) BuildSharedVariant() bool {
544 if mod.compiler != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700545 if library, ok := mod.compiler.(libraryInterface); ok {
546 return library.buildShared()
Ivan Lozano183a3212019-10-18 14:18:45 -0700547 }
548 }
549 panic(fmt.Errorf("BuildSharedVariant called on non-library module: %q", mod.BaseModuleName()))
550}
551
Ivan Lozano183a3212019-10-18 14:18:45 -0700552func (mod *Module) Module() android.Module {
553 return mod
554}
555
Ivan Lozano183a3212019-10-18 14:18:45 -0700556func (mod *Module) OutputFile() android.OptionalPath {
Jiyong Parke54f07e2021-04-07 15:08:04 +0900557 if mod.compiler != nil && mod.compiler.strippedOutputFilePath().Valid() {
558 return mod.compiler.strippedOutputFilePath()
559 }
560 return mod.unstrippedOutputFile
Ivan Lozano183a3212019-10-18 14:18:45 -0700561}
562
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400563func (mod *Module) CoverageFiles() android.Paths {
564 if mod.compiler != nil {
Joel Galensonfa049382021-01-14 16:03:18 -0800565 return android.Paths{}
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400566 }
567 panic(fmt.Errorf("CoverageFiles called on non-library module: %q", mod.BaseModuleName()))
568}
569
Jiyong Park459feca2020-12-15 11:02:21 +0900570func (mod *Module) installable(apexInfo android.ApexInfo) bool {
571 // The apex variant is not installable because it is included in the APEX and won't appear
572 // in the system partition as a standalone file.
573 if !apexInfo.IsForPlatform() {
574 return false
575 }
576
Jiyong Parke54f07e2021-04-07 15:08:04 +0900577 return mod.OutputFile().Valid() && !mod.Properties.PreventInstall
Jiyong Park459feca2020-12-15 11:02:21 +0900578}
579
Ivan Lozano183a3212019-10-18 14:18:45 -0700580var _ cc.LinkableInterface = (*Module)(nil)
581
Ivan Lozanoffee3342019-08-27 12:03:00 -0700582func (mod *Module) Init() android.Module {
583 mod.AddProperties(&mod.Properties)
Ivan Lozano6a884432020-12-02 09:15:16 -0500584 mod.AddProperties(&mod.VendorProperties)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700585
586 if mod.compiler != nil {
587 mod.AddProperties(mod.compiler.compilerProps()...)
588 }
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400589 if mod.coverage != nil {
590 mod.AddProperties(mod.coverage.props()...)
591 }
Thiébaud Weksteen92f703b2020-06-22 13:28:02 +0200592 if mod.clippy != nil {
593 mod.AddProperties(mod.clippy.props()...)
594 }
Ivan Lozano4fef93c2020-07-08 08:39:44 -0400595 if mod.sourceProvider != nil {
Andrei Homescuc7767922020-08-05 06:36:19 -0700596 mod.AddProperties(mod.sourceProvider.SourceProviderProps()...)
Ivan Lozano4fef93c2020-07-08 08:39:44 -0400597 }
Ivan Lozano6cd99e62020-02-11 08:24:25 -0500598 if mod.sanitize != nil {
599 mod.AddProperties(mod.sanitize.props()...)
600 }
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400601
Ivan Lozanoffee3342019-08-27 12:03:00 -0700602 android.InitAndroidArchModule(mod, mod.hod, mod.multilib)
Jiyong Park99644e92020-11-17 22:21:02 +0900603 android.InitApexModule(mod)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700604
605 android.InitDefaultableModule(mod)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700606 return mod
607}
608
609func newBaseModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
610 return &Module{
611 hod: hod,
612 multilib: multilib,
613 }
614}
615func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
616 module := newBaseModule(hod, multilib)
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400617 module.coverage = &coverage{}
Thiébaud Weksteen92f703b2020-06-22 13:28:02 +0200618 module.clippy = &clippy{}
Ivan Lozano6cd99e62020-02-11 08:24:25 -0500619 module.sanitize = &sanitize{}
Ivan Lozanoffee3342019-08-27 12:03:00 -0700620 return module
621}
622
623type ModuleContext interface {
624 android.ModuleContext
625 ModuleContextIntf
626}
627
628type BaseModuleContext interface {
629 android.BaseModuleContext
630 ModuleContextIntf
631}
632
633type DepsContext interface {
634 android.BottomUpMutatorContext
635 ModuleContextIntf
636}
637
638type ModuleContextIntf interface {
Thiébaud Weksteen1f7f70f2020-06-24 11:32:48 +0200639 RustModule() *Module
Ivan Lozanoffee3342019-08-27 12:03:00 -0700640 toolchain() config.Toolchain
Ivan Lozanoffee3342019-08-27 12:03:00 -0700641}
642
643type depsContext struct {
644 android.BottomUpMutatorContext
Ivan Lozanoffee3342019-08-27 12:03:00 -0700645}
646
647type moduleContext struct {
648 android.ModuleContext
Ivan Lozanoffee3342019-08-27 12:03:00 -0700649}
650
Thiébaud Weksteen1f7f70f2020-06-24 11:32:48 +0200651type baseModuleContext struct {
652 android.BaseModuleContext
653}
654
655func (ctx *moduleContext) RustModule() *Module {
656 return ctx.Module().(*Module)
657}
658
659func (ctx *moduleContext) toolchain() config.Toolchain {
660 return ctx.RustModule().toolchain(ctx)
661}
662
663func (ctx *depsContext) RustModule() *Module {
664 return ctx.Module().(*Module)
665}
666
667func (ctx *depsContext) toolchain() config.Toolchain {
668 return ctx.RustModule().toolchain(ctx)
669}
670
671func (ctx *baseModuleContext) RustModule() *Module {
672 return ctx.Module().(*Module)
673}
674
675func (ctx *baseModuleContext) toolchain() config.Toolchain {
676 return ctx.RustModule().toolchain(ctx)
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400677}
678
679func (mod *Module) nativeCoverage() bool {
680 return mod.compiler != nil && mod.compiler.nativeCoverage()
681}
682
Ivan Lozanoffee3342019-08-27 12:03:00 -0700683func (mod *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
684 if mod.cachedToolchain == nil {
685 mod.cachedToolchain = config.FindToolchain(ctx.Os(), ctx.Arch())
686 }
687 return mod.cachedToolchain
688}
689
Thiébaud Weksteen31f1bb82020-08-27 13:37:29 +0200690func (mod *Module) ccToolchain(ctx android.BaseModuleContext) cc_config.Toolchain {
691 return cc_config.FindToolchain(ctx.Os(), ctx.Arch())
692}
693
Ivan Lozanoffee3342019-08-27 12:03:00 -0700694func (d *Defaults) GenerateAndroidBuildActions(ctx android.ModuleContext) {
695}
696
697func (mod *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
698 ctx := &moduleContext{
699 ModuleContext: actx,
Ivan Lozanoffee3342019-08-27 12:03:00 -0700700 }
Ivan Lozanoffee3342019-08-27 12:03:00 -0700701
Jiyong Park99644e92020-11-17 22:21:02 +0900702 apexInfo := actx.Provider(android.ApexInfoProvider).(android.ApexInfo)
703 if !apexInfo.IsForPlatform() {
704 mod.hideApexVariantFromMake = true
705 }
706
Ivan Lozanoffee3342019-08-27 12:03:00 -0700707 toolchain := mod.toolchain(ctx)
Ivan Lozano6a884432020-12-02 09:15:16 -0500708 mod.makeLinkType = cc.GetMakeLinkType(actx, mod)
709
710 // Differentiate static libraries that are vendor available
711 if mod.UseVndk() {
Ivan Lozanoe6d30982021-02-05 10:57:43 -0500712 mod.Properties.SubName += cc.VendorSuffix
713 } else if mod.InVendorRamdisk() && !mod.OnlyInVendorRamdisk() {
714 mod.Properties.SubName += cc.VendorRamdiskSuffix
Ivan Lozano6a884432020-12-02 09:15:16 -0500715 }
Ivan Lozanoffee3342019-08-27 12:03:00 -0700716
717 if !toolchain.Supported() {
718 // This toolchain's unsupported, there's nothing to do for this mod.
719 return
720 }
721
722 deps := mod.depsToPaths(ctx)
723 flags := Flags{
724 Toolchain: toolchain,
725 }
726
727 if mod.compiler != nil {
728 flags = mod.compiler.compilerFlags(ctx, flags)
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400729 }
730 if mod.coverage != nil {
731 flags, deps = mod.coverage.flags(ctx, flags, deps)
732 }
Thiébaud Weksteen92f703b2020-06-22 13:28:02 +0200733 if mod.clippy != nil {
734 flags, deps = mod.clippy.flags(ctx, flags, deps)
735 }
Ivan Lozano6cd99e62020-02-11 08:24:25 -0500736 if mod.sanitize != nil {
737 flags, deps = mod.sanitize.flags(ctx, flags, deps)
738 }
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400739
Thiébaud Weksteen295c72b2020-09-23 18:10:17 +0200740 // SourceProvider needs to call GenerateSource() before compiler calls
741 // compile() so it can provide the source. A SourceProvider has
742 // multiple variants (e.g. source, rlib, dylib). Only the "source"
743 // variant is responsible for effectively generating the source. The
744 // remaining variants relies on the "source" variant output.
Ivan Lozano26ecd6c2020-07-31 13:40:31 -0400745 if mod.sourceProvider != nil {
Thiébaud Weksteen295c72b2020-09-23 18:10:17 +0200746 if mod.compiler.(libraryInterface).source() {
747 mod.sourceProvider.GenerateSource(ctx, deps)
748 mod.sourceProvider.setSubName(ctx.ModuleSubDir())
749 } else {
750 sourceMod := actx.GetDirectDepWithTag(mod.Name(), sourceDepTag)
751 sourceLib := sourceMod.(*Module).compiler.(*libraryDecorator)
Chih-Hung Hsiehc49649c2020-10-01 21:25:05 -0700752 mod.sourceProvider.setOutputFiles(sourceLib.sourceProvider.Srcs())
Thiébaud Weksteen295c72b2020-09-23 18:10:17 +0200753 }
Ivan Lozano26ecd6c2020-07-31 13:40:31 -0400754 }
755
756 if mod.compiler != nil && !mod.compiler.Disabled() {
Thiébaud Weksteenee6a89b2021-02-25 16:30:57 +0100757 mod.compiler.initialize(ctx)
Jiyong Parke54f07e2021-04-07 15:08:04 +0900758 unstrippedOutputFile := mod.compiler.compile(ctx, flags, deps)
Jiyong Parke54f07e2021-04-07 15:08:04 +0900759 mod.unstrippedOutputFile = android.OptionalPathForPath(unstrippedOutputFile)
Thiébaud Weksteene4dd14b2021-04-14 11:18:47 +0200760 bloaty.MeasureSizeForPaths(ctx, mod.compiler.strippedOutputFilePath(), mod.unstrippedOutputFile)
Jiyong Park459feca2020-12-15 11:02:21 +0900761
Dan Albert06feee92021-03-19 15:06:02 -0700762 mod.docTimestampFile = mod.compiler.rustdoc(ctx, flags, deps)
763
Jiyong Park459feca2020-12-15 11:02:21 +0900764 apexInfo := actx.Provider(android.ApexInfoProvider).(android.ApexInfo)
765 if mod.installable(apexInfo) {
Thiébaud Weksteenfabaff62020-08-27 13:48:36 +0200766 mod.compiler.install(ctx)
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400767 }
Ivan Lozanoffee3342019-08-27 12:03:00 -0700768 }
769}
770
771func (mod *Module) deps(ctx DepsContext) Deps {
772 deps := Deps{}
773
774 if mod.compiler != nil {
775 deps = mod.compiler.compilerDeps(ctx, deps)
Ivan Lozano26ecd6c2020-07-31 13:40:31 -0400776 }
777 if mod.sourceProvider != nil {
Andrei Homescuc7767922020-08-05 06:36:19 -0700778 deps = mod.sourceProvider.SourceProviderDeps(ctx, deps)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700779 }
780
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400781 if mod.coverage != nil {
782 deps = mod.coverage.deps(ctx, deps)
783 }
784
Ivan Lozano6cd99e62020-02-11 08:24:25 -0500785 if mod.sanitize != nil {
786 deps = mod.sanitize.deps(ctx, deps)
787 }
788
Ivan Lozanoffee3342019-08-27 12:03:00 -0700789 deps.Rlibs = android.LastUniqueStrings(deps.Rlibs)
790 deps.Dylibs = android.LastUniqueStrings(deps.Dylibs)
Matthew Maurer0f003b12020-06-29 14:34:06 -0700791 deps.Rustlibs = android.LastUniqueStrings(deps.Rustlibs)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700792 deps.ProcMacros = android.LastUniqueStrings(deps.ProcMacros)
793 deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
794 deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
Ivan Lozano63bb7682021-03-23 15:53:44 -0400795 deps.WholeStaticLibs = android.LastUniqueStrings(deps.WholeStaticLibs)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700796 return deps
797
798}
799
Ivan Lozanoffee3342019-08-27 12:03:00 -0700800type dependencyTag struct {
801 blueprint.BaseDependencyTag
Jaewoong Jung18aefc12020-12-21 09:11:10 -0800802 name string
803 library bool
804 procMacro bool
Ivan Lozanoffee3342019-08-27 12:03:00 -0700805}
806
Jiyong Park65b62242020-11-25 12:44:59 +0900807// InstallDepNeeded returns true for rlibs, dylibs, and proc macros so that they or their transitive
808// dependencies (especially C/C++ shared libs) are installed as dependencies of a rust binary.
809func (d dependencyTag) InstallDepNeeded() bool {
Jaewoong Jung18aefc12020-12-21 09:11:10 -0800810 return d.library || d.procMacro
Jiyong Park65b62242020-11-25 12:44:59 +0900811}
812
813var _ android.InstallNeededDependencyTag = dependencyTag{}
814
Ivan Lozanoffee3342019-08-27 12:03:00 -0700815var (
Ivan Lozanoc564d2d2020-08-04 15:43:37 -0400816 customBindgenDepTag = dependencyTag{name: "customBindgenTag"}
817 rlibDepTag = dependencyTag{name: "rlibTag", library: true}
818 dylibDepTag = dependencyTag{name: "dylib", library: true}
Jaewoong Jung18aefc12020-12-21 09:11:10 -0800819 procMacroDepTag = dependencyTag{name: "procMacro", procMacro: true}
Ivan Lozanoc564d2d2020-08-04 15:43:37 -0400820 testPerSrcDepTag = dependencyTag{name: "rust_unit_tests"}
Thiébaud Weksteen295c72b2020-09-23 18:10:17 +0200821 sourceDepTag = dependencyTag{name: "source"}
Ivan Lozanoffee3342019-08-27 12:03:00 -0700822)
823
Jiyong Park99644e92020-11-17 22:21:02 +0900824func IsDylibDepTag(depTag blueprint.DependencyTag) bool {
825 tag, ok := depTag.(dependencyTag)
826 return ok && tag == dylibDepTag
827}
828
Jiyong Park94e22fd2021-04-08 18:19:15 +0900829func IsRlibDepTag(depTag blueprint.DependencyTag) bool {
830 tag, ok := depTag.(dependencyTag)
831 return ok && tag == rlibDepTag
832}
833
Matthew Maurer0f003b12020-06-29 14:34:06 -0700834type autoDep struct {
835 variation string
836 depTag dependencyTag
837}
838
839var (
Thiébaud Weksteen295c72b2020-09-23 18:10:17 +0200840 rlibVariation = "rlib"
841 dylibVariation = "dylib"
842 rlibAutoDep = autoDep{variation: rlibVariation, depTag: rlibDepTag}
843 dylibAutoDep = autoDep{variation: dylibVariation, depTag: dylibDepTag}
Matthew Maurer0f003b12020-06-29 14:34:06 -0700844)
845
846type autoDeppable interface {
Liz Kammer356f7d42021-01-26 09:18:53 -0500847 autoDep(ctx android.BottomUpMutatorContext) autoDep
Matthew Maurer0f003b12020-06-29 14:34:06 -0700848}
849
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400850func (mod *Module) begin(ctx BaseModuleContext) {
851 if mod.coverage != nil {
852 mod.coverage.begin(ctx)
853 }
Ivan Lozano6cd99e62020-02-11 08:24:25 -0500854 if mod.sanitize != nil {
855 mod.sanitize.begin(ctx)
856 }
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400857}
858
Ivan Lozanoffee3342019-08-27 12:03:00 -0700859func (mod *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
860 var depPaths PathDeps
861
862 directRlibDeps := []*Module{}
863 directDylibDeps := []*Module{}
864 directProcMacroDeps := []*Module{}
Ivan Lozano52767be2019-10-18 14:49:46 -0700865 directSharedLibDeps := [](cc.LinkableInterface){}
866 directStaticLibDeps := [](cc.LinkableInterface){}
Ivan Lozano07cbaf42020-07-22 16:09:13 -0400867 directSrcProvidersDeps := []*Module{}
868 directSrcDeps := [](android.SourceFileProducer){}
Ivan Lozanoffee3342019-08-27 12:03:00 -0700869
870 ctx.VisitDirectDeps(func(dep android.Module) {
871 depName := ctx.OtherModuleName(dep)
872 depTag := ctx.OtherModuleDependencyTag(dep)
Ivan Lozanoc08897c2021-04-02 12:41:32 -0400873
Ivan Lozano89435d12020-07-31 11:01:18 -0400874 if rustDep, ok := dep.(*Module); ok && !rustDep.CcLibraryInterface() {
Ivan Lozanoffee3342019-08-27 12:03:00 -0700875 //Handle Rust Modules
Ivan Lozanoc08897c2021-04-02 12:41:32 -0400876 makeLibName := cc.MakeLibName(ctx, mod, rustDep, depName+rustDep.Properties.RustSubName)
Ivan Lozano70e0a072019-09-13 14:23:15 -0700877
Ivan Lozanoffee3342019-08-27 12:03:00 -0700878 switch depTag {
879 case dylibDepTag:
880 dylib, ok := rustDep.compiler.(libraryInterface)
881 if !ok || !dylib.dylib() {
882 ctx.ModuleErrorf("mod %q not an dylib library", depName)
883 return
884 }
885 directDylibDeps = append(directDylibDeps, rustDep)
Ivan Lozanoc08897c2021-04-02 12:41:32 -0400886 mod.Properties.AndroidMkDylibs = append(mod.Properties.AndroidMkDylibs, makeLibName)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700887 case rlibDepTag:
Ivan Lozano2b081132020-09-08 12:46:52 -0400888
Ivan Lozanoffee3342019-08-27 12:03:00 -0700889 rlib, ok := rustDep.compiler.(libraryInterface)
890 if !ok || !rlib.rlib() {
Ivan Lozanoc08897c2021-04-02 12:41:32 -0400891 ctx.ModuleErrorf("mod %q not an rlib library", makeLibName)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700892 return
893 }
894 directRlibDeps = append(directRlibDeps, rustDep)
Ivan Lozanoc08897c2021-04-02 12:41:32 -0400895 mod.Properties.AndroidMkRlibs = append(mod.Properties.AndroidMkRlibs, makeLibName)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700896 case procMacroDepTag:
897 directProcMacroDeps = append(directProcMacroDeps, rustDep)
Ivan Lozanoc08897c2021-04-02 12:41:32 -0400898 mod.Properties.AndroidMkProcMacroLibs = append(mod.Properties.AndroidMkProcMacroLibs, makeLibName)
Ivan Lozano07cbaf42020-07-22 16:09:13 -0400899 case android.SourceDepTag:
900 // Since these deps are added in path_properties.go via AddDependencies, we need to ensure the correct
901 // OS/Arch variant is used.
902 var helper string
903 if ctx.Host() {
904 helper = "missing 'host_supported'?"
905 } else {
906 helper = "device module defined?"
907 }
908
909 if dep.Target().Os != ctx.Os() {
910 ctx.ModuleErrorf("OS mismatch on dependency %q (%s)", dep.Name(), helper)
911 return
912 } else if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
913 ctx.ModuleErrorf("Arch mismatch on dependency %q (%s)", dep.Name(), helper)
914 return
915 }
916 directSrcProvidersDeps = append(directSrcProvidersDeps, rustDep)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700917 }
918
Ivan Lozano2bbcacf2020-08-07 09:00:50 -0400919 //Append the dependencies exportedDirs, except for proc-macros which target a different arch/OS
Colin Cross0de8a1e2020-09-18 14:15:30 -0700920 if depTag != procMacroDepTag {
921 exportedInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
922 depPaths.linkDirs = append(depPaths.linkDirs, exportedInfo.LinkDirs...)
923 depPaths.depFlags = append(depPaths.depFlags, exportedInfo.Flags...)
924 depPaths.linkObjects = append(depPaths.linkObjects, exportedInfo.LinkObjects...)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700925 }
926
Ivan Lozanoffee3342019-08-27 12:03:00 -0700927 if depTag == dylibDepTag || depTag == rlibDepTag || depTag == procMacroDepTag {
Jiyong Parke54f07e2021-04-07 15:08:04 +0900928 linkFile := rustDep.unstrippedOutputFile
Ivan Lozano26ecd6c2020-07-31 13:40:31 -0400929 if !linkFile.Valid() {
930 ctx.ModuleErrorf("Invalid output file when adding dep %q to %q",
931 depName, ctx.ModuleName())
932 return
933 }
Ivan Lozanoffee3342019-08-27 12:03:00 -0700934 linkDir := linkPathFromFilePath(linkFile.Path())
Matthew Maurerbb3add12020-06-25 09:34:12 -0700935 if lib, ok := mod.compiler.(exportedFlagsProducer); ok {
936 lib.exportLinkDirs(linkDir)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700937 }
938 }
939
Ivan Lozano89435d12020-07-31 11:01:18 -0400940 } else if ccDep, ok := dep.(cc.LinkableInterface); ok {
Ivan Lozano52767be2019-10-18 14:49:46 -0700941 //Handle C dependencies
Ivan Lozanoc08897c2021-04-02 12:41:32 -0400942 makeLibName := cc.MakeLibName(ctx, mod, ccDep, depName)
Ivan Lozano52767be2019-10-18 14:49:46 -0700943 if _, ok := ccDep.(*Module); !ok {
944 if ccDep.Module().Target().Os != ctx.Os() {
945 ctx.ModuleErrorf("OS mismatch between %q and %q", ctx.ModuleName(), depName)
946 return
947 }
948 if ccDep.Module().Target().Arch.ArchType != ctx.Arch().ArchType {
949 ctx.ModuleErrorf("Arch mismatch between %q and %q", ctx.ModuleName(), depName)
950 return
951 }
Ivan Lozano70e0a072019-09-13 14:23:15 -0700952 }
Ivan Lozano2093af22020-08-25 12:48:19 -0400953 linkObject := ccDep.OutputFile()
954 linkPath := linkPathFromFilePath(linkObject.Path())
Ivan Lozano6aa66022020-02-06 13:22:43 -0500955
Ivan Lozano2093af22020-08-25 12:48:19 -0400956 if !linkObject.Valid() {
Ivan Lozanoffee3342019-08-27 12:03:00 -0700957 ctx.ModuleErrorf("Invalid output file when adding dep %q to %q", depName, ctx.ModuleName())
958 }
959
960 exportDep := false
Colin Cross6e511a92020-07-27 21:26:48 -0700961 switch {
962 case cc.IsStaticDepTag(depTag):
Ivan Lozano63bb7682021-03-23 15:53:44 -0400963 if cc.IsWholeStaticLib(depTag) {
964 // rustc will bundle static libraries when they're passed with "-lstatic=<lib>". This will fail
965 // if the library is not prefixed by "lib".
Ivan Lozanofb6f36f2021-02-05 12:27:08 -0500966 if libName, ok := libNameFromFilePath(linkObject.Path()); ok {
967 depPaths.depFlags = append(depPaths.depFlags, "-lstatic="+libName)
Ivan Lozano63bb7682021-03-23 15:53:44 -0400968 } else {
969 ctx.ModuleErrorf("'%q' cannot be listed as a whole_static_library in Rust modules unless the output is prefixed by 'lib'", depName, ctx.ModuleName())
Ivan Lozanofb6f36f2021-02-05 12:27:08 -0500970 }
Ivan Lozano3dfa12d2021-02-04 11:29:41 -0500971 }
972
973 // Add this to linkObjects to pass the library directly to the linker as well. This propagates
974 // to dependencies to avoid having to redeclare static libraries for dependents of the dylib variant.
Ivan Lozano2093af22020-08-25 12:48:19 -0400975 depPaths.linkObjects = append(depPaths.linkObjects, linkObject.String())
Ivan Lozano3dfa12d2021-02-04 11:29:41 -0500976 depPaths.linkDirs = append(depPaths.linkDirs, linkPath)
977
Colin Cross0de8a1e2020-09-18 14:15:30 -0700978 exportedInfo := ctx.OtherModuleProvider(dep, cc.FlagExporterInfoProvider).(cc.FlagExporterInfo)
979 depPaths.depIncludePaths = append(depPaths.depIncludePaths, exportedInfo.IncludeDirs...)
980 depPaths.depSystemIncludePaths = append(depPaths.depSystemIncludePaths, exportedInfo.SystemIncludeDirs...)
981 depPaths.depClangFlags = append(depPaths.depClangFlags, exportedInfo.Flags...)
982 depPaths.depGeneratedHeaders = append(depPaths.depGeneratedHeaders, exportedInfo.GeneratedHeaders...)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700983 directStaticLibDeps = append(directStaticLibDeps, ccDep)
Ivan Lozanoc08897c2021-04-02 12:41:32 -0400984 mod.Properties.AndroidMkStaticLibs = append(mod.Properties.AndroidMkStaticLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -0700985 case cc.IsSharedDepTag(depTag):
Ivan Lozanoffee3342019-08-27 12:03:00 -0700986 depPaths.linkDirs = append(depPaths.linkDirs, linkPath)
Ivan Lozano2093af22020-08-25 12:48:19 -0400987 depPaths.linkObjects = append(depPaths.linkObjects, linkObject.String())
Colin Cross0de8a1e2020-09-18 14:15:30 -0700988 exportedInfo := ctx.OtherModuleProvider(dep, cc.FlagExporterInfoProvider).(cc.FlagExporterInfo)
989 depPaths.depIncludePaths = append(depPaths.depIncludePaths, exportedInfo.IncludeDirs...)
990 depPaths.depSystemIncludePaths = append(depPaths.depSystemIncludePaths, exportedInfo.SystemIncludeDirs...)
991 depPaths.depClangFlags = append(depPaths.depClangFlags, exportedInfo.Flags...)
992 depPaths.depGeneratedHeaders = append(depPaths.depGeneratedHeaders, exportedInfo.GeneratedHeaders...)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700993 directSharedLibDeps = append(directSharedLibDeps, ccDep)
Ivan Lozanoc08897c2021-04-02 12:41:32 -0400994 mod.Properties.AndroidMkSharedLibs = append(mod.Properties.AndroidMkSharedLibs, makeLibName)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700995 exportDep = true
Zach Johnson3df4e632020-11-06 11:56:27 -0800996 case cc.IsHeaderDepTag(depTag):
997 exportedInfo := ctx.OtherModuleProvider(dep, cc.FlagExporterInfoProvider).(cc.FlagExporterInfo)
998 depPaths.depIncludePaths = append(depPaths.depIncludePaths, exportedInfo.IncludeDirs...)
999 depPaths.depSystemIncludePaths = append(depPaths.depSystemIncludePaths, exportedInfo.SystemIncludeDirs...)
1000 depPaths.depGeneratedHeaders = append(depPaths.depGeneratedHeaders, exportedInfo.GeneratedHeaders...)
Colin Cross6e511a92020-07-27 21:26:48 -07001001 case depTag == cc.CrtBeginDepTag:
Ivan Lozano2093af22020-08-25 12:48:19 -04001002 depPaths.CrtBegin = linkObject
Colin Cross6e511a92020-07-27 21:26:48 -07001003 case depTag == cc.CrtEndDepTag:
Ivan Lozano2093af22020-08-25 12:48:19 -04001004 depPaths.CrtEnd = linkObject
Ivan Lozanoffee3342019-08-27 12:03:00 -07001005 }
1006
1007 // Make sure these dependencies are propagated
Matthew Maurerbb3add12020-06-25 09:34:12 -07001008 if lib, ok := mod.compiler.(exportedFlagsProducer); ok && exportDep {
1009 lib.exportLinkDirs(linkPath)
Ivan Lozano2093af22020-08-25 12:48:19 -04001010 lib.exportLinkObjects(linkObject.String())
Ivan Lozanoffee3342019-08-27 12:03:00 -07001011 }
Ivan Lozanoffee3342019-08-27 12:03:00 -07001012 }
Ivan Lozano89435d12020-07-31 11:01:18 -04001013
1014 if srcDep, ok := dep.(android.SourceFileProducer); ok {
1015 switch depTag {
1016 case android.SourceDepTag:
1017 // These are usually genrules which don't have per-target variants.
1018 directSrcDeps = append(directSrcDeps, srcDep)
1019 }
1020 }
Ivan Lozanoffee3342019-08-27 12:03:00 -07001021 })
1022
1023 var rlibDepFiles RustLibraries
1024 for _, dep := range directRlibDeps {
Jiyong Parke54f07e2021-04-07 15:08:04 +09001025 rlibDepFiles = append(rlibDepFiles, RustLibrary{Path: dep.unstrippedOutputFile.Path(), CrateName: dep.CrateName()})
Ivan Lozanoffee3342019-08-27 12:03:00 -07001026 }
1027 var dylibDepFiles RustLibraries
1028 for _, dep := range directDylibDeps {
Jiyong Parke54f07e2021-04-07 15:08:04 +09001029 dylibDepFiles = append(dylibDepFiles, RustLibrary{Path: dep.unstrippedOutputFile.Path(), CrateName: dep.CrateName()})
Ivan Lozanoffee3342019-08-27 12:03:00 -07001030 }
1031 var procMacroDepFiles RustLibraries
1032 for _, dep := range directProcMacroDeps {
Jiyong Parke54f07e2021-04-07 15:08:04 +09001033 procMacroDepFiles = append(procMacroDepFiles, RustLibrary{Path: dep.unstrippedOutputFile.Path(), CrateName: dep.CrateName()})
Ivan Lozanoffee3342019-08-27 12:03:00 -07001034 }
1035
1036 var staticLibDepFiles android.Paths
1037 for _, dep := range directStaticLibDeps {
1038 staticLibDepFiles = append(staticLibDepFiles, dep.OutputFile().Path())
1039 }
1040
Ivan Lozanoec6e9912021-01-21 15:23:29 -05001041 var sharedLibFiles android.Paths
Ivan Lozanoffee3342019-08-27 12:03:00 -07001042 var sharedLibDepFiles android.Paths
1043 for _, dep := range directSharedLibDeps {
Ivan Lozanoec6e9912021-01-21 15:23:29 -05001044 sharedLibFiles = append(sharedLibFiles, dep.OutputFile().Path())
1045 if dep.Toc().Valid() {
1046 sharedLibDepFiles = append(sharedLibDepFiles, dep.Toc().Path())
1047 } else {
1048 sharedLibDepFiles = append(sharedLibDepFiles, dep.OutputFile().Path())
1049 }
Ivan Lozanoffee3342019-08-27 12:03:00 -07001050 }
1051
Ivan Lozano07cbaf42020-07-22 16:09:13 -04001052 var srcProviderDepFiles android.Paths
1053 for _, dep := range directSrcProvidersDeps {
1054 srcs, _ := dep.OutputFiles("")
1055 srcProviderDepFiles = append(srcProviderDepFiles, srcs...)
1056 }
1057 for _, dep := range directSrcDeps {
1058 srcs := dep.Srcs()
1059 srcProviderDepFiles = append(srcProviderDepFiles, srcs...)
1060 }
1061
Ivan Lozanoffee3342019-08-27 12:03:00 -07001062 depPaths.RLibs = append(depPaths.RLibs, rlibDepFiles...)
1063 depPaths.DyLibs = append(depPaths.DyLibs, dylibDepFiles...)
1064 depPaths.SharedLibs = append(depPaths.SharedLibs, sharedLibDepFiles...)
Ivan Lozanoec6e9912021-01-21 15:23:29 -05001065 depPaths.SharedLibDeps = append(depPaths.SharedLibDeps, sharedLibDepFiles...)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001066 depPaths.StaticLibs = append(depPaths.StaticLibs, staticLibDepFiles...)
1067 depPaths.ProcMacros = append(depPaths.ProcMacros, procMacroDepFiles...)
Ivan Lozano07cbaf42020-07-22 16:09:13 -04001068 depPaths.SrcDeps = append(depPaths.SrcDeps, srcProviderDepFiles...)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001069
1070 // Dedup exported flags from dependencies
1071 depPaths.linkDirs = android.FirstUniqueStrings(depPaths.linkDirs)
Ivan Lozanoec6e9912021-01-21 15:23:29 -05001072 depPaths.linkObjects = android.FirstUniqueStrings(depPaths.linkObjects)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001073 depPaths.depFlags = android.FirstUniqueStrings(depPaths.depFlags)
Ivan Lozano45901ed2020-07-24 16:05:01 -04001074 depPaths.depClangFlags = android.FirstUniqueStrings(depPaths.depClangFlags)
1075 depPaths.depIncludePaths = android.FirstUniquePaths(depPaths.depIncludePaths)
1076 depPaths.depSystemIncludePaths = android.FirstUniquePaths(depPaths.depSystemIncludePaths)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001077
1078 return depPaths
1079}
1080
Chih-Hung Hsieh9a4a7ba2019-12-12 19:36:05 -08001081func (mod *Module) InstallInData() bool {
1082 if mod.compiler == nil {
1083 return false
1084 }
1085 return mod.compiler.inData()
1086}
1087
Ivan Lozanoffee3342019-08-27 12:03:00 -07001088func linkPathFromFilePath(filepath android.Path) string {
1089 return strings.Split(filepath.String(), filepath.Base())[0]
1090}
Ivan Lozanod648c432020-02-06 12:05:10 -05001091
Ivan Lozanoffee3342019-08-27 12:03:00 -07001092func (mod *Module) DepsMutator(actx android.BottomUpMutatorContext) {
1093 ctx := &depsContext{
1094 BottomUpMutatorContext: actx,
Ivan Lozanoffee3342019-08-27 12:03:00 -07001095 }
Ivan Lozanoffee3342019-08-27 12:03:00 -07001096
1097 deps := mod.deps(ctx)
Colin Cross3146c5c2020-09-30 15:34:40 -07001098 var commonDepVariations []blueprint.Variation
Ivan Lozanodd055472020-09-28 13:22:45 -04001099
Ivan Lozano2b081132020-09-08 12:46:52 -04001100 stdLinkage := "dylib-std"
Ivan Lozanodd055472020-09-28 13:22:45 -04001101 if mod.compiler.stdLinkage(ctx) == RlibLinkage {
Ivan Lozano2b081132020-09-08 12:46:52 -04001102 stdLinkage = "rlib-std"
1103 }
1104
1105 rlibDepVariations := commonDepVariations
1106 if lib, ok := mod.compiler.(libraryInterface); !ok || !lib.sysroot() {
1107 rlibDepVariations = append(rlibDepVariations,
1108 blueprint.Variation{Mutator: "rust_stdlinkage", Variation: stdLinkage})
1109 }
1110
Ivan Lozano52767be2019-10-18 14:49:46 -07001111 actx.AddVariationDependencies(
Ivan Lozano2b081132020-09-08 12:46:52 -04001112 append(rlibDepVariations, []blueprint.Variation{
Thiébaud Weksteen295c72b2020-09-23 18:10:17 +02001113 {Mutator: "rust_libraries", Variation: rlibVariation}}...),
Ivan Lozano52767be2019-10-18 14:49:46 -07001114 rlibDepTag, deps.Rlibs...)
1115 actx.AddVariationDependencies(
1116 append(commonDepVariations, []blueprint.Variation{
Thiébaud Weksteen295c72b2020-09-23 18:10:17 +02001117 {Mutator: "rust_libraries", Variation: dylibVariation}}...),
Ivan Lozano52767be2019-10-18 14:49:46 -07001118 dylibDepTag, deps.Dylibs...)
1119
Ivan Lozano042504f2020-08-18 14:31:23 -04001120 if deps.Rustlibs != nil && !mod.compiler.Disabled() {
1121 autoDep := mod.compiler.(autoDeppable).autoDep(ctx)
Ivan Lozano2b081132020-09-08 12:46:52 -04001122 if autoDep.depTag == rlibDepTag {
1123 actx.AddVariationDependencies(
1124 append(rlibDepVariations, blueprint.Variation{Mutator: "rust_libraries", Variation: autoDep.variation}),
1125 autoDep.depTag, deps.Rustlibs...)
1126 } else {
1127 actx.AddVariationDependencies(
1128 append(commonDepVariations, blueprint.Variation{Mutator: "rust_libraries", Variation: autoDep.variation}),
1129 autoDep.depTag, deps.Rustlibs...)
1130 }
Matthew Maurer0f003b12020-06-29 14:34:06 -07001131 }
Ivan Lozano2b081132020-09-08 12:46:52 -04001132 if deps.Stdlibs != nil {
Ivan Lozanodd055472020-09-28 13:22:45 -04001133 if mod.compiler.stdLinkage(ctx) == RlibLinkage {
Ivan Lozano2b081132020-09-08 12:46:52 -04001134 actx.AddVariationDependencies(
1135 append(commonDepVariations, blueprint.Variation{Mutator: "rust_libraries", Variation: "rlib"}),
1136 rlibDepTag, deps.Stdlibs...)
1137 } else {
1138 actx.AddVariationDependencies(
1139 append(commonDepVariations, blueprint.Variation{Mutator: "rust_libraries", Variation: "dylib"}),
1140 dylibDepTag, deps.Stdlibs...)
1141 }
1142 }
Ivan Lozano52767be2019-10-18 14:49:46 -07001143 actx.AddVariationDependencies(append(commonDepVariations,
1144 blueprint.Variation{Mutator: "link", Variation: "shared"}),
Colin Cross6e511a92020-07-27 21:26:48 -07001145 cc.SharedDepTag(), deps.SharedLibs...)
Ivan Lozano52767be2019-10-18 14:49:46 -07001146 actx.AddVariationDependencies(append(commonDepVariations,
1147 blueprint.Variation{Mutator: "link", Variation: "static"}),
Ivan Lozano63bb7682021-03-23 15:53:44 -04001148 cc.StaticDepTag(false), deps.StaticLibs...)
1149 actx.AddVariationDependencies(append(commonDepVariations,
1150 blueprint.Variation{Mutator: "link", Variation: "static"}),
1151 cc.StaticDepTag(true), deps.WholeStaticLibs...)
Ivan Lozano5ca5ef62019-09-23 10:10:40 -07001152
Zach Johnson3df4e632020-11-06 11:56:27 -08001153 actx.AddVariationDependencies(nil, cc.HeaderDepTag(), deps.HeaderLibs...)
1154
Colin Cross565cafd2020-09-25 18:47:38 -07001155 crtVariations := cc.GetCrtVariations(ctx, mod)
Ivan Lozanof1c84332019-09-20 11:00:37 -07001156 if deps.CrtBegin != "" {
Dan Albert92fe7402020-07-15 13:33:30 -07001157 actx.AddVariationDependencies(crtVariations, cc.CrtBeginDepTag, deps.CrtBegin)
Ivan Lozanof1c84332019-09-20 11:00:37 -07001158 }
1159 if deps.CrtEnd != "" {
Dan Albert92fe7402020-07-15 13:33:30 -07001160 actx.AddVariationDependencies(crtVariations, cc.CrtEndDepTag, deps.CrtEnd)
Ivan Lozanof1c84332019-09-20 11:00:37 -07001161 }
1162
Ivan Lozanoc564d2d2020-08-04 15:43:37 -04001163 if mod.sourceProvider != nil {
1164 if bindgen, ok := mod.sourceProvider.(*bindgenDecorator); ok &&
1165 bindgen.Properties.Custom_bindgen != "" {
1166 actx.AddFarVariationDependencies(ctx.Config().BuildOSTarget.Variations(), customBindgenDepTag,
1167 bindgen.Properties.Custom_bindgen)
1168 }
1169 }
Ivan Lozano5ca5ef62019-09-23 10:10:40 -07001170 // proc_macros are compiler plugins, and so we need the host arch variant as a dependendcy.
Colin Cross0f7d2ef2019-10-16 11:03:10 -07001171 actx.AddFarVariationDependencies(ctx.Config().BuildOSTarget.Variations(), procMacroDepTag, deps.ProcMacros...)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001172}
1173
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001174func BeginMutator(ctx android.BottomUpMutatorContext) {
1175 if mod, ok := ctx.Module().(*Module); ok && mod.Enabled() {
1176 mod.beginMutator(ctx)
1177 }
1178}
1179
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001180func (mod *Module) beginMutator(actx android.BottomUpMutatorContext) {
1181 ctx := &baseModuleContext{
1182 BaseModuleContext: actx,
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001183 }
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001184
1185 mod.begin(ctx)
1186}
1187
Ivan Lozanoffee3342019-08-27 12:03:00 -07001188func (mod *Module) Name() string {
1189 name := mod.ModuleBase.Name()
1190 if p, ok := mod.compiler.(interface {
1191 Name(string) string
1192 }); ok {
1193 name = p.Name(name)
1194 }
1195 return name
1196}
1197
Thiébaud Weksteen9e8451e2020-08-13 12:55:59 +02001198func (mod *Module) disableClippy() {
Ivan Lozano32267c82020-08-04 16:27:16 -04001199 if mod.clippy != nil {
Thiébaud Weksteen9e8451e2020-08-13 12:55:59 +02001200 mod.clippy.Properties.Clippy_lints = proptools.StringPtr("none")
Ivan Lozano32267c82020-08-04 16:27:16 -04001201 }
1202}
1203
Chih-Hung Hsieh5c4e4892020-05-15 17:36:30 -07001204var _ android.HostToolProvider = (*Module)(nil)
1205
1206func (mod *Module) HostToolPath() android.OptionalPath {
1207 if !mod.Host() {
1208 return android.OptionalPath{}
1209 }
Chih-Hung Hsieha7562702020-08-10 21:50:43 -07001210 if binary, ok := mod.compiler.(*binaryDecorator); ok {
1211 return android.OptionalPathForPath(binary.baseCompiler.path)
Chih-Hung Hsieh5c4e4892020-05-15 17:36:30 -07001212 }
1213 return android.OptionalPath{}
1214}
1215
Jiyong Park99644e92020-11-17 22:21:02 +09001216var _ android.ApexModule = (*Module)(nil)
1217
Ivan Lozano3e9f9e42020-12-04 15:05:43 -05001218func (mod *Module) minSdkVersion() string {
1219 return String(mod.Properties.Min_sdk_version)
1220}
1221
Jiyong Park45bf82e2020-12-15 22:29:02 +09001222var _ android.ApexModule = (*Module)(nil)
1223
1224// Implements android.ApexModule
Jiyong Park99644e92020-11-17 22:21:02 +09001225func (mod *Module) ShouldSupportSdkVersion(ctx android.BaseModuleContext, sdkVersion android.ApiLevel) error {
Ivan Lozano3e9f9e42020-12-04 15:05:43 -05001226 minSdkVersion := mod.minSdkVersion()
1227 if minSdkVersion == "apex_inherit" {
1228 return nil
1229 }
1230 if minSdkVersion == "" {
1231 return fmt.Errorf("min_sdk_version is not specificed")
1232 }
1233
1234 // Not using nativeApiLevelFromUser because the context here is not
1235 // necessarily a native context.
1236 ver, err := android.ApiLevelFromUser(ctx, minSdkVersion)
1237 if err != nil {
1238 return err
1239 }
1240
1241 if ver.GreaterThan(sdkVersion) {
1242 return fmt.Errorf("newer SDK(%v)", ver)
1243 }
Jiyong Park99644e92020-11-17 22:21:02 +09001244 return nil
1245}
1246
Jiyong Park45bf82e2020-12-15 22:29:02 +09001247// Implements android.ApexModule
Jiyong Park99644e92020-11-17 22:21:02 +09001248func (mod *Module) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
1249 depTag := ctx.OtherModuleDependencyTag(dep)
1250
1251 if ccm, ok := dep.(*cc.Module); ok {
1252 if ccm.HasStubsVariants() {
1253 if cc.IsSharedDepTag(depTag) {
1254 // dynamic dep to a stubs lib crosses APEX boundary
1255 return false
1256 }
1257 if cc.IsRuntimeDepTag(depTag) {
1258 // runtime dep to a stubs lib also crosses APEX boundary
1259 return false
1260 }
1261
1262 if cc.IsHeaderDepTag(depTag) {
1263 return false
1264 }
1265 }
1266 if mod.Static() && cc.IsSharedDepTag(depTag) {
1267 // shared_lib dependency from a static lib is considered as crossing
1268 // the APEX boundary because the dependency doesn't actually is
1269 // linked; the dependency is used only during the compilation phase.
1270 return false
1271 }
1272 }
1273
1274 if depTag == procMacroDepTag {
1275 return false
1276 }
1277
1278 return true
1279}
1280
1281// Overrides ApexModule.IsInstallabeToApex()
1282func (mod *Module) IsInstallableToApex() bool {
1283 if mod.compiler != nil {
1284 if lib, ok := mod.compiler.(*libraryDecorator); ok && (lib.shared() || lib.dylib()) {
1285 return true
1286 }
1287 if _, ok := mod.compiler.(*binaryDecorator); ok {
1288 return true
1289 }
1290 }
1291 return false
1292}
1293
Ivan Lozano3dfa12d2021-02-04 11:29:41 -05001294// If a library file has a "lib" prefix, extract the library name without the prefix.
1295func libNameFromFilePath(filepath android.Path) (string, bool) {
1296 libName := strings.TrimSuffix(filepath.Base(), filepath.Ext())
1297 if strings.HasPrefix(libName, "lib") {
1298 libName = libName[3:]
1299 return libName, true
1300 }
1301 return "", false
1302}
1303
Ivan Lozanoffee3342019-08-27 12:03:00 -07001304var Bool = proptools.Bool
1305var BoolDefault = proptools.BoolDefault
1306var String = proptools.String
1307var StringPtr = proptools.StringPtr
Ivan Lozano43845682020-07-09 21:03:28 -04001308
1309var _ android.OutputFileProducer = (*Module)(nil)