blob: b287f678d2db1e743389e9771be0c4ccb0dd0312 [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"
hamzehc0a671f2021-07-22 12:05:08 -070028 "android/soong/fuzz"
Ivan Lozanoffee3342019-08-27 12:03:00 -070029 "android/soong/rust/config"
Ivan Lozano872d5792022-03-23 17:31:39 -040030 "android/soong/snapshot"
Ivan Lozanoffee3342019-08-27 12:03:00 -070031)
32
33var pctx = android.NewPackageContext("android/soong/rust")
34
35func init() {
36 // Only allow rust modules to be defined for certain projects
Ivan Lozanoffee3342019-08-27 12:03:00 -070037
38 android.AddNeverAllowRules(
39 android.NeverAllow().
Ivan Lozano03a94c42021-06-28 11:27:11 -040040 NotIn(append(config.RustAllowedPaths, config.DownstreamRustAllowedPaths...)...).
Ivan Lozanoe169ad72019-09-18 08:42:54 -070041 ModuleType(config.RustModuleTypes...))
Ivan Lozanoffee3342019-08-27 12:03:00 -070042
43 android.RegisterModuleType("rust_defaults", defaultsFactory)
44 android.PreDepsMutators(func(ctx android.RegisterMutatorsContext) {
45 ctx.BottomUp("rust_libraries", LibraryMutator).Parallel()
Ivan Lozano2b081132020-09-08 12:46:52 -040046 ctx.BottomUp("rust_stdlinkage", LibstdMutator).Parallel()
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -040047 ctx.BottomUp("rust_begin", BeginMutator).Parallel()
Ivan Lozano6cd99e62020-02-11 08:24:25 -050048
49 })
50 android.PostDepsMutators(func(ctx android.RegisterMutatorsContext) {
51 ctx.BottomUp("rust_sanitizers", rustSanitizerRuntimeMutator).Parallel()
Ivan Lozanoffee3342019-08-27 12:03:00 -070052 })
53 pctx.Import("android/soong/rust/config")
Thiébaud Weksteen682c9d72020-08-31 10:06:16 +020054 pctx.ImportAs("cc_config", "android/soong/cc/config")
Ivan Lozanoffee3342019-08-27 12:03:00 -070055}
56
57type Flags struct {
Ivan Lozano8a23fa42020-06-16 10:26:57 -040058 GlobalRustFlags []string // Flags that apply globally to rust
59 GlobalLinkFlags []string // Flags that apply globally to linker
60 RustFlags []string // Flags that apply to rust
61 LinkFlags []string // Flags that apply to linker
Thiébaud Weksteen92f703b2020-06-22 13:28:02 +020062 ClippyFlags []string // Flags that apply to clippy-driver, during the linting
Dan Albert06feee92021-03-19 15:06:02 -070063 RustdocFlags []string // Flags that apply to rustdoc
Ivan Lozanof1c84332019-09-20 11:00:37 -070064 Toolchain config.Toolchain
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -040065 Coverage bool
Thiébaud Weksteen92f703b2020-06-22 13:28:02 +020066 Clippy bool
Ivan Lozanoffee3342019-08-27 12:03:00 -070067}
68
69type BaseProperties struct {
70 AndroidMkRlibs []string
71 AndroidMkDylibs []string
72 AndroidMkProcMacroLibs []string
73 AndroidMkSharedLibs []string
74 AndroidMkStaticLibs []string
Ivan Lozano43845682020-07-09 21:03:28 -040075
Ivan Lozano6a884432020-12-02 09:15:16 -050076 ImageVariationPrefix string `blueprint:"mutated"`
77 VndkVersion string `blueprint:"mutated"`
78 SubName string `blueprint:"mutated"`
79
Ivan Lozanoc08897c2021-04-02 12:41:32 -040080 // SubName is used by CC for tracking image variants / SDK versions. RustSubName is used for Rust-specific
81 // subnaming which shouldn't be visible to CC modules (such as the rlib stdlinkage subname). This should be
82 // appended before SubName.
83 RustSubName string `blueprint:"mutated"`
84
Ivan Lozano6a884432020-12-02 09:15:16 -050085 // Set by imageMutator
Ivan Lozanoe6d30982021-02-05 10:57:43 -050086 CoreVariantNeeded bool `blueprint:"mutated"`
87 VendorRamdiskVariantNeeded bool `blueprint:"mutated"`
Matthew Maurerc6868382021-07-13 14:12:37 -070088 RamdiskVariantNeeded bool `blueprint:"mutated"`
Matthew Maurer460ee942021-02-11 12:31:46 -080089 RecoveryVariantNeeded bool `blueprint:"mutated"`
Ivan Lozanoe6d30982021-02-05 10:57:43 -050090 ExtraVariants []string `blueprint:"mutated"`
91
Ivan Lozanoa2268632021-07-22 10:52:06 -040092 // Allows this module to use non-APEX version of libraries. Useful
93 // for building binaries that are started before APEXes are activated.
94 Bootstrap *bool
95
Ivan Lozano1921e802021-05-20 13:39:16 -040096 // Used by vendor snapshot to record dependencies from snapshot modules.
97 SnapshotSharedLibs []string `blueprint:"mutated"`
Justin Yun5e035862021-06-29 20:50:37 +090098 SnapshotStaticLibs []string `blueprint:"mutated"`
Ivan Lozano1921e802021-05-20 13:39:16 -040099
Matthew Maurerc6868382021-07-13 14:12:37 -0700100 // Make this module available when building for ramdisk.
101 // On device without a dedicated recovery partition, the module is only
102 // available after switching root into
103 // /first_stage_ramdisk. To expose the module before switching root, install
104 // the recovery variant instead.
105 Ramdisk_available *bool
106
Ivan Lozanoe6d30982021-02-05 10:57:43 -0500107 // Make this module available when building for vendor ramdisk.
108 // On device without a dedicated recovery partition, the module is only
109 // available after switching root into
110 // /first_stage_ramdisk. To expose the module before switching root, install
Matthew Maurer460ee942021-02-11 12:31:46 -0800111 // the recovery variant instead
Ivan Lozanoe6d30982021-02-05 10:57:43 -0500112 Vendor_ramdisk_available *bool
Ivan Lozano26ecd6c2020-07-31 13:40:31 -0400113
Ivan Lozano1921e802021-05-20 13:39:16 -0400114 // Normally Soong uses the directory structure to decide which modules
115 // should be included (framework) or excluded (non-framework) from the
116 // different snapshots (vendor, recovery, etc.), but this property
117 // allows a partner to exclude a module normally thought of as a
118 // framework module from the vendor snapshot.
119 Exclude_from_vendor_snapshot *bool
120
121 // Normally Soong uses the directory structure to decide which modules
122 // should be included (framework) or excluded (non-framework) from the
123 // different snapshots (vendor, recovery, etc.), but this property
124 // allows a partner to exclude a module normally thought of as a
125 // framework module from the recovery snapshot.
126 Exclude_from_recovery_snapshot *bool
127
Matthew Maurer460ee942021-02-11 12:31:46 -0800128 // Make this module available when building for recovery
129 Recovery_available *bool
130
Ivan Lozano3e9f9e42020-12-04 15:05:43 -0500131 // Minimum sdk version that the artifact should support when it runs as part of mainline modules(APEX).
132 Min_sdk_version *string
133
Jiyong Parkd1e366a2021-10-05 09:12:41 +0900134 HideFromMake bool `blueprint:"mutated"`
135 PreventInstall bool `blueprint:"mutated"`
136
137 Installable *bool
Ivan Lozanoffee3342019-08-27 12:03:00 -0700138}
139
140type Module struct {
hamzehc0a671f2021-07-22 12:05:08 -0700141 fuzz.FuzzModule
Ivan Lozanoffee3342019-08-27 12:03:00 -0700142
Ivan Lozano6a884432020-12-02 09:15:16 -0500143 VendorProperties cc.VendorProperties
144
Ivan Lozanoffee3342019-08-27 12:03:00 -0700145 Properties BaseProperties
146
147 hod android.HostOrDeviceSupported
148 multilib android.Multilib
149
Ivan Lozano6a884432020-12-02 09:15:16 -0500150 makeLinkType string
151
Yi Kong46c6e592022-01-20 22:55:00 +0800152 afdo *afdo
Ivan Lozanoffee3342019-08-27 12:03:00 -0700153 compiler compiler
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400154 coverage *coverage
Thiébaud Weksteen92f703b2020-06-22 13:28:02 +0200155 clippy *clippy
Ivan Lozano6cd99e62020-02-11 08:24:25 -0500156 sanitize *sanitize
Ivan Lozanoffee3342019-08-27 12:03:00 -0700157 cachedToolchain config.Toolchain
Ivan Lozano4fef93c2020-07-08 08:39:44 -0400158 sourceProvider SourceProvider
Andrei Homescuc7767922020-08-05 06:36:19 -0700159 subAndroidMkOnce map[SubAndroidMkProvider]bool
Ivan Lozano4fef93c2020-07-08 08:39:44 -0400160
Ivan Lozano8d10fc32021-11-05 16:36:47 -0400161 // Output file to be installed, may be stripped or unstripped.
162 outputFile android.OptionalPath
163
164 docTimestampFile android.OptionalPath
Jiyong Park99644e92020-11-17 22:21:02 +0900165
166 hideApexVariantFromMake bool
Ivan Lozanoe950cda2021-11-09 11:26:04 -0500167
168 // For apex variants, this is set as apex.min_sdk_version
169 apexSdkVersion android.ApiLevel
Ivan Lozanoffee3342019-08-27 12:03:00 -0700170}
171
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500172func (mod *Module) Header() bool {
173 //TODO: If Rust libraries provide header variants, this needs to be updated.
174 return false
175}
176
177func (mod *Module) SetPreventInstall() {
178 mod.Properties.PreventInstall = true
179}
180
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500181func (mod *Module) SetHideFromMake() {
182 mod.Properties.HideFromMake = true
183}
184
Jiyong Parkd1e366a2021-10-05 09:12:41 +0900185func (mod *Module) HiddenFromMake() bool {
186 return mod.Properties.HideFromMake
Ivan Lozanod7586b62021-04-01 09:49:36 -0400187}
188
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500189func (mod *Module) SanitizePropDefined() bool {
Ivan Lozano6cd99e62020-02-11 08:24:25 -0500190 // Because compiler is not set for some Rust modules where sanitize might be set, check that compiler is also not
191 // nil since we need compiler to actually sanitize.
192 return mod.sanitize != nil && mod.compiler != nil
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500193}
194
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500195func (mod *Module) IsPrebuilt() bool {
196 if _, ok := mod.compiler.(*prebuiltLibraryDecorator); ok {
197 return true
198 }
199 return false
200}
201
Ivan Lozano43845682020-07-09 21:03:28 -0400202func (mod *Module) OutputFiles(tag string) (android.Paths, error) {
203 switch tag {
204 case "":
Andrei Homescu5db69cc2020-08-06 15:27:45 -0700205 if mod.sourceProvider != nil && (mod.compiler == nil || mod.compiler.Disabled()) {
Ivan Lozano43845682020-07-09 21:03:28 -0400206 return mod.sourceProvider.Srcs(), nil
207 } else {
Jiyong Parke54f07e2021-04-07 15:08:04 +0900208 if mod.OutputFile().Valid() {
209 return android.Paths{mod.OutputFile().Path()}, nil
Ivan Lozano43845682020-07-09 21:03:28 -0400210 }
211 return android.Paths{}, nil
212 }
213 default:
214 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
215 }
216}
217
Ivan Lozano52767be2019-10-18 14:49:46 -0700218func (mod *Module) SelectedStl() string {
219 return ""
220}
221
Ivan Lozano2b262972019-11-21 12:30:50 -0800222func (mod *Module) NonCcVariants() bool {
223 if mod.compiler != nil {
Ivan Lozano89435d12020-07-31 11:01:18 -0400224 if _, ok := mod.compiler.(libraryInterface); ok {
225 return false
Ivan Lozano2b262972019-11-21 12:30:50 -0800226 }
227 }
228 panic(fmt.Errorf("NonCcVariants called on non-library module: %q", mod.BaseModuleName()))
229}
230
Ivan Lozano52767be2019-10-18 14:49:46 -0700231func (mod *Module) Static() bool {
232 if mod.compiler != nil {
233 if library, ok := mod.compiler.(libraryInterface); ok {
234 return library.static()
235 }
236 }
Ivan Lozano89435d12020-07-31 11:01:18 -0400237 return false
Ivan Lozano52767be2019-10-18 14:49:46 -0700238}
239
240func (mod *Module) Shared() bool {
241 if mod.compiler != nil {
242 if library, ok := mod.compiler.(libraryInterface); ok {
Ivan Lozano89435d12020-07-31 11:01:18 -0400243 return library.shared()
Ivan Lozano52767be2019-10-18 14:49:46 -0700244 }
245 }
Ivan Lozano89435d12020-07-31 11:01:18 -0400246 return false
Ivan Lozano52767be2019-10-18 14:49:46 -0700247}
248
Ivan Lozanod7586b62021-04-01 09:49:36 -0400249func (mod *Module) Dylib() bool {
250 if mod.compiler != nil {
251 if library, ok := mod.compiler.(libraryInterface); ok {
252 return library.dylib()
253 }
254 }
255 return false
256}
257
258func (mod *Module) Rlib() bool {
259 if mod.compiler != nil {
260 if library, ok := mod.compiler.(libraryInterface); ok {
261 return library.rlib()
262 }
263 }
264 return false
265}
266
267func (mod *Module) Binary() bool {
Ivan Lozano21fa0a52021-11-01 09:19:45 -0400268 if binary, ok := mod.compiler.(binaryInterface); ok {
269 return binary.binary()
Ivan Lozanod7586b62021-04-01 09:49:36 -0400270 }
271 return false
272}
273
Justin Yun5e035862021-06-29 20:50:37 +0900274func (mod *Module) StaticExecutable() bool {
275 if !mod.Binary() {
276 return false
277 }
Ivan Lozano21fa0a52021-11-01 09:19:45 -0400278 return mod.StaticallyLinked()
Justin Yun5e035862021-06-29 20:50:37 +0900279}
280
Ivan Lozanod7586b62021-04-01 09:49:36 -0400281func (mod *Module) Object() bool {
282 // Rust has no modules which produce only object files.
283 return false
284}
285
Ivan Lozano52767be2019-10-18 14:49:46 -0700286func (mod *Module) Toc() android.OptionalPath {
287 if mod.compiler != nil {
Ivan Lozano7b0781d2021-11-03 15:30:18 -0400288 if lib, ok := mod.compiler.(libraryInterface); ok {
289 return lib.toc()
Ivan Lozano52767be2019-10-18 14:49:46 -0700290 }
291 }
292 panic(fmt.Errorf("Toc() called on non-library module: %q", mod.BaseModuleName()))
293}
294
Colin Crossc511bc52020-04-07 16:50:32 +0000295func (mod *Module) UseSdk() bool {
296 return false
297}
298
Ivan Lozanod7586b62021-04-01 09:49:36 -0400299func (mod *Module) RelativeInstallPath() string {
300 if mod.compiler != nil {
301 return mod.compiler.relativeInstallPath()
302 }
303 return ""
304}
305
Ivan Lozano52767be2019-10-18 14:49:46 -0700306func (mod *Module) UseVndk() bool {
Ivan Lozano6a884432020-12-02 09:15:16 -0500307 return mod.Properties.VndkVersion != ""
Ivan Lozano52767be2019-10-18 14:49:46 -0700308}
309
Jiyong Park7d55b612021-06-11 17:22:09 +0900310func (mod *Module) Bootstrap() bool {
Ivan Lozanoa2268632021-07-22 10:52:06 -0400311 return Bool(mod.Properties.Bootstrap)
Jiyong Park7d55b612021-06-11 17:22:09 +0900312}
313
Ivan Lozano52767be2019-10-18 14:49:46 -0700314func (mod *Module) MustUseVendorVariant() bool {
Ivan Lozanoc08897c2021-04-02 12:41:32 -0400315 return true
316}
317
318func (mod *Module) SubName() string {
319 return mod.Properties.SubName
Ivan Lozano52767be2019-10-18 14:49:46 -0700320}
321
322func (mod *Module) IsVndk() bool {
Ivan Lozano6a884432020-12-02 09:15:16 -0500323 // TODO(b/165791368)
Ivan Lozano52767be2019-10-18 14:49:46 -0700324 return false
325}
326
Ivan Lozanof9e21722020-12-02 09:00:51 -0500327func (mod *Module) IsVndkExt() bool {
328 return false
329}
330
Ivan Lozanod7586b62021-04-01 09:49:36 -0400331func (mod *Module) IsVndkSp() bool {
332 return false
333}
334
Colin Cross127bb8b2020-12-16 16:46:01 -0800335func (c *Module) IsVndkPrivate() bool {
336 return false
337}
338
339func (c *Module) IsLlndk() bool {
340 return false
341}
342
343func (c *Module) IsLlndkPublic() bool {
Ivan Lozanof9e21722020-12-02 09:00:51 -0500344 return false
345}
346
Ivan Lozano3a7d0002021-03-30 12:19:36 -0400347func (mod *Module) KernelHeadersDecorator() bool {
348 return false
349}
350
Colin Cross1f3f1302021-04-26 18:37:44 -0700351func (m *Module) NeedsLlndkVariants() bool {
Ivan Lozano3a7d0002021-03-30 12:19:36 -0400352 return false
353}
354
Colin Cross5271fea2021-04-27 13:06:04 -0700355func (m *Module) NeedsVendorPublicLibraryVariants() bool {
356 return false
357}
358
Ivan Lozanod7586b62021-04-01 09:49:36 -0400359func (mod *Module) HasLlndkStubs() bool {
360 return false
361}
362
363func (mod *Module) StubsVersion() string {
364 panic(fmt.Errorf("StubsVersion called on non-versioned module: %q", mod.BaseModuleName()))
365}
366
Ivan Lozano52767be2019-10-18 14:49:46 -0700367func (mod *Module) SdkVersion() string {
368 return ""
369}
370
Colin Crossc511bc52020-04-07 16:50:32 +0000371func (mod *Module) AlwaysSdk() bool {
372 return false
373}
374
Jiyong Park2286afd2020-06-16 21:58:53 +0900375func (mod *Module) IsSdkVariant() bool {
376 return false
377}
378
Colin Cross1348ce32020-10-01 13:37:16 -0700379func (mod *Module) SplitPerApiLevel() bool {
380 return false
381}
382
Ivan Lozanoffee3342019-08-27 12:03:00 -0700383type Deps struct {
Ivan Lozano63bb7682021-03-23 15:53:44 -0400384 Dylibs []string
385 Rlibs []string
386 Rustlibs []string
387 Stdlibs []string
388 ProcMacros []string
389 SharedLibs []string
390 StaticLibs []string
391 WholeStaticLibs []string
392 HeaderLibs []string
Ivan Lozanoffee3342019-08-27 12:03:00 -0700393
Ivan Lozano4e5f07d2021-11-04 14:09:38 -0400394 // Used for data dependencies adjacent to tests
395 DataLibs []string
396 DataBins []string
397
Colin Crossfe605e12022-01-23 20:46:16 -0800398 CrtBegin, CrtEnd []string
Ivan Lozanoffee3342019-08-27 12:03:00 -0700399}
400
401type PathDeps struct {
Ivan Lozanoec6e9912021-01-21 15:23:29 -0500402 DyLibs RustLibraries
403 RLibs RustLibraries
404 SharedLibs android.Paths
405 SharedLibDeps android.Paths
406 StaticLibs android.Paths
407 ProcMacros RustLibraries
Yi Kong46c6e592022-01-20 22:55:00 +0800408 AfdoProfiles android.Paths
Ivan Lozano3dfa12d2021-02-04 11:29:41 -0500409
410 // depFlags and depLinkFlags are rustc and linker (clang) flags.
411 depFlags []string
412 depLinkFlags []string
413
414 // linkDirs are link paths passed via -L to rustc. linkObjects are objects passed directly to the linker.
415 // Both of these are exported and propagate to dependencies.
416 linkDirs []string
417 linkObjects []string
Ivan Lozanof1c84332019-09-20 11:00:37 -0700418
Ivan Lozano45901ed2020-07-24 16:05:01 -0400419 // Used by bindgen modules which call clang
420 depClangFlags []string
421 depIncludePaths android.Paths
Ivan Lozanoddd0bdb2020-08-28 17:00:26 -0400422 depGeneratedHeaders android.Paths
Ivan Lozano45901ed2020-07-24 16:05:01 -0400423 depSystemIncludePaths android.Paths
424
Colin Crossfe605e12022-01-23 20:46:16 -0800425 CrtBegin android.Paths
426 CrtEnd android.Paths
Chih-Hung Hsiehbbd25ae2020-05-15 17:36:30 -0700427
428 // Paths to generated source files
Ivan Lozano9d74a522020-12-01 09:25:22 -0500429 SrcDeps android.Paths
430 srcProviderFiles android.Paths
Ivan Lozanoffee3342019-08-27 12:03:00 -0700431}
432
433type RustLibraries []RustLibrary
434
435type RustLibrary struct {
436 Path android.Path
437 CrateName string
438}
439
440type compiler interface {
Thiébaud Weksteenee6a89b2021-02-25 16:30:57 +0100441 initialize(ctx ModuleContext)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700442 compilerFlags(ctx ModuleContext, flags Flags) Flags
Ivan Lozano67eada32021-09-23 11:50:33 -0400443 cfgFlags(ctx ModuleContext, flags Flags) Flags
444 featureFlags(ctx ModuleContext, flags Flags) Flags
Ivan Lozanoffee3342019-08-27 12:03:00 -0700445 compilerProps() []interface{}
446 compile(ctx ModuleContext, flags Flags, deps PathDeps) android.Path
447 compilerDeps(ctx DepsContext, deps Deps) Deps
448 crateName() string
Dan Albert06feee92021-03-19 15:06:02 -0700449 rustdoc(ctx ModuleContext, flags Flags, deps PathDeps) android.OptionalPath
Ivan Lozanoffee3342019-08-27 12:03:00 -0700450
Thiébaud Weksteenee6a89b2021-02-25 16:30:57 +0100451 // Output directory in which source-generated code from dependencies is
452 // copied. This is equivalent to Cargo's OUT_DIR variable.
453 CargoOutDir() android.OptionalPath
Dan Albert06feee92021-03-19 15:06:02 -0700454
Ivan Lozanoa9a1fc02021-08-11 15:13:43 -0400455 // CargoPkgVersion returns the value of the Cargo_pkg_version property.
456 CargoPkgVersion() string
457
458 // CargoEnvCompat returns whether Cargo environment variables should be used.
459 CargoEnvCompat() bool
460
Chih-Hung Hsieh9a4a7ba2019-12-12 19:36:05 -0800461 inData() bool
Thiébaud Weksteenfabaff62020-08-27 13:48:36 +0200462 install(ctx ModuleContext)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700463 relativeInstallPath() string
Ivan Lozanod7586b62021-04-01 09:49:36 -0400464 everInstallable() bool
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400465
466 nativeCoverage() bool
Ivan Lozano26ecd6c2020-07-31 13:40:31 -0400467
468 Disabled() bool
469 SetDisabled()
Ivan Lozano042504f2020-08-18 14:31:23 -0400470
Ivan Lozanodd055472020-09-28 13:22:45 -0400471 stdLinkage(ctx *depsContext) RustLinkage
Jiyong Parke54f07e2021-04-07 15:08:04 +0900472
Ivan Lozano8d10fc32021-11-05 16:36:47 -0400473 unstrippedOutputFilePath() android.Path
Jiyong Parke54f07e2021-04-07 15:08:04 +0900474 strippedOutputFilePath() android.OptionalPath
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400475}
476
Matthew Maurerbb3add12020-06-25 09:34:12 -0700477type exportedFlagsProducer interface {
Matthew Maurerbb3add12020-06-25 09:34:12 -0700478 exportLinkDirs(...string)
Ivan Lozano2093af22020-08-25 12:48:19 -0400479 exportLinkObjects(...string)
Matthew Maurerbb3add12020-06-25 09:34:12 -0700480}
481
482type flagExporter struct {
Ivan Lozano2093af22020-08-25 12:48:19 -0400483 linkDirs []string
484 linkObjects []string
Matthew Maurerbb3add12020-06-25 09:34:12 -0700485}
486
Matthew Maurerbb3add12020-06-25 09:34:12 -0700487func (flagExporter *flagExporter) exportLinkDirs(dirs ...string) {
488 flagExporter.linkDirs = android.FirstUniqueStrings(append(flagExporter.linkDirs, dirs...))
489}
490
Ivan Lozano2093af22020-08-25 12:48:19 -0400491func (flagExporter *flagExporter) exportLinkObjects(flags ...string) {
492 flagExporter.linkObjects = android.FirstUniqueStrings(append(flagExporter.linkObjects, flags...))
493}
494
Colin Cross0de8a1e2020-09-18 14:15:30 -0700495func (flagExporter *flagExporter) setProvider(ctx ModuleContext) {
496 ctx.SetProvider(FlagExporterInfoProvider, FlagExporterInfo{
Colin Cross0de8a1e2020-09-18 14:15:30 -0700497 LinkDirs: flagExporter.linkDirs,
498 LinkObjects: flagExporter.linkObjects,
499 })
500}
501
Matthew Maurerbb3add12020-06-25 09:34:12 -0700502var _ exportedFlagsProducer = (*flagExporter)(nil)
503
504func NewFlagExporter() *flagExporter {
Colin Cross0de8a1e2020-09-18 14:15:30 -0700505 return &flagExporter{}
Matthew Maurerbb3add12020-06-25 09:34:12 -0700506}
507
Colin Cross0de8a1e2020-09-18 14:15:30 -0700508type FlagExporterInfo struct {
509 Flags []string
510 LinkDirs []string // TODO: this should be android.Paths
511 LinkObjects []string // TODO: this should be android.Paths
512}
513
514var FlagExporterInfoProvider = blueprint.NewProvider(FlagExporterInfo{})
515
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400516func (mod *Module) isCoverageVariant() bool {
517 return mod.coverage.Properties.IsCoverageVariant
518}
519
520var _ cc.Coverage = (*Module)(nil)
521
522func (mod *Module) IsNativeCoverageNeeded(ctx android.BaseModuleContext) bool {
523 return mod.coverage != nil && mod.coverage.Properties.NeedCoverageVariant
524}
525
Ivan Lozanod7586b62021-04-01 09:49:36 -0400526func (mod *Module) VndkVersion() string {
527 return mod.Properties.VndkVersion
528}
529
530func (mod *Module) PreventInstall() bool {
531 return mod.Properties.PreventInstall
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400532}
533
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400534func (mod *Module) MarkAsCoverageVariant(coverage bool) {
535 mod.coverage.Properties.IsCoverageVariant = coverage
536}
537
538func (mod *Module) EnableCoverageIfNeeded() {
539 mod.coverage.Properties.CoverageEnabled = mod.coverage.Properties.NeedCoverageBuild
Ivan Lozanoffee3342019-08-27 12:03:00 -0700540}
541
542func defaultsFactory() android.Module {
543 return DefaultsFactory()
544}
545
546type Defaults struct {
547 android.ModuleBase
548 android.DefaultsModuleBase
549}
550
551func DefaultsFactory(props ...interface{}) android.Module {
552 module := &Defaults{}
553
554 module.AddProperties(props...)
555 module.AddProperties(
556 &BaseProperties{},
Yi Kong46c6e592022-01-20 22:55:00 +0800557 &cc.AfdoProperties{},
Ivan Lozano6a884432020-12-02 09:15:16 -0500558 &cc.VendorProperties{},
Jakub Kotur1d640d02021-01-06 12:40:43 +0100559 &BenchmarkProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -0400560 &BindgenProperties{},
Ivan Lozanoffee3342019-08-27 12:03:00 -0700561 &BaseCompilerProperties{},
562 &BinaryCompilerProperties{},
563 &LibraryCompilerProperties{},
564 &ProcMacroCompilerProperties{},
565 &PrebuiltProperties{},
Ivan Lozano4fef93c2020-07-08 08:39:44 -0400566 &SourceProviderProperties{},
Chih-Hung Hsieh41805be2019-10-31 20:56:47 -0700567 &TestProperties{},
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400568 &cc.CoverageProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -0400569 &cc.RustBindgenClangProperties{},
Thiébaud Weksteen92f703b2020-06-22 13:28:02 +0200570 &ClippyProperties{},
Ivan Lozano6cd99e62020-02-11 08:24:25 -0500571 &SanitizeProperties{},
Ivan Lozanoffee3342019-08-27 12:03:00 -0700572 )
573
574 android.InitDefaultsModule(module)
575 return module
576}
577
578func (mod *Module) CrateName() string {
Ivan Lozanoad8b18b2019-10-31 19:38:29 -0700579 return mod.compiler.crateName()
Ivan Lozanoffee3342019-08-27 12:03:00 -0700580}
581
Ivan Lozano183a3212019-10-18 14:18:45 -0700582func (mod *Module) CcLibrary() bool {
583 if mod.compiler != nil {
Ivan Lozano45e0e5b2021-11-13 07:42:36 -0500584 if _, ok := mod.compiler.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700585 return true
586 }
587 }
588 return false
589}
590
591func (mod *Module) CcLibraryInterface() bool {
592 if mod.compiler != nil {
Ivan Lozano89435d12020-07-31 11:01:18 -0400593 // use build{Static,Shared}() instead of {static,shared}() here because this might be called before
594 // VariantIs{Static,Shared} is set.
595 if lib, ok := mod.compiler.(libraryInterface); ok && (lib.buildShared() || lib.buildStatic()) {
Ivan Lozano183a3212019-10-18 14:18:45 -0700596 return true
597 }
598 }
599 return false
600}
601
Ivan Lozano39b0bf02021-10-14 12:22:09 -0400602func (mod *Module) UnstrippedOutputFile() android.Path {
Ivan Lozano8d10fc32021-11-05 16:36:47 -0400603 if mod.compiler != nil {
604 return mod.compiler.unstrippedOutputFilePath()
Ivan Lozano39b0bf02021-10-14 12:22:09 -0400605 }
606 return nil
607}
608
Ivan Lozanoe0833b12019-11-06 19:15:49 -0800609func (mod *Module) IncludeDirs() android.Paths {
Ivan Lozano183a3212019-10-18 14:18:45 -0700610 if mod.compiler != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700611 if library, ok := mod.compiler.(*libraryDecorator); ok {
Ivan Lozanoe0833b12019-11-06 19:15:49 -0800612 return library.includeDirs
Ivan Lozano183a3212019-10-18 14:18:45 -0700613 }
614 }
615 panic(fmt.Errorf("IncludeDirs called on non-library module: %q", mod.BaseModuleName()))
616}
617
618func (mod *Module) SetStatic() {
619 if mod.compiler != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700620 if library, ok := mod.compiler.(libraryInterface); ok {
621 library.setStatic()
Ivan Lozano183a3212019-10-18 14:18:45 -0700622 return
623 }
624 }
625 panic(fmt.Errorf("SetStatic called on non-library module: %q", mod.BaseModuleName()))
626}
627
628func (mod *Module) SetShared() {
629 if mod.compiler != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700630 if library, ok := mod.compiler.(libraryInterface); ok {
631 library.setShared()
Ivan Lozano183a3212019-10-18 14:18:45 -0700632 return
633 }
634 }
635 panic(fmt.Errorf("SetShared called on non-library module: %q", mod.BaseModuleName()))
636}
637
Ivan Lozano183a3212019-10-18 14:18:45 -0700638func (mod *Module) BuildStaticVariant() bool {
639 if mod.compiler != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700640 if library, ok := mod.compiler.(libraryInterface); ok {
641 return library.buildStatic()
Ivan Lozano183a3212019-10-18 14:18:45 -0700642 }
643 }
644 panic(fmt.Errorf("BuildStaticVariant called on non-library module: %q", mod.BaseModuleName()))
645}
646
647func (mod *Module) BuildSharedVariant() bool {
648 if mod.compiler != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700649 if library, ok := mod.compiler.(libraryInterface); ok {
650 return library.buildShared()
Ivan Lozano183a3212019-10-18 14:18:45 -0700651 }
652 }
653 panic(fmt.Errorf("BuildSharedVariant called on non-library module: %q", mod.BaseModuleName()))
654}
655
Ivan Lozano183a3212019-10-18 14:18:45 -0700656func (mod *Module) Module() android.Module {
657 return mod
658}
659
Ivan Lozano183a3212019-10-18 14:18:45 -0700660func (mod *Module) OutputFile() android.OptionalPath {
Ivan Lozano8d10fc32021-11-05 16:36:47 -0400661 return mod.outputFile
Ivan Lozano183a3212019-10-18 14:18:45 -0700662}
663
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400664func (mod *Module) CoverageFiles() android.Paths {
665 if mod.compiler != nil {
Joel Galensonfa049382021-01-14 16:03:18 -0800666 return android.Paths{}
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400667 }
668 panic(fmt.Errorf("CoverageFiles called on non-library module: %q", mod.BaseModuleName()))
669}
670
Jiyong Park459feca2020-12-15 11:02:21 +0900671func (mod *Module) installable(apexInfo android.ApexInfo) bool {
Jiyong Park2811e072021-09-30 17:25:21 +0900672 if !proptools.BoolDefault(mod.Installable(), mod.EverInstallable()) {
Jiyong Parkbf8147a2021-05-17 13:19:33 +0900673 return false
674 }
675
Jiyong Park459feca2020-12-15 11:02:21 +0900676 // The apex variant is not installable because it is included in the APEX and won't appear
677 // in the system partition as a standalone file.
678 if !apexInfo.IsForPlatform() {
679 return false
680 }
681
Jiyong Parke54f07e2021-04-07 15:08:04 +0900682 return mod.OutputFile().Valid() && !mod.Properties.PreventInstall
Jiyong Park459feca2020-12-15 11:02:21 +0900683}
684
Ivan Lozanoe950cda2021-11-09 11:26:04 -0500685func (ctx moduleContext) apexVariationName() string {
686 return ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).ApexVariationName
687}
688
Ivan Lozano183a3212019-10-18 14:18:45 -0700689var _ cc.LinkableInterface = (*Module)(nil)
690
Ivan Lozanoffee3342019-08-27 12:03:00 -0700691func (mod *Module) Init() android.Module {
692 mod.AddProperties(&mod.Properties)
Ivan Lozano6a884432020-12-02 09:15:16 -0500693 mod.AddProperties(&mod.VendorProperties)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700694
Yi Kong46c6e592022-01-20 22:55:00 +0800695 if mod.afdo != nil {
696 mod.AddProperties(mod.afdo.props()...)
697 }
Ivan Lozanoffee3342019-08-27 12:03:00 -0700698 if mod.compiler != nil {
699 mod.AddProperties(mod.compiler.compilerProps()...)
700 }
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400701 if mod.coverage != nil {
702 mod.AddProperties(mod.coverage.props()...)
703 }
Thiébaud Weksteen92f703b2020-06-22 13:28:02 +0200704 if mod.clippy != nil {
705 mod.AddProperties(mod.clippy.props()...)
706 }
Ivan Lozano4fef93c2020-07-08 08:39:44 -0400707 if mod.sourceProvider != nil {
Andrei Homescuc7767922020-08-05 06:36:19 -0700708 mod.AddProperties(mod.sourceProvider.SourceProviderProps()...)
Ivan Lozano4fef93c2020-07-08 08:39:44 -0400709 }
Ivan Lozano6cd99e62020-02-11 08:24:25 -0500710 if mod.sanitize != nil {
711 mod.AddProperties(mod.sanitize.props()...)
712 }
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400713
Ivan Lozanoffee3342019-08-27 12:03:00 -0700714 android.InitAndroidArchModule(mod, mod.hod, mod.multilib)
Jiyong Park99644e92020-11-17 22:21:02 +0900715 android.InitApexModule(mod)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700716
717 android.InitDefaultableModule(mod)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700718 return mod
719}
720
721func newBaseModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
722 return &Module{
723 hod: hod,
724 multilib: multilib,
725 }
726}
727func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
728 module := newBaseModule(hod, multilib)
Yi Kong46c6e592022-01-20 22:55:00 +0800729 module.afdo = &afdo{}
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400730 module.coverage = &coverage{}
Thiébaud Weksteen92f703b2020-06-22 13:28:02 +0200731 module.clippy = &clippy{}
Ivan Lozano6cd99e62020-02-11 08:24:25 -0500732 module.sanitize = &sanitize{}
Ivan Lozanoffee3342019-08-27 12:03:00 -0700733 return module
734}
735
736type ModuleContext interface {
737 android.ModuleContext
738 ModuleContextIntf
739}
740
741type BaseModuleContext interface {
742 android.BaseModuleContext
743 ModuleContextIntf
744}
745
746type DepsContext interface {
747 android.BottomUpMutatorContext
748 ModuleContextIntf
749}
750
751type ModuleContextIntf interface {
Thiébaud Weksteen1f7f70f2020-06-24 11:32:48 +0200752 RustModule() *Module
Ivan Lozanoffee3342019-08-27 12:03:00 -0700753 toolchain() config.Toolchain
Ivan Lozanoffee3342019-08-27 12:03:00 -0700754}
755
756type depsContext struct {
757 android.BottomUpMutatorContext
Ivan Lozanoffee3342019-08-27 12:03:00 -0700758}
759
760type moduleContext struct {
761 android.ModuleContext
Ivan Lozanoffee3342019-08-27 12:03:00 -0700762}
763
Thiébaud Weksteen1f7f70f2020-06-24 11:32:48 +0200764type baseModuleContext struct {
765 android.BaseModuleContext
766}
767
768func (ctx *moduleContext) RustModule() *Module {
769 return ctx.Module().(*Module)
770}
771
772func (ctx *moduleContext) toolchain() config.Toolchain {
773 return ctx.RustModule().toolchain(ctx)
774}
775
776func (ctx *depsContext) RustModule() *Module {
777 return ctx.Module().(*Module)
778}
779
780func (ctx *depsContext) toolchain() config.Toolchain {
781 return ctx.RustModule().toolchain(ctx)
782}
783
784func (ctx *baseModuleContext) RustModule() *Module {
785 return ctx.Module().(*Module)
786}
787
788func (ctx *baseModuleContext) toolchain() config.Toolchain {
789 return ctx.RustModule().toolchain(ctx)
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400790}
791
792func (mod *Module) nativeCoverage() bool {
Matthew Maurera61e31f2021-05-27 11:09:11 -0700793 // Bug: http://b/137883967 - native-bridge modules do not currently work with coverage
794 if mod.Target().NativeBridge == android.NativeBridgeEnabled {
795 return false
796 }
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400797 return mod.compiler != nil && mod.compiler.nativeCoverage()
798}
799
Ivan Lozanod7586b62021-04-01 09:49:36 -0400800func (mod *Module) EverInstallable() bool {
801 return mod.compiler != nil &&
802 // Check to see whether the module is actually ever installable.
803 mod.compiler.everInstallable()
804}
805
806func (mod *Module) Installable() *bool {
807 return mod.Properties.Installable
808}
809
Ivan Lozano872d5792022-03-23 17:31:39 -0400810func (mod *Module) ProcMacro() bool {
811 if pm, ok := mod.compiler.(procMacroInterface); ok {
812 return pm.ProcMacro()
813 }
814 return false
815}
816
Ivan Lozanoffee3342019-08-27 12:03:00 -0700817func (mod *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
818 if mod.cachedToolchain == nil {
819 mod.cachedToolchain = config.FindToolchain(ctx.Os(), ctx.Arch())
820 }
821 return mod.cachedToolchain
822}
823
Thiébaud Weksteen31f1bb82020-08-27 13:37:29 +0200824func (mod *Module) ccToolchain(ctx android.BaseModuleContext) cc_config.Toolchain {
825 return cc_config.FindToolchain(ctx.Os(), ctx.Arch())
826}
827
Ivan Lozanoffee3342019-08-27 12:03:00 -0700828func (d *Defaults) GenerateAndroidBuildActions(ctx android.ModuleContext) {
829}
830
831func (mod *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
832 ctx := &moduleContext{
833 ModuleContext: actx,
Ivan Lozanoffee3342019-08-27 12:03:00 -0700834 }
Ivan Lozanoffee3342019-08-27 12:03:00 -0700835
Jiyong Park99644e92020-11-17 22:21:02 +0900836 apexInfo := actx.Provider(android.ApexInfoProvider).(android.ApexInfo)
837 if !apexInfo.IsForPlatform() {
838 mod.hideApexVariantFromMake = true
839 }
840
Ivan Lozanoffee3342019-08-27 12:03:00 -0700841 toolchain := mod.toolchain(ctx)
Ivan Lozano6a884432020-12-02 09:15:16 -0500842 mod.makeLinkType = cc.GetMakeLinkType(actx, mod)
843
844 // Differentiate static libraries that are vendor available
845 if mod.UseVndk() {
Matthew Maurer52af5b02021-05-27 10:01:36 -0700846 if mod.InProduct() && !mod.OnlyInProduct() {
847 mod.Properties.SubName += cc.ProductSuffix
848 } else {
849 mod.Properties.SubName += cc.VendorSuffix
850 }
Matthew Maurerc6868382021-07-13 14:12:37 -0700851 } else if mod.InRamdisk() && !mod.OnlyInRamdisk() {
852 mod.Properties.SubName += cc.RamdiskSuffix
Ivan Lozanoe6d30982021-02-05 10:57:43 -0500853 } else if mod.InVendorRamdisk() && !mod.OnlyInVendorRamdisk() {
854 mod.Properties.SubName += cc.VendorRamdiskSuffix
Matthew Maurer460ee942021-02-11 12:31:46 -0800855 } else if mod.InRecovery() && !mod.OnlyInRecovery() {
856 mod.Properties.SubName += cc.RecoverySuffix
Ivan Lozano6a884432020-12-02 09:15:16 -0500857 }
Ivan Lozanoffee3342019-08-27 12:03:00 -0700858
Matthew Maurera61e31f2021-05-27 11:09:11 -0700859 if mod.Target().NativeBridge == android.NativeBridgeEnabled {
860 mod.Properties.SubName += cc.NativeBridgeSuffix
861 }
862
Ivan Lozanoffee3342019-08-27 12:03:00 -0700863 if !toolchain.Supported() {
864 // This toolchain's unsupported, there's nothing to do for this mod.
865 return
866 }
867
868 deps := mod.depsToPaths(ctx)
869 flags := Flags{
870 Toolchain: toolchain,
871 }
872
Ivan Lozano67eada32021-09-23 11:50:33 -0400873 // Calculate rustc flags
Yi Kong46c6e592022-01-20 22:55:00 +0800874 if mod.afdo != nil {
875 flags, deps = mod.afdo.flags(ctx, flags, deps)
876 }
Ivan Lozanoffee3342019-08-27 12:03:00 -0700877 if mod.compiler != nil {
878 flags = mod.compiler.compilerFlags(ctx, flags)
Ivan Lozano67eada32021-09-23 11:50:33 -0400879 flags = mod.compiler.cfgFlags(ctx, flags)
880 flags = mod.compiler.featureFlags(ctx, flags)
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400881 }
882 if mod.coverage != nil {
883 flags, deps = mod.coverage.flags(ctx, flags, deps)
884 }
Thiébaud Weksteen92f703b2020-06-22 13:28:02 +0200885 if mod.clippy != nil {
886 flags, deps = mod.clippy.flags(ctx, flags, deps)
887 }
Ivan Lozano6cd99e62020-02-11 08:24:25 -0500888 if mod.sanitize != nil {
889 flags, deps = mod.sanitize.flags(ctx, flags, deps)
890 }
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400891
Thiébaud Weksteen295c72b2020-09-23 18:10:17 +0200892 // SourceProvider needs to call GenerateSource() before compiler calls
893 // compile() so it can provide the source. A SourceProvider has
894 // multiple variants (e.g. source, rlib, dylib). Only the "source"
895 // variant is responsible for effectively generating the source. The
896 // remaining variants relies on the "source" variant output.
Ivan Lozano26ecd6c2020-07-31 13:40:31 -0400897 if mod.sourceProvider != nil {
Thiébaud Weksteen295c72b2020-09-23 18:10:17 +0200898 if mod.compiler.(libraryInterface).source() {
899 mod.sourceProvider.GenerateSource(ctx, deps)
900 mod.sourceProvider.setSubName(ctx.ModuleSubDir())
901 } else {
902 sourceMod := actx.GetDirectDepWithTag(mod.Name(), sourceDepTag)
903 sourceLib := sourceMod.(*Module).compiler.(*libraryDecorator)
Chih-Hung Hsiehc49649c2020-10-01 21:25:05 -0700904 mod.sourceProvider.setOutputFiles(sourceLib.sourceProvider.Srcs())
Thiébaud Weksteen295c72b2020-09-23 18:10:17 +0200905 }
Ivan Lozano26ecd6c2020-07-31 13:40:31 -0400906 }
907
908 if mod.compiler != nil && !mod.compiler.Disabled() {
Thiébaud Weksteenee6a89b2021-02-25 16:30:57 +0100909 mod.compiler.initialize(ctx)
Ivan Lozano8d10fc32021-11-05 16:36:47 -0400910 outputFile := mod.compiler.compile(ctx, flags, deps)
911 if ctx.Failed() {
912 return
913 }
914 mod.outputFile = android.OptionalPathForPath(outputFile)
915 bloaty.MeasureSizeForPaths(ctx, mod.compiler.strippedOutputFilePath(), android.OptionalPathForPath(mod.compiler.unstrippedOutputFilePath()))
Jiyong Park459feca2020-12-15 11:02:21 +0900916
Dan Albert06feee92021-03-19 15:06:02 -0700917 mod.docTimestampFile = mod.compiler.rustdoc(ctx, flags, deps)
Matthew Maurere3803632021-12-10 21:57:21 +0000918 if mod.docTimestampFile.Valid() {
919 ctx.CheckbuildFile(mod.docTimestampFile.Path())
920 }
Dan Albert06feee92021-03-19 15:06:02 -0700921
Ivan Lozano1921e802021-05-20 13:39:16 -0400922 // glob exported headers for snapshot, if BOARD_VNDK_VERSION is current or
923 // RECOVERY_SNAPSHOT_VERSION is current.
924 if lib, ok := mod.compiler.(snapshotLibraryInterface); ok {
925 if cc.ShouldCollectHeadersForSnapshot(ctx, mod, apexInfo) {
926 lib.collectHeadersForSnapshot(ctx, deps)
927 }
928 }
929
Jiyong Park459feca2020-12-15 11:02:21 +0900930 apexInfo := actx.Provider(android.ApexInfoProvider).(android.ApexInfo)
Ivan Lozano872d5792022-03-23 17:31:39 -0400931 if !proptools.BoolDefault(mod.Installable(), mod.EverInstallable()) && !mod.ProcMacro() {
Jiyong Parkd1e366a2021-10-05 09:12:41 +0900932 // If the module has been specifically configure to not be installed then
933 // hide from make as otherwise it will break when running inside make as the
934 // output path to install will not be specified. Not all uninstallable
935 // modules can be hidden from make as some are needed for resolving make
Ivan Lozano872d5792022-03-23 17:31:39 -0400936 // side dependencies. In particular, proc-macros need to be captured in the
937 // host snapshot.
Jiyong Parkd1e366a2021-10-05 09:12:41 +0900938 mod.HideFromMake()
939 } else if !mod.installable(apexInfo) {
940 mod.SkipInstall()
941 }
942
943 // Still call install though, the installs will be stored as PackageSpecs to allow
944 // using the outputs in a genrule.
945 if mod.OutputFile().Valid() {
Thiébaud Weksteenfabaff62020-08-27 13:48:36 +0200946 mod.compiler.install(ctx)
Jiyong Parkd1e366a2021-10-05 09:12:41 +0900947 if ctx.Failed() {
948 return
949 }
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400950 }
Chris Wailes74be7642021-07-22 16:20:28 -0700951
952 ctx.Phony("rust", ctx.RustModule().OutputFile().Path())
Ivan Lozanoffee3342019-08-27 12:03:00 -0700953 }
954}
955
956func (mod *Module) deps(ctx DepsContext) Deps {
957 deps := Deps{}
958
959 if mod.compiler != nil {
960 deps = mod.compiler.compilerDeps(ctx, deps)
Ivan Lozano26ecd6c2020-07-31 13:40:31 -0400961 }
962 if mod.sourceProvider != nil {
Andrei Homescuc7767922020-08-05 06:36:19 -0700963 deps = mod.sourceProvider.SourceProviderDeps(ctx, deps)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700964 }
965
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400966 if mod.coverage != nil {
967 deps = mod.coverage.deps(ctx, deps)
968 }
969
Ivan Lozano6cd99e62020-02-11 08:24:25 -0500970 if mod.sanitize != nil {
971 deps = mod.sanitize.deps(ctx, deps)
972 }
973
Ivan Lozanoffee3342019-08-27 12:03:00 -0700974 deps.Rlibs = android.LastUniqueStrings(deps.Rlibs)
975 deps.Dylibs = android.LastUniqueStrings(deps.Dylibs)
Matthew Maurer0f003b12020-06-29 14:34:06 -0700976 deps.Rustlibs = android.LastUniqueStrings(deps.Rustlibs)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700977 deps.ProcMacros = android.LastUniqueStrings(deps.ProcMacros)
978 deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
979 deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
Andrew Walbran797e4be2022-03-07 15:41:53 +0000980 deps.Stdlibs = android.LastUniqueStrings(deps.Stdlibs)
Ivan Lozano63bb7682021-03-23 15:53:44 -0400981 deps.WholeStaticLibs = android.LastUniqueStrings(deps.WholeStaticLibs)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700982 return deps
983
984}
985
Ivan Lozanoffee3342019-08-27 12:03:00 -0700986type dependencyTag struct {
987 blueprint.BaseDependencyTag
Jaewoong Jung18aefc12020-12-21 09:11:10 -0800988 name string
989 library bool
990 procMacro bool
Colin Cross65cb3142021-12-10 23:05:02 +0000991 dynamic bool
Ivan Lozanoffee3342019-08-27 12:03:00 -0700992}
993
Jiyong Park65b62242020-11-25 12:44:59 +0900994// InstallDepNeeded returns true for rlibs, dylibs, and proc macros so that they or their transitive
995// dependencies (especially C/C++ shared libs) are installed as dependencies of a rust binary.
996func (d dependencyTag) InstallDepNeeded() bool {
Jaewoong Jung18aefc12020-12-21 09:11:10 -0800997 return d.library || d.procMacro
Jiyong Park65b62242020-11-25 12:44:59 +0900998}
999
1000var _ android.InstallNeededDependencyTag = dependencyTag{}
1001
Colin Cross65cb3142021-12-10 23:05:02 +00001002func (d dependencyTag) LicenseAnnotations() []android.LicenseAnnotation {
1003 if d.library && d.dynamic {
1004 return []android.LicenseAnnotation{android.LicenseAnnotationSharedDependency}
1005 }
1006 return nil
1007}
1008
1009var _ android.LicenseAnnotationsDependencyTag = dependencyTag{}
1010
Ivan Lozanoffee3342019-08-27 12:03:00 -07001011var (
Ivan Lozanoc564d2d2020-08-04 15:43:37 -04001012 customBindgenDepTag = dependencyTag{name: "customBindgenTag"}
1013 rlibDepTag = dependencyTag{name: "rlibTag", library: true}
Colin Cross65cb3142021-12-10 23:05:02 +00001014 dylibDepTag = dependencyTag{name: "dylib", library: true, dynamic: true}
Jaewoong Jung18aefc12020-12-21 09:11:10 -08001015 procMacroDepTag = dependencyTag{name: "procMacro", procMacro: true}
Ivan Lozanoc564d2d2020-08-04 15:43:37 -04001016 testPerSrcDepTag = dependencyTag{name: "rust_unit_tests"}
Thiébaud Weksteen295c72b2020-09-23 18:10:17 +02001017 sourceDepTag = dependencyTag{name: "source"}
Ivan Lozano4e5f07d2021-11-04 14:09:38 -04001018 dataLibDepTag = dependencyTag{name: "data lib"}
1019 dataBinDepTag = dependencyTag{name: "data bin"}
Ivan Lozanoffee3342019-08-27 12:03:00 -07001020)
1021
Jiyong Park99644e92020-11-17 22:21:02 +09001022func IsDylibDepTag(depTag blueprint.DependencyTag) bool {
1023 tag, ok := depTag.(dependencyTag)
1024 return ok && tag == dylibDepTag
1025}
1026
Jiyong Park94e22fd2021-04-08 18:19:15 +09001027func IsRlibDepTag(depTag blueprint.DependencyTag) bool {
1028 tag, ok := depTag.(dependencyTag)
1029 return ok && tag == rlibDepTag
1030}
1031
Matthew Maurer0f003b12020-06-29 14:34:06 -07001032type autoDep struct {
1033 variation string
1034 depTag dependencyTag
1035}
1036
1037var (
Thiébaud Weksteen295c72b2020-09-23 18:10:17 +02001038 rlibVariation = "rlib"
1039 dylibVariation = "dylib"
1040 rlibAutoDep = autoDep{variation: rlibVariation, depTag: rlibDepTag}
1041 dylibAutoDep = autoDep{variation: dylibVariation, depTag: dylibDepTag}
Matthew Maurer0f003b12020-06-29 14:34:06 -07001042)
1043
1044type autoDeppable interface {
Liz Kammer356f7d42021-01-26 09:18:53 -05001045 autoDep(ctx android.BottomUpMutatorContext) autoDep
Matthew Maurer0f003b12020-06-29 14:34:06 -07001046}
1047
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001048func (mod *Module) begin(ctx BaseModuleContext) {
1049 if mod.coverage != nil {
1050 mod.coverage.begin(ctx)
1051 }
Ivan Lozano6cd99e62020-02-11 08:24:25 -05001052 if mod.sanitize != nil {
1053 mod.sanitize.begin(ctx)
1054 }
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001055}
1056
Ivan Lozanofba2aa22021-11-11 09:29:07 -05001057func (mod *Module) Prebuilt() *android.Prebuilt {
Ivan Lozano872d5792022-03-23 17:31:39 -04001058 if p, ok := mod.compiler.(rustPrebuilt); ok {
Ivan Lozanofba2aa22021-11-11 09:29:07 -05001059 return p.prebuilt()
1060 }
1061 return nil
1062}
1063
Ivan Lozanoffee3342019-08-27 12:03:00 -07001064func (mod *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
1065 var depPaths PathDeps
1066
1067 directRlibDeps := []*Module{}
1068 directDylibDeps := []*Module{}
1069 directProcMacroDeps := []*Module{}
Jiyong Park7d55b612021-06-11 17:22:09 +09001070 directSharedLibDeps := []cc.SharedLibraryInfo{}
Ivan Lozano52767be2019-10-18 14:49:46 -07001071 directStaticLibDeps := [](cc.LinkableInterface){}
Ivan Lozano07cbaf42020-07-22 16:09:13 -04001072 directSrcProvidersDeps := []*Module{}
1073 directSrcDeps := [](android.SourceFileProducer){}
Ivan Lozanoffee3342019-08-27 12:03:00 -07001074
Ivan Lozanoe950cda2021-11-09 11:26:04 -05001075 // For the dependency from platform to apex, use the latest stubs
1076 mod.apexSdkVersion = android.FutureApiLevel
1077 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
1078 if !apexInfo.IsForPlatform() {
1079 mod.apexSdkVersion = apexInfo.MinSdkVersion
1080 }
1081
1082 if android.InList("hwaddress", ctx.Config().SanitizeDevice()) {
1083 // In hwasan build, we override apexSdkVersion to the FutureApiLevel(10000)
1084 // so that even Q(29/Android10) apexes could use the dynamic unwinder by linking the newer stubs(e.g libc(R+)).
1085 // (b/144430859)
1086 mod.apexSdkVersion = android.FutureApiLevel
1087 }
1088
Ivan Lozanoffee3342019-08-27 12:03:00 -07001089 ctx.VisitDirectDeps(func(dep android.Module) {
1090 depName := ctx.OtherModuleName(dep)
1091 depTag := ctx.OtherModuleDependencyTag(dep)
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001092
Ivan Lozano89435d12020-07-31 11:01:18 -04001093 if rustDep, ok := dep.(*Module); ok && !rustDep.CcLibraryInterface() {
Ivan Lozanoffee3342019-08-27 12:03:00 -07001094 //Handle Rust Modules
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001095 makeLibName := cc.MakeLibName(ctx, mod, rustDep, depName+rustDep.Properties.RustSubName)
Ivan Lozano70e0a072019-09-13 14:23:15 -07001096
Ivan Lozanoffee3342019-08-27 12:03:00 -07001097 switch depTag {
1098 case dylibDepTag:
1099 dylib, ok := rustDep.compiler.(libraryInterface)
1100 if !ok || !dylib.dylib() {
1101 ctx.ModuleErrorf("mod %q not an dylib library", depName)
1102 return
1103 }
1104 directDylibDeps = append(directDylibDeps, rustDep)
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001105 mod.Properties.AndroidMkDylibs = append(mod.Properties.AndroidMkDylibs, makeLibName)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001106 case rlibDepTag:
Ivan Lozano2b081132020-09-08 12:46:52 -04001107
Ivan Lozanoffee3342019-08-27 12:03:00 -07001108 rlib, ok := rustDep.compiler.(libraryInterface)
1109 if !ok || !rlib.rlib() {
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001110 ctx.ModuleErrorf("mod %q not an rlib library", makeLibName)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001111 return
1112 }
1113 directRlibDeps = append(directRlibDeps, rustDep)
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001114 mod.Properties.AndroidMkRlibs = append(mod.Properties.AndroidMkRlibs, makeLibName)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001115 case procMacroDepTag:
1116 directProcMacroDeps = append(directProcMacroDeps, rustDep)
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001117 mod.Properties.AndroidMkProcMacroLibs = append(mod.Properties.AndroidMkProcMacroLibs, makeLibName)
Paul Duffind5cf92e2021-07-09 17:38:55 +01001118 }
1119
1120 if android.IsSourceDepTagWithOutputTag(depTag, "") {
Ivan Lozano07cbaf42020-07-22 16:09:13 -04001121 // Since these deps are added in path_properties.go via AddDependencies, we need to ensure the correct
1122 // OS/Arch variant is used.
1123 var helper string
1124 if ctx.Host() {
1125 helper = "missing 'host_supported'?"
1126 } else {
1127 helper = "device module defined?"
1128 }
1129
1130 if dep.Target().Os != ctx.Os() {
1131 ctx.ModuleErrorf("OS mismatch on dependency %q (%s)", dep.Name(), helper)
1132 return
1133 } else if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
1134 ctx.ModuleErrorf("Arch mismatch on dependency %q (%s)", dep.Name(), helper)
1135 return
1136 }
1137 directSrcProvidersDeps = append(directSrcProvidersDeps, rustDep)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001138 }
1139
Ivan Lozano2bbcacf2020-08-07 09:00:50 -04001140 //Append the dependencies exportedDirs, except for proc-macros which target a different arch/OS
Colin Cross0de8a1e2020-09-18 14:15:30 -07001141 if depTag != procMacroDepTag {
1142 exportedInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
1143 depPaths.linkDirs = append(depPaths.linkDirs, exportedInfo.LinkDirs...)
1144 depPaths.depFlags = append(depPaths.depFlags, exportedInfo.Flags...)
1145 depPaths.linkObjects = append(depPaths.linkObjects, exportedInfo.LinkObjects...)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001146 }
1147
Ivan Lozanoffee3342019-08-27 12:03:00 -07001148 if depTag == dylibDepTag || depTag == rlibDepTag || depTag == procMacroDepTag {
Ivan Lozano8d10fc32021-11-05 16:36:47 -04001149 linkFile := rustDep.UnstrippedOutputFile()
1150 linkDir := linkPathFromFilePath(linkFile)
Matthew Maurerbb3add12020-06-25 09:34:12 -07001151 if lib, ok := mod.compiler.(exportedFlagsProducer); ok {
1152 lib.exportLinkDirs(linkDir)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001153 }
1154 }
1155
Ivan Lozano89435d12020-07-31 11:01:18 -04001156 } else if ccDep, ok := dep.(cc.LinkableInterface); ok {
Ivan Lozano52767be2019-10-18 14:49:46 -07001157 //Handle C dependencies
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001158 makeLibName := cc.MakeLibName(ctx, mod, ccDep, depName)
Ivan Lozano52767be2019-10-18 14:49:46 -07001159 if _, ok := ccDep.(*Module); !ok {
1160 if ccDep.Module().Target().Os != ctx.Os() {
1161 ctx.ModuleErrorf("OS mismatch between %q and %q", ctx.ModuleName(), depName)
1162 return
1163 }
1164 if ccDep.Module().Target().Arch.ArchType != ctx.Arch().ArchType {
1165 ctx.ModuleErrorf("Arch mismatch between %q and %q", ctx.ModuleName(), depName)
1166 return
1167 }
Ivan Lozano70e0a072019-09-13 14:23:15 -07001168 }
Ivan Lozano2093af22020-08-25 12:48:19 -04001169 linkObject := ccDep.OutputFile()
1170 linkPath := linkPathFromFilePath(linkObject.Path())
Ivan Lozano6aa66022020-02-06 13:22:43 -05001171
Ivan Lozano2093af22020-08-25 12:48:19 -04001172 if !linkObject.Valid() {
Ivan Lozanoffee3342019-08-27 12:03:00 -07001173 ctx.ModuleErrorf("Invalid output file when adding dep %q to %q", depName, ctx.ModuleName())
1174 }
1175
1176 exportDep := false
Colin Cross6e511a92020-07-27 21:26:48 -07001177 switch {
1178 case cc.IsStaticDepTag(depTag):
Ivan Lozano63bb7682021-03-23 15:53:44 -04001179 if cc.IsWholeStaticLib(depTag) {
1180 // rustc will bundle static libraries when they're passed with "-lstatic=<lib>". This will fail
1181 // if the library is not prefixed by "lib".
Ivan Lozanofdadcd72021-11-01 09:04:23 -04001182 if mod.Binary() {
1183 // Binaries may sometimes need to link whole static libraries that don't start with 'lib'.
1184 // Since binaries don't need to 'rebundle' these like libraries and only use these for the
1185 // final linkage, pass the args directly to the linker to handle these cases.
1186 depPaths.depLinkFlags = append(depPaths.depLinkFlags, []string{"-Wl,--whole-archive", linkObject.Path().String(), "-Wl,--no-whole-archive"}...)
1187 } else if libName, ok := libNameFromFilePath(linkObject.Path()); ok {
Ivan Lozanofb6f36f2021-02-05 12:27:08 -05001188 depPaths.depFlags = append(depPaths.depFlags, "-lstatic="+libName)
Ivan Lozano63bb7682021-03-23 15:53:44 -04001189 } else {
1190 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 -05001191 }
Ivan Lozano3dfa12d2021-02-04 11:29:41 -05001192 }
1193
1194 // Add this to linkObjects to pass the library directly to the linker as well. This propagates
1195 // to dependencies to avoid having to redeclare static libraries for dependents of the dylib variant.
Ivan Lozano2093af22020-08-25 12:48:19 -04001196 depPaths.linkObjects = append(depPaths.linkObjects, linkObject.String())
Ivan Lozano3dfa12d2021-02-04 11:29:41 -05001197 depPaths.linkDirs = append(depPaths.linkDirs, linkPath)
1198
Colin Cross0de8a1e2020-09-18 14:15:30 -07001199 exportedInfo := ctx.OtherModuleProvider(dep, cc.FlagExporterInfoProvider).(cc.FlagExporterInfo)
1200 depPaths.depIncludePaths = append(depPaths.depIncludePaths, exportedInfo.IncludeDirs...)
1201 depPaths.depSystemIncludePaths = append(depPaths.depSystemIncludePaths, exportedInfo.SystemIncludeDirs...)
1202 depPaths.depClangFlags = append(depPaths.depClangFlags, exportedInfo.Flags...)
1203 depPaths.depGeneratedHeaders = append(depPaths.depGeneratedHeaders, exportedInfo.GeneratedHeaders...)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001204 directStaticLibDeps = append(directStaticLibDeps, ccDep)
Justin Yun2b3ed642022-02-16 08:15:07 +09001205
1206 // Record baseLibName for snapshots.
1207 mod.Properties.SnapshotStaticLibs = append(mod.Properties.SnapshotStaticLibs, cc.BaseLibName(depName))
1208
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001209 mod.Properties.AndroidMkStaticLibs = append(mod.Properties.AndroidMkStaticLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07001210 case cc.IsSharedDepTag(depTag):
Jiyong Park7d55b612021-06-11 17:22:09 +09001211 // For the shared lib dependencies, we may link to the stub variant
1212 // of the dependency depending on the context (e.g. if this
1213 // dependency crosses the APEX boundaries).
1214 sharedLibraryInfo, exportedInfo := cc.ChooseStubOrImpl(ctx, dep)
1215
1216 // Re-get linkObject as ChooseStubOrImpl actually tells us which
1217 // object (either from stub or non-stub) to use.
1218 linkObject = android.OptionalPathForPath(sharedLibraryInfo.SharedLibrary)
1219 linkPath = linkPathFromFilePath(linkObject.Path())
1220
Ivan Lozanoffee3342019-08-27 12:03:00 -07001221 depPaths.linkDirs = append(depPaths.linkDirs, linkPath)
Ivan Lozano2093af22020-08-25 12:48:19 -04001222 depPaths.linkObjects = append(depPaths.linkObjects, linkObject.String())
Colin Cross0de8a1e2020-09-18 14:15:30 -07001223 depPaths.depIncludePaths = append(depPaths.depIncludePaths, exportedInfo.IncludeDirs...)
1224 depPaths.depSystemIncludePaths = append(depPaths.depSystemIncludePaths, exportedInfo.SystemIncludeDirs...)
1225 depPaths.depClangFlags = append(depPaths.depClangFlags, exportedInfo.Flags...)
1226 depPaths.depGeneratedHeaders = append(depPaths.depGeneratedHeaders, exportedInfo.GeneratedHeaders...)
Jiyong Park7d55b612021-06-11 17:22:09 +09001227 directSharedLibDeps = append(directSharedLibDeps, sharedLibraryInfo)
Ivan Lozano1921e802021-05-20 13:39:16 -04001228
1229 // Record baseLibName for snapshots.
1230 mod.Properties.SnapshotSharedLibs = append(mod.Properties.SnapshotSharedLibs, cc.BaseLibName(depName))
1231
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001232 mod.Properties.AndroidMkSharedLibs = append(mod.Properties.AndroidMkSharedLibs, makeLibName)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001233 exportDep = true
Zach Johnson3df4e632020-11-06 11:56:27 -08001234 case cc.IsHeaderDepTag(depTag):
1235 exportedInfo := ctx.OtherModuleProvider(dep, cc.FlagExporterInfoProvider).(cc.FlagExporterInfo)
1236 depPaths.depIncludePaths = append(depPaths.depIncludePaths, exportedInfo.IncludeDirs...)
1237 depPaths.depSystemIncludePaths = append(depPaths.depSystemIncludePaths, exportedInfo.SystemIncludeDirs...)
1238 depPaths.depGeneratedHeaders = append(depPaths.depGeneratedHeaders, exportedInfo.GeneratedHeaders...)
Colin Cross6e511a92020-07-27 21:26:48 -07001239 case depTag == cc.CrtBeginDepTag:
Colin Crossfe605e12022-01-23 20:46:16 -08001240 depPaths.CrtBegin = append(depPaths.CrtBegin, linkObject.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07001241 case depTag == cc.CrtEndDepTag:
Colin Crossfe605e12022-01-23 20:46:16 -08001242 depPaths.CrtEnd = append(depPaths.CrtEnd, linkObject.Path())
Ivan Lozanoffee3342019-08-27 12:03:00 -07001243 }
1244
1245 // Make sure these dependencies are propagated
Matthew Maurerbb3add12020-06-25 09:34:12 -07001246 if lib, ok := mod.compiler.(exportedFlagsProducer); ok && exportDep {
1247 lib.exportLinkDirs(linkPath)
Ivan Lozano2093af22020-08-25 12:48:19 -04001248 lib.exportLinkObjects(linkObject.String())
Ivan Lozanoffee3342019-08-27 12:03:00 -07001249 }
Colin Cross018cbeb2022-01-24 17:22:45 -08001250 } else {
1251 switch {
1252 case depTag == cc.CrtBeginDepTag:
1253 depPaths.CrtBegin = append(depPaths.CrtBegin, android.OutputFileForModule(ctx, dep, ""))
1254 case depTag == cc.CrtEndDepTag:
1255 depPaths.CrtEnd = append(depPaths.CrtEnd, android.OutputFileForModule(ctx, dep, ""))
1256 }
Ivan Lozanoffee3342019-08-27 12:03:00 -07001257 }
Ivan Lozano89435d12020-07-31 11:01:18 -04001258
1259 if srcDep, ok := dep.(android.SourceFileProducer); ok {
Paul Duffind5cf92e2021-07-09 17:38:55 +01001260 if android.IsSourceDepTagWithOutputTag(depTag, "") {
Ivan Lozano89435d12020-07-31 11:01:18 -04001261 // These are usually genrules which don't have per-target variants.
1262 directSrcDeps = append(directSrcDeps, srcDep)
1263 }
1264 }
Ivan Lozanoffee3342019-08-27 12:03:00 -07001265 })
1266
1267 var rlibDepFiles RustLibraries
1268 for _, dep := range directRlibDeps {
Ivan Lozano8d10fc32021-11-05 16:36:47 -04001269 rlibDepFiles = append(rlibDepFiles, RustLibrary{Path: dep.UnstrippedOutputFile(), CrateName: dep.CrateName()})
Ivan Lozanoffee3342019-08-27 12:03:00 -07001270 }
1271 var dylibDepFiles RustLibraries
1272 for _, dep := range directDylibDeps {
Ivan Lozano8d10fc32021-11-05 16:36:47 -04001273 dylibDepFiles = append(dylibDepFiles, RustLibrary{Path: dep.UnstrippedOutputFile(), CrateName: dep.CrateName()})
Ivan Lozanoffee3342019-08-27 12:03:00 -07001274 }
1275 var procMacroDepFiles RustLibraries
1276 for _, dep := range directProcMacroDeps {
Ivan Lozano8d10fc32021-11-05 16:36:47 -04001277 procMacroDepFiles = append(procMacroDepFiles, RustLibrary{Path: dep.UnstrippedOutputFile(), CrateName: dep.CrateName()})
Ivan Lozanoffee3342019-08-27 12:03:00 -07001278 }
1279
1280 var staticLibDepFiles android.Paths
1281 for _, dep := range directStaticLibDeps {
1282 staticLibDepFiles = append(staticLibDepFiles, dep.OutputFile().Path())
1283 }
1284
Ivan Lozanoec6e9912021-01-21 15:23:29 -05001285 var sharedLibFiles android.Paths
Ivan Lozanoffee3342019-08-27 12:03:00 -07001286 var sharedLibDepFiles android.Paths
1287 for _, dep := range directSharedLibDeps {
Jiyong Park7d55b612021-06-11 17:22:09 +09001288 sharedLibFiles = append(sharedLibFiles, dep.SharedLibrary)
1289 if dep.TableOfContents.Valid() {
1290 sharedLibDepFiles = append(sharedLibDepFiles, dep.TableOfContents.Path())
Ivan Lozanoec6e9912021-01-21 15:23:29 -05001291 } else {
Jiyong Park7d55b612021-06-11 17:22:09 +09001292 sharedLibDepFiles = append(sharedLibDepFiles, dep.SharedLibrary)
Ivan Lozanoec6e9912021-01-21 15:23:29 -05001293 }
Ivan Lozanoffee3342019-08-27 12:03:00 -07001294 }
1295
Ivan Lozano07cbaf42020-07-22 16:09:13 -04001296 var srcProviderDepFiles android.Paths
1297 for _, dep := range directSrcProvidersDeps {
1298 srcs, _ := dep.OutputFiles("")
1299 srcProviderDepFiles = append(srcProviderDepFiles, srcs...)
1300 }
1301 for _, dep := range directSrcDeps {
1302 srcs := dep.Srcs()
1303 srcProviderDepFiles = append(srcProviderDepFiles, srcs...)
1304 }
1305
Ivan Lozanoffee3342019-08-27 12:03:00 -07001306 depPaths.RLibs = append(depPaths.RLibs, rlibDepFiles...)
1307 depPaths.DyLibs = append(depPaths.DyLibs, dylibDepFiles...)
1308 depPaths.SharedLibs = append(depPaths.SharedLibs, sharedLibDepFiles...)
Ivan Lozanoec6e9912021-01-21 15:23:29 -05001309 depPaths.SharedLibDeps = append(depPaths.SharedLibDeps, sharedLibDepFiles...)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001310 depPaths.StaticLibs = append(depPaths.StaticLibs, staticLibDepFiles...)
1311 depPaths.ProcMacros = append(depPaths.ProcMacros, procMacroDepFiles...)
Ivan Lozano07cbaf42020-07-22 16:09:13 -04001312 depPaths.SrcDeps = append(depPaths.SrcDeps, srcProviderDepFiles...)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001313
1314 // Dedup exported flags from dependencies
1315 depPaths.linkDirs = android.FirstUniqueStrings(depPaths.linkDirs)
Ivan Lozanoec6e9912021-01-21 15:23:29 -05001316 depPaths.linkObjects = android.FirstUniqueStrings(depPaths.linkObjects)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001317 depPaths.depFlags = android.FirstUniqueStrings(depPaths.depFlags)
Ivan Lozano45901ed2020-07-24 16:05:01 -04001318 depPaths.depClangFlags = android.FirstUniqueStrings(depPaths.depClangFlags)
1319 depPaths.depIncludePaths = android.FirstUniquePaths(depPaths.depIncludePaths)
1320 depPaths.depSystemIncludePaths = android.FirstUniquePaths(depPaths.depSystemIncludePaths)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001321
1322 return depPaths
1323}
1324
Chih-Hung Hsieh9a4a7ba2019-12-12 19:36:05 -08001325func (mod *Module) InstallInData() bool {
1326 if mod.compiler == nil {
1327 return false
1328 }
1329 return mod.compiler.inData()
1330}
1331
Matthew Maurer9f59e8d2021-08-19 13:10:05 -07001332func (mod *Module) InstallInRamdisk() bool {
1333 return mod.InRamdisk()
1334}
1335
1336func (mod *Module) InstallInVendorRamdisk() bool {
1337 return mod.InVendorRamdisk()
1338}
1339
1340func (mod *Module) InstallInRecovery() bool {
1341 return mod.InRecovery()
1342}
1343
Ivan Lozanoffee3342019-08-27 12:03:00 -07001344func linkPathFromFilePath(filepath android.Path) string {
1345 return strings.Split(filepath.String(), filepath.Base())[0]
1346}
Ivan Lozanod648c432020-02-06 12:05:10 -05001347
Ivan Lozanoffee3342019-08-27 12:03:00 -07001348func (mod *Module) DepsMutator(actx android.BottomUpMutatorContext) {
1349 ctx := &depsContext{
1350 BottomUpMutatorContext: actx,
Ivan Lozanoffee3342019-08-27 12:03:00 -07001351 }
Ivan Lozanoffee3342019-08-27 12:03:00 -07001352
1353 deps := mod.deps(ctx)
Colin Cross3146c5c2020-09-30 15:34:40 -07001354 var commonDepVariations []blueprint.Variation
Ivan Lozano1921e802021-05-20 13:39:16 -04001355 var snapshotInfo *cc.SnapshotInfo
1356
1357 if ctx.Os() == android.Android {
1358 deps.SharedLibs, _ = cc.RewriteLibs(mod, &snapshotInfo, actx, ctx.Config(), deps.SharedLibs)
1359 }
Ivan Lozanodd055472020-09-28 13:22:45 -04001360
Ivan Lozano2b081132020-09-08 12:46:52 -04001361 stdLinkage := "dylib-std"
Ivan Lozanodd055472020-09-28 13:22:45 -04001362 if mod.compiler.stdLinkage(ctx) == RlibLinkage {
Ivan Lozano2b081132020-09-08 12:46:52 -04001363 stdLinkage = "rlib-std"
1364 }
1365
1366 rlibDepVariations := commonDepVariations
Ivan Lozano1921e802021-05-20 13:39:16 -04001367
Ivan Lozano2b081132020-09-08 12:46:52 -04001368 if lib, ok := mod.compiler.(libraryInterface); !ok || !lib.sysroot() {
1369 rlibDepVariations = append(rlibDepVariations,
1370 blueprint.Variation{Mutator: "rust_stdlinkage", Variation: stdLinkage})
1371 }
1372
Ivan Lozano1921e802021-05-20 13:39:16 -04001373 // rlibs
Ivan Lozano2d407632022-04-07 12:59:11 -04001374 rlibDepVariations = append(rlibDepVariations, blueprint.Variation{Mutator: "rust_libraries", Variation: rlibVariation})
Ivan Lozano3149e6e2021-06-01 15:09:53 -04001375 for _, lib := range deps.Rlibs {
1376 depTag := rlibDepTag
1377 lib = cc.RewriteSnapshotLib(lib, cc.GetSnapshot(mod, &snapshotInfo, actx).Rlibs)
1378
Ivan Lozano2d407632022-04-07 12:59:11 -04001379 actx.AddVariationDependencies(rlibDepVariations, depTag, lib)
Ivan Lozano3149e6e2021-06-01 15:09:53 -04001380 }
Ivan Lozano1921e802021-05-20 13:39:16 -04001381
1382 // dylibs
Ivan Lozano52767be2019-10-18 14:49:46 -07001383 actx.AddVariationDependencies(
1384 append(commonDepVariations, []blueprint.Variation{
Thiébaud Weksteen295c72b2020-09-23 18:10:17 +02001385 {Mutator: "rust_libraries", Variation: dylibVariation}}...),
Ivan Lozano52767be2019-10-18 14:49:46 -07001386 dylibDepTag, deps.Dylibs...)
1387
Ivan Lozano1921e802021-05-20 13:39:16 -04001388 // rustlibs
Ivan Lozano042504f2020-08-18 14:31:23 -04001389 if deps.Rustlibs != nil && !mod.compiler.Disabled() {
1390 autoDep := mod.compiler.(autoDeppable).autoDep(ctx)
Ivan Lozano2d407632022-04-07 12:59:11 -04001391 for _, lib := range deps.Rustlibs {
1392 if autoDep.depTag == rlibDepTag {
1393 // Handle the rlib deptag case
1394 addRlibDependency(actx, lib, mod, snapshotInfo, rlibDepVariations)
1395 } else {
1396 // autoDep.depTag is a dylib depTag. Not all rustlibs may be available as a dylib however.
1397 // Check for the existence of the dylib deptag variant. Select it if available,
1398 // otherwise select the rlib variant.
1399 autoDepVariations := append(commonDepVariations,
1400 blueprint.Variation{Mutator: "rust_libraries", Variation: autoDep.variation})
1401 if actx.OtherModuleDependencyVariantExists(autoDepVariations, lib) {
1402 actx.AddVariationDependencies(autoDepVariations, autoDep.depTag, lib)
1403 } else {
1404 // If there's no dylib dependency available, try to add the rlib dependency instead.
1405 addRlibDependency(actx, lib, mod, snapshotInfo, rlibDepVariations)
1406 }
Ivan Lozano3149e6e2021-06-01 15:09:53 -04001407 }
Ivan Lozano2b081132020-09-08 12:46:52 -04001408 }
Matthew Maurer0f003b12020-06-29 14:34:06 -07001409 }
Ivan Lozano1921e802021-05-20 13:39:16 -04001410 // stdlibs
Ivan Lozano2b081132020-09-08 12:46:52 -04001411 if deps.Stdlibs != nil {
Ivan Lozanodd055472020-09-28 13:22:45 -04001412 if mod.compiler.stdLinkage(ctx) == RlibLinkage {
Ivan Lozano3149e6e2021-06-01 15:09:53 -04001413 for _, lib := range deps.Stdlibs {
1414 depTag := rlibDepTag
1415 lib = cc.RewriteSnapshotLib(lib, cc.GetSnapshot(mod, &snapshotInfo, actx).Rlibs)
1416
1417 actx.AddVariationDependencies(append(commonDepVariations, []blueprint.Variation{{Mutator: "rust_libraries", Variation: "rlib"}}...),
1418 depTag, lib)
1419 }
Ivan Lozano2b081132020-09-08 12:46:52 -04001420 } else {
1421 actx.AddVariationDependencies(
1422 append(commonDepVariations, blueprint.Variation{Mutator: "rust_libraries", Variation: "dylib"}),
1423 dylibDepTag, deps.Stdlibs...)
1424 }
1425 }
Ivan Lozano1921e802021-05-20 13:39:16 -04001426
1427 for _, lib := range deps.SharedLibs {
1428 depTag := cc.SharedDepTag()
1429 name, version := cc.StubsLibNameAndVersion(lib)
1430
1431 variations := []blueprint.Variation{
1432 {Mutator: "link", Variation: "shared"},
1433 }
1434 cc.AddSharedLibDependenciesWithVersions(ctx, mod, variations, depTag, name, version, false)
1435 }
1436
1437 for _, lib := range deps.WholeStaticLibs {
1438 depTag := cc.StaticDepTag(true)
1439 lib = cc.RewriteSnapshotLib(lib, cc.GetSnapshot(mod, &snapshotInfo, actx).StaticLibs)
1440
1441 actx.AddVariationDependencies([]blueprint.Variation{
1442 {Mutator: "link", Variation: "static"},
1443 }, depTag, lib)
1444 }
1445
1446 for _, lib := range deps.StaticLibs {
1447 depTag := cc.StaticDepTag(false)
1448 lib = cc.RewriteSnapshotLib(lib, cc.GetSnapshot(mod, &snapshotInfo, actx).StaticLibs)
1449
1450 actx.AddVariationDependencies([]blueprint.Variation{
1451 {Mutator: "link", Variation: "static"},
1452 }, depTag, lib)
1453 }
Ivan Lozano5ca5ef62019-09-23 10:10:40 -07001454
Zach Johnson3df4e632020-11-06 11:56:27 -08001455 actx.AddVariationDependencies(nil, cc.HeaderDepTag(), deps.HeaderLibs...)
1456
Colin Cross565cafd2020-09-25 18:47:38 -07001457 crtVariations := cc.GetCrtVariations(ctx, mod)
Colin Crossfe605e12022-01-23 20:46:16 -08001458 for _, crt := range deps.CrtBegin {
Ivan Lozano1921e802021-05-20 13:39:16 -04001459 actx.AddVariationDependencies(crtVariations, cc.CrtBeginDepTag,
Colin Crossfe605e12022-01-23 20:46:16 -08001460 cc.RewriteSnapshotLib(crt, cc.GetSnapshot(mod, &snapshotInfo, actx).Objects))
Ivan Lozanof1c84332019-09-20 11:00:37 -07001461 }
Colin Crossfe605e12022-01-23 20:46:16 -08001462 for _, crt := range deps.CrtEnd {
Ivan Lozano1921e802021-05-20 13:39:16 -04001463 actx.AddVariationDependencies(crtVariations, cc.CrtEndDepTag,
Colin Crossfe605e12022-01-23 20:46:16 -08001464 cc.RewriteSnapshotLib(crt, cc.GetSnapshot(mod, &snapshotInfo, actx).Objects))
Ivan Lozanof1c84332019-09-20 11:00:37 -07001465 }
1466
Ivan Lozanoc564d2d2020-08-04 15:43:37 -04001467 if mod.sourceProvider != nil {
1468 if bindgen, ok := mod.sourceProvider.(*bindgenDecorator); ok &&
1469 bindgen.Properties.Custom_bindgen != "" {
1470 actx.AddFarVariationDependencies(ctx.Config().BuildOSTarget.Variations(), customBindgenDepTag,
1471 bindgen.Properties.Custom_bindgen)
1472 }
1473 }
Ivan Lozano1921e802021-05-20 13:39:16 -04001474
Ivan Lozano4e5f07d2021-11-04 14:09:38 -04001475 actx.AddVariationDependencies([]blueprint.Variation{
1476 {Mutator: "link", Variation: "shared"},
1477 }, dataLibDepTag, deps.DataLibs...)
1478
1479 actx.AddVariationDependencies(nil, dataBinDepTag, deps.DataBins...)
1480
Ivan Lozano5ca5ef62019-09-23 10:10:40 -07001481 // proc_macros are compiler plugins, and so we need the host arch variant as a dependendcy.
Colin Cross0f7d2ef2019-10-16 11:03:10 -07001482 actx.AddFarVariationDependencies(ctx.Config().BuildOSTarget.Variations(), procMacroDepTag, deps.ProcMacros...)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001483}
1484
Ivan Lozano2d407632022-04-07 12:59:11 -04001485// addRlibDependency will add an rlib dependency, rewriting to the snapshot library if available.
1486func addRlibDependency(actx android.BottomUpMutatorContext, lib string, mod *Module, snapshotInfo *cc.SnapshotInfo, variations []blueprint.Variation) {
1487 lib = cc.RewriteSnapshotLib(lib, cc.GetSnapshot(mod, &snapshotInfo, actx).Rlibs)
1488 actx.AddVariationDependencies(variations, rlibDepTag, lib)
1489}
1490
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001491func BeginMutator(ctx android.BottomUpMutatorContext) {
1492 if mod, ok := ctx.Module().(*Module); ok && mod.Enabled() {
1493 mod.beginMutator(ctx)
1494 }
1495}
1496
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001497func (mod *Module) beginMutator(actx android.BottomUpMutatorContext) {
1498 ctx := &baseModuleContext{
1499 BaseModuleContext: actx,
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001500 }
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001501
1502 mod.begin(ctx)
1503}
1504
Ivan Lozanoffee3342019-08-27 12:03:00 -07001505func (mod *Module) Name() string {
1506 name := mod.ModuleBase.Name()
1507 if p, ok := mod.compiler.(interface {
1508 Name(string) string
1509 }); ok {
1510 name = p.Name(name)
1511 }
1512 return name
1513}
1514
Thiébaud Weksteen9e8451e2020-08-13 12:55:59 +02001515func (mod *Module) disableClippy() {
Ivan Lozano32267c82020-08-04 16:27:16 -04001516 if mod.clippy != nil {
Thiébaud Weksteen9e8451e2020-08-13 12:55:59 +02001517 mod.clippy.Properties.Clippy_lints = proptools.StringPtr("none")
Ivan Lozano32267c82020-08-04 16:27:16 -04001518 }
1519}
1520
Chih-Hung Hsieh5c4e4892020-05-15 17:36:30 -07001521var _ android.HostToolProvider = (*Module)(nil)
Ivan Lozano872d5792022-03-23 17:31:39 -04001522var _ snapshot.RelativeInstallPath = (*Module)(nil)
Chih-Hung Hsieh5c4e4892020-05-15 17:36:30 -07001523
1524func (mod *Module) HostToolPath() android.OptionalPath {
1525 if !mod.Host() {
1526 return android.OptionalPath{}
1527 }
Chih-Hung Hsieha7562702020-08-10 21:50:43 -07001528 if binary, ok := mod.compiler.(*binaryDecorator); ok {
1529 return android.OptionalPathForPath(binary.baseCompiler.path)
Ivan Lozano872d5792022-03-23 17:31:39 -04001530 } else if pm, ok := mod.compiler.(*procMacroDecorator); ok {
1531 // Even though proc-macros aren't strictly "tools", since they target the compiler
1532 // and act as compiler plugins, we treat them similarly.
1533 return android.OptionalPathForPath(pm.baseCompiler.path)
Chih-Hung Hsieh5c4e4892020-05-15 17:36:30 -07001534 }
1535 return android.OptionalPath{}
1536}
1537
Jiyong Park99644e92020-11-17 22:21:02 +09001538var _ android.ApexModule = (*Module)(nil)
1539
Ivan Lozanoa91ba252022-01-11 12:02:06 -05001540func (mod *Module) MinSdkVersion() string {
Ivan Lozano3e9f9e42020-12-04 15:05:43 -05001541 return String(mod.Properties.Min_sdk_version)
1542}
1543
Jiyong Park45bf82e2020-12-15 22:29:02 +09001544// Implements android.ApexModule
Jiyong Park99644e92020-11-17 22:21:02 +09001545func (mod *Module) ShouldSupportSdkVersion(ctx android.BaseModuleContext, sdkVersion android.ApiLevel) error {
Ivan Lozanoa91ba252022-01-11 12:02:06 -05001546 minSdkVersion := mod.MinSdkVersion()
Ivan Lozano3e9f9e42020-12-04 15:05:43 -05001547 if minSdkVersion == "apex_inherit" {
1548 return nil
1549 }
1550 if minSdkVersion == "" {
1551 return fmt.Errorf("min_sdk_version is not specificed")
1552 }
1553
1554 // Not using nativeApiLevelFromUser because the context here is not
1555 // necessarily a native context.
1556 ver, err := android.ApiLevelFromUser(ctx, minSdkVersion)
1557 if err != nil {
1558 return err
1559 }
1560
1561 if ver.GreaterThan(sdkVersion) {
1562 return fmt.Errorf("newer SDK(%v)", ver)
1563 }
Jiyong Park99644e92020-11-17 22:21:02 +09001564 return nil
1565}
1566
Jiyong Park45bf82e2020-12-15 22:29:02 +09001567// Implements android.ApexModule
Jiyong Park99644e92020-11-17 22:21:02 +09001568func (mod *Module) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
1569 depTag := ctx.OtherModuleDependencyTag(dep)
1570
1571 if ccm, ok := dep.(*cc.Module); ok {
1572 if ccm.HasStubsVariants() {
1573 if cc.IsSharedDepTag(depTag) {
1574 // dynamic dep to a stubs lib crosses APEX boundary
1575 return false
1576 }
1577 if cc.IsRuntimeDepTag(depTag) {
1578 // runtime dep to a stubs lib also crosses APEX boundary
1579 return false
1580 }
1581
1582 if cc.IsHeaderDepTag(depTag) {
1583 return false
1584 }
1585 }
1586 if mod.Static() && cc.IsSharedDepTag(depTag) {
1587 // shared_lib dependency from a static lib is considered as crossing
1588 // the APEX boundary because the dependency doesn't actually is
1589 // linked; the dependency is used only during the compilation phase.
1590 return false
1591 }
1592 }
1593
1594 if depTag == procMacroDepTag {
1595 return false
1596 }
1597
1598 return true
1599}
1600
1601// Overrides ApexModule.IsInstallabeToApex()
1602func (mod *Module) IsInstallableToApex() bool {
1603 if mod.compiler != nil {
Ivan Lozano45e0e5b2021-11-13 07:42:36 -05001604 if lib, ok := mod.compiler.(libraryInterface); ok && (lib.shared() || lib.dylib()) {
Jiyong Park99644e92020-11-17 22:21:02 +09001605 return true
1606 }
1607 if _, ok := mod.compiler.(*binaryDecorator); ok {
1608 return true
1609 }
1610 }
1611 return false
1612}
1613
Ivan Lozano3dfa12d2021-02-04 11:29:41 -05001614// If a library file has a "lib" prefix, extract the library name without the prefix.
1615func libNameFromFilePath(filepath android.Path) (string, bool) {
1616 libName := strings.TrimSuffix(filepath.Base(), filepath.Ext())
1617 if strings.HasPrefix(libName, "lib") {
1618 libName = libName[3:]
1619 return libName, true
1620 }
1621 return "", false
1622}
1623
Ivan Lozanoffee3342019-08-27 12:03:00 -07001624var Bool = proptools.Bool
1625var BoolDefault = proptools.BoolDefault
1626var String = proptools.String
1627var StringPtr = proptools.StringPtr
Ivan Lozano43845682020-07-09 21:03:28 -04001628
1629var _ android.OutputFileProducer = (*Module)(nil)