blob: 65ab68604533fe9b64f53db86171a56e0707315f [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
Yu Liu76d94462024-10-31 23:32:36 +000040type CcMakeVarsInfo struct {
41 WarningsAllowed string
42 UsingWnoError string
43 MissingProfile string
44}
45
46var CcMakeVarsInfoProvider = blueprint.NewProvider[*CcMakeVarsInfo]()
47
Yu Liuec7043d2024-11-05 18:22:20 +000048type CcObjectInfo struct {
49 objFiles android.Paths
50 tidyFiles android.Paths
51 kytheFiles android.Paths
52}
53
54var CcObjectInfoProvider = blueprint.NewProvider[CcObjectInfo]()
55
Yu Liu986d98c2024-11-12 00:28:11 +000056type LinkableInfo struct {
57 // StaticExecutable returns true if this is a binary module with "static_executable: true".
58 StaticExecutable bool
59}
60
61var LinkableInfoKey = blueprint.NewProvider[LinkableInfo]()
62
Colin Cross463a90e2015-06-17 14:20:06 -070063func init() {
Paul Duffin036e7002019-12-19 19:16:28 +000064 RegisterCCBuildComponents(android.InitRegistrationContext)
Colin Cross463a90e2015-06-17 14:20:06 -070065
Inseob Kim3b244062023-07-11 13:31:36 +090066 pctx.Import("android/soong/android")
Paul Duffin036e7002019-12-19 19:16:28 +000067 pctx.Import("android/soong/cc/config")
68}
69
70func RegisterCCBuildComponents(ctx android.RegistrationContext) {
71 ctx.RegisterModuleType("cc_defaults", defaultsFactory)
72
73 ctx.PreDepsMutators(func(ctx android.RegisterMutatorsContext) {
Colin Crossac57a6c2024-06-26 13:09:53 -070074 ctx.Transition("sdk", &sdkTransitionMutator{})
Colin Cross8a962802024-10-09 15:29:27 -070075 ctx.BottomUp("llndk", llndkMutator)
Colin Cross767819f2024-05-22 14:22:34 -070076 ctx.Transition("link", &linkageTransitionMutator{})
Colin Crossadd04a82024-05-22 09:57:59 -070077 ctx.Transition("version", &versionTransitionMutator{})
Colin Cross8a962802024-10-09 15:29:27 -070078 ctx.BottomUp("begin", BeginMutator)
Colin Cross1e676be2016-10-12 14:38:15 -070079 })
Colin Cross16b23492016-01-06 14:41:07 -080080
Paul Duffin036e7002019-12-19 19:16:28 +000081 ctx.PostDepsMutators(func(ctx android.RegisterMutatorsContext) {
Liz Kammer75db9312021-07-07 16:41:50 -040082 for _, san := range Sanitizers {
83 san.registerMutators(ctx)
84 }
Dan Willemsen581341d2017-02-09 16:16:31 -080085
Colin Cross8a962802024-10-09 15:29:27 -070086 ctx.BottomUp("sanitize_runtime_deps", sanitizerRuntimeDepsMutator)
87 ctx.BottomUp("sanitize_runtime", sanitizerRuntimeMutator)
Ivan Lozano30c5db22018-02-21 15:49:20 -080088
Colin Cross597bad62024-10-08 15:10:55 -070089 ctx.Transition("fuzz", &fuzzTransitionMutator{})
Cory Barkera1da26f2022-06-07 20:12:06 +000090
Colin Crossf5f4ad32024-01-19 15:41:48 -080091 ctx.Transition("coverage", &coverageTransitionMutator{})
Stephen Craneba090d12017-05-09 15:44:35 -070092
Colin Crossd38feb02024-01-23 16:38:06 -080093 ctx.Transition("afdo", &afdoTransitionMutator{})
Yi Kongeb8efc92021-12-09 18:06:29 +080094
Colin Cross33e0c812024-01-23 16:36:07 -080095 ctx.Transition("orderfile", &orderfileTransitionMutator{})
Sharjeel Khanc6a93d82023-07-18 21:01:11 +000096
Colin Cross6ac83a82024-01-23 11:23:10 -080097 ctx.Transition("lto", &ltoTransitionMutator{})
Jooyung Hana70f0672019-01-18 15:20:43 +090098
Colin Cross8a962802024-10-09 15:29:27 -070099 ctx.BottomUp("check_linktype", checkLinkTypeMutator)
100 ctx.BottomUp("double_loadable", checkDoubleLoadableLibraries)
Colin Cross1e676be2016-10-12 14:38:15 -0700101 })
Colin Crossb98c8b02016-07-29 13:44:28 -0700102
Colin Cross91ae5ec2024-10-01 14:03:40 -0700103 ctx.PostApexMutators(func(ctx android.RegisterMutatorsContext) {
Yo Chiang8aa4e3f2020-11-19 16:30:49 +0800104 // sabi mutator needs to be run after apex mutator finishes.
Colin Cross91ae5ec2024-10-01 14:03:40 -0700105 ctx.Transition("sabi", &sabiTransitionMutator{})
Yo Chiang8aa4e3f2020-11-19 16:30:49 +0800106 })
107
LaMont Jones0c10e4d2023-05-16 00:58:37 +0000108 ctx.RegisterParallelSingletonType("kythe_extract_all", kytheExtractAllFactory)
Colin Cross463a90e2015-06-17 14:20:06 -0700109}
110
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500111// Deps is a struct containing module names of dependencies, separated by the kind of dependency.
112// Mutators should use `AddVariationDependencies` or its sibling methods to add actual dependency
113// edges to these modules.
114// This object is constructed in DepsMutator, by calling to various module delegates to set
115// relevant fields. For example, `module.compiler.compilerDeps()` may append type-specific
116// dependencies.
117// This is then consumed by the same DepsMutator, which will call `ctx.AddVariationDependencies()`
118// (or its sibling methods) to set real dependencies on the given modules.
Colin Crossca860ac2016-01-04 14:34:37 -0800119type Deps struct {
120 SharedLibs, LateSharedLibs []string
121 StaticLibs, LateStaticLibs, WholeStaticLibs []string
Colin Cross5950f382016-12-13 12:50:57 -0800122 HeaderLibs []string
Logan Chien43d34c32017-12-20 01:17:32 +0800123 RuntimeLibs []string
Colin Crossc472d572015-03-17 15:06:21 -0700124
Colin Cross3e5e7782022-06-17 22:17:05 +0000125 // UnexportedStaticLibs are static libraries that are also passed to -Wl,--exclude-libs= to
126 // prevent automatically exporting symbols.
127 UnexportedStaticLibs []string
128
Chris Parsons79d66a52020-06-05 17:26:16 -0400129 // Used for data dependencies adjacent to tests
130 DataLibs []string
Colin Crossc8caa062021-09-24 16:50:14 -0700131 DataBins []string
Chris Parsons79d66a52020-06-05 17:26:16 -0400132
Yo Chiang219968c2020-09-22 18:45:04 +0800133 // Used by DepsMutator to pass system_shared_libs information to check_elf_file.py.
134 SystemSharedLibs []string
135
Vinh Tran367d89d2023-04-28 11:21:25 -0400136 // Used by DepMutator to pass aidl_library modules to aidl compiler
137 AidlLibs []string
138
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500139 // If true, statically link the unwinder into native libraries/binaries.
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800140 StaticUnwinderIfLegacy bool
141
Colin Cross5950f382016-12-13 12:50:57 -0800142 ReexportSharedLibHeaders, ReexportStaticLibHeaders, ReexportHeaderLibHeaders []string
Dan Willemsen490a8dc2016-06-06 18:22:19 -0700143
Colin Cross81413472016-04-11 14:37:39 -0700144 ObjFiles []string
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700145
Cole Faust65cb40a2024-10-21 15:41:42 -0700146 GeneratedSources []string
147 GeneratedHeaders []string
148 DeviceFirstGeneratedHeaders []string
149 GeneratedDeps []string
Dan Willemsenb40aab62016-04-20 14:21:14 -0700150
Dan Willemsenb3454ab2016-09-28 17:34:58 -0700151 ReexportGeneratedHeaders []string
152
Colin Crossc465efd2021-06-11 18:00:04 -0700153 CrtBegin, CrtEnd []string
Dan Willemsena0790e32018-10-12 00:24:23 -0700154
155 // Used for host bionic
Colin Cross9cfe6112021-06-11 18:02:22 -0700156 DynamicLinker string
Jiyong Parke3867542020-12-03 17:28:25 +0900157
158 // List of libs that need to be excluded for APEX variant
159 ExcludeLibsForApex []string
Jooyung Han9ffbe832023-11-28 22:31:35 +0900160 // List of libs that need to be excluded for non-APEX variant
161 ExcludeLibsForNonApex []string
Hsin-Yi Chen715142a2024-03-27 16:31:16 +0800162
163 // LLNDK headers for the ABI checker to check LLNDK implementation library.
164 // An LLNDK implementation is the core variant. LLNDK header libs are reexported by the vendor variant.
Colin Cross1e954b62024-09-13 13:50:00 -0700165 // The core variant cannot depend on the vendor variant because of the order of imageTransitionMutator.Split().
Hsin-Yi Chen715142a2024-03-27 16:31:16 +0800166 // Instead, the LLNDK implementation depends on the LLNDK header libs.
167 LlndkHeaderLibs []string
Colin Crossc472d572015-03-17 15:06:21 -0700168}
169
Ivan Lozano0a468a42024-05-13 21:03:34 -0400170// A struct which to collect flags for rlib dependencies
171type RustRlibDep struct {
172 LibPath android.Path // path to the rlib
173 LinkDirs []string // flags required for dependency (e.g. -L flags)
174 CrateName string // crateNames associated with rlibDeps
175}
176
177func EqRustRlibDeps(a RustRlibDep, b RustRlibDep) bool {
178 return a.LibPath == b.LibPath
179}
180
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500181// PathDeps is a struct containing file paths to dependencies of a module.
182// It's constructed in depsToPath() by traversing the direct dependencies of the current module.
183// It's used to construct flags for various build statements (such as for compiling and linking).
184// It is then passed to module decorator functions responsible for registering build statements
185// (such as `module.compiler.compile()`).`
Colin Crossca860ac2016-01-04 14:34:37 -0800186type PathDeps struct {
Colin Cross26c34ed2016-09-30 17:10:16 -0700187 // Paths to .so files
Jiyong Park64a44f22019-01-18 14:37:08 +0900188 SharedLibs, EarlySharedLibs, LateSharedLibs android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700189 // Paths to the dependencies to use for .so files (.so.toc files)
Jiyong Park64a44f22019-01-18 14:37:08 +0900190 SharedLibsDeps, EarlySharedLibsDeps, LateSharedLibsDeps android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700191 // Paths to .a files
Colin Cross635c3b02016-05-18 15:37:25 -0700192 StaticLibs, LateStaticLibs, WholeStaticLibs android.Paths
Ivan Lozano0a468a42024-05-13 21:03:34 -0400193 // Paths and crateNames for RustStaticLib dependencies
194 RustRlibDeps []RustRlibDep
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700195
Colin Cross0de8a1e2020-09-18 14:15:30 -0700196 // Transitive static library dependencies of static libraries for use in ordering.
Colin Crossa14fb6a2024-10-23 16:57:06 -0700197 TranstiveStaticLibrariesForOrdering depset.DepSet[android.Path]
Colin Cross0de8a1e2020-09-18 14:15:30 -0700198
Colin Cross26c34ed2016-09-30 17:10:16 -0700199 // Paths to .o files
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100200 Objs Objects
201 // Paths to .o files in dependencies that provide them. Note that these lists
202 // aren't complete since prebuilt modules don't provide the .o files.
Dan Willemsen581341d2017-02-09 16:16:31 -0800203 StaticLibObjs Objects
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700204 WholeStaticLibObjs Objects
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700205
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100206 // Paths to .a files in prebuilts. Complements WholeStaticLibObjs to contain
207 // the libs from all whole_static_lib dependencies.
208 WholeStaticLibsFromPrebuilts android.Paths
209
Colin Cross26c34ed2016-09-30 17:10:16 -0700210 // Paths to generated source files
Colin Cross635c3b02016-05-18 15:37:25 -0700211 GeneratedSources android.Paths
Inseob Kimd110f872019-12-06 13:15:38 +0900212 GeneratedDeps android.Paths
Dan Willemsenb40aab62016-04-20 14:21:14 -0700213
Inseob Kimd110f872019-12-06 13:15:38 +0900214 Flags []string
Colin Cross3e5e7782022-06-17 22:17:05 +0000215 LdFlags []string
Inseob Kimd110f872019-12-06 13:15:38 +0900216 IncludeDirs android.Paths
217 SystemIncludeDirs android.Paths
218 ReexportedDirs android.Paths
219 ReexportedSystemDirs android.Paths
220 ReexportedFlags []string
221 ReexportedGeneratedHeaders android.Paths
222 ReexportedDeps android.Paths
Ivan Lozano0a468a42024-05-13 21:03:34 -0400223 ReexportedRustRlibDeps []RustRlibDep
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700224
Colin Cross26c34ed2016-09-30 17:10:16 -0700225 // Paths to crt*.o files
Colin Crossc465efd2021-06-11 18:00:04 -0700226 CrtBegin, CrtEnd android.Paths
Dan Willemsena0790e32018-10-12 00:24:23 -0700227
Dan Willemsena0790e32018-10-12 00:24:23 -0700228 // Path to the dynamic linker binary
229 DynamicLinker android.OptionalPath
Dan Willemsen47450072021-10-19 20:24:49 -0700230
231 // For Darwin builds, the path to the second architecture's output that should
232 // be combined with this architectures's output into a FAT MachO file.
233 DarwinSecondArchOutput android.OptionalPath
Vinh Tran367d89d2023-04-28 11:21:25 -0400234
235 // Paths to direct srcs and transitive include dirs from direct aidl_library deps
236 AidlLibraryInfos []aidl_library.AidlLibraryInfo
Hsin-Yi Chen715142a2024-03-27 16:31:16 +0800237
238 // LLNDK headers for the ABI checker to check LLNDK implementation library.
239 LlndkIncludeDirs android.Paths
240 LlndkSystemIncludeDirs android.Paths
Colin Crossb614cd42024-10-11 12:52:21 -0700241
242 directImplementationDeps android.Paths
243 transitiveImplementationDeps []depset.DepSet[android.Path]
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700244}
245
Colin Cross4af21ed2019-11-04 09:37:55 -0800246// LocalOrGlobalFlags contains flags that need to have values set globally by the build system or locally by the module
247// tracked separately, in order to maintain the required ordering (most of the global flags need to go first on the
248// command line so they can be overridden by the local module flags).
249type LocalOrGlobalFlags struct {
250 CommonFlags []string // Flags that apply to C, C++, and assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700251 AsFlags []string // Flags that apply to assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800252 YasmFlags []string // Flags that apply to yasm assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700253 CFlags []string // Flags that apply to C and C++ source files
254 ToolingCFlags []string // Flags that apply to C and C++ source files parsed by clang LibTooling tools
255 ConlyFlags []string // Flags that apply to C source files
256 CppFlags []string // Flags that apply to C++ source files
257 ToolingCppFlags []string // Flags that apply to C++ source files parsed by clang LibTooling tools
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700258 LdFlags []string // Flags that apply to linker command lines
Colin Cross4af21ed2019-11-04 09:37:55 -0800259}
260
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500261// Flags contains various types of command line flags (and settings) for use in building build
262// statements related to C++.
Colin Cross4af21ed2019-11-04 09:37:55 -0800263type Flags struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500264 // Local flags (which individual modules are responsible for). These may override global flags.
265 Local LocalOrGlobalFlags
266 // Global flags (which build system or toolchain is responsible for).
Luis Useche342fa6b2024-04-01 19:33:18 -0700267 Global LocalOrGlobalFlags
268 NoOverrideFlags []string // Flags applied to the end of list of flags so they are not overridden
Colin Cross4af21ed2019-11-04 09:37:55 -0800269
270 aidlFlags []string // Flags that apply to aidl source files
271 rsFlags []string // Flags that apply to renderscript source files
272 libFlags []string // Flags to add libraries early to the link order
273 extraLibFlags []string // Flags to add libraries late in the link order after LdFlags
274 TidyFlags []string // Flags that apply to clang-tidy
275 SAbiFlags []string // Flags that apply to header-abi-dumper
Colin Cross28344522015-04-22 13:07:53 -0700276
Colin Crossc3199482017-03-30 15:03:04 -0700277 // Global include flags that apply to C, C++, and assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800278 // These must be after any module include flags, which will be in CommonFlags.
Colin Crossc3199482017-03-30 15:03:04 -0700279 SystemIncludeFlags []string
280
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800281 Toolchain config.Toolchain
282 Tidy bool // True if ninja .tidy rules should be generated.
283 NeedTidyFiles bool // True if module link should depend on .tidy files
284 GcovCoverage bool // True if coverage files should be generated.
285 SAbiDump bool // True if header abi dumps should be generated.
286 EmitXrefs bool // If true, generate Ninja rules to generate emitXrefs input files for Kythe
kellyhungd62ea302024-05-19 21:16:07 +0800287 ClangVerify bool // If true, append cflags "-Xclang -verify" and append "&& touch $out" to the clang command line.
Colin Crossca860ac2016-01-04 14:34:37 -0800288
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500289 // The instruction set required for clang ("arm" or "thumb").
Colin Crossca860ac2016-01-04 14:34:37 -0800290 RequiredInstructionSet string
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500291 // The target-device system path to the dynamic linker.
292 DynamicLinker string
Colin Cross16b23492016-01-06 14:41:07 -0800293
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700294 CFlagsDeps android.Paths // Files depended on by compiler flags
295 LdFlagsDeps android.Paths // Files depended on by linker flags
Colin Cross18c0c5a2016-12-01 14:45:23 -0800296
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500297 // True if .s files should be processed with the c preprocessor.
Dan Willemsen98ab3112019-08-27 21:20:40 -0700298 AssemblerWithCpp bool
Dan Willemsen60e62f02018-11-16 21:05:32 -0800299
Colin Cross19878da2019-03-28 14:45:07 -0700300 proto android.ProtoFlags
Colin Cross19878da2019-03-28 14:45:07 -0700301 protoC bool // Whether to use C instead of C++
302 protoOptionsFile bool // Whether to look for a .options file next to the .proto
Dan Willemsen4e0aa232019-04-10 22:59:54 -0700303
304 Yacc *YaccProperties
Matthias Maennich22fd4d12020-07-15 10:58:56 +0200305 Lex *LexProperties
Colin Crossc472d572015-03-17 15:06:21 -0700306}
307
Colin Crossca860ac2016-01-04 14:34:37 -0800308// Properties used to compile all C or C++ modules
309type BaseProperties struct {
Dan Willemsen742a5452018-07-23 17:19:36 -0700310 // Deprecated. true is the default, false is invalid.
Colin Crossca860ac2016-01-04 14:34:37 -0800311 Clang *bool `android:"arch_variant"`
Colin Cross7d5136f2015-05-11 13:39:40 -0700312
Yi Kong5786f5c2024-05-28 02:22:34 +0900313 // Aggresively trade performance for smaller binary size.
314 // This should only be used for on-device binaries that are rarely executed and not
315 // performance critical.
316 Optimize_for_size *bool `android:"arch_variant"`
317
Jiyong Parkb35a8192020-08-10 15:59:36 +0900318 // The API level that this module is built against. The APIs of this API level will be
319 // visible at build time, but use of any APIs newer than min_sdk_version will render the
320 // module unloadable on older devices. In the future it will be possible to weakly-link new
321 // APIs, making the behavior match Java: such modules will load on older devices, but
322 // calling new APIs on devices that do not support them will result in a crash.
323 //
324 // This property has the same behavior as sdk_version does for Java modules. For those
325 // familiar with Android Gradle, the property behaves similarly to how compileSdkVersion
326 // does for Java code.
327 //
328 // In addition, setting this property causes two variants to be built, one for the platform
329 // and one for apps.
Nan Zhang0007d812017-11-07 10:57:05 -0800330 Sdk_version *string
Colin Cross7d5136f2015-05-11 13:39:40 -0700331
Jiyong Parkb35a8192020-08-10 15:59:36 +0900332 // Minimum OS API level supported by this C or C++ module. This property becomes the value
333 // of the __ANDROID_API__ macro. When the C or C++ module is included in an APEX or an APK,
334 // this property is also used to ensure that the min_sdk_version of the containing module is
335 // not older (i.e. less) than this module's min_sdk_version. When not set, this property
336 // defaults to the value of sdk_version. When this is set to "apex_inherit", this tracks
337 // min_sdk_version of the containing APEX. When the module
338 // is not built for an APEX, "apex_inherit" defaults to sdk_version.
Jooyung Han379660c2020-04-21 15:24:00 +0900339 Min_sdk_version *string
340
Colin Crossc511bc52020-04-07 16:50:32 +0000341 // If true, always create an sdk variant and don't create a platform variant.
342 Sdk_variant_only *bool
343
Colin Cross4297f402024-11-20 15:20:09 -0800344 AndroidMkSharedLibs []string `blueprint:"mutated"`
345 AndroidMkStaticLibs []string `blueprint:"mutated"`
346 AndroidMkRlibs []string `blueprint:"mutated"`
347 AndroidMkRuntimeLibs []string `blueprint:"mutated"`
348 AndroidMkWholeStaticLibs []string `blueprint:"mutated"`
349 AndroidMkHeaderLibs []string `blueprint:"mutated"`
350 HideFromMake bool `blueprint:"mutated"`
351 PreventInstall bool `blueprint:"mutated"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700352
Yo Chiang219968c2020-09-22 18:45:04 +0800353 // Set by DepsMutator.
354 AndroidMkSystemSharedLibs []string `blueprint:"mutated"`
355
Kiyoung Kimb5fdb2e2024-01-03 14:24:34 +0900356 // The name of the image this module is built for
357 ImageVariation string `blueprint:"mutated"`
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200358
359 // The VNDK version this module is built against. If empty, the module is not
360 // build against the VNDK.
361 VndkVersion string `blueprint:"mutated"`
362
363 // Suffix for the name of Android.mk entries generated by this module
364 SubName string `blueprint:"mutated"`
Colin Cross5beccee2017-12-07 15:28:59 -0800365
366 // *.logtags files, to combine together in order to generate the /system/etc/event-log-tags
367 // file
Inseob Kim37e0bb02024-04-29 15:54:44 +0900368 Logtags []string `android:"path"`
Jiyong Parkf9332f12018-02-01 00:54:12 +0900369
Yifan Hong39143a92020-10-26 12:43:12 -0700370 // Make this module available when building for ramdisk.
371 // On device without a dedicated recovery partition, the module is only
372 // available after switching root into
373 // /first_stage_ramdisk. To expose the module before switching root, install
374 // the recovery variant instead.
Yifan Hong1b3348d2020-01-21 15:53:22 -0800375 Ramdisk_available *bool
376
Yifan Hong39143a92020-10-26 12:43:12 -0700377 // Make this module available when building for vendor ramdisk.
378 // On device without a dedicated recovery partition, the module is only
379 // available after switching root into
380 // /first_stage_ramdisk. To expose the module before switching root, install
381 // the recovery variant instead.
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700382 Vendor_ramdisk_available *bool
383
Jiyong Parkf9332f12018-02-01 00:54:12 +0900384 // Make this module available when building for recovery
385 Recovery_available *bool
386
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200387 // Used by imageMutator, set by ImageMutatorBegin()
Jihoon Kang47e91842024-06-19 00:51:16 +0000388 VendorVariantNeeded bool `blueprint:"mutated"`
389 ProductVariantNeeded bool `blueprint:"mutated"`
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200390 CoreVariantNeeded bool `blueprint:"mutated"`
391 RamdiskVariantNeeded bool `blueprint:"mutated"`
392 VendorRamdiskVariantNeeded bool `blueprint:"mutated"`
393 RecoveryVariantNeeded bool `blueprint:"mutated"`
394
395 // A list of variations for the "image" mutator of the form
396 //<image name> '.' <version char>, for example, 'vendor.S'
397 ExtraVersionedImageVariations []string `blueprint:"mutated"`
Jiyong Parkb0788572018-12-20 22:10:17 +0900398
399 // Allows this module to use non-APEX version of libraries. Useful
400 // for building binaries that are started before APEXes are activated.
401 Bootstrap *bool
Jooyung Han097087b2019-10-22 19:32:18 +0900402
Hao Chen1c8ea5b2023-10-20 23:03:45 +0000403 // Allows this module to be included in CMake release snapshots to be built outside of Android
404 // build system and source tree.
405 Cmake_snapshot_supported *bool
406
Colin Cross1bc94122021-10-28 13:25:54 -0700407 Installable *bool `android:"arch_variant"`
Colin Crossc511bc52020-04-07 16:50:32 +0000408
409 // Set by factories of module types that can only be referenced from variants compiled against
410 // the SDK.
411 AlwaysSdk bool `blueprint:"mutated"`
412
413 // Variant is an SDK variant created by sdkMutator
414 IsSdkVariant bool `blueprint:"mutated"`
415 // Set when both SDK and platform variants are exported to Make to trigger renaming the SDK
416 // variant to have a ".sdk" suffix.
417 SdkAndPlatformVariantVisibleToMake bool `blueprint:"mutated"`
Bill Peckham945441c2020-08-31 16:07:58 -0700418
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800419 Target struct {
420 Platform struct {
421 // List of modules required by the core variant.
422 Required []string `android:"arch_variant"`
423
424 // List of modules not required by the core variant.
425 Exclude_required []string `android:"arch_variant"`
426 } `android:"arch_variant"`
427
428 Recovery struct {
429 // List of modules required by the recovery variant.
430 Required []string `android:"arch_variant"`
431
432 // List of modules not required by the recovery variant.
433 Exclude_required []string `android:"arch_variant"`
434 } `android:"arch_variant"`
435 } `android:"arch_variant"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700436}
437
438type VendorProperties struct {
Jiyong Park82e2bf32017-08-16 14:05:54 +0900439 // whether this module should be allowed to be directly depended by other
440 // modules with `vendor: true`, `proprietary: true`, or `vendor_available:true`.
Justin Yun63e9ec72020-10-29 16:49:43 +0900441 // If set to true, two variants will be built separately, one like
442 // normal, and the other limited to the set of libraries and headers
443 // that are exposed to /vendor modules.
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700444 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900445 // The vendor variant may be used with a different (newer) /system,
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700446 // so it shouldn't have any unversioned runtime dependencies, or
447 // make assumptions about the system that may not be true in the
448 // future.
449 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900450 // If set to false, this module becomes inaccessible from /vendor modules.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900451 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900452 // The modules with vndk: {enabled: true} must define 'vendor_available'
Justin Yun0b1db6d2021-01-08 15:22:34 +0900453 // to 'true'.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900454 //
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700455 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
456 Vendor_available *bool
Jiyong Park5fb8c102018-04-09 12:03:06 +0900457
Justin Yunebcf0c52021-01-08 18:00:19 +0900458 // This is the same as the "vendor_available" except that the install path
459 // of the vendor variant is /odm or /vendor/odm.
460 // By replacing "vendor_available: true" with "odm_available: true", the
461 // module will install its vendor variant to the /odm partition or /vendor/odm.
462 // As the modules with "odm_available: true" still create the vendor variants,
463 // they can link to the other vendor modules as the vendor_available modules do.
464 // Also, the vendor modules can link to odm_available modules.
465 //
466 // It may not be used for VNDK modules.
467 Odm_available *bool
468
Justin Yun63e9ec72020-10-29 16:49:43 +0900469 // whether this module should be allowed to be directly depended by other
470 // modules with `product_specific: true` or `product_available: true`.
471 // If set to true, an additional product variant will be built separately
472 // that is limited to the set of libraries and headers that are exposed to
473 // /product modules.
474 //
475 // The product variant may be used with a different (newer) /system,
476 // so it shouldn't have any unversioned runtime dependencies, or
477 // make assumptions about the system that may not be true in the
478 // future.
479 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900480 // If set to false, this module becomes inaccessible from /product modules.
481 //
482 // Different from the 'vendor_available' property, the modules with
483 // vndk: {enabled: true} don't have to define 'product_available'. The VNDK
484 // library without 'product_available' may not be depended on by any other
485 // modules that has product variants including the product available VNDKs.
Justin Yun63e9ec72020-10-29 16:49:43 +0900486 //
487 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
488 // and PRODUCT_PRODUCT_VNDK_VERSION isn't set.
489 Product_available *bool
490
Jiyong Park5fb8c102018-04-09 12:03:06 +0900491 // whether this module is capable of being loaded with other instance
492 // (possibly an older version) of the same module in the same process.
493 // Currently, a shared library that is a member of VNDK (vndk: {enabled: true})
494 // can be double loaded in a vendor process if the library is also a
495 // (direct and indirect) dependency of an LLNDK library. Such libraries must be
496 // explicitly marked as `double_loadable: true` by the owner, or the dependency
497 // from the LLNDK lib should be cut if the lib is not designed to be double loaded.
498 Double_loadable *bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800499
500 // IsLLNDK is set to true for the vendor variant of a cc_library module that has LLNDK stubs.
501 IsLLNDK bool `blueprint:"mutated"`
502
Colin Cross5271fea2021-04-27 13:06:04 -0700503 // IsVendorPublicLibrary is set for the core and product variants of a library that has
504 // vendor_public_library stubs.
505 IsVendorPublicLibrary bool `blueprint:"mutated"`
Colin Crossca860ac2016-01-04 14:34:37 -0800506}
507
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500508// ModuleContextIntf is an interface (on a module context helper) consisting of functions related
509// to understanding details about the type of the current module.
510// For example, one might call these functions to determine whether the current module is a static
511// library and/or is installed in vendor directories.
Colin Crossca860ac2016-01-04 14:34:37 -0800512type ModuleContextIntf interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800513 static() bool
514 staticBinary() bool
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -0700515 testBinary() bool
Yi Kong56fc1b62022-09-06 16:24:00 +0800516 testLibrary() bool
Jiyong Park1d1119f2019-07-29 21:27:18 +0900517 header() bool
Inseob Kim7f283f42020-06-01 21:53:49 +0900518 binary() bool
Inseob Kim1042d292020-06-01 23:23:05 +0900519 object() bool
Colin Crossb98c8b02016-07-29 13:44:28 -0700520 toolchain() config.Toolchain
Jooyung Hanccce2f22020-03-07 03:45:53 +0900521 canUseSdk() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700522 useSdk() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800523 sdkVersion() string
Jiyong Parkb35a8192020-08-10 15:59:36 +0900524 minSdkVersion() string
525 isSdkVariant() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700526 useVndk() bool
Colin Cross95f1ca02020-10-29 20:47:22 -0700527 isNdk(config android.Config) bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800528 IsLlndk() bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800529 isImplementationForLLNDKPublic() bool
Colin Cross5271fea2021-04-27 13:06:04 -0700530 IsVendorPublicLibrary() bool
Justin Yun5f7f7e82019-11-18 19:52:14 +0900531 inProduct() bool
532 inVendor() bool
Yifan Hong1b3348d2020-01-21 15:53:22 -0800533 inRamdisk() bool
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700534 inVendorRamdisk() bool
Jiyong Parkf9332f12018-02-01 00:54:12 +0900535 inRecovery() bool
Kiyoung Kimaa394802024-01-08 12:55:45 +0900536 InVendorOrProduct() bool
Dan Willemsen8146b2f2016-03-30 21:00:30 -0700537 selectedStl() string
Colin Crossce75d2c2016-10-06 16:12:58 -0700538 baseModuleName() string
Colin Cross3513fb12024-01-24 14:44:47 -0800539 isAfdoCompile(ctx ModuleContext) bool
Sharjeel Khanc6a93d82023-07-18 21:01:11 +0000540 isOrderfileCompile() bool
Yi Kongc702ebd2022-08-19 16:02:45 +0800541 isCfi() bool
Yi Konged79fa32023-06-04 17:15:42 +0900542 isFuzzer() bool
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800543 isNDKStubLibrary() bool
Ivan Lozanobd721262018-11-27 14:33:03 -0800544 useClangLld(actx ModuleContext) bool
Logan Chiene274fc92019-12-03 11:18:32 -0800545 isForPlatform() bool
Colin Crosse07f2312020-08-13 11:24:56 -0700546 apexVariationName() string
Dan Albertc8060532020-07-22 22:32:17 -0700547 apexSdkVersion() android.ApiLevel
Jiyong Parka4b9dd02019-01-16 22:53:13 +0900548 bootstrap() bool
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700549 nativeCoverage() bool
Colin Cross95b07f22020-12-16 11:06:50 -0800550 isPreventInstall() bool
Cindy Zhou5d5cfc12021-01-09 08:25:22 -0800551 isCfiAssemblySupportEnabled() bool
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800552 getSharedFlags() *SharedFlags
Colin Cross4a9e6ec2023-12-18 15:29:41 -0800553 notInPlatform() bool
Yi Kong5786f5c2024-05-28 02:22:34 +0900554 optimizeForSize() bool
Yu Liu76d94462024-10-31 23:32:36 +0000555 getOrCreateMakeVarsInfo() *CcMakeVarsInfo
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800556}
557
558type SharedFlags struct {
559 numSharedFlags int
560 flagsMap map[string]string
Colin Crossca860ac2016-01-04 14:34:37 -0800561}
562
563type ModuleContext interface {
Colin Cross635c3b02016-05-18 15:37:25 -0700564 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800565 ModuleContextIntf
566}
567
568type BaseModuleContext interface {
Colin Cross0ea8ba82019-06-06 14:33:29 -0700569 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800570 ModuleContextIntf
571}
572
Colin Cross37047f12016-12-13 17:06:13 -0800573type DepsContext interface {
574 android.BottomUpMutatorContext
575 ModuleContextIntf
576}
577
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500578// feature represents additional (optional) steps to building cc-related modules, such as invocation
579// of clang-tidy.
Colin Crossca860ac2016-01-04 14:34:37 -0800580type feature interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800581 flags(ctx ModuleContext, flags Flags) Flags
582 props() []interface{}
583}
584
Joe Onorato37f900c2023-07-18 16:58:16 -0700585// Information returned from Generator about the source code it's generating
586type GeneratedSource struct {
587 IncludeDirs android.Paths
588 Sources android.Paths
589 Headers android.Paths
590 ReexportedDirs android.Paths
591}
592
593// generator allows injection of generated code
594type Generator interface {
595 GeneratorProps() []interface{}
596 GeneratorInit(ctx BaseModuleContext)
597 GeneratorDeps(ctx DepsContext, deps Deps) Deps
598 GeneratorFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
599 GeneratorSources(ctx ModuleContext) GeneratedSource
600 GeneratorBuildActions(ctx ModuleContext, flags Flags, deps PathDeps)
601}
602
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500603// compiler is the interface for a compiler helper object. Different module decorators may implement
Liz Kammer718eb272022-01-07 10:53:37 -0500604// this helper differently.
Colin Crossca860ac2016-01-04 14:34:37 -0800605type compiler interface {
Colin Cross42742b82016-08-01 13:20:05 -0700606 compilerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800607 compilerDeps(ctx DepsContext, deps Deps) Deps
Colin Crossf18e1102017-11-16 14:33:08 -0800608 compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
Colin Cross42742b82016-08-01 13:20:05 -0700609 compilerProps() []interface{}
Hao Chen1c8ea5b2023-10-20 23:03:45 +0000610 baseCompilerProps() BaseCompilerProperties
Colin Cross42742b82016-08-01 13:20:05 -0700611
Colin Cross76fada02016-07-27 10:31:13 -0700612 appendCflags([]string)
613 appendAsflags([]string)
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700614 compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects
Colin Crossca860ac2016-01-04 14:34:37 -0800615}
616
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500617// linker is the interface for a linker decorator object. Individual module types can provide
618// their own implementation for this decorator, and thus specify custom logic regarding build
619// statements pertaining to linking.
Colin Crossca860ac2016-01-04 14:34:37 -0800620type linker interface {
Colin Cross42742b82016-08-01 13:20:05 -0700621 linkerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800622 linkerDeps(ctx DepsContext, deps Deps) Deps
Colin Cross42742b82016-08-01 13:20:05 -0700623 linkerFlags(ctx ModuleContext, flags Flags) Flags
624 linkerProps() []interface{}
Hao Chen1c8ea5b2023-10-20 23:03:45 +0000625 baseLinkerProps() BaseLinkerProperties
Ivan Lozanobd721262018-11-27 14:33:03 -0800626 useClangLld(actx ModuleContext) bool
Colin Cross42742b82016-08-01 13:20:05 -0700627
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700628 link(ctx ModuleContext, flags Flags, deps PathDeps, objs Objects) android.Path
Colin Cross76fada02016-07-27 10:31:13 -0700629 appendLdflags([]string)
Jiyong Parkaf6d8952019-01-31 12:21:23 +0900630 unstrippedOutputFilePath() android.Path
Wei Li5f5d2712023-12-11 15:40:29 -0800631 strippedAllOutputFilePath() android.Path
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700632
633 nativeCoverage() bool
Jiyong Parkee9a98d2019-08-09 14:44:36 +0900634 coverageOutputFilePath() android.OptionalPath
Paul Duffin13f02712020-03-06 12:30:43 +0000635
636 // Get the deps that have been explicitly specified in the properties.
Cole Fauste8a87832024-09-11 11:35:46 -0700637 linkerSpecifiedDeps(ctx android.ConfigurableEvaluatorContext, module *Module, specifiedDeps specifiedDeps) specifiedDeps
Colin Cross4a9e6ec2023-12-18 15:29:41 -0800638
639 moduleInfoJSON(ctx ModuleContext, moduleInfoJSON *android.ModuleInfoJSON)
Paul Duffin13f02712020-03-06 12:30:43 +0000640}
641
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500642// specifiedDeps is a tuple struct representing dependencies of a linked binary owned by the linker.
Paul Duffin13f02712020-03-06 12:30:43 +0000643type specifiedDeps struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500644 sharedLibs []string
645 // Note nil and [] are semantically distinct. [] prevents linking against the defaults (usually
646 // libc, libm, etc.)
Colin Cross6b8f4252021-07-22 11:39:44 -0700647 systemSharedLibs []string
Colin Crossca860ac2016-01-04 14:34:37 -0800648}
649
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500650// installer is the interface for an installer helper object. This helper is responsible for
651// copying build outputs to the appropriate locations so that they may be installed on device.
Colin Crossca860ac2016-01-04 14:34:37 -0800652type installer interface {
Colin Cross42742b82016-08-01 13:20:05 -0700653 installerProps() []interface{}
Colin Cross635c3b02016-05-18 15:37:25 -0700654 install(ctx ModuleContext, path android.Path)
Paul Duffin0cb37b92020-03-04 14:52:46 +0000655 everInstallable() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800656 inData() bool
Vishwath Mohan1dd88392017-03-29 22:00:18 -0700657 inSanitizerDir() bool
Dan Willemsen4aa75ca2016-09-28 16:18:03 -0700658 hostToolPath() android.OptionalPath
Jiyong Parkb7c24df2019-02-01 12:03:59 +0900659 relativeInstallPath() string
Jingwen Chen8ac7d7d2023-03-20 11:05:16 +0000660 makeUninstallable(mod *Module)
Inseob Kim800d1142021-06-14 12:03:51 +0900661 installInRoot() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800662}
663
Inseob Kima1888ce2022-10-04 14:42:02 +0900664type overridable interface {
665 overriddenModules() []string
666}
667
Colin Cross6e511a92020-07-27 21:26:48 -0700668type libraryDependencyKind int
669
670const (
671 headerLibraryDependency = iota
672 sharedLibraryDependency
673 staticLibraryDependency
Ivan Lozano0a468a42024-05-13 21:03:34 -0400674 rlibLibraryDependency
Colin Cross6e511a92020-07-27 21:26:48 -0700675)
676
677func (k libraryDependencyKind) String() string {
678 switch k {
679 case headerLibraryDependency:
680 return "headerLibraryDependency"
681 case sharedLibraryDependency:
682 return "sharedLibraryDependency"
683 case staticLibraryDependency:
684 return "staticLibraryDependency"
Ivan Lozano0a468a42024-05-13 21:03:34 -0400685 case rlibLibraryDependency:
686 return "rlibLibraryDependency"
Colin Cross6e511a92020-07-27 21:26:48 -0700687 default:
688 panic(fmt.Errorf("unknown libraryDependencyKind %d", k))
689 }
690}
691
692type libraryDependencyOrder int
693
694const (
695 earlyLibraryDependency = -1
696 normalLibraryDependency = 0
697 lateLibraryDependency = 1
698)
699
700func (o libraryDependencyOrder) String() string {
701 switch o {
702 case earlyLibraryDependency:
703 return "earlyLibraryDependency"
704 case normalLibraryDependency:
705 return "normalLibraryDependency"
706 case lateLibraryDependency:
707 return "lateLibraryDependency"
708 default:
709 panic(fmt.Errorf("unknown libraryDependencyOrder %d", o))
710 }
711}
712
713// libraryDependencyTag is used to tag dependencies on libraries. Unlike many dependency
714// tags that have a set of predefined tag objects that are reused for each dependency, a
715// libraryDependencyTag is designed to contain extra metadata and is constructed as needed.
716// That means that comparing a libraryDependencyTag for equality will only be equal if all
717// of the metadata is equal. Most usages will want to type assert to libraryDependencyTag and
718// then check individual metadata fields instead.
719type libraryDependencyTag struct {
720 blueprint.BaseDependencyTag
721
722 // These are exported so that fmt.Printf("%#v") can call their String methods.
723 Kind libraryDependencyKind
724 Order libraryDependencyOrder
725
726 wholeStatic bool
727
728 reexportFlags bool
729 explicitlyVersioned bool
730 dataLib bool
731 ndk bool
732
733 staticUnwinder bool
734
735 makeSuffix string
Jiyong Parke3867542020-12-03 17:28:25 +0900736
Cindy Zhou18417cb2020-12-10 07:12:38 -0800737 // Whether or not this dependency should skip the apex dependency check
738 skipApexAllowedDependenciesCheck bool
739
Jiyong Parke3867542020-12-03 17:28:25 +0900740 // Whether or not this dependency has to be followed for the apex variants
741 excludeInApex bool
Jooyung Han9ffbe832023-11-28 22:31:35 +0900742 // Whether or not this dependency has to be followed for the non-apex variants
743 excludeInNonApex bool
Colin Cross3e5e7782022-06-17 22:17:05 +0000744
745 // If true, don't automatically export symbols from the static library into a shared library.
746 unexportedSymbols bool
Colin Cross6e511a92020-07-27 21:26:48 -0700747}
748
749// header returns true if the libraryDependencyTag is tagging a header lib dependency.
750func (d libraryDependencyTag) header() bool {
751 return d.Kind == headerLibraryDependency
752}
753
754// shared returns true if the libraryDependencyTag is tagging a shared lib dependency.
755func (d libraryDependencyTag) shared() bool {
756 return d.Kind == sharedLibraryDependency
757}
758
759// shared returns true if the libraryDependencyTag is tagging a static lib dependency.
760func (d libraryDependencyTag) static() bool {
761 return d.Kind == staticLibraryDependency
762}
763
Colin Cross65cb3142021-12-10 23:05:02 +0000764func (d libraryDependencyTag) LicenseAnnotations() []android.LicenseAnnotation {
765 if d.shared() {
766 return []android.LicenseAnnotation{android.LicenseAnnotationSharedDependency}
767 }
768 return nil
769}
770
771var _ android.LicenseAnnotationsDependencyTag = libraryDependencyTag{}
772
Colin Crosse9fe2942020-11-10 18:12:15 -0800773// InstallDepNeeded returns true for shared libraries so that shared library dependencies of
774// binaries or other shared libraries are installed as dependencies.
775func (d libraryDependencyTag) InstallDepNeeded() bool {
776 return d.shared()
777}
778
779var _ android.InstallNeededDependencyTag = libraryDependencyTag{}
780
Yu Liu67a28422024-03-05 00:36:31 +0000781func (d libraryDependencyTag) PropagateAconfigValidation() bool {
782 return d.static()
783}
784
785var _ android.PropagateAconfigValidationDependencyTag = libraryDependencyTag{}
786
Colin Crosse9fe2942020-11-10 18:12:15 -0800787// dependencyTag is used for tagging miscellaneous dependency types that don't fit into
Colin Cross6e511a92020-07-27 21:26:48 -0700788// libraryDependencyTag. Each tag object is created globally and reused for multiple
789// dependencies (although since the object contains no references, assigning a tag to a
790// variable and modifying it will not modify the original). Users can compare the tag
791// returned by ctx.OtherModuleDependencyTag against the global original
792type dependencyTag struct {
793 blueprint.BaseDependencyTag
794 name string
795}
796
Colin Crosse9fe2942020-11-10 18:12:15 -0800797// installDependencyTag is used for tagging miscellaneous dependency types that don't fit into
798// libraryDependencyTag, but where the dependency needs to be installed when the parent is
799// installed.
800type installDependencyTag struct {
801 blueprint.BaseDependencyTag
802 android.InstallAlwaysNeededDependencyTag
803 name string
804}
805
Colin Crossc99deeb2016-04-11 15:06:20 -0700806var (
Colin Cross6e511a92020-07-27 21:26:48 -0700807 genSourceDepTag = dependencyTag{name: "gen source"}
808 genHeaderDepTag = dependencyTag{name: "gen header"}
809 genHeaderExportDepTag = dependencyTag{name: "gen header export"}
810 objDepTag = dependencyTag{name: "obj"}
Jiyong Parkd630bdd2020-11-25 11:47:24 +0900811 dynamicLinkerDepTag = installDependencyTag{name: "dynamic linker"}
Colin Cross6e511a92020-07-27 21:26:48 -0700812 reuseObjTag = dependencyTag{name: "reuse objects"}
813 staticVariantTag = dependencyTag{name: "static variant"}
814 vndkExtDepTag = dependencyTag{name: "vndk extends"}
815 dataLibDepTag = dependencyTag{name: "data lib"}
Colin Crossc8caa062021-09-24 16:50:14 -0700816 dataBinDepTag = dependencyTag{name: "data bin"}
Colin Crosse9fe2942020-11-10 18:12:15 -0800817 runtimeDepTag = installDependencyTag{name: "runtime lib"}
Colin Cross0de8a1e2020-09-18 14:15:30 -0700818 stubImplDepTag = dependencyTag{name: "stub_impl"}
Muhammad Haseeb Ahmad7e744052022-03-25 22:50:53 +0000819 JniFuzzLibTag = dependencyTag{name: "jni_fuzz_lib_tag"}
Vinh Tran44cb78c2023-03-09 22:07:19 -0500820 FdoProfileTag = dependencyTag{name: "fdo_profile"}
Vinh Tran367d89d2023-04-28 11:21:25 -0400821 aidlLibraryTag = dependencyTag{name: "aidl_library"}
Hsin-Yi Chen715142a2024-03-27 16:31:16 +0800822 llndkHeaderLibTag = dependencyTag{name: "llndk_header_lib"}
Colin Crossc99deeb2016-04-11 15:06:20 -0700823)
824
Roland Levillainf89cd092019-07-29 16:22:59 +0100825func IsSharedDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700826 ccLibDepTag, ok := depTag.(libraryDependencyTag)
827 return ok && ccLibDepTag.shared()
828}
829
830func IsStaticDepTag(depTag blueprint.DependencyTag) bool {
831 ccLibDepTag, ok := depTag.(libraryDependencyTag)
832 return ok && ccLibDepTag.static()
Roland Levillainf89cd092019-07-29 16:22:59 +0100833}
834
Zach Johnson3df4e632020-11-06 11:56:27 -0800835func IsHeaderDepTag(depTag blueprint.DependencyTag) bool {
836 ccLibDepTag, ok := depTag.(libraryDependencyTag)
837 return ok && ccLibDepTag.header()
838}
839
Roland Levillainf89cd092019-07-29 16:22:59 +0100840func IsRuntimeDepTag(depTag blueprint.DependencyTag) bool {
Colin Crosse9fe2942020-11-10 18:12:15 -0800841 return depTag == runtimeDepTag
Roland Levillainf89cd092019-07-29 16:22:59 +0100842}
843
Colin Crossca860ac2016-01-04 14:34:37 -0800844// Module contains the properties and members used by all C/C++ module types, and implements
845// the blueprint.Module interface. It delegates to compiler, linker, and installer interfaces
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500846// to construct the output file. Behavior can be customized with a Customizer, or "decorator",
847// interface.
848//
849// To define a C/C++ related module, construct a new Module object and point its delegates to
850// type-specific structs. These delegates will be invoked to register module-specific build
851// statements which may be unique to the module type. For example, module.compiler.compile() should
852// be defined so as to register build statements which are responsible for compiling the module.
853//
854// Another example: to construct a cc_binary module, one can create a `cc.binaryDecorator` struct
855// which implements the `linker` and `installer` interfaces, and points the `linker` and `installer`
856// members of the cc.Module to this decorator. Thus, a cc_binary module has custom linker and
857// installer logic.
Colin Crossca860ac2016-01-04 14:34:37 -0800858type Module struct {
hamzehc0a671f2021-07-22 12:05:08 -0700859 fuzz.FuzzModule
hamzeh41ad8812021-07-07 14:00:07 -0700860
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700861 VendorProperties VendorProperties
hamzeh41ad8812021-07-07 14:00:07 -0700862 Properties BaseProperties
Ronald Braunsteina115e262024-04-09 18:07:38 -0700863 sourceProperties android.SourceProperties
Colin Crossfa138792015-04-24 17:31:52 -0700864
Colin Crossca860ac2016-01-04 14:34:37 -0800865 // initialize before calling Init
Yu Liu76d94462024-10-31 23:32:36 +0000866 hod android.HostOrDeviceSupported
867 multilib android.Multilib
868 testModule bool
869 incremental bool
Colin Crossc472d572015-03-17 15:06:21 -0700870
Paul Duffina0843f62019-12-13 19:50:38 +0000871 // Allowable SdkMemberTypes of this module type.
872 sdkMemberTypes []android.SdkMemberType
873
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500874 // decorator delegates, initialize before calling Init
875 // these may contain module-specific implementations, and effectively allow for custom
876 // type-specific logic. These members may reference different objects or the same object.
877 // Functions of these decorators will be invoked to initialize and register type-specific
878 // build statements.
Colin Cross8ff10582023-12-07 13:10:56 -0800879 generators []Generator
880 compiler compiler
881 linker linker
882 installer installer
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500883
Spandan Dase12d2522023-09-12 21:42:31 +0000884 features []feature
885 stl *stl
886 sanitize *sanitize
887 coverage *coverage
888 fuzzer *fuzzer
889 sabi *sabi
Spandan Dase12d2522023-09-12 21:42:31 +0000890 lto *lto
891 afdo *afdo
Sharjeel Khanc6a93d82023-07-18 21:01:11 +0000892 orderfile *orderfile
Colin Cross16b23492016-01-06 14:41:07 -0800893
Colin Cross31076b32020-10-23 17:22:06 -0700894 library libraryInterface
895
Colin Cross635c3b02016-05-18 15:37:25 -0700896 outputFile android.OptionalPath
Colin Crossca860ac2016-01-04 14:34:37 -0800897
Colin Crossb98c8b02016-07-29 13:44:28 -0700898 cachedToolchain config.Toolchain
Colin Crossb916a382016-07-29 17:28:03 -0700899
Yu Liue70976d2024-10-15 20:45:35 +0000900 subAndroidMkOnce map[subAndroidMkProviderInfoProducer]bool
Fabien Sanglardd61f1f42017-01-10 16:21:22 -0800901
902 // Flags used to compile this module
903 flags Flags
Jeff Gaston294356f2017-09-27 17:05:30 -0700904
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800905 // Shared flags among build rules of this module
906 sharedFlags SharedFlags
907
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800908 // only non-nil when this is a shared library that reuses the objects of a static library
Colin Cross0de8a1e2020-09-18 14:15:30 -0700909 staticAnalogue *StaticLibraryInfo
Inseob Kim9516ee92019-05-09 10:56:13 +0900910
911 makeLinkType string
Jooyung Han75568392020-03-20 04:29:24 +0900912
913 // For apex variants, this is set as apex.min_sdk_version
Dan Albertc8060532020-07-22 22:32:17 -0700914 apexSdkVersion android.ApiLevel
Colin Cross56a83212020-09-15 18:30:11 -0700915
916 hideApexVariantFromMake bool
Yu Liueae7b362023-11-16 17:05:47 -0800917
Inseob Kim37e0bb02024-04-29 15:54:44 +0900918 logtagsPaths android.Paths
Ivan Lozanofd47b1a2024-05-17 14:13:41 -0400919
920 WholeRustStaticlib bool
Cole Faust96a692b2024-08-08 14:47:51 -0700921
922 hasAidl bool
923 hasLex bool
924 hasProto bool
925 hasRenderscript bool
926 hasSysprop bool
927 hasWinMsg bool
928 hasYacc bool
Yu Liu76d94462024-10-31 23:32:36 +0000929
930 makeVarsInfo *CcMakeVarsInfo
Colin Crossc472d572015-03-17 15:06:21 -0700931}
932
Yu Liu76d94462024-10-31 23:32:36 +0000933func (c *Module) IncrementalSupported() bool {
934 return c.incremental
935}
936
937var _ blueprint.Incremental = (*Module)(nil)
938
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200939func (c *Module) AddJSONData(d *map[string]interface{}) {
940 c.AndroidModuleBase().AddJSONData(d)
941 (*d)["Cc"] = map[string]interface{}{
942 "SdkVersion": c.SdkVersion(),
943 "MinSdkVersion": c.MinSdkVersion(),
944 "VndkVersion": c.VndkVersion(),
945 "ProductSpecific": c.ProductSpecific(),
946 "SocSpecific": c.SocSpecific(),
947 "DeviceSpecific": c.DeviceSpecific(),
948 "InProduct": c.InProduct(),
949 "InVendor": c.InVendor(),
950 "InRamdisk": c.InRamdisk(),
951 "InVendorRamdisk": c.InVendorRamdisk(),
952 "InRecovery": c.InRecovery(),
953 "VendorAvailable": c.VendorAvailable(),
954 "ProductAvailable": c.ProductAvailable(),
955 "RamdiskAvailable": c.RamdiskAvailable(),
956 "VendorRamdiskAvailable": c.VendorRamdiskAvailable(),
957 "RecoveryAvailable": c.RecoveryAvailable(),
958 "OdmAvailable": c.OdmAvailable(),
959 "InstallInData": c.InstallInData(),
960 "InstallInRamdisk": c.InstallInRamdisk(),
961 "InstallInSanitizerDir": c.InstallInSanitizerDir(),
962 "InstallInVendorRamdisk": c.InstallInVendorRamdisk(),
963 "InstallInRecovery": c.InstallInRecovery(),
964 "InstallInRoot": c.InstallInRoot(),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200965 "IsLlndk": c.IsLlndk(),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200966 "IsVendorPublicLibrary": c.IsVendorPublicLibrary(),
967 "ApexSdkVersion": c.apexSdkVersion,
Cole Faust96a692b2024-08-08 14:47:51 -0700968 "AidlSrcs": c.hasAidl,
969 "LexSrcs": c.hasLex,
970 "ProtoSrcs": c.hasProto,
971 "RenderscriptSrcs": c.hasRenderscript,
972 "SyspropSrcs": c.hasSysprop,
973 "WinMsgSrcs": c.hasWinMsg,
974 "YaccSrsc": c.hasYacc,
975 "OnlyCSrcs": !(c.hasAidl || c.hasLex || c.hasProto || c.hasRenderscript || c.hasSysprop || c.hasWinMsg || c.hasYacc),
Yi Kong5786f5c2024-05-28 02:22:34 +0900976 "OptimizeForSize": c.OptimizeForSize(),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200977 }
978}
979
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500980func (c *Module) SetPreventInstall() {
981 c.Properties.PreventInstall = true
982}
983
984func (c *Module) SetHideFromMake() {
985 c.Properties.HideFromMake = true
986}
987
Ivan Lozanod7586b62021-04-01 09:49:36 -0400988func (c *Module) HiddenFromMake() bool {
989 return c.Properties.HideFromMake
990}
991
Cole Fauste8a87832024-09-11 11:35:46 -0700992func (c *Module) RequiredModuleNames(ctx android.ConfigurableEvaluatorContext) []string {
Cole Faust43ddd082024-06-17 12:32:40 -0700993 required := android.CopyOf(c.ModuleBase.RequiredModuleNames(ctx))
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800994 if c.ImageVariation().Variation == android.CoreVariation {
995 required = append(required, c.Properties.Target.Platform.Required...)
996 required = removeListFromList(required, c.Properties.Target.Platform.Exclude_required)
997 } else if c.InRecovery() {
998 required = append(required, c.Properties.Target.Recovery.Required...)
999 required = removeListFromList(required, c.Properties.Target.Recovery.Exclude_required)
1000 }
1001 return android.FirstUniqueStrings(required)
1002}
1003
Ivan Lozano52767be2019-10-18 14:49:46 -07001004func (c *Module) Toc() android.OptionalPath {
1005 if c.linker != nil {
1006 if library, ok := c.linker.(libraryInterface); ok {
1007 return library.toc()
1008 }
1009 }
1010 panic(fmt.Errorf("Toc() called on non-library module: %q", c.BaseModuleName()))
1011}
1012
1013func (c *Module) ApiLevel() string {
1014 if c.linker != nil {
1015 if stub, ok := c.linker.(*stubDecorator); ok {
Dan Albert1a246272020-07-06 14:49:35 -07001016 return stub.apiLevel.String()
Ivan Lozano52767be2019-10-18 14:49:46 -07001017 }
1018 }
1019 panic(fmt.Errorf("ApiLevel() called on non-stub library module: %q", c.BaseModuleName()))
1020}
1021
1022func (c *Module) Static() bool {
1023 if c.linker != nil {
1024 if library, ok := c.linker.(libraryInterface); ok {
1025 return library.static()
1026 }
1027 }
1028 panic(fmt.Errorf("Static() called on non-library module: %q", c.BaseModuleName()))
1029}
1030
1031func (c *Module) Shared() bool {
1032 if c.linker != nil {
1033 if library, ok := c.linker.(libraryInterface); ok {
1034 return library.shared()
1035 }
1036 }
Lukacs T. Berki6c716762022-06-13 20:50:39 +02001037
Ivan Lozano52767be2019-10-18 14:49:46 -07001038 panic(fmt.Errorf("Shared() called on non-library module: %q", c.BaseModuleName()))
1039}
1040
1041func (c *Module) SelectedStl() string {
Colin Crossc511bc52020-04-07 16:50:32 +00001042 if c.stl != nil {
1043 return c.stl.Properties.SelectedStl
1044 }
1045 return ""
Ivan Lozano52767be2019-10-18 14:49:46 -07001046}
1047
Ivan Lozano52767be2019-10-18 14:49:46 -07001048func (c *Module) StubDecorator() bool {
1049 if _, ok := c.linker.(*stubDecorator); ok {
1050 return true
1051 }
1052 return false
1053}
1054
Yi Kong5786f5c2024-05-28 02:22:34 +09001055func (c *Module) OptimizeForSize() bool {
1056 return Bool(c.Properties.Optimize_for_size)
1057}
1058
Ivan Lozano52767be2019-10-18 14:49:46 -07001059func (c *Module) SdkVersion() string {
1060 return String(c.Properties.Sdk_version)
1061}
1062
Artur Satayev480e25b2020-04-27 18:53:18 +01001063func (c *Module) MinSdkVersion() string {
1064 return String(c.Properties.Min_sdk_version)
1065}
1066
Jiyong Park5df7bd32021-08-25 16:18:46 +09001067func (c *Module) isCrt() bool {
Dan Albert92fe7402020-07-15 13:33:30 -07001068 if linker, ok := c.linker.(*objectLinker); ok {
1069 return linker.isCrt()
1070 }
1071 return false
1072}
1073
Jiyong Park5df7bd32021-08-25 16:18:46 +09001074func (c *Module) SplitPerApiLevel() bool {
1075 return c.canUseSdk() && c.isCrt()
1076}
1077
Colin Crossc511bc52020-04-07 16:50:32 +00001078func (c *Module) AlwaysSdk() bool {
1079 return c.Properties.AlwaysSdk || Bool(c.Properties.Sdk_variant_only)
1080}
1081
Ivan Lozano183a3212019-10-18 14:18:45 -07001082func (c *Module) CcLibrary() bool {
1083 if c.linker != nil {
1084 if _, ok := c.linker.(*libraryDecorator); ok {
1085 return true
1086 }
Colin Crossd48fe732020-09-23 20:37:24 -07001087 if _, ok := c.linker.(*prebuiltLibraryLinker); ok {
1088 return true
1089 }
Ivan Lozano183a3212019-10-18 14:18:45 -07001090 }
1091 return false
1092}
1093
1094func (c *Module) CcLibraryInterface() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001095 if _, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001096 return true
1097 }
1098 return false
1099}
1100
Ivan Lozanoadd122a2023-07-13 11:01:41 -04001101func (c *Module) RlibStd() bool {
1102 panic(fmt.Errorf("RlibStd called on non-Rust module: %q", c.BaseModuleName()))
1103}
1104
Ivan Lozano61c02cc2023-06-09 14:06:44 -04001105func (c *Module) RustLibraryInterface() bool {
1106 return false
1107}
1108
Ivan Lozano0a468a42024-05-13 21:03:34 -04001109func (c *Module) CrateName() string {
1110 panic(fmt.Errorf("CrateName called on non-Rust module: %q", c.BaseModuleName()))
1111}
1112
1113func (c *Module) ExportedCrateLinkDirs() []string {
1114 panic(fmt.Errorf("ExportedCrateLinkDirs called on non-Rust module: %q", c.BaseModuleName()))
1115}
1116
Ivan Lozano0f9963e2023-02-06 13:31:02 -05001117func (c *Module) IsFuzzModule() bool {
1118 if _, ok := c.compiler.(*fuzzBinary); ok {
1119 return true
1120 }
1121 return false
1122}
1123
1124func (c *Module) FuzzModuleStruct() fuzz.FuzzModule {
1125 return c.FuzzModule
1126}
1127
1128func (c *Module) FuzzPackagedModule() fuzz.FuzzPackagedModule {
1129 if fuzzer, ok := c.compiler.(*fuzzBinary); ok {
1130 return fuzzer.fuzzPackagedModule
1131 }
1132 panic(fmt.Errorf("FuzzPackagedModule called on non-fuzz module: %q", c.BaseModuleName()))
1133}
1134
Hamzeh Zawawy38917492023-04-05 22:08:46 +00001135func (c *Module) FuzzSharedLibraries() android.RuleBuilderInstalls {
Ivan Lozano0f9963e2023-02-06 13:31:02 -05001136 if fuzzer, ok := c.compiler.(*fuzzBinary); ok {
1137 return fuzzer.sharedLibraries
1138 }
1139 panic(fmt.Errorf("FuzzSharedLibraries called on non-fuzz module: %q", c.BaseModuleName()))
1140}
1141
Ivan Lozano2b262972019-11-21 12:30:50 -08001142func (c *Module) NonCcVariants() bool {
1143 return false
1144}
1145
Ivan Lozano183a3212019-10-18 14:18:45 -07001146func (c *Module) SetStatic() {
1147 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001148 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001149 library.setStatic()
1150 return
1151 }
1152 }
1153 panic(fmt.Errorf("SetStatic called on non-library module: %q", c.BaseModuleName()))
1154}
1155
1156func (c *Module) SetShared() {
1157 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001158 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001159 library.setShared()
1160 return
1161 }
1162 }
1163 panic(fmt.Errorf("SetShared called on non-library module: %q", c.BaseModuleName()))
1164}
1165
1166func (c *Module) BuildStaticVariant() bool {
1167 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001168 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001169 return library.buildStatic()
1170 }
1171 }
1172 panic(fmt.Errorf("BuildStaticVariant called on non-library module: %q", c.BaseModuleName()))
1173}
1174
1175func (c *Module) BuildSharedVariant() bool {
1176 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001177 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001178 return library.buildShared()
1179 }
1180 }
1181 panic(fmt.Errorf("BuildSharedVariant called on non-library module: %q", c.BaseModuleName()))
1182}
1183
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04001184func (c *Module) BuildRlibVariant() bool {
1185 // cc modules can never build rlib variants
1186 return false
1187}
1188
1189func (c *Module) IsRustFFI() bool {
1190 // cc modules are not Rust modules
1191 return false
1192}
1193
Ivan Lozano183a3212019-10-18 14:18:45 -07001194func (c *Module) Module() android.Module {
1195 return c
1196}
1197
Jiyong Parkc20eee32018-09-05 22:36:17 +09001198func (c *Module) OutputFile() android.OptionalPath {
1199 return c.outputFile
1200}
1201
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001202func (c *Module) CoverageFiles() android.Paths {
1203 if c.linker != nil {
1204 if library, ok := c.linker.(libraryInterface); ok {
1205 return library.objs().coverageFiles
1206 }
1207 }
1208 panic(fmt.Errorf("CoverageFiles called on non-library module: %q", c.BaseModuleName()))
1209}
1210
Ivan Lozano183a3212019-10-18 14:18:45 -07001211var _ LinkableInterface = (*Module)(nil)
1212
Jiyong Park719b4462019-01-13 00:39:51 +09001213func (c *Module) UnstrippedOutputFile() android.Path {
Jiyong Parkaf6d8952019-01-31 12:21:23 +09001214 if c.linker != nil {
1215 return c.linker.unstrippedOutputFilePath()
Jiyong Park719b4462019-01-13 00:39:51 +09001216 }
1217 return nil
1218}
1219
Jiyong Parkee9a98d2019-08-09 14:44:36 +09001220func (c *Module) CoverageOutputFile() android.OptionalPath {
1221 if c.linker != nil {
1222 return c.linker.coverageOutputFilePath()
1223 }
1224 return android.OptionalPath{}
1225}
1226
Jiyong Parkb7c24df2019-02-01 12:03:59 +09001227func (c *Module) RelativeInstallPath() string {
1228 if c.installer != nil {
1229 return c.installer.relativeInstallPath()
1230 }
1231 return ""
1232}
1233
Jooyung Han344d5432019-08-23 11:17:39 +09001234func (c *Module) VndkVersion() string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001235 return c.Properties.VndkVersion
Jooyung Han344d5432019-08-23 11:17:39 +09001236}
1237
Colin Cross36242852017-06-23 15:06:31 -07001238func (c *Module) Init() android.Module {
Dan Willemsenf923f2b2018-05-09 13:45:03 -07001239 c.AddProperties(&c.Properties, &c.VendorProperties)
Joe Onorato37f900c2023-07-18 16:58:16 -07001240 for _, generator := range c.generators {
1241 c.AddProperties(generator.GeneratorProps()...)
1242 }
Colin Crossca860ac2016-01-04 14:34:37 -08001243 if c.compiler != nil {
Colin Cross36242852017-06-23 15:06:31 -07001244 c.AddProperties(c.compiler.compilerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001245 }
1246 if c.linker != nil {
Colin Cross36242852017-06-23 15:06:31 -07001247 c.AddProperties(c.linker.linkerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001248 }
1249 if c.installer != nil {
Colin Cross36242852017-06-23 15:06:31 -07001250 c.AddProperties(c.installer.installerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001251 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001252 if c.stl != nil {
Colin Cross36242852017-06-23 15:06:31 -07001253 c.AddProperties(c.stl.props()...)
Colin Crossa8e07cc2016-04-04 15:07:06 -07001254 }
Colin Cross16b23492016-01-06 14:41:07 -08001255 if c.sanitize != nil {
Colin Cross36242852017-06-23 15:06:31 -07001256 c.AddProperties(c.sanitize.props()...)
Colin Cross16b23492016-01-06 14:41:07 -08001257 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001258 if c.coverage != nil {
Colin Cross36242852017-06-23 15:06:31 -07001259 c.AddProperties(c.coverage.props()...)
Dan Willemsen581341d2017-02-09 16:16:31 -08001260 }
Cory Barkera1da26f2022-06-07 20:12:06 +00001261 if c.fuzzer != nil {
1262 c.AddProperties(c.fuzzer.props()...)
1263 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001264 if c.sabi != nil {
Colin Cross36242852017-06-23 15:06:31 -07001265 c.AddProperties(c.sabi.props()...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001266 }
Stephen Craneba090d12017-05-09 15:44:35 -07001267 if c.lto != nil {
1268 c.AddProperties(c.lto.props()...)
1269 }
Yi Kongeb8efc92021-12-09 18:06:29 +08001270 if c.afdo != nil {
1271 c.AddProperties(c.afdo.props()...)
1272 }
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001273 if c.orderfile != nil {
1274 c.AddProperties(c.orderfile.props()...)
1275 }
Colin Crossca860ac2016-01-04 14:34:37 -08001276 for _, feature := range c.features {
Colin Cross36242852017-06-23 15:06:31 -07001277 c.AddProperties(feature.props()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001278 }
Ronald Braunsteina115e262024-04-09 18:07:38 -07001279 // Allow test-only on libraries that are not cc_test_library
1280 if c.library != nil && !c.testLibrary() {
1281 c.AddProperties(&c.sourceProperties)
1282 }
Colin Crossc472d572015-03-17 15:06:21 -07001283
Colin Cross36242852017-06-23 15:06:31 -07001284 android.InitAndroidArchModule(c, c.hod, c.multilib)
Jiyong Park7916bfc2019-09-30 19:13:12 +09001285 android.InitApexModule(c)
Jooyung Han18020ea2019-11-13 10:50:48 +09001286 android.InitDefaultableModule(c)
Jiyong Park9d452992018-10-03 00:38:19 +09001287
Colin Cross36242852017-06-23 15:06:31 -07001288 return c
Colin Crossc472d572015-03-17 15:06:21 -07001289}
1290
Yi-Yo Chiang1080f0c2022-11-22 18:24:14 +08001291// UseVndk() returns true if this module is built against VNDK.
1292// This means the vendor and product variants of a module.
Ivan Lozano52767be2019-10-18 14:49:46 -07001293func (c *Module) UseVndk() bool {
Inseob Kim64c43952019-08-26 16:52:35 +09001294 return c.Properties.VndkVersion != ""
Dan Willemsen4416e5d2017-04-06 12:43:22 -07001295}
1296
Colin Crossc511bc52020-04-07 16:50:32 +00001297func (c *Module) canUseSdk() bool {
Colin Cross94e347e2021-01-19 14:56:07 -08001298 return c.Os() == android.Android && c.Target().NativeBridge == android.NativeBridgeDisabled &&
Kiyoung Kimaa394802024-01-08 12:55:45 +09001299 !c.InVendorOrProduct() && !c.InRamdisk() && !c.InRecovery() && !c.InVendorRamdisk()
Colin Crossc511bc52020-04-07 16:50:32 +00001300}
1301
1302func (c *Module) UseSdk() bool {
1303 if c.canUseSdk() {
Colin Cross1348ce32020-10-01 13:37:16 -07001304 return String(c.Properties.Sdk_version) != ""
Colin Crossc511bc52020-04-07 16:50:32 +00001305 }
1306 return false
1307}
1308
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001309func (c *Module) isCoverageVariant() bool {
1310 return c.coverage.Properties.IsCoverageVariant
1311}
1312
Colin Cross95f1ca02020-10-29 20:47:22 -07001313func (c *Module) IsNdk(config android.Config) bool {
1314 return inList(c.BaseModuleName(), *getNDKKnownLibs(config))
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001315}
1316
Colin Cross127bb8b2020-12-16 16:46:01 -08001317func (c *Module) IsLlndk() bool {
1318 return c.VendorProperties.IsLLNDK
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001319}
1320
Colin Cross1f3f1302021-04-26 18:37:44 -07001321func (m *Module) NeedsLlndkVariants() bool {
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001322 lib := moduleLibraryInterface(m)
Colin Cross1f3f1302021-04-26 18:37:44 -07001323 return lib != nil && (lib.hasLLNDKStubs() || lib.hasLLNDKHeaders())
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001324}
1325
Colin Cross5271fea2021-04-27 13:06:04 -07001326func (m *Module) NeedsVendorPublicLibraryVariants() bool {
1327 lib := moduleLibraryInterface(m)
1328 return lib != nil && (lib.hasVendorPublicLibrary())
1329}
1330
1331// IsVendorPublicLibrary returns true for vendor public libraries.
1332func (c *Module) IsVendorPublicLibrary() bool {
1333 return c.VendorProperties.IsVendorPublicLibrary
1334}
1335
Ivan Lozanof1868af2022-04-12 13:08:36 -04001336func (c *Module) IsVndkPrebuiltLibrary() bool {
1337 if _, ok := c.linker.(*vndkPrebuiltLibraryDecorator); ok {
1338 return true
1339 }
1340 return false
1341}
1342
1343func (c *Module) SdkAndPlatformVariantVisibleToMake() bool {
1344 return c.Properties.SdkAndPlatformVariantVisibleToMake
1345}
1346
Ivan Lozanod7586b62021-04-01 09:49:36 -04001347func (c *Module) HasLlndkStubs() bool {
1348 lib := moduleLibraryInterface(c)
1349 return lib != nil && lib.hasLLNDKStubs()
1350}
1351
1352func (c *Module) StubsVersion() string {
1353 if lib, ok := c.linker.(versionedInterface); ok {
1354 return lib.stubsVersion()
1355 }
1356 panic(fmt.Errorf("StubsVersion called on non-versioned module: %q", c.BaseModuleName()))
1357}
1358
Colin Cross127bb8b2020-12-16 16:46:01 -08001359// isImplementationForLLNDKPublic returns true for any variant of a cc_library that has LLNDK stubs
1360// and does not set llndk.vendor_available: false.
1361func (c *Module) isImplementationForLLNDKPublic() bool {
1362 library, _ := c.library.(*libraryDecorator)
1363 return library != nil && library.hasLLNDKStubs() &&
Colin Cross0fb7fcd2021-03-02 11:00:07 -08001364 !Bool(library.Properties.Llndk.Private)
Colin Cross127bb8b2020-12-16 16:46:01 -08001365}
1366
Colin Cross3513fb12024-01-24 14:44:47 -08001367func (c *Module) isAfdoCompile(ctx ModuleContext) bool {
Yi Kong4ef54592022-02-14 20:00:10 +08001368 if afdo := c.afdo; afdo != nil {
Colin Cross3513fb12024-01-24 14:44:47 -08001369 return afdo.isAfdoCompile(ctx)
Yi Kong4ef54592022-02-14 20:00:10 +08001370 }
1371 return false
1372}
1373
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001374func (c *Module) isOrderfileCompile() bool {
1375 if orderfile := c.orderfile; orderfile != nil {
1376 return orderfile.Properties.OrderfileLoad
1377 }
1378 return false
1379}
1380
Yi Kongc702ebd2022-08-19 16:02:45 +08001381func (c *Module) isCfi() bool {
Colin Cross694fced2024-06-25 14:56:42 -07001382 return c.sanitize.isSanitizerEnabled(cfi)
Yi Kongc702ebd2022-08-19 16:02:45 +08001383}
1384
Yi Konged79fa32023-06-04 17:15:42 +09001385func (c *Module) isFuzzer() bool {
Colin Cross694fced2024-06-25 14:56:42 -07001386 return c.sanitize.isSanitizerEnabled(Fuzzer)
Yi Konged79fa32023-06-04 17:15:42 +09001387}
1388
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001389func (c *Module) isNDKStubLibrary() bool {
1390 if _, ok := c.compiler.(*stubDecorator); ok {
1391 return true
1392 }
1393 return false
1394}
1395
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001396func (c *Module) SubName() string {
1397 return c.Properties.SubName
1398}
1399
Jiyong Park25fc6a92018-11-18 18:02:45 +09001400func (c *Module) IsStubs() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001401 if lib := c.library; lib != nil {
1402 return lib.buildStubs()
Jiyong Park25fc6a92018-11-18 18:02:45 +09001403 }
1404 return false
1405}
1406
1407func (c *Module) HasStubsVariants() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001408 if lib := c.library; lib != nil {
1409 return lib.hasStubsVariants()
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001410 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09001411 return false
1412}
1413
Alan Stokes73feba32022-11-14 12:21:24 +00001414func (c *Module) IsStubsImplementationRequired() bool {
1415 if lib := c.library; lib != nil {
1416 return lib.isStubsImplementationRequired()
1417 }
1418 return false
1419}
1420
Colin Cross0477b422020-10-13 18:43:54 -07001421// If this is a stubs library, ImplementationModuleName returns the name of the module that contains
1422// the implementation. If it is an implementation library it returns its own name.
1423func (c *Module) ImplementationModuleName(ctx android.BaseModuleContext) string {
1424 name := ctx.OtherModuleName(c)
1425 if versioned, ok := c.linker.(versionedInterface); ok {
1426 name = versioned.implementationModuleName(name)
1427 }
1428 return name
1429}
1430
Martin Stjernholm2856c662020-12-02 15:03:42 +00001431// Similar to ImplementationModuleName, but uses the Make variant of the module
1432// name as base name, for use in AndroidMk output. E.g. for a prebuilt module
1433// where the Soong name is prebuilt_foo, this returns foo (which works in Make
1434// under the premise that the prebuilt module overrides its source counterpart
1435// if it is exposed to Make).
1436func (c *Module) ImplementationModuleNameForMake(ctx android.BaseModuleContext) string {
1437 name := c.BaseModuleName()
1438 if versioned, ok := c.linker.(versionedInterface); ok {
1439 name = versioned.implementationModuleName(name)
1440 }
1441 return name
1442}
1443
Jiyong Park7d55b612021-06-11 17:22:09 +09001444func (c *Module) Bootstrap() bool {
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001445 return Bool(c.Properties.Bootstrap)
1446}
1447
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001448func (c *Module) nativeCoverage() bool {
Pirama Arumuga Nainar5f69b9a2019-09-12 13:18:48 -07001449 // Bug: http://b/137883967 - native-bridge modules do not currently work with coverage
1450 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1451 return false
1452 }
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001453 return c.linker != nil && c.linker.nativeCoverage()
1454}
1455
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001456func (c *Module) IsSnapshotPrebuilt() bool {
Ivan Lozanod1dec542021-05-26 15:33:11 -04001457 if p, ok := c.linker.(SnapshotInterface); ok {
1458 return p.IsSnapshotPrebuilt()
Inseob Kimeec88e12020-01-22 11:11:29 +09001459 }
1460 return false
Inseob Kim8471cda2019-11-15 09:59:12 +09001461}
1462
Jiyong Parkf1194352019-02-25 11:05:47 +09001463func isBionic(name string) bool {
1464 switch name {
Jooyung Hanbff73352022-12-13 18:29:44 +09001465 case "libc", "libm", "libdl", "libdl_android", "linker":
Jiyong Parkf1194352019-02-25 11:05:47 +09001466 return true
1467 }
1468 return false
1469}
1470
Martin Stjernholm279de572019-09-10 23:18:20 +01001471func InstallToBootstrap(name string, config android.Config) bool {
Florian Mayer95cd6db2023-03-23 17:48:07 -07001472 if name == "libclang_rt.hwasan" || name == "libc_hwasan" {
Jooyung Han8ce8db92020-05-15 19:05:05 +09001473 return true
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001474 }
1475 return isBionic(name)
1476}
1477
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001478func (c *Module) isCfiAssemblySupportEnabled() bool {
1479 return c.sanitize != nil &&
1480 Bool(c.sanitize.Properties.Sanitize.Config.Cfi_assembly_support)
1481}
1482
Inseob Kim800d1142021-06-14 12:03:51 +09001483func (c *Module) InstallInRoot() bool {
1484 return c.installer != nil && c.installer.installInRoot()
1485}
1486
Colin Crossca860ac2016-01-04 14:34:37 -08001487type baseModuleContext struct {
Colin Cross0ea8ba82019-06-06 14:33:29 -07001488 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001489 moduleContextImpl
1490}
1491
Colin Cross37047f12016-12-13 17:06:13 -08001492type depsContext struct {
1493 android.BottomUpMutatorContext
1494 moduleContextImpl
1495}
1496
Colin Crossca860ac2016-01-04 14:34:37 -08001497type moduleContext struct {
Colin Cross635c3b02016-05-18 15:37:25 -07001498 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001499 moduleContextImpl
1500}
1501
1502type moduleContextImpl struct {
1503 mod *Module
1504 ctx BaseModuleContext
1505}
1506
Colin Crossb98c8b02016-07-29 13:44:28 -07001507func (ctx *moduleContextImpl) toolchain() config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001508 return ctx.mod.toolchain(ctx.ctx)
1509}
1510
1511func (ctx *moduleContextImpl) static() bool {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00001512 return ctx.mod.static()
Colin Crossca860ac2016-01-04 14:34:37 -08001513}
1514
1515func (ctx *moduleContextImpl) staticBinary() bool {
Jiyong Park379de2f2018-12-19 02:47:14 +09001516 return ctx.mod.staticBinary()
Colin Crossca860ac2016-01-04 14:34:37 -08001517}
1518
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07001519func (ctx *moduleContextImpl) testBinary() bool {
1520 return ctx.mod.testBinary()
1521}
1522
Yi Kong56fc1b62022-09-06 16:24:00 +08001523func (ctx *moduleContextImpl) testLibrary() bool {
1524 return ctx.mod.testLibrary()
1525}
1526
Jiyong Park1d1119f2019-07-29 21:27:18 +09001527func (ctx *moduleContextImpl) header() bool {
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001528 return ctx.mod.Header()
Jiyong Park1d1119f2019-07-29 21:27:18 +09001529}
1530
Inseob Kim7f283f42020-06-01 21:53:49 +09001531func (ctx *moduleContextImpl) binary() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001532 return ctx.mod.Binary()
Inseob Kim7f283f42020-06-01 21:53:49 +09001533}
1534
Inseob Kim1042d292020-06-01 23:23:05 +09001535func (ctx *moduleContextImpl) object() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001536 return ctx.mod.Object()
Inseob Kim1042d292020-06-01 23:23:05 +09001537}
1538
Yi Kong5786f5c2024-05-28 02:22:34 +09001539func (ctx *moduleContextImpl) optimizeForSize() bool {
1540 return ctx.mod.OptimizeForSize()
1541}
1542
Jooyung Hanccce2f22020-03-07 03:45:53 +09001543func (ctx *moduleContextImpl) canUseSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001544 return ctx.mod.canUseSdk()
Jooyung Hanccce2f22020-03-07 03:45:53 +09001545}
1546
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001547func (ctx *moduleContextImpl) useSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001548 return ctx.mod.UseSdk()
Colin Crossca860ac2016-01-04 14:34:37 -08001549}
1550
1551func (ctx *moduleContextImpl) sdkVersion() string {
Dan Willemsena96ff642016-06-07 12:34:45 -07001552 if ctx.ctx.Device() {
Justin Yun732aa6a2018-03-23 17:43:47 +09001553 return String(ctx.mod.Properties.Sdk_version)
Dan Willemsena96ff642016-06-07 12:34:45 -07001554 }
1555 return ""
Colin Crossca860ac2016-01-04 14:34:37 -08001556}
1557
Jiyong Parkb35a8192020-08-10 15:59:36 +09001558func (ctx *moduleContextImpl) minSdkVersion() string {
1559 ver := ctx.mod.MinSdkVersion()
1560 if ver == "apex_inherit" && !ctx.isForPlatform() {
1561 ver = ctx.apexSdkVersion().String()
1562 }
1563 if ver == "apex_inherit" || ver == "" {
1564 ver = ctx.sdkVersion()
1565 }
Yi-Yo Chiang88960aa2024-01-19 15:02:29 +08001566
1567 if ctx.ctx.Device() {
Jooyung Hanaa2d3f52024-11-09 02:41:06 +00001568 // When building for vendor/product, use the latest _stable_ API as "current".
1569 // This is passed to clang/aidl compilers so that compiled/generated code works
1570 // with the system.
1571 if (ctx.inVendor() || ctx.inProduct()) && (ver == "" || ver == "current") {
1572 ver = ctx.ctx.Config().PlatformSdkVersion().String()
Yi-Yo Chiang88960aa2024-01-19 15:02:29 +08001573 }
1574 }
1575
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001576 // For crt objects, the meaning of min_sdk_version is very different from other types of
1577 // module. For them, min_sdk_version defines the oldest version that the build system will
1578 // create versioned variants for. For example, if min_sdk_version is 16, then sdk variant of
1579 // the crt object has local variants of 16, 17, ..., up to the latest version. sdk_version
1580 // and min_sdk_version properties of the variants are set to the corresponding version
Jiyong Park5df7bd32021-08-25 16:18:46 +09001581 // numbers. However, the non-sdk variant (for apex or platform) of the crt object is left
1582 // untouched. min_sdk_version: 16 doesn't actually mean that the non-sdk variant has to
1583 // support such an old version. The version is set to the later version in case when the
1584 // non-sdk variant is for the platform, or the min_sdk_version of the containing APEX if
1585 // it's for an APEX.
1586 if ctx.mod.isCrt() && !ctx.isSdkVariant() {
1587 if ctx.isForPlatform() {
1588 ver = strconv.Itoa(android.FutureApiLevelInt)
1589 } else { // for apex
1590 ver = ctx.apexSdkVersion().String()
1591 if ver == "" { // in case when min_sdk_version was not set by the APEX
1592 ver = ctx.sdkVersion()
1593 }
1594 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001595 }
1596
Jiyong Parkb35a8192020-08-10 15:59:36 +09001597 // Also make sure that minSdkVersion is not greater than sdkVersion, if they are both numbers
1598 sdkVersionInt, err := strconv.Atoi(ctx.sdkVersion())
1599 minSdkVersionInt, err2 := strconv.Atoi(ver)
1600 if err == nil && err2 == nil {
1601 if sdkVersionInt < minSdkVersionInt {
1602 return strconv.Itoa(sdkVersionInt)
1603 }
1604 }
1605 return ver
1606}
1607
1608func (ctx *moduleContextImpl) isSdkVariant() bool {
1609 return ctx.mod.IsSdkVariant()
1610}
1611
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001612func (ctx *moduleContextImpl) useVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001613 return ctx.mod.UseVndk()
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001614}
Justin Yun8effde42017-06-23 19:24:43 +09001615
Kiyoung Kimaa394802024-01-08 12:55:45 +09001616func (ctx *moduleContextImpl) InVendorOrProduct() bool {
1617 return ctx.mod.InVendorOrProduct()
1618}
1619
Colin Cross95f1ca02020-10-29 20:47:22 -07001620func (ctx *moduleContextImpl) isNdk(config android.Config) bool {
1621 return ctx.mod.IsNdk(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001622}
1623
Colin Cross127bb8b2020-12-16 16:46:01 -08001624func (ctx *moduleContextImpl) IsLlndk() bool {
1625 return ctx.mod.IsLlndk()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001626}
1627
Colin Cross127bb8b2020-12-16 16:46:01 -08001628func (ctx *moduleContextImpl) isImplementationForLLNDKPublic() bool {
1629 return ctx.mod.isImplementationForLLNDKPublic()
1630}
1631
Colin Cross3513fb12024-01-24 14:44:47 -08001632func (ctx *moduleContextImpl) isAfdoCompile(mctx ModuleContext) bool {
1633 return ctx.mod.isAfdoCompile(mctx)
Yi Kong4ef54592022-02-14 20:00:10 +08001634}
1635
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001636func (ctx *moduleContextImpl) isOrderfileCompile() bool {
1637 return ctx.mod.isOrderfileCompile()
1638}
1639
Yi Kongc702ebd2022-08-19 16:02:45 +08001640func (ctx *moduleContextImpl) isCfi() bool {
1641 return ctx.mod.isCfi()
1642}
1643
Yi Konged79fa32023-06-04 17:15:42 +09001644func (ctx *moduleContextImpl) isFuzzer() bool {
1645 return ctx.mod.isFuzzer()
1646}
1647
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001648func (ctx *moduleContextImpl) isNDKStubLibrary() bool {
1649 return ctx.mod.isNDKStubLibrary()
1650}
1651
Colin Cross5271fea2021-04-27 13:06:04 -07001652func (ctx *moduleContextImpl) IsVendorPublicLibrary() bool {
1653 return ctx.mod.IsVendorPublicLibrary()
1654}
1655
Dan Willemsen8146b2f2016-03-30 21:00:30 -07001656func (ctx *moduleContextImpl) selectedStl() string {
1657 if stl := ctx.mod.stl; stl != nil {
1658 return stl.Properties.SelectedStl
1659 }
1660 return ""
1661}
1662
Ivan Lozanobd721262018-11-27 14:33:03 -08001663func (ctx *moduleContextImpl) useClangLld(actx ModuleContext) bool {
1664 return ctx.mod.linker.useClangLld(actx)
1665}
1666
Colin Crossce75d2c2016-10-06 16:12:58 -07001667func (ctx *moduleContextImpl) baseModuleName() string {
Spandan Das2b6dfb52024-01-19 00:22:22 +00001668 return ctx.mod.BaseModuleName()
Colin Crossce75d2c2016-10-06 16:12:58 -07001669}
1670
Logan Chiene274fc92019-12-03 11:18:32 -08001671func (ctx *moduleContextImpl) isForPlatform() bool {
Colin Crossff694a82023-12-13 15:54:49 -08001672 apexInfo, _ := android.ModuleProvider(ctx.ctx, android.ApexInfoProvider)
1673 return apexInfo.IsForPlatform()
Logan Chiene274fc92019-12-03 11:18:32 -08001674}
1675
Colin Crosse07f2312020-08-13 11:24:56 -07001676func (ctx *moduleContextImpl) apexVariationName() string {
Colin Crossff694a82023-12-13 15:54:49 -08001677 apexInfo, _ := android.ModuleProvider(ctx.ctx, android.ApexInfoProvider)
1678 return apexInfo.ApexVariationName
Jiyong Park25fc6a92018-11-18 18:02:45 +09001679}
1680
Dan Albertc8060532020-07-22 22:32:17 -07001681func (ctx *moduleContextImpl) apexSdkVersion() android.ApiLevel {
Jooyung Han75568392020-03-20 04:29:24 +09001682 return ctx.mod.apexSdkVersion
Jooyung Hanccce2f22020-03-07 03:45:53 +09001683}
1684
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001685func (ctx *moduleContextImpl) bootstrap() bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09001686 return ctx.mod.Bootstrap()
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001687}
1688
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001689func (ctx *moduleContextImpl) nativeCoverage() bool {
1690 return ctx.mod.nativeCoverage()
1691}
1692
Colin Cross95b07f22020-12-16 11:06:50 -08001693func (ctx *moduleContextImpl) isPreventInstall() bool {
1694 return ctx.mod.Properties.PreventInstall
1695}
1696
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -08001697func (ctx *moduleContextImpl) getSharedFlags() *SharedFlags {
1698 shared := &ctx.mod.sharedFlags
1699 if shared.flagsMap == nil {
1700 shared.numSharedFlags = 0
1701 shared.flagsMap = make(map[string]string)
1702 }
1703 return shared
1704}
1705
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001706func (ctx *moduleContextImpl) isCfiAssemblySupportEnabled() bool {
1707 return ctx.mod.isCfiAssemblySupportEnabled()
1708}
1709
Colin Cross4a9e6ec2023-12-18 15:29:41 -08001710func (ctx *moduleContextImpl) notInPlatform() bool {
1711 return ctx.mod.NotInPlatform()
1712}
1713
Yu Liu76d94462024-10-31 23:32:36 +00001714func (ctx *moduleContextImpl) getOrCreateMakeVarsInfo() *CcMakeVarsInfo {
1715 if ctx.mod.makeVarsInfo == nil {
1716 ctx.mod.makeVarsInfo = &CcMakeVarsInfo{}
1717 }
1718 return ctx.mod.makeVarsInfo
1719}
1720
Colin Cross635c3b02016-05-18 15:37:25 -07001721func newBaseModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001722 return &Module{
1723 hod: hod,
1724 multilib: multilib,
1725 }
1726}
1727
Colin Cross635c3b02016-05-18 15:37:25 -07001728func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001729 module := newBaseModule(hod, multilib)
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001730 module.features = []feature{
1731 &tidyFeature{},
1732 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001733 module.stl = &stl{}
Colin Cross16b23492016-01-06 14:41:07 -08001734 module.sanitize = &sanitize{}
Dan Willemsen581341d2017-02-09 16:16:31 -08001735 module.coverage = &coverage{}
Cory Barkera1da26f2022-06-07 20:12:06 +00001736 module.fuzzer = &fuzzer{}
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001737 module.sabi = &sabi{}
Stephen Craneba090d12017-05-09 15:44:35 -07001738 module.lto = &lto{}
Yi Kongeb8efc92021-12-09 18:06:29 +08001739 module.afdo = &afdo{}
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00001740 module.orderfile = &orderfile{}
Colin Crossca860ac2016-01-04 14:34:37 -08001741 return module
1742}
1743
Colin Crossce75d2c2016-10-06 16:12:58 -07001744func (c *Module) Prebuilt() *android.Prebuilt {
1745 if p, ok := c.linker.(prebuiltLinkerInterface); ok {
1746 return p.prebuilt()
1747 }
1748 return nil
1749}
1750
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001751func (c *Module) IsPrebuilt() bool {
1752 return c.Prebuilt() != nil
1753}
1754
Colin Crossce75d2c2016-10-06 16:12:58 -07001755func (c *Module) Name() string {
1756 name := c.ModuleBase.Name()
Dan Willemsen01a90592017-04-07 15:21:13 -07001757 if p, ok := c.linker.(interface {
1758 Name(string) string
1759 }); ok {
Colin Crossce75d2c2016-10-06 16:12:58 -07001760 name = p.Name(name)
1761 }
1762 return name
1763}
1764
Alex Light3d673592019-01-18 14:37:31 -08001765func (c *Module) Symlinks() []string {
1766 if p, ok := c.installer.(interface {
1767 symlinkList() []string
1768 }); ok {
1769 return p.symlinkList()
1770 }
1771 return nil
1772}
1773
Chris Parsons216e10a2020-07-09 17:12:52 -04001774func (c *Module) DataPaths() []android.DataPath {
Liz Kammer1c14a212020-05-12 15:26:55 -07001775 if p, ok := c.installer.(interface {
Chris Parsons216e10a2020-07-09 17:12:52 -04001776 dataPaths() []android.DataPath
Liz Kammer1c14a212020-05-12 15:26:55 -07001777 }); ok {
1778 return p.dataPaths()
1779 }
1780 return nil
1781}
1782
Ivan Lozanof1868af2022-04-12 13:08:36 -04001783func getNameSuffixWithVndkVersion(ctx android.ModuleContext, c LinkableInterface) string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001784 // Returns the name suffix for product and vendor variants. If the VNDK version is not
1785 // "current", it will append the VNDK version to the name suffix.
Justin Yun5f7f7e82019-11-18 19:52:14 +09001786 var nameSuffix string
Ivan Lozanof9e21722020-12-02 09:00:51 -05001787 if c.InProduct() {
Justin Yund00f5ca2021-02-03 19:43:02 +09001788 if c.ProductSpecific() {
1789 // If the module is product specific with 'product_specific: true',
1790 // do not add a name suffix because it is a base module.
1791 return ""
1792 }
Justin Yunaf1fde42023-09-27 16:22:10 +09001793 return ProductSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001794 } else {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05001795 nameSuffix = VendorSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001796 }
Kiyoung Kim4e765b12024-04-04 17:33:42 +09001797 if c.VndkVersion() != "" {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001798 // add version suffix only if the module is using different vndk version than the
1799 // version in product or vendor partition.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001800 nameSuffix += "." + c.VndkVersion()
Justin Yun5f7f7e82019-11-18 19:52:14 +09001801 }
1802 return nameSuffix
1803}
1804
Ivan Lozanof1868af2022-04-12 13:08:36 -04001805func GetSubnameProperty(actx android.ModuleContext, c LinkableInterface) string {
1806 var subName = ""
Inseob Kim64c43952019-08-26 16:52:35 +09001807
1808 if c.Target().NativeBridge == android.NativeBridgeEnabled {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001809 subName += NativeBridgeSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001810 }
1811
Colin Cross127bb8b2020-12-16 16:46:01 -08001812 llndk := c.IsLlndk()
Kiyoung Kimaa394802024-01-08 12:55:45 +09001813 if llndk || (c.InVendorOrProduct() && c.HasNonSystemVariants()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001814 // .vendor.{version} suffix is added for vendor variant or .product.{version} suffix is
1815 // added for product variant only when we have vendor and product variants with core
1816 // variant. The suffix is not added for vendor-only or product-only module.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001817 subName += getNameSuffixWithVndkVersion(actx, c)
Colin Cross5271fea2021-04-27 13:06:04 -07001818 } else if c.IsVendorPublicLibrary() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001819 subName += vendorPublicLibrarySuffix
1820 } else if c.IsVndkPrebuiltLibrary() {
Inseob Kim64c43952019-08-26 16:52:35 +09001821 // .vendor suffix is added for backward compatibility with VNDK snapshot whose names with
1822 // such suffixes are already hard-coded in prebuilts/vndk/.../Android.bp.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001823 subName += VendorSuffix
Yifan Hong1b3348d2020-01-21 15:53:22 -08001824 } else if c.InRamdisk() && !c.OnlyInRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001825 subName += RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001826 } else if c.InVendorRamdisk() && !c.OnlyInVendorRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001827 subName += VendorRamdiskSuffix
Ivan Lozano52767be2019-10-18 14:49:46 -07001828 } else if c.InRecovery() && !c.OnlyInRecovery() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001829 subName += RecoverySuffix
1830 } else if c.IsSdkVariant() && (c.SdkAndPlatformVariantVisibleToMake() || c.SplitPerApiLevel()) {
1831 subName += sdkSuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001832 if c.SplitPerApiLevel() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001833 subName += "." + c.SdkVersion()
Dan Albert92fe7402020-07-15 13:33:30 -07001834 }
Spandan Dasb2b41d52023-04-13 18:15:05 +00001835 } else if c.IsStubs() && c.IsSdkVariant() {
1836 // Public API surface (NDK)
1837 // Add a suffix to this stub variant to distinguish it from the module-lib stub variant.
1838 subName = sdkSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001839 }
Ivan Lozanof1868af2022-04-12 13:08:36 -04001840
1841 return subName
Chris Parsons8d6e4332021-02-22 16:13:50 -05001842}
1843
Sam Delmerico75dbca22023-04-20 13:13:25 +00001844func moduleContextFromAndroidModuleContext(actx android.ModuleContext, c *Module) ModuleContext {
1845 ctx := &moduleContext{
1846 ModuleContext: actx,
1847 moduleContextImpl: moduleContextImpl{
1848 mod: c,
1849 },
1850 }
1851 ctx.ctx = ctx
1852 return ctx
1853}
1854
Spandan Das20fce2d2023-04-12 17:21:39 +00001855// TODO (b/277651159): Remove this allowlist
1856var (
1857 skipStubLibraryMultipleApexViolation = map[string]bool{
1858 "libclang_rt.asan": true,
1859 "libclang_rt.hwasan": true,
1860 // runtime apex
1861 "libc": true,
1862 "libc_hwasan": true,
1863 "libdl_android": true,
1864 "libm": true,
1865 "libdl": true,
Spandan Das1a0c6e12024-01-04 01:44:17 +00001866 "libz": true,
Spandan Das20fce2d2023-04-12 17:21:39 +00001867 // art apex
Martin Stjernholm75598032024-07-12 18:47:26 +01001868 // TODO(b/234351700): Remove this when com.android.art.debug is gone.
Spandan Das20fce2d2023-04-12 17:21:39 +00001869 "libandroidio": true,
1870 "libdexfile": true,
Martin Stjernholm75598032024-07-12 18:47:26 +01001871 "libdexfiled": true, // com.android.art.debug only
Spandan Das20fce2d2023-04-12 17:21:39 +00001872 "libnativebridge": true,
1873 "libnativehelper": true,
1874 "libnativeloader": true,
1875 "libsigchain": true,
1876 }
1877)
1878
1879// Returns true if a stub library could be installed in multiple apexes
1880func (c *Module) stubLibraryMultipleApexViolation(ctx android.ModuleContext) bool {
1881 // If this is not an apex variant, no check necessary
Colin Cross2dcbca62024-11-20 14:55:14 -08001882 if info, ok := android.ModuleProvider(ctx, android.ApexInfoProvider); !ok || info.IsForPlatform() {
Spandan Das20fce2d2023-04-12 17:21:39 +00001883 return false
1884 }
1885 // If this is not a stub library, no check necessary
1886 if !c.HasStubsVariants() {
1887 return false
1888 }
1889 // Skip the allowlist
1890 // Use BaseModuleName so that this matches prebuilts.
1891 if _, exists := skipStubLibraryMultipleApexViolation[c.BaseModuleName()]; exists {
1892 return false
1893 }
1894
1895 _, aaWithoutTestApexes, _ := android.ListSetDifference(c.ApexAvailable(), c.TestApexes())
1896 // Stub libraries should not have more than one apex_available
1897 if len(aaWithoutTestApexes) > 1 {
1898 return true
1899 }
1900 // Stub libraries should not use the wildcard
1901 if aaWithoutTestApexes[0] == android.AvailableToAnyApex {
1902 return true
1903 }
1904 // Default: no violation
1905 return false
1906}
1907
Chris Parsons8d6e4332021-02-22 16:13:50 -05001908func (c *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
Ronald Braunstein6a08d492024-04-15 12:55:30 -07001909 ctx := moduleContextFromAndroidModuleContext(actx, c)
1910
Inseob Kim37e0bb02024-04-29 15:54:44 +09001911 c.logtagsPaths = android.PathsForModuleSrc(actx, c.Properties.Logtags)
1912 android.SetProvider(ctx, android.LogtagsProviderKey, &android.LogtagsInfo{
1913 Logtags: c.logtagsPaths,
1914 })
1915
Ronald Braunstein6a08d492024-04-15 12:55:30 -07001916 // If Test_only is set on a module in bp file, respect the setting, otherwise
1917 // see if is a known test module type.
1918 testOnly := c.testModule || c.testLibrary()
1919 if c.sourceProperties.Test_only != nil {
1920 testOnly = Bool(c.sourceProperties.Test_only)
1921 }
1922 // Keep before any early returns.
1923 android.SetProvider(ctx, android.TestOnlyProviderKey, android.TestModuleInformation{
1924 TestOnly: testOnly,
1925 TopLevelTarget: c.testModule,
1926 })
1927
Ivan Lozanof1868af2022-04-12 13:08:36 -04001928 c.Properties.SubName = GetSubnameProperty(actx, c)
Colin Crossff694a82023-12-13 15:54:49 -08001929 apexInfo, _ := android.ModuleProvider(actx, android.ApexInfoProvider)
Chris Parsons8d6e4332021-02-22 16:13:50 -05001930 if !apexInfo.IsForPlatform() {
1931 c.hideApexVariantFromMake = true
1932 }
1933
Chris Parsonseefc9e62021-04-02 17:36:47 -04001934 c.makeLinkType = GetMakeLinkType(actx, c)
1935
Colin Crossf18e1102017-11-16 14:33:08 -08001936 deps := c.depsToPaths(ctx)
1937 if ctx.Failed() {
1938 return
1939 }
1940
Joe Onorato37f900c2023-07-18 16:58:16 -07001941 for _, generator := range c.generators {
1942 gen := generator.GeneratorSources(ctx)
1943 deps.IncludeDirs = append(deps.IncludeDirs, gen.IncludeDirs...)
1944 deps.ReexportedDirs = append(deps.ReexportedDirs, gen.ReexportedDirs...)
1945 deps.GeneratedDeps = append(deps.GeneratedDeps, gen.Headers...)
1946 deps.ReexportedGeneratedHeaders = append(deps.ReexportedGeneratedHeaders, gen.Headers...)
1947 deps.ReexportedDeps = append(deps.ReexportedDeps, gen.Headers...)
1948 if len(deps.Objs.objFiles) == 0 {
1949 // If we are reusuing object files (which happens when we're a shared library and we're
1950 // reusing our static variant's object files), then skip adding the actual source files,
1951 // because we already have the object for it.
1952 deps.GeneratedSources = append(deps.GeneratedSources, gen.Sources...)
1953 }
1954 }
1955
1956 if ctx.Failed() {
1957 return
1958 }
1959
Spandan Das20fce2d2023-04-12 17:21:39 +00001960 if c.stubLibraryMultipleApexViolation(actx) {
1961 actx.PropertyErrorf("apex_available",
1962 "Stub libraries should have a single apex_available (test apexes excluded). Got %v", c.ApexAvailable())
1963 }
Dan Willemsen8536d6b2018-10-07 20:54:34 -07001964 if c.Properties.Clang != nil && *c.Properties.Clang == false {
1965 ctx.PropertyErrorf("clang", "false (GCC) is no longer supported")
Alixb5f6d9e2022-04-20 23:00:58 +00001966 } else if c.Properties.Clang != nil && !ctx.DeviceConfig().BuildBrokenClangProperty() {
1967 ctx.PropertyErrorf("clang", "property is deprecated, see Changes.md file")
Dan Willemsen8536d6b2018-10-07 20:54:34 -07001968 }
1969
Colin Crossca860ac2016-01-04 14:34:37 -08001970 flags := Flags{
1971 Toolchain: c.toolchain(ctx),
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001972 EmitXrefs: ctx.Config().EmitXrefRules(),
Colin Crossca860ac2016-01-04 14:34:37 -08001973 }
Joe Onorato37f900c2023-07-18 16:58:16 -07001974 for _, generator := range c.generators {
1975 flags = generator.GeneratorFlags(ctx, flags, deps)
1976 }
Colin Crossca860ac2016-01-04 14:34:37 -08001977 if c.compiler != nil {
Colin Crossf18e1102017-11-16 14:33:08 -08001978 flags = c.compiler.compilerFlags(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001979 }
1980 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001981 flags = c.linker.linkerFlags(ctx, flags)
Colin Crossca860ac2016-01-04 14:34:37 -08001982 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001983 if c.stl != nil {
1984 flags = c.stl.flags(ctx, flags)
1985 }
Colin Cross16b23492016-01-06 14:41:07 -08001986 if c.sanitize != nil {
1987 flags = c.sanitize.flags(ctx, flags)
1988 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001989 if c.coverage != nil {
Pirama Arumuga Nainar82fe59b2019-07-02 14:55:35 -07001990 flags, deps = c.coverage.flags(ctx, flags, deps)
Dan Willemsen581341d2017-02-09 16:16:31 -08001991 }
Cory Barkera1da26f2022-06-07 20:12:06 +00001992 if c.fuzzer != nil {
1993 flags = c.fuzzer.flags(ctx, flags)
1994 }
Stephen Craneba090d12017-05-09 15:44:35 -07001995 if c.lto != nil {
1996 flags = c.lto.flags(ctx, flags)
1997 }
Yi Kongeb8efc92021-12-09 18:06:29 +08001998 if c.afdo != nil {
1999 flags = c.afdo.flags(ctx, flags)
2000 }
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00002001 if c.orderfile != nil {
2002 flags = c.orderfile.flags(ctx, flags)
2003 }
Colin Crossca860ac2016-01-04 14:34:37 -08002004 for _, feature := range c.features {
2005 flags = feature.flags(ctx, flags)
2006 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002007 if ctx.Failed() {
2008 return
2009 }
2010
Colin Cross4af21ed2019-11-04 09:37:55 -08002011 flags.Local.CFlags, _ = filterList(flags.Local.CFlags, config.IllegalFlags)
2012 flags.Local.CppFlags, _ = filterList(flags.Local.CppFlags, config.IllegalFlags)
2013 flags.Local.ConlyFlags, _ = filterList(flags.Local.ConlyFlags, config.IllegalFlags)
Colin Cross3f40fa42015-01-30 17:27:36 -08002014
Colin Cross4af21ed2019-11-04 09:37:55 -08002015 flags.Local.CommonFlags = append(flags.Local.CommonFlags, deps.Flags...)
Inseob Kim69378442019-06-03 19:10:47 +09002016
2017 for _, dir := range deps.IncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08002018 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-I"+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09002019 }
2020 for _, dir := range deps.SystemIncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08002021 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-isystem "+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09002022 }
2023
Colin Cross3e5e7782022-06-17 22:17:05 +00002024 flags.Local.LdFlags = append(flags.Local.LdFlags, deps.LdFlags...)
2025
Fabien Sanglardd61f1f42017-01-10 16:21:22 -08002026 c.flags = flags
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -07002027 // We need access to all the flags seen by a source file.
2028 if c.sabi != nil {
2029 flags = c.sabi.flags(ctx, flags)
2030 }
Dan Willemsen98ab3112019-08-27 21:20:40 -07002031
Colin Cross4af21ed2019-11-04 09:37:55 -08002032 flags.AssemblerWithCpp = inList("-xassembler-with-cpp", flags.Local.AsFlags)
Dan Willemsen98ab3112019-08-27 21:20:40 -07002033
Joe Onorato37f900c2023-07-18 16:58:16 -07002034 for _, generator := range c.generators {
2035 generator.GeneratorBuildActions(ctx, flags, deps)
2036 }
2037
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002038 var objs Objects
Colin Crossca860ac2016-01-04 14:34:37 -08002039 if c.compiler != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002040 objs = c.compiler.compile(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08002041 if ctx.Failed() {
2042 return
2043 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002044 }
2045
Colin Crossca860ac2016-01-04 14:34:37 -08002046 if c.linker != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002047 outputFile := c.linker.link(ctx, flags, deps, objs)
Colin Crossca860ac2016-01-04 14:34:37 -08002048 if ctx.Failed() {
2049 return
2050 }
Colin Cross635c3b02016-05-18 15:37:25 -07002051 c.outputFile = android.OptionalPathForPath(outputFile)
Jiyong Parkb0788572018-12-20 22:10:17 +09002052
Chris Parsons94a0bba2021-06-04 15:03:47 -04002053 c.maybeUnhideFromMake()
Colin Crossb614cd42024-10-11 12:52:21 -07002054
2055 android.SetProvider(ctx, ImplementationDepInfoProvider, &ImplementationDepInfo{
2056 ImplementationDeps: depset.New(depset.PREORDER, deps.directImplementationDeps, deps.transitiveImplementationDeps),
2057 })
Colin Crossce75d2c2016-10-06 16:12:58 -07002058 }
Ronald Braunsteina115e262024-04-09 18:07:38 -07002059
Colin Cross40213022023-12-13 15:19:49 -08002060 android.SetProvider(ctx, blueprint.SrcsFileProviderKey, blueprint.SrcsFileProviderData{SrcPaths: deps.GeneratedSources.Strings()})
Colin Cross5049f022015-03-18 13:28:46 -07002061
Hao Chen1c8ea5b2023-10-20 23:03:45 +00002062 if Bool(c.Properties.Cmake_snapshot_supported) {
2063 android.SetProvider(ctx, cmakeSnapshotSourcesProvider, android.GlobFiles(ctx, ctx.ModuleDir()+"/**/*", nil))
2064 }
2065
Chris Parsons94a0bba2021-06-04 15:03:47 -04002066 c.maybeInstall(ctx, apexInfo)
Colin Cross4a9e6ec2023-12-18 15:29:41 -08002067
2068 if c.linker != nil {
2069 moduleInfoJSON := ctx.ModuleInfoJSON()
2070 c.linker.moduleInfoJSON(ctx, moduleInfoJSON)
2071 moduleInfoJSON.SharedLibs = c.Properties.AndroidMkSharedLibs
2072 moduleInfoJSON.StaticLibs = c.Properties.AndroidMkStaticLibs
2073 moduleInfoJSON.SystemSharedLibs = c.Properties.AndroidMkSystemSharedLibs
2074 moduleInfoJSON.RuntimeDependencies = c.Properties.AndroidMkRuntimeLibs
2075
2076 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkSharedLibs...)
2077 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkStaticLibs...)
2078 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkHeaderLibs...)
2079 moduleInfoJSON.Dependencies = append(moduleInfoJSON.Dependencies, c.Properties.AndroidMkWholeStaticLibs...)
2080
2081 if c.sanitize != nil && len(moduleInfoJSON.Class) > 0 &&
2082 (moduleInfoJSON.Class[0] == "STATIC_LIBRARIES" || moduleInfoJSON.Class[0] == "HEADER_LIBRARIES") {
2083 if Bool(c.sanitize.Properties.SanitizeMutated.Cfi) {
2084 moduleInfoJSON.SubName += ".cfi"
2085 }
2086 if Bool(c.sanitize.Properties.SanitizeMutated.Hwaddress) {
2087 moduleInfoJSON.SubName += ".hwasan"
2088 }
2089 if Bool(c.sanitize.Properties.SanitizeMutated.Scs) {
2090 moduleInfoJSON.SubName += ".scs"
2091 }
2092 }
2093 moduleInfoJSON.SubName += c.Properties.SubName
2094
2095 if c.Properties.IsSdkVariant && c.Properties.SdkAndPlatformVariantVisibleToMake {
2096 moduleInfoJSON.Uninstallable = true
2097 }
Colin Cross4a9e6ec2023-12-18 15:29:41 -08002098 }
Wei Lia1aa2972024-06-21 13:08:51 -07002099
2100 buildComplianceMetadataInfo(ctx, c, deps)
mrziwangabdb2932024-06-18 12:43:41 -07002101
Cole Faust96a692b2024-08-08 14:47:51 -07002102 if b, ok := c.compiler.(*baseCompiler); ok {
2103 c.hasAidl = b.hasSrcExt(ctx, ".aidl")
2104 c.hasLex = b.hasSrcExt(ctx, ".l") || b.hasSrcExt(ctx, ".ll")
2105 c.hasProto = b.hasSrcExt(ctx, ".proto")
2106 c.hasRenderscript = b.hasSrcExt(ctx, ".rscript") || b.hasSrcExt(ctx, ".fs")
2107 c.hasSysprop = b.hasSrcExt(ctx, ".sysprop")
2108 c.hasWinMsg = b.hasSrcExt(ctx, ".mc")
2109 c.hasYacc = b.hasSrcExt(ctx, ".y") || b.hasSrcExt(ctx, ".yy")
2110 }
2111
Yu Liuec7043d2024-11-05 18:22:20 +00002112 ccObjectInfo := CcObjectInfo{
2113 kytheFiles: objs.kytheFiles,
2114 }
2115 if !ctx.Config().KatiEnabled() || !android.ShouldSkipAndroidMkProcessing(ctx, c) {
2116 ccObjectInfo.objFiles = objs.objFiles
2117 ccObjectInfo.tidyFiles = objs.tidyFiles
2118 }
2119 if len(ccObjectInfo.kytheFiles)+len(ccObjectInfo.objFiles)+len(ccObjectInfo.tidyFiles) > 0 {
2120 android.SetProvider(ctx, CcObjectInfoProvider, ccObjectInfo)
2121 }
2122
Yu Liu986d98c2024-11-12 00:28:11 +00002123 android.SetProvider(ctx, LinkableInfoKey, LinkableInfo{
2124 StaticExecutable: c.StaticExecutable(),
2125 })
2126
mrziwangabdb2932024-06-18 12:43:41 -07002127 c.setOutputFiles(ctx)
Yu Liu76d94462024-10-31 23:32:36 +00002128
2129 if c.makeVarsInfo != nil {
2130 android.SetProvider(ctx, CcMakeVarsInfoProvider, c.makeVarsInfo)
2131 }
mrziwangabdb2932024-06-18 12:43:41 -07002132}
2133
Yu Liuec7043d2024-11-05 18:22:20 +00002134func setOutputFilesIfNotEmpty(ctx ModuleContext, files android.Paths, tag string) {
2135 if len(files) > 0 {
2136 ctx.SetOutputFiles(files, tag)
2137 }
2138}
2139
mrziwangabdb2932024-06-18 12:43:41 -07002140func (c *Module) setOutputFiles(ctx ModuleContext) {
2141 if c.outputFile.Valid() {
2142 ctx.SetOutputFiles(android.Paths{c.outputFile.Path()}, "")
2143 } else {
2144 ctx.SetOutputFiles(android.Paths{}, "")
2145 }
2146 if c.linker != nil {
2147 ctx.SetOutputFiles(android.PathsIfNonNil(c.linker.unstrippedOutputFilePath()), "unstripped")
2148 ctx.SetOutputFiles(android.PathsIfNonNil(c.linker.strippedAllOutputFilePath()), "stripped_all")
2149 }
Wei Lia1aa2972024-06-21 13:08:51 -07002150}
2151
2152func buildComplianceMetadataInfo(ctx ModuleContext, c *Module, deps PathDeps) {
2153 // Dump metadata that can not be done in android/compliance-metadata.go
2154 complianceMetadataInfo := ctx.ComplianceMetadataInfo()
2155 complianceMetadataInfo.SetStringValue(android.ComplianceMetadataProp.IS_STATIC_LIB, strconv.FormatBool(ctx.static()))
2156 complianceMetadataInfo.SetStringValue(android.ComplianceMetadataProp.BUILT_FILES, c.outputFile.String())
2157
2158 // Static deps
2159 staticDeps := ctx.GetDirectDepsWithTag(StaticDepTag(false))
2160 staticDepNames := make([]string, 0, len(staticDeps))
2161 for _, dep := range staticDeps {
2162 staticDepNames = append(staticDepNames, dep.Name())
2163 }
2164
2165 staticDepPaths := make([]string, 0, len(deps.StaticLibs))
2166 for _, dep := range deps.StaticLibs {
2167 staticDepPaths = append(staticDepPaths, dep.String())
2168 }
2169 complianceMetadataInfo.SetListValue(android.ComplianceMetadataProp.STATIC_DEPS, android.FirstUniqueStrings(staticDepNames))
2170 complianceMetadataInfo.SetListValue(android.ComplianceMetadataProp.STATIC_DEP_FILES, android.FirstUniqueStrings(staticDepPaths))
2171
2172 // Whole static deps
2173 wholeStaticDeps := ctx.GetDirectDepsWithTag(StaticDepTag(true))
2174 wholeStaticDepNames := make([]string, 0, len(wholeStaticDeps))
2175 for _, dep := range wholeStaticDeps {
2176 wholeStaticDepNames = append(wholeStaticDepNames, dep.Name())
2177 }
2178
2179 wholeStaticDepPaths := make([]string, 0, len(deps.WholeStaticLibs))
2180 for _, dep := range deps.WholeStaticLibs {
2181 wholeStaticDepPaths = append(wholeStaticDepPaths, dep.String())
2182 }
2183 complianceMetadataInfo.SetListValue(android.ComplianceMetadataProp.WHOLE_STATIC_DEPS, android.FirstUniqueStrings(wholeStaticDepNames))
2184 complianceMetadataInfo.SetListValue(android.ComplianceMetadataProp.WHOLE_STATIC_DEP_FILES, android.FirstUniqueStrings(wholeStaticDepPaths))
Chris Parsons94a0bba2021-06-04 15:03:47 -04002185}
2186
2187func (c *Module) maybeUnhideFromMake() {
2188 // If a lib is directly included in any of the APEXes or is not available to the
2189 // platform (which is often the case when the stub is provided as a prebuilt),
2190 // unhide the stubs variant having the latest version gets visible to make. In
2191 // addition, the non-stubs variant is renamed to <libname>.bootstrap. This is to
2192 // force anything in the make world to link against the stubs library. (unless it
2193 // is explicitly referenced via .bootstrap suffix or the module is marked with
2194 // 'bootstrap: true').
2195 if c.HasStubsVariants() && c.NotInPlatform() && !c.InRamdisk() &&
Kiyoung Kimaa394802024-01-08 12:55:45 +09002196 !c.InRecovery() && !c.InVendorOrProduct() && !c.static() && !c.isCoverageVariant() &&
Chris Parsons94a0bba2021-06-04 15:03:47 -04002197 c.IsStubs() && !c.InVendorRamdisk() {
2198 c.Properties.HideFromMake = false // unhide
2199 // Note: this is still non-installable
2200 }
2201}
2202
Colin Cross8ff10582023-12-07 13:10:56 -08002203// maybeInstall is called at the end of both GenerateAndroidBuildActions to run the
2204// install hooks for installable modules, like binaries and tests.
Chris Parsons94a0bba2021-06-04 15:03:47 -04002205func (c *Module) maybeInstall(ctx ModuleContext, apexInfo android.ApexInfo) {
Colin Cross1bc94122021-10-28 13:25:54 -07002206 if !proptools.BoolDefault(c.Installable(), true) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002207 // If the module has been specifically configure to not be installed then
2208 // hide from make as otherwise it will break when running inside make
2209 // as the output path to install will not be specified. Not all uninstallable
2210 // modules can be hidden from make as some are needed for resolving make side
2211 // dependencies.
2212 c.HideFromMake()
Spandan Das034af2c2024-10-30 21:45:09 +00002213 c.SkipInstall()
Ivan Lozanod7586b62021-04-01 09:49:36 -04002214 } else if !installable(c, apexInfo) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002215 c.SkipInstall()
2216 }
2217
2218 // Still call c.installer.install though, the installs will be stored as PackageSpecs
2219 // to allow using the outputs in a genrule.
2220 if c.installer != nil && c.outputFile.Valid() {
Colin Crossce75d2c2016-10-06 16:12:58 -07002221 c.installer.install(ctx, c.outputFile.Path())
2222 if ctx.Failed() {
2223 return
Colin Crossca860ac2016-01-04 14:34:37 -08002224 }
Dan Albertc403f7c2015-03-18 14:01:18 -07002225 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002226}
2227
Colin Cross0ea8ba82019-06-06 14:33:29 -07002228func (c *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08002229 if c.cachedToolchain == nil {
Liz Kammer356f7d42021-01-26 09:18:53 -05002230 c.cachedToolchain = config.FindToolchainWithContext(ctx)
Colin Cross3f40fa42015-01-30 17:27:36 -08002231 }
Colin Crossca860ac2016-01-04 14:34:37 -08002232 return c.cachedToolchain
Colin Cross3f40fa42015-01-30 17:27:36 -08002233}
2234
Colin Crossca860ac2016-01-04 14:34:37 -08002235func (c *Module) begin(ctx BaseModuleContext) {
Joe Onorato37f900c2023-07-18 16:58:16 -07002236 for _, generator := range c.generators {
2237 generator.GeneratorInit(ctx)
2238 }
Colin Crossca860ac2016-01-04 14:34:37 -08002239 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002240 c.compiler.compilerInit(ctx)
Colin Cross21b9a242015-03-24 14:15:58 -07002241 }
Colin Crossca860ac2016-01-04 14:34:37 -08002242 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002243 c.linker.linkerInit(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08002244 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002245 if c.stl != nil {
2246 c.stl.begin(ctx)
2247 }
Colin Cross16b23492016-01-06 14:41:07 -08002248 if c.sanitize != nil {
2249 c.sanitize.begin(ctx)
2250 }
Dan Willemsen581341d2017-02-09 16:16:31 -08002251 if c.coverage != nil {
2252 c.coverage.begin(ctx)
2253 }
Yi Kong9723e332023-12-04 14:52:53 +09002254 if c.afdo != nil {
2255 c.afdo.begin(ctx)
2256 }
Stephen Craneba090d12017-05-09 15:44:35 -07002257 if c.lto != nil {
2258 c.lto.begin(ctx)
2259 }
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00002260 if c.orderfile != nil {
2261 c.orderfile.begin(ctx)
2262 }
Dan Albert92fe7402020-07-15 13:33:30 -07002263 if ctx.useSdk() && c.IsSdkVariant() {
Dan Albert1a246272020-07-06 14:49:35 -07002264 version, err := nativeApiLevelFromUser(ctx, ctx.sdkVersion())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002265 if err != nil {
2266 ctx.PropertyErrorf("sdk_version", err.Error())
Dan Albert1a246272020-07-06 14:49:35 -07002267 c.Properties.Sdk_version = nil
2268 } else {
2269 c.Properties.Sdk_version = StringPtr(version.String())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002270 }
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002271 }
Colin Crossca860ac2016-01-04 14:34:37 -08002272}
2273
Colin Cross37047f12016-12-13 17:06:13 -08002274func (c *Module) deps(ctx DepsContext) Deps {
Colin Crossc99deeb2016-04-11 15:06:20 -07002275 deps := Deps{}
2276
Joe Onorato37f900c2023-07-18 16:58:16 -07002277 for _, generator := range c.generators {
2278 deps = generator.GeneratorDeps(ctx, deps)
2279 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002280 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002281 deps = c.compiler.compilerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002282 }
2283 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002284 deps = c.linker.linkerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002285 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002286 if c.stl != nil {
2287 deps = c.stl.deps(ctx, deps)
2288 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00002289 if c.coverage != nil {
2290 deps = c.coverage.deps(ctx, deps)
2291 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002292
Colin Crossb6715442017-10-24 11:13:31 -07002293 deps.WholeStaticLibs = android.LastUniqueStrings(deps.WholeStaticLibs)
2294 deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
2295 deps.LateStaticLibs = android.LastUniqueStrings(deps.LateStaticLibs)
2296 deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
2297 deps.LateSharedLibs = android.LastUniqueStrings(deps.LateSharedLibs)
2298 deps.HeaderLibs = android.LastUniqueStrings(deps.HeaderLibs)
Logan Chien43d34c32017-12-20 01:17:32 +08002299 deps.RuntimeLibs = android.LastUniqueStrings(deps.RuntimeLibs)
Hsin-Yi Chen715142a2024-03-27 16:31:16 +08002300 deps.LlndkHeaderLibs = android.LastUniqueStrings(deps.LlndkHeaderLibs)
Colin Crossc99deeb2016-04-11 15:06:20 -07002301
Colin Cross516c5452024-10-28 13:45:21 -07002302 if err := checkConflictingExplicitVersions(deps.SharedLibs); err != nil {
2303 ctx.PropertyErrorf("shared_libs", "%s", err.Error())
2304 }
2305
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002306 for _, lib := range deps.ReexportSharedLibHeaders {
2307 if !inList(lib, deps.SharedLibs) {
2308 ctx.PropertyErrorf("export_shared_lib_headers", "Shared library not in shared_libs: '%s'", lib)
2309 }
2310 }
2311
2312 for _, lib := range deps.ReexportStaticLibHeaders {
Steven Morelandba407c82021-04-01 22:17:50 +00002313 if !inList(lib, deps.StaticLibs) && !inList(lib, deps.WholeStaticLibs) {
2314 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 -07002315 }
2316 }
2317
Colin Cross5950f382016-12-13 12:50:57 -08002318 for _, lib := range deps.ReexportHeaderLibHeaders {
2319 if !inList(lib, deps.HeaderLibs) {
2320 ctx.PropertyErrorf("export_header_lib_headers", "Header library not in header_libs: '%s'", lib)
2321 }
2322 }
2323
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002324 for _, gen := range deps.ReexportGeneratedHeaders {
2325 if !inList(gen, deps.GeneratedHeaders) {
2326 ctx.PropertyErrorf("export_generated_headers", "Generated header module not in generated_headers: '%s'", gen)
2327 }
2328 }
2329
Colin Crossc99deeb2016-04-11 15:06:20 -07002330 return deps
2331}
2332
Colin Cross516c5452024-10-28 13:45:21 -07002333func checkConflictingExplicitVersions(libs []string) error {
2334 withoutVersion := func(s string) string {
2335 name, _ := StubsLibNameAndVersion(s)
2336 return name
2337 }
2338 var errs []error
2339 for i, lib := range libs {
2340 libName := withoutVersion(lib)
2341 libsToCompare := libs[i+1:]
2342 j := slices.IndexFunc(libsToCompare, func(s string) bool {
2343 return withoutVersion(s) == libName
2344 })
2345 if j >= 0 {
2346 errs = append(errs, fmt.Errorf("duplicate shared libraries with different explicit versions: %q and %q",
2347 lib, libsToCompare[j]))
2348 }
2349 }
2350 return errors.Join(errs...)
2351}
2352
Dan Albert7e9d2952016-08-04 13:02:36 -07002353func (c *Module) beginMutator(actx android.BottomUpMutatorContext) {
Colin Crossca860ac2016-01-04 14:34:37 -08002354 ctx := &baseModuleContext{
Colin Cross0ea8ba82019-06-06 14:33:29 -07002355 BaseModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08002356 moduleContextImpl: moduleContextImpl{
2357 mod: c,
2358 },
2359 }
2360 ctx.ctx = ctx
2361
Colin Crossca860ac2016-01-04 14:34:37 -08002362 c.begin(ctx)
Dan Albert7e9d2952016-08-04 13:02:36 -07002363}
2364
Jiyong Park7ed9de32018-10-15 22:25:07 +09002365// Split name#version into name and version
Jiyong Park73c54ee2019-10-22 20:31:18 +09002366func StubsLibNameAndVersion(name string) (string, string) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002367 if sharp := strings.LastIndex(name, "#"); sharp != -1 && sharp != len(name)-1 {
2368 version := name[sharp+1:]
2369 libname := name[:sharp]
2370 return libname, version
2371 }
2372 return name, ""
2373}
2374
Dan Albert92fe7402020-07-15 13:33:30 -07002375func GetCrtVariations(ctx android.BottomUpMutatorContext,
2376 m LinkableInterface) []blueprint.Variation {
2377 if ctx.Os() != android.Android {
2378 return nil
2379 }
2380 if m.UseSdk() {
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09002381 // Choose the CRT that best satisfies the min_sdk_version requirement of this module
2382 minSdkVersion := m.MinSdkVersion()
2383 if minSdkVersion == "" || minSdkVersion == "apex_inherit" {
2384 minSdkVersion = m.SdkVersion()
2385 }
Jooyung Han94a76ee2021-06-08 09:49:48 +09002386 apiLevel, err := android.ApiLevelFromUser(ctx, minSdkVersion)
2387 if err != nil {
2388 ctx.PropertyErrorf("min_sdk_version", err.Error())
2389 }
Colin Cross363ec762023-01-13 13:45:14 -08002390
2391 // Raise the minSdkVersion to the minimum supported for the architecture.
Colin Crossbb137a32023-01-26 09:54:42 -08002392 minApiForArch := MinApiForArch(ctx, m.Target().Arch.ArchType)
Colin Cross363ec762023-01-13 13:45:14 -08002393 if apiLevel.LessThan(minApiForArch) {
2394 apiLevel = minApiForArch
2395 }
2396
Dan Albert92fe7402020-07-15 13:33:30 -07002397 return []blueprint.Variation{
2398 {Mutator: "sdk", Variation: "sdk"},
Jooyung Han94a76ee2021-06-08 09:49:48 +09002399 {Mutator: "version", Variation: apiLevel.String()},
Dan Albert92fe7402020-07-15 13:33:30 -07002400 }
2401 }
2402 return []blueprint.Variation{
2403 {Mutator: "sdk", Variation: ""},
2404 }
2405}
2406
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002407func AddSharedLibDependenciesWithVersions(ctx android.BottomUpMutatorContext, mod LinkableInterface,
2408 variations []blueprint.Variation, depTag blueprint.DependencyTag, name, version string, far bool) {
Colin Crosse7257d22020-09-24 09:56:18 -07002409
2410 variations = append([]blueprint.Variation(nil), variations...)
2411
Liz Kammer23942242022-04-08 15:41:00 -04002412 if version != "" && canBeOrLinkAgainstVersionVariants(mod) {
Colin Crosse7257d22020-09-24 09:56:18 -07002413 // Version is explicitly specified. i.e. libFoo#30
Colin Crossb614cd42024-10-11 12:52:21 -07002414 if version == "impl" {
2415 version = ""
2416 }
Colin Crosse7257d22020-09-24 09:56:18 -07002417 variations = append(variations, blueprint.Variation{Mutator: "version", Variation: version})
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002418 if tag, ok := depTag.(libraryDependencyTag); ok {
2419 tag.explicitlyVersioned = true
Colin Crossafcdce82024-10-22 13:59:33 -07002420 // depTag is an interface that contains a concrete non-pointer struct. That makes the local
2421 // tag variable a copy of the contents of depTag, and updating it doesn't change depTag. Reassign
2422 // the modified copy to depTag.
2423 depTag = tag
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002424 } else {
2425 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
2426 }
Colin Crosse7257d22020-09-24 09:56:18 -07002427 }
Colin Crosse7257d22020-09-24 09:56:18 -07002428
Colin Cross0de8a1e2020-09-18 14:15:30 -07002429 if far {
2430 ctx.AddFarVariationDependencies(variations, depTag, name)
2431 } else {
2432 ctx.AddVariationDependencies(variations, depTag, name)
Colin Crosse7257d22020-09-24 09:56:18 -07002433 }
2434}
2435
Kiyoung Kim487689e2022-07-26 09:48:22 +09002436func GetReplaceModuleName(lib string, replaceMap map[string]string) string {
2437 if snapshot, ok := replaceMap[lib]; ok {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002438 return snapshot
2439 }
2440
2441 return lib
2442}
2443
Kiyoung Kim37693d02024-04-04 09:56:15 +09002444// FilterNdkLibs takes a list of names of shared libraries and scans it for two types
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002445// of names:
2446//
Kiyoung Kim37693d02024-04-04 09:56:15 +09002447// 1. Name of an NDK library that refers to an ndk_library module.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002448//
2449// For each of these, it adds the name of the ndk_library module to the list of
2450// variant libs.
2451//
Kiyoung Kim37693d02024-04-04 09:56:15 +09002452// 2. Anything else (so anything that isn't an NDK library).
Kiyoung Kim487689e2022-07-26 09:48:22 +09002453//
2454// It adds these to the nonvariantLibs list.
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002455//
2456// The caller can then know to add the variantLibs dependencies differently from the
2457// nonvariantLibs
Kiyoung Kim37693d02024-04-04 09:56:15 +09002458func FilterNdkLibs(c LinkableInterface, config android.Config, list []string) (nonvariantLibs []string, variantLibs []string) {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002459 variantLibs = []string{}
2460
2461 nonvariantLibs = []string{}
2462 for _, entry := range list {
2463 // strip #version suffix out
2464 name, _ := StubsLibNameAndVersion(entry)
Kiyoung Kim37693d02024-04-04 09:56:15 +09002465 if c.UseSdk() && inList(name, *getNDKKnownLibs(config)) {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002466 variantLibs = append(variantLibs, name+ndkLibrarySuffix)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002467 } else {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002468 nonvariantLibs = append(nonvariantLibs, entry)
2469 }
2470 }
2471 return nonvariantLibs, variantLibs
Kiyoung Kim37693d02024-04-04 09:56:15 +09002472
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002473}
2474
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002475func rewriteLibsForApiImports(c LinkableInterface, libs []string, replaceList map[string]string, config android.Config) ([]string, []string) {
2476 nonVariantLibs := []string{}
2477 variantLibs := []string{}
2478
2479 for _, lib := range libs {
2480 replaceLibName := GetReplaceModuleName(lib, replaceList)
2481 if replaceLibName == lib {
2482 // Do not handle any libs which are not in API imports
2483 nonVariantLibs = append(nonVariantLibs, replaceLibName)
2484 } else if c.UseSdk() && inList(replaceLibName, *getNDKKnownLibs(config)) {
2485 variantLibs = append(variantLibs, replaceLibName)
2486 } else {
2487 nonVariantLibs = append(nonVariantLibs, replaceLibName)
2488 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002489 }
2490
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002491 return nonVariantLibs, variantLibs
Kiyoung Kim487689e2022-07-26 09:48:22 +09002492}
2493
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002494func (c *Module) shouldUseApiSurface() bool {
2495 if c.Os() == android.Android && c.Target().NativeBridge != android.NativeBridgeEnabled {
2496 if GetImageVariantType(c) == vendorImageVariant || GetImageVariantType(c) == productImageVariant {
2497 // LLNDK Variant
2498 return true
2499 }
2500
2501 if c.Properties.IsSdkVariant {
2502 // NDK Variant
2503 return true
2504 }
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002505 }
2506
2507 return false
2508}
2509
Colin Cross1e676be2016-10-12 14:38:15 -07002510func (c *Module) DepsMutator(actx android.BottomUpMutatorContext) {
Cole Fausta963b942024-04-11 17:43:00 -07002511 if !c.Enabled(actx) {
Inseob Kimeec88e12020-01-22 11:11:29 +09002512 return
2513 }
2514
Colin Cross37047f12016-12-13 17:06:13 -08002515 ctx := &depsContext{
2516 BottomUpMutatorContext: actx,
Dan Albert7e9d2952016-08-04 13:02:36 -07002517 moduleContextImpl: moduleContextImpl{
2518 mod: c,
2519 },
2520 }
2521 ctx.ctx = ctx
Colin Crossca860ac2016-01-04 14:34:37 -08002522
Colin Crossc99deeb2016-04-11 15:06:20 -07002523 deps := c.deps(ctx)
Kiyoung Kim11d91082022-10-19 19:20:57 +09002524
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002525 apiNdkLibs := []string{}
2526 apiLateNdkLibs := []string{}
2527
Yo Chiang219968c2020-09-22 18:45:04 +08002528 c.Properties.AndroidMkSystemSharedLibs = deps.SystemSharedLibs
2529
Dan Albert914449f2016-06-17 16:45:24 -07002530 variantNdkLibs := []string{}
2531 variantLateNdkLibs := []string{}
Dan Willemsenb916b802017-03-19 13:44:32 -07002532 if ctx.Os() == android.Android {
Kiyoung Kim37693d02024-04-04 09:56:15 +09002533 deps.SharedLibs, variantNdkLibs = FilterNdkLibs(c, ctx.Config(), deps.SharedLibs)
2534 deps.LateSharedLibs, variantLateNdkLibs = FilterNdkLibs(c, ctx.Config(), deps.LateSharedLibs)
2535 deps.ReexportSharedLibHeaders, _ = FilterNdkLibs(c, ctx.Config(), deps.ReexportSharedLibHeaders)
Dan Willemsen72d39932016-07-08 23:23:48 -07002536 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002537
Colin Cross32ec36c2016-12-15 07:39:51 -08002538 for _, lib := range deps.HeaderLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002539 depTag := libraryDependencyTag{Kind: headerLibraryDependency}
Colin Cross32ec36c2016-12-15 07:39:51 -08002540 if inList(lib, deps.ReexportHeaderLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002541 depTag.reexportFlags = true
Colin Cross32ec36c2016-12-15 07:39:51 -08002542 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002543
Spandan Das73bcafc2022-08-18 23:26:00 +00002544 if c.isNDKStubLibrary() {
Jiyong Parkf8fab9b2024-09-02 15:24:15 +09002545 variationExists := actx.OtherModuleDependencyVariantExists(nil, lib)
2546 if variationExists {
2547 actx.AddVariationDependencies(nil, depTag, lib)
2548 } else {
2549 // dependencies to ndk_headers fall here as ndk_headers do not have
2550 // any variants.
2551 actx.AddFarVariationDependencies([]blueprint.Variation{}, depTag, lib)
2552 }
Spandan Dasff665182024-09-11 18:48:44 +00002553 } else if c.IsStubs() {
Colin Cross7228ecd2019-11-18 16:00:16 -08002554 actx.AddFarVariationDependencies(append(ctx.Target().Variations(), c.ImageVariation()),
Colin Cross0f7d2ef2019-10-16 11:03:10 -07002555 depTag, lib)
Jiyong Park7e636d02019-01-28 16:16:54 +09002556 } else {
2557 actx.AddVariationDependencies(nil, depTag, lib)
2558 }
2559 }
2560
Dan Albertf1d14c72020-07-30 14:32:55 -07002561 if c.isNDKStubLibrary() {
2562 // NDK stubs depend on their implementation because the ABI dumps are
2563 // generated from the implementation library.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002564
Spandan Das8b08aea2023-03-14 19:29:34 +00002565 actx.AddFarVariationDependencies(append(ctx.Target().Variations(),
2566 c.ImageVariation(),
2567 blueprint.Variation{Mutator: "link", Variation: "shared"},
2568 ), stubImplementation, c.BaseModuleName())
Dan Albertf1d14c72020-07-30 14:32:55 -07002569 }
2570
Hsin-Yi Chen715142a2024-03-27 16:31:16 +08002571 // If this module is an LLNDK implementation library, let it depend on LlndkHeaderLibs.
2572 if c.ImageVariation().Variation == android.CoreVariation && c.Device() &&
2573 c.Target().NativeBridge == android.NativeBridgeDisabled {
2574 actx.AddVariationDependencies(
Jihoon Kang47e91842024-06-19 00:51:16 +00002575 []blueprint.Variation{{Mutator: "image", Variation: android.VendorVariation}},
Hsin-Yi Chen715142a2024-03-27 16:31:16 +08002576 llndkHeaderLibTag,
2577 deps.LlndkHeaderLibs...)
2578 }
2579
Jiyong Park5d1598f2019-02-25 22:14:17 +09002580 for _, lib := range deps.WholeStaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002581 depTag := libraryDependencyTag{Kind: staticLibraryDependency, wholeStatic: true, reexportFlags: true}
Inseob Kimeec88e12020-01-22 11:11:29 +09002582
Jiyong Park5d1598f2019-02-25 22:14:17 +09002583 actx.AddVariationDependencies([]blueprint.Variation{
2584 {Mutator: "link", Variation: "static"},
2585 }, depTag, lib)
2586 }
2587
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002588 for _, lib := range deps.StaticLibs {
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04002589 // Some dependencies listed in static_libs might actually be rust_ffi rlib variants.
Colin Cross6e511a92020-07-27 21:26:48 -07002590 depTag := libraryDependencyTag{Kind: staticLibraryDependency}
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04002591
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002592 if inList(lib, deps.ReexportStaticLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002593 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002594 }
Jiyong Parke3867542020-12-03 17:28:25 +09002595 if inList(lib, deps.ExcludeLibsForApex) {
2596 depTag.excludeInApex = true
2597 }
Dan Willemsen59339a22018-07-22 21:18:45 -07002598 actx.AddVariationDependencies([]blueprint.Variation{
2599 {Mutator: "link", Variation: "static"},
2600 }, depTag, lib)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002601 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002602
Jooyung Han75568392020-03-20 04:29:24 +09002603 // staticUnwinderDep is treated as staticDep for Q apexes
2604 // so that native libraries/binaries are linked with static unwinder
2605 // because Q libc doesn't have unwinder APIs
2606 if deps.StaticUnwinderIfLegacy {
Colin Cross6e511a92020-07-27 21:26:48 -07002607 depTag := libraryDependencyTag{Kind: staticLibraryDependency, staticUnwinder: true}
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002608 actx.AddVariationDependencies([]blueprint.Variation{
2609 {Mutator: "link", Variation: "static"},
Kiyoung Kim37693d02024-04-04 09:56:15 +09002610 }, depTag, staticUnwinder(actx))
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002611 }
2612
Jiyong Park7ed9de32018-10-15 22:25:07 +09002613 // shared lib names without the #version suffix
2614 var sharedLibNames []string
2615
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002616 for _, lib := range deps.SharedLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002617 depTag := libraryDependencyTag{Kind: sharedLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002618 if inList(lib, deps.ReexportSharedLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002619 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002620 }
Jiyong Parke3867542020-12-03 17:28:25 +09002621 if inList(lib, deps.ExcludeLibsForApex) {
2622 depTag.excludeInApex = true
2623 }
Jooyung Han9ffbe832023-11-28 22:31:35 +09002624 if inList(lib, deps.ExcludeLibsForNonApex) {
2625 depTag.excludeInNonApex = true
2626 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002627
Jiyong Park73c54ee2019-10-22 20:31:18 +09002628 name, version := StubsLibNameAndVersion(lib)
Inseob Kimc0907f12019-02-08 21:00:45 +09002629 sharedLibNames = append(sharedLibNames, name)
2630
Colin Crosse7257d22020-09-24 09:56:18 -07002631 variations := []blueprint.Variation{
2632 {Mutator: "link", Variation: "shared"},
2633 }
Spandan Dasff665182024-09-11 18:48:44 +00002634 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, name, version, false)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002635 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002636
Colin Crossfe9acfe2021-06-14 16:13:03 -07002637 for _, lib := range deps.LateStaticLibs {
2638 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency}
2639 actx.AddVariationDependencies([]blueprint.Variation{
2640 {Mutator: "link", Variation: "static"},
Kiyoung Kim37693d02024-04-04 09:56:15 +09002641 }, depTag, lib)
Colin Crossfe9acfe2021-06-14 16:13:03 -07002642 }
2643
Colin Cross3e5e7782022-06-17 22:17:05 +00002644 for _, lib := range deps.UnexportedStaticLibs {
2645 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency, unexportedSymbols: true}
2646 actx.AddVariationDependencies([]blueprint.Variation{
2647 {Mutator: "link", Variation: "static"},
Kiyoung Kim37693d02024-04-04 09:56:15 +09002648 }, depTag, lib)
Colin Cross3e5e7782022-06-17 22:17:05 +00002649 }
2650
Jiyong Park7ed9de32018-10-15 22:25:07 +09002651 for _, lib := range deps.LateSharedLibs {
Jiyong Park25fc6a92018-11-18 18:02:45 +09002652 if inList(lib, sharedLibNames) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002653 // This is to handle the case that some of the late shared libs (libc, libdl, libm, ...)
2654 // are added also to SharedLibs with version (e.g., libc#10). If not skipped, we will be
2655 // linking against both the stubs lib and the non-stubs lib at the same time.
2656 continue
2657 }
Colin Cross6e511a92020-07-27 21:26:48 -07002658 depTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency}
Colin Crosse7257d22020-09-24 09:56:18 -07002659 variations := []blueprint.Variation{
2660 {Mutator: "link", Variation: "shared"},
2661 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002662 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, lib, "", false)
Jiyong Park7ed9de32018-10-15 22:25:07 +09002663 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002664
Dan Willemsen59339a22018-07-22 21:18:45 -07002665 actx.AddVariationDependencies([]blueprint.Variation{
2666 {Mutator: "link", Variation: "shared"},
Chris Parsons79d66a52020-06-05 17:26:16 -04002667 }, dataLibDepTag, deps.DataLibs...)
2668
Colin Crossc8caa062021-09-24 16:50:14 -07002669 actx.AddVariationDependencies(nil, dataBinDepTag, deps.DataBins...)
2670
Chris Parsons79d66a52020-06-05 17:26:16 -04002671 actx.AddVariationDependencies([]blueprint.Variation{
2672 {Mutator: "link", Variation: "shared"},
Dan Willemsen59339a22018-07-22 21:18:45 -07002673 }, runtimeDepTag, deps.RuntimeLibs...)
Logan Chien43d34c32017-12-20 01:17:32 +08002674
Colin Cross68861832016-07-08 10:41:41 -07002675 actx.AddDependency(c, genSourceDepTag, deps.GeneratedSources...)
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002676
2677 for _, gen := range deps.GeneratedHeaders {
2678 depTag := genHeaderDepTag
2679 if inList(gen, deps.ReexportGeneratedHeaders) {
2680 depTag = genHeaderExportDepTag
2681 }
2682 actx.AddDependency(c, depTag, gen)
2683 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002684
Cole Faust65cb40a2024-10-21 15:41:42 -07002685 for _, gen := range deps.DeviceFirstGeneratedHeaders {
2686 depTag := genHeaderDepTag
2687 actx.AddVariationDependencies(ctx.Config().AndroidFirstDeviceTarget.Variations(), depTag, gen)
2688 }
2689
Dan Albert92fe7402020-07-15 13:33:30 -07002690 crtVariations := GetCrtVariations(ctx, c)
Colin Crossbbc941b2020-09-30 12:27:01 -07002691 actx.AddVariationDependencies(crtVariations, objDepTag, deps.ObjFiles...)
Colin Crossc465efd2021-06-11 18:00:04 -07002692 for _, crt := range deps.CrtBegin {
Dan Albert92fe7402020-07-15 13:33:30 -07002693 actx.AddVariationDependencies(crtVariations, CrtBeginDepTag,
Kiyoung Kim37693d02024-04-04 09:56:15 +09002694 crt)
Colin Crossca860ac2016-01-04 14:34:37 -08002695 }
Colin Crossc465efd2021-06-11 18:00:04 -07002696 for _, crt := range deps.CrtEnd {
Dan Albert92fe7402020-07-15 13:33:30 -07002697 actx.AddVariationDependencies(crtVariations, CrtEndDepTag,
Kiyoung Kim37693d02024-04-04 09:56:15 +09002698 crt)
Colin Cross21b9a242015-03-24 14:15:58 -07002699 }
Dan Willemsena0790e32018-10-12 00:24:23 -07002700 if deps.DynamicLinker != "" {
2701 actx.AddDependency(c, dynamicLinkerDepTag, deps.DynamicLinker)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002702 }
Dan Albert914449f2016-06-17 16:45:24 -07002703
2704 version := ctx.sdkVersion()
Colin Cross6e511a92020-07-27 21:26:48 -07002705
2706 ndkStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002707 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002708 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002709 {Mutator: "link", Variation: "shared"},
2710 }, ndkStubDepTag, variantNdkLibs...)
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002711 actx.AddVariationDependencies([]blueprint.Variation{
2712 {Mutator: "version", Variation: version},
2713 {Mutator: "link", Variation: "shared"},
2714 }, ndkStubDepTag, apiNdkLibs...)
Colin Cross6e511a92020-07-27 21:26:48 -07002715
2716 ndkLateStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002717 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002718 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002719 {Mutator: "link", Variation: "shared"},
2720 }, ndkLateStubDepTag, variantLateNdkLibs...)
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002721 actx.AddVariationDependencies([]blueprint.Variation{
2722 {Mutator: "version", Variation: version},
2723 {Mutator: "link", Variation: "shared"},
2724 }, ndkLateStubDepTag, apiLateNdkLibs...)
Logan Chienf3511742017-10-31 18:04:35 +08002725
Vinh Tran367d89d2023-04-28 11:21:25 -04002726 if len(deps.AidlLibs) > 0 {
2727 actx.AddDependency(
2728 c,
2729 aidlLibraryTag,
2730 deps.AidlLibs...,
2731 )
2732 }
2733
Colin Cross6362e272015-10-29 15:25:03 -07002734}
Colin Cross21b9a242015-03-24 14:15:58 -07002735
Colin Crosse40b4ea2018-10-02 22:25:58 -07002736func BeginMutator(ctx android.BottomUpMutatorContext) {
Cole Fausta963b942024-04-11 17:43:00 -07002737 if c, ok := ctx.Module().(*Module); ok && c.Enabled(ctx) {
Dan Albert7e9d2952016-08-04 13:02:36 -07002738 c.beginMutator(ctx)
2739 }
2740}
2741
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002742// Whether a module can link to another module, taking into
2743// account NDK linking.
Jooyung Han479ca172020-10-19 18:51:07 +09002744func checkLinkType(ctx android.BaseModuleContext, from LinkableInterface, to LinkableInterface,
Colin Cross6e511a92020-07-27 21:26:48 -07002745 tag blueprint.DependencyTag) {
2746
2747 switch t := tag.(type) {
2748 case dependencyTag:
2749 if t != vndkExtDepTag {
2750 return
2751 }
2752 case libraryDependencyTag:
2753 default:
2754 return
2755 }
2756
Ivan Lozanof9e21722020-12-02 09:00:51 -05002757 if from.Target().Os != android.Android {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002758 // Host code is not restricted
2759 return
2760 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002761
Ivan Lozano52767be2019-10-18 14:49:46 -07002762 if from.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002763 // Platform code can link to anything
2764 return
2765 }
Yifan Hong1b3348d2020-01-21 15:53:22 -08002766 if from.InRamdisk() {
2767 // Ramdisk code is not NDK
2768 return
2769 }
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002770 if from.InVendorRamdisk() {
2771 // Vendor ramdisk code is not NDK
2772 return
2773 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002774 if from.InRecovery() {
Jiyong Parkf9332f12018-02-01 00:54:12 +09002775 // Recovery code is not NDK
2776 return
2777 }
Colin Cross31076b32020-10-23 17:22:06 -07002778 if c, ok := to.(*Module); ok {
Colin Cross31076b32020-10-23 17:22:06 -07002779 if c.StubDecorator() {
2780 // These aren't real libraries, but are the stub shared libraries that are included in
2781 // the NDK.
2782 return
2783 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002784 }
Logan Chien834b9a62019-01-14 15:39:03 +08002785
Ivan Lozano52767be2019-10-18 14:49:46 -07002786 if strings.HasPrefix(ctx.ModuleName(), "libclang_rt.") && to.Module().Name() == "libc++" {
Logan Chien834b9a62019-01-14 15:39:03 +08002787 // Bug: http://b/121358700 - Allow libclang_rt.* shared libraries (with sdk_version)
2788 // to link to libc++ (non-NDK and without sdk_version).
2789 return
2790 }
2791
Ivan Lozano52767be2019-10-18 14:49:46 -07002792 if to.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002793 // NDK code linking to platform code is never okay.
2794 ctx.ModuleErrorf("depends on non-NDK-built library %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002795 ctx.OtherModuleName(to.Module()))
Dan Willemsen155d17c2019-02-06 18:30:02 -08002796 return
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002797 }
2798
2799 // At this point we know we have two NDK libraries, but we need to
2800 // check that we're not linking against anything built against a higher
2801 // API level, as it is only valid to link against older or equivalent
2802 // APIs.
2803
Inseob Kim01a28722018-04-11 09:48:45 +09002804 // Current can link against anything.
Ivan Lozano52767be2019-10-18 14:49:46 -07002805 if from.SdkVersion() != "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002806 // Otherwise we need to check.
Ivan Lozano52767be2019-10-18 14:49:46 -07002807 if to.SdkVersion() == "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002808 // Current can't be linked against by anything else.
2809 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002810 ctx.OtherModuleName(to.Module()), "current")
Inseob Kim01a28722018-04-11 09:48:45 +09002811 } else {
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002812 fromApi, err := android.ApiLevelFromUserWithConfig(ctx.Config(), from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002813 if err != nil {
2814 ctx.PropertyErrorf("sdk_version",
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002815 "Invalid sdk_version value (must be int, preview or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002816 from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002817 }
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002818 toApi, err := android.ApiLevelFromUserWithConfig(ctx.Config(), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002819 if err != nil {
2820 ctx.PropertyErrorf("sdk_version",
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002821 "Invalid sdk_version value (must be int, preview or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002822 to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002823 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002824
Prashanth Swaminathan6dcbd9c2023-07-18 17:55:01 -07002825 if toApi.GreaterThan(fromApi) {
Inseob Kim01a28722018-04-11 09:48:45 +09002826 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002827 ctx.OtherModuleName(to.Module()), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002828 }
2829 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002830 }
Dan Albert202fe492017-12-15 13:56:59 -08002831
2832 // Also check that the two STL choices are compatible.
Ivan Lozano52767be2019-10-18 14:49:46 -07002833 fromStl := from.SelectedStl()
2834 toStl := to.SelectedStl()
Dan Albert202fe492017-12-15 13:56:59 -08002835 if fromStl == "" || toStl == "" {
2836 // Libraries that don't use the STL are unrestricted.
Inseob Kimda2171a2018-04-11 15:41:38 +09002837 } else if fromStl == "ndk_system" || toStl == "ndk_system" {
Dan Albert202fe492017-12-15 13:56:59 -08002838 // We can be permissive with the system "STL" since it is only the C++
2839 // ABI layer, but in the future we should make sure that everyone is
2840 // using either libc++ or nothing.
Colin Crossb60190a2018-09-04 16:28:17 -07002841 } else if getNdkStlFamily(from) != getNdkStlFamily(to) {
Dan Albert202fe492017-12-15 13:56:59 -08002842 ctx.ModuleErrorf("uses %q and depends on %q which uses incompatible %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002843 from.SelectedStl(), ctx.OtherModuleName(to.Module()),
2844 to.SelectedStl())
Dan Albert202fe492017-12-15 13:56:59 -08002845 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002846}
2847
Jooyung Han479ca172020-10-19 18:51:07 +09002848func checkLinkTypeMutator(ctx android.BottomUpMutatorContext) {
2849 if c, ok := ctx.Module().(*Module); ok {
2850 ctx.VisitDirectDeps(func(dep android.Module) {
2851 depTag := ctx.OtherModuleDependencyTag(dep)
2852 ccDep, ok := dep.(LinkableInterface)
2853 if ok {
2854 checkLinkType(ctx, c, ccDep, depTag)
2855 }
2856 })
2857 }
2858}
2859
Jiyong Park5fb8c102018-04-09 12:03:06 +09002860// Tests whether the dependent library is okay to be double loaded inside a single process.
Jooyung Hana70f0672019-01-18 15:20:43 +09002861// If a library has a vendor variant and is a (transitive) dependency of an LLNDK library,
2862// it is subject to be double loaded. Such lib should be explicitly marked as double_loadable: true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002863// or as vndk-sp (vndk: { enabled: true, support_system_process: true}).
Colin Crossda279cf2024-09-17 14:25:45 -07002864func checkDoubleLoadableLibraries(ctx android.BottomUpMutatorContext) {
Jooyung Hana70f0672019-01-18 15:20:43 +09002865 check := func(child, parent android.Module) bool {
2866 to, ok := child.(*Module)
2867 if !ok {
Jooyung Han479ca172020-10-19 18:51:07 +09002868 return false
Jooyung Hana70f0672019-01-18 15:20:43 +09002869 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002870
Jooyung Hana70f0672019-01-18 15:20:43 +09002871 if lib, ok := to.linker.(*libraryDecorator); !ok || !lib.shared() {
2872 return false
Jiyong Park5fb8c102018-04-09 12:03:06 +09002873 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002874
Jiyong Park0474e1f2021-01-14 14:26:06 +09002875 // These dependencies are not excercised at runtime. Tracking these will give us
2876 // false negative, so skip.
Jiyong Park1ad8e162020-12-01 23:40:09 +09002877 depTag := ctx.OtherModuleDependencyTag(child)
2878 if IsHeaderDepTag(depTag) {
2879 return false
2880 }
Jiyong Park0474e1f2021-01-14 14:26:06 +09002881 if depTag == staticVariantTag {
2882 return false
2883 }
2884 if depTag == stubImplDepTag {
2885 return false
2886 }
Jiyong Park8bcf3c62024-03-18 18:37:10 +09002887 if depTag == android.RequiredDepTag {
2888 return false
2889 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002890
Justin Yun63e9ec72020-10-29 16:49:43 +09002891 // Even if target lib has no vendor variant, keep checking dependency
2892 // graph in case it depends on vendor_available or product_available
2893 // but not double_loadable transtively.
2894 if !to.HasNonSystemVariants() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002895 return true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002896 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002897
Jiyong Park0474e1f2021-01-14 14:26:06 +09002898 // The happy path. Keep tracking dependencies until we hit a non double-loadable
2899 // one.
2900 if Bool(to.VendorProperties.Double_loadable) {
2901 return true
2902 }
2903
Kiyoung Kim9f26fcf2024-05-27 17:25:52 +09002904 if to.IsLlndk() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002905 return false
2906 }
2907
Jooyung Hana70f0672019-01-18 15:20:43 +09002908 ctx.ModuleErrorf("links a library %q which is not LL-NDK, "+
2909 "VNDK-SP, or explicitly marked as 'double_loadable:true'. "+
Jiyong Park0474e1f2021-01-14 14:26:06 +09002910 "Dependency list: %s", ctx.OtherModuleName(to), ctx.GetPathString(false))
Jooyung Hana70f0672019-01-18 15:20:43 +09002911 return false
2912 }
2913 if module, ok := ctx.Module().(*Module); ok {
2914 if lib, ok := module.linker.(*libraryDecorator); ok && lib.shared() {
Jiyong Park0474e1f2021-01-14 14:26:06 +09002915 if lib.hasLLNDKStubs() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002916 ctx.WalkDeps(check)
2917 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002918 }
2919 }
2920}
2921
Yu Liue4312402023-01-18 09:15:31 -08002922func findApexSdkVersion(ctx android.BaseModuleContext, apexInfo android.ApexInfo) android.ApiLevel {
2923 // For the dependency from platform to apex, use the latest stubs
2924 apexSdkVersion := android.FutureApiLevel
2925 if !apexInfo.IsForPlatform() {
2926 apexSdkVersion = apexInfo.MinSdkVersion
2927 }
2928
2929 if android.InList("hwaddress", ctx.Config().SanitizeDevice()) {
2930 // In hwasan build, we override apexSdkVersion to the FutureApiLevel(10000)
2931 // so that even Q(29/Android10) apexes could use the dynamic unwinder by linking the newer stubs(e.g libc(R+)).
2932 // (b/144430859)
2933 apexSdkVersion = android.FutureApiLevel
2934 }
2935
2936 return apexSdkVersion
2937}
2938
Colin Crossc99deeb2016-04-11 15:06:20 -07002939// Convert dependencies to paths. Returns a PathDeps containing paths
Colin Cross635c3b02016-05-18 15:37:25 -07002940func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
Colin Crossca860ac2016-01-04 14:34:37 -08002941 var depPaths PathDeps
Colin Crossca860ac2016-01-04 14:34:37 -08002942
Colin Cross0de8a1e2020-09-18 14:15:30 -07002943 var directStaticDeps []StaticLibraryInfo
2944 var directSharedDeps []SharedLibraryInfo
Jeff Gaston294356f2017-09-27 17:05:30 -07002945
Colin Cross0de8a1e2020-09-18 14:15:30 -07002946 reexportExporter := func(exporter FlagExporterInfo) {
2947 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, exporter.IncludeDirs...)
2948 depPaths.ReexportedSystemDirs = append(depPaths.ReexportedSystemDirs, exporter.SystemIncludeDirs...)
2949 depPaths.ReexportedFlags = append(depPaths.ReexportedFlags, exporter.Flags...)
2950 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, exporter.Deps...)
2951 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders, exporter.GeneratedHeaders...)
Inseob Kim69378442019-06-03 19:10:47 +09002952 }
2953
Colin Crossff694a82023-12-13 15:54:49 -08002954 apexInfo, _ := android.ModuleProvider(ctx, android.ApexInfoProvider)
Yu Liue4312402023-01-18 09:15:31 -08002955 c.apexSdkVersion = findApexSdkVersion(ctx, apexInfo)
Jooyung Hande34d232020-07-23 13:04:15 +09002956
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002957 skipModuleList := map[string]bool{}
2958
Colin Crossd11fcda2017-10-23 17:59:01 -07002959 ctx.VisitDirectDeps(func(dep android.Module) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002960 depName := ctx.OtherModuleName(dep)
2961 depTag := ctx.OtherModuleDependencyTag(dep)
Dan Albert9e10cd42016-08-03 14:12:14 -07002962
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002963 if _, ok := skipModuleList[depName]; ok {
2964 // skip this module because original module or API imported module matching with this should be used instead.
2965 return
2966 }
2967
Dan Willemsen47450072021-10-19 20:24:49 -07002968 if depTag == android.DarwinUniversalVariantTag {
2969 depPaths.DarwinSecondArchOutput = dep.(*Module).OutputFile()
2970 return
2971 }
2972
Vinh Tran367d89d2023-04-28 11:21:25 -04002973 if depTag == aidlLibraryTag {
Colin Cross313aa542023-12-13 13:47:44 -08002974 if aidlLibraryInfo, ok := android.OtherModuleProvider(ctx, dep, aidl_library.AidlLibraryProvider); ok {
Vinh Tran367d89d2023-04-28 11:21:25 -04002975 depPaths.AidlLibraryInfos = append(
2976 depPaths.AidlLibraryInfos,
Colin Cross313aa542023-12-13 13:47:44 -08002977 aidlLibraryInfo,
Vinh Tran367d89d2023-04-28 11:21:25 -04002978 )
2979 }
2980 }
2981
Ivan Lozano52767be2019-10-18 14:49:46 -07002982 ccDep, ok := dep.(LinkableInterface)
2983 if !ok {
2984
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002985 // handling for a few module types that aren't cc Module but that are also supported
2986 switch depTag {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002987 case genSourceDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002988 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002989 depPaths.GeneratedSources = append(depPaths.GeneratedSources,
2990 genRule.GeneratedSourceFiles()...)
2991 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002992 ctx.ModuleErrorf("module %q is not a gensrcs or genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002993 }
Colin Crosse90bfd12017-04-26 16:59:26 -07002994 // Support exported headers from a generated_sources dependency
2995 fallthrough
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002996 case genHeaderDepTag, genHeaderExportDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002997 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Inseob Kimd110f872019-12-06 13:15:38 +09002998 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps,
Dan Willemsen9da9d492018-02-21 18:28:18 -08002999 genRule.GeneratedDeps()...)
Jiyong Park74955042019-10-22 20:19:51 +09003000 dirs := genRule.GeneratedHeaderDirs()
Inseob Kim69378442019-06-03 19:10:47 +09003001 depPaths.IncludeDirs = append(depPaths.IncludeDirs, dirs...)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003002 if depTag == genHeaderExportDepTag {
Inseob Kim69378442019-06-03 19:10:47 +09003003 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, dirs...)
Inseob Kimd110f872019-12-06 13:15:38 +09003004 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders,
3005 genRule.GeneratedSourceFiles()...)
Inseob Kim69378442019-06-03 19:10:47 +09003006 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, genRule.GeneratedDeps()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07003007 // 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 +09003008 c.sabi.Properties.ReexportedIncludes = append(c.sabi.Properties.ReexportedIncludes, dirs.Strings()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07003009
Dan Willemsenb3454ab2016-09-28 17:34:58 -07003010 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07003011 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003012 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07003013 }
Colin Crosscef792e2021-06-11 18:01:26 -07003014 case CrtBeginDepTag:
3015 depPaths.CrtBegin = append(depPaths.CrtBegin, android.OutputFileForModule(ctx, dep, ""))
3016 case CrtEndDepTag:
3017 depPaths.CrtEnd = append(depPaths.CrtEnd, android.OutputFileForModule(ctx, dep, ""))
Colin Crossca860ac2016-01-04 14:34:37 -08003018 }
Colin Crossc99deeb2016-04-11 15:06:20 -07003019 return
3020 }
3021
Colin Crossfe17f6f2019-03-28 19:30:56 -07003022 if depTag == android.ProtoPluginDepTag {
3023 return
3024 }
3025
Jiyong Park8bcf3c62024-03-18 18:37:10 +09003026 if depTag == android.RequiredDepTag {
3027 return
3028 }
3029
Colin Crossd11fcda2017-10-23 17:59:01 -07003030 if dep.Target().Os != ctx.Os() {
Steven Morelandaaae81f2024-08-27 22:55:48 +00003031 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 -07003032 return
3033 }
Colin Crossd11fcda2017-10-23 17:59:01 -07003034 if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
Jooyung Han61b66e92020-03-21 14:21:46 +00003035 ctx.ModuleErrorf("Arch mismatch between %q(%v) and %q(%v)",
3036 ctx.ModuleName(), ctx.Arch().ArchType, depName, dep.Target().Arch.ArchType)
Colin Crossa1ad8d12016-06-01 17:09:44 -07003037 return
3038 }
3039
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003040 if depTag == reuseObjTag {
Colin Crossa717db72020-10-23 14:53:06 -07003041 // Skip reused objects for stub libraries, they use their own stub object file instead.
3042 // The reuseObjTag dependency still exists because the LinkageMutator runs before the
3043 // version mutator, so the stubs variant is created from the shared variant that
3044 // already has the reuseObjTag dependency on the static variant.
Colin Cross31076b32020-10-23 17:22:06 -07003045 if !c.library.buildStubs() {
Colin Cross313aa542023-12-13 13:47:44 -08003046 staticAnalogue, _ := android.OtherModuleProvider(ctx, dep, StaticLibraryInfoProvider)
Colin Crossa717db72020-10-23 14:53:06 -07003047 objs := staticAnalogue.ReuseObjects
3048 depPaths.Objs = depPaths.Objs.Append(objs)
Colin Cross313aa542023-12-13 13:47:44 -08003049 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
Colin Crossa717db72020-10-23 14:53:06 -07003050 reexportExporter(depExporterInfo)
3051 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07003052 return
Jiyong Parke4bb9862019-02-01 00:31:10 +09003053 }
3054
Hsin-Yi Chen715142a2024-03-27 16:31:16 +08003055 if depTag == llndkHeaderLibTag {
3056 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
3057 depPaths.LlndkIncludeDirs = append(depPaths.LlndkIncludeDirs, depExporterInfo.IncludeDirs...)
3058 depPaths.LlndkSystemIncludeDirs = append(depPaths.LlndkSystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
3059 }
3060
Colin Cross6e511a92020-07-27 21:26:48 -07003061 linkFile := ccDep.OutputFile()
3062
3063 if libDepTag, ok := depTag.(libraryDependencyTag); ok {
3064 // Only use static unwinder for legacy (min_sdk_version = 29) apexes (b/144430859)
Dan Albertc8060532020-07-22 22:32:17 -07003065 if libDepTag.staticUnwinder && c.apexSdkVersion.GreaterThan(android.SdkVersion_Android10) {
Peter Collingbournedc4f9862020-02-12 17:13:25 -08003066 return
3067 }
Peter Collingbournedc4f9862020-02-12 17:13:25 -08003068
Jiyong Parke3867542020-12-03 17:28:25 +09003069 if !apexInfo.IsForPlatform() && libDepTag.excludeInApex {
3070 return
3071 }
Jooyung Han9ffbe832023-11-28 22:31:35 +09003072 if apexInfo.IsForPlatform() && libDepTag.excludeInNonApex {
3073 return
3074 }
Jiyong Parke3867542020-12-03 17:28:25 +09003075
Colin Cross313aa542023-12-13 13:47:44 -08003076 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
Colin Crossc99deeb2016-04-11 15:06:20 -07003077
Colin Cross6e511a92020-07-27 21:26:48 -07003078 var ptr *android.Paths
3079 var depPtr *android.Paths
Colin Crossc99deeb2016-04-11 15:06:20 -07003080
Colin Cross6e511a92020-07-27 21:26:48 -07003081 depFile := android.OptionalPath{}
Colin Cross26c34ed2016-09-30 17:10:16 -07003082
Colin Cross6e511a92020-07-27 21:26:48 -07003083 switch {
3084 case libDepTag.header():
Colin Cross313aa542023-12-13 13:47:44 -08003085 if _, isHeaderLib := android.OtherModuleProvider(ctx, dep, HeaderLibraryInfoProvider); !isHeaderLib {
Colin Cross649d8172020-12-10 12:30:21 -08003086 if !ctx.Config().AllowMissingDependencies() {
3087 ctx.ModuleErrorf("module %q is not a header library", depName)
3088 } else {
3089 ctx.AddMissingDependencies([]string{depName})
3090 }
3091 return
3092 }
Colin Cross6e511a92020-07-27 21:26:48 -07003093 case libDepTag.shared():
Colin Cross313aa542023-12-13 13:47:44 -08003094 if _, isSharedLib := android.OtherModuleProvider(ctx, dep, SharedLibraryInfoProvider); !isSharedLib {
Colin Cross0de8a1e2020-09-18 14:15:30 -07003095 if !ctx.Config().AllowMissingDependencies() {
3096 ctx.ModuleErrorf("module %q is not a shared library", depName)
3097 } else {
3098 ctx.AddMissingDependencies([]string{depName})
3099 }
3100 return
3101 }
Jiyong Parke3867542020-12-03 17:28:25 +09003102
Jiyong Park7d55b612021-06-11 17:22:09 +09003103 sharedLibraryInfo, returnedDepExporterInfo := ChooseStubOrImpl(ctx, dep)
3104 depExporterInfo = returnedDepExporterInfo
Colin Cross0de8a1e2020-09-18 14:15:30 -07003105
Jiyong Park1ad8e162020-12-01 23:40:09 +09003106 // Stubs lib doesn't link to the shared lib dependencies. Don't set
3107 // linkFile, depFile, and ptr.
3108 if c.IsStubs() {
3109 break
3110 }
3111
Colin Cross0de8a1e2020-09-18 14:15:30 -07003112 linkFile = android.OptionalPathForPath(sharedLibraryInfo.SharedLibrary)
3113 depFile = sharedLibraryInfo.TableOfContents
3114
Colin Crossb614cd42024-10-11 12:52:21 -07003115 if !sharedLibraryInfo.IsStubs {
3116 depPaths.directImplementationDeps = append(depPaths.directImplementationDeps, android.OutputFileForModule(ctx, dep, ""))
3117 if info, ok := android.OtherModuleProvider(ctx, dep, ImplementationDepInfoProvider); ok {
3118 depPaths.transitiveImplementationDeps = append(depPaths.transitiveImplementationDeps, info.ImplementationDeps)
3119 }
3120 }
3121
Colin Cross6e511a92020-07-27 21:26:48 -07003122 ptr = &depPaths.SharedLibs
3123 switch libDepTag.Order {
3124 case earlyLibraryDependency:
3125 ptr = &depPaths.EarlySharedLibs
3126 depPtr = &depPaths.EarlySharedLibsDeps
3127 case normalLibraryDependency:
3128 ptr = &depPaths.SharedLibs
3129 depPtr = &depPaths.SharedLibsDeps
Colin Cross0de8a1e2020-09-18 14:15:30 -07003130 directSharedDeps = append(directSharedDeps, sharedLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07003131 case lateLibraryDependency:
3132 ptr = &depPaths.LateSharedLibs
3133 depPtr = &depPaths.LateSharedLibsDeps
3134 default:
3135 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Colin Crossc99deeb2016-04-11 15:06:20 -07003136 }
Ivan Lozano0a468a42024-05-13 21:03:34 -04003137
Colin Cross6e511a92020-07-27 21:26:48 -07003138 case libDepTag.static():
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003139 if ccDep.RustLibraryInterface() {
3140 rlibDep := RustRlibDep{LibPath: linkFile.Path(), CrateName: ccDep.CrateName(), LinkDirs: ccDep.ExportedCrateLinkDirs()}
3141 depPaths.RustRlibDeps = append(depPaths.RustRlibDeps, rlibDep)
3142 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
3143 if libDepTag.wholeStatic {
3144 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, depExporterInfo.IncludeDirs...)
3145 depPaths.ReexportedRustRlibDeps = append(depPaths.ReexportedRustRlibDeps, rlibDep)
Jiyong Park1ad8e162020-12-01 23:40:09 +09003146
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003147 // If whole_static, track this as we want to make sure that in a final linkage for a shared library,
3148 // exported functions from the rust generated staticlib still exported.
3149 if c.CcLibrary() && c.Shared() {
3150 c.WholeRustStaticlib = true
3151 }
Colin Cross6e511a92020-07-27 21:26:48 -07003152 }
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003153
Colin Cross6e511a92020-07-27 21:26:48 -07003154 } else {
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003155 staticLibraryInfo, isStaticLib := android.OtherModuleProvider(ctx, dep, StaticLibraryInfoProvider)
3156 if !isStaticLib {
3157 if !ctx.Config().AllowMissingDependencies() {
3158 ctx.ModuleErrorf("module %q is not a static library", depName)
3159 } else {
3160 ctx.AddMissingDependencies([]string{depName})
3161 }
3162 return
Inseob Kimeec88e12020-01-22 11:11:29 +09003163 }
Ivan Lozano0a468a42024-05-13 21:03:34 -04003164
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003165 // Stubs lib doesn't link to the static lib dependencies. Don't set
3166 // linkFile, depFile, and ptr.
3167 if c.IsStubs() {
3168 break
3169 }
Ivan Lozano0a468a42024-05-13 21:03:34 -04003170
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003171 linkFile = android.OptionalPathForPath(staticLibraryInfo.StaticLibrary)
3172 if libDepTag.wholeStatic {
3173 ptr = &depPaths.WholeStaticLibs
3174 if len(staticLibraryInfo.Objects.objFiles) > 0 {
3175 depPaths.WholeStaticLibObjs = depPaths.WholeStaticLibObjs.Append(staticLibraryInfo.Objects)
3176 } else {
3177 // This case normally catches prebuilt static
3178 // libraries, but it can also occur when
3179 // AllowMissingDependencies is on and the
3180 // dependencies has no sources of its own
3181 // but has a whole_static_libs dependency
3182 // on a missing library. We want to depend
3183 // on the .a file so that there is something
3184 // in the dependency tree that contains the
3185 // error rule for the missing transitive
3186 // dependency.
3187 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts, linkFile.Path())
3188 }
3189 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts,
3190 staticLibraryInfo.WholeStaticLibsFromPrebuilts...)
3191 } else {
3192 switch libDepTag.Order {
3193 case earlyLibraryDependency:
3194 panic(fmt.Errorf("early static libs not supported"))
3195 case normalLibraryDependency:
3196 // static dependencies will be handled separately so they can be ordered
3197 // using transitive dependencies.
3198 ptr = nil
3199 directStaticDeps = append(directStaticDeps, staticLibraryInfo)
3200 case lateLibraryDependency:
3201 ptr = &depPaths.LateStaticLibs
3202 default:
3203 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
3204 }
3205 }
3206
3207 // Collect any exported Rust rlib deps from static libraries which have been included as whole_static_libs
3208 depPaths.RustRlibDeps = append(depPaths.RustRlibDeps, depExporterInfo.RustRlibDeps...)
3209
3210 if libDepTag.unexportedSymbols {
3211 depPaths.LdFlags = append(depPaths.LdFlags,
3212 "-Wl,--exclude-libs="+staticLibraryInfo.StaticLibrary.Base())
3213 }
Colin Cross3e5e7782022-06-17 22:17:05 +00003214 }
Inseob Kimeec88e12020-01-22 11:11:29 +09003215 }
3216
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003217 if libDepTag.static() && !libDepTag.wholeStatic && !ccDep.RustLibraryInterface() {
Colin Cross6e511a92020-07-27 21:26:48 -07003218 if !ccDep.CcLibraryInterface() || !ccDep.Static() {
3219 ctx.ModuleErrorf("module %q not a static library", depName)
3220 return
3221 }
Logan Chien43d34c32017-12-20 01:17:32 +08003222
Colin Cross6e511a92020-07-27 21:26:48 -07003223 // When combining coverage files for shared libraries and executables, coverage files
3224 // in static libraries act as if they were whole static libraries. The same goes for
3225 // source based Abi dump files.
3226 if c, ok := ccDep.(*Module); ok {
3227 staticLib := c.linker.(libraryInterface)
3228 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
3229 staticLib.objs().coverageFiles...)
3230 depPaths.StaticLibObjs.sAbiDumpFiles = append(depPaths.StaticLibObjs.sAbiDumpFiles,
3231 staticLib.objs().sAbiDumpFiles...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003232 } else {
Colin Cross6e511a92020-07-27 21:26:48 -07003233 // Handle non-CC modules here
3234 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
Colin Cross0de8a1e2020-09-18 14:15:30 -07003235 ccDep.CoverageFiles()...)
Jiyong Parkde866cb2018-12-07 23:08:36 +09003236 }
3237 }
3238
Colin Cross6e511a92020-07-27 21:26:48 -07003239 if ptr != nil {
3240 if !linkFile.Valid() {
3241 if !ctx.Config().AllowMissingDependencies() {
3242 ctx.ModuleErrorf("module %q missing output file", depName)
3243 } else {
3244 ctx.AddMissingDependencies([]string{depName})
3245 }
3246 return
3247 }
3248 *ptr = append(*ptr, linkFile.Path())
3249 }
3250
3251 if depPtr != nil {
3252 dep := depFile
3253 if !dep.Valid() {
3254 dep = linkFile
3255 }
3256 *depPtr = append(*depPtr, dep.Path())
3257 }
3258
Colin Cross0de8a1e2020-09-18 14:15:30 -07003259 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
3260 depPaths.SystemIncludeDirs = append(depPaths.SystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
3261 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps, depExporterInfo.Deps...)
3262 depPaths.Flags = append(depPaths.Flags, depExporterInfo.Flags...)
Ivan Lozano0a468a42024-05-13 21:03:34 -04003263 depPaths.RustRlibDeps = append(depPaths.RustRlibDeps, depExporterInfo.RustRlibDeps...)
3264
3265 // Only re-export RustRlibDeps for cc static libs
3266 if c.static() {
3267 depPaths.ReexportedRustRlibDeps = append(depPaths.ReexportedRustRlibDeps, depExporterInfo.RustRlibDeps...)
3268 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07003269
3270 if libDepTag.reexportFlags {
3271 reexportExporter(depExporterInfo)
3272 // Add these re-exported flags to help header-abi-dumper to infer the abi exported by a library.
3273 // Re-exported shared library headers must be included as well since they can help us with type information
3274 // about template instantiations (instantiated from their headers).
Colin Cross0de8a1e2020-09-18 14:15:30 -07003275 c.sabi.Properties.ReexportedIncludes = append(
3276 c.sabi.Properties.ReexportedIncludes, depExporterInfo.IncludeDirs.Strings()...)
Hsin-Yi Chen5f228b02024-04-02 12:38:47 +08003277 c.sabi.Properties.ReexportedSystemIncludes = append(
3278 c.sabi.Properties.ReexportedSystemIncludes, depExporterInfo.SystemIncludeDirs.Strings()...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003279 }
3280
Spandan Das3faa7922024-02-26 19:42:32 +00003281 makeLibName := MakeLibName(ctx, c, ccDep, ccDep.BaseModuleName()) + libDepTag.makeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003282 switch {
3283 case libDepTag.header():
Colin Cross370173e2020-07-29 12:48:33 -07003284 c.Properties.AndroidMkHeaderLibs = append(
3285 c.Properties.AndroidMkHeaderLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07003286 case libDepTag.shared():
Colin Cross6e511a92020-07-27 21:26:48 -07003287 // Note: the order of libs in this list is not important because
3288 // they merely serve as Make dependencies and do not affect this lib itself.
Colin Cross370173e2020-07-29 12:48:33 -07003289 c.Properties.AndroidMkSharedLibs = append(
3290 c.Properties.AndroidMkSharedLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07003291 case libDepTag.static():
Ivan Lozanofd47b1a2024-05-17 14:13:41 -04003292 if !ccDep.RustLibraryInterface() {
3293 if libDepTag.wholeStatic {
3294 c.Properties.AndroidMkWholeStaticLibs = append(
3295 c.Properties.AndroidMkWholeStaticLibs, makeLibName)
3296 } else {
3297 c.Properties.AndroidMkStaticLibs = append(
3298 c.Properties.AndroidMkStaticLibs, makeLibName)
3299 }
Colin Cross6e511a92020-07-27 21:26:48 -07003300 }
3301 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09003302 } else if !c.IsStubs() {
3303 // Stubs lib doesn't link to the runtime lib, object, crt, etc. dependencies.
3304
Colin Cross6e511a92020-07-27 21:26:48 -07003305 switch depTag {
3306 case runtimeDepTag:
3307 c.Properties.AndroidMkRuntimeLibs = append(
Spandan Das3faa7922024-02-26 19:42:32 +00003308 c.Properties.AndroidMkRuntimeLibs, MakeLibName(ctx, c, ccDep, ccDep.BaseModuleName())+libDepTag.makeSuffix)
Colin Cross6e511a92020-07-27 21:26:48 -07003309 case objDepTag:
3310 depPaths.Objs.objFiles = append(depPaths.Objs.objFiles, linkFile.Path())
3311 case CrtBeginDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003312 depPaths.CrtBegin = append(depPaths.CrtBegin, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003313 case CrtEndDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003314 depPaths.CrtEnd = append(depPaths.CrtEnd, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003315 case dynamicLinkerDepTag:
3316 depPaths.DynamicLinker = linkFile
3317 }
Jiyong Park27b188b2017-07-18 13:23:39 +09003318 }
Colin Crossca860ac2016-01-04 14:34:37 -08003319 })
3320
Jeff Gaston294356f2017-09-27 17:05:30 -07003321 // use the ordered dependencies as this module's dependencies
Colin Cross0de8a1e2020-09-18 14:15:30 -07003322 orderedStaticPaths, transitiveStaticLibs := orderStaticModuleDeps(directStaticDeps, directSharedDeps)
3323 depPaths.TranstiveStaticLibrariesForOrdering = transitiveStaticLibs
3324 depPaths.StaticLibs = append(depPaths.StaticLibs, orderedStaticPaths...)
Jeff Gaston294356f2017-09-27 17:05:30 -07003325
Colin Crossdd84e052017-05-17 13:44:16 -07003326 // Dedup exported flags from dependencies
Colin Crossb6715442017-10-24 11:13:31 -07003327 depPaths.Flags = android.FirstUniqueStrings(depPaths.Flags)
Jiyong Park74955042019-10-22 20:19:51 +09003328 depPaths.IncludeDirs = android.FirstUniquePaths(depPaths.IncludeDirs)
3329 depPaths.SystemIncludeDirs = android.FirstUniquePaths(depPaths.SystemIncludeDirs)
Inseob Kimd110f872019-12-06 13:15:38 +09003330 depPaths.GeneratedDeps = android.FirstUniquePaths(depPaths.GeneratedDeps)
Ivan Lozano0a468a42024-05-13 21:03:34 -04003331 depPaths.RustRlibDeps = android.FirstUniqueFunc(depPaths.RustRlibDeps, EqRustRlibDeps)
3332
Jiyong Park74955042019-10-22 20:19:51 +09003333 depPaths.ReexportedDirs = android.FirstUniquePaths(depPaths.ReexportedDirs)
3334 depPaths.ReexportedSystemDirs = android.FirstUniquePaths(depPaths.ReexportedSystemDirs)
Colin Crossb6715442017-10-24 11:13:31 -07003335 depPaths.ReexportedFlags = android.FirstUniqueStrings(depPaths.ReexportedFlags)
Inseob Kim69378442019-06-03 19:10:47 +09003336 depPaths.ReexportedDeps = android.FirstUniquePaths(depPaths.ReexportedDeps)
Inseob Kimd110f872019-12-06 13:15:38 +09003337 depPaths.ReexportedGeneratedHeaders = android.FirstUniquePaths(depPaths.ReexportedGeneratedHeaders)
Ivan Lozano0a468a42024-05-13 21:03:34 -04003338 depPaths.ReexportedRustRlibDeps = android.FirstUniqueFunc(depPaths.ReexportedRustRlibDeps, EqRustRlibDeps)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003339
3340 if c.sabi != nil {
Inseob Kim69378442019-06-03 19:10:47 +09003341 c.sabi.Properties.ReexportedIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedIncludes)
Hsin-Yi Chen5f228b02024-04-02 12:38:47 +08003342 c.sabi.Properties.ReexportedSystemIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedSystemIncludes)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003343 }
Colin Crossdd84e052017-05-17 13:44:16 -07003344
Colin Crossca860ac2016-01-04 14:34:37 -08003345 return depPaths
3346}
3347
Spandan Das604f3762023-03-16 22:51:40 +00003348func ShouldUseStubForApex(ctx android.ModuleContext, dep android.Module) bool {
Kiyoung Kimaa394802024-01-08 12:55:45 +09003349 inVendorOrProduct := false
Jiyong Park7d55b612021-06-11 17:22:09 +09003350 bootstrap := false
3351 if linkable, ok := ctx.Module().(LinkableInterface); !ok {
3352 panic(fmt.Errorf("Not a Linkable module: %q", ctx.ModuleName()))
3353 } else {
Kiyoung Kimaa394802024-01-08 12:55:45 +09003354 inVendorOrProduct = linkable.InVendorOrProduct()
Jiyong Park7d55b612021-06-11 17:22:09 +09003355 bootstrap = linkable.Bootstrap()
3356 }
3357
Colin Crossff694a82023-12-13 15:54:49 -08003358 apexInfo, _ := android.ModuleProvider(ctx, android.ApexInfoProvider)
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003359
3360 useStubs := false
3361
Kiyoung Kimaa394802024-01-08 12:55:45 +09003362 if lib := moduleLibraryInterface(dep); lib.buildStubs() && inVendorOrProduct { // LLNDK
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003363 if !apexInfo.IsForPlatform() {
3364 // For platform libraries, use current version of LLNDK
3365 // If this is for use_vendor apex we will apply the same rules
3366 // of apex sdk enforcement below to choose right version.
3367 useStubs = true
3368 }
3369 } else if apexInfo.IsForPlatform() || apexInfo.UsePlatformApis {
3370 // If not building for APEX or the containing APEX allows the use of
3371 // platform APIs, use stubs only when it is from an APEX (and not from
3372 // platform) However, for host, ramdisk, vendor_ramdisk, recovery or
3373 // bootstrap modules, always link to non-stub variant
3374 isNotInPlatform := dep.(android.ApexModule).NotInPlatform()
3375
Spandan Dasff665182024-09-11 18:48:44 +00003376 useStubs = isNotInPlatform && !bootstrap
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003377 } else {
Colin Crossea91a172024-11-05 16:14:05 -08003378 // If building for APEX, always use stubs (can be bypassed by depending on <dep>#impl)
3379 useStubs = true
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003380 }
3381
3382 return useStubs
3383}
3384
3385// ChooseStubOrImpl determines whether a given dependency should be redirected to the stub variant
3386// of the dependency or not, and returns the SharedLibraryInfo and FlagExporterInfo for the right
3387// dependency. The stub variant is selected when the dependency crosses a boundary where each side
3388// has different level of updatability. For example, if a library foo in an APEX depends on a
3389// library bar which provides stable interface and exists in the platform, foo uses the stub variant
3390// of bar. If bar doesn't provide a stable interface (i.e. buildStubs() == false) or is in the
3391// same APEX as foo, the non-stub variant of bar is used.
3392func ChooseStubOrImpl(ctx android.ModuleContext, dep android.Module) (SharedLibraryInfo, FlagExporterInfo) {
3393 depTag := ctx.OtherModuleDependencyTag(dep)
3394 libDepTag, ok := depTag.(libraryDependencyTag)
3395 if !ok || !libDepTag.shared() {
3396 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
3397 }
3398
Colin Cross313aa542023-12-13 13:47:44 -08003399 sharedLibraryInfo, _ := android.OtherModuleProvider(ctx, dep, SharedLibraryInfoProvider)
3400 depExporterInfo, _ := android.OtherModuleProvider(ctx, dep, FlagExporterInfoProvider)
3401 sharedLibraryStubsInfo, _ := android.OtherModuleProvider(ctx, dep, SharedLibraryStubsProvider)
Jiyong Park7d55b612021-06-11 17:22:09 +09003402
3403 if !libDepTag.explicitlyVersioned && len(sharedLibraryStubsInfo.SharedStubLibraries) > 0 {
Jiyong Park7d55b612021-06-11 17:22:09 +09003404 // when to use (unspecified) stubs, use the latest one.
Spandan Das604f3762023-03-16 22:51:40 +00003405 if ShouldUseStubForApex(ctx, dep) {
Jiyong Park7d55b612021-06-11 17:22:09 +09003406 stubs := sharedLibraryStubsInfo.SharedStubLibraries
3407 toUse := stubs[len(stubs)-1]
3408 sharedLibraryInfo = toUse.SharedLibraryInfo
3409 depExporterInfo = toUse.FlagExporterInfo
3410 }
3411 }
3412 return sharedLibraryInfo, depExporterInfo
3413}
3414
Colin Cross0de8a1e2020-09-18 14:15:30 -07003415// orderStaticModuleDeps rearranges the order of the static library dependencies of the module
3416// to match the topological order of the dependency tree, including any static analogues of
Colin Crossa14fb6a2024-10-23 16:57:06 -07003417// direct shared libraries. It returns the ordered static dependencies, and a depset.DepSet
Colin Cross0de8a1e2020-09-18 14:15:30 -07003418// of the transitive dependencies.
Colin Crossa14fb6a2024-10-23 16:57:06 -07003419func orderStaticModuleDeps(staticDeps []StaticLibraryInfo, sharedDeps []SharedLibraryInfo) (ordered android.Paths, transitive depset.DepSet[android.Path]) {
3420 transitiveStaticLibsBuilder := depset.NewBuilder[android.Path](depset.TOPOLOGICAL)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003421 var staticPaths android.Paths
3422 for _, staticDep := range staticDeps {
3423 staticPaths = append(staticPaths, staticDep.StaticLibrary)
3424 transitiveStaticLibsBuilder.Transitive(staticDep.TransitiveStaticLibrariesForOrdering)
3425 }
3426 for _, sharedDep := range sharedDeps {
Colin Crossa14fb6a2024-10-23 16:57:06 -07003427 transitiveStaticLibsBuilder.Transitive(sharedDep.TransitiveStaticLibrariesForOrdering)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003428 }
3429 transitiveStaticLibs := transitiveStaticLibsBuilder.Build()
3430
3431 orderedTransitiveStaticLibs := transitiveStaticLibs.ToList()
3432
3433 // reorder the dependencies based on transitive dependencies
3434 staticPaths = android.FirstUniquePaths(staticPaths)
3435 _, orderedStaticPaths := android.FilterPathList(orderedTransitiveStaticLibs, staticPaths)
3436
3437 if len(orderedStaticPaths) != len(staticPaths) {
3438 missing, _ := android.FilterPathList(staticPaths, orderedStaticPaths)
3439 panic(fmt.Errorf("expected %d ordered static paths , got %d, missing %q %q %q", len(staticPaths), len(orderedStaticPaths), missing, orderedStaticPaths, staticPaths))
3440 }
3441
3442 return orderedStaticPaths, transitiveStaticLibs
3443}
3444
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003445// BaseLibName trims known prefixes and suffixes
3446func BaseLibName(depName string) string {
Colin Cross6e511a92020-07-27 21:26:48 -07003447 libName := strings.TrimSuffix(depName, llndkLibrarySuffix)
3448 libName = strings.TrimSuffix(libName, vendorPublicLibrarySuffix)
Paul Duffind23c7262020-12-11 18:13:08 +00003449 libName = android.RemoveOptionalPrebuiltPrefix(libName)
Colin Cross6e511a92020-07-27 21:26:48 -07003450 return libName
3451}
3452
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003453func MakeLibName(ctx android.ModuleContext, c LinkableInterface, ccDep LinkableInterface, depName string) string {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003454 libName := BaseLibName(depName)
Colin Cross127bb8b2020-12-16 16:46:01 -08003455 ccDepModule, _ := ccDep.(*Module)
3456 isLLndk := ccDepModule != nil && ccDepModule.IsLlndk()
Justin Yuncbca3732021-02-03 19:24:13 +09003457 nonSystemVariantsExist := ccDep.HasNonSystemVariants() || isLLndk
Colin Cross6e511a92020-07-27 21:26:48 -07003458
Justin Yuncbca3732021-02-03 19:24:13 +09003459 if ccDepModule != nil {
Colin Cross6e511a92020-07-27 21:26:48 -07003460 // Use base module name for snapshots when exporting to Makefile.
Ivan Lozanod1dec542021-05-26 15:33:11 -04003461 if snapshotPrebuilt, ok := ccDepModule.linker.(SnapshotInterface); ok {
Justin Yuncbca3732021-02-03 19:24:13 +09003462 baseName := ccDepModule.BaseModuleName()
Colin Cross6e511a92020-07-27 21:26:48 -07003463
Ivan Lozanod1dec542021-05-26 15:33:11 -04003464 return baseName + snapshotPrebuilt.SnapshotAndroidMkSuffix()
Colin Cross6e511a92020-07-27 21:26:48 -07003465 }
3466 }
3467
Kiyoung Kim22152f62024-05-24 10:45:28 +09003468 if ccDep.InVendorOrProduct() && nonSystemVariantsExist {
Justin Yuncbca3732021-02-03 19:24:13 +09003469 // The vendor and product modules in Make will have been renamed to not conflict with the
3470 // core module, so update the dependency name here accordingly.
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003471 return libName + ccDep.SubName()
Colin Cross6e511a92020-07-27 21:26:48 -07003472 } else if ccDep.InRamdisk() && !ccDep.OnlyInRamdisk() {
Matthew Maurerc6868382021-07-13 14:12:37 -07003473 return libName + RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003474 } else if ccDep.InVendorRamdisk() && !ccDep.OnlyInVendorRamdisk() {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05003475 return libName + VendorRamdiskSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003476 } else if ccDep.InRecovery() && !ccDep.OnlyInRecovery() {
Matthew Maurer460ee942021-02-11 12:31:46 -08003477 return libName + RecoverySuffix
Ivan Lozanof9e21722020-12-02 09:00:51 -05003478 } else if ccDep.Target().NativeBridge == android.NativeBridgeEnabled {
Matthew Maurera61e31f2021-05-27 11:09:11 -07003479 return libName + NativeBridgeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003480 } else {
3481 return libName
3482 }
3483}
3484
Colin Crossca860ac2016-01-04 14:34:37 -08003485func (c *Module) InstallInData() bool {
3486 if c.installer == nil {
3487 return false
3488 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003489 return c.installer.inData()
3490}
3491
3492func (c *Module) InstallInSanitizerDir() bool {
3493 if c.installer == nil {
3494 return false
3495 }
3496 if c.sanitize != nil && c.sanitize.inSanitizerDir() {
Colin Cross94610402016-08-29 13:41:32 -07003497 return true
3498 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003499 return c.installer.inSanitizerDir()
Colin Crossca860ac2016-01-04 14:34:37 -08003500}
3501
Yifan Hong1b3348d2020-01-21 15:53:22 -08003502func (c *Module) InstallInRamdisk() bool {
3503 return c.InRamdisk()
3504}
3505
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003506func (c *Module) InstallInVendorRamdisk() bool {
3507 return c.InVendorRamdisk()
3508}
3509
Jiyong Parkf9332f12018-02-01 00:54:12 +09003510func (c *Module) InstallInRecovery() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07003511 return c.InRecovery()
Jiyong Parkf9332f12018-02-01 00:54:12 +09003512}
3513
Jingwen Chen8ac7d7d2023-03-20 11:05:16 +00003514func (c *Module) MakeUninstallable() {
3515 if c.installer == nil {
3516 c.ModuleBase.MakeUninstallable()
3517 return
3518 }
3519 c.installer.makeUninstallable(c)
3520}
3521
Dan Willemsen4aa75ca2016-09-28 16:18:03 -07003522func (c *Module) HostToolPath() android.OptionalPath {
3523 if c.installer == nil {
3524 return android.OptionalPath{}
3525 }
3526 return c.installer.hostToolPath()
3527}
3528
Nan Zhangd4e641b2017-07-12 12:55:28 -07003529func (c *Module) IntermPathForModuleOut() android.OptionalPath {
3530 return c.outputFile
3531}
3532
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00003533func (c *Module) static() bool {
3534 if static, ok := c.linker.(interface {
3535 static() bool
3536 }); ok {
3537 return static.static()
3538 }
3539 return false
3540}
3541
Jiyong Park379de2f2018-12-19 02:47:14 +09003542func (c *Module) staticBinary() bool {
3543 if static, ok := c.linker.(interface {
3544 staticBinary() bool
3545 }); ok {
3546 return static.staticBinary()
3547 }
3548 return false
3549}
3550
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07003551func (c *Module) testBinary() bool {
3552 if test, ok := c.linker.(interface {
3553 testBinary() bool
3554 }); ok {
3555 return test.testBinary()
3556 }
3557 return false
3558}
3559
Jingwen Chen537242c2022-08-24 11:53:27 +00003560func (c *Module) testLibrary() bool {
3561 if test, ok := c.linker.(interface {
3562 testLibrary() bool
3563 }); ok {
3564 return test.testLibrary()
3565 }
3566 return false
3567}
3568
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003569func (c *Module) benchmarkBinary() bool {
3570 if b, ok := c.linker.(interface {
3571 benchmarkBinary() bool
3572 }); ok {
3573 return b.benchmarkBinary()
3574 }
3575 return false
3576}
3577
3578func (c *Module) fuzzBinary() bool {
3579 if f, ok := c.linker.(interface {
3580 fuzzBinary() bool
3581 }); ok {
3582 return f.fuzzBinary()
3583 }
3584 return false
3585}
3586
Ivan Lozano3968d8f2020-12-14 11:27:52 -05003587// Header returns true if the module is a header-only variant. (See cc/library.go header()).
3588func (c *Module) Header() bool {
Jiyong Park1d1119f2019-07-29 21:27:18 +09003589 if h, ok := c.linker.(interface {
3590 header() bool
3591 }); ok {
3592 return h.header()
3593 }
3594 return false
3595}
3596
Ivan Lozanod7586b62021-04-01 09:49:36 -04003597func (c *Module) Binary() bool {
Inseob Kim7f283f42020-06-01 21:53:49 +09003598 if b, ok := c.linker.(interface {
3599 binary() bool
3600 }); ok {
3601 return b.binary()
3602 }
3603 return false
3604}
3605
Justin Yun5e035862021-06-29 20:50:37 +09003606func (c *Module) StaticExecutable() bool {
3607 if b, ok := c.linker.(*binaryDecorator); ok {
3608 return b.static()
3609 }
3610 return false
3611}
3612
Ivan Lozanod7586b62021-04-01 09:49:36 -04003613func (c *Module) Object() bool {
Inseob Kim1042d292020-06-01 23:23:05 +09003614 if o, ok := c.linker.(interface {
3615 object() bool
3616 }); ok {
3617 return o.object()
3618 }
3619 return false
3620}
3621
Kiyoung Kim37693d02024-04-04 09:56:15 +09003622func (m *Module) Dylib() bool {
3623 return false
3624}
3625
3626func (m *Module) Rlib() bool {
3627 return false
3628}
3629
Ivan Lozanof9e21722020-12-02 09:00:51 -05003630func GetMakeLinkType(actx android.ModuleContext, c LinkableInterface) string {
Kiyoung Kim8487c0b2024-01-11 16:03:13 +09003631 if c.InVendorOrProduct() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003632 if c.IsLlndk() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003633 return "native:vndk"
Jooyung Han38002912019-05-16 04:01:54 +09003634 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003635 if c.InProduct() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09003636 return "native:product"
3637 }
Jooyung Han38002912019-05-16 04:01:54 +09003638 return "native:vendor"
Yifan Hong1b3348d2020-01-21 15:53:22 -08003639 } else if c.InRamdisk() {
3640 return "native:ramdisk"
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003641 } else if c.InVendorRamdisk() {
3642 return "native:vendor_ramdisk"
Ivan Lozano52767be2019-10-18 14:49:46 -07003643 } else if c.InRecovery() {
Colin Crossb60190a2018-09-04 16:28:17 -07003644 return "native:recovery"
Ivan Lozanof9e21722020-12-02 09:00:51 -05003645 } else if c.Target().Os == android.Android && c.SdkVersion() != "" {
Colin Crossb60190a2018-09-04 16:28:17 -07003646 return "native:ndk:none:none"
3647 // TODO(b/114741097): use the correct ndk stl once build errors have been fixed
3648 //family, link := getNdkStlFamilyAndLinkType(c)
3649 //return fmt.Sprintf("native:ndk:%s:%s", family, link)
3650 } else {
3651 return "native:platform"
3652 }
3653}
3654
Jiyong Park9d452992018-10-03 00:38:19 +09003655// Overrides ApexModule.IsInstallabeToApex()
Colin Cross3a02c7b2024-05-21 13:46:22 -07003656// Only shared/runtime libraries .
Jiyong Park9d452992018-10-03 00:38:19 +09003657func (c *Module) IsInstallableToApex() bool {
Colin Cross31076b32020-10-23 17:22:06 -07003658 if lib := c.library; lib != nil {
Jiyong Park73c54ee2019-10-22 20:31:18 +09003659 // Stub libs and prebuilt libs in a versioned SDK are not
3660 // installable to APEX even though they are shared libs.
Paul Duffin458a15b2022-11-25 12:18:24 +00003661 return lib.shared() && !lib.buildStubs()
Jiyong Park9d452992018-10-03 00:38:19 +09003662 }
3663 return false
3664}
3665
Jiyong Parka90ca002019-10-07 15:47:24 +09003666func (c *Module) AvailableFor(what string) bool {
3667 if linker, ok := c.linker.(interface {
3668 availableFor(string) bool
3669 }); ok {
3670 return c.ApexModuleBase.AvailableFor(what) || linker.availableFor(what)
3671 } else {
3672 return c.ApexModuleBase.AvailableFor(what)
3673 }
3674}
3675
Paul Duffin0cb37b92020-03-04 14:52:46 +00003676func (c *Module) EverInstallable() bool {
3677 return c.installer != nil &&
3678 // Check to see whether the module is actually ever installable.
3679 c.installer.everInstallable()
3680}
3681
Ivan Lozanod7586b62021-04-01 09:49:36 -04003682func (c *Module) PreventInstall() bool {
3683 return c.Properties.PreventInstall
3684}
3685
3686func (c *Module) Installable() *bool {
Colin Cross1bc94122021-10-28 13:25:54 -07003687 if c.library != nil {
3688 if i := c.library.installable(); i != nil {
3689 return i
3690 }
3691 }
Ivan Lozanod7586b62021-04-01 09:49:36 -04003692 return c.Properties.Installable
3693}
3694
3695func installable(c LinkableInterface, apexInfo android.ApexInfo) bool {
Paul Duffin0cb37b92020-03-04 14:52:46 +00003696 ret := c.EverInstallable() &&
3697 // Check to see whether the module has been configured to not be installed.
Ivan Lozanod7586b62021-04-01 09:49:36 -04003698 proptools.BoolDefault(c.Installable(), true) &&
3699 !c.PreventInstall() && c.OutputFile().Valid()
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003700
3701 // The platform variant doesn't need further condition. Apex variants however might not
3702 // be installable because it will likely to be included in the APEX and won't appear
3703 // in the system partition.
Colin Cross56a83212020-09-15 18:30:11 -07003704 if apexInfo.IsForPlatform() {
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003705 return ret
3706 }
3707
3708 // Special case for modules that are configured to be installed to /data, which includes
3709 // test modules. For these modules, both APEX and non-APEX variants are considered as
3710 // installable. This is because even the APEX variants won't be included in the APEX, but
3711 // will anyway be installed to /data/*.
3712 // See b/146995717
3713 if c.InstallInData() {
3714 return ret
3715 }
3716
3717 return false
Inseob Kim1f086e22019-05-09 13:29:15 +09003718}
3719
Logan Chien41eabe62019-04-10 13:33:58 +08003720func (c *Module) AndroidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer) {
3721 if c.linker != nil {
3722 if library, ok := c.linker.(*libraryDecorator); ok {
3723 library.androidMkWriteAdditionalDependenciesForSourceAbiDiff(w)
3724 }
3725 }
3726}
3727
Jiyong Park45bf82e2020-12-15 22:29:02 +09003728var _ android.ApexModule = (*Module)(nil)
3729
3730// Implements android.ApexModule
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003731func (c *Module) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
Colin Cross6e511a92020-07-27 21:26:48 -07003732 depTag := ctx.OtherModuleDependencyTag(dep)
3733 libDepTag, isLibDepTag := depTag.(libraryDependencyTag)
3734
3735 if cc, ok := dep.(*Module); ok {
3736 if cc.HasStubsVariants() {
3737 if isLibDepTag && libDepTag.shared() {
3738 // dynamic dep to a stubs lib crosses APEX boundary
3739 return false
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003740 }
Colin Cross6e511a92020-07-27 21:26:48 -07003741 if IsRuntimeDepTag(depTag) {
3742 // runtime dep to a stubs lib also crosses APEX boundary
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003743 return false
3744 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003745 }
Zhijun Heec285872021-04-24 10:47:08 -07003746 if cc.IsLlndk() {
3747 return false
3748 }
Colin Crossaac32222020-07-29 12:51:56 -07003749 if isLibDepTag && c.static() && libDepTag.shared() {
Colin Cross6e511a92020-07-27 21:26:48 -07003750 // shared_lib dependency from a static lib is considered as crossing
3751 // the APEX boundary because the dependency doesn't actually is
3752 // linked; the dependency is used only during the compilation phase.
3753 return false
3754 }
Jiyong Parke3867542020-12-03 17:28:25 +09003755
3756 if isLibDepTag && libDepTag.excludeInApex {
3757 return false
3758 }
Colin Cross6e511a92020-07-27 21:26:48 -07003759 }
Colin Crossc1b36442021-05-06 13:42:48 -07003760 if depTag == stubImplDepTag {
3761 // We don't track from an implementation library to its stubs.
Jiyong Park7d95a512020-05-10 15:16:24 +09003762 return false
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003763 }
Jiyong Park12177fc2021-01-05 14:37:15 +09003764 if depTag == staticVariantTag {
3765 // This dependency is for optimization (reuse *.o from the static lib). It doesn't
3766 // actually mean that the static lib (and its dependencies) are copied into the
3767 // APEX.
3768 return false
3769 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003770 return true
3771}
3772
Jiyong Park45bf82e2020-12-15 22:29:02 +09003773// Implements android.ApexModule
Dan Albertc8060532020-07-22 22:32:17 -07003774func (c *Module) ShouldSupportSdkVersion(ctx android.BaseModuleContext,
3775 sdkVersion android.ApiLevel) error {
Jooyung Han749dc692020-04-15 11:03:39 +09003776 // We ignore libclang_rt.* prebuilt libs since they declare sdk_version: 14(b/121358700)
3777 if strings.HasPrefix(ctx.OtherModuleName(c), "libclang_rt") {
3778 return nil
3779 }
Jooyung Han749dc692020-04-15 11:03:39 +09003780 // We don't check for prebuilt modules
3781 if _, ok := c.linker.(prebuiltLinkerInterface); ok {
3782 return nil
3783 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09003784
Jooyung Han749dc692020-04-15 11:03:39 +09003785 minSdkVersion := c.MinSdkVersion()
3786 if minSdkVersion == "apex_inherit" {
3787 return nil
3788 }
3789 if minSdkVersion == "" {
3790 // JNI libs within APK-in-APEX fall into here
3791 // Those are okay to set sdk_version instead
3792 // We don't have to check if this is a SDK variant because
3793 // non-SDK variant resets sdk_version, which works too.
3794 minSdkVersion = c.SdkVersion()
3795 }
Dan Albertc8060532020-07-22 22:32:17 -07003796 if minSdkVersion == "" {
3797 return fmt.Errorf("neither min_sdk_version nor sdk_version specificed")
3798 }
3799 // Not using nativeApiLevelFromUser because the context here is not
3800 // necessarily a native context.
3801 ver, err := android.ApiLevelFromUser(ctx, minSdkVersion)
Jooyung Han749dc692020-04-15 11:03:39 +09003802 if err != nil {
3803 return err
3804 }
Dan Albertc8060532020-07-22 22:32:17 -07003805
Colin Cross8ca61c12022-10-06 21:00:14 -07003806 // A dependency only needs to support a min_sdk_version at least
3807 // as high as the api level that the architecture was introduced in.
3808 // This allows introducing new architectures in the platform that
3809 // need to be included in apexes that normally require an older
3810 // min_sdk_version.
Colin Crossbb137a32023-01-26 09:54:42 -08003811 minApiForArch := MinApiForArch(ctx, c.Target().Arch.ArchType)
Colin Cross8ca61c12022-10-06 21:00:14 -07003812 if sdkVersion.LessThan(minApiForArch) {
3813 sdkVersion = minApiForArch
3814 }
3815
Dan Albertc8060532020-07-22 22:32:17 -07003816 if ver.GreaterThan(sdkVersion) {
Jooyung Han749dc692020-04-15 11:03:39 +09003817 return fmt.Errorf("newer SDK(%v)", ver)
3818 }
3819 return nil
3820}
3821
Paul Duffinb5769c12021-05-12 16:16:51 +01003822// Implements android.ApexModule
3823func (c *Module) AlwaysRequiresPlatformApexVariant() bool {
3824 // stub libraries and native bridge libraries are always available to platform
3825 return c.IsStubs() || c.Target().NativeBridge == android.NativeBridgeEnabled
3826}
3827
Inseob Kima1888ce2022-10-04 14:42:02 +09003828func (c *Module) overriddenModules() []string {
3829 if o, ok := c.linker.(overridable); ok {
3830 return o.overriddenModules()
3831 }
3832 return nil
3833}
3834
Liz Kammer35ca77e2021-12-22 15:31:40 -05003835type moduleType int
3836
3837const (
3838 unknownType moduleType = iota
3839 binary
3840 object
3841 fullLibrary
3842 staticLibrary
3843 sharedLibrary
3844 headerLibrary
Jingwen Chen537242c2022-08-24 11:53:27 +00003845 testBin // testBinary already declared
Spandan Das1278c2c2022-08-19 18:17:28 +00003846 ndkLibrary
Liz Kammer35ca77e2021-12-22 15:31:40 -05003847)
3848
3849func (c *Module) typ() moduleType {
Jingwen Chen537242c2022-08-24 11:53:27 +00003850 if c.testBinary() {
3851 // testBinary is also a binary, so this comes before the c.Binary()
3852 // conditional. A testBinary has additional implicit dependencies and
3853 // other test-only semantics.
3854 return testBin
3855 } else if c.Binary() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003856 return binary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003857 } else if c.Object() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003858 return object
Jingwen Chen537242c2022-08-24 11:53:27 +00003859 } else if c.testLibrary() {
3860 // TODO(b/244431896) properly convert cc_test_library to its own macro. This
3861 // will let them add implicit compile deps on gtest, for example.
3862 //
Liz Kammerefc51d92023-04-21 15:11:25 -04003863 // For now, treat them as regular libraries.
3864 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003865 } else if c.CcLibrary() {
Chris Parsons58852a02021-12-09 18:10:18 -05003866 static := false
3867 shared := false
3868 if library, ok := c.linker.(*libraryDecorator); ok {
3869 static = library.MutatedProperties.BuildStatic
3870 shared = library.MutatedProperties.BuildShared
3871 } else if library, ok := c.linker.(*prebuiltLibraryLinker); ok {
3872 static = library.MutatedProperties.BuildStatic
3873 shared = library.MutatedProperties.BuildShared
3874 }
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003875 if static && shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003876 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003877 } else if !static && !shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003878 return headerLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003879 } else if static {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003880 return staticLibrary
3881 }
3882 return sharedLibrary
Spandan Das1278c2c2022-08-19 18:17:28 +00003883 } else if c.isNDKStubLibrary() {
3884 return ndkLibrary
Liz Kammer35ca77e2021-12-22 15:31:40 -05003885 }
3886 return unknownType
3887}
3888
Colin Crosscfad1192015-11-02 16:43:11 -08003889// Defaults
Colin Crossca860ac2016-01-04 14:34:37 -08003890type Defaults struct {
Colin Cross635c3b02016-05-18 15:37:25 -07003891 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -07003892 android.DefaultsModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +09003893 android.ApexModuleBase
Colin Crosscfad1192015-11-02 16:43:11 -08003894}
3895
Patrice Arrudac249c712019-03-19 17:00:29 -07003896// cc_defaults provides a set of properties that can be inherited by other cc
3897// modules. A module can use the properties from a cc_defaults using
3898// `defaults: ["<:default_module_name>"]`. Properties of both modules are
3899// merged (when possible) by prepending the default module's values to the
3900// depending module's values.
Colin Cross36242852017-06-23 15:06:31 -07003901func defaultsFactory() android.Module {
Colin Crosse1d764e2016-08-18 14:18:32 -07003902 return DefaultsFactory()
3903}
3904
Colin Cross36242852017-06-23 15:06:31 -07003905func DefaultsFactory(props ...interface{}) android.Module {
Colin Crossca860ac2016-01-04 14:34:37 -08003906 module := &Defaults{}
Colin Crosscfad1192015-11-02 16:43:11 -08003907
Colin Cross36242852017-06-23 15:06:31 -07003908 module.AddProperties(props...)
3909 module.AddProperties(
Colin Crossca860ac2016-01-04 14:34:37 -08003910 &BaseProperties{},
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003911 &VendorProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003912 &BaseCompilerProperties{},
3913 &BaseLinkerProperties{},
Paul Duffina37832a2019-07-18 12:31:26 +01003914 &ObjectLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003915 &LibraryProperties{},
Colin Crosse1bb5d02019-09-24 14:55:04 -07003916 &StaticProperties{},
3917 &SharedProperties{},
Colin Cross919281a2016-04-05 16:42:05 -07003918 &FlagExporterProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003919 &BinaryLinkerProperties{},
Trevor Radcliffef389cb42022-03-24 21:06:14 +00003920 &TestLinkerProperties{},
3921 &TestInstallerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003922 &TestBinaryProperties{},
Colin Cross43287652020-06-30 10:15:07 -07003923 &BenchmarkProperties{},
hamzehc0a671f2021-07-22 12:05:08 -07003924 &fuzz.FuzzProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003925 &StlProperties{},
Colin Cross16b23492016-01-06 14:41:07 -08003926 &SanitizeProperties{},
Colin Cross665dce92016-04-28 14:50:03 -07003927 &StripProperties{},
Dan Willemsen7424d612016-09-01 13:45:39 -07003928 &InstallerProperties{},
Dan Willemsena03cf6d2016-09-26 15:45:04 -07003929 &TidyProperties{},
Dan Willemsen581341d2017-02-09 16:16:31 -08003930 &CoverageProperties{},
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08003931 &SAbiProperties{},
Stephen Craneba090d12017-05-09 15:44:35 -07003932 &LTOProperties{},
Yi Kongeb8efc92021-12-09 18:06:29 +08003933 &AfdoProperties{},
Sharjeel Khanc6a93d82023-07-18 21:01:11 +00003934 &OrderfileProperties{},
Dan Willemsen6424d172018-03-08 13:27:59 -08003935 &android.ProtoProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -04003936 // RustBindgenProperties is included here so that cc_defaults can be used for rust_bindgen modules.
3937 &RustBindgenClangProperties{},
Yu-Chi Cheng24b2b0f2021-06-23 15:56:39 -07003938 &prebuiltLinkerProperties{},
Colin Crosse1d764e2016-08-18 14:18:32 -07003939 )
Colin Crosscfad1192015-11-02 16:43:11 -08003940
Jooyung Hancc372c52019-09-25 15:18:44 +09003941 android.InitDefaultsModule(module)
Colin Cross36242852017-06-23 15:06:31 -07003942
3943 return module
Colin Crosscfad1192015-11-02 16:43:11 -08003944}
3945
Jiyong Park2286afd2020-06-16 21:58:53 +09003946func (c *Module) IsSdkVariant() bool {
Lukacs T. Berki2063a0d2021-06-17 09:32:36 +02003947 return c.Properties.IsSdkVariant
Jiyong Park2286afd2020-06-16 21:58:53 +09003948}
3949
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003950func kytheExtractAllFactory() android.Singleton {
3951 return &kytheExtractAllSingleton{}
3952}
3953
3954type kytheExtractAllSingleton struct {
3955}
3956
3957func (ks *kytheExtractAllSingleton) GenerateBuildActions(ctx android.SingletonContext) {
3958 var xrefTargets android.Paths
Yu Liuec7043d2024-11-05 18:22:20 +00003959 ctx.VisitAllModuleProxies(func(module android.ModuleProxy) {
3960 files := android.OtherModuleProviderOrDefault(ctx, module, CcObjectInfoProvider).kytheFiles
3961 if len(files) > 0 {
3962 xrefTargets = append(xrefTargets, files...)
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003963 }
3964 })
3965 // TODO(asmundak): Perhaps emit a rule to output a warning if there were no xrefTargets
3966 if len(xrefTargets) > 0 {
Colin Crossc3d87d32020-06-04 13:25:17 -07003967 ctx.Phony("xref_cxx", xrefTargets...)
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003968 }
3969}
3970
Jihoon Kangf78a8902022-09-01 22:47:07 +00003971func (c *Module) Partition() string {
3972 if p, ok := c.installer.(interface {
3973 getPartition() string
3974 }); ok {
3975 return p.getPartition()
3976 }
3977 return ""
3978}
3979
Spandan Das2b6dfb52024-01-19 00:22:22 +00003980type sourceModuleName interface {
3981 sourceModuleName() string
3982}
3983
3984func (c *Module) BaseModuleName() string {
3985 if smn, ok := c.linker.(sourceModuleName); ok && smn.sourceModuleName() != "" {
3986 // if the prebuilt module sets a source_module_name in Android.bp, use that
3987 return smn.sourceModuleName()
3988 }
3989 return c.ModuleBase.BaseModuleName()
3990}
3991
Spandan Dase20c56c2024-07-23 21:34:24 +00003992func (c *Module) stubsSymbolFilePath() android.Path {
3993 if library, ok := c.linker.(*libraryDecorator); ok {
3994 return library.stubsSymbolFilePath
3995 }
3996 return android.OptionalPath{}.Path()
3997}
3998
Colin Cross06a931b2015-10-28 17:23:31 -07003999var Bool = proptools.Bool
Colin Cross38b40df2018-04-10 16:14:46 -07004000var BoolDefault = proptools.BoolDefault
Nan Zhang0007d812017-11-07 10:57:05 -08004001var BoolPtr = proptools.BoolPtr
4002var String = proptools.String
4003var StringPtr = proptools.StringPtr