blob: 7abb72c86f599d8b722d3a00d093847a50bd1b62 [file] [log] [blame]
Colin Cross5049f022015-03-18 13:28:46 -07001// Copyright 2015 Google Inc. All rights reserved.
Colin Cross3f40fa42015-01-30 17:27:36 -08002//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15package cc
16
17// This file contains the module types for compiling C/C++ for Android, and converts the properties
18// into the flags and filenames necessary to pass to the compiler. The final creation of the rules
19// is handled in builder.go
20
21import (
Colin Cross41955e82019-05-29 14:40:35 -070022 "fmt"
Logan Chien41eabe62019-04-10 13:33:58 +080023 "io"
Dan Albert9e10cd42016-08-03 14:12:14 -070024 "strconv"
Colin Cross3f40fa42015-01-30 17:27:36 -080025 "strings"
26
Colin Cross97ba0732015-03-23 17:50:24 -070027 "github.com/google/blueprint"
Colin Cross06a931b2015-10-28 17:23:31 -070028 "github.com/google/blueprint/proptools"
Colin Cross97ba0732015-03-23 17:50:24 -070029
Colin Cross635c3b02016-05-18 15:37:25 -070030 "android/soong/android"
Colin Crossb98c8b02016-07-29 13:44:28 -070031 "android/soong/cc/config"
Colin Cross5049f022015-03-18 13:28:46 -070032 "android/soong/genrule"
Colin Cross3f40fa42015-01-30 17:27:36 -080033)
34
Colin Cross463a90e2015-06-17 14:20:06 -070035func init() {
Colin Cross798bfce2016-10-12 14:28:16 -070036 android.RegisterModuleType("cc_defaults", defaultsFactory)
Colin Cross463a90e2015-06-17 14:20:06 -070037
Colin Cross1e676be2016-10-12 14:38:15 -070038 android.PreDepsMutators(func(ctx android.RegisterMutatorsContext) {
Jiyong Parkda6eb592018-12-19 17:12:36 +090039 ctx.BottomUp("image", ImageMutator).Parallel()
Colin Crosse40b4ea2018-10-02 22:25:58 -070040 ctx.BottomUp("link", LinkageMutator).Parallel()
Jiyong Parkda6eb592018-12-19 17:12:36 +090041 ctx.BottomUp("vndk", VndkMutator).Parallel()
Colin Cross1e676be2016-10-12 14:38:15 -070042 ctx.BottomUp("ndk_api", ndkApiMutator).Parallel()
Roland Levillain9b5fde92019-06-28 15:41:19 +010043 ctx.BottomUp("test_per_src", TestPerSrcMutator).Parallel()
Jiyong Park25fc6a92018-11-18 18:02:45 +090044 ctx.BottomUp("version", VersionMutator).Parallel()
Colin Crosse40b4ea2018-10-02 22:25:58 -070045 ctx.BottomUp("begin", BeginMutator).Parallel()
Inseob Kimc0907f12019-02-08 21:00:45 +090046 ctx.BottomUp("sysprop", SyspropMutator).Parallel()
Colin Cross1e676be2016-10-12 14:38:15 -070047 })
Colin Cross16b23492016-01-06 14:41:07 -080048
Colin Cross1e676be2016-10-12 14:38:15 -070049 android.PostDepsMutators(func(ctx android.RegisterMutatorsContext) {
50 ctx.TopDown("asan_deps", sanitizerDepsMutator(asan))
51 ctx.BottomUp("asan", sanitizerMutator(asan)).Parallel()
Colin Cross16b23492016-01-06 14:41:07 -080052
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -070053 ctx.TopDown("hwasan_deps", sanitizerDepsMutator(hwasan))
54 ctx.BottomUp("hwasan", sanitizerMutator(hwasan)).Parallel()
55
Mitch Phillipsbfeade62019-05-01 14:42:05 -070056 ctx.TopDown("fuzzer_deps", sanitizerDepsMutator(fuzzer))
57 ctx.BottomUp("fuzzer", sanitizerMutator(fuzzer)).Parallel()
58
Jiyong Park1d1119f2019-07-29 21:27:18 +090059 // cfi mutator shouldn't run before sanitizers that return true for
60 // incompatibleWithCfi()
Vishwath Mohanb743e9c2017-11-01 09:20:21 +000061 ctx.TopDown("cfi_deps", sanitizerDepsMutator(cfi))
62 ctx.BottomUp("cfi", sanitizerMutator(cfi)).Parallel()
63
Peter Collingbourne8c7e6e22018-11-19 16:03:58 -080064 ctx.TopDown("scs_deps", sanitizerDepsMutator(scs))
65 ctx.BottomUp("scs", sanitizerMutator(scs)).Parallel()
66
Colin Cross1e676be2016-10-12 14:38:15 -070067 ctx.TopDown("tsan_deps", sanitizerDepsMutator(tsan))
68 ctx.BottomUp("tsan", sanitizerMutator(tsan)).Parallel()
Dan Willemsen581341d2017-02-09 16:16:31 -080069
Colin Cross0b908332019-06-19 23:00:20 -070070 ctx.TopDown("sanitize_runtime_deps", sanitizerRuntimeDepsMutator).Parallel()
Jiyong Park379de2f2018-12-19 02:47:14 +090071 ctx.BottomUp("sanitize_runtime", sanitizerRuntimeMutator).Parallel()
Ivan Lozano30c5db22018-02-21 15:49:20 -080072
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -080073 ctx.BottomUp("coverage", coverageMutator).Parallel()
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -080074 ctx.TopDown("vndk_deps", sabiDepsMutator)
Stephen Craneba090d12017-05-09 15:44:35 -070075
76 ctx.TopDown("lto_deps", ltoDepsMutator)
77 ctx.BottomUp("lto", ltoMutator).Parallel()
Jooyung Hana70f0672019-01-18 15:20:43 +090078
79 ctx.TopDown("double_loadable", checkDoubleLoadableLibraries).Parallel()
Colin Cross1e676be2016-10-12 14:38:15 -070080 })
Colin Crossb98c8b02016-07-29 13:44:28 -070081
Sasha Smundak2a4549e2018-11-05 16:49:08 -080082 android.RegisterSingletonType("kythe_extract_all", kytheExtractAllFactory)
Colin Crossb98c8b02016-07-29 13:44:28 -070083 pctx.Import("android/soong/cc/config")
Colin Cross463a90e2015-06-17 14:20:06 -070084}
85
Colin Crossca860ac2016-01-04 14:34:37 -080086type Deps struct {
87 SharedLibs, LateSharedLibs []string
88 StaticLibs, LateStaticLibs, WholeStaticLibs []string
Colin Cross5950f382016-12-13 12:50:57 -080089 HeaderLibs []string
Logan Chien43d34c32017-12-20 01:17:32 +080090 RuntimeLibs []string
Colin Crossc472d572015-03-17 15:06:21 -070091
Colin Cross5950f382016-12-13 12:50:57 -080092 ReexportSharedLibHeaders, ReexportStaticLibHeaders, ReexportHeaderLibHeaders []string
Dan Willemsen490a8dc2016-06-06 18:22:19 -070093
Colin Cross81413472016-04-11 14:37:39 -070094 ObjFiles []string
Dan Willemsen34cc69e2015-09-23 15:26:20 -070095
Dan Willemsenb40aab62016-04-20 14:21:14 -070096 GeneratedSources []string
97 GeneratedHeaders []string
98
Dan Willemsenb3454ab2016-09-28 17:34:58 -070099 ReexportGeneratedHeaders []string
100
Colin Cross97ba0732015-03-23 17:50:24 -0700101 CrtBegin, CrtEnd string
Dan Willemsena0790e32018-10-12 00:24:23 -0700102
103 // Used for host bionic
104 LinkerFlagsFile string
105 DynamicLinker string
Colin Crossc472d572015-03-17 15:06:21 -0700106}
107
Colin Crossca860ac2016-01-04 14:34:37 -0800108type PathDeps struct {
Colin Cross26c34ed2016-09-30 17:10:16 -0700109 // Paths to .so files
Jiyong Park64a44f22019-01-18 14:37:08 +0900110 SharedLibs, EarlySharedLibs, LateSharedLibs android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700111 // Paths to the dependencies to use for .so files (.so.toc files)
Jiyong Park64a44f22019-01-18 14:37:08 +0900112 SharedLibsDeps, EarlySharedLibsDeps, LateSharedLibsDeps android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700113 // Paths to .a files
Colin Cross635c3b02016-05-18 15:37:25 -0700114 StaticLibs, LateStaticLibs, WholeStaticLibs android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700115
Colin Cross26c34ed2016-09-30 17:10:16 -0700116 // Paths to .o files
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700117 Objs Objects
Dan Willemsen581341d2017-02-09 16:16:31 -0800118 StaticLibObjs Objects
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700119 WholeStaticLibObjs Objects
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700120
Colin Cross26c34ed2016-09-30 17:10:16 -0700121 // Paths to generated source files
Colin Cross635c3b02016-05-18 15:37:25 -0700122 GeneratedSources android.Paths
123 GeneratedHeaders android.Paths
Dan Willemsenb40aab62016-04-20 14:21:14 -0700124
Inseob Kim69378442019-06-03 19:10:47 +0900125 Flags []string
126 IncludeDirs []string
127 SystemIncludeDirs []string
128 ReexportedDirs []string
129 ReexportedSystemDirs []string
130 ReexportedFlags []string
131 ReexportedDeps android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700132
Colin Cross26c34ed2016-09-30 17:10:16 -0700133 // Paths to crt*.o files
Colin Cross635c3b02016-05-18 15:37:25 -0700134 CrtBegin, CrtEnd android.OptionalPath
Dan Willemsena0790e32018-10-12 00:24:23 -0700135
136 // Path to the file container flags to use with the linker
137 LinkerFlagsFile android.OptionalPath
138
139 // Path to the dynamic linker binary
140 DynamicLinker android.OptionalPath
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700141}
142
Colin Crossca860ac2016-01-04 14:34:37 -0800143type Flags struct {
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700144 GlobalFlags []string // Flags that apply to C, C++, and assembly source files
145 ArFlags []string // Flags that apply to ar
146 AsFlags []string // Flags that apply to assembly source files
147 CFlags []string // Flags that apply to C and C++ source files
148 ToolingCFlags []string // Flags that apply to C and C++ source files parsed by clang LibTooling tools
149 ConlyFlags []string // Flags that apply to C source files
150 CppFlags []string // Flags that apply to C++ source files
151 ToolingCppFlags []string // Flags that apply to C++ source files parsed by clang LibTooling tools
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700152 aidlFlags []string // Flags that apply to aidl source files
153 rsFlags []string // Flags that apply to renderscript source files
154 LdFlags []string // Flags that apply to linker command lines
155 libFlags []string // Flags to add libraries early to the link order
156 TidyFlags []string // Flags that apply to clang-tidy
157 SAbiFlags []string // Flags that apply to header-abi-dumper
158 YasmFlags []string // Flags that apply to yasm assembly source files
Colin Cross28344522015-04-22 13:07:53 -0700159
Colin Crossc3199482017-03-30 15:03:04 -0700160 // Global include flags that apply to C, C++, and assembly source files
161 // These must be after any module include flags, which will be in GlobalFlags.
162 SystemIncludeFlags []string
163
Colin Crossb98c8b02016-07-29 13:44:28 -0700164 Toolchain config.Toolchain
Dan Willemsena03cf6d2016-09-26 15:45:04 -0700165 Tidy bool
Dan Willemsen581341d2017-02-09 16:16:31 -0800166 Coverage bool
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800167 SAbiDump bool
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800168 EmitXrefs bool // If true, generate Ninja rules to generate emitXrefs input files for Kythe
Colin Crossca860ac2016-01-04 14:34:37 -0800169
170 RequiredInstructionSet string
Colin Cross16b23492016-01-06 14:41:07 -0800171 DynamicLinker string
172
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700173 CFlagsDeps android.Paths // Files depended on by compiler flags
174 LdFlagsDeps android.Paths // Files depended on by linker flags
Colin Cross18c0c5a2016-12-01 14:45:23 -0800175
176 GroupStaticLibs bool
Dan Willemsen60e62f02018-11-16 21:05:32 -0800177
Colin Cross19878da2019-03-28 14:45:07 -0700178 proto android.ProtoFlags
Colin Cross19878da2019-03-28 14:45:07 -0700179 protoC bool // Whether to use C instead of C++
180 protoOptionsFile bool // Whether to look for a .options file next to the .proto
Dan Willemsen4e0aa232019-04-10 22:59:54 -0700181
182 Yacc *YaccProperties
Colin Crossc472d572015-03-17 15:06:21 -0700183}
184
Colin Crossca860ac2016-01-04 14:34:37 -0800185// Properties used to compile all C or C++ modules
186type BaseProperties struct {
Dan Willemsen742a5452018-07-23 17:19:36 -0700187 // Deprecated. true is the default, false is invalid.
Colin Crossca860ac2016-01-04 14:34:37 -0800188 Clang *bool `android:"arch_variant"`
Colin Cross7d5136f2015-05-11 13:39:40 -0700189
190 // Minimum sdk version supported when compiling against the ndk
Nan Zhang0007d812017-11-07 10:57:05 -0800191 Sdk_version *string
Colin Cross7d5136f2015-05-11 13:39:40 -0700192
Jiyong Parkde866cb2018-12-07 23:08:36 +0900193 AndroidMkSharedLibs []string `blueprint:"mutated"`
194 AndroidMkStaticLibs []string `blueprint:"mutated"`
195 AndroidMkRuntimeLibs []string `blueprint:"mutated"`
196 AndroidMkWholeStaticLibs []string `blueprint:"mutated"`
197 HideFromMake bool `blueprint:"mutated"`
198 PreventInstall bool `blueprint:"mutated"`
199 ApexesProvidingSharedLibs []string `blueprint:"mutated"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700200
201 UseVndk bool `blueprint:"mutated"`
Colin Cross5beccee2017-12-07 15:28:59 -0800202
203 // *.logtags files, to combine together in order to generate the /system/etc/event-log-tags
204 // file
205 Logtags []string
Jiyong Parkf9332f12018-02-01 00:54:12 +0900206
207 // Make this module available when building for recovery
208 Recovery_available *bool
209
210 InRecovery bool `blueprint:"mutated"`
Jiyong Parkb0788572018-12-20 22:10:17 +0900211
212 // Allows this module to use non-APEX version of libraries. Useful
213 // for building binaries that are started before APEXes are activated.
214 Bootstrap *bool
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700215}
216
217type VendorProperties struct {
Jiyong Park82e2bf32017-08-16 14:05:54 +0900218 // whether this module should be allowed to be directly depended by other
219 // modules with `vendor: true`, `proprietary: true`, or `vendor_available:true`.
220 // If set to true, two variants will be built separately, one like
221 // normal, and the other limited to the set of libraries and headers
222 // that are exposed to /vendor modules.
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700223 //
224 // The vendor variant may be used with a different (newer) /system,
225 // so it shouldn't have any unversioned runtime dependencies, or
226 // make assumptions about the system that may not be true in the
227 // future.
228 //
Jiyong Park82e2bf32017-08-16 14:05:54 +0900229 // If set to false, this module becomes inaccessible from /vendor modules.
230 //
231 // Default value is true when vndk: {enabled: true} or vendor: true.
232 //
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700233 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
234 Vendor_available *bool
Jiyong Park5fb8c102018-04-09 12:03:06 +0900235
236 // whether this module is capable of being loaded with other instance
237 // (possibly an older version) of the same module in the same process.
238 // Currently, a shared library that is a member of VNDK (vndk: {enabled: true})
239 // can be double loaded in a vendor process if the library is also a
240 // (direct and indirect) dependency of an LLNDK library. Such libraries must be
241 // explicitly marked as `double_loadable: true` by the owner, or the dependency
242 // from the LLNDK lib should be cut if the lib is not designed to be double loaded.
243 Double_loadable *bool
Colin Crossca860ac2016-01-04 14:34:37 -0800244}
245
Colin Crossca860ac2016-01-04 14:34:37 -0800246type ModuleContextIntf interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800247 static() bool
248 staticBinary() bool
Jiyong Park1d1119f2019-07-29 21:27:18 +0900249 header() bool
Colin Crossb98c8b02016-07-29 13:44:28 -0700250 toolchain() config.Toolchain
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700251 useSdk() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800252 sdkVersion() string
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700253 useVndk() bool
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800254 isNdk() bool
Inseob Kim9516ee92019-05-09 10:56:13 +0900255 isLlndk(config android.Config) bool
256 isLlndkPublic(config android.Config) bool
257 isVndkPrivate(config android.Config) bool
Justin Yun8effde42017-06-23 19:24:43 +0900258 isVndk() bool
259 isVndkSp() bool
Logan Chienf3511742017-10-31 18:04:35 +0800260 isVndkExt() bool
Jiyong Parkf9332f12018-02-01 00:54:12 +0900261 inRecovery() bool
Hsin-Yi Chenaf17d742019-07-29 17:46:59 +0800262 shouldCreateSourceAbiDump() bool
Dan Willemsen8146b2f2016-03-30 21:00:30 -0700263 selectedStl() string
Colin Crossce75d2c2016-10-06 16:12:58 -0700264 baseModuleName() string
Logan Chienf3511742017-10-31 18:04:35 +0800265 getVndkExtendsModuleName() string
Yi Kong7e53c572018-02-14 18:16:12 +0800266 isPgoCompile() bool
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800267 isNDKStubLibrary() bool
Ivan Lozanobd721262018-11-27 14:33:03 -0800268 useClangLld(actx ModuleContext) bool
Jiyong Park58e364a2019-01-19 19:24:06 +0900269 apexName() string
Jiyong Parkb0788572018-12-20 22:10:17 +0900270 hasStubsVariants() bool
271 isStubs() bool
Jiyong Parka4b9dd02019-01-16 22:53:13 +0900272 bootstrap() bool
Vic Yangefd249e2018-11-12 20:19:56 -0800273 mustUseVendorVariant() bool
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700274 nativeCoverage() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800275}
276
277type ModuleContext interface {
Colin Cross635c3b02016-05-18 15:37:25 -0700278 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800279 ModuleContextIntf
280}
281
282type BaseModuleContext interface {
Colin Cross0ea8ba82019-06-06 14:33:29 -0700283 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800284 ModuleContextIntf
285}
286
Colin Cross37047f12016-12-13 17:06:13 -0800287type DepsContext interface {
288 android.BottomUpMutatorContext
289 ModuleContextIntf
290}
291
Colin Crossca860ac2016-01-04 14:34:37 -0800292type feature interface {
293 begin(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800294 deps(ctx DepsContext, deps Deps) Deps
Colin Crossca860ac2016-01-04 14:34:37 -0800295 flags(ctx ModuleContext, flags Flags) Flags
296 props() []interface{}
297}
298
299type compiler interface {
Colin Cross42742b82016-08-01 13:20:05 -0700300 compilerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800301 compilerDeps(ctx DepsContext, deps Deps) Deps
Colin Crossf18e1102017-11-16 14:33:08 -0800302 compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
Colin Cross42742b82016-08-01 13:20:05 -0700303 compilerProps() []interface{}
304
Colin Cross76fada02016-07-27 10:31:13 -0700305 appendCflags([]string)
306 appendAsflags([]string)
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700307 compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects
Colin Crossca860ac2016-01-04 14:34:37 -0800308}
309
310type linker interface {
Colin Cross42742b82016-08-01 13:20:05 -0700311 linkerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800312 linkerDeps(ctx DepsContext, deps Deps) Deps
Colin Cross42742b82016-08-01 13:20:05 -0700313 linkerFlags(ctx ModuleContext, flags Flags) Flags
314 linkerProps() []interface{}
Ivan Lozanobd721262018-11-27 14:33:03 -0800315 useClangLld(actx ModuleContext) bool
Colin Cross42742b82016-08-01 13:20:05 -0700316
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700317 link(ctx ModuleContext, flags Flags, deps PathDeps, objs Objects) android.Path
Colin Cross76fada02016-07-27 10:31:13 -0700318 appendLdflags([]string)
Jiyong Parkaf6d8952019-01-31 12:21:23 +0900319 unstrippedOutputFilePath() android.Path
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700320
321 nativeCoverage() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800322}
323
324type installer interface {
Colin Cross42742b82016-08-01 13:20:05 -0700325 installerProps() []interface{}
Colin Cross635c3b02016-05-18 15:37:25 -0700326 install(ctx ModuleContext, path android.Path)
Colin Crossca860ac2016-01-04 14:34:37 -0800327 inData() bool
Vishwath Mohan1dd88392017-03-29 22:00:18 -0700328 inSanitizerDir() bool
Dan Willemsen4aa75ca2016-09-28 16:18:03 -0700329 hostToolPath() android.OptionalPath
Jiyong Parkb7c24df2019-02-01 12:03:59 +0900330 relativeInstallPath() string
Colin Crossca860ac2016-01-04 14:34:37 -0800331}
332
Colin Crossc99deeb2016-04-11 15:06:20 -0700333type dependencyTag struct {
334 blueprint.BaseDependencyTag
335 name string
336 library bool
Roland Levillainf89cd092019-07-29 16:22:59 +0100337 shared bool
Dan Willemsen490a8dc2016-06-06 18:22:19 -0700338
339 reexportFlags bool
Jiyong Park25fc6a92018-11-18 18:02:45 +0900340
341 explicitlyVersioned bool
Colin Crossc99deeb2016-04-11 15:06:20 -0700342}
343
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800344type xref interface {
345 XrefCcFiles() android.Paths
346}
347
Colin Crossc99deeb2016-04-11 15:06:20 -0700348var (
Roland Levillainf89cd092019-07-29 16:22:59 +0100349 sharedDepTag = dependencyTag{name: "shared", library: true, shared: true}
350 sharedExportDepTag = dependencyTag{name: "shared", library: true, shared: true, reexportFlags: true}
351 earlySharedDepTag = dependencyTag{name: "early_shared", library: true, shared: true}
352 lateSharedDepTag = dependencyTag{name: "late shared", library: true, shared: true}
Dan Willemsenb3454ab2016-09-28 17:34:58 -0700353 staticDepTag = dependencyTag{name: "static", library: true}
354 staticExportDepTag = dependencyTag{name: "static", library: true, reexportFlags: true}
355 lateStaticDepTag = dependencyTag{name: "late static", library: true}
356 wholeStaticDepTag = dependencyTag{name: "whole static", library: true, reexportFlags: true}
Colin Cross32ec36c2016-12-15 07:39:51 -0800357 headerDepTag = dependencyTag{name: "header", library: true}
358 headerExportDepTag = dependencyTag{name: "header", library: true, reexportFlags: true}
Dan Willemsenb3454ab2016-09-28 17:34:58 -0700359 genSourceDepTag = dependencyTag{name: "gen source"}
360 genHeaderDepTag = dependencyTag{name: "gen header"}
361 genHeaderExportDepTag = dependencyTag{name: "gen header", reexportFlags: true}
362 objDepTag = dependencyTag{name: "obj"}
363 crtBeginDepTag = dependencyTag{name: "crtbegin"}
364 crtEndDepTag = dependencyTag{name: "crtend"}
Dan Willemsena0790e32018-10-12 00:24:23 -0700365 linkerFlagsDepTag = dependencyTag{name: "linker flags file"}
366 dynamicLinkerDepTag = dependencyTag{name: "dynamic linker"}
Dan Willemsenb3454ab2016-09-28 17:34:58 -0700367 reuseObjTag = dependencyTag{name: "reuse objects"}
Jiyong Parke4bb9862019-02-01 00:31:10 +0900368 staticVariantTag = dependencyTag{name: "static variant"}
Dan Willemsenb3454ab2016-09-28 17:34:58 -0700369 ndkStubDepTag = dependencyTag{name: "ndk stub", library: true}
370 ndkLateStubDepTag = dependencyTag{name: "ndk late stub", library: true}
Logan Chienf3511742017-10-31 18:04:35 +0800371 vndkExtDepTag = dependencyTag{name: "vndk extends", library: true}
Logan Chien43d34c32017-12-20 01:17:32 +0800372 runtimeDepTag = dependencyTag{name: "runtime lib"}
Pirama Arumuga Nainar82fe59b2019-07-02 14:55:35 -0700373 coverageDepTag = dependencyTag{name: "coverage"}
Roland Levillainf2fad972019-06-28 15:41:19 +0100374 testPerSrcDepTag = dependencyTag{name: "test_per_src"}
Colin Crossc99deeb2016-04-11 15:06:20 -0700375)
376
Roland Levillainf89cd092019-07-29 16:22:59 +0100377func IsSharedDepTag(depTag blueprint.DependencyTag) bool {
378 ccDepTag, ok := depTag.(dependencyTag)
379 return ok && ccDepTag.shared
380}
381
382func IsRuntimeDepTag(depTag blueprint.DependencyTag) bool {
383 ccDepTag, ok := depTag.(dependencyTag)
384 return ok && ccDepTag == runtimeDepTag
385}
386
387func IsTestPerSrcDepTag(depTag blueprint.DependencyTag) bool {
388 ccDepTag, ok := depTag.(dependencyTag)
389 return ok && ccDepTag == testPerSrcDepTag
390}
391
Colin Crossca860ac2016-01-04 14:34:37 -0800392// Module contains the properties and members used by all C/C++ module types, and implements
393// the blueprint.Module interface. It delegates to compiler, linker, and installer interfaces
394// to construct the output file. Behavior can be customized with a Customizer interface
395type Module struct {
Colin Cross635c3b02016-05-18 15:37:25 -0700396 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -0700397 android.DefaultableModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +0900398 android.ApexModuleBase
Colin Crossc472d572015-03-17 15:06:21 -0700399
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700400 Properties BaseProperties
401 VendorProperties VendorProperties
Colin Crossfa138792015-04-24 17:31:52 -0700402
Colin Crossca860ac2016-01-04 14:34:37 -0800403 // initialize before calling Init
Colin Cross635c3b02016-05-18 15:37:25 -0700404 hod android.HostOrDeviceSupported
405 multilib android.Multilib
Colin Crossc472d572015-03-17 15:06:21 -0700406
Colin Crossca860ac2016-01-04 14:34:37 -0800407 // delegates, initialize before calling Init
Colin Crossb4ce0ec2016-09-13 13:41:39 -0700408 features []feature
409 compiler compiler
410 linker linker
411 installer installer
412 stl *stl
413 sanitize *sanitize
Dan Willemsen581341d2017-02-09 16:16:31 -0800414 coverage *coverage
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800415 sabi *sabi
Justin Yun8effde42017-06-23 19:24:43 +0900416 vndkdep *vndkdep
Stephen Craneba090d12017-05-09 15:44:35 -0700417 lto *lto
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700418 pgo *pgo
Ivan Lozano074ec482018-11-21 08:59:37 -0800419 xom *xom
Colin Cross16b23492016-01-06 14:41:07 -0800420
421 androidMkSharedLibDeps []string
Colin Cross74d1ec02015-04-28 13:30:13 -0700422
Colin Cross635c3b02016-05-18 15:37:25 -0700423 outputFile android.OptionalPath
Colin Crossca860ac2016-01-04 14:34:37 -0800424
Colin Crossb98c8b02016-07-29 13:44:28 -0700425 cachedToolchain config.Toolchain
Colin Crossb916a382016-07-29 17:28:03 -0700426
427 subAndroidMkOnce map[subAndroidMkProvider]bool
Fabien Sanglardd61f1f42017-01-10 16:21:22 -0800428
429 // Flags used to compile this module
430 flags Flags
Jeff Gaston294356f2017-09-27 17:05:30 -0700431
432 // When calling a linker, if module A depends on module B, then A must precede B in its command
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800433 // line invocation. depsInLinkOrder stores the proper ordering of all of the transitive
Jeff Gaston294356f2017-09-27 17:05:30 -0700434 // deps of this module
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800435 depsInLinkOrder android.Paths
436
437 // only non-nil when this is a shared library that reuses the objects of a static library
438 staticVariant *Module
Inseob Kim9516ee92019-05-09 10:56:13 +0900439
440 makeLinkType string
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800441 // Kythe (source file indexer) paths for this compilation module
442 kytheFiles android.Paths
Colin Crossc472d572015-03-17 15:06:21 -0700443}
444
Jiyong Parkc20eee32018-09-05 22:36:17 +0900445func (c *Module) OutputFile() android.OptionalPath {
446 return c.outputFile
447}
448
Jiyong Park719b4462019-01-13 00:39:51 +0900449func (c *Module) UnstrippedOutputFile() android.Path {
Jiyong Parkaf6d8952019-01-31 12:21:23 +0900450 if c.linker != nil {
451 return c.linker.unstrippedOutputFilePath()
Jiyong Park719b4462019-01-13 00:39:51 +0900452 }
453 return nil
454}
455
Jiyong Parkb7c24df2019-02-01 12:03:59 +0900456func (c *Module) RelativeInstallPath() string {
457 if c.installer != nil {
458 return c.installer.relativeInstallPath()
459 }
460 return ""
461}
462
Colin Cross36242852017-06-23 15:06:31 -0700463func (c *Module) Init() android.Module {
Dan Willemsenf923f2b2018-05-09 13:45:03 -0700464 c.AddProperties(&c.Properties, &c.VendorProperties)
Colin Crossca860ac2016-01-04 14:34:37 -0800465 if c.compiler != nil {
Colin Cross36242852017-06-23 15:06:31 -0700466 c.AddProperties(c.compiler.compilerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -0800467 }
468 if c.linker != nil {
Colin Cross36242852017-06-23 15:06:31 -0700469 c.AddProperties(c.linker.linkerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -0800470 }
471 if c.installer != nil {
Colin Cross36242852017-06-23 15:06:31 -0700472 c.AddProperties(c.installer.installerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -0800473 }
Colin Crossa8e07cc2016-04-04 15:07:06 -0700474 if c.stl != nil {
Colin Cross36242852017-06-23 15:06:31 -0700475 c.AddProperties(c.stl.props()...)
Colin Crossa8e07cc2016-04-04 15:07:06 -0700476 }
Colin Cross16b23492016-01-06 14:41:07 -0800477 if c.sanitize != nil {
Colin Cross36242852017-06-23 15:06:31 -0700478 c.AddProperties(c.sanitize.props()...)
Colin Cross16b23492016-01-06 14:41:07 -0800479 }
Dan Willemsen581341d2017-02-09 16:16:31 -0800480 if c.coverage != nil {
Colin Cross36242852017-06-23 15:06:31 -0700481 c.AddProperties(c.coverage.props()...)
Dan Willemsen581341d2017-02-09 16:16:31 -0800482 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800483 if c.sabi != nil {
Colin Cross36242852017-06-23 15:06:31 -0700484 c.AddProperties(c.sabi.props()...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800485 }
Justin Yun8effde42017-06-23 19:24:43 +0900486 if c.vndkdep != nil {
487 c.AddProperties(c.vndkdep.props()...)
488 }
Stephen Craneba090d12017-05-09 15:44:35 -0700489 if c.lto != nil {
490 c.AddProperties(c.lto.props()...)
491 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700492 if c.pgo != nil {
493 c.AddProperties(c.pgo.props()...)
494 }
Ivan Lozano074ec482018-11-21 08:59:37 -0800495 if c.xom != nil {
496 c.AddProperties(c.xom.props()...)
497 }
Colin Crossca860ac2016-01-04 14:34:37 -0800498 for _, feature := range c.features {
Colin Cross36242852017-06-23 15:06:31 -0700499 c.AddProperties(feature.props()...)
Colin Crossca860ac2016-01-04 14:34:37 -0800500 }
Colin Crossc472d572015-03-17 15:06:21 -0700501
Colin Crossa9d8bee2018-10-02 13:59:46 -0700502 c.Prefer32(func(ctx android.BaseModuleContext, base *android.ModuleBase, class android.OsClass) bool {
503 switch class {
504 case android.Device:
505 return ctx.Config().DevicePrefer32BitExecutables()
506 case android.HostCross:
507 // Windows builds always prefer 32-bit
508 return true
509 default:
510 return false
511 }
512 })
Colin Cross36242852017-06-23 15:06:31 -0700513 android.InitAndroidArchModule(c, c.hod, c.multilib)
Colin Crossc472d572015-03-17 15:06:21 -0700514
Colin Cross1f44a3a2017-07-07 14:33:33 -0700515 android.InitDefaultableModule(c)
Colin Cross36242852017-06-23 15:06:31 -0700516
Jiyong Park9d452992018-10-03 00:38:19 +0900517 android.InitApexModule(c)
518
Colin Cross36242852017-06-23 15:06:31 -0700519 return c
Colin Crossc472d572015-03-17 15:06:21 -0700520}
521
Colin Crossb916a382016-07-29 17:28:03 -0700522// Returns true for dependency roots (binaries)
523// TODO(ccross): also handle dlopenable libraries
524func (c *Module) isDependencyRoot() bool {
525 if root, ok := c.linker.(interface {
526 isDependencyRoot() bool
527 }); ok {
528 return root.isDependencyRoot()
529 }
530 return false
531}
532
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700533func (c *Module) useVndk() bool {
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700534 return c.Properties.UseVndk
535}
536
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800537func (c *Module) isCoverageVariant() bool {
538 return c.coverage.Properties.IsCoverageVariant
539}
540
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800541func (c *Module) isNdk() bool {
542 return inList(c.Name(), ndkMigratedLibs)
543}
544
Inseob Kim9516ee92019-05-09 10:56:13 +0900545func (c *Module) isLlndk(config android.Config) bool {
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800546 // Returns true for both LLNDK (public) and LLNDK-private libs.
Inseob Kim9516ee92019-05-09 10:56:13 +0900547 return inList(c.Name(), *llndkLibraries(config))
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800548}
549
Inseob Kim9516ee92019-05-09 10:56:13 +0900550func (c *Module) isLlndkPublic(config android.Config) bool {
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800551 // Returns true only for LLNDK (public) libs.
Inseob Kim9516ee92019-05-09 10:56:13 +0900552 return c.isLlndk(config) && !c.isVndkPrivate(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800553}
554
Inseob Kim9516ee92019-05-09 10:56:13 +0900555func (c *Module) isVndkPrivate(config android.Config) bool {
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800556 // Returns true for LLNDK-private, VNDK-SP-private, and VNDK-core-private.
Inseob Kim9516ee92019-05-09 10:56:13 +0900557 return inList(c.Name(), *vndkPrivateLibraries(config))
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800558}
559
Justin Yun8effde42017-06-23 19:24:43 +0900560func (c *Module) isVndk() bool {
Logan Chienf3511742017-10-31 18:04:35 +0800561 if vndkdep := c.vndkdep; vndkdep != nil {
562 return vndkdep.isVndk()
Justin Yun8effde42017-06-23 19:24:43 +0900563 }
564 return false
565}
566
Jooyung Han76106d92019-05-20 18:49:10 +0900567func (c *Module) vndkVersion() string {
568 if vndkdep := c.vndkdep; vndkdep != nil {
569 return vndkdep.Properties.Vndk.Version
570 }
571 return ""
572}
573
Yi Kong7e53c572018-02-14 18:16:12 +0800574func (c *Module) isPgoCompile() bool {
575 if pgo := c.pgo; pgo != nil {
576 return pgo.Properties.PgoCompile
577 }
578 return false
579}
580
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800581func (c *Module) isNDKStubLibrary() bool {
582 if _, ok := c.compiler.(*stubDecorator); ok {
583 return true
584 }
585 return false
586}
587
Logan Chienf3511742017-10-31 18:04:35 +0800588func (c *Module) isVndkSp() bool {
589 if vndkdep := c.vndkdep; vndkdep != nil {
590 return vndkdep.isVndkSp()
591 }
592 return false
593}
594
595func (c *Module) isVndkExt() bool {
596 if vndkdep := c.vndkdep; vndkdep != nil {
597 return vndkdep.isVndkExt()
598 }
599 return false
600}
601
Vic Yangefd249e2018-11-12 20:19:56 -0800602func (c *Module) mustUseVendorVariant() bool {
603 return c.isVndkSp() || inList(c.Name(), config.VndkMustUseVendorVariantList)
604}
605
Logan Chienf3511742017-10-31 18:04:35 +0800606func (c *Module) getVndkExtendsModuleName() string {
607 if vndkdep := c.vndkdep; vndkdep != nil {
608 return vndkdep.getVndkExtendsModuleName()
609 }
610 return ""
611}
612
Jiyong Park82e2bf32017-08-16 14:05:54 +0900613// Returns true only when this module is configured to have core and vendor
614// variants.
615func (c *Module) hasVendorVariant() bool {
616 return c.isVndk() || Bool(c.VendorProperties.Vendor_available)
617}
618
Jiyong Parkf9332f12018-02-01 00:54:12 +0900619func (c *Module) inRecovery() bool {
620 return c.Properties.InRecovery || c.ModuleBase.InstallInRecovery()
621}
622
623func (c *Module) onlyInRecovery() bool {
624 return c.ModuleBase.InstallInRecovery()
625}
626
Jiyong Park25fc6a92018-11-18 18:02:45 +0900627func (c *Module) IsStubs() bool {
628 if library, ok := c.linker.(*libraryDecorator); ok {
629 return library.buildStubs()
Jiyong Park379de2f2018-12-19 02:47:14 +0900630 } else if _, ok := c.linker.(*llndkStubDecorator); ok {
631 return true
Jiyong Park25fc6a92018-11-18 18:02:45 +0900632 }
633 return false
634}
635
636func (c *Module) HasStubsVariants() bool {
637 if library, ok := c.linker.(*libraryDecorator); ok {
638 return len(library.Properties.Stubs.Versions) > 0
639 }
Peter Collingbourne3478bb22019-04-24 14:41:12 -0700640 if library, ok := c.linker.(*prebuiltLibraryLinker); ok {
641 return len(library.Properties.Stubs.Versions) > 0
642 }
Jiyong Park25fc6a92018-11-18 18:02:45 +0900643 return false
644}
645
Jiyong Parka4b9dd02019-01-16 22:53:13 +0900646func (c *Module) bootstrap() bool {
647 return Bool(c.Properties.Bootstrap)
648}
649
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700650func (c *Module) nativeCoverage() bool {
651 return c.linker != nil && c.linker.nativeCoverage()
652}
653
Jiyong Parkf1194352019-02-25 11:05:47 +0900654func isBionic(name string) bool {
655 switch name {
656 case "libc", "libm", "libdl", "linker":
657 return true
658 }
659 return false
660}
661
Peter Collingbourne3478bb22019-04-24 14:41:12 -0700662func installToBootstrap(name string, config android.Config) bool {
663 if name == "libclang_rt.hwasan-aarch64-android" {
664 return inList("hwaddress", config.SanitizeDevice())
665 }
666 return isBionic(name)
667}
668
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800669func (c *Module) XrefCcFiles() android.Paths {
670 return c.kytheFiles
671}
672
Colin Crossca860ac2016-01-04 14:34:37 -0800673type baseModuleContext struct {
Colin Cross0ea8ba82019-06-06 14:33:29 -0700674 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800675 moduleContextImpl
676}
677
Colin Cross37047f12016-12-13 17:06:13 -0800678type depsContext struct {
679 android.BottomUpMutatorContext
680 moduleContextImpl
681}
682
Colin Crossca860ac2016-01-04 14:34:37 -0800683type moduleContext struct {
Colin Cross635c3b02016-05-18 15:37:25 -0700684 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800685 moduleContextImpl
686}
687
Jiyong Park2db76922017-11-08 16:03:48 +0900688func (ctx *moduleContext) SocSpecific() bool {
689 return ctx.ModuleContext.SocSpecific() ||
690 (ctx.mod.hasVendorVariant() && ctx.mod.useVndk() && !ctx.mod.isVndk())
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700691}
692
Colin Crossca860ac2016-01-04 14:34:37 -0800693type moduleContextImpl struct {
694 mod *Module
695 ctx BaseModuleContext
696}
697
Colin Crossb98c8b02016-07-29 13:44:28 -0700698func (ctx *moduleContextImpl) toolchain() config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -0800699 return ctx.mod.toolchain(ctx.ctx)
700}
701
702func (ctx *moduleContextImpl) static() bool {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000703 return ctx.mod.static()
Colin Crossca860ac2016-01-04 14:34:37 -0800704}
705
706func (ctx *moduleContextImpl) staticBinary() bool {
Jiyong Park379de2f2018-12-19 02:47:14 +0900707 return ctx.mod.staticBinary()
Colin Crossca860ac2016-01-04 14:34:37 -0800708}
709
Jiyong Park1d1119f2019-07-29 21:27:18 +0900710func (ctx *moduleContextImpl) header() bool {
711 return ctx.mod.header()
712}
713
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700714func (ctx *moduleContextImpl) useSdk() bool {
Doug Hornc32c6b02019-01-17 14:44:05 -0800715 if ctx.ctx.Device() && !ctx.useVndk() && !ctx.inRecovery() && !ctx.ctx.Fuchsia() {
Nan Zhang0007d812017-11-07 10:57:05 -0800716 return String(ctx.mod.Properties.Sdk_version) != ""
Dan Willemsena96ff642016-06-07 12:34:45 -0700717 }
718 return false
Colin Crossca860ac2016-01-04 14:34:37 -0800719}
720
721func (ctx *moduleContextImpl) sdkVersion() string {
Dan Willemsena96ff642016-06-07 12:34:45 -0700722 if ctx.ctx.Device() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700723 if ctx.useVndk() {
Justin Yun732aa6a2018-03-23 17:43:47 +0900724 vndk_ver := ctx.ctx.DeviceConfig().VndkVersion()
Ryan Prichard05206112018-03-26 21:25:27 -0700725 if vndk_ver == "current" {
Justin Yun732aa6a2018-03-23 17:43:47 +0900726 platform_vndk_ver := ctx.ctx.DeviceConfig().PlatformVndkVersion()
727 if inList(platform_vndk_ver, ctx.ctx.Config().PlatformVersionCombinedCodenames()) {
728 return "current"
729 }
730 return platform_vndk_ver
731 }
732 return vndk_ver
Dan Willemsend2ede872016-11-18 14:54:24 -0800733 }
Justin Yun732aa6a2018-03-23 17:43:47 +0900734 return String(ctx.mod.Properties.Sdk_version)
Dan Willemsena96ff642016-06-07 12:34:45 -0700735 }
736 return ""
Colin Crossca860ac2016-01-04 14:34:37 -0800737}
738
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700739func (ctx *moduleContextImpl) useVndk() bool {
740 return ctx.mod.useVndk()
741}
Justin Yun8effde42017-06-23 19:24:43 +0900742
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800743func (ctx *moduleContextImpl) isNdk() bool {
744 return ctx.mod.isNdk()
745}
746
Inseob Kim9516ee92019-05-09 10:56:13 +0900747func (ctx *moduleContextImpl) isLlndk(config android.Config) bool {
748 return ctx.mod.isLlndk(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800749}
750
Inseob Kim9516ee92019-05-09 10:56:13 +0900751func (ctx *moduleContextImpl) isLlndkPublic(config android.Config) bool {
752 return ctx.mod.isLlndkPublic(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800753}
754
Inseob Kim9516ee92019-05-09 10:56:13 +0900755func (ctx *moduleContextImpl) isVndkPrivate(config android.Config) bool {
756 return ctx.mod.isVndkPrivate(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800757}
758
Logan Chienf3511742017-10-31 18:04:35 +0800759func (ctx *moduleContextImpl) isVndk() bool {
760 return ctx.mod.isVndk()
761}
762
Yi Kong7e53c572018-02-14 18:16:12 +0800763func (ctx *moduleContextImpl) isPgoCompile() bool {
764 return ctx.mod.isPgoCompile()
765}
766
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800767func (ctx *moduleContextImpl) isNDKStubLibrary() bool {
768 return ctx.mod.isNDKStubLibrary()
769}
770
Justin Yun8effde42017-06-23 19:24:43 +0900771func (ctx *moduleContextImpl) isVndkSp() bool {
Logan Chienf3511742017-10-31 18:04:35 +0800772 return ctx.mod.isVndkSp()
773}
774
775func (ctx *moduleContextImpl) isVndkExt() bool {
776 return ctx.mod.isVndkExt()
Justin Yun8effde42017-06-23 19:24:43 +0900777}
778
Vic Yangefd249e2018-11-12 20:19:56 -0800779func (ctx *moduleContextImpl) mustUseVendorVariant() bool {
780 return ctx.mod.mustUseVendorVariant()
781}
782
Jiyong Parkf9332f12018-02-01 00:54:12 +0900783func (ctx *moduleContextImpl) inRecovery() bool {
784 return ctx.mod.inRecovery()
785}
786
Logan Chien2f2b8902018-07-10 15:01:19 +0800787// Check whether ABI dumps should be created for this module.
Hsin-Yi Chenaf17d742019-07-29 17:46:59 +0800788func (ctx *moduleContextImpl) shouldCreateSourceAbiDump() bool {
Logan Chien2f2b8902018-07-10 15:01:19 +0800789 if ctx.ctx.Config().IsEnvTrue("SKIP_ABI_CHECKS") {
790 return false
Jayant Chowdharyea0a2e12018-03-01 19:12:16 -0800791 }
Doug Hornc32c6b02019-01-17 14:44:05 -0800792
793 if ctx.ctx.Fuchsia() {
794 return false
795 }
796
Logan Chien2f2b8902018-07-10 15:01:19 +0800797 if sanitize := ctx.mod.sanitize; sanitize != nil {
798 if !sanitize.isVariantOnProductionDevice() {
799 return false
800 }
801 }
802 if !ctx.ctx.Device() {
803 // Host modules do not need ABI dumps.
804 return false
805 }
Logan Chienfa478c02018-12-28 16:25:39 +0800806 if !ctx.mod.IsForPlatform() {
807 // APEX variants do not need ABI dumps.
808 return false
809 }
Hsin-Yi Chenf6a95462019-06-25 14:46:52 +0800810 if ctx.isStubs() {
811 // Stubs do not need ABI dumps.
812 return false
813 }
Hsin-Yi Chenaf17d742019-07-29 17:46:59 +0800814 return true
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800815}
816
Dan Willemsen8146b2f2016-03-30 21:00:30 -0700817func (ctx *moduleContextImpl) selectedStl() string {
818 if stl := ctx.mod.stl; stl != nil {
819 return stl.Properties.SelectedStl
820 }
821 return ""
822}
823
Ivan Lozanobd721262018-11-27 14:33:03 -0800824func (ctx *moduleContextImpl) useClangLld(actx ModuleContext) bool {
825 return ctx.mod.linker.useClangLld(actx)
826}
827
Colin Crossce75d2c2016-10-06 16:12:58 -0700828func (ctx *moduleContextImpl) baseModuleName() string {
829 return ctx.mod.ModuleBase.BaseModuleName()
830}
831
Logan Chienf3511742017-10-31 18:04:35 +0800832func (ctx *moduleContextImpl) getVndkExtendsModuleName() string {
833 return ctx.mod.getVndkExtendsModuleName()
834}
835
Jiyong Park58e364a2019-01-19 19:24:06 +0900836func (ctx *moduleContextImpl) apexName() string {
837 return ctx.mod.ApexName()
Jiyong Park25fc6a92018-11-18 18:02:45 +0900838}
839
Jiyong Parkb0788572018-12-20 22:10:17 +0900840func (ctx *moduleContextImpl) hasStubsVariants() bool {
841 return ctx.mod.HasStubsVariants()
842}
843
844func (ctx *moduleContextImpl) isStubs() bool {
845 return ctx.mod.IsStubs()
846}
847
Jiyong Parka4b9dd02019-01-16 22:53:13 +0900848func (ctx *moduleContextImpl) bootstrap() bool {
849 return ctx.mod.bootstrap()
850}
851
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700852func (ctx *moduleContextImpl) nativeCoverage() bool {
853 return ctx.mod.nativeCoverage()
854}
855
Colin Cross635c3b02016-05-18 15:37:25 -0700856func newBaseModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -0800857 return &Module{
858 hod: hod,
859 multilib: multilib,
860 }
861}
862
Colin Cross635c3b02016-05-18 15:37:25 -0700863func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -0800864 module := newBaseModule(hod, multilib)
Dan Willemsena03cf6d2016-09-26 15:45:04 -0700865 module.features = []feature{
866 &tidyFeature{},
867 }
Colin Crossa8e07cc2016-04-04 15:07:06 -0700868 module.stl = &stl{}
Colin Cross16b23492016-01-06 14:41:07 -0800869 module.sanitize = &sanitize{}
Dan Willemsen581341d2017-02-09 16:16:31 -0800870 module.coverage = &coverage{}
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800871 module.sabi = &sabi{}
Justin Yun8effde42017-06-23 19:24:43 +0900872 module.vndkdep = &vndkdep{}
Stephen Craneba090d12017-05-09 15:44:35 -0700873 module.lto = &lto{}
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700874 module.pgo = &pgo{}
Ivan Lozano074ec482018-11-21 08:59:37 -0800875 module.xom = &xom{}
Colin Crossca860ac2016-01-04 14:34:37 -0800876 return module
877}
878
Colin Crossce75d2c2016-10-06 16:12:58 -0700879func (c *Module) Prebuilt() *android.Prebuilt {
880 if p, ok := c.linker.(prebuiltLinkerInterface); ok {
881 return p.prebuilt()
882 }
883 return nil
884}
885
886func (c *Module) Name() string {
887 name := c.ModuleBase.Name()
Dan Willemsen01a90592017-04-07 15:21:13 -0700888 if p, ok := c.linker.(interface {
889 Name(string) string
890 }); ok {
Colin Crossce75d2c2016-10-06 16:12:58 -0700891 name = p.Name(name)
892 }
893 return name
894}
895
Alex Light3d673592019-01-18 14:37:31 -0800896func (c *Module) Symlinks() []string {
897 if p, ok := c.installer.(interface {
898 symlinkList() []string
899 }); ok {
900 return p.symlinkList()
901 }
902 return nil
903}
904
Jeff Gaston294356f2017-09-27 17:05:30 -0700905// orderDeps reorders dependencies into a list such that if module A depends on B, then
906// A will precede B in the resultant list.
907// This is convenient for passing into a linker.
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800908// Note that directSharedDeps should be the analogous static library for each shared lib dep
909func orderDeps(directStaticDeps []android.Path, directSharedDeps []android.Path, allTransitiveDeps map[android.Path][]android.Path) (orderedAllDeps []android.Path, orderedDeclaredDeps []android.Path) {
Jeff Gaston294356f2017-09-27 17:05:30 -0700910 // If A depends on B, then
911 // Every list containing A will also contain B later in the list
912 // So, after concatenating all lists, the final instance of B will have come from the same
913 // original list as the final instance of A
914 // So, the final instance of B will be later in the concatenation than the final A
915 // So, keeping only the final instance of A and of B ensures that A is earlier in the output
916 // list than B
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800917 for _, dep := range directStaticDeps {
Jeff Gaston294356f2017-09-27 17:05:30 -0700918 orderedAllDeps = append(orderedAllDeps, dep)
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800919 orderedAllDeps = append(orderedAllDeps, allTransitiveDeps[dep]...)
920 }
921 for _, dep := range directSharedDeps {
922 orderedAllDeps = append(orderedAllDeps, dep)
923 orderedAllDeps = append(orderedAllDeps, allTransitiveDeps[dep]...)
Jeff Gaston294356f2017-09-27 17:05:30 -0700924 }
925
Colin Crossb6715442017-10-24 11:13:31 -0700926 orderedAllDeps = android.LastUniquePaths(orderedAllDeps)
Jeff Gaston294356f2017-09-27 17:05:30 -0700927
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800928 // We don't want to add any new dependencies into directStaticDeps (to allow the caller to
Jeff Gaston294356f2017-09-27 17:05:30 -0700929 // intentionally exclude or replace any unwanted transitive dependencies), so we limit the
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800930 // resultant list to only what the caller has chosen to include in directStaticDeps
931 _, orderedDeclaredDeps = android.FilterPathList(orderedAllDeps, directStaticDeps)
Jeff Gaston294356f2017-09-27 17:05:30 -0700932
933 return orderedAllDeps, orderedDeclaredDeps
934}
935
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800936func orderStaticModuleDeps(module *Module, staticDeps []*Module, sharedDeps []*Module) (results []android.Path) {
937 // convert Module to Path
938 allTransitiveDeps := make(map[android.Path][]android.Path, len(staticDeps))
939 staticDepFiles := []android.Path{}
940 for _, dep := range staticDeps {
941 allTransitiveDeps[dep.outputFile.Path()] = dep.depsInLinkOrder
942 staticDepFiles = append(staticDepFiles, dep.outputFile.Path())
Jeff Gaston294356f2017-09-27 17:05:30 -0700943 }
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800944 sharedDepFiles := []android.Path{}
945 for _, sharedDep := range sharedDeps {
946 staticAnalogue := sharedDep.staticVariant
947 if staticAnalogue != nil {
948 allTransitiveDeps[staticAnalogue.outputFile.Path()] = staticAnalogue.depsInLinkOrder
949 sharedDepFiles = append(sharedDepFiles, staticAnalogue.outputFile.Path())
950 }
Jeff Gaston294356f2017-09-27 17:05:30 -0700951 }
952
953 // reorder the dependencies based on transitive dependencies
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800954 module.depsInLinkOrder, results = orderDeps(staticDepFiles, sharedDepFiles, allTransitiveDeps)
Jeff Gaston294356f2017-09-27 17:05:30 -0700955
956 return results
Jeff Gaston294356f2017-09-27 17:05:30 -0700957}
958
Roland Levillainf89cd092019-07-29 16:22:59 +0100959func (c *Module) IsTestPerSrcAllTestsVariation() bool {
960 test, ok := c.linker.(testPerSrc)
961 return ok && test.isAllTestsVariation()
962}
963
Colin Cross635c3b02016-05-18 15:37:25 -0700964func (c *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
Roland Levillainf2fad972019-06-28 15:41:19 +0100965 // Handle the case of a test module split by `test_per_src` mutator.
Roland Levillainf89cd092019-07-29 16:22:59 +0100966 //
967 // The `test_per_src` mutator adds an extra variation named "", depending on all the other
968 // `test_per_src` variations of the test module. Set `outputFile` to an empty path for this
969 // module and return early, as this module does not produce an output file per se.
970 if c.IsTestPerSrcAllTestsVariation() {
971 c.outputFile = android.OptionalPath{}
972 return
Roland Levillainf2fad972019-06-28 15:41:19 +0100973 }
974
Jooyung Han38002912019-05-16 04:01:54 +0900975 c.makeLinkType = c.getMakeLinkType(actx)
Inseob Kim9516ee92019-05-09 10:56:13 +0900976
Colin Crossca860ac2016-01-04 14:34:37 -0800977 ctx := &moduleContext{
Colin Cross635c3b02016-05-18 15:37:25 -0700978 ModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -0800979 moduleContextImpl: moduleContextImpl{
980 mod: c,
981 },
982 }
983 ctx.ctx = ctx
984
Colin Crossf18e1102017-11-16 14:33:08 -0800985 deps := c.depsToPaths(ctx)
986 if ctx.Failed() {
987 return
988 }
989
Dan Willemsen8536d6b2018-10-07 20:54:34 -0700990 if c.Properties.Clang != nil && *c.Properties.Clang == false {
991 ctx.PropertyErrorf("clang", "false (GCC) is no longer supported")
992 }
993
Colin Crossca860ac2016-01-04 14:34:37 -0800994 flags := Flags{
995 Toolchain: c.toolchain(ctx),
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800996 EmitXrefs: ctx.Config().EmitXrefRules(),
Colin Crossca860ac2016-01-04 14:34:37 -0800997 }
Colin Crossca860ac2016-01-04 14:34:37 -0800998 if c.compiler != nil {
Colin Crossf18e1102017-11-16 14:33:08 -0800999 flags = c.compiler.compilerFlags(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001000 }
1001 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001002 flags = c.linker.linkerFlags(ctx, flags)
Colin Crossca860ac2016-01-04 14:34:37 -08001003 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001004 if c.stl != nil {
1005 flags = c.stl.flags(ctx, flags)
1006 }
Colin Cross16b23492016-01-06 14:41:07 -08001007 if c.sanitize != nil {
1008 flags = c.sanitize.flags(ctx, flags)
1009 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001010 if c.coverage != nil {
Pirama Arumuga Nainar82fe59b2019-07-02 14:55:35 -07001011 flags, deps = c.coverage.flags(ctx, flags, deps)
Dan Willemsen581341d2017-02-09 16:16:31 -08001012 }
Stephen Craneba090d12017-05-09 15:44:35 -07001013 if c.lto != nil {
1014 flags = c.lto.flags(ctx, flags)
1015 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001016 if c.pgo != nil {
1017 flags = c.pgo.flags(ctx, flags)
1018 }
Ivan Lozano074ec482018-11-21 08:59:37 -08001019 if c.xom != nil {
1020 flags = c.xom.flags(ctx, flags)
1021 }
Colin Crossca860ac2016-01-04 14:34:37 -08001022 for _, feature := range c.features {
1023 flags = feature.flags(ctx, flags)
1024 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001025 if ctx.Failed() {
1026 return
1027 }
1028
Colin Crossb98c8b02016-07-29 13:44:28 -07001029 flags.CFlags, _ = filterList(flags.CFlags, config.IllegalFlags)
1030 flags.CppFlags, _ = filterList(flags.CppFlags, config.IllegalFlags)
1031 flags.ConlyFlags, _ = filterList(flags.ConlyFlags, config.IllegalFlags)
Colin Cross3f40fa42015-01-30 17:27:36 -08001032
Fabien Sanglardd61f1f42017-01-10 16:21:22 -08001033 flags.GlobalFlags = append(flags.GlobalFlags, deps.Flags...)
Inseob Kim69378442019-06-03 19:10:47 +09001034
1035 for _, dir := range deps.IncludeDirs {
1036 flags.GlobalFlags = append(flags.GlobalFlags, "-I"+dir)
1037 }
1038 for _, dir := range deps.SystemIncludeDirs {
1039 flags.GlobalFlags = append(flags.GlobalFlags, "-isystem "+dir)
1040 }
1041
Fabien Sanglardd61f1f42017-01-10 16:21:22 -08001042 c.flags = flags
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -07001043 // We need access to all the flags seen by a source file.
1044 if c.sabi != nil {
1045 flags = c.sabi.flags(ctx, flags)
1046 }
Colin Crossca860ac2016-01-04 14:34:37 -08001047 // Optimization to reduce size of build.ninja
1048 // Replace the long list of flags for each file with a module-local variable
1049 ctx.Variable(pctx, "cflags", strings.Join(flags.CFlags, " "))
1050 ctx.Variable(pctx, "cppflags", strings.Join(flags.CppFlags, " "))
1051 ctx.Variable(pctx, "asflags", strings.Join(flags.AsFlags, " "))
1052 flags.CFlags = []string{"$cflags"}
1053 flags.CppFlags = []string{"$cppflags"}
1054 flags.AsFlags = []string{"$asflags"}
1055
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001056 var objs Objects
Colin Crossca860ac2016-01-04 14:34:37 -08001057 if c.compiler != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001058 objs = c.compiler.compile(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001059 if ctx.Failed() {
1060 return
1061 }
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001062 c.kytheFiles = objs.kytheFiles
Colin Cross3f40fa42015-01-30 17:27:36 -08001063 }
1064
Colin Crossca860ac2016-01-04 14:34:37 -08001065 if c.linker != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001066 outputFile := c.linker.link(ctx, flags, deps, objs)
Colin Crossca860ac2016-01-04 14:34:37 -08001067 if ctx.Failed() {
1068 return
1069 }
Colin Cross635c3b02016-05-18 15:37:25 -07001070 c.outputFile = android.OptionalPathForPath(outputFile)
Jiyong Parkb0788572018-12-20 22:10:17 +09001071
1072 // If a lib is directly included in any of the APEXes, unhide the stubs
1073 // variant having the latest version gets visible to make. In addition,
1074 // the non-stubs variant is renamed to <libname>.bootstrap. This is to
1075 // force anything in the make world to link against the stubs library.
1076 // (unless it is explicitly referenced via .bootstrap suffix or the
1077 // module is marked with 'bootstrap: true').
Nicolas Geoffrayc22c1bf2019-01-15 19:53:23 +00001078 if c.HasStubsVariants() &&
1079 android.DirectlyInAnyApex(ctx, ctx.baseModuleName()) &&
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001080 !c.inRecovery() && !c.useVndk() && !c.static() && !c.isCoverageVariant() &&
1081 c.IsStubs() {
Jiyong Parkb0788572018-12-20 22:10:17 +09001082 c.Properties.HideFromMake = false // unhide
1083 // Note: this is still non-installable
1084 }
Colin Crossce75d2c2016-10-06 16:12:58 -07001085 }
Colin Cross5049f022015-03-18 13:28:46 -07001086
Inseob Kim1f086e22019-05-09 13:29:15 +09001087 if c.installable() {
Colin Crossce75d2c2016-10-06 16:12:58 -07001088 c.installer.install(ctx, c.outputFile.Path())
1089 if ctx.Failed() {
1090 return
Colin Crossca860ac2016-01-04 14:34:37 -08001091 }
Dan Albertc403f7c2015-03-18 14:01:18 -07001092 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001093}
1094
Colin Cross0ea8ba82019-06-06 14:33:29 -07001095func (c *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001096 if c.cachedToolchain == nil {
Colin Crossb98c8b02016-07-29 13:44:28 -07001097 c.cachedToolchain = config.FindToolchain(ctx.Os(), ctx.Arch())
Colin Cross3f40fa42015-01-30 17:27:36 -08001098 }
Colin Crossca860ac2016-01-04 14:34:37 -08001099 return c.cachedToolchain
Colin Cross3f40fa42015-01-30 17:27:36 -08001100}
1101
Colin Crossca860ac2016-01-04 14:34:37 -08001102func (c *Module) begin(ctx BaseModuleContext) {
1103 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001104 c.compiler.compilerInit(ctx)
Colin Cross21b9a242015-03-24 14:15:58 -07001105 }
Colin Crossca860ac2016-01-04 14:34:37 -08001106 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001107 c.linker.linkerInit(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08001108 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001109 if c.stl != nil {
1110 c.stl.begin(ctx)
1111 }
Colin Cross16b23492016-01-06 14:41:07 -08001112 if c.sanitize != nil {
1113 c.sanitize.begin(ctx)
1114 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001115 if c.coverage != nil {
1116 c.coverage.begin(ctx)
1117 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001118 if c.sabi != nil {
1119 c.sabi.begin(ctx)
1120 }
Justin Yun8effde42017-06-23 19:24:43 +09001121 if c.vndkdep != nil {
1122 c.vndkdep.begin(ctx)
1123 }
Stephen Craneba090d12017-05-09 15:44:35 -07001124 if c.lto != nil {
1125 c.lto.begin(ctx)
1126 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001127 if c.pgo != nil {
1128 c.pgo.begin(ctx)
1129 }
Colin Crossca860ac2016-01-04 14:34:37 -08001130 for _, feature := range c.features {
1131 feature.begin(ctx)
1132 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001133 if ctx.useSdk() {
Dan Albertf5415d72017-08-17 16:19:59 -07001134 version, err := normalizeNdkApiLevel(ctx, ctx.sdkVersion(), ctx.Arch())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07001135 if err != nil {
1136 ctx.PropertyErrorf("sdk_version", err.Error())
1137 }
Nan Zhang0007d812017-11-07 10:57:05 -08001138 c.Properties.Sdk_version = StringPtr(version)
Dan Albert7fa7b2e2016-08-05 16:37:52 -07001139 }
Colin Crossca860ac2016-01-04 14:34:37 -08001140}
1141
Colin Cross37047f12016-12-13 17:06:13 -08001142func (c *Module) deps(ctx DepsContext) Deps {
Colin Crossc99deeb2016-04-11 15:06:20 -07001143 deps := Deps{}
1144
1145 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001146 deps = c.compiler.compilerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07001147 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00001148 // Add the PGO dependency (the clang_rt.profile runtime library), which
1149 // sometimes depends on symbols from libgcc, before libgcc gets added
1150 // in linkerDeps().
Pirama Arumuga Nainar49b53d52017-10-04 16:47:29 -07001151 if c.pgo != nil {
1152 deps = c.pgo.deps(ctx, deps)
1153 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001154 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001155 deps = c.linker.linkerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07001156 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001157 if c.stl != nil {
1158 deps = c.stl.deps(ctx, deps)
1159 }
Colin Cross16b23492016-01-06 14:41:07 -08001160 if c.sanitize != nil {
1161 deps = c.sanitize.deps(ctx, deps)
1162 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00001163 if c.coverage != nil {
1164 deps = c.coverage.deps(ctx, deps)
1165 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001166 if c.sabi != nil {
1167 deps = c.sabi.deps(ctx, deps)
1168 }
Justin Yun8effde42017-06-23 19:24:43 +09001169 if c.vndkdep != nil {
1170 deps = c.vndkdep.deps(ctx, deps)
1171 }
Stephen Craneba090d12017-05-09 15:44:35 -07001172 if c.lto != nil {
1173 deps = c.lto.deps(ctx, deps)
1174 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001175 for _, feature := range c.features {
1176 deps = feature.deps(ctx, deps)
1177 }
1178
Colin Crossb6715442017-10-24 11:13:31 -07001179 deps.WholeStaticLibs = android.LastUniqueStrings(deps.WholeStaticLibs)
1180 deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
1181 deps.LateStaticLibs = android.LastUniqueStrings(deps.LateStaticLibs)
1182 deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
1183 deps.LateSharedLibs = android.LastUniqueStrings(deps.LateSharedLibs)
1184 deps.HeaderLibs = android.LastUniqueStrings(deps.HeaderLibs)
Logan Chien43d34c32017-12-20 01:17:32 +08001185 deps.RuntimeLibs = android.LastUniqueStrings(deps.RuntimeLibs)
Colin Crossc99deeb2016-04-11 15:06:20 -07001186
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001187 for _, lib := range deps.ReexportSharedLibHeaders {
1188 if !inList(lib, deps.SharedLibs) {
1189 ctx.PropertyErrorf("export_shared_lib_headers", "Shared library not in shared_libs: '%s'", lib)
1190 }
1191 }
1192
1193 for _, lib := range deps.ReexportStaticLibHeaders {
1194 if !inList(lib, deps.StaticLibs) {
1195 ctx.PropertyErrorf("export_static_lib_headers", "Static library not in static_libs: '%s'", lib)
1196 }
1197 }
1198
Colin Cross5950f382016-12-13 12:50:57 -08001199 for _, lib := range deps.ReexportHeaderLibHeaders {
1200 if !inList(lib, deps.HeaderLibs) {
1201 ctx.PropertyErrorf("export_header_lib_headers", "Header library not in header_libs: '%s'", lib)
1202 }
1203 }
1204
Dan Willemsenb3454ab2016-09-28 17:34:58 -07001205 for _, gen := range deps.ReexportGeneratedHeaders {
1206 if !inList(gen, deps.GeneratedHeaders) {
1207 ctx.PropertyErrorf("export_generated_headers", "Generated header module not in generated_headers: '%s'", gen)
1208 }
1209 }
1210
Colin Crossc99deeb2016-04-11 15:06:20 -07001211 return deps
1212}
1213
Dan Albert7e9d2952016-08-04 13:02:36 -07001214func (c *Module) beginMutator(actx android.BottomUpMutatorContext) {
Colin Crossca860ac2016-01-04 14:34:37 -08001215 ctx := &baseModuleContext{
Colin Cross0ea8ba82019-06-06 14:33:29 -07001216 BaseModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08001217 moduleContextImpl: moduleContextImpl{
1218 mod: c,
1219 },
1220 }
1221 ctx.ctx = ctx
1222
Colin Crossca860ac2016-01-04 14:34:37 -08001223 c.begin(ctx)
Dan Albert7e9d2952016-08-04 13:02:36 -07001224}
1225
Jiyong Park7ed9de32018-10-15 22:25:07 +09001226// Split name#version into name and version
1227func stubsLibNameAndVersion(name string) (string, string) {
1228 if sharp := strings.LastIndex(name, "#"); sharp != -1 && sharp != len(name)-1 {
1229 version := name[sharp+1:]
1230 libname := name[:sharp]
1231 return libname, version
1232 }
1233 return name, ""
1234}
1235
Colin Cross1e676be2016-10-12 14:38:15 -07001236func (c *Module) DepsMutator(actx android.BottomUpMutatorContext) {
Colin Cross37047f12016-12-13 17:06:13 -08001237 ctx := &depsContext{
1238 BottomUpMutatorContext: actx,
Dan Albert7e9d2952016-08-04 13:02:36 -07001239 moduleContextImpl: moduleContextImpl{
1240 mod: c,
1241 },
1242 }
1243 ctx.ctx = ctx
Colin Crossca860ac2016-01-04 14:34:37 -08001244
Colin Crossc99deeb2016-04-11 15:06:20 -07001245 deps := c.deps(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08001246
Dan Albert914449f2016-06-17 16:45:24 -07001247 variantNdkLibs := []string{}
1248 variantLateNdkLibs := []string{}
Dan Willemsenb916b802017-03-19 13:44:32 -07001249 if ctx.Os() == android.Android {
Dan Albert914449f2016-06-17 16:45:24 -07001250 version := ctx.sdkVersion()
Dan Willemsen72d39932016-07-08 23:23:48 -07001251
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001252 // rewriteNdkLibs takes a list of names of shared libraries and scans it for three types
1253 // of names:
Dan Albert914449f2016-06-17 16:45:24 -07001254 //
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001255 // 1. Name of an NDK library that refers to a prebuilt module.
1256 // For each of these, it adds the name of the prebuilt module (which will be in
1257 // prebuilts/ndk) to the list of nonvariant libs.
1258 // 2. Name of an NDK library that refers to an ndk_library module.
1259 // For each of these, it adds the name of the ndk_library module to the list of
1260 // variant libs.
1261 // 3. Anything else (so anything that isn't an NDK library).
1262 // It adds these to the nonvariantLibs list.
Dan Albert914449f2016-06-17 16:45:24 -07001263 //
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001264 // The caller can then know to add the variantLibs dependencies differently from the
1265 // nonvariantLibs
Inseob Kim9516ee92019-05-09 10:56:13 +09001266
1267 llndkLibraries := llndkLibraries(actx.Config())
1268 vendorPublicLibraries := vendorPublicLibraries(actx.Config())
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001269 rewriteNdkLibs := func(list []string) (nonvariantLibs []string, variantLibs []string) {
1270 variantLibs = []string{}
1271 nonvariantLibs = []string{}
Dan Albert914449f2016-06-17 16:45:24 -07001272 for _, entry := range list {
Jiyong Park7ed9de32018-10-15 22:25:07 +09001273 // strip #version suffix out
1274 name, _ := stubsLibNameAndVersion(entry)
1275 if ctx.useSdk() && inList(name, ndkPrebuiltSharedLibraries) {
1276 if !inList(name, ndkMigratedLibs) {
1277 nonvariantLibs = append(nonvariantLibs, name+".ndk."+version)
Dan Albert914449f2016-06-17 16:45:24 -07001278 } else {
Jiyong Park7ed9de32018-10-15 22:25:07 +09001279 variantLibs = append(variantLibs, name+ndkLibrarySuffix)
Dan Albert914449f2016-06-17 16:45:24 -07001280 }
Inseob Kim9516ee92019-05-09 10:56:13 +09001281 } else if ctx.useVndk() && inList(name, *llndkLibraries) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09001282 nonvariantLibs = append(nonvariantLibs, name+llndkLibrarySuffix)
Inseob Kim9516ee92019-05-09 10:56:13 +09001283 } else if (ctx.Platform() || ctx.ProductSpecific()) && inList(name, *vendorPublicLibraries) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09001284 vendorPublicLib := name + vendorPublicLibrarySuffix
Jiyong Park374510b2018-03-19 18:23:01 +09001285 if actx.OtherModuleExists(vendorPublicLib) {
1286 nonvariantLibs = append(nonvariantLibs, vendorPublicLib)
1287 } else {
1288 // This can happen if vendor_public_library module is defined in a
1289 // namespace that isn't visible to the current module. In that case,
1290 // link to the original library.
Jiyong Park7ed9de32018-10-15 22:25:07 +09001291 nonvariantLibs = append(nonvariantLibs, name)
Jiyong Park374510b2018-03-19 18:23:01 +09001292 }
Dan Albert914449f2016-06-17 16:45:24 -07001293 } else {
Jiyong Park7ed9de32018-10-15 22:25:07 +09001294 // put name#version back
Dan Willemsen7cbf5f82017-03-28 00:08:30 -07001295 nonvariantLibs = append(nonvariantLibs, entry)
Dan Willemsen72d39932016-07-08 23:23:48 -07001296 }
1297 }
Dan Albert914449f2016-06-17 16:45:24 -07001298 return nonvariantLibs, variantLibs
Dan Willemsen72d39932016-07-08 23:23:48 -07001299 }
1300
Dan Albert914449f2016-06-17 16:45:24 -07001301 deps.SharedLibs, variantNdkLibs = rewriteNdkLibs(deps.SharedLibs)
1302 deps.LateSharedLibs, variantLateNdkLibs = rewriteNdkLibs(deps.LateSharedLibs)
Jiyong Park4c35af02017-07-05 13:41:55 +09001303 deps.ReexportSharedLibHeaders, _ = rewriteNdkLibs(deps.ReexportSharedLibHeaders)
Dan Willemsen72d39932016-07-08 23:23:48 -07001304 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001305
Jiyong Park7e636d02019-01-28 16:16:54 +09001306 buildStubs := false
Jiyong Park7ed9de32018-10-15 22:25:07 +09001307 if c.linker != nil {
1308 if library, ok := c.linker.(*libraryDecorator); ok {
1309 if library.buildStubs() {
Jiyong Park7e636d02019-01-28 16:16:54 +09001310 buildStubs = true
Jiyong Park7ed9de32018-10-15 22:25:07 +09001311 }
1312 }
1313 }
1314
Colin Cross32ec36c2016-12-15 07:39:51 -08001315 for _, lib := range deps.HeaderLibs {
1316 depTag := headerDepTag
1317 if inList(lib, deps.ReexportHeaderLibHeaders) {
1318 depTag = headerExportDepTag
1319 }
Jiyong Park7e636d02019-01-28 16:16:54 +09001320 if buildStubs {
Jiyong Park7e636d02019-01-28 16:16:54 +09001321 actx.AddFarVariationDependencies([]blueprint.Variation{
1322 {Mutator: "arch", Variation: ctx.Target().String()},
Jiyong Park3b1746a2019-01-29 11:15:04 +09001323 {Mutator: "image", Variation: c.imageVariation()},
Jiyong Park7e636d02019-01-28 16:16:54 +09001324 }, depTag, lib)
1325 } else {
1326 actx.AddVariationDependencies(nil, depTag, lib)
1327 }
1328 }
1329
1330 if buildStubs {
1331 // Stubs lib does not have dependency to other static/shared libraries.
1332 // Don't proceed.
1333 return
Colin Cross32ec36c2016-12-15 07:39:51 -08001334 }
Colin Cross5950f382016-12-13 12:50:57 -08001335
Inseob Kimc0907f12019-02-08 21:00:45 +09001336 syspropImplLibraries := syspropImplLibraries(actx.Config())
1337
Jiyong Park5d1598f2019-02-25 22:14:17 +09001338 for _, lib := range deps.WholeStaticLibs {
1339 depTag := wholeStaticDepTag
1340 if impl, ok := syspropImplLibraries[lib]; ok {
1341 lib = impl
1342 }
1343 actx.AddVariationDependencies([]blueprint.Variation{
1344 {Mutator: "link", Variation: "static"},
1345 }, depTag, lib)
1346 }
1347
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001348 for _, lib := range deps.StaticLibs {
1349 depTag := staticDepTag
1350 if inList(lib, deps.ReexportStaticLibHeaders) {
1351 depTag = staticExportDepTag
1352 }
Inseob Kimc0907f12019-02-08 21:00:45 +09001353
1354 if impl, ok := syspropImplLibraries[lib]; ok {
1355 lib = impl
1356 }
1357
Dan Willemsen59339a22018-07-22 21:18:45 -07001358 actx.AddVariationDependencies([]blueprint.Variation{
1359 {Mutator: "link", Variation: "static"},
1360 }, depTag, lib)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001361 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001362
Dan Willemsen59339a22018-07-22 21:18:45 -07001363 actx.AddVariationDependencies([]blueprint.Variation{
1364 {Mutator: "link", Variation: "static"},
1365 }, lateStaticDepTag, deps.LateStaticLibs...)
Colin Crossc99deeb2016-04-11 15:06:20 -07001366
Jiyong Park25fc6a92018-11-18 18:02:45 +09001367 addSharedLibDependencies := func(depTag dependencyTag, name string, version string) {
1368 var variations []blueprint.Variation
1369 variations = append(variations, blueprint.Variation{Mutator: "link", Variation: "shared"})
Jiyong Park0fefdea2018-12-13 12:01:31 +09001370 versionVariantAvail := !ctx.useVndk() && !c.inRecovery()
Jiyong Park25fc6a92018-11-18 18:02:45 +09001371 if version != "" && versionVariantAvail {
1372 // Version is explicitly specified. i.e. libFoo#30
1373 variations = append(variations, blueprint.Variation{Mutator: "version", Variation: version})
1374 depTag.explicitlyVersioned = true
1375 }
1376 actx.AddVariationDependencies(variations, depTag, name)
1377
1378 // If the version is not specified, add dependency to the latest stubs library.
1379 // The stubs library will be used when the depending module is built for APEX and
1380 // the dependent module is not in the same APEX.
1381 latestVersion := latestStubsVersionFor(actx.Config(), name)
1382 if version == "" && latestVersion != "" && versionVariantAvail {
1383 actx.AddVariationDependencies([]blueprint.Variation{
1384 {Mutator: "link", Variation: "shared"},
1385 {Mutator: "version", Variation: latestVersion},
1386 }, depTag, name)
1387 // Note that depTag.explicitlyVersioned is false in this case.
1388 }
1389 }
1390
Jiyong Park7ed9de32018-10-15 22:25:07 +09001391 // shared lib names without the #version suffix
1392 var sharedLibNames []string
1393
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001394 for _, lib := range deps.SharedLibs {
1395 depTag := sharedDepTag
1396 if inList(lib, deps.ReexportSharedLibHeaders) {
1397 depTag = sharedExportDepTag
1398 }
Inseob Kimc0907f12019-02-08 21:00:45 +09001399
1400 if impl, ok := syspropImplLibraries[lib]; ok {
1401 lib = impl
1402 }
1403
1404 name, version := stubsLibNameAndVersion(lib)
1405 sharedLibNames = append(sharedLibNames, name)
1406
Jiyong Park25fc6a92018-11-18 18:02:45 +09001407 addSharedLibDependencies(depTag, name, version)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001408 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001409
Jiyong Park7ed9de32018-10-15 22:25:07 +09001410 for _, lib := range deps.LateSharedLibs {
Jiyong Park25fc6a92018-11-18 18:02:45 +09001411 if inList(lib, sharedLibNames) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09001412 // This is to handle the case that some of the late shared libs (libc, libdl, libm, ...)
1413 // are added also to SharedLibs with version (e.g., libc#10). If not skipped, we will be
1414 // linking against both the stubs lib and the non-stubs lib at the same time.
1415 continue
1416 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09001417 addSharedLibDependencies(lateSharedDepTag, lib, "")
Jiyong Park7ed9de32018-10-15 22:25:07 +09001418 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001419
Dan Willemsen59339a22018-07-22 21:18:45 -07001420 actx.AddVariationDependencies([]blueprint.Variation{
1421 {Mutator: "link", Variation: "shared"},
1422 }, runtimeDepTag, deps.RuntimeLibs...)
Logan Chien43d34c32017-12-20 01:17:32 +08001423
Colin Cross68861832016-07-08 10:41:41 -07001424 actx.AddDependency(c, genSourceDepTag, deps.GeneratedSources...)
Dan Willemsenb3454ab2016-09-28 17:34:58 -07001425
1426 for _, gen := range deps.GeneratedHeaders {
1427 depTag := genHeaderDepTag
1428 if inList(gen, deps.ReexportGeneratedHeaders) {
1429 depTag = genHeaderExportDepTag
1430 }
1431 actx.AddDependency(c, depTag, gen)
1432 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07001433
Colin Cross42d48b72018-08-29 14:10:52 -07001434 actx.AddVariationDependencies(nil, objDepTag, deps.ObjFiles...)
Colin Crossc99deeb2016-04-11 15:06:20 -07001435
1436 if deps.CrtBegin != "" {
Colin Cross42d48b72018-08-29 14:10:52 -07001437 actx.AddVariationDependencies(nil, crtBeginDepTag, deps.CrtBegin)
Colin Crossca860ac2016-01-04 14:34:37 -08001438 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001439 if deps.CrtEnd != "" {
Colin Cross42d48b72018-08-29 14:10:52 -07001440 actx.AddVariationDependencies(nil, crtEndDepTag, deps.CrtEnd)
Colin Cross21b9a242015-03-24 14:15:58 -07001441 }
Dan Willemsena0790e32018-10-12 00:24:23 -07001442 if deps.LinkerFlagsFile != "" {
1443 actx.AddDependency(c, linkerFlagsDepTag, deps.LinkerFlagsFile)
1444 }
1445 if deps.DynamicLinker != "" {
1446 actx.AddDependency(c, dynamicLinkerDepTag, deps.DynamicLinker)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07001447 }
Dan Albert914449f2016-06-17 16:45:24 -07001448
1449 version := ctx.sdkVersion()
1450 actx.AddVariationDependencies([]blueprint.Variation{
Dan Willemsen59339a22018-07-22 21:18:45 -07001451 {Mutator: "ndk_api", Variation: version},
1452 {Mutator: "link", Variation: "shared"},
1453 }, ndkStubDepTag, variantNdkLibs...)
Dan Albert914449f2016-06-17 16:45:24 -07001454 actx.AddVariationDependencies([]blueprint.Variation{
Dan Willemsen59339a22018-07-22 21:18:45 -07001455 {Mutator: "ndk_api", Variation: version},
1456 {Mutator: "link", Variation: "shared"},
1457 }, ndkLateStubDepTag, variantLateNdkLibs...)
Logan Chienf3511742017-10-31 18:04:35 +08001458
1459 if vndkdep := c.vndkdep; vndkdep != nil {
1460 if vndkdep.isVndkExt() {
1461 baseModuleMode := vendorMode
1462 if actx.DeviceConfig().VndkVersion() == "" {
1463 baseModuleMode = coreMode
1464 }
1465 actx.AddVariationDependencies([]blueprint.Variation{
Dan Willemsen59339a22018-07-22 21:18:45 -07001466 {Mutator: "image", Variation: baseModuleMode},
1467 {Mutator: "link", Variation: "shared"},
1468 }, vndkExtDepTag, vndkdep.getVndkExtendsModuleName())
Logan Chienf3511742017-10-31 18:04:35 +08001469 }
1470 }
Colin Cross6362e272015-10-29 15:25:03 -07001471}
Colin Cross21b9a242015-03-24 14:15:58 -07001472
Colin Crosse40b4ea2018-10-02 22:25:58 -07001473func BeginMutator(ctx android.BottomUpMutatorContext) {
Dan Albert7e9d2952016-08-04 13:02:36 -07001474 if c, ok := ctx.Module().(*Module); ok && c.Enabled() {
1475 c.beginMutator(ctx)
1476 }
1477}
1478
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001479// Whether a module can link to another module, taking into
1480// account NDK linking.
Logan Chienf3511742017-10-31 18:04:35 +08001481func checkLinkType(ctx android.ModuleContext, from *Module, to *Module, tag dependencyTag) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001482 if from.Target().Os != android.Android {
1483 // Host code is not restricted
1484 return
1485 }
1486 if from.Properties.UseVndk {
1487 // Though vendor code is limited by the vendor mutator,
1488 // each vendor-available module needs to check
1489 // link-type for VNDK.
1490 if from.vndkdep != nil {
Logan Chienf3511742017-10-31 18:04:35 +08001491 from.vndkdep.vndkCheckLinkType(ctx, to, tag)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001492 }
1493 return
1494 }
Nan Zhang0007d812017-11-07 10:57:05 -08001495 if String(from.Properties.Sdk_version) == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001496 // Platform code can link to anything
1497 return
1498 }
Jiyong Parkf9332f12018-02-01 00:54:12 +09001499 if from.inRecovery() {
1500 // Recovery code is not NDK
1501 return
1502 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001503 if _, ok := to.linker.(*toolchainLibraryDecorator); ok {
1504 // These are always allowed
1505 return
1506 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001507 if _, ok := to.linker.(*ndkPrebuiltStlLinker); ok {
1508 // These are allowed, but they don't set sdk_version
1509 return
1510 }
1511 if _, ok := to.linker.(*stubDecorator); ok {
1512 // These aren't real libraries, but are the stub shared libraries that are included in
1513 // the NDK.
1514 return
1515 }
Logan Chien834b9a62019-01-14 15:39:03 +08001516
1517 if strings.HasPrefix(ctx.ModuleName(), "libclang_rt.") && to.Name() == "libc++" {
1518 // Bug: http://b/121358700 - Allow libclang_rt.* shared libraries (with sdk_version)
1519 // to link to libc++ (non-NDK and without sdk_version).
1520 return
1521 }
1522
Nan Zhang0007d812017-11-07 10:57:05 -08001523 if String(to.Properties.Sdk_version) == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001524 // NDK code linking to platform code is never okay.
1525 ctx.ModuleErrorf("depends on non-NDK-built library %q",
1526 ctx.OtherModuleName(to))
Dan Willemsen155d17c2019-02-06 18:30:02 -08001527 return
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001528 }
1529
1530 // At this point we know we have two NDK libraries, but we need to
1531 // check that we're not linking against anything built against a higher
1532 // API level, as it is only valid to link against older or equivalent
1533 // APIs.
1534
Inseob Kim01a28722018-04-11 09:48:45 +09001535 // Current can link against anything.
1536 if String(from.Properties.Sdk_version) != "current" {
1537 // Otherwise we need to check.
1538 if String(to.Properties.Sdk_version) == "current" {
1539 // Current can't be linked against by anything else.
1540 ctx.ModuleErrorf("links %q built against newer API version %q",
1541 ctx.OtherModuleName(to), "current")
1542 } else {
1543 fromApi, err := strconv.Atoi(String(from.Properties.Sdk_version))
1544 if err != nil {
1545 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09001546 "Invalid sdk_version value (must be int or current): %q",
Inseob Kim01a28722018-04-11 09:48:45 +09001547 String(from.Properties.Sdk_version))
1548 }
1549 toApi, err := strconv.Atoi(String(to.Properties.Sdk_version))
1550 if err != nil {
1551 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09001552 "Invalid sdk_version value (must be int or current): %q",
Inseob Kim01a28722018-04-11 09:48:45 +09001553 String(to.Properties.Sdk_version))
1554 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001555
Inseob Kim01a28722018-04-11 09:48:45 +09001556 if toApi > fromApi {
1557 ctx.ModuleErrorf("links %q built against newer API version %q",
1558 ctx.OtherModuleName(to), String(to.Properties.Sdk_version))
1559 }
1560 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001561 }
Dan Albert202fe492017-12-15 13:56:59 -08001562
1563 // Also check that the two STL choices are compatible.
1564 fromStl := from.stl.Properties.SelectedStl
1565 toStl := to.stl.Properties.SelectedStl
1566 if fromStl == "" || toStl == "" {
1567 // Libraries that don't use the STL are unrestricted.
Inseob Kimda2171a2018-04-11 15:41:38 +09001568 } else if fromStl == "ndk_system" || toStl == "ndk_system" {
Dan Albert202fe492017-12-15 13:56:59 -08001569 // We can be permissive with the system "STL" since it is only the C++
1570 // ABI layer, but in the future we should make sure that everyone is
1571 // using either libc++ or nothing.
Colin Crossb60190a2018-09-04 16:28:17 -07001572 } else if getNdkStlFamily(from) != getNdkStlFamily(to) {
Dan Albert202fe492017-12-15 13:56:59 -08001573 ctx.ModuleErrorf("uses %q and depends on %q which uses incompatible %q",
1574 from.stl.Properties.SelectedStl, ctx.OtherModuleName(to),
1575 to.stl.Properties.SelectedStl)
1576 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001577}
1578
Jiyong Park5fb8c102018-04-09 12:03:06 +09001579// Tests whether the dependent library is okay to be double loaded inside a single process.
Jooyung Hana70f0672019-01-18 15:20:43 +09001580// If a library has a vendor variant and is a (transitive) dependency of an LLNDK library,
1581// it is subject to be double loaded. Such lib should be explicitly marked as double_loadable: true
Jiyong Park5fb8c102018-04-09 12:03:06 +09001582// or as vndk-sp (vndk: { enabled: true, support_system_process: true}).
Jooyung Hana70f0672019-01-18 15:20:43 +09001583func checkDoubleLoadableLibraries(ctx android.TopDownMutatorContext) {
Inseob Kim9516ee92019-05-09 10:56:13 +09001584 llndkLibraries := llndkLibraries(ctx.Config())
Jooyung Hana70f0672019-01-18 15:20:43 +09001585 check := func(child, parent android.Module) bool {
1586 to, ok := child.(*Module)
1587 if !ok {
1588 // follow thru cc.Defaults, etc.
1589 return true
1590 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09001591
Jooyung Hana70f0672019-01-18 15:20:43 +09001592 if lib, ok := to.linker.(*libraryDecorator); !ok || !lib.shared() {
1593 return false
Jiyong Park5fb8c102018-04-09 12:03:06 +09001594 }
Jooyung Hana70f0672019-01-18 15:20:43 +09001595
1596 // if target lib has no vendor variant, keep checking dependency graph
1597 if !to.hasVendorVariant() {
1598 return true
Jiyong Park5fb8c102018-04-09 12:03:06 +09001599 }
Jooyung Hana70f0672019-01-18 15:20:43 +09001600
Inseob Kim9516ee92019-05-09 10:56:13 +09001601 if to.isVndkSp() || inList(child.Name(), *llndkLibraries) || Bool(to.VendorProperties.Double_loadable) {
Jooyung Hana70f0672019-01-18 15:20:43 +09001602 return false
1603 }
1604
1605 var stringPath []string
1606 for _, m := range ctx.GetWalkPath() {
1607 stringPath = append(stringPath, m.Name())
1608 }
1609 ctx.ModuleErrorf("links a library %q which is not LL-NDK, "+
1610 "VNDK-SP, or explicitly marked as 'double_loadable:true'. "+
1611 "(dependency: %s)", ctx.OtherModuleName(to), strings.Join(stringPath, " -> "))
1612 return false
1613 }
1614 if module, ok := ctx.Module().(*Module); ok {
1615 if lib, ok := module.linker.(*libraryDecorator); ok && lib.shared() {
Inseob Kim9516ee92019-05-09 10:56:13 +09001616 if inList(ctx.ModuleName(), *llndkLibraries) || Bool(module.VendorProperties.Double_loadable) {
Jooyung Hana70f0672019-01-18 15:20:43 +09001617 ctx.WalkDeps(check)
1618 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09001619 }
1620 }
1621}
1622
Colin Crossc99deeb2016-04-11 15:06:20 -07001623// Convert dependencies to paths. Returns a PathDeps containing paths
Colin Cross635c3b02016-05-18 15:37:25 -07001624func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
Colin Crossca860ac2016-01-04 14:34:37 -08001625 var depPaths PathDeps
Colin Crossca860ac2016-01-04 14:34:37 -08001626
Jeff Gaston294356f2017-09-27 17:05:30 -07001627 directStaticDeps := []*Module{}
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -08001628 directSharedDeps := []*Module{}
Jeff Gaston294356f2017-09-27 17:05:30 -07001629
Inseob Kim9516ee92019-05-09 10:56:13 +09001630 llndkLibraries := llndkLibraries(ctx.Config())
1631 vendorPublicLibraries := vendorPublicLibraries(ctx.Config())
1632
Inseob Kim69378442019-06-03 19:10:47 +09001633 reexportExporter := func(exporter exportedFlagsProducer) {
1634 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, exporter.exportedDirs()...)
1635 depPaths.ReexportedSystemDirs = append(depPaths.ReexportedSystemDirs, exporter.exportedSystemDirs()...)
1636 depPaths.ReexportedFlags = append(depPaths.ReexportedFlags, exporter.exportedFlags()...)
1637 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, exporter.exportedDeps()...)
1638 }
1639
Colin Crossd11fcda2017-10-23 17:59:01 -07001640 ctx.VisitDirectDeps(func(dep android.Module) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001641 depName := ctx.OtherModuleName(dep)
1642 depTag := ctx.OtherModuleDependencyTag(dep)
Dan Albert9e10cd42016-08-03 14:12:14 -07001643
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001644 ccDep, _ := dep.(*Module)
1645 if ccDep == nil {
1646 // handling for a few module types that aren't cc Module but that are also supported
1647 switch depTag {
Dan Willemsenb40aab62016-04-20 14:21:14 -07001648 case genSourceDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001649 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenb40aab62016-04-20 14:21:14 -07001650 depPaths.GeneratedSources = append(depPaths.GeneratedSources,
1651 genRule.GeneratedSourceFiles()...)
1652 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001653 ctx.ModuleErrorf("module %q is not a gensrcs or genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07001654 }
Colin Crosse90bfd12017-04-26 16:59:26 -07001655 // Support exported headers from a generated_sources dependency
1656 fallthrough
Dan Willemsenb3454ab2016-09-28 17:34:58 -07001657 case genHeaderDepTag, genHeaderExportDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001658 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenb40aab62016-04-20 14:21:14 -07001659 depPaths.GeneratedHeaders = append(depPaths.GeneratedHeaders,
Dan Willemsen9da9d492018-02-21 18:28:18 -08001660 genRule.GeneratedDeps()...)
Inseob Kim69378442019-06-03 19:10:47 +09001661 dirs := genRule.GeneratedHeaderDirs().Strings()
1662 depPaths.IncludeDirs = append(depPaths.IncludeDirs, dirs...)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001663 if depTag == genHeaderExportDepTag {
Inseob Kim69378442019-06-03 19:10:47 +09001664 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, dirs...)
1665 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, genRule.GeneratedDeps()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07001666 // Add these re-exported flags to help header-abi-dumper to infer the abi exported by a library.
Inseob Kim69378442019-06-03 19:10:47 +09001667 c.sabi.Properties.ReexportedIncludes = append(c.sabi.Properties.ReexportedIncludes, dirs...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07001668
Dan Willemsenb3454ab2016-09-28 17:34:58 -07001669 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07001670 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001671 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07001672 }
Dan Willemsena0790e32018-10-12 00:24:23 -07001673 case linkerFlagsDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001674 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenc77a0b32017-09-18 23:19:12 -07001675 files := genRule.GeneratedSourceFiles()
1676 if len(files) == 1 {
Dan Willemsena0790e32018-10-12 00:24:23 -07001677 depPaths.LinkerFlagsFile = android.OptionalPathForPath(files[0])
Dan Willemsenc77a0b32017-09-18 23:19:12 -07001678 } else if len(files) > 1 {
Dan Willemsena0790e32018-10-12 00:24:23 -07001679 ctx.ModuleErrorf("module %q can only generate a single file if used for a linker flag file", depName)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07001680 }
1681 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001682 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07001683 }
Colin Crossca860ac2016-01-04 14:34:37 -08001684 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001685 return
1686 }
1687
Colin Crossfe17f6f2019-03-28 19:30:56 -07001688 if depTag == android.ProtoPluginDepTag {
1689 return
1690 }
1691
Colin Crossd11fcda2017-10-23 17:59:01 -07001692 if dep.Target().Os != ctx.Os() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001693 ctx.ModuleErrorf("OS mismatch between %q and %q", ctx.ModuleName(), depName)
1694 return
1695 }
Colin Crossd11fcda2017-10-23 17:59:01 -07001696 if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001697 ctx.ModuleErrorf("Arch mismatch between %q and %q", ctx.ModuleName(), depName)
Colin Crossa1ad8d12016-06-01 17:09:44 -07001698 return
1699 }
1700
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001701 // re-exporting flags
1702 if depTag == reuseObjTag {
1703 if l, ok := ccDep.compiler.(libraryInterface); ok {
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -08001704 c.staticVariant = ccDep
Inseob Kim69378442019-06-03 19:10:47 +09001705 objs, exporter := l.reuseObjs()
Colin Cross10d22312017-05-03 11:01:58 -07001706 depPaths.Objs = depPaths.Objs.Append(objs)
Inseob Kim69378442019-06-03 19:10:47 +09001707 reexportExporter(exporter)
Colin Crossbba99042016-11-23 15:45:05 -08001708 return
1709 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001710 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09001711
Jiyong Parke4bb9862019-02-01 00:31:10 +09001712 if depTag == staticVariantTag {
1713 if _, ok := ccDep.compiler.(libraryInterface); ok {
1714 c.staticVariant = ccDep
1715 return
1716 }
1717 }
1718
Jiyong Park25fc6a92018-11-18 18:02:45 +09001719 // Extract explicitlyVersioned field from the depTag and reset it inside the struct.
1720 // Otherwise, sharedDepTag and lateSharedDepTag with explicitlyVersioned set to true
1721 // won't be matched to sharedDepTag and lateSharedDepTag.
1722 explicitlyVersioned := false
1723 if t, ok := depTag.(dependencyTag); ok {
1724 explicitlyVersioned = t.explicitlyVersioned
1725 t.explicitlyVersioned = false
1726 depTag = t
1727 }
1728
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001729 if t, ok := depTag.(dependencyTag); ok && t.library {
Jiyong Park16e91a02018-12-20 18:18:08 +09001730 depIsStatic := false
1731 switch depTag {
1732 case staticDepTag, staticExportDepTag, lateStaticDepTag, wholeStaticDepTag:
1733 depIsStatic = true
1734 }
1735 if dependentLibrary, ok := ccDep.linker.(*libraryDecorator); ok && !depIsStatic {
Jiyong Park25fc6a92018-11-18 18:02:45 +09001736 depIsStubs := dependentLibrary.buildStubs()
1737 depHasStubs := ccDep.HasStubsVariants()
Jiyong Park0ddfcd12018-12-11 01:35:25 +09001738 depInSameApex := android.DirectlyInApex(c.ApexName(), depName)
Nicolas Geoffrayc22c1bf2019-01-15 19:53:23 +00001739 depInPlatform := !android.DirectlyInAnyApex(ctx, depName)
Jiyong Park25fc6a92018-11-18 18:02:45 +09001740
1741 var useThisDep bool
1742 if depIsStubs && explicitlyVersioned {
1743 // Always respect dependency to the versioned stubs (i.e. libX#10)
1744 useThisDep = true
1745 } else if !depHasStubs {
1746 // Use non-stub variant if that is the only choice
1747 // (i.e. depending on a lib without stubs.version property)
1748 useThisDep = true
1749 } else if c.IsForPlatform() {
1750 // If not building for APEX, use stubs only when it is from
1751 // an APEX (and not from platform)
1752 useThisDep = (depInPlatform != depIsStubs)
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001753 if c.inRecovery() || c.bootstrap() {
Jiyong Parkb0788572018-12-20 22:10:17 +09001754 // However, for recovery or bootstrap modules,
Jiyong Park25fc6a92018-11-18 18:02:45 +09001755 // always link to non-stub variant
1756 useThisDep = !depIsStubs
1757 }
1758 } else {
1759 // If building for APEX, use stubs only when it is not from
1760 // the same APEX
1761 useThisDep = (depInSameApex != depIsStubs)
1762 }
1763
1764 if !useThisDep {
1765 return // stop processing this dep
1766 }
1767 }
1768
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001769 if i, ok := ccDep.linker.(exportedFlagsProducer); ok {
Inseob Kim69378442019-06-03 19:10:47 +09001770 depPaths.IncludeDirs = append(depPaths.IncludeDirs, i.exportedDirs()...)
1771 depPaths.SystemIncludeDirs = append(depPaths.SystemIncludeDirs, i.exportedSystemDirs()...)
1772 depPaths.GeneratedHeaders = append(depPaths.GeneratedHeaders, i.exportedDeps()...)
1773 depPaths.Flags = append(depPaths.Flags, i.exportedFlags()...)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001774
1775 if t.reexportFlags {
Inseob Kim69378442019-06-03 19:10:47 +09001776 reexportExporter(i)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07001777 // Add these re-exported flags to help header-abi-dumper to infer the abi exported by a library.
Jayant Chowdharyaf6eb712017-08-23 16:08:29 -07001778 // Re-exported shared library headers must be included as well since they can help us with type information
1779 // about template instantiations (instantiated from their headers).
Inseob Kim69378442019-06-03 19:10:47 +09001780 // -isystem headers are not included since for bionic libraries, abi-filtering is taken care of by version
1781 // scripts.
1782 c.sabi.Properties.ReexportedIncludes = append(
1783 c.sabi.Properties.ReexportedIncludes, i.exportedDirs()...)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001784 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001785 }
Dan Willemsena96ff642016-06-07 12:34:45 -07001786
Logan Chienf3511742017-10-31 18:04:35 +08001787 checkLinkType(ctx, c, ccDep, t)
Colin Crossc99deeb2016-04-11 15:06:20 -07001788 }
1789
Colin Cross26c34ed2016-09-30 17:10:16 -07001790 var ptr *android.Paths
Colin Cross635c3b02016-05-18 15:37:25 -07001791 var depPtr *android.Paths
Colin Crossc99deeb2016-04-11 15:06:20 -07001792
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001793 linkFile := ccDep.outputFile
Colin Cross26c34ed2016-09-30 17:10:16 -07001794 depFile := android.OptionalPath{}
1795
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001796 switch depTag {
Dan Albert914449f2016-06-17 16:45:24 -07001797 case ndkStubDepTag, sharedDepTag, sharedExportDepTag:
Colin Cross26c34ed2016-09-30 17:10:16 -07001798 ptr = &depPaths.SharedLibs
1799 depPtr = &depPaths.SharedLibsDeps
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001800 depFile = ccDep.linker.(libraryInterface).toc()
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -08001801 directSharedDeps = append(directSharedDeps, ccDep)
Jiyong Park64a44f22019-01-18 14:37:08 +09001802 case earlySharedDepTag:
1803 ptr = &depPaths.EarlySharedLibs
1804 depPtr = &depPaths.EarlySharedLibsDeps
1805 depFile = ccDep.linker.(libraryInterface).toc()
1806 directSharedDeps = append(directSharedDeps, ccDep)
Dan Albert914449f2016-06-17 16:45:24 -07001807 case lateSharedDepTag, ndkLateStubDepTag:
Colin Cross26c34ed2016-09-30 17:10:16 -07001808 ptr = &depPaths.LateSharedLibs
1809 depPtr = &depPaths.LateSharedLibsDeps
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001810 depFile = ccDep.linker.(libraryInterface).toc()
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001811 case staticDepTag, staticExportDepTag:
Jeff Gaston294356f2017-09-27 17:05:30 -07001812 ptr = nil
1813 directStaticDeps = append(directStaticDeps, ccDep)
Colin Crossc99deeb2016-04-11 15:06:20 -07001814 case lateStaticDepTag:
Colin Cross26c34ed2016-09-30 17:10:16 -07001815 ptr = &depPaths.LateStaticLibs
Colin Crossc99deeb2016-04-11 15:06:20 -07001816 case wholeStaticDepTag:
Colin Cross26c34ed2016-09-30 17:10:16 -07001817 ptr = &depPaths.WholeStaticLibs
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001818 staticLib, ok := ccDep.linker.(libraryInterface)
Colin Crossb916a382016-07-29 17:28:03 -07001819 if !ok || !staticLib.static() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001820 ctx.ModuleErrorf("module %q not a static library", depName)
Colin Crossc99deeb2016-04-11 15:06:20 -07001821 return
1822 }
1823
1824 if missingDeps := staticLib.getWholeStaticMissingDeps(); missingDeps != nil {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001825 postfix := " (required by " + ctx.OtherModuleName(dep) + ")"
Colin Crossc99deeb2016-04-11 15:06:20 -07001826 for i := range missingDeps {
1827 missingDeps[i] += postfix
1828 }
1829 ctx.AddMissingDependencies(missingDeps)
1830 }
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001831 depPaths.WholeStaticLibObjs = depPaths.WholeStaticLibObjs.Append(staticLib.objs())
Colin Cross5950f382016-12-13 12:50:57 -08001832 case headerDepTag:
1833 // Nothing
Colin Crossc99deeb2016-04-11 15:06:20 -07001834 case objDepTag:
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001835 depPaths.Objs.objFiles = append(depPaths.Objs.objFiles, linkFile.Path())
Colin Crossc99deeb2016-04-11 15:06:20 -07001836 case crtBeginDepTag:
Colin Cross26c34ed2016-09-30 17:10:16 -07001837 depPaths.CrtBegin = linkFile
Colin Crossc99deeb2016-04-11 15:06:20 -07001838 case crtEndDepTag:
Colin Cross26c34ed2016-09-30 17:10:16 -07001839 depPaths.CrtEnd = linkFile
Dan Willemsena0790e32018-10-12 00:24:23 -07001840 case dynamicLinkerDepTag:
1841 depPaths.DynamicLinker = linkFile
Colin Crossc99deeb2016-04-11 15:06:20 -07001842 }
1843
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001844 switch depTag {
Dan Willemsen581341d2017-02-09 16:16:31 -08001845 case staticDepTag, staticExportDepTag, lateStaticDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001846 staticLib, ok := ccDep.linker.(libraryInterface)
Dan Willemsen581341d2017-02-09 16:16:31 -08001847 if !ok || !staticLib.static() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001848 ctx.ModuleErrorf("module %q not a static library", depName)
Dan Willemsen581341d2017-02-09 16:16:31 -08001849 return
1850 }
1851
1852 // When combining coverage files for shared libraries and executables, coverage files
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001853 // in static libraries act as if they were whole static libraries. The same goes for
1854 // source based Abi dump files.
Dan Willemsen581341d2017-02-09 16:16:31 -08001855 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
1856 staticLib.objs().coverageFiles...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001857 depPaths.StaticLibObjs.sAbiDumpFiles = append(depPaths.StaticLibObjs.sAbiDumpFiles,
1858 staticLib.objs().sAbiDumpFiles...)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001859
Dan Willemsen581341d2017-02-09 16:16:31 -08001860 }
1861
Colin Cross26c34ed2016-09-30 17:10:16 -07001862 if ptr != nil {
Colin Crossce75d2c2016-10-06 16:12:58 -07001863 if !linkFile.Valid() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001864 ctx.ModuleErrorf("module %q missing output file", depName)
Colin Crossce75d2c2016-10-06 16:12:58 -07001865 return
1866 }
Colin Cross26c34ed2016-09-30 17:10:16 -07001867 *ptr = append(*ptr, linkFile.Path())
1868 }
1869
Colin Crossc99deeb2016-04-11 15:06:20 -07001870 if depPtr != nil {
Colin Cross26c34ed2016-09-30 17:10:16 -07001871 dep := depFile
1872 if !dep.Valid() {
1873 dep = linkFile
1874 }
1875 *depPtr = append(*depPtr, dep.Path())
Colin Crossca860ac2016-01-04 14:34:37 -08001876 }
Jiyong Park27b188b2017-07-18 13:23:39 +09001877
Logan Chien43d34c32017-12-20 01:17:32 +08001878 makeLibName := func(depName string) string {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001879 libName := strings.TrimSuffix(depName, llndkLibrarySuffix)
Jiyong Park374510b2018-03-19 18:23:01 +09001880 libName = strings.TrimSuffix(libName, vendorPublicLibrarySuffix)
Jiyong Park27b188b2017-07-18 13:23:39 +09001881 libName = strings.TrimPrefix(libName, "prebuilt_")
Inseob Kim9516ee92019-05-09 10:56:13 +09001882 isLLndk := inList(libName, *llndkLibraries)
1883 isVendorPublicLib := inList(libName, *vendorPublicLibraries)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001884 bothVendorAndCoreVariantsExist := ccDep.hasVendorVariant() || isLLndk
Vic Yangefd249e2018-11-12 20:19:56 -08001885
yidong.zhangd06ecc82019-08-02 15:49:24 +08001886 if ctx.DeviceConfig().VndkUseCoreVariant() && ccDep.isVndk() && !ccDep.mustUseVendorVariant() && !c.inRecovery() {
Vic Yangefd249e2018-11-12 20:19:56 -08001887 // The vendor module is a no-vendor-variant VNDK library. Depend on the
1888 // core module instead.
1889 return libName
1890 } else if c.useVndk() && bothVendorAndCoreVariantsExist {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001891 // The vendor module in Make will have been renamed to not conflict with the core
1892 // module, so update the dependency name here accordingly.
Logan Chien43d34c32017-12-20 01:17:32 +08001893 return libName + vendorSuffix
Jiyong Park374510b2018-03-19 18:23:01 +09001894 } else if (ctx.Platform() || ctx.ProductSpecific()) && isVendorPublicLib {
Logan Chien43d34c32017-12-20 01:17:32 +08001895 return libName + vendorPublicLibrarySuffix
Jiyong Parkf9332f12018-02-01 00:54:12 +09001896 } else if ccDep.inRecovery() && !ccDep.onlyInRecovery() {
1897 return libName + recoverySuffix
dimitry1f33e402019-03-26 12:39:31 +01001898 } else if ccDep.Target().NativeBridge == android.NativeBridgeEnabled {
dimitry43204492019-05-23 13:24:38 +02001899 return libName + nativeBridgeSuffix
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001900 } else {
Logan Chien43d34c32017-12-20 01:17:32 +08001901 return libName
Jiyong Park27b188b2017-07-18 13:23:39 +09001902 }
Logan Chien43d34c32017-12-20 01:17:32 +08001903 }
1904
1905 // Export the shared libs to Make.
1906 switch depTag {
Jiyong Park64a44f22019-01-18 14:37:08 +09001907 case sharedDepTag, sharedExportDepTag, lateSharedDepTag, earlySharedDepTag:
Jiyong Parkde866cb2018-12-07 23:08:36 +09001908 if dependentLibrary, ok := ccDep.linker.(*libraryDecorator); ok {
Jiyong Park0ddfcd12018-12-11 01:35:25 +09001909 if dependentLibrary.buildStubs() && android.InAnyApex(depName) {
Logan Chien09106e12019-01-18 14:57:48 +08001910 // Add the dependency to the APEX(es) providing the library so that
Jiyong Parkde866cb2018-12-07 23:08:36 +09001911 // m <module> can trigger building the APEXes as well.
Jiyong Park0ddfcd12018-12-11 01:35:25 +09001912 for _, an := range android.GetApexesForModule(depName) {
Jiyong Parkde866cb2018-12-07 23:08:36 +09001913 c.Properties.ApexesProvidingSharedLibs = append(
1914 c.Properties.ApexesProvidingSharedLibs, an)
1915 }
Jiyong Parkde866cb2018-12-07 23:08:36 +09001916 }
1917 }
1918
Jiyong Park27b188b2017-07-18 13:23:39 +09001919 // Note: the order of libs in this list is not important because
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001920 // they merely serve as Make dependencies and do not affect this lib itself.
Logan Chien43d34c32017-12-20 01:17:32 +08001921 c.Properties.AndroidMkSharedLibs = append(
1922 c.Properties.AndroidMkSharedLibs, makeLibName(depName))
Logan Chienc7f797e2019-01-14 15:35:08 +08001923 case ndkStubDepTag, ndkLateStubDepTag:
1924 ndkStub := ccDep.linker.(*stubDecorator)
1925 c.Properties.AndroidMkSharedLibs = append(
1926 c.Properties.AndroidMkSharedLibs,
1927 depName+"."+ndkStub.properties.ApiLevel)
Jaewoong Jung16c7d3d2018-11-16 01:19:56 +00001928 case staticDepTag, staticExportDepTag, lateStaticDepTag:
1929 c.Properties.AndroidMkStaticLibs = append(
1930 c.Properties.AndroidMkStaticLibs, makeLibName(depName))
Logan Chien43d34c32017-12-20 01:17:32 +08001931 case runtimeDepTag:
1932 c.Properties.AndroidMkRuntimeLibs = append(
1933 c.Properties.AndroidMkRuntimeLibs, makeLibName(depName))
Jaewoong Jung16c7d3d2018-11-16 01:19:56 +00001934 case wholeStaticDepTag:
1935 c.Properties.AndroidMkWholeStaticLibs = append(
1936 c.Properties.AndroidMkWholeStaticLibs, makeLibName(depName))
Jiyong Park27b188b2017-07-18 13:23:39 +09001937 }
Colin Crossca860ac2016-01-04 14:34:37 -08001938 })
1939
Jeff Gaston294356f2017-09-27 17:05:30 -07001940 // use the ordered dependencies as this module's dependencies
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -08001941 depPaths.StaticLibs = append(depPaths.StaticLibs, orderStaticModuleDeps(c, directStaticDeps, directSharedDeps)...)
Jeff Gaston294356f2017-09-27 17:05:30 -07001942
Colin Crossdd84e052017-05-17 13:44:16 -07001943 // Dedup exported flags from dependencies
Colin Crossb6715442017-10-24 11:13:31 -07001944 depPaths.Flags = android.FirstUniqueStrings(depPaths.Flags)
Inseob Kim69378442019-06-03 19:10:47 +09001945 depPaths.IncludeDirs = android.FirstUniqueStrings(depPaths.IncludeDirs)
1946 depPaths.SystemIncludeDirs = android.FirstUniqueStrings(depPaths.SystemIncludeDirs)
Dan Willemsenfe92c962017-08-29 12:28:37 -07001947 depPaths.GeneratedHeaders = android.FirstUniquePaths(depPaths.GeneratedHeaders)
Inseob Kim69378442019-06-03 19:10:47 +09001948 depPaths.ReexportedDirs = android.FirstUniqueStrings(depPaths.ReexportedDirs)
1949 depPaths.ReexportedSystemDirs = android.FirstUniqueStrings(depPaths.ReexportedSystemDirs)
Colin Crossb6715442017-10-24 11:13:31 -07001950 depPaths.ReexportedFlags = android.FirstUniqueStrings(depPaths.ReexportedFlags)
Inseob Kim69378442019-06-03 19:10:47 +09001951 depPaths.ReexportedDeps = android.FirstUniquePaths(depPaths.ReexportedDeps)
Dan Willemsenfe92c962017-08-29 12:28:37 -07001952
1953 if c.sabi != nil {
Inseob Kim69378442019-06-03 19:10:47 +09001954 c.sabi.Properties.ReexportedIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedIncludes)
Dan Willemsenfe92c962017-08-29 12:28:37 -07001955 }
Colin Crossdd84e052017-05-17 13:44:16 -07001956
Colin Crossca860ac2016-01-04 14:34:37 -08001957 return depPaths
1958}
1959
1960func (c *Module) InstallInData() bool {
1961 if c.installer == nil {
1962 return false
1963 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07001964 return c.installer.inData()
1965}
1966
1967func (c *Module) InstallInSanitizerDir() bool {
1968 if c.installer == nil {
1969 return false
1970 }
1971 if c.sanitize != nil && c.sanitize.inSanitizerDir() {
Colin Cross94610402016-08-29 13:41:32 -07001972 return true
1973 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07001974 return c.installer.inSanitizerDir()
Colin Crossca860ac2016-01-04 14:34:37 -08001975}
1976
Jiyong Parkf9332f12018-02-01 00:54:12 +09001977func (c *Module) InstallInRecovery() bool {
1978 return c.inRecovery()
1979}
1980
Dan Willemsen4aa75ca2016-09-28 16:18:03 -07001981func (c *Module) HostToolPath() android.OptionalPath {
1982 if c.installer == nil {
1983 return android.OptionalPath{}
1984 }
1985 return c.installer.hostToolPath()
1986}
1987
Nan Zhangd4e641b2017-07-12 12:55:28 -07001988func (c *Module) IntermPathForModuleOut() android.OptionalPath {
1989 return c.outputFile
1990}
1991
Colin Cross41955e82019-05-29 14:40:35 -07001992func (c *Module) OutputFiles(tag string) (android.Paths, error) {
1993 switch tag {
1994 case "":
1995 if c.outputFile.Valid() {
1996 return android.Paths{c.outputFile.Path()}, nil
1997 }
1998 return android.Paths{}, nil
1999 default:
2000 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07002001 }
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07002002}
2003
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00002004func (c *Module) static() bool {
2005 if static, ok := c.linker.(interface {
2006 static() bool
2007 }); ok {
2008 return static.static()
2009 }
2010 return false
2011}
2012
Jiyong Park379de2f2018-12-19 02:47:14 +09002013func (c *Module) staticBinary() bool {
2014 if static, ok := c.linker.(interface {
2015 staticBinary() bool
2016 }); ok {
2017 return static.staticBinary()
2018 }
2019 return false
2020}
2021
Jiyong Park1d1119f2019-07-29 21:27:18 +09002022func (c *Module) header() bool {
2023 if h, ok := c.linker.(interface {
2024 header() bool
2025 }); ok {
2026 return h.header()
2027 }
2028 return false
2029}
2030
Jooyung Han38002912019-05-16 04:01:54 +09002031func (c *Module) getMakeLinkType(actx android.ModuleContext) string {
2032 name := actx.ModuleName()
Colin Crossb60190a2018-09-04 16:28:17 -07002033 if c.useVndk() {
Jooyung Han38002912019-05-16 04:01:54 +09002034 if lib, ok := c.linker.(*llndkStubDecorator); ok {
2035 if Bool(lib.Properties.Vendor_available) {
Colin Crossb60190a2018-09-04 16:28:17 -07002036 return "native:vndk"
2037 }
Jooyung Han38002912019-05-16 04:01:54 +09002038 return "native:vndk_private"
Colin Crossb60190a2018-09-04 16:28:17 -07002039 }
Jooyung Han38002912019-05-16 04:01:54 +09002040 if c.isVndk() && !c.isVndkExt() {
2041 if Bool(c.VendorProperties.Vendor_available) {
2042 return "native:vndk"
2043 }
2044 return "native:vndk_private"
2045 }
2046 return "native:vendor"
Colin Crossb60190a2018-09-04 16:28:17 -07002047 } else if c.inRecovery() {
2048 return "native:recovery"
2049 } else if c.Target().Os == android.Android && String(c.Properties.Sdk_version) != "" {
2050 return "native:ndk:none:none"
2051 // TODO(b/114741097): use the correct ndk stl once build errors have been fixed
2052 //family, link := getNdkStlFamilyAndLinkType(c)
2053 //return fmt.Sprintf("native:ndk:%s:%s", family, link)
Jooyung Han38002912019-05-16 04:01:54 +09002054 } else if inList(name, *vndkUsingCoreVariantLibraries(actx.Config())) {
Vic Yangefd249e2018-11-12 20:19:56 -08002055 return "native:platform_vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07002056 } else {
2057 return "native:platform"
2058 }
2059}
2060
Jiyong Park9d452992018-10-03 00:38:19 +09002061// Overrides ApexModule.IsInstallabeToApex()
Roland Levillainf89cd092019-07-29 16:22:59 +01002062// Only shared/runtime libraries and "test_per_src" tests are installable to APEX.
Jiyong Park9d452992018-10-03 00:38:19 +09002063func (c *Module) IsInstallableToApex() bool {
2064 if shared, ok := c.linker.(interface {
2065 shared() bool
2066 }); ok {
2067 return shared.shared()
Roland Levillainf89cd092019-07-29 16:22:59 +01002068 } else if _, ok := c.linker.(testPerSrc); ok {
2069 return true
Jiyong Park9d452992018-10-03 00:38:19 +09002070 }
2071 return false
2072}
2073
Inseob Kim1f086e22019-05-09 13:29:15 +09002074func (c *Module) installable() bool {
2075 return c.installer != nil && !c.Properties.PreventInstall && c.IsForPlatform() && c.outputFile.Valid()
2076}
2077
Jiyong Park3b1746a2019-01-29 11:15:04 +09002078func (c *Module) imageVariation() string {
2079 variation := "core"
2080 if c.useVndk() {
2081 variation = "vendor"
2082 } else if c.inRecovery() {
2083 variation = "recovery"
2084 }
2085 return variation
2086}
2087
bralee3f49f4d2019-03-04 06:58:15 +08002088func (c *Module) IDEInfo(dpInfo *android.IdeInfo) {
Colin Cross41955e82019-05-29 14:40:35 -07002089 outputFiles, err := c.OutputFiles("")
2090 if err != nil {
2091 panic(err)
2092 }
2093 dpInfo.Srcs = append(dpInfo.Srcs, outputFiles.Strings()...)
bralee3f49f4d2019-03-04 06:58:15 +08002094}
2095
Logan Chien41eabe62019-04-10 13:33:58 +08002096func (c *Module) AndroidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer) {
2097 if c.linker != nil {
2098 if library, ok := c.linker.(*libraryDecorator); ok {
2099 library.androidMkWriteAdditionalDependenciesForSourceAbiDiff(w)
2100 }
2101 }
2102}
2103
Colin Cross2ba19d92015-05-07 15:44:20 -07002104//
Colin Crosscfad1192015-11-02 16:43:11 -08002105// Defaults
2106//
Colin Crossca860ac2016-01-04 14:34:37 -08002107type Defaults struct {
Colin Cross635c3b02016-05-18 15:37:25 -07002108 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -07002109 android.DefaultsModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +09002110 android.ApexModuleBase
Colin Crosscfad1192015-11-02 16:43:11 -08002111}
2112
Patrice Arrudac249c712019-03-19 17:00:29 -07002113// cc_defaults provides a set of properties that can be inherited by other cc
2114// modules. A module can use the properties from a cc_defaults using
2115// `defaults: ["<:default_module_name>"]`. Properties of both modules are
2116// merged (when possible) by prepending the default module's values to the
2117// depending module's values.
Colin Cross36242852017-06-23 15:06:31 -07002118func defaultsFactory() android.Module {
Colin Crosse1d764e2016-08-18 14:18:32 -07002119 return DefaultsFactory()
2120}
2121
Colin Cross36242852017-06-23 15:06:31 -07002122func DefaultsFactory(props ...interface{}) android.Module {
Colin Crossca860ac2016-01-04 14:34:37 -08002123 module := &Defaults{}
Colin Crosscfad1192015-11-02 16:43:11 -08002124
Colin Cross36242852017-06-23 15:06:31 -07002125 module.AddProperties(props...)
2126 module.AddProperties(
Colin Crossca860ac2016-01-04 14:34:37 -08002127 &BaseProperties{},
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07002128 &VendorProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08002129 &BaseCompilerProperties{},
2130 &BaseLinkerProperties{},
Paul Duffina37832a2019-07-18 12:31:26 +01002131 &ObjectLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07002132 &LibraryProperties{},
Colin Cross919281a2016-04-05 16:42:05 -07002133 &FlagExporterProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08002134 &BinaryLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07002135 &TestProperties{},
2136 &TestBinaryProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08002137 &StlProperties{},
Colin Cross16b23492016-01-06 14:41:07 -08002138 &SanitizeProperties{},
Colin Cross665dce92016-04-28 14:50:03 -07002139 &StripProperties{},
Dan Willemsen7424d612016-09-01 13:45:39 -07002140 &InstallerProperties{},
Dan Willemsena03cf6d2016-09-26 15:45:04 -07002141 &TidyProperties{},
Dan Willemsen581341d2017-02-09 16:16:31 -08002142 &CoverageProperties{},
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08002143 &SAbiProperties{},
Justin Yun4b2382f2017-07-26 14:22:10 +09002144 &VndkProperties{},
Stephen Craneba090d12017-05-09 15:44:35 -07002145 &LTOProperties{},
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07002146 &PgoProperties{},
Ivan Lozano074ec482018-11-21 08:59:37 -08002147 &XomProperties{},
Dan Willemsen6424d172018-03-08 13:27:59 -08002148 &android.ProtoProperties{},
Colin Crosse1d764e2016-08-18 14:18:32 -07002149 )
Colin Crosscfad1192015-11-02 16:43:11 -08002150
Colin Cross1f44a3a2017-07-07 14:33:33 -07002151 android.InitDefaultsModule(module)
Jiyong Park9d452992018-10-03 00:38:19 +09002152 android.InitApexModule(module)
Colin Cross36242852017-06-23 15:06:31 -07002153
2154 return module
Colin Crosscfad1192015-11-02 16:43:11 -08002155}
2156
Dan Willemsen4416e5d2017-04-06 12:43:22 -07002157const (
2158 // coreMode is the variant used for framework-private libraries, or
2159 // SDK libraries. (which framework-private libraries can use)
2160 coreMode = "core"
2161
2162 // vendorMode is the variant used for /vendor code that compiles
2163 // against the VNDK.
2164 vendorMode = "vendor"
Jiyong Parkf9332f12018-02-01 00:54:12 +09002165
2166 recoveryMode = "recovery"
Dan Willemsen4416e5d2017-04-06 12:43:22 -07002167)
2168
Jiyong Park6a43f042017-10-12 23:05:00 +09002169func squashVendorSrcs(m *Module) {
2170 if lib, ok := m.compiler.(*libraryDecorator); ok {
2171 lib.baseCompiler.Properties.Srcs = append(lib.baseCompiler.Properties.Srcs,
2172 lib.baseCompiler.Properties.Target.Vendor.Srcs...)
2173
2174 lib.baseCompiler.Properties.Exclude_srcs = append(lib.baseCompiler.Properties.Exclude_srcs,
2175 lib.baseCompiler.Properties.Target.Vendor.Exclude_srcs...)
2176 }
2177}
2178
Jiyong Parkf9332f12018-02-01 00:54:12 +09002179func squashRecoverySrcs(m *Module) {
2180 if lib, ok := m.compiler.(*libraryDecorator); ok {
2181 lib.baseCompiler.Properties.Srcs = append(lib.baseCompiler.Properties.Srcs,
2182 lib.baseCompiler.Properties.Target.Recovery.Srcs...)
2183
2184 lib.baseCompiler.Properties.Exclude_srcs = append(lib.baseCompiler.Properties.Exclude_srcs,
2185 lib.baseCompiler.Properties.Target.Recovery.Exclude_srcs...)
2186 }
2187}
2188
Jiyong Parkda6eb592018-12-19 17:12:36 +09002189func ImageMutator(mctx android.BottomUpMutatorContext) {
Dan Willemsen4416e5d2017-04-06 12:43:22 -07002190 if mctx.Os() != android.Android {
2191 return
2192 }
2193
Jiyong Park7ed9de32018-10-15 22:25:07 +09002194 if g, ok := mctx.Module().(*genrule.Module); ok {
2195 if props, ok := g.Extra.(*GenruleExtraProperties); ok {
Jiyong Park3f736c92018-05-24 13:36:56 +09002196 var coreVariantNeeded bool = false
2197 var vendorVariantNeeded bool = false
2198 var recoveryVariantNeeded bool = false
Justin Yun71549282017-11-17 12:10:28 +09002199 if mctx.DeviceConfig().VndkVersion() == "" {
Jiyong Park3f736c92018-05-24 13:36:56 +09002200 coreVariantNeeded = true
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07002201 } else if Bool(props.Vendor_available) {
Jiyong Park3f736c92018-05-24 13:36:56 +09002202 coreVariantNeeded = true
2203 vendorVariantNeeded = true
Jiyong Park2db76922017-11-08 16:03:48 +09002204 } else if mctx.SocSpecific() || mctx.DeviceSpecific() {
Jiyong Park3f736c92018-05-24 13:36:56 +09002205 vendorVariantNeeded = true
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07002206 } else {
Jiyong Park3f736c92018-05-24 13:36:56 +09002207 coreVariantNeeded = true
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07002208 }
Jiyong Park3f736c92018-05-24 13:36:56 +09002209 if Bool(props.Recovery_available) {
2210 recoveryVariantNeeded = true
2211 }
2212
Jiyong Park413cc742018-06-19 01:46:06 +09002213 if recoveryVariantNeeded {
Jiyong Park8d52f862018-07-07 18:02:07 +09002214 primaryArch := mctx.Config().DevicePrimaryArchType()
Jiyong Park7ed9de32018-10-15 22:25:07 +09002215 moduleArch := g.Target().Arch.ArchType
Jiyong Park8d52f862018-07-07 18:02:07 +09002216 if moduleArch != primaryArch {
Jiyong Park413cc742018-06-19 01:46:06 +09002217 recoveryVariantNeeded = false
2218 }
2219 }
2220
Jiyong Park3f736c92018-05-24 13:36:56 +09002221 var variants []string
2222 if coreVariantNeeded {
2223 variants = append(variants, coreMode)
2224 }
2225 if vendorVariantNeeded {
2226 variants = append(variants, vendorMode)
2227 }
2228 if recoveryVariantNeeded {
2229 variants = append(variants, recoveryMode)
2230 }
Jiyong Park7ed9de32018-10-15 22:25:07 +09002231 mod := mctx.CreateVariations(variants...)
2232 for i, v := range variants {
2233 if v == recoveryMode {
2234 m := mod[i].(*genrule.Module)
2235 m.Extra.(*GenruleExtraProperties).InRecovery = true
2236 }
2237 }
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07002238 }
2239 }
2240
Dan Willemsen4416e5d2017-04-06 12:43:22 -07002241 m, ok := mctx.Module().(*Module)
2242 if !ok {
2243 return
2244 }
2245
2246 // Sanity check
Logan Chienf3511742017-10-31 18:04:35 +08002247 vendorSpecific := mctx.SocSpecific() || mctx.DeviceSpecific()
Justin Yun9357f4a2018-11-28 15:14:47 +09002248 productSpecific := mctx.ProductSpecific()
Logan Chienf3511742017-10-31 18:04:35 +08002249
2250 if m.VendorProperties.Vendor_available != nil && vendorSpecific {
Dan Willemsen4416e5d2017-04-06 12:43:22 -07002251 mctx.PropertyErrorf("vendor_available",
Jiyong Park2db76922017-11-08 16:03:48 +09002252 "doesn't make sense at the same time as `vendor: true`, `proprietary: true`, or `device_specific:true`")
Dan Willemsen4416e5d2017-04-06 12:43:22 -07002253 return
2254 }
Logan Chienf3511742017-10-31 18:04:35 +08002255
2256 if vndkdep := m.vndkdep; vndkdep != nil {
2257 if vndkdep.isVndk() {
Justin Yun9357f4a2018-11-28 15:14:47 +09002258 if productSpecific {
2259 mctx.PropertyErrorf("product_specific",
2260 "product_specific must not be true when `vndk: {enabled: true}`")
2261 return
2262 }
Logan Chienf3511742017-10-31 18:04:35 +08002263 if vendorSpecific {
2264 if !vndkdep.isVndkExt() {
2265 mctx.PropertyErrorf("vndk",
2266 "must set `extends: \"...\"` to vndk extension")
2267 return
2268 }
2269 } else {
2270 if vndkdep.isVndkExt() {
2271 mctx.PropertyErrorf("vndk",
2272 "must set `vendor: true` to set `extends: %q`",
2273 m.getVndkExtendsModuleName())
2274 return
2275 }
2276 if m.VendorProperties.Vendor_available == nil {
2277 mctx.PropertyErrorf("vndk",
2278 "vendor_available must be set to either true or false when `vndk: {enabled: true}`")
2279 return
2280 }
2281 }
2282 } else {
2283 if vndkdep.isVndkSp() {
2284 mctx.PropertyErrorf("vndk",
2285 "must set `enabled: true` to set `support_system_process: true`")
2286 return
2287 }
2288 if vndkdep.isVndkExt() {
2289 mctx.PropertyErrorf("vndk",
2290 "must set `enabled: true` to set `extends: %q`",
2291 m.getVndkExtendsModuleName())
2292 return
2293 }
Justin Yun8effde42017-06-23 19:24:43 +09002294 }
2295 }
Dan Willemsen4416e5d2017-04-06 12:43:22 -07002296
Jiyong Parkf9332f12018-02-01 00:54:12 +09002297 var coreVariantNeeded bool = false
2298 var vendorVariantNeeded bool = false
2299 var recoveryVariantNeeded bool = false
2300
Justin Yun71549282017-11-17 12:10:28 +09002301 if mctx.DeviceConfig().VndkVersion() == "" {
Dan Willemsen4416e5d2017-04-06 12:43:22 -07002302 // If the device isn't compiling against the VNDK, we always
2303 // use the core mode.
Jiyong Parkf9332f12018-02-01 00:54:12 +09002304 coreVariantNeeded = true
Dan Willemsen4416e5d2017-04-06 12:43:22 -07002305 } else if _, ok := m.linker.(*llndkStubDecorator); ok {
2306 // LL-NDK stubs only exist in the vendor variant, since the
2307 // real libraries will be used in the core variant.
Jiyong Parkf9332f12018-02-01 00:54:12 +09002308 vendorVariantNeeded = true
Jiyong Park2a454122017-10-19 15:59:33 +09002309 } else if _, ok := m.linker.(*llndkHeadersDecorator); ok {
2310 // ... and LL-NDK headers as well
Jiyong Parkf9332f12018-02-01 00:54:12 +09002311 vendorVariantNeeded = true
Justin Yun312ccb92018-01-23 12:07:46 +09002312 } else if _, ok := m.linker.(*vndkPrebuiltLibraryDecorator); ok {
Justin Yun71549282017-11-17 12:10:28 +09002313 // Make vendor variants only for the versions in BOARD_VNDK_VERSION and
2314 // PRODUCT_EXTRA_VNDK_VERSIONS.
Jiyong Parkf9332f12018-02-01 00:54:12 +09002315 vendorVariantNeeded = true
Logan Chienf3511742017-10-31 18:04:35 +08002316 } else if m.hasVendorVariant() && !vendorSpecific {
Dan Willemsen4416e5d2017-04-06 12:43:22 -07002317 // This will be available in both /system and /vendor
Justin Yun8effde42017-06-23 19:24:43 +09002318 // or a /system directory that is available to vendor.
Jiyong Parkf9332f12018-02-01 00:54:12 +09002319 coreVariantNeeded = true
2320 vendorVariantNeeded = true
Logan Chienf3511742017-10-31 18:04:35 +08002321 } else if vendorSpecific && String(m.Properties.Sdk_version) == "" {
Jiyong Park2db76922017-11-08 16:03:48 +09002322 // This will be available in /vendor (or /odm) only
Jiyong Parkf9332f12018-02-01 00:54:12 +09002323 vendorVariantNeeded = true
Dan Willemsen4416e5d2017-04-06 12:43:22 -07002324 } else {
2325 // This is either in /system (or similar: /data), or is a
2326 // modules built with the NDK. Modules built with the NDK
2327 // will be restricted using the existing link type checks.
Jiyong Parkf9332f12018-02-01 00:54:12 +09002328 coreVariantNeeded = true
2329 }
2330
2331 if Bool(m.Properties.Recovery_available) {
2332 recoveryVariantNeeded = true
2333 }
2334
2335 if m.ModuleBase.InstallInRecovery() {
2336 recoveryVariantNeeded = true
2337 coreVariantNeeded = false
2338 }
2339
Jiyong Park413cc742018-06-19 01:46:06 +09002340 if recoveryVariantNeeded {
Jiyong Park8d52f862018-07-07 18:02:07 +09002341 primaryArch := mctx.Config().DevicePrimaryArchType()
2342 moduleArch := m.Target().Arch.ArchType
2343 if moduleArch != primaryArch {
Jiyong Park413cc742018-06-19 01:46:06 +09002344 recoveryVariantNeeded = false
2345 }
2346 }
2347
Jiyong Parkf9332f12018-02-01 00:54:12 +09002348 var variants []string
2349 if coreVariantNeeded {
2350 variants = append(variants, coreMode)
2351 }
2352 if vendorVariantNeeded {
2353 variants = append(variants, vendorMode)
2354 }
2355 if recoveryVariantNeeded {
2356 variants = append(variants, recoveryMode)
2357 }
2358 mod := mctx.CreateVariations(variants...)
2359 for i, v := range variants {
2360 if v == vendorMode {
2361 m := mod[i].(*Module)
2362 m.Properties.UseVndk = true
2363 squashVendorSrcs(m)
2364 } else if v == recoveryMode {
2365 m := mod[i].(*Module)
2366 m.Properties.InRecovery = true
Jiyong Park5baac542018-08-28 09:55:37 +09002367 m.MakeAsPlatform()
Jiyong Parkf9332f12018-02-01 00:54:12 +09002368 squashRecoverySrcs(m)
2369 }
Dan Willemsen4416e5d2017-04-06 12:43:22 -07002370 }
2371}
2372
Jayant Chowdhary6e8115a2017-05-09 10:21:52 -07002373func getCurrentNdkPrebuiltVersion(ctx DepsContext) string {
Colin Cross6510f912017-11-29 00:27:14 -08002374 if ctx.Config().PlatformSdkVersionInt() > config.NdkMaxPrebuiltVersionInt {
Jayant Chowdhary6e8115a2017-05-09 10:21:52 -07002375 return strconv.Itoa(config.NdkMaxPrebuiltVersionInt)
2376 }
Colin Cross6510f912017-11-29 00:27:14 -08002377 return ctx.Config().PlatformSdkVersion()
Jayant Chowdhary6e8115a2017-05-09 10:21:52 -07002378}
2379
Sasha Smundak2a4549e2018-11-05 16:49:08 -08002380func kytheExtractAllFactory() android.Singleton {
2381 return &kytheExtractAllSingleton{}
2382}
2383
2384type kytheExtractAllSingleton struct {
2385}
2386
2387func (ks *kytheExtractAllSingleton) GenerateBuildActions(ctx android.SingletonContext) {
2388 var xrefTargets android.Paths
2389 ctx.VisitAllModules(func(module android.Module) {
2390 if ccModule, ok := module.(xref); ok {
2391 xrefTargets = append(xrefTargets, ccModule.XrefCcFiles()...)
2392 }
2393 })
2394 // TODO(asmundak): Perhaps emit a rule to output a warning if there were no xrefTargets
2395 if len(xrefTargets) > 0 {
2396 ctx.Build(pctx, android.BuildParams{
2397 Rule: blueprint.Phony,
2398 Output: android.PathForPhony(ctx, "xref_cxx"),
2399 Inputs: xrefTargets,
2400 //Default: true,
2401 })
2402 }
2403}
2404
Colin Cross06a931b2015-10-28 17:23:31 -07002405var Bool = proptools.Bool
Colin Cross38b40df2018-04-10 16:14:46 -07002406var BoolDefault = proptools.BoolDefault
Nan Zhang0007d812017-11-07 10:57:05 -08002407var BoolPtr = proptools.BoolPtr
2408var String = proptools.String
2409var StringPtr = proptools.StringPtr