blob: 0a7d68dee80ecd3d98f8dda17f702cd69293ceef [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"
30)
31
32var pctx = android.NewPackageContext("android/soong/rust")
33
34func init() {
35 // Only allow rust modules to be defined for certain projects
Ivan Lozanoffee3342019-08-27 12:03:00 -070036
37 android.AddNeverAllowRules(
38 android.NeverAllow().
Ivan Lozano03a94c42021-06-28 11:27:11 -040039 NotIn(append(config.RustAllowedPaths, config.DownstreamRustAllowedPaths...)...).
Ivan Lozanoe169ad72019-09-18 08:42:54 -070040 ModuleType(config.RustModuleTypes...))
Ivan Lozanoffee3342019-08-27 12:03:00 -070041
42 android.RegisterModuleType("rust_defaults", defaultsFactory)
43 android.PreDepsMutators(func(ctx android.RegisterMutatorsContext) {
44 ctx.BottomUp("rust_libraries", LibraryMutator).Parallel()
Ivan Lozano2b081132020-09-08 12:46:52 -040045 ctx.BottomUp("rust_stdlinkage", LibstdMutator).Parallel()
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -040046 ctx.BottomUp("rust_begin", BeginMutator).Parallel()
Ivan Lozano6cd99e62020-02-11 08:24:25 -050047
48 })
49 android.PostDepsMutators(func(ctx android.RegisterMutatorsContext) {
50 ctx.BottomUp("rust_sanitizers", rustSanitizerRuntimeMutator).Parallel()
Ivan Lozanoffee3342019-08-27 12:03:00 -070051 })
52 pctx.Import("android/soong/rust/config")
Thiébaud Weksteen682c9d72020-08-31 10:06:16 +020053 pctx.ImportAs("cc_config", "android/soong/cc/config")
Ivan Lozanoffee3342019-08-27 12:03:00 -070054}
55
56type Flags struct {
Ivan Lozano8a23fa42020-06-16 10:26:57 -040057 GlobalRustFlags []string // Flags that apply globally to rust
58 GlobalLinkFlags []string // Flags that apply globally to linker
59 RustFlags []string // Flags that apply to rust
60 LinkFlags []string // Flags that apply to linker
Thiébaud Weksteen92f703b2020-06-22 13:28:02 +020061 ClippyFlags []string // Flags that apply to clippy-driver, during the linting
Dan Albert06feee92021-03-19 15:06:02 -070062 RustdocFlags []string // Flags that apply to rustdoc
Ivan Lozanof1c84332019-09-20 11:00:37 -070063 Toolchain config.Toolchain
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -040064 Coverage bool
Thiébaud Weksteen92f703b2020-06-22 13:28:02 +020065 Clippy bool
Ivan Lozanoffee3342019-08-27 12:03:00 -070066}
67
68type BaseProperties struct {
69 AndroidMkRlibs []string
70 AndroidMkDylibs []string
71 AndroidMkProcMacroLibs []string
72 AndroidMkSharedLibs []string
73 AndroidMkStaticLibs []string
Ivan Lozano43845682020-07-09 21:03:28 -040074
Ivan Lozano6a884432020-12-02 09:15:16 -050075 ImageVariationPrefix string `blueprint:"mutated"`
76 VndkVersion string `blueprint:"mutated"`
77 SubName string `blueprint:"mutated"`
78
Ivan Lozanoc08897c2021-04-02 12:41:32 -040079 // SubName is used by CC for tracking image variants / SDK versions. RustSubName is used for Rust-specific
80 // subnaming which shouldn't be visible to CC modules (such as the rlib stdlinkage subname). This should be
81 // appended before SubName.
82 RustSubName string `blueprint:"mutated"`
83
Ivan Lozano6a884432020-12-02 09:15:16 -050084 // Set by imageMutator
Ivan Lozanoe6d30982021-02-05 10:57:43 -050085 CoreVariantNeeded bool `blueprint:"mutated"`
86 VendorRamdiskVariantNeeded bool `blueprint:"mutated"`
Matthew Maurerc6868382021-07-13 14:12:37 -070087 RamdiskVariantNeeded bool `blueprint:"mutated"`
Matthew Maurer460ee942021-02-11 12:31:46 -080088 RecoveryVariantNeeded bool `blueprint:"mutated"`
Ivan Lozanoe6d30982021-02-05 10:57:43 -050089 ExtraVariants []string `blueprint:"mutated"`
90
Ivan Lozanoa2268632021-07-22 10:52:06 -040091 // Allows this module to use non-APEX version of libraries. Useful
92 // for building binaries that are started before APEXes are activated.
93 Bootstrap *bool
94
Ivan Lozano1921e802021-05-20 13:39:16 -040095 // Used by vendor snapshot to record dependencies from snapshot modules.
96 SnapshotSharedLibs []string `blueprint:"mutated"`
Justin Yun5e035862021-06-29 20:50:37 +090097 SnapshotStaticLibs []string `blueprint:"mutated"`
Ivan Lozano1921e802021-05-20 13:39:16 -040098
Matthew Maurerc6868382021-07-13 14:12:37 -070099 // Make this module available when building for ramdisk.
100 // On device without a dedicated recovery partition, the module is only
101 // available after switching root into
102 // /first_stage_ramdisk. To expose the module before switching root, install
103 // the recovery variant instead.
104 Ramdisk_available *bool
105
Ivan Lozanoe6d30982021-02-05 10:57:43 -0500106 // Make this module available when building for vendor ramdisk.
107 // On device without a dedicated recovery partition, the module is only
108 // available after switching root into
109 // /first_stage_ramdisk. To expose the module before switching root, install
Matthew Maurer460ee942021-02-11 12:31:46 -0800110 // the recovery variant instead
Ivan Lozanoe6d30982021-02-05 10:57:43 -0500111 Vendor_ramdisk_available *bool
Ivan Lozano26ecd6c2020-07-31 13:40:31 -0400112
Ivan Lozano1921e802021-05-20 13:39:16 -0400113 // Normally Soong uses the directory structure to decide which modules
114 // should be included (framework) or excluded (non-framework) from the
115 // different snapshots (vendor, recovery, etc.), but this property
116 // allows a partner to exclude a module normally thought of as a
117 // framework module from the vendor snapshot.
118 Exclude_from_vendor_snapshot *bool
119
120 // Normally Soong uses the directory structure to decide which modules
121 // should be included (framework) or excluded (non-framework) from the
122 // different snapshots (vendor, recovery, etc.), but this property
123 // allows a partner to exclude a module normally thought of as a
124 // framework module from the recovery snapshot.
125 Exclude_from_recovery_snapshot *bool
126
Matthew Maurer460ee942021-02-11 12:31:46 -0800127 // Make this module available when building for recovery
128 Recovery_available *bool
129
Ivan Lozano3e9f9e42020-12-04 15:05:43 -0500130 // Minimum sdk version that the artifact should support when it runs as part of mainline modules(APEX).
131 Min_sdk_version *string
132
Ivan Lozano43845682020-07-09 21:03:28 -0400133 PreventInstall bool
134 HideFromMake bool
Ivan Lozanod7586b62021-04-01 09:49:36 -0400135 Installable *bool
Ivan Lozanoffee3342019-08-27 12:03:00 -0700136}
137
138type Module struct {
hamzehc0a671f2021-07-22 12:05:08 -0700139 fuzz.FuzzModule
Ivan Lozanoffee3342019-08-27 12:03:00 -0700140
Ivan Lozano6a884432020-12-02 09:15:16 -0500141 VendorProperties cc.VendorProperties
142
Ivan Lozanoffee3342019-08-27 12:03:00 -0700143 Properties BaseProperties
144
145 hod android.HostOrDeviceSupported
146 multilib android.Multilib
147
Ivan Lozano6a884432020-12-02 09:15:16 -0500148 makeLinkType string
149
Ivan Lozanoffee3342019-08-27 12:03:00 -0700150 compiler compiler
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400151 coverage *coverage
Thiébaud Weksteen92f703b2020-06-22 13:28:02 +0200152 clippy *clippy
Ivan Lozano6cd99e62020-02-11 08:24:25 -0500153 sanitize *sanitize
Ivan Lozanoffee3342019-08-27 12:03:00 -0700154 cachedToolchain config.Toolchain
Ivan Lozano4fef93c2020-07-08 08:39:44 -0400155 sourceProvider SourceProvider
Andrei Homescuc7767922020-08-05 06:36:19 -0700156 subAndroidMkOnce map[SubAndroidMkProvider]bool
Ivan Lozano4fef93c2020-07-08 08:39:44 -0400157
Jiyong Parke54f07e2021-04-07 15:08:04 +0900158 // Unstripped output. This is usually used when this module is linked to another module
159 // as a library. The stripped output which is used for installation can be found via
160 // compiler.strippedOutputFile if it exists.
161 unstrippedOutputFile android.OptionalPath
Dan Albert06feee92021-03-19 15:06:02 -0700162 docTimestampFile android.OptionalPath
Jiyong Park99644e92020-11-17 22:21:02 +0900163
164 hideApexVariantFromMake bool
Ivan Lozanoffee3342019-08-27 12:03:00 -0700165}
166
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500167func (mod *Module) Header() bool {
168 //TODO: If Rust libraries provide header variants, this needs to be updated.
169 return false
170}
171
172func (mod *Module) SetPreventInstall() {
173 mod.Properties.PreventInstall = true
174}
175
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500176func (mod *Module) SetHideFromMake() {
177 mod.Properties.HideFromMake = true
178}
179
Ivan Lozanod7586b62021-04-01 09:49:36 -0400180func (c *Module) HiddenFromMake() bool {
181 return c.Properties.HideFromMake
182}
183
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500184func (mod *Module) SanitizePropDefined() bool {
Ivan Lozano6cd99e62020-02-11 08:24:25 -0500185 // Because compiler is not set for some Rust modules where sanitize might be set, check that compiler is also not
186 // nil since we need compiler to actually sanitize.
187 return mod.sanitize != nil && mod.compiler != nil
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500188}
189
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500190func (mod *Module) IsPrebuilt() bool {
191 if _, ok := mod.compiler.(*prebuiltLibraryDecorator); ok {
192 return true
193 }
194 return false
195}
196
Ivan Lozano43845682020-07-09 21:03:28 -0400197func (mod *Module) OutputFiles(tag string) (android.Paths, error) {
198 switch tag {
199 case "":
Andrei Homescu5db69cc2020-08-06 15:27:45 -0700200 if mod.sourceProvider != nil && (mod.compiler == nil || mod.compiler.Disabled()) {
Ivan Lozano43845682020-07-09 21:03:28 -0400201 return mod.sourceProvider.Srcs(), nil
202 } else {
Jiyong Parke54f07e2021-04-07 15:08:04 +0900203 if mod.OutputFile().Valid() {
204 return android.Paths{mod.OutputFile().Path()}, nil
Ivan Lozano43845682020-07-09 21:03:28 -0400205 }
206 return android.Paths{}, nil
207 }
208 default:
209 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
210 }
211}
212
Ivan Lozano52767be2019-10-18 14:49:46 -0700213func (mod *Module) SelectedStl() string {
214 return ""
215}
216
Ivan Lozano2b262972019-11-21 12:30:50 -0800217func (mod *Module) NonCcVariants() bool {
218 if mod.compiler != nil {
Ivan Lozano89435d12020-07-31 11:01:18 -0400219 if _, ok := mod.compiler.(libraryInterface); ok {
220 return false
Ivan Lozano2b262972019-11-21 12:30:50 -0800221 }
222 }
223 panic(fmt.Errorf("NonCcVariants called on non-library module: %q", mod.BaseModuleName()))
224}
225
Ivan Lozano52767be2019-10-18 14:49:46 -0700226func (mod *Module) Static() bool {
227 if mod.compiler != nil {
228 if library, ok := mod.compiler.(libraryInterface); ok {
229 return library.static()
230 }
231 }
Ivan Lozano89435d12020-07-31 11:01:18 -0400232 return false
Ivan Lozano52767be2019-10-18 14:49:46 -0700233}
234
235func (mod *Module) Shared() bool {
236 if mod.compiler != nil {
237 if library, ok := mod.compiler.(libraryInterface); ok {
Ivan Lozano89435d12020-07-31 11:01:18 -0400238 return library.shared()
Ivan Lozano52767be2019-10-18 14:49:46 -0700239 }
240 }
Ivan Lozano89435d12020-07-31 11:01:18 -0400241 return false
Ivan Lozano52767be2019-10-18 14:49:46 -0700242}
243
Ivan Lozanod7586b62021-04-01 09:49:36 -0400244func (mod *Module) Dylib() bool {
245 if mod.compiler != nil {
246 if library, ok := mod.compiler.(libraryInterface); ok {
247 return library.dylib()
248 }
249 }
250 return false
251}
252
253func (mod *Module) Rlib() bool {
254 if mod.compiler != nil {
255 if library, ok := mod.compiler.(libraryInterface); ok {
256 return library.rlib()
257 }
258 }
259 return false
260}
261
262func (mod *Module) Binary() bool {
263 if mod.compiler != nil {
264 if _, ok := mod.compiler.(*binaryDecorator); ok {
265 return true
266 }
267 }
268 return false
269}
270
Justin Yun5e035862021-06-29 20:50:37 +0900271func (mod *Module) StaticExecutable() bool {
272 if !mod.Binary() {
273 return false
274 }
275 return Bool(mod.compiler.(*binaryDecorator).Properties.Static_executable)
276}
277
Ivan Lozanod7586b62021-04-01 09:49:36 -0400278func (mod *Module) Object() bool {
279 // Rust has no modules which produce only object files.
280 return false
281}
282
Ivan Lozano52767be2019-10-18 14:49:46 -0700283func (mod *Module) Toc() android.OptionalPath {
284 if mod.compiler != nil {
285 if _, ok := mod.compiler.(libraryInterface); ok {
286 return android.OptionalPath{}
287 }
288 }
289 panic(fmt.Errorf("Toc() called on non-library module: %q", mod.BaseModuleName()))
290}
291
Colin Crossc511bc52020-04-07 16:50:32 +0000292func (mod *Module) UseSdk() bool {
293 return false
294}
295
Ivan Lozanod7586b62021-04-01 09:49:36 -0400296func (mod *Module) RelativeInstallPath() string {
297 if mod.compiler != nil {
298 return mod.compiler.relativeInstallPath()
299 }
300 return ""
301}
302
Ivan Lozano52767be2019-10-18 14:49:46 -0700303func (mod *Module) UseVndk() bool {
Ivan Lozano6a884432020-12-02 09:15:16 -0500304 return mod.Properties.VndkVersion != ""
Ivan Lozano52767be2019-10-18 14:49:46 -0700305}
306
Jiyong Park7d55b612021-06-11 17:22:09 +0900307func (mod *Module) Bootstrap() bool {
Ivan Lozanoa2268632021-07-22 10:52:06 -0400308 return Bool(mod.Properties.Bootstrap)
Jiyong Park7d55b612021-06-11 17:22:09 +0900309}
310
Ivan Lozano52767be2019-10-18 14:49:46 -0700311func (mod *Module) MustUseVendorVariant() bool {
Ivan Lozanoc08897c2021-04-02 12:41:32 -0400312 return true
313}
314
315func (mod *Module) SubName() string {
316 return mod.Properties.SubName
Ivan Lozano52767be2019-10-18 14:49:46 -0700317}
318
319func (mod *Module) IsVndk() bool {
Ivan Lozano6a884432020-12-02 09:15:16 -0500320 // TODO(b/165791368)
Ivan Lozano52767be2019-10-18 14:49:46 -0700321 return false
322}
323
Ivan Lozanof9e21722020-12-02 09:00:51 -0500324func (mod *Module) IsVndkExt() bool {
325 return false
326}
327
Ivan Lozanod7586b62021-04-01 09:49:36 -0400328func (mod *Module) IsVndkSp() bool {
329 return false
330}
331
Colin Cross127bb8b2020-12-16 16:46:01 -0800332func (c *Module) IsVndkPrivate() bool {
333 return false
334}
335
336func (c *Module) IsLlndk() bool {
337 return false
338}
339
340func (c *Module) IsLlndkPublic() bool {
Ivan Lozanof9e21722020-12-02 09:00:51 -0500341 return false
342}
343
Ivan Lozano3a7d0002021-03-30 12:19:36 -0400344func (mod *Module) KernelHeadersDecorator() bool {
345 return false
346}
347
Colin Cross1f3f1302021-04-26 18:37:44 -0700348func (m *Module) NeedsLlndkVariants() bool {
Ivan Lozano3a7d0002021-03-30 12:19:36 -0400349 return false
350}
351
Colin Cross5271fea2021-04-27 13:06:04 -0700352func (m *Module) NeedsVendorPublicLibraryVariants() bool {
353 return false
354}
355
Ivan Lozanod7586b62021-04-01 09:49:36 -0400356func (mod *Module) HasLlndkStubs() bool {
357 return false
358}
359
360func (mod *Module) StubsVersion() string {
361 panic(fmt.Errorf("StubsVersion called on non-versioned module: %q", mod.BaseModuleName()))
362}
363
Ivan Lozano52767be2019-10-18 14:49:46 -0700364func (mod *Module) SdkVersion() string {
365 return ""
366}
367
Jiyong Parkfdaa5f72021-03-19 22:18:04 +0900368func (mod *Module) MinSdkVersion() string {
369 return ""
370}
371
Colin Crossc511bc52020-04-07 16:50:32 +0000372func (mod *Module) AlwaysSdk() bool {
373 return false
374}
375
Jiyong Park2286afd2020-06-16 21:58:53 +0900376func (mod *Module) IsSdkVariant() bool {
377 return false
378}
379
Colin Cross1348ce32020-10-01 13:37:16 -0700380func (mod *Module) SplitPerApiLevel() bool {
381 return false
382}
383
Ivan Lozanoffee3342019-08-27 12:03:00 -0700384type Deps struct {
Ivan Lozano63bb7682021-03-23 15:53:44 -0400385 Dylibs []string
386 Rlibs []string
387 Rustlibs []string
388 Stdlibs []string
389 ProcMacros []string
390 SharedLibs []string
391 StaticLibs []string
392 WholeStaticLibs []string
393 HeaderLibs []string
Ivan Lozanoffee3342019-08-27 12:03:00 -0700394
395 CrtBegin, CrtEnd string
396}
397
398type PathDeps struct {
Ivan Lozanoec6e9912021-01-21 15:23:29 -0500399 DyLibs RustLibraries
400 RLibs RustLibraries
401 SharedLibs android.Paths
402 SharedLibDeps android.Paths
403 StaticLibs android.Paths
404 ProcMacros RustLibraries
Ivan Lozano3dfa12d2021-02-04 11:29:41 -0500405
406 // depFlags and depLinkFlags are rustc and linker (clang) flags.
407 depFlags []string
408 depLinkFlags []string
409
410 // linkDirs are link paths passed via -L to rustc. linkObjects are objects passed directly to the linker.
411 // Both of these are exported and propagate to dependencies.
412 linkDirs []string
413 linkObjects []string
Ivan Lozanof1c84332019-09-20 11:00:37 -0700414
Ivan Lozano45901ed2020-07-24 16:05:01 -0400415 // Used by bindgen modules which call clang
416 depClangFlags []string
417 depIncludePaths android.Paths
Ivan Lozanoddd0bdb2020-08-28 17:00:26 -0400418 depGeneratedHeaders android.Paths
Ivan Lozano45901ed2020-07-24 16:05:01 -0400419 depSystemIncludePaths android.Paths
420
Ivan Lozanof1c84332019-09-20 11:00:37 -0700421 CrtBegin android.OptionalPath
422 CrtEnd android.OptionalPath
Chih-Hung Hsiehbbd25ae2020-05-15 17:36:30 -0700423
424 // Paths to generated source files
Ivan Lozano9d74a522020-12-01 09:25:22 -0500425 SrcDeps android.Paths
426 srcProviderFiles android.Paths
Ivan Lozanoffee3342019-08-27 12:03:00 -0700427}
428
429type RustLibraries []RustLibrary
430
431type RustLibrary struct {
432 Path android.Path
433 CrateName string
434}
435
436type compiler interface {
Thiébaud Weksteenee6a89b2021-02-25 16:30:57 +0100437 initialize(ctx ModuleContext)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700438 compilerFlags(ctx ModuleContext, flags Flags) Flags
Ivan Lozano67eada32021-09-23 11:50:33 -0400439 cfgFlags(ctx ModuleContext, flags Flags) Flags
440 featureFlags(ctx ModuleContext, flags Flags) Flags
Ivan Lozanoffee3342019-08-27 12:03:00 -0700441 compilerProps() []interface{}
442 compile(ctx ModuleContext, flags Flags, deps PathDeps) android.Path
443 compilerDeps(ctx DepsContext, deps Deps) Deps
444 crateName() string
Dan Albert06feee92021-03-19 15:06:02 -0700445 rustdoc(ctx ModuleContext, flags Flags, deps PathDeps) android.OptionalPath
Ivan Lozanoffee3342019-08-27 12:03:00 -0700446
Thiébaud Weksteenee6a89b2021-02-25 16:30:57 +0100447 // Output directory in which source-generated code from dependencies is
448 // copied. This is equivalent to Cargo's OUT_DIR variable.
449 CargoOutDir() android.OptionalPath
Dan Albert06feee92021-03-19 15:06:02 -0700450
Ivan Lozanoa9a1fc02021-08-11 15:13:43 -0400451 // CargoPkgVersion returns the value of the Cargo_pkg_version property.
452 CargoPkgVersion() string
453
454 // CargoEnvCompat returns whether Cargo environment variables should be used.
455 CargoEnvCompat() bool
456
Chih-Hung Hsieh9a4a7ba2019-12-12 19:36:05 -0800457 inData() bool
Thiébaud Weksteenfabaff62020-08-27 13:48:36 +0200458 install(ctx ModuleContext)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700459 relativeInstallPath() string
Ivan Lozanod7586b62021-04-01 09:49:36 -0400460 everInstallable() bool
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400461
462 nativeCoverage() bool
Ivan Lozano26ecd6c2020-07-31 13:40:31 -0400463
464 Disabled() bool
465 SetDisabled()
Ivan Lozano042504f2020-08-18 14:31:23 -0400466
Ivan Lozanodd055472020-09-28 13:22:45 -0400467 stdLinkage(ctx *depsContext) RustLinkage
Jiyong Parke54f07e2021-04-07 15:08:04 +0900468
469 strippedOutputFilePath() android.OptionalPath
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400470}
471
Matthew Maurerbb3add12020-06-25 09:34:12 -0700472type exportedFlagsProducer interface {
Matthew Maurerbb3add12020-06-25 09:34:12 -0700473 exportLinkDirs(...string)
Ivan Lozano2093af22020-08-25 12:48:19 -0400474 exportLinkObjects(...string)
Matthew Maurerbb3add12020-06-25 09:34:12 -0700475}
476
477type flagExporter struct {
Ivan Lozano2093af22020-08-25 12:48:19 -0400478 linkDirs []string
479 linkObjects []string
Matthew Maurerbb3add12020-06-25 09:34:12 -0700480}
481
Matthew Maurerbb3add12020-06-25 09:34:12 -0700482func (flagExporter *flagExporter) exportLinkDirs(dirs ...string) {
483 flagExporter.linkDirs = android.FirstUniqueStrings(append(flagExporter.linkDirs, dirs...))
484}
485
Ivan Lozano2093af22020-08-25 12:48:19 -0400486func (flagExporter *flagExporter) exportLinkObjects(flags ...string) {
487 flagExporter.linkObjects = android.FirstUniqueStrings(append(flagExporter.linkObjects, flags...))
488}
489
Colin Cross0de8a1e2020-09-18 14:15:30 -0700490func (flagExporter *flagExporter) setProvider(ctx ModuleContext) {
491 ctx.SetProvider(FlagExporterInfoProvider, FlagExporterInfo{
Colin Cross0de8a1e2020-09-18 14:15:30 -0700492 LinkDirs: flagExporter.linkDirs,
493 LinkObjects: flagExporter.linkObjects,
494 })
495}
496
Matthew Maurerbb3add12020-06-25 09:34:12 -0700497var _ exportedFlagsProducer = (*flagExporter)(nil)
498
499func NewFlagExporter() *flagExporter {
Colin Cross0de8a1e2020-09-18 14:15:30 -0700500 return &flagExporter{}
Matthew Maurerbb3add12020-06-25 09:34:12 -0700501}
502
Colin Cross0de8a1e2020-09-18 14:15:30 -0700503type FlagExporterInfo struct {
504 Flags []string
505 LinkDirs []string // TODO: this should be android.Paths
506 LinkObjects []string // TODO: this should be android.Paths
507}
508
509var FlagExporterInfoProvider = blueprint.NewProvider(FlagExporterInfo{})
510
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400511func (mod *Module) isCoverageVariant() bool {
512 return mod.coverage.Properties.IsCoverageVariant
513}
514
515var _ cc.Coverage = (*Module)(nil)
516
517func (mod *Module) IsNativeCoverageNeeded(ctx android.BaseModuleContext) bool {
518 return mod.coverage != nil && mod.coverage.Properties.NeedCoverageVariant
519}
520
Ivan Lozanod7586b62021-04-01 09:49:36 -0400521func (mod *Module) VndkVersion() string {
522 return mod.Properties.VndkVersion
523}
524
525func (mod *Module) PreventInstall() bool {
526 return mod.Properties.PreventInstall
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400527}
528
529func (mod *Module) HideFromMake() {
530 mod.Properties.HideFromMake = true
531}
532
533func (mod *Module) MarkAsCoverageVariant(coverage bool) {
534 mod.coverage.Properties.IsCoverageVariant = coverage
535}
536
537func (mod *Module) EnableCoverageIfNeeded() {
538 mod.coverage.Properties.CoverageEnabled = mod.coverage.Properties.NeedCoverageBuild
Ivan Lozanoffee3342019-08-27 12:03:00 -0700539}
540
541func defaultsFactory() android.Module {
542 return DefaultsFactory()
543}
544
545type Defaults struct {
546 android.ModuleBase
547 android.DefaultsModuleBase
548}
549
550func DefaultsFactory(props ...interface{}) android.Module {
551 module := &Defaults{}
552
553 module.AddProperties(props...)
554 module.AddProperties(
555 &BaseProperties{},
Ivan Lozano6a884432020-12-02 09:15:16 -0500556 &cc.VendorProperties{},
Jakub Kotur1d640d02021-01-06 12:40:43 +0100557 &BenchmarkProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -0400558 &BindgenProperties{},
Ivan Lozanoffee3342019-08-27 12:03:00 -0700559 &BaseCompilerProperties{},
560 &BinaryCompilerProperties{},
561 &LibraryCompilerProperties{},
562 &ProcMacroCompilerProperties{},
563 &PrebuiltProperties{},
Ivan Lozano4fef93c2020-07-08 08:39:44 -0400564 &SourceProviderProperties{},
Chih-Hung Hsieh41805be2019-10-31 20:56:47 -0700565 &TestProperties{},
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400566 &cc.CoverageProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -0400567 &cc.RustBindgenClangProperties{},
Thiébaud Weksteen92f703b2020-06-22 13:28:02 +0200568 &ClippyProperties{},
Ivan Lozano6cd99e62020-02-11 08:24:25 -0500569 &SanitizeProperties{},
Ivan Lozanoffee3342019-08-27 12:03:00 -0700570 )
571
572 android.InitDefaultsModule(module)
573 return module
574}
575
576func (mod *Module) CrateName() string {
Ivan Lozanoad8b18b2019-10-31 19:38:29 -0700577 return mod.compiler.crateName()
Ivan Lozanoffee3342019-08-27 12:03:00 -0700578}
579
Ivan Lozano183a3212019-10-18 14:18:45 -0700580func (mod *Module) CcLibrary() bool {
581 if mod.compiler != nil {
582 if _, ok := mod.compiler.(*libraryDecorator); ok {
583 return true
584 }
585 }
586 return false
587}
588
589func (mod *Module) CcLibraryInterface() bool {
590 if mod.compiler != nil {
Ivan Lozano89435d12020-07-31 11:01:18 -0400591 // use build{Static,Shared}() instead of {static,shared}() here because this might be called before
592 // VariantIs{Static,Shared} is set.
593 if lib, ok := mod.compiler.(libraryInterface); ok && (lib.buildShared() || lib.buildStatic()) {
Ivan Lozano183a3212019-10-18 14:18:45 -0700594 return true
595 }
596 }
597 return false
598}
599
Ivan Lozanoe0833b12019-11-06 19:15:49 -0800600func (mod *Module) IncludeDirs() android.Paths {
Ivan Lozano183a3212019-10-18 14:18:45 -0700601 if mod.compiler != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700602 if library, ok := mod.compiler.(*libraryDecorator); ok {
Ivan Lozanoe0833b12019-11-06 19:15:49 -0800603 return library.includeDirs
Ivan Lozano183a3212019-10-18 14:18:45 -0700604 }
605 }
606 panic(fmt.Errorf("IncludeDirs called on non-library module: %q", mod.BaseModuleName()))
607}
608
609func (mod *Module) SetStatic() {
610 if mod.compiler != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700611 if library, ok := mod.compiler.(libraryInterface); ok {
612 library.setStatic()
Ivan Lozano183a3212019-10-18 14:18:45 -0700613 return
614 }
615 }
616 panic(fmt.Errorf("SetStatic called on non-library module: %q", mod.BaseModuleName()))
617}
618
619func (mod *Module) SetShared() {
620 if mod.compiler != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700621 if library, ok := mod.compiler.(libraryInterface); ok {
622 library.setShared()
Ivan Lozano183a3212019-10-18 14:18:45 -0700623 return
624 }
625 }
626 panic(fmt.Errorf("SetShared called on non-library module: %q", mod.BaseModuleName()))
627}
628
Ivan Lozano183a3212019-10-18 14:18:45 -0700629func (mod *Module) BuildStaticVariant() bool {
630 if mod.compiler != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700631 if library, ok := mod.compiler.(libraryInterface); ok {
632 return library.buildStatic()
Ivan Lozano183a3212019-10-18 14:18:45 -0700633 }
634 }
635 panic(fmt.Errorf("BuildStaticVariant called on non-library module: %q", mod.BaseModuleName()))
636}
637
638func (mod *Module) BuildSharedVariant() bool {
639 if mod.compiler != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700640 if library, ok := mod.compiler.(libraryInterface); ok {
641 return library.buildShared()
Ivan Lozano183a3212019-10-18 14:18:45 -0700642 }
643 }
644 panic(fmt.Errorf("BuildSharedVariant called on non-library module: %q", mod.BaseModuleName()))
645}
646
Ivan Lozano183a3212019-10-18 14:18:45 -0700647func (mod *Module) Module() android.Module {
648 return mod
649}
650
Ivan Lozano183a3212019-10-18 14:18:45 -0700651func (mod *Module) OutputFile() android.OptionalPath {
Jiyong Parke54f07e2021-04-07 15:08:04 +0900652 if mod.compiler != nil && mod.compiler.strippedOutputFilePath().Valid() {
653 return mod.compiler.strippedOutputFilePath()
654 }
655 return mod.unstrippedOutputFile
Ivan Lozano183a3212019-10-18 14:18:45 -0700656}
657
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400658func (mod *Module) CoverageFiles() android.Paths {
659 if mod.compiler != nil {
Joel Galensonfa049382021-01-14 16:03:18 -0800660 return android.Paths{}
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400661 }
662 panic(fmt.Errorf("CoverageFiles called on non-library module: %q", mod.BaseModuleName()))
663}
664
Jiyong Park459feca2020-12-15 11:02:21 +0900665func (mod *Module) installable(apexInfo android.ApexInfo) bool {
Jiyong Parkbf8147a2021-05-17 13:19:33 +0900666 if !mod.EverInstallable() {
667 return false
668 }
669
Jiyong Park459feca2020-12-15 11:02:21 +0900670 // The apex variant is not installable because it is included in the APEX and won't appear
671 // in the system partition as a standalone file.
672 if !apexInfo.IsForPlatform() {
673 return false
674 }
675
Jiyong Parke54f07e2021-04-07 15:08:04 +0900676 return mod.OutputFile().Valid() && !mod.Properties.PreventInstall
Jiyong Park459feca2020-12-15 11:02:21 +0900677}
678
Ivan Lozano183a3212019-10-18 14:18:45 -0700679var _ cc.LinkableInterface = (*Module)(nil)
680
Ivan Lozanoffee3342019-08-27 12:03:00 -0700681func (mod *Module) Init() android.Module {
682 mod.AddProperties(&mod.Properties)
Ivan Lozano6a884432020-12-02 09:15:16 -0500683 mod.AddProperties(&mod.VendorProperties)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700684
685 if mod.compiler != nil {
686 mod.AddProperties(mod.compiler.compilerProps()...)
687 }
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400688 if mod.coverage != nil {
689 mod.AddProperties(mod.coverage.props()...)
690 }
Thiébaud Weksteen92f703b2020-06-22 13:28:02 +0200691 if mod.clippy != nil {
692 mod.AddProperties(mod.clippy.props()...)
693 }
Ivan Lozano4fef93c2020-07-08 08:39:44 -0400694 if mod.sourceProvider != nil {
Andrei Homescuc7767922020-08-05 06:36:19 -0700695 mod.AddProperties(mod.sourceProvider.SourceProviderProps()...)
Ivan Lozano4fef93c2020-07-08 08:39:44 -0400696 }
Ivan Lozano6cd99e62020-02-11 08:24:25 -0500697 if mod.sanitize != nil {
698 mod.AddProperties(mod.sanitize.props()...)
699 }
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400700
Ivan Lozanoffee3342019-08-27 12:03:00 -0700701 android.InitAndroidArchModule(mod, mod.hod, mod.multilib)
Jiyong Park99644e92020-11-17 22:21:02 +0900702 android.InitApexModule(mod)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700703
704 android.InitDefaultableModule(mod)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700705 return mod
706}
707
708func newBaseModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
709 return &Module{
710 hod: hod,
711 multilib: multilib,
712 }
713}
714func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
715 module := newBaseModule(hod, multilib)
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400716 module.coverage = &coverage{}
Thiébaud Weksteen92f703b2020-06-22 13:28:02 +0200717 module.clippy = &clippy{}
Ivan Lozano6cd99e62020-02-11 08:24:25 -0500718 module.sanitize = &sanitize{}
Ivan Lozanoffee3342019-08-27 12:03:00 -0700719 return module
720}
721
722type ModuleContext interface {
723 android.ModuleContext
724 ModuleContextIntf
725}
726
727type BaseModuleContext interface {
728 android.BaseModuleContext
729 ModuleContextIntf
730}
731
732type DepsContext interface {
733 android.BottomUpMutatorContext
734 ModuleContextIntf
735}
736
737type ModuleContextIntf interface {
Thiébaud Weksteen1f7f70f2020-06-24 11:32:48 +0200738 RustModule() *Module
Ivan Lozanoffee3342019-08-27 12:03:00 -0700739 toolchain() config.Toolchain
Ivan Lozanoffee3342019-08-27 12:03:00 -0700740}
741
742type depsContext struct {
743 android.BottomUpMutatorContext
Ivan Lozanoffee3342019-08-27 12:03:00 -0700744}
745
746type moduleContext struct {
747 android.ModuleContext
Ivan Lozanoffee3342019-08-27 12:03:00 -0700748}
749
Thiébaud Weksteen1f7f70f2020-06-24 11:32:48 +0200750type baseModuleContext struct {
751 android.BaseModuleContext
752}
753
754func (ctx *moduleContext) RustModule() *Module {
755 return ctx.Module().(*Module)
756}
757
758func (ctx *moduleContext) toolchain() config.Toolchain {
759 return ctx.RustModule().toolchain(ctx)
760}
761
762func (ctx *depsContext) RustModule() *Module {
763 return ctx.Module().(*Module)
764}
765
766func (ctx *depsContext) toolchain() config.Toolchain {
767 return ctx.RustModule().toolchain(ctx)
768}
769
770func (ctx *baseModuleContext) RustModule() *Module {
771 return ctx.Module().(*Module)
772}
773
774func (ctx *baseModuleContext) toolchain() config.Toolchain {
775 return ctx.RustModule().toolchain(ctx)
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400776}
777
778func (mod *Module) nativeCoverage() bool {
Matthew Maurera61e31f2021-05-27 11:09:11 -0700779 // Bug: http://b/137883967 - native-bridge modules do not currently work with coverage
780 if mod.Target().NativeBridge == android.NativeBridgeEnabled {
781 return false
782 }
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400783 return mod.compiler != nil && mod.compiler.nativeCoverage()
784}
785
Ivan Lozanod7586b62021-04-01 09:49:36 -0400786func (mod *Module) EverInstallable() bool {
787 return mod.compiler != nil &&
788 // Check to see whether the module is actually ever installable.
789 mod.compiler.everInstallable()
790}
791
792func (mod *Module) Installable() *bool {
793 return mod.Properties.Installable
794}
795
Ivan Lozanoffee3342019-08-27 12:03:00 -0700796func (mod *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
797 if mod.cachedToolchain == nil {
798 mod.cachedToolchain = config.FindToolchain(ctx.Os(), ctx.Arch())
799 }
800 return mod.cachedToolchain
801}
802
Thiébaud Weksteen31f1bb82020-08-27 13:37:29 +0200803func (mod *Module) ccToolchain(ctx android.BaseModuleContext) cc_config.Toolchain {
804 return cc_config.FindToolchain(ctx.Os(), ctx.Arch())
805}
806
Ivan Lozanoffee3342019-08-27 12:03:00 -0700807func (d *Defaults) GenerateAndroidBuildActions(ctx android.ModuleContext) {
808}
809
810func (mod *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
811 ctx := &moduleContext{
812 ModuleContext: actx,
Ivan Lozanoffee3342019-08-27 12:03:00 -0700813 }
Ivan Lozanoffee3342019-08-27 12:03:00 -0700814
Jiyong Park99644e92020-11-17 22:21:02 +0900815 apexInfo := actx.Provider(android.ApexInfoProvider).(android.ApexInfo)
816 if !apexInfo.IsForPlatform() {
817 mod.hideApexVariantFromMake = true
818 }
819
Ivan Lozanoffee3342019-08-27 12:03:00 -0700820 toolchain := mod.toolchain(ctx)
Ivan Lozano6a884432020-12-02 09:15:16 -0500821 mod.makeLinkType = cc.GetMakeLinkType(actx, mod)
822
823 // Differentiate static libraries that are vendor available
824 if mod.UseVndk() {
Matthew Maurer52af5b02021-05-27 10:01:36 -0700825 if mod.InProduct() && !mod.OnlyInProduct() {
826 mod.Properties.SubName += cc.ProductSuffix
827 } else {
828 mod.Properties.SubName += cc.VendorSuffix
829 }
Matthew Maurerc6868382021-07-13 14:12:37 -0700830 } else if mod.InRamdisk() && !mod.OnlyInRamdisk() {
831 mod.Properties.SubName += cc.RamdiskSuffix
Ivan Lozanoe6d30982021-02-05 10:57:43 -0500832 } else if mod.InVendorRamdisk() && !mod.OnlyInVendorRamdisk() {
833 mod.Properties.SubName += cc.VendorRamdiskSuffix
Matthew Maurer460ee942021-02-11 12:31:46 -0800834 } else if mod.InRecovery() && !mod.OnlyInRecovery() {
835 mod.Properties.SubName += cc.RecoverySuffix
Ivan Lozano6a884432020-12-02 09:15:16 -0500836 }
Ivan Lozanoffee3342019-08-27 12:03:00 -0700837
Matthew Maurera61e31f2021-05-27 11:09:11 -0700838 if mod.Target().NativeBridge == android.NativeBridgeEnabled {
839 mod.Properties.SubName += cc.NativeBridgeSuffix
840 }
841
Ivan Lozanoffee3342019-08-27 12:03:00 -0700842 if !toolchain.Supported() {
843 // This toolchain's unsupported, there's nothing to do for this mod.
844 return
845 }
846
847 deps := mod.depsToPaths(ctx)
848 flags := Flags{
849 Toolchain: toolchain,
850 }
851
Ivan Lozano67eada32021-09-23 11:50:33 -0400852 // Calculate rustc flags
Ivan Lozanoffee3342019-08-27 12:03:00 -0700853 if mod.compiler != nil {
854 flags = mod.compiler.compilerFlags(ctx, flags)
Ivan Lozano67eada32021-09-23 11:50:33 -0400855 flags = mod.compiler.cfgFlags(ctx, flags)
856 flags = mod.compiler.featureFlags(ctx, flags)
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400857 }
858 if mod.coverage != nil {
859 flags, deps = mod.coverage.flags(ctx, flags, deps)
860 }
Thiébaud Weksteen92f703b2020-06-22 13:28:02 +0200861 if mod.clippy != nil {
862 flags, deps = mod.clippy.flags(ctx, flags, deps)
863 }
Ivan Lozano6cd99e62020-02-11 08:24:25 -0500864 if mod.sanitize != nil {
865 flags, deps = mod.sanitize.flags(ctx, flags, deps)
866 }
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400867
Thiébaud Weksteen295c72b2020-09-23 18:10:17 +0200868 // SourceProvider needs to call GenerateSource() before compiler calls
869 // compile() so it can provide the source. A SourceProvider has
870 // multiple variants (e.g. source, rlib, dylib). Only the "source"
871 // variant is responsible for effectively generating the source. The
872 // remaining variants relies on the "source" variant output.
Ivan Lozano26ecd6c2020-07-31 13:40:31 -0400873 if mod.sourceProvider != nil {
Thiébaud Weksteen295c72b2020-09-23 18:10:17 +0200874 if mod.compiler.(libraryInterface).source() {
875 mod.sourceProvider.GenerateSource(ctx, deps)
876 mod.sourceProvider.setSubName(ctx.ModuleSubDir())
877 } else {
878 sourceMod := actx.GetDirectDepWithTag(mod.Name(), sourceDepTag)
879 sourceLib := sourceMod.(*Module).compiler.(*libraryDecorator)
Chih-Hung Hsiehc49649c2020-10-01 21:25:05 -0700880 mod.sourceProvider.setOutputFiles(sourceLib.sourceProvider.Srcs())
Thiébaud Weksteen295c72b2020-09-23 18:10:17 +0200881 }
Ivan Lozano26ecd6c2020-07-31 13:40:31 -0400882 }
883
884 if mod.compiler != nil && !mod.compiler.Disabled() {
Thiébaud Weksteenee6a89b2021-02-25 16:30:57 +0100885 mod.compiler.initialize(ctx)
Jiyong Parke54f07e2021-04-07 15:08:04 +0900886 unstrippedOutputFile := mod.compiler.compile(ctx, flags, deps)
Jiyong Parke54f07e2021-04-07 15:08:04 +0900887 mod.unstrippedOutputFile = android.OptionalPathForPath(unstrippedOutputFile)
Thiébaud Weksteene4dd14b2021-04-14 11:18:47 +0200888 bloaty.MeasureSizeForPaths(ctx, mod.compiler.strippedOutputFilePath(), mod.unstrippedOutputFile)
Jiyong Park459feca2020-12-15 11:02:21 +0900889
Dan Albert06feee92021-03-19 15:06:02 -0700890 mod.docTimestampFile = mod.compiler.rustdoc(ctx, flags, deps)
891
Ivan Lozano1921e802021-05-20 13:39:16 -0400892 // glob exported headers for snapshot, if BOARD_VNDK_VERSION is current or
893 // RECOVERY_SNAPSHOT_VERSION is current.
894 if lib, ok := mod.compiler.(snapshotLibraryInterface); ok {
895 if cc.ShouldCollectHeadersForSnapshot(ctx, mod, apexInfo) {
896 lib.collectHeadersForSnapshot(ctx, deps)
897 }
898 }
899
Jiyong Park459feca2020-12-15 11:02:21 +0900900 apexInfo := actx.Provider(android.ApexInfoProvider).(android.ApexInfo)
901 if mod.installable(apexInfo) {
Thiébaud Weksteenfabaff62020-08-27 13:48:36 +0200902 mod.compiler.install(ctx)
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400903 }
Chris Wailes74be7642021-07-22 16:20:28 -0700904
905 ctx.Phony("rust", ctx.RustModule().OutputFile().Path())
Ivan Lozanoffee3342019-08-27 12:03:00 -0700906 }
907}
908
909func (mod *Module) deps(ctx DepsContext) Deps {
910 deps := Deps{}
911
912 if mod.compiler != nil {
913 deps = mod.compiler.compilerDeps(ctx, deps)
Ivan Lozano26ecd6c2020-07-31 13:40:31 -0400914 }
915 if mod.sourceProvider != nil {
Andrei Homescuc7767922020-08-05 06:36:19 -0700916 deps = mod.sourceProvider.SourceProviderDeps(ctx, deps)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700917 }
918
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400919 if mod.coverage != nil {
920 deps = mod.coverage.deps(ctx, deps)
921 }
922
Ivan Lozano6cd99e62020-02-11 08:24:25 -0500923 if mod.sanitize != nil {
924 deps = mod.sanitize.deps(ctx, deps)
925 }
926
Ivan Lozanoffee3342019-08-27 12:03:00 -0700927 deps.Rlibs = android.LastUniqueStrings(deps.Rlibs)
928 deps.Dylibs = android.LastUniqueStrings(deps.Dylibs)
Matthew Maurer0f003b12020-06-29 14:34:06 -0700929 deps.Rustlibs = android.LastUniqueStrings(deps.Rustlibs)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700930 deps.ProcMacros = android.LastUniqueStrings(deps.ProcMacros)
931 deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
932 deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
Ivan Lozano63bb7682021-03-23 15:53:44 -0400933 deps.WholeStaticLibs = android.LastUniqueStrings(deps.WholeStaticLibs)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700934 return deps
935
936}
937
Ivan Lozanoffee3342019-08-27 12:03:00 -0700938type dependencyTag struct {
939 blueprint.BaseDependencyTag
Jaewoong Jung18aefc12020-12-21 09:11:10 -0800940 name string
941 library bool
942 procMacro bool
Ivan Lozanoffee3342019-08-27 12:03:00 -0700943}
944
Jiyong Park65b62242020-11-25 12:44:59 +0900945// InstallDepNeeded returns true for rlibs, dylibs, and proc macros so that they or their transitive
946// dependencies (especially C/C++ shared libs) are installed as dependencies of a rust binary.
947func (d dependencyTag) InstallDepNeeded() bool {
Jaewoong Jung18aefc12020-12-21 09:11:10 -0800948 return d.library || d.procMacro
Jiyong Park65b62242020-11-25 12:44:59 +0900949}
950
951var _ android.InstallNeededDependencyTag = dependencyTag{}
952
Ivan Lozanoffee3342019-08-27 12:03:00 -0700953var (
Ivan Lozanoc564d2d2020-08-04 15:43:37 -0400954 customBindgenDepTag = dependencyTag{name: "customBindgenTag"}
955 rlibDepTag = dependencyTag{name: "rlibTag", library: true}
956 dylibDepTag = dependencyTag{name: "dylib", library: true}
Jaewoong Jung18aefc12020-12-21 09:11:10 -0800957 procMacroDepTag = dependencyTag{name: "procMacro", procMacro: true}
Ivan Lozanoc564d2d2020-08-04 15:43:37 -0400958 testPerSrcDepTag = dependencyTag{name: "rust_unit_tests"}
Thiébaud Weksteen295c72b2020-09-23 18:10:17 +0200959 sourceDepTag = dependencyTag{name: "source"}
Ivan Lozanoffee3342019-08-27 12:03:00 -0700960)
961
Jiyong Park99644e92020-11-17 22:21:02 +0900962func IsDylibDepTag(depTag blueprint.DependencyTag) bool {
963 tag, ok := depTag.(dependencyTag)
964 return ok && tag == dylibDepTag
965}
966
Jiyong Park94e22fd2021-04-08 18:19:15 +0900967func IsRlibDepTag(depTag blueprint.DependencyTag) bool {
968 tag, ok := depTag.(dependencyTag)
969 return ok && tag == rlibDepTag
970}
971
Matthew Maurer0f003b12020-06-29 14:34:06 -0700972type autoDep struct {
973 variation string
974 depTag dependencyTag
975}
976
977var (
Thiébaud Weksteen295c72b2020-09-23 18:10:17 +0200978 rlibVariation = "rlib"
979 dylibVariation = "dylib"
980 rlibAutoDep = autoDep{variation: rlibVariation, depTag: rlibDepTag}
981 dylibAutoDep = autoDep{variation: dylibVariation, depTag: dylibDepTag}
Matthew Maurer0f003b12020-06-29 14:34:06 -0700982)
983
984type autoDeppable interface {
Liz Kammer356f7d42021-01-26 09:18:53 -0500985 autoDep(ctx android.BottomUpMutatorContext) autoDep
Matthew Maurer0f003b12020-06-29 14:34:06 -0700986}
987
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400988func (mod *Module) begin(ctx BaseModuleContext) {
989 if mod.coverage != nil {
990 mod.coverage.begin(ctx)
991 }
Ivan Lozano6cd99e62020-02-11 08:24:25 -0500992 if mod.sanitize != nil {
993 mod.sanitize.begin(ctx)
994 }
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400995}
996
Ivan Lozanoffee3342019-08-27 12:03:00 -0700997func (mod *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
998 var depPaths PathDeps
999
1000 directRlibDeps := []*Module{}
1001 directDylibDeps := []*Module{}
1002 directProcMacroDeps := []*Module{}
Jiyong Park7d55b612021-06-11 17:22:09 +09001003 directSharedLibDeps := []cc.SharedLibraryInfo{}
Ivan Lozano52767be2019-10-18 14:49:46 -07001004 directStaticLibDeps := [](cc.LinkableInterface){}
Ivan Lozano07cbaf42020-07-22 16:09:13 -04001005 directSrcProvidersDeps := []*Module{}
1006 directSrcDeps := [](android.SourceFileProducer){}
Ivan Lozanoffee3342019-08-27 12:03:00 -07001007
1008 ctx.VisitDirectDeps(func(dep android.Module) {
1009 depName := ctx.OtherModuleName(dep)
1010 depTag := ctx.OtherModuleDependencyTag(dep)
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001011
Ivan Lozano89435d12020-07-31 11:01:18 -04001012 if rustDep, ok := dep.(*Module); ok && !rustDep.CcLibraryInterface() {
Ivan Lozanoffee3342019-08-27 12:03:00 -07001013 //Handle Rust Modules
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001014 makeLibName := cc.MakeLibName(ctx, mod, rustDep, depName+rustDep.Properties.RustSubName)
Ivan Lozano70e0a072019-09-13 14:23:15 -07001015
Ivan Lozanoffee3342019-08-27 12:03:00 -07001016 switch depTag {
1017 case dylibDepTag:
1018 dylib, ok := rustDep.compiler.(libraryInterface)
1019 if !ok || !dylib.dylib() {
1020 ctx.ModuleErrorf("mod %q not an dylib library", depName)
1021 return
1022 }
1023 directDylibDeps = append(directDylibDeps, rustDep)
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001024 mod.Properties.AndroidMkDylibs = append(mod.Properties.AndroidMkDylibs, makeLibName)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001025 case rlibDepTag:
Ivan Lozano2b081132020-09-08 12:46:52 -04001026
Ivan Lozanoffee3342019-08-27 12:03:00 -07001027 rlib, ok := rustDep.compiler.(libraryInterface)
1028 if !ok || !rlib.rlib() {
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001029 ctx.ModuleErrorf("mod %q not an rlib library", makeLibName)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001030 return
1031 }
1032 directRlibDeps = append(directRlibDeps, rustDep)
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001033 mod.Properties.AndroidMkRlibs = append(mod.Properties.AndroidMkRlibs, makeLibName)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001034 case procMacroDepTag:
1035 directProcMacroDeps = append(directProcMacroDeps, rustDep)
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001036 mod.Properties.AndroidMkProcMacroLibs = append(mod.Properties.AndroidMkProcMacroLibs, makeLibName)
Paul Duffind5cf92e2021-07-09 17:38:55 +01001037 }
1038
1039 if android.IsSourceDepTagWithOutputTag(depTag, "") {
Ivan Lozano07cbaf42020-07-22 16:09:13 -04001040 // Since these deps are added in path_properties.go via AddDependencies, we need to ensure the correct
1041 // OS/Arch variant is used.
1042 var helper string
1043 if ctx.Host() {
1044 helper = "missing 'host_supported'?"
1045 } else {
1046 helper = "device module defined?"
1047 }
1048
1049 if dep.Target().Os != ctx.Os() {
1050 ctx.ModuleErrorf("OS mismatch on dependency %q (%s)", dep.Name(), helper)
1051 return
1052 } else if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
1053 ctx.ModuleErrorf("Arch mismatch on dependency %q (%s)", dep.Name(), helper)
1054 return
1055 }
1056 directSrcProvidersDeps = append(directSrcProvidersDeps, rustDep)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001057 }
1058
Ivan Lozano2bbcacf2020-08-07 09:00:50 -04001059 //Append the dependencies exportedDirs, except for proc-macros which target a different arch/OS
Colin Cross0de8a1e2020-09-18 14:15:30 -07001060 if depTag != procMacroDepTag {
1061 exportedInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
1062 depPaths.linkDirs = append(depPaths.linkDirs, exportedInfo.LinkDirs...)
1063 depPaths.depFlags = append(depPaths.depFlags, exportedInfo.Flags...)
1064 depPaths.linkObjects = append(depPaths.linkObjects, exportedInfo.LinkObjects...)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001065 }
1066
Ivan Lozanoffee3342019-08-27 12:03:00 -07001067 if depTag == dylibDepTag || depTag == rlibDepTag || depTag == procMacroDepTag {
Jiyong Parke54f07e2021-04-07 15:08:04 +09001068 linkFile := rustDep.unstrippedOutputFile
Ivan Lozano26ecd6c2020-07-31 13:40:31 -04001069 if !linkFile.Valid() {
1070 ctx.ModuleErrorf("Invalid output file when adding dep %q to %q",
1071 depName, ctx.ModuleName())
1072 return
1073 }
Ivan Lozanoffee3342019-08-27 12:03:00 -07001074 linkDir := linkPathFromFilePath(linkFile.Path())
Matthew Maurerbb3add12020-06-25 09:34:12 -07001075 if lib, ok := mod.compiler.(exportedFlagsProducer); ok {
1076 lib.exportLinkDirs(linkDir)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001077 }
1078 }
1079
Ivan Lozano89435d12020-07-31 11:01:18 -04001080 } else if ccDep, ok := dep.(cc.LinkableInterface); ok {
Ivan Lozano52767be2019-10-18 14:49:46 -07001081 //Handle C dependencies
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001082 makeLibName := cc.MakeLibName(ctx, mod, ccDep, depName)
Ivan Lozano52767be2019-10-18 14:49:46 -07001083 if _, ok := ccDep.(*Module); !ok {
1084 if ccDep.Module().Target().Os != ctx.Os() {
1085 ctx.ModuleErrorf("OS mismatch between %q and %q", ctx.ModuleName(), depName)
1086 return
1087 }
1088 if ccDep.Module().Target().Arch.ArchType != ctx.Arch().ArchType {
1089 ctx.ModuleErrorf("Arch mismatch between %q and %q", ctx.ModuleName(), depName)
1090 return
1091 }
Ivan Lozano70e0a072019-09-13 14:23:15 -07001092 }
Ivan Lozano2093af22020-08-25 12:48:19 -04001093 linkObject := ccDep.OutputFile()
1094 linkPath := linkPathFromFilePath(linkObject.Path())
Ivan Lozano6aa66022020-02-06 13:22:43 -05001095
Ivan Lozano2093af22020-08-25 12:48:19 -04001096 if !linkObject.Valid() {
Ivan Lozanoffee3342019-08-27 12:03:00 -07001097 ctx.ModuleErrorf("Invalid output file when adding dep %q to %q", depName, ctx.ModuleName())
1098 }
1099
1100 exportDep := false
Colin Cross6e511a92020-07-27 21:26:48 -07001101 switch {
1102 case cc.IsStaticDepTag(depTag):
Ivan Lozano63bb7682021-03-23 15:53:44 -04001103 if cc.IsWholeStaticLib(depTag) {
1104 // rustc will bundle static libraries when they're passed with "-lstatic=<lib>". This will fail
1105 // if the library is not prefixed by "lib".
Ivan Lozanofb6f36f2021-02-05 12:27:08 -05001106 if libName, ok := libNameFromFilePath(linkObject.Path()); ok {
1107 depPaths.depFlags = append(depPaths.depFlags, "-lstatic="+libName)
Ivan Lozano63bb7682021-03-23 15:53:44 -04001108 } else {
1109 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 -05001110 }
Ivan Lozano3dfa12d2021-02-04 11:29:41 -05001111 }
1112
1113 // Add this to linkObjects to pass the library directly to the linker as well. This propagates
1114 // to dependencies to avoid having to redeclare static libraries for dependents of the dylib variant.
Ivan Lozano2093af22020-08-25 12:48:19 -04001115 depPaths.linkObjects = append(depPaths.linkObjects, linkObject.String())
Ivan Lozano3dfa12d2021-02-04 11:29:41 -05001116 depPaths.linkDirs = append(depPaths.linkDirs, linkPath)
1117
Colin Cross0de8a1e2020-09-18 14:15:30 -07001118 exportedInfo := ctx.OtherModuleProvider(dep, cc.FlagExporterInfoProvider).(cc.FlagExporterInfo)
1119 depPaths.depIncludePaths = append(depPaths.depIncludePaths, exportedInfo.IncludeDirs...)
1120 depPaths.depSystemIncludePaths = append(depPaths.depSystemIncludePaths, exportedInfo.SystemIncludeDirs...)
1121 depPaths.depClangFlags = append(depPaths.depClangFlags, exportedInfo.Flags...)
1122 depPaths.depGeneratedHeaders = append(depPaths.depGeneratedHeaders, exportedInfo.GeneratedHeaders...)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001123 directStaticLibDeps = append(directStaticLibDeps, ccDep)
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001124 mod.Properties.AndroidMkStaticLibs = append(mod.Properties.AndroidMkStaticLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07001125 case cc.IsSharedDepTag(depTag):
Jiyong Park7d55b612021-06-11 17:22:09 +09001126 // For the shared lib dependencies, we may link to the stub variant
1127 // of the dependency depending on the context (e.g. if this
1128 // dependency crosses the APEX boundaries).
1129 sharedLibraryInfo, exportedInfo := cc.ChooseStubOrImpl(ctx, dep)
1130
1131 // Re-get linkObject as ChooseStubOrImpl actually tells us which
1132 // object (either from stub or non-stub) to use.
1133 linkObject = android.OptionalPathForPath(sharedLibraryInfo.SharedLibrary)
1134 linkPath = linkPathFromFilePath(linkObject.Path())
1135
Ivan Lozanoffee3342019-08-27 12:03:00 -07001136 depPaths.linkDirs = append(depPaths.linkDirs, linkPath)
Ivan Lozano2093af22020-08-25 12:48:19 -04001137 depPaths.linkObjects = append(depPaths.linkObjects, linkObject.String())
Colin Cross0de8a1e2020-09-18 14:15:30 -07001138 depPaths.depIncludePaths = append(depPaths.depIncludePaths, exportedInfo.IncludeDirs...)
1139 depPaths.depSystemIncludePaths = append(depPaths.depSystemIncludePaths, exportedInfo.SystemIncludeDirs...)
1140 depPaths.depClangFlags = append(depPaths.depClangFlags, exportedInfo.Flags...)
1141 depPaths.depGeneratedHeaders = append(depPaths.depGeneratedHeaders, exportedInfo.GeneratedHeaders...)
Jiyong Park7d55b612021-06-11 17:22:09 +09001142 directSharedLibDeps = append(directSharedLibDeps, sharedLibraryInfo)
Ivan Lozano1921e802021-05-20 13:39:16 -04001143
1144 // Record baseLibName for snapshots.
1145 mod.Properties.SnapshotSharedLibs = append(mod.Properties.SnapshotSharedLibs, cc.BaseLibName(depName))
Justin Yun5e035862021-06-29 20:50:37 +09001146 mod.Properties.SnapshotStaticLibs = append(mod.Properties.SnapshotStaticLibs, cc.BaseLibName(depName))
Ivan Lozano1921e802021-05-20 13:39:16 -04001147
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001148 mod.Properties.AndroidMkSharedLibs = append(mod.Properties.AndroidMkSharedLibs, makeLibName)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001149 exportDep = true
Zach Johnson3df4e632020-11-06 11:56:27 -08001150 case cc.IsHeaderDepTag(depTag):
1151 exportedInfo := ctx.OtherModuleProvider(dep, cc.FlagExporterInfoProvider).(cc.FlagExporterInfo)
1152 depPaths.depIncludePaths = append(depPaths.depIncludePaths, exportedInfo.IncludeDirs...)
1153 depPaths.depSystemIncludePaths = append(depPaths.depSystemIncludePaths, exportedInfo.SystemIncludeDirs...)
1154 depPaths.depGeneratedHeaders = append(depPaths.depGeneratedHeaders, exportedInfo.GeneratedHeaders...)
Colin Cross6e511a92020-07-27 21:26:48 -07001155 case depTag == cc.CrtBeginDepTag:
Ivan Lozano2093af22020-08-25 12:48:19 -04001156 depPaths.CrtBegin = linkObject
Colin Cross6e511a92020-07-27 21:26:48 -07001157 case depTag == cc.CrtEndDepTag:
Ivan Lozano2093af22020-08-25 12:48:19 -04001158 depPaths.CrtEnd = linkObject
Ivan Lozanoffee3342019-08-27 12:03:00 -07001159 }
1160
1161 // Make sure these dependencies are propagated
Matthew Maurerbb3add12020-06-25 09:34:12 -07001162 if lib, ok := mod.compiler.(exportedFlagsProducer); ok && exportDep {
1163 lib.exportLinkDirs(linkPath)
Ivan Lozano2093af22020-08-25 12:48:19 -04001164 lib.exportLinkObjects(linkObject.String())
Ivan Lozanoffee3342019-08-27 12:03:00 -07001165 }
Ivan Lozanoffee3342019-08-27 12:03:00 -07001166 }
Ivan Lozano89435d12020-07-31 11:01:18 -04001167
1168 if srcDep, ok := dep.(android.SourceFileProducer); ok {
Paul Duffind5cf92e2021-07-09 17:38:55 +01001169 if android.IsSourceDepTagWithOutputTag(depTag, "") {
Ivan Lozano89435d12020-07-31 11:01:18 -04001170 // These are usually genrules which don't have per-target variants.
1171 directSrcDeps = append(directSrcDeps, srcDep)
1172 }
1173 }
Ivan Lozanoffee3342019-08-27 12:03:00 -07001174 })
1175
1176 var rlibDepFiles RustLibraries
1177 for _, dep := range directRlibDeps {
Jiyong Parke54f07e2021-04-07 15:08:04 +09001178 rlibDepFiles = append(rlibDepFiles, RustLibrary{Path: dep.unstrippedOutputFile.Path(), CrateName: dep.CrateName()})
Ivan Lozanoffee3342019-08-27 12:03:00 -07001179 }
1180 var dylibDepFiles RustLibraries
1181 for _, dep := range directDylibDeps {
Jiyong Parke54f07e2021-04-07 15:08:04 +09001182 dylibDepFiles = append(dylibDepFiles, RustLibrary{Path: dep.unstrippedOutputFile.Path(), CrateName: dep.CrateName()})
Ivan Lozanoffee3342019-08-27 12:03:00 -07001183 }
1184 var procMacroDepFiles RustLibraries
1185 for _, dep := range directProcMacroDeps {
Jiyong Parke54f07e2021-04-07 15:08:04 +09001186 procMacroDepFiles = append(procMacroDepFiles, RustLibrary{Path: dep.unstrippedOutputFile.Path(), CrateName: dep.CrateName()})
Ivan Lozanoffee3342019-08-27 12:03:00 -07001187 }
1188
1189 var staticLibDepFiles android.Paths
1190 for _, dep := range directStaticLibDeps {
1191 staticLibDepFiles = append(staticLibDepFiles, dep.OutputFile().Path())
1192 }
1193
Ivan Lozanoec6e9912021-01-21 15:23:29 -05001194 var sharedLibFiles android.Paths
Ivan Lozanoffee3342019-08-27 12:03:00 -07001195 var sharedLibDepFiles android.Paths
1196 for _, dep := range directSharedLibDeps {
Jiyong Park7d55b612021-06-11 17:22:09 +09001197 sharedLibFiles = append(sharedLibFiles, dep.SharedLibrary)
1198 if dep.TableOfContents.Valid() {
1199 sharedLibDepFiles = append(sharedLibDepFiles, dep.TableOfContents.Path())
Ivan Lozanoec6e9912021-01-21 15:23:29 -05001200 } else {
Jiyong Park7d55b612021-06-11 17:22:09 +09001201 sharedLibDepFiles = append(sharedLibDepFiles, dep.SharedLibrary)
Ivan Lozanoec6e9912021-01-21 15:23:29 -05001202 }
Ivan Lozanoffee3342019-08-27 12:03:00 -07001203 }
1204
Ivan Lozano07cbaf42020-07-22 16:09:13 -04001205 var srcProviderDepFiles android.Paths
1206 for _, dep := range directSrcProvidersDeps {
1207 srcs, _ := dep.OutputFiles("")
1208 srcProviderDepFiles = append(srcProviderDepFiles, srcs...)
1209 }
1210 for _, dep := range directSrcDeps {
1211 srcs := dep.Srcs()
1212 srcProviderDepFiles = append(srcProviderDepFiles, srcs...)
1213 }
1214
Ivan Lozanoffee3342019-08-27 12:03:00 -07001215 depPaths.RLibs = append(depPaths.RLibs, rlibDepFiles...)
1216 depPaths.DyLibs = append(depPaths.DyLibs, dylibDepFiles...)
1217 depPaths.SharedLibs = append(depPaths.SharedLibs, sharedLibDepFiles...)
Ivan Lozanoec6e9912021-01-21 15:23:29 -05001218 depPaths.SharedLibDeps = append(depPaths.SharedLibDeps, sharedLibDepFiles...)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001219 depPaths.StaticLibs = append(depPaths.StaticLibs, staticLibDepFiles...)
1220 depPaths.ProcMacros = append(depPaths.ProcMacros, procMacroDepFiles...)
Ivan Lozano07cbaf42020-07-22 16:09:13 -04001221 depPaths.SrcDeps = append(depPaths.SrcDeps, srcProviderDepFiles...)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001222
1223 // Dedup exported flags from dependencies
1224 depPaths.linkDirs = android.FirstUniqueStrings(depPaths.linkDirs)
Ivan Lozanoec6e9912021-01-21 15:23:29 -05001225 depPaths.linkObjects = android.FirstUniqueStrings(depPaths.linkObjects)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001226 depPaths.depFlags = android.FirstUniqueStrings(depPaths.depFlags)
Ivan Lozano45901ed2020-07-24 16:05:01 -04001227 depPaths.depClangFlags = android.FirstUniqueStrings(depPaths.depClangFlags)
1228 depPaths.depIncludePaths = android.FirstUniquePaths(depPaths.depIncludePaths)
1229 depPaths.depSystemIncludePaths = android.FirstUniquePaths(depPaths.depSystemIncludePaths)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001230
1231 return depPaths
1232}
1233
Chih-Hung Hsieh9a4a7ba2019-12-12 19:36:05 -08001234func (mod *Module) InstallInData() bool {
1235 if mod.compiler == nil {
1236 return false
1237 }
1238 return mod.compiler.inData()
1239}
1240
Matthew Maurer9f59e8d2021-08-19 13:10:05 -07001241func (mod *Module) InstallInRamdisk() bool {
1242 return mod.InRamdisk()
1243}
1244
1245func (mod *Module) InstallInVendorRamdisk() bool {
1246 return mod.InVendorRamdisk()
1247}
1248
1249func (mod *Module) InstallInRecovery() bool {
1250 return mod.InRecovery()
1251}
1252
Ivan Lozanoffee3342019-08-27 12:03:00 -07001253func linkPathFromFilePath(filepath android.Path) string {
1254 return strings.Split(filepath.String(), filepath.Base())[0]
1255}
Ivan Lozanod648c432020-02-06 12:05:10 -05001256
Ivan Lozanoffee3342019-08-27 12:03:00 -07001257func (mod *Module) DepsMutator(actx android.BottomUpMutatorContext) {
1258 ctx := &depsContext{
1259 BottomUpMutatorContext: actx,
Ivan Lozanoffee3342019-08-27 12:03:00 -07001260 }
Ivan Lozanoffee3342019-08-27 12:03:00 -07001261
1262 deps := mod.deps(ctx)
Colin Cross3146c5c2020-09-30 15:34:40 -07001263 var commonDepVariations []blueprint.Variation
Ivan Lozano1921e802021-05-20 13:39:16 -04001264 var snapshotInfo *cc.SnapshotInfo
1265
1266 if ctx.Os() == android.Android {
1267 deps.SharedLibs, _ = cc.RewriteLibs(mod, &snapshotInfo, actx, ctx.Config(), deps.SharedLibs)
1268 }
Ivan Lozanodd055472020-09-28 13:22:45 -04001269
Ivan Lozano2b081132020-09-08 12:46:52 -04001270 stdLinkage := "dylib-std"
Ivan Lozanodd055472020-09-28 13:22:45 -04001271 if mod.compiler.stdLinkage(ctx) == RlibLinkage {
Ivan Lozano2b081132020-09-08 12:46:52 -04001272 stdLinkage = "rlib-std"
1273 }
1274
1275 rlibDepVariations := commonDepVariations
Ivan Lozano1921e802021-05-20 13:39:16 -04001276
Ivan Lozano2b081132020-09-08 12:46:52 -04001277 if lib, ok := mod.compiler.(libraryInterface); !ok || !lib.sysroot() {
1278 rlibDepVariations = append(rlibDepVariations,
1279 blueprint.Variation{Mutator: "rust_stdlinkage", Variation: stdLinkage})
1280 }
1281
Ivan Lozano1921e802021-05-20 13:39:16 -04001282 // rlibs
Ivan Lozano3149e6e2021-06-01 15:09:53 -04001283 for _, lib := range deps.Rlibs {
1284 depTag := rlibDepTag
1285 lib = cc.RewriteSnapshotLib(lib, cc.GetSnapshot(mod, &snapshotInfo, actx).Rlibs)
1286
1287 actx.AddVariationDependencies(append(rlibDepVariations, []blueprint.Variation{
1288 {Mutator: "rust_libraries", Variation: rlibVariation},
1289 }...), depTag, lib)
1290 }
Ivan Lozano1921e802021-05-20 13:39:16 -04001291
1292 // dylibs
Ivan Lozano52767be2019-10-18 14:49:46 -07001293 actx.AddVariationDependencies(
1294 append(commonDepVariations, []blueprint.Variation{
Thiébaud Weksteen295c72b2020-09-23 18:10:17 +02001295 {Mutator: "rust_libraries", Variation: dylibVariation}}...),
Ivan Lozano52767be2019-10-18 14:49:46 -07001296 dylibDepTag, deps.Dylibs...)
1297
Ivan Lozano1921e802021-05-20 13:39:16 -04001298 // rustlibs
Ivan Lozano042504f2020-08-18 14:31:23 -04001299 if deps.Rustlibs != nil && !mod.compiler.Disabled() {
1300 autoDep := mod.compiler.(autoDeppable).autoDep(ctx)
Ivan Lozano2b081132020-09-08 12:46:52 -04001301 if autoDep.depTag == rlibDepTag {
Ivan Lozano3149e6e2021-06-01 15:09:53 -04001302 for _, lib := range deps.Rustlibs {
1303 depTag := autoDep.depTag
1304 lib = cc.RewriteSnapshotLib(lib, cc.GetSnapshot(mod, &snapshotInfo, actx).Rlibs)
1305 actx.AddVariationDependencies(append(rlibDepVariations, []blueprint.Variation{
1306 {Mutator: "rust_libraries", Variation: autoDep.variation},
1307 }...), depTag, lib)
1308 }
Ivan Lozano2b081132020-09-08 12:46:52 -04001309 } else {
1310 actx.AddVariationDependencies(
1311 append(commonDepVariations, blueprint.Variation{Mutator: "rust_libraries", Variation: autoDep.variation}),
1312 autoDep.depTag, deps.Rustlibs...)
1313 }
Matthew Maurer0f003b12020-06-29 14:34:06 -07001314 }
Ivan Lozano1921e802021-05-20 13:39:16 -04001315
1316 // stdlibs
Ivan Lozano2b081132020-09-08 12:46:52 -04001317 if deps.Stdlibs != nil {
Ivan Lozanodd055472020-09-28 13:22:45 -04001318 if mod.compiler.stdLinkage(ctx) == RlibLinkage {
Ivan Lozano3149e6e2021-06-01 15:09:53 -04001319 for _, lib := range deps.Stdlibs {
1320 depTag := rlibDepTag
1321 lib = cc.RewriteSnapshotLib(lib, cc.GetSnapshot(mod, &snapshotInfo, actx).Rlibs)
1322
1323 actx.AddVariationDependencies(append(commonDepVariations, []blueprint.Variation{{Mutator: "rust_libraries", Variation: "rlib"}}...),
1324 depTag, lib)
1325 }
Ivan Lozano2b081132020-09-08 12:46:52 -04001326 } else {
1327 actx.AddVariationDependencies(
1328 append(commonDepVariations, blueprint.Variation{Mutator: "rust_libraries", Variation: "dylib"}),
1329 dylibDepTag, deps.Stdlibs...)
1330 }
1331 }
Ivan Lozano1921e802021-05-20 13:39:16 -04001332
1333 for _, lib := range deps.SharedLibs {
1334 depTag := cc.SharedDepTag()
1335 name, version := cc.StubsLibNameAndVersion(lib)
1336
1337 variations := []blueprint.Variation{
1338 {Mutator: "link", Variation: "shared"},
1339 }
1340 cc.AddSharedLibDependenciesWithVersions(ctx, mod, variations, depTag, name, version, false)
1341 }
1342
1343 for _, lib := range deps.WholeStaticLibs {
1344 depTag := cc.StaticDepTag(true)
1345 lib = cc.RewriteSnapshotLib(lib, cc.GetSnapshot(mod, &snapshotInfo, actx).StaticLibs)
1346
1347 actx.AddVariationDependencies([]blueprint.Variation{
1348 {Mutator: "link", Variation: "static"},
1349 }, depTag, lib)
1350 }
1351
1352 for _, lib := range deps.StaticLibs {
1353 depTag := cc.StaticDepTag(false)
1354 lib = cc.RewriteSnapshotLib(lib, cc.GetSnapshot(mod, &snapshotInfo, actx).StaticLibs)
1355
1356 actx.AddVariationDependencies([]blueprint.Variation{
1357 {Mutator: "link", Variation: "static"},
1358 }, depTag, lib)
1359 }
Ivan Lozano5ca5ef62019-09-23 10:10:40 -07001360
Zach Johnson3df4e632020-11-06 11:56:27 -08001361 actx.AddVariationDependencies(nil, cc.HeaderDepTag(), deps.HeaderLibs...)
1362
Colin Cross565cafd2020-09-25 18:47:38 -07001363 crtVariations := cc.GetCrtVariations(ctx, mod)
Ivan Lozanof1c84332019-09-20 11:00:37 -07001364 if deps.CrtBegin != "" {
Ivan Lozano1921e802021-05-20 13:39:16 -04001365 actx.AddVariationDependencies(crtVariations, cc.CrtBeginDepTag,
1366 cc.RewriteSnapshotLib(deps.CrtBegin, cc.GetSnapshot(mod, &snapshotInfo, actx).Objects))
Ivan Lozanof1c84332019-09-20 11:00:37 -07001367 }
1368 if deps.CrtEnd != "" {
Ivan Lozano1921e802021-05-20 13:39:16 -04001369 actx.AddVariationDependencies(crtVariations, cc.CrtEndDepTag,
1370 cc.RewriteSnapshotLib(deps.CrtEnd, cc.GetSnapshot(mod, &snapshotInfo, actx).Objects))
Ivan Lozanof1c84332019-09-20 11:00:37 -07001371 }
1372
Ivan Lozanoc564d2d2020-08-04 15:43:37 -04001373 if mod.sourceProvider != nil {
1374 if bindgen, ok := mod.sourceProvider.(*bindgenDecorator); ok &&
1375 bindgen.Properties.Custom_bindgen != "" {
1376 actx.AddFarVariationDependencies(ctx.Config().BuildOSTarget.Variations(), customBindgenDepTag,
1377 bindgen.Properties.Custom_bindgen)
1378 }
1379 }
Ivan Lozano1921e802021-05-20 13:39:16 -04001380
Ivan Lozano5ca5ef62019-09-23 10:10:40 -07001381 // proc_macros are compiler plugins, and so we need the host arch variant as a dependendcy.
Colin Cross0f7d2ef2019-10-16 11:03:10 -07001382 actx.AddFarVariationDependencies(ctx.Config().BuildOSTarget.Variations(), procMacroDepTag, deps.ProcMacros...)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001383}
1384
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001385func BeginMutator(ctx android.BottomUpMutatorContext) {
1386 if mod, ok := ctx.Module().(*Module); ok && mod.Enabled() {
1387 mod.beginMutator(ctx)
1388 }
1389}
1390
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001391func (mod *Module) beginMutator(actx android.BottomUpMutatorContext) {
1392 ctx := &baseModuleContext{
1393 BaseModuleContext: actx,
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001394 }
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001395
1396 mod.begin(ctx)
1397}
1398
Ivan Lozanoffee3342019-08-27 12:03:00 -07001399func (mod *Module) Name() string {
1400 name := mod.ModuleBase.Name()
1401 if p, ok := mod.compiler.(interface {
1402 Name(string) string
1403 }); ok {
1404 name = p.Name(name)
1405 }
1406 return name
1407}
1408
Thiébaud Weksteen9e8451e2020-08-13 12:55:59 +02001409func (mod *Module) disableClippy() {
Ivan Lozano32267c82020-08-04 16:27:16 -04001410 if mod.clippy != nil {
Thiébaud Weksteen9e8451e2020-08-13 12:55:59 +02001411 mod.clippy.Properties.Clippy_lints = proptools.StringPtr("none")
Ivan Lozano32267c82020-08-04 16:27:16 -04001412 }
1413}
1414
Chih-Hung Hsieh5c4e4892020-05-15 17:36:30 -07001415var _ android.HostToolProvider = (*Module)(nil)
1416
1417func (mod *Module) HostToolPath() android.OptionalPath {
1418 if !mod.Host() {
1419 return android.OptionalPath{}
1420 }
Chih-Hung Hsieha7562702020-08-10 21:50:43 -07001421 if binary, ok := mod.compiler.(*binaryDecorator); ok {
1422 return android.OptionalPathForPath(binary.baseCompiler.path)
Chih-Hung Hsieh5c4e4892020-05-15 17:36:30 -07001423 }
1424 return android.OptionalPath{}
1425}
1426
Jiyong Park99644e92020-11-17 22:21:02 +09001427var _ android.ApexModule = (*Module)(nil)
1428
Ivan Lozano3e9f9e42020-12-04 15:05:43 -05001429func (mod *Module) minSdkVersion() string {
1430 return String(mod.Properties.Min_sdk_version)
1431}
1432
Jiyong Park45bf82e2020-12-15 22:29:02 +09001433var _ android.ApexModule = (*Module)(nil)
1434
1435// Implements android.ApexModule
Jiyong Park99644e92020-11-17 22:21:02 +09001436func (mod *Module) ShouldSupportSdkVersion(ctx android.BaseModuleContext, sdkVersion android.ApiLevel) error {
Ivan Lozano3e9f9e42020-12-04 15:05:43 -05001437 minSdkVersion := mod.minSdkVersion()
1438 if minSdkVersion == "apex_inherit" {
1439 return nil
1440 }
1441 if minSdkVersion == "" {
1442 return fmt.Errorf("min_sdk_version is not specificed")
1443 }
1444
1445 // Not using nativeApiLevelFromUser because the context here is not
1446 // necessarily a native context.
1447 ver, err := android.ApiLevelFromUser(ctx, minSdkVersion)
1448 if err != nil {
1449 return err
1450 }
1451
1452 if ver.GreaterThan(sdkVersion) {
1453 return fmt.Errorf("newer SDK(%v)", ver)
1454 }
Jiyong Park99644e92020-11-17 22:21:02 +09001455 return nil
1456}
1457
Jiyong Park45bf82e2020-12-15 22:29:02 +09001458// Implements android.ApexModule
Jiyong Park99644e92020-11-17 22:21:02 +09001459func (mod *Module) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
1460 depTag := ctx.OtherModuleDependencyTag(dep)
1461
1462 if ccm, ok := dep.(*cc.Module); ok {
1463 if ccm.HasStubsVariants() {
1464 if cc.IsSharedDepTag(depTag) {
1465 // dynamic dep to a stubs lib crosses APEX boundary
1466 return false
1467 }
1468 if cc.IsRuntimeDepTag(depTag) {
1469 // runtime dep to a stubs lib also crosses APEX boundary
1470 return false
1471 }
1472
1473 if cc.IsHeaderDepTag(depTag) {
1474 return false
1475 }
1476 }
1477 if mod.Static() && cc.IsSharedDepTag(depTag) {
1478 // shared_lib dependency from a static lib is considered as crossing
1479 // the APEX boundary because the dependency doesn't actually is
1480 // linked; the dependency is used only during the compilation phase.
1481 return false
1482 }
1483 }
1484
1485 if depTag == procMacroDepTag {
1486 return false
1487 }
1488
1489 return true
1490}
1491
1492// Overrides ApexModule.IsInstallabeToApex()
1493func (mod *Module) IsInstallableToApex() bool {
1494 if mod.compiler != nil {
1495 if lib, ok := mod.compiler.(*libraryDecorator); ok && (lib.shared() || lib.dylib()) {
1496 return true
1497 }
1498 if _, ok := mod.compiler.(*binaryDecorator); ok {
1499 return true
1500 }
1501 }
1502 return false
1503}
1504
Ivan Lozano3dfa12d2021-02-04 11:29:41 -05001505// If a library file has a "lib" prefix, extract the library name without the prefix.
1506func libNameFromFilePath(filepath android.Path) (string, bool) {
1507 libName := strings.TrimSuffix(filepath.Base(), filepath.Ext())
1508 if strings.HasPrefix(libName, "lib") {
1509 libName = libName[3:]
1510 return libName, true
1511 }
1512 return "", false
1513}
1514
Ivan Lozanoffee3342019-08-27 12:03:00 -07001515var Bool = proptools.Bool
1516var BoolDefault = proptools.BoolDefault
1517var String = proptools.String
1518var StringPtr = proptools.StringPtr
Ivan Lozano43845682020-07-09 21:03:28 -04001519
1520var _ android.OutputFileProducer = (*Module)(nil)