blob: 3ba5366d54e27e91de5f18fc2bdf3be773ce06b7 [file] [log] [blame]
Colin Cross5049f022015-03-18 13:28:46 -07001// Copyright 2015 Google Inc. All rights reserved.
Colin Cross3f40fa42015-01-30 17:27:36 -08002//
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 cc
16
17// This file contains the module types for compiling C/C++ for Android, and converts the properties
18// into the flags and filenames necessary to pass to the compiler. The final creation of the rules
19// is handled in builder.go
20
21import (
Colin Cross41955e82019-05-29 14:40:35 -070022 "fmt"
Logan Chien41eabe62019-04-10 13:33:58 +080023 "io"
Dan Albert9e10cd42016-08-03 14:12:14 -070024 "strconv"
Colin Cross3f40fa42015-01-30 17:27:36 -080025 "strings"
26
Colin Cross97ba0732015-03-23 17:50:24 -070027 "github.com/google/blueprint"
Colin Cross06a931b2015-10-28 17:23:31 -070028 "github.com/google/blueprint/proptools"
Colin Cross97ba0732015-03-23 17:50:24 -070029
Colin Cross635c3b02016-05-18 15:37:25 -070030 "android/soong/android"
Colin Crossb98c8b02016-07-29 13:44:28 -070031 "android/soong/cc/config"
Colin Cross5049f022015-03-18 13:28:46 -070032 "android/soong/genrule"
Colin Cross3f40fa42015-01-30 17:27:36 -080033)
34
Colin Cross463a90e2015-06-17 14:20:06 -070035func init() {
Paul Duffin036e7002019-12-19 19:16:28 +000036 RegisterCCBuildComponents(android.InitRegistrationContext)
Colin Cross463a90e2015-06-17 14:20:06 -070037
Paul Duffin036e7002019-12-19 19:16:28 +000038 pctx.Import("android/soong/cc/config")
39}
40
41func RegisterCCBuildComponents(ctx android.RegistrationContext) {
42 ctx.RegisterModuleType("cc_defaults", defaultsFactory)
43
44 ctx.PreDepsMutators(func(ctx android.RegisterMutatorsContext) {
Colin Crossc511bc52020-04-07 16:50:32 +000045 ctx.BottomUp("sdk", sdkMutator).Parallel()
Inseob Kim64c43952019-08-26 16:52:35 +090046 ctx.BottomUp("vndk", VndkMutator).Parallel()
Colin Crosse40b4ea2018-10-02 22:25:58 -070047 ctx.BottomUp("link", LinkageMutator).Parallel()
Roland Levillain9b5fde92019-06-28 15:41:19 +010048 ctx.BottomUp("test_per_src", TestPerSrcMutator).Parallel()
Colin Crossd1f898e2020-08-18 18:35:15 -070049 ctx.BottomUp("version_selector", versionSelectorMutator).Parallel()
50 ctx.BottomUp("version", versionMutator).Parallel()
Colin Crosse40b4ea2018-10-02 22:25:58 -070051 ctx.BottomUp("begin", BeginMutator).Parallel()
Inseob Kimac1e9862019-12-09 18:15:47 +090052 ctx.BottomUp("sysprop_cc", SyspropMutator).Parallel()
Colin Cross1e676be2016-10-12 14:38:15 -070053 })
Colin Cross16b23492016-01-06 14:41:07 -080054
Paul Duffin036e7002019-12-19 19:16:28 +000055 ctx.PostDepsMutators(func(ctx android.RegisterMutatorsContext) {
Ivan Lozano3968d8f2020-12-14 11:27:52 -050056 ctx.TopDown("asan_deps", sanitizerDepsMutator(Asan))
57 ctx.BottomUp("asan", sanitizerMutator(Asan)).Parallel()
Colin Cross16b23492016-01-06 14:41:07 -080058
Tri Vo6eafc362021-04-01 11:29:09 -070059 ctx.TopDown("hwasan_deps", sanitizerDepsMutator(Hwasan))
60 ctx.BottomUp("hwasan", sanitizerMutator(Hwasan)).Parallel()
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -070061
Ivan Lozano3968d8f2020-12-14 11:27:52 -050062 ctx.TopDown("fuzzer_deps", sanitizerDepsMutator(Fuzzer))
63 ctx.BottomUp("fuzzer", sanitizerMutator(Fuzzer)).Parallel()
Mitch Phillipsbfeade62019-05-01 14:42:05 -070064
Jiyong Park1d1119f2019-07-29 21:27:18 +090065 // cfi mutator shouldn't run before sanitizers that return true for
66 // incompatibleWithCfi()
Vishwath Mohanb743e9c2017-11-01 09:20:21 +000067 ctx.TopDown("cfi_deps", sanitizerDepsMutator(cfi))
68 ctx.BottomUp("cfi", sanitizerMutator(cfi)).Parallel()
69
Peter Collingbourne8c7e6e22018-11-19 16:03:58 -080070 ctx.TopDown("scs_deps", sanitizerDepsMutator(scs))
71 ctx.BottomUp("scs", sanitizerMutator(scs)).Parallel()
72
Colin Cross1e676be2016-10-12 14:38:15 -070073 ctx.TopDown("tsan_deps", sanitizerDepsMutator(tsan))
74 ctx.BottomUp("tsan", sanitizerMutator(tsan)).Parallel()
Dan Willemsen581341d2017-02-09 16:16:31 -080075
Colin Cross0b908332019-06-19 23:00:20 -070076 ctx.TopDown("sanitize_runtime_deps", sanitizerRuntimeDepsMutator).Parallel()
Jiyong Park379de2f2018-12-19 02:47:14 +090077 ctx.BottomUp("sanitize_runtime", sanitizerRuntimeMutator).Parallel()
Ivan Lozano30c5db22018-02-21 15:49:20 -080078
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -080079 ctx.BottomUp("coverage", coverageMutator).Parallel()
Stephen Craneba090d12017-05-09 15:44:35 -070080
81 ctx.TopDown("lto_deps", ltoDepsMutator)
82 ctx.BottomUp("lto", ltoMutator).Parallel()
Jooyung Hana70f0672019-01-18 15:20:43 +090083
Jooyung Han479ca172020-10-19 18:51:07 +090084 ctx.BottomUp("check_linktype", checkLinkTypeMutator).Parallel()
Jooyung Hana70f0672019-01-18 15:20:43 +090085 ctx.TopDown("double_loadable", checkDoubleLoadableLibraries).Parallel()
Colin Cross1e676be2016-10-12 14:38:15 -070086 })
Colin Crossb98c8b02016-07-29 13:44:28 -070087
Yo Chiang8aa4e3f2020-11-19 16:30:49 +080088 ctx.FinalDepsMutators(func(ctx android.RegisterMutatorsContext) {
89 // sabi mutator needs to be run after apex mutator finishes.
90 ctx.TopDown("sabi_deps", sabiDepsMutator)
91 })
92
Colin Cross57898582020-10-29 18:25:19 -070093 ctx.RegisterSingletonType("kythe_extract_all", kytheExtractAllFactory)
Colin Cross463a90e2015-06-17 14:20:06 -070094}
95
Chris Parsonsef6e0cf2020-12-01 18:26:21 -050096// Deps is a struct containing module names of dependencies, separated by the kind of dependency.
97// Mutators should use `AddVariationDependencies` or its sibling methods to add actual dependency
98// edges to these modules.
99// This object is constructed in DepsMutator, by calling to various module delegates to set
100// relevant fields. For example, `module.compiler.compilerDeps()` may append type-specific
101// dependencies.
102// This is then consumed by the same DepsMutator, which will call `ctx.AddVariationDependencies()`
103// (or its sibling methods) to set real dependencies on the given modules.
Colin Crossca860ac2016-01-04 14:34:37 -0800104type Deps struct {
105 SharedLibs, LateSharedLibs []string
106 StaticLibs, LateStaticLibs, WholeStaticLibs []string
Colin Cross5950f382016-12-13 12:50:57 -0800107 HeaderLibs []string
Logan Chien43d34c32017-12-20 01:17:32 +0800108 RuntimeLibs []string
Colin Crossc472d572015-03-17 15:06:21 -0700109
Chris Parsons79d66a52020-06-05 17:26:16 -0400110 // Used for data dependencies adjacent to tests
111 DataLibs []string
112
Yo Chiang219968c2020-09-22 18:45:04 +0800113 // Used by DepsMutator to pass system_shared_libs information to check_elf_file.py.
114 SystemSharedLibs []string
115
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500116 // If true, statically link the unwinder into native libraries/binaries.
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800117 StaticUnwinderIfLegacy bool
118
Colin Cross5950f382016-12-13 12:50:57 -0800119 ReexportSharedLibHeaders, ReexportStaticLibHeaders, ReexportHeaderLibHeaders []string
Dan Willemsen490a8dc2016-06-06 18:22:19 -0700120
Colin Cross81413472016-04-11 14:37:39 -0700121 ObjFiles []string
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700122
Dan Willemsenb40aab62016-04-20 14:21:14 -0700123 GeneratedSources []string
124 GeneratedHeaders []string
Inseob Kimd110f872019-12-06 13:15:38 +0900125 GeneratedDeps []string
Dan Willemsenb40aab62016-04-20 14:21:14 -0700126
Dan Willemsenb3454ab2016-09-28 17:34:58 -0700127 ReexportGeneratedHeaders []string
128
Colin Cross97ba0732015-03-23 17:50:24 -0700129 CrtBegin, CrtEnd string
Dan Willemsena0790e32018-10-12 00:24:23 -0700130
131 // Used for host bionic
132 LinkerFlagsFile string
133 DynamicLinker string
Jiyong Parke3867542020-12-03 17:28:25 +0900134
135 // List of libs that need to be excluded for APEX variant
136 ExcludeLibsForApex []string
Colin Crossc472d572015-03-17 15:06:21 -0700137}
138
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500139// PathDeps is a struct containing file paths to dependencies of a module.
140// It's constructed in depsToPath() by traversing the direct dependencies of the current module.
141// It's used to construct flags for various build statements (such as for compiling and linking).
142// It is then passed to module decorator functions responsible for registering build statements
143// (such as `module.compiler.compile()`).`
Colin Crossca860ac2016-01-04 14:34:37 -0800144type PathDeps struct {
Colin Cross26c34ed2016-09-30 17:10:16 -0700145 // Paths to .so files
Jiyong Park64a44f22019-01-18 14:37:08 +0900146 SharedLibs, EarlySharedLibs, LateSharedLibs android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700147 // Paths to the dependencies to use for .so files (.so.toc files)
Jiyong Park64a44f22019-01-18 14:37:08 +0900148 SharedLibsDeps, EarlySharedLibsDeps, LateSharedLibsDeps android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700149 // Paths to .a files
Colin Cross635c3b02016-05-18 15:37:25 -0700150 StaticLibs, LateStaticLibs, WholeStaticLibs android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700151
Colin Cross0de8a1e2020-09-18 14:15:30 -0700152 // Transitive static library dependencies of static libraries for use in ordering.
153 TranstiveStaticLibrariesForOrdering *android.DepSet
154
Colin Cross26c34ed2016-09-30 17:10:16 -0700155 // Paths to .o files
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100156 Objs Objects
157 // Paths to .o files in dependencies that provide them. Note that these lists
158 // aren't complete since prebuilt modules don't provide the .o files.
Dan Willemsen581341d2017-02-09 16:16:31 -0800159 StaticLibObjs Objects
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700160 WholeStaticLibObjs Objects
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700161
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100162 // Paths to .a files in prebuilts. Complements WholeStaticLibObjs to contain
163 // the libs from all whole_static_lib dependencies.
164 WholeStaticLibsFromPrebuilts android.Paths
165
Colin Cross26c34ed2016-09-30 17:10:16 -0700166 // Paths to generated source files
Colin Cross635c3b02016-05-18 15:37:25 -0700167 GeneratedSources android.Paths
Inseob Kimd110f872019-12-06 13:15:38 +0900168 GeneratedDeps android.Paths
Dan Willemsenb40aab62016-04-20 14:21:14 -0700169
Inseob Kimd110f872019-12-06 13:15:38 +0900170 Flags []string
171 IncludeDirs android.Paths
172 SystemIncludeDirs android.Paths
173 ReexportedDirs android.Paths
174 ReexportedSystemDirs android.Paths
175 ReexportedFlags []string
176 ReexportedGeneratedHeaders android.Paths
177 ReexportedDeps android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700178
Colin Cross26c34ed2016-09-30 17:10:16 -0700179 // Paths to crt*.o files
Colin Cross635c3b02016-05-18 15:37:25 -0700180 CrtBegin, CrtEnd android.OptionalPath
Dan Willemsena0790e32018-10-12 00:24:23 -0700181
182 // Path to the file container flags to use with the linker
183 LinkerFlagsFile android.OptionalPath
184
185 // Path to the dynamic linker binary
186 DynamicLinker android.OptionalPath
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700187}
188
Colin Cross4af21ed2019-11-04 09:37:55 -0800189// LocalOrGlobalFlags contains flags that need to have values set globally by the build system or locally by the module
190// tracked separately, in order to maintain the required ordering (most of the global flags need to go first on the
191// command line so they can be overridden by the local module flags).
192type LocalOrGlobalFlags struct {
193 CommonFlags []string // Flags that apply to C, C++, and assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700194 AsFlags []string // Flags that apply to assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800195 YasmFlags []string // Flags that apply to yasm assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700196 CFlags []string // Flags that apply to C and C++ source files
197 ToolingCFlags []string // Flags that apply to C and C++ source files parsed by clang LibTooling tools
198 ConlyFlags []string // Flags that apply to C source files
199 CppFlags []string // Flags that apply to C++ source files
200 ToolingCppFlags []string // Flags that apply to C++ source files parsed by clang LibTooling tools
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700201 LdFlags []string // Flags that apply to linker command lines
Colin Cross4af21ed2019-11-04 09:37:55 -0800202}
203
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500204// Flags contains various types of command line flags (and settings) for use in building build
205// statements related to C++.
Colin Cross4af21ed2019-11-04 09:37:55 -0800206type Flags struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500207 // Local flags (which individual modules are responsible for). These may override global flags.
208 Local LocalOrGlobalFlags
209 // Global flags (which build system or toolchain is responsible for).
Colin Cross4af21ed2019-11-04 09:37:55 -0800210 Global LocalOrGlobalFlags
211
212 aidlFlags []string // Flags that apply to aidl source files
213 rsFlags []string // Flags that apply to renderscript source files
214 libFlags []string // Flags to add libraries early to the link order
215 extraLibFlags []string // Flags to add libraries late in the link order after LdFlags
216 TidyFlags []string // Flags that apply to clang-tidy
217 SAbiFlags []string // Flags that apply to header-abi-dumper
Colin Cross28344522015-04-22 13:07:53 -0700218
Colin Crossc3199482017-03-30 15:03:04 -0700219 // Global include flags that apply to C, C++, and assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800220 // These must be after any module include flags, which will be in CommonFlags.
Colin Crossc3199482017-03-30 15:03:04 -0700221 SystemIncludeFlags []string
222
Oliver Nguyen04526782020-04-21 12:40:27 -0700223 Toolchain config.Toolchain
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500224 Tidy bool // True if clang-tidy is enabled.
225 GcovCoverage bool // True if coverage files should be generated.
226 SAbiDump bool // True if header abi dumps should be generated.
Oliver Nguyen04526782020-04-21 12:40:27 -0700227 EmitXrefs bool // If true, generate Ninja rules to generate emitXrefs input files for Kythe
Colin Crossca860ac2016-01-04 14:34:37 -0800228
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500229 // The instruction set required for clang ("arm" or "thumb").
Colin Crossca860ac2016-01-04 14:34:37 -0800230 RequiredInstructionSet string
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500231 // The target-device system path to the dynamic linker.
232 DynamicLinker string
Colin Cross16b23492016-01-06 14:41:07 -0800233
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700234 CFlagsDeps android.Paths // Files depended on by compiler flags
235 LdFlagsDeps android.Paths // Files depended on by linker flags
Colin Cross18c0c5a2016-12-01 14:45:23 -0800236
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500237 // True if .s files should be processed with the c preprocessor.
Dan Willemsen98ab3112019-08-27 21:20:40 -0700238 AssemblerWithCpp bool
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500239 // True if static libraries should be grouped (using `-Wl,--start-group` and `-Wl,--end-group`).
240 GroupStaticLibs bool
Dan Willemsen60e62f02018-11-16 21:05:32 -0800241
Colin Cross19878da2019-03-28 14:45:07 -0700242 proto android.ProtoFlags
Colin Cross19878da2019-03-28 14:45:07 -0700243 protoC bool // Whether to use C instead of C++
244 protoOptionsFile bool // Whether to look for a .options file next to the .proto
Dan Willemsen4e0aa232019-04-10 22:59:54 -0700245
246 Yacc *YaccProperties
Matthias Maennich22fd4d12020-07-15 10:58:56 +0200247 Lex *LexProperties
Colin Crossc472d572015-03-17 15:06:21 -0700248}
249
Colin Crossca860ac2016-01-04 14:34:37 -0800250// Properties used to compile all C or C++ modules
251type BaseProperties struct {
Dan Willemsen742a5452018-07-23 17:19:36 -0700252 // Deprecated. true is the default, false is invalid.
Colin Crossca860ac2016-01-04 14:34:37 -0800253 Clang *bool `android:"arch_variant"`
Colin Cross7d5136f2015-05-11 13:39:40 -0700254
Jiyong Parkb35a8192020-08-10 15:59:36 +0900255 // The API level that this module is built against. The APIs of this API level will be
256 // visible at build time, but use of any APIs newer than min_sdk_version will render the
257 // module unloadable on older devices. In the future it will be possible to weakly-link new
258 // APIs, making the behavior match Java: such modules will load on older devices, but
259 // calling new APIs on devices that do not support them will result in a crash.
260 //
261 // This property has the same behavior as sdk_version does for Java modules. For those
262 // familiar with Android Gradle, the property behaves similarly to how compileSdkVersion
263 // does for Java code.
264 //
265 // In addition, setting this property causes two variants to be built, one for the platform
266 // and one for apps.
Nan Zhang0007d812017-11-07 10:57:05 -0800267 Sdk_version *string
Colin Cross7d5136f2015-05-11 13:39:40 -0700268
Jiyong Parkb35a8192020-08-10 15:59:36 +0900269 // Minimum OS API level supported by this C or C++ module. This property becomes the value
270 // of the __ANDROID_API__ macro. When the C or C++ module is included in an APEX or an APK,
271 // this property is also used to ensure that the min_sdk_version of the containing module is
272 // not older (i.e. less) than this module's min_sdk_version. When not set, this property
273 // defaults to the value of sdk_version. When this is set to "apex_inherit", this tracks
274 // min_sdk_version of the containing APEX. When the module
275 // is not built for an APEX, "apex_inherit" defaults to sdk_version.
Jooyung Han379660c2020-04-21 15:24:00 +0900276 Min_sdk_version *string
277
Colin Crossc511bc52020-04-07 16:50:32 +0000278 // If true, always create an sdk variant and don't create a platform variant.
279 Sdk_variant_only *bool
280
Jiyong Parkde866cb2018-12-07 23:08:36 +0900281 AndroidMkSharedLibs []string `blueprint:"mutated"`
282 AndroidMkStaticLibs []string `blueprint:"mutated"`
283 AndroidMkRuntimeLibs []string `blueprint:"mutated"`
284 AndroidMkWholeStaticLibs []string `blueprint:"mutated"`
Bill Peckhama46de702020-04-21 17:23:37 -0700285 AndroidMkHeaderLibs []string `blueprint:"mutated"`
Jiyong Parkde866cb2018-12-07 23:08:36 +0900286 HideFromMake bool `blueprint:"mutated"`
287 PreventInstall bool `blueprint:"mutated"`
288 ApexesProvidingSharedLibs []string `blueprint:"mutated"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700289
Yo Chiang219968c2020-09-22 18:45:04 +0800290 // Set by DepsMutator.
291 AndroidMkSystemSharedLibs []string `blueprint:"mutated"`
292
Justin Yun5f7f7e82019-11-18 19:52:14 +0900293 ImageVariationPrefix string `blueprint:"mutated"`
294 VndkVersion string `blueprint:"mutated"`
295 SubName string `blueprint:"mutated"`
Colin Cross5beccee2017-12-07 15:28:59 -0800296
297 // *.logtags files, to combine together in order to generate the /system/etc/event-log-tags
298 // file
299 Logtags []string
Jiyong Parkf9332f12018-02-01 00:54:12 +0900300
Yifan Hong39143a92020-10-26 12:43:12 -0700301 // Make this module available when building for ramdisk.
302 // On device without a dedicated recovery partition, the module is only
303 // available after switching root into
304 // /first_stage_ramdisk. To expose the module before switching root, install
305 // the recovery variant instead.
Yifan Hong1b3348d2020-01-21 15:53:22 -0800306 Ramdisk_available *bool
307
Yifan Hong39143a92020-10-26 12:43:12 -0700308 // Make this module available when building for vendor ramdisk.
309 // On device without a dedicated recovery partition, the module is only
310 // available after switching root into
311 // /first_stage_ramdisk. To expose the module before switching root, install
312 // the recovery variant instead.
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700313 Vendor_ramdisk_available *bool
314
Jiyong Parkf9332f12018-02-01 00:54:12 +0900315 // Make this module available when building for recovery
316 Recovery_available *bool
317
Colin Crossae6c5202019-11-20 13:35:50 -0800318 // Set by imageMutator
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700319 CoreVariantNeeded bool `blueprint:"mutated"`
320 RamdiskVariantNeeded bool `blueprint:"mutated"`
321 VendorRamdiskVariantNeeded bool `blueprint:"mutated"`
322 RecoveryVariantNeeded bool `blueprint:"mutated"`
323 ExtraVariants []string `blueprint:"mutated"`
Jiyong Parkb0788572018-12-20 22:10:17 +0900324
325 // Allows this module to use non-APEX version of libraries. Useful
326 // for building binaries that are started before APEXes are activated.
327 Bootstrap *bool
Jooyung Han097087b2019-10-22 19:32:18 +0900328
329 // Even if DeviceConfig().VndkUseCoreVariant() is set, this module must use vendor variant.
330 // see soong/cc/config/vndk.go
331 MustUseVendorVariant bool `blueprint:"mutated"`
Inseob Kim8471cda2019-11-15 09:59:12 +0900332
333 // Used by vendor snapshot to record dependencies from snapshot modules.
334 SnapshotSharedLibs []string `blueprint:"mutated"`
335 SnapshotRuntimeLibs []string `blueprint:"mutated"`
Paul Duffin0cb37b92020-03-04 14:52:46 +0000336
337 Installable *bool
Colin Crossc511bc52020-04-07 16:50:32 +0000338
339 // Set by factories of module types that can only be referenced from variants compiled against
340 // the SDK.
341 AlwaysSdk bool `blueprint:"mutated"`
342
343 // Variant is an SDK variant created by sdkMutator
344 IsSdkVariant bool `blueprint:"mutated"`
345 // Set when both SDK and platform variants are exported to Make to trigger renaming the SDK
346 // variant to have a ".sdk" suffix.
347 SdkAndPlatformVariantVisibleToMake bool `blueprint:"mutated"`
Bill Peckham945441c2020-08-31 16:07:58 -0700348
349 // Normally Soong uses the directory structure to decide which modules
350 // should be included (framework) or excluded (non-framework) from the
Jose Galmes6f843bc2020-12-11 13:36:29 -0800351 // different snapshots (vendor, recovery, etc.), but this property
352 // allows a partner to exclude a module normally thought of as a
353 // framework module from the vendor snapshot.
354 Exclude_from_vendor_snapshot *bool
355
356 // Normally Soong uses the directory structure to decide which modules
357 // should be included (framework) or excluded (non-framework) from the
358 // different snapshots (vendor, recovery, etc.), but this property
359 // allows a partner to exclude a module normally thought of as a
360 // framework module from the recovery snapshot.
Jose Galmesf7294582020-11-13 12:07:36 -0800361 Exclude_from_recovery_snapshot *bool
Jiyong Park46a512f2020-12-04 18:02:13 +0900362
363 // List of APEXes that this module has private access to for testing purpose. The module
364 // can depend on libraries that are not exported by the APEXes and use private symbols
365 // from the exported libraries.
Martin Stjernholm855e90b2021-03-25 02:33:14 +0000366 Test_for []string `android:"arch_variant"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700367}
368
369type VendorProperties struct {
Jiyong Park82e2bf32017-08-16 14:05:54 +0900370 // whether this module should be allowed to be directly depended by other
371 // modules with `vendor: true`, `proprietary: true`, or `vendor_available:true`.
Justin Yun63e9ec72020-10-29 16:49:43 +0900372 // If set to true, two variants will be built separately, one like
373 // normal, and the other limited to the set of libraries and headers
374 // that are exposed to /vendor modules.
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700375 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900376 // The vendor variant may be used with a different (newer) /system,
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700377 // so it shouldn't have any unversioned runtime dependencies, or
378 // make assumptions about the system that may not be true in the
379 // future.
380 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900381 // If set to false, this module becomes inaccessible from /vendor modules.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900382 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900383 // The modules with vndk: {enabled: true} must define 'vendor_available'
Justin Yun0b1db6d2021-01-08 15:22:34 +0900384 // to 'true'.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900385 //
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700386 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
387 Vendor_available *bool
Jiyong Park5fb8c102018-04-09 12:03:06 +0900388
Justin Yunebcf0c52021-01-08 18:00:19 +0900389 // This is the same as the "vendor_available" except that the install path
390 // of the vendor variant is /odm or /vendor/odm.
391 // By replacing "vendor_available: true" with "odm_available: true", the
392 // module will install its vendor variant to the /odm partition or /vendor/odm.
393 // As the modules with "odm_available: true" still create the vendor variants,
394 // they can link to the other vendor modules as the vendor_available modules do.
395 // Also, the vendor modules can link to odm_available modules.
396 //
397 // It may not be used for VNDK modules.
398 Odm_available *bool
399
Justin Yun63e9ec72020-10-29 16:49:43 +0900400 // whether this module should be allowed to be directly depended by other
401 // modules with `product_specific: true` or `product_available: true`.
402 // If set to true, an additional product variant will be built separately
403 // that is limited to the set of libraries and headers that are exposed to
404 // /product modules.
405 //
406 // The product variant may be used with a different (newer) /system,
407 // so it shouldn't have any unversioned runtime dependencies, or
408 // make assumptions about the system that may not be true in the
409 // future.
410 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900411 // If set to false, this module becomes inaccessible from /product modules.
412 //
413 // Different from the 'vendor_available' property, the modules with
414 // vndk: {enabled: true} don't have to define 'product_available'. The VNDK
415 // library without 'product_available' may not be depended on by any other
416 // modules that has product variants including the product available VNDKs.
Justin Yun63e9ec72020-10-29 16:49:43 +0900417 //
418 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
419 // and PRODUCT_PRODUCT_VNDK_VERSION isn't set.
420 Product_available *bool
421
Jiyong Park5fb8c102018-04-09 12:03:06 +0900422 // whether this module is capable of being loaded with other instance
423 // (possibly an older version) of the same module in the same process.
424 // Currently, a shared library that is a member of VNDK (vndk: {enabled: true})
425 // can be double loaded in a vendor process if the library is also a
426 // (direct and indirect) dependency of an LLNDK library. Such libraries must be
427 // explicitly marked as `double_loadable: true` by the owner, or the dependency
428 // from the LLNDK lib should be cut if the lib is not designed to be double loaded.
429 Double_loadable *bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800430
431 // IsLLNDK is set to true for the vendor variant of a cc_library module that has LLNDK stubs.
432 IsLLNDK bool `blueprint:"mutated"`
433
Colin Cross78212242021-01-06 14:51:30 -0800434 // IsVNDKUsingCoreVariant is true for VNDK modules if the global VndkUseCoreVariant option is
435 // set and the module is not listed in VndkMustUseVendorVariantList.
436 IsVNDKUsingCoreVariant bool `blueprint:"mutated"`
437
438 // IsVNDKCore is set if a VNDK module does not set the vndk.support_system_process property.
439 IsVNDKCore bool `blueprint:"mutated"`
440
441 // IsVNDKSP is set if a VNDK module sets the vndk.support_system_process property.
442 IsVNDKSP bool `blueprint:"mutated"`
443
444 // IsVNDKPrivate is set if a VNDK module sets the vndk.private property or an LLNDK
445 // module sets the llndk.private property.
446 IsVNDKPrivate bool `blueprint:"mutated"`
447
448 // IsVNDKProduct is set if a VNDK module sets the product_available property.
449 IsVNDKProduct bool `blueprint:"mutated"`
Colin Crossca860ac2016-01-04 14:34:37 -0800450}
451
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500452// ModuleContextIntf is an interface (on a module context helper) consisting of functions related
453// to understanding details about the type of the current module.
454// For example, one might call these functions to determine whether the current module is a static
455// library and/or is installed in vendor directories.
Colin Crossca860ac2016-01-04 14:34:37 -0800456type ModuleContextIntf interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800457 static() bool
458 staticBinary() bool
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -0700459 testBinary() bool
Jiyong Park1d1119f2019-07-29 21:27:18 +0900460 header() bool
Inseob Kim7f283f42020-06-01 21:53:49 +0900461 binary() bool
Inseob Kim1042d292020-06-01 23:23:05 +0900462 object() bool
Colin Crossb98c8b02016-07-29 13:44:28 -0700463 toolchain() config.Toolchain
Jooyung Hanccce2f22020-03-07 03:45:53 +0900464 canUseSdk() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700465 useSdk() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800466 sdkVersion() string
Jiyong Parkb35a8192020-08-10 15:59:36 +0900467 minSdkVersion() string
468 isSdkVariant() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700469 useVndk() bool
Colin Cross95f1ca02020-10-29 20:47:22 -0700470 isNdk(config android.Config) bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800471 IsLlndk() bool
472 IsLlndkPublic() bool
473 isImplementationForLLNDKPublic() bool
474 IsVndkPrivate() bool
Justin Yun8effde42017-06-23 19:24:43 +0900475 isVndk() bool
476 isVndkSp() bool
Ivan Lozanof9e21722020-12-02 09:00:51 -0500477 IsVndkExt() bool
Justin Yun5f7f7e82019-11-18 19:52:14 +0900478 inProduct() bool
479 inVendor() bool
Yifan Hong1b3348d2020-01-21 15:53:22 -0800480 inRamdisk() bool
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700481 inVendorRamdisk() bool
Jiyong Parkf9332f12018-02-01 00:54:12 +0900482 inRecovery() bool
Dan Willemsen8146b2f2016-03-30 21:00:30 -0700483 selectedStl() string
Colin Crossce75d2c2016-10-06 16:12:58 -0700484 baseModuleName() string
Logan Chienf3511742017-10-31 18:04:35 +0800485 getVndkExtendsModuleName() string
Yi Kong7e53c572018-02-14 18:16:12 +0800486 isPgoCompile() bool
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800487 isNDKStubLibrary() bool
Ivan Lozanobd721262018-11-27 14:33:03 -0800488 useClangLld(actx ModuleContext) bool
Logan Chiene274fc92019-12-03 11:18:32 -0800489 isForPlatform() bool
Colin Crosse07f2312020-08-13 11:24:56 -0700490 apexVariationName() string
Dan Albertc8060532020-07-22 22:32:17 -0700491 apexSdkVersion() android.ApiLevel
Jiyong Parka4b9dd02019-01-16 22:53:13 +0900492 bootstrap() bool
Vic Yangefd249e2018-11-12 20:19:56 -0800493 mustUseVendorVariant() bool
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700494 nativeCoverage() bool
Colin Cross56a83212020-09-15 18:30:11 -0700495 directlyInAnyApex() bool
Colin Cross95b07f22020-12-16 11:06:50 -0800496 isPreventInstall() bool
Cindy Zhou5d5cfc12021-01-09 08:25:22 -0800497 isCfiAssemblySupportEnabled() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800498}
499
500type ModuleContext interface {
Colin Cross635c3b02016-05-18 15:37:25 -0700501 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800502 ModuleContextIntf
503}
504
505type BaseModuleContext interface {
Colin Cross0ea8ba82019-06-06 14:33:29 -0700506 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800507 ModuleContextIntf
508}
509
Colin Cross37047f12016-12-13 17:06:13 -0800510type DepsContext interface {
511 android.BottomUpMutatorContext
512 ModuleContextIntf
513}
514
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500515// feature represents additional (optional) steps to building cc-related modules, such as invocation
516// of clang-tidy.
Colin Crossca860ac2016-01-04 14:34:37 -0800517type feature interface {
518 begin(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800519 deps(ctx DepsContext, deps Deps) Deps
Colin Crossca860ac2016-01-04 14:34:37 -0800520 flags(ctx ModuleContext, flags Flags) Flags
521 props() []interface{}
522}
523
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500524// compiler is the interface for a compiler helper object. Different module decorators may implement
525// this helper differently. For example, compiling a `cc_library` may use a different build
526// statement than building a `toolchain_library`.
Colin Crossca860ac2016-01-04 14:34:37 -0800527type compiler interface {
Colin Cross42742b82016-08-01 13:20:05 -0700528 compilerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800529 compilerDeps(ctx DepsContext, deps Deps) Deps
Colin Crossf18e1102017-11-16 14:33:08 -0800530 compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
Colin Cross42742b82016-08-01 13:20:05 -0700531 compilerProps() []interface{}
532
Colin Cross76fada02016-07-27 10:31:13 -0700533 appendCflags([]string)
534 appendAsflags([]string)
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700535 compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects
Colin Crossca860ac2016-01-04 14:34:37 -0800536}
537
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500538// linker is the interface for a linker decorator object. Individual module types can provide
539// their own implementation for this decorator, and thus specify custom logic regarding build
540// statements pertaining to linking.
Colin Crossca860ac2016-01-04 14:34:37 -0800541type linker interface {
Colin Cross42742b82016-08-01 13:20:05 -0700542 linkerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800543 linkerDeps(ctx DepsContext, deps Deps) Deps
Colin Cross42742b82016-08-01 13:20:05 -0700544 linkerFlags(ctx ModuleContext, flags Flags) Flags
545 linkerProps() []interface{}
Ivan Lozanobd721262018-11-27 14:33:03 -0800546 useClangLld(actx ModuleContext) bool
Colin Cross42742b82016-08-01 13:20:05 -0700547
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700548 link(ctx ModuleContext, flags Flags, deps PathDeps, objs Objects) android.Path
Colin Cross76fada02016-07-27 10:31:13 -0700549 appendLdflags([]string)
Jiyong Parkaf6d8952019-01-31 12:21:23 +0900550 unstrippedOutputFilePath() android.Path
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700551
552 nativeCoverage() bool
Jiyong Parkee9a98d2019-08-09 14:44:36 +0900553 coverageOutputFilePath() android.OptionalPath
Paul Duffin13f02712020-03-06 12:30:43 +0000554
555 // Get the deps that have been explicitly specified in the properties.
Paul Duffin13f02712020-03-06 12:30:43 +0000556 linkerSpecifiedDeps(specifiedDeps specifiedDeps) specifiedDeps
557}
558
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500559// specifiedDeps is a tuple struct representing dependencies of a linked binary owned by the linker.
Paul Duffin13f02712020-03-06 12:30:43 +0000560type specifiedDeps struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500561 sharedLibs []string
562 // Note nil and [] are semantically distinct. [] prevents linking against the defaults (usually
563 // libc, libm, etc.)
564 systemSharedLibs []string
Colin Crossca860ac2016-01-04 14:34:37 -0800565}
566
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500567// installer is the interface for an installer helper object. This helper is responsible for
568// copying build outputs to the appropriate locations so that they may be installed on device.
Colin Crossca860ac2016-01-04 14:34:37 -0800569type installer interface {
Colin Cross42742b82016-08-01 13:20:05 -0700570 installerProps() []interface{}
Colin Cross635c3b02016-05-18 15:37:25 -0700571 install(ctx ModuleContext, path android.Path)
Paul Duffin0cb37b92020-03-04 14:52:46 +0000572 everInstallable() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800573 inData() bool
Vishwath Mohan1dd88392017-03-29 22:00:18 -0700574 inSanitizerDir() bool
Dan Willemsen4aa75ca2016-09-28 16:18:03 -0700575 hostToolPath() android.OptionalPath
Jiyong Parkb7c24df2019-02-01 12:03:59 +0900576 relativeInstallPath() string
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +0100577 makeUninstallable(mod *Module)
Colin Crossca860ac2016-01-04 14:34:37 -0800578}
579
Chris Parsons8d6e4332021-02-22 16:13:50 -0500580// bazelHandler is the interface for a helper object related to deferring to Bazel for
581// processing a module (during Bazel mixed builds). Individual module types should define
582// their own bazel handler if they support deferring to Bazel.
583type bazelHandler interface {
584 // Issue query to Bazel to retrieve information about Bazel's view of the current module.
585 // If Bazel returns this information, set module properties on the current module to reflect
586 // the returned information.
587 // Returns true if information was available from Bazel, false if bazel invocation still needs to occur.
588 generateBazelBuildActions(ctx android.ModuleContext, label string) bool
589}
590
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800591type xref interface {
592 XrefCcFiles() android.Paths
593}
594
Colin Cross6e511a92020-07-27 21:26:48 -0700595type libraryDependencyKind int
596
597const (
598 headerLibraryDependency = iota
599 sharedLibraryDependency
600 staticLibraryDependency
601)
602
603func (k libraryDependencyKind) String() string {
604 switch k {
605 case headerLibraryDependency:
606 return "headerLibraryDependency"
607 case sharedLibraryDependency:
608 return "sharedLibraryDependency"
609 case staticLibraryDependency:
610 return "staticLibraryDependency"
611 default:
612 panic(fmt.Errorf("unknown libraryDependencyKind %d", k))
613 }
614}
615
616type libraryDependencyOrder int
617
618const (
619 earlyLibraryDependency = -1
620 normalLibraryDependency = 0
621 lateLibraryDependency = 1
622)
623
624func (o libraryDependencyOrder) String() string {
625 switch o {
626 case earlyLibraryDependency:
627 return "earlyLibraryDependency"
628 case normalLibraryDependency:
629 return "normalLibraryDependency"
630 case lateLibraryDependency:
631 return "lateLibraryDependency"
632 default:
633 panic(fmt.Errorf("unknown libraryDependencyOrder %d", o))
634 }
635}
636
637// libraryDependencyTag is used to tag dependencies on libraries. Unlike many dependency
638// tags that have a set of predefined tag objects that are reused for each dependency, a
639// libraryDependencyTag is designed to contain extra metadata and is constructed as needed.
640// That means that comparing a libraryDependencyTag for equality will only be equal if all
641// of the metadata is equal. Most usages will want to type assert to libraryDependencyTag and
642// then check individual metadata fields instead.
643type libraryDependencyTag struct {
644 blueprint.BaseDependencyTag
645
646 // These are exported so that fmt.Printf("%#v") can call their String methods.
647 Kind libraryDependencyKind
648 Order libraryDependencyOrder
649
650 wholeStatic bool
651
652 reexportFlags bool
653 explicitlyVersioned bool
654 dataLib bool
655 ndk bool
656
657 staticUnwinder bool
658
659 makeSuffix string
Jiyong Parke3867542020-12-03 17:28:25 +0900660
Cindy Zhou18417cb2020-12-10 07:12:38 -0800661 // Whether or not this dependency should skip the apex dependency check
662 skipApexAllowedDependenciesCheck bool
663
Jiyong Parke3867542020-12-03 17:28:25 +0900664 // Whether or not this dependency has to be followed for the apex variants
665 excludeInApex bool
Colin Cross6e511a92020-07-27 21:26:48 -0700666}
667
668// header returns true if the libraryDependencyTag is tagging a header lib dependency.
669func (d libraryDependencyTag) header() bool {
670 return d.Kind == headerLibraryDependency
671}
672
673// shared returns true if the libraryDependencyTag is tagging a shared lib dependency.
674func (d libraryDependencyTag) shared() bool {
675 return d.Kind == sharedLibraryDependency
676}
677
678// shared returns true if the libraryDependencyTag is tagging a static lib dependency.
679func (d libraryDependencyTag) static() bool {
680 return d.Kind == staticLibraryDependency
681}
682
Colin Crosse9fe2942020-11-10 18:12:15 -0800683// InstallDepNeeded returns true for shared libraries so that shared library dependencies of
684// binaries or other shared libraries are installed as dependencies.
685func (d libraryDependencyTag) InstallDepNeeded() bool {
686 return d.shared()
687}
688
689var _ android.InstallNeededDependencyTag = libraryDependencyTag{}
690
691// dependencyTag is used for tagging miscellaneous dependency types that don't fit into
Colin Cross6e511a92020-07-27 21:26:48 -0700692// libraryDependencyTag. Each tag object is created globally and reused for multiple
693// dependencies (although since the object contains no references, assigning a tag to a
694// variable and modifying it will not modify the original). Users can compare the tag
695// returned by ctx.OtherModuleDependencyTag against the global original
696type dependencyTag struct {
697 blueprint.BaseDependencyTag
698 name string
699}
700
Colin Crosse9fe2942020-11-10 18:12:15 -0800701// installDependencyTag is used for tagging miscellaneous dependency types that don't fit into
702// libraryDependencyTag, but where the dependency needs to be installed when the parent is
703// installed.
704type installDependencyTag struct {
705 blueprint.BaseDependencyTag
706 android.InstallAlwaysNeededDependencyTag
707 name string
708}
709
Colin Crossc99deeb2016-04-11 15:06:20 -0700710var (
Colin Cross6e511a92020-07-27 21:26:48 -0700711 genSourceDepTag = dependencyTag{name: "gen source"}
712 genHeaderDepTag = dependencyTag{name: "gen header"}
713 genHeaderExportDepTag = dependencyTag{name: "gen header export"}
714 objDepTag = dependencyTag{name: "obj"}
715 linkerFlagsDepTag = dependencyTag{name: "linker flags file"}
Jiyong Parkd630bdd2020-11-25 11:47:24 +0900716 dynamicLinkerDepTag = installDependencyTag{name: "dynamic linker"}
Colin Cross6e511a92020-07-27 21:26:48 -0700717 reuseObjTag = dependencyTag{name: "reuse objects"}
718 staticVariantTag = dependencyTag{name: "static variant"}
719 vndkExtDepTag = dependencyTag{name: "vndk extends"}
720 dataLibDepTag = dependencyTag{name: "data lib"}
Colin Crosse9fe2942020-11-10 18:12:15 -0800721 runtimeDepTag = installDependencyTag{name: "runtime lib"}
Colin Cross6e511a92020-07-27 21:26:48 -0700722 testPerSrcDepTag = dependencyTag{name: "test_per_src"}
Colin Cross0de8a1e2020-09-18 14:15:30 -0700723 stubImplDepTag = dependencyTag{name: "stub_impl"}
Colin Cross127bb8b2020-12-16 16:46:01 -0800724 llndkStubDepTag = dependencyTag{name: "llndk stub"}
Colin Crossc99deeb2016-04-11 15:06:20 -0700725)
726
Colin Cross56a83212020-09-15 18:30:11 -0700727type copyDirectlyInAnyApexDependencyTag dependencyTag
728
729func (copyDirectlyInAnyApexDependencyTag) CopyDirectlyInAnyApex() {}
730
731var _ android.CopyDirectlyInAnyApexTag = copyDirectlyInAnyApexDependencyTag{}
732
Roland Levillainf89cd092019-07-29 16:22:59 +0100733func IsSharedDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700734 ccLibDepTag, ok := depTag.(libraryDependencyTag)
735 return ok && ccLibDepTag.shared()
736}
737
738func IsStaticDepTag(depTag blueprint.DependencyTag) bool {
739 ccLibDepTag, ok := depTag.(libraryDependencyTag)
740 return ok && ccLibDepTag.static()
Roland Levillainf89cd092019-07-29 16:22:59 +0100741}
742
Zach Johnson3df4e632020-11-06 11:56:27 -0800743func IsHeaderDepTag(depTag blueprint.DependencyTag) bool {
744 ccLibDepTag, ok := depTag.(libraryDependencyTag)
745 return ok && ccLibDepTag.header()
746}
747
Roland Levillainf89cd092019-07-29 16:22:59 +0100748func IsRuntimeDepTag(depTag blueprint.DependencyTag) bool {
Colin Crosse9fe2942020-11-10 18:12:15 -0800749 return depTag == runtimeDepTag
Roland Levillainf89cd092019-07-29 16:22:59 +0100750}
751
752func IsTestPerSrcDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700753 ccDepTag, ok := depTag.(dependencyTag)
Roland Levillainf89cd092019-07-29 16:22:59 +0100754 return ok && ccDepTag == testPerSrcDepTag
755}
756
Colin Crossca860ac2016-01-04 14:34:37 -0800757// Module contains the properties and members used by all C/C++ module types, and implements
758// the blueprint.Module interface. It delegates to compiler, linker, and installer interfaces
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500759// to construct the output file. Behavior can be customized with a Customizer, or "decorator",
760// interface.
761//
762// To define a C/C++ related module, construct a new Module object and point its delegates to
763// type-specific structs. These delegates will be invoked to register module-specific build
764// statements which may be unique to the module type. For example, module.compiler.compile() should
765// be defined so as to register build statements which are responsible for compiling the module.
766//
767// Another example: to construct a cc_binary module, one can create a `cc.binaryDecorator` struct
768// which implements the `linker` and `installer` interfaces, and points the `linker` and `installer`
769// members of the cc.Module to this decorator. Thus, a cc_binary module has custom linker and
770// installer logic.
Colin Crossca860ac2016-01-04 14:34:37 -0800771type Module struct {
Colin Cross635c3b02016-05-18 15:37:25 -0700772 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -0700773 android.DefaultableModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +0900774 android.ApexModuleBase
Jiyong Parkd1063c12019-07-17 20:08:41 +0900775 android.SdkBase
Liz Kammerea6666f2021-02-17 10:17:28 -0500776 android.BazelModuleBase
Colin Crossc472d572015-03-17 15:06:21 -0700777
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700778 Properties BaseProperties
779 VendorProperties VendorProperties
Colin Crossfa138792015-04-24 17:31:52 -0700780
Colin Crossca860ac2016-01-04 14:34:37 -0800781 // initialize before calling Init
Colin Cross635c3b02016-05-18 15:37:25 -0700782 hod android.HostOrDeviceSupported
783 multilib android.Multilib
Colin Crossc472d572015-03-17 15:06:21 -0700784
Paul Duffina0843f62019-12-13 19:50:38 +0000785 // Allowable SdkMemberTypes of this module type.
786 sdkMemberTypes []android.SdkMemberType
787
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500788 // decorator delegates, initialize before calling Init
789 // these may contain module-specific implementations, and effectively allow for custom
790 // type-specific logic. These members may reference different objects or the same object.
791 // Functions of these decorators will be invoked to initialize and register type-specific
792 // build statements.
Chris Parsons8d6e4332021-02-22 16:13:50 -0500793 compiler compiler
794 linker linker
795 installer installer
796 bazelHandler bazelHandler
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500797
798 features []feature
799 stl *stl
800 sanitize *sanitize
801 coverage *coverage
802 sabi *sabi
803 vndkdep *vndkdep
804 lto *lto
805 pgo *pgo
Colin Cross16b23492016-01-06 14:41:07 -0800806
Colin Cross31076b32020-10-23 17:22:06 -0700807 library libraryInterface
808
Colin Cross635c3b02016-05-18 15:37:25 -0700809 outputFile android.OptionalPath
Colin Crossca860ac2016-01-04 14:34:37 -0800810
Colin Crossb98c8b02016-07-29 13:44:28 -0700811 cachedToolchain config.Toolchain
Colin Crossb916a382016-07-29 17:28:03 -0700812
813 subAndroidMkOnce map[subAndroidMkProvider]bool
Fabien Sanglardd61f1f42017-01-10 16:21:22 -0800814
815 // Flags used to compile this module
816 flags Flags
Jeff Gaston294356f2017-09-27 17:05:30 -0700817
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800818 // only non-nil when this is a shared library that reuses the objects of a static library
Colin Cross0de8a1e2020-09-18 14:15:30 -0700819 staticAnalogue *StaticLibraryInfo
Inseob Kim9516ee92019-05-09 10:56:13 +0900820
821 makeLinkType string
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800822 // Kythe (source file indexer) paths for this compilation module
823 kytheFiles android.Paths
Jooyung Han75568392020-03-20 04:29:24 +0900824
825 // For apex variants, this is set as apex.min_sdk_version
Dan Albertc8060532020-07-22 22:32:17 -0700826 apexSdkVersion android.ApiLevel
Colin Cross56a83212020-09-15 18:30:11 -0700827
828 hideApexVariantFromMake bool
Colin Crossc472d572015-03-17 15:06:21 -0700829}
830
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500831func (c *Module) SetPreventInstall() {
832 c.Properties.PreventInstall = true
833}
834
835func (c *Module) SetHideFromMake() {
836 c.Properties.HideFromMake = true
837}
838
Ivan Lozano52767be2019-10-18 14:49:46 -0700839func (c *Module) Toc() android.OptionalPath {
840 if c.linker != nil {
841 if library, ok := c.linker.(libraryInterface); ok {
842 return library.toc()
843 }
844 }
845 panic(fmt.Errorf("Toc() called on non-library module: %q", c.BaseModuleName()))
846}
847
848func (c *Module) ApiLevel() string {
849 if c.linker != nil {
850 if stub, ok := c.linker.(*stubDecorator); ok {
Dan Albert1a246272020-07-06 14:49:35 -0700851 return stub.apiLevel.String()
Ivan Lozano52767be2019-10-18 14:49:46 -0700852 }
853 }
854 panic(fmt.Errorf("ApiLevel() called on non-stub library module: %q", c.BaseModuleName()))
855}
856
857func (c *Module) Static() bool {
858 if c.linker != nil {
859 if library, ok := c.linker.(libraryInterface); ok {
860 return library.static()
861 }
862 }
863 panic(fmt.Errorf("Static() called on non-library module: %q", c.BaseModuleName()))
864}
865
866func (c *Module) Shared() bool {
867 if c.linker != nil {
868 if library, ok := c.linker.(libraryInterface); ok {
869 return library.shared()
870 }
871 }
872 panic(fmt.Errorf("Shared() called on non-library module: %q", c.BaseModuleName()))
873}
874
875func (c *Module) SelectedStl() string {
Colin Crossc511bc52020-04-07 16:50:32 +0000876 if c.stl != nil {
877 return c.stl.Properties.SelectedStl
878 }
879 return ""
Ivan Lozano52767be2019-10-18 14:49:46 -0700880}
881
882func (c *Module) ToolchainLibrary() bool {
883 if _, ok := c.linker.(*toolchainLibraryDecorator); ok {
884 return true
885 }
886 return false
887}
888
889func (c *Module) NdkPrebuiltStl() bool {
890 if _, ok := c.linker.(*ndkPrebuiltStlLinker); ok {
891 return true
892 }
893 return false
894}
895
896func (c *Module) StubDecorator() bool {
897 if _, ok := c.linker.(*stubDecorator); ok {
898 return true
899 }
900 return false
901}
902
903func (c *Module) SdkVersion() string {
904 return String(c.Properties.Sdk_version)
905}
906
Artur Satayev480e25b2020-04-27 18:53:18 +0100907func (c *Module) MinSdkVersion() string {
908 return String(c.Properties.Min_sdk_version)
909}
910
Dan Albert92fe7402020-07-15 13:33:30 -0700911func (c *Module) SplitPerApiLevel() bool {
Colin Cross1348ce32020-10-01 13:37:16 -0700912 if !c.canUseSdk() {
913 return false
914 }
Dan Albert92fe7402020-07-15 13:33:30 -0700915 if linker, ok := c.linker.(*objectLinker); ok {
916 return linker.isCrt()
917 }
918 return false
919}
920
Colin Crossc511bc52020-04-07 16:50:32 +0000921func (c *Module) AlwaysSdk() bool {
922 return c.Properties.AlwaysSdk || Bool(c.Properties.Sdk_variant_only)
923}
924
Ivan Lozano183a3212019-10-18 14:18:45 -0700925func (c *Module) CcLibrary() bool {
926 if c.linker != nil {
927 if _, ok := c.linker.(*libraryDecorator); ok {
928 return true
929 }
Colin Crossd48fe732020-09-23 20:37:24 -0700930 if _, ok := c.linker.(*prebuiltLibraryLinker); ok {
931 return true
932 }
Ivan Lozano183a3212019-10-18 14:18:45 -0700933 }
934 return false
935}
936
937func (c *Module) CcLibraryInterface() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -0700938 if _, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700939 return true
940 }
941 return false
942}
943
Ivan Lozano2b262972019-11-21 12:30:50 -0800944func (c *Module) NonCcVariants() bool {
945 return false
946}
947
Ivan Lozano183a3212019-10-18 14:18:45 -0700948func (c *Module) SetStatic() {
949 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700950 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700951 library.setStatic()
952 return
953 }
954 }
955 panic(fmt.Errorf("SetStatic called on non-library module: %q", c.BaseModuleName()))
956}
957
958func (c *Module) SetShared() {
959 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700960 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700961 library.setShared()
962 return
963 }
964 }
965 panic(fmt.Errorf("SetShared called on non-library module: %q", c.BaseModuleName()))
966}
967
968func (c *Module) BuildStaticVariant() bool {
969 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700970 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700971 return library.buildStatic()
972 }
973 }
974 panic(fmt.Errorf("BuildStaticVariant called on non-library module: %q", c.BaseModuleName()))
975}
976
977func (c *Module) BuildSharedVariant() bool {
978 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700979 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700980 return library.buildShared()
981 }
982 }
983 panic(fmt.Errorf("BuildSharedVariant called on non-library module: %q", c.BaseModuleName()))
984}
985
986func (c *Module) Module() android.Module {
987 return c
988}
989
Jiyong Parkc20eee32018-09-05 22:36:17 +0900990func (c *Module) OutputFile() android.OptionalPath {
991 return c.outputFile
992}
993
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400994func (c *Module) CoverageFiles() android.Paths {
995 if c.linker != nil {
996 if library, ok := c.linker.(libraryInterface); ok {
997 return library.objs().coverageFiles
998 }
999 }
1000 panic(fmt.Errorf("CoverageFiles called on non-library module: %q", c.BaseModuleName()))
1001}
1002
Ivan Lozano183a3212019-10-18 14:18:45 -07001003var _ LinkableInterface = (*Module)(nil)
1004
Jiyong Park719b4462019-01-13 00:39:51 +09001005func (c *Module) UnstrippedOutputFile() android.Path {
Jiyong Parkaf6d8952019-01-31 12:21:23 +09001006 if c.linker != nil {
1007 return c.linker.unstrippedOutputFilePath()
Jiyong Park719b4462019-01-13 00:39:51 +09001008 }
1009 return nil
1010}
1011
Jiyong Parkee9a98d2019-08-09 14:44:36 +09001012func (c *Module) CoverageOutputFile() android.OptionalPath {
1013 if c.linker != nil {
1014 return c.linker.coverageOutputFilePath()
1015 }
1016 return android.OptionalPath{}
1017}
1018
Jiyong Parkb7c24df2019-02-01 12:03:59 +09001019func (c *Module) RelativeInstallPath() string {
1020 if c.installer != nil {
1021 return c.installer.relativeInstallPath()
1022 }
1023 return ""
1024}
1025
Jooyung Han344d5432019-08-23 11:17:39 +09001026func (c *Module) VndkVersion() string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001027 return c.Properties.VndkVersion
Jooyung Han344d5432019-08-23 11:17:39 +09001028}
1029
Colin Cross36242852017-06-23 15:06:31 -07001030func (c *Module) Init() android.Module {
Dan Willemsenf923f2b2018-05-09 13:45:03 -07001031 c.AddProperties(&c.Properties, &c.VendorProperties)
Colin Crossca860ac2016-01-04 14:34:37 -08001032 if c.compiler != nil {
Colin Cross36242852017-06-23 15:06:31 -07001033 c.AddProperties(c.compiler.compilerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001034 }
1035 if c.linker != nil {
Colin Cross36242852017-06-23 15:06:31 -07001036 c.AddProperties(c.linker.linkerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001037 }
1038 if c.installer != nil {
Colin Cross36242852017-06-23 15:06:31 -07001039 c.AddProperties(c.installer.installerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001040 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001041 if c.stl != nil {
Colin Cross36242852017-06-23 15:06:31 -07001042 c.AddProperties(c.stl.props()...)
Colin Crossa8e07cc2016-04-04 15:07:06 -07001043 }
Colin Cross16b23492016-01-06 14:41:07 -08001044 if c.sanitize != nil {
Colin Cross36242852017-06-23 15:06:31 -07001045 c.AddProperties(c.sanitize.props()...)
Colin Cross16b23492016-01-06 14:41:07 -08001046 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001047 if c.coverage != nil {
Colin Cross36242852017-06-23 15:06:31 -07001048 c.AddProperties(c.coverage.props()...)
Dan Willemsen581341d2017-02-09 16:16:31 -08001049 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001050 if c.sabi != nil {
Colin Cross36242852017-06-23 15:06:31 -07001051 c.AddProperties(c.sabi.props()...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001052 }
Justin Yun8effde42017-06-23 19:24:43 +09001053 if c.vndkdep != nil {
1054 c.AddProperties(c.vndkdep.props()...)
1055 }
Stephen Craneba090d12017-05-09 15:44:35 -07001056 if c.lto != nil {
1057 c.AddProperties(c.lto.props()...)
1058 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001059 if c.pgo != nil {
1060 c.AddProperties(c.pgo.props()...)
1061 }
Colin Crossca860ac2016-01-04 14:34:37 -08001062 for _, feature := range c.features {
Colin Cross36242852017-06-23 15:06:31 -07001063 c.AddProperties(feature.props()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001064 }
Colin Crossc472d572015-03-17 15:06:21 -07001065
Colin Cross36242852017-06-23 15:06:31 -07001066 android.InitAndroidArchModule(c, c.hod, c.multilib)
Liz Kammerea6666f2021-02-17 10:17:28 -05001067 android.InitBazelModule(c)
Jiyong Park7916bfc2019-09-30 19:13:12 +09001068 android.InitApexModule(c)
Jiyong Parkd1063c12019-07-17 20:08:41 +09001069 android.InitSdkAwareModule(c)
Jooyung Han18020ea2019-11-13 10:50:48 +09001070 android.InitDefaultableModule(c)
Jiyong Park9d452992018-10-03 00:38:19 +09001071
Colin Cross36242852017-06-23 15:06:31 -07001072 return c
Colin Crossc472d572015-03-17 15:06:21 -07001073}
1074
Colin Crossb916a382016-07-29 17:28:03 -07001075// Returns true for dependency roots (binaries)
1076// TODO(ccross): also handle dlopenable libraries
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001077func (c *Module) IsDependencyRoot() bool {
Colin Crossb916a382016-07-29 17:28:03 -07001078 if root, ok := c.linker.(interface {
1079 isDependencyRoot() bool
1080 }); ok {
1081 return root.isDependencyRoot()
1082 }
1083 return false
1084}
1085
Justin Yun5f7f7e82019-11-18 19:52:14 +09001086// Returns true if the module is using VNDK libraries instead of the libraries in /system/lib or /system/lib64.
1087// "product" and "vendor" variant modules return true for this function.
1088// When BOARD_VNDK_VERSION is set, vendor variants of "vendor_available: true", "vendor: true",
1089// "soc_specific: true" and more vendor installed modules are included here.
Justin Yun63e9ec72020-10-29 16:49:43 +09001090// When PRODUCT_PRODUCT_VNDK_VERSION is set, product variants of "product_available: true" or
Justin Yun5f7f7e82019-11-18 19:52:14 +09001091// "product_specific: true" modules are included here.
Ivan Lozano52767be2019-10-18 14:49:46 -07001092func (c *Module) UseVndk() bool {
Inseob Kim64c43952019-08-26 16:52:35 +09001093 return c.Properties.VndkVersion != ""
Dan Willemsen4416e5d2017-04-06 12:43:22 -07001094}
1095
Colin Crossc511bc52020-04-07 16:50:32 +00001096func (c *Module) canUseSdk() bool {
Colin Cross94e347e2021-01-19 14:56:07 -08001097 return c.Os() == android.Android && c.Target().NativeBridge == android.NativeBridgeDisabled &&
1098 !c.UseVndk() && !c.InRamdisk() && !c.InRecovery() && !c.InVendorRamdisk()
Colin Crossc511bc52020-04-07 16:50:32 +00001099}
1100
1101func (c *Module) UseSdk() bool {
1102 if c.canUseSdk() {
Colin Cross1348ce32020-10-01 13:37:16 -07001103 return String(c.Properties.Sdk_version) != ""
Colin Crossc511bc52020-04-07 16:50:32 +00001104 }
1105 return false
1106}
1107
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001108func (c *Module) isCoverageVariant() bool {
1109 return c.coverage.Properties.IsCoverageVariant
1110}
1111
Colin Cross95f1ca02020-10-29 20:47:22 -07001112func (c *Module) IsNdk(config android.Config) bool {
1113 return inList(c.BaseModuleName(), *getNDKKnownLibs(config))
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001114}
1115
Colin Cross127bb8b2020-12-16 16:46:01 -08001116func (c *Module) IsLlndk() bool {
1117 return c.VendorProperties.IsLLNDK
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001118}
1119
Colin Cross127bb8b2020-12-16 16:46:01 -08001120func (c *Module) IsLlndkPublic() bool {
Colin Cross78212242021-01-06 14:51:30 -08001121 return c.VendorProperties.IsLLNDK && !c.VendorProperties.IsVNDKPrivate
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001122}
1123
Colin Cross1f3f1302021-04-26 18:37:44 -07001124func (m *Module) NeedsLlndkVariants() bool {
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001125 lib := moduleLibraryInterface(m)
Colin Cross1f3f1302021-04-26 18:37:44 -07001126 return lib != nil && (lib.hasLLNDKStubs() || lib.hasLLNDKHeaders())
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001127}
1128
Colin Cross127bb8b2020-12-16 16:46:01 -08001129// isImplementationForLLNDKPublic returns true for any variant of a cc_library that has LLNDK stubs
1130// and does not set llndk.vendor_available: false.
1131func (c *Module) isImplementationForLLNDKPublic() bool {
1132 library, _ := c.library.(*libraryDecorator)
1133 return library != nil && library.hasLLNDKStubs() &&
Colin Cross0fb7fcd2021-03-02 11:00:07 -08001134 !Bool(library.Properties.Llndk.Private)
Colin Cross127bb8b2020-12-16 16:46:01 -08001135}
1136
Justin Yunfd9e8042020-12-23 18:23:14 +09001137// Returns true for LLNDK-private, VNDK-SP-private, and VNDK-core-private.
Colin Cross127bb8b2020-12-16 16:46:01 -08001138func (c *Module) IsVndkPrivate() bool {
Justin Yunfd9e8042020-12-23 18:23:14 +09001139 // Check if VNDK-core-private or VNDK-SP-private
1140 if c.IsVndk() {
Justin Yunc0d8c492021-01-07 17:45:31 +09001141 return Bool(c.vndkdep.Properties.Vndk.Private)
Justin Yunfd9e8042020-12-23 18:23:14 +09001142 }
1143
1144 // Check if LLNDK-private
1145 if library, ok := c.library.(*libraryDecorator); ok && c.IsLlndk() {
Justin Yunc0d8c492021-01-07 17:45:31 +09001146 return Bool(library.Properties.Llndk.Private)
Justin Yunfd9e8042020-12-23 18:23:14 +09001147 }
1148
1149 return false
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001150}
1151
Ivan Lozano52767be2019-10-18 14:49:46 -07001152func (c *Module) IsVndk() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001153 if vndkdep := c.vndkdep; vndkdep != nil {
1154 return vndkdep.isVndk()
Justin Yun8effde42017-06-23 19:24:43 +09001155 }
1156 return false
1157}
1158
Yi Kong7e53c572018-02-14 18:16:12 +08001159func (c *Module) isPgoCompile() bool {
1160 if pgo := c.pgo; pgo != nil {
1161 return pgo.Properties.PgoCompile
1162 }
1163 return false
1164}
1165
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001166func (c *Module) isNDKStubLibrary() bool {
1167 if _, ok := c.compiler.(*stubDecorator); ok {
1168 return true
1169 }
1170 return false
1171}
1172
Logan Chienf3511742017-10-31 18:04:35 +08001173func (c *Module) isVndkSp() bool {
1174 if vndkdep := c.vndkdep; vndkdep != nil {
1175 return vndkdep.isVndkSp()
1176 }
1177 return false
1178}
1179
Ivan Lozanof9e21722020-12-02 09:00:51 -05001180func (c *Module) IsVndkExt() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001181 if vndkdep := c.vndkdep; vndkdep != nil {
1182 return vndkdep.isVndkExt()
1183 }
1184 return false
1185}
1186
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001187func (c *Module) SubName() string {
1188 return c.Properties.SubName
1189}
1190
Ivan Lozano52767be2019-10-18 14:49:46 -07001191func (c *Module) MustUseVendorVariant() bool {
Jooyung Han097087b2019-10-22 19:32:18 +09001192 return c.isVndkSp() || c.Properties.MustUseVendorVariant
Vic Yangefd249e2018-11-12 20:19:56 -08001193}
1194
Logan Chienf3511742017-10-31 18:04:35 +08001195func (c *Module) getVndkExtendsModuleName() string {
1196 if vndkdep := c.vndkdep; vndkdep != nil {
1197 return vndkdep.getVndkExtendsModuleName()
1198 }
1199 return ""
1200}
1201
Jiyong Park25fc6a92018-11-18 18:02:45 +09001202func (c *Module) IsStubs() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001203 if lib := c.library; lib != nil {
1204 return lib.buildStubs()
Jiyong Park25fc6a92018-11-18 18:02:45 +09001205 }
1206 return false
1207}
1208
1209func (c *Module) HasStubsVariants() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001210 if lib := c.library; lib != nil {
1211 return lib.hasStubsVariants()
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001212 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09001213 return false
1214}
1215
Colin Cross0477b422020-10-13 18:43:54 -07001216// If this is a stubs library, ImplementationModuleName returns the name of the module that contains
1217// the implementation. If it is an implementation library it returns its own name.
1218func (c *Module) ImplementationModuleName(ctx android.BaseModuleContext) string {
1219 name := ctx.OtherModuleName(c)
1220 if versioned, ok := c.linker.(versionedInterface); ok {
1221 name = versioned.implementationModuleName(name)
1222 }
1223 return name
1224}
1225
Martin Stjernholm2856c662020-12-02 15:03:42 +00001226// Similar to ImplementationModuleName, but uses the Make variant of the module
1227// name as base name, for use in AndroidMk output. E.g. for a prebuilt module
1228// where the Soong name is prebuilt_foo, this returns foo (which works in Make
1229// under the premise that the prebuilt module overrides its source counterpart
1230// if it is exposed to Make).
1231func (c *Module) ImplementationModuleNameForMake(ctx android.BaseModuleContext) string {
1232 name := c.BaseModuleName()
1233 if versioned, ok := c.linker.(versionedInterface); ok {
1234 name = versioned.implementationModuleName(name)
1235 }
1236 return name
1237}
1238
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001239func (c *Module) bootstrap() bool {
1240 return Bool(c.Properties.Bootstrap)
1241}
1242
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001243func (c *Module) nativeCoverage() bool {
Pirama Arumuga Nainar5f69b9a2019-09-12 13:18:48 -07001244 // Bug: http://b/137883967 - native-bridge modules do not currently work with coverage
1245 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1246 return false
1247 }
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001248 return c.linker != nil && c.linker.nativeCoverage()
1249}
1250
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001251func (c *Module) IsSnapshotPrebuilt() bool {
Colin Crossa8890802021-01-22 14:06:33 -08001252 if p, ok := c.linker.(snapshotInterface); ok {
Inseob Kim1042d292020-06-01 23:23:05 +09001253 return p.isSnapshotPrebuilt()
Inseob Kimeec88e12020-01-22 11:11:29 +09001254 }
1255 return false
Inseob Kim8471cda2019-11-15 09:59:12 +09001256}
1257
Bill Peckham945441c2020-08-31 16:07:58 -07001258func (c *Module) ExcludeFromVendorSnapshot() bool {
1259 return Bool(c.Properties.Exclude_from_vendor_snapshot)
1260}
1261
Jose Galmesf7294582020-11-13 12:07:36 -08001262func (c *Module) ExcludeFromRecoverySnapshot() bool {
1263 return Bool(c.Properties.Exclude_from_recovery_snapshot)
1264}
1265
Jiyong Parkf1194352019-02-25 11:05:47 +09001266func isBionic(name string) bool {
1267 switch name {
Kiyoung Kim4098c7e2020-11-30 14:42:14 +09001268 case "libc", "libm", "libdl", "libdl_android", "linker", "linkerconfig":
Jiyong Parkf1194352019-02-25 11:05:47 +09001269 return true
1270 }
1271 return false
1272}
1273
Martin Stjernholm279de572019-09-10 23:18:20 +01001274func InstallToBootstrap(name string, config android.Config) bool {
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001275 if name == "libclang_rt.hwasan-aarch64-android" {
Jooyung Han8ce8db92020-05-15 19:05:05 +09001276 return true
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001277 }
1278 return isBionic(name)
1279}
1280
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001281func (c *Module) XrefCcFiles() android.Paths {
1282 return c.kytheFiles
1283}
1284
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001285func (c *Module) isCfiAssemblySupportEnabled() bool {
1286 return c.sanitize != nil &&
1287 Bool(c.sanitize.Properties.Sanitize.Config.Cfi_assembly_support)
1288}
1289
Colin Crossca860ac2016-01-04 14:34:37 -08001290type baseModuleContext struct {
Colin Cross0ea8ba82019-06-06 14:33:29 -07001291 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001292 moduleContextImpl
1293}
1294
Colin Cross37047f12016-12-13 17:06:13 -08001295type depsContext struct {
1296 android.BottomUpMutatorContext
1297 moduleContextImpl
1298}
1299
Colin Crossca860ac2016-01-04 14:34:37 -08001300type moduleContext struct {
Colin Cross635c3b02016-05-18 15:37:25 -07001301 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001302 moduleContextImpl
1303}
1304
1305type moduleContextImpl struct {
1306 mod *Module
1307 ctx BaseModuleContext
1308}
1309
Colin Crossb98c8b02016-07-29 13:44:28 -07001310func (ctx *moduleContextImpl) toolchain() config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001311 return ctx.mod.toolchain(ctx.ctx)
1312}
1313
1314func (ctx *moduleContextImpl) static() bool {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00001315 return ctx.mod.static()
Colin Crossca860ac2016-01-04 14:34:37 -08001316}
1317
1318func (ctx *moduleContextImpl) staticBinary() bool {
Jiyong Park379de2f2018-12-19 02:47:14 +09001319 return ctx.mod.staticBinary()
Colin Crossca860ac2016-01-04 14:34:37 -08001320}
1321
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07001322func (ctx *moduleContextImpl) testBinary() bool {
1323 return ctx.mod.testBinary()
1324}
1325
Jiyong Park1d1119f2019-07-29 21:27:18 +09001326func (ctx *moduleContextImpl) header() bool {
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001327 return ctx.mod.Header()
Jiyong Park1d1119f2019-07-29 21:27:18 +09001328}
1329
Inseob Kim7f283f42020-06-01 21:53:49 +09001330func (ctx *moduleContextImpl) binary() bool {
1331 return ctx.mod.binary()
1332}
1333
Inseob Kim1042d292020-06-01 23:23:05 +09001334func (ctx *moduleContextImpl) object() bool {
1335 return ctx.mod.object()
1336}
1337
Jooyung Hanccce2f22020-03-07 03:45:53 +09001338func (ctx *moduleContextImpl) canUseSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001339 return ctx.mod.canUseSdk()
Jooyung Hanccce2f22020-03-07 03:45:53 +09001340}
1341
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001342func (ctx *moduleContextImpl) useSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001343 return ctx.mod.UseSdk()
Colin Crossca860ac2016-01-04 14:34:37 -08001344}
1345
1346func (ctx *moduleContextImpl) sdkVersion() string {
Dan Willemsena96ff642016-06-07 12:34:45 -07001347 if ctx.ctx.Device() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001348 if ctx.useVndk() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001349 vndkVer := ctx.mod.VndkVersion()
Jooyung Han03302ee2020-04-08 09:22:26 +09001350 if inList(vndkVer, ctx.ctx.Config().PlatformVersionActiveCodenames()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001351 return "current"
Justin Yun732aa6a2018-03-23 17:43:47 +09001352 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001353 return vndkVer
Dan Willemsend2ede872016-11-18 14:54:24 -08001354 }
Justin Yun732aa6a2018-03-23 17:43:47 +09001355 return String(ctx.mod.Properties.Sdk_version)
Dan Willemsena96ff642016-06-07 12:34:45 -07001356 }
1357 return ""
Colin Crossca860ac2016-01-04 14:34:37 -08001358}
1359
Jiyong Parkb35a8192020-08-10 15:59:36 +09001360func (ctx *moduleContextImpl) minSdkVersion() string {
1361 ver := ctx.mod.MinSdkVersion()
1362 if ver == "apex_inherit" && !ctx.isForPlatform() {
1363 ver = ctx.apexSdkVersion().String()
1364 }
1365 if ver == "apex_inherit" || ver == "" {
1366 ver = ctx.sdkVersion()
1367 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001368 // For crt objects, the meaning of min_sdk_version is very different from other types of
1369 // module. For them, min_sdk_version defines the oldest version that the build system will
1370 // create versioned variants for. For example, if min_sdk_version is 16, then sdk variant of
1371 // the crt object has local variants of 16, 17, ..., up to the latest version. sdk_version
1372 // and min_sdk_version properties of the variants are set to the corresponding version
1373 // numbers. However, the platform (non-sdk) variant of the crt object is left untouched.
1374 // min_sdk_version: 16 doesn't actually mean that the platform variant has to support such
1375 // an old version. Since the variant is for the platform, it's preferred to target the
1376 // latest version.
1377 if ctx.mod.SplitPerApiLevel() && !ctx.isSdkVariant() {
1378 ver = strconv.Itoa(android.FutureApiLevelInt)
1379 }
1380
Jiyong Parkb35a8192020-08-10 15:59:36 +09001381 // Also make sure that minSdkVersion is not greater than sdkVersion, if they are both numbers
1382 sdkVersionInt, err := strconv.Atoi(ctx.sdkVersion())
1383 minSdkVersionInt, err2 := strconv.Atoi(ver)
1384 if err == nil && err2 == nil {
1385 if sdkVersionInt < minSdkVersionInt {
1386 return strconv.Itoa(sdkVersionInt)
1387 }
1388 }
1389 return ver
1390}
1391
1392func (ctx *moduleContextImpl) isSdkVariant() bool {
1393 return ctx.mod.IsSdkVariant()
1394}
1395
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001396func (ctx *moduleContextImpl) useVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001397 return ctx.mod.UseVndk()
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001398}
Justin Yun8effde42017-06-23 19:24:43 +09001399
Colin Cross95f1ca02020-10-29 20:47:22 -07001400func (ctx *moduleContextImpl) isNdk(config android.Config) bool {
1401 return ctx.mod.IsNdk(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001402}
1403
Colin Cross127bb8b2020-12-16 16:46:01 -08001404func (ctx *moduleContextImpl) IsLlndk() bool {
1405 return ctx.mod.IsLlndk()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001406}
1407
Colin Cross127bb8b2020-12-16 16:46:01 -08001408func (ctx *moduleContextImpl) IsLlndkPublic() bool {
1409 return ctx.mod.IsLlndkPublic()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001410}
1411
Colin Cross127bb8b2020-12-16 16:46:01 -08001412func (ctx *moduleContextImpl) isImplementationForLLNDKPublic() bool {
1413 return ctx.mod.isImplementationForLLNDKPublic()
1414}
1415
1416func (ctx *moduleContextImpl) IsVndkPrivate() bool {
1417 return ctx.mod.IsVndkPrivate()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001418}
1419
Logan Chienf3511742017-10-31 18:04:35 +08001420func (ctx *moduleContextImpl) isVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001421 return ctx.mod.IsVndk()
Logan Chienf3511742017-10-31 18:04:35 +08001422}
1423
Yi Kong7e53c572018-02-14 18:16:12 +08001424func (ctx *moduleContextImpl) isPgoCompile() bool {
1425 return ctx.mod.isPgoCompile()
1426}
1427
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001428func (ctx *moduleContextImpl) isNDKStubLibrary() bool {
1429 return ctx.mod.isNDKStubLibrary()
1430}
1431
Justin Yun8effde42017-06-23 19:24:43 +09001432func (ctx *moduleContextImpl) isVndkSp() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001433 return ctx.mod.isVndkSp()
1434}
1435
Ivan Lozanof9e21722020-12-02 09:00:51 -05001436func (ctx *moduleContextImpl) IsVndkExt() bool {
1437 return ctx.mod.IsVndkExt()
Justin Yun8effde42017-06-23 19:24:43 +09001438}
1439
Vic Yangefd249e2018-11-12 20:19:56 -08001440func (ctx *moduleContextImpl) mustUseVendorVariant() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001441 return ctx.mod.MustUseVendorVariant()
Vic Yangefd249e2018-11-12 20:19:56 -08001442}
1443
Dan Willemsen8146b2f2016-03-30 21:00:30 -07001444func (ctx *moduleContextImpl) selectedStl() string {
1445 if stl := ctx.mod.stl; stl != nil {
1446 return stl.Properties.SelectedStl
1447 }
1448 return ""
1449}
1450
Ivan Lozanobd721262018-11-27 14:33:03 -08001451func (ctx *moduleContextImpl) useClangLld(actx ModuleContext) bool {
1452 return ctx.mod.linker.useClangLld(actx)
1453}
1454
Colin Crossce75d2c2016-10-06 16:12:58 -07001455func (ctx *moduleContextImpl) baseModuleName() string {
1456 return ctx.mod.ModuleBase.BaseModuleName()
1457}
1458
Logan Chienf3511742017-10-31 18:04:35 +08001459func (ctx *moduleContextImpl) getVndkExtendsModuleName() string {
1460 return ctx.mod.getVndkExtendsModuleName()
1461}
1462
Logan Chiene274fc92019-12-03 11:18:32 -08001463func (ctx *moduleContextImpl) isForPlatform() bool {
Colin Cross56a83212020-09-15 18:30:11 -07001464 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).IsForPlatform()
Logan Chiene274fc92019-12-03 11:18:32 -08001465}
1466
Colin Crosse07f2312020-08-13 11:24:56 -07001467func (ctx *moduleContextImpl) apexVariationName() string {
Colin Cross56a83212020-09-15 18:30:11 -07001468 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).ApexVariationName
Jiyong Park25fc6a92018-11-18 18:02:45 +09001469}
1470
Dan Albertc8060532020-07-22 22:32:17 -07001471func (ctx *moduleContextImpl) apexSdkVersion() android.ApiLevel {
Jooyung Han75568392020-03-20 04:29:24 +09001472 return ctx.mod.apexSdkVersion
Jooyung Hanccce2f22020-03-07 03:45:53 +09001473}
1474
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001475func (ctx *moduleContextImpl) bootstrap() bool {
1476 return ctx.mod.bootstrap()
1477}
1478
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001479func (ctx *moduleContextImpl) nativeCoverage() bool {
1480 return ctx.mod.nativeCoverage()
1481}
1482
Colin Cross56a83212020-09-15 18:30:11 -07001483func (ctx *moduleContextImpl) directlyInAnyApex() bool {
1484 return ctx.mod.DirectlyInAnyApex()
1485}
1486
Colin Cross95b07f22020-12-16 11:06:50 -08001487func (ctx *moduleContextImpl) isPreventInstall() bool {
1488 return ctx.mod.Properties.PreventInstall
1489}
1490
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001491func (ctx *moduleContextImpl) isCfiAssemblySupportEnabled() bool {
1492 return ctx.mod.isCfiAssemblySupportEnabled()
1493}
1494
Colin Cross635c3b02016-05-18 15:37:25 -07001495func newBaseModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001496 return &Module{
1497 hod: hod,
1498 multilib: multilib,
1499 }
1500}
1501
Colin Cross635c3b02016-05-18 15:37:25 -07001502func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001503 module := newBaseModule(hod, multilib)
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001504 module.features = []feature{
1505 &tidyFeature{},
1506 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001507 module.stl = &stl{}
Colin Cross16b23492016-01-06 14:41:07 -08001508 module.sanitize = &sanitize{}
Dan Willemsen581341d2017-02-09 16:16:31 -08001509 module.coverage = &coverage{}
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001510 module.sabi = &sabi{}
Justin Yun8effde42017-06-23 19:24:43 +09001511 module.vndkdep = &vndkdep{}
Stephen Craneba090d12017-05-09 15:44:35 -07001512 module.lto = &lto{}
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001513 module.pgo = &pgo{}
Colin Crossca860ac2016-01-04 14:34:37 -08001514 return module
1515}
1516
Colin Crossce75d2c2016-10-06 16:12:58 -07001517func (c *Module) Prebuilt() *android.Prebuilt {
1518 if p, ok := c.linker.(prebuiltLinkerInterface); ok {
1519 return p.prebuilt()
1520 }
1521 return nil
1522}
1523
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001524func (c *Module) IsPrebuilt() bool {
1525 return c.Prebuilt() != nil
1526}
1527
Colin Crossce75d2c2016-10-06 16:12:58 -07001528func (c *Module) Name() string {
1529 name := c.ModuleBase.Name()
Dan Willemsen01a90592017-04-07 15:21:13 -07001530 if p, ok := c.linker.(interface {
1531 Name(string) string
1532 }); ok {
Colin Crossce75d2c2016-10-06 16:12:58 -07001533 name = p.Name(name)
1534 }
1535 return name
1536}
1537
Alex Light3d673592019-01-18 14:37:31 -08001538func (c *Module) Symlinks() []string {
1539 if p, ok := c.installer.(interface {
1540 symlinkList() []string
1541 }); ok {
1542 return p.symlinkList()
1543 }
1544 return nil
1545}
1546
Roland Levillainf89cd092019-07-29 16:22:59 +01001547func (c *Module) IsTestPerSrcAllTestsVariation() bool {
1548 test, ok := c.linker.(testPerSrc)
1549 return ok && test.isAllTestsVariation()
1550}
1551
Chris Parsons216e10a2020-07-09 17:12:52 -04001552func (c *Module) DataPaths() []android.DataPath {
Liz Kammer1c14a212020-05-12 15:26:55 -07001553 if p, ok := c.installer.(interface {
Chris Parsons216e10a2020-07-09 17:12:52 -04001554 dataPaths() []android.DataPath
Liz Kammer1c14a212020-05-12 15:26:55 -07001555 }); ok {
1556 return p.dataPaths()
1557 }
1558 return nil
1559}
1560
Justin Yun5f7f7e82019-11-18 19:52:14 +09001561func (c *Module) getNameSuffixWithVndkVersion(ctx android.ModuleContext) string {
1562 // Returns the name suffix for product and vendor variants. If the VNDK version is not
1563 // "current", it will append the VNDK version to the name suffix.
1564 var vndkVersion string
1565 var nameSuffix string
Ivan Lozanof9e21722020-12-02 09:00:51 -05001566 if c.InProduct() {
Justin Yund00f5ca2021-02-03 19:43:02 +09001567 if c.ProductSpecific() {
1568 // If the module is product specific with 'product_specific: true',
1569 // do not add a name suffix because it is a base module.
1570 return ""
1571 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001572 vndkVersion = ctx.DeviceConfig().ProductVndkVersion()
1573 nameSuffix = productSuffix
1574 } else {
1575 vndkVersion = ctx.DeviceConfig().VndkVersion()
Ivan Lozanoe6d30982021-02-05 10:57:43 -05001576 nameSuffix = VendorSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001577 }
1578 if vndkVersion == "current" {
1579 vndkVersion = ctx.DeviceConfig().PlatformVndkVersion()
1580 }
Colin Cross127bb8b2020-12-16 16:46:01 -08001581 if c.Properties.VndkVersion != vndkVersion && c.Properties.VndkVersion != "" {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001582 // add version suffix only if the module is using different vndk version than the
1583 // version in product or vendor partition.
1584 nameSuffix += "." + c.Properties.VndkVersion
1585 }
1586 return nameSuffix
1587}
1588
Chris Parsons8d6e4332021-02-22 16:13:50 -05001589func (c *Module) setSubnameProperty(actx android.ModuleContext) {
Inseob Kim64c43952019-08-26 16:52:35 +09001590 c.Properties.SubName = ""
1591
1592 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1593 c.Properties.SubName += nativeBridgeSuffix
1594 }
1595
Colin Cross127bb8b2020-12-16 16:46:01 -08001596 llndk := c.IsLlndk()
Colin Cross627280f2021-04-26 16:53:58 -07001597 if llndk || (c.UseVndk() && c.HasNonSystemVariants()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001598 // .vendor.{version} suffix is added for vendor variant or .product.{version} suffix is
1599 // added for product variant only when we have vendor and product variants with core
1600 // variant. The suffix is not added for vendor-only or product-only module.
1601 c.Properties.SubName += c.getNameSuffixWithVndkVersion(actx)
1602 } else if _, ok := c.linker.(*vndkPrebuiltLibraryDecorator); ok {
Inseob Kim64c43952019-08-26 16:52:35 +09001603 // .vendor suffix is added for backward compatibility with VNDK snapshot whose names with
1604 // such suffixes are already hard-coded in prebuilts/vndk/.../Android.bp.
Ivan Lozanoe6d30982021-02-05 10:57:43 -05001605 c.Properties.SubName += VendorSuffix
Yifan Hong1b3348d2020-01-21 15:53:22 -08001606 } else if c.InRamdisk() && !c.OnlyInRamdisk() {
1607 c.Properties.SubName += ramdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001608 } else if c.InVendorRamdisk() && !c.OnlyInVendorRamdisk() {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05001609 c.Properties.SubName += VendorRamdiskSuffix
Ivan Lozano52767be2019-10-18 14:49:46 -07001610 } else if c.InRecovery() && !c.OnlyInRecovery() {
Inseob Kim64c43952019-08-26 16:52:35 +09001611 c.Properties.SubName += recoverySuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001612 } else if c.IsSdkVariant() && (c.Properties.SdkAndPlatformVariantVisibleToMake || c.SplitPerApiLevel()) {
Colin Crossc511bc52020-04-07 16:50:32 +00001613 c.Properties.SubName += sdkSuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001614 if c.SplitPerApiLevel() {
1615 c.Properties.SubName += "." + c.SdkVersion()
1616 }
Inseob Kim64c43952019-08-26 16:52:35 +09001617 }
Chris Parsons8d6e4332021-02-22 16:13:50 -05001618}
1619
1620// Returns true if Bazel was successfully used for the analysis of this module.
1621func (c *Module) maybeGenerateBazelActions(actx android.ModuleContext) bool {
Liz Kammerbdc60992021-02-24 16:55:11 -05001622 bazelModuleLabel := c.GetBazelLabel(actx, c)
Chris Parsons8d6e4332021-02-22 16:13:50 -05001623 bazelActionsUsed := false
Chris Parsonsbab4d7e2021-04-15 17:27:08 -04001624 if c.MixedBuildsEnabled(actx) && c.bazelHandler != nil {
Chris Parsons8d6e4332021-02-22 16:13:50 -05001625 bazelActionsUsed = c.bazelHandler.generateBazelBuildActions(actx, bazelModuleLabel)
1626 }
1627 return bazelActionsUsed
1628}
1629
1630func (c *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
1631 // TODO(cparsons): Any logic in this method occurring prior to querying Bazel should be
1632 // requested from Bazel instead.
1633
1634 // Handle the case of a test module split by `test_per_src` mutator.
1635 //
1636 // The `test_per_src` mutator adds an extra variation named "", depending on all the other
1637 // `test_per_src` variations of the test module. Set `outputFile` to an empty path for this
1638 // module and return early, as this module does not produce an output file per se.
1639 if c.IsTestPerSrcAllTestsVariation() {
1640 c.outputFile = android.OptionalPath{}
1641 return
1642 }
1643
1644 c.setSubnameProperty(actx)
1645 apexInfo := actx.Provider(android.ApexInfoProvider).(android.ApexInfo)
1646 if !apexInfo.IsForPlatform() {
1647 c.hideApexVariantFromMake = true
1648 }
1649
Chris Parsonseefc9e62021-04-02 17:36:47 -04001650 c.makeLinkType = GetMakeLinkType(actx, c)
1651
Chris Parsons8d6e4332021-02-22 16:13:50 -05001652 if c.maybeGenerateBazelActions(actx) {
1653 return
1654 }
1655
Colin Crossca860ac2016-01-04 14:34:37 -08001656 ctx := &moduleContext{
Colin Cross635c3b02016-05-18 15:37:25 -07001657 ModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08001658 moduleContextImpl: moduleContextImpl{
1659 mod: c,
1660 },
1661 }
1662 ctx.ctx = ctx
1663
Colin Crossf18e1102017-11-16 14:33:08 -08001664 deps := c.depsToPaths(ctx)
1665 if ctx.Failed() {
1666 return
1667 }
1668
Dan Willemsen8536d6b2018-10-07 20:54:34 -07001669 if c.Properties.Clang != nil && *c.Properties.Clang == false {
1670 ctx.PropertyErrorf("clang", "false (GCC) is no longer supported")
1671 }
1672
Colin Crossca860ac2016-01-04 14:34:37 -08001673 flags := Flags{
1674 Toolchain: c.toolchain(ctx),
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001675 EmitXrefs: ctx.Config().EmitXrefRules(),
Colin Crossca860ac2016-01-04 14:34:37 -08001676 }
Colin Crossca860ac2016-01-04 14:34:37 -08001677 if c.compiler != nil {
Colin Crossf18e1102017-11-16 14:33:08 -08001678 flags = c.compiler.compilerFlags(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001679 }
1680 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001681 flags = c.linker.linkerFlags(ctx, flags)
Colin Crossca860ac2016-01-04 14:34:37 -08001682 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001683 if c.stl != nil {
1684 flags = c.stl.flags(ctx, flags)
1685 }
Colin Cross16b23492016-01-06 14:41:07 -08001686 if c.sanitize != nil {
1687 flags = c.sanitize.flags(ctx, flags)
1688 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001689 if c.coverage != nil {
Pirama Arumuga Nainar82fe59b2019-07-02 14:55:35 -07001690 flags, deps = c.coverage.flags(ctx, flags, deps)
Dan Willemsen581341d2017-02-09 16:16:31 -08001691 }
Stephen Craneba090d12017-05-09 15:44:35 -07001692 if c.lto != nil {
1693 flags = c.lto.flags(ctx, flags)
1694 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001695 if c.pgo != nil {
1696 flags = c.pgo.flags(ctx, flags)
1697 }
Colin Crossca860ac2016-01-04 14:34:37 -08001698 for _, feature := range c.features {
1699 flags = feature.flags(ctx, flags)
1700 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001701 if ctx.Failed() {
1702 return
1703 }
1704
Colin Cross4af21ed2019-11-04 09:37:55 -08001705 flags.Local.CFlags, _ = filterList(flags.Local.CFlags, config.IllegalFlags)
1706 flags.Local.CppFlags, _ = filterList(flags.Local.CppFlags, config.IllegalFlags)
1707 flags.Local.ConlyFlags, _ = filterList(flags.Local.ConlyFlags, config.IllegalFlags)
Colin Cross3f40fa42015-01-30 17:27:36 -08001708
Colin Cross4af21ed2019-11-04 09:37:55 -08001709 flags.Local.CommonFlags = append(flags.Local.CommonFlags, deps.Flags...)
Inseob Kim69378442019-06-03 19:10:47 +09001710
1711 for _, dir := range deps.IncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08001712 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-I"+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09001713 }
1714 for _, dir := range deps.SystemIncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08001715 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-isystem "+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09001716 }
1717
Fabien Sanglardd61f1f42017-01-10 16:21:22 -08001718 c.flags = flags
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -07001719 // We need access to all the flags seen by a source file.
1720 if c.sabi != nil {
1721 flags = c.sabi.flags(ctx, flags)
1722 }
Dan Willemsen98ab3112019-08-27 21:20:40 -07001723
Colin Cross4af21ed2019-11-04 09:37:55 -08001724 flags.AssemblerWithCpp = inList("-xassembler-with-cpp", flags.Local.AsFlags)
Dan Willemsen98ab3112019-08-27 21:20:40 -07001725
Colin Crossca860ac2016-01-04 14:34:37 -08001726 // Optimization to reduce size of build.ninja
1727 // Replace the long list of flags for each file with a module-local variable
Colin Cross4af21ed2019-11-04 09:37:55 -08001728 ctx.Variable(pctx, "cflags", strings.Join(flags.Local.CFlags, " "))
1729 ctx.Variable(pctx, "cppflags", strings.Join(flags.Local.CppFlags, " "))
1730 ctx.Variable(pctx, "asflags", strings.Join(flags.Local.AsFlags, " "))
1731 flags.Local.CFlags = []string{"$cflags"}
1732 flags.Local.CppFlags = []string{"$cppflags"}
1733 flags.Local.AsFlags = []string{"$asflags"}
Colin Crossca860ac2016-01-04 14:34:37 -08001734
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001735 var objs Objects
Colin Crossca860ac2016-01-04 14:34:37 -08001736 if c.compiler != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001737 objs = c.compiler.compile(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001738 if ctx.Failed() {
1739 return
1740 }
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001741 c.kytheFiles = objs.kytheFiles
Colin Cross3f40fa42015-01-30 17:27:36 -08001742 }
1743
Colin Crossca860ac2016-01-04 14:34:37 -08001744 if c.linker != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001745 outputFile := c.linker.link(ctx, flags, deps, objs)
Colin Crossca860ac2016-01-04 14:34:37 -08001746 if ctx.Failed() {
1747 return
1748 }
Colin Cross635c3b02016-05-18 15:37:25 -07001749 c.outputFile = android.OptionalPathForPath(outputFile)
Jiyong Parkb0788572018-12-20 22:10:17 +09001750
Jiyong Parkf7c3bbe2020-12-09 21:18:56 +09001751 // If a lib is directly included in any of the APEXes or is not available to the
1752 // platform (which is often the case when the stub is provided as a prebuilt),
1753 // unhide the stubs variant having the latest version gets visible to make. In
1754 // addition, the non-stubs variant is renamed to <libname>.bootstrap. This is to
1755 // force anything in the make world to link against the stubs library. (unless it
1756 // is explicitly referenced via .bootstrap suffix or the module is marked with
1757 // 'bootstrap: true').
1758 if c.HasStubsVariants() && c.NotInPlatform() && !c.InRamdisk() &&
Ivan Lozano52767be2019-10-18 14:49:46 -07001759 !c.InRecovery() && !c.UseVndk() && !c.static() && !c.isCoverageVariant() &&
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001760 c.IsStubs() && !c.InVendorRamdisk() {
Jiyong Parkb0788572018-12-20 22:10:17 +09001761 c.Properties.HideFromMake = false // unhide
1762 // Note: this is still non-installable
1763 }
Inseob Kimeda2e9c2020-03-03 22:06:32 +09001764
Jose Galmes6f843bc2020-12-11 13:36:29 -08001765 // glob exported headers for snapshot, if BOARD_VNDK_VERSION is current or
1766 // RECOVERY_SNAPSHOT_VERSION is current.
1767 if i, ok := c.linker.(snapshotLibraryInterface); ok {
Inseob Kimde5744a2020-12-02 13:14:28 +09001768 if shouldCollectHeadersForSnapshot(ctx, c, apexInfo) {
Inseob Kimeda2e9c2020-03-03 22:06:32 +09001769 i.collectHeadersForSnapshot(ctx)
1770 }
1771 }
Colin Crossce75d2c2016-10-06 16:12:58 -07001772 }
Colin Cross5049f022015-03-18 13:28:46 -07001773
Colin Crossa9c8c9f2020-12-16 10:20:23 -08001774 if !proptools.BoolDefault(c.Properties.Installable, true) {
1775 // If the module has been specifically configure to not be installed then
1776 // hide from make as otherwise it will break when running inside make
1777 // as the output path to install will not be specified. Not all uninstallable
1778 // modules can be hidden from make as some are needed for resolving make side
1779 // dependencies.
1780 c.HideFromMake()
1781 } else if !c.installable(apexInfo) {
1782 c.SkipInstall()
1783 }
1784
1785 // Still call c.installer.install though, the installs will be stored as PackageSpecs
1786 // to allow using the outputs in a genrule.
1787 if c.installer != nil && c.outputFile.Valid() {
Colin Crossce75d2c2016-10-06 16:12:58 -07001788 c.installer.install(ctx, c.outputFile.Path())
1789 if ctx.Failed() {
1790 return
Colin Crossca860ac2016-01-04 14:34:37 -08001791 }
Dan Albertc403f7c2015-03-18 14:01:18 -07001792 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001793}
1794
Colin Cross0ea8ba82019-06-06 14:33:29 -07001795func (c *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001796 if c.cachedToolchain == nil {
Liz Kammer356f7d42021-01-26 09:18:53 -05001797 c.cachedToolchain = config.FindToolchainWithContext(ctx)
Colin Cross3f40fa42015-01-30 17:27:36 -08001798 }
Colin Crossca860ac2016-01-04 14:34:37 -08001799 return c.cachedToolchain
Colin Cross3f40fa42015-01-30 17:27:36 -08001800}
1801
Colin Crossca860ac2016-01-04 14:34:37 -08001802func (c *Module) begin(ctx BaseModuleContext) {
1803 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001804 c.compiler.compilerInit(ctx)
Colin Cross21b9a242015-03-24 14:15:58 -07001805 }
Colin Crossca860ac2016-01-04 14:34:37 -08001806 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001807 c.linker.linkerInit(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08001808 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001809 if c.stl != nil {
1810 c.stl.begin(ctx)
1811 }
Colin Cross16b23492016-01-06 14:41:07 -08001812 if c.sanitize != nil {
1813 c.sanitize.begin(ctx)
1814 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001815 if c.coverage != nil {
1816 c.coverage.begin(ctx)
1817 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001818 if c.sabi != nil {
1819 c.sabi.begin(ctx)
1820 }
Justin Yun8effde42017-06-23 19:24:43 +09001821 if c.vndkdep != nil {
1822 c.vndkdep.begin(ctx)
1823 }
Stephen Craneba090d12017-05-09 15:44:35 -07001824 if c.lto != nil {
1825 c.lto.begin(ctx)
1826 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001827 if c.pgo != nil {
1828 c.pgo.begin(ctx)
1829 }
Colin Crossca860ac2016-01-04 14:34:37 -08001830 for _, feature := range c.features {
1831 feature.begin(ctx)
1832 }
Dan Albert92fe7402020-07-15 13:33:30 -07001833 if ctx.useSdk() && c.IsSdkVariant() {
Dan Albert1a246272020-07-06 14:49:35 -07001834 version, err := nativeApiLevelFromUser(ctx, ctx.sdkVersion())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07001835 if err != nil {
1836 ctx.PropertyErrorf("sdk_version", err.Error())
Dan Albert1a246272020-07-06 14:49:35 -07001837 c.Properties.Sdk_version = nil
1838 } else {
1839 c.Properties.Sdk_version = StringPtr(version.String())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07001840 }
Dan Albert7fa7b2e2016-08-05 16:37:52 -07001841 }
Colin Crossca860ac2016-01-04 14:34:37 -08001842}
1843
Colin Cross37047f12016-12-13 17:06:13 -08001844func (c *Module) deps(ctx DepsContext) Deps {
Colin Crossc99deeb2016-04-11 15:06:20 -07001845 deps := Deps{}
1846
1847 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001848 deps = c.compiler.compilerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07001849 }
1850 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001851 deps = c.linker.linkerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07001852 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001853 if c.stl != nil {
1854 deps = c.stl.deps(ctx, deps)
1855 }
Colin Cross16b23492016-01-06 14:41:07 -08001856 if c.sanitize != nil {
1857 deps = c.sanitize.deps(ctx, deps)
1858 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00001859 if c.coverage != nil {
1860 deps = c.coverage.deps(ctx, deps)
1861 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001862 if c.sabi != nil {
1863 deps = c.sabi.deps(ctx, deps)
1864 }
Justin Yun8effde42017-06-23 19:24:43 +09001865 if c.vndkdep != nil {
1866 deps = c.vndkdep.deps(ctx, deps)
1867 }
Stephen Craneba090d12017-05-09 15:44:35 -07001868 if c.lto != nil {
1869 deps = c.lto.deps(ctx, deps)
1870 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001871 for _, feature := range c.features {
1872 deps = feature.deps(ctx, deps)
1873 }
1874
Colin Crossb6715442017-10-24 11:13:31 -07001875 deps.WholeStaticLibs = android.LastUniqueStrings(deps.WholeStaticLibs)
1876 deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
1877 deps.LateStaticLibs = android.LastUniqueStrings(deps.LateStaticLibs)
1878 deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
1879 deps.LateSharedLibs = android.LastUniqueStrings(deps.LateSharedLibs)
1880 deps.HeaderLibs = android.LastUniqueStrings(deps.HeaderLibs)
Logan Chien43d34c32017-12-20 01:17:32 +08001881 deps.RuntimeLibs = android.LastUniqueStrings(deps.RuntimeLibs)
Colin Crossc99deeb2016-04-11 15:06:20 -07001882
Liz Kammer356f7d42021-01-26 09:18:53 -05001883 // In Bazel conversion mode, we dependency and build validations will occur in Bazel, so there is
1884 // no need to do so in Soong.
1885 if ctx.BazelConversionMode() {
1886 return deps
1887 }
1888
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001889 for _, lib := range deps.ReexportSharedLibHeaders {
1890 if !inList(lib, deps.SharedLibs) {
1891 ctx.PropertyErrorf("export_shared_lib_headers", "Shared library not in shared_libs: '%s'", lib)
1892 }
1893 }
1894
1895 for _, lib := range deps.ReexportStaticLibHeaders {
Steven Morelandba407c82021-04-01 22:17:50 +00001896 if !inList(lib, deps.StaticLibs) && !inList(lib, deps.WholeStaticLibs) {
1897 ctx.PropertyErrorf("export_static_lib_headers", "Static library not in static_libs or whole_static_libs: '%s'", lib)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001898 }
1899 }
1900
Colin Cross5950f382016-12-13 12:50:57 -08001901 for _, lib := range deps.ReexportHeaderLibHeaders {
1902 if !inList(lib, deps.HeaderLibs) {
1903 ctx.PropertyErrorf("export_header_lib_headers", "Header library not in header_libs: '%s'", lib)
1904 }
1905 }
1906
Dan Willemsenb3454ab2016-09-28 17:34:58 -07001907 for _, gen := range deps.ReexportGeneratedHeaders {
1908 if !inList(gen, deps.GeneratedHeaders) {
1909 ctx.PropertyErrorf("export_generated_headers", "Generated header module not in generated_headers: '%s'", gen)
1910 }
1911 }
1912
Colin Crossc99deeb2016-04-11 15:06:20 -07001913 return deps
1914}
1915
Dan Albert7e9d2952016-08-04 13:02:36 -07001916func (c *Module) beginMutator(actx android.BottomUpMutatorContext) {
Colin Crossca860ac2016-01-04 14:34:37 -08001917 ctx := &baseModuleContext{
Colin Cross0ea8ba82019-06-06 14:33:29 -07001918 BaseModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08001919 moduleContextImpl: moduleContextImpl{
1920 mod: c,
1921 },
1922 }
1923 ctx.ctx = ctx
1924
Colin Crossca860ac2016-01-04 14:34:37 -08001925 c.begin(ctx)
Dan Albert7e9d2952016-08-04 13:02:36 -07001926}
1927
Jiyong Park7ed9de32018-10-15 22:25:07 +09001928// Split name#version into name and version
Jiyong Park73c54ee2019-10-22 20:31:18 +09001929func StubsLibNameAndVersion(name string) (string, string) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09001930 if sharp := strings.LastIndex(name, "#"); sharp != -1 && sharp != len(name)-1 {
1931 version := name[sharp+1:]
1932 libname := name[:sharp]
1933 return libname, version
1934 }
1935 return name, ""
1936}
1937
Dan Albert92fe7402020-07-15 13:33:30 -07001938func GetCrtVariations(ctx android.BottomUpMutatorContext,
1939 m LinkableInterface) []blueprint.Variation {
1940 if ctx.Os() != android.Android {
1941 return nil
1942 }
1943 if m.UseSdk() {
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001944 // Choose the CRT that best satisfies the min_sdk_version requirement of this module
1945 minSdkVersion := m.MinSdkVersion()
1946 if minSdkVersion == "" || minSdkVersion == "apex_inherit" {
1947 minSdkVersion = m.SdkVersion()
1948 }
Dan Albert92fe7402020-07-15 13:33:30 -07001949 return []blueprint.Variation{
1950 {Mutator: "sdk", Variation: "sdk"},
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001951 {Mutator: "version", Variation: minSdkVersion},
Dan Albert92fe7402020-07-15 13:33:30 -07001952 }
1953 }
1954 return []blueprint.Variation{
1955 {Mutator: "sdk", Variation: ""},
1956 }
1957}
1958
Colin Crosse7257d22020-09-24 09:56:18 -07001959func (c *Module) addSharedLibDependenciesWithVersions(ctx android.BottomUpMutatorContext,
1960 variations []blueprint.Variation, depTag libraryDependencyTag, name, version string, far bool) {
1961
1962 variations = append([]blueprint.Variation(nil), variations...)
1963
Colin Cross3146c5c2020-09-30 15:34:40 -07001964 if version != "" && CanBeOrLinkAgainstVersionVariants(c) {
Colin Crosse7257d22020-09-24 09:56:18 -07001965 // Version is explicitly specified. i.e. libFoo#30
1966 variations = append(variations, blueprint.Variation{Mutator: "version", Variation: version})
1967 depTag.explicitlyVersioned = true
1968 }
Colin Crosse7257d22020-09-24 09:56:18 -07001969
Colin Cross0de8a1e2020-09-18 14:15:30 -07001970 if far {
1971 ctx.AddFarVariationDependencies(variations, depTag, name)
1972 } else {
1973 ctx.AddVariationDependencies(variations, depTag, name)
Colin Crosse7257d22020-09-24 09:56:18 -07001974 }
1975}
1976
Colin Cross1e676be2016-10-12 14:38:15 -07001977func (c *Module) DepsMutator(actx android.BottomUpMutatorContext) {
Inseob Kimeec88e12020-01-22 11:11:29 +09001978 if !c.Enabled() {
1979 return
1980 }
1981
Colin Cross37047f12016-12-13 17:06:13 -08001982 ctx := &depsContext{
1983 BottomUpMutatorContext: actx,
Dan Albert7e9d2952016-08-04 13:02:36 -07001984 moduleContextImpl: moduleContextImpl{
1985 mod: c,
1986 },
1987 }
1988 ctx.ctx = ctx
Colin Crossca860ac2016-01-04 14:34:37 -08001989
Colin Crossc99deeb2016-04-11 15:06:20 -07001990 deps := c.deps(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08001991
Yo Chiang219968c2020-09-22 18:45:04 +08001992 c.Properties.AndroidMkSystemSharedLibs = deps.SystemSharedLibs
1993
Colin Crosse0edaf92021-01-11 17:31:17 -08001994 var snapshotInfo *SnapshotInfo
1995 getSnapshot := func() SnapshotInfo {
1996 // Only modules with BOARD_VNDK_VERSION uses snapshot. Others use the zero value of
1997 // SnapshotInfo, which provides no mappings.
1998 if snapshotInfo == nil {
1999 // Only retrieve the snapshot on demand in order to avoid circular dependencies
2000 // between the modules in the snapshot and the snapshot itself.
2001 var snapshotModule []blueprint.Module
2002 if c.InVendor() && c.VndkVersion() == actx.DeviceConfig().VndkVersion() {
2003 snapshotModule = ctx.AddVariationDependencies(nil, nil, "vendor_snapshot")
2004 } else if recoverySnapshotVersion := actx.DeviceConfig().RecoverySnapshotVersion(); recoverySnapshotVersion != "current" && recoverySnapshotVersion != "" && c.InRecovery() {
2005 snapshotModule = ctx.AddVariationDependencies(nil, nil, "recovery_snapshot")
2006 }
2007 if len(snapshotModule) > 0 {
2008 snapshot := ctx.OtherModuleProvider(snapshotModule[0], SnapshotInfoProvider).(SnapshotInfo)
2009 snapshotInfo = &snapshot
2010 // republish the snapshot for use in later mutators on this module
2011 ctx.SetProvider(SnapshotInfoProvider, snapshot)
2012 } else {
2013 snapshotInfo = &SnapshotInfo{}
2014 }
2015 }
2016
2017 return *snapshotInfo
2018 }
2019
2020 rewriteSnapshotLib := func(lib string, snapshotMap map[string]string) string {
2021 if snapshot, ok := snapshotMap[lib]; ok {
2022 return snapshot
2023 }
2024
2025 return lib
2026 }
2027
Dan Albert914449f2016-06-17 16:45:24 -07002028 variantNdkLibs := []string{}
2029 variantLateNdkLibs := []string{}
Dan Willemsenb916b802017-03-19 13:44:32 -07002030 if ctx.Os() == android.Android {
Inseob Kimeec88e12020-01-22 11:11:29 +09002031 // rewriteLibs takes a list of names of shared libraries and scans it for three types
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002032 // of names:
Dan Albert914449f2016-06-17 16:45:24 -07002033 //
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002034 // 1. Name of an NDK library that refers to a prebuilt module.
2035 // For each of these, it adds the name of the prebuilt module (which will be in
2036 // prebuilts/ndk) to the list of nonvariant libs.
2037 // 2. Name of an NDK library that refers to an ndk_library module.
2038 // For each of these, it adds the name of the ndk_library module to the list of
2039 // variant libs.
2040 // 3. Anything else (so anything that isn't an NDK library).
2041 // It adds these to the nonvariantLibs list.
Dan Albert914449f2016-06-17 16:45:24 -07002042 //
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002043 // The caller can then know to add the variantLibs dependencies differently from the
2044 // nonvariantLibs
Inseob Kim9516ee92019-05-09 10:56:13 +09002045
Inseob Kim9516ee92019-05-09 10:56:13 +09002046 vendorPublicLibraries := vendorPublicLibraries(actx.Config())
Inseob Kimeec88e12020-01-22 11:11:29 +09002047
2048 rewriteLibs := func(list []string) (nonvariantLibs []string, variantLibs []string) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002049 variantLibs = []string{}
2050 nonvariantLibs = []string{}
Dan Albert914449f2016-06-17 16:45:24 -07002051 for _, entry := range list {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002052 // strip #version suffix out
Jiyong Park73c54ee2019-10-22 20:31:18 +09002053 name, _ := StubsLibNameAndVersion(entry)
Jose Galmes6f843bc2020-12-11 13:36:29 -08002054 if c.InRecovery() {
Colin Crosse0edaf92021-01-11 17:31:17 -08002055 nonvariantLibs = append(nonvariantLibs, rewriteSnapshotLib(entry, getSnapshot().SharedLibs))
Jose Galmes6f843bc2020-12-11 13:36:29 -08002056 } else if ctx.useSdk() && inList(name, *getNDKKnownLibs(ctx.Config())) {
Dan Albertde5aade2020-06-30 12:32:51 -07002057 variantLibs = append(variantLibs, name+ndkLibrarySuffix)
Inseob Kim9516ee92019-05-09 10:56:13 +09002058 } else if (ctx.Platform() || ctx.ProductSpecific()) && inList(name, *vendorPublicLibraries) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002059 vendorPublicLib := name + vendorPublicLibrarySuffix
Jiyong Park374510b2018-03-19 18:23:01 +09002060 if actx.OtherModuleExists(vendorPublicLib) {
2061 nonvariantLibs = append(nonvariantLibs, vendorPublicLib)
2062 } else {
2063 // This can happen if vendor_public_library module is defined in a
2064 // namespace that isn't visible to the current module. In that case,
2065 // link to the original library.
Jiyong Park7ed9de32018-10-15 22:25:07 +09002066 nonvariantLibs = append(nonvariantLibs, name)
Jiyong Park374510b2018-03-19 18:23:01 +09002067 }
Colin Crossb719c012021-04-26 14:35:38 -07002068 } else if ctx.useVndk() {
2069 nonvariantLibs = append(nonvariantLibs, rewriteSnapshotLib(entry, getSnapshot().SharedLibs))
Dan Albert914449f2016-06-17 16:45:24 -07002070 } else {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002071 // put name#version back
Dan Willemsen7cbf5f82017-03-28 00:08:30 -07002072 nonvariantLibs = append(nonvariantLibs, entry)
Dan Willemsen72d39932016-07-08 23:23:48 -07002073 }
2074 }
Dan Albert914449f2016-06-17 16:45:24 -07002075 return nonvariantLibs, variantLibs
Dan Willemsen72d39932016-07-08 23:23:48 -07002076 }
2077
Inseob Kimeec88e12020-01-22 11:11:29 +09002078 deps.SharedLibs, variantNdkLibs = rewriteLibs(deps.SharedLibs)
2079 deps.LateSharedLibs, variantLateNdkLibs = rewriteLibs(deps.LateSharedLibs)
2080 deps.ReexportSharedLibHeaders, _ = rewriteLibs(deps.ReexportSharedLibHeaders)
Colin Crosse0edaf92021-01-11 17:31:17 -08002081
2082 for idx, lib := range deps.RuntimeLibs {
2083 deps.RuntimeLibs[idx] = rewriteSnapshotLib(lib, getSnapshot().SharedLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002084 }
Dan Willemsen72d39932016-07-08 23:23:48 -07002085 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002086
Colin Cross32ec36c2016-12-15 07:39:51 -08002087 for _, lib := range deps.HeaderLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002088 depTag := libraryDependencyTag{Kind: headerLibraryDependency}
Colin Cross32ec36c2016-12-15 07:39:51 -08002089 if inList(lib, deps.ReexportHeaderLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002090 depTag.reexportFlags = true
Colin Cross32ec36c2016-12-15 07:39:51 -08002091 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002092
Colin Crosse0edaf92021-01-11 17:31:17 -08002093 lib = rewriteSnapshotLib(lib, getSnapshot().HeaderLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002094
Jiyong Park1ad8e162020-12-01 23:40:09 +09002095 if c.IsStubs() {
Colin Cross7228ecd2019-11-18 16:00:16 -08002096 actx.AddFarVariationDependencies(append(ctx.Target().Variations(), c.ImageVariation()),
Colin Cross0f7d2ef2019-10-16 11:03:10 -07002097 depTag, lib)
Jiyong Park7e636d02019-01-28 16:16:54 +09002098 } else {
2099 actx.AddVariationDependencies(nil, depTag, lib)
2100 }
2101 }
2102
Inseob Kim07def122020-11-23 14:43:02 +09002103 // sysprop_library has to support both C++ and Java. So sysprop_library internally creates one
2104 // C++ implementation library and one Java implementation library. When a module links against
2105 // sysprop_library, the C++ implementation library has to be linked. syspropImplLibraries is a
2106 // map from sysprop_library to implementation library; it will be used in whole_static_libs,
2107 // static_libs, and shared_libs.
Inseob Kimc0907f12019-02-08 21:00:45 +09002108 syspropImplLibraries := syspropImplLibraries(actx.Config())
2109
Jiyong Park5d1598f2019-02-25 22:14:17 +09002110 for _, lib := range deps.WholeStaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002111 depTag := libraryDependencyTag{Kind: staticLibraryDependency, wholeStatic: true, reexportFlags: true}
Jiyong Park5d1598f2019-02-25 22:14:17 +09002112 if impl, ok := syspropImplLibraries[lib]; ok {
2113 lib = impl
2114 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002115
Colin Crosse0edaf92021-01-11 17:31:17 -08002116 lib = rewriteSnapshotLib(lib, getSnapshot().StaticLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002117
Jiyong Park5d1598f2019-02-25 22:14:17 +09002118 actx.AddVariationDependencies([]blueprint.Variation{
2119 {Mutator: "link", Variation: "static"},
2120 }, depTag, lib)
2121 }
2122
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002123 for _, lib := range deps.StaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002124 depTag := libraryDependencyTag{Kind: staticLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002125 if inList(lib, deps.ReexportStaticLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002126 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002127 }
Jiyong Parke3867542020-12-03 17:28:25 +09002128 if inList(lib, deps.ExcludeLibsForApex) {
2129 depTag.excludeInApex = true
2130 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002131
2132 if impl, ok := syspropImplLibraries[lib]; ok {
2133 lib = impl
2134 }
2135
Colin Crosse0edaf92021-01-11 17:31:17 -08002136 lib = rewriteSnapshotLib(lib, getSnapshot().StaticLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002137
Dan Willemsen59339a22018-07-22 21:18:45 -07002138 actx.AddVariationDependencies([]blueprint.Variation{
2139 {Mutator: "link", Variation: "static"},
2140 }, depTag, lib)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002141 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002142
Jooyung Han75568392020-03-20 04:29:24 +09002143 // staticUnwinderDep is treated as staticDep for Q apexes
2144 // so that native libraries/binaries are linked with static unwinder
2145 // because Q libc doesn't have unwinder APIs
2146 if deps.StaticUnwinderIfLegacy {
Colin Cross6e511a92020-07-27 21:26:48 -07002147 depTag := libraryDependencyTag{Kind: staticLibraryDependency, staticUnwinder: true}
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002148 actx.AddVariationDependencies([]blueprint.Variation{
2149 {Mutator: "link", Variation: "static"},
Colin Crosse0edaf92021-01-11 17:31:17 -08002150 }, depTag, rewriteSnapshotLib(staticUnwinder(actx), getSnapshot().StaticLibs))
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002151 }
2152
Inseob Kimeec88e12020-01-22 11:11:29 +09002153 for _, lib := range deps.LateStaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002154 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency}
Inseob Kimeec88e12020-01-22 11:11:29 +09002155 actx.AddVariationDependencies([]blueprint.Variation{
2156 {Mutator: "link", Variation: "static"},
Colin Crosse0edaf92021-01-11 17:31:17 -08002157 }, depTag, rewriteSnapshotLib(lib, getSnapshot().StaticLibs))
Inseob Kimeec88e12020-01-22 11:11:29 +09002158 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002159
Jiyong Park7ed9de32018-10-15 22:25:07 +09002160 // shared lib names without the #version suffix
2161 var sharedLibNames []string
2162
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002163 for _, lib := range deps.SharedLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002164 depTag := libraryDependencyTag{Kind: sharedLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002165 if inList(lib, deps.ReexportSharedLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002166 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002167 }
Jiyong Parke3867542020-12-03 17:28:25 +09002168 if inList(lib, deps.ExcludeLibsForApex) {
2169 depTag.excludeInApex = true
2170 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002171
2172 if impl, ok := syspropImplLibraries[lib]; ok {
2173 lib = impl
2174 }
2175
Jiyong Park73c54ee2019-10-22 20:31:18 +09002176 name, version := StubsLibNameAndVersion(lib)
Inseob Kimc0907f12019-02-08 21:00:45 +09002177 sharedLibNames = append(sharedLibNames, name)
2178
Colin Crosse7257d22020-09-24 09:56:18 -07002179 variations := []blueprint.Variation{
2180 {Mutator: "link", Variation: "shared"},
2181 }
2182 c.addSharedLibDependenciesWithVersions(ctx, variations, depTag, name, version, false)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002183 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002184
Jiyong Park7ed9de32018-10-15 22:25:07 +09002185 for _, lib := range deps.LateSharedLibs {
Jiyong Park25fc6a92018-11-18 18:02:45 +09002186 if inList(lib, sharedLibNames) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002187 // This is to handle the case that some of the late shared libs (libc, libdl, libm, ...)
2188 // are added also to SharedLibs with version (e.g., libc#10). If not skipped, we will be
2189 // linking against both the stubs lib and the non-stubs lib at the same time.
2190 continue
2191 }
Colin Cross6e511a92020-07-27 21:26:48 -07002192 depTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency}
Colin Crosse7257d22020-09-24 09:56:18 -07002193 variations := []blueprint.Variation{
2194 {Mutator: "link", Variation: "shared"},
2195 }
2196 c.addSharedLibDependenciesWithVersions(ctx, variations, depTag, lib, "", false)
Jiyong Park7ed9de32018-10-15 22:25:07 +09002197 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002198
Dan Willemsen59339a22018-07-22 21:18:45 -07002199 actx.AddVariationDependencies([]blueprint.Variation{
2200 {Mutator: "link", Variation: "shared"},
Chris Parsons79d66a52020-06-05 17:26:16 -04002201 }, dataLibDepTag, deps.DataLibs...)
2202
2203 actx.AddVariationDependencies([]blueprint.Variation{
2204 {Mutator: "link", Variation: "shared"},
Dan Willemsen59339a22018-07-22 21:18:45 -07002205 }, runtimeDepTag, deps.RuntimeLibs...)
Logan Chien43d34c32017-12-20 01:17:32 +08002206
Colin Cross68861832016-07-08 10:41:41 -07002207 actx.AddDependency(c, genSourceDepTag, deps.GeneratedSources...)
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002208
2209 for _, gen := range deps.GeneratedHeaders {
2210 depTag := genHeaderDepTag
2211 if inList(gen, deps.ReexportGeneratedHeaders) {
2212 depTag = genHeaderExportDepTag
2213 }
2214 actx.AddDependency(c, depTag, gen)
2215 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002216
Dan Albert92fe7402020-07-15 13:33:30 -07002217 crtVariations := GetCrtVariations(ctx, c)
Colin Crossbbc941b2020-09-30 12:27:01 -07002218 actx.AddVariationDependencies(crtVariations, objDepTag, deps.ObjFiles...)
Colin Crossc99deeb2016-04-11 15:06:20 -07002219 if deps.CrtBegin != "" {
Dan Albert92fe7402020-07-15 13:33:30 -07002220 actx.AddVariationDependencies(crtVariations, CrtBeginDepTag,
Colin Crosse0edaf92021-01-11 17:31:17 -08002221 rewriteSnapshotLib(deps.CrtBegin, getSnapshot().Objects))
Colin Crossca860ac2016-01-04 14:34:37 -08002222 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002223 if deps.CrtEnd != "" {
Dan Albert92fe7402020-07-15 13:33:30 -07002224 actx.AddVariationDependencies(crtVariations, CrtEndDepTag,
Colin Crosse0edaf92021-01-11 17:31:17 -08002225 rewriteSnapshotLib(deps.CrtEnd, getSnapshot().Objects))
Colin Cross21b9a242015-03-24 14:15:58 -07002226 }
Dan Willemsena0790e32018-10-12 00:24:23 -07002227 if deps.LinkerFlagsFile != "" {
2228 actx.AddDependency(c, linkerFlagsDepTag, deps.LinkerFlagsFile)
2229 }
2230 if deps.DynamicLinker != "" {
2231 actx.AddDependency(c, dynamicLinkerDepTag, deps.DynamicLinker)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002232 }
Dan Albert914449f2016-06-17 16:45:24 -07002233
2234 version := ctx.sdkVersion()
Colin Cross6e511a92020-07-27 21:26:48 -07002235
2236 ndkStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002237 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002238 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002239 {Mutator: "link", Variation: "shared"},
2240 }, ndkStubDepTag, variantNdkLibs...)
Colin Cross6e511a92020-07-27 21:26:48 -07002241
2242 ndkLateStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002243 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002244 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002245 {Mutator: "link", Variation: "shared"},
2246 }, ndkLateStubDepTag, variantLateNdkLibs...)
Logan Chienf3511742017-10-31 18:04:35 +08002247
2248 if vndkdep := c.vndkdep; vndkdep != nil {
2249 if vndkdep.isVndkExt() {
Logan Chienf3511742017-10-31 18:04:35 +08002250 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross7228ecd2019-11-18 16:00:16 -08002251 c.ImageVariation(),
Dan Willemsen59339a22018-07-22 21:18:45 -07002252 {Mutator: "link", Variation: "shared"},
2253 }, vndkExtDepTag, vndkdep.getVndkExtendsModuleName())
Logan Chienf3511742017-10-31 18:04:35 +08002254 }
2255 }
Colin Cross6362e272015-10-29 15:25:03 -07002256}
Colin Cross21b9a242015-03-24 14:15:58 -07002257
Colin Crosse40b4ea2018-10-02 22:25:58 -07002258func BeginMutator(ctx android.BottomUpMutatorContext) {
Dan Albert7e9d2952016-08-04 13:02:36 -07002259 if c, ok := ctx.Module().(*Module); ok && c.Enabled() {
2260 c.beginMutator(ctx)
2261 }
2262}
2263
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002264// Whether a module can link to another module, taking into
2265// account NDK linking.
Jooyung Han479ca172020-10-19 18:51:07 +09002266func checkLinkType(ctx android.BaseModuleContext, from LinkableInterface, to LinkableInterface,
Colin Cross6e511a92020-07-27 21:26:48 -07002267 tag blueprint.DependencyTag) {
2268
2269 switch t := tag.(type) {
2270 case dependencyTag:
2271 if t != vndkExtDepTag {
2272 return
2273 }
2274 case libraryDependencyTag:
2275 default:
2276 return
2277 }
2278
Ivan Lozanof9e21722020-12-02 09:00:51 -05002279 if from.Target().Os != android.Android {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002280 // Host code is not restricted
2281 return
2282 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002283
2284 // VNDK is cc.Module supported only for now.
2285 if ccFrom, ok := from.(*Module); ok && from.UseVndk() {
Justin Yun63e9ec72020-10-29 16:49:43 +09002286 // Though allowed dependency is limited by the image mutator,
2287 // each vendor and product module needs to check link-type
2288 // for VNDK.
Ivan Lozano52767be2019-10-18 14:49:46 -07002289 if ccTo, ok := to.(*Module); ok {
2290 if ccFrom.vndkdep != nil {
2291 ccFrom.vndkdep.vndkCheckLinkType(ctx, ccTo, tag)
2292 }
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002293 } else if _, ok := to.(LinkableInterface); !ok {
Ivan Lozano52767be2019-10-18 14:49:46 -07002294 ctx.ModuleErrorf("Attempting to link VNDK cc.Module with unsupported module type")
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002295 }
2296 return
2297 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002298 if from.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002299 // Platform code can link to anything
2300 return
2301 }
Yifan Hong1b3348d2020-01-21 15:53:22 -08002302 if from.InRamdisk() {
2303 // Ramdisk code is not NDK
2304 return
2305 }
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002306 if from.InVendorRamdisk() {
2307 // Vendor ramdisk code is not NDK
2308 return
2309 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002310 if from.InRecovery() {
Jiyong Parkf9332f12018-02-01 00:54:12 +09002311 // Recovery code is not NDK
2312 return
2313 }
Colin Cross31076b32020-10-23 17:22:06 -07002314 if c, ok := to.(*Module); ok {
2315 if c.ToolchainLibrary() {
2316 // These are always allowed
2317 return
2318 }
2319 if c.NdkPrebuiltStl() {
2320 // These are allowed, but they don't set sdk_version
2321 return
2322 }
2323 if c.StubDecorator() {
2324 // These aren't real libraries, but are the stub shared libraries that are included in
2325 // the NDK.
2326 return
2327 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002328 }
Logan Chien834b9a62019-01-14 15:39:03 +08002329
Ivan Lozano52767be2019-10-18 14:49:46 -07002330 if strings.HasPrefix(ctx.ModuleName(), "libclang_rt.") && to.Module().Name() == "libc++" {
Logan Chien834b9a62019-01-14 15:39:03 +08002331 // Bug: http://b/121358700 - Allow libclang_rt.* shared libraries (with sdk_version)
2332 // to link to libc++ (non-NDK and without sdk_version).
2333 return
2334 }
2335
Ivan Lozano52767be2019-10-18 14:49:46 -07002336 if to.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002337 // NDK code linking to platform code is never okay.
2338 ctx.ModuleErrorf("depends on non-NDK-built library %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002339 ctx.OtherModuleName(to.Module()))
Dan Willemsen155d17c2019-02-06 18:30:02 -08002340 return
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002341 }
2342
2343 // At this point we know we have two NDK libraries, but we need to
2344 // check that we're not linking against anything built against a higher
2345 // API level, as it is only valid to link against older or equivalent
2346 // APIs.
2347
Inseob Kim01a28722018-04-11 09:48:45 +09002348 // Current can link against anything.
Ivan Lozano52767be2019-10-18 14:49:46 -07002349 if from.SdkVersion() != "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002350 // Otherwise we need to check.
Ivan Lozano52767be2019-10-18 14:49:46 -07002351 if to.SdkVersion() == "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002352 // Current can't be linked against by anything else.
2353 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002354 ctx.OtherModuleName(to.Module()), "current")
Inseob Kim01a28722018-04-11 09:48:45 +09002355 } else {
Ivan Lozano52767be2019-10-18 14:49:46 -07002356 fromApi, err := strconv.Atoi(from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002357 if err != nil {
2358 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002359 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002360 from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002361 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002362 toApi, err := strconv.Atoi(to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002363 if err != nil {
2364 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002365 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002366 to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002367 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002368
Inseob Kim01a28722018-04-11 09:48:45 +09002369 if toApi > fromApi {
2370 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002371 ctx.OtherModuleName(to.Module()), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002372 }
2373 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002374 }
Dan Albert202fe492017-12-15 13:56:59 -08002375
2376 // Also check that the two STL choices are compatible.
Ivan Lozano52767be2019-10-18 14:49:46 -07002377 fromStl := from.SelectedStl()
2378 toStl := to.SelectedStl()
Dan Albert202fe492017-12-15 13:56:59 -08002379 if fromStl == "" || toStl == "" {
2380 // Libraries that don't use the STL are unrestricted.
Inseob Kimda2171a2018-04-11 15:41:38 +09002381 } else if fromStl == "ndk_system" || toStl == "ndk_system" {
Dan Albert202fe492017-12-15 13:56:59 -08002382 // We can be permissive with the system "STL" since it is only the C++
2383 // ABI layer, but in the future we should make sure that everyone is
2384 // using either libc++ or nothing.
Colin Crossb60190a2018-09-04 16:28:17 -07002385 } else if getNdkStlFamily(from) != getNdkStlFamily(to) {
Dan Albert202fe492017-12-15 13:56:59 -08002386 ctx.ModuleErrorf("uses %q and depends on %q which uses incompatible %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002387 from.SelectedStl(), ctx.OtherModuleName(to.Module()),
2388 to.SelectedStl())
Dan Albert202fe492017-12-15 13:56:59 -08002389 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002390}
2391
Jooyung Han479ca172020-10-19 18:51:07 +09002392func checkLinkTypeMutator(ctx android.BottomUpMutatorContext) {
2393 if c, ok := ctx.Module().(*Module); ok {
2394 ctx.VisitDirectDeps(func(dep android.Module) {
2395 depTag := ctx.OtherModuleDependencyTag(dep)
2396 ccDep, ok := dep.(LinkableInterface)
2397 if ok {
2398 checkLinkType(ctx, c, ccDep, depTag)
2399 }
2400 })
2401 }
2402}
2403
Jiyong Park5fb8c102018-04-09 12:03:06 +09002404// Tests whether the dependent library is okay to be double loaded inside a single process.
Jooyung Hana70f0672019-01-18 15:20:43 +09002405// If a library has a vendor variant and is a (transitive) dependency of an LLNDK library,
2406// it is subject to be double loaded. Such lib should be explicitly marked as double_loadable: true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002407// or as vndk-sp (vndk: { enabled: true, support_system_process: true}).
Jooyung Hana70f0672019-01-18 15:20:43 +09002408func checkDoubleLoadableLibraries(ctx android.TopDownMutatorContext) {
2409 check := func(child, parent android.Module) bool {
2410 to, ok := child.(*Module)
2411 if !ok {
Jooyung Han479ca172020-10-19 18:51:07 +09002412 return false
Jooyung Hana70f0672019-01-18 15:20:43 +09002413 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002414
Jooyung Hana70f0672019-01-18 15:20:43 +09002415 if lib, ok := to.linker.(*libraryDecorator); !ok || !lib.shared() {
2416 return false
Jiyong Park5fb8c102018-04-09 12:03:06 +09002417 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002418
Jiyong Park0474e1f2021-01-14 14:26:06 +09002419 // These dependencies are not excercised at runtime. Tracking these will give us
2420 // false negative, so skip.
Jiyong Park1ad8e162020-12-01 23:40:09 +09002421 depTag := ctx.OtherModuleDependencyTag(child)
2422 if IsHeaderDepTag(depTag) {
2423 return false
2424 }
Jiyong Park0474e1f2021-01-14 14:26:06 +09002425 if depTag == staticVariantTag {
2426 return false
2427 }
2428 if depTag == stubImplDepTag {
2429 return false
2430 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002431
Justin Yun63e9ec72020-10-29 16:49:43 +09002432 // Even if target lib has no vendor variant, keep checking dependency
2433 // graph in case it depends on vendor_available or product_available
2434 // but not double_loadable transtively.
2435 if !to.HasNonSystemVariants() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002436 return true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002437 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002438
Jiyong Park0474e1f2021-01-14 14:26:06 +09002439 // The happy path. Keep tracking dependencies until we hit a non double-loadable
2440 // one.
2441 if Bool(to.VendorProperties.Double_loadable) {
2442 return true
2443 }
2444
2445 if to.isVndkSp() || to.IsLlndk() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002446 return false
2447 }
2448
Jooyung Hana70f0672019-01-18 15:20:43 +09002449 ctx.ModuleErrorf("links a library %q which is not LL-NDK, "+
2450 "VNDK-SP, or explicitly marked as 'double_loadable:true'. "+
Jiyong Park0474e1f2021-01-14 14:26:06 +09002451 "Dependency list: %s", ctx.OtherModuleName(to), ctx.GetPathString(false))
Jooyung Hana70f0672019-01-18 15:20:43 +09002452 return false
2453 }
2454 if module, ok := ctx.Module().(*Module); ok {
2455 if lib, ok := module.linker.(*libraryDecorator); ok && lib.shared() {
Jiyong Park0474e1f2021-01-14 14:26:06 +09002456 if lib.hasLLNDKStubs() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002457 ctx.WalkDeps(check)
2458 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002459 }
2460 }
2461}
2462
Colin Crossc99deeb2016-04-11 15:06:20 -07002463// Convert dependencies to paths. Returns a PathDeps containing paths
Colin Cross635c3b02016-05-18 15:37:25 -07002464func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
Colin Crossca860ac2016-01-04 14:34:37 -08002465 var depPaths PathDeps
Colin Crossca860ac2016-01-04 14:34:37 -08002466
Colin Cross0de8a1e2020-09-18 14:15:30 -07002467 var directStaticDeps []StaticLibraryInfo
2468 var directSharedDeps []SharedLibraryInfo
Jeff Gaston294356f2017-09-27 17:05:30 -07002469
Colin Cross0de8a1e2020-09-18 14:15:30 -07002470 reexportExporter := func(exporter FlagExporterInfo) {
2471 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, exporter.IncludeDirs...)
2472 depPaths.ReexportedSystemDirs = append(depPaths.ReexportedSystemDirs, exporter.SystemIncludeDirs...)
2473 depPaths.ReexportedFlags = append(depPaths.ReexportedFlags, exporter.Flags...)
2474 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, exporter.Deps...)
2475 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders, exporter.GeneratedHeaders...)
Inseob Kim69378442019-06-03 19:10:47 +09002476 }
2477
Jooyung Hande34d232020-07-23 13:04:15 +09002478 // For the dependency from platform to apex, use the latest stubs
2479 c.apexSdkVersion = android.FutureApiLevel
Colin Cross56a83212020-09-15 18:30:11 -07002480 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
2481 if !apexInfo.IsForPlatform() {
Jiyong Park4eab21d2021-04-15 15:17:54 +09002482 c.apexSdkVersion = apexInfo.MinSdkVersion
Jooyung Hande34d232020-07-23 13:04:15 +09002483 }
2484
2485 if android.InList("hwaddress", ctx.Config().SanitizeDevice()) {
2486 // In hwasan build, we override apexSdkVersion to the FutureApiLevel(10000)
2487 // so that even Q(29/Android10) apexes could use the dynamic unwinder by linking the newer stubs(e.g libc(R+)).
2488 // (b/144430859)
2489 c.apexSdkVersion = android.FutureApiLevel
2490 }
2491
Colin Crossd11fcda2017-10-23 17:59:01 -07002492 ctx.VisitDirectDeps(func(dep android.Module) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002493 depName := ctx.OtherModuleName(dep)
2494 depTag := ctx.OtherModuleDependencyTag(dep)
Dan Albert9e10cd42016-08-03 14:12:14 -07002495
Ivan Lozano52767be2019-10-18 14:49:46 -07002496 ccDep, ok := dep.(LinkableInterface)
2497 if !ok {
2498
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002499 // handling for a few module types that aren't cc Module but that are also supported
2500 switch depTag {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002501 case genSourceDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002502 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002503 depPaths.GeneratedSources = append(depPaths.GeneratedSources,
2504 genRule.GeneratedSourceFiles()...)
2505 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002506 ctx.ModuleErrorf("module %q is not a gensrcs or genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002507 }
Colin Crosse90bfd12017-04-26 16:59:26 -07002508 // Support exported headers from a generated_sources dependency
2509 fallthrough
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002510 case genHeaderDepTag, genHeaderExportDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002511 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Inseob Kimd110f872019-12-06 13:15:38 +09002512 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps,
Dan Willemsen9da9d492018-02-21 18:28:18 -08002513 genRule.GeneratedDeps()...)
Jiyong Park74955042019-10-22 20:19:51 +09002514 dirs := genRule.GeneratedHeaderDirs()
Inseob Kim69378442019-06-03 19:10:47 +09002515 depPaths.IncludeDirs = append(depPaths.IncludeDirs, dirs...)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002516 if depTag == genHeaderExportDepTag {
Inseob Kim69378442019-06-03 19:10:47 +09002517 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, dirs...)
Inseob Kimd110f872019-12-06 13:15:38 +09002518 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders,
2519 genRule.GeneratedSourceFiles()...)
Inseob Kim69378442019-06-03 19:10:47 +09002520 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, genRule.GeneratedDeps()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002521 // Add these re-exported flags to help header-abi-dumper to infer the abi exported by a library.
Jiyong Park74955042019-10-22 20:19:51 +09002522 c.sabi.Properties.ReexportedIncludes = append(c.sabi.Properties.ReexportedIncludes, dirs.Strings()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002523
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002524 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002525 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002526 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002527 }
Dan Willemsena0790e32018-10-12 00:24:23 -07002528 case linkerFlagsDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002529 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002530 files := genRule.GeneratedSourceFiles()
2531 if len(files) == 1 {
Dan Willemsena0790e32018-10-12 00:24:23 -07002532 depPaths.LinkerFlagsFile = android.OptionalPathForPath(files[0])
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002533 } else if len(files) > 1 {
Dan Willemsena0790e32018-10-12 00:24:23 -07002534 ctx.ModuleErrorf("module %q can only generate a single file if used for a linker flag file", depName)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002535 }
2536 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002537 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002538 }
Colin Crossca860ac2016-01-04 14:34:37 -08002539 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002540 return
2541 }
2542
Colin Crossfe17f6f2019-03-28 19:30:56 -07002543 if depTag == android.ProtoPluginDepTag {
2544 return
2545 }
2546
Colin Crossd11fcda2017-10-23 17:59:01 -07002547 if dep.Target().Os != ctx.Os() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002548 ctx.ModuleErrorf("OS mismatch between %q and %q", ctx.ModuleName(), depName)
2549 return
2550 }
Colin Crossd11fcda2017-10-23 17:59:01 -07002551 if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
Jooyung Han61b66e92020-03-21 14:21:46 +00002552 ctx.ModuleErrorf("Arch mismatch between %q(%v) and %q(%v)",
2553 ctx.ModuleName(), ctx.Arch().ArchType, depName, dep.Target().Arch.ArchType)
Colin Crossa1ad8d12016-06-01 17:09:44 -07002554 return
2555 }
2556
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002557 if depTag == reuseObjTag {
Colin Crossa717db72020-10-23 14:53:06 -07002558 // Skip reused objects for stub libraries, they use their own stub object file instead.
2559 // The reuseObjTag dependency still exists because the LinkageMutator runs before the
2560 // version mutator, so the stubs variant is created from the shared variant that
2561 // already has the reuseObjTag dependency on the static variant.
Colin Cross31076b32020-10-23 17:22:06 -07002562 if !c.library.buildStubs() {
Colin Crossa717db72020-10-23 14:53:06 -07002563 staticAnalogue := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
2564 objs := staticAnalogue.ReuseObjects
2565 depPaths.Objs = depPaths.Objs.Append(objs)
2566 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
2567 reexportExporter(depExporterInfo)
2568 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07002569 return
Jiyong Parke4bb9862019-02-01 00:31:10 +09002570 }
2571
Colin Cross6e511a92020-07-27 21:26:48 -07002572 linkFile := ccDep.OutputFile()
2573
2574 if libDepTag, ok := depTag.(libraryDependencyTag); ok {
2575 // Only use static unwinder for legacy (min_sdk_version = 29) apexes (b/144430859)
Dan Albertc8060532020-07-22 22:32:17 -07002576 if libDepTag.staticUnwinder && c.apexSdkVersion.GreaterThan(android.SdkVersion_Android10) {
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002577 return
2578 }
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002579
Jiyong Parke3867542020-12-03 17:28:25 +09002580 if !apexInfo.IsForPlatform() && libDepTag.excludeInApex {
2581 return
2582 }
2583
Colin Cross0de8a1e2020-09-18 14:15:30 -07002584 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
Colin Crossc99deeb2016-04-11 15:06:20 -07002585
Colin Cross6e511a92020-07-27 21:26:48 -07002586 var ptr *android.Paths
2587 var depPtr *android.Paths
Colin Crossc99deeb2016-04-11 15:06:20 -07002588
Colin Cross6e511a92020-07-27 21:26:48 -07002589 depFile := android.OptionalPath{}
Colin Cross26c34ed2016-09-30 17:10:16 -07002590
Colin Cross6e511a92020-07-27 21:26:48 -07002591 switch {
2592 case libDepTag.header():
Colin Cross649d8172020-12-10 12:30:21 -08002593 if !ctx.OtherModuleHasProvider(dep, HeaderLibraryInfoProvider) {
2594 if !ctx.Config().AllowMissingDependencies() {
2595 ctx.ModuleErrorf("module %q is not a header library", depName)
2596 } else {
2597 ctx.AddMissingDependencies([]string{depName})
2598 }
2599 return
2600 }
Colin Cross6e511a92020-07-27 21:26:48 -07002601 case libDepTag.shared():
Colin Cross0de8a1e2020-09-18 14:15:30 -07002602 if !ctx.OtherModuleHasProvider(dep, SharedLibraryInfoProvider) {
2603 if !ctx.Config().AllowMissingDependencies() {
2604 ctx.ModuleErrorf("module %q is not a shared library", depName)
2605 } else {
2606 ctx.AddMissingDependencies([]string{depName})
2607 }
2608 return
2609 }
Jiyong Parke3867542020-12-03 17:28:25 +09002610
Colin Cross0de8a1e2020-09-18 14:15:30 -07002611 sharedLibraryInfo := ctx.OtherModuleProvider(dep, SharedLibraryInfoProvider).(SharedLibraryInfo)
Chris Parsons3c27ca32020-11-20 12:42:07 -05002612 sharedLibraryStubsInfo := ctx.OtherModuleProvider(dep, SharedLibraryStubsProvider).(SharedLibraryStubsInfo)
Colin Cross0de8a1e2020-09-18 14:15:30 -07002613
Chris Parsons3c27ca32020-11-20 12:42:07 -05002614 if !libDepTag.explicitlyVersioned && len(sharedLibraryStubsInfo.SharedStubLibraries) > 0 {
Colin Cross0de8a1e2020-09-18 14:15:30 -07002615 useStubs := false
Colin Cross31076b32020-10-23 17:22:06 -07002616
2617 if lib := moduleLibraryInterface(dep); lib.buildStubs() && c.UseVndk() { // LLNDK
Colin Cross0de8a1e2020-09-18 14:15:30 -07002618 if !apexInfo.IsForPlatform() {
2619 // For platform libraries, use current version of LLNDK
2620 // If this is for use_vendor apex we will apply the same rules
2621 // of apex sdk enforcement below to choose right version.
2622 useStubs = true
2623 }
2624 } else if apexInfo.IsForPlatform() {
2625 // If not building for APEX, use stubs only when it is from
2626 // an APEX (and not from platform)
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002627 // However, for host, ramdisk, vendor_ramdisk, recovery or bootstrap modules,
Colin Cross0de8a1e2020-09-18 14:15:30 -07002628 // always link to non-stub variant
Jiyong Parkf7c3bbe2020-12-09 21:18:56 +09002629 useStubs = dep.(android.ApexModule).NotInPlatform() && !c.bootstrap()
Martin Stjernholm4e6c2692021-03-25 01:25:06 +00002630 if useStubs {
2631 // Another exception: if this module is a test for an APEX, then
2632 // it is linked with the non-stub variant of a module in the APEX
2633 // as if this is part of the APEX.
2634 testFor := ctx.Provider(android.ApexTestForInfoProvider).(android.ApexTestForInfo)
2635 for _, apexContents := range testFor.ApexContents {
2636 if apexContents.DirectlyInApex(depName) {
2637 useStubs = false
2638 break
2639 }
2640 }
2641 }
2642 if useStubs {
2643 // Yet another exception: If this module and the dependency are
2644 // available to the same APEXes then skip stubs between their
2645 // platform variants. This complements the test_for case above,
2646 // which avoids the stubs on a direct APEX library dependency, by
2647 // avoiding stubs for indirect test dependencies as well.
2648 //
2649 // TODO(b/183882457): This doesn't work if the two libraries have
2650 // only partially overlapping apex_available. For that test_for
2651 // modules would need to be split into APEX variants and resolved
2652 // separately for each APEX they have access to.
2653 if android.AvailableToSameApexes(c, dep.(android.ApexModule)) {
Colin Cross0de8a1e2020-09-18 14:15:30 -07002654 useStubs = false
Colin Cross0de8a1e2020-09-18 14:15:30 -07002655 }
2656 }
2657 } else {
2658 // If building for APEX, use stubs when the parent is in any APEX that
2659 // the child is not in.
2660 useStubs = !android.DirectlyInAllApexes(apexInfo, depName)
2661 }
2662
Jiyong Park55549df2021-02-26 23:57:23 +09002663 // when to use (unspecified) stubs, use the latest one.
Colin Cross0de8a1e2020-09-18 14:15:30 -07002664 if useStubs {
Jiyong Park55549df2021-02-26 23:57:23 +09002665 stubs := sharedLibraryStubsInfo.SharedStubLibraries
2666 toUse := stubs[len(stubs)-1]
2667 sharedLibraryInfo = toUse.SharedLibraryInfo
2668 depExporterInfo = toUse.FlagExporterInfo
Colin Cross0de8a1e2020-09-18 14:15:30 -07002669 }
2670 }
2671
Jiyong Park1ad8e162020-12-01 23:40:09 +09002672 // Stubs lib doesn't link to the shared lib dependencies. Don't set
2673 // linkFile, depFile, and ptr.
2674 if c.IsStubs() {
2675 break
2676 }
2677
Colin Cross0de8a1e2020-09-18 14:15:30 -07002678 linkFile = android.OptionalPathForPath(sharedLibraryInfo.SharedLibrary)
2679 depFile = sharedLibraryInfo.TableOfContents
2680
Colin Cross6e511a92020-07-27 21:26:48 -07002681 ptr = &depPaths.SharedLibs
2682 switch libDepTag.Order {
2683 case earlyLibraryDependency:
2684 ptr = &depPaths.EarlySharedLibs
2685 depPtr = &depPaths.EarlySharedLibsDeps
2686 case normalLibraryDependency:
2687 ptr = &depPaths.SharedLibs
2688 depPtr = &depPaths.SharedLibsDeps
Colin Cross0de8a1e2020-09-18 14:15:30 -07002689 directSharedDeps = append(directSharedDeps, sharedLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07002690 case lateLibraryDependency:
2691 ptr = &depPaths.LateSharedLibs
2692 depPtr = &depPaths.LateSharedLibsDeps
2693 default:
2694 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Colin Crossc99deeb2016-04-11 15:06:20 -07002695 }
Colin Cross6e511a92020-07-27 21:26:48 -07002696 case libDepTag.static():
Colin Cross0de8a1e2020-09-18 14:15:30 -07002697 if !ctx.OtherModuleHasProvider(dep, StaticLibraryInfoProvider) {
2698 if !ctx.Config().AllowMissingDependencies() {
2699 ctx.ModuleErrorf("module %q is not a static library", depName)
2700 } else {
2701 ctx.AddMissingDependencies([]string{depName})
2702 }
2703 return
2704 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002705
2706 // Stubs lib doesn't link to the static lib dependencies. Don't set
2707 // linkFile, depFile, and ptr.
2708 if c.IsStubs() {
2709 break
2710 }
2711
Colin Cross0de8a1e2020-09-18 14:15:30 -07002712 staticLibraryInfo := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
2713 linkFile = android.OptionalPathForPath(staticLibraryInfo.StaticLibrary)
Colin Cross6e511a92020-07-27 21:26:48 -07002714 if libDepTag.wholeStatic {
2715 ptr = &depPaths.WholeStaticLibs
Colin Cross0de8a1e2020-09-18 14:15:30 -07002716 if len(staticLibraryInfo.Objects.objFiles) > 0 {
2717 depPaths.WholeStaticLibObjs = depPaths.WholeStaticLibObjs.Append(staticLibraryInfo.Objects)
Inseob Kimeec88e12020-01-22 11:11:29 +09002718 } else {
Colin Cross0de8a1e2020-09-18 14:15:30 -07002719 // This case normally catches prebuilt static
2720 // libraries, but it can also occur when
2721 // AllowMissingDependencies is on and the
2722 // dependencies has no sources of its own
2723 // but has a whole_static_libs dependency
2724 // on a missing library. We want to depend
2725 // on the .a file so that there is something
2726 // in the dependency tree that contains the
2727 // error rule for the missing transitive
2728 // dependency.
2729 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07002730 }
Colin Cross6e511a92020-07-27 21:26:48 -07002731 } else {
2732 switch libDepTag.Order {
2733 case earlyLibraryDependency:
2734 panic(fmt.Errorf("early static libs not suppported"))
2735 case normalLibraryDependency:
2736 // static dependencies will be handled separately so they can be ordered
2737 // using transitive dependencies.
2738 ptr = nil
Colin Cross0de8a1e2020-09-18 14:15:30 -07002739 directStaticDeps = append(directStaticDeps, staticLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07002740 case lateLibraryDependency:
2741 ptr = &depPaths.LateStaticLibs
2742 default:
2743 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Inseob Kimeec88e12020-01-22 11:11:29 +09002744 }
2745 }
2746 }
2747
Colin Cross6e511a92020-07-27 21:26:48 -07002748 if libDepTag.static() && !libDepTag.wholeStatic {
2749 if !ccDep.CcLibraryInterface() || !ccDep.Static() {
2750 ctx.ModuleErrorf("module %q not a static library", depName)
2751 return
2752 }
Logan Chien43d34c32017-12-20 01:17:32 +08002753
Colin Cross6e511a92020-07-27 21:26:48 -07002754 // When combining coverage files for shared libraries and executables, coverage files
2755 // in static libraries act as if they were whole static libraries. The same goes for
2756 // source based Abi dump files.
2757 if c, ok := ccDep.(*Module); ok {
2758 staticLib := c.linker.(libraryInterface)
2759 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
2760 staticLib.objs().coverageFiles...)
2761 depPaths.StaticLibObjs.sAbiDumpFiles = append(depPaths.StaticLibObjs.sAbiDumpFiles,
2762 staticLib.objs().sAbiDumpFiles...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07002763 } else {
Colin Cross6e511a92020-07-27 21:26:48 -07002764 // Handle non-CC modules here
2765 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
Colin Cross0de8a1e2020-09-18 14:15:30 -07002766 ccDep.CoverageFiles()...)
Jiyong Parkde866cb2018-12-07 23:08:36 +09002767 }
2768 }
2769
Colin Cross6e511a92020-07-27 21:26:48 -07002770 if ptr != nil {
2771 if !linkFile.Valid() {
2772 if !ctx.Config().AllowMissingDependencies() {
2773 ctx.ModuleErrorf("module %q missing output file", depName)
2774 } else {
2775 ctx.AddMissingDependencies([]string{depName})
2776 }
2777 return
2778 }
2779 *ptr = append(*ptr, linkFile.Path())
2780 }
2781
2782 if depPtr != nil {
2783 dep := depFile
2784 if !dep.Valid() {
2785 dep = linkFile
2786 }
2787 *depPtr = append(*depPtr, dep.Path())
2788 }
2789
Colin Cross0de8a1e2020-09-18 14:15:30 -07002790 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
2791 depPaths.SystemIncludeDirs = append(depPaths.SystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
2792 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps, depExporterInfo.Deps...)
2793 depPaths.Flags = append(depPaths.Flags, depExporterInfo.Flags...)
2794
2795 if libDepTag.reexportFlags {
2796 reexportExporter(depExporterInfo)
2797 // Add these re-exported flags to help header-abi-dumper to infer the abi exported by a library.
2798 // Re-exported shared library headers must be included as well since they can help us with type information
2799 // about template instantiations (instantiated from their headers).
2800 // -isystem headers are not included since for bionic libraries, abi-filtering is taken care of by version
2801 // scripts.
2802 c.sabi.Properties.ReexportedIncludes = append(
2803 c.sabi.Properties.ReexportedIncludes, depExporterInfo.IncludeDirs.Strings()...)
2804 }
2805
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002806 makeLibName := MakeLibName(ctx, c, ccDep, depName) + libDepTag.makeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07002807 switch {
2808 case libDepTag.header():
Colin Cross370173e2020-07-29 12:48:33 -07002809 c.Properties.AndroidMkHeaderLibs = append(
2810 c.Properties.AndroidMkHeaderLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07002811 case libDepTag.shared():
Colin Cross31076b32020-10-23 17:22:06 -07002812 if lib := moduleLibraryInterface(dep); lib != nil {
2813 if lib.buildStubs() && dep.(android.ApexModule).InAnyApex() {
Colin Cross6e511a92020-07-27 21:26:48 -07002814 // Add the dependency to the APEX(es) providing the library so that
2815 // m <module> can trigger building the APEXes as well.
Colin Cross56a83212020-09-15 18:30:11 -07002816 depApexInfo := ctx.OtherModuleProvider(dep, android.ApexInfoProvider).(android.ApexInfo)
2817 for _, an := range depApexInfo.InApexes {
Colin Cross6e511a92020-07-27 21:26:48 -07002818 c.Properties.ApexesProvidingSharedLibs = append(
2819 c.Properties.ApexesProvidingSharedLibs, an)
2820 }
2821 }
2822 }
2823
2824 // Note: the order of libs in this list is not important because
2825 // they merely serve as Make dependencies and do not affect this lib itself.
Colin Cross370173e2020-07-29 12:48:33 -07002826 c.Properties.AndroidMkSharedLibs = append(
2827 c.Properties.AndroidMkSharedLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07002828 // Record baseLibName for snapshots.
2829 c.Properties.SnapshotSharedLibs = append(c.Properties.SnapshotSharedLibs, baseLibName(depName))
2830 case libDepTag.static():
2831 if libDepTag.wholeStatic {
2832 c.Properties.AndroidMkWholeStaticLibs = append(
2833 c.Properties.AndroidMkWholeStaticLibs, makeLibName)
2834 } else {
2835 c.Properties.AndroidMkStaticLibs = append(
2836 c.Properties.AndroidMkStaticLibs, makeLibName)
2837 }
2838 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002839 } else if !c.IsStubs() {
2840 // Stubs lib doesn't link to the runtime lib, object, crt, etc. dependencies.
2841
Colin Cross6e511a92020-07-27 21:26:48 -07002842 switch depTag {
2843 case runtimeDepTag:
2844 c.Properties.AndroidMkRuntimeLibs = append(
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002845 c.Properties.AndroidMkRuntimeLibs, MakeLibName(ctx, c, ccDep, depName)+libDepTag.makeSuffix)
Colin Cross6e511a92020-07-27 21:26:48 -07002846 // Record baseLibName for snapshots.
2847 c.Properties.SnapshotRuntimeLibs = append(c.Properties.SnapshotRuntimeLibs, baseLibName(depName))
2848 case objDepTag:
2849 depPaths.Objs.objFiles = append(depPaths.Objs.objFiles, linkFile.Path())
2850 case CrtBeginDepTag:
2851 depPaths.CrtBegin = linkFile
2852 case CrtEndDepTag:
2853 depPaths.CrtEnd = linkFile
2854 case dynamicLinkerDepTag:
2855 depPaths.DynamicLinker = linkFile
2856 }
Jiyong Park27b188b2017-07-18 13:23:39 +09002857 }
Colin Crossca860ac2016-01-04 14:34:37 -08002858 })
2859
Jeff Gaston294356f2017-09-27 17:05:30 -07002860 // use the ordered dependencies as this module's dependencies
Colin Cross0de8a1e2020-09-18 14:15:30 -07002861 orderedStaticPaths, transitiveStaticLibs := orderStaticModuleDeps(directStaticDeps, directSharedDeps)
2862 depPaths.TranstiveStaticLibrariesForOrdering = transitiveStaticLibs
2863 depPaths.StaticLibs = append(depPaths.StaticLibs, orderedStaticPaths...)
Jeff Gaston294356f2017-09-27 17:05:30 -07002864
Colin Crossdd84e052017-05-17 13:44:16 -07002865 // Dedup exported flags from dependencies
Colin Crossb6715442017-10-24 11:13:31 -07002866 depPaths.Flags = android.FirstUniqueStrings(depPaths.Flags)
Jiyong Park74955042019-10-22 20:19:51 +09002867 depPaths.IncludeDirs = android.FirstUniquePaths(depPaths.IncludeDirs)
2868 depPaths.SystemIncludeDirs = android.FirstUniquePaths(depPaths.SystemIncludeDirs)
Inseob Kimd110f872019-12-06 13:15:38 +09002869 depPaths.GeneratedDeps = android.FirstUniquePaths(depPaths.GeneratedDeps)
Jiyong Park74955042019-10-22 20:19:51 +09002870 depPaths.ReexportedDirs = android.FirstUniquePaths(depPaths.ReexportedDirs)
2871 depPaths.ReexportedSystemDirs = android.FirstUniquePaths(depPaths.ReexportedSystemDirs)
Colin Crossb6715442017-10-24 11:13:31 -07002872 depPaths.ReexportedFlags = android.FirstUniqueStrings(depPaths.ReexportedFlags)
Inseob Kim69378442019-06-03 19:10:47 +09002873 depPaths.ReexportedDeps = android.FirstUniquePaths(depPaths.ReexportedDeps)
Inseob Kimd110f872019-12-06 13:15:38 +09002874 depPaths.ReexportedGeneratedHeaders = android.FirstUniquePaths(depPaths.ReexportedGeneratedHeaders)
Dan Willemsenfe92c962017-08-29 12:28:37 -07002875
2876 if c.sabi != nil {
Inseob Kim69378442019-06-03 19:10:47 +09002877 c.sabi.Properties.ReexportedIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedIncludes)
Dan Willemsenfe92c962017-08-29 12:28:37 -07002878 }
Colin Crossdd84e052017-05-17 13:44:16 -07002879
Colin Crossca860ac2016-01-04 14:34:37 -08002880 return depPaths
2881}
2882
Colin Cross0de8a1e2020-09-18 14:15:30 -07002883// orderStaticModuleDeps rearranges the order of the static library dependencies of the module
2884// to match the topological order of the dependency tree, including any static analogues of
2885// direct shared libraries. It returns the ordered static dependencies, and an android.DepSet
2886// of the transitive dependencies.
2887func orderStaticModuleDeps(staticDeps []StaticLibraryInfo, sharedDeps []SharedLibraryInfo) (ordered android.Paths, transitive *android.DepSet) {
2888 transitiveStaticLibsBuilder := android.NewDepSetBuilder(android.TOPOLOGICAL)
2889 var staticPaths android.Paths
2890 for _, staticDep := range staticDeps {
2891 staticPaths = append(staticPaths, staticDep.StaticLibrary)
2892 transitiveStaticLibsBuilder.Transitive(staticDep.TransitiveStaticLibrariesForOrdering)
2893 }
2894 for _, sharedDep := range sharedDeps {
2895 if sharedDep.StaticAnalogue != nil {
2896 transitiveStaticLibsBuilder.Transitive(sharedDep.StaticAnalogue.TransitiveStaticLibrariesForOrdering)
2897 }
2898 }
2899 transitiveStaticLibs := transitiveStaticLibsBuilder.Build()
2900
2901 orderedTransitiveStaticLibs := transitiveStaticLibs.ToList()
2902
2903 // reorder the dependencies based on transitive dependencies
2904 staticPaths = android.FirstUniquePaths(staticPaths)
2905 _, orderedStaticPaths := android.FilterPathList(orderedTransitiveStaticLibs, staticPaths)
2906
2907 if len(orderedStaticPaths) != len(staticPaths) {
2908 missing, _ := android.FilterPathList(staticPaths, orderedStaticPaths)
2909 panic(fmt.Errorf("expected %d ordered static paths , got %d, missing %q %q %q", len(staticPaths), len(orderedStaticPaths), missing, orderedStaticPaths, staticPaths))
2910 }
2911
2912 return orderedStaticPaths, transitiveStaticLibs
2913}
2914
Colin Cross6e511a92020-07-27 21:26:48 -07002915// baseLibName trims known prefixes and suffixes
2916func baseLibName(depName string) string {
2917 libName := strings.TrimSuffix(depName, llndkLibrarySuffix)
2918 libName = strings.TrimSuffix(libName, vendorPublicLibrarySuffix)
Paul Duffind23c7262020-12-11 18:13:08 +00002919 libName = android.RemoveOptionalPrebuiltPrefix(libName)
Colin Cross6e511a92020-07-27 21:26:48 -07002920 return libName
2921}
2922
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002923func MakeLibName(ctx android.ModuleContext, c LinkableInterface, ccDep LinkableInterface, depName string) string {
2924
Colin Cross6e511a92020-07-27 21:26:48 -07002925 vendorPublicLibraries := vendorPublicLibraries(ctx.Config())
2926
2927 libName := baseLibName(depName)
Colin Cross127bb8b2020-12-16 16:46:01 -08002928 ccDepModule, _ := ccDep.(*Module)
2929 isLLndk := ccDepModule != nil && ccDepModule.IsLlndk()
Colin Cross6e511a92020-07-27 21:26:48 -07002930 isVendorPublicLib := inList(libName, *vendorPublicLibraries)
Justin Yuncbca3732021-02-03 19:24:13 +09002931 nonSystemVariantsExist := ccDep.HasNonSystemVariants() || isLLndk
Colin Cross6e511a92020-07-27 21:26:48 -07002932
Justin Yuncbca3732021-02-03 19:24:13 +09002933 if ccDepModule != nil {
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002934 // TODO(ivanlozano) Support snapshots for Rust-produced C library variants.
Colin Cross6e511a92020-07-27 21:26:48 -07002935 // Use base module name for snapshots when exporting to Makefile.
Justin Yuncbca3732021-02-03 19:24:13 +09002936 if snapshotPrebuilt, ok := ccDepModule.linker.(snapshotInterface); ok {
2937 baseName := ccDepModule.BaseModuleName()
Colin Cross6e511a92020-07-27 21:26:48 -07002938
Colin Crossa8890802021-01-22 14:06:33 -08002939 return baseName + snapshotPrebuilt.snapshotAndroidMkSuffix()
Colin Cross6e511a92020-07-27 21:26:48 -07002940 }
2941 }
2942
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002943 if ctx.DeviceConfig().VndkUseCoreVariant() && ccDep.IsVndk() && !ccDep.MustUseVendorVariant() &&
2944 !c.InRamdisk() && !c.InVendorRamdisk() && !c.InRecovery() {
Colin Cross6e511a92020-07-27 21:26:48 -07002945 // The vendor module is a no-vendor-variant VNDK library. Depend on the
2946 // core module instead.
2947 return libName
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002948 } else if ccDep.UseVndk() && nonSystemVariantsExist {
Justin Yuncbca3732021-02-03 19:24:13 +09002949 // The vendor and product modules in Make will have been renamed to not conflict with the
2950 // core module, so update the dependency name here accordingly.
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002951 return libName + ccDep.SubName()
Colin Cross6e511a92020-07-27 21:26:48 -07002952 } else if (ctx.Platform() || ctx.ProductSpecific()) && isVendorPublicLib {
2953 return libName + vendorPublicLibrarySuffix
2954 } else if ccDep.InRamdisk() && !ccDep.OnlyInRamdisk() {
2955 return libName + ramdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002956 } else if ccDep.InVendorRamdisk() && !ccDep.OnlyInVendorRamdisk() {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05002957 return libName + VendorRamdiskSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07002958 } else if ccDep.InRecovery() && !ccDep.OnlyInRecovery() {
2959 return libName + recoverySuffix
Ivan Lozanof9e21722020-12-02 09:00:51 -05002960 } else if ccDep.Target().NativeBridge == android.NativeBridgeEnabled {
Colin Cross6e511a92020-07-27 21:26:48 -07002961 return libName + nativeBridgeSuffix
2962 } else {
2963 return libName
2964 }
2965}
2966
Colin Crossca860ac2016-01-04 14:34:37 -08002967func (c *Module) InstallInData() bool {
2968 if c.installer == nil {
2969 return false
2970 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07002971 return c.installer.inData()
2972}
2973
2974func (c *Module) InstallInSanitizerDir() bool {
2975 if c.installer == nil {
2976 return false
2977 }
2978 if c.sanitize != nil && c.sanitize.inSanitizerDir() {
Colin Cross94610402016-08-29 13:41:32 -07002979 return true
2980 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07002981 return c.installer.inSanitizerDir()
Colin Crossca860ac2016-01-04 14:34:37 -08002982}
2983
Yifan Hong1b3348d2020-01-21 15:53:22 -08002984func (c *Module) InstallInRamdisk() bool {
2985 return c.InRamdisk()
2986}
2987
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002988func (c *Module) InstallInVendorRamdisk() bool {
2989 return c.InVendorRamdisk()
2990}
2991
Jiyong Parkf9332f12018-02-01 00:54:12 +09002992func (c *Module) InstallInRecovery() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07002993 return c.InRecovery()
Jiyong Parkf9332f12018-02-01 00:54:12 +09002994}
2995
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01002996func (c *Module) MakeUninstallable() {
Martin Stjernholmbf37d162020-03-31 16:05:34 +01002997 if c.installer == nil {
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01002998 c.ModuleBase.MakeUninstallable()
Martin Stjernholmbf37d162020-03-31 16:05:34 +01002999 return
3000 }
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01003001 c.installer.makeUninstallable(c)
Martin Stjernholmbf37d162020-03-31 16:05:34 +01003002}
3003
Dan Willemsen4aa75ca2016-09-28 16:18:03 -07003004func (c *Module) HostToolPath() android.OptionalPath {
3005 if c.installer == nil {
3006 return android.OptionalPath{}
3007 }
3008 return c.installer.hostToolPath()
3009}
3010
Nan Zhangd4e641b2017-07-12 12:55:28 -07003011func (c *Module) IntermPathForModuleOut() android.OptionalPath {
3012 return c.outputFile
3013}
3014
Colin Cross41955e82019-05-29 14:40:35 -07003015func (c *Module) OutputFiles(tag string) (android.Paths, error) {
3016 switch tag {
3017 case "":
3018 if c.outputFile.Valid() {
3019 return android.Paths{c.outputFile.Path()}, nil
3020 }
3021 return android.Paths{}, nil
3022 default:
3023 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003024 }
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003025}
3026
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00003027func (c *Module) static() bool {
3028 if static, ok := c.linker.(interface {
3029 static() bool
3030 }); ok {
3031 return static.static()
3032 }
3033 return false
3034}
3035
Jiyong Park379de2f2018-12-19 02:47:14 +09003036func (c *Module) staticBinary() bool {
3037 if static, ok := c.linker.(interface {
3038 staticBinary() bool
3039 }); ok {
3040 return static.staticBinary()
3041 }
3042 return false
3043}
3044
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07003045func (c *Module) testBinary() bool {
3046 if test, ok := c.linker.(interface {
3047 testBinary() bool
3048 }); ok {
3049 return test.testBinary()
3050 }
3051 return false
3052}
3053
Ivan Lozano3968d8f2020-12-14 11:27:52 -05003054// Header returns true if the module is a header-only variant. (See cc/library.go header()).
3055func (c *Module) Header() bool {
Jiyong Park1d1119f2019-07-29 21:27:18 +09003056 if h, ok := c.linker.(interface {
3057 header() bool
3058 }); ok {
3059 return h.header()
3060 }
3061 return false
3062}
3063
Inseob Kim7f283f42020-06-01 21:53:49 +09003064func (c *Module) binary() bool {
3065 if b, ok := c.linker.(interface {
3066 binary() bool
3067 }); ok {
3068 return b.binary()
3069 }
3070 return false
3071}
3072
Inseob Kim1042d292020-06-01 23:23:05 +09003073func (c *Module) object() bool {
3074 if o, ok := c.linker.(interface {
3075 object() bool
3076 }); ok {
3077 return o.object()
3078 }
3079 return false
3080}
3081
Ivan Lozanof9e21722020-12-02 09:00:51 -05003082func GetMakeLinkType(actx android.ModuleContext, c LinkableInterface) string {
Ivan Lozano52767be2019-10-18 14:49:46 -07003083 if c.UseVndk() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003084 if c.IsLlndk() {
3085 if !c.IsLlndkPublic() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003086 return "native:vndk_private"
Colin Crossb60190a2018-09-04 16:28:17 -07003087 }
Colin Cross127bb8b2020-12-16 16:46:01 -08003088 return "native:vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07003089 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003090 if c.IsVndk() && !c.IsVndkExt() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003091 if c.IsVndkPrivate() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003092 return "native:vndk_private"
Jooyung Han38002912019-05-16 04:01:54 +09003093 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003094 return "native:vndk"
Jooyung Han38002912019-05-16 04:01:54 +09003095 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003096 if c.InProduct() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09003097 return "native:product"
3098 }
Jooyung Han38002912019-05-16 04:01:54 +09003099 return "native:vendor"
Yifan Hong1b3348d2020-01-21 15:53:22 -08003100 } else if c.InRamdisk() {
3101 return "native:ramdisk"
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003102 } else if c.InVendorRamdisk() {
3103 return "native:vendor_ramdisk"
Ivan Lozano52767be2019-10-18 14:49:46 -07003104 } else if c.InRecovery() {
Colin Crossb60190a2018-09-04 16:28:17 -07003105 return "native:recovery"
Ivan Lozanof9e21722020-12-02 09:00:51 -05003106 } else if c.Target().Os == android.Android && c.SdkVersion() != "" {
Colin Crossb60190a2018-09-04 16:28:17 -07003107 return "native:ndk:none:none"
3108 // TODO(b/114741097): use the correct ndk stl once build errors have been fixed
3109 //family, link := getNdkStlFamilyAndLinkType(c)
3110 //return fmt.Sprintf("native:ndk:%s:%s", family, link)
Ivan Lozano52767be2019-10-18 14:49:46 -07003111 } else if actx.DeviceConfig().VndkUseCoreVariant() && !c.MustUseVendorVariant() {
Vic Yangefd249e2018-11-12 20:19:56 -08003112 return "native:platform_vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07003113 } else {
3114 return "native:platform"
3115 }
3116}
3117
Jiyong Park9d452992018-10-03 00:38:19 +09003118// Overrides ApexModule.IsInstallabeToApex()
Roland Levillainf89cd092019-07-29 16:22:59 +01003119// Only shared/runtime libraries and "test_per_src" tests are installable to APEX.
Jiyong Park9d452992018-10-03 00:38:19 +09003120func (c *Module) IsInstallableToApex() bool {
Colin Cross31076b32020-10-23 17:22:06 -07003121 if lib := c.library; lib != nil {
Jiyong Park73c54ee2019-10-22 20:31:18 +09003122 // Stub libs and prebuilt libs in a versioned SDK are not
3123 // installable to APEX even though they are shared libs.
Colin Cross31076b32020-10-23 17:22:06 -07003124 return lib.shared() && !lib.buildStubs() && c.ContainingSdk().Unversioned()
Roland Levillainf89cd092019-07-29 16:22:59 +01003125 } else if _, ok := c.linker.(testPerSrc); ok {
3126 return true
Jiyong Park9d452992018-10-03 00:38:19 +09003127 }
3128 return false
3129}
3130
Jiyong Parka90ca002019-10-07 15:47:24 +09003131func (c *Module) AvailableFor(what string) bool {
3132 if linker, ok := c.linker.(interface {
3133 availableFor(string) bool
3134 }); ok {
3135 return c.ApexModuleBase.AvailableFor(what) || linker.availableFor(what)
3136 } else {
3137 return c.ApexModuleBase.AvailableFor(what)
3138 }
3139}
3140
Jiyong Park62304bb2020-04-13 16:19:48 +09003141func (c *Module) TestFor() []string {
Jiyong Park46a512f2020-12-04 18:02:13 +09003142 return c.Properties.Test_for
Jiyong Park62304bb2020-04-13 16:19:48 +09003143}
3144
Colin Crossaede88c2020-08-11 12:17:01 -07003145func (c *Module) UniqueApexVariations() bool {
3146 if u, ok := c.compiler.(interface {
3147 uniqueApexVariations() bool
3148 }); ok {
3149 return u.uniqueApexVariations()
3150 } else {
3151 return false
3152 }
3153}
3154
Paul Duffin0cb37b92020-03-04 14:52:46 +00003155// Return true if the module is ever installable.
3156func (c *Module) EverInstallable() bool {
3157 return c.installer != nil &&
3158 // Check to see whether the module is actually ever installable.
3159 c.installer.everInstallable()
3160}
3161
Colin Cross56a83212020-09-15 18:30:11 -07003162func (c *Module) installable(apexInfo android.ApexInfo) bool {
Paul Duffin0cb37b92020-03-04 14:52:46 +00003163 ret := c.EverInstallable() &&
3164 // Check to see whether the module has been configured to not be installed.
3165 proptools.BoolDefault(c.Properties.Installable, true) &&
3166 !c.Properties.PreventInstall && c.outputFile.Valid()
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003167
3168 // The platform variant doesn't need further condition. Apex variants however might not
3169 // be installable because it will likely to be included in the APEX and won't appear
3170 // in the system partition.
Colin Cross56a83212020-09-15 18:30:11 -07003171 if apexInfo.IsForPlatform() {
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003172 return ret
3173 }
3174
3175 // Special case for modules that are configured to be installed to /data, which includes
3176 // test modules. For these modules, both APEX and non-APEX variants are considered as
3177 // installable. This is because even the APEX variants won't be included in the APEX, but
3178 // will anyway be installed to /data/*.
3179 // See b/146995717
3180 if c.InstallInData() {
3181 return ret
3182 }
3183
3184 return false
Inseob Kim1f086e22019-05-09 13:29:15 +09003185}
3186
Logan Chien41eabe62019-04-10 13:33:58 +08003187func (c *Module) AndroidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer) {
3188 if c.linker != nil {
3189 if library, ok := c.linker.(*libraryDecorator); ok {
3190 library.androidMkWriteAdditionalDependenciesForSourceAbiDiff(w)
3191 }
3192 }
3193}
3194
Jiyong Park45bf82e2020-12-15 22:29:02 +09003195var _ android.ApexModule = (*Module)(nil)
3196
3197// Implements android.ApexModule
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003198func (c *Module) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
Colin Cross6e511a92020-07-27 21:26:48 -07003199 depTag := ctx.OtherModuleDependencyTag(dep)
3200 libDepTag, isLibDepTag := depTag.(libraryDependencyTag)
3201
3202 if cc, ok := dep.(*Module); ok {
3203 if cc.HasStubsVariants() {
3204 if isLibDepTag && libDepTag.shared() {
3205 // dynamic dep to a stubs lib crosses APEX boundary
3206 return false
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003207 }
Colin Cross6e511a92020-07-27 21:26:48 -07003208 if IsRuntimeDepTag(depTag) {
3209 // runtime dep to a stubs lib also crosses APEX boundary
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003210 return false
3211 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003212 }
Colin Crossaac32222020-07-29 12:51:56 -07003213 if isLibDepTag && c.static() && libDepTag.shared() {
Colin Cross6e511a92020-07-27 21:26:48 -07003214 // shared_lib dependency from a static lib is considered as crossing
3215 // the APEX boundary because the dependency doesn't actually is
3216 // linked; the dependency is used only during the compilation phase.
3217 return false
3218 }
Jiyong Parke3867542020-12-03 17:28:25 +09003219
3220 if isLibDepTag && libDepTag.excludeInApex {
3221 return false
3222 }
Colin Cross6e511a92020-07-27 21:26:48 -07003223 }
Colin Cross127bb8b2020-12-16 16:46:01 -08003224 if depTag == stubImplDepTag || depTag == llndkStubDepTag {
Colin Cross0de8a1e2020-09-18 14:15:30 -07003225 // We don't track beyond LLNDK or from an implementation library to its stubs.
Jiyong Park7d95a512020-05-10 15:16:24 +09003226 return false
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003227 }
Jiyong Park12177fc2021-01-05 14:37:15 +09003228 if depTag == staticVariantTag {
3229 // This dependency is for optimization (reuse *.o from the static lib). It doesn't
3230 // actually mean that the static lib (and its dependencies) are copied into the
3231 // APEX.
3232 return false
3233 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003234 return true
3235}
3236
Jiyong Park45bf82e2020-12-15 22:29:02 +09003237// Implements android.ApexModule
Dan Albertc8060532020-07-22 22:32:17 -07003238func (c *Module) ShouldSupportSdkVersion(ctx android.BaseModuleContext,
3239 sdkVersion android.ApiLevel) error {
Jooyung Han749dc692020-04-15 11:03:39 +09003240 // We ignore libclang_rt.* prebuilt libs since they declare sdk_version: 14(b/121358700)
3241 if strings.HasPrefix(ctx.OtherModuleName(c), "libclang_rt") {
3242 return nil
3243 }
3244 // b/154569636: set min_sdk_version correctly for toolchain_libraries
3245 if c.ToolchainLibrary() {
3246 return nil
3247 }
3248 // We don't check for prebuilt modules
3249 if _, ok := c.linker.(prebuiltLinkerInterface); ok {
3250 return nil
3251 }
3252 minSdkVersion := c.MinSdkVersion()
3253 if minSdkVersion == "apex_inherit" {
3254 return nil
3255 }
3256 if minSdkVersion == "" {
3257 // JNI libs within APK-in-APEX fall into here
3258 // Those are okay to set sdk_version instead
3259 // We don't have to check if this is a SDK variant because
3260 // non-SDK variant resets sdk_version, which works too.
3261 minSdkVersion = c.SdkVersion()
3262 }
Dan Albertc8060532020-07-22 22:32:17 -07003263 if minSdkVersion == "" {
3264 return fmt.Errorf("neither min_sdk_version nor sdk_version specificed")
3265 }
3266 // Not using nativeApiLevelFromUser because the context here is not
3267 // necessarily a native context.
3268 ver, err := android.ApiLevelFromUser(ctx, minSdkVersion)
Jooyung Han749dc692020-04-15 11:03:39 +09003269 if err != nil {
3270 return err
3271 }
Dan Albertc8060532020-07-22 22:32:17 -07003272
3273 if ver.GreaterThan(sdkVersion) {
Jooyung Han749dc692020-04-15 11:03:39 +09003274 return fmt.Errorf("newer SDK(%v)", ver)
3275 }
3276 return nil
3277}
3278
Colin Cross2ba19d92015-05-07 15:44:20 -07003279//
Colin Crosscfad1192015-11-02 16:43:11 -08003280// Defaults
3281//
Colin Crossca860ac2016-01-04 14:34:37 -08003282type Defaults struct {
Colin Cross635c3b02016-05-18 15:37:25 -07003283 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -07003284 android.DefaultsModuleBase
Liz Kammer3cf52112021-03-31 15:42:03 -04003285 // Included to support setting bazel_module.label for multiple Soong modules to the same Bazel
3286 // target. This is primarily useful for modules that were architecture specific and instead are
3287 // handled in Bazel as a select().
3288 android.BazelModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +09003289 android.ApexModuleBase
Colin Crosscfad1192015-11-02 16:43:11 -08003290}
3291
Patrice Arrudac249c712019-03-19 17:00:29 -07003292// cc_defaults provides a set of properties that can be inherited by other cc
3293// modules. A module can use the properties from a cc_defaults using
3294// `defaults: ["<:default_module_name>"]`. Properties of both modules are
3295// merged (when possible) by prepending the default module's values to the
3296// depending module's values.
Colin Cross36242852017-06-23 15:06:31 -07003297func defaultsFactory() android.Module {
Colin Crosse1d764e2016-08-18 14:18:32 -07003298 return DefaultsFactory()
3299}
3300
Colin Cross36242852017-06-23 15:06:31 -07003301func DefaultsFactory(props ...interface{}) android.Module {
Colin Crossca860ac2016-01-04 14:34:37 -08003302 module := &Defaults{}
Colin Crosscfad1192015-11-02 16:43:11 -08003303
Colin Cross36242852017-06-23 15:06:31 -07003304 module.AddProperties(props...)
3305 module.AddProperties(
Colin Crossca860ac2016-01-04 14:34:37 -08003306 &BaseProperties{},
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003307 &VendorProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003308 &BaseCompilerProperties{},
3309 &BaseLinkerProperties{},
Paul Duffina37832a2019-07-18 12:31:26 +01003310 &ObjectLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003311 &LibraryProperties{},
Colin Crosse1bb5d02019-09-24 14:55:04 -07003312 &StaticProperties{},
3313 &SharedProperties{},
Colin Cross919281a2016-04-05 16:42:05 -07003314 &FlagExporterProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003315 &BinaryLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003316 &TestProperties{},
3317 &TestBinaryProperties{},
Colin Cross43287652020-06-30 10:15:07 -07003318 &BenchmarkProperties{},
Mitch Phillips4e4ab8a2019-09-13 17:32:50 -07003319 &FuzzProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003320 &StlProperties{},
Colin Cross16b23492016-01-06 14:41:07 -08003321 &SanitizeProperties{},
Colin Cross665dce92016-04-28 14:50:03 -07003322 &StripProperties{},
Dan Willemsen7424d612016-09-01 13:45:39 -07003323 &InstallerProperties{},
Dan Willemsena03cf6d2016-09-26 15:45:04 -07003324 &TidyProperties{},
Dan Willemsen581341d2017-02-09 16:16:31 -08003325 &CoverageProperties{},
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08003326 &SAbiProperties{},
Justin Yun4b2382f2017-07-26 14:22:10 +09003327 &VndkProperties{},
Stephen Craneba090d12017-05-09 15:44:35 -07003328 &LTOProperties{},
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07003329 &PgoProperties{},
Dan Willemsen6424d172018-03-08 13:27:59 -08003330 &android.ProtoProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -04003331 // RustBindgenProperties is included here so that cc_defaults can be used for rust_bindgen modules.
3332 &RustBindgenClangProperties{},
Colin Crosse1d764e2016-08-18 14:18:32 -07003333 )
Colin Crosscfad1192015-11-02 16:43:11 -08003334
Liz Kammer3cf52112021-03-31 15:42:03 -04003335 // Bazel module must be initialized _before_ Defaults to be included in cc_defaults module.
3336 android.InitBazelModule(module)
Jooyung Hancc372c52019-09-25 15:18:44 +09003337 android.InitDefaultsModule(module)
Colin Cross36242852017-06-23 15:06:31 -07003338
3339 return module
Colin Crosscfad1192015-11-02 16:43:11 -08003340}
3341
Jiyong Park2286afd2020-06-16 21:58:53 +09003342func (c *Module) IsSdkVariant() bool {
Dan Albert92fe7402020-07-15 13:33:30 -07003343 return c.Properties.IsSdkVariant || c.AlwaysSdk()
Jiyong Park2286afd2020-06-16 21:58:53 +09003344}
3345
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003346func kytheExtractAllFactory() android.Singleton {
3347 return &kytheExtractAllSingleton{}
3348}
3349
3350type kytheExtractAllSingleton struct {
3351}
3352
3353func (ks *kytheExtractAllSingleton) GenerateBuildActions(ctx android.SingletonContext) {
3354 var xrefTargets android.Paths
3355 ctx.VisitAllModules(func(module android.Module) {
3356 if ccModule, ok := module.(xref); ok {
3357 xrefTargets = append(xrefTargets, ccModule.XrefCcFiles()...)
3358 }
3359 })
3360 // TODO(asmundak): Perhaps emit a rule to output a warning if there were no xrefTargets
3361 if len(xrefTargets) > 0 {
Colin Crossc3d87d32020-06-04 13:25:17 -07003362 ctx.Phony("xref_cxx", xrefTargets...)
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003363 }
3364}
3365
Colin Cross06a931b2015-10-28 17:23:31 -07003366var Bool = proptools.Bool
Colin Cross38b40df2018-04-10 16:14:46 -07003367var BoolDefault = proptools.BoolDefault
Nan Zhang0007d812017-11-07 10:57:05 -08003368var BoolPtr = proptools.BoolPtr
3369var String = proptools.String
3370var StringPtr = proptools.StringPtr