blob: bb971420ed9fdb7111496cd10e90ce9b6b6d3411 [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 (mod *Module) KernelHeadersDecorator() bool {
266 return false
267}
268
Colin Cross1f3f1302021-04-26 18:37:44 -0700269func (m *Module) NeedsLlndkVariants() bool {
Ivan Lozano3a7d0002021-03-30 12:19:36 -0400270 return false
271}
272
Colin Cross5271fea2021-04-27 13:06:04 -0700273func (m *Module) NeedsVendorPublicLibraryVariants() bool {
274 return false
275}
276
Ivan Lozano52767be2019-10-18 14:49:46 -0700277func (mod *Module) SdkVersion() string {
278 return ""
279}
280
Jiyong Parkfdaa5f72021-03-19 22:18:04 +0900281func (mod *Module) MinSdkVersion() string {
282 return ""
283}
284
Colin Crossc511bc52020-04-07 16:50:32 +0000285func (mod *Module) AlwaysSdk() bool {
286 return false
287}
288
Jiyong Park2286afd2020-06-16 21:58:53 +0900289func (mod *Module) IsSdkVariant() bool {
290 return false
291}
292
Colin Cross1348ce32020-10-01 13:37:16 -0700293func (mod *Module) SplitPerApiLevel() bool {
294 return false
295}
296
Ivan Lozanoffee3342019-08-27 12:03:00 -0700297type Deps struct {
Ivan Lozano63bb7682021-03-23 15:53:44 -0400298 Dylibs []string
299 Rlibs []string
300 Rustlibs []string
301 Stdlibs []string
302 ProcMacros []string
303 SharedLibs []string
304 StaticLibs []string
305 WholeStaticLibs []string
306 HeaderLibs []string
Ivan Lozanoffee3342019-08-27 12:03:00 -0700307
308 CrtBegin, CrtEnd string
309}
310
311type PathDeps struct {
Ivan Lozanoec6e9912021-01-21 15:23:29 -0500312 DyLibs RustLibraries
313 RLibs RustLibraries
314 SharedLibs android.Paths
315 SharedLibDeps android.Paths
316 StaticLibs android.Paths
317 ProcMacros RustLibraries
Ivan Lozano3dfa12d2021-02-04 11:29:41 -0500318
319 // depFlags and depLinkFlags are rustc and linker (clang) flags.
320 depFlags []string
321 depLinkFlags []string
322
323 // linkDirs are link paths passed via -L to rustc. linkObjects are objects passed directly to the linker.
324 // Both of these are exported and propagate to dependencies.
325 linkDirs []string
326 linkObjects []string
Ivan Lozanof1c84332019-09-20 11:00:37 -0700327
Ivan Lozano45901ed2020-07-24 16:05:01 -0400328 // Used by bindgen modules which call clang
329 depClangFlags []string
330 depIncludePaths android.Paths
Ivan Lozanoddd0bdb2020-08-28 17:00:26 -0400331 depGeneratedHeaders android.Paths
Ivan Lozano45901ed2020-07-24 16:05:01 -0400332 depSystemIncludePaths android.Paths
333
Ivan Lozanof1c84332019-09-20 11:00:37 -0700334 CrtBegin android.OptionalPath
335 CrtEnd android.OptionalPath
Chih-Hung Hsiehbbd25ae2020-05-15 17:36:30 -0700336
337 // Paths to generated source files
Ivan Lozano9d74a522020-12-01 09:25:22 -0500338 SrcDeps android.Paths
339 srcProviderFiles android.Paths
Ivan Lozanoffee3342019-08-27 12:03:00 -0700340}
341
342type RustLibraries []RustLibrary
343
344type RustLibrary struct {
345 Path android.Path
346 CrateName string
347}
348
349type compiler interface {
Thiébaud Weksteenee6a89b2021-02-25 16:30:57 +0100350 initialize(ctx ModuleContext)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700351 compilerFlags(ctx ModuleContext, flags Flags) Flags
352 compilerProps() []interface{}
353 compile(ctx ModuleContext, flags Flags, deps PathDeps) android.Path
354 compilerDeps(ctx DepsContext, deps Deps) Deps
355 crateName() string
Dan Albert06feee92021-03-19 15:06:02 -0700356 rustdoc(ctx ModuleContext, flags Flags, deps PathDeps) android.OptionalPath
Ivan Lozanoffee3342019-08-27 12:03:00 -0700357
Thiébaud Weksteenee6a89b2021-02-25 16:30:57 +0100358 // Output directory in which source-generated code from dependencies is
359 // copied. This is equivalent to Cargo's OUT_DIR variable.
360 CargoOutDir() android.OptionalPath
Dan Albert06feee92021-03-19 15:06:02 -0700361
Chih-Hung Hsieh9a4a7ba2019-12-12 19:36:05 -0800362 inData() bool
Thiébaud Weksteenfabaff62020-08-27 13:48:36 +0200363 install(ctx ModuleContext)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700364 relativeInstallPath() string
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400365
366 nativeCoverage() bool
Ivan Lozano26ecd6c2020-07-31 13:40:31 -0400367
368 Disabled() bool
369 SetDisabled()
Ivan Lozano042504f2020-08-18 14:31:23 -0400370
Ivan Lozanodd055472020-09-28 13:22:45 -0400371 stdLinkage(ctx *depsContext) RustLinkage
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500372 isDependencyRoot() bool
Jiyong Parke54f07e2021-04-07 15:08:04 +0900373
374 strippedOutputFilePath() android.OptionalPath
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400375}
376
Matthew Maurerbb3add12020-06-25 09:34:12 -0700377type exportedFlagsProducer interface {
Matthew Maurerbb3add12020-06-25 09:34:12 -0700378 exportLinkDirs(...string)
Ivan Lozano2093af22020-08-25 12:48:19 -0400379 exportLinkObjects(...string)
Matthew Maurerbb3add12020-06-25 09:34:12 -0700380}
381
382type flagExporter struct {
Ivan Lozano2093af22020-08-25 12:48:19 -0400383 linkDirs []string
384 linkObjects []string
Matthew Maurerbb3add12020-06-25 09:34:12 -0700385}
386
Matthew Maurerbb3add12020-06-25 09:34:12 -0700387func (flagExporter *flagExporter) exportLinkDirs(dirs ...string) {
388 flagExporter.linkDirs = android.FirstUniqueStrings(append(flagExporter.linkDirs, dirs...))
389}
390
Ivan Lozano2093af22020-08-25 12:48:19 -0400391func (flagExporter *flagExporter) exportLinkObjects(flags ...string) {
392 flagExporter.linkObjects = android.FirstUniqueStrings(append(flagExporter.linkObjects, flags...))
393}
394
Colin Cross0de8a1e2020-09-18 14:15:30 -0700395func (flagExporter *flagExporter) setProvider(ctx ModuleContext) {
396 ctx.SetProvider(FlagExporterInfoProvider, FlagExporterInfo{
Colin Cross0de8a1e2020-09-18 14:15:30 -0700397 LinkDirs: flagExporter.linkDirs,
398 LinkObjects: flagExporter.linkObjects,
399 })
400}
401
Matthew Maurerbb3add12020-06-25 09:34:12 -0700402var _ exportedFlagsProducer = (*flagExporter)(nil)
403
404func NewFlagExporter() *flagExporter {
Colin Cross0de8a1e2020-09-18 14:15:30 -0700405 return &flagExporter{}
Matthew Maurerbb3add12020-06-25 09:34:12 -0700406}
407
Colin Cross0de8a1e2020-09-18 14:15:30 -0700408type FlagExporterInfo struct {
409 Flags []string
410 LinkDirs []string // TODO: this should be android.Paths
411 LinkObjects []string // TODO: this should be android.Paths
412}
413
414var FlagExporterInfoProvider = blueprint.NewProvider(FlagExporterInfo{})
415
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400416func (mod *Module) isCoverageVariant() bool {
417 return mod.coverage.Properties.IsCoverageVariant
418}
419
420var _ cc.Coverage = (*Module)(nil)
421
422func (mod *Module) IsNativeCoverageNeeded(ctx android.BaseModuleContext) bool {
423 return mod.coverage != nil && mod.coverage.Properties.NeedCoverageVariant
424}
425
426func (mod *Module) PreventInstall() {
427 mod.Properties.PreventInstall = true
428}
429
430func (mod *Module) HideFromMake() {
431 mod.Properties.HideFromMake = true
432}
433
434func (mod *Module) MarkAsCoverageVariant(coverage bool) {
435 mod.coverage.Properties.IsCoverageVariant = coverage
436}
437
438func (mod *Module) EnableCoverageIfNeeded() {
439 mod.coverage.Properties.CoverageEnabled = mod.coverage.Properties.NeedCoverageBuild
Ivan Lozanoffee3342019-08-27 12:03:00 -0700440}
441
442func defaultsFactory() android.Module {
443 return DefaultsFactory()
444}
445
446type Defaults struct {
447 android.ModuleBase
448 android.DefaultsModuleBase
449}
450
451func DefaultsFactory(props ...interface{}) android.Module {
452 module := &Defaults{}
453
454 module.AddProperties(props...)
455 module.AddProperties(
456 &BaseProperties{},
Ivan Lozano6a884432020-12-02 09:15:16 -0500457 &cc.VendorProperties{},
Jakub Kotur1d640d02021-01-06 12:40:43 +0100458 &BenchmarkProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -0400459 &BindgenProperties{},
Ivan Lozanoffee3342019-08-27 12:03:00 -0700460 &BaseCompilerProperties{},
461 &BinaryCompilerProperties{},
462 &LibraryCompilerProperties{},
463 &ProcMacroCompilerProperties{},
464 &PrebuiltProperties{},
Ivan Lozano4fef93c2020-07-08 08:39:44 -0400465 &SourceProviderProperties{},
Chih-Hung Hsieh41805be2019-10-31 20:56:47 -0700466 &TestProperties{},
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400467 &cc.CoverageProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -0400468 &cc.RustBindgenClangProperties{},
Thiébaud Weksteen92f703b2020-06-22 13:28:02 +0200469 &ClippyProperties{},
Ivan Lozano6cd99e62020-02-11 08:24:25 -0500470 &SanitizeProperties{},
Ivan Lozanoffee3342019-08-27 12:03:00 -0700471 )
472
473 android.InitDefaultsModule(module)
474 return module
475}
476
477func (mod *Module) CrateName() string {
Ivan Lozanoad8b18b2019-10-31 19:38:29 -0700478 return mod.compiler.crateName()
Ivan Lozanoffee3342019-08-27 12:03:00 -0700479}
480
Ivan Lozano183a3212019-10-18 14:18:45 -0700481func (mod *Module) CcLibrary() bool {
482 if mod.compiler != nil {
483 if _, ok := mod.compiler.(*libraryDecorator); ok {
484 return true
485 }
486 }
487 return false
488}
489
490func (mod *Module) CcLibraryInterface() bool {
491 if mod.compiler != nil {
Ivan Lozano89435d12020-07-31 11:01:18 -0400492 // use build{Static,Shared}() instead of {static,shared}() here because this might be called before
493 // VariantIs{Static,Shared} is set.
494 if lib, ok := mod.compiler.(libraryInterface); ok && (lib.buildShared() || lib.buildStatic()) {
Ivan Lozano183a3212019-10-18 14:18:45 -0700495 return true
496 }
497 }
498 return false
499}
500
Ivan Lozanoe0833b12019-11-06 19:15:49 -0800501func (mod *Module) IncludeDirs() android.Paths {
Ivan Lozano183a3212019-10-18 14:18:45 -0700502 if mod.compiler != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700503 if library, ok := mod.compiler.(*libraryDecorator); ok {
Ivan Lozanoe0833b12019-11-06 19:15:49 -0800504 return library.includeDirs
Ivan Lozano183a3212019-10-18 14:18:45 -0700505 }
506 }
507 panic(fmt.Errorf("IncludeDirs called on non-library module: %q", mod.BaseModuleName()))
508}
509
510func (mod *Module) SetStatic() {
511 if mod.compiler != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700512 if library, ok := mod.compiler.(libraryInterface); ok {
513 library.setStatic()
Ivan Lozano183a3212019-10-18 14:18:45 -0700514 return
515 }
516 }
517 panic(fmt.Errorf("SetStatic called on non-library module: %q", mod.BaseModuleName()))
518}
519
520func (mod *Module) SetShared() {
521 if mod.compiler != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700522 if library, ok := mod.compiler.(libraryInterface); ok {
523 library.setShared()
Ivan Lozano183a3212019-10-18 14:18:45 -0700524 return
525 }
526 }
527 panic(fmt.Errorf("SetShared called on non-library module: %q", mod.BaseModuleName()))
528}
529
Ivan Lozano183a3212019-10-18 14:18:45 -0700530func (mod *Module) BuildStaticVariant() bool {
531 if mod.compiler != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700532 if library, ok := mod.compiler.(libraryInterface); ok {
533 return library.buildStatic()
Ivan Lozano183a3212019-10-18 14:18:45 -0700534 }
535 }
536 panic(fmt.Errorf("BuildStaticVariant called on non-library module: %q", mod.BaseModuleName()))
537}
538
539func (mod *Module) BuildSharedVariant() bool {
540 if mod.compiler != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700541 if library, ok := mod.compiler.(libraryInterface); ok {
542 return library.buildShared()
Ivan Lozano183a3212019-10-18 14:18:45 -0700543 }
544 }
545 panic(fmt.Errorf("BuildSharedVariant called on non-library module: %q", mod.BaseModuleName()))
546}
547
Ivan Lozano183a3212019-10-18 14:18:45 -0700548func (mod *Module) Module() android.Module {
549 return mod
550}
551
Ivan Lozano183a3212019-10-18 14:18:45 -0700552func (mod *Module) OutputFile() android.OptionalPath {
Jiyong Parke54f07e2021-04-07 15:08:04 +0900553 if mod.compiler != nil && mod.compiler.strippedOutputFilePath().Valid() {
554 return mod.compiler.strippedOutputFilePath()
555 }
556 return mod.unstrippedOutputFile
Ivan Lozano183a3212019-10-18 14:18:45 -0700557}
558
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400559func (mod *Module) CoverageFiles() android.Paths {
560 if mod.compiler != nil {
Joel Galensonfa049382021-01-14 16:03:18 -0800561 return android.Paths{}
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400562 }
563 panic(fmt.Errorf("CoverageFiles called on non-library module: %q", mod.BaseModuleName()))
564}
565
Jiyong Park459feca2020-12-15 11:02:21 +0900566func (mod *Module) installable(apexInfo android.ApexInfo) bool {
567 // The apex variant is not installable because it is included in the APEX and won't appear
568 // in the system partition as a standalone file.
569 if !apexInfo.IsForPlatform() {
570 return false
571 }
572
Jiyong Parke54f07e2021-04-07 15:08:04 +0900573 return mod.OutputFile().Valid() && !mod.Properties.PreventInstall
Jiyong Park459feca2020-12-15 11:02:21 +0900574}
575
Ivan Lozano183a3212019-10-18 14:18:45 -0700576var _ cc.LinkableInterface = (*Module)(nil)
577
Ivan Lozanoffee3342019-08-27 12:03:00 -0700578func (mod *Module) Init() android.Module {
579 mod.AddProperties(&mod.Properties)
Ivan Lozano6a884432020-12-02 09:15:16 -0500580 mod.AddProperties(&mod.VendorProperties)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700581
582 if mod.compiler != nil {
583 mod.AddProperties(mod.compiler.compilerProps()...)
584 }
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400585 if mod.coverage != nil {
586 mod.AddProperties(mod.coverage.props()...)
587 }
Thiébaud Weksteen92f703b2020-06-22 13:28:02 +0200588 if mod.clippy != nil {
589 mod.AddProperties(mod.clippy.props()...)
590 }
Ivan Lozano4fef93c2020-07-08 08:39:44 -0400591 if mod.sourceProvider != nil {
Andrei Homescuc7767922020-08-05 06:36:19 -0700592 mod.AddProperties(mod.sourceProvider.SourceProviderProps()...)
Ivan Lozano4fef93c2020-07-08 08:39:44 -0400593 }
Ivan Lozano6cd99e62020-02-11 08:24:25 -0500594 if mod.sanitize != nil {
595 mod.AddProperties(mod.sanitize.props()...)
596 }
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400597
Ivan Lozanoffee3342019-08-27 12:03:00 -0700598 android.InitAndroidArchModule(mod, mod.hod, mod.multilib)
Jiyong Park99644e92020-11-17 22:21:02 +0900599 android.InitApexModule(mod)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700600
601 android.InitDefaultableModule(mod)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700602 return mod
603}
604
605func newBaseModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
606 return &Module{
607 hod: hod,
608 multilib: multilib,
609 }
610}
611func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
612 module := newBaseModule(hod, multilib)
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400613 module.coverage = &coverage{}
Thiébaud Weksteen92f703b2020-06-22 13:28:02 +0200614 module.clippy = &clippy{}
Ivan Lozano6cd99e62020-02-11 08:24:25 -0500615 module.sanitize = &sanitize{}
Ivan Lozanoffee3342019-08-27 12:03:00 -0700616 return module
617}
618
619type ModuleContext interface {
620 android.ModuleContext
621 ModuleContextIntf
622}
623
624type BaseModuleContext interface {
625 android.BaseModuleContext
626 ModuleContextIntf
627}
628
629type DepsContext interface {
630 android.BottomUpMutatorContext
631 ModuleContextIntf
632}
633
634type ModuleContextIntf interface {
Thiébaud Weksteen1f7f70f2020-06-24 11:32:48 +0200635 RustModule() *Module
Ivan Lozanoffee3342019-08-27 12:03:00 -0700636 toolchain() config.Toolchain
Ivan Lozanoffee3342019-08-27 12:03:00 -0700637}
638
639type depsContext struct {
640 android.BottomUpMutatorContext
Ivan Lozanoffee3342019-08-27 12:03:00 -0700641}
642
643type moduleContext struct {
644 android.ModuleContext
Ivan Lozanoffee3342019-08-27 12:03:00 -0700645}
646
Thiébaud Weksteen1f7f70f2020-06-24 11:32:48 +0200647type baseModuleContext struct {
648 android.BaseModuleContext
649}
650
651func (ctx *moduleContext) RustModule() *Module {
652 return ctx.Module().(*Module)
653}
654
655func (ctx *moduleContext) toolchain() config.Toolchain {
656 return ctx.RustModule().toolchain(ctx)
657}
658
659func (ctx *depsContext) RustModule() *Module {
660 return ctx.Module().(*Module)
661}
662
663func (ctx *depsContext) toolchain() config.Toolchain {
664 return ctx.RustModule().toolchain(ctx)
665}
666
667func (ctx *baseModuleContext) RustModule() *Module {
668 return ctx.Module().(*Module)
669}
670
671func (ctx *baseModuleContext) toolchain() config.Toolchain {
672 return ctx.RustModule().toolchain(ctx)
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400673}
674
675func (mod *Module) nativeCoverage() bool {
676 return mod.compiler != nil && mod.compiler.nativeCoverage()
677}
678
Ivan Lozanoffee3342019-08-27 12:03:00 -0700679func (mod *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
680 if mod.cachedToolchain == nil {
681 mod.cachedToolchain = config.FindToolchain(ctx.Os(), ctx.Arch())
682 }
683 return mod.cachedToolchain
684}
685
Thiébaud Weksteen31f1bb82020-08-27 13:37:29 +0200686func (mod *Module) ccToolchain(ctx android.BaseModuleContext) cc_config.Toolchain {
687 return cc_config.FindToolchain(ctx.Os(), ctx.Arch())
688}
689
Ivan Lozanoffee3342019-08-27 12:03:00 -0700690func (d *Defaults) GenerateAndroidBuildActions(ctx android.ModuleContext) {
691}
692
693func (mod *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
694 ctx := &moduleContext{
695 ModuleContext: actx,
Ivan Lozanoffee3342019-08-27 12:03:00 -0700696 }
Ivan Lozanoffee3342019-08-27 12:03:00 -0700697
Jiyong Park99644e92020-11-17 22:21:02 +0900698 apexInfo := actx.Provider(android.ApexInfoProvider).(android.ApexInfo)
699 if !apexInfo.IsForPlatform() {
700 mod.hideApexVariantFromMake = true
701 }
702
Ivan Lozanoffee3342019-08-27 12:03:00 -0700703 toolchain := mod.toolchain(ctx)
Ivan Lozano6a884432020-12-02 09:15:16 -0500704 mod.makeLinkType = cc.GetMakeLinkType(actx, mod)
705
706 // Differentiate static libraries that are vendor available
707 if mod.UseVndk() {
Ivan Lozanoe6d30982021-02-05 10:57:43 -0500708 mod.Properties.SubName += cc.VendorSuffix
709 } else if mod.InVendorRamdisk() && !mod.OnlyInVendorRamdisk() {
710 mod.Properties.SubName += cc.VendorRamdiskSuffix
Ivan Lozano6a884432020-12-02 09:15:16 -0500711 }
Ivan Lozanoffee3342019-08-27 12:03:00 -0700712
713 if !toolchain.Supported() {
714 // This toolchain's unsupported, there's nothing to do for this mod.
715 return
716 }
717
718 deps := mod.depsToPaths(ctx)
719 flags := Flags{
720 Toolchain: toolchain,
721 }
722
723 if mod.compiler != nil {
724 flags = mod.compiler.compilerFlags(ctx, flags)
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400725 }
726 if mod.coverage != nil {
727 flags, deps = mod.coverage.flags(ctx, flags, deps)
728 }
Thiébaud Weksteen92f703b2020-06-22 13:28:02 +0200729 if mod.clippy != nil {
730 flags, deps = mod.clippy.flags(ctx, flags, deps)
731 }
Ivan Lozano6cd99e62020-02-11 08:24:25 -0500732 if mod.sanitize != nil {
733 flags, deps = mod.sanitize.flags(ctx, flags, deps)
734 }
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400735
Thiébaud Weksteen295c72b2020-09-23 18:10:17 +0200736 // SourceProvider needs to call GenerateSource() before compiler calls
737 // compile() so it can provide the source. A SourceProvider has
738 // multiple variants (e.g. source, rlib, dylib). Only the "source"
739 // variant is responsible for effectively generating the source. The
740 // remaining variants relies on the "source" variant output.
Ivan Lozano26ecd6c2020-07-31 13:40:31 -0400741 if mod.sourceProvider != nil {
Thiébaud Weksteen295c72b2020-09-23 18:10:17 +0200742 if mod.compiler.(libraryInterface).source() {
743 mod.sourceProvider.GenerateSource(ctx, deps)
744 mod.sourceProvider.setSubName(ctx.ModuleSubDir())
745 } else {
746 sourceMod := actx.GetDirectDepWithTag(mod.Name(), sourceDepTag)
747 sourceLib := sourceMod.(*Module).compiler.(*libraryDecorator)
Chih-Hung Hsiehc49649c2020-10-01 21:25:05 -0700748 mod.sourceProvider.setOutputFiles(sourceLib.sourceProvider.Srcs())
Thiébaud Weksteen295c72b2020-09-23 18:10:17 +0200749 }
Ivan Lozano26ecd6c2020-07-31 13:40:31 -0400750 }
751
752 if mod.compiler != nil && !mod.compiler.Disabled() {
Thiébaud Weksteenee6a89b2021-02-25 16:30:57 +0100753 mod.compiler.initialize(ctx)
Jiyong Parke54f07e2021-04-07 15:08:04 +0900754 unstrippedOutputFile := mod.compiler.compile(ctx, flags, deps)
Jiyong Parke54f07e2021-04-07 15:08:04 +0900755 mod.unstrippedOutputFile = android.OptionalPathForPath(unstrippedOutputFile)
Thiébaud Weksteene4dd14b2021-04-14 11:18:47 +0200756 bloaty.MeasureSizeForPaths(ctx, mod.compiler.strippedOutputFilePath(), mod.unstrippedOutputFile)
Jiyong Park459feca2020-12-15 11:02:21 +0900757
Dan Albert06feee92021-03-19 15:06:02 -0700758 mod.docTimestampFile = mod.compiler.rustdoc(ctx, flags, deps)
759
Jiyong Park459feca2020-12-15 11:02:21 +0900760 apexInfo := actx.Provider(android.ApexInfoProvider).(android.ApexInfo)
761 if mod.installable(apexInfo) {
Thiébaud Weksteenfabaff62020-08-27 13:48:36 +0200762 mod.compiler.install(ctx)
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400763 }
Ivan Lozanoffee3342019-08-27 12:03:00 -0700764 }
765}
766
767func (mod *Module) deps(ctx DepsContext) Deps {
768 deps := Deps{}
769
770 if mod.compiler != nil {
771 deps = mod.compiler.compilerDeps(ctx, deps)
Ivan Lozano26ecd6c2020-07-31 13:40:31 -0400772 }
773 if mod.sourceProvider != nil {
Andrei Homescuc7767922020-08-05 06:36:19 -0700774 deps = mod.sourceProvider.SourceProviderDeps(ctx, deps)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700775 }
776
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400777 if mod.coverage != nil {
778 deps = mod.coverage.deps(ctx, deps)
779 }
780
Ivan Lozano6cd99e62020-02-11 08:24:25 -0500781 if mod.sanitize != nil {
782 deps = mod.sanitize.deps(ctx, deps)
783 }
784
Ivan Lozanoffee3342019-08-27 12:03:00 -0700785 deps.Rlibs = android.LastUniqueStrings(deps.Rlibs)
786 deps.Dylibs = android.LastUniqueStrings(deps.Dylibs)
Matthew Maurer0f003b12020-06-29 14:34:06 -0700787 deps.Rustlibs = android.LastUniqueStrings(deps.Rustlibs)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700788 deps.ProcMacros = android.LastUniqueStrings(deps.ProcMacros)
789 deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
790 deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
Ivan Lozano63bb7682021-03-23 15:53:44 -0400791 deps.WholeStaticLibs = android.LastUniqueStrings(deps.WholeStaticLibs)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700792 return deps
793
794}
795
Ivan Lozanoffee3342019-08-27 12:03:00 -0700796type dependencyTag struct {
797 blueprint.BaseDependencyTag
Jaewoong Jung18aefc12020-12-21 09:11:10 -0800798 name string
799 library bool
800 procMacro bool
Ivan Lozanoffee3342019-08-27 12:03:00 -0700801}
802
Jiyong Park65b62242020-11-25 12:44:59 +0900803// InstallDepNeeded returns true for rlibs, dylibs, and proc macros so that they or their transitive
804// dependencies (especially C/C++ shared libs) are installed as dependencies of a rust binary.
805func (d dependencyTag) InstallDepNeeded() bool {
Jaewoong Jung18aefc12020-12-21 09:11:10 -0800806 return d.library || d.procMacro
Jiyong Park65b62242020-11-25 12:44:59 +0900807}
808
809var _ android.InstallNeededDependencyTag = dependencyTag{}
810
Ivan Lozanoffee3342019-08-27 12:03:00 -0700811var (
Ivan Lozanoc564d2d2020-08-04 15:43:37 -0400812 customBindgenDepTag = dependencyTag{name: "customBindgenTag"}
813 rlibDepTag = dependencyTag{name: "rlibTag", library: true}
814 dylibDepTag = dependencyTag{name: "dylib", library: true}
Jaewoong Jung18aefc12020-12-21 09:11:10 -0800815 procMacroDepTag = dependencyTag{name: "procMacro", procMacro: true}
Ivan Lozanoc564d2d2020-08-04 15:43:37 -0400816 testPerSrcDepTag = dependencyTag{name: "rust_unit_tests"}
Thiébaud Weksteen295c72b2020-09-23 18:10:17 +0200817 sourceDepTag = dependencyTag{name: "source"}
Ivan Lozanoffee3342019-08-27 12:03:00 -0700818)
819
Jiyong Park99644e92020-11-17 22:21:02 +0900820func IsDylibDepTag(depTag blueprint.DependencyTag) bool {
821 tag, ok := depTag.(dependencyTag)
822 return ok && tag == dylibDepTag
823}
824
Jiyong Park94e22fd2021-04-08 18:19:15 +0900825func IsRlibDepTag(depTag blueprint.DependencyTag) bool {
826 tag, ok := depTag.(dependencyTag)
827 return ok && tag == rlibDepTag
828}
829
Matthew Maurer0f003b12020-06-29 14:34:06 -0700830type autoDep struct {
831 variation string
832 depTag dependencyTag
833}
834
835var (
Thiébaud Weksteen295c72b2020-09-23 18:10:17 +0200836 rlibVariation = "rlib"
837 dylibVariation = "dylib"
838 rlibAutoDep = autoDep{variation: rlibVariation, depTag: rlibDepTag}
839 dylibAutoDep = autoDep{variation: dylibVariation, depTag: dylibDepTag}
Matthew Maurer0f003b12020-06-29 14:34:06 -0700840)
841
842type autoDeppable interface {
Liz Kammer356f7d42021-01-26 09:18:53 -0500843 autoDep(ctx android.BottomUpMutatorContext) autoDep
Matthew Maurer0f003b12020-06-29 14:34:06 -0700844}
845
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400846func (mod *Module) begin(ctx BaseModuleContext) {
847 if mod.coverage != nil {
848 mod.coverage.begin(ctx)
849 }
Ivan Lozano6cd99e62020-02-11 08:24:25 -0500850 if mod.sanitize != nil {
851 mod.sanitize.begin(ctx)
852 }
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400853}
854
Ivan Lozanoffee3342019-08-27 12:03:00 -0700855func (mod *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
856 var depPaths PathDeps
857
858 directRlibDeps := []*Module{}
859 directDylibDeps := []*Module{}
860 directProcMacroDeps := []*Module{}
Ivan Lozano52767be2019-10-18 14:49:46 -0700861 directSharedLibDeps := [](cc.LinkableInterface){}
862 directStaticLibDeps := [](cc.LinkableInterface){}
Ivan Lozano07cbaf42020-07-22 16:09:13 -0400863 directSrcProvidersDeps := []*Module{}
864 directSrcDeps := [](android.SourceFileProducer){}
Ivan Lozanoffee3342019-08-27 12:03:00 -0700865
866 ctx.VisitDirectDeps(func(dep android.Module) {
867 depName := ctx.OtherModuleName(dep)
868 depTag := ctx.OtherModuleDependencyTag(dep)
Ivan Lozanoc08897c2021-04-02 12:41:32 -0400869
Ivan Lozano89435d12020-07-31 11:01:18 -0400870 if rustDep, ok := dep.(*Module); ok && !rustDep.CcLibraryInterface() {
Ivan Lozanoffee3342019-08-27 12:03:00 -0700871 //Handle Rust Modules
Ivan Lozanoc08897c2021-04-02 12:41:32 -0400872 makeLibName := cc.MakeLibName(ctx, mod, rustDep, depName+rustDep.Properties.RustSubName)
Ivan Lozano70e0a072019-09-13 14:23:15 -0700873
Ivan Lozanoffee3342019-08-27 12:03:00 -0700874 switch depTag {
875 case dylibDepTag:
876 dylib, ok := rustDep.compiler.(libraryInterface)
877 if !ok || !dylib.dylib() {
878 ctx.ModuleErrorf("mod %q not an dylib library", depName)
879 return
880 }
881 directDylibDeps = append(directDylibDeps, rustDep)
Ivan Lozanoc08897c2021-04-02 12:41:32 -0400882 mod.Properties.AndroidMkDylibs = append(mod.Properties.AndroidMkDylibs, makeLibName)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700883 case rlibDepTag:
Ivan Lozano2b081132020-09-08 12:46:52 -0400884
Ivan Lozanoffee3342019-08-27 12:03:00 -0700885 rlib, ok := rustDep.compiler.(libraryInterface)
886 if !ok || !rlib.rlib() {
Ivan Lozanoc08897c2021-04-02 12:41:32 -0400887 ctx.ModuleErrorf("mod %q not an rlib library", makeLibName)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700888 return
889 }
890 directRlibDeps = append(directRlibDeps, rustDep)
Ivan Lozanoc08897c2021-04-02 12:41:32 -0400891 mod.Properties.AndroidMkRlibs = append(mod.Properties.AndroidMkRlibs, makeLibName)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700892 case procMacroDepTag:
893 directProcMacroDeps = append(directProcMacroDeps, rustDep)
Ivan Lozanoc08897c2021-04-02 12:41:32 -0400894 mod.Properties.AndroidMkProcMacroLibs = append(mod.Properties.AndroidMkProcMacroLibs, makeLibName)
Ivan Lozano07cbaf42020-07-22 16:09:13 -0400895 case android.SourceDepTag:
896 // Since these deps are added in path_properties.go via AddDependencies, we need to ensure the correct
897 // OS/Arch variant is used.
898 var helper string
899 if ctx.Host() {
900 helper = "missing 'host_supported'?"
901 } else {
902 helper = "device module defined?"
903 }
904
905 if dep.Target().Os != ctx.Os() {
906 ctx.ModuleErrorf("OS mismatch on dependency %q (%s)", dep.Name(), helper)
907 return
908 } else if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
909 ctx.ModuleErrorf("Arch mismatch on dependency %q (%s)", dep.Name(), helper)
910 return
911 }
912 directSrcProvidersDeps = append(directSrcProvidersDeps, rustDep)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700913 }
914
Ivan Lozano2bbcacf2020-08-07 09:00:50 -0400915 //Append the dependencies exportedDirs, except for proc-macros which target a different arch/OS
Colin Cross0de8a1e2020-09-18 14:15:30 -0700916 if depTag != procMacroDepTag {
917 exportedInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
918 depPaths.linkDirs = append(depPaths.linkDirs, exportedInfo.LinkDirs...)
919 depPaths.depFlags = append(depPaths.depFlags, exportedInfo.Flags...)
920 depPaths.linkObjects = append(depPaths.linkObjects, exportedInfo.LinkObjects...)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700921 }
922
Ivan Lozanoffee3342019-08-27 12:03:00 -0700923 if depTag == dylibDepTag || depTag == rlibDepTag || depTag == procMacroDepTag {
Jiyong Parke54f07e2021-04-07 15:08:04 +0900924 linkFile := rustDep.unstrippedOutputFile
Ivan Lozano26ecd6c2020-07-31 13:40:31 -0400925 if !linkFile.Valid() {
926 ctx.ModuleErrorf("Invalid output file when adding dep %q to %q",
927 depName, ctx.ModuleName())
928 return
929 }
Ivan Lozanoffee3342019-08-27 12:03:00 -0700930 linkDir := linkPathFromFilePath(linkFile.Path())
Matthew Maurerbb3add12020-06-25 09:34:12 -0700931 if lib, ok := mod.compiler.(exportedFlagsProducer); ok {
932 lib.exportLinkDirs(linkDir)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700933 }
934 }
935
Ivan Lozano89435d12020-07-31 11:01:18 -0400936 } else if ccDep, ok := dep.(cc.LinkableInterface); ok {
Ivan Lozano52767be2019-10-18 14:49:46 -0700937 //Handle C dependencies
Ivan Lozanoc08897c2021-04-02 12:41:32 -0400938 makeLibName := cc.MakeLibName(ctx, mod, ccDep, depName)
Ivan Lozano52767be2019-10-18 14:49:46 -0700939 if _, ok := ccDep.(*Module); !ok {
940 if ccDep.Module().Target().Os != ctx.Os() {
941 ctx.ModuleErrorf("OS mismatch between %q and %q", ctx.ModuleName(), depName)
942 return
943 }
944 if ccDep.Module().Target().Arch.ArchType != ctx.Arch().ArchType {
945 ctx.ModuleErrorf("Arch mismatch between %q and %q", ctx.ModuleName(), depName)
946 return
947 }
Ivan Lozano70e0a072019-09-13 14:23:15 -0700948 }
Ivan Lozano2093af22020-08-25 12:48:19 -0400949 linkObject := ccDep.OutputFile()
950 linkPath := linkPathFromFilePath(linkObject.Path())
Ivan Lozano6aa66022020-02-06 13:22:43 -0500951
Ivan Lozano2093af22020-08-25 12:48:19 -0400952 if !linkObject.Valid() {
Ivan Lozanoffee3342019-08-27 12:03:00 -0700953 ctx.ModuleErrorf("Invalid output file when adding dep %q to %q", depName, ctx.ModuleName())
954 }
955
956 exportDep := false
Colin Cross6e511a92020-07-27 21:26:48 -0700957 switch {
958 case cc.IsStaticDepTag(depTag):
Ivan Lozano63bb7682021-03-23 15:53:44 -0400959 if cc.IsWholeStaticLib(depTag) {
960 // rustc will bundle static libraries when they're passed with "-lstatic=<lib>". This will fail
961 // if the library is not prefixed by "lib".
Ivan Lozanofb6f36f2021-02-05 12:27:08 -0500962 if libName, ok := libNameFromFilePath(linkObject.Path()); ok {
963 depPaths.depFlags = append(depPaths.depFlags, "-lstatic="+libName)
Ivan Lozano63bb7682021-03-23 15:53:44 -0400964 } else {
965 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 -0500966 }
Ivan Lozano3dfa12d2021-02-04 11:29:41 -0500967 }
968
969 // Add this to linkObjects to pass the library directly to the linker as well. This propagates
970 // to dependencies to avoid having to redeclare static libraries for dependents of the dylib variant.
Ivan Lozano2093af22020-08-25 12:48:19 -0400971 depPaths.linkObjects = append(depPaths.linkObjects, linkObject.String())
Ivan Lozano3dfa12d2021-02-04 11:29:41 -0500972 depPaths.linkDirs = append(depPaths.linkDirs, linkPath)
973
Colin Cross0de8a1e2020-09-18 14:15:30 -0700974 exportedInfo := ctx.OtherModuleProvider(dep, cc.FlagExporterInfoProvider).(cc.FlagExporterInfo)
975 depPaths.depIncludePaths = append(depPaths.depIncludePaths, exportedInfo.IncludeDirs...)
976 depPaths.depSystemIncludePaths = append(depPaths.depSystemIncludePaths, exportedInfo.SystemIncludeDirs...)
977 depPaths.depClangFlags = append(depPaths.depClangFlags, exportedInfo.Flags...)
978 depPaths.depGeneratedHeaders = append(depPaths.depGeneratedHeaders, exportedInfo.GeneratedHeaders...)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700979 directStaticLibDeps = append(directStaticLibDeps, ccDep)
Ivan Lozanoc08897c2021-04-02 12:41:32 -0400980 mod.Properties.AndroidMkStaticLibs = append(mod.Properties.AndroidMkStaticLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -0700981 case cc.IsSharedDepTag(depTag):
Ivan Lozanoffee3342019-08-27 12:03:00 -0700982 depPaths.linkDirs = append(depPaths.linkDirs, linkPath)
Ivan Lozano2093af22020-08-25 12:48:19 -0400983 depPaths.linkObjects = append(depPaths.linkObjects, linkObject.String())
Colin Cross0de8a1e2020-09-18 14:15:30 -0700984 exportedInfo := ctx.OtherModuleProvider(dep, cc.FlagExporterInfoProvider).(cc.FlagExporterInfo)
985 depPaths.depIncludePaths = append(depPaths.depIncludePaths, exportedInfo.IncludeDirs...)
986 depPaths.depSystemIncludePaths = append(depPaths.depSystemIncludePaths, exportedInfo.SystemIncludeDirs...)
987 depPaths.depClangFlags = append(depPaths.depClangFlags, exportedInfo.Flags...)
988 depPaths.depGeneratedHeaders = append(depPaths.depGeneratedHeaders, exportedInfo.GeneratedHeaders...)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700989 directSharedLibDeps = append(directSharedLibDeps, ccDep)
Ivan Lozanoc08897c2021-04-02 12:41:32 -0400990 mod.Properties.AndroidMkSharedLibs = append(mod.Properties.AndroidMkSharedLibs, makeLibName)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700991 exportDep = true
Zach Johnson3df4e632020-11-06 11:56:27 -0800992 case cc.IsHeaderDepTag(depTag):
993 exportedInfo := ctx.OtherModuleProvider(dep, cc.FlagExporterInfoProvider).(cc.FlagExporterInfo)
994 depPaths.depIncludePaths = append(depPaths.depIncludePaths, exportedInfo.IncludeDirs...)
995 depPaths.depSystemIncludePaths = append(depPaths.depSystemIncludePaths, exportedInfo.SystemIncludeDirs...)
996 depPaths.depGeneratedHeaders = append(depPaths.depGeneratedHeaders, exportedInfo.GeneratedHeaders...)
Colin Cross6e511a92020-07-27 21:26:48 -0700997 case depTag == cc.CrtBeginDepTag:
Ivan Lozano2093af22020-08-25 12:48:19 -0400998 depPaths.CrtBegin = linkObject
Colin Cross6e511a92020-07-27 21:26:48 -0700999 case depTag == cc.CrtEndDepTag:
Ivan Lozano2093af22020-08-25 12:48:19 -04001000 depPaths.CrtEnd = linkObject
Ivan Lozanoffee3342019-08-27 12:03:00 -07001001 }
1002
1003 // Make sure these dependencies are propagated
Matthew Maurerbb3add12020-06-25 09:34:12 -07001004 if lib, ok := mod.compiler.(exportedFlagsProducer); ok && exportDep {
1005 lib.exportLinkDirs(linkPath)
Ivan Lozano2093af22020-08-25 12:48:19 -04001006 lib.exportLinkObjects(linkObject.String())
Ivan Lozanoffee3342019-08-27 12:03:00 -07001007 }
Ivan Lozanoffee3342019-08-27 12:03:00 -07001008 }
Ivan Lozano89435d12020-07-31 11:01:18 -04001009
1010 if srcDep, ok := dep.(android.SourceFileProducer); ok {
1011 switch depTag {
1012 case android.SourceDepTag:
1013 // These are usually genrules which don't have per-target variants.
1014 directSrcDeps = append(directSrcDeps, srcDep)
1015 }
1016 }
Ivan Lozanoffee3342019-08-27 12:03:00 -07001017 })
1018
1019 var rlibDepFiles RustLibraries
1020 for _, dep := range directRlibDeps {
Jiyong Parke54f07e2021-04-07 15:08:04 +09001021 rlibDepFiles = append(rlibDepFiles, RustLibrary{Path: dep.unstrippedOutputFile.Path(), CrateName: dep.CrateName()})
Ivan Lozanoffee3342019-08-27 12:03:00 -07001022 }
1023 var dylibDepFiles RustLibraries
1024 for _, dep := range directDylibDeps {
Jiyong Parke54f07e2021-04-07 15:08:04 +09001025 dylibDepFiles = append(dylibDepFiles, RustLibrary{Path: dep.unstrippedOutputFile.Path(), CrateName: dep.CrateName()})
Ivan Lozanoffee3342019-08-27 12:03:00 -07001026 }
1027 var procMacroDepFiles RustLibraries
1028 for _, dep := range directProcMacroDeps {
Jiyong Parke54f07e2021-04-07 15:08:04 +09001029 procMacroDepFiles = append(procMacroDepFiles, RustLibrary{Path: dep.unstrippedOutputFile.Path(), CrateName: dep.CrateName()})
Ivan Lozanoffee3342019-08-27 12:03:00 -07001030 }
1031
1032 var staticLibDepFiles android.Paths
1033 for _, dep := range directStaticLibDeps {
1034 staticLibDepFiles = append(staticLibDepFiles, dep.OutputFile().Path())
1035 }
1036
Ivan Lozanoec6e9912021-01-21 15:23:29 -05001037 var sharedLibFiles android.Paths
Ivan Lozanoffee3342019-08-27 12:03:00 -07001038 var sharedLibDepFiles android.Paths
1039 for _, dep := range directSharedLibDeps {
Ivan Lozanoec6e9912021-01-21 15:23:29 -05001040 sharedLibFiles = append(sharedLibFiles, dep.OutputFile().Path())
1041 if dep.Toc().Valid() {
1042 sharedLibDepFiles = append(sharedLibDepFiles, dep.Toc().Path())
1043 } else {
1044 sharedLibDepFiles = append(sharedLibDepFiles, dep.OutputFile().Path())
1045 }
Ivan Lozanoffee3342019-08-27 12:03:00 -07001046 }
1047
Ivan Lozano07cbaf42020-07-22 16:09:13 -04001048 var srcProviderDepFiles android.Paths
1049 for _, dep := range directSrcProvidersDeps {
1050 srcs, _ := dep.OutputFiles("")
1051 srcProviderDepFiles = append(srcProviderDepFiles, srcs...)
1052 }
1053 for _, dep := range directSrcDeps {
1054 srcs := dep.Srcs()
1055 srcProviderDepFiles = append(srcProviderDepFiles, srcs...)
1056 }
1057
Ivan Lozanoffee3342019-08-27 12:03:00 -07001058 depPaths.RLibs = append(depPaths.RLibs, rlibDepFiles...)
1059 depPaths.DyLibs = append(depPaths.DyLibs, dylibDepFiles...)
1060 depPaths.SharedLibs = append(depPaths.SharedLibs, sharedLibDepFiles...)
Ivan Lozanoec6e9912021-01-21 15:23:29 -05001061 depPaths.SharedLibDeps = append(depPaths.SharedLibDeps, sharedLibDepFiles...)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001062 depPaths.StaticLibs = append(depPaths.StaticLibs, staticLibDepFiles...)
1063 depPaths.ProcMacros = append(depPaths.ProcMacros, procMacroDepFiles...)
Ivan Lozano07cbaf42020-07-22 16:09:13 -04001064 depPaths.SrcDeps = append(depPaths.SrcDeps, srcProviderDepFiles...)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001065
1066 // Dedup exported flags from dependencies
1067 depPaths.linkDirs = android.FirstUniqueStrings(depPaths.linkDirs)
Ivan Lozanoec6e9912021-01-21 15:23:29 -05001068 depPaths.linkObjects = android.FirstUniqueStrings(depPaths.linkObjects)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001069 depPaths.depFlags = android.FirstUniqueStrings(depPaths.depFlags)
Ivan Lozano45901ed2020-07-24 16:05:01 -04001070 depPaths.depClangFlags = android.FirstUniqueStrings(depPaths.depClangFlags)
1071 depPaths.depIncludePaths = android.FirstUniquePaths(depPaths.depIncludePaths)
1072 depPaths.depSystemIncludePaths = android.FirstUniquePaths(depPaths.depSystemIncludePaths)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001073
1074 return depPaths
1075}
1076
Chih-Hung Hsieh9a4a7ba2019-12-12 19:36:05 -08001077func (mod *Module) InstallInData() bool {
1078 if mod.compiler == nil {
1079 return false
1080 }
1081 return mod.compiler.inData()
1082}
1083
Ivan Lozanoffee3342019-08-27 12:03:00 -07001084func linkPathFromFilePath(filepath android.Path) string {
1085 return strings.Split(filepath.String(), filepath.Base())[0]
1086}
Ivan Lozanod648c432020-02-06 12:05:10 -05001087
Ivan Lozanoffee3342019-08-27 12:03:00 -07001088func (mod *Module) DepsMutator(actx android.BottomUpMutatorContext) {
1089 ctx := &depsContext{
1090 BottomUpMutatorContext: actx,
Ivan Lozanoffee3342019-08-27 12:03:00 -07001091 }
Ivan Lozanoffee3342019-08-27 12:03:00 -07001092
1093 deps := mod.deps(ctx)
Colin Cross3146c5c2020-09-30 15:34:40 -07001094 var commonDepVariations []blueprint.Variation
Ivan Lozanodd055472020-09-28 13:22:45 -04001095
Ivan Lozano2b081132020-09-08 12:46:52 -04001096 stdLinkage := "dylib-std"
Ivan Lozanodd055472020-09-28 13:22:45 -04001097 if mod.compiler.stdLinkage(ctx) == RlibLinkage {
Ivan Lozano2b081132020-09-08 12:46:52 -04001098 stdLinkage = "rlib-std"
1099 }
1100
1101 rlibDepVariations := commonDepVariations
1102 if lib, ok := mod.compiler.(libraryInterface); !ok || !lib.sysroot() {
1103 rlibDepVariations = append(rlibDepVariations,
1104 blueprint.Variation{Mutator: "rust_stdlinkage", Variation: stdLinkage})
1105 }
1106
Ivan Lozano52767be2019-10-18 14:49:46 -07001107 actx.AddVariationDependencies(
Ivan Lozano2b081132020-09-08 12:46:52 -04001108 append(rlibDepVariations, []blueprint.Variation{
Thiébaud Weksteen295c72b2020-09-23 18:10:17 +02001109 {Mutator: "rust_libraries", Variation: rlibVariation}}...),
Ivan Lozano52767be2019-10-18 14:49:46 -07001110 rlibDepTag, deps.Rlibs...)
1111 actx.AddVariationDependencies(
1112 append(commonDepVariations, []blueprint.Variation{
Thiébaud Weksteen295c72b2020-09-23 18:10:17 +02001113 {Mutator: "rust_libraries", Variation: dylibVariation}}...),
Ivan Lozano52767be2019-10-18 14:49:46 -07001114 dylibDepTag, deps.Dylibs...)
1115
Ivan Lozano042504f2020-08-18 14:31:23 -04001116 if deps.Rustlibs != nil && !mod.compiler.Disabled() {
1117 autoDep := mod.compiler.(autoDeppable).autoDep(ctx)
Ivan Lozano2b081132020-09-08 12:46:52 -04001118 if autoDep.depTag == rlibDepTag {
1119 actx.AddVariationDependencies(
1120 append(rlibDepVariations, blueprint.Variation{Mutator: "rust_libraries", Variation: autoDep.variation}),
1121 autoDep.depTag, deps.Rustlibs...)
1122 } else {
1123 actx.AddVariationDependencies(
1124 append(commonDepVariations, blueprint.Variation{Mutator: "rust_libraries", Variation: autoDep.variation}),
1125 autoDep.depTag, deps.Rustlibs...)
1126 }
Matthew Maurer0f003b12020-06-29 14:34:06 -07001127 }
Ivan Lozano2b081132020-09-08 12:46:52 -04001128 if deps.Stdlibs != nil {
Ivan Lozanodd055472020-09-28 13:22:45 -04001129 if mod.compiler.stdLinkage(ctx) == RlibLinkage {
Ivan Lozano2b081132020-09-08 12:46:52 -04001130 actx.AddVariationDependencies(
1131 append(commonDepVariations, blueprint.Variation{Mutator: "rust_libraries", Variation: "rlib"}),
1132 rlibDepTag, deps.Stdlibs...)
1133 } else {
1134 actx.AddVariationDependencies(
1135 append(commonDepVariations, blueprint.Variation{Mutator: "rust_libraries", Variation: "dylib"}),
1136 dylibDepTag, deps.Stdlibs...)
1137 }
1138 }
Ivan Lozano52767be2019-10-18 14:49:46 -07001139 actx.AddVariationDependencies(append(commonDepVariations,
1140 blueprint.Variation{Mutator: "link", Variation: "shared"}),
Colin Cross6e511a92020-07-27 21:26:48 -07001141 cc.SharedDepTag(), deps.SharedLibs...)
Ivan Lozano52767be2019-10-18 14:49:46 -07001142 actx.AddVariationDependencies(append(commonDepVariations,
1143 blueprint.Variation{Mutator: "link", Variation: "static"}),
Ivan Lozano63bb7682021-03-23 15:53:44 -04001144 cc.StaticDepTag(false), deps.StaticLibs...)
1145 actx.AddVariationDependencies(append(commonDepVariations,
1146 blueprint.Variation{Mutator: "link", Variation: "static"}),
1147 cc.StaticDepTag(true), deps.WholeStaticLibs...)
Ivan Lozano5ca5ef62019-09-23 10:10:40 -07001148
Zach Johnson3df4e632020-11-06 11:56:27 -08001149 actx.AddVariationDependencies(nil, cc.HeaderDepTag(), deps.HeaderLibs...)
1150
Colin Cross565cafd2020-09-25 18:47:38 -07001151 crtVariations := cc.GetCrtVariations(ctx, mod)
Ivan Lozanof1c84332019-09-20 11:00:37 -07001152 if deps.CrtBegin != "" {
Dan Albert92fe7402020-07-15 13:33:30 -07001153 actx.AddVariationDependencies(crtVariations, cc.CrtBeginDepTag, deps.CrtBegin)
Ivan Lozanof1c84332019-09-20 11:00:37 -07001154 }
1155 if deps.CrtEnd != "" {
Dan Albert92fe7402020-07-15 13:33:30 -07001156 actx.AddVariationDependencies(crtVariations, cc.CrtEndDepTag, deps.CrtEnd)
Ivan Lozanof1c84332019-09-20 11:00:37 -07001157 }
1158
Ivan Lozanoc564d2d2020-08-04 15:43:37 -04001159 if mod.sourceProvider != nil {
1160 if bindgen, ok := mod.sourceProvider.(*bindgenDecorator); ok &&
1161 bindgen.Properties.Custom_bindgen != "" {
1162 actx.AddFarVariationDependencies(ctx.Config().BuildOSTarget.Variations(), customBindgenDepTag,
1163 bindgen.Properties.Custom_bindgen)
1164 }
1165 }
Ivan Lozano5ca5ef62019-09-23 10:10:40 -07001166 // proc_macros are compiler plugins, and so we need the host arch variant as a dependendcy.
Colin Cross0f7d2ef2019-10-16 11:03:10 -07001167 actx.AddFarVariationDependencies(ctx.Config().BuildOSTarget.Variations(), procMacroDepTag, deps.ProcMacros...)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001168}
1169
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001170func BeginMutator(ctx android.BottomUpMutatorContext) {
1171 if mod, ok := ctx.Module().(*Module); ok && mod.Enabled() {
1172 mod.beginMutator(ctx)
1173 }
1174}
1175
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001176func (mod *Module) beginMutator(actx android.BottomUpMutatorContext) {
1177 ctx := &baseModuleContext{
1178 BaseModuleContext: actx,
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001179 }
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001180
1181 mod.begin(ctx)
1182}
1183
Ivan Lozanoffee3342019-08-27 12:03:00 -07001184func (mod *Module) Name() string {
1185 name := mod.ModuleBase.Name()
1186 if p, ok := mod.compiler.(interface {
1187 Name(string) string
1188 }); ok {
1189 name = p.Name(name)
1190 }
1191 return name
1192}
1193
Thiébaud Weksteen9e8451e2020-08-13 12:55:59 +02001194func (mod *Module) disableClippy() {
Ivan Lozano32267c82020-08-04 16:27:16 -04001195 if mod.clippy != nil {
Thiébaud Weksteen9e8451e2020-08-13 12:55:59 +02001196 mod.clippy.Properties.Clippy_lints = proptools.StringPtr("none")
Ivan Lozano32267c82020-08-04 16:27:16 -04001197 }
1198}
1199
Chih-Hung Hsieh5c4e4892020-05-15 17:36:30 -07001200var _ android.HostToolProvider = (*Module)(nil)
1201
1202func (mod *Module) HostToolPath() android.OptionalPath {
1203 if !mod.Host() {
1204 return android.OptionalPath{}
1205 }
Chih-Hung Hsieha7562702020-08-10 21:50:43 -07001206 if binary, ok := mod.compiler.(*binaryDecorator); ok {
1207 return android.OptionalPathForPath(binary.baseCompiler.path)
Chih-Hung Hsieh5c4e4892020-05-15 17:36:30 -07001208 }
1209 return android.OptionalPath{}
1210}
1211
Jiyong Park99644e92020-11-17 22:21:02 +09001212var _ android.ApexModule = (*Module)(nil)
1213
Ivan Lozano3e9f9e42020-12-04 15:05:43 -05001214func (mod *Module) minSdkVersion() string {
1215 return String(mod.Properties.Min_sdk_version)
1216}
1217
Jiyong Park45bf82e2020-12-15 22:29:02 +09001218var _ android.ApexModule = (*Module)(nil)
1219
1220// Implements android.ApexModule
Jiyong Park99644e92020-11-17 22:21:02 +09001221func (mod *Module) ShouldSupportSdkVersion(ctx android.BaseModuleContext, sdkVersion android.ApiLevel) error {
Ivan Lozano3e9f9e42020-12-04 15:05:43 -05001222 minSdkVersion := mod.minSdkVersion()
1223 if minSdkVersion == "apex_inherit" {
1224 return nil
1225 }
1226 if minSdkVersion == "" {
1227 return fmt.Errorf("min_sdk_version is not specificed")
1228 }
1229
1230 // Not using nativeApiLevelFromUser because the context here is not
1231 // necessarily a native context.
1232 ver, err := android.ApiLevelFromUser(ctx, minSdkVersion)
1233 if err != nil {
1234 return err
1235 }
1236
1237 if ver.GreaterThan(sdkVersion) {
1238 return fmt.Errorf("newer SDK(%v)", ver)
1239 }
Jiyong Park99644e92020-11-17 22:21:02 +09001240 return nil
1241}
1242
Jiyong Park45bf82e2020-12-15 22:29:02 +09001243// Implements android.ApexModule
Jiyong Park99644e92020-11-17 22:21:02 +09001244func (mod *Module) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
1245 depTag := ctx.OtherModuleDependencyTag(dep)
1246
1247 if ccm, ok := dep.(*cc.Module); ok {
1248 if ccm.HasStubsVariants() {
1249 if cc.IsSharedDepTag(depTag) {
1250 // dynamic dep to a stubs lib crosses APEX boundary
1251 return false
1252 }
1253 if cc.IsRuntimeDepTag(depTag) {
1254 // runtime dep to a stubs lib also crosses APEX boundary
1255 return false
1256 }
1257
1258 if cc.IsHeaderDepTag(depTag) {
1259 return false
1260 }
1261 }
1262 if mod.Static() && cc.IsSharedDepTag(depTag) {
1263 // shared_lib dependency from a static lib is considered as crossing
1264 // the APEX boundary because the dependency doesn't actually is
1265 // linked; the dependency is used only during the compilation phase.
1266 return false
1267 }
1268 }
1269
1270 if depTag == procMacroDepTag {
1271 return false
1272 }
1273
1274 return true
1275}
1276
1277// Overrides ApexModule.IsInstallabeToApex()
1278func (mod *Module) IsInstallableToApex() bool {
1279 if mod.compiler != nil {
1280 if lib, ok := mod.compiler.(*libraryDecorator); ok && (lib.shared() || lib.dylib()) {
1281 return true
1282 }
1283 if _, ok := mod.compiler.(*binaryDecorator); ok {
1284 return true
1285 }
1286 }
1287 return false
1288}
1289
Ivan Lozano3dfa12d2021-02-04 11:29:41 -05001290// If a library file has a "lib" prefix, extract the library name without the prefix.
1291func libNameFromFilePath(filepath android.Path) (string, bool) {
1292 libName := strings.TrimSuffix(filepath.Base(), filepath.Ext())
1293 if strings.HasPrefix(libName, "lib") {
1294 libName = libName[3:]
1295 return libName, true
1296 }
1297 return "", false
1298}
1299
Ivan Lozanoffee3342019-08-27 12:03:00 -07001300var Bool = proptools.Bool
1301var BoolDefault = proptools.BoolDefault
1302var String = proptools.String
1303var StringPtr = proptools.StringPtr
Ivan Lozano43845682020-07-09 21:03:28 -04001304
1305var _ android.OutputFileProducer = (*Module)(nil)