blob: fe5b303171a78a0521926c16ff5f99069d4c2a67 [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 (
Sasha Smundaka76acba2022-04-18 20:12:56 -070018 "android/soong/bloaty"
Ivan Lozano183a3212019-10-18 14:18:45 -070019 "fmt"
Ivan Lozanoffee3342019-08-27 12:03:00 -070020 "strings"
21
22 "github.com/google/blueprint"
23 "github.com/google/blueprint/proptools"
24
25 "android/soong/android"
26 "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"
Spandan Das604f3762023-03-16 22:51:40 +000029 "android/soong/multitree"
Ivan Lozanoffee3342019-08-27 12:03:00 -070030 "android/soong/rust/config"
Ivan Lozano872d5792022-03-23 17:31:39 -040031 "android/soong/snapshot"
Ivan Lozanoffee3342019-08-27 12:03:00 -070032)
33
34var pctx = android.NewPackageContext("android/soong/rust")
35
36func init() {
Ivan Lozanoffee3342019-08-27 12:03:00 -070037 android.RegisterModuleType("rust_defaults", defaultsFactory)
38 android.PreDepsMutators(func(ctx android.RegisterMutatorsContext) {
39 ctx.BottomUp("rust_libraries", LibraryMutator).Parallel()
Ivan Lozano2b081132020-09-08 12:46:52 -040040 ctx.BottomUp("rust_stdlinkage", LibstdMutator).Parallel()
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -040041 ctx.BottomUp("rust_begin", BeginMutator).Parallel()
Ivan Lozano6cd99e62020-02-11 08:24:25 -050042 })
43 android.PostDepsMutators(func(ctx android.RegisterMutatorsContext) {
44 ctx.BottomUp("rust_sanitizers", rustSanitizerRuntimeMutator).Parallel()
Ivan Lozanoffee3342019-08-27 12:03:00 -070045 })
Inseob Kim3b244062023-07-11 13:31:36 +090046 pctx.Import("android/soong/android")
Ivan Lozanoffee3342019-08-27 12:03:00 -070047 pctx.Import("android/soong/rust/config")
Thiébaud Weksteen682c9d72020-08-31 10:06:16 +020048 pctx.ImportAs("cc_config", "android/soong/cc/config")
LaMont Jones0c10e4d2023-05-16 00:58:37 +000049 android.InitRegistrationContext.RegisterParallelSingletonType("kythe_rust_extract", kytheExtractRustFactory)
Ivan Lozanoffee3342019-08-27 12:03:00 -070050}
51
52type Flags struct {
Ivan Lozano8a23fa42020-06-16 10:26:57 -040053 GlobalRustFlags []string // Flags that apply globally to rust
54 GlobalLinkFlags []string // Flags that apply globally to linker
55 RustFlags []string // Flags that apply to rust
56 LinkFlags []string // Flags that apply to linker
Thiébaud Weksteen92f703b2020-06-22 13:28:02 +020057 ClippyFlags []string // Flags that apply to clippy-driver, during the linting
Dan Albert06feee92021-03-19 15:06:02 -070058 RustdocFlags []string // Flags that apply to rustdoc
Ivan Lozanof1c84332019-09-20 11:00:37 -070059 Toolchain config.Toolchain
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -040060 Coverage bool
Thiébaud Weksteen92f703b2020-06-22 13:28:02 +020061 Clippy bool
Sasha Smundaka76acba2022-04-18 20:12:56 -070062 EmitXrefs bool // If true, emit rules to aid cross-referencing
Ivan Lozanoffee3342019-08-27 12:03:00 -070063}
64
65type BaseProperties struct {
Liz Kammer884fe9e2023-02-28 14:29:13 -050066 AndroidMkRlibs []string `blueprint:"mutated"`
67 AndroidMkDylibs []string `blueprint:"mutated"`
68 AndroidMkProcMacroLibs []string `blueprint:"mutated"`
Liz Kammer884fe9e2023-02-28 14:29:13 -050069 AndroidMkStaticLibs []string `blueprint:"mutated"`
Ivan Lozano43845682020-07-09 21:03:28 -040070
Ivan Lozano6a884432020-12-02 09:15:16 -050071 ImageVariationPrefix string `blueprint:"mutated"`
72 VndkVersion string `blueprint:"mutated"`
73 SubName string `blueprint:"mutated"`
74
Ivan Lozanoc08897c2021-04-02 12:41:32 -040075 // SubName is used by CC for tracking image variants / SDK versions. RustSubName is used for Rust-specific
76 // subnaming which shouldn't be visible to CC modules (such as the rlib stdlinkage subname). This should be
77 // appended before SubName.
78 RustSubName string `blueprint:"mutated"`
79
Ivan Lozano6a884432020-12-02 09:15:16 -050080 // Set by imageMutator
Ivan Lozanoe6d30982021-02-05 10:57:43 -050081 CoreVariantNeeded bool `blueprint:"mutated"`
82 VendorRamdiskVariantNeeded bool `blueprint:"mutated"`
Matthew Maurerc6868382021-07-13 14:12:37 -070083 RamdiskVariantNeeded bool `blueprint:"mutated"`
Matthew Maurer460ee942021-02-11 12:31:46 -080084 RecoveryVariantNeeded bool `blueprint:"mutated"`
Ivan Lozanoe6d30982021-02-05 10:57:43 -050085 ExtraVariants []string `blueprint:"mutated"`
86
Ivan Lozanoa2268632021-07-22 10:52:06 -040087 // Allows this module to use non-APEX version of libraries. Useful
88 // for building binaries that are started before APEXes are activated.
89 Bootstrap *bool
90
Ivan Lozano1921e802021-05-20 13:39:16 -040091 // Used by vendor snapshot to record dependencies from snapshot modules.
92 SnapshotSharedLibs []string `blueprint:"mutated"`
Justin Yun5e035862021-06-29 20:50:37 +090093 SnapshotStaticLibs []string `blueprint:"mutated"`
Ivan Lozanoadd122a2023-07-13 11:01:41 -040094 SnapshotRlibs []string `blueprint:"mutated"`
95 SnapshotDylibs []string `blueprint:"mutated"`
Ivan Lozano1921e802021-05-20 13:39:16 -040096
Matthew Maurerc6868382021-07-13 14:12:37 -070097 // Make this module available when building for ramdisk.
98 // On device without a dedicated recovery partition, the module is only
99 // available after switching root into
100 // /first_stage_ramdisk. To expose the module before switching root, install
101 // the recovery variant instead.
102 Ramdisk_available *bool
103
Ivan Lozanoe6d30982021-02-05 10:57:43 -0500104 // Make this module available when building for vendor ramdisk.
105 // On device without a dedicated recovery partition, the module is only
106 // available after switching root into
107 // /first_stage_ramdisk. To expose the module before switching root, install
Matthew Maurer460ee942021-02-11 12:31:46 -0800108 // the recovery variant instead
Ivan Lozanoe6d30982021-02-05 10:57:43 -0500109 Vendor_ramdisk_available *bool
Ivan Lozano26ecd6c2020-07-31 13:40:31 -0400110
Ivan Lozano1921e802021-05-20 13:39:16 -0400111 // Normally Soong uses the directory structure to decide which modules
112 // should be included (framework) or excluded (non-framework) from the
113 // different snapshots (vendor, recovery, etc.), but this property
114 // allows a partner to exclude a module normally thought of as a
115 // framework module from the vendor snapshot.
116 Exclude_from_vendor_snapshot *bool
117
118 // Normally Soong uses the directory structure to decide which modules
119 // should be included (framework) or excluded (non-framework) from the
120 // different snapshots (vendor, recovery, etc.), but this property
121 // allows a partner to exclude a module normally thought of as a
122 // framework module from the recovery snapshot.
123 Exclude_from_recovery_snapshot *bool
124
Matthew Maurer460ee942021-02-11 12:31:46 -0800125 // Make this module available when building for recovery
126 Recovery_available *bool
127
Ivan Lozano3e9f9e42020-12-04 15:05:43 -0500128 // Minimum sdk version that the artifact should support when it runs as part of mainline modules(APEX).
129 Min_sdk_version *string
130
Jiyong Parkd1e366a2021-10-05 09:12:41 +0900131 HideFromMake bool `blueprint:"mutated"`
132 PreventInstall bool `blueprint:"mutated"`
133
134 Installable *bool
Ivan Lozanoffee3342019-08-27 12:03:00 -0700135}
136
137type Module struct {
hamzehc0a671f2021-07-22 12:05:08 -0700138 fuzz.FuzzModule
Ivan Lozanoffee3342019-08-27 12:03:00 -0700139
Ivan Lozano6a884432020-12-02 09:15:16 -0500140 VendorProperties cc.VendorProperties
141
Ivan Lozanoffee3342019-08-27 12:03:00 -0700142 Properties BaseProperties
143
144 hod android.HostOrDeviceSupported
145 multilib android.Multilib
146
Ivan Lozano6a884432020-12-02 09:15:16 -0500147 makeLinkType string
148
Yi Kong46c6e592022-01-20 22:55:00 +0800149 afdo *afdo
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
Ivan Lozano8d10fc32021-11-05 16:36:47 -0400158 // Output file to be installed, may be stripped or unstripped.
159 outputFile android.OptionalPath
160
Sasha Smundaka76acba2022-04-18 20:12:56 -0700161 // Cross-reference input file
162 kytheFiles android.Paths
163
Ivan Lozano8d10fc32021-11-05 16:36:47 -0400164 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
Cole Faustb6e6f992023-08-17 17:42:26 -0700170
171 transitiveAndroidMkSharedLibs *android.DepSet[string]
Ivan Lozanoffee3342019-08-27 12:03:00 -0700172}
173
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500174func (mod *Module) Header() bool {
175 //TODO: If Rust libraries provide header variants, this needs to be updated.
176 return false
177}
178
179func (mod *Module) SetPreventInstall() {
180 mod.Properties.PreventInstall = true
181}
182
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500183func (mod *Module) SetHideFromMake() {
184 mod.Properties.HideFromMake = true
185}
186
Jiyong Parkd1e366a2021-10-05 09:12:41 +0900187func (mod *Module) HiddenFromMake() bool {
188 return mod.Properties.HideFromMake
Ivan Lozanod7586b62021-04-01 09:49:36 -0400189}
190
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500191func (mod *Module) SanitizePropDefined() bool {
Ivan Lozano6cd99e62020-02-11 08:24:25 -0500192 // Because compiler is not set for some Rust modules where sanitize might be set, check that compiler is also not
193 // nil since we need compiler to actually sanitize.
194 return mod.sanitize != nil && mod.compiler != nil
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500195}
196
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500197func (mod *Module) IsPrebuilt() bool {
198 if _, ok := mod.compiler.(*prebuiltLibraryDecorator); ok {
199 return true
200 }
201 return false
202}
203
Ivan Lozano43845682020-07-09 21:03:28 -0400204func (mod *Module) OutputFiles(tag string) (android.Paths, error) {
205 switch tag {
206 case "":
Andrei Homescu5db69cc2020-08-06 15:27:45 -0700207 if mod.sourceProvider != nil && (mod.compiler == nil || mod.compiler.Disabled()) {
Ivan Lozano43845682020-07-09 21:03:28 -0400208 return mod.sourceProvider.Srcs(), nil
209 } else {
Jiyong Parke54f07e2021-04-07 15:08:04 +0900210 if mod.OutputFile().Valid() {
211 return android.Paths{mod.OutputFile().Path()}, nil
Ivan Lozano43845682020-07-09 21:03:28 -0400212 }
213 return android.Paths{}, nil
214 }
Ivan Lozano0f9963e2023-02-06 13:31:02 -0500215 case "unstripped":
216 if mod.compiler != nil {
217 return android.PathsIfNonNil(mod.compiler.unstrippedOutputFilePath()), nil
218 }
219 return nil, nil
Ivan Lozano43845682020-07-09 21:03:28 -0400220 default:
221 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
222 }
223}
224
Ivan Lozano52767be2019-10-18 14:49:46 -0700225func (mod *Module) SelectedStl() string {
226 return ""
227}
228
Ivan Lozano2b262972019-11-21 12:30:50 -0800229func (mod *Module) NonCcVariants() bool {
230 if mod.compiler != nil {
Ivan Lozano89435d12020-07-31 11:01:18 -0400231 if _, ok := mod.compiler.(libraryInterface); ok {
232 return false
Ivan Lozano2b262972019-11-21 12:30:50 -0800233 }
234 }
235 panic(fmt.Errorf("NonCcVariants called on non-library module: %q", mod.BaseModuleName()))
236}
237
Ivan Lozano52767be2019-10-18 14:49:46 -0700238func (mod *Module) Static() bool {
239 if mod.compiler != nil {
240 if library, ok := mod.compiler.(libraryInterface); ok {
241 return library.static()
242 }
243 }
Ivan Lozano89435d12020-07-31 11:01:18 -0400244 return false
Ivan Lozano52767be2019-10-18 14:49:46 -0700245}
246
247func (mod *Module) Shared() bool {
248 if mod.compiler != nil {
249 if library, ok := mod.compiler.(libraryInterface); ok {
Ivan Lozano89435d12020-07-31 11:01:18 -0400250 return library.shared()
Ivan Lozano52767be2019-10-18 14:49:46 -0700251 }
252 }
Ivan Lozano89435d12020-07-31 11:01:18 -0400253 return false
Ivan Lozano52767be2019-10-18 14:49:46 -0700254}
255
Ivan Lozanod7586b62021-04-01 09:49:36 -0400256func (mod *Module) Dylib() bool {
257 if mod.compiler != nil {
258 if library, ok := mod.compiler.(libraryInterface); ok {
259 return library.dylib()
260 }
261 }
262 return false
263}
264
Ivan Lozanoadd122a2023-07-13 11:01:41 -0400265func (mod *Module) RlibStd() bool {
266 if mod.compiler != nil {
267 if library, ok := mod.compiler.(libraryInterface); ok && library.rlib() {
268 return library.rlibStd()
269 }
270 }
271 panic(fmt.Errorf("RlibStd() called on non-rlib module: %q", mod.BaseModuleName()))
272}
273
Ivan Lozanod7586b62021-04-01 09:49:36 -0400274func (mod *Module) Rlib() bool {
275 if mod.compiler != nil {
276 if library, ok := mod.compiler.(libraryInterface); ok {
277 return library.rlib()
278 }
279 }
280 return false
281}
282
283func (mod *Module) Binary() bool {
Ivan Lozano21fa0a52021-11-01 09:19:45 -0400284 if binary, ok := mod.compiler.(binaryInterface); ok {
285 return binary.binary()
Ivan Lozanod7586b62021-04-01 09:49:36 -0400286 }
287 return false
288}
289
Justin Yun5e035862021-06-29 20:50:37 +0900290func (mod *Module) StaticExecutable() bool {
291 if !mod.Binary() {
292 return false
293 }
Ivan Lozano21fa0a52021-11-01 09:19:45 -0400294 return mod.StaticallyLinked()
Justin Yun5e035862021-06-29 20:50:37 +0900295}
296
Ivan Lozanod7586b62021-04-01 09:49:36 -0400297func (mod *Module) Object() bool {
298 // Rust has no modules which produce only object files.
299 return false
300}
301
Ivan Lozano52767be2019-10-18 14:49:46 -0700302func (mod *Module) Toc() android.OptionalPath {
303 if mod.compiler != nil {
Ivan Lozano7b0781d2021-11-03 15:30:18 -0400304 if lib, ok := mod.compiler.(libraryInterface); ok {
305 return lib.toc()
Ivan Lozano52767be2019-10-18 14:49:46 -0700306 }
307 }
308 panic(fmt.Errorf("Toc() called on non-library module: %q", mod.BaseModuleName()))
309}
310
Colin Crossc511bc52020-04-07 16:50:32 +0000311func (mod *Module) UseSdk() bool {
312 return false
313}
314
Ivan Lozanod7586b62021-04-01 09:49:36 -0400315func (mod *Module) RelativeInstallPath() string {
316 if mod.compiler != nil {
317 return mod.compiler.relativeInstallPath()
318 }
319 return ""
320}
321
Ivan Lozano52767be2019-10-18 14:49:46 -0700322func (mod *Module) UseVndk() bool {
Ivan Lozano6a884432020-12-02 09:15:16 -0500323 return mod.Properties.VndkVersion != ""
Ivan Lozano52767be2019-10-18 14:49:46 -0700324}
325
Jiyong Park7d55b612021-06-11 17:22:09 +0900326func (mod *Module) Bootstrap() bool {
Ivan Lozanoa2268632021-07-22 10:52:06 -0400327 return Bool(mod.Properties.Bootstrap)
Jiyong Park7d55b612021-06-11 17:22:09 +0900328}
329
Ivan Lozano52767be2019-10-18 14:49:46 -0700330func (mod *Module) MustUseVendorVariant() bool {
Ivan Lozanoc08897c2021-04-02 12:41:32 -0400331 return true
332}
333
334func (mod *Module) SubName() string {
335 return mod.Properties.SubName
Ivan Lozano52767be2019-10-18 14:49:46 -0700336}
337
338func (mod *Module) IsVndk() bool {
Ivan Lozano6a884432020-12-02 09:15:16 -0500339 // TODO(b/165791368)
Ivan Lozano52767be2019-10-18 14:49:46 -0700340 return false
341}
342
Ivan Lozanof9e21722020-12-02 09:00:51 -0500343func (mod *Module) IsVndkExt() bool {
344 return false
345}
346
Ivan Lozanod7586b62021-04-01 09:49:36 -0400347func (mod *Module) IsVndkSp() bool {
348 return false
349}
350
Ivan Lozanof1868af2022-04-12 13:08:36 -0400351func (mod *Module) IsVndkPrebuiltLibrary() bool {
352 // Rust modules do not provide VNDK prebuilts
353 return false
354}
355
356func (mod *Module) IsVendorPublicLibrary() bool {
357 return mod.VendorProperties.IsVendorPublicLibrary
358}
359
360func (mod *Module) SdkAndPlatformVariantVisibleToMake() bool {
361 // Rust modules to not provide Sdk variants
362 return false
363}
364
Colin Cross127bb8b2020-12-16 16:46:01 -0800365func (c *Module) IsVndkPrivate() bool {
366 return false
367}
368
369func (c *Module) IsLlndk() bool {
370 return false
371}
372
373func (c *Module) IsLlndkPublic() bool {
Ivan Lozanof9e21722020-12-02 09:00:51 -0500374 return false
375}
376
Ivan Lozano3a7d0002021-03-30 12:19:36 -0400377func (mod *Module) KernelHeadersDecorator() bool {
378 return false
379}
380
Colin Cross1f3f1302021-04-26 18:37:44 -0700381func (m *Module) NeedsLlndkVariants() bool {
Ivan Lozano3a7d0002021-03-30 12:19:36 -0400382 return false
383}
384
Colin Cross5271fea2021-04-27 13:06:04 -0700385func (m *Module) NeedsVendorPublicLibraryVariants() bool {
386 return false
387}
388
Ivan Lozanod7586b62021-04-01 09:49:36 -0400389func (mod *Module) HasLlndkStubs() bool {
390 return false
391}
392
393func (mod *Module) StubsVersion() string {
394 panic(fmt.Errorf("StubsVersion called on non-versioned module: %q", mod.BaseModuleName()))
395}
396
Ivan Lozano52767be2019-10-18 14:49:46 -0700397func (mod *Module) SdkVersion() string {
398 return ""
399}
400
Colin Crossc511bc52020-04-07 16:50:32 +0000401func (mod *Module) AlwaysSdk() bool {
402 return false
403}
404
Jiyong Park2286afd2020-06-16 21:58:53 +0900405func (mod *Module) IsSdkVariant() bool {
406 return false
407}
408
Colin Cross1348ce32020-10-01 13:37:16 -0700409func (mod *Module) SplitPerApiLevel() bool {
410 return false
411}
412
Sasha Smundaka76acba2022-04-18 20:12:56 -0700413func (mod *Module) XrefRustFiles() android.Paths {
414 return mod.kytheFiles
415}
416
Ivan Lozanoffee3342019-08-27 12:03:00 -0700417type Deps struct {
Ivan Lozano63bb7682021-03-23 15:53:44 -0400418 Dylibs []string
419 Rlibs []string
420 Rustlibs []string
421 Stdlibs []string
422 ProcMacros []string
423 SharedLibs []string
424 StaticLibs []string
425 WholeStaticLibs []string
426 HeaderLibs []string
Ivan Lozanoffee3342019-08-27 12:03:00 -0700427
Ivan Lozano4e5f07d2021-11-04 14:09:38 -0400428 // Used for data dependencies adjacent to tests
429 DataLibs []string
430 DataBins []string
431
Colin Crossfe605e12022-01-23 20:46:16 -0800432 CrtBegin, CrtEnd []string
Ivan Lozanoffee3342019-08-27 12:03:00 -0700433}
434
435type PathDeps struct {
Peter Collingbournee7c71c32023-03-31 20:21:19 -0700436 DyLibs RustLibraries
437 RLibs RustLibraries
438 LibDeps android.Paths
439 WholeStaticLibs android.Paths
440 ProcMacros RustLibraries
441 AfdoProfiles android.Paths
Ivan Lozano3dfa12d2021-02-04 11:29:41 -0500442
443 // depFlags and depLinkFlags are rustc and linker (clang) flags.
444 depFlags []string
445 depLinkFlags []string
446
447 // linkDirs are link paths passed via -L to rustc. linkObjects are objects passed directly to the linker.
448 // Both of these are exported and propagate to dependencies.
449 linkDirs []string
Peter Collingbournee7c71c32023-03-31 20:21:19 -0700450 linkObjects android.Paths
Ivan Lozanof1c84332019-09-20 11:00:37 -0700451
Ivan Lozano45901ed2020-07-24 16:05:01 -0400452 // Used by bindgen modules which call clang
453 depClangFlags []string
454 depIncludePaths android.Paths
Ivan Lozanoddd0bdb2020-08-28 17:00:26 -0400455 depGeneratedHeaders android.Paths
Ivan Lozano45901ed2020-07-24 16:05:01 -0400456 depSystemIncludePaths android.Paths
457
Colin Crossfe605e12022-01-23 20:46:16 -0800458 CrtBegin android.Paths
459 CrtEnd android.Paths
Chih-Hung Hsiehbbd25ae2020-05-15 17:36:30 -0700460
461 // Paths to generated source files
Ivan Lozano9d74a522020-12-01 09:25:22 -0500462 SrcDeps android.Paths
463 srcProviderFiles android.Paths
Ivan Lozanoffee3342019-08-27 12:03:00 -0700464}
465
466type RustLibraries []RustLibrary
467
468type RustLibrary struct {
469 Path android.Path
470 CrateName string
471}
472
473type compiler interface {
Thiébaud Weksteenee6a89b2021-02-25 16:30:57 +0100474 initialize(ctx ModuleContext)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700475 compilerFlags(ctx ModuleContext, flags Flags) Flags
Ivan Lozano67eada32021-09-23 11:50:33 -0400476 cfgFlags(ctx ModuleContext, flags Flags) Flags
477 featureFlags(ctx ModuleContext, flags Flags) Flags
Ivan Lozanoffee3342019-08-27 12:03:00 -0700478 compilerProps() []interface{}
Sasha Smundaka76acba2022-04-18 20:12:56 -0700479 compile(ctx ModuleContext, flags Flags, deps PathDeps) buildOutput
Ivan Lozanoffee3342019-08-27 12:03:00 -0700480 compilerDeps(ctx DepsContext, deps Deps) Deps
481 crateName() string
Dan Albert06feee92021-03-19 15:06:02 -0700482 rustdoc(ctx ModuleContext, flags Flags, deps PathDeps) android.OptionalPath
Ivan Lozanoffee3342019-08-27 12:03:00 -0700483
Thiébaud Weksteenee6a89b2021-02-25 16:30:57 +0100484 // Output directory in which source-generated code from dependencies is
485 // copied. This is equivalent to Cargo's OUT_DIR variable.
486 CargoOutDir() android.OptionalPath
Dan Albert06feee92021-03-19 15:06:02 -0700487
Ivan Lozanoa9a1fc02021-08-11 15:13:43 -0400488 // CargoPkgVersion returns the value of the Cargo_pkg_version property.
489 CargoPkgVersion() string
490
491 // CargoEnvCompat returns whether Cargo environment variables should be used.
492 CargoEnvCompat() bool
493
Chih-Hung Hsieh9a4a7ba2019-12-12 19:36:05 -0800494 inData() bool
Thiébaud Weksteenfabaff62020-08-27 13:48:36 +0200495 install(ctx ModuleContext)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700496 relativeInstallPath() string
Ivan Lozanod7586b62021-04-01 09:49:36 -0400497 everInstallable() bool
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400498
499 nativeCoverage() bool
Ivan Lozano26ecd6c2020-07-31 13:40:31 -0400500
501 Disabled() bool
502 SetDisabled()
Ivan Lozano042504f2020-08-18 14:31:23 -0400503
Ivan Lozanodd055472020-09-28 13:22:45 -0400504 stdLinkage(ctx *depsContext) RustLinkage
Ivan Lozano9ef9cb82023-02-14 10:56:14 -0500505 noStdlibs() bool
Jiyong Parke54f07e2021-04-07 15:08:04 +0900506
Ivan Lozano8d10fc32021-11-05 16:36:47 -0400507 unstrippedOutputFilePath() android.Path
Jiyong Parke54f07e2021-04-07 15:08:04 +0900508 strippedOutputFilePath() android.OptionalPath
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400509}
510
Matthew Maurerbb3add12020-06-25 09:34:12 -0700511type exportedFlagsProducer interface {
Matthew Maurerbb3add12020-06-25 09:34:12 -0700512 exportLinkDirs(...string)
Peter Collingbournee7c71c32023-03-31 20:21:19 -0700513 exportLinkObjects(...android.Path)
Matthew Maurerbb3add12020-06-25 09:34:12 -0700514}
515
Sasha Smundaka76acba2022-04-18 20:12:56 -0700516type xref interface {
517 XrefRustFiles() android.Paths
518}
519
Matthew Maurerbb3add12020-06-25 09:34:12 -0700520type flagExporter struct {
Ivan Lozano2093af22020-08-25 12:48:19 -0400521 linkDirs []string
Peter Collingbournee7c71c32023-03-31 20:21:19 -0700522 linkObjects android.Paths
523 libDeps android.Paths
Matthew Maurerbb3add12020-06-25 09:34:12 -0700524}
525
Matthew Maurerbb3add12020-06-25 09:34:12 -0700526func (flagExporter *flagExporter) exportLinkDirs(dirs ...string) {
527 flagExporter.linkDirs = android.FirstUniqueStrings(append(flagExporter.linkDirs, dirs...))
528}
529
Peter Collingbournee7c71c32023-03-31 20:21:19 -0700530func (flagExporter *flagExporter) exportLinkObjects(flags ...android.Path) {
531 flagExporter.linkObjects = android.FirstUniquePaths(append(flagExporter.linkObjects, flags...))
532}
533
534func (flagExporter *flagExporter) exportLibDeps(paths ...android.Path) {
535 flagExporter.libDeps = android.FirstUniquePaths(append(flagExporter.libDeps, paths...))
Ivan Lozano2093af22020-08-25 12:48:19 -0400536}
537
Colin Cross0de8a1e2020-09-18 14:15:30 -0700538func (flagExporter *flagExporter) setProvider(ctx ModuleContext) {
539 ctx.SetProvider(FlagExporterInfoProvider, FlagExporterInfo{
Colin Cross0de8a1e2020-09-18 14:15:30 -0700540 LinkDirs: flagExporter.linkDirs,
541 LinkObjects: flagExporter.linkObjects,
Peter Collingbournee7c71c32023-03-31 20:21:19 -0700542 LibDeps: flagExporter.libDeps,
Colin Cross0de8a1e2020-09-18 14:15:30 -0700543 })
544}
545
Matthew Maurerbb3add12020-06-25 09:34:12 -0700546var _ exportedFlagsProducer = (*flagExporter)(nil)
547
548func NewFlagExporter() *flagExporter {
Colin Cross0de8a1e2020-09-18 14:15:30 -0700549 return &flagExporter{}
Matthew Maurerbb3add12020-06-25 09:34:12 -0700550}
551
Colin Cross0de8a1e2020-09-18 14:15:30 -0700552type FlagExporterInfo struct {
553 Flags []string
554 LinkDirs []string // TODO: this should be android.Paths
Peter Collingbournee7c71c32023-03-31 20:21:19 -0700555 LinkObjects android.Paths
556 LibDeps android.Paths
Colin Cross0de8a1e2020-09-18 14:15:30 -0700557}
558
559var FlagExporterInfoProvider = blueprint.NewProvider(FlagExporterInfo{})
560
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400561func (mod *Module) isCoverageVariant() bool {
562 return mod.coverage.Properties.IsCoverageVariant
563}
564
565var _ cc.Coverage = (*Module)(nil)
566
567func (mod *Module) IsNativeCoverageNeeded(ctx android.BaseModuleContext) bool {
568 return mod.coverage != nil && mod.coverage.Properties.NeedCoverageVariant
569}
570
Ivan Lozanod7586b62021-04-01 09:49:36 -0400571func (mod *Module) VndkVersion() string {
572 return mod.Properties.VndkVersion
573}
574
575func (mod *Module) PreventInstall() bool {
576 return mod.Properties.PreventInstall
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400577}
578
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400579func (mod *Module) MarkAsCoverageVariant(coverage bool) {
580 mod.coverage.Properties.IsCoverageVariant = coverage
581}
582
583func (mod *Module) EnableCoverageIfNeeded() {
584 mod.coverage.Properties.CoverageEnabled = mod.coverage.Properties.NeedCoverageBuild
Ivan Lozanoffee3342019-08-27 12:03:00 -0700585}
586
587func defaultsFactory() android.Module {
588 return DefaultsFactory()
589}
590
591type Defaults struct {
592 android.ModuleBase
593 android.DefaultsModuleBase
594}
595
596func DefaultsFactory(props ...interface{}) android.Module {
597 module := &Defaults{}
598
599 module.AddProperties(props...)
600 module.AddProperties(
601 &BaseProperties{},
Yi Kong46c6e592022-01-20 22:55:00 +0800602 &cc.AfdoProperties{},
Ivan Lozano6a884432020-12-02 09:15:16 -0500603 &cc.VendorProperties{},
Jakub Kotur1d640d02021-01-06 12:40:43 +0100604 &BenchmarkProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -0400605 &BindgenProperties{},
Ivan Lozanoffee3342019-08-27 12:03:00 -0700606 &BaseCompilerProperties{},
607 &BinaryCompilerProperties{},
608 &LibraryCompilerProperties{},
609 &ProcMacroCompilerProperties{},
610 &PrebuiltProperties{},
Ivan Lozano4fef93c2020-07-08 08:39:44 -0400611 &SourceProviderProperties{},
Chih-Hung Hsieh41805be2019-10-31 20:56:47 -0700612 &TestProperties{},
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400613 &cc.CoverageProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -0400614 &cc.RustBindgenClangProperties{},
Thiébaud Weksteen92f703b2020-06-22 13:28:02 +0200615 &ClippyProperties{},
Ivan Lozano6cd99e62020-02-11 08:24:25 -0500616 &SanitizeProperties{},
Ivan Lozanoffee3342019-08-27 12:03:00 -0700617 )
618
619 android.InitDefaultsModule(module)
620 return module
621}
622
623func (mod *Module) CrateName() string {
Ivan Lozanoad8b18b2019-10-31 19:38:29 -0700624 return mod.compiler.crateName()
Ivan Lozanoffee3342019-08-27 12:03:00 -0700625}
626
Ivan Lozano183a3212019-10-18 14:18:45 -0700627func (mod *Module) CcLibrary() bool {
628 if mod.compiler != nil {
Ivan Lozano45e0e5b2021-11-13 07:42:36 -0500629 if _, ok := mod.compiler.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700630 return true
631 }
632 }
633 return false
634}
635
636func (mod *Module) CcLibraryInterface() bool {
637 if mod.compiler != nil {
Ivan Lozano89435d12020-07-31 11:01:18 -0400638 // use build{Static,Shared}() instead of {static,shared}() here because this might be called before
639 // VariantIs{Static,Shared} is set.
640 if lib, ok := mod.compiler.(libraryInterface); ok && (lib.buildShared() || lib.buildStatic()) {
Ivan Lozano183a3212019-10-18 14:18:45 -0700641 return true
642 }
643 }
644 return false
645}
646
Ivan Lozano61c02cc2023-06-09 14:06:44 -0400647func (mod *Module) RustLibraryInterface() bool {
648 if mod.compiler != nil {
649 if _, ok := mod.compiler.(libraryInterface); ok {
650 return true
651 }
652 }
653 return false
654}
655
Ivan Lozano0f9963e2023-02-06 13:31:02 -0500656func (mod *Module) IsFuzzModule() bool {
657 if _, ok := mod.compiler.(*fuzzDecorator); ok {
658 return true
659 }
660 return false
661}
662
663func (mod *Module) FuzzModuleStruct() fuzz.FuzzModule {
664 return mod.FuzzModule
665}
666
667func (mod *Module) FuzzPackagedModule() fuzz.FuzzPackagedModule {
668 if fuzzer, ok := mod.compiler.(*fuzzDecorator); ok {
669 return fuzzer.fuzzPackagedModule
670 }
671 panic(fmt.Errorf("FuzzPackagedModule called on non-fuzz module: %q", mod.BaseModuleName()))
672}
673
Hamzeh Zawawy38917492023-04-05 22:08:46 +0000674func (mod *Module) FuzzSharedLibraries() android.RuleBuilderInstalls {
Ivan Lozano0f9963e2023-02-06 13:31:02 -0500675 if fuzzer, ok := mod.compiler.(*fuzzDecorator); ok {
676 return fuzzer.sharedLibraries
677 }
678 panic(fmt.Errorf("FuzzSharedLibraries called on non-fuzz module: %q", mod.BaseModuleName()))
679}
680
Ivan Lozano39b0bf02021-10-14 12:22:09 -0400681func (mod *Module) UnstrippedOutputFile() android.Path {
Ivan Lozano8d10fc32021-11-05 16:36:47 -0400682 if mod.compiler != nil {
683 return mod.compiler.unstrippedOutputFilePath()
Ivan Lozano39b0bf02021-10-14 12:22:09 -0400684 }
685 return nil
686}
687
Ivan Lozanoe0833b12019-11-06 19:15:49 -0800688func (mod *Module) IncludeDirs() android.Paths {
Ivan Lozano183a3212019-10-18 14:18:45 -0700689 if mod.compiler != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700690 if library, ok := mod.compiler.(*libraryDecorator); ok {
Ivan Lozanoe0833b12019-11-06 19:15:49 -0800691 return library.includeDirs
Ivan Lozano183a3212019-10-18 14:18:45 -0700692 }
693 }
694 panic(fmt.Errorf("IncludeDirs called on non-library module: %q", mod.BaseModuleName()))
695}
696
697func (mod *Module) SetStatic() {
698 if mod.compiler != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700699 if library, ok := mod.compiler.(libraryInterface); ok {
700 library.setStatic()
Ivan Lozano183a3212019-10-18 14:18:45 -0700701 return
702 }
703 }
704 panic(fmt.Errorf("SetStatic called on non-library module: %q", mod.BaseModuleName()))
705}
706
707func (mod *Module) SetShared() {
708 if mod.compiler != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700709 if library, ok := mod.compiler.(libraryInterface); ok {
710 library.setShared()
Ivan Lozano183a3212019-10-18 14:18:45 -0700711 return
712 }
713 }
714 panic(fmt.Errorf("SetShared called on non-library module: %q", mod.BaseModuleName()))
715}
716
Ivan Lozano183a3212019-10-18 14:18:45 -0700717func (mod *Module) BuildStaticVariant() bool {
718 if mod.compiler != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700719 if library, ok := mod.compiler.(libraryInterface); ok {
720 return library.buildStatic()
Ivan Lozano183a3212019-10-18 14:18:45 -0700721 }
722 }
723 panic(fmt.Errorf("BuildStaticVariant called on non-library module: %q", mod.BaseModuleName()))
724}
725
726func (mod *Module) BuildSharedVariant() bool {
727 if mod.compiler != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700728 if library, ok := mod.compiler.(libraryInterface); ok {
729 return library.buildShared()
Ivan Lozano183a3212019-10-18 14:18:45 -0700730 }
731 }
732 panic(fmt.Errorf("BuildSharedVariant called on non-library module: %q", mod.BaseModuleName()))
733}
734
Ivan Lozano183a3212019-10-18 14:18:45 -0700735func (mod *Module) Module() android.Module {
736 return mod
737}
738
Ivan Lozano183a3212019-10-18 14:18:45 -0700739func (mod *Module) OutputFile() android.OptionalPath {
Ivan Lozano8d10fc32021-11-05 16:36:47 -0400740 return mod.outputFile
Ivan Lozano183a3212019-10-18 14:18:45 -0700741}
742
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400743func (mod *Module) CoverageFiles() android.Paths {
744 if mod.compiler != nil {
Joel Galensonfa049382021-01-14 16:03:18 -0800745 return android.Paths{}
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400746 }
747 panic(fmt.Errorf("CoverageFiles called on non-library module: %q", mod.BaseModuleName()))
748}
749
Ivan Lozano7f67c2a2022-06-27 16:00:26 -0400750// Rust does not produce gcno files, and therefore does not produce a coverage archive.
751func (mod *Module) CoverageOutputFile() android.OptionalPath {
752 return android.OptionalPath{}
753}
754
755func (mod *Module) IsNdk(config android.Config) bool {
756 return false
757}
758
759func (mod *Module) IsStubs() bool {
760 return false
761}
762
Jiyong Park459feca2020-12-15 11:02:21 +0900763func (mod *Module) installable(apexInfo android.ApexInfo) bool {
Jiyong Park2811e072021-09-30 17:25:21 +0900764 if !proptools.BoolDefault(mod.Installable(), mod.EverInstallable()) {
Jiyong Parkbf8147a2021-05-17 13:19:33 +0900765 return false
766 }
767
Jiyong Park459feca2020-12-15 11:02:21 +0900768 // The apex variant is not installable because it is included in the APEX and won't appear
769 // in the system partition as a standalone file.
770 if !apexInfo.IsForPlatform() {
771 return false
772 }
773
Jiyong Parke54f07e2021-04-07 15:08:04 +0900774 return mod.OutputFile().Valid() && !mod.Properties.PreventInstall
Jiyong Park459feca2020-12-15 11:02:21 +0900775}
776
Ivan Lozanoe950cda2021-11-09 11:26:04 -0500777func (ctx moduleContext) apexVariationName() string {
778 return ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).ApexVariationName
779}
780
Ivan Lozano183a3212019-10-18 14:18:45 -0700781var _ cc.LinkableInterface = (*Module)(nil)
782
Ivan Lozanoffee3342019-08-27 12:03:00 -0700783func (mod *Module) Init() android.Module {
784 mod.AddProperties(&mod.Properties)
Ivan Lozano6a884432020-12-02 09:15:16 -0500785 mod.AddProperties(&mod.VendorProperties)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700786
Yi Kong46c6e592022-01-20 22:55:00 +0800787 if mod.afdo != nil {
788 mod.AddProperties(mod.afdo.props()...)
789 }
Ivan Lozanoffee3342019-08-27 12:03:00 -0700790 if mod.compiler != nil {
791 mod.AddProperties(mod.compiler.compilerProps()...)
792 }
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400793 if mod.coverage != nil {
794 mod.AddProperties(mod.coverage.props()...)
795 }
Thiébaud Weksteen92f703b2020-06-22 13:28:02 +0200796 if mod.clippy != nil {
797 mod.AddProperties(mod.clippy.props()...)
798 }
Ivan Lozano4fef93c2020-07-08 08:39:44 -0400799 if mod.sourceProvider != nil {
Andrei Homescuc7767922020-08-05 06:36:19 -0700800 mod.AddProperties(mod.sourceProvider.SourceProviderProps()...)
Ivan Lozano4fef93c2020-07-08 08:39:44 -0400801 }
Ivan Lozano6cd99e62020-02-11 08:24:25 -0500802 if mod.sanitize != nil {
803 mod.AddProperties(mod.sanitize.props()...)
804 }
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400805
Ivan Lozanoffee3342019-08-27 12:03:00 -0700806 android.InitAndroidArchModule(mod, mod.hod, mod.multilib)
Jiyong Park99644e92020-11-17 22:21:02 +0900807 android.InitApexModule(mod)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700808
809 android.InitDefaultableModule(mod)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700810 return mod
811}
812
813func newBaseModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
814 return &Module{
815 hod: hod,
816 multilib: multilib,
817 }
818}
819func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
820 module := newBaseModule(hod, multilib)
Yi Kong46c6e592022-01-20 22:55:00 +0800821 module.afdo = &afdo{}
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400822 module.coverage = &coverage{}
Thiébaud Weksteen92f703b2020-06-22 13:28:02 +0200823 module.clippy = &clippy{}
Ivan Lozano6cd99e62020-02-11 08:24:25 -0500824 module.sanitize = &sanitize{}
Ivan Lozanoffee3342019-08-27 12:03:00 -0700825 return module
826}
827
828type ModuleContext interface {
829 android.ModuleContext
830 ModuleContextIntf
831}
832
833type BaseModuleContext interface {
834 android.BaseModuleContext
835 ModuleContextIntf
836}
837
838type DepsContext interface {
839 android.BottomUpMutatorContext
840 ModuleContextIntf
841}
842
843type ModuleContextIntf interface {
Thiébaud Weksteen1f7f70f2020-06-24 11:32:48 +0200844 RustModule() *Module
Ivan Lozanoffee3342019-08-27 12:03:00 -0700845 toolchain() config.Toolchain
Ivan Lozanoffee3342019-08-27 12:03:00 -0700846}
847
848type depsContext struct {
849 android.BottomUpMutatorContext
Ivan Lozanoffee3342019-08-27 12:03:00 -0700850}
851
852type moduleContext struct {
853 android.ModuleContext
Ivan Lozanoffee3342019-08-27 12:03:00 -0700854}
855
Thiébaud Weksteen1f7f70f2020-06-24 11:32:48 +0200856type baseModuleContext struct {
857 android.BaseModuleContext
858}
859
860func (ctx *moduleContext) RustModule() *Module {
861 return ctx.Module().(*Module)
862}
863
864func (ctx *moduleContext) toolchain() config.Toolchain {
865 return ctx.RustModule().toolchain(ctx)
866}
867
868func (ctx *depsContext) RustModule() *Module {
869 return ctx.Module().(*Module)
870}
871
872func (ctx *depsContext) toolchain() config.Toolchain {
873 return ctx.RustModule().toolchain(ctx)
874}
875
876func (ctx *baseModuleContext) RustModule() *Module {
877 return ctx.Module().(*Module)
878}
879
880func (ctx *baseModuleContext) toolchain() config.Toolchain {
881 return ctx.RustModule().toolchain(ctx)
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400882}
883
884func (mod *Module) nativeCoverage() bool {
Matthew Maurera61e31f2021-05-27 11:09:11 -0700885 // Bug: http://b/137883967 - native-bridge modules do not currently work with coverage
886 if mod.Target().NativeBridge == android.NativeBridgeEnabled {
887 return false
888 }
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400889 return mod.compiler != nil && mod.compiler.nativeCoverage()
890}
891
Ivan Lozanod7586b62021-04-01 09:49:36 -0400892func (mod *Module) EverInstallable() bool {
893 return mod.compiler != nil &&
894 // Check to see whether the module is actually ever installable.
895 mod.compiler.everInstallable()
896}
897
898func (mod *Module) Installable() *bool {
899 return mod.Properties.Installable
900}
901
Ivan Lozano872d5792022-03-23 17:31:39 -0400902func (mod *Module) ProcMacro() bool {
903 if pm, ok := mod.compiler.(procMacroInterface); ok {
904 return pm.ProcMacro()
905 }
906 return false
907}
908
Ivan Lozanoffee3342019-08-27 12:03:00 -0700909func (mod *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
910 if mod.cachedToolchain == nil {
911 mod.cachedToolchain = config.FindToolchain(ctx.Os(), ctx.Arch())
912 }
913 return mod.cachedToolchain
914}
915
Thiébaud Weksteen31f1bb82020-08-27 13:37:29 +0200916func (mod *Module) ccToolchain(ctx android.BaseModuleContext) cc_config.Toolchain {
917 return cc_config.FindToolchain(ctx.Os(), ctx.Arch())
918}
919
Ivan Lozanoffee3342019-08-27 12:03:00 -0700920func (d *Defaults) GenerateAndroidBuildActions(ctx android.ModuleContext) {
921}
922
923func (mod *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
924 ctx := &moduleContext{
925 ModuleContext: actx,
Ivan Lozanoffee3342019-08-27 12:03:00 -0700926 }
Ivan Lozanoffee3342019-08-27 12:03:00 -0700927
Jiyong Park99644e92020-11-17 22:21:02 +0900928 apexInfo := actx.Provider(android.ApexInfoProvider).(android.ApexInfo)
929 if !apexInfo.IsForPlatform() {
930 mod.hideApexVariantFromMake = true
931 }
932
Ivan Lozanoffee3342019-08-27 12:03:00 -0700933 toolchain := mod.toolchain(ctx)
Ivan Lozano6a884432020-12-02 09:15:16 -0500934 mod.makeLinkType = cc.GetMakeLinkType(actx, mod)
935
Ivan Lozanof1868af2022-04-12 13:08:36 -0400936 mod.Properties.SubName = cc.GetSubnameProperty(actx, mod)
Matthew Maurera61e31f2021-05-27 11:09:11 -0700937
Ivan Lozanoffee3342019-08-27 12:03:00 -0700938 if !toolchain.Supported() {
939 // This toolchain's unsupported, there's nothing to do for this mod.
940 return
941 }
942
943 deps := mod.depsToPaths(ctx)
944 flags := Flags{
945 Toolchain: toolchain,
946 }
947
Ivan Lozano67eada32021-09-23 11:50:33 -0400948 // Calculate rustc flags
Yi Kong46c6e592022-01-20 22:55:00 +0800949 if mod.afdo != nil {
Vinh Trancde10162023-03-09 22:07:19 -0500950 flags, deps = mod.afdo.flags(actx, flags, deps)
Yi Kong46c6e592022-01-20 22:55:00 +0800951 }
Ivan Lozanoffee3342019-08-27 12:03:00 -0700952 if mod.compiler != nil {
953 flags = mod.compiler.compilerFlags(ctx, flags)
Ivan Lozano67eada32021-09-23 11:50:33 -0400954 flags = mod.compiler.cfgFlags(ctx, flags)
955 flags = mod.compiler.featureFlags(ctx, flags)
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400956 }
957 if mod.coverage != nil {
958 flags, deps = mod.coverage.flags(ctx, flags, deps)
959 }
Thiébaud Weksteen92f703b2020-06-22 13:28:02 +0200960 if mod.clippy != nil {
961 flags, deps = mod.clippy.flags(ctx, flags, deps)
962 }
Ivan Lozano6cd99e62020-02-11 08:24:25 -0500963 if mod.sanitize != nil {
964 flags, deps = mod.sanitize.flags(ctx, flags, deps)
965 }
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400966
Thiébaud Weksteen295c72b2020-09-23 18:10:17 +0200967 // SourceProvider needs to call GenerateSource() before compiler calls
968 // compile() so it can provide the source. A SourceProvider has
969 // multiple variants (e.g. source, rlib, dylib). Only the "source"
970 // variant is responsible for effectively generating the source. The
971 // remaining variants relies on the "source" variant output.
Ivan Lozano26ecd6c2020-07-31 13:40:31 -0400972 if mod.sourceProvider != nil {
Thiébaud Weksteen295c72b2020-09-23 18:10:17 +0200973 if mod.compiler.(libraryInterface).source() {
974 mod.sourceProvider.GenerateSource(ctx, deps)
975 mod.sourceProvider.setSubName(ctx.ModuleSubDir())
976 } else {
977 sourceMod := actx.GetDirectDepWithTag(mod.Name(), sourceDepTag)
978 sourceLib := sourceMod.(*Module).compiler.(*libraryDecorator)
Chih-Hung Hsiehc49649c2020-10-01 21:25:05 -0700979 mod.sourceProvider.setOutputFiles(sourceLib.sourceProvider.Srcs())
Thiébaud Weksteen295c72b2020-09-23 18:10:17 +0200980 }
Ivan Lozano26ecd6c2020-07-31 13:40:31 -0400981 }
982
983 if mod.compiler != nil && !mod.compiler.Disabled() {
Thiébaud Weksteenee6a89b2021-02-25 16:30:57 +0100984 mod.compiler.initialize(ctx)
Sasha Smundaka76acba2022-04-18 20:12:56 -0700985 buildOutput := mod.compiler.compile(ctx, flags, deps)
Ivan Lozano8d10fc32021-11-05 16:36:47 -0400986 if ctx.Failed() {
987 return
988 }
Sasha Smundaka76acba2022-04-18 20:12:56 -0700989 mod.outputFile = android.OptionalPathForPath(buildOutput.outputFile)
990 if buildOutput.kytheFile != nil {
991 mod.kytheFiles = append(mod.kytheFiles, buildOutput.kytheFile)
992 }
Ivan Lozano8d10fc32021-11-05 16:36:47 -0400993 bloaty.MeasureSizeForPaths(ctx, mod.compiler.strippedOutputFilePath(), android.OptionalPathForPath(mod.compiler.unstrippedOutputFilePath()))
Jiyong Park459feca2020-12-15 11:02:21 +0900994
Dan Albert06feee92021-03-19 15:06:02 -0700995 mod.docTimestampFile = mod.compiler.rustdoc(ctx, flags, deps)
Matthew Maurere3803632021-12-10 21:57:21 +0000996 if mod.docTimestampFile.Valid() {
997 ctx.CheckbuildFile(mod.docTimestampFile.Path())
998 }
Dan Albert06feee92021-03-19 15:06:02 -0700999
Ivan Lozano1921e802021-05-20 13:39:16 -04001000 // glob exported headers for snapshot, if BOARD_VNDK_VERSION is current or
1001 // RECOVERY_SNAPSHOT_VERSION is current.
1002 if lib, ok := mod.compiler.(snapshotLibraryInterface); ok {
1003 if cc.ShouldCollectHeadersForSnapshot(ctx, mod, apexInfo) {
1004 lib.collectHeadersForSnapshot(ctx, deps)
1005 }
1006 }
1007
Jiyong Park459feca2020-12-15 11:02:21 +09001008 apexInfo := actx.Provider(android.ApexInfoProvider).(android.ApexInfo)
Ivan Lozano872d5792022-03-23 17:31:39 -04001009 if !proptools.BoolDefault(mod.Installable(), mod.EverInstallable()) && !mod.ProcMacro() {
Jiyong Parkd1e366a2021-10-05 09:12:41 +09001010 // If the module has been specifically configure to not be installed then
1011 // hide from make as otherwise it will break when running inside make as the
1012 // output path to install will not be specified. Not all uninstallable
1013 // modules can be hidden from make as some are needed for resolving make
Ivan Lozano872d5792022-03-23 17:31:39 -04001014 // side dependencies. In particular, proc-macros need to be captured in the
1015 // host snapshot.
Jiyong Parkd1e366a2021-10-05 09:12:41 +09001016 mod.HideFromMake()
1017 } else if !mod.installable(apexInfo) {
1018 mod.SkipInstall()
1019 }
1020
1021 // Still call install though, the installs will be stored as PackageSpecs to allow
1022 // using the outputs in a genrule.
1023 if mod.OutputFile().Valid() {
Thiébaud Weksteenfabaff62020-08-27 13:48:36 +02001024 mod.compiler.install(ctx)
Jiyong Parkd1e366a2021-10-05 09:12:41 +09001025 if ctx.Failed() {
1026 return
1027 }
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001028 }
Chris Wailes74be7642021-07-22 16:20:28 -07001029
1030 ctx.Phony("rust", ctx.RustModule().OutputFile().Path())
Ivan Lozanoffee3342019-08-27 12:03:00 -07001031 }
1032}
1033
1034func (mod *Module) deps(ctx DepsContext) Deps {
1035 deps := Deps{}
1036
1037 if mod.compiler != nil {
1038 deps = mod.compiler.compilerDeps(ctx, deps)
Ivan Lozano26ecd6c2020-07-31 13:40:31 -04001039 }
1040 if mod.sourceProvider != nil {
Andrei Homescuc7767922020-08-05 06:36:19 -07001041 deps = mod.sourceProvider.SourceProviderDeps(ctx, deps)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001042 }
1043
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001044 if mod.coverage != nil {
1045 deps = mod.coverage.deps(ctx, deps)
1046 }
1047
Ivan Lozano6cd99e62020-02-11 08:24:25 -05001048 if mod.sanitize != nil {
1049 deps = mod.sanitize.deps(ctx, deps)
1050 }
1051
Ivan Lozanoffee3342019-08-27 12:03:00 -07001052 deps.Rlibs = android.LastUniqueStrings(deps.Rlibs)
1053 deps.Dylibs = android.LastUniqueStrings(deps.Dylibs)
Matthew Maurer0f003b12020-06-29 14:34:06 -07001054 deps.Rustlibs = android.LastUniqueStrings(deps.Rustlibs)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001055 deps.ProcMacros = android.LastUniqueStrings(deps.ProcMacros)
1056 deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
1057 deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
Andrew Walbran797e4be2022-03-07 15:41:53 +00001058 deps.Stdlibs = android.LastUniqueStrings(deps.Stdlibs)
Ivan Lozano63bb7682021-03-23 15:53:44 -04001059 deps.WholeStaticLibs = android.LastUniqueStrings(deps.WholeStaticLibs)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001060 return deps
1061
1062}
1063
Ivan Lozanoffee3342019-08-27 12:03:00 -07001064type dependencyTag struct {
1065 blueprint.BaseDependencyTag
Jaewoong Jung18aefc12020-12-21 09:11:10 -08001066 name string
1067 library bool
1068 procMacro bool
Colin Cross65cb3142021-12-10 23:05:02 +00001069 dynamic bool
Ivan Lozanoffee3342019-08-27 12:03:00 -07001070}
1071
Jiyong Park65b62242020-11-25 12:44:59 +09001072// InstallDepNeeded returns true for rlibs, dylibs, and proc macros so that they or their transitive
1073// dependencies (especially C/C++ shared libs) are installed as dependencies of a rust binary.
1074func (d dependencyTag) InstallDepNeeded() bool {
Jaewoong Jung18aefc12020-12-21 09:11:10 -08001075 return d.library || d.procMacro
Jiyong Park65b62242020-11-25 12:44:59 +09001076}
1077
1078var _ android.InstallNeededDependencyTag = dependencyTag{}
1079
Colin Cross65cb3142021-12-10 23:05:02 +00001080func (d dependencyTag) LicenseAnnotations() []android.LicenseAnnotation {
1081 if d.library && d.dynamic {
1082 return []android.LicenseAnnotation{android.LicenseAnnotationSharedDependency}
1083 }
1084 return nil
1085}
1086
1087var _ android.LicenseAnnotationsDependencyTag = dependencyTag{}
1088
Ivan Lozanoffee3342019-08-27 12:03:00 -07001089var (
Ivan Lozanoc564d2d2020-08-04 15:43:37 -04001090 customBindgenDepTag = dependencyTag{name: "customBindgenTag"}
1091 rlibDepTag = dependencyTag{name: "rlibTag", library: true}
Colin Cross65cb3142021-12-10 23:05:02 +00001092 dylibDepTag = dependencyTag{name: "dylib", library: true, dynamic: true}
Jaewoong Jung18aefc12020-12-21 09:11:10 -08001093 procMacroDepTag = dependencyTag{name: "procMacro", procMacro: true}
Ivan Lozanoc564d2d2020-08-04 15:43:37 -04001094 testPerSrcDepTag = dependencyTag{name: "rust_unit_tests"}
Thiébaud Weksteen295c72b2020-09-23 18:10:17 +02001095 sourceDepTag = dependencyTag{name: "source"}
Ivan Lozano4e5f07d2021-11-04 14:09:38 -04001096 dataLibDepTag = dependencyTag{name: "data lib"}
1097 dataBinDepTag = dependencyTag{name: "data bin"}
Ivan Lozanoffee3342019-08-27 12:03:00 -07001098)
1099
Jiyong Park99644e92020-11-17 22:21:02 +09001100func IsDylibDepTag(depTag blueprint.DependencyTag) bool {
1101 tag, ok := depTag.(dependencyTag)
1102 return ok && tag == dylibDepTag
1103}
1104
Jiyong Park94e22fd2021-04-08 18:19:15 +09001105func IsRlibDepTag(depTag blueprint.DependencyTag) bool {
1106 tag, ok := depTag.(dependencyTag)
1107 return ok && tag == rlibDepTag
1108}
1109
Matthew Maurer0f003b12020-06-29 14:34:06 -07001110type autoDep struct {
1111 variation string
1112 depTag dependencyTag
1113}
1114
1115var (
Thiébaud Weksteen295c72b2020-09-23 18:10:17 +02001116 rlibVariation = "rlib"
1117 dylibVariation = "dylib"
1118 rlibAutoDep = autoDep{variation: rlibVariation, depTag: rlibDepTag}
1119 dylibAutoDep = autoDep{variation: dylibVariation, depTag: dylibDepTag}
Matthew Maurer0f003b12020-06-29 14:34:06 -07001120)
1121
1122type autoDeppable interface {
Liz Kammer356f7d42021-01-26 09:18:53 -05001123 autoDep(ctx android.BottomUpMutatorContext) autoDep
Matthew Maurer0f003b12020-06-29 14:34:06 -07001124}
1125
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001126func (mod *Module) begin(ctx BaseModuleContext) {
1127 if mod.coverage != nil {
1128 mod.coverage.begin(ctx)
1129 }
Ivan Lozano6cd99e62020-02-11 08:24:25 -05001130 if mod.sanitize != nil {
1131 mod.sanitize.begin(ctx)
1132 }
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001133}
1134
Ivan Lozanofba2aa22021-11-11 09:29:07 -05001135func (mod *Module) Prebuilt() *android.Prebuilt {
Ivan Lozano872d5792022-03-23 17:31:39 -04001136 if p, ok := mod.compiler.(rustPrebuilt); ok {
Ivan Lozanofba2aa22021-11-11 09:29:07 -05001137 return p.prebuilt()
1138 }
1139 return nil
1140}
1141
Justin Yun24b246a2023-03-16 10:36:16 +09001142func rustMakeLibName(ctx android.ModuleContext, c cc.LinkableInterface, dep cc.LinkableInterface, depName string) string {
1143 if rustDep, ok := dep.(*Module); ok {
1144 // Use base module name for snapshots when exporting to Makefile.
1145 if snapshotPrebuilt, ok := rustDep.compiler.(cc.SnapshotInterface); ok {
1146 baseName := rustDep.BaseModuleName()
1147 return baseName + snapshotPrebuilt.SnapshotAndroidMkSuffix() + rustDep.AndroidMkSuffix()
1148 }
1149 }
1150 return cc.MakeLibName(ctx, c, dep, depName)
1151}
1152
Ivan Lozanoffee3342019-08-27 12:03:00 -07001153func (mod *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
1154 var depPaths PathDeps
1155
1156 directRlibDeps := []*Module{}
1157 directDylibDeps := []*Module{}
1158 directProcMacroDeps := []*Module{}
Jiyong Park7d55b612021-06-11 17:22:09 +09001159 directSharedLibDeps := []cc.SharedLibraryInfo{}
Ivan Lozano52767be2019-10-18 14:49:46 -07001160 directStaticLibDeps := [](cc.LinkableInterface){}
Ivan Lozano07cbaf42020-07-22 16:09:13 -04001161 directSrcProvidersDeps := []*Module{}
1162 directSrcDeps := [](android.SourceFileProducer){}
Ivan Lozanoffee3342019-08-27 12:03:00 -07001163
Ivan Lozanoe950cda2021-11-09 11:26:04 -05001164 // For the dependency from platform to apex, use the latest stubs
1165 mod.apexSdkVersion = android.FutureApiLevel
1166 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
1167 if !apexInfo.IsForPlatform() {
1168 mod.apexSdkVersion = apexInfo.MinSdkVersion
1169 }
1170
1171 if android.InList("hwaddress", ctx.Config().SanitizeDevice()) {
1172 // In hwasan build, we override apexSdkVersion to the FutureApiLevel(10000)
1173 // so that even Q(29/Android10) apexes could use the dynamic unwinder by linking the newer stubs(e.g libc(R+)).
1174 // (b/144430859)
1175 mod.apexSdkVersion = android.FutureApiLevel
1176 }
1177
Spandan Das604f3762023-03-16 22:51:40 +00001178 skipModuleList := map[string]bool{}
1179
1180 var apiImportInfo multitree.ApiImportInfo
1181 hasApiImportInfo := false
1182
1183 ctx.VisitDirectDeps(func(dep android.Module) {
1184 if dep.Name() == "api_imports" {
1185 apiImportInfo = ctx.OtherModuleProvider(dep, multitree.ApiImportsProvider).(multitree.ApiImportInfo)
1186 hasApiImportInfo = true
1187 }
1188 })
1189
1190 if hasApiImportInfo {
1191 targetStubModuleList := map[string]string{}
1192 targetOrigModuleList := map[string]string{}
1193
1194 // Search for dependency which both original module and API imported library with APEX stub exists
1195 ctx.VisitDirectDeps(func(dep android.Module) {
1196 depName := ctx.OtherModuleName(dep)
1197 if apiLibrary, ok := apiImportInfo.ApexSharedLibs[depName]; ok {
1198 targetStubModuleList[apiLibrary] = depName
1199 }
1200 })
1201 ctx.VisitDirectDeps(func(dep android.Module) {
1202 depName := ctx.OtherModuleName(dep)
1203 if origLibrary, ok := targetStubModuleList[depName]; ok {
1204 targetOrigModuleList[origLibrary] = depName
1205 }
1206 })
1207
1208 // Decide which library should be used between original and API imported library
1209 ctx.VisitDirectDeps(func(dep android.Module) {
1210 depName := ctx.OtherModuleName(dep)
1211 if apiLibrary, ok := targetOrigModuleList[depName]; ok {
1212 if cc.ShouldUseStubForApex(ctx, dep) {
1213 skipModuleList[depName] = true
1214 } else {
1215 skipModuleList[apiLibrary] = true
1216 }
1217 }
1218 })
1219 }
1220
Cole Faustb6e6f992023-08-17 17:42:26 -07001221 var transitiveAndroidMkSharedLibs []*android.DepSet[string]
1222 var directAndroidMkSharedLibs []string
1223
Ivan Lozanoffee3342019-08-27 12:03:00 -07001224 ctx.VisitDirectDeps(func(dep android.Module) {
1225 depName := ctx.OtherModuleName(dep)
1226 depTag := ctx.OtherModuleDependencyTag(dep)
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001227
Spandan Das604f3762023-03-16 22:51:40 +00001228 if _, exists := skipModuleList[depName]; exists {
1229 return
1230 }
Ivan Lozano89435d12020-07-31 11:01:18 -04001231 if rustDep, ok := dep.(*Module); ok && !rustDep.CcLibraryInterface() {
Ivan Lozanoffee3342019-08-27 12:03:00 -07001232 //Handle Rust Modules
Justin Yun24b246a2023-03-16 10:36:16 +09001233 makeLibName := rustMakeLibName(ctx, mod, rustDep, depName+rustDep.Properties.RustSubName)
Ivan Lozano70e0a072019-09-13 14:23:15 -07001234
Ivan Lozanoffee3342019-08-27 12:03:00 -07001235 switch depTag {
1236 case dylibDepTag:
1237 dylib, ok := rustDep.compiler.(libraryInterface)
1238 if !ok || !dylib.dylib() {
1239 ctx.ModuleErrorf("mod %q not an dylib library", depName)
1240 return
1241 }
1242 directDylibDeps = append(directDylibDeps, rustDep)
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001243 mod.Properties.AndroidMkDylibs = append(mod.Properties.AndroidMkDylibs, makeLibName)
Ivan Lozanoadd122a2023-07-13 11:01:41 -04001244 mod.Properties.SnapshotDylibs = append(mod.Properties.SnapshotDylibs, cc.BaseLibName(depName))
1245
Ivan Lozanoffee3342019-08-27 12:03:00 -07001246 case rlibDepTag:
Ivan Lozano2b081132020-09-08 12:46:52 -04001247
Ivan Lozanoffee3342019-08-27 12:03:00 -07001248 rlib, ok := rustDep.compiler.(libraryInterface)
1249 if !ok || !rlib.rlib() {
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001250 ctx.ModuleErrorf("mod %q not an rlib library", makeLibName)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001251 return
1252 }
1253 directRlibDeps = append(directRlibDeps, rustDep)
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001254 mod.Properties.AndroidMkRlibs = append(mod.Properties.AndroidMkRlibs, makeLibName)
Ivan Lozanoadd122a2023-07-13 11:01:41 -04001255 mod.Properties.SnapshotRlibs = append(mod.Properties.SnapshotRlibs, cc.BaseLibName(depName))
1256
Ivan Lozanoffee3342019-08-27 12:03:00 -07001257 case procMacroDepTag:
1258 directProcMacroDeps = append(directProcMacroDeps, rustDep)
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001259 mod.Properties.AndroidMkProcMacroLibs = append(mod.Properties.AndroidMkProcMacroLibs, makeLibName)
Paul Duffind5cf92e2021-07-09 17:38:55 +01001260 }
1261
Cole Faustb6e6f992023-08-17 17:42:26 -07001262 transitiveAndroidMkSharedLibs = append(transitiveAndroidMkSharedLibs, rustDep.transitiveAndroidMkSharedLibs)
1263
Paul Duffind5cf92e2021-07-09 17:38:55 +01001264 if android.IsSourceDepTagWithOutputTag(depTag, "") {
Ivan Lozano07cbaf42020-07-22 16:09:13 -04001265 // Since these deps are added in path_properties.go via AddDependencies, we need to ensure the correct
1266 // OS/Arch variant is used.
1267 var helper string
1268 if ctx.Host() {
1269 helper = "missing 'host_supported'?"
1270 } else {
1271 helper = "device module defined?"
1272 }
1273
1274 if dep.Target().Os != ctx.Os() {
1275 ctx.ModuleErrorf("OS mismatch on dependency %q (%s)", dep.Name(), helper)
1276 return
1277 } else if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
1278 ctx.ModuleErrorf("Arch mismatch on dependency %q (%s)", dep.Name(), helper)
1279 return
1280 }
1281 directSrcProvidersDeps = append(directSrcProvidersDeps, rustDep)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001282 }
1283
Ivan Lozano2bbcacf2020-08-07 09:00:50 -04001284 //Append the dependencies exportedDirs, except for proc-macros which target a different arch/OS
Colin Cross0de8a1e2020-09-18 14:15:30 -07001285 if depTag != procMacroDepTag {
1286 exportedInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
1287 depPaths.linkDirs = append(depPaths.linkDirs, exportedInfo.LinkDirs...)
1288 depPaths.depFlags = append(depPaths.depFlags, exportedInfo.Flags...)
1289 depPaths.linkObjects = append(depPaths.linkObjects, exportedInfo.LinkObjects...)
Peter Collingbournee7c71c32023-03-31 20:21:19 -07001290 depPaths.LibDeps = append(depPaths.LibDeps, exportedInfo.LibDeps...)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001291 }
1292
Ivan Lozanoffee3342019-08-27 12:03:00 -07001293 if depTag == dylibDepTag || depTag == rlibDepTag || depTag == procMacroDepTag {
Ivan Lozano8d10fc32021-11-05 16:36:47 -04001294 linkFile := rustDep.UnstrippedOutputFile()
1295 linkDir := linkPathFromFilePath(linkFile)
Matthew Maurerbb3add12020-06-25 09:34:12 -07001296 if lib, ok := mod.compiler.(exportedFlagsProducer); ok {
1297 lib.exportLinkDirs(linkDir)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001298 }
1299 }
1300
Ivan Lozano89435d12020-07-31 11:01:18 -04001301 } else if ccDep, ok := dep.(cc.LinkableInterface); ok {
Ivan Lozano52767be2019-10-18 14:49:46 -07001302 //Handle C dependencies
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001303 makeLibName := cc.MakeLibName(ctx, mod, ccDep, depName)
Ivan Lozano52767be2019-10-18 14:49:46 -07001304 if _, ok := ccDep.(*Module); !ok {
1305 if ccDep.Module().Target().Os != ctx.Os() {
1306 ctx.ModuleErrorf("OS mismatch between %q and %q", ctx.ModuleName(), depName)
1307 return
1308 }
1309 if ccDep.Module().Target().Arch.ArchType != ctx.Arch().ArchType {
1310 ctx.ModuleErrorf("Arch mismatch between %q and %q", ctx.ModuleName(), depName)
1311 return
1312 }
Ivan Lozano70e0a072019-09-13 14:23:15 -07001313 }
Ivan Lozano2093af22020-08-25 12:48:19 -04001314 linkObject := ccDep.OutputFile()
Ivan Lozano2093af22020-08-25 12:48:19 -04001315 if !linkObject.Valid() {
Colin Crossa86ea0e2023-08-01 09:57:22 -07001316 if !ctx.Config().AllowMissingDependencies() {
1317 ctx.ModuleErrorf("Invalid output file when adding dep %q to %q", depName, ctx.ModuleName())
1318 } else {
1319 ctx.AddMissingDependencies([]string{depName})
1320 }
1321 return
Ivan Lozanoffee3342019-08-27 12:03:00 -07001322 }
1323
Colin Crossa86ea0e2023-08-01 09:57:22 -07001324 linkPath := linkPathFromFilePath(linkObject.Path())
1325
Ivan Lozanoffee3342019-08-27 12:03:00 -07001326 exportDep := false
Colin Cross6e511a92020-07-27 21:26:48 -07001327 switch {
1328 case cc.IsStaticDepTag(depTag):
Ivan Lozano63bb7682021-03-23 15:53:44 -04001329 if cc.IsWholeStaticLib(depTag) {
1330 // rustc will bundle static libraries when they're passed with "-lstatic=<lib>". This will fail
1331 // if the library is not prefixed by "lib".
Ivan Lozanofdadcd72021-11-01 09:04:23 -04001332 if mod.Binary() {
1333 // Binaries may sometimes need to link whole static libraries that don't start with 'lib'.
1334 // Since binaries don't need to 'rebundle' these like libraries and only use these for the
1335 // final linkage, pass the args directly to the linker to handle these cases.
1336 depPaths.depLinkFlags = append(depPaths.depLinkFlags, []string{"-Wl,--whole-archive", linkObject.Path().String(), "-Wl,--no-whole-archive"}...)
1337 } else if libName, ok := libNameFromFilePath(linkObject.Path()); ok {
Ivan Lozanofb6f36f2021-02-05 12:27:08 -05001338 depPaths.depFlags = append(depPaths.depFlags, "-lstatic="+libName)
Peter Collingbournee7c71c32023-03-31 20:21:19 -07001339 depPaths.WholeStaticLibs = append(depPaths.WholeStaticLibs, linkObject.Path())
Ivan Lozano63bb7682021-03-23 15:53:44 -04001340 } else {
1341 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 -05001342 }
Ivan Lozano3dfa12d2021-02-04 11:29:41 -05001343 }
1344
1345 // Add this to linkObjects to pass the library directly to the linker as well. This propagates
1346 // to dependencies to avoid having to redeclare static libraries for dependents of the dylib variant.
Peter Collingbournee7c71c32023-03-31 20:21:19 -07001347 depPaths.linkObjects = append(depPaths.linkObjects, linkObject.AsPaths()...)
Ivan Lozano3dfa12d2021-02-04 11:29:41 -05001348 depPaths.linkDirs = append(depPaths.linkDirs, linkPath)
1349
Colin Cross0de8a1e2020-09-18 14:15:30 -07001350 exportedInfo := ctx.OtherModuleProvider(dep, cc.FlagExporterInfoProvider).(cc.FlagExporterInfo)
1351 depPaths.depIncludePaths = append(depPaths.depIncludePaths, exportedInfo.IncludeDirs...)
1352 depPaths.depSystemIncludePaths = append(depPaths.depSystemIncludePaths, exportedInfo.SystemIncludeDirs...)
1353 depPaths.depClangFlags = append(depPaths.depClangFlags, exportedInfo.Flags...)
1354 depPaths.depGeneratedHeaders = append(depPaths.depGeneratedHeaders, exportedInfo.GeneratedHeaders...)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001355 directStaticLibDeps = append(directStaticLibDeps, ccDep)
Justin Yun2b3ed642022-02-16 08:15:07 +09001356
1357 // Record baseLibName for snapshots.
1358 mod.Properties.SnapshotStaticLibs = append(mod.Properties.SnapshotStaticLibs, cc.BaseLibName(depName))
1359
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001360 mod.Properties.AndroidMkStaticLibs = append(mod.Properties.AndroidMkStaticLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07001361 case cc.IsSharedDepTag(depTag):
Jiyong Park7d55b612021-06-11 17:22:09 +09001362 // For the shared lib dependencies, we may link to the stub variant
1363 // of the dependency depending on the context (e.g. if this
1364 // dependency crosses the APEX boundaries).
1365 sharedLibraryInfo, exportedInfo := cc.ChooseStubOrImpl(ctx, dep)
1366
1367 // Re-get linkObject as ChooseStubOrImpl actually tells us which
1368 // object (either from stub or non-stub) to use.
1369 linkObject = android.OptionalPathForPath(sharedLibraryInfo.SharedLibrary)
Colin Crossa86ea0e2023-08-01 09:57:22 -07001370 if !linkObject.Valid() {
1371 if !ctx.Config().AllowMissingDependencies() {
1372 ctx.ModuleErrorf("Invalid output file when adding dep %q to %q", depName, ctx.ModuleName())
1373 } else {
1374 ctx.AddMissingDependencies([]string{depName})
1375 }
1376 return
1377 }
Jiyong Park7d55b612021-06-11 17:22:09 +09001378 linkPath = linkPathFromFilePath(linkObject.Path())
1379
Ivan Lozanoffee3342019-08-27 12:03:00 -07001380 depPaths.linkDirs = append(depPaths.linkDirs, linkPath)
Peter Collingbournee7c71c32023-03-31 20:21:19 -07001381 depPaths.linkObjects = append(depPaths.linkObjects, linkObject.AsPaths()...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07001382 depPaths.depIncludePaths = append(depPaths.depIncludePaths, exportedInfo.IncludeDirs...)
1383 depPaths.depSystemIncludePaths = append(depPaths.depSystemIncludePaths, exportedInfo.SystemIncludeDirs...)
1384 depPaths.depClangFlags = append(depPaths.depClangFlags, exportedInfo.Flags...)
1385 depPaths.depGeneratedHeaders = append(depPaths.depGeneratedHeaders, exportedInfo.GeneratedHeaders...)
Jiyong Park7d55b612021-06-11 17:22:09 +09001386 directSharedLibDeps = append(directSharedLibDeps, sharedLibraryInfo)
Ivan Lozano1921e802021-05-20 13:39:16 -04001387
1388 // Record baseLibName for snapshots.
1389 mod.Properties.SnapshotSharedLibs = append(mod.Properties.SnapshotSharedLibs, cc.BaseLibName(depName))
1390
Cole Faustb6e6f992023-08-17 17:42:26 -07001391 directAndroidMkSharedLibs = append(directAndroidMkSharedLibs, makeLibName)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001392 exportDep = true
Zach Johnson3df4e632020-11-06 11:56:27 -08001393 case cc.IsHeaderDepTag(depTag):
1394 exportedInfo := ctx.OtherModuleProvider(dep, cc.FlagExporterInfoProvider).(cc.FlagExporterInfo)
1395 depPaths.depIncludePaths = append(depPaths.depIncludePaths, exportedInfo.IncludeDirs...)
1396 depPaths.depSystemIncludePaths = append(depPaths.depSystemIncludePaths, exportedInfo.SystemIncludeDirs...)
1397 depPaths.depGeneratedHeaders = append(depPaths.depGeneratedHeaders, exportedInfo.GeneratedHeaders...)
Colin Cross6e511a92020-07-27 21:26:48 -07001398 case depTag == cc.CrtBeginDepTag:
Colin Crossfe605e12022-01-23 20:46:16 -08001399 depPaths.CrtBegin = append(depPaths.CrtBegin, linkObject.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07001400 case depTag == cc.CrtEndDepTag:
Colin Crossfe605e12022-01-23 20:46:16 -08001401 depPaths.CrtEnd = append(depPaths.CrtEnd, linkObject.Path())
Ivan Lozanoffee3342019-08-27 12:03:00 -07001402 }
1403
1404 // Make sure these dependencies are propagated
Matthew Maurerbb3add12020-06-25 09:34:12 -07001405 if lib, ok := mod.compiler.(exportedFlagsProducer); ok && exportDep {
1406 lib.exportLinkDirs(linkPath)
Peter Collingbournee7c71c32023-03-31 20:21:19 -07001407 if linkObject.Valid() {
1408 lib.exportLinkObjects(linkObject.Path())
1409 }
Ivan Lozanoffee3342019-08-27 12:03:00 -07001410 }
Colin Cross018cbeb2022-01-24 17:22:45 -08001411 } else {
1412 switch {
1413 case depTag == cc.CrtBeginDepTag:
1414 depPaths.CrtBegin = append(depPaths.CrtBegin, android.OutputFileForModule(ctx, dep, ""))
1415 case depTag == cc.CrtEndDepTag:
1416 depPaths.CrtEnd = append(depPaths.CrtEnd, android.OutputFileForModule(ctx, dep, ""))
1417 }
Ivan Lozanoffee3342019-08-27 12:03:00 -07001418 }
Ivan Lozano89435d12020-07-31 11:01:18 -04001419
1420 if srcDep, ok := dep.(android.SourceFileProducer); ok {
Paul Duffind5cf92e2021-07-09 17:38:55 +01001421 if android.IsSourceDepTagWithOutputTag(depTag, "") {
Ivan Lozano89435d12020-07-31 11:01:18 -04001422 // These are usually genrules which don't have per-target variants.
1423 directSrcDeps = append(directSrcDeps, srcDep)
1424 }
1425 }
Ivan Lozanoffee3342019-08-27 12:03:00 -07001426 })
1427
Cole Faustb6e6f992023-08-17 17:42:26 -07001428 mod.transitiveAndroidMkSharedLibs = android.NewDepSet[string](android.PREORDER, directAndroidMkSharedLibs, transitiveAndroidMkSharedLibs)
1429
Ivan Lozanoffee3342019-08-27 12:03:00 -07001430 var rlibDepFiles RustLibraries
1431 for _, dep := range directRlibDeps {
Ivan Lozano8d10fc32021-11-05 16:36:47 -04001432 rlibDepFiles = append(rlibDepFiles, RustLibrary{Path: dep.UnstrippedOutputFile(), CrateName: dep.CrateName()})
Ivan Lozanoffee3342019-08-27 12:03:00 -07001433 }
1434 var dylibDepFiles RustLibraries
1435 for _, dep := range directDylibDeps {
Ivan Lozano8d10fc32021-11-05 16:36:47 -04001436 dylibDepFiles = append(dylibDepFiles, RustLibrary{Path: dep.UnstrippedOutputFile(), CrateName: dep.CrateName()})
Ivan Lozanoffee3342019-08-27 12:03:00 -07001437 }
1438 var procMacroDepFiles RustLibraries
1439 for _, dep := range directProcMacroDeps {
Ivan Lozano8d10fc32021-11-05 16:36:47 -04001440 procMacroDepFiles = append(procMacroDepFiles, RustLibrary{Path: dep.UnstrippedOutputFile(), CrateName: dep.CrateName()})
Ivan Lozanoffee3342019-08-27 12:03:00 -07001441 }
1442
Peter Collingbournee7c71c32023-03-31 20:21:19 -07001443 var libDepFiles android.Paths
Ivan Lozanoffee3342019-08-27 12:03:00 -07001444 for _, dep := range directStaticLibDeps {
Peter Collingbournee7c71c32023-03-31 20:21:19 -07001445 libDepFiles = append(libDepFiles, dep.OutputFile().Path())
Ivan Lozanoffee3342019-08-27 12:03:00 -07001446 }
1447
Ivan Lozanoffee3342019-08-27 12:03:00 -07001448 for _, dep := range directSharedLibDeps {
Jiyong Park7d55b612021-06-11 17:22:09 +09001449 if dep.TableOfContents.Valid() {
Peter Collingbournee7c71c32023-03-31 20:21:19 -07001450 libDepFiles = append(libDepFiles, dep.TableOfContents.Path())
Ivan Lozanoec6e9912021-01-21 15:23:29 -05001451 } else {
Peter Collingbournee7c71c32023-03-31 20:21:19 -07001452 libDepFiles = append(libDepFiles, dep.SharedLibrary)
Ivan Lozanoec6e9912021-01-21 15:23:29 -05001453 }
Ivan Lozanoffee3342019-08-27 12:03:00 -07001454 }
1455
Ivan Lozano07cbaf42020-07-22 16:09:13 -04001456 var srcProviderDepFiles android.Paths
1457 for _, dep := range directSrcProvidersDeps {
1458 srcs, _ := dep.OutputFiles("")
1459 srcProviderDepFiles = append(srcProviderDepFiles, srcs...)
1460 }
1461 for _, dep := range directSrcDeps {
1462 srcs := dep.Srcs()
1463 srcProviderDepFiles = append(srcProviderDepFiles, srcs...)
1464 }
1465
Ivan Lozanoffee3342019-08-27 12:03:00 -07001466 depPaths.RLibs = append(depPaths.RLibs, rlibDepFiles...)
1467 depPaths.DyLibs = append(depPaths.DyLibs, dylibDepFiles...)
Peter Collingbournee7c71c32023-03-31 20:21:19 -07001468 depPaths.LibDeps = append(depPaths.LibDeps, libDepFiles...)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001469 depPaths.ProcMacros = append(depPaths.ProcMacros, procMacroDepFiles...)
Ivan Lozano07cbaf42020-07-22 16:09:13 -04001470 depPaths.SrcDeps = append(depPaths.SrcDeps, srcProviderDepFiles...)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001471
1472 // Dedup exported flags from dependencies
1473 depPaths.linkDirs = android.FirstUniqueStrings(depPaths.linkDirs)
Peter Collingbournee7c71c32023-03-31 20:21:19 -07001474 depPaths.linkObjects = android.FirstUniquePaths(depPaths.linkObjects)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001475 depPaths.depFlags = android.FirstUniqueStrings(depPaths.depFlags)
Ivan Lozano45901ed2020-07-24 16:05:01 -04001476 depPaths.depClangFlags = android.FirstUniqueStrings(depPaths.depClangFlags)
1477 depPaths.depIncludePaths = android.FirstUniquePaths(depPaths.depIncludePaths)
1478 depPaths.depSystemIncludePaths = android.FirstUniquePaths(depPaths.depSystemIncludePaths)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001479
1480 return depPaths
1481}
1482
Chih-Hung Hsieh9a4a7ba2019-12-12 19:36:05 -08001483func (mod *Module) InstallInData() bool {
1484 if mod.compiler == nil {
1485 return false
1486 }
1487 return mod.compiler.inData()
1488}
1489
Matthew Maurer9f59e8d2021-08-19 13:10:05 -07001490func (mod *Module) InstallInRamdisk() bool {
1491 return mod.InRamdisk()
1492}
1493
1494func (mod *Module) InstallInVendorRamdisk() bool {
1495 return mod.InVendorRamdisk()
1496}
1497
1498func (mod *Module) InstallInRecovery() bool {
1499 return mod.InRecovery()
1500}
1501
Ivan Lozanoffee3342019-08-27 12:03:00 -07001502func linkPathFromFilePath(filepath android.Path) string {
1503 return strings.Split(filepath.String(), filepath.Base())[0]
1504}
Ivan Lozanod648c432020-02-06 12:05:10 -05001505
Spandan Das604f3762023-03-16 22:51:40 +00001506// usePublicApi returns true if the rust variant should link against NDK (publicapi)
1507func (r *Module) usePublicApi() bool {
1508 return r.Device() && r.UseSdk()
1509}
1510
1511// useVendorApi returns true if the rust variant should link against LLNDK (vendorapi)
1512func (r *Module) useVendorApi() bool {
1513 return r.Device() && (r.InVendor() || r.InProduct())
1514}
1515
Ivan Lozanoffee3342019-08-27 12:03:00 -07001516func (mod *Module) DepsMutator(actx android.BottomUpMutatorContext) {
1517 ctx := &depsContext{
1518 BottomUpMutatorContext: actx,
Ivan Lozanoffee3342019-08-27 12:03:00 -07001519 }
Ivan Lozanoffee3342019-08-27 12:03:00 -07001520
1521 deps := mod.deps(ctx)
Colin Cross3146c5c2020-09-30 15:34:40 -07001522 var commonDepVariations []blueprint.Variation
Ivan Lozano1921e802021-05-20 13:39:16 -04001523 var snapshotInfo *cc.SnapshotInfo
1524
Kiyoung Kim487689e2022-07-26 09:48:22 +09001525 apiImportInfo := cc.GetApiImports(mod, actx)
Spandan Das604f3762023-03-16 22:51:40 +00001526 if mod.usePublicApi() || mod.useVendorApi() {
1527 for idx, lib := range deps.SharedLibs {
1528 deps.SharedLibs[idx] = cc.GetReplaceModuleName(lib, apiImportInfo.SharedLibs)
1529 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09001530 }
1531
Ivan Lozano1921e802021-05-20 13:39:16 -04001532 if ctx.Os() == android.Android {
1533 deps.SharedLibs, _ = cc.RewriteLibs(mod, &snapshotInfo, actx, ctx.Config(), deps.SharedLibs)
1534 }
Ivan Lozanodd055472020-09-28 13:22:45 -04001535
Ivan Lozano2b081132020-09-08 12:46:52 -04001536 stdLinkage := "dylib-std"
Ivan Lozanodd055472020-09-28 13:22:45 -04001537 if mod.compiler.stdLinkage(ctx) == RlibLinkage {
Ivan Lozano2b081132020-09-08 12:46:52 -04001538 stdLinkage = "rlib-std"
1539 }
1540
1541 rlibDepVariations := commonDepVariations
Ivan Lozano1921e802021-05-20 13:39:16 -04001542
Ivan Lozano2b081132020-09-08 12:46:52 -04001543 if lib, ok := mod.compiler.(libraryInterface); !ok || !lib.sysroot() {
1544 rlibDepVariations = append(rlibDepVariations,
1545 blueprint.Variation{Mutator: "rust_stdlinkage", Variation: stdLinkage})
1546 }
1547
Ivan Lozano1921e802021-05-20 13:39:16 -04001548 // rlibs
Ivan Lozano2d407632022-04-07 12:59:11 -04001549 rlibDepVariations = append(rlibDepVariations, blueprint.Variation{Mutator: "rust_libraries", Variation: rlibVariation})
Ivan Lozano3149e6e2021-06-01 15:09:53 -04001550 for _, lib := range deps.Rlibs {
1551 depTag := rlibDepTag
Kiyoung Kim487689e2022-07-26 09:48:22 +09001552 lib = cc.GetReplaceModuleName(lib, cc.GetSnapshot(mod, &snapshotInfo, actx).Rlibs)
Ivan Lozano3149e6e2021-06-01 15:09:53 -04001553
Ivan Lozano2d407632022-04-07 12:59:11 -04001554 actx.AddVariationDependencies(rlibDepVariations, depTag, lib)
Ivan Lozano3149e6e2021-06-01 15:09:53 -04001555 }
Ivan Lozano1921e802021-05-20 13:39:16 -04001556
1557 // dylibs
Ivan Lozanoadd122a2023-07-13 11:01:41 -04001558 dylibDepVariations := append(commonDepVariations, blueprint.Variation{Mutator: "rust_libraries", Variation: dylibVariation})
1559 for _, lib := range deps.Dylibs {
1560 addDylibDependency(actx, lib, mod, &snapshotInfo, dylibDepVariations, dylibDepTag)
1561 }
Ivan Lozano52767be2019-10-18 14:49:46 -07001562
Ivan Lozano1921e802021-05-20 13:39:16 -04001563 // rustlibs
Ivan Lozano042504f2020-08-18 14:31:23 -04001564 if deps.Rustlibs != nil && !mod.compiler.Disabled() {
1565 autoDep := mod.compiler.(autoDeppable).autoDep(ctx)
Ivan Lozano2d407632022-04-07 12:59:11 -04001566 for _, lib := range deps.Rustlibs {
1567 if autoDep.depTag == rlibDepTag {
1568 // Handle the rlib deptag case
Inseob Kimcd2b46a2023-03-31 18:04:12 +09001569 addRlibDependency(actx, lib, mod, &snapshotInfo, rlibDepVariations)
Ivan Lozano2d407632022-04-07 12:59:11 -04001570 } else {
1571 // autoDep.depTag is a dylib depTag. Not all rustlibs may be available as a dylib however.
1572 // Check for the existence of the dylib deptag variant. Select it if available,
1573 // otherwise select the rlib variant.
1574 autoDepVariations := append(commonDepVariations,
1575 blueprint.Variation{Mutator: "rust_libraries", Variation: autoDep.variation})
Ivan Lozanoadd122a2023-07-13 11:01:41 -04001576
1577 replacementLib := cc.GetReplaceModuleName(lib, cc.GetSnapshot(mod, &snapshotInfo, actx).Dylibs)
1578
1579 if actx.OtherModuleDependencyVariantExists(autoDepVariations, replacementLib) {
1580 addDylibDependency(actx, lib, mod, &snapshotInfo, autoDepVariations, autoDep.depTag)
Ivan Lozano2d407632022-04-07 12:59:11 -04001581 } else {
1582 // If there's no dylib dependency available, try to add the rlib dependency instead.
Inseob Kimcd2b46a2023-03-31 18:04:12 +09001583 addRlibDependency(actx, lib, mod, &snapshotInfo, rlibDepVariations)
Ivan Lozano2d407632022-04-07 12:59:11 -04001584 }
Ivan Lozano3149e6e2021-06-01 15:09:53 -04001585 }
Ivan Lozano2b081132020-09-08 12:46:52 -04001586 }
Matthew Maurer0f003b12020-06-29 14:34:06 -07001587 }
Ivan Lozano1921e802021-05-20 13:39:16 -04001588 // stdlibs
Ivan Lozano2b081132020-09-08 12:46:52 -04001589 if deps.Stdlibs != nil {
Ivan Lozanodd055472020-09-28 13:22:45 -04001590 if mod.compiler.stdLinkage(ctx) == RlibLinkage {
Ivan Lozano3149e6e2021-06-01 15:09:53 -04001591 for _, lib := range deps.Stdlibs {
Kiyoung Kim487689e2022-07-26 09:48:22 +09001592 lib = cc.GetReplaceModuleName(lib, cc.GetSnapshot(mod, &snapshotInfo, actx).Rlibs)
Ivan Lozano3149e6e2021-06-01 15:09:53 -04001593 actx.AddVariationDependencies(append(commonDepVariations, []blueprint.Variation{{Mutator: "rust_libraries", Variation: "rlib"}}...),
Ivan Lozanoadd122a2023-07-13 11:01:41 -04001594 rlibDepTag, lib)
Ivan Lozano3149e6e2021-06-01 15:09:53 -04001595 }
Ivan Lozano2b081132020-09-08 12:46:52 -04001596 } else {
Ivan Lozanoadd122a2023-07-13 11:01:41 -04001597 for _, lib := range deps.Stdlibs {
1598 addDylibDependency(actx, lib, mod, &snapshotInfo, dylibDepVariations, dylibDepTag)
1599 }
Ivan Lozano2b081132020-09-08 12:46:52 -04001600 }
1601 }
Ivan Lozano1921e802021-05-20 13:39:16 -04001602
1603 for _, lib := range deps.SharedLibs {
1604 depTag := cc.SharedDepTag()
1605 name, version := cc.StubsLibNameAndVersion(lib)
1606
1607 variations := []blueprint.Variation{
1608 {Mutator: "link", Variation: "shared"},
1609 }
Spandan Das604f3762023-03-16 22:51:40 +00001610 // For core variant, add a dep on the implementation (if it exists) and its .apiimport (if it exists)
1611 // GenerateAndroidBuildActions will pick the correct impl/stub based on the api_domain boundary
1612 if _, ok := apiImportInfo.ApexSharedLibs[name]; !ok || ctx.OtherModuleExists(name) {
1613 cc.AddSharedLibDependenciesWithVersions(ctx, mod, variations, depTag, name, version, false)
1614 }
1615
1616 if apiLibraryName, ok := apiImportInfo.ApexSharedLibs[name]; ok {
1617 cc.AddSharedLibDependenciesWithVersions(ctx, mod, variations, depTag, apiLibraryName, version, false)
1618 }
Ivan Lozano1921e802021-05-20 13:39:16 -04001619 }
1620
1621 for _, lib := range deps.WholeStaticLibs {
1622 depTag := cc.StaticDepTag(true)
Kiyoung Kim487689e2022-07-26 09:48:22 +09001623 lib = cc.GetReplaceModuleName(lib, cc.GetSnapshot(mod, &snapshotInfo, actx).StaticLibs)
Ivan Lozano1921e802021-05-20 13:39:16 -04001624
1625 actx.AddVariationDependencies([]blueprint.Variation{
1626 {Mutator: "link", Variation: "static"},
1627 }, depTag, lib)
1628 }
1629
1630 for _, lib := range deps.StaticLibs {
1631 depTag := cc.StaticDepTag(false)
Kiyoung Kim487689e2022-07-26 09:48:22 +09001632 lib = cc.GetReplaceModuleName(lib, cc.GetSnapshot(mod, &snapshotInfo, actx).StaticLibs)
Ivan Lozano1921e802021-05-20 13:39:16 -04001633
1634 actx.AddVariationDependencies([]blueprint.Variation{
1635 {Mutator: "link", Variation: "static"},
1636 }, depTag, lib)
1637 }
Ivan Lozano5ca5ef62019-09-23 10:10:40 -07001638
Zach Johnson3df4e632020-11-06 11:56:27 -08001639 actx.AddVariationDependencies(nil, cc.HeaderDepTag(), deps.HeaderLibs...)
1640
Colin Cross565cafd2020-09-25 18:47:38 -07001641 crtVariations := cc.GetCrtVariations(ctx, mod)
Colin Crossfe605e12022-01-23 20:46:16 -08001642 for _, crt := range deps.CrtBegin {
Ivan Lozano1921e802021-05-20 13:39:16 -04001643 actx.AddVariationDependencies(crtVariations, cc.CrtBeginDepTag,
Kiyoung Kim487689e2022-07-26 09:48:22 +09001644 cc.GetReplaceModuleName(crt, cc.GetSnapshot(mod, &snapshotInfo, actx).Objects))
Ivan Lozanof1c84332019-09-20 11:00:37 -07001645 }
Colin Crossfe605e12022-01-23 20:46:16 -08001646 for _, crt := range deps.CrtEnd {
Ivan Lozano1921e802021-05-20 13:39:16 -04001647 actx.AddVariationDependencies(crtVariations, cc.CrtEndDepTag,
Kiyoung Kim487689e2022-07-26 09:48:22 +09001648 cc.GetReplaceModuleName(crt, cc.GetSnapshot(mod, &snapshotInfo, actx).Objects))
Ivan Lozanof1c84332019-09-20 11:00:37 -07001649 }
1650
Ivan Lozanoc564d2d2020-08-04 15:43:37 -04001651 if mod.sourceProvider != nil {
1652 if bindgen, ok := mod.sourceProvider.(*bindgenDecorator); ok &&
1653 bindgen.Properties.Custom_bindgen != "" {
1654 actx.AddFarVariationDependencies(ctx.Config().BuildOSTarget.Variations(), customBindgenDepTag,
1655 bindgen.Properties.Custom_bindgen)
1656 }
1657 }
Ivan Lozano1921e802021-05-20 13:39:16 -04001658
Ivan Lozano4e5f07d2021-11-04 14:09:38 -04001659 actx.AddVariationDependencies([]blueprint.Variation{
1660 {Mutator: "link", Variation: "shared"},
1661 }, dataLibDepTag, deps.DataLibs...)
1662
1663 actx.AddVariationDependencies(nil, dataBinDepTag, deps.DataBins...)
1664
Ivan Lozano5ca5ef62019-09-23 10:10:40 -07001665 // proc_macros are compiler plugins, and so we need the host arch variant as a dependendcy.
Colin Cross0f7d2ef2019-10-16 11:03:10 -07001666 actx.AddFarVariationDependencies(ctx.Config().BuildOSTarget.Variations(), procMacroDepTag, deps.ProcMacros...)
Vinh Trancde10162023-03-09 22:07:19 -05001667
1668 mod.afdo.addDep(ctx, actx)
Ivan Lozanoffee3342019-08-27 12:03:00 -07001669}
1670
Ivan Lozano2d407632022-04-07 12:59:11 -04001671// addRlibDependency will add an rlib dependency, rewriting to the snapshot library if available.
Inseob Kimcd2b46a2023-03-31 18:04:12 +09001672func addRlibDependency(actx android.BottomUpMutatorContext, lib string, mod *Module, snapshotInfo **cc.SnapshotInfo, variations []blueprint.Variation) {
1673 lib = cc.GetReplaceModuleName(lib, cc.GetSnapshot(mod, snapshotInfo, actx).Rlibs)
Ivan Lozano2d407632022-04-07 12:59:11 -04001674 actx.AddVariationDependencies(variations, rlibDepTag, lib)
1675}
1676
Ivan Lozanoadd122a2023-07-13 11:01:41 -04001677func addDylibDependency(actx android.BottomUpMutatorContext, lib string, mod *Module, snapshotInfo **cc.SnapshotInfo, variations []blueprint.Variation, depTag dependencyTag) {
1678 lib = cc.GetReplaceModuleName(lib, cc.GetSnapshot(mod, snapshotInfo, actx).Dylibs)
1679 actx.AddVariationDependencies(variations, depTag, lib)
1680}
1681
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001682func BeginMutator(ctx android.BottomUpMutatorContext) {
1683 if mod, ok := ctx.Module().(*Module); ok && mod.Enabled() {
1684 mod.beginMutator(ctx)
1685 }
1686}
1687
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001688func (mod *Module) beginMutator(actx android.BottomUpMutatorContext) {
1689 ctx := &baseModuleContext{
1690 BaseModuleContext: actx,
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001691 }
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001692
1693 mod.begin(ctx)
1694}
1695
Ivan Lozanoffee3342019-08-27 12:03:00 -07001696func (mod *Module) Name() string {
1697 name := mod.ModuleBase.Name()
1698 if p, ok := mod.compiler.(interface {
1699 Name(string) string
1700 }); ok {
1701 name = p.Name(name)
1702 }
1703 return name
1704}
1705
Thiébaud Weksteen9e8451e2020-08-13 12:55:59 +02001706func (mod *Module) disableClippy() {
Ivan Lozano32267c82020-08-04 16:27:16 -04001707 if mod.clippy != nil {
Thiébaud Weksteen9e8451e2020-08-13 12:55:59 +02001708 mod.clippy.Properties.Clippy_lints = proptools.StringPtr("none")
Ivan Lozano32267c82020-08-04 16:27:16 -04001709 }
1710}
1711
Chih-Hung Hsieh5c4e4892020-05-15 17:36:30 -07001712var _ android.HostToolProvider = (*Module)(nil)
Ivan Lozano872d5792022-03-23 17:31:39 -04001713var _ snapshot.RelativeInstallPath = (*Module)(nil)
Chih-Hung Hsieh5c4e4892020-05-15 17:36:30 -07001714
1715func (mod *Module) HostToolPath() android.OptionalPath {
1716 if !mod.Host() {
1717 return android.OptionalPath{}
1718 }
Chih-Hung Hsieha7562702020-08-10 21:50:43 -07001719 if binary, ok := mod.compiler.(*binaryDecorator); ok {
1720 return android.OptionalPathForPath(binary.baseCompiler.path)
Ivan Lozano872d5792022-03-23 17:31:39 -04001721 } else if pm, ok := mod.compiler.(*procMacroDecorator); ok {
1722 // Even though proc-macros aren't strictly "tools", since they target the compiler
1723 // and act as compiler plugins, we treat them similarly.
1724 return android.OptionalPathForPath(pm.baseCompiler.path)
Chih-Hung Hsieh5c4e4892020-05-15 17:36:30 -07001725 }
1726 return android.OptionalPath{}
1727}
1728
Jiyong Park99644e92020-11-17 22:21:02 +09001729var _ android.ApexModule = (*Module)(nil)
1730
Ivan Lozanoa91ba252022-01-11 12:02:06 -05001731func (mod *Module) MinSdkVersion() string {
Ivan Lozano3e9f9e42020-12-04 15:05:43 -05001732 return String(mod.Properties.Min_sdk_version)
1733}
1734
Jiyong Park45bf82e2020-12-15 22:29:02 +09001735// Implements android.ApexModule
Jiyong Park99644e92020-11-17 22:21:02 +09001736func (mod *Module) ShouldSupportSdkVersion(ctx android.BaseModuleContext, sdkVersion android.ApiLevel) error {
Ivan Lozanoa91ba252022-01-11 12:02:06 -05001737 minSdkVersion := mod.MinSdkVersion()
Ivan Lozano3e9f9e42020-12-04 15:05:43 -05001738 if minSdkVersion == "apex_inherit" {
1739 return nil
1740 }
1741 if minSdkVersion == "" {
1742 return fmt.Errorf("min_sdk_version is not specificed")
1743 }
1744
1745 // Not using nativeApiLevelFromUser because the context here is not
1746 // necessarily a native context.
1747 ver, err := android.ApiLevelFromUser(ctx, minSdkVersion)
1748 if err != nil {
1749 return err
1750 }
1751
1752 if ver.GreaterThan(sdkVersion) {
1753 return fmt.Errorf("newer SDK(%v)", ver)
1754 }
Jiyong Park99644e92020-11-17 22:21:02 +09001755 return nil
1756}
1757
Jiyong Park45bf82e2020-12-15 22:29:02 +09001758// Implements android.ApexModule
Jiyong Park99644e92020-11-17 22:21:02 +09001759func (mod *Module) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
1760 depTag := ctx.OtherModuleDependencyTag(dep)
1761
1762 if ccm, ok := dep.(*cc.Module); ok {
1763 if ccm.HasStubsVariants() {
1764 if cc.IsSharedDepTag(depTag) {
1765 // dynamic dep to a stubs lib crosses APEX boundary
1766 return false
1767 }
1768 if cc.IsRuntimeDepTag(depTag) {
1769 // runtime dep to a stubs lib also crosses APEX boundary
1770 return false
1771 }
1772
1773 if cc.IsHeaderDepTag(depTag) {
1774 return false
1775 }
1776 }
1777 if mod.Static() && cc.IsSharedDepTag(depTag) {
1778 // shared_lib dependency from a static lib is considered as crossing
1779 // the APEX boundary because the dependency doesn't actually is
1780 // linked; the dependency is used only during the compilation phase.
1781 return false
1782 }
1783 }
1784
Matthew Maurer581b6d82022-09-29 16:46:25 -07001785 if depTag == procMacroDepTag || depTag == customBindgenDepTag {
Jiyong Park99644e92020-11-17 22:21:02 +09001786 return false
1787 }
1788
1789 return true
1790}
1791
1792// Overrides ApexModule.IsInstallabeToApex()
1793func (mod *Module) IsInstallableToApex() bool {
1794 if mod.compiler != nil {
Ivan Lozano45e0e5b2021-11-13 07:42:36 -05001795 if lib, ok := mod.compiler.(libraryInterface); ok && (lib.shared() || lib.dylib()) {
Jiyong Park99644e92020-11-17 22:21:02 +09001796 return true
1797 }
1798 if _, ok := mod.compiler.(*binaryDecorator); ok {
1799 return true
1800 }
1801 }
1802 return false
1803}
1804
Ivan Lozano3dfa12d2021-02-04 11:29:41 -05001805// If a library file has a "lib" prefix, extract the library name without the prefix.
1806func libNameFromFilePath(filepath android.Path) (string, bool) {
1807 libName := strings.TrimSuffix(filepath.Base(), filepath.Ext())
1808 if strings.HasPrefix(libName, "lib") {
1809 libName = libName[3:]
1810 return libName, true
1811 }
1812 return "", false
1813}
1814
Sasha Smundaka76acba2022-04-18 20:12:56 -07001815func kytheExtractRustFactory() android.Singleton {
1816 return &kytheExtractRustSingleton{}
1817}
1818
1819type kytheExtractRustSingleton struct {
1820}
1821
1822func (k kytheExtractRustSingleton) GenerateBuildActions(ctx android.SingletonContext) {
1823 var xrefTargets android.Paths
1824 ctx.VisitAllModules(func(module android.Module) {
1825 if rustModule, ok := module.(xref); ok {
1826 xrefTargets = append(xrefTargets, rustModule.XrefRustFiles()...)
1827 }
1828 })
1829 if len(xrefTargets) > 0 {
1830 ctx.Phony("xref_rust", xrefTargets...)
1831 }
1832}
1833
Jihoon Kangf78a8902022-09-01 22:47:07 +00001834func (c *Module) Partition() string {
1835 return ""
1836}
1837
Ivan Lozanoffee3342019-08-27 12:03:00 -07001838var Bool = proptools.Bool
1839var BoolDefault = proptools.BoolDefault
1840var String = proptools.String
1841var StringPtr = proptools.StringPtr
Ivan Lozano43845682020-07-09 21:03:28 -04001842
1843var _ android.OutputFileProducer = (*Module)(nil)