blob: 1f73149eec390f8337a3e8bec988c98c608949db [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 Crossc465efd2021-06-11 18:00:04 -0700129 CrtBegin, CrtEnd []string
Dan Willemsena0790e32018-10-12 00:24:23 -0700130
131 // Used for host bionic
Colin Cross9cfe6112021-06-11 18:02:22 -0700132 DynamicLinker string
Jiyong Parke3867542020-12-03 17:28:25 +0900133
134 // List of libs that need to be excluded for APEX variant
135 ExcludeLibsForApex []string
Colin Crossc472d572015-03-17 15:06:21 -0700136}
137
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500138// PathDeps is a struct containing file paths to dependencies of a module.
139// It's constructed in depsToPath() by traversing the direct dependencies of the current module.
140// It's used to construct flags for various build statements (such as for compiling and linking).
141// It is then passed to module decorator functions responsible for registering build statements
142// (such as `module.compiler.compile()`).`
Colin Crossca860ac2016-01-04 14:34:37 -0800143type PathDeps struct {
Colin Cross26c34ed2016-09-30 17:10:16 -0700144 // Paths to .so files
Jiyong Park64a44f22019-01-18 14:37:08 +0900145 SharedLibs, EarlySharedLibs, LateSharedLibs android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700146 // Paths to the dependencies to use for .so files (.so.toc files)
Jiyong Park64a44f22019-01-18 14:37:08 +0900147 SharedLibsDeps, EarlySharedLibsDeps, LateSharedLibsDeps android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700148 // Paths to .a files
Colin Cross635c3b02016-05-18 15:37:25 -0700149 StaticLibs, LateStaticLibs, WholeStaticLibs android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700150
Colin Cross0de8a1e2020-09-18 14:15:30 -0700151 // Transitive static library dependencies of static libraries for use in ordering.
152 TranstiveStaticLibrariesForOrdering *android.DepSet
153
Colin Cross26c34ed2016-09-30 17:10:16 -0700154 // Paths to .o files
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100155 Objs Objects
156 // Paths to .o files in dependencies that provide them. Note that these lists
157 // aren't complete since prebuilt modules don't provide the .o files.
Dan Willemsen581341d2017-02-09 16:16:31 -0800158 StaticLibObjs Objects
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700159 WholeStaticLibObjs Objects
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700160
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100161 // Paths to .a files in prebuilts. Complements WholeStaticLibObjs to contain
162 // the libs from all whole_static_lib dependencies.
163 WholeStaticLibsFromPrebuilts android.Paths
164
Colin Cross26c34ed2016-09-30 17:10:16 -0700165 // Paths to generated source files
Colin Cross635c3b02016-05-18 15:37:25 -0700166 GeneratedSources android.Paths
Inseob Kimd110f872019-12-06 13:15:38 +0900167 GeneratedDeps android.Paths
Dan Willemsenb40aab62016-04-20 14:21:14 -0700168
Inseob Kimd110f872019-12-06 13:15:38 +0900169 Flags []string
170 IncludeDirs android.Paths
171 SystemIncludeDirs android.Paths
172 ReexportedDirs android.Paths
173 ReexportedSystemDirs android.Paths
174 ReexportedFlags []string
175 ReexportedGeneratedHeaders android.Paths
176 ReexportedDeps android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700177
Colin Cross26c34ed2016-09-30 17:10:16 -0700178 // Paths to crt*.o files
Colin Crossc465efd2021-06-11 18:00:04 -0700179 CrtBegin, CrtEnd android.Paths
Dan Willemsena0790e32018-10-12 00:24:23 -0700180
Dan Willemsena0790e32018-10-12 00:24:23 -0700181 // Path to the dynamic linker binary
182 DynamicLinker android.OptionalPath
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700183}
184
Colin Cross4af21ed2019-11-04 09:37:55 -0800185// LocalOrGlobalFlags contains flags that need to have values set globally by the build system or locally by the module
186// tracked separately, in order to maintain the required ordering (most of the global flags need to go first on the
187// command line so they can be overridden by the local module flags).
188type LocalOrGlobalFlags struct {
189 CommonFlags []string // Flags that apply to C, C++, and assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700190 AsFlags []string // Flags that apply to assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800191 YasmFlags []string // Flags that apply to yasm assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700192 CFlags []string // Flags that apply to C and C++ source files
193 ToolingCFlags []string // Flags that apply to C and C++ source files parsed by clang LibTooling tools
194 ConlyFlags []string // Flags that apply to C source files
195 CppFlags []string // Flags that apply to C++ source files
196 ToolingCppFlags []string // Flags that apply to C++ source files parsed by clang LibTooling tools
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700197 LdFlags []string // Flags that apply to linker command lines
Colin Cross4af21ed2019-11-04 09:37:55 -0800198}
199
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500200// Flags contains various types of command line flags (and settings) for use in building build
201// statements related to C++.
Colin Cross4af21ed2019-11-04 09:37:55 -0800202type Flags struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500203 // Local flags (which individual modules are responsible for). These may override global flags.
204 Local LocalOrGlobalFlags
205 // Global flags (which build system or toolchain is responsible for).
Colin Cross4af21ed2019-11-04 09:37:55 -0800206 Global LocalOrGlobalFlags
207
208 aidlFlags []string // Flags that apply to aidl source files
209 rsFlags []string // Flags that apply to renderscript source files
210 libFlags []string // Flags to add libraries early to the link order
211 extraLibFlags []string // Flags to add libraries late in the link order after LdFlags
212 TidyFlags []string // Flags that apply to clang-tidy
213 SAbiFlags []string // Flags that apply to header-abi-dumper
Colin Cross28344522015-04-22 13:07:53 -0700214
Colin Crossc3199482017-03-30 15:03:04 -0700215 // Global include flags that apply to C, C++, and assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800216 // These must be after any module include flags, which will be in CommonFlags.
Colin Crossc3199482017-03-30 15:03:04 -0700217 SystemIncludeFlags []string
218
Oliver Nguyen04526782020-04-21 12:40:27 -0700219 Toolchain config.Toolchain
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500220 Tidy bool // True if clang-tidy is enabled.
221 GcovCoverage bool // True if coverage files should be generated.
222 SAbiDump bool // True if header abi dumps should be generated.
Oliver Nguyen04526782020-04-21 12:40:27 -0700223 EmitXrefs bool // If true, generate Ninja rules to generate emitXrefs input files for Kythe
Colin Crossca860ac2016-01-04 14:34:37 -0800224
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500225 // The instruction set required for clang ("arm" or "thumb").
Colin Crossca860ac2016-01-04 14:34:37 -0800226 RequiredInstructionSet string
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500227 // The target-device system path to the dynamic linker.
228 DynamicLinker string
Colin Cross16b23492016-01-06 14:41:07 -0800229
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700230 CFlagsDeps android.Paths // Files depended on by compiler flags
231 LdFlagsDeps android.Paths // Files depended on by linker flags
Colin Cross18c0c5a2016-12-01 14:45:23 -0800232
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500233 // True if .s files should be processed with the c preprocessor.
Dan Willemsen98ab3112019-08-27 21:20:40 -0700234 AssemblerWithCpp bool
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500235 // True if static libraries should be grouped (using `-Wl,--start-group` and `-Wl,--end-group`).
236 GroupStaticLibs bool
Dan Willemsen60e62f02018-11-16 21:05:32 -0800237
Colin Cross19878da2019-03-28 14:45:07 -0700238 proto android.ProtoFlags
Colin Cross19878da2019-03-28 14:45:07 -0700239 protoC bool // Whether to use C instead of C++
240 protoOptionsFile bool // Whether to look for a .options file next to the .proto
Dan Willemsen4e0aa232019-04-10 22:59:54 -0700241
242 Yacc *YaccProperties
Matthias Maennich22fd4d12020-07-15 10:58:56 +0200243 Lex *LexProperties
Colin Crossc472d572015-03-17 15:06:21 -0700244}
245
Colin Crossca860ac2016-01-04 14:34:37 -0800246// Properties used to compile all C or C++ modules
247type BaseProperties struct {
Dan Willemsen742a5452018-07-23 17:19:36 -0700248 // Deprecated. true is the default, false is invalid.
Colin Crossca860ac2016-01-04 14:34:37 -0800249 Clang *bool `android:"arch_variant"`
Colin Cross7d5136f2015-05-11 13:39:40 -0700250
Jiyong Parkb35a8192020-08-10 15:59:36 +0900251 // The API level that this module is built against. The APIs of this API level will be
252 // visible at build time, but use of any APIs newer than min_sdk_version will render the
253 // module unloadable on older devices. In the future it will be possible to weakly-link new
254 // APIs, making the behavior match Java: such modules will load on older devices, but
255 // calling new APIs on devices that do not support them will result in a crash.
256 //
257 // This property has the same behavior as sdk_version does for Java modules. For those
258 // familiar with Android Gradle, the property behaves similarly to how compileSdkVersion
259 // does for Java code.
260 //
261 // In addition, setting this property causes two variants to be built, one for the platform
262 // and one for apps.
Nan Zhang0007d812017-11-07 10:57:05 -0800263 Sdk_version *string
Colin Cross7d5136f2015-05-11 13:39:40 -0700264
Jiyong Parkb35a8192020-08-10 15:59:36 +0900265 // Minimum OS API level supported by this C or C++ module. This property becomes the value
266 // of the __ANDROID_API__ macro. When the C or C++ module is included in an APEX or an APK,
267 // this property is also used to ensure that the min_sdk_version of the containing module is
268 // not older (i.e. less) than this module's min_sdk_version. When not set, this property
269 // defaults to the value of sdk_version. When this is set to "apex_inherit", this tracks
270 // min_sdk_version of the containing APEX. When the module
271 // is not built for an APEX, "apex_inherit" defaults to sdk_version.
Jooyung Han379660c2020-04-21 15:24:00 +0900272 Min_sdk_version *string
273
Colin Crossc511bc52020-04-07 16:50:32 +0000274 // If true, always create an sdk variant and don't create a platform variant.
275 Sdk_variant_only *bool
276
Jiyong Parkde866cb2018-12-07 23:08:36 +0900277 AndroidMkSharedLibs []string `blueprint:"mutated"`
278 AndroidMkStaticLibs []string `blueprint:"mutated"`
279 AndroidMkRuntimeLibs []string `blueprint:"mutated"`
280 AndroidMkWholeStaticLibs []string `blueprint:"mutated"`
Bill Peckhama46de702020-04-21 17:23:37 -0700281 AndroidMkHeaderLibs []string `blueprint:"mutated"`
Jiyong Parkde866cb2018-12-07 23:08:36 +0900282 HideFromMake bool `blueprint:"mutated"`
283 PreventInstall bool `blueprint:"mutated"`
284 ApexesProvidingSharedLibs []string `blueprint:"mutated"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700285
Yo Chiang219968c2020-09-22 18:45:04 +0800286 // Set by DepsMutator.
287 AndroidMkSystemSharedLibs []string `blueprint:"mutated"`
288
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200289 // The name of the image this module is built for, suffixed with a '.'
Justin Yun5f7f7e82019-11-18 19:52:14 +0900290 ImageVariationPrefix string `blueprint:"mutated"`
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200291
292 // The VNDK version this module is built against. If empty, the module is not
293 // build against the VNDK.
294 VndkVersion string `blueprint:"mutated"`
295
296 // Suffix for the name of Android.mk entries generated by this module
297 SubName string `blueprint:"mutated"`
Colin Cross5beccee2017-12-07 15:28:59 -0800298
299 // *.logtags files, to combine together in order to generate the /system/etc/event-log-tags
300 // file
301 Logtags []string
Jiyong Parkf9332f12018-02-01 00:54:12 +0900302
Yifan Hong39143a92020-10-26 12:43:12 -0700303 // Make this module available when building for ramdisk.
304 // On device without a dedicated recovery partition, the module is only
305 // available after switching root into
306 // /first_stage_ramdisk. To expose the module before switching root, install
307 // the recovery variant instead.
Yifan Hong1b3348d2020-01-21 15:53:22 -0800308 Ramdisk_available *bool
309
Yifan Hong39143a92020-10-26 12:43:12 -0700310 // Make this module available when building for vendor ramdisk.
311 // On device without a dedicated recovery partition, the module is only
312 // available after switching root into
313 // /first_stage_ramdisk. To expose the module before switching root, install
314 // the recovery variant instead.
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700315 Vendor_ramdisk_available *bool
316
Jiyong Parkf9332f12018-02-01 00:54:12 +0900317 // Make this module available when building for recovery
318 Recovery_available *bool
319
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200320 // Used by imageMutator, set by ImageMutatorBegin()
321 CoreVariantNeeded bool `blueprint:"mutated"`
322 RamdiskVariantNeeded bool `blueprint:"mutated"`
323 VendorRamdiskVariantNeeded bool `blueprint:"mutated"`
324 RecoveryVariantNeeded bool `blueprint:"mutated"`
325
326 // A list of variations for the "image" mutator of the form
327 //<image name> '.' <version char>, for example, 'vendor.S'
328 ExtraVersionedImageVariations []string `blueprint:"mutated"`
Jiyong Parkb0788572018-12-20 22:10:17 +0900329
330 // Allows this module to use non-APEX version of libraries. Useful
331 // for building binaries that are started before APEXes are activated.
332 Bootstrap *bool
Jooyung Han097087b2019-10-22 19:32:18 +0900333
334 // Even if DeviceConfig().VndkUseCoreVariant() is set, this module must use vendor variant.
335 // see soong/cc/config/vndk.go
336 MustUseVendorVariant bool `blueprint:"mutated"`
Inseob Kim8471cda2019-11-15 09:59:12 +0900337
338 // Used by vendor snapshot to record dependencies from snapshot modules.
339 SnapshotSharedLibs []string `blueprint:"mutated"`
Justin Yun5e035862021-06-29 20:50:37 +0900340 SnapshotStaticLibs []string `blueprint:"mutated"`
Inseob Kim8471cda2019-11-15 09:59:12 +0900341 SnapshotRuntimeLibs []string `blueprint:"mutated"`
Paul Duffin0cb37b92020-03-04 14:52:46 +0000342
343 Installable *bool
Colin Crossc511bc52020-04-07 16:50:32 +0000344
345 // Set by factories of module types that can only be referenced from variants compiled against
346 // the SDK.
347 AlwaysSdk bool `blueprint:"mutated"`
348
349 // Variant is an SDK variant created by sdkMutator
350 IsSdkVariant bool `blueprint:"mutated"`
351 // Set when both SDK and platform variants are exported to Make to trigger renaming the SDK
352 // variant to have a ".sdk" suffix.
353 SdkAndPlatformVariantVisibleToMake bool `blueprint:"mutated"`
Bill Peckham945441c2020-08-31 16:07:58 -0700354
355 // Normally Soong uses the directory structure to decide which modules
356 // should be included (framework) or excluded (non-framework) from the
Jose Galmes6f843bc2020-12-11 13:36:29 -0800357 // different snapshots (vendor, recovery, etc.), but this property
358 // allows a partner to exclude a module normally thought of as a
359 // framework module from the vendor snapshot.
360 Exclude_from_vendor_snapshot *bool
361
362 // Normally Soong uses the directory structure to decide which modules
363 // should be included (framework) or excluded (non-framework) from the
364 // different snapshots (vendor, recovery, etc.), but this property
365 // allows a partner to exclude a module normally thought of as a
366 // framework module from the recovery snapshot.
Jose Galmesf7294582020-11-13 12:07:36 -0800367 Exclude_from_recovery_snapshot *bool
Jiyong Park46a512f2020-12-04 18:02:13 +0900368
369 // List of APEXes that this module has private access to for testing purpose. The module
370 // can depend on libraries that are not exported by the APEXes and use private symbols
371 // from the exported libraries.
Martin Stjernholm855e90b2021-03-25 02:33:14 +0000372 Test_for []string `android:"arch_variant"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700373}
374
375type VendorProperties struct {
Jiyong Park82e2bf32017-08-16 14:05:54 +0900376 // whether this module should be allowed to be directly depended by other
377 // modules with `vendor: true`, `proprietary: true`, or `vendor_available:true`.
Justin Yun63e9ec72020-10-29 16:49:43 +0900378 // If set to true, two variants will be built separately, one like
379 // normal, and the other limited to the set of libraries and headers
380 // that are exposed to /vendor modules.
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700381 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900382 // The vendor variant may be used with a different (newer) /system,
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700383 // so it shouldn't have any unversioned runtime dependencies, or
384 // make assumptions about the system that may not be true in the
385 // future.
386 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900387 // If set to false, this module becomes inaccessible from /vendor modules.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900388 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900389 // The modules with vndk: {enabled: true} must define 'vendor_available'
Justin Yun0b1db6d2021-01-08 15:22:34 +0900390 // to 'true'.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900391 //
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700392 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
393 Vendor_available *bool
Jiyong Park5fb8c102018-04-09 12:03:06 +0900394
Justin Yunebcf0c52021-01-08 18:00:19 +0900395 // This is the same as the "vendor_available" except that the install path
396 // of the vendor variant is /odm or /vendor/odm.
397 // By replacing "vendor_available: true" with "odm_available: true", the
398 // module will install its vendor variant to the /odm partition or /vendor/odm.
399 // As the modules with "odm_available: true" still create the vendor variants,
400 // they can link to the other vendor modules as the vendor_available modules do.
401 // Also, the vendor modules can link to odm_available modules.
402 //
403 // It may not be used for VNDK modules.
404 Odm_available *bool
405
Justin Yun63e9ec72020-10-29 16:49:43 +0900406 // whether this module should be allowed to be directly depended by other
407 // modules with `product_specific: true` or `product_available: true`.
408 // If set to true, an additional product variant will be built separately
409 // that is limited to the set of libraries and headers that are exposed to
410 // /product modules.
411 //
412 // The product variant may be used with a different (newer) /system,
413 // so it shouldn't have any unversioned runtime dependencies, or
414 // make assumptions about the system that may not be true in the
415 // future.
416 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900417 // If set to false, this module becomes inaccessible from /product modules.
418 //
419 // Different from the 'vendor_available' property, the modules with
420 // vndk: {enabled: true} don't have to define 'product_available'. The VNDK
421 // library without 'product_available' may not be depended on by any other
422 // modules that has product variants including the product available VNDKs.
Justin Yun63e9ec72020-10-29 16:49:43 +0900423 //
424 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
425 // and PRODUCT_PRODUCT_VNDK_VERSION isn't set.
426 Product_available *bool
427
Jiyong Park5fb8c102018-04-09 12:03:06 +0900428 // whether this module is capable of being loaded with other instance
429 // (possibly an older version) of the same module in the same process.
430 // Currently, a shared library that is a member of VNDK (vndk: {enabled: true})
431 // can be double loaded in a vendor process if the library is also a
432 // (direct and indirect) dependency of an LLNDK library. Such libraries must be
433 // explicitly marked as `double_loadable: true` by the owner, or the dependency
434 // from the LLNDK lib should be cut if the lib is not designed to be double loaded.
435 Double_loadable *bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800436
437 // IsLLNDK is set to true for the vendor variant of a cc_library module that has LLNDK stubs.
438 IsLLNDK bool `blueprint:"mutated"`
439
Colin Cross78212242021-01-06 14:51:30 -0800440 // IsVNDKUsingCoreVariant is true for VNDK modules if the global VndkUseCoreVariant option is
441 // set and the module is not listed in VndkMustUseVendorVariantList.
442 IsVNDKUsingCoreVariant bool `blueprint:"mutated"`
443
444 // IsVNDKCore is set if a VNDK module does not set the vndk.support_system_process property.
445 IsVNDKCore bool `blueprint:"mutated"`
446
447 // IsVNDKSP is set if a VNDK module sets the vndk.support_system_process property.
448 IsVNDKSP bool `blueprint:"mutated"`
449
450 // IsVNDKPrivate is set if a VNDK module sets the vndk.private property or an LLNDK
451 // module sets the llndk.private property.
452 IsVNDKPrivate bool `blueprint:"mutated"`
453
454 // IsVNDKProduct is set if a VNDK module sets the product_available property.
455 IsVNDKProduct bool `blueprint:"mutated"`
Colin Cross5271fea2021-04-27 13:06:04 -0700456
457 // IsVendorPublicLibrary is set for the core and product variants of a library that has
458 // vendor_public_library stubs.
459 IsVendorPublicLibrary bool `blueprint:"mutated"`
Colin Crossca860ac2016-01-04 14:34:37 -0800460}
461
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500462// ModuleContextIntf is an interface (on a module context helper) consisting of functions related
463// to understanding details about the type of the current module.
464// For example, one might call these functions to determine whether the current module is a static
465// library and/or is installed in vendor directories.
Colin Crossca860ac2016-01-04 14:34:37 -0800466type ModuleContextIntf interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800467 static() bool
468 staticBinary() bool
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -0700469 testBinary() bool
Jiyong Park1d1119f2019-07-29 21:27:18 +0900470 header() bool
Inseob Kim7f283f42020-06-01 21:53:49 +0900471 binary() bool
Inseob Kim1042d292020-06-01 23:23:05 +0900472 object() bool
Colin Crossb98c8b02016-07-29 13:44:28 -0700473 toolchain() config.Toolchain
Jooyung Hanccce2f22020-03-07 03:45:53 +0900474 canUseSdk() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700475 useSdk() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800476 sdkVersion() string
Jiyong Parkb35a8192020-08-10 15:59:36 +0900477 minSdkVersion() string
478 isSdkVariant() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700479 useVndk() bool
Colin Cross95f1ca02020-10-29 20:47:22 -0700480 isNdk(config android.Config) bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800481 IsLlndk() bool
482 IsLlndkPublic() bool
483 isImplementationForLLNDKPublic() bool
484 IsVndkPrivate() bool
Justin Yun8effde42017-06-23 19:24:43 +0900485 isVndk() bool
486 isVndkSp() bool
Ivan Lozanof9e21722020-12-02 09:00:51 -0500487 IsVndkExt() bool
Colin Cross5271fea2021-04-27 13:06:04 -0700488 IsVendorPublicLibrary() bool
Justin Yun5f7f7e82019-11-18 19:52:14 +0900489 inProduct() bool
490 inVendor() bool
Yifan Hong1b3348d2020-01-21 15:53:22 -0800491 inRamdisk() bool
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700492 inVendorRamdisk() bool
Jiyong Parkf9332f12018-02-01 00:54:12 +0900493 inRecovery() bool
Dan Willemsen8146b2f2016-03-30 21:00:30 -0700494 selectedStl() string
Colin Crossce75d2c2016-10-06 16:12:58 -0700495 baseModuleName() string
Logan Chienf3511742017-10-31 18:04:35 +0800496 getVndkExtendsModuleName() string
Yi Kong7e53c572018-02-14 18:16:12 +0800497 isPgoCompile() bool
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800498 isNDKStubLibrary() bool
Ivan Lozanobd721262018-11-27 14:33:03 -0800499 useClangLld(actx ModuleContext) bool
Logan Chiene274fc92019-12-03 11:18:32 -0800500 isForPlatform() bool
Colin Crosse07f2312020-08-13 11:24:56 -0700501 apexVariationName() string
Dan Albertc8060532020-07-22 22:32:17 -0700502 apexSdkVersion() android.ApiLevel
Jiyong Parka4b9dd02019-01-16 22:53:13 +0900503 bootstrap() bool
Vic Yangefd249e2018-11-12 20:19:56 -0800504 mustUseVendorVariant() bool
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700505 nativeCoverage() bool
Colin Cross56a83212020-09-15 18:30:11 -0700506 directlyInAnyApex() bool
Colin Cross95b07f22020-12-16 11:06:50 -0800507 isPreventInstall() bool
Cindy Zhou5d5cfc12021-01-09 08:25:22 -0800508 isCfiAssemblySupportEnabled() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800509}
510
511type ModuleContext interface {
Colin Cross635c3b02016-05-18 15:37:25 -0700512 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800513 ModuleContextIntf
514}
515
516type BaseModuleContext interface {
Colin Cross0ea8ba82019-06-06 14:33:29 -0700517 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800518 ModuleContextIntf
519}
520
Colin Cross37047f12016-12-13 17:06:13 -0800521type DepsContext interface {
522 android.BottomUpMutatorContext
523 ModuleContextIntf
524}
525
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500526// feature represents additional (optional) steps to building cc-related modules, such as invocation
527// of clang-tidy.
Colin Crossca860ac2016-01-04 14:34:37 -0800528type feature interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800529 flags(ctx ModuleContext, flags Flags) Flags
530 props() []interface{}
531}
532
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500533// compiler is the interface for a compiler helper object. Different module decorators may implement
534// this helper differently. For example, compiling a `cc_library` may use a different build
535// statement than building a `toolchain_library`.
Colin Crossca860ac2016-01-04 14:34:37 -0800536type compiler interface {
Colin Cross42742b82016-08-01 13:20:05 -0700537 compilerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800538 compilerDeps(ctx DepsContext, deps Deps) Deps
Colin Crossf18e1102017-11-16 14:33:08 -0800539 compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
Colin Cross42742b82016-08-01 13:20:05 -0700540 compilerProps() []interface{}
541
Colin Cross76fada02016-07-27 10:31:13 -0700542 appendCflags([]string)
543 appendAsflags([]string)
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700544 compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects
Colin Crossca860ac2016-01-04 14:34:37 -0800545}
546
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500547// linker is the interface for a linker decorator object. Individual module types can provide
548// their own implementation for this decorator, and thus specify custom logic regarding build
549// statements pertaining to linking.
Colin Crossca860ac2016-01-04 14:34:37 -0800550type linker interface {
Colin Cross42742b82016-08-01 13:20:05 -0700551 linkerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800552 linkerDeps(ctx DepsContext, deps Deps) Deps
Colin Cross42742b82016-08-01 13:20:05 -0700553 linkerFlags(ctx ModuleContext, flags Flags) Flags
554 linkerProps() []interface{}
Ivan Lozanobd721262018-11-27 14:33:03 -0800555 useClangLld(actx ModuleContext) bool
Colin Cross42742b82016-08-01 13:20:05 -0700556
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700557 link(ctx ModuleContext, flags Flags, deps PathDeps, objs Objects) android.Path
Colin Cross76fada02016-07-27 10:31:13 -0700558 appendLdflags([]string)
Jiyong Parkaf6d8952019-01-31 12:21:23 +0900559 unstrippedOutputFilePath() android.Path
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700560
561 nativeCoverage() bool
Jiyong Parkee9a98d2019-08-09 14:44:36 +0900562 coverageOutputFilePath() android.OptionalPath
Paul Duffin13f02712020-03-06 12:30:43 +0000563
564 // Get the deps that have been explicitly specified in the properties.
Paul Duffin13f02712020-03-06 12:30:43 +0000565 linkerSpecifiedDeps(specifiedDeps specifiedDeps) specifiedDeps
566}
567
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500568// specifiedDeps is a tuple struct representing dependencies of a linked binary owned by the linker.
Paul Duffin13f02712020-03-06 12:30:43 +0000569type specifiedDeps struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500570 sharedLibs []string
571 // Note nil and [] are semantically distinct. [] prevents linking against the defaults (usually
572 // libc, libm, etc.)
Colin Cross9ecb42d2021-06-22 13:20:01 -0700573 systemSharedLibs []string
574 defaultSharedLibs []string
Colin Crossca860ac2016-01-04 14:34:37 -0800575}
576
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500577// installer is the interface for an installer helper object. This helper is responsible for
578// copying build outputs to the appropriate locations so that they may be installed on device.
Colin Crossca860ac2016-01-04 14:34:37 -0800579type installer interface {
Colin Cross42742b82016-08-01 13:20:05 -0700580 installerProps() []interface{}
Colin Cross635c3b02016-05-18 15:37:25 -0700581 install(ctx ModuleContext, path android.Path)
Paul Duffin0cb37b92020-03-04 14:52:46 +0000582 everInstallable() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800583 inData() bool
Vishwath Mohan1dd88392017-03-29 22:00:18 -0700584 inSanitizerDir() bool
Dan Willemsen4aa75ca2016-09-28 16:18:03 -0700585 hostToolPath() android.OptionalPath
Jiyong Parkb7c24df2019-02-01 12:03:59 +0900586 relativeInstallPath() string
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +0100587 makeUninstallable(mod *Module)
Inseob Kim800d1142021-06-14 12:03:51 +0900588 installInRoot() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800589}
590
Chris Parsons8d6e4332021-02-22 16:13:50 -0500591// bazelHandler is the interface for a helper object related to deferring to Bazel for
592// processing a module (during Bazel mixed builds). Individual module types should define
593// their own bazel handler if they support deferring to Bazel.
594type bazelHandler interface {
595 // Issue query to Bazel to retrieve information about Bazel's view of the current module.
596 // If Bazel returns this information, set module properties on the current module to reflect
597 // the returned information.
598 // Returns true if information was available from Bazel, false if bazel invocation still needs to occur.
599 generateBazelBuildActions(ctx android.ModuleContext, label string) bool
600}
601
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800602type xref interface {
603 XrefCcFiles() android.Paths
604}
605
Colin Cross6e511a92020-07-27 21:26:48 -0700606type libraryDependencyKind int
607
608const (
609 headerLibraryDependency = iota
610 sharedLibraryDependency
611 staticLibraryDependency
612)
613
614func (k libraryDependencyKind) String() string {
615 switch k {
616 case headerLibraryDependency:
617 return "headerLibraryDependency"
618 case sharedLibraryDependency:
619 return "sharedLibraryDependency"
620 case staticLibraryDependency:
621 return "staticLibraryDependency"
622 default:
623 panic(fmt.Errorf("unknown libraryDependencyKind %d", k))
624 }
625}
626
627type libraryDependencyOrder int
628
629const (
630 earlyLibraryDependency = -1
631 normalLibraryDependency = 0
632 lateLibraryDependency = 1
633)
634
635func (o libraryDependencyOrder) String() string {
636 switch o {
637 case earlyLibraryDependency:
638 return "earlyLibraryDependency"
639 case normalLibraryDependency:
640 return "normalLibraryDependency"
641 case lateLibraryDependency:
642 return "lateLibraryDependency"
643 default:
644 panic(fmt.Errorf("unknown libraryDependencyOrder %d", o))
645 }
646}
647
648// libraryDependencyTag is used to tag dependencies on libraries. Unlike many dependency
649// tags that have a set of predefined tag objects that are reused for each dependency, a
650// libraryDependencyTag is designed to contain extra metadata and is constructed as needed.
651// That means that comparing a libraryDependencyTag for equality will only be equal if all
652// of the metadata is equal. Most usages will want to type assert to libraryDependencyTag and
653// then check individual metadata fields instead.
654type libraryDependencyTag struct {
655 blueprint.BaseDependencyTag
656
657 // These are exported so that fmt.Printf("%#v") can call their String methods.
658 Kind libraryDependencyKind
659 Order libraryDependencyOrder
660
661 wholeStatic bool
662
663 reexportFlags bool
664 explicitlyVersioned bool
665 dataLib bool
666 ndk bool
667
668 staticUnwinder bool
669
670 makeSuffix string
Jiyong Parke3867542020-12-03 17:28:25 +0900671
Cindy Zhou18417cb2020-12-10 07:12:38 -0800672 // Whether or not this dependency should skip the apex dependency check
673 skipApexAllowedDependenciesCheck bool
674
Jiyong Parke3867542020-12-03 17:28:25 +0900675 // Whether or not this dependency has to be followed for the apex variants
676 excludeInApex bool
Colin Cross6e511a92020-07-27 21:26:48 -0700677}
678
679// header returns true if the libraryDependencyTag is tagging a header lib dependency.
680func (d libraryDependencyTag) header() bool {
681 return d.Kind == headerLibraryDependency
682}
683
684// shared returns true if the libraryDependencyTag is tagging a shared lib dependency.
685func (d libraryDependencyTag) shared() bool {
686 return d.Kind == sharedLibraryDependency
687}
688
689// shared returns true if the libraryDependencyTag is tagging a static lib dependency.
690func (d libraryDependencyTag) static() bool {
691 return d.Kind == staticLibraryDependency
692}
693
Colin Crosse9fe2942020-11-10 18:12:15 -0800694// InstallDepNeeded returns true for shared libraries so that shared library dependencies of
695// binaries or other shared libraries are installed as dependencies.
696func (d libraryDependencyTag) InstallDepNeeded() bool {
697 return d.shared()
698}
699
700var _ android.InstallNeededDependencyTag = libraryDependencyTag{}
701
702// dependencyTag is used for tagging miscellaneous dependency types that don't fit into
Colin Cross6e511a92020-07-27 21:26:48 -0700703// libraryDependencyTag. Each tag object is created globally and reused for multiple
704// dependencies (although since the object contains no references, assigning a tag to a
705// variable and modifying it will not modify the original). Users can compare the tag
706// returned by ctx.OtherModuleDependencyTag against the global original
707type dependencyTag struct {
708 blueprint.BaseDependencyTag
709 name string
710}
711
Colin Crosse9fe2942020-11-10 18:12:15 -0800712// installDependencyTag is used for tagging miscellaneous dependency types that don't fit into
713// libraryDependencyTag, but where the dependency needs to be installed when the parent is
714// installed.
715type installDependencyTag struct {
716 blueprint.BaseDependencyTag
717 android.InstallAlwaysNeededDependencyTag
718 name string
719}
720
Colin Crossc99deeb2016-04-11 15:06:20 -0700721var (
Colin Cross6e511a92020-07-27 21:26:48 -0700722 genSourceDepTag = dependencyTag{name: "gen source"}
723 genHeaderDepTag = dependencyTag{name: "gen header"}
724 genHeaderExportDepTag = dependencyTag{name: "gen header export"}
725 objDepTag = dependencyTag{name: "obj"}
Jiyong Parkd630bdd2020-11-25 11:47:24 +0900726 dynamicLinkerDepTag = installDependencyTag{name: "dynamic linker"}
Colin Cross6e511a92020-07-27 21:26:48 -0700727 reuseObjTag = dependencyTag{name: "reuse objects"}
728 staticVariantTag = dependencyTag{name: "static variant"}
729 vndkExtDepTag = dependencyTag{name: "vndk extends"}
730 dataLibDepTag = dependencyTag{name: "data lib"}
Colin Crosse9fe2942020-11-10 18:12:15 -0800731 runtimeDepTag = installDependencyTag{name: "runtime lib"}
Colin Cross6e511a92020-07-27 21:26:48 -0700732 testPerSrcDepTag = dependencyTag{name: "test_per_src"}
Colin Cross0de8a1e2020-09-18 14:15:30 -0700733 stubImplDepTag = dependencyTag{name: "stub_impl"}
Colin Crossc99deeb2016-04-11 15:06:20 -0700734)
735
Roland Levillainf89cd092019-07-29 16:22:59 +0100736func IsSharedDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700737 ccLibDepTag, ok := depTag.(libraryDependencyTag)
738 return ok && ccLibDepTag.shared()
739}
740
741func IsStaticDepTag(depTag blueprint.DependencyTag) bool {
742 ccLibDepTag, ok := depTag.(libraryDependencyTag)
743 return ok && ccLibDepTag.static()
Roland Levillainf89cd092019-07-29 16:22:59 +0100744}
745
Zach Johnson3df4e632020-11-06 11:56:27 -0800746func IsHeaderDepTag(depTag blueprint.DependencyTag) bool {
747 ccLibDepTag, ok := depTag.(libraryDependencyTag)
748 return ok && ccLibDepTag.header()
749}
750
Roland Levillainf89cd092019-07-29 16:22:59 +0100751func IsRuntimeDepTag(depTag blueprint.DependencyTag) bool {
Colin Crosse9fe2942020-11-10 18:12:15 -0800752 return depTag == runtimeDepTag
Roland Levillainf89cd092019-07-29 16:22:59 +0100753}
754
755func IsTestPerSrcDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700756 ccDepTag, ok := depTag.(dependencyTag)
Roland Levillainf89cd092019-07-29 16:22:59 +0100757 return ok && ccDepTag == testPerSrcDepTag
758}
759
Colin Crossca860ac2016-01-04 14:34:37 -0800760// Module contains the properties and members used by all C/C++ module types, and implements
761// the blueprint.Module interface. It delegates to compiler, linker, and installer interfaces
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500762// to construct the output file. Behavior can be customized with a Customizer, or "decorator",
763// interface.
764//
765// To define a C/C++ related module, construct a new Module object and point its delegates to
766// type-specific structs. These delegates will be invoked to register module-specific build
767// statements which may be unique to the module type. For example, module.compiler.compile() should
768// be defined so as to register build statements which are responsible for compiling the module.
769//
770// Another example: to construct a cc_binary module, one can create a `cc.binaryDecorator` struct
771// which implements the `linker` and `installer` interfaces, and points the `linker` and `installer`
772// members of the cc.Module to this decorator. Thus, a cc_binary module has custom linker and
773// installer logic.
Colin Crossca860ac2016-01-04 14:34:37 -0800774type Module struct {
Colin Cross635c3b02016-05-18 15:37:25 -0700775 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -0700776 android.DefaultableModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +0900777 android.ApexModuleBase
Jiyong Parkd1063c12019-07-17 20:08:41 +0900778 android.SdkBase
Liz Kammerea6666f2021-02-17 10:17:28 -0500779 android.BazelModuleBase
Colin Crossc472d572015-03-17 15:06:21 -0700780
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700781 Properties BaseProperties
782 VendorProperties VendorProperties
Colin Crossfa138792015-04-24 17:31:52 -0700783
Colin Crossca860ac2016-01-04 14:34:37 -0800784 // initialize before calling Init
Colin Cross635c3b02016-05-18 15:37:25 -0700785 hod android.HostOrDeviceSupported
786 multilib android.Multilib
Colin Crossc472d572015-03-17 15:06:21 -0700787
Paul Duffina0843f62019-12-13 19:50:38 +0000788 // Allowable SdkMemberTypes of this module type.
789 sdkMemberTypes []android.SdkMemberType
790
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500791 // decorator delegates, initialize before calling Init
792 // these may contain module-specific implementations, and effectively allow for custom
793 // type-specific logic. These members may reference different objects or the same object.
794 // Functions of these decorators will be invoked to initialize and register type-specific
795 // build statements.
Chris Parsons8d6e4332021-02-22 16:13:50 -0500796 compiler compiler
797 linker linker
798 installer installer
799 bazelHandler bazelHandler
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500800
801 features []feature
802 stl *stl
803 sanitize *sanitize
804 coverage *coverage
805 sabi *sabi
806 vndkdep *vndkdep
807 lto *lto
808 pgo *pgo
Colin Cross16b23492016-01-06 14:41:07 -0800809
Colin Cross31076b32020-10-23 17:22:06 -0700810 library libraryInterface
811
Colin Cross635c3b02016-05-18 15:37:25 -0700812 outputFile android.OptionalPath
Colin Crossca860ac2016-01-04 14:34:37 -0800813
Colin Crossb98c8b02016-07-29 13:44:28 -0700814 cachedToolchain config.Toolchain
Colin Crossb916a382016-07-29 17:28:03 -0700815
816 subAndroidMkOnce map[subAndroidMkProvider]bool
Fabien Sanglardd61f1f42017-01-10 16:21:22 -0800817
818 // Flags used to compile this module
819 flags Flags
Jeff Gaston294356f2017-09-27 17:05:30 -0700820
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800821 // only non-nil when this is a shared library that reuses the objects of a static library
Colin Cross0de8a1e2020-09-18 14:15:30 -0700822 staticAnalogue *StaticLibraryInfo
Inseob Kim9516ee92019-05-09 10:56:13 +0900823
824 makeLinkType string
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800825 // Kythe (source file indexer) paths for this compilation module
826 kytheFiles android.Paths
Jooyung Han75568392020-03-20 04:29:24 +0900827
828 // For apex variants, this is set as apex.min_sdk_version
Dan Albertc8060532020-07-22 22:32:17 -0700829 apexSdkVersion android.ApiLevel
Colin Cross56a83212020-09-15 18:30:11 -0700830
831 hideApexVariantFromMake bool
Colin Crossc472d572015-03-17 15:06:21 -0700832}
833
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200834func (c *Module) AddJSONData(d *map[string]interface{}) {
835 c.AndroidModuleBase().AddJSONData(d)
836 (*d)["Cc"] = map[string]interface{}{
837 "SdkVersion": c.SdkVersion(),
838 "MinSdkVersion": c.MinSdkVersion(),
839 "VndkVersion": c.VndkVersion(),
840 "ProductSpecific": c.ProductSpecific(),
841 "SocSpecific": c.SocSpecific(),
842 "DeviceSpecific": c.DeviceSpecific(),
843 "InProduct": c.InProduct(),
844 "InVendor": c.InVendor(),
845 "InRamdisk": c.InRamdisk(),
846 "InVendorRamdisk": c.InVendorRamdisk(),
847 "InRecovery": c.InRecovery(),
848 "VendorAvailable": c.VendorAvailable(),
849 "ProductAvailable": c.ProductAvailable(),
850 "RamdiskAvailable": c.RamdiskAvailable(),
851 "VendorRamdiskAvailable": c.VendorRamdiskAvailable(),
852 "RecoveryAvailable": c.RecoveryAvailable(),
853 "OdmAvailable": c.OdmAvailable(),
854 "InstallInData": c.InstallInData(),
855 "InstallInRamdisk": c.InstallInRamdisk(),
856 "InstallInSanitizerDir": c.InstallInSanitizerDir(),
857 "InstallInVendorRamdisk": c.InstallInVendorRamdisk(),
858 "InstallInRecovery": c.InstallInRecovery(),
859 "InstallInRoot": c.InstallInRoot(),
860 "IsVndk": c.IsVndk(),
861 "IsVndkExt": c.IsVndkExt(),
862 "IsVndkPrivate": c.IsVndkPrivate(),
863 "IsVndkSp": c.IsVndkSp(),
864 "IsLlndk": c.IsLlndk(),
865 "IsLlndkPublic": c.IsLlndkPublic(),
866 "IsSnapshotLibrary": c.IsSnapshotLibrary(),
867 "IsSnapshotPrebuilt": c.IsSnapshotPrebuilt(),
868 "IsVendorPublicLibrary": c.IsVendorPublicLibrary(),
869 "ApexSdkVersion": c.apexSdkVersion,
870 "TestFor": c.TestFor(),
871 }
872}
873
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500874func (c *Module) SetPreventInstall() {
875 c.Properties.PreventInstall = true
876}
877
878func (c *Module) SetHideFromMake() {
879 c.Properties.HideFromMake = true
880}
881
Ivan Lozanod7586b62021-04-01 09:49:36 -0400882func (c *Module) HiddenFromMake() bool {
883 return c.Properties.HideFromMake
884}
885
Ivan Lozano52767be2019-10-18 14:49:46 -0700886func (c *Module) Toc() android.OptionalPath {
887 if c.linker != nil {
888 if library, ok := c.linker.(libraryInterface); ok {
889 return library.toc()
890 }
891 }
892 panic(fmt.Errorf("Toc() called on non-library module: %q", c.BaseModuleName()))
893}
894
895func (c *Module) ApiLevel() string {
896 if c.linker != nil {
897 if stub, ok := c.linker.(*stubDecorator); ok {
Dan Albert1a246272020-07-06 14:49:35 -0700898 return stub.apiLevel.String()
Ivan Lozano52767be2019-10-18 14:49:46 -0700899 }
900 }
901 panic(fmt.Errorf("ApiLevel() called on non-stub library module: %q", c.BaseModuleName()))
902}
903
904func (c *Module) Static() bool {
905 if c.linker != nil {
906 if library, ok := c.linker.(libraryInterface); ok {
907 return library.static()
908 }
909 }
910 panic(fmt.Errorf("Static() called on non-library module: %q", c.BaseModuleName()))
911}
912
913func (c *Module) Shared() bool {
914 if c.linker != nil {
915 if library, ok := c.linker.(libraryInterface); ok {
916 return library.shared()
917 }
918 }
919 panic(fmt.Errorf("Shared() called on non-library module: %q", c.BaseModuleName()))
920}
921
922func (c *Module) SelectedStl() string {
Colin Crossc511bc52020-04-07 16:50:32 +0000923 if c.stl != nil {
924 return c.stl.Properties.SelectedStl
925 }
926 return ""
Ivan Lozano52767be2019-10-18 14:49:46 -0700927}
928
929func (c *Module) ToolchainLibrary() bool {
930 if _, ok := c.linker.(*toolchainLibraryDecorator); ok {
931 return true
932 }
933 return false
934}
935
936func (c *Module) NdkPrebuiltStl() bool {
937 if _, ok := c.linker.(*ndkPrebuiltStlLinker); ok {
938 return true
939 }
940 return false
941}
942
943func (c *Module) StubDecorator() bool {
944 if _, ok := c.linker.(*stubDecorator); ok {
945 return true
946 }
947 return false
948}
949
950func (c *Module) SdkVersion() string {
951 return String(c.Properties.Sdk_version)
952}
953
Artur Satayev480e25b2020-04-27 18:53:18 +0100954func (c *Module) MinSdkVersion() string {
955 return String(c.Properties.Min_sdk_version)
956}
957
Dan Albert92fe7402020-07-15 13:33:30 -0700958func (c *Module) SplitPerApiLevel() bool {
Colin Cross1348ce32020-10-01 13:37:16 -0700959 if !c.canUseSdk() {
960 return false
961 }
Dan Albert92fe7402020-07-15 13:33:30 -0700962 if linker, ok := c.linker.(*objectLinker); ok {
963 return linker.isCrt()
964 }
965 return false
966}
967
Colin Crossc511bc52020-04-07 16:50:32 +0000968func (c *Module) AlwaysSdk() bool {
969 return c.Properties.AlwaysSdk || Bool(c.Properties.Sdk_variant_only)
970}
971
Ivan Lozano183a3212019-10-18 14:18:45 -0700972func (c *Module) CcLibrary() bool {
973 if c.linker != nil {
974 if _, ok := c.linker.(*libraryDecorator); ok {
975 return true
976 }
Colin Crossd48fe732020-09-23 20:37:24 -0700977 if _, ok := c.linker.(*prebuiltLibraryLinker); ok {
978 return true
979 }
Ivan Lozano183a3212019-10-18 14:18:45 -0700980 }
981 return false
982}
983
984func (c *Module) CcLibraryInterface() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -0700985 if _, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700986 return true
987 }
988 return false
989}
990
Ivan Lozano2b262972019-11-21 12:30:50 -0800991func (c *Module) NonCcVariants() bool {
992 return false
993}
994
Ivan Lozano183a3212019-10-18 14:18:45 -0700995func (c *Module) SetStatic() {
996 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700997 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700998 library.setStatic()
999 return
1000 }
1001 }
1002 panic(fmt.Errorf("SetStatic called on non-library module: %q", c.BaseModuleName()))
1003}
1004
1005func (c *Module) SetShared() {
1006 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001007 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001008 library.setShared()
1009 return
1010 }
1011 }
1012 panic(fmt.Errorf("SetShared called on non-library module: %q", c.BaseModuleName()))
1013}
1014
1015func (c *Module) BuildStaticVariant() bool {
1016 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001017 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001018 return library.buildStatic()
1019 }
1020 }
1021 panic(fmt.Errorf("BuildStaticVariant called on non-library module: %q", c.BaseModuleName()))
1022}
1023
1024func (c *Module) BuildSharedVariant() bool {
1025 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001026 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001027 return library.buildShared()
1028 }
1029 }
1030 panic(fmt.Errorf("BuildSharedVariant called on non-library module: %q", c.BaseModuleName()))
1031}
1032
1033func (c *Module) Module() android.Module {
1034 return c
1035}
1036
Jiyong Parkc20eee32018-09-05 22:36:17 +09001037func (c *Module) OutputFile() android.OptionalPath {
1038 return c.outputFile
1039}
1040
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001041func (c *Module) CoverageFiles() android.Paths {
1042 if c.linker != nil {
1043 if library, ok := c.linker.(libraryInterface); ok {
1044 return library.objs().coverageFiles
1045 }
1046 }
1047 panic(fmt.Errorf("CoverageFiles called on non-library module: %q", c.BaseModuleName()))
1048}
1049
Ivan Lozano183a3212019-10-18 14:18:45 -07001050var _ LinkableInterface = (*Module)(nil)
1051
Jiyong Park719b4462019-01-13 00:39:51 +09001052func (c *Module) UnstrippedOutputFile() android.Path {
Jiyong Parkaf6d8952019-01-31 12:21:23 +09001053 if c.linker != nil {
1054 return c.linker.unstrippedOutputFilePath()
Jiyong Park719b4462019-01-13 00:39:51 +09001055 }
1056 return nil
1057}
1058
Jiyong Parkee9a98d2019-08-09 14:44:36 +09001059func (c *Module) CoverageOutputFile() android.OptionalPath {
1060 if c.linker != nil {
1061 return c.linker.coverageOutputFilePath()
1062 }
1063 return android.OptionalPath{}
1064}
1065
Jiyong Parkb7c24df2019-02-01 12:03:59 +09001066func (c *Module) RelativeInstallPath() string {
1067 if c.installer != nil {
1068 return c.installer.relativeInstallPath()
1069 }
1070 return ""
1071}
1072
Jooyung Han344d5432019-08-23 11:17:39 +09001073func (c *Module) VndkVersion() string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001074 return c.Properties.VndkVersion
Jooyung Han344d5432019-08-23 11:17:39 +09001075}
1076
Colin Cross36242852017-06-23 15:06:31 -07001077func (c *Module) Init() android.Module {
Dan Willemsenf923f2b2018-05-09 13:45:03 -07001078 c.AddProperties(&c.Properties, &c.VendorProperties)
Colin Crossca860ac2016-01-04 14:34:37 -08001079 if c.compiler != nil {
Colin Cross36242852017-06-23 15:06:31 -07001080 c.AddProperties(c.compiler.compilerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001081 }
1082 if c.linker != nil {
Colin Cross36242852017-06-23 15:06:31 -07001083 c.AddProperties(c.linker.linkerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001084 }
1085 if c.installer != nil {
Colin Cross36242852017-06-23 15:06:31 -07001086 c.AddProperties(c.installer.installerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001087 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001088 if c.stl != nil {
Colin Cross36242852017-06-23 15:06:31 -07001089 c.AddProperties(c.stl.props()...)
Colin Crossa8e07cc2016-04-04 15:07:06 -07001090 }
Colin Cross16b23492016-01-06 14:41:07 -08001091 if c.sanitize != nil {
Colin Cross36242852017-06-23 15:06:31 -07001092 c.AddProperties(c.sanitize.props()...)
Colin Cross16b23492016-01-06 14:41:07 -08001093 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001094 if c.coverage != nil {
Colin Cross36242852017-06-23 15:06:31 -07001095 c.AddProperties(c.coverage.props()...)
Dan Willemsen581341d2017-02-09 16:16:31 -08001096 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001097 if c.sabi != nil {
Colin Cross36242852017-06-23 15:06:31 -07001098 c.AddProperties(c.sabi.props()...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001099 }
Justin Yun8effde42017-06-23 19:24:43 +09001100 if c.vndkdep != nil {
1101 c.AddProperties(c.vndkdep.props()...)
1102 }
Stephen Craneba090d12017-05-09 15:44:35 -07001103 if c.lto != nil {
1104 c.AddProperties(c.lto.props()...)
1105 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001106 if c.pgo != nil {
1107 c.AddProperties(c.pgo.props()...)
1108 }
Colin Crossca860ac2016-01-04 14:34:37 -08001109 for _, feature := range c.features {
Colin Cross36242852017-06-23 15:06:31 -07001110 c.AddProperties(feature.props()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001111 }
Colin Crossc472d572015-03-17 15:06:21 -07001112
Colin Cross36242852017-06-23 15:06:31 -07001113 android.InitAndroidArchModule(c, c.hod, c.multilib)
Liz Kammerea6666f2021-02-17 10:17:28 -05001114 android.InitBazelModule(c)
Jiyong Park7916bfc2019-09-30 19:13:12 +09001115 android.InitApexModule(c)
Jiyong Parkd1063c12019-07-17 20:08:41 +09001116 android.InitSdkAwareModule(c)
Jooyung Han18020ea2019-11-13 10:50:48 +09001117 android.InitDefaultableModule(c)
Jiyong Park9d452992018-10-03 00:38:19 +09001118
Colin Cross36242852017-06-23 15:06:31 -07001119 return c
Colin Crossc472d572015-03-17 15:06:21 -07001120}
1121
Colin Crossb916a382016-07-29 17:28:03 -07001122// Returns true for dependency roots (binaries)
1123// TODO(ccross): also handle dlopenable libraries
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001124func (c *Module) IsDependencyRoot() bool {
Colin Crossb916a382016-07-29 17:28:03 -07001125 if root, ok := c.linker.(interface {
1126 isDependencyRoot() bool
1127 }); ok {
1128 return root.isDependencyRoot()
1129 }
1130 return false
1131}
1132
Ivan Lozano52767be2019-10-18 14:49:46 -07001133func (c *Module) UseVndk() bool {
Inseob Kim64c43952019-08-26 16:52:35 +09001134 return c.Properties.VndkVersion != ""
Dan Willemsen4416e5d2017-04-06 12:43:22 -07001135}
1136
Colin Crossc511bc52020-04-07 16:50:32 +00001137func (c *Module) canUseSdk() bool {
Colin Cross94e347e2021-01-19 14:56:07 -08001138 return c.Os() == android.Android && c.Target().NativeBridge == android.NativeBridgeDisabled &&
1139 !c.UseVndk() && !c.InRamdisk() && !c.InRecovery() && !c.InVendorRamdisk()
Colin Crossc511bc52020-04-07 16:50:32 +00001140}
1141
1142func (c *Module) UseSdk() bool {
1143 if c.canUseSdk() {
Colin Cross1348ce32020-10-01 13:37:16 -07001144 return String(c.Properties.Sdk_version) != ""
Colin Crossc511bc52020-04-07 16:50:32 +00001145 }
1146 return false
1147}
1148
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001149func (c *Module) isCoverageVariant() bool {
1150 return c.coverage.Properties.IsCoverageVariant
1151}
1152
Colin Cross95f1ca02020-10-29 20:47:22 -07001153func (c *Module) IsNdk(config android.Config) bool {
1154 return inList(c.BaseModuleName(), *getNDKKnownLibs(config))
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001155}
1156
Colin Cross127bb8b2020-12-16 16:46:01 -08001157func (c *Module) IsLlndk() bool {
1158 return c.VendorProperties.IsLLNDK
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001159}
1160
Colin Cross127bb8b2020-12-16 16:46:01 -08001161func (c *Module) IsLlndkPublic() bool {
Colin Cross78212242021-01-06 14:51:30 -08001162 return c.VendorProperties.IsLLNDK && !c.VendorProperties.IsVNDKPrivate
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001163}
1164
Colin Cross1f3f1302021-04-26 18:37:44 -07001165func (m *Module) NeedsLlndkVariants() bool {
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001166 lib := moduleLibraryInterface(m)
Colin Cross1f3f1302021-04-26 18:37:44 -07001167 return lib != nil && (lib.hasLLNDKStubs() || lib.hasLLNDKHeaders())
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001168}
1169
Colin Cross5271fea2021-04-27 13:06:04 -07001170func (m *Module) NeedsVendorPublicLibraryVariants() bool {
1171 lib := moduleLibraryInterface(m)
1172 return lib != nil && (lib.hasVendorPublicLibrary())
1173}
1174
1175// IsVendorPublicLibrary returns true for vendor public libraries.
1176func (c *Module) IsVendorPublicLibrary() bool {
1177 return c.VendorProperties.IsVendorPublicLibrary
1178}
1179
Ivan Lozanod7586b62021-04-01 09:49:36 -04001180func (c *Module) HasLlndkStubs() bool {
1181 lib := moduleLibraryInterface(c)
1182 return lib != nil && lib.hasLLNDKStubs()
1183}
1184
1185func (c *Module) StubsVersion() string {
1186 if lib, ok := c.linker.(versionedInterface); ok {
1187 return lib.stubsVersion()
1188 }
1189 panic(fmt.Errorf("StubsVersion called on non-versioned module: %q", c.BaseModuleName()))
1190}
1191
Colin Cross127bb8b2020-12-16 16:46:01 -08001192// isImplementationForLLNDKPublic returns true for any variant of a cc_library that has LLNDK stubs
1193// and does not set llndk.vendor_available: false.
1194func (c *Module) isImplementationForLLNDKPublic() bool {
1195 library, _ := c.library.(*libraryDecorator)
1196 return library != nil && library.hasLLNDKStubs() &&
Colin Cross0fb7fcd2021-03-02 11:00:07 -08001197 !Bool(library.Properties.Llndk.Private)
Colin Cross127bb8b2020-12-16 16:46:01 -08001198}
1199
Justin Yunfd9e8042020-12-23 18:23:14 +09001200// Returns true for LLNDK-private, VNDK-SP-private, and VNDK-core-private.
Colin Cross127bb8b2020-12-16 16:46:01 -08001201func (c *Module) IsVndkPrivate() bool {
Justin Yunfd9e8042020-12-23 18:23:14 +09001202 // Check if VNDK-core-private or VNDK-SP-private
1203 if c.IsVndk() {
Justin Yunc0d8c492021-01-07 17:45:31 +09001204 return Bool(c.vndkdep.Properties.Vndk.Private)
Justin Yunfd9e8042020-12-23 18:23:14 +09001205 }
1206
1207 // Check if LLNDK-private
1208 if library, ok := c.library.(*libraryDecorator); ok && c.IsLlndk() {
Justin Yunc0d8c492021-01-07 17:45:31 +09001209 return Bool(library.Properties.Llndk.Private)
Justin Yunfd9e8042020-12-23 18:23:14 +09001210 }
1211
1212 return false
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001213}
1214
Ivan Lozano52767be2019-10-18 14:49:46 -07001215func (c *Module) IsVndk() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001216 if vndkdep := c.vndkdep; vndkdep != nil {
1217 return vndkdep.isVndk()
Justin Yun8effde42017-06-23 19:24:43 +09001218 }
1219 return false
1220}
1221
Yi Kong7e53c572018-02-14 18:16:12 +08001222func (c *Module) isPgoCompile() bool {
1223 if pgo := c.pgo; pgo != nil {
1224 return pgo.Properties.PgoCompile
1225 }
1226 return false
1227}
1228
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001229func (c *Module) isNDKStubLibrary() bool {
1230 if _, ok := c.compiler.(*stubDecorator); ok {
1231 return true
1232 }
1233 return false
1234}
1235
Ivan Lozanod7586b62021-04-01 09:49:36 -04001236func (c *Module) IsVndkSp() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001237 if vndkdep := c.vndkdep; vndkdep != nil {
1238 return vndkdep.isVndkSp()
1239 }
1240 return false
1241}
1242
Ivan Lozanof9e21722020-12-02 09:00:51 -05001243func (c *Module) IsVndkExt() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001244 if vndkdep := c.vndkdep; vndkdep != nil {
1245 return vndkdep.isVndkExt()
1246 }
1247 return false
1248}
1249
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001250func (c *Module) SubName() string {
1251 return c.Properties.SubName
1252}
1253
Ivan Lozano52767be2019-10-18 14:49:46 -07001254func (c *Module) MustUseVendorVariant() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001255 return c.IsVndkSp() || c.Properties.MustUseVendorVariant
Vic Yangefd249e2018-11-12 20:19:56 -08001256}
1257
Logan Chienf3511742017-10-31 18:04:35 +08001258func (c *Module) getVndkExtendsModuleName() string {
1259 if vndkdep := c.vndkdep; vndkdep != nil {
1260 return vndkdep.getVndkExtendsModuleName()
1261 }
1262 return ""
1263}
1264
Jiyong Park25fc6a92018-11-18 18:02:45 +09001265func (c *Module) IsStubs() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001266 if lib := c.library; lib != nil {
1267 return lib.buildStubs()
Jiyong Park25fc6a92018-11-18 18:02:45 +09001268 }
1269 return false
1270}
1271
1272func (c *Module) HasStubsVariants() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001273 if lib := c.library; lib != nil {
1274 return lib.hasStubsVariants()
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001275 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09001276 return false
1277}
1278
Colin Cross0477b422020-10-13 18:43:54 -07001279// If this is a stubs library, ImplementationModuleName returns the name of the module that contains
1280// the implementation. If it is an implementation library it returns its own name.
1281func (c *Module) ImplementationModuleName(ctx android.BaseModuleContext) string {
1282 name := ctx.OtherModuleName(c)
1283 if versioned, ok := c.linker.(versionedInterface); ok {
1284 name = versioned.implementationModuleName(name)
1285 }
1286 return name
1287}
1288
Martin Stjernholm2856c662020-12-02 15:03:42 +00001289// Similar to ImplementationModuleName, but uses the Make variant of the module
1290// name as base name, for use in AndroidMk output. E.g. for a prebuilt module
1291// where the Soong name is prebuilt_foo, this returns foo (which works in Make
1292// under the premise that the prebuilt module overrides its source counterpart
1293// if it is exposed to Make).
1294func (c *Module) ImplementationModuleNameForMake(ctx android.BaseModuleContext) string {
1295 name := c.BaseModuleName()
1296 if versioned, ok := c.linker.(versionedInterface); ok {
1297 name = versioned.implementationModuleName(name)
1298 }
1299 return name
1300}
1301
Jiyong Park7d55b612021-06-11 17:22:09 +09001302func (c *Module) Bootstrap() bool {
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001303 return Bool(c.Properties.Bootstrap)
1304}
1305
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001306func (c *Module) nativeCoverage() bool {
Pirama Arumuga Nainar5f69b9a2019-09-12 13:18:48 -07001307 // Bug: http://b/137883967 - native-bridge modules do not currently work with coverage
1308 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1309 return false
1310 }
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001311 return c.linker != nil && c.linker.nativeCoverage()
1312}
1313
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001314func (c *Module) IsSnapshotPrebuilt() bool {
Ivan Lozanod1dec542021-05-26 15:33:11 -04001315 if p, ok := c.linker.(SnapshotInterface); ok {
1316 return p.IsSnapshotPrebuilt()
Inseob Kimeec88e12020-01-22 11:11:29 +09001317 }
1318 return false
Inseob Kim8471cda2019-11-15 09:59:12 +09001319}
1320
Bill Peckham945441c2020-08-31 16:07:58 -07001321func (c *Module) ExcludeFromVendorSnapshot() bool {
1322 return Bool(c.Properties.Exclude_from_vendor_snapshot)
1323}
1324
Jose Galmesf7294582020-11-13 12:07:36 -08001325func (c *Module) ExcludeFromRecoverySnapshot() bool {
1326 return Bool(c.Properties.Exclude_from_recovery_snapshot)
1327}
1328
Jiyong Parkf1194352019-02-25 11:05:47 +09001329func isBionic(name string) bool {
1330 switch name {
Kiyoung Kim4098c7e2020-11-30 14:42:14 +09001331 case "libc", "libm", "libdl", "libdl_android", "linker", "linkerconfig":
Jiyong Parkf1194352019-02-25 11:05:47 +09001332 return true
1333 }
1334 return false
1335}
1336
Martin Stjernholm279de572019-09-10 23:18:20 +01001337func InstallToBootstrap(name string, config android.Config) bool {
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001338 if name == "libclang_rt.hwasan-aarch64-android" {
Jooyung Han8ce8db92020-05-15 19:05:05 +09001339 return true
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001340 }
1341 return isBionic(name)
1342}
1343
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001344func (c *Module) XrefCcFiles() android.Paths {
1345 return c.kytheFiles
1346}
1347
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001348func (c *Module) isCfiAssemblySupportEnabled() bool {
1349 return c.sanitize != nil &&
1350 Bool(c.sanitize.Properties.Sanitize.Config.Cfi_assembly_support)
1351}
1352
Inseob Kim800d1142021-06-14 12:03:51 +09001353func (c *Module) InstallInRoot() bool {
1354 return c.installer != nil && c.installer.installInRoot()
1355}
1356
Colin Crossca860ac2016-01-04 14:34:37 -08001357type baseModuleContext struct {
Colin Cross0ea8ba82019-06-06 14:33:29 -07001358 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001359 moduleContextImpl
1360}
1361
Colin Cross37047f12016-12-13 17:06:13 -08001362type depsContext struct {
1363 android.BottomUpMutatorContext
1364 moduleContextImpl
1365}
1366
Colin Crossca860ac2016-01-04 14:34:37 -08001367type moduleContext struct {
Colin Cross635c3b02016-05-18 15:37:25 -07001368 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001369 moduleContextImpl
1370}
1371
1372type moduleContextImpl struct {
1373 mod *Module
1374 ctx BaseModuleContext
1375}
1376
Colin Crossb98c8b02016-07-29 13:44:28 -07001377func (ctx *moduleContextImpl) toolchain() config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001378 return ctx.mod.toolchain(ctx.ctx)
1379}
1380
1381func (ctx *moduleContextImpl) static() bool {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00001382 return ctx.mod.static()
Colin Crossca860ac2016-01-04 14:34:37 -08001383}
1384
1385func (ctx *moduleContextImpl) staticBinary() bool {
Jiyong Park379de2f2018-12-19 02:47:14 +09001386 return ctx.mod.staticBinary()
Colin Crossca860ac2016-01-04 14:34:37 -08001387}
1388
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07001389func (ctx *moduleContextImpl) testBinary() bool {
1390 return ctx.mod.testBinary()
1391}
1392
Jiyong Park1d1119f2019-07-29 21:27:18 +09001393func (ctx *moduleContextImpl) header() bool {
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001394 return ctx.mod.Header()
Jiyong Park1d1119f2019-07-29 21:27:18 +09001395}
1396
Inseob Kim7f283f42020-06-01 21:53:49 +09001397func (ctx *moduleContextImpl) binary() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001398 return ctx.mod.Binary()
Inseob Kim7f283f42020-06-01 21:53:49 +09001399}
1400
Inseob Kim1042d292020-06-01 23:23:05 +09001401func (ctx *moduleContextImpl) object() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001402 return ctx.mod.Object()
Inseob Kim1042d292020-06-01 23:23:05 +09001403}
1404
Jooyung Hanccce2f22020-03-07 03:45:53 +09001405func (ctx *moduleContextImpl) canUseSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001406 return ctx.mod.canUseSdk()
Jooyung Hanccce2f22020-03-07 03:45:53 +09001407}
1408
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001409func (ctx *moduleContextImpl) useSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001410 return ctx.mod.UseSdk()
Colin Crossca860ac2016-01-04 14:34:37 -08001411}
1412
1413func (ctx *moduleContextImpl) sdkVersion() string {
Dan Willemsena96ff642016-06-07 12:34:45 -07001414 if ctx.ctx.Device() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001415 if ctx.useVndk() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001416 vndkVer := ctx.mod.VndkVersion()
Jooyung Han03302ee2020-04-08 09:22:26 +09001417 if inList(vndkVer, ctx.ctx.Config().PlatformVersionActiveCodenames()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001418 return "current"
Justin Yun732aa6a2018-03-23 17:43:47 +09001419 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001420 return vndkVer
Dan Willemsend2ede872016-11-18 14:54:24 -08001421 }
Justin Yun732aa6a2018-03-23 17:43:47 +09001422 return String(ctx.mod.Properties.Sdk_version)
Dan Willemsena96ff642016-06-07 12:34:45 -07001423 }
1424 return ""
Colin Crossca860ac2016-01-04 14:34:37 -08001425}
1426
Jiyong Parkb35a8192020-08-10 15:59:36 +09001427func (ctx *moduleContextImpl) minSdkVersion() string {
1428 ver := ctx.mod.MinSdkVersion()
1429 if ver == "apex_inherit" && !ctx.isForPlatform() {
1430 ver = ctx.apexSdkVersion().String()
1431 }
1432 if ver == "apex_inherit" || ver == "" {
1433 ver = ctx.sdkVersion()
1434 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001435 // For crt objects, the meaning of min_sdk_version is very different from other types of
1436 // module. For them, min_sdk_version defines the oldest version that the build system will
1437 // create versioned variants for. For example, if min_sdk_version is 16, then sdk variant of
1438 // the crt object has local variants of 16, 17, ..., up to the latest version. sdk_version
1439 // and min_sdk_version properties of the variants are set to the corresponding version
1440 // numbers. However, the platform (non-sdk) variant of the crt object is left untouched.
1441 // min_sdk_version: 16 doesn't actually mean that the platform variant has to support such
1442 // an old version. Since the variant is for the platform, it's preferred to target the
1443 // latest version.
1444 if ctx.mod.SplitPerApiLevel() && !ctx.isSdkVariant() {
1445 ver = strconv.Itoa(android.FutureApiLevelInt)
1446 }
1447
Jiyong Parkb35a8192020-08-10 15:59:36 +09001448 // Also make sure that minSdkVersion is not greater than sdkVersion, if they are both numbers
1449 sdkVersionInt, err := strconv.Atoi(ctx.sdkVersion())
1450 minSdkVersionInt, err2 := strconv.Atoi(ver)
1451 if err == nil && err2 == nil {
1452 if sdkVersionInt < minSdkVersionInt {
1453 return strconv.Itoa(sdkVersionInt)
1454 }
1455 }
1456 return ver
1457}
1458
1459func (ctx *moduleContextImpl) isSdkVariant() bool {
1460 return ctx.mod.IsSdkVariant()
1461}
1462
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001463func (ctx *moduleContextImpl) useVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001464 return ctx.mod.UseVndk()
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001465}
Justin Yun8effde42017-06-23 19:24:43 +09001466
Colin Cross95f1ca02020-10-29 20:47:22 -07001467func (ctx *moduleContextImpl) isNdk(config android.Config) bool {
1468 return ctx.mod.IsNdk(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001469}
1470
Colin Cross127bb8b2020-12-16 16:46:01 -08001471func (ctx *moduleContextImpl) IsLlndk() bool {
1472 return ctx.mod.IsLlndk()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001473}
1474
Colin Cross127bb8b2020-12-16 16:46:01 -08001475func (ctx *moduleContextImpl) IsLlndkPublic() bool {
1476 return ctx.mod.IsLlndkPublic()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001477}
1478
Colin Cross127bb8b2020-12-16 16:46:01 -08001479func (ctx *moduleContextImpl) isImplementationForLLNDKPublic() bool {
1480 return ctx.mod.isImplementationForLLNDKPublic()
1481}
1482
1483func (ctx *moduleContextImpl) IsVndkPrivate() bool {
1484 return ctx.mod.IsVndkPrivate()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001485}
1486
Logan Chienf3511742017-10-31 18:04:35 +08001487func (ctx *moduleContextImpl) isVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001488 return ctx.mod.IsVndk()
Logan Chienf3511742017-10-31 18:04:35 +08001489}
1490
Yi Kong7e53c572018-02-14 18:16:12 +08001491func (ctx *moduleContextImpl) isPgoCompile() bool {
1492 return ctx.mod.isPgoCompile()
1493}
1494
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001495func (ctx *moduleContextImpl) isNDKStubLibrary() bool {
1496 return ctx.mod.isNDKStubLibrary()
1497}
1498
Justin Yun8effde42017-06-23 19:24:43 +09001499func (ctx *moduleContextImpl) isVndkSp() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001500 return ctx.mod.IsVndkSp()
Logan Chienf3511742017-10-31 18:04:35 +08001501}
1502
Ivan Lozanof9e21722020-12-02 09:00:51 -05001503func (ctx *moduleContextImpl) IsVndkExt() bool {
1504 return ctx.mod.IsVndkExt()
Justin Yun8effde42017-06-23 19:24:43 +09001505}
1506
Colin Cross5271fea2021-04-27 13:06:04 -07001507func (ctx *moduleContextImpl) IsVendorPublicLibrary() bool {
1508 return ctx.mod.IsVendorPublicLibrary()
1509}
1510
Vic Yangefd249e2018-11-12 20:19:56 -08001511func (ctx *moduleContextImpl) mustUseVendorVariant() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001512 return ctx.mod.MustUseVendorVariant()
Vic Yangefd249e2018-11-12 20:19:56 -08001513}
1514
Dan Willemsen8146b2f2016-03-30 21:00:30 -07001515func (ctx *moduleContextImpl) selectedStl() string {
1516 if stl := ctx.mod.stl; stl != nil {
1517 return stl.Properties.SelectedStl
1518 }
1519 return ""
1520}
1521
Ivan Lozanobd721262018-11-27 14:33:03 -08001522func (ctx *moduleContextImpl) useClangLld(actx ModuleContext) bool {
1523 return ctx.mod.linker.useClangLld(actx)
1524}
1525
Colin Crossce75d2c2016-10-06 16:12:58 -07001526func (ctx *moduleContextImpl) baseModuleName() string {
1527 return ctx.mod.ModuleBase.BaseModuleName()
1528}
1529
Logan Chienf3511742017-10-31 18:04:35 +08001530func (ctx *moduleContextImpl) getVndkExtendsModuleName() string {
1531 return ctx.mod.getVndkExtendsModuleName()
1532}
1533
Logan Chiene274fc92019-12-03 11:18:32 -08001534func (ctx *moduleContextImpl) isForPlatform() bool {
Colin Cross56a83212020-09-15 18:30:11 -07001535 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).IsForPlatform()
Logan Chiene274fc92019-12-03 11:18:32 -08001536}
1537
Colin Crosse07f2312020-08-13 11:24:56 -07001538func (ctx *moduleContextImpl) apexVariationName() string {
Colin Cross56a83212020-09-15 18:30:11 -07001539 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).ApexVariationName
Jiyong Park25fc6a92018-11-18 18:02:45 +09001540}
1541
Dan Albertc8060532020-07-22 22:32:17 -07001542func (ctx *moduleContextImpl) apexSdkVersion() android.ApiLevel {
Jooyung Han75568392020-03-20 04:29:24 +09001543 return ctx.mod.apexSdkVersion
Jooyung Hanccce2f22020-03-07 03:45:53 +09001544}
1545
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001546func (ctx *moduleContextImpl) bootstrap() bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09001547 return ctx.mod.Bootstrap()
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001548}
1549
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001550func (ctx *moduleContextImpl) nativeCoverage() bool {
1551 return ctx.mod.nativeCoverage()
1552}
1553
Colin Cross56a83212020-09-15 18:30:11 -07001554func (ctx *moduleContextImpl) directlyInAnyApex() bool {
1555 return ctx.mod.DirectlyInAnyApex()
1556}
1557
Colin Cross95b07f22020-12-16 11:06:50 -08001558func (ctx *moduleContextImpl) isPreventInstall() bool {
1559 return ctx.mod.Properties.PreventInstall
1560}
1561
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001562func (ctx *moduleContextImpl) isCfiAssemblySupportEnabled() bool {
1563 return ctx.mod.isCfiAssemblySupportEnabled()
1564}
1565
Colin Cross635c3b02016-05-18 15:37:25 -07001566func newBaseModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001567 return &Module{
1568 hod: hod,
1569 multilib: multilib,
1570 }
1571}
1572
Colin Cross635c3b02016-05-18 15:37:25 -07001573func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001574 module := newBaseModule(hod, multilib)
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001575 module.features = []feature{
1576 &tidyFeature{},
1577 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001578 module.stl = &stl{}
Colin Cross16b23492016-01-06 14:41:07 -08001579 module.sanitize = &sanitize{}
Dan Willemsen581341d2017-02-09 16:16:31 -08001580 module.coverage = &coverage{}
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001581 module.sabi = &sabi{}
Justin Yun8effde42017-06-23 19:24:43 +09001582 module.vndkdep = &vndkdep{}
Stephen Craneba090d12017-05-09 15:44:35 -07001583 module.lto = &lto{}
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001584 module.pgo = &pgo{}
Colin Crossca860ac2016-01-04 14:34:37 -08001585 return module
1586}
1587
Colin Crossce75d2c2016-10-06 16:12:58 -07001588func (c *Module) Prebuilt() *android.Prebuilt {
1589 if p, ok := c.linker.(prebuiltLinkerInterface); ok {
1590 return p.prebuilt()
1591 }
1592 return nil
1593}
1594
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001595func (c *Module) IsPrebuilt() bool {
1596 return c.Prebuilt() != nil
1597}
1598
Colin Crossce75d2c2016-10-06 16:12:58 -07001599func (c *Module) Name() string {
1600 name := c.ModuleBase.Name()
Dan Willemsen01a90592017-04-07 15:21:13 -07001601 if p, ok := c.linker.(interface {
1602 Name(string) string
1603 }); ok {
Colin Crossce75d2c2016-10-06 16:12:58 -07001604 name = p.Name(name)
1605 }
1606 return name
1607}
1608
Alex Light3d673592019-01-18 14:37:31 -08001609func (c *Module) Symlinks() []string {
1610 if p, ok := c.installer.(interface {
1611 symlinkList() []string
1612 }); ok {
1613 return p.symlinkList()
1614 }
1615 return nil
1616}
1617
Roland Levillainf89cd092019-07-29 16:22:59 +01001618func (c *Module) IsTestPerSrcAllTestsVariation() bool {
1619 test, ok := c.linker.(testPerSrc)
1620 return ok && test.isAllTestsVariation()
1621}
1622
Chris Parsons216e10a2020-07-09 17:12:52 -04001623func (c *Module) DataPaths() []android.DataPath {
Liz Kammer1c14a212020-05-12 15:26:55 -07001624 if p, ok := c.installer.(interface {
Chris Parsons216e10a2020-07-09 17:12:52 -04001625 dataPaths() []android.DataPath
Liz Kammer1c14a212020-05-12 15:26:55 -07001626 }); ok {
1627 return p.dataPaths()
1628 }
1629 return nil
1630}
1631
Justin Yun5f7f7e82019-11-18 19:52:14 +09001632func (c *Module) getNameSuffixWithVndkVersion(ctx android.ModuleContext) string {
1633 // Returns the name suffix for product and vendor variants. If the VNDK version is not
1634 // "current", it will append the VNDK version to the name suffix.
1635 var vndkVersion string
1636 var nameSuffix string
Ivan Lozanof9e21722020-12-02 09:00:51 -05001637 if c.InProduct() {
Justin Yund00f5ca2021-02-03 19:43:02 +09001638 if c.ProductSpecific() {
1639 // If the module is product specific with 'product_specific: true',
1640 // do not add a name suffix because it is a base module.
1641 return ""
1642 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001643 vndkVersion = ctx.DeviceConfig().ProductVndkVersion()
1644 nameSuffix = productSuffix
1645 } else {
1646 vndkVersion = ctx.DeviceConfig().VndkVersion()
Ivan Lozanoe6d30982021-02-05 10:57:43 -05001647 nameSuffix = VendorSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001648 }
1649 if vndkVersion == "current" {
1650 vndkVersion = ctx.DeviceConfig().PlatformVndkVersion()
1651 }
Colin Cross127bb8b2020-12-16 16:46:01 -08001652 if c.Properties.VndkVersion != vndkVersion && c.Properties.VndkVersion != "" {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001653 // add version suffix only if the module is using different vndk version than the
1654 // version in product or vendor partition.
1655 nameSuffix += "." + c.Properties.VndkVersion
1656 }
1657 return nameSuffix
1658}
1659
Chris Parsons8d6e4332021-02-22 16:13:50 -05001660func (c *Module) setSubnameProperty(actx android.ModuleContext) {
Inseob Kim64c43952019-08-26 16:52:35 +09001661 c.Properties.SubName = ""
1662
1663 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1664 c.Properties.SubName += nativeBridgeSuffix
1665 }
1666
Colin Cross127bb8b2020-12-16 16:46:01 -08001667 llndk := c.IsLlndk()
Colin Cross627280f2021-04-26 16:53:58 -07001668 if llndk || (c.UseVndk() && c.HasNonSystemVariants()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001669 // .vendor.{version} suffix is added for vendor variant or .product.{version} suffix is
1670 // added for product variant only when we have vendor and product variants with core
1671 // variant. The suffix is not added for vendor-only or product-only module.
1672 c.Properties.SubName += c.getNameSuffixWithVndkVersion(actx)
Colin Cross5271fea2021-04-27 13:06:04 -07001673 } else if c.IsVendorPublicLibrary() {
1674 c.Properties.SubName += vendorPublicLibrarySuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001675 } else if _, ok := c.linker.(*vndkPrebuiltLibraryDecorator); ok {
Inseob Kim64c43952019-08-26 16:52:35 +09001676 // .vendor suffix is added for backward compatibility with VNDK snapshot whose names with
1677 // such suffixes are already hard-coded in prebuilts/vndk/.../Android.bp.
Ivan Lozanoe6d30982021-02-05 10:57:43 -05001678 c.Properties.SubName += VendorSuffix
Yifan Hong1b3348d2020-01-21 15:53:22 -08001679 } else if c.InRamdisk() && !c.OnlyInRamdisk() {
1680 c.Properties.SubName += ramdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001681 } else if c.InVendorRamdisk() && !c.OnlyInVendorRamdisk() {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05001682 c.Properties.SubName += VendorRamdiskSuffix
Ivan Lozano52767be2019-10-18 14:49:46 -07001683 } else if c.InRecovery() && !c.OnlyInRecovery() {
Inseob Kim64c43952019-08-26 16:52:35 +09001684 c.Properties.SubName += recoverySuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001685 } else if c.IsSdkVariant() && (c.Properties.SdkAndPlatformVariantVisibleToMake || c.SplitPerApiLevel()) {
Colin Crossc511bc52020-04-07 16:50:32 +00001686 c.Properties.SubName += sdkSuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001687 if c.SplitPerApiLevel() {
1688 c.Properties.SubName += "." + c.SdkVersion()
1689 }
Inseob Kim64c43952019-08-26 16:52:35 +09001690 }
Chris Parsons8d6e4332021-02-22 16:13:50 -05001691}
1692
1693// Returns true if Bazel was successfully used for the analysis of this module.
1694func (c *Module) maybeGenerateBazelActions(actx android.ModuleContext) bool {
Liz Kammerbdc60992021-02-24 16:55:11 -05001695 bazelModuleLabel := c.GetBazelLabel(actx, c)
Chris Parsons8d6e4332021-02-22 16:13:50 -05001696 bazelActionsUsed := false
Chris Parsonsbab4d7e2021-04-15 17:27:08 -04001697 if c.MixedBuildsEnabled(actx) && c.bazelHandler != nil {
Chris Parsons8d6e4332021-02-22 16:13:50 -05001698 bazelActionsUsed = c.bazelHandler.generateBazelBuildActions(actx, bazelModuleLabel)
1699 }
1700 return bazelActionsUsed
1701}
1702
1703func (c *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
1704 // TODO(cparsons): Any logic in this method occurring prior to querying Bazel should be
1705 // requested from Bazel instead.
1706
1707 // Handle the case of a test module split by `test_per_src` mutator.
1708 //
1709 // The `test_per_src` mutator adds an extra variation named "", depending on all the other
1710 // `test_per_src` variations of the test module. Set `outputFile` to an empty path for this
1711 // module and return early, as this module does not produce an output file per se.
1712 if c.IsTestPerSrcAllTestsVariation() {
1713 c.outputFile = android.OptionalPath{}
1714 return
1715 }
1716
1717 c.setSubnameProperty(actx)
1718 apexInfo := actx.Provider(android.ApexInfoProvider).(android.ApexInfo)
1719 if !apexInfo.IsForPlatform() {
1720 c.hideApexVariantFromMake = true
1721 }
1722
Chris Parsonseefc9e62021-04-02 17:36:47 -04001723 c.makeLinkType = GetMakeLinkType(actx, c)
1724
Colin Crossca860ac2016-01-04 14:34:37 -08001725 ctx := &moduleContext{
Colin Cross635c3b02016-05-18 15:37:25 -07001726 ModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08001727 moduleContextImpl: moduleContextImpl{
1728 mod: c,
1729 },
1730 }
1731 ctx.ctx = ctx
1732
Chris Parsons94a0bba2021-06-04 15:03:47 -04001733 if c.maybeGenerateBazelActions(actx) {
1734 c.maybeInstall(ctx, apexInfo)
1735 return
1736 }
1737
Colin Crossf18e1102017-11-16 14:33:08 -08001738 deps := c.depsToPaths(ctx)
1739 if ctx.Failed() {
1740 return
1741 }
1742
Dan Willemsen8536d6b2018-10-07 20:54:34 -07001743 if c.Properties.Clang != nil && *c.Properties.Clang == false {
1744 ctx.PropertyErrorf("clang", "false (GCC) is no longer supported")
1745 }
1746
Colin Crossca860ac2016-01-04 14:34:37 -08001747 flags := Flags{
1748 Toolchain: c.toolchain(ctx),
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001749 EmitXrefs: ctx.Config().EmitXrefRules(),
Colin Crossca860ac2016-01-04 14:34:37 -08001750 }
Colin Crossca860ac2016-01-04 14:34:37 -08001751 if c.compiler != nil {
Colin Crossf18e1102017-11-16 14:33:08 -08001752 flags = c.compiler.compilerFlags(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001753 }
1754 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001755 flags = c.linker.linkerFlags(ctx, flags)
Colin Crossca860ac2016-01-04 14:34:37 -08001756 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001757 if c.stl != nil {
1758 flags = c.stl.flags(ctx, flags)
1759 }
Colin Cross16b23492016-01-06 14:41:07 -08001760 if c.sanitize != nil {
1761 flags = c.sanitize.flags(ctx, flags)
1762 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001763 if c.coverage != nil {
Pirama Arumuga Nainar82fe59b2019-07-02 14:55:35 -07001764 flags, deps = c.coverage.flags(ctx, flags, deps)
Dan Willemsen581341d2017-02-09 16:16:31 -08001765 }
Stephen Craneba090d12017-05-09 15:44:35 -07001766 if c.lto != nil {
1767 flags = c.lto.flags(ctx, flags)
1768 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001769 if c.pgo != nil {
1770 flags = c.pgo.flags(ctx, flags)
1771 }
Colin Crossca860ac2016-01-04 14:34:37 -08001772 for _, feature := range c.features {
1773 flags = feature.flags(ctx, flags)
1774 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001775 if ctx.Failed() {
1776 return
1777 }
1778
Colin Cross4af21ed2019-11-04 09:37:55 -08001779 flags.Local.CFlags, _ = filterList(flags.Local.CFlags, config.IllegalFlags)
1780 flags.Local.CppFlags, _ = filterList(flags.Local.CppFlags, config.IllegalFlags)
1781 flags.Local.ConlyFlags, _ = filterList(flags.Local.ConlyFlags, config.IllegalFlags)
Colin Cross3f40fa42015-01-30 17:27:36 -08001782
Colin Cross4af21ed2019-11-04 09:37:55 -08001783 flags.Local.CommonFlags = append(flags.Local.CommonFlags, deps.Flags...)
Inseob Kim69378442019-06-03 19:10:47 +09001784
1785 for _, dir := range deps.IncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08001786 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-I"+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09001787 }
1788 for _, dir := range deps.SystemIncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08001789 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-isystem "+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09001790 }
1791
Fabien Sanglardd61f1f42017-01-10 16:21:22 -08001792 c.flags = flags
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -07001793 // We need access to all the flags seen by a source file.
1794 if c.sabi != nil {
1795 flags = c.sabi.flags(ctx, flags)
1796 }
Dan Willemsen98ab3112019-08-27 21:20:40 -07001797
Colin Cross4af21ed2019-11-04 09:37:55 -08001798 flags.AssemblerWithCpp = inList("-xassembler-with-cpp", flags.Local.AsFlags)
Dan Willemsen98ab3112019-08-27 21:20:40 -07001799
Colin Crossca860ac2016-01-04 14:34:37 -08001800 // Optimization to reduce size of build.ninja
1801 // Replace the long list of flags for each file with a module-local variable
Colin Cross4af21ed2019-11-04 09:37:55 -08001802 ctx.Variable(pctx, "cflags", strings.Join(flags.Local.CFlags, " "))
1803 ctx.Variable(pctx, "cppflags", strings.Join(flags.Local.CppFlags, " "))
1804 ctx.Variable(pctx, "asflags", strings.Join(flags.Local.AsFlags, " "))
1805 flags.Local.CFlags = []string{"$cflags"}
1806 flags.Local.CppFlags = []string{"$cppflags"}
1807 flags.Local.AsFlags = []string{"$asflags"}
Colin Crossca860ac2016-01-04 14:34:37 -08001808
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001809 var objs Objects
Colin Crossca860ac2016-01-04 14:34:37 -08001810 if c.compiler != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001811 objs = c.compiler.compile(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001812 if ctx.Failed() {
1813 return
1814 }
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001815 c.kytheFiles = objs.kytheFiles
Colin Cross3f40fa42015-01-30 17:27:36 -08001816 }
1817
Colin Crossca860ac2016-01-04 14:34:37 -08001818 if c.linker != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001819 outputFile := c.linker.link(ctx, flags, deps, objs)
Colin Crossca860ac2016-01-04 14:34:37 -08001820 if ctx.Failed() {
1821 return
1822 }
Colin Cross635c3b02016-05-18 15:37:25 -07001823 c.outputFile = android.OptionalPathForPath(outputFile)
Jiyong Parkb0788572018-12-20 22:10:17 +09001824
Chris Parsons94a0bba2021-06-04 15:03:47 -04001825 c.maybeUnhideFromMake()
Inseob Kimeda2e9c2020-03-03 22:06:32 +09001826
Jose Galmes6f843bc2020-12-11 13:36:29 -08001827 // glob exported headers for snapshot, if BOARD_VNDK_VERSION is current or
1828 // RECOVERY_SNAPSHOT_VERSION is current.
1829 if i, ok := c.linker.(snapshotLibraryInterface); ok {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001830 if ShouldCollectHeadersForSnapshot(ctx, c, apexInfo) {
Inseob Kimeda2e9c2020-03-03 22:06:32 +09001831 i.collectHeadersForSnapshot(ctx)
1832 }
1833 }
Colin Crossce75d2c2016-10-06 16:12:58 -07001834 }
Colin Cross5049f022015-03-18 13:28:46 -07001835
Chris Parsons94a0bba2021-06-04 15:03:47 -04001836 c.maybeInstall(ctx, apexInfo)
1837}
1838
1839func (c *Module) maybeUnhideFromMake() {
1840 // If a lib is directly included in any of the APEXes or is not available to the
1841 // platform (which is often the case when the stub is provided as a prebuilt),
1842 // unhide the stubs variant having the latest version gets visible to make. In
1843 // addition, the non-stubs variant is renamed to <libname>.bootstrap. This is to
1844 // force anything in the make world to link against the stubs library. (unless it
1845 // is explicitly referenced via .bootstrap suffix or the module is marked with
1846 // 'bootstrap: true').
1847 if c.HasStubsVariants() && c.NotInPlatform() && !c.InRamdisk() &&
1848 !c.InRecovery() && !c.UseVndk() && !c.static() && !c.isCoverageVariant() &&
1849 c.IsStubs() && !c.InVendorRamdisk() {
1850 c.Properties.HideFromMake = false // unhide
1851 // Note: this is still non-installable
1852 }
1853}
1854
1855func (c *Module) maybeInstall(ctx ModuleContext, apexInfo android.ApexInfo) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08001856 if !proptools.BoolDefault(c.Properties.Installable, true) {
1857 // If the module has been specifically configure to not be installed then
1858 // hide from make as otherwise it will break when running inside make
1859 // as the output path to install will not be specified. Not all uninstallable
1860 // modules can be hidden from make as some are needed for resolving make side
1861 // dependencies.
1862 c.HideFromMake()
Ivan Lozanod7586b62021-04-01 09:49:36 -04001863 } else if !installable(c, apexInfo) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08001864 c.SkipInstall()
1865 }
1866
1867 // Still call c.installer.install though, the installs will be stored as PackageSpecs
1868 // to allow using the outputs in a genrule.
1869 if c.installer != nil && c.outputFile.Valid() {
Colin Crossce75d2c2016-10-06 16:12:58 -07001870 c.installer.install(ctx, c.outputFile.Path())
1871 if ctx.Failed() {
1872 return
Colin Crossca860ac2016-01-04 14:34:37 -08001873 }
Dan Albertc403f7c2015-03-18 14:01:18 -07001874 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001875}
1876
Colin Cross0ea8ba82019-06-06 14:33:29 -07001877func (c *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001878 if c.cachedToolchain == nil {
Liz Kammer356f7d42021-01-26 09:18:53 -05001879 c.cachedToolchain = config.FindToolchainWithContext(ctx)
Colin Cross3f40fa42015-01-30 17:27:36 -08001880 }
Colin Crossca860ac2016-01-04 14:34:37 -08001881 return c.cachedToolchain
Colin Cross3f40fa42015-01-30 17:27:36 -08001882}
1883
Colin Crossca860ac2016-01-04 14:34:37 -08001884func (c *Module) begin(ctx BaseModuleContext) {
1885 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001886 c.compiler.compilerInit(ctx)
Colin Cross21b9a242015-03-24 14:15:58 -07001887 }
Colin Crossca860ac2016-01-04 14:34:37 -08001888 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001889 c.linker.linkerInit(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08001890 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001891 if c.stl != nil {
1892 c.stl.begin(ctx)
1893 }
Colin Cross16b23492016-01-06 14:41:07 -08001894 if c.sanitize != nil {
1895 c.sanitize.begin(ctx)
1896 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001897 if c.coverage != nil {
1898 c.coverage.begin(ctx)
1899 }
Stephen Craneba090d12017-05-09 15:44:35 -07001900 if c.lto != nil {
1901 c.lto.begin(ctx)
1902 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001903 if c.pgo != nil {
1904 c.pgo.begin(ctx)
1905 }
Dan Albert92fe7402020-07-15 13:33:30 -07001906 if ctx.useSdk() && c.IsSdkVariant() {
Dan Albert1a246272020-07-06 14:49:35 -07001907 version, err := nativeApiLevelFromUser(ctx, ctx.sdkVersion())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07001908 if err != nil {
1909 ctx.PropertyErrorf("sdk_version", err.Error())
Dan Albert1a246272020-07-06 14:49:35 -07001910 c.Properties.Sdk_version = nil
1911 } else {
1912 c.Properties.Sdk_version = StringPtr(version.String())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07001913 }
Dan Albert7fa7b2e2016-08-05 16:37:52 -07001914 }
Colin Crossca860ac2016-01-04 14:34:37 -08001915}
1916
Colin Cross37047f12016-12-13 17:06:13 -08001917func (c *Module) deps(ctx DepsContext) Deps {
Colin Crossc99deeb2016-04-11 15:06:20 -07001918 deps := Deps{}
1919
1920 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001921 deps = c.compiler.compilerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07001922 }
1923 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001924 deps = c.linker.linkerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07001925 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001926 if c.stl != nil {
1927 deps = c.stl.deps(ctx, deps)
1928 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00001929 if c.coverage != nil {
1930 deps = c.coverage.deps(ctx, deps)
1931 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001932
Colin Crossb6715442017-10-24 11:13:31 -07001933 deps.WholeStaticLibs = android.LastUniqueStrings(deps.WholeStaticLibs)
1934 deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
1935 deps.LateStaticLibs = android.LastUniqueStrings(deps.LateStaticLibs)
1936 deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
1937 deps.LateSharedLibs = android.LastUniqueStrings(deps.LateSharedLibs)
1938 deps.HeaderLibs = android.LastUniqueStrings(deps.HeaderLibs)
Logan Chien43d34c32017-12-20 01:17:32 +08001939 deps.RuntimeLibs = android.LastUniqueStrings(deps.RuntimeLibs)
Colin Crossc99deeb2016-04-11 15:06:20 -07001940
Liz Kammer356f7d42021-01-26 09:18:53 -05001941 // In Bazel conversion mode, we dependency and build validations will occur in Bazel, so there is
1942 // no need to do so in Soong.
1943 if ctx.BazelConversionMode() {
1944 return deps
1945 }
1946
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001947 for _, lib := range deps.ReexportSharedLibHeaders {
1948 if !inList(lib, deps.SharedLibs) {
1949 ctx.PropertyErrorf("export_shared_lib_headers", "Shared library not in shared_libs: '%s'", lib)
1950 }
1951 }
1952
1953 for _, lib := range deps.ReexportStaticLibHeaders {
Steven Morelandba407c82021-04-01 22:17:50 +00001954 if !inList(lib, deps.StaticLibs) && !inList(lib, deps.WholeStaticLibs) {
1955 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 -07001956 }
1957 }
1958
Colin Cross5950f382016-12-13 12:50:57 -08001959 for _, lib := range deps.ReexportHeaderLibHeaders {
1960 if !inList(lib, deps.HeaderLibs) {
1961 ctx.PropertyErrorf("export_header_lib_headers", "Header library not in header_libs: '%s'", lib)
1962 }
1963 }
1964
Dan Willemsenb3454ab2016-09-28 17:34:58 -07001965 for _, gen := range deps.ReexportGeneratedHeaders {
1966 if !inList(gen, deps.GeneratedHeaders) {
1967 ctx.PropertyErrorf("export_generated_headers", "Generated header module not in generated_headers: '%s'", gen)
1968 }
1969 }
1970
Colin Crossc99deeb2016-04-11 15:06:20 -07001971 return deps
1972}
1973
Dan Albert7e9d2952016-08-04 13:02:36 -07001974func (c *Module) beginMutator(actx android.BottomUpMutatorContext) {
Colin Crossca860ac2016-01-04 14:34:37 -08001975 ctx := &baseModuleContext{
Colin Cross0ea8ba82019-06-06 14:33:29 -07001976 BaseModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08001977 moduleContextImpl: moduleContextImpl{
1978 mod: c,
1979 },
1980 }
1981 ctx.ctx = ctx
1982
Colin Crossca860ac2016-01-04 14:34:37 -08001983 c.begin(ctx)
Dan Albert7e9d2952016-08-04 13:02:36 -07001984}
1985
Jiyong Park7ed9de32018-10-15 22:25:07 +09001986// Split name#version into name and version
Jiyong Park73c54ee2019-10-22 20:31:18 +09001987func StubsLibNameAndVersion(name string) (string, string) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09001988 if sharp := strings.LastIndex(name, "#"); sharp != -1 && sharp != len(name)-1 {
1989 version := name[sharp+1:]
1990 libname := name[:sharp]
1991 return libname, version
1992 }
1993 return name, ""
1994}
1995
Dan Albert92fe7402020-07-15 13:33:30 -07001996func GetCrtVariations(ctx android.BottomUpMutatorContext,
1997 m LinkableInterface) []blueprint.Variation {
1998 if ctx.Os() != android.Android {
1999 return nil
2000 }
2001 if m.UseSdk() {
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09002002 // Choose the CRT that best satisfies the min_sdk_version requirement of this module
2003 minSdkVersion := m.MinSdkVersion()
2004 if minSdkVersion == "" || minSdkVersion == "apex_inherit" {
2005 minSdkVersion = m.SdkVersion()
2006 }
Jooyung Han94a76ee2021-06-08 09:49:48 +09002007 apiLevel, err := android.ApiLevelFromUser(ctx, minSdkVersion)
2008 if err != nil {
2009 ctx.PropertyErrorf("min_sdk_version", err.Error())
2010 }
Dan Albert92fe7402020-07-15 13:33:30 -07002011 return []blueprint.Variation{
2012 {Mutator: "sdk", Variation: "sdk"},
Jooyung Han94a76ee2021-06-08 09:49:48 +09002013 {Mutator: "version", Variation: apiLevel.String()},
Dan Albert92fe7402020-07-15 13:33:30 -07002014 }
2015 }
2016 return []blueprint.Variation{
2017 {Mutator: "sdk", Variation: ""},
2018 }
2019}
2020
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002021func AddSharedLibDependenciesWithVersions(ctx android.BottomUpMutatorContext, mod LinkableInterface,
2022 variations []blueprint.Variation, depTag blueprint.DependencyTag, name, version string, far bool) {
Colin Crosse7257d22020-09-24 09:56:18 -07002023
2024 variations = append([]blueprint.Variation(nil), variations...)
2025
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002026 if version != "" && CanBeOrLinkAgainstVersionVariants(mod) {
Colin Crosse7257d22020-09-24 09:56:18 -07002027 // Version is explicitly specified. i.e. libFoo#30
2028 variations = append(variations, blueprint.Variation{Mutator: "version", Variation: version})
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002029 if tag, ok := depTag.(libraryDependencyTag); ok {
2030 tag.explicitlyVersioned = true
2031 } else {
2032 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
2033 }
Colin Crosse7257d22020-09-24 09:56:18 -07002034 }
Colin Crosse7257d22020-09-24 09:56:18 -07002035
Colin Cross0de8a1e2020-09-18 14:15:30 -07002036 if far {
2037 ctx.AddFarVariationDependencies(variations, depTag, name)
2038 } else {
2039 ctx.AddVariationDependencies(variations, depTag, name)
Colin Crosse7257d22020-09-24 09:56:18 -07002040 }
2041}
2042
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002043func GetSnapshot(c LinkableInterface, snapshotInfo **SnapshotInfo, actx android.BottomUpMutatorContext) SnapshotInfo {
2044 // Only modules with BOARD_VNDK_VERSION uses snapshot. Others use the zero value of
2045 // SnapshotInfo, which provides no mappings.
2046 if *snapshotInfo == nil {
2047 // Only retrieve the snapshot on demand in order to avoid circular dependencies
2048 // between the modules in the snapshot and the snapshot itself.
2049 var snapshotModule []blueprint.Module
2050 if c.InVendor() && c.VndkVersion() == actx.DeviceConfig().VndkVersion() {
2051 snapshotModule = actx.AddVariationDependencies(nil, nil, "vendor_snapshot")
2052 } else if recoverySnapshotVersion := actx.DeviceConfig().RecoverySnapshotVersion(); recoverySnapshotVersion != "current" && recoverySnapshotVersion != "" && c.InRecovery() {
2053 snapshotModule = actx.AddVariationDependencies(nil, nil, "recovery_snapshot")
2054 }
2055 if len(snapshotModule) > 0 {
2056 snapshot := actx.OtherModuleProvider(snapshotModule[0], SnapshotInfoProvider).(SnapshotInfo)
2057 *snapshotInfo = &snapshot
2058 // republish the snapshot for use in later mutators on this module
2059 actx.SetProvider(SnapshotInfoProvider, snapshot)
2060 } else {
2061 *snapshotInfo = &SnapshotInfo{}
2062 }
2063 }
2064
2065 return **snapshotInfo
2066}
2067
2068func RewriteSnapshotLib(lib string, snapshotMap map[string]string) string {
2069 if snapshot, ok := snapshotMap[lib]; ok {
2070 return snapshot
2071 }
2072
2073 return lib
2074}
2075
2076// RewriteLibs takes a list of names of shared libraries and scans it for three types
2077// of names:
2078//
2079// 1. Name of an NDK library that refers to a prebuilt module.
2080// For each of these, it adds the name of the prebuilt module (which will be in
2081// prebuilts/ndk) to the list of nonvariant libs.
2082// 2. Name of an NDK library that refers to an ndk_library module.
2083// For each of these, it adds the name of the ndk_library module to the list of
2084// variant libs.
2085// 3. Anything else (so anything that isn't an NDK library).
2086// It adds these to the nonvariantLibs list.
2087//
2088// The caller can then know to add the variantLibs dependencies differently from the
2089// nonvariantLibs
2090func RewriteLibs(c LinkableInterface, snapshotInfo **SnapshotInfo, actx android.BottomUpMutatorContext, config android.Config, list []string) (nonvariantLibs []string, variantLibs []string) {
2091 variantLibs = []string{}
2092
2093 nonvariantLibs = []string{}
2094 for _, entry := range list {
2095 // strip #version suffix out
2096 name, _ := StubsLibNameAndVersion(entry)
2097 if c.InRecovery() {
2098 nonvariantLibs = append(nonvariantLibs, RewriteSnapshotLib(entry, GetSnapshot(c, snapshotInfo, actx).SharedLibs))
2099 } else if c.UseSdk() && inList(name, *getNDKKnownLibs(config)) {
2100 variantLibs = append(variantLibs, name+ndkLibrarySuffix)
2101 } else if c.UseVndk() {
2102 nonvariantLibs = append(nonvariantLibs, RewriteSnapshotLib(entry, GetSnapshot(c, snapshotInfo, actx).SharedLibs))
2103 } else {
2104 // put name#version back
2105 nonvariantLibs = append(nonvariantLibs, entry)
2106 }
2107 }
2108 return nonvariantLibs, variantLibs
2109}
2110
Colin Cross1e676be2016-10-12 14:38:15 -07002111func (c *Module) DepsMutator(actx android.BottomUpMutatorContext) {
Inseob Kimeec88e12020-01-22 11:11:29 +09002112 if !c.Enabled() {
2113 return
2114 }
2115
Colin Cross37047f12016-12-13 17:06:13 -08002116 ctx := &depsContext{
2117 BottomUpMutatorContext: actx,
Dan Albert7e9d2952016-08-04 13:02:36 -07002118 moduleContextImpl: moduleContextImpl{
2119 mod: c,
2120 },
2121 }
2122 ctx.ctx = ctx
Colin Crossca860ac2016-01-04 14:34:37 -08002123
Colin Crossc99deeb2016-04-11 15:06:20 -07002124 deps := c.deps(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08002125
Yo Chiang219968c2020-09-22 18:45:04 +08002126 c.Properties.AndroidMkSystemSharedLibs = deps.SystemSharedLibs
2127
Colin Crosse0edaf92021-01-11 17:31:17 -08002128 var snapshotInfo *SnapshotInfo
Colin Crosse0edaf92021-01-11 17:31:17 -08002129
Dan Albert914449f2016-06-17 16:45:24 -07002130 variantNdkLibs := []string{}
2131 variantLateNdkLibs := []string{}
Dan Willemsenb916b802017-03-19 13:44:32 -07002132 if ctx.Os() == android.Android {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002133 deps.SharedLibs, variantNdkLibs = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.SharedLibs)
2134 deps.LateSharedLibs, variantLateNdkLibs = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.LateSharedLibs)
2135 deps.ReexportSharedLibHeaders, _ = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.ReexportSharedLibHeaders)
Colin Crosse0edaf92021-01-11 17:31:17 -08002136
2137 for idx, lib := range deps.RuntimeLibs {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002138 deps.RuntimeLibs[idx] = RewriteSnapshotLib(lib, GetSnapshot(c, &snapshotInfo, actx).SharedLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002139 }
Dan Willemsen72d39932016-07-08 23:23:48 -07002140 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002141
Colin Cross32ec36c2016-12-15 07:39:51 -08002142 for _, lib := range deps.HeaderLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002143 depTag := libraryDependencyTag{Kind: headerLibraryDependency}
Colin Cross32ec36c2016-12-15 07:39:51 -08002144 if inList(lib, deps.ReexportHeaderLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002145 depTag.reexportFlags = true
Colin Cross32ec36c2016-12-15 07:39:51 -08002146 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002147
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002148 lib = RewriteSnapshotLib(lib, GetSnapshot(c, &snapshotInfo, actx).HeaderLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002149
Jiyong Park1ad8e162020-12-01 23:40:09 +09002150 if c.IsStubs() {
Colin Cross7228ecd2019-11-18 16:00:16 -08002151 actx.AddFarVariationDependencies(append(ctx.Target().Variations(), c.ImageVariation()),
Colin Cross0f7d2ef2019-10-16 11:03:10 -07002152 depTag, lib)
Jiyong Park7e636d02019-01-28 16:16:54 +09002153 } else {
2154 actx.AddVariationDependencies(nil, depTag, lib)
2155 }
2156 }
2157
Dan Albertf1d14c72020-07-30 14:32:55 -07002158 if c.isNDKStubLibrary() {
2159 // NDK stubs depend on their implementation because the ABI dumps are
2160 // generated from the implementation library.
2161 actx.AddFarVariationDependencies(append(ctx.Target().Variations(),
2162 c.ImageVariation(),
2163 blueprint.Variation{Mutator: "link", Variation: "shared"},
2164 ), stubImplementation, c.BaseModuleName())
2165 }
2166
Inseob Kim07def122020-11-23 14:43:02 +09002167 // sysprop_library has to support both C++ and Java. So sysprop_library internally creates one
2168 // C++ implementation library and one Java implementation library. When a module links against
2169 // sysprop_library, the C++ implementation library has to be linked. syspropImplLibraries is a
2170 // map from sysprop_library to implementation library; it will be used in whole_static_libs,
2171 // static_libs, and shared_libs.
Inseob Kimc0907f12019-02-08 21:00:45 +09002172 syspropImplLibraries := syspropImplLibraries(actx.Config())
2173
Jiyong Park5d1598f2019-02-25 22:14:17 +09002174 for _, lib := range deps.WholeStaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002175 depTag := libraryDependencyTag{Kind: staticLibraryDependency, wholeStatic: true, reexportFlags: true}
Jiyong Park5d1598f2019-02-25 22:14:17 +09002176 if impl, ok := syspropImplLibraries[lib]; ok {
2177 lib = impl
2178 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002179
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002180 lib = RewriteSnapshotLib(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002181
Jiyong Park5d1598f2019-02-25 22:14:17 +09002182 actx.AddVariationDependencies([]blueprint.Variation{
2183 {Mutator: "link", Variation: "static"},
2184 }, depTag, lib)
2185 }
2186
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002187 for _, lib := range deps.StaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002188 depTag := libraryDependencyTag{Kind: staticLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002189 if inList(lib, deps.ReexportStaticLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002190 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002191 }
Jiyong Parke3867542020-12-03 17:28:25 +09002192 if inList(lib, deps.ExcludeLibsForApex) {
2193 depTag.excludeInApex = true
2194 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002195
2196 if impl, ok := syspropImplLibraries[lib]; ok {
2197 lib = impl
2198 }
2199
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002200 lib = RewriteSnapshotLib(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002201
Dan Willemsen59339a22018-07-22 21:18:45 -07002202 actx.AddVariationDependencies([]blueprint.Variation{
2203 {Mutator: "link", Variation: "static"},
2204 }, depTag, lib)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002205 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002206
Jooyung Han75568392020-03-20 04:29:24 +09002207 // staticUnwinderDep is treated as staticDep for Q apexes
2208 // so that native libraries/binaries are linked with static unwinder
2209 // because Q libc doesn't have unwinder APIs
2210 if deps.StaticUnwinderIfLegacy {
Colin Cross6e511a92020-07-27 21:26:48 -07002211 depTag := libraryDependencyTag{Kind: staticLibraryDependency, staticUnwinder: true}
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002212 actx.AddVariationDependencies([]blueprint.Variation{
2213 {Mutator: "link", Variation: "static"},
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002214 }, depTag, RewriteSnapshotLib(staticUnwinder(actx), GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002215 }
2216
Jiyong Park7ed9de32018-10-15 22:25:07 +09002217 // shared lib names without the #version suffix
2218 var sharedLibNames []string
2219
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002220 for _, lib := range deps.SharedLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002221 depTag := libraryDependencyTag{Kind: sharedLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002222 if inList(lib, deps.ReexportSharedLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002223 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002224 }
Jiyong Parke3867542020-12-03 17:28:25 +09002225 if inList(lib, deps.ExcludeLibsForApex) {
2226 depTag.excludeInApex = true
2227 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002228
2229 if impl, ok := syspropImplLibraries[lib]; ok {
2230 lib = impl
2231 }
2232
Jiyong Park73c54ee2019-10-22 20:31:18 +09002233 name, version := StubsLibNameAndVersion(lib)
Inseob Kimc0907f12019-02-08 21:00:45 +09002234 sharedLibNames = append(sharedLibNames, name)
2235
Colin Crosse7257d22020-09-24 09:56:18 -07002236 variations := []blueprint.Variation{
2237 {Mutator: "link", Variation: "shared"},
2238 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002239 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, name, version, false)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002240 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002241
Colin Crossfe9acfe2021-06-14 16:13:03 -07002242 for _, lib := range deps.LateStaticLibs {
2243 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency}
2244 actx.AddVariationDependencies([]blueprint.Variation{
2245 {Mutator: "link", Variation: "static"},
2246 }, depTag, RewriteSnapshotLib(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
2247 }
2248
Jiyong Park7ed9de32018-10-15 22:25:07 +09002249 for _, lib := range deps.LateSharedLibs {
Jiyong Park25fc6a92018-11-18 18:02:45 +09002250 if inList(lib, sharedLibNames) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002251 // This is to handle the case that some of the late shared libs (libc, libdl, libm, ...)
2252 // are added also to SharedLibs with version (e.g., libc#10). If not skipped, we will be
2253 // linking against both the stubs lib and the non-stubs lib at the same time.
2254 continue
2255 }
Colin Cross6e511a92020-07-27 21:26:48 -07002256 depTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency}
Colin Crosse7257d22020-09-24 09:56:18 -07002257 variations := []blueprint.Variation{
2258 {Mutator: "link", Variation: "shared"},
2259 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002260 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, lib, "", false)
Jiyong Park7ed9de32018-10-15 22:25:07 +09002261 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002262
Dan Willemsen59339a22018-07-22 21:18:45 -07002263 actx.AddVariationDependencies([]blueprint.Variation{
2264 {Mutator: "link", Variation: "shared"},
Chris Parsons79d66a52020-06-05 17:26:16 -04002265 }, dataLibDepTag, deps.DataLibs...)
2266
2267 actx.AddVariationDependencies([]blueprint.Variation{
2268 {Mutator: "link", Variation: "shared"},
Dan Willemsen59339a22018-07-22 21:18:45 -07002269 }, runtimeDepTag, deps.RuntimeLibs...)
Logan Chien43d34c32017-12-20 01:17:32 +08002270
Colin Cross68861832016-07-08 10:41:41 -07002271 actx.AddDependency(c, genSourceDepTag, deps.GeneratedSources...)
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002272
2273 for _, gen := range deps.GeneratedHeaders {
2274 depTag := genHeaderDepTag
2275 if inList(gen, deps.ReexportGeneratedHeaders) {
2276 depTag = genHeaderExportDepTag
2277 }
2278 actx.AddDependency(c, depTag, gen)
2279 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002280
Dan Albert92fe7402020-07-15 13:33:30 -07002281 crtVariations := GetCrtVariations(ctx, c)
Colin Crossbbc941b2020-09-30 12:27:01 -07002282 actx.AddVariationDependencies(crtVariations, objDepTag, deps.ObjFiles...)
Colin Crossc465efd2021-06-11 18:00:04 -07002283 for _, crt := range deps.CrtBegin {
Dan Albert92fe7402020-07-15 13:33:30 -07002284 actx.AddVariationDependencies(crtVariations, CrtBeginDepTag,
Colin Crossc465efd2021-06-11 18:00:04 -07002285 RewriteSnapshotLib(crt, GetSnapshot(c, &snapshotInfo, actx).Objects))
Colin Crossca860ac2016-01-04 14:34:37 -08002286 }
Colin Crossc465efd2021-06-11 18:00:04 -07002287 for _, crt := range deps.CrtEnd {
Dan Albert92fe7402020-07-15 13:33:30 -07002288 actx.AddVariationDependencies(crtVariations, CrtEndDepTag,
Colin Crossc465efd2021-06-11 18:00:04 -07002289 RewriteSnapshotLib(crt, GetSnapshot(c, &snapshotInfo, actx).Objects))
Colin Cross21b9a242015-03-24 14:15:58 -07002290 }
Dan Willemsena0790e32018-10-12 00:24:23 -07002291 if deps.DynamicLinker != "" {
2292 actx.AddDependency(c, dynamicLinkerDepTag, deps.DynamicLinker)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002293 }
Dan Albert914449f2016-06-17 16:45:24 -07002294
2295 version := ctx.sdkVersion()
Colin Cross6e511a92020-07-27 21:26:48 -07002296
2297 ndkStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002298 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002299 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002300 {Mutator: "link", Variation: "shared"},
2301 }, ndkStubDepTag, variantNdkLibs...)
Colin Cross6e511a92020-07-27 21:26:48 -07002302
2303 ndkLateStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002304 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002305 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002306 {Mutator: "link", Variation: "shared"},
2307 }, ndkLateStubDepTag, variantLateNdkLibs...)
Logan Chienf3511742017-10-31 18:04:35 +08002308
2309 if vndkdep := c.vndkdep; vndkdep != nil {
2310 if vndkdep.isVndkExt() {
Logan Chienf3511742017-10-31 18:04:35 +08002311 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross7228ecd2019-11-18 16:00:16 -08002312 c.ImageVariation(),
Dan Willemsen59339a22018-07-22 21:18:45 -07002313 {Mutator: "link", Variation: "shared"},
2314 }, vndkExtDepTag, vndkdep.getVndkExtendsModuleName())
Logan Chienf3511742017-10-31 18:04:35 +08002315 }
2316 }
Colin Cross6362e272015-10-29 15:25:03 -07002317}
Colin Cross21b9a242015-03-24 14:15:58 -07002318
Colin Crosse40b4ea2018-10-02 22:25:58 -07002319func BeginMutator(ctx android.BottomUpMutatorContext) {
Dan Albert7e9d2952016-08-04 13:02:36 -07002320 if c, ok := ctx.Module().(*Module); ok && c.Enabled() {
2321 c.beginMutator(ctx)
2322 }
2323}
2324
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002325// Whether a module can link to another module, taking into
2326// account NDK linking.
Jooyung Han479ca172020-10-19 18:51:07 +09002327func checkLinkType(ctx android.BaseModuleContext, from LinkableInterface, to LinkableInterface,
Colin Cross6e511a92020-07-27 21:26:48 -07002328 tag blueprint.DependencyTag) {
2329
2330 switch t := tag.(type) {
2331 case dependencyTag:
2332 if t != vndkExtDepTag {
2333 return
2334 }
2335 case libraryDependencyTag:
2336 default:
2337 return
2338 }
2339
Ivan Lozanof9e21722020-12-02 09:00:51 -05002340 if from.Target().Os != android.Android {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002341 // Host code is not restricted
2342 return
2343 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002344
2345 // VNDK is cc.Module supported only for now.
2346 if ccFrom, ok := from.(*Module); ok && from.UseVndk() {
Justin Yun63e9ec72020-10-29 16:49:43 +09002347 // Though allowed dependency is limited by the image mutator,
2348 // each vendor and product module needs to check link-type
2349 // for VNDK.
Ivan Lozano52767be2019-10-18 14:49:46 -07002350 if ccTo, ok := to.(*Module); ok {
2351 if ccFrom.vndkdep != nil {
2352 ccFrom.vndkdep.vndkCheckLinkType(ctx, ccTo, tag)
2353 }
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002354 } else if _, ok := to.(LinkableInterface); !ok {
Ivan Lozano52767be2019-10-18 14:49:46 -07002355 ctx.ModuleErrorf("Attempting to link VNDK cc.Module with unsupported module type")
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002356 }
2357 return
2358 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002359 if from.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002360 // Platform code can link to anything
2361 return
2362 }
Yifan Hong1b3348d2020-01-21 15:53:22 -08002363 if from.InRamdisk() {
2364 // Ramdisk code is not NDK
2365 return
2366 }
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002367 if from.InVendorRamdisk() {
2368 // Vendor ramdisk code is not NDK
2369 return
2370 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002371 if from.InRecovery() {
Jiyong Parkf9332f12018-02-01 00:54:12 +09002372 // Recovery code is not NDK
2373 return
2374 }
Colin Cross31076b32020-10-23 17:22:06 -07002375 if c, ok := to.(*Module); ok {
2376 if c.ToolchainLibrary() {
2377 // These are always allowed
2378 return
2379 }
2380 if c.NdkPrebuiltStl() {
2381 // These are allowed, but they don't set sdk_version
2382 return
2383 }
2384 if c.StubDecorator() {
2385 // These aren't real libraries, but are the stub shared libraries that are included in
2386 // the NDK.
2387 return
2388 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002389 }
Logan Chien834b9a62019-01-14 15:39:03 +08002390
Ivan Lozano52767be2019-10-18 14:49:46 -07002391 if strings.HasPrefix(ctx.ModuleName(), "libclang_rt.") && to.Module().Name() == "libc++" {
Logan Chien834b9a62019-01-14 15:39:03 +08002392 // Bug: http://b/121358700 - Allow libclang_rt.* shared libraries (with sdk_version)
2393 // to link to libc++ (non-NDK and without sdk_version).
2394 return
2395 }
2396
Ivan Lozano52767be2019-10-18 14:49:46 -07002397 if to.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002398 // NDK code linking to platform code is never okay.
2399 ctx.ModuleErrorf("depends on non-NDK-built library %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002400 ctx.OtherModuleName(to.Module()))
Dan Willemsen155d17c2019-02-06 18:30:02 -08002401 return
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002402 }
2403
2404 // At this point we know we have two NDK libraries, but we need to
2405 // check that we're not linking against anything built against a higher
2406 // API level, as it is only valid to link against older or equivalent
2407 // APIs.
2408
Inseob Kim01a28722018-04-11 09:48:45 +09002409 // Current can link against anything.
Ivan Lozano52767be2019-10-18 14:49:46 -07002410 if from.SdkVersion() != "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002411 // Otherwise we need to check.
Ivan Lozano52767be2019-10-18 14:49:46 -07002412 if to.SdkVersion() == "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002413 // Current can't be linked against by anything else.
2414 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002415 ctx.OtherModuleName(to.Module()), "current")
Inseob Kim01a28722018-04-11 09:48:45 +09002416 } else {
Ivan Lozano52767be2019-10-18 14:49:46 -07002417 fromApi, err := strconv.Atoi(from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002418 if err != nil {
2419 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002420 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002421 from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002422 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002423 toApi, err := strconv.Atoi(to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002424 if err != nil {
2425 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002426 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002427 to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002428 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002429
Inseob Kim01a28722018-04-11 09:48:45 +09002430 if toApi > fromApi {
2431 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002432 ctx.OtherModuleName(to.Module()), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002433 }
2434 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002435 }
Dan Albert202fe492017-12-15 13:56:59 -08002436
2437 // Also check that the two STL choices are compatible.
Ivan Lozano52767be2019-10-18 14:49:46 -07002438 fromStl := from.SelectedStl()
2439 toStl := to.SelectedStl()
Dan Albert202fe492017-12-15 13:56:59 -08002440 if fromStl == "" || toStl == "" {
2441 // Libraries that don't use the STL are unrestricted.
Inseob Kimda2171a2018-04-11 15:41:38 +09002442 } else if fromStl == "ndk_system" || toStl == "ndk_system" {
Dan Albert202fe492017-12-15 13:56:59 -08002443 // We can be permissive with the system "STL" since it is only the C++
2444 // ABI layer, but in the future we should make sure that everyone is
2445 // using either libc++ or nothing.
Colin Crossb60190a2018-09-04 16:28:17 -07002446 } else if getNdkStlFamily(from) != getNdkStlFamily(to) {
Dan Albert202fe492017-12-15 13:56:59 -08002447 ctx.ModuleErrorf("uses %q and depends on %q which uses incompatible %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002448 from.SelectedStl(), ctx.OtherModuleName(to.Module()),
2449 to.SelectedStl())
Dan Albert202fe492017-12-15 13:56:59 -08002450 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002451}
2452
Jooyung Han479ca172020-10-19 18:51:07 +09002453func checkLinkTypeMutator(ctx android.BottomUpMutatorContext) {
2454 if c, ok := ctx.Module().(*Module); ok {
2455 ctx.VisitDirectDeps(func(dep android.Module) {
2456 depTag := ctx.OtherModuleDependencyTag(dep)
2457 ccDep, ok := dep.(LinkableInterface)
2458 if ok {
2459 checkLinkType(ctx, c, ccDep, depTag)
2460 }
2461 })
2462 }
2463}
2464
Jiyong Park5fb8c102018-04-09 12:03:06 +09002465// Tests whether the dependent library is okay to be double loaded inside a single process.
Jooyung Hana70f0672019-01-18 15:20:43 +09002466// If a library has a vendor variant and is a (transitive) dependency of an LLNDK library,
2467// it is subject to be double loaded. Such lib should be explicitly marked as double_loadable: true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002468// or as vndk-sp (vndk: { enabled: true, support_system_process: true}).
Jooyung Hana70f0672019-01-18 15:20:43 +09002469func checkDoubleLoadableLibraries(ctx android.TopDownMutatorContext) {
2470 check := func(child, parent android.Module) bool {
2471 to, ok := child.(*Module)
2472 if !ok {
Jooyung Han479ca172020-10-19 18:51:07 +09002473 return false
Jooyung Hana70f0672019-01-18 15:20:43 +09002474 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002475
Jooyung Hana70f0672019-01-18 15:20:43 +09002476 if lib, ok := to.linker.(*libraryDecorator); !ok || !lib.shared() {
2477 return false
Jiyong Park5fb8c102018-04-09 12:03:06 +09002478 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002479
Jiyong Park0474e1f2021-01-14 14:26:06 +09002480 // These dependencies are not excercised at runtime. Tracking these will give us
2481 // false negative, so skip.
Jiyong Park1ad8e162020-12-01 23:40:09 +09002482 depTag := ctx.OtherModuleDependencyTag(child)
2483 if IsHeaderDepTag(depTag) {
2484 return false
2485 }
Jiyong Park0474e1f2021-01-14 14:26:06 +09002486 if depTag == staticVariantTag {
2487 return false
2488 }
2489 if depTag == stubImplDepTag {
2490 return false
2491 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002492
Justin Yun63e9ec72020-10-29 16:49:43 +09002493 // Even if target lib has no vendor variant, keep checking dependency
2494 // graph in case it depends on vendor_available or product_available
2495 // but not double_loadable transtively.
2496 if !to.HasNonSystemVariants() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002497 return true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002498 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002499
Jiyong Park0474e1f2021-01-14 14:26:06 +09002500 // The happy path. Keep tracking dependencies until we hit a non double-loadable
2501 // one.
2502 if Bool(to.VendorProperties.Double_loadable) {
2503 return true
2504 }
2505
Ivan Lozanod7586b62021-04-01 09:49:36 -04002506 if to.IsVndkSp() || to.IsLlndk() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002507 return false
2508 }
2509
Jooyung Hana70f0672019-01-18 15:20:43 +09002510 ctx.ModuleErrorf("links a library %q which is not LL-NDK, "+
2511 "VNDK-SP, or explicitly marked as 'double_loadable:true'. "+
Jiyong Park0474e1f2021-01-14 14:26:06 +09002512 "Dependency list: %s", ctx.OtherModuleName(to), ctx.GetPathString(false))
Jooyung Hana70f0672019-01-18 15:20:43 +09002513 return false
2514 }
2515 if module, ok := ctx.Module().(*Module); ok {
2516 if lib, ok := module.linker.(*libraryDecorator); ok && lib.shared() {
Jiyong Park0474e1f2021-01-14 14:26:06 +09002517 if lib.hasLLNDKStubs() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002518 ctx.WalkDeps(check)
2519 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002520 }
2521 }
2522}
2523
Colin Crossc99deeb2016-04-11 15:06:20 -07002524// Convert dependencies to paths. Returns a PathDeps containing paths
Colin Cross635c3b02016-05-18 15:37:25 -07002525func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
Colin Crossca860ac2016-01-04 14:34:37 -08002526 var depPaths PathDeps
Colin Crossca860ac2016-01-04 14:34:37 -08002527
Colin Cross0de8a1e2020-09-18 14:15:30 -07002528 var directStaticDeps []StaticLibraryInfo
2529 var directSharedDeps []SharedLibraryInfo
Jeff Gaston294356f2017-09-27 17:05:30 -07002530
Colin Cross0de8a1e2020-09-18 14:15:30 -07002531 reexportExporter := func(exporter FlagExporterInfo) {
2532 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, exporter.IncludeDirs...)
2533 depPaths.ReexportedSystemDirs = append(depPaths.ReexportedSystemDirs, exporter.SystemIncludeDirs...)
2534 depPaths.ReexportedFlags = append(depPaths.ReexportedFlags, exporter.Flags...)
2535 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, exporter.Deps...)
2536 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders, exporter.GeneratedHeaders...)
Inseob Kim69378442019-06-03 19:10:47 +09002537 }
2538
Jooyung Hande34d232020-07-23 13:04:15 +09002539 // For the dependency from platform to apex, use the latest stubs
2540 c.apexSdkVersion = android.FutureApiLevel
Colin Cross56a83212020-09-15 18:30:11 -07002541 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
2542 if !apexInfo.IsForPlatform() {
Jiyong Park4eab21d2021-04-15 15:17:54 +09002543 c.apexSdkVersion = apexInfo.MinSdkVersion
Jooyung Hande34d232020-07-23 13:04:15 +09002544 }
2545
2546 if android.InList("hwaddress", ctx.Config().SanitizeDevice()) {
2547 // In hwasan build, we override apexSdkVersion to the FutureApiLevel(10000)
2548 // so that even Q(29/Android10) apexes could use the dynamic unwinder by linking the newer stubs(e.g libc(R+)).
2549 // (b/144430859)
2550 c.apexSdkVersion = android.FutureApiLevel
2551 }
2552
Colin Crossd11fcda2017-10-23 17:59:01 -07002553 ctx.VisitDirectDeps(func(dep android.Module) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002554 depName := ctx.OtherModuleName(dep)
2555 depTag := ctx.OtherModuleDependencyTag(dep)
Dan Albert9e10cd42016-08-03 14:12:14 -07002556
Ivan Lozano52767be2019-10-18 14:49:46 -07002557 ccDep, ok := dep.(LinkableInterface)
2558 if !ok {
2559
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002560 // handling for a few module types that aren't cc Module but that are also supported
2561 switch depTag {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002562 case genSourceDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002563 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002564 depPaths.GeneratedSources = append(depPaths.GeneratedSources,
2565 genRule.GeneratedSourceFiles()...)
2566 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002567 ctx.ModuleErrorf("module %q is not a gensrcs or genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002568 }
Colin Crosse90bfd12017-04-26 16:59:26 -07002569 // Support exported headers from a generated_sources dependency
2570 fallthrough
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002571 case genHeaderDepTag, genHeaderExportDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002572 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Inseob Kimd110f872019-12-06 13:15:38 +09002573 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps,
Dan Willemsen9da9d492018-02-21 18:28:18 -08002574 genRule.GeneratedDeps()...)
Jiyong Park74955042019-10-22 20:19:51 +09002575 dirs := genRule.GeneratedHeaderDirs()
Inseob Kim69378442019-06-03 19:10:47 +09002576 depPaths.IncludeDirs = append(depPaths.IncludeDirs, dirs...)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002577 if depTag == genHeaderExportDepTag {
Inseob Kim69378442019-06-03 19:10:47 +09002578 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, dirs...)
Inseob Kimd110f872019-12-06 13:15:38 +09002579 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders,
2580 genRule.GeneratedSourceFiles()...)
Inseob Kim69378442019-06-03 19:10:47 +09002581 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, genRule.GeneratedDeps()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002582 // 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 +09002583 c.sabi.Properties.ReexportedIncludes = append(c.sabi.Properties.ReexportedIncludes, dirs.Strings()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002584
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002585 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002586 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002587 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002588 }
Colin Crosscef792e2021-06-11 18:01:26 -07002589 case CrtBeginDepTag:
2590 depPaths.CrtBegin = append(depPaths.CrtBegin, android.OutputFileForModule(ctx, dep, ""))
2591 case CrtEndDepTag:
2592 depPaths.CrtEnd = append(depPaths.CrtEnd, android.OutputFileForModule(ctx, dep, ""))
Colin Crossca860ac2016-01-04 14:34:37 -08002593 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002594 return
2595 }
2596
Colin Crossfe17f6f2019-03-28 19:30:56 -07002597 if depTag == android.ProtoPluginDepTag {
2598 return
2599 }
2600
Colin Crossd11fcda2017-10-23 17:59:01 -07002601 if dep.Target().Os != ctx.Os() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002602 ctx.ModuleErrorf("OS mismatch between %q and %q", ctx.ModuleName(), depName)
2603 return
2604 }
Colin Crossd11fcda2017-10-23 17:59:01 -07002605 if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
Jooyung Han61b66e92020-03-21 14:21:46 +00002606 ctx.ModuleErrorf("Arch mismatch between %q(%v) and %q(%v)",
2607 ctx.ModuleName(), ctx.Arch().ArchType, depName, dep.Target().Arch.ArchType)
Colin Crossa1ad8d12016-06-01 17:09:44 -07002608 return
2609 }
2610
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002611 if depTag == reuseObjTag {
Colin Crossa717db72020-10-23 14:53:06 -07002612 // Skip reused objects for stub libraries, they use their own stub object file instead.
2613 // The reuseObjTag dependency still exists because the LinkageMutator runs before the
2614 // version mutator, so the stubs variant is created from the shared variant that
2615 // already has the reuseObjTag dependency on the static variant.
Colin Cross31076b32020-10-23 17:22:06 -07002616 if !c.library.buildStubs() {
Colin Crossa717db72020-10-23 14:53:06 -07002617 staticAnalogue := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
2618 objs := staticAnalogue.ReuseObjects
2619 depPaths.Objs = depPaths.Objs.Append(objs)
2620 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
2621 reexportExporter(depExporterInfo)
2622 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07002623 return
Jiyong Parke4bb9862019-02-01 00:31:10 +09002624 }
2625
Colin Cross6e511a92020-07-27 21:26:48 -07002626 linkFile := ccDep.OutputFile()
2627
2628 if libDepTag, ok := depTag.(libraryDependencyTag); ok {
2629 // Only use static unwinder for legacy (min_sdk_version = 29) apexes (b/144430859)
Dan Albertc8060532020-07-22 22:32:17 -07002630 if libDepTag.staticUnwinder && c.apexSdkVersion.GreaterThan(android.SdkVersion_Android10) {
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002631 return
2632 }
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002633
Jiyong Parke3867542020-12-03 17:28:25 +09002634 if !apexInfo.IsForPlatform() && libDepTag.excludeInApex {
2635 return
2636 }
2637
Colin Cross0de8a1e2020-09-18 14:15:30 -07002638 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
Colin Crossc99deeb2016-04-11 15:06:20 -07002639
Colin Cross6e511a92020-07-27 21:26:48 -07002640 var ptr *android.Paths
2641 var depPtr *android.Paths
Colin Crossc99deeb2016-04-11 15:06:20 -07002642
Colin Cross6e511a92020-07-27 21:26:48 -07002643 depFile := android.OptionalPath{}
Colin Cross26c34ed2016-09-30 17:10:16 -07002644
Colin Cross6e511a92020-07-27 21:26:48 -07002645 switch {
2646 case libDepTag.header():
Colin Cross649d8172020-12-10 12:30:21 -08002647 if !ctx.OtherModuleHasProvider(dep, HeaderLibraryInfoProvider) {
2648 if !ctx.Config().AllowMissingDependencies() {
2649 ctx.ModuleErrorf("module %q is not a header library", depName)
2650 } else {
2651 ctx.AddMissingDependencies([]string{depName})
2652 }
2653 return
2654 }
Colin Cross6e511a92020-07-27 21:26:48 -07002655 case libDepTag.shared():
Colin Cross0de8a1e2020-09-18 14:15:30 -07002656 if !ctx.OtherModuleHasProvider(dep, SharedLibraryInfoProvider) {
2657 if !ctx.Config().AllowMissingDependencies() {
2658 ctx.ModuleErrorf("module %q is not a shared library", depName)
2659 } else {
2660 ctx.AddMissingDependencies([]string{depName})
2661 }
2662 return
2663 }
Jiyong Parke3867542020-12-03 17:28:25 +09002664
Jiyong Park7d55b612021-06-11 17:22:09 +09002665 sharedLibraryInfo, returnedDepExporterInfo := ChooseStubOrImpl(ctx, dep)
2666 depExporterInfo = returnedDepExporterInfo
Colin Cross0de8a1e2020-09-18 14:15:30 -07002667
Jiyong Park1ad8e162020-12-01 23:40:09 +09002668 // Stubs lib doesn't link to the shared lib dependencies. Don't set
2669 // linkFile, depFile, and ptr.
2670 if c.IsStubs() {
2671 break
2672 }
2673
Colin Cross0de8a1e2020-09-18 14:15:30 -07002674 linkFile = android.OptionalPathForPath(sharedLibraryInfo.SharedLibrary)
2675 depFile = sharedLibraryInfo.TableOfContents
2676
Colin Cross6e511a92020-07-27 21:26:48 -07002677 ptr = &depPaths.SharedLibs
2678 switch libDepTag.Order {
2679 case earlyLibraryDependency:
2680 ptr = &depPaths.EarlySharedLibs
2681 depPtr = &depPaths.EarlySharedLibsDeps
2682 case normalLibraryDependency:
2683 ptr = &depPaths.SharedLibs
2684 depPtr = &depPaths.SharedLibsDeps
Colin Cross0de8a1e2020-09-18 14:15:30 -07002685 directSharedDeps = append(directSharedDeps, sharedLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07002686 case lateLibraryDependency:
2687 ptr = &depPaths.LateSharedLibs
2688 depPtr = &depPaths.LateSharedLibsDeps
2689 default:
2690 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Colin Crossc99deeb2016-04-11 15:06:20 -07002691 }
Colin Cross6e511a92020-07-27 21:26:48 -07002692 case libDepTag.static():
Colin Cross0de8a1e2020-09-18 14:15:30 -07002693 if !ctx.OtherModuleHasProvider(dep, StaticLibraryInfoProvider) {
2694 if !ctx.Config().AllowMissingDependencies() {
2695 ctx.ModuleErrorf("module %q is not a static library", depName)
2696 } else {
2697 ctx.AddMissingDependencies([]string{depName})
2698 }
2699 return
2700 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002701
2702 // Stubs lib doesn't link to the static lib dependencies. Don't set
2703 // linkFile, depFile, and ptr.
2704 if c.IsStubs() {
2705 break
2706 }
2707
Colin Cross0de8a1e2020-09-18 14:15:30 -07002708 staticLibraryInfo := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
2709 linkFile = android.OptionalPathForPath(staticLibraryInfo.StaticLibrary)
Colin Cross6e511a92020-07-27 21:26:48 -07002710 if libDepTag.wholeStatic {
2711 ptr = &depPaths.WholeStaticLibs
Colin Cross0de8a1e2020-09-18 14:15:30 -07002712 if len(staticLibraryInfo.Objects.objFiles) > 0 {
2713 depPaths.WholeStaticLibObjs = depPaths.WholeStaticLibObjs.Append(staticLibraryInfo.Objects)
Inseob Kimeec88e12020-01-22 11:11:29 +09002714 } else {
Colin Cross0de8a1e2020-09-18 14:15:30 -07002715 // This case normally catches prebuilt static
2716 // libraries, but it can also occur when
2717 // AllowMissingDependencies is on and the
2718 // dependencies has no sources of its own
2719 // but has a whole_static_libs dependency
2720 // on a missing library. We want to depend
2721 // on the .a file so that there is something
2722 // in the dependency tree that contains the
2723 // error rule for the missing transitive
2724 // dependency.
2725 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07002726 }
Colin Cross6e511a92020-07-27 21:26:48 -07002727 } else {
2728 switch libDepTag.Order {
2729 case earlyLibraryDependency:
2730 panic(fmt.Errorf("early static libs not suppported"))
2731 case normalLibraryDependency:
2732 // static dependencies will be handled separately so they can be ordered
2733 // using transitive dependencies.
2734 ptr = nil
Colin Cross0de8a1e2020-09-18 14:15:30 -07002735 directStaticDeps = append(directStaticDeps, staticLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07002736 case lateLibraryDependency:
2737 ptr = &depPaths.LateStaticLibs
2738 default:
2739 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Inseob Kimeec88e12020-01-22 11:11:29 +09002740 }
2741 }
2742 }
2743
Colin Cross6e511a92020-07-27 21:26:48 -07002744 if libDepTag.static() && !libDepTag.wholeStatic {
2745 if !ccDep.CcLibraryInterface() || !ccDep.Static() {
2746 ctx.ModuleErrorf("module %q not a static library", depName)
2747 return
2748 }
Logan Chien43d34c32017-12-20 01:17:32 +08002749
Colin Cross6e511a92020-07-27 21:26:48 -07002750 // When combining coverage files for shared libraries and executables, coverage files
2751 // in static libraries act as if they were whole static libraries. The same goes for
2752 // source based Abi dump files.
2753 if c, ok := ccDep.(*Module); ok {
2754 staticLib := c.linker.(libraryInterface)
2755 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
2756 staticLib.objs().coverageFiles...)
2757 depPaths.StaticLibObjs.sAbiDumpFiles = append(depPaths.StaticLibObjs.sAbiDumpFiles,
2758 staticLib.objs().sAbiDumpFiles...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07002759 } else {
Colin Cross6e511a92020-07-27 21:26:48 -07002760 // Handle non-CC modules here
2761 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
Colin Cross0de8a1e2020-09-18 14:15:30 -07002762 ccDep.CoverageFiles()...)
Jiyong Parkde866cb2018-12-07 23:08:36 +09002763 }
2764 }
2765
Colin Cross6e511a92020-07-27 21:26:48 -07002766 if ptr != nil {
2767 if !linkFile.Valid() {
2768 if !ctx.Config().AllowMissingDependencies() {
2769 ctx.ModuleErrorf("module %q missing output file", depName)
2770 } else {
2771 ctx.AddMissingDependencies([]string{depName})
2772 }
2773 return
2774 }
2775 *ptr = append(*ptr, linkFile.Path())
2776 }
2777
2778 if depPtr != nil {
2779 dep := depFile
2780 if !dep.Valid() {
2781 dep = linkFile
2782 }
2783 *depPtr = append(*depPtr, dep.Path())
2784 }
2785
Colin Cross0de8a1e2020-09-18 14:15:30 -07002786 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
2787 depPaths.SystemIncludeDirs = append(depPaths.SystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
2788 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps, depExporterInfo.Deps...)
2789 depPaths.Flags = append(depPaths.Flags, depExporterInfo.Flags...)
2790
2791 if libDepTag.reexportFlags {
2792 reexportExporter(depExporterInfo)
2793 // Add these re-exported flags to help header-abi-dumper to infer the abi exported by a library.
2794 // Re-exported shared library headers must be included as well since they can help us with type information
2795 // about template instantiations (instantiated from their headers).
2796 // -isystem headers are not included since for bionic libraries, abi-filtering is taken care of by version
2797 // scripts.
2798 c.sabi.Properties.ReexportedIncludes = append(
2799 c.sabi.Properties.ReexportedIncludes, depExporterInfo.IncludeDirs.Strings()...)
2800 }
2801
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002802 makeLibName := MakeLibName(ctx, c, ccDep, depName) + libDepTag.makeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07002803 switch {
2804 case libDepTag.header():
Colin Cross370173e2020-07-29 12:48:33 -07002805 c.Properties.AndroidMkHeaderLibs = append(
2806 c.Properties.AndroidMkHeaderLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07002807 case libDepTag.shared():
Colin Cross31076b32020-10-23 17:22:06 -07002808 if lib := moduleLibraryInterface(dep); lib != nil {
2809 if lib.buildStubs() && dep.(android.ApexModule).InAnyApex() {
Colin Cross6e511a92020-07-27 21:26:48 -07002810 // Add the dependency to the APEX(es) providing the library so that
2811 // m <module> can trigger building the APEXes as well.
Colin Cross56a83212020-09-15 18:30:11 -07002812 depApexInfo := ctx.OtherModuleProvider(dep, android.ApexInfoProvider).(android.ApexInfo)
Jiyong Parkab50b072021-05-12 17:13:56 +09002813 for _, an := range depApexInfo.InApexVariants {
Colin Cross6e511a92020-07-27 21:26:48 -07002814 c.Properties.ApexesProvidingSharedLibs = append(
2815 c.Properties.ApexesProvidingSharedLibs, an)
2816 }
2817 }
2818 }
2819
2820 // Note: the order of libs in this list is not important because
2821 // they merely serve as Make dependencies and do not affect this lib itself.
Colin Cross370173e2020-07-29 12:48:33 -07002822 c.Properties.AndroidMkSharedLibs = append(
2823 c.Properties.AndroidMkSharedLibs, makeLibName)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002824 // Record BaseLibName for snapshots.
2825 c.Properties.SnapshotSharedLibs = append(c.Properties.SnapshotSharedLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07002826 case libDepTag.static():
2827 if libDepTag.wholeStatic {
2828 c.Properties.AndroidMkWholeStaticLibs = append(
2829 c.Properties.AndroidMkWholeStaticLibs, makeLibName)
2830 } else {
2831 c.Properties.AndroidMkStaticLibs = append(
2832 c.Properties.AndroidMkStaticLibs, makeLibName)
2833 }
Justin Yun5e035862021-06-29 20:50:37 +09002834 // Record BaseLibName for snapshots.
2835 c.Properties.SnapshotStaticLibs = append(c.Properties.SnapshotStaticLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07002836 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002837 } else if !c.IsStubs() {
2838 // Stubs lib doesn't link to the runtime lib, object, crt, etc. dependencies.
2839
Colin Cross6e511a92020-07-27 21:26:48 -07002840 switch depTag {
2841 case runtimeDepTag:
2842 c.Properties.AndroidMkRuntimeLibs = append(
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002843 c.Properties.AndroidMkRuntimeLibs, MakeLibName(ctx, c, ccDep, depName)+libDepTag.makeSuffix)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002844 // Record BaseLibName for snapshots.
2845 c.Properties.SnapshotRuntimeLibs = append(c.Properties.SnapshotRuntimeLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07002846 case objDepTag:
2847 depPaths.Objs.objFiles = append(depPaths.Objs.objFiles, linkFile.Path())
2848 case CrtBeginDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07002849 depPaths.CrtBegin = append(depPaths.CrtBegin, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07002850 case CrtEndDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07002851 depPaths.CrtEnd = append(depPaths.CrtEnd, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07002852 case dynamicLinkerDepTag:
2853 depPaths.DynamicLinker = linkFile
2854 }
Jiyong Park27b188b2017-07-18 13:23:39 +09002855 }
Colin Crossca860ac2016-01-04 14:34:37 -08002856 })
2857
Jeff Gaston294356f2017-09-27 17:05:30 -07002858 // use the ordered dependencies as this module's dependencies
Colin Cross0de8a1e2020-09-18 14:15:30 -07002859 orderedStaticPaths, transitiveStaticLibs := orderStaticModuleDeps(directStaticDeps, directSharedDeps)
2860 depPaths.TranstiveStaticLibrariesForOrdering = transitiveStaticLibs
2861 depPaths.StaticLibs = append(depPaths.StaticLibs, orderedStaticPaths...)
Jeff Gaston294356f2017-09-27 17:05:30 -07002862
Colin Crossdd84e052017-05-17 13:44:16 -07002863 // Dedup exported flags from dependencies
Colin Crossb6715442017-10-24 11:13:31 -07002864 depPaths.Flags = android.FirstUniqueStrings(depPaths.Flags)
Jiyong Park74955042019-10-22 20:19:51 +09002865 depPaths.IncludeDirs = android.FirstUniquePaths(depPaths.IncludeDirs)
2866 depPaths.SystemIncludeDirs = android.FirstUniquePaths(depPaths.SystemIncludeDirs)
Inseob Kimd110f872019-12-06 13:15:38 +09002867 depPaths.GeneratedDeps = android.FirstUniquePaths(depPaths.GeneratedDeps)
Jiyong Park74955042019-10-22 20:19:51 +09002868 depPaths.ReexportedDirs = android.FirstUniquePaths(depPaths.ReexportedDirs)
2869 depPaths.ReexportedSystemDirs = android.FirstUniquePaths(depPaths.ReexportedSystemDirs)
Colin Crossb6715442017-10-24 11:13:31 -07002870 depPaths.ReexportedFlags = android.FirstUniqueStrings(depPaths.ReexportedFlags)
Inseob Kim69378442019-06-03 19:10:47 +09002871 depPaths.ReexportedDeps = android.FirstUniquePaths(depPaths.ReexportedDeps)
Inseob Kimd110f872019-12-06 13:15:38 +09002872 depPaths.ReexportedGeneratedHeaders = android.FirstUniquePaths(depPaths.ReexportedGeneratedHeaders)
Dan Willemsenfe92c962017-08-29 12:28:37 -07002873
2874 if c.sabi != nil {
Inseob Kim69378442019-06-03 19:10:47 +09002875 c.sabi.Properties.ReexportedIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedIncludes)
Dan Willemsenfe92c962017-08-29 12:28:37 -07002876 }
Colin Crossdd84e052017-05-17 13:44:16 -07002877
Colin Crossca860ac2016-01-04 14:34:37 -08002878 return depPaths
2879}
2880
Jiyong Park7d55b612021-06-11 17:22:09 +09002881// ChooseStubOrImpl determines whether a given dependency should be redirected to the stub variant
2882// of the dependency or not, and returns the SharedLibraryInfo and FlagExporterInfo for the right
2883// dependency. The stub variant is selected when the dependency crosses a boundary where each side
2884// has different level of updatability. For example, if a library foo in an APEX depends on a
2885// library bar which provides stable interface and exists in the platform, foo uses the stub variant
2886// of bar. If bar doesn't provide a stable interface (i.e. buildStubs() == false) or is in the
2887// same APEX as foo, the non-stub variant of bar is used.
2888func ChooseStubOrImpl(ctx android.ModuleContext, dep android.Module) (SharedLibraryInfo, FlagExporterInfo) {
2889 depName := ctx.OtherModuleName(dep)
2890 depTag := ctx.OtherModuleDependencyTag(dep)
2891 libDepTag, ok := depTag.(libraryDependencyTag)
2892 if !ok || !libDepTag.shared() {
2893 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
2894 }
2895
2896 thisModule, ok := ctx.Module().(android.ApexModule)
2897 if !ok {
2898 panic(fmt.Errorf("Not an APEX module: %q", ctx.ModuleName()))
2899 }
2900
2901 useVndk := false
2902 bootstrap := false
2903 if linkable, ok := ctx.Module().(LinkableInterface); !ok {
2904 panic(fmt.Errorf("Not a Linkable module: %q", ctx.ModuleName()))
2905 } else {
2906 useVndk = linkable.UseVndk()
2907 bootstrap = linkable.Bootstrap()
2908 }
2909
2910 sharedLibraryInfo := ctx.OtherModuleProvider(dep, SharedLibraryInfoProvider).(SharedLibraryInfo)
2911 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
2912 sharedLibraryStubsInfo := ctx.OtherModuleProvider(dep, SharedLibraryStubsProvider).(SharedLibraryStubsInfo)
2913 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
2914
2915 if !libDepTag.explicitlyVersioned && len(sharedLibraryStubsInfo.SharedStubLibraries) > 0 {
2916 useStubs := false
2917
2918 if lib := moduleLibraryInterface(dep); lib.buildStubs() && useVndk { // LLNDK
2919 if !apexInfo.IsForPlatform() {
2920 // For platform libraries, use current version of LLNDK
2921 // If this is for use_vendor apex we will apply the same rules
2922 // of apex sdk enforcement below to choose right version.
2923 useStubs = true
2924 }
Jiyong Park9477c262021-06-22 20:23:05 +09002925 } else if apexInfo.IsForPlatform() || apexInfo.UsePlatformApis {
2926 // If not building for APEX or the containing APEX allows the use of
2927 // platform APIs, use stubs only when it is from an APEX (and not from
2928 // platform) However, for host, ramdisk, vendor_ramdisk, recovery or
2929 // bootstrap modules, always link to non-stub variant
Jiyong Park7d55b612021-06-11 17:22:09 +09002930 useStubs = dep.(android.ApexModule).NotInPlatform() && !bootstrap
2931 if useStubs {
2932 // Another exception: if this module is a test for an APEX, then
2933 // it is linked with the non-stub variant of a module in the APEX
2934 // as if this is part of the APEX.
2935 testFor := ctx.Provider(android.ApexTestForInfoProvider).(android.ApexTestForInfo)
2936 for _, apexContents := range testFor.ApexContents {
2937 if apexContents.DirectlyInApex(depName) {
2938 useStubs = false
2939 break
2940 }
2941 }
2942 }
2943 if useStubs {
2944 // Yet another exception: If this module and the dependency are
2945 // available to the same APEXes then skip stubs between their
2946 // platform variants. This complements the test_for case above,
2947 // which avoids the stubs on a direct APEX library dependency, by
2948 // avoiding stubs for indirect test dependencies as well.
2949 //
2950 // TODO(b/183882457): This doesn't work if the two libraries have
2951 // only partially overlapping apex_available. For that test_for
2952 // modules would need to be split into APEX variants and resolved
2953 // separately for each APEX they have access to.
2954 if android.AvailableToSameApexes(thisModule, dep.(android.ApexModule)) {
2955 useStubs = false
2956 }
2957 }
2958 } else {
2959 // If building for APEX, use stubs when the parent is in any APEX that
2960 // the child is not in.
2961 useStubs = !android.DirectlyInAllApexes(apexInfo, depName)
2962 }
2963
2964 // when to use (unspecified) stubs, use the latest one.
2965 if useStubs {
2966 stubs := sharedLibraryStubsInfo.SharedStubLibraries
2967 toUse := stubs[len(stubs)-1]
2968 sharedLibraryInfo = toUse.SharedLibraryInfo
2969 depExporterInfo = toUse.FlagExporterInfo
2970 }
2971 }
2972 return sharedLibraryInfo, depExporterInfo
2973}
2974
Colin Cross0de8a1e2020-09-18 14:15:30 -07002975// orderStaticModuleDeps rearranges the order of the static library dependencies of the module
2976// to match the topological order of the dependency tree, including any static analogues of
2977// direct shared libraries. It returns the ordered static dependencies, and an android.DepSet
2978// of the transitive dependencies.
2979func orderStaticModuleDeps(staticDeps []StaticLibraryInfo, sharedDeps []SharedLibraryInfo) (ordered android.Paths, transitive *android.DepSet) {
2980 transitiveStaticLibsBuilder := android.NewDepSetBuilder(android.TOPOLOGICAL)
2981 var staticPaths android.Paths
2982 for _, staticDep := range staticDeps {
2983 staticPaths = append(staticPaths, staticDep.StaticLibrary)
2984 transitiveStaticLibsBuilder.Transitive(staticDep.TransitiveStaticLibrariesForOrdering)
2985 }
2986 for _, sharedDep := range sharedDeps {
Liz Kammeref6dfea2021-06-08 15:37:09 -04002987 if sharedDep.TransitiveStaticLibrariesForOrdering != nil {
2988 transitiveStaticLibsBuilder.Transitive(sharedDep.TransitiveStaticLibrariesForOrdering)
Colin Cross0de8a1e2020-09-18 14:15:30 -07002989 }
2990 }
2991 transitiveStaticLibs := transitiveStaticLibsBuilder.Build()
2992
2993 orderedTransitiveStaticLibs := transitiveStaticLibs.ToList()
2994
2995 // reorder the dependencies based on transitive dependencies
2996 staticPaths = android.FirstUniquePaths(staticPaths)
2997 _, orderedStaticPaths := android.FilterPathList(orderedTransitiveStaticLibs, staticPaths)
2998
2999 if len(orderedStaticPaths) != len(staticPaths) {
3000 missing, _ := android.FilterPathList(staticPaths, orderedStaticPaths)
3001 panic(fmt.Errorf("expected %d ordered static paths , got %d, missing %q %q %q", len(staticPaths), len(orderedStaticPaths), missing, orderedStaticPaths, staticPaths))
3002 }
3003
3004 return orderedStaticPaths, transitiveStaticLibs
3005}
3006
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003007// BaseLibName trims known prefixes and suffixes
3008func BaseLibName(depName string) string {
Colin Cross6e511a92020-07-27 21:26:48 -07003009 libName := strings.TrimSuffix(depName, llndkLibrarySuffix)
3010 libName = strings.TrimSuffix(libName, vendorPublicLibrarySuffix)
Paul Duffind23c7262020-12-11 18:13:08 +00003011 libName = android.RemoveOptionalPrebuiltPrefix(libName)
Colin Cross6e511a92020-07-27 21:26:48 -07003012 return libName
3013}
3014
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003015func MakeLibName(ctx android.ModuleContext, c LinkableInterface, ccDep LinkableInterface, depName string) string {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003016 libName := BaseLibName(depName)
Colin Cross127bb8b2020-12-16 16:46:01 -08003017 ccDepModule, _ := ccDep.(*Module)
3018 isLLndk := ccDepModule != nil && ccDepModule.IsLlndk()
Justin Yuncbca3732021-02-03 19:24:13 +09003019 nonSystemVariantsExist := ccDep.HasNonSystemVariants() || isLLndk
Colin Cross6e511a92020-07-27 21:26:48 -07003020
Justin Yuncbca3732021-02-03 19:24:13 +09003021 if ccDepModule != nil {
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003022 // TODO(ivanlozano) Support snapshots for Rust-produced C library variants.
Colin Cross6e511a92020-07-27 21:26:48 -07003023 // Use base module name for snapshots when exporting to Makefile.
Ivan Lozanod1dec542021-05-26 15:33:11 -04003024 if snapshotPrebuilt, ok := ccDepModule.linker.(SnapshotInterface); ok {
Justin Yuncbca3732021-02-03 19:24:13 +09003025 baseName := ccDepModule.BaseModuleName()
Colin Cross6e511a92020-07-27 21:26:48 -07003026
Ivan Lozanod1dec542021-05-26 15:33:11 -04003027 return baseName + snapshotPrebuilt.SnapshotAndroidMkSuffix()
Colin Cross6e511a92020-07-27 21:26:48 -07003028 }
3029 }
3030
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003031 if ctx.DeviceConfig().VndkUseCoreVariant() && ccDep.IsVndk() && !ccDep.MustUseVendorVariant() &&
3032 !c.InRamdisk() && !c.InVendorRamdisk() && !c.InRecovery() {
Colin Cross6e511a92020-07-27 21:26:48 -07003033 // The vendor module is a no-vendor-variant VNDK library. Depend on the
3034 // core module instead.
3035 return libName
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003036 } else if ccDep.UseVndk() && nonSystemVariantsExist {
Justin Yuncbca3732021-02-03 19:24:13 +09003037 // The vendor and product modules in Make will have been renamed to not conflict with the
3038 // core module, so update the dependency name here accordingly.
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003039 return libName + ccDep.SubName()
Colin Cross6e511a92020-07-27 21:26:48 -07003040 } else if ccDep.InRamdisk() && !ccDep.OnlyInRamdisk() {
3041 return libName + ramdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003042 } else if ccDep.InVendorRamdisk() && !ccDep.OnlyInVendorRamdisk() {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05003043 return libName + VendorRamdiskSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003044 } else if ccDep.InRecovery() && !ccDep.OnlyInRecovery() {
3045 return libName + recoverySuffix
Ivan Lozanof9e21722020-12-02 09:00:51 -05003046 } else if ccDep.Target().NativeBridge == android.NativeBridgeEnabled {
Colin Cross6e511a92020-07-27 21:26:48 -07003047 return libName + nativeBridgeSuffix
3048 } else {
3049 return libName
3050 }
3051}
3052
Colin Crossca860ac2016-01-04 14:34:37 -08003053func (c *Module) InstallInData() bool {
3054 if c.installer == nil {
3055 return false
3056 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003057 return c.installer.inData()
3058}
3059
3060func (c *Module) InstallInSanitizerDir() bool {
3061 if c.installer == nil {
3062 return false
3063 }
3064 if c.sanitize != nil && c.sanitize.inSanitizerDir() {
Colin Cross94610402016-08-29 13:41:32 -07003065 return true
3066 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003067 return c.installer.inSanitizerDir()
Colin Crossca860ac2016-01-04 14:34:37 -08003068}
3069
Yifan Hong1b3348d2020-01-21 15:53:22 -08003070func (c *Module) InstallInRamdisk() bool {
3071 return c.InRamdisk()
3072}
3073
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003074func (c *Module) InstallInVendorRamdisk() bool {
3075 return c.InVendorRamdisk()
3076}
3077
Jiyong Parkf9332f12018-02-01 00:54:12 +09003078func (c *Module) InstallInRecovery() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07003079 return c.InRecovery()
Jiyong Parkf9332f12018-02-01 00:54:12 +09003080}
3081
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01003082func (c *Module) MakeUninstallable() {
Martin Stjernholmbf37d162020-03-31 16:05:34 +01003083 if c.installer == nil {
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01003084 c.ModuleBase.MakeUninstallable()
Martin Stjernholmbf37d162020-03-31 16:05:34 +01003085 return
3086 }
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01003087 c.installer.makeUninstallable(c)
Martin Stjernholmbf37d162020-03-31 16:05:34 +01003088}
3089
Dan Willemsen4aa75ca2016-09-28 16:18:03 -07003090func (c *Module) HostToolPath() android.OptionalPath {
3091 if c.installer == nil {
3092 return android.OptionalPath{}
3093 }
3094 return c.installer.hostToolPath()
3095}
3096
Nan Zhangd4e641b2017-07-12 12:55:28 -07003097func (c *Module) IntermPathForModuleOut() android.OptionalPath {
3098 return c.outputFile
3099}
3100
Colin Cross41955e82019-05-29 14:40:35 -07003101func (c *Module) OutputFiles(tag string) (android.Paths, error) {
3102 switch tag {
3103 case "":
3104 if c.outputFile.Valid() {
3105 return android.Paths{c.outputFile.Path()}, nil
3106 }
3107 return android.Paths{}, nil
3108 default:
3109 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003110 }
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003111}
3112
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00003113func (c *Module) static() bool {
3114 if static, ok := c.linker.(interface {
3115 static() bool
3116 }); ok {
3117 return static.static()
3118 }
3119 return false
3120}
3121
Jiyong Park379de2f2018-12-19 02:47:14 +09003122func (c *Module) staticBinary() bool {
3123 if static, ok := c.linker.(interface {
3124 staticBinary() bool
3125 }); ok {
3126 return static.staticBinary()
3127 }
3128 return false
3129}
3130
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07003131func (c *Module) testBinary() bool {
3132 if test, ok := c.linker.(interface {
3133 testBinary() bool
3134 }); ok {
3135 return test.testBinary()
3136 }
3137 return false
3138}
3139
Ivan Lozano3968d8f2020-12-14 11:27:52 -05003140// Header returns true if the module is a header-only variant. (See cc/library.go header()).
3141func (c *Module) Header() bool {
Jiyong Park1d1119f2019-07-29 21:27:18 +09003142 if h, ok := c.linker.(interface {
3143 header() bool
3144 }); ok {
3145 return h.header()
3146 }
3147 return false
3148}
3149
Ivan Lozanod7586b62021-04-01 09:49:36 -04003150func (c *Module) Binary() bool {
Inseob Kim7f283f42020-06-01 21:53:49 +09003151 if b, ok := c.linker.(interface {
3152 binary() bool
3153 }); ok {
3154 return b.binary()
3155 }
3156 return false
3157}
3158
Justin Yun5e035862021-06-29 20:50:37 +09003159func (c *Module) StaticExecutable() bool {
3160 if b, ok := c.linker.(*binaryDecorator); ok {
3161 return b.static()
3162 }
3163 return false
3164}
3165
Ivan Lozanod7586b62021-04-01 09:49:36 -04003166func (c *Module) Object() bool {
Inseob Kim1042d292020-06-01 23:23:05 +09003167 if o, ok := c.linker.(interface {
3168 object() bool
3169 }); ok {
3170 return o.object()
3171 }
3172 return false
3173}
3174
Ivan Lozanof9e21722020-12-02 09:00:51 -05003175func GetMakeLinkType(actx android.ModuleContext, c LinkableInterface) string {
Ivan Lozano52767be2019-10-18 14:49:46 -07003176 if c.UseVndk() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003177 if c.IsLlndk() {
3178 if !c.IsLlndkPublic() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003179 return "native:vndk_private"
Colin Crossb60190a2018-09-04 16:28:17 -07003180 }
Colin Cross127bb8b2020-12-16 16:46:01 -08003181 return "native:vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07003182 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003183 if c.IsVndk() && !c.IsVndkExt() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003184 if c.IsVndkPrivate() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003185 return "native:vndk_private"
Jooyung Han38002912019-05-16 04:01:54 +09003186 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003187 return "native:vndk"
Jooyung Han38002912019-05-16 04:01:54 +09003188 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003189 if c.InProduct() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09003190 return "native:product"
3191 }
Jooyung Han38002912019-05-16 04:01:54 +09003192 return "native:vendor"
Yifan Hong1b3348d2020-01-21 15:53:22 -08003193 } else if c.InRamdisk() {
3194 return "native:ramdisk"
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003195 } else if c.InVendorRamdisk() {
3196 return "native:vendor_ramdisk"
Ivan Lozano52767be2019-10-18 14:49:46 -07003197 } else if c.InRecovery() {
Colin Crossb60190a2018-09-04 16:28:17 -07003198 return "native:recovery"
Ivan Lozanof9e21722020-12-02 09:00:51 -05003199 } else if c.Target().Os == android.Android && c.SdkVersion() != "" {
Colin Crossb60190a2018-09-04 16:28:17 -07003200 return "native:ndk:none:none"
3201 // TODO(b/114741097): use the correct ndk stl once build errors have been fixed
3202 //family, link := getNdkStlFamilyAndLinkType(c)
3203 //return fmt.Sprintf("native:ndk:%s:%s", family, link)
Ivan Lozano52767be2019-10-18 14:49:46 -07003204 } else if actx.DeviceConfig().VndkUseCoreVariant() && !c.MustUseVendorVariant() {
Vic Yangefd249e2018-11-12 20:19:56 -08003205 return "native:platform_vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07003206 } else {
3207 return "native:platform"
3208 }
3209}
3210
Jiyong Park9d452992018-10-03 00:38:19 +09003211// Overrides ApexModule.IsInstallabeToApex()
Roland Levillainf89cd092019-07-29 16:22:59 +01003212// Only shared/runtime libraries and "test_per_src" tests are installable to APEX.
Jiyong Park9d452992018-10-03 00:38:19 +09003213func (c *Module) IsInstallableToApex() bool {
Colin Cross31076b32020-10-23 17:22:06 -07003214 if lib := c.library; lib != nil {
Jiyong Park73c54ee2019-10-22 20:31:18 +09003215 // Stub libs and prebuilt libs in a versioned SDK are not
3216 // installable to APEX even though they are shared libs.
Colin Cross31076b32020-10-23 17:22:06 -07003217 return lib.shared() && !lib.buildStubs() && c.ContainingSdk().Unversioned()
Roland Levillainf89cd092019-07-29 16:22:59 +01003218 } else if _, ok := c.linker.(testPerSrc); ok {
3219 return true
Jiyong Park9d452992018-10-03 00:38:19 +09003220 }
3221 return false
3222}
3223
Jiyong Parka90ca002019-10-07 15:47:24 +09003224func (c *Module) AvailableFor(what string) bool {
3225 if linker, ok := c.linker.(interface {
3226 availableFor(string) bool
3227 }); ok {
3228 return c.ApexModuleBase.AvailableFor(what) || linker.availableFor(what)
3229 } else {
3230 return c.ApexModuleBase.AvailableFor(what)
3231 }
3232}
3233
Jiyong Park62304bb2020-04-13 16:19:48 +09003234func (c *Module) TestFor() []string {
Jiyong Park46a512f2020-12-04 18:02:13 +09003235 return c.Properties.Test_for
Jiyong Park62304bb2020-04-13 16:19:48 +09003236}
3237
Colin Crossaede88c2020-08-11 12:17:01 -07003238func (c *Module) UniqueApexVariations() bool {
3239 if u, ok := c.compiler.(interface {
3240 uniqueApexVariations() bool
3241 }); ok {
3242 return u.uniqueApexVariations()
3243 } else {
3244 return false
3245 }
3246}
3247
Paul Duffin0cb37b92020-03-04 14:52:46 +00003248func (c *Module) EverInstallable() bool {
3249 return c.installer != nil &&
3250 // Check to see whether the module is actually ever installable.
3251 c.installer.everInstallable()
3252}
3253
Ivan Lozanod7586b62021-04-01 09:49:36 -04003254func (c *Module) PreventInstall() bool {
3255 return c.Properties.PreventInstall
3256}
3257
3258func (c *Module) Installable() *bool {
3259 return c.Properties.Installable
3260}
3261
3262func installable(c LinkableInterface, apexInfo android.ApexInfo) bool {
Paul Duffin0cb37b92020-03-04 14:52:46 +00003263 ret := c.EverInstallable() &&
3264 // Check to see whether the module has been configured to not be installed.
Ivan Lozanod7586b62021-04-01 09:49:36 -04003265 proptools.BoolDefault(c.Installable(), true) &&
3266 !c.PreventInstall() && c.OutputFile().Valid()
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003267
3268 // The platform variant doesn't need further condition. Apex variants however might not
3269 // be installable because it will likely to be included in the APEX and won't appear
3270 // in the system partition.
Colin Cross56a83212020-09-15 18:30:11 -07003271 if apexInfo.IsForPlatform() {
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003272 return ret
3273 }
3274
3275 // Special case for modules that are configured to be installed to /data, which includes
3276 // test modules. For these modules, both APEX and non-APEX variants are considered as
3277 // installable. This is because even the APEX variants won't be included in the APEX, but
3278 // will anyway be installed to /data/*.
3279 // See b/146995717
3280 if c.InstallInData() {
3281 return ret
3282 }
3283
3284 return false
Inseob Kim1f086e22019-05-09 13:29:15 +09003285}
3286
Logan Chien41eabe62019-04-10 13:33:58 +08003287func (c *Module) AndroidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer) {
3288 if c.linker != nil {
3289 if library, ok := c.linker.(*libraryDecorator); ok {
3290 library.androidMkWriteAdditionalDependenciesForSourceAbiDiff(w)
3291 }
3292 }
3293}
3294
Jiyong Park45bf82e2020-12-15 22:29:02 +09003295var _ android.ApexModule = (*Module)(nil)
3296
3297// Implements android.ApexModule
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003298func (c *Module) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
Colin Cross6e511a92020-07-27 21:26:48 -07003299 depTag := ctx.OtherModuleDependencyTag(dep)
3300 libDepTag, isLibDepTag := depTag.(libraryDependencyTag)
3301
3302 if cc, ok := dep.(*Module); ok {
3303 if cc.HasStubsVariants() {
3304 if isLibDepTag && libDepTag.shared() {
3305 // dynamic dep to a stubs lib crosses APEX boundary
3306 return false
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003307 }
Colin Cross6e511a92020-07-27 21:26:48 -07003308 if IsRuntimeDepTag(depTag) {
3309 // runtime dep to a stubs lib also crosses APEX boundary
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003310 return false
3311 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003312 }
Zhijun Heec285872021-04-24 10:47:08 -07003313 if cc.IsLlndk() {
3314 return false
3315 }
Colin Crossaac32222020-07-29 12:51:56 -07003316 if isLibDepTag && c.static() && libDepTag.shared() {
Colin Cross6e511a92020-07-27 21:26:48 -07003317 // shared_lib dependency from a static lib is considered as crossing
3318 // the APEX boundary because the dependency doesn't actually is
3319 // linked; the dependency is used only during the compilation phase.
3320 return false
3321 }
Jiyong Parke3867542020-12-03 17:28:25 +09003322
3323 if isLibDepTag && libDepTag.excludeInApex {
3324 return false
3325 }
Colin Cross6e511a92020-07-27 21:26:48 -07003326 }
Colin Crossc1b36442021-05-06 13:42:48 -07003327 if depTag == stubImplDepTag {
3328 // We don't track from an implementation library to its stubs.
Jiyong Park7d95a512020-05-10 15:16:24 +09003329 return false
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003330 }
Jiyong Park12177fc2021-01-05 14:37:15 +09003331 if depTag == staticVariantTag {
3332 // This dependency is for optimization (reuse *.o from the static lib). It doesn't
3333 // actually mean that the static lib (and its dependencies) are copied into the
3334 // APEX.
3335 return false
3336 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003337 return true
3338}
3339
Jiyong Park45bf82e2020-12-15 22:29:02 +09003340// Implements android.ApexModule
Dan Albertc8060532020-07-22 22:32:17 -07003341func (c *Module) ShouldSupportSdkVersion(ctx android.BaseModuleContext,
3342 sdkVersion android.ApiLevel) error {
Jooyung Han749dc692020-04-15 11:03:39 +09003343 // We ignore libclang_rt.* prebuilt libs since they declare sdk_version: 14(b/121358700)
3344 if strings.HasPrefix(ctx.OtherModuleName(c), "libclang_rt") {
3345 return nil
3346 }
3347 // b/154569636: set min_sdk_version correctly for toolchain_libraries
3348 if c.ToolchainLibrary() {
3349 return nil
3350 }
3351 // We don't check for prebuilt modules
3352 if _, ok := c.linker.(prebuiltLinkerInterface); ok {
3353 return nil
3354 }
3355 minSdkVersion := c.MinSdkVersion()
3356 if minSdkVersion == "apex_inherit" {
3357 return nil
3358 }
3359 if minSdkVersion == "" {
3360 // JNI libs within APK-in-APEX fall into here
3361 // Those are okay to set sdk_version instead
3362 // We don't have to check if this is a SDK variant because
3363 // non-SDK variant resets sdk_version, which works too.
3364 minSdkVersion = c.SdkVersion()
3365 }
Dan Albertc8060532020-07-22 22:32:17 -07003366 if minSdkVersion == "" {
3367 return fmt.Errorf("neither min_sdk_version nor sdk_version specificed")
3368 }
3369 // Not using nativeApiLevelFromUser because the context here is not
3370 // necessarily a native context.
3371 ver, err := android.ApiLevelFromUser(ctx, minSdkVersion)
Jooyung Han749dc692020-04-15 11:03:39 +09003372 if err != nil {
3373 return err
3374 }
Dan Albertc8060532020-07-22 22:32:17 -07003375
3376 if ver.GreaterThan(sdkVersion) {
Jooyung Han749dc692020-04-15 11:03:39 +09003377 return fmt.Errorf("newer SDK(%v)", ver)
3378 }
3379 return nil
3380}
3381
Paul Duffinb5769c12021-05-12 16:16:51 +01003382// Implements android.ApexModule
3383func (c *Module) AlwaysRequiresPlatformApexVariant() bool {
3384 // stub libraries and native bridge libraries are always available to platform
3385 return c.IsStubs() || c.Target().NativeBridge == android.NativeBridgeEnabled
3386}
3387
Colin Cross2ba19d92015-05-07 15:44:20 -07003388//
Colin Crosscfad1192015-11-02 16:43:11 -08003389// Defaults
3390//
Colin Crossca860ac2016-01-04 14:34:37 -08003391type Defaults struct {
Colin Cross635c3b02016-05-18 15:37:25 -07003392 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -07003393 android.DefaultsModuleBase
Liz Kammer3cf52112021-03-31 15:42:03 -04003394 // Included to support setting bazel_module.label for multiple Soong modules to the same Bazel
3395 // target. This is primarily useful for modules that were architecture specific and instead are
3396 // handled in Bazel as a select().
3397 android.BazelModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +09003398 android.ApexModuleBase
Colin Crosscfad1192015-11-02 16:43:11 -08003399}
3400
Patrice Arrudac249c712019-03-19 17:00:29 -07003401// cc_defaults provides a set of properties that can be inherited by other cc
3402// modules. A module can use the properties from a cc_defaults using
3403// `defaults: ["<:default_module_name>"]`. Properties of both modules are
3404// merged (when possible) by prepending the default module's values to the
3405// depending module's values.
Colin Cross36242852017-06-23 15:06:31 -07003406func defaultsFactory() android.Module {
Colin Crosse1d764e2016-08-18 14:18:32 -07003407 return DefaultsFactory()
3408}
3409
Colin Cross36242852017-06-23 15:06:31 -07003410func DefaultsFactory(props ...interface{}) android.Module {
Colin Crossca860ac2016-01-04 14:34:37 -08003411 module := &Defaults{}
Colin Crosscfad1192015-11-02 16:43:11 -08003412
Colin Cross36242852017-06-23 15:06:31 -07003413 module.AddProperties(props...)
3414 module.AddProperties(
Colin Crossca860ac2016-01-04 14:34:37 -08003415 &BaseProperties{},
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003416 &VendorProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003417 &BaseCompilerProperties{},
3418 &BaseLinkerProperties{},
Paul Duffina37832a2019-07-18 12:31:26 +01003419 &ObjectLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003420 &LibraryProperties{},
Colin Crosse1bb5d02019-09-24 14:55:04 -07003421 &StaticProperties{},
3422 &SharedProperties{},
Colin Cross919281a2016-04-05 16:42:05 -07003423 &FlagExporterProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003424 &BinaryLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003425 &TestProperties{},
3426 &TestBinaryProperties{},
Colin Cross43287652020-06-30 10:15:07 -07003427 &BenchmarkProperties{},
Mitch Phillips4e4ab8a2019-09-13 17:32:50 -07003428 &FuzzProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003429 &StlProperties{},
Colin Cross16b23492016-01-06 14:41:07 -08003430 &SanitizeProperties{},
Colin Cross665dce92016-04-28 14:50:03 -07003431 &StripProperties{},
Dan Willemsen7424d612016-09-01 13:45:39 -07003432 &InstallerProperties{},
Dan Willemsena03cf6d2016-09-26 15:45:04 -07003433 &TidyProperties{},
Dan Willemsen581341d2017-02-09 16:16:31 -08003434 &CoverageProperties{},
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08003435 &SAbiProperties{},
Justin Yun4b2382f2017-07-26 14:22:10 +09003436 &VndkProperties{},
Stephen Craneba090d12017-05-09 15:44:35 -07003437 &LTOProperties{},
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07003438 &PgoProperties{},
Dan Willemsen6424d172018-03-08 13:27:59 -08003439 &android.ProtoProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -04003440 // RustBindgenProperties is included here so that cc_defaults can be used for rust_bindgen modules.
3441 &RustBindgenClangProperties{},
Colin Crosse1d764e2016-08-18 14:18:32 -07003442 )
Colin Crosscfad1192015-11-02 16:43:11 -08003443
Liz Kammer3cf52112021-03-31 15:42:03 -04003444 // Bazel module must be initialized _before_ Defaults to be included in cc_defaults module.
3445 android.InitBazelModule(module)
Jooyung Hancc372c52019-09-25 15:18:44 +09003446 android.InitDefaultsModule(module)
Colin Cross36242852017-06-23 15:06:31 -07003447
3448 return module
Colin Crosscfad1192015-11-02 16:43:11 -08003449}
3450
Jiyong Park2286afd2020-06-16 21:58:53 +09003451func (c *Module) IsSdkVariant() bool {
Lukacs T. Berki2063a0d2021-06-17 09:32:36 +02003452 return c.Properties.IsSdkVariant
Jiyong Park2286afd2020-06-16 21:58:53 +09003453}
3454
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003455func kytheExtractAllFactory() android.Singleton {
3456 return &kytheExtractAllSingleton{}
3457}
3458
3459type kytheExtractAllSingleton struct {
3460}
3461
3462func (ks *kytheExtractAllSingleton) GenerateBuildActions(ctx android.SingletonContext) {
3463 var xrefTargets android.Paths
3464 ctx.VisitAllModules(func(module android.Module) {
3465 if ccModule, ok := module.(xref); ok {
3466 xrefTargets = append(xrefTargets, ccModule.XrefCcFiles()...)
3467 }
3468 })
3469 // TODO(asmundak): Perhaps emit a rule to output a warning if there were no xrefTargets
3470 if len(xrefTargets) > 0 {
Colin Crossc3d87d32020-06-04 13:25:17 -07003471 ctx.Phony("xref_cxx", xrefTargets...)
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003472 }
3473}
3474
Colin Cross06a931b2015-10-28 17:23:31 -07003475var Bool = proptools.Bool
Colin Cross38b40df2018-04-10 16:14:46 -07003476var BoolDefault = proptools.BoolDefault
Nan Zhang0007d812017-11-07 10:57:05 -08003477var BoolPtr = proptools.BoolPtr
3478var String = proptools.String
3479var StringPtr = proptools.StringPtr