blob: 551f2cdb57ac6ddcafc5a498ec323421ae212d07 [file] [log] [blame]
Colin Cross5049f022015-03-18 13:28:46 -07001// Copyright 2015 Google Inc. All rights reserved.
Colin Cross3f40fa42015-01-30 17:27:36 -08002//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15package cc
16
17// This file contains the module types for compiling C/C++ for Android, and converts the properties
18// into the flags and filenames necessary to pass to the compiler. The final creation of the rules
19// is handled in builder.go
20
21import (
Colin Cross41955e82019-05-29 14:40:35 -070022 "fmt"
Logan Chien41eabe62019-04-10 13:33:58 +080023 "io"
Dan Albert9e10cd42016-08-03 14:12:14 -070024 "strconv"
Colin Cross3f40fa42015-01-30 17:27:36 -080025 "strings"
26
Colin Cross97ba0732015-03-23 17:50:24 -070027 "github.com/google/blueprint"
Colin Crossa14fb6a2024-10-23 16:57:06 -070028 "github.com/google/blueprint/depset"
Colin Cross06a931b2015-10-28 17:23:31 -070029 "github.com/google/blueprint/proptools"
Colin Cross97ba0732015-03-23 17:50:24 -070030
Vinh Tran367d89d2023-04-28 11:21:25 -040031 "android/soong/aidl_library"
Colin Cross635c3b02016-05-18 15:37:25 -070032 "android/soong/android"
Colin Crossb98c8b02016-07-29 13:44:28 -070033 "android/soong/cc/config"
hamzehc0a671f2021-07-22 12:05:08 -070034 "android/soong/fuzz"
Colin Cross5049f022015-03-18 13:28:46 -070035 "android/soong/genrule"
Colin Cross3f40fa42015-01-30 17:27:36 -080036)
37
Colin Cross463a90e2015-06-17 14:20:06 -070038func init() {
Paul Duffin036e7002019-12-19 19:16:28 +000039 RegisterCCBuildComponents(android.InitRegistrationContext)
Colin Cross463a90e2015-06-17 14:20:06 -070040
Inseob Kim3b244062023-07-11 13:31:36 +090041 pctx.Import("android/soong/android")
Paul Duffin036e7002019-12-19 19:16:28 +000042 pctx.Import("android/soong/cc/config")
43}
44
45func RegisterCCBuildComponents(ctx android.RegistrationContext) {
46 ctx.RegisterModuleType("cc_defaults", defaultsFactory)
47
48 ctx.PreDepsMutators(func(ctx android.RegisterMutatorsContext) {
Colin Crossac57a6c2024-06-26 13:09:53 -070049 ctx.Transition("sdk", &sdkTransitionMutator{})
Colin Cross8a962802024-10-09 15:29:27 -070050 ctx.BottomUp("llndk", llndkMutator)
Colin Cross767819f2024-05-22 14:22:34 -070051 ctx.Transition("link", &linkageTransitionMutator{})
Colin Crossadd04a82024-05-22 09:57:59 -070052 ctx.Transition("version", &versionTransitionMutator{})
Colin Cross8a962802024-10-09 15:29:27 -070053 ctx.BottomUp("begin", BeginMutator)
Colin Cross1e676be2016-10-12 14:38:15 -070054 })
Colin Cross16b23492016-01-06 14:41:07 -080055
Paul Duffin036e7002019-12-19 19:16:28 +000056 ctx.PostDepsMutators(func(ctx android.RegisterMutatorsContext) {
Liz Kammer75db9312021-07-07 16:41:50 -040057 for _, san := range Sanitizers {
58 san.registerMutators(ctx)
59 }
Dan Willemsen581341d2017-02-09 16:16:31 -080060
Colin Cross8a962802024-10-09 15:29:27 -070061 ctx.BottomUp("sanitize_runtime_deps", sanitizerRuntimeDepsMutator)
62 ctx.BottomUp("sanitize_runtime", sanitizerRuntimeMutator)
Ivan Lozano30c5db22018-02-21 15:49:20 -080063
Colin Cross597bad62024-10-08 15:10:55 -070064 ctx.Transition("fuzz", &fuzzTransitionMutator{})
Cory Barkera1da26f2022-06-07 20:12:06 +000065
Colin Crossf5f4ad32024-01-19 15:41:48 -080066 ctx.Transition("coverage", &coverageTransitionMutator{})
Stephen Craneba090d12017-05-09 15:44:35 -070067
Colin Crossd38feb02024-01-23 16:38:06 -080068 ctx.Transition("afdo", &afdoTransitionMutator{})
Yi Kongeb8efc92021-12-09 18:06:29 +080069
Colin Cross33e0c812024-01-23 16:36:07 -080070 ctx.Transition("orderfile", &orderfileTransitionMutator{})
Sharjeel Khanc6a93d82023-07-18 21:01:11 +000071
Colin Cross6ac83a82024-01-23 11:23:10 -080072 ctx.Transition("lto", &ltoTransitionMutator{})
Jooyung Hana70f0672019-01-18 15:20:43 +090073
Colin Cross8a962802024-10-09 15:29:27 -070074 ctx.BottomUp("check_linktype", checkLinkTypeMutator)
75 ctx.BottomUp("double_loadable", checkDoubleLoadableLibraries)
Colin Cross1e676be2016-10-12 14:38:15 -070076 })
Colin Crossb98c8b02016-07-29 13:44:28 -070077
Colin Cross91ae5ec2024-10-01 14:03:40 -070078 ctx.PostApexMutators(func(ctx android.RegisterMutatorsContext) {
Yo Chiang8aa4e3f2020-11-19 16:30:49 +080079 // sabi mutator needs to be run after apex mutator finishes.
Colin Cross91ae5ec2024-10-01 14:03:40 -070080 ctx.Transition("sabi", &sabiTransitionMutator{})
Yo Chiang8aa4e3f2020-11-19 16:30:49 +080081 })
82
LaMont Jones0c10e4d2023-05-16 00:58:37 +000083 ctx.RegisterParallelSingletonType("kythe_extract_all", kytheExtractAllFactory)
Colin Cross463a90e2015-06-17 14:20:06 -070084}
85
Chris Parsonsef6e0cf2020-12-01 18:26:21 -050086// Deps is a struct containing module names of dependencies, separated by the kind of dependency.
87// Mutators should use `AddVariationDependencies` or its sibling methods to add actual dependency
88// edges to these modules.
89// This object is constructed in DepsMutator, by calling to various module delegates to set
90// relevant fields. For example, `module.compiler.compilerDeps()` may append type-specific
91// dependencies.
92// This is then consumed by the same DepsMutator, which will call `ctx.AddVariationDependencies()`
93// (or its sibling methods) to set real dependencies on the given modules.
Colin Crossca860ac2016-01-04 14:34:37 -080094type Deps struct {
95 SharedLibs, LateSharedLibs []string
96 StaticLibs, LateStaticLibs, WholeStaticLibs []string
Colin Cross5950f382016-12-13 12:50:57 -080097 HeaderLibs []string
Logan Chien43d34c32017-12-20 01:17:32 +080098 RuntimeLibs []string
Colin Crossc472d572015-03-17 15:06:21 -070099
Colin Cross3e5e7782022-06-17 22:17:05 +0000100 // UnexportedStaticLibs are static libraries that are also passed to -Wl,--exclude-libs= to
101 // prevent automatically exporting symbols.
102 UnexportedStaticLibs []string
103
Chris Parsons79d66a52020-06-05 17:26:16 -0400104 // Used for data dependencies adjacent to tests
105 DataLibs []string
Colin Crossc8caa062021-09-24 16:50:14 -0700106 DataBins []string
Chris Parsons79d66a52020-06-05 17:26:16 -0400107
Yo Chiang219968c2020-09-22 18:45:04 +0800108 // Used by DepsMutator to pass system_shared_libs information to check_elf_file.py.
109 SystemSharedLibs []string
110
Vinh Tran367d89d2023-04-28 11:21:25 -0400111 // Used by DepMutator to pass aidl_library modules to aidl compiler
112 AidlLibs []string
113
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500114 // If true, statically link the unwinder into native libraries/binaries.
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800115 StaticUnwinderIfLegacy bool
116
Colin Cross5950f382016-12-13 12:50:57 -0800117 ReexportSharedLibHeaders, ReexportStaticLibHeaders, ReexportHeaderLibHeaders []string
Dan Willemsen490a8dc2016-06-06 18:22:19 -0700118
Colin Cross81413472016-04-11 14:37:39 -0700119 ObjFiles []string
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700120
Cole Faust65cb40a2024-10-21 15:41:42 -0700121 GeneratedSources []string
122 GeneratedHeaders []string
123 DeviceFirstGeneratedHeaders []string
124 GeneratedDeps []string
Dan Willemsenb40aab62016-04-20 14:21:14 -0700125
Dan Willemsenb3454ab2016-09-28 17:34:58 -0700126 ReexportGeneratedHeaders []string
127
Colin Crossc465efd2021-06-11 18:00:04 -0700128 CrtBegin, CrtEnd []string
Dan Willemsena0790e32018-10-12 00:24:23 -0700129
130 // Used for host bionic
Colin Cross9cfe6112021-06-11 18:02:22 -0700131 DynamicLinker string
Jiyong Parke3867542020-12-03 17:28:25 +0900132
133 // List of libs that need to be excluded for APEX variant
134 ExcludeLibsForApex []string
Jooyung Han9ffbe832023-11-28 22:31:35 +0900135 // List of libs that need to be excluded for non-APEX variant
136 ExcludeLibsForNonApex []string
Hsin-Yi Chen715142a2024-03-27 16:31:16 +0800137
138 // LLNDK headers for the ABI checker to check LLNDK implementation library.
139 // An LLNDK implementation is the core variant. LLNDK header libs are reexported by the vendor variant.
Colin Cross1e954b62024-09-13 13:50:00 -0700140 // The core variant cannot depend on the vendor variant because of the order of imageTransitionMutator.Split().
Hsin-Yi Chen715142a2024-03-27 16:31:16 +0800141 // Instead, the LLNDK implementation depends on the LLNDK header libs.
142 LlndkHeaderLibs []string
Colin Crossc472d572015-03-17 15:06:21 -0700143}
144
Ivan Lozano0a468a42024-05-13 21:03:34 -0400145// A struct which to collect flags for rlib dependencies
146type RustRlibDep struct {
147 LibPath android.Path // path to the rlib
148 LinkDirs []string // flags required for dependency (e.g. -L flags)
149 CrateName string // crateNames associated with rlibDeps
150}
151
152func EqRustRlibDeps(a RustRlibDep, b RustRlibDep) bool {
153 return a.LibPath == b.LibPath
154}
155
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500156// PathDeps is a struct containing file paths to dependencies of a module.
157// It's constructed in depsToPath() by traversing the direct dependencies of the current module.
158// It's used to construct flags for various build statements (such as for compiling and linking).
159// It is then passed to module decorator functions responsible for registering build statements
160// (such as `module.compiler.compile()`).`
Colin Crossca860ac2016-01-04 14:34:37 -0800161type PathDeps struct {
Colin Cross26c34ed2016-09-30 17:10:16 -0700162 // Paths to .so files
Jiyong Park64a44f22019-01-18 14:37:08 +0900163 SharedLibs, EarlySharedLibs, LateSharedLibs android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700164 // Paths to the dependencies to use for .so files (.so.toc files)
Jiyong Park64a44f22019-01-18 14:37:08 +0900165 SharedLibsDeps, EarlySharedLibsDeps, LateSharedLibsDeps android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700166 // Paths to .a files
Colin Cross635c3b02016-05-18 15:37:25 -0700167 StaticLibs, LateStaticLibs, WholeStaticLibs android.Paths
Ivan Lozano0a468a42024-05-13 21:03:34 -0400168 // Paths and crateNames for RustStaticLib dependencies
169 RustRlibDeps []RustRlibDep
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700170
Colin Cross0de8a1e2020-09-18 14:15:30 -0700171 // Transitive static library dependencies of static libraries for use in ordering.
Colin Crossa14fb6a2024-10-23 16:57:06 -0700172 TranstiveStaticLibrariesForOrdering depset.DepSet[android.Path]
Colin Cross0de8a1e2020-09-18 14:15:30 -0700173
Colin Cross26c34ed2016-09-30 17:10:16 -0700174 // Paths to .o files
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100175 Objs Objects
176 // Paths to .o files in dependencies that provide them. Note that these lists
177 // aren't complete since prebuilt modules don't provide the .o files.
Dan Willemsen581341d2017-02-09 16:16:31 -0800178 StaticLibObjs Objects
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700179 WholeStaticLibObjs Objects
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700180
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100181 // Paths to .a files in prebuilts. Complements WholeStaticLibObjs to contain
182 // the libs from all whole_static_lib dependencies.
183 WholeStaticLibsFromPrebuilts android.Paths
184
Colin Cross26c34ed2016-09-30 17:10:16 -0700185 // Paths to generated source files
Colin Cross635c3b02016-05-18 15:37:25 -0700186 GeneratedSources android.Paths
Inseob Kimd110f872019-12-06 13:15:38 +0900187 GeneratedDeps android.Paths
Dan Willemsenb40aab62016-04-20 14:21:14 -0700188
Inseob Kimd110f872019-12-06 13:15:38 +0900189 Flags []string
Colin Cross3e5e7782022-06-17 22:17:05 +0000190 LdFlags []string
Inseob Kimd110f872019-12-06 13:15:38 +0900191 IncludeDirs android.Paths
192 SystemIncludeDirs android.Paths
193 ReexportedDirs android.Paths
194 ReexportedSystemDirs android.Paths
195 ReexportedFlags []string
196 ReexportedGeneratedHeaders android.Paths
197 ReexportedDeps android.Paths
Ivan Lozano0a468a42024-05-13 21:03:34 -0400198 ReexportedRustRlibDeps []RustRlibDep
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700199
Colin Cross26c34ed2016-09-30 17:10:16 -0700200 // Paths to crt*.o files
Colin Crossc465efd2021-06-11 18:00:04 -0700201 CrtBegin, CrtEnd android.Paths
Dan Willemsena0790e32018-10-12 00:24:23 -0700202
Dan Willemsena0790e32018-10-12 00:24:23 -0700203 // Path to the dynamic linker binary
204 DynamicLinker android.OptionalPath
Dan Willemsen47450072021-10-19 20:24:49 -0700205
206 // For Darwin builds, the path to the second architecture's output that should
207 // be combined with this architectures's output into a FAT MachO file.
208 DarwinSecondArchOutput android.OptionalPath
Vinh Tran367d89d2023-04-28 11:21:25 -0400209
210 // Paths to direct srcs and transitive include dirs from direct aidl_library deps
211 AidlLibraryInfos []aidl_library.AidlLibraryInfo
Hsin-Yi Chen715142a2024-03-27 16:31:16 +0800212
213 // LLNDK headers for the ABI checker to check LLNDK implementation library.
214 LlndkIncludeDirs android.Paths
215 LlndkSystemIncludeDirs android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700216}
217
Colin Cross4af21ed2019-11-04 09:37:55 -0800218// LocalOrGlobalFlags contains flags that need to have values set globally by the build system or locally by the module
219// tracked separately, in order to maintain the required ordering (most of the global flags need to go first on the
220// command line so they can be overridden by the local module flags).
221type LocalOrGlobalFlags struct {
222 CommonFlags []string // Flags that apply to C, C++, and assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700223 AsFlags []string // Flags that apply to assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800224 YasmFlags []string // Flags that apply to yasm assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700225 CFlags []string // Flags that apply to C and C++ source files
226 ToolingCFlags []string // Flags that apply to C and C++ source files parsed by clang LibTooling tools
227 ConlyFlags []string // Flags that apply to C source files
228 CppFlags []string // Flags that apply to C++ source files
229 ToolingCppFlags []string // Flags that apply to C++ source files parsed by clang LibTooling tools
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700230 LdFlags []string // Flags that apply to linker command lines
Colin Cross4af21ed2019-11-04 09:37:55 -0800231}
232
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500233// Flags contains various types of command line flags (and settings) for use in building build
234// statements related to C++.
Colin Cross4af21ed2019-11-04 09:37:55 -0800235type Flags struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500236 // Local flags (which individual modules are responsible for). These may override global flags.
237 Local LocalOrGlobalFlags
238 // Global flags (which build system or toolchain is responsible for).
Luis Useche342fa6b2024-04-01 19:33:18 -0700239 Global LocalOrGlobalFlags
240 NoOverrideFlags []string // Flags applied to the end of list of flags so they are not overridden
Colin Cross4af21ed2019-11-04 09:37:55 -0800241
242 aidlFlags []string // Flags that apply to aidl source files
243 rsFlags []string // Flags that apply to renderscript source files
244 libFlags []string // Flags to add libraries early to the link order
245 extraLibFlags []string // Flags to add libraries late in the link order after LdFlags
246 TidyFlags []string // Flags that apply to clang-tidy
247 SAbiFlags []string // Flags that apply to header-abi-dumper
Colin Cross28344522015-04-22 13:07:53 -0700248
Colin Crossc3199482017-03-30 15:03:04 -0700249 // Global include flags that apply to C, C++, and assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800250 // These must be after any module include flags, which will be in CommonFlags.
Colin Crossc3199482017-03-30 15:03:04 -0700251 SystemIncludeFlags []string
252
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800253 Toolchain config.Toolchain
254 Tidy bool // True if ninja .tidy rules should be generated.
255 NeedTidyFiles bool // True if module link should depend on .tidy files
256 GcovCoverage bool // True if coverage files should be generated.
257 SAbiDump bool // True if header abi dumps should be generated.
258 EmitXrefs bool // If true, generate Ninja rules to generate emitXrefs input files for Kythe
kellyhungd62ea302024-05-19 21:16:07 +0800259 ClangVerify bool // If true, append cflags "-Xclang -verify" and append "&& touch $out" to the clang command line.
Colin Crossca860ac2016-01-04 14:34:37 -0800260
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500261 // The instruction set required for clang ("arm" or "thumb").
Colin Crossca860ac2016-01-04 14:34:37 -0800262 RequiredInstructionSet string
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500263 // The target-device system path to the dynamic linker.
264 DynamicLinker string
Colin Cross16b23492016-01-06 14:41:07 -0800265
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700266 CFlagsDeps android.Paths // Files depended on by compiler flags
267 LdFlagsDeps android.Paths // Files depended on by linker flags
Colin Cross18c0c5a2016-12-01 14:45:23 -0800268
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500269 // True if .s files should be processed with the c preprocessor.
Dan Willemsen98ab3112019-08-27 21:20:40 -0700270 AssemblerWithCpp bool
Dan Willemsen60e62f02018-11-16 21:05:32 -0800271
Colin Cross19878da2019-03-28 14:45:07 -0700272 proto android.ProtoFlags
Colin Cross19878da2019-03-28 14:45:07 -0700273 protoC bool // Whether to use C instead of C++
274 protoOptionsFile bool // Whether to look for a .options file next to the .proto
Dan Willemsen4e0aa232019-04-10 22:59:54 -0700275
276 Yacc *YaccProperties
Matthias Maennich22fd4d12020-07-15 10:58:56 +0200277 Lex *LexProperties
Colin Crossc472d572015-03-17 15:06:21 -0700278}
279
Colin Crossca860ac2016-01-04 14:34:37 -0800280// Properties used to compile all C or C++ modules
281type BaseProperties struct {
Dan Willemsen742a5452018-07-23 17:19:36 -0700282 // Deprecated. true is the default, false is invalid.
Colin Crossca860ac2016-01-04 14:34:37 -0800283 Clang *bool `android:"arch_variant"`
Colin Cross7d5136f2015-05-11 13:39:40 -0700284
Yi Kong5786f5c2024-05-28 02:22:34 +0900285 // Aggresively trade performance for smaller binary size.
286 // This should only be used for on-device binaries that are rarely executed and not
287 // performance critical.
288 Optimize_for_size *bool `android:"arch_variant"`
289
Jiyong Parkb35a8192020-08-10 15:59:36 +0900290 // The API level that this module is built against. The APIs of this API level will be
291 // visible at build time, but use of any APIs newer than min_sdk_version will render the
292 // module unloadable on older devices. In the future it will be possible to weakly-link new
293 // APIs, making the behavior match Java: such modules will load on older devices, but
294 // calling new APIs on devices that do not support them will result in a crash.
295 //
296 // This property has the same behavior as sdk_version does for Java modules. For those
297 // familiar with Android Gradle, the property behaves similarly to how compileSdkVersion
298 // does for Java code.
299 //
300 // In addition, setting this property causes two variants to be built, one for the platform
301 // and one for apps.
Nan Zhang0007d812017-11-07 10:57:05 -0800302 Sdk_version *string
Colin Cross7d5136f2015-05-11 13:39:40 -0700303
Jiyong Parkb35a8192020-08-10 15:59:36 +0900304 // Minimum OS API level supported by this C or C++ module. This property becomes the value
305 // of the __ANDROID_API__ macro. When the C or C++ module is included in an APEX or an APK,
306 // this property is also used to ensure that the min_sdk_version of the containing module is
307 // not older (i.e. less) than this module's min_sdk_version. When not set, this property
308 // defaults to the value of sdk_version. When this is set to "apex_inherit", this tracks
309 // min_sdk_version of the containing APEX. When the module
310 // is not built for an APEX, "apex_inherit" defaults to sdk_version.
Jooyung Han379660c2020-04-21 15:24:00 +0900311 Min_sdk_version *string
312
Colin Crossc511bc52020-04-07 16:50:32 +0000313 // If true, always create an sdk variant and don't create a platform variant.
314 Sdk_variant_only *bool
315
Jiyong Parkde866cb2018-12-07 23:08:36 +0900316 AndroidMkSharedLibs []string `blueprint:"mutated"`
317 AndroidMkStaticLibs []string `blueprint:"mutated"`
Ivan Lozano0a468a42024-05-13 21:03:34 -0400318 AndroidMkRlibs []string `blueprint:"mutated"`
Jiyong Parkde866cb2018-12-07 23:08:36 +0900319 AndroidMkRuntimeLibs []string `blueprint:"mutated"`
320 AndroidMkWholeStaticLibs []string `blueprint:"mutated"`
Bill Peckhama46de702020-04-21 17:23:37 -0700321 AndroidMkHeaderLibs []string `blueprint:"mutated"`
Jiyong Parkde866cb2018-12-07 23:08:36 +0900322 HideFromMake bool `blueprint:"mutated"`
323 PreventInstall bool `blueprint:"mutated"`
324 ApexesProvidingSharedLibs []string `blueprint:"mutated"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700325
Yo Chiang219968c2020-09-22 18:45:04 +0800326 // Set by DepsMutator.
327 AndroidMkSystemSharedLibs []string `blueprint:"mutated"`
328
Kiyoung Kimb5fdb2e2024-01-03 14:24:34 +0900329 // The name of the image this module is built for
330 ImageVariation string `blueprint:"mutated"`
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200331
332 // The VNDK version this module is built against. If empty, the module is not
333 // build against the VNDK.
334 VndkVersion string `blueprint:"mutated"`
335
336 // Suffix for the name of Android.mk entries generated by this module
337 SubName string `blueprint:"mutated"`
Colin Cross5beccee2017-12-07 15:28:59 -0800338
339 // *.logtags files, to combine together in order to generate the /system/etc/event-log-tags
340 // file
Inseob Kim37e0bb02024-04-29 15:54:44 +0900341 Logtags []string `android:"path"`
Jiyong Parkf9332f12018-02-01 00:54:12 +0900342
Yifan Hong39143a92020-10-26 12:43:12 -0700343 // Make this module available when building for ramdisk.
344 // On device without a dedicated recovery partition, the module is only
345 // available after switching root into
346 // /first_stage_ramdisk. To expose the module before switching root, install
347 // the recovery variant instead.
Yifan Hong1b3348d2020-01-21 15:53:22 -0800348 Ramdisk_available *bool
349
Yifan Hong39143a92020-10-26 12:43:12 -0700350 // Make this module available when building for vendor ramdisk.
351 // On device without a dedicated recovery partition, the module is only
352 // available after switching root into
353 // /first_stage_ramdisk. To expose the module before switching root, install
354 // the recovery variant instead.
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700355 Vendor_ramdisk_available *bool
356
Jiyong Parkf9332f12018-02-01 00:54:12 +0900357 // Make this module available when building for recovery
358 Recovery_available *bool
359
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200360 // Used by imageMutator, set by ImageMutatorBegin()
Jihoon Kang47e91842024-06-19 00:51:16 +0000361 VendorVariantNeeded bool `blueprint:"mutated"`
362 ProductVariantNeeded bool `blueprint:"mutated"`
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200363 CoreVariantNeeded bool `blueprint:"mutated"`
364 RamdiskVariantNeeded bool `blueprint:"mutated"`
365 VendorRamdiskVariantNeeded bool `blueprint:"mutated"`
366 RecoveryVariantNeeded bool `blueprint:"mutated"`
367
368 // A list of variations for the "image" mutator of the form
369 //<image name> '.' <version char>, for example, 'vendor.S'
370 ExtraVersionedImageVariations []string `blueprint:"mutated"`
Jiyong Parkb0788572018-12-20 22:10:17 +0900371
372 // Allows this module to use non-APEX version of libraries. Useful
373 // for building binaries that are started before APEXes are activated.
374 Bootstrap *bool
Jooyung Han097087b2019-10-22 19:32:18 +0900375
Hao Chen1c8ea5b2023-10-20 23:03:45 +0000376 // Allows this module to be included in CMake release snapshots to be built outside of Android
377 // build system and source tree.
378 Cmake_snapshot_supported *bool
379
Colin Cross1bc94122021-10-28 13:25:54 -0700380 Installable *bool `android:"arch_variant"`
Colin Crossc511bc52020-04-07 16:50:32 +0000381
382 // Set by factories of module types that can only be referenced from variants compiled against
383 // the SDK.
384 AlwaysSdk bool `blueprint:"mutated"`
385
386 // Variant is an SDK variant created by sdkMutator
387 IsSdkVariant bool `blueprint:"mutated"`
388 // Set when both SDK and platform variants are exported to Make to trigger renaming the SDK
389 // variant to have a ".sdk" suffix.
390 SdkAndPlatformVariantVisibleToMake bool `blueprint:"mutated"`
Bill Peckham945441c2020-08-31 16:07:58 -0700391
Jiyong Park46a512f2020-12-04 18:02:13 +0900392 // List of APEXes that this module has private access to for testing purpose. The module
393 // can depend on libraries that are not exported by the APEXes and use private symbols
394 // from the exported libraries.
Martin Stjernholm855e90b2021-03-25 02:33:14 +0000395 Test_for []string `android:"arch_variant"`
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800396
397 Target struct {
398 Platform struct {
399 // List of modules required by the core variant.
400 Required []string `android:"arch_variant"`
401
402 // List of modules not required by the core variant.
403 Exclude_required []string `android:"arch_variant"`
404 } `android:"arch_variant"`
405
406 Recovery struct {
407 // List of modules required by the recovery variant.
408 Required []string `android:"arch_variant"`
409
410 // List of modules not required by the recovery variant.
411 Exclude_required []string `android:"arch_variant"`
412 } `android:"arch_variant"`
413 } `android:"arch_variant"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700414}
415
416type VendorProperties struct {
Jiyong Park82e2bf32017-08-16 14:05:54 +0900417 // whether this module should be allowed to be directly depended by other
418 // modules with `vendor: true`, `proprietary: true`, or `vendor_available:true`.
Justin Yun63e9ec72020-10-29 16:49:43 +0900419 // If set to true, two variants will be built separately, one like
420 // normal, and the other limited to the set of libraries and headers
421 // that are exposed to /vendor modules.
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700422 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900423 // The vendor variant may be used with a different (newer) /system,
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700424 // so it shouldn't have any unversioned runtime dependencies, or
425 // make assumptions about the system that may not be true in the
426 // future.
427 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900428 // If set to false, this module becomes inaccessible from /vendor modules.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900429 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900430 // The modules with vndk: {enabled: true} must define 'vendor_available'
Justin Yun0b1db6d2021-01-08 15:22:34 +0900431 // to 'true'.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900432 //
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700433 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
434 Vendor_available *bool
Jiyong Park5fb8c102018-04-09 12:03:06 +0900435
Justin Yunebcf0c52021-01-08 18:00:19 +0900436 // This is the same as the "vendor_available" except that the install path
437 // of the vendor variant is /odm or /vendor/odm.
438 // By replacing "vendor_available: true" with "odm_available: true", the
439 // module will install its vendor variant to the /odm partition or /vendor/odm.
440 // As the modules with "odm_available: true" still create the vendor variants,
441 // they can link to the other vendor modules as the vendor_available modules do.
442 // Also, the vendor modules can link to odm_available modules.
443 //
444 // It may not be used for VNDK modules.
445 Odm_available *bool
446
Justin Yun63e9ec72020-10-29 16:49:43 +0900447 // whether this module should be allowed to be directly depended by other
448 // modules with `product_specific: true` or `product_available: true`.
449 // If set to true, an additional product variant will be built separately
450 // that is limited to the set of libraries and headers that are exposed to
451 // /product modules.
452 //
453 // The product variant may be used with a different (newer) /system,
454 // so it shouldn't have any unversioned runtime dependencies, or
455 // make assumptions about the system that may not be true in the
456 // future.
457 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900458 // If set to false, this module becomes inaccessible from /product modules.
459 //
460 // Different from the 'vendor_available' property, the modules with
461 // vndk: {enabled: true} don't have to define 'product_available'. The VNDK
462 // library without 'product_available' may not be depended on by any other
463 // modules that has product variants including the product available VNDKs.
Justin Yun63e9ec72020-10-29 16:49:43 +0900464 //
465 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
466 // and PRODUCT_PRODUCT_VNDK_VERSION isn't set.
467 Product_available *bool
468
Jiyong Park5fb8c102018-04-09 12:03:06 +0900469 // whether this module is capable of being loaded with other instance
470 // (possibly an older version) of the same module in the same process.
471 // Currently, a shared library that is a member of VNDK (vndk: {enabled: true})
472 // can be double loaded in a vendor process if the library is also a
473 // (direct and indirect) dependency of an LLNDK library. Such libraries must be
474 // explicitly marked as `double_loadable: true` by the owner, or the dependency
475 // from the LLNDK lib should be cut if the lib is not designed to be double loaded.
476 Double_loadable *bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800477
478 // IsLLNDK is set to true for the vendor variant of a cc_library module that has LLNDK stubs.
479 IsLLNDK bool `blueprint:"mutated"`
480
Colin Cross5271fea2021-04-27 13:06:04 -0700481 // IsVendorPublicLibrary is set for the core and product variants of a library that has
482 // vendor_public_library stubs.
483 IsVendorPublicLibrary bool `blueprint:"mutated"`
Colin Crossca860ac2016-01-04 14:34:37 -0800484}
485
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500486// ModuleContextIntf is an interface (on a module context helper) consisting of functions related
487// to understanding details about the type of the current module.
488// For example, one might call these functions to determine whether the current module is a static
489// library and/or is installed in vendor directories.
Colin Crossca860ac2016-01-04 14:34:37 -0800490type ModuleContextIntf interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800491 static() bool
492 staticBinary() bool
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -0700493 testBinary() bool
Yi Kong56fc1b62022-09-06 16:24:00 +0800494 testLibrary() bool
Jiyong Park1d1119f2019-07-29 21:27:18 +0900495 header() bool
Inseob Kim7f283f42020-06-01 21:53:49 +0900496 binary() bool
Inseob Kim1042d292020-06-01 23:23:05 +0900497 object() bool
Colin Crossb98c8b02016-07-29 13:44:28 -0700498 toolchain() config.Toolchain
Jooyung Hanccce2f22020-03-07 03:45:53 +0900499 canUseSdk() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700500 useSdk() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800501 sdkVersion() string
Jiyong Parkb35a8192020-08-10 15:59:36 +0900502 minSdkVersion() string
503 isSdkVariant() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700504 useVndk() bool
Colin Cross95f1ca02020-10-29 20:47:22 -0700505 isNdk(config android.Config) bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800506 IsLlndk() bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800507 isImplementationForLLNDKPublic() bool
Colin Cross5271fea2021-04-27 13:06:04 -0700508 IsVendorPublicLibrary() bool
Justin Yun5f7f7e82019-11-18 19:52:14 +0900509 inProduct() bool
510 inVendor() bool
Yifan Hong1b3348d2020-01-21 15:53:22 -0800511 inRamdisk() bool
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700512 inVendorRamdisk() bool
Jiyong Parkf9332f12018-02-01 00:54:12 +0900513 inRecovery() bool
Kiyoung Kimaa394802024-01-08 12:55:45 +0900514 InVendorOrProduct() bool
Dan Willemsen8146b2f2016-03-30 21:00:30 -0700515 selectedStl() string
Colin Crossce75d2c2016-10-06 16:12:58 -0700516 baseModuleName() string
Colin Cross3513fb12024-01-24 14:44:47 -0800517 isAfdoCompile(ctx ModuleContext) bool
Sharjeel Khanc6a93d82023-07-18 21:01:11 +0000518 isOrderfileCompile() bool
Yi Kongc702ebd2022-08-19 16:02:45 +0800519 isCfi() bool
Yi Konged79fa32023-06-04 17:15:42 +0900520 isFuzzer() bool
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800521 isNDKStubLibrary() bool
Ivan Lozanobd721262018-11-27 14:33:03 -0800522 useClangLld(actx ModuleContext) bool
Logan Chiene274fc92019-12-03 11:18:32 -0800523 isForPlatform() bool
Colin Crosse07f2312020-08-13 11:24:56 -0700524 apexVariationName() string
Dan Albertc8060532020-07-22 22:32:17 -0700525 apexSdkVersion() android.ApiLevel
Jiyong Parka4b9dd02019-01-16 22:53:13 +0900526 bootstrap() bool
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700527 nativeCoverage() bool
Colin Cross56a83212020-09-15 18:30:11 -0700528 directlyInAnyApex() bool
Colin Cross95b07f22020-12-16 11:06:50 -0800529 isPreventInstall() bool
Cindy Zhou5d5cfc12021-01-09 08:25:22 -0800530 isCfiAssemblySupportEnabled() bool
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800531 getSharedFlags() *SharedFlags
Colin Cross4a9e6ec2023-12-18 15:29:41 -0800532 notInPlatform() bool
Yi Kong5786f5c2024-05-28 02:22:34 +0900533 optimizeForSize() bool
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800534}
535
536type SharedFlags struct {
537 numSharedFlags int
538 flagsMap map[string]string
Colin Crossca860ac2016-01-04 14:34:37 -0800539}
540
541type ModuleContext interface {
Colin Cross635c3b02016-05-18 15:37:25 -0700542 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800543 ModuleContextIntf
544}
545
546type BaseModuleContext interface {
Colin Cross0ea8ba82019-06-06 14:33:29 -0700547 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800548 ModuleContextIntf
549}
550
Colin Cross37047f12016-12-13 17:06:13 -0800551type DepsContext interface {
552 android.BottomUpMutatorContext
553 ModuleContextIntf
554}
555
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500556// feature represents additional (optional) steps to building cc-related modules, such as invocation
557// of clang-tidy.
Colin Crossca860ac2016-01-04 14:34:37 -0800558type feature interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800559 flags(ctx ModuleContext, flags Flags) Flags
560 props() []interface{}
561}
562
Joe Onorato37f900c2023-07-18 16:58:16 -0700563// Information returned from Generator about the source code it's generating
564type GeneratedSource struct {
565 IncludeDirs android.Paths
566 Sources android.Paths
567 Headers android.Paths
568 ReexportedDirs android.Paths
569}
570
571// generator allows injection of generated code
572type Generator interface {
573 GeneratorProps() []interface{}
574 GeneratorInit(ctx BaseModuleContext)
575 GeneratorDeps(ctx DepsContext, deps Deps) Deps
576 GeneratorFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
577 GeneratorSources(ctx ModuleContext) GeneratedSource
578 GeneratorBuildActions(ctx ModuleContext, flags Flags, deps PathDeps)
579}
580
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500581// compiler is the interface for a compiler helper object. Different module decorators may implement
Liz Kammer718eb272022-01-07 10:53:37 -0500582// this helper differently.
Colin Crossca860ac2016-01-04 14:34:37 -0800583type compiler interface {
Colin Cross42742b82016-08-01 13:20:05 -0700584 compilerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800585 compilerDeps(ctx DepsContext, deps Deps) Deps
Colin Crossf18e1102017-11-16 14:33:08 -0800586 compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
Colin Cross42742b82016-08-01 13:20:05 -0700587 compilerProps() []interface{}
Hao Chen1c8ea5b2023-10-20 23:03:45 +0000588 baseCompilerProps() BaseCompilerProperties
Colin Cross42742b82016-08-01 13:20:05 -0700589
Colin Cross76fada02016-07-27 10:31:13 -0700590 appendCflags([]string)
591 appendAsflags([]string)
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700592 compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects
Colin Crossca860ac2016-01-04 14:34:37 -0800593}
594
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500595// linker is the interface for a linker decorator object. Individual module types can provide
596// their own implementation for this decorator, and thus specify custom logic regarding build
597// statements pertaining to linking.
Colin Crossca860ac2016-01-04 14:34:37 -0800598type linker interface {
Colin Cross42742b82016-08-01 13:20:05 -0700599 linkerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800600 linkerDeps(ctx DepsContext, deps Deps) Deps
Colin Cross42742b82016-08-01 13:20:05 -0700601 linkerFlags(ctx ModuleContext, flags Flags) Flags
602 linkerProps() []interface{}
Hao Chen1c8ea5b2023-10-20 23:03:45 +0000603 baseLinkerProps() BaseLinkerProperties
Ivan Lozanobd721262018-11-27 14:33:03 -0800604 useClangLld(actx ModuleContext) bool
Colin Cross42742b82016-08-01 13:20:05 -0700605
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700606 link(ctx ModuleContext, flags Flags, deps PathDeps, objs Objects) android.Path
Colin Cross76fada02016-07-27 10:31:13 -0700607 appendLdflags([]string)
Jiyong Parkaf6d8952019-01-31 12:21:23 +0900608 unstrippedOutputFilePath() android.Path
Wei Li5f5d2712023-12-11 15:40:29 -0800609 strippedAllOutputFilePath() android.Path
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700610
611 nativeCoverage() bool
Jiyong Parkee9a98d2019-08-09 14:44:36 +0900612 coverageOutputFilePath() android.OptionalPath
Paul Duffin13f02712020-03-06 12:30:43 +0000613
614 // Get the deps that have been explicitly specified in the properties.
Cole Fauste8a87832024-09-11 11:35:46 -0700615 linkerSpecifiedDeps(ctx android.ConfigurableEvaluatorContext, module *Module, specifiedDeps specifiedDeps) specifiedDeps
Colin Cross4a9e6ec2023-12-18 15:29:41 -0800616
617 moduleInfoJSON(ctx ModuleContext, moduleInfoJSON *android.ModuleInfoJSON)
Paul Duffin13f02712020-03-06 12:30:43 +0000618}
619
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500620// specifiedDeps is a tuple struct representing dependencies of a linked binary owned by the linker.
Paul Duffin13f02712020-03-06 12:30:43 +0000621type specifiedDeps struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500622 sharedLibs []string
623 // Note nil and [] are semantically distinct. [] prevents linking against the defaults (usually
624 // libc, libm, etc.)
Colin Cross6b8f4252021-07-22 11:39:44 -0700625 systemSharedLibs []string
Colin Crossca860ac2016-01-04 14:34:37 -0800626}
627
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500628// installer is the interface for an installer helper object. This helper is responsible for
629// copying build outputs to the appropriate locations so that they may be installed on device.
Colin Crossca860ac2016-01-04 14:34:37 -0800630type installer interface {
Colin Cross42742b82016-08-01 13:20:05 -0700631 installerProps() []interface{}
Colin Cross635c3b02016-05-18 15:37:25 -0700632 install(ctx ModuleContext, path android.Path)
Paul Duffin0cb37b92020-03-04 14:52:46 +0000633 everInstallable() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800634 inData() bool
Vishwath Mohan1dd88392017-03-29 22:00:18 -0700635 inSanitizerDir() bool
Dan Willemsen4aa75ca2016-09-28 16:18:03 -0700636 hostToolPath() android.OptionalPath
Jiyong Parkb7c24df2019-02-01 12:03:59 +0900637 relativeInstallPath() string
Jingwen Chen8ac7d7d2023-03-20 11:05:16 +0000638 makeUninstallable(mod *Module)
Inseob Kim800d1142021-06-14 12:03:51 +0900639 installInRoot() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800640}
641
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800642type xref interface {
643 XrefCcFiles() android.Paths
644}
645
Inseob Kima1888ce2022-10-04 14:42:02 +0900646type overridable interface {
647 overriddenModules() []string
648}
649
Colin Cross6e511a92020-07-27 21:26:48 -0700650type libraryDependencyKind int
651
652const (
653 headerLibraryDependency = iota
654 sharedLibraryDependency
655 staticLibraryDependency
Ivan Lozano0a468a42024-05-13 21:03:34 -0400656 rlibLibraryDependency
Colin Cross6e511a92020-07-27 21:26:48 -0700657)
658
659func (k libraryDependencyKind) String() string {
660 switch k {
661 case headerLibraryDependency:
662 return "headerLibraryDependency"
663 case sharedLibraryDependency:
664 return "sharedLibraryDependency"
665 case staticLibraryDependency:
666 return "staticLibraryDependency"
Ivan Lozano0a468a42024-05-13 21:03:34 -0400667 case rlibLibraryDependency:
668 return "rlibLibraryDependency"
Colin Cross6e511a92020-07-27 21:26:48 -0700669 default:
670 panic(fmt.Errorf("unknown libraryDependencyKind %d", k))
671 }
672}
673
674type libraryDependencyOrder int
675
676const (
677 earlyLibraryDependency = -1
678 normalLibraryDependency = 0
679 lateLibraryDependency = 1
680)
681
682func (o libraryDependencyOrder) String() string {
683 switch o {
684 case earlyLibraryDependency:
685 return "earlyLibraryDependency"
686 case normalLibraryDependency:
687 return "normalLibraryDependency"
688 case lateLibraryDependency:
689 return "lateLibraryDependency"
690 default:
691 panic(fmt.Errorf("unknown libraryDependencyOrder %d", o))
692 }
693}
694
695// libraryDependencyTag is used to tag dependencies on libraries. Unlike many dependency
696// tags that have a set of predefined tag objects that are reused for each dependency, a
697// libraryDependencyTag is designed to contain extra metadata and is constructed as needed.
698// That means that comparing a libraryDependencyTag for equality will only be equal if all
699// of the metadata is equal. Most usages will want to type assert to libraryDependencyTag and
700// then check individual metadata fields instead.
701type libraryDependencyTag struct {
702 blueprint.BaseDependencyTag
703
704 // These are exported so that fmt.Printf("%#v") can call their String methods.
705 Kind libraryDependencyKind
706 Order libraryDependencyOrder
707
708 wholeStatic bool
709
710 reexportFlags bool
711 explicitlyVersioned bool
712 dataLib bool
713 ndk bool
714
715 staticUnwinder bool
716
717 makeSuffix string
Jiyong Parke3867542020-12-03 17:28:25 +0900718
Cindy Zhou18417cb2020-12-10 07:12:38 -0800719 // Whether or not this dependency should skip the apex dependency check
720 skipApexAllowedDependenciesCheck bool
721
Jiyong Parke3867542020-12-03 17:28:25 +0900722 // Whether or not this dependency has to be followed for the apex variants
723 excludeInApex bool
Jooyung Han9ffbe832023-11-28 22:31:35 +0900724 // Whether or not this dependency has to be followed for the non-apex variants
725 excludeInNonApex bool
Colin Cross3e5e7782022-06-17 22:17:05 +0000726
727 // If true, don't automatically export symbols from the static library into a shared library.
728 unexportedSymbols bool
Colin Cross6e511a92020-07-27 21:26:48 -0700729}
730
731// header returns true if the libraryDependencyTag is tagging a header lib dependency.
732func (d libraryDependencyTag) header() bool {
733 return d.Kind == headerLibraryDependency
734}
735
736// shared returns true if the libraryDependencyTag is tagging a shared lib dependency.
737func (d libraryDependencyTag) shared() bool {
738 return d.Kind == sharedLibraryDependency
739}
740
741// shared returns true if the libraryDependencyTag is tagging a static lib dependency.
742func (d libraryDependencyTag) static() bool {
743 return d.Kind == staticLibraryDependency
744}
745
Colin Cross65cb3142021-12-10 23:05:02 +0000746func (d libraryDependencyTag) LicenseAnnotations() []android.LicenseAnnotation {
747 if d.shared() {
748 return []android.LicenseAnnotation{android.LicenseAnnotationSharedDependency}
749 }
750 return nil
751}
752
753var _ android.LicenseAnnotationsDependencyTag = libraryDependencyTag{}
754
Colin Crosse9fe2942020-11-10 18:12:15 -0800755// InstallDepNeeded returns true for shared libraries so that shared library dependencies of
756// binaries or other shared libraries are installed as dependencies.
757func (d libraryDependencyTag) InstallDepNeeded() bool {
758 return d.shared()
759}
760
761var _ android.InstallNeededDependencyTag = libraryDependencyTag{}
762
Yu Liu67a28422024-03-05 00:36:31 +0000763func (d libraryDependencyTag) PropagateAconfigValidation() bool {
764 return d.static()
765}
766
767var _ android.PropagateAconfigValidationDependencyTag = libraryDependencyTag{}
768
Colin Crosse9fe2942020-11-10 18:12:15 -0800769// dependencyTag is used for tagging miscellaneous dependency types that don't fit into
Colin Cross6e511a92020-07-27 21:26:48 -0700770// libraryDependencyTag. Each tag object is created globally and reused for multiple
771// dependencies (although since the object contains no references, assigning a tag to a
772// variable and modifying it will not modify the original). Users can compare the tag
773// returned by ctx.OtherModuleDependencyTag against the global original
774type dependencyTag struct {
775 blueprint.BaseDependencyTag
776 name string
777}
778
Colin Crosse9fe2942020-11-10 18:12:15 -0800779// installDependencyTag is used for tagging miscellaneous dependency types that don't fit into
780// libraryDependencyTag, but where the dependency needs to be installed when the parent is
781// installed.
782type installDependencyTag struct {
783 blueprint.BaseDependencyTag
784 android.InstallAlwaysNeededDependencyTag
785 name string
786}
787
Colin Crossc99deeb2016-04-11 15:06:20 -0700788var (
Colin Cross6e511a92020-07-27 21:26:48 -0700789 genSourceDepTag = dependencyTag{name: "gen source"}
790 genHeaderDepTag = dependencyTag{name: "gen header"}
791 genHeaderExportDepTag = dependencyTag{name: "gen header export"}
792 objDepTag = dependencyTag{name: "obj"}
Jiyong Parkd630bdd2020-11-25 11:47:24 +0900793 dynamicLinkerDepTag = installDependencyTag{name: "dynamic linker"}
Colin Cross6e511a92020-07-27 21:26:48 -0700794 reuseObjTag = dependencyTag{name: "reuse objects"}
795 staticVariantTag = dependencyTag{name: "static variant"}
796 vndkExtDepTag = dependencyTag{name: "vndk extends"}
797 dataLibDepTag = dependencyTag{name: "data lib"}
Colin Crossc8caa062021-09-24 16:50:14 -0700798 dataBinDepTag = dependencyTag{name: "data bin"}
Colin Crosse9fe2942020-11-10 18:12:15 -0800799 runtimeDepTag = installDependencyTag{name: "runtime lib"}
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"}
Hsin-Yi Chen715142a2024-03-27 16:31:16 +0800804 llndkHeaderLibTag = dependencyTag{name: "llndk_header_lib"}
Colin Crossc99deeb2016-04-11 15:06:20 -0700805)
806
Roland Levillainf89cd092019-07-29 16:22:59 +0100807func IsSharedDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700808 ccLibDepTag, ok := depTag.(libraryDependencyTag)
809 return ok && ccLibDepTag.shared()
810}
811
812func IsStaticDepTag(depTag blueprint.DependencyTag) bool {
813 ccLibDepTag, ok := depTag.(libraryDependencyTag)
814 return ok && ccLibDepTag.static()
Roland Levillainf89cd092019-07-29 16:22:59 +0100815}
816
Zach Johnson3df4e632020-11-06 11:56:27 -0800817func IsHeaderDepTag(depTag blueprint.DependencyTag) bool {
818 ccLibDepTag, ok := depTag.(libraryDependencyTag)
819 return ok && ccLibDepTag.header()
820}
821
Roland Levillainf89cd092019-07-29 16:22:59 +0100822func IsRuntimeDepTag(depTag blueprint.DependencyTag) bool {
Colin Crosse9fe2942020-11-10 18:12:15 -0800823 return depTag == runtimeDepTag
Roland Levillainf89cd092019-07-29 16:22:59 +0100824}
825
Colin Crossca860ac2016-01-04 14:34:37 -0800826// Module contains the properties and members used by all C/C++ module types, and implements
827// the blueprint.Module interface. It delegates to compiler, linker, and installer interfaces
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500828// to construct the output file. Behavior can be customized with a Customizer, or "decorator",
829// interface.
830//
831// To define a C/C++ related module, construct a new Module object and point its delegates to
832// type-specific structs. These delegates will be invoked to register module-specific build
833// statements which may be unique to the module type. For example, module.compiler.compile() should
834// be defined so as to register build statements which are responsible for compiling the module.
835//
836// Another example: to construct a cc_binary module, one can create a `cc.binaryDecorator` struct
837// which implements the `linker` and `installer` interfaces, and points the `linker` and `installer`
838// members of the cc.Module to this decorator. Thus, a cc_binary module has custom linker and
839// installer logic.
Colin Crossca860ac2016-01-04 14:34:37 -0800840type Module struct {
hamzehc0a671f2021-07-22 12:05:08 -0700841 fuzz.FuzzModule
hamzeh41ad8812021-07-07 14:00:07 -0700842
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700843 VendorProperties VendorProperties
hamzeh41ad8812021-07-07 14:00:07 -0700844 Properties BaseProperties
Ronald Braunsteina115e262024-04-09 18:07:38 -0700845 sourceProperties android.SourceProperties
Colin Crossfa138792015-04-24 17:31:52 -0700846
Colin Crossca860ac2016-01-04 14:34:37 -0800847 // initialize before calling Init
Aditya Choudhary87b2ab22023-11-17 15:27:06 +0000848 hod android.HostOrDeviceSupported
849 multilib android.Multilib
Aditya Choudhary87b2ab22023-11-17 15:27:06 +0000850 testModule bool
Colin Crossc472d572015-03-17 15:06:21 -0700851
Paul Duffina0843f62019-12-13 19:50:38 +0000852 // Allowable SdkMemberTypes of this module type.
853 sdkMemberTypes []android.SdkMemberType
854
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500855 // decorator delegates, initialize before calling Init
856 // these may contain module-specific implementations, and effectively allow for custom
857 // type-specific logic. These members may reference different objects or the same object.
858 // Functions of these decorators will be invoked to initialize and register type-specific
859 // build statements.
Colin Cross8ff10582023-12-07 13:10:56 -0800860 generators []Generator
861 compiler compiler
862 linker linker
863 installer installer
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500864
Spandan Dase12d2522023-09-12 21:42:31 +0000865 features []feature
866 stl *stl
867 sanitize *sanitize
868 coverage *coverage
869 fuzzer *fuzzer
870 sabi *sabi
Spandan Dase12d2522023-09-12 21:42:31 +0000871 lto *lto
872 afdo *afdo
Sharjeel Khanc6a93d82023-07-18 21:01:11 +0000873 orderfile *orderfile
Colin Cross16b23492016-01-06 14:41:07 -0800874
Colin Cross31076b32020-10-23 17:22:06 -0700875 library libraryInterface
876
Colin Cross635c3b02016-05-18 15:37:25 -0700877 outputFile android.OptionalPath
Colin Crossca860ac2016-01-04 14:34:37 -0800878
Colin Crossb98c8b02016-07-29 13:44:28 -0700879 cachedToolchain config.Toolchain
Colin Crossb916a382016-07-29 17:28:03 -0700880
Yu Liue70976d2024-10-15 20:45:35 +0000881 subAndroidMkOnce map[subAndroidMkProviderInfoProducer]bool
Fabien Sanglardd61f1f42017-01-10 16:21:22 -0800882
883 // Flags used to compile this module
884 flags Flags
Jeff Gaston294356f2017-09-27 17:05:30 -0700885
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800886 // Shared flags among build rules of this module
887 sharedFlags SharedFlags
888
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800889 // only non-nil when this is a shared library that reuses the objects of a static library
Colin Cross0de8a1e2020-09-18 14:15:30 -0700890 staticAnalogue *StaticLibraryInfo
Inseob Kim9516ee92019-05-09 10:56:13 +0900891
892 makeLinkType string
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800893 // Kythe (source file indexer) paths for this compilation module
894 kytheFiles android.Paths
Chih-Hung Hsieh80783772021-10-11 16:46:56 -0700895 // Object .o file output paths for this compilation module
896 objFiles android.Paths
897 // Tidy .tidy file output paths for this compilation module
898 tidyFiles android.Paths
Jooyung Han75568392020-03-20 04:29:24 +0900899
900 // For apex variants, this is set as apex.min_sdk_version
Dan Albertc8060532020-07-22 22:32:17 -0700901 apexSdkVersion android.ApiLevel
Colin Cross56a83212020-09-15 18:30:11 -0700902
903 hideApexVariantFromMake bool
Yu Liueae7b362023-11-16 17:05:47 -0800904
Inseob Kim37e0bb02024-04-29 15:54:44 +0900905 logtagsPaths android.Paths
Ivan Lozanofd47b1a2024-05-17 14:13:41 -0400906
907 WholeRustStaticlib bool
Cole Faust96a692b2024-08-08 14:47:51 -0700908
909 hasAidl bool
910 hasLex bool
911 hasProto bool
912 hasRenderscript bool
913 hasSysprop bool
914 hasWinMsg bool
915 hasYacc bool
Colin Crossc472d572015-03-17 15:06:21 -0700916}
917
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200918func (c *Module) AddJSONData(d *map[string]interface{}) {
919 c.AndroidModuleBase().AddJSONData(d)
920 (*d)["Cc"] = map[string]interface{}{
921 "SdkVersion": c.SdkVersion(),
922 "MinSdkVersion": c.MinSdkVersion(),
923 "VndkVersion": c.VndkVersion(),
924 "ProductSpecific": c.ProductSpecific(),
925 "SocSpecific": c.SocSpecific(),
926 "DeviceSpecific": c.DeviceSpecific(),
927 "InProduct": c.InProduct(),
928 "InVendor": c.InVendor(),
929 "InRamdisk": c.InRamdisk(),
930 "InVendorRamdisk": c.InVendorRamdisk(),
931 "InRecovery": c.InRecovery(),
932 "VendorAvailable": c.VendorAvailable(),
933 "ProductAvailable": c.ProductAvailable(),
934 "RamdiskAvailable": c.RamdiskAvailable(),
935 "VendorRamdiskAvailable": c.VendorRamdiskAvailable(),
936 "RecoveryAvailable": c.RecoveryAvailable(),
937 "OdmAvailable": c.OdmAvailable(),
938 "InstallInData": c.InstallInData(),
939 "InstallInRamdisk": c.InstallInRamdisk(),
940 "InstallInSanitizerDir": c.InstallInSanitizerDir(),
941 "InstallInVendorRamdisk": c.InstallInVendorRamdisk(),
942 "InstallInRecovery": c.InstallInRecovery(),
943 "InstallInRoot": c.InstallInRoot(),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200944 "IsLlndk": c.IsLlndk(),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200945 "IsVendorPublicLibrary": c.IsVendorPublicLibrary(),
946 "ApexSdkVersion": c.apexSdkVersion,
947 "TestFor": c.TestFor(),
Cole Faust96a692b2024-08-08 14:47:51 -0700948 "AidlSrcs": c.hasAidl,
949 "LexSrcs": c.hasLex,
950 "ProtoSrcs": c.hasProto,
951 "RenderscriptSrcs": c.hasRenderscript,
952 "SyspropSrcs": c.hasSysprop,
953 "WinMsgSrcs": c.hasWinMsg,
954 "YaccSrsc": c.hasYacc,
955 "OnlyCSrcs": !(c.hasAidl || c.hasLex || c.hasProto || c.hasRenderscript || c.hasSysprop || c.hasWinMsg || c.hasYacc),
Yi Kong5786f5c2024-05-28 02:22:34 +0900956 "OptimizeForSize": c.OptimizeForSize(),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200957 }
958}
959
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500960func (c *Module) SetPreventInstall() {
961 c.Properties.PreventInstall = true
962}
963
964func (c *Module) SetHideFromMake() {
965 c.Properties.HideFromMake = true
966}
967
Ivan Lozanod7586b62021-04-01 09:49:36 -0400968func (c *Module) HiddenFromMake() bool {
969 return c.Properties.HideFromMake
970}
971
Cole Fauste8a87832024-09-11 11:35:46 -0700972func (c *Module) RequiredModuleNames(ctx android.ConfigurableEvaluatorContext) []string {
Cole Faust43ddd082024-06-17 12:32:40 -0700973 required := android.CopyOf(c.ModuleBase.RequiredModuleNames(ctx))
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800974 if c.ImageVariation().Variation == android.CoreVariation {
975 required = append(required, c.Properties.Target.Platform.Required...)
976 required = removeListFromList(required, c.Properties.Target.Platform.Exclude_required)
977 } else if c.InRecovery() {
978 required = append(required, c.Properties.Target.Recovery.Required...)
979 required = removeListFromList(required, c.Properties.Target.Recovery.Exclude_required)
980 }
981 return android.FirstUniqueStrings(required)
982}
983
Ivan Lozano52767be2019-10-18 14:49:46 -0700984func (c *Module) Toc() android.OptionalPath {
985 if c.linker != nil {
986 if library, ok := c.linker.(libraryInterface); ok {
987 return library.toc()
988 }
989 }
990 panic(fmt.Errorf("Toc() called on non-library module: %q", c.BaseModuleName()))
991}
992
993func (c *Module) ApiLevel() string {
994 if c.linker != nil {
995 if stub, ok := c.linker.(*stubDecorator); ok {
Dan Albert1a246272020-07-06 14:49:35 -0700996 return stub.apiLevel.String()
Ivan Lozano52767be2019-10-18 14:49:46 -0700997 }
998 }
999 panic(fmt.Errorf("ApiLevel() called on non-stub library module: %q", c.BaseModuleName()))
1000}
1001
1002func (c *Module) Static() bool {
1003 if c.linker != nil {
1004 if library, ok := c.linker.(libraryInterface); ok {
1005 return library.static()
1006 }
1007 }
1008 panic(fmt.Errorf("Static() called on non-library module: %q", c.BaseModuleName()))
1009}
1010
1011func (c *Module) Shared() bool {
1012 if c.linker != nil {
1013 if library, ok := c.linker.(libraryInterface); ok {
1014 return library.shared()
1015 }
1016 }
Lukacs T. Berki6c716762022-06-13 20:50:39 +02001017
Ivan Lozano52767be2019-10-18 14:49:46 -07001018 panic(fmt.Errorf("Shared() called on non-library module: %q", c.BaseModuleName()))
1019}
1020
1021func (c *Module) SelectedStl() string {
Colin Crossc511bc52020-04-07 16:50:32 +00001022 if c.stl != nil {
1023 return c.stl.Properties.SelectedStl
1024 }
1025 return ""
Ivan Lozano52767be2019-10-18 14:49:46 -07001026}
1027
Ivan Lozano52767be2019-10-18 14:49:46 -07001028func (c *Module) StubDecorator() bool {
1029 if _, ok := c.linker.(*stubDecorator); ok {
1030 return true
1031 }
1032 return false
1033}
1034
Yi Kong5786f5c2024-05-28 02:22:34 +09001035func (c *Module) OptimizeForSize() bool {
1036 return Bool(c.Properties.Optimize_for_size)
1037}
1038
Ivan Lozano52767be2019-10-18 14:49:46 -07001039func (c *Module) SdkVersion() string {
1040 return String(c.Properties.Sdk_version)
1041}
1042
Artur Satayev480e25b2020-04-27 18:53:18 +01001043func (c *Module) MinSdkVersion() string {
1044 return String(c.Properties.Min_sdk_version)
1045}
1046
Jiyong Park5df7bd32021-08-25 16:18:46 +09001047func (c *Module) isCrt() bool {
Dan Albert92fe7402020-07-15 13:33:30 -07001048 if linker, ok := c.linker.(*objectLinker); ok {
1049 return linker.isCrt()
1050 }
1051 return false
1052}
1053
Jiyong Park5df7bd32021-08-25 16:18:46 +09001054func (c *Module) SplitPerApiLevel() bool {
1055 return c.canUseSdk() && c.isCrt()
1056}
1057
Colin Crossc511bc52020-04-07 16:50:32 +00001058func (c *Module) AlwaysSdk() bool {
1059 return c.Properties.AlwaysSdk || Bool(c.Properties.Sdk_variant_only)
1060}
1061
Ivan Lozano183a3212019-10-18 14:18:45 -07001062func (c *Module) CcLibrary() bool {
1063 if c.linker != nil {
1064 if _, ok := c.linker.(*libraryDecorator); ok {
1065 return true
1066 }
Colin Crossd48fe732020-09-23 20:37:24 -07001067 if _, ok := c.linker.(*prebuiltLibraryLinker); ok {
1068 return true
1069 }
Ivan Lozano183a3212019-10-18 14:18:45 -07001070 }
1071 return false
1072}
1073
1074func (c *Module) CcLibraryInterface() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001075 if _, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001076 return true
1077 }
1078 return false
1079}
1080
Ivan Lozanoadd122a2023-07-13 11:01:41 -04001081func (c *Module) RlibStd() bool {
1082 panic(fmt.Errorf("RlibStd called on non-Rust module: %q", c.BaseModuleName()))
1083}
1084
Ivan Lozano61c02cc2023-06-09 14:06:44 -04001085func (c *Module) RustLibraryInterface() bool {
1086 return false
1087}
1088
Ivan Lozano0a468a42024-05-13 21:03:34 -04001089func (c *Module) CrateName() string {
1090 panic(fmt.Errorf("CrateName called on non-Rust module: %q", c.BaseModuleName()))
1091}
1092
1093func (c *Module) ExportedCrateLinkDirs() []string {
1094 panic(fmt.Errorf("ExportedCrateLinkDirs called on non-Rust module: %q", c.BaseModuleName()))
1095}
1096
Ivan Lozano0f9963e2023-02-06 13:31:02 -05001097func (c *Module) IsFuzzModule() bool {
1098 if _, ok := c.compiler.(*fuzzBinary); ok {
1099 return true
1100 }
1101 return false
1102}
1103
1104func (c *Module) FuzzModuleStruct() fuzz.FuzzModule {
1105 return c.FuzzModule
1106}
1107
1108func (c *Module) FuzzPackagedModule() fuzz.FuzzPackagedModule {
1109 if fuzzer, ok := c.compiler.(*fuzzBinary); ok {
1110 return fuzzer.fuzzPackagedModule
1111 }
1112 panic(fmt.Errorf("FuzzPackagedModule called on non-fuzz module: %q", c.BaseModuleName()))
1113}
1114
Hamzeh Zawawy38917492023-04-05 22:08:46 +00001115func (c *Module) FuzzSharedLibraries() android.RuleBuilderInstalls {
Ivan Lozano0f9963e2023-02-06 13:31:02 -05001116 if fuzzer, ok := c.compiler.(*fuzzBinary); ok {
1117 return fuzzer.sharedLibraries
1118 }
1119 panic(fmt.Errorf("FuzzSharedLibraries called on non-fuzz module: %q", c.BaseModuleName()))
1120}
1121
Ivan Lozano2b262972019-11-21 12:30:50 -08001122func (c *Module) NonCcVariants() bool {
1123 return false
1124}
1125
Ivan Lozano183a3212019-10-18 14:18:45 -07001126func (c *Module) SetStatic() {
1127 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001128 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001129 library.setStatic()
1130 return
1131 }
1132 }
1133 panic(fmt.Errorf("SetStatic called on non-library module: %q", c.BaseModuleName()))
1134}
1135
1136func (c *Module) SetShared() {
1137 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001138 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001139 library.setShared()
1140 return
1141 }
1142 }
1143 panic(fmt.Errorf("SetShared called on non-library module: %q", c.BaseModuleName()))
1144}
1145
1146func (c *Module) BuildStaticVariant() bool {
1147 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001148 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001149 return library.buildStatic()
1150 }
1151 }
1152 panic(fmt.Errorf("BuildStaticVariant called on non-library module: %q", c.BaseModuleName()))
1153}
1154
1155func (c *Module) BuildSharedVariant() bool {
1156 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001157 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001158 return library.buildShared()
1159 }
1160 }
1161 panic(fmt.Errorf("BuildSharedVariant called on non-library module: %q", c.BaseModuleName()))
1162}
1163
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04001164func (c *Module) BuildRlibVariant() bool {
1165 // cc modules can never build rlib variants
1166 return false
1167}
1168
1169func (c *Module) IsRustFFI() bool {
1170 // cc modules are not Rust modules
1171 return false
1172}
1173
Ivan Lozano183a3212019-10-18 14:18:45 -07001174func (c *Module) Module() android.Module {
1175 return c
1176}
1177
Jiyong Parkc20eee32018-09-05 22:36:17 +09001178func (c *Module) OutputFile() android.OptionalPath {
1179 return c.outputFile
1180}
1181
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001182func (c *Module) CoverageFiles() android.Paths {
1183 if c.linker != nil {
1184 if library, ok := c.linker.(libraryInterface); ok {
1185 return library.objs().coverageFiles
1186 }
1187 }
1188 panic(fmt.Errorf("CoverageFiles called on non-library module: %q", c.BaseModuleName()))
1189}
1190
Ivan Lozano183a3212019-10-18 14:18:45 -07001191var _ LinkableInterface = (*Module)(nil)
1192
Jiyong Park719b4462019-01-13 00:39:51 +09001193func (c *Module) UnstrippedOutputFile() android.Path {
Jiyong Parkaf6d8952019-01-31 12:21:23 +09001194 if c.linker != nil {
1195 return c.linker.unstrippedOutputFilePath()
Jiyong Park719b4462019-01-13 00:39:51 +09001196 }
1197 return nil
1198}
1199
Jiyong Parkee9a98d2019-08-09 14:44:36 +09001200func (c *Module) CoverageOutputFile() android.OptionalPath {
1201 if c.linker != nil {
1202 return c.linker.coverageOutputFilePath()
1203 }
1204 return android.OptionalPath{}
1205}
1206
Jiyong Parkb7c24df2019-02-01 12:03:59 +09001207func (c *Module) RelativeInstallPath() string {
1208 if c.installer != nil {
1209 return c.installer.relativeInstallPath()
1210 }
1211 return ""
1212}
1213
Jooyung Han344d5432019-08-23 11:17:39 +09001214func (c *Module) VndkVersion() string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001215 return c.Properties.VndkVersion
Jooyung Han344d5432019-08-23 11:17:39 +09001216}
1217
Colin Cross36242852017-06-23 15:06:31 -07001218func (c *Module) Init() android.Module {
Dan Willemsenf923f2b2018-05-09 13:45:03 -07001219 c.AddProperties(&c.Properties, &c.VendorProperties)
Joe Onorato37f900c2023-07-18 16:58:16 -07001220 for _, generator := range c.generators {
1221 c.AddProperties(generator.GeneratorProps()...)
1222 }
Colin Crossca860ac2016-01-04 14:34:37 -08001223 if c.compiler != nil {
Colin Cross36242852017-06-23 15:06:31 -07001224 c.AddProperties(c.compiler.compilerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001225 }
1226 if c.linker != nil {
Colin Cross36242852017-06-23 15:06:31 -07001227 c.AddProperties(c.linker.linkerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001228 }
1229 if c.installer != nil {
Colin Cross36242852017-06-23 15:06:31 -07001230 c.AddProperties(c.installer.installerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001231 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001232 if c.stl != nil {
Colin Cross36242852017-06-23 15:06:31 -07001233 c.AddProperties(c.stl.props()...)
Colin Crossa8e07cc2016-04-04 15:07:06 -07001234 }
Colin Cross16b23492016-01-06 14:41:07 -08001235 if c.sanitize != nil {
Colin Cross36242852017-06-23 15:06:31 -07001236 c.AddProperties(c.sanitize.props()...)
Colin Cross16b23492016-01-06 14:41:07 -08001237 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001238 if c.coverage != nil {
Colin Cross36242852017-06-23 15:06:31 -07001239 c.AddProperties(c.coverage.props()...)
Dan Willemsen581341d2017-02-09 16:16:31 -08001240 }
Cory Barkera1da26f2022-06-07 20:12:06 +00001241 if c.fuzzer != nil {
1242 c.AddProperties(c.fuzzer.props()...)
1243 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001244 if c.sabi != nil {
Colin Cross36242852017-06-23 15:06:31 -07001245 c.AddProperties(c.sabi.props()...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001246 }
Stephen Craneba090d12017-05-09 15:44:35 -07001247 if c.lto != nil {
1248 c.AddProperties(c.lto.props()...)
1249 }
Yi Kongeb8efc92021-12-09 18:06:29 +08001250 if c.afdo != nil {
1251 c.AddProperties(c.afdo.props()...)
1252 }
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001253 if c.orderfile != nil {
1254 c.AddProperties(c.orderfile.props()...)
1255 }
Colin Crossca860ac2016-01-04 14:34:37 -08001256 for _, feature := range c.features {
Colin Cross36242852017-06-23 15:06:31 -07001257 c.AddProperties(feature.props()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001258 }
Ronald Braunsteina115e262024-04-09 18:07:38 -07001259 // Allow test-only on libraries that are not cc_test_library
1260 if c.library != nil && !c.testLibrary() {
1261 c.AddProperties(&c.sourceProperties)
1262 }
Colin Crossc472d572015-03-17 15:06:21 -07001263
Colin Cross36242852017-06-23 15:06:31 -07001264 android.InitAndroidArchModule(c, c.hod, c.multilib)
Jiyong Park7916bfc2019-09-30 19:13:12 +09001265 android.InitApexModule(c)
Jooyung Han18020ea2019-11-13 10:50:48 +09001266 android.InitDefaultableModule(c)
Jiyong Park9d452992018-10-03 00:38:19 +09001267
Colin Cross36242852017-06-23 15:06:31 -07001268 return c
Colin Crossc472d572015-03-17 15:06:21 -07001269}
1270
Yi-Yo Chiang1080f0c2022-11-22 18:24:14 +08001271// UseVndk() returns true if this module is built against VNDK.
1272// This means the vendor and product variants of a module.
Ivan Lozano52767be2019-10-18 14:49:46 -07001273func (c *Module) UseVndk() bool {
Inseob Kim64c43952019-08-26 16:52:35 +09001274 return c.Properties.VndkVersion != ""
Dan Willemsen4416e5d2017-04-06 12:43:22 -07001275}
1276
Colin Crossc511bc52020-04-07 16:50:32 +00001277func (c *Module) canUseSdk() bool {
Colin Cross94e347e2021-01-19 14:56:07 -08001278 return c.Os() == android.Android && c.Target().NativeBridge == android.NativeBridgeDisabled &&
Kiyoung Kimaa394802024-01-08 12:55:45 +09001279 !c.InVendorOrProduct() && !c.InRamdisk() && !c.InRecovery() && !c.InVendorRamdisk()
Colin Crossc511bc52020-04-07 16:50:32 +00001280}
1281
1282func (c *Module) UseSdk() bool {
1283 if c.canUseSdk() {
Colin Cross1348ce32020-10-01 13:37:16 -07001284 return String(c.Properties.Sdk_version) != ""
Colin Crossc511bc52020-04-07 16:50:32 +00001285 }
1286 return false
1287}
1288
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001289func (c *Module) isCoverageVariant() bool {
1290 return c.coverage.Properties.IsCoverageVariant
1291}
1292
Colin Cross95f1ca02020-10-29 20:47:22 -07001293func (c *Module) IsNdk(config android.Config) bool {
1294 return inList(c.BaseModuleName(), *getNDKKnownLibs(config))
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001295}
1296
Colin Cross127bb8b2020-12-16 16:46:01 -08001297func (c *Module) IsLlndk() bool {
1298 return c.VendorProperties.IsLLNDK
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001299}
1300
Colin Cross1f3f1302021-04-26 18:37:44 -07001301func (m *Module) NeedsLlndkVariants() bool {
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001302 lib := moduleLibraryInterface(m)
Colin Cross1f3f1302021-04-26 18:37:44 -07001303 return lib != nil && (lib.hasLLNDKStubs() || lib.hasLLNDKHeaders())
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001304}
1305
Colin Cross5271fea2021-04-27 13:06:04 -07001306func (m *Module) NeedsVendorPublicLibraryVariants() bool {
1307 lib := moduleLibraryInterface(m)
1308 return lib != nil && (lib.hasVendorPublicLibrary())
1309}
1310
1311// IsVendorPublicLibrary returns true for vendor public libraries.
1312func (c *Module) IsVendorPublicLibrary() bool {
1313 return c.VendorProperties.IsVendorPublicLibrary
1314}
1315
Ivan Lozanof1868af2022-04-12 13:08:36 -04001316func (c *Module) IsVndkPrebuiltLibrary() bool {
1317 if _, ok := c.linker.(*vndkPrebuiltLibraryDecorator); ok {
1318 return true
1319 }
1320 return false
1321}
1322
1323func (c *Module) SdkAndPlatformVariantVisibleToMake() bool {
1324 return c.Properties.SdkAndPlatformVariantVisibleToMake
1325}
1326
Ivan Lozanod7586b62021-04-01 09:49:36 -04001327func (c *Module) HasLlndkStubs() bool {
1328 lib := moduleLibraryInterface(c)
1329 return lib != nil && lib.hasLLNDKStubs()
1330}
1331
1332func (c *Module) StubsVersion() string {
1333 if lib, ok := c.linker.(versionedInterface); ok {
1334 return lib.stubsVersion()
1335 }
1336 panic(fmt.Errorf("StubsVersion called on non-versioned module: %q", c.BaseModuleName()))
1337}
1338
Colin Cross127bb8b2020-12-16 16:46:01 -08001339// isImplementationForLLNDKPublic returns true for any variant of a cc_library that has LLNDK stubs
1340// and does not set llndk.vendor_available: false.
1341func (c *Module) isImplementationForLLNDKPublic() bool {
1342 library, _ := c.library.(*libraryDecorator)
1343 return library != nil && library.hasLLNDKStubs() &&
Colin Cross0fb7fcd2021-03-02 11:00:07 -08001344 !Bool(library.Properties.Llndk.Private)
Colin Cross127bb8b2020-12-16 16:46:01 -08001345}
1346
Colin Cross3513fb12024-01-24 14:44:47 -08001347func (c *Module) isAfdoCompile(ctx ModuleContext) bool {
Yi Kong4ef54592022-02-14 20:00:10 +08001348 if afdo := c.afdo; afdo != nil {
Colin Cross3513fb12024-01-24 14:44:47 -08001349 return afdo.isAfdoCompile(ctx)
Yi Kong4ef54592022-02-14 20:00:10 +08001350 }
1351 return false
1352}
1353
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001354func (c *Module) isOrderfileCompile() bool {
1355 if orderfile := c.orderfile; orderfile != nil {
1356 return orderfile.Properties.OrderfileLoad
1357 }
1358 return false
1359}
1360
Yi Kongc702ebd2022-08-19 16:02:45 +08001361func (c *Module) isCfi() bool {
Colin Cross694fced2024-06-25 14:56:42 -07001362 return c.sanitize.isSanitizerEnabled(cfi)
Yi Kongc702ebd2022-08-19 16:02:45 +08001363}
1364
Yi Konged79fa32023-06-04 17:15:42 +09001365func (c *Module) isFuzzer() bool {
Colin Cross694fced2024-06-25 14:56:42 -07001366 return c.sanitize.isSanitizerEnabled(Fuzzer)
Yi Konged79fa32023-06-04 17:15:42 +09001367}
1368
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001369func (c *Module) isNDKStubLibrary() bool {
1370 if _, ok := c.compiler.(*stubDecorator); ok {
1371 return true
1372 }
1373 return false
1374}
1375
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001376func (c *Module) SubName() string {
1377 return c.Properties.SubName
1378}
1379
Jiyong Park25fc6a92018-11-18 18:02:45 +09001380func (c *Module) IsStubs() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001381 if lib := c.library; lib != nil {
1382 return lib.buildStubs()
Jiyong Park25fc6a92018-11-18 18:02:45 +09001383 }
1384 return false
1385}
1386
1387func (c *Module) HasStubsVariants() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001388 if lib := c.library; lib != nil {
1389 return lib.hasStubsVariants()
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001390 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09001391 return false
1392}
1393
Alan Stokes73feba32022-11-14 12:21:24 +00001394func (c *Module) IsStubsImplementationRequired() bool {
1395 if lib := c.library; lib != nil {
1396 return lib.isStubsImplementationRequired()
1397 }
1398 return false
1399}
1400
Colin Cross0477b422020-10-13 18:43:54 -07001401// If this is a stubs library, ImplementationModuleName returns the name of the module that contains
1402// the implementation. If it is an implementation library it returns its own name.
1403func (c *Module) ImplementationModuleName(ctx android.BaseModuleContext) string {
1404 name := ctx.OtherModuleName(c)
1405 if versioned, ok := c.linker.(versionedInterface); ok {
1406 name = versioned.implementationModuleName(name)
1407 }
1408 return name
1409}
1410
Martin Stjernholm2856c662020-12-02 15:03:42 +00001411// Similar to ImplementationModuleName, but uses the Make variant of the module
1412// name as base name, for use in AndroidMk output. E.g. for a prebuilt module
1413// where the Soong name is prebuilt_foo, this returns foo (which works in Make
1414// under the premise that the prebuilt module overrides its source counterpart
1415// if it is exposed to Make).
1416func (c *Module) ImplementationModuleNameForMake(ctx android.BaseModuleContext) string {
1417 name := c.BaseModuleName()
1418 if versioned, ok := c.linker.(versionedInterface); ok {
1419 name = versioned.implementationModuleName(name)
1420 }
1421 return name
1422}
1423
Jiyong Park7d55b612021-06-11 17:22:09 +09001424func (c *Module) Bootstrap() bool {
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001425 return Bool(c.Properties.Bootstrap)
1426}
1427
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001428func (c *Module) nativeCoverage() bool {
Pirama Arumuga Nainar5f69b9a2019-09-12 13:18:48 -07001429 // Bug: http://b/137883967 - native-bridge modules do not currently work with coverage
1430 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1431 return false
1432 }
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001433 return c.linker != nil && c.linker.nativeCoverage()
1434}
1435
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001436func (c *Module) IsSnapshotPrebuilt() bool {
Ivan Lozanod1dec542021-05-26 15:33:11 -04001437 if p, ok := c.linker.(SnapshotInterface); ok {
1438 return p.IsSnapshotPrebuilt()
Inseob Kimeec88e12020-01-22 11:11:29 +09001439 }
1440 return false
Inseob Kim8471cda2019-11-15 09:59:12 +09001441}
1442
Jiyong Parkf1194352019-02-25 11:05:47 +09001443func isBionic(name string) bool {
1444 switch name {
Jooyung Hanbff73352022-12-13 18:29:44 +09001445 case "libc", "libm", "libdl", "libdl_android", "linker":
Jiyong Parkf1194352019-02-25 11:05:47 +09001446 return true
1447 }
1448 return false
1449}
1450
Martin Stjernholm279de572019-09-10 23:18:20 +01001451func InstallToBootstrap(name string, config android.Config) bool {
Florian Mayer95cd6db2023-03-23 17:48:07 -07001452 if name == "libclang_rt.hwasan" || name == "libc_hwasan" {
Jooyung Han8ce8db92020-05-15 19:05:05 +09001453 return true
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001454 }
1455 return isBionic(name)
1456}
1457
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001458func (c *Module) XrefCcFiles() android.Paths {
1459 return c.kytheFiles
1460}
1461
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001462func (c *Module) isCfiAssemblySupportEnabled() bool {
1463 return c.sanitize != nil &&
1464 Bool(c.sanitize.Properties.Sanitize.Config.Cfi_assembly_support)
1465}
1466
Inseob Kim800d1142021-06-14 12:03:51 +09001467func (c *Module) InstallInRoot() bool {
1468 return c.installer != nil && c.installer.installInRoot()
1469}
1470
Colin Crossca860ac2016-01-04 14:34:37 -08001471type baseModuleContext struct {
Colin Cross0ea8ba82019-06-06 14:33:29 -07001472 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001473 moduleContextImpl
1474}
1475
Colin Cross37047f12016-12-13 17:06:13 -08001476type depsContext struct {
1477 android.BottomUpMutatorContext
1478 moduleContextImpl
1479}
1480
Colin Crossca860ac2016-01-04 14:34:37 -08001481type moduleContext struct {
Colin Cross635c3b02016-05-18 15:37:25 -07001482 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001483 moduleContextImpl
1484}
1485
1486type moduleContextImpl struct {
1487 mod *Module
1488 ctx BaseModuleContext
1489}
1490
Colin Crossb98c8b02016-07-29 13:44:28 -07001491func (ctx *moduleContextImpl) toolchain() config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001492 return ctx.mod.toolchain(ctx.ctx)
1493}
1494
1495func (ctx *moduleContextImpl) static() bool {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00001496 return ctx.mod.static()
Colin Crossca860ac2016-01-04 14:34:37 -08001497}
1498
1499func (ctx *moduleContextImpl) staticBinary() bool {
Jiyong Park379de2f2018-12-19 02:47:14 +09001500 return ctx.mod.staticBinary()
Colin Crossca860ac2016-01-04 14:34:37 -08001501}
1502
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07001503func (ctx *moduleContextImpl) testBinary() bool {
1504 return ctx.mod.testBinary()
1505}
1506
Yi Kong56fc1b62022-09-06 16:24:00 +08001507func (ctx *moduleContextImpl) testLibrary() bool {
1508 return ctx.mod.testLibrary()
1509}
1510
Jiyong Park1d1119f2019-07-29 21:27:18 +09001511func (ctx *moduleContextImpl) header() bool {
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001512 return ctx.mod.Header()
Jiyong Park1d1119f2019-07-29 21:27:18 +09001513}
1514
Inseob Kim7f283f42020-06-01 21:53:49 +09001515func (ctx *moduleContextImpl) binary() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001516 return ctx.mod.Binary()
Inseob Kim7f283f42020-06-01 21:53:49 +09001517}
1518
Inseob Kim1042d292020-06-01 23:23:05 +09001519func (ctx *moduleContextImpl) object() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001520 return ctx.mod.Object()
Inseob Kim1042d292020-06-01 23:23:05 +09001521}
1522
Yi Kong5786f5c2024-05-28 02:22:34 +09001523func (ctx *moduleContextImpl) optimizeForSize() bool {
1524 return ctx.mod.OptimizeForSize()
1525}
1526
Jooyung Hanccce2f22020-03-07 03:45:53 +09001527func (ctx *moduleContextImpl) canUseSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001528 return ctx.mod.canUseSdk()
Jooyung Hanccce2f22020-03-07 03:45:53 +09001529}
1530
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001531func (ctx *moduleContextImpl) useSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001532 return ctx.mod.UseSdk()
Colin Crossca860ac2016-01-04 14:34:37 -08001533}
1534
1535func (ctx *moduleContextImpl) sdkVersion() string {
Dan Willemsena96ff642016-06-07 12:34:45 -07001536 if ctx.ctx.Device() {
Justin Yun732aa6a2018-03-23 17:43:47 +09001537 return String(ctx.mod.Properties.Sdk_version)
Dan Willemsena96ff642016-06-07 12:34:45 -07001538 }
1539 return ""
Colin Crossca860ac2016-01-04 14:34:37 -08001540}
1541
Jiyong Parkb35a8192020-08-10 15:59:36 +09001542func (ctx *moduleContextImpl) minSdkVersion() string {
1543 ver := ctx.mod.MinSdkVersion()
1544 if ver == "apex_inherit" && !ctx.isForPlatform() {
1545 ver = ctx.apexSdkVersion().String()
1546 }
1547 if ver == "apex_inherit" || ver == "" {
1548 ver = ctx.sdkVersion()
1549 }
Yi-Yo Chiang88960aa2024-01-19 15:02:29 +08001550
1551 if ctx.ctx.Device() {
1552 config := ctx.ctx.Config()
Kiyoung Kim8f05c542024-05-22 16:50:34 +09001553 if ctx.inVendor() {
Yi-Yo Chiang88960aa2024-01-19 15:02:29 +08001554 // If building for vendor with final API, then use the latest _stable_ API as "current".
1555 if config.VendorApiLevelFrozen() && (ver == "" || ver == "current") {
1556 ver = config.PlatformSdkVersion().String()
1557 }
1558 }
1559 }
1560
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001561 // For crt objects, the meaning of min_sdk_version is very different from other types of
1562 // module. For them, min_sdk_version defines the oldest version that the build system will
1563 // create versioned variants for. For example, if min_sdk_version is 16, then sdk variant of
1564 // the crt object has local variants of 16, 17, ..., up to the latest version. sdk_version
1565 // and min_sdk_version properties of the variants are set to the corresponding version
Jiyong Park5df7bd32021-08-25 16:18:46 +09001566 // numbers. However, the non-sdk variant (for apex or platform) of the crt object is left
1567 // untouched. min_sdk_version: 16 doesn't actually mean that the non-sdk variant has to
1568 // support such an old version. The version is set to the later version in case when the
1569 // non-sdk variant is for the platform, or the min_sdk_version of the containing APEX if
1570 // it's for an APEX.
1571 if ctx.mod.isCrt() && !ctx.isSdkVariant() {
1572 if ctx.isForPlatform() {
1573 ver = strconv.Itoa(android.FutureApiLevelInt)
1574 } else { // for apex
1575 ver = ctx.apexSdkVersion().String()
1576 if ver == "" { // in case when min_sdk_version was not set by the APEX
1577 ver = ctx.sdkVersion()
1578 }
1579 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001580 }
1581
Jiyong Parkb35a8192020-08-10 15:59:36 +09001582 // Also make sure that minSdkVersion is not greater than sdkVersion, if they are both numbers
1583 sdkVersionInt, err := strconv.Atoi(ctx.sdkVersion())
1584 minSdkVersionInt, err2 := strconv.Atoi(ver)
1585 if err == nil && err2 == nil {
1586 if sdkVersionInt < minSdkVersionInt {
1587 return strconv.Itoa(sdkVersionInt)
1588 }
1589 }
1590 return ver
1591}
1592
1593func (ctx *moduleContextImpl) isSdkVariant() bool {
1594 return ctx.mod.IsSdkVariant()
1595}
1596
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001597func (ctx *moduleContextImpl) useVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001598 return ctx.mod.UseVndk()
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001599}
Justin Yun8effde42017-06-23 19:24:43 +09001600
Kiyoung Kimaa394802024-01-08 12:55:45 +09001601func (ctx *moduleContextImpl) InVendorOrProduct() bool {
1602 return ctx.mod.InVendorOrProduct()
1603}
1604
Colin Cross95f1ca02020-10-29 20:47:22 -07001605func (ctx *moduleContextImpl) isNdk(config android.Config) bool {
1606 return ctx.mod.IsNdk(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001607}
1608
Colin Cross127bb8b2020-12-16 16:46:01 -08001609func (ctx *moduleContextImpl) IsLlndk() bool {
1610 return ctx.mod.IsLlndk()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001611}
1612
Colin Cross127bb8b2020-12-16 16:46:01 -08001613func (ctx *moduleContextImpl) isImplementationForLLNDKPublic() bool {
1614 return ctx.mod.isImplementationForLLNDKPublic()
1615}
1616
Colin Cross3513fb12024-01-24 14:44:47 -08001617func (ctx *moduleContextImpl) isAfdoCompile(mctx ModuleContext) bool {
1618 return ctx.mod.isAfdoCompile(mctx)
Yi Kong4ef54592022-02-14 20:00:10 +08001619}
1620
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001621func (ctx *moduleContextImpl) isOrderfileCompile() bool {
1622 return ctx.mod.isOrderfileCompile()
1623}
1624
Yi Kongc702ebd2022-08-19 16:02:45 +08001625func (ctx *moduleContextImpl) isCfi() bool {
1626 return ctx.mod.isCfi()
1627}
1628
Yi Konged79fa32023-06-04 17:15:42 +09001629func (ctx *moduleContextImpl) isFuzzer() bool {
1630 return ctx.mod.isFuzzer()
1631}
1632
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001633func (ctx *moduleContextImpl) isNDKStubLibrary() bool {
1634 return ctx.mod.isNDKStubLibrary()
1635}
1636
Colin Cross5271fea2021-04-27 13:06:04 -07001637func (ctx *moduleContextImpl) IsVendorPublicLibrary() bool {
1638 return ctx.mod.IsVendorPublicLibrary()
1639}
1640
Dan Willemsen8146b2f2016-03-30 21:00:30 -07001641func (ctx *moduleContextImpl) selectedStl() string {
1642 if stl := ctx.mod.stl; stl != nil {
1643 return stl.Properties.SelectedStl
1644 }
1645 return ""
1646}
1647
Ivan Lozanobd721262018-11-27 14:33:03 -08001648func (ctx *moduleContextImpl) useClangLld(actx ModuleContext) bool {
1649 return ctx.mod.linker.useClangLld(actx)
1650}
1651
Colin Crossce75d2c2016-10-06 16:12:58 -07001652func (ctx *moduleContextImpl) baseModuleName() string {
Spandan Das2b6dfb52024-01-19 00:22:22 +00001653 return ctx.mod.BaseModuleName()
Colin Crossce75d2c2016-10-06 16:12:58 -07001654}
1655
Logan Chiene274fc92019-12-03 11:18:32 -08001656func (ctx *moduleContextImpl) isForPlatform() bool {
Colin Crossff694a82023-12-13 15:54:49 -08001657 apexInfo, _ := android.ModuleProvider(ctx.ctx, android.ApexInfoProvider)
1658 return apexInfo.IsForPlatform()
Logan Chiene274fc92019-12-03 11:18:32 -08001659}
1660
Colin Crosse07f2312020-08-13 11:24:56 -07001661func (ctx *moduleContextImpl) apexVariationName() string {
Colin Crossff694a82023-12-13 15:54:49 -08001662 apexInfo, _ := android.ModuleProvider(ctx.ctx, android.ApexInfoProvider)
1663 return apexInfo.ApexVariationName
Jiyong Park25fc6a92018-11-18 18:02:45 +09001664}
1665
Dan Albertc8060532020-07-22 22:32:17 -07001666func (ctx *moduleContextImpl) apexSdkVersion() android.ApiLevel {
Jooyung Han75568392020-03-20 04:29:24 +09001667 return ctx.mod.apexSdkVersion
Jooyung Hanccce2f22020-03-07 03:45:53 +09001668}
1669
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001670func (ctx *moduleContextImpl) bootstrap() bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09001671 return ctx.mod.Bootstrap()
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001672}
1673
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001674func (ctx *moduleContextImpl) nativeCoverage() bool {
1675 return ctx.mod.nativeCoverage()
1676}
1677
Colin Cross56a83212020-09-15 18:30:11 -07001678func (ctx *moduleContextImpl) directlyInAnyApex() bool {
1679 return ctx.mod.DirectlyInAnyApex()
1680}
1681
Colin Cross95b07f22020-12-16 11:06:50 -08001682func (ctx *moduleContextImpl) isPreventInstall() bool {
1683 return ctx.mod.Properties.PreventInstall
1684}
1685
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -08001686func (ctx *moduleContextImpl) getSharedFlags() *SharedFlags {
1687 shared := &ctx.mod.sharedFlags
1688 if shared.flagsMap == nil {
1689 shared.numSharedFlags = 0
1690 shared.flagsMap = make(map[string]string)
1691 }
1692 return shared
1693}
1694
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001695func (ctx *moduleContextImpl) isCfiAssemblySupportEnabled() bool {
1696 return ctx.mod.isCfiAssemblySupportEnabled()
1697}
1698
Colin Cross4a9e6ec2023-12-18 15:29:41 -08001699func (ctx *moduleContextImpl) notInPlatform() bool {
1700 return ctx.mod.NotInPlatform()
1701}
1702
Colin Cross635c3b02016-05-18 15:37:25 -07001703func newBaseModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001704 return &Module{
1705 hod: hod,
1706 multilib: multilib,
1707 }
1708}
1709
Colin Cross635c3b02016-05-18 15:37:25 -07001710func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001711 module := newBaseModule(hod, multilib)
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001712 module.features = []feature{
1713 &tidyFeature{},
1714 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001715 module.stl = &stl{}
Colin Cross16b23492016-01-06 14:41:07 -08001716 module.sanitize = &sanitize{}
Dan Willemsen581341d2017-02-09 16:16:31 -08001717 module.coverage = &coverage{}
Cory Barkera1da26f2022-06-07 20:12:06 +00001718 module.fuzzer = &fuzzer{}
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001719 module.sabi = &sabi{}
Stephen Craneba090d12017-05-09 15:44:35 -07001720 module.lto = &lto{}
Yi Kongeb8efc92021-12-09 18:06:29 +08001721 module.afdo = &afdo{}
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001722 module.orderfile = &orderfile{}
Colin Crossca860ac2016-01-04 14:34:37 -08001723 return module
1724}
1725
Colin Crossce75d2c2016-10-06 16:12:58 -07001726func (c *Module) Prebuilt() *android.Prebuilt {
1727 if p, ok := c.linker.(prebuiltLinkerInterface); ok {
1728 return p.prebuilt()
1729 }
1730 return nil
1731}
1732
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001733func (c *Module) IsPrebuilt() bool {
1734 return c.Prebuilt() != nil
1735}
1736
Colin Crossce75d2c2016-10-06 16:12:58 -07001737func (c *Module) Name() string {
1738 name := c.ModuleBase.Name()
Dan Willemsen01a90592017-04-07 15:21:13 -07001739 if p, ok := c.linker.(interface {
1740 Name(string) string
1741 }); ok {
Colin Crossce75d2c2016-10-06 16:12:58 -07001742 name = p.Name(name)
1743 }
1744 return name
1745}
1746
Alex Light3d673592019-01-18 14:37:31 -08001747func (c *Module) Symlinks() []string {
1748 if p, ok := c.installer.(interface {
1749 symlinkList() []string
1750 }); ok {
1751 return p.symlinkList()
1752 }
1753 return nil
1754}
1755
Chris Parsons216e10a2020-07-09 17:12:52 -04001756func (c *Module) DataPaths() []android.DataPath {
Liz Kammer1c14a212020-05-12 15:26:55 -07001757 if p, ok := c.installer.(interface {
Chris Parsons216e10a2020-07-09 17:12:52 -04001758 dataPaths() []android.DataPath
Liz Kammer1c14a212020-05-12 15:26:55 -07001759 }); ok {
1760 return p.dataPaths()
1761 }
1762 return nil
1763}
1764
Ivan Lozanof1868af2022-04-12 13:08:36 -04001765func getNameSuffixWithVndkVersion(ctx android.ModuleContext, c LinkableInterface) string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001766 // Returns the name suffix for product and vendor variants. If the VNDK version is not
1767 // "current", it will append the VNDK version to the name suffix.
Justin Yun5f7f7e82019-11-18 19:52:14 +09001768 var nameSuffix string
Ivan Lozanof9e21722020-12-02 09:00:51 -05001769 if c.InProduct() {
Justin Yund00f5ca2021-02-03 19:43:02 +09001770 if c.ProductSpecific() {
1771 // If the module is product specific with 'product_specific: true',
1772 // do not add a name suffix because it is a base module.
1773 return ""
1774 }
Justin Yunaf1fde42023-09-27 16:22:10 +09001775 return ProductSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001776 } else {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05001777 nameSuffix = VendorSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001778 }
Kiyoung Kim4e765b12024-04-04 17:33:42 +09001779 if c.VndkVersion() != "" {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001780 // add version suffix only if the module is using different vndk version than the
1781 // version in product or vendor partition.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001782 nameSuffix += "." + c.VndkVersion()
Justin Yun5f7f7e82019-11-18 19:52:14 +09001783 }
1784 return nameSuffix
1785}
1786
Ivan Lozanof1868af2022-04-12 13:08:36 -04001787func GetSubnameProperty(actx android.ModuleContext, c LinkableInterface) string {
1788 var subName = ""
Inseob Kim64c43952019-08-26 16:52:35 +09001789
1790 if c.Target().NativeBridge == android.NativeBridgeEnabled {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001791 subName += NativeBridgeSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001792 }
1793
Colin Cross127bb8b2020-12-16 16:46:01 -08001794 llndk := c.IsLlndk()
Kiyoung Kimaa394802024-01-08 12:55:45 +09001795 if llndk || (c.InVendorOrProduct() && c.HasNonSystemVariants()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001796 // .vendor.{version} suffix is added for vendor variant or .product.{version} suffix is
1797 // added for product variant only when we have vendor and product variants with core
1798 // variant. The suffix is not added for vendor-only or product-only module.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001799 subName += getNameSuffixWithVndkVersion(actx, c)
Colin Cross5271fea2021-04-27 13:06:04 -07001800 } else if c.IsVendorPublicLibrary() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001801 subName += vendorPublicLibrarySuffix
1802 } else if c.IsVndkPrebuiltLibrary() {
Inseob Kim64c43952019-08-26 16:52:35 +09001803 // .vendor suffix is added for backward compatibility with VNDK snapshot whose names with
1804 // such suffixes are already hard-coded in prebuilts/vndk/.../Android.bp.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001805 subName += VendorSuffix
Yifan Hong1b3348d2020-01-21 15:53:22 -08001806 } else if c.InRamdisk() && !c.OnlyInRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001807 subName += RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001808 } else if c.InVendorRamdisk() && !c.OnlyInVendorRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001809 subName += VendorRamdiskSuffix
Ivan Lozano52767be2019-10-18 14:49:46 -07001810 } else if c.InRecovery() && !c.OnlyInRecovery() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001811 subName += RecoverySuffix
1812 } else if c.IsSdkVariant() && (c.SdkAndPlatformVariantVisibleToMake() || c.SplitPerApiLevel()) {
1813 subName += sdkSuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001814 if c.SplitPerApiLevel() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001815 subName += "." + c.SdkVersion()
Dan Albert92fe7402020-07-15 13:33:30 -07001816 }
Spandan Dasb2b41d52023-04-13 18:15:05 +00001817 } else if c.IsStubs() && c.IsSdkVariant() {
1818 // Public API surface (NDK)
1819 // Add a suffix to this stub variant to distinguish it from the module-lib stub variant.
1820 subName = sdkSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001821 }
Ivan Lozanof1868af2022-04-12 13:08:36 -04001822
1823 return subName
Chris Parsons8d6e4332021-02-22 16:13:50 -05001824}
1825
Sam Delmerico75dbca22023-04-20 13:13:25 +00001826func moduleContextFromAndroidModuleContext(actx android.ModuleContext, c *Module) ModuleContext {
1827 ctx := &moduleContext{
1828 ModuleContext: actx,
1829 moduleContextImpl: moduleContextImpl{
1830 mod: c,
1831 },
1832 }
1833 ctx.ctx = ctx
1834 return ctx
1835}
1836
Spandan Das20fce2d2023-04-12 17:21:39 +00001837// TODO (b/277651159): Remove this allowlist
1838var (
1839 skipStubLibraryMultipleApexViolation = map[string]bool{
1840 "libclang_rt.asan": true,
1841 "libclang_rt.hwasan": true,
1842 // runtime apex
1843 "libc": true,
1844 "libc_hwasan": true,
1845 "libdl_android": true,
1846 "libm": true,
1847 "libdl": true,
Spandan Das1a0c6e12024-01-04 01:44:17 +00001848 "libz": true,
Spandan Das20fce2d2023-04-12 17:21:39 +00001849 // art apex
Martin Stjernholm75598032024-07-12 18:47:26 +01001850 // TODO(b/234351700): Remove this when com.android.art.debug is gone.
Spandan Das20fce2d2023-04-12 17:21:39 +00001851 "libandroidio": true,
1852 "libdexfile": true,
Martin Stjernholm75598032024-07-12 18:47:26 +01001853 "libdexfiled": true, // com.android.art.debug only
Spandan Das20fce2d2023-04-12 17:21:39 +00001854 "libnativebridge": true,
1855 "libnativehelper": true,
1856 "libnativeloader": true,
1857 "libsigchain": true,
1858 }
1859)
1860
1861// Returns true if a stub library could be installed in multiple apexes
1862func (c *Module) stubLibraryMultipleApexViolation(ctx android.ModuleContext) bool {
1863 // If this is not an apex variant, no check necessary
1864 if !c.InAnyApex() {
1865 return false
1866 }
1867 // If this is not a stub library, no check necessary
1868 if !c.HasStubsVariants() {
1869 return false
1870 }
1871 // Skip the allowlist
1872 // Use BaseModuleName so that this matches prebuilts.
1873 if _, exists := skipStubLibraryMultipleApexViolation[c.BaseModuleName()]; exists {
1874 return false
1875 }
1876
1877 _, aaWithoutTestApexes, _ := android.ListSetDifference(c.ApexAvailable(), c.TestApexes())
1878 // Stub libraries should not have more than one apex_available
1879 if len(aaWithoutTestApexes) > 1 {
1880 return true
1881 }
1882 // Stub libraries should not use the wildcard
1883 if aaWithoutTestApexes[0] == android.AvailableToAnyApex {
1884 return true
1885 }
1886 // Default: no violation
1887 return false
1888}
1889
Chris Parsons8d6e4332021-02-22 16:13:50 -05001890func (c *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
Ronald Braunstein6a08d492024-04-15 12:55:30 -07001891 ctx := moduleContextFromAndroidModuleContext(actx, c)
1892
Inseob Kim37e0bb02024-04-29 15:54:44 +09001893 c.logtagsPaths = android.PathsForModuleSrc(actx, c.Properties.Logtags)
1894 android.SetProvider(ctx, android.LogtagsProviderKey, &android.LogtagsInfo{
1895 Logtags: c.logtagsPaths,
1896 })
1897
Ronald Braunstein6a08d492024-04-15 12:55:30 -07001898 // If Test_only is set on a module in bp file, respect the setting, otherwise
1899 // see if is a known test module type.
1900 testOnly := c.testModule || c.testLibrary()
1901 if c.sourceProperties.Test_only != nil {
1902 testOnly = Bool(c.sourceProperties.Test_only)
1903 }
1904 // Keep before any early returns.
1905 android.SetProvider(ctx, android.TestOnlyProviderKey, android.TestModuleInformation{
1906 TestOnly: testOnly,
1907 TopLevelTarget: c.testModule,
1908 })
1909
Ivan Lozanof1868af2022-04-12 13:08:36 -04001910 c.Properties.SubName = GetSubnameProperty(actx, c)
Colin Crossff694a82023-12-13 15:54:49 -08001911 apexInfo, _ := android.ModuleProvider(actx, android.ApexInfoProvider)
Chris Parsons8d6e4332021-02-22 16:13:50 -05001912 if !apexInfo.IsForPlatform() {
1913 c.hideApexVariantFromMake = true
1914 }
1915
Chris Parsonseefc9e62021-04-02 17:36:47 -04001916 c.makeLinkType = GetMakeLinkType(actx, c)
1917
Colin Crossf18e1102017-11-16 14:33:08 -08001918 deps := c.depsToPaths(ctx)
1919 if ctx.Failed() {
1920 return
1921 }
1922
Joe Onorato37f900c2023-07-18 16:58:16 -07001923 for _, generator := range c.generators {
1924 gen := generator.GeneratorSources(ctx)
1925 deps.IncludeDirs = append(deps.IncludeDirs, gen.IncludeDirs...)
1926 deps.ReexportedDirs = append(deps.ReexportedDirs, gen.ReexportedDirs...)
1927 deps.GeneratedDeps = append(deps.GeneratedDeps, gen.Headers...)
1928 deps.ReexportedGeneratedHeaders = append(deps.ReexportedGeneratedHeaders, gen.Headers...)
1929 deps.ReexportedDeps = append(deps.ReexportedDeps, gen.Headers...)
1930 if len(deps.Objs.objFiles) == 0 {
1931 // If we are reusuing object files (which happens when we're a shared library and we're
1932 // reusing our static variant's object files), then skip adding the actual source files,
1933 // because we already have the object for it.
1934 deps.GeneratedSources = append(deps.GeneratedSources, gen.Sources...)
1935 }
1936 }
1937
1938 if ctx.Failed() {
1939 return
1940 }
1941
Spandan Das20fce2d2023-04-12 17:21:39 +00001942 if c.stubLibraryMultipleApexViolation(actx) {
1943 actx.PropertyErrorf("apex_available",
1944 "Stub libraries should have a single apex_available (test apexes excluded). Got %v", c.ApexAvailable())
1945 }
Dan Willemsen8536d6b2018-10-07 20:54:34 -07001946 if c.Properties.Clang != nil && *c.Properties.Clang == false {
1947 ctx.PropertyErrorf("clang", "false (GCC) is no longer supported")
Alixb5f6d9e2022-04-20 23:00:58 +00001948 } else if c.Properties.Clang != nil && !ctx.DeviceConfig().BuildBrokenClangProperty() {
1949 ctx.PropertyErrorf("clang", "property is deprecated, see Changes.md file")
Dan Willemsen8536d6b2018-10-07 20:54:34 -07001950 }
1951
Colin Crossca860ac2016-01-04 14:34:37 -08001952 flags := Flags{
1953 Toolchain: c.toolchain(ctx),
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001954 EmitXrefs: ctx.Config().EmitXrefRules(),
Colin Crossca860ac2016-01-04 14:34:37 -08001955 }
Joe Onorato37f900c2023-07-18 16:58:16 -07001956 for _, generator := range c.generators {
1957 flags = generator.GeneratorFlags(ctx, flags, deps)
1958 }
Colin Crossca860ac2016-01-04 14:34:37 -08001959 if c.compiler != nil {
Colin Crossf18e1102017-11-16 14:33:08 -08001960 flags = c.compiler.compilerFlags(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001961 }
1962 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001963 flags = c.linker.linkerFlags(ctx, flags)
Colin Crossca860ac2016-01-04 14:34:37 -08001964 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001965 if c.stl != nil {
1966 flags = c.stl.flags(ctx, flags)
1967 }
Colin Cross16b23492016-01-06 14:41:07 -08001968 if c.sanitize != nil {
1969 flags = c.sanitize.flags(ctx, flags)
1970 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001971 if c.coverage != nil {
Pirama Arumuga Nainar82fe59b2019-07-02 14:55:35 -07001972 flags, deps = c.coverage.flags(ctx, flags, deps)
Dan Willemsen581341d2017-02-09 16:16:31 -08001973 }
Cory Barkera1da26f2022-06-07 20:12:06 +00001974 if c.fuzzer != nil {
1975 flags = c.fuzzer.flags(ctx, flags)
1976 }
Stephen Craneba090d12017-05-09 15:44:35 -07001977 if c.lto != nil {
1978 flags = c.lto.flags(ctx, flags)
1979 }
Yi Kongeb8efc92021-12-09 18:06:29 +08001980 if c.afdo != nil {
1981 flags = c.afdo.flags(ctx, flags)
1982 }
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001983 if c.orderfile != nil {
1984 flags = c.orderfile.flags(ctx, flags)
1985 }
Colin Crossca860ac2016-01-04 14:34:37 -08001986 for _, feature := range c.features {
1987 flags = feature.flags(ctx, flags)
1988 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001989 if ctx.Failed() {
1990 return
1991 }
1992
Colin Cross4af21ed2019-11-04 09:37:55 -08001993 flags.Local.CFlags, _ = filterList(flags.Local.CFlags, config.IllegalFlags)
1994 flags.Local.CppFlags, _ = filterList(flags.Local.CppFlags, config.IllegalFlags)
1995 flags.Local.ConlyFlags, _ = filterList(flags.Local.ConlyFlags, config.IllegalFlags)
Colin Cross3f40fa42015-01-30 17:27:36 -08001996
Colin Cross4af21ed2019-11-04 09:37:55 -08001997 flags.Local.CommonFlags = append(flags.Local.CommonFlags, deps.Flags...)
Inseob Kim69378442019-06-03 19:10:47 +09001998
1999 for _, dir := range deps.IncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08002000 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-I"+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09002001 }
2002 for _, dir := range deps.SystemIncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08002003 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-isystem "+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09002004 }
2005
Colin Cross3e5e7782022-06-17 22:17:05 +00002006 flags.Local.LdFlags = append(flags.Local.LdFlags, deps.LdFlags...)
2007
Fabien Sanglardd61f1f42017-01-10 16:21:22 -08002008 c.flags = flags
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -07002009 // We need access to all the flags seen by a source file.
2010 if c.sabi != nil {
2011 flags = c.sabi.flags(ctx, flags)
2012 }
Dan Willemsen98ab3112019-08-27 21:20:40 -07002013
Colin Cross4af21ed2019-11-04 09:37:55 -08002014 flags.AssemblerWithCpp = inList("-xassembler-with-cpp", flags.Local.AsFlags)
Dan Willemsen98ab3112019-08-27 21:20:40 -07002015
Joe Onorato37f900c2023-07-18 16:58:16 -07002016 for _, generator := range c.generators {
2017 generator.GeneratorBuildActions(ctx, flags, deps)
2018 }
2019
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002020 var objs Objects
Colin Crossca860ac2016-01-04 14:34:37 -08002021 if c.compiler != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002022 objs = c.compiler.compile(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08002023 if ctx.Failed() {
2024 return
2025 }
Sasha Smundak2a4549e2018-11-05 16:49:08 -08002026 c.kytheFiles = objs.kytheFiles
Chih-Hung Hsieh80783772021-10-11 16:46:56 -07002027 c.objFiles = objs.objFiles
2028 c.tidyFiles = objs.tidyFiles
Colin Cross3f40fa42015-01-30 17:27:36 -08002029 }
2030
Colin Crossca860ac2016-01-04 14:34:37 -08002031 if c.linker != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002032 outputFile := c.linker.link(ctx, flags, deps, objs)
Colin Crossca860ac2016-01-04 14:34:37 -08002033 if ctx.Failed() {
2034 return
2035 }
Colin Cross635c3b02016-05-18 15:37:25 -07002036 c.outputFile = android.OptionalPathForPath(outputFile)
Jiyong Parkb0788572018-12-20 22:10:17 +09002037
Chris Parsons94a0bba2021-06-04 15:03:47 -04002038 c.maybeUnhideFromMake()
Colin Crossce75d2c2016-10-06 16:12:58 -07002039 }
Ronald Braunsteina115e262024-04-09 18:07:38 -07002040
Colin Cross40213022023-12-13 15:19:49 -08002041 android.SetProvider(ctx, blueprint.SrcsFileProviderKey, blueprint.SrcsFileProviderData{SrcPaths: deps.GeneratedSources.Strings()})
Colin Cross5049f022015-03-18 13:28:46 -07002042
Hao Chen1c8ea5b2023-10-20 23:03:45 +00002043 if Bool(c.Properties.Cmake_snapshot_supported) {
2044 android.SetProvider(ctx, cmakeSnapshotSourcesProvider, android.GlobFiles(ctx, ctx.ModuleDir()+"/**/*", nil))
2045 }
2046
Chris Parsons94a0bba2021-06-04 15:03:47 -04002047 c.maybeInstall(ctx, apexInfo)
Colin Cross4a9e6ec2023-12-18 15:29:41 -08002048
2049 if c.linker != nil {
2050 moduleInfoJSON := ctx.ModuleInfoJSON()
2051 c.linker.moduleInfoJSON(ctx, moduleInfoJSON)
2052 moduleInfoJSON.SharedLibs = c.Properties.AndroidMkSharedLibs
2053 moduleInfoJSON.StaticLibs = c.Properties.AndroidMkStaticLibs
2054 moduleInfoJSON.SystemSharedLibs = c.Properties.AndroidMkSystemSharedLibs
2055 moduleInfoJSON.RuntimeDependencies = c.Properties.AndroidMkRuntimeLibs
2056
2057 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkSharedLibs...)
2058 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkStaticLibs...)
2059 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkHeaderLibs...)
2060 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkWholeStaticLibs...)
2061
2062 if c.sanitize != nil && len(moduleInfoJSON.Class) > 0 &&
2063 (moduleInfoJSON.Class[0] == "STATIC_LIBRARIES" || moduleInfoJSON.Class[0] == "HEADER_LIBRARIES") {
2064 if Bool(c.sanitize.Properties.SanitizeMutated.Cfi) {
2065 moduleInfoJSON.SubName += ".cfi"
2066 }
2067 if Bool(c.sanitize.Properties.SanitizeMutated.Hwaddress) {
2068 moduleInfoJSON.SubName += ".hwasan"
2069 }
2070 if Bool(c.sanitize.Properties.SanitizeMutated.Scs) {
2071 moduleInfoJSON.SubName += ".scs"
2072 }
2073 }
2074 moduleInfoJSON.SubName += c.Properties.SubName
2075
2076 if c.Properties.IsSdkVariant && c.Properties.SdkAndPlatformVariantVisibleToMake {
2077 moduleInfoJSON.Uninstallable = true
2078 }
Colin Cross4a9e6ec2023-12-18 15:29:41 -08002079 }
Wei Lia1aa2972024-06-21 13:08:51 -07002080
2081 buildComplianceMetadataInfo(ctx, c, deps)
mrziwangabdb2932024-06-18 12:43:41 -07002082
Cole Faust96a692b2024-08-08 14:47:51 -07002083 if b, ok := c.compiler.(*baseCompiler); ok {
2084 c.hasAidl = b.hasSrcExt(ctx, ".aidl")
2085 c.hasLex = b.hasSrcExt(ctx, ".l") || b.hasSrcExt(ctx, ".ll")
2086 c.hasProto = b.hasSrcExt(ctx, ".proto")
2087 c.hasRenderscript = b.hasSrcExt(ctx, ".rscript") || b.hasSrcExt(ctx, ".fs")
2088 c.hasSysprop = b.hasSrcExt(ctx, ".sysprop")
2089 c.hasWinMsg = b.hasSrcExt(ctx, ".mc")
2090 c.hasYacc = b.hasSrcExt(ctx, ".y") || b.hasSrcExt(ctx, ".yy")
2091 }
2092
mrziwangabdb2932024-06-18 12:43:41 -07002093 c.setOutputFiles(ctx)
2094}
2095
2096func (c *Module) setOutputFiles(ctx ModuleContext) {
2097 if c.outputFile.Valid() {
2098 ctx.SetOutputFiles(android.Paths{c.outputFile.Path()}, "")
2099 } else {
2100 ctx.SetOutputFiles(android.Paths{}, "")
2101 }
2102 if c.linker != nil {
2103 ctx.SetOutputFiles(android.PathsIfNonNil(c.linker.unstrippedOutputFilePath()), "unstripped")
2104 ctx.SetOutputFiles(android.PathsIfNonNil(c.linker.strippedAllOutputFilePath()), "stripped_all")
2105 }
Wei Lia1aa2972024-06-21 13:08:51 -07002106}
2107
2108func buildComplianceMetadataInfo(ctx ModuleContext, c *Module, deps PathDeps) {
2109 // Dump metadata that can not be done in android/compliance-metadata.go
2110 complianceMetadataInfo := ctx.ComplianceMetadataInfo()
2111 complianceMetadataInfo.SetStringValue(android.ComplianceMetadataProp.IS_STATIC_LIB, strconv.FormatBool(ctx.static()))
2112 complianceMetadataInfo.SetStringValue(android.ComplianceMetadataProp.BUILT_FILES, c.outputFile.String())
2113
2114 // Static deps
2115 staticDeps := ctx.GetDirectDepsWithTag(StaticDepTag(false))
2116 staticDepNames := make([]string, 0, len(staticDeps))
2117 for _, dep := range staticDeps {
2118 staticDepNames = append(staticDepNames, dep.Name())
2119 }
2120
2121 staticDepPaths := make([]string, 0, len(deps.StaticLibs))
2122 for _, dep := range deps.StaticLibs {
2123 staticDepPaths = append(staticDepPaths, dep.String())
2124 }
2125 complianceMetadataInfo.SetListValue(android.ComplianceMetadataProp.STATIC_DEPS, android.FirstUniqueStrings(staticDepNames))
2126 complianceMetadataInfo.SetListValue(android.ComplianceMetadataProp.STATIC_DEP_FILES, android.FirstUniqueStrings(staticDepPaths))
2127
2128 // Whole static deps
2129 wholeStaticDeps := ctx.GetDirectDepsWithTag(StaticDepTag(true))
2130 wholeStaticDepNames := make([]string, 0, len(wholeStaticDeps))
2131 for _, dep := range wholeStaticDeps {
2132 wholeStaticDepNames = append(wholeStaticDepNames, dep.Name())
2133 }
2134
2135 wholeStaticDepPaths := make([]string, 0, len(deps.WholeStaticLibs))
2136 for _, dep := range deps.WholeStaticLibs {
2137 wholeStaticDepPaths = append(wholeStaticDepPaths, dep.String())
2138 }
2139 complianceMetadataInfo.SetListValue(android.ComplianceMetadataProp.WHOLE_STATIC_DEPS, android.FirstUniqueStrings(wholeStaticDepNames))
2140 complianceMetadataInfo.SetListValue(android.ComplianceMetadataProp.WHOLE_STATIC_DEP_FILES, android.FirstUniqueStrings(wholeStaticDepPaths))
Chris Parsons94a0bba2021-06-04 15:03:47 -04002141}
2142
2143func (c *Module) maybeUnhideFromMake() {
2144 // If a lib is directly included in any of the APEXes or is not available to the
2145 // platform (which is often the case when the stub is provided as a prebuilt),
2146 // unhide the stubs variant having the latest version gets visible to make. In
2147 // addition, the non-stubs variant is renamed to <libname>.bootstrap. This is to
2148 // force anything in the make world to link against the stubs library. (unless it
2149 // is explicitly referenced via .bootstrap suffix or the module is marked with
2150 // 'bootstrap: true').
2151 if c.HasStubsVariants() && c.NotInPlatform() && !c.InRamdisk() &&
Kiyoung Kimaa394802024-01-08 12:55:45 +09002152 !c.InRecovery() && !c.InVendorOrProduct() && !c.static() && !c.isCoverageVariant() &&
Chris Parsons94a0bba2021-06-04 15:03:47 -04002153 c.IsStubs() && !c.InVendorRamdisk() {
2154 c.Properties.HideFromMake = false // unhide
2155 // Note: this is still non-installable
2156 }
2157}
2158
Colin Cross8ff10582023-12-07 13:10:56 -08002159// maybeInstall is called at the end of both GenerateAndroidBuildActions to run the
2160// install hooks for installable modules, like binaries and tests.
Chris Parsons94a0bba2021-06-04 15:03:47 -04002161func (c *Module) maybeInstall(ctx ModuleContext, apexInfo android.ApexInfo) {
Colin Cross1bc94122021-10-28 13:25:54 -07002162 if !proptools.BoolDefault(c.Installable(), true) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002163 // If the module has been specifically configure to not be installed then
2164 // hide from make as otherwise it will break when running inside make
2165 // as the output path to install will not be specified. Not all uninstallable
2166 // modules can be hidden from make as some are needed for resolving make side
2167 // dependencies.
2168 c.HideFromMake()
Spandan Das034af2c2024-10-30 21:45:09 +00002169 c.SkipInstall()
Ivan Lozanod7586b62021-04-01 09:49:36 -04002170 } else if !installable(c, apexInfo) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002171 c.SkipInstall()
2172 }
2173
2174 // Still call c.installer.install though, the installs will be stored as PackageSpecs
2175 // to allow using the outputs in a genrule.
2176 if c.installer != nil && c.outputFile.Valid() {
Colin Crossce75d2c2016-10-06 16:12:58 -07002177 c.installer.install(ctx, c.outputFile.Path())
2178 if ctx.Failed() {
2179 return
Colin Crossca860ac2016-01-04 14:34:37 -08002180 }
Dan Albertc403f7c2015-03-18 14:01:18 -07002181 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002182}
2183
Colin Cross0ea8ba82019-06-06 14:33:29 -07002184func (c *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08002185 if c.cachedToolchain == nil {
Liz Kammer356f7d42021-01-26 09:18:53 -05002186 c.cachedToolchain = config.FindToolchainWithContext(ctx)
Colin Cross3f40fa42015-01-30 17:27:36 -08002187 }
Colin Crossca860ac2016-01-04 14:34:37 -08002188 return c.cachedToolchain
Colin Cross3f40fa42015-01-30 17:27:36 -08002189}
2190
Colin Crossca860ac2016-01-04 14:34:37 -08002191func (c *Module) begin(ctx BaseModuleContext) {
Joe Onorato37f900c2023-07-18 16:58:16 -07002192 for _, generator := range c.generators {
2193 generator.GeneratorInit(ctx)
2194 }
Colin Crossca860ac2016-01-04 14:34:37 -08002195 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002196 c.compiler.compilerInit(ctx)
Colin Cross21b9a242015-03-24 14:15:58 -07002197 }
Colin Crossca860ac2016-01-04 14:34:37 -08002198 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002199 c.linker.linkerInit(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08002200 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002201 if c.stl != nil {
2202 c.stl.begin(ctx)
2203 }
Colin Cross16b23492016-01-06 14:41:07 -08002204 if c.sanitize != nil {
2205 c.sanitize.begin(ctx)
2206 }
Dan Willemsen581341d2017-02-09 16:16:31 -08002207 if c.coverage != nil {
2208 c.coverage.begin(ctx)
2209 }
Yi Kong9723e332023-12-04 14:52:53 +09002210 if c.afdo != nil {
2211 c.afdo.begin(ctx)
2212 }
Stephen Craneba090d12017-05-09 15:44:35 -07002213 if c.lto != nil {
2214 c.lto.begin(ctx)
2215 }
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00002216 if c.orderfile != nil {
2217 c.orderfile.begin(ctx)
2218 }
Dan Albert92fe7402020-07-15 13:33:30 -07002219 if ctx.useSdk() && c.IsSdkVariant() {
Dan Albert1a246272020-07-06 14:49:35 -07002220 version, err := nativeApiLevelFromUser(ctx, ctx.sdkVersion())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002221 if err != nil {
2222 ctx.PropertyErrorf("sdk_version", err.Error())
Dan Albert1a246272020-07-06 14:49:35 -07002223 c.Properties.Sdk_version = nil
2224 } else {
2225 c.Properties.Sdk_version = StringPtr(version.String())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002226 }
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002227 }
Colin Crossca860ac2016-01-04 14:34:37 -08002228}
2229
Colin Cross37047f12016-12-13 17:06:13 -08002230func (c *Module) deps(ctx DepsContext) Deps {
Colin Crossc99deeb2016-04-11 15:06:20 -07002231 deps := Deps{}
2232
Joe Onorato37f900c2023-07-18 16:58:16 -07002233 for _, generator := range c.generators {
2234 deps = generator.GeneratorDeps(ctx, deps)
2235 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002236 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002237 deps = c.compiler.compilerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002238 }
2239 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002240 deps = c.linker.linkerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002241 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002242 if c.stl != nil {
2243 deps = c.stl.deps(ctx, deps)
2244 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00002245 if c.coverage != nil {
2246 deps = c.coverage.deps(ctx, deps)
2247 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002248
Colin Crossb6715442017-10-24 11:13:31 -07002249 deps.WholeStaticLibs = android.LastUniqueStrings(deps.WholeStaticLibs)
2250 deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
2251 deps.LateStaticLibs = android.LastUniqueStrings(deps.LateStaticLibs)
2252 deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
2253 deps.LateSharedLibs = android.LastUniqueStrings(deps.LateSharedLibs)
2254 deps.HeaderLibs = android.LastUniqueStrings(deps.HeaderLibs)
Logan Chien43d34c32017-12-20 01:17:32 +08002255 deps.RuntimeLibs = android.LastUniqueStrings(deps.RuntimeLibs)
Hsin-Yi Chen715142a2024-03-27 16:31:16 +08002256 deps.LlndkHeaderLibs = android.LastUniqueStrings(deps.LlndkHeaderLibs)
Colin Crossc99deeb2016-04-11 15:06:20 -07002257
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002258 for _, lib := range deps.ReexportSharedLibHeaders {
2259 if !inList(lib, deps.SharedLibs) {
2260 ctx.PropertyErrorf("export_shared_lib_headers", "Shared library not in shared_libs: '%s'", lib)
2261 }
2262 }
2263
2264 for _, lib := range deps.ReexportStaticLibHeaders {
Steven Morelandba407c82021-04-01 22:17:50 +00002265 if !inList(lib, deps.StaticLibs) && !inList(lib, deps.WholeStaticLibs) {
2266 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 -07002267 }
2268 }
2269
Colin Cross5950f382016-12-13 12:50:57 -08002270 for _, lib := range deps.ReexportHeaderLibHeaders {
2271 if !inList(lib, deps.HeaderLibs) {
2272 ctx.PropertyErrorf("export_header_lib_headers", "Header library not in header_libs: '%s'", lib)
2273 }
2274 }
2275
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002276 for _, gen := range deps.ReexportGeneratedHeaders {
2277 if !inList(gen, deps.GeneratedHeaders) {
2278 ctx.PropertyErrorf("export_generated_headers", "Generated header module not in generated_headers: '%s'", gen)
2279 }
2280 }
2281
Colin Crossc99deeb2016-04-11 15:06:20 -07002282 return deps
2283}
2284
Dan Albert7e9d2952016-08-04 13:02:36 -07002285func (c *Module) beginMutator(actx android.BottomUpMutatorContext) {
Colin Crossca860ac2016-01-04 14:34:37 -08002286 ctx := &baseModuleContext{
Colin Cross0ea8ba82019-06-06 14:33:29 -07002287 BaseModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08002288 moduleContextImpl: moduleContextImpl{
2289 mod: c,
2290 },
2291 }
2292 ctx.ctx = ctx
2293
Colin Crossca860ac2016-01-04 14:34:37 -08002294 c.begin(ctx)
Dan Albert7e9d2952016-08-04 13:02:36 -07002295}
2296
Jiyong Park7ed9de32018-10-15 22:25:07 +09002297// Split name#version into name and version
Jiyong Park73c54ee2019-10-22 20:31:18 +09002298func StubsLibNameAndVersion(name string) (string, string) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002299 if sharp := strings.LastIndex(name, "#"); sharp != -1 && sharp != len(name)-1 {
2300 version := name[sharp+1:]
2301 libname := name[:sharp]
2302 return libname, version
2303 }
2304 return name, ""
2305}
2306
Dan Albert92fe7402020-07-15 13:33:30 -07002307func GetCrtVariations(ctx android.BottomUpMutatorContext,
2308 m LinkableInterface) []blueprint.Variation {
2309 if ctx.Os() != android.Android {
2310 return nil
2311 }
2312 if m.UseSdk() {
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09002313 // Choose the CRT that best satisfies the min_sdk_version requirement of this module
2314 minSdkVersion := m.MinSdkVersion()
2315 if minSdkVersion == "" || minSdkVersion == "apex_inherit" {
2316 minSdkVersion = m.SdkVersion()
2317 }
Jooyung Han94a76ee2021-06-08 09:49:48 +09002318 apiLevel, err := android.ApiLevelFromUser(ctx, minSdkVersion)
2319 if err != nil {
2320 ctx.PropertyErrorf("min_sdk_version", err.Error())
2321 }
Colin Cross363ec762023-01-13 13:45:14 -08002322
2323 // Raise the minSdkVersion to the minimum supported for the architecture.
Colin Crossbb137a32023-01-26 09:54:42 -08002324 minApiForArch := MinApiForArch(ctx, m.Target().Arch.ArchType)
Colin Cross363ec762023-01-13 13:45:14 -08002325 if apiLevel.LessThan(minApiForArch) {
2326 apiLevel = minApiForArch
2327 }
2328
Dan Albert92fe7402020-07-15 13:33:30 -07002329 return []blueprint.Variation{
2330 {Mutator: "sdk", Variation: "sdk"},
Jooyung Han94a76ee2021-06-08 09:49:48 +09002331 {Mutator: "version", Variation: apiLevel.String()},
Dan Albert92fe7402020-07-15 13:33:30 -07002332 }
2333 }
2334 return []blueprint.Variation{
2335 {Mutator: "sdk", Variation: ""},
2336 }
2337}
2338
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002339func AddSharedLibDependenciesWithVersions(ctx android.BottomUpMutatorContext, mod LinkableInterface,
2340 variations []blueprint.Variation, depTag blueprint.DependencyTag, name, version string, far bool) {
Colin Crosse7257d22020-09-24 09:56:18 -07002341
2342 variations = append([]blueprint.Variation(nil), variations...)
2343
Liz Kammer23942242022-04-08 15:41:00 -04002344 if version != "" && canBeOrLinkAgainstVersionVariants(mod) {
Colin Crosse7257d22020-09-24 09:56:18 -07002345 // Version is explicitly specified. i.e. libFoo#30
2346 variations = append(variations, blueprint.Variation{Mutator: "version", Variation: version})
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002347 if tag, ok := depTag.(libraryDependencyTag); ok {
2348 tag.explicitlyVersioned = true
Colin Crossafcdce82024-10-22 13:59:33 -07002349 // depTag is an interface that contains a concrete non-pointer struct. That makes the local
2350 // tag variable a copy of the contents of depTag, and updating it doesn't change depTag. Reassign
2351 // the modified copy to depTag.
2352 depTag = tag
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002353 } else {
2354 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
2355 }
Colin Crosse7257d22020-09-24 09:56:18 -07002356 }
Colin Crosse7257d22020-09-24 09:56:18 -07002357
Colin Cross0de8a1e2020-09-18 14:15:30 -07002358 if far {
2359 ctx.AddFarVariationDependencies(variations, depTag, name)
2360 } else {
2361 ctx.AddVariationDependencies(variations, depTag, name)
Colin Crosse7257d22020-09-24 09:56:18 -07002362 }
2363}
2364
Kiyoung Kim487689e2022-07-26 09:48:22 +09002365func GetReplaceModuleName(lib string, replaceMap map[string]string) string {
2366 if snapshot, ok := replaceMap[lib]; ok {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002367 return snapshot
2368 }
2369
2370 return lib
2371}
2372
Kiyoung Kim37693d02024-04-04 09:56:15 +09002373// FilterNdkLibs takes a list of names of shared libraries and scans it for two types
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002374// of names:
2375//
Kiyoung Kim37693d02024-04-04 09:56:15 +09002376// 1. Name of an NDK library that refers to an ndk_library module.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002377//
2378// For each of these, it adds the name of the ndk_library module to the list of
2379// variant libs.
2380//
Kiyoung Kim37693d02024-04-04 09:56:15 +09002381// 2. Anything else (so anything that isn't an NDK library).
Kiyoung Kim487689e2022-07-26 09:48:22 +09002382//
2383// It adds these to the nonvariantLibs list.
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002384//
2385// The caller can then know to add the variantLibs dependencies differently from the
2386// nonvariantLibs
Kiyoung Kim37693d02024-04-04 09:56:15 +09002387func FilterNdkLibs(c LinkableInterface, config android.Config, list []string) (nonvariantLibs []string, variantLibs []string) {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002388 variantLibs = []string{}
2389
2390 nonvariantLibs = []string{}
2391 for _, entry := range list {
2392 // strip #version suffix out
2393 name, _ := StubsLibNameAndVersion(entry)
Kiyoung Kim37693d02024-04-04 09:56:15 +09002394 if c.UseSdk() && inList(name, *getNDKKnownLibs(config)) {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002395 variantLibs = append(variantLibs, name+ndkLibrarySuffix)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002396 } else {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002397 nonvariantLibs = append(nonvariantLibs, entry)
2398 }
2399 }
2400 return nonvariantLibs, variantLibs
Kiyoung Kim37693d02024-04-04 09:56:15 +09002401
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002402}
2403
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002404func rewriteLibsForApiImports(c LinkableInterface, libs []string, replaceList map[string]string, config android.Config) ([]string, []string) {
2405 nonVariantLibs := []string{}
2406 variantLibs := []string{}
2407
2408 for _, lib := range libs {
2409 replaceLibName := GetReplaceModuleName(lib, replaceList)
2410 if replaceLibName == lib {
2411 // Do not handle any libs which are not in API imports
2412 nonVariantLibs = append(nonVariantLibs, replaceLibName)
2413 } else if c.UseSdk() && inList(replaceLibName, *getNDKKnownLibs(config)) {
2414 variantLibs = append(variantLibs, replaceLibName)
2415 } else {
2416 nonVariantLibs = append(nonVariantLibs, replaceLibName)
2417 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002418 }
2419
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002420 return nonVariantLibs, variantLibs
Kiyoung Kim487689e2022-07-26 09:48:22 +09002421}
2422
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002423func (c *Module) shouldUseApiSurface() bool {
2424 if c.Os() == android.Android && c.Target().NativeBridge != android.NativeBridgeEnabled {
2425 if GetImageVariantType(c) == vendorImageVariant || GetImageVariantType(c) == productImageVariant {
2426 // LLNDK Variant
2427 return true
2428 }
2429
2430 if c.Properties.IsSdkVariant {
2431 // NDK Variant
2432 return true
2433 }
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002434 }
2435
2436 return false
2437}
2438
Colin Cross1e676be2016-10-12 14:38:15 -07002439func (c *Module) DepsMutator(actx android.BottomUpMutatorContext) {
Cole Fausta963b942024-04-11 17:43:00 -07002440 if !c.Enabled(actx) {
Inseob Kimeec88e12020-01-22 11:11:29 +09002441 return
2442 }
2443
Colin Cross37047f12016-12-13 17:06:13 -08002444 ctx := &depsContext{
2445 BottomUpMutatorContext: actx,
Dan Albert7e9d2952016-08-04 13:02:36 -07002446 moduleContextImpl: moduleContextImpl{
2447 mod: c,
2448 },
2449 }
2450 ctx.ctx = ctx
Colin Crossca860ac2016-01-04 14:34:37 -08002451
Colin Crossc99deeb2016-04-11 15:06:20 -07002452 deps := c.deps(ctx)
Kiyoung Kim11d91082022-10-19 19:20:57 +09002453
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002454 apiNdkLibs := []string{}
2455 apiLateNdkLibs := []string{}
2456
Yo Chiang219968c2020-09-22 18:45:04 +08002457 c.Properties.AndroidMkSystemSharedLibs = deps.SystemSharedLibs
2458
Dan Albert914449f2016-06-17 16:45:24 -07002459 variantNdkLibs := []string{}
2460 variantLateNdkLibs := []string{}
Dan Willemsenb916b802017-03-19 13:44:32 -07002461 if ctx.Os() == android.Android {
Kiyoung Kim37693d02024-04-04 09:56:15 +09002462 deps.SharedLibs, variantNdkLibs = FilterNdkLibs(c, ctx.Config(), deps.SharedLibs)
2463 deps.LateSharedLibs, variantLateNdkLibs = FilterNdkLibs(c, ctx.Config(), deps.LateSharedLibs)
2464 deps.ReexportSharedLibHeaders, _ = FilterNdkLibs(c, ctx.Config(), deps.ReexportSharedLibHeaders)
Dan Willemsen72d39932016-07-08 23:23:48 -07002465 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002466
Colin Cross32ec36c2016-12-15 07:39:51 -08002467 for _, lib := range deps.HeaderLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002468 depTag := libraryDependencyTag{Kind: headerLibraryDependency}
Colin Cross32ec36c2016-12-15 07:39:51 -08002469 if inList(lib, deps.ReexportHeaderLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002470 depTag.reexportFlags = true
Colin Cross32ec36c2016-12-15 07:39:51 -08002471 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002472
Spandan Das73bcafc2022-08-18 23:26:00 +00002473 if c.isNDKStubLibrary() {
Jiyong Parkf8fab9b2024-09-02 15:24:15 +09002474 variationExists := actx.OtherModuleDependencyVariantExists(nil, lib)
2475 if variationExists {
2476 actx.AddVariationDependencies(nil, depTag, lib)
2477 } else {
2478 // dependencies to ndk_headers fall here as ndk_headers do not have
2479 // any variants.
2480 actx.AddFarVariationDependencies([]blueprint.Variation{}, depTag, lib)
2481 }
Spandan Dasff665182024-09-11 18:48:44 +00002482 } else if c.IsStubs() {
Colin Cross7228ecd2019-11-18 16:00:16 -08002483 actx.AddFarVariationDependencies(append(ctx.Target().Variations(), c.ImageVariation()),
Colin Cross0f7d2ef2019-10-16 11:03:10 -07002484 depTag, lib)
Jiyong Park7e636d02019-01-28 16:16:54 +09002485 } else {
2486 actx.AddVariationDependencies(nil, depTag, lib)
2487 }
2488 }
2489
Dan Albertf1d14c72020-07-30 14:32:55 -07002490 if c.isNDKStubLibrary() {
2491 // NDK stubs depend on their implementation because the ABI dumps are
2492 // generated from the implementation library.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002493
Spandan Das8b08aea2023-03-14 19:29:34 +00002494 actx.AddFarVariationDependencies(append(ctx.Target().Variations(),
2495 c.ImageVariation(),
2496 blueprint.Variation{Mutator: "link", Variation: "shared"},
2497 ), stubImplementation, c.BaseModuleName())
Dan Albertf1d14c72020-07-30 14:32:55 -07002498 }
2499
Hsin-Yi Chen715142a2024-03-27 16:31:16 +08002500 // If this module is an LLNDK implementation library, let it depend on LlndkHeaderLibs.
2501 if c.ImageVariation().Variation == android.CoreVariation && c.Device() &&
2502 c.Target().NativeBridge == android.NativeBridgeDisabled {
2503 actx.AddVariationDependencies(
Jihoon Kang47e91842024-06-19 00:51:16 +00002504 []blueprint.Variation{{Mutator: "image", Variation: android.VendorVariation}},
Hsin-Yi Chen715142a2024-03-27 16:31:16 +08002505 llndkHeaderLibTag,
2506 deps.LlndkHeaderLibs...)
2507 }
2508
Jiyong Park5d1598f2019-02-25 22:14:17 +09002509 for _, lib := range deps.WholeStaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002510 depTag := libraryDependencyTag{Kind: staticLibraryDependency, wholeStatic: true, reexportFlags: true}
Inseob Kimeec88e12020-01-22 11:11:29 +09002511
Jiyong Park5d1598f2019-02-25 22:14:17 +09002512 actx.AddVariationDependencies([]blueprint.Variation{
2513 {Mutator: "link", Variation: "static"},
2514 }, depTag, lib)
2515 }
2516
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002517 for _, lib := range deps.StaticLibs {
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04002518 // Some dependencies listed in static_libs might actually be rust_ffi rlib variants.
Colin Cross6e511a92020-07-27 21:26:48 -07002519 depTag := libraryDependencyTag{Kind: staticLibraryDependency}
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04002520
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002521 if inList(lib, deps.ReexportStaticLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002522 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002523 }
Jiyong Parke3867542020-12-03 17:28:25 +09002524 if inList(lib, deps.ExcludeLibsForApex) {
2525 depTag.excludeInApex = true
2526 }
Dan Willemsen59339a22018-07-22 21:18:45 -07002527 actx.AddVariationDependencies([]blueprint.Variation{
2528 {Mutator: "link", Variation: "static"},
2529 }, depTag, lib)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002530 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002531
Jooyung Han75568392020-03-20 04:29:24 +09002532 // staticUnwinderDep is treated as staticDep for Q apexes
2533 // so that native libraries/binaries are linked with static unwinder
2534 // because Q libc doesn't have unwinder APIs
2535 if deps.StaticUnwinderIfLegacy {
Colin Cross6e511a92020-07-27 21:26:48 -07002536 depTag := libraryDependencyTag{Kind: staticLibraryDependency, staticUnwinder: true}
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002537 actx.AddVariationDependencies([]blueprint.Variation{
2538 {Mutator: "link", Variation: "static"},
Kiyoung Kim37693d02024-04-04 09:56:15 +09002539 }, depTag, staticUnwinder(actx))
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002540 }
2541
Jiyong Park7ed9de32018-10-15 22:25:07 +09002542 // shared lib names without the #version suffix
2543 var sharedLibNames []string
2544
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002545 for _, lib := range deps.SharedLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002546 depTag := libraryDependencyTag{Kind: sharedLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002547 if inList(lib, deps.ReexportSharedLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002548 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002549 }
Jiyong Parke3867542020-12-03 17:28:25 +09002550 if inList(lib, deps.ExcludeLibsForApex) {
2551 depTag.excludeInApex = true
2552 }
Jooyung Han9ffbe832023-11-28 22:31:35 +09002553 if inList(lib, deps.ExcludeLibsForNonApex) {
2554 depTag.excludeInNonApex = true
2555 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002556
Jiyong Park73c54ee2019-10-22 20:31:18 +09002557 name, version := StubsLibNameAndVersion(lib)
Inseob Kimc0907f12019-02-08 21:00:45 +09002558 sharedLibNames = append(sharedLibNames, name)
2559
Colin Crosse7257d22020-09-24 09:56:18 -07002560 variations := []blueprint.Variation{
2561 {Mutator: "link", Variation: "shared"},
2562 }
Spandan Dasff665182024-09-11 18:48:44 +00002563 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, name, version, false)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002564 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002565
Colin Crossfe9acfe2021-06-14 16:13:03 -07002566 for _, lib := range deps.LateStaticLibs {
2567 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency}
2568 actx.AddVariationDependencies([]blueprint.Variation{
2569 {Mutator: "link", Variation: "static"},
Kiyoung Kim37693d02024-04-04 09:56:15 +09002570 }, depTag, lib)
Colin Crossfe9acfe2021-06-14 16:13:03 -07002571 }
2572
Colin Cross3e5e7782022-06-17 22:17:05 +00002573 for _, lib := range deps.UnexportedStaticLibs {
2574 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency, unexportedSymbols: true}
2575 actx.AddVariationDependencies([]blueprint.Variation{
2576 {Mutator: "link", Variation: "static"},
Kiyoung Kim37693d02024-04-04 09:56:15 +09002577 }, depTag, lib)
Colin Cross3e5e7782022-06-17 22:17:05 +00002578 }
2579
Jiyong Park7ed9de32018-10-15 22:25:07 +09002580 for _, lib := range deps.LateSharedLibs {
Jiyong Park25fc6a92018-11-18 18:02:45 +09002581 if inList(lib, sharedLibNames) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002582 // This is to handle the case that some of the late shared libs (libc, libdl, libm, ...)
2583 // are added also to SharedLibs with version (e.g., libc#10). If not skipped, we will be
2584 // linking against both the stubs lib and the non-stubs lib at the same time.
2585 continue
2586 }
Colin Cross6e511a92020-07-27 21:26:48 -07002587 depTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency}
Colin Crosse7257d22020-09-24 09:56:18 -07002588 variations := []blueprint.Variation{
2589 {Mutator: "link", Variation: "shared"},
2590 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002591 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, lib, "", false)
Jiyong Park7ed9de32018-10-15 22:25:07 +09002592 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002593
Dan Willemsen59339a22018-07-22 21:18:45 -07002594 actx.AddVariationDependencies([]blueprint.Variation{
2595 {Mutator: "link", Variation: "shared"},
Chris Parsons79d66a52020-06-05 17:26:16 -04002596 }, dataLibDepTag, deps.DataLibs...)
2597
Colin Crossc8caa062021-09-24 16:50:14 -07002598 actx.AddVariationDependencies(nil, dataBinDepTag, deps.DataBins...)
2599
Chris Parsons79d66a52020-06-05 17:26:16 -04002600 actx.AddVariationDependencies([]blueprint.Variation{
2601 {Mutator: "link", Variation: "shared"},
Dan Willemsen59339a22018-07-22 21:18:45 -07002602 }, runtimeDepTag, deps.RuntimeLibs...)
Logan Chien43d34c32017-12-20 01:17:32 +08002603
Colin Cross68861832016-07-08 10:41:41 -07002604 actx.AddDependency(c, genSourceDepTag, deps.GeneratedSources...)
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002605
2606 for _, gen := range deps.GeneratedHeaders {
2607 depTag := genHeaderDepTag
2608 if inList(gen, deps.ReexportGeneratedHeaders) {
2609 depTag = genHeaderExportDepTag
2610 }
2611 actx.AddDependency(c, depTag, gen)
2612 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002613
Cole Faust65cb40a2024-10-21 15:41:42 -07002614 for _, gen := range deps.DeviceFirstGeneratedHeaders {
2615 depTag := genHeaderDepTag
2616 actx.AddVariationDependencies(ctx.Config().AndroidFirstDeviceTarget.Variations(), depTag, gen)
2617 }
2618
Dan Albert92fe7402020-07-15 13:33:30 -07002619 crtVariations := GetCrtVariations(ctx, c)
Colin Crossbbc941b2020-09-30 12:27:01 -07002620 actx.AddVariationDependencies(crtVariations, objDepTag, deps.ObjFiles...)
Colin Crossc465efd2021-06-11 18:00:04 -07002621 for _, crt := range deps.CrtBegin {
Dan Albert92fe7402020-07-15 13:33:30 -07002622 actx.AddVariationDependencies(crtVariations, CrtBeginDepTag,
Kiyoung Kim37693d02024-04-04 09:56:15 +09002623 crt)
Colin Crossca860ac2016-01-04 14:34:37 -08002624 }
Colin Crossc465efd2021-06-11 18:00:04 -07002625 for _, crt := range deps.CrtEnd {
Dan Albert92fe7402020-07-15 13:33:30 -07002626 actx.AddVariationDependencies(crtVariations, CrtEndDepTag,
Kiyoung Kim37693d02024-04-04 09:56:15 +09002627 crt)
Colin Cross21b9a242015-03-24 14:15:58 -07002628 }
Dan Willemsena0790e32018-10-12 00:24:23 -07002629 if deps.DynamicLinker != "" {
2630 actx.AddDependency(c, dynamicLinkerDepTag, deps.DynamicLinker)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002631 }
Dan Albert914449f2016-06-17 16:45:24 -07002632
2633 version := ctx.sdkVersion()
Colin Cross6e511a92020-07-27 21:26:48 -07002634
2635 ndkStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002636 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002637 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002638 {Mutator: "link", Variation: "shared"},
2639 }, ndkStubDepTag, variantNdkLibs...)
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002640 actx.AddVariationDependencies([]blueprint.Variation{
2641 {Mutator: "version", Variation: version},
2642 {Mutator: "link", Variation: "shared"},
2643 }, ndkStubDepTag, apiNdkLibs...)
Colin Cross6e511a92020-07-27 21:26:48 -07002644
2645 ndkLateStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002646 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002647 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002648 {Mutator: "link", Variation: "shared"},
2649 }, ndkLateStubDepTag, variantLateNdkLibs...)
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002650 actx.AddVariationDependencies([]blueprint.Variation{
2651 {Mutator: "version", Variation: version},
2652 {Mutator: "link", Variation: "shared"},
2653 }, ndkLateStubDepTag, apiLateNdkLibs...)
Logan Chienf3511742017-10-31 18:04:35 +08002654
Vinh Tran367d89d2023-04-28 11:21:25 -04002655 if len(deps.AidlLibs) > 0 {
2656 actx.AddDependency(
2657 c,
2658 aidlLibraryTag,
2659 deps.AidlLibs...,
2660 )
2661 }
2662
Colin Cross6362e272015-10-29 15:25:03 -07002663}
Colin Cross21b9a242015-03-24 14:15:58 -07002664
Colin Crosse40b4ea2018-10-02 22:25:58 -07002665func BeginMutator(ctx android.BottomUpMutatorContext) {
Cole Fausta963b942024-04-11 17:43:00 -07002666 if c, ok := ctx.Module().(*Module); ok && c.Enabled(ctx) {
Dan Albert7e9d2952016-08-04 13:02:36 -07002667 c.beginMutator(ctx)
2668 }
2669}
2670
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002671// Whether a module can link to another module, taking into
2672// account NDK linking.
Jooyung Han479ca172020-10-19 18:51:07 +09002673func checkLinkType(ctx android.BaseModuleContext, from LinkableInterface, to LinkableInterface,
Colin Cross6e511a92020-07-27 21:26:48 -07002674 tag blueprint.DependencyTag) {
2675
2676 switch t := tag.(type) {
2677 case dependencyTag:
2678 if t != vndkExtDepTag {
2679 return
2680 }
2681 case libraryDependencyTag:
2682 default:
2683 return
2684 }
2685
Ivan Lozanof9e21722020-12-02 09:00:51 -05002686 if from.Target().Os != android.Android {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002687 // Host code is not restricted
2688 return
2689 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002690
Ivan Lozano52767be2019-10-18 14:49:46 -07002691 if from.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002692 // Platform code can link to anything
2693 return
2694 }
Yifan Hong1b3348d2020-01-21 15:53:22 -08002695 if from.InRamdisk() {
2696 // Ramdisk code is not NDK
2697 return
2698 }
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002699 if from.InVendorRamdisk() {
2700 // Vendor ramdisk code is not NDK
2701 return
2702 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002703 if from.InRecovery() {
Jiyong Parkf9332f12018-02-01 00:54:12 +09002704 // Recovery code is not NDK
2705 return
2706 }
Colin Cross31076b32020-10-23 17:22:06 -07002707 if c, ok := to.(*Module); ok {
Colin Cross31076b32020-10-23 17:22:06 -07002708 if c.StubDecorator() {
2709 // These aren't real libraries, but are the stub shared libraries that are included in
2710 // the NDK.
2711 return
2712 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002713 }
Logan Chien834b9a62019-01-14 15:39:03 +08002714
Ivan Lozano52767be2019-10-18 14:49:46 -07002715 if strings.HasPrefix(ctx.ModuleName(), "libclang_rt.") && to.Module().Name() == "libc++" {
Logan Chien834b9a62019-01-14 15:39:03 +08002716 // Bug: http://b/121358700 - Allow libclang_rt.* shared libraries (with sdk_version)
2717 // to link to libc++ (non-NDK and without sdk_version).
2718 return
2719 }
2720
Ivan Lozano52767be2019-10-18 14:49:46 -07002721 if to.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002722 // NDK code linking to platform code is never okay.
2723 ctx.ModuleErrorf("depends on non-NDK-built library %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002724 ctx.OtherModuleName(to.Module()))
Dan Willemsen155d17c2019-02-06 18:30:02 -08002725 return
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002726 }
2727
2728 // At this point we know we have two NDK libraries, but we need to
2729 // check that we're not linking against anything built against a higher
2730 // API level, as it is only valid to link against older or equivalent
2731 // APIs.
2732
Inseob Kim01a28722018-04-11 09:48:45 +09002733 // Current can link against anything.
Ivan Lozano52767be2019-10-18 14:49:46 -07002734 if from.SdkVersion() != "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002735 // Otherwise we need to check.
Ivan Lozano52767be2019-10-18 14:49:46 -07002736 if to.SdkVersion() == "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002737 // Current can't be linked against by anything else.
2738 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002739 ctx.OtherModuleName(to.Module()), "current")
Inseob Kim01a28722018-04-11 09:48:45 +09002740 } else {
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002741 fromApi, err := android.ApiLevelFromUserWithConfig(ctx.Config(), from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002742 if err != nil {
2743 ctx.PropertyErrorf("sdk_version",
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002744 "Invalid sdk_version value (must be int, preview or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002745 from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002746 }
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002747 toApi, err := android.ApiLevelFromUserWithConfig(ctx.Config(), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002748 if err != nil {
2749 ctx.PropertyErrorf("sdk_version",
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002750 "Invalid sdk_version value (must be int, preview or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002751 to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002752 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002753
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002754 if toApi.GreaterThan(fromApi) {
Inseob Kim01a28722018-04-11 09:48:45 +09002755 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002756 ctx.OtherModuleName(to.Module()), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002757 }
2758 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002759 }
Dan Albert202fe492017-12-15 13:56:59 -08002760
2761 // Also check that the two STL choices are compatible.
Ivan Lozano52767be2019-10-18 14:49:46 -07002762 fromStl := from.SelectedStl()
2763 toStl := to.SelectedStl()
Dan Albert202fe492017-12-15 13:56:59 -08002764 if fromStl == "" || toStl == "" {
2765 // Libraries that don't use the STL are unrestricted.
Inseob Kimda2171a2018-04-11 15:41:38 +09002766 } else if fromStl == "ndk_system" || toStl == "ndk_system" {
Dan Albert202fe492017-12-15 13:56:59 -08002767 // We can be permissive with the system "STL" since it is only the C++
2768 // ABI layer, but in the future we should make sure that everyone is
2769 // using either libc++ or nothing.
Colin Crossb60190a2018-09-04 16:28:17 -07002770 } else if getNdkStlFamily(from) != getNdkStlFamily(to) {
Dan Albert202fe492017-12-15 13:56:59 -08002771 ctx.ModuleErrorf("uses %q and depends on %q which uses incompatible %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002772 from.SelectedStl(), ctx.OtherModuleName(to.Module()),
2773 to.SelectedStl())
Dan Albert202fe492017-12-15 13:56:59 -08002774 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002775}
2776
Jooyung Han479ca172020-10-19 18:51:07 +09002777func checkLinkTypeMutator(ctx android.BottomUpMutatorContext) {
2778 if c, ok := ctx.Module().(*Module); ok {
2779 ctx.VisitDirectDeps(func(dep android.Module) {
2780 depTag := ctx.OtherModuleDependencyTag(dep)
2781 ccDep, ok := dep.(LinkableInterface)
2782 if ok {
2783 checkLinkType(ctx, c, ccDep, depTag)
2784 }
2785 })
2786 }
2787}
2788
Jiyong Park5fb8c102018-04-09 12:03:06 +09002789// Tests whether the dependent library is okay to be double loaded inside a single process.
Jooyung Hana70f0672019-01-18 15:20:43 +09002790// If a library has a vendor variant and is a (transitive) dependency of an LLNDK library,
2791// it is subject to be double loaded. Such lib should be explicitly marked as double_loadable: true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002792// or as vndk-sp (vndk: { enabled: true, support_system_process: true}).
Colin Crossda279cf2024-09-17 14:25:45 -07002793func checkDoubleLoadableLibraries(ctx android.BottomUpMutatorContext) {
Jooyung Hana70f0672019-01-18 15:20:43 +09002794 check := func(child, parent android.Module) bool {
2795 to, ok := child.(*Module)
2796 if !ok {
Jooyung Han479ca172020-10-19 18:51:07 +09002797 return false
Jooyung Hana70f0672019-01-18 15:20:43 +09002798 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002799
Jooyung Hana70f0672019-01-18 15:20:43 +09002800 if lib, ok := to.linker.(*libraryDecorator); !ok || !lib.shared() {
2801 return false
Jiyong Park5fb8c102018-04-09 12:03:06 +09002802 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002803
Jiyong Park0474e1f2021-01-14 14:26:06 +09002804 // These dependencies are not excercised at runtime. Tracking these will give us
2805 // false negative, so skip.
Jiyong Park1ad8e162020-12-01 23:40:09 +09002806 depTag := ctx.OtherModuleDependencyTag(child)
2807 if IsHeaderDepTag(depTag) {
2808 return false
2809 }
Jiyong Park0474e1f2021-01-14 14:26:06 +09002810 if depTag == staticVariantTag {
2811 return false
2812 }
2813 if depTag == stubImplDepTag {
2814 return false
2815 }
Jiyong Park8bcf3c62024-03-18 18:37:10 +09002816 if depTag == android.RequiredDepTag {
2817 return false
2818 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002819
Justin Yun63e9ec72020-10-29 16:49:43 +09002820 // Even if target lib has no vendor variant, keep checking dependency
2821 // graph in case it depends on vendor_available or product_available
2822 // but not double_loadable transtively.
2823 if !to.HasNonSystemVariants() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002824 return true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002825 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002826
Jiyong Park0474e1f2021-01-14 14:26:06 +09002827 // The happy path. Keep tracking dependencies until we hit a non double-loadable
2828 // one.
2829 if Bool(to.VendorProperties.Double_loadable) {
2830 return true
2831 }
2832
Kiyoung Kim9f26fcf2024-05-27 17:25:52 +09002833 if to.IsLlndk() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002834 return false
2835 }
2836
Jooyung Hana70f0672019-01-18 15:20:43 +09002837 ctx.ModuleErrorf("links a library %q which is not LL-NDK, "+
2838 "VNDK-SP, or explicitly marked as 'double_loadable:true'. "+
Jiyong Park0474e1f2021-01-14 14:26:06 +09002839 "Dependency list: %s", ctx.OtherModuleName(to), ctx.GetPathString(false))
Jooyung Hana70f0672019-01-18 15:20:43 +09002840 return false
2841 }
2842 if module, ok := ctx.Module().(*Module); ok {
2843 if lib, ok := module.linker.(*libraryDecorator); ok && lib.shared() {
Jiyong Park0474e1f2021-01-14 14:26:06 +09002844 if lib.hasLLNDKStubs() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002845 ctx.WalkDeps(check)
2846 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002847 }
2848 }
2849}
2850
Yu Liue4312402023-01-18 09:15:31 -08002851func findApexSdkVersion(ctx android.BaseModuleContext, apexInfo android.ApexInfo) android.ApiLevel {
2852 // For the dependency from platform to apex, use the latest stubs
2853 apexSdkVersion := android.FutureApiLevel
2854 if !apexInfo.IsForPlatform() {
2855 apexSdkVersion = apexInfo.MinSdkVersion
2856 }
2857
2858 if android.InList("hwaddress", ctx.Config().SanitizeDevice()) {
2859 // In hwasan build, we override apexSdkVersion to the FutureApiLevel(10000)
2860 // so that even Q(29/Android10) apexes could use the dynamic unwinder by linking the newer stubs(e.g libc(R+)).
2861 // (b/144430859)
2862 apexSdkVersion = android.FutureApiLevel
2863 }
2864
2865 return apexSdkVersion
2866}
2867
Colin Crossc99deeb2016-04-11 15:06:20 -07002868// Convert dependencies to paths. Returns a PathDeps containing paths
Colin Cross635c3b02016-05-18 15:37:25 -07002869func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
Colin Crossca860ac2016-01-04 14:34:37 -08002870 var depPaths PathDeps
Colin Crossca860ac2016-01-04 14:34:37 -08002871
Colin Cross0de8a1e2020-09-18 14:15:30 -07002872 var directStaticDeps []StaticLibraryInfo
2873 var directSharedDeps []SharedLibraryInfo
Jeff Gaston294356f2017-09-27 17:05:30 -07002874
Colin Cross0de8a1e2020-09-18 14:15:30 -07002875 reexportExporter := func(exporter FlagExporterInfo) {
2876 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, exporter.IncludeDirs...)
2877 depPaths.ReexportedSystemDirs = append(depPaths.ReexportedSystemDirs, exporter.SystemIncludeDirs...)
2878 depPaths.ReexportedFlags = append(depPaths.ReexportedFlags, exporter.Flags...)
2879 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, exporter.Deps...)
2880 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders, exporter.GeneratedHeaders...)
Inseob Kim69378442019-06-03 19:10:47 +09002881 }
2882
Colin Crossff694a82023-12-13 15:54:49 -08002883 apexInfo, _ := android.ModuleProvider(ctx, android.ApexInfoProvider)
Yu Liue4312402023-01-18 09:15:31 -08002884 c.apexSdkVersion = findApexSdkVersion(ctx, apexInfo)
Jooyung Hande34d232020-07-23 13:04:15 +09002885
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002886 skipModuleList := map[string]bool{}
2887
Colin Crossd11fcda2017-10-23 17:59:01 -07002888 ctx.VisitDirectDeps(func(dep android.Module) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002889 depName := ctx.OtherModuleName(dep)
2890 depTag := ctx.OtherModuleDependencyTag(dep)
Dan Albert9e10cd42016-08-03 14:12:14 -07002891
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002892 if _, ok := skipModuleList[depName]; ok {
2893 // skip this module because original module or API imported module matching with this should be used instead.
2894 return
2895 }
2896
Dan Willemsen47450072021-10-19 20:24:49 -07002897 if depTag == android.DarwinUniversalVariantTag {
2898 depPaths.DarwinSecondArchOutput = dep.(*Module).OutputFile()
2899 return
2900 }
2901
Vinh Tran367d89d2023-04-28 11:21:25 -04002902 if depTag == aidlLibraryTag {
Colin Cross313aa542023-12-13 13:47:44 -08002903 if aidlLibraryInfo, ok := android.OtherModuleProvider(ctx, dep, aidl_library.AidlLibraryProvider); ok {
Vinh Tran367d89d2023-04-28 11:21:25 -04002904 depPaths.AidlLibraryInfos = append(
2905 depPaths.AidlLibraryInfos,
Colin Cross313aa542023-12-13 13:47:44 -08002906 aidlLibraryInfo,
Vinh Tran367d89d2023-04-28 11:21:25 -04002907 )
2908 }
2909 }
2910
Ivan Lozano52767be2019-10-18 14:49:46 -07002911 ccDep, ok := dep.(LinkableInterface)
2912 if !ok {
2913
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002914 // handling for a few module types that aren't cc Module but that are also supported
2915 switch depTag {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002916 case genSourceDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002917 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002918 depPaths.GeneratedSources = append(depPaths.GeneratedSources,
2919 genRule.GeneratedSourceFiles()...)
2920 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002921 ctx.ModuleErrorf("module %q is not a gensrcs or genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002922 }
Colin Crosse90bfd12017-04-26 16:59:26 -07002923 // Support exported headers from a generated_sources dependency
2924 fallthrough
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002925 case genHeaderDepTag, genHeaderExportDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002926 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Inseob Kimd110f872019-12-06 13:15:38 +09002927 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps,
Dan Willemsen9da9d492018-02-21 18:28:18 -08002928 genRule.GeneratedDeps()...)
Jiyong Park74955042019-10-22 20:19:51 +09002929 dirs := genRule.GeneratedHeaderDirs()
Inseob Kim69378442019-06-03 19:10:47 +09002930 depPaths.IncludeDirs = append(depPaths.IncludeDirs, dirs...)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002931 if depTag == genHeaderExportDepTag {
Inseob Kim69378442019-06-03 19:10:47 +09002932 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, dirs...)
Inseob Kimd110f872019-12-06 13:15:38 +09002933 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders,
2934 genRule.GeneratedSourceFiles()...)
Inseob Kim69378442019-06-03 19:10:47 +09002935 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, genRule.GeneratedDeps()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002936 // 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 +09002937 c.sabi.Properties.ReexportedIncludes = append(c.sabi.Properties.ReexportedIncludes, dirs.Strings()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002938
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002939 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002940 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002941 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002942 }
Colin Crosscef792e2021-06-11 18:01:26 -07002943 case CrtBeginDepTag:
2944 depPaths.CrtBegin = append(depPaths.CrtBegin, android.OutputFileForModule(ctx, dep, ""))
2945 case CrtEndDepTag:
2946 depPaths.CrtEnd = append(depPaths.CrtEnd, android.OutputFileForModule(ctx, dep, ""))
Colin Crossca860ac2016-01-04 14:34:37 -08002947 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002948 return
2949 }
2950
Colin Crossfe17f6f2019-03-28 19:30:56 -07002951 if depTag == android.ProtoPluginDepTag {
2952 return
2953 }
2954
Jiyong Park8bcf3c62024-03-18 18:37:10 +09002955 if depTag == android.RequiredDepTag {
2956 return
2957 }
2958
Colin Crossd11fcda2017-10-23 17:59:01 -07002959 if dep.Target().Os != ctx.Os() {
Steven Morelandaaae81f2024-08-27 22:55:48 +00002960 ctx.ModuleErrorf("OS mismatch between %q (%s) and %q (%s)", ctx.ModuleName(), ctx.Os().Name, depName, dep.Target().Os.Name)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002961 return
2962 }
Colin Crossd11fcda2017-10-23 17:59:01 -07002963 if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
Jooyung Han61b66e92020-03-21 14:21:46 +00002964 ctx.ModuleErrorf("Arch mismatch between %q(%v) and %q(%v)",
2965 ctx.ModuleName(), ctx.Arch().ArchType, depName, dep.Target().Arch.ArchType)
Colin Crossa1ad8d12016-06-01 17:09:44 -07002966 return
2967 }
2968
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002969 if depTag == reuseObjTag {
Colin Crossa717db72020-10-23 14:53:06 -07002970 // Skip reused objects for stub libraries, they use their own stub object file instead.
2971 // The reuseObjTag dependency still exists because the LinkageMutator runs before the
2972 // version mutator, so the stubs variant is created from the shared variant that
2973 // already has the reuseObjTag dependency on the static variant.
Colin Cross31076b32020-10-23 17:22:06 -07002974 if !c.library.buildStubs() {
Colin Cross313aa542023-12-13 13:47:44 -08002975 staticAnalogue, _ := android.OtherModuleProvider(ctx, dep, StaticLibraryInfoProvider)
Colin Crossa717db72020-10-23 14:53:06 -07002976 objs := staticAnalogue.ReuseObjects
2977 depPaths.Objs = depPaths.Objs.Append(objs)
Colin Cross313aa542023-12-13 13:47:44 -08002978 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
Colin Crossa717db72020-10-23 14:53:06 -07002979 reexportExporter(depExporterInfo)
2980 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07002981 return
Jiyong Parke4bb9862019-02-01 00:31:10 +09002982 }
2983
Hsin-Yi Chen715142a2024-03-27 16:31:16 +08002984 if depTag == llndkHeaderLibTag {
2985 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
2986 depPaths.LlndkIncludeDirs = append(depPaths.LlndkIncludeDirs, depExporterInfo.IncludeDirs...)
2987 depPaths.LlndkSystemIncludeDirs = append(depPaths.LlndkSystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
2988 }
2989
Colin Cross6e511a92020-07-27 21:26:48 -07002990 linkFile := ccDep.OutputFile()
2991
2992 if libDepTag, ok := depTag.(libraryDependencyTag); ok {
2993 // Only use static unwinder for legacy (min_sdk_version = 29) apexes (b/144430859)
Dan Albertc8060532020-07-22 22:32:17 -07002994 if libDepTag.staticUnwinder && c.apexSdkVersion.GreaterThan(android.SdkVersion_Android10) {
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002995 return
2996 }
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002997
Jiyong Parke3867542020-12-03 17:28:25 +09002998 if !apexInfo.IsForPlatform() && libDepTag.excludeInApex {
2999 return
3000 }
Jooyung Han9ffbe832023-11-28 22:31:35 +09003001 if apexInfo.IsForPlatform() && libDepTag.excludeInNonApex {
3002 return
3003 }
Jiyong Parke3867542020-12-03 17:28:25 +09003004
Colin Cross313aa542023-12-13 13:47:44 -08003005 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
Colin Crossc99deeb2016-04-11 15:06:20 -07003006
Colin Cross6e511a92020-07-27 21:26:48 -07003007 var ptr *android.Paths
3008 var depPtr *android.Paths
Colin Crossc99deeb2016-04-11 15:06:20 -07003009
Colin Cross6e511a92020-07-27 21:26:48 -07003010 depFile := android.OptionalPath{}
Colin Cross26c34ed2016-09-30 17:10:16 -07003011
Colin Cross6e511a92020-07-27 21:26:48 -07003012 switch {
3013 case libDepTag.header():
Colin Cross313aa542023-12-13 13:47:44 -08003014 if _, isHeaderLib := android.OtherModuleProvider(ctx, dep, HeaderLibraryInfoProvider); !isHeaderLib {
Colin Cross649d8172020-12-10 12:30:21 -08003015 if !ctx.Config().AllowMissingDependencies() {
3016 ctx.ModuleErrorf("module %q is not a header library", depName)
3017 } else {
3018 ctx.AddMissingDependencies([]string{depName})
3019 }
3020 return
3021 }
Colin Cross6e511a92020-07-27 21:26:48 -07003022 case libDepTag.shared():
Colin Cross313aa542023-12-13 13:47:44 -08003023 if _, isSharedLib := android.OtherModuleProvider(ctx, dep, SharedLibraryInfoProvider); !isSharedLib {
Colin Cross0de8a1e2020-09-18 14:15:30 -07003024 if !ctx.Config().AllowMissingDependencies() {
3025 ctx.ModuleErrorf("module %q is not a shared library", depName)
3026 } else {
3027 ctx.AddMissingDependencies([]string{depName})
3028 }
3029 return
3030 }
Jiyong Parke3867542020-12-03 17:28:25 +09003031
Jiyong Park7d55b612021-06-11 17:22:09 +09003032 sharedLibraryInfo, returnedDepExporterInfo := ChooseStubOrImpl(ctx, dep)
3033 depExporterInfo = returnedDepExporterInfo
Colin Cross0de8a1e2020-09-18 14:15:30 -07003034
Jiyong Park1ad8e162020-12-01 23:40:09 +09003035 // Stubs lib doesn't link to the shared lib dependencies. Don't set
3036 // linkFile, depFile, and ptr.
3037 if c.IsStubs() {
3038 break
3039 }
3040
Colin Cross0de8a1e2020-09-18 14:15:30 -07003041 linkFile = android.OptionalPathForPath(sharedLibraryInfo.SharedLibrary)
3042 depFile = sharedLibraryInfo.TableOfContents
3043
Colin Cross6e511a92020-07-27 21:26:48 -07003044 ptr = &depPaths.SharedLibs
3045 switch libDepTag.Order {
3046 case earlyLibraryDependency:
3047 ptr = &depPaths.EarlySharedLibs
3048 depPtr = &depPaths.EarlySharedLibsDeps
3049 case normalLibraryDependency:
3050 ptr = &depPaths.SharedLibs
3051 depPtr = &depPaths.SharedLibsDeps
Colin Cross0de8a1e2020-09-18 14:15:30 -07003052 directSharedDeps = append(directSharedDeps, sharedLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07003053 case lateLibraryDependency:
3054 ptr = &depPaths.LateSharedLibs
3055 depPtr = &depPaths.LateSharedLibsDeps
3056 default:
3057 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Colin Crossc99deeb2016-04-11 15:06:20 -07003058 }
Ivan Lozano0a468a42024-05-13 21:03:34 -04003059
Colin Cross6e511a92020-07-27 21:26:48 -07003060 case libDepTag.static():
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003061 if ccDep.RustLibraryInterface() {
3062 rlibDep := RustRlibDep{LibPath: linkFile.Path(), CrateName: ccDep.CrateName(), LinkDirs: ccDep.ExportedCrateLinkDirs()}
3063 depPaths.RustRlibDeps = append(depPaths.RustRlibDeps, rlibDep)
3064 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
3065 if libDepTag.wholeStatic {
3066 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, depExporterInfo.IncludeDirs...)
3067 depPaths.ReexportedRustRlibDeps = append(depPaths.ReexportedRustRlibDeps, rlibDep)
Jiyong Park1ad8e162020-12-01 23:40:09 +09003068
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003069 // If whole_static, track this as we want to make sure that in a final linkage for a shared library,
3070 // exported functions from the rust generated staticlib still exported.
3071 if c.CcLibrary() && c.Shared() {
3072 c.WholeRustStaticlib = true
3073 }
Colin Cross6e511a92020-07-27 21:26:48 -07003074 }
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003075
Colin Cross6e511a92020-07-27 21:26:48 -07003076 } else {
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003077 staticLibraryInfo, isStaticLib := android.OtherModuleProvider(ctx, dep, StaticLibraryInfoProvider)
3078 if !isStaticLib {
3079 if !ctx.Config().AllowMissingDependencies() {
3080 ctx.ModuleErrorf("module %q is not a static library", depName)
3081 } else {
3082 ctx.AddMissingDependencies([]string{depName})
3083 }
3084 return
Inseob Kimeec88e12020-01-22 11:11:29 +09003085 }
Ivan Lozano0a468a42024-05-13 21:03:34 -04003086
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003087 // Stubs lib doesn't link to the static lib dependencies. Don't set
3088 // linkFile, depFile, and ptr.
3089 if c.IsStubs() {
3090 break
3091 }
Ivan Lozano0a468a42024-05-13 21:03:34 -04003092
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003093 linkFile = android.OptionalPathForPath(staticLibraryInfo.StaticLibrary)
3094 if libDepTag.wholeStatic {
3095 ptr = &depPaths.WholeStaticLibs
3096 if len(staticLibraryInfo.Objects.objFiles) > 0 {
3097 depPaths.WholeStaticLibObjs = depPaths.WholeStaticLibObjs.Append(staticLibraryInfo.Objects)
3098 } else {
3099 // This case normally catches prebuilt static
3100 // libraries, but it can also occur when
3101 // AllowMissingDependencies is on and the
3102 // dependencies has no sources of its own
3103 // but has a whole_static_libs dependency
3104 // on a missing library. We want to depend
3105 // on the .a file so that there is something
3106 // in the dependency tree that contains the
3107 // error rule for the missing transitive
3108 // dependency.
3109 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts, linkFile.Path())
3110 }
3111 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts,
3112 staticLibraryInfo.WholeStaticLibsFromPrebuilts...)
3113 } else {
3114 switch libDepTag.Order {
3115 case earlyLibraryDependency:
3116 panic(fmt.Errorf("early static libs not supported"))
3117 case normalLibraryDependency:
3118 // static dependencies will be handled separately so they can be ordered
3119 // using transitive dependencies.
3120 ptr = nil
3121 directStaticDeps = append(directStaticDeps, staticLibraryInfo)
3122 case lateLibraryDependency:
3123 ptr = &depPaths.LateStaticLibs
3124 default:
3125 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
3126 }
3127 }
3128
3129 // Collect any exported Rust rlib deps from static libraries which have been included as whole_static_libs
3130 depPaths.RustRlibDeps = append(depPaths.RustRlibDeps, depExporterInfo.RustRlibDeps...)
3131
3132 if libDepTag.unexportedSymbols {
3133 depPaths.LdFlags = append(depPaths.LdFlags,
3134 "-Wl,--exclude-libs="+staticLibraryInfo.StaticLibrary.Base())
3135 }
Colin Cross3e5e7782022-06-17 22:17:05 +00003136 }
Inseob Kimeec88e12020-01-22 11:11:29 +09003137 }
3138
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003139 if libDepTag.static() && !libDepTag.wholeStatic && !ccDep.RustLibraryInterface() {
Colin Cross6e511a92020-07-27 21:26:48 -07003140 if !ccDep.CcLibraryInterface() || !ccDep.Static() {
3141 ctx.ModuleErrorf("module %q not a static library", depName)
3142 return
3143 }
Logan Chien43d34c32017-12-20 01:17:32 +08003144
Colin Cross6e511a92020-07-27 21:26:48 -07003145 // When combining coverage files for shared libraries and executables, coverage files
3146 // in static libraries act as if they were whole static libraries. The same goes for
3147 // source based Abi dump files.
3148 if c, ok := ccDep.(*Module); ok {
3149 staticLib := c.linker.(libraryInterface)
3150 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
3151 staticLib.objs().coverageFiles...)
3152 depPaths.StaticLibObjs.sAbiDumpFiles = append(depPaths.StaticLibObjs.sAbiDumpFiles,
3153 staticLib.objs().sAbiDumpFiles...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003154 } else {
Colin Cross6e511a92020-07-27 21:26:48 -07003155 // Handle non-CC modules here
3156 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
Colin Cross0de8a1e2020-09-18 14:15:30 -07003157 ccDep.CoverageFiles()...)
Jiyong Parkde866cb2018-12-07 23:08:36 +09003158 }
3159 }
3160
Colin Cross6e511a92020-07-27 21:26:48 -07003161 if ptr != nil {
3162 if !linkFile.Valid() {
3163 if !ctx.Config().AllowMissingDependencies() {
3164 ctx.ModuleErrorf("module %q missing output file", depName)
3165 } else {
3166 ctx.AddMissingDependencies([]string{depName})
3167 }
3168 return
3169 }
3170 *ptr = append(*ptr, linkFile.Path())
3171 }
3172
3173 if depPtr != nil {
3174 dep := depFile
3175 if !dep.Valid() {
3176 dep = linkFile
3177 }
3178 *depPtr = append(*depPtr, dep.Path())
3179 }
3180
Colin Cross0de8a1e2020-09-18 14:15:30 -07003181 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
3182 depPaths.SystemIncludeDirs = append(depPaths.SystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
3183 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps, depExporterInfo.Deps...)
3184 depPaths.Flags = append(depPaths.Flags, depExporterInfo.Flags...)
Ivan Lozano0a468a42024-05-13 21:03:34 -04003185 depPaths.RustRlibDeps = append(depPaths.RustRlibDeps, depExporterInfo.RustRlibDeps...)
3186
3187 // Only re-export RustRlibDeps for cc static libs
3188 if c.static() {
3189 depPaths.ReexportedRustRlibDeps = append(depPaths.ReexportedRustRlibDeps, depExporterInfo.RustRlibDeps...)
3190 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07003191
3192 if libDepTag.reexportFlags {
3193 reexportExporter(depExporterInfo)
3194 // Add these re-exported flags to help header-abi-dumper to infer the abi exported by a library.
3195 // Re-exported shared library headers must be included as well since they can help us with type information
3196 // about template instantiations (instantiated from their headers).
Colin Cross0de8a1e2020-09-18 14:15:30 -07003197 c.sabi.Properties.ReexportedIncludes = append(
3198 c.sabi.Properties.ReexportedIncludes, depExporterInfo.IncludeDirs.Strings()...)
Hsin-Yi Chen5f228b02024-04-02 12:38:47 +08003199 c.sabi.Properties.ReexportedSystemIncludes = append(
3200 c.sabi.Properties.ReexportedSystemIncludes, depExporterInfo.SystemIncludeDirs.Strings()...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003201 }
3202
Spandan Das3faa7922024-02-26 19:42:32 +00003203 makeLibName := MakeLibName(ctx, c, ccDep, ccDep.BaseModuleName()) + libDepTag.makeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003204 switch {
3205 case libDepTag.header():
Colin Cross370173e2020-07-29 12:48:33 -07003206 c.Properties.AndroidMkHeaderLibs = append(
3207 c.Properties.AndroidMkHeaderLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07003208 case libDepTag.shared():
Colin Cross31076b32020-10-23 17:22:06 -07003209 if lib := moduleLibraryInterface(dep); lib != nil {
3210 if lib.buildStubs() && dep.(android.ApexModule).InAnyApex() {
Colin Cross6e511a92020-07-27 21:26:48 -07003211 // Add the dependency to the APEX(es) providing the library so that
3212 // m <module> can trigger building the APEXes as well.
Colin Cross313aa542023-12-13 13:47:44 -08003213 depApexInfo, _ := android.OtherModuleProvider(ctx, dep, android.ApexInfoProvider)
Jiyong Parkab50b072021-05-12 17:13:56 +09003214 for _, an := range depApexInfo.InApexVariants {
Colin Cross6e511a92020-07-27 21:26:48 -07003215 c.Properties.ApexesProvidingSharedLibs = append(
3216 c.Properties.ApexesProvidingSharedLibs, an)
3217 }
3218 }
3219 }
3220
3221 // Note: the order of libs in this list is not important because
3222 // they merely serve as Make dependencies and do not affect this lib itself.
Colin Cross370173e2020-07-29 12:48:33 -07003223 c.Properties.AndroidMkSharedLibs = append(
3224 c.Properties.AndroidMkSharedLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07003225 case libDepTag.static():
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003226 if !ccDep.RustLibraryInterface() {
3227 if libDepTag.wholeStatic {
3228 c.Properties.AndroidMkWholeStaticLibs = append(
3229 c.Properties.AndroidMkWholeStaticLibs, makeLibName)
3230 } else {
3231 c.Properties.AndroidMkStaticLibs = append(
3232 c.Properties.AndroidMkStaticLibs, makeLibName)
3233 }
Colin Cross6e511a92020-07-27 21:26:48 -07003234 }
3235 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09003236 } else if !c.IsStubs() {
3237 // Stubs lib doesn't link to the runtime lib, object, crt, etc. dependencies.
3238
Colin Cross6e511a92020-07-27 21:26:48 -07003239 switch depTag {
3240 case runtimeDepTag:
3241 c.Properties.AndroidMkRuntimeLibs = append(
Spandan Das3faa7922024-02-26 19:42:32 +00003242 c.Properties.AndroidMkRuntimeLibs, MakeLibName(ctx, c, ccDep, ccDep.BaseModuleName())+libDepTag.makeSuffix)
Colin Cross6e511a92020-07-27 21:26:48 -07003243 case objDepTag:
3244 depPaths.Objs.objFiles = append(depPaths.Objs.objFiles, linkFile.Path())
3245 case CrtBeginDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003246 depPaths.CrtBegin = append(depPaths.CrtBegin, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003247 case CrtEndDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003248 depPaths.CrtEnd = append(depPaths.CrtEnd, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003249 case dynamicLinkerDepTag:
3250 depPaths.DynamicLinker = linkFile
3251 }
Jiyong Park27b188b2017-07-18 13:23:39 +09003252 }
Colin Crossca860ac2016-01-04 14:34:37 -08003253 })
3254
Jeff Gaston294356f2017-09-27 17:05:30 -07003255 // use the ordered dependencies as this module's dependencies
Colin Cross0de8a1e2020-09-18 14:15:30 -07003256 orderedStaticPaths, transitiveStaticLibs := orderStaticModuleDeps(directStaticDeps, directSharedDeps)
3257 depPaths.TranstiveStaticLibrariesForOrdering = transitiveStaticLibs
3258 depPaths.StaticLibs = append(depPaths.StaticLibs, orderedStaticPaths...)
Jeff Gaston294356f2017-09-27 17:05:30 -07003259
Colin Crossdd84e052017-05-17 13:44:16 -07003260 // Dedup exported flags from dependencies
Colin Crossb6715442017-10-24 11:13:31 -07003261 depPaths.Flags = android.FirstUniqueStrings(depPaths.Flags)
Jiyong Park74955042019-10-22 20:19:51 +09003262 depPaths.IncludeDirs = android.FirstUniquePaths(depPaths.IncludeDirs)
3263 depPaths.SystemIncludeDirs = android.FirstUniquePaths(depPaths.SystemIncludeDirs)
Inseob Kimd110f872019-12-06 13:15:38 +09003264 depPaths.GeneratedDeps = android.FirstUniquePaths(depPaths.GeneratedDeps)
Ivan Lozano0a468a42024-05-13 21:03:34 -04003265 depPaths.RustRlibDeps = android.FirstUniqueFunc(depPaths.RustRlibDeps, EqRustRlibDeps)
3266
Jiyong Park74955042019-10-22 20:19:51 +09003267 depPaths.ReexportedDirs = android.FirstUniquePaths(depPaths.ReexportedDirs)
3268 depPaths.ReexportedSystemDirs = android.FirstUniquePaths(depPaths.ReexportedSystemDirs)
Colin Crossb6715442017-10-24 11:13:31 -07003269 depPaths.ReexportedFlags = android.FirstUniqueStrings(depPaths.ReexportedFlags)
Inseob Kim69378442019-06-03 19:10:47 +09003270 depPaths.ReexportedDeps = android.FirstUniquePaths(depPaths.ReexportedDeps)
Inseob Kimd110f872019-12-06 13:15:38 +09003271 depPaths.ReexportedGeneratedHeaders = android.FirstUniquePaths(depPaths.ReexportedGeneratedHeaders)
Ivan Lozano0a468a42024-05-13 21:03:34 -04003272 depPaths.ReexportedRustRlibDeps = android.FirstUniqueFunc(depPaths.ReexportedRustRlibDeps, EqRustRlibDeps)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003273
3274 if c.sabi != nil {
Inseob Kim69378442019-06-03 19:10:47 +09003275 c.sabi.Properties.ReexportedIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedIncludes)
Hsin-Yi Chen5f228b02024-04-02 12:38:47 +08003276 c.sabi.Properties.ReexportedSystemIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedSystemIncludes)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003277 }
Colin Crossdd84e052017-05-17 13:44:16 -07003278
Colin Crossca860ac2016-01-04 14:34:37 -08003279 return depPaths
3280}
3281
Spandan Das604f3762023-03-16 22:51:40 +00003282func ShouldUseStubForApex(ctx android.ModuleContext, dep android.Module) bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09003283 depName := ctx.OtherModuleName(dep)
Jiyong Park7d55b612021-06-11 17:22:09 +09003284 thisModule, ok := ctx.Module().(android.ApexModule)
3285 if !ok {
3286 panic(fmt.Errorf("Not an APEX module: %q", ctx.ModuleName()))
3287 }
3288
Kiyoung Kimaa394802024-01-08 12:55:45 +09003289 inVendorOrProduct := false
Jiyong Park7d55b612021-06-11 17:22:09 +09003290 bootstrap := false
3291 if linkable, ok := ctx.Module().(LinkableInterface); !ok {
3292 panic(fmt.Errorf("Not a Linkable module: %q", ctx.ModuleName()))
3293 } else {
Kiyoung Kimaa394802024-01-08 12:55:45 +09003294 inVendorOrProduct = linkable.InVendorOrProduct()
Jiyong Park7d55b612021-06-11 17:22:09 +09003295 bootstrap = linkable.Bootstrap()
3296 }
3297
Colin Crossff694a82023-12-13 15:54:49 -08003298 apexInfo, _ := android.ModuleProvider(ctx, android.ApexInfoProvider)
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003299
3300 useStubs := false
3301
Kiyoung Kimaa394802024-01-08 12:55:45 +09003302 if lib := moduleLibraryInterface(dep); lib.buildStubs() && inVendorOrProduct { // LLNDK
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003303 if !apexInfo.IsForPlatform() {
3304 // For platform libraries, use current version of LLNDK
3305 // If this is for use_vendor apex we will apply the same rules
3306 // of apex sdk enforcement below to choose right version.
3307 useStubs = true
3308 }
3309 } else if apexInfo.IsForPlatform() || apexInfo.UsePlatformApis {
3310 // If not building for APEX or the containing APEX allows the use of
3311 // platform APIs, use stubs only when it is from an APEX (and not from
3312 // platform) However, for host, ramdisk, vendor_ramdisk, recovery or
3313 // bootstrap modules, always link to non-stub variant
3314 isNotInPlatform := dep.(android.ApexModule).NotInPlatform()
3315
Spandan Dasff665182024-09-11 18:48:44 +00003316 useStubs = isNotInPlatform && !bootstrap
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003317
3318 if useStubs {
3319 // Another exception: if this module is a test for an APEX, then
3320 // it is linked with the non-stub variant of a module in the APEX
3321 // as if this is part of the APEX.
Colin Crossff694a82023-12-13 15:54:49 -08003322 testFor, _ := android.ModuleProvider(ctx, android.ApexTestForInfoProvider)
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003323 for _, apexContents := range testFor.ApexContents {
3324 if apexContents.DirectlyInApex(depName) {
3325 useStubs = false
3326 break
3327 }
3328 }
3329 }
3330 if useStubs {
3331 // Yet another exception: If this module and the dependency are
3332 // available to the same APEXes then skip stubs between their
3333 // platform variants. This complements the test_for case above,
3334 // which avoids the stubs on a direct APEX library dependency, by
3335 // avoiding stubs for indirect test dependencies as well.
3336 //
3337 // TODO(b/183882457): This doesn't work if the two libraries have
3338 // only partially overlapping apex_available. For that test_for
3339 // modules would need to be split into APEX variants and resolved
3340 // separately for each APEX they have access to.
Spandan Dasff665182024-09-11 18:48:44 +00003341 if android.AvailableToSameApexes(thisModule, dep.(android.ApexModule)) {
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003342 useStubs = false
3343 }
3344 }
3345 } else {
3346 // If building for APEX, use stubs when the parent is in any APEX that
3347 // the child is not in.
3348 useStubs = !android.DirectlyInAllApexes(apexInfo, depName)
3349 }
3350
3351 return useStubs
3352}
3353
3354// ChooseStubOrImpl determines whether a given dependency should be redirected to the stub variant
3355// of the dependency or not, and returns the SharedLibraryInfo and FlagExporterInfo for the right
3356// dependency. The stub variant is selected when the dependency crosses a boundary where each side
3357// has different level of updatability. For example, if a library foo in an APEX depends on a
3358// library bar which provides stable interface and exists in the platform, foo uses the stub variant
3359// of bar. If bar doesn't provide a stable interface (i.e. buildStubs() == false) or is in the
3360// same APEX as foo, the non-stub variant of bar is used.
3361func ChooseStubOrImpl(ctx android.ModuleContext, dep android.Module) (SharedLibraryInfo, FlagExporterInfo) {
3362 depTag := ctx.OtherModuleDependencyTag(dep)
3363 libDepTag, ok := depTag.(libraryDependencyTag)
3364 if !ok || !libDepTag.shared() {
3365 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
3366 }
3367
Colin Cross313aa542023-12-13 13:47:44 -08003368 sharedLibraryInfo, _ := android.OtherModuleProvider(ctx, dep, SharedLibraryInfoProvider)
3369 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
3370 sharedLibraryStubsInfo, _ := android.OtherModuleProvider(ctx, dep, SharedLibraryStubsProvider)
Jiyong Park7d55b612021-06-11 17:22:09 +09003371
3372 if !libDepTag.explicitlyVersioned && len(sharedLibraryStubsInfo.SharedStubLibraries) > 0 {
Jiyong Park7d55b612021-06-11 17:22:09 +09003373 // when to use (unspecified) stubs, use the latest one.
Spandan Das604f3762023-03-16 22:51:40 +00003374 if ShouldUseStubForApex(ctx, dep) {
Jiyong Park7d55b612021-06-11 17:22:09 +09003375 stubs := sharedLibraryStubsInfo.SharedStubLibraries
3376 toUse := stubs[len(stubs)-1]
3377 sharedLibraryInfo = toUse.SharedLibraryInfo
3378 depExporterInfo = toUse.FlagExporterInfo
3379 }
3380 }
3381 return sharedLibraryInfo, depExporterInfo
3382}
3383
Colin Cross0de8a1e2020-09-18 14:15:30 -07003384// orderStaticModuleDeps rearranges the order of the static library dependencies of the module
3385// to match the topological order of the dependency tree, including any static analogues of
Colin Crossa14fb6a2024-10-23 16:57:06 -07003386// direct shared libraries. It returns the ordered static dependencies, and a depset.DepSet
Colin Cross0de8a1e2020-09-18 14:15:30 -07003387// of the transitive dependencies.
Colin Crossa14fb6a2024-10-23 16:57:06 -07003388func orderStaticModuleDeps(staticDeps []StaticLibraryInfo, sharedDeps []SharedLibraryInfo) (ordered android.Paths, transitive depset.DepSet[android.Path]) {
3389 transitiveStaticLibsBuilder := depset.NewBuilder[android.Path](depset.TOPOLOGICAL)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003390 var staticPaths android.Paths
3391 for _, staticDep := range staticDeps {
3392 staticPaths = append(staticPaths, staticDep.StaticLibrary)
3393 transitiveStaticLibsBuilder.Transitive(staticDep.TransitiveStaticLibrariesForOrdering)
3394 }
3395 for _, sharedDep := range sharedDeps {
Colin Crossa14fb6a2024-10-23 16:57:06 -07003396 transitiveStaticLibsBuilder.Transitive(sharedDep.TransitiveStaticLibrariesForOrdering)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003397 }
3398 transitiveStaticLibs := transitiveStaticLibsBuilder.Build()
3399
3400 orderedTransitiveStaticLibs := transitiveStaticLibs.ToList()
3401
3402 // reorder the dependencies based on transitive dependencies
3403 staticPaths = android.FirstUniquePaths(staticPaths)
3404 _, orderedStaticPaths := android.FilterPathList(orderedTransitiveStaticLibs, staticPaths)
3405
3406 if len(orderedStaticPaths) != len(staticPaths) {
3407 missing, _ := android.FilterPathList(staticPaths, orderedStaticPaths)
3408 panic(fmt.Errorf("expected %d ordered static paths , got %d, missing %q %q %q", len(staticPaths), len(orderedStaticPaths), missing, orderedStaticPaths, staticPaths))
3409 }
3410
3411 return orderedStaticPaths, transitiveStaticLibs
3412}
3413
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003414// BaseLibName trims known prefixes and suffixes
3415func BaseLibName(depName string) string {
Colin Cross6e511a92020-07-27 21:26:48 -07003416 libName := strings.TrimSuffix(depName, llndkLibrarySuffix)
3417 libName = strings.TrimSuffix(libName, vendorPublicLibrarySuffix)
Paul Duffind23c7262020-12-11 18:13:08 +00003418 libName = android.RemoveOptionalPrebuiltPrefix(libName)
Colin Cross6e511a92020-07-27 21:26:48 -07003419 return libName
3420}
3421
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003422func MakeLibName(ctx android.ModuleContext, c LinkableInterface, ccDep LinkableInterface, depName string) string {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003423 libName := BaseLibName(depName)
Colin Cross127bb8b2020-12-16 16:46:01 -08003424 ccDepModule, _ := ccDep.(*Module)
3425 isLLndk := ccDepModule != nil && ccDepModule.IsLlndk()
Justin Yuncbca3732021-02-03 19:24:13 +09003426 nonSystemVariantsExist := ccDep.HasNonSystemVariants() || isLLndk
Colin Cross6e511a92020-07-27 21:26:48 -07003427
Justin Yuncbca3732021-02-03 19:24:13 +09003428 if ccDepModule != nil {
Colin Cross6e511a92020-07-27 21:26:48 -07003429 // Use base module name for snapshots when exporting to Makefile.
Ivan Lozanod1dec542021-05-26 15:33:11 -04003430 if snapshotPrebuilt, ok := ccDepModule.linker.(SnapshotInterface); ok {
Justin Yuncbca3732021-02-03 19:24:13 +09003431 baseName := ccDepModule.BaseModuleName()
Colin Cross6e511a92020-07-27 21:26:48 -07003432
Ivan Lozanod1dec542021-05-26 15:33:11 -04003433 return baseName + snapshotPrebuilt.SnapshotAndroidMkSuffix()
Colin Cross6e511a92020-07-27 21:26:48 -07003434 }
3435 }
3436
Kiyoung Kim22152f62024-05-24 10:45:28 +09003437 if ccDep.InVendorOrProduct() && nonSystemVariantsExist {
Justin Yuncbca3732021-02-03 19:24:13 +09003438 // The vendor and product modules in Make will have been renamed to not conflict with the
3439 // core module, so update the dependency name here accordingly.
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003440 return libName + ccDep.SubName()
Colin Cross6e511a92020-07-27 21:26:48 -07003441 } else if ccDep.InRamdisk() && !ccDep.OnlyInRamdisk() {
Matthew Maurerc6868382021-07-13 14:12:37 -07003442 return libName + RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003443 } else if ccDep.InVendorRamdisk() && !ccDep.OnlyInVendorRamdisk() {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05003444 return libName + VendorRamdiskSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003445 } else if ccDep.InRecovery() && !ccDep.OnlyInRecovery() {
Matthew Maurer460ee942021-02-11 12:31:46 -08003446 return libName + RecoverySuffix
Ivan Lozanof9e21722020-12-02 09:00:51 -05003447 } else if ccDep.Target().NativeBridge == android.NativeBridgeEnabled {
Matthew Maurera61e31f2021-05-27 11:09:11 -07003448 return libName + NativeBridgeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003449 } else {
3450 return libName
3451 }
3452}
3453
Colin Crossca860ac2016-01-04 14:34:37 -08003454func (c *Module) InstallInData() bool {
3455 if c.installer == nil {
3456 return false
3457 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003458 return c.installer.inData()
3459}
3460
3461func (c *Module) InstallInSanitizerDir() bool {
3462 if c.installer == nil {
3463 return false
3464 }
3465 if c.sanitize != nil && c.sanitize.inSanitizerDir() {
Colin Cross94610402016-08-29 13:41:32 -07003466 return true
3467 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003468 return c.installer.inSanitizerDir()
Colin Crossca860ac2016-01-04 14:34:37 -08003469}
3470
Yifan Hong1b3348d2020-01-21 15:53:22 -08003471func (c *Module) InstallInRamdisk() bool {
3472 return c.InRamdisk()
3473}
3474
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003475func (c *Module) InstallInVendorRamdisk() bool {
3476 return c.InVendorRamdisk()
3477}
3478
Jiyong Parkf9332f12018-02-01 00:54:12 +09003479func (c *Module) InstallInRecovery() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07003480 return c.InRecovery()
Jiyong Parkf9332f12018-02-01 00:54:12 +09003481}
3482
Jingwen Chen8ac7d7d2023-03-20 11:05:16 +00003483func (c *Module) MakeUninstallable() {
3484 if c.installer == nil {
3485 c.ModuleBase.MakeUninstallable()
3486 return
3487 }
3488 c.installer.makeUninstallable(c)
3489}
3490
Dan Willemsen4aa75ca2016-09-28 16:18:03 -07003491func (c *Module) HostToolPath() android.OptionalPath {
3492 if c.installer == nil {
3493 return android.OptionalPath{}
3494 }
3495 return c.installer.hostToolPath()
3496}
3497
Nan Zhangd4e641b2017-07-12 12:55:28 -07003498func (c *Module) IntermPathForModuleOut() android.OptionalPath {
3499 return c.outputFile
3500}
3501
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00003502func (c *Module) static() bool {
3503 if static, ok := c.linker.(interface {
3504 static() bool
3505 }); ok {
3506 return static.static()
3507 }
3508 return false
3509}
3510
Jiyong Park379de2f2018-12-19 02:47:14 +09003511func (c *Module) staticBinary() bool {
3512 if static, ok := c.linker.(interface {
3513 staticBinary() bool
3514 }); ok {
3515 return static.staticBinary()
3516 }
3517 return false
3518}
3519
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07003520func (c *Module) testBinary() bool {
3521 if test, ok := c.linker.(interface {
3522 testBinary() bool
3523 }); ok {
3524 return test.testBinary()
3525 }
3526 return false
3527}
3528
Jingwen Chen537242c2022-08-24 11:53:27 +00003529func (c *Module) testLibrary() bool {
3530 if test, ok := c.linker.(interface {
3531 testLibrary() bool
3532 }); ok {
3533 return test.testLibrary()
3534 }
3535 return false
3536}
3537
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003538func (c *Module) benchmarkBinary() bool {
3539 if b, ok := c.linker.(interface {
3540 benchmarkBinary() bool
3541 }); ok {
3542 return b.benchmarkBinary()
3543 }
3544 return false
3545}
3546
3547func (c *Module) fuzzBinary() bool {
3548 if f, ok := c.linker.(interface {
3549 fuzzBinary() bool
3550 }); ok {
3551 return f.fuzzBinary()
3552 }
3553 return false
3554}
3555
Ivan Lozano3968d8f2020-12-14 11:27:52 -05003556// Header returns true if the module is a header-only variant. (See cc/library.go header()).
3557func (c *Module) Header() bool {
Jiyong Park1d1119f2019-07-29 21:27:18 +09003558 if h, ok := c.linker.(interface {
3559 header() bool
3560 }); ok {
3561 return h.header()
3562 }
3563 return false
3564}
3565
Ivan Lozanod7586b62021-04-01 09:49:36 -04003566func (c *Module) Binary() bool {
Inseob Kim7f283f42020-06-01 21:53:49 +09003567 if b, ok := c.linker.(interface {
3568 binary() bool
3569 }); ok {
3570 return b.binary()
3571 }
3572 return false
3573}
3574
Justin Yun5e035862021-06-29 20:50:37 +09003575func (c *Module) StaticExecutable() bool {
3576 if b, ok := c.linker.(*binaryDecorator); ok {
3577 return b.static()
3578 }
3579 return false
3580}
3581
Ivan Lozanod7586b62021-04-01 09:49:36 -04003582func (c *Module) Object() bool {
Inseob Kim1042d292020-06-01 23:23:05 +09003583 if o, ok := c.linker.(interface {
3584 object() bool
3585 }); ok {
3586 return o.object()
3587 }
3588 return false
3589}
3590
Kiyoung Kim37693d02024-04-04 09:56:15 +09003591func (m *Module) Dylib() bool {
3592 return false
3593}
3594
3595func (m *Module) Rlib() bool {
3596 return false
3597}
3598
Ivan Lozanof9e21722020-12-02 09:00:51 -05003599func GetMakeLinkType(actx android.ModuleContext, c LinkableInterface) string {
Kiyoung Kim8487c0b2024-01-11 16:03:13 +09003600 if c.InVendorOrProduct() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003601 if c.IsLlndk() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003602 return "native:vndk"
Jooyung Han38002912019-05-16 04:01:54 +09003603 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003604 if c.InProduct() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09003605 return "native:product"
3606 }
Jooyung Han38002912019-05-16 04:01:54 +09003607 return "native:vendor"
Yifan Hong1b3348d2020-01-21 15:53:22 -08003608 } else if c.InRamdisk() {
3609 return "native:ramdisk"
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003610 } else if c.InVendorRamdisk() {
3611 return "native:vendor_ramdisk"
Ivan Lozano52767be2019-10-18 14:49:46 -07003612 } else if c.InRecovery() {
Colin Crossb60190a2018-09-04 16:28:17 -07003613 return "native:recovery"
Ivan Lozanof9e21722020-12-02 09:00:51 -05003614 } else if c.Target().Os == android.Android && c.SdkVersion() != "" {
Colin Crossb60190a2018-09-04 16:28:17 -07003615 return "native:ndk:none:none"
3616 // TODO(b/114741097): use the correct ndk stl once build errors have been fixed
3617 //family, link := getNdkStlFamilyAndLinkType(c)
3618 //return fmt.Sprintf("native:ndk:%s:%s", family, link)
3619 } else {
3620 return "native:platform"
3621 }
3622}
3623
Jiyong Park9d452992018-10-03 00:38:19 +09003624// Overrides ApexModule.IsInstallabeToApex()
Colin Cross3a02c7b2024-05-21 13:46:22 -07003625// Only shared/runtime libraries .
Jiyong Park9d452992018-10-03 00:38:19 +09003626func (c *Module) IsInstallableToApex() bool {
Colin Cross31076b32020-10-23 17:22:06 -07003627 if lib := c.library; lib != nil {
Jiyong Park73c54ee2019-10-22 20:31:18 +09003628 // Stub libs and prebuilt libs in a versioned SDK are not
3629 // installable to APEX even though they are shared libs.
Paul Duffin458a15b2022-11-25 12:18:24 +00003630 return lib.shared() && !lib.buildStubs()
Jiyong Park9d452992018-10-03 00:38:19 +09003631 }
3632 return false
3633}
3634
Jiyong Parka90ca002019-10-07 15:47:24 +09003635func (c *Module) AvailableFor(what string) bool {
3636 if linker, ok := c.linker.(interface {
3637 availableFor(string) bool
3638 }); ok {
3639 return c.ApexModuleBase.AvailableFor(what) || linker.availableFor(what)
3640 } else {
3641 return c.ApexModuleBase.AvailableFor(what)
3642 }
3643}
3644
Jiyong Park62304bb2020-04-13 16:19:48 +09003645func (c *Module) TestFor() []string {
Jiyong Park46a512f2020-12-04 18:02:13 +09003646 return c.Properties.Test_for
Jiyong Park62304bb2020-04-13 16:19:48 +09003647}
3648
Paul Duffin0cb37b92020-03-04 14:52:46 +00003649func (c *Module) EverInstallable() bool {
3650 return c.installer != nil &&
3651 // Check to see whether the module is actually ever installable.
3652 c.installer.everInstallable()
3653}
3654
Ivan Lozanod7586b62021-04-01 09:49:36 -04003655func (c *Module) PreventInstall() bool {
3656 return c.Properties.PreventInstall
3657}
3658
3659func (c *Module) Installable() *bool {
Colin Cross1bc94122021-10-28 13:25:54 -07003660 if c.library != nil {
3661 if i := c.library.installable(); i != nil {
3662 return i
3663 }
3664 }
Ivan Lozanod7586b62021-04-01 09:49:36 -04003665 return c.Properties.Installable
3666}
3667
3668func installable(c LinkableInterface, apexInfo android.ApexInfo) bool {
Paul Duffin0cb37b92020-03-04 14:52:46 +00003669 ret := c.EverInstallable() &&
3670 // Check to see whether the module has been configured to not be installed.
Ivan Lozanod7586b62021-04-01 09:49:36 -04003671 proptools.BoolDefault(c.Installable(), true) &&
3672 !c.PreventInstall() && c.OutputFile().Valid()
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003673
3674 // The platform variant doesn't need further condition. Apex variants however might not
3675 // be installable because it will likely to be included in the APEX and won't appear
3676 // in the system partition.
Colin Cross56a83212020-09-15 18:30:11 -07003677 if apexInfo.IsForPlatform() {
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003678 return ret
3679 }
3680
3681 // Special case for modules that are configured to be installed to /data, which includes
3682 // test modules. For these modules, both APEX and non-APEX variants are considered as
3683 // installable. This is because even the APEX variants won't be included in the APEX, but
3684 // will anyway be installed to /data/*.
3685 // See b/146995717
3686 if c.InstallInData() {
3687 return ret
3688 }
3689
3690 return false
Inseob Kim1f086e22019-05-09 13:29:15 +09003691}
3692
Logan Chien41eabe62019-04-10 13:33:58 +08003693func (c *Module) AndroidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer) {
3694 if c.linker != nil {
3695 if library, ok := c.linker.(*libraryDecorator); ok {
3696 library.androidMkWriteAdditionalDependenciesForSourceAbiDiff(w)
3697 }
3698 }
3699}
3700
Jiyong Park45bf82e2020-12-15 22:29:02 +09003701var _ android.ApexModule = (*Module)(nil)
3702
3703// Implements android.ApexModule
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003704func (c *Module) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
Colin Cross6e511a92020-07-27 21:26:48 -07003705 depTag := ctx.OtherModuleDependencyTag(dep)
3706 libDepTag, isLibDepTag := depTag.(libraryDependencyTag)
3707
3708 if cc, ok := dep.(*Module); ok {
3709 if cc.HasStubsVariants() {
3710 if isLibDepTag && libDepTag.shared() {
3711 // dynamic dep to a stubs lib crosses APEX boundary
3712 return false
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003713 }
Colin Cross6e511a92020-07-27 21:26:48 -07003714 if IsRuntimeDepTag(depTag) {
3715 // runtime dep to a stubs lib also crosses APEX boundary
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003716 return false
3717 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003718 }
Zhijun Heec285872021-04-24 10:47:08 -07003719 if cc.IsLlndk() {
3720 return false
3721 }
Colin Crossaac32222020-07-29 12:51:56 -07003722 if isLibDepTag && c.static() && libDepTag.shared() {
Colin Cross6e511a92020-07-27 21:26:48 -07003723 // shared_lib dependency from a static lib is considered as crossing
3724 // the APEX boundary because the dependency doesn't actually is
3725 // linked; the dependency is used only during the compilation phase.
3726 return false
3727 }
Jiyong Parke3867542020-12-03 17:28:25 +09003728
3729 if isLibDepTag && libDepTag.excludeInApex {
3730 return false
3731 }
Colin Cross6e511a92020-07-27 21:26:48 -07003732 }
Colin Crossc1b36442021-05-06 13:42:48 -07003733 if depTag == stubImplDepTag {
3734 // We don't track from an implementation library to its stubs.
Jiyong Park7d95a512020-05-10 15:16:24 +09003735 return false
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003736 }
Jiyong Park12177fc2021-01-05 14:37:15 +09003737 if depTag == staticVariantTag {
3738 // This dependency is for optimization (reuse *.o from the static lib). It doesn't
3739 // actually mean that the static lib (and its dependencies) are copied into the
3740 // APEX.
3741 return false
3742 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003743 return true
3744}
3745
Jiyong Park45bf82e2020-12-15 22:29:02 +09003746// Implements android.ApexModule
Dan Albertc8060532020-07-22 22:32:17 -07003747func (c *Module) ShouldSupportSdkVersion(ctx android.BaseModuleContext,
3748 sdkVersion android.ApiLevel) error {
Jooyung Han749dc692020-04-15 11:03:39 +09003749 // We ignore libclang_rt.* prebuilt libs since they declare sdk_version: 14(b/121358700)
3750 if strings.HasPrefix(ctx.OtherModuleName(c), "libclang_rt") {
3751 return nil
3752 }
Jooyung Han749dc692020-04-15 11:03:39 +09003753 // We don't check for prebuilt modules
3754 if _, ok := c.linker.(prebuiltLinkerInterface); ok {
3755 return nil
3756 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09003757
Jooyung Han749dc692020-04-15 11:03:39 +09003758 minSdkVersion := c.MinSdkVersion()
3759 if minSdkVersion == "apex_inherit" {
3760 return nil
3761 }
3762 if minSdkVersion == "" {
3763 // JNI libs within APK-in-APEX fall into here
3764 // Those are okay to set sdk_version instead
3765 // We don't have to check if this is a SDK variant because
3766 // non-SDK variant resets sdk_version, which works too.
3767 minSdkVersion = c.SdkVersion()
3768 }
Dan Albertc8060532020-07-22 22:32:17 -07003769 if minSdkVersion == "" {
3770 return fmt.Errorf("neither min_sdk_version nor sdk_version specificed")
3771 }
3772 // Not using nativeApiLevelFromUser because the context here is not
3773 // necessarily a native context.
3774 ver, err := android.ApiLevelFromUser(ctx, minSdkVersion)
Jooyung Han749dc692020-04-15 11:03:39 +09003775 if err != nil {
3776 return err
3777 }
Dan Albertc8060532020-07-22 22:32:17 -07003778
Colin Cross8ca61c12022-10-06 21:00:14 -07003779 // A dependency only needs to support a min_sdk_version at least
3780 // as high as the api level that the architecture was introduced in.
3781 // This allows introducing new architectures in the platform that
3782 // need to be included in apexes that normally require an older
3783 // min_sdk_version.
Colin Crossbb137a32023-01-26 09:54:42 -08003784 minApiForArch := MinApiForArch(ctx, c.Target().Arch.ArchType)
Colin Cross8ca61c12022-10-06 21:00:14 -07003785 if sdkVersion.LessThan(minApiForArch) {
3786 sdkVersion = minApiForArch
3787 }
3788
Dan Albertc8060532020-07-22 22:32:17 -07003789 if ver.GreaterThan(sdkVersion) {
Jooyung Han749dc692020-04-15 11:03:39 +09003790 return fmt.Errorf("newer SDK(%v)", ver)
3791 }
3792 return nil
3793}
3794
Paul Duffinb5769c12021-05-12 16:16:51 +01003795// Implements android.ApexModule
3796func (c *Module) AlwaysRequiresPlatformApexVariant() bool {
3797 // stub libraries and native bridge libraries are always available to platform
3798 return c.IsStubs() || c.Target().NativeBridge == android.NativeBridgeEnabled
3799}
3800
Inseob Kima1888ce2022-10-04 14:42:02 +09003801func (c *Module) overriddenModules() []string {
3802 if o, ok := c.linker.(overridable); ok {
3803 return o.overriddenModules()
3804 }
3805 return nil
3806}
3807
Liz Kammer35ca77e2021-12-22 15:31:40 -05003808type moduleType int
3809
3810const (
3811 unknownType moduleType = iota
3812 binary
3813 object
3814 fullLibrary
3815 staticLibrary
3816 sharedLibrary
3817 headerLibrary
Jingwen Chen537242c2022-08-24 11:53:27 +00003818 testBin // testBinary already declared
Spandan Das1278c2c2022-08-19 18:17:28 +00003819 ndkLibrary
Liz Kammer35ca77e2021-12-22 15:31:40 -05003820)
3821
3822func (c *Module) typ() moduleType {
Jingwen Chen537242c2022-08-24 11:53:27 +00003823 if c.testBinary() {
3824 // testBinary is also a binary, so this comes before the c.Binary()
3825 // conditional. A testBinary has additional implicit dependencies and
3826 // other test-only semantics.
3827 return testBin
3828 } else if c.Binary() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003829 return binary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003830 } else if c.Object() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003831 return object
Jingwen Chen537242c2022-08-24 11:53:27 +00003832 } else if c.testLibrary() {
3833 // TODO(b/244431896) properly convert cc_test_library to its own macro. This
3834 // will let them add implicit compile deps on gtest, for example.
3835 //
Liz Kammerefc51d92023-04-21 15:11:25 -04003836 // For now, treat them as regular libraries.
3837 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003838 } else if c.CcLibrary() {
Chris Parsons58852a02021-12-09 18:10:18 -05003839 static := false
3840 shared := false
3841 if library, ok := c.linker.(*libraryDecorator); ok {
3842 static = library.MutatedProperties.BuildStatic
3843 shared = library.MutatedProperties.BuildShared
3844 } else if library, ok := c.linker.(*prebuiltLibraryLinker); ok {
3845 static = library.MutatedProperties.BuildStatic
3846 shared = library.MutatedProperties.BuildShared
3847 }
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003848 if static && shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003849 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003850 } else if !static && !shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003851 return headerLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003852 } else if static {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003853 return staticLibrary
3854 }
3855 return sharedLibrary
Spandan Das1278c2c2022-08-19 18:17:28 +00003856 } else if c.isNDKStubLibrary() {
3857 return ndkLibrary
Liz Kammer35ca77e2021-12-22 15:31:40 -05003858 }
3859 return unknownType
3860}
3861
Colin Crosscfad1192015-11-02 16:43:11 -08003862// Defaults
Colin Crossca860ac2016-01-04 14:34:37 -08003863type Defaults struct {
Colin Cross635c3b02016-05-18 15:37:25 -07003864 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -07003865 android.DefaultsModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +09003866 android.ApexModuleBase
Colin Crosscfad1192015-11-02 16:43:11 -08003867}
3868
Patrice Arrudac249c712019-03-19 17:00:29 -07003869// cc_defaults provides a set of properties that can be inherited by other cc
3870// modules. A module can use the properties from a cc_defaults using
3871// `defaults: ["<:default_module_name>"]`. Properties of both modules are
3872// merged (when possible) by prepending the default module's values to the
3873// depending module's values.
Colin Cross36242852017-06-23 15:06:31 -07003874func defaultsFactory() android.Module {
Colin Crosse1d764e2016-08-18 14:18:32 -07003875 return DefaultsFactory()
3876}
3877
Colin Cross36242852017-06-23 15:06:31 -07003878func DefaultsFactory(props ...interface{}) android.Module {
Colin Crossca860ac2016-01-04 14:34:37 -08003879 module := &Defaults{}
Colin Crosscfad1192015-11-02 16:43:11 -08003880
Colin Cross36242852017-06-23 15:06:31 -07003881 module.AddProperties(props...)
3882 module.AddProperties(
Colin Crossca860ac2016-01-04 14:34:37 -08003883 &BaseProperties{},
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003884 &VendorProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003885 &BaseCompilerProperties{},
3886 &BaseLinkerProperties{},
Paul Duffina37832a2019-07-18 12:31:26 +01003887 &ObjectLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003888 &LibraryProperties{},
Colin Crosse1bb5d02019-09-24 14:55:04 -07003889 &StaticProperties{},
3890 &SharedProperties{},
Colin Cross919281a2016-04-05 16:42:05 -07003891 &FlagExporterProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003892 &BinaryLinkerProperties{},
Trevor Radcliffef389cb42022-03-24 21:06:14 +00003893 &TestLinkerProperties{},
3894 &TestInstallerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003895 &TestBinaryProperties{},
Colin Cross43287652020-06-30 10:15:07 -07003896 &BenchmarkProperties{},
hamzehc0a671f2021-07-22 12:05:08 -07003897 &fuzz.FuzzProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003898 &StlProperties{},
Colin Cross16b23492016-01-06 14:41:07 -08003899 &SanitizeProperties{},
Colin Cross665dce92016-04-28 14:50:03 -07003900 &StripProperties{},
Dan Willemsen7424d612016-09-01 13:45:39 -07003901 &InstallerProperties{},
Dan Willemsena03cf6d2016-09-26 15:45:04 -07003902 &TidyProperties{},
Dan Willemsen581341d2017-02-09 16:16:31 -08003903 &CoverageProperties{},
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08003904 &SAbiProperties{},
Stephen Craneba090d12017-05-09 15:44:35 -07003905 &LTOProperties{},
Yi Kongeb8efc92021-12-09 18:06:29 +08003906 &AfdoProperties{},
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00003907 &OrderfileProperties{},
Dan Willemsen6424d172018-03-08 13:27:59 -08003908 &android.ProtoProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -04003909 // RustBindgenProperties is included here so that cc_defaults can be used for rust_bindgen modules.
3910 &RustBindgenClangProperties{},
Yu-Chi Cheng24b2b0f2021-06-23 15:56:39 -07003911 &prebuiltLinkerProperties{},
Colin Crosse1d764e2016-08-18 14:18:32 -07003912 )
Colin Crosscfad1192015-11-02 16:43:11 -08003913
Jooyung Hancc372c52019-09-25 15:18:44 +09003914 android.InitDefaultsModule(module)
Colin Cross36242852017-06-23 15:06:31 -07003915
3916 return module
Colin Crosscfad1192015-11-02 16:43:11 -08003917}
3918
Jiyong Park2286afd2020-06-16 21:58:53 +09003919func (c *Module) IsSdkVariant() bool {
Lukacs T. Berki2063a0d2021-06-17 09:32:36 +02003920 return c.Properties.IsSdkVariant
Jiyong Park2286afd2020-06-16 21:58:53 +09003921}
3922
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003923func kytheExtractAllFactory() android.Singleton {
3924 return &kytheExtractAllSingleton{}
3925}
3926
3927type kytheExtractAllSingleton struct {
3928}
3929
3930func (ks *kytheExtractAllSingleton) GenerateBuildActions(ctx android.SingletonContext) {
3931 var xrefTargets android.Paths
3932 ctx.VisitAllModules(func(module android.Module) {
3933 if ccModule, ok := module.(xref); ok {
3934 xrefTargets = append(xrefTargets, ccModule.XrefCcFiles()...)
3935 }
3936 })
3937 // TODO(asmundak): Perhaps emit a rule to output a warning if there were no xrefTargets
3938 if len(xrefTargets) > 0 {
Colin Crossc3d87d32020-06-04 13:25:17 -07003939 ctx.Phony("xref_cxx", xrefTargets...)
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003940 }
3941}
3942
Jihoon Kangf78a8902022-09-01 22:47:07 +00003943func (c *Module) Partition() string {
3944 if p, ok := c.installer.(interface {
3945 getPartition() string
3946 }); ok {
3947 return p.getPartition()
3948 }
3949 return ""
3950}
3951
Spandan Das2b6dfb52024-01-19 00:22:22 +00003952type sourceModuleName interface {
3953 sourceModuleName() string
3954}
3955
3956func (c *Module) BaseModuleName() string {
3957 if smn, ok := c.linker.(sourceModuleName); ok && smn.sourceModuleName() != "" {
3958 // if the prebuilt module sets a source_module_name in Android.bp, use that
3959 return smn.sourceModuleName()
3960 }
3961 return c.ModuleBase.BaseModuleName()
3962}
3963
Spandan Dase20c56c2024-07-23 21:34:24 +00003964func (c *Module) stubsSymbolFilePath() android.Path {
3965 if library, ok := c.linker.(*libraryDecorator); ok {
3966 return library.stubsSymbolFilePath
3967 }
3968 return android.OptionalPath{}.Path()
3969}
3970
Colin Cross06a931b2015-10-28 17:23:31 -07003971var Bool = proptools.Bool
Colin Cross38b40df2018-04-10 16:14:46 -07003972var BoolDefault = proptools.BoolDefault
Nan Zhang0007d812017-11-07 10:57:05 -08003973var BoolPtr = proptools.BoolPtr
3974var String = proptools.String
3975var StringPtr = proptools.StringPtr