blob: 4b2b41771127ff1733f869d91a770259a284559b [file] [log] [blame]
Colin Cross5049f022015-03-18 13:28:46 -07001// Copyright 2015 Google Inc. All rights reserved.
Colin Cross3f40fa42015-01-30 17:27:36 -08002//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15package cc
16
17// This file contains the module types for compiling C/C++ for Android, and converts the properties
18// into the flags and filenames necessary to pass to the compiler. The final creation of the rules
19// is handled in builder.go
20
21import (
Colin Cross41955e82019-05-29 14:40:35 -070022 "fmt"
Logan Chien41eabe62019-04-10 13:33:58 +080023 "io"
Dan Albert9e10cd42016-08-03 14:12:14 -070024 "strconv"
Colin Cross3f40fa42015-01-30 17:27:36 -080025 "strings"
26
Aditya Choudhary87b2ab22023-11-17 15:27:06 +000027 "android/soong/testing"
Kiyoung Kimb5fdb2e2024-01-03 14:24:34 +090028
Colin Cross97ba0732015-03-23 17:50:24 -070029 "github.com/google/blueprint"
Colin Crossa14fb6a2024-10-23 16:57:06 -070030 "github.com/google/blueprint/depset"
Colin Cross06a931b2015-10-28 17:23:31 -070031 "github.com/google/blueprint/proptools"
Colin Cross97ba0732015-03-23 17:50:24 -070032
Vinh Tran367d89d2023-04-28 11:21:25 -040033 "android/soong/aidl_library"
Colin Cross635c3b02016-05-18 15:37:25 -070034 "android/soong/android"
Colin Crossb98c8b02016-07-29 13:44:28 -070035 "android/soong/cc/config"
hamzehc0a671f2021-07-22 12:05:08 -070036 "android/soong/fuzz"
Colin Cross5049f022015-03-18 13:28:46 -070037 "android/soong/genrule"
Colin Cross3f40fa42015-01-30 17:27:36 -080038)
39
Colin Cross463a90e2015-06-17 14:20:06 -070040func init() {
Paul Duffin036e7002019-12-19 19:16:28 +000041 RegisterCCBuildComponents(android.InitRegistrationContext)
Colin Cross463a90e2015-06-17 14:20:06 -070042
Inseob Kim3b244062023-07-11 13:31:36 +090043 pctx.Import("android/soong/android")
Paul Duffin036e7002019-12-19 19:16:28 +000044 pctx.Import("android/soong/cc/config")
45}
46
47func RegisterCCBuildComponents(ctx android.RegistrationContext) {
48 ctx.RegisterModuleType("cc_defaults", defaultsFactory)
49
50 ctx.PreDepsMutators(func(ctx android.RegisterMutatorsContext) {
Colin Crossac57a6c2024-06-26 13:09:53 -070051 ctx.Transition("sdk", &sdkTransitionMutator{})
Colin Cross8a962802024-10-09 15:29:27 -070052 ctx.BottomUp("llndk", llndkMutator)
Colin Cross767819f2024-05-22 14:22:34 -070053 ctx.Transition("link", &linkageTransitionMutator{})
Colin Crossadd04a82024-05-22 09:57:59 -070054 ctx.Transition("version", &versionTransitionMutator{})
Colin Cross8a962802024-10-09 15:29:27 -070055 ctx.BottomUp("begin", BeginMutator)
Colin Cross1e676be2016-10-12 14:38:15 -070056 })
Colin Cross16b23492016-01-06 14:41:07 -080057
Paul Duffin036e7002019-12-19 19:16:28 +000058 ctx.PostDepsMutators(func(ctx android.RegisterMutatorsContext) {
Liz Kammer75db9312021-07-07 16:41:50 -040059 for _, san := range Sanitizers {
60 san.registerMutators(ctx)
61 }
Dan Willemsen581341d2017-02-09 16:16:31 -080062
Colin Cross8a962802024-10-09 15:29:27 -070063 ctx.BottomUp("sanitize_runtime_deps", sanitizerRuntimeDepsMutator)
64 ctx.BottomUp("sanitize_runtime", sanitizerRuntimeMutator)
Ivan Lozano30c5db22018-02-21 15:49:20 -080065
Colin Cross597bad62024-10-08 15:10:55 -070066 ctx.Transition("fuzz", &fuzzTransitionMutator{})
Cory Barkera1da26f2022-06-07 20:12:06 +000067
Colin Crossf5f4ad32024-01-19 15:41:48 -080068 ctx.Transition("coverage", &coverageTransitionMutator{})
Stephen Craneba090d12017-05-09 15:44:35 -070069
Colin Crossd38feb02024-01-23 16:38:06 -080070 ctx.Transition("afdo", &afdoTransitionMutator{})
Yi Kongeb8efc92021-12-09 18:06:29 +080071
Colin Cross33e0c812024-01-23 16:36:07 -080072 ctx.Transition("orderfile", &orderfileTransitionMutator{})
Sharjeel Khanc6a93d82023-07-18 21:01:11 +000073
Colin Cross6ac83a82024-01-23 11:23:10 -080074 ctx.Transition("lto", &ltoTransitionMutator{})
Jooyung Hana70f0672019-01-18 15:20:43 +090075
Colin Cross8a962802024-10-09 15:29:27 -070076 ctx.BottomUp("check_linktype", checkLinkTypeMutator)
77 ctx.BottomUp("double_loadable", checkDoubleLoadableLibraries)
Colin Cross1e676be2016-10-12 14:38:15 -070078 })
Colin Crossb98c8b02016-07-29 13:44:28 -070079
Colin Cross91ae5ec2024-10-01 14:03:40 -070080 ctx.PostApexMutators(func(ctx android.RegisterMutatorsContext) {
Yo Chiang8aa4e3f2020-11-19 16:30:49 +080081 // sabi mutator needs to be run after apex mutator finishes.
Colin Cross91ae5ec2024-10-01 14:03:40 -070082 ctx.Transition("sabi", &sabiTransitionMutator{})
Yo Chiang8aa4e3f2020-11-19 16:30:49 +080083 })
84
LaMont Jones0c10e4d2023-05-16 00:58:37 +000085 ctx.RegisterParallelSingletonType("kythe_extract_all", kytheExtractAllFactory)
Colin Cross463a90e2015-06-17 14:20:06 -070086}
87
Chris Parsonsef6e0cf2020-12-01 18:26:21 -050088// Deps is a struct containing module names of dependencies, separated by the kind of dependency.
89// Mutators should use `AddVariationDependencies` or its sibling methods to add actual dependency
90// edges to these modules.
91// This object is constructed in DepsMutator, by calling to various module delegates to set
92// relevant fields. For example, `module.compiler.compilerDeps()` may append type-specific
93// dependencies.
94// This is then consumed by the same DepsMutator, which will call `ctx.AddVariationDependencies()`
95// (or its sibling methods) to set real dependencies on the given modules.
Colin Crossca860ac2016-01-04 14:34:37 -080096type Deps struct {
97 SharedLibs, LateSharedLibs []string
98 StaticLibs, LateStaticLibs, WholeStaticLibs []string
Colin Cross5950f382016-12-13 12:50:57 -080099 HeaderLibs []string
Logan Chien43d34c32017-12-20 01:17:32 +0800100 RuntimeLibs []string
Colin Crossc472d572015-03-17 15:06:21 -0700101
Colin Cross3e5e7782022-06-17 22:17:05 +0000102 // UnexportedStaticLibs are static libraries that are also passed to -Wl,--exclude-libs= to
103 // prevent automatically exporting symbols.
104 UnexportedStaticLibs []string
105
Chris Parsons79d66a52020-06-05 17:26:16 -0400106 // Used for data dependencies adjacent to tests
107 DataLibs []string
Colin Crossc8caa062021-09-24 16:50:14 -0700108 DataBins []string
Chris Parsons79d66a52020-06-05 17:26:16 -0400109
Yo Chiang219968c2020-09-22 18:45:04 +0800110 // Used by DepsMutator to pass system_shared_libs information to check_elf_file.py.
111 SystemSharedLibs []string
112
Vinh Tran367d89d2023-04-28 11:21:25 -0400113 // Used by DepMutator to pass aidl_library modules to aidl compiler
114 AidlLibs []string
115
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500116 // If true, statically link the unwinder into native libraries/binaries.
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800117 StaticUnwinderIfLegacy bool
118
Colin Cross5950f382016-12-13 12:50:57 -0800119 ReexportSharedLibHeaders, ReexportStaticLibHeaders, ReexportHeaderLibHeaders []string
Dan Willemsen490a8dc2016-06-06 18:22:19 -0700120
Colin Cross81413472016-04-11 14:37:39 -0700121 ObjFiles []string
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700122
Dan Willemsenb40aab62016-04-20 14:21:14 -0700123 GeneratedSources []string
124 GeneratedHeaders []string
Inseob Kimd110f872019-12-06 13:15:38 +0900125 GeneratedDeps []string
Dan Willemsenb40aab62016-04-20 14:21:14 -0700126
Dan Willemsenb3454ab2016-09-28 17:34:58 -0700127 ReexportGeneratedHeaders []string
128
Colin Crossc465efd2021-06-11 18:00:04 -0700129 CrtBegin, CrtEnd []string
Dan Willemsena0790e32018-10-12 00:24:23 -0700130
131 // Used for host bionic
Colin Cross9cfe6112021-06-11 18:02:22 -0700132 DynamicLinker string
Jiyong Parke3867542020-12-03 17:28:25 +0900133
134 // List of libs that need to be excluded for APEX variant
135 ExcludeLibsForApex []string
Jooyung Han9ffbe832023-11-28 22:31:35 +0900136 // List of libs that need to be excluded for non-APEX variant
137 ExcludeLibsForNonApex []string
Hsin-Yi Chen715142a2024-03-27 16:31:16 +0800138
139 // LLNDK headers for the ABI checker to check LLNDK implementation library.
140 // An LLNDK implementation is the core variant. LLNDK header libs are reexported by the vendor variant.
Colin Cross1e954b62024-09-13 13:50:00 -0700141 // The core variant cannot depend on the vendor variant because of the order of imageTransitionMutator.Split().
Hsin-Yi Chen715142a2024-03-27 16:31:16 +0800142 // Instead, the LLNDK implementation depends on the LLNDK header libs.
143 LlndkHeaderLibs []string
Colin Crossc472d572015-03-17 15:06:21 -0700144}
145
Ivan Lozano0a468a42024-05-13 21:03:34 -0400146// A struct which to collect flags for rlib dependencies
147type RustRlibDep struct {
148 LibPath android.Path // path to the rlib
149 LinkDirs []string // flags required for dependency (e.g. -L flags)
150 CrateName string // crateNames associated with rlibDeps
151}
152
153func EqRustRlibDeps(a RustRlibDep, b RustRlibDep) bool {
154 return a.LibPath == b.LibPath
155}
156
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500157// PathDeps is a struct containing file paths to dependencies of a module.
158// It's constructed in depsToPath() by traversing the direct dependencies of the current module.
159// It's used to construct flags for various build statements (such as for compiling and linking).
160// It is then passed to module decorator functions responsible for registering build statements
161// (such as `module.compiler.compile()`).`
Colin Crossca860ac2016-01-04 14:34:37 -0800162type PathDeps struct {
Colin Cross26c34ed2016-09-30 17:10:16 -0700163 // Paths to .so files
Jiyong Park64a44f22019-01-18 14:37:08 +0900164 SharedLibs, EarlySharedLibs, LateSharedLibs android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700165 // Paths to the dependencies to use for .so files (.so.toc files)
Jiyong Park64a44f22019-01-18 14:37:08 +0900166 SharedLibsDeps, EarlySharedLibsDeps, LateSharedLibsDeps android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700167 // Paths to .a files
Colin Cross635c3b02016-05-18 15:37:25 -0700168 StaticLibs, LateStaticLibs, WholeStaticLibs android.Paths
Ivan Lozano0a468a42024-05-13 21:03:34 -0400169 // Paths and crateNames for RustStaticLib dependencies
170 RustRlibDeps []RustRlibDep
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700171
Colin Cross0de8a1e2020-09-18 14:15:30 -0700172 // Transitive static library dependencies of static libraries for use in ordering.
Colin Crossa14fb6a2024-10-23 16:57:06 -0700173 TranstiveStaticLibrariesForOrdering depset.DepSet[android.Path]
Colin Cross0de8a1e2020-09-18 14:15:30 -0700174
Colin Cross26c34ed2016-09-30 17:10:16 -0700175 // Paths to .o files
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100176 Objs Objects
177 // Paths to .o files in dependencies that provide them. Note that these lists
178 // aren't complete since prebuilt modules don't provide the .o files.
Dan Willemsen581341d2017-02-09 16:16:31 -0800179 StaticLibObjs Objects
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700180 WholeStaticLibObjs Objects
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700181
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100182 // Paths to .a files in prebuilts. Complements WholeStaticLibObjs to contain
183 // the libs from all whole_static_lib dependencies.
184 WholeStaticLibsFromPrebuilts android.Paths
185
Colin Cross26c34ed2016-09-30 17:10:16 -0700186 // Paths to generated source files
Colin Cross635c3b02016-05-18 15:37:25 -0700187 GeneratedSources android.Paths
Inseob Kimd110f872019-12-06 13:15:38 +0900188 GeneratedDeps android.Paths
Dan Willemsenb40aab62016-04-20 14:21:14 -0700189
Inseob Kimd110f872019-12-06 13:15:38 +0900190 Flags []string
Colin Cross3e5e7782022-06-17 22:17:05 +0000191 LdFlags []string
Inseob Kimd110f872019-12-06 13:15:38 +0900192 IncludeDirs android.Paths
193 SystemIncludeDirs android.Paths
194 ReexportedDirs android.Paths
195 ReexportedSystemDirs android.Paths
196 ReexportedFlags []string
197 ReexportedGeneratedHeaders android.Paths
198 ReexportedDeps android.Paths
Ivan Lozano0a468a42024-05-13 21:03:34 -0400199 ReexportedRustRlibDeps []RustRlibDep
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700200
Colin Cross26c34ed2016-09-30 17:10:16 -0700201 // Paths to crt*.o files
Colin Crossc465efd2021-06-11 18:00:04 -0700202 CrtBegin, CrtEnd android.Paths
Dan Willemsena0790e32018-10-12 00:24:23 -0700203
Dan Willemsena0790e32018-10-12 00:24:23 -0700204 // Path to the dynamic linker binary
205 DynamicLinker android.OptionalPath
Dan Willemsen47450072021-10-19 20:24:49 -0700206
207 // For Darwin builds, the path to the second architecture's output that should
208 // be combined with this architectures's output into a FAT MachO file.
209 DarwinSecondArchOutput android.OptionalPath
Vinh Tran367d89d2023-04-28 11:21:25 -0400210
211 // Paths to direct srcs and transitive include dirs from direct aidl_library deps
212 AidlLibraryInfos []aidl_library.AidlLibraryInfo
Hsin-Yi Chen715142a2024-03-27 16:31:16 +0800213
214 // LLNDK headers for the ABI checker to check LLNDK implementation library.
215 LlndkIncludeDirs android.Paths
216 LlndkSystemIncludeDirs android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700217}
218
Colin Cross4af21ed2019-11-04 09:37:55 -0800219// LocalOrGlobalFlags contains flags that need to have values set globally by the build system or locally by the module
220// tracked separately, in order to maintain the required ordering (most of the global flags need to go first on the
221// command line so they can be overridden by the local module flags).
222type LocalOrGlobalFlags struct {
223 CommonFlags []string // Flags that apply to C, C++, and assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700224 AsFlags []string // Flags that apply to assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800225 YasmFlags []string // Flags that apply to yasm assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700226 CFlags []string // Flags that apply to C and C++ source files
227 ToolingCFlags []string // Flags that apply to C and C++ source files parsed by clang LibTooling tools
228 ConlyFlags []string // Flags that apply to C source files
229 CppFlags []string // Flags that apply to C++ source files
230 ToolingCppFlags []string // Flags that apply to C++ source files parsed by clang LibTooling tools
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700231 LdFlags []string // Flags that apply to linker command lines
Colin Cross4af21ed2019-11-04 09:37:55 -0800232}
233
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500234// Flags contains various types of command line flags (and settings) for use in building build
235// statements related to C++.
Colin Cross4af21ed2019-11-04 09:37:55 -0800236type Flags struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500237 // Local flags (which individual modules are responsible for). These may override global flags.
238 Local LocalOrGlobalFlags
239 // Global flags (which build system or toolchain is responsible for).
Luis Useche342fa6b2024-04-01 19:33:18 -0700240 Global LocalOrGlobalFlags
241 NoOverrideFlags []string // Flags applied to the end of list of flags so they are not overridden
Colin Cross4af21ed2019-11-04 09:37:55 -0800242
243 aidlFlags []string // Flags that apply to aidl source files
244 rsFlags []string // Flags that apply to renderscript source files
245 libFlags []string // Flags to add libraries early to the link order
246 extraLibFlags []string // Flags to add libraries late in the link order after LdFlags
247 TidyFlags []string // Flags that apply to clang-tidy
248 SAbiFlags []string // Flags that apply to header-abi-dumper
Colin Cross28344522015-04-22 13:07:53 -0700249
Colin Crossc3199482017-03-30 15:03:04 -0700250 // Global include flags that apply to C, C++, and assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800251 // These must be after any module include flags, which will be in CommonFlags.
Colin Crossc3199482017-03-30 15:03:04 -0700252 SystemIncludeFlags []string
253
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800254 Toolchain config.Toolchain
255 Tidy bool // True if ninja .tidy rules should be generated.
256 NeedTidyFiles bool // True if module link should depend on .tidy files
257 GcovCoverage bool // True if coverage files should be generated.
258 SAbiDump bool // True if header abi dumps should be generated.
259 EmitXrefs bool // If true, generate Ninja rules to generate emitXrefs input files for Kythe
kellyhungd62ea302024-05-19 21:16:07 +0800260 ClangVerify bool // If true, append cflags "-Xclang -verify" and append "&& touch $out" to the clang command line.
Colin Crossca860ac2016-01-04 14:34:37 -0800261
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500262 // The instruction set required for clang ("arm" or "thumb").
Colin Crossca860ac2016-01-04 14:34:37 -0800263 RequiredInstructionSet string
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500264 // The target-device system path to the dynamic linker.
265 DynamicLinker string
Colin Cross16b23492016-01-06 14:41:07 -0800266
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700267 CFlagsDeps android.Paths // Files depended on by compiler flags
268 LdFlagsDeps android.Paths // Files depended on by linker flags
Colin Cross18c0c5a2016-12-01 14:45:23 -0800269
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500270 // True if .s files should be processed with the c preprocessor.
Dan Willemsen98ab3112019-08-27 21:20:40 -0700271 AssemblerWithCpp bool
Dan Willemsen60e62f02018-11-16 21:05:32 -0800272
Colin Cross19878da2019-03-28 14:45:07 -0700273 proto android.ProtoFlags
Colin Cross19878da2019-03-28 14:45:07 -0700274 protoC bool // Whether to use C instead of C++
275 protoOptionsFile bool // Whether to look for a .options file next to the .proto
Dan Willemsen4e0aa232019-04-10 22:59:54 -0700276
277 Yacc *YaccProperties
Matthias Maennich22fd4d12020-07-15 10:58:56 +0200278 Lex *LexProperties
Colin Crossc472d572015-03-17 15:06:21 -0700279}
280
Colin Crossca860ac2016-01-04 14:34:37 -0800281// Properties used to compile all C or C++ modules
282type BaseProperties struct {
Dan Willemsen742a5452018-07-23 17:19:36 -0700283 // Deprecated. true is the default, false is invalid.
Colin Crossca860ac2016-01-04 14:34:37 -0800284 Clang *bool `android:"arch_variant"`
Colin Cross7d5136f2015-05-11 13:39:40 -0700285
Yi Kong5786f5c2024-05-28 02:22:34 +0900286 // Aggresively trade performance for smaller binary size.
287 // This should only be used for on-device binaries that are rarely executed and not
288 // performance critical.
289 Optimize_for_size *bool `android:"arch_variant"`
290
Jiyong Parkb35a8192020-08-10 15:59:36 +0900291 // The API level that this module is built against. The APIs of this API level will be
292 // visible at build time, but use of any APIs newer than min_sdk_version will render the
293 // module unloadable on older devices. In the future it will be possible to weakly-link new
294 // APIs, making the behavior match Java: such modules will load on older devices, but
295 // calling new APIs on devices that do not support them will result in a crash.
296 //
297 // This property has the same behavior as sdk_version does for Java modules. For those
298 // familiar with Android Gradle, the property behaves similarly to how compileSdkVersion
299 // does for Java code.
300 //
301 // In addition, setting this property causes two variants to be built, one for the platform
302 // and one for apps.
Nan Zhang0007d812017-11-07 10:57:05 -0800303 Sdk_version *string
Colin Cross7d5136f2015-05-11 13:39:40 -0700304
Jiyong Parkb35a8192020-08-10 15:59:36 +0900305 // Minimum OS API level supported by this C or C++ module. This property becomes the value
306 // of the __ANDROID_API__ macro. When the C or C++ module is included in an APEX or an APK,
307 // this property is also used to ensure that the min_sdk_version of the containing module is
308 // not older (i.e. less) than this module's min_sdk_version. When not set, this property
309 // defaults to the value of sdk_version. When this is set to "apex_inherit", this tracks
310 // min_sdk_version of the containing APEX. When the module
311 // is not built for an APEX, "apex_inherit" defaults to sdk_version.
Jooyung Han379660c2020-04-21 15:24:00 +0900312 Min_sdk_version *string
313
Colin Crossc511bc52020-04-07 16:50:32 +0000314 // If true, always create an sdk variant and don't create a platform variant.
315 Sdk_variant_only *bool
316
Jiyong Parkde866cb2018-12-07 23:08:36 +0900317 AndroidMkSharedLibs []string `blueprint:"mutated"`
318 AndroidMkStaticLibs []string `blueprint:"mutated"`
Ivan Lozano0a468a42024-05-13 21:03:34 -0400319 AndroidMkRlibs []string `blueprint:"mutated"`
Jiyong Parkde866cb2018-12-07 23:08:36 +0900320 AndroidMkRuntimeLibs []string `blueprint:"mutated"`
321 AndroidMkWholeStaticLibs []string `blueprint:"mutated"`
Bill Peckhama46de702020-04-21 17:23:37 -0700322 AndroidMkHeaderLibs []string `blueprint:"mutated"`
Jiyong Parkde866cb2018-12-07 23:08:36 +0900323 HideFromMake bool `blueprint:"mutated"`
324 PreventInstall bool `blueprint:"mutated"`
325 ApexesProvidingSharedLibs []string `blueprint:"mutated"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700326
Yo Chiang219968c2020-09-22 18:45:04 +0800327 // Set by DepsMutator.
328 AndroidMkSystemSharedLibs []string `blueprint:"mutated"`
329
Kiyoung Kimb5fdb2e2024-01-03 14:24:34 +0900330 // The name of the image this module is built for
331 ImageVariation string `blueprint:"mutated"`
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200332
333 // The VNDK version this module is built against. If empty, the module is not
334 // build against the VNDK.
335 VndkVersion string `blueprint:"mutated"`
336
337 // Suffix for the name of Android.mk entries generated by this module
338 SubName string `blueprint:"mutated"`
Colin Cross5beccee2017-12-07 15:28:59 -0800339
340 // *.logtags files, to combine together in order to generate the /system/etc/event-log-tags
341 // file
Inseob Kim37e0bb02024-04-29 15:54:44 +0900342 Logtags []string `android:"path"`
Jiyong Parkf9332f12018-02-01 00:54:12 +0900343
Yifan Hong39143a92020-10-26 12:43:12 -0700344 // Make this module available when building for ramdisk.
345 // On device without a dedicated recovery partition, the module is only
346 // available after switching root into
347 // /first_stage_ramdisk. To expose the module before switching root, install
348 // the recovery variant instead.
Yifan Hong1b3348d2020-01-21 15:53:22 -0800349 Ramdisk_available *bool
350
Yifan Hong39143a92020-10-26 12:43:12 -0700351 // Make this module available when building for vendor ramdisk.
352 // On device without a dedicated recovery partition, the module is only
353 // available after switching root into
354 // /first_stage_ramdisk. To expose the module before switching root, install
355 // the recovery variant instead.
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700356 Vendor_ramdisk_available *bool
357
Jiyong Parkf9332f12018-02-01 00:54:12 +0900358 // Make this module available when building for recovery
359 Recovery_available *bool
360
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200361 // Used by imageMutator, set by ImageMutatorBegin()
Jihoon Kang47e91842024-06-19 00:51:16 +0000362 VendorVariantNeeded bool `blueprint:"mutated"`
363 ProductVariantNeeded bool `blueprint:"mutated"`
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200364 CoreVariantNeeded bool `blueprint:"mutated"`
365 RamdiskVariantNeeded bool `blueprint:"mutated"`
366 VendorRamdiskVariantNeeded bool `blueprint:"mutated"`
367 RecoveryVariantNeeded bool `blueprint:"mutated"`
368
369 // A list of variations for the "image" mutator of the form
370 //<image name> '.' <version char>, for example, 'vendor.S'
371 ExtraVersionedImageVariations []string `blueprint:"mutated"`
Jiyong Parkb0788572018-12-20 22:10:17 +0900372
373 // Allows this module to use non-APEX version of libraries. Useful
374 // for building binaries that are started before APEXes are activated.
375 Bootstrap *bool
Jooyung Han097087b2019-10-22 19:32:18 +0900376
Hao Chen1c8ea5b2023-10-20 23:03:45 +0000377 // Allows this module to be included in CMake release snapshots to be built outside of Android
378 // build system and source tree.
379 Cmake_snapshot_supported *bool
380
Colin Cross1bc94122021-10-28 13:25:54 -0700381 Installable *bool `android:"arch_variant"`
Colin Crossc511bc52020-04-07 16:50:32 +0000382
383 // Set by factories of module types that can only be referenced from variants compiled against
384 // the SDK.
385 AlwaysSdk bool `blueprint:"mutated"`
386
387 // Variant is an SDK variant created by sdkMutator
388 IsSdkVariant bool `blueprint:"mutated"`
389 // Set when both SDK and platform variants are exported to Make to trigger renaming the SDK
390 // variant to have a ".sdk" suffix.
391 SdkAndPlatformVariantVisibleToMake bool `blueprint:"mutated"`
Bill Peckham945441c2020-08-31 16:07:58 -0700392
Jiyong Park46a512f2020-12-04 18:02:13 +0900393 // List of APEXes that this module has private access to for testing purpose. The module
394 // can depend on libraries that are not exported by the APEXes and use private symbols
395 // from the exported libraries.
Martin Stjernholm855e90b2021-03-25 02:33:14 +0000396 Test_for []string `android:"arch_variant"`
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800397
398 Target struct {
399 Platform struct {
400 // List of modules required by the core variant.
401 Required []string `android:"arch_variant"`
402
403 // List of modules not required by the core variant.
404 Exclude_required []string `android:"arch_variant"`
405 } `android:"arch_variant"`
406
407 Recovery struct {
408 // List of modules required by the recovery variant.
409 Required []string `android:"arch_variant"`
410
411 // List of modules not required by the recovery variant.
412 Exclude_required []string `android:"arch_variant"`
413 } `android:"arch_variant"`
414 } `android:"arch_variant"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700415}
416
417type VendorProperties struct {
Jiyong Park82e2bf32017-08-16 14:05:54 +0900418 // whether this module should be allowed to be directly depended by other
419 // modules with `vendor: true`, `proprietary: true`, or `vendor_available:true`.
Justin Yun63e9ec72020-10-29 16:49:43 +0900420 // If set to true, two variants will be built separately, one like
421 // normal, and the other limited to the set of libraries and headers
422 // that are exposed to /vendor modules.
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700423 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900424 // The vendor variant may be used with a different (newer) /system,
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700425 // so it shouldn't have any unversioned runtime dependencies, or
426 // make assumptions about the system that may not be true in the
427 // future.
428 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900429 // If set to false, this module becomes inaccessible from /vendor modules.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900430 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900431 // The modules with vndk: {enabled: true} must define 'vendor_available'
Justin Yun0b1db6d2021-01-08 15:22:34 +0900432 // to 'true'.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900433 //
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700434 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
435 Vendor_available *bool
Jiyong Park5fb8c102018-04-09 12:03:06 +0900436
Justin Yunebcf0c52021-01-08 18:00:19 +0900437 // This is the same as the "vendor_available" except that the install path
438 // of the vendor variant is /odm or /vendor/odm.
439 // By replacing "vendor_available: true" with "odm_available: true", the
440 // module will install its vendor variant to the /odm partition or /vendor/odm.
441 // As the modules with "odm_available: true" still create the vendor variants,
442 // they can link to the other vendor modules as the vendor_available modules do.
443 // Also, the vendor modules can link to odm_available modules.
444 //
445 // It may not be used for VNDK modules.
446 Odm_available *bool
447
Justin Yun63e9ec72020-10-29 16:49:43 +0900448 // whether this module should be allowed to be directly depended by other
449 // modules with `product_specific: true` or `product_available: true`.
450 // If set to true, an additional product variant will be built separately
451 // that is limited to the set of libraries and headers that are exposed to
452 // /product modules.
453 //
454 // The product variant may be used with a different (newer) /system,
455 // so it shouldn't have any unversioned runtime dependencies, or
456 // make assumptions about the system that may not be true in the
457 // future.
458 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900459 // If set to false, this module becomes inaccessible from /product modules.
460 //
461 // Different from the 'vendor_available' property, the modules with
462 // vndk: {enabled: true} don't have to define 'product_available'. The VNDK
463 // library without 'product_available' may not be depended on by any other
464 // modules that has product variants including the product available VNDKs.
Justin Yun63e9ec72020-10-29 16:49:43 +0900465 //
466 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
467 // and PRODUCT_PRODUCT_VNDK_VERSION isn't set.
468 Product_available *bool
469
Jiyong Park5fb8c102018-04-09 12:03:06 +0900470 // whether this module is capable of being loaded with other instance
471 // (possibly an older version) of the same module in the same process.
472 // Currently, a shared library that is a member of VNDK (vndk: {enabled: true})
473 // can be double loaded in a vendor process if the library is also a
474 // (direct and indirect) dependency of an LLNDK library. Such libraries must be
475 // explicitly marked as `double_loadable: true` by the owner, or the dependency
476 // from the LLNDK lib should be cut if the lib is not designed to be double loaded.
477 Double_loadable *bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800478
479 // IsLLNDK is set to true for the vendor variant of a cc_library module that has LLNDK stubs.
480 IsLLNDK bool `blueprint:"mutated"`
481
Colin Cross5271fea2021-04-27 13:06:04 -0700482 // IsVendorPublicLibrary is set for the core and product variants of a library that has
483 // vendor_public_library stubs.
484 IsVendorPublicLibrary bool `blueprint:"mutated"`
Colin Crossca860ac2016-01-04 14:34:37 -0800485}
486
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500487// ModuleContextIntf is an interface (on a module context helper) consisting of functions related
488// to understanding details about the type of the current module.
489// For example, one might call these functions to determine whether the current module is a static
490// library and/or is installed in vendor directories.
Colin Crossca860ac2016-01-04 14:34:37 -0800491type ModuleContextIntf interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800492 static() bool
493 staticBinary() bool
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -0700494 testBinary() bool
Yi Kong56fc1b62022-09-06 16:24:00 +0800495 testLibrary() bool
Jiyong Park1d1119f2019-07-29 21:27:18 +0900496 header() bool
Inseob Kim7f283f42020-06-01 21:53:49 +0900497 binary() bool
Inseob Kim1042d292020-06-01 23:23:05 +0900498 object() bool
Colin Crossb98c8b02016-07-29 13:44:28 -0700499 toolchain() config.Toolchain
Jooyung Hanccce2f22020-03-07 03:45:53 +0900500 canUseSdk() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700501 useSdk() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800502 sdkVersion() string
Jiyong Parkb35a8192020-08-10 15:59:36 +0900503 minSdkVersion() string
504 isSdkVariant() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700505 useVndk() bool
Colin Cross95f1ca02020-10-29 20:47:22 -0700506 isNdk(config android.Config) bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800507 IsLlndk() bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800508 isImplementationForLLNDKPublic() bool
Colin Cross5271fea2021-04-27 13:06:04 -0700509 IsVendorPublicLibrary() bool
Justin Yun5f7f7e82019-11-18 19:52:14 +0900510 inProduct() bool
511 inVendor() bool
Yifan Hong1b3348d2020-01-21 15:53:22 -0800512 inRamdisk() bool
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700513 inVendorRamdisk() bool
Jiyong Parkf9332f12018-02-01 00:54:12 +0900514 inRecovery() bool
Kiyoung Kimaa394802024-01-08 12:55:45 +0900515 InVendorOrProduct() bool
Dan Willemsen8146b2f2016-03-30 21:00:30 -0700516 selectedStl() string
Colin Crossce75d2c2016-10-06 16:12:58 -0700517 baseModuleName() string
Colin Cross3513fb12024-01-24 14:44:47 -0800518 isAfdoCompile(ctx ModuleContext) bool
Sharjeel Khanc6a93d82023-07-18 21:01:11 +0000519 isOrderfileCompile() bool
Yi Kongc702ebd2022-08-19 16:02:45 +0800520 isCfi() bool
Yi Konged79fa32023-06-04 17:15:42 +0900521 isFuzzer() bool
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800522 isNDKStubLibrary() bool
Ivan Lozanobd721262018-11-27 14:33:03 -0800523 useClangLld(actx ModuleContext) bool
Logan Chiene274fc92019-12-03 11:18:32 -0800524 isForPlatform() bool
Colin Crosse07f2312020-08-13 11:24:56 -0700525 apexVariationName() string
Dan Albertc8060532020-07-22 22:32:17 -0700526 apexSdkVersion() android.ApiLevel
Jiyong Parka4b9dd02019-01-16 22:53:13 +0900527 bootstrap() bool
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700528 nativeCoverage() bool
Colin Cross56a83212020-09-15 18:30:11 -0700529 directlyInAnyApex() bool
Colin Cross95b07f22020-12-16 11:06:50 -0800530 isPreventInstall() bool
Cindy Zhou5d5cfc12021-01-09 08:25:22 -0800531 isCfiAssemblySupportEnabled() bool
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800532 getSharedFlags() *SharedFlags
Colin Cross4a9e6ec2023-12-18 15:29:41 -0800533 notInPlatform() bool
Yi Kong5786f5c2024-05-28 02:22:34 +0900534 optimizeForSize() bool
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800535}
536
537type SharedFlags struct {
538 numSharedFlags int
539 flagsMap map[string]string
Colin Crossca860ac2016-01-04 14:34:37 -0800540}
541
542type ModuleContext interface {
Colin Cross635c3b02016-05-18 15:37:25 -0700543 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800544 ModuleContextIntf
545}
546
547type BaseModuleContext interface {
Colin Cross0ea8ba82019-06-06 14:33:29 -0700548 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800549 ModuleContextIntf
550}
551
Colin Cross37047f12016-12-13 17:06:13 -0800552type DepsContext interface {
553 android.BottomUpMutatorContext
554 ModuleContextIntf
555}
556
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500557// feature represents additional (optional) steps to building cc-related modules, such as invocation
558// of clang-tidy.
Colin Crossca860ac2016-01-04 14:34:37 -0800559type feature interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800560 flags(ctx ModuleContext, flags Flags) Flags
561 props() []interface{}
562}
563
Joe Onorato37f900c2023-07-18 16:58:16 -0700564// Information returned from Generator about the source code it's generating
565type GeneratedSource struct {
566 IncludeDirs android.Paths
567 Sources android.Paths
568 Headers android.Paths
569 ReexportedDirs android.Paths
570}
571
572// generator allows injection of generated code
573type Generator interface {
574 GeneratorProps() []interface{}
575 GeneratorInit(ctx BaseModuleContext)
576 GeneratorDeps(ctx DepsContext, deps Deps) Deps
577 GeneratorFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
578 GeneratorSources(ctx ModuleContext) GeneratedSource
579 GeneratorBuildActions(ctx ModuleContext, flags Flags, deps PathDeps)
580}
581
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500582// compiler is the interface for a compiler helper object. Different module decorators may implement
Liz Kammer718eb272022-01-07 10:53:37 -0500583// this helper differently.
Colin Crossca860ac2016-01-04 14:34:37 -0800584type compiler interface {
Colin Cross42742b82016-08-01 13:20:05 -0700585 compilerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800586 compilerDeps(ctx DepsContext, deps Deps) Deps
Colin Crossf18e1102017-11-16 14:33:08 -0800587 compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
Colin Cross42742b82016-08-01 13:20:05 -0700588 compilerProps() []interface{}
Hao Chen1c8ea5b2023-10-20 23:03:45 +0000589 baseCompilerProps() BaseCompilerProperties
Colin Cross42742b82016-08-01 13:20:05 -0700590
Colin Cross76fada02016-07-27 10:31:13 -0700591 appendCflags([]string)
592 appendAsflags([]string)
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700593 compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects
Colin Crossca860ac2016-01-04 14:34:37 -0800594}
595
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500596// linker is the interface for a linker decorator object. Individual module types can provide
597// their own implementation for this decorator, and thus specify custom logic regarding build
598// statements pertaining to linking.
Colin Crossca860ac2016-01-04 14:34:37 -0800599type linker interface {
Colin Cross42742b82016-08-01 13:20:05 -0700600 linkerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800601 linkerDeps(ctx DepsContext, deps Deps) Deps
Colin Cross42742b82016-08-01 13:20:05 -0700602 linkerFlags(ctx ModuleContext, flags Flags) Flags
603 linkerProps() []interface{}
Hao Chen1c8ea5b2023-10-20 23:03:45 +0000604 baseLinkerProps() BaseLinkerProperties
Ivan Lozanobd721262018-11-27 14:33:03 -0800605 useClangLld(actx ModuleContext) bool
Colin Cross42742b82016-08-01 13:20:05 -0700606
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700607 link(ctx ModuleContext, flags Flags, deps PathDeps, objs Objects) android.Path
Colin Cross76fada02016-07-27 10:31:13 -0700608 appendLdflags([]string)
Jiyong Parkaf6d8952019-01-31 12:21:23 +0900609 unstrippedOutputFilePath() android.Path
Wei Li5f5d2712023-12-11 15:40:29 -0800610 strippedAllOutputFilePath() android.Path
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700611
612 nativeCoverage() bool
Jiyong Parkee9a98d2019-08-09 14:44:36 +0900613 coverageOutputFilePath() android.OptionalPath
Paul Duffin13f02712020-03-06 12:30:43 +0000614
615 // Get the deps that have been explicitly specified in the properties.
Cole Fauste8a87832024-09-11 11:35:46 -0700616 linkerSpecifiedDeps(ctx android.ConfigurableEvaluatorContext, module *Module, specifiedDeps specifiedDeps) specifiedDeps
Colin Cross4a9e6ec2023-12-18 15:29:41 -0800617
618 moduleInfoJSON(ctx ModuleContext, moduleInfoJSON *android.ModuleInfoJSON)
Paul Duffin13f02712020-03-06 12:30:43 +0000619}
620
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500621// specifiedDeps is a tuple struct representing dependencies of a linked binary owned by the linker.
Paul Duffin13f02712020-03-06 12:30:43 +0000622type specifiedDeps struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500623 sharedLibs []string
624 // Note nil and [] are semantically distinct. [] prevents linking against the defaults (usually
625 // libc, libm, etc.)
Colin Cross6b8f4252021-07-22 11:39:44 -0700626 systemSharedLibs []string
Colin Crossca860ac2016-01-04 14:34:37 -0800627}
628
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500629// installer is the interface for an installer helper object. This helper is responsible for
630// copying build outputs to the appropriate locations so that they may be installed on device.
Colin Crossca860ac2016-01-04 14:34:37 -0800631type installer interface {
Colin Cross42742b82016-08-01 13:20:05 -0700632 installerProps() []interface{}
Colin Cross635c3b02016-05-18 15:37:25 -0700633 install(ctx ModuleContext, path android.Path)
Paul Duffin0cb37b92020-03-04 14:52:46 +0000634 everInstallable() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800635 inData() bool
Vishwath Mohan1dd88392017-03-29 22:00:18 -0700636 inSanitizerDir() bool
Dan Willemsen4aa75ca2016-09-28 16:18:03 -0700637 hostToolPath() android.OptionalPath
Jiyong Parkb7c24df2019-02-01 12:03:59 +0900638 relativeInstallPath() string
Jingwen Chen8ac7d7d2023-03-20 11:05:16 +0000639 makeUninstallable(mod *Module)
Inseob Kim800d1142021-06-14 12:03:51 +0900640 installInRoot() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800641}
642
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800643type xref interface {
644 XrefCcFiles() android.Paths
645}
646
Inseob Kima1888ce2022-10-04 14:42:02 +0900647type overridable interface {
648 overriddenModules() []string
649}
650
Colin Cross6e511a92020-07-27 21:26:48 -0700651type libraryDependencyKind int
652
653const (
654 headerLibraryDependency = iota
655 sharedLibraryDependency
656 staticLibraryDependency
Ivan Lozano0a468a42024-05-13 21:03:34 -0400657 rlibLibraryDependency
Colin Cross6e511a92020-07-27 21:26:48 -0700658)
659
660func (k libraryDependencyKind) String() string {
661 switch k {
662 case headerLibraryDependency:
663 return "headerLibraryDependency"
664 case sharedLibraryDependency:
665 return "sharedLibraryDependency"
666 case staticLibraryDependency:
667 return "staticLibraryDependency"
Ivan Lozano0a468a42024-05-13 21:03:34 -0400668 case rlibLibraryDependency:
669 return "rlibLibraryDependency"
Colin Cross6e511a92020-07-27 21:26:48 -0700670 default:
671 panic(fmt.Errorf("unknown libraryDependencyKind %d", k))
672 }
673}
674
675type libraryDependencyOrder int
676
677const (
678 earlyLibraryDependency = -1
679 normalLibraryDependency = 0
680 lateLibraryDependency = 1
681)
682
683func (o libraryDependencyOrder) String() string {
684 switch o {
685 case earlyLibraryDependency:
686 return "earlyLibraryDependency"
687 case normalLibraryDependency:
688 return "normalLibraryDependency"
689 case lateLibraryDependency:
690 return "lateLibraryDependency"
691 default:
692 panic(fmt.Errorf("unknown libraryDependencyOrder %d", o))
693 }
694}
695
696// libraryDependencyTag is used to tag dependencies on libraries. Unlike many dependency
697// tags that have a set of predefined tag objects that are reused for each dependency, a
698// libraryDependencyTag is designed to contain extra metadata and is constructed as needed.
699// That means that comparing a libraryDependencyTag for equality will only be equal if all
700// of the metadata is equal. Most usages will want to type assert to libraryDependencyTag and
701// then check individual metadata fields instead.
702type libraryDependencyTag struct {
703 blueprint.BaseDependencyTag
704
705 // These are exported so that fmt.Printf("%#v") can call their String methods.
706 Kind libraryDependencyKind
707 Order libraryDependencyOrder
708
709 wholeStatic bool
710
711 reexportFlags bool
712 explicitlyVersioned bool
713 dataLib bool
714 ndk bool
715
716 staticUnwinder bool
717
718 makeSuffix string
Jiyong Parke3867542020-12-03 17:28:25 +0900719
Cindy Zhou18417cb2020-12-10 07:12:38 -0800720 // Whether or not this dependency should skip the apex dependency check
721 skipApexAllowedDependenciesCheck bool
722
Jiyong Parke3867542020-12-03 17:28:25 +0900723 // Whether or not this dependency has to be followed for the apex variants
724 excludeInApex bool
Jooyung Han9ffbe832023-11-28 22:31:35 +0900725 // Whether or not this dependency has to be followed for the non-apex variants
726 excludeInNonApex bool
Colin Cross3e5e7782022-06-17 22:17:05 +0000727
728 // If true, don't automatically export symbols from the static library into a shared library.
729 unexportedSymbols bool
Colin Cross6e511a92020-07-27 21:26:48 -0700730}
731
732// header returns true if the libraryDependencyTag is tagging a header lib dependency.
733func (d libraryDependencyTag) header() bool {
734 return d.Kind == headerLibraryDependency
735}
736
737// shared returns true if the libraryDependencyTag is tagging a shared lib dependency.
738func (d libraryDependencyTag) shared() bool {
739 return d.Kind == sharedLibraryDependency
740}
741
742// shared returns true if the libraryDependencyTag is tagging a static lib dependency.
743func (d libraryDependencyTag) static() bool {
744 return d.Kind == staticLibraryDependency
745}
746
Colin Cross65cb3142021-12-10 23:05:02 +0000747func (d libraryDependencyTag) LicenseAnnotations() []android.LicenseAnnotation {
748 if d.shared() {
749 return []android.LicenseAnnotation{android.LicenseAnnotationSharedDependency}
750 }
751 return nil
752}
753
754var _ android.LicenseAnnotationsDependencyTag = libraryDependencyTag{}
755
Colin Crosse9fe2942020-11-10 18:12:15 -0800756// InstallDepNeeded returns true for shared libraries so that shared library dependencies of
757// binaries or other shared libraries are installed as dependencies.
758func (d libraryDependencyTag) InstallDepNeeded() bool {
759 return d.shared()
760}
761
762var _ android.InstallNeededDependencyTag = libraryDependencyTag{}
763
Yu Liu67a28422024-03-05 00:36:31 +0000764func (d libraryDependencyTag) PropagateAconfigValidation() bool {
765 return d.static()
766}
767
768var _ android.PropagateAconfigValidationDependencyTag = libraryDependencyTag{}
769
Colin Crosse9fe2942020-11-10 18:12:15 -0800770// dependencyTag is used for tagging miscellaneous dependency types that don't fit into
Colin Cross6e511a92020-07-27 21:26:48 -0700771// libraryDependencyTag. Each tag object is created globally and reused for multiple
772// dependencies (although since the object contains no references, assigning a tag to a
773// variable and modifying it will not modify the original). Users can compare the tag
774// returned by ctx.OtherModuleDependencyTag against the global original
775type dependencyTag struct {
776 blueprint.BaseDependencyTag
777 name string
778}
779
Colin Crosse9fe2942020-11-10 18:12:15 -0800780// installDependencyTag is used for tagging miscellaneous dependency types that don't fit into
781// libraryDependencyTag, but where the dependency needs to be installed when the parent is
782// installed.
783type installDependencyTag struct {
784 blueprint.BaseDependencyTag
785 android.InstallAlwaysNeededDependencyTag
786 name string
787}
788
Colin Crossc99deeb2016-04-11 15:06:20 -0700789var (
Colin Cross6e511a92020-07-27 21:26:48 -0700790 genSourceDepTag = dependencyTag{name: "gen source"}
791 genHeaderDepTag = dependencyTag{name: "gen header"}
792 genHeaderExportDepTag = dependencyTag{name: "gen header export"}
793 objDepTag = dependencyTag{name: "obj"}
Jiyong Parkd630bdd2020-11-25 11:47:24 +0900794 dynamicLinkerDepTag = installDependencyTag{name: "dynamic linker"}
Colin Cross6e511a92020-07-27 21:26:48 -0700795 reuseObjTag = dependencyTag{name: "reuse objects"}
796 staticVariantTag = dependencyTag{name: "static variant"}
797 vndkExtDepTag = dependencyTag{name: "vndk extends"}
798 dataLibDepTag = dependencyTag{name: "data lib"}
Colin Crossc8caa062021-09-24 16:50:14 -0700799 dataBinDepTag = dependencyTag{name: "data bin"}
Colin Crosse9fe2942020-11-10 18:12:15 -0800800 runtimeDepTag = installDependencyTag{name: "runtime lib"}
Colin Cross0de8a1e2020-09-18 14:15:30 -0700801 stubImplDepTag = dependencyTag{name: "stub_impl"}
Muhammad Haseeb Ahmad7e744052022-03-25 22:50:53 +0000802 JniFuzzLibTag = dependencyTag{name: "jni_fuzz_lib_tag"}
Vinh Tran44cb78c2023-03-09 22:07:19 -0500803 FdoProfileTag = dependencyTag{name: "fdo_profile"}
Vinh Tran367d89d2023-04-28 11:21:25 -0400804 aidlLibraryTag = dependencyTag{name: "aidl_library"}
Hsin-Yi Chen715142a2024-03-27 16:31:16 +0800805 llndkHeaderLibTag = dependencyTag{name: "llndk_header_lib"}
Colin Crossc99deeb2016-04-11 15:06:20 -0700806)
807
Roland Levillainf89cd092019-07-29 16:22:59 +0100808func IsSharedDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700809 ccLibDepTag, ok := depTag.(libraryDependencyTag)
810 return ok && ccLibDepTag.shared()
811}
812
813func IsStaticDepTag(depTag blueprint.DependencyTag) bool {
814 ccLibDepTag, ok := depTag.(libraryDependencyTag)
815 return ok && ccLibDepTag.static()
Roland Levillainf89cd092019-07-29 16:22:59 +0100816}
817
Zach Johnson3df4e632020-11-06 11:56:27 -0800818func IsHeaderDepTag(depTag blueprint.DependencyTag) bool {
819 ccLibDepTag, ok := depTag.(libraryDependencyTag)
820 return ok && ccLibDepTag.header()
821}
822
Roland Levillainf89cd092019-07-29 16:22:59 +0100823func IsRuntimeDepTag(depTag blueprint.DependencyTag) bool {
Colin Crosse9fe2942020-11-10 18:12:15 -0800824 return depTag == runtimeDepTag
Roland Levillainf89cd092019-07-29 16:22:59 +0100825}
826
Colin Crossca860ac2016-01-04 14:34:37 -0800827// Module contains the properties and members used by all C/C++ module types, and implements
828// the blueprint.Module interface. It delegates to compiler, linker, and installer interfaces
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500829// to construct the output file. Behavior can be customized with a Customizer, or "decorator",
830// interface.
831//
832// To define a C/C++ related module, construct a new Module object and point its delegates to
833// type-specific structs. These delegates will be invoked to register module-specific build
834// statements which may be unique to the module type. For example, module.compiler.compile() should
835// be defined so as to register build statements which are responsible for compiling the module.
836//
837// Another example: to construct a cc_binary module, one can create a `cc.binaryDecorator` struct
838// which implements the `linker` and `installer` interfaces, and points the `linker` and `installer`
839// members of the cc.Module to this decorator. Thus, a cc_binary module has custom linker and
840// installer logic.
Colin Crossca860ac2016-01-04 14:34:37 -0800841type Module struct {
hamzehc0a671f2021-07-22 12:05:08 -0700842 fuzz.FuzzModule
hamzeh41ad8812021-07-07 14:00:07 -0700843
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700844 VendorProperties VendorProperties
hamzeh41ad8812021-07-07 14:00:07 -0700845 Properties BaseProperties
Ronald Braunsteina115e262024-04-09 18:07:38 -0700846 sourceProperties android.SourceProperties
Colin Crossfa138792015-04-24 17:31:52 -0700847
Colin Crossca860ac2016-01-04 14:34:37 -0800848 // initialize before calling Init
Aditya Choudhary87b2ab22023-11-17 15:27:06 +0000849 hod android.HostOrDeviceSupported
850 multilib android.Multilib
Aditya Choudhary87b2ab22023-11-17 15:27:06 +0000851 testModule bool
Colin Crossc472d572015-03-17 15:06:21 -0700852
Paul Duffina0843f62019-12-13 19:50:38 +0000853 // Allowable SdkMemberTypes of this module type.
854 sdkMemberTypes []android.SdkMemberType
855
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500856 // decorator delegates, initialize before calling Init
857 // these may contain module-specific implementations, and effectively allow for custom
858 // type-specific logic. These members may reference different objects or the same object.
859 // Functions of these decorators will be invoked to initialize and register type-specific
860 // build statements.
Colin Cross8ff10582023-12-07 13:10:56 -0800861 generators []Generator
862 compiler compiler
863 linker linker
864 installer installer
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500865
Spandan Dase12d2522023-09-12 21:42:31 +0000866 features []feature
867 stl *stl
868 sanitize *sanitize
869 coverage *coverage
870 fuzzer *fuzzer
871 sabi *sabi
Spandan Dase12d2522023-09-12 21:42:31 +0000872 lto *lto
873 afdo *afdo
Sharjeel Khanc6a93d82023-07-18 21:01:11 +0000874 orderfile *orderfile
Colin Cross16b23492016-01-06 14:41:07 -0800875
Colin Cross31076b32020-10-23 17:22:06 -0700876 library libraryInterface
877
Colin Cross635c3b02016-05-18 15:37:25 -0700878 outputFile android.OptionalPath
Colin Crossca860ac2016-01-04 14:34:37 -0800879
Colin Crossb98c8b02016-07-29 13:44:28 -0700880 cachedToolchain config.Toolchain
Colin Crossb916a382016-07-29 17:28:03 -0700881
Priyanka Advani (xWF)37e67942024-10-17 18:58:08 +0000882 subAndroidMkOnce map[subAndroidMkProvider]bool
Fabien Sanglardd61f1f42017-01-10 16:21:22 -0800883
884 // Flags used to compile this module
885 flags Flags
Jeff Gaston294356f2017-09-27 17:05:30 -0700886
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800887 // Shared flags among build rules of this module
888 sharedFlags SharedFlags
889
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800890 // only non-nil when this is a shared library that reuses the objects of a static library
Colin Cross0de8a1e2020-09-18 14:15:30 -0700891 staticAnalogue *StaticLibraryInfo
Inseob Kim9516ee92019-05-09 10:56:13 +0900892
893 makeLinkType string
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800894 // Kythe (source file indexer) paths for this compilation module
895 kytheFiles android.Paths
Chih-Hung Hsieh80783772021-10-11 16:46:56 -0700896 // Object .o file output paths for this compilation module
897 objFiles android.Paths
898 // Tidy .tidy file output paths for this compilation module
899 tidyFiles android.Paths
Jooyung Han75568392020-03-20 04:29:24 +0900900
901 // For apex variants, this is set as apex.min_sdk_version
Dan Albertc8060532020-07-22 22:32:17 -0700902 apexSdkVersion android.ApiLevel
Colin Cross56a83212020-09-15 18:30:11 -0700903
904 hideApexVariantFromMake bool
Yu Liueae7b362023-11-16 17:05:47 -0800905
Inseob Kim37e0bb02024-04-29 15:54:44 +0900906 logtagsPaths android.Paths
Ivan Lozanofd47b1a2024-05-17 14:13:41 -0400907
908 WholeRustStaticlib bool
Cole Faust96a692b2024-08-08 14:47:51 -0700909
910 hasAidl bool
911 hasLex bool
912 hasProto bool
913 hasRenderscript bool
914 hasSysprop bool
915 hasWinMsg bool
916 hasYacc bool
Colin Crossc472d572015-03-17 15:06:21 -0700917}
918
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200919func (c *Module) AddJSONData(d *map[string]interface{}) {
920 c.AndroidModuleBase().AddJSONData(d)
921 (*d)["Cc"] = map[string]interface{}{
922 "SdkVersion": c.SdkVersion(),
923 "MinSdkVersion": c.MinSdkVersion(),
924 "VndkVersion": c.VndkVersion(),
925 "ProductSpecific": c.ProductSpecific(),
926 "SocSpecific": c.SocSpecific(),
927 "DeviceSpecific": c.DeviceSpecific(),
928 "InProduct": c.InProduct(),
929 "InVendor": c.InVendor(),
930 "InRamdisk": c.InRamdisk(),
931 "InVendorRamdisk": c.InVendorRamdisk(),
932 "InRecovery": c.InRecovery(),
933 "VendorAvailable": c.VendorAvailable(),
934 "ProductAvailable": c.ProductAvailable(),
935 "RamdiskAvailable": c.RamdiskAvailable(),
936 "VendorRamdiskAvailable": c.VendorRamdiskAvailable(),
937 "RecoveryAvailable": c.RecoveryAvailable(),
938 "OdmAvailable": c.OdmAvailable(),
939 "InstallInData": c.InstallInData(),
940 "InstallInRamdisk": c.InstallInRamdisk(),
941 "InstallInSanitizerDir": c.InstallInSanitizerDir(),
942 "InstallInVendorRamdisk": c.InstallInVendorRamdisk(),
943 "InstallInRecovery": c.InstallInRecovery(),
944 "InstallInRoot": c.InstallInRoot(),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200945 "IsLlndk": c.IsLlndk(),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200946 "IsVendorPublicLibrary": c.IsVendorPublicLibrary(),
947 "ApexSdkVersion": c.apexSdkVersion,
948 "TestFor": c.TestFor(),
Cole Faust96a692b2024-08-08 14:47:51 -0700949 "AidlSrcs": c.hasAidl,
950 "LexSrcs": c.hasLex,
951 "ProtoSrcs": c.hasProto,
952 "RenderscriptSrcs": c.hasRenderscript,
953 "SyspropSrcs": c.hasSysprop,
954 "WinMsgSrcs": c.hasWinMsg,
955 "YaccSrsc": c.hasYacc,
956 "OnlyCSrcs": !(c.hasAidl || c.hasLex || c.hasProto || c.hasRenderscript || c.hasSysprop || c.hasWinMsg || c.hasYacc),
Yi Kong5786f5c2024-05-28 02:22:34 +0900957 "OptimizeForSize": c.OptimizeForSize(),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200958 }
959}
960
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500961func (c *Module) SetPreventInstall() {
962 c.Properties.PreventInstall = true
963}
964
965func (c *Module) SetHideFromMake() {
966 c.Properties.HideFromMake = true
967}
968
Ivan Lozanod7586b62021-04-01 09:49:36 -0400969func (c *Module) HiddenFromMake() bool {
970 return c.Properties.HideFromMake
971}
972
Cole Fauste8a87832024-09-11 11:35:46 -0700973func (c *Module) RequiredModuleNames(ctx android.ConfigurableEvaluatorContext) []string {
Cole Faust43ddd082024-06-17 12:32:40 -0700974 required := android.CopyOf(c.ModuleBase.RequiredModuleNames(ctx))
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800975 if c.ImageVariation().Variation == android.CoreVariation {
976 required = append(required, c.Properties.Target.Platform.Required...)
977 required = removeListFromList(required, c.Properties.Target.Platform.Exclude_required)
978 } else if c.InRecovery() {
979 required = append(required, c.Properties.Target.Recovery.Required...)
980 required = removeListFromList(required, c.Properties.Target.Recovery.Exclude_required)
981 }
982 return android.FirstUniqueStrings(required)
983}
984
Ivan Lozano52767be2019-10-18 14:49:46 -0700985func (c *Module) Toc() android.OptionalPath {
986 if c.linker != nil {
987 if library, ok := c.linker.(libraryInterface); ok {
988 return library.toc()
989 }
990 }
991 panic(fmt.Errorf("Toc() called on non-library module: %q", c.BaseModuleName()))
992}
993
994func (c *Module) ApiLevel() string {
995 if c.linker != nil {
996 if stub, ok := c.linker.(*stubDecorator); ok {
Dan Albert1a246272020-07-06 14:49:35 -0700997 return stub.apiLevel.String()
Ivan Lozano52767be2019-10-18 14:49:46 -0700998 }
999 }
1000 panic(fmt.Errorf("ApiLevel() called on non-stub library module: %q", c.BaseModuleName()))
1001}
1002
1003func (c *Module) Static() bool {
1004 if c.linker != nil {
1005 if library, ok := c.linker.(libraryInterface); ok {
1006 return library.static()
1007 }
1008 }
1009 panic(fmt.Errorf("Static() called on non-library module: %q", c.BaseModuleName()))
1010}
1011
1012func (c *Module) Shared() bool {
1013 if c.linker != nil {
1014 if library, ok := c.linker.(libraryInterface); ok {
1015 return library.shared()
1016 }
1017 }
Lukacs T. Berki6c716762022-06-13 20:50:39 +02001018
Ivan Lozano52767be2019-10-18 14:49:46 -07001019 panic(fmt.Errorf("Shared() called on non-library module: %q", c.BaseModuleName()))
1020}
1021
1022func (c *Module) SelectedStl() string {
Colin Crossc511bc52020-04-07 16:50:32 +00001023 if c.stl != nil {
1024 return c.stl.Properties.SelectedStl
1025 }
1026 return ""
Ivan Lozano52767be2019-10-18 14:49:46 -07001027}
1028
Ivan Lozano52767be2019-10-18 14:49:46 -07001029func (c *Module) StubDecorator() bool {
1030 if _, ok := c.linker.(*stubDecorator); ok {
1031 return true
1032 }
1033 return false
1034}
1035
Yi Kong5786f5c2024-05-28 02:22:34 +09001036func (c *Module) OptimizeForSize() bool {
1037 return Bool(c.Properties.Optimize_for_size)
1038}
1039
Ivan Lozano52767be2019-10-18 14:49:46 -07001040func (c *Module) SdkVersion() string {
1041 return String(c.Properties.Sdk_version)
1042}
1043
Artur Satayev480e25b2020-04-27 18:53:18 +01001044func (c *Module) MinSdkVersion() string {
1045 return String(c.Properties.Min_sdk_version)
1046}
1047
Jiyong Park5df7bd32021-08-25 16:18:46 +09001048func (c *Module) isCrt() bool {
Dan Albert92fe7402020-07-15 13:33:30 -07001049 if linker, ok := c.linker.(*objectLinker); ok {
1050 return linker.isCrt()
1051 }
1052 return false
1053}
1054
Jiyong Park5df7bd32021-08-25 16:18:46 +09001055func (c *Module) SplitPerApiLevel() bool {
1056 return c.canUseSdk() && c.isCrt()
1057}
1058
Colin Crossc511bc52020-04-07 16:50:32 +00001059func (c *Module) AlwaysSdk() bool {
1060 return c.Properties.AlwaysSdk || Bool(c.Properties.Sdk_variant_only)
1061}
1062
Ivan Lozano183a3212019-10-18 14:18:45 -07001063func (c *Module) CcLibrary() bool {
1064 if c.linker != nil {
1065 if _, ok := c.linker.(*libraryDecorator); ok {
1066 return true
1067 }
Colin Crossd48fe732020-09-23 20:37:24 -07001068 if _, ok := c.linker.(*prebuiltLibraryLinker); ok {
1069 return true
1070 }
Ivan Lozano183a3212019-10-18 14:18:45 -07001071 }
1072 return false
1073}
1074
1075func (c *Module) CcLibraryInterface() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001076 if _, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001077 return true
1078 }
1079 return false
1080}
1081
Ivan Lozanoadd122a2023-07-13 11:01:41 -04001082func (c *Module) RlibStd() bool {
1083 panic(fmt.Errorf("RlibStd called on non-Rust module: %q", c.BaseModuleName()))
1084}
1085
Ivan Lozano61c02cc2023-06-09 14:06:44 -04001086func (c *Module) RustLibraryInterface() bool {
1087 return false
1088}
1089
Ivan Lozano0a468a42024-05-13 21:03:34 -04001090func (c *Module) CrateName() string {
1091 panic(fmt.Errorf("CrateName called on non-Rust module: %q", c.BaseModuleName()))
1092}
1093
1094func (c *Module) ExportedCrateLinkDirs() []string {
1095 panic(fmt.Errorf("ExportedCrateLinkDirs called on non-Rust module: %q", c.BaseModuleName()))
1096}
1097
Ivan Lozano0f9963e2023-02-06 13:31:02 -05001098func (c *Module) IsFuzzModule() bool {
1099 if _, ok := c.compiler.(*fuzzBinary); ok {
1100 return true
1101 }
1102 return false
1103}
1104
1105func (c *Module) FuzzModuleStruct() fuzz.FuzzModule {
1106 return c.FuzzModule
1107}
1108
1109func (c *Module) FuzzPackagedModule() fuzz.FuzzPackagedModule {
1110 if fuzzer, ok := c.compiler.(*fuzzBinary); ok {
1111 return fuzzer.fuzzPackagedModule
1112 }
1113 panic(fmt.Errorf("FuzzPackagedModule called on non-fuzz module: %q", c.BaseModuleName()))
1114}
1115
Hamzeh Zawawy38917492023-04-05 22:08:46 +00001116func (c *Module) FuzzSharedLibraries() android.RuleBuilderInstalls {
Ivan Lozano0f9963e2023-02-06 13:31:02 -05001117 if fuzzer, ok := c.compiler.(*fuzzBinary); ok {
1118 return fuzzer.sharedLibraries
1119 }
1120 panic(fmt.Errorf("FuzzSharedLibraries called on non-fuzz module: %q", c.BaseModuleName()))
1121}
1122
Ivan Lozano2b262972019-11-21 12:30:50 -08001123func (c *Module) NonCcVariants() bool {
1124 return false
1125}
1126
Ivan Lozano183a3212019-10-18 14:18:45 -07001127func (c *Module) SetStatic() {
1128 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001129 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001130 library.setStatic()
1131 return
1132 }
1133 }
1134 panic(fmt.Errorf("SetStatic called on non-library module: %q", c.BaseModuleName()))
1135}
1136
1137func (c *Module) SetShared() {
1138 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001139 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001140 library.setShared()
1141 return
1142 }
1143 }
1144 panic(fmt.Errorf("SetShared called on non-library module: %q", c.BaseModuleName()))
1145}
1146
1147func (c *Module) BuildStaticVariant() bool {
1148 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001149 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001150 return library.buildStatic()
1151 }
1152 }
1153 panic(fmt.Errorf("BuildStaticVariant called on non-library module: %q", c.BaseModuleName()))
1154}
1155
1156func (c *Module) BuildSharedVariant() bool {
1157 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001158 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001159 return library.buildShared()
1160 }
1161 }
1162 panic(fmt.Errorf("BuildSharedVariant called on non-library module: %q", c.BaseModuleName()))
1163}
1164
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04001165func (c *Module) BuildRlibVariant() bool {
1166 // cc modules can never build rlib variants
1167 return false
1168}
1169
1170func (c *Module) IsRustFFI() bool {
1171 // cc modules are not Rust modules
1172 return false
1173}
1174
Ivan Lozano183a3212019-10-18 14:18:45 -07001175func (c *Module) Module() android.Module {
1176 return c
1177}
1178
Jiyong Parkc20eee32018-09-05 22:36:17 +09001179func (c *Module) OutputFile() android.OptionalPath {
1180 return c.outputFile
1181}
1182
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001183func (c *Module) CoverageFiles() android.Paths {
1184 if c.linker != nil {
1185 if library, ok := c.linker.(libraryInterface); ok {
1186 return library.objs().coverageFiles
1187 }
1188 }
1189 panic(fmt.Errorf("CoverageFiles called on non-library module: %q", c.BaseModuleName()))
1190}
1191
Ivan Lozano183a3212019-10-18 14:18:45 -07001192var _ LinkableInterface = (*Module)(nil)
1193
Jiyong Park719b4462019-01-13 00:39:51 +09001194func (c *Module) UnstrippedOutputFile() android.Path {
Jiyong Parkaf6d8952019-01-31 12:21:23 +09001195 if c.linker != nil {
1196 return c.linker.unstrippedOutputFilePath()
Jiyong Park719b4462019-01-13 00:39:51 +09001197 }
1198 return nil
1199}
1200
Jiyong Parkee9a98d2019-08-09 14:44:36 +09001201func (c *Module) CoverageOutputFile() android.OptionalPath {
1202 if c.linker != nil {
1203 return c.linker.coverageOutputFilePath()
1204 }
1205 return android.OptionalPath{}
1206}
1207
Jiyong Parkb7c24df2019-02-01 12:03:59 +09001208func (c *Module) RelativeInstallPath() string {
1209 if c.installer != nil {
1210 return c.installer.relativeInstallPath()
1211 }
1212 return ""
1213}
1214
Jooyung Han344d5432019-08-23 11:17:39 +09001215func (c *Module) VndkVersion() string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001216 return c.Properties.VndkVersion
Jooyung Han344d5432019-08-23 11:17:39 +09001217}
1218
Colin Cross36242852017-06-23 15:06:31 -07001219func (c *Module) Init() android.Module {
Dan Willemsenf923f2b2018-05-09 13:45:03 -07001220 c.AddProperties(&c.Properties, &c.VendorProperties)
Joe Onorato37f900c2023-07-18 16:58:16 -07001221 for _, generator := range c.generators {
1222 c.AddProperties(generator.GeneratorProps()...)
1223 }
Colin Crossca860ac2016-01-04 14:34:37 -08001224 if c.compiler != nil {
Colin Cross36242852017-06-23 15:06:31 -07001225 c.AddProperties(c.compiler.compilerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001226 }
1227 if c.linker != nil {
Colin Cross36242852017-06-23 15:06:31 -07001228 c.AddProperties(c.linker.linkerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001229 }
1230 if c.installer != nil {
Colin Cross36242852017-06-23 15:06:31 -07001231 c.AddProperties(c.installer.installerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001232 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001233 if c.stl != nil {
Colin Cross36242852017-06-23 15:06:31 -07001234 c.AddProperties(c.stl.props()...)
Colin Crossa8e07cc2016-04-04 15:07:06 -07001235 }
Colin Cross16b23492016-01-06 14:41:07 -08001236 if c.sanitize != nil {
Colin Cross36242852017-06-23 15:06:31 -07001237 c.AddProperties(c.sanitize.props()...)
Colin Cross16b23492016-01-06 14:41:07 -08001238 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001239 if c.coverage != nil {
Colin Cross36242852017-06-23 15:06:31 -07001240 c.AddProperties(c.coverage.props()...)
Dan Willemsen581341d2017-02-09 16:16:31 -08001241 }
Cory Barkera1da26f2022-06-07 20:12:06 +00001242 if c.fuzzer != nil {
1243 c.AddProperties(c.fuzzer.props()...)
1244 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001245 if c.sabi != nil {
Colin Cross36242852017-06-23 15:06:31 -07001246 c.AddProperties(c.sabi.props()...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001247 }
Stephen Craneba090d12017-05-09 15:44:35 -07001248 if c.lto != nil {
1249 c.AddProperties(c.lto.props()...)
1250 }
Yi Kongeb8efc92021-12-09 18:06:29 +08001251 if c.afdo != nil {
1252 c.AddProperties(c.afdo.props()...)
1253 }
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001254 if c.orderfile != nil {
1255 c.AddProperties(c.orderfile.props()...)
1256 }
Colin Crossca860ac2016-01-04 14:34:37 -08001257 for _, feature := range c.features {
Colin Cross36242852017-06-23 15:06:31 -07001258 c.AddProperties(feature.props()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001259 }
Ronald Braunsteina115e262024-04-09 18:07:38 -07001260 // Allow test-only on libraries that are not cc_test_library
1261 if c.library != nil && !c.testLibrary() {
1262 c.AddProperties(&c.sourceProperties)
1263 }
Colin Crossc472d572015-03-17 15:06:21 -07001264
Colin Cross36242852017-06-23 15:06:31 -07001265 android.InitAndroidArchModule(c, c.hod, c.multilib)
Jiyong Park7916bfc2019-09-30 19:13:12 +09001266 android.InitApexModule(c)
Jooyung Han18020ea2019-11-13 10:50:48 +09001267 android.InitDefaultableModule(c)
Jiyong Park9d452992018-10-03 00:38:19 +09001268
Colin Cross36242852017-06-23 15:06:31 -07001269 return c
Colin Crossc472d572015-03-17 15:06:21 -07001270}
1271
Yi-Yo Chiang1080f0c2022-11-22 18:24:14 +08001272// UseVndk() returns true if this module is built against VNDK.
1273// This means the vendor and product variants of a module.
Ivan Lozano52767be2019-10-18 14:49:46 -07001274func (c *Module) UseVndk() bool {
Inseob Kim64c43952019-08-26 16:52:35 +09001275 return c.Properties.VndkVersion != ""
Dan Willemsen4416e5d2017-04-06 12:43:22 -07001276}
1277
Colin Crossc511bc52020-04-07 16:50:32 +00001278func (c *Module) canUseSdk() bool {
Colin Cross94e347e2021-01-19 14:56:07 -08001279 return c.Os() == android.Android && c.Target().NativeBridge == android.NativeBridgeDisabled &&
Kiyoung Kimaa394802024-01-08 12:55:45 +09001280 !c.InVendorOrProduct() && !c.InRamdisk() && !c.InRecovery() && !c.InVendorRamdisk()
Colin Crossc511bc52020-04-07 16:50:32 +00001281}
1282
1283func (c *Module) UseSdk() bool {
1284 if c.canUseSdk() {
Colin Cross1348ce32020-10-01 13:37:16 -07001285 return String(c.Properties.Sdk_version) != ""
Colin Crossc511bc52020-04-07 16:50:32 +00001286 }
1287 return false
1288}
1289
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001290func (c *Module) isCoverageVariant() bool {
1291 return c.coverage.Properties.IsCoverageVariant
1292}
1293
Colin Cross95f1ca02020-10-29 20:47:22 -07001294func (c *Module) IsNdk(config android.Config) bool {
1295 return inList(c.BaseModuleName(), *getNDKKnownLibs(config))
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001296}
1297
Colin Cross127bb8b2020-12-16 16:46:01 -08001298func (c *Module) IsLlndk() bool {
1299 return c.VendorProperties.IsLLNDK
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001300}
1301
Colin Cross1f3f1302021-04-26 18:37:44 -07001302func (m *Module) NeedsLlndkVariants() bool {
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001303 lib := moduleLibraryInterface(m)
Colin Cross1f3f1302021-04-26 18:37:44 -07001304 return lib != nil && (lib.hasLLNDKStubs() || lib.hasLLNDKHeaders())
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001305}
1306
Colin Cross5271fea2021-04-27 13:06:04 -07001307func (m *Module) NeedsVendorPublicLibraryVariants() bool {
1308 lib := moduleLibraryInterface(m)
1309 return lib != nil && (lib.hasVendorPublicLibrary())
1310}
1311
1312// IsVendorPublicLibrary returns true for vendor public libraries.
1313func (c *Module) IsVendorPublicLibrary() bool {
1314 return c.VendorProperties.IsVendorPublicLibrary
1315}
1316
Ivan Lozanof1868af2022-04-12 13:08:36 -04001317func (c *Module) IsVndkPrebuiltLibrary() bool {
1318 if _, ok := c.linker.(*vndkPrebuiltLibraryDecorator); ok {
1319 return true
1320 }
1321 return false
1322}
1323
1324func (c *Module) SdkAndPlatformVariantVisibleToMake() bool {
1325 return c.Properties.SdkAndPlatformVariantVisibleToMake
1326}
1327
Ivan Lozanod7586b62021-04-01 09:49:36 -04001328func (c *Module) HasLlndkStubs() bool {
1329 lib := moduleLibraryInterface(c)
1330 return lib != nil && lib.hasLLNDKStubs()
1331}
1332
1333func (c *Module) StubsVersion() string {
1334 if lib, ok := c.linker.(versionedInterface); ok {
1335 return lib.stubsVersion()
1336 }
1337 panic(fmt.Errorf("StubsVersion called on non-versioned module: %q", c.BaseModuleName()))
1338}
1339
Colin Cross127bb8b2020-12-16 16:46:01 -08001340// isImplementationForLLNDKPublic returns true for any variant of a cc_library that has LLNDK stubs
1341// and does not set llndk.vendor_available: false.
1342func (c *Module) isImplementationForLLNDKPublic() bool {
1343 library, _ := c.library.(*libraryDecorator)
1344 return library != nil && library.hasLLNDKStubs() &&
Colin Cross0fb7fcd2021-03-02 11:00:07 -08001345 !Bool(library.Properties.Llndk.Private)
Colin Cross127bb8b2020-12-16 16:46:01 -08001346}
1347
Colin Cross3513fb12024-01-24 14:44:47 -08001348func (c *Module) isAfdoCompile(ctx ModuleContext) bool {
Yi Kong4ef54592022-02-14 20:00:10 +08001349 if afdo := c.afdo; afdo != nil {
Colin Cross3513fb12024-01-24 14:44:47 -08001350 return afdo.isAfdoCompile(ctx)
Yi Kong4ef54592022-02-14 20:00:10 +08001351 }
1352 return false
1353}
1354
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001355func (c *Module) isOrderfileCompile() bool {
1356 if orderfile := c.orderfile; orderfile != nil {
1357 return orderfile.Properties.OrderfileLoad
1358 }
1359 return false
1360}
1361
Yi Kongc702ebd2022-08-19 16:02:45 +08001362func (c *Module) isCfi() bool {
Colin Cross694fced2024-06-25 14:56:42 -07001363 return c.sanitize.isSanitizerEnabled(cfi)
Yi Kongc702ebd2022-08-19 16:02:45 +08001364}
1365
Yi Konged79fa32023-06-04 17:15:42 +09001366func (c *Module) isFuzzer() bool {
Colin Cross694fced2024-06-25 14:56:42 -07001367 return c.sanitize.isSanitizerEnabled(Fuzzer)
Yi Konged79fa32023-06-04 17:15:42 +09001368}
1369
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001370func (c *Module) isNDKStubLibrary() bool {
1371 if _, ok := c.compiler.(*stubDecorator); ok {
1372 return true
1373 }
1374 return false
1375}
1376
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001377func (c *Module) SubName() string {
1378 return c.Properties.SubName
1379}
1380
Jiyong Park25fc6a92018-11-18 18:02:45 +09001381func (c *Module) IsStubs() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001382 if lib := c.library; lib != nil {
1383 return lib.buildStubs()
Jiyong Park25fc6a92018-11-18 18:02:45 +09001384 }
1385 return false
1386}
1387
1388func (c *Module) HasStubsVariants() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001389 if lib := c.library; lib != nil {
1390 return lib.hasStubsVariants()
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001391 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09001392 return false
1393}
1394
Alan Stokes73feba32022-11-14 12:21:24 +00001395func (c *Module) IsStubsImplementationRequired() bool {
1396 if lib := c.library; lib != nil {
1397 return lib.isStubsImplementationRequired()
1398 }
1399 return false
1400}
1401
Colin Cross0477b422020-10-13 18:43:54 -07001402// If this is a stubs library, ImplementationModuleName returns the name of the module that contains
1403// the implementation. If it is an implementation library it returns its own name.
1404func (c *Module) ImplementationModuleName(ctx android.BaseModuleContext) string {
1405 name := ctx.OtherModuleName(c)
1406 if versioned, ok := c.linker.(versionedInterface); ok {
1407 name = versioned.implementationModuleName(name)
1408 }
1409 return name
1410}
1411
Martin Stjernholm2856c662020-12-02 15:03:42 +00001412// Similar to ImplementationModuleName, but uses the Make variant of the module
1413// name as base name, for use in AndroidMk output. E.g. for a prebuilt module
1414// where the Soong name is prebuilt_foo, this returns foo (which works in Make
1415// under the premise that the prebuilt module overrides its source counterpart
1416// if it is exposed to Make).
1417func (c *Module) ImplementationModuleNameForMake(ctx android.BaseModuleContext) string {
1418 name := c.BaseModuleName()
1419 if versioned, ok := c.linker.(versionedInterface); ok {
1420 name = versioned.implementationModuleName(name)
1421 }
1422 return name
1423}
1424
Jiyong Park7d55b612021-06-11 17:22:09 +09001425func (c *Module) Bootstrap() bool {
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001426 return Bool(c.Properties.Bootstrap)
1427}
1428
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001429func (c *Module) nativeCoverage() bool {
Pirama Arumuga Nainar5f69b9a2019-09-12 13:18:48 -07001430 // Bug: http://b/137883967 - native-bridge modules do not currently work with coverage
1431 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1432 return false
1433 }
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001434 return c.linker != nil && c.linker.nativeCoverage()
1435}
1436
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001437func (c *Module) IsSnapshotPrebuilt() bool {
Ivan Lozanod1dec542021-05-26 15:33:11 -04001438 if p, ok := c.linker.(SnapshotInterface); ok {
1439 return p.IsSnapshotPrebuilt()
Inseob Kimeec88e12020-01-22 11:11:29 +09001440 }
1441 return false
Inseob Kim8471cda2019-11-15 09:59:12 +09001442}
1443
Jiyong Parkf1194352019-02-25 11:05:47 +09001444func isBionic(name string) bool {
1445 switch name {
Jooyung Hanbff73352022-12-13 18:29:44 +09001446 case "libc", "libm", "libdl", "libdl_android", "linker":
Jiyong Parkf1194352019-02-25 11:05:47 +09001447 return true
1448 }
1449 return false
1450}
1451
Martin Stjernholm279de572019-09-10 23:18:20 +01001452func InstallToBootstrap(name string, config android.Config) bool {
Florian Mayer95cd6db2023-03-23 17:48:07 -07001453 if name == "libclang_rt.hwasan" || name == "libc_hwasan" {
Jooyung Han8ce8db92020-05-15 19:05:05 +09001454 return true
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001455 }
1456 return isBionic(name)
1457}
1458
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001459func (c *Module) XrefCcFiles() android.Paths {
1460 return c.kytheFiles
1461}
1462
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001463func (c *Module) isCfiAssemblySupportEnabled() bool {
1464 return c.sanitize != nil &&
1465 Bool(c.sanitize.Properties.Sanitize.Config.Cfi_assembly_support)
1466}
1467
Inseob Kim800d1142021-06-14 12:03:51 +09001468func (c *Module) InstallInRoot() bool {
1469 return c.installer != nil && c.installer.installInRoot()
1470}
1471
Colin Crossca860ac2016-01-04 14:34:37 -08001472type baseModuleContext struct {
Colin Cross0ea8ba82019-06-06 14:33:29 -07001473 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001474 moduleContextImpl
1475}
1476
Colin Cross37047f12016-12-13 17:06:13 -08001477type depsContext struct {
1478 android.BottomUpMutatorContext
1479 moduleContextImpl
1480}
1481
Colin Crossca860ac2016-01-04 14:34:37 -08001482type moduleContext struct {
Colin Cross635c3b02016-05-18 15:37:25 -07001483 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001484 moduleContextImpl
1485}
1486
1487type moduleContextImpl struct {
1488 mod *Module
1489 ctx BaseModuleContext
1490}
1491
Colin Crossb98c8b02016-07-29 13:44:28 -07001492func (ctx *moduleContextImpl) toolchain() config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001493 return ctx.mod.toolchain(ctx.ctx)
1494}
1495
1496func (ctx *moduleContextImpl) static() bool {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00001497 return ctx.mod.static()
Colin Crossca860ac2016-01-04 14:34:37 -08001498}
1499
1500func (ctx *moduleContextImpl) staticBinary() bool {
Jiyong Park379de2f2018-12-19 02:47:14 +09001501 return ctx.mod.staticBinary()
Colin Crossca860ac2016-01-04 14:34:37 -08001502}
1503
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07001504func (ctx *moduleContextImpl) testBinary() bool {
1505 return ctx.mod.testBinary()
1506}
1507
Yi Kong56fc1b62022-09-06 16:24:00 +08001508func (ctx *moduleContextImpl) testLibrary() bool {
1509 return ctx.mod.testLibrary()
1510}
1511
Jiyong Park1d1119f2019-07-29 21:27:18 +09001512func (ctx *moduleContextImpl) header() bool {
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001513 return ctx.mod.Header()
Jiyong Park1d1119f2019-07-29 21:27:18 +09001514}
1515
Inseob Kim7f283f42020-06-01 21:53:49 +09001516func (ctx *moduleContextImpl) binary() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001517 return ctx.mod.Binary()
Inseob Kim7f283f42020-06-01 21:53:49 +09001518}
1519
Inseob Kim1042d292020-06-01 23:23:05 +09001520func (ctx *moduleContextImpl) object() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001521 return ctx.mod.Object()
Inseob Kim1042d292020-06-01 23:23:05 +09001522}
1523
Yi Kong5786f5c2024-05-28 02:22:34 +09001524func (ctx *moduleContextImpl) optimizeForSize() bool {
1525 return ctx.mod.OptimizeForSize()
1526}
1527
Jooyung Hanccce2f22020-03-07 03:45:53 +09001528func (ctx *moduleContextImpl) canUseSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001529 return ctx.mod.canUseSdk()
Jooyung Hanccce2f22020-03-07 03:45:53 +09001530}
1531
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001532func (ctx *moduleContextImpl) useSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001533 return ctx.mod.UseSdk()
Colin Crossca860ac2016-01-04 14:34:37 -08001534}
1535
1536func (ctx *moduleContextImpl) sdkVersion() string {
Dan Willemsena96ff642016-06-07 12:34:45 -07001537 if ctx.ctx.Device() {
Justin Yun732aa6a2018-03-23 17:43:47 +09001538 return String(ctx.mod.Properties.Sdk_version)
Dan Willemsena96ff642016-06-07 12:34:45 -07001539 }
1540 return ""
Colin Crossca860ac2016-01-04 14:34:37 -08001541}
1542
Jiyong Parkb35a8192020-08-10 15:59:36 +09001543func (ctx *moduleContextImpl) minSdkVersion() string {
1544 ver := ctx.mod.MinSdkVersion()
1545 if ver == "apex_inherit" && !ctx.isForPlatform() {
1546 ver = ctx.apexSdkVersion().String()
1547 }
1548 if ver == "apex_inherit" || ver == "" {
1549 ver = ctx.sdkVersion()
1550 }
Yi-Yo Chiang88960aa2024-01-19 15:02:29 +08001551
1552 if ctx.ctx.Device() {
1553 config := ctx.ctx.Config()
Kiyoung Kim8f05c542024-05-22 16:50:34 +09001554 if ctx.inVendor() {
Yi-Yo Chiang88960aa2024-01-19 15:02:29 +08001555 // If building for vendor with final API, then use the latest _stable_ API as "current".
1556 if config.VendorApiLevelFrozen() && (ver == "" || ver == "current") {
1557 ver = config.PlatformSdkVersion().String()
1558 }
1559 }
1560 }
1561
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001562 // For crt objects, the meaning of min_sdk_version is very different from other types of
1563 // module. For them, min_sdk_version defines the oldest version that the build system will
1564 // create versioned variants for. For example, if min_sdk_version is 16, then sdk variant of
1565 // the crt object has local variants of 16, 17, ..., up to the latest version. sdk_version
1566 // and min_sdk_version properties of the variants are set to the corresponding version
Jiyong Park5df7bd32021-08-25 16:18:46 +09001567 // numbers. However, the non-sdk variant (for apex or platform) of the crt object is left
1568 // untouched. min_sdk_version: 16 doesn't actually mean that the non-sdk variant has to
1569 // support such an old version. The version is set to the later version in case when the
1570 // non-sdk variant is for the platform, or the min_sdk_version of the containing APEX if
1571 // it's for an APEX.
1572 if ctx.mod.isCrt() && !ctx.isSdkVariant() {
1573 if ctx.isForPlatform() {
1574 ver = strconv.Itoa(android.FutureApiLevelInt)
1575 } else { // for apex
1576 ver = ctx.apexSdkVersion().String()
1577 if ver == "" { // in case when min_sdk_version was not set by the APEX
1578 ver = ctx.sdkVersion()
1579 }
1580 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001581 }
1582
Jiyong Parkb35a8192020-08-10 15:59:36 +09001583 // Also make sure that minSdkVersion is not greater than sdkVersion, if they are both numbers
1584 sdkVersionInt, err := strconv.Atoi(ctx.sdkVersion())
1585 minSdkVersionInt, err2 := strconv.Atoi(ver)
1586 if err == nil && err2 == nil {
1587 if sdkVersionInt < minSdkVersionInt {
1588 return strconv.Itoa(sdkVersionInt)
1589 }
1590 }
1591 return ver
1592}
1593
1594func (ctx *moduleContextImpl) isSdkVariant() bool {
1595 return ctx.mod.IsSdkVariant()
1596}
1597
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001598func (ctx *moduleContextImpl) useVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001599 return ctx.mod.UseVndk()
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001600}
Justin Yun8effde42017-06-23 19:24:43 +09001601
Kiyoung Kimaa394802024-01-08 12:55:45 +09001602func (ctx *moduleContextImpl) InVendorOrProduct() bool {
1603 return ctx.mod.InVendorOrProduct()
1604}
1605
Colin Cross95f1ca02020-10-29 20:47:22 -07001606func (ctx *moduleContextImpl) isNdk(config android.Config) bool {
1607 return ctx.mod.IsNdk(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001608}
1609
Colin Cross127bb8b2020-12-16 16:46:01 -08001610func (ctx *moduleContextImpl) IsLlndk() bool {
1611 return ctx.mod.IsLlndk()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001612}
1613
Colin Cross127bb8b2020-12-16 16:46:01 -08001614func (ctx *moduleContextImpl) isImplementationForLLNDKPublic() bool {
1615 return ctx.mod.isImplementationForLLNDKPublic()
1616}
1617
Colin Cross3513fb12024-01-24 14:44:47 -08001618func (ctx *moduleContextImpl) isAfdoCompile(mctx ModuleContext) bool {
1619 return ctx.mod.isAfdoCompile(mctx)
Yi Kong4ef54592022-02-14 20:00:10 +08001620}
1621
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001622func (ctx *moduleContextImpl) isOrderfileCompile() bool {
1623 return ctx.mod.isOrderfileCompile()
1624}
1625
Yi Kongc702ebd2022-08-19 16:02:45 +08001626func (ctx *moduleContextImpl) isCfi() bool {
1627 return ctx.mod.isCfi()
1628}
1629
Yi Konged79fa32023-06-04 17:15:42 +09001630func (ctx *moduleContextImpl) isFuzzer() bool {
1631 return ctx.mod.isFuzzer()
1632}
1633
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001634func (ctx *moduleContextImpl) isNDKStubLibrary() bool {
1635 return ctx.mod.isNDKStubLibrary()
1636}
1637
Colin Cross5271fea2021-04-27 13:06:04 -07001638func (ctx *moduleContextImpl) IsVendorPublicLibrary() bool {
1639 return ctx.mod.IsVendorPublicLibrary()
1640}
1641
Dan Willemsen8146b2f2016-03-30 21:00:30 -07001642func (ctx *moduleContextImpl) selectedStl() string {
1643 if stl := ctx.mod.stl; stl != nil {
1644 return stl.Properties.SelectedStl
1645 }
1646 return ""
1647}
1648
Ivan Lozanobd721262018-11-27 14:33:03 -08001649func (ctx *moduleContextImpl) useClangLld(actx ModuleContext) bool {
1650 return ctx.mod.linker.useClangLld(actx)
1651}
1652
Colin Crossce75d2c2016-10-06 16:12:58 -07001653func (ctx *moduleContextImpl) baseModuleName() string {
Spandan Das2b6dfb52024-01-19 00:22:22 +00001654 return ctx.mod.BaseModuleName()
Colin Crossce75d2c2016-10-06 16:12:58 -07001655}
1656
Logan Chiene274fc92019-12-03 11:18:32 -08001657func (ctx *moduleContextImpl) isForPlatform() bool {
Colin Crossff694a82023-12-13 15:54:49 -08001658 apexInfo, _ := android.ModuleProvider(ctx.ctx, android.ApexInfoProvider)
1659 return apexInfo.IsForPlatform()
Logan Chiene274fc92019-12-03 11:18:32 -08001660}
1661
Colin Crosse07f2312020-08-13 11:24:56 -07001662func (ctx *moduleContextImpl) apexVariationName() string {
Colin Crossff694a82023-12-13 15:54:49 -08001663 apexInfo, _ := android.ModuleProvider(ctx.ctx, android.ApexInfoProvider)
1664 return apexInfo.ApexVariationName
Jiyong Park25fc6a92018-11-18 18:02:45 +09001665}
1666
Dan Albertc8060532020-07-22 22:32:17 -07001667func (ctx *moduleContextImpl) apexSdkVersion() android.ApiLevel {
Jooyung Han75568392020-03-20 04:29:24 +09001668 return ctx.mod.apexSdkVersion
Jooyung Hanccce2f22020-03-07 03:45:53 +09001669}
1670
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001671func (ctx *moduleContextImpl) bootstrap() bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09001672 return ctx.mod.Bootstrap()
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001673}
1674
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001675func (ctx *moduleContextImpl) nativeCoverage() bool {
1676 return ctx.mod.nativeCoverage()
1677}
1678
Colin Cross56a83212020-09-15 18:30:11 -07001679func (ctx *moduleContextImpl) directlyInAnyApex() bool {
1680 return ctx.mod.DirectlyInAnyApex()
1681}
1682
Colin Cross95b07f22020-12-16 11:06:50 -08001683func (ctx *moduleContextImpl) isPreventInstall() bool {
1684 return ctx.mod.Properties.PreventInstall
1685}
1686
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -08001687func (ctx *moduleContextImpl) getSharedFlags() *SharedFlags {
1688 shared := &ctx.mod.sharedFlags
1689 if shared.flagsMap == nil {
1690 shared.numSharedFlags = 0
1691 shared.flagsMap = make(map[string]string)
1692 }
1693 return shared
1694}
1695
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001696func (ctx *moduleContextImpl) isCfiAssemblySupportEnabled() bool {
1697 return ctx.mod.isCfiAssemblySupportEnabled()
1698}
1699
Colin Cross4a9e6ec2023-12-18 15:29:41 -08001700func (ctx *moduleContextImpl) notInPlatform() bool {
1701 return ctx.mod.NotInPlatform()
1702}
1703
Colin Cross635c3b02016-05-18 15:37:25 -07001704func newBaseModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001705 return &Module{
1706 hod: hod,
1707 multilib: multilib,
1708 }
1709}
1710
Colin Cross635c3b02016-05-18 15:37:25 -07001711func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001712 module := newBaseModule(hod, multilib)
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001713 module.features = []feature{
1714 &tidyFeature{},
1715 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001716 module.stl = &stl{}
Colin Cross16b23492016-01-06 14:41:07 -08001717 module.sanitize = &sanitize{}
Dan Willemsen581341d2017-02-09 16:16:31 -08001718 module.coverage = &coverage{}
Cory Barkera1da26f2022-06-07 20:12:06 +00001719 module.fuzzer = &fuzzer{}
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001720 module.sabi = &sabi{}
Stephen Craneba090d12017-05-09 15:44:35 -07001721 module.lto = &lto{}
Yi Kongeb8efc92021-12-09 18:06:29 +08001722 module.afdo = &afdo{}
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001723 module.orderfile = &orderfile{}
Colin Crossca860ac2016-01-04 14:34:37 -08001724 return module
1725}
1726
Colin Crossce75d2c2016-10-06 16:12:58 -07001727func (c *Module) Prebuilt() *android.Prebuilt {
1728 if p, ok := c.linker.(prebuiltLinkerInterface); ok {
1729 return p.prebuilt()
1730 }
1731 return nil
1732}
1733
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001734func (c *Module) IsPrebuilt() bool {
1735 return c.Prebuilt() != nil
1736}
1737
Colin Crossce75d2c2016-10-06 16:12:58 -07001738func (c *Module) Name() string {
1739 name := c.ModuleBase.Name()
Dan Willemsen01a90592017-04-07 15:21:13 -07001740 if p, ok := c.linker.(interface {
1741 Name(string) string
1742 }); ok {
Colin Crossce75d2c2016-10-06 16:12:58 -07001743 name = p.Name(name)
1744 }
1745 return name
1746}
1747
Alex Light3d673592019-01-18 14:37:31 -08001748func (c *Module) Symlinks() []string {
1749 if p, ok := c.installer.(interface {
1750 symlinkList() []string
1751 }); ok {
1752 return p.symlinkList()
1753 }
1754 return nil
1755}
1756
Chris Parsons216e10a2020-07-09 17:12:52 -04001757func (c *Module) DataPaths() []android.DataPath {
Liz Kammer1c14a212020-05-12 15:26:55 -07001758 if p, ok := c.installer.(interface {
Chris Parsons216e10a2020-07-09 17:12:52 -04001759 dataPaths() []android.DataPath
Liz Kammer1c14a212020-05-12 15:26:55 -07001760 }); ok {
1761 return p.dataPaths()
1762 }
1763 return nil
1764}
1765
Ivan Lozanof1868af2022-04-12 13:08:36 -04001766func getNameSuffixWithVndkVersion(ctx android.ModuleContext, c LinkableInterface) string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001767 // Returns the name suffix for product and vendor variants. If the VNDK version is not
1768 // "current", it will append the VNDK version to the name suffix.
Justin Yun5f7f7e82019-11-18 19:52:14 +09001769 var nameSuffix string
Ivan Lozanof9e21722020-12-02 09:00:51 -05001770 if c.InProduct() {
Justin Yund00f5ca2021-02-03 19:43:02 +09001771 if c.ProductSpecific() {
1772 // If the module is product specific with 'product_specific: true',
1773 // do not add a name suffix because it is a base module.
1774 return ""
1775 }
Justin Yunaf1fde42023-09-27 16:22:10 +09001776 return ProductSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001777 } else {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05001778 nameSuffix = VendorSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001779 }
Kiyoung Kim4e765b12024-04-04 17:33:42 +09001780 if c.VndkVersion() != "" {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001781 // add version suffix only if the module is using different vndk version than the
1782 // version in product or vendor partition.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001783 nameSuffix += "." + c.VndkVersion()
Justin Yun5f7f7e82019-11-18 19:52:14 +09001784 }
1785 return nameSuffix
1786}
1787
Ivan Lozanof1868af2022-04-12 13:08:36 -04001788func GetSubnameProperty(actx android.ModuleContext, c LinkableInterface) string {
1789 var subName = ""
Inseob Kim64c43952019-08-26 16:52:35 +09001790
1791 if c.Target().NativeBridge == android.NativeBridgeEnabled {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001792 subName += NativeBridgeSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001793 }
1794
Colin Cross127bb8b2020-12-16 16:46:01 -08001795 llndk := c.IsLlndk()
Kiyoung Kimaa394802024-01-08 12:55:45 +09001796 if llndk || (c.InVendorOrProduct() && c.HasNonSystemVariants()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001797 // .vendor.{version} suffix is added for vendor variant or .product.{version} suffix is
1798 // added for product variant only when we have vendor and product variants with core
1799 // variant. The suffix is not added for vendor-only or product-only module.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001800 subName += getNameSuffixWithVndkVersion(actx, c)
Colin Cross5271fea2021-04-27 13:06:04 -07001801 } else if c.IsVendorPublicLibrary() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001802 subName += vendorPublicLibrarySuffix
1803 } else if c.IsVndkPrebuiltLibrary() {
Inseob Kim64c43952019-08-26 16:52:35 +09001804 // .vendor suffix is added for backward compatibility with VNDK snapshot whose names with
1805 // such suffixes are already hard-coded in prebuilts/vndk/.../Android.bp.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001806 subName += VendorSuffix
Yifan Hong1b3348d2020-01-21 15:53:22 -08001807 } else if c.InRamdisk() && !c.OnlyInRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001808 subName += RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001809 } else if c.InVendorRamdisk() && !c.OnlyInVendorRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001810 subName += VendorRamdiskSuffix
Ivan Lozano52767be2019-10-18 14:49:46 -07001811 } else if c.InRecovery() && !c.OnlyInRecovery() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001812 subName += RecoverySuffix
1813 } else if c.IsSdkVariant() && (c.SdkAndPlatformVariantVisibleToMake() || c.SplitPerApiLevel()) {
1814 subName += sdkSuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001815 if c.SplitPerApiLevel() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001816 subName += "." + c.SdkVersion()
Dan Albert92fe7402020-07-15 13:33:30 -07001817 }
Spandan Dasb2b41d52023-04-13 18:15:05 +00001818 } else if c.IsStubs() && c.IsSdkVariant() {
1819 // Public API surface (NDK)
1820 // Add a suffix to this stub variant to distinguish it from the module-lib stub variant.
1821 subName = sdkSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001822 }
Ivan Lozanof1868af2022-04-12 13:08:36 -04001823
1824 return subName
Chris Parsons8d6e4332021-02-22 16:13:50 -05001825}
1826
Sam Delmerico75dbca22023-04-20 13:13:25 +00001827func moduleContextFromAndroidModuleContext(actx android.ModuleContext, c *Module) ModuleContext {
1828 ctx := &moduleContext{
1829 ModuleContext: actx,
1830 moduleContextImpl: moduleContextImpl{
1831 mod: c,
1832 },
1833 }
1834 ctx.ctx = ctx
1835 return ctx
1836}
1837
Spandan Das20fce2d2023-04-12 17:21:39 +00001838// TODO (b/277651159): Remove this allowlist
1839var (
1840 skipStubLibraryMultipleApexViolation = map[string]bool{
1841 "libclang_rt.asan": true,
1842 "libclang_rt.hwasan": true,
1843 // runtime apex
1844 "libc": true,
1845 "libc_hwasan": true,
1846 "libdl_android": true,
1847 "libm": true,
1848 "libdl": true,
Spandan Das1a0c6e12024-01-04 01:44:17 +00001849 "libz": true,
Spandan Das20fce2d2023-04-12 17:21:39 +00001850 // art apex
Martin Stjernholm75598032024-07-12 18:47:26 +01001851 // TODO(b/234351700): Remove this when com.android.art.debug is gone.
Spandan Das20fce2d2023-04-12 17:21:39 +00001852 "libandroidio": true,
1853 "libdexfile": true,
Martin Stjernholm75598032024-07-12 18:47:26 +01001854 "libdexfiled": true, // com.android.art.debug only
Spandan Das20fce2d2023-04-12 17:21:39 +00001855 "libnativebridge": true,
1856 "libnativehelper": true,
1857 "libnativeloader": true,
1858 "libsigchain": true,
1859 }
1860)
1861
1862// Returns true if a stub library could be installed in multiple apexes
1863func (c *Module) stubLibraryMultipleApexViolation(ctx android.ModuleContext) bool {
1864 // If this is not an apex variant, no check necessary
1865 if !c.InAnyApex() {
1866 return false
1867 }
1868 // If this is not a stub library, no check necessary
1869 if !c.HasStubsVariants() {
1870 return false
1871 }
1872 // Skip the allowlist
1873 // Use BaseModuleName so that this matches prebuilts.
1874 if _, exists := skipStubLibraryMultipleApexViolation[c.BaseModuleName()]; exists {
1875 return false
1876 }
1877
1878 _, aaWithoutTestApexes, _ := android.ListSetDifference(c.ApexAvailable(), c.TestApexes())
1879 // Stub libraries should not have more than one apex_available
1880 if len(aaWithoutTestApexes) > 1 {
1881 return true
1882 }
1883 // Stub libraries should not use the wildcard
1884 if aaWithoutTestApexes[0] == android.AvailableToAnyApex {
1885 return true
1886 }
1887 // Default: no violation
1888 return false
1889}
1890
Chris Parsons8d6e4332021-02-22 16:13:50 -05001891func (c *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
Ronald Braunstein6a08d492024-04-15 12:55:30 -07001892 ctx := moduleContextFromAndroidModuleContext(actx, c)
1893
Inseob Kim37e0bb02024-04-29 15:54:44 +09001894 c.logtagsPaths = android.PathsForModuleSrc(actx, c.Properties.Logtags)
1895 android.SetProvider(ctx, android.LogtagsProviderKey, &android.LogtagsInfo{
1896 Logtags: c.logtagsPaths,
1897 })
1898
Ronald Braunstein6a08d492024-04-15 12:55:30 -07001899 // If Test_only is set on a module in bp file, respect the setting, otherwise
1900 // see if is a known test module type.
1901 testOnly := c.testModule || c.testLibrary()
1902 if c.sourceProperties.Test_only != nil {
1903 testOnly = Bool(c.sourceProperties.Test_only)
1904 }
1905 // Keep before any early returns.
1906 android.SetProvider(ctx, android.TestOnlyProviderKey, android.TestModuleInformation{
1907 TestOnly: testOnly,
1908 TopLevelTarget: c.testModule,
1909 })
1910
Ivan Lozanof1868af2022-04-12 13:08:36 -04001911 c.Properties.SubName = GetSubnameProperty(actx, c)
Colin Crossff694a82023-12-13 15:54:49 -08001912 apexInfo, _ := android.ModuleProvider(actx, android.ApexInfoProvider)
Chris Parsons8d6e4332021-02-22 16:13:50 -05001913 if !apexInfo.IsForPlatform() {
1914 c.hideApexVariantFromMake = true
1915 }
1916
Chris Parsonseefc9e62021-04-02 17:36:47 -04001917 c.makeLinkType = GetMakeLinkType(actx, c)
1918
Colin Crossf18e1102017-11-16 14:33:08 -08001919 deps := c.depsToPaths(ctx)
1920 if ctx.Failed() {
1921 return
1922 }
1923
Joe Onorato37f900c2023-07-18 16:58:16 -07001924 for _, generator := range c.generators {
1925 gen := generator.GeneratorSources(ctx)
1926 deps.IncludeDirs = append(deps.IncludeDirs, gen.IncludeDirs...)
1927 deps.ReexportedDirs = append(deps.ReexportedDirs, gen.ReexportedDirs...)
1928 deps.GeneratedDeps = append(deps.GeneratedDeps, gen.Headers...)
1929 deps.ReexportedGeneratedHeaders = append(deps.ReexportedGeneratedHeaders, gen.Headers...)
1930 deps.ReexportedDeps = append(deps.ReexportedDeps, gen.Headers...)
1931 if len(deps.Objs.objFiles) == 0 {
1932 // If we are reusuing object files (which happens when we're a shared library and we're
1933 // reusing our static variant's object files), then skip adding the actual source files,
1934 // because we already have the object for it.
1935 deps.GeneratedSources = append(deps.GeneratedSources, gen.Sources...)
1936 }
1937 }
1938
1939 if ctx.Failed() {
1940 return
1941 }
1942
Spandan Das20fce2d2023-04-12 17:21:39 +00001943 if c.stubLibraryMultipleApexViolation(actx) {
1944 actx.PropertyErrorf("apex_available",
1945 "Stub libraries should have a single apex_available (test apexes excluded). Got %v", c.ApexAvailable())
1946 }
Dan Willemsen8536d6b2018-10-07 20:54:34 -07001947 if c.Properties.Clang != nil && *c.Properties.Clang == false {
1948 ctx.PropertyErrorf("clang", "false (GCC) is no longer supported")
Alixb5f6d9e2022-04-20 23:00:58 +00001949 } else if c.Properties.Clang != nil && !ctx.DeviceConfig().BuildBrokenClangProperty() {
1950 ctx.PropertyErrorf("clang", "property is deprecated, see Changes.md file")
Dan Willemsen8536d6b2018-10-07 20:54:34 -07001951 }
1952
Colin Crossca860ac2016-01-04 14:34:37 -08001953 flags := Flags{
1954 Toolchain: c.toolchain(ctx),
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001955 EmitXrefs: ctx.Config().EmitXrefRules(),
Colin Crossca860ac2016-01-04 14:34:37 -08001956 }
Joe Onorato37f900c2023-07-18 16:58:16 -07001957 for _, generator := range c.generators {
1958 flags = generator.GeneratorFlags(ctx, flags, deps)
1959 }
Colin Crossca860ac2016-01-04 14:34:37 -08001960 if c.compiler != nil {
Colin Crossf18e1102017-11-16 14:33:08 -08001961 flags = c.compiler.compilerFlags(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001962 }
1963 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001964 flags = c.linker.linkerFlags(ctx, flags)
Colin Crossca860ac2016-01-04 14:34:37 -08001965 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001966 if c.stl != nil {
1967 flags = c.stl.flags(ctx, flags)
1968 }
Colin Cross16b23492016-01-06 14:41:07 -08001969 if c.sanitize != nil {
1970 flags = c.sanitize.flags(ctx, flags)
1971 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001972 if c.coverage != nil {
Pirama Arumuga Nainar82fe59b2019-07-02 14:55:35 -07001973 flags, deps = c.coverage.flags(ctx, flags, deps)
Dan Willemsen581341d2017-02-09 16:16:31 -08001974 }
Cory Barkera1da26f2022-06-07 20:12:06 +00001975 if c.fuzzer != nil {
1976 flags = c.fuzzer.flags(ctx, flags)
1977 }
Stephen Craneba090d12017-05-09 15:44:35 -07001978 if c.lto != nil {
1979 flags = c.lto.flags(ctx, flags)
1980 }
Yi Kongeb8efc92021-12-09 18:06:29 +08001981 if c.afdo != nil {
1982 flags = c.afdo.flags(ctx, flags)
1983 }
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001984 if c.orderfile != nil {
1985 flags = c.orderfile.flags(ctx, flags)
1986 }
Colin Crossca860ac2016-01-04 14:34:37 -08001987 for _, feature := range c.features {
1988 flags = feature.flags(ctx, flags)
1989 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001990 if ctx.Failed() {
1991 return
1992 }
1993
Colin Cross4af21ed2019-11-04 09:37:55 -08001994 flags.Local.CFlags, _ = filterList(flags.Local.CFlags, config.IllegalFlags)
1995 flags.Local.CppFlags, _ = filterList(flags.Local.CppFlags, config.IllegalFlags)
1996 flags.Local.ConlyFlags, _ = filterList(flags.Local.ConlyFlags, config.IllegalFlags)
Colin Cross3f40fa42015-01-30 17:27:36 -08001997
Colin Cross4af21ed2019-11-04 09:37:55 -08001998 flags.Local.CommonFlags = append(flags.Local.CommonFlags, deps.Flags...)
Inseob Kim69378442019-06-03 19:10:47 +09001999
2000 for _, dir := range deps.IncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08002001 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-I"+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09002002 }
2003 for _, dir := range deps.SystemIncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08002004 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-isystem "+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09002005 }
2006
Colin Cross3e5e7782022-06-17 22:17:05 +00002007 flags.Local.LdFlags = append(flags.Local.LdFlags, deps.LdFlags...)
2008
Fabien Sanglardd61f1f42017-01-10 16:21:22 -08002009 c.flags = flags
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -07002010 // We need access to all the flags seen by a source file.
2011 if c.sabi != nil {
2012 flags = c.sabi.flags(ctx, flags)
2013 }
Dan Willemsen98ab3112019-08-27 21:20:40 -07002014
Colin Cross4af21ed2019-11-04 09:37:55 -08002015 flags.AssemblerWithCpp = inList("-xassembler-with-cpp", flags.Local.AsFlags)
Dan Willemsen98ab3112019-08-27 21:20:40 -07002016
Joe Onorato37f900c2023-07-18 16:58:16 -07002017 for _, generator := range c.generators {
2018 generator.GeneratorBuildActions(ctx, flags, deps)
2019 }
2020
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002021 var objs Objects
Colin Crossca860ac2016-01-04 14:34:37 -08002022 if c.compiler != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002023 objs = c.compiler.compile(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08002024 if ctx.Failed() {
2025 return
2026 }
Sasha Smundak2a4549e2018-11-05 16:49:08 -08002027 c.kytheFiles = objs.kytheFiles
Chih-Hung Hsieh80783772021-10-11 16:46:56 -07002028 c.objFiles = objs.objFiles
2029 c.tidyFiles = objs.tidyFiles
Colin Cross3f40fa42015-01-30 17:27:36 -08002030 }
2031
Colin Crossca860ac2016-01-04 14:34:37 -08002032 if c.linker != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002033 outputFile := c.linker.link(ctx, flags, deps, objs)
Colin Crossca860ac2016-01-04 14:34:37 -08002034 if ctx.Failed() {
2035 return
2036 }
Colin Cross635c3b02016-05-18 15:37:25 -07002037 c.outputFile = android.OptionalPathForPath(outputFile)
Jiyong Parkb0788572018-12-20 22:10:17 +09002038
Chris Parsons94a0bba2021-06-04 15:03:47 -04002039 c.maybeUnhideFromMake()
Colin Crossce75d2c2016-10-06 16:12:58 -07002040 }
Aditya Choudhary87b2ab22023-11-17 15:27:06 +00002041 if c.testModule {
Colin Cross40213022023-12-13 15:19:49 -08002042 android.SetProvider(ctx, testing.TestModuleProviderKey, testing.TestModuleProviderData{})
Aditya Choudhary87b2ab22023-11-17 15:27:06 +00002043 }
Ronald Braunsteina115e262024-04-09 18:07:38 -07002044
Colin Cross40213022023-12-13 15:19:49 -08002045 android.SetProvider(ctx, blueprint.SrcsFileProviderKey, blueprint.SrcsFileProviderData{SrcPaths: deps.GeneratedSources.Strings()})
Colin Cross5049f022015-03-18 13:28:46 -07002046
Hao Chen1c8ea5b2023-10-20 23:03:45 +00002047 if Bool(c.Properties.Cmake_snapshot_supported) {
2048 android.SetProvider(ctx, cmakeSnapshotSourcesProvider, android.GlobFiles(ctx, ctx.ModuleDir()+"/**/*", nil))
2049 }
2050
Chris Parsons94a0bba2021-06-04 15:03:47 -04002051 c.maybeInstall(ctx, apexInfo)
Colin Cross4a9e6ec2023-12-18 15:29:41 -08002052
2053 if c.linker != nil {
2054 moduleInfoJSON := ctx.ModuleInfoJSON()
2055 c.linker.moduleInfoJSON(ctx, moduleInfoJSON)
2056 moduleInfoJSON.SharedLibs = c.Properties.AndroidMkSharedLibs
2057 moduleInfoJSON.StaticLibs = c.Properties.AndroidMkStaticLibs
2058 moduleInfoJSON.SystemSharedLibs = c.Properties.AndroidMkSystemSharedLibs
2059 moduleInfoJSON.RuntimeDependencies = c.Properties.AndroidMkRuntimeLibs
2060
2061 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkSharedLibs...)
2062 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkStaticLibs...)
2063 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkHeaderLibs...)
2064 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkWholeStaticLibs...)
2065
2066 if c.sanitize != nil && len(moduleInfoJSON.Class) > 0 &&
2067 (moduleInfoJSON.Class[0] == "STATIC_LIBRARIES" || moduleInfoJSON.Class[0] == "HEADER_LIBRARIES") {
2068 if Bool(c.sanitize.Properties.SanitizeMutated.Cfi) {
2069 moduleInfoJSON.SubName += ".cfi"
2070 }
2071 if Bool(c.sanitize.Properties.SanitizeMutated.Hwaddress) {
2072 moduleInfoJSON.SubName += ".hwasan"
2073 }
2074 if Bool(c.sanitize.Properties.SanitizeMutated.Scs) {
2075 moduleInfoJSON.SubName += ".scs"
2076 }
2077 }
2078 moduleInfoJSON.SubName += c.Properties.SubName
2079
2080 if c.Properties.IsSdkVariant && c.Properties.SdkAndPlatformVariantVisibleToMake {
2081 moduleInfoJSON.Uninstallable = true
2082 }
Colin Cross4a9e6ec2023-12-18 15:29:41 -08002083 }
Wei Lia1aa2972024-06-21 13:08:51 -07002084
2085 buildComplianceMetadataInfo(ctx, c, deps)
mrziwangabdb2932024-06-18 12:43:41 -07002086
Cole Faust96a692b2024-08-08 14:47:51 -07002087 if b, ok := c.compiler.(*baseCompiler); ok {
2088 c.hasAidl = b.hasSrcExt(ctx, ".aidl")
2089 c.hasLex = b.hasSrcExt(ctx, ".l") || b.hasSrcExt(ctx, ".ll")
2090 c.hasProto = b.hasSrcExt(ctx, ".proto")
2091 c.hasRenderscript = b.hasSrcExt(ctx, ".rscript") || b.hasSrcExt(ctx, ".fs")
2092 c.hasSysprop = b.hasSrcExt(ctx, ".sysprop")
2093 c.hasWinMsg = b.hasSrcExt(ctx, ".mc")
2094 c.hasYacc = b.hasSrcExt(ctx, ".y") || b.hasSrcExt(ctx, ".yy")
2095 }
2096
mrziwangabdb2932024-06-18 12:43:41 -07002097 c.setOutputFiles(ctx)
2098}
2099
2100func (c *Module) setOutputFiles(ctx ModuleContext) {
2101 if c.outputFile.Valid() {
2102 ctx.SetOutputFiles(android.Paths{c.outputFile.Path()}, "")
2103 } else {
2104 ctx.SetOutputFiles(android.Paths{}, "")
2105 }
2106 if c.linker != nil {
2107 ctx.SetOutputFiles(android.PathsIfNonNil(c.linker.unstrippedOutputFilePath()), "unstripped")
2108 ctx.SetOutputFiles(android.PathsIfNonNil(c.linker.strippedAllOutputFilePath()), "stripped_all")
2109 }
Wei Lia1aa2972024-06-21 13:08:51 -07002110}
2111
2112func buildComplianceMetadataInfo(ctx ModuleContext, c *Module, deps PathDeps) {
2113 // Dump metadata that can not be done in android/compliance-metadata.go
2114 complianceMetadataInfo := ctx.ComplianceMetadataInfo()
2115 complianceMetadataInfo.SetStringValue(android.ComplianceMetadataProp.IS_STATIC_LIB, strconv.FormatBool(ctx.static()))
2116 complianceMetadataInfo.SetStringValue(android.ComplianceMetadataProp.BUILT_FILES, c.outputFile.String())
2117
2118 // Static deps
2119 staticDeps := ctx.GetDirectDepsWithTag(StaticDepTag(false))
2120 staticDepNames := make([]string, 0, len(staticDeps))
2121 for _, dep := range staticDeps {
2122 staticDepNames = append(staticDepNames, dep.Name())
2123 }
2124
2125 staticDepPaths := make([]string, 0, len(deps.StaticLibs))
2126 for _, dep := range deps.StaticLibs {
2127 staticDepPaths = append(staticDepPaths, dep.String())
2128 }
2129 complianceMetadataInfo.SetListValue(android.ComplianceMetadataProp.STATIC_DEPS, android.FirstUniqueStrings(staticDepNames))
2130 complianceMetadataInfo.SetListValue(android.ComplianceMetadataProp.STATIC_DEP_FILES, android.FirstUniqueStrings(staticDepPaths))
2131
2132 // Whole static deps
2133 wholeStaticDeps := ctx.GetDirectDepsWithTag(StaticDepTag(true))
2134 wholeStaticDepNames := make([]string, 0, len(wholeStaticDeps))
2135 for _, dep := range wholeStaticDeps {
2136 wholeStaticDepNames = append(wholeStaticDepNames, dep.Name())
2137 }
2138
2139 wholeStaticDepPaths := make([]string, 0, len(deps.WholeStaticLibs))
2140 for _, dep := range deps.WholeStaticLibs {
2141 wholeStaticDepPaths = append(wholeStaticDepPaths, dep.String())
2142 }
2143 complianceMetadataInfo.SetListValue(android.ComplianceMetadataProp.WHOLE_STATIC_DEPS, android.FirstUniqueStrings(wholeStaticDepNames))
2144 complianceMetadataInfo.SetListValue(android.ComplianceMetadataProp.WHOLE_STATIC_DEP_FILES, android.FirstUniqueStrings(wholeStaticDepPaths))
Chris Parsons94a0bba2021-06-04 15:03:47 -04002145}
2146
2147func (c *Module) maybeUnhideFromMake() {
2148 // If a lib is directly included in any of the APEXes or is not available to the
2149 // platform (which is often the case when the stub is provided as a prebuilt),
2150 // unhide the stubs variant having the latest version gets visible to make. In
2151 // addition, the non-stubs variant is renamed to <libname>.bootstrap. This is to
2152 // force anything in the make world to link against the stubs library. (unless it
2153 // is explicitly referenced via .bootstrap suffix or the module is marked with
2154 // 'bootstrap: true').
2155 if c.HasStubsVariants() && c.NotInPlatform() && !c.InRamdisk() &&
Kiyoung Kimaa394802024-01-08 12:55:45 +09002156 !c.InRecovery() && !c.InVendorOrProduct() && !c.static() && !c.isCoverageVariant() &&
Chris Parsons94a0bba2021-06-04 15:03:47 -04002157 c.IsStubs() && !c.InVendorRamdisk() {
2158 c.Properties.HideFromMake = false // unhide
2159 // Note: this is still non-installable
2160 }
2161}
2162
Colin Cross8ff10582023-12-07 13:10:56 -08002163// maybeInstall is called at the end of both GenerateAndroidBuildActions to run the
2164// install hooks for installable modules, like binaries and tests.
Chris Parsons94a0bba2021-06-04 15:03:47 -04002165func (c *Module) maybeInstall(ctx ModuleContext, apexInfo android.ApexInfo) {
Colin Cross1bc94122021-10-28 13:25:54 -07002166 if !proptools.BoolDefault(c.Installable(), true) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002167 // If the module has been specifically configure to not be installed then
2168 // hide from make as otherwise it will break when running inside make
2169 // as the output path to install will not be specified. Not all uninstallable
2170 // modules can be hidden from make as some are needed for resolving make side
2171 // dependencies.
2172 c.HideFromMake()
Ivan Lozanod7586b62021-04-01 09:49:36 -04002173 } else if !installable(c, apexInfo) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002174 c.SkipInstall()
2175 }
2176
2177 // Still call c.installer.install though, the installs will be stored as PackageSpecs
2178 // to allow using the outputs in a genrule.
2179 if c.installer != nil && c.outputFile.Valid() {
Colin Crossce75d2c2016-10-06 16:12:58 -07002180 c.installer.install(ctx, c.outputFile.Path())
2181 if ctx.Failed() {
2182 return
Colin Crossca860ac2016-01-04 14:34:37 -08002183 }
Dan Albertc403f7c2015-03-18 14:01:18 -07002184 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002185}
2186
Colin Cross0ea8ba82019-06-06 14:33:29 -07002187func (c *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08002188 if c.cachedToolchain == nil {
Liz Kammer356f7d42021-01-26 09:18:53 -05002189 c.cachedToolchain = config.FindToolchainWithContext(ctx)
Colin Cross3f40fa42015-01-30 17:27:36 -08002190 }
Colin Crossca860ac2016-01-04 14:34:37 -08002191 return c.cachedToolchain
Colin Cross3f40fa42015-01-30 17:27:36 -08002192}
2193
Colin Crossca860ac2016-01-04 14:34:37 -08002194func (c *Module) begin(ctx BaseModuleContext) {
Joe Onorato37f900c2023-07-18 16:58:16 -07002195 for _, generator := range c.generators {
2196 generator.GeneratorInit(ctx)
2197 }
Colin Crossca860ac2016-01-04 14:34:37 -08002198 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002199 c.compiler.compilerInit(ctx)
Colin Cross21b9a242015-03-24 14:15:58 -07002200 }
Colin Crossca860ac2016-01-04 14:34:37 -08002201 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002202 c.linker.linkerInit(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08002203 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002204 if c.stl != nil {
2205 c.stl.begin(ctx)
2206 }
Colin Cross16b23492016-01-06 14:41:07 -08002207 if c.sanitize != nil {
2208 c.sanitize.begin(ctx)
2209 }
Dan Willemsen581341d2017-02-09 16:16:31 -08002210 if c.coverage != nil {
2211 c.coverage.begin(ctx)
2212 }
Yi Kong9723e332023-12-04 14:52:53 +09002213 if c.afdo != nil {
2214 c.afdo.begin(ctx)
2215 }
Stephen Craneba090d12017-05-09 15:44:35 -07002216 if c.lto != nil {
2217 c.lto.begin(ctx)
2218 }
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00002219 if c.orderfile != nil {
2220 c.orderfile.begin(ctx)
2221 }
Dan Albert92fe7402020-07-15 13:33:30 -07002222 if ctx.useSdk() && c.IsSdkVariant() {
Dan Albert1a246272020-07-06 14:49:35 -07002223 version, err := nativeApiLevelFromUser(ctx, ctx.sdkVersion())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002224 if err != nil {
2225 ctx.PropertyErrorf("sdk_version", err.Error())
Dan Albert1a246272020-07-06 14:49:35 -07002226 c.Properties.Sdk_version = nil
2227 } else {
2228 c.Properties.Sdk_version = StringPtr(version.String())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002229 }
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002230 }
Colin Crossca860ac2016-01-04 14:34:37 -08002231}
2232
Colin Cross37047f12016-12-13 17:06:13 -08002233func (c *Module) deps(ctx DepsContext) Deps {
Colin Crossc99deeb2016-04-11 15:06:20 -07002234 deps := Deps{}
2235
Joe Onorato37f900c2023-07-18 16:58:16 -07002236 for _, generator := range c.generators {
2237 deps = generator.GeneratorDeps(ctx, deps)
2238 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002239 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002240 deps = c.compiler.compilerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002241 }
2242 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002243 deps = c.linker.linkerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002244 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002245 if c.stl != nil {
2246 deps = c.stl.deps(ctx, deps)
2247 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00002248 if c.coverage != nil {
2249 deps = c.coverage.deps(ctx, deps)
2250 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002251
Colin Crossb6715442017-10-24 11:13:31 -07002252 deps.WholeStaticLibs = android.LastUniqueStrings(deps.WholeStaticLibs)
2253 deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
2254 deps.LateStaticLibs = android.LastUniqueStrings(deps.LateStaticLibs)
2255 deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
2256 deps.LateSharedLibs = android.LastUniqueStrings(deps.LateSharedLibs)
2257 deps.HeaderLibs = android.LastUniqueStrings(deps.HeaderLibs)
Logan Chien43d34c32017-12-20 01:17:32 +08002258 deps.RuntimeLibs = android.LastUniqueStrings(deps.RuntimeLibs)
Hsin-Yi Chen715142a2024-03-27 16:31:16 +08002259 deps.LlndkHeaderLibs = android.LastUniqueStrings(deps.LlndkHeaderLibs)
Colin Crossc99deeb2016-04-11 15:06:20 -07002260
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002261 for _, lib := range deps.ReexportSharedLibHeaders {
2262 if !inList(lib, deps.SharedLibs) {
2263 ctx.PropertyErrorf("export_shared_lib_headers", "Shared library not in shared_libs: '%s'", lib)
2264 }
2265 }
2266
2267 for _, lib := range deps.ReexportStaticLibHeaders {
Steven Morelandba407c82021-04-01 22:17:50 +00002268 if !inList(lib, deps.StaticLibs) && !inList(lib, deps.WholeStaticLibs) {
2269 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 -07002270 }
2271 }
2272
Colin Cross5950f382016-12-13 12:50:57 -08002273 for _, lib := range deps.ReexportHeaderLibHeaders {
2274 if !inList(lib, deps.HeaderLibs) {
2275 ctx.PropertyErrorf("export_header_lib_headers", "Header library not in header_libs: '%s'", lib)
2276 }
2277 }
2278
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002279 for _, gen := range deps.ReexportGeneratedHeaders {
2280 if !inList(gen, deps.GeneratedHeaders) {
2281 ctx.PropertyErrorf("export_generated_headers", "Generated header module not in generated_headers: '%s'", gen)
2282 }
2283 }
2284
Colin Crossc99deeb2016-04-11 15:06:20 -07002285 return deps
2286}
2287
Dan Albert7e9d2952016-08-04 13:02:36 -07002288func (c *Module) beginMutator(actx android.BottomUpMutatorContext) {
Colin Crossca860ac2016-01-04 14:34:37 -08002289 ctx := &baseModuleContext{
Colin Cross0ea8ba82019-06-06 14:33:29 -07002290 BaseModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08002291 moduleContextImpl: moduleContextImpl{
2292 mod: c,
2293 },
2294 }
2295 ctx.ctx = ctx
2296
Colin Crossca860ac2016-01-04 14:34:37 -08002297 c.begin(ctx)
Dan Albert7e9d2952016-08-04 13:02:36 -07002298}
2299
Jiyong Park7ed9de32018-10-15 22:25:07 +09002300// Split name#version into name and version
Jiyong Park73c54ee2019-10-22 20:31:18 +09002301func StubsLibNameAndVersion(name string) (string, string) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002302 if sharp := strings.LastIndex(name, "#"); sharp != -1 && sharp != len(name)-1 {
2303 version := name[sharp+1:]
2304 libname := name[:sharp]
2305 return libname, version
2306 }
2307 return name, ""
2308}
2309
Dan Albert92fe7402020-07-15 13:33:30 -07002310func GetCrtVariations(ctx android.BottomUpMutatorContext,
2311 m LinkableInterface) []blueprint.Variation {
2312 if ctx.Os() != android.Android {
2313 return nil
2314 }
2315 if m.UseSdk() {
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09002316 // Choose the CRT that best satisfies the min_sdk_version requirement of this module
2317 minSdkVersion := m.MinSdkVersion()
2318 if minSdkVersion == "" || minSdkVersion == "apex_inherit" {
2319 minSdkVersion = m.SdkVersion()
2320 }
Jooyung Han94a76ee2021-06-08 09:49:48 +09002321 apiLevel, err := android.ApiLevelFromUser(ctx, minSdkVersion)
2322 if err != nil {
2323 ctx.PropertyErrorf("min_sdk_version", err.Error())
2324 }
Colin Cross363ec762023-01-13 13:45:14 -08002325
2326 // Raise the minSdkVersion to the minimum supported for the architecture.
Colin Crossbb137a32023-01-26 09:54:42 -08002327 minApiForArch := MinApiForArch(ctx, m.Target().Arch.ArchType)
Colin Cross363ec762023-01-13 13:45:14 -08002328 if apiLevel.LessThan(minApiForArch) {
2329 apiLevel = minApiForArch
2330 }
2331
Dan Albert92fe7402020-07-15 13:33:30 -07002332 return []blueprint.Variation{
2333 {Mutator: "sdk", Variation: "sdk"},
Jooyung Han94a76ee2021-06-08 09:49:48 +09002334 {Mutator: "version", Variation: apiLevel.String()},
Dan Albert92fe7402020-07-15 13:33:30 -07002335 }
2336 }
2337 return []blueprint.Variation{
2338 {Mutator: "sdk", Variation: ""},
2339 }
2340}
2341
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002342func AddSharedLibDependenciesWithVersions(ctx android.BottomUpMutatorContext, mod LinkableInterface,
2343 variations []blueprint.Variation, depTag blueprint.DependencyTag, name, version string, far bool) {
Colin Crosse7257d22020-09-24 09:56:18 -07002344
2345 variations = append([]blueprint.Variation(nil), variations...)
2346
Liz Kammer23942242022-04-08 15:41:00 -04002347 if version != "" && canBeOrLinkAgainstVersionVariants(mod) {
Colin Crosse7257d22020-09-24 09:56:18 -07002348 // Version is explicitly specified. i.e. libFoo#30
2349 variations = append(variations, blueprint.Variation{Mutator: "version", Variation: version})
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002350 if tag, ok := depTag.(libraryDependencyTag); ok {
2351 tag.explicitlyVersioned = true
2352 } else {
2353 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
2354 }
Colin Crosse7257d22020-09-24 09:56:18 -07002355 }
Colin Crosse7257d22020-09-24 09:56:18 -07002356
Colin Cross0de8a1e2020-09-18 14:15:30 -07002357 if far {
2358 ctx.AddFarVariationDependencies(variations, depTag, name)
2359 } else {
2360 ctx.AddVariationDependencies(variations, depTag, name)
Colin Crosse7257d22020-09-24 09:56:18 -07002361 }
2362}
2363
Kiyoung Kim487689e2022-07-26 09:48:22 +09002364func GetReplaceModuleName(lib string, replaceMap map[string]string) string {
2365 if snapshot, ok := replaceMap[lib]; ok {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002366 return snapshot
2367 }
2368
2369 return lib
2370}
2371
Kiyoung Kim37693d02024-04-04 09:56:15 +09002372// FilterNdkLibs takes a list of names of shared libraries and scans it for two types
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002373// of names:
2374//
Kiyoung Kim37693d02024-04-04 09:56:15 +09002375// 1. Name of an NDK library that refers to an ndk_library module.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002376//
2377// For each of these, it adds the name of the ndk_library module to the list of
2378// variant libs.
2379//
Kiyoung Kim37693d02024-04-04 09:56:15 +09002380// 2. Anything else (so anything that isn't an NDK library).
Kiyoung Kim487689e2022-07-26 09:48:22 +09002381//
2382// It adds these to the nonvariantLibs list.
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002383//
2384// The caller can then know to add the variantLibs dependencies differently from the
2385// nonvariantLibs
Kiyoung Kim37693d02024-04-04 09:56:15 +09002386func FilterNdkLibs(c LinkableInterface, config android.Config, list []string) (nonvariantLibs []string, variantLibs []string) {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002387 variantLibs = []string{}
2388
2389 nonvariantLibs = []string{}
2390 for _, entry := range list {
2391 // strip #version suffix out
2392 name, _ := StubsLibNameAndVersion(entry)
Kiyoung Kim37693d02024-04-04 09:56:15 +09002393 if c.UseSdk() && inList(name, *getNDKKnownLibs(config)) {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002394 variantLibs = append(variantLibs, name+ndkLibrarySuffix)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002395 } else {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002396 nonvariantLibs = append(nonvariantLibs, entry)
2397 }
2398 }
2399 return nonvariantLibs, variantLibs
Kiyoung Kim37693d02024-04-04 09:56:15 +09002400
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002401}
2402
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002403func rewriteLibsForApiImports(c LinkableInterface, libs []string, replaceList map[string]string, config android.Config) ([]string, []string) {
2404 nonVariantLibs := []string{}
2405 variantLibs := []string{}
2406
2407 for _, lib := range libs {
2408 replaceLibName := GetReplaceModuleName(lib, replaceList)
2409 if replaceLibName == lib {
2410 // Do not handle any libs which are not in API imports
2411 nonVariantLibs = append(nonVariantLibs, replaceLibName)
2412 } else if c.UseSdk() && inList(replaceLibName, *getNDKKnownLibs(config)) {
2413 variantLibs = append(variantLibs, replaceLibName)
2414 } else {
2415 nonVariantLibs = append(nonVariantLibs, replaceLibName)
2416 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002417 }
2418
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002419 return nonVariantLibs, variantLibs
Kiyoung Kim487689e2022-07-26 09:48:22 +09002420}
2421
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002422func (c *Module) shouldUseApiSurface() bool {
2423 if c.Os() == android.Android && c.Target().NativeBridge != android.NativeBridgeEnabled {
2424 if GetImageVariantType(c) == vendorImageVariant || GetImageVariantType(c) == productImageVariant {
2425 // LLNDK Variant
2426 return true
2427 }
2428
2429 if c.Properties.IsSdkVariant {
2430 // NDK Variant
2431 return true
2432 }
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002433 }
2434
2435 return false
2436}
2437
Colin Cross1e676be2016-10-12 14:38:15 -07002438func (c *Module) DepsMutator(actx android.BottomUpMutatorContext) {
Cole Fausta963b942024-04-11 17:43:00 -07002439 if !c.Enabled(actx) {
Inseob Kimeec88e12020-01-22 11:11:29 +09002440 return
2441 }
2442
Colin Cross37047f12016-12-13 17:06:13 -08002443 ctx := &depsContext{
2444 BottomUpMutatorContext: actx,
Dan Albert7e9d2952016-08-04 13:02:36 -07002445 moduleContextImpl: moduleContextImpl{
2446 mod: c,
2447 },
2448 }
2449 ctx.ctx = ctx
Colin Crossca860ac2016-01-04 14:34:37 -08002450
Colin Crossc99deeb2016-04-11 15:06:20 -07002451 deps := c.deps(ctx)
Kiyoung Kim11d91082022-10-19 19:20:57 +09002452
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002453 apiNdkLibs := []string{}
2454 apiLateNdkLibs := []string{}
2455
Yo Chiang219968c2020-09-22 18:45:04 +08002456 c.Properties.AndroidMkSystemSharedLibs = deps.SystemSharedLibs
2457
Dan Albert914449f2016-06-17 16:45:24 -07002458 variantNdkLibs := []string{}
2459 variantLateNdkLibs := []string{}
Dan Willemsenb916b802017-03-19 13:44:32 -07002460 if ctx.Os() == android.Android {
Kiyoung Kim37693d02024-04-04 09:56:15 +09002461 deps.SharedLibs, variantNdkLibs = FilterNdkLibs(c, ctx.Config(), deps.SharedLibs)
2462 deps.LateSharedLibs, variantLateNdkLibs = FilterNdkLibs(c, ctx.Config(), deps.LateSharedLibs)
2463 deps.ReexportSharedLibHeaders, _ = FilterNdkLibs(c, ctx.Config(), deps.ReexportSharedLibHeaders)
Dan Willemsen72d39932016-07-08 23:23:48 -07002464 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002465
Colin Cross32ec36c2016-12-15 07:39:51 -08002466 for _, lib := range deps.HeaderLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002467 depTag := libraryDependencyTag{Kind: headerLibraryDependency}
Colin Cross32ec36c2016-12-15 07:39:51 -08002468 if inList(lib, deps.ReexportHeaderLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002469 depTag.reexportFlags = true
Colin Cross32ec36c2016-12-15 07:39:51 -08002470 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002471
Spandan Das73bcafc2022-08-18 23:26:00 +00002472 if c.isNDKStubLibrary() {
Jiyong Parkf8fab9b2024-09-02 15:24:15 +09002473 variationExists := actx.OtherModuleDependencyVariantExists(nil, lib)
2474 if variationExists {
2475 actx.AddVariationDependencies(nil, depTag, lib)
2476 } else {
2477 // dependencies to ndk_headers fall here as ndk_headers do not have
2478 // any variants.
2479 actx.AddFarVariationDependencies([]blueprint.Variation{}, depTag, lib)
2480 }
Spandan Dasff665182024-09-11 18:48:44 +00002481 } else if c.IsStubs() {
Colin Cross7228ecd2019-11-18 16:00:16 -08002482 actx.AddFarVariationDependencies(append(ctx.Target().Variations(), c.ImageVariation()),
Colin Cross0f7d2ef2019-10-16 11:03:10 -07002483 depTag, lib)
Jiyong Park7e636d02019-01-28 16:16:54 +09002484 } else {
2485 actx.AddVariationDependencies(nil, depTag, lib)
2486 }
2487 }
2488
Dan Albertf1d14c72020-07-30 14:32:55 -07002489 if c.isNDKStubLibrary() {
2490 // NDK stubs depend on their implementation because the ABI dumps are
2491 // generated from the implementation library.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002492
Spandan Das8b08aea2023-03-14 19:29:34 +00002493 actx.AddFarVariationDependencies(append(ctx.Target().Variations(),
2494 c.ImageVariation(),
2495 blueprint.Variation{Mutator: "link", Variation: "shared"},
2496 ), stubImplementation, c.BaseModuleName())
Dan Albertf1d14c72020-07-30 14:32:55 -07002497 }
2498
Hsin-Yi Chen715142a2024-03-27 16:31:16 +08002499 // If this module is an LLNDK implementation library, let it depend on LlndkHeaderLibs.
2500 if c.ImageVariation().Variation == android.CoreVariation && c.Device() &&
2501 c.Target().NativeBridge == android.NativeBridgeDisabled {
2502 actx.AddVariationDependencies(
Jihoon Kang47e91842024-06-19 00:51:16 +00002503 []blueprint.Variation{{Mutator: "image", Variation: android.VendorVariation}},
Hsin-Yi Chen715142a2024-03-27 16:31:16 +08002504 llndkHeaderLibTag,
2505 deps.LlndkHeaderLibs...)
2506 }
2507
Jiyong Park5d1598f2019-02-25 22:14:17 +09002508 for _, lib := range deps.WholeStaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002509 depTag := libraryDependencyTag{Kind: staticLibraryDependency, wholeStatic: true, reexportFlags: true}
Inseob Kimeec88e12020-01-22 11:11:29 +09002510
Jiyong Park5d1598f2019-02-25 22:14:17 +09002511 actx.AddVariationDependencies([]blueprint.Variation{
2512 {Mutator: "link", Variation: "static"},
2513 }, depTag, lib)
2514 }
2515
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002516 for _, lib := range deps.StaticLibs {
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04002517 // Some dependencies listed in static_libs might actually be rust_ffi rlib variants.
Colin Cross6e511a92020-07-27 21:26:48 -07002518 depTag := libraryDependencyTag{Kind: staticLibraryDependency}
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04002519
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002520 if inList(lib, deps.ReexportStaticLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002521 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002522 }
Jiyong Parke3867542020-12-03 17:28:25 +09002523 if inList(lib, deps.ExcludeLibsForApex) {
2524 depTag.excludeInApex = true
2525 }
Dan Willemsen59339a22018-07-22 21:18:45 -07002526 actx.AddVariationDependencies([]blueprint.Variation{
2527 {Mutator: "link", Variation: "static"},
2528 }, depTag, lib)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002529 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002530
Jooyung Han75568392020-03-20 04:29:24 +09002531 // staticUnwinderDep is treated as staticDep for Q apexes
2532 // so that native libraries/binaries are linked with static unwinder
2533 // because Q libc doesn't have unwinder APIs
2534 if deps.StaticUnwinderIfLegacy {
Colin Cross6e511a92020-07-27 21:26:48 -07002535 depTag := libraryDependencyTag{Kind: staticLibraryDependency, staticUnwinder: true}
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002536 actx.AddVariationDependencies([]blueprint.Variation{
2537 {Mutator: "link", Variation: "static"},
Kiyoung Kim37693d02024-04-04 09:56:15 +09002538 }, depTag, staticUnwinder(actx))
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002539 }
2540
Jiyong Park7ed9de32018-10-15 22:25:07 +09002541 // shared lib names without the #version suffix
2542 var sharedLibNames []string
2543
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002544 for _, lib := range deps.SharedLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002545 depTag := libraryDependencyTag{Kind: sharedLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002546 if inList(lib, deps.ReexportSharedLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002547 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002548 }
Jiyong Parke3867542020-12-03 17:28:25 +09002549 if inList(lib, deps.ExcludeLibsForApex) {
2550 depTag.excludeInApex = true
2551 }
Jooyung Han9ffbe832023-11-28 22:31:35 +09002552 if inList(lib, deps.ExcludeLibsForNonApex) {
2553 depTag.excludeInNonApex = true
2554 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002555
Jiyong Park73c54ee2019-10-22 20:31:18 +09002556 name, version := StubsLibNameAndVersion(lib)
Inseob Kimc0907f12019-02-08 21:00:45 +09002557 sharedLibNames = append(sharedLibNames, name)
2558
Colin Crosse7257d22020-09-24 09:56:18 -07002559 variations := []blueprint.Variation{
2560 {Mutator: "link", Variation: "shared"},
2561 }
Spandan Dasff665182024-09-11 18:48:44 +00002562 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, name, version, false)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002563 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002564
Colin Crossfe9acfe2021-06-14 16:13:03 -07002565 for _, lib := range deps.LateStaticLibs {
2566 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency}
2567 actx.AddVariationDependencies([]blueprint.Variation{
2568 {Mutator: "link", Variation: "static"},
Kiyoung Kim37693d02024-04-04 09:56:15 +09002569 }, depTag, lib)
Colin Crossfe9acfe2021-06-14 16:13:03 -07002570 }
2571
Colin Cross3e5e7782022-06-17 22:17:05 +00002572 for _, lib := range deps.UnexportedStaticLibs {
2573 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency, unexportedSymbols: true}
2574 actx.AddVariationDependencies([]blueprint.Variation{
2575 {Mutator: "link", Variation: "static"},
Kiyoung Kim37693d02024-04-04 09:56:15 +09002576 }, depTag, lib)
Colin Cross3e5e7782022-06-17 22:17:05 +00002577 }
2578
Jiyong Park7ed9de32018-10-15 22:25:07 +09002579 for _, lib := range deps.LateSharedLibs {
Jiyong Park25fc6a92018-11-18 18:02:45 +09002580 if inList(lib, sharedLibNames) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002581 // This is to handle the case that some of the late shared libs (libc, libdl, libm, ...)
2582 // are added also to SharedLibs with version (e.g., libc#10). If not skipped, we will be
2583 // linking against both the stubs lib and the non-stubs lib at the same time.
2584 continue
2585 }
Colin Cross6e511a92020-07-27 21:26:48 -07002586 depTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency}
Colin Crosse7257d22020-09-24 09:56:18 -07002587 variations := []blueprint.Variation{
2588 {Mutator: "link", Variation: "shared"},
2589 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002590 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, lib, "", false)
Jiyong Park7ed9de32018-10-15 22:25:07 +09002591 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002592
Dan Willemsen59339a22018-07-22 21:18:45 -07002593 actx.AddVariationDependencies([]blueprint.Variation{
2594 {Mutator: "link", Variation: "shared"},
Chris Parsons79d66a52020-06-05 17:26:16 -04002595 }, dataLibDepTag, deps.DataLibs...)
2596
Colin Crossc8caa062021-09-24 16:50:14 -07002597 actx.AddVariationDependencies(nil, dataBinDepTag, deps.DataBins...)
2598
Chris Parsons79d66a52020-06-05 17:26:16 -04002599 actx.AddVariationDependencies([]blueprint.Variation{
2600 {Mutator: "link", Variation: "shared"},
Dan Willemsen59339a22018-07-22 21:18:45 -07002601 }, runtimeDepTag, deps.RuntimeLibs...)
Logan Chien43d34c32017-12-20 01:17:32 +08002602
Colin Cross68861832016-07-08 10:41:41 -07002603 actx.AddDependency(c, genSourceDepTag, deps.GeneratedSources...)
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002604
2605 for _, gen := range deps.GeneratedHeaders {
2606 depTag := genHeaderDepTag
2607 if inList(gen, deps.ReexportGeneratedHeaders) {
2608 depTag = genHeaderExportDepTag
2609 }
2610 actx.AddDependency(c, depTag, gen)
2611 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002612
Dan Albert92fe7402020-07-15 13:33:30 -07002613 crtVariations := GetCrtVariations(ctx, c)
Colin Crossbbc941b2020-09-30 12:27:01 -07002614 actx.AddVariationDependencies(crtVariations, objDepTag, deps.ObjFiles...)
Colin Crossc465efd2021-06-11 18:00:04 -07002615 for _, crt := range deps.CrtBegin {
Dan Albert92fe7402020-07-15 13:33:30 -07002616 actx.AddVariationDependencies(crtVariations, CrtBeginDepTag,
Kiyoung Kim37693d02024-04-04 09:56:15 +09002617 crt)
Colin Crossca860ac2016-01-04 14:34:37 -08002618 }
Colin Crossc465efd2021-06-11 18:00:04 -07002619 for _, crt := range deps.CrtEnd {
Dan Albert92fe7402020-07-15 13:33:30 -07002620 actx.AddVariationDependencies(crtVariations, CrtEndDepTag,
Kiyoung Kim37693d02024-04-04 09:56:15 +09002621 crt)
Colin Cross21b9a242015-03-24 14:15:58 -07002622 }
Dan Willemsena0790e32018-10-12 00:24:23 -07002623 if deps.DynamicLinker != "" {
2624 actx.AddDependency(c, dynamicLinkerDepTag, deps.DynamicLinker)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002625 }
Dan Albert914449f2016-06-17 16:45:24 -07002626
2627 version := ctx.sdkVersion()
Colin Cross6e511a92020-07-27 21:26:48 -07002628
2629 ndkStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002630 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002631 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002632 {Mutator: "link", Variation: "shared"},
2633 }, ndkStubDepTag, variantNdkLibs...)
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002634 actx.AddVariationDependencies([]blueprint.Variation{
2635 {Mutator: "version", Variation: version},
2636 {Mutator: "link", Variation: "shared"},
2637 }, ndkStubDepTag, apiNdkLibs...)
Colin Cross6e511a92020-07-27 21:26:48 -07002638
2639 ndkLateStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002640 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002641 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002642 {Mutator: "link", Variation: "shared"},
2643 }, ndkLateStubDepTag, variantLateNdkLibs...)
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002644 actx.AddVariationDependencies([]blueprint.Variation{
2645 {Mutator: "version", Variation: version},
2646 {Mutator: "link", Variation: "shared"},
2647 }, ndkLateStubDepTag, apiLateNdkLibs...)
Logan Chienf3511742017-10-31 18:04:35 +08002648
Vinh Tran367d89d2023-04-28 11:21:25 -04002649 if len(deps.AidlLibs) > 0 {
2650 actx.AddDependency(
2651 c,
2652 aidlLibraryTag,
2653 deps.AidlLibs...,
2654 )
2655 }
2656
Colin Cross6362e272015-10-29 15:25:03 -07002657}
Colin Cross21b9a242015-03-24 14:15:58 -07002658
Colin Crosse40b4ea2018-10-02 22:25:58 -07002659func BeginMutator(ctx android.BottomUpMutatorContext) {
Cole Fausta963b942024-04-11 17:43:00 -07002660 if c, ok := ctx.Module().(*Module); ok && c.Enabled(ctx) {
Dan Albert7e9d2952016-08-04 13:02:36 -07002661 c.beginMutator(ctx)
2662 }
2663}
2664
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002665// Whether a module can link to another module, taking into
2666// account NDK linking.
Jooyung Han479ca172020-10-19 18:51:07 +09002667func checkLinkType(ctx android.BaseModuleContext, from LinkableInterface, to LinkableInterface,
Colin Cross6e511a92020-07-27 21:26:48 -07002668 tag blueprint.DependencyTag) {
2669
2670 switch t := tag.(type) {
2671 case dependencyTag:
2672 if t != vndkExtDepTag {
2673 return
2674 }
2675 case libraryDependencyTag:
2676 default:
2677 return
2678 }
2679
Ivan Lozanof9e21722020-12-02 09:00:51 -05002680 if from.Target().Os != android.Android {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002681 // Host code is not restricted
2682 return
2683 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002684
Ivan Lozano52767be2019-10-18 14:49:46 -07002685 if from.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002686 // Platform code can link to anything
2687 return
2688 }
Yifan Hong1b3348d2020-01-21 15:53:22 -08002689 if from.InRamdisk() {
2690 // Ramdisk code is not NDK
2691 return
2692 }
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002693 if from.InVendorRamdisk() {
2694 // Vendor ramdisk code is not NDK
2695 return
2696 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002697 if from.InRecovery() {
Jiyong Parkf9332f12018-02-01 00:54:12 +09002698 // Recovery code is not NDK
2699 return
2700 }
Colin Cross31076b32020-10-23 17:22:06 -07002701 if c, ok := to.(*Module); ok {
Colin Cross31076b32020-10-23 17:22:06 -07002702 if c.StubDecorator() {
2703 // These aren't real libraries, but are the stub shared libraries that are included in
2704 // the NDK.
2705 return
2706 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002707 }
Logan Chien834b9a62019-01-14 15:39:03 +08002708
Ivan Lozano52767be2019-10-18 14:49:46 -07002709 if strings.HasPrefix(ctx.ModuleName(), "libclang_rt.") && to.Module().Name() == "libc++" {
Logan Chien834b9a62019-01-14 15:39:03 +08002710 // Bug: http://b/121358700 - Allow libclang_rt.* shared libraries (with sdk_version)
2711 // to link to libc++ (non-NDK and without sdk_version).
2712 return
2713 }
2714
Ivan Lozano52767be2019-10-18 14:49:46 -07002715 if to.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002716 // NDK code linking to platform code is never okay.
2717 ctx.ModuleErrorf("depends on non-NDK-built library %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002718 ctx.OtherModuleName(to.Module()))
Dan Willemsen155d17c2019-02-06 18:30:02 -08002719 return
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002720 }
2721
2722 // At this point we know we have two NDK libraries, but we need to
2723 // check that we're not linking against anything built against a higher
2724 // API level, as it is only valid to link against older or equivalent
2725 // APIs.
2726
Inseob Kim01a28722018-04-11 09:48:45 +09002727 // Current can link against anything.
Ivan Lozano52767be2019-10-18 14:49:46 -07002728 if from.SdkVersion() != "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002729 // Otherwise we need to check.
Ivan Lozano52767be2019-10-18 14:49:46 -07002730 if to.SdkVersion() == "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002731 // Current can't be linked against by anything else.
2732 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002733 ctx.OtherModuleName(to.Module()), "current")
Inseob Kim01a28722018-04-11 09:48:45 +09002734 } else {
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002735 fromApi, err := android.ApiLevelFromUserWithConfig(ctx.Config(), from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002736 if err != nil {
2737 ctx.PropertyErrorf("sdk_version",
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002738 "Invalid sdk_version value (must be int, preview or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002739 from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002740 }
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002741 toApi, err := android.ApiLevelFromUserWithConfig(ctx.Config(), to.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 to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002746 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002747
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002748 if toApi.GreaterThan(fromApi) {
Inseob Kim01a28722018-04-11 09:48:45 +09002749 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002750 ctx.OtherModuleName(to.Module()), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002751 }
2752 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002753 }
Dan Albert202fe492017-12-15 13:56:59 -08002754
2755 // Also check that the two STL choices are compatible.
Ivan Lozano52767be2019-10-18 14:49:46 -07002756 fromStl := from.SelectedStl()
2757 toStl := to.SelectedStl()
Dan Albert202fe492017-12-15 13:56:59 -08002758 if fromStl == "" || toStl == "" {
2759 // Libraries that don't use the STL are unrestricted.
Inseob Kimda2171a2018-04-11 15:41:38 +09002760 } else if fromStl == "ndk_system" || toStl == "ndk_system" {
Dan Albert202fe492017-12-15 13:56:59 -08002761 // We can be permissive with the system "STL" since it is only the C++
2762 // ABI layer, but in the future we should make sure that everyone is
2763 // using either libc++ or nothing.
Colin Crossb60190a2018-09-04 16:28:17 -07002764 } else if getNdkStlFamily(from) != getNdkStlFamily(to) {
Dan Albert202fe492017-12-15 13:56:59 -08002765 ctx.ModuleErrorf("uses %q and depends on %q which uses incompatible %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002766 from.SelectedStl(), ctx.OtherModuleName(to.Module()),
2767 to.SelectedStl())
Dan Albert202fe492017-12-15 13:56:59 -08002768 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002769}
2770
Jooyung Han479ca172020-10-19 18:51:07 +09002771func checkLinkTypeMutator(ctx android.BottomUpMutatorContext) {
2772 if c, ok := ctx.Module().(*Module); ok {
2773 ctx.VisitDirectDeps(func(dep android.Module) {
2774 depTag := ctx.OtherModuleDependencyTag(dep)
2775 ccDep, ok := dep.(LinkableInterface)
2776 if ok {
2777 checkLinkType(ctx, c, ccDep, depTag)
2778 }
2779 })
2780 }
2781}
2782
Jiyong Park5fb8c102018-04-09 12:03:06 +09002783// Tests whether the dependent library is okay to be double loaded inside a single process.
Jooyung Hana70f0672019-01-18 15:20:43 +09002784// If a library has a vendor variant and is a (transitive) dependency of an LLNDK library,
2785// it is subject to be double loaded. Such lib should be explicitly marked as double_loadable: true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002786// or as vndk-sp (vndk: { enabled: true, support_system_process: true}).
Colin Crossda279cf2024-09-17 14:25:45 -07002787func checkDoubleLoadableLibraries(ctx android.BottomUpMutatorContext) {
Jooyung Hana70f0672019-01-18 15:20:43 +09002788 check := func(child, parent android.Module) bool {
2789 to, ok := child.(*Module)
2790 if !ok {
Jooyung Han479ca172020-10-19 18:51:07 +09002791 return false
Jooyung Hana70f0672019-01-18 15:20:43 +09002792 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002793
Jooyung Hana70f0672019-01-18 15:20:43 +09002794 if lib, ok := to.linker.(*libraryDecorator); !ok || !lib.shared() {
2795 return false
Jiyong Park5fb8c102018-04-09 12:03:06 +09002796 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002797
Jiyong Park0474e1f2021-01-14 14:26:06 +09002798 // These dependencies are not excercised at runtime. Tracking these will give us
2799 // false negative, so skip.
Jiyong Park1ad8e162020-12-01 23:40:09 +09002800 depTag := ctx.OtherModuleDependencyTag(child)
2801 if IsHeaderDepTag(depTag) {
2802 return false
2803 }
Jiyong Park0474e1f2021-01-14 14:26:06 +09002804 if depTag == staticVariantTag {
2805 return false
2806 }
2807 if depTag == stubImplDepTag {
2808 return false
2809 }
Jiyong Park8bcf3c62024-03-18 18:37:10 +09002810 if depTag == android.RequiredDepTag {
2811 return false
2812 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002813
Justin Yun63e9ec72020-10-29 16:49:43 +09002814 // Even if target lib has no vendor variant, keep checking dependency
2815 // graph in case it depends on vendor_available or product_available
2816 // but not double_loadable transtively.
2817 if !to.HasNonSystemVariants() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002818 return true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002819 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002820
Jiyong Park0474e1f2021-01-14 14:26:06 +09002821 // The happy path. Keep tracking dependencies until we hit a non double-loadable
2822 // one.
2823 if Bool(to.VendorProperties.Double_loadable) {
2824 return true
2825 }
2826
Kiyoung Kim9f26fcf2024-05-27 17:25:52 +09002827 if to.IsLlndk() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002828 return false
2829 }
2830
Jooyung Hana70f0672019-01-18 15:20:43 +09002831 ctx.ModuleErrorf("links a library %q which is not LL-NDK, "+
2832 "VNDK-SP, or explicitly marked as 'double_loadable:true'. "+
Jiyong Park0474e1f2021-01-14 14:26:06 +09002833 "Dependency list: %s", ctx.OtherModuleName(to), ctx.GetPathString(false))
Jooyung Hana70f0672019-01-18 15:20:43 +09002834 return false
2835 }
2836 if module, ok := ctx.Module().(*Module); ok {
2837 if lib, ok := module.linker.(*libraryDecorator); ok && lib.shared() {
Jiyong Park0474e1f2021-01-14 14:26:06 +09002838 if lib.hasLLNDKStubs() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002839 ctx.WalkDeps(check)
2840 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002841 }
2842 }
2843}
2844
Yu Liue4312402023-01-18 09:15:31 -08002845func findApexSdkVersion(ctx android.BaseModuleContext, apexInfo android.ApexInfo) android.ApiLevel {
2846 // For the dependency from platform to apex, use the latest stubs
2847 apexSdkVersion := android.FutureApiLevel
2848 if !apexInfo.IsForPlatform() {
2849 apexSdkVersion = apexInfo.MinSdkVersion
2850 }
2851
2852 if android.InList("hwaddress", ctx.Config().SanitizeDevice()) {
2853 // In hwasan build, we override apexSdkVersion to the FutureApiLevel(10000)
2854 // so that even Q(29/Android10) apexes could use the dynamic unwinder by linking the newer stubs(e.g libc(R+)).
2855 // (b/144430859)
2856 apexSdkVersion = android.FutureApiLevel
2857 }
2858
2859 return apexSdkVersion
2860}
2861
Colin Crossc99deeb2016-04-11 15:06:20 -07002862// Convert dependencies to paths. Returns a PathDeps containing paths
Colin Cross635c3b02016-05-18 15:37:25 -07002863func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
Colin Crossca860ac2016-01-04 14:34:37 -08002864 var depPaths PathDeps
Colin Crossca860ac2016-01-04 14:34:37 -08002865
Colin Cross0de8a1e2020-09-18 14:15:30 -07002866 var directStaticDeps []StaticLibraryInfo
2867 var directSharedDeps []SharedLibraryInfo
Jeff Gaston294356f2017-09-27 17:05:30 -07002868
Colin Cross0de8a1e2020-09-18 14:15:30 -07002869 reexportExporter := func(exporter FlagExporterInfo) {
2870 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, exporter.IncludeDirs...)
2871 depPaths.ReexportedSystemDirs = append(depPaths.ReexportedSystemDirs, exporter.SystemIncludeDirs...)
2872 depPaths.ReexportedFlags = append(depPaths.ReexportedFlags, exporter.Flags...)
2873 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, exporter.Deps...)
2874 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders, exporter.GeneratedHeaders...)
Inseob Kim69378442019-06-03 19:10:47 +09002875 }
2876
Colin Crossff694a82023-12-13 15:54:49 -08002877 apexInfo, _ := android.ModuleProvider(ctx, android.ApexInfoProvider)
Yu Liue4312402023-01-18 09:15:31 -08002878 c.apexSdkVersion = findApexSdkVersion(ctx, apexInfo)
Jooyung Hande34d232020-07-23 13:04:15 +09002879
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002880 skipModuleList := map[string]bool{}
2881
Colin Crossd11fcda2017-10-23 17:59:01 -07002882 ctx.VisitDirectDeps(func(dep android.Module) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002883 depName := ctx.OtherModuleName(dep)
2884 depTag := ctx.OtherModuleDependencyTag(dep)
Dan Albert9e10cd42016-08-03 14:12:14 -07002885
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002886 if _, ok := skipModuleList[depName]; ok {
2887 // skip this module because original module or API imported module matching with this should be used instead.
2888 return
2889 }
2890
Dan Willemsen47450072021-10-19 20:24:49 -07002891 if depTag == android.DarwinUniversalVariantTag {
2892 depPaths.DarwinSecondArchOutput = dep.(*Module).OutputFile()
2893 return
2894 }
2895
Vinh Tran367d89d2023-04-28 11:21:25 -04002896 if depTag == aidlLibraryTag {
Colin Cross313aa542023-12-13 13:47:44 -08002897 if aidlLibraryInfo, ok := android.OtherModuleProvider(ctx, dep, aidl_library.AidlLibraryProvider); ok {
Vinh Tran367d89d2023-04-28 11:21:25 -04002898 depPaths.AidlLibraryInfos = append(
2899 depPaths.AidlLibraryInfos,
Colin Cross313aa542023-12-13 13:47:44 -08002900 aidlLibraryInfo,
Vinh Tran367d89d2023-04-28 11:21:25 -04002901 )
2902 }
2903 }
2904
Ivan Lozano52767be2019-10-18 14:49:46 -07002905 ccDep, ok := dep.(LinkableInterface)
2906 if !ok {
2907
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002908 // handling for a few module types that aren't cc Module but that are also supported
2909 switch depTag {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002910 case genSourceDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002911 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002912 depPaths.GeneratedSources = append(depPaths.GeneratedSources,
2913 genRule.GeneratedSourceFiles()...)
2914 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002915 ctx.ModuleErrorf("module %q is not a gensrcs or genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002916 }
Colin Crosse90bfd12017-04-26 16:59:26 -07002917 // Support exported headers from a generated_sources dependency
2918 fallthrough
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002919 case genHeaderDepTag, genHeaderExportDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002920 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Inseob Kimd110f872019-12-06 13:15:38 +09002921 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps,
Dan Willemsen9da9d492018-02-21 18:28:18 -08002922 genRule.GeneratedDeps()...)
Jiyong Park74955042019-10-22 20:19:51 +09002923 dirs := genRule.GeneratedHeaderDirs()
Inseob Kim69378442019-06-03 19:10:47 +09002924 depPaths.IncludeDirs = append(depPaths.IncludeDirs, dirs...)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002925 if depTag == genHeaderExportDepTag {
Inseob Kim69378442019-06-03 19:10:47 +09002926 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, dirs...)
Inseob Kimd110f872019-12-06 13:15:38 +09002927 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders,
2928 genRule.GeneratedSourceFiles()...)
Inseob Kim69378442019-06-03 19:10:47 +09002929 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, genRule.GeneratedDeps()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002930 // 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 +09002931 c.sabi.Properties.ReexportedIncludes = append(c.sabi.Properties.ReexportedIncludes, dirs.Strings()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002932
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002933 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002934 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002935 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002936 }
Colin Crosscef792e2021-06-11 18:01:26 -07002937 case CrtBeginDepTag:
2938 depPaths.CrtBegin = append(depPaths.CrtBegin, android.OutputFileForModule(ctx, dep, ""))
2939 case CrtEndDepTag:
2940 depPaths.CrtEnd = append(depPaths.CrtEnd, android.OutputFileForModule(ctx, dep, ""))
Colin Crossca860ac2016-01-04 14:34:37 -08002941 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002942 return
2943 }
2944
Colin Crossfe17f6f2019-03-28 19:30:56 -07002945 if depTag == android.ProtoPluginDepTag {
2946 return
2947 }
2948
Jiyong Park8bcf3c62024-03-18 18:37:10 +09002949 if depTag == android.RequiredDepTag {
2950 return
2951 }
2952
Colin Crossd11fcda2017-10-23 17:59:01 -07002953 if dep.Target().Os != ctx.Os() {
Steven Morelandaaae81f2024-08-27 22:55:48 +00002954 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 -07002955 return
2956 }
Colin Crossd11fcda2017-10-23 17:59:01 -07002957 if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
Jooyung Han61b66e92020-03-21 14:21:46 +00002958 ctx.ModuleErrorf("Arch mismatch between %q(%v) and %q(%v)",
2959 ctx.ModuleName(), ctx.Arch().ArchType, depName, dep.Target().Arch.ArchType)
Colin Crossa1ad8d12016-06-01 17:09:44 -07002960 return
2961 }
2962
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002963 if depTag == reuseObjTag {
Colin Crossa717db72020-10-23 14:53:06 -07002964 // Skip reused objects for stub libraries, they use their own stub object file instead.
2965 // The reuseObjTag dependency still exists because the LinkageMutator runs before the
2966 // version mutator, so the stubs variant is created from the shared variant that
2967 // already has the reuseObjTag dependency on the static variant.
Colin Cross31076b32020-10-23 17:22:06 -07002968 if !c.library.buildStubs() {
Colin Cross313aa542023-12-13 13:47:44 -08002969 staticAnalogue, _ := android.OtherModuleProvider(ctx, dep, StaticLibraryInfoProvider)
Colin Crossa717db72020-10-23 14:53:06 -07002970 objs := staticAnalogue.ReuseObjects
2971 depPaths.Objs = depPaths.Objs.Append(objs)
Colin Cross313aa542023-12-13 13:47:44 -08002972 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
Colin Crossa717db72020-10-23 14:53:06 -07002973 reexportExporter(depExporterInfo)
2974 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07002975 return
Jiyong Parke4bb9862019-02-01 00:31:10 +09002976 }
2977
Hsin-Yi Chen715142a2024-03-27 16:31:16 +08002978 if depTag == llndkHeaderLibTag {
2979 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
2980 depPaths.LlndkIncludeDirs = append(depPaths.LlndkIncludeDirs, depExporterInfo.IncludeDirs...)
2981 depPaths.LlndkSystemIncludeDirs = append(depPaths.LlndkSystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
2982 }
2983
Colin Cross6e511a92020-07-27 21:26:48 -07002984 linkFile := ccDep.OutputFile()
2985
2986 if libDepTag, ok := depTag.(libraryDependencyTag); ok {
2987 // Only use static unwinder for legacy (min_sdk_version = 29) apexes (b/144430859)
Dan Albertc8060532020-07-22 22:32:17 -07002988 if libDepTag.staticUnwinder && c.apexSdkVersion.GreaterThan(android.SdkVersion_Android10) {
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002989 return
2990 }
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002991
Jiyong Parke3867542020-12-03 17:28:25 +09002992 if !apexInfo.IsForPlatform() && libDepTag.excludeInApex {
2993 return
2994 }
Jooyung Han9ffbe832023-11-28 22:31:35 +09002995 if apexInfo.IsForPlatform() && libDepTag.excludeInNonApex {
2996 return
2997 }
Jiyong Parke3867542020-12-03 17:28:25 +09002998
Colin Cross313aa542023-12-13 13:47:44 -08002999 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
Colin Crossc99deeb2016-04-11 15:06:20 -07003000
Colin Cross6e511a92020-07-27 21:26:48 -07003001 var ptr *android.Paths
3002 var depPtr *android.Paths
Colin Crossc99deeb2016-04-11 15:06:20 -07003003
Colin Cross6e511a92020-07-27 21:26:48 -07003004 depFile := android.OptionalPath{}
Colin Cross26c34ed2016-09-30 17:10:16 -07003005
Colin Cross6e511a92020-07-27 21:26:48 -07003006 switch {
3007 case libDepTag.header():
Colin Cross313aa542023-12-13 13:47:44 -08003008 if _, isHeaderLib := android.OtherModuleProvider(ctx, dep, HeaderLibraryInfoProvider); !isHeaderLib {
Colin Cross649d8172020-12-10 12:30:21 -08003009 if !ctx.Config().AllowMissingDependencies() {
3010 ctx.ModuleErrorf("module %q is not a header library", depName)
3011 } else {
3012 ctx.AddMissingDependencies([]string{depName})
3013 }
3014 return
3015 }
Colin Cross6e511a92020-07-27 21:26:48 -07003016 case libDepTag.shared():
Colin Cross313aa542023-12-13 13:47:44 -08003017 if _, isSharedLib := android.OtherModuleProvider(ctx, dep, SharedLibraryInfoProvider); !isSharedLib {
Colin Cross0de8a1e2020-09-18 14:15:30 -07003018 if !ctx.Config().AllowMissingDependencies() {
3019 ctx.ModuleErrorf("module %q is not a shared library", depName)
3020 } else {
3021 ctx.AddMissingDependencies([]string{depName})
3022 }
3023 return
3024 }
Jiyong Parke3867542020-12-03 17:28:25 +09003025
Jiyong Park7d55b612021-06-11 17:22:09 +09003026 sharedLibraryInfo, returnedDepExporterInfo := ChooseStubOrImpl(ctx, dep)
3027 depExporterInfo = returnedDepExporterInfo
Colin Cross0de8a1e2020-09-18 14:15:30 -07003028
Jiyong Park1ad8e162020-12-01 23:40:09 +09003029 // Stubs lib doesn't link to the shared lib dependencies. Don't set
3030 // linkFile, depFile, and ptr.
3031 if c.IsStubs() {
3032 break
3033 }
3034
Colin Cross0de8a1e2020-09-18 14:15:30 -07003035 linkFile = android.OptionalPathForPath(sharedLibraryInfo.SharedLibrary)
3036 depFile = sharedLibraryInfo.TableOfContents
3037
Colin Cross6e511a92020-07-27 21:26:48 -07003038 ptr = &depPaths.SharedLibs
3039 switch libDepTag.Order {
3040 case earlyLibraryDependency:
3041 ptr = &depPaths.EarlySharedLibs
3042 depPtr = &depPaths.EarlySharedLibsDeps
3043 case normalLibraryDependency:
3044 ptr = &depPaths.SharedLibs
3045 depPtr = &depPaths.SharedLibsDeps
Colin Cross0de8a1e2020-09-18 14:15:30 -07003046 directSharedDeps = append(directSharedDeps, sharedLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07003047 case lateLibraryDependency:
3048 ptr = &depPaths.LateSharedLibs
3049 depPtr = &depPaths.LateSharedLibsDeps
3050 default:
3051 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Colin Crossc99deeb2016-04-11 15:06:20 -07003052 }
Ivan Lozano0a468a42024-05-13 21:03:34 -04003053
Colin Cross6e511a92020-07-27 21:26:48 -07003054 case libDepTag.static():
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003055 if ccDep.RustLibraryInterface() {
3056 rlibDep := RustRlibDep{LibPath: linkFile.Path(), CrateName: ccDep.CrateName(), LinkDirs: ccDep.ExportedCrateLinkDirs()}
3057 depPaths.RustRlibDeps = append(depPaths.RustRlibDeps, rlibDep)
3058 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
3059 if libDepTag.wholeStatic {
3060 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, depExporterInfo.IncludeDirs...)
3061 depPaths.ReexportedRustRlibDeps = append(depPaths.ReexportedRustRlibDeps, rlibDep)
Jiyong Park1ad8e162020-12-01 23:40:09 +09003062
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003063 // If whole_static, track this as we want to make sure that in a final linkage for a shared library,
3064 // exported functions from the rust generated staticlib still exported.
3065 if c.CcLibrary() && c.Shared() {
3066 c.WholeRustStaticlib = true
3067 }
Colin Cross6e511a92020-07-27 21:26:48 -07003068 }
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003069
Colin Cross6e511a92020-07-27 21:26:48 -07003070 } else {
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003071 staticLibraryInfo, isStaticLib := android.OtherModuleProvider(ctx, dep, StaticLibraryInfoProvider)
3072 if !isStaticLib {
3073 if !ctx.Config().AllowMissingDependencies() {
3074 ctx.ModuleErrorf("module %q is not a static library", depName)
3075 } else {
3076 ctx.AddMissingDependencies([]string{depName})
3077 }
3078 return
Inseob Kimeec88e12020-01-22 11:11:29 +09003079 }
Ivan Lozano0a468a42024-05-13 21:03:34 -04003080
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003081 // Stubs lib doesn't link to the static lib dependencies. Don't set
3082 // linkFile, depFile, and ptr.
3083 if c.IsStubs() {
3084 break
3085 }
Ivan Lozano0a468a42024-05-13 21:03:34 -04003086
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003087 linkFile = android.OptionalPathForPath(staticLibraryInfo.StaticLibrary)
3088 if libDepTag.wholeStatic {
3089 ptr = &depPaths.WholeStaticLibs
3090 if len(staticLibraryInfo.Objects.objFiles) > 0 {
3091 depPaths.WholeStaticLibObjs = depPaths.WholeStaticLibObjs.Append(staticLibraryInfo.Objects)
3092 } else {
3093 // This case normally catches prebuilt static
3094 // libraries, but it can also occur when
3095 // AllowMissingDependencies is on and the
3096 // dependencies has no sources of its own
3097 // but has a whole_static_libs dependency
3098 // on a missing library. We want to depend
3099 // on the .a file so that there is something
3100 // in the dependency tree that contains the
3101 // error rule for the missing transitive
3102 // dependency.
3103 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts, linkFile.Path())
3104 }
3105 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts,
3106 staticLibraryInfo.WholeStaticLibsFromPrebuilts...)
3107 } else {
3108 switch libDepTag.Order {
3109 case earlyLibraryDependency:
3110 panic(fmt.Errorf("early static libs not supported"))
3111 case normalLibraryDependency:
3112 // static dependencies will be handled separately so they can be ordered
3113 // using transitive dependencies.
3114 ptr = nil
3115 directStaticDeps = append(directStaticDeps, staticLibraryInfo)
3116 case lateLibraryDependency:
3117 ptr = &depPaths.LateStaticLibs
3118 default:
3119 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
3120 }
3121 }
3122
3123 // Collect any exported Rust rlib deps from static libraries which have been included as whole_static_libs
3124 depPaths.RustRlibDeps = append(depPaths.RustRlibDeps, depExporterInfo.RustRlibDeps...)
3125
3126 if libDepTag.unexportedSymbols {
3127 depPaths.LdFlags = append(depPaths.LdFlags,
3128 "-Wl,--exclude-libs="+staticLibraryInfo.StaticLibrary.Base())
3129 }
Colin Cross3e5e7782022-06-17 22:17:05 +00003130 }
Inseob Kimeec88e12020-01-22 11:11:29 +09003131 }
3132
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003133 if libDepTag.static() && !libDepTag.wholeStatic && !ccDep.RustLibraryInterface() {
Colin Cross6e511a92020-07-27 21:26:48 -07003134 if !ccDep.CcLibraryInterface() || !ccDep.Static() {
3135 ctx.ModuleErrorf("module %q not a static library", depName)
3136 return
3137 }
Logan Chien43d34c32017-12-20 01:17:32 +08003138
Colin Cross6e511a92020-07-27 21:26:48 -07003139 // When combining coverage files for shared libraries and executables, coverage files
3140 // in static libraries act as if they were whole static libraries. The same goes for
3141 // source based Abi dump files.
3142 if c, ok := ccDep.(*Module); ok {
3143 staticLib := c.linker.(libraryInterface)
3144 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
3145 staticLib.objs().coverageFiles...)
3146 depPaths.StaticLibObjs.sAbiDumpFiles = append(depPaths.StaticLibObjs.sAbiDumpFiles,
3147 staticLib.objs().sAbiDumpFiles...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003148 } else {
Colin Cross6e511a92020-07-27 21:26:48 -07003149 // Handle non-CC modules here
3150 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
Colin Cross0de8a1e2020-09-18 14:15:30 -07003151 ccDep.CoverageFiles()...)
Jiyong Parkde866cb2018-12-07 23:08:36 +09003152 }
3153 }
3154
Colin Cross6e511a92020-07-27 21:26:48 -07003155 if ptr != nil {
3156 if !linkFile.Valid() {
3157 if !ctx.Config().AllowMissingDependencies() {
3158 ctx.ModuleErrorf("module %q missing output file", depName)
3159 } else {
3160 ctx.AddMissingDependencies([]string{depName})
3161 }
3162 return
3163 }
3164 *ptr = append(*ptr, linkFile.Path())
3165 }
3166
3167 if depPtr != nil {
3168 dep := depFile
3169 if !dep.Valid() {
3170 dep = linkFile
3171 }
3172 *depPtr = append(*depPtr, dep.Path())
3173 }
3174
Colin Cross0de8a1e2020-09-18 14:15:30 -07003175 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
3176 depPaths.SystemIncludeDirs = append(depPaths.SystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
3177 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps, depExporterInfo.Deps...)
3178 depPaths.Flags = append(depPaths.Flags, depExporterInfo.Flags...)
Ivan Lozano0a468a42024-05-13 21:03:34 -04003179 depPaths.RustRlibDeps = append(depPaths.RustRlibDeps, depExporterInfo.RustRlibDeps...)
3180
3181 // Only re-export RustRlibDeps for cc static libs
3182 if c.static() {
3183 depPaths.ReexportedRustRlibDeps = append(depPaths.ReexportedRustRlibDeps, depExporterInfo.RustRlibDeps...)
3184 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07003185
3186 if libDepTag.reexportFlags {
3187 reexportExporter(depExporterInfo)
3188 // Add these re-exported flags to help header-abi-dumper to infer the abi exported by a library.
3189 // Re-exported shared library headers must be included as well since they can help us with type information
3190 // about template instantiations (instantiated from their headers).
Colin Cross0de8a1e2020-09-18 14:15:30 -07003191 c.sabi.Properties.ReexportedIncludes = append(
3192 c.sabi.Properties.ReexportedIncludes, depExporterInfo.IncludeDirs.Strings()...)
Hsin-Yi Chen5f228b02024-04-02 12:38:47 +08003193 c.sabi.Properties.ReexportedSystemIncludes = append(
3194 c.sabi.Properties.ReexportedSystemIncludes, depExporterInfo.SystemIncludeDirs.Strings()...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003195 }
3196
Spandan Das3faa7922024-02-26 19:42:32 +00003197 makeLibName := MakeLibName(ctx, c, ccDep, ccDep.BaseModuleName()) + libDepTag.makeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003198 switch {
3199 case libDepTag.header():
Colin Cross370173e2020-07-29 12:48:33 -07003200 c.Properties.AndroidMkHeaderLibs = append(
3201 c.Properties.AndroidMkHeaderLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07003202 case libDepTag.shared():
Colin Cross31076b32020-10-23 17:22:06 -07003203 if lib := moduleLibraryInterface(dep); lib != nil {
3204 if lib.buildStubs() && dep.(android.ApexModule).InAnyApex() {
Colin Cross6e511a92020-07-27 21:26:48 -07003205 // Add the dependency to the APEX(es) providing the library so that
3206 // m <module> can trigger building the APEXes as well.
Colin Cross313aa542023-12-13 13:47:44 -08003207 depApexInfo, _ := android.OtherModuleProvider(ctx, dep, android.ApexInfoProvider)
Jiyong Parkab50b072021-05-12 17:13:56 +09003208 for _, an := range depApexInfo.InApexVariants {
Colin Cross6e511a92020-07-27 21:26:48 -07003209 c.Properties.ApexesProvidingSharedLibs = append(
3210 c.Properties.ApexesProvidingSharedLibs, an)
3211 }
3212 }
3213 }
3214
3215 // Note: the order of libs in this list is not important because
3216 // they merely serve as Make dependencies and do not affect this lib itself.
Colin Cross370173e2020-07-29 12:48:33 -07003217 c.Properties.AndroidMkSharedLibs = append(
3218 c.Properties.AndroidMkSharedLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07003219 case libDepTag.static():
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003220 if !ccDep.RustLibraryInterface() {
3221 if libDepTag.wholeStatic {
3222 c.Properties.AndroidMkWholeStaticLibs = append(
3223 c.Properties.AndroidMkWholeStaticLibs, makeLibName)
3224 } else {
3225 c.Properties.AndroidMkStaticLibs = append(
3226 c.Properties.AndroidMkStaticLibs, makeLibName)
3227 }
Colin Cross6e511a92020-07-27 21:26:48 -07003228 }
3229 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09003230 } else if !c.IsStubs() {
3231 // Stubs lib doesn't link to the runtime lib, object, crt, etc. dependencies.
3232
Colin Cross6e511a92020-07-27 21:26:48 -07003233 switch depTag {
3234 case runtimeDepTag:
3235 c.Properties.AndroidMkRuntimeLibs = append(
Spandan Das3faa7922024-02-26 19:42:32 +00003236 c.Properties.AndroidMkRuntimeLibs, MakeLibName(ctx, c, ccDep, ccDep.BaseModuleName())+libDepTag.makeSuffix)
Colin Cross6e511a92020-07-27 21:26:48 -07003237 case objDepTag:
3238 depPaths.Objs.objFiles = append(depPaths.Objs.objFiles, linkFile.Path())
3239 case CrtBeginDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003240 depPaths.CrtBegin = append(depPaths.CrtBegin, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003241 case CrtEndDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003242 depPaths.CrtEnd = append(depPaths.CrtEnd, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003243 case dynamicLinkerDepTag:
3244 depPaths.DynamicLinker = linkFile
3245 }
Jiyong Park27b188b2017-07-18 13:23:39 +09003246 }
Colin Crossca860ac2016-01-04 14:34:37 -08003247 })
3248
Jeff Gaston294356f2017-09-27 17:05:30 -07003249 // use the ordered dependencies as this module's dependencies
Colin Cross0de8a1e2020-09-18 14:15:30 -07003250 orderedStaticPaths, transitiveStaticLibs := orderStaticModuleDeps(directStaticDeps, directSharedDeps)
3251 depPaths.TranstiveStaticLibrariesForOrdering = transitiveStaticLibs
3252 depPaths.StaticLibs = append(depPaths.StaticLibs, orderedStaticPaths...)
Jeff Gaston294356f2017-09-27 17:05:30 -07003253
Colin Crossdd84e052017-05-17 13:44:16 -07003254 // Dedup exported flags from dependencies
Colin Crossb6715442017-10-24 11:13:31 -07003255 depPaths.Flags = android.FirstUniqueStrings(depPaths.Flags)
Jiyong Park74955042019-10-22 20:19:51 +09003256 depPaths.IncludeDirs = android.FirstUniquePaths(depPaths.IncludeDirs)
3257 depPaths.SystemIncludeDirs = android.FirstUniquePaths(depPaths.SystemIncludeDirs)
Inseob Kimd110f872019-12-06 13:15:38 +09003258 depPaths.GeneratedDeps = android.FirstUniquePaths(depPaths.GeneratedDeps)
Ivan Lozano0a468a42024-05-13 21:03:34 -04003259 depPaths.RustRlibDeps = android.FirstUniqueFunc(depPaths.RustRlibDeps, EqRustRlibDeps)
3260
Jiyong Park74955042019-10-22 20:19:51 +09003261 depPaths.ReexportedDirs = android.FirstUniquePaths(depPaths.ReexportedDirs)
3262 depPaths.ReexportedSystemDirs = android.FirstUniquePaths(depPaths.ReexportedSystemDirs)
Colin Crossb6715442017-10-24 11:13:31 -07003263 depPaths.ReexportedFlags = android.FirstUniqueStrings(depPaths.ReexportedFlags)
Inseob Kim69378442019-06-03 19:10:47 +09003264 depPaths.ReexportedDeps = android.FirstUniquePaths(depPaths.ReexportedDeps)
Inseob Kimd110f872019-12-06 13:15:38 +09003265 depPaths.ReexportedGeneratedHeaders = android.FirstUniquePaths(depPaths.ReexportedGeneratedHeaders)
Ivan Lozano0a468a42024-05-13 21:03:34 -04003266 depPaths.ReexportedRustRlibDeps = android.FirstUniqueFunc(depPaths.ReexportedRustRlibDeps, EqRustRlibDeps)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003267
3268 if c.sabi != nil {
Inseob Kim69378442019-06-03 19:10:47 +09003269 c.sabi.Properties.ReexportedIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedIncludes)
Hsin-Yi Chen5f228b02024-04-02 12:38:47 +08003270 c.sabi.Properties.ReexportedSystemIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedSystemIncludes)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003271 }
Colin Crossdd84e052017-05-17 13:44:16 -07003272
Colin Crossca860ac2016-01-04 14:34:37 -08003273 return depPaths
3274}
3275
Spandan Das604f3762023-03-16 22:51:40 +00003276func ShouldUseStubForApex(ctx android.ModuleContext, dep android.Module) bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09003277 depName := ctx.OtherModuleName(dep)
Jiyong Park7d55b612021-06-11 17:22:09 +09003278 thisModule, ok := ctx.Module().(android.ApexModule)
3279 if !ok {
3280 panic(fmt.Errorf("Not an APEX module: %q", ctx.ModuleName()))
3281 }
3282
Kiyoung Kimaa394802024-01-08 12:55:45 +09003283 inVendorOrProduct := false
Jiyong Park7d55b612021-06-11 17:22:09 +09003284 bootstrap := false
3285 if linkable, ok := ctx.Module().(LinkableInterface); !ok {
3286 panic(fmt.Errorf("Not a Linkable module: %q", ctx.ModuleName()))
3287 } else {
Kiyoung Kimaa394802024-01-08 12:55:45 +09003288 inVendorOrProduct = linkable.InVendorOrProduct()
Jiyong Park7d55b612021-06-11 17:22:09 +09003289 bootstrap = linkable.Bootstrap()
3290 }
3291
Colin Crossff694a82023-12-13 15:54:49 -08003292 apexInfo, _ := android.ModuleProvider(ctx, android.ApexInfoProvider)
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003293
3294 useStubs := false
3295
Kiyoung Kimaa394802024-01-08 12:55:45 +09003296 if lib := moduleLibraryInterface(dep); lib.buildStubs() && inVendorOrProduct { // LLNDK
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003297 if !apexInfo.IsForPlatform() {
3298 // For platform libraries, use current version of LLNDK
3299 // If this is for use_vendor apex we will apply the same rules
3300 // of apex sdk enforcement below to choose right version.
3301 useStubs = true
3302 }
3303 } else if apexInfo.IsForPlatform() || apexInfo.UsePlatformApis {
3304 // If not building for APEX or the containing APEX allows the use of
3305 // platform APIs, use stubs only when it is from an APEX (and not from
3306 // platform) However, for host, ramdisk, vendor_ramdisk, recovery or
3307 // bootstrap modules, always link to non-stub variant
3308 isNotInPlatform := dep.(android.ApexModule).NotInPlatform()
3309
Spandan Dasff665182024-09-11 18:48:44 +00003310 useStubs = isNotInPlatform && !bootstrap
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003311
3312 if useStubs {
3313 // Another exception: if this module is a test for an APEX, then
3314 // it is linked with the non-stub variant of a module in the APEX
3315 // as if this is part of the APEX.
Colin Crossff694a82023-12-13 15:54:49 -08003316 testFor, _ := android.ModuleProvider(ctx, android.ApexTestForInfoProvider)
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003317 for _, apexContents := range testFor.ApexContents {
3318 if apexContents.DirectlyInApex(depName) {
3319 useStubs = false
3320 break
3321 }
3322 }
3323 }
3324 if useStubs {
3325 // Yet another exception: If this module and the dependency are
3326 // available to the same APEXes then skip stubs between their
3327 // platform variants. This complements the test_for case above,
3328 // which avoids the stubs on a direct APEX library dependency, by
3329 // avoiding stubs for indirect test dependencies as well.
3330 //
3331 // TODO(b/183882457): This doesn't work if the two libraries have
3332 // only partially overlapping apex_available. For that test_for
3333 // modules would need to be split into APEX variants and resolved
3334 // separately for each APEX they have access to.
Spandan Dasff665182024-09-11 18:48:44 +00003335 if android.AvailableToSameApexes(thisModule, dep.(android.ApexModule)) {
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003336 useStubs = false
3337 }
3338 }
3339 } else {
3340 // If building for APEX, use stubs when the parent is in any APEX that
3341 // the child is not in.
3342 useStubs = !android.DirectlyInAllApexes(apexInfo, depName)
3343 }
3344
3345 return useStubs
3346}
3347
3348// ChooseStubOrImpl determines whether a given dependency should be redirected to the stub variant
3349// of the dependency or not, and returns the SharedLibraryInfo and FlagExporterInfo for the right
3350// dependency. The stub variant is selected when the dependency crosses a boundary where each side
3351// has different level of updatability. For example, if a library foo in an APEX depends on a
3352// library bar which provides stable interface and exists in the platform, foo uses the stub variant
3353// of bar. If bar doesn't provide a stable interface (i.e. buildStubs() == false) or is in the
3354// same APEX as foo, the non-stub variant of bar is used.
3355func ChooseStubOrImpl(ctx android.ModuleContext, dep android.Module) (SharedLibraryInfo, FlagExporterInfo) {
3356 depTag := ctx.OtherModuleDependencyTag(dep)
3357 libDepTag, ok := depTag.(libraryDependencyTag)
3358 if !ok || !libDepTag.shared() {
3359 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
3360 }
3361
Colin Cross313aa542023-12-13 13:47:44 -08003362 sharedLibraryInfo, _ := android.OtherModuleProvider(ctx, dep, SharedLibraryInfoProvider)
3363 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
3364 sharedLibraryStubsInfo, _ := android.OtherModuleProvider(ctx, dep, SharedLibraryStubsProvider)
Jiyong Park7d55b612021-06-11 17:22:09 +09003365
3366 if !libDepTag.explicitlyVersioned && len(sharedLibraryStubsInfo.SharedStubLibraries) > 0 {
Jiyong Park7d55b612021-06-11 17:22:09 +09003367 // when to use (unspecified) stubs, use the latest one.
Spandan Das604f3762023-03-16 22:51:40 +00003368 if ShouldUseStubForApex(ctx, dep) {
Jiyong Park7d55b612021-06-11 17:22:09 +09003369 stubs := sharedLibraryStubsInfo.SharedStubLibraries
3370 toUse := stubs[len(stubs)-1]
3371 sharedLibraryInfo = toUse.SharedLibraryInfo
3372 depExporterInfo = toUse.FlagExporterInfo
3373 }
3374 }
3375 return sharedLibraryInfo, depExporterInfo
3376}
3377
Colin Cross0de8a1e2020-09-18 14:15:30 -07003378// orderStaticModuleDeps rearranges the order of the static library dependencies of the module
3379// to match the topological order of the dependency tree, including any static analogues of
Colin Crossa14fb6a2024-10-23 16:57:06 -07003380// direct shared libraries. It returns the ordered static dependencies, and a depset.DepSet
Colin Cross0de8a1e2020-09-18 14:15:30 -07003381// of the transitive dependencies.
Colin Crossa14fb6a2024-10-23 16:57:06 -07003382func orderStaticModuleDeps(staticDeps []StaticLibraryInfo, sharedDeps []SharedLibraryInfo) (ordered android.Paths, transitive depset.DepSet[android.Path]) {
3383 transitiveStaticLibsBuilder := depset.NewBuilder[android.Path](depset.TOPOLOGICAL)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003384 var staticPaths android.Paths
3385 for _, staticDep := range staticDeps {
3386 staticPaths = append(staticPaths, staticDep.StaticLibrary)
3387 transitiveStaticLibsBuilder.Transitive(staticDep.TransitiveStaticLibrariesForOrdering)
3388 }
3389 for _, sharedDep := range sharedDeps {
Colin Crossa14fb6a2024-10-23 16:57:06 -07003390 transitiveStaticLibsBuilder.Transitive(sharedDep.TransitiveStaticLibrariesForOrdering)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003391 }
3392 transitiveStaticLibs := transitiveStaticLibsBuilder.Build()
3393
3394 orderedTransitiveStaticLibs := transitiveStaticLibs.ToList()
3395
3396 // reorder the dependencies based on transitive dependencies
3397 staticPaths = android.FirstUniquePaths(staticPaths)
3398 _, orderedStaticPaths := android.FilterPathList(orderedTransitiveStaticLibs, staticPaths)
3399
3400 if len(orderedStaticPaths) != len(staticPaths) {
3401 missing, _ := android.FilterPathList(staticPaths, orderedStaticPaths)
3402 panic(fmt.Errorf("expected %d ordered static paths , got %d, missing %q %q %q", len(staticPaths), len(orderedStaticPaths), missing, orderedStaticPaths, staticPaths))
3403 }
3404
3405 return orderedStaticPaths, transitiveStaticLibs
3406}
3407
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003408// BaseLibName trims known prefixes and suffixes
3409func BaseLibName(depName string) string {
Colin Cross6e511a92020-07-27 21:26:48 -07003410 libName := strings.TrimSuffix(depName, llndkLibrarySuffix)
3411 libName = strings.TrimSuffix(libName, vendorPublicLibrarySuffix)
Paul Duffind23c7262020-12-11 18:13:08 +00003412 libName = android.RemoveOptionalPrebuiltPrefix(libName)
Colin Cross6e511a92020-07-27 21:26:48 -07003413 return libName
3414}
3415
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003416func MakeLibName(ctx android.ModuleContext, c LinkableInterface, ccDep LinkableInterface, depName string) string {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003417 libName := BaseLibName(depName)
Colin Cross127bb8b2020-12-16 16:46:01 -08003418 ccDepModule, _ := ccDep.(*Module)
3419 isLLndk := ccDepModule != nil && ccDepModule.IsLlndk()
Justin Yuncbca3732021-02-03 19:24:13 +09003420 nonSystemVariantsExist := ccDep.HasNonSystemVariants() || isLLndk
Colin Cross6e511a92020-07-27 21:26:48 -07003421
Justin Yuncbca3732021-02-03 19:24:13 +09003422 if ccDepModule != nil {
Colin Cross6e511a92020-07-27 21:26:48 -07003423 // Use base module name for snapshots when exporting to Makefile.
Ivan Lozanod1dec542021-05-26 15:33:11 -04003424 if snapshotPrebuilt, ok := ccDepModule.linker.(SnapshotInterface); ok {
Justin Yuncbca3732021-02-03 19:24:13 +09003425 baseName := ccDepModule.BaseModuleName()
Colin Cross6e511a92020-07-27 21:26:48 -07003426
Ivan Lozanod1dec542021-05-26 15:33:11 -04003427 return baseName + snapshotPrebuilt.SnapshotAndroidMkSuffix()
Colin Cross6e511a92020-07-27 21:26:48 -07003428 }
3429 }
3430
Kiyoung Kim22152f62024-05-24 10:45:28 +09003431 if ccDep.InVendorOrProduct() && nonSystemVariantsExist {
Justin Yuncbca3732021-02-03 19:24:13 +09003432 // The vendor and product modules in Make will have been renamed to not conflict with the
3433 // core module, so update the dependency name here accordingly.
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003434 return libName + ccDep.SubName()
Colin Cross6e511a92020-07-27 21:26:48 -07003435 } else if ccDep.InRamdisk() && !ccDep.OnlyInRamdisk() {
Matthew Maurerc6868382021-07-13 14:12:37 -07003436 return libName + RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003437 } else if ccDep.InVendorRamdisk() && !ccDep.OnlyInVendorRamdisk() {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05003438 return libName + VendorRamdiskSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003439 } else if ccDep.InRecovery() && !ccDep.OnlyInRecovery() {
Matthew Maurer460ee942021-02-11 12:31:46 -08003440 return libName + RecoverySuffix
Ivan Lozanof9e21722020-12-02 09:00:51 -05003441 } else if ccDep.Target().NativeBridge == android.NativeBridgeEnabled {
Matthew Maurera61e31f2021-05-27 11:09:11 -07003442 return libName + NativeBridgeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003443 } else {
3444 return libName
3445 }
3446}
3447
Colin Crossca860ac2016-01-04 14:34:37 -08003448func (c *Module) InstallInData() bool {
3449 if c.installer == nil {
3450 return false
3451 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003452 return c.installer.inData()
3453}
3454
3455func (c *Module) InstallInSanitizerDir() bool {
3456 if c.installer == nil {
3457 return false
3458 }
3459 if c.sanitize != nil && c.sanitize.inSanitizerDir() {
Colin Cross94610402016-08-29 13:41:32 -07003460 return true
3461 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003462 return c.installer.inSanitizerDir()
Colin Crossca860ac2016-01-04 14:34:37 -08003463}
3464
Yifan Hong1b3348d2020-01-21 15:53:22 -08003465func (c *Module) InstallInRamdisk() bool {
3466 return c.InRamdisk()
3467}
3468
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003469func (c *Module) InstallInVendorRamdisk() bool {
3470 return c.InVendorRamdisk()
3471}
3472
Jiyong Parkf9332f12018-02-01 00:54:12 +09003473func (c *Module) InstallInRecovery() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07003474 return c.InRecovery()
Jiyong Parkf9332f12018-02-01 00:54:12 +09003475}
3476
Jingwen Chen8ac7d7d2023-03-20 11:05:16 +00003477func (c *Module) MakeUninstallable() {
3478 if c.installer == nil {
3479 c.ModuleBase.MakeUninstallable()
3480 return
3481 }
3482 c.installer.makeUninstallable(c)
3483}
3484
Dan Willemsen4aa75ca2016-09-28 16:18:03 -07003485func (c *Module) HostToolPath() android.OptionalPath {
3486 if c.installer == nil {
3487 return android.OptionalPath{}
3488 }
3489 return c.installer.hostToolPath()
3490}
3491
Nan Zhangd4e641b2017-07-12 12:55:28 -07003492func (c *Module) IntermPathForModuleOut() android.OptionalPath {
3493 return c.outputFile
3494}
3495
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00003496func (c *Module) static() bool {
3497 if static, ok := c.linker.(interface {
3498 static() bool
3499 }); ok {
3500 return static.static()
3501 }
3502 return false
3503}
3504
Jiyong Park379de2f2018-12-19 02:47:14 +09003505func (c *Module) staticBinary() bool {
3506 if static, ok := c.linker.(interface {
3507 staticBinary() bool
3508 }); ok {
3509 return static.staticBinary()
3510 }
3511 return false
3512}
3513
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07003514func (c *Module) testBinary() bool {
3515 if test, ok := c.linker.(interface {
3516 testBinary() bool
3517 }); ok {
3518 return test.testBinary()
3519 }
3520 return false
3521}
3522
Jingwen Chen537242c2022-08-24 11:53:27 +00003523func (c *Module) testLibrary() bool {
3524 if test, ok := c.linker.(interface {
3525 testLibrary() bool
3526 }); ok {
3527 return test.testLibrary()
3528 }
3529 return false
3530}
3531
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003532func (c *Module) benchmarkBinary() bool {
3533 if b, ok := c.linker.(interface {
3534 benchmarkBinary() bool
3535 }); ok {
3536 return b.benchmarkBinary()
3537 }
3538 return false
3539}
3540
3541func (c *Module) fuzzBinary() bool {
3542 if f, ok := c.linker.(interface {
3543 fuzzBinary() bool
3544 }); ok {
3545 return f.fuzzBinary()
3546 }
3547 return false
3548}
3549
Ivan Lozano3968d8f2020-12-14 11:27:52 -05003550// Header returns true if the module is a header-only variant. (See cc/library.go header()).
3551func (c *Module) Header() bool {
Jiyong Park1d1119f2019-07-29 21:27:18 +09003552 if h, ok := c.linker.(interface {
3553 header() bool
3554 }); ok {
3555 return h.header()
3556 }
3557 return false
3558}
3559
Ivan Lozanod7586b62021-04-01 09:49:36 -04003560func (c *Module) Binary() bool {
Inseob Kim7f283f42020-06-01 21:53:49 +09003561 if b, ok := c.linker.(interface {
3562 binary() bool
3563 }); ok {
3564 return b.binary()
3565 }
3566 return false
3567}
3568
Justin Yun5e035862021-06-29 20:50:37 +09003569func (c *Module) StaticExecutable() bool {
3570 if b, ok := c.linker.(*binaryDecorator); ok {
3571 return b.static()
3572 }
3573 return false
3574}
3575
Ivan Lozanod7586b62021-04-01 09:49:36 -04003576func (c *Module) Object() bool {
Inseob Kim1042d292020-06-01 23:23:05 +09003577 if o, ok := c.linker.(interface {
3578 object() bool
3579 }); ok {
3580 return o.object()
3581 }
3582 return false
3583}
3584
Kiyoung Kim37693d02024-04-04 09:56:15 +09003585func (m *Module) Dylib() bool {
3586 return false
3587}
3588
3589func (m *Module) Rlib() bool {
3590 return false
3591}
3592
Ivan Lozanof9e21722020-12-02 09:00:51 -05003593func GetMakeLinkType(actx android.ModuleContext, c LinkableInterface) string {
Kiyoung Kim8487c0b2024-01-11 16:03:13 +09003594 if c.InVendorOrProduct() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003595 if c.IsLlndk() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003596 return "native:vndk"
Jooyung Han38002912019-05-16 04:01:54 +09003597 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003598 if c.InProduct() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09003599 return "native:product"
3600 }
Jooyung Han38002912019-05-16 04:01:54 +09003601 return "native:vendor"
Yifan Hong1b3348d2020-01-21 15:53:22 -08003602 } else if c.InRamdisk() {
3603 return "native:ramdisk"
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003604 } else if c.InVendorRamdisk() {
3605 return "native:vendor_ramdisk"
Ivan Lozano52767be2019-10-18 14:49:46 -07003606 } else if c.InRecovery() {
Colin Crossb60190a2018-09-04 16:28:17 -07003607 return "native:recovery"
Ivan Lozanof9e21722020-12-02 09:00:51 -05003608 } else if c.Target().Os == android.Android && c.SdkVersion() != "" {
Colin Crossb60190a2018-09-04 16:28:17 -07003609 return "native:ndk:none:none"
3610 // TODO(b/114741097): use the correct ndk stl once build errors have been fixed
3611 //family, link := getNdkStlFamilyAndLinkType(c)
3612 //return fmt.Sprintf("native:ndk:%s:%s", family, link)
3613 } else {
3614 return "native:platform"
3615 }
3616}
3617
Jiyong Park9d452992018-10-03 00:38:19 +09003618// Overrides ApexModule.IsInstallabeToApex()
Colin Cross3a02c7b2024-05-21 13:46:22 -07003619// Only shared/runtime libraries .
Jiyong Park9d452992018-10-03 00:38:19 +09003620func (c *Module) IsInstallableToApex() bool {
Colin Cross31076b32020-10-23 17:22:06 -07003621 if lib := c.library; lib != nil {
Jiyong Park73c54ee2019-10-22 20:31:18 +09003622 // Stub libs and prebuilt libs in a versioned SDK are not
3623 // installable to APEX even though they are shared libs.
Paul Duffin458a15b2022-11-25 12:18:24 +00003624 return lib.shared() && !lib.buildStubs()
Jiyong Park9d452992018-10-03 00:38:19 +09003625 }
3626 return false
3627}
3628
Jiyong Parka90ca002019-10-07 15:47:24 +09003629func (c *Module) AvailableFor(what string) bool {
3630 if linker, ok := c.linker.(interface {
3631 availableFor(string) bool
3632 }); ok {
3633 return c.ApexModuleBase.AvailableFor(what) || linker.availableFor(what)
3634 } else {
3635 return c.ApexModuleBase.AvailableFor(what)
3636 }
3637}
3638
Jiyong Park62304bb2020-04-13 16:19:48 +09003639func (c *Module) TestFor() []string {
Jiyong Park46a512f2020-12-04 18:02:13 +09003640 return c.Properties.Test_for
Jiyong Park62304bb2020-04-13 16:19:48 +09003641}
3642
Paul Duffin0cb37b92020-03-04 14:52:46 +00003643func (c *Module) EverInstallable() bool {
3644 return c.installer != nil &&
3645 // Check to see whether the module is actually ever installable.
3646 c.installer.everInstallable()
3647}
3648
Ivan Lozanod7586b62021-04-01 09:49:36 -04003649func (c *Module) PreventInstall() bool {
3650 return c.Properties.PreventInstall
3651}
3652
3653func (c *Module) Installable() *bool {
Colin Cross1bc94122021-10-28 13:25:54 -07003654 if c.library != nil {
3655 if i := c.library.installable(); i != nil {
3656 return i
3657 }
3658 }
Ivan Lozanod7586b62021-04-01 09:49:36 -04003659 return c.Properties.Installable
3660}
3661
3662func installable(c LinkableInterface, apexInfo android.ApexInfo) bool {
Paul Duffin0cb37b92020-03-04 14:52:46 +00003663 ret := c.EverInstallable() &&
3664 // Check to see whether the module has been configured to not be installed.
Ivan Lozanod7586b62021-04-01 09:49:36 -04003665 proptools.BoolDefault(c.Installable(), true) &&
3666 !c.PreventInstall() && c.OutputFile().Valid()
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003667
3668 // The platform variant doesn't need further condition. Apex variants however might not
3669 // be installable because it will likely to be included in the APEX and won't appear
3670 // in the system partition.
Colin Cross56a83212020-09-15 18:30:11 -07003671 if apexInfo.IsForPlatform() {
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003672 return ret
3673 }
3674
3675 // Special case for modules that are configured to be installed to /data, which includes
3676 // test modules. For these modules, both APEX and non-APEX variants are considered as
3677 // installable. This is because even the APEX variants won't be included in the APEX, but
3678 // will anyway be installed to /data/*.
3679 // See b/146995717
3680 if c.InstallInData() {
3681 return ret
3682 }
3683
3684 return false
Inseob Kim1f086e22019-05-09 13:29:15 +09003685}
3686
Logan Chien41eabe62019-04-10 13:33:58 +08003687func (c *Module) AndroidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer) {
3688 if c.linker != nil {
3689 if library, ok := c.linker.(*libraryDecorator); ok {
3690 library.androidMkWriteAdditionalDependenciesForSourceAbiDiff(w)
3691 }
3692 }
3693}
3694
Jiyong Park45bf82e2020-12-15 22:29:02 +09003695var _ android.ApexModule = (*Module)(nil)
3696
3697// Implements android.ApexModule
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003698func (c *Module) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
Colin Cross6e511a92020-07-27 21:26:48 -07003699 depTag := ctx.OtherModuleDependencyTag(dep)
3700 libDepTag, isLibDepTag := depTag.(libraryDependencyTag)
3701
3702 if cc, ok := dep.(*Module); ok {
3703 if cc.HasStubsVariants() {
3704 if isLibDepTag && libDepTag.shared() {
3705 // dynamic dep to a stubs lib crosses APEX boundary
3706 return false
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003707 }
Colin Cross6e511a92020-07-27 21:26:48 -07003708 if IsRuntimeDepTag(depTag) {
3709 // runtime dep to a stubs lib also crosses APEX boundary
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003710 return false
3711 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003712 }
Zhijun Heec285872021-04-24 10:47:08 -07003713 if cc.IsLlndk() {
3714 return false
3715 }
Colin Crossaac32222020-07-29 12:51:56 -07003716 if isLibDepTag && c.static() && libDepTag.shared() {
Colin Cross6e511a92020-07-27 21:26:48 -07003717 // shared_lib dependency from a static lib is considered as crossing
3718 // the APEX boundary because the dependency doesn't actually is
3719 // linked; the dependency is used only during the compilation phase.
3720 return false
3721 }
Jiyong Parke3867542020-12-03 17:28:25 +09003722
3723 if isLibDepTag && libDepTag.excludeInApex {
3724 return false
3725 }
Colin Cross6e511a92020-07-27 21:26:48 -07003726 }
Colin Crossc1b36442021-05-06 13:42:48 -07003727 if depTag == stubImplDepTag {
3728 // We don't track from an implementation library to its stubs.
Jiyong Park7d95a512020-05-10 15:16:24 +09003729 return false
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003730 }
Jiyong Park12177fc2021-01-05 14:37:15 +09003731 if depTag == staticVariantTag {
3732 // This dependency is for optimization (reuse *.o from the static lib). It doesn't
3733 // actually mean that the static lib (and its dependencies) are copied into the
3734 // APEX.
3735 return false
3736 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003737 return true
3738}
3739
Jiyong Park45bf82e2020-12-15 22:29:02 +09003740// Implements android.ApexModule
Dan Albertc8060532020-07-22 22:32:17 -07003741func (c *Module) ShouldSupportSdkVersion(ctx android.BaseModuleContext,
3742 sdkVersion android.ApiLevel) error {
Jooyung Han749dc692020-04-15 11:03:39 +09003743 // We ignore libclang_rt.* prebuilt libs since they declare sdk_version: 14(b/121358700)
3744 if strings.HasPrefix(ctx.OtherModuleName(c), "libclang_rt") {
3745 return nil
3746 }
Jooyung Han749dc692020-04-15 11:03:39 +09003747 // We don't check for prebuilt modules
3748 if _, ok := c.linker.(prebuiltLinkerInterface); ok {
3749 return nil
3750 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09003751
Jooyung Han749dc692020-04-15 11:03:39 +09003752 minSdkVersion := c.MinSdkVersion()
3753 if minSdkVersion == "apex_inherit" {
3754 return nil
3755 }
3756 if minSdkVersion == "" {
3757 // JNI libs within APK-in-APEX fall into here
3758 // Those are okay to set sdk_version instead
3759 // We don't have to check if this is a SDK variant because
3760 // non-SDK variant resets sdk_version, which works too.
3761 minSdkVersion = c.SdkVersion()
3762 }
Dan Albertc8060532020-07-22 22:32:17 -07003763 if minSdkVersion == "" {
3764 return fmt.Errorf("neither min_sdk_version nor sdk_version specificed")
3765 }
3766 // Not using nativeApiLevelFromUser because the context here is not
3767 // necessarily a native context.
3768 ver, err := android.ApiLevelFromUser(ctx, minSdkVersion)
Jooyung Han749dc692020-04-15 11:03:39 +09003769 if err != nil {
3770 return err
3771 }
Dan Albertc8060532020-07-22 22:32:17 -07003772
Colin Cross8ca61c12022-10-06 21:00:14 -07003773 // A dependency only needs to support a min_sdk_version at least
3774 // as high as the api level that the architecture was introduced in.
3775 // This allows introducing new architectures in the platform that
3776 // need to be included in apexes that normally require an older
3777 // min_sdk_version.
Colin Crossbb137a32023-01-26 09:54:42 -08003778 minApiForArch := MinApiForArch(ctx, c.Target().Arch.ArchType)
Colin Cross8ca61c12022-10-06 21:00:14 -07003779 if sdkVersion.LessThan(minApiForArch) {
3780 sdkVersion = minApiForArch
3781 }
3782
Dan Albertc8060532020-07-22 22:32:17 -07003783 if ver.GreaterThan(sdkVersion) {
Jooyung Han749dc692020-04-15 11:03:39 +09003784 return fmt.Errorf("newer SDK(%v)", ver)
3785 }
3786 return nil
3787}
3788
Paul Duffinb5769c12021-05-12 16:16:51 +01003789// Implements android.ApexModule
3790func (c *Module) AlwaysRequiresPlatformApexVariant() bool {
3791 // stub libraries and native bridge libraries are always available to platform
3792 return c.IsStubs() || c.Target().NativeBridge == android.NativeBridgeEnabled
3793}
3794
Inseob Kima1888ce2022-10-04 14:42:02 +09003795func (c *Module) overriddenModules() []string {
3796 if o, ok := c.linker.(overridable); ok {
3797 return o.overriddenModules()
3798 }
3799 return nil
3800}
3801
Liz Kammer35ca77e2021-12-22 15:31:40 -05003802type moduleType int
3803
3804const (
3805 unknownType moduleType = iota
3806 binary
3807 object
3808 fullLibrary
3809 staticLibrary
3810 sharedLibrary
3811 headerLibrary
Jingwen Chen537242c2022-08-24 11:53:27 +00003812 testBin // testBinary already declared
Spandan Das1278c2c2022-08-19 18:17:28 +00003813 ndkLibrary
Liz Kammer35ca77e2021-12-22 15:31:40 -05003814)
3815
3816func (c *Module) typ() moduleType {
Jingwen Chen537242c2022-08-24 11:53:27 +00003817 if c.testBinary() {
3818 // testBinary is also a binary, so this comes before the c.Binary()
3819 // conditional. A testBinary has additional implicit dependencies and
3820 // other test-only semantics.
3821 return testBin
3822 } else if c.Binary() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003823 return binary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003824 } else if c.Object() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003825 return object
Jingwen Chen537242c2022-08-24 11:53:27 +00003826 } else if c.testLibrary() {
3827 // TODO(b/244431896) properly convert cc_test_library to its own macro. This
3828 // will let them add implicit compile deps on gtest, for example.
3829 //
Liz Kammerefc51d92023-04-21 15:11:25 -04003830 // For now, treat them as regular libraries.
3831 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003832 } else if c.CcLibrary() {
Chris Parsons58852a02021-12-09 18:10:18 -05003833 static := false
3834 shared := false
3835 if library, ok := c.linker.(*libraryDecorator); ok {
3836 static = library.MutatedProperties.BuildStatic
3837 shared = library.MutatedProperties.BuildShared
3838 } else if library, ok := c.linker.(*prebuiltLibraryLinker); ok {
3839 static = library.MutatedProperties.BuildStatic
3840 shared = library.MutatedProperties.BuildShared
3841 }
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003842 if static && shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003843 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003844 } else if !static && !shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003845 return headerLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003846 } else if static {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003847 return staticLibrary
3848 }
3849 return sharedLibrary
Spandan Das1278c2c2022-08-19 18:17:28 +00003850 } else if c.isNDKStubLibrary() {
3851 return ndkLibrary
Liz Kammer35ca77e2021-12-22 15:31:40 -05003852 }
3853 return unknownType
3854}
3855
Colin Crosscfad1192015-11-02 16:43:11 -08003856// Defaults
Colin Crossca860ac2016-01-04 14:34:37 -08003857type Defaults struct {
Colin Cross635c3b02016-05-18 15:37:25 -07003858 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -07003859 android.DefaultsModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +09003860 android.ApexModuleBase
Colin Crosscfad1192015-11-02 16:43:11 -08003861}
3862
Patrice Arrudac249c712019-03-19 17:00:29 -07003863// cc_defaults provides a set of properties that can be inherited by other cc
3864// modules. A module can use the properties from a cc_defaults using
3865// `defaults: ["<:default_module_name>"]`. Properties of both modules are
3866// merged (when possible) by prepending the default module's values to the
3867// depending module's values.
Colin Cross36242852017-06-23 15:06:31 -07003868func defaultsFactory() android.Module {
Colin Crosse1d764e2016-08-18 14:18:32 -07003869 return DefaultsFactory()
3870}
3871
Colin Cross36242852017-06-23 15:06:31 -07003872func DefaultsFactory(props ...interface{}) android.Module {
Colin Crossca860ac2016-01-04 14:34:37 -08003873 module := &Defaults{}
Colin Crosscfad1192015-11-02 16:43:11 -08003874
Colin Cross36242852017-06-23 15:06:31 -07003875 module.AddProperties(props...)
3876 module.AddProperties(
Colin Crossca860ac2016-01-04 14:34:37 -08003877 &BaseProperties{},
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003878 &VendorProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003879 &BaseCompilerProperties{},
3880 &BaseLinkerProperties{},
Paul Duffina37832a2019-07-18 12:31:26 +01003881 &ObjectLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003882 &LibraryProperties{},
Colin Crosse1bb5d02019-09-24 14:55:04 -07003883 &StaticProperties{},
3884 &SharedProperties{},
Colin Cross919281a2016-04-05 16:42:05 -07003885 &FlagExporterProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003886 &BinaryLinkerProperties{},
Trevor Radcliffef389cb42022-03-24 21:06:14 +00003887 &TestLinkerProperties{},
3888 &TestInstallerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003889 &TestBinaryProperties{},
Colin Cross43287652020-06-30 10:15:07 -07003890 &BenchmarkProperties{},
hamzehc0a671f2021-07-22 12:05:08 -07003891 &fuzz.FuzzProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003892 &StlProperties{},
Colin Cross16b23492016-01-06 14:41:07 -08003893 &SanitizeProperties{},
Colin Cross665dce92016-04-28 14:50:03 -07003894 &StripProperties{},
Dan Willemsen7424d612016-09-01 13:45:39 -07003895 &InstallerProperties{},
Dan Willemsena03cf6d2016-09-26 15:45:04 -07003896 &TidyProperties{},
Dan Willemsen581341d2017-02-09 16:16:31 -08003897 &CoverageProperties{},
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08003898 &SAbiProperties{},
Stephen Craneba090d12017-05-09 15:44:35 -07003899 &LTOProperties{},
Yi Kongeb8efc92021-12-09 18:06:29 +08003900 &AfdoProperties{},
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00003901 &OrderfileProperties{},
Dan Willemsen6424d172018-03-08 13:27:59 -08003902 &android.ProtoProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -04003903 // RustBindgenProperties is included here so that cc_defaults can be used for rust_bindgen modules.
3904 &RustBindgenClangProperties{},
Yu-Chi Cheng24b2b0f2021-06-23 15:56:39 -07003905 &prebuiltLinkerProperties{},
Colin Crosse1d764e2016-08-18 14:18:32 -07003906 )
Colin Crosscfad1192015-11-02 16:43:11 -08003907
Jooyung Hancc372c52019-09-25 15:18:44 +09003908 android.InitDefaultsModule(module)
Colin Cross36242852017-06-23 15:06:31 -07003909
3910 return module
Colin Crosscfad1192015-11-02 16:43:11 -08003911}
3912
Jiyong Park2286afd2020-06-16 21:58:53 +09003913func (c *Module) IsSdkVariant() bool {
Lukacs T. Berki2063a0d2021-06-17 09:32:36 +02003914 return c.Properties.IsSdkVariant
Jiyong Park2286afd2020-06-16 21:58:53 +09003915}
3916
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003917func kytheExtractAllFactory() android.Singleton {
3918 return &kytheExtractAllSingleton{}
3919}
3920
3921type kytheExtractAllSingleton struct {
3922}
3923
3924func (ks *kytheExtractAllSingleton) GenerateBuildActions(ctx android.SingletonContext) {
3925 var xrefTargets android.Paths
3926 ctx.VisitAllModules(func(module android.Module) {
3927 if ccModule, ok := module.(xref); ok {
3928 xrefTargets = append(xrefTargets, ccModule.XrefCcFiles()...)
3929 }
3930 })
3931 // TODO(asmundak): Perhaps emit a rule to output a warning if there were no xrefTargets
3932 if len(xrefTargets) > 0 {
Colin Crossc3d87d32020-06-04 13:25:17 -07003933 ctx.Phony("xref_cxx", xrefTargets...)
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003934 }
3935}
3936
Jihoon Kangf78a8902022-09-01 22:47:07 +00003937func (c *Module) Partition() string {
3938 if p, ok := c.installer.(interface {
3939 getPartition() string
3940 }); ok {
3941 return p.getPartition()
3942 }
3943 return ""
3944}
3945
Spandan Das2b6dfb52024-01-19 00:22:22 +00003946type sourceModuleName interface {
3947 sourceModuleName() string
3948}
3949
3950func (c *Module) BaseModuleName() string {
3951 if smn, ok := c.linker.(sourceModuleName); ok && smn.sourceModuleName() != "" {
3952 // if the prebuilt module sets a source_module_name in Android.bp, use that
3953 return smn.sourceModuleName()
3954 }
3955 return c.ModuleBase.BaseModuleName()
3956}
3957
Spandan Dase20c56c2024-07-23 21:34:24 +00003958func (c *Module) stubsSymbolFilePath() android.Path {
3959 if library, ok := c.linker.(*libraryDecorator); ok {
3960 return library.stubsSymbolFilePath
3961 }
3962 return android.OptionalPath{}.Path()
3963}
3964
Colin Cross06a931b2015-10-28 17:23:31 -07003965var Bool = proptools.Bool
Colin Cross38b40df2018-04-10 16:14:46 -07003966var BoolDefault = proptools.BoolDefault
Nan Zhang0007d812017-11-07 10:57:05 -08003967var BoolPtr = proptools.BoolPtr
3968var String = proptools.String
3969var StringPtr = proptools.StringPtr