blob: 28605f5c42262d07501dca455f93e0fb4353556a [file] [log] [blame]
Colin Cross4d9c2d12016-07-29 12:48:20 -07001// Copyright 2016 Google Inc. All rights reserved.
2//
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
17import (
Inseob Kim69378442019-06-03 19:10:47 +090018 "fmt"
Logan Chien41eabe62019-04-10 13:33:58 +080019 "io"
Jiyong Parkf1194352019-02-25 11:05:47 +090020 "path/filepath"
Jiyong Parkda732bd2018-11-02 18:23:15 +090021 "regexp"
Jooyung Han11b0fbd2021-02-05 02:28:22 +090022 "strconv"
Colin Cross4d9c2d12016-07-29 12:48:20 -070023 "strings"
Jiyong Parkda732bd2018-11-02 18:23:15 +090024 "sync"
Colin Cross4d9c2d12016-07-29 12:48:20 -070025
Colin Cross127bb8b2020-12-16 16:46:01 -080026 "github.com/google/blueprint"
Colin Cross26c34ed2016-09-30 17:10:16 -070027 "github.com/google/blueprint/pathtools"
Colin Cross4d9c2d12016-07-29 12:48:20 -070028
Colin Cross4d9c2d12016-07-29 12:48:20 -070029 "android/soong/android"
Rupert Shuttleworth095081c2021-03-25 09:06:03 +000030 "android/soong/bazel"
Dan Albertea4b7b92018-04-25 16:05:30 -070031 "android/soong/cc/config"
Colin Cross4d9c2d12016-07-29 12:48:20 -070032)
33
Chris Parsons3c27ca32020-11-20 12:42:07 -050034// LibraryProperties is a collection of properties shared by cc library rules.
Colin Crossb916a382016-07-29 17:28:03 -070035type LibraryProperties struct {
Colin Cross4d9c2d12016-07-29 12:48:20 -070036 // local file name to pass to the linker as -unexported_symbols_list
Colin Cross27b922f2019-03-04 22:35:41 -080037 Unexported_symbols_list *string `android:"path,arch_variant"`
Colin Cross4d9c2d12016-07-29 12:48:20 -070038 // local file name to pass to the linker as -force_symbols_not_weak_list
Colin Cross27b922f2019-03-04 22:35:41 -080039 Force_symbols_not_weak_list *string `android:"path,arch_variant"`
Colin Cross4d9c2d12016-07-29 12:48:20 -070040 // local file name to pass to the linker as -force_symbols_weak_list
Colin Cross27b922f2019-03-04 22:35:41 -080041 Force_symbols_weak_list *string `android:"path,arch_variant"`
Colin Cross4d9c2d12016-07-29 12:48:20 -070042
43 // rename host libraries to prevent overlap with system installed libraries
44 Unique_host_soname *bool
45
Dan Willemsene1240db2016-11-03 14:28:51 -070046 Aidl struct {
47 // export headers generated from .aidl sources
Nan Zhang0007d812017-11-07 10:57:05 -080048 Export_aidl_headers *bool
Dan Willemsene1240db2016-11-03 14:28:51 -070049 }
50
Colin Cross0c461f12016-10-20 16:11:43 -070051 Proto struct {
52 // export headers generated from .proto sources
Nan Zhang0007d812017-11-07 10:57:05 -080053 Export_proto_headers *bool
Colin Cross0c461f12016-10-20 16:11:43 -070054 }
Dan Albertf563d252017-10-13 00:29:00 -070055
Inseob Kimc0907f12019-02-08 21:00:45 +090056 Sysprop struct {
57 // Whether platform owns this sysprop library.
58 Platform *bool
Inseob Kimb3f22ca2019-03-05 12:40:24 +090059 } `blueprint:"mutated"`
Inseob Kimc0907f12019-02-08 21:00:45 +090060
Nan Zhang0007d812017-11-07 10:57:05 -080061 Static_ndk_lib *bool
Jiyong Park7ed9de32018-10-15 22:25:07 +090062
Florian Mayer6dab96c2020-12-31 11:39:48 +000063 // Generate stubs to make this library accessible to APEXes.
Jiyong Park7ed9de32018-10-15 22:25:07 +090064 Stubs struct {
65 // Relative path to the symbol map. The symbol map provides the list of
66 // symbols that are exported for stubs variant of this library.
Colin Cross27b922f2019-03-04 22:35:41 -080067 Symbol_file *string `android:"path"`
Jiyong Park7ed9de32018-10-15 22:25:07 +090068
Jiyong Parkd4a3a132021-03-17 20:21:35 +090069 // List versions to generate stubs libs for. The version name "current" is always
70 // implicitly added.
Jiyong Park7ed9de32018-10-15 22:25:07 +090071 Versions []string
72 }
dimitryd95964a2018-11-07 13:43:34 +010073
74 // set the name of the output
75 Stem *string `android:"arch_variant"`
76
Colin Cross0fd6a412019-08-16 14:22:10 -070077 // set suffix of the name of the output
78 Suffix *string `android:"arch_variant"`
79
80 Target struct {
Justin Yun63e9ec72020-10-29 16:49:43 +090081 Vendor, Product struct {
Colin Cross0fd6a412019-08-16 14:22:10 -070082 // set suffix of the name of the output
83 Suffix *string `android:"arch_variant"`
84 }
85 }
86
dimitryd95964a2018-11-07 13:43:34 +010087 // Names of modules to be overridden. Listed modules can only be other shared libraries
88 // (in Make or Soong).
89 // This does not completely prevent installation of the overridden libraries, but if both
90 // binaries would be installed by default (in PRODUCT_PACKAGES) the other library will be removed
91 // from PRODUCT_PACKAGES.
92 Overrides []string
Logan Chiene3d7a0d2019-01-17 00:18:02 +080093
94 // Properties for ABI compatibility checker
95 Header_abi_checker struct {
Logan Chien41eabe62019-04-10 13:33:58 +080096 // Enable ABI checks (even if this is not an LLNDK/VNDK lib)
97 Enabled *bool
98
Logan Chiene3d7a0d2019-01-17 00:18:02 +080099 // Path to a symbol file that specifies the symbols to be included in the generated
100 // ABI dump file
Colin Cross27b922f2019-03-04 22:35:41 -0800101 Symbol_file *string `android:"path"`
Logan Chiene3d7a0d2019-01-17 00:18:02 +0800102
103 // Symbol versions that should be ignored from the symbol file
104 Exclude_symbol_versions []string
105
106 // Symbol tags that should be ignored from the symbol file
107 Exclude_symbol_tags []string
Logan Chien2a65dda2019-10-01 15:58:07 -0700108
109 // Run checks on all APIs (in addition to the ones referred by
110 // one of exported ELF symbols.)
111 Check_all_apis *bool
Logan Chiene3d7a0d2019-01-17 00:18:02 +0800112 }
Vic Yang6cd1be82019-06-24 16:08:48 -0700113
Pete Bentley803e1612019-08-06 22:19:59 +0100114 // Inject boringssl hash into the shared library. This is only intended for use by external/boringssl.
115 Inject_bssl_hash *bool `android:"arch_variant"`
Colin Cross0477b422020-10-13 18:43:54 -0700116
Colin Cross127bb8b2020-12-16 16:46:01 -0800117 // If this is an LLNDK library, properties to describe the LLNDK stubs. Will be copied from
118 // the module pointed to by llndk_stubs if it is set.
119 Llndk llndkLibraryProperties
Colin Cross5271fea2021-04-27 13:06:04 -0700120
121 // If this is a vendor public library, properties to describe the vendor public library stubs.
122 Vendor_public_library vendorPublicLibraryProperties
Colin Crossa48ab5b2017-02-14 15:28:44 -0800123}
Colin Cross0c461f12016-10-20 16:11:43 -0700124
Chris Parsons3c27ca32020-11-20 12:42:07 -0500125// StaticProperties is a properties stanza to affect only attributes of the "static" variants of a
126// library module.
Colin Crosse1bb5d02019-09-24 14:55:04 -0700127type StaticProperties struct {
128 Static StaticOrSharedProperties `android:"arch_variant"`
129}
130
Chris Parsons3c27ca32020-11-20 12:42:07 -0500131// SharedProperties is a properties stanza to affect only attributes of the "shared" variants of a
132// library module.
Colin Crosse1bb5d02019-09-24 14:55:04 -0700133type SharedProperties struct {
134 Shared StaticOrSharedProperties `android:"arch_variant"`
135}
136
Chris Parsons3c27ca32020-11-20 12:42:07 -0500137// StaticOrSharedProperties is an embedded struct representing properties to affect attributes of
138// either only the "static" variants or only the "shared" variants of a library module. These override
139// the base properties of the same name.
140// Use `StaticProperties` or `SharedProperties`, depending on which variant is needed.
141// `StaticOrSharedProperties` exists only to avoid duplication.
Colin Crosse1bb5d02019-09-24 14:55:04 -0700142type StaticOrSharedProperties struct {
Evgenii Stepanov2080bfe2020-07-24 15:35:40 -0700143 Srcs []string `android:"path,arch_variant"`
144
145 Sanitized Sanitized `android:"arch_variant"`
146
Colin Crosse1bb5d02019-09-24 14:55:04 -0700147 Cflags []string `android:"arch_variant"`
148
149 Enabled *bool `android:"arch_variant"`
150 Whole_static_libs []string `android:"arch_variant"`
151 Static_libs []string `android:"arch_variant"`
152 Shared_libs []string `android:"arch_variant"`
153 System_shared_libs []string `android:"arch_variant"`
154
155 Export_shared_lib_headers []string `android:"arch_variant"`
156 Export_static_lib_headers []string `android:"arch_variant"`
Jiyong Parka90ca002019-10-07 15:47:24 +0900157
158 Apex_available []string `android:"arch_variant"`
Colin Crosse1bb5d02019-09-24 14:55:04 -0700159}
160
Colin Crossa48ab5b2017-02-14 15:28:44 -0800161type LibraryMutatedProperties struct {
Colin Crossb916a382016-07-29 17:28:03 -0700162 // Build a static variant
163 BuildStatic bool `blueprint:"mutated"`
164 // Build a shared variant
165 BuildShared bool `blueprint:"mutated"`
166 // This variant is shared
167 VariantIsShared bool `blueprint:"mutated"`
168 // This variant is static
169 VariantIsStatic bool `blueprint:"mutated"`
Jiyong Park7ed9de32018-10-15 22:25:07 +0900170
171 // This variant is a stubs lib
172 BuildStubs bool `blueprint:"mutated"`
Jiyong Parkd4a3a132021-03-17 20:21:35 +0900173 // This variant is the latest version
174 IsLatestVersion bool `blueprint:"mutated"`
Jiyong Park7ed9de32018-10-15 22:25:07 +0900175 // Version of the stubs lib
176 StubsVersion string `blueprint:"mutated"`
Colin Crossd1f898e2020-08-18 18:35:15 -0700177 // List of all stubs versions associated with an implementation lib
178 AllStubsVersions []string `blueprint:"mutated"`
Colin Crossb916a382016-07-29 17:28:03 -0700179}
180
181type FlagExporterProperties struct {
182 // list of directories relative to the Blueprints file that will
Dan Willemsen273af7f2016-11-03 15:53:42 -0700183 // be added to the include path (using -I) for this module and any module that links
Colin Cross5d195602017-10-17 16:15:50 -0700184 // against this module. Directories listed in export_include_dirs do not need to be
185 // listed in local_include_dirs.
Colin Crossb916a382016-07-29 17:28:03 -0700186 Export_include_dirs []string `android:"arch_variant"`
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700187
Jiyong Park73c54ee2019-10-22 20:31:18 +0900188 // list of directories that will be added to the system include path
189 // using -isystem for this module and any module that links against this module.
190 Export_system_include_dirs []string `android:"arch_variant"`
191
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700192 Target struct {
Justin Yun63e9ec72020-10-29 16:49:43 +0900193 Vendor, Product struct {
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700194 // list of exported include directories, like
Justin Yun63e9ec72020-10-29 16:49:43 +0900195 // export_include_dirs, that will be applied to
196 // vendor or product variant of this library.
197 // This will overwrite any other declarations.
Steven Morelandb21df8f2018-01-05 14:42:54 -0800198 Override_export_include_dirs []string
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700199 }
200 }
Colin Cross4d9c2d12016-07-29 12:48:20 -0700201}
202
203func init() {
Paul Duffin6c26dc72019-12-19 15:02:40 +0000204 RegisterLibraryBuildComponents(android.InitRegistrationContext)
Rupert Shuttleworth095081c2021-03-25 09:06:03 +0000205
206 android.RegisterBp2BuildMutator("cc_library_static", CcLibraryStaticBp2Build)
Jingwen Chen63930982021-03-24 10:04:33 -0400207 android.RegisterBp2BuildMutator("cc_library", CcLibraryBp2Build)
Paul Duffin6c26dc72019-12-19 15:02:40 +0000208}
209
210func RegisterLibraryBuildComponents(ctx android.RegistrationContext) {
211 ctx.RegisterModuleType("cc_library_static", LibraryStaticFactory)
212 ctx.RegisterModuleType("cc_library_shared", LibrarySharedFactory)
213 ctx.RegisterModuleType("cc_library", LibraryFactory)
214 ctx.RegisterModuleType("cc_library_host_static", LibraryHostStaticFactory)
215 ctx.RegisterModuleType("cc_library_host_shared", LibraryHostSharedFactory)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700216}
217
Jingwen Chen63930982021-03-24 10:04:33 -0400218// For bp2build conversion.
219type bazelCcLibraryAttributes struct {
Chris Parsons08648312021-05-06 16:23:19 -0400220 // Attributes pertaining to both static and shared variants.
Jingwen Chen14a8bda2021-06-02 11:10:02 +0000221 Srcs bazel.LabelListAttribute
222 Srcs_c bazel.LabelListAttribute
223 Srcs_as bazel.LabelListAttribute
224
225 Copts bazel.StringListAttribute
226 Cppflags bazel.StringListAttribute
227 Conlyflags bazel.StringListAttribute
228 Asflags bazel.StringListAttribute
229
Chris Parsonsd6358772021-05-18 18:35:24 -0400230 Hdrs bazel.LabelListAttribute
231 Deps bazel.LabelListAttribute
232 Implementation_deps bazel.LabelListAttribute
233 Dynamic_deps bazel.LabelListAttribute
234 Whole_archive_deps bazel.LabelListAttribute
Chris Parsonsd6358772021-05-18 18:35:24 -0400235 Includes bazel.StringListAttribute
236 Linkopts bazel.StringListAttribute
Liz Kammerd366c902021-06-03 13:43:01 -0400237 Use_libcrt bazel.BoolAttribute
Chris Parsons990c4f42021-05-25 12:10:58 -0400238
Chris Parsons08648312021-05-06 16:23:19 -0400239 // Attributes pertaining to shared variant.
Jingwen Chen14a8bda2021-06-02 11:10:02 +0000240 Shared_srcs bazel.LabelListAttribute
241 Shared_srcs_c bazel.LabelListAttribute
242 Shared_srcs_as bazel.LabelListAttribute
243 Shared_copts bazel.StringListAttribute
244
Chris Parsonsd6358772021-05-18 18:35:24 -0400245 Exported_deps_for_shared bazel.LabelListAttribute
Chris Parsons08648312021-05-06 16:23:19 -0400246 Static_deps_for_shared bazel.LabelListAttribute
247 Dynamic_deps_for_shared bazel.LabelListAttribute
248 Whole_archive_deps_for_shared bazel.LabelListAttribute
249 User_link_flags bazel.StringListAttribute
250 Version_script bazel.LabelAttribute
Chris Parsons990c4f42021-05-25 12:10:58 -0400251
Chris Parsons08648312021-05-06 16:23:19 -0400252 // Attributes pertaining to static variant.
Jingwen Chen14a8bda2021-06-02 11:10:02 +0000253 Static_srcs bazel.LabelListAttribute
254 Static_srcs_c bazel.LabelListAttribute
255 Static_srcs_as bazel.LabelListAttribute
256 Static_copts bazel.StringListAttribute
257
Chris Parsonsd6358772021-05-18 18:35:24 -0400258 Exported_deps_for_static bazel.LabelListAttribute
Chris Parsons08648312021-05-06 16:23:19 -0400259 Static_deps_for_static bazel.LabelListAttribute
260 Dynamic_deps_for_static bazel.LabelListAttribute
261 Whole_archive_deps_for_static bazel.LabelListAttribute
Jingwen Chen3d383bb2021-06-09 07:18:37 +0000262
263 Strip stripAttributes
264}
265
266type stripAttributes struct {
267 Keep_symbols bazel.BoolAttribute
268 Keep_symbols_and_debug_frame bazel.BoolAttribute
269 Keep_symbols_list bazel.StringListAttribute
270 All bazel.BoolAttribute
271 None bazel.BoolAttribute
Jingwen Chen63930982021-03-24 10:04:33 -0400272}
273
274type bazelCcLibrary struct {
275 android.BazelTargetModuleBase
276 bazelCcLibraryAttributes
277}
278
279func (m *bazelCcLibrary) Name() string {
280 return m.BaseModuleName()
281}
282
283func (m *bazelCcLibrary) GenerateAndroidBuildActions(ctx android.ModuleContext) {}
284
285func BazelCcLibraryFactory() android.Module {
286 module := &bazelCcLibrary{}
287 module.AddProperties(&module.bazelCcLibraryAttributes)
288 android.InitBazelTargetModule(module)
289 return module
290}
291
292func CcLibraryBp2Build(ctx android.TopDownMutatorContext) {
293 m, ok := ctx.Module().(*Module)
294 if !ok || !m.ConvertWithBp2build(ctx) {
295 return
296 }
297
298 if ctx.ModuleType() != "cc_library" {
299 return
300 }
301
Jingwen Chen179856a2021-05-03 09:15:48 +0000302 // For some cc_library modules, their static variants are ready to be
303 // converted, but not their shared variants. For these modules, delegate to
304 // the cc_library_static bp2build converter temporarily instead.
305 if android.GenerateCcLibraryStaticOnly(ctx) {
306 ccLibraryStaticBp2BuildInternal(ctx, m)
307 return
308 }
309
Jingwen Chen53681ef2021-04-29 08:15:13 +0000310 sharedAttrs := bp2BuildParseSharedProps(ctx, m)
311 staticAttrs := bp2BuildParseStaticProps(ctx, m)
Jingwen Chen107c0de2021-04-09 10:43:12 +0000312 compilerAttrs := bp2BuildParseCompilerProps(ctx, m)
313 linkerAttrs := bp2BuildParseLinkerProps(ctx, m)
Jingwen Chen882bcc12021-04-27 05:54:20 +0000314 exportedIncludes := bp2BuildParseExportedIncludes(ctx, m)
Jingwen Chen63930982021-03-24 10:04:33 -0400315
Liz Kammer9abd62d2021-05-21 08:37:59 -0400316 srcs := compilerAttrs.srcs
Jingwen Chen53681ef2021-04-29 08:15:13 +0000317
Jingwen Chen63930982021-03-24 10:04:33 -0400318 attrs := &bazelCcLibraryAttributes{
Jingwen Chen14a8bda2021-06-02 11:10:02 +0000319 Srcs: srcs,
320 Srcs_c: compilerAttrs.cSrcs,
321 Srcs_as: compilerAttrs.asSrcs,
322
323 Copts: compilerAttrs.copts,
324 Cppflags: compilerAttrs.cppFlags,
325 Conlyflags: compilerAttrs.conlyFlags,
326 Asflags: compilerAttrs.asFlags,
327
Chris Parsons990c4f42021-05-25 12:10:58 -0400328 Implementation_deps: linkerAttrs.deps,
329 Deps: linkerAttrs.exportedDeps,
330 Dynamic_deps: linkerAttrs.dynamicDeps,
331 Whole_archive_deps: linkerAttrs.wholeArchiveDeps,
Chris Parsons990c4f42021-05-25 12:10:58 -0400332 Includes: exportedIncludes,
333 Linkopts: linkerAttrs.linkopts,
Liz Kammerd366c902021-06-03 13:43:01 -0400334 Use_libcrt: linkerAttrs.useLibcrt,
Chris Parsons990c4f42021-05-25 12:10:58 -0400335
Jingwen Chen3d383bb2021-06-09 07:18:37 +0000336 Strip: stripAttributes{
337 Keep_symbols: linkerAttrs.stripKeepSymbols,
338 Keep_symbols_and_debug_frame: linkerAttrs.stripKeepSymbolsAndDebugFrame,
339 Keep_symbols_list: linkerAttrs.stripKeepSymbolsList,
340 All: linkerAttrs.stripAll,
341 None: linkerAttrs.stripNone,
342 },
343
Chris Parsons08648312021-05-06 16:23:19 -0400344 Shared_srcs: sharedAttrs.srcs,
Jingwen Chen14a8bda2021-06-02 11:10:02 +0000345 Shared_srcs_c: sharedAttrs.srcs_c,
346 Shared_srcs_as: sharedAttrs.srcs_as,
347 Shared_copts: sharedAttrs.copts,
Chris Parsons08648312021-05-06 16:23:19 -0400348 Static_deps_for_shared: sharedAttrs.staticDeps,
349 Whole_archive_deps_for_shared: sharedAttrs.wholeArchiveDeps,
350 Dynamic_deps_for_shared: sharedAttrs.dynamicDeps,
351 Version_script: linkerAttrs.versionScript,
Chris Parsons990c4f42021-05-25 12:10:58 -0400352
Chris Parsons08648312021-05-06 16:23:19 -0400353 Static_srcs: staticAttrs.srcs,
Jingwen Chen14a8bda2021-06-02 11:10:02 +0000354 Static_srcs_c: staticAttrs.srcs_c,
355 Static_srcs_as: staticAttrs.srcs_as,
356 Static_copts: staticAttrs.copts,
Chris Parsons08648312021-05-06 16:23:19 -0400357 Static_deps_for_static: staticAttrs.staticDeps,
358 Whole_archive_deps_for_static: staticAttrs.wholeArchiveDeps,
359 Dynamic_deps_for_static: staticAttrs.dynamicDeps,
Jingwen Chen63930982021-03-24 10:04:33 -0400360 }
361
362 props := bazel.BazelTargetModuleProperties{
363 Rule_class: "cc_library",
364 Bzl_load_location: "//build/bazel/rules:full_cc_library.bzl",
365 }
366
367 ctx.CreateBazelTargetModule(BazelCcLibraryFactory, m.Name(), props, attrs)
368}
369
Patrice Arruda83c89e02019-03-25 15:32:39 -0700370// cc_library creates both static and/or shared libraries for a device and/or
371// host. By default, a cc_library has a single variant that targets the device.
372// Specifying `host_supported: true` also creates a library that targets the
373// host.
Steven Morelandf9e62162017-11-02 17:00:50 -0700374func LibraryFactory() android.Module {
Colin Crossab3b7322016-12-09 14:46:15 -0800375 module, _ := NewLibrary(android.HostAndDeviceSupported)
Paul Duffina0843f62019-12-13 19:50:38 +0000376 // Can be used as both a static and a shared library.
377 module.sdkMemberTypes = []android.SdkMemberType{
378 sharedLibrarySdkMemberType,
379 staticLibrarySdkMemberType,
Paul Duffin9b76c0b2020-03-12 10:24:35 +0000380 staticAndSharedLibrarySdkMemberType,
Paul Duffina0843f62019-12-13 19:50:38 +0000381 }
Chris Parsonsbcc9b882021-06-03 11:16:27 -0400382 module.bazelHandler = &ccLibraryBazelHandler{module: module}
Colin Cross4d9c2d12016-07-29 12:48:20 -0700383 return module.Init()
384}
385
Patrice Arruda83c89e02019-03-25 15:32:39 -0700386// cc_library_static creates a static library for a device and/or host binary.
Steven Morelandf9e62162017-11-02 17:00:50 -0700387func LibraryStaticFactory() android.Module {
Colin Crossab3b7322016-12-09 14:46:15 -0800388 module, library := NewLibrary(android.HostAndDeviceSupported)
389 library.BuildOnlyStatic()
Paul Duffina0843f62019-12-13 19:50:38 +0000390 module.sdkMemberTypes = []android.SdkMemberType{staticLibrarySdkMemberType}
Chris Parsonsbcc9b882021-06-03 11:16:27 -0400391 module.bazelHandler = &ccLibraryBazelHandler{module: module}
Colin Cross4d9c2d12016-07-29 12:48:20 -0700392 return module.Init()
393}
394
Patrice Arruda83c89e02019-03-25 15:32:39 -0700395// cc_library_shared creates a shared library for a device and/or host.
Steven Morelandf9e62162017-11-02 17:00:50 -0700396func LibrarySharedFactory() android.Module {
Colin Crossab3b7322016-12-09 14:46:15 -0800397 module, library := NewLibrary(android.HostAndDeviceSupported)
398 library.BuildOnlyShared()
Paul Duffina0843f62019-12-13 19:50:38 +0000399 module.sdkMemberTypes = []android.SdkMemberType{sharedLibrarySdkMemberType}
Colin Cross4d9c2d12016-07-29 12:48:20 -0700400 return module.Init()
401}
402
Patrice Arruda83c89e02019-03-25 15:32:39 -0700403// cc_library_host_static creates a static library that is linkable to a host
404// binary.
Steven Morelandf9e62162017-11-02 17:00:50 -0700405func LibraryHostStaticFactory() android.Module {
Colin Crossab3b7322016-12-09 14:46:15 -0800406 module, library := NewLibrary(android.HostSupported)
407 library.BuildOnlyStatic()
Paul Duffina0843f62019-12-13 19:50:38 +0000408 module.sdkMemberTypes = []android.SdkMemberType{staticLibrarySdkMemberType}
Colin Cross4d9c2d12016-07-29 12:48:20 -0700409 return module.Init()
410}
411
Patrice Arruda83c89e02019-03-25 15:32:39 -0700412// cc_library_host_shared creates a shared library that is usable on a host.
Steven Morelandf9e62162017-11-02 17:00:50 -0700413func LibraryHostSharedFactory() android.Module {
Colin Crossab3b7322016-12-09 14:46:15 -0800414 module, library := NewLibrary(android.HostSupported)
415 library.BuildOnlyShared()
Paul Duffina0843f62019-12-13 19:50:38 +0000416 module.sdkMemberTypes = []android.SdkMemberType{sharedLibrarySdkMemberType}
Colin Cross4d9c2d12016-07-29 12:48:20 -0700417 return module.Init()
418}
419
Chris Parsons3c27ca32020-11-20 12:42:07 -0500420// flagExporter is a separated portion of libraryDecorator pertaining to exported
421// include paths and flags. Keeping this dependency-related information separate
422// from the rest of library information is helpful in keeping data more structured
423// and explicit.
Colin Cross4d9c2d12016-07-29 12:48:20 -0700424type flagExporter struct {
425 Properties FlagExporterProperties
426
Chris Parsons3c27ca32020-11-20 12:42:07 -0500427 dirs android.Paths // Include directories to be included with -I
428 systemDirs android.Paths // System include directories to be included with -isystem
429 flags []string // Exported raw flags.
Inseob Kim69378442019-06-03 19:10:47 +0900430 deps android.Paths
Inseob Kimd110f872019-12-06 13:15:38 +0900431 headers android.Paths
Colin Cross4d9c2d12016-07-29 12:48:20 -0700432}
433
Chris Parsons3c27ca32020-11-20 12:42:07 -0500434// exportedIncludes returns the effective include paths for this module and
435// any module that links against this module. This is obtained from
436// the export_include_dirs property in the appropriate target stanza.
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700437func (f *flagExporter) exportedIncludes(ctx ModuleContext) android.Paths {
Justin Yun6977e8a2020-10-29 18:24:11 +0900438 if ctx.inVendor() && f.Properties.Target.Vendor.Override_export_include_dirs != nil {
Steven Morelandb21df8f2018-01-05 14:42:54 -0800439 return android.PathsForModuleSrc(ctx, f.Properties.Target.Vendor.Override_export_include_dirs)
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700440 }
Justin Yun6977e8a2020-10-29 18:24:11 +0900441 if ctx.inProduct() && f.Properties.Target.Product.Override_export_include_dirs != nil {
442 return android.PathsForModuleSrc(ctx, f.Properties.Target.Product.Override_export_include_dirs)
443 }
444 return android.PathsForModuleSrc(ctx, f.Properties.Export_include_dirs)
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700445}
446
Chris Parsons3c27ca32020-11-20 12:42:07 -0500447// exportIncludes registers the include directories and system include directories to be exported
448// transitively to modules depending on this module.
Inseob Kim69378442019-06-03 19:10:47 +0900449func (f *flagExporter) exportIncludes(ctx ModuleContext) {
Jiyong Park74955042019-10-22 20:19:51 +0900450 f.dirs = append(f.dirs, f.exportedIncludes(ctx)...)
Jiyong Park73c54ee2019-10-22 20:31:18 +0900451 f.systemDirs = append(f.systemDirs, android.PathsForModuleSrc(ctx, f.Properties.Export_system_include_dirs)...)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700452}
453
Chris Parsons3c27ca32020-11-20 12:42:07 -0500454// exportIncludesAsSystem registers the include directories and system include directories to be
455// exported transitively both as system include directories to modules depending on this module.
Inseob Kim69378442019-06-03 19:10:47 +0900456func (f *flagExporter) exportIncludesAsSystem(ctx ModuleContext) {
Jiyong Park73c54ee2019-10-22 20:31:18 +0900457 // all dirs are force exported as system
Jiyong Park74955042019-10-22 20:19:51 +0900458 f.systemDirs = append(f.systemDirs, f.exportedIncludes(ctx)...)
Jiyong Park73c54ee2019-10-22 20:31:18 +0900459 f.systemDirs = append(f.systemDirs, android.PathsForModuleSrc(ctx, f.Properties.Export_system_include_dirs)...)
Inseob Kim69378442019-06-03 19:10:47 +0900460}
461
Chris Parsons3c27ca32020-11-20 12:42:07 -0500462// reexportDirs registers the given directories as include directories to be exported transitively
463// to modules depending on this module.
Jiyong Park74955042019-10-22 20:19:51 +0900464func (f *flagExporter) reexportDirs(dirs ...android.Path) {
Inseob Kim69378442019-06-03 19:10:47 +0900465 f.dirs = append(f.dirs, dirs...)
466}
467
Chris Parsons3c27ca32020-11-20 12:42:07 -0500468// reexportSystemDirs registers the given directories as system include directories
469// to be exported transitively to modules depending on this module.
Jiyong Park74955042019-10-22 20:19:51 +0900470func (f *flagExporter) reexportSystemDirs(dirs ...android.Path) {
Inseob Kim69378442019-06-03 19:10:47 +0900471 f.systemDirs = append(f.systemDirs, dirs...)
472}
473
Chris Parsons3c27ca32020-11-20 12:42:07 -0500474// reexportFlags registers the flags to be exported transitively to modules depending on this
475// module.
Inseob Kim69378442019-06-03 19:10:47 +0900476func (f *flagExporter) reexportFlags(flags ...string) {
Jaewoong Jung3aff5782020-02-11 07:54:35 -0800477 if android.PrefixInList(flags, "-I") || android.PrefixInList(flags, "-isystem") {
478 panic(fmt.Errorf("Exporting invalid flag %q: "+
479 "use reexportDirs or reexportSystemDirs to export directories", flag))
Inseob Kim69378442019-06-03 19:10:47 +0900480 }
Colin Cross4d9c2d12016-07-29 12:48:20 -0700481 f.flags = append(f.flags, flags...)
482}
483
Inseob Kim69378442019-06-03 19:10:47 +0900484func (f *flagExporter) reexportDeps(deps ...android.Path) {
485 f.deps = append(f.deps, deps...)
486}
487
Inseob Kimd110f872019-12-06 13:15:38 +0900488// addExportedGeneratedHeaders does nothing but collects generated header files.
489// This can be differ to exportedDeps which may contain phony files to minimize ninja.
490func (f *flagExporter) addExportedGeneratedHeaders(headers ...android.Path) {
491 f.headers = append(f.headers, headers...)
492}
493
Colin Cross0de8a1e2020-09-18 14:15:30 -0700494func (f *flagExporter) setProvider(ctx android.ModuleContext) {
495 ctx.SetProvider(FlagExporterInfoProvider, FlagExporterInfo{
Chris Parsonsf60ecf02021-04-27 14:48:30 -0400496 // Comes from Export_include_dirs property, and those of exported transitive deps
497 IncludeDirs: android.FirstUniquePaths(f.dirs),
498 // Comes from Export_system_include_dirs property, and those of exported transitive deps
Colin Crossc82e6e22021-04-20 18:21:50 -0700499 SystemIncludeDirs: android.FirstUniquePaths(f.systemDirs),
Chris Parsonsf60ecf02021-04-27 14:48:30 -0400500 // Used in very few places as a one-off way of adding extra defines.
501 Flags: f.flags,
502 // Used sparingly, for extra files that need to be explicitly exported to dependers,
503 // or for phony files to minimize ninja.
504 Deps: f.deps,
505 // For exported generated headers, such as exported aidl headers, proto headers, or
506 // sysprop headers.
507 GeneratedHeaders: f.headers,
Colin Cross0de8a1e2020-09-18 14:15:30 -0700508 })
Inseob Kim69378442019-06-03 19:10:47 +0900509}
510
Colin Crossb916a382016-07-29 17:28:03 -0700511// libraryDecorator wraps baseCompiler, baseLinker and baseInstaller to provide library-specific
512// functionality: static vs. shared linkage, reusing object files for shared libraries
513type libraryDecorator struct {
Colin Crossa48ab5b2017-02-14 15:28:44 -0800514 Properties LibraryProperties
Colin Crosse1bb5d02019-09-24 14:55:04 -0700515 StaticProperties StaticProperties
516 SharedProperties SharedProperties
Colin Crossa48ab5b2017-02-14 15:28:44 -0800517 MutatedProperties LibraryMutatedProperties
Colin Cross4d9c2d12016-07-29 12:48:20 -0700518
519 // For reusing static library objects for shared library
Inseob Kim69378442019-06-03 19:10:47 +0900520 reuseObjects Objects
Colin Cross10d22312017-05-03 11:01:58 -0700521
Colin Cross26c34ed2016-09-30 17:10:16 -0700522 // table-of-contents file to optimize out relinking when possible
523 tocFile android.OptionalPath
Colin Cross4d9c2d12016-07-29 12:48:20 -0700524
Colin Cross4d9c2d12016-07-29 12:48:20 -0700525 flagExporter
Liz Kammerb6a55bf2021-04-12 15:42:51 -0400526 flagExporterInfo *FlagExporterInfo
527 stripper Stripper
Colin Cross4d9c2d12016-07-29 12:48:20 -0700528
Colin Cross4d9c2d12016-07-29 12:48:20 -0700529 // For whole_static_libs
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700530 objects Objects
Colin Cross4d9c2d12016-07-29 12:48:20 -0700531
532 // Uses the module's name if empty, but can be overridden. Does not include
533 // shlib suffix.
534 libName string
Colin Crossb916a382016-07-29 17:28:03 -0700535
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800536 sabi *sabi
537
Dan Willemsen581341d2017-02-09 16:16:31 -0800538 // Output archive of gcno coverage information files
539 coverageOutputFile android.OptionalPath
540
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800541 // linked Source Abi Dump
542 sAbiOutputFile android.OptionalPath
543
544 // Source Abi Diff
545 sAbiDiff android.OptionalPath
546
Colin Cross0875c522017-11-28 17:34:01 -0800547 // Location of the static library in the sysroot. Empty if the library is
548 // not included in the NDK.
549 ndkSysrootPath android.Path
550
Colin Crossb60190a2018-09-04 16:28:17 -0700551 // Location of the linked, unstripped library for shared libraries
552 unstrippedOutputFile android.Path
553
Dan Willemsen569edc52018-11-19 09:33:29 -0800554 // Location of the file that should be copied to dist dir when requested
Jingwen Chen40fd90a2020-06-15 05:24:19 +0000555 distFile android.Path
Dan Willemsen569edc52018-11-19 09:33:29 -0800556
Colin Cross8e21aa52020-09-28 18:28:02 -0700557 versionScriptPath android.OptionalPath
Jiyong Park7ed9de32018-10-15 22:25:07 +0900558
Jaewoong Jung18aefc12020-12-21 09:11:10 -0800559 postInstallCmds []string
Jiyong Parkf1194352019-02-25 11:05:47 +0900560
Vic Yangefd249e2018-11-12 20:19:56 -0800561 // If useCoreVariant is true, the vendor variant of a VNDK library is
562 // not installed.
Vic Yangd92090f2020-01-08 14:32:28 -0800563 useCoreVariant bool
564 checkSameCoreVariant bool
Vic Yangefd249e2018-11-12 20:19:56 -0800565
Colin Cross5ec407b2020-09-30 11:41:33 -0700566 skipAPIDefine bool
567
Martin Stjernholmc5dd4f72020-04-01 20:38:01 +0100568 // Decorated interfaces
Colin Crossb916a382016-07-29 17:28:03 -0700569 *baseCompiler
570 *baseLinker
571 *baseInstaller
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900572
573 collectedSnapshotHeaders android.Paths
574}
575
Chris Parsonsbcc9b882021-06-03 11:16:27 -0400576type ccLibraryBazelHandler struct {
Chris Parsons808d84c2021-03-09 20:43:32 -0500577 bazelHandler
578
579 module *Module
580}
581
Chris Parsonsbcc9b882021-06-03 11:16:27 -0400582func (handler *ccLibraryBazelHandler) generateBazelBuildActions(ctx android.ModuleContext, label string) bool {
583 if !handler.module.static() {
584 // TODO(cparsons): Support shared libraries.
585 return false
586 }
Chris Parsons808d84c2021-03-09 20:43:32 -0500587 bazelCtx := ctx.Config().BazelContext
Liz Kammerfe23bf32021-04-09 16:17:05 -0400588 ccInfo, ok, err := bazelCtx.GetCcInfo(label, ctx.Arch().ArchType)
589 if err != nil {
590 ctx.ModuleErrorf("Error getting Bazel CcInfo: %s", err)
591 return false
592 }
Chris Parsons944e7d02021-03-11 11:08:46 -0500593 if !ok {
594 return ok
Chris Parsons808d84c2021-03-09 20:43:32 -0500595 }
Chris Parsonsbcc9b882021-06-03 11:16:27 -0400596 rootStaticArchives := ccInfo.RootStaticArchives
Liz Kammerfe23bf32021-04-09 16:17:05 -0400597 objPaths := ccInfo.CcObjectFiles
Chris Parsonsbcc9b882021-06-03 11:16:27 -0400598 if len(rootStaticArchives) != 1 {
599 ctx.ModuleErrorf("expected exactly one root archive file for '%s', but got %s", label, rootStaticArchives)
Chris Parsons944e7d02021-03-11 11:08:46 -0500600 return false
601 }
Chris Parsonsbcc9b882021-06-03 11:16:27 -0400602 outputFilePath := android.PathForBazelOut(ctx, rootStaticArchives[0])
Chris Parsons944e7d02021-03-11 11:08:46 -0500603 handler.module.outputFile = android.OptionalPathForPath(outputFilePath)
604
605 objFiles := make(android.Paths, len(objPaths))
606 for i, objPath := range objPaths {
607 objFiles[i] = android.PathForBazelOut(ctx, objPath)
608 }
609 objects := Objects{
610 objFiles: objFiles,
611 }
612
613 ctx.SetProvider(StaticLibraryInfoProvider, StaticLibraryInfo{
614 StaticLibrary: outputFilePath,
615 ReuseObjects: objects,
616 Objects: objects,
617
618 // TODO(cparsons): Include transitive static libraries in this provider to support
619 // static libraries with deps.
620 TransitiveStaticLibrariesForOrdering: android.NewDepSetBuilder(android.TOPOLOGICAL).
621 Direct(outputFilePath).
622 Build(),
623 })
Chris Parsonsf60ecf02021-04-27 14:48:30 -0400624
625 ctx.SetProvider(FlagExporterInfoProvider, flagExporterInfoFromCcInfo(ctx, ccInfo))
Chris Parsonseefc9e62021-04-02 17:36:47 -0400626 if i, ok := handler.module.linker.(snapshotLibraryInterface); ok {
627 // Dependencies on this library will expect collectedSnapshotHeaders to
628 // be set, otherwise validation will fail. For now, set this to an empty
629 // list.
630 // TODO(cparsons): More closely mirror the collectHeadersForSnapshot
631 // implementation.
632 i.(*libraryDecorator).collectedSnapshotHeaders = android.Paths{}
633 }
634
Chris Parsons808d84c2021-03-09 20:43:32 -0500635 return ok
636}
637
Ivan Lozanod67a6b02021-05-20 13:01:32 -0400638func GlobHeadersForSnapshot(ctx android.ModuleContext, paths android.Paths) android.Paths {
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900639 ret := android.Paths{}
640
641 // Headers in the source tree should be globbed. On the contrast, generated headers
642 // can't be globbed, and they should be manually collected.
643 // So, we first filter out intermediate directories (which contains generated headers)
644 // from exported directories, and then glob headers under remaining directories.
Ivan Lozanod67a6b02021-05-20 13:01:32 -0400645 for _, path := range paths {
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900646 dir := path.String()
647 // Skip if dir is for generated headers
648 if strings.HasPrefix(dir, android.PathForOutput(ctx).String()) {
649 continue
650 }
Inseob Kim04f2d6a2020-05-29 22:30:58 +0900651 // libeigen wrongly exports the root directory "external/eigen". But only two
652 // subdirectories "Eigen" and "unsupported" contain exported header files. Even worse
653 // some of them have no extension. So we need special treatment for libeigen in order
654 // to glob correctly.
655 if dir == "external/eigen" {
656 // Only these two directories contains exported headers.
657 for _, subdir := range []string{"Eigen", "unsupported/Eigen"} {
658 glob, err := ctx.GlobWithDeps("external/eigen/"+subdir+"/**/*", nil)
659 if err != nil {
660 ctx.ModuleErrorf("glob failed: %#v", err)
Ivan Lozanod67a6b02021-05-20 13:01:32 -0400661 return nil
Inseob Kim04f2d6a2020-05-29 22:30:58 +0900662 }
663 for _, header := range glob {
664 if strings.HasSuffix(header, "/") {
665 continue
666 }
667 ext := filepath.Ext(header)
668 if ext != "" && ext != ".h" {
669 continue
670 }
671 ret = append(ret, android.PathForSource(ctx, header))
672 }
673 }
674 continue
675 }
Colin Crossec118d02021-01-22 18:05:59 +0000676 glob, err := ctx.GlobWithDeps(dir+"/**/*", nil)
677 if err != nil {
678 ctx.ModuleErrorf("glob failed: %#v", err)
Ivan Lozanod67a6b02021-05-20 13:01:32 -0400679 return nil
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900680 }
Colin Crossec118d02021-01-22 18:05:59 +0000681 isLibcxx := strings.HasPrefix(dir, "external/libcxx/include")
Jose Galmes0d736912021-03-30 11:00:06 -0700682 for _, header := range glob {
Colin Crossec118d02021-01-22 18:05:59 +0000683 if isLibcxx {
684 // Glob all files under this special directory, because of C++ headers with no
685 // extension.
Jose Galmes0d736912021-03-30 11:00:06 -0700686 if strings.HasSuffix(header, "/") {
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900687 continue
688 }
Colin Crossec118d02021-01-22 18:05:59 +0000689 } else {
690 // Filter out only the files with extensions that are headers.
691 found := false
Ivan Lozanod67a6b02021-05-20 13:01:32 -0400692 for _, ext := range HeaderExts {
Colin Crossec118d02021-01-22 18:05:59 +0000693 if strings.HasSuffix(header, ext) {
694 found = true
695 break
696 }
697 }
698 if !found {
699 continue
700 }
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900701 }
Jose Galmes0d736912021-03-30 11:00:06 -0700702 ret = append(ret, android.PathForSource(ctx, header))
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900703 }
704 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -0400705 return ret
706}
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900707
Ivan Lozanod67a6b02021-05-20 13:01:32 -0400708func GlobGeneratedHeadersForSnapshot(ctx android.ModuleContext, paths android.Paths) android.Paths {
709 ret := android.Paths{}
710 for _, header := range paths {
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900711 // TODO(b/148123511): remove exportedDeps after cleaning up genrule
712 if strings.HasSuffix(header.Base(), "-phony") {
713 continue
714 }
715 ret = append(ret, header)
716 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -0400717 return ret
718}
719
720// collectHeadersForSnapshot collects all exported headers from library.
721// It globs header files in the source tree for exported include directories,
722// and tracks generated header files separately.
723//
724// This is to be called from GenerateAndroidBuildActions, and then collected
725// header files can be retrieved by snapshotHeaders().
726func (l *libraryDecorator) collectHeadersForSnapshot(ctx android.ModuleContext) {
727 ret := android.Paths{}
728
729 // Headers in the source tree should be globbed. On the contrast, generated headers
730 // can't be globbed, and they should be manually collected.
731 // So, we first filter out intermediate directories (which contains generated headers)
732 // from exported directories, and then glob headers under remaining directories.
733 ret = append(ret, GlobHeadersForSnapshot(ctx, append(android.CopyOfPaths(l.flagExporter.dirs), l.flagExporter.systemDirs...))...)
734
735 // Collect generated headers
736 ret = append(ret, GlobGeneratedHeadersForSnapshot(ctx, append(android.CopyOfPaths(l.flagExporter.headers), l.flagExporter.deps...))...)
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900737
738 l.collectedSnapshotHeaders = ret
739}
740
741// This returns all exported header files, both generated ones and headers from source tree.
742// collectHeadersForSnapshot() must be called before calling this.
743func (l *libraryDecorator) snapshotHeaders() android.Paths {
744 if l.collectedSnapshotHeaders == nil {
745 panic("snapshotHeaders() must be called after collectHeadersForSnapshot()")
746 }
747 return l.collectedSnapshotHeaders
Colin Cross4d9c2d12016-07-29 12:48:20 -0700748}
749
Chris Parsons3c27ca32020-11-20 12:42:07 -0500750// linkerProps returns the list of properties structs relevant for this library. (For example, if
751// the library is cc_shared_library, then static-library properties are omitted.)
Colin Crossb916a382016-07-29 17:28:03 -0700752func (library *libraryDecorator) linkerProps() []interface{} {
753 var props []interface{}
754 props = append(props, library.baseLinker.linkerProps()...)
Colin Crosse1bb5d02019-09-24 14:55:04 -0700755 props = append(props,
Colin Cross4d9c2d12016-07-29 12:48:20 -0700756 &library.Properties,
Colin Crossa48ab5b2017-02-14 15:28:44 -0800757 &library.MutatedProperties,
Colin Cross4d9c2d12016-07-29 12:48:20 -0700758 &library.flagExporter.Properties,
Colin Cross22f37952018-09-05 10:43:13 -0700759 &library.stripper.StripProperties)
Colin Crosse1bb5d02019-09-24 14:55:04 -0700760
761 if library.MutatedProperties.BuildShared {
762 props = append(props, &library.SharedProperties)
763 }
764 if library.MutatedProperties.BuildStatic {
765 props = append(props, &library.StaticProperties)
766 }
767
768 return props
Colin Cross4d9c2d12016-07-29 12:48:20 -0700769}
770
Chris Parsons3c27ca32020-11-20 12:42:07 -0500771// linkerFlags takes a Flags struct and augments it to contain linker flags that are defined by this
772// library, or that are implied by attributes of this library (such as whether this library is a
773// shared library).
Colin Crossb916a382016-07-29 17:28:03 -0700774func (library *libraryDecorator) linkerFlags(ctx ModuleContext, flags Flags) Flags {
Colin Cross42742b82016-08-01 13:20:05 -0700775 flags = library.baseLinker.linkerFlags(ctx, flags)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700776
Colin Crossb916a382016-07-29 17:28:03 -0700777 // MinGW spits out warnings about -fPIC even for -fpie?!) being ignored because
778 // all code is position independent, and then those warnings get promoted to
779 // errors.
Colin Cross3edeee12017-04-04 12:59:48 -0700780 if !ctx.Windows() {
Colin Cross4af21ed2019-11-04 09:37:55 -0800781 flags.Global.CFlags = append(flags.Global.CFlags, "-fPIC")
Colin Crossb916a382016-07-29 17:28:03 -0700782 }
783
784 if library.static() {
Colin Cross4af21ed2019-11-04 09:37:55 -0800785 flags.Local.CFlags = append(flags.Local.CFlags, library.StaticProperties.Static.Cflags...)
Colin Crossa48ab5b2017-02-14 15:28:44 -0800786 } else if library.shared() {
Colin Cross4af21ed2019-11-04 09:37:55 -0800787 flags.Local.CFlags = append(flags.Local.CFlags, library.SharedProperties.Shared.Cflags...)
Colin Crossb916a382016-07-29 17:28:03 -0700788 }
789
Colin Crossa48ab5b2017-02-14 15:28:44 -0800790 if library.shared() {
Colin Cross4d9c2d12016-07-29 12:48:20 -0700791 libName := library.getLibName(ctx)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700792 var f []string
Dan Willemsen01a405a2016-06-13 17:19:03 -0700793 if ctx.toolchain().Bionic() {
Colin Cross4d9c2d12016-07-29 12:48:20 -0700794 f = append(f,
795 "-nostdlib",
796 "-Wl,--gc-sections",
797 )
798 }
799
800 if ctx.Darwin() {
801 f = append(f,
802 "-dynamiclib",
803 "-single_module",
Colin Cross4d9c2d12016-07-29 12:48:20 -0700804 "-install_name @rpath/"+libName+flags.Toolchain.ShlibSuffix(),
805 )
Colin Cross7863cf52016-10-20 10:47:21 -0700806 if ctx.Arch().ArchType == android.X86 {
807 f = append(f,
808 "-read_only_relocs suppress",
809 )
810 }
Colin Cross4d9c2d12016-07-29 12:48:20 -0700811 } else {
Josh Gao75a50a22019-06-07 17:58:59 -0700812 f = append(f, "-shared")
813 if !ctx.Windows() {
814 f = append(f, "-Wl,-soname,"+libName+flags.Toolchain.ShlibSuffix())
815 }
Colin Cross4d9c2d12016-07-29 12:48:20 -0700816 }
817
Colin Cross4af21ed2019-11-04 09:37:55 -0800818 flags.Global.LdFlags = append(flags.Global.LdFlags, f...)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700819 }
820
821 return flags
822}
823
Chris Parsons3c27ca32020-11-20 12:42:07 -0500824// compilerFlags takes a Flags and augments it to contain compile flags from global values,
825// per-target values, module type values, per-module Blueprints properties, extra flags from
826// `flags`, and generated sources from `deps`.
Colin Crossf18e1102017-11-16 14:33:08 -0800827func (library *libraryDecorator) compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags {
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700828 exportIncludeDirs := library.flagExporter.exportedIncludes(ctx)
Dan Willemsen273af7f2016-11-03 15:53:42 -0700829 if len(exportIncludeDirs) > 0 {
Colin Crossdad8c952017-04-26 14:55:27 -0700830 f := includeDirsToFlags(exportIncludeDirs)
Colin Cross4af21ed2019-11-04 09:37:55 -0800831 flags.Local.CommonFlags = append(flags.Local.CommonFlags, f)
832 flags.Local.YasmFlags = append(flags.Local.YasmFlags, f)
Dan Willemsen273af7f2016-11-03 15:53:42 -0700833 }
834
Jiyong Park7ed9de32018-10-15 22:25:07 +0900835 flags = library.baseCompiler.compilerFlags(ctx, flags, deps)
Colin Cross127bb8b2020-12-16 16:46:01 -0800836 if ctx.IsLlndk() {
837 // LLNDK libraries ignore most of the properties on the cc_library and use the
838 // LLNDK-specific properties instead.
839 // Wipe all the module-local properties, leaving only the global properties.
840 flags.Local = LocalOrGlobalFlags{}
841 }
Jiyong Park7ed9de32018-10-15 22:25:07 +0900842 if library.buildStubs() {
Jiyong Park64379952018-12-13 18:37:29 +0900843 // Remove -include <file> when compiling stubs. Otherwise, the force included
844 // headers might cause conflicting types error with the symbols in the
845 // generated stubs source code. e.g.
846 // double acos(double); // in header
847 // void acos() {} // in the generated source code
848 removeInclude := func(flags []string) []string {
849 ret := flags[:0]
850 for _, f := range flags {
851 if strings.HasPrefix(f, "-include ") {
852 continue
853 }
854 ret = append(ret, f)
855 }
856 return ret
857 }
Colin Cross4af21ed2019-11-04 09:37:55 -0800858 flags.Local.CommonFlags = removeInclude(flags.Local.CommonFlags)
859 flags.Local.CFlags = removeInclude(flags.Local.CFlags)
Jiyong Park64379952018-12-13 18:37:29 +0900860
Jiyong Park7ed9de32018-10-15 22:25:07 +0900861 flags = addStubLibraryCompilerFlags(flags)
862 }
863 return flags
Dan Willemsen273af7f2016-11-03 15:53:42 -0700864}
865
Yo Chiang2bbadfa2020-12-14 11:42:16 +0800866func (library *libraryDecorator) headerAbiCheckerEnabled() bool {
867 return Bool(library.Properties.Header_abi_checker.Enabled)
Hsin-Yi Chen53489642019-07-31 17:10:45 +0800868}
869
Yo Chiang2bbadfa2020-12-14 11:42:16 +0800870func (library *libraryDecorator) headerAbiCheckerExplicitlyDisabled() bool {
871 return !BoolDefault(library.Properties.Header_abi_checker.Enabled, true)
Logan Chien41eabe62019-04-10 13:33:58 +0800872}
873
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700874func (library *libraryDecorator) compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects {
Colin Cross127bb8b2020-12-16 16:46:01 -0800875 if ctx.IsLlndk() {
876 // This is the vendor variant of an LLNDK library, build the LLNDK stubs.
877 vndkVer := ctx.Module().(*Module).VndkVersion()
878 if !inList(vndkVer, ctx.Config().PlatformVersionActiveCodenames()) || vndkVer == "" {
879 // For non-enforcing devices, vndkVer is empty. Use "current" in that case, too.
880 vndkVer = "current"
881 }
882 if library.stubsVersion() != "" {
883 vndkVer = library.stubsVersion()
884 }
Dan Albertf1d14c72020-07-30 14:32:55 -0700885 nativeAbiResult := parseNativeAbiDefinition(ctx,
886 String(library.Properties.Llndk.Symbol_file),
887 android.ApiLevelOrPanic(ctx, vndkVer), "--llndk")
888 objs := compileStubLibrary(ctx, flags, nativeAbiResult.stubSrc)
Colin Cross127bb8b2020-12-16 16:46:01 -0800889 if !Bool(library.Properties.Llndk.Unversioned) {
Dan Albertf1d14c72020-07-30 14:32:55 -0700890 library.versionScriptPath = android.OptionalPathForPath(
891 nativeAbiResult.versionScript)
Colin Cross127bb8b2020-12-16 16:46:01 -0800892 }
893 return objs
894 }
Colin Cross5271fea2021-04-27 13:06:04 -0700895 if ctx.IsVendorPublicLibrary() {
Dan Albertf1d14c72020-07-30 14:32:55 -0700896 nativeAbiResult := parseNativeAbiDefinition(ctx,
897 String(library.Properties.Vendor_public_library.Symbol_file),
898 android.FutureApiLevel, "")
899 objs := compileStubLibrary(ctx, flags, nativeAbiResult.stubSrc)
Colin Cross5271fea2021-04-27 13:06:04 -0700900 if !Bool(library.Properties.Vendor_public_library.Unversioned) {
Dan Albertf1d14c72020-07-30 14:32:55 -0700901 library.versionScriptPath = android.OptionalPathForPath(nativeAbiResult.versionScript)
Colin Cross5271fea2021-04-27 13:06:04 -0700902 }
903 return objs
904 }
Jiyong Park7ed9de32018-10-15 22:25:07 +0900905 if library.buildStubs() {
Jiyong Parka4175572021-02-04 21:05:47 +0900906 symbolFile := String(library.Properties.Stubs.Symbol_file)
907 if symbolFile != "" && !strings.HasSuffix(symbolFile, ".map.txt") {
908 ctx.PropertyErrorf("symbol_file", "%q doesn't have .map.txt suffix", symbolFile)
909 return Objects{}
910 }
Dan Albertf1d14c72020-07-30 14:32:55 -0700911 nativeAbiResult := parseNativeAbiDefinition(ctx, symbolFile,
912 android.ApiLevelOrPanic(ctx, library.MutatedProperties.StubsVersion),
913 "--apex")
914 objs := compileStubLibrary(ctx, flags, nativeAbiResult.stubSrc)
915 library.versionScriptPath = android.OptionalPathForPath(
916 nativeAbiResult.versionScript)
Jiyong Park7ed9de32018-10-15 22:25:07 +0900917 return objs
918 }
919
Colin Cross5950f382016-12-13 12:50:57 -0800920 if !library.buildShared() && !library.buildStatic() {
921 if len(library.baseCompiler.Properties.Srcs) > 0 {
922 ctx.PropertyErrorf("srcs", "cc_library_headers must not have any srcs")
923 }
Colin Crosse1bb5d02019-09-24 14:55:04 -0700924 if len(library.StaticProperties.Static.Srcs) > 0 {
Colin Cross5950f382016-12-13 12:50:57 -0800925 ctx.PropertyErrorf("static.srcs", "cc_library_headers must not have any srcs")
926 }
Colin Crosse1bb5d02019-09-24 14:55:04 -0700927 if len(library.SharedProperties.Shared.Srcs) > 0 {
Colin Cross5950f382016-12-13 12:50:57 -0800928 ctx.PropertyErrorf("shared.srcs", "cc_library_headers must not have any srcs")
929 }
930 return Objects{}
931 }
Yo Chiang2bbadfa2020-12-14 11:42:16 +0800932 if library.sabi.shouldCreateSourceAbiDump() {
Jayant Chowdharya4fce192017-09-06 13:10:03 -0700933 exportIncludeDirs := library.flagExporter.exportedIncludes(ctx)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800934 var SourceAbiFlags []string
935 for _, dir := range exportIncludeDirs.Strings() {
Jayant Chowdhary715cac32017-04-20 06:53:59 -0700936 SourceAbiFlags = append(SourceAbiFlags, "-I"+dir)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800937 }
Inseob Kim69378442019-06-03 19:10:47 +0900938 for _, reexportedInclude := range library.sabi.Properties.ReexportedIncludes {
939 SourceAbiFlags = append(SourceAbiFlags, "-I"+reexportedInclude)
Jayant Chowdhary715cac32017-04-20 06:53:59 -0700940 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800941 flags.SAbiFlags = SourceAbiFlags
Jaewoong Jung18aefc12020-12-21 09:11:10 -0800942 totalLength := len(library.baseCompiler.Properties.Srcs) + len(deps.GeneratedSources) +
Colin Crosse1bb5d02019-09-24 14:55:04 -0700943 len(library.SharedProperties.Shared.Srcs) + len(library.StaticProperties.Static.Srcs)
Jaewoong Jung18aefc12020-12-21 09:11:10 -0800944 if totalLength > 0 {
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800945 flags.SAbiDump = true
946 }
947 }
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700948 objs := library.baseCompiler.compile(ctx, flags, deps)
949 library.reuseObjects = objs
Colin Cross2f336352016-10-26 10:03:47 -0700950 buildFlags := flagsToBuilderFlags(flags)
Colin Crossb916a382016-07-29 17:28:03 -0700951
Colin Cross4d9c2d12016-07-29 12:48:20 -0700952 if library.static() {
Colin Crosse1bb5d02019-09-24 14:55:04 -0700953 srcs := android.PathsForModuleSrc(ctx, library.StaticProperties.Static.Srcs)
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700954 objs = objs.Append(compileObjs(ctx, buildFlags, android.DeviceStaticLibrary,
Pirama Arumuga Nainarf231b192018-01-23 10:49:04 -0800955 srcs, library.baseCompiler.pathDeps, library.baseCompiler.cFlagsDeps))
Colin Crossa48ab5b2017-02-14 15:28:44 -0800956 } else if library.shared() {
Colin Crosse1bb5d02019-09-24 14:55:04 -0700957 srcs := android.PathsForModuleSrc(ctx, library.SharedProperties.Shared.Srcs)
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700958 objs = objs.Append(compileObjs(ctx, buildFlags, android.DeviceSharedLibrary,
Pirama Arumuga Nainarf231b192018-01-23 10:49:04 -0800959 srcs, library.baseCompiler.pathDeps, library.baseCompiler.cFlagsDeps))
Colin Crossb916a382016-07-29 17:28:03 -0700960 }
961
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700962 return objs
Colin Crossb916a382016-07-29 17:28:03 -0700963}
964
965type libraryInterface interface {
Colin Cross3572cf72020-10-01 15:58:11 -0700966 versionedInterface
967
Colin Crossb916a382016-07-29 17:28:03 -0700968 static() bool
Inseob Kimae553032019-05-14 18:52:49 +0900969 shared() bool
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700970 objs() Objects
Colin Cross0de8a1e2020-09-18 14:15:30 -0700971 reuseObjs() Objects
Colin Cross26c34ed2016-09-30 17:10:16 -0700972 toc() android.OptionalPath
Colin Crossb916a382016-07-29 17:28:03 -0700973
974 // Returns true if the build options for the module have selected a static or shared build
975 buildStatic() bool
976 buildShared() bool
977
978 // Sets whether a specific variant is static or shared
Colin Crossa48ab5b2017-02-14 15:28:44 -0800979 setStatic()
980 setShared()
Logan Chien41eabe62019-04-10 13:33:58 +0800981
Yo Chiang2bbadfa2020-12-14 11:42:16 +0800982 // Check whether header_abi_checker is enabled or explicitly disabled.
983 headerAbiCheckerEnabled() bool
984 headerAbiCheckerExplicitlyDisabled() bool
985
Logan Chien41eabe62019-04-10 13:33:58 +0800986 // Write LOCAL_ADDITIONAL_DEPENDENCIES for ABI diff
987 androidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer)
Jiyong Parka90ca002019-10-07 15:47:24 +0900988
989 availableFor(string) bool
Colin Crossb916a382016-07-29 17:28:03 -0700990}
991
Colin Crossc88c2722020-09-28 17:32:47 -0700992type versionedInterface interface {
993 buildStubs() bool
Jiyong Parkd4a3a132021-03-17 20:21:35 +0900994 setBuildStubs(isLatest bool)
Colin Crossc88c2722020-09-28 17:32:47 -0700995 hasStubsVariants() bool
996 setStubsVersion(string)
997 stubsVersion() string
998
Colin Cross3572cf72020-10-01 15:58:11 -0700999 stubsVersions(ctx android.BaseMutatorContext) []string
Colin Crossc88c2722020-09-28 17:32:47 -07001000 setAllStubsVersions([]string)
1001 allStubsVersions() []string
Colin Cross0477b422020-10-13 18:43:54 -07001002
1003 implementationModuleName(name string) string
Colin Cross127bb8b2020-12-16 16:46:01 -08001004 hasLLNDKStubs() bool
Colin Cross1f3f1302021-04-26 18:37:44 -07001005 hasLLNDKHeaders() bool
Colin Cross5271fea2021-04-27 13:06:04 -07001006 hasVendorPublicLibrary() bool
Colin Crossc88c2722020-09-28 17:32:47 -07001007}
1008
1009var _ libraryInterface = (*libraryDecorator)(nil)
1010var _ versionedInterface = (*libraryDecorator)(nil)
1011
Justin Yun6977e8a2020-10-29 18:24:11 +09001012func (library *libraryDecorator) getLibNameHelper(baseModuleName string, inVendor bool, inProduct bool) string {
Colin Crossb916a382016-07-29 17:28:03 -07001013 name := library.libName
1014 if name == "" {
dimitryd95964a2018-11-07 13:43:34 +01001015 name = String(library.Properties.Stem)
1016 if name == "" {
Jooyung Han0302a842019-10-30 18:43:49 +09001017 name = baseModuleName
dimitryd95964a2018-11-07 13:43:34 +01001018 }
Colin Crossb916a382016-07-29 17:28:03 -07001019 }
1020
Colin Cross0fd6a412019-08-16 14:22:10 -07001021 suffix := ""
Justin Yun6977e8a2020-10-29 18:24:11 +09001022 if inVendor {
Colin Cross0fd6a412019-08-16 14:22:10 -07001023 suffix = String(library.Properties.Target.Vendor.Suffix)
Justin Yun6977e8a2020-10-29 18:24:11 +09001024 } else if inProduct {
1025 suffix = String(library.Properties.Target.Product.Suffix)
Colin Cross0fd6a412019-08-16 14:22:10 -07001026 }
1027 if suffix == "" {
1028 suffix = String(library.Properties.Suffix)
1029 }
1030
Jooyung Han0302a842019-10-30 18:43:49 +09001031 return name + suffix
1032}
1033
Chris Parsons3c27ca32020-11-20 12:42:07 -05001034// getLibName returns the actual canonical name of the library (the name which
1035// should be passed to the linker via linker flags).
Jooyung Han0302a842019-10-30 18:43:49 +09001036func (library *libraryDecorator) getLibName(ctx BaseModuleContext) string {
Justin Yun6977e8a2020-10-29 18:24:11 +09001037 name := library.getLibNameHelper(ctx.baseModuleName(), ctx.inVendor(), ctx.inProduct())
Colin Cross0fd6a412019-08-16 14:22:10 -07001038
Ivan Lozanof9e21722020-12-02 09:00:51 -05001039 if ctx.IsVndkExt() {
Jooyung Han4c2b9422019-10-22 19:53:47 +09001040 // vndk-ext lib should have the same name with original lib
1041 ctx.VisitDirectDepsWithTag(vndkExtDepTag, func(module android.Module) {
1042 originalName := module.(*Module).outputFile.Path()
1043 name = strings.TrimSuffix(originalName.Base(), originalName.Ext())
1044 })
Logan Chienf3511742017-10-31 18:04:35 +08001045 }
1046
Colin Crossb916a382016-07-29 17:28:03 -07001047 if ctx.Host() && Bool(library.Properties.Unique_host_soname) {
1048 if !strings.HasSuffix(name, "-host") {
1049 name = name + "-host"
1050 }
1051 }
1052
Inseob Kim0ce291e2019-07-04 14:38:27 +09001053 return name
Colin Crossb916a382016-07-29 17:28:03 -07001054}
1055
Jiyong Parkda732bd2018-11-02 18:23:15 +09001056var versioningMacroNamesListMutex sync.Mutex
1057
Colin Crossb916a382016-07-29 17:28:03 -07001058func (library *libraryDecorator) linkerInit(ctx BaseModuleContext) {
1059 location := InstallInSystem
Dan Albert61f32122018-07-26 14:00:24 -07001060 if library.baseLinker.sanitize.inSanitizerDir() {
Vishwath Mohan1dd88392017-03-29 22:00:18 -07001061 location = InstallInSanitizerDir
Colin Crossb916a382016-07-29 17:28:03 -07001062 }
1063 library.baseInstaller.location = location
Colin Crossb916a382016-07-29 17:28:03 -07001064 library.baseLinker.linkerInit(ctx)
Jiyong Park7ed9de32018-10-15 22:25:07 +09001065 // Let baseLinker know whether this variant is for stubs or not, so that
1066 // it can omit things that are not required for linking stubs.
1067 library.baseLinker.dynamicProperties.BuildStubs = library.buildStubs()
Jiyong Parkda732bd2018-11-02 18:23:15 +09001068
1069 if library.buildStubs() {
1070 macroNames := versioningMacroNamesList(ctx.Config())
1071 myName := versioningMacroName(ctx.ModuleName())
1072 versioningMacroNamesListMutex.Lock()
1073 defer versioningMacroNamesListMutex.Unlock()
1074 if (*macroNames)[myName] == "" {
1075 (*macroNames)[myName] = ctx.ModuleName()
1076 } else if (*macroNames)[myName] != ctx.ModuleName() {
1077 ctx.ModuleErrorf("Macro name %q for versioning conflicts with macro name from module %q ", myName, (*macroNames)[myName])
1078 }
1079 }
Colin Crossb916a382016-07-29 17:28:03 -07001080}
1081
dimitry0345ad82018-12-05 16:28:14 +01001082func (library *libraryDecorator) compilerDeps(ctx DepsContext, deps Deps) Deps {
Colin Cross127bb8b2020-12-16 16:46:01 -08001083 if ctx.IsLlndk() {
1084 // LLNDK libraries ignore most of the properties on the cc_library and use the
1085 // LLNDK-specific properties instead.
1086 return deps
1087 }
1088
dimitry0345ad82018-12-05 16:28:14 +01001089 deps = library.baseCompiler.compilerDeps(ctx, deps)
1090
dimitry0345ad82018-12-05 16:28:14 +01001091 return deps
1092}
1093
Colin Cross37047f12016-12-13 17:06:13 -08001094func (library *libraryDecorator) linkerDeps(ctx DepsContext, deps Deps) Deps {
Colin Cross127bb8b2020-12-16 16:46:01 -08001095 if ctx.IsLlndk() {
1096 // LLNDK libraries ignore most of the properties on the cc_library and use the
1097 // LLNDK-specific properties instead.
Colin Cross0fb7fcd2021-03-02 11:00:07 -08001098 deps.HeaderLibs = append([]string(nil), library.Properties.Llndk.Export_llndk_headers...)
1099 deps.ReexportHeaderLibHeaders = append([]string(nil), library.Properties.Llndk.Export_llndk_headers...)
Colin Cross127bb8b2020-12-16 16:46:01 -08001100 return deps
1101 }
Colin Cross5271fea2021-04-27 13:06:04 -07001102 if ctx.IsVendorPublicLibrary() {
1103 headers := library.Properties.Vendor_public_library.Export_public_headers
1104 deps.HeaderLibs = append([]string(nil), headers...)
1105 deps.ReexportHeaderLibHeaders = append([]string(nil), headers...)
1106 return deps
1107 }
Colin Cross127bb8b2020-12-16 16:46:01 -08001108
Dan Willemsen3a26eef2018-12-03 15:25:46 -08001109 if library.static() {
Martin Stjernholm10566a02020-03-24 01:19:52 +00001110 // Compare with nil because an empty list needs to be propagated.
Colin Crosse1bb5d02019-09-24 14:55:04 -07001111 if library.StaticProperties.Static.System_shared_libs != nil {
1112 library.baseLinker.Properties.System_shared_libs = library.StaticProperties.Static.System_shared_libs
Dan Willemsen3a26eef2018-12-03 15:25:46 -08001113 }
1114 } else if library.shared() {
Martin Stjernholm10566a02020-03-24 01:19:52 +00001115 // Compare with nil because an empty list needs to be propagated.
Colin Crosse1bb5d02019-09-24 14:55:04 -07001116 if library.SharedProperties.Shared.System_shared_libs != nil {
1117 library.baseLinker.Properties.System_shared_libs = library.SharedProperties.Shared.System_shared_libs
Dan Willemsen3a26eef2018-12-03 15:25:46 -08001118 }
1119 }
1120
Colin Crossb916a382016-07-29 17:28:03 -07001121 deps = library.baseLinker.linkerDeps(ctx, deps)
1122
1123 if library.static() {
1124 deps.WholeStaticLibs = append(deps.WholeStaticLibs,
Colin Crosse1bb5d02019-09-24 14:55:04 -07001125 library.StaticProperties.Static.Whole_static_libs...)
1126 deps.StaticLibs = append(deps.StaticLibs, library.StaticProperties.Static.Static_libs...)
1127 deps.SharedLibs = append(deps.SharedLibs, library.StaticProperties.Static.Shared_libs...)
Colin Crosseefe9a32019-01-22 14:41:08 -08001128
Colin Crosse1bb5d02019-09-24 14:55:04 -07001129 deps.ReexportSharedLibHeaders = append(deps.ReexportSharedLibHeaders, library.StaticProperties.Static.Export_shared_lib_headers...)
1130 deps.ReexportStaticLibHeaders = append(deps.ReexportStaticLibHeaders, library.StaticProperties.Static.Export_static_lib_headers...)
Colin Crossa48ab5b2017-02-14 15:28:44 -08001131 } else if library.shared() {
Dan Willemsen2e47b342016-11-17 01:02:25 -08001132 if ctx.toolchain().Bionic() && !Bool(library.baseLinker.Properties.Nocrt) {
Dan Albert92fe7402020-07-15 13:33:30 -07001133 deps.CrtBegin = "crtbegin_so"
1134 deps.CrtEnd = "crtend_so"
Colin Cross4d9c2d12016-07-29 12:48:20 -07001135 }
Colin Crosse1bb5d02019-09-24 14:55:04 -07001136 deps.WholeStaticLibs = append(deps.WholeStaticLibs, library.SharedProperties.Shared.Whole_static_libs...)
1137 deps.StaticLibs = append(deps.StaticLibs, library.SharedProperties.Shared.Static_libs...)
1138 deps.SharedLibs = append(deps.SharedLibs, library.SharedProperties.Shared.Shared_libs...)
Colin Crosseefe9a32019-01-22 14:41:08 -08001139
Colin Crosse1bb5d02019-09-24 14:55:04 -07001140 deps.ReexportSharedLibHeaders = append(deps.ReexportSharedLibHeaders, library.SharedProperties.Shared.Export_shared_lib_headers...)
1141 deps.ReexportStaticLibHeaders = append(deps.ReexportStaticLibHeaders, library.SharedProperties.Shared.Export_static_lib_headers...)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001142 }
Justin Yun6977e8a2020-10-29 18:24:11 +09001143 if ctx.inVendor() {
Jiyong Park52d25bd2017-10-13 09:17:01 +09001144 deps.WholeStaticLibs = removeListFromList(deps.WholeStaticLibs, library.baseLinker.Properties.Target.Vendor.Exclude_static_libs)
1145 deps.SharedLibs = removeListFromList(deps.SharedLibs, library.baseLinker.Properties.Target.Vendor.Exclude_shared_libs)
1146 deps.StaticLibs = removeListFromList(deps.StaticLibs, library.baseLinker.Properties.Target.Vendor.Exclude_static_libs)
Victor Chang51271c12019-01-30 16:02:22 +00001147 deps.ReexportSharedLibHeaders = removeListFromList(deps.ReexportSharedLibHeaders, library.baseLinker.Properties.Target.Vendor.Exclude_shared_libs)
1148 deps.ReexportStaticLibHeaders = removeListFromList(deps.ReexportStaticLibHeaders, library.baseLinker.Properties.Target.Vendor.Exclude_static_libs)
Jiyong Park52d25bd2017-10-13 09:17:01 +09001149 }
Justin Yun6977e8a2020-10-29 18:24:11 +09001150 if ctx.inProduct() {
1151 deps.WholeStaticLibs = removeListFromList(deps.WholeStaticLibs, library.baseLinker.Properties.Target.Product.Exclude_static_libs)
1152 deps.SharedLibs = removeListFromList(deps.SharedLibs, library.baseLinker.Properties.Target.Product.Exclude_shared_libs)
1153 deps.StaticLibs = removeListFromList(deps.StaticLibs, library.baseLinker.Properties.Target.Product.Exclude_static_libs)
1154 deps.ReexportSharedLibHeaders = removeListFromList(deps.ReexportSharedLibHeaders, library.baseLinker.Properties.Target.Product.Exclude_shared_libs)
1155 deps.ReexportStaticLibHeaders = removeListFromList(deps.ReexportStaticLibHeaders, library.baseLinker.Properties.Target.Product.Exclude_static_libs)
1156 }
Jiyong Parkf9332f12018-02-01 00:54:12 +09001157 if ctx.inRecovery() {
1158 deps.WholeStaticLibs = removeListFromList(deps.WholeStaticLibs, library.baseLinker.Properties.Target.Recovery.Exclude_static_libs)
1159 deps.SharedLibs = removeListFromList(deps.SharedLibs, library.baseLinker.Properties.Target.Recovery.Exclude_shared_libs)
1160 deps.StaticLibs = removeListFromList(deps.StaticLibs, library.baseLinker.Properties.Target.Recovery.Exclude_static_libs)
Victor Chang51271c12019-01-30 16:02:22 +00001161 deps.ReexportSharedLibHeaders = removeListFromList(deps.ReexportSharedLibHeaders, library.baseLinker.Properties.Target.Recovery.Exclude_shared_libs)
1162 deps.ReexportStaticLibHeaders = removeListFromList(deps.ReexportStaticLibHeaders, library.baseLinker.Properties.Target.Recovery.Exclude_static_libs)
Jiyong Parkf9332f12018-02-01 00:54:12 +09001163 }
Yifan Hongcf4832c2020-01-21 17:04:13 -08001164 if ctx.inRamdisk() {
1165 deps.WholeStaticLibs = removeListFromList(deps.WholeStaticLibs, library.baseLinker.Properties.Target.Ramdisk.Exclude_static_libs)
1166 deps.SharedLibs = removeListFromList(deps.SharedLibs, library.baseLinker.Properties.Target.Ramdisk.Exclude_shared_libs)
1167 deps.StaticLibs = removeListFromList(deps.StaticLibs, library.baseLinker.Properties.Target.Ramdisk.Exclude_static_libs)
1168 deps.ReexportSharedLibHeaders = removeListFromList(deps.ReexportSharedLibHeaders, library.baseLinker.Properties.Target.Ramdisk.Exclude_shared_libs)
1169 deps.ReexportStaticLibHeaders = removeListFromList(deps.ReexportStaticLibHeaders, library.baseLinker.Properties.Target.Ramdisk.Exclude_static_libs)
1170 }
Yifan Hong6da33c22020-10-27 15:01:21 -07001171 if ctx.inVendorRamdisk() {
1172 deps.WholeStaticLibs = removeListFromList(deps.WholeStaticLibs, library.baseLinker.Properties.Target.Vendor_ramdisk.Exclude_static_libs)
1173 deps.SharedLibs = removeListFromList(deps.SharedLibs, library.baseLinker.Properties.Target.Vendor_ramdisk.Exclude_shared_libs)
1174 deps.StaticLibs = removeListFromList(deps.StaticLibs, library.baseLinker.Properties.Target.Vendor_ramdisk.Exclude_static_libs)
1175 deps.ReexportSharedLibHeaders = removeListFromList(deps.ReexportSharedLibHeaders, library.baseLinker.Properties.Target.Vendor_ramdisk.Exclude_shared_libs)
1176 deps.ReexportStaticLibHeaders = removeListFromList(deps.ReexportStaticLibHeaders, library.baseLinker.Properties.Target.Vendor_ramdisk.Exclude_static_libs)
1177 }
Colin Cross2383f3b2018-02-06 14:40:13 -08001178
Colin Cross4d9c2d12016-07-29 12:48:20 -07001179 return deps
1180}
1181
Paul Duffin13f02712020-03-06 12:30:43 +00001182func (library *libraryDecorator) linkerSpecifiedDeps(specifiedDeps specifiedDeps) specifiedDeps {
1183 specifiedDeps = library.baseLinker.linkerSpecifiedDeps(specifiedDeps)
1184 var properties StaticOrSharedProperties
1185 if library.static() {
1186 properties = library.StaticProperties.Static
1187 } else if library.shared() {
1188 properties = library.SharedProperties.Shared
1189 }
1190
1191 specifiedDeps.sharedLibs = append(specifiedDeps.sharedLibs, properties.Shared_libs...)
Martin Stjernholm10566a02020-03-24 01:19:52 +00001192
1193 // Must distinguish nil and [] in system_shared_libs - ensure that [] in
1194 // either input list doesn't come out as nil.
1195 if specifiedDeps.systemSharedLibs == nil {
1196 specifiedDeps.systemSharedLibs = properties.System_shared_libs
1197 } else {
1198 specifiedDeps.systemSharedLibs = append(specifiedDeps.systemSharedLibs, properties.System_shared_libs...)
1199 }
Paul Duffin13f02712020-03-06 12:30:43 +00001200
1201 specifiedDeps.sharedLibs = android.FirstUniqueStrings(specifiedDeps.sharedLibs)
Martin Stjernholm10566a02020-03-24 01:19:52 +00001202 if len(specifiedDeps.systemSharedLibs) > 0 {
1203 // Skip this if systemSharedLibs is either nil or [], to ensure they are
1204 // retained.
1205 specifiedDeps.systemSharedLibs = android.FirstUniqueStrings(specifiedDeps.systemSharedLibs)
1206 }
Paul Duffin13f02712020-03-06 12:30:43 +00001207 return specifiedDeps
1208}
1209
Colin Crossb916a382016-07-29 17:28:03 -07001210func (library *libraryDecorator) linkStatic(ctx ModuleContext,
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001211 flags Flags, deps PathDeps, objs Objects) android.Path {
Colin Cross4d9c2d12016-07-29 12:48:20 -07001212
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001213 library.objects = deps.WholeStaticLibObjs.Copy()
1214 library.objects = library.objects.Append(objs)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001215
Inseob Kim0ce291e2019-07-04 14:38:27 +09001216 fileName := ctx.ModuleName() + staticLibraryExtension
Colin Cross86803cf2018-02-15 14:12:26 -08001217 outputFile := android.PathForModuleOut(ctx, fileName)
Dan Willemsen581341d2017-02-09 16:16:31 -08001218 builderFlags := flagsToBuilderFlags(flags)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001219
Dan Willemsen569edc52018-11-19 09:33:29 -08001220 if Bool(library.baseLinker.Properties.Use_version_lib) {
1221 if ctx.Host() {
1222 versionedOutputFile := outputFile
1223 outputFile = android.PathForModuleOut(ctx, "unversioned", fileName)
1224 library.injectVersionSymbol(ctx, outputFile, versionedOutputFile)
1225 } else {
1226 versionedOutputFile := android.PathForModuleOut(ctx, "versioned", fileName)
Jingwen Chen40fd90a2020-06-15 05:24:19 +00001227 library.distFile = versionedOutputFile
Dan Willemsen569edc52018-11-19 09:33:29 -08001228 library.injectVersionSymbol(ctx, outputFile, versionedOutputFile)
1229 }
Colin Cross86803cf2018-02-15 14:12:26 -08001230 }
1231
Chris Parsonsbf4f55f2020-11-23 17:02:44 -05001232 transformObjToStaticLib(ctx, library.objects.objFiles, deps.WholeStaticLibsFromPrebuilts, builderFlags, outputFile, objs.tidyFiles)
Dan Willemsen581341d2017-02-09 16:16:31 -08001233
Chris Parsonsbf4f55f2020-11-23 17:02:44 -05001234 library.coverageOutputFile = transformCoverageFilesToZip(ctx, library.objects, ctx.ModuleName())
Colin Cross4d9c2d12016-07-29 12:48:20 -07001235
Colin Cross4d9c2d12016-07-29 12:48:20 -07001236 ctx.CheckbuildFile(outputFile)
1237
Colin Cross649d8172020-12-10 12:30:21 -08001238 if library.static() {
1239 ctx.SetProvider(StaticLibraryInfoProvider, StaticLibraryInfo{
1240 StaticLibrary: outputFile,
1241 ReuseObjects: library.reuseObjects,
1242 Objects: library.objects,
Colin Cross0de8a1e2020-09-18 14:15:30 -07001243
Colin Cross649d8172020-12-10 12:30:21 -08001244 TransitiveStaticLibrariesForOrdering: android.NewDepSetBuilder(android.TOPOLOGICAL).
1245 Direct(outputFile).
1246 Transitive(deps.TranstiveStaticLibrariesForOrdering).
1247 Build(),
1248 })
1249 }
1250
1251 if library.header() {
1252 ctx.SetProvider(HeaderLibraryInfoProvider, HeaderLibraryInfo{})
1253 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07001254
Colin Cross4d9c2d12016-07-29 12:48:20 -07001255 return outputFile
1256}
1257
Colin Crossb916a382016-07-29 17:28:03 -07001258func (library *libraryDecorator) linkShared(ctx ModuleContext,
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001259 flags Flags, deps PathDeps, objs Objects) android.Path {
Colin Cross4d9c2d12016-07-29 12:48:20 -07001260
1261 var linkerDeps android.Paths
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001262 linkerDeps = append(linkerDeps, flags.LdFlagsDeps...)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001263
Colin Cross2383f3b2018-02-06 14:40:13 -08001264 unexportedSymbols := ctx.ExpandOptionalSource(library.Properties.Unexported_symbols_list, "unexported_symbols_list")
1265 forceNotWeakSymbols := ctx.ExpandOptionalSource(library.Properties.Force_symbols_not_weak_list, "force_symbols_not_weak_list")
1266 forceWeakSymbols := ctx.ExpandOptionalSource(library.Properties.Force_symbols_weak_list, "force_symbols_weak_list")
Colin Cross4d9c2d12016-07-29 12:48:20 -07001267 if !ctx.Darwin() {
Colin Cross4d9c2d12016-07-29 12:48:20 -07001268 if unexportedSymbols.Valid() {
1269 ctx.PropertyErrorf("unexported_symbols_list", "Only supported on Darwin")
1270 }
1271 if forceNotWeakSymbols.Valid() {
1272 ctx.PropertyErrorf("force_symbols_not_weak_list", "Only supported on Darwin")
1273 }
1274 if forceWeakSymbols.Valid() {
1275 ctx.PropertyErrorf("force_symbols_weak_list", "Only supported on Darwin")
1276 }
1277 } else {
Colin Cross4d9c2d12016-07-29 12:48:20 -07001278 if unexportedSymbols.Valid() {
Colin Cross4af21ed2019-11-04 09:37:55 -08001279 flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,-unexported_symbols_list,"+unexportedSymbols.String())
Colin Cross4d9c2d12016-07-29 12:48:20 -07001280 linkerDeps = append(linkerDeps, unexportedSymbols.Path())
1281 }
1282 if forceNotWeakSymbols.Valid() {
Colin Cross4af21ed2019-11-04 09:37:55 -08001283 flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,-force_symbols_not_weak_list,"+forceNotWeakSymbols.String())
Colin Cross4d9c2d12016-07-29 12:48:20 -07001284 linkerDeps = append(linkerDeps, forceNotWeakSymbols.Path())
1285 }
1286 if forceWeakSymbols.Valid() {
Colin Cross4af21ed2019-11-04 09:37:55 -08001287 flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,-force_symbols_weak_list,"+forceWeakSymbols.String())
Colin Cross4d9c2d12016-07-29 12:48:20 -07001288 linkerDeps = append(linkerDeps, forceWeakSymbols.Path())
1289 }
1290 }
Colin Cross8e21aa52020-09-28 18:28:02 -07001291 if library.versionScriptPath.Valid() {
Jiyong Parkc1e7f482019-01-12 13:39:10 +09001292 linkerScriptFlags := "-Wl,--version-script," + library.versionScriptPath.String()
Colin Cross4af21ed2019-11-04 09:37:55 -08001293 flags.Local.LdFlags = append(flags.Local.LdFlags, linkerScriptFlags)
Colin Cross8e21aa52020-09-28 18:28:02 -07001294 linkerDeps = append(linkerDeps, library.versionScriptPath.Path())
Jiyong Parkc1e7f482019-01-12 13:39:10 +09001295 }
Colin Cross4d9c2d12016-07-29 12:48:20 -07001296
1297 fileName := library.getLibName(ctx) + flags.Toolchain.ShlibSuffix()
1298 outputFile := android.PathForModuleOut(ctx, fileName)
Colin Cross0de8a1e2020-09-18 14:15:30 -07001299 unstrippedOutputFile := outputFile
Colin Cross4d9c2d12016-07-29 12:48:20 -07001300
Josh Gao75a50a22019-06-07 17:58:59 -07001301 var implicitOutputs android.WritablePaths
1302 if ctx.Windows() {
1303 importLibraryPath := android.PathForModuleOut(ctx, pathtools.ReplaceExtension(fileName, "lib"))
1304
Colin Cross4af21ed2019-11-04 09:37:55 -08001305 flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,--out-implib="+importLibraryPath.String())
Josh Gao75a50a22019-06-07 17:58:59 -07001306 implicitOutputs = append(implicitOutputs, importLibraryPath)
1307 }
1308
Colin Cross4d9c2d12016-07-29 12:48:20 -07001309 builderFlags := flagsToBuilderFlags(flags)
1310
Colin Crossb496cfd2018-09-10 16:50:05 -07001311 // Optimize out relinking against shared libraries whose interface hasn't changed by
1312 // depending on a table of contents file instead of the library itself.
Colin Cross70dda7e2019-10-01 22:05:35 -07001313 tocFile := outputFile.ReplaceExtension(ctx, flags.Toolchain.ShlibSuffix()[1:]+".toc")
Colin Crossb496cfd2018-09-10 16:50:05 -07001314 library.tocFile = android.OptionalPathForPath(tocFile)
Chris Parsonsbf4f55f2020-11-23 17:02:44 -05001315 transformSharedObjectToToc(ctx, outputFile, tocFile, builderFlags)
Colin Cross89562dc2016-10-03 17:47:19 -07001316
Thiébaud Weksteend4587452020-08-19 14:53:01 +02001317 stripFlags := flagsToStripFlags(flags)
Colin Crossadc81a02020-12-14 17:01:55 -08001318 needsStrip := library.stripper.NeedsStrip(ctx)
1319 if library.buildStubs() {
1320 // No need to strip stubs libraries
1321 needsStrip = false
1322 }
1323 if needsStrip {
Yi Kongb5c34d72018-11-07 16:28:49 -08001324 if ctx.Darwin() {
Thiébaud Weksteend4587452020-08-19 14:53:01 +02001325 stripFlags.StripUseGnuStrip = true
Yi Kongb5c34d72018-11-07 16:28:49 -08001326 }
Colin Cross4d9c2d12016-07-29 12:48:20 -07001327 strippedOutputFile := outputFile
1328 outputFile = android.PathForModuleOut(ctx, "unstripped", fileName)
Thiébaud Weksteend4587452020-08-19 14:53:01 +02001329 library.stripper.StripExecutableOrSharedLib(ctx, outputFile, strippedOutputFile, stripFlags)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001330 }
Colin Crossb60190a2018-09-04 16:28:17 -07001331 library.unstrippedOutputFile = outputFile
1332
Colin Crossd7227f92019-09-05 14:26:33 -07001333 outputFile = maybeInjectBoringSSLHash(ctx, outputFile, library.Properties.Inject_bssl_hash, fileName)
Pete Bentley803e1612019-08-06 22:19:59 +01001334
Dan Willemsen569edc52018-11-19 09:33:29 -08001335 if Bool(library.baseLinker.Properties.Use_version_lib) {
1336 if ctx.Host() {
1337 versionedOutputFile := outputFile
1338 outputFile = android.PathForModuleOut(ctx, "unversioned", fileName)
1339 library.injectVersionSymbol(ctx, outputFile, versionedOutputFile)
1340 } else {
1341 versionedOutputFile := android.PathForModuleOut(ctx, "versioned", fileName)
Jingwen Chen40fd90a2020-06-15 05:24:19 +00001342 library.distFile = versionedOutputFile
Dan Willemsen569edc52018-11-19 09:33:29 -08001343
Thiébaud Weksteend4587452020-08-19 14:53:01 +02001344 if library.stripper.NeedsStrip(ctx) {
Dan Willemsen569edc52018-11-19 09:33:29 -08001345 out := android.PathForModuleOut(ctx, "versioned-stripped", fileName)
Jingwen Chen40fd90a2020-06-15 05:24:19 +00001346 library.distFile = out
Thiébaud Weksteend4587452020-08-19 14:53:01 +02001347 library.stripper.StripExecutableOrSharedLib(ctx, versionedOutputFile, out, stripFlags)
Dan Willemsen569edc52018-11-19 09:33:29 -08001348 }
1349
1350 library.injectVersionSymbol(ctx, outputFile, versionedOutputFile)
1351 }
Colin Cross86803cf2018-02-15 14:12:26 -08001352 }
1353
Jiyong Park64a44f22019-01-18 14:37:08 +09001354 sharedLibs := deps.EarlySharedLibs
1355 sharedLibs = append(sharedLibs, deps.SharedLibs...)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001356 sharedLibs = append(sharedLibs, deps.LateSharedLibs...)
1357
Jiyong Park64a44f22019-01-18 14:37:08 +09001358 linkerDeps = append(linkerDeps, deps.EarlySharedLibsDeps...)
Colin Cross26c34ed2016-09-30 17:10:16 -07001359 linkerDeps = append(linkerDeps, deps.SharedLibsDeps...)
1360 linkerDeps = append(linkerDeps, deps.LateSharedLibsDeps...)
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001361 linkerDeps = append(linkerDeps, objs.tidyFiles...)
Chris Parsonsbf4f55f2020-11-23 17:02:44 -05001362 transformObjToDynamicBinary(ctx, objs.objFiles, sharedLibs,
Colin Cross4d9c2d12016-07-29 12:48:20 -07001363 deps.StaticLibs, deps.LateStaticLibs, deps.WholeStaticLibs,
Josh Gao75a50a22019-06-07 17:58:59 -07001364 linkerDeps, deps.CrtBegin, deps.CrtEnd, false, builderFlags, outputFile, implicitOutputs)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001365
Dan Willemsen581341d2017-02-09 16:16:31 -08001366 objs.coverageFiles = append(objs.coverageFiles, deps.StaticLibObjs.coverageFiles...)
1367 objs.coverageFiles = append(objs.coverageFiles, deps.WholeStaticLibObjs.coverageFiles...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001368
1369 objs.sAbiDumpFiles = append(objs.sAbiDumpFiles, deps.StaticLibObjs.sAbiDumpFiles...)
1370 objs.sAbiDumpFiles = append(objs.sAbiDumpFiles, deps.WholeStaticLibObjs.sAbiDumpFiles...)
1371
Chris Parsonsbf4f55f2020-11-23 17:02:44 -05001372 library.coverageOutputFile = transformCoverageFilesToZip(ctx, objs, library.getLibName(ctx))
Colin Cross0de8a1e2020-09-18 14:15:30 -07001373 library.linkSAbiDumpFiles(ctx, objs, fileName, unstrippedOutputFile)
Dan Willemsen581341d2017-02-09 16:16:31 -08001374
Liz Kammeref6dfea2021-06-08 15:37:09 -04001375 var transitiveStaticLibrariesForOrdering *android.DepSet
Colin Cross0de8a1e2020-09-18 14:15:30 -07001376 if static := ctx.GetDirectDepsWithTag(staticVariantTag); len(static) > 0 {
1377 s := ctx.OtherModuleProvider(static[0], StaticLibraryInfoProvider).(StaticLibraryInfo)
Liz Kammeref6dfea2021-06-08 15:37:09 -04001378 transitiveStaticLibrariesForOrdering = s.TransitiveStaticLibrariesForOrdering
Colin Cross0de8a1e2020-09-18 14:15:30 -07001379 }
1380
1381 ctx.SetProvider(SharedLibraryInfoProvider, SharedLibraryInfo{
Liz Kammeref6dfea2021-06-08 15:37:09 -04001382 TableOfContents: android.OptionalPathForPath(tocFile),
1383 SharedLibrary: unstrippedOutputFile,
1384 TransitiveStaticLibrariesForOrdering: transitiveStaticLibrariesForOrdering,
1385 Target: ctx.Target(),
Colin Cross0de8a1e2020-09-18 14:15:30 -07001386 })
1387
1388 stubs := ctx.GetDirectDepsWithTag(stubImplDepTag)
1389 if len(stubs) > 0 {
Chris Parsons3c27ca32020-11-20 12:42:07 -05001390 var stubsInfo []SharedStubLibrary
Colin Cross0de8a1e2020-09-18 14:15:30 -07001391 for _, stub := range stubs {
1392 stubInfo := ctx.OtherModuleProvider(stub, SharedLibraryInfoProvider).(SharedLibraryInfo)
1393 flagInfo := ctx.OtherModuleProvider(stub, FlagExporterInfoProvider).(FlagExporterInfo)
Chris Parsons3c27ca32020-11-20 12:42:07 -05001394 stubsInfo = append(stubsInfo, SharedStubLibrary{
Colin Cross31076b32020-10-23 17:22:06 -07001395 Version: moduleLibraryInterface(stub).stubsVersion(),
Colin Cross0de8a1e2020-09-18 14:15:30 -07001396 SharedLibraryInfo: stubInfo,
1397 FlagExporterInfo: flagInfo,
1398 })
1399 }
Chris Parsons3c27ca32020-11-20 12:42:07 -05001400 ctx.SetProvider(SharedLibraryStubsProvider, SharedLibraryStubsInfo{
1401 SharedStubLibraries: stubsInfo,
Colin Cross0de8a1e2020-09-18 14:15:30 -07001402
Colin Cross127bb8b2020-12-16 16:46:01 -08001403 IsLLNDK: ctx.IsLlndk(),
Colin Cross0de8a1e2020-09-18 14:15:30 -07001404 })
1405 }
1406
1407 return unstrippedOutputFile
Colin Cross4d9c2d12016-07-29 12:48:20 -07001408}
1409
Jiyong Parkaf6d8952019-01-31 12:21:23 +09001410func (library *libraryDecorator) unstrippedOutputFilePath() android.Path {
1411 return library.unstrippedOutputFile
1412}
1413
Thiébaud Weksteend4587452020-08-19 14:53:01 +02001414func (library *libraryDecorator) disableStripping() {
1415 library.stripper.StripProperties.Strip.None = BoolPtr(true)
1416}
1417
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001418func (library *libraryDecorator) nativeCoverage() bool {
1419 if library.header() || library.buildStubs() {
1420 return false
1421 }
1422 return true
1423}
1424
Jiyong Parkee9a98d2019-08-09 14:44:36 +09001425func (library *libraryDecorator) coverageOutputFilePath() android.OptionalPath {
1426 return library.coverageOutputFile
1427}
1428
Logan Chien7eefdc42018-07-11 18:10:41 +08001429func getRefAbiDumpFile(ctx ModuleContext, vndkVersion, fileName string) android.Path {
Hsin-Yi Chen27d235f2020-03-26 17:50:29 +08001430 // The logic must be consistent with classifySourceAbiDump.
Colin Cross95f1ca02020-10-29 20:47:22 -07001431 isNdk := ctx.isNdk(ctx.Config())
Colin Cross127bb8b2020-12-16 16:46:01 -08001432 isLlndkOrVndk := ctx.IsLlndkPublic() || (ctx.useVndk() && ctx.isVndk())
Logan Chien7eefdc42018-07-11 18:10:41 +08001433
Hsin-Yi Chen53489642019-07-31 17:10:45 +08001434 refAbiDumpTextFile := android.PathForVndkRefAbiDump(ctx, vndkVersion, fileName, isNdk, isLlndkOrVndk, false)
1435 refAbiDumpGzipFile := android.PathForVndkRefAbiDump(ctx, vndkVersion, fileName, isNdk, isLlndkOrVndk, true)
Logan Chien7eefdc42018-07-11 18:10:41 +08001436
1437 if refAbiDumpTextFile.Valid() {
1438 if refAbiDumpGzipFile.Valid() {
1439 ctx.ModuleErrorf(
1440 "Two reference ABI dump files are found: %q and %q. Please delete the stale one.",
1441 refAbiDumpTextFile, refAbiDumpGzipFile)
1442 return nil
1443 }
1444 return refAbiDumpTextFile.Path()
1445 }
1446 if refAbiDumpGzipFile.Valid() {
Chris Parsonsbf4f55f2020-11-23 17:02:44 -05001447 return unzipRefDump(ctx, refAbiDumpGzipFile.Path(), fileName)
Logan Chien7eefdc42018-07-11 18:10:41 +08001448 }
1449 return nil
1450}
1451
Jayant Chowdhary6ab3d842017-06-26 12:52:58 -07001452func (library *libraryDecorator) linkSAbiDumpFiles(ctx ModuleContext, objs Objects, fileName string, soFile android.Path) {
Yo Chiang2bbadfa2020-12-14 11:42:16 +08001453 if library.sabi.shouldCreateSourceAbiDump() {
Inseob Kim96f17f02020-06-09 22:05:09 +09001454 var vndkVersion string
1455
1456 if ctx.useVndk() {
1457 // For modules linking against vndk, follow its vndk version
1458 vndkVersion = ctx.Module().(*Module).VndkVersion()
1459 } else {
1460 // Regard the other modules as PLATFORM_VNDK_VERSION
1461 vndkVersion = ctx.DeviceConfig().PlatformVndkVersion()
Logan Chienf3511742017-10-31 18:04:35 +08001462 }
1463
Jayant Chowdharya4fce192017-09-06 13:10:03 -07001464 exportIncludeDirs := library.flagExporter.exportedIncludes(ctx)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001465 var SourceAbiFlags []string
1466 for _, dir := range exportIncludeDirs.Strings() {
Jayant Chowdhary715cac32017-04-20 06:53:59 -07001467 SourceAbiFlags = append(SourceAbiFlags, "-I"+dir)
1468 }
Inseob Kim69378442019-06-03 19:10:47 +09001469 for _, reexportedInclude := range library.sabi.Properties.ReexportedIncludes {
1470 SourceAbiFlags = append(SourceAbiFlags, "-I"+reexportedInclude)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001471 }
1472 exportedHeaderFlags := strings.Join(SourceAbiFlags, " ")
Chris Parsonsbf4f55f2020-11-23 17:02:44 -05001473 library.sAbiOutputFile = transformDumpToLinkedDump(ctx, objs.sAbiDumpFiles, soFile, fileName, exportedHeaderFlags,
Jiyong Parka034b832019-08-27 14:02:19 +09001474 android.OptionalPathForModuleSrc(ctx, library.symbolFileForAbiCheck(ctx)),
Logan Chiene3d7a0d2019-01-17 00:18:02 +08001475 library.Properties.Header_abi_checker.Exclude_symbol_versions,
1476 library.Properties.Header_abi_checker.Exclude_symbol_tags)
Logan Chien2f2b8902018-07-10 15:01:19 +08001477
Yo Chiang2bbadfa2020-12-14 11:42:16 +08001478 addLsdumpPath(classifySourceAbiDump(ctx) + ":" + library.sAbiOutputFile.String())
Hsin-Yi Chen53489642019-07-31 17:10:45 +08001479
Logan Chien7eefdc42018-07-11 18:10:41 +08001480 refAbiDumpFile := getRefAbiDumpFile(ctx, vndkVersion, fileName)
1481 if refAbiDumpFile != nil {
Chris Parsonsbf4f55f2020-11-23 17:02:44 -05001482 library.sAbiDiff = sourceAbiDiff(ctx, library.sAbiOutputFile.Path(),
Logan Chien2a65dda2019-10-01 15:58:07 -07001483 refAbiDumpFile, fileName, exportedHeaderFlags,
1484 Bool(library.Properties.Header_abi_checker.Check_all_apis),
Colin Cross127bb8b2020-12-16 16:46:01 -08001485 ctx.IsLlndk(), ctx.isNdk(ctx.Config()), ctx.IsVndkExt())
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001486 }
1487 }
1488}
1489
Inseob Kimcc12d902021-05-14 20:15:55 +09001490func processLLNDKHeaders(ctx ModuleContext, srcHeaderDir string, outDir android.ModuleGenPath) (timestamp android.Path, installPaths android.WritablePaths) {
Colin Cross127bb8b2020-12-16 16:46:01 -08001491 srcDir := android.PathForModuleSrc(ctx, srcHeaderDir)
1492 srcFiles := ctx.GlobFiles(filepath.Join(srcDir.String(), "**/*.h"), nil)
1493
Colin Cross127bb8b2020-12-16 16:46:01 -08001494 for _, header := range srcFiles {
1495 headerDir := filepath.Dir(header.String())
1496 relHeaderDir, err := filepath.Rel(srcDir.String(), headerDir)
1497 if err != nil {
1498 ctx.ModuleErrorf("filepath.Rel(%q, %q) failed: %s",
1499 srcDir.String(), headerDir, err)
1500 continue
1501 }
1502
1503 installPaths = append(installPaths, outDir.Join(ctx, relHeaderDir, header.Base()))
1504 }
1505
Inseob Kimcc12d902021-05-14 20:15:55 +09001506 return processHeadersWithVersioner(ctx, srcDir, outDir, srcFiles, installPaths), installPaths
Colin Cross127bb8b2020-12-16 16:46:01 -08001507}
1508
Chris Parsons3c27ca32020-11-20 12:42:07 -05001509// link registers actions to link this library, and sets various fields
1510// on this library to reflect information that should be exported up the build
1511// tree (for example, exported flags and include paths).
Colin Crossb916a382016-07-29 17:28:03 -07001512func (library *libraryDecorator) link(ctx ModuleContext,
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001513 flags Flags, deps PathDeps, objs Objects) android.Path {
Colin Cross4d9c2d12016-07-29 12:48:20 -07001514
Colin Cross127bb8b2020-12-16 16:46:01 -08001515 if ctx.IsLlndk() {
1516 if len(library.Properties.Llndk.Export_preprocessed_headers) > 0 {
1517 // This is the vendor variant of an LLNDK library with preprocessed headers.
1518 genHeaderOutDir := android.PathForModuleGen(ctx, "include")
1519
1520 var timestampFiles android.Paths
1521 for _, dir := range library.Properties.Llndk.Export_preprocessed_headers {
Inseob Kimcc12d902021-05-14 20:15:55 +09001522 timestampFile, installPaths := processLLNDKHeaders(ctx, dir, genHeaderOutDir)
1523 timestampFiles = append(timestampFiles, timestampFile)
1524 library.addExportedGeneratedHeaders(installPaths.Paths()...)
Colin Cross127bb8b2020-12-16 16:46:01 -08001525 }
1526
1527 if Bool(library.Properties.Llndk.Export_headers_as_system) {
1528 library.reexportSystemDirs(genHeaderOutDir)
1529 } else {
1530 library.reexportDirs(genHeaderOutDir)
1531 }
1532
1533 library.reexportDeps(timestampFiles...)
1534 }
1535
Colin Cross0fb7fcd2021-03-02 11:00:07 -08001536 // override the module's export_include_dirs with llndk.override_export_include_dirs
1537 // if it is set.
1538 if override := library.Properties.Llndk.Override_export_include_dirs; override != nil {
1539 library.flagExporter.Properties.Export_include_dirs = override
1540 }
1541
Colin Cross127bb8b2020-12-16 16:46:01 -08001542 if Bool(library.Properties.Llndk.Export_headers_as_system) {
1543 library.flagExporter.Properties.Export_system_include_dirs = append(
1544 library.flagExporter.Properties.Export_system_include_dirs,
1545 library.flagExporter.Properties.Export_include_dirs...)
1546 library.flagExporter.Properties.Export_include_dirs = nil
1547 }
1548 }
1549
Colin Cross5271fea2021-04-27 13:06:04 -07001550 if ctx.IsVendorPublicLibrary() {
1551 // override the module's export_include_dirs with vendor_public_library.override_export_include_dirs
1552 // if it is set.
1553 if override := library.Properties.Vendor_public_library.Override_export_include_dirs; override != nil {
1554 library.flagExporter.Properties.Export_include_dirs = override
1555 }
1556 }
1557
Chris Parsons3c27ca32020-11-20 12:42:07 -05001558 // Linking this library consists of linking `deps.Objs` (.o files in dependencies
1559 // of this library), together with `objs` (.o files created by compiling this
1560 // library).
Colin Crossad59e752017-11-16 14:29:11 -08001561 objs = deps.Objs.Copy().Append(objs)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001562 var out android.Path
Colin Crossa48ab5b2017-02-14 15:28:44 -08001563 if library.static() || library.header() {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001564 out = library.linkStatic(ctx, flags, deps, objs)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001565 } else {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001566 out = library.linkShared(ctx, flags, deps, objs)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001567 }
1568
Chris Parsons3c27ca32020-11-20 12:42:07 -05001569 // Export include paths and flags to be propagated up the tree.
Inseob Kim69378442019-06-03 19:10:47 +09001570 library.exportIncludes(ctx)
1571 library.reexportDirs(deps.ReexportedDirs...)
1572 library.reexportSystemDirs(deps.ReexportedSystemDirs...)
1573 library.reexportFlags(deps.ReexportedFlags...)
1574 library.reexportDeps(deps.ReexportedDeps...)
Inseob Kimd110f872019-12-06 13:15:38 +09001575 library.addExportedGeneratedHeaders(deps.ReexportedGeneratedHeaders...)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001576
Chris Parsons3c27ca32020-11-20 12:42:07 -05001577 // Optionally export aidl headers.
Nan Zhang0007d812017-11-07 10:57:05 -08001578 if Bool(library.Properties.Aidl.Export_aidl_headers) {
Dan Willemsene1240db2016-11-03 14:28:51 -07001579 if library.baseCompiler.hasSrcExt(".aidl") {
Jiyong Park74955042019-10-22 20:19:51 +09001580 dir := android.PathForModuleGen(ctx, "aidl")
Inseob Kim69378442019-06-03 19:10:47 +09001581 library.reexportDirs(dir)
Inseob Kimd110f872019-12-06 13:15:38 +09001582
Paul Duffin33056e82021-02-19 13:49:08 +00001583 library.reexportDeps(library.baseCompiler.aidlOrderOnlyDeps...)
1584 library.addExportedGeneratedHeaders(library.baseCompiler.aidlHeaders...)
Dan Willemsene1240db2016-11-03 14:28:51 -07001585 }
1586 }
1587
Chris Parsons3c27ca32020-11-20 12:42:07 -05001588 // Optionally export proto headers.
Nan Zhang0007d812017-11-07 10:57:05 -08001589 if Bool(library.Properties.Proto.Export_proto_headers) {
Dan Willemsene1240db2016-11-03 14:28:51 -07001590 if library.baseCompiler.hasSrcExt(".proto") {
Jiyong Park74955042019-10-22 20:19:51 +09001591 var includes android.Paths
Colin Cross19878da2019-03-28 14:45:07 -07001592 if flags.proto.CanonicalPathFromRoot {
Jiyong Park74955042019-10-22 20:19:51 +09001593 includes = append(includes, flags.proto.SubDir)
Colin Cross10d22312017-05-03 11:01:58 -07001594 }
Jiyong Park74955042019-10-22 20:19:51 +09001595 includes = append(includes, flags.proto.Dir)
Inseob Kim69378442019-06-03 19:10:47 +09001596 library.reexportDirs(includes...)
Inseob Kimd110f872019-12-06 13:15:38 +09001597
Paul Duffin33056e82021-02-19 13:49:08 +00001598 library.reexportDeps(library.baseCompiler.protoOrderOnlyDeps...)
1599 library.addExportedGeneratedHeaders(library.baseCompiler.protoHeaders...)
Colin Cross0c461f12016-10-20 16:11:43 -07001600 }
1601 }
1602
Inseob Kim07def122020-11-23 14:43:02 +09001603 // If the library is sysprop_library, expose either public or internal header selectively.
Inseob Kim21f26902018-09-06 00:55:20 +09001604 if library.baseCompiler.hasSrcExt(".sysprop") {
Jiyong Park74955042019-10-22 20:19:51 +09001605 dir := android.PathForModuleGen(ctx, "sysprop", "include")
Inseob Kimc0907f12019-02-08 21:00:45 +09001606 if library.Properties.Sysprop.Platform != nil {
Inseob Kimc0907f12019-02-08 21:00:45 +09001607 isOwnerPlatform := Bool(library.Properties.Sysprop.Platform)
1608
Inseob Kim07def122020-11-23 14:43:02 +09001609 // If the owner is different from the user, expose public header. That is,
1610 // 1) if the user is product (as owner can only be platform / vendor)
Inseob Kim06410042021-01-18 15:23:28 +09001611 // 2) if the owner is platform and the client is vendor
1612 // We don't care Platform -> Vendor dependency as it's already forbidden.
1613 if ctx.Device() && (ctx.ProductSpecific() || (isOwnerPlatform && ctx.inVendor())) {
Jiyong Park74955042019-10-22 20:19:51 +09001614 dir = android.PathForModuleGen(ctx, "sysprop/public", "include")
Inseob Kimc0907f12019-02-08 21:00:45 +09001615 }
1616 }
1617
Paul Duffin37e0de52021-02-19 17:05:39 +00001618 // Make sure to only export headers which are within the include directory.
1619 _, headers := android.FilterPathListPredicate(library.baseCompiler.syspropHeaders, func(path android.Path) bool {
1620 _, isRel := android.MaybeRel(ctx, dir.String(), path.String())
1621 return isRel
1622 })
1623
Chris Parsons3c27ca32020-11-20 12:42:07 -05001624 // Add sysprop-related directories to the exported directories of this library.
Inseob Kim69378442019-06-03 19:10:47 +09001625 library.reexportDirs(dir)
Paul Duffin33056e82021-02-19 13:49:08 +00001626 library.reexportDeps(library.baseCompiler.syspropOrderOnlyDeps...)
Paul Duffin37e0de52021-02-19 17:05:39 +00001627 library.addExportedGeneratedHeaders(headers...)
Inseob Kim21f26902018-09-06 00:55:20 +09001628 }
1629
Chris Parsons3c27ca32020-11-20 12:42:07 -05001630 // Add stub-related flags if this library is a stub library.
Jiyong Park892a98f2020-12-14 09:20:00 +09001631 library.exportVersioningMacroIfNeeded(ctx)
Jiyong Parkda732bd2018-11-02 18:23:15 +09001632
Chris Parsons3c27ca32020-11-20 12:42:07 -05001633 // Propagate a Provider containing information about exported flags, deps, and include paths.
Colin Cross0de8a1e2020-09-18 14:15:30 -07001634 library.flagExporter.setProvider(ctx)
1635
Colin Cross4d9c2d12016-07-29 12:48:20 -07001636 return out
1637}
1638
Jiyong Park892a98f2020-12-14 09:20:00 +09001639func (library *libraryDecorator) exportVersioningMacroIfNeeded(ctx android.BaseModuleContext) {
Colin Cross127bb8b2020-12-16 16:46:01 -08001640 if library.buildStubs() && library.stubsVersion() != "" && !library.skipAPIDefine {
Jiyong Park892a98f2020-12-14 09:20:00 +09001641 name := versioningMacroName(ctx.Module().(*Module).ImplementationModuleName(ctx))
Jooyung Han11b0fbd2021-02-05 02:28:22 +09001642 apiLevel, err := android.ApiLevelFromUser(ctx, library.stubsVersion())
1643 if err != nil {
1644 ctx.ModuleErrorf("Can't export version macro: %s", err.Error())
1645 }
1646 library.reexportFlags("-D" + name + "=" + strconv.Itoa(apiLevel.FinalOrPreviewInt()))
Jiyong Park892a98f2020-12-14 09:20:00 +09001647 }
1648}
1649
Chris Parsons3c27ca32020-11-20 12:42:07 -05001650// buildStatic returns true if this library should be built as a static library.
Colin Crossb916a382016-07-29 17:28:03 -07001651func (library *libraryDecorator) buildStatic() bool {
Colin Crosse1bb5d02019-09-24 14:55:04 -07001652 return library.MutatedProperties.BuildStatic &&
1653 BoolDefault(library.StaticProperties.Static.Enabled, true)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001654}
1655
Chris Parsons3c27ca32020-11-20 12:42:07 -05001656// buildShared returns true if this library should be built as a shared library.
Colin Crossb916a382016-07-29 17:28:03 -07001657func (library *libraryDecorator) buildShared() bool {
Colin Crosse1bb5d02019-09-24 14:55:04 -07001658 return library.MutatedProperties.BuildShared &&
1659 BoolDefault(library.SharedProperties.Shared.Enabled, true)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001660}
1661
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001662func (library *libraryDecorator) objs() Objects {
1663 return library.objects
Colin Cross4d9c2d12016-07-29 12:48:20 -07001664}
1665
Colin Cross0de8a1e2020-09-18 14:15:30 -07001666func (library *libraryDecorator) reuseObjs() Objects {
1667 return library.reuseObjects
Colin Cross4d9c2d12016-07-29 12:48:20 -07001668}
1669
Colin Cross26c34ed2016-09-30 17:10:16 -07001670func (library *libraryDecorator) toc() android.OptionalPath {
1671 return library.tocFile
1672}
1673
Jiyong Parkf1194352019-02-25 11:05:47 +09001674func (library *libraryDecorator) installSymlinkToRuntimeApex(ctx ModuleContext, file android.Path) {
1675 dir := library.baseInstaller.installDir(ctx)
1676 dirOnDevice := android.InstallPathToOnDevicePath(ctx, dir)
1677 target := "/" + filepath.Join("apex", "com.android.runtime", dir.Base(), "bionic", file.Base())
1678 ctx.InstallAbsoluteSymlink(dir, file.Base(), target)
Jaewoong Jung18aefc12020-12-21 09:11:10 -08001679 library.postInstallCmds = append(library.postInstallCmds, makeSymlinkCmd(dirOnDevice, file.Base(), target))
Jiyong Parkf1194352019-02-25 11:05:47 +09001680}
1681
Colin Crossb916a382016-07-29 17:28:03 -07001682func (library *libraryDecorator) install(ctx ModuleContext, file android.Path) {
Colin Crossc43ae772017-04-14 15:42:53 -07001683 if library.shared() {
Justin Yun8fe12122017-12-07 17:18:15 +09001684 if ctx.Device() && ctx.useVndk() {
Jooyung Han261e1582020-10-20 18:54:21 +09001685 // set subDir for VNDK extensions
Ivan Lozanof9e21722020-12-02 09:00:51 -05001686 if ctx.IsVndkExt() {
Jooyung Han261e1582020-10-20 18:54:21 +09001687 if ctx.isVndkSp() {
1688 library.baseInstaller.subDir = "vndk-sp"
1689 } else {
1690 library.baseInstaller.subDir = "vndk"
1691 }
1692 }
1693
Justin Yun31094b12020-12-24 16:11:23 +09001694 // In some cases we want to use core variant for VNDK-Core libs.
1695 // Skip product variant since VNDKs use only the vendor variant.
1696 if ctx.isVndk() && !ctx.isVndkSp() && !ctx.IsVndkExt() && !ctx.inProduct() {
Vic Yang1a5812a2020-01-31 10:38:40 -08001697 mayUseCoreVariant := true
1698
1699 if ctx.mustUseVendorVariant() {
1700 mayUseCoreVariant = false
1701 }
1702
Vic Yang1a5812a2020-01-31 10:38:40 -08001703 if ctx.Config().CFIEnabledForPath(ctx.ModuleDir()) && ctx.Arch().ArchType == android.Arm64 {
1704 mayUseCoreVariant = false
1705 }
1706
1707 if mayUseCoreVariant {
Vic Yangd92090f2020-01-08 14:32:28 -08001708 library.checkSameCoreVariant = true
1709 if ctx.DeviceConfig().VndkUseCoreVariant() {
1710 library.useCoreVariant = true
1711 }
Vic Yangefd249e2018-11-12 20:19:56 -08001712 }
Justin Yun8fe12122017-12-07 17:18:15 +09001713 }
Logan Chienf3511742017-10-31 18:04:35 +08001714
Jooyung Han261e1582020-10-20 18:54:21 +09001715 // do not install vndk libs
1716 // vndk libs are packaged into VNDK APEX
Ivan Lozanof9e21722020-12-02 09:00:51 -05001717 if ctx.isVndk() && !ctx.IsVndkExt() {
Jooyung Han261e1582020-10-20 18:54:21 +09001718 return
Justin Yun8effde42017-06-23 19:24:43 +09001719 }
Jiyong Parkd4a3a132021-03-17 20:21:35 +09001720 } else if library.hasStubsVariants() && !ctx.Host() && ctx.directlyInAnyApex() {
Jiyong Parkf1194352019-02-25 11:05:47 +09001721 // Bionic libraries (e.g. libc.so) is installed to the bootstrap subdirectory.
1722 // The original path becomes a symlink to the corresponding file in the
1723 // runtime APEX.
Colin Cross3b19f5d2019-09-17 14:45:31 -07001724 translatedArch := ctx.Target().NativeBridge == android.NativeBridgeEnabled
Colin Cross56a83212020-09-15 18:30:11 -07001725 if InstallToBootstrap(ctx.baseModuleName(), ctx.Config()) && !library.buildStubs() &&
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001726 !translatedArch && !ctx.inRamdisk() && !ctx.inVendorRamdisk() && !ctx.inRecovery() {
Martin Stjernholm279de572019-09-10 23:18:20 +01001727 if ctx.Device() {
Jiyong Parkc3e2c862019-03-16 01:10:08 +09001728 library.installSymlinkToRuntimeApex(ctx, file)
1729 }
Jiyong Park429660f2019-01-16 22:31:11 +09001730 library.baseInstaller.subDir = "bootstrap"
1731 }
Colin Cross127bb8b2020-12-16 16:46:01 -08001732 } else if ctx.directlyInAnyApex() && ctx.IsLlndk() && !isBionic(ctx.baseModuleName()) {
Przemyslaw Szczepaniake6fc5072019-07-12 14:06:23 +01001733 // Skip installing LLNDK (non-bionic) libraries moved to APEX.
Colin Crossa9c8c9f2020-12-16 10:20:23 -08001734 ctx.Module().HideFromMake()
Justin Yun8effde42017-06-23 19:24:43 +09001735 }
Przemyslaw Szczepaniake6fc5072019-07-12 14:06:23 +01001736
Colin Cross4d9c2d12016-07-29 12:48:20 -07001737 library.baseInstaller.install(ctx, file)
1738 }
Dan Albertf563d252017-10-13 00:29:00 -07001739
Dan Albert281f22b2017-12-13 15:03:47 -08001740 if Bool(library.Properties.Static_ndk_lib) && library.static() &&
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001741 !ctx.useVndk() && !ctx.inRamdisk() && !ctx.inVendorRamdisk() && !ctx.inRecovery() && ctx.Device() &&
Jiyong Park7ed9de32018-10-15 22:25:07 +09001742 library.baseLinker.sanitize.isUnsanitizedVariant() &&
Colin Cross95b07f22020-12-16 11:06:50 -08001743 ctx.isForPlatform() && !ctx.isPreventInstall() {
Dan Albertf563d252017-10-13 00:29:00 -07001744 installPath := getNdkSysrootBase(ctx).Join(
Dan Albertea4b7b92018-04-25 16:05:30 -07001745 ctx, "usr/lib", config.NDKTriple(ctx.toolchain()), file.Base())
Dan Albertf563d252017-10-13 00:29:00 -07001746
1747 ctx.ModuleBuild(pctx, android.ModuleBuildParams{
1748 Rule: android.Cp,
1749 Description: "install " + installPath.Base(),
1750 Output: installPath,
1751 Input: file,
1752 })
1753
Colin Cross0875c522017-11-28 17:34:01 -08001754 library.ndkSysrootPath = installPath
Dan Albertf563d252017-10-13 00:29:00 -07001755 }
Colin Cross4d9c2d12016-07-29 12:48:20 -07001756}
1757
Paul Duffin0cb37b92020-03-04 14:52:46 +00001758func (library *libraryDecorator) everInstallable() bool {
1759 // Only shared and static libraries are installed. Header libraries (which are
1760 // neither static or shared) are not installed.
1761 return library.shared() || library.static()
1762}
1763
Chris Parsons3c27ca32020-11-20 12:42:07 -05001764// static returns true if this library is for a "static' variant.
Colin Crossb916a382016-07-29 17:28:03 -07001765func (library *libraryDecorator) static() bool {
Colin Crossa48ab5b2017-02-14 15:28:44 -08001766 return library.MutatedProperties.VariantIsStatic
Colin Cross4d9c2d12016-07-29 12:48:20 -07001767}
1768
Chris Parsons3c27ca32020-11-20 12:42:07 -05001769// shared returns true if this library is for a "shared' variant.
Colin Crossa48ab5b2017-02-14 15:28:44 -08001770func (library *libraryDecorator) shared() bool {
1771 return library.MutatedProperties.VariantIsShared
1772}
1773
Chris Parsons3c27ca32020-11-20 12:42:07 -05001774// header returns true if this library is for a header-only variant.
Colin Crossa48ab5b2017-02-14 15:28:44 -08001775func (library *libraryDecorator) header() bool {
Chris Parsons3c27ca32020-11-20 12:42:07 -05001776 // Neither "static" nor "shared" implies this library is header-only.
Colin Crossa48ab5b2017-02-14 15:28:44 -08001777 return !library.static() && !library.shared()
1778}
1779
Chris Parsons3c27ca32020-11-20 12:42:07 -05001780// setStatic marks the library variant as "static".
Colin Crossa48ab5b2017-02-14 15:28:44 -08001781func (library *libraryDecorator) setStatic() {
1782 library.MutatedProperties.VariantIsStatic = true
1783 library.MutatedProperties.VariantIsShared = false
1784}
1785
Chris Parsons3c27ca32020-11-20 12:42:07 -05001786// setShared marks the library variant as "shared".
Colin Crossa48ab5b2017-02-14 15:28:44 -08001787func (library *libraryDecorator) setShared() {
1788 library.MutatedProperties.VariantIsStatic = false
1789 library.MutatedProperties.VariantIsShared = true
Colin Crossb916a382016-07-29 17:28:03 -07001790}
1791
Chris Parsons3c27ca32020-11-20 12:42:07 -05001792// BuildOnlyStatic disables building this library as a shared library.
Colin Crossab3b7322016-12-09 14:46:15 -08001793func (library *libraryDecorator) BuildOnlyStatic() {
Colin Crossa48ab5b2017-02-14 15:28:44 -08001794 library.MutatedProperties.BuildShared = false
Colin Crossab3b7322016-12-09 14:46:15 -08001795}
1796
Chris Parsons3c27ca32020-11-20 12:42:07 -05001797// BuildOnlyShared disables building this library as a static library.
Colin Crossab3b7322016-12-09 14:46:15 -08001798func (library *libraryDecorator) BuildOnlyShared() {
Colin Crossa48ab5b2017-02-14 15:28:44 -08001799 library.MutatedProperties.BuildStatic = false
Colin Crossab3b7322016-12-09 14:46:15 -08001800}
1801
Chris Parsons3c27ca32020-11-20 12:42:07 -05001802// HeaderOnly disables building this library as a shared or static library;
1803// the library only exists to propagate header file dependencies up the build graph.
Colin Cross5950f382016-12-13 12:50:57 -08001804func (library *libraryDecorator) HeaderOnly() {
Colin Crossa48ab5b2017-02-14 15:28:44 -08001805 library.MutatedProperties.BuildShared = false
1806 library.MutatedProperties.BuildStatic = false
Colin Cross5950f382016-12-13 12:50:57 -08001807}
1808
Colin Cross127bb8b2020-12-16 16:46:01 -08001809// hasLLNDKStubs returns true if this cc_library module has a variant that will build LLNDK stubs.
1810func (library *libraryDecorator) hasLLNDKStubs() bool {
Colin Cross203b4212021-04-26 17:19:41 -07001811 return String(library.Properties.Llndk.Symbol_file) != ""
Colin Cross0fb7fcd2021-03-02 11:00:07 -08001812}
1813
Colin Cross203b4212021-04-26 17:19:41 -07001814// hasLLNDKStubs returns true if this cc_library module has a variant that will build LLNDK stubs.
Colin Cross1f3f1302021-04-26 18:37:44 -07001815func (library *libraryDecorator) hasLLNDKHeaders() bool {
1816 return Bool(library.Properties.Llndk.Llndk_headers)
1817}
1818
Colin Cross5271fea2021-04-27 13:06:04 -07001819// hasVendorPublicLibrary returns true if this cc_library module has a variant that will build
1820// vendor public library stubs.
1821func (library *libraryDecorator) hasVendorPublicLibrary() bool {
1822 return String(library.Properties.Vendor_public_library.Symbol_file) != ""
1823}
1824
Colin Cross0477b422020-10-13 18:43:54 -07001825func (library *libraryDecorator) implementationModuleName(name string) string {
1826 return name
1827}
1828
Jiyong Park7ed9de32018-10-15 22:25:07 +09001829func (library *libraryDecorator) buildStubs() bool {
1830 return library.MutatedProperties.BuildStubs
1831}
1832
Jiyong Parka034b832019-08-27 14:02:19 +09001833func (library *libraryDecorator) symbolFileForAbiCheck(ctx ModuleContext) *string {
1834 if library.Properties.Header_abi_checker.Symbol_file != nil {
1835 return library.Properties.Header_abi_checker.Symbol_file
1836 }
Colin Cross127bb8b2020-12-16 16:46:01 -08001837 if ctx.Module().(*Module).IsLlndk() {
1838 return library.Properties.Llndk.Symbol_file
1839 }
Colin Cross31076b32020-10-23 17:22:06 -07001840 if library.hasStubsVariants() && library.Properties.Stubs.Symbol_file != nil {
Jiyong Parka034b832019-08-27 14:02:19 +09001841 return library.Properties.Stubs.Symbol_file
1842 }
1843 return nil
1844}
1845
Colin Crossc88c2722020-09-28 17:32:47 -07001846func (library *libraryDecorator) hasStubsVariants() bool {
Jiyong Parkd4a3a132021-03-17 20:21:35 +09001847 // Just having stubs.symbol_file is enough to create a stub variant. In that case
1848 // the stub for the future API level is created.
1849 return library.Properties.Stubs.Symbol_file != nil ||
1850 len(library.Properties.Stubs.Versions) > 0
Colin Crossc88c2722020-09-28 17:32:47 -07001851}
1852
Colin Cross3572cf72020-10-01 15:58:11 -07001853func (library *libraryDecorator) stubsVersions(ctx android.BaseMutatorContext) []string {
Jiyong Parkd4a3a132021-03-17 20:21:35 +09001854 if !library.hasStubsVariants() {
1855 return nil
1856 }
1857
Colin Crossc1b36442021-05-06 13:42:48 -07001858 if library.hasLLNDKStubs() && ctx.Module().(*Module).UseVndk() {
1859 // LLNDK libraries only need a single stubs variant.
1860 return []string{android.FutureApiLevel.String()}
1861 }
1862
Jiyong Parkd4a3a132021-03-17 20:21:35 +09001863 // Future API level is implicitly added if there isn't
1864 vers := library.Properties.Stubs.Versions
1865 if inList(android.FutureApiLevel.String(), vers) {
1866 return vers
1867 }
1868 // In some cases, people use the raw value "10000" in the versions property.
1869 // We shouldn't add the future API level in that case, otherwise there will
1870 // be two identical versions.
1871 if inList(strconv.Itoa(android.FutureApiLevel.FinalOrFutureInt()), vers) {
1872 return vers
1873 }
1874 return append(vers, android.FutureApiLevel.String())
Colin Crossc88c2722020-09-28 17:32:47 -07001875}
1876
1877func (library *libraryDecorator) setStubsVersion(version string) {
1878 library.MutatedProperties.StubsVersion = version
1879}
1880
Jiyong Park7ed9de32018-10-15 22:25:07 +09001881func (library *libraryDecorator) stubsVersion() string {
1882 return library.MutatedProperties.StubsVersion
1883}
1884
Jiyong Parkd4a3a132021-03-17 20:21:35 +09001885func (library *libraryDecorator) setBuildStubs(isLatest bool) {
Colin Crossc88c2722020-09-28 17:32:47 -07001886 library.MutatedProperties.BuildStubs = true
Jiyong Parkd4a3a132021-03-17 20:21:35 +09001887 library.MutatedProperties.IsLatestVersion = isLatest
Colin Crossc88c2722020-09-28 17:32:47 -07001888}
1889
1890func (library *libraryDecorator) setAllStubsVersions(versions []string) {
1891 library.MutatedProperties.AllStubsVersions = versions
1892}
1893
1894func (library *libraryDecorator) allStubsVersions() []string {
1895 return library.MutatedProperties.AllStubsVersions
1896}
1897
Jooyung Hanad4c1872020-02-27 17:56:44 +09001898func (library *libraryDecorator) isLatestStubVersion() bool {
Jiyong Parkd4a3a132021-03-17 20:21:35 +09001899 return library.MutatedProperties.IsLatestVersion
Jooyung Hanad4c1872020-02-27 17:56:44 +09001900}
1901
Jiyong Parka90ca002019-10-07 15:47:24 +09001902func (library *libraryDecorator) availableFor(what string) bool {
1903 var list []string
1904 if library.static() {
1905 list = library.StaticProperties.Static.Apex_available
1906 } else if library.shared() {
1907 list = library.SharedProperties.Shared.Apex_available
1908 }
1909 if len(list) == 0 {
1910 return false
1911 }
1912 return android.CheckAvailableForApex(what, list)
1913}
1914
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01001915func (library *libraryDecorator) makeUninstallable(mod *Module) {
Martin Stjernholmbf37d162020-03-31 16:05:34 +01001916 if library.static() && library.buildStatic() && !library.buildStubs() {
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01001917 // If we're asked to make a static library uninstallable we don't do
1918 // anything since AndroidMkEntries always sets LOCAL_UNINSTALLABLE_MODULE
1919 // for these entries. This is done to still get the make targets for NOTICE
1920 // files from notice_files.mk, which other libraries might depend on.
Martin Stjernholmbf37d162020-03-31 16:05:34 +01001921 return
1922 }
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01001923 mod.ModuleBase.MakeUninstallable()
Martin Stjernholmbf37d162020-03-31 16:05:34 +01001924}
1925
Colin Cross571cccf2019-02-04 11:22:08 -08001926var versioningMacroNamesListKey = android.NewOnceKey("versioningMacroNamesList")
1927
Chris Parsons3c27ca32020-11-20 12:42:07 -05001928// versioningMacroNamesList returns a singleton map, where keys are "version macro names",
1929// and values are the module name responsible for registering the version macro name.
1930//
1931// Version macros are used when building against stubs, to provide version information about
1932// the stub. Only stub libraries should have an entry in this list.
1933//
1934// For example, when building against libFoo#ver, __LIBFOO_API__ macro is set to ver so
1935// that headers from libFoo can be conditionally compiled (this may hide APIs
1936// that are not available for the version).
1937//
1938// This map is used to ensure that there aren't conflicts between these version macro names.
Jiyong Parkda732bd2018-11-02 18:23:15 +09001939func versioningMacroNamesList(config android.Config) *map[string]string {
Colin Cross571cccf2019-02-04 11:22:08 -08001940 return config.Once(versioningMacroNamesListKey, func() interface{} {
Jiyong Parkda732bd2018-11-02 18:23:15 +09001941 m := make(map[string]string)
1942 return &m
1943 }).(*map[string]string)
1944}
1945
1946// alphanumeric and _ characters are preserved.
1947// other characters are all converted to _
1948var charsNotForMacro = regexp.MustCompile("[^a-zA-Z0-9_]+")
1949
Chris Parsons3c27ca32020-11-20 12:42:07 -05001950// versioningMacroName returns the canonical version macro name for the given module.
Jiyong Parkda732bd2018-11-02 18:23:15 +09001951func versioningMacroName(moduleName string) string {
1952 macroName := charsNotForMacro.ReplaceAllString(moduleName, "_")
Jooyung Hanb04a4992020-03-13 18:57:35 +09001953 macroName = strings.ToUpper(macroName)
Jiyong Parkda732bd2018-11-02 18:23:15 +09001954 return "__" + macroName + "_API__"
1955}
1956
Chris Parsons3c27ca32020-11-20 12:42:07 -05001957// NewLibrary builds and returns a new Module corresponding to a C++ library.
1958// Individual module implementations which comprise a C++ library (or something like
1959// a C++ library) should call this function, set some fields on the result, and
1960// then call the Init function.
Colin Crossab3b7322016-12-09 14:46:15 -08001961func NewLibrary(hod android.HostOrDeviceSupported) (*Module, *libraryDecorator) {
Colin Cross4d9c2d12016-07-29 12:48:20 -07001962 module := newModule(hod, android.MultilibBoth)
1963
Colin Crossb916a382016-07-29 17:28:03 -07001964 library := &libraryDecorator{
Colin Crossa48ab5b2017-02-14 15:28:44 -08001965 MutatedProperties: LibraryMutatedProperties{
Colin Crossab3b7322016-12-09 14:46:15 -08001966 BuildShared: true,
1967 BuildStatic: true,
Colin Cross4d9c2d12016-07-29 12:48:20 -07001968 },
Colin Crossb916a382016-07-29 17:28:03 -07001969 baseCompiler: NewBaseCompiler(),
Dan Albert61f32122018-07-26 14:00:24 -07001970 baseLinker: NewBaseLinker(module.sanitize),
Colin Crossb916a382016-07-29 17:28:03 -07001971 baseInstaller: NewBaseInstaller("lib", "lib64", InstallInSystem),
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001972 sabi: module.sabi,
Colin Cross4d9c2d12016-07-29 12:48:20 -07001973 }
1974
Colin Crossb916a382016-07-29 17:28:03 -07001975 module.compiler = library
1976 module.linker = library
1977 module.installer = library
Colin Cross31076b32020-10-23 17:22:06 -07001978 module.library = library
Colin Crossb916a382016-07-29 17:28:03 -07001979
1980 return module, library
1981}
1982
Colin Cross10d22312017-05-03 11:01:58 -07001983// connects a shared library to a static library in order to reuse its .o files to avoid
1984// compiling source files twice.
1985func reuseStaticLibrary(mctx android.BottomUpMutatorContext, static, shared *Module) {
1986 if staticCompiler, ok := static.compiler.(*libraryDecorator); ok {
1987 sharedCompiler := shared.compiler.(*libraryDecorator)
Dan Willemsen3a26eef2018-12-03 15:25:46 -08001988
1989 // Check libraries in addition to cflags, since libraries may be exporting different
1990 // include directories.
Colin Crosse1bb5d02019-09-24 14:55:04 -07001991 if len(staticCompiler.StaticProperties.Static.Cflags) == 0 &&
1992 len(sharedCompiler.SharedProperties.Shared.Cflags) == 0 &&
1993 len(staticCompiler.StaticProperties.Static.Whole_static_libs) == 0 &&
1994 len(sharedCompiler.SharedProperties.Shared.Whole_static_libs) == 0 &&
1995 len(staticCompiler.StaticProperties.Static.Static_libs) == 0 &&
1996 len(sharedCompiler.SharedProperties.Shared.Static_libs) == 0 &&
1997 len(staticCompiler.StaticProperties.Static.Shared_libs) == 0 &&
1998 len(sharedCompiler.SharedProperties.Shared.Shared_libs) == 0 &&
Martin Stjernholm10566a02020-03-24 01:19:52 +00001999 // Compare System_shared_libs properties with nil because empty lists are
2000 // semantically significant for them.
Colin Crosse1bb5d02019-09-24 14:55:04 -07002001 staticCompiler.StaticProperties.Static.System_shared_libs == nil &&
2002 sharedCompiler.SharedProperties.Shared.System_shared_libs == nil {
Colin Cross10d22312017-05-03 11:01:58 -07002003
2004 mctx.AddInterVariantDependency(reuseObjTag, shared, static)
2005 sharedCompiler.baseCompiler.Properties.OriginalSrcs =
2006 sharedCompiler.baseCompiler.Properties.Srcs
2007 sharedCompiler.baseCompiler.Properties.Srcs = nil
2008 sharedCompiler.baseCompiler.Properties.Generated_sources = nil
2009 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07002010
2011 // This dep is just to reference static variant from shared variant
2012 mctx.AddInterVariantDependency(staticVariantTag, shared, static)
Colin Cross10d22312017-05-03 11:01:58 -07002013 }
2014}
2015
Chris Parsons3c27ca32020-11-20 12:42:07 -05002016// LinkageMutator adds "static" or "shared" variants for modules depending
2017// on whether the module can be built as a static library or a shared library.
Colin Crosse40b4ea2018-10-02 22:25:58 -07002018func LinkageMutator(mctx android.BottomUpMutatorContext) {
Jaewoong Jung18aefc12020-12-21 09:11:10 -08002019 ccPrebuilt := false
Colin Crossb916a382016-07-29 17:28:03 -07002020 if m, ok := mctx.Module().(*Module); ok && m.linker != nil {
Jaewoong Jung18aefc12020-12-21 09:11:10 -08002021 _, ccPrebuilt = m.linker.(prebuiltLibraryInterface)
Ivan Lozano52767be2019-10-18 14:49:46 -07002022 }
Jaewoong Jung18aefc12020-12-21 09:11:10 -08002023 if ccPrebuilt {
Ivan Lozano52767be2019-10-18 14:49:46 -07002024 library := mctx.Module().(*Module).linker.(prebuiltLibraryInterface)
Colin Cross33b2fb72019-05-14 14:07:01 -07002025
Paul Duffinf5ea9e12020-02-21 10:57:00 +00002026 // Differentiate between header only and building an actual static/shared library
Colin Cross127bb8b2020-12-16 16:46:01 -08002027 buildStatic := library.buildStatic()
2028 buildShared := library.buildShared()
2029 if buildStatic || buildShared {
Paul Duffinf5ea9e12020-02-21 10:57:00 +00002030 // Always create both the static and shared variants for prebuilt libraries, and then disable the one
2031 // that is not being used. This allows them to share the name of a cc_library module, which requires that
2032 // all the variants of the cc_library also exist on the prebuilt.
2033 modules := mctx.CreateLocalVariations("static", "shared")
2034 static := modules[0].(*Module)
2035 shared := modules[1].(*Module)
Colin Cross33b2fb72019-05-14 14:07:01 -07002036
Paul Duffinf5ea9e12020-02-21 10:57:00 +00002037 static.linker.(prebuiltLibraryInterface).setStatic()
2038 shared.linker.(prebuiltLibraryInterface).setShared()
Colin Cross33b2fb72019-05-14 14:07:01 -07002039
Colin Cross127bb8b2020-12-16 16:46:01 -08002040 if buildShared {
Colin Cross81ca6cd2020-08-06 17:46:48 -07002041 mctx.AliasVariation("shared")
Colin Cross127bb8b2020-12-16 16:46:01 -08002042 } else if buildStatic {
Colin Cross81ca6cd2020-08-06 17:46:48 -07002043 mctx.AliasVariation("static")
2044 }
2045
Colin Cross127bb8b2020-12-16 16:46:01 -08002046 if !buildStatic {
Paul Duffinf5ea9e12020-02-21 10:57:00 +00002047 static.linker.(prebuiltLibraryInterface).disablePrebuilt()
2048 }
Colin Cross127bb8b2020-12-16 16:46:01 -08002049 if !buildShared {
Paul Duffinf5ea9e12020-02-21 10:57:00 +00002050 shared.linker.(prebuiltLibraryInterface).disablePrebuilt()
2051 }
2052 } else {
2053 // Header only
Colin Crossb916a382016-07-29 17:28:03 -07002054 }
Paul Duffinf5ea9e12020-02-21 10:57:00 +00002055
Ivan Lozano52767be2019-10-18 14:49:46 -07002056 } else if library, ok := mctx.Module().(LinkableInterface); ok && library.CcLibraryInterface() {
Ivan Lozano52767be2019-10-18 14:49:46 -07002057
Ivan Lozano2b262972019-11-21 12:30:50 -08002058 // Non-cc.Modules may need an empty variant for their mutators.
2059 variations := []string{}
2060 if library.NonCcVariants() {
2061 variations = append(variations, "")
2062 }
2063
Colin Cross127bb8b2020-12-16 16:46:01 -08002064 isLLNDK := false
2065 if m, ok := mctx.Module().(*Module); ok {
Colin Cross203b4212021-04-26 17:19:41 -07002066 isLLNDK = m.IsLlndk()
Colin Cross127bb8b2020-12-16 16:46:01 -08002067 }
2068 buildStatic := library.BuildStaticVariant() && !isLLNDK
2069 buildShared := library.BuildSharedVariant()
2070 if buildStatic && buildShared {
Ivan Lozano2b262972019-11-21 12:30:50 -08002071 variations := append([]string{"static", "shared"}, variations...)
Ivan Lozano52767be2019-10-18 14:49:46 -07002072
2073 modules := mctx.CreateLocalVariations(variations...)
2074 static := modules[0].(LinkableInterface)
2075 shared := modules[1].(LinkableInterface)
2076
2077 static.SetStatic()
2078 shared.SetShared()
2079
2080 if _, ok := library.(*Module); ok {
2081 reuseStaticLibrary(mctx, static.(*Module), shared.(*Module))
2082 }
Colin Cross81ca6cd2020-08-06 17:46:48 -07002083 mctx.AliasVariation("shared")
Colin Cross127bb8b2020-12-16 16:46:01 -08002084 } else if buildStatic {
Ivan Lozano2b262972019-11-21 12:30:50 -08002085 variations := append([]string{"static"}, variations...)
2086
2087 modules := mctx.CreateLocalVariations(variations...)
Ivan Lozano52767be2019-10-18 14:49:46 -07002088 modules[0].(LinkableInterface).SetStatic()
Colin Cross81ca6cd2020-08-06 17:46:48 -07002089 mctx.AliasVariation("static")
Colin Cross127bb8b2020-12-16 16:46:01 -08002090 } else if buildShared {
Ivan Lozano2b262972019-11-21 12:30:50 -08002091 variations := append([]string{"shared"}, variations...)
Ivan Lozano52767be2019-10-18 14:49:46 -07002092
Ivan Lozano2b262972019-11-21 12:30:50 -08002093 modules := mctx.CreateLocalVariations(variations...)
2094 modules[0].(LinkableInterface).SetShared()
Colin Cross81ca6cd2020-08-06 17:46:48 -07002095 mctx.AliasVariation("shared")
Ivan Lozano2b262972019-11-21 12:30:50 -08002096 } else if len(variations) > 0 {
2097 mctx.CreateLocalVariations(variations...)
Colin Cross81ca6cd2020-08-06 17:46:48 -07002098 mctx.AliasVariation(variations[0])
Ivan Lozano2b262972019-11-21 12:30:50 -08002099 }
Colin Crossb916a382016-07-29 17:28:03 -07002100 }
Colin Cross4d9c2d12016-07-29 12:48:20 -07002101}
Jiyong Park7ed9de32018-10-15 22:25:07 +09002102
Chris Parsons3c27ca32020-11-20 12:42:07 -05002103// normalizeVersions modifies `versions` in place, so that each raw version
2104// string becomes its normalized canonical form.
2105// Validates that the versions in `versions` are specified in least to greatest order.
Jooyung Hanaed150d2020-04-02 01:41:41 +09002106func normalizeVersions(ctx android.BaseModuleContext, versions []string) {
Dan Albertc8060532020-07-22 22:32:17 -07002107 var previous android.ApiLevel
Jooyung Hanad4c1872020-02-27 17:56:44 +09002108 for i, v := range versions {
Dan Albertc8060532020-07-22 22:32:17 -07002109 ver, err := android.ApiLevelFromUser(ctx, v)
Jooyung Hanad4c1872020-02-27 17:56:44 +09002110 if err != nil {
Jooyung Hanaed150d2020-04-02 01:41:41 +09002111 ctx.PropertyErrorf("versions", "%s", err.Error())
2112 return
Jooyung Hanad4c1872020-02-27 17:56:44 +09002113 }
Dan Albertc8060532020-07-22 22:32:17 -07002114 if i > 0 && ver.LessThanOrEqualTo(previous) {
2115 ctx.PropertyErrorf("versions", "not sorted: %v", versions)
2116 }
2117 versions[i] = ver.String()
2118 previous = ver
Jooyung Hanaed150d2020-04-02 01:41:41 +09002119 }
Jooyung Hanad4c1872020-02-27 17:56:44 +09002120}
2121
Jooyung Han61b66e92020-03-21 14:21:46 +00002122func createVersionVariations(mctx android.BottomUpMutatorContext, versions []string) {
Colin Cross127bb8b2020-12-16 16:46:01 -08002123 // "" is for the non-stubs (implementation) variant for system modules, or the LLNDK variant
2124 // for LLNDK modules.
Colin Cross0de8a1e2020-09-18 14:15:30 -07002125 variants := append(android.CopyOf(versions), "")
Jooyung Han61b66e92020-03-21 14:21:46 +00002126
Colin Cross127bb8b2020-12-16 16:46:01 -08002127 m := mctx.Module().(*Module)
2128 isLLNDK := m.IsLlndk()
Colin Cross5271fea2021-04-27 13:06:04 -07002129 isVendorPublicLibrary := m.IsVendorPublicLibrary()
Colin Cross127bb8b2020-12-16 16:46:01 -08002130
Colin Crossd1f898e2020-08-18 18:35:15 -07002131 modules := mctx.CreateLocalVariations(variants...)
Jooyung Han61b66e92020-03-21 14:21:46 +00002132 for i, m := range modules {
Colin Cross127bb8b2020-12-16 16:46:01 -08002133
Colin Cross5271fea2021-04-27 13:06:04 -07002134 if variants[i] != "" || isLLNDK || isVendorPublicLibrary {
Colin Cross127bb8b2020-12-16 16:46:01 -08002135 // A stubs or LLNDK stubs variant.
Colin Cross31076b32020-10-23 17:22:06 -07002136 c := m.(*Module)
Colin Cross31076b32020-10-23 17:22:06 -07002137 c.sanitize = nil
2138 c.stl = nil
2139 c.Properties.PreventInstall = true
2140 lib := moduleLibraryInterface(m)
Jiyong Parkd4a3a132021-03-17 20:21:35 +09002141 isLatest := i == (len(versions) - 1)
2142 lib.setBuildStubs(isLatest)
Colin Cross127bb8b2020-12-16 16:46:01 -08002143
2144 if variants[i] != "" {
2145 // A non-LLNDK stubs module is hidden from make and has a dependency from the
2146 // implementation module to the stubs module.
2147 c.Properties.HideFromMake = true
2148 lib.setStubsVersion(variants[i])
2149 mctx.AddInterVariantDependency(stubImplDepTag, modules[len(modules)-1], modules[i])
2150 }
Jooyung Han61b66e92020-03-21 14:21:46 +00002151 }
2152 }
Colin Cross094faa52020-08-06 17:38:25 -07002153 mctx.AliasVariation("")
Colin Crossd1f898e2020-08-18 18:35:15 -07002154 latestVersion := ""
2155 if len(versions) > 0 {
2156 latestVersion = versions[len(versions)-1]
2157 }
2158 mctx.CreateAliasVariation("latest", latestVersion)
Jooyung Han61b66e92020-03-21 14:21:46 +00002159}
2160
Colin Crossbbc941b2020-09-30 12:27:01 -07002161func createPerApiVersionVariations(mctx android.BottomUpMutatorContext, minSdkVersion string) {
2162 from, err := nativeApiLevelFromUser(mctx, minSdkVersion)
2163 if err != nil {
2164 mctx.PropertyErrorf("min_sdk_version", err.Error())
2165 return
2166 }
2167
2168 versionStrs := ndkLibraryVersions(mctx, from)
2169 modules := mctx.CreateLocalVariations(versionStrs...)
2170
2171 for i, module := range modules {
2172 module.(*Module).Properties.Sdk_version = StringPtr(versionStrs[i])
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09002173 module.(*Module).Properties.Min_sdk_version = StringPtr(versionStrs[i])
Colin Crossbbc941b2020-09-30 12:27:01 -07002174 }
2175}
2176
Colin Cross3146c5c2020-09-30 15:34:40 -07002177func CanBeOrLinkAgainstVersionVariants(module interface {
Jooyung Han624d35c2020-04-10 12:57:24 +09002178 Host() bool
2179 InRamdisk() bool
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002180 InVendorRamdisk() bool
Jooyung Han624d35c2020-04-10 12:57:24 +09002181}) bool {
Jose Galmes6f843bc2020-12-11 13:36:29 -08002182 return !module.Host() && !module.InRamdisk() && !module.InVendorRamdisk()
Jooyung Han624d35c2020-04-10 12:57:24 +09002183}
2184
Colin Cross3146c5c2020-09-30 15:34:40 -07002185func CanBeVersionVariant(module interface {
2186 Host() bool
2187 InRamdisk() bool
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002188 InVendorRamdisk() bool
Colin Cross3146c5c2020-09-30 15:34:40 -07002189 InRecovery() bool
2190 CcLibraryInterface() bool
2191 Shared() bool
Colin Cross3146c5c2020-09-30 15:34:40 -07002192}) bool {
2193 return CanBeOrLinkAgainstVersionVariants(module) &&
Colin Crossa717db72020-10-23 14:53:06 -07002194 module.CcLibraryInterface() && module.Shared()
Colin Cross3146c5c2020-09-30 15:34:40 -07002195}
2196
Colin Cross127bb8b2020-12-16 16:46:01 -08002197func moduleLibraryInterface(module blueprint.Module) libraryInterface {
Colin Cross31076b32020-10-23 17:22:06 -07002198 if m, ok := module.(*Module); ok {
2199 return m.library
2200 }
2201 return nil
2202}
2203
Colin Crossc1b36442021-05-06 13:42:48 -07002204// versionSelector normalizes the versions in the Stubs.Versions property into MutatedProperties.AllStubsVersions.
Colin Crossd1f898e2020-08-18 18:35:15 -07002205func versionSelectorMutator(mctx android.BottomUpMutatorContext) {
Colin Cross31076b32020-10-23 17:22:06 -07002206 if library := moduleLibraryInterface(mctx.Module()); library != nil && CanBeVersionVariant(mctx.Module().(*Module)) {
2207 if library.buildShared() {
2208 versions := library.stubsVersions(mctx)
Colin Cross3572cf72020-10-01 15:58:11 -07002209 if len(versions) > 0 {
2210 normalizeVersions(mctx, versions)
2211 if mctx.Failed() {
Colin Crossbbc941b2020-09-30 12:27:01 -07002212 return
2213 }
Colin Cross3572cf72020-10-01 15:58:11 -07002214 // Set the versions on the pre-mutated module so they can be read by any llndk modules that
2215 // depend on the implementation library and haven't been mutated yet.
Colin Cross31076b32020-10-23 17:22:06 -07002216 library.setAllStubsVersions(versions)
Colin Cross127bb8b2020-12-16 16:46:01 -08002217 }
Jooyung Han61b66e92020-03-21 14:21:46 +00002218 }
Colin Crossd1f898e2020-08-18 18:35:15 -07002219 }
2220}
Jooyung Han61b66e92020-03-21 14:21:46 +00002221
Colin Crossd1f898e2020-08-18 18:35:15 -07002222// versionMutator splits a module into the mandatory non-stubs variant
2223// (which is unnamed) and zero or more stubs variants.
2224func versionMutator(mctx android.BottomUpMutatorContext) {
Colin Cross31076b32020-10-23 17:22:06 -07002225 if library := moduleLibraryInterface(mctx.Module()); library != nil && CanBeVersionVariant(mctx.Module().(*Module)) {
2226 createVersionVariations(mctx, library.allStubsVersions())
Colin Crossbbc941b2020-09-30 12:27:01 -07002227 return
2228 }
2229
2230 if m, ok := mctx.Module().(*Module); ok {
2231 if m.SplitPerApiLevel() && m.IsSdkVariant() {
2232 if mctx.Os() != android.Android {
2233 return
2234 }
2235 createPerApiVersionVariations(mctx, m.MinSdkVersion())
2236 }
Jiyong Park7ed9de32018-10-15 22:25:07 +09002237 }
Jiyong Park7ed9de32018-10-15 22:25:07 +09002238}
Colin Crossd7227f92019-09-05 14:26:33 -07002239
2240// maybeInjectBoringSSLHash adds a rule to run bssl_inject_hash on the output file if the module has the
2241// inject_bssl_hash or if any static library dependencies have inject_bssl_hash set. It returns the output path
2242// that the linked output file should be written to.
2243// TODO(b/137267623): Remove this in favor of a cc_genrule when they support operating on shared libraries.
2244func maybeInjectBoringSSLHash(ctx android.ModuleContext, outputFile android.ModuleOutPath,
2245 inject *bool, fileName string) android.ModuleOutPath {
2246 // TODO(b/137267623): Remove this in favor of a cc_genrule when they support operating on shared libraries.
2247 injectBoringSSLHash := Bool(inject)
2248 ctx.VisitDirectDeps(func(dep android.Module) {
Colin Cross6e511a92020-07-27 21:26:48 -07002249 if tag, ok := ctx.OtherModuleDependencyTag(dep).(libraryDependencyTag); ok && tag.static() {
Colin Crossd7227f92019-09-05 14:26:33 -07002250 if cc, ok := dep.(*Module); ok {
2251 if library, ok := cc.linker.(*libraryDecorator); ok {
2252 if Bool(library.Properties.Inject_bssl_hash) {
2253 injectBoringSSLHash = true
2254 }
2255 }
2256 }
2257 }
2258 })
2259 if injectBoringSSLHash {
2260 hashedOutputfile := outputFile
2261 outputFile = android.PathForModuleOut(ctx, "unhashed", fileName)
2262
Colin Crossf1a035e2020-11-16 17:32:30 -08002263 rule := android.NewRuleBuilder(pctx, ctx)
Colin Crossd7227f92019-09-05 14:26:33 -07002264 rule.Command().
Colin Crossf1a035e2020-11-16 17:32:30 -08002265 BuiltTool("bssl_inject_hash").
Pete Bentley5c4be822019-10-01 17:03:17 +01002266 Flag("-sha256").
Colin Crossd7227f92019-09-05 14:26:33 -07002267 FlagWithInput("-in-object ", outputFile).
2268 FlagWithOutput("-o ", hashedOutputfile)
Colin Crossf1a035e2020-11-16 17:32:30 -08002269 rule.Build("injectCryptoHash", "inject crypto hash")
Colin Crossd7227f92019-09-05 14:26:33 -07002270 }
2271
2272 return outputFile
2273}
Rupert Shuttleworth095081c2021-03-25 09:06:03 +00002274
Rupert Shuttleworth095081c2021-03-25 09:06:03 +00002275type bazelCcLibraryStaticAttributes struct {
Chris Parsonsd6358772021-05-18 18:35:24 -04002276 Copts bazel.StringListAttribute
2277 Srcs bazel.LabelListAttribute
2278 Implementation_deps bazel.LabelListAttribute
2279 Deps bazel.LabelListAttribute
2280 Whole_archive_deps bazel.LabelListAttribute
2281 Linkopts bazel.StringListAttribute
2282 Linkstatic bool
Liz Kammerd366c902021-06-03 13:43:01 -04002283 Use_libcrt bazel.BoolAttribute
Chris Parsonsd6358772021-05-18 18:35:24 -04002284 Includes bazel.StringListAttribute
2285 Hdrs bazel.LabelListAttribute
Chris Parsons990c4f42021-05-25 12:10:58 -04002286
2287 Cppflags bazel.StringListAttribute
2288 Srcs_c bazel.LabelListAttribute
2289 Conlyflags bazel.StringListAttribute
2290 Srcs_as bazel.LabelListAttribute
2291 Asflags bazel.StringListAttribute
Rupert Shuttleworth095081c2021-03-25 09:06:03 +00002292}
2293
2294type bazelCcLibraryStatic struct {
2295 android.BazelTargetModuleBase
2296 bazelCcLibraryStaticAttributes
2297}
2298
2299func BazelCcLibraryStaticFactory() android.Module {
2300 module := &bazelCcLibraryStatic{}
2301 module.AddProperties(&module.bazelCcLibraryStaticAttributes)
2302 android.InitBazelTargetModule(module)
2303 return module
2304}
2305
Jingwen Chen179856a2021-05-03 09:15:48 +00002306func ccLibraryStaticBp2BuildInternal(ctx android.TopDownMutatorContext, module *Module) {
2307 compilerAttrs := bp2BuildParseCompilerProps(ctx, module)
2308 linkerAttrs := bp2BuildParseLinkerProps(ctx, module)
2309 exportedIncludes := bp2BuildParseExportedIncludes(ctx, module)
2310
2311 attrs := &bazelCcLibraryStaticAttributes{
Chris Parsonsd6358772021-05-18 18:35:24 -04002312 Copts: compilerAttrs.copts,
2313 Srcs: compilerAttrs.srcs,
2314 Implementation_deps: linkerAttrs.deps,
2315 Deps: linkerAttrs.exportedDeps,
2316 Whole_archive_deps: linkerAttrs.wholeArchiveDeps,
Chris Parsons08648312021-05-06 16:23:19 -04002317
Jingwen Chen179856a2021-05-03 09:15:48 +00002318 Linkopts: linkerAttrs.linkopts,
2319 Linkstatic: true,
Liz Kammerd366c902021-06-03 13:43:01 -04002320 Use_libcrt: linkerAttrs.useLibcrt,
Jingwen Chen179856a2021-05-03 09:15:48 +00002321 Includes: exportedIncludes,
Chris Parsons990c4f42021-05-25 12:10:58 -04002322
2323 Cppflags: compilerAttrs.cppFlags,
2324 Srcs_c: compilerAttrs.cSrcs,
2325 Conlyflags: compilerAttrs.conlyFlags,
2326 Srcs_as: compilerAttrs.asSrcs,
2327 Asflags: compilerAttrs.asFlags,
Jingwen Chen179856a2021-05-03 09:15:48 +00002328 }
2329
2330 props := bazel.BazelTargetModuleProperties{
2331 Rule_class: "cc_library_static",
2332 Bzl_load_location: "//build/bazel/rules:cc_library_static.bzl",
2333 }
2334
2335 ctx.CreateBazelTargetModule(BazelCcLibraryStaticFactory, module.Name(), props, attrs)
2336}
2337
Rupert Shuttleworth095081c2021-03-25 09:06:03 +00002338func CcLibraryStaticBp2Build(ctx android.TopDownMutatorContext) {
2339 module, ok := ctx.Module().(*Module)
2340 if !ok {
2341 // Not a cc module
2342 return
2343 }
2344 if !module.ConvertWithBp2build(ctx) {
2345 return
2346 }
2347 if ctx.ModuleType() != "cc_library_static" {
2348 return
2349 }
2350
Jingwen Chen179856a2021-05-03 09:15:48 +00002351 ccLibraryStaticBp2BuildInternal(ctx, module)
Rupert Shuttleworth095081c2021-03-25 09:06:03 +00002352}
2353
2354func (m *bazelCcLibraryStatic) Name() string {
2355 return m.BaseModuleName()
2356}
2357
2358func (m *bazelCcLibraryStatic) GenerateAndroidBuildActions(ctx android.ModuleContext) {}