blob: 91c4417826721c44751ccc7296d92d75d561d20d [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 Cross5271fea2021-04-27 13:06:04 -0700450
451 // IsVendorPublicLibrary is set for the core and product variants of a library that has
452 // vendor_public_library stubs.
453 IsVendorPublicLibrary bool `blueprint:"mutated"`
Colin Crossca860ac2016-01-04 14:34:37 -0800454}
455
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500456// ModuleContextIntf is an interface (on a module context helper) consisting of functions related
457// to understanding details about the type of the current module.
458// For example, one might call these functions to determine whether the current module is a static
459// library and/or is installed in vendor directories.
Colin Crossca860ac2016-01-04 14:34:37 -0800460type ModuleContextIntf interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800461 static() bool
462 staticBinary() bool
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -0700463 testBinary() bool
Jiyong Park1d1119f2019-07-29 21:27:18 +0900464 header() bool
Inseob Kim7f283f42020-06-01 21:53:49 +0900465 binary() bool
Inseob Kim1042d292020-06-01 23:23:05 +0900466 object() bool
Colin Crossb98c8b02016-07-29 13:44:28 -0700467 toolchain() config.Toolchain
Jooyung Hanccce2f22020-03-07 03:45:53 +0900468 canUseSdk() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700469 useSdk() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800470 sdkVersion() string
Jiyong Parkb35a8192020-08-10 15:59:36 +0900471 minSdkVersion() string
472 isSdkVariant() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700473 useVndk() bool
Colin Cross95f1ca02020-10-29 20:47:22 -0700474 isNdk(config android.Config) bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800475 IsLlndk() bool
476 IsLlndkPublic() bool
477 isImplementationForLLNDKPublic() bool
478 IsVndkPrivate() bool
Justin Yun8effde42017-06-23 19:24:43 +0900479 isVndk() bool
480 isVndkSp() bool
Ivan Lozanof9e21722020-12-02 09:00:51 -0500481 IsVndkExt() bool
Colin Cross5271fea2021-04-27 13:06:04 -0700482 IsVendorPublicLibrary() bool
Justin Yun5f7f7e82019-11-18 19:52:14 +0900483 inProduct() bool
484 inVendor() bool
Yifan Hong1b3348d2020-01-21 15:53:22 -0800485 inRamdisk() bool
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700486 inVendorRamdisk() bool
Jiyong Parkf9332f12018-02-01 00:54:12 +0900487 inRecovery() bool
Dan Willemsen8146b2f2016-03-30 21:00:30 -0700488 selectedStl() string
Colin Crossce75d2c2016-10-06 16:12:58 -0700489 baseModuleName() string
Logan Chienf3511742017-10-31 18:04:35 +0800490 getVndkExtendsModuleName() string
Yi Kong7e53c572018-02-14 18:16:12 +0800491 isPgoCompile() bool
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800492 isNDKStubLibrary() bool
Ivan Lozanobd721262018-11-27 14:33:03 -0800493 useClangLld(actx ModuleContext) bool
Logan Chiene274fc92019-12-03 11:18:32 -0800494 isForPlatform() bool
Colin Crosse07f2312020-08-13 11:24:56 -0700495 apexVariationName() string
Dan Albertc8060532020-07-22 22:32:17 -0700496 apexSdkVersion() android.ApiLevel
Jiyong Parka4b9dd02019-01-16 22:53:13 +0900497 bootstrap() bool
Vic Yangefd249e2018-11-12 20:19:56 -0800498 mustUseVendorVariant() bool
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700499 nativeCoverage() bool
Colin Cross56a83212020-09-15 18:30:11 -0700500 directlyInAnyApex() bool
Colin Cross95b07f22020-12-16 11:06:50 -0800501 isPreventInstall() bool
Cindy Zhou5d5cfc12021-01-09 08:25:22 -0800502 isCfiAssemblySupportEnabled() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800503}
504
505type ModuleContext interface {
Colin Cross635c3b02016-05-18 15:37:25 -0700506 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800507 ModuleContextIntf
508}
509
510type BaseModuleContext interface {
Colin Cross0ea8ba82019-06-06 14:33:29 -0700511 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800512 ModuleContextIntf
513}
514
Colin Cross37047f12016-12-13 17:06:13 -0800515type DepsContext interface {
516 android.BottomUpMutatorContext
517 ModuleContextIntf
518}
519
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500520// feature represents additional (optional) steps to building cc-related modules, such as invocation
521// of clang-tidy.
Colin Crossca860ac2016-01-04 14:34:37 -0800522type feature interface {
523 begin(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800524 deps(ctx DepsContext, deps Deps) Deps
Colin Crossca860ac2016-01-04 14:34:37 -0800525 flags(ctx ModuleContext, flags Flags) Flags
526 props() []interface{}
527}
528
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500529// compiler is the interface for a compiler helper object. Different module decorators may implement
530// this helper differently. For example, compiling a `cc_library` may use a different build
531// statement than building a `toolchain_library`.
Colin Crossca860ac2016-01-04 14:34:37 -0800532type compiler interface {
Colin Cross42742b82016-08-01 13:20:05 -0700533 compilerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800534 compilerDeps(ctx DepsContext, deps Deps) Deps
Colin Crossf18e1102017-11-16 14:33:08 -0800535 compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
Colin Cross42742b82016-08-01 13:20:05 -0700536 compilerProps() []interface{}
537
Colin Cross76fada02016-07-27 10:31:13 -0700538 appendCflags([]string)
539 appendAsflags([]string)
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700540 compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects
Colin Crossca860ac2016-01-04 14:34:37 -0800541}
542
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500543// linker is the interface for a linker decorator object. Individual module types can provide
544// their own implementation for this decorator, and thus specify custom logic regarding build
545// statements pertaining to linking.
Colin Crossca860ac2016-01-04 14:34:37 -0800546type linker interface {
Colin Cross42742b82016-08-01 13:20:05 -0700547 linkerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800548 linkerDeps(ctx DepsContext, deps Deps) Deps
Colin Cross42742b82016-08-01 13:20:05 -0700549 linkerFlags(ctx ModuleContext, flags Flags) Flags
550 linkerProps() []interface{}
Ivan Lozanobd721262018-11-27 14:33:03 -0800551 useClangLld(actx ModuleContext) bool
Colin Cross42742b82016-08-01 13:20:05 -0700552
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700553 link(ctx ModuleContext, flags Flags, deps PathDeps, objs Objects) android.Path
Colin Cross76fada02016-07-27 10:31:13 -0700554 appendLdflags([]string)
Jiyong Parkaf6d8952019-01-31 12:21:23 +0900555 unstrippedOutputFilePath() android.Path
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700556
557 nativeCoverage() bool
Jiyong Parkee9a98d2019-08-09 14:44:36 +0900558 coverageOutputFilePath() android.OptionalPath
Paul Duffin13f02712020-03-06 12:30:43 +0000559
560 // Get the deps that have been explicitly specified in the properties.
Paul Duffin13f02712020-03-06 12:30:43 +0000561 linkerSpecifiedDeps(specifiedDeps specifiedDeps) specifiedDeps
562}
563
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500564// specifiedDeps is a tuple struct representing dependencies of a linked binary owned by the linker.
Paul Duffin13f02712020-03-06 12:30:43 +0000565type specifiedDeps struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500566 sharedLibs []string
567 // Note nil and [] are semantically distinct. [] prevents linking against the defaults (usually
568 // libc, libm, etc.)
569 systemSharedLibs []string
Colin Crossca860ac2016-01-04 14:34:37 -0800570}
571
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500572// installer is the interface for an installer helper object. This helper is responsible for
573// copying build outputs to the appropriate locations so that they may be installed on device.
Colin Crossca860ac2016-01-04 14:34:37 -0800574type installer interface {
Colin Cross42742b82016-08-01 13:20:05 -0700575 installerProps() []interface{}
Colin Cross635c3b02016-05-18 15:37:25 -0700576 install(ctx ModuleContext, path android.Path)
Paul Duffin0cb37b92020-03-04 14:52:46 +0000577 everInstallable() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800578 inData() bool
Vishwath Mohan1dd88392017-03-29 22:00:18 -0700579 inSanitizerDir() bool
Dan Willemsen4aa75ca2016-09-28 16:18:03 -0700580 hostToolPath() android.OptionalPath
Jiyong Parkb7c24df2019-02-01 12:03:59 +0900581 relativeInstallPath() string
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +0100582 makeUninstallable(mod *Module)
Colin Crossca860ac2016-01-04 14:34:37 -0800583}
584
Chris Parsons8d6e4332021-02-22 16:13:50 -0500585// bazelHandler is the interface for a helper object related to deferring to Bazel for
586// processing a module (during Bazel mixed builds). Individual module types should define
587// their own bazel handler if they support deferring to Bazel.
588type bazelHandler interface {
589 // Issue query to Bazel to retrieve information about Bazel's view of the current module.
590 // If Bazel returns this information, set module properties on the current module to reflect
591 // the returned information.
592 // Returns true if information was available from Bazel, false if bazel invocation still needs to occur.
593 generateBazelBuildActions(ctx android.ModuleContext, label string) bool
594}
595
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800596type xref interface {
597 XrefCcFiles() android.Paths
598}
599
Colin Cross6e511a92020-07-27 21:26:48 -0700600type libraryDependencyKind int
601
602const (
603 headerLibraryDependency = iota
604 sharedLibraryDependency
605 staticLibraryDependency
606)
607
608func (k libraryDependencyKind) String() string {
609 switch k {
610 case headerLibraryDependency:
611 return "headerLibraryDependency"
612 case sharedLibraryDependency:
613 return "sharedLibraryDependency"
614 case staticLibraryDependency:
615 return "staticLibraryDependency"
616 default:
617 panic(fmt.Errorf("unknown libraryDependencyKind %d", k))
618 }
619}
620
621type libraryDependencyOrder int
622
623const (
624 earlyLibraryDependency = -1
625 normalLibraryDependency = 0
626 lateLibraryDependency = 1
627)
628
629func (o libraryDependencyOrder) String() string {
630 switch o {
631 case earlyLibraryDependency:
632 return "earlyLibraryDependency"
633 case normalLibraryDependency:
634 return "normalLibraryDependency"
635 case lateLibraryDependency:
636 return "lateLibraryDependency"
637 default:
638 panic(fmt.Errorf("unknown libraryDependencyOrder %d", o))
639 }
640}
641
642// libraryDependencyTag is used to tag dependencies on libraries. Unlike many dependency
643// tags that have a set of predefined tag objects that are reused for each dependency, a
644// libraryDependencyTag is designed to contain extra metadata and is constructed as needed.
645// That means that comparing a libraryDependencyTag for equality will only be equal if all
646// of the metadata is equal. Most usages will want to type assert to libraryDependencyTag and
647// then check individual metadata fields instead.
648type libraryDependencyTag struct {
649 blueprint.BaseDependencyTag
650
651 // These are exported so that fmt.Printf("%#v") can call their String methods.
652 Kind libraryDependencyKind
653 Order libraryDependencyOrder
654
655 wholeStatic bool
656
657 reexportFlags bool
658 explicitlyVersioned bool
659 dataLib bool
660 ndk bool
661
662 staticUnwinder bool
663
664 makeSuffix string
Jiyong Parke3867542020-12-03 17:28:25 +0900665
Cindy Zhou18417cb2020-12-10 07:12:38 -0800666 // Whether or not this dependency should skip the apex dependency check
667 skipApexAllowedDependenciesCheck bool
668
Jiyong Parke3867542020-12-03 17:28:25 +0900669 // Whether or not this dependency has to be followed for the apex variants
670 excludeInApex bool
Colin Cross6e511a92020-07-27 21:26:48 -0700671}
672
673// header returns true if the libraryDependencyTag is tagging a header lib dependency.
674func (d libraryDependencyTag) header() bool {
675 return d.Kind == headerLibraryDependency
676}
677
678// shared returns true if the libraryDependencyTag is tagging a shared lib dependency.
679func (d libraryDependencyTag) shared() bool {
680 return d.Kind == sharedLibraryDependency
681}
682
683// shared returns true if the libraryDependencyTag is tagging a static lib dependency.
684func (d libraryDependencyTag) static() bool {
685 return d.Kind == staticLibraryDependency
686}
687
Colin Crosse9fe2942020-11-10 18:12:15 -0800688// InstallDepNeeded returns true for shared libraries so that shared library dependencies of
689// binaries or other shared libraries are installed as dependencies.
690func (d libraryDependencyTag) InstallDepNeeded() bool {
691 return d.shared()
692}
693
694var _ android.InstallNeededDependencyTag = libraryDependencyTag{}
695
696// dependencyTag is used for tagging miscellaneous dependency types that don't fit into
Colin Cross6e511a92020-07-27 21:26:48 -0700697// libraryDependencyTag. Each tag object is created globally and reused for multiple
698// dependencies (although since the object contains no references, assigning a tag to a
699// variable and modifying it will not modify the original). Users can compare the tag
700// returned by ctx.OtherModuleDependencyTag against the global original
701type dependencyTag struct {
702 blueprint.BaseDependencyTag
703 name string
704}
705
Colin Crosse9fe2942020-11-10 18:12:15 -0800706// installDependencyTag is used for tagging miscellaneous dependency types that don't fit into
707// libraryDependencyTag, but where the dependency needs to be installed when the parent is
708// installed.
709type installDependencyTag struct {
710 blueprint.BaseDependencyTag
711 android.InstallAlwaysNeededDependencyTag
712 name string
713}
714
Colin Crossc99deeb2016-04-11 15:06:20 -0700715var (
Colin Cross6e511a92020-07-27 21:26:48 -0700716 genSourceDepTag = dependencyTag{name: "gen source"}
717 genHeaderDepTag = dependencyTag{name: "gen header"}
718 genHeaderExportDepTag = dependencyTag{name: "gen header export"}
719 objDepTag = dependencyTag{name: "obj"}
720 linkerFlagsDepTag = dependencyTag{name: "linker flags file"}
Jiyong Parkd630bdd2020-11-25 11:47:24 +0900721 dynamicLinkerDepTag = installDependencyTag{name: "dynamic linker"}
Colin Cross6e511a92020-07-27 21:26:48 -0700722 reuseObjTag = dependencyTag{name: "reuse objects"}
723 staticVariantTag = dependencyTag{name: "static variant"}
724 vndkExtDepTag = dependencyTag{name: "vndk extends"}
725 dataLibDepTag = dependencyTag{name: "data lib"}
Colin Crosse9fe2942020-11-10 18:12:15 -0800726 runtimeDepTag = installDependencyTag{name: "runtime lib"}
Colin Cross6e511a92020-07-27 21:26:48 -0700727 testPerSrcDepTag = dependencyTag{name: "test_per_src"}
Colin Cross0de8a1e2020-09-18 14:15:30 -0700728 stubImplDepTag = dependencyTag{name: "stub_impl"}
Colin Crossc99deeb2016-04-11 15:06:20 -0700729)
730
Roland Levillainf89cd092019-07-29 16:22:59 +0100731func IsSharedDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700732 ccLibDepTag, ok := depTag.(libraryDependencyTag)
733 return ok && ccLibDepTag.shared()
734}
735
736func IsStaticDepTag(depTag blueprint.DependencyTag) bool {
737 ccLibDepTag, ok := depTag.(libraryDependencyTag)
738 return ok && ccLibDepTag.static()
Roland Levillainf89cd092019-07-29 16:22:59 +0100739}
740
Zach Johnson3df4e632020-11-06 11:56:27 -0800741func IsHeaderDepTag(depTag blueprint.DependencyTag) bool {
742 ccLibDepTag, ok := depTag.(libraryDependencyTag)
743 return ok && ccLibDepTag.header()
744}
745
Roland Levillainf89cd092019-07-29 16:22:59 +0100746func IsRuntimeDepTag(depTag blueprint.DependencyTag) bool {
Colin Crosse9fe2942020-11-10 18:12:15 -0800747 return depTag == runtimeDepTag
Roland Levillainf89cd092019-07-29 16:22:59 +0100748}
749
750func IsTestPerSrcDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700751 ccDepTag, ok := depTag.(dependencyTag)
Roland Levillainf89cd092019-07-29 16:22:59 +0100752 return ok && ccDepTag == testPerSrcDepTag
753}
754
Colin Crossca860ac2016-01-04 14:34:37 -0800755// Module contains the properties and members used by all C/C++ module types, and implements
756// the blueprint.Module interface. It delegates to compiler, linker, and installer interfaces
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500757// to construct the output file. Behavior can be customized with a Customizer, or "decorator",
758// interface.
759//
760// To define a C/C++ related module, construct a new Module object and point its delegates to
761// type-specific structs. These delegates will be invoked to register module-specific build
762// statements which may be unique to the module type. For example, module.compiler.compile() should
763// be defined so as to register build statements which are responsible for compiling the module.
764//
765// Another example: to construct a cc_binary module, one can create a `cc.binaryDecorator` struct
766// which implements the `linker` and `installer` interfaces, and points the `linker` and `installer`
767// members of the cc.Module to this decorator. Thus, a cc_binary module has custom linker and
768// installer logic.
Colin Crossca860ac2016-01-04 14:34:37 -0800769type Module struct {
Colin Cross635c3b02016-05-18 15:37:25 -0700770 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -0700771 android.DefaultableModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +0900772 android.ApexModuleBase
Jiyong Parkd1063c12019-07-17 20:08:41 +0900773 android.SdkBase
Liz Kammerea6666f2021-02-17 10:17:28 -0500774 android.BazelModuleBase
Colin Crossc472d572015-03-17 15:06:21 -0700775
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700776 Properties BaseProperties
777 VendorProperties VendorProperties
Colin Crossfa138792015-04-24 17:31:52 -0700778
Colin Crossca860ac2016-01-04 14:34:37 -0800779 // initialize before calling Init
Colin Cross635c3b02016-05-18 15:37:25 -0700780 hod android.HostOrDeviceSupported
781 multilib android.Multilib
Colin Crossc472d572015-03-17 15:06:21 -0700782
Paul Duffina0843f62019-12-13 19:50:38 +0000783 // Allowable SdkMemberTypes of this module type.
784 sdkMemberTypes []android.SdkMemberType
785
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500786 // decorator delegates, initialize before calling Init
787 // these may contain module-specific implementations, and effectively allow for custom
788 // type-specific logic. These members may reference different objects or the same object.
789 // Functions of these decorators will be invoked to initialize and register type-specific
790 // build statements.
Chris Parsons8d6e4332021-02-22 16:13:50 -0500791 compiler compiler
792 linker linker
793 installer installer
794 bazelHandler bazelHandler
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500795
796 features []feature
797 stl *stl
798 sanitize *sanitize
799 coverage *coverage
800 sabi *sabi
801 vndkdep *vndkdep
802 lto *lto
803 pgo *pgo
Colin Cross16b23492016-01-06 14:41:07 -0800804
Colin Cross31076b32020-10-23 17:22:06 -0700805 library libraryInterface
806
Colin Cross635c3b02016-05-18 15:37:25 -0700807 outputFile android.OptionalPath
Colin Crossca860ac2016-01-04 14:34:37 -0800808
Colin Crossb98c8b02016-07-29 13:44:28 -0700809 cachedToolchain config.Toolchain
Colin Crossb916a382016-07-29 17:28:03 -0700810
811 subAndroidMkOnce map[subAndroidMkProvider]bool
Fabien Sanglardd61f1f42017-01-10 16:21:22 -0800812
813 // Flags used to compile this module
814 flags Flags
Jeff Gaston294356f2017-09-27 17:05:30 -0700815
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800816 // only non-nil when this is a shared library that reuses the objects of a static library
Colin Cross0de8a1e2020-09-18 14:15:30 -0700817 staticAnalogue *StaticLibraryInfo
Inseob Kim9516ee92019-05-09 10:56:13 +0900818
819 makeLinkType string
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800820 // Kythe (source file indexer) paths for this compilation module
821 kytheFiles android.Paths
Jooyung Han75568392020-03-20 04:29:24 +0900822
823 // For apex variants, this is set as apex.min_sdk_version
Dan Albertc8060532020-07-22 22:32:17 -0700824 apexSdkVersion android.ApiLevel
Colin Cross56a83212020-09-15 18:30:11 -0700825
826 hideApexVariantFromMake bool
Colin Crossc472d572015-03-17 15:06:21 -0700827}
828
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500829func (c *Module) SetPreventInstall() {
830 c.Properties.PreventInstall = true
831}
832
833func (c *Module) SetHideFromMake() {
834 c.Properties.HideFromMake = true
835}
836
Ivan Lozanod7586b62021-04-01 09:49:36 -0400837func (c *Module) HiddenFromMake() bool {
838 return c.Properties.HideFromMake
839}
840
Ivan Lozano52767be2019-10-18 14:49:46 -0700841func (c *Module) Toc() android.OptionalPath {
842 if c.linker != nil {
843 if library, ok := c.linker.(libraryInterface); ok {
844 return library.toc()
845 }
846 }
847 panic(fmt.Errorf("Toc() called on non-library module: %q", c.BaseModuleName()))
848}
849
850func (c *Module) ApiLevel() string {
851 if c.linker != nil {
852 if stub, ok := c.linker.(*stubDecorator); ok {
Dan Albert1a246272020-07-06 14:49:35 -0700853 return stub.apiLevel.String()
Ivan Lozano52767be2019-10-18 14:49:46 -0700854 }
855 }
856 panic(fmt.Errorf("ApiLevel() called on non-stub library module: %q", c.BaseModuleName()))
857}
858
859func (c *Module) Static() bool {
860 if c.linker != nil {
861 if library, ok := c.linker.(libraryInterface); ok {
862 return library.static()
863 }
864 }
865 panic(fmt.Errorf("Static() called on non-library module: %q", c.BaseModuleName()))
866}
867
868func (c *Module) Shared() bool {
869 if c.linker != nil {
870 if library, ok := c.linker.(libraryInterface); ok {
871 return library.shared()
872 }
873 }
874 panic(fmt.Errorf("Shared() called on non-library module: %q", c.BaseModuleName()))
875}
876
877func (c *Module) SelectedStl() string {
Colin Crossc511bc52020-04-07 16:50:32 +0000878 if c.stl != nil {
879 return c.stl.Properties.SelectedStl
880 }
881 return ""
Ivan Lozano52767be2019-10-18 14:49:46 -0700882}
883
884func (c *Module) ToolchainLibrary() bool {
885 if _, ok := c.linker.(*toolchainLibraryDecorator); ok {
886 return true
887 }
888 return false
889}
890
891func (c *Module) NdkPrebuiltStl() bool {
892 if _, ok := c.linker.(*ndkPrebuiltStlLinker); ok {
893 return true
894 }
895 return false
896}
897
898func (c *Module) StubDecorator() bool {
899 if _, ok := c.linker.(*stubDecorator); ok {
900 return true
901 }
902 return false
903}
904
905func (c *Module) SdkVersion() string {
906 return String(c.Properties.Sdk_version)
907}
908
Artur Satayev480e25b2020-04-27 18:53:18 +0100909func (c *Module) MinSdkVersion() string {
910 return String(c.Properties.Min_sdk_version)
911}
912
Dan Albert92fe7402020-07-15 13:33:30 -0700913func (c *Module) SplitPerApiLevel() bool {
Colin Cross1348ce32020-10-01 13:37:16 -0700914 if !c.canUseSdk() {
915 return false
916 }
Dan Albert92fe7402020-07-15 13:33:30 -0700917 if linker, ok := c.linker.(*objectLinker); ok {
918 return linker.isCrt()
919 }
920 return false
921}
922
Colin Crossc511bc52020-04-07 16:50:32 +0000923func (c *Module) AlwaysSdk() bool {
924 return c.Properties.AlwaysSdk || Bool(c.Properties.Sdk_variant_only)
925}
926
Ivan Lozano183a3212019-10-18 14:18:45 -0700927func (c *Module) CcLibrary() bool {
928 if c.linker != nil {
929 if _, ok := c.linker.(*libraryDecorator); ok {
930 return true
931 }
Colin Crossd48fe732020-09-23 20:37:24 -0700932 if _, ok := c.linker.(*prebuiltLibraryLinker); ok {
933 return true
934 }
Ivan Lozano183a3212019-10-18 14:18:45 -0700935 }
936 return false
937}
938
939func (c *Module) CcLibraryInterface() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -0700940 if _, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700941 return true
942 }
943 return false
944}
945
Ivan Lozano2b262972019-11-21 12:30:50 -0800946func (c *Module) NonCcVariants() bool {
947 return false
948}
949
Ivan Lozano183a3212019-10-18 14:18:45 -0700950func (c *Module) SetStatic() {
951 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700952 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700953 library.setStatic()
954 return
955 }
956 }
957 panic(fmt.Errorf("SetStatic called on non-library module: %q", c.BaseModuleName()))
958}
959
960func (c *Module) SetShared() {
961 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700962 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700963 library.setShared()
964 return
965 }
966 }
967 panic(fmt.Errorf("SetShared called on non-library module: %q", c.BaseModuleName()))
968}
969
970func (c *Module) BuildStaticVariant() bool {
971 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700972 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700973 return library.buildStatic()
974 }
975 }
976 panic(fmt.Errorf("BuildStaticVariant called on non-library module: %q", c.BaseModuleName()))
977}
978
979func (c *Module) BuildSharedVariant() bool {
980 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700981 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700982 return library.buildShared()
983 }
984 }
985 panic(fmt.Errorf("BuildSharedVariant called on non-library module: %q", c.BaseModuleName()))
986}
987
988func (c *Module) Module() android.Module {
989 return c
990}
991
Jiyong Parkc20eee32018-09-05 22:36:17 +0900992func (c *Module) OutputFile() android.OptionalPath {
993 return c.outputFile
994}
995
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400996func (c *Module) CoverageFiles() android.Paths {
997 if c.linker != nil {
998 if library, ok := c.linker.(libraryInterface); ok {
999 return library.objs().coverageFiles
1000 }
1001 }
1002 panic(fmt.Errorf("CoverageFiles called on non-library module: %q", c.BaseModuleName()))
1003}
1004
Ivan Lozano183a3212019-10-18 14:18:45 -07001005var _ LinkableInterface = (*Module)(nil)
1006
Jiyong Park719b4462019-01-13 00:39:51 +09001007func (c *Module) UnstrippedOutputFile() android.Path {
Jiyong Parkaf6d8952019-01-31 12:21:23 +09001008 if c.linker != nil {
1009 return c.linker.unstrippedOutputFilePath()
Jiyong Park719b4462019-01-13 00:39:51 +09001010 }
1011 return nil
1012}
1013
Jiyong Parkee9a98d2019-08-09 14:44:36 +09001014func (c *Module) CoverageOutputFile() android.OptionalPath {
1015 if c.linker != nil {
1016 return c.linker.coverageOutputFilePath()
1017 }
1018 return android.OptionalPath{}
1019}
1020
Jiyong Parkb7c24df2019-02-01 12:03:59 +09001021func (c *Module) RelativeInstallPath() string {
1022 if c.installer != nil {
1023 return c.installer.relativeInstallPath()
1024 }
1025 return ""
1026}
1027
Jooyung Han344d5432019-08-23 11:17:39 +09001028func (c *Module) VndkVersion() string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001029 return c.Properties.VndkVersion
Jooyung Han344d5432019-08-23 11:17:39 +09001030}
1031
Colin Cross36242852017-06-23 15:06:31 -07001032func (c *Module) Init() android.Module {
Dan Willemsenf923f2b2018-05-09 13:45:03 -07001033 c.AddProperties(&c.Properties, &c.VendorProperties)
Colin Crossca860ac2016-01-04 14:34:37 -08001034 if c.compiler != nil {
Colin Cross36242852017-06-23 15:06:31 -07001035 c.AddProperties(c.compiler.compilerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001036 }
1037 if c.linker != nil {
Colin Cross36242852017-06-23 15:06:31 -07001038 c.AddProperties(c.linker.linkerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001039 }
1040 if c.installer != nil {
Colin Cross36242852017-06-23 15:06:31 -07001041 c.AddProperties(c.installer.installerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001042 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001043 if c.stl != nil {
Colin Cross36242852017-06-23 15:06:31 -07001044 c.AddProperties(c.stl.props()...)
Colin Crossa8e07cc2016-04-04 15:07:06 -07001045 }
Colin Cross16b23492016-01-06 14:41:07 -08001046 if c.sanitize != nil {
Colin Cross36242852017-06-23 15:06:31 -07001047 c.AddProperties(c.sanitize.props()...)
Colin Cross16b23492016-01-06 14:41:07 -08001048 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001049 if c.coverage != nil {
Colin Cross36242852017-06-23 15:06:31 -07001050 c.AddProperties(c.coverage.props()...)
Dan Willemsen581341d2017-02-09 16:16:31 -08001051 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001052 if c.sabi != nil {
Colin Cross36242852017-06-23 15:06:31 -07001053 c.AddProperties(c.sabi.props()...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001054 }
Justin Yun8effde42017-06-23 19:24:43 +09001055 if c.vndkdep != nil {
1056 c.AddProperties(c.vndkdep.props()...)
1057 }
Stephen Craneba090d12017-05-09 15:44:35 -07001058 if c.lto != nil {
1059 c.AddProperties(c.lto.props()...)
1060 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001061 if c.pgo != nil {
1062 c.AddProperties(c.pgo.props()...)
1063 }
Colin Crossca860ac2016-01-04 14:34:37 -08001064 for _, feature := range c.features {
Colin Cross36242852017-06-23 15:06:31 -07001065 c.AddProperties(feature.props()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001066 }
Colin Crossc472d572015-03-17 15:06:21 -07001067
Colin Cross36242852017-06-23 15:06:31 -07001068 android.InitAndroidArchModule(c, c.hod, c.multilib)
Liz Kammerea6666f2021-02-17 10:17:28 -05001069 android.InitBazelModule(c)
Jiyong Park7916bfc2019-09-30 19:13:12 +09001070 android.InitApexModule(c)
Jiyong Parkd1063c12019-07-17 20:08:41 +09001071 android.InitSdkAwareModule(c)
Jooyung Han18020ea2019-11-13 10:50:48 +09001072 android.InitDefaultableModule(c)
Jiyong Park9d452992018-10-03 00:38:19 +09001073
Colin Cross36242852017-06-23 15:06:31 -07001074 return c
Colin Crossc472d572015-03-17 15:06:21 -07001075}
1076
Colin Crossb916a382016-07-29 17:28:03 -07001077// Returns true for dependency roots (binaries)
1078// TODO(ccross): also handle dlopenable libraries
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001079func (c *Module) IsDependencyRoot() bool {
Colin Crossb916a382016-07-29 17:28:03 -07001080 if root, ok := c.linker.(interface {
1081 isDependencyRoot() bool
1082 }); ok {
1083 return root.isDependencyRoot()
1084 }
1085 return false
1086}
1087
Ivan Lozano52767be2019-10-18 14:49:46 -07001088func (c *Module) UseVndk() bool {
Inseob Kim64c43952019-08-26 16:52:35 +09001089 return c.Properties.VndkVersion != ""
Dan Willemsen4416e5d2017-04-06 12:43:22 -07001090}
1091
Colin Crossc511bc52020-04-07 16:50:32 +00001092func (c *Module) canUseSdk() bool {
Colin Cross94e347e2021-01-19 14:56:07 -08001093 return c.Os() == android.Android && c.Target().NativeBridge == android.NativeBridgeDisabled &&
1094 !c.UseVndk() && !c.InRamdisk() && !c.InRecovery() && !c.InVendorRamdisk()
Colin Crossc511bc52020-04-07 16:50:32 +00001095}
1096
1097func (c *Module) UseSdk() bool {
1098 if c.canUseSdk() {
Colin Cross1348ce32020-10-01 13:37:16 -07001099 return String(c.Properties.Sdk_version) != ""
Colin Crossc511bc52020-04-07 16:50:32 +00001100 }
1101 return false
1102}
1103
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001104func (c *Module) isCoverageVariant() bool {
1105 return c.coverage.Properties.IsCoverageVariant
1106}
1107
Colin Cross95f1ca02020-10-29 20:47:22 -07001108func (c *Module) IsNdk(config android.Config) bool {
1109 return inList(c.BaseModuleName(), *getNDKKnownLibs(config))
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001110}
1111
Colin Cross127bb8b2020-12-16 16:46:01 -08001112func (c *Module) IsLlndk() bool {
1113 return c.VendorProperties.IsLLNDK
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001114}
1115
Colin Cross127bb8b2020-12-16 16:46:01 -08001116func (c *Module) IsLlndkPublic() bool {
Colin Cross78212242021-01-06 14:51:30 -08001117 return c.VendorProperties.IsLLNDK && !c.VendorProperties.IsVNDKPrivate
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001118}
1119
Colin Cross1f3f1302021-04-26 18:37:44 -07001120func (m *Module) NeedsLlndkVariants() bool {
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001121 lib := moduleLibraryInterface(m)
Colin Cross1f3f1302021-04-26 18:37:44 -07001122 return lib != nil && (lib.hasLLNDKStubs() || lib.hasLLNDKHeaders())
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001123}
1124
Colin Cross5271fea2021-04-27 13:06:04 -07001125func (m *Module) NeedsVendorPublicLibraryVariants() bool {
1126 lib := moduleLibraryInterface(m)
1127 return lib != nil && (lib.hasVendorPublicLibrary())
1128}
1129
1130// IsVendorPublicLibrary returns true for vendor public libraries.
1131func (c *Module) IsVendorPublicLibrary() bool {
1132 return c.VendorProperties.IsVendorPublicLibrary
1133}
1134
Ivan Lozanod7586b62021-04-01 09:49:36 -04001135func (c *Module) HasLlndkStubs() bool {
1136 lib := moduleLibraryInterface(c)
1137 return lib != nil && lib.hasLLNDKStubs()
1138}
1139
1140func (c *Module) StubsVersion() string {
1141 if lib, ok := c.linker.(versionedInterface); ok {
1142 return lib.stubsVersion()
1143 }
1144 panic(fmt.Errorf("StubsVersion called on non-versioned module: %q", c.BaseModuleName()))
1145}
1146
Colin Cross127bb8b2020-12-16 16:46:01 -08001147// isImplementationForLLNDKPublic returns true for any variant of a cc_library that has LLNDK stubs
1148// and does not set llndk.vendor_available: false.
1149func (c *Module) isImplementationForLLNDKPublic() bool {
1150 library, _ := c.library.(*libraryDecorator)
1151 return library != nil && library.hasLLNDKStubs() &&
Colin Cross0fb7fcd2021-03-02 11:00:07 -08001152 !Bool(library.Properties.Llndk.Private)
Colin Cross127bb8b2020-12-16 16:46:01 -08001153}
1154
Justin Yunfd9e8042020-12-23 18:23:14 +09001155// Returns true for LLNDK-private, VNDK-SP-private, and VNDK-core-private.
Colin Cross127bb8b2020-12-16 16:46:01 -08001156func (c *Module) IsVndkPrivate() bool {
Justin Yunfd9e8042020-12-23 18:23:14 +09001157 // Check if VNDK-core-private or VNDK-SP-private
1158 if c.IsVndk() {
Justin Yunc0d8c492021-01-07 17:45:31 +09001159 return Bool(c.vndkdep.Properties.Vndk.Private)
Justin Yunfd9e8042020-12-23 18:23:14 +09001160 }
1161
1162 // Check if LLNDK-private
1163 if library, ok := c.library.(*libraryDecorator); ok && c.IsLlndk() {
Justin Yunc0d8c492021-01-07 17:45:31 +09001164 return Bool(library.Properties.Llndk.Private)
Justin Yunfd9e8042020-12-23 18:23:14 +09001165 }
1166
1167 return false
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001168}
1169
Ivan Lozano52767be2019-10-18 14:49:46 -07001170func (c *Module) IsVndk() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001171 if vndkdep := c.vndkdep; vndkdep != nil {
1172 return vndkdep.isVndk()
Justin Yun8effde42017-06-23 19:24:43 +09001173 }
1174 return false
1175}
1176
Yi Kong7e53c572018-02-14 18:16:12 +08001177func (c *Module) isPgoCompile() bool {
1178 if pgo := c.pgo; pgo != nil {
1179 return pgo.Properties.PgoCompile
1180 }
1181 return false
1182}
1183
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001184func (c *Module) isNDKStubLibrary() bool {
1185 if _, ok := c.compiler.(*stubDecorator); ok {
1186 return true
1187 }
1188 return false
1189}
1190
Ivan Lozanod7586b62021-04-01 09:49:36 -04001191func (c *Module) IsVndkSp() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001192 if vndkdep := c.vndkdep; vndkdep != nil {
1193 return vndkdep.isVndkSp()
1194 }
1195 return false
1196}
1197
Ivan Lozanof9e21722020-12-02 09:00:51 -05001198func (c *Module) IsVndkExt() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001199 if vndkdep := c.vndkdep; vndkdep != nil {
1200 return vndkdep.isVndkExt()
1201 }
1202 return false
1203}
1204
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001205func (c *Module) SubName() string {
1206 return c.Properties.SubName
1207}
1208
Ivan Lozano52767be2019-10-18 14:49:46 -07001209func (c *Module) MustUseVendorVariant() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001210 return c.IsVndkSp() || c.Properties.MustUseVendorVariant
Vic Yangefd249e2018-11-12 20:19:56 -08001211}
1212
Logan Chienf3511742017-10-31 18:04:35 +08001213func (c *Module) getVndkExtendsModuleName() string {
1214 if vndkdep := c.vndkdep; vndkdep != nil {
1215 return vndkdep.getVndkExtendsModuleName()
1216 }
1217 return ""
1218}
1219
Jiyong Park25fc6a92018-11-18 18:02:45 +09001220func (c *Module) IsStubs() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001221 if lib := c.library; lib != nil {
1222 return lib.buildStubs()
Jiyong Park25fc6a92018-11-18 18:02:45 +09001223 }
1224 return false
1225}
1226
1227func (c *Module) HasStubsVariants() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001228 if lib := c.library; lib != nil {
1229 return lib.hasStubsVariants()
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001230 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09001231 return false
1232}
1233
Colin Cross0477b422020-10-13 18:43:54 -07001234// If this is a stubs library, ImplementationModuleName returns the name of the module that contains
1235// the implementation. If it is an implementation library it returns its own name.
1236func (c *Module) ImplementationModuleName(ctx android.BaseModuleContext) string {
1237 name := ctx.OtherModuleName(c)
1238 if versioned, ok := c.linker.(versionedInterface); ok {
1239 name = versioned.implementationModuleName(name)
1240 }
1241 return name
1242}
1243
Martin Stjernholm2856c662020-12-02 15:03:42 +00001244// Similar to ImplementationModuleName, but uses the Make variant of the module
1245// name as base name, for use in AndroidMk output. E.g. for a prebuilt module
1246// where the Soong name is prebuilt_foo, this returns foo (which works in Make
1247// under the premise that the prebuilt module overrides its source counterpart
1248// if it is exposed to Make).
1249func (c *Module) ImplementationModuleNameForMake(ctx android.BaseModuleContext) string {
1250 name := c.BaseModuleName()
1251 if versioned, ok := c.linker.(versionedInterface); ok {
1252 name = versioned.implementationModuleName(name)
1253 }
1254 return name
1255}
1256
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001257func (c *Module) bootstrap() bool {
1258 return Bool(c.Properties.Bootstrap)
1259}
1260
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001261func (c *Module) nativeCoverage() bool {
Pirama Arumuga Nainar5f69b9a2019-09-12 13:18:48 -07001262 // Bug: http://b/137883967 - native-bridge modules do not currently work with coverage
1263 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1264 return false
1265 }
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001266 return c.linker != nil && c.linker.nativeCoverage()
1267}
1268
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001269func (c *Module) IsSnapshotPrebuilt() bool {
Colin Crossa8890802021-01-22 14:06:33 -08001270 if p, ok := c.linker.(snapshotInterface); ok {
Inseob Kim1042d292020-06-01 23:23:05 +09001271 return p.isSnapshotPrebuilt()
Inseob Kimeec88e12020-01-22 11:11:29 +09001272 }
1273 return false
Inseob Kim8471cda2019-11-15 09:59:12 +09001274}
1275
Bill Peckham945441c2020-08-31 16:07:58 -07001276func (c *Module) ExcludeFromVendorSnapshot() bool {
1277 return Bool(c.Properties.Exclude_from_vendor_snapshot)
1278}
1279
Jose Galmesf7294582020-11-13 12:07:36 -08001280func (c *Module) ExcludeFromRecoverySnapshot() bool {
1281 return Bool(c.Properties.Exclude_from_recovery_snapshot)
1282}
1283
Jiyong Parkf1194352019-02-25 11:05:47 +09001284func isBionic(name string) bool {
1285 switch name {
Kiyoung Kim4098c7e2020-11-30 14:42:14 +09001286 case "libc", "libm", "libdl", "libdl_android", "linker", "linkerconfig":
Jiyong Parkf1194352019-02-25 11:05:47 +09001287 return true
1288 }
1289 return false
1290}
1291
Martin Stjernholm279de572019-09-10 23:18:20 +01001292func InstallToBootstrap(name string, config android.Config) bool {
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001293 if name == "libclang_rt.hwasan-aarch64-android" {
Jooyung Han8ce8db92020-05-15 19:05:05 +09001294 return true
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001295 }
1296 return isBionic(name)
1297}
1298
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001299func (c *Module) XrefCcFiles() android.Paths {
1300 return c.kytheFiles
1301}
1302
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001303func (c *Module) isCfiAssemblySupportEnabled() bool {
1304 return c.sanitize != nil &&
1305 Bool(c.sanitize.Properties.Sanitize.Config.Cfi_assembly_support)
1306}
1307
Colin Crossca860ac2016-01-04 14:34:37 -08001308type baseModuleContext struct {
Colin Cross0ea8ba82019-06-06 14:33:29 -07001309 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001310 moduleContextImpl
1311}
1312
Colin Cross37047f12016-12-13 17:06:13 -08001313type depsContext struct {
1314 android.BottomUpMutatorContext
1315 moduleContextImpl
1316}
1317
Colin Crossca860ac2016-01-04 14:34:37 -08001318type moduleContext struct {
Colin Cross635c3b02016-05-18 15:37:25 -07001319 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001320 moduleContextImpl
1321}
1322
1323type moduleContextImpl struct {
1324 mod *Module
1325 ctx BaseModuleContext
1326}
1327
Colin Crossb98c8b02016-07-29 13:44:28 -07001328func (ctx *moduleContextImpl) toolchain() config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001329 return ctx.mod.toolchain(ctx.ctx)
1330}
1331
1332func (ctx *moduleContextImpl) static() bool {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00001333 return ctx.mod.static()
Colin Crossca860ac2016-01-04 14:34:37 -08001334}
1335
1336func (ctx *moduleContextImpl) staticBinary() bool {
Jiyong Park379de2f2018-12-19 02:47:14 +09001337 return ctx.mod.staticBinary()
Colin Crossca860ac2016-01-04 14:34:37 -08001338}
1339
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07001340func (ctx *moduleContextImpl) testBinary() bool {
1341 return ctx.mod.testBinary()
1342}
1343
Jiyong Park1d1119f2019-07-29 21:27:18 +09001344func (ctx *moduleContextImpl) header() bool {
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001345 return ctx.mod.Header()
Jiyong Park1d1119f2019-07-29 21:27:18 +09001346}
1347
Inseob Kim7f283f42020-06-01 21:53:49 +09001348func (ctx *moduleContextImpl) binary() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001349 return ctx.mod.Binary()
Inseob Kim7f283f42020-06-01 21:53:49 +09001350}
1351
Inseob Kim1042d292020-06-01 23:23:05 +09001352func (ctx *moduleContextImpl) object() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001353 return ctx.mod.Object()
Inseob Kim1042d292020-06-01 23:23:05 +09001354}
1355
Jooyung Hanccce2f22020-03-07 03:45:53 +09001356func (ctx *moduleContextImpl) canUseSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001357 return ctx.mod.canUseSdk()
Jooyung Hanccce2f22020-03-07 03:45:53 +09001358}
1359
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001360func (ctx *moduleContextImpl) useSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001361 return ctx.mod.UseSdk()
Colin Crossca860ac2016-01-04 14:34:37 -08001362}
1363
1364func (ctx *moduleContextImpl) sdkVersion() string {
Dan Willemsena96ff642016-06-07 12:34:45 -07001365 if ctx.ctx.Device() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001366 if ctx.useVndk() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001367 vndkVer := ctx.mod.VndkVersion()
Jooyung Han03302ee2020-04-08 09:22:26 +09001368 if inList(vndkVer, ctx.ctx.Config().PlatformVersionActiveCodenames()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001369 return "current"
Justin Yun732aa6a2018-03-23 17:43:47 +09001370 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001371 return vndkVer
Dan Willemsend2ede872016-11-18 14:54:24 -08001372 }
Justin Yun732aa6a2018-03-23 17:43:47 +09001373 return String(ctx.mod.Properties.Sdk_version)
Dan Willemsena96ff642016-06-07 12:34:45 -07001374 }
1375 return ""
Colin Crossca860ac2016-01-04 14:34:37 -08001376}
1377
Jiyong Parkb35a8192020-08-10 15:59:36 +09001378func (ctx *moduleContextImpl) minSdkVersion() string {
1379 ver := ctx.mod.MinSdkVersion()
1380 if ver == "apex_inherit" && !ctx.isForPlatform() {
1381 ver = ctx.apexSdkVersion().String()
1382 }
1383 if ver == "apex_inherit" || ver == "" {
1384 ver = ctx.sdkVersion()
1385 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001386 // For crt objects, the meaning of min_sdk_version is very different from other types of
1387 // module. For them, min_sdk_version defines the oldest version that the build system will
1388 // create versioned variants for. For example, if min_sdk_version is 16, then sdk variant of
1389 // the crt object has local variants of 16, 17, ..., up to the latest version. sdk_version
1390 // and min_sdk_version properties of the variants are set to the corresponding version
1391 // numbers. However, the platform (non-sdk) variant of the crt object is left untouched.
1392 // min_sdk_version: 16 doesn't actually mean that the platform variant has to support such
1393 // an old version. Since the variant is for the platform, it's preferred to target the
1394 // latest version.
1395 if ctx.mod.SplitPerApiLevel() && !ctx.isSdkVariant() {
1396 ver = strconv.Itoa(android.FutureApiLevelInt)
1397 }
1398
Jiyong Parkb35a8192020-08-10 15:59:36 +09001399 // Also make sure that minSdkVersion is not greater than sdkVersion, if they are both numbers
1400 sdkVersionInt, err := strconv.Atoi(ctx.sdkVersion())
1401 minSdkVersionInt, err2 := strconv.Atoi(ver)
1402 if err == nil && err2 == nil {
1403 if sdkVersionInt < minSdkVersionInt {
1404 return strconv.Itoa(sdkVersionInt)
1405 }
1406 }
1407 return ver
1408}
1409
1410func (ctx *moduleContextImpl) isSdkVariant() bool {
1411 return ctx.mod.IsSdkVariant()
1412}
1413
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001414func (ctx *moduleContextImpl) useVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001415 return ctx.mod.UseVndk()
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001416}
Justin Yun8effde42017-06-23 19:24:43 +09001417
Colin Cross95f1ca02020-10-29 20:47:22 -07001418func (ctx *moduleContextImpl) isNdk(config android.Config) bool {
1419 return ctx.mod.IsNdk(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001420}
1421
Colin Cross127bb8b2020-12-16 16:46:01 -08001422func (ctx *moduleContextImpl) IsLlndk() bool {
1423 return ctx.mod.IsLlndk()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001424}
1425
Colin Cross127bb8b2020-12-16 16:46:01 -08001426func (ctx *moduleContextImpl) IsLlndkPublic() bool {
1427 return ctx.mod.IsLlndkPublic()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001428}
1429
Colin Cross127bb8b2020-12-16 16:46:01 -08001430func (ctx *moduleContextImpl) isImplementationForLLNDKPublic() bool {
1431 return ctx.mod.isImplementationForLLNDKPublic()
1432}
1433
1434func (ctx *moduleContextImpl) IsVndkPrivate() bool {
1435 return ctx.mod.IsVndkPrivate()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001436}
1437
Logan Chienf3511742017-10-31 18:04:35 +08001438func (ctx *moduleContextImpl) isVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001439 return ctx.mod.IsVndk()
Logan Chienf3511742017-10-31 18:04:35 +08001440}
1441
Yi Kong7e53c572018-02-14 18:16:12 +08001442func (ctx *moduleContextImpl) isPgoCompile() bool {
1443 return ctx.mod.isPgoCompile()
1444}
1445
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001446func (ctx *moduleContextImpl) isNDKStubLibrary() bool {
1447 return ctx.mod.isNDKStubLibrary()
1448}
1449
Justin Yun8effde42017-06-23 19:24:43 +09001450func (ctx *moduleContextImpl) isVndkSp() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001451 return ctx.mod.IsVndkSp()
Logan Chienf3511742017-10-31 18:04:35 +08001452}
1453
Ivan Lozanof9e21722020-12-02 09:00:51 -05001454func (ctx *moduleContextImpl) IsVndkExt() bool {
1455 return ctx.mod.IsVndkExt()
Justin Yun8effde42017-06-23 19:24:43 +09001456}
1457
Colin Cross5271fea2021-04-27 13:06:04 -07001458func (ctx *moduleContextImpl) IsVendorPublicLibrary() bool {
1459 return ctx.mod.IsVendorPublicLibrary()
1460}
1461
Vic Yangefd249e2018-11-12 20:19:56 -08001462func (ctx *moduleContextImpl) mustUseVendorVariant() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001463 return ctx.mod.MustUseVendorVariant()
Vic Yangefd249e2018-11-12 20:19:56 -08001464}
1465
Dan Willemsen8146b2f2016-03-30 21:00:30 -07001466func (ctx *moduleContextImpl) selectedStl() string {
1467 if stl := ctx.mod.stl; stl != nil {
1468 return stl.Properties.SelectedStl
1469 }
1470 return ""
1471}
1472
Ivan Lozanobd721262018-11-27 14:33:03 -08001473func (ctx *moduleContextImpl) useClangLld(actx ModuleContext) bool {
1474 return ctx.mod.linker.useClangLld(actx)
1475}
1476
Colin Crossce75d2c2016-10-06 16:12:58 -07001477func (ctx *moduleContextImpl) baseModuleName() string {
1478 return ctx.mod.ModuleBase.BaseModuleName()
1479}
1480
Logan Chienf3511742017-10-31 18:04:35 +08001481func (ctx *moduleContextImpl) getVndkExtendsModuleName() string {
1482 return ctx.mod.getVndkExtendsModuleName()
1483}
1484
Logan Chiene274fc92019-12-03 11:18:32 -08001485func (ctx *moduleContextImpl) isForPlatform() bool {
Colin Cross56a83212020-09-15 18:30:11 -07001486 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).IsForPlatform()
Logan Chiene274fc92019-12-03 11:18:32 -08001487}
1488
Colin Crosse07f2312020-08-13 11:24:56 -07001489func (ctx *moduleContextImpl) apexVariationName() string {
Colin Cross56a83212020-09-15 18:30:11 -07001490 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).ApexVariationName
Jiyong Park25fc6a92018-11-18 18:02:45 +09001491}
1492
Dan Albertc8060532020-07-22 22:32:17 -07001493func (ctx *moduleContextImpl) apexSdkVersion() android.ApiLevel {
Jooyung Han75568392020-03-20 04:29:24 +09001494 return ctx.mod.apexSdkVersion
Jooyung Hanccce2f22020-03-07 03:45:53 +09001495}
1496
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001497func (ctx *moduleContextImpl) bootstrap() bool {
1498 return ctx.mod.bootstrap()
1499}
1500
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001501func (ctx *moduleContextImpl) nativeCoverage() bool {
1502 return ctx.mod.nativeCoverage()
1503}
1504
Colin Cross56a83212020-09-15 18:30:11 -07001505func (ctx *moduleContextImpl) directlyInAnyApex() bool {
1506 return ctx.mod.DirectlyInAnyApex()
1507}
1508
Colin Cross95b07f22020-12-16 11:06:50 -08001509func (ctx *moduleContextImpl) isPreventInstall() bool {
1510 return ctx.mod.Properties.PreventInstall
1511}
1512
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001513func (ctx *moduleContextImpl) isCfiAssemblySupportEnabled() bool {
1514 return ctx.mod.isCfiAssemblySupportEnabled()
1515}
1516
Colin Cross635c3b02016-05-18 15:37:25 -07001517func newBaseModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001518 return &Module{
1519 hod: hod,
1520 multilib: multilib,
1521 }
1522}
1523
Colin Cross635c3b02016-05-18 15:37:25 -07001524func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001525 module := newBaseModule(hod, multilib)
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001526 module.features = []feature{
1527 &tidyFeature{},
1528 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001529 module.stl = &stl{}
Colin Cross16b23492016-01-06 14:41:07 -08001530 module.sanitize = &sanitize{}
Dan Willemsen581341d2017-02-09 16:16:31 -08001531 module.coverage = &coverage{}
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001532 module.sabi = &sabi{}
Justin Yun8effde42017-06-23 19:24:43 +09001533 module.vndkdep = &vndkdep{}
Stephen Craneba090d12017-05-09 15:44:35 -07001534 module.lto = &lto{}
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001535 module.pgo = &pgo{}
Colin Crossca860ac2016-01-04 14:34:37 -08001536 return module
1537}
1538
Colin Crossce75d2c2016-10-06 16:12:58 -07001539func (c *Module) Prebuilt() *android.Prebuilt {
1540 if p, ok := c.linker.(prebuiltLinkerInterface); ok {
1541 return p.prebuilt()
1542 }
1543 return nil
1544}
1545
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001546func (c *Module) IsPrebuilt() bool {
1547 return c.Prebuilt() != nil
1548}
1549
Colin Crossce75d2c2016-10-06 16:12:58 -07001550func (c *Module) Name() string {
1551 name := c.ModuleBase.Name()
Dan Willemsen01a90592017-04-07 15:21:13 -07001552 if p, ok := c.linker.(interface {
1553 Name(string) string
1554 }); ok {
Colin Crossce75d2c2016-10-06 16:12:58 -07001555 name = p.Name(name)
1556 }
1557 return name
1558}
1559
Alex Light3d673592019-01-18 14:37:31 -08001560func (c *Module) Symlinks() []string {
1561 if p, ok := c.installer.(interface {
1562 symlinkList() []string
1563 }); ok {
1564 return p.symlinkList()
1565 }
1566 return nil
1567}
1568
Roland Levillainf89cd092019-07-29 16:22:59 +01001569func (c *Module) IsTestPerSrcAllTestsVariation() bool {
1570 test, ok := c.linker.(testPerSrc)
1571 return ok && test.isAllTestsVariation()
1572}
1573
Chris Parsons216e10a2020-07-09 17:12:52 -04001574func (c *Module) DataPaths() []android.DataPath {
Liz Kammer1c14a212020-05-12 15:26:55 -07001575 if p, ok := c.installer.(interface {
Chris Parsons216e10a2020-07-09 17:12:52 -04001576 dataPaths() []android.DataPath
Liz Kammer1c14a212020-05-12 15:26:55 -07001577 }); ok {
1578 return p.dataPaths()
1579 }
1580 return nil
1581}
1582
Justin Yun5f7f7e82019-11-18 19:52:14 +09001583func (c *Module) getNameSuffixWithVndkVersion(ctx android.ModuleContext) string {
1584 // Returns the name suffix for product and vendor variants. If the VNDK version is not
1585 // "current", it will append the VNDK version to the name suffix.
1586 var vndkVersion string
1587 var nameSuffix string
Ivan Lozanof9e21722020-12-02 09:00:51 -05001588 if c.InProduct() {
Justin Yund00f5ca2021-02-03 19:43:02 +09001589 if c.ProductSpecific() {
1590 // If the module is product specific with 'product_specific: true',
1591 // do not add a name suffix because it is a base module.
1592 return ""
1593 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001594 vndkVersion = ctx.DeviceConfig().ProductVndkVersion()
1595 nameSuffix = productSuffix
1596 } else {
1597 vndkVersion = ctx.DeviceConfig().VndkVersion()
Ivan Lozanoe6d30982021-02-05 10:57:43 -05001598 nameSuffix = VendorSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001599 }
1600 if vndkVersion == "current" {
1601 vndkVersion = ctx.DeviceConfig().PlatformVndkVersion()
1602 }
Colin Cross127bb8b2020-12-16 16:46:01 -08001603 if c.Properties.VndkVersion != vndkVersion && c.Properties.VndkVersion != "" {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001604 // add version suffix only if the module is using different vndk version than the
1605 // version in product or vendor partition.
1606 nameSuffix += "." + c.Properties.VndkVersion
1607 }
1608 return nameSuffix
1609}
1610
Chris Parsons8d6e4332021-02-22 16:13:50 -05001611func (c *Module) setSubnameProperty(actx android.ModuleContext) {
Inseob Kim64c43952019-08-26 16:52:35 +09001612 c.Properties.SubName = ""
1613
1614 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1615 c.Properties.SubName += nativeBridgeSuffix
1616 }
1617
Colin Cross127bb8b2020-12-16 16:46:01 -08001618 llndk := c.IsLlndk()
Colin Cross627280f2021-04-26 16:53:58 -07001619 if llndk || (c.UseVndk() && c.HasNonSystemVariants()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001620 // .vendor.{version} suffix is added for vendor variant or .product.{version} suffix is
1621 // added for product variant only when we have vendor and product variants with core
1622 // variant. The suffix is not added for vendor-only or product-only module.
1623 c.Properties.SubName += c.getNameSuffixWithVndkVersion(actx)
Colin Cross5271fea2021-04-27 13:06:04 -07001624 } else if c.IsVendorPublicLibrary() {
1625 c.Properties.SubName += vendorPublicLibrarySuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001626 } else if _, ok := c.linker.(*vndkPrebuiltLibraryDecorator); ok {
Inseob Kim64c43952019-08-26 16:52:35 +09001627 // .vendor suffix is added for backward compatibility with VNDK snapshot whose names with
1628 // such suffixes are already hard-coded in prebuilts/vndk/.../Android.bp.
Ivan Lozanoe6d30982021-02-05 10:57:43 -05001629 c.Properties.SubName += VendorSuffix
Yifan Hong1b3348d2020-01-21 15:53:22 -08001630 } else if c.InRamdisk() && !c.OnlyInRamdisk() {
1631 c.Properties.SubName += ramdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001632 } else if c.InVendorRamdisk() && !c.OnlyInVendorRamdisk() {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05001633 c.Properties.SubName += VendorRamdiskSuffix
Ivan Lozano52767be2019-10-18 14:49:46 -07001634 } else if c.InRecovery() && !c.OnlyInRecovery() {
Inseob Kim64c43952019-08-26 16:52:35 +09001635 c.Properties.SubName += recoverySuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001636 } else if c.IsSdkVariant() && (c.Properties.SdkAndPlatformVariantVisibleToMake || c.SplitPerApiLevel()) {
Colin Crossc511bc52020-04-07 16:50:32 +00001637 c.Properties.SubName += sdkSuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001638 if c.SplitPerApiLevel() {
1639 c.Properties.SubName += "." + c.SdkVersion()
1640 }
Inseob Kim64c43952019-08-26 16:52:35 +09001641 }
Chris Parsons8d6e4332021-02-22 16:13:50 -05001642}
1643
1644// Returns true if Bazel was successfully used for the analysis of this module.
1645func (c *Module) maybeGenerateBazelActions(actx android.ModuleContext) bool {
Liz Kammerbdc60992021-02-24 16:55:11 -05001646 bazelModuleLabel := c.GetBazelLabel(actx, c)
Chris Parsons8d6e4332021-02-22 16:13:50 -05001647 bazelActionsUsed := false
Chris Parsonsbab4d7e2021-04-15 17:27:08 -04001648 if c.MixedBuildsEnabled(actx) && c.bazelHandler != nil {
Chris Parsons8d6e4332021-02-22 16:13:50 -05001649 bazelActionsUsed = c.bazelHandler.generateBazelBuildActions(actx, bazelModuleLabel)
1650 }
1651 return bazelActionsUsed
1652}
1653
1654func (c *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
1655 // TODO(cparsons): Any logic in this method occurring prior to querying Bazel should be
1656 // requested from Bazel instead.
1657
1658 // Handle the case of a test module split by `test_per_src` mutator.
1659 //
1660 // The `test_per_src` mutator adds an extra variation named "", depending on all the other
1661 // `test_per_src` variations of the test module. Set `outputFile` to an empty path for this
1662 // module and return early, as this module does not produce an output file per se.
1663 if c.IsTestPerSrcAllTestsVariation() {
1664 c.outputFile = android.OptionalPath{}
1665 return
1666 }
1667
1668 c.setSubnameProperty(actx)
1669 apexInfo := actx.Provider(android.ApexInfoProvider).(android.ApexInfo)
1670 if !apexInfo.IsForPlatform() {
1671 c.hideApexVariantFromMake = true
1672 }
1673
Chris Parsonseefc9e62021-04-02 17:36:47 -04001674 c.makeLinkType = GetMakeLinkType(actx, c)
1675
Chris Parsons8d6e4332021-02-22 16:13:50 -05001676 if c.maybeGenerateBazelActions(actx) {
1677 return
1678 }
1679
Colin Crossca860ac2016-01-04 14:34:37 -08001680 ctx := &moduleContext{
Colin Cross635c3b02016-05-18 15:37:25 -07001681 ModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08001682 moduleContextImpl: moduleContextImpl{
1683 mod: c,
1684 },
1685 }
1686 ctx.ctx = ctx
1687
Colin Crossf18e1102017-11-16 14:33:08 -08001688 deps := c.depsToPaths(ctx)
1689 if ctx.Failed() {
1690 return
1691 }
1692
Dan Willemsen8536d6b2018-10-07 20:54:34 -07001693 if c.Properties.Clang != nil && *c.Properties.Clang == false {
1694 ctx.PropertyErrorf("clang", "false (GCC) is no longer supported")
1695 }
1696
Colin Crossca860ac2016-01-04 14:34:37 -08001697 flags := Flags{
1698 Toolchain: c.toolchain(ctx),
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001699 EmitXrefs: ctx.Config().EmitXrefRules(),
Colin Crossca860ac2016-01-04 14:34:37 -08001700 }
Colin Crossca860ac2016-01-04 14:34:37 -08001701 if c.compiler != nil {
Colin Crossf18e1102017-11-16 14:33:08 -08001702 flags = c.compiler.compilerFlags(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001703 }
1704 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001705 flags = c.linker.linkerFlags(ctx, flags)
Colin Crossca860ac2016-01-04 14:34:37 -08001706 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001707 if c.stl != nil {
1708 flags = c.stl.flags(ctx, flags)
1709 }
Colin Cross16b23492016-01-06 14:41:07 -08001710 if c.sanitize != nil {
1711 flags = c.sanitize.flags(ctx, flags)
1712 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001713 if c.coverage != nil {
Pirama Arumuga Nainar82fe59b2019-07-02 14:55:35 -07001714 flags, deps = c.coverage.flags(ctx, flags, deps)
Dan Willemsen581341d2017-02-09 16:16:31 -08001715 }
Stephen Craneba090d12017-05-09 15:44:35 -07001716 if c.lto != nil {
1717 flags = c.lto.flags(ctx, flags)
1718 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001719 if c.pgo != nil {
1720 flags = c.pgo.flags(ctx, flags)
1721 }
Colin Crossca860ac2016-01-04 14:34:37 -08001722 for _, feature := range c.features {
1723 flags = feature.flags(ctx, flags)
1724 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001725 if ctx.Failed() {
1726 return
1727 }
1728
Colin Cross4af21ed2019-11-04 09:37:55 -08001729 flags.Local.CFlags, _ = filterList(flags.Local.CFlags, config.IllegalFlags)
1730 flags.Local.CppFlags, _ = filterList(flags.Local.CppFlags, config.IllegalFlags)
1731 flags.Local.ConlyFlags, _ = filterList(flags.Local.ConlyFlags, config.IllegalFlags)
Colin Cross3f40fa42015-01-30 17:27:36 -08001732
Colin Cross4af21ed2019-11-04 09:37:55 -08001733 flags.Local.CommonFlags = append(flags.Local.CommonFlags, deps.Flags...)
Inseob Kim69378442019-06-03 19:10:47 +09001734
1735 for _, dir := range deps.IncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08001736 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-I"+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09001737 }
1738 for _, dir := range deps.SystemIncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08001739 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-isystem "+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09001740 }
1741
Fabien Sanglardd61f1f42017-01-10 16:21:22 -08001742 c.flags = flags
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -07001743 // We need access to all the flags seen by a source file.
1744 if c.sabi != nil {
1745 flags = c.sabi.flags(ctx, flags)
1746 }
Dan Willemsen98ab3112019-08-27 21:20:40 -07001747
Colin Cross4af21ed2019-11-04 09:37:55 -08001748 flags.AssemblerWithCpp = inList("-xassembler-with-cpp", flags.Local.AsFlags)
Dan Willemsen98ab3112019-08-27 21:20:40 -07001749
Colin Crossca860ac2016-01-04 14:34:37 -08001750 // Optimization to reduce size of build.ninja
1751 // Replace the long list of flags for each file with a module-local variable
Colin Cross4af21ed2019-11-04 09:37:55 -08001752 ctx.Variable(pctx, "cflags", strings.Join(flags.Local.CFlags, " "))
1753 ctx.Variable(pctx, "cppflags", strings.Join(flags.Local.CppFlags, " "))
1754 ctx.Variable(pctx, "asflags", strings.Join(flags.Local.AsFlags, " "))
1755 flags.Local.CFlags = []string{"$cflags"}
1756 flags.Local.CppFlags = []string{"$cppflags"}
1757 flags.Local.AsFlags = []string{"$asflags"}
Colin Crossca860ac2016-01-04 14:34:37 -08001758
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001759 var objs Objects
Colin Crossca860ac2016-01-04 14:34:37 -08001760 if c.compiler != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001761 objs = c.compiler.compile(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001762 if ctx.Failed() {
1763 return
1764 }
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001765 c.kytheFiles = objs.kytheFiles
Colin Cross3f40fa42015-01-30 17:27:36 -08001766 }
1767
Colin Crossca860ac2016-01-04 14:34:37 -08001768 if c.linker != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001769 outputFile := c.linker.link(ctx, flags, deps, objs)
Colin Crossca860ac2016-01-04 14:34:37 -08001770 if ctx.Failed() {
1771 return
1772 }
Colin Cross635c3b02016-05-18 15:37:25 -07001773 c.outputFile = android.OptionalPathForPath(outputFile)
Jiyong Parkb0788572018-12-20 22:10:17 +09001774
Jiyong Parkf7c3bbe2020-12-09 21:18:56 +09001775 // If a lib is directly included in any of the APEXes or is not available to the
1776 // platform (which is often the case when the stub is provided as a prebuilt),
1777 // unhide the stubs variant having the latest version gets visible to make. In
1778 // addition, the non-stubs variant is renamed to <libname>.bootstrap. This is to
1779 // force anything in the make world to link against the stubs library. (unless it
1780 // is explicitly referenced via .bootstrap suffix or the module is marked with
1781 // 'bootstrap: true').
1782 if c.HasStubsVariants() && c.NotInPlatform() && !c.InRamdisk() &&
Ivan Lozano52767be2019-10-18 14:49:46 -07001783 !c.InRecovery() && !c.UseVndk() && !c.static() && !c.isCoverageVariant() &&
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001784 c.IsStubs() && !c.InVendorRamdisk() {
Jiyong Parkb0788572018-12-20 22:10:17 +09001785 c.Properties.HideFromMake = false // unhide
1786 // Note: this is still non-installable
1787 }
Inseob Kimeda2e9c2020-03-03 22:06:32 +09001788
Jose Galmes6f843bc2020-12-11 13:36:29 -08001789 // glob exported headers for snapshot, if BOARD_VNDK_VERSION is current or
1790 // RECOVERY_SNAPSHOT_VERSION is current.
1791 if i, ok := c.linker.(snapshotLibraryInterface); ok {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001792 if ShouldCollectHeadersForSnapshot(ctx, c, apexInfo) {
Inseob Kimeda2e9c2020-03-03 22:06:32 +09001793 i.collectHeadersForSnapshot(ctx)
1794 }
1795 }
Colin Crossce75d2c2016-10-06 16:12:58 -07001796 }
Colin Cross5049f022015-03-18 13:28:46 -07001797
Colin Crossa9c8c9f2020-12-16 10:20:23 -08001798 if !proptools.BoolDefault(c.Properties.Installable, true) {
1799 // If the module has been specifically configure to not be installed then
1800 // hide from make as otherwise it will break when running inside make
1801 // as the output path to install will not be specified. Not all uninstallable
1802 // modules can be hidden from make as some are needed for resolving make side
1803 // dependencies.
1804 c.HideFromMake()
Ivan Lozanod7586b62021-04-01 09:49:36 -04001805 } else if !installable(c, apexInfo) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08001806 c.SkipInstall()
1807 }
1808
1809 // Still call c.installer.install though, the installs will be stored as PackageSpecs
1810 // to allow using the outputs in a genrule.
1811 if c.installer != nil && c.outputFile.Valid() {
Colin Crossce75d2c2016-10-06 16:12:58 -07001812 c.installer.install(ctx, c.outputFile.Path())
1813 if ctx.Failed() {
1814 return
Colin Crossca860ac2016-01-04 14:34:37 -08001815 }
Dan Albertc403f7c2015-03-18 14:01:18 -07001816 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001817}
1818
Colin Cross0ea8ba82019-06-06 14:33:29 -07001819func (c *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001820 if c.cachedToolchain == nil {
Liz Kammer356f7d42021-01-26 09:18:53 -05001821 c.cachedToolchain = config.FindToolchainWithContext(ctx)
Colin Cross3f40fa42015-01-30 17:27:36 -08001822 }
Colin Crossca860ac2016-01-04 14:34:37 -08001823 return c.cachedToolchain
Colin Cross3f40fa42015-01-30 17:27:36 -08001824}
1825
Colin Crossca860ac2016-01-04 14:34:37 -08001826func (c *Module) begin(ctx BaseModuleContext) {
1827 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001828 c.compiler.compilerInit(ctx)
Colin Cross21b9a242015-03-24 14:15:58 -07001829 }
Colin Crossca860ac2016-01-04 14:34:37 -08001830 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001831 c.linker.linkerInit(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08001832 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001833 if c.stl != nil {
1834 c.stl.begin(ctx)
1835 }
Colin Cross16b23492016-01-06 14:41:07 -08001836 if c.sanitize != nil {
1837 c.sanitize.begin(ctx)
1838 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001839 if c.coverage != nil {
1840 c.coverage.begin(ctx)
1841 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001842 if c.sabi != nil {
1843 c.sabi.begin(ctx)
1844 }
Justin Yun8effde42017-06-23 19:24:43 +09001845 if c.vndkdep != nil {
1846 c.vndkdep.begin(ctx)
1847 }
Stephen Craneba090d12017-05-09 15:44:35 -07001848 if c.lto != nil {
1849 c.lto.begin(ctx)
1850 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001851 if c.pgo != nil {
1852 c.pgo.begin(ctx)
1853 }
Colin Crossca860ac2016-01-04 14:34:37 -08001854 for _, feature := range c.features {
1855 feature.begin(ctx)
1856 }
Dan Albert92fe7402020-07-15 13:33:30 -07001857 if ctx.useSdk() && c.IsSdkVariant() {
Dan Albert1a246272020-07-06 14:49:35 -07001858 version, err := nativeApiLevelFromUser(ctx, ctx.sdkVersion())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07001859 if err != nil {
1860 ctx.PropertyErrorf("sdk_version", err.Error())
Dan Albert1a246272020-07-06 14:49:35 -07001861 c.Properties.Sdk_version = nil
1862 } else {
1863 c.Properties.Sdk_version = StringPtr(version.String())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07001864 }
Dan Albert7fa7b2e2016-08-05 16:37:52 -07001865 }
Colin Crossca860ac2016-01-04 14:34:37 -08001866}
1867
Colin Cross37047f12016-12-13 17:06:13 -08001868func (c *Module) deps(ctx DepsContext) Deps {
Colin Crossc99deeb2016-04-11 15:06:20 -07001869 deps := Deps{}
1870
1871 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001872 deps = c.compiler.compilerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07001873 }
1874 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001875 deps = c.linker.linkerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07001876 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001877 if c.stl != nil {
1878 deps = c.stl.deps(ctx, deps)
1879 }
Colin Cross16b23492016-01-06 14:41:07 -08001880 if c.sanitize != nil {
1881 deps = c.sanitize.deps(ctx, deps)
1882 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00001883 if c.coverage != nil {
1884 deps = c.coverage.deps(ctx, deps)
1885 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001886 if c.sabi != nil {
1887 deps = c.sabi.deps(ctx, deps)
1888 }
Justin Yun8effde42017-06-23 19:24:43 +09001889 if c.vndkdep != nil {
1890 deps = c.vndkdep.deps(ctx, deps)
1891 }
Stephen Craneba090d12017-05-09 15:44:35 -07001892 if c.lto != nil {
1893 deps = c.lto.deps(ctx, deps)
1894 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001895 for _, feature := range c.features {
1896 deps = feature.deps(ctx, deps)
1897 }
1898
Colin Crossb6715442017-10-24 11:13:31 -07001899 deps.WholeStaticLibs = android.LastUniqueStrings(deps.WholeStaticLibs)
1900 deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
1901 deps.LateStaticLibs = android.LastUniqueStrings(deps.LateStaticLibs)
1902 deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
1903 deps.LateSharedLibs = android.LastUniqueStrings(deps.LateSharedLibs)
1904 deps.HeaderLibs = android.LastUniqueStrings(deps.HeaderLibs)
Logan Chien43d34c32017-12-20 01:17:32 +08001905 deps.RuntimeLibs = android.LastUniqueStrings(deps.RuntimeLibs)
Colin Crossc99deeb2016-04-11 15:06:20 -07001906
Liz Kammer356f7d42021-01-26 09:18:53 -05001907 // In Bazel conversion mode, we dependency and build validations will occur in Bazel, so there is
1908 // no need to do so in Soong.
1909 if ctx.BazelConversionMode() {
1910 return deps
1911 }
1912
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001913 for _, lib := range deps.ReexportSharedLibHeaders {
1914 if !inList(lib, deps.SharedLibs) {
1915 ctx.PropertyErrorf("export_shared_lib_headers", "Shared library not in shared_libs: '%s'", lib)
1916 }
1917 }
1918
1919 for _, lib := range deps.ReexportStaticLibHeaders {
Steven Morelandba407c82021-04-01 22:17:50 +00001920 if !inList(lib, deps.StaticLibs) && !inList(lib, deps.WholeStaticLibs) {
1921 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 -07001922 }
1923 }
1924
Colin Cross5950f382016-12-13 12:50:57 -08001925 for _, lib := range deps.ReexportHeaderLibHeaders {
1926 if !inList(lib, deps.HeaderLibs) {
1927 ctx.PropertyErrorf("export_header_lib_headers", "Header library not in header_libs: '%s'", lib)
1928 }
1929 }
1930
Dan Willemsenb3454ab2016-09-28 17:34:58 -07001931 for _, gen := range deps.ReexportGeneratedHeaders {
1932 if !inList(gen, deps.GeneratedHeaders) {
1933 ctx.PropertyErrorf("export_generated_headers", "Generated header module not in generated_headers: '%s'", gen)
1934 }
1935 }
1936
Colin Crossc99deeb2016-04-11 15:06:20 -07001937 return deps
1938}
1939
Dan Albert7e9d2952016-08-04 13:02:36 -07001940func (c *Module) beginMutator(actx android.BottomUpMutatorContext) {
Colin Crossca860ac2016-01-04 14:34:37 -08001941 ctx := &baseModuleContext{
Colin Cross0ea8ba82019-06-06 14:33:29 -07001942 BaseModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08001943 moduleContextImpl: moduleContextImpl{
1944 mod: c,
1945 },
1946 }
1947 ctx.ctx = ctx
1948
Colin Crossca860ac2016-01-04 14:34:37 -08001949 c.begin(ctx)
Dan Albert7e9d2952016-08-04 13:02:36 -07001950}
1951
Jiyong Park7ed9de32018-10-15 22:25:07 +09001952// Split name#version into name and version
Jiyong Park73c54ee2019-10-22 20:31:18 +09001953func StubsLibNameAndVersion(name string) (string, string) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09001954 if sharp := strings.LastIndex(name, "#"); sharp != -1 && sharp != len(name)-1 {
1955 version := name[sharp+1:]
1956 libname := name[:sharp]
1957 return libname, version
1958 }
1959 return name, ""
1960}
1961
Dan Albert92fe7402020-07-15 13:33:30 -07001962func GetCrtVariations(ctx android.BottomUpMutatorContext,
1963 m LinkableInterface) []blueprint.Variation {
1964 if ctx.Os() != android.Android {
1965 return nil
1966 }
1967 if m.UseSdk() {
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001968 // Choose the CRT that best satisfies the min_sdk_version requirement of this module
1969 minSdkVersion := m.MinSdkVersion()
1970 if minSdkVersion == "" || minSdkVersion == "apex_inherit" {
1971 minSdkVersion = m.SdkVersion()
1972 }
Dan Albert92fe7402020-07-15 13:33:30 -07001973 return []blueprint.Variation{
1974 {Mutator: "sdk", Variation: "sdk"},
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001975 {Mutator: "version", Variation: minSdkVersion},
Dan Albert92fe7402020-07-15 13:33:30 -07001976 }
1977 }
1978 return []blueprint.Variation{
1979 {Mutator: "sdk", Variation: ""},
1980 }
1981}
1982
Colin Crosse7257d22020-09-24 09:56:18 -07001983func (c *Module) addSharedLibDependenciesWithVersions(ctx android.BottomUpMutatorContext,
1984 variations []blueprint.Variation, depTag libraryDependencyTag, name, version string, far bool) {
1985
1986 variations = append([]blueprint.Variation(nil), variations...)
1987
Colin Cross3146c5c2020-09-30 15:34:40 -07001988 if version != "" && CanBeOrLinkAgainstVersionVariants(c) {
Colin Crosse7257d22020-09-24 09:56:18 -07001989 // Version is explicitly specified. i.e. libFoo#30
1990 variations = append(variations, blueprint.Variation{Mutator: "version", Variation: version})
1991 depTag.explicitlyVersioned = true
1992 }
Colin Crosse7257d22020-09-24 09:56:18 -07001993
Colin Cross0de8a1e2020-09-18 14:15:30 -07001994 if far {
1995 ctx.AddFarVariationDependencies(variations, depTag, name)
1996 } else {
1997 ctx.AddVariationDependencies(variations, depTag, name)
Colin Crosse7257d22020-09-24 09:56:18 -07001998 }
1999}
2000
Colin Cross1e676be2016-10-12 14:38:15 -07002001func (c *Module) DepsMutator(actx android.BottomUpMutatorContext) {
Inseob Kimeec88e12020-01-22 11:11:29 +09002002 if !c.Enabled() {
2003 return
2004 }
2005
Colin Cross37047f12016-12-13 17:06:13 -08002006 ctx := &depsContext{
2007 BottomUpMutatorContext: actx,
Dan Albert7e9d2952016-08-04 13:02:36 -07002008 moduleContextImpl: moduleContextImpl{
2009 mod: c,
2010 },
2011 }
2012 ctx.ctx = ctx
Colin Crossca860ac2016-01-04 14:34:37 -08002013
Colin Crossc99deeb2016-04-11 15:06:20 -07002014 deps := c.deps(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08002015
Yo Chiang219968c2020-09-22 18:45:04 +08002016 c.Properties.AndroidMkSystemSharedLibs = deps.SystemSharedLibs
2017
Colin Crosse0edaf92021-01-11 17:31:17 -08002018 var snapshotInfo *SnapshotInfo
2019 getSnapshot := func() SnapshotInfo {
2020 // Only modules with BOARD_VNDK_VERSION uses snapshot. Others use the zero value of
2021 // SnapshotInfo, which provides no mappings.
2022 if snapshotInfo == nil {
2023 // Only retrieve the snapshot on demand in order to avoid circular dependencies
2024 // between the modules in the snapshot and the snapshot itself.
2025 var snapshotModule []blueprint.Module
2026 if c.InVendor() && c.VndkVersion() == actx.DeviceConfig().VndkVersion() {
2027 snapshotModule = ctx.AddVariationDependencies(nil, nil, "vendor_snapshot")
2028 } else if recoverySnapshotVersion := actx.DeviceConfig().RecoverySnapshotVersion(); recoverySnapshotVersion != "current" && recoverySnapshotVersion != "" && c.InRecovery() {
2029 snapshotModule = ctx.AddVariationDependencies(nil, nil, "recovery_snapshot")
2030 }
2031 if len(snapshotModule) > 0 {
2032 snapshot := ctx.OtherModuleProvider(snapshotModule[0], SnapshotInfoProvider).(SnapshotInfo)
2033 snapshotInfo = &snapshot
2034 // republish the snapshot for use in later mutators on this module
2035 ctx.SetProvider(SnapshotInfoProvider, snapshot)
2036 } else {
2037 snapshotInfo = &SnapshotInfo{}
2038 }
2039 }
2040
2041 return *snapshotInfo
2042 }
2043
2044 rewriteSnapshotLib := func(lib string, snapshotMap map[string]string) string {
2045 if snapshot, ok := snapshotMap[lib]; ok {
2046 return snapshot
2047 }
2048
2049 return lib
2050 }
2051
Dan Albert914449f2016-06-17 16:45:24 -07002052 variantNdkLibs := []string{}
2053 variantLateNdkLibs := []string{}
Dan Willemsenb916b802017-03-19 13:44:32 -07002054 if ctx.Os() == android.Android {
Inseob Kimeec88e12020-01-22 11:11:29 +09002055 // rewriteLibs takes a list of names of shared libraries and scans it for three types
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002056 // of names:
Dan Albert914449f2016-06-17 16:45:24 -07002057 //
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002058 // 1. Name of an NDK library that refers to a prebuilt module.
2059 // For each of these, it adds the name of the prebuilt module (which will be in
2060 // prebuilts/ndk) to the list of nonvariant libs.
2061 // 2. Name of an NDK library that refers to an ndk_library module.
2062 // For each of these, it adds the name of the ndk_library module to the list of
2063 // variant libs.
2064 // 3. Anything else (so anything that isn't an NDK library).
2065 // It adds these to the nonvariantLibs list.
Dan Albert914449f2016-06-17 16:45:24 -07002066 //
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002067 // The caller can then know to add the variantLibs dependencies differently from the
2068 // nonvariantLibs
Inseob Kim9516ee92019-05-09 10:56:13 +09002069
Inseob Kimeec88e12020-01-22 11:11:29 +09002070 rewriteLibs := func(list []string) (nonvariantLibs []string, variantLibs []string) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002071 variantLibs = []string{}
2072 nonvariantLibs = []string{}
Dan Albert914449f2016-06-17 16:45:24 -07002073 for _, entry := range list {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002074 // strip #version suffix out
Jiyong Park73c54ee2019-10-22 20:31:18 +09002075 name, _ := StubsLibNameAndVersion(entry)
Jose Galmes6f843bc2020-12-11 13:36:29 -08002076 if c.InRecovery() {
Colin Crosse0edaf92021-01-11 17:31:17 -08002077 nonvariantLibs = append(nonvariantLibs, rewriteSnapshotLib(entry, getSnapshot().SharedLibs))
Jose Galmes6f843bc2020-12-11 13:36:29 -08002078 } else if ctx.useSdk() && inList(name, *getNDKKnownLibs(ctx.Config())) {
Dan Albertde5aade2020-06-30 12:32:51 -07002079 variantLibs = append(variantLibs, name+ndkLibrarySuffix)
Colin Crossb719c012021-04-26 14:35:38 -07002080 } else if ctx.useVndk() {
2081 nonvariantLibs = append(nonvariantLibs, rewriteSnapshotLib(entry, getSnapshot().SharedLibs))
Dan Albert914449f2016-06-17 16:45:24 -07002082 } else {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002083 // put name#version back
Dan Willemsen7cbf5f82017-03-28 00:08:30 -07002084 nonvariantLibs = append(nonvariantLibs, entry)
Dan Willemsen72d39932016-07-08 23:23:48 -07002085 }
2086 }
Dan Albert914449f2016-06-17 16:45:24 -07002087 return nonvariantLibs, variantLibs
Dan Willemsen72d39932016-07-08 23:23:48 -07002088 }
2089
Inseob Kimeec88e12020-01-22 11:11:29 +09002090 deps.SharedLibs, variantNdkLibs = rewriteLibs(deps.SharedLibs)
2091 deps.LateSharedLibs, variantLateNdkLibs = rewriteLibs(deps.LateSharedLibs)
2092 deps.ReexportSharedLibHeaders, _ = rewriteLibs(deps.ReexportSharedLibHeaders)
Colin Crosse0edaf92021-01-11 17:31:17 -08002093
2094 for idx, lib := range deps.RuntimeLibs {
2095 deps.RuntimeLibs[idx] = rewriteSnapshotLib(lib, getSnapshot().SharedLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002096 }
Dan Willemsen72d39932016-07-08 23:23:48 -07002097 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002098
Colin Cross32ec36c2016-12-15 07:39:51 -08002099 for _, lib := range deps.HeaderLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002100 depTag := libraryDependencyTag{Kind: headerLibraryDependency}
Colin Cross32ec36c2016-12-15 07:39:51 -08002101 if inList(lib, deps.ReexportHeaderLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002102 depTag.reexportFlags = true
Colin Cross32ec36c2016-12-15 07:39:51 -08002103 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002104
Colin Crosse0edaf92021-01-11 17:31:17 -08002105 lib = rewriteSnapshotLib(lib, getSnapshot().HeaderLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002106
Jiyong Park1ad8e162020-12-01 23:40:09 +09002107 if c.IsStubs() {
Colin Cross7228ecd2019-11-18 16:00:16 -08002108 actx.AddFarVariationDependencies(append(ctx.Target().Variations(), c.ImageVariation()),
Colin Cross0f7d2ef2019-10-16 11:03:10 -07002109 depTag, lib)
Jiyong Park7e636d02019-01-28 16:16:54 +09002110 } else {
2111 actx.AddVariationDependencies(nil, depTag, lib)
2112 }
2113 }
2114
Inseob Kim07def122020-11-23 14:43:02 +09002115 // sysprop_library has to support both C++ and Java. So sysprop_library internally creates one
2116 // C++ implementation library and one Java implementation library. When a module links against
2117 // sysprop_library, the C++ implementation library has to be linked. syspropImplLibraries is a
2118 // map from sysprop_library to implementation library; it will be used in whole_static_libs,
2119 // static_libs, and shared_libs.
Inseob Kimc0907f12019-02-08 21:00:45 +09002120 syspropImplLibraries := syspropImplLibraries(actx.Config())
2121
Jiyong Park5d1598f2019-02-25 22:14:17 +09002122 for _, lib := range deps.WholeStaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002123 depTag := libraryDependencyTag{Kind: staticLibraryDependency, wholeStatic: true, reexportFlags: true}
Jiyong Park5d1598f2019-02-25 22:14:17 +09002124 if impl, ok := syspropImplLibraries[lib]; ok {
2125 lib = impl
2126 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002127
Colin Crosse0edaf92021-01-11 17:31:17 -08002128 lib = rewriteSnapshotLib(lib, getSnapshot().StaticLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002129
Jiyong Park5d1598f2019-02-25 22:14:17 +09002130 actx.AddVariationDependencies([]blueprint.Variation{
2131 {Mutator: "link", Variation: "static"},
2132 }, depTag, lib)
2133 }
2134
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002135 for _, lib := range deps.StaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002136 depTag := libraryDependencyTag{Kind: staticLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002137 if inList(lib, deps.ReexportStaticLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002138 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002139 }
Jiyong Parke3867542020-12-03 17:28:25 +09002140 if inList(lib, deps.ExcludeLibsForApex) {
2141 depTag.excludeInApex = true
2142 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002143
2144 if impl, ok := syspropImplLibraries[lib]; ok {
2145 lib = impl
2146 }
2147
Colin Crosse0edaf92021-01-11 17:31:17 -08002148 lib = rewriteSnapshotLib(lib, getSnapshot().StaticLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002149
Dan Willemsen59339a22018-07-22 21:18:45 -07002150 actx.AddVariationDependencies([]blueprint.Variation{
2151 {Mutator: "link", Variation: "static"},
2152 }, depTag, lib)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002153 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002154
Jooyung Han75568392020-03-20 04:29:24 +09002155 // staticUnwinderDep is treated as staticDep for Q apexes
2156 // so that native libraries/binaries are linked with static unwinder
2157 // because Q libc doesn't have unwinder APIs
2158 if deps.StaticUnwinderIfLegacy {
Colin Cross6e511a92020-07-27 21:26:48 -07002159 depTag := libraryDependencyTag{Kind: staticLibraryDependency, staticUnwinder: true}
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002160 actx.AddVariationDependencies([]blueprint.Variation{
2161 {Mutator: "link", Variation: "static"},
Colin Crosse0edaf92021-01-11 17:31:17 -08002162 }, depTag, rewriteSnapshotLib(staticUnwinder(actx), getSnapshot().StaticLibs))
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002163 }
2164
Inseob Kimeec88e12020-01-22 11:11:29 +09002165 for _, lib := range deps.LateStaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002166 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency}
Inseob Kimeec88e12020-01-22 11:11:29 +09002167 actx.AddVariationDependencies([]blueprint.Variation{
2168 {Mutator: "link", Variation: "static"},
Colin Crosse0edaf92021-01-11 17:31:17 -08002169 }, depTag, rewriteSnapshotLib(lib, getSnapshot().StaticLibs))
Inseob Kimeec88e12020-01-22 11:11:29 +09002170 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002171
Jiyong Park7ed9de32018-10-15 22:25:07 +09002172 // shared lib names without the #version suffix
2173 var sharedLibNames []string
2174
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002175 for _, lib := range deps.SharedLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002176 depTag := libraryDependencyTag{Kind: sharedLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002177 if inList(lib, deps.ReexportSharedLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002178 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002179 }
Jiyong Parke3867542020-12-03 17:28:25 +09002180 if inList(lib, deps.ExcludeLibsForApex) {
2181 depTag.excludeInApex = true
2182 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002183
2184 if impl, ok := syspropImplLibraries[lib]; ok {
2185 lib = impl
2186 }
2187
Jiyong Park73c54ee2019-10-22 20:31:18 +09002188 name, version := StubsLibNameAndVersion(lib)
Inseob Kimc0907f12019-02-08 21:00:45 +09002189 sharedLibNames = append(sharedLibNames, name)
2190
Colin Crosse7257d22020-09-24 09:56:18 -07002191 variations := []blueprint.Variation{
2192 {Mutator: "link", Variation: "shared"},
2193 }
2194 c.addSharedLibDependenciesWithVersions(ctx, variations, depTag, name, version, false)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002195 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002196
Jiyong Park7ed9de32018-10-15 22:25:07 +09002197 for _, lib := range deps.LateSharedLibs {
Jiyong Park25fc6a92018-11-18 18:02:45 +09002198 if inList(lib, sharedLibNames) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002199 // This is to handle the case that some of the late shared libs (libc, libdl, libm, ...)
2200 // are added also to SharedLibs with version (e.g., libc#10). If not skipped, we will be
2201 // linking against both the stubs lib and the non-stubs lib at the same time.
2202 continue
2203 }
Colin Cross6e511a92020-07-27 21:26:48 -07002204 depTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency}
Colin Crosse7257d22020-09-24 09:56:18 -07002205 variations := []blueprint.Variation{
2206 {Mutator: "link", Variation: "shared"},
2207 }
2208 c.addSharedLibDependenciesWithVersions(ctx, variations, depTag, lib, "", false)
Jiyong Park7ed9de32018-10-15 22:25:07 +09002209 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002210
Dan Willemsen59339a22018-07-22 21:18:45 -07002211 actx.AddVariationDependencies([]blueprint.Variation{
2212 {Mutator: "link", Variation: "shared"},
Chris Parsons79d66a52020-06-05 17:26:16 -04002213 }, dataLibDepTag, deps.DataLibs...)
2214
2215 actx.AddVariationDependencies([]blueprint.Variation{
2216 {Mutator: "link", Variation: "shared"},
Dan Willemsen59339a22018-07-22 21:18:45 -07002217 }, runtimeDepTag, deps.RuntimeLibs...)
Logan Chien43d34c32017-12-20 01:17:32 +08002218
Colin Cross68861832016-07-08 10:41:41 -07002219 actx.AddDependency(c, genSourceDepTag, deps.GeneratedSources...)
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002220
2221 for _, gen := range deps.GeneratedHeaders {
2222 depTag := genHeaderDepTag
2223 if inList(gen, deps.ReexportGeneratedHeaders) {
2224 depTag = genHeaderExportDepTag
2225 }
2226 actx.AddDependency(c, depTag, gen)
2227 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002228
Dan Albert92fe7402020-07-15 13:33:30 -07002229 crtVariations := GetCrtVariations(ctx, c)
Colin Crossbbc941b2020-09-30 12:27:01 -07002230 actx.AddVariationDependencies(crtVariations, objDepTag, deps.ObjFiles...)
Colin Crossc99deeb2016-04-11 15:06:20 -07002231 if deps.CrtBegin != "" {
Dan Albert92fe7402020-07-15 13:33:30 -07002232 actx.AddVariationDependencies(crtVariations, CrtBeginDepTag,
Colin Crosse0edaf92021-01-11 17:31:17 -08002233 rewriteSnapshotLib(deps.CrtBegin, getSnapshot().Objects))
Colin Crossca860ac2016-01-04 14:34:37 -08002234 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002235 if deps.CrtEnd != "" {
Dan Albert92fe7402020-07-15 13:33:30 -07002236 actx.AddVariationDependencies(crtVariations, CrtEndDepTag,
Colin Crosse0edaf92021-01-11 17:31:17 -08002237 rewriteSnapshotLib(deps.CrtEnd, getSnapshot().Objects))
Colin Cross21b9a242015-03-24 14:15:58 -07002238 }
Dan Willemsena0790e32018-10-12 00:24:23 -07002239 if deps.LinkerFlagsFile != "" {
2240 actx.AddDependency(c, linkerFlagsDepTag, deps.LinkerFlagsFile)
2241 }
2242 if deps.DynamicLinker != "" {
2243 actx.AddDependency(c, dynamicLinkerDepTag, deps.DynamicLinker)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002244 }
Dan Albert914449f2016-06-17 16:45:24 -07002245
2246 version := ctx.sdkVersion()
Colin Cross6e511a92020-07-27 21:26:48 -07002247
2248 ndkStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002249 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002250 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002251 {Mutator: "link", Variation: "shared"},
2252 }, ndkStubDepTag, variantNdkLibs...)
Colin Cross6e511a92020-07-27 21:26:48 -07002253
2254 ndkLateStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002255 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002256 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002257 {Mutator: "link", Variation: "shared"},
2258 }, ndkLateStubDepTag, variantLateNdkLibs...)
Logan Chienf3511742017-10-31 18:04:35 +08002259
2260 if vndkdep := c.vndkdep; vndkdep != nil {
2261 if vndkdep.isVndkExt() {
Logan Chienf3511742017-10-31 18:04:35 +08002262 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross7228ecd2019-11-18 16:00:16 -08002263 c.ImageVariation(),
Dan Willemsen59339a22018-07-22 21:18:45 -07002264 {Mutator: "link", Variation: "shared"},
2265 }, vndkExtDepTag, vndkdep.getVndkExtendsModuleName())
Logan Chienf3511742017-10-31 18:04:35 +08002266 }
2267 }
Colin Cross6362e272015-10-29 15:25:03 -07002268}
Colin Cross21b9a242015-03-24 14:15:58 -07002269
Colin Crosse40b4ea2018-10-02 22:25:58 -07002270func BeginMutator(ctx android.BottomUpMutatorContext) {
Dan Albert7e9d2952016-08-04 13:02:36 -07002271 if c, ok := ctx.Module().(*Module); ok && c.Enabled() {
2272 c.beginMutator(ctx)
2273 }
2274}
2275
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002276// Whether a module can link to another module, taking into
2277// account NDK linking.
Jooyung Han479ca172020-10-19 18:51:07 +09002278func checkLinkType(ctx android.BaseModuleContext, from LinkableInterface, to LinkableInterface,
Colin Cross6e511a92020-07-27 21:26:48 -07002279 tag blueprint.DependencyTag) {
2280
2281 switch t := tag.(type) {
2282 case dependencyTag:
2283 if t != vndkExtDepTag {
2284 return
2285 }
2286 case libraryDependencyTag:
2287 default:
2288 return
2289 }
2290
Ivan Lozanof9e21722020-12-02 09:00:51 -05002291 if from.Target().Os != android.Android {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002292 // Host code is not restricted
2293 return
2294 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002295
2296 // VNDK is cc.Module supported only for now.
2297 if ccFrom, ok := from.(*Module); ok && from.UseVndk() {
Justin Yun63e9ec72020-10-29 16:49:43 +09002298 // Though allowed dependency is limited by the image mutator,
2299 // each vendor and product module needs to check link-type
2300 // for VNDK.
Ivan Lozano52767be2019-10-18 14:49:46 -07002301 if ccTo, ok := to.(*Module); ok {
2302 if ccFrom.vndkdep != nil {
2303 ccFrom.vndkdep.vndkCheckLinkType(ctx, ccTo, tag)
2304 }
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002305 } else if _, ok := to.(LinkableInterface); !ok {
Ivan Lozano52767be2019-10-18 14:49:46 -07002306 ctx.ModuleErrorf("Attempting to link VNDK cc.Module with unsupported module type")
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002307 }
2308 return
2309 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002310 if from.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002311 // Platform code can link to anything
2312 return
2313 }
Yifan Hong1b3348d2020-01-21 15:53:22 -08002314 if from.InRamdisk() {
2315 // Ramdisk code is not NDK
2316 return
2317 }
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002318 if from.InVendorRamdisk() {
2319 // Vendor ramdisk code is not NDK
2320 return
2321 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002322 if from.InRecovery() {
Jiyong Parkf9332f12018-02-01 00:54:12 +09002323 // Recovery code is not NDK
2324 return
2325 }
Colin Cross31076b32020-10-23 17:22:06 -07002326 if c, ok := to.(*Module); ok {
2327 if c.ToolchainLibrary() {
2328 // These are always allowed
2329 return
2330 }
2331 if c.NdkPrebuiltStl() {
2332 // These are allowed, but they don't set sdk_version
2333 return
2334 }
2335 if c.StubDecorator() {
2336 // These aren't real libraries, but are the stub shared libraries that are included in
2337 // the NDK.
2338 return
2339 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002340 }
Logan Chien834b9a62019-01-14 15:39:03 +08002341
Ivan Lozano52767be2019-10-18 14:49:46 -07002342 if strings.HasPrefix(ctx.ModuleName(), "libclang_rt.") && to.Module().Name() == "libc++" {
Logan Chien834b9a62019-01-14 15:39:03 +08002343 // Bug: http://b/121358700 - Allow libclang_rt.* shared libraries (with sdk_version)
2344 // to link to libc++ (non-NDK and without sdk_version).
2345 return
2346 }
2347
Ivan Lozano52767be2019-10-18 14:49:46 -07002348 if to.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002349 // NDK code linking to platform code is never okay.
2350 ctx.ModuleErrorf("depends on non-NDK-built library %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002351 ctx.OtherModuleName(to.Module()))
Dan Willemsen155d17c2019-02-06 18:30:02 -08002352 return
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002353 }
2354
2355 // At this point we know we have two NDK libraries, but we need to
2356 // check that we're not linking against anything built against a higher
2357 // API level, as it is only valid to link against older or equivalent
2358 // APIs.
2359
Inseob Kim01a28722018-04-11 09:48:45 +09002360 // Current can link against anything.
Ivan Lozano52767be2019-10-18 14:49:46 -07002361 if from.SdkVersion() != "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002362 // Otherwise we need to check.
Ivan Lozano52767be2019-10-18 14:49:46 -07002363 if to.SdkVersion() == "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002364 // Current can't be linked against by anything else.
2365 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002366 ctx.OtherModuleName(to.Module()), "current")
Inseob Kim01a28722018-04-11 09:48:45 +09002367 } else {
Ivan Lozano52767be2019-10-18 14:49:46 -07002368 fromApi, err := strconv.Atoi(from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002369 if err != nil {
2370 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002371 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002372 from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002373 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002374 toApi, err := strconv.Atoi(to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002375 if err != nil {
2376 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002377 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002378 to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002379 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002380
Inseob Kim01a28722018-04-11 09:48:45 +09002381 if toApi > fromApi {
2382 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002383 ctx.OtherModuleName(to.Module()), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002384 }
2385 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002386 }
Dan Albert202fe492017-12-15 13:56:59 -08002387
2388 // Also check that the two STL choices are compatible.
Ivan Lozano52767be2019-10-18 14:49:46 -07002389 fromStl := from.SelectedStl()
2390 toStl := to.SelectedStl()
Dan Albert202fe492017-12-15 13:56:59 -08002391 if fromStl == "" || toStl == "" {
2392 // Libraries that don't use the STL are unrestricted.
Inseob Kimda2171a2018-04-11 15:41:38 +09002393 } else if fromStl == "ndk_system" || toStl == "ndk_system" {
Dan Albert202fe492017-12-15 13:56:59 -08002394 // We can be permissive with the system "STL" since it is only the C++
2395 // ABI layer, but in the future we should make sure that everyone is
2396 // using either libc++ or nothing.
Colin Crossb60190a2018-09-04 16:28:17 -07002397 } else if getNdkStlFamily(from) != getNdkStlFamily(to) {
Dan Albert202fe492017-12-15 13:56:59 -08002398 ctx.ModuleErrorf("uses %q and depends on %q which uses incompatible %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002399 from.SelectedStl(), ctx.OtherModuleName(to.Module()),
2400 to.SelectedStl())
Dan Albert202fe492017-12-15 13:56:59 -08002401 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002402}
2403
Jooyung Han479ca172020-10-19 18:51:07 +09002404func checkLinkTypeMutator(ctx android.BottomUpMutatorContext) {
2405 if c, ok := ctx.Module().(*Module); ok {
2406 ctx.VisitDirectDeps(func(dep android.Module) {
2407 depTag := ctx.OtherModuleDependencyTag(dep)
2408 ccDep, ok := dep.(LinkableInterface)
2409 if ok {
2410 checkLinkType(ctx, c, ccDep, depTag)
2411 }
2412 })
2413 }
2414}
2415
Jiyong Park5fb8c102018-04-09 12:03:06 +09002416// Tests whether the dependent library is okay to be double loaded inside a single process.
Jooyung Hana70f0672019-01-18 15:20:43 +09002417// If a library has a vendor variant and is a (transitive) dependency of an LLNDK library,
2418// it is subject to be double loaded. Such lib should be explicitly marked as double_loadable: true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002419// or as vndk-sp (vndk: { enabled: true, support_system_process: true}).
Jooyung Hana70f0672019-01-18 15:20:43 +09002420func checkDoubleLoadableLibraries(ctx android.TopDownMutatorContext) {
2421 check := func(child, parent android.Module) bool {
2422 to, ok := child.(*Module)
2423 if !ok {
Jooyung Han479ca172020-10-19 18:51:07 +09002424 return false
Jooyung Hana70f0672019-01-18 15:20:43 +09002425 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002426
Jooyung Hana70f0672019-01-18 15:20:43 +09002427 if lib, ok := to.linker.(*libraryDecorator); !ok || !lib.shared() {
2428 return false
Jiyong Park5fb8c102018-04-09 12:03:06 +09002429 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002430
Jiyong Park0474e1f2021-01-14 14:26:06 +09002431 // These dependencies are not excercised at runtime. Tracking these will give us
2432 // false negative, so skip.
Jiyong Park1ad8e162020-12-01 23:40:09 +09002433 depTag := ctx.OtherModuleDependencyTag(child)
2434 if IsHeaderDepTag(depTag) {
2435 return false
2436 }
Jiyong Park0474e1f2021-01-14 14:26:06 +09002437 if depTag == staticVariantTag {
2438 return false
2439 }
2440 if depTag == stubImplDepTag {
2441 return false
2442 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002443
Justin Yun63e9ec72020-10-29 16:49:43 +09002444 // Even if target lib has no vendor variant, keep checking dependency
2445 // graph in case it depends on vendor_available or product_available
2446 // but not double_loadable transtively.
2447 if !to.HasNonSystemVariants() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002448 return true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002449 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002450
Jiyong Park0474e1f2021-01-14 14:26:06 +09002451 // The happy path. Keep tracking dependencies until we hit a non double-loadable
2452 // one.
2453 if Bool(to.VendorProperties.Double_loadable) {
2454 return true
2455 }
2456
Ivan Lozanod7586b62021-04-01 09:49:36 -04002457 if to.IsVndkSp() || to.IsLlndk() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002458 return false
2459 }
2460
Jooyung Hana70f0672019-01-18 15:20:43 +09002461 ctx.ModuleErrorf("links a library %q which is not LL-NDK, "+
2462 "VNDK-SP, or explicitly marked as 'double_loadable:true'. "+
Jiyong Park0474e1f2021-01-14 14:26:06 +09002463 "Dependency list: %s", ctx.OtherModuleName(to), ctx.GetPathString(false))
Jooyung Hana70f0672019-01-18 15:20:43 +09002464 return false
2465 }
2466 if module, ok := ctx.Module().(*Module); ok {
2467 if lib, ok := module.linker.(*libraryDecorator); ok && lib.shared() {
Jiyong Park0474e1f2021-01-14 14:26:06 +09002468 if lib.hasLLNDKStubs() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002469 ctx.WalkDeps(check)
2470 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002471 }
2472 }
2473}
2474
Colin Crossc99deeb2016-04-11 15:06:20 -07002475// Convert dependencies to paths. Returns a PathDeps containing paths
Colin Cross635c3b02016-05-18 15:37:25 -07002476func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
Colin Crossca860ac2016-01-04 14:34:37 -08002477 var depPaths PathDeps
Colin Crossca860ac2016-01-04 14:34:37 -08002478
Colin Cross0de8a1e2020-09-18 14:15:30 -07002479 var directStaticDeps []StaticLibraryInfo
2480 var directSharedDeps []SharedLibraryInfo
Jeff Gaston294356f2017-09-27 17:05:30 -07002481
Colin Cross0de8a1e2020-09-18 14:15:30 -07002482 reexportExporter := func(exporter FlagExporterInfo) {
2483 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, exporter.IncludeDirs...)
2484 depPaths.ReexportedSystemDirs = append(depPaths.ReexportedSystemDirs, exporter.SystemIncludeDirs...)
2485 depPaths.ReexportedFlags = append(depPaths.ReexportedFlags, exporter.Flags...)
2486 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, exporter.Deps...)
2487 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders, exporter.GeneratedHeaders...)
Inseob Kim69378442019-06-03 19:10:47 +09002488 }
2489
Jooyung Hande34d232020-07-23 13:04:15 +09002490 // For the dependency from platform to apex, use the latest stubs
2491 c.apexSdkVersion = android.FutureApiLevel
Colin Cross56a83212020-09-15 18:30:11 -07002492 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
2493 if !apexInfo.IsForPlatform() {
Jiyong Park4eab21d2021-04-15 15:17:54 +09002494 c.apexSdkVersion = apexInfo.MinSdkVersion
Jooyung Hande34d232020-07-23 13:04:15 +09002495 }
2496
2497 if android.InList("hwaddress", ctx.Config().SanitizeDevice()) {
2498 // In hwasan build, we override apexSdkVersion to the FutureApiLevel(10000)
2499 // so that even Q(29/Android10) apexes could use the dynamic unwinder by linking the newer stubs(e.g libc(R+)).
2500 // (b/144430859)
2501 c.apexSdkVersion = android.FutureApiLevel
2502 }
2503
Colin Crossd11fcda2017-10-23 17:59:01 -07002504 ctx.VisitDirectDeps(func(dep android.Module) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002505 depName := ctx.OtherModuleName(dep)
2506 depTag := ctx.OtherModuleDependencyTag(dep)
Dan Albert9e10cd42016-08-03 14:12:14 -07002507
Ivan Lozano52767be2019-10-18 14:49:46 -07002508 ccDep, ok := dep.(LinkableInterface)
2509 if !ok {
2510
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002511 // handling for a few module types that aren't cc Module but that are also supported
2512 switch depTag {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002513 case genSourceDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002514 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002515 depPaths.GeneratedSources = append(depPaths.GeneratedSources,
2516 genRule.GeneratedSourceFiles()...)
2517 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002518 ctx.ModuleErrorf("module %q is not a gensrcs or genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002519 }
Colin Crosse90bfd12017-04-26 16:59:26 -07002520 // Support exported headers from a generated_sources dependency
2521 fallthrough
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002522 case genHeaderDepTag, genHeaderExportDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002523 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Inseob Kimd110f872019-12-06 13:15:38 +09002524 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps,
Dan Willemsen9da9d492018-02-21 18:28:18 -08002525 genRule.GeneratedDeps()...)
Jiyong Park74955042019-10-22 20:19:51 +09002526 dirs := genRule.GeneratedHeaderDirs()
Inseob Kim69378442019-06-03 19:10:47 +09002527 depPaths.IncludeDirs = append(depPaths.IncludeDirs, dirs...)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002528 if depTag == genHeaderExportDepTag {
Inseob Kim69378442019-06-03 19:10:47 +09002529 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, dirs...)
Inseob Kimd110f872019-12-06 13:15:38 +09002530 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders,
2531 genRule.GeneratedSourceFiles()...)
Inseob Kim69378442019-06-03 19:10:47 +09002532 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, genRule.GeneratedDeps()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002533 // 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 +09002534 c.sabi.Properties.ReexportedIncludes = append(c.sabi.Properties.ReexportedIncludes, dirs.Strings()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002535
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002536 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002537 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002538 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002539 }
Dan Willemsena0790e32018-10-12 00:24:23 -07002540 case linkerFlagsDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002541 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002542 files := genRule.GeneratedSourceFiles()
2543 if len(files) == 1 {
Dan Willemsena0790e32018-10-12 00:24:23 -07002544 depPaths.LinkerFlagsFile = android.OptionalPathForPath(files[0])
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002545 } else if len(files) > 1 {
Dan Willemsena0790e32018-10-12 00:24:23 -07002546 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 -07002547 }
2548 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002549 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002550 }
Colin Crossca860ac2016-01-04 14:34:37 -08002551 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002552 return
2553 }
2554
Colin Crossfe17f6f2019-03-28 19:30:56 -07002555 if depTag == android.ProtoPluginDepTag {
2556 return
2557 }
2558
Colin Crossd11fcda2017-10-23 17:59:01 -07002559 if dep.Target().Os != ctx.Os() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002560 ctx.ModuleErrorf("OS mismatch between %q and %q", ctx.ModuleName(), depName)
2561 return
2562 }
Colin Crossd11fcda2017-10-23 17:59:01 -07002563 if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
Jooyung Han61b66e92020-03-21 14:21:46 +00002564 ctx.ModuleErrorf("Arch mismatch between %q(%v) and %q(%v)",
2565 ctx.ModuleName(), ctx.Arch().ArchType, depName, dep.Target().Arch.ArchType)
Colin Crossa1ad8d12016-06-01 17:09:44 -07002566 return
2567 }
2568
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002569 if depTag == reuseObjTag {
Colin Crossa717db72020-10-23 14:53:06 -07002570 // Skip reused objects for stub libraries, they use their own stub object file instead.
2571 // The reuseObjTag dependency still exists because the LinkageMutator runs before the
2572 // version mutator, so the stubs variant is created from the shared variant that
2573 // already has the reuseObjTag dependency on the static variant.
Colin Cross31076b32020-10-23 17:22:06 -07002574 if !c.library.buildStubs() {
Colin Crossa717db72020-10-23 14:53:06 -07002575 staticAnalogue := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
2576 objs := staticAnalogue.ReuseObjects
2577 depPaths.Objs = depPaths.Objs.Append(objs)
2578 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
2579 reexportExporter(depExporterInfo)
2580 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07002581 return
Jiyong Parke4bb9862019-02-01 00:31:10 +09002582 }
2583
Colin Cross6e511a92020-07-27 21:26:48 -07002584 linkFile := ccDep.OutputFile()
2585
2586 if libDepTag, ok := depTag.(libraryDependencyTag); ok {
2587 // Only use static unwinder for legacy (min_sdk_version = 29) apexes (b/144430859)
Dan Albertc8060532020-07-22 22:32:17 -07002588 if libDepTag.staticUnwinder && c.apexSdkVersion.GreaterThan(android.SdkVersion_Android10) {
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002589 return
2590 }
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002591
Jiyong Parke3867542020-12-03 17:28:25 +09002592 if !apexInfo.IsForPlatform() && libDepTag.excludeInApex {
2593 return
2594 }
2595
Colin Cross0de8a1e2020-09-18 14:15:30 -07002596 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
Colin Crossc99deeb2016-04-11 15:06:20 -07002597
Colin Cross6e511a92020-07-27 21:26:48 -07002598 var ptr *android.Paths
2599 var depPtr *android.Paths
Colin Crossc99deeb2016-04-11 15:06:20 -07002600
Colin Cross6e511a92020-07-27 21:26:48 -07002601 depFile := android.OptionalPath{}
Colin Cross26c34ed2016-09-30 17:10:16 -07002602
Colin Cross6e511a92020-07-27 21:26:48 -07002603 switch {
2604 case libDepTag.header():
Colin Cross649d8172020-12-10 12:30:21 -08002605 if !ctx.OtherModuleHasProvider(dep, HeaderLibraryInfoProvider) {
2606 if !ctx.Config().AllowMissingDependencies() {
2607 ctx.ModuleErrorf("module %q is not a header library", depName)
2608 } else {
2609 ctx.AddMissingDependencies([]string{depName})
2610 }
2611 return
2612 }
Colin Cross6e511a92020-07-27 21:26:48 -07002613 case libDepTag.shared():
Colin Cross0de8a1e2020-09-18 14:15:30 -07002614 if !ctx.OtherModuleHasProvider(dep, SharedLibraryInfoProvider) {
2615 if !ctx.Config().AllowMissingDependencies() {
2616 ctx.ModuleErrorf("module %q is not a shared library", depName)
2617 } else {
2618 ctx.AddMissingDependencies([]string{depName})
2619 }
2620 return
2621 }
Jiyong Parke3867542020-12-03 17:28:25 +09002622
Colin Cross0de8a1e2020-09-18 14:15:30 -07002623 sharedLibraryInfo := ctx.OtherModuleProvider(dep, SharedLibraryInfoProvider).(SharedLibraryInfo)
Chris Parsons3c27ca32020-11-20 12:42:07 -05002624 sharedLibraryStubsInfo := ctx.OtherModuleProvider(dep, SharedLibraryStubsProvider).(SharedLibraryStubsInfo)
Colin Cross0de8a1e2020-09-18 14:15:30 -07002625
Chris Parsons3c27ca32020-11-20 12:42:07 -05002626 if !libDepTag.explicitlyVersioned && len(sharedLibraryStubsInfo.SharedStubLibraries) > 0 {
Colin Cross0de8a1e2020-09-18 14:15:30 -07002627 useStubs := false
Colin Cross31076b32020-10-23 17:22:06 -07002628
2629 if lib := moduleLibraryInterface(dep); lib.buildStubs() && c.UseVndk() { // LLNDK
Colin Cross0de8a1e2020-09-18 14:15:30 -07002630 if !apexInfo.IsForPlatform() {
2631 // For platform libraries, use current version of LLNDK
2632 // If this is for use_vendor apex we will apply the same rules
2633 // of apex sdk enforcement below to choose right version.
2634 useStubs = true
2635 }
2636 } else if apexInfo.IsForPlatform() {
2637 // If not building for APEX, use stubs only when it is from
2638 // an APEX (and not from platform)
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002639 // However, for host, ramdisk, vendor_ramdisk, recovery or bootstrap modules,
Colin Cross0de8a1e2020-09-18 14:15:30 -07002640 // always link to non-stub variant
Jiyong Parkf7c3bbe2020-12-09 21:18:56 +09002641 useStubs = dep.(android.ApexModule).NotInPlatform() && !c.bootstrap()
Martin Stjernholm4e6c2692021-03-25 01:25:06 +00002642 if useStubs {
2643 // Another exception: if this module is a test for an APEX, then
2644 // it is linked with the non-stub variant of a module in the APEX
2645 // as if this is part of the APEX.
2646 testFor := ctx.Provider(android.ApexTestForInfoProvider).(android.ApexTestForInfo)
2647 for _, apexContents := range testFor.ApexContents {
2648 if apexContents.DirectlyInApex(depName) {
2649 useStubs = false
2650 break
2651 }
2652 }
2653 }
2654 if useStubs {
2655 // Yet another exception: If this module and the dependency are
2656 // available to the same APEXes then skip stubs between their
2657 // platform variants. This complements the test_for case above,
2658 // which avoids the stubs on a direct APEX library dependency, by
2659 // avoiding stubs for indirect test dependencies as well.
2660 //
2661 // TODO(b/183882457): This doesn't work if the two libraries have
2662 // only partially overlapping apex_available. For that test_for
2663 // modules would need to be split into APEX variants and resolved
2664 // separately for each APEX they have access to.
2665 if android.AvailableToSameApexes(c, dep.(android.ApexModule)) {
Colin Cross0de8a1e2020-09-18 14:15:30 -07002666 useStubs = false
Colin Cross0de8a1e2020-09-18 14:15:30 -07002667 }
2668 }
2669 } else {
2670 // If building for APEX, use stubs when the parent is in any APEX that
2671 // the child is not in.
2672 useStubs = !android.DirectlyInAllApexes(apexInfo, depName)
2673 }
2674
Jiyong Park55549df2021-02-26 23:57:23 +09002675 // when to use (unspecified) stubs, use the latest one.
Colin Cross0de8a1e2020-09-18 14:15:30 -07002676 if useStubs {
Jiyong Park55549df2021-02-26 23:57:23 +09002677 stubs := sharedLibraryStubsInfo.SharedStubLibraries
2678 toUse := stubs[len(stubs)-1]
2679 sharedLibraryInfo = toUse.SharedLibraryInfo
2680 depExporterInfo = toUse.FlagExporterInfo
Colin Cross0de8a1e2020-09-18 14:15:30 -07002681 }
2682 }
2683
Jiyong Park1ad8e162020-12-01 23:40:09 +09002684 // Stubs lib doesn't link to the shared lib dependencies. Don't set
2685 // linkFile, depFile, and ptr.
2686 if c.IsStubs() {
2687 break
2688 }
2689
Colin Cross0de8a1e2020-09-18 14:15:30 -07002690 linkFile = android.OptionalPathForPath(sharedLibraryInfo.SharedLibrary)
2691 depFile = sharedLibraryInfo.TableOfContents
2692
Colin Cross6e511a92020-07-27 21:26:48 -07002693 ptr = &depPaths.SharedLibs
2694 switch libDepTag.Order {
2695 case earlyLibraryDependency:
2696 ptr = &depPaths.EarlySharedLibs
2697 depPtr = &depPaths.EarlySharedLibsDeps
2698 case normalLibraryDependency:
2699 ptr = &depPaths.SharedLibs
2700 depPtr = &depPaths.SharedLibsDeps
Colin Cross0de8a1e2020-09-18 14:15:30 -07002701 directSharedDeps = append(directSharedDeps, sharedLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07002702 case lateLibraryDependency:
2703 ptr = &depPaths.LateSharedLibs
2704 depPtr = &depPaths.LateSharedLibsDeps
2705 default:
2706 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Colin Crossc99deeb2016-04-11 15:06:20 -07002707 }
Colin Cross6e511a92020-07-27 21:26:48 -07002708 case libDepTag.static():
Colin Cross0de8a1e2020-09-18 14:15:30 -07002709 if !ctx.OtherModuleHasProvider(dep, StaticLibraryInfoProvider) {
2710 if !ctx.Config().AllowMissingDependencies() {
2711 ctx.ModuleErrorf("module %q is not a static library", depName)
2712 } else {
2713 ctx.AddMissingDependencies([]string{depName})
2714 }
2715 return
2716 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002717
2718 // Stubs lib doesn't link to the static lib dependencies. Don't set
2719 // linkFile, depFile, and ptr.
2720 if c.IsStubs() {
2721 break
2722 }
2723
Colin Cross0de8a1e2020-09-18 14:15:30 -07002724 staticLibraryInfo := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
2725 linkFile = android.OptionalPathForPath(staticLibraryInfo.StaticLibrary)
Colin Cross6e511a92020-07-27 21:26:48 -07002726 if libDepTag.wholeStatic {
2727 ptr = &depPaths.WholeStaticLibs
Colin Cross0de8a1e2020-09-18 14:15:30 -07002728 if len(staticLibraryInfo.Objects.objFiles) > 0 {
2729 depPaths.WholeStaticLibObjs = depPaths.WholeStaticLibObjs.Append(staticLibraryInfo.Objects)
Inseob Kimeec88e12020-01-22 11:11:29 +09002730 } else {
Colin Cross0de8a1e2020-09-18 14:15:30 -07002731 // This case normally catches prebuilt static
2732 // libraries, but it can also occur when
2733 // AllowMissingDependencies is on and the
2734 // dependencies has no sources of its own
2735 // but has a whole_static_libs dependency
2736 // on a missing library. We want to depend
2737 // on the .a file so that there is something
2738 // in the dependency tree that contains the
2739 // error rule for the missing transitive
2740 // dependency.
2741 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07002742 }
Colin Cross6e511a92020-07-27 21:26:48 -07002743 } else {
2744 switch libDepTag.Order {
2745 case earlyLibraryDependency:
2746 panic(fmt.Errorf("early static libs not suppported"))
2747 case normalLibraryDependency:
2748 // static dependencies will be handled separately so they can be ordered
2749 // using transitive dependencies.
2750 ptr = nil
Colin Cross0de8a1e2020-09-18 14:15:30 -07002751 directStaticDeps = append(directStaticDeps, staticLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07002752 case lateLibraryDependency:
2753 ptr = &depPaths.LateStaticLibs
2754 default:
2755 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Inseob Kimeec88e12020-01-22 11:11:29 +09002756 }
2757 }
2758 }
2759
Colin Cross6e511a92020-07-27 21:26:48 -07002760 if libDepTag.static() && !libDepTag.wholeStatic {
2761 if !ccDep.CcLibraryInterface() || !ccDep.Static() {
2762 ctx.ModuleErrorf("module %q not a static library", depName)
2763 return
2764 }
Logan Chien43d34c32017-12-20 01:17:32 +08002765
Colin Cross6e511a92020-07-27 21:26:48 -07002766 // When combining coverage files for shared libraries and executables, coverage files
2767 // in static libraries act as if they were whole static libraries. The same goes for
2768 // source based Abi dump files.
2769 if c, ok := ccDep.(*Module); ok {
2770 staticLib := c.linker.(libraryInterface)
2771 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
2772 staticLib.objs().coverageFiles...)
2773 depPaths.StaticLibObjs.sAbiDumpFiles = append(depPaths.StaticLibObjs.sAbiDumpFiles,
2774 staticLib.objs().sAbiDumpFiles...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07002775 } else {
Colin Cross6e511a92020-07-27 21:26:48 -07002776 // Handle non-CC modules here
2777 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
Colin Cross0de8a1e2020-09-18 14:15:30 -07002778 ccDep.CoverageFiles()...)
Jiyong Parkde866cb2018-12-07 23:08:36 +09002779 }
2780 }
2781
Colin Cross6e511a92020-07-27 21:26:48 -07002782 if ptr != nil {
2783 if !linkFile.Valid() {
2784 if !ctx.Config().AllowMissingDependencies() {
2785 ctx.ModuleErrorf("module %q missing output file", depName)
2786 } else {
2787 ctx.AddMissingDependencies([]string{depName})
2788 }
2789 return
2790 }
2791 *ptr = append(*ptr, linkFile.Path())
2792 }
2793
2794 if depPtr != nil {
2795 dep := depFile
2796 if !dep.Valid() {
2797 dep = linkFile
2798 }
2799 *depPtr = append(*depPtr, dep.Path())
2800 }
2801
Colin Cross0de8a1e2020-09-18 14:15:30 -07002802 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
2803 depPaths.SystemIncludeDirs = append(depPaths.SystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
2804 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps, depExporterInfo.Deps...)
2805 depPaths.Flags = append(depPaths.Flags, depExporterInfo.Flags...)
2806
2807 if libDepTag.reexportFlags {
2808 reexportExporter(depExporterInfo)
2809 // Add these re-exported flags to help header-abi-dumper to infer the abi exported by a library.
2810 // Re-exported shared library headers must be included as well since they can help us with type information
2811 // about template instantiations (instantiated from their headers).
2812 // -isystem headers are not included since for bionic libraries, abi-filtering is taken care of by version
2813 // scripts.
2814 c.sabi.Properties.ReexportedIncludes = append(
2815 c.sabi.Properties.ReexportedIncludes, depExporterInfo.IncludeDirs.Strings()...)
2816 }
2817
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002818 makeLibName := MakeLibName(ctx, c, ccDep, depName) + libDepTag.makeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07002819 switch {
2820 case libDepTag.header():
Colin Cross370173e2020-07-29 12:48:33 -07002821 c.Properties.AndroidMkHeaderLibs = append(
2822 c.Properties.AndroidMkHeaderLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07002823 case libDepTag.shared():
Colin Cross31076b32020-10-23 17:22:06 -07002824 if lib := moduleLibraryInterface(dep); lib != nil {
2825 if lib.buildStubs() && dep.(android.ApexModule).InAnyApex() {
Colin Cross6e511a92020-07-27 21:26:48 -07002826 // Add the dependency to the APEX(es) providing the library so that
2827 // m <module> can trigger building the APEXes as well.
Colin Cross56a83212020-09-15 18:30:11 -07002828 depApexInfo := ctx.OtherModuleProvider(dep, android.ApexInfoProvider).(android.ApexInfo)
Jiyong Parkab50b072021-05-12 17:13:56 +09002829 for _, an := range depApexInfo.InApexVariants {
Colin Cross6e511a92020-07-27 21:26:48 -07002830 c.Properties.ApexesProvidingSharedLibs = append(
2831 c.Properties.ApexesProvidingSharedLibs, an)
2832 }
2833 }
2834 }
2835
2836 // Note: the order of libs in this list is not important because
2837 // they merely serve as Make dependencies and do not affect this lib itself.
Colin Cross370173e2020-07-29 12:48:33 -07002838 c.Properties.AndroidMkSharedLibs = append(
2839 c.Properties.AndroidMkSharedLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07002840 // Record baseLibName for snapshots.
2841 c.Properties.SnapshotSharedLibs = append(c.Properties.SnapshotSharedLibs, baseLibName(depName))
2842 case libDepTag.static():
2843 if libDepTag.wholeStatic {
2844 c.Properties.AndroidMkWholeStaticLibs = append(
2845 c.Properties.AndroidMkWholeStaticLibs, makeLibName)
2846 } else {
2847 c.Properties.AndroidMkStaticLibs = append(
2848 c.Properties.AndroidMkStaticLibs, makeLibName)
2849 }
2850 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002851 } else if !c.IsStubs() {
2852 // Stubs lib doesn't link to the runtime lib, object, crt, etc. dependencies.
2853
Colin Cross6e511a92020-07-27 21:26:48 -07002854 switch depTag {
2855 case runtimeDepTag:
2856 c.Properties.AndroidMkRuntimeLibs = append(
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002857 c.Properties.AndroidMkRuntimeLibs, MakeLibName(ctx, c, ccDep, depName)+libDepTag.makeSuffix)
Colin Cross6e511a92020-07-27 21:26:48 -07002858 // Record baseLibName for snapshots.
2859 c.Properties.SnapshotRuntimeLibs = append(c.Properties.SnapshotRuntimeLibs, baseLibName(depName))
2860 case objDepTag:
2861 depPaths.Objs.objFiles = append(depPaths.Objs.objFiles, linkFile.Path())
2862 case CrtBeginDepTag:
2863 depPaths.CrtBegin = linkFile
2864 case CrtEndDepTag:
2865 depPaths.CrtEnd = linkFile
2866 case dynamicLinkerDepTag:
2867 depPaths.DynamicLinker = linkFile
2868 }
Jiyong Park27b188b2017-07-18 13:23:39 +09002869 }
Colin Crossca860ac2016-01-04 14:34:37 -08002870 })
2871
Jeff Gaston294356f2017-09-27 17:05:30 -07002872 // use the ordered dependencies as this module's dependencies
Colin Cross0de8a1e2020-09-18 14:15:30 -07002873 orderedStaticPaths, transitiveStaticLibs := orderStaticModuleDeps(directStaticDeps, directSharedDeps)
2874 depPaths.TranstiveStaticLibrariesForOrdering = transitiveStaticLibs
2875 depPaths.StaticLibs = append(depPaths.StaticLibs, orderedStaticPaths...)
Jeff Gaston294356f2017-09-27 17:05:30 -07002876
Colin Crossdd84e052017-05-17 13:44:16 -07002877 // Dedup exported flags from dependencies
Colin Crossb6715442017-10-24 11:13:31 -07002878 depPaths.Flags = android.FirstUniqueStrings(depPaths.Flags)
Jiyong Park74955042019-10-22 20:19:51 +09002879 depPaths.IncludeDirs = android.FirstUniquePaths(depPaths.IncludeDirs)
2880 depPaths.SystemIncludeDirs = android.FirstUniquePaths(depPaths.SystemIncludeDirs)
Inseob Kimd110f872019-12-06 13:15:38 +09002881 depPaths.GeneratedDeps = android.FirstUniquePaths(depPaths.GeneratedDeps)
Jiyong Park74955042019-10-22 20:19:51 +09002882 depPaths.ReexportedDirs = android.FirstUniquePaths(depPaths.ReexportedDirs)
2883 depPaths.ReexportedSystemDirs = android.FirstUniquePaths(depPaths.ReexportedSystemDirs)
Colin Crossb6715442017-10-24 11:13:31 -07002884 depPaths.ReexportedFlags = android.FirstUniqueStrings(depPaths.ReexportedFlags)
Inseob Kim69378442019-06-03 19:10:47 +09002885 depPaths.ReexportedDeps = android.FirstUniquePaths(depPaths.ReexportedDeps)
Inseob Kimd110f872019-12-06 13:15:38 +09002886 depPaths.ReexportedGeneratedHeaders = android.FirstUniquePaths(depPaths.ReexportedGeneratedHeaders)
Dan Willemsenfe92c962017-08-29 12:28:37 -07002887
2888 if c.sabi != nil {
Inseob Kim69378442019-06-03 19:10:47 +09002889 c.sabi.Properties.ReexportedIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedIncludes)
Dan Willemsenfe92c962017-08-29 12:28:37 -07002890 }
Colin Crossdd84e052017-05-17 13:44:16 -07002891
Colin Crossca860ac2016-01-04 14:34:37 -08002892 return depPaths
2893}
2894
Colin Cross0de8a1e2020-09-18 14:15:30 -07002895// orderStaticModuleDeps rearranges the order of the static library dependencies of the module
2896// to match the topological order of the dependency tree, including any static analogues of
2897// direct shared libraries. It returns the ordered static dependencies, and an android.DepSet
2898// of the transitive dependencies.
2899func orderStaticModuleDeps(staticDeps []StaticLibraryInfo, sharedDeps []SharedLibraryInfo) (ordered android.Paths, transitive *android.DepSet) {
2900 transitiveStaticLibsBuilder := android.NewDepSetBuilder(android.TOPOLOGICAL)
2901 var staticPaths android.Paths
2902 for _, staticDep := range staticDeps {
2903 staticPaths = append(staticPaths, staticDep.StaticLibrary)
2904 transitiveStaticLibsBuilder.Transitive(staticDep.TransitiveStaticLibrariesForOrdering)
2905 }
2906 for _, sharedDep := range sharedDeps {
2907 if sharedDep.StaticAnalogue != nil {
2908 transitiveStaticLibsBuilder.Transitive(sharedDep.StaticAnalogue.TransitiveStaticLibrariesForOrdering)
2909 }
2910 }
2911 transitiveStaticLibs := transitiveStaticLibsBuilder.Build()
2912
2913 orderedTransitiveStaticLibs := transitiveStaticLibs.ToList()
2914
2915 // reorder the dependencies based on transitive dependencies
2916 staticPaths = android.FirstUniquePaths(staticPaths)
2917 _, orderedStaticPaths := android.FilterPathList(orderedTransitiveStaticLibs, staticPaths)
2918
2919 if len(orderedStaticPaths) != len(staticPaths) {
2920 missing, _ := android.FilterPathList(staticPaths, orderedStaticPaths)
2921 panic(fmt.Errorf("expected %d ordered static paths , got %d, missing %q %q %q", len(staticPaths), len(orderedStaticPaths), missing, orderedStaticPaths, staticPaths))
2922 }
2923
2924 return orderedStaticPaths, transitiveStaticLibs
2925}
2926
Colin Cross6e511a92020-07-27 21:26:48 -07002927// baseLibName trims known prefixes and suffixes
2928func baseLibName(depName string) string {
2929 libName := strings.TrimSuffix(depName, llndkLibrarySuffix)
2930 libName = strings.TrimSuffix(libName, vendorPublicLibrarySuffix)
Paul Duffind23c7262020-12-11 18:13:08 +00002931 libName = android.RemoveOptionalPrebuiltPrefix(libName)
Colin Cross6e511a92020-07-27 21:26:48 -07002932 return libName
2933}
2934
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002935func MakeLibName(ctx android.ModuleContext, c LinkableInterface, ccDep LinkableInterface, depName string) string {
Colin Cross6e511a92020-07-27 21:26:48 -07002936 libName := baseLibName(depName)
Colin Cross127bb8b2020-12-16 16:46:01 -08002937 ccDepModule, _ := ccDep.(*Module)
2938 isLLndk := ccDepModule != nil && ccDepModule.IsLlndk()
Justin Yuncbca3732021-02-03 19:24:13 +09002939 nonSystemVariantsExist := ccDep.HasNonSystemVariants() || isLLndk
Colin Cross6e511a92020-07-27 21:26:48 -07002940
Justin Yuncbca3732021-02-03 19:24:13 +09002941 if ccDepModule != nil {
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002942 // TODO(ivanlozano) Support snapshots for Rust-produced C library variants.
Colin Cross6e511a92020-07-27 21:26:48 -07002943 // Use base module name for snapshots when exporting to Makefile.
Justin Yuncbca3732021-02-03 19:24:13 +09002944 if snapshotPrebuilt, ok := ccDepModule.linker.(snapshotInterface); ok {
2945 baseName := ccDepModule.BaseModuleName()
Colin Cross6e511a92020-07-27 21:26:48 -07002946
Colin Crossa8890802021-01-22 14:06:33 -08002947 return baseName + snapshotPrebuilt.snapshotAndroidMkSuffix()
Colin Cross6e511a92020-07-27 21:26:48 -07002948 }
2949 }
2950
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002951 if ctx.DeviceConfig().VndkUseCoreVariant() && ccDep.IsVndk() && !ccDep.MustUseVendorVariant() &&
2952 !c.InRamdisk() && !c.InVendorRamdisk() && !c.InRecovery() {
Colin Cross6e511a92020-07-27 21:26:48 -07002953 // The vendor module is a no-vendor-variant VNDK library. Depend on the
2954 // core module instead.
2955 return libName
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002956 } else if ccDep.UseVndk() && nonSystemVariantsExist {
Justin Yuncbca3732021-02-03 19:24:13 +09002957 // The vendor and product modules in Make will have been renamed to not conflict with the
2958 // core module, so update the dependency name here accordingly.
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002959 return libName + ccDep.SubName()
Colin Cross6e511a92020-07-27 21:26:48 -07002960 } else if ccDep.InRamdisk() && !ccDep.OnlyInRamdisk() {
2961 return libName + ramdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002962 } else if ccDep.InVendorRamdisk() && !ccDep.OnlyInVendorRamdisk() {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05002963 return libName + VendorRamdiskSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07002964 } else if ccDep.InRecovery() && !ccDep.OnlyInRecovery() {
2965 return libName + recoverySuffix
Ivan Lozanof9e21722020-12-02 09:00:51 -05002966 } else if ccDep.Target().NativeBridge == android.NativeBridgeEnabled {
Colin Cross6e511a92020-07-27 21:26:48 -07002967 return libName + nativeBridgeSuffix
2968 } else {
2969 return libName
2970 }
2971}
2972
Colin Crossca860ac2016-01-04 14:34:37 -08002973func (c *Module) InstallInData() bool {
2974 if c.installer == nil {
2975 return false
2976 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07002977 return c.installer.inData()
2978}
2979
2980func (c *Module) InstallInSanitizerDir() bool {
2981 if c.installer == nil {
2982 return false
2983 }
2984 if c.sanitize != nil && c.sanitize.inSanitizerDir() {
Colin Cross94610402016-08-29 13:41:32 -07002985 return true
2986 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07002987 return c.installer.inSanitizerDir()
Colin Crossca860ac2016-01-04 14:34:37 -08002988}
2989
Yifan Hong1b3348d2020-01-21 15:53:22 -08002990func (c *Module) InstallInRamdisk() bool {
2991 return c.InRamdisk()
2992}
2993
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002994func (c *Module) InstallInVendorRamdisk() bool {
2995 return c.InVendorRamdisk()
2996}
2997
Jiyong Parkf9332f12018-02-01 00:54:12 +09002998func (c *Module) InstallInRecovery() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07002999 return c.InRecovery()
Jiyong Parkf9332f12018-02-01 00:54:12 +09003000}
3001
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01003002func (c *Module) MakeUninstallable() {
Martin Stjernholmbf37d162020-03-31 16:05:34 +01003003 if c.installer == nil {
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01003004 c.ModuleBase.MakeUninstallable()
Martin Stjernholmbf37d162020-03-31 16:05:34 +01003005 return
3006 }
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01003007 c.installer.makeUninstallable(c)
Martin Stjernholmbf37d162020-03-31 16:05:34 +01003008}
3009
Dan Willemsen4aa75ca2016-09-28 16:18:03 -07003010func (c *Module) HostToolPath() android.OptionalPath {
3011 if c.installer == nil {
3012 return android.OptionalPath{}
3013 }
3014 return c.installer.hostToolPath()
3015}
3016
Nan Zhangd4e641b2017-07-12 12:55:28 -07003017func (c *Module) IntermPathForModuleOut() android.OptionalPath {
3018 return c.outputFile
3019}
3020
Colin Cross41955e82019-05-29 14:40:35 -07003021func (c *Module) OutputFiles(tag string) (android.Paths, error) {
3022 switch tag {
3023 case "":
3024 if c.outputFile.Valid() {
3025 return android.Paths{c.outputFile.Path()}, nil
3026 }
3027 return android.Paths{}, nil
3028 default:
3029 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003030 }
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003031}
3032
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00003033func (c *Module) static() bool {
3034 if static, ok := c.linker.(interface {
3035 static() bool
3036 }); ok {
3037 return static.static()
3038 }
3039 return false
3040}
3041
Jiyong Park379de2f2018-12-19 02:47:14 +09003042func (c *Module) staticBinary() bool {
3043 if static, ok := c.linker.(interface {
3044 staticBinary() bool
3045 }); ok {
3046 return static.staticBinary()
3047 }
3048 return false
3049}
3050
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07003051func (c *Module) testBinary() bool {
3052 if test, ok := c.linker.(interface {
3053 testBinary() bool
3054 }); ok {
3055 return test.testBinary()
3056 }
3057 return false
3058}
3059
Ivan Lozano3968d8f2020-12-14 11:27:52 -05003060// Header returns true if the module is a header-only variant. (See cc/library.go header()).
3061func (c *Module) Header() bool {
Jiyong Park1d1119f2019-07-29 21:27:18 +09003062 if h, ok := c.linker.(interface {
3063 header() bool
3064 }); ok {
3065 return h.header()
3066 }
3067 return false
3068}
3069
Ivan Lozanod7586b62021-04-01 09:49:36 -04003070func (c *Module) Binary() bool {
Inseob Kim7f283f42020-06-01 21:53:49 +09003071 if b, ok := c.linker.(interface {
3072 binary() bool
3073 }); ok {
3074 return b.binary()
3075 }
3076 return false
3077}
3078
Ivan Lozanod7586b62021-04-01 09:49:36 -04003079func (c *Module) Object() bool {
Inseob Kim1042d292020-06-01 23:23:05 +09003080 if o, ok := c.linker.(interface {
3081 object() bool
3082 }); ok {
3083 return o.object()
3084 }
3085 return false
3086}
3087
Ivan Lozanof9e21722020-12-02 09:00:51 -05003088func GetMakeLinkType(actx android.ModuleContext, c LinkableInterface) string {
Ivan Lozano52767be2019-10-18 14:49:46 -07003089 if c.UseVndk() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003090 if c.IsLlndk() {
3091 if !c.IsLlndkPublic() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003092 return "native:vndk_private"
Colin Crossb60190a2018-09-04 16:28:17 -07003093 }
Colin Cross127bb8b2020-12-16 16:46:01 -08003094 return "native:vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07003095 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003096 if c.IsVndk() && !c.IsVndkExt() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003097 if c.IsVndkPrivate() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003098 return "native:vndk_private"
Jooyung Han38002912019-05-16 04:01:54 +09003099 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003100 return "native:vndk"
Jooyung Han38002912019-05-16 04:01:54 +09003101 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003102 if c.InProduct() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09003103 return "native:product"
3104 }
Jooyung Han38002912019-05-16 04:01:54 +09003105 return "native:vendor"
Yifan Hong1b3348d2020-01-21 15:53:22 -08003106 } else if c.InRamdisk() {
3107 return "native:ramdisk"
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003108 } else if c.InVendorRamdisk() {
3109 return "native:vendor_ramdisk"
Ivan Lozano52767be2019-10-18 14:49:46 -07003110 } else if c.InRecovery() {
Colin Crossb60190a2018-09-04 16:28:17 -07003111 return "native:recovery"
Ivan Lozanof9e21722020-12-02 09:00:51 -05003112 } else if c.Target().Os == android.Android && c.SdkVersion() != "" {
Colin Crossb60190a2018-09-04 16:28:17 -07003113 return "native:ndk:none:none"
3114 // TODO(b/114741097): use the correct ndk stl once build errors have been fixed
3115 //family, link := getNdkStlFamilyAndLinkType(c)
3116 //return fmt.Sprintf("native:ndk:%s:%s", family, link)
Ivan Lozano52767be2019-10-18 14:49:46 -07003117 } else if actx.DeviceConfig().VndkUseCoreVariant() && !c.MustUseVendorVariant() {
Vic Yangefd249e2018-11-12 20:19:56 -08003118 return "native:platform_vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07003119 } else {
3120 return "native:platform"
3121 }
3122}
3123
Jiyong Park9d452992018-10-03 00:38:19 +09003124// Overrides ApexModule.IsInstallabeToApex()
Roland Levillainf89cd092019-07-29 16:22:59 +01003125// Only shared/runtime libraries and "test_per_src" tests are installable to APEX.
Jiyong Park9d452992018-10-03 00:38:19 +09003126func (c *Module) IsInstallableToApex() bool {
Colin Cross31076b32020-10-23 17:22:06 -07003127 if lib := c.library; lib != nil {
Jiyong Park73c54ee2019-10-22 20:31:18 +09003128 // Stub libs and prebuilt libs in a versioned SDK are not
3129 // installable to APEX even though they are shared libs.
Colin Cross31076b32020-10-23 17:22:06 -07003130 return lib.shared() && !lib.buildStubs() && c.ContainingSdk().Unversioned()
Roland Levillainf89cd092019-07-29 16:22:59 +01003131 } else if _, ok := c.linker.(testPerSrc); ok {
3132 return true
Jiyong Park9d452992018-10-03 00:38:19 +09003133 }
3134 return false
3135}
3136
Jiyong Parka90ca002019-10-07 15:47:24 +09003137func (c *Module) AvailableFor(what string) bool {
3138 if linker, ok := c.linker.(interface {
3139 availableFor(string) bool
3140 }); ok {
3141 return c.ApexModuleBase.AvailableFor(what) || linker.availableFor(what)
3142 } else {
3143 return c.ApexModuleBase.AvailableFor(what)
3144 }
3145}
3146
Jiyong Park62304bb2020-04-13 16:19:48 +09003147func (c *Module) TestFor() []string {
Jiyong Park46a512f2020-12-04 18:02:13 +09003148 return c.Properties.Test_for
Jiyong Park62304bb2020-04-13 16:19:48 +09003149}
3150
Colin Crossaede88c2020-08-11 12:17:01 -07003151func (c *Module) UniqueApexVariations() bool {
3152 if u, ok := c.compiler.(interface {
3153 uniqueApexVariations() bool
3154 }); ok {
3155 return u.uniqueApexVariations()
3156 } else {
3157 return false
3158 }
3159}
3160
Paul Duffin0cb37b92020-03-04 14:52:46 +00003161func (c *Module) EverInstallable() bool {
3162 return c.installer != nil &&
3163 // Check to see whether the module is actually ever installable.
3164 c.installer.everInstallable()
3165}
3166
Ivan Lozanod7586b62021-04-01 09:49:36 -04003167func (c *Module) PreventInstall() bool {
3168 return c.Properties.PreventInstall
3169}
3170
3171func (c *Module) Installable() *bool {
3172 return c.Properties.Installable
3173}
3174
3175func installable(c LinkableInterface, apexInfo android.ApexInfo) bool {
Paul Duffin0cb37b92020-03-04 14:52:46 +00003176 ret := c.EverInstallable() &&
3177 // Check to see whether the module has been configured to not be installed.
Ivan Lozanod7586b62021-04-01 09:49:36 -04003178 proptools.BoolDefault(c.Installable(), true) &&
3179 !c.PreventInstall() && c.OutputFile().Valid()
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003180
3181 // The platform variant doesn't need further condition. Apex variants however might not
3182 // be installable because it will likely to be included in the APEX and won't appear
3183 // in the system partition.
Colin Cross56a83212020-09-15 18:30:11 -07003184 if apexInfo.IsForPlatform() {
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003185 return ret
3186 }
3187
3188 // Special case for modules that are configured to be installed to /data, which includes
3189 // test modules. For these modules, both APEX and non-APEX variants are considered as
3190 // installable. This is because even the APEX variants won't be included in the APEX, but
3191 // will anyway be installed to /data/*.
3192 // See b/146995717
3193 if c.InstallInData() {
3194 return ret
3195 }
3196
3197 return false
Inseob Kim1f086e22019-05-09 13:29:15 +09003198}
3199
Logan Chien41eabe62019-04-10 13:33:58 +08003200func (c *Module) AndroidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer) {
3201 if c.linker != nil {
3202 if library, ok := c.linker.(*libraryDecorator); ok {
3203 library.androidMkWriteAdditionalDependenciesForSourceAbiDiff(w)
3204 }
3205 }
3206}
3207
Jiyong Park45bf82e2020-12-15 22:29:02 +09003208var _ android.ApexModule = (*Module)(nil)
3209
3210// Implements android.ApexModule
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003211func (c *Module) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
Colin Cross6e511a92020-07-27 21:26:48 -07003212 depTag := ctx.OtherModuleDependencyTag(dep)
3213 libDepTag, isLibDepTag := depTag.(libraryDependencyTag)
3214
3215 if cc, ok := dep.(*Module); ok {
3216 if cc.HasStubsVariants() {
3217 if isLibDepTag && libDepTag.shared() {
3218 // dynamic dep to a stubs lib crosses APEX boundary
3219 return false
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003220 }
Colin Cross6e511a92020-07-27 21:26:48 -07003221 if IsRuntimeDepTag(depTag) {
3222 // runtime dep to a stubs lib also crosses APEX boundary
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003223 return false
3224 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003225 }
Zhijun Heec285872021-04-24 10:47:08 -07003226 if cc.IsLlndk() {
3227 return false
3228 }
Colin Crossaac32222020-07-29 12:51:56 -07003229 if isLibDepTag && c.static() && libDepTag.shared() {
Colin Cross6e511a92020-07-27 21:26:48 -07003230 // shared_lib dependency from a static lib is considered as crossing
3231 // the APEX boundary because the dependency doesn't actually is
3232 // linked; the dependency is used only during the compilation phase.
3233 return false
3234 }
Jiyong Parke3867542020-12-03 17:28:25 +09003235
3236 if isLibDepTag && libDepTag.excludeInApex {
3237 return false
3238 }
Colin Cross6e511a92020-07-27 21:26:48 -07003239 }
Colin Crossc1b36442021-05-06 13:42:48 -07003240 if depTag == stubImplDepTag {
3241 // We don't track from an implementation library to its stubs.
Jiyong Park7d95a512020-05-10 15:16:24 +09003242 return false
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003243 }
Jiyong Park12177fc2021-01-05 14:37:15 +09003244 if depTag == staticVariantTag {
3245 // This dependency is for optimization (reuse *.o from the static lib). It doesn't
3246 // actually mean that the static lib (and its dependencies) are copied into the
3247 // APEX.
3248 return false
3249 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003250 return true
3251}
3252
Jiyong Park45bf82e2020-12-15 22:29:02 +09003253// Implements android.ApexModule
Dan Albertc8060532020-07-22 22:32:17 -07003254func (c *Module) ShouldSupportSdkVersion(ctx android.BaseModuleContext,
3255 sdkVersion android.ApiLevel) error {
Jooyung Han749dc692020-04-15 11:03:39 +09003256 // We ignore libclang_rt.* prebuilt libs since they declare sdk_version: 14(b/121358700)
3257 if strings.HasPrefix(ctx.OtherModuleName(c), "libclang_rt") {
3258 return nil
3259 }
3260 // b/154569636: set min_sdk_version correctly for toolchain_libraries
3261 if c.ToolchainLibrary() {
3262 return nil
3263 }
3264 // We don't check for prebuilt modules
3265 if _, ok := c.linker.(prebuiltLinkerInterface); ok {
3266 return nil
3267 }
3268 minSdkVersion := c.MinSdkVersion()
3269 if minSdkVersion == "apex_inherit" {
3270 return nil
3271 }
3272 if minSdkVersion == "" {
3273 // JNI libs within APK-in-APEX fall into here
3274 // Those are okay to set sdk_version instead
3275 // We don't have to check if this is a SDK variant because
3276 // non-SDK variant resets sdk_version, which works too.
3277 minSdkVersion = c.SdkVersion()
3278 }
Dan Albertc8060532020-07-22 22:32:17 -07003279 if minSdkVersion == "" {
3280 return fmt.Errorf("neither min_sdk_version nor sdk_version specificed")
3281 }
3282 // Not using nativeApiLevelFromUser because the context here is not
3283 // necessarily a native context.
3284 ver, err := android.ApiLevelFromUser(ctx, minSdkVersion)
Jooyung Han749dc692020-04-15 11:03:39 +09003285 if err != nil {
3286 return err
3287 }
Dan Albertc8060532020-07-22 22:32:17 -07003288
3289 if ver.GreaterThan(sdkVersion) {
Jooyung Han749dc692020-04-15 11:03:39 +09003290 return fmt.Errorf("newer SDK(%v)", ver)
3291 }
3292 return nil
3293}
3294
Paul Duffinb5769c12021-05-12 16:16:51 +01003295// Implements android.ApexModule
3296func (c *Module) AlwaysRequiresPlatformApexVariant() bool {
3297 // stub libraries and native bridge libraries are always available to platform
3298 return c.IsStubs() || c.Target().NativeBridge == android.NativeBridgeEnabled
3299}
3300
Colin Cross2ba19d92015-05-07 15:44:20 -07003301//
Colin Crosscfad1192015-11-02 16:43:11 -08003302// Defaults
3303//
Colin Crossca860ac2016-01-04 14:34:37 -08003304type Defaults struct {
Colin Cross635c3b02016-05-18 15:37:25 -07003305 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -07003306 android.DefaultsModuleBase
Liz Kammer3cf52112021-03-31 15:42:03 -04003307 // Included to support setting bazel_module.label for multiple Soong modules to the same Bazel
3308 // target. This is primarily useful for modules that were architecture specific and instead are
3309 // handled in Bazel as a select().
3310 android.BazelModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +09003311 android.ApexModuleBase
Colin Crosscfad1192015-11-02 16:43:11 -08003312}
3313
Patrice Arrudac249c712019-03-19 17:00:29 -07003314// cc_defaults provides a set of properties that can be inherited by other cc
3315// modules. A module can use the properties from a cc_defaults using
3316// `defaults: ["<:default_module_name>"]`. Properties of both modules are
3317// merged (when possible) by prepending the default module's values to the
3318// depending module's values.
Colin Cross36242852017-06-23 15:06:31 -07003319func defaultsFactory() android.Module {
Colin Crosse1d764e2016-08-18 14:18:32 -07003320 return DefaultsFactory()
3321}
3322
Colin Cross36242852017-06-23 15:06:31 -07003323func DefaultsFactory(props ...interface{}) android.Module {
Colin Crossca860ac2016-01-04 14:34:37 -08003324 module := &Defaults{}
Colin Crosscfad1192015-11-02 16:43:11 -08003325
Colin Cross36242852017-06-23 15:06:31 -07003326 module.AddProperties(props...)
3327 module.AddProperties(
Colin Crossca860ac2016-01-04 14:34:37 -08003328 &BaseProperties{},
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003329 &VendorProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003330 &BaseCompilerProperties{},
3331 &BaseLinkerProperties{},
Paul Duffina37832a2019-07-18 12:31:26 +01003332 &ObjectLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003333 &LibraryProperties{},
Colin Crosse1bb5d02019-09-24 14:55:04 -07003334 &StaticProperties{},
3335 &SharedProperties{},
Colin Cross919281a2016-04-05 16:42:05 -07003336 &FlagExporterProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003337 &BinaryLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003338 &TestProperties{},
3339 &TestBinaryProperties{},
Colin Cross43287652020-06-30 10:15:07 -07003340 &BenchmarkProperties{},
Mitch Phillips4e4ab8a2019-09-13 17:32:50 -07003341 &FuzzProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003342 &StlProperties{},
Colin Cross16b23492016-01-06 14:41:07 -08003343 &SanitizeProperties{},
Colin Cross665dce92016-04-28 14:50:03 -07003344 &StripProperties{},
Dan Willemsen7424d612016-09-01 13:45:39 -07003345 &InstallerProperties{},
Dan Willemsena03cf6d2016-09-26 15:45:04 -07003346 &TidyProperties{},
Dan Willemsen581341d2017-02-09 16:16:31 -08003347 &CoverageProperties{},
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08003348 &SAbiProperties{},
Justin Yun4b2382f2017-07-26 14:22:10 +09003349 &VndkProperties{},
Stephen Craneba090d12017-05-09 15:44:35 -07003350 &LTOProperties{},
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07003351 &PgoProperties{},
Dan Willemsen6424d172018-03-08 13:27:59 -08003352 &android.ProtoProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -04003353 // RustBindgenProperties is included here so that cc_defaults can be used for rust_bindgen modules.
3354 &RustBindgenClangProperties{},
Colin Crosse1d764e2016-08-18 14:18:32 -07003355 )
Colin Crosscfad1192015-11-02 16:43:11 -08003356
Liz Kammer3cf52112021-03-31 15:42:03 -04003357 // Bazel module must be initialized _before_ Defaults to be included in cc_defaults module.
3358 android.InitBazelModule(module)
Jooyung Hancc372c52019-09-25 15:18:44 +09003359 android.InitDefaultsModule(module)
Colin Cross36242852017-06-23 15:06:31 -07003360
3361 return module
Colin Crosscfad1192015-11-02 16:43:11 -08003362}
3363
Jiyong Park2286afd2020-06-16 21:58:53 +09003364func (c *Module) IsSdkVariant() bool {
Dan Albert92fe7402020-07-15 13:33:30 -07003365 return c.Properties.IsSdkVariant || c.AlwaysSdk()
Jiyong Park2286afd2020-06-16 21:58:53 +09003366}
3367
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003368func kytheExtractAllFactory() android.Singleton {
3369 return &kytheExtractAllSingleton{}
3370}
3371
3372type kytheExtractAllSingleton struct {
3373}
3374
3375func (ks *kytheExtractAllSingleton) GenerateBuildActions(ctx android.SingletonContext) {
3376 var xrefTargets android.Paths
3377 ctx.VisitAllModules(func(module android.Module) {
3378 if ccModule, ok := module.(xref); ok {
3379 xrefTargets = append(xrefTargets, ccModule.XrefCcFiles()...)
3380 }
3381 })
3382 // TODO(asmundak): Perhaps emit a rule to output a warning if there were no xrefTargets
3383 if len(xrefTargets) > 0 {
Colin Crossc3d87d32020-06-04 13:25:17 -07003384 ctx.Phony("xref_cxx", xrefTargets...)
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003385 }
3386}
3387
Colin Cross06a931b2015-10-28 17:23:31 -07003388var Bool = proptools.Bool
Colin Cross38b40df2018-04-10 16:14:46 -07003389var BoolDefault = proptools.BoolDefault
Nan Zhang0007d812017-11-07 10:57:05 -08003390var BoolPtr = proptools.BoolPtr
3391var String = proptools.String
3392var StringPtr = proptools.StringPtr