blob: 5480a8cce13e857076c1f45fc52f09945d8f6999 [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 Cross516c5452024-10-28 13:45:21 -070022 "errors"
Colin Cross41955e82019-05-29 14:40:35 -070023 "fmt"
Logan Chien41eabe62019-04-10 13:33:58 +080024 "io"
Colin Cross516c5452024-10-28 13:45:21 -070025 "slices"
Dan Albert9e10cd42016-08-03 14:12:14 -070026 "strconv"
Colin Cross3f40fa42015-01-30 17:27:36 -080027 "strings"
28
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
Cole Faust65cb40a2024-10-21 15:41:42 -0700123 GeneratedSources []string
124 GeneratedHeaders []string
125 DeviceFirstGeneratedHeaders []string
126 GeneratedDeps []string
Dan Willemsenb40aab62016-04-20 14:21:14 -0700127
Dan Willemsenb3454ab2016-09-28 17:34:58 -0700128 ReexportGeneratedHeaders []string
129
Colin Crossc465efd2021-06-11 18:00:04 -0700130 CrtBegin, CrtEnd []string
Dan Willemsena0790e32018-10-12 00:24:23 -0700131
132 // Used for host bionic
Colin Cross9cfe6112021-06-11 18:02:22 -0700133 DynamicLinker string
Jiyong Parke3867542020-12-03 17:28:25 +0900134
135 // List of libs that need to be excluded for APEX variant
136 ExcludeLibsForApex []string
Jooyung Han9ffbe832023-11-28 22:31:35 +0900137 // List of libs that need to be excluded for non-APEX variant
138 ExcludeLibsForNonApex []string
Hsin-Yi Chen715142a2024-03-27 16:31:16 +0800139
140 // LLNDK headers for the ABI checker to check LLNDK implementation library.
141 // An LLNDK implementation is the core variant. LLNDK header libs are reexported by the vendor variant.
Colin Cross1e954b62024-09-13 13:50:00 -0700142 // The core variant cannot depend on the vendor variant because of the order of imageTransitionMutator.Split().
Hsin-Yi Chen715142a2024-03-27 16:31:16 +0800143 // Instead, the LLNDK implementation depends on the LLNDK header libs.
144 LlndkHeaderLibs []string
Colin Crossc472d572015-03-17 15:06:21 -0700145}
146
Ivan Lozano0a468a42024-05-13 21:03:34 -0400147// A struct which to collect flags for rlib dependencies
148type RustRlibDep struct {
149 LibPath android.Path // path to the rlib
150 LinkDirs []string // flags required for dependency (e.g. -L flags)
151 CrateName string // crateNames associated with rlibDeps
152}
153
154func EqRustRlibDeps(a RustRlibDep, b RustRlibDep) bool {
155 return a.LibPath == b.LibPath
156}
157
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500158// PathDeps is a struct containing file paths to dependencies of a module.
159// It's constructed in depsToPath() by traversing the direct dependencies of the current module.
160// It's used to construct flags for various build statements (such as for compiling and linking).
161// It is then passed to module decorator functions responsible for registering build statements
162// (such as `module.compiler.compile()`).`
Colin Crossca860ac2016-01-04 14:34:37 -0800163type PathDeps struct {
Colin Cross26c34ed2016-09-30 17:10:16 -0700164 // Paths to .so files
Jiyong Park64a44f22019-01-18 14:37:08 +0900165 SharedLibs, EarlySharedLibs, LateSharedLibs android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700166 // Paths to the dependencies to use for .so files (.so.toc files)
Jiyong Park64a44f22019-01-18 14:37:08 +0900167 SharedLibsDeps, EarlySharedLibsDeps, LateSharedLibsDeps android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700168 // Paths to .a files
Colin Cross635c3b02016-05-18 15:37:25 -0700169 StaticLibs, LateStaticLibs, WholeStaticLibs android.Paths
Ivan Lozano0a468a42024-05-13 21:03:34 -0400170 // Paths and crateNames for RustStaticLib dependencies
171 RustRlibDeps []RustRlibDep
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700172
Colin Cross0de8a1e2020-09-18 14:15:30 -0700173 // Transitive static library dependencies of static libraries for use in ordering.
Colin Crossa14fb6a2024-10-23 16:57:06 -0700174 TranstiveStaticLibrariesForOrdering depset.DepSet[android.Path]
Colin Cross0de8a1e2020-09-18 14:15:30 -0700175
Colin Cross26c34ed2016-09-30 17:10:16 -0700176 // Paths to .o files
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100177 Objs Objects
178 // Paths to .o files in dependencies that provide them. Note that these lists
179 // aren't complete since prebuilt modules don't provide the .o files.
Dan Willemsen581341d2017-02-09 16:16:31 -0800180 StaticLibObjs Objects
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700181 WholeStaticLibObjs Objects
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700182
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100183 // Paths to .a files in prebuilts. Complements WholeStaticLibObjs to contain
184 // the libs from all whole_static_lib dependencies.
185 WholeStaticLibsFromPrebuilts android.Paths
186
Colin Cross26c34ed2016-09-30 17:10:16 -0700187 // Paths to generated source files
Colin Cross635c3b02016-05-18 15:37:25 -0700188 GeneratedSources android.Paths
Inseob Kimd110f872019-12-06 13:15:38 +0900189 GeneratedDeps android.Paths
Dan Willemsenb40aab62016-04-20 14:21:14 -0700190
Inseob Kimd110f872019-12-06 13:15:38 +0900191 Flags []string
Colin Cross3e5e7782022-06-17 22:17:05 +0000192 LdFlags []string
Inseob Kimd110f872019-12-06 13:15:38 +0900193 IncludeDirs android.Paths
194 SystemIncludeDirs android.Paths
195 ReexportedDirs android.Paths
196 ReexportedSystemDirs android.Paths
197 ReexportedFlags []string
198 ReexportedGeneratedHeaders android.Paths
199 ReexportedDeps android.Paths
Ivan Lozano0a468a42024-05-13 21:03:34 -0400200 ReexportedRustRlibDeps []RustRlibDep
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700201
Colin Cross26c34ed2016-09-30 17:10:16 -0700202 // Paths to crt*.o files
Colin Crossc465efd2021-06-11 18:00:04 -0700203 CrtBegin, CrtEnd android.Paths
Dan Willemsena0790e32018-10-12 00:24:23 -0700204
Dan Willemsena0790e32018-10-12 00:24:23 -0700205 // Path to the dynamic linker binary
206 DynamicLinker android.OptionalPath
Dan Willemsen47450072021-10-19 20:24:49 -0700207
208 // For Darwin builds, the path to the second architecture's output that should
209 // be combined with this architectures's output into a FAT MachO file.
210 DarwinSecondArchOutput android.OptionalPath
Vinh Tran367d89d2023-04-28 11:21:25 -0400211
212 // Paths to direct srcs and transitive include dirs from direct aidl_library deps
213 AidlLibraryInfos []aidl_library.AidlLibraryInfo
Hsin-Yi Chen715142a2024-03-27 16:31:16 +0800214
215 // LLNDK headers for the ABI checker to check LLNDK implementation library.
216 LlndkIncludeDirs android.Paths
217 LlndkSystemIncludeDirs android.Paths
Colin Crossb614cd42024-10-11 12:52:21 -0700218
219 directImplementationDeps android.Paths
220 transitiveImplementationDeps []depset.DepSet[android.Path]
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700221}
222
Colin Cross4af21ed2019-11-04 09:37:55 -0800223// LocalOrGlobalFlags contains flags that need to have values set globally by the build system or locally by the module
224// tracked separately, in order to maintain the required ordering (most of the global flags need to go first on the
225// command line so they can be overridden by the local module flags).
226type LocalOrGlobalFlags struct {
227 CommonFlags []string // Flags that apply to C, C++, and assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700228 AsFlags []string // Flags that apply to assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800229 YasmFlags []string // Flags that apply to yasm assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700230 CFlags []string // Flags that apply to C and C++ source files
231 ToolingCFlags []string // Flags that apply to C and C++ source files parsed by clang LibTooling tools
232 ConlyFlags []string // Flags that apply to C source files
233 CppFlags []string // Flags that apply to C++ source files
234 ToolingCppFlags []string // Flags that apply to C++ source files parsed by clang LibTooling tools
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700235 LdFlags []string // Flags that apply to linker command lines
Colin Cross4af21ed2019-11-04 09:37:55 -0800236}
237
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500238// Flags contains various types of command line flags (and settings) for use in building build
239// statements related to C++.
Colin Cross4af21ed2019-11-04 09:37:55 -0800240type Flags struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500241 // Local flags (which individual modules are responsible for). These may override global flags.
242 Local LocalOrGlobalFlags
243 // Global flags (which build system or toolchain is responsible for).
Luis Useche342fa6b2024-04-01 19:33:18 -0700244 Global LocalOrGlobalFlags
245 NoOverrideFlags []string // Flags applied to the end of list of flags so they are not overridden
Colin Cross4af21ed2019-11-04 09:37:55 -0800246
247 aidlFlags []string // Flags that apply to aidl source files
248 rsFlags []string // Flags that apply to renderscript source files
249 libFlags []string // Flags to add libraries early to the link order
250 extraLibFlags []string // Flags to add libraries late in the link order after LdFlags
251 TidyFlags []string // Flags that apply to clang-tidy
252 SAbiFlags []string // Flags that apply to header-abi-dumper
Colin Cross28344522015-04-22 13:07:53 -0700253
Colin Crossc3199482017-03-30 15:03:04 -0700254 // Global include flags that apply to C, C++, and assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800255 // These must be after any module include flags, which will be in CommonFlags.
Colin Crossc3199482017-03-30 15:03:04 -0700256 SystemIncludeFlags []string
257
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800258 Toolchain config.Toolchain
259 Tidy bool // True if ninja .tidy rules should be generated.
260 NeedTidyFiles bool // True if module link should depend on .tidy files
261 GcovCoverage bool // True if coverage files should be generated.
262 SAbiDump bool // True if header abi dumps should be generated.
263 EmitXrefs bool // If true, generate Ninja rules to generate emitXrefs input files for Kythe
kellyhungd62ea302024-05-19 21:16:07 +0800264 ClangVerify bool // If true, append cflags "-Xclang -verify" and append "&& touch $out" to the clang command line.
Colin Crossca860ac2016-01-04 14:34:37 -0800265
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500266 // The instruction set required for clang ("arm" or "thumb").
Colin Crossca860ac2016-01-04 14:34:37 -0800267 RequiredInstructionSet string
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500268 // The target-device system path to the dynamic linker.
269 DynamicLinker string
Colin Cross16b23492016-01-06 14:41:07 -0800270
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700271 CFlagsDeps android.Paths // Files depended on by compiler flags
272 LdFlagsDeps android.Paths // Files depended on by linker flags
Colin Cross18c0c5a2016-12-01 14:45:23 -0800273
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500274 // True if .s files should be processed with the c preprocessor.
Dan Willemsen98ab3112019-08-27 21:20:40 -0700275 AssemblerWithCpp bool
Dan Willemsen60e62f02018-11-16 21:05:32 -0800276
Colin Cross19878da2019-03-28 14:45:07 -0700277 proto android.ProtoFlags
Colin Cross19878da2019-03-28 14:45:07 -0700278 protoC bool // Whether to use C instead of C++
279 protoOptionsFile bool // Whether to look for a .options file next to the .proto
Dan Willemsen4e0aa232019-04-10 22:59:54 -0700280
281 Yacc *YaccProperties
Matthias Maennich22fd4d12020-07-15 10:58:56 +0200282 Lex *LexProperties
Colin Crossc472d572015-03-17 15:06:21 -0700283}
284
Colin Crossca860ac2016-01-04 14:34:37 -0800285// Properties used to compile all C or C++ modules
286type BaseProperties struct {
Dan Willemsen742a5452018-07-23 17:19:36 -0700287 // Deprecated. true is the default, false is invalid.
Colin Crossca860ac2016-01-04 14:34:37 -0800288 Clang *bool `android:"arch_variant"`
Colin Cross7d5136f2015-05-11 13:39:40 -0700289
Yi Kong5786f5c2024-05-28 02:22:34 +0900290 // Aggresively trade performance for smaller binary size.
291 // This should only be used for on-device binaries that are rarely executed and not
292 // performance critical.
293 Optimize_for_size *bool `android:"arch_variant"`
294
Jiyong Parkb35a8192020-08-10 15:59:36 +0900295 // The API level that this module is built against. The APIs of this API level will be
296 // visible at build time, but use of any APIs newer than min_sdk_version will render the
297 // module unloadable on older devices. In the future it will be possible to weakly-link new
298 // APIs, making the behavior match Java: such modules will load on older devices, but
299 // calling new APIs on devices that do not support them will result in a crash.
300 //
301 // This property has the same behavior as sdk_version does for Java modules. For those
302 // familiar with Android Gradle, the property behaves similarly to how compileSdkVersion
303 // does for Java code.
304 //
305 // In addition, setting this property causes two variants to be built, one for the platform
306 // and one for apps.
Nan Zhang0007d812017-11-07 10:57:05 -0800307 Sdk_version *string
Colin Cross7d5136f2015-05-11 13:39:40 -0700308
Jiyong Parkb35a8192020-08-10 15:59:36 +0900309 // Minimum OS API level supported by this C or C++ module. This property becomes the value
310 // of the __ANDROID_API__ macro. When the C or C++ module is included in an APEX or an APK,
311 // this property is also used to ensure that the min_sdk_version of the containing module is
312 // not older (i.e. less) than this module's min_sdk_version. When not set, this property
313 // defaults to the value of sdk_version. When this is set to "apex_inherit", this tracks
314 // min_sdk_version of the containing APEX. When the module
315 // is not built for an APEX, "apex_inherit" defaults to sdk_version.
Jooyung Han379660c2020-04-21 15:24:00 +0900316 Min_sdk_version *string
317
Colin Crossc511bc52020-04-07 16:50:32 +0000318 // If true, always create an sdk variant and don't create a platform variant.
319 Sdk_variant_only *bool
320
Jiyong Parkde866cb2018-12-07 23:08:36 +0900321 AndroidMkSharedLibs []string `blueprint:"mutated"`
322 AndroidMkStaticLibs []string `blueprint:"mutated"`
Ivan Lozano0a468a42024-05-13 21:03:34 -0400323 AndroidMkRlibs []string `blueprint:"mutated"`
Jiyong Parkde866cb2018-12-07 23:08:36 +0900324 AndroidMkRuntimeLibs []string `blueprint:"mutated"`
325 AndroidMkWholeStaticLibs []string `blueprint:"mutated"`
Bill Peckhama46de702020-04-21 17:23:37 -0700326 AndroidMkHeaderLibs []string `blueprint:"mutated"`
Jiyong Parkde866cb2018-12-07 23:08:36 +0900327 HideFromMake bool `blueprint:"mutated"`
328 PreventInstall bool `blueprint:"mutated"`
329 ApexesProvidingSharedLibs []string `blueprint:"mutated"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700330
Yo Chiang219968c2020-09-22 18:45:04 +0800331 // Set by DepsMutator.
332 AndroidMkSystemSharedLibs []string `blueprint:"mutated"`
333
Kiyoung Kimb5fdb2e2024-01-03 14:24:34 +0900334 // The name of the image this module is built for
335 ImageVariation string `blueprint:"mutated"`
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200336
337 // The VNDK version this module is built against. If empty, the module is not
338 // build against the VNDK.
339 VndkVersion string `blueprint:"mutated"`
340
341 // Suffix for the name of Android.mk entries generated by this module
342 SubName string `blueprint:"mutated"`
Colin Cross5beccee2017-12-07 15:28:59 -0800343
344 // *.logtags files, to combine together in order to generate the /system/etc/event-log-tags
345 // file
Inseob Kim37e0bb02024-04-29 15:54:44 +0900346 Logtags []string `android:"path"`
Jiyong Parkf9332f12018-02-01 00:54:12 +0900347
Yifan Hong39143a92020-10-26 12:43:12 -0700348 // Make this module available when building for ramdisk.
349 // On device without a dedicated recovery partition, the module is only
350 // available after switching root into
351 // /first_stage_ramdisk. To expose the module before switching root, install
352 // the recovery variant instead.
Yifan Hong1b3348d2020-01-21 15:53:22 -0800353 Ramdisk_available *bool
354
Yifan Hong39143a92020-10-26 12:43:12 -0700355 // Make this module available when building for vendor ramdisk.
356 // On device without a dedicated recovery partition, the module is only
357 // available after switching root into
358 // /first_stage_ramdisk. To expose the module before switching root, install
359 // the recovery variant instead.
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700360 Vendor_ramdisk_available *bool
361
Jiyong Parkf9332f12018-02-01 00:54:12 +0900362 // Make this module available when building for recovery
363 Recovery_available *bool
364
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200365 // Used by imageMutator, set by ImageMutatorBegin()
Jihoon Kang47e91842024-06-19 00:51:16 +0000366 VendorVariantNeeded bool `blueprint:"mutated"`
367 ProductVariantNeeded bool `blueprint:"mutated"`
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200368 CoreVariantNeeded bool `blueprint:"mutated"`
369 RamdiskVariantNeeded bool `blueprint:"mutated"`
370 VendorRamdiskVariantNeeded bool `blueprint:"mutated"`
371 RecoveryVariantNeeded bool `blueprint:"mutated"`
372
373 // A list of variations for the "image" mutator of the form
374 //<image name> '.' <version char>, for example, 'vendor.S'
375 ExtraVersionedImageVariations []string `blueprint:"mutated"`
Jiyong Parkb0788572018-12-20 22:10:17 +0900376
377 // Allows this module to use non-APEX version of libraries. Useful
378 // for building binaries that are started before APEXes are activated.
379 Bootstrap *bool
Jooyung Han097087b2019-10-22 19:32:18 +0900380
Hao Chen1c8ea5b2023-10-20 23:03:45 +0000381 // Allows this module to be included in CMake release snapshots to be built outside of Android
382 // build system and source tree.
383 Cmake_snapshot_supported *bool
384
Colin Cross1bc94122021-10-28 13:25:54 -0700385 Installable *bool `android:"arch_variant"`
Colin Crossc511bc52020-04-07 16:50:32 +0000386
387 // Set by factories of module types that can only be referenced from variants compiled against
388 // the SDK.
389 AlwaysSdk bool `blueprint:"mutated"`
390
391 // Variant is an SDK variant created by sdkMutator
392 IsSdkVariant bool `blueprint:"mutated"`
393 // Set when both SDK and platform variants are exported to Make to trigger renaming the SDK
394 // variant to have a ".sdk" suffix.
395 SdkAndPlatformVariantVisibleToMake bool `blueprint:"mutated"`
Bill Peckham945441c2020-08-31 16:07:58 -0700396
Jiyong Park46a512f2020-12-04 18:02:13 +0900397 // List of APEXes that this module has private access to for testing purpose. The module
398 // can depend on libraries that are not exported by the APEXes and use private symbols
399 // from the exported libraries.
Martin Stjernholm855e90b2021-03-25 02:33:14 +0000400 Test_for []string `android:"arch_variant"`
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800401
402 Target struct {
403 Platform struct {
404 // List of modules required by the core variant.
405 Required []string `android:"arch_variant"`
406
407 // List of modules not required by the core variant.
408 Exclude_required []string `android:"arch_variant"`
409 } `android:"arch_variant"`
410
411 Recovery struct {
412 // List of modules required by the recovery variant.
413 Required []string `android:"arch_variant"`
414
415 // List of modules not required by the recovery variant.
416 Exclude_required []string `android:"arch_variant"`
417 } `android:"arch_variant"`
418 } `android:"arch_variant"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700419}
420
421type VendorProperties struct {
Jiyong Park82e2bf32017-08-16 14:05:54 +0900422 // whether this module should be allowed to be directly depended by other
423 // modules with `vendor: true`, `proprietary: true`, or `vendor_available:true`.
Justin Yun63e9ec72020-10-29 16:49:43 +0900424 // If set to true, two variants will be built separately, one like
425 // normal, and the other limited to the set of libraries and headers
426 // that are exposed to /vendor modules.
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700427 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900428 // The vendor variant may be used with a different (newer) /system,
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700429 // so it shouldn't have any unversioned runtime dependencies, or
430 // make assumptions about the system that may not be true in the
431 // future.
432 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900433 // If set to false, this module becomes inaccessible from /vendor modules.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900434 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900435 // The modules with vndk: {enabled: true} must define 'vendor_available'
Justin Yun0b1db6d2021-01-08 15:22:34 +0900436 // to 'true'.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900437 //
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700438 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
439 Vendor_available *bool
Jiyong Park5fb8c102018-04-09 12:03:06 +0900440
Justin Yunebcf0c52021-01-08 18:00:19 +0900441 // This is the same as the "vendor_available" except that the install path
442 // of the vendor variant is /odm or /vendor/odm.
443 // By replacing "vendor_available: true" with "odm_available: true", the
444 // module will install its vendor variant to the /odm partition or /vendor/odm.
445 // As the modules with "odm_available: true" still create the vendor variants,
446 // they can link to the other vendor modules as the vendor_available modules do.
447 // Also, the vendor modules can link to odm_available modules.
448 //
449 // It may not be used for VNDK modules.
450 Odm_available *bool
451
Justin Yun63e9ec72020-10-29 16:49:43 +0900452 // whether this module should be allowed to be directly depended by other
453 // modules with `product_specific: true` or `product_available: true`.
454 // If set to true, an additional product variant will be built separately
455 // that is limited to the set of libraries and headers that are exposed to
456 // /product modules.
457 //
458 // The product variant may be used with a different (newer) /system,
459 // so it shouldn't have any unversioned runtime dependencies, or
460 // make assumptions about the system that may not be true in the
461 // future.
462 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900463 // If set to false, this module becomes inaccessible from /product modules.
464 //
465 // Different from the 'vendor_available' property, the modules with
466 // vndk: {enabled: true} don't have to define 'product_available'. The VNDK
467 // library without 'product_available' may not be depended on by any other
468 // modules that has product variants including the product available VNDKs.
Justin Yun63e9ec72020-10-29 16:49:43 +0900469 //
470 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
471 // and PRODUCT_PRODUCT_VNDK_VERSION isn't set.
472 Product_available *bool
473
Jiyong Park5fb8c102018-04-09 12:03:06 +0900474 // whether this module is capable of being loaded with other instance
475 // (possibly an older version) of the same module in the same process.
476 // Currently, a shared library that is a member of VNDK (vndk: {enabled: true})
477 // can be double loaded in a vendor process if the library is also a
478 // (direct and indirect) dependency of an LLNDK library. Such libraries must be
479 // explicitly marked as `double_loadable: true` by the owner, or the dependency
480 // from the LLNDK lib should be cut if the lib is not designed to be double loaded.
481 Double_loadable *bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800482
483 // IsLLNDK is set to true for the vendor variant of a cc_library module that has LLNDK stubs.
484 IsLLNDK bool `blueprint:"mutated"`
485
Colin Cross5271fea2021-04-27 13:06:04 -0700486 // IsVendorPublicLibrary is set for the core and product variants of a library that has
487 // vendor_public_library stubs.
488 IsVendorPublicLibrary bool `blueprint:"mutated"`
Colin Crossca860ac2016-01-04 14:34:37 -0800489}
490
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500491// ModuleContextIntf is an interface (on a module context helper) consisting of functions related
492// to understanding details about the type of the current module.
493// For example, one might call these functions to determine whether the current module is a static
494// library and/or is installed in vendor directories.
Colin Crossca860ac2016-01-04 14:34:37 -0800495type ModuleContextIntf interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800496 static() bool
497 staticBinary() bool
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -0700498 testBinary() bool
Yi Kong56fc1b62022-09-06 16:24:00 +0800499 testLibrary() bool
Jiyong Park1d1119f2019-07-29 21:27:18 +0900500 header() bool
Inseob Kim7f283f42020-06-01 21:53:49 +0900501 binary() bool
Inseob Kim1042d292020-06-01 23:23:05 +0900502 object() bool
Colin Crossb98c8b02016-07-29 13:44:28 -0700503 toolchain() config.Toolchain
Jooyung Hanccce2f22020-03-07 03:45:53 +0900504 canUseSdk() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700505 useSdk() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800506 sdkVersion() string
Jiyong Parkb35a8192020-08-10 15:59:36 +0900507 minSdkVersion() string
508 isSdkVariant() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700509 useVndk() bool
Colin Cross95f1ca02020-10-29 20:47:22 -0700510 isNdk(config android.Config) bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800511 IsLlndk() bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800512 isImplementationForLLNDKPublic() bool
Colin Cross5271fea2021-04-27 13:06:04 -0700513 IsVendorPublicLibrary() bool
Justin Yun5f7f7e82019-11-18 19:52:14 +0900514 inProduct() bool
515 inVendor() bool
Yifan Hong1b3348d2020-01-21 15:53:22 -0800516 inRamdisk() bool
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700517 inVendorRamdisk() bool
Jiyong Parkf9332f12018-02-01 00:54:12 +0900518 inRecovery() bool
Kiyoung Kimaa394802024-01-08 12:55:45 +0900519 InVendorOrProduct() bool
Dan Willemsen8146b2f2016-03-30 21:00:30 -0700520 selectedStl() string
Colin Crossce75d2c2016-10-06 16:12:58 -0700521 baseModuleName() string
Colin Cross3513fb12024-01-24 14:44:47 -0800522 isAfdoCompile(ctx ModuleContext) bool
Sharjeel Khanc6a93d82023-07-18 21:01:11 +0000523 isOrderfileCompile() bool
Yi Kongc702ebd2022-08-19 16:02:45 +0800524 isCfi() bool
Yi Konged79fa32023-06-04 17:15:42 +0900525 isFuzzer() bool
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800526 isNDKStubLibrary() bool
Ivan Lozanobd721262018-11-27 14:33:03 -0800527 useClangLld(actx ModuleContext) bool
Logan Chiene274fc92019-12-03 11:18:32 -0800528 isForPlatform() bool
Colin Crosse07f2312020-08-13 11:24:56 -0700529 apexVariationName() string
Dan Albertc8060532020-07-22 22:32:17 -0700530 apexSdkVersion() android.ApiLevel
Jiyong Parka4b9dd02019-01-16 22:53:13 +0900531 bootstrap() bool
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700532 nativeCoverage() bool
Colin Cross56a83212020-09-15 18:30:11 -0700533 directlyInAnyApex() bool
Colin Cross95b07f22020-12-16 11:06:50 -0800534 isPreventInstall() bool
Cindy Zhou5d5cfc12021-01-09 08:25:22 -0800535 isCfiAssemblySupportEnabled() bool
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800536 getSharedFlags() *SharedFlags
Colin Cross4a9e6ec2023-12-18 15:29:41 -0800537 notInPlatform() bool
Yi Kong5786f5c2024-05-28 02:22:34 +0900538 optimizeForSize() bool
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800539}
540
541type SharedFlags struct {
542 numSharedFlags int
543 flagsMap map[string]string
Colin Crossca860ac2016-01-04 14:34:37 -0800544}
545
546type ModuleContext interface {
Colin Cross635c3b02016-05-18 15:37:25 -0700547 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800548 ModuleContextIntf
549}
550
551type BaseModuleContext interface {
Colin Cross0ea8ba82019-06-06 14:33:29 -0700552 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800553 ModuleContextIntf
554}
555
Colin Cross37047f12016-12-13 17:06:13 -0800556type DepsContext interface {
557 android.BottomUpMutatorContext
558 ModuleContextIntf
559}
560
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500561// feature represents additional (optional) steps to building cc-related modules, such as invocation
562// of clang-tidy.
Colin Crossca860ac2016-01-04 14:34:37 -0800563type feature interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800564 flags(ctx ModuleContext, flags Flags) Flags
565 props() []interface{}
566}
567
Joe Onorato37f900c2023-07-18 16:58:16 -0700568// Information returned from Generator about the source code it's generating
569type GeneratedSource struct {
570 IncludeDirs android.Paths
571 Sources android.Paths
572 Headers android.Paths
573 ReexportedDirs android.Paths
574}
575
576// generator allows injection of generated code
577type Generator interface {
578 GeneratorProps() []interface{}
579 GeneratorInit(ctx BaseModuleContext)
580 GeneratorDeps(ctx DepsContext, deps Deps) Deps
581 GeneratorFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
582 GeneratorSources(ctx ModuleContext) GeneratedSource
583 GeneratorBuildActions(ctx ModuleContext, flags Flags, deps PathDeps)
584}
585
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500586// compiler is the interface for a compiler helper object. Different module decorators may implement
Liz Kammer718eb272022-01-07 10:53:37 -0500587// this helper differently.
Colin Crossca860ac2016-01-04 14:34:37 -0800588type compiler interface {
Colin Cross42742b82016-08-01 13:20:05 -0700589 compilerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800590 compilerDeps(ctx DepsContext, deps Deps) Deps
Colin Crossf18e1102017-11-16 14:33:08 -0800591 compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
Colin Cross42742b82016-08-01 13:20:05 -0700592 compilerProps() []interface{}
Hao Chen1c8ea5b2023-10-20 23:03:45 +0000593 baseCompilerProps() BaseCompilerProperties
Colin Cross42742b82016-08-01 13:20:05 -0700594
Colin Cross76fada02016-07-27 10:31:13 -0700595 appendCflags([]string)
596 appendAsflags([]string)
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700597 compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects
Colin Crossca860ac2016-01-04 14:34:37 -0800598}
599
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500600// linker is the interface for a linker decorator object. Individual module types can provide
601// their own implementation for this decorator, and thus specify custom logic regarding build
602// statements pertaining to linking.
Colin Crossca860ac2016-01-04 14:34:37 -0800603type linker interface {
Colin Cross42742b82016-08-01 13:20:05 -0700604 linkerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800605 linkerDeps(ctx DepsContext, deps Deps) Deps
Colin Cross42742b82016-08-01 13:20:05 -0700606 linkerFlags(ctx ModuleContext, flags Flags) Flags
607 linkerProps() []interface{}
Hao Chen1c8ea5b2023-10-20 23:03:45 +0000608 baseLinkerProps() BaseLinkerProperties
Ivan Lozanobd721262018-11-27 14:33:03 -0800609 useClangLld(actx ModuleContext) bool
Colin Cross42742b82016-08-01 13:20:05 -0700610
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700611 link(ctx ModuleContext, flags Flags, deps PathDeps, objs Objects) android.Path
Colin Cross76fada02016-07-27 10:31:13 -0700612 appendLdflags([]string)
Jiyong Parkaf6d8952019-01-31 12:21:23 +0900613 unstrippedOutputFilePath() android.Path
Wei Li5f5d2712023-12-11 15:40:29 -0800614 strippedAllOutputFilePath() android.Path
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700615
616 nativeCoverage() bool
Jiyong Parkee9a98d2019-08-09 14:44:36 +0900617 coverageOutputFilePath() android.OptionalPath
Paul Duffin13f02712020-03-06 12:30:43 +0000618
619 // Get the deps that have been explicitly specified in the properties.
Cole Fauste8a87832024-09-11 11:35:46 -0700620 linkerSpecifiedDeps(ctx android.ConfigurableEvaluatorContext, module *Module, specifiedDeps specifiedDeps) specifiedDeps
Colin Cross4a9e6ec2023-12-18 15:29:41 -0800621
622 moduleInfoJSON(ctx ModuleContext, moduleInfoJSON *android.ModuleInfoJSON)
Paul Duffin13f02712020-03-06 12:30:43 +0000623}
624
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500625// specifiedDeps is a tuple struct representing dependencies of a linked binary owned by the linker.
Paul Duffin13f02712020-03-06 12:30:43 +0000626type specifiedDeps struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500627 sharedLibs []string
628 // Note nil and [] are semantically distinct. [] prevents linking against the defaults (usually
629 // libc, libm, etc.)
Colin Cross6b8f4252021-07-22 11:39:44 -0700630 systemSharedLibs []string
Colin Crossca860ac2016-01-04 14:34:37 -0800631}
632
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500633// installer is the interface for an installer helper object. This helper is responsible for
634// copying build outputs to the appropriate locations so that they may be installed on device.
Colin Crossca860ac2016-01-04 14:34:37 -0800635type installer interface {
Colin Cross42742b82016-08-01 13:20:05 -0700636 installerProps() []interface{}
Colin Cross635c3b02016-05-18 15:37:25 -0700637 install(ctx ModuleContext, path android.Path)
Paul Duffin0cb37b92020-03-04 14:52:46 +0000638 everInstallable() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800639 inData() bool
Vishwath Mohan1dd88392017-03-29 22:00:18 -0700640 inSanitizerDir() bool
Dan Willemsen4aa75ca2016-09-28 16:18:03 -0700641 hostToolPath() android.OptionalPath
Jiyong Parkb7c24df2019-02-01 12:03:59 +0900642 relativeInstallPath() string
Jingwen Chen8ac7d7d2023-03-20 11:05:16 +0000643 makeUninstallable(mod *Module)
Inseob Kim800d1142021-06-14 12:03:51 +0900644 installInRoot() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800645}
646
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800647type xref interface {
648 XrefCcFiles() android.Paths
649}
650
Inseob Kima1888ce2022-10-04 14:42:02 +0900651type overridable interface {
652 overriddenModules() []string
653}
654
Colin Cross6e511a92020-07-27 21:26:48 -0700655type libraryDependencyKind int
656
657const (
658 headerLibraryDependency = iota
659 sharedLibraryDependency
660 staticLibraryDependency
Ivan Lozano0a468a42024-05-13 21:03:34 -0400661 rlibLibraryDependency
Colin Cross6e511a92020-07-27 21:26:48 -0700662)
663
664func (k libraryDependencyKind) String() string {
665 switch k {
666 case headerLibraryDependency:
667 return "headerLibraryDependency"
668 case sharedLibraryDependency:
669 return "sharedLibraryDependency"
670 case staticLibraryDependency:
671 return "staticLibraryDependency"
Ivan Lozano0a468a42024-05-13 21:03:34 -0400672 case rlibLibraryDependency:
673 return "rlibLibraryDependency"
Colin Cross6e511a92020-07-27 21:26:48 -0700674 default:
675 panic(fmt.Errorf("unknown libraryDependencyKind %d", k))
676 }
677}
678
679type libraryDependencyOrder int
680
681const (
682 earlyLibraryDependency = -1
683 normalLibraryDependency = 0
684 lateLibraryDependency = 1
685)
686
687func (o libraryDependencyOrder) String() string {
688 switch o {
689 case earlyLibraryDependency:
690 return "earlyLibraryDependency"
691 case normalLibraryDependency:
692 return "normalLibraryDependency"
693 case lateLibraryDependency:
694 return "lateLibraryDependency"
695 default:
696 panic(fmt.Errorf("unknown libraryDependencyOrder %d", o))
697 }
698}
699
700// libraryDependencyTag is used to tag dependencies on libraries. Unlike many dependency
701// tags that have a set of predefined tag objects that are reused for each dependency, a
702// libraryDependencyTag is designed to contain extra metadata and is constructed as needed.
703// That means that comparing a libraryDependencyTag for equality will only be equal if all
704// of the metadata is equal. Most usages will want to type assert to libraryDependencyTag and
705// then check individual metadata fields instead.
706type libraryDependencyTag struct {
707 blueprint.BaseDependencyTag
708
709 // These are exported so that fmt.Printf("%#v") can call their String methods.
710 Kind libraryDependencyKind
711 Order libraryDependencyOrder
712
713 wholeStatic bool
714
715 reexportFlags bool
716 explicitlyVersioned bool
717 dataLib bool
718 ndk bool
719
720 staticUnwinder bool
721
722 makeSuffix string
Jiyong Parke3867542020-12-03 17:28:25 +0900723
Cindy Zhou18417cb2020-12-10 07:12:38 -0800724 // Whether or not this dependency should skip the apex dependency check
725 skipApexAllowedDependenciesCheck bool
726
Jiyong Parke3867542020-12-03 17:28:25 +0900727 // Whether or not this dependency has to be followed for the apex variants
728 excludeInApex bool
Jooyung Han9ffbe832023-11-28 22:31:35 +0900729 // Whether or not this dependency has to be followed for the non-apex variants
730 excludeInNonApex bool
Colin Cross3e5e7782022-06-17 22:17:05 +0000731
732 // If true, don't automatically export symbols from the static library into a shared library.
733 unexportedSymbols bool
Colin Cross6e511a92020-07-27 21:26:48 -0700734}
735
736// header returns true if the libraryDependencyTag is tagging a header lib dependency.
737func (d libraryDependencyTag) header() bool {
738 return d.Kind == headerLibraryDependency
739}
740
741// shared returns true if the libraryDependencyTag is tagging a shared lib dependency.
742func (d libraryDependencyTag) shared() bool {
743 return d.Kind == sharedLibraryDependency
744}
745
746// shared returns true if the libraryDependencyTag is tagging a static lib dependency.
747func (d libraryDependencyTag) static() bool {
748 return d.Kind == staticLibraryDependency
749}
750
Colin Cross65cb3142021-12-10 23:05:02 +0000751func (d libraryDependencyTag) LicenseAnnotations() []android.LicenseAnnotation {
752 if d.shared() {
753 return []android.LicenseAnnotation{android.LicenseAnnotationSharedDependency}
754 }
755 return nil
756}
757
758var _ android.LicenseAnnotationsDependencyTag = libraryDependencyTag{}
759
Colin Crosse9fe2942020-11-10 18:12:15 -0800760// InstallDepNeeded returns true for shared libraries so that shared library dependencies of
761// binaries or other shared libraries are installed as dependencies.
762func (d libraryDependencyTag) InstallDepNeeded() bool {
763 return d.shared()
764}
765
766var _ android.InstallNeededDependencyTag = libraryDependencyTag{}
767
Yu Liu67a28422024-03-05 00:36:31 +0000768func (d libraryDependencyTag) PropagateAconfigValidation() bool {
769 return d.static()
770}
771
772var _ android.PropagateAconfigValidationDependencyTag = libraryDependencyTag{}
773
Colin Crosse9fe2942020-11-10 18:12:15 -0800774// dependencyTag is used for tagging miscellaneous dependency types that don't fit into
Colin Cross6e511a92020-07-27 21:26:48 -0700775// libraryDependencyTag. Each tag object is created globally and reused for multiple
776// dependencies (although since the object contains no references, assigning a tag to a
777// variable and modifying it will not modify the original). Users can compare the tag
778// returned by ctx.OtherModuleDependencyTag against the global original
779type dependencyTag struct {
780 blueprint.BaseDependencyTag
781 name string
782}
783
Colin Crosse9fe2942020-11-10 18:12:15 -0800784// installDependencyTag is used for tagging miscellaneous dependency types that don't fit into
785// libraryDependencyTag, but where the dependency needs to be installed when the parent is
786// installed.
787type installDependencyTag struct {
788 blueprint.BaseDependencyTag
789 android.InstallAlwaysNeededDependencyTag
790 name string
791}
792
Colin Crossc99deeb2016-04-11 15:06:20 -0700793var (
Colin Cross6e511a92020-07-27 21:26:48 -0700794 genSourceDepTag = dependencyTag{name: "gen source"}
795 genHeaderDepTag = dependencyTag{name: "gen header"}
796 genHeaderExportDepTag = dependencyTag{name: "gen header export"}
797 objDepTag = dependencyTag{name: "obj"}
Jiyong Parkd630bdd2020-11-25 11:47:24 +0900798 dynamicLinkerDepTag = installDependencyTag{name: "dynamic linker"}
Colin Cross6e511a92020-07-27 21:26:48 -0700799 reuseObjTag = dependencyTag{name: "reuse objects"}
800 staticVariantTag = dependencyTag{name: "static variant"}
801 vndkExtDepTag = dependencyTag{name: "vndk extends"}
802 dataLibDepTag = dependencyTag{name: "data lib"}
Colin Crossc8caa062021-09-24 16:50:14 -0700803 dataBinDepTag = dependencyTag{name: "data bin"}
Colin Crosse9fe2942020-11-10 18:12:15 -0800804 runtimeDepTag = installDependencyTag{name: "runtime lib"}
Colin Cross0de8a1e2020-09-18 14:15:30 -0700805 stubImplDepTag = dependencyTag{name: "stub_impl"}
Muhammad Haseeb Ahmad7e744052022-03-25 22:50:53 +0000806 JniFuzzLibTag = dependencyTag{name: "jni_fuzz_lib_tag"}
Vinh Tran44cb78c2023-03-09 22:07:19 -0500807 FdoProfileTag = dependencyTag{name: "fdo_profile"}
Vinh Tran367d89d2023-04-28 11:21:25 -0400808 aidlLibraryTag = dependencyTag{name: "aidl_library"}
Hsin-Yi Chen715142a2024-03-27 16:31:16 +0800809 llndkHeaderLibTag = dependencyTag{name: "llndk_header_lib"}
Colin Crossc99deeb2016-04-11 15:06:20 -0700810)
811
Roland Levillainf89cd092019-07-29 16:22:59 +0100812func IsSharedDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700813 ccLibDepTag, ok := depTag.(libraryDependencyTag)
814 return ok && ccLibDepTag.shared()
815}
816
817func IsStaticDepTag(depTag blueprint.DependencyTag) bool {
818 ccLibDepTag, ok := depTag.(libraryDependencyTag)
819 return ok && ccLibDepTag.static()
Roland Levillainf89cd092019-07-29 16:22:59 +0100820}
821
Zach Johnson3df4e632020-11-06 11:56:27 -0800822func IsHeaderDepTag(depTag blueprint.DependencyTag) bool {
823 ccLibDepTag, ok := depTag.(libraryDependencyTag)
824 return ok && ccLibDepTag.header()
825}
826
Roland Levillainf89cd092019-07-29 16:22:59 +0100827func IsRuntimeDepTag(depTag blueprint.DependencyTag) bool {
Colin Crosse9fe2942020-11-10 18:12:15 -0800828 return depTag == runtimeDepTag
Roland Levillainf89cd092019-07-29 16:22:59 +0100829}
830
Colin Crossca860ac2016-01-04 14:34:37 -0800831// Module contains the properties and members used by all C/C++ module types, and implements
832// the blueprint.Module interface. It delegates to compiler, linker, and installer interfaces
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500833// to construct the output file. Behavior can be customized with a Customizer, or "decorator",
834// interface.
835//
836// To define a C/C++ related module, construct a new Module object and point its delegates to
837// type-specific structs. These delegates will be invoked to register module-specific build
838// statements which may be unique to the module type. For example, module.compiler.compile() should
839// be defined so as to register build statements which are responsible for compiling the module.
840//
841// Another example: to construct a cc_binary module, one can create a `cc.binaryDecorator` struct
842// which implements the `linker` and `installer` interfaces, and points the `linker` and `installer`
843// members of the cc.Module to this decorator. Thus, a cc_binary module has custom linker and
844// installer logic.
Colin Crossca860ac2016-01-04 14:34:37 -0800845type Module struct {
hamzehc0a671f2021-07-22 12:05:08 -0700846 fuzz.FuzzModule
hamzeh41ad8812021-07-07 14:00:07 -0700847
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700848 VendorProperties VendorProperties
hamzeh41ad8812021-07-07 14:00:07 -0700849 Properties BaseProperties
Ronald Braunsteina115e262024-04-09 18:07:38 -0700850 sourceProperties android.SourceProperties
Colin Crossfa138792015-04-24 17:31:52 -0700851
Colin Crossca860ac2016-01-04 14:34:37 -0800852 // initialize before calling Init
Aditya Choudhary87b2ab22023-11-17 15:27:06 +0000853 hod android.HostOrDeviceSupported
854 multilib android.Multilib
Aditya Choudhary87b2ab22023-11-17 15:27:06 +0000855 testModule bool
Colin Crossc472d572015-03-17 15:06:21 -0700856
Paul Duffina0843f62019-12-13 19:50:38 +0000857 // Allowable SdkMemberTypes of this module type.
858 sdkMemberTypes []android.SdkMemberType
859
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500860 // decorator delegates, initialize before calling Init
861 // these may contain module-specific implementations, and effectively allow for custom
862 // type-specific logic. These members may reference different objects or the same object.
863 // Functions of these decorators will be invoked to initialize and register type-specific
864 // build statements.
Colin Cross8ff10582023-12-07 13:10:56 -0800865 generators []Generator
866 compiler compiler
867 linker linker
868 installer installer
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500869
Spandan Dase12d2522023-09-12 21:42:31 +0000870 features []feature
871 stl *stl
872 sanitize *sanitize
873 coverage *coverage
874 fuzzer *fuzzer
875 sabi *sabi
Spandan Dase12d2522023-09-12 21:42:31 +0000876 lto *lto
877 afdo *afdo
Sharjeel Khanc6a93d82023-07-18 21:01:11 +0000878 orderfile *orderfile
Colin Cross16b23492016-01-06 14:41:07 -0800879
Colin Cross31076b32020-10-23 17:22:06 -0700880 library libraryInterface
881
Colin Cross635c3b02016-05-18 15:37:25 -0700882 outputFile android.OptionalPath
Colin Crossca860ac2016-01-04 14:34:37 -0800883
Colin Crossb98c8b02016-07-29 13:44:28 -0700884 cachedToolchain config.Toolchain
Colin Crossb916a382016-07-29 17:28:03 -0700885
Yu Liue70976d2024-10-15 20:45:35 +0000886 subAndroidMkOnce map[subAndroidMkProviderInfoProducer]bool
Fabien Sanglardd61f1f42017-01-10 16:21:22 -0800887
888 // Flags used to compile this module
889 flags Flags
Jeff Gaston294356f2017-09-27 17:05:30 -0700890
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800891 // Shared flags among build rules of this module
892 sharedFlags SharedFlags
893
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800894 // only non-nil when this is a shared library that reuses the objects of a static library
Colin Cross0de8a1e2020-09-18 14:15:30 -0700895 staticAnalogue *StaticLibraryInfo
Inseob Kim9516ee92019-05-09 10:56:13 +0900896
897 makeLinkType string
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800898 // Kythe (source file indexer) paths for this compilation module
899 kytheFiles android.Paths
Chih-Hung Hsieh80783772021-10-11 16:46:56 -0700900 // Object .o file output paths for this compilation module
901 objFiles android.Paths
902 // Tidy .tidy file output paths for this compilation module
903 tidyFiles android.Paths
Jooyung Han75568392020-03-20 04:29:24 +0900904
905 // For apex variants, this is set as apex.min_sdk_version
Dan Albertc8060532020-07-22 22:32:17 -0700906 apexSdkVersion android.ApiLevel
Colin Cross56a83212020-09-15 18:30:11 -0700907
908 hideApexVariantFromMake bool
Yu Liueae7b362023-11-16 17:05:47 -0800909
Inseob Kim37e0bb02024-04-29 15:54:44 +0900910 logtagsPaths android.Paths
Ivan Lozanofd47b1a2024-05-17 14:13:41 -0400911
912 WholeRustStaticlib bool
Cole Faust96a692b2024-08-08 14:47:51 -0700913
914 hasAidl bool
915 hasLex bool
916 hasProto bool
917 hasRenderscript bool
918 hasSysprop bool
919 hasWinMsg bool
920 hasYacc bool
Colin Crossc472d572015-03-17 15:06:21 -0700921}
922
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200923func (c *Module) AddJSONData(d *map[string]interface{}) {
924 c.AndroidModuleBase().AddJSONData(d)
925 (*d)["Cc"] = map[string]interface{}{
926 "SdkVersion": c.SdkVersion(),
927 "MinSdkVersion": c.MinSdkVersion(),
928 "VndkVersion": c.VndkVersion(),
929 "ProductSpecific": c.ProductSpecific(),
930 "SocSpecific": c.SocSpecific(),
931 "DeviceSpecific": c.DeviceSpecific(),
932 "InProduct": c.InProduct(),
933 "InVendor": c.InVendor(),
934 "InRamdisk": c.InRamdisk(),
935 "InVendorRamdisk": c.InVendorRamdisk(),
936 "InRecovery": c.InRecovery(),
937 "VendorAvailable": c.VendorAvailable(),
938 "ProductAvailable": c.ProductAvailable(),
939 "RamdiskAvailable": c.RamdiskAvailable(),
940 "VendorRamdiskAvailable": c.VendorRamdiskAvailable(),
941 "RecoveryAvailable": c.RecoveryAvailable(),
942 "OdmAvailable": c.OdmAvailable(),
943 "InstallInData": c.InstallInData(),
944 "InstallInRamdisk": c.InstallInRamdisk(),
945 "InstallInSanitizerDir": c.InstallInSanitizerDir(),
946 "InstallInVendorRamdisk": c.InstallInVendorRamdisk(),
947 "InstallInRecovery": c.InstallInRecovery(),
948 "InstallInRoot": c.InstallInRoot(),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200949 "IsLlndk": c.IsLlndk(),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200950 "IsVendorPublicLibrary": c.IsVendorPublicLibrary(),
951 "ApexSdkVersion": c.apexSdkVersion,
952 "TestFor": c.TestFor(),
Cole Faust96a692b2024-08-08 14:47:51 -0700953 "AidlSrcs": c.hasAidl,
954 "LexSrcs": c.hasLex,
955 "ProtoSrcs": c.hasProto,
956 "RenderscriptSrcs": c.hasRenderscript,
957 "SyspropSrcs": c.hasSysprop,
958 "WinMsgSrcs": c.hasWinMsg,
959 "YaccSrsc": c.hasYacc,
960 "OnlyCSrcs": !(c.hasAidl || c.hasLex || c.hasProto || c.hasRenderscript || c.hasSysprop || c.hasWinMsg || c.hasYacc),
Yi Kong5786f5c2024-05-28 02:22:34 +0900961 "OptimizeForSize": c.OptimizeForSize(),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200962 }
963}
964
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500965func (c *Module) SetPreventInstall() {
966 c.Properties.PreventInstall = true
967}
968
969func (c *Module) SetHideFromMake() {
970 c.Properties.HideFromMake = true
971}
972
Ivan Lozanod7586b62021-04-01 09:49:36 -0400973func (c *Module) HiddenFromMake() bool {
974 return c.Properties.HideFromMake
975}
976
Cole Fauste8a87832024-09-11 11:35:46 -0700977func (c *Module) RequiredModuleNames(ctx android.ConfigurableEvaluatorContext) []string {
Cole Faust43ddd082024-06-17 12:32:40 -0700978 required := android.CopyOf(c.ModuleBase.RequiredModuleNames(ctx))
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800979 if c.ImageVariation().Variation == android.CoreVariation {
980 required = append(required, c.Properties.Target.Platform.Required...)
981 required = removeListFromList(required, c.Properties.Target.Platform.Exclude_required)
982 } else if c.InRecovery() {
983 required = append(required, c.Properties.Target.Recovery.Required...)
984 required = removeListFromList(required, c.Properties.Target.Recovery.Exclude_required)
985 }
986 return android.FirstUniqueStrings(required)
987}
988
Ivan Lozano52767be2019-10-18 14:49:46 -0700989func (c *Module) Toc() android.OptionalPath {
990 if c.linker != nil {
991 if library, ok := c.linker.(libraryInterface); ok {
992 return library.toc()
993 }
994 }
995 panic(fmt.Errorf("Toc() called on non-library module: %q", c.BaseModuleName()))
996}
997
998func (c *Module) ApiLevel() string {
999 if c.linker != nil {
1000 if stub, ok := c.linker.(*stubDecorator); ok {
Dan Albert1a246272020-07-06 14:49:35 -07001001 return stub.apiLevel.String()
Ivan Lozano52767be2019-10-18 14:49:46 -07001002 }
1003 }
1004 panic(fmt.Errorf("ApiLevel() called on non-stub library module: %q", c.BaseModuleName()))
1005}
1006
1007func (c *Module) Static() bool {
1008 if c.linker != nil {
1009 if library, ok := c.linker.(libraryInterface); ok {
1010 return library.static()
1011 }
1012 }
1013 panic(fmt.Errorf("Static() called on non-library module: %q", c.BaseModuleName()))
1014}
1015
1016func (c *Module) Shared() bool {
1017 if c.linker != nil {
1018 if library, ok := c.linker.(libraryInterface); ok {
1019 return library.shared()
1020 }
1021 }
Lukacs T. Berki6c716762022-06-13 20:50:39 +02001022
Ivan Lozano52767be2019-10-18 14:49:46 -07001023 panic(fmt.Errorf("Shared() called on non-library module: %q", c.BaseModuleName()))
1024}
1025
1026func (c *Module) SelectedStl() string {
Colin Crossc511bc52020-04-07 16:50:32 +00001027 if c.stl != nil {
1028 return c.stl.Properties.SelectedStl
1029 }
1030 return ""
Ivan Lozano52767be2019-10-18 14:49:46 -07001031}
1032
Ivan Lozano52767be2019-10-18 14:49:46 -07001033func (c *Module) StubDecorator() bool {
1034 if _, ok := c.linker.(*stubDecorator); ok {
1035 return true
1036 }
1037 return false
1038}
1039
Yi Kong5786f5c2024-05-28 02:22:34 +09001040func (c *Module) OptimizeForSize() bool {
1041 return Bool(c.Properties.Optimize_for_size)
1042}
1043
Ivan Lozano52767be2019-10-18 14:49:46 -07001044func (c *Module) SdkVersion() string {
1045 return String(c.Properties.Sdk_version)
1046}
1047
Artur Satayev480e25b2020-04-27 18:53:18 +01001048func (c *Module) MinSdkVersion() string {
1049 return String(c.Properties.Min_sdk_version)
1050}
1051
Jiyong Park5df7bd32021-08-25 16:18:46 +09001052func (c *Module) isCrt() bool {
Dan Albert92fe7402020-07-15 13:33:30 -07001053 if linker, ok := c.linker.(*objectLinker); ok {
1054 return linker.isCrt()
1055 }
1056 return false
1057}
1058
Jiyong Park5df7bd32021-08-25 16:18:46 +09001059func (c *Module) SplitPerApiLevel() bool {
1060 return c.canUseSdk() && c.isCrt()
1061}
1062
Colin Crossc511bc52020-04-07 16:50:32 +00001063func (c *Module) AlwaysSdk() bool {
1064 return c.Properties.AlwaysSdk || Bool(c.Properties.Sdk_variant_only)
1065}
1066
Ivan Lozano183a3212019-10-18 14:18:45 -07001067func (c *Module) CcLibrary() bool {
1068 if c.linker != nil {
1069 if _, ok := c.linker.(*libraryDecorator); ok {
1070 return true
1071 }
Colin Crossd48fe732020-09-23 20:37:24 -07001072 if _, ok := c.linker.(*prebuiltLibraryLinker); ok {
1073 return true
1074 }
Ivan Lozano183a3212019-10-18 14:18:45 -07001075 }
1076 return false
1077}
1078
1079func (c *Module) CcLibraryInterface() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001080 if _, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001081 return true
1082 }
1083 return false
1084}
1085
Ivan Lozanoadd122a2023-07-13 11:01:41 -04001086func (c *Module) RlibStd() bool {
1087 panic(fmt.Errorf("RlibStd called on non-Rust module: %q", c.BaseModuleName()))
1088}
1089
Ivan Lozano61c02cc2023-06-09 14:06:44 -04001090func (c *Module) RustLibraryInterface() bool {
1091 return false
1092}
1093
Ivan Lozano0a468a42024-05-13 21:03:34 -04001094func (c *Module) CrateName() string {
1095 panic(fmt.Errorf("CrateName called on non-Rust module: %q", c.BaseModuleName()))
1096}
1097
1098func (c *Module) ExportedCrateLinkDirs() []string {
1099 panic(fmt.Errorf("ExportedCrateLinkDirs called on non-Rust module: %q", c.BaseModuleName()))
1100}
1101
Ivan Lozano0f9963e2023-02-06 13:31:02 -05001102func (c *Module) IsFuzzModule() bool {
1103 if _, ok := c.compiler.(*fuzzBinary); ok {
1104 return true
1105 }
1106 return false
1107}
1108
1109func (c *Module) FuzzModuleStruct() fuzz.FuzzModule {
1110 return c.FuzzModule
1111}
1112
1113func (c *Module) FuzzPackagedModule() fuzz.FuzzPackagedModule {
1114 if fuzzer, ok := c.compiler.(*fuzzBinary); ok {
1115 return fuzzer.fuzzPackagedModule
1116 }
1117 panic(fmt.Errorf("FuzzPackagedModule called on non-fuzz module: %q", c.BaseModuleName()))
1118}
1119
Hamzeh Zawawy38917492023-04-05 22:08:46 +00001120func (c *Module) FuzzSharedLibraries() android.RuleBuilderInstalls {
Ivan Lozano0f9963e2023-02-06 13:31:02 -05001121 if fuzzer, ok := c.compiler.(*fuzzBinary); ok {
1122 return fuzzer.sharedLibraries
1123 }
1124 panic(fmt.Errorf("FuzzSharedLibraries called on non-fuzz module: %q", c.BaseModuleName()))
1125}
1126
Ivan Lozano2b262972019-11-21 12:30:50 -08001127func (c *Module) NonCcVariants() bool {
1128 return false
1129}
1130
Ivan Lozano183a3212019-10-18 14:18:45 -07001131func (c *Module) SetStatic() {
1132 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001133 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001134 library.setStatic()
1135 return
1136 }
1137 }
1138 panic(fmt.Errorf("SetStatic called on non-library module: %q", c.BaseModuleName()))
1139}
1140
1141func (c *Module) SetShared() {
1142 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001143 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001144 library.setShared()
1145 return
1146 }
1147 }
1148 panic(fmt.Errorf("SetShared called on non-library module: %q", c.BaseModuleName()))
1149}
1150
1151func (c *Module) BuildStaticVariant() bool {
1152 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001153 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001154 return library.buildStatic()
1155 }
1156 }
1157 panic(fmt.Errorf("BuildStaticVariant called on non-library module: %q", c.BaseModuleName()))
1158}
1159
1160func (c *Module) BuildSharedVariant() bool {
1161 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001162 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001163 return library.buildShared()
1164 }
1165 }
1166 panic(fmt.Errorf("BuildSharedVariant called on non-library module: %q", c.BaseModuleName()))
1167}
1168
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04001169func (c *Module) BuildRlibVariant() bool {
1170 // cc modules can never build rlib variants
1171 return false
1172}
1173
1174func (c *Module) IsRustFFI() bool {
1175 // cc modules are not Rust modules
1176 return false
1177}
1178
Ivan Lozano183a3212019-10-18 14:18:45 -07001179func (c *Module) Module() android.Module {
1180 return c
1181}
1182
Jiyong Parkc20eee32018-09-05 22:36:17 +09001183func (c *Module) OutputFile() android.OptionalPath {
1184 return c.outputFile
1185}
1186
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001187func (c *Module) CoverageFiles() android.Paths {
1188 if c.linker != nil {
1189 if library, ok := c.linker.(libraryInterface); ok {
1190 return library.objs().coverageFiles
1191 }
1192 }
1193 panic(fmt.Errorf("CoverageFiles called on non-library module: %q", c.BaseModuleName()))
1194}
1195
Ivan Lozano183a3212019-10-18 14:18:45 -07001196var _ LinkableInterface = (*Module)(nil)
1197
Jiyong Park719b4462019-01-13 00:39:51 +09001198func (c *Module) UnstrippedOutputFile() android.Path {
Jiyong Parkaf6d8952019-01-31 12:21:23 +09001199 if c.linker != nil {
1200 return c.linker.unstrippedOutputFilePath()
Jiyong Park719b4462019-01-13 00:39:51 +09001201 }
1202 return nil
1203}
1204
Jiyong Parkee9a98d2019-08-09 14:44:36 +09001205func (c *Module) CoverageOutputFile() android.OptionalPath {
1206 if c.linker != nil {
1207 return c.linker.coverageOutputFilePath()
1208 }
1209 return android.OptionalPath{}
1210}
1211
Jiyong Parkb7c24df2019-02-01 12:03:59 +09001212func (c *Module) RelativeInstallPath() string {
1213 if c.installer != nil {
1214 return c.installer.relativeInstallPath()
1215 }
1216 return ""
1217}
1218
Jooyung Han344d5432019-08-23 11:17:39 +09001219func (c *Module) VndkVersion() string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001220 return c.Properties.VndkVersion
Jooyung Han344d5432019-08-23 11:17:39 +09001221}
1222
Colin Cross36242852017-06-23 15:06:31 -07001223func (c *Module) Init() android.Module {
Dan Willemsenf923f2b2018-05-09 13:45:03 -07001224 c.AddProperties(&c.Properties, &c.VendorProperties)
Joe Onorato37f900c2023-07-18 16:58:16 -07001225 for _, generator := range c.generators {
1226 c.AddProperties(generator.GeneratorProps()...)
1227 }
Colin Crossca860ac2016-01-04 14:34:37 -08001228 if c.compiler != nil {
Colin Cross36242852017-06-23 15:06:31 -07001229 c.AddProperties(c.compiler.compilerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001230 }
1231 if c.linker != nil {
Colin Cross36242852017-06-23 15:06:31 -07001232 c.AddProperties(c.linker.linkerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001233 }
1234 if c.installer != nil {
Colin Cross36242852017-06-23 15:06:31 -07001235 c.AddProperties(c.installer.installerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001236 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001237 if c.stl != nil {
Colin Cross36242852017-06-23 15:06:31 -07001238 c.AddProperties(c.stl.props()...)
Colin Crossa8e07cc2016-04-04 15:07:06 -07001239 }
Colin Cross16b23492016-01-06 14:41:07 -08001240 if c.sanitize != nil {
Colin Cross36242852017-06-23 15:06:31 -07001241 c.AddProperties(c.sanitize.props()...)
Colin Cross16b23492016-01-06 14:41:07 -08001242 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001243 if c.coverage != nil {
Colin Cross36242852017-06-23 15:06:31 -07001244 c.AddProperties(c.coverage.props()...)
Dan Willemsen581341d2017-02-09 16:16:31 -08001245 }
Cory Barkera1da26f2022-06-07 20:12:06 +00001246 if c.fuzzer != nil {
1247 c.AddProperties(c.fuzzer.props()...)
1248 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001249 if c.sabi != nil {
Colin Cross36242852017-06-23 15:06:31 -07001250 c.AddProperties(c.sabi.props()...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001251 }
Stephen Craneba090d12017-05-09 15:44:35 -07001252 if c.lto != nil {
1253 c.AddProperties(c.lto.props()...)
1254 }
Yi Kongeb8efc92021-12-09 18:06:29 +08001255 if c.afdo != nil {
1256 c.AddProperties(c.afdo.props()...)
1257 }
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001258 if c.orderfile != nil {
1259 c.AddProperties(c.orderfile.props()...)
1260 }
Colin Crossca860ac2016-01-04 14:34:37 -08001261 for _, feature := range c.features {
Colin Cross36242852017-06-23 15:06:31 -07001262 c.AddProperties(feature.props()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001263 }
Ronald Braunsteina115e262024-04-09 18:07:38 -07001264 // Allow test-only on libraries that are not cc_test_library
1265 if c.library != nil && !c.testLibrary() {
1266 c.AddProperties(&c.sourceProperties)
1267 }
Colin Crossc472d572015-03-17 15:06:21 -07001268
Colin Cross36242852017-06-23 15:06:31 -07001269 android.InitAndroidArchModule(c, c.hod, c.multilib)
Jiyong Park7916bfc2019-09-30 19:13:12 +09001270 android.InitApexModule(c)
Jooyung Han18020ea2019-11-13 10:50:48 +09001271 android.InitDefaultableModule(c)
Jiyong Park9d452992018-10-03 00:38:19 +09001272
Colin Cross36242852017-06-23 15:06:31 -07001273 return c
Colin Crossc472d572015-03-17 15:06:21 -07001274}
1275
Yi-Yo Chiang1080f0c2022-11-22 18:24:14 +08001276// UseVndk() returns true if this module is built against VNDK.
1277// This means the vendor and product variants of a module.
Ivan Lozano52767be2019-10-18 14:49:46 -07001278func (c *Module) UseVndk() bool {
Inseob Kim64c43952019-08-26 16:52:35 +09001279 return c.Properties.VndkVersion != ""
Dan Willemsen4416e5d2017-04-06 12:43:22 -07001280}
1281
Colin Crossc511bc52020-04-07 16:50:32 +00001282func (c *Module) canUseSdk() bool {
Colin Cross94e347e2021-01-19 14:56:07 -08001283 return c.Os() == android.Android && c.Target().NativeBridge == android.NativeBridgeDisabled &&
Kiyoung Kimaa394802024-01-08 12:55:45 +09001284 !c.InVendorOrProduct() && !c.InRamdisk() && !c.InRecovery() && !c.InVendorRamdisk()
Colin Crossc511bc52020-04-07 16:50:32 +00001285}
1286
1287func (c *Module) UseSdk() bool {
1288 if c.canUseSdk() {
Colin Cross1348ce32020-10-01 13:37:16 -07001289 return String(c.Properties.Sdk_version) != ""
Colin Crossc511bc52020-04-07 16:50:32 +00001290 }
1291 return false
1292}
1293
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001294func (c *Module) isCoverageVariant() bool {
1295 return c.coverage.Properties.IsCoverageVariant
1296}
1297
Colin Cross95f1ca02020-10-29 20:47:22 -07001298func (c *Module) IsNdk(config android.Config) bool {
1299 return inList(c.BaseModuleName(), *getNDKKnownLibs(config))
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001300}
1301
Colin Cross127bb8b2020-12-16 16:46:01 -08001302func (c *Module) IsLlndk() bool {
1303 return c.VendorProperties.IsLLNDK
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001304}
1305
Colin Cross1f3f1302021-04-26 18:37:44 -07001306func (m *Module) NeedsLlndkVariants() bool {
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001307 lib := moduleLibraryInterface(m)
Colin Cross1f3f1302021-04-26 18:37:44 -07001308 return lib != nil && (lib.hasLLNDKStubs() || lib.hasLLNDKHeaders())
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001309}
1310
Colin Cross5271fea2021-04-27 13:06:04 -07001311func (m *Module) NeedsVendorPublicLibraryVariants() bool {
1312 lib := moduleLibraryInterface(m)
1313 return lib != nil && (lib.hasVendorPublicLibrary())
1314}
1315
1316// IsVendorPublicLibrary returns true for vendor public libraries.
1317func (c *Module) IsVendorPublicLibrary() bool {
1318 return c.VendorProperties.IsVendorPublicLibrary
1319}
1320
Ivan Lozanof1868af2022-04-12 13:08:36 -04001321func (c *Module) IsVndkPrebuiltLibrary() bool {
1322 if _, ok := c.linker.(*vndkPrebuiltLibraryDecorator); ok {
1323 return true
1324 }
1325 return false
1326}
1327
1328func (c *Module) SdkAndPlatformVariantVisibleToMake() bool {
1329 return c.Properties.SdkAndPlatformVariantVisibleToMake
1330}
1331
Ivan Lozanod7586b62021-04-01 09:49:36 -04001332func (c *Module) HasLlndkStubs() bool {
1333 lib := moduleLibraryInterface(c)
1334 return lib != nil && lib.hasLLNDKStubs()
1335}
1336
1337func (c *Module) StubsVersion() string {
1338 if lib, ok := c.linker.(versionedInterface); ok {
1339 return lib.stubsVersion()
1340 }
1341 panic(fmt.Errorf("StubsVersion called on non-versioned module: %q", c.BaseModuleName()))
1342}
1343
Colin Cross127bb8b2020-12-16 16:46:01 -08001344// isImplementationForLLNDKPublic returns true for any variant of a cc_library that has LLNDK stubs
1345// and does not set llndk.vendor_available: false.
1346func (c *Module) isImplementationForLLNDKPublic() bool {
1347 library, _ := c.library.(*libraryDecorator)
1348 return library != nil && library.hasLLNDKStubs() &&
Colin Cross0fb7fcd2021-03-02 11:00:07 -08001349 !Bool(library.Properties.Llndk.Private)
Colin Cross127bb8b2020-12-16 16:46:01 -08001350}
1351
Colin Cross3513fb12024-01-24 14:44:47 -08001352func (c *Module) isAfdoCompile(ctx ModuleContext) bool {
Yi Kong4ef54592022-02-14 20:00:10 +08001353 if afdo := c.afdo; afdo != nil {
Colin Cross3513fb12024-01-24 14:44:47 -08001354 return afdo.isAfdoCompile(ctx)
Yi Kong4ef54592022-02-14 20:00:10 +08001355 }
1356 return false
1357}
1358
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001359func (c *Module) isOrderfileCompile() bool {
1360 if orderfile := c.orderfile; orderfile != nil {
1361 return orderfile.Properties.OrderfileLoad
1362 }
1363 return false
1364}
1365
Yi Kongc702ebd2022-08-19 16:02:45 +08001366func (c *Module) isCfi() bool {
Colin Cross694fced2024-06-25 14:56:42 -07001367 return c.sanitize.isSanitizerEnabled(cfi)
Yi Kongc702ebd2022-08-19 16:02:45 +08001368}
1369
Yi Konged79fa32023-06-04 17:15:42 +09001370func (c *Module) isFuzzer() bool {
Colin Cross694fced2024-06-25 14:56:42 -07001371 return c.sanitize.isSanitizerEnabled(Fuzzer)
Yi Konged79fa32023-06-04 17:15:42 +09001372}
1373
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001374func (c *Module) isNDKStubLibrary() bool {
1375 if _, ok := c.compiler.(*stubDecorator); ok {
1376 return true
1377 }
1378 return false
1379}
1380
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001381func (c *Module) SubName() string {
1382 return c.Properties.SubName
1383}
1384
Jiyong Park25fc6a92018-11-18 18:02:45 +09001385func (c *Module) IsStubs() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001386 if lib := c.library; lib != nil {
1387 return lib.buildStubs()
Jiyong Park25fc6a92018-11-18 18:02:45 +09001388 }
1389 return false
1390}
1391
1392func (c *Module) HasStubsVariants() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001393 if lib := c.library; lib != nil {
1394 return lib.hasStubsVariants()
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001395 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09001396 return false
1397}
1398
Alan Stokes73feba32022-11-14 12:21:24 +00001399func (c *Module) IsStubsImplementationRequired() bool {
1400 if lib := c.library; lib != nil {
1401 return lib.isStubsImplementationRequired()
1402 }
1403 return false
1404}
1405
Colin Cross0477b422020-10-13 18:43:54 -07001406// If this is a stubs library, ImplementationModuleName returns the name of the module that contains
1407// the implementation. If it is an implementation library it returns its own name.
1408func (c *Module) ImplementationModuleName(ctx android.BaseModuleContext) string {
1409 name := ctx.OtherModuleName(c)
1410 if versioned, ok := c.linker.(versionedInterface); ok {
1411 name = versioned.implementationModuleName(name)
1412 }
1413 return name
1414}
1415
Martin Stjernholm2856c662020-12-02 15:03:42 +00001416// Similar to ImplementationModuleName, but uses the Make variant of the module
1417// name as base name, for use in AndroidMk output. E.g. for a prebuilt module
1418// where the Soong name is prebuilt_foo, this returns foo (which works in Make
1419// under the premise that the prebuilt module overrides its source counterpart
1420// if it is exposed to Make).
1421func (c *Module) ImplementationModuleNameForMake(ctx android.BaseModuleContext) string {
1422 name := c.BaseModuleName()
1423 if versioned, ok := c.linker.(versionedInterface); ok {
1424 name = versioned.implementationModuleName(name)
1425 }
1426 return name
1427}
1428
Jiyong Park7d55b612021-06-11 17:22:09 +09001429func (c *Module) Bootstrap() bool {
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001430 return Bool(c.Properties.Bootstrap)
1431}
1432
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001433func (c *Module) nativeCoverage() bool {
Pirama Arumuga Nainar5f69b9a2019-09-12 13:18:48 -07001434 // Bug: http://b/137883967 - native-bridge modules do not currently work with coverage
1435 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1436 return false
1437 }
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001438 return c.linker != nil && c.linker.nativeCoverage()
1439}
1440
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001441func (c *Module) IsSnapshotPrebuilt() bool {
Ivan Lozanod1dec542021-05-26 15:33:11 -04001442 if p, ok := c.linker.(SnapshotInterface); ok {
1443 return p.IsSnapshotPrebuilt()
Inseob Kimeec88e12020-01-22 11:11:29 +09001444 }
1445 return false
Inseob Kim8471cda2019-11-15 09:59:12 +09001446}
1447
Jiyong Parkf1194352019-02-25 11:05:47 +09001448func isBionic(name string) bool {
1449 switch name {
Jooyung Hanbff73352022-12-13 18:29:44 +09001450 case "libc", "libm", "libdl", "libdl_android", "linker":
Jiyong Parkf1194352019-02-25 11:05:47 +09001451 return true
1452 }
1453 return false
1454}
1455
Martin Stjernholm279de572019-09-10 23:18:20 +01001456func InstallToBootstrap(name string, config android.Config) bool {
Florian Mayer95cd6db2023-03-23 17:48:07 -07001457 if name == "libclang_rt.hwasan" || name == "libc_hwasan" {
Jooyung Han8ce8db92020-05-15 19:05:05 +09001458 return true
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001459 }
1460 return isBionic(name)
1461}
1462
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001463func (c *Module) XrefCcFiles() android.Paths {
1464 return c.kytheFiles
1465}
1466
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001467func (c *Module) isCfiAssemblySupportEnabled() bool {
1468 return c.sanitize != nil &&
1469 Bool(c.sanitize.Properties.Sanitize.Config.Cfi_assembly_support)
1470}
1471
Inseob Kim800d1142021-06-14 12:03:51 +09001472func (c *Module) InstallInRoot() bool {
1473 return c.installer != nil && c.installer.installInRoot()
1474}
1475
Colin Crossca860ac2016-01-04 14:34:37 -08001476type baseModuleContext struct {
Colin Cross0ea8ba82019-06-06 14:33:29 -07001477 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001478 moduleContextImpl
1479}
1480
Colin Cross37047f12016-12-13 17:06:13 -08001481type depsContext struct {
1482 android.BottomUpMutatorContext
1483 moduleContextImpl
1484}
1485
Colin Crossca860ac2016-01-04 14:34:37 -08001486type moduleContext struct {
Colin Cross635c3b02016-05-18 15:37:25 -07001487 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001488 moduleContextImpl
1489}
1490
1491type moduleContextImpl struct {
1492 mod *Module
1493 ctx BaseModuleContext
1494}
1495
Colin Crossb98c8b02016-07-29 13:44:28 -07001496func (ctx *moduleContextImpl) toolchain() config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001497 return ctx.mod.toolchain(ctx.ctx)
1498}
1499
1500func (ctx *moduleContextImpl) static() bool {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00001501 return ctx.mod.static()
Colin Crossca860ac2016-01-04 14:34:37 -08001502}
1503
1504func (ctx *moduleContextImpl) staticBinary() bool {
Jiyong Park379de2f2018-12-19 02:47:14 +09001505 return ctx.mod.staticBinary()
Colin Crossca860ac2016-01-04 14:34:37 -08001506}
1507
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07001508func (ctx *moduleContextImpl) testBinary() bool {
1509 return ctx.mod.testBinary()
1510}
1511
Yi Kong56fc1b62022-09-06 16:24:00 +08001512func (ctx *moduleContextImpl) testLibrary() bool {
1513 return ctx.mod.testLibrary()
1514}
1515
Jiyong Park1d1119f2019-07-29 21:27:18 +09001516func (ctx *moduleContextImpl) header() bool {
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001517 return ctx.mod.Header()
Jiyong Park1d1119f2019-07-29 21:27:18 +09001518}
1519
Inseob Kim7f283f42020-06-01 21:53:49 +09001520func (ctx *moduleContextImpl) binary() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001521 return ctx.mod.Binary()
Inseob Kim7f283f42020-06-01 21:53:49 +09001522}
1523
Inseob Kim1042d292020-06-01 23:23:05 +09001524func (ctx *moduleContextImpl) object() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001525 return ctx.mod.Object()
Inseob Kim1042d292020-06-01 23:23:05 +09001526}
1527
Yi Kong5786f5c2024-05-28 02:22:34 +09001528func (ctx *moduleContextImpl) optimizeForSize() bool {
1529 return ctx.mod.OptimizeForSize()
1530}
1531
Jooyung Hanccce2f22020-03-07 03:45:53 +09001532func (ctx *moduleContextImpl) canUseSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001533 return ctx.mod.canUseSdk()
Jooyung Hanccce2f22020-03-07 03:45:53 +09001534}
1535
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001536func (ctx *moduleContextImpl) useSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001537 return ctx.mod.UseSdk()
Colin Crossca860ac2016-01-04 14:34:37 -08001538}
1539
1540func (ctx *moduleContextImpl) sdkVersion() string {
Dan Willemsena96ff642016-06-07 12:34:45 -07001541 if ctx.ctx.Device() {
Justin Yun732aa6a2018-03-23 17:43:47 +09001542 return String(ctx.mod.Properties.Sdk_version)
Dan Willemsena96ff642016-06-07 12:34:45 -07001543 }
1544 return ""
Colin Crossca860ac2016-01-04 14:34:37 -08001545}
1546
Jiyong Parkb35a8192020-08-10 15:59:36 +09001547func (ctx *moduleContextImpl) minSdkVersion() string {
1548 ver := ctx.mod.MinSdkVersion()
1549 if ver == "apex_inherit" && !ctx.isForPlatform() {
1550 ver = ctx.apexSdkVersion().String()
1551 }
1552 if ver == "apex_inherit" || ver == "" {
1553 ver = ctx.sdkVersion()
1554 }
Yi-Yo Chiang88960aa2024-01-19 15:02:29 +08001555
1556 if ctx.ctx.Device() {
1557 config := ctx.ctx.Config()
Kiyoung Kim8f05c542024-05-22 16:50:34 +09001558 if ctx.inVendor() {
Yi-Yo Chiang88960aa2024-01-19 15:02:29 +08001559 // If building for vendor with final API, then use the latest _stable_ API as "current".
1560 if config.VendorApiLevelFrozen() && (ver == "" || ver == "current") {
1561 ver = config.PlatformSdkVersion().String()
1562 }
1563 }
1564 }
1565
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001566 // For crt objects, the meaning of min_sdk_version is very different from other types of
1567 // module. For them, min_sdk_version defines the oldest version that the build system will
1568 // create versioned variants for. For example, if min_sdk_version is 16, then sdk variant of
1569 // the crt object has local variants of 16, 17, ..., up to the latest version. sdk_version
1570 // and min_sdk_version properties of the variants are set to the corresponding version
Jiyong Park5df7bd32021-08-25 16:18:46 +09001571 // numbers. However, the non-sdk variant (for apex or platform) of the crt object is left
1572 // untouched. min_sdk_version: 16 doesn't actually mean that the non-sdk variant has to
1573 // support such an old version. The version is set to the later version in case when the
1574 // non-sdk variant is for the platform, or the min_sdk_version of the containing APEX if
1575 // it's for an APEX.
1576 if ctx.mod.isCrt() && !ctx.isSdkVariant() {
1577 if ctx.isForPlatform() {
1578 ver = strconv.Itoa(android.FutureApiLevelInt)
1579 } else { // for apex
1580 ver = ctx.apexSdkVersion().String()
1581 if ver == "" { // in case when min_sdk_version was not set by the APEX
1582 ver = ctx.sdkVersion()
1583 }
1584 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001585 }
1586
Jiyong Parkb35a8192020-08-10 15:59:36 +09001587 // Also make sure that minSdkVersion is not greater than sdkVersion, if they are both numbers
1588 sdkVersionInt, err := strconv.Atoi(ctx.sdkVersion())
1589 minSdkVersionInt, err2 := strconv.Atoi(ver)
1590 if err == nil && err2 == nil {
1591 if sdkVersionInt < minSdkVersionInt {
1592 return strconv.Itoa(sdkVersionInt)
1593 }
1594 }
1595 return ver
1596}
1597
1598func (ctx *moduleContextImpl) isSdkVariant() bool {
1599 return ctx.mod.IsSdkVariant()
1600}
1601
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001602func (ctx *moduleContextImpl) useVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001603 return ctx.mod.UseVndk()
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001604}
Justin Yun8effde42017-06-23 19:24:43 +09001605
Kiyoung Kimaa394802024-01-08 12:55:45 +09001606func (ctx *moduleContextImpl) InVendorOrProduct() bool {
1607 return ctx.mod.InVendorOrProduct()
1608}
1609
Colin Cross95f1ca02020-10-29 20:47:22 -07001610func (ctx *moduleContextImpl) isNdk(config android.Config) bool {
1611 return ctx.mod.IsNdk(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001612}
1613
Colin Cross127bb8b2020-12-16 16:46:01 -08001614func (ctx *moduleContextImpl) IsLlndk() bool {
1615 return ctx.mod.IsLlndk()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001616}
1617
Colin Cross127bb8b2020-12-16 16:46:01 -08001618func (ctx *moduleContextImpl) isImplementationForLLNDKPublic() bool {
1619 return ctx.mod.isImplementationForLLNDKPublic()
1620}
1621
Colin Cross3513fb12024-01-24 14:44:47 -08001622func (ctx *moduleContextImpl) isAfdoCompile(mctx ModuleContext) bool {
1623 return ctx.mod.isAfdoCompile(mctx)
Yi Kong4ef54592022-02-14 20:00:10 +08001624}
1625
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001626func (ctx *moduleContextImpl) isOrderfileCompile() bool {
1627 return ctx.mod.isOrderfileCompile()
1628}
1629
Yi Kongc702ebd2022-08-19 16:02:45 +08001630func (ctx *moduleContextImpl) isCfi() bool {
1631 return ctx.mod.isCfi()
1632}
1633
Yi Konged79fa32023-06-04 17:15:42 +09001634func (ctx *moduleContextImpl) isFuzzer() bool {
1635 return ctx.mod.isFuzzer()
1636}
1637
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001638func (ctx *moduleContextImpl) isNDKStubLibrary() bool {
1639 return ctx.mod.isNDKStubLibrary()
1640}
1641
Colin Cross5271fea2021-04-27 13:06:04 -07001642func (ctx *moduleContextImpl) IsVendorPublicLibrary() bool {
1643 return ctx.mod.IsVendorPublicLibrary()
1644}
1645
Dan Willemsen8146b2f2016-03-30 21:00:30 -07001646func (ctx *moduleContextImpl) selectedStl() string {
1647 if stl := ctx.mod.stl; stl != nil {
1648 return stl.Properties.SelectedStl
1649 }
1650 return ""
1651}
1652
Ivan Lozanobd721262018-11-27 14:33:03 -08001653func (ctx *moduleContextImpl) useClangLld(actx ModuleContext) bool {
1654 return ctx.mod.linker.useClangLld(actx)
1655}
1656
Colin Crossce75d2c2016-10-06 16:12:58 -07001657func (ctx *moduleContextImpl) baseModuleName() string {
Spandan Das2b6dfb52024-01-19 00:22:22 +00001658 return ctx.mod.BaseModuleName()
Colin Crossce75d2c2016-10-06 16:12:58 -07001659}
1660
Logan Chiene274fc92019-12-03 11:18:32 -08001661func (ctx *moduleContextImpl) isForPlatform() bool {
Colin Crossff694a82023-12-13 15:54:49 -08001662 apexInfo, _ := android.ModuleProvider(ctx.ctx, android.ApexInfoProvider)
1663 return apexInfo.IsForPlatform()
Logan Chiene274fc92019-12-03 11:18:32 -08001664}
1665
Colin Crosse07f2312020-08-13 11:24:56 -07001666func (ctx *moduleContextImpl) apexVariationName() string {
Colin Crossff694a82023-12-13 15:54:49 -08001667 apexInfo, _ := android.ModuleProvider(ctx.ctx, android.ApexInfoProvider)
1668 return apexInfo.ApexVariationName
Jiyong Park25fc6a92018-11-18 18:02:45 +09001669}
1670
Dan Albertc8060532020-07-22 22:32:17 -07001671func (ctx *moduleContextImpl) apexSdkVersion() android.ApiLevel {
Jooyung Han75568392020-03-20 04:29:24 +09001672 return ctx.mod.apexSdkVersion
Jooyung Hanccce2f22020-03-07 03:45:53 +09001673}
1674
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001675func (ctx *moduleContextImpl) bootstrap() bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09001676 return ctx.mod.Bootstrap()
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001677}
1678
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001679func (ctx *moduleContextImpl) nativeCoverage() bool {
1680 return ctx.mod.nativeCoverage()
1681}
1682
Colin Cross56a83212020-09-15 18:30:11 -07001683func (ctx *moduleContextImpl) directlyInAnyApex() bool {
1684 return ctx.mod.DirectlyInAnyApex()
1685}
1686
Colin Cross95b07f22020-12-16 11:06:50 -08001687func (ctx *moduleContextImpl) isPreventInstall() bool {
1688 return ctx.mod.Properties.PreventInstall
1689}
1690
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -08001691func (ctx *moduleContextImpl) getSharedFlags() *SharedFlags {
1692 shared := &ctx.mod.sharedFlags
1693 if shared.flagsMap == nil {
1694 shared.numSharedFlags = 0
1695 shared.flagsMap = make(map[string]string)
1696 }
1697 return shared
1698}
1699
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001700func (ctx *moduleContextImpl) isCfiAssemblySupportEnabled() bool {
1701 return ctx.mod.isCfiAssemblySupportEnabled()
1702}
1703
Colin Cross4a9e6ec2023-12-18 15:29:41 -08001704func (ctx *moduleContextImpl) notInPlatform() bool {
1705 return ctx.mod.NotInPlatform()
1706}
1707
Colin Cross635c3b02016-05-18 15:37:25 -07001708func newBaseModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001709 return &Module{
1710 hod: hod,
1711 multilib: multilib,
1712 }
1713}
1714
Colin Cross635c3b02016-05-18 15:37:25 -07001715func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001716 module := newBaseModule(hod, multilib)
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001717 module.features = []feature{
1718 &tidyFeature{},
1719 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001720 module.stl = &stl{}
Colin Cross16b23492016-01-06 14:41:07 -08001721 module.sanitize = &sanitize{}
Dan Willemsen581341d2017-02-09 16:16:31 -08001722 module.coverage = &coverage{}
Cory Barkera1da26f2022-06-07 20:12:06 +00001723 module.fuzzer = &fuzzer{}
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001724 module.sabi = &sabi{}
Stephen Craneba090d12017-05-09 15:44:35 -07001725 module.lto = &lto{}
Yi Kongeb8efc92021-12-09 18:06:29 +08001726 module.afdo = &afdo{}
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001727 module.orderfile = &orderfile{}
Colin Crossca860ac2016-01-04 14:34:37 -08001728 return module
1729}
1730
Colin Crossce75d2c2016-10-06 16:12:58 -07001731func (c *Module) Prebuilt() *android.Prebuilt {
1732 if p, ok := c.linker.(prebuiltLinkerInterface); ok {
1733 return p.prebuilt()
1734 }
1735 return nil
1736}
1737
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001738func (c *Module) IsPrebuilt() bool {
1739 return c.Prebuilt() != nil
1740}
1741
Colin Crossce75d2c2016-10-06 16:12:58 -07001742func (c *Module) Name() string {
1743 name := c.ModuleBase.Name()
Dan Willemsen01a90592017-04-07 15:21:13 -07001744 if p, ok := c.linker.(interface {
1745 Name(string) string
1746 }); ok {
Colin Crossce75d2c2016-10-06 16:12:58 -07001747 name = p.Name(name)
1748 }
1749 return name
1750}
1751
Alex Light3d673592019-01-18 14:37:31 -08001752func (c *Module) Symlinks() []string {
1753 if p, ok := c.installer.(interface {
1754 symlinkList() []string
1755 }); ok {
1756 return p.symlinkList()
1757 }
1758 return nil
1759}
1760
Chris Parsons216e10a2020-07-09 17:12:52 -04001761func (c *Module) DataPaths() []android.DataPath {
Liz Kammer1c14a212020-05-12 15:26:55 -07001762 if p, ok := c.installer.(interface {
Chris Parsons216e10a2020-07-09 17:12:52 -04001763 dataPaths() []android.DataPath
Liz Kammer1c14a212020-05-12 15:26:55 -07001764 }); ok {
1765 return p.dataPaths()
1766 }
1767 return nil
1768}
1769
Ivan Lozanof1868af2022-04-12 13:08:36 -04001770func getNameSuffixWithVndkVersion(ctx android.ModuleContext, c LinkableInterface) string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001771 // Returns the name suffix for product and vendor variants. If the VNDK version is not
1772 // "current", it will append the VNDK version to the name suffix.
Justin Yun5f7f7e82019-11-18 19:52:14 +09001773 var nameSuffix string
Ivan Lozanof9e21722020-12-02 09:00:51 -05001774 if c.InProduct() {
Justin Yund00f5ca2021-02-03 19:43:02 +09001775 if c.ProductSpecific() {
1776 // If the module is product specific with 'product_specific: true',
1777 // do not add a name suffix because it is a base module.
1778 return ""
1779 }
Justin Yunaf1fde42023-09-27 16:22:10 +09001780 return ProductSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001781 } else {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05001782 nameSuffix = VendorSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001783 }
Kiyoung Kim4e765b12024-04-04 17:33:42 +09001784 if c.VndkVersion() != "" {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001785 // add version suffix only if the module is using different vndk version than the
1786 // version in product or vendor partition.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001787 nameSuffix += "." + c.VndkVersion()
Justin Yun5f7f7e82019-11-18 19:52:14 +09001788 }
1789 return nameSuffix
1790}
1791
Ivan Lozanof1868af2022-04-12 13:08:36 -04001792func GetSubnameProperty(actx android.ModuleContext, c LinkableInterface) string {
1793 var subName = ""
Inseob Kim64c43952019-08-26 16:52:35 +09001794
1795 if c.Target().NativeBridge == android.NativeBridgeEnabled {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001796 subName += NativeBridgeSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001797 }
1798
Colin Cross127bb8b2020-12-16 16:46:01 -08001799 llndk := c.IsLlndk()
Kiyoung Kimaa394802024-01-08 12:55:45 +09001800 if llndk || (c.InVendorOrProduct() && c.HasNonSystemVariants()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001801 // .vendor.{version} suffix is added for vendor variant or .product.{version} suffix is
1802 // added for product variant only when we have vendor and product variants with core
1803 // variant. The suffix is not added for vendor-only or product-only module.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001804 subName += getNameSuffixWithVndkVersion(actx, c)
Colin Cross5271fea2021-04-27 13:06:04 -07001805 } else if c.IsVendorPublicLibrary() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001806 subName += vendorPublicLibrarySuffix
1807 } else if c.IsVndkPrebuiltLibrary() {
Inseob Kim64c43952019-08-26 16:52:35 +09001808 // .vendor suffix is added for backward compatibility with VNDK snapshot whose names with
1809 // such suffixes are already hard-coded in prebuilts/vndk/.../Android.bp.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001810 subName += VendorSuffix
Yifan Hong1b3348d2020-01-21 15:53:22 -08001811 } else if c.InRamdisk() && !c.OnlyInRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001812 subName += RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001813 } else if c.InVendorRamdisk() && !c.OnlyInVendorRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001814 subName += VendorRamdiskSuffix
Ivan Lozano52767be2019-10-18 14:49:46 -07001815 } else if c.InRecovery() && !c.OnlyInRecovery() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001816 subName += RecoverySuffix
1817 } else if c.IsSdkVariant() && (c.SdkAndPlatformVariantVisibleToMake() || c.SplitPerApiLevel()) {
1818 subName += sdkSuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001819 if c.SplitPerApiLevel() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001820 subName += "." + c.SdkVersion()
Dan Albert92fe7402020-07-15 13:33:30 -07001821 }
Spandan Dasb2b41d52023-04-13 18:15:05 +00001822 } else if c.IsStubs() && c.IsSdkVariant() {
1823 // Public API surface (NDK)
1824 // Add a suffix to this stub variant to distinguish it from the module-lib stub variant.
1825 subName = sdkSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001826 }
Ivan Lozanof1868af2022-04-12 13:08:36 -04001827
1828 return subName
Chris Parsons8d6e4332021-02-22 16:13:50 -05001829}
1830
Sam Delmerico75dbca22023-04-20 13:13:25 +00001831func moduleContextFromAndroidModuleContext(actx android.ModuleContext, c *Module) ModuleContext {
1832 ctx := &moduleContext{
1833 ModuleContext: actx,
1834 moduleContextImpl: moduleContextImpl{
1835 mod: c,
1836 },
1837 }
1838 ctx.ctx = ctx
1839 return ctx
1840}
1841
Spandan Das20fce2d2023-04-12 17:21:39 +00001842// TODO (b/277651159): Remove this allowlist
1843var (
1844 skipStubLibraryMultipleApexViolation = map[string]bool{
1845 "libclang_rt.asan": true,
1846 "libclang_rt.hwasan": true,
1847 // runtime apex
1848 "libc": true,
1849 "libc_hwasan": true,
1850 "libdl_android": true,
1851 "libm": true,
1852 "libdl": true,
Spandan Das1a0c6e12024-01-04 01:44:17 +00001853 "libz": true,
Spandan Das20fce2d2023-04-12 17:21:39 +00001854 // art apex
Martin Stjernholm75598032024-07-12 18:47:26 +01001855 // TODO(b/234351700): Remove this when com.android.art.debug is gone.
Spandan Das20fce2d2023-04-12 17:21:39 +00001856 "libandroidio": true,
1857 "libdexfile": true,
Martin Stjernholm75598032024-07-12 18:47:26 +01001858 "libdexfiled": true, // com.android.art.debug only
Spandan Das20fce2d2023-04-12 17:21:39 +00001859 "libnativebridge": true,
1860 "libnativehelper": true,
1861 "libnativeloader": true,
1862 "libsigchain": true,
1863 }
1864)
1865
1866// Returns true if a stub library could be installed in multiple apexes
1867func (c *Module) stubLibraryMultipleApexViolation(ctx android.ModuleContext) bool {
1868 // If this is not an apex variant, no check necessary
1869 if !c.InAnyApex() {
1870 return false
1871 }
1872 // If this is not a stub library, no check necessary
1873 if !c.HasStubsVariants() {
1874 return false
1875 }
1876 // Skip the allowlist
1877 // Use BaseModuleName so that this matches prebuilts.
1878 if _, exists := skipStubLibraryMultipleApexViolation[c.BaseModuleName()]; exists {
1879 return false
1880 }
1881
1882 _, aaWithoutTestApexes, _ := android.ListSetDifference(c.ApexAvailable(), c.TestApexes())
1883 // Stub libraries should not have more than one apex_available
1884 if len(aaWithoutTestApexes) > 1 {
1885 return true
1886 }
1887 // Stub libraries should not use the wildcard
1888 if aaWithoutTestApexes[0] == android.AvailableToAnyApex {
1889 return true
1890 }
1891 // Default: no violation
1892 return false
1893}
1894
Chris Parsons8d6e4332021-02-22 16:13:50 -05001895func (c *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
Ronald Braunstein6a08d492024-04-15 12:55:30 -07001896 ctx := moduleContextFromAndroidModuleContext(actx, c)
1897
Inseob Kim37e0bb02024-04-29 15:54:44 +09001898 c.logtagsPaths = android.PathsForModuleSrc(actx, c.Properties.Logtags)
1899 android.SetProvider(ctx, android.LogtagsProviderKey, &android.LogtagsInfo{
1900 Logtags: c.logtagsPaths,
1901 })
1902
Ronald Braunstein6a08d492024-04-15 12:55:30 -07001903 // If Test_only is set on a module in bp file, respect the setting, otherwise
1904 // see if is a known test module type.
1905 testOnly := c.testModule || c.testLibrary()
1906 if c.sourceProperties.Test_only != nil {
1907 testOnly = Bool(c.sourceProperties.Test_only)
1908 }
1909 // Keep before any early returns.
1910 android.SetProvider(ctx, android.TestOnlyProviderKey, android.TestModuleInformation{
1911 TestOnly: testOnly,
1912 TopLevelTarget: c.testModule,
1913 })
1914
Ivan Lozanof1868af2022-04-12 13:08:36 -04001915 c.Properties.SubName = GetSubnameProperty(actx, c)
Colin Crossff694a82023-12-13 15:54:49 -08001916 apexInfo, _ := android.ModuleProvider(actx, android.ApexInfoProvider)
Chris Parsons8d6e4332021-02-22 16:13:50 -05001917 if !apexInfo.IsForPlatform() {
1918 c.hideApexVariantFromMake = true
1919 }
1920
Chris Parsonseefc9e62021-04-02 17:36:47 -04001921 c.makeLinkType = GetMakeLinkType(actx, c)
1922
Colin Crossf18e1102017-11-16 14:33:08 -08001923 deps := c.depsToPaths(ctx)
1924 if ctx.Failed() {
1925 return
1926 }
1927
Joe Onorato37f900c2023-07-18 16:58:16 -07001928 for _, generator := range c.generators {
1929 gen := generator.GeneratorSources(ctx)
1930 deps.IncludeDirs = append(deps.IncludeDirs, gen.IncludeDirs...)
1931 deps.ReexportedDirs = append(deps.ReexportedDirs, gen.ReexportedDirs...)
1932 deps.GeneratedDeps = append(deps.GeneratedDeps, gen.Headers...)
1933 deps.ReexportedGeneratedHeaders = append(deps.ReexportedGeneratedHeaders, gen.Headers...)
1934 deps.ReexportedDeps = append(deps.ReexportedDeps, gen.Headers...)
1935 if len(deps.Objs.objFiles) == 0 {
1936 // If we are reusuing object files (which happens when we're a shared library and we're
1937 // reusing our static variant's object files), then skip adding the actual source files,
1938 // because we already have the object for it.
1939 deps.GeneratedSources = append(deps.GeneratedSources, gen.Sources...)
1940 }
1941 }
1942
1943 if ctx.Failed() {
1944 return
1945 }
1946
Spandan Das20fce2d2023-04-12 17:21:39 +00001947 if c.stubLibraryMultipleApexViolation(actx) {
1948 actx.PropertyErrorf("apex_available",
1949 "Stub libraries should have a single apex_available (test apexes excluded). Got %v", c.ApexAvailable())
1950 }
Dan Willemsen8536d6b2018-10-07 20:54:34 -07001951 if c.Properties.Clang != nil && *c.Properties.Clang == false {
1952 ctx.PropertyErrorf("clang", "false (GCC) is no longer supported")
Alixb5f6d9e2022-04-20 23:00:58 +00001953 } else if c.Properties.Clang != nil && !ctx.DeviceConfig().BuildBrokenClangProperty() {
1954 ctx.PropertyErrorf("clang", "property is deprecated, see Changes.md file")
Dan Willemsen8536d6b2018-10-07 20:54:34 -07001955 }
1956
Colin Crossca860ac2016-01-04 14:34:37 -08001957 flags := Flags{
1958 Toolchain: c.toolchain(ctx),
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001959 EmitXrefs: ctx.Config().EmitXrefRules(),
Colin Crossca860ac2016-01-04 14:34:37 -08001960 }
Joe Onorato37f900c2023-07-18 16:58:16 -07001961 for _, generator := range c.generators {
1962 flags = generator.GeneratorFlags(ctx, flags, deps)
1963 }
Colin Crossca860ac2016-01-04 14:34:37 -08001964 if c.compiler != nil {
Colin Crossf18e1102017-11-16 14:33:08 -08001965 flags = c.compiler.compilerFlags(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001966 }
1967 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001968 flags = c.linker.linkerFlags(ctx, flags)
Colin Crossca860ac2016-01-04 14:34:37 -08001969 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001970 if c.stl != nil {
1971 flags = c.stl.flags(ctx, flags)
1972 }
Colin Cross16b23492016-01-06 14:41:07 -08001973 if c.sanitize != nil {
1974 flags = c.sanitize.flags(ctx, flags)
1975 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001976 if c.coverage != nil {
Pirama Arumuga Nainar82fe59b2019-07-02 14:55:35 -07001977 flags, deps = c.coverage.flags(ctx, flags, deps)
Dan Willemsen581341d2017-02-09 16:16:31 -08001978 }
Cory Barkera1da26f2022-06-07 20:12:06 +00001979 if c.fuzzer != nil {
1980 flags = c.fuzzer.flags(ctx, flags)
1981 }
Stephen Craneba090d12017-05-09 15:44:35 -07001982 if c.lto != nil {
1983 flags = c.lto.flags(ctx, flags)
1984 }
Yi Kongeb8efc92021-12-09 18:06:29 +08001985 if c.afdo != nil {
1986 flags = c.afdo.flags(ctx, flags)
1987 }
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001988 if c.orderfile != nil {
1989 flags = c.orderfile.flags(ctx, flags)
1990 }
Colin Crossca860ac2016-01-04 14:34:37 -08001991 for _, feature := range c.features {
1992 flags = feature.flags(ctx, flags)
1993 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001994 if ctx.Failed() {
1995 return
1996 }
1997
Colin Cross4af21ed2019-11-04 09:37:55 -08001998 flags.Local.CFlags, _ = filterList(flags.Local.CFlags, config.IllegalFlags)
1999 flags.Local.CppFlags, _ = filterList(flags.Local.CppFlags, config.IllegalFlags)
2000 flags.Local.ConlyFlags, _ = filterList(flags.Local.ConlyFlags, config.IllegalFlags)
Colin Cross3f40fa42015-01-30 17:27:36 -08002001
Colin Cross4af21ed2019-11-04 09:37:55 -08002002 flags.Local.CommonFlags = append(flags.Local.CommonFlags, deps.Flags...)
Inseob Kim69378442019-06-03 19:10:47 +09002003
2004 for _, dir := range deps.IncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08002005 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-I"+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09002006 }
2007 for _, dir := range deps.SystemIncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08002008 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-isystem "+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09002009 }
2010
Colin Cross3e5e7782022-06-17 22:17:05 +00002011 flags.Local.LdFlags = append(flags.Local.LdFlags, deps.LdFlags...)
2012
Fabien Sanglardd61f1f42017-01-10 16:21:22 -08002013 c.flags = flags
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -07002014 // We need access to all the flags seen by a source file.
2015 if c.sabi != nil {
2016 flags = c.sabi.flags(ctx, flags)
2017 }
Dan Willemsen98ab3112019-08-27 21:20:40 -07002018
Colin Cross4af21ed2019-11-04 09:37:55 -08002019 flags.AssemblerWithCpp = inList("-xassembler-with-cpp", flags.Local.AsFlags)
Dan Willemsen98ab3112019-08-27 21:20:40 -07002020
Joe Onorato37f900c2023-07-18 16:58:16 -07002021 for _, generator := range c.generators {
2022 generator.GeneratorBuildActions(ctx, flags, deps)
2023 }
2024
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002025 var objs Objects
Colin Crossca860ac2016-01-04 14:34:37 -08002026 if c.compiler != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002027 objs = c.compiler.compile(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08002028 if ctx.Failed() {
2029 return
2030 }
Sasha Smundak2a4549e2018-11-05 16:49:08 -08002031 c.kytheFiles = objs.kytheFiles
Chih-Hung Hsieh80783772021-10-11 16:46:56 -07002032 c.objFiles = objs.objFiles
2033 c.tidyFiles = objs.tidyFiles
Colin Cross3f40fa42015-01-30 17:27:36 -08002034 }
2035
Colin Crossca860ac2016-01-04 14:34:37 -08002036 if c.linker != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002037 outputFile := c.linker.link(ctx, flags, deps, objs)
Colin Crossca860ac2016-01-04 14:34:37 -08002038 if ctx.Failed() {
2039 return
2040 }
Colin Cross635c3b02016-05-18 15:37:25 -07002041 c.outputFile = android.OptionalPathForPath(outputFile)
Jiyong Parkb0788572018-12-20 22:10:17 +09002042
Chris Parsons94a0bba2021-06-04 15:03:47 -04002043 c.maybeUnhideFromMake()
Colin Crossb614cd42024-10-11 12:52:21 -07002044
2045 android.SetProvider(ctx, ImplementationDepInfoProvider, &ImplementationDepInfo{
2046 ImplementationDeps: depset.New(depset.PREORDER, deps.directImplementationDeps, deps.transitiveImplementationDeps),
2047 })
Colin Crossce75d2c2016-10-06 16:12:58 -07002048 }
Ronald Braunsteina115e262024-04-09 18:07:38 -07002049
Colin Cross40213022023-12-13 15:19:49 -08002050 android.SetProvider(ctx, blueprint.SrcsFileProviderKey, blueprint.SrcsFileProviderData{SrcPaths: deps.GeneratedSources.Strings()})
Colin Cross5049f022015-03-18 13:28:46 -07002051
Hao Chen1c8ea5b2023-10-20 23:03:45 +00002052 if Bool(c.Properties.Cmake_snapshot_supported) {
2053 android.SetProvider(ctx, cmakeSnapshotSourcesProvider, android.GlobFiles(ctx, ctx.ModuleDir()+"/**/*", nil))
2054 }
2055
Chris Parsons94a0bba2021-06-04 15:03:47 -04002056 c.maybeInstall(ctx, apexInfo)
Colin Cross4a9e6ec2023-12-18 15:29:41 -08002057
2058 if c.linker != nil {
2059 moduleInfoJSON := ctx.ModuleInfoJSON()
2060 c.linker.moduleInfoJSON(ctx, moduleInfoJSON)
2061 moduleInfoJSON.SharedLibs = c.Properties.AndroidMkSharedLibs
2062 moduleInfoJSON.StaticLibs = c.Properties.AndroidMkStaticLibs
2063 moduleInfoJSON.SystemSharedLibs = c.Properties.AndroidMkSystemSharedLibs
2064 moduleInfoJSON.RuntimeDependencies = c.Properties.AndroidMkRuntimeLibs
2065
2066 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkSharedLibs...)
2067 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkStaticLibs...)
2068 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkHeaderLibs...)
2069 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkWholeStaticLibs...)
2070
2071 if c.sanitize != nil && len(moduleInfoJSON.Class) > 0 &&
2072 (moduleInfoJSON.Class[0] == "STATIC_LIBRARIES" || moduleInfoJSON.Class[0] == "HEADER_LIBRARIES") {
2073 if Bool(c.sanitize.Properties.SanitizeMutated.Cfi) {
2074 moduleInfoJSON.SubName += ".cfi"
2075 }
2076 if Bool(c.sanitize.Properties.SanitizeMutated.Hwaddress) {
2077 moduleInfoJSON.SubName += ".hwasan"
2078 }
2079 if Bool(c.sanitize.Properties.SanitizeMutated.Scs) {
2080 moduleInfoJSON.SubName += ".scs"
2081 }
2082 }
2083 moduleInfoJSON.SubName += c.Properties.SubName
2084
2085 if c.Properties.IsSdkVariant && c.Properties.SdkAndPlatformVariantVisibleToMake {
2086 moduleInfoJSON.Uninstallable = true
2087 }
Colin Cross4a9e6ec2023-12-18 15:29:41 -08002088 }
Wei Lia1aa2972024-06-21 13:08:51 -07002089
2090 buildComplianceMetadataInfo(ctx, c, deps)
mrziwangabdb2932024-06-18 12:43:41 -07002091
Cole Faust96a692b2024-08-08 14:47:51 -07002092 if b, ok := c.compiler.(*baseCompiler); ok {
2093 c.hasAidl = b.hasSrcExt(ctx, ".aidl")
2094 c.hasLex = b.hasSrcExt(ctx, ".l") || b.hasSrcExt(ctx, ".ll")
2095 c.hasProto = b.hasSrcExt(ctx, ".proto")
2096 c.hasRenderscript = b.hasSrcExt(ctx, ".rscript") || b.hasSrcExt(ctx, ".fs")
2097 c.hasSysprop = b.hasSrcExt(ctx, ".sysprop")
2098 c.hasWinMsg = b.hasSrcExt(ctx, ".mc")
2099 c.hasYacc = b.hasSrcExt(ctx, ".y") || b.hasSrcExt(ctx, ".yy")
2100 }
2101
mrziwangabdb2932024-06-18 12:43:41 -07002102 c.setOutputFiles(ctx)
2103}
2104
2105func (c *Module) setOutputFiles(ctx ModuleContext) {
2106 if c.outputFile.Valid() {
2107 ctx.SetOutputFiles(android.Paths{c.outputFile.Path()}, "")
2108 } else {
2109 ctx.SetOutputFiles(android.Paths{}, "")
2110 }
2111 if c.linker != nil {
2112 ctx.SetOutputFiles(android.PathsIfNonNil(c.linker.unstrippedOutputFilePath()), "unstripped")
2113 ctx.SetOutputFiles(android.PathsIfNonNil(c.linker.strippedAllOutputFilePath()), "stripped_all")
2114 }
Wei Lia1aa2972024-06-21 13:08:51 -07002115}
2116
2117func buildComplianceMetadataInfo(ctx ModuleContext, c *Module, deps PathDeps) {
2118 // Dump metadata that can not be done in android/compliance-metadata.go
2119 complianceMetadataInfo := ctx.ComplianceMetadataInfo()
2120 complianceMetadataInfo.SetStringValue(android.ComplianceMetadataProp.IS_STATIC_LIB, strconv.FormatBool(ctx.static()))
2121 complianceMetadataInfo.SetStringValue(android.ComplianceMetadataProp.BUILT_FILES, c.outputFile.String())
2122
2123 // Static deps
2124 staticDeps := ctx.GetDirectDepsWithTag(StaticDepTag(false))
2125 staticDepNames := make([]string, 0, len(staticDeps))
2126 for _, dep := range staticDeps {
2127 staticDepNames = append(staticDepNames, dep.Name())
2128 }
2129
2130 staticDepPaths := make([]string, 0, len(deps.StaticLibs))
2131 for _, dep := range deps.StaticLibs {
2132 staticDepPaths = append(staticDepPaths, dep.String())
2133 }
2134 complianceMetadataInfo.SetListValue(android.ComplianceMetadataProp.STATIC_DEPS, android.FirstUniqueStrings(staticDepNames))
2135 complianceMetadataInfo.SetListValue(android.ComplianceMetadataProp.STATIC_DEP_FILES, android.FirstUniqueStrings(staticDepPaths))
2136
2137 // Whole static deps
2138 wholeStaticDeps := ctx.GetDirectDepsWithTag(StaticDepTag(true))
2139 wholeStaticDepNames := make([]string, 0, len(wholeStaticDeps))
2140 for _, dep := range wholeStaticDeps {
2141 wholeStaticDepNames = append(wholeStaticDepNames, dep.Name())
2142 }
2143
2144 wholeStaticDepPaths := make([]string, 0, len(deps.WholeStaticLibs))
2145 for _, dep := range deps.WholeStaticLibs {
2146 wholeStaticDepPaths = append(wholeStaticDepPaths, dep.String())
2147 }
2148 complianceMetadataInfo.SetListValue(android.ComplianceMetadataProp.WHOLE_STATIC_DEPS, android.FirstUniqueStrings(wholeStaticDepNames))
2149 complianceMetadataInfo.SetListValue(android.ComplianceMetadataProp.WHOLE_STATIC_DEP_FILES, android.FirstUniqueStrings(wholeStaticDepPaths))
Chris Parsons94a0bba2021-06-04 15:03:47 -04002150}
2151
2152func (c *Module) maybeUnhideFromMake() {
2153 // If a lib is directly included in any of the APEXes or is not available to the
2154 // platform (which is often the case when the stub is provided as a prebuilt),
2155 // unhide the stubs variant having the latest version gets visible to make. In
2156 // addition, the non-stubs variant is renamed to <libname>.bootstrap. This is to
2157 // force anything in the make world to link against the stubs library. (unless it
2158 // is explicitly referenced via .bootstrap suffix or the module is marked with
2159 // 'bootstrap: true').
2160 if c.HasStubsVariants() && c.NotInPlatform() && !c.InRamdisk() &&
Kiyoung Kimaa394802024-01-08 12:55:45 +09002161 !c.InRecovery() && !c.InVendorOrProduct() && !c.static() && !c.isCoverageVariant() &&
Chris Parsons94a0bba2021-06-04 15:03:47 -04002162 c.IsStubs() && !c.InVendorRamdisk() {
2163 c.Properties.HideFromMake = false // unhide
2164 // Note: this is still non-installable
2165 }
2166}
2167
Colin Cross8ff10582023-12-07 13:10:56 -08002168// maybeInstall is called at the end of both GenerateAndroidBuildActions to run the
2169// install hooks for installable modules, like binaries and tests.
Chris Parsons94a0bba2021-06-04 15:03:47 -04002170func (c *Module) maybeInstall(ctx ModuleContext, apexInfo android.ApexInfo) {
Colin Cross1bc94122021-10-28 13:25:54 -07002171 if !proptools.BoolDefault(c.Installable(), true) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002172 // If the module has been specifically configure to not be installed then
2173 // hide from make as otherwise it will break when running inside make
2174 // as the output path to install will not be specified. Not all uninstallable
2175 // modules can be hidden from make as some are needed for resolving make side
2176 // dependencies.
2177 c.HideFromMake()
Ivan Lozanod7586b62021-04-01 09:49:36 -04002178 } else if !installable(c, apexInfo) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002179 c.SkipInstall()
2180 }
2181
2182 // Still call c.installer.install though, the installs will be stored as PackageSpecs
2183 // to allow using the outputs in a genrule.
2184 if c.installer != nil && c.outputFile.Valid() {
Colin Crossce75d2c2016-10-06 16:12:58 -07002185 c.installer.install(ctx, c.outputFile.Path())
2186 if ctx.Failed() {
2187 return
Colin Crossca860ac2016-01-04 14:34:37 -08002188 }
Dan Albertc403f7c2015-03-18 14:01:18 -07002189 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002190}
2191
Colin Cross0ea8ba82019-06-06 14:33:29 -07002192func (c *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08002193 if c.cachedToolchain == nil {
Liz Kammer356f7d42021-01-26 09:18:53 -05002194 c.cachedToolchain = config.FindToolchainWithContext(ctx)
Colin Cross3f40fa42015-01-30 17:27:36 -08002195 }
Colin Crossca860ac2016-01-04 14:34:37 -08002196 return c.cachedToolchain
Colin Cross3f40fa42015-01-30 17:27:36 -08002197}
2198
Colin Crossca860ac2016-01-04 14:34:37 -08002199func (c *Module) begin(ctx BaseModuleContext) {
Joe Onorato37f900c2023-07-18 16:58:16 -07002200 for _, generator := range c.generators {
2201 generator.GeneratorInit(ctx)
2202 }
Colin Crossca860ac2016-01-04 14:34:37 -08002203 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002204 c.compiler.compilerInit(ctx)
Colin Cross21b9a242015-03-24 14:15:58 -07002205 }
Colin Crossca860ac2016-01-04 14:34:37 -08002206 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002207 c.linker.linkerInit(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08002208 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002209 if c.stl != nil {
2210 c.stl.begin(ctx)
2211 }
Colin Cross16b23492016-01-06 14:41:07 -08002212 if c.sanitize != nil {
2213 c.sanitize.begin(ctx)
2214 }
Dan Willemsen581341d2017-02-09 16:16:31 -08002215 if c.coverage != nil {
2216 c.coverage.begin(ctx)
2217 }
Yi Kong9723e332023-12-04 14:52:53 +09002218 if c.afdo != nil {
2219 c.afdo.begin(ctx)
2220 }
Stephen Craneba090d12017-05-09 15:44:35 -07002221 if c.lto != nil {
2222 c.lto.begin(ctx)
2223 }
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00002224 if c.orderfile != nil {
2225 c.orderfile.begin(ctx)
2226 }
Dan Albert92fe7402020-07-15 13:33:30 -07002227 if ctx.useSdk() && c.IsSdkVariant() {
Dan Albert1a246272020-07-06 14:49:35 -07002228 version, err := nativeApiLevelFromUser(ctx, ctx.sdkVersion())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002229 if err != nil {
2230 ctx.PropertyErrorf("sdk_version", err.Error())
Dan Albert1a246272020-07-06 14:49:35 -07002231 c.Properties.Sdk_version = nil
2232 } else {
2233 c.Properties.Sdk_version = StringPtr(version.String())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002234 }
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002235 }
Colin Crossca860ac2016-01-04 14:34:37 -08002236}
2237
Colin Cross37047f12016-12-13 17:06:13 -08002238func (c *Module) deps(ctx DepsContext) Deps {
Colin Crossc99deeb2016-04-11 15:06:20 -07002239 deps := Deps{}
2240
Joe Onorato37f900c2023-07-18 16:58:16 -07002241 for _, generator := range c.generators {
2242 deps = generator.GeneratorDeps(ctx, deps)
2243 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002244 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002245 deps = c.compiler.compilerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002246 }
2247 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002248 deps = c.linker.linkerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002249 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002250 if c.stl != nil {
2251 deps = c.stl.deps(ctx, deps)
2252 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00002253 if c.coverage != nil {
2254 deps = c.coverage.deps(ctx, deps)
2255 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002256
Colin Crossb6715442017-10-24 11:13:31 -07002257 deps.WholeStaticLibs = android.LastUniqueStrings(deps.WholeStaticLibs)
2258 deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
2259 deps.LateStaticLibs = android.LastUniqueStrings(deps.LateStaticLibs)
2260 deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
2261 deps.LateSharedLibs = android.LastUniqueStrings(deps.LateSharedLibs)
2262 deps.HeaderLibs = android.LastUniqueStrings(deps.HeaderLibs)
Logan Chien43d34c32017-12-20 01:17:32 +08002263 deps.RuntimeLibs = android.LastUniqueStrings(deps.RuntimeLibs)
Hsin-Yi Chen715142a2024-03-27 16:31:16 +08002264 deps.LlndkHeaderLibs = android.LastUniqueStrings(deps.LlndkHeaderLibs)
Colin Crossc99deeb2016-04-11 15:06:20 -07002265
Colin Cross516c5452024-10-28 13:45:21 -07002266 if err := checkConflictingExplicitVersions(deps.SharedLibs); err != nil {
2267 ctx.PropertyErrorf("shared_libs", "%s", err.Error())
2268 }
2269
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002270 for _, lib := range deps.ReexportSharedLibHeaders {
2271 if !inList(lib, deps.SharedLibs) {
2272 ctx.PropertyErrorf("export_shared_lib_headers", "Shared library not in shared_libs: '%s'", lib)
2273 }
2274 }
2275
2276 for _, lib := range deps.ReexportStaticLibHeaders {
Steven Morelandba407c82021-04-01 22:17:50 +00002277 if !inList(lib, deps.StaticLibs) && !inList(lib, deps.WholeStaticLibs) {
2278 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 -07002279 }
2280 }
2281
Colin Cross5950f382016-12-13 12:50:57 -08002282 for _, lib := range deps.ReexportHeaderLibHeaders {
2283 if !inList(lib, deps.HeaderLibs) {
2284 ctx.PropertyErrorf("export_header_lib_headers", "Header library not in header_libs: '%s'", lib)
2285 }
2286 }
2287
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002288 for _, gen := range deps.ReexportGeneratedHeaders {
2289 if !inList(gen, deps.GeneratedHeaders) {
2290 ctx.PropertyErrorf("export_generated_headers", "Generated header module not in generated_headers: '%s'", gen)
2291 }
2292 }
2293
Colin Crossc99deeb2016-04-11 15:06:20 -07002294 return deps
2295}
2296
Colin Cross516c5452024-10-28 13:45:21 -07002297func checkConflictingExplicitVersions(libs []string) error {
2298 withoutVersion := func(s string) string {
2299 name, _ := StubsLibNameAndVersion(s)
2300 return name
2301 }
2302 var errs []error
2303 for i, lib := range libs {
2304 libName := withoutVersion(lib)
2305 libsToCompare := libs[i+1:]
2306 j := slices.IndexFunc(libsToCompare, func(s string) bool {
2307 return withoutVersion(s) == libName
2308 })
2309 if j >= 0 {
2310 errs = append(errs, fmt.Errorf("duplicate shared libraries with different explicit versions: %q and %q",
2311 lib, libsToCompare[j]))
2312 }
2313 }
2314 return errors.Join(errs...)
2315}
2316
Dan Albert7e9d2952016-08-04 13:02:36 -07002317func (c *Module) beginMutator(actx android.BottomUpMutatorContext) {
Colin Crossca860ac2016-01-04 14:34:37 -08002318 ctx := &baseModuleContext{
Colin Cross0ea8ba82019-06-06 14:33:29 -07002319 BaseModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08002320 moduleContextImpl: moduleContextImpl{
2321 mod: c,
2322 },
2323 }
2324 ctx.ctx = ctx
2325
Colin Crossca860ac2016-01-04 14:34:37 -08002326 c.begin(ctx)
Dan Albert7e9d2952016-08-04 13:02:36 -07002327}
2328
Jiyong Park7ed9de32018-10-15 22:25:07 +09002329// Split name#version into name and version
Jiyong Park73c54ee2019-10-22 20:31:18 +09002330func StubsLibNameAndVersion(name string) (string, string) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002331 if sharp := strings.LastIndex(name, "#"); sharp != -1 && sharp != len(name)-1 {
2332 version := name[sharp+1:]
2333 libname := name[:sharp]
2334 return libname, version
2335 }
2336 return name, ""
2337}
2338
Dan Albert92fe7402020-07-15 13:33:30 -07002339func GetCrtVariations(ctx android.BottomUpMutatorContext,
2340 m LinkableInterface) []blueprint.Variation {
2341 if ctx.Os() != android.Android {
2342 return nil
2343 }
2344 if m.UseSdk() {
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09002345 // Choose the CRT that best satisfies the min_sdk_version requirement of this module
2346 minSdkVersion := m.MinSdkVersion()
2347 if minSdkVersion == "" || minSdkVersion == "apex_inherit" {
2348 minSdkVersion = m.SdkVersion()
2349 }
Jooyung Han94a76ee2021-06-08 09:49:48 +09002350 apiLevel, err := android.ApiLevelFromUser(ctx, minSdkVersion)
2351 if err != nil {
2352 ctx.PropertyErrorf("min_sdk_version", err.Error())
2353 }
Colin Cross363ec762023-01-13 13:45:14 -08002354
2355 // Raise the minSdkVersion to the minimum supported for the architecture.
Colin Crossbb137a32023-01-26 09:54:42 -08002356 minApiForArch := MinApiForArch(ctx, m.Target().Arch.ArchType)
Colin Cross363ec762023-01-13 13:45:14 -08002357 if apiLevel.LessThan(minApiForArch) {
2358 apiLevel = minApiForArch
2359 }
2360
Dan Albert92fe7402020-07-15 13:33:30 -07002361 return []blueprint.Variation{
2362 {Mutator: "sdk", Variation: "sdk"},
Jooyung Han94a76ee2021-06-08 09:49:48 +09002363 {Mutator: "version", Variation: apiLevel.String()},
Dan Albert92fe7402020-07-15 13:33:30 -07002364 }
2365 }
2366 return []blueprint.Variation{
2367 {Mutator: "sdk", Variation: ""},
2368 }
2369}
2370
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002371func AddSharedLibDependenciesWithVersions(ctx android.BottomUpMutatorContext, mod LinkableInterface,
2372 variations []blueprint.Variation, depTag blueprint.DependencyTag, name, version string, far bool) {
Colin Crosse7257d22020-09-24 09:56:18 -07002373
2374 variations = append([]blueprint.Variation(nil), variations...)
2375
Liz Kammer23942242022-04-08 15:41:00 -04002376 if version != "" && canBeOrLinkAgainstVersionVariants(mod) {
Colin Crosse7257d22020-09-24 09:56:18 -07002377 // Version is explicitly specified. i.e. libFoo#30
Colin Crossb614cd42024-10-11 12:52:21 -07002378 if version == "impl" {
2379 version = ""
2380 }
Colin Crosse7257d22020-09-24 09:56:18 -07002381 variations = append(variations, blueprint.Variation{Mutator: "version", Variation: version})
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002382 if tag, ok := depTag.(libraryDependencyTag); ok {
2383 tag.explicitlyVersioned = true
Colin Crossafcdce82024-10-22 13:59:33 -07002384 // depTag is an interface that contains a concrete non-pointer struct. That makes the local
2385 // tag variable a copy of the contents of depTag, and updating it doesn't change depTag. Reassign
2386 // the modified copy to depTag.
2387 depTag = tag
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002388 } else {
2389 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
2390 }
Colin Crosse7257d22020-09-24 09:56:18 -07002391 }
Colin Crosse7257d22020-09-24 09:56:18 -07002392
Colin Cross0de8a1e2020-09-18 14:15:30 -07002393 if far {
2394 ctx.AddFarVariationDependencies(variations, depTag, name)
2395 } else {
2396 ctx.AddVariationDependencies(variations, depTag, name)
Colin Crosse7257d22020-09-24 09:56:18 -07002397 }
2398}
2399
Kiyoung Kim487689e2022-07-26 09:48:22 +09002400func GetReplaceModuleName(lib string, replaceMap map[string]string) string {
2401 if snapshot, ok := replaceMap[lib]; ok {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002402 return snapshot
2403 }
2404
2405 return lib
2406}
2407
Kiyoung Kim37693d02024-04-04 09:56:15 +09002408// FilterNdkLibs takes a list of names of shared libraries and scans it for two types
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002409// of names:
2410//
Kiyoung Kim37693d02024-04-04 09:56:15 +09002411// 1. Name of an NDK library that refers to an ndk_library module.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002412//
2413// For each of these, it adds the name of the ndk_library module to the list of
2414// variant libs.
2415//
Kiyoung Kim37693d02024-04-04 09:56:15 +09002416// 2. Anything else (so anything that isn't an NDK library).
Kiyoung Kim487689e2022-07-26 09:48:22 +09002417//
2418// It adds these to the nonvariantLibs list.
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002419//
2420// The caller can then know to add the variantLibs dependencies differently from the
2421// nonvariantLibs
Kiyoung Kim37693d02024-04-04 09:56:15 +09002422func FilterNdkLibs(c LinkableInterface, config android.Config, list []string) (nonvariantLibs []string, variantLibs []string) {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002423 variantLibs = []string{}
2424
2425 nonvariantLibs = []string{}
2426 for _, entry := range list {
2427 // strip #version suffix out
2428 name, _ := StubsLibNameAndVersion(entry)
Kiyoung Kim37693d02024-04-04 09:56:15 +09002429 if c.UseSdk() && inList(name, *getNDKKnownLibs(config)) {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002430 variantLibs = append(variantLibs, name+ndkLibrarySuffix)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002431 } else {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002432 nonvariantLibs = append(nonvariantLibs, entry)
2433 }
2434 }
2435 return nonvariantLibs, variantLibs
Kiyoung Kim37693d02024-04-04 09:56:15 +09002436
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002437}
2438
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002439func rewriteLibsForApiImports(c LinkableInterface, libs []string, replaceList map[string]string, config android.Config) ([]string, []string) {
2440 nonVariantLibs := []string{}
2441 variantLibs := []string{}
2442
2443 for _, lib := range libs {
2444 replaceLibName := GetReplaceModuleName(lib, replaceList)
2445 if replaceLibName == lib {
2446 // Do not handle any libs which are not in API imports
2447 nonVariantLibs = append(nonVariantLibs, replaceLibName)
2448 } else if c.UseSdk() && inList(replaceLibName, *getNDKKnownLibs(config)) {
2449 variantLibs = append(variantLibs, replaceLibName)
2450 } else {
2451 nonVariantLibs = append(nonVariantLibs, replaceLibName)
2452 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002453 }
2454
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002455 return nonVariantLibs, variantLibs
Kiyoung Kim487689e2022-07-26 09:48:22 +09002456}
2457
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002458func (c *Module) shouldUseApiSurface() bool {
2459 if c.Os() == android.Android && c.Target().NativeBridge != android.NativeBridgeEnabled {
2460 if GetImageVariantType(c) == vendorImageVariant || GetImageVariantType(c) == productImageVariant {
2461 // LLNDK Variant
2462 return true
2463 }
2464
2465 if c.Properties.IsSdkVariant {
2466 // NDK Variant
2467 return true
2468 }
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002469 }
2470
2471 return false
2472}
2473
Colin Cross1e676be2016-10-12 14:38:15 -07002474func (c *Module) DepsMutator(actx android.BottomUpMutatorContext) {
Cole Fausta963b942024-04-11 17:43:00 -07002475 if !c.Enabled(actx) {
Inseob Kimeec88e12020-01-22 11:11:29 +09002476 return
2477 }
2478
Colin Cross37047f12016-12-13 17:06:13 -08002479 ctx := &depsContext{
2480 BottomUpMutatorContext: actx,
Dan Albert7e9d2952016-08-04 13:02:36 -07002481 moduleContextImpl: moduleContextImpl{
2482 mod: c,
2483 },
2484 }
2485 ctx.ctx = ctx
Colin Crossca860ac2016-01-04 14:34:37 -08002486
Colin Crossc99deeb2016-04-11 15:06:20 -07002487 deps := c.deps(ctx)
Kiyoung Kim11d91082022-10-19 19:20:57 +09002488
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002489 apiNdkLibs := []string{}
2490 apiLateNdkLibs := []string{}
2491
Yo Chiang219968c2020-09-22 18:45:04 +08002492 c.Properties.AndroidMkSystemSharedLibs = deps.SystemSharedLibs
2493
Dan Albert914449f2016-06-17 16:45:24 -07002494 variantNdkLibs := []string{}
2495 variantLateNdkLibs := []string{}
Dan Willemsenb916b802017-03-19 13:44:32 -07002496 if ctx.Os() == android.Android {
Kiyoung Kim37693d02024-04-04 09:56:15 +09002497 deps.SharedLibs, variantNdkLibs = FilterNdkLibs(c, ctx.Config(), deps.SharedLibs)
2498 deps.LateSharedLibs, variantLateNdkLibs = FilterNdkLibs(c, ctx.Config(), deps.LateSharedLibs)
2499 deps.ReexportSharedLibHeaders, _ = FilterNdkLibs(c, ctx.Config(), deps.ReexportSharedLibHeaders)
Dan Willemsen72d39932016-07-08 23:23:48 -07002500 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002501
Colin Cross32ec36c2016-12-15 07:39:51 -08002502 for _, lib := range deps.HeaderLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002503 depTag := libraryDependencyTag{Kind: headerLibraryDependency}
Colin Cross32ec36c2016-12-15 07:39:51 -08002504 if inList(lib, deps.ReexportHeaderLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002505 depTag.reexportFlags = true
Colin Cross32ec36c2016-12-15 07:39:51 -08002506 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002507
Spandan Das73bcafc2022-08-18 23:26:00 +00002508 if c.isNDKStubLibrary() {
Jiyong Parkf8fab9b2024-09-02 15:24:15 +09002509 variationExists := actx.OtherModuleDependencyVariantExists(nil, lib)
2510 if variationExists {
2511 actx.AddVariationDependencies(nil, depTag, lib)
2512 } else {
2513 // dependencies to ndk_headers fall here as ndk_headers do not have
2514 // any variants.
2515 actx.AddFarVariationDependencies([]blueprint.Variation{}, depTag, lib)
2516 }
Spandan Dasff665182024-09-11 18:48:44 +00002517 } else if c.IsStubs() {
Colin Cross7228ecd2019-11-18 16:00:16 -08002518 actx.AddFarVariationDependencies(append(ctx.Target().Variations(), c.ImageVariation()),
Colin Cross0f7d2ef2019-10-16 11:03:10 -07002519 depTag, lib)
Jiyong Park7e636d02019-01-28 16:16:54 +09002520 } else {
2521 actx.AddVariationDependencies(nil, depTag, lib)
2522 }
2523 }
2524
Dan Albertf1d14c72020-07-30 14:32:55 -07002525 if c.isNDKStubLibrary() {
2526 // NDK stubs depend on their implementation because the ABI dumps are
2527 // generated from the implementation library.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002528
Spandan Das8b08aea2023-03-14 19:29:34 +00002529 actx.AddFarVariationDependencies(append(ctx.Target().Variations(),
2530 c.ImageVariation(),
2531 blueprint.Variation{Mutator: "link", Variation: "shared"},
2532 ), stubImplementation, c.BaseModuleName())
Dan Albertf1d14c72020-07-30 14:32:55 -07002533 }
2534
Hsin-Yi Chen715142a2024-03-27 16:31:16 +08002535 // If this module is an LLNDK implementation library, let it depend on LlndkHeaderLibs.
2536 if c.ImageVariation().Variation == android.CoreVariation && c.Device() &&
2537 c.Target().NativeBridge == android.NativeBridgeDisabled {
2538 actx.AddVariationDependencies(
Jihoon Kang47e91842024-06-19 00:51:16 +00002539 []blueprint.Variation{{Mutator: "image", Variation: android.VendorVariation}},
Hsin-Yi Chen715142a2024-03-27 16:31:16 +08002540 llndkHeaderLibTag,
2541 deps.LlndkHeaderLibs...)
2542 }
2543
Jiyong Park5d1598f2019-02-25 22:14:17 +09002544 for _, lib := range deps.WholeStaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002545 depTag := libraryDependencyTag{Kind: staticLibraryDependency, wholeStatic: true, reexportFlags: true}
Inseob Kimeec88e12020-01-22 11:11:29 +09002546
Jiyong Park5d1598f2019-02-25 22:14:17 +09002547 actx.AddVariationDependencies([]blueprint.Variation{
2548 {Mutator: "link", Variation: "static"},
2549 }, depTag, lib)
2550 }
2551
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002552 for _, lib := range deps.StaticLibs {
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04002553 // Some dependencies listed in static_libs might actually be rust_ffi rlib variants.
Colin Cross6e511a92020-07-27 21:26:48 -07002554 depTag := libraryDependencyTag{Kind: staticLibraryDependency}
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04002555
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002556 if inList(lib, deps.ReexportStaticLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002557 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002558 }
Jiyong Parke3867542020-12-03 17:28:25 +09002559 if inList(lib, deps.ExcludeLibsForApex) {
2560 depTag.excludeInApex = true
2561 }
Dan Willemsen59339a22018-07-22 21:18:45 -07002562 actx.AddVariationDependencies([]blueprint.Variation{
2563 {Mutator: "link", Variation: "static"},
2564 }, depTag, lib)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002565 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002566
Jooyung Han75568392020-03-20 04:29:24 +09002567 // staticUnwinderDep is treated as staticDep for Q apexes
2568 // so that native libraries/binaries are linked with static unwinder
2569 // because Q libc doesn't have unwinder APIs
2570 if deps.StaticUnwinderIfLegacy {
Colin Cross6e511a92020-07-27 21:26:48 -07002571 depTag := libraryDependencyTag{Kind: staticLibraryDependency, staticUnwinder: true}
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002572 actx.AddVariationDependencies([]blueprint.Variation{
2573 {Mutator: "link", Variation: "static"},
Kiyoung Kim37693d02024-04-04 09:56:15 +09002574 }, depTag, staticUnwinder(actx))
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002575 }
2576
Jiyong Park7ed9de32018-10-15 22:25:07 +09002577 // shared lib names without the #version suffix
2578 var sharedLibNames []string
2579
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002580 for _, lib := range deps.SharedLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002581 depTag := libraryDependencyTag{Kind: sharedLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002582 if inList(lib, deps.ReexportSharedLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002583 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002584 }
Jiyong Parke3867542020-12-03 17:28:25 +09002585 if inList(lib, deps.ExcludeLibsForApex) {
2586 depTag.excludeInApex = true
2587 }
Jooyung Han9ffbe832023-11-28 22:31:35 +09002588 if inList(lib, deps.ExcludeLibsForNonApex) {
2589 depTag.excludeInNonApex = true
2590 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002591
Jiyong Park73c54ee2019-10-22 20:31:18 +09002592 name, version := StubsLibNameAndVersion(lib)
Inseob Kimc0907f12019-02-08 21:00:45 +09002593 sharedLibNames = append(sharedLibNames, name)
2594
Colin Crosse7257d22020-09-24 09:56:18 -07002595 variations := []blueprint.Variation{
2596 {Mutator: "link", Variation: "shared"},
2597 }
Spandan Dasff665182024-09-11 18:48:44 +00002598 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, name, version, false)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002599 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002600
Colin Crossfe9acfe2021-06-14 16:13:03 -07002601 for _, lib := range deps.LateStaticLibs {
2602 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency}
2603 actx.AddVariationDependencies([]blueprint.Variation{
2604 {Mutator: "link", Variation: "static"},
Kiyoung Kim37693d02024-04-04 09:56:15 +09002605 }, depTag, lib)
Colin Crossfe9acfe2021-06-14 16:13:03 -07002606 }
2607
Colin Cross3e5e7782022-06-17 22:17:05 +00002608 for _, lib := range deps.UnexportedStaticLibs {
2609 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency, unexportedSymbols: true}
2610 actx.AddVariationDependencies([]blueprint.Variation{
2611 {Mutator: "link", Variation: "static"},
Kiyoung Kim37693d02024-04-04 09:56:15 +09002612 }, depTag, lib)
Colin Cross3e5e7782022-06-17 22:17:05 +00002613 }
2614
Jiyong Park7ed9de32018-10-15 22:25:07 +09002615 for _, lib := range deps.LateSharedLibs {
Jiyong Park25fc6a92018-11-18 18:02:45 +09002616 if inList(lib, sharedLibNames) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002617 // This is to handle the case that some of the late shared libs (libc, libdl, libm, ...)
2618 // are added also to SharedLibs with version (e.g., libc#10). If not skipped, we will be
2619 // linking against both the stubs lib and the non-stubs lib at the same time.
2620 continue
2621 }
Colin Cross6e511a92020-07-27 21:26:48 -07002622 depTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency}
Colin Crosse7257d22020-09-24 09:56:18 -07002623 variations := []blueprint.Variation{
2624 {Mutator: "link", Variation: "shared"},
2625 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002626 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, lib, "", false)
Jiyong Park7ed9de32018-10-15 22:25:07 +09002627 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002628
Dan Willemsen59339a22018-07-22 21:18:45 -07002629 actx.AddVariationDependencies([]blueprint.Variation{
2630 {Mutator: "link", Variation: "shared"},
Chris Parsons79d66a52020-06-05 17:26:16 -04002631 }, dataLibDepTag, deps.DataLibs...)
2632
Colin Crossc8caa062021-09-24 16:50:14 -07002633 actx.AddVariationDependencies(nil, dataBinDepTag, deps.DataBins...)
2634
Chris Parsons79d66a52020-06-05 17:26:16 -04002635 actx.AddVariationDependencies([]blueprint.Variation{
2636 {Mutator: "link", Variation: "shared"},
Dan Willemsen59339a22018-07-22 21:18:45 -07002637 }, runtimeDepTag, deps.RuntimeLibs...)
Logan Chien43d34c32017-12-20 01:17:32 +08002638
Colin Cross68861832016-07-08 10:41:41 -07002639 actx.AddDependency(c, genSourceDepTag, deps.GeneratedSources...)
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002640
2641 for _, gen := range deps.GeneratedHeaders {
2642 depTag := genHeaderDepTag
2643 if inList(gen, deps.ReexportGeneratedHeaders) {
2644 depTag = genHeaderExportDepTag
2645 }
2646 actx.AddDependency(c, depTag, gen)
2647 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002648
Cole Faust65cb40a2024-10-21 15:41:42 -07002649 for _, gen := range deps.DeviceFirstGeneratedHeaders {
2650 depTag := genHeaderDepTag
2651 actx.AddVariationDependencies(ctx.Config().AndroidFirstDeviceTarget.Variations(), depTag, gen)
2652 }
2653
Dan Albert92fe7402020-07-15 13:33:30 -07002654 crtVariations := GetCrtVariations(ctx, c)
Colin Crossbbc941b2020-09-30 12:27:01 -07002655 actx.AddVariationDependencies(crtVariations, objDepTag, deps.ObjFiles...)
Colin Crossc465efd2021-06-11 18:00:04 -07002656 for _, crt := range deps.CrtBegin {
Dan Albert92fe7402020-07-15 13:33:30 -07002657 actx.AddVariationDependencies(crtVariations, CrtBeginDepTag,
Kiyoung Kim37693d02024-04-04 09:56:15 +09002658 crt)
Colin Crossca860ac2016-01-04 14:34:37 -08002659 }
Colin Crossc465efd2021-06-11 18:00:04 -07002660 for _, crt := range deps.CrtEnd {
Dan Albert92fe7402020-07-15 13:33:30 -07002661 actx.AddVariationDependencies(crtVariations, CrtEndDepTag,
Kiyoung Kim37693d02024-04-04 09:56:15 +09002662 crt)
Colin Cross21b9a242015-03-24 14:15:58 -07002663 }
Dan Willemsena0790e32018-10-12 00:24:23 -07002664 if deps.DynamicLinker != "" {
2665 actx.AddDependency(c, dynamicLinkerDepTag, deps.DynamicLinker)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002666 }
Dan Albert914449f2016-06-17 16:45:24 -07002667
2668 version := ctx.sdkVersion()
Colin Cross6e511a92020-07-27 21:26:48 -07002669
2670 ndkStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002671 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002672 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002673 {Mutator: "link", Variation: "shared"},
2674 }, ndkStubDepTag, variantNdkLibs...)
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002675 actx.AddVariationDependencies([]blueprint.Variation{
2676 {Mutator: "version", Variation: version},
2677 {Mutator: "link", Variation: "shared"},
2678 }, ndkStubDepTag, apiNdkLibs...)
Colin Cross6e511a92020-07-27 21:26:48 -07002679
2680 ndkLateStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002681 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002682 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002683 {Mutator: "link", Variation: "shared"},
2684 }, ndkLateStubDepTag, variantLateNdkLibs...)
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002685 actx.AddVariationDependencies([]blueprint.Variation{
2686 {Mutator: "version", Variation: version},
2687 {Mutator: "link", Variation: "shared"},
2688 }, ndkLateStubDepTag, apiLateNdkLibs...)
Logan Chienf3511742017-10-31 18:04:35 +08002689
Vinh Tran367d89d2023-04-28 11:21:25 -04002690 if len(deps.AidlLibs) > 0 {
2691 actx.AddDependency(
2692 c,
2693 aidlLibraryTag,
2694 deps.AidlLibs...,
2695 )
2696 }
2697
Colin Cross6362e272015-10-29 15:25:03 -07002698}
Colin Cross21b9a242015-03-24 14:15:58 -07002699
Colin Crosse40b4ea2018-10-02 22:25:58 -07002700func BeginMutator(ctx android.BottomUpMutatorContext) {
Cole Fausta963b942024-04-11 17:43:00 -07002701 if c, ok := ctx.Module().(*Module); ok && c.Enabled(ctx) {
Dan Albert7e9d2952016-08-04 13:02:36 -07002702 c.beginMutator(ctx)
2703 }
2704}
2705
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002706// Whether a module can link to another module, taking into
2707// account NDK linking.
Jooyung Han479ca172020-10-19 18:51:07 +09002708func checkLinkType(ctx android.BaseModuleContext, from LinkableInterface, to LinkableInterface,
Colin Cross6e511a92020-07-27 21:26:48 -07002709 tag blueprint.DependencyTag) {
2710
2711 switch t := tag.(type) {
2712 case dependencyTag:
2713 if t != vndkExtDepTag {
2714 return
2715 }
2716 case libraryDependencyTag:
2717 default:
2718 return
2719 }
2720
Ivan Lozanof9e21722020-12-02 09:00:51 -05002721 if from.Target().Os != android.Android {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002722 // Host code is not restricted
2723 return
2724 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002725
Ivan Lozano52767be2019-10-18 14:49:46 -07002726 if from.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002727 // Platform code can link to anything
2728 return
2729 }
Yifan Hong1b3348d2020-01-21 15:53:22 -08002730 if from.InRamdisk() {
2731 // Ramdisk code is not NDK
2732 return
2733 }
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002734 if from.InVendorRamdisk() {
2735 // Vendor ramdisk code is not NDK
2736 return
2737 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002738 if from.InRecovery() {
Jiyong Parkf9332f12018-02-01 00:54:12 +09002739 // Recovery code is not NDK
2740 return
2741 }
Colin Cross31076b32020-10-23 17:22:06 -07002742 if c, ok := to.(*Module); ok {
Colin Cross31076b32020-10-23 17:22:06 -07002743 if c.StubDecorator() {
2744 // These aren't real libraries, but are the stub shared libraries that are included in
2745 // the NDK.
2746 return
2747 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002748 }
Logan Chien834b9a62019-01-14 15:39:03 +08002749
Ivan Lozano52767be2019-10-18 14:49:46 -07002750 if strings.HasPrefix(ctx.ModuleName(), "libclang_rt.") && to.Module().Name() == "libc++" {
Logan Chien834b9a62019-01-14 15:39:03 +08002751 // Bug: http://b/121358700 - Allow libclang_rt.* shared libraries (with sdk_version)
2752 // to link to libc++ (non-NDK and without sdk_version).
2753 return
2754 }
2755
Ivan Lozano52767be2019-10-18 14:49:46 -07002756 if to.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002757 // NDK code linking to platform code is never okay.
2758 ctx.ModuleErrorf("depends on non-NDK-built library %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002759 ctx.OtherModuleName(to.Module()))
Dan Willemsen155d17c2019-02-06 18:30:02 -08002760 return
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002761 }
2762
2763 // At this point we know we have two NDK libraries, but we need to
2764 // check that we're not linking against anything built against a higher
2765 // API level, as it is only valid to link against older or equivalent
2766 // APIs.
2767
Inseob Kim01a28722018-04-11 09:48:45 +09002768 // Current can link against anything.
Ivan Lozano52767be2019-10-18 14:49:46 -07002769 if from.SdkVersion() != "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002770 // Otherwise we need to check.
Ivan Lozano52767be2019-10-18 14:49:46 -07002771 if to.SdkVersion() == "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002772 // Current can't be linked against by anything else.
2773 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002774 ctx.OtherModuleName(to.Module()), "current")
Inseob Kim01a28722018-04-11 09:48:45 +09002775 } else {
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002776 fromApi, err := android.ApiLevelFromUserWithConfig(ctx.Config(), from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002777 if err != nil {
2778 ctx.PropertyErrorf("sdk_version",
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002779 "Invalid sdk_version value (must be int, preview or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002780 from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002781 }
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002782 toApi, err := android.ApiLevelFromUserWithConfig(ctx.Config(), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002783 if err != nil {
2784 ctx.PropertyErrorf("sdk_version",
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002785 "Invalid sdk_version value (must be int, preview or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002786 to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002787 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002788
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002789 if toApi.GreaterThan(fromApi) {
Inseob Kim01a28722018-04-11 09:48:45 +09002790 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002791 ctx.OtherModuleName(to.Module()), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002792 }
2793 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002794 }
Dan Albert202fe492017-12-15 13:56:59 -08002795
2796 // Also check that the two STL choices are compatible.
Ivan Lozano52767be2019-10-18 14:49:46 -07002797 fromStl := from.SelectedStl()
2798 toStl := to.SelectedStl()
Dan Albert202fe492017-12-15 13:56:59 -08002799 if fromStl == "" || toStl == "" {
2800 // Libraries that don't use the STL are unrestricted.
Inseob Kimda2171a2018-04-11 15:41:38 +09002801 } else if fromStl == "ndk_system" || toStl == "ndk_system" {
Dan Albert202fe492017-12-15 13:56:59 -08002802 // We can be permissive with the system "STL" since it is only the C++
2803 // ABI layer, but in the future we should make sure that everyone is
2804 // using either libc++ or nothing.
Colin Crossb60190a2018-09-04 16:28:17 -07002805 } else if getNdkStlFamily(from) != getNdkStlFamily(to) {
Dan Albert202fe492017-12-15 13:56:59 -08002806 ctx.ModuleErrorf("uses %q and depends on %q which uses incompatible %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002807 from.SelectedStl(), ctx.OtherModuleName(to.Module()),
2808 to.SelectedStl())
Dan Albert202fe492017-12-15 13:56:59 -08002809 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002810}
2811
Jooyung Han479ca172020-10-19 18:51:07 +09002812func checkLinkTypeMutator(ctx android.BottomUpMutatorContext) {
2813 if c, ok := ctx.Module().(*Module); ok {
2814 ctx.VisitDirectDeps(func(dep android.Module) {
2815 depTag := ctx.OtherModuleDependencyTag(dep)
2816 ccDep, ok := dep.(LinkableInterface)
2817 if ok {
2818 checkLinkType(ctx, c, ccDep, depTag)
2819 }
2820 })
2821 }
2822}
2823
Jiyong Park5fb8c102018-04-09 12:03:06 +09002824// Tests whether the dependent library is okay to be double loaded inside a single process.
Jooyung Hana70f0672019-01-18 15:20:43 +09002825// If a library has a vendor variant and is a (transitive) dependency of an LLNDK library,
2826// it is subject to be double loaded. Such lib should be explicitly marked as double_loadable: true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002827// or as vndk-sp (vndk: { enabled: true, support_system_process: true}).
Colin Crossda279cf2024-09-17 14:25:45 -07002828func checkDoubleLoadableLibraries(ctx android.BottomUpMutatorContext) {
Jooyung Hana70f0672019-01-18 15:20:43 +09002829 check := func(child, parent android.Module) bool {
2830 to, ok := child.(*Module)
2831 if !ok {
Jooyung Han479ca172020-10-19 18:51:07 +09002832 return false
Jooyung Hana70f0672019-01-18 15:20:43 +09002833 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002834
Jooyung Hana70f0672019-01-18 15:20:43 +09002835 if lib, ok := to.linker.(*libraryDecorator); !ok || !lib.shared() {
2836 return false
Jiyong Park5fb8c102018-04-09 12:03:06 +09002837 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002838
Jiyong Park0474e1f2021-01-14 14:26:06 +09002839 // These dependencies are not excercised at runtime. Tracking these will give us
2840 // false negative, so skip.
Jiyong Park1ad8e162020-12-01 23:40:09 +09002841 depTag := ctx.OtherModuleDependencyTag(child)
2842 if IsHeaderDepTag(depTag) {
2843 return false
2844 }
Jiyong Park0474e1f2021-01-14 14:26:06 +09002845 if depTag == staticVariantTag {
2846 return false
2847 }
2848 if depTag == stubImplDepTag {
2849 return false
2850 }
Jiyong Park8bcf3c62024-03-18 18:37:10 +09002851 if depTag == android.RequiredDepTag {
2852 return false
2853 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002854
Justin Yun63e9ec72020-10-29 16:49:43 +09002855 // Even if target lib has no vendor variant, keep checking dependency
2856 // graph in case it depends on vendor_available or product_available
2857 // but not double_loadable transtively.
2858 if !to.HasNonSystemVariants() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002859 return true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002860 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002861
Jiyong Park0474e1f2021-01-14 14:26:06 +09002862 // The happy path. Keep tracking dependencies until we hit a non double-loadable
2863 // one.
2864 if Bool(to.VendorProperties.Double_loadable) {
2865 return true
2866 }
2867
Kiyoung Kim9f26fcf2024-05-27 17:25:52 +09002868 if to.IsLlndk() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002869 return false
2870 }
2871
Jooyung Hana70f0672019-01-18 15:20:43 +09002872 ctx.ModuleErrorf("links a library %q which is not LL-NDK, "+
2873 "VNDK-SP, or explicitly marked as 'double_loadable:true'. "+
Jiyong Park0474e1f2021-01-14 14:26:06 +09002874 "Dependency list: %s", ctx.OtherModuleName(to), ctx.GetPathString(false))
Jooyung Hana70f0672019-01-18 15:20:43 +09002875 return false
2876 }
2877 if module, ok := ctx.Module().(*Module); ok {
2878 if lib, ok := module.linker.(*libraryDecorator); ok && lib.shared() {
Jiyong Park0474e1f2021-01-14 14:26:06 +09002879 if lib.hasLLNDKStubs() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002880 ctx.WalkDeps(check)
2881 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002882 }
2883 }
2884}
2885
Yu Liue4312402023-01-18 09:15:31 -08002886func findApexSdkVersion(ctx android.BaseModuleContext, apexInfo android.ApexInfo) android.ApiLevel {
2887 // For the dependency from platform to apex, use the latest stubs
2888 apexSdkVersion := android.FutureApiLevel
2889 if !apexInfo.IsForPlatform() {
2890 apexSdkVersion = apexInfo.MinSdkVersion
2891 }
2892
2893 if android.InList("hwaddress", ctx.Config().SanitizeDevice()) {
2894 // In hwasan build, we override apexSdkVersion to the FutureApiLevel(10000)
2895 // so that even Q(29/Android10) apexes could use the dynamic unwinder by linking the newer stubs(e.g libc(R+)).
2896 // (b/144430859)
2897 apexSdkVersion = android.FutureApiLevel
2898 }
2899
2900 return apexSdkVersion
2901}
2902
Colin Crossc99deeb2016-04-11 15:06:20 -07002903// Convert dependencies to paths. Returns a PathDeps containing paths
Colin Cross635c3b02016-05-18 15:37:25 -07002904func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
Colin Crossca860ac2016-01-04 14:34:37 -08002905 var depPaths PathDeps
Colin Crossca860ac2016-01-04 14:34:37 -08002906
Colin Cross0de8a1e2020-09-18 14:15:30 -07002907 var directStaticDeps []StaticLibraryInfo
2908 var directSharedDeps []SharedLibraryInfo
Jeff Gaston294356f2017-09-27 17:05:30 -07002909
Colin Cross0de8a1e2020-09-18 14:15:30 -07002910 reexportExporter := func(exporter FlagExporterInfo) {
2911 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, exporter.IncludeDirs...)
2912 depPaths.ReexportedSystemDirs = append(depPaths.ReexportedSystemDirs, exporter.SystemIncludeDirs...)
2913 depPaths.ReexportedFlags = append(depPaths.ReexportedFlags, exporter.Flags...)
2914 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, exporter.Deps...)
2915 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders, exporter.GeneratedHeaders...)
Inseob Kim69378442019-06-03 19:10:47 +09002916 }
2917
Colin Crossff694a82023-12-13 15:54:49 -08002918 apexInfo, _ := android.ModuleProvider(ctx, android.ApexInfoProvider)
Yu Liue4312402023-01-18 09:15:31 -08002919 c.apexSdkVersion = findApexSdkVersion(ctx, apexInfo)
Jooyung Hande34d232020-07-23 13:04:15 +09002920
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002921 skipModuleList := map[string]bool{}
2922
Colin Crossd11fcda2017-10-23 17:59:01 -07002923 ctx.VisitDirectDeps(func(dep android.Module) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002924 depName := ctx.OtherModuleName(dep)
2925 depTag := ctx.OtherModuleDependencyTag(dep)
Dan Albert9e10cd42016-08-03 14:12:14 -07002926
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002927 if _, ok := skipModuleList[depName]; ok {
2928 // skip this module because original module or API imported module matching with this should be used instead.
2929 return
2930 }
2931
Dan Willemsen47450072021-10-19 20:24:49 -07002932 if depTag == android.DarwinUniversalVariantTag {
2933 depPaths.DarwinSecondArchOutput = dep.(*Module).OutputFile()
2934 return
2935 }
2936
Vinh Tran367d89d2023-04-28 11:21:25 -04002937 if depTag == aidlLibraryTag {
Colin Cross313aa542023-12-13 13:47:44 -08002938 if aidlLibraryInfo, ok := android.OtherModuleProvider(ctx, dep, aidl_library.AidlLibraryProvider); ok {
Vinh Tran367d89d2023-04-28 11:21:25 -04002939 depPaths.AidlLibraryInfos = append(
2940 depPaths.AidlLibraryInfos,
Colin Cross313aa542023-12-13 13:47:44 -08002941 aidlLibraryInfo,
Vinh Tran367d89d2023-04-28 11:21:25 -04002942 )
2943 }
2944 }
2945
Ivan Lozano52767be2019-10-18 14:49:46 -07002946 ccDep, ok := dep.(LinkableInterface)
2947 if !ok {
2948
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002949 // handling for a few module types that aren't cc Module but that are also supported
2950 switch depTag {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002951 case genSourceDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002952 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002953 depPaths.GeneratedSources = append(depPaths.GeneratedSources,
2954 genRule.GeneratedSourceFiles()...)
2955 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002956 ctx.ModuleErrorf("module %q is not a gensrcs or genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002957 }
Colin Crosse90bfd12017-04-26 16:59:26 -07002958 // Support exported headers from a generated_sources dependency
2959 fallthrough
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002960 case genHeaderDepTag, genHeaderExportDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002961 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Inseob Kimd110f872019-12-06 13:15:38 +09002962 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps,
Dan Willemsen9da9d492018-02-21 18:28:18 -08002963 genRule.GeneratedDeps()...)
Jiyong Park74955042019-10-22 20:19:51 +09002964 dirs := genRule.GeneratedHeaderDirs()
Inseob Kim69378442019-06-03 19:10:47 +09002965 depPaths.IncludeDirs = append(depPaths.IncludeDirs, dirs...)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002966 if depTag == genHeaderExportDepTag {
Inseob Kim69378442019-06-03 19:10:47 +09002967 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, dirs...)
Inseob Kimd110f872019-12-06 13:15:38 +09002968 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders,
2969 genRule.GeneratedSourceFiles()...)
Inseob Kim69378442019-06-03 19:10:47 +09002970 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, genRule.GeneratedDeps()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002971 // 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 +09002972 c.sabi.Properties.ReexportedIncludes = append(c.sabi.Properties.ReexportedIncludes, dirs.Strings()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002973
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002974 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002975 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002976 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002977 }
Colin Crosscef792e2021-06-11 18:01:26 -07002978 case CrtBeginDepTag:
2979 depPaths.CrtBegin = append(depPaths.CrtBegin, android.OutputFileForModule(ctx, dep, ""))
2980 case CrtEndDepTag:
2981 depPaths.CrtEnd = append(depPaths.CrtEnd, android.OutputFileForModule(ctx, dep, ""))
Colin Crossca860ac2016-01-04 14:34:37 -08002982 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002983 return
2984 }
2985
Colin Crossfe17f6f2019-03-28 19:30:56 -07002986 if depTag == android.ProtoPluginDepTag {
2987 return
2988 }
2989
Jiyong Park8bcf3c62024-03-18 18:37:10 +09002990 if depTag == android.RequiredDepTag {
2991 return
2992 }
2993
Colin Crossd11fcda2017-10-23 17:59:01 -07002994 if dep.Target().Os != ctx.Os() {
Steven Morelandaaae81f2024-08-27 22:55:48 +00002995 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 -07002996 return
2997 }
Colin Crossd11fcda2017-10-23 17:59:01 -07002998 if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
Jooyung Han61b66e92020-03-21 14:21:46 +00002999 ctx.ModuleErrorf("Arch mismatch between %q(%v) and %q(%v)",
3000 ctx.ModuleName(), ctx.Arch().ArchType, depName, dep.Target().Arch.ArchType)
Colin Crossa1ad8d12016-06-01 17:09:44 -07003001 return
3002 }
3003
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003004 if depTag == reuseObjTag {
Colin Crossa717db72020-10-23 14:53:06 -07003005 // Skip reused objects for stub libraries, they use their own stub object file instead.
3006 // The reuseObjTag dependency still exists because the LinkageMutator runs before the
3007 // version mutator, so the stubs variant is created from the shared variant that
3008 // already has the reuseObjTag dependency on the static variant.
Colin Cross31076b32020-10-23 17:22:06 -07003009 if !c.library.buildStubs() {
Colin Cross313aa542023-12-13 13:47:44 -08003010 staticAnalogue, _ := android.OtherModuleProvider(ctx, dep, StaticLibraryInfoProvider)
Colin Crossa717db72020-10-23 14:53:06 -07003011 objs := staticAnalogue.ReuseObjects
3012 depPaths.Objs = depPaths.Objs.Append(objs)
Colin Cross313aa542023-12-13 13:47:44 -08003013 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
Colin Crossa717db72020-10-23 14:53:06 -07003014 reexportExporter(depExporterInfo)
3015 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07003016 return
Jiyong Parke4bb9862019-02-01 00:31:10 +09003017 }
3018
Hsin-Yi Chen715142a2024-03-27 16:31:16 +08003019 if depTag == llndkHeaderLibTag {
3020 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
3021 depPaths.LlndkIncludeDirs = append(depPaths.LlndkIncludeDirs, depExporterInfo.IncludeDirs...)
3022 depPaths.LlndkSystemIncludeDirs = append(depPaths.LlndkSystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
3023 }
3024
Colin Cross6e511a92020-07-27 21:26:48 -07003025 linkFile := ccDep.OutputFile()
3026
3027 if libDepTag, ok := depTag.(libraryDependencyTag); ok {
3028 // Only use static unwinder for legacy (min_sdk_version = 29) apexes (b/144430859)
Dan Albertc8060532020-07-22 22:32:17 -07003029 if libDepTag.staticUnwinder && c.apexSdkVersion.GreaterThan(android.SdkVersion_Android10) {
Peter Collingbournedc4f9862020-02-12 17:13:25 -08003030 return
3031 }
Peter Collingbournedc4f9862020-02-12 17:13:25 -08003032
Jiyong Parke3867542020-12-03 17:28:25 +09003033 if !apexInfo.IsForPlatform() && libDepTag.excludeInApex {
3034 return
3035 }
Jooyung Han9ffbe832023-11-28 22:31:35 +09003036 if apexInfo.IsForPlatform() && libDepTag.excludeInNonApex {
3037 return
3038 }
Jiyong Parke3867542020-12-03 17:28:25 +09003039
Colin Cross313aa542023-12-13 13:47:44 -08003040 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
Colin Crossc99deeb2016-04-11 15:06:20 -07003041
Colin Cross6e511a92020-07-27 21:26:48 -07003042 var ptr *android.Paths
3043 var depPtr *android.Paths
Colin Crossc99deeb2016-04-11 15:06:20 -07003044
Colin Cross6e511a92020-07-27 21:26:48 -07003045 depFile := android.OptionalPath{}
Colin Cross26c34ed2016-09-30 17:10:16 -07003046
Colin Cross6e511a92020-07-27 21:26:48 -07003047 switch {
3048 case libDepTag.header():
Colin Cross313aa542023-12-13 13:47:44 -08003049 if _, isHeaderLib := android.OtherModuleProvider(ctx, dep, HeaderLibraryInfoProvider); !isHeaderLib {
Colin Cross649d8172020-12-10 12:30:21 -08003050 if !ctx.Config().AllowMissingDependencies() {
3051 ctx.ModuleErrorf("module %q is not a header library", depName)
3052 } else {
3053 ctx.AddMissingDependencies([]string{depName})
3054 }
3055 return
3056 }
Colin Cross6e511a92020-07-27 21:26:48 -07003057 case libDepTag.shared():
Colin Cross313aa542023-12-13 13:47:44 -08003058 if _, isSharedLib := android.OtherModuleProvider(ctx, dep, SharedLibraryInfoProvider); !isSharedLib {
Colin Cross0de8a1e2020-09-18 14:15:30 -07003059 if !ctx.Config().AllowMissingDependencies() {
3060 ctx.ModuleErrorf("module %q is not a shared library", depName)
3061 } else {
3062 ctx.AddMissingDependencies([]string{depName})
3063 }
3064 return
3065 }
Jiyong Parke3867542020-12-03 17:28:25 +09003066
Jiyong Park7d55b612021-06-11 17:22:09 +09003067 sharedLibraryInfo, returnedDepExporterInfo := ChooseStubOrImpl(ctx, dep)
3068 depExporterInfo = returnedDepExporterInfo
Colin Cross0de8a1e2020-09-18 14:15:30 -07003069
Jiyong Park1ad8e162020-12-01 23:40:09 +09003070 // Stubs lib doesn't link to the shared lib dependencies. Don't set
3071 // linkFile, depFile, and ptr.
3072 if c.IsStubs() {
3073 break
3074 }
3075
Colin Cross0de8a1e2020-09-18 14:15:30 -07003076 linkFile = android.OptionalPathForPath(sharedLibraryInfo.SharedLibrary)
3077 depFile = sharedLibraryInfo.TableOfContents
3078
Colin Crossb614cd42024-10-11 12:52:21 -07003079 if !sharedLibraryInfo.IsStubs {
3080 depPaths.directImplementationDeps = append(depPaths.directImplementationDeps, android.OutputFileForModule(ctx, dep, ""))
3081 if info, ok := android.OtherModuleProvider(ctx, dep, ImplementationDepInfoProvider); ok {
3082 depPaths.transitiveImplementationDeps = append(depPaths.transitiveImplementationDeps, info.ImplementationDeps)
3083 }
3084 }
3085
Colin Cross6e511a92020-07-27 21:26:48 -07003086 ptr = &depPaths.SharedLibs
3087 switch libDepTag.Order {
3088 case earlyLibraryDependency:
3089 ptr = &depPaths.EarlySharedLibs
3090 depPtr = &depPaths.EarlySharedLibsDeps
3091 case normalLibraryDependency:
3092 ptr = &depPaths.SharedLibs
3093 depPtr = &depPaths.SharedLibsDeps
Colin Cross0de8a1e2020-09-18 14:15:30 -07003094 directSharedDeps = append(directSharedDeps, sharedLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07003095 case lateLibraryDependency:
3096 ptr = &depPaths.LateSharedLibs
3097 depPtr = &depPaths.LateSharedLibsDeps
3098 default:
3099 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Colin Crossc99deeb2016-04-11 15:06:20 -07003100 }
Ivan Lozano0a468a42024-05-13 21:03:34 -04003101
Colin Cross6e511a92020-07-27 21:26:48 -07003102 case libDepTag.static():
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003103 if ccDep.RustLibraryInterface() {
3104 rlibDep := RustRlibDep{LibPath: linkFile.Path(), CrateName: ccDep.CrateName(), LinkDirs: ccDep.ExportedCrateLinkDirs()}
3105 depPaths.RustRlibDeps = append(depPaths.RustRlibDeps, rlibDep)
3106 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
3107 if libDepTag.wholeStatic {
3108 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, depExporterInfo.IncludeDirs...)
3109 depPaths.ReexportedRustRlibDeps = append(depPaths.ReexportedRustRlibDeps, rlibDep)
Jiyong Park1ad8e162020-12-01 23:40:09 +09003110
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003111 // If whole_static, track this as we want to make sure that in a final linkage for a shared library,
3112 // exported functions from the rust generated staticlib still exported.
3113 if c.CcLibrary() && c.Shared() {
3114 c.WholeRustStaticlib = true
3115 }
Colin Cross6e511a92020-07-27 21:26:48 -07003116 }
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003117
Colin Cross6e511a92020-07-27 21:26:48 -07003118 } else {
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003119 staticLibraryInfo, isStaticLib := android.OtherModuleProvider(ctx, dep, StaticLibraryInfoProvider)
3120 if !isStaticLib {
3121 if !ctx.Config().AllowMissingDependencies() {
3122 ctx.ModuleErrorf("module %q is not a static library", depName)
3123 } else {
3124 ctx.AddMissingDependencies([]string{depName})
3125 }
3126 return
Inseob Kimeec88e12020-01-22 11:11:29 +09003127 }
Ivan Lozano0a468a42024-05-13 21:03:34 -04003128
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003129 // Stubs lib doesn't link to the static lib dependencies. Don't set
3130 // linkFile, depFile, and ptr.
3131 if c.IsStubs() {
3132 break
3133 }
Ivan Lozano0a468a42024-05-13 21:03:34 -04003134
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003135 linkFile = android.OptionalPathForPath(staticLibraryInfo.StaticLibrary)
3136 if libDepTag.wholeStatic {
3137 ptr = &depPaths.WholeStaticLibs
3138 if len(staticLibraryInfo.Objects.objFiles) > 0 {
3139 depPaths.WholeStaticLibObjs = depPaths.WholeStaticLibObjs.Append(staticLibraryInfo.Objects)
3140 } else {
3141 // This case normally catches prebuilt static
3142 // libraries, but it can also occur when
3143 // AllowMissingDependencies is on and the
3144 // dependencies has no sources of its own
3145 // but has a whole_static_libs dependency
3146 // on a missing library. We want to depend
3147 // on the .a file so that there is something
3148 // in the dependency tree that contains the
3149 // error rule for the missing transitive
3150 // dependency.
3151 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts, linkFile.Path())
3152 }
3153 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts,
3154 staticLibraryInfo.WholeStaticLibsFromPrebuilts...)
3155 } else {
3156 switch libDepTag.Order {
3157 case earlyLibraryDependency:
3158 panic(fmt.Errorf("early static libs not supported"))
3159 case normalLibraryDependency:
3160 // static dependencies will be handled separately so they can be ordered
3161 // using transitive dependencies.
3162 ptr = nil
3163 directStaticDeps = append(directStaticDeps, staticLibraryInfo)
3164 case lateLibraryDependency:
3165 ptr = &depPaths.LateStaticLibs
3166 default:
3167 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
3168 }
3169 }
3170
3171 // Collect any exported Rust rlib deps from static libraries which have been included as whole_static_libs
3172 depPaths.RustRlibDeps = append(depPaths.RustRlibDeps, depExporterInfo.RustRlibDeps...)
3173
3174 if libDepTag.unexportedSymbols {
3175 depPaths.LdFlags = append(depPaths.LdFlags,
3176 "-Wl,--exclude-libs="+staticLibraryInfo.StaticLibrary.Base())
3177 }
Colin Cross3e5e7782022-06-17 22:17:05 +00003178 }
Inseob Kimeec88e12020-01-22 11:11:29 +09003179 }
3180
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003181 if libDepTag.static() && !libDepTag.wholeStatic && !ccDep.RustLibraryInterface() {
Colin Cross6e511a92020-07-27 21:26:48 -07003182 if !ccDep.CcLibraryInterface() || !ccDep.Static() {
3183 ctx.ModuleErrorf("module %q not a static library", depName)
3184 return
3185 }
Logan Chien43d34c32017-12-20 01:17:32 +08003186
Colin Cross6e511a92020-07-27 21:26:48 -07003187 // When combining coverage files for shared libraries and executables, coverage files
3188 // in static libraries act as if they were whole static libraries. The same goes for
3189 // source based Abi dump files.
3190 if c, ok := ccDep.(*Module); ok {
3191 staticLib := c.linker.(libraryInterface)
3192 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
3193 staticLib.objs().coverageFiles...)
3194 depPaths.StaticLibObjs.sAbiDumpFiles = append(depPaths.StaticLibObjs.sAbiDumpFiles,
3195 staticLib.objs().sAbiDumpFiles...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003196 } else {
Colin Cross6e511a92020-07-27 21:26:48 -07003197 // Handle non-CC modules here
3198 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
Colin Cross0de8a1e2020-09-18 14:15:30 -07003199 ccDep.CoverageFiles()...)
Jiyong Parkde866cb2018-12-07 23:08:36 +09003200 }
3201 }
3202
Colin Cross6e511a92020-07-27 21:26:48 -07003203 if ptr != nil {
3204 if !linkFile.Valid() {
3205 if !ctx.Config().AllowMissingDependencies() {
3206 ctx.ModuleErrorf("module %q missing output file", depName)
3207 } else {
3208 ctx.AddMissingDependencies([]string{depName})
3209 }
3210 return
3211 }
3212 *ptr = append(*ptr, linkFile.Path())
3213 }
3214
3215 if depPtr != nil {
3216 dep := depFile
3217 if !dep.Valid() {
3218 dep = linkFile
3219 }
3220 *depPtr = append(*depPtr, dep.Path())
3221 }
3222
Colin Cross0de8a1e2020-09-18 14:15:30 -07003223 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
3224 depPaths.SystemIncludeDirs = append(depPaths.SystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
3225 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps, depExporterInfo.Deps...)
3226 depPaths.Flags = append(depPaths.Flags, depExporterInfo.Flags...)
Ivan Lozano0a468a42024-05-13 21:03:34 -04003227 depPaths.RustRlibDeps = append(depPaths.RustRlibDeps, depExporterInfo.RustRlibDeps...)
3228
3229 // Only re-export RustRlibDeps for cc static libs
3230 if c.static() {
3231 depPaths.ReexportedRustRlibDeps = append(depPaths.ReexportedRustRlibDeps, depExporterInfo.RustRlibDeps...)
3232 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07003233
3234 if libDepTag.reexportFlags {
3235 reexportExporter(depExporterInfo)
3236 // Add these re-exported flags to help header-abi-dumper to infer the abi exported by a library.
3237 // Re-exported shared library headers must be included as well since they can help us with type information
3238 // about template instantiations (instantiated from their headers).
Colin Cross0de8a1e2020-09-18 14:15:30 -07003239 c.sabi.Properties.ReexportedIncludes = append(
3240 c.sabi.Properties.ReexportedIncludes, depExporterInfo.IncludeDirs.Strings()...)
Hsin-Yi Chen5f228b02024-04-02 12:38:47 +08003241 c.sabi.Properties.ReexportedSystemIncludes = append(
3242 c.sabi.Properties.ReexportedSystemIncludes, depExporterInfo.SystemIncludeDirs.Strings()...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003243 }
3244
Spandan Das3faa7922024-02-26 19:42:32 +00003245 makeLibName := MakeLibName(ctx, c, ccDep, ccDep.BaseModuleName()) + libDepTag.makeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003246 switch {
3247 case libDepTag.header():
Colin Cross370173e2020-07-29 12:48:33 -07003248 c.Properties.AndroidMkHeaderLibs = append(
3249 c.Properties.AndroidMkHeaderLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07003250 case libDepTag.shared():
Colin Cross31076b32020-10-23 17:22:06 -07003251 if lib := moduleLibraryInterface(dep); lib != nil {
3252 if lib.buildStubs() && dep.(android.ApexModule).InAnyApex() {
Colin Cross6e511a92020-07-27 21:26:48 -07003253 // Add the dependency to the APEX(es) providing the library so that
3254 // m <module> can trigger building the APEXes as well.
Colin Cross313aa542023-12-13 13:47:44 -08003255 depApexInfo, _ := android.OtherModuleProvider(ctx, dep, android.ApexInfoProvider)
Jiyong Parkab50b072021-05-12 17:13:56 +09003256 for _, an := range depApexInfo.InApexVariants {
Colin Cross6e511a92020-07-27 21:26:48 -07003257 c.Properties.ApexesProvidingSharedLibs = append(
3258 c.Properties.ApexesProvidingSharedLibs, an)
3259 }
3260 }
3261 }
3262
3263 // Note: the order of libs in this list is not important because
3264 // they merely serve as Make dependencies and do not affect this lib itself.
Colin Cross370173e2020-07-29 12:48:33 -07003265 c.Properties.AndroidMkSharedLibs = append(
3266 c.Properties.AndroidMkSharedLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07003267 case libDepTag.static():
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003268 if !ccDep.RustLibraryInterface() {
3269 if libDepTag.wholeStatic {
3270 c.Properties.AndroidMkWholeStaticLibs = append(
3271 c.Properties.AndroidMkWholeStaticLibs, makeLibName)
3272 } else {
3273 c.Properties.AndroidMkStaticLibs = append(
3274 c.Properties.AndroidMkStaticLibs, makeLibName)
3275 }
Colin Cross6e511a92020-07-27 21:26:48 -07003276 }
3277 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09003278 } else if !c.IsStubs() {
3279 // Stubs lib doesn't link to the runtime lib, object, crt, etc. dependencies.
3280
Colin Cross6e511a92020-07-27 21:26:48 -07003281 switch depTag {
3282 case runtimeDepTag:
3283 c.Properties.AndroidMkRuntimeLibs = append(
Spandan Das3faa7922024-02-26 19:42:32 +00003284 c.Properties.AndroidMkRuntimeLibs, MakeLibName(ctx, c, ccDep, ccDep.BaseModuleName())+libDepTag.makeSuffix)
Colin Cross6e511a92020-07-27 21:26:48 -07003285 case objDepTag:
3286 depPaths.Objs.objFiles = append(depPaths.Objs.objFiles, linkFile.Path())
3287 case CrtBeginDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003288 depPaths.CrtBegin = append(depPaths.CrtBegin, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003289 case CrtEndDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003290 depPaths.CrtEnd = append(depPaths.CrtEnd, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003291 case dynamicLinkerDepTag:
3292 depPaths.DynamicLinker = linkFile
3293 }
Jiyong Park27b188b2017-07-18 13:23:39 +09003294 }
Colin Crossca860ac2016-01-04 14:34:37 -08003295 })
3296
Jeff Gaston294356f2017-09-27 17:05:30 -07003297 // use the ordered dependencies as this module's dependencies
Colin Cross0de8a1e2020-09-18 14:15:30 -07003298 orderedStaticPaths, transitiveStaticLibs := orderStaticModuleDeps(directStaticDeps, directSharedDeps)
3299 depPaths.TranstiveStaticLibrariesForOrdering = transitiveStaticLibs
3300 depPaths.StaticLibs = append(depPaths.StaticLibs, orderedStaticPaths...)
Jeff Gaston294356f2017-09-27 17:05:30 -07003301
Colin Crossdd84e052017-05-17 13:44:16 -07003302 // Dedup exported flags from dependencies
Colin Crossb6715442017-10-24 11:13:31 -07003303 depPaths.Flags = android.FirstUniqueStrings(depPaths.Flags)
Jiyong Park74955042019-10-22 20:19:51 +09003304 depPaths.IncludeDirs = android.FirstUniquePaths(depPaths.IncludeDirs)
3305 depPaths.SystemIncludeDirs = android.FirstUniquePaths(depPaths.SystemIncludeDirs)
Inseob Kimd110f872019-12-06 13:15:38 +09003306 depPaths.GeneratedDeps = android.FirstUniquePaths(depPaths.GeneratedDeps)
Ivan Lozano0a468a42024-05-13 21:03:34 -04003307 depPaths.RustRlibDeps = android.FirstUniqueFunc(depPaths.RustRlibDeps, EqRustRlibDeps)
3308
Jiyong Park74955042019-10-22 20:19:51 +09003309 depPaths.ReexportedDirs = android.FirstUniquePaths(depPaths.ReexportedDirs)
3310 depPaths.ReexportedSystemDirs = android.FirstUniquePaths(depPaths.ReexportedSystemDirs)
Colin Crossb6715442017-10-24 11:13:31 -07003311 depPaths.ReexportedFlags = android.FirstUniqueStrings(depPaths.ReexportedFlags)
Inseob Kim69378442019-06-03 19:10:47 +09003312 depPaths.ReexportedDeps = android.FirstUniquePaths(depPaths.ReexportedDeps)
Inseob Kimd110f872019-12-06 13:15:38 +09003313 depPaths.ReexportedGeneratedHeaders = android.FirstUniquePaths(depPaths.ReexportedGeneratedHeaders)
Ivan Lozano0a468a42024-05-13 21:03:34 -04003314 depPaths.ReexportedRustRlibDeps = android.FirstUniqueFunc(depPaths.ReexportedRustRlibDeps, EqRustRlibDeps)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003315
3316 if c.sabi != nil {
Inseob Kim69378442019-06-03 19:10:47 +09003317 c.sabi.Properties.ReexportedIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedIncludes)
Hsin-Yi Chen5f228b02024-04-02 12:38:47 +08003318 c.sabi.Properties.ReexportedSystemIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedSystemIncludes)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003319 }
Colin Crossdd84e052017-05-17 13:44:16 -07003320
Colin Crossca860ac2016-01-04 14:34:37 -08003321 return depPaths
3322}
3323
Spandan Das604f3762023-03-16 22:51:40 +00003324func ShouldUseStubForApex(ctx android.ModuleContext, dep android.Module) bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09003325 depName := ctx.OtherModuleName(dep)
Jiyong Park7d55b612021-06-11 17:22:09 +09003326 thisModule, ok := ctx.Module().(android.ApexModule)
3327 if !ok {
3328 panic(fmt.Errorf("Not an APEX module: %q", ctx.ModuleName()))
3329 }
3330
Kiyoung Kimaa394802024-01-08 12:55:45 +09003331 inVendorOrProduct := false
Jiyong Park7d55b612021-06-11 17:22:09 +09003332 bootstrap := false
3333 if linkable, ok := ctx.Module().(LinkableInterface); !ok {
3334 panic(fmt.Errorf("Not a Linkable module: %q", ctx.ModuleName()))
3335 } else {
Kiyoung Kimaa394802024-01-08 12:55:45 +09003336 inVendorOrProduct = linkable.InVendorOrProduct()
Jiyong Park7d55b612021-06-11 17:22:09 +09003337 bootstrap = linkable.Bootstrap()
3338 }
3339
Colin Crossff694a82023-12-13 15:54:49 -08003340 apexInfo, _ := android.ModuleProvider(ctx, android.ApexInfoProvider)
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003341
3342 useStubs := false
3343
Kiyoung Kimaa394802024-01-08 12:55:45 +09003344 if lib := moduleLibraryInterface(dep); lib.buildStubs() && inVendorOrProduct { // LLNDK
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003345 if !apexInfo.IsForPlatform() {
3346 // For platform libraries, use current version of LLNDK
3347 // If this is for use_vendor apex we will apply the same rules
3348 // of apex sdk enforcement below to choose right version.
3349 useStubs = true
3350 }
3351 } else if apexInfo.IsForPlatform() || apexInfo.UsePlatformApis {
3352 // If not building for APEX or the containing APEX allows the use of
3353 // platform APIs, use stubs only when it is from an APEX (and not from
3354 // platform) However, for host, ramdisk, vendor_ramdisk, recovery or
3355 // bootstrap modules, always link to non-stub variant
3356 isNotInPlatform := dep.(android.ApexModule).NotInPlatform()
3357
Spandan Dasff665182024-09-11 18:48:44 +00003358 useStubs = isNotInPlatform && !bootstrap
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003359
3360 if useStubs {
3361 // Another exception: if this module is a test for an APEX, then
3362 // it is linked with the non-stub variant of a module in the APEX
3363 // as if this is part of the APEX.
Colin Crossff694a82023-12-13 15:54:49 -08003364 testFor, _ := android.ModuleProvider(ctx, android.ApexTestForInfoProvider)
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003365 for _, apexContents := range testFor.ApexContents {
3366 if apexContents.DirectlyInApex(depName) {
3367 useStubs = false
3368 break
3369 }
3370 }
3371 }
3372 if useStubs {
3373 // Yet another exception: If this module and the dependency are
3374 // available to the same APEXes then skip stubs between their
3375 // platform variants. This complements the test_for case above,
3376 // which avoids the stubs on a direct APEX library dependency, by
3377 // avoiding stubs for indirect test dependencies as well.
3378 //
3379 // TODO(b/183882457): This doesn't work if the two libraries have
3380 // only partially overlapping apex_available. For that test_for
3381 // modules would need to be split into APEX variants and resolved
3382 // separately for each APEX they have access to.
Spandan Dasff665182024-09-11 18:48:44 +00003383 if android.AvailableToSameApexes(thisModule, dep.(android.ApexModule)) {
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003384 useStubs = false
3385 }
3386 }
3387 } else {
3388 // If building for APEX, use stubs when the parent is in any APEX that
3389 // the child is not in.
3390 useStubs = !android.DirectlyInAllApexes(apexInfo, depName)
3391 }
3392
3393 return useStubs
3394}
3395
3396// ChooseStubOrImpl determines whether a given dependency should be redirected to the stub variant
3397// of the dependency or not, and returns the SharedLibraryInfo and FlagExporterInfo for the right
3398// dependency. The stub variant is selected when the dependency crosses a boundary where each side
3399// has different level of updatability. For example, if a library foo in an APEX depends on a
3400// library bar which provides stable interface and exists in the platform, foo uses the stub variant
3401// of bar. If bar doesn't provide a stable interface (i.e. buildStubs() == false) or is in the
3402// same APEX as foo, the non-stub variant of bar is used.
3403func ChooseStubOrImpl(ctx android.ModuleContext, dep android.Module) (SharedLibraryInfo, FlagExporterInfo) {
3404 depTag := ctx.OtherModuleDependencyTag(dep)
3405 libDepTag, ok := depTag.(libraryDependencyTag)
3406 if !ok || !libDepTag.shared() {
3407 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
3408 }
3409
Colin Cross313aa542023-12-13 13:47:44 -08003410 sharedLibraryInfo, _ := android.OtherModuleProvider(ctx, dep, SharedLibraryInfoProvider)
3411 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
3412 sharedLibraryStubsInfo, _ := android.OtherModuleProvider(ctx, dep, SharedLibraryStubsProvider)
Jiyong Park7d55b612021-06-11 17:22:09 +09003413
3414 if !libDepTag.explicitlyVersioned && len(sharedLibraryStubsInfo.SharedStubLibraries) > 0 {
Jiyong Park7d55b612021-06-11 17:22:09 +09003415 // when to use (unspecified) stubs, use the latest one.
Spandan Das604f3762023-03-16 22:51:40 +00003416 if ShouldUseStubForApex(ctx, dep) {
Jiyong Park7d55b612021-06-11 17:22:09 +09003417 stubs := sharedLibraryStubsInfo.SharedStubLibraries
3418 toUse := stubs[len(stubs)-1]
3419 sharedLibraryInfo = toUse.SharedLibraryInfo
3420 depExporterInfo = toUse.FlagExporterInfo
3421 }
3422 }
3423 return sharedLibraryInfo, depExporterInfo
3424}
3425
Colin Cross0de8a1e2020-09-18 14:15:30 -07003426// orderStaticModuleDeps rearranges the order of the static library dependencies of the module
3427// to match the topological order of the dependency tree, including any static analogues of
Colin Crossa14fb6a2024-10-23 16:57:06 -07003428// direct shared libraries. It returns the ordered static dependencies, and a depset.DepSet
Colin Cross0de8a1e2020-09-18 14:15:30 -07003429// of the transitive dependencies.
Colin Crossa14fb6a2024-10-23 16:57:06 -07003430func orderStaticModuleDeps(staticDeps []StaticLibraryInfo, sharedDeps []SharedLibraryInfo) (ordered android.Paths, transitive depset.DepSet[android.Path]) {
3431 transitiveStaticLibsBuilder := depset.NewBuilder[android.Path](depset.TOPOLOGICAL)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003432 var staticPaths android.Paths
3433 for _, staticDep := range staticDeps {
3434 staticPaths = append(staticPaths, staticDep.StaticLibrary)
3435 transitiveStaticLibsBuilder.Transitive(staticDep.TransitiveStaticLibrariesForOrdering)
3436 }
3437 for _, sharedDep := range sharedDeps {
Colin Crossa14fb6a2024-10-23 16:57:06 -07003438 transitiveStaticLibsBuilder.Transitive(sharedDep.TransitiveStaticLibrariesForOrdering)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003439 }
3440 transitiveStaticLibs := transitiveStaticLibsBuilder.Build()
3441
3442 orderedTransitiveStaticLibs := transitiveStaticLibs.ToList()
3443
3444 // reorder the dependencies based on transitive dependencies
3445 staticPaths = android.FirstUniquePaths(staticPaths)
3446 _, orderedStaticPaths := android.FilterPathList(orderedTransitiveStaticLibs, staticPaths)
3447
3448 if len(orderedStaticPaths) != len(staticPaths) {
3449 missing, _ := android.FilterPathList(staticPaths, orderedStaticPaths)
3450 panic(fmt.Errorf("expected %d ordered static paths , got %d, missing %q %q %q", len(staticPaths), len(orderedStaticPaths), missing, orderedStaticPaths, staticPaths))
3451 }
3452
3453 return orderedStaticPaths, transitiveStaticLibs
3454}
3455
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003456// BaseLibName trims known prefixes and suffixes
3457func BaseLibName(depName string) string {
Colin Cross6e511a92020-07-27 21:26:48 -07003458 libName := strings.TrimSuffix(depName, llndkLibrarySuffix)
3459 libName = strings.TrimSuffix(libName, vendorPublicLibrarySuffix)
Paul Duffind23c7262020-12-11 18:13:08 +00003460 libName = android.RemoveOptionalPrebuiltPrefix(libName)
Colin Cross6e511a92020-07-27 21:26:48 -07003461 return libName
3462}
3463
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003464func MakeLibName(ctx android.ModuleContext, c LinkableInterface, ccDep LinkableInterface, depName string) string {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003465 libName := BaseLibName(depName)
Colin Cross127bb8b2020-12-16 16:46:01 -08003466 ccDepModule, _ := ccDep.(*Module)
3467 isLLndk := ccDepModule != nil && ccDepModule.IsLlndk()
Justin Yuncbca3732021-02-03 19:24:13 +09003468 nonSystemVariantsExist := ccDep.HasNonSystemVariants() || isLLndk
Colin Cross6e511a92020-07-27 21:26:48 -07003469
Justin Yuncbca3732021-02-03 19:24:13 +09003470 if ccDepModule != nil {
Colin Cross6e511a92020-07-27 21:26:48 -07003471 // Use base module name for snapshots when exporting to Makefile.
Ivan Lozanod1dec542021-05-26 15:33:11 -04003472 if snapshotPrebuilt, ok := ccDepModule.linker.(SnapshotInterface); ok {
Justin Yuncbca3732021-02-03 19:24:13 +09003473 baseName := ccDepModule.BaseModuleName()
Colin Cross6e511a92020-07-27 21:26:48 -07003474
Ivan Lozanod1dec542021-05-26 15:33:11 -04003475 return baseName + snapshotPrebuilt.SnapshotAndroidMkSuffix()
Colin Cross6e511a92020-07-27 21:26:48 -07003476 }
3477 }
3478
Kiyoung Kim22152f62024-05-24 10:45:28 +09003479 if ccDep.InVendorOrProduct() && nonSystemVariantsExist {
Justin Yuncbca3732021-02-03 19:24:13 +09003480 // The vendor and product modules in Make will have been renamed to not conflict with the
3481 // core module, so update the dependency name here accordingly.
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003482 return libName + ccDep.SubName()
Colin Cross6e511a92020-07-27 21:26:48 -07003483 } else if ccDep.InRamdisk() && !ccDep.OnlyInRamdisk() {
Matthew Maurerc6868382021-07-13 14:12:37 -07003484 return libName + RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003485 } else if ccDep.InVendorRamdisk() && !ccDep.OnlyInVendorRamdisk() {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05003486 return libName + VendorRamdiskSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003487 } else if ccDep.InRecovery() && !ccDep.OnlyInRecovery() {
Matthew Maurer460ee942021-02-11 12:31:46 -08003488 return libName + RecoverySuffix
Ivan Lozanof9e21722020-12-02 09:00:51 -05003489 } else if ccDep.Target().NativeBridge == android.NativeBridgeEnabled {
Matthew Maurera61e31f2021-05-27 11:09:11 -07003490 return libName + NativeBridgeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003491 } else {
3492 return libName
3493 }
3494}
3495
Colin Crossca860ac2016-01-04 14:34:37 -08003496func (c *Module) InstallInData() bool {
3497 if c.installer == nil {
3498 return false
3499 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003500 return c.installer.inData()
3501}
3502
3503func (c *Module) InstallInSanitizerDir() bool {
3504 if c.installer == nil {
3505 return false
3506 }
3507 if c.sanitize != nil && c.sanitize.inSanitizerDir() {
Colin Cross94610402016-08-29 13:41:32 -07003508 return true
3509 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003510 return c.installer.inSanitizerDir()
Colin Crossca860ac2016-01-04 14:34:37 -08003511}
3512
Yifan Hong1b3348d2020-01-21 15:53:22 -08003513func (c *Module) InstallInRamdisk() bool {
3514 return c.InRamdisk()
3515}
3516
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003517func (c *Module) InstallInVendorRamdisk() bool {
3518 return c.InVendorRamdisk()
3519}
3520
Jiyong Parkf9332f12018-02-01 00:54:12 +09003521func (c *Module) InstallInRecovery() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07003522 return c.InRecovery()
Jiyong Parkf9332f12018-02-01 00:54:12 +09003523}
3524
Jingwen Chen8ac7d7d2023-03-20 11:05:16 +00003525func (c *Module) MakeUninstallable() {
3526 if c.installer == nil {
3527 c.ModuleBase.MakeUninstallable()
3528 return
3529 }
3530 c.installer.makeUninstallable(c)
3531}
3532
Dan Willemsen4aa75ca2016-09-28 16:18:03 -07003533func (c *Module) HostToolPath() android.OptionalPath {
3534 if c.installer == nil {
3535 return android.OptionalPath{}
3536 }
3537 return c.installer.hostToolPath()
3538}
3539
Nan Zhangd4e641b2017-07-12 12:55:28 -07003540func (c *Module) IntermPathForModuleOut() android.OptionalPath {
3541 return c.outputFile
3542}
3543
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00003544func (c *Module) static() bool {
3545 if static, ok := c.linker.(interface {
3546 static() bool
3547 }); ok {
3548 return static.static()
3549 }
3550 return false
3551}
3552
Jiyong Park379de2f2018-12-19 02:47:14 +09003553func (c *Module) staticBinary() bool {
3554 if static, ok := c.linker.(interface {
3555 staticBinary() bool
3556 }); ok {
3557 return static.staticBinary()
3558 }
3559 return false
3560}
3561
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07003562func (c *Module) testBinary() bool {
3563 if test, ok := c.linker.(interface {
3564 testBinary() bool
3565 }); ok {
3566 return test.testBinary()
3567 }
3568 return false
3569}
3570
Jingwen Chen537242c2022-08-24 11:53:27 +00003571func (c *Module) testLibrary() bool {
3572 if test, ok := c.linker.(interface {
3573 testLibrary() bool
3574 }); ok {
3575 return test.testLibrary()
3576 }
3577 return false
3578}
3579
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003580func (c *Module) benchmarkBinary() bool {
3581 if b, ok := c.linker.(interface {
3582 benchmarkBinary() bool
3583 }); ok {
3584 return b.benchmarkBinary()
3585 }
3586 return false
3587}
3588
3589func (c *Module) fuzzBinary() bool {
3590 if f, ok := c.linker.(interface {
3591 fuzzBinary() bool
3592 }); ok {
3593 return f.fuzzBinary()
3594 }
3595 return false
3596}
3597
Ivan Lozano3968d8f2020-12-14 11:27:52 -05003598// Header returns true if the module is a header-only variant. (See cc/library.go header()).
3599func (c *Module) Header() bool {
Jiyong Park1d1119f2019-07-29 21:27:18 +09003600 if h, ok := c.linker.(interface {
3601 header() bool
3602 }); ok {
3603 return h.header()
3604 }
3605 return false
3606}
3607
Ivan Lozanod7586b62021-04-01 09:49:36 -04003608func (c *Module) Binary() bool {
Inseob Kim7f283f42020-06-01 21:53:49 +09003609 if b, ok := c.linker.(interface {
3610 binary() bool
3611 }); ok {
3612 return b.binary()
3613 }
3614 return false
3615}
3616
Justin Yun5e035862021-06-29 20:50:37 +09003617func (c *Module) StaticExecutable() bool {
3618 if b, ok := c.linker.(*binaryDecorator); ok {
3619 return b.static()
3620 }
3621 return false
3622}
3623
Ivan Lozanod7586b62021-04-01 09:49:36 -04003624func (c *Module) Object() bool {
Inseob Kim1042d292020-06-01 23:23:05 +09003625 if o, ok := c.linker.(interface {
3626 object() bool
3627 }); ok {
3628 return o.object()
3629 }
3630 return false
3631}
3632
Kiyoung Kim37693d02024-04-04 09:56:15 +09003633func (m *Module) Dylib() bool {
3634 return false
3635}
3636
3637func (m *Module) Rlib() bool {
3638 return false
3639}
3640
Ivan Lozanof9e21722020-12-02 09:00:51 -05003641func GetMakeLinkType(actx android.ModuleContext, c LinkableInterface) string {
Kiyoung Kim8487c0b2024-01-11 16:03:13 +09003642 if c.InVendorOrProduct() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003643 if c.IsLlndk() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003644 return "native:vndk"
Jooyung Han38002912019-05-16 04:01:54 +09003645 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003646 if c.InProduct() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09003647 return "native:product"
3648 }
Jooyung Han38002912019-05-16 04:01:54 +09003649 return "native:vendor"
Yifan Hong1b3348d2020-01-21 15:53:22 -08003650 } else if c.InRamdisk() {
3651 return "native:ramdisk"
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003652 } else if c.InVendorRamdisk() {
3653 return "native:vendor_ramdisk"
Ivan Lozano52767be2019-10-18 14:49:46 -07003654 } else if c.InRecovery() {
Colin Crossb60190a2018-09-04 16:28:17 -07003655 return "native:recovery"
Ivan Lozanof9e21722020-12-02 09:00:51 -05003656 } else if c.Target().Os == android.Android && c.SdkVersion() != "" {
Colin Crossb60190a2018-09-04 16:28:17 -07003657 return "native:ndk:none:none"
3658 // TODO(b/114741097): use the correct ndk stl once build errors have been fixed
3659 //family, link := getNdkStlFamilyAndLinkType(c)
3660 //return fmt.Sprintf("native:ndk:%s:%s", family, link)
3661 } else {
3662 return "native:platform"
3663 }
3664}
3665
Jiyong Park9d452992018-10-03 00:38:19 +09003666// Overrides ApexModule.IsInstallabeToApex()
Colin Cross3a02c7b2024-05-21 13:46:22 -07003667// Only shared/runtime libraries .
Jiyong Park9d452992018-10-03 00:38:19 +09003668func (c *Module) IsInstallableToApex() bool {
Colin Cross31076b32020-10-23 17:22:06 -07003669 if lib := c.library; lib != nil {
Jiyong Park73c54ee2019-10-22 20:31:18 +09003670 // Stub libs and prebuilt libs in a versioned SDK are not
3671 // installable to APEX even though they are shared libs.
Paul Duffin458a15b2022-11-25 12:18:24 +00003672 return lib.shared() && !lib.buildStubs()
Jiyong Park9d452992018-10-03 00:38:19 +09003673 }
3674 return false
3675}
3676
Jiyong Parka90ca002019-10-07 15:47:24 +09003677func (c *Module) AvailableFor(what string) bool {
3678 if linker, ok := c.linker.(interface {
3679 availableFor(string) bool
3680 }); ok {
3681 return c.ApexModuleBase.AvailableFor(what) || linker.availableFor(what)
3682 } else {
3683 return c.ApexModuleBase.AvailableFor(what)
3684 }
3685}
3686
Jiyong Park62304bb2020-04-13 16:19:48 +09003687func (c *Module) TestFor() []string {
Jiyong Park46a512f2020-12-04 18:02:13 +09003688 return c.Properties.Test_for
Jiyong Park62304bb2020-04-13 16:19:48 +09003689}
3690
Paul Duffin0cb37b92020-03-04 14:52:46 +00003691func (c *Module) EverInstallable() bool {
3692 return c.installer != nil &&
3693 // Check to see whether the module is actually ever installable.
3694 c.installer.everInstallable()
3695}
3696
Ivan Lozanod7586b62021-04-01 09:49:36 -04003697func (c *Module) PreventInstall() bool {
3698 return c.Properties.PreventInstall
3699}
3700
3701func (c *Module) Installable() *bool {
Colin Cross1bc94122021-10-28 13:25:54 -07003702 if c.library != nil {
3703 if i := c.library.installable(); i != nil {
3704 return i
3705 }
3706 }
Ivan Lozanod7586b62021-04-01 09:49:36 -04003707 return c.Properties.Installable
3708}
3709
3710func installable(c LinkableInterface, apexInfo android.ApexInfo) bool {
Paul Duffin0cb37b92020-03-04 14:52:46 +00003711 ret := c.EverInstallable() &&
3712 // Check to see whether the module has been configured to not be installed.
Ivan Lozanod7586b62021-04-01 09:49:36 -04003713 proptools.BoolDefault(c.Installable(), true) &&
3714 !c.PreventInstall() && c.OutputFile().Valid()
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003715
3716 // The platform variant doesn't need further condition. Apex variants however might not
3717 // be installable because it will likely to be included in the APEX and won't appear
3718 // in the system partition.
Colin Cross56a83212020-09-15 18:30:11 -07003719 if apexInfo.IsForPlatform() {
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003720 return ret
3721 }
3722
3723 // Special case for modules that are configured to be installed to /data, which includes
3724 // test modules. For these modules, both APEX and non-APEX variants are considered as
3725 // installable. This is because even the APEX variants won't be included in the APEX, but
3726 // will anyway be installed to /data/*.
3727 // See b/146995717
3728 if c.InstallInData() {
3729 return ret
3730 }
3731
3732 return false
Inseob Kim1f086e22019-05-09 13:29:15 +09003733}
3734
Logan Chien41eabe62019-04-10 13:33:58 +08003735func (c *Module) AndroidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer) {
3736 if c.linker != nil {
3737 if library, ok := c.linker.(*libraryDecorator); ok {
3738 library.androidMkWriteAdditionalDependenciesForSourceAbiDiff(w)
3739 }
3740 }
3741}
3742
Jiyong Park45bf82e2020-12-15 22:29:02 +09003743var _ android.ApexModule = (*Module)(nil)
3744
3745// Implements android.ApexModule
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003746func (c *Module) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
Colin Cross6e511a92020-07-27 21:26:48 -07003747 depTag := ctx.OtherModuleDependencyTag(dep)
3748 libDepTag, isLibDepTag := depTag.(libraryDependencyTag)
3749
3750 if cc, ok := dep.(*Module); ok {
3751 if cc.HasStubsVariants() {
3752 if isLibDepTag && libDepTag.shared() {
3753 // dynamic dep to a stubs lib crosses APEX boundary
3754 return false
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003755 }
Colin Cross6e511a92020-07-27 21:26:48 -07003756 if IsRuntimeDepTag(depTag) {
3757 // runtime dep to a stubs lib also crosses APEX boundary
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003758 return false
3759 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003760 }
Zhijun Heec285872021-04-24 10:47:08 -07003761 if cc.IsLlndk() {
3762 return false
3763 }
Colin Crossaac32222020-07-29 12:51:56 -07003764 if isLibDepTag && c.static() && libDepTag.shared() {
Colin Cross6e511a92020-07-27 21:26:48 -07003765 // shared_lib dependency from a static lib is considered as crossing
3766 // the APEX boundary because the dependency doesn't actually is
3767 // linked; the dependency is used only during the compilation phase.
3768 return false
3769 }
Jiyong Parke3867542020-12-03 17:28:25 +09003770
3771 if isLibDepTag && libDepTag.excludeInApex {
3772 return false
3773 }
Colin Cross6e511a92020-07-27 21:26:48 -07003774 }
Colin Crossc1b36442021-05-06 13:42:48 -07003775 if depTag == stubImplDepTag {
3776 // We don't track from an implementation library to its stubs.
Jiyong Park7d95a512020-05-10 15:16:24 +09003777 return false
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003778 }
Jiyong Park12177fc2021-01-05 14:37:15 +09003779 if depTag == staticVariantTag {
3780 // This dependency is for optimization (reuse *.o from the static lib). It doesn't
3781 // actually mean that the static lib (and its dependencies) are copied into the
3782 // APEX.
3783 return false
3784 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003785 return true
3786}
3787
Jiyong Park45bf82e2020-12-15 22:29:02 +09003788// Implements android.ApexModule
Dan Albertc8060532020-07-22 22:32:17 -07003789func (c *Module) ShouldSupportSdkVersion(ctx android.BaseModuleContext,
3790 sdkVersion android.ApiLevel) error {
Jooyung Han749dc692020-04-15 11:03:39 +09003791 // We ignore libclang_rt.* prebuilt libs since they declare sdk_version: 14(b/121358700)
3792 if strings.HasPrefix(ctx.OtherModuleName(c), "libclang_rt") {
3793 return nil
3794 }
Jooyung Han749dc692020-04-15 11:03:39 +09003795 // We don't check for prebuilt modules
3796 if _, ok := c.linker.(prebuiltLinkerInterface); ok {
3797 return nil
3798 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09003799
Jooyung Han749dc692020-04-15 11:03:39 +09003800 minSdkVersion := c.MinSdkVersion()
3801 if minSdkVersion == "apex_inherit" {
3802 return nil
3803 }
3804 if minSdkVersion == "" {
3805 // JNI libs within APK-in-APEX fall into here
3806 // Those are okay to set sdk_version instead
3807 // We don't have to check if this is a SDK variant because
3808 // non-SDK variant resets sdk_version, which works too.
3809 minSdkVersion = c.SdkVersion()
3810 }
Dan Albertc8060532020-07-22 22:32:17 -07003811 if minSdkVersion == "" {
3812 return fmt.Errorf("neither min_sdk_version nor sdk_version specificed")
3813 }
3814 // Not using nativeApiLevelFromUser because the context here is not
3815 // necessarily a native context.
3816 ver, err := android.ApiLevelFromUser(ctx, minSdkVersion)
Jooyung Han749dc692020-04-15 11:03:39 +09003817 if err != nil {
3818 return err
3819 }
Dan Albertc8060532020-07-22 22:32:17 -07003820
Colin Cross8ca61c12022-10-06 21:00:14 -07003821 // A dependency only needs to support a min_sdk_version at least
3822 // as high as the api level that the architecture was introduced in.
3823 // This allows introducing new architectures in the platform that
3824 // need to be included in apexes that normally require an older
3825 // min_sdk_version.
Colin Crossbb137a32023-01-26 09:54:42 -08003826 minApiForArch := MinApiForArch(ctx, c.Target().Arch.ArchType)
Colin Cross8ca61c12022-10-06 21:00:14 -07003827 if sdkVersion.LessThan(minApiForArch) {
3828 sdkVersion = minApiForArch
3829 }
3830
Dan Albertc8060532020-07-22 22:32:17 -07003831 if ver.GreaterThan(sdkVersion) {
Jooyung Han749dc692020-04-15 11:03:39 +09003832 return fmt.Errorf("newer SDK(%v)", ver)
3833 }
3834 return nil
3835}
3836
Paul Duffinb5769c12021-05-12 16:16:51 +01003837// Implements android.ApexModule
3838func (c *Module) AlwaysRequiresPlatformApexVariant() bool {
3839 // stub libraries and native bridge libraries are always available to platform
3840 return c.IsStubs() || c.Target().NativeBridge == android.NativeBridgeEnabled
3841}
3842
Inseob Kima1888ce2022-10-04 14:42:02 +09003843func (c *Module) overriddenModules() []string {
3844 if o, ok := c.linker.(overridable); ok {
3845 return o.overriddenModules()
3846 }
3847 return nil
3848}
3849
Liz Kammer35ca77e2021-12-22 15:31:40 -05003850type moduleType int
3851
3852const (
3853 unknownType moduleType = iota
3854 binary
3855 object
3856 fullLibrary
3857 staticLibrary
3858 sharedLibrary
3859 headerLibrary
Jingwen Chen537242c2022-08-24 11:53:27 +00003860 testBin // testBinary already declared
Spandan Das1278c2c2022-08-19 18:17:28 +00003861 ndkLibrary
Liz Kammer35ca77e2021-12-22 15:31:40 -05003862)
3863
3864func (c *Module) typ() moduleType {
Jingwen Chen537242c2022-08-24 11:53:27 +00003865 if c.testBinary() {
3866 // testBinary is also a binary, so this comes before the c.Binary()
3867 // conditional. A testBinary has additional implicit dependencies and
3868 // other test-only semantics.
3869 return testBin
3870 } else if c.Binary() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003871 return binary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003872 } else if c.Object() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003873 return object
Jingwen Chen537242c2022-08-24 11:53:27 +00003874 } else if c.testLibrary() {
3875 // TODO(b/244431896) properly convert cc_test_library to its own macro. This
3876 // will let them add implicit compile deps on gtest, for example.
3877 //
Liz Kammerefc51d92023-04-21 15:11:25 -04003878 // For now, treat them as regular libraries.
3879 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003880 } else if c.CcLibrary() {
Chris Parsons58852a02021-12-09 18:10:18 -05003881 static := false
3882 shared := false
3883 if library, ok := c.linker.(*libraryDecorator); ok {
3884 static = library.MutatedProperties.BuildStatic
3885 shared = library.MutatedProperties.BuildShared
3886 } else if library, ok := c.linker.(*prebuiltLibraryLinker); ok {
3887 static = library.MutatedProperties.BuildStatic
3888 shared = library.MutatedProperties.BuildShared
3889 }
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003890 if static && shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003891 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003892 } else if !static && !shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003893 return headerLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003894 } else if static {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003895 return staticLibrary
3896 }
3897 return sharedLibrary
Spandan Das1278c2c2022-08-19 18:17:28 +00003898 } else if c.isNDKStubLibrary() {
3899 return ndkLibrary
Liz Kammer35ca77e2021-12-22 15:31:40 -05003900 }
3901 return unknownType
3902}
3903
Colin Crosscfad1192015-11-02 16:43:11 -08003904// Defaults
Colin Crossca860ac2016-01-04 14:34:37 -08003905type Defaults struct {
Colin Cross635c3b02016-05-18 15:37:25 -07003906 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -07003907 android.DefaultsModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +09003908 android.ApexModuleBase
Colin Crosscfad1192015-11-02 16:43:11 -08003909}
3910
Patrice Arrudac249c712019-03-19 17:00:29 -07003911// cc_defaults provides a set of properties that can be inherited by other cc
3912// modules. A module can use the properties from a cc_defaults using
3913// `defaults: ["<:default_module_name>"]`. Properties of both modules are
3914// merged (when possible) by prepending the default module's values to the
3915// depending module's values.
Colin Cross36242852017-06-23 15:06:31 -07003916func defaultsFactory() android.Module {
Colin Crosse1d764e2016-08-18 14:18:32 -07003917 return DefaultsFactory()
3918}
3919
Colin Cross36242852017-06-23 15:06:31 -07003920func DefaultsFactory(props ...interface{}) android.Module {
Colin Crossca860ac2016-01-04 14:34:37 -08003921 module := &Defaults{}
Colin Crosscfad1192015-11-02 16:43:11 -08003922
Colin Cross36242852017-06-23 15:06:31 -07003923 module.AddProperties(props...)
3924 module.AddProperties(
Colin Crossca860ac2016-01-04 14:34:37 -08003925 &BaseProperties{},
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003926 &VendorProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003927 &BaseCompilerProperties{},
3928 &BaseLinkerProperties{},
Paul Duffina37832a2019-07-18 12:31:26 +01003929 &ObjectLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003930 &LibraryProperties{},
Colin Crosse1bb5d02019-09-24 14:55:04 -07003931 &StaticProperties{},
3932 &SharedProperties{},
Colin Cross919281a2016-04-05 16:42:05 -07003933 &FlagExporterProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003934 &BinaryLinkerProperties{},
Trevor Radcliffef389cb42022-03-24 21:06:14 +00003935 &TestLinkerProperties{},
3936 &TestInstallerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003937 &TestBinaryProperties{},
Colin Cross43287652020-06-30 10:15:07 -07003938 &BenchmarkProperties{},
hamzehc0a671f2021-07-22 12:05:08 -07003939 &fuzz.FuzzProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003940 &StlProperties{},
Colin Cross16b23492016-01-06 14:41:07 -08003941 &SanitizeProperties{},
Colin Cross665dce92016-04-28 14:50:03 -07003942 &StripProperties{},
Dan Willemsen7424d612016-09-01 13:45:39 -07003943 &InstallerProperties{},
Dan Willemsena03cf6d2016-09-26 15:45:04 -07003944 &TidyProperties{},
Dan Willemsen581341d2017-02-09 16:16:31 -08003945 &CoverageProperties{},
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08003946 &SAbiProperties{},
Stephen Craneba090d12017-05-09 15:44:35 -07003947 &LTOProperties{},
Yi Kongeb8efc92021-12-09 18:06:29 +08003948 &AfdoProperties{},
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00003949 &OrderfileProperties{},
Dan Willemsen6424d172018-03-08 13:27:59 -08003950 &android.ProtoProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -04003951 // RustBindgenProperties is included here so that cc_defaults can be used for rust_bindgen modules.
3952 &RustBindgenClangProperties{},
Yu-Chi Cheng24b2b0f2021-06-23 15:56:39 -07003953 &prebuiltLinkerProperties{},
Colin Crosse1d764e2016-08-18 14:18:32 -07003954 )
Colin Crosscfad1192015-11-02 16:43:11 -08003955
Jooyung Hancc372c52019-09-25 15:18:44 +09003956 android.InitDefaultsModule(module)
Colin Cross36242852017-06-23 15:06:31 -07003957
3958 return module
Colin Crosscfad1192015-11-02 16:43:11 -08003959}
3960
Jiyong Park2286afd2020-06-16 21:58:53 +09003961func (c *Module) IsSdkVariant() bool {
Lukacs T. Berki2063a0d2021-06-17 09:32:36 +02003962 return c.Properties.IsSdkVariant
Jiyong Park2286afd2020-06-16 21:58:53 +09003963}
3964
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003965func kytheExtractAllFactory() android.Singleton {
3966 return &kytheExtractAllSingleton{}
3967}
3968
3969type kytheExtractAllSingleton struct {
3970}
3971
3972func (ks *kytheExtractAllSingleton) GenerateBuildActions(ctx android.SingletonContext) {
3973 var xrefTargets android.Paths
3974 ctx.VisitAllModules(func(module android.Module) {
3975 if ccModule, ok := module.(xref); ok {
3976 xrefTargets = append(xrefTargets, ccModule.XrefCcFiles()...)
3977 }
3978 })
3979 // TODO(asmundak): Perhaps emit a rule to output a warning if there were no xrefTargets
3980 if len(xrefTargets) > 0 {
Colin Crossc3d87d32020-06-04 13:25:17 -07003981 ctx.Phony("xref_cxx", xrefTargets...)
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003982 }
3983}
3984
Jihoon Kangf78a8902022-09-01 22:47:07 +00003985func (c *Module) Partition() string {
3986 if p, ok := c.installer.(interface {
3987 getPartition() string
3988 }); ok {
3989 return p.getPartition()
3990 }
3991 return ""
3992}
3993
Spandan Das2b6dfb52024-01-19 00:22:22 +00003994type sourceModuleName interface {
3995 sourceModuleName() string
3996}
3997
3998func (c *Module) BaseModuleName() string {
3999 if smn, ok := c.linker.(sourceModuleName); ok && smn.sourceModuleName() != "" {
4000 // if the prebuilt module sets a source_module_name in Android.bp, use that
4001 return smn.sourceModuleName()
4002 }
4003 return c.ModuleBase.BaseModuleName()
4004}
4005
Spandan Dase20c56c2024-07-23 21:34:24 +00004006func (c *Module) stubsSymbolFilePath() android.Path {
4007 if library, ok := c.linker.(*libraryDecorator); ok {
4008 return library.stubsSymbolFilePath
4009 }
4010 return android.OptionalPath{}.Path()
4011}
4012
Colin Cross06a931b2015-10-28 17:23:31 -07004013var Bool = proptools.Bool
Colin Cross38b40df2018-04-10 16:14:46 -07004014var BoolDefault = proptools.BoolDefault
Nan Zhang0007d812017-11-07 10:57:05 -08004015var BoolPtr = proptools.BoolPtr
4016var String = proptools.String
4017var StringPtr = proptools.StringPtr