blob: 62937cb7311316ea28b063b3e4ce5f6cd8a70345 [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 Cross4d9c2d12016-07-29 12:48:20 -070026 "android/soong/android"
Rupert Shuttleworth095081c2021-03-25 09:06:03 +000027 "android/soong/bazel"
Chris Parsons94a0bba2021-06-04 15:03:47 -040028 "android/soong/bazel/cquery"
Dan Albertea4b7b92018-04-25 16:05:30 -070029 "android/soong/cc/config"
Liz Kammer2ada09a2021-08-11 00:17:36 -040030
Chris Parsons51f8c392021-08-03 21:01:05 -040031 "github.com/google/blueprint"
32 "github.com/google/blueprint/pathtools"
Colin Cross4d9c2d12016-07-29 12:48:20 -070033)
34
Liz Kammer2b376bc2022-01-12 12:00:49 -050035// LibraryProperties is a collection of properties shared by cc library rules/cc.
Colin Crossb916a382016-07-29 17:28:03 -070036type LibraryProperties struct {
Colin Cross4d9c2d12016-07-29 12:48:20 -070037 // local file name to pass to the linker as -unexported_symbols_list
Colin Cross27b922f2019-03-04 22:35:41 -080038 Unexported_symbols_list *string `android:"path,arch_variant"`
Colin Cross4d9c2d12016-07-29 12:48:20 -070039 // local file name to pass to the linker as -force_symbols_not_weak_list
Colin Cross27b922f2019-03-04 22:35:41 -080040 Force_symbols_not_weak_list *string `android:"path,arch_variant"`
Colin Cross4d9c2d12016-07-29 12:48:20 -070041 // local file name to pass to the linker as -force_symbols_weak_list
Colin Cross27b922f2019-03-04 22:35:41 -080042 Force_symbols_weak_list *string `android:"path,arch_variant"`
Colin Cross4d9c2d12016-07-29 12:48:20 -070043
44 // rename host libraries to prevent overlap with system installed libraries
45 Unique_host_soname *bool
46
Dan Willemsene1240db2016-11-03 14:28:51 -070047 Aidl struct {
48 // export headers generated from .aidl sources
Nan Zhang0007d812017-11-07 10:57:05 -080049 Export_aidl_headers *bool
Dan Willemsene1240db2016-11-03 14:28:51 -070050 }
51
Colin Cross0c461f12016-10-20 16:11:43 -070052 Proto struct {
53 // export headers generated from .proto sources
Nan Zhang0007d812017-11-07 10:57:05 -080054 Export_proto_headers *bool
Colin Cross0c461f12016-10-20 16:11:43 -070055 }
Dan Albertf563d252017-10-13 00:29:00 -070056
Inseob Kimc0907f12019-02-08 21:00:45 +090057 Sysprop struct {
58 // Whether platform owns this sysprop library.
59 Platform *bool
Inseob Kimb3f22ca2019-03-05 12:40:24 +090060 } `blueprint:"mutated"`
Inseob Kimc0907f12019-02-08 21:00:45 +090061
Nan Zhang0007d812017-11-07 10:57:05 -080062 Static_ndk_lib *bool
Jiyong Park7ed9de32018-10-15 22:25:07 +090063
Florian Mayer6dab96c2020-12-31 11:39:48 +000064 // Generate stubs to make this library accessible to APEXes.
Jiyong Park7ed9de32018-10-15 22:25:07 +090065 Stubs struct {
66 // Relative path to the symbol map. The symbol map provides the list of
67 // symbols that are exported for stubs variant of this library.
Colin Cross27b922f2019-03-04 22:35:41 -080068 Symbol_file *string `android:"path"`
Jiyong Park7ed9de32018-10-15 22:25:07 +090069
Jiyong Parkd4a3a132021-03-17 20:21:35 +090070 // List versions to generate stubs libs for. The version name "current" is always
71 // implicitly added.
Jiyong Park7ed9de32018-10-15 22:25:07 +090072 Versions []string
73 }
dimitryd95964a2018-11-07 13:43:34 +010074
75 // set the name of the output
76 Stem *string `android:"arch_variant"`
77
Colin Cross0fd6a412019-08-16 14:22:10 -070078 // set suffix of the name of the output
79 Suffix *string `android:"arch_variant"`
80
81 Target struct {
Justin Yun63e9ec72020-10-29 16:49:43 +090082 Vendor, Product struct {
Colin Cross0fd6a412019-08-16 14:22:10 -070083 // set suffix of the name of the output
84 Suffix *string `android:"arch_variant"`
85 }
86 }
87
dimitryd95964a2018-11-07 13:43:34 +010088 // Names of modules to be overridden. Listed modules can only be other shared libraries
89 // (in Make or Soong).
90 // This does not completely prevent installation of the overridden libraries, but if both
91 // binaries would be installed by default (in PRODUCT_PACKAGES) the other library will be removed
92 // from PRODUCT_PACKAGES.
93 Overrides []string
Logan Chiene3d7a0d2019-01-17 00:18:02 +080094
95 // Properties for ABI compatibility checker
96 Header_abi_checker struct {
Logan Chien41eabe62019-04-10 13:33:58 +080097 // Enable ABI checks (even if this is not an LLNDK/VNDK lib)
98 Enabled *bool
99
Logan Chiene3d7a0d2019-01-17 00:18:02 +0800100 // Path to a symbol file that specifies the symbols to be included in the generated
101 // ABI dump file
Colin Cross27b922f2019-03-04 22:35:41 -0800102 Symbol_file *string `android:"path"`
Logan Chiene3d7a0d2019-01-17 00:18:02 +0800103
104 // Symbol versions that should be ignored from the symbol file
105 Exclude_symbol_versions []string
106
107 // Symbol tags that should be ignored from the symbol file
108 Exclude_symbol_tags []string
Logan Chien2a65dda2019-10-01 15:58:07 -0700109
110 // Run checks on all APIs (in addition to the ones referred by
111 // one of exported ELF symbols.)
112 Check_all_apis *bool
Hsin-Yi Chen6ad1e4b2022-05-19 15:17:54 +0800113
114 // Extra flags passed to header-abi-diff
115 Diff_flags []string
Logan Chiene3d7a0d2019-01-17 00:18:02 +0800116 }
Vic Yang6cd1be82019-06-24 16:08:48 -0700117
Pete Bentley803e1612019-08-06 22:19:59 +0100118 // Inject boringssl hash into the shared library. This is only intended for use by external/boringssl.
119 Inject_bssl_hash *bool `android:"arch_variant"`
Colin Cross0477b422020-10-13 18:43:54 -0700120
Colin Cross127bb8b2020-12-16 16:46:01 -0800121 // If this is an LLNDK library, properties to describe the LLNDK stubs. Will be copied from
122 // the module pointed to by llndk_stubs if it is set.
123 Llndk llndkLibraryProperties
Colin Cross5271fea2021-04-27 13:06:04 -0700124
125 // If this is a vendor public library, properties to describe the vendor public library stubs.
126 Vendor_public_library vendorPublicLibraryProperties
Colin Crossa48ab5b2017-02-14 15:28:44 -0800127}
Colin Cross0c461f12016-10-20 16:11:43 -0700128
Chris Parsons3c27ca32020-11-20 12:42:07 -0500129// StaticProperties is a properties stanza to affect only attributes of the "static" variants of a
130// library module.
Colin Crosse1bb5d02019-09-24 14:55:04 -0700131type StaticProperties struct {
132 Static StaticOrSharedProperties `android:"arch_variant"`
133}
134
Chris Parsons3c27ca32020-11-20 12:42:07 -0500135// SharedProperties is a properties stanza to affect only attributes of the "shared" variants of a
136// library module.
Colin Crosse1bb5d02019-09-24 14:55:04 -0700137type SharedProperties struct {
138 Shared StaticOrSharedProperties `android:"arch_variant"`
139}
140
Chris Parsons3c27ca32020-11-20 12:42:07 -0500141// StaticOrSharedProperties is an embedded struct representing properties to affect attributes of
142// either only the "static" variants or only the "shared" variants of a library module. These override
143// the base properties of the same name.
144// Use `StaticProperties` or `SharedProperties`, depending on which variant is needed.
145// `StaticOrSharedProperties` exists only to avoid duplication.
Colin Crosse1bb5d02019-09-24 14:55:04 -0700146type StaticOrSharedProperties struct {
Evgenii Stepanov2080bfe2020-07-24 15:35:40 -0700147 Srcs []string `android:"path,arch_variant"`
148
Chih-Hung Hsieh769a51c2021-09-17 17:18:39 -0700149 Tidy_disabled_srcs []string `android:"path,arch_variant"`
150
Chih-Hung Hsieh9db8a0c2022-02-17 12:54:45 -0800151 Tidy_timeout_srcs []string `android:"path,arch_variant"`
152
Evgenii Stepanov2080bfe2020-07-24 15:35:40 -0700153 Sanitized Sanitized `android:"arch_variant"`
154
Colin Crosse1bb5d02019-09-24 14:55:04 -0700155 Cflags []string `android:"arch_variant"`
156
Colin Cross6b8f4252021-07-22 11:39:44 -0700157 Enabled *bool `android:"arch_variant"`
158 Whole_static_libs []string `android:"arch_variant"`
159 Static_libs []string `android:"arch_variant"`
160 Shared_libs []string `android:"arch_variant"`
161 System_shared_libs []string `android:"arch_variant"`
Colin Crosse1bb5d02019-09-24 14:55:04 -0700162
163 Export_shared_lib_headers []string `android:"arch_variant"`
164 Export_static_lib_headers []string `android:"arch_variant"`
Jiyong Parka90ca002019-10-07 15:47:24 +0900165
166 Apex_available []string `android:"arch_variant"`
Colin Cross1bc94122021-10-28 13:25:54 -0700167
168 Installable *bool `android:"arch_variant"`
Colin Crosse1bb5d02019-09-24 14:55:04 -0700169}
170
Colin Crossa48ab5b2017-02-14 15:28:44 -0800171type LibraryMutatedProperties struct {
Colin Crossb916a382016-07-29 17:28:03 -0700172 // Build a static variant
173 BuildStatic bool `blueprint:"mutated"`
174 // Build a shared variant
175 BuildShared bool `blueprint:"mutated"`
176 // This variant is shared
177 VariantIsShared bool `blueprint:"mutated"`
178 // This variant is static
179 VariantIsStatic bool `blueprint:"mutated"`
Jiyong Park7ed9de32018-10-15 22:25:07 +0900180
181 // This variant is a stubs lib
182 BuildStubs bool `blueprint:"mutated"`
Jiyong Parkd4a3a132021-03-17 20:21:35 +0900183 // This variant is the latest version
184 IsLatestVersion bool `blueprint:"mutated"`
Jiyong Park7ed9de32018-10-15 22:25:07 +0900185 // Version of the stubs lib
186 StubsVersion string `blueprint:"mutated"`
Colin Crossd1f898e2020-08-18 18:35:15 -0700187 // List of all stubs versions associated with an implementation lib
188 AllStubsVersions []string `blueprint:"mutated"`
Colin Crossb916a382016-07-29 17:28:03 -0700189}
190
191type FlagExporterProperties struct {
192 // list of directories relative to the Blueprints file that will
Dan Willemsen273af7f2016-11-03 15:53:42 -0700193 // be added to the include path (using -I) for this module and any module that links
Colin Cross5d195602017-10-17 16:15:50 -0700194 // against this module. Directories listed in export_include_dirs do not need to be
195 // listed in local_include_dirs.
Colin Cross0ed579e2021-06-29 00:51:12 +0000196 Export_include_dirs []string `android:"arch_variant,variant_prepend"`
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700197
Jiyong Park73c54ee2019-10-22 20:31:18 +0900198 // list of directories that will be added to the system include path
199 // using -isystem for this module and any module that links against this module.
Colin Cross0ed579e2021-06-29 00:51:12 +0000200 Export_system_include_dirs []string `android:"arch_variant,variant_prepend"`
Jiyong Park73c54ee2019-10-22 20:31:18 +0900201
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700202 Target struct {
Justin Yun63e9ec72020-10-29 16:49:43 +0900203 Vendor, Product struct {
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700204 // list of exported include directories, like
Justin Yun63e9ec72020-10-29 16:49:43 +0900205 // export_include_dirs, that will be applied to
206 // vendor or product variant of this library.
207 // This will overwrite any other declarations.
Steven Morelandb21df8f2018-01-05 14:42:54 -0800208 Override_export_include_dirs []string
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700209 }
210 }
Colin Cross4d9c2d12016-07-29 12:48:20 -0700211}
212
213func init() {
Paul Duffin6c26dc72019-12-19 15:02:40 +0000214 RegisterLibraryBuildComponents(android.InitRegistrationContext)
215}
216
217func RegisterLibraryBuildComponents(ctx android.RegistrationContext) {
218 ctx.RegisterModuleType("cc_library_static", LibraryStaticFactory)
219 ctx.RegisterModuleType("cc_library_shared", LibrarySharedFactory)
220 ctx.RegisterModuleType("cc_library", LibraryFactory)
221 ctx.RegisterModuleType("cc_library_host_static", LibraryHostStaticFactory)
222 ctx.RegisterModuleType("cc_library_host_shared", LibraryHostSharedFactory)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700223}
224
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +0000225// TODO(b/199902614): Can this be factored to share with the other Attributes?
Jingwen Chen63930982021-03-24 10:04:33 -0400226// For bp2build conversion.
227type bazelCcLibraryAttributes struct {
Chris Parsons08648312021-05-06 16:23:19 -0400228 // Attributes pertaining to both static and shared variants.
Jingwen Chen14a8bda2021-06-02 11:10:02 +0000229 Srcs bazel.LabelListAttribute
230 Srcs_c bazel.LabelListAttribute
231 Srcs_as bazel.LabelListAttribute
232
233 Copts bazel.StringListAttribute
234 Cppflags bazel.StringListAttribute
235 Conlyflags bazel.StringListAttribute
236 Asflags bazel.StringListAttribute
237
Liz Kammer7a210ac2021-09-22 15:52:58 -0400238 Hdrs bazel.LabelListAttribute
239
Liz Kammer12615db2021-09-28 09:19:17 -0400240 Deps bazel.LabelListAttribute
241 Implementation_deps bazel.LabelListAttribute
242 Dynamic_deps bazel.LabelListAttribute
243 Implementation_dynamic_deps bazel.LabelListAttribute
244 Whole_archive_deps bazel.LabelListAttribute
245 Implementation_whole_archive_deps bazel.LabelListAttribute
246 System_dynamic_deps bazel.LabelListAttribute
Liz Kammer7a210ac2021-09-22 15:52:58 -0400247
Liz Kammer5fad5012021-09-09 14:08:21 -0400248 Export_includes bazel.StringListAttribute
249 Export_system_includes bazel.StringListAttribute
Liz Kammer35687bc2021-09-10 10:07:07 -0400250 Local_includes bazel.StringListAttribute
251 Absolute_includes bazel.StringListAttribute
Liz Kammer5fad5012021-09-09 14:08:21 -0400252 Linkopts bazel.StringListAttribute
253 Use_libcrt bazel.BoolAttribute
254 Rtti bazel.BoolAttribute
Jingwen Chen5b11ab12021-10-11 17:44:33 +0000255
256 Stl *string
257 Cpp_std *string
Chris Parsons79bd2b72021-11-29 17:52:41 -0500258 C_std *string
Chris Parsons990c4f42021-05-25 12:10:58 -0400259
Jingwen Chenc4dc9b42021-06-11 12:51:48 +0000260 // This is shared only.
Liz Kammerd2871182021-10-04 13:54:37 -0400261 Link_crt bazel.BoolAttribute
262 Additional_linker_inputs bazel.LabelListAttribute
Jingwen Chen14a8bda2021-06-02 11:10:02 +0000263
Jingwen Chenc4dc9b42021-06-11 12:51:48 +0000264 // Common properties shared between both shared and static variants.
265 Shared staticOrSharedAttributes
266 Static staticOrSharedAttributes
Jingwen Chen3d383bb2021-06-09 07:18:37 +0000267
268 Strip stripAttributes
Liz Kammer0eae52e2021-10-06 10:32:26 -0400269
270 Features bazel.StringListAttribute
Jingwen Chen3d383bb2021-06-09 07:18:37 +0000271}
272
Vinh Tran9f6796a2022-08-16 13:10:31 -0400273type aidlLibraryAttributes struct {
274 Srcs bazel.LabelListAttribute
275 Include_dir *string
276}
277
278type ccAidlLibraryAttributes struct {
279 Deps bazel.LabelListAttribute
280}
281
Jingwen Chen3d383bb2021-06-09 07:18:37 +0000282type stripAttributes struct {
283 Keep_symbols bazel.BoolAttribute
284 Keep_symbols_and_debug_frame bazel.BoolAttribute
285 Keep_symbols_list bazel.StringListAttribute
286 All bazel.BoolAttribute
287 None bazel.BoolAttribute
Jingwen Chen63930982021-03-24 10:04:33 -0400288}
289
Liz Kammerbe46fcc2021-11-01 15:32:43 -0400290func libraryBp2Build(ctx android.TopDownMutatorContext, m *Module) {
Jingwen Chen179856a2021-05-03 09:15:48 +0000291 // For some cc_library modules, their static variants are ready to be
292 // converted, but not their shared variants. For these modules, delegate to
293 // the cc_library_static bp2build converter temporarily instead.
Chris Parsonsad876012022-08-20 14:48:32 -0400294 if android.GetBp2BuildAllowList().GenerateCcLibraryStaticOnly(ctx.Module().Name()) {
Liz Kammerbe46fcc2021-11-01 15:32:43 -0400295 sharedOrStaticLibraryBp2Build(ctx, m, true)
Jingwen Chen179856a2021-05-03 09:15:48 +0000296 return
297 }
298
Jingwen Chen53681ef2021-04-29 08:15:13 +0000299 sharedAttrs := bp2BuildParseSharedProps(ctx, m)
300 staticAttrs := bp2BuildParseStaticProps(ctx, m)
Liz Kammere6583482021-10-19 13:56:10 -0400301 baseAttributes := bp2BuildParseBaseProps(ctx, m)
302 compilerAttrs := baseAttributes.compilerAttributes
303 linkerAttrs := baseAttributes.linkerAttributes
Liz Kammer54549442022-05-11 13:55:06 -0400304 exportedIncludes := bp2BuildParseExportedIncludes(ctx, m, &compilerAttrs.includes)
Jingwen Chen63930982021-03-24 10:04:33 -0400305
Liz Kammer9abd62d2021-05-21 08:37:59 -0400306 srcs := compilerAttrs.srcs
Jingwen Chen53681ef2021-04-29 08:15:13 +0000307
Liz Kammer12615db2021-09-28 09:19:17 -0400308 sharedAttrs.Dynamic_deps.Add(baseAttributes.protoDependency)
309 staticAttrs.Deps.Add(baseAttributes.protoDependency)
310
Chris Parsons69fa9f92021-07-13 11:47:44 -0400311 asFlags := compilerAttrs.asFlags
312 if compilerAttrs.asSrcs.IsEmpty() && sharedAttrs.Srcs_as.IsEmpty() && staticAttrs.Srcs_as.IsEmpty() {
313 // Skip asflags for BUILD file simplicity if there are no assembly sources.
314 asFlags = bazel.MakeStringListAttribute(nil)
315 }
316
Chris Parsons77acf2e2021-12-03 17:27:16 -0500317 staticCommonAttrs := staticOrSharedAttributes{
318 Srcs: *srcs.Clone().Append(staticAttrs.Srcs),
319 Srcs_c: *compilerAttrs.cSrcs.Clone().Append(staticAttrs.Srcs_c),
320 Srcs_as: *compilerAttrs.asSrcs.Clone().Append(staticAttrs.Srcs_as),
321 Copts: *compilerAttrs.copts.Clone().Append(staticAttrs.Copts),
322 Hdrs: *compilerAttrs.hdrs.Clone().Append(staticAttrs.Hdrs),
Jingwen Chen14a8bda2021-06-02 11:10:02 +0000323
Chris Parsons77acf2e2021-12-03 17:27:16 -0500324 Deps: *linkerAttrs.deps.Clone().Append(staticAttrs.Deps),
325 Implementation_deps: *linkerAttrs.implementationDeps.Clone().Append(staticAttrs.Implementation_deps),
326 Dynamic_deps: *linkerAttrs.dynamicDeps.Clone().Append(staticAttrs.Dynamic_deps),
327 Implementation_dynamic_deps: *linkerAttrs.implementationDynamicDeps.Clone().Append(staticAttrs.Implementation_dynamic_deps),
328 Implementation_whole_archive_deps: linkerAttrs.implementationWholeArchiveDeps,
329 Whole_archive_deps: *linkerAttrs.wholeArchiveDeps.Clone().Append(staticAttrs.Whole_archive_deps),
330 System_dynamic_deps: *linkerAttrs.systemDynamicDeps.Clone().Append(staticAttrs.System_dynamic_deps),
Cole Faust6b29f592022-08-09 09:50:56 -0700331 Runtime_deps: linkerAttrs.runtimeDeps,
Yu Liufc603162022-03-01 15:44:08 -0800332 sdkAttributes: bp2BuildParseSdkAttributes(m),
Chris Parsons77acf2e2021-12-03 17:27:16 -0500333 }
334
335 sharedCommonAttrs := staticOrSharedAttributes{
336 Srcs: *srcs.Clone().Append(sharedAttrs.Srcs),
337 Srcs_c: *compilerAttrs.cSrcs.Clone().Append(sharedAttrs.Srcs_c),
338 Srcs_as: *compilerAttrs.asSrcs.Clone().Append(sharedAttrs.Srcs_as),
339 Copts: *compilerAttrs.copts.Clone().Append(sharedAttrs.Copts),
340 Hdrs: *compilerAttrs.hdrs.Clone().Append(sharedAttrs.Hdrs),
341
Liz Kammer84b0ecb2022-09-14 10:49:13 -0400342 Deps: *linkerAttrs.deps.Clone().Append(sharedAttrs.Deps),
343 Implementation_deps: *linkerAttrs.implementationDeps.Clone().Append(sharedAttrs.Implementation_deps),
344 Dynamic_deps: *linkerAttrs.dynamicDeps.Clone().Append(sharedAttrs.Dynamic_deps),
345 Implementation_dynamic_deps: *linkerAttrs.implementationDynamicDeps.Clone().Append(sharedAttrs.Implementation_dynamic_deps),
346 Whole_archive_deps: *linkerAttrs.wholeArchiveDeps.Clone().Append(sharedAttrs.Whole_archive_deps),
347 Implementation_whole_archive_deps: linkerAttrs.implementationWholeArchiveDeps,
348 System_dynamic_deps: *linkerAttrs.systemDynamicDeps.Clone().Append(sharedAttrs.System_dynamic_deps),
349 Runtime_deps: linkerAttrs.runtimeDeps,
350 sdkAttributes: bp2BuildParseSdkAttributes(m),
Chris Parsons77acf2e2021-12-03 17:27:16 -0500351 }
352
353 staticTargetAttrs := &bazelCcLibraryStaticAttributes{
354 staticOrSharedAttributes: staticCommonAttrs,
355
Jingwen Chen14a8bda2021-06-02 11:10:02 +0000356 Cppflags: compilerAttrs.cppFlags,
357 Conlyflags: compilerAttrs.conlyFlags,
Chris Parsons69fa9f92021-07-13 11:47:44 -0400358 Asflags: asFlags,
Jingwen Chen14a8bda2021-06-02 11:10:02 +0000359
Liz Kammer1263d9b2021-12-10 14:28:20 -0500360 Export_includes: exportedIncludes.Includes,
361 Export_absolute_includes: exportedIncludes.AbsoluteIncludes,
362 Export_system_includes: exportedIncludes.SystemIncludes,
363 Local_includes: compilerAttrs.localIncludes,
364 Absolute_includes: compilerAttrs.absoluteIncludes,
365 Use_libcrt: linkerAttrs.useLibcrt,
366 Rtti: compilerAttrs.rtti,
367 Stl: compilerAttrs.stl,
368 Cpp_std: compilerAttrs.cppStd,
369 C_std: compilerAttrs.cStd,
Yu Liua79c9462022-03-22 16:35:22 -0700370 Use_version_lib: linkerAttrs.useVersionLib,
Chris Parsons77acf2e2021-12-03 17:27:16 -0500371
Cole Faust5fa4e962022-08-22 14:31:04 -0700372 Features: baseAttributes.features,
Chris Parsons77acf2e2021-12-03 17:27:16 -0500373 }
374
375 sharedTargetAttrs := &bazelCcLibrarySharedAttributes{
376 staticOrSharedAttributes: sharedCommonAttrs,
377 Cppflags: compilerAttrs.cppFlags,
378 Conlyflags: compilerAttrs.conlyFlags,
379 Asflags: asFlags,
380
Liz Kammer1263d9b2021-12-10 14:28:20 -0500381 Export_includes: exportedIncludes.Includes,
382 Export_absolute_includes: exportedIncludes.AbsoluteIncludes,
383 Export_system_includes: exportedIncludes.SystemIncludes,
384 Local_includes: compilerAttrs.localIncludes,
385 Absolute_includes: compilerAttrs.absoluteIncludes,
386 Linkopts: linkerAttrs.linkopts,
387 Link_crt: linkerAttrs.linkCrt,
388 Use_libcrt: linkerAttrs.useLibcrt,
389 Rtti: compilerAttrs.rtti,
390 Stl: compilerAttrs.stl,
391 Cpp_std: compilerAttrs.cppStd,
392 C_std: compilerAttrs.cStd,
Yu Liua79c9462022-03-22 16:35:22 -0700393 Use_version_lib: linkerAttrs.useVersionLib,
Chris Parsons990c4f42021-05-25 12:10:58 -0400394
Liz Kammerd2871182021-10-04 13:54:37 -0400395 Additional_linker_inputs: linkerAttrs.additionalLinkerInputs,
Jingwen Chenc4dc9b42021-06-11 12:51:48 +0000396
Jingwen Chen3d383bb2021-06-09 07:18:37 +0000397 Strip: stripAttributes{
398 Keep_symbols: linkerAttrs.stripKeepSymbols,
399 Keep_symbols_and_debug_frame: linkerAttrs.stripKeepSymbolsAndDebugFrame,
400 Keep_symbols_list: linkerAttrs.stripKeepSymbolsList,
401 All: linkerAttrs.stripAll,
402 None: linkerAttrs.stripNone,
403 },
Cole Faust5fa4e962022-08-22 14:31:04 -0700404 Features: baseAttributes.features,
Wei Li81852ca2022-07-27 00:22:06 -0700405 }
Jingwen Chen0ee88a62022-01-07 14:55:29 +0000406
Wei Li81852ca2022-07-27 00:22:06 -0700407 if compilerAttrs.stubsSymbolFile != nil && len(compilerAttrs.stubsVersions.Value) > 0 {
408 hasStubs := true
409 sharedTargetAttrs.Has_stubs.SetValue(&hasStubs)
Jingwen Chen63930982021-03-24 10:04:33 -0400410 }
411
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxa56e9702022-02-23 18:39:59 -0500412 sharedTargetAttrs.Suffix = compilerAttrs.suffix
413
Yu Liu75be7b92022-02-01 09:54:09 -0800414 for axis, configToProps := range m.GetArchVariantProperties(ctx, &LibraryProperties{}) {
415 for config, props := range configToProps {
416 if props, ok := props.(*LibraryProperties); ok {
417 if props.Inject_bssl_hash != nil {
418 // This is an edge case applies only to libcrypto
Sam Delmericofae47f92022-08-08 13:35:08 -0400419 if m.Name() == "libcrypto" || m.Name() == "libcrypto_for_testing" {
Yu Liu75be7b92022-02-01 09:54:09 -0800420 sharedTargetAttrs.Inject_bssl_hash.SetSelectValue(axis, config, props.Inject_bssl_hash)
421 } else {
422 ctx.PropertyErrorf("inject_bssl_hash", "only applies to libcrypto")
423 }
424 }
425 }
426 }
427 }
428
Chris Parsons77acf2e2021-12-03 17:27:16 -0500429 staticProps := bazel.BazelTargetModuleProperties{
430 Rule_class: "cc_library_static",
Liz Kammer2b376bc2022-01-12 12:00:49 -0500431 Bzl_load_location: "//build/bazel/rules/cc:cc_library_static.bzl",
Chris Parsons77acf2e2021-12-03 17:27:16 -0500432 }
433 sharedProps := bazel.BazelTargetModuleProperties{
434 Rule_class: "cc_library_shared",
Liz Kammer2b376bc2022-01-12 12:00:49 -0500435 Bzl_load_location: "//build/bazel/rules/cc:cc_library_shared.bzl",
Jingwen Chen63930982021-03-24 10:04:33 -0400436 }
437
Chris Parsons58852a02021-12-09 18:10:18 -0500438 ctx.CreateBazelTargetModuleWithRestrictions(staticProps,
439 android.CommonAttributes{Name: m.Name() + "_bp2build_cc_library_static"},
440 staticTargetAttrs, staticAttrs.Enabled)
441 ctx.CreateBazelTargetModuleWithRestrictions(sharedProps,
442 android.CommonAttributes{Name: m.Name()},
443 sharedTargetAttrs, sharedAttrs.Enabled)
Wei Li81852ca2022-07-27 00:22:06 -0700444
Trevor Radcliffe087af542022-09-16 15:36:10 +0000445 createStubsBazelTargetIfNeeded(ctx, m, compilerAttrs, exportedIncludes, baseAttributes)
446}
447
448func createStubsBazelTargetIfNeeded(ctx android.TopDownMutatorContext, m *Module, compilerAttrs compilerAttributes, exportedIncludes BazelIncludes, baseAttributes baseAttributes) {
Wei Li81852ca2022-07-27 00:22:06 -0700449 if compilerAttrs.stubsSymbolFile != nil && len(compilerAttrs.stubsVersions.Value) > 0 {
450 stubSuitesProps := bazel.BazelTargetModuleProperties{
451 Rule_class: "cc_stub_suite",
452 Bzl_load_location: "//build/bazel/rules/cc:cc_stub_library.bzl",
453 }
454 soname := m.Name() + ".so"
455 stubSuitesAttrs := &bazelCcStubSuiteAttributes{
456 Symbol_file: compilerAttrs.stubsSymbolFile,
457 Versions: compilerAttrs.stubsVersions,
458 Export_includes: exportedIncludes.Includes,
459 Soname: &soname,
460 Source_library: *bazel.MakeLabelAttribute(":" + m.Name()),
461 Deps: baseAttributes.deps,
462 }
463 ctx.CreateBazelTargetModule(stubSuitesProps,
464 android.CommonAttributes{Name: m.Name() + "_stub_libs"},
465 stubSuitesAttrs)
466 }
Jingwen Chen63930982021-03-24 10:04:33 -0400467}
468
Patrice Arruda83c89e02019-03-25 15:32:39 -0700469// cc_library creates both static and/or shared libraries for a device and/or
470// host. By default, a cc_library has a single variant that targets the device.
471// Specifying `host_supported: true` also creates a library that targets the
472// host.
Steven Morelandf9e62162017-11-02 17:00:50 -0700473func LibraryFactory() android.Module {
Colin Crossab3b7322016-12-09 14:46:15 -0800474 module, _ := NewLibrary(android.HostAndDeviceSupported)
Paul Duffina0843f62019-12-13 19:50:38 +0000475 // Can be used as both a static and a shared library.
476 module.sdkMemberTypes = []android.SdkMemberType{
477 sharedLibrarySdkMemberType,
478 staticLibrarySdkMemberType,
Paul Duffin9b76c0b2020-03-12 10:24:35 +0000479 staticAndSharedLibrarySdkMemberType,
Paul Duffina0843f62019-12-13 19:50:38 +0000480 }
Liz Kammerbe46fcc2021-11-01 15:32:43 -0400481 module.bazelable = true
Chris Parsonsbcc9b882021-06-03 11:16:27 -0400482 module.bazelHandler = &ccLibraryBazelHandler{module: module}
Colin Cross4d9c2d12016-07-29 12:48:20 -0700483 return module.Init()
484}
485
Patrice Arruda83c89e02019-03-25 15:32:39 -0700486// cc_library_static creates a static library for a device and/or host binary.
Steven Morelandf9e62162017-11-02 17:00:50 -0700487func LibraryStaticFactory() android.Module {
Colin Crossab3b7322016-12-09 14:46:15 -0800488 module, library := NewLibrary(android.HostAndDeviceSupported)
489 library.BuildOnlyStatic()
Paul Duffina0843f62019-12-13 19:50:38 +0000490 module.sdkMemberTypes = []android.SdkMemberType{staticLibrarySdkMemberType}
Liz Kammerbe46fcc2021-11-01 15:32:43 -0400491 module.bazelable = true
Chris Parsonsbcc9b882021-06-03 11:16:27 -0400492 module.bazelHandler = &ccLibraryBazelHandler{module: module}
Colin Cross4d9c2d12016-07-29 12:48:20 -0700493 return module.Init()
494}
495
Patrice Arruda83c89e02019-03-25 15:32:39 -0700496// cc_library_shared creates a shared library for a device and/or host.
Steven Morelandf9e62162017-11-02 17:00:50 -0700497func LibrarySharedFactory() android.Module {
Colin Crossab3b7322016-12-09 14:46:15 -0800498 module, library := NewLibrary(android.HostAndDeviceSupported)
499 library.BuildOnlyShared()
Paul Duffina0843f62019-12-13 19:50:38 +0000500 module.sdkMemberTypes = []android.SdkMemberType{sharedLibrarySdkMemberType}
Liz Kammerbe46fcc2021-11-01 15:32:43 -0400501 module.bazelable = true
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxbc4e7342021-09-14 20:58:25 +0000502 module.bazelHandler = &ccLibraryBazelHandler{module: module}
Colin Cross4d9c2d12016-07-29 12:48:20 -0700503 return module.Init()
504}
505
Patrice Arruda83c89e02019-03-25 15:32:39 -0700506// cc_library_host_static creates a static library that is linkable to a host
507// binary.
Steven Morelandf9e62162017-11-02 17:00:50 -0700508func LibraryHostStaticFactory() android.Module {
Colin Crossab3b7322016-12-09 14:46:15 -0800509 module, library := NewLibrary(android.HostSupported)
510 library.BuildOnlyStatic()
Paul Duffina0843f62019-12-13 19:50:38 +0000511 module.sdkMemberTypes = []android.SdkMemberType{staticLibrarySdkMemberType}
Liz Kammer3d3b35c2022-01-11 16:02:50 +0000512 module.bazelable = true
513 module.bazelHandler = &ccLibraryBazelHandler{module: module}
Colin Cross4d9c2d12016-07-29 12:48:20 -0700514 return module.Init()
515}
516
Patrice Arruda83c89e02019-03-25 15:32:39 -0700517// cc_library_host_shared creates a shared library that is usable on a host.
Steven Morelandf9e62162017-11-02 17:00:50 -0700518func LibraryHostSharedFactory() android.Module {
Colin Crossab3b7322016-12-09 14:46:15 -0800519 module, library := NewLibrary(android.HostSupported)
520 library.BuildOnlyShared()
Paul Duffina0843f62019-12-13 19:50:38 +0000521 module.sdkMemberTypes = []android.SdkMemberType{sharedLibrarySdkMemberType}
Wei Libafb6d62021-12-10 03:14:59 -0800522 module.bazelable = true
523 module.bazelHandler = &ccLibraryBazelHandler{module: module}
Colin Cross4d9c2d12016-07-29 12:48:20 -0700524 return module.Init()
525}
526
Chris Parsons3c27ca32020-11-20 12:42:07 -0500527// flagExporter is a separated portion of libraryDecorator pertaining to exported
528// include paths and flags. Keeping this dependency-related information separate
529// from the rest of library information is helpful in keeping data more structured
530// and explicit.
Colin Cross4d9c2d12016-07-29 12:48:20 -0700531type flagExporter struct {
532 Properties FlagExporterProperties
533
Chris Parsons3c27ca32020-11-20 12:42:07 -0500534 dirs android.Paths // Include directories to be included with -I
535 systemDirs android.Paths // System include directories to be included with -isystem
536 flags []string // Exported raw flags.
Inseob Kim69378442019-06-03 19:10:47 +0900537 deps android.Paths
Inseob Kimd110f872019-12-06 13:15:38 +0900538 headers android.Paths
Colin Cross4d9c2d12016-07-29 12:48:20 -0700539}
540
Chris Parsons3c27ca32020-11-20 12:42:07 -0500541// exportedIncludes returns the effective include paths for this module and
542// any module that links against this module. This is obtained from
543// the export_include_dirs property in the appropriate target stanza.
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700544func (f *flagExporter) exportedIncludes(ctx ModuleContext) android.Paths {
Justin Yun6977e8a2020-10-29 18:24:11 +0900545 if ctx.inVendor() && f.Properties.Target.Vendor.Override_export_include_dirs != nil {
Steven Morelandb21df8f2018-01-05 14:42:54 -0800546 return android.PathsForModuleSrc(ctx, f.Properties.Target.Vendor.Override_export_include_dirs)
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700547 }
Justin Yun6977e8a2020-10-29 18:24:11 +0900548 if ctx.inProduct() && f.Properties.Target.Product.Override_export_include_dirs != nil {
549 return android.PathsForModuleSrc(ctx, f.Properties.Target.Product.Override_export_include_dirs)
550 }
551 return android.PathsForModuleSrc(ctx, f.Properties.Export_include_dirs)
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700552}
553
Chris Parsons3c27ca32020-11-20 12:42:07 -0500554// exportIncludes registers the include directories and system include directories to be exported
555// transitively to modules depending on this module.
Inseob Kim69378442019-06-03 19:10:47 +0900556func (f *flagExporter) exportIncludes(ctx ModuleContext) {
Jiyong Park74955042019-10-22 20:19:51 +0900557 f.dirs = append(f.dirs, f.exportedIncludes(ctx)...)
Jiyong Park73c54ee2019-10-22 20:31:18 +0900558 f.systemDirs = append(f.systemDirs, android.PathsForModuleSrc(ctx, f.Properties.Export_system_include_dirs)...)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700559}
560
Chris Parsons3c27ca32020-11-20 12:42:07 -0500561// exportIncludesAsSystem registers the include directories and system include directories to be
562// exported transitively both as system include directories to modules depending on this module.
Inseob Kim69378442019-06-03 19:10:47 +0900563func (f *flagExporter) exportIncludesAsSystem(ctx ModuleContext) {
Jiyong Park73c54ee2019-10-22 20:31:18 +0900564 // all dirs are force exported as system
Jiyong Park74955042019-10-22 20:19:51 +0900565 f.systemDirs = append(f.systemDirs, f.exportedIncludes(ctx)...)
Jiyong Park73c54ee2019-10-22 20:31:18 +0900566 f.systemDirs = append(f.systemDirs, android.PathsForModuleSrc(ctx, f.Properties.Export_system_include_dirs)...)
Inseob Kim69378442019-06-03 19:10:47 +0900567}
568
Chris Parsons3c27ca32020-11-20 12:42:07 -0500569// reexportDirs registers the given directories as include directories to be exported transitively
570// to modules depending on this module.
Jiyong Park74955042019-10-22 20:19:51 +0900571func (f *flagExporter) reexportDirs(dirs ...android.Path) {
Inseob Kim69378442019-06-03 19:10:47 +0900572 f.dirs = append(f.dirs, dirs...)
573}
574
Chris Parsons3c27ca32020-11-20 12:42:07 -0500575// reexportSystemDirs registers the given directories as system include directories
576// to be exported transitively to modules depending on this module.
Jiyong Park74955042019-10-22 20:19:51 +0900577func (f *flagExporter) reexportSystemDirs(dirs ...android.Path) {
Inseob Kim69378442019-06-03 19:10:47 +0900578 f.systemDirs = append(f.systemDirs, dirs...)
579}
580
Chris Parsons3c27ca32020-11-20 12:42:07 -0500581// reexportFlags registers the flags to be exported transitively to modules depending on this
582// module.
Inseob Kim69378442019-06-03 19:10:47 +0900583func (f *flagExporter) reexportFlags(flags ...string) {
Jaewoong Jung3aff5782020-02-11 07:54:35 -0800584 if android.PrefixInList(flags, "-I") || android.PrefixInList(flags, "-isystem") {
585 panic(fmt.Errorf("Exporting invalid flag %q: "+
586 "use reexportDirs or reexportSystemDirs to export directories", flag))
Inseob Kim69378442019-06-03 19:10:47 +0900587 }
Colin Cross4d9c2d12016-07-29 12:48:20 -0700588 f.flags = append(f.flags, flags...)
589}
590
Inseob Kim69378442019-06-03 19:10:47 +0900591func (f *flagExporter) reexportDeps(deps ...android.Path) {
592 f.deps = append(f.deps, deps...)
593}
594
Inseob Kimd110f872019-12-06 13:15:38 +0900595// addExportedGeneratedHeaders does nothing but collects generated header files.
596// This can be differ to exportedDeps which may contain phony files to minimize ninja.
597func (f *flagExporter) addExportedGeneratedHeaders(headers ...android.Path) {
598 f.headers = append(f.headers, headers...)
599}
600
Colin Cross0de8a1e2020-09-18 14:15:30 -0700601func (f *flagExporter) setProvider(ctx android.ModuleContext) {
602 ctx.SetProvider(FlagExporterInfoProvider, FlagExporterInfo{
Chris Parsonsf60ecf02021-04-27 14:48:30 -0400603 // Comes from Export_include_dirs property, and those of exported transitive deps
604 IncludeDirs: android.FirstUniquePaths(f.dirs),
605 // Comes from Export_system_include_dirs property, and those of exported transitive deps
Colin Crossc82e6e22021-04-20 18:21:50 -0700606 SystemIncludeDirs: android.FirstUniquePaths(f.systemDirs),
Chris Parsonsf60ecf02021-04-27 14:48:30 -0400607 // Used in very few places as a one-off way of adding extra defines.
608 Flags: f.flags,
609 // Used sparingly, for extra files that need to be explicitly exported to dependers,
610 // or for phony files to minimize ninja.
611 Deps: f.deps,
612 // For exported generated headers, such as exported aidl headers, proto headers, or
613 // sysprop headers.
614 GeneratedHeaders: f.headers,
Colin Cross0de8a1e2020-09-18 14:15:30 -0700615 })
Inseob Kim69378442019-06-03 19:10:47 +0900616}
617
Colin Crossb916a382016-07-29 17:28:03 -0700618// libraryDecorator wraps baseCompiler, baseLinker and baseInstaller to provide library-specific
619// functionality: static vs. shared linkage, reusing object files for shared libraries
620type libraryDecorator struct {
Colin Crossa48ab5b2017-02-14 15:28:44 -0800621 Properties LibraryProperties
Colin Crosse1bb5d02019-09-24 14:55:04 -0700622 StaticProperties StaticProperties
623 SharedProperties SharedProperties
Colin Crossa48ab5b2017-02-14 15:28:44 -0800624 MutatedProperties LibraryMutatedProperties
Colin Cross4d9c2d12016-07-29 12:48:20 -0700625
626 // For reusing static library objects for shared library
Inseob Kim69378442019-06-03 19:10:47 +0900627 reuseObjects Objects
Colin Cross10d22312017-05-03 11:01:58 -0700628
Colin Cross26c34ed2016-09-30 17:10:16 -0700629 // table-of-contents file to optimize out relinking when possible
630 tocFile android.OptionalPath
Colin Cross4d9c2d12016-07-29 12:48:20 -0700631
Colin Cross4d9c2d12016-07-29 12:48:20 -0700632 flagExporter
Liz Kammerb6a55bf2021-04-12 15:42:51 -0400633 flagExporterInfo *FlagExporterInfo
634 stripper Stripper
Colin Cross4d9c2d12016-07-29 12:48:20 -0700635
Colin Cross4d9c2d12016-07-29 12:48:20 -0700636 // For whole_static_libs
Colin Crossa2bcf2c2022-02-11 13:11:55 -0800637 objects Objects
638 wholeStaticLibsFromPrebuilts android.Paths
Colin Cross4d9c2d12016-07-29 12:48:20 -0700639
640 // Uses the module's name if empty, but can be overridden. Does not include
641 // shlib suffix.
642 libName string
Colin Crossb916a382016-07-29 17:28:03 -0700643
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800644 sabi *sabi
645
Dan Willemsen581341d2017-02-09 16:16:31 -0800646 // Output archive of gcno coverage information files
647 coverageOutputFile android.OptionalPath
648
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800649 // linked Source Abi Dump
650 sAbiOutputFile android.OptionalPath
651
652 // Source Abi Diff
653 sAbiDiff android.OptionalPath
654
Mu-Le Lee0a9005e2022-07-05 09:49:50 +0000655 // Source Abi Diff against previous SDK version
656 prevSAbiDiff android.OptionalPath
657
Colin Cross0875c522017-11-28 17:34:01 -0800658 // Location of the static library in the sysroot. Empty if the library is
659 // not included in the NDK.
660 ndkSysrootPath android.Path
661
Colin Crossb60190a2018-09-04 16:28:17 -0700662 // Location of the linked, unstripped library for shared libraries
663 unstrippedOutputFile android.Path
664
Dan Willemsen569edc52018-11-19 09:33:29 -0800665 // Location of the file that should be copied to dist dir when requested
Jingwen Chen40fd90a2020-06-15 05:24:19 +0000666 distFile android.Path
Dan Willemsen569edc52018-11-19 09:33:29 -0800667
Colin Cross8e21aa52020-09-28 18:28:02 -0700668 versionScriptPath android.OptionalPath
Jiyong Park7ed9de32018-10-15 22:25:07 +0900669
Jaewoong Jung18aefc12020-12-21 09:11:10 -0800670 postInstallCmds []string
Jiyong Parkf1194352019-02-25 11:05:47 +0900671
Vic Yangefd249e2018-11-12 20:19:56 -0800672 // If useCoreVariant is true, the vendor variant of a VNDK library is
673 // not installed.
Vic Yangd92090f2020-01-08 14:32:28 -0800674 useCoreVariant bool
675 checkSameCoreVariant bool
Vic Yangefd249e2018-11-12 20:19:56 -0800676
Colin Cross5ec407b2020-09-30 11:41:33 -0700677 skipAPIDefine bool
678
Martin Stjernholmc5dd4f72020-04-01 20:38:01 +0100679 // Decorated interfaces
Colin Crossb916a382016-07-29 17:28:03 -0700680 *baseCompiler
681 *baseLinker
682 *baseInstaller
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900683
684 collectedSnapshotHeaders android.Paths
sophiez4c4f8032021-08-16 22:54:00 -0700685
686 apiListCoverageXmlPath android.ModuleOutPath
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900687}
688
Chris Parsonsbcc9b882021-06-03 11:16:27 -0400689type ccLibraryBazelHandler struct {
Chris Parsons808d84c2021-03-09 20:43:32 -0500690 module *Module
691}
692
Chris Parsons6ce2cf92022-05-20 10:54:17 -0400693var _ BazelHandler = (*ccLibraryBazelHandler)(nil)
694
Chris Parsons94a0bba2021-06-04 15:03:47 -0400695// generateStaticBazelBuildActions constructs the StaticLibraryInfo Soong
696// provider from a Bazel shared library's CcInfo provider.
Chris Parsonsf874e462022-05-10 13:50:12 -0400697func (handler *ccLibraryBazelHandler) generateStaticBazelBuildActions(ctx android.ModuleContext, label string, ccInfo cquery.CcInfo) {
Chris Parsonsbcc9b882021-06-03 11:16:27 -0400698 rootStaticArchives := ccInfo.RootStaticArchives
Chris Parsonsbcc9b882021-06-03 11:16:27 -0400699 if len(rootStaticArchives) != 1 {
700 ctx.ModuleErrorf("expected exactly one root archive file for '%s', but got %s", label, rootStaticArchives)
Chris Parsonsf874e462022-05-10 13:50:12 -0400701 return
Chris Parsons944e7d02021-03-11 11:08:46 -0500702 }
Chris Parsonsbcc9b882021-06-03 11:16:27 -0400703 outputFilePath := android.PathForBazelOut(ctx, rootStaticArchives[0])
Chris Parsons944e7d02021-03-11 11:08:46 -0500704 handler.module.outputFile = android.OptionalPathForPath(outputFilePath)
705
Chris Parsons94a0bba2021-06-04 15:03:47 -0400706 objPaths := ccInfo.CcObjectFiles
Chris Parsons944e7d02021-03-11 11:08:46 -0500707 objFiles := make(android.Paths, len(objPaths))
708 for i, objPath := range objPaths {
709 objFiles[i] = android.PathForBazelOut(ctx, objPath)
710 }
711 objects := Objects{
712 objFiles: objFiles,
713 }
714
715 ctx.SetProvider(StaticLibraryInfoProvider, StaticLibraryInfo{
716 StaticLibrary: outputFilePath,
717 ReuseObjects: objects,
718 Objects: objects,
719
Chris Parsons94a0bba2021-06-04 15:03:47 -0400720 // TODO(b/190524881): Include transitive static libraries in this provider to support
Chris Parsons944e7d02021-03-11 11:08:46 -0500721 // static libraries with deps.
722 TransitiveStaticLibrariesForOrdering: android.NewDepSetBuilder(android.TOPOLOGICAL).
723 Direct(outputFilePath).
724 Build(),
725 })
Chris Parsonsf60ecf02021-04-27 14:48:30 -0400726
Chris Parsonsf874e462022-05-10 13:50:12 -0400727 return
Chris Parsons94a0bba2021-06-04 15:03:47 -0400728}
729
730// generateSharedBazelBuildActions constructs the SharedLibraryInfo Soong
731// provider from a Bazel shared library's CcInfo provider.
Chris Parsonsf874e462022-05-10 13:50:12 -0400732func (handler *ccLibraryBazelHandler) generateSharedBazelBuildActions(ctx android.ModuleContext, label string, ccInfo cquery.CcInfo) {
Chris Parsons94a0bba2021-06-04 15:03:47 -0400733 rootDynamicLibraries := ccInfo.RootDynamicLibraries
734
735 if len(rootDynamicLibraries) != 1 {
736 ctx.ModuleErrorf("expected exactly one root dynamic library file for '%s', but got %s", label, rootDynamicLibraries)
Chris Parsonsf874e462022-05-10 13:50:12 -0400737 return
Chris Parsons94a0bba2021-06-04 15:03:47 -0400738 }
739 outputFilePath := android.PathForBazelOut(ctx, rootDynamicLibraries[0])
740 handler.module.outputFile = android.OptionalPathForPath(outputFilePath)
741
742 handler.module.linker.(*libraryDecorator).unstrippedOutputFile = outputFilePath
743
Alex Márquez Pérez Muñíz Díaz Púras Thaureaux62585e82021-09-14 21:19:31 +0000744 var tocFile android.OptionalPath
745 if len(ccInfo.TocFile) > 0 {
746 tocFile = android.OptionalPathForPath(android.PathForBazelOut(ctx, ccInfo.TocFile))
747 }
Chris Parsons94a0bba2021-06-04 15:03:47 -0400748 handler.module.linker.(*libraryDecorator).tocFile = tocFile
749
750 ctx.SetProvider(SharedLibraryInfoProvider, SharedLibraryInfo{
751 TableOfContents: tocFile,
752 SharedLibrary: outputFilePath,
Jingwen Chen702963e2021-06-15 23:44:13 +0000753 Target: ctx.Target(),
Chris Parsons94a0bba2021-06-04 15:03:47 -0400754 // TODO(b/190524881): Include transitive static libraries in this provider to support
Jingwen Chen702963e2021-06-15 23:44:13 +0000755 // static libraries with deps. The provider key for this is TransitiveStaticLibrariesForOrdering.
Chris Parsons94a0bba2021-06-04 15:03:47 -0400756 })
Chris Parsons94a0bba2021-06-04 15:03:47 -0400757}
758
Chris Parsonsf874e462022-05-10 13:50:12 -0400759func (handler *ccLibraryBazelHandler) QueueBazelCall(ctx android.BaseModuleContext, label string) {
Chris Parsons94a0bba2021-06-04 15:03:47 -0400760 bazelCtx := ctx.Config().BazelContext
Chris Parsonsf874e462022-05-10 13:50:12 -0400761 bazelCtx.QueueBazelRequest(label, cquery.GetCcInfo, android.GetConfigKey(ctx))
762}
763
764func (handler *ccLibraryBazelHandler) ProcessBazelQueryResponse(ctx android.ModuleContext, label string) {
765 bazelCtx := ctx.Config().BazelContext
766 ccInfo, err := bazelCtx.GetCcInfo(label, android.GetConfigKey(ctx))
Chris Parsons94a0bba2021-06-04 15:03:47 -0400767 if err != nil {
768 ctx.ModuleErrorf("Error getting Bazel CcInfo: %s", err)
Chris Parsonsf874e462022-05-10 13:50:12 -0400769 return
Chris Parsons94a0bba2021-06-04 15:03:47 -0400770 }
771
772 if handler.module.static() {
Chris Parsonsf874e462022-05-10 13:50:12 -0400773 handler.generateStaticBazelBuildActions(ctx, label, ccInfo)
Chris Parsons94a0bba2021-06-04 15:03:47 -0400774 } else if handler.module.Shared() {
Chris Parsonsf874e462022-05-10 13:50:12 -0400775 handler.generateSharedBazelBuildActions(ctx, label, ccInfo)
Chris Parsons94a0bba2021-06-04 15:03:47 -0400776 } else {
Chris Parsonsf874e462022-05-10 13:50:12 -0400777 ctx.ModuleErrorf("Unhandled bazel case for %s (neither shared nor static!)", ctx.ModuleName())
Chris Parsons94a0bba2021-06-04 15:03:47 -0400778 }
779
780 handler.module.linker.(*libraryDecorator).setFlagExporterInfoFromCcInfo(ctx, ccInfo)
781 handler.module.maybeUnhideFromMake()
782
Chris Parsonseefc9e62021-04-02 17:36:47 -0400783 if i, ok := handler.module.linker.(snapshotLibraryInterface); ok {
784 // Dependencies on this library will expect collectedSnapshotHeaders to
785 // be set, otherwise validation will fail. For now, set this to an empty
786 // list.
Chris Parsons94a0bba2021-06-04 15:03:47 -0400787 // TODO(b/190533363): More closely mirror the collectHeadersForSnapshot
Chris Parsonseefc9e62021-04-02 17:36:47 -0400788 // implementation.
789 i.(*libraryDecorator).collectedSnapshotHeaders = android.Paths{}
790 }
Chris Parsons808d84c2021-03-09 20:43:32 -0500791}
792
Chris Parsons94a0bba2021-06-04 15:03:47 -0400793func (library *libraryDecorator) setFlagExporterInfoFromCcInfo(ctx android.ModuleContext, ccInfo cquery.CcInfo) {
794 flagExporterInfo := flagExporterInfoFromCcInfo(ctx, ccInfo)
795 // flag exporters consolidates properties like includes, flags, dependencies that should be
796 // exported from this module to other modules
797 ctx.SetProvider(FlagExporterInfoProvider, flagExporterInfo)
798 // Store flag info to be passed along to androidmk
799 // TODO(b/184387147): Androidmk should be done in Bazel, not Soong.
800 library.flagExporterInfo = &flagExporterInfo
801}
802
Ivan Lozanod67a6b02021-05-20 13:01:32 -0400803func GlobHeadersForSnapshot(ctx android.ModuleContext, paths android.Paths) android.Paths {
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900804 ret := android.Paths{}
805
806 // Headers in the source tree should be globbed. On the contrast, generated headers
807 // can't be globbed, and they should be manually collected.
808 // So, we first filter out intermediate directories (which contains generated headers)
809 // from exported directories, and then glob headers under remaining directories.
Ivan Lozanod67a6b02021-05-20 13:01:32 -0400810 for _, path := range paths {
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900811 dir := path.String()
812 // Skip if dir is for generated headers
813 if strings.HasPrefix(dir, android.PathForOutput(ctx).String()) {
814 continue
815 }
Yu Liu1175c052022-08-15 10:21:31 -0700816
817 // Filter out the generated headers from bazel.
818 if strings.HasPrefix(dir, android.PathForBazelOut(ctx, "bazel-out").String()) {
819 continue
820 }
821
Inseob Kim04f2d6a2020-05-29 22:30:58 +0900822 // libeigen wrongly exports the root directory "external/eigen". But only two
823 // subdirectories "Eigen" and "unsupported" contain exported header files. Even worse
824 // some of them have no extension. So we need special treatment for libeigen in order
825 // to glob correctly.
826 if dir == "external/eigen" {
827 // Only these two directories contains exported headers.
828 for _, subdir := range []string{"Eigen", "unsupported/Eigen"} {
Liz Kammer0ea79982022-02-07 08:51:47 -0500829 globDir := "external/eigen/" + subdir + "/**/*"
830 glob, err := ctx.GlobWithDeps(globDir, nil)
Inseob Kim04f2d6a2020-05-29 22:30:58 +0900831 if err != nil {
Liz Kammer0ea79982022-02-07 08:51:47 -0500832 ctx.ModuleErrorf("glob of %q failed: %s", globDir, err)
Ivan Lozanod67a6b02021-05-20 13:01:32 -0400833 return nil
Inseob Kim04f2d6a2020-05-29 22:30:58 +0900834 }
835 for _, header := range glob {
836 if strings.HasSuffix(header, "/") {
837 continue
838 }
839 ext := filepath.Ext(header)
840 if ext != "" && ext != ".h" {
841 continue
842 }
843 ret = append(ret, android.PathForSource(ctx, header))
844 }
845 }
846 continue
847 }
Liz Kammer0ea79982022-02-07 08:51:47 -0500848 globDir := dir + "/**/*"
849 glob, err := ctx.GlobWithDeps(globDir, nil)
Colin Crossec118d02021-01-22 18:05:59 +0000850 if err != nil {
Liz Kammer0ea79982022-02-07 08:51:47 -0500851 ctx.ModuleErrorf("glob of %q failed: %s", globDir, err)
Ivan Lozanod67a6b02021-05-20 13:01:32 -0400852 return nil
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900853 }
Colin Crossec118d02021-01-22 18:05:59 +0000854 isLibcxx := strings.HasPrefix(dir, "external/libcxx/include")
Jose Galmes0d736912021-03-30 11:00:06 -0700855 for _, header := range glob {
Colin Crossec118d02021-01-22 18:05:59 +0000856 if isLibcxx {
857 // Glob all files under this special directory, because of C++ headers with no
858 // extension.
Jose Galmes0d736912021-03-30 11:00:06 -0700859 if strings.HasSuffix(header, "/") {
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900860 continue
861 }
Colin Crossec118d02021-01-22 18:05:59 +0000862 } else {
863 // Filter out only the files with extensions that are headers.
864 found := false
Ivan Lozanod67a6b02021-05-20 13:01:32 -0400865 for _, ext := range HeaderExts {
Colin Crossec118d02021-01-22 18:05:59 +0000866 if strings.HasSuffix(header, ext) {
867 found = true
868 break
869 }
870 }
871 if !found {
872 continue
873 }
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900874 }
Jose Galmes0d736912021-03-30 11:00:06 -0700875 ret = append(ret, android.PathForSource(ctx, header))
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900876 }
877 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -0400878 return ret
879}
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900880
Ivan Lozanod67a6b02021-05-20 13:01:32 -0400881func GlobGeneratedHeadersForSnapshot(ctx android.ModuleContext, paths android.Paths) android.Paths {
882 ret := android.Paths{}
883 for _, header := range paths {
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900884 // TODO(b/148123511): remove exportedDeps after cleaning up genrule
885 if strings.HasSuffix(header.Base(), "-phony") {
886 continue
887 }
888 ret = append(ret, header)
889 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -0400890 return ret
891}
892
893// collectHeadersForSnapshot collects all exported headers from library.
894// It globs header files in the source tree for exported include directories,
895// and tracks generated header files separately.
896//
897// This is to be called from GenerateAndroidBuildActions, and then collected
898// header files can be retrieved by snapshotHeaders().
899func (l *libraryDecorator) collectHeadersForSnapshot(ctx android.ModuleContext) {
900 ret := android.Paths{}
901
902 // Headers in the source tree should be globbed. On the contrast, generated headers
903 // can't be globbed, and they should be manually collected.
904 // So, we first filter out intermediate directories (which contains generated headers)
905 // from exported directories, and then glob headers under remaining directories.
906 ret = append(ret, GlobHeadersForSnapshot(ctx, append(android.CopyOfPaths(l.flagExporter.dirs), l.flagExporter.systemDirs...))...)
907
908 // Collect generated headers
909 ret = append(ret, GlobGeneratedHeadersForSnapshot(ctx, append(android.CopyOfPaths(l.flagExporter.headers), l.flagExporter.deps...))...)
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900910
911 l.collectedSnapshotHeaders = ret
912}
913
914// This returns all exported header files, both generated ones and headers from source tree.
915// collectHeadersForSnapshot() must be called before calling this.
916func (l *libraryDecorator) snapshotHeaders() android.Paths {
917 if l.collectedSnapshotHeaders == nil {
918 panic("snapshotHeaders() must be called after collectHeadersForSnapshot()")
919 }
920 return l.collectedSnapshotHeaders
Colin Cross4d9c2d12016-07-29 12:48:20 -0700921}
922
Chris Parsons3c27ca32020-11-20 12:42:07 -0500923// linkerProps returns the list of properties structs relevant for this library. (For example, if
924// the library is cc_shared_library, then static-library properties are omitted.)
Colin Crossb916a382016-07-29 17:28:03 -0700925func (library *libraryDecorator) linkerProps() []interface{} {
926 var props []interface{}
927 props = append(props, library.baseLinker.linkerProps()...)
Colin Crosse1bb5d02019-09-24 14:55:04 -0700928 props = append(props,
Colin Cross4d9c2d12016-07-29 12:48:20 -0700929 &library.Properties,
Colin Crossa48ab5b2017-02-14 15:28:44 -0800930 &library.MutatedProperties,
Colin Cross4d9c2d12016-07-29 12:48:20 -0700931 &library.flagExporter.Properties,
Colin Cross22f37952018-09-05 10:43:13 -0700932 &library.stripper.StripProperties)
Colin Crosse1bb5d02019-09-24 14:55:04 -0700933
934 if library.MutatedProperties.BuildShared {
935 props = append(props, &library.SharedProperties)
936 }
937 if library.MutatedProperties.BuildStatic {
938 props = append(props, &library.StaticProperties)
939 }
940
941 return props
Colin Cross4d9c2d12016-07-29 12:48:20 -0700942}
943
Chris Parsons3c27ca32020-11-20 12:42:07 -0500944// linkerFlags takes a Flags struct and augments it to contain linker flags that are defined by this
945// library, or that are implied by attributes of this library (such as whether this library is a
946// shared library).
Colin Crossb916a382016-07-29 17:28:03 -0700947func (library *libraryDecorator) linkerFlags(ctx ModuleContext, flags Flags) Flags {
Colin Cross42742b82016-08-01 13:20:05 -0700948 flags = library.baseLinker.linkerFlags(ctx, flags)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700949
Colin Crossb916a382016-07-29 17:28:03 -0700950 // MinGW spits out warnings about -fPIC even for -fpie?!) being ignored because
951 // all code is position independent, and then those warnings get promoted to
952 // errors.
Colin Cross3edeee12017-04-04 12:59:48 -0700953 if !ctx.Windows() {
Colin Cross4af21ed2019-11-04 09:37:55 -0800954 flags.Global.CFlags = append(flags.Global.CFlags, "-fPIC")
Colin Crossb916a382016-07-29 17:28:03 -0700955 }
956
957 if library.static() {
Colin Cross4af21ed2019-11-04 09:37:55 -0800958 flags.Local.CFlags = append(flags.Local.CFlags, library.StaticProperties.Static.Cflags...)
Colin Crossa48ab5b2017-02-14 15:28:44 -0800959 } else if library.shared() {
Colin Cross4af21ed2019-11-04 09:37:55 -0800960 flags.Local.CFlags = append(flags.Local.CFlags, library.SharedProperties.Shared.Cflags...)
Colin Crossb916a382016-07-29 17:28:03 -0700961 }
962
Colin Crossa48ab5b2017-02-14 15:28:44 -0800963 if library.shared() {
Colin Cross4d9c2d12016-07-29 12:48:20 -0700964 libName := library.getLibName(ctx)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700965 var f []string
Dan Willemsen01a405a2016-06-13 17:19:03 -0700966 if ctx.toolchain().Bionic() {
Colin Cross4d9c2d12016-07-29 12:48:20 -0700967 f = append(f,
968 "-nostdlib",
969 "-Wl,--gc-sections",
970 )
971 }
972
973 if ctx.Darwin() {
974 f = append(f,
975 "-dynamiclib",
Colin Cross4d9c2d12016-07-29 12:48:20 -0700976 "-install_name @rpath/"+libName+flags.Toolchain.ShlibSuffix(),
977 )
Colin Cross7863cf52016-10-20 10:47:21 -0700978 if ctx.Arch().ArchType == android.X86 {
979 f = append(f,
980 "-read_only_relocs suppress",
981 )
982 }
Colin Cross4d9c2d12016-07-29 12:48:20 -0700983 } else {
Josh Gao75a50a22019-06-07 17:58:59 -0700984 f = append(f, "-shared")
985 if !ctx.Windows() {
986 f = append(f, "-Wl,-soname,"+libName+flags.Toolchain.ShlibSuffix())
987 }
Colin Cross4d9c2d12016-07-29 12:48:20 -0700988 }
989
Colin Cross4af21ed2019-11-04 09:37:55 -0800990 flags.Global.LdFlags = append(flags.Global.LdFlags, f...)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700991 }
992
993 return flags
994}
995
Chris Parsons3c27ca32020-11-20 12:42:07 -0500996// compilerFlags takes a Flags and augments it to contain compile flags from global values,
997// per-target values, module type values, per-module Blueprints properties, extra flags from
998// `flags`, and generated sources from `deps`.
Colin Crossf18e1102017-11-16 14:33:08 -0800999func (library *libraryDecorator) compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags {
Dan Willemsen4416e5d2017-04-06 12:43:22 -07001000 exportIncludeDirs := library.flagExporter.exportedIncludes(ctx)
Dan Willemsen273af7f2016-11-03 15:53:42 -07001001 if len(exportIncludeDirs) > 0 {
Colin Crossdad8c952017-04-26 14:55:27 -07001002 f := includeDirsToFlags(exportIncludeDirs)
Colin Cross4af21ed2019-11-04 09:37:55 -08001003 flags.Local.CommonFlags = append(flags.Local.CommonFlags, f)
1004 flags.Local.YasmFlags = append(flags.Local.YasmFlags, f)
Dan Willemsen273af7f2016-11-03 15:53:42 -07001005 }
1006
Jiyong Park7ed9de32018-10-15 22:25:07 +09001007 flags = library.baseCompiler.compilerFlags(ctx, flags, deps)
Colin Cross127bb8b2020-12-16 16:46:01 -08001008 if ctx.IsLlndk() {
1009 // LLNDK libraries ignore most of the properties on the cc_library and use the
1010 // LLNDK-specific properties instead.
1011 // Wipe all the module-local properties, leaving only the global properties.
1012 flags.Local = LocalOrGlobalFlags{}
1013 }
Jiyong Park7ed9de32018-10-15 22:25:07 +09001014 if library.buildStubs() {
Jiyong Park64379952018-12-13 18:37:29 +09001015 // Remove -include <file> when compiling stubs. Otherwise, the force included
1016 // headers might cause conflicting types error with the symbols in the
1017 // generated stubs source code. e.g.
1018 // double acos(double); // in header
1019 // void acos() {} // in the generated source code
1020 removeInclude := func(flags []string) []string {
1021 ret := flags[:0]
1022 for _, f := range flags {
1023 if strings.HasPrefix(f, "-include ") {
1024 continue
1025 }
1026 ret = append(ret, f)
1027 }
1028 return ret
1029 }
Colin Cross4af21ed2019-11-04 09:37:55 -08001030 flags.Local.CommonFlags = removeInclude(flags.Local.CommonFlags)
1031 flags.Local.CFlags = removeInclude(flags.Local.CFlags)
Jiyong Park64379952018-12-13 18:37:29 +09001032
Jiyong Park7ed9de32018-10-15 22:25:07 +09001033 flags = addStubLibraryCompilerFlags(flags)
1034 }
1035 return flags
Dan Willemsen273af7f2016-11-03 15:53:42 -07001036}
1037
Yo Chiang2bbadfa2020-12-14 11:42:16 +08001038func (library *libraryDecorator) headerAbiCheckerEnabled() bool {
1039 return Bool(library.Properties.Header_abi_checker.Enabled)
Hsin-Yi Chen53489642019-07-31 17:10:45 +08001040}
1041
Yo Chiang2bbadfa2020-12-14 11:42:16 +08001042func (library *libraryDecorator) headerAbiCheckerExplicitlyDisabled() bool {
1043 return !BoolDefault(library.Properties.Header_abi_checker.Enabled, true)
Logan Chien41eabe62019-04-10 13:33:58 +08001044}
1045
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001046func (library *libraryDecorator) compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects {
Colin Cross127bb8b2020-12-16 16:46:01 -08001047 if ctx.IsLlndk() {
1048 // This is the vendor variant of an LLNDK library, build the LLNDK stubs.
1049 vndkVer := ctx.Module().(*Module).VndkVersion()
1050 if !inList(vndkVer, ctx.Config().PlatformVersionActiveCodenames()) || vndkVer == "" {
1051 // For non-enforcing devices, vndkVer is empty. Use "current" in that case, too.
1052 vndkVer = "current"
1053 }
1054 if library.stubsVersion() != "" {
1055 vndkVer = library.stubsVersion()
1056 }
Dan Albertf1d14c72020-07-30 14:32:55 -07001057 nativeAbiResult := parseNativeAbiDefinition(ctx,
1058 String(library.Properties.Llndk.Symbol_file),
1059 android.ApiLevelOrPanic(ctx, vndkVer), "--llndk")
1060 objs := compileStubLibrary(ctx, flags, nativeAbiResult.stubSrc)
Colin Cross127bb8b2020-12-16 16:46:01 -08001061 if !Bool(library.Properties.Llndk.Unversioned) {
Dan Albertf1d14c72020-07-30 14:32:55 -07001062 library.versionScriptPath = android.OptionalPathForPath(
1063 nativeAbiResult.versionScript)
Colin Cross127bb8b2020-12-16 16:46:01 -08001064 }
1065 return objs
1066 }
Colin Cross5271fea2021-04-27 13:06:04 -07001067 if ctx.IsVendorPublicLibrary() {
Dan Albertf1d14c72020-07-30 14:32:55 -07001068 nativeAbiResult := parseNativeAbiDefinition(ctx,
1069 String(library.Properties.Vendor_public_library.Symbol_file),
1070 android.FutureApiLevel, "")
1071 objs := compileStubLibrary(ctx, flags, nativeAbiResult.stubSrc)
Colin Cross5271fea2021-04-27 13:06:04 -07001072 if !Bool(library.Properties.Vendor_public_library.Unversioned) {
Dan Albertf1d14c72020-07-30 14:32:55 -07001073 library.versionScriptPath = android.OptionalPathForPath(nativeAbiResult.versionScript)
Colin Cross5271fea2021-04-27 13:06:04 -07001074 }
1075 return objs
1076 }
Jiyong Park7ed9de32018-10-15 22:25:07 +09001077 if library.buildStubs() {
Jiyong Parka4175572021-02-04 21:05:47 +09001078 symbolFile := String(library.Properties.Stubs.Symbol_file)
1079 if symbolFile != "" && !strings.HasSuffix(symbolFile, ".map.txt") {
1080 ctx.PropertyErrorf("symbol_file", "%q doesn't have .map.txt suffix", symbolFile)
1081 return Objects{}
1082 }
Jiyong Park85cc35a2022-07-17 11:30:47 +09001083 // b/239274367 --apex and --systemapi filters symbols tagged with # apex and #
1084 // systemapi, respectively. The former is for symbols defined in platform libraries
1085 // and the latter is for symbols defined in APEXes.
1086 var flag string
1087 if ctx.Module().(android.ApexModule).NotInPlatform() {
1088 flag = "--apex"
1089 } else {
Jiyong Parkffea9b32022-07-17 17:32:56 +09001090 flag = "--systemapi"
Jiyong Park85cc35a2022-07-17 11:30:47 +09001091 }
Dan Albertf1d14c72020-07-30 14:32:55 -07001092 nativeAbiResult := parseNativeAbiDefinition(ctx, symbolFile,
Jiyong Park85cc35a2022-07-17 11:30:47 +09001093 android.ApiLevelOrPanic(ctx, library.MutatedProperties.StubsVersion), flag)
Dan Albertf1d14c72020-07-30 14:32:55 -07001094 objs := compileStubLibrary(ctx, flags, nativeAbiResult.stubSrc)
1095 library.versionScriptPath = android.OptionalPathForPath(
1096 nativeAbiResult.versionScript)
sophiez4c4f8032021-08-16 22:54:00 -07001097
1098 // Parse symbol file to get API list for coverage
Colin Crossceaa5322021-09-28 16:37:50 -07001099 if library.stubsVersion() == "current" && ctx.PrimaryArch() && !ctx.inRecovery() && !ctx.inProduct() && !ctx.inVendor() {
sophiez4c4f8032021-08-16 22:54:00 -07001100 library.apiListCoverageXmlPath = parseSymbolFileForAPICoverage(ctx, symbolFile)
1101 }
1102
Jiyong Park7ed9de32018-10-15 22:25:07 +09001103 return objs
1104 }
1105
Colin Cross5950f382016-12-13 12:50:57 -08001106 if !library.buildShared() && !library.buildStatic() {
1107 if len(library.baseCompiler.Properties.Srcs) > 0 {
1108 ctx.PropertyErrorf("srcs", "cc_library_headers must not have any srcs")
1109 }
Colin Crosse1bb5d02019-09-24 14:55:04 -07001110 if len(library.StaticProperties.Static.Srcs) > 0 {
Colin Cross5950f382016-12-13 12:50:57 -08001111 ctx.PropertyErrorf("static.srcs", "cc_library_headers must not have any srcs")
1112 }
Colin Crosse1bb5d02019-09-24 14:55:04 -07001113 if len(library.SharedProperties.Shared.Srcs) > 0 {
Colin Cross5950f382016-12-13 12:50:57 -08001114 ctx.PropertyErrorf("shared.srcs", "cc_library_headers must not have any srcs")
1115 }
1116 return Objects{}
1117 }
Yo Chiang2bbadfa2020-12-14 11:42:16 +08001118 if library.sabi.shouldCreateSourceAbiDump() {
Jayant Chowdharya4fce192017-09-06 13:10:03 -07001119 exportIncludeDirs := library.flagExporter.exportedIncludes(ctx)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001120 var SourceAbiFlags []string
1121 for _, dir := range exportIncludeDirs.Strings() {
Jayant Chowdhary715cac32017-04-20 06:53:59 -07001122 SourceAbiFlags = append(SourceAbiFlags, "-I"+dir)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001123 }
Inseob Kim69378442019-06-03 19:10:47 +09001124 for _, reexportedInclude := range library.sabi.Properties.ReexportedIncludes {
1125 SourceAbiFlags = append(SourceAbiFlags, "-I"+reexportedInclude)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07001126 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001127 flags.SAbiFlags = SourceAbiFlags
Jaewoong Jung18aefc12020-12-21 09:11:10 -08001128 totalLength := len(library.baseCompiler.Properties.Srcs) + len(deps.GeneratedSources) +
Colin Crosse1bb5d02019-09-24 14:55:04 -07001129 len(library.SharedProperties.Shared.Srcs) + len(library.StaticProperties.Static.Srcs)
Jaewoong Jung18aefc12020-12-21 09:11:10 -08001130 if totalLength > 0 {
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001131 flags.SAbiDump = true
1132 }
1133 }
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001134 objs := library.baseCompiler.compile(ctx, flags, deps)
1135 library.reuseObjects = objs
Colin Cross2f336352016-10-26 10:03:47 -07001136 buildFlags := flagsToBuilderFlags(flags)
Colin Crossb916a382016-07-29 17:28:03 -07001137
Colin Cross4d9c2d12016-07-29 12:48:20 -07001138 if library.static() {
Colin Crosse1bb5d02019-09-24 14:55:04 -07001139 srcs := android.PathsForModuleSrc(ctx, library.StaticProperties.Static.Srcs)
Chih-Hung Hsieh769a51c2021-09-17 17:18:39 -07001140 objs = objs.Append(compileObjs(ctx, buildFlags, android.DeviceStaticLibrary, srcs,
1141 android.PathsForModuleSrc(ctx, library.StaticProperties.Static.Tidy_disabled_srcs),
Chih-Hung Hsieh9db8a0c2022-02-17 12:54:45 -08001142 android.PathsForModuleSrc(ctx, library.StaticProperties.Static.Tidy_timeout_srcs),
Chih-Hung Hsieh769a51c2021-09-17 17:18:39 -07001143 library.baseCompiler.pathDeps, library.baseCompiler.cFlagsDeps))
Colin Crossa48ab5b2017-02-14 15:28:44 -08001144 } else if library.shared() {
Colin Crosse1bb5d02019-09-24 14:55:04 -07001145 srcs := android.PathsForModuleSrc(ctx, library.SharedProperties.Shared.Srcs)
Chih-Hung Hsieh769a51c2021-09-17 17:18:39 -07001146 objs = objs.Append(compileObjs(ctx, buildFlags, android.DeviceSharedLibrary, srcs,
1147 android.PathsForModuleSrc(ctx, library.SharedProperties.Shared.Tidy_disabled_srcs),
Chih-Hung Hsieh9db8a0c2022-02-17 12:54:45 -08001148 android.PathsForModuleSrc(ctx, library.SharedProperties.Shared.Tidy_timeout_srcs),
Chih-Hung Hsieh769a51c2021-09-17 17:18:39 -07001149 library.baseCompiler.pathDeps, library.baseCompiler.cFlagsDeps))
Colin Crossb916a382016-07-29 17:28:03 -07001150 }
1151
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001152 return objs
Colin Crossb916a382016-07-29 17:28:03 -07001153}
1154
1155type libraryInterface interface {
Colin Cross3572cf72020-10-01 15:58:11 -07001156 versionedInterface
1157
Colin Crossb916a382016-07-29 17:28:03 -07001158 static() bool
Inseob Kimae553032019-05-14 18:52:49 +09001159 shared() bool
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001160 objs() Objects
Colin Cross0de8a1e2020-09-18 14:15:30 -07001161 reuseObjs() Objects
Colin Cross26c34ed2016-09-30 17:10:16 -07001162 toc() android.OptionalPath
Colin Crossb916a382016-07-29 17:28:03 -07001163
1164 // Returns true if the build options for the module have selected a static or shared build
1165 buildStatic() bool
1166 buildShared() bool
1167
1168 // Sets whether a specific variant is static or shared
Colin Crossa48ab5b2017-02-14 15:28:44 -08001169 setStatic()
1170 setShared()
Logan Chien41eabe62019-04-10 13:33:58 +08001171
Yo Chiang2bbadfa2020-12-14 11:42:16 +08001172 // Check whether header_abi_checker is enabled or explicitly disabled.
1173 headerAbiCheckerEnabled() bool
1174 headerAbiCheckerExplicitlyDisabled() bool
1175
Logan Chien41eabe62019-04-10 13:33:58 +08001176 // Write LOCAL_ADDITIONAL_DEPENDENCIES for ABI diff
1177 androidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer)
Jiyong Parka90ca002019-10-07 15:47:24 +09001178
1179 availableFor(string) bool
Colin Crossceaa5322021-09-28 16:37:50 -07001180
1181 getAPIListCoverageXMLPath() android.ModuleOutPath
Colin Cross1bc94122021-10-28 13:25:54 -07001182
1183 installable() *bool
Colin Crossb916a382016-07-29 17:28:03 -07001184}
1185
Colin Crossc88c2722020-09-28 17:32:47 -07001186type versionedInterface interface {
1187 buildStubs() bool
Jiyong Parkd4a3a132021-03-17 20:21:35 +09001188 setBuildStubs(isLatest bool)
Colin Crossc88c2722020-09-28 17:32:47 -07001189 hasStubsVariants() bool
1190 setStubsVersion(string)
1191 stubsVersion() string
1192
Colin Cross3572cf72020-10-01 15:58:11 -07001193 stubsVersions(ctx android.BaseMutatorContext) []string
Colin Crossc88c2722020-09-28 17:32:47 -07001194 setAllStubsVersions([]string)
1195 allStubsVersions() []string
Colin Cross0477b422020-10-13 18:43:54 -07001196
1197 implementationModuleName(name string) string
Colin Cross127bb8b2020-12-16 16:46:01 -08001198 hasLLNDKStubs() bool
Colin Cross1f3f1302021-04-26 18:37:44 -07001199 hasLLNDKHeaders() bool
Colin Cross5271fea2021-04-27 13:06:04 -07001200 hasVendorPublicLibrary() bool
Colin Crossc88c2722020-09-28 17:32:47 -07001201}
1202
1203var _ libraryInterface = (*libraryDecorator)(nil)
1204var _ versionedInterface = (*libraryDecorator)(nil)
1205
Justin Yun6977e8a2020-10-29 18:24:11 +09001206func (library *libraryDecorator) getLibNameHelper(baseModuleName string, inVendor bool, inProduct bool) string {
Colin Crossb916a382016-07-29 17:28:03 -07001207 name := library.libName
1208 if name == "" {
dimitryd95964a2018-11-07 13:43:34 +01001209 name = String(library.Properties.Stem)
1210 if name == "" {
Jooyung Han0302a842019-10-30 18:43:49 +09001211 name = baseModuleName
dimitryd95964a2018-11-07 13:43:34 +01001212 }
Colin Crossb916a382016-07-29 17:28:03 -07001213 }
1214
Colin Cross0fd6a412019-08-16 14:22:10 -07001215 suffix := ""
Justin Yun6977e8a2020-10-29 18:24:11 +09001216 if inVendor {
Colin Cross0fd6a412019-08-16 14:22:10 -07001217 suffix = String(library.Properties.Target.Vendor.Suffix)
Justin Yun6977e8a2020-10-29 18:24:11 +09001218 } else if inProduct {
1219 suffix = String(library.Properties.Target.Product.Suffix)
Colin Cross0fd6a412019-08-16 14:22:10 -07001220 }
1221 if suffix == "" {
1222 suffix = String(library.Properties.Suffix)
1223 }
1224
Jooyung Han0302a842019-10-30 18:43:49 +09001225 return name + suffix
1226}
1227
Chris Parsons3c27ca32020-11-20 12:42:07 -05001228// getLibName returns the actual canonical name of the library (the name which
1229// should be passed to the linker via linker flags).
Jooyung Han0302a842019-10-30 18:43:49 +09001230func (library *libraryDecorator) getLibName(ctx BaseModuleContext) string {
Justin Yun6977e8a2020-10-29 18:24:11 +09001231 name := library.getLibNameHelper(ctx.baseModuleName(), ctx.inVendor(), ctx.inProduct())
Colin Cross0fd6a412019-08-16 14:22:10 -07001232
Ivan Lozanof9e21722020-12-02 09:00:51 -05001233 if ctx.IsVndkExt() {
Jooyung Han4c2b9422019-10-22 19:53:47 +09001234 // vndk-ext lib should have the same name with original lib
1235 ctx.VisitDirectDepsWithTag(vndkExtDepTag, func(module android.Module) {
1236 originalName := module.(*Module).outputFile.Path()
1237 name = strings.TrimSuffix(originalName.Base(), originalName.Ext())
1238 })
Logan Chienf3511742017-10-31 18:04:35 +08001239 }
1240
Colin Crossb916a382016-07-29 17:28:03 -07001241 if ctx.Host() && Bool(library.Properties.Unique_host_soname) {
1242 if !strings.HasSuffix(name, "-host") {
1243 name = name + "-host"
1244 }
1245 }
1246
Inseob Kim0ce291e2019-07-04 14:38:27 +09001247 return name
Colin Crossb916a382016-07-29 17:28:03 -07001248}
1249
Jiyong Parkda732bd2018-11-02 18:23:15 +09001250var versioningMacroNamesListMutex sync.Mutex
1251
Colin Crossb916a382016-07-29 17:28:03 -07001252func (library *libraryDecorator) linkerInit(ctx BaseModuleContext) {
1253 location := InstallInSystem
Dan Albert61f32122018-07-26 14:00:24 -07001254 if library.baseLinker.sanitize.inSanitizerDir() {
Vishwath Mohan1dd88392017-03-29 22:00:18 -07001255 location = InstallInSanitizerDir
Colin Crossb916a382016-07-29 17:28:03 -07001256 }
1257 library.baseInstaller.location = location
Colin Crossb916a382016-07-29 17:28:03 -07001258 library.baseLinker.linkerInit(ctx)
Jiyong Park7ed9de32018-10-15 22:25:07 +09001259 // Let baseLinker know whether this variant is for stubs or not, so that
1260 // it can omit things that are not required for linking stubs.
1261 library.baseLinker.dynamicProperties.BuildStubs = library.buildStubs()
Jiyong Parkda732bd2018-11-02 18:23:15 +09001262
1263 if library.buildStubs() {
1264 macroNames := versioningMacroNamesList(ctx.Config())
1265 myName := versioningMacroName(ctx.ModuleName())
1266 versioningMacroNamesListMutex.Lock()
1267 defer versioningMacroNamesListMutex.Unlock()
1268 if (*macroNames)[myName] == "" {
1269 (*macroNames)[myName] = ctx.ModuleName()
1270 } else if (*macroNames)[myName] != ctx.ModuleName() {
1271 ctx.ModuleErrorf("Macro name %q for versioning conflicts with macro name from module %q ", myName, (*macroNames)[myName])
1272 }
1273 }
Colin Crossb916a382016-07-29 17:28:03 -07001274}
1275
dimitry0345ad82018-12-05 16:28:14 +01001276func (library *libraryDecorator) compilerDeps(ctx DepsContext, deps Deps) Deps {
Colin Cross127bb8b2020-12-16 16:46:01 -08001277 if ctx.IsLlndk() {
1278 // LLNDK libraries ignore most of the properties on the cc_library and use the
1279 // LLNDK-specific properties instead.
1280 return deps
1281 }
1282
dimitry0345ad82018-12-05 16:28:14 +01001283 deps = library.baseCompiler.compilerDeps(ctx, deps)
1284
dimitry0345ad82018-12-05 16:28:14 +01001285 return deps
1286}
1287
Colin Cross37047f12016-12-13 17:06:13 -08001288func (library *libraryDecorator) linkerDeps(ctx DepsContext, deps Deps) Deps {
Colin Cross127bb8b2020-12-16 16:46:01 -08001289 if ctx.IsLlndk() {
1290 // LLNDK libraries ignore most of the properties on the cc_library and use the
1291 // LLNDK-specific properties instead.
Colin Cross0fb7fcd2021-03-02 11:00:07 -08001292 deps.HeaderLibs = append([]string(nil), library.Properties.Llndk.Export_llndk_headers...)
1293 deps.ReexportHeaderLibHeaders = append([]string(nil), library.Properties.Llndk.Export_llndk_headers...)
Colin Cross127bb8b2020-12-16 16:46:01 -08001294 return deps
1295 }
Colin Cross5271fea2021-04-27 13:06:04 -07001296 if ctx.IsVendorPublicLibrary() {
1297 headers := library.Properties.Vendor_public_library.Export_public_headers
1298 deps.HeaderLibs = append([]string(nil), headers...)
1299 deps.ReexportHeaderLibHeaders = append([]string(nil), headers...)
1300 return deps
1301 }
Colin Cross127bb8b2020-12-16 16:46:01 -08001302
Dan Willemsen3a26eef2018-12-03 15:25:46 -08001303 if library.static() {
Martin Stjernholm10566a02020-03-24 01:19:52 +00001304 // Compare with nil because an empty list needs to be propagated.
Colin Crosse1bb5d02019-09-24 14:55:04 -07001305 if library.StaticProperties.Static.System_shared_libs != nil {
1306 library.baseLinker.Properties.System_shared_libs = library.StaticProperties.Static.System_shared_libs
Dan Willemsen3a26eef2018-12-03 15:25:46 -08001307 }
1308 } else if library.shared() {
Martin Stjernholm10566a02020-03-24 01:19:52 +00001309 // Compare with nil because an empty list needs to be propagated.
Colin Crosse1bb5d02019-09-24 14:55:04 -07001310 if library.SharedProperties.Shared.System_shared_libs != nil {
1311 library.baseLinker.Properties.System_shared_libs = library.SharedProperties.Shared.System_shared_libs
Dan Willemsen3a26eef2018-12-03 15:25:46 -08001312 }
1313 }
1314
Colin Crossb916a382016-07-29 17:28:03 -07001315 deps = library.baseLinker.linkerDeps(ctx, deps)
1316
1317 if library.static() {
1318 deps.WholeStaticLibs = append(deps.WholeStaticLibs,
Colin Crosse1bb5d02019-09-24 14:55:04 -07001319 library.StaticProperties.Static.Whole_static_libs...)
1320 deps.StaticLibs = append(deps.StaticLibs, library.StaticProperties.Static.Static_libs...)
1321 deps.SharedLibs = append(deps.SharedLibs, library.StaticProperties.Static.Shared_libs...)
Colin Crosseefe9a32019-01-22 14:41:08 -08001322
Colin Crosse1bb5d02019-09-24 14:55:04 -07001323 deps.ReexportSharedLibHeaders = append(deps.ReexportSharedLibHeaders, library.StaticProperties.Static.Export_shared_lib_headers...)
1324 deps.ReexportStaticLibHeaders = append(deps.ReexportStaticLibHeaders, library.StaticProperties.Static.Export_static_lib_headers...)
Colin Crossa48ab5b2017-02-14 15:28:44 -08001325 } else if library.shared() {
Colin Crossd1a28132021-06-21 17:34:47 -07001326 if !Bool(library.baseLinker.Properties.Nocrt) {
1327 deps.CrtBegin = append(deps.CrtBegin, ctx.toolchain().CrtBeginSharedLibrary()...)
1328 deps.CrtEnd = append(deps.CrtEnd, ctx.toolchain().CrtEndSharedLibrary()...)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001329 }
Colin Crosse1bb5d02019-09-24 14:55:04 -07001330 deps.WholeStaticLibs = append(deps.WholeStaticLibs, library.SharedProperties.Shared.Whole_static_libs...)
1331 deps.StaticLibs = append(deps.StaticLibs, library.SharedProperties.Shared.Static_libs...)
1332 deps.SharedLibs = append(deps.SharedLibs, library.SharedProperties.Shared.Shared_libs...)
Colin Crosseefe9a32019-01-22 14:41:08 -08001333
Colin Crosse1bb5d02019-09-24 14:55:04 -07001334 deps.ReexportSharedLibHeaders = append(deps.ReexportSharedLibHeaders, library.SharedProperties.Shared.Export_shared_lib_headers...)
1335 deps.ReexportStaticLibHeaders = append(deps.ReexportStaticLibHeaders, library.SharedProperties.Shared.Export_static_lib_headers...)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001336 }
Justin Yun6977e8a2020-10-29 18:24:11 +09001337 if ctx.inVendor() {
Jiyong Park52d25bd2017-10-13 09:17:01 +09001338 deps.WholeStaticLibs = removeListFromList(deps.WholeStaticLibs, library.baseLinker.Properties.Target.Vendor.Exclude_static_libs)
1339 deps.SharedLibs = removeListFromList(deps.SharedLibs, library.baseLinker.Properties.Target.Vendor.Exclude_shared_libs)
1340 deps.StaticLibs = removeListFromList(deps.StaticLibs, library.baseLinker.Properties.Target.Vendor.Exclude_static_libs)
Victor Chang51271c12019-01-30 16:02:22 +00001341 deps.ReexportSharedLibHeaders = removeListFromList(deps.ReexportSharedLibHeaders, library.baseLinker.Properties.Target.Vendor.Exclude_shared_libs)
1342 deps.ReexportStaticLibHeaders = removeListFromList(deps.ReexportStaticLibHeaders, library.baseLinker.Properties.Target.Vendor.Exclude_static_libs)
Jiyong Park52d25bd2017-10-13 09:17:01 +09001343 }
Justin Yun6977e8a2020-10-29 18:24:11 +09001344 if ctx.inProduct() {
1345 deps.WholeStaticLibs = removeListFromList(deps.WholeStaticLibs, library.baseLinker.Properties.Target.Product.Exclude_static_libs)
1346 deps.SharedLibs = removeListFromList(deps.SharedLibs, library.baseLinker.Properties.Target.Product.Exclude_shared_libs)
1347 deps.StaticLibs = removeListFromList(deps.StaticLibs, library.baseLinker.Properties.Target.Product.Exclude_static_libs)
1348 deps.ReexportSharedLibHeaders = removeListFromList(deps.ReexportSharedLibHeaders, library.baseLinker.Properties.Target.Product.Exclude_shared_libs)
1349 deps.ReexportStaticLibHeaders = removeListFromList(deps.ReexportStaticLibHeaders, library.baseLinker.Properties.Target.Product.Exclude_static_libs)
1350 }
Jiyong Parkf9332f12018-02-01 00:54:12 +09001351 if ctx.inRecovery() {
1352 deps.WholeStaticLibs = removeListFromList(deps.WholeStaticLibs, library.baseLinker.Properties.Target.Recovery.Exclude_static_libs)
1353 deps.SharedLibs = removeListFromList(deps.SharedLibs, library.baseLinker.Properties.Target.Recovery.Exclude_shared_libs)
1354 deps.StaticLibs = removeListFromList(deps.StaticLibs, library.baseLinker.Properties.Target.Recovery.Exclude_static_libs)
Victor Chang51271c12019-01-30 16:02:22 +00001355 deps.ReexportSharedLibHeaders = removeListFromList(deps.ReexportSharedLibHeaders, library.baseLinker.Properties.Target.Recovery.Exclude_shared_libs)
1356 deps.ReexportStaticLibHeaders = removeListFromList(deps.ReexportStaticLibHeaders, library.baseLinker.Properties.Target.Recovery.Exclude_static_libs)
Jiyong Parkf9332f12018-02-01 00:54:12 +09001357 }
Yifan Hongcf4832c2020-01-21 17:04:13 -08001358 if ctx.inRamdisk() {
1359 deps.WholeStaticLibs = removeListFromList(deps.WholeStaticLibs, library.baseLinker.Properties.Target.Ramdisk.Exclude_static_libs)
1360 deps.SharedLibs = removeListFromList(deps.SharedLibs, library.baseLinker.Properties.Target.Ramdisk.Exclude_shared_libs)
1361 deps.StaticLibs = removeListFromList(deps.StaticLibs, library.baseLinker.Properties.Target.Ramdisk.Exclude_static_libs)
1362 deps.ReexportSharedLibHeaders = removeListFromList(deps.ReexportSharedLibHeaders, library.baseLinker.Properties.Target.Ramdisk.Exclude_shared_libs)
1363 deps.ReexportStaticLibHeaders = removeListFromList(deps.ReexportStaticLibHeaders, library.baseLinker.Properties.Target.Ramdisk.Exclude_static_libs)
1364 }
Yifan Hong6da33c22020-10-27 15:01:21 -07001365 if ctx.inVendorRamdisk() {
1366 deps.WholeStaticLibs = removeListFromList(deps.WholeStaticLibs, library.baseLinker.Properties.Target.Vendor_ramdisk.Exclude_static_libs)
1367 deps.SharedLibs = removeListFromList(deps.SharedLibs, library.baseLinker.Properties.Target.Vendor_ramdisk.Exclude_shared_libs)
1368 deps.StaticLibs = removeListFromList(deps.StaticLibs, library.baseLinker.Properties.Target.Vendor_ramdisk.Exclude_static_libs)
1369 deps.ReexportSharedLibHeaders = removeListFromList(deps.ReexportSharedLibHeaders, library.baseLinker.Properties.Target.Vendor_ramdisk.Exclude_shared_libs)
1370 deps.ReexportStaticLibHeaders = removeListFromList(deps.ReexportStaticLibHeaders, library.baseLinker.Properties.Target.Vendor_ramdisk.Exclude_static_libs)
1371 }
Colin Cross2383f3b2018-02-06 14:40:13 -08001372
Colin Cross4d9c2d12016-07-29 12:48:20 -07001373 return deps
1374}
1375
Paul Duffin13f02712020-03-06 12:30:43 +00001376func (library *libraryDecorator) linkerSpecifiedDeps(specifiedDeps specifiedDeps) specifiedDeps {
1377 specifiedDeps = library.baseLinker.linkerSpecifiedDeps(specifiedDeps)
1378 var properties StaticOrSharedProperties
1379 if library.static() {
1380 properties = library.StaticProperties.Static
1381 } else if library.shared() {
1382 properties = library.SharedProperties.Shared
1383 }
1384
1385 specifiedDeps.sharedLibs = append(specifiedDeps.sharedLibs, properties.Shared_libs...)
Martin Stjernholm10566a02020-03-24 01:19:52 +00001386
1387 // Must distinguish nil and [] in system_shared_libs - ensure that [] in
1388 // either input list doesn't come out as nil.
1389 if specifiedDeps.systemSharedLibs == nil {
1390 specifiedDeps.systemSharedLibs = properties.System_shared_libs
1391 } else {
1392 specifiedDeps.systemSharedLibs = append(specifiedDeps.systemSharedLibs, properties.System_shared_libs...)
1393 }
Paul Duffin13f02712020-03-06 12:30:43 +00001394
1395 specifiedDeps.sharedLibs = android.FirstUniqueStrings(specifiedDeps.sharedLibs)
Martin Stjernholm10566a02020-03-24 01:19:52 +00001396 if len(specifiedDeps.systemSharedLibs) > 0 {
1397 // Skip this if systemSharedLibs is either nil or [], to ensure they are
1398 // retained.
1399 specifiedDeps.systemSharedLibs = android.FirstUniqueStrings(specifiedDeps.systemSharedLibs)
1400 }
Paul Duffin13f02712020-03-06 12:30:43 +00001401 return specifiedDeps
1402}
1403
Colin Crossb916a382016-07-29 17:28:03 -07001404func (library *libraryDecorator) linkStatic(ctx ModuleContext,
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001405 flags Flags, deps PathDeps, objs Objects) android.Path {
Colin Cross4d9c2d12016-07-29 12:48:20 -07001406
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001407 library.objects = deps.WholeStaticLibObjs.Copy()
1408 library.objects = library.objects.Append(objs)
Colin Crossa2bcf2c2022-02-11 13:11:55 -08001409 library.wholeStaticLibsFromPrebuilts = android.CopyOfPaths(deps.WholeStaticLibsFromPrebuilts)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001410
Inseob Kim0ce291e2019-07-04 14:38:27 +09001411 fileName := ctx.ModuleName() + staticLibraryExtension
Colin Cross86803cf2018-02-15 14:12:26 -08001412 outputFile := android.PathForModuleOut(ctx, fileName)
Dan Willemsen581341d2017-02-09 16:16:31 -08001413 builderFlags := flagsToBuilderFlags(flags)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001414
Dan Willemsen569edc52018-11-19 09:33:29 -08001415 if Bool(library.baseLinker.Properties.Use_version_lib) {
1416 if ctx.Host() {
1417 versionedOutputFile := outputFile
1418 outputFile = android.PathForModuleOut(ctx, "unversioned", fileName)
1419 library.injectVersionSymbol(ctx, outputFile, versionedOutputFile)
1420 } else {
1421 versionedOutputFile := android.PathForModuleOut(ctx, "versioned", fileName)
Jingwen Chen40fd90a2020-06-15 05:24:19 +00001422 library.distFile = versionedOutputFile
Dan Willemsen569edc52018-11-19 09:33:29 -08001423 library.injectVersionSymbol(ctx, outputFile, versionedOutputFile)
1424 }
Colin Cross86803cf2018-02-15 14:12:26 -08001425 }
1426
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -08001427 transformObjToStaticLib(ctx, library.objects.objFiles, deps.WholeStaticLibsFromPrebuilts, builderFlags, outputFile, nil, objs.tidyDepFiles)
Dan Willemsen581341d2017-02-09 16:16:31 -08001428
Chris Parsonsbf4f55f2020-11-23 17:02:44 -05001429 library.coverageOutputFile = transformCoverageFilesToZip(ctx, library.objects, ctx.ModuleName())
Colin Cross4d9c2d12016-07-29 12:48:20 -07001430
Colin Cross4d9c2d12016-07-29 12:48:20 -07001431 ctx.CheckbuildFile(outputFile)
1432
Colin Cross649d8172020-12-10 12:30:21 -08001433 if library.static() {
1434 ctx.SetProvider(StaticLibraryInfoProvider, StaticLibraryInfo{
Colin Crossa2bcf2c2022-02-11 13:11:55 -08001435 StaticLibrary: outputFile,
1436 ReuseObjects: library.reuseObjects,
1437 Objects: library.objects,
1438 WholeStaticLibsFromPrebuilts: library.wholeStaticLibsFromPrebuilts,
Colin Cross0de8a1e2020-09-18 14:15:30 -07001439
Colin Cross649d8172020-12-10 12:30:21 -08001440 TransitiveStaticLibrariesForOrdering: android.NewDepSetBuilder(android.TOPOLOGICAL).
1441 Direct(outputFile).
1442 Transitive(deps.TranstiveStaticLibrariesForOrdering).
1443 Build(),
1444 })
1445 }
1446
1447 if library.header() {
1448 ctx.SetProvider(HeaderLibraryInfoProvider, HeaderLibraryInfo{})
1449 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07001450
Colin Cross4d9c2d12016-07-29 12:48:20 -07001451 return outputFile
1452}
1453
Chih-Hung Hsiehf6ca1b92021-12-05 18:02:50 -08001454func ndkSharedLibDeps(ctx ModuleContext) android.Paths {
1455 if ctx.Module().(*Module).IsSdkVariant() {
1456 // The NDK sysroot timestamp file depends on all the NDK
1457 // sysroot header and shared library files.
1458 return android.Paths{getNdkBaseTimestampFile(ctx)}
1459 }
1460 return nil
1461}
1462
Colin Crossb916a382016-07-29 17:28:03 -07001463func (library *libraryDecorator) linkShared(ctx ModuleContext,
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001464 flags Flags, deps PathDeps, objs Objects) android.Path {
Colin Cross4d9c2d12016-07-29 12:48:20 -07001465
1466 var linkerDeps android.Paths
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001467 linkerDeps = append(linkerDeps, flags.LdFlagsDeps...)
Chih-Hung Hsiehf6ca1b92021-12-05 18:02:50 -08001468 linkerDeps = append(linkerDeps, ndkSharedLibDeps(ctx)...)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001469
Colin Cross2383f3b2018-02-06 14:40:13 -08001470 unexportedSymbols := ctx.ExpandOptionalSource(library.Properties.Unexported_symbols_list, "unexported_symbols_list")
1471 forceNotWeakSymbols := ctx.ExpandOptionalSource(library.Properties.Force_symbols_not_weak_list, "force_symbols_not_weak_list")
1472 forceWeakSymbols := ctx.ExpandOptionalSource(library.Properties.Force_symbols_weak_list, "force_symbols_weak_list")
Colin Cross4d9c2d12016-07-29 12:48:20 -07001473 if !ctx.Darwin() {
Colin Cross4d9c2d12016-07-29 12:48:20 -07001474 if unexportedSymbols.Valid() {
1475 ctx.PropertyErrorf("unexported_symbols_list", "Only supported on Darwin")
1476 }
1477 if forceNotWeakSymbols.Valid() {
1478 ctx.PropertyErrorf("force_symbols_not_weak_list", "Only supported on Darwin")
1479 }
1480 if forceWeakSymbols.Valid() {
1481 ctx.PropertyErrorf("force_symbols_weak_list", "Only supported on Darwin")
1482 }
1483 } else {
Colin Cross4d9c2d12016-07-29 12:48:20 -07001484 if unexportedSymbols.Valid() {
Colin Cross4af21ed2019-11-04 09:37:55 -08001485 flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,-unexported_symbols_list,"+unexportedSymbols.String())
Colin Cross4d9c2d12016-07-29 12:48:20 -07001486 linkerDeps = append(linkerDeps, unexportedSymbols.Path())
1487 }
1488 if forceNotWeakSymbols.Valid() {
Colin Cross4af21ed2019-11-04 09:37:55 -08001489 flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,-force_symbols_not_weak_list,"+forceNotWeakSymbols.String())
Colin Cross4d9c2d12016-07-29 12:48:20 -07001490 linkerDeps = append(linkerDeps, forceNotWeakSymbols.Path())
1491 }
1492 if forceWeakSymbols.Valid() {
Colin Cross4af21ed2019-11-04 09:37:55 -08001493 flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,-force_symbols_weak_list,"+forceWeakSymbols.String())
Colin Cross4d9c2d12016-07-29 12:48:20 -07001494 linkerDeps = append(linkerDeps, forceWeakSymbols.Path())
1495 }
1496 }
Colin Cross8e21aa52020-09-28 18:28:02 -07001497 if library.versionScriptPath.Valid() {
Jiyong Parkc1e7f482019-01-12 13:39:10 +09001498 linkerScriptFlags := "-Wl,--version-script," + library.versionScriptPath.String()
Colin Cross4af21ed2019-11-04 09:37:55 -08001499 flags.Local.LdFlags = append(flags.Local.LdFlags, linkerScriptFlags)
Colin Cross8e21aa52020-09-28 18:28:02 -07001500 linkerDeps = append(linkerDeps, library.versionScriptPath.Path())
Jiyong Parkc1e7f482019-01-12 13:39:10 +09001501 }
Colin Cross4d9c2d12016-07-29 12:48:20 -07001502
1503 fileName := library.getLibName(ctx) + flags.Toolchain.ShlibSuffix()
1504 outputFile := android.PathForModuleOut(ctx, fileName)
Colin Cross0de8a1e2020-09-18 14:15:30 -07001505 unstrippedOutputFile := outputFile
Colin Cross4d9c2d12016-07-29 12:48:20 -07001506
Josh Gao75a50a22019-06-07 17:58:59 -07001507 var implicitOutputs android.WritablePaths
1508 if ctx.Windows() {
1509 importLibraryPath := android.PathForModuleOut(ctx, pathtools.ReplaceExtension(fileName, "lib"))
1510
Colin Cross4af21ed2019-11-04 09:37:55 -08001511 flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,--out-implib="+importLibraryPath.String())
Josh Gao75a50a22019-06-07 17:58:59 -07001512 implicitOutputs = append(implicitOutputs, importLibraryPath)
1513 }
1514
Colin Cross4d9c2d12016-07-29 12:48:20 -07001515 builderFlags := flagsToBuilderFlags(flags)
1516
Dan Willemsen47450072021-10-19 20:24:49 -07001517 if ctx.Darwin() && deps.DarwinSecondArchOutput.Valid() {
1518 fatOutputFile := outputFile
1519 outputFile = android.PathForModuleOut(ctx, "pre-fat", fileName)
1520 transformDarwinUniversalBinary(ctx, fatOutputFile, outputFile, deps.DarwinSecondArchOutput.Path())
1521 }
1522
Colin Crossb496cfd2018-09-10 16:50:05 -07001523 // Optimize out relinking against shared libraries whose interface hasn't changed by
1524 // depending on a table of contents file instead of the library itself.
Colin Cross70dda7e2019-10-01 22:05:35 -07001525 tocFile := outputFile.ReplaceExtension(ctx, flags.Toolchain.ShlibSuffix()[1:]+".toc")
Colin Crossb496cfd2018-09-10 16:50:05 -07001526 library.tocFile = android.OptionalPathForPath(tocFile)
Ivan Lozano7b0781d2021-11-03 15:30:18 -04001527 TransformSharedObjectToToc(ctx, outputFile, tocFile)
Colin Cross89562dc2016-10-03 17:47:19 -07001528
Thiébaud Weksteend4587452020-08-19 14:53:01 +02001529 stripFlags := flagsToStripFlags(flags)
Colin Crossadc81a02020-12-14 17:01:55 -08001530 needsStrip := library.stripper.NeedsStrip(ctx)
1531 if library.buildStubs() {
1532 // No need to strip stubs libraries
1533 needsStrip = false
1534 }
1535 if needsStrip {
Yi Kongb5c34d72018-11-07 16:28:49 -08001536 if ctx.Darwin() {
Thiébaud Weksteend4587452020-08-19 14:53:01 +02001537 stripFlags.StripUseGnuStrip = true
Yi Kongb5c34d72018-11-07 16:28:49 -08001538 }
Colin Cross4d9c2d12016-07-29 12:48:20 -07001539 strippedOutputFile := outputFile
1540 outputFile = android.PathForModuleOut(ctx, "unstripped", fileName)
Thiébaud Weksteend4587452020-08-19 14:53:01 +02001541 library.stripper.StripExecutableOrSharedLib(ctx, outputFile, strippedOutputFile, stripFlags)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001542 }
Colin Crossb60190a2018-09-04 16:28:17 -07001543 library.unstrippedOutputFile = outputFile
1544
Colin Crossd7227f92019-09-05 14:26:33 -07001545 outputFile = maybeInjectBoringSSLHash(ctx, outputFile, library.Properties.Inject_bssl_hash, fileName)
Pete Bentley803e1612019-08-06 22:19:59 +01001546
Dan Willemsen569edc52018-11-19 09:33:29 -08001547 if Bool(library.baseLinker.Properties.Use_version_lib) {
1548 if ctx.Host() {
1549 versionedOutputFile := outputFile
1550 outputFile = android.PathForModuleOut(ctx, "unversioned", fileName)
1551 library.injectVersionSymbol(ctx, outputFile, versionedOutputFile)
1552 } else {
1553 versionedOutputFile := android.PathForModuleOut(ctx, "versioned", fileName)
Jingwen Chen40fd90a2020-06-15 05:24:19 +00001554 library.distFile = versionedOutputFile
Dan Willemsen569edc52018-11-19 09:33:29 -08001555
Thiébaud Weksteend4587452020-08-19 14:53:01 +02001556 if library.stripper.NeedsStrip(ctx) {
Dan Willemsen569edc52018-11-19 09:33:29 -08001557 out := android.PathForModuleOut(ctx, "versioned-stripped", fileName)
Jingwen Chen40fd90a2020-06-15 05:24:19 +00001558 library.distFile = out
Thiébaud Weksteend4587452020-08-19 14:53:01 +02001559 library.stripper.StripExecutableOrSharedLib(ctx, versionedOutputFile, out, stripFlags)
Dan Willemsen569edc52018-11-19 09:33:29 -08001560 }
1561
1562 library.injectVersionSymbol(ctx, outputFile, versionedOutputFile)
1563 }
Colin Cross86803cf2018-02-15 14:12:26 -08001564 }
1565
Jiyong Park64a44f22019-01-18 14:37:08 +09001566 sharedLibs := deps.EarlySharedLibs
1567 sharedLibs = append(sharedLibs, deps.SharedLibs...)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001568 sharedLibs = append(sharedLibs, deps.LateSharedLibs...)
1569
Jiyong Park64a44f22019-01-18 14:37:08 +09001570 linkerDeps = append(linkerDeps, deps.EarlySharedLibsDeps...)
Colin Cross26c34ed2016-09-30 17:10:16 -07001571 linkerDeps = append(linkerDeps, deps.SharedLibsDeps...)
1572 linkerDeps = append(linkerDeps, deps.LateSharedLibsDeps...)
Chris Parsonsbf4f55f2020-11-23 17:02:44 -05001573 transformObjToDynamicBinary(ctx, objs.objFiles, sharedLibs,
Colin Cross4d9c2d12016-07-29 12:48:20 -07001574 deps.StaticLibs, deps.LateStaticLibs, deps.WholeStaticLibs,
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -08001575 linkerDeps, deps.CrtBegin, deps.CrtEnd, false, builderFlags, outputFile, implicitOutputs, objs.tidyDepFiles)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001576
Dan Willemsen581341d2017-02-09 16:16:31 -08001577 objs.coverageFiles = append(objs.coverageFiles, deps.StaticLibObjs.coverageFiles...)
1578 objs.coverageFiles = append(objs.coverageFiles, deps.WholeStaticLibObjs.coverageFiles...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001579
1580 objs.sAbiDumpFiles = append(objs.sAbiDumpFiles, deps.StaticLibObjs.sAbiDumpFiles...)
1581 objs.sAbiDumpFiles = append(objs.sAbiDumpFiles, deps.WholeStaticLibObjs.sAbiDumpFiles...)
1582
Chris Parsonsbf4f55f2020-11-23 17:02:44 -05001583 library.coverageOutputFile = transformCoverageFilesToZip(ctx, objs, library.getLibName(ctx))
Colin Cross0de8a1e2020-09-18 14:15:30 -07001584 library.linkSAbiDumpFiles(ctx, objs, fileName, unstrippedOutputFile)
Dan Willemsen581341d2017-02-09 16:16:31 -08001585
Liz Kammeref6dfea2021-06-08 15:37:09 -04001586 var transitiveStaticLibrariesForOrdering *android.DepSet
Colin Cross0de8a1e2020-09-18 14:15:30 -07001587 if static := ctx.GetDirectDepsWithTag(staticVariantTag); len(static) > 0 {
1588 s := ctx.OtherModuleProvider(static[0], StaticLibraryInfoProvider).(StaticLibraryInfo)
Liz Kammeref6dfea2021-06-08 15:37:09 -04001589 transitiveStaticLibrariesForOrdering = s.TransitiveStaticLibrariesForOrdering
Colin Cross0de8a1e2020-09-18 14:15:30 -07001590 }
1591
1592 ctx.SetProvider(SharedLibraryInfoProvider, SharedLibraryInfo{
Liz Kammeref6dfea2021-06-08 15:37:09 -04001593 TableOfContents: android.OptionalPathForPath(tocFile),
1594 SharedLibrary: unstrippedOutputFile,
1595 TransitiveStaticLibrariesForOrdering: transitiveStaticLibrariesForOrdering,
1596 Target: ctx.Target(),
Colin Cross0de8a1e2020-09-18 14:15:30 -07001597 })
1598
1599 stubs := ctx.GetDirectDepsWithTag(stubImplDepTag)
1600 if len(stubs) > 0 {
Chris Parsons3c27ca32020-11-20 12:42:07 -05001601 var stubsInfo []SharedStubLibrary
Colin Cross0de8a1e2020-09-18 14:15:30 -07001602 for _, stub := range stubs {
1603 stubInfo := ctx.OtherModuleProvider(stub, SharedLibraryInfoProvider).(SharedLibraryInfo)
1604 flagInfo := ctx.OtherModuleProvider(stub, FlagExporterInfoProvider).(FlagExporterInfo)
Chris Parsons3c27ca32020-11-20 12:42:07 -05001605 stubsInfo = append(stubsInfo, SharedStubLibrary{
Colin Cross31076b32020-10-23 17:22:06 -07001606 Version: moduleLibraryInterface(stub).stubsVersion(),
Colin Cross0de8a1e2020-09-18 14:15:30 -07001607 SharedLibraryInfo: stubInfo,
1608 FlagExporterInfo: flagInfo,
1609 })
1610 }
Chris Parsons3c27ca32020-11-20 12:42:07 -05001611 ctx.SetProvider(SharedLibraryStubsProvider, SharedLibraryStubsInfo{
1612 SharedStubLibraries: stubsInfo,
Colin Cross0de8a1e2020-09-18 14:15:30 -07001613
Colin Cross127bb8b2020-12-16 16:46:01 -08001614 IsLLNDK: ctx.IsLlndk(),
Colin Cross0de8a1e2020-09-18 14:15:30 -07001615 })
1616 }
1617
1618 return unstrippedOutputFile
Colin Cross4d9c2d12016-07-29 12:48:20 -07001619}
1620
Jiyong Parkaf6d8952019-01-31 12:21:23 +09001621func (library *libraryDecorator) unstrippedOutputFilePath() android.Path {
1622 return library.unstrippedOutputFile
1623}
1624
Thiébaud Weksteend4587452020-08-19 14:53:01 +02001625func (library *libraryDecorator) disableStripping() {
1626 library.stripper.StripProperties.Strip.None = BoolPtr(true)
1627}
1628
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001629func (library *libraryDecorator) nativeCoverage() bool {
1630 if library.header() || library.buildStubs() {
1631 return false
1632 }
1633 return true
1634}
1635
Jiyong Parkee9a98d2019-08-09 14:44:36 +09001636func (library *libraryDecorator) coverageOutputFilePath() android.OptionalPath {
1637 return library.coverageOutputFile
1638}
1639
Mu-Le Leef5ed30b2022-08-30 10:37:21 +00001640// pathForVndkRefAbiDump returns an OptionalPath representing the path of the
1641// reference abi dump for the given module. This is not guaranteed to be valid.
1642func pathForVndkRefAbiDump(ctx android.ModuleInstallPathContext, version, fileName string,
1643 isNdk, isVndk, isGzip bool) android.OptionalPath {
1644
1645 currentArchType := ctx.Arch().ArchType
1646 primaryArchType := ctx.Config().DevicePrimaryArchType()
1647 archName := currentArchType.String()
1648 if currentArchType != primaryArchType {
1649 archName += "_" + primaryArchType.String()
1650 }
1651
1652 var dirName string
1653 if isNdk {
1654 dirName = "ndk"
1655 } else if isVndk {
1656 dirName = "vndk"
1657 } else {
1658 dirName = "platform" // opt-in libs
1659 }
1660
1661 binderBitness := ctx.DeviceConfig().BinderBitness()
1662
1663 var ext string
1664 if isGzip {
1665 ext = ".lsdump.gz"
1666 } else {
1667 ext = ".lsdump"
1668 }
1669
1670 return android.ExistentPathForSource(ctx, "prebuilts", "abi-dumps", dirName,
1671 version, binderBitness, archName, "source-based",
1672 fileName+ext)
1673}
1674
Logan Chien7eefdc42018-07-11 18:10:41 +08001675func getRefAbiDumpFile(ctx ModuleContext, vndkVersion, fileName string) android.Path {
Hsin-Yi Chen27d235f2020-03-26 17:50:29 +08001676 // The logic must be consistent with classifySourceAbiDump.
Colin Cross95f1ca02020-10-29 20:47:22 -07001677 isNdk := ctx.isNdk(ctx.Config())
Mu-Le Lee85155c82022-07-07 10:05:09 +00001678 isVndk := ctx.useVndk() && ctx.isVndk()
Logan Chien7eefdc42018-07-11 18:10:41 +08001679
Mu-Le Leef5ed30b2022-08-30 10:37:21 +00001680 refAbiDumpTextFile := pathForVndkRefAbiDump(ctx, vndkVersion, fileName, isNdk, isVndk, false)
1681 refAbiDumpGzipFile := pathForVndkRefAbiDump(ctx, vndkVersion, fileName, isNdk, isVndk, true)
Logan Chien7eefdc42018-07-11 18:10:41 +08001682
1683 if refAbiDumpTextFile.Valid() {
1684 if refAbiDumpGzipFile.Valid() {
1685 ctx.ModuleErrorf(
1686 "Two reference ABI dump files are found: %q and %q. Please delete the stale one.",
1687 refAbiDumpTextFile, refAbiDumpGzipFile)
1688 return nil
1689 }
1690 return refAbiDumpTextFile.Path()
1691 }
1692 if refAbiDumpGzipFile.Valid() {
Chris Parsonsbf4f55f2020-11-23 17:02:44 -05001693 return unzipRefDump(ctx, refAbiDumpGzipFile.Path(), fileName)
Logan Chien7eefdc42018-07-11 18:10:41 +08001694 }
1695 return nil
1696}
1697
Mu-Le Lee13043932022-08-27 08:55:25 +00001698func prevDumpRefVersion(ctx ModuleContext) int {
Mu-Le Lee0a9005e2022-07-05 09:49:50 +00001699 sdkVersionInt := ctx.Config().PlatformSdkVersion().FinalInt()
1700 sdkVersionStr := ctx.Config().PlatformSdkVersion().String()
1701
1702 if ctx.Config().PlatformSdkFinal() {
Mu-Le Lee13043932022-08-27 08:55:25 +00001703 return sdkVersionInt - 1
Mu-Le Lee0a9005e2022-07-05 09:49:50 +00001704 } else {
1705 var dirName string
1706
1707 isNdk := ctx.isNdk(ctx.Config())
1708 if isNdk {
1709 dirName = "ndk"
1710 } else {
1711 dirName = "platform"
1712 }
1713
1714 // The platform SDK version can be upgraded before finalization while the corresponding abi dumps hasn't
1715 // been generated. Thus the Cross-Version Check chooses PLATFORM_SDK_VERION - 1 as previous version.
1716 // This situation could be identified by checking the existence of the PLATFORM_SDK_VERION dump directory.
1717 refDumpDir := android.ExistentPathForSource(ctx, "prebuilts", "abi-dumps", dirName, sdkVersionStr)
1718 if refDumpDir.Valid() {
Mu-Le Lee13043932022-08-27 08:55:25 +00001719 return sdkVersionInt
Mu-Le Lee0a9005e2022-07-05 09:49:50 +00001720 } else {
Mu-Le Lee13043932022-08-27 08:55:25 +00001721 return sdkVersionInt - 1
Mu-Le Lee0a9005e2022-07-05 09:49:50 +00001722 }
1723 }
1724}
1725
Jayant Chowdhary6ab3d842017-06-26 12:52:58 -07001726func (library *libraryDecorator) linkSAbiDumpFiles(ctx ModuleContext, objs Objects, fileName string, soFile android.Path) {
Yo Chiang2bbadfa2020-12-14 11:42:16 +08001727 if library.sabi.shouldCreateSourceAbiDump() {
Mu-Le Lee5e047532022-07-27 02:32:03 +00001728 var version string
Mu-Le Lee13043932022-08-27 08:55:25 +00001729 var prevVersion int
Mu-Le Lee0a9005e2022-07-05 09:49:50 +00001730
Inseob Kim96f17f02020-06-09 22:05:09 +09001731 if ctx.useVndk() {
1732 // For modules linking against vndk, follow its vndk version
Mu-Le Lee5e047532022-07-27 02:32:03 +00001733 version = ctx.Module().(*Module).VndkVersion()
Inseob Kim96f17f02020-06-09 22:05:09 +09001734 } else {
Mu-Le Lee5e047532022-07-27 02:32:03 +00001735 // After sdk finalizatoin, the ABI of the latest API level must be consistent with the source code
1736 // so the chosen reference dump is the PLATFORM_SDK_VERSION.
1737 if ctx.Config().PlatformSdkFinal() {
1738 version = ctx.Config().PlatformSdkVersion().String()
1739 } else {
1740 version = "current"
1741 }
Mu-Le Lee0a9005e2022-07-05 09:49:50 +00001742 prevVersion = prevDumpRefVersion(ctx)
Logan Chienf3511742017-10-31 18:04:35 +08001743 }
1744
Jayant Chowdharya4fce192017-09-06 13:10:03 -07001745 exportIncludeDirs := library.flagExporter.exportedIncludes(ctx)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001746 var SourceAbiFlags []string
1747 for _, dir := range exportIncludeDirs.Strings() {
Jayant Chowdhary715cac32017-04-20 06:53:59 -07001748 SourceAbiFlags = append(SourceAbiFlags, "-I"+dir)
1749 }
Inseob Kim69378442019-06-03 19:10:47 +09001750 for _, reexportedInclude := range library.sabi.Properties.ReexportedIncludes {
1751 SourceAbiFlags = append(SourceAbiFlags, "-I"+reexportedInclude)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001752 }
1753 exportedHeaderFlags := strings.Join(SourceAbiFlags, " ")
Chris Parsonsbf4f55f2020-11-23 17:02:44 -05001754 library.sAbiOutputFile = transformDumpToLinkedDump(ctx, objs.sAbiDumpFiles, soFile, fileName, exportedHeaderFlags,
Jiyong Parka034b832019-08-27 14:02:19 +09001755 android.OptionalPathForModuleSrc(ctx, library.symbolFileForAbiCheck(ctx)),
Logan Chiene3d7a0d2019-01-17 00:18:02 +08001756 library.Properties.Header_abi_checker.Exclude_symbol_versions,
1757 library.Properties.Header_abi_checker.Exclude_symbol_tags)
Logan Chien2f2b8902018-07-10 15:01:19 +08001758
Yo Chiang2bbadfa2020-12-14 11:42:16 +08001759 addLsdumpPath(classifySourceAbiDump(ctx) + ":" + library.sAbiOutputFile.String())
Hsin-Yi Chen53489642019-07-31 17:10:45 +08001760
Mu-Le Lee13043932022-08-27 08:55:25 +00001761 // If NDK or PLATFORM library, check against previous version ABI.
1762 if !ctx.useVndk() {
1763 prevRefAbiDumpFile := getRefAbiDumpFile(ctx, strconv.Itoa(prevVersion), fileName)
Mu-Le Lee0a9005e2022-07-05 09:49:50 +00001764 if prevRefAbiDumpFile != nil {
1765 library.prevSAbiDiff = sourceAbiDiff(ctx, library.sAbiOutputFile.Path(),
Mu-Le Lee13043932022-08-27 08:55:25 +00001766 prevRefAbiDumpFile, fileName, exportedHeaderFlags,
1767 library.Properties.Header_abi_checker.Diff_flags, prevVersion,
Mu-Le Lee0a9005e2022-07-05 09:49:50 +00001768 Bool(library.Properties.Header_abi_checker.Check_all_apis),
1769 ctx.IsLlndk(), ctx.isNdk(ctx.Config()), ctx.IsVndkExt(), true)
1770 }
1771 }
1772
Mu-Le Lee5e047532022-07-27 02:32:03 +00001773 refAbiDumpFile := getRefAbiDumpFile(ctx, version, fileName)
Logan Chien7eefdc42018-07-11 18:10:41 +08001774 if refAbiDumpFile != nil {
Chris Parsonsbf4f55f2020-11-23 17:02:44 -05001775 library.sAbiDiff = sourceAbiDiff(ctx, library.sAbiOutputFile.Path(),
Mu-Le Lee13043932022-08-27 08:55:25 +00001776 refAbiDumpFile, fileName, exportedHeaderFlags,
Hsin-Yi Chen6ad1e4b2022-05-19 15:17:54 +08001777 library.Properties.Header_abi_checker.Diff_flags,
Mu-Le Lee13043932022-08-27 08:55:25 +00001778 /* unused if not previousVersionDiff */ 0,
Logan Chien2a65dda2019-10-01 15:58:07 -07001779 Bool(library.Properties.Header_abi_checker.Check_all_apis),
Mu-Le Lee0a9005e2022-07-05 09:49:50 +00001780 ctx.IsLlndk(), ctx.isNdk(ctx.Config()), ctx.IsVndkExt(), false)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001781 }
1782 }
1783}
1784
Inseob Kimcc12d902021-05-14 20:15:55 +09001785func processLLNDKHeaders(ctx ModuleContext, srcHeaderDir string, outDir android.ModuleGenPath) (timestamp android.Path, installPaths android.WritablePaths) {
Colin Cross127bb8b2020-12-16 16:46:01 -08001786 srcDir := android.PathForModuleSrc(ctx, srcHeaderDir)
1787 srcFiles := ctx.GlobFiles(filepath.Join(srcDir.String(), "**/*.h"), nil)
1788
Colin Cross127bb8b2020-12-16 16:46:01 -08001789 for _, header := range srcFiles {
1790 headerDir := filepath.Dir(header.String())
1791 relHeaderDir, err := filepath.Rel(srcDir.String(), headerDir)
1792 if err != nil {
1793 ctx.ModuleErrorf("filepath.Rel(%q, %q) failed: %s",
1794 srcDir.String(), headerDir, err)
1795 continue
1796 }
1797
1798 installPaths = append(installPaths, outDir.Join(ctx, relHeaderDir, header.Base()))
1799 }
1800
Inseob Kimcc12d902021-05-14 20:15:55 +09001801 return processHeadersWithVersioner(ctx, srcDir, outDir, srcFiles, installPaths), installPaths
Colin Cross127bb8b2020-12-16 16:46:01 -08001802}
1803
Chris Parsons3c27ca32020-11-20 12:42:07 -05001804// link registers actions to link this library, and sets various fields
1805// on this library to reflect information that should be exported up the build
1806// tree (for example, exported flags and include paths).
Colin Crossb916a382016-07-29 17:28:03 -07001807func (library *libraryDecorator) link(ctx ModuleContext,
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001808 flags Flags, deps PathDeps, objs Objects) android.Path {
Colin Cross4d9c2d12016-07-29 12:48:20 -07001809
Colin Cross127bb8b2020-12-16 16:46:01 -08001810 if ctx.IsLlndk() {
1811 if len(library.Properties.Llndk.Export_preprocessed_headers) > 0 {
1812 // This is the vendor variant of an LLNDK library with preprocessed headers.
1813 genHeaderOutDir := android.PathForModuleGen(ctx, "include")
1814
1815 var timestampFiles android.Paths
1816 for _, dir := range library.Properties.Llndk.Export_preprocessed_headers {
Inseob Kimcc12d902021-05-14 20:15:55 +09001817 timestampFile, installPaths := processLLNDKHeaders(ctx, dir, genHeaderOutDir)
1818 timestampFiles = append(timestampFiles, timestampFile)
1819 library.addExportedGeneratedHeaders(installPaths.Paths()...)
Colin Cross127bb8b2020-12-16 16:46:01 -08001820 }
1821
1822 if Bool(library.Properties.Llndk.Export_headers_as_system) {
1823 library.reexportSystemDirs(genHeaderOutDir)
1824 } else {
1825 library.reexportDirs(genHeaderOutDir)
1826 }
1827
1828 library.reexportDeps(timestampFiles...)
1829 }
1830
Colin Cross0fb7fcd2021-03-02 11:00:07 -08001831 // override the module's export_include_dirs with llndk.override_export_include_dirs
1832 // if it is set.
1833 if override := library.Properties.Llndk.Override_export_include_dirs; override != nil {
1834 library.flagExporter.Properties.Export_include_dirs = override
1835 }
1836
Colin Cross127bb8b2020-12-16 16:46:01 -08001837 if Bool(library.Properties.Llndk.Export_headers_as_system) {
1838 library.flagExporter.Properties.Export_system_include_dirs = append(
1839 library.flagExporter.Properties.Export_system_include_dirs,
1840 library.flagExporter.Properties.Export_include_dirs...)
1841 library.flagExporter.Properties.Export_include_dirs = nil
1842 }
1843 }
1844
Colin Cross5271fea2021-04-27 13:06:04 -07001845 if ctx.IsVendorPublicLibrary() {
1846 // override the module's export_include_dirs with vendor_public_library.override_export_include_dirs
1847 // if it is set.
1848 if override := library.Properties.Vendor_public_library.Override_export_include_dirs; override != nil {
1849 library.flagExporter.Properties.Export_include_dirs = override
1850 }
1851 }
1852
Chris Parsons3c27ca32020-11-20 12:42:07 -05001853 // Linking this library consists of linking `deps.Objs` (.o files in dependencies
1854 // of this library), together with `objs` (.o files created by compiling this
1855 // library).
Colin Crossad59e752017-11-16 14:29:11 -08001856 objs = deps.Objs.Copy().Append(objs)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001857 var out android.Path
Colin Crossa48ab5b2017-02-14 15:28:44 -08001858 if library.static() || library.header() {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001859 out = library.linkStatic(ctx, flags, deps, objs)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001860 } else {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001861 out = library.linkShared(ctx, flags, deps, objs)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001862 }
1863
Chris Parsons3c27ca32020-11-20 12:42:07 -05001864 // Export include paths and flags to be propagated up the tree.
Inseob Kim69378442019-06-03 19:10:47 +09001865 library.exportIncludes(ctx)
1866 library.reexportDirs(deps.ReexportedDirs...)
1867 library.reexportSystemDirs(deps.ReexportedSystemDirs...)
1868 library.reexportFlags(deps.ReexportedFlags...)
1869 library.reexportDeps(deps.ReexportedDeps...)
Inseob Kimd110f872019-12-06 13:15:38 +09001870 library.addExportedGeneratedHeaders(deps.ReexportedGeneratedHeaders...)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001871
Chris Parsons3c27ca32020-11-20 12:42:07 -05001872 // Optionally export aidl headers.
Nan Zhang0007d812017-11-07 10:57:05 -08001873 if Bool(library.Properties.Aidl.Export_aidl_headers) {
Dan Willemsene1240db2016-11-03 14:28:51 -07001874 if library.baseCompiler.hasSrcExt(".aidl") {
Jiyong Park74955042019-10-22 20:19:51 +09001875 dir := android.PathForModuleGen(ctx, "aidl")
Inseob Kim69378442019-06-03 19:10:47 +09001876 library.reexportDirs(dir)
Inseob Kimd110f872019-12-06 13:15:38 +09001877
Paul Duffin33056e82021-02-19 13:49:08 +00001878 library.reexportDeps(library.baseCompiler.aidlOrderOnlyDeps...)
1879 library.addExportedGeneratedHeaders(library.baseCompiler.aidlHeaders...)
Dan Willemsene1240db2016-11-03 14:28:51 -07001880 }
1881 }
1882
Chris Parsons3c27ca32020-11-20 12:42:07 -05001883 // Optionally export proto headers.
Nan Zhang0007d812017-11-07 10:57:05 -08001884 if Bool(library.Properties.Proto.Export_proto_headers) {
Dan Willemsene1240db2016-11-03 14:28:51 -07001885 if library.baseCompiler.hasSrcExt(".proto") {
Jiyong Park74955042019-10-22 20:19:51 +09001886 var includes android.Paths
Colin Cross19878da2019-03-28 14:45:07 -07001887 if flags.proto.CanonicalPathFromRoot {
Jiyong Park74955042019-10-22 20:19:51 +09001888 includes = append(includes, flags.proto.SubDir)
Colin Cross10d22312017-05-03 11:01:58 -07001889 }
Jiyong Park74955042019-10-22 20:19:51 +09001890 includes = append(includes, flags.proto.Dir)
Inseob Kim69378442019-06-03 19:10:47 +09001891 library.reexportDirs(includes...)
Inseob Kimd110f872019-12-06 13:15:38 +09001892
Paul Duffin33056e82021-02-19 13:49:08 +00001893 library.reexportDeps(library.baseCompiler.protoOrderOnlyDeps...)
1894 library.addExportedGeneratedHeaders(library.baseCompiler.protoHeaders...)
Colin Cross0c461f12016-10-20 16:11:43 -07001895 }
1896 }
1897
Inseob Kim07def122020-11-23 14:43:02 +09001898 // If the library is sysprop_library, expose either public or internal header selectively.
Inseob Kim21f26902018-09-06 00:55:20 +09001899 if library.baseCompiler.hasSrcExt(".sysprop") {
Jiyong Park74955042019-10-22 20:19:51 +09001900 dir := android.PathForModuleGen(ctx, "sysprop", "include")
Inseob Kimc0907f12019-02-08 21:00:45 +09001901 if library.Properties.Sysprop.Platform != nil {
Inseob Kimc0907f12019-02-08 21:00:45 +09001902 isOwnerPlatform := Bool(library.Properties.Sysprop.Platform)
1903
Inseob Kim07def122020-11-23 14:43:02 +09001904 // If the owner is different from the user, expose public header. That is,
1905 // 1) if the user is product (as owner can only be platform / vendor)
Inseob Kim06410042021-01-18 15:23:28 +09001906 // 2) if the owner is platform and the client is vendor
1907 // We don't care Platform -> Vendor dependency as it's already forbidden.
1908 if ctx.Device() && (ctx.ProductSpecific() || (isOwnerPlatform && ctx.inVendor())) {
Jiyong Park74955042019-10-22 20:19:51 +09001909 dir = android.PathForModuleGen(ctx, "sysprop/public", "include")
Inseob Kimc0907f12019-02-08 21:00:45 +09001910 }
1911 }
1912
Paul Duffin37e0de52021-02-19 17:05:39 +00001913 // Make sure to only export headers which are within the include directory.
1914 _, headers := android.FilterPathListPredicate(library.baseCompiler.syspropHeaders, func(path android.Path) bool {
1915 _, isRel := android.MaybeRel(ctx, dir.String(), path.String())
1916 return isRel
1917 })
1918
Chris Parsons3c27ca32020-11-20 12:42:07 -05001919 // Add sysprop-related directories to the exported directories of this library.
Inseob Kim69378442019-06-03 19:10:47 +09001920 library.reexportDirs(dir)
Paul Duffin33056e82021-02-19 13:49:08 +00001921 library.reexportDeps(library.baseCompiler.syspropOrderOnlyDeps...)
Paul Duffin37e0de52021-02-19 17:05:39 +00001922 library.addExportedGeneratedHeaders(headers...)
Inseob Kim21f26902018-09-06 00:55:20 +09001923 }
1924
Chris Parsons3c27ca32020-11-20 12:42:07 -05001925 // Add stub-related flags if this library is a stub library.
Jiyong Park892a98f2020-12-14 09:20:00 +09001926 library.exportVersioningMacroIfNeeded(ctx)
Jiyong Parkda732bd2018-11-02 18:23:15 +09001927
Chris Parsons3c27ca32020-11-20 12:42:07 -05001928 // Propagate a Provider containing information about exported flags, deps, and include paths.
Colin Cross0de8a1e2020-09-18 14:15:30 -07001929 library.flagExporter.setProvider(ctx)
1930
Colin Cross4d9c2d12016-07-29 12:48:20 -07001931 return out
1932}
1933
Jiyong Park892a98f2020-12-14 09:20:00 +09001934func (library *libraryDecorator) exportVersioningMacroIfNeeded(ctx android.BaseModuleContext) {
Colin Cross127bb8b2020-12-16 16:46:01 -08001935 if library.buildStubs() && library.stubsVersion() != "" && !library.skipAPIDefine {
Jiyong Park892a98f2020-12-14 09:20:00 +09001936 name := versioningMacroName(ctx.Module().(*Module).ImplementationModuleName(ctx))
Jooyung Han11b0fbd2021-02-05 02:28:22 +09001937 apiLevel, err := android.ApiLevelFromUser(ctx, library.stubsVersion())
1938 if err != nil {
1939 ctx.ModuleErrorf("Can't export version macro: %s", err.Error())
1940 }
1941 library.reexportFlags("-D" + name + "=" + strconv.Itoa(apiLevel.FinalOrPreviewInt()))
Jiyong Park892a98f2020-12-14 09:20:00 +09001942 }
1943}
1944
Chris Parsons3c27ca32020-11-20 12:42:07 -05001945// buildStatic returns true if this library should be built as a static library.
Colin Crossb916a382016-07-29 17:28:03 -07001946func (library *libraryDecorator) buildStatic() bool {
Colin Crosse1bb5d02019-09-24 14:55:04 -07001947 return library.MutatedProperties.BuildStatic &&
1948 BoolDefault(library.StaticProperties.Static.Enabled, true)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001949}
1950
Chris Parsons3c27ca32020-11-20 12:42:07 -05001951// buildShared returns true if this library should be built as a shared library.
Colin Crossb916a382016-07-29 17:28:03 -07001952func (library *libraryDecorator) buildShared() bool {
Colin Crosse1bb5d02019-09-24 14:55:04 -07001953 return library.MutatedProperties.BuildShared &&
1954 BoolDefault(library.SharedProperties.Shared.Enabled, true)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001955}
1956
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001957func (library *libraryDecorator) objs() Objects {
1958 return library.objects
Colin Cross4d9c2d12016-07-29 12:48:20 -07001959}
1960
Colin Cross0de8a1e2020-09-18 14:15:30 -07001961func (library *libraryDecorator) reuseObjs() Objects {
1962 return library.reuseObjects
Colin Cross4d9c2d12016-07-29 12:48:20 -07001963}
1964
Colin Cross26c34ed2016-09-30 17:10:16 -07001965func (library *libraryDecorator) toc() android.OptionalPath {
1966 return library.tocFile
1967}
1968
Jiyong Parkf1194352019-02-25 11:05:47 +09001969func (library *libraryDecorator) installSymlinkToRuntimeApex(ctx ModuleContext, file android.Path) {
1970 dir := library.baseInstaller.installDir(ctx)
1971 dirOnDevice := android.InstallPathToOnDevicePath(ctx, dir)
1972 target := "/" + filepath.Join("apex", "com.android.runtime", dir.Base(), "bionic", file.Base())
1973 ctx.InstallAbsoluteSymlink(dir, file.Base(), target)
Jaewoong Jung18aefc12020-12-21 09:11:10 -08001974 library.postInstallCmds = append(library.postInstallCmds, makeSymlinkCmd(dirOnDevice, file.Base(), target))
Jiyong Parkf1194352019-02-25 11:05:47 +09001975}
1976
Colin Crossb916a382016-07-29 17:28:03 -07001977func (library *libraryDecorator) install(ctx ModuleContext, file android.Path) {
Colin Crossc43ae772017-04-14 15:42:53 -07001978 if library.shared() {
Justin Yun8fe12122017-12-07 17:18:15 +09001979 if ctx.Device() && ctx.useVndk() {
Jooyung Han261e1582020-10-20 18:54:21 +09001980 // set subDir for VNDK extensions
Ivan Lozanof9e21722020-12-02 09:00:51 -05001981 if ctx.IsVndkExt() {
Jooyung Han261e1582020-10-20 18:54:21 +09001982 if ctx.isVndkSp() {
1983 library.baseInstaller.subDir = "vndk-sp"
1984 } else {
1985 library.baseInstaller.subDir = "vndk"
1986 }
1987 }
1988
Justin Yun31094b12020-12-24 16:11:23 +09001989 // In some cases we want to use core variant for VNDK-Core libs.
1990 // Skip product variant since VNDKs use only the vendor variant.
1991 if ctx.isVndk() && !ctx.isVndkSp() && !ctx.IsVndkExt() && !ctx.inProduct() {
Vic Yang1a5812a2020-01-31 10:38:40 -08001992 mayUseCoreVariant := true
1993
1994 if ctx.mustUseVendorVariant() {
1995 mayUseCoreVariant = false
1996 }
1997
Elvis Chien9c993542021-06-25 01:15:17 +08001998 if ctx.Config().CFIEnabledForPath(ctx.ModuleDir()) {
Vic Yang1a5812a2020-01-31 10:38:40 -08001999 mayUseCoreVariant = false
2000 }
2001
2002 if mayUseCoreVariant {
Vic Yangd92090f2020-01-08 14:32:28 -08002003 library.checkSameCoreVariant = true
2004 if ctx.DeviceConfig().VndkUseCoreVariant() {
2005 library.useCoreVariant = true
2006 }
Vic Yangefd249e2018-11-12 20:19:56 -08002007 }
Justin Yun8fe12122017-12-07 17:18:15 +09002008 }
Logan Chienf3511742017-10-31 18:04:35 +08002009
Jooyung Han261e1582020-10-20 18:54:21 +09002010 // do not install vndk libs
2011 // vndk libs are packaged into VNDK APEX
Ivan Lozanof9e21722020-12-02 09:00:51 -05002012 if ctx.isVndk() && !ctx.IsVndkExt() {
Jooyung Han261e1582020-10-20 18:54:21 +09002013 return
Justin Yun8effde42017-06-23 19:24:43 +09002014 }
Jiyong Parkd4a3a132021-03-17 20:21:35 +09002015 } else if library.hasStubsVariants() && !ctx.Host() && ctx.directlyInAnyApex() {
Jiyong Parkf1194352019-02-25 11:05:47 +09002016 // Bionic libraries (e.g. libc.so) is installed to the bootstrap subdirectory.
2017 // The original path becomes a symlink to the corresponding file in the
2018 // runtime APEX.
Colin Cross3b19f5d2019-09-17 14:45:31 -07002019 translatedArch := ctx.Target().NativeBridge == android.NativeBridgeEnabled
Colin Cross56a83212020-09-15 18:30:11 -07002020 if InstallToBootstrap(ctx.baseModuleName(), ctx.Config()) && !library.buildStubs() &&
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002021 !translatedArch && !ctx.inRamdisk() && !ctx.inVendorRamdisk() && !ctx.inRecovery() {
Martin Stjernholm279de572019-09-10 23:18:20 +01002022 if ctx.Device() {
Jiyong Parkc3e2c862019-03-16 01:10:08 +09002023 library.installSymlinkToRuntimeApex(ctx, file)
2024 }
Jiyong Park429660f2019-01-16 22:31:11 +09002025 library.baseInstaller.subDir = "bootstrap"
2026 }
Colin Cross127bb8b2020-12-16 16:46:01 -08002027 } else if ctx.directlyInAnyApex() && ctx.IsLlndk() && !isBionic(ctx.baseModuleName()) {
Przemyslaw Szczepaniake6fc5072019-07-12 14:06:23 +01002028 // Skip installing LLNDK (non-bionic) libraries moved to APEX.
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002029 ctx.Module().HideFromMake()
Justin Yun8effde42017-06-23 19:24:43 +09002030 }
Przemyslaw Szczepaniake6fc5072019-07-12 14:06:23 +01002031
Colin Cross4d9c2d12016-07-29 12:48:20 -07002032 library.baseInstaller.install(ctx, file)
2033 }
Dan Albertf563d252017-10-13 00:29:00 -07002034
Dan Albert281f22b2017-12-13 15:03:47 -08002035 if Bool(library.Properties.Static_ndk_lib) && library.static() &&
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002036 !ctx.useVndk() && !ctx.inRamdisk() && !ctx.inVendorRamdisk() && !ctx.inRecovery() && ctx.Device() &&
Jiyong Park7ed9de32018-10-15 22:25:07 +09002037 library.baseLinker.sanitize.isUnsanitizedVariant() &&
Colin Cross95b07f22020-12-16 11:06:50 -08002038 ctx.isForPlatform() && !ctx.isPreventInstall() {
Dan Albertf563d252017-10-13 00:29:00 -07002039 installPath := getNdkSysrootBase(ctx).Join(
Dan Albertea4b7b92018-04-25 16:05:30 -07002040 ctx, "usr/lib", config.NDKTriple(ctx.toolchain()), file.Base())
Dan Albertf563d252017-10-13 00:29:00 -07002041
2042 ctx.ModuleBuild(pctx, android.ModuleBuildParams{
2043 Rule: android.Cp,
2044 Description: "install " + installPath.Base(),
2045 Output: installPath,
2046 Input: file,
2047 })
2048
Colin Cross0875c522017-11-28 17:34:01 -08002049 library.ndkSysrootPath = installPath
Dan Albertf563d252017-10-13 00:29:00 -07002050 }
Colin Cross4d9c2d12016-07-29 12:48:20 -07002051}
2052
Paul Duffin0cb37b92020-03-04 14:52:46 +00002053func (library *libraryDecorator) everInstallable() bool {
2054 // Only shared and static libraries are installed. Header libraries (which are
2055 // neither static or shared) are not installed.
2056 return library.shared() || library.static()
2057}
2058
Chris Parsons3c27ca32020-11-20 12:42:07 -05002059// static returns true if this library is for a "static' variant.
Colin Crossb916a382016-07-29 17:28:03 -07002060func (library *libraryDecorator) static() bool {
Colin Crossa48ab5b2017-02-14 15:28:44 -08002061 return library.MutatedProperties.VariantIsStatic
Colin Cross4d9c2d12016-07-29 12:48:20 -07002062}
2063
Chris Parsons3c27ca32020-11-20 12:42:07 -05002064// shared returns true if this library is for a "shared' variant.
Colin Crossa48ab5b2017-02-14 15:28:44 -08002065func (library *libraryDecorator) shared() bool {
2066 return library.MutatedProperties.VariantIsShared
2067}
2068
Chris Parsons3c27ca32020-11-20 12:42:07 -05002069// header returns true if this library is for a header-only variant.
Colin Crossa48ab5b2017-02-14 15:28:44 -08002070func (library *libraryDecorator) header() bool {
Chris Parsons3c27ca32020-11-20 12:42:07 -05002071 // Neither "static" nor "shared" implies this library is header-only.
Colin Crossa48ab5b2017-02-14 15:28:44 -08002072 return !library.static() && !library.shared()
2073}
2074
Chris Parsons3c27ca32020-11-20 12:42:07 -05002075// setStatic marks the library variant as "static".
Colin Crossa48ab5b2017-02-14 15:28:44 -08002076func (library *libraryDecorator) setStatic() {
2077 library.MutatedProperties.VariantIsStatic = true
2078 library.MutatedProperties.VariantIsShared = false
2079}
2080
Chris Parsons3c27ca32020-11-20 12:42:07 -05002081// setShared marks the library variant as "shared".
Colin Crossa48ab5b2017-02-14 15:28:44 -08002082func (library *libraryDecorator) setShared() {
2083 library.MutatedProperties.VariantIsStatic = false
2084 library.MutatedProperties.VariantIsShared = true
Colin Crossb916a382016-07-29 17:28:03 -07002085}
2086
Chris Parsons3c27ca32020-11-20 12:42:07 -05002087// BuildOnlyStatic disables building this library as a shared library.
Colin Crossab3b7322016-12-09 14:46:15 -08002088func (library *libraryDecorator) BuildOnlyStatic() {
Colin Crossa48ab5b2017-02-14 15:28:44 -08002089 library.MutatedProperties.BuildShared = false
Colin Crossab3b7322016-12-09 14:46:15 -08002090}
2091
Chris Parsons3c27ca32020-11-20 12:42:07 -05002092// BuildOnlyShared disables building this library as a static library.
Colin Crossab3b7322016-12-09 14:46:15 -08002093func (library *libraryDecorator) BuildOnlyShared() {
Colin Crossa48ab5b2017-02-14 15:28:44 -08002094 library.MutatedProperties.BuildStatic = false
Colin Crossab3b7322016-12-09 14:46:15 -08002095}
2096
Chris Parsons3c27ca32020-11-20 12:42:07 -05002097// HeaderOnly disables building this library as a shared or static library;
2098// the library only exists to propagate header file dependencies up the build graph.
Colin Cross5950f382016-12-13 12:50:57 -08002099func (library *libraryDecorator) HeaderOnly() {
Colin Crossa48ab5b2017-02-14 15:28:44 -08002100 library.MutatedProperties.BuildShared = false
2101 library.MutatedProperties.BuildStatic = false
Colin Cross5950f382016-12-13 12:50:57 -08002102}
2103
Colin Cross127bb8b2020-12-16 16:46:01 -08002104// hasLLNDKStubs returns true if this cc_library module has a variant that will build LLNDK stubs.
2105func (library *libraryDecorator) hasLLNDKStubs() bool {
Colin Cross203b4212021-04-26 17:19:41 -07002106 return String(library.Properties.Llndk.Symbol_file) != ""
Colin Cross0fb7fcd2021-03-02 11:00:07 -08002107}
2108
Colin Cross203b4212021-04-26 17:19:41 -07002109// hasLLNDKStubs returns true if this cc_library module has a variant that will build LLNDK stubs.
Colin Cross1f3f1302021-04-26 18:37:44 -07002110func (library *libraryDecorator) hasLLNDKHeaders() bool {
2111 return Bool(library.Properties.Llndk.Llndk_headers)
2112}
2113
Colin Cross5271fea2021-04-27 13:06:04 -07002114// hasVendorPublicLibrary returns true if this cc_library module has a variant that will build
2115// vendor public library stubs.
2116func (library *libraryDecorator) hasVendorPublicLibrary() bool {
2117 return String(library.Properties.Vendor_public_library.Symbol_file) != ""
2118}
2119
Colin Cross0477b422020-10-13 18:43:54 -07002120func (library *libraryDecorator) implementationModuleName(name string) string {
2121 return name
2122}
2123
Jiyong Park7ed9de32018-10-15 22:25:07 +09002124func (library *libraryDecorator) buildStubs() bool {
2125 return library.MutatedProperties.BuildStubs
2126}
2127
Jiyong Parka034b832019-08-27 14:02:19 +09002128func (library *libraryDecorator) symbolFileForAbiCheck(ctx ModuleContext) *string {
2129 if library.Properties.Header_abi_checker.Symbol_file != nil {
2130 return library.Properties.Header_abi_checker.Symbol_file
2131 }
Colin Cross127bb8b2020-12-16 16:46:01 -08002132 if ctx.Module().(*Module).IsLlndk() {
2133 return library.Properties.Llndk.Symbol_file
2134 }
Colin Cross31076b32020-10-23 17:22:06 -07002135 if library.hasStubsVariants() && library.Properties.Stubs.Symbol_file != nil {
Jiyong Parka034b832019-08-27 14:02:19 +09002136 return library.Properties.Stubs.Symbol_file
2137 }
2138 return nil
2139}
2140
Colin Crossc88c2722020-09-28 17:32:47 -07002141func (library *libraryDecorator) hasStubsVariants() bool {
Jiyong Parkd4a3a132021-03-17 20:21:35 +09002142 // Just having stubs.symbol_file is enough to create a stub variant. In that case
2143 // the stub for the future API level is created.
2144 return library.Properties.Stubs.Symbol_file != nil ||
2145 len(library.Properties.Stubs.Versions) > 0
Colin Crossc88c2722020-09-28 17:32:47 -07002146}
2147
Colin Cross3572cf72020-10-01 15:58:11 -07002148func (library *libraryDecorator) stubsVersions(ctx android.BaseMutatorContext) []string {
Jiyong Parkd4a3a132021-03-17 20:21:35 +09002149 if !library.hasStubsVariants() {
2150 return nil
2151 }
2152
Colin Crossc1b36442021-05-06 13:42:48 -07002153 if library.hasLLNDKStubs() && ctx.Module().(*Module).UseVndk() {
2154 // LLNDK libraries only need a single stubs variant.
2155 return []string{android.FutureApiLevel.String()}
2156 }
2157
Jiyong Parkd4a3a132021-03-17 20:21:35 +09002158 // Future API level is implicitly added if there isn't
2159 vers := library.Properties.Stubs.Versions
2160 if inList(android.FutureApiLevel.String(), vers) {
2161 return vers
2162 }
2163 // In some cases, people use the raw value "10000" in the versions property.
2164 // We shouldn't add the future API level in that case, otherwise there will
2165 // be two identical versions.
2166 if inList(strconv.Itoa(android.FutureApiLevel.FinalOrFutureInt()), vers) {
2167 return vers
2168 }
2169 return append(vers, android.FutureApiLevel.String())
Colin Crossc88c2722020-09-28 17:32:47 -07002170}
2171
2172func (library *libraryDecorator) setStubsVersion(version string) {
2173 library.MutatedProperties.StubsVersion = version
2174}
2175
Jiyong Park7ed9de32018-10-15 22:25:07 +09002176func (library *libraryDecorator) stubsVersion() string {
2177 return library.MutatedProperties.StubsVersion
2178}
2179
Jiyong Parkd4a3a132021-03-17 20:21:35 +09002180func (library *libraryDecorator) setBuildStubs(isLatest bool) {
Colin Crossc88c2722020-09-28 17:32:47 -07002181 library.MutatedProperties.BuildStubs = true
Jiyong Parkd4a3a132021-03-17 20:21:35 +09002182 library.MutatedProperties.IsLatestVersion = isLatest
Colin Crossc88c2722020-09-28 17:32:47 -07002183}
2184
2185func (library *libraryDecorator) setAllStubsVersions(versions []string) {
2186 library.MutatedProperties.AllStubsVersions = versions
2187}
2188
2189func (library *libraryDecorator) allStubsVersions() []string {
2190 return library.MutatedProperties.AllStubsVersions
2191}
2192
Jooyung Hanad4c1872020-02-27 17:56:44 +09002193func (library *libraryDecorator) isLatestStubVersion() bool {
Jiyong Parkd4a3a132021-03-17 20:21:35 +09002194 return library.MutatedProperties.IsLatestVersion
Jooyung Hanad4c1872020-02-27 17:56:44 +09002195}
2196
Jiyong Parka90ca002019-10-07 15:47:24 +09002197func (library *libraryDecorator) availableFor(what string) bool {
2198 var list []string
2199 if library.static() {
2200 list = library.StaticProperties.Static.Apex_available
2201 } else if library.shared() {
2202 list = library.SharedProperties.Shared.Apex_available
2203 }
2204 if len(list) == 0 {
2205 return false
2206 }
2207 return android.CheckAvailableForApex(what, list)
2208}
2209
Colin Cross1bc94122021-10-28 13:25:54 -07002210func (library *libraryDecorator) installable() *bool {
2211 if library.static() {
2212 return library.StaticProperties.Static.Installable
2213 } else if library.shared() {
2214 return library.SharedProperties.Shared.Installable
2215 }
2216 return nil
2217}
2218
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01002219func (library *libraryDecorator) makeUninstallable(mod *Module) {
Martin Stjernholmbf37d162020-03-31 16:05:34 +01002220 if library.static() && library.buildStatic() && !library.buildStubs() {
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01002221 // If we're asked to make a static library uninstallable we don't do
2222 // anything since AndroidMkEntries always sets LOCAL_UNINSTALLABLE_MODULE
2223 // for these entries. This is done to still get the make targets for NOTICE
2224 // files from notice_files.mk, which other libraries might depend on.
Martin Stjernholmbf37d162020-03-31 16:05:34 +01002225 return
2226 }
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01002227 mod.ModuleBase.MakeUninstallable()
Martin Stjernholmbf37d162020-03-31 16:05:34 +01002228}
2229
Colin Crossceaa5322021-09-28 16:37:50 -07002230func (library *libraryDecorator) getAPIListCoverageXMLPath() android.ModuleOutPath {
2231 return library.apiListCoverageXmlPath
2232}
2233
Colin Cross571cccf2019-02-04 11:22:08 -08002234var versioningMacroNamesListKey = android.NewOnceKey("versioningMacroNamesList")
2235
Chris Parsons3c27ca32020-11-20 12:42:07 -05002236// versioningMacroNamesList returns a singleton map, where keys are "version macro names",
2237// and values are the module name responsible for registering the version macro name.
2238//
2239// Version macros are used when building against stubs, to provide version information about
2240// the stub. Only stub libraries should have an entry in this list.
2241//
2242// For example, when building against libFoo#ver, __LIBFOO_API__ macro is set to ver so
2243// that headers from libFoo can be conditionally compiled (this may hide APIs
2244// that are not available for the version).
2245//
2246// This map is used to ensure that there aren't conflicts between these version macro names.
Jiyong Parkda732bd2018-11-02 18:23:15 +09002247func versioningMacroNamesList(config android.Config) *map[string]string {
Colin Cross571cccf2019-02-04 11:22:08 -08002248 return config.Once(versioningMacroNamesListKey, func() interface{} {
Jiyong Parkda732bd2018-11-02 18:23:15 +09002249 m := make(map[string]string)
2250 return &m
2251 }).(*map[string]string)
2252}
2253
2254// alphanumeric and _ characters are preserved.
2255// other characters are all converted to _
2256var charsNotForMacro = regexp.MustCompile("[^a-zA-Z0-9_]+")
2257
Chris Parsons3c27ca32020-11-20 12:42:07 -05002258// versioningMacroName returns the canonical version macro name for the given module.
Jiyong Parkda732bd2018-11-02 18:23:15 +09002259func versioningMacroName(moduleName string) string {
2260 macroName := charsNotForMacro.ReplaceAllString(moduleName, "_")
Jooyung Hanb04a4992020-03-13 18:57:35 +09002261 macroName = strings.ToUpper(macroName)
Jiyong Parkda732bd2018-11-02 18:23:15 +09002262 return "__" + macroName + "_API__"
2263}
2264
Chris Parsons3c27ca32020-11-20 12:42:07 -05002265// NewLibrary builds and returns a new Module corresponding to a C++ library.
2266// Individual module implementations which comprise a C++ library (or something like
2267// a C++ library) should call this function, set some fields on the result, and
2268// then call the Init function.
Colin Crossab3b7322016-12-09 14:46:15 -08002269func NewLibrary(hod android.HostOrDeviceSupported) (*Module, *libraryDecorator) {
Colin Cross4d9c2d12016-07-29 12:48:20 -07002270 module := newModule(hod, android.MultilibBoth)
2271
Colin Crossb916a382016-07-29 17:28:03 -07002272 library := &libraryDecorator{
Colin Crossa48ab5b2017-02-14 15:28:44 -08002273 MutatedProperties: LibraryMutatedProperties{
Colin Crossab3b7322016-12-09 14:46:15 -08002274 BuildShared: true,
2275 BuildStatic: true,
Colin Cross4d9c2d12016-07-29 12:48:20 -07002276 },
Colin Crossb916a382016-07-29 17:28:03 -07002277 baseCompiler: NewBaseCompiler(),
Dan Albert61f32122018-07-26 14:00:24 -07002278 baseLinker: NewBaseLinker(module.sanitize),
Colin Crossb916a382016-07-29 17:28:03 -07002279 baseInstaller: NewBaseInstaller("lib", "lib64", InstallInSystem),
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08002280 sabi: module.sabi,
Colin Cross4d9c2d12016-07-29 12:48:20 -07002281 }
2282
Colin Crossb916a382016-07-29 17:28:03 -07002283 module.compiler = library
2284 module.linker = library
2285 module.installer = library
Colin Cross31076b32020-10-23 17:22:06 -07002286 module.library = library
Colin Crossb916a382016-07-29 17:28:03 -07002287
2288 return module, library
2289}
2290
Colin Cross10d22312017-05-03 11:01:58 -07002291// connects a shared library to a static library in order to reuse its .o files to avoid
2292// compiling source files twice.
2293func reuseStaticLibrary(mctx android.BottomUpMutatorContext, static, shared *Module) {
2294 if staticCompiler, ok := static.compiler.(*libraryDecorator); ok {
2295 sharedCompiler := shared.compiler.(*libraryDecorator)
Dan Willemsen3a26eef2018-12-03 15:25:46 -08002296
2297 // Check libraries in addition to cflags, since libraries may be exporting different
2298 // include directories.
Colin Crosse1bb5d02019-09-24 14:55:04 -07002299 if len(staticCompiler.StaticProperties.Static.Cflags) == 0 &&
2300 len(sharedCompiler.SharedProperties.Shared.Cflags) == 0 &&
2301 len(staticCompiler.StaticProperties.Static.Whole_static_libs) == 0 &&
2302 len(sharedCompiler.SharedProperties.Shared.Whole_static_libs) == 0 &&
2303 len(staticCompiler.StaticProperties.Static.Static_libs) == 0 &&
2304 len(sharedCompiler.SharedProperties.Shared.Static_libs) == 0 &&
2305 len(staticCompiler.StaticProperties.Static.Shared_libs) == 0 &&
2306 len(sharedCompiler.SharedProperties.Shared.Shared_libs) == 0 &&
Martin Stjernholm10566a02020-03-24 01:19:52 +00002307 // Compare System_shared_libs properties with nil because empty lists are
2308 // semantically significant for them.
Colin Crosse1bb5d02019-09-24 14:55:04 -07002309 staticCompiler.StaticProperties.Static.System_shared_libs == nil &&
2310 sharedCompiler.SharedProperties.Shared.System_shared_libs == nil {
Colin Cross10d22312017-05-03 11:01:58 -07002311
2312 mctx.AddInterVariantDependency(reuseObjTag, shared, static)
2313 sharedCompiler.baseCompiler.Properties.OriginalSrcs =
2314 sharedCompiler.baseCompiler.Properties.Srcs
2315 sharedCompiler.baseCompiler.Properties.Srcs = nil
2316 sharedCompiler.baseCompiler.Properties.Generated_sources = nil
2317 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07002318
2319 // This dep is just to reference static variant from shared variant
2320 mctx.AddInterVariantDependency(staticVariantTag, shared, static)
Colin Cross10d22312017-05-03 11:01:58 -07002321 }
2322}
2323
Chris Parsons3c27ca32020-11-20 12:42:07 -05002324// LinkageMutator adds "static" or "shared" variants for modules depending
2325// on whether the module can be built as a static library or a shared library.
Colin Crosse40b4ea2018-10-02 22:25:58 -07002326func LinkageMutator(mctx android.BottomUpMutatorContext) {
Jaewoong Jung18aefc12020-12-21 09:11:10 -08002327 ccPrebuilt := false
Colin Crossb916a382016-07-29 17:28:03 -07002328 if m, ok := mctx.Module().(*Module); ok && m.linker != nil {
Jaewoong Jung18aefc12020-12-21 09:11:10 -08002329 _, ccPrebuilt = m.linker.(prebuiltLibraryInterface)
Ivan Lozano52767be2019-10-18 14:49:46 -07002330 }
Jaewoong Jung18aefc12020-12-21 09:11:10 -08002331 if ccPrebuilt {
Ivan Lozano52767be2019-10-18 14:49:46 -07002332 library := mctx.Module().(*Module).linker.(prebuiltLibraryInterface)
Colin Cross33b2fb72019-05-14 14:07:01 -07002333
Paul Duffinf5ea9e12020-02-21 10:57:00 +00002334 // Differentiate between header only and building an actual static/shared library
Colin Cross127bb8b2020-12-16 16:46:01 -08002335 buildStatic := library.buildStatic()
2336 buildShared := library.buildShared()
2337 if buildStatic || buildShared {
Paul Duffinf5ea9e12020-02-21 10:57:00 +00002338 // Always create both the static and shared variants for prebuilt libraries, and then disable the one
2339 // that is not being used. This allows them to share the name of a cc_library module, which requires that
2340 // all the variants of the cc_library also exist on the prebuilt.
2341 modules := mctx.CreateLocalVariations("static", "shared")
2342 static := modules[0].(*Module)
2343 shared := modules[1].(*Module)
Colin Cross33b2fb72019-05-14 14:07:01 -07002344
Paul Duffinf5ea9e12020-02-21 10:57:00 +00002345 static.linker.(prebuiltLibraryInterface).setStatic()
2346 shared.linker.(prebuiltLibraryInterface).setShared()
Colin Cross33b2fb72019-05-14 14:07:01 -07002347
Colin Cross127bb8b2020-12-16 16:46:01 -08002348 if buildShared {
Colin Cross81ca6cd2020-08-06 17:46:48 -07002349 mctx.AliasVariation("shared")
Colin Cross127bb8b2020-12-16 16:46:01 -08002350 } else if buildStatic {
Colin Cross81ca6cd2020-08-06 17:46:48 -07002351 mctx.AliasVariation("static")
2352 }
2353
Colin Cross127bb8b2020-12-16 16:46:01 -08002354 if !buildStatic {
Paul Duffinf5ea9e12020-02-21 10:57:00 +00002355 static.linker.(prebuiltLibraryInterface).disablePrebuilt()
2356 }
Colin Cross127bb8b2020-12-16 16:46:01 -08002357 if !buildShared {
Paul Duffinf5ea9e12020-02-21 10:57:00 +00002358 shared.linker.(prebuiltLibraryInterface).disablePrebuilt()
2359 }
2360 } else {
2361 // Header only
Colin Crossb916a382016-07-29 17:28:03 -07002362 }
Paul Duffinf5ea9e12020-02-21 10:57:00 +00002363
Ivan Lozano52767be2019-10-18 14:49:46 -07002364 } else if library, ok := mctx.Module().(LinkableInterface); ok && library.CcLibraryInterface() {
Ivan Lozano52767be2019-10-18 14:49:46 -07002365
Ivan Lozano2b262972019-11-21 12:30:50 -08002366 // Non-cc.Modules may need an empty variant for their mutators.
2367 variations := []string{}
2368 if library.NonCcVariants() {
2369 variations = append(variations, "")
2370 }
2371
Colin Cross127bb8b2020-12-16 16:46:01 -08002372 isLLNDK := false
2373 if m, ok := mctx.Module().(*Module); ok {
Colin Cross203b4212021-04-26 17:19:41 -07002374 isLLNDK = m.IsLlndk()
Colin Cross127bb8b2020-12-16 16:46:01 -08002375 }
2376 buildStatic := library.BuildStaticVariant() && !isLLNDK
2377 buildShared := library.BuildSharedVariant()
2378 if buildStatic && buildShared {
Ivan Lozano2b262972019-11-21 12:30:50 -08002379 variations := append([]string{"static", "shared"}, variations...)
Ivan Lozano52767be2019-10-18 14:49:46 -07002380
2381 modules := mctx.CreateLocalVariations(variations...)
2382 static := modules[0].(LinkableInterface)
2383 shared := modules[1].(LinkableInterface)
2384
2385 static.SetStatic()
2386 shared.SetShared()
2387
2388 if _, ok := library.(*Module); ok {
2389 reuseStaticLibrary(mctx, static.(*Module), shared.(*Module))
2390 }
Colin Cross81ca6cd2020-08-06 17:46:48 -07002391 mctx.AliasVariation("shared")
Colin Cross127bb8b2020-12-16 16:46:01 -08002392 } else if buildStatic {
Ivan Lozano2b262972019-11-21 12:30:50 -08002393 variations := append([]string{"static"}, variations...)
2394
2395 modules := mctx.CreateLocalVariations(variations...)
Ivan Lozano52767be2019-10-18 14:49:46 -07002396 modules[0].(LinkableInterface).SetStatic()
Colin Cross81ca6cd2020-08-06 17:46:48 -07002397 mctx.AliasVariation("static")
Colin Cross127bb8b2020-12-16 16:46:01 -08002398 } else if buildShared {
Ivan Lozano2b262972019-11-21 12:30:50 -08002399 variations := append([]string{"shared"}, variations...)
Ivan Lozano52767be2019-10-18 14:49:46 -07002400
Ivan Lozano2b262972019-11-21 12:30:50 -08002401 modules := mctx.CreateLocalVariations(variations...)
2402 modules[0].(LinkableInterface).SetShared()
Colin Cross81ca6cd2020-08-06 17:46:48 -07002403 mctx.AliasVariation("shared")
Ivan Lozano2b262972019-11-21 12:30:50 -08002404 } else if len(variations) > 0 {
2405 mctx.CreateLocalVariations(variations...)
Colin Cross81ca6cd2020-08-06 17:46:48 -07002406 mctx.AliasVariation(variations[0])
Ivan Lozano2b262972019-11-21 12:30:50 -08002407 }
Colin Crossb916a382016-07-29 17:28:03 -07002408 }
Colin Cross4d9c2d12016-07-29 12:48:20 -07002409}
Jiyong Park7ed9de32018-10-15 22:25:07 +09002410
Chris Parsons3c27ca32020-11-20 12:42:07 -05002411// normalizeVersions modifies `versions` in place, so that each raw version
2412// string becomes its normalized canonical form.
2413// Validates that the versions in `versions` are specified in least to greatest order.
Jooyung Hanaed150d2020-04-02 01:41:41 +09002414func normalizeVersions(ctx android.BaseModuleContext, versions []string) {
Dan Albertc8060532020-07-22 22:32:17 -07002415 var previous android.ApiLevel
Jooyung Hanad4c1872020-02-27 17:56:44 +09002416 for i, v := range versions {
Dan Albertc8060532020-07-22 22:32:17 -07002417 ver, err := android.ApiLevelFromUser(ctx, v)
Jooyung Hanad4c1872020-02-27 17:56:44 +09002418 if err != nil {
Jooyung Hanaed150d2020-04-02 01:41:41 +09002419 ctx.PropertyErrorf("versions", "%s", err.Error())
2420 return
Jooyung Hanad4c1872020-02-27 17:56:44 +09002421 }
Dan Albertc8060532020-07-22 22:32:17 -07002422 if i > 0 && ver.LessThanOrEqualTo(previous) {
2423 ctx.PropertyErrorf("versions", "not sorted: %v", versions)
2424 }
2425 versions[i] = ver.String()
2426 previous = ver
Jooyung Hanaed150d2020-04-02 01:41:41 +09002427 }
Jooyung Hanad4c1872020-02-27 17:56:44 +09002428}
2429
Jooyung Han61b66e92020-03-21 14:21:46 +00002430func createVersionVariations(mctx android.BottomUpMutatorContext, versions []string) {
Colin Cross127bb8b2020-12-16 16:46:01 -08002431 // "" is for the non-stubs (implementation) variant for system modules, or the LLNDK variant
2432 // for LLNDK modules.
Colin Cross0de8a1e2020-09-18 14:15:30 -07002433 variants := append(android.CopyOf(versions), "")
Jooyung Han61b66e92020-03-21 14:21:46 +00002434
Colin Cross127bb8b2020-12-16 16:46:01 -08002435 m := mctx.Module().(*Module)
2436 isLLNDK := m.IsLlndk()
Colin Cross5271fea2021-04-27 13:06:04 -07002437 isVendorPublicLibrary := m.IsVendorPublicLibrary()
Colin Cross127bb8b2020-12-16 16:46:01 -08002438
Colin Crossd1f898e2020-08-18 18:35:15 -07002439 modules := mctx.CreateLocalVariations(variants...)
Jooyung Han61b66e92020-03-21 14:21:46 +00002440 for i, m := range modules {
Colin Cross127bb8b2020-12-16 16:46:01 -08002441
Colin Cross5271fea2021-04-27 13:06:04 -07002442 if variants[i] != "" || isLLNDK || isVendorPublicLibrary {
Colin Cross127bb8b2020-12-16 16:46:01 -08002443 // A stubs or LLNDK stubs variant.
Colin Cross31076b32020-10-23 17:22:06 -07002444 c := m.(*Module)
Colin Cross31076b32020-10-23 17:22:06 -07002445 c.sanitize = nil
2446 c.stl = nil
2447 c.Properties.PreventInstall = true
2448 lib := moduleLibraryInterface(m)
Jiyong Parkd4a3a132021-03-17 20:21:35 +09002449 isLatest := i == (len(versions) - 1)
2450 lib.setBuildStubs(isLatest)
Colin Cross127bb8b2020-12-16 16:46:01 -08002451
2452 if variants[i] != "" {
2453 // A non-LLNDK stubs module is hidden from make and has a dependency from the
2454 // implementation module to the stubs module.
2455 c.Properties.HideFromMake = true
2456 lib.setStubsVersion(variants[i])
2457 mctx.AddInterVariantDependency(stubImplDepTag, modules[len(modules)-1], modules[i])
2458 }
Jooyung Han61b66e92020-03-21 14:21:46 +00002459 }
2460 }
Colin Cross094faa52020-08-06 17:38:25 -07002461 mctx.AliasVariation("")
Colin Crossd1f898e2020-08-18 18:35:15 -07002462 latestVersion := ""
2463 if len(versions) > 0 {
2464 latestVersion = versions[len(versions)-1]
2465 }
2466 mctx.CreateAliasVariation("latest", latestVersion)
Jooyung Han61b66e92020-03-21 14:21:46 +00002467}
2468
Colin Crossbbc941b2020-09-30 12:27:01 -07002469func createPerApiVersionVariations(mctx android.BottomUpMutatorContext, minSdkVersion string) {
2470 from, err := nativeApiLevelFromUser(mctx, minSdkVersion)
2471 if err != nil {
2472 mctx.PropertyErrorf("min_sdk_version", err.Error())
2473 return
2474 }
2475
2476 versionStrs := ndkLibraryVersions(mctx, from)
2477 modules := mctx.CreateLocalVariations(versionStrs...)
2478
2479 for i, module := range modules {
2480 module.(*Module).Properties.Sdk_version = StringPtr(versionStrs[i])
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09002481 module.(*Module).Properties.Min_sdk_version = StringPtr(versionStrs[i])
Colin Crossbbc941b2020-09-30 12:27:01 -07002482 }
2483}
2484
Liz Kammer23942242022-04-08 15:41:00 -04002485func canBeOrLinkAgainstVersionVariants(module interface {
Jooyung Han624d35c2020-04-10 12:57:24 +09002486 Host() bool
2487 InRamdisk() bool
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002488 InVendorRamdisk() bool
Jooyung Han624d35c2020-04-10 12:57:24 +09002489}) bool {
Jose Galmes6f843bc2020-12-11 13:36:29 -08002490 return !module.Host() && !module.InRamdisk() && !module.InVendorRamdisk()
Jooyung Han624d35c2020-04-10 12:57:24 +09002491}
2492
Liz Kammer23942242022-04-08 15:41:00 -04002493func canBeVersionVariant(module interface {
Colin Cross3146c5c2020-09-30 15:34:40 -07002494 Host() bool
2495 InRamdisk() bool
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002496 InVendorRamdisk() bool
Colin Cross3146c5c2020-09-30 15:34:40 -07002497 CcLibraryInterface() bool
2498 Shared() bool
Colin Cross3146c5c2020-09-30 15:34:40 -07002499}) bool {
Liz Kammer23942242022-04-08 15:41:00 -04002500 return canBeOrLinkAgainstVersionVariants(module) &&
Colin Crossa717db72020-10-23 14:53:06 -07002501 module.CcLibraryInterface() && module.Shared()
Colin Cross3146c5c2020-09-30 15:34:40 -07002502}
2503
Colin Cross127bb8b2020-12-16 16:46:01 -08002504func moduleLibraryInterface(module blueprint.Module) libraryInterface {
Colin Cross31076b32020-10-23 17:22:06 -07002505 if m, ok := module.(*Module); ok {
2506 return m.library
2507 }
2508 return nil
2509}
2510
Liz Kammer23942242022-04-08 15:41:00 -04002511// setStubsVersions normalizes the versions in the Stubs.Versions property into MutatedProperties.AllStubsVersions.
2512func setStubsVersions(mctx android.BottomUpMutatorContext, library libraryInterface, module *Module) {
2513 if !library.buildShared() || !canBeVersionVariant(module) {
2514 return
Colin Crossd1f898e2020-08-18 18:35:15 -07002515 }
Liz Kammer23942242022-04-08 15:41:00 -04002516 versions := library.stubsVersions(mctx)
2517 if len(versions) <= 0 {
2518 return
2519 }
2520 normalizeVersions(mctx, versions)
2521 if mctx.Failed() {
2522 return
2523 }
2524 // Set the versions on the pre-mutated module so they can be read by any llndk modules that
2525 // depend on the implementation library and haven't been mutated yet.
2526 library.setAllStubsVersions(versions)
Colin Crossd1f898e2020-08-18 18:35:15 -07002527}
Jooyung Han61b66e92020-03-21 14:21:46 +00002528
Colin Crossd1f898e2020-08-18 18:35:15 -07002529// versionMutator splits a module into the mandatory non-stubs variant
2530// (which is unnamed) and zero or more stubs variants.
2531func versionMutator(mctx android.BottomUpMutatorContext) {
Liz Kammer23942242022-04-08 15:41:00 -04002532 if mctx.Os() != android.Android {
2533 return
2534 }
2535
2536 m, ok := mctx.Module().(*Module)
2537 if library := moduleLibraryInterface(mctx.Module()); library != nil && canBeVersionVariant(m) {
2538 setStubsVersions(mctx, library, m)
2539
Colin Cross31076b32020-10-23 17:22:06 -07002540 createVersionVariations(mctx, library.allStubsVersions())
Colin Crossbbc941b2020-09-30 12:27:01 -07002541 return
2542 }
2543
Liz Kammer23942242022-04-08 15:41:00 -04002544 if ok {
Colin Crossbbc941b2020-09-30 12:27:01 -07002545 if m.SplitPerApiLevel() && m.IsSdkVariant() {
Colin Crossbbc941b2020-09-30 12:27:01 -07002546 createPerApiVersionVariations(mctx, m.MinSdkVersion())
2547 }
Jiyong Park7ed9de32018-10-15 22:25:07 +09002548 }
Jiyong Park7ed9de32018-10-15 22:25:07 +09002549}
Colin Crossd7227f92019-09-05 14:26:33 -07002550
2551// maybeInjectBoringSSLHash adds a rule to run bssl_inject_hash on the output file if the module has the
2552// inject_bssl_hash or if any static library dependencies have inject_bssl_hash set. It returns the output path
2553// that the linked output file should be written to.
2554// TODO(b/137267623): Remove this in favor of a cc_genrule when they support operating on shared libraries.
2555func maybeInjectBoringSSLHash(ctx android.ModuleContext, outputFile android.ModuleOutPath,
2556 inject *bool, fileName string) android.ModuleOutPath {
2557 // TODO(b/137267623): Remove this in favor of a cc_genrule when they support operating on shared libraries.
2558 injectBoringSSLHash := Bool(inject)
2559 ctx.VisitDirectDeps(func(dep android.Module) {
Colin Cross6e511a92020-07-27 21:26:48 -07002560 if tag, ok := ctx.OtherModuleDependencyTag(dep).(libraryDependencyTag); ok && tag.static() {
Colin Crossd7227f92019-09-05 14:26:33 -07002561 if cc, ok := dep.(*Module); ok {
2562 if library, ok := cc.linker.(*libraryDecorator); ok {
2563 if Bool(library.Properties.Inject_bssl_hash) {
2564 injectBoringSSLHash = true
2565 }
2566 }
2567 }
2568 }
2569 })
2570 if injectBoringSSLHash {
2571 hashedOutputfile := outputFile
2572 outputFile = android.PathForModuleOut(ctx, "unhashed", fileName)
2573
Colin Crossf1a035e2020-11-16 17:32:30 -08002574 rule := android.NewRuleBuilder(pctx, ctx)
Colin Crossd7227f92019-09-05 14:26:33 -07002575 rule.Command().
Colin Crossf1a035e2020-11-16 17:32:30 -08002576 BuiltTool("bssl_inject_hash").
Colin Crossd7227f92019-09-05 14:26:33 -07002577 FlagWithInput("-in-object ", outputFile).
2578 FlagWithOutput("-o ", hashedOutputfile)
Colin Crossf1a035e2020-11-16 17:32:30 -08002579 rule.Build("injectCryptoHash", "inject crypto hash")
Colin Crossd7227f92019-09-05 14:26:33 -07002580 }
2581
2582 return outputFile
2583}
Rupert Shuttleworth095081c2021-03-25 09:06:03 +00002584
Liz Kammerbe46fcc2021-11-01 15:32:43 -04002585func sharedOrStaticLibraryBp2Build(ctx android.TopDownMutatorContext, module *Module, isStatic bool) {
Liz Kammere6583482021-10-19 13:56:10 -04002586 baseAttributes := bp2BuildParseBaseProps(ctx, module)
2587 compilerAttrs := baseAttributes.compilerAttributes
2588 linkerAttrs := baseAttributes.linkerAttributes
2589
Liz Kammer54549442022-05-11 13:55:06 -04002590 exportedIncludes := bp2BuildParseExportedIncludes(ctx, module, &compilerAttrs.includes)
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002591
2592 // Append shared/static{} stanza properties. These won't be specified on
2593 // cc_library_* itself, but may be specified in cc_defaults that this module
2594 // depends on.
2595 libSharedOrStaticAttrs := bp2BuildParseLibProps(ctx, module, isStatic)
2596
2597 compilerAttrs.srcs.Append(libSharedOrStaticAttrs.Srcs)
2598 compilerAttrs.cSrcs.Append(libSharedOrStaticAttrs.Srcs_c)
2599 compilerAttrs.asSrcs.Append(libSharedOrStaticAttrs.Srcs_as)
2600 compilerAttrs.copts.Append(libSharedOrStaticAttrs.Copts)
Liz Kammer7a210ac2021-09-22 15:52:58 -04002601
2602 linkerAttrs.deps.Append(libSharedOrStaticAttrs.Deps)
2603 linkerAttrs.implementationDeps.Append(libSharedOrStaticAttrs.Implementation_deps)
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002604 linkerAttrs.dynamicDeps.Append(libSharedOrStaticAttrs.Dynamic_deps)
Liz Kammer7a210ac2021-09-22 15:52:58 -04002605 linkerAttrs.implementationDynamicDeps.Append(libSharedOrStaticAttrs.Implementation_dynamic_deps)
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002606 linkerAttrs.systemDynamicDeps.Append(libSharedOrStaticAttrs.System_dynamic_deps)
2607
2608 asFlags := compilerAttrs.asFlags
2609 if compilerAttrs.asSrcs.IsEmpty() {
2610 // Skip asflags for BUILD file simplicity if there are no assembly sources.
2611 asFlags = bazel.MakeStringListAttribute(nil)
2612 }
2613
Liz Kammer7a210ac2021-09-22 15:52:58 -04002614 commonAttrs := staticOrSharedAttributes{
2615 Srcs: compilerAttrs.srcs,
2616 Srcs_c: compilerAttrs.cSrcs,
2617 Srcs_as: compilerAttrs.asSrcs,
2618 Copts: compilerAttrs.copts,
Liz Kammere6583482021-10-19 13:56:10 -04002619 Hdrs: compilerAttrs.hdrs,
Liz Kammer7a210ac2021-09-22 15:52:58 -04002620
Liz Kammer12615db2021-09-28 09:19:17 -04002621 Deps: linkerAttrs.deps,
2622 Implementation_deps: linkerAttrs.implementationDeps,
2623 Dynamic_deps: linkerAttrs.dynamicDeps,
2624 Implementation_dynamic_deps: linkerAttrs.implementationDynamicDeps,
2625 Whole_archive_deps: linkerAttrs.wholeArchiveDeps,
2626 Implementation_whole_archive_deps: linkerAttrs.implementationWholeArchiveDeps,
2627 System_dynamic_deps: linkerAttrs.systemDynamicDeps,
Yu Liufc603162022-03-01 15:44:08 -08002628 sdkAttributes: bp2BuildParseSdkAttributes(module),
Cole Faust6b29f592022-08-09 09:50:56 -07002629 Runtime_deps: linkerAttrs.runtimeDeps,
Liz Kammer7a210ac2021-09-22 15:52:58 -04002630 }
2631
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002632 var attrs interface{}
2633 if isStatic {
Liz Kammer12615db2021-09-28 09:19:17 -04002634 commonAttrs.Deps.Add(baseAttributes.protoDependency)
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002635 attrs = &bazelCcLibraryStaticAttributes{
Liz Kammer7a210ac2021-09-22 15:52:58 -04002636 staticOrSharedAttributes: commonAttrs,
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002637
Rupert Shuttleworth484aa252021-12-10 07:22:53 -05002638 Use_libcrt: linkerAttrs.useLibcrt,
2639 Use_version_lib: linkerAttrs.useVersionLib,
2640
Liz Kammer1263d9b2021-12-10 14:28:20 -05002641 Rtti: compilerAttrs.rtti,
2642 Stl: compilerAttrs.stl,
2643 Cpp_std: compilerAttrs.cppStd,
2644 C_std: compilerAttrs.cStd,
2645
2646 Export_includes: exportedIncludes.Includes,
2647 Export_absolute_includes: exportedIncludes.AbsoluteIncludes,
2648 Export_system_includes: exportedIncludes.SystemIncludes,
2649 Local_includes: compilerAttrs.localIncludes,
2650 Absolute_includes: compilerAttrs.absoluteIncludes,
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002651
2652 Cppflags: compilerAttrs.cppFlags,
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002653 Conlyflags: compilerAttrs.conlyFlags,
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002654 Asflags: asFlags,
Liz Kammer0eae52e2021-10-06 10:32:26 -04002655
Cole Faust5fa4e962022-08-22 14:31:04 -07002656 Features: baseAttributes.features,
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002657 }
2658 } else {
Liz Kammer12615db2021-09-28 09:19:17 -04002659 commonAttrs.Dynamic_deps.Add(baseAttributes.protoDependency)
2660
Wei Li81852ca2022-07-27 00:22:06 -07002661 sharedLibAttrs := &bazelCcLibrarySharedAttributes{
Liz Kammer7a210ac2021-09-22 15:52:58 -04002662 staticOrSharedAttributes: commonAttrs,
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002663
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002664 Cppflags: compilerAttrs.cppFlags,
2665 Conlyflags: compilerAttrs.conlyFlags,
2666 Asflags: asFlags,
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002667
Rupert Shuttleworth484aa252021-12-10 07:22:53 -05002668 Linkopts: linkerAttrs.linkopts,
2669 Link_crt: linkerAttrs.linkCrt,
2670 Use_libcrt: linkerAttrs.useLibcrt,
2671 Use_version_lib: linkerAttrs.useVersionLib,
2672
2673 Rtti: compilerAttrs.rtti,
2674 Stl: compilerAttrs.stl,
2675 Cpp_std: compilerAttrs.cppStd,
2676 C_std: compilerAttrs.cStd,
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002677
Liz Kammerd2871182021-10-04 13:54:37 -04002678 Export_includes: exportedIncludes.Includes,
Liz Kammer1263d9b2021-12-10 14:28:20 -05002679 Export_absolute_includes: exportedIncludes.AbsoluteIncludes,
Liz Kammerd2871182021-10-04 13:54:37 -04002680 Export_system_includes: exportedIncludes.SystemIncludes,
2681 Local_includes: compilerAttrs.localIncludes,
2682 Absolute_includes: compilerAttrs.absoluteIncludes,
2683 Additional_linker_inputs: linkerAttrs.additionalLinkerInputs,
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002684
2685 Strip: stripAttributes{
2686 Keep_symbols: linkerAttrs.stripKeepSymbols,
2687 Keep_symbols_and_debug_frame: linkerAttrs.stripKeepSymbolsAndDebugFrame,
2688 Keep_symbols_list: linkerAttrs.stripKeepSymbolsList,
2689 All: linkerAttrs.stripAll,
2690 None: linkerAttrs.stripNone,
2691 },
Liz Kammer0eae52e2021-10-06 10:32:26 -04002692
Cole Faust5fa4e962022-08-22 14:31:04 -07002693 Features: baseAttributes.features,
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxa56e9702022-02-23 18:39:59 -05002694
2695 Suffix: compilerAttrs.suffix,
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002696 }
Wei Li81852ca2022-07-27 00:22:06 -07002697 if compilerAttrs.stubsSymbolFile != nil && len(compilerAttrs.stubsVersions.Value) > 0 {
2698 hasStubs := true
2699 sharedLibAttrs.Has_stubs.SetValue(&hasStubs)
2700 }
2701 attrs = sharedLibAttrs
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002702 }
2703
Liz Kammerbe46fcc2021-11-01 15:32:43 -04002704 var modType string
2705 if isStatic {
2706 modType = "cc_library_static"
2707 } else {
2708 modType = "cc_library_shared"
2709 }
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002710 props := bazel.BazelTargetModuleProperties{
2711 Rule_class: modType,
Liz Kammer2b376bc2022-01-12 12:00:49 -05002712 Bzl_load_location: fmt.Sprintf("//build/bazel/rules/cc:%s.bzl", modType),
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002713 }
2714
Alex Márquez Pérez Muñíz Díaz Púras Thaureaux447f6c92021-08-31 20:30:36 +00002715 ctx.CreateBazelTargetModule(props, android.CommonAttributes{Name: module.Name()}, attrs)
Trevor Radcliffe087af542022-09-16 15:36:10 +00002716
2717 createStubsBazelTargetIfNeeded(ctx, module, compilerAttrs, exportedIncludes, baseAttributes)
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002718}
2719
2720// TODO(b/199902614): Can this be factored to share with the other Attributes?
Rupert Shuttleworth095081c2021-03-25 09:06:03 +00002721type bazelCcLibraryStaticAttributes struct {
Liz Kammer7a210ac2021-09-22 15:52:58 -04002722 staticOrSharedAttributes
2723
Rupert Shuttleworth484aa252021-12-10 07:22:53 -05002724 Use_libcrt bazel.BoolAttribute
2725 Use_version_lib bazel.BoolAttribute
2726
2727 Rtti bazel.BoolAttribute
2728 Stl *string
2729 Cpp_std *string
2730 C_std *string
Liz Kammer7a210ac2021-09-22 15:52:58 -04002731
Liz Kammer1263d9b2021-12-10 14:28:20 -05002732 Export_includes bazel.StringListAttribute
2733 Export_absolute_includes bazel.StringListAttribute
2734 Export_system_includes bazel.StringListAttribute
2735 Local_includes bazel.StringListAttribute
2736 Absolute_includes bazel.StringListAttribute
2737 Hdrs bazel.LabelListAttribute
Chris Parsons990c4f42021-05-25 12:10:58 -04002738
2739 Cppflags bazel.StringListAttribute
Chris Parsons990c4f42021-05-25 12:10:58 -04002740 Conlyflags bazel.StringListAttribute
Chris Parsons990c4f42021-05-25 12:10:58 -04002741 Asflags bazel.StringListAttribute
Liz Kammer0eae52e2021-10-06 10:32:26 -04002742
2743 Features bazel.StringListAttribute
Jingwen Chen179856a2021-05-03 09:15:48 +00002744}
2745
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002746// TODO(b/199902614): Can this be factored to share with the other Attributes?
2747type bazelCcLibrarySharedAttributes struct {
Liz Kammer7a210ac2021-09-22 15:52:58 -04002748 staticOrSharedAttributes
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002749
Rupert Shuttleworth484aa252021-12-10 07:22:53 -05002750 Linkopts bazel.StringListAttribute
2751 Link_crt bazel.BoolAttribute // Only for linking shared library (and cc_binary)
2752
2753 Use_libcrt bazel.BoolAttribute
2754 Use_version_lib bazel.BoolAttribute
2755
2756 Rtti bazel.BoolAttribute
2757 Stl *string
2758 Cpp_std *string
2759 C_std *string
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002760
Liz Kammer1263d9b2021-12-10 14:28:20 -05002761 Export_includes bazel.StringListAttribute
2762 Export_absolute_includes bazel.StringListAttribute
2763 Export_system_includes bazel.StringListAttribute
2764 Local_includes bazel.StringListAttribute
2765 Absolute_includes bazel.StringListAttribute
2766 Hdrs bazel.LabelListAttribute
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002767
Liz Kammerd2871182021-10-04 13:54:37 -04002768 Strip stripAttributes
2769 Additional_linker_inputs bazel.LabelListAttribute
Liz Kammer7a210ac2021-09-22 15:52:58 -04002770
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002771 Cppflags bazel.StringListAttribute
2772 Conlyflags bazel.StringListAttribute
2773 Asflags bazel.StringListAttribute
Liz Kammer0eae52e2021-10-06 10:32:26 -04002774
2775 Features bazel.StringListAttribute
Jingwen Chen0ee88a62022-01-07 14:55:29 +00002776
Wei Li81852ca2022-07-27 00:22:06 -07002777 Has_stubs bazel.BoolAttribute
2778
2779 Inject_bssl_hash bazel.BoolAttribute
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxa56e9702022-02-23 18:39:59 -05002780
2781 Suffix bazel.StringAttribute
Wei Li81852ca2022-07-27 00:22:06 -07002782}
2783
2784type bazelCcStubSuiteAttributes struct {
2785 Symbol_file *string
2786 Versions bazel.StringListAttribute
2787 Export_includes bazel.StringListAttribute
2788 Source_library bazel.LabelAttribute
2789 Soname *string
2790 Deps bazel.LabelListAttribute
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002791}