blob: 12db7975af48b79a1851ca2f143efec32d80440c [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
Aditya Choudhary87b2ab22023-11-17 15:27:06 +000027 "android/soong/testing"
Colin Cross97ba0732015-03-23 17:50:24 -070028 "github.com/google/blueprint"
Colin Cross06a931b2015-10-28 17:23:31 -070029 "github.com/google/blueprint/proptools"
Colin Cross97ba0732015-03-23 17:50:24 -070030
Yu Liueae7b362023-11-16 17:05:47 -080031 "android/soong/aconfig"
Vinh Tran367d89d2023-04-28 11:21:25 -040032 "android/soong/aidl_library"
Colin Cross635c3b02016-05-18 15:37:25 -070033 "android/soong/android"
Colin Crossb98c8b02016-07-29 13:44:28 -070034 "android/soong/cc/config"
hamzehc0a671f2021-07-22 12:05:08 -070035 "android/soong/fuzz"
Colin Cross5049f022015-03-18 13:28:46 -070036 "android/soong/genrule"
Kiyoung Kim487689e2022-07-26 09:48:22 +090037 "android/soong/multitree"
Rob Seymour925aa092021-08-10 20:42:03 +000038 "android/soong/snapshot"
Colin Cross3f40fa42015-01-30 17:27:36 -080039)
40
Colin Cross463a90e2015-06-17 14:20:06 -070041func init() {
Paul Duffin036e7002019-12-19 19:16:28 +000042 RegisterCCBuildComponents(android.InitRegistrationContext)
Colin Cross463a90e2015-06-17 14:20:06 -070043
Inseob Kim3b244062023-07-11 13:31:36 +090044 pctx.Import("android/soong/android")
Paul Duffin036e7002019-12-19 19:16:28 +000045 pctx.Import("android/soong/cc/config")
46}
47
48func RegisterCCBuildComponents(ctx android.RegistrationContext) {
49 ctx.RegisterModuleType("cc_defaults", defaultsFactory)
50
51 ctx.PreDepsMutators(func(ctx android.RegisterMutatorsContext) {
Colin Crossc511bc52020-04-07 16:50:32 +000052 ctx.BottomUp("sdk", sdkMutator).Parallel()
Inseob Kim64c43952019-08-26 16:52:35 +090053 ctx.BottomUp("vndk", VndkMutator).Parallel()
Colin Crosse40b4ea2018-10-02 22:25:58 -070054 ctx.BottomUp("link", LinkageMutator).Parallel()
Roland Levillain9b5fde92019-06-28 15:41:19 +010055 ctx.BottomUp("test_per_src", TestPerSrcMutator).Parallel()
Colin Crossd1f898e2020-08-18 18:35:15 -070056 ctx.BottomUp("version", versionMutator).Parallel()
Colin Crosse40b4ea2018-10-02 22:25:58 -070057 ctx.BottomUp("begin", BeginMutator).Parallel()
Vinh Tran44cb78c2023-03-09 22:07:19 -050058 ctx.BottomUp("fdo_profile", fdoProfileMutator)
Colin Cross1e676be2016-10-12 14:38:15 -070059 })
Colin Cross16b23492016-01-06 14:41:07 -080060
Paul Duffin036e7002019-12-19 19:16:28 +000061 ctx.PostDepsMutators(func(ctx android.RegisterMutatorsContext) {
Liz Kammer75db9312021-07-07 16:41:50 -040062 for _, san := range Sanitizers {
63 san.registerMutators(ctx)
64 }
Dan Willemsen581341d2017-02-09 16:16:31 -080065
Colin Cross0b908332019-06-19 23:00:20 -070066 ctx.TopDown("sanitize_runtime_deps", sanitizerRuntimeDepsMutator).Parallel()
Jiyong Park379de2f2018-12-19 02:47:14 +090067 ctx.BottomUp("sanitize_runtime", sanitizerRuntimeMutator).Parallel()
Ivan Lozano30c5db22018-02-21 15:49:20 -080068
Cory Barkera1da26f2022-06-07 20:12:06 +000069 ctx.TopDown("fuzz_deps", fuzzMutatorDeps)
Cory Barkera1da26f2022-06-07 20:12:06 +000070
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -080071 ctx.BottomUp("coverage", coverageMutator).Parallel()
Stephen Craneba090d12017-05-09 15:44:35 -070072
Yi Kongeb8efc92021-12-09 18:06:29 +080073 ctx.TopDown("afdo_deps", afdoDepsMutator)
74 ctx.BottomUp("afdo", afdoMutator).Parallel()
75
Sharjeel Khanc6a93d82023-07-18 21:01:11 +000076 ctx.TopDown("orderfile_deps", orderfileDepsMutator)
77 ctx.BottomUp("orderfile", orderfileMutator).Parallel()
78
Stephen Craneba090d12017-05-09 15:44:35 -070079 ctx.TopDown("lto_deps", ltoDepsMutator)
80 ctx.BottomUp("lto", ltoMutator).Parallel()
Jooyung Hana70f0672019-01-18 15:20:43 +090081
Jooyung Han479ca172020-10-19 18:51:07 +090082 ctx.BottomUp("check_linktype", checkLinkTypeMutator).Parallel()
Jooyung Hana70f0672019-01-18 15:20:43 +090083 ctx.TopDown("double_loadable", checkDoubleLoadableLibraries).Parallel()
Colin Cross1e676be2016-10-12 14:38:15 -070084 })
Colin Crossb98c8b02016-07-29 13:44:28 -070085
Yo Chiang8aa4e3f2020-11-19 16:30:49 +080086 ctx.FinalDepsMutators(func(ctx android.RegisterMutatorsContext) {
87 // sabi mutator needs to be run after apex mutator finishes.
88 ctx.TopDown("sabi_deps", sabiDepsMutator)
89 })
90
LaMont Jones0c10e4d2023-05-16 00:58:37 +000091 ctx.RegisterParallelSingletonType("kythe_extract_all", kytheExtractAllFactory)
Colin Cross463a90e2015-06-17 14:20:06 -070092}
93
Chris Parsonsef6e0cf2020-12-01 18:26:21 -050094// Deps is a struct containing module names of dependencies, separated by the kind of dependency.
95// Mutators should use `AddVariationDependencies` or its sibling methods to add actual dependency
96// edges to these modules.
97// This object is constructed in DepsMutator, by calling to various module delegates to set
98// relevant fields. For example, `module.compiler.compilerDeps()` may append type-specific
99// dependencies.
100// This is then consumed by the same DepsMutator, which will call `ctx.AddVariationDependencies()`
101// (or its sibling methods) to set real dependencies on the given modules.
Colin Crossca860ac2016-01-04 14:34:37 -0800102type Deps struct {
103 SharedLibs, LateSharedLibs []string
104 StaticLibs, LateStaticLibs, WholeStaticLibs []string
Colin Cross5950f382016-12-13 12:50:57 -0800105 HeaderLibs []string
Logan Chien43d34c32017-12-20 01:17:32 +0800106 RuntimeLibs []string
Colin Crossc472d572015-03-17 15:06:21 -0700107
Colin Cross3e5e7782022-06-17 22:17:05 +0000108 // UnexportedStaticLibs are static libraries that are also passed to -Wl,--exclude-libs= to
109 // prevent automatically exporting symbols.
110 UnexportedStaticLibs []string
111
Chris Parsons79d66a52020-06-05 17:26:16 -0400112 // Used for data dependencies adjacent to tests
113 DataLibs []string
Colin Crossc8caa062021-09-24 16:50:14 -0700114 DataBins []string
Chris Parsons79d66a52020-06-05 17:26:16 -0400115
Yo Chiang219968c2020-09-22 18:45:04 +0800116 // Used by DepsMutator to pass system_shared_libs information to check_elf_file.py.
117 SystemSharedLibs []string
118
Vinh Tran367d89d2023-04-28 11:21:25 -0400119 // Used by DepMutator to pass aidl_library modules to aidl compiler
120 AidlLibs []string
121
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500122 // If true, statically link the unwinder into native libraries/binaries.
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800123 StaticUnwinderIfLegacy bool
124
Colin Cross5950f382016-12-13 12:50:57 -0800125 ReexportSharedLibHeaders, ReexportStaticLibHeaders, ReexportHeaderLibHeaders []string
Dan Willemsen490a8dc2016-06-06 18:22:19 -0700126
Colin Cross81413472016-04-11 14:37:39 -0700127 ObjFiles []string
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700128
Dan Willemsenb40aab62016-04-20 14:21:14 -0700129 GeneratedSources []string
130 GeneratedHeaders []string
Inseob Kimd110f872019-12-06 13:15:38 +0900131 GeneratedDeps []string
Dan Willemsenb40aab62016-04-20 14:21:14 -0700132
Dan Willemsenb3454ab2016-09-28 17:34:58 -0700133 ReexportGeneratedHeaders []string
134
Colin Crossc465efd2021-06-11 18:00:04 -0700135 CrtBegin, CrtEnd []string
Dan Willemsena0790e32018-10-12 00:24:23 -0700136
137 // Used for host bionic
Colin Cross9cfe6112021-06-11 18:02:22 -0700138 DynamicLinker string
Jiyong Parke3867542020-12-03 17:28:25 +0900139
140 // List of libs that need to be excluded for APEX variant
141 ExcludeLibsForApex []string
Jooyung Han9ffbe832023-11-28 22:31:35 +0900142 // List of libs that need to be excluded for non-APEX variant
143 ExcludeLibsForNonApex []string
Colin Crossc472d572015-03-17 15:06:21 -0700144}
145
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500146// PathDeps is a struct containing file paths to dependencies of a module.
147// It's constructed in depsToPath() by traversing the direct dependencies of the current module.
148// It's used to construct flags for various build statements (such as for compiling and linking).
149// It is then passed to module decorator functions responsible for registering build statements
150// (such as `module.compiler.compile()`).`
Colin Crossca860ac2016-01-04 14:34:37 -0800151type PathDeps struct {
Colin Cross26c34ed2016-09-30 17:10:16 -0700152 // Paths to .so files
Jiyong Park64a44f22019-01-18 14:37:08 +0900153 SharedLibs, EarlySharedLibs, LateSharedLibs android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700154 // Paths to the dependencies to use for .so files (.so.toc files)
Jiyong Park64a44f22019-01-18 14:37:08 +0900155 SharedLibsDeps, EarlySharedLibsDeps, LateSharedLibsDeps android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700156 // Paths to .a files
Colin Cross635c3b02016-05-18 15:37:25 -0700157 StaticLibs, LateStaticLibs, WholeStaticLibs android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700158
Colin Cross0de8a1e2020-09-18 14:15:30 -0700159 // Transitive static library dependencies of static libraries for use in ordering.
Colin Crossc85750b2022-04-21 12:50:51 -0700160 TranstiveStaticLibrariesForOrdering *android.DepSet[android.Path]
Colin Cross0de8a1e2020-09-18 14:15:30 -0700161
Colin Cross26c34ed2016-09-30 17:10:16 -0700162 // Paths to .o files
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100163 Objs Objects
164 // Paths to .o files in dependencies that provide them. Note that these lists
165 // aren't complete since prebuilt modules don't provide the .o files.
Dan Willemsen581341d2017-02-09 16:16:31 -0800166 StaticLibObjs Objects
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700167 WholeStaticLibObjs Objects
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700168
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100169 // Paths to .a files in prebuilts. Complements WholeStaticLibObjs to contain
170 // the libs from all whole_static_lib dependencies.
171 WholeStaticLibsFromPrebuilts android.Paths
172
Colin Cross26c34ed2016-09-30 17:10:16 -0700173 // Paths to generated source files
Colin Cross635c3b02016-05-18 15:37:25 -0700174 GeneratedSources android.Paths
Inseob Kimd110f872019-12-06 13:15:38 +0900175 GeneratedDeps android.Paths
Dan Willemsenb40aab62016-04-20 14:21:14 -0700176
Inseob Kimd110f872019-12-06 13:15:38 +0900177 Flags []string
Colin Cross3e5e7782022-06-17 22:17:05 +0000178 LdFlags []string
Inseob Kimd110f872019-12-06 13:15:38 +0900179 IncludeDirs android.Paths
180 SystemIncludeDirs android.Paths
181 ReexportedDirs android.Paths
182 ReexportedSystemDirs android.Paths
183 ReexportedFlags []string
184 ReexportedGeneratedHeaders android.Paths
185 ReexportedDeps android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700186
Colin Cross26c34ed2016-09-30 17:10:16 -0700187 // Paths to crt*.o files
Colin Crossc465efd2021-06-11 18:00:04 -0700188 CrtBegin, CrtEnd android.Paths
Dan Willemsena0790e32018-10-12 00:24:23 -0700189
Dan Willemsena0790e32018-10-12 00:24:23 -0700190 // Path to the dynamic linker binary
191 DynamicLinker android.OptionalPath
Dan Willemsen47450072021-10-19 20:24:49 -0700192
193 // For Darwin builds, the path to the second architecture's output that should
194 // be combined with this architectures's output into a FAT MachO file.
195 DarwinSecondArchOutput android.OptionalPath
Vinh Tran367d89d2023-04-28 11:21:25 -0400196
197 // Paths to direct srcs and transitive include dirs from direct aidl_library deps
198 AidlLibraryInfos []aidl_library.AidlLibraryInfo
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700199}
200
Colin Cross4af21ed2019-11-04 09:37:55 -0800201// LocalOrGlobalFlags contains flags that need to have values set globally by the build system or locally by the module
202// tracked separately, in order to maintain the required ordering (most of the global flags need to go first on the
203// command line so they can be overridden by the local module flags).
204type LocalOrGlobalFlags struct {
205 CommonFlags []string // Flags that apply to C, C++, and assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700206 AsFlags []string // Flags that apply to assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800207 YasmFlags []string // Flags that apply to yasm assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700208 CFlags []string // Flags that apply to C and C++ source files
209 ToolingCFlags []string // Flags that apply to C and C++ source files parsed by clang LibTooling tools
210 ConlyFlags []string // Flags that apply to C source files
211 CppFlags []string // Flags that apply to C++ source files
212 ToolingCppFlags []string // Flags that apply to C++ source files parsed by clang LibTooling tools
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700213 LdFlags []string // Flags that apply to linker command lines
Colin Cross4af21ed2019-11-04 09:37:55 -0800214}
215
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500216// Flags contains various types of command line flags (and settings) for use in building build
217// statements related to C++.
Colin Cross4af21ed2019-11-04 09:37:55 -0800218type Flags struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500219 // Local flags (which individual modules are responsible for). These may override global flags.
220 Local LocalOrGlobalFlags
221 // Global flags (which build system or toolchain is responsible for).
Colin Cross4af21ed2019-11-04 09:37:55 -0800222 Global LocalOrGlobalFlags
223
224 aidlFlags []string // Flags that apply to aidl source files
225 rsFlags []string // Flags that apply to renderscript source files
226 libFlags []string // Flags to add libraries early to the link order
227 extraLibFlags []string // Flags to add libraries late in the link order after LdFlags
228 TidyFlags []string // Flags that apply to clang-tidy
229 SAbiFlags []string // Flags that apply to header-abi-dumper
Colin Cross28344522015-04-22 13:07:53 -0700230
Colin Crossc3199482017-03-30 15:03:04 -0700231 // Global include flags that apply to C, C++, and assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800232 // These must be after any module include flags, which will be in CommonFlags.
Colin Crossc3199482017-03-30 15:03:04 -0700233 SystemIncludeFlags []string
234
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800235 Toolchain config.Toolchain
236 Tidy bool // True if ninja .tidy rules should be generated.
237 NeedTidyFiles bool // True if module link should depend on .tidy files
238 GcovCoverage bool // True if coverage files should be generated.
239 SAbiDump bool // True if header abi dumps should be generated.
240 EmitXrefs bool // If true, generate Ninja rules to generate emitXrefs input files for Kythe
Colin Crossca860ac2016-01-04 14:34:37 -0800241
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500242 // The instruction set required for clang ("arm" or "thumb").
Colin Crossca860ac2016-01-04 14:34:37 -0800243 RequiredInstructionSet string
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500244 // The target-device system path to the dynamic linker.
245 DynamicLinker string
Colin Cross16b23492016-01-06 14:41:07 -0800246
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700247 CFlagsDeps android.Paths // Files depended on by compiler flags
248 LdFlagsDeps android.Paths // Files depended on by linker flags
Colin Cross18c0c5a2016-12-01 14:45:23 -0800249
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500250 // True if .s files should be processed with the c preprocessor.
Dan Willemsen98ab3112019-08-27 21:20:40 -0700251 AssemblerWithCpp bool
Dan Willemsen60e62f02018-11-16 21:05:32 -0800252
Colin Cross19878da2019-03-28 14:45:07 -0700253 proto android.ProtoFlags
Colin Cross19878da2019-03-28 14:45:07 -0700254 protoC bool // Whether to use C instead of C++
255 protoOptionsFile bool // Whether to look for a .options file next to the .proto
Dan Willemsen4e0aa232019-04-10 22:59:54 -0700256
257 Yacc *YaccProperties
Matthias Maennich22fd4d12020-07-15 10:58:56 +0200258 Lex *LexProperties
Colin Crossc472d572015-03-17 15:06:21 -0700259}
260
Colin Crossca860ac2016-01-04 14:34:37 -0800261// Properties used to compile all C or C++ modules
262type BaseProperties struct {
Dan Willemsen742a5452018-07-23 17:19:36 -0700263 // Deprecated. true is the default, false is invalid.
Colin Crossca860ac2016-01-04 14:34:37 -0800264 Clang *bool `android:"arch_variant"`
Colin Cross7d5136f2015-05-11 13:39:40 -0700265
Jiyong Parkb35a8192020-08-10 15:59:36 +0900266 // The API level that this module is built against. The APIs of this API level will be
267 // visible at build time, but use of any APIs newer than min_sdk_version will render the
268 // module unloadable on older devices. In the future it will be possible to weakly-link new
269 // APIs, making the behavior match Java: such modules will load on older devices, but
270 // calling new APIs on devices that do not support them will result in a crash.
271 //
272 // This property has the same behavior as sdk_version does for Java modules. For those
273 // familiar with Android Gradle, the property behaves similarly to how compileSdkVersion
274 // does for Java code.
275 //
276 // In addition, setting this property causes two variants to be built, one for the platform
277 // and one for apps.
Nan Zhang0007d812017-11-07 10:57:05 -0800278 Sdk_version *string
Colin Cross7d5136f2015-05-11 13:39:40 -0700279
Jiyong Parkb35a8192020-08-10 15:59:36 +0900280 // Minimum OS API level supported by this C or C++ module. This property becomes the value
281 // of the __ANDROID_API__ macro. When the C or C++ module is included in an APEX or an APK,
282 // this property is also used to ensure that the min_sdk_version of the containing module is
283 // not older (i.e. less) than this module's min_sdk_version. When not set, this property
284 // defaults to the value of sdk_version. When this is set to "apex_inherit", this tracks
285 // min_sdk_version of the containing APEX. When the module
286 // is not built for an APEX, "apex_inherit" defaults to sdk_version.
Jooyung Han379660c2020-04-21 15:24:00 +0900287 Min_sdk_version *string
288
Colin Crossc511bc52020-04-07 16:50:32 +0000289 // If true, always create an sdk variant and don't create a platform variant.
290 Sdk_variant_only *bool
291
Jiyong Parkde866cb2018-12-07 23:08:36 +0900292 AndroidMkSharedLibs []string `blueprint:"mutated"`
293 AndroidMkStaticLibs []string `blueprint:"mutated"`
294 AndroidMkRuntimeLibs []string `blueprint:"mutated"`
295 AndroidMkWholeStaticLibs []string `blueprint:"mutated"`
Bill Peckhama46de702020-04-21 17:23:37 -0700296 AndroidMkHeaderLibs []string `blueprint:"mutated"`
Jiyong Parkde866cb2018-12-07 23:08:36 +0900297 HideFromMake bool `blueprint:"mutated"`
298 PreventInstall bool `blueprint:"mutated"`
299 ApexesProvidingSharedLibs []string `blueprint:"mutated"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700300
Yo Chiang219968c2020-09-22 18:45:04 +0800301 // Set by DepsMutator.
302 AndroidMkSystemSharedLibs []string `blueprint:"mutated"`
303
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200304 // The name of the image this module is built for, suffixed with a '.'
Justin Yun5f7f7e82019-11-18 19:52:14 +0900305 ImageVariationPrefix string `blueprint:"mutated"`
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200306
307 // The VNDK version this module is built against. If empty, the module is not
308 // build against the VNDK.
309 VndkVersion string `blueprint:"mutated"`
310
311 // Suffix for the name of Android.mk entries generated by this module
312 SubName string `blueprint:"mutated"`
Colin Cross5beccee2017-12-07 15:28:59 -0800313
314 // *.logtags files, to combine together in order to generate the /system/etc/event-log-tags
315 // file
316 Logtags []string
Jiyong Parkf9332f12018-02-01 00:54:12 +0900317
Yifan Hong39143a92020-10-26 12:43:12 -0700318 // Make this module available when building for ramdisk.
319 // On device without a dedicated recovery partition, the module is only
320 // available after switching root into
321 // /first_stage_ramdisk. To expose the module before switching root, install
322 // the recovery variant instead.
Yifan Hong1b3348d2020-01-21 15:53:22 -0800323 Ramdisk_available *bool
324
Yifan Hong39143a92020-10-26 12:43:12 -0700325 // Make this module available when building for vendor ramdisk.
326 // On device without a dedicated recovery partition, the module is only
327 // available after switching root into
328 // /first_stage_ramdisk. To expose the module before switching root, install
329 // the recovery variant instead.
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700330 Vendor_ramdisk_available *bool
331
Jiyong Parkf9332f12018-02-01 00:54:12 +0900332 // Make this module available when building for recovery
333 Recovery_available *bool
334
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200335 // Used by imageMutator, set by ImageMutatorBegin()
336 CoreVariantNeeded bool `blueprint:"mutated"`
337 RamdiskVariantNeeded bool `blueprint:"mutated"`
338 VendorRamdiskVariantNeeded bool `blueprint:"mutated"`
339 RecoveryVariantNeeded bool `blueprint:"mutated"`
340
341 // A list of variations for the "image" mutator of the form
342 //<image name> '.' <version char>, for example, 'vendor.S'
343 ExtraVersionedImageVariations []string `blueprint:"mutated"`
Jiyong Parkb0788572018-12-20 22:10:17 +0900344
345 // Allows this module to use non-APEX version of libraries. Useful
346 // for building binaries that are started before APEXes are activated.
347 Bootstrap *bool
Jooyung Han097087b2019-10-22 19:32:18 +0900348
349 // Even if DeviceConfig().VndkUseCoreVariant() is set, this module must use vendor variant.
350 // see soong/cc/config/vndk.go
351 MustUseVendorVariant bool `blueprint:"mutated"`
Inseob Kim8471cda2019-11-15 09:59:12 +0900352
353 // Used by vendor snapshot to record dependencies from snapshot modules.
354 SnapshotSharedLibs []string `blueprint:"mutated"`
Justin Yun5e035862021-06-29 20:50:37 +0900355 SnapshotStaticLibs []string `blueprint:"mutated"`
Inseob Kim8471cda2019-11-15 09:59:12 +0900356 SnapshotRuntimeLibs []string `blueprint:"mutated"`
Paul Duffin0cb37b92020-03-04 14:52:46 +0000357
Colin Cross1bc94122021-10-28 13:25:54 -0700358 Installable *bool `android:"arch_variant"`
Colin Crossc511bc52020-04-07 16:50:32 +0000359
360 // Set by factories of module types that can only be referenced from variants compiled against
361 // the SDK.
362 AlwaysSdk bool `blueprint:"mutated"`
363
364 // Variant is an SDK variant created by sdkMutator
365 IsSdkVariant bool `blueprint:"mutated"`
366 // Set when both SDK and platform variants are exported to Make to trigger renaming the SDK
367 // variant to have a ".sdk" suffix.
368 SdkAndPlatformVariantVisibleToMake bool `blueprint:"mutated"`
Bill Peckham945441c2020-08-31 16:07:58 -0700369
370 // Normally Soong uses the directory structure to decide which modules
371 // should be included (framework) or excluded (non-framework) from the
Jose Galmes6f843bc2020-12-11 13:36:29 -0800372 // different snapshots (vendor, recovery, etc.), but this property
373 // allows a partner to exclude a module normally thought of as a
374 // framework module from the vendor snapshot.
375 Exclude_from_vendor_snapshot *bool
376
377 // Normally Soong uses the directory structure to decide which modules
378 // should be included (framework) or excluded (non-framework) from the
379 // different snapshots (vendor, recovery, etc.), but this property
380 // allows a partner to exclude a module normally thought of as a
381 // framework module from the recovery snapshot.
Jose Galmesf7294582020-11-13 12:07:36 -0800382 Exclude_from_recovery_snapshot *bool
Jiyong Park46a512f2020-12-04 18:02:13 +0900383
384 // List of APEXes that this module has private access to for testing purpose. The module
385 // can depend on libraries that are not exported by the APEXes and use private symbols
386 // from the exported libraries.
Martin Stjernholm855e90b2021-03-25 02:33:14 +0000387 Test_for []string `android:"arch_variant"`
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800388
389 Target struct {
390 Platform struct {
391 // List of modules required by the core variant.
392 Required []string `android:"arch_variant"`
393
394 // List of modules not required by the core variant.
395 Exclude_required []string `android:"arch_variant"`
396 } `android:"arch_variant"`
397
398 Recovery struct {
399 // List of modules required by the recovery variant.
400 Required []string `android:"arch_variant"`
401
402 // List of modules not required by the recovery variant.
403 Exclude_required []string `android:"arch_variant"`
404 } `android:"arch_variant"`
405 } `android:"arch_variant"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700406}
407
408type VendorProperties struct {
Jiyong Park82e2bf32017-08-16 14:05:54 +0900409 // whether this module should be allowed to be directly depended by other
410 // modules with `vendor: true`, `proprietary: true`, or `vendor_available:true`.
Justin Yun63e9ec72020-10-29 16:49:43 +0900411 // If set to true, two variants will be built separately, one like
412 // normal, and the other limited to the set of libraries and headers
413 // that are exposed to /vendor modules.
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700414 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900415 // The vendor variant may be used with a different (newer) /system,
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700416 // so it shouldn't have any unversioned runtime dependencies, or
417 // make assumptions about the system that may not be true in the
418 // future.
419 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900420 // If set to false, this module becomes inaccessible from /vendor modules.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900421 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900422 // The modules with vndk: {enabled: true} must define 'vendor_available'
Justin Yun0b1db6d2021-01-08 15:22:34 +0900423 // to 'true'.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900424 //
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700425 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
426 Vendor_available *bool
Jiyong Park5fb8c102018-04-09 12:03:06 +0900427
Justin Yunebcf0c52021-01-08 18:00:19 +0900428 // This is the same as the "vendor_available" except that the install path
429 // of the vendor variant is /odm or /vendor/odm.
430 // By replacing "vendor_available: true" with "odm_available: true", the
431 // module will install its vendor variant to the /odm partition or /vendor/odm.
432 // As the modules with "odm_available: true" still create the vendor variants,
433 // they can link to the other vendor modules as the vendor_available modules do.
434 // Also, the vendor modules can link to odm_available modules.
435 //
436 // It may not be used for VNDK modules.
437 Odm_available *bool
438
Justin Yun63e9ec72020-10-29 16:49:43 +0900439 // whether this module should be allowed to be directly depended by other
440 // modules with `product_specific: true` or `product_available: true`.
441 // If set to true, an additional product variant will be built separately
442 // that is limited to the set of libraries and headers that are exposed to
443 // /product modules.
444 //
445 // The product variant may be used with a different (newer) /system,
446 // so it shouldn't have any unversioned runtime dependencies, or
447 // make assumptions about the system that may not be true in the
448 // future.
449 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900450 // If set to false, this module becomes inaccessible from /product modules.
451 //
452 // Different from the 'vendor_available' property, the modules with
453 // vndk: {enabled: true} don't have to define 'product_available'. The VNDK
454 // library without 'product_available' may not be depended on by any other
455 // modules that has product variants including the product available VNDKs.
Justin Yun63e9ec72020-10-29 16:49:43 +0900456 //
457 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
458 // and PRODUCT_PRODUCT_VNDK_VERSION isn't set.
459 Product_available *bool
460
Jiyong Park5fb8c102018-04-09 12:03:06 +0900461 // whether this module is capable of being loaded with other instance
462 // (possibly an older version) of the same module in the same process.
463 // Currently, a shared library that is a member of VNDK (vndk: {enabled: true})
464 // can be double loaded in a vendor process if the library is also a
465 // (direct and indirect) dependency of an LLNDK library. Such libraries must be
466 // explicitly marked as `double_loadable: true` by the owner, or the dependency
467 // from the LLNDK lib should be cut if the lib is not designed to be double loaded.
468 Double_loadable *bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800469
470 // IsLLNDK is set to true for the vendor variant of a cc_library module that has LLNDK stubs.
471 IsLLNDK bool `blueprint:"mutated"`
472
Colin Cross78212242021-01-06 14:51:30 -0800473 // IsVNDKUsingCoreVariant is true for VNDK modules if the global VndkUseCoreVariant option is
474 // set and the module is not listed in VndkMustUseVendorVariantList.
475 IsVNDKUsingCoreVariant bool `blueprint:"mutated"`
476
477 // IsVNDKCore is set if a VNDK module does not set the vndk.support_system_process property.
478 IsVNDKCore bool `blueprint:"mutated"`
479
480 // IsVNDKSP is set if a VNDK module sets the vndk.support_system_process property.
481 IsVNDKSP bool `blueprint:"mutated"`
482
483 // IsVNDKPrivate is set if a VNDK module sets the vndk.private property or an LLNDK
484 // module sets the llndk.private property.
485 IsVNDKPrivate bool `blueprint:"mutated"`
486
487 // IsVNDKProduct is set if a VNDK module sets the product_available property.
488 IsVNDKProduct bool `blueprint:"mutated"`
Colin Cross5271fea2021-04-27 13:06:04 -0700489
490 // IsVendorPublicLibrary is set for the core and product variants of a library that has
491 // vendor_public_library stubs.
492 IsVendorPublicLibrary bool `blueprint:"mutated"`
Colin Crossca860ac2016-01-04 14:34:37 -0800493}
494
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500495// ModuleContextIntf is an interface (on a module context helper) consisting of functions related
496// to understanding details about the type of the current module.
497// For example, one might call these functions to determine whether the current module is a static
498// library and/or is installed in vendor directories.
Colin Crossca860ac2016-01-04 14:34:37 -0800499type ModuleContextIntf interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800500 static() bool
501 staticBinary() bool
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -0700502 testBinary() bool
Yi Kong56fc1b62022-09-06 16:24:00 +0800503 testLibrary() bool
Jiyong Park1d1119f2019-07-29 21:27:18 +0900504 header() bool
Inseob Kim7f283f42020-06-01 21:53:49 +0900505 binary() bool
Inseob Kim1042d292020-06-01 23:23:05 +0900506 object() bool
Colin Crossb98c8b02016-07-29 13:44:28 -0700507 toolchain() config.Toolchain
Jooyung Hanccce2f22020-03-07 03:45:53 +0900508 canUseSdk() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700509 useSdk() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800510 sdkVersion() string
Jiyong Parkb35a8192020-08-10 15:59:36 +0900511 minSdkVersion() string
512 isSdkVariant() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700513 useVndk() bool
Colin Cross95f1ca02020-10-29 20:47:22 -0700514 isNdk(config android.Config) bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800515 IsLlndk() bool
516 IsLlndkPublic() bool
517 isImplementationForLLNDKPublic() bool
518 IsVndkPrivate() bool
Justin Yun8effde42017-06-23 19:24:43 +0900519 isVndk() bool
520 isVndkSp() bool
Ivan Lozanof9e21722020-12-02 09:00:51 -0500521 IsVndkExt() bool
Colin Cross5271fea2021-04-27 13:06:04 -0700522 IsVendorPublicLibrary() bool
Justin Yun5f7f7e82019-11-18 19:52:14 +0900523 inProduct() bool
524 inVendor() bool
Yifan Hong1b3348d2020-01-21 15:53:22 -0800525 inRamdisk() bool
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700526 inVendorRamdisk() bool
Jiyong Parkf9332f12018-02-01 00:54:12 +0900527 inRecovery() bool
Dan Willemsen8146b2f2016-03-30 21:00:30 -0700528 selectedStl() string
Colin Crossce75d2c2016-10-06 16:12:58 -0700529 baseModuleName() string
Logan Chienf3511742017-10-31 18:04:35 +0800530 getVndkExtendsModuleName() string
Yi Kong4ef54592022-02-14 20:00:10 +0800531 isAfdoCompile() bool
Sharjeel Khanc6a93d82023-07-18 21:01:11 +0000532 isOrderfileCompile() bool
Yi Kongc702ebd2022-08-19 16:02:45 +0800533 isCfi() bool
Yi Konged79fa32023-06-04 17:15:42 +0900534 isFuzzer() bool
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800535 isNDKStubLibrary() bool
Ivan Lozanobd721262018-11-27 14:33:03 -0800536 useClangLld(actx ModuleContext) bool
Logan Chiene274fc92019-12-03 11:18:32 -0800537 isForPlatform() bool
Colin Crosse07f2312020-08-13 11:24:56 -0700538 apexVariationName() string
Dan Albertc8060532020-07-22 22:32:17 -0700539 apexSdkVersion() android.ApiLevel
Jiyong Parka4b9dd02019-01-16 22:53:13 +0900540 bootstrap() bool
Vic Yangefd249e2018-11-12 20:19:56 -0800541 mustUseVendorVariant() bool
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700542 nativeCoverage() bool
Colin Cross56a83212020-09-15 18:30:11 -0700543 directlyInAnyApex() bool
Colin Cross95b07f22020-12-16 11:06:50 -0800544 isPreventInstall() bool
Cindy Zhou5d5cfc12021-01-09 08:25:22 -0800545 isCfiAssemblySupportEnabled() bool
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800546 getSharedFlags() *SharedFlags
547}
548
549type SharedFlags struct {
550 numSharedFlags int
551 flagsMap map[string]string
Colin Crossca860ac2016-01-04 14:34:37 -0800552}
553
554type ModuleContext interface {
Colin Cross635c3b02016-05-18 15:37:25 -0700555 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800556 ModuleContextIntf
557}
558
559type BaseModuleContext interface {
Colin Cross0ea8ba82019-06-06 14:33:29 -0700560 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800561 ModuleContextIntf
562}
563
Colin Cross37047f12016-12-13 17:06:13 -0800564type DepsContext interface {
565 android.BottomUpMutatorContext
566 ModuleContextIntf
567}
568
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500569// feature represents additional (optional) steps to building cc-related modules, such as invocation
570// of clang-tidy.
Colin Crossca860ac2016-01-04 14:34:37 -0800571type feature interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800572 flags(ctx ModuleContext, flags Flags) Flags
573 props() []interface{}
574}
575
Joe Onorato37f900c2023-07-18 16:58:16 -0700576// Information returned from Generator about the source code it's generating
577type GeneratedSource struct {
578 IncludeDirs android.Paths
579 Sources android.Paths
580 Headers android.Paths
581 ReexportedDirs android.Paths
582}
583
584// generator allows injection of generated code
585type Generator interface {
586 GeneratorProps() []interface{}
587 GeneratorInit(ctx BaseModuleContext)
588 GeneratorDeps(ctx DepsContext, deps Deps) Deps
589 GeneratorFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
590 GeneratorSources(ctx ModuleContext) GeneratedSource
591 GeneratorBuildActions(ctx ModuleContext, flags Flags, deps PathDeps)
592}
593
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500594// compiler is the interface for a compiler helper object. Different module decorators may implement
Liz Kammer718eb272022-01-07 10:53:37 -0500595// this helper differently.
Colin Crossca860ac2016-01-04 14:34:37 -0800596type compiler interface {
Colin Cross42742b82016-08-01 13:20:05 -0700597 compilerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800598 compilerDeps(ctx DepsContext, deps Deps) Deps
Colin Crossf18e1102017-11-16 14:33:08 -0800599 compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
Colin Cross42742b82016-08-01 13:20:05 -0700600 compilerProps() []interface{}
601
Colin Cross76fada02016-07-27 10:31:13 -0700602 appendCflags([]string)
603 appendAsflags([]string)
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700604 compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects
Colin Crossca860ac2016-01-04 14:34:37 -0800605}
606
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500607// linker is the interface for a linker decorator object. Individual module types can provide
608// their own implementation for this decorator, and thus specify custom logic regarding build
609// statements pertaining to linking.
Colin Crossca860ac2016-01-04 14:34:37 -0800610type linker interface {
Colin Cross42742b82016-08-01 13:20:05 -0700611 linkerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800612 linkerDeps(ctx DepsContext, deps Deps) Deps
Colin Cross42742b82016-08-01 13:20:05 -0700613 linkerFlags(ctx ModuleContext, flags Flags) Flags
614 linkerProps() []interface{}
Ivan Lozanobd721262018-11-27 14:33:03 -0800615 useClangLld(actx ModuleContext) bool
Colin Cross42742b82016-08-01 13:20:05 -0700616
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700617 link(ctx ModuleContext, flags Flags, deps PathDeps, objs Objects) android.Path
Colin Cross76fada02016-07-27 10:31:13 -0700618 appendLdflags([]string)
Jiyong Parkaf6d8952019-01-31 12:21:23 +0900619 unstrippedOutputFilePath() android.Path
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700620
621 nativeCoverage() bool
Jiyong Parkee9a98d2019-08-09 14:44:36 +0900622 coverageOutputFilePath() android.OptionalPath
Paul Duffin13f02712020-03-06 12:30:43 +0000623
624 // Get the deps that have been explicitly specified in the properties.
Paul Duffin13f02712020-03-06 12:30:43 +0000625 linkerSpecifiedDeps(specifiedDeps specifiedDeps) specifiedDeps
626}
627
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500628// specifiedDeps is a tuple struct representing dependencies of a linked binary owned by the linker.
Paul Duffin13f02712020-03-06 12:30:43 +0000629type specifiedDeps struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500630 sharedLibs []string
631 // Note nil and [] are semantically distinct. [] prevents linking against the defaults (usually
632 // libc, libm, etc.)
Colin Cross6b8f4252021-07-22 11:39:44 -0700633 systemSharedLibs []string
Colin Crossca860ac2016-01-04 14:34:37 -0800634}
635
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500636// installer is the interface for an installer helper object. This helper is responsible for
637// copying build outputs to the appropriate locations so that they may be installed on device.
Colin Crossca860ac2016-01-04 14:34:37 -0800638type installer interface {
Colin Cross42742b82016-08-01 13:20:05 -0700639 installerProps() []interface{}
Colin Cross635c3b02016-05-18 15:37:25 -0700640 install(ctx ModuleContext, path android.Path)
Paul Duffin0cb37b92020-03-04 14:52:46 +0000641 everInstallable() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800642 inData() bool
Vishwath Mohan1dd88392017-03-29 22:00:18 -0700643 inSanitizerDir() bool
Dan Willemsen4aa75ca2016-09-28 16:18:03 -0700644 hostToolPath() android.OptionalPath
Jiyong Parkb7c24df2019-02-01 12:03:59 +0900645 relativeInstallPath() string
Jingwen Chen8ac7d7d2023-03-20 11:05:16 +0000646 makeUninstallable(mod *Module)
Inseob Kim800d1142021-06-14 12:03:51 +0900647 installInRoot() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800648}
649
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800650type xref interface {
651 XrefCcFiles() android.Paths
652}
653
Inseob Kima1888ce2022-10-04 14:42:02 +0900654type overridable interface {
655 overriddenModules() []string
656}
657
Colin Cross6e511a92020-07-27 21:26:48 -0700658type libraryDependencyKind int
659
660const (
661 headerLibraryDependency = iota
662 sharedLibraryDependency
663 staticLibraryDependency
664)
665
666func (k libraryDependencyKind) String() string {
667 switch k {
668 case headerLibraryDependency:
669 return "headerLibraryDependency"
670 case sharedLibraryDependency:
671 return "sharedLibraryDependency"
672 case staticLibraryDependency:
673 return "staticLibraryDependency"
674 default:
675 panic(fmt.Errorf("unknown libraryDependencyKind %d", k))
676 }
677}
678
679type libraryDependencyOrder int
680
681const (
682 earlyLibraryDependency = -1
683 normalLibraryDependency = 0
684 lateLibraryDependency = 1
685)
686
687func (o libraryDependencyOrder) String() string {
688 switch o {
689 case earlyLibraryDependency:
690 return "earlyLibraryDependency"
691 case normalLibraryDependency:
692 return "normalLibraryDependency"
693 case lateLibraryDependency:
694 return "lateLibraryDependency"
695 default:
696 panic(fmt.Errorf("unknown libraryDependencyOrder %d", o))
697 }
698}
699
700// libraryDependencyTag is used to tag dependencies on libraries. Unlike many dependency
701// tags that have a set of predefined tag objects that are reused for each dependency, a
702// libraryDependencyTag is designed to contain extra metadata and is constructed as needed.
703// That means that comparing a libraryDependencyTag for equality will only be equal if all
704// of the metadata is equal. Most usages will want to type assert to libraryDependencyTag and
705// then check individual metadata fields instead.
706type libraryDependencyTag struct {
707 blueprint.BaseDependencyTag
708
709 // These are exported so that fmt.Printf("%#v") can call their String methods.
710 Kind libraryDependencyKind
711 Order libraryDependencyOrder
712
713 wholeStatic bool
714
715 reexportFlags bool
716 explicitlyVersioned bool
717 dataLib bool
718 ndk bool
719
720 staticUnwinder bool
721
722 makeSuffix string
Jiyong Parke3867542020-12-03 17:28:25 +0900723
Cindy Zhou18417cb2020-12-10 07:12:38 -0800724 // Whether or not this dependency should skip the apex dependency check
725 skipApexAllowedDependenciesCheck bool
726
Jiyong Parke3867542020-12-03 17:28:25 +0900727 // Whether or not this dependency has to be followed for the apex variants
728 excludeInApex bool
Jooyung Han9ffbe832023-11-28 22:31:35 +0900729 // Whether or not this dependency has to be followed for the non-apex variants
730 excludeInNonApex bool
Colin Cross3e5e7782022-06-17 22:17:05 +0000731
732 // If true, don't automatically export symbols from the static library into a shared library.
733 unexportedSymbols bool
Colin Cross6e511a92020-07-27 21:26:48 -0700734}
735
736// header returns true if the libraryDependencyTag is tagging a header lib dependency.
737func (d libraryDependencyTag) header() bool {
738 return d.Kind == headerLibraryDependency
739}
740
741// shared returns true if the libraryDependencyTag is tagging a shared lib dependency.
742func (d libraryDependencyTag) shared() bool {
743 return d.Kind == sharedLibraryDependency
744}
745
746// shared returns true if the libraryDependencyTag is tagging a static lib dependency.
747func (d libraryDependencyTag) static() bool {
748 return d.Kind == staticLibraryDependency
749}
750
Colin Cross65cb3142021-12-10 23:05:02 +0000751func (d libraryDependencyTag) LicenseAnnotations() []android.LicenseAnnotation {
752 if d.shared() {
753 return []android.LicenseAnnotation{android.LicenseAnnotationSharedDependency}
754 }
755 return nil
756}
757
758var _ android.LicenseAnnotationsDependencyTag = libraryDependencyTag{}
759
Colin Crosse9fe2942020-11-10 18:12:15 -0800760// InstallDepNeeded returns true for shared libraries so that shared library dependencies of
761// binaries or other shared libraries are installed as dependencies.
762func (d libraryDependencyTag) InstallDepNeeded() bool {
763 return d.shared()
764}
765
766var _ android.InstallNeededDependencyTag = libraryDependencyTag{}
767
768// dependencyTag is used for tagging miscellaneous dependency types that don't fit into
Colin Cross6e511a92020-07-27 21:26:48 -0700769// libraryDependencyTag. Each tag object is created globally and reused for multiple
770// dependencies (although since the object contains no references, assigning a tag to a
771// variable and modifying it will not modify the original). Users can compare the tag
772// returned by ctx.OtherModuleDependencyTag against the global original
773type dependencyTag struct {
774 blueprint.BaseDependencyTag
775 name string
776}
777
Colin Crosse9fe2942020-11-10 18:12:15 -0800778// installDependencyTag is used for tagging miscellaneous dependency types that don't fit into
779// libraryDependencyTag, but where the dependency needs to be installed when the parent is
780// installed.
781type installDependencyTag struct {
782 blueprint.BaseDependencyTag
783 android.InstallAlwaysNeededDependencyTag
784 name string
785}
786
Colin Crossc99deeb2016-04-11 15:06:20 -0700787var (
Colin Cross6e511a92020-07-27 21:26:48 -0700788 genSourceDepTag = dependencyTag{name: "gen source"}
789 genHeaderDepTag = dependencyTag{name: "gen header"}
790 genHeaderExportDepTag = dependencyTag{name: "gen header export"}
791 objDepTag = dependencyTag{name: "obj"}
Jiyong Parkd630bdd2020-11-25 11:47:24 +0900792 dynamicLinkerDepTag = installDependencyTag{name: "dynamic linker"}
Colin Cross6e511a92020-07-27 21:26:48 -0700793 reuseObjTag = dependencyTag{name: "reuse objects"}
794 staticVariantTag = dependencyTag{name: "static variant"}
795 vndkExtDepTag = dependencyTag{name: "vndk extends"}
796 dataLibDepTag = dependencyTag{name: "data lib"}
Colin Crossc8caa062021-09-24 16:50:14 -0700797 dataBinDepTag = dependencyTag{name: "data bin"}
Colin Crosse9fe2942020-11-10 18:12:15 -0800798 runtimeDepTag = installDependencyTag{name: "runtime lib"}
Colin Cross6e511a92020-07-27 21:26:48 -0700799 testPerSrcDepTag = dependencyTag{name: "test_per_src"}
Colin Cross0de8a1e2020-09-18 14:15:30 -0700800 stubImplDepTag = dependencyTag{name: "stub_impl"}
Muhammad Haseeb Ahmad7e744052022-03-25 22:50:53 +0000801 JniFuzzLibTag = dependencyTag{name: "jni_fuzz_lib_tag"}
Vinh Tran44cb78c2023-03-09 22:07:19 -0500802 FdoProfileTag = dependencyTag{name: "fdo_profile"}
Vinh Tran367d89d2023-04-28 11:21:25 -0400803 aidlLibraryTag = dependencyTag{name: "aidl_library"}
Colin Crossc99deeb2016-04-11 15:06:20 -0700804)
805
Roland Levillainf89cd092019-07-29 16:22:59 +0100806func IsSharedDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700807 ccLibDepTag, ok := depTag.(libraryDependencyTag)
808 return ok && ccLibDepTag.shared()
809}
810
811func IsStaticDepTag(depTag blueprint.DependencyTag) bool {
812 ccLibDepTag, ok := depTag.(libraryDependencyTag)
813 return ok && ccLibDepTag.static()
Roland Levillainf89cd092019-07-29 16:22:59 +0100814}
815
Zach Johnson3df4e632020-11-06 11:56:27 -0800816func IsHeaderDepTag(depTag blueprint.DependencyTag) bool {
817 ccLibDepTag, ok := depTag.(libraryDependencyTag)
818 return ok && ccLibDepTag.header()
819}
820
Roland Levillainf89cd092019-07-29 16:22:59 +0100821func IsRuntimeDepTag(depTag blueprint.DependencyTag) bool {
Colin Crosse9fe2942020-11-10 18:12:15 -0800822 return depTag == runtimeDepTag
Roland Levillainf89cd092019-07-29 16:22:59 +0100823}
824
825func IsTestPerSrcDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700826 ccDepTag, ok := depTag.(dependencyTag)
Roland Levillainf89cd092019-07-29 16:22:59 +0100827 return ok && ccDepTag == testPerSrcDepTag
828}
829
Colin Crossca860ac2016-01-04 14:34:37 -0800830// Module contains the properties and members used by all C/C++ module types, and implements
831// the blueprint.Module interface. It delegates to compiler, linker, and installer interfaces
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500832// to construct the output file. Behavior can be customized with a Customizer, or "decorator",
833// interface.
834//
835// To define a C/C++ related module, construct a new Module object and point its delegates to
836// type-specific structs. These delegates will be invoked to register module-specific build
837// statements which may be unique to the module type. For example, module.compiler.compile() should
838// be defined so as to register build statements which are responsible for compiling the module.
839//
840// Another example: to construct a cc_binary module, one can create a `cc.binaryDecorator` struct
841// which implements the `linker` and `installer` interfaces, and points the `linker` and `installer`
842// members of the cc.Module to this decorator. Thus, a cc_binary module has custom linker and
843// installer logic.
Colin Crossca860ac2016-01-04 14:34:37 -0800844type Module struct {
hamzehc0a671f2021-07-22 12:05:08 -0700845 fuzz.FuzzModule
hamzeh41ad8812021-07-07 14:00:07 -0700846
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700847 VendorProperties VendorProperties
hamzeh41ad8812021-07-07 14:00:07 -0700848 Properties BaseProperties
Colin Crossfa138792015-04-24 17:31:52 -0700849
Colin Crossca860ac2016-01-04 14:34:37 -0800850 // initialize before calling Init
Aditya Choudhary87b2ab22023-11-17 15:27:06 +0000851 hod android.HostOrDeviceSupported
852 multilib android.Multilib
Aditya Choudhary87b2ab22023-11-17 15:27:06 +0000853 testModule bool
Colin Crossc472d572015-03-17 15:06:21 -0700854
Paul Duffina0843f62019-12-13 19:50:38 +0000855 // Allowable SdkMemberTypes of this module type.
856 sdkMemberTypes []android.SdkMemberType
857
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500858 // decorator delegates, initialize before calling Init
859 // these may contain module-specific implementations, and effectively allow for custom
860 // type-specific logic. These members may reference different objects or the same object.
861 // Functions of these decorators will be invoked to initialize and register type-specific
862 // build statements.
Colin Cross8ff10582023-12-07 13:10:56 -0800863 generators []Generator
864 compiler compiler
865 linker linker
866 installer installer
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500867
Spandan Dase12d2522023-09-12 21:42:31 +0000868 features []feature
869 stl *stl
870 sanitize *sanitize
871 coverage *coverage
872 fuzzer *fuzzer
873 sabi *sabi
874 vndkdep *vndkdep
875 lto *lto
876 afdo *afdo
Sharjeel Khanc6a93d82023-07-18 21:01:11 +0000877 orderfile *orderfile
Colin Cross16b23492016-01-06 14:41:07 -0800878
Colin Cross31076b32020-10-23 17:22:06 -0700879 library libraryInterface
880
Colin Cross635c3b02016-05-18 15:37:25 -0700881 outputFile android.OptionalPath
Colin Crossca860ac2016-01-04 14:34:37 -0800882
Colin Crossb98c8b02016-07-29 13:44:28 -0700883 cachedToolchain config.Toolchain
Colin Crossb916a382016-07-29 17:28:03 -0700884
885 subAndroidMkOnce map[subAndroidMkProvider]bool
Fabien Sanglardd61f1f42017-01-10 16:21:22 -0800886
887 // Flags used to compile this module
888 flags Flags
Jeff Gaston294356f2017-09-27 17:05:30 -0700889
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800890 // Shared flags among build rules of this module
891 sharedFlags SharedFlags
892
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800893 // only non-nil when this is a shared library that reuses the objects of a static library
Colin Cross0de8a1e2020-09-18 14:15:30 -0700894 staticAnalogue *StaticLibraryInfo
Inseob Kim9516ee92019-05-09 10:56:13 +0900895
896 makeLinkType string
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800897 // Kythe (source file indexer) paths for this compilation module
898 kytheFiles android.Paths
Chih-Hung Hsieh80783772021-10-11 16:46:56 -0700899 // Object .o file output paths for this compilation module
900 objFiles android.Paths
901 // Tidy .tidy file output paths for this compilation module
902 tidyFiles android.Paths
Jooyung Han75568392020-03-20 04:29:24 +0900903
904 // For apex variants, this is set as apex.min_sdk_version
Dan Albertc8060532020-07-22 22:32:17 -0700905 apexSdkVersion android.ApiLevel
Colin Cross56a83212020-09-15 18:30:11 -0700906
907 hideApexVariantFromMake bool
Yu Liueae7b362023-11-16 17:05:47 -0800908
909 // Aconfig files for all transitive deps. Also exposed via TransitiveDeclarationsInfo
Colin Crossd788b3e2023-11-28 13:14:56 -0800910 mergedAconfigFiles map[string]android.Paths
Colin Crossc472d572015-03-17 15:06:21 -0700911}
912
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200913func (c *Module) AddJSONData(d *map[string]interface{}) {
Liz Kammer74ec1682021-08-17 17:29:51 -0400914 var hasAidl, hasLex, hasProto, hasRenderscript, hasSysprop, hasWinMsg, hasYacc bool
915 if b, ok := c.compiler.(*baseCompiler); ok {
916 hasAidl = b.hasSrcExt(".aidl")
917 hasLex = b.hasSrcExt(".l") || b.hasSrcExt(".ll")
918 hasProto = b.hasSrcExt(".proto")
919 hasRenderscript = b.hasSrcExt(".rscript") || b.hasSrcExt(".fs")
920 hasSysprop = b.hasSrcExt(".sysprop")
921 hasWinMsg = b.hasSrcExt(".mc")
922 hasYacc = b.hasSrcExt(".y") || b.hasSrcExt(".yy")
923 }
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200924 c.AndroidModuleBase().AddJSONData(d)
925 (*d)["Cc"] = map[string]interface{}{
926 "SdkVersion": c.SdkVersion(),
927 "MinSdkVersion": c.MinSdkVersion(),
928 "VndkVersion": c.VndkVersion(),
929 "ProductSpecific": c.ProductSpecific(),
930 "SocSpecific": c.SocSpecific(),
931 "DeviceSpecific": c.DeviceSpecific(),
932 "InProduct": c.InProduct(),
933 "InVendor": c.InVendor(),
934 "InRamdisk": c.InRamdisk(),
935 "InVendorRamdisk": c.InVendorRamdisk(),
936 "InRecovery": c.InRecovery(),
937 "VendorAvailable": c.VendorAvailable(),
938 "ProductAvailable": c.ProductAvailable(),
939 "RamdiskAvailable": c.RamdiskAvailable(),
940 "VendorRamdiskAvailable": c.VendorRamdiskAvailable(),
941 "RecoveryAvailable": c.RecoveryAvailable(),
942 "OdmAvailable": c.OdmAvailable(),
943 "InstallInData": c.InstallInData(),
944 "InstallInRamdisk": c.InstallInRamdisk(),
945 "InstallInSanitizerDir": c.InstallInSanitizerDir(),
946 "InstallInVendorRamdisk": c.InstallInVendorRamdisk(),
947 "InstallInRecovery": c.InstallInRecovery(),
948 "InstallInRoot": c.InstallInRoot(),
949 "IsVndk": c.IsVndk(),
950 "IsVndkExt": c.IsVndkExt(),
951 "IsVndkPrivate": c.IsVndkPrivate(),
952 "IsVndkSp": c.IsVndkSp(),
953 "IsLlndk": c.IsLlndk(),
954 "IsLlndkPublic": c.IsLlndkPublic(),
955 "IsSnapshotLibrary": c.IsSnapshotLibrary(),
956 "IsSnapshotPrebuilt": c.IsSnapshotPrebuilt(),
957 "IsVendorPublicLibrary": c.IsVendorPublicLibrary(),
958 "ApexSdkVersion": c.apexSdkVersion,
959 "TestFor": c.TestFor(),
Liz Kammer74ec1682021-08-17 17:29:51 -0400960 "AidlSrcs": hasAidl,
961 "LexSrcs": hasLex,
962 "ProtoSrcs": hasProto,
963 "RenderscriptSrcs": hasRenderscript,
964 "SyspropSrcs": hasSysprop,
965 "WinMsgSrcs": hasWinMsg,
966 "YaccSrsc": hasYacc,
967 "OnlyCSrcs": !(hasAidl || hasLex || hasProto || hasRenderscript || hasSysprop || hasWinMsg || hasYacc),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200968 }
969}
970
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500971func (c *Module) SetPreventInstall() {
972 c.Properties.PreventInstall = true
973}
974
975func (c *Module) SetHideFromMake() {
976 c.Properties.HideFromMake = true
977}
978
Ivan Lozanod7586b62021-04-01 09:49:36 -0400979func (c *Module) HiddenFromMake() bool {
980 return c.Properties.HideFromMake
981}
982
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800983func (c *Module) RequiredModuleNames() []string {
984 required := android.CopyOf(c.ModuleBase.RequiredModuleNames())
985 if c.ImageVariation().Variation == android.CoreVariation {
986 required = append(required, c.Properties.Target.Platform.Required...)
987 required = removeListFromList(required, c.Properties.Target.Platform.Exclude_required)
988 } else if c.InRecovery() {
989 required = append(required, c.Properties.Target.Recovery.Required...)
990 required = removeListFromList(required, c.Properties.Target.Recovery.Exclude_required)
991 }
992 return android.FirstUniqueStrings(required)
993}
994
Ivan Lozano52767be2019-10-18 14:49:46 -0700995func (c *Module) Toc() android.OptionalPath {
996 if c.linker != nil {
997 if library, ok := c.linker.(libraryInterface); ok {
998 return library.toc()
999 }
1000 }
1001 panic(fmt.Errorf("Toc() called on non-library module: %q", c.BaseModuleName()))
1002}
1003
1004func (c *Module) ApiLevel() string {
1005 if c.linker != nil {
1006 if stub, ok := c.linker.(*stubDecorator); ok {
Dan Albert1a246272020-07-06 14:49:35 -07001007 return stub.apiLevel.String()
Ivan Lozano52767be2019-10-18 14:49:46 -07001008 }
1009 }
1010 panic(fmt.Errorf("ApiLevel() called on non-stub library module: %q", c.BaseModuleName()))
1011}
1012
1013func (c *Module) Static() bool {
1014 if c.linker != nil {
1015 if library, ok := c.linker.(libraryInterface); ok {
1016 return library.static()
1017 }
1018 }
1019 panic(fmt.Errorf("Static() called on non-library module: %q", c.BaseModuleName()))
1020}
1021
1022func (c *Module) Shared() bool {
1023 if c.linker != nil {
1024 if library, ok := c.linker.(libraryInterface); ok {
1025 return library.shared()
1026 }
1027 }
Lukacs T. Berki6c716762022-06-13 20:50:39 +02001028
Ivan Lozano52767be2019-10-18 14:49:46 -07001029 panic(fmt.Errorf("Shared() called on non-library module: %q", c.BaseModuleName()))
1030}
1031
1032func (c *Module) SelectedStl() string {
Colin Crossc511bc52020-04-07 16:50:32 +00001033 if c.stl != nil {
1034 return c.stl.Properties.SelectedStl
1035 }
1036 return ""
Ivan Lozano52767be2019-10-18 14:49:46 -07001037}
1038
Ivan Lozano52767be2019-10-18 14:49:46 -07001039func (c *Module) NdkPrebuiltStl() bool {
1040 if _, ok := c.linker.(*ndkPrebuiltStlLinker); ok {
1041 return true
1042 }
1043 return false
1044}
1045
1046func (c *Module) StubDecorator() bool {
1047 if _, ok := c.linker.(*stubDecorator); ok {
1048 return true
1049 }
1050 return false
1051}
1052
1053func (c *Module) SdkVersion() string {
1054 return String(c.Properties.Sdk_version)
1055}
1056
Artur Satayev480e25b2020-04-27 18:53:18 +01001057func (c *Module) MinSdkVersion() string {
1058 return String(c.Properties.Min_sdk_version)
1059}
1060
Jiyong Park5df7bd32021-08-25 16:18:46 +09001061func (c *Module) isCrt() bool {
Dan Albert92fe7402020-07-15 13:33:30 -07001062 if linker, ok := c.linker.(*objectLinker); ok {
1063 return linker.isCrt()
1064 }
1065 return false
1066}
1067
Jiyong Park5df7bd32021-08-25 16:18:46 +09001068func (c *Module) SplitPerApiLevel() bool {
1069 return c.canUseSdk() && c.isCrt()
1070}
1071
Colin Crossc511bc52020-04-07 16:50:32 +00001072func (c *Module) AlwaysSdk() bool {
1073 return c.Properties.AlwaysSdk || Bool(c.Properties.Sdk_variant_only)
1074}
1075
Ivan Lozano183a3212019-10-18 14:18:45 -07001076func (c *Module) CcLibrary() bool {
1077 if c.linker != nil {
1078 if _, ok := c.linker.(*libraryDecorator); ok {
1079 return true
1080 }
Colin Crossd48fe732020-09-23 20:37:24 -07001081 if _, ok := c.linker.(*prebuiltLibraryLinker); ok {
1082 return true
1083 }
Ivan Lozano183a3212019-10-18 14:18:45 -07001084 }
1085 return false
1086}
1087
1088func (c *Module) CcLibraryInterface() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001089 if _, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001090 return true
1091 }
1092 return false
1093}
1094
Spandan Dase12d2522023-09-12 21:42:31 +00001095func (c *Module) IsNdkPrebuiltStl() bool {
1096 if c.linker == nil {
1097 return false
1098 }
1099 if _, ok := c.linker.(*ndkPrebuiltStlLinker); ok {
1100 return true
1101 }
1102 return false
1103}
1104
Ivan Lozanoadd122a2023-07-13 11:01:41 -04001105func (c *Module) RlibStd() bool {
1106 panic(fmt.Errorf("RlibStd called on non-Rust module: %q", c.BaseModuleName()))
1107}
1108
Ivan Lozano61c02cc2023-06-09 14:06:44 -04001109func (c *Module) RustLibraryInterface() bool {
1110 return false
1111}
1112
Ivan Lozano0f9963e2023-02-06 13:31:02 -05001113func (c *Module) IsFuzzModule() bool {
1114 if _, ok := c.compiler.(*fuzzBinary); ok {
1115 return true
1116 }
1117 return false
1118}
1119
1120func (c *Module) FuzzModuleStruct() fuzz.FuzzModule {
1121 return c.FuzzModule
1122}
1123
1124func (c *Module) FuzzPackagedModule() fuzz.FuzzPackagedModule {
1125 if fuzzer, ok := c.compiler.(*fuzzBinary); ok {
1126 return fuzzer.fuzzPackagedModule
1127 }
1128 panic(fmt.Errorf("FuzzPackagedModule called on non-fuzz module: %q", c.BaseModuleName()))
1129}
1130
Hamzeh Zawawy38917492023-04-05 22:08:46 +00001131func (c *Module) FuzzSharedLibraries() android.RuleBuilderInstalls {
Ivan Lozano0f9963e2023-02-06 13:31:02 -05001132 if fuzzer, ok := c.compiler.(*fuzzBinary); ok {
1133 return fuzzer.sharedLibraries
1134 }
1135 panic(fmt.Errorf("FuzzSharedLibraries called on non-fuzz module: %q", c.BaseModuleName()))
1136}
1137
Ivan Lozano2b262972019-11-21 12:30:50 -08001138func (c *Module) NonCcVariants() bool {
1139 return false
1140}
1141
Ivan Lozano183a3212019-10-18 14:18:45 -07001142func (c *Module) SetStatic() {
1143 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001144 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001145 library.setStatic()
1146 return
1147 }
1148 }
1149 panic(fmt.Errorf("SetStatic called on non-library module: %q", c.BaseModuleName()))
1150}
1151
1152func (c *Module) SetShared() {
1153 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001154 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001155 library.setShared()
1156 return
1157 }
1158 }
1159 panic(fmt.Errorf("SetShared called on non-library module: %q", c.BaseModuleName()))
1160}
1161
1162func (c *Module) BuildStaticVariant() bool {
1163 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001164 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001165 return library.buildStatic()
1166 }
1167 }
1168 panic(fmt.Errorf("BuildStaticVariant called on non-library module: %q", c.BaseModuleName()))
1169}
1170
1171func (c *Module) BuildSharedVariant() bool {
1172 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001173 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001174 return library.buildShared()
1175 }
1176 }
1177 panic(fmt.Errorf("BuildSharedVariant called on non-library module: %q", c.BaseModuleName()))
1178}
1179
1180func (c *Module) Module() android.Module {
1181 return c
1182}
1183
Jiyong Parkc20eee32018-09-05 22:36:17 +09001184func (c *Module) OutputFile() android.OptionalPath {
1185 return c.outputFile
1186}
1187
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001188func (c *Module) CoverageFiles() android.Paths {
1189 if c.linker != nil {
1190 if library, ok := c.linker.(libraryInterface); ok {
1191 return library.objs().coverageFiles
1192 }
1193 }
1194 panic(fmt.Errorf("CoverageFiles called on non-library module: %q", c.BaseModuleName()))
1195}
1196
Ivan Lozano183a3212019-10-18 14:18:45 -07001197var _ LinkableInterface = (*Module)(nil)
1198
Jiyong Park719b4462019-01-13 00:39:51 +09001199func (c *Module) UnstrippedOutputFile() android.Path {
Jiyong Parkaf6d8952019-01-31 12:21:23 +09001200 if c.linker != nil {
1201 return c.linker.unstrippedOutputFilePath()
Jiyong Park719b4462019-01-13 00:39:51 +09001202 }
1203 return nil
1204}
1205
Jiyong Parkee9a98d2019-08-09 14:44:36 +09001206func (c *Module) CoverageOutputFile() android.OptionalPath {
1207 if c.linker != nil {
1208 return c.linker.coverageOutputFilePath()
1209 }
1210 return android.OptionalPath{}
1211}
1212
Jiyong Parkb7c24df2019-02-01 12:03:59 +09001213func (c *Module) RelativeInstallPath() string {
1214 if c.installer != nil {
1215 return c.installer.relativeInstallPath()
1216 }
1217 return ""
1218}
1219
Jooyung Han344d5432019-08-23 11:17:39 +09001220func (c *Module) VndkVersion() string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001221 return c.Properties.VndkVersion
Jooyung Han344d5432019-08-23 11:17:39 +09001222}
1223
Colin Cross36242852017-06-23 15:06:31 -07001224func (c *Module) Init() android.Module {
Dan Willemsenf923f2b2018-05-09 13:45:03 -07001225 c.AddProperties(&c.Properties, &c.VendorProperties)
Joe Onorato37f900c2023-07-18 16:58:16 -07001226 for _, generator := range c.generators {
1227 c.AddProperties(generator.GeneratorProps()...)
1228 }
Colin Crossca860ac2016-01-04 14:34:37 -08001229 if c.compiler != nil {
Colin Cross36242852017-06-23 15:06:31 -07001230 c.AddProperties(c.compiler.compilerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001231 }
1232 if c.linker != nil {
Colin Cross36242852017-06-23 15:06:31 -07001233 c.AddProperties(c.linker.linkerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001234 }
1235 if c.installer != nil {
Colin Cross36242852017-06-23 15:06:31 -07001236 c.AddProperties(c.installer.installerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001237 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001238 if c.stl != nil {
Colin Cross36242852017-06-23 15:06:31 -07001239 c.AddProperties(c.stl.props()...)
Colin Crossa8e07cc2016-04-04 15:07:06 -07001240 }
Colin Cross16b23492016-01-06 14:41:07 -08001241 if c.sanitize != nil {
Colin Cross36242852017-06-23 15:06:31 -07001242 c.AddProperties(c.sanitize.props()...)
Colin Cross16b23492016-01-06 14:41:07 -08001243 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001244 if c.coverage != nil {
Colin Cross36242852017-06-23 15:06:31 -07001245 c.AddProperties(c.coverage.props()...)
Dan Willemsen581341d2017-02-09 16:16:31 -08001246 }
Cory Barkera1da26f2022-06-07 20:12:06 +00001247 if c.fuzzer != nil {
1248 c.AddProperties(c.fuzzer.props()...)
1249 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001250 if c.sabi != nil {
Colin Cross36242852017-06-23 15:06:31 -07001251 c.AddProperties(c.sabi.props()...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001252 }
Justin Yun8effde42017-06-23 19:24:43 +09001253 if c.vndkdep != nil {
1254 c.AddProperties(c.vndkdep.props()...)
1255 }
Stephen Craneba090d12017-05-09 15:44:35 -07001256 if c.lto != nil {
1257 c.AddProperties(c.lto.props()...)
1258 }
Yi Kongeb8efc92021-12-09 18:06:29 +08001259 if c.afdo != nil {
1260 c.AddProperties(c.afdo.props()...)
1261 }
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001262 if c.orderfile != nil {
1263 c.AddProperties(c.orderfile.props()...)
1264 }
Colin Crossca860ac2016-01-04 14:34:37 -08001265 for _, feature := range c.features {
Colin Cross36242852017-06-23 15:06:31 -07001266 c.AddProperties(feature.props()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001267 }
Colin Crossc472d572015-03-17 15:06:21 -07001268
Colin Cross36242852017-06-23 15:06:31 -07001269 android.InitAndroidArchModule(c, c.hod, c.multilib)
Jiyong Park7916bfc2019-09-30 19:13:12 +09001270 android.InitApexModule(c)
Jooyung Han18020ea2019-11-13 10:50:48 +09001271 android.InitDefaultableModule(c)
Jiyong Park9d452992018-10-03 00:38:19 +09001272
Colin Cross36242852017-06-23 15:06:31 -07001273 return c
Colin Crossc472d572015-03-17 15:06:21 -07001274}
1275
Yi-Yo Chiang1080f0c2022-11-22 18:24:14 +08001276// UseVndk() returns true if this module is built against VNDK.
1277// This means the vendor and product variants of a module.
Ivan Lozano52767be2019-10-18 14:49:46 -07001278func (c *Module) UseVndk() bool {
Inseob Kim64c43952019-08-26 16:52:35 +09001279 return c.Properties.VndkVersion != ""
Dan Willemsen4416e5d2017-04-06 12:43:22 -07001280}
1281
Colin Crossc511bc52020-04-07 16:50:32 +00001282func (c *Module) canUseSdk() bool {
Colin Cross94e347e2021-01-19 14:56:07 -08001283 return c.Os() == android.Android && c.Target().NativeBridge == android.NativeBridgeDisabled &&
1284 !c.UseVndk() && !c.InRamdisk() && !c.InRecovery() && !c.InVendorRamdisk()
Colin Crossc511bc52020-04-07 16:50:32 +00001285}
1286
1287func (c *Module) UseSdk() bool {
1288 if c.canUseSdk() {
Colin Cross1348ce32020-10-01 13:37:16 -07001289 return String(c.Properties.Sdk_version) != ""
Colin Crossc511bc52020-04-07 16:50:32 +00001290 }
1291 return false
1292}
1293
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001294func (c *Module) isCoverageVariant() bool {
1295 return c.coverage.Properties.IsCoverageVariant
1296}
1297
Colin Cross95f1ca02020-10-29 20:47:22 -07001298func (c *Module) IsNdk(config android.Config) bool {
1299 return inList(c.BaseModuleName(), *getNDKKnownLibs(config))
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001300}
1301
Colin Cross127bb8b2020-12-16 16:46:01 -08001302func (c *Module) IsLlndk() bool {
1303 return c.VendorProperties.IsLLNDK
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001304}
1305
Colin Cross127bb8b2020-12-16 16:46:01 -08001306func (c *Module) IsLlndkPublic() bool {
Colin Cross78212242021-01-06 14:51:30 -08001307 return c.VendorProperties.IsLLNDK && !c.VendorProperties.IsVNDKPrivate
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001308}
1309
Colin Cross1f3f1302021-04-26 18:37:44 -07001310func (m *Module) NeedsLlndkVariants() bool {
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001311 lib := moduleLibraryInterface(m)
Colin Cross1f3f1302021-04-26 18:37:44 -07001312 return lib != nil && (lib.hasLLNDKStubs() || lib.hasLLNDKHeaders())
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001313}
1314
Colin Cross5271fea2021-04-27 13:06:04 -07001315func (m *Module) NeedsVendorPublicLibraryVariants() bool {
1316 lib := moduleLibraryInterface(m)
1317 return lib != nil && (lib.hasVendorPublicLibrary())
1318}
1319
1320// IsVendorPublicLibrary returns true for vendor public libraries.
1321func (c *Module) IsVendorPublicLibrary() bool {
1322 return c.VendorProperties.IsVendorPublicLibrary
1323}
1324
Ivan Lozanof1868af2022-04-12 13:08:36 -04001325func (c *Module) IsVndkPrebuiltLibrary() bool {
1326 if _, ok := c.linker.(*vndkPrebuiltLibraryDecorator); ok {
1327 return true
1328 }
1329 return false
1330}
1331
1332func (c *Module) SdkAndPlatformVariantVisibleToMake() bool {
1333 return c.Properties.SdkAndPlatformVariantVisibleToMake
1334}
1335
Ivan Lozanod7586b62021-04-01 09:49:36 -04001336func (c *Module) HasLlndkStubs() bool {
1337 lib := moduleLibraryInterface(c)
1338 return lib != nil && lib.hasLLNDKStubs()
1339}
1340
1341func (c *Module) StubsVersion() string {
1342 if lib, ok := c.linker.(versionedInterface); ok {
1343 return lib.stubsVersion()
1344 }
1345 panic(fmt.Errorf("StubsVersion called on non-versioned module: %q", c.BaseModuleName()))
1346}
1347
Colin Cross127bb8b2020-12-16 16:46:01 -08001348// isImplementationForLLNDKPublic returns true for any variant of a cc_library that has LLNDK stubs
1349// and does not set llndk.vendor_available: false.
1350func (c *Module) isImplementationForLLNDKPublic() bool {
1351 library, _ := c.library.(*libraryDecorator)
1352 return library != nil && library.hasLLNDKStubs() &&
Colin Cross0fb7fcd2021-03-02 11:00:07 -08001353 !Bool(library.Properties.Llndk.Private)
Colin Cross127bb8b2020-12-16 16:46:01 -08001354}
1355
Justin Yunfd9e8042020-12-23 18:23:14 +09001356// Returns true for LLNDK-private, VNDK-SP-private, and VNDK-core-private.
Colin Cross127bb8b2020-12-16 16:46:01 -08001357func (c *Module) IsVndkPrivate() bool {
Justin Yunfd9e8042020-12-23 18:23:14 +09001358 // Check if VNDK-core-private or VNDK-SP-private
1359 if c.IsVndk() {
Justin Yunc0d8c492021-01-07 17:45:31 +09001360 return Bool(c.vndkdep.Properties.Vndk.Private)
Justin Yunfd9e8042020-12-23 18:23:14 +09001361 }
1362
1363 // Check if LLNDK-private
1364 if library, ok := c.library.(*libraryDecorator); ok && c.IsLlndk() {
Justin Yunc0d8c492021-01-07 17:45:31 +09001365 return Bool(library.Properties.Llndk.Private)
Justin Yunfd9e8042020-12-23 18:23:14 +09001366 }
1367
1368 return false
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001369}
1370
Yi-Yo Chiang1080f0c2022-11-22 18:24:14 +08001371// IsVndk() returns true if this module has a vndk variant.
1372// Note that IsVndk() returns true for all variants of vndk-enabled libraries. Not only vendor variant,
1373// but also platform and product variants of vndk-enabled libraries return true for IsVndk().
Ivan Lozano52767be2019-10-18 14:49:46 -07001374func (c *Module) IsVndk() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001375 if vndkdep := c.vndkdep; vndkdep != nil {
1376 return vndkdep.isVndk()
Justin Yun8effde42017-06-23 19:24:43 +09001377 }
1378 return false
1379}
1380
Yi Kong4ef54592022-02-14 20:00:10 +08001381func (c *Module) isAfdoCompile() bool {
1382 if afdo := c.afdo; afdo != nil {
Vinh Tran44cb78c2023-03-09 22:07:19 -05001383 return afdo.Properties.FdoProfilePath != nil
Yi Kong4ef54592022-02-14 20:00:10 +08001384 }
1385 return false
1386}
1387
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001388func (c *Module) isOrderfileCompile() bool {
1389 if orderfile := c.orderfile; orderfile != nil {
1390 return orderfile.Properties.OrderfileLoad
1391 }
1392 return false
1393}
1394
Yi Kongc702ebd2022-08-19 16:02:45 +08001395func (c *Module) isCfi() bool {
1396 if sanitize := c.sanitize; sanitize != nil {
Yi Kongddffe722023-07-18 16:40:36 +09001397 return Bool(sanitize.Properties.SanitizeMutated.Cfi)
Yi Kongc702ebd2022-08-19 16:02:45 +08001398 }
1399 return false
1400}
1401
Yi Konged79fa32023-06-04 17:15:42 +09001402func (c *Module) isFuzzer() bool {
1403 if sanitize := c.sanitize; sanitize != nil {
1404 return Bool(sanitize.Properties.SanitizeMutated.Fuzzer)
1405 }
1406 return false
1407}
1408
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001409func (c *Module) isNDKStubLibrary() bool {
1410 if _, ok := c.compiler.(*stubDecorator); ok {
1411 return true
1412 }
1413 return false
1414}
1415
Ivan Lozanod7586b62021-04-01 09:49:36 -04001416func (c *Module) IsVndkSp() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001417 if vndkdep := c.vndkdep; vndkdep != nil {
1418 return vndkdep.isVndkSp()
1419 }
1420 return false
1421}
1422
Ivan Lozanof9e21722020-12-02 09:00:51 -05001423func (c *Module) IsVndkExt() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001424 if vndkdep := c.vndkdep; vndkdep != nil {
1425 return vndkdep.isVndkExt()
1426 }
1427 return false
1428}
1429
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001430func (c *Module) SubName() string {
1431 return c.Properties.SubName
1432}
1433
Ivan Lozano52767be2019-10-18 14:49:46 -07001434func (c *Module) MustUseVendorVariant() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001435 return c.IsVndkSp() || c.Properties.MustUseVendorVariant
Vic Yangefd249e2018-11-12 20:19:56 -08001436}
1437
Logan Chienf3511742017-10-31 18:04:35 +08001438func (c *Module) getVndkExtendsModuleName() string {
1439 if vndkdep := c.vndkdep; vndkdep != nil {
1440 return vndkdep.getVndkExtendsModuleName()
1441 }
1442 return ""
1443}
1444
Jiyong Park25fc6a92018-11-18 18:02:45 +09001445func (c *Module) IsStubs() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001446 if lib := c.library; lib != nil {
1447 return lib.buildStubs()
Jiyong Park25fc6a92018-11-18 18:02:45 +09001448 }
1449 return false
1450}
1451
1452func (c *Module) HasStubsVariants() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001453 if lib := c.library; lib != nil {
1454 return lib.hasStubsVariants()
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001455 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09001456 return false
1457}
1458
Alan Stokes73feba32022-11-14 12:21:24 +00001459func (c *Module) IsStubsImplementationRequired() bool {
1460 if lib := c.library; lib != nil {
1461 return lib.isStubsImplementationRequired()
1462 }
1463 return false
1464}
1465
Colin Cross0477b422020-10-13 18:43:54 -07001466// If this is a stubs library, ImplementationModuleName returns the name of the module that contains
1467// the implementation. If it is an implementation library it returns its own name.
1468func (c *Module) ImplementationModuleName(ctx android.BaseModuleContext) string {
1469 name := ctx.OtherModuleName(c)
1470 if versioned, ok := c.linker.(versionedInterface); ok {
1471 name = versioned.implementationModuleName(name)
1472 }
1473 return name
1474}
1475
Martin Stjernholm2856c662020-12-02 15:03:42 +00001476// Similar to ImplementationModuleName, but uses the Make variant of the module
1477// name as base name, for use in AndroidMk output. E.g. for a prebuilt module
1478// where the Soong name is prebuilt_foo, this returns foo (which works in Make
1479// under the premise that the prebuilt module overrides its source counterpart
1480// if it is exposed to Make).
1481func (c *Module) ImplementationModuleNameForMake(ctx android.BaseModuleContext) string {
1482 name := c.BaseModuleName()
1483 if versioned, ok := c.linker.(versionedInterface); ok {
1484 name = versioned.implementationModuleName(name)
1485 }
1486 return name
1487}
1488
Jiyong Park7d55b612021-06-11 17:22:09 +09001489func (c *Module) Bootstrap() bool {
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001490 return Bool(c.Properties.Bootstrap)
1491}
1492
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001493func (c *Module) nativeCoverage() bool {
Pirama Arumuga Nainar5f69b9a2019-09-12 13:18:48 -07001494 // Bug: http://b/137883967 - native-bridge modules do not currently work with coverage
1495 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1496 return false
1497 }
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001498 return c.linker != nil && c.linker.nativeCoverage()
1499}
1500
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001501func (c *Module) IsSnapshotPrebuilt() bool {
Ivan Lozanod1dec542021-05-26 15:33:11 -04001502 if p, ok := c.linker.(SnapshotInterface); ok {
1503 return p.IsSnapshotPrebuilt()
Inseob Kimeec88e12020-01-22 11:11:29 +09001504 }
1505 return false
Inseob Kim8471cda2019-11-15 09:59:12 +09001506}
1507
Bill Peckham945441c2020-08-31 16:07:58 -07001508func (c *Module) ExcludeFromVendorSnapshot() bool {
1509 return Bool(c.Properties.Exclude_from_vendor_snapshot)
1510}
1511
Jose Galmesf7294582020-11-13 12:07:36 -08001512func (c *Module) ExcludeFromRecoverySnapshot() bool {
1513 return Bool(c.Properties.Exclude_from_recovery_snapshot)
1514}
1515
Jiyong Parkf1194352019-02-25 11:05:47 +09001516func isBionic(name string) bool {
1517 switch name {
Jooyung Hanbff73352022-12-13 18:29:44 +09001518 case "libc", "libm", "libdl", "libdl_android", "linker":
Jiyong Parkf1194352019-02-25 11:05:47 +09001519 return true
1520 }
1521 return false
1522}
1523
Martin Stjernholm279de572019-09-10 23:18:20 +01001524func InstallToBootstrap(name string, config android.Config) bool {
Florian Mayer95cd6db2023-03-23 17:48:07 -07001525 if name == "libclang_rt.hwasan" || name == "libc_hwasan" {
Jooyung Han8ce8db92020-05-15 19:05:05 +09001526 return true
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001527 }
1528 return isBionic(name)
1529}
1530
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001531func (c *Module) XrefCcFiles() android.Paths {
1532 return c.kytheFiles
1533}
1534
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001535func (c *Module) isCfiAssemblySupportEnabled() bool {
1536 return c.sanitize != nil &&
1537 Bool(c.sanitize.Properties.Sanitize.Config.Cfi_assembly_support)
1538}
1539
Inseob Kim800d1142021-06-14 12:03:51 +09001540func (c *Module) InstallInRoot() bool {
1541 return c.installer != nil && c.installer.installInRoot()
1542}
1543
Colin Crossca860ac2016-01-04 14:34:37 -08001544type baseModuleContext struct {
Colin Cross0ea8ba82019-06-06 14:33:29 -07001545 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001546 moduleContextImpl
1547}
1548
Colin Cross37047f12016-12-13 17:06:13 -08001549type depsContext struct {
1550 android.BottomUpMutatorContext
1551 moduleContextImpl
1552}
1553
Colin Crossca860ac2016-01-04 14:34:37 -08001554type moduleContext struct {
Colin Cross635c3b02016-05-18 15:37:25 -07001555 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001556 moduleContextImpl
1557}
1558
1559type moduleContextImpl struct {
1560 mod *Module
1561 ctx BaseModuleContext
1562}
1563
Colin Crossb98c8b02016-07-29 13:44:28 -07001564func (ctx *moduleContextImpl) toolchain() config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001565 return ctx.mod.toolchain(ctx.ctx)
1566}
1567
1568func (ctx *moduleContextImpl) static() bool {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00001569 return ctx.mod.static()
Colin Crossca860ac2016-01-04 14:34:37 -08001570}
1571
1572func (ctx *moduleContextImpl) staticBinary() bool {
Jiyong Park379de2f2018-12-19 02:47:14 +09001573 return ctx.mod.staticBinary()
Colin Crossca860ac2016-01-04 14:34:37 -08001574}
1575
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07001576func (ctx *moduleContextImpl) testBinary() bool {
1577 return ctx.mod.testBinary()
1578}
1579
Yi Kong56fc1b62022-09-06 16:24:00 +08001580func (ctx *moduleContextImpl) testLibrary() bool {
1581 return ctx.mod.testLibrary()
1582}
1583
Jiyong Park1d1119f2019-07-29 21:27:18 +09001584func (ctx *moduleContextImpl) header() bool {
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001585 return ctx.mod.Header()
Jiyong Park1d1119f2019-07-29 21:27:18 +09001586}
1587
Inseob Kim7f283f42020-06-01 21:53:49 +09001588func (ctx *moduleContextImpl) binary() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001589 return ctx.mod.Binary()
Inseob Kim7f283f42020-06-01 21:53:49 +09001590}
1591
Inseob Kim1042d292020-06-01 23:23:05 +09001592func (ctx *moduleContextImpl) object() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001593 return ctx.mod.Object()
Inseob Kim1042d292020-06-01 23:23:05 +09001594}
1595
Jooyung Hanccce2f22020-03-07 03:45:53 +09001596func (ctx *moduleContextImpl) canUseSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001597 return ctx.mod.canUseSdk()
Jooyung Hanccce2f22020-03-07 03:45:53 +09001598}
1599
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001600func (ctx *moduleContextImpl) useSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001601 return ctx.mod.UseSdk()
Colin Crossca860ac2016-01-04 14:34:37 -08001602}
1603
1604func (ctx *moduleContextImpl) sdkVersion() string {
Dan Willemsena96ff642016-06-07 12:34:45 -07001605 if ctx.ctx.Device() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001606 if ctx.useVndk() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001607 vndkVer := ctx.mod.VndkVersion()
Jooyung Han03302ee2020-04-08 09:22:26 +09001608 if inList(vndkVer, ctx.ctx.Config().PlatformVersionActiveCodenames()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001609 return "current"
Justin Yun732aa6a2018-03-23 17:43:47 +09001610 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001611 return vndkVer
Dan Willemsend2ede872016-11-18 14:54:24 -08001612 }
Justin Yun732aa6a2018-03-23 17:43:47 +09001613 return String(ctx.mod.Properties.Sdk_version)
Dan Willemsena96ff642016-06-07 12:34:45 -07001614 }
1615 return ""
Colin Crossca860ac2016-01-04 14:34:37 -08001616}
1617
Jiyong Parkb35a8192020-08-10 15:59:36 +09001618func (ctx *moduleContextImpl) minSdkVersion() string {
1619 ver := ctx.mod.MinSdkVersion()
1620 if ver == "apex_inherit" && !ctx.isForPlatform() {
1621 ver = ctx.apexSdkVersion().String()
1622 }
1623 if ver == "apex_inherit" || ver == "" {
1624 ver = ctx.sdkVersion()
1625 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001626 // For crt objects, the meaning of min_sdk_version is very different from other types of
1627 // module. For them, min_sdk_version defines the oldest version that the build system will
1628 // create versioned variants for. For example, if min_sdk_version is 16, then sdk variant of
1629 // the crt object has local variants of 16, 17, ..., up to the latest version. sdk_version
1630 // and min_sdk_version properties of the variants are set to the corresponding version
Jiyong Park5df7bd32021-08-25 16:18:46 +09001631 // numbers. However, the non-sdk variant (for apex or platform) of the crt object is left
1632 // untouched. min_sdk_version: 16 doesn't actually mean that the non-sdk variant has to
1633 // support such an old version. The version is set to the later version in case when the
1634 // non-sdk variant is for the platform, or the min_sdk_version of the containing APEX if
1635 // it's for an APEX.
1636 if ctx.mod.isCrt() && !ctx.isSdkVariant() {
1637 if ctx.isForPlatform() {
1638 ver = strconv.Itoa(android.FutureApiLevelInt)
1639 } else { // for apex
1640 ver = ctx.apexSdkVersion().String()
1641 if ver == "" { // in case when min_sdk_version was not set by the APEX
1642 ver = ctx.sdkVersion()
1643 }
1644 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001645 }
1646
Jiyong Parkb35a8192020-08-10 15:59:36 +09001647 // Also make sure that minSdkVersion is not greater than sdkVersion, if they are both numbers
1648 sdkVersionInt, err := strconv.Atoi(ctx.sdkVersion())
1649 minSdkVersionInt, err2 := strconv.Atoi(ver)
1650 if err == nil && err2 == nil {
1651 if sdkVersionInt < minSdkVersionInt {
1652 return strconv.Itoa(sdkVersionInt)
1653 }
1654 }
1655 return ver
1656}
1657
1658func (ctx *moduleContextImpl) isSdkVariant() bool {
1659 return ctx.mod.IsSdkVariant()
1660}
1661
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001662func (ctx *moduleContextImpl) useVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001663 return ctx.mod.UseVndk()
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001664}
Justin Yun8effde42017-06-23 19:24:43 +09001665
Colin Cross95f1ca02020-10-29 20:47:22 -07001666func (ctx *moduleContextImpl) isNdk(config android.Config) bool {
1667 return ctx.mod.IsNdk(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001668}
1669
Colin Cross127bb8b2020-12-16 16:46:01 -08001670func (ctx *moduleContextImpl) IsLlndk() bool {
1671 return ctx.mod.IsLlndk()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001672}
1673
Colin Cross127bb8b2020-12-16 16:46:01 -08001674func (ctx *moduleContextImpl) IsLlndkPublic() bool {
1675 return ctx.mod.IsLlndkPublic()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001676}
1677
Colin Cross127bb8b2020-12-16 16:46:01 -08001678func (ctx *moduleContextImpl) isImplementationForLLNDKPublic() bool {
1679 return ctx.mod.isImplementationForLLNDKPublic()
1680}
1681
1682func (ctx *moduleContextImpl) IsVndkPrivate() bool {
1683 return ctx.mod.IsVndkPrivate()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001684}
1685
Logan Chienf3511742017-10-31 18:04:35 +08001686func (ctx *moduleContextImpl) isVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001687 return ctx.mod.IsVndk()
Logan Chienf3511742017-10-31 18:04:35 +08001688}
1689
Yi Kong4ef54592022-02-14 20:00:10 +08001690func (ctx *moduleContextImpl) isAfdoCompile() bool {
1691 return ctx.mod.isAfdoCompile()
1692}
1693
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001694func (ctx *moduleContextImpl) isOrderfileCompile() bool {
1695 return ctx.mod.isOrderfileCompile()
1696}
1697
Yi Kongc702ebd2022-08-19 16:02:45 +08001698func (ctx *moduleContextImpl) isCfi() bool {
1699 return ctx.mod.isCfi()
1700}
1701
Yi Konged79fa32023-06-04 17:15:42 +09001702func (ctx *moduleContextImpl) isFuzzer() bool {
1703 return ctx.mod.isFuzzer()
1704}
1705
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001706func (ctx *moduleContextImpl) isNDKStubLibrary() bool {
1707 return ctx.mod.isNDKStubLibrary()
1708}
1709
Justin Yun8effde42017-06-23 19:24:43 +09001710func (ctx *moduleContextImpl) isVndkSp() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001711 return ctx.mod.IsVndkSp()
Logan Chienf3511742017-10-31 18:04:35 +08001712}
1713
Ivan Lozanof9e21722020-12-02 09:00:51 -05001714func (ctx *moduleContextImpl) IsVndkExt() bool {
1715 return ctx.mod.IsVndkExt()
Justin Yun8effde42017-06-23 19:24:43 +09001716}
1717
Colin Cross5271fea2021-04-27 13:06:04 -07001718func (ctx *moduleContextImpl) IsVendorPublicLibrary() bool {
1719 return ctx.mod.IsVendorPublicLibrary()
1720}
1721
Vic Yangefd249e2018-11-12 20:19:56 -08001722func (ctx *moduleContextImpl) mustUseVendorVariant() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001723 return ctx.mod.MustUseVendorVariant()
Vic Yangefd249e2018-11-12 20:19:56 -08001724}
1725
Dan Willemsen8146b2f2016-03-30 21:00:30 -07001726func (ctx *moduleContextImpl) selectedStl() string {
1727 if stl := ctx.mod.stl; stl != nil {
1728 return stl.Properties.SelectedStl
1729 }
1730 return ""
1731}
1732
Ivan Lozanobd721262018-11-27 14:33:03 -08001733func (ctx *moduleContextImpl) useClangLld(actx ModuleContext) bool {
1734 return ctx.mod.linker.useClangLld(actx)
1735}
1736
Colin Crossce75d2c2016-10-06 16:12:58 -07001737func (ctx *moduleContextImpl) baseModuleName() string {
1738 return ctx.mod.ModuleBase.BaseModuleName()
1739}
1740
Logan Chienf3511742017-10-31 18:04:35 +08001741func (ctx *moduleContextImpl) getVndkExtendsModuleName() string {
1742 return ctx.mod.getVndkExtendsModuleName()
1743}
1744
Logan Chiene274fc92019-12-03 11:18:32 -08001745func (ctx *moduleContextImpl) isForPlatform() bool {
Colin Cross56a83212020-09-15 18:30:11 -07001746 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).IsForPlatform()
Logan Chiene274fc92019-12-03 11:18:32 -08001747}
1748
Colin Crosse07f2312020-08-13 11:24:56 -07001749func (ctx *moduleContextImpl) apexVariationName() string {
Colin Cross56a83212020-09-15 18:30:11 -07001750 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).ApexVariationName
Jiyong Park25fc6a92018-11-18 18:02:45 +09001751}
1752
Dan Albertc8060532020-07-22 22:32:17 -07001753func (ctx *moduleContextImpl) apexSdkVersion() android.ApiLevel {
Jooyung Han75568392020-03-20 04:29:24 +09001754 return ctx.mod.apexSdkVersion
Jooyung Hanccce2f22020-03-07 03:45:53 +09001755}
1756
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001757func (ctx *moduleContextImpl) bootstrap() bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09001758 return ctx.mod.Bootstrap()
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001759}
1760
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001761func (ctx *moduleContextImpl) nativeCoverage() bool {
1762 return ctx.mod.nativeCoverage()
1763}
1764
Colin Cross56a83212020-09-15 18:30:11 -07001765func (ctx *moduleContextImpl) directlyInAnyApex() bool {
1766 return ctx.mod.DirectlyInAnyApex()
1767}
1768
Colin Cross95b07f22020-12-16 11:06:50 -08001769func (ctx *moduleContextImpl) isPreventInstall() bool {
1770 return ctx.mod.Properties.PreventInstall
1771}
1772
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -08001773func (ctx *moduleContextImpl) getSharedFlags() *SharedFlags {
1774 shared := &ctx.mod.sharedFlags
1775 if shared.flagsMap == nil {
1776 shared.numSharedFlags = 0
1777 shared.flagsMap = make(map[string]string)
1778 }
1779 return shared
1780}
1781
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001782func (ctx *moduleContextImpl) isCfiAssemblySupportEnabled() bool {
1783 return ctx.mod.isCfiAssemblySupportEnabled()
1784}
1785
Colin Cross635c3b02016-05-18 15:37:25 -07001786func newBaseModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001787 return &Module{
1788 hod: hod,
1789 multilib: multilib,
1790 }
1791}
1792
Colin Cross635c3b02016-05-18 15:37:25 -07001793func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001794 module := newBaseModule(hod, multilib)
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001795 module.features = []feature{
1796 &tidyFeature{},
1797 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001798 module.stl = &stl{}
Colin Cross16b23492016-01-06 14:41:07 -08001799 module.sanitize = &sanitize{}
Dan Willemsen581341d2017-02-09 16:16:31 -08001800 module.coverage = &coverage{}
Cory Barkera1da26f2022-06-07 20:12:06 +00001801 module.fuzzer = &fuzzer{}
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001802 module.sabi = &sabi{}
Justin Yun8effde42017-06-23 19:24:43 +09001803 module.vndkdep = &vndkdep{}
Stephen Craneba090d12017-05-09 15:44:35 -07001804 module.lto = &lto{}
Yi Kongeb8efc92021-12-09 18:06:29 +08001805 module.afdo = &afdo{}
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001806 module.orderfile = &orderfile{}
Colin Crossca860ac2016-01-04 14:34:37 -08001807 return module
1808}
1809
Colin Crossce75d2c2016-10-06 16:12:58 -07001810func (c *Module) Prebuilt() *android.Prebuilt {
1811 if p, ok := c.linker.(prebuiltLinkerInterface); ok {
1812 return p.prebuilt()
1813 }
1814 return nil
1815}
1816
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001817func (c *Module) IsPrebuilt() bool {
1818 return c.Prebuilt() != nil
1819}
1820
Colin Crossce75d2c2016-10-06 16:12:58 -07001821func (c *Module) Name() string {
1822 name := c.ModuleBase.Name()
Dan Willemsen01a90592017-04-07 15:21:13 -07001823 if p, ok := c.linker.(interface {
1824 Name(string) string
1825 }); ok {
Colin Crossce75d2c2016-10-06 16:12:58 -07001826 name = p.Name(name)
1827 }
1828 return name
1829}
1830
Alex Light3d673592019-01-18 14:37:31 -08001831func (c *Module) Symlinks() []string {
1832 if p, ok := c.installer.(interface {
1833 symlinkList() []string
1834 }); ok {
1835 return p.symlinkList()
1836 }
1837 return nil
1838}
1839
Roland Levillainf89cd092019-07-29 16:22:59 +01001840func (c *Module) IsTestPerSrcAllTestsVariation() bool {
1841 test, ok := c.linker.(testPerSrc)
1842 return ok && test.isAllTestsVariation()
1843}
1844
Chris Parsons216e10a2020-07-09 17:12:52 -04001845func (c *Module) DataPaths() []android.DataPath {
Liz Kammer1c14a212020-05-12 15:26:55 -07001846 if p, ok := c.installer.(interface {
Chris Parsons216e10a2020-07-09 17:12:52 -04001847 dataPaths() []android.DataPath
Liz Kammer1c14a212020-05-12 15:26:55 -07001848 }); ok {
1849 return p.dataPaths()
1850 }
1851 return nil
1852}
1853
Ivan Lozanof1868af2022-04-12 13:08:36 -04001854func getNameSuffixWithVndkVersion(ctx android.ModuleContext, c LinkableInterface) string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001855 // Returns the name suffix for product and vendor variants. If the VNDK version is not
1856 // "current", it will append the VNDK version to the name suffix.
1857 var vndkVersion string
1858 var nameSuffix string
Ivan Lozanof9e21722020-12-02 09:00:51 -05001859 if c.InProduct() {
Justin Yund00f5ca2021-02-03 19:43:02 +09001860 if c.ProductSpecific() {
1861 // If the module is product specific with 'product_specific: true',
1862 // do not add a name suffix because it is a base module.
1863 return ""
1864 }
Justin Yunaf1fde42023-09-27 16:22:10 +09001865 return ProductSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001866 } else {
1867 vndkVersion = ctx.DeviceConfig().VndkVersion()
Ivan Lozanoe6d30982021-02-05 10:57:43 -05001868 nameSuffix = VendorSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001869 }
1870 if vndkVersion == "current" {
1871 vndkVersion = ctx.DeviceConfig().PlatformVndkVersion()
1872 }
Ivan Lozanof1868af2022-04-12 13:08:36 -04001873 if c.VndkVersion() != vndkVersion && c.VndkVersion() != "" {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001874 // add version suffix only if the module is using different vndk version than the
1875 // version in product or vendor partition.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001876 nameSuffix += "." + c.VndkVersion()
Justin Yun5f7f7e82019-11-18 19:52:14 +09001877 }
1878 return nameSuffix
1879}
1880
Ivan Lozanof1868af2022-04-12 13:08:36 -04001881func GetSubnameProperty(actx android.ModuleContext, c LinkableInterface) string {
1882 var subName = ""
Inseob Kim64c43952019-08-26 16:52:35 +09001883
1884 if c.Target().NativeBridge == android.NativeBridgeEnabled {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001885 subName += NativeBridgeSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001886 }
1887
Colin Cross127bb8b2020-12-16 16:46:01 -08001888 llndk := c.IsLlndk()
Colin Cross627280f2021-04-26 16:53:58 -07001889 if llndk || (c.UseVndk() && c.HasNonSystemVariants()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001890 // .vendor.{version} suffix is added for vendor variant or .product.{version} suffix is
1891 // added for product variant only when we have vendor and product variants with core
1892 // variant. The suffix is not added for vendor-only or product-only module.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001893 subName += getNameSuffixWithVndkVersion(actx, c)
Colin Cross5271fea2021-04-27 13:06:04 -07001894 } else if c.IsVendorPublicLibrary() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001895 subName += vendorPublicLibrarySuffix
1896 } else if c.IsVndkPrebuiltLibrary() {
Inseob Kim64c43952019-08-26 16:52:35 +09001897 // .vendor suffix is added for backward compatibility with VNDK snapshot whose names with
1898 // such suffixes are already hard-coded in prebuilts/vndk/.../Android.bp.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001899 subName += VendorSuffix
Yifan Hong1b3348d2020-01-21 15:53:22 -08001900 } else if c.InRamdisk() && !c.OnlyInRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001901 subName += RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001902 } else if c.InVendorRamdisk() && !c.OnlyInVendorRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001903 subName += VendorRamdiskSuffix
Ivan Lozano52767be2019-10-18 14:49:46 -07001904 } else if c.InRecovery() && !c.OnlyInRecovery() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001905 subName += RecoverySuffix
1906 } else if c.IsSdkVariant() && (c.SdkAndPlatformVariantVisibleToMake() || c.SplitPerApiLevel()) {
1907 subName += sdkSuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001908 if c.SplitPerApiLevel() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001909 subName += "." + c.SdkVersion()
Dan Albert92fe7402020-07-15 13:33:30 -07001910 }
Spandan Dasb2b41d52023-04-13 18:15:05 +00001911 } else if c.IsStubs() && c.IsSdkVariant() {
1912 // Public API surface (NDK)
1913 // Add a suffix to this stub variant to distinguish it from the module-lib stub variant.
1914 subName = sdkSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001915 }
Ivan Lozanof1868af2022-04-12 13:08:36 -04001916
1917 return subName
Chris Parsons8d6e4332021-02-22 16:13:50 -05001918}
1919
Sam Delmerico75dbca22023-04-20 13:13:25 +00001920func moduleContextFromAndroidModuleContext(actx android.ModuleContext, c *Module) ModuleContext {
1921 ctx := &moduleContext{
1922 ModuleContext: actx,
1923 moduleContextImpl: moduleContextImpl{
1924 mod: c,
1925 },
1926 }
1927 ctx.ctx = ctx
1928 return ctx
1929}
1930
Spandan Das20fce2d2023-04-12 17:21:39 +00001931// TODO (b/277651159): Remove this allowlist
1932var (
1933 skipStubLibraryMultipleApexViolation = map[string]bool{
1934 "libclang_rt.asan": true,
1935 "libclang_rt.hwasan": true,
1936 // runtime apex
1937 "libc": true,
1938 "libc_hwasan": true,
1939 "libdl_android": true,
1940 "libm": true,
1941 "libdl": true,
1942 // art apex
1943 "libandroidio": true,
1944 "libdexfile": true,
1945 "libnativebridge": true,
1946 "libnativehelper": true,
1947 "libnativeloader": true,
1948 "libsigchain": true,
1949 }
1950)
1951
1952// Returns true if a stub library could be installed in multiple apexes
1953func (c *Module) stubLibraryMultipleApexViolation(ctx android.ModuleContext) bool {
1954 // If this is not an apex variant, no check necessary
1955 if !c.InAnyApex() {
1956 return false
1957 }
1958 // If this is not a stub library, no check necessary
1959 if !c.HasStubsVariants() {
1960 return false
1961 }
1962 // Skip the allowlist
1963 // Use BaseModuleName so that this matches prebuilts.
1964 if _, exists := skipStubLibraryMultipleApexViolation[c.BaseModuleName()]; exists {
1965 return false
1966 }
1967
1968 _, aaWithoutTestApexes, _ := android.ListSetDifference(c.ApexAvailable(), c.TestApexes())
1969 // Stub libraries should not have more than one apex_available
1970 if len(aaWithoutTestApexes) > 1 {
1971 return true
1972 }
1973 // Stub libraries should not use the wildcard
1974 if aaWithoutTestApexes[0] == android.AvailableToAnyApex {
1975 return true
1976 }
1977 // Default: no violation
1978 return false
1979}
1980
Chris Parsons8d6e4332021-02-22 16:13:50 -05001981func (c *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
Chris Parsons8d6e4332021-02-22 16:13:50 -05001982 // Handle the case of a test module split by `test_per_src` mutator.
1983 //
1984 // The `test_per_src` mutator adds an extra variation named "", depending on all the other
1985 // `test_per_src` variations of the test module. Set `outputFile` to an empty path for this
1986 // module and return early, as this module does not produce an output file per se.
1987 if c.IsTestPerSrcAllTestsVariation() {
1988 c.outputFile = android.OptionalPath{}
1989 return
1990 }
1991
Ivan Lozanof1868af2022-04-12 13:08:36 -04001992 c.Properties.SubName = GetSubnameProperty(actx, c)
Chris Parsons8d6e4332021-02-22 16:13:50 -05001993 apexInfo := actx.Provider(android.ApexInfoProvider).(android.ApexInfo)
1994 if !apexInfo.IsForPlatform() {
1995 c.hideApexVariantFromMake = true
1996 }
1997
Chris Parsonseefc9e62021-04-02 17:36:47 -04001998 c.makeLinkType = GetMakeLinkType(actx, c)
1999
Sam Delmerico75dbca22023-04-20 13:13:25 +00002000 ctx := moduleContextFromAndroidModuleContext(actx, c)
Colin Crossca860ac2016-01-04 14:34:37 -08002001
Colin Crossf18e1102017-11-16 14:33:08 -08002002 deps := c.depsToPaths(ctx)
2003 if ctx.Failed() {
2004 return
2005 }
2006
Joe Onorato37f900c2023-07-18 16:58:16 -07002007 for _, generator := range c.generators {
2008 gen := generator.GeneratorSources(ctx)
2009 deps.IncludeDirs = append(deps.IncludeDirs, gen.IncludeDirs...)
2010 deps.ReexportedDirs = append(deps.ReexportedDirs, gen.ReexportedDirs...)
2011 deps.GeneratedDeps = append(deps.GeneratedDeps, gen.Headers...)
2012 deps.ReexportedGeneratedHeaders = append(deps.ReexportedGeneratedHeaders, gen.Headers...)
2013 deps.ReexportedDeps = append(deps.ReexportedDeps, gen.Headers...)
2014 if len(deps.Objs.objFiles) == 0 {
2015 // If we are reusuing object files (which happens when we're a shared library and we're
2016 // reusing our static variant's object files), then skip adding the actual source files,
2017 // because we already have the object for it.
2018 deps.GeneratedSources = append(deps.GeneratedSources, gen.Sources...)
2019 }
2020 }
2021
2022 if ctx.Failed() {
2023 return
2024 }
2025
Spandan Das20fce2d2023-04-12 17:21:39 +00002026 if c.stubLibraryMultipleApexViolation(actx) {
2027 actx.PropertyErrorf("apex_available",
2028 "Stub libraries should have a single apex_available (test apexes excluded). Got %v", c.ApexAvailable())
2029 }
Dan Willemsen8536d6b2018-10-07 20:54:34 -07002030 if c.Properties.Clang != nil && *c.Properties.Clang == false {
2031 ctx.PropertyErrorf("clang", "false (GCC) is no longer supported")
Alixb5f6d9e2022-04-20 23:00:58 +00002032 } else if c.Properties.Clang != nil && !ctx.DeviceConfig().BuildBrokenClangProperty() {
2033 ctx.PropertyErrorf("clang", "property is deprecated, see Changes.md file")
Dan Willemsen8536d6b2018-10-07 20:54:34 -07002034 }
2035
Colin Crossca860ac2016-01-04 14:34:37 -08002036 flags := Flags{
2037 Toolchain: c.toolchain(ctx),
Sasha Smundak2a4549e2018-11-05 16:49:08 -08002038 EmitXrefs: ctx.Config().EmitXrefRules(),
Colin Crossca860ac2016-01-04 14:34:37 -08002039 }
Joe Onorato37f900c2023-07-18 16:58:16 -07002040 for _, generator := range c.generators {
2041 flags = generator.GeneratorFlags(ctx, flags, deps)
2042 }
Colin Crossca860ac2016-01-04 14:34:37 -08002043 if c.compiler != nil {
Colin Crossf18e1102017-11-16 14:33:08 -08002044 flags = c.compiler.compilerFlags(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08002045 }
2046 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002047 flags = c.linker.linkerFlags(ctx, flags)
Colin Crossca860ac2016-01-04 14:34:37 -08002048 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002049 if c.stl != nil {
2050 flags = c.stl.flags(ctx, flags)
2051 }
Colin Cross16b23492016-01-06 14:41:07 -08002052 if c.sanitize != nil {
2053 flags = c.sanitize.flags(ctx, flags)
2054 }
Dan Willemsen581341d2017-02-09 16:16:31 -08002055 if c.coverage != nil {
Pirama Arumuga Nainar82fe59b2019-07-02 14:55:35 -07002056 flags, deps = c.coverage.flags(ctx, flags, deps)
Dan Willemsen581341d2017-02-09 16:16:31 -08002057 }
Cory Barkera1da26f2022-06-07 20:12:06 +00002058 if c.fuzzer != nil {
2059 flags = c.fuzzer.flags(ctx, flags)
2060 }
Stephen Craneba090d12017-05-09 15:44:35 -07002061 if c.lto != nil {
2062 flags = c.lto.flags(ctx, flags)
2063 }
Yi Kongeb8efc92021-12-09 18:06:29 +08002064 if c.afdo != nil {
2065 flags = c.afdo.flags(ctx, flags)
2066 }
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00002067 if c.orderfile != nil {
2068 flags = c.orderfile.flags(ctx, flags)
2069 }
Colin Crossca860ac2016-01-04 14:34:37 -08002070 for _, feature := range c.features {
2071 flags = feature.flags(ctx, flags)
2072 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002073 if ctx.Failed() {
2074 return
2075 }
2076
Colin Cross4af21ed2019-11-04 09:37:55 -08002077 flags.Local.CFlags, _ = filterList(flags.Local.CFlags, config.IllegalFlags)
2078 flags.Local.CppFlags, _ = filterList(flags.Local.CppFlags, config.IllegalFlags)
2079 flags.Local.ConlyFlags, _ = filterList(flags.Local.ConlyFlags, config.IllegalFlags)
Colin Cross3f40fa42015-01-30 17:27:36 -08002080
Colin Cross4af21ed2019-11-04 09:37:55 -08002081 flags.Local.CommonFlags = append(flags.Local.CommonFlags, deps.Flags...)
Inseob Kim69378442019-06-03 19:10:47 +09002082
2083 for _, dir := range deps.IncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08002084 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-I"+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09002085 }
2086 for _, dir := range deps.SystemIncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08002087 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-isystem "+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09002088 }
2089
Colin Cross3e5e7782022-06-17 22:17:05 +00002090 flags.Local.LdFlags = append(flags.Local.LdFlags, deps.LdFlags...)
2091
Fabien Sanglardd61f1f42017-01-10 16:21:22 -08002092 c.flags = flags
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -07002093 // We need access to all the flags seen by a source file.
2094 if c.sabi != nil {
2095 flags = c.sabi.flags(ctx, flags)
2096 }
Dan Willemsen98ab3112019-08-27 21:20:40 -07002097
Colin Cross4af21ed2019-11-04 09:37:55 -08002098 flags.AssemblerWithCpp = inList("-xassembler-with-cpp", flags.Local.AsFlags)
Dan Willemsen98ab3112019-08-27 21:20:40 -07002099
Joe Onorato37f900c2023-07-18 16:58:16 -07002100 for _, generator := range c.generators {
2101 generator.GeneratorBuildActions(ctx, flags, deps)
2102 }
2103
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002104 var objs Objects
Colin Crossca860ac2016-01-04 14:34:37 -08002105 if c.compiler != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002106 objs = c.compiler.compile(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08002107 if ctx.Failed() {
2108 return
2109 }
Sasha Smundak2a4549e2018-11-05 16:49:08 -08002110 c.kytheFiles = objs.kytheFiles
Chih-Hung Hsieh80783772021-10-11 16:46:56 -07002111 c.objFiles = objs.objFiles
2112 c.tidyFiles = objs.tidyFiles
Colin Cross3f40fa42015-01-30 17:27:36 -08002113 }
2114
Colin Crossca860ac2016-01-04 14:34:37 -08002115 if c.linker != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002116 outputFile := c.linker.link(ctx, flags, deps, objs)
Colin Crossca860ac2016-01-04 14:34:37 -08002117 if ctx.Failed() {
2118 return
2119 }
Colin Cross635c3b02016-05-18 15:37:25 -07002120 c.outputFile = android.OptionalPathForPath(outputFile)
Jiyong Parkb0788572018-12-20 22:10:17 +09002121
Chris Parsons94a0bba2021-06-04 15:03:47 -04002122 c.maybeUnhideFromMake()
Inseob Kimeda2e9c2020-03-03 22:06:32 +09002123
Jose Galmes6f843bc2020-12-11 13:36:29 -08002124 // glob exported headers for snapshot, if BOARD_VNDK_VERSION is current or
2125 // RECOVERY_SNAPSHOT_VERSION is current.
2126 if i, ok := c.linker.(snapshotLibraryInterface); ok {
Ivan Lozanod7586b62021-04-01 09:49:36 -04002127 if ShouldCollectHeadersForSnapshot(ctx, c, apexInfo) {
Inseob Kimeda2e9c2020-03-03 22:06:32 +09002128 i.collectHeadersForSnapshot(ctx)
2129 }
2130 }
Colin Crossce75d2c2016-10-06 16:12:58 -07002131 }
Aditya Choudhary87b2ab22023-11-17 15:27:06 +00002132 if c.testModule {
2133 ctx.SetProvider(testing.TestModuleProviderKey, testing.TestModuleProviderData{})
2134 }
Aditya Choudhary26df39f2023-11-29 16:42:42 +00002135 ctx.SetProvider(blueprint.SrcsFileProviderKey, blueprint.SrcsFileProviderData{SrcPaths: deps.GeneratedSources.Strings()})
Colin Cross5049f022015-03-18 13:28:46 -07002136
Colin Crossd788b3e2023-11-28 13:14:56 -08002137 aconfig.CollectDependencyAconfigFiles(ctx, &c.mergedAconfigFiles)
Yu Liueae7b362023-11-16 17:05:47 -08002138
Chris Parsons94a0bba2021-06-04 15:03:47 -04002139 c.maybeInstall(ctx, apexInfo)
2140}
2141
2142func (c *Module) maybeUnhideFromMake() {
2143 // If a lib is directly included in any of the APEXes or is not available to the
2144 // platform (which is often the case when the stub is provided as a prebuilt),
2145 // unhide the stubs variant having the latest version gets visible to make. In
2146 // addition, the non-stubs variant is renamed to <libname>.bootstrap. This is to
2147 // force anything in the make world to link against the stubs library. (unless it
2148 // is explicitly referenced via .bootstrap suffix or the module is marked with
2149 // 'bootstrap: true').
2150 if c.HasStubsVariants() && c.NotInPlatform() && !c.InRamdisk() &&
2151 !c.InRecovery() && !c.UseVndk() && !c.static() && !c.isCoverageVariant() &&
2152 c.IsStubs() && !c.InVendorRamdisk() {
2153 c.Properties.HideFromMake = false // unhide
2154 // Note: this is still non-installable
2155 }
2156}
2157
Colin Cross8ff10582023-12-07 13:10:56 -08002158// maybeInstall is called at the end of both GenerateAndroidBuildActions to run the
2159// install hooks for installable modules, like binaries and tests.
Chris Parsons94a0bba2021-06-04 15:03:47 -04002160func (c *Module) maybeInstall(ctx ModuleContext, apexInfo android.ApexInfo) {
Colin Cross1bc94122021-10-28 13:25:54 -07002161 if !proptools.BoolDefault(c.Installable(), true) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002162 // If the module has been specifically configure to not be installed then
2163 // hide from make as otherwise it will break when running inside make
2164 // as the output path to install will not be specified. Not all uninstallable
2165 // modules can be hidden from make as some are needed for resolving make side
2166 // dependencies.
2167 c.HideFromMake()
Ivan Lozanod7586b62021-04-01 09:49:36 -04002168 } else if !installable(c, apexInfo) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002169 c.SkipInstall()
2170 }
2171
2172 // Still call c.installer.install though, the installs will be stored as PackageSpecs
2173 // to allow using the outputs in a genrule.
2174 if c.installer != nil && c.outputFile.Valid() {
Colin Crossce75d2c2016-10-06 16:12:58 -07002175 c.installer.install(ctx, c.outputFile.Path())
2176 if ctx.Failed() {
2177 return
Colin Crossca860ac2016-01-04 14:34:37 -08002178 }
Dan Albertc403f7c2015-03-18 14:01:18 -07002179 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002180}
2181
Colin Cross0ea8ba82019-06-06 14:33:29 -07002182func (c *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08002183 if c.cachedToolchain == nil {
Liz Kammer356f7d42021-01-26 09:18:53 -05002184 c.cachedToolchain = config.FindToolchainWithContext(ctx)
Colin Cross3f40fa42015-01-30 17:27:36 -08002185 }
Colin Crossca860ac2016-01-04 14:34:37 -08002186 return c.cachedToolchain
Colin Cross3f40fa42015-01-30 17:27:36 -08002187}
2188
Colin Crossca860ac2016-01-04 14:34:37 -08002189func (c *Module) begin(ctx BaseModuleContext) {
Joe Onorato37f900c2023-07-18 16:58:16 -07002190 for _, generator := range c.generators {
2191 generator.GeneratorInit(ctx)
2192 }
Colin Crossca860ac2016-01-04 14:34:37 -08002193 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002194 c.compiler.compilerInit(ctx)
Colin Cross21b9a242015-03-24 14:15:58 -07002195 }
Colin Crossca860ac2016-01-04 14:34:37 -08002196 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002197 c.linker.linkerInit(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08002198 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002199 if c.stl != nil {
2200 c.stl.begin(ctx)
2201 }
Colin Cross16b23492016-01-06 14:41:07 -08002202 if c.sanitize != nil {
2203 c.sanitize.begin(ctx)
2204 }
Dan Willemsen581341d2017-02-09 16:16:31 -08002205 if c.coverage != nil {
2206 c.coverage.begin(ctx)
2207 }
Yi Kong9723e332023-12-04 14:52:53 +09002208 if c.afdo != nil {
2209 c.afdo.begin(ctx)
2210 }
Stephen Craneba090d12017-05-09 15:44:35 -07002211 if c.lto != nil {
2212 c.lto.begin(ctx)
2213 }
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00002214 if c.orderfile != nil {
2215 c.orderfile.begin(ctx)
2216 }
Dan Albert92fe7402020-07-15 13:33:30 -07002217 if ctx.useSdk() && c.IsSdkVariant() {
Dan Albert1a246272020-07-06 14:49:35 -07002218 version, err := nativeApiLevelFromUser(ctx, ctx.sdkVersion())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002219 if err != nil {
2220 ctx.PropertyErrorf("sdk_version", err.Error())
Dan Albert1a246272020-07-06 14:49:35 -07002221 c.Properties.Sdk_version = nil
2222 } else {
2223 c.Properties.Sdk_version = StringPtr(version.String())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002224 }
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002225 }
Colin Crossca860ac2016-01-04 14:34:37 -08002226}
2227
Colin Cross37047f12016-12-13 17:06:13 -08002228func (c *Module) deps(ctx DepsContext) Deps {
Colin Crossc99deeb2016-04-11 15:06:20 -07002229 deps := Deps{}
2230
Joe Onorato37f900c2023-07-18 16:58:16 -07002231 for _, generator := range c.generators {
2232 deps = generator.GeneratorDeps(ctx, deps)
2233 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002234 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002235 deps = c.compiler.compilerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002236 }
2237 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002238 deps = c.linker.linkerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002239 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002240 if c.stl != nil {
2241 deps = c.stl.deps(ctx, deps)
2242 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00002243 if c.coverage != nil {
2244 deps = c.coverage.deps(ctx, deps)
2245 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002246
Colin Crossb6715442017-10-24 11:13:31 -07002247 deps.WholeStaticLibs = android.LastUniqueStrings(deps.WholeStaticLibs)
2248 deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
2249 deps.LateStaticLibs = android.LastUniqueStrings(deps.LateStaticLibs)
2250 deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
2251 deps.LateSharedLibs = android.LastUniqueStrings(deps.LateSharedLibs)
2252 deps.HeaderLibs = android.LastUniqueStrings(deps.HeaderLibs)
Logan Chien43d34c32017-12-20 01:17:32 +08002253 deps.RuntimeLibs = android.LastUniqueStrings(deps.RuntimeLibs)
Colin Crossc99deeb2016-04-11 15:06:20 -07002254
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002255 for _, lib := range deps.ReexportSharedLibHeaders {
2256 if !inList(lib, deps.SharedLibs) {
2257 ctx.PropertyErrorf("export_shared_lib_headers", "Shared library not in shared_libs: '%s'", lib)
2258 }
2259 }
2260
2261 for _, lib := range deps.ReexportStaticLibHeaders {
Steven Morelandba407c82021-04-01 22:17:50 +00002262 if !inList(lib, deps.StaticLibs) && !inList(lib, deps.WholeStaticLibs) {
2263 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 -07002264 }
2265 }
2266
Colin Cross5950f382016-12-13 12:50:57 -08002267 for _, lib := range deps.ReexportHeaderLibHeaders {
2268 if !inList(lib, deps.HeaderLibs) {
2269 ctx.PropertyErrorf("export_header_lib_headers", "Header library not in header_libs: '%s'", lib)
2270 }
2271 }
2272
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002273 for _, gen := range deps.ReexportGeneratedHeaders {
2274 if !inList(gen, deps.GeneratedHeaders) {
2275 ctx.PropertyErrorf("export_generated_headers", "Generated header module not in generated_headers: '%s'", gen)
2276 }
2277 }
2278
Colin Crossc99deeb2016-04-11 15:06:20 -07002279 return deps
2280}
2281
Dan Albert7e9d2952016-08-04 13:02:36 -07002282func (c *Module) beginMutator(actx android.BottomUpMutatorContext) {
Colin Crossca860ac2016-01-04 14:34:37 -08002283 ctx := &baseModuleContext{
Colin Cross0ea8ba82019-06-06 14:33:29 -07002284 BaseModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08002285 moduleContextImpl: moduleContextImpl{
2286 mod: c,
2287 },
2288 }
2289 ctx.ctx = ctx
2290
Vinh Tran44cb78c2023-03-09 22:07:19 -05002291 if !actx.Host() || !ctx.static() || ctx.staticBinary() {
2292 c.afdo.addDep(ctx, actx)
2293 }
2294
Colin Crossca860ac2016-01-04 14:34:37 -08002295 c.begin(ctx)
Dan Albert7e9d2952016-08-04 13:02:36 -07002296}
2297
Jiyong Park7ed9de32018-10-15 22:25:07 +09002298// Split name#version into name and version
Jiyong Park73c54ee2019-10-22 20:31:18 +09002299func StubsLibNameAndVersion(name string) (string, string) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002300 if sharp := strings.LastIndex(name, "#"); sharp != -1 && sharp != len(name)-1 {
2301 version := name[sharp+1:]
2302 libname := name[:sharp]
2303 return libname, version
2304 }
2305 return name, ""
2306}
2307
Dan Albert92fe7402020-07-15 13:33:30 -07002308func GetCrtVariations(ctx android.BottomUpMutatorContext,
2309 m LinkableInterface) []blueprint.Variation {
2310 if ctx.Os() != android.Android {
2311 return nil
2312 }
2313 if m.UseSdk() {
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09002314 // Choose the CRT that best satisfies the min_sdk_version requirement of this module
2315 minSdkVersion := m.MinSdkVersion()
2316 if minSdkVersion == "" || minSdkVersion == "apex_inherit" {
2317 minSdkVersion = m.SdkVersion()
2318 }
Jooyung Han94a76ee2021-06-08 09:49:48 +09002319 apiLevel, err := android.ApiLevelFromUser(ctx, minSdkVersion)
2320 if err != nil {
2321 ctx.PropertyErrorf("min_sdk_version", err.Error())
2322 }
Colin Cross363ec762023-01-13 13:45:14 -08002323
2324 // Raise the minSdkVersion to the minimum supported for the architecture.
Colin Crossbb137a32023-01-26 09:54:42 -08002325 minApiForArch := MinApiForArch(ctx, m.Target().Arch.ArchType)
Colin Cross363ec762023-01-13 13:45:14 -08002326 if apiLevel.LessThan(minApiForArch) {
2327 apiLevel = minApiForArch
2328 }
2329
Dan Albert92fe7402020-07-15 13:33:30 -07002330 return []blueprint.Variation{
2331 {Mutator: "sdk", Variation: "sdk"},
Jooyung Han94a76ee2021-06-08 09:49:48 +09002332 {Mutator: "version", Variation: apiLevel.String()},
Dan Albert92fe7402020-07-15 13:33:30 -07002333 }
2334 }
2335 return []blueprint.Variation{
2336 {Mutator: "sdk", Variation: ""},
2337 }
2338}
2339
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002340func AddSharedLibDependenciesWithVersions(ctx android.BottomUpMutatorContext, mod LinkableInterface,
2341 variations []blueprint.Variation, depTag blueprint.DependencyTag, name, version string, far bool) {
Colin Crosse7257d22020-09-24 09:56:18 -07002342
2343 variations = append([]blueprint.Variation(nil), variations...)
2344
Liz Kammer23942242022-04-08 15:41:00 -04002345 if version != "" && canBeOrLinkAgainstVersionVariants(mod) {
Colin Crosse7257d22020-09-24 09:56:18 -07002346 // Version is explicitly specified. i.e. libFoo#30
2347 variations = append(variations, blueprint.Variation{Mutator: "version", Variation: version})
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002348 if tag, ok := depTag.(libraryDependencyTag); ok {
2349 tag.explicitlyVersioned = true
2350 } else {
2351 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
2352 }
Colin Crosse7257d22020-09-24 09:56:18 -07002353 }
Colin Crosse7257d22020-09-24 09:56:18 -07002354
Colin Cross0de8a1e2020-09-18 14:15:30 -07002355 if far {
2356 ctx.AddFarVariationDependencies(variations, depTag, name)
2357 } else {
2358 ctx.AddVariationDependencies(variations, depTag, name)
Colin Crosse7257d22020-09-24 09:56:18 -07002359 }
2360}
2361
Kiyoung Kim487689e2022-07-26 09:48:22 +09002362func GetApiImports(c LinkableInterface, actx android.BottomUpMutatorContext) multitree.ApiImportInfo {
2363 apiImportInfo := multitree.ApiImportInfo{}
2364
2365 if c.Device() {
2366 var apiImportModule []blueprint.Module
2367 if actx.OtherModuleExists("api_imports") {
2368 apiImportModule = actx.AddDependency(c, nil, "api_imports")
2369 if len(apiImportModule) > 0 && apiImportModule[0] != nil {
2370 apiInfo := actx.OtherModuleProvider(apiImportModule[0], multitree.ApiImportsProvider).(multitree.ApiImportInfo)
2371 apiImportInfo = apiInfo
2372 actx.SetProvider(multitree.ApiImportsProvider, apiInfo)
2373 }
2374 }
2375 }
2376
2377 return apiImportInfo
2378}
2379
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002380func GetSnapshot(c LinkableInterface, snapshotInfo **SnapshotInfo, actx android.BottomUpMutatorContext) SnapshotInfo {
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002381 // Only device modules with BOARD_VNDK_VERSION uses snapshot. Others use the zero value of
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002382 // SnapshotInfo, which provides no mappings.
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002383 if *snapshotInfo == nil && c.Device() {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002384 // Only retrieve the snapshot on demand in order to avoid circular dependencies
2385 // between the modules in the snapshot and the snapshot itself.
2386 var snapshotModule []blueprint.Module
2387 if c.InVendor() && c.VndkVersion() == actx.DeviceConfig().VndkVersion() {
2388 snapshotModule = actx.AddVariationDependencies(nil, nil, "vendor_snapshot")
2389 } else if recoverySnapshotVersion := actx.DeviceConfig().RecoverySnapshotVersion(); recoverySnapshotVersion != "current" && recoverySnapshotVersion != "" && c.InRecovery() {
2390 snapshotModule = actx.AddVariationDependencies(nil, nil, "recovery_snapshot")
2391 }
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002392 if len(snapshotModule) > 0 && snapshotModule[0] != nil {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002393 snapshot := actx.OtherModuleProvider(snapshotModule[0], SnapshotInfoProvider).(SnapshotInfo)
2394 *snapshotInfo = &snapshot
2395 // republish the snapshot for use in later mutators on this module
2396 actx.SetProvider(SnapshotInfoProvider, snapshot)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002397 }
2398 }
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002399 if *snapshotInfo == nil {
2400 *snapshotInfo = &SnapshotInfo{}
2401 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002402 return **snapshotInfo
2403}
2404
Kiyoung Kim487689e2022-07-26 09:48:22 +09002405func GetReplaceModuleName(lib string, replaceMap map[string]string) string {
2406 if snapshot, ok := replaceMap[lib]; ok {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002407 return snapshot
2408 }
2409
2410 return lib
2411}
2412
2413// RewriteLibs takes a list of names of shared libraries and scans it for three types
2414// of names:
2415//
2416// 1. Name of an NDK library that refers to a prebuilt module.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002417//
2418// For each of these, it adds the name of the prebuilt module (which will be in
2419// prebuilts/ndk) to the list of nonvariant libs.
2420//
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002421// 2. Name of an NDK library that refers to an ndk_library module.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002422//
2423// For each of these, it adds the name of the ndk_library module to the list of
2424// variant libs.
2425//
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002426// 3. Anything else (so anything that isn't an NDK library).
Kiyoung Kim487689e2022-07-26 09:48:22 +09002427//
2428// It adds these to the nonvariantLibs list.
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002429//
2430// The caller can then know to add the variantLibs dependencies differently from the
2431// nonvariantLibs
2432func RewriteLibs(c LinkableInterface, snapshotInfo **SnapshotInfo, actx android.BottomUpMutatorContext, config android.Config, list []string) (nonvariantLibs []string, variantLibs []string) {
2433 variantLibs = []string{}
2434
2435 nonvariantLibs = []string{}
2436 for _, entry := range list {
2437 // strip #version suffix out
2438 name, _ := StubsLibNameAndVersion(entry)
2439 if c.InRecovery() {
Kiyoung Kim487689e2022-07-26 09:48:22 +09002440 nonvariantLibs = append(nonvariantLibs, GetReplaceModuleName(entry, GetSnapshot(c, snapshotInfo, actx).SharedLibs))
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002441 } else if c.UseSdk() && inList(name, *getNDKKnownLibs(config)) {
2442 variantLibs = append(variantLibs, name+ndkLibrarySuffix)
2443 } else if c.UseVndk() {
Kiyoung Kim487689e2022-07-26 09:48:22 +09002444 nonvariantLibs = append(nonvariantLibs, GetReplaceModuleName(entry, GetSnapshot(c, snapshotInfo, actx).SharedLibs))
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002445 } else {
2446 // put name#version back
2447 nonvariantLibs = append(nonvariantLibs, entry)
2448 }
2449 }
2450 return nonvariantLibs, variantLibs
2451}
2452
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002453func rewriteLibsForApiImports(c LinkableInterface, libs []string, replaceList map[string]string, config android.Config) ([]string, []string) {
2454 nonVariantLibs := []string{}
2455 variantLibs := []string{}
2456
2457 for _, lib := range libs {
2458 replaceLibName := GetReplaceModuleName(lib, replaceList)
2459 if replaceLibName == lib {
2460 // Do not handle any libs which are not in API imports
2461 nonVariantLibs = append(nonVariantLibs, replaceLibName)
2462 } else if c.UseSdk() && inList(replaceLibName, *getNDKKnownLibs(config)) {
2463 variantLibs = append(variantLibs, replaceLibName)
2464 } else {
2465 nonVariantLibs = append(nonVariantLibs, replaceLibName)
2466 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002467 }
2468
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002469 return nonVariantLibs, variantLibs
Kiyoung Kim487689e2022-07-26 09:48:22 +09002470}
2471
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002472func (c *Module) shouldUseApiSurface() bool {
2473 if c.Os() == android.Android && c.Target().NativeBridge != android.NativeBridgeEnabled {
2474 if GetImageVariantType(c) == vendorImageVariant || GetImageVariantType(c) == productImageVariant {
2475 // LLNDK Variant
2476 return true
2477 }
2478
2479 if c.Properties.IsSdkVariant {
2480 // NDK Variant
2481 return true
2482 }
2483
2484 if c.isImportedApiLibrary() {
2485 // API Library should depend on API headers
2486 return true
2487 }
2488 }
2489
2490 return false
2491}
2492
Colin Cross1e676be2016-10-12 14:38:15 -07002493func (c *Module) DepsMutator(actx android.BottomUpMutatorContext) {
Inseob Kimeec88e12020-01-22 11:11:29 +09002494 if !c.Enabled() {
2495 return
2496 }
2497
Colin Cross37047f12016-12-13 17:06:13 -08002498 ctx := &depsContext{
2499 BottomUpMutatorContext: actx,
Dan Albert7e9d2952016-08-04 13:02:36 -07002500 moduleContextImpl: moduleContextImpl{
2501 mod: c,
2502 },
2503 }
2504 ctx.ctx = ctx
Colin Crossca860ac2016-01-04 14:34:37 -08002505
Colin Crossc99deeb2016-04-11 15:06:20 -07002506 deps := c.deps(ctx)
Kiyoung Kim487689e2022-07-26 09:48:22 +09002507 apiImportInfo := GetApiImports(c, actx)
Kiyoung Kim11d91082022-10-19 19:20:57 +09002508
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002509 apiNdkLibs := []string{}
2510 apiLateNdkLibs := []string{}
2511
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002512 if c.shouldUseApiSurface() {
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002513 deps.SharedLibs, apiNdkLibs = rewriteLibsForApiImports(c, deps.SharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2514 deps.LateSharedLibs, apiLateNdkLibs = rewriteLibsForApiImports(c, deps.LateSharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2515 deps.SystemSharedLibs, _ = rewriteLibsForApiImports(c, deps.SystemSharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2516 deps.ReexportHeaderLibHeaders, _ = rewriteLibsForApiImports(c, deps.ReexportHeaderLibHeaders, apiImportInfo.SharedLibs, ctx.Config())
2517 deps.ReexportSharedLibHeaders, _ = rewriteLibsForApiImports(c, deps.ReexportSharedLibHeaders, apiImportInfo.SharedLibs, ctx.Config())
Kiyoung Kim11d91082022-10-19 19:20:57 +09002518 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002519
Yo Chiang219968c2020-09-22 18:45:04 +08002520 c.Properties.AndroidMkSystemSharedLibs = deps.SystemSharedLibs
2521
Colin Crosse0edaf92021-01-11 17:31:17 -08002522 var snapshotInfo *SnapshotInfo
Colin Crosse0edaf92021-01-11 17:31:17 -08002523
Dan Albert914449f2016-06-17 16:45:24 -07002524 variantNdkLibs := []string{}
2525 variantLateNdkLibs := []string{}
Dan Willemsenb916b802017-03-19 13:44:32 -07002526 if ctx.Os() == android.Android {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002527 deps.SharedLibs, variantNdkLibs = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.SharedLibs)
2528 deps.LateSharedLibs, variantLateNdkLibs = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.LateSharedLibs)
2529 deps.ReexportSharedLibHeaders, _ = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.ReexportSharedLibHeaders)
Colin Crosse0edaf92021-01-11 17:31:17 -08002530
2531 for idx, lib := range deps.RuntimeLibs {
Kiyoung Kim487689e2022-07-26 09:48:22 +09002532 deps.RuntimeLibs[idx] = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).SharedLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002533 }
Dan Willemsen72d39932016-07-08 23:23:48 -07002534 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002535
Colin Cross32ec36c2016-12-15 07:39:51 -08002536 for _, lib := range deps.HeaderLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002537 depTag := libraryDependencyTag{Kind: headerLibraryDependency}
Colin Cross32ec36c2016-12-15 07:39:51 -08002538 if inList(lib, deps.ReexportHeaderLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002539 depTag.reexportFlags = true
Colin Cross32ec36c2016-12-15 07:39:51 -08002540 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002541
Kiyoung Kim51279d32022-08-24 14:10:46 +09002542 // Check header lib replacement from API surface first, and then check again with VSDK
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002543 if c.shouldUseApiSurface() {
Kiyoung Kim11d91082022-10-19 19:20:57 +09002544 lib = GetReplaceModuleName(lib, apiImportInfo.HeaderLibs)
2545 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002546 lib = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).HeaderLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002547
Spandan Das73bcafc2022-08-18 23:26:00 +00002548 if c.isNDKStubLibrary() {
2549 // ndk_headers do not have any variations
2550 actx.AddFarVariationDependencies([]blueprint.Variation{}, depTag, lib)
Kiyoung Kim51279d32022-08-24 14:10:46 +09002551 } else if c.IsStubs() && !c.isImportedApiLibrary() {
Colin Cross7228ecd2019-11-18 16:00:16 -08002552 actx.AddFarVariationDependencies(append(ctx.Target().Variations(), c.ImageVariation()),
Colin Cross0f7d2ef2019-10-16 11:03:10 -07002553 depTag, lib)
Jiyong Park7e636d02019-01-28 16:16:54 +09002554 } else {
2555 actx.AddVariationDependencies(nil, depTag, lib)
2556 }
2557 }
2558
Dan Albertf1d14c72020-07-30 14:32:55 -07002559 if c.isNDKStubLibrary() {
2560 // NDK stubs depend on their implementation because the ABI dumps are
2561 // generated from the implementation library.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002562
Spandan Das8b08aea2023-03-14 19:29:34 +00002563 actx.AddFarVariationDependencies(append(ctx.Target().Variations(),
2564 c.ImageVariation(),
2565 blueprint.Variation{Mutator: "link", Variation: "shared"},
2566 ), stubImplementation, c.BaseModuleName())
Dan Albertf1d14c72020-07-30 14:32:55 -07002567 }
2568
Jiyong Park5d1598f2019-02-25 22:14:17 +09002569 for _, lib := range deps.WholeStaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002570 depTag := libraryDependencyTag{Kind: staticLibraryDependency, wholeStatic: true, reexportFlags: true}
Inseob Kimeec88e12020-01-22 11:11:29 +09002571
Kiyoung Kim487689e2022-07-26 09:48:22 +09002572 lib = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002573
Jiyong Park5d1598f2019-02-25 22:14:17 +09002574 actx.AddVariationDependencies([]blueprint.Variation{
2575 {Mutator: "link", Variation: "static"},
2576 }, depTag, lib)
2577 }
2578
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002579 for _, lib := range deps.StaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002580 depTag := libraryDependencyTag{Kind: staticLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002581 if inList(lib, deps.ReexportStaticLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002582 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002583 }
Jiyong Parke3867542020-12-03 17:28:25 +09002584 if inList(lib, deps.ExcludeLibsForApex) {
2585 depTag.excludeInApex = true
2586 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002587
Kiyoung Kim487689e2022-07-26 09:48:22 +09002588 lib = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002589
Dan Willemsen59339a22018-07-22 21:18:45 -07002590 actx.AddVariationDependencies([]blueprint.Variation{
2591 {Mutator: "link", Variation: "static"},
2592 }, depTag, lib)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002593 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002594
Jooyung Han75568392020-03-20 04:29:24 +09002595 // staticUnwinderDep is treated as staticDep for Q apexes
2596 // so that native libraries/binaries are linked with static unwinder
2597 // because Q libc doesn't have unwinder APIs
2598 if deps.StaticUnwinderIfLegacy {
Colin Cross6e511a92020-07-27 21:26:48 -07002599 depTag := libraryDependencyTag{Kind: staticLibraryDependency, staticUnwinder: true}
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002600 actx.AddVariationDependencies([]blueprint.Variation{
2601 {Mutator: "link", Variation: "static"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002602 }, depTag, GetReplaceModuleName(staticUnwinder(actx), GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002603 }
2604
Jiyong Park7ed9de32018-10-15 22:25:07 +09002605 // shared lib names without the #version suffix
2606 var sharedLibNames []string
2607
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002608 for _, lib := range deps.SharedLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002609 depTag := libraryDependencyTag{Kind: sharedLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002610 if inList(lib, deps.ReexportSharedLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002611 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002612 }
Jiyong Parke3867542020-12-03 17:28:25 +09002613 if inList(lib, deps.ExcludeLibsForApex) {
2614 depTag.excludeInApex = true
2615 }
Jooyung Han9ffbe832023-11-28 22:31:35 +09002616 if inList(lib, deps.ExcludeLibsForNonApex) {
2617 depTag.excludeInNonApex = true
2618 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002619
Jiyong Park73c54ee2019-10-22 20:31:18 +09002620 name, version := StubsLibNameAndVersion(lib)
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002621 if apiLibraryName, ok := apiImportInfo.SharedLibs[name]; ok && !ctx.OtherModuleExists(name) {
2622 name = apiLibraryName
2623 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002624 sharedLibNames = append(sharedLibNames, name)
2625
Colin Crosse7257d22020-09-24 09:56:18 -07002626 variations := []blueprint.Variation{
2627 {Mutator: "link", Variation: "shared"},
2628 }
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002629
2630 if _, ok := apiImportInfo.ApexSharedLibs[name]; !ok || ctx.OtherModuleExists(name) {
2631 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, name, version, false)
2632 }
2633
2634 if apiLibraryName, ok := apiImportInfo.ApexSharedLibs[name]; ok {
2635 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, apiLibraryName, version, false)
2636 }
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002637 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002638
Colin Crossfe9acfe2021-06-14 16:13:03 -07002639 for _, lib := range deps.LateStaticLibs {
2640 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency}
2641 actx.AddVariationDependencies([]blueprint.Variation{
2642 {Mutator: "link", Variation: "static"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002643 }, depTag, GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
Colin Crossfe9acfe2021-06-14 16:13:03 -07002644 }
2645
Colin Cross3e5e7782022-06-17 22:17:05 +00002646 for _, lib := range deps.UnexportedStaticLibs {
2647 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency, unexportedSymbols: true}
2648 actx.AddVariationDependencies([]blueprint.Variation{
2649 {Mutator: "link", Variation: "static"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002650 }, depTag, GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
Colin Cross3e5e7782022-06-17 22:17:05 +00002651 }
2652
Jiyong Park7ed9de32018-10-15 22:25:07 +09002653 for _, lib := range deps.LateSharedLibs {
Jiyong Park25fc6a92018-11-18 18:02:45 +09002654 if inList(lib, sharedLibNames) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002655 // This is to handle the case that some of the late shared libs (libc, libdl, libm, ...)
2656 // are added also to SharedLibs with version (e.g., libc#10). If not skipped, we will be
2657 // linking against both the stubs lib and the non-stubs lib at the same time.
2658 continue
2659 }
Colin Cross6e511a92020-07-27 21:26:48 -07002660 depTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency}
Colin Crosse7257d22020-09-24 09:56:18 -07002661 variations := []blueprint.Variation{
2662 {Mutator: "link", Variation: "shared"},
2663 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002664 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, lib, "", false)
Jiyong Park7ed9de32018-10-15 22:25:07 +09002665 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002666
Dan Willemsen59339a22018-07-22 21:18:45 -07002667 actx.AddVariationDependencies([]blueprint.Variation{
2668 {Mutator: "link", Variation: "shared"},
Chris Parsons79d66a52020-06-05 17:26:16 -04002669 }, dataLibDepTag, deps.DataLibs...)
2670
Colin Crossc8caa062021-09-24 16:50:14 -07002671 actx.AddVariationDependencies(nil, dataBinDepTag, deps.DataBins...)
2672
Chris Parsons79d66a52020-06-05 17:26:16 -04002673 actx.AddVariationDependencies([]blueprint.Variation{
2674 {Mutator: "link", Variation: "shared"},
Dan Willemsen59339a22018-07-22 21:18:45 -07002675 }, runtimeDepTag, deps.RuntimeLibs...)
Logan Chien43d34c32017-12-20 01:17:32 +08002676
Colin Cross68861832016-07-08 10:41:41 -07002677 actx.AddDependency(c, genSourceDepTag, deps.GeneratedSources...)
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002678
2679 for _, gen := range deps.GeneratedHeaders {
2680 depTag := genHeaderDepTag
2681 if inList(gen, deps.ReexportGeneratedHeaders) {
2682 depTag = genHeaderExportDepTag
2683 }
2684 actx.AddDependency(c, depTag, gen)
2685 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002686
Dan Albert92fe7402020-07-15 13:33:30 -07002687 crtVariations := GetCrtVariations(ctx, c)
Colin Crossbbc941b2020-09-30 12:27:01 -07002688 actx.AddVariationDependencies(crtVariations, objDepTag, deps.ObjFiles...)
Colin Crossc465efd2021-06-11 18:00:04 -07002689 for _, crt := range deps.CrtBegin {
Dan Albert92fe7402020-07-15 13:33:30 -07002690 actx.AddVariationDependencies(crtVariations, CrtBeginDepTag,
Kiyoung Kim487689e2022-07-26 09:48:22 +09002691 GetReplaceModuleName(crt, GetSnapshot(c, &snapshotInfo, actx).Objects))
Colin Crossca860ac2016-01-04 14:34:37 -08002692 }
Colin Crossc465efd2021-06-11 18:00:04 -07002693 for _, crt := range deps.CrtEnd {
Dan Albert92fe7402020-07-15 13:33:30 -07002694 actx.AddVariationDependencies(crtVariations, CrtEndDepTag,
Kiyoung Kim487689e2022-07-26 09:48:22 +09002695 GetReplaceModuleName(crt, GetSnapshot(c, &snapshotInfo, actx).Objects))
Colin Cross21b9a242015-03-24 14:15:58 -07002696 }
Dan Willemsena0790e32018-10-12 00:24:23 -07002697 if deps.DynamicLinker != "" {
2698 actx.AddDependency(c, dynamicLinkerDepTag, deps.DynamicLinker)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002699 }
Dan Albert914449f2016-06-17 16:45:24 -07002700
2701 version := ctx.sdkVersion()
Colin Cross6e511a92020-07-27 21:26:48 -07002702
2703 ndkStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002704 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002705 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002706 {Mutator: "link", Variation: "shared"},
2707 }, ndkStubDepTag, variantNdkLibs...)
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002708 actx.AddVariationDependencies([]blueprint.Variation{
2709 {Mutator: "version", Variation: version},
2710 {Mutator: "link", Variation: "shared"},
2711 }, ndkStubDepTag, apiNdkLibs...)
Colin Cross6e511a92020-07-27 21:26:48 -07002712
2713 ndkLateStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002714 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002715 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002716 {Mutator: "link", Variation: "shared"},
2717 }, ndkLateStubDepTag, variantLateNdkLibs...)
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002718 actx.AddVariationDependencies([]blueprint.Variation{
2719 {Mutator: "version", Variation: version},
2720 {Mutator: "link", Variation: "shared"},
2721 }, ndkLateStubDepTag, apiLateNdkLibs...)
Logan Chienf3511742017-10-31 18:04:35 +08002722
2723 if vndkdep := c.vndkdep; vndkdep != nil {
2724 if vndkdep.isVndkExt() {
Logan Chienf3511742017-10-31 18:04:35 +08002725 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross7228ecd2019-11-18 16:00:16 -08002726 c.ImageVariation(),
Dan Willemsen59339a22018-07-22 21:18:45 -07002727 {Mutator: "link", Variation: "shared"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002728 }, vndkExtDepTag, GetReplaceModuleName(vndkdep.getVndkExtendsModuleName(), GetSnapshot(c, &snapshotInfo, actx).SharedLibs))
Logan Chienf3511742017-10-31 18:04:35 +08002729 }
2730 }
Kiyoung Kimee58c932022-10-25 22:59:41 +09002731
Vinh Tran367d89d2023-04-28 11:21:25 -04002732 if len(deps.AidlLibs) > 0 {
2733 actx.AddDependency(
2734 c,
2735 aidlLibraryTag,
2736 deps.AidlLibs...,
2737 )
2738 }
2739
Kiyoung Kimee58c932022-10-25 22:59:41 +09002740 updateImportedLibraryDependency(ctx)
Colin Cross6362e272015-10-29 15:25:03 -07002741}
Colin Cross21b9a242015-03-24 14:15:58 -07002742
Colin Crosse40b4ea2018-10-02 22:25:58 -07002743func BeginMutator(ctx android.BottomUpMutatorContext) {
Dan Albert7e9d2952016-08-04 13:02:36 -07002744 if c, ok := ctx.Module().(*Module); ok && c.Enabled() {
2745 c.beginMutator(ctx)
2746 }
2747}
2748
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002749// Whether a module can link to another module, taking into
2750// account NDK linking.
Jooyung Han479ca172020-10-19 18:51:07 +09002751func checkLinkType(ctx android.BaseModuleContext, from LinkableInterface, to LinkableInterface,
Colin Cross6e511a92020-07-27 21:26:48 -07002752 tag blueprint.DependencyTag) {
2753
2754 switch t := tag.(type) {
2755 case dependencyTag:
2756 if t != vndkExtDepTag {
2757 return
2758 }
2759 case libraryDependencyTag:
2760 default:
2761 return
2762 }
2763
Ivan Lozanof9e21722020-12-02 09:00:51 -05002764 if from.Target().Os != android.Android {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002765 // Host code is not restricted
2766 return
2767 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002768
2769 // VNDK is cc.Module supported only for now.
2770 if ccFrom, ok := from.(*Module); ok && from.UseVndk() {
Justin Yun63e9ec72020-10-29 16:49:43 +09002771 // Though allowed dependency is limited by the image mutator,
2772 // each vendor and product module needs to check link-type
2773 // for VNDK.
Ivan Lozano52767be2019-10-18 14:49:46 -07002774 if ccTo, ok := to.(*Module); ok {
2775 if ccFrom.vndkdep != nil {
2776 ccFrom.vndkdep.vndkCheckLinkType(ctx, ccTo, tag)
2777 }
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002778 } else if _, ok := to.(LinkableInterface); !ok {
Ivan Lozano52767be2019-10-18 14:49:46 -07002779 ctx.ModuleErrorf("Attempting to link VNDK cc.Module with unsupported module type")
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002780 }
2781 return
2782 }
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002783 // TODO(b/244244438) : Remove this once all variants are implemented
2784 if ccFrom, ok := from.(*Module); ok && ccFrom.isImportedApiLibrary() {
2785 return
2786 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002787 if from.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002788 // Platform code can link to anything
2789 return
2790 }
Yifan Hong1b3348d2020-01-21 15:53:22 -08002791 if from.InRamdisk() {
2792 // Ramdisk code is not NDK
2793 return
2794 }
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002795 if from.InVendorRamdisk() {
2796 // Vendor ramdisk code is not NDK
2797 return
2798 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002799 if from.InRecovery() {
Jiyong Parkf9332f12018-02-01 00:54:12 +09002800 // Recovery code is not NDK
2801 return
2802 }
Colin Cross31076b32020-10-23 17:22:06 -07002803 if c, ok := to.(*Module); ok {
Colin Cross31076b32020-10-23 17:22:06 -07002804 if c.NdkPrebuiltStl() {
2805 // These are allowed, but they don't set sdk_version
2806 return
2807 }
2808 if c.StubDecorator() {
2809 // These aren't real libraries, but are the stub shared libraries that are included in
2810 // the NDK.
2811 return
2812 }
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002813 if c.isImportedApiLibrary() {
2814 // Imported library from the API surface is a stub library built against interface definition.
2815 return
2816 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002817 }
Logan Chien834b9a62019-01-14 15:39:03 +08002818
Ivan Lozano52767be2019-10-18 14:49:46 -07002819 if strings.HasPrefix(ctx.ModuleName(), "libclang_rt.") && to.Module().Name() == "libc++" {
Logan Chien834b9a62019-01-14 15:39:03 +08002820 // Bug: http://b/121358700 - Allow libclang_rt.* shared libraries (with sdk_version)
2821 // to link to libc++ (non-NDK and without sdk_version).
2822 return
2823 }
2824
Ivan Lozano52767be2019-10-18 14:49:46 -07002825 if to.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002826 // NDK code linking to platform code is never okay.
2827 ctx.ModuleErrorf("depends on non-NDK-built library %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002828 ctx.OtherModuleName(to.Module()))
Dan Willemsen155d17c2019-02-06 18:30:02 -08002829 return
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002830 }
2831
2832 // At this point we know we have two NDK libraries, but we need to
2833 // check that we're not linking against anything built against a higher
2834 // API level, as it is only valid to link against older or equivalent
2835 // APIs.
2836
Inseob Kim01a28722018-04-11 09:48:45 +09002837 // Current can link against anything.
Ivan Lozano52767be2019-10-18 14:49:46 -07002838 if from.SdkVersion() != "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002839 // Otherwise we need to check.
Ivan Lozano52767be2019-10-18 14:49:46 -07002840 if to.SdkVersion() == "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002841 // Current can't be linked against by anything else.
2842 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002843 ctx.OtherModuleName(to.Module()), "current")
Inseob Kim01a28722018-04-11 09:48:45 +09002844 } else {
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002845 fromApi, err := android.ApiLevelFromUserWithConfig(ctx.Config(), from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002846 if err != nil {
2847 ctx.PropertyErrorf("sdk_version",
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002848 "Invalid sdk_version value (must be int, preview or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002849 from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002850 }
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002851 toApi, err := android.ApiLevelFromUserWithConfig(ctx.Config(), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002852 if err != nil {
2853 ctx.PropertyErrorf("sdk_version",
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002854 "Invalid sdk_version value (must be int, preview or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002855 to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002856 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002857
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002858 if toApi.GreaterThan(fromApi) {
Inseob Kim01a28722018-04-11 09:48:45 +09002859 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002860 ctx.OtherModuleName(to.Module()), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002861 }
2862 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002863 }
Dan Albert202fe492017-12-15 13:56:59 -08002864
2865 // Also check that the two STL choices are compatible.
Ivan Lozano52767be2019-10-18 14:49:46 -07002866 fromStl := from.SelectedStl()
2867 toStl := to.SelectedStl()
Dan Albert202fe492017-12-15 13:56:59 -08002868 if fromStl == "" || toStl == "" {
2869 // Libraries that don't use the STL are unrestricted.
Inseob Kimda2171a2018-04-11 15:41:38 +09002870 } else if fromStl == "ndk_system" || toStl == "ndk_system" {
Dan Albert202fe492017-12-15 13:56:59 -08002871 // We can be permissive with the system "STL" since it is only the C++
2872 // ABI layer, but in the future we should make sure that everyone is
2873 // using either libc++ or nothing.
Colin Crossb60190a2018-09-04 16:28:17 -07002874 } else if getNdkStlFamily(from) != getNdkStlFamily(to) {
Dan Albert202fe492017-12-15 13:56:59 -08002875 ctx.ModuleErrorf("uses %q and depends on %q which uses incompatible %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002876 from.SelectedStl(), ctx.OtherModuleName(to.Module()),
2877 to.SelectedStl())
Dan Albert202fe492017-12-15 13:56:59 -08002878 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002879}
2880
Jooyung Han479ca172020-10-19 18:51:07 +09002881func checkLinkTypeMutator(ctx android.BottomUpMutatorContext) {
2882 if c, ok := ctx.Module().(*Module); ok {
2883 ctx.VisitDirectDeps(func(dep android.Module) {
2884 depTag := ctx.OtherModuleDependencyTag(dep)
2885 ccDep, ok := dep.(LinkableInterface)
2886 if ok {
2887 checkLinkType(ctx, c, ccDep, depTag)
2888 }
2889 })
2890 }
2891}
2892
Jiyong Park5fb8c102018-04-09 12:03:06 +09002893// Tests whether the dependent library is okay to be double loaded inside a single process.
Jooyung Hana70f0672019-01-18 15:20:43 +09002894// If a library has a vendor variant and is a (transitive) dependency of an LLNDK library,
2895// it is subject to be double loaded. Such lib should be explicitly marked as double_loadable: true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002896// or as vndk-sp (vndk: { enabled: true, support_system_process: true}).
Jooyung Hana70f0672019-01-18 15:20:43 +09002897func checkDoubleLoadableLibraries(ctx android.TopDownMutatorContext) {
2898 check := func(child, parent android.Module) bool {
2899 to, ok := child.(*Module)
2900 if !ok {
Jooyung Han479ca172020-10-19 18:51:07 +09002901 return false
Jooyung Hana70f0672019-01-18 15:20:43 +09002902 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002903
Jooyung Hana70f0672019-01-18 15:20:43 +09002904 if lib, ok := to.linker.(*libraryDecorator); !ok || !lib.shared() {
2905 return false
Jiyong Park5fb8c102018-04-09 12:03:06 +09002906 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002907
Jiyong Park0474e1f2021-01-14 14:26:06 +09002908 // These dependencies are not excercised at runtime. Tracking these will give us
2909 // false negative, so skip.
Jiyong Park1ad8e162020-12-01 23:40:09 +09002910 depTag := ctx.OtherModuleDependencyTag(child)
2911 if IsHeaderDepTag(depTag) {
2912 return false
2913 }
Jiyong Park0474e1f2021-01-14 14:26:06 +09002914 if depTag == staticVariantTag {
2915 return false
2916 }
2917 if depTag == stubImplDepTag {
2918 return false
2919 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002920
Justin Yun63e9ec72020-10-29 16:49:43 +09002921 // Even if target lib has no vendor variant, keep checking dependency
2922 // graph in case it depends on vendor_available or product_available
2923 // but not double_loadable transtively.
2924 if !to.HasNonSystemVariants() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002925 return true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002926 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002927
Jiyong Park0474e1f2021-01-14 14:26:06 +09002928 // The happy path. Keep tracking dependencies until we hit a non double-loadable
2929 // one.
2930 if Bool(to.VendorProperties.Double_loadable) {
2931 return true
2932 }
2933
Ivan Lozanod7586b62021-04-01 09:49:36 -04002934 if to.IsVndkSp() || to.IsLlndk() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002935 return false
2936 }
2937
Jooyung Hana70f0672019-01-18 15:20:43 +09002938 ctx.ModuleErrorf("links a library %q which is not LL-NDK, "+
2939 "VNDK-SP, or explicitly marked as 'double_loadable:true'. "+
Jiyong Park0474e1f2021-01-14 14:26:06 +09002940 "Dependency list: %s", ctx.OtherModuleName(to), ctx.GetPathString(false))
Jooyung Hana70f0672019-01-18 15:20:43 +09002941 return false
2942 }
2943 if module, ok := ctx.Module().(*Module); ok {
2944 if lib, ok := module.linker.(*libraryDecorator); ok && lib.shared() {
Jiyong Park0474e1f2021-01-14 14:26:06 +09002945 if lib.hasLLNDKStubs() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002946 ctx.WalkDeps(check)
2947 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002948 }
2949 }
2950}
2951
Yu Liue4312402023-01-18 09:15:31 -08002952func findApexSdkVersion(ctx android.BaseModuleContext, apexInfo android.ApexInfo) android.ApiLevel {
2953 // For the dependency from platform to apex, use the latest stubs
2954 apexSdkVersion := android.FutureApiLevel
2955 if !apexInfo.IsForPlatform() {
2956 apexSdkVersion = apexInfo.MinSdkVersion
2957 }
2958
2959 if android.InList("hwaddress", ctx.Config().SanitizeDevice()) {
2960 // In hwasan build, we override apexSdkVersion to the FutureApiLevel(10000)
2961 // so that even Q(29/Android10) apexes could use the dynamic unwinder by linking the newer stubs(e.g libc(R+)).
2962 // (b/144430859)
2963 apexSdkVersion = android.FutureApiLevel
2964 }
2965
2966 return apexSdkVersion
2967}
2968
Colin Crossc99deeb2016-04-11 15:06:20 -07002969// Convert dependencies to paths. Returns a PathDeps containing paths
Colin Cross635c3b02016-05-18 15:37:25 -07002970func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
Colin Crossca860ac2016-01-04 14:34:37 -08002971 var depPaths PathDeps
Colin Crossca860ac2016-01-04 14:34:37 -08002972
Colin Cross0de8a1e2020-09-18 14:15:30 -07002973 var directStaticDeps []StaticLibraryInfo
2974 var directSharedDeps []SharedLibraryInfo
Jeff Gaston294356f2017-09-27 17:05:30 -07002975
Colin Cross0de8a1e2020-09-18 14:15:30 -07002976 reexportExporter := func(exporter FlagExporterInfo) {
2977 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, exporter.IncludeDirs...)
2978 depPaths.ReexportedSystemDirs = append(depPaths.ReexportedSystemDirs, exporter.SystemIncludeDirs...)
2979 depPaths.ReexportedFlags = append(depPaths.ReexportedFlags, exporter.Flags...)
2980 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, exporter.Deps...)
2981 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders, exporter.GeneratedHeaders...)
Inseob Kim69378442019-06-03 19:10:47 +09002982 }
2983
Colin Cross56a83212020-09-15 18:30:11 -07002984 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
Yu Liue4312402023-01-18 09:15:31 -08002985 c.apexSdkVersion = findApexSdkVersion(ctx, apexInfo)
Jooyung Hande34d232020-07-23 13:04:15 +09002986
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002987 skipModuleList := map[string]bool{}
2988
2989 var apiImportInfo multitree.ApiImportInfo
2990 hasApiImportInfo := false
2991
2992 ctx.VisitDirectDeps(func(dep android.Module) {
2993 if dep.Name() == "api_imports" {
2994 apiImportInfo = ctx.OtherModuleProvider(dep, multitree.ApiImportsProvider).(multitree.ApiImportInfo)
2995 hasApiImportInfo = true
2996 }
2997 })
2998
2999 if hasApiImportInfo {
3000 targetStubModuleList := map[string]string{}
3001 targetOrigModuleList := map[string]string{}
3002
3003 // Search for dependency which both original module and API imported library with APEX stub exists
3004 ctx.VisitDirectDeps(func(dep android.Module) {
3005 depName := ctx.OtherModuleName(dep)
3006 if apiLibrary, ok := apiImportInfo.ApexSharedLibs[depName]; ok {
3007 targetStubModuleList[apiLibrary] = depName
3008 }
3009 })
3010 ctx.VisitDirectDeps(func(dep android.Module) {
3011 depName := ctx.OtherModuleName(dep)
3012 if origLibrary, ok := targetStubModuleList[depName]; ok {
3013 targetOrigModuleList[origLibrary] = depName
3014 }
3015 })
3016
3017 // Decide which library should be used between original and API imported library
3018 ctx.VisitDirectDeps(func(dep android.Module) {
3019 depName := ctx.OtherModuleName(dep)
3020 if apiLibrary, ok := targetOrigModuleList[depName]; ok {
Spandan Das604f3762023-03-16 22:51:40 +00003021 if ShouldUseStubForApex(ctx, dep) {
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003022 skipModuleList[depName] = true
3023 } else {
3024 skipModuleList[apiLibrary] = true
3025 }
3026 }
3027 })
3028 }
3029
Colin Crossd11fcda2017-10-23 17:59:01 -07003030 ctx.VisitDirectDeps(func(dep android.Module) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003031 depName := ctx.OtherModuleName(dep)
3032 depTag := ctx.OtherModuleDependencyTag(dep)
Dan Albert9e10cd42016-08-03 14:12:14 -07003033
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003034 if _, ok := skipModuleList[depName]; ok {
3035 // skip this module because original module or API imported module matching with this should be used instead.
3036 return
3037 }
3038
Dan Willemsen47450072021-10-19 20:24:49 -07003039 if depTag == android.DarwinUniversalVariantTag {
3040 depPaths.DarwinSecondArchOutput = dep.(*Module).OutputFile()
3041 return
3042 }
3043
Vinh Tran367d89d2023-04-28 11:21:25 -04003044 if depTag == aidlLibraryTag {
3045 if ctx.OtherModuleHasProvider(dep, aidl_library.AidlLibraryProvider) {
3046 depPaths.AidlLibraryInfos = append(
3047 depPaths.AidlLibraryInfos,
3048 ctx.OtherModuleProvider(
3049 dep,
3050 aidl_library.AidlLibraryProvider).(aidl_library.AidlLibraryInfo),
3051 )
3052 }
3053 }
3054
Ivan Lozano52767be2019-10-18 14:49:46 -07003055 ccDep, ok := dep.(LinkableInterface)
3056 if !ok {
3057
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003058 // handling for a few module types that aren't cc Module but that are also supported
3059 switch depTag {
Dan Willemsenb40aab62016-04-20 14:21:14 -07003060 case genSourceDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003061 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenb40aab62016-04-20 14:21:14 -07003062 depPaths.GeneratedSources = append(depPaths.GeneratedSources,
3063 genRule.GeneratedSourceFiles()...)
3064 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003065 ctx.ModuleErrorf("module %q is not a gensrcs or genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07003066 }
Colin Crosse90bfd12017-04-26 16:59:26 -07003067 // Support exported headers from a generated_sources dependency
3068 fallthrough
Dan Willemsenb3454ab2016-09-28 17:34:58 -07003069 case genHeaderDepTag, genHeaderExportDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003070 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Inseob Kimd110f872019-12-06 13:15:38 +09003071 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps,
Dan Willemsen9da9d492018-02-21 18:28:18 -08003072 genRule.GeneratedDeps()...)
Jiyong Park74955042019-10-22 20:19:51 +09003073 dirs := genRule.GeneratedHeaderDirs()
Inseob Kim69378442019-06-03 19:10:47 +09003074 depPaths.IncludeDirs = append(depPaths.IncludeDirs, dirs...)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003075 if depTag == genHeaderExportDepTag {
Inseob Kim69378442019-06-03 19:10:47 +09003076 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, dirs...)
Inseob Kimd110f872019-12-06 13:15:38 +09003077 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders,
3078 genRule.GeneratedSourceFiles()...)
Inseob Kim69378442019-06-03 19:10:47 +09003079 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, genRule.GeneratedDeps()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07003080 // 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 +09003081 c.sabi.Properties.ReexportedIncludes = append(c.sabi.Properties.ReexportedIncludes, dirs.Strings()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07003082
Dan Willemsenb3454ab2016-09-28 17:34:58 -07003083 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07003084 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003085 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07003086 }
Colin Crosscef792e2021-06-11 18:01:26 -07003087 case CrtBeginDepTag:
3088 depPaths.CrtBegin = append(depPaths.CrtBegin, android.OutputFileForModule(ctx, dep, ""))
3089 case CrtEndDepTag:
3090 depPaths.CrtEnd = append(depPaths.CrtEnd, android.OutputFileForModule(ctx, dep, ""))
Colin Crossca860ac2016-01-04 14:34:37 -08003091 }
Colin Crossc99deeb2016-04-11 15:06:20 -07003092 return
3093 }
3094
Colin Crossfe17f6f2019-03-28 19:30:56 -07003095 if depTag == android.ProtoPluginDepTag {
3096 return
3097 }
3098
Colin Crossd11fcda2017-10-23 17:59:01 -07003099 if dep.Target().Os != ctx.Os() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003100 ctx.ModuleErrorf("OS mismatch between %q and %q", ctx.ModuleName(), depName)
3101 return
3102 }
Colin Crossd11fcda2017-10-23 17:59:01 -07003103 if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
Jooyung Han61b66e92020-03-21 14:21:46 +00003104 ctx.ModuleErrorf("Arch mismatch between %q(%v) and %q(%v)",
3105 ctx.ModuleName(), ctx.Arch().ArchType, depName, dep.Target().Arch.ArchType)
Colin Crossa1ad8d12016-06-01 17:09:44 -07003106 return
3107 }
3108
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003109 if depTag == reuseObjTag {
Colin Crossa717db72020-10-23 14:53:06 -07003110 // Skip reused objects for stub libraries, they use their own stub object file instead.
3111 // The reuseObjTag dependency still exists because the LinkageMutator runs before the
3112 // version mutator, so the stubs variant is created from the shared variant that
3113 // already has the reuseObjTag dependency on the static variant.
Colin Cross31076b32020-10-23 17:22:06 -07003114 if !c.library.buildStubs() {
Colin Crossa717db72020-10-23 14:53:06 -07003115 staticAnalogue := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
3116 objs := staticAnalogue.ReuseObjects
3117 depPaths.Objs = depPaths.Objs.Append(objs)
3118 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
3119 reexportExporter(depExporterInfo)
3120 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07003121 return
Jiyong Parke4bb9862019-02-01 00:31:10 +09003122 }
3123
Colin Cross6e511a92020-07-27 21:26:48 -07003124 linkFile := ccDep.OutputFile()
3125
3126 if libDepTag, ok := depTag.(libraryDependencyTag); ok {
3127 // Only use static unwinder for legacy (min_sdk_version = 29) apexes (b/144430859)
Dan Albertc8060532020-07-22 22:32:17 -07003128 if libDepTag.staticUnwinder && c.apexSdkVersion.GreaterThan(android.SdkVersion_Android10) {
Peter Collingbournedc4f9862020-02-12 17:13:25 -08003129 return
3130 }
Peter Collingbournedc4f9862020-02-12 17:13:25 -08003131
Jiyong Parke3867542020-12-03 17:28:25 +09003132 if !apexInfo.IsForPlatform() && libDepTag.excludeInApex {
3133 return
3134 }
Jooyung Han9ffbe832023-11-28 22:31:35 +09003135 if apexInfo.IsForPlatform() && libDepTag.excludeInNonApex {
3136 return
3137 }
Jiyong Parke3867542020-12-03 17:28:25 +09003138
Colin Cross0de8a1e2020-09-18 14:15:30 -07003139 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
Colin Crossc99deeb2016-04-11 15:06:20 -07003140
Colin Cross6e511a92020-07-27 21:26:48 -07003141 var ptr *android.Paths
3142 var depPtr *android.Paths
Colin Crossc99deeb2016-04-11 15:06:20 -07003143
Colin Cross6e511a92020-07-27 21:26:48 -07003144 depFile := android.OptionalPath{}
Colin Cross26c34ed2016-09-30 17:10:16 -07003145
Colin Cross6e511a92020-07-27 21:26:48 -07003146 switch {
3147 case libDepTag.header():
Colin Cross649d8172020-12-10 12:30:21 -08003148 if !ctx.OtherModuleHasProvider(dep, HeaderLibraryInfoProvider) {
3149 if !ctx.Config().AllowMissingDependencies() {
3150 ctx.ModuleErrorf("module %q is not a header library", depName)
3151 } else {
3152 ctx.AddMissingDependencies([]string{depName})
3153 }
3154 return
3155 }
Colin Cross6e511a92020-07-27 21:26:48 -07003156 case libDepTag.shared():
Colin Cross0de8a1e2020-09-18 14:15:30 -07003157 if !ctx.OtherModuleHasProvider(dep, SharedLibraryInfoProvider) {
3158 if !ctx.Config().AllowMissingDependencies() {
3159 ctx.ModuleErrorf("module %q is not a shared library", depName)
3160 } else {
3161 ctx.AddMissingDependencies([]string{depName})
3162 }
3163 return
3164 }
Jiyong Parke3867542020-12-03 17:28:25 +09003165
Jiyong Park7d55b612021-06-11 17:22:09 +09003166 sharedLibraryInfo, returnedDepExporterInfo := ChooseStubOrImpl(ctx, dep)
3167 depExporterInfo = returnedDepExporterInfo
Colin Cross0de8a1e2020-09-18 14:15:30 -07003168
Jiyong Park1ad8e162020-12-01 23:40:09 +09003169 // Stubs lib doesn't link to the shared lib dependencies. Don't set
3170 // linkFile, depFile, and ptr.
3171 if c.IsStubs() {
3172 break
3173 }
3174
Colin Cross0de8a1e2020-09-18 14:15:30 -07003175 linkFile = android.OptionalPathForPath(sharedLibraryInfo.SharedLibrary)
3176 depFile = sharedLibraryInfo.TableOfContents
3177
Colin Cross6e511a92020-07-27 21:26:48 -07003178 ptr = &depPaths.SharedLibs
3179 switch libDepTag.Order {
3180 case earlyLibraryDependency:
3181 ptr = &depPaths.EarlySharedLibs
3182 depPtr = &depPaths.EarlySharedLibsDeps
3183 case normalLibraryDependency:
3184 ptr = &depPaths.SharedLibs
3185 depPtr = &depPaths.SharedLibsDeps
Colin Cross0de8a1e2020-09-18 14:15:30 -07003186 directSharedDeps = append(directSharedDeps, sharedLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07003187 case lateLibraryDependency:
3188 ptr = &depPaths.LateSharedLibs
3189 depPtr = &depPaths.LateSharedLibsDeps
3190 default:
3191 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Colin Crossc99deeb2016-04-11 15:06:20 -07003192 }
Colin Cross6e511a92020-07-27 21:26:48 -07003193 case libDepTag.static():
Colin Cross0de8a1e2020-09-18 14:15:30 -07003194 if !ctx.OtherModuleHasProvider(dep, StaticLibraryInfoProvider) {
3195 if !ctx.Config().AllowMissingDependencies() {
3196 ctx.ModuleErrorf("module %q is not a static library", depName)
3197 } else {
3198 ctx.AddMissingDependencies([]string{depName})
3199 }
3200 return
3201 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09003202
3203 // Stubs lib doesn't link to the static lib dependencies. Don't set
3204 // linkFile, depFile, and ptr.
3205 if c.IsStubs() {
3206 break
3207 }
3208
Colin Cross0de8a1e2020-09-18 14:15:30 -07003209 staticLibraryInfo := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
3210 linkFile = android.OptionalPathForPath(staticLibraryInfo.StaticLibrary)
Colin Cross6e511a92020-07-27 21:26:48 -07003211 if libDepTag.wholeStatic {
3212 ptr = &depPaths.WholeStaticLibs
Colin Cross0de8a1e2020-09-18 14:15:30 -07003213 if len(staticLibraryInfo.Objects.objFiles) > 0 {
3214 depPaths.WholeStaticLibObjs = depPaths.WholeStaticLibObjs.Append(staticLibraryInfo.Objects)
Inseob Kimeec88e12020-01-22 11:11:29 +09003215 } else {
Colin Cross0de8a1e2020-09-18 14:15:30 -07003216 // This case normally catches prebuilt static
3217 // libraries, but it can also occur when
3218 // AllowMissingDependencies is on and the
3219 // dependencies has no sources of its own
3220 // but has a whole_static_libs dependency
3221 // on a missing library. We want to depend
3222 // on the .a file so that there is something
3223 // in the dependency tree that contains the
3224 // error rule for the missing transitive
3225 // dependency.
3226 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003227 }
Colin Crossa2bcf2c2022-02-11 13:11:55 -08003228 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts,
3229 staticLibraryInfo.WholeStaticLibsFromPrebuilts...)
Colin Cross6e511a92020-07-27 21:26:48 -07003230 } else {
3231 switch libDepTag.Order {
3232 case earlyLibraryDependency:
3233 panic(fmt.Errorf("early static libs not suppported"))
3234 case normalLibraryDependency:
3235 // static dependencies will be handled separately so they can be ordered
3236 // using transitive dependencies.
3237 ptr = nil
Colin Cross0de8a1e2020-09-18 14:15:30 -07003238 directStaticDeps = append(directStaticDeps, staticLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07003239 case lateLibraryDependency:
3240 ptr = &depPaths.LateStaticLibs
3241 default:
3242 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Inseob Kimeec88e12020-01-22 11:11:29 +09003243 }
3244 }
Colin Cross3e5e7782022-06-17 22:17:05 +00003245 if libDepTag.unexportedSymbols {
3246 depPaths.LdFlags = append(depPaths.LdFlags,
3247 "-Wl,--exclude-libs="+staticLibraryInfo.StaticLibrary.Base())
3248 }
Inseob Kimeec88e12020-01-22 11:11:29 +09003249 }
3250
Colin Cross6e511a92020-07-27 21:26:48 -07003251 if libDepTag.static() && !libDepTag.wholeStatic {
3252 if !ccDep.CcLibraryInterface() || !ccDep.Static() {
3253 ctx.ModuleErrorf("module %q not a static library", depName)
3254 return
3255 }
Logan Chien43d34c32017-12-20 01:17:32 +08003256
Colin Cross6e511a92020-07-27 21:26:48 -07003257 // When combining coverage files for shared libraries and executables, coverage files
3258 // in static libraries act as if they were whole static libraries. The same goes for
3259 // source based Abi dump files.
3260 if c, ok := ccDep.(*Module); ok {
3261 staticLib := c.linker.(libraryInterface)
3262 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
3263 staticLib.objs().coverageFiles...)
3264 depPaths.StaticLibObjs.sAbiDumpFiles = append(depPaths.StaticLibObjs.sAbiDumpFiles,
3265 staticLib.objs().sAbiDumpFiles...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003266 } else {
Colin Cross6e511a92020-07-27 21:26:48 -07003267 // Handle non-CC modules here
3268 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
Colin Cross0de8a1e2020-09-18 14:15:30 -07003269 ccDep.CoverageFiles()...)
Jiyong Parkde866cb2018-12-07 23:08:36 +09003270 }
3271 }
3272
Colin Cross6e511a92020-07-27 21:26:48 -07003273 if ptr != nil {
3274 if !linkFile.Valid() {
3275 if !ctx.Config().AllowMissingDependencies() {
3276 ctx.ModuleErrorf("module %q missing output file", depName)
3277 } else {
3278 ctx.AddMissingDependencies([]string{depName})
3279 }
3280 return
3281 }
3282 *ptr = append(*ptr, linkFile.Path())
3283 }
3284
3285 if depPtr != nil {
3286 dep := depFile
3287 if !dep.Valid() {
3288 dep = linkFile
3289 }
3290 *depPtr = append(*depPtr, dep.Path())
3291 }
3292
Colin Cross0de8a1e2020-09-18 14:15:30 -07003293 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
3294 depPaths.SystemIncludeDirs = append(depPaths.SystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
3295 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps, depExporterInfo.Deps...)
3296 depPaths.Flags = append(depPaths.Flags, depExporterInfo.Flags...)
3297
3298 if libDepTag.reexportFlags {
3299 reexportExporter(depExporterInfo)
3300 // Add these re-exported flags to help header-abi-dumper to infer the abi exported by a library.
3301 // Re-exported shared library headers must be included as well since they can help us with type information
3302 // about template instantiations (instantiated from their headers).
3303 // -isystem headers are not included since for bionic libraries, abi-filtering is taken care of by version
3304 // scripts.
3305 c.sabi.Properties.ReexportedIncludes = append(
3306 c.sabi.Properties.ReexportedIncludes, depExporterInfo.IncludeDirs.Strings()...)
3307 }
3308
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003309 makeLibName := MakeLibName(ctx, c, ccDep, depName) + libDepTag.makeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003310 switch {
3311 case libDepTag.header():
Colin Cross370173e2020-07-29 12:48:33 -07003312 c.Properties.AndroidMkHeaderLibs = append(
3313 c.Properties.AndroidMkHeaderLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07003314 case libDepTag.shared():
Colin Cross31076b32020-10-23 17:22:06 -07003315 if lib := moduleLibraryInterface(dep); lib != nil {
3316 if lib.buildStubs() && dep.(android.ApexModule).InAnyApex() {
Colin Cross6e511a92020-07-27 21:26:48 -07003317 // Add the dependency to the APEX(es) providing the library so that
3318 // m <module> can trigger building the APEXes as well.
Colin Cross56a83212020-09-15 18:30:11 -07003319 depApexInfo := ctx.OtherModuleProvider(dep, android.ApexInfoProvider).(android.ApexInfo)
Jiyong Parkab50b072021-05-12 17:13:56 +09003320 for _, an := range depApexInfo.InApexVariants {
Colin Cross6e511a92020-07-27 21:26:48 -07003321 c.Properties.ApexesProvidingSharedLibs = append(
3322 c.Properties.ApexesProvidingSharedLibs, an)
3323 }
3324 }
3325 }
3326
3327 // Note: the order of libs in this list is not important because
3328 // they merely serve as Make dependencies and do not affect this lib itself.
Colin Cross370173e2020-07-29 12:48:33 -07003329 c.Properties.AndroidMkSharedLibs = append(
3330 c.Properties.AndroidMkSharedLibs, makeLibName)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003331 // Record BaseLibName for snapshots.
3332 c.Properties.SnapshotSharedLibs = append(c.Properties.SnapshotSharedLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07003333 case libDepTag.static():
3334 if libDepTag.wholeStatic {
3335 c.Properties.AndroidMkWholeStaticLibs = append(
3336 c.Properties.AndroidMkWholeStaticLibs, makeLibName)
3337 } else {
3338 c.Properties.AndroidMkStaticLibs = append(
3339 c.Properties.AndroidMkStaticLibs, makeLibName)
3340 }
Justin Yun5e035862021-06-29 20:50:37 +09003341 // Record BaseLibName for snapshots.
3342 c.Properties.SnapshotStaticLibs = append(c.Properties.SnapshotStaticLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07003343 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09003344 } else if !c.IsStubs() {
3345 // Stubs lib doesn't link to the runtime lib, object, crt, etc. dependencies.
3346
Colin Cross6e511a92020-07-27 21:26:48 -07003347 switch depTag {
3348 case runtimeDepTag:
3349 c.Properties.AndroidMkRuntimeLibs = append(
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003350 c.Properties.AndroidMkRuntimeLibs, MakeLibName(ctx, c, ccDep, depName)+libDepTag.makeSuffix)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003351 // Record BaseLibName for snapshots.
3352 c.Properties.SnapshotRuntimeLibs = append(c.Properties.SnapshotRuntimeLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07003353 case objDepTag:
3354 depPaths.Objs.objFiles = append(depPaths.Objs.objFiles, linkFile.Path())
3355 case CrtBeginDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003356 depPaths.CrtBegin = append(depPaths.CrtBegin, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003357 case CrtEndDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003358 depPaths.CrtEnd = append(depPaths.CrtEnd, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003359 case dynamicLinkerDepTag:
3360 depPaths.DynamicLinker = linkFile
3361 }
Jiyong Park27b188b2017-07-18 13:23:39 +09003362 }
Colin Crossca860ac2016-01-04 14:34:37 -08003363 })
3364
Jeff Gaston294356f2017-09-27 17:05:30 -07003365 // use the ordered dependencies as this module's dependencies
Colin Cross0de8a1e2020-09-18 14:15:30 -07003366 orderedStaticPaths, transitiveStaticLibs := orderStaticModuleDeps(directStaticDeps, directSharedDeps)
3367 depPaths.TranstiveStaticLibrariesForOrdering = transitiveStaticLibs
3368 depPaths.StaticLibs = append(depPaths.StaticLibs, orderedStaticPaths...)
Jeff Gaston294356f2017-09-27 17:05:30 -07003369
Colin Crossdd84e052017-05-17 13:44:16 -07003370 // Dedup exported flags from dependencies
Colin Crossb6715442017-10-24 11:13:31 -07003371 depPaths.Flags = android.FirstUniqueStrings(depPaths.Flags)
Jiyong Park74955042019-10-22 20:19:51 +09003372 depPaths.IncludeDirs = android.FirstUniquePaths(depPaths.IncludeDirs)
3373 depPaths.SystemIncludeDirs = android.FirstUniquePaths(depPaths.SystemIncludeDirs)
Inseob Kimd110f872019-12-06 13:15:38 +09003374 depPaths.GeneratedDeps = android.FirstUniquePaths(depPaths.GeneratedDeps)
Jiyong Park74955042019-10-22 20:19:51 +09003375 depPaths.ReexportedDirs = android.FirstUniquePaths(depPaths.ReexportedDirs)
3376 depPaths.ReexportedSystemDirs = android.FirstUniquePaths(depPaths.ReexportedSystemDirs)
Colin Crossb6715442017-10-24 11:13:31 -07003377 depPaths.ReexportedFlags = android.FirstUniqueStrings(depPaths.ReexportedFlags)
Inseob Kim69378442019-06-03 19:10:47 +09003378 depPaths.ReexportedDeps = android.FirstUniquePaths(depPaths.ReexportedDeps)
Inseob Kimd110f872019-12-06 13:15:38 +09003379 depPaths.ReexportedGeneratedHeaders = android.FirstUniquePaths(depPaths.ReexportedGeneratedHeaders)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003380
3381 if c.sabi != nil {
Inseob Kim69378442019-06-03 19:10:47 +09003382 c.sabi.Properties.ReexportedIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedIncludes)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003383 }
Colin Crossdd84e052017-05-17 13:44:16 -07003384
Colin Crossca860ac2016-01-04 14:34:37 -08003385 return depPaths
3386}
3387
Spandan Das604f3762023-03-16 22:51:40 +00003388func ShouldUseStubForApex(ctx android.ModuleContext, dep android.Module) bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09003389 depName := ctx.OtherModuleName(dep)
Jiyong Park7d55b612021-06-11 17:22:09 +09003390 thisModule, ok := ctx.Module().(android.ApexModule)
3391 if !ok {
3392 panic(fmt.Errorf("Not an APEX module: %q", ctx.ModuleName()))
3393 }
3394
3395 useVndk := false
3396 bootstrap := false
3397 if linkable, ok := ctx.Module().(LinkableInterface); !ok {
3398 panic(fmt.Errorf("Not a Linkable module: %q", ctx.ModuleName()))
3399 } else {
3400 useVndk = linkable.UseVndk()
3401 bootstrap = linkable.Bootstrap()
3402 }
3403
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003404 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
3405
3406 useStubs := false
3407
3408 if lib := moduleLibraryInterface(dep); lib.buildStubs() && useVndk { // LLNDK
3409 if !apexInfo.IsForPlatform() {
3410 // For platform libraries, use current version of LLNDK
3411 // If this is for use_vendor apex we will apply the same rules
3412 // of apex sdk enforcement below to choose right version.
3413 useStubs = true
3414 }
3415 } else if apexInfo.IsForPlatform() || apexInfo.UsePlatformApis {
3416 // If not building for APEX or the containing APEX allows the use of
3417 // platform APIs, use stubs only when it is from an APEX (and not from
3418 // platform) However, for host, ramdisk, vendor_ramdisk, recovery or
3419 // bootstrap modules, always link to non-stub variant
3420 isNotInPlatform := dep.(android.ApexModule).NotInPlatform()
3421
3422 isApexImportedApiLibrary := false
3423
3424 if cc, ok := dep.(*Module); ok {
3425 if apiLibrary, ok := cc.linker.(*apiLibraryDecorator); ok {
3426 if apiLibrary.hasApexStubs() {
3427 isApexImportedApiLibrary = true
3428 }
3429 }
3430 }
3431
3432 useStubs = (isNotInPlatform || isApexImportedApiLibrary) && !bootstrap
3433
3434 if useStubs {
3435 // Another exception: if this module is a test for an APEX, then
3436 // it is linked with the non-stub variant of a module in the APEX
3437 // as if this is part of the APEX.
3438 testFor := ctx.Provider(android.ApexTestForInfoProvider).(android.ApexTestForInfo)
3439 for _, apexContents := range testFor.ApexContents {
3440 if apexContents.DirectlyInApex(depName) {
3441 useStubs = false
3442 break
3443 }
3444 }
3445 }
3446 if useStubs {
3447 // Yet another exception: If this module and the dependency are
3448 // available to the same APEXes then skip stubs between their
3449 // platform variants. This complements the test_for case above,
3450 // which avoids the stubs on a direct APEX library dependency, by
3451 // avoiding stubs for indirect test dependencies as well.
3452 //
3453 // TODO(b/183882457): This doesn't work if the two libraries have
3454 // only partially overlapping apex_available. For that test_for
3455 // modules would need to be split into APEX variants and resolved
3456 // separately for each APEX they have access to.
3457 if !isApexImportedApiLibrary && android.AvailableToSameApexes(thisModule, dep.(android.ApexModule)) {
3458 useStubs = false
3459 }
3460 }
3461 } else {
3462 // If building for APEX, use stubs when the parent is in any APEX that
3463 // the child is not in.
3464 useStubs = !android.DirectlyInAllApexes(apexInfo, depName)
3465 }
3466
3467 return useStubs
3468}
3469
3470// ChooseStubOrImpl determines whether a given dependency should be redirected to the stub variant
3471// of the dependency or not, and returns the SharedLibraryInfo and FlagExporterInfo for the right
3472// dependency. The stub variant is selected when the dependency crosses a boundary where each side
3473// has different level of updatability. For example, if a library foo in an APEX depends on a
3474// library bar which provides stable interface and exists in the platform, foo uses the stub variant
3475// of bar. If bar doesn't provide a stable interface (i.e. buildStubs() == false) or is in the
3476// same APEX as foo, the non-stub variant of bar is used.
3477func ChooseStubOrImpl(ctx android.ModuleContext, dep android.Module) (SharedLibraryInfo, FlagExporterInfo) {
3478 depTag := ctx.OtherModuleDependencyTag(dep)
3479 libDepTag, ok := depTag.(libraryDependencyTag)
3480 if !ok || !libDepTag.shared() {
3481 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
3482 }
3483
Jiyong Park7d55b612021-06-11 17:22:09 +09003484 sharedLibraryInfo := ctx.OtherModuleProvider(dep, SharedLibraryInfoProvider).(SharedLibraryInfo)
3485 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
3486 sharedLibraryStubsInfo := ctx.OtherModuleProvider(dep, SharedLibraryStubsProvider).(SharedLibraryStubsInfo)
Jiyong Park7d55b612021-06-11 17:22:09 +09003487
3488 if !libDepTag.explicitlyVersioned && len(sharedLibraryStubsInfo.SharedStubLibraries) > 0 {
Jiyong Park7d55b612021-06-11 17:22:09 +09003489 // when to use (unspecified) stubs, use the latest one.
Spandan Das604f3762023-03-16 22:51:40 +00003490 if ShouldUseStubForApex(ctx, dep) {
Jiyong Park7d55b612021-06-11 17:22:09 +09003491 stubs := sharedLibraryStubsInfo.SharedStubLibraries
3492 toUse := stubs[len(stubs)-1]
3493 sharedLibraryInfo = toUse.SharedLibraryInfo
3494 depExporterInfo = toUse.FlagExporterInfo
3495 }
3496 }
3497 return sharedLibraryInfo, depExporterInfo
3498}
3499
Colin Cross0de8a1e2020-09-18 14:15:30 -07003500// orderStaticModuleDeps rearranges the order of the static library dependencies of the module
3501// to match the topological order of the dependency tree, including any static analogues of
3502// direct shared libraries. It returns the ordered static dependencies, and an android.DepSet
3503// of the transitive dependencies.
Colin Crossc85750b2022-04-21 12:50:51 -07003504func orderStaticModuleDeps(staticDeps []StaticLibraryInfo, sharedDeps []SharedLibraryInfo) (ordered android.Paths, transitive *android.DepSet[android.Path]) {
3505 transitiveStaticLibsBuilder := android.NewDepSetBuilder[android.Path](android.TOPOLOGICAL)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003506 var staticPaths android.Paths
3507 for _, staticDep := range staticDeps {
3508 staticPaths = append(staticPaths, staticDep.StaticLibrary)
3509 transitiveStaticLibsBuilder.Transitive(staticDep.TransitiveStaticLibrariesForOrdering)
3510 }
3511 for _, sharedDep := range sharedDeps {
Liz Kammeref6dfea2021-06-08 15:37:09 -04003512 if sharedDep.TransitiveStaticLibrariesForOrdering != nil {
3513 transitiveStaticLibsBuilder.Transitive(sharedDep.TransitiveStaticLibrariesForOrdering)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003514 }
3515 }
3516 transitiveStaticLibs := transitiveStaticLibsBuilder.Build()
3517
3518 orderedTransitiveStaticLibs := transitiveStaticLibs.ToList()
3519
3520 // reorder the dependencies based on transitive dependencies
3521 staticPaths = android.FirstUniquePaths(staticPaths)
3522 _, orderedStaticPaths := android.FilterPathList(orderedTransitiveStaticLibs, staticPaths)
3523
3524 if len(orderedStaticPaths) != len(staticPaths) {
3525 missing, _ := android.FilterPathList(staticPaths, orderedStaticPaths)
3526 panic(fmt.Errorf("expected %d ordered static paths , got %d, missing %q %q %q", len(staticPaths), len(orderedStaticPaths), missing, orderedStaticPaths, staticPaths))
3527 }
3528
3529 return orderedStaticPaths, transitiveStaticLibs
3530}
3531
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003532// BaseLibName trims known prefixes and suffixes
3533func BaseLibName(depName string) string {
Colin Cross6e511a92020-07-27 21:26:48 -07003534 libName := strings.TrimSuffix(depName, llndkLibrarySuffix)
3535 libName = strings.TrimSuffix(libName, vendorPublicLibrarySuffix)
Paul Duffind23c7262020-12-11 18:13:08 +00003536 libName = android.RemoveOptionalPrebuiltPrefix(libName)
Colin Cross6e511a92020-07-27 21:26:48 -07003537 return libName
3538}
3539
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003540func MakeLibName(ctx android.ModuleContext, c LinkableInterface, ccDep LinkableInterface, depName string) string {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003541 libName := BaseLibName(depName)
Colin Cross127bb8b2020-12-16 16:46:01 -08003542 ccDepModule, _ := ccDep.(*Module)
3543 isLLndk := ccDepModule != nil && ccDepModule.IsLlndk()
Justin Yuncbca3732021-02-03 19:24:13 +09003544 nonSystemVariantsExist := ccDep.HasNonSystemVariants() || isLLndk
Colin Cross6e511a92020-07-27 21:26:48 -07003545
Justin Yuncbca3732021-02-03 19:24:13 +09003546 if ccDepModule != nil {
Colin Cross6e511a92020-07-27 21:26:48 -07003547 // Use base module name for snapshots when exporting to Makefile.
Ivan Lozanod1dec542021-05-26 15:33:11 -04003548 if snapshotPrebuilt, ok := ccDepModule.linker.(SnapshotInterface); ok {
Justin Yuncbca3732021-02-03 19:24:13 +09003549 baseName := ccDepModule.BaseModuleName()
Colin Cross6e511a92020-07-27 21:26:48 -07003550
Ivan Lozanod1dec542021-05-26 15:33:11 -04003551 return baseName + snapshotPrebuilt.SnapshotAndroidMkSuffix()
Colin Cross6e511a92020-07-27 21:26:48 -07003552 }
3553 }
3554
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003555 if ctx.DeviceConfig().VndkUseCoreVariant() && ccDep.IsVndk() && !ccDep.MustUseVendorVariant() &&
3556 !c.InRamdisk() && !c.InVendorRamdisk() && !c.InRecovery() {
Colin Cross6e511a92020-07-27 21:26:48 -07003557 // The vendor module is a no-vendor-variant VNDK library. Depend on the
3558 // core module instead.
3559 return libName
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003560 } else if ccDep.UseVndk() && nonSystemVariantsExist {
Justin Yuncbca3732021-02-03 19:24:13 +09003561 // The vendor and product modules in Make will have been renamed to not conflict with the
3562 // core module, so update the dependency name here accordingly.
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003563 return libName + ccDep.SubName()
Colin Cross6e511a92020-07-27 21:26:48 -07003564 } else if ccDep.InRamdisk() && !ccDep.OnlyInRamdisk() {
Matthew Maurerc6868382021-07-13 14:12:37 -07003565 return libName + RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003566 } else if ccDep.InVendorRamdisk() && !ccDep.OnlyInVendorRamdisk() {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05003567 return libName + VendorRamdiskSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003568 } else if ccDep.InRecovery() && !ccDep.OnlyInRecovery() {
Matthew Maurer460ee942021-02-11 12:31:46 -08003569 return libName + RecoverySuffix
Ivan Lozanof9e21722020-12-02 09:00:51 -05003570 } else if ccDep.Target().NativeBridge == android.NativeBridgeEnabled {
Matthew Maurera61e31f2021-05-27 11:09:11 -07003571 return libName + NativeBridgeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003572 } else {
3573 return libName
3574 }
3575}
3576
Colin Crossca860ac2016-01-04 14:34:37 -08003577func (c *Module) InstallInData() bool {
3578 if c.installer == nil {
3579 return false
3580 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003581 return c.installer.inData()
3582}
3583
3584func (c *Module) InstallInSanitizerDir() bool {
3585 if c.installer == nil {
3586 return false
3587 }
3588 if c.sanitize != nil && c.sanitize.inSanitizerDir() {
Colin Cross94610402016-08-29 13:41:32 -07003589 return true
3590 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003591 return c.installer.inSanitizerDir()
Colin Crossca860ac2016-01-04 14:34:37 -08003592}
3593
Yifan Hong1b3348d2020-01-21 15:53:22 -08003594func (c *Module) InstallInRamdisk() bool {
3595 return c.InRamdisk()
3596}
3597
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003598func (c *Module) InstallInVendorRamdisk() bool {
3599 return c.InVendorRamdisk()
3600}
3601
Jiyong Parkf9332f12018-02-01 00:54:12 +09003602func (c *Module) InstallInRecovery() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07003603 return c.InRecovery()
Jiyong Parkf9332f12018-02-01 00:54:12 +09003604}
3605
Jingwen Chen8ac7d7d2023-03-20 11:05:16 +00003606func (c *Module) MakeUninstallable() {
3607 if c.installer == nil {
3608 c.ModuleBase.MakeUninstallable()
3609 return
3610 }
3611 c.installer.makeUninstallable(c)
3612}
3613
Dan Willemsen4aa75ca2016-09-28 16:18:03 -07003614func (c *Module) HostToolPath() android.OptionalPath {
3615 if c.installer == nil {
3616 return android.OptionalPath{}
3617 }
3618 return c.installer.hostToolPath()
3619}
3620
Nan Zhangd4e641b2017-07-12 12:55:28 -07003621func (c *Module) IntermPathForModuleOut() android.OptionalPath {
3622 return c.outputFile
3623}
3624
Colin Cross41955e82019-05-29 14:40:35 -07003625func (c *Module) OutputFiles(tag string) (android.Paths, error) {
3626 switch tag {
3627 case "":
3628 if c.outputFile.Valid() {
3629 return android.Paths{c.outputFile.Path()}, nil
3630 }
3631 return android.Paths{}, nil
Colin Cross31d89b42022-10-04 16:35:39 -07003632 case "unstripped":
3633 if c.linker != nil {
3634 return android.PathsIfNonNil(c.linker.unstrippedOutputFilePath()), nil
3635 }
3636 return nil, nil
Colin Cross41955e82019-05-29 14:40:35 -07003637 default:
3638 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003639 }
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003640}
3641
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00003642func (c *Module) static() bool {
3643 if static, ok := c.linker.(interface {
3644 static() bool
3645 }); ok {
3646 return static.static()
3647 }
3648 return false
3649}
3650
Jiyong Park379de2f2018-12-19 02:47:14 +09003651func (c *Module) staticBinary() bool {
3652 if static, ok := c.linker.(interface {
3653 staticBinary() bool
3654 }); ok {
3655 return static.staticBinary()
3656 }
3657 return false
3658}
3659
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07003660func (c *Module) testBinary() bool {
3661 if test, ok := c.linker.(interface {
3662 testBinary() bool
3663 }); ok {
3664 return test.testBinary()
3665 }
3666 return false
3667}
3668
Jingwen Chen537242c2022-08-24 11:53:27 +00003669func (c *Module) testLibrary() bool {
3670 if test, ok := c.linker.(interface {
3671 testLibrary() bool
3672 }); ok {
3673 return test.testLibrary()
3674 }
3675 return false
3676}
3677
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003678func (c *Module) benchmarkBinary() bool {
3679 if b, ok := c.linker.(interface {
3680 benchmarkBinary() bool
3681 }); ok {
3682 return b.benchmarkBinary()
3683 }
3684 return false
3685}
3686
3687func (c *Module) fuzzBinary() bool {
3688 if f, ok := c.linker.(interface {
3689 fuzzBinary() bool
3690 }); ok {
3691 return f.fuzzBinary()
3692 }
3693 return false
3694}
3695
Ivan Lozano3968d8f2020-12-14 11:27:52 -05003696// Header returns true if the module is a header-only variant. (See cc/library.go header()).
3697func (c *Module) Header() bool {
Jiyong Park1d1119f2019-07-29 21:27:18 +09003698 if h, ok := c.linker.(interface {
3699 header() bool
3700 }); ok {
3701 return h.header()
3702 }
3703 return false
3704}
3705
Ivan Lozanod7586b62021-04-01 09:49:36 -04003706func (c *Module) Binary() bool {
Inseob Kim7f283f42020-06-01 21:53:49 +09003707 if b, ok := c.linker.(interface {
3708 binary() bool
3709 }); ok {
3710 return b.binary()
3711 }
3712 return false
3713}
3714
Justin Yun5e035862021-06-29 20:50:37 +09003715func (c *Module) StaticExecutable() bool {
3716 if b, ok := c.linker.(*binaryDecorator); ok {
3717 return b.static()
3718 }
3719 return false
3720}
3721
Ivan Lozanod7586b62021-04-01 09:49:36 -04003722func (c *Module) Object() bool {
Inseob Kim1042d292020-06-01 23:23:05 +09003723 if o, ok := c.linker.(interface {
3724 object() bool
3725 }); ok {
3726 return o.object()
3727 }
3728 return false
3729}
3730
Ivan Lozanof9e21722020-12-02 09:00:51 -05003731func GetMakeLinkType(actx android.ModuleContext, c LinkableInterface) string {
Ivan Lozano52767be2019-10-18 14:49:46 -07003732 if c.UseVndk() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003733 if c.IsLlndk() {
3734 if !c.IsLlndkPublic() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003735 return "native:vndk_private"
Colin Crossb60190a2018-09-04 16:28:17 -07003736 }
Colin Cross127bb8b2020-12-16 16:46:01 -08003737 return "native:vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07003738 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003739 if c.IsVndk() && !c.IsVndkExt() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003740 if c.IsVndkPrivate() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003741 return "native:vndk_private"
Jooyung Han38002912019-05-16 04:01:54 +09003742 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003743 return "native:vndk"
Jooyung Han38002912019-05-16 04:01:54 +09003744 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003745 if c.InProduct() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09003746 return "native:product"
3747 }
Jooyung Han38002912019-05-16 04:01:54 +09003748 return "native:vendor"
Yifan Hong1b3348d2020-01-21 15:53:22 -08003749 } else if c.InRamdisk() {
3750 return "native:ramdisk"
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003751 } else if c.InVendorRamdisk() {
3752 return "native:vendor_ramdisk"
Ivan Lozano52767be2019-10-18 14:49:46 -07003753 } else if c.InRecovery() {
Colin Crossb60190a2018-09-04 16:28:17 -07003754 return "native:recovery"
Ivan Lozanof9e21722020-12-02 09:00:51 -05003755 } else if c.Target().Os == android.Android && c.SdkVersion() != "" {
Colin Crossb60190a2018-09-04 16:28:17 -07003756 return "native:ndk:none:none"
3757 // TODO(b/114741097): use the correct ndk stl once build errors have been fixed
3758 //family, link := getNdkStlFamilyAndLinkType(c)
3759 //return fmt.Sprintf("native:ndk:%s:%s", family, link)
Ivan Lozano52767be2019-10-18 14:49:46 -07003760 } else if actx.DeviceConfig().VndkUseCoreVariant() && !c.MustUseVendorVariant() {
Vic Yangefd249e2018-11-12 20:19:56 -08003761 return "native:platform_vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07003762 } else {
3763 return "native:platform"
3764 }
3765}
3766
Jiyong Park9d452992018-10-03 00:38:19 +09003767// Overrides ApexModule.IsInstallabeToApex()
Roland Levillainf89cd092019-07-29 16:22:59 +01003768// Only shared/runtime libraries and "test_per_src" tests are installable to APEX.
Jiyong Park9d452992018-10-03 00:38:19 +09003769func (c *Module) IsInstallableToApex() bool {
Colin Cross31076b32020-10-23 17:22:06 -07003770 if lib := c.library; lib != nil {
Jiyong Park73c54ee2019-10-22 20:31:18 +09003771 // Stub libs and prebuilt libs in a versioned SDK are not
3772 // installable to APEX even though they are shared libs.
Paul Duffin458a15b2022-11-25 12:18:24 +00003773 return lib.shared() && !lib.buildStubs()
Roland Levillainf89cd092019-07-29 16:22:59 +01003774 } else if _, ok := c.linker.(testPerSrc); ok {
3775 return true
Jiyong Park9d452992018-10-03 00:38:19 +09003776 }
3777 return false
3778}
3779
Jiyong Parka90ca002019-10-07 15:47:24 +09003780func (c *Module) AvailableFor(what string) bool {
3781 if linker, ok := c.linker.(interface {
3782 availableFor(string) bool
3783 }); ok {
3784 return c.ApexModuleBase.AvailableFor(what) || linker.availableFor(what)
3785 } else {
3786 return c.ApexModuleBase.AvailableFor(what)
3787 }
3788}
3789
Jiyong Park62304bb2020-04-13 16:19:48 +09003790func (c *Module) TestFor() []string {
Jiyong Park46a512f2020-12-04 18:02:13 +09003791 return c.Properties.Test_for
Jiyong Park62304bb2020-04-13 16:19:48 +09003792}
3793
Paul Duffin0cb37b92020-03-04 14:52:46 +00003794func (c *Module) EverInstallable() bool {
3795 return c.installer != nil &&
3796 // Check to see whether the module is actually ever installable.
3797 c.installer.everInstallable()
3798}
3799
Ivan Lozanod7586b62021-04-01 09:49:36 -04003800func (c *Module) PreventInstall() bool {
3801 return c.Properties.PreventInstall
3802}
3803
3804func (c *Module) Installable() *bool {
Colin Cross1bc94122021-10-28 13:25:54 -07003805 if c.library != nil {
3806 if i := c.library.installable(); i != nil {
3807 return i
3808 }
3809 }
Ivan Lozanod7586b62021-04-01 09:49:36 -04003810 return c.Properties.Installable
3811}
3812
3813func installable(c LinkableInterface, apexInfo android.ApexInfo) bool {
Paul Duffin0cb37b92020-03-04 14:52:46 +00003814 ret := c.EverInstallable() &&
3815 // Check to see whether the module has been configured to not be installed.
Ivan Lozanod7586b62021-04-01 09:49:36 -04003816 proptools.BoolDefault(c.Installable(), true) &&
3817 !c.PreventInstall() && c.OutputFile().Valid()
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003818
3819 // The platform variant doesn't need further condition. Apex variants however might not
3820 // be installable because it will likely to be included in the APEX and won't appear
3821 // in the system partition.
Colin Cross56a83212020-09-15 18:30:11 -07003822 if apexInfo.IsForPlatform() {
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003823 return ret
3824 }
3825
3826 // Special case for modules that are configured to be installed to /data, which includes
3827 // test modules. For these modules, both APEX and non-APEX variants are considered as
3828 // installable. This is because even the APEX variants won't be included in the APEX, but
3829 // will anyway be installed to /data/*.
3830 // See b/146995717
3831 if c.InstallInData() {
3832 return ret
3833 }
3834
3835 return false
Inseob Kim1f086e22019-05-09 13:29:15 +09003836}
3837
Logan Chien41eabe62019-04-10 13:33:58 +08003838func (c *Module) AndroidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer) {
3839 if c.linker != nil {
3840 if library, ok := c.linker.(*libraryDecorator); ok {
3841 library.androidMkWriteAdditionalDependenciesForSourceAbiDiff(w)
3842 }
3843 }
3844}
3845
Jiyong Park45bf82e2020-12-15 22:29:02 +09003846var _ android.ApexModule = (*Module)(nil)
3847
3848// Implements android.ApexModule
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003849func (c *Module) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
Colin Cross6e511a92020-07-27 21:26:48 -07003850 depTag := ctx.OtherModuleDependencyTag(dep)
3851 libDepTag, isLibDepTag := depTag.(libraryDependencyTag)
3852
3853 if cc, ok := dep.(*Module); ok {
3854 if cc.HasStubsVariants() {
3855 if isLibDepTag && libDepTag.shared() {
3856 // dynamic dep to a stubs lib crosses APEX boundary
3857 return false
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003858 }
Colin Cross6e511a92020-07-27 21:26:48 -07003859 if IsRuntimeDepTag(depTag) {
3860 // runtime dep to a stubs lib also crosses APEX boundary
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003861 return false
3862 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003863 }
Zhijun Heec285872021-04-24 10:47:08 -07003864 if cc.IsLlndk() {
3865 return false
3866 }
Colin Crossaac32222020-07-29 12:51:56 -07003867 if isLibDepTag && c.static() && libDepTag.shared() {
Colin Cross6e511a92020-07-27 21:26:48 -07003868 // shared_lib dependency from a static lib is considered as crossing
3869 // the APEX boundary because the dependency doesn't actually is
3870 // linked; the dependency is used only during the compilation phase.
3871 return false
3872 }
Jiyong Parke3867542020-12-03 17:28:25 +09003873
3874 if isLibDepTag && libDepTag.excludeInApex {
3875 return false
3876 }
Colin Cross6e511a92020-07-27 21:26:48 -07003877 }
Colin Crossc1b36442021-05-06 13:42:48 -07003878 if depTag == stubImplDepTag {
3879 // We don't track from an implementation library to its stubs.
Jiyong Park7d95a512020-05-10 15:16:24 +09003880 return false
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003881 }
Jiyong Park12177fc2021-01-05 14:37:15 +09003882 if depTag == staticVariantTag {
3883 // This dependency is for optimization (reuse *.o from the static lib). It doesn't
3884 // actually mean that the static lib (and its dependencies) are copied into the
3885 // APEX.
3886 return false
3887 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003888 return true
3889}
3890
Jiyong Park45bf82e2020-12-15 22:29:02 +09003891// Implements android.ApexModule
Dan Albertc8060532020-07-22 22:32:17 -07003892func (c *Module) ShouldSupportSdkVersion(ctx android.BaseModuleContext,
3893 sdkVersion android.ApiLevel) error {
Jooyung Han749dc692020-04-15 11:03:39 +09003894 // We ignore libclang_rt.* prebuilt libs since they declare sdk_version: 14(b/121358700)
3895 if strings.HasPrefix(ctx.OtherModuleName(c), "libclang_rt") {
3896 return nil
3897 }
Jooyung Han749dc692020-04-15 11:03:39 +09003898 // We don't check for prebuilt modules
3899 if _, ok := c.linker.(prebuiltLinkerInterface); ok {
3900 return nil
3901 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09003902
Jooyung Han749dc692020-04-15 11:03:39 +09003903 minSdkVersion := c.MinSdkVersion()
3904 if minSdkVersion == "apex_inherit" {
3905 return nil
3906 }
3907 if minSdkVersion == "" {
3908 // JNI libs within APK-in-APEX fall into here
3909 // Those are okay to set sdk_version instead
3910 // We don't have to check if this is a SDK variant because
3911 // non-SDK variant resets sdk_version, which works too.
3912 minSdkVersion = c.SdkVersion()
3913 }
Dan Albertc8060532020-07-22 22:32:17 -07003914 if minSdkVersion == "" {
3915 return fmt.Errorf("neither min_sdk_version nor sdk_version specificed")
3916 }
3917 // Not using nativeApiLevelFromUser because the context here is not
3918 // necessarily a native context.
3919 ver, err := android.ApiLevelFromUser(ctx, minSdkVersion)
Jooyung Han749dc692020-04-15 11:03:39 +09003920 if err != nil {
3921 return err
3922 }
Dan Albertc8060532020-07-22 22:32:17 -07003923
Colin Cross8ca61c12022-10-06 21:00:14 -07003924 // A dependency only needs to support a min_sdk_version at least
3925 // as high as the api level that the architecture was introduced in.
3926 // This allows introducing new architectures in the platform that
3927 // need to be included in apexes that normally require an older
3928 // min_sdk_version.
Colin Crossbb137a32023-01-26 09:54:42 -08003929 minApiForArch := MinApiForArch(ctx, c.Target().Arch.ArchType)
Colin Cross8ca61c12022-10-06 21:00:14 -07003930 if sdkVersion.LessThan(minApiForArch) {
3931 sdkVersion = minApiForArch
3932 }
3933
Dan Albertc8060532020-07-22 22:32:17 -07003934 if ver.GreaterThan(sdkVersion) {
Jooyung Han749dc692020-04-15 11:03:39 +09003935 return fmt.Errorf("newer SDK(%v)", ver)
3936 }
3937 return nil
3938}
3939
Paul Duffinb5769c12021-05-12 16:16:51 +01003940// Implements android.ApexModule
3941func (c *Module) AlwaysRequiresPlatformApexVariant() bool {
3942 // stub libraries and native bridge libraries are always available to platform
3943 return c.IsStubs() || c.Target().NativeBridge == android.NativeBridgeEnabled
3944}
3945
Jooyung Han91f92032022-02-04 12:36:33 +09003946// Overrides android.ApexModuleBase.UniqueApexVariations
3947func (c *Module) UniqueApexVariations() bool {
3948 // When a vendor APEX needs a VNDK lib in it (use_vndk_as_stable: false), it should be a unique
3949 // APEX variation. Otherwise, another vendor APEX with use_vndk_as_stable:true may use a wrong
3950 // variation of the VNDK lib because APEX variations are merged/grouped.
Jooyung Handfc864c2023-03-20 18:19:07 +09003951 // TODO(b/274401041) Find a way to merge APEX variations for vendor apexes.
Jooyung Han91f92032022-02-04 12:36:33 +09003952 return c.UseVndk() && c.IsVndk()
3953}
3954
Inseob Kima1888ce2022-10-04 14:42:02 +09003955func (c *Module) overriddenModules() []string {
3956 if o, ok := c.linker.(overridable); ok {
3957 return o.overriddenModules()
3958 }
3959 return nil
3960}
3961
Rob Seymour925aa092021-08-10 20:42:03 +00003962var _ snapshot.RelativeInstallPath = (*Module)(nil)
3963
Liz Kammer35ca77e2021-12-22 15:31:40 -05003964type moduleType int
3965
3966const (
3967 unknownType moduleType = iota
3968 binary
3969 object
3970 fullLibrary
3971 staticLibrary
3972 sharedLibrary
3973 headerLibrary
Jingwen Chen537242c2022-08-24 11:53:27 +00003974 testBin // testBinary already declared
Spandan Das1278c2c2022-08-19 18:17:28 +00003975 ndkLibrary
Spandan Dase12d2522023-09-12 21:42:31 +00003976 ndkPrebuiltStl
Liz Kammer35ca77e2021-12-22 15:31:40 -05003977)
3978
3979func (c *Module) typ() moduleType {
Jingwen Chen537242c2022-08-24 11:53:27 +00003980 if c.testBinary() {
3981 // testBinary is also a binary, so this comes before the c.Binary()
3982 // conditional. A testBinary has additional implicit dependencies and
3983 // other test-only semantics.
3984 return testBin
3985 } else if c.Binary() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003986 return binary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003987 } else if c.Object() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003988 return object
Jingwen Chen537242c2022-08-24 11:53:27 +00003989 } else if c.testLibrary() {
3990 // TODO(b/244431896) properly convert cc_test_library to its own macro. This
3991 // will let them add implicit compile deps on gtest, for example.
3992 //
Liz Kammerefc51d92023-04-21 15:11:25 -04003993 // For now, treat them as regular libraries.
3994 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003995 } else if c.CcLibrary() {
Chris Parsons58852a02021-12-09 18:10:18 -05003996 static := false
3997 shared := false
3998 if library, ok := c.linker.(*libraryDecorator); ok {
3999 static = library.MutatedProperties.BuildStatic
4000 shared = library.MutatedProperties.BuildShared
4001 } else if library, ok := c.linker.(*prebuiltLibraryLinker); ok {
4002 static = library.MutatedProperties.BuildStatic
4003 shared = library.MutatedProperties.BuildShared
4004 }
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004005 if static && shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004006 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004007 } else if !static && !shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004008 return headerLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004009 } else if static {
Liz Kammer35ca77e2021-12-22 15:31:40 -05004010 return staticLibrary
4011 }
4012 return sharedLibrary
Spandan Das1278c2c2022-08-19 18:17:28 +00004013 } else if c.isNDKStubLibrary() {
4014 return ndkLibrary
Spandan Dase12d2522023-09-12 21:42:31 +00004015 } else if c.IsNdkPrebuiltStl() {
4016 return ndkPrebuiltStl
Liz Kammer35ca77e2021-12-22 15:31:40 -05004017 }
4018 return unknownType
4019}
4020
Colin Crosscfad1192015-11-02 16:43:11 -08004021// Defaults
Colin Crossca860ac2016-01-04 14:34:37 -08004022type Defaults struct {
Colin Cross635c3b02016-05-18 15:37:25 -07004023 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -07004024 android.DefaultsModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +09004025 android.ApexModuleBase
Colin Crosscfad1192015-11-02 16:43:11 -08004026}
4027
Patrice Arrudac249c712019-03-19 17:00:29 -07004028// cc_defaults provides a set of properties that can be inherited by other cc
4029// modules. A module can use the properties from a cc_defaults using
4030// `defaults: ["<:default_module_name>"]`. Properties of both modules are
4031// merged (when possible) by prepending the default module's values to the
4032// depending module's values.
Colin Cross36242852017-06-23 15:06:31 -07004033func defaultsFactory() android.Module {
Colin Crosse1d764e2016-08-18 14:18:32 -07004034 return DefaultsFactory()
4035}
4036
Colin Cross36242852017-06-23 15:06:31 -07004037func DefaultsFactory(props ...interface{}) android.Module {
Colin Crossca860ac2016-01-04 14:34:37 -08004038 module := &Defaults{}
Colin Crosscfad1192015-11-02 16:43:11 -08004039
Colin Cross36242852017-06-23 15:06:31 -07004040 module.AddProperties(props...)
4041 module.AddProperties(
Colin Crossca860ac2016-01-04 14:34:37 -08004042 &BaseProperties{},
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07004043 &VendorProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08004044 &BaseCompilerProperties{},
4045 &BaseLinkerProperties{},
Paul Duffina37832a2019-07-18 12:31:26 +01004046 &ObjectLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07004047 &LibraryProperties{},
Colin Crosse1bb5d02019-09-24 14:55:04 -07004048 &StaticProperties{},
4049 &SharedProperties{},
Colin Cross919281a2016-04-05 16:42:05 -07004050 &FlagExporterProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08004051 &BinaryLinkerProperties{},
Trevor Radcliffef389cb42022-03-24 21:06:14 +00004052 &TestLinkerProperties{},
4053 &TestInstallerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07004054 &TestBinaryProperties{},
Colin Cross43287652020-06-30 10:15:07 -07004055 &BenchmarkProperties{},
hamzehc0a671f2021-07-22 12:05:08 -07004056 &fuzz.FuzzProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08004057 &StlProperties{},
Colin Cross16b23492016-01-06 14:41:07 -08004058 &SanitizeProperties{},
Colin Cross665dce92016-04-28 14:50:03 -07004059 &StripProperties{},
Dan Willemsen7424d612016-09-01 13:45:39 -07004060 &InstallerProperties{},
Dan Willemsena03cf6d2016-09-26 15:45:04 -07004061 &TidyProperties{},
Dan Willemsen581341d2017-02-09 16:16:31 -08004062 &CoverageProperties{},
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08004063 &SAbiProperties{},
Justin Yun4b2382f2017-07-26 14:22:10 +09004064 &VndkProperties{},
Stephen Craneba090d12017-05-09 15:44:35 -07004065 &LTOProperties{},
Yi Kongeb8efc92021-12-09 18:06:29 +08004066 &AfdoProperties{},
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00004067 &OrderfileProperties{},
Dan Willemsen6424d172018-03-08 13:27:59 -08004068 &android.ProtoProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -04004069 // RustBindgenProperties is included here so that cc_defaults can be used for rust_bindgen modules.
4070 &RustBindgenClangProperties{},
Yu-Chi Cheng24b2b0f2021-06-23 15:56:39 -07004071 &prebuiltLinkerProperties{},
Colin Crosse1d764e2016-08-18 14:18:32 -07004072 )
Colin Crosscfad1192015-11-02 16:43:11 -08004073
Jooyung Hancc372c52019-09-25 15:18:44 +09004074 android.InitDefaultsModule(module)
Colin Cross36242852017-06-23 15:06:31 -07004075
4076 return module
Colin Crosscfad1192015-11-02 16:43:11 -08004077}
4078
Jiyong Park2286afd2020-06-16 21:58:53 +09004079func (c *Module) IsSdkVariant() bool {
Lukacs T. Berki2063a0d2021-06-17 09:32:36 +02004080 return c.Properties.IsSdkVariant
Jiyong Park2286afd2020-06-16 21:58:53 +09004081}
4082
Kiyoung Kim51279d32022-08-24 14:10:46 +09004083func (c *Module) isImportedApiLibrary() bool {
4084 _, ok := c.linker.(*apiLibraryDecorator)
4085 return ok
4086}
4087
Sasha Smundak2a4549e2018-11-05 16:49:08 -08004088func kytheExtractAllFactory() android.Singleton {
4089 return &kytheExtractAllSingleton{}
4090}
4091
4092type kytheExtractAllSingleton struct {
4093}
4094
4095func (ks *kytheExtractAllSingleton) GenerateBuildActions(ctx android.SingletonContext) {
4096 var xrefTargets android.Paths
4097 ctx.VisitAllModules(func(module android.Module) {
4098 if ccModule, ok := module.(xref); ok {
4099 xrefTargets = append(xrefTargets, ccModule.XrefCcFiles()...)
4100 }
4101 })
4102 // TODO(asmundak): Perhaps emit a rule to output a warning if there were no xrefTargets
4103 if len(xrefTargets) > 0 {
Colin Crossc3d87d32020-06-04 13:25:17 -07004104 ctx.Phony("xref_cxx", xrefTargets...)
Sasha Smundak2a4549e2018-11-05 16:49:08 -08004105 }
4106}
4107
Jihoon Kangf78a8902022-09-01 22:47:07 +00004108func (c *Module) Partition() string {
4109 if p, ok := c.installer.(interface {
4110 getPartition() string
4111 }); ok {
4112 return p.getPartition()
4113 }
4114 return ""
4115}
4116
Colin Cross06a931b2015-10-28 17:23:31 -07004117var Bool = proptools.Bool
Colin Cross38b40df2018-04-10 16:14:46 -07004118var BoolDefault = proptools.BoolDefault
Nan Zhang0007d812017-11-07 10:57:05 -08004119var BoolPtr = proptools.BoolPtr
4120var String = proptools.String
4121var StringPtr = proptools.StringPtr