blob: 5720944ab592eccaee14491852aae930e0514eb2 [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
Chris Parsons3c27ca32020-11-20 12:42:07 -050035// LibraryProperties is a collection of properties shared by cc library rules.
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
Logan Chiene3d7a0d2019-01-17 00:18:02 +0800113 }
Vic Yang6cd1be82019-06-24 16:08:48 -0700114
Pete Bentley803e1612019-08-06 22:19:59 +0100115 // Inject boringssl hash into the shared library. This is only intended for use by external/boringssl.
116 Inject_bssl_hash *bool `android:"arch_variant"`
Colin Cross0477b422020-10-13 18:43:54 -0700117
Colin Cross127bb8b2020-12-16 16:46:01 -0800118 // If this is an LLNDK library, properties to describe the LLNDK stubs. Will be copied from
119 // the module pointed to by llndk_stubs if it is set.
120 Llndk llndkLibraryProperties
Colin Cross5271fea2021-04-27 13:06:04 -0700121
122 // If this is a vendor public library, properties to describe the vendor public library stubs.
123 Vendor_public_library vendorPublicLibraryProperties
Colin Crossa48ab5b2017-02-14 15:28:44 -0800124}
Colin Cross0c461f12016-10-20 16:11:43 -0700125
Chris Parsons3c27ca32020-11-20 12:42:07 -0500126// StaticProperties is a properties stanza to affect only attributes of the "static" variants of a
127// library module.
Colin Crosse1bb5d02019-09-24 14:55:04 -0700128type StaticProperties struct {
129 Static StaticOrSharedProperties `android:"arch_variant"`
130}
131
Chris Parsons3c27ca32020-11-20 12:42:07 -0500132// SharedProperties is a properties stanza to affect only attributes of the "shared" variants of a
133// library module.
Colin Crosse1bb5d02019-09-24 14:55:04 -0700134type SharedProperties struct {
135 Shared StaticOrSharedProperties `android:"arch_variant"`
136}
137
Chris Parsons3c27ca32020-11-20 12:42:07 -0500138// StaticOrSharedProperties is an embedded struct representing properties to affect attributes of
139// either only the "static" variants or only the "shared" variants of a library module. These override
140// the base properties of the same name.
141// Use `StaticProperties` or `SharedProperties`, depending on which variant is needed.
142// `StaticOrSharedProperties` exists only to avoid duplication.
Colin Crosse1bb5d02019-09-24 14:55:04 -0700143type StaticOrSharedProperties struct {
Evgenii Stepanov2080bfe2020-07-24 15:35:40 -0700144 Srcs []string `android:"path,arch_variant"`
145
Chih-Hung Hsieh769a51c2021-09-17 17:18:39 -0700146 Tidy_disabled_srcs []string `android:"path,arch_variant"`
147
Evgenii Stepanov2080bfe2020-07-24 15:35:40 -0700148 Sanitized Sanitized `android:"arch_variant"`
149
Colin Crosse1bb5d02019-09-24 14:55:04 -0700150 Cflags []string `android:"arch_variant"`
151
Colin Cross6b8f4252021-07-22 11:39:44 -0700152 Enabled *bool `android:"arch_variant"`
153 Whole_static_libs []string `android:"arch_variant"`
154 Static_libs []string `android:"arch_variant"`
155 Shared_libs []string `android:"arch_variant"`
156 System_shared_libs []string `android:"arch_variant"`
Colin Crosse1bb5d02019-09-24 14:55:04 -0700157
158 Export_shared_lib_headers []string `android:"arch_variant"`
159 Export_static_lib_headers []string `android:"arch_variant"`
Jiyong Parka90ca002019-10-07 15:47:24 +0900160
161 Apex_available []string `android:"arch_variant"`
Colin Cross1bc94122021-10-28 13:25:54 -0700162
163 Installable *bool `android:"arch_variant"`
Colin Crosse1bb5d02019-09-24 14:55:04 -0700164}
165
Colin Crossa48ab5b2017-02-14 15:28:44 -0800166type LibraryMutatedProperties struct {
Colin Crossb916a382016-07-29 17:28:03 -0700167 // Build a static variant
168 BuildStatic bool `blueprint:"mutated"`
169 // Build a shared variant
170 BuildShared bool `blueprint:"mutated"`
171 // This variant is shared
172 VariantIsShared bool `blueprint:"mutated"`
173 // This variant is static
174 VariantIsStatic bool `blueprint:"mutated"`
Jiyong Park7ed9de32018-10-15 22:25:07 +0900175
176 // This variant is a stubs lib
177 BuildStubs bool `blueprint:"mutated"`
Jiyong Parkd4a3a132021-03-17 20:21:35 +0900178 // This variant is the latest version
179 IsLatestVersion bool `blueprint:"mutated"`
Jiyong Park7ed9de32018-10-15 22:25:07 +0900180 // Version of the stubs lib
181 StubsVersion string `blueprint:"mutated"`
Colin Crossd1f898e2020-08-18 18:35:15 -0700182 // List of all stubs versions associated with an implementation lib
183 AllStubsVersions []string `blueprint:"mutated"`
Colin Crossb916a382016-07-29 17:28:03 -0700184}
185
186type FlagExporterProperties struct {
187 // list of directories relative to the Blueprints file that will
Dan Willemsen273af7f2016-11-03 15:53:42 -0700188 // be added to the include path (using -I) for this module and any module that links
Colin Cross5d195602017-10-17 16:15:50 -0700189 // against this module. Directories listed in export_include_dirs do not need to be
190 // listed in local_include_dirs.
Colin Cross0ed579e2021-06-29 00:51:12 +0000191 Export_include_dirs []string `android:"arch_variant,variant_prepend"`
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700192
Jiyong Park73c54ee2019-10-22 20:31:18 +0900193 // list of directories that will be added to the system include path
194 // using -isystem for this module and any module that links against this module.
Colin Cross0ed579e2021-06-29 00:51:12 +0000195 Export_system_include_dirs []string `android:"arch_variant,variant_prepend"`
Jiyong Park73c54ee2019-10-22 20:31:18 +0900196
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700197 Target struct {
Justin Yun63e9ec72020-10-29 16:49:43 +0900198 Vendor, Product struct {
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700199 // list of exported include directories, like
Justin Yun63e9ec72020-10-29 16:49:43 +0900200 // export_include_dirs, that will be applied to
201 // vendor or product variant of this library.
202 // This will overwrite any other declarations.
Steven Morelandb21df8f2018-01-05 14:42:54 -0800203 Override_export_include_dirs []string
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700204 }
205 }
Colin Cross4d9c2d12016-07-29 12:48:20 -0700206}
207
208func init() {
Paul Duffin6c26dc72019-12-19 15:02:40 +0000209 RegisterLibraryBuildComponents(android.InitRegistrationContext)
210}
211
212func RegisterLibraryBuildComponents(ctx android.RegistrationContext) {
213 ctx.RegisterModuleType("cc_library_static", LibraryStaticFactory)
214 ctx.RegisterModuleType("cc_library_shared", LibrarySharedFactory)
215 ctx.RegisterModuleType("cc_library", LibraryFactory)
216 ctx.RegisterModuleType("cc_library_host_static", LibraryHostStaticFactory)
217 ctx.RegisterModuleType("cc_library_host_shared", LibraryHostSharedFactory)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700218}
219
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +0000220// TODO(b/199902614): Can this be factored to share with the other Attributes?
Jingwen Chen63930982021-03-24 10:04:33 -0400221// For bp2build conversion.
222type bazelCcLibraryAttributes struct {
Chris Parsons08648312021-05-06 16:23:19 -0400223 // Attributes pertaining to both static and shared variants.
Jingwen Chen14a8bda2021-06-02 11:10:02 +0000224 Srcs bazel.LabelListAttribute
225 Srcs_c bazel.LabelListAttribute
226 Srcs_as bazel.LabelListAttribute
227
228 Copts bazel.StringListAttribute
229 Cppflags bazel.StringListAttribute
230 Conlyflags bazel.StringListAttribute
231 Asflags bazel.StringListAttribute
232
Liz Kammer7a210ac2021-09-22 15:52:58 -0400233 Hdrs bazel.LabelListAttribute
234
Liz Kammer12615db2021-09-28 09:19:17 -0400235 Deps bazel.LabelListAttribute
236 Implementation_deps bazel.LabelListAttribute
237 Dynamic_deps bazel.LabelListAttribute
238 Implementation_dynamic_deps bazel.LabelListAttribute
239 Whole_archive_deps bazel.LabelListAttribute
240 Implementation_whole_archive_deps bazel.LabelListAttribute
241 System_dynamic_deps bazel.LabelListAttribute
Liz Kammer7a210ac2021-09-22 15:52:58 -0400242
Liz Kammer5fad5012021-09-09 14:08:21 -0400243 Export_includes bazel.StringListAttribute
244 Export_system_includes bazel.StringListAttribute
Liz Kammer35687bc2021-09-10 10:07:07 -0400245 Local_includes bazel.StringListAttribute
246 Absolute_includes bazel.StringListAttribute
Liz Kammer5fad5012021-09-09 14:08:21 -0400247 Linkopts bazel.StringListAttribute
248 Use_libcrt bazel.BoolAttribute
249 Rtti bazel.BoolAttribute
Jingwen Chen5b11ab12021-10-11 17:44:33 +0000250
251 Stl *string
252 Cpp_std *string
Chris Parsons79bd2b72021-11-29 17:52:41 -0500253 C_std *string
Chris Parsons990c4f42021-05-25 12:10:58 -0400254
Jingwen Chenc4dc9b42021-06-11 12:51:48 +0000255 // This is shared only.
Liz Kammerd2871182021-10-04 13:54:37 -0400256 Link_crt bazel.BoolAttribute
257 Additional_linker_inputs bazel.LabelListAttribute
Jingwen Chen14a8bda2021-06-02 11:10:02 +0000258
Jingwen Chenc4dc9b42021-06-11 12:51:48 +0000259 // Common properties shared between both shared and static variants.
260 Shared staticOrSharedAttributes
261 Static staticOrSharedAttributes
Jingwen Chen3d383bb2021-06-09 07:18:37 +0000262
263 Strip stripAttributes
Liz Kammer0eae52e2021-10-06 10:32:26 -0400264
265 Features bazel.StringListAttribute
Jingwen Chen3d383bb2021-06-09 07:18:37 +0000266}
267
268type stripAttributes struct {
269 Keep_symbols bazel.BoolAttribute
270 Keep_symbols_and_debug_frame bazel.BoolAttribute
271 Keep_symbols_list bazel.StringListAttribute
272 All bazel.BoolAttribute
273 None bazel.BoolAttribute
Jingwen Chen63930982021-03-24 10:04:33 -0400274}
275
Liz Kammerbe46fcc2021-11-01 15:32:43 -0400276func libraryBp2Build(ctx android.TopDownMutatorContext, m *Module) {
Jingwen Chen179856a2021-05-03 09:15:48 +0000277 // For some cc_library modules, their static variants are ready to be
278 // converted, but not their shared variants. For these modules, delegate to
279 // the cc_library_static bp2build converter temporarily instead.
Chris Parsons953b3562021-09-20 15:14:39 -0400280 if android.GenerateCcLibraryStaticOnly(ctx.Module().Name()) {
Liz Kammerbe46fcc2021-11-01 15:32:43 -0400281 sharedOrStaticLibraryBp2Build(ctx, m, true)
Jingwen Chen179856a2021-05-03 09:15:48 +0000282 return
283 }
284
Jingwen Chen53681ef2021-04-29 08:15:13 +0000285 sharedAttrs := bp2BuildParseSharedProps(ctx, m)
286 staticAttrs := bp2BuildParseStaticProps(ctx, m)
Liz Kammere6583482021-10-19 13:56:10 -0400287 baseAttributes := bp2BuildParseBaseProps(ctx, m)
288 compilerAttrs := baseAttributes.compilerAttributes
289 linkerAttrs := baseAttributes.linkerAttributes
Liz Kammer1263d9b2021-12-10 14:28:20 -0500290 exportedIncludes := bp2BuildParseExportedIncludes(ctx, m, compilerAttrs.includes)
Jingwen Chen63930982021-03-24 10:04:33 -0400291
Liz Kammer9abd62d2021-05-21 08:37:59 -0400292 srcs := compilerAttrs.srcs
Jingwen Chen53681ef2021-04-29 08:15:13 +0000293
Liz Kammer12615db2021-09-28 09:19:17 -0400294 sharedAttrs.Dynamic_deps.Add(baseAttributes.protoDependency)
295 staticAttrs.Deps.Add(baseAttributes.protoDependency)
296
Chris Parsons69fa9f92021-07-13 11:47:44 -0400297 asFlags := compilerAttrs.asFlags
298 if compilerAttrs.asSrcs.IsEmpty() && sharedAttrs.Srcs_as.IsEmpty() && staticAttrs.Srcs_as.IsEmpty() {
299 // Skip asflags for BUILD file simplicity if there are no assembly sources.
300 asFlags = bazel.MakeStringListAttribute(nil)
301 }
302
Chris Parsons77acf2e2021-12-03 17:27:16 -0500303 staticCommonAttrs := staticOrSharedAttributes{
304 Srcs: *srcs.Clone().Append(staticAttrs.Srcs),
305 Srcs_c: *compilerAttrs.cSrcs.Clone().Append(staticAttrs.Srcs_c),
306 Srcs_as: *compilerAttrs.asSrcs.Clone().Append(staticAttrs.Srcs_as),
307 Copts: *compilerAttrs.copts.Clone().Append(staticAttrs.Copts),
308 Hdrs: *compilerAttrs.hdrs.Clone().Append(staticAttrs.Hdrs),
Jingwen Chen14a8bda2021-06-02 11:10:02 +0000309
Chris Parsons77acf2e2021-12-03 17:27:16 -0500310 Deps: *linkerAttrs.deps.Clone().Append(staticAttrs.Deps),
311 Implementation_deps: *linkerAttrs.implementationDeps.Clone().Append(staticAttrs.Implementation_deps),
312 Dynamic_deps: *linkerAttrs.dynamicDeps.Clone().Append(staticAttrs.Dynamic_deps),
313 Implementation_dynamic_deps: *linkerAttrs.implementationDynamicDeps.Clone().Append(staticAttrs.Implementation_dynamic_deps),
314 Implementation_whole_archive_deps: linkerAttrs.implementationWholeArchiveDeps,
315 Whole_archive_deps: *linkerAttrs.wholeArchiveDeps.Clone().Append(staticAttrs.Whole_archive_deps),
316 System_dynamic_deps: *linkerAttrs.systemDynamicDeps.Clone().Append(staticAttrs.System_dynamic_deps),
317 }
318
319 sharedCommonAttrs := staticOrSharedAttributes{
320 Srcs: *srcs.Clone().Append(sharedAttrs.Srcs),
321 Srcs_c: *compilerAttrs.cSrcs.Clone().Append(sharedAttrs.Srcs_c),
322 Srcs_as: *compilerAttrs.asSrcs.Clone().Append(sharedAttrs.Srcs_as),
323 Copts: *compilerAttrs.copts.Clone().Append(sharedAttrs.Copts),
324 Hdrs: *compilerAttrs.hdrs.Clone().Append(sharedAttrs.Hdrs),
325
326 Deps: *linkerAttrs.deps.Clone().Append(sharedAttrs.Deps),
327 Implementation_deps: *linkerAttrs.implementationDeps.Clone().Append(sharedAttrs.Implementation_deps),
328 Dynamic_deps: *linkerAttrs.dynamicDeps.Clone().Append(sharedAttrs.Dynamic_deps),
329 Implementation_dynamic_deps: *linkerAttrs.implementationDynamicDeps.Clone().Append(sharedAttrs.Implementation_dynamic_deps),
330 Whole_archive_deps: *linkerAttrs.wholeArchiveDeps.Clone().Append(sharedAttrs.Whole_archive_deps),
331 System_dynamic_deps: *linkerAttrs.systemDynamicDeps.Clone().Append(sharedAttrs.System_dynamic_deps),
332 }
333
334 staticTargetAttrs := &bazelCcLibraryStaticAttributes{
335 staticOrSharedAttributes: staticCommonAttrs,
336
Jingwen Chen14a8bda2021-06-02 11:10:02 +0000337 Cppflags: compilerAttrs.cppFlags,
338 Conlyflags: compilerAttrs.conlyFlags,
Chris Parsons69fa9f92021-07-13 11:47:44 -0400339 Asflags: asFlags,
Jingwen Chen14a8bda2021-06-02 11:10:02 +0000340
Liz Kammer1263d9b2021-12-10 14:28:20 -0500341 Export_includes: exportedIncludes.Includes,
342 Export_absolute_includes: exportedIncludes.AbsoluteIncludes,
343 Export_system_includes: exportedIncludes.SystemIncludes,
344 Local_includes: compilerAttrs.localIncludes,
345 Absolute_includes: compilerAttrs.absoluteIncludes,
346 Use_libcrt: linkerAttrs.useLibcrt,
347 Rtti: compilerAttrs.rtti,
348 Stl: compilerAttrs.stl,
349 Cpp_std: compilerAttrs.cppStd,
350 C_std: compilerAttrs.cStd,
Chris Parsons77acf2e2021-12-03 17:27:16 -0500351
352 Features: linkerAttrs.features,
353 }
354
355 sharedTargetAttrs := &bazelCcLibrarySharedAttributes{
356 staticOrSharedAttributes: sharedCommonAttrs,
357 Cppflags: compilerAttrs.cppFlags,
358 Conlyflags: compilerAttrs.conlyFlags,
359 Asflags: asFlags,
360
Liz Kammer1263d9b2021-12-10 14:28:20 -0500361 Export_includes: exportedIncludes.Includes,
362 Export_absolute_includes: exportedIncludes.AbsoluteIncludes,
363 Export_system_includes: exportedIncludes.SystemIncludes,
364 Local_includes: compilerAttrs.localIncludes,
365 Absolute_includes: compilerAttrs.absoluteIncludes,
366 Linkopts: linkerAttrs.linkopts,
367 Link_crt: linkerAttrs.linkCrt,
368 Use_libcrt: linkerAttrs.useLibcrt,
369 Rtti: compilerAttrs.rtti,
370 Stl: compilerAttrs.stl,
371 Cpp_std: compilerAttrs.cppStd,
372 C_std: compilerAttrs.cStd,
Chris Parsons990c4f42021-05-25 12:10:58 -0400373
Liz Kammerd2871182021-10-04 13:54:37 -0400374 Additional_linker_inputs: linkerAttrs.additionalLinkerInputs,
Jingwen Chenc4dc9b42021-06-11 12:51:48 +0000375
Jingwen Chen3d383bb2021-06-09 07:18:37 +0000376 Strip: stripAttributes{
377 Keep_symbols: linkerAttrs.stripKeepSymbols,
378 Keep_symbols_and_debug_frame: linkerAttrs.stripKeepSymbolsAndDebugFrame,
379 Keep_symbols_list: linkerAttrs.stripKeepSymbolsList,
380 All: linkerAttrs.stripAll,
381 None: linkerAttrs.stripNone,
382 },
Liz Kammer0eae52e2021-10-06 10:32:26 -0400383 Features: linkerAttrs.features,
Jingwen Chen63930982021-03-24 10:04:33 -0400384 }
385
Chris Parsons77acf2e2021-12-03 17:27:16 -0500386 staticProps := bazel.BazelTargetModuleProperties{
387 Rule_class: "cc_library_static",
388 Bzl_load_location: "//build/bazel/rules:cc_library_static.bzl",
389 }
390 sharedProps := bazel.BazelTargetModuleProperties{
391 Rule_class: "cc_library_shared",
392 Bzl_load_location: "//build/bazel/rules:cc_library_shared.bzl",
Jingwen Chen63930982021-03-24 10:04:33 -0400393 }
394
Chris Parsons58852a02021-12-09 18:10:18 -0500395 ctx.CreateBazelTargetModuleWithRestrictions(staticProps,
396 android.CommonAttributes{Name: m.Name() + "_bp2build_cc_library_static"},
397 staticTargetAttrs, staticAttrs.Enabled)
398 ctx.CreateBazelTargetModuleWithRestrictions(sharedProps,
399 android.CommonAttributes{Name: m.Name()},
400 sharedTargetAttrs, sharedAttrs.Enabled)
Jingwen Chen63930982021-03-24 10:04:33 -0400401}
402
Patrice Arruda83c89e02019-03-25 15:32:39 -0700403// cc_library creates both static and/or shared libraries for a device and/or
404// host. By default, a cc_library has a single variant that targets the device.
405// Specifying `host_supported: true` also creates a library that targets the
406// host.
Steven Morelandf9e62162017-11-02 17:00:50 -0700407func LibraryFactory() android.Module {
Colin Crossab3b7322016-12-09 14:46:15 -0800408 module, _ := NewLibrary(android.HostAndDeviceSupported)
Paul Duffina0843f62019-12-13 19:50:38 +0000409 // Can be used as both a static and a shared library.
410 module.sdkMemberTypes = []android.SdkMemberType{
411 sharedLibrarySdkMemberType,
412 staticLibrarySdkMemberType,
Paul Duffin9b76c0b2020-03-12 10:24:35 +0000413 staticAndSharedLibrarySdkMemberType,
Paul Duffina0843f62019-12-13 19:50:38 +0000414 }
Liz Kammerbe46fcc2021-11-01 15:32:43 -0400415 module.bazelable = true
Chris Parsonsbcc9b882021-06-03 11:16:27 -0400416 module.bazelHandler = &ccLibraryBazelHandler{module: module}
Colin Cross4d9c2d12016-07-29 12:48:20 -0700417 return module.Init()
418}
419
Patrice Arruda83c89e02019-03-25 15:32:39 -0700420// cc_library_static creates a static library for a device and/or host binary.
Steven Morelandf9e62162017-11-02 17:00:50 -0700421func LibraryStaticFactory() android.Module {
Colin Crossab3b7322016-12-09 14:46:15 -0800422 module, library := NewLibrary(android.HostAndDeviceSupported)
423 library.BuildOnlyStatic()
Paul Duffina0843f62019-12-13 19:50:38 +0000424 module.sdkMemberTypes = []android.SdkMemberType{staticLibrarySdkMemberType}
Liz Kammerbe46fcc2021-11-01 15:32:43 -0400425 module.bazelable = true
Chris Parsonsbcc9b882021-06-03 11:16:27 -0400426 module.bazelHandler = &ccLibraryBazelHandler{module: module}
Colin Cross4d9c2d12016-07-29 12:48:20 -0700427 return module.Init()
428}
429
Patrice Arruda83c89e02019-03-25 15:32:39 -0700430// cc_library_shared creates a shared library for a device and/or host.
Steven Morelandf9e62162017-11-02 17:00:50 -0700431func LibrarySharedFactory() android.Module {
Colin Crossab3b7322016-12-09 14:46:15 -0800432 module, library := NewLibrary(android.HostAndDeviceSupported)
433 library.BuildOnlyShared()
Paul Duffina0843f62019-12-13 19:50:38 +0000434 module.sdkMemberTypes = []android.SdkMemberType{sharedLibrarySdkMemberType}
Liz Kammerbe46fcc2021-11-01 15:32:43 -0400435 module.bazelable = true
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxbc4e7342021-09-14 20:58:25 +0000436 module.bazelHandler = &ccLibraryBazelHandler{module: module}
Colin Cross4d9c2d12016-07-29 12:48:20 -0700437 return module.Init()
438}
439
Patrice Arruda83c89e02019-03-25 15:32:39 -0700440// cc_library_host_static creates a static library that is linkable to a host
441// binary.
Steven Morelandf9e62162017-11-02 17:00:50 -0700442func LibraryHostStaticFactory() android.Module {
Colin Crossab3b7322016-12-09 14:46:15 -0800443 module, library := NewLibrary(android.HostSupported)
444 library.BuildOnlyStatic()
Paul Duffina0843f62019-12-13 19:50:38 +0000445 module.sdkMemberTypes = []android.SdkMemberType{staticLibrarySdkMemberType}
Colin Cross4d9c2d12016-07-29 12:48:20 -0700446 return module.Init()
447}
448
Patrice Arruda83c89e02019-03-25 15:32:39 -0700449// cc_library_host_shared creates a shared library that is usable on a host.
Steven Morelandf9e62162017-11-02 17:00:50 -0700450func LibraryHostSharedFactory() android.Module {
Colin Crossab3b7322016-12-09 14:46:15 -0800451 module, library := NewLibrary(android.HostSupported)
452 library.BuildOnlyShared()
Paul Duffina0843f62019-12-13 19:50:38 +0000453 module.sdkMemberTypes = []android.SdkMemberType{sharedLibrarySdkMemberType}
Wei Libafb6d62021-12-10 03:14:59 -0800454 module.bazelable = true
455 module.bazelHandler = &ccLibraryBazelHandler{module: module}
Colin Cross4d9c2d12016-07-29 12:48:20 -0700456 return module.Init()
457}
458
Chris Parsons3c27ca32020-11-20 12:42:07 -0500459// flagExporter is a separated portion of libraryDecorator pertaining to exported
460// include paths and flags. Keeping this dependency-related information separate
461// from the rest of library information is helpful in keeping data more structured
462// and explicit.
Colin Cross4d9c2d12016-07-29 12:48:20 -0700463type flagExporter struct {
464 Properties FlagExporterProperties
465
Chris Parsons3c27ca32020-11-20 12:42:07 -0500466 dirs android.Paths // Include directories to be included with -I
467 systemDirs android.Paths // System include directories to be included with -isystem
468 flags []string // Exported raw flags.
Inseob Kim69378442019-06-03 19:10:47 +0900469 deps android.Paths
Inseob Kimd110f872019-12-06 13:15:38 +0900470 headers android.Paths
Colin Cross4d9c2d12016-07-29 12:48:20 -0700471}
472
Chris Parsons3c27ca32020-11-20 12:42:07 -0500473// exportedIncludes returns the effective include paths for this module and
474// any module that links against this module. This is obtained from
475// the export_include_dirs property in the appropriate target stanza.
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700476func (f *flagExporter) exportedIncludes(ctx ModuleContext) android.Paths {
Justin Yun6977e8a2020-10-29 18:24:11 +0900477 if ctx.inVendor() && f.Properties.Target.Vendor.Override_export_include_dirs != nil {
Steven Morelandb21df8f2018-01-05 14:42:54 -0800478 return android.PathsForModuleSrc(ctx, f.Properties.Target.Vendor.Override_export_include_dirs)
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700479 }
Justin Yun6977e8a2020-10-29 18:24:11 +0900480 if ctx.inProduct() && f.Properties.Target.Product.Override_export_include_dirs != nil {
481 return android.PathsForModuleSrc(ctx, f.Properties.Target.Product.Override_export_include_dirs)
482 }
483 return android.PathsForModuleSrc(ctx, f.Properties.Export_include_dirs)
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700484}
485
Chris Parsons3c27ca32020-11-20 12:42:07 -0500486// exportIncludes registers the include directories and system include directories to be exported
487// transitively to modules depending on this module.
Inseob Kim69378442019-06-03 19:10:47 +0900488func (f *flagExporter) exportIncludes(ctx ModuleContext) {
Jiyong Park74955042019-10-22 20:19:51 +0900489 f.dirs = append(f.dirs, f.exportedIncludes(ctx)...)
Jiyong Park73c54ee2019-10-22 20:31:18 +0900490 f.systemDirs = append(f.systemDirs, android.PathsForModuleSrc(ctx, f.Properties.Export_system_include_dirs)...)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700491}
492
Chris Parsons3c27ca32020-11-20 12:42:07 -0500493// exportIncludesAsSystem registers the include directories and system include directories to be
494// exported transitively both as system include directories to modules depending on this module.
Inseob Kim69378442019-06-03 19:10:47 +0900495func (f *flagExporter) exportIncludesAsSystem(ctx ModuleContext) {
Jiyong Park73c54ee2019-10-22 20:31:18 +0900496 // all dirs are force exported as system
Jiyong Park74955042019-10-22 20:19:51 +0900497 f.systemDirs = append(f.systemDirs, f.exportedIncludes(ctx)...)
Jiyong Park73c54ee2019-10-22 20:31:18 +0900498 f.systemDirs = append(f.systemDirs, android.PathsForModuleSrc(ctx, f.Properties.Export_system_include_dirs)...)
Inseob Kim69378442019-06-03 19:10:47 +0900499}
500
Chris Parsons3c27ca32020-11-20 12:42:07 -0500501// reexportDirs registers the given directories as include directories to be exported transitively
502// to modules depending on this module.
Jiyong Park74955042019-10-22 20:19:51 +0900503func (f *flagExporter) reexportDirs(dirs ...android.Path) {
Inseob Kim69378442019-06-03 19:10:47 +0900504 f.dirs = append(f.dirs, dirs...)
505}
506
Chris Parsons3c27ca32020-11-20 12:42:07 -0500507// reexportSystemDirs registers the given directories as system include directories
508// to be exported transitively to modules depending on this module.
Jiyong Park74955042019-10-22 20:19:51 +0900509func (f *flagExporter) reexportSystemDirs(dirs ...android.Path) {
Inseob Kim69378442019-06-03 19:10:47 +0900510 f.systemDirs = append(f.systemDirs, dirs...)
511}
512
Chris Parsons3c27ca32020-11-20 12:42:07 -0500513// reexportFlags registers the flags to be exported transitively to modules depending on this
514// module.
Inseob Kim69378442019-06-03 19:10:47 +0900515func (f *flagExporter) reexportFlags(flags ...string) {
Jaewoong Jung3aff5782020-02-11 07:54:35 -0800516 if android.PrefixInList(flags, "-I") || android.PrefixInList(flags, "-isystem") {
517 panic(fmt.Errorf("Exporting invalid flag %q: "+
518 "use reexportDirs or reexportSystemDirs to export directories", flag))
Inseob Kim69378442019-06-03 19:10:47 +0900519 }
Colin Cross4d9c2d12016-07-29 12:48:20 -0700520 f.flags = append(f.flags, flags...)
521}
522
Inseob Kim69378442019-06-03 19:10:47 +0900523func (f *flagExporter) reexportDeps(deps ...android.Path) {
524 f.deps = append(f.deps, deps...)
525}
526
Inseob Kimd110f872019-12-06 13:15:38 +0900527// addExportedGeneratedHeaders does nothing but collects generated header files.
528// This can be differ to exportedDeps which may contain phony files to minimize ninja.
529func (f *flagExporter) addExportedGeneratedHeaders(headers ...android.Path) {
530 f.headers = append(f.headers, headers...)
531}
532
Colin Cross0de8a1e2020-09-18 14:15:30 -0700533func (f *flagExporter) setProvider(ctx android.ModuleContext) {
534 ctx.SetProvider(FlagExporterInfoProvider, FlagExporterInfo{
Chris Parsonsf60ecf02021-04-27 14:48:30 -0400535 // Comes from Export_include_dirs property, and those of exported transitive deps
536 IncludeDirs: android.FirstUniquePaths(f.dirs),
537 // Comes from Export_system_include_dirs property, and those of exported transitive deps
Colin Crossc82e6e22021-04-20 18:21:50 -0700538 SystemIncludeDirs: android.FirstUniquePaths(f.systemDirs),
Chris Parsonsf60ecf02021-04-27 14:48:30 -0400539 // Used in very few places as a one-off way of adding extra defines.
540 Flags: f.flags,
541 // Used sparingly, for extra files that need to be explicitly exported to dependers,
542 // or for phony files to minimize ninja.
543 Deps: f.deps,
544 // For exported generated headers, such as exported aidl headers, proto headers, or
545 // sysprop headers.
546 GeneratedHeaders: f.headers,
Colin Cross0de8a1e2020-09-18 14:15:30 -0700547 })
Inseob Kim69378442019-06-03 19:10:47 +0900548}
549
Colin Crossb916a382016-07-29 17:28:03 -0700550// libraryDecorator wraps baseCompiler, baseLinker and baseInstaller to provide library-specific
551// functionality: static vs. shared linkage, reusing object files for shared libraries
552type libraryDecorator struct {
Colin Crossa48ab5b2017-02-14 15:28:44 -0800553 Properties LibraryProperties
Colin Crosse1bb5d02019-09-24 14:55:04 -0700554 StaticProperties StaticProperties
555 SharedProperties SharedProperties
Colin Crossa48ab5b2017-02-14 15:28:44 -0800556 MutatedProperties LibraryMutatedProperties
Colin Cross4d9c2d12016-07-29 12:48:20 -0700557
558 // For reusing static library objects for shared library
Inseob Kim69378442019-06-03 19:10:47 +0900559 reuseObjects Objects
Colin Cross10d22312017-05-03 11:01:58 -0700560
Colin Cross26c34ed2016-09-30 17:10:16 -0700561 // table-of-contents file to optimize out relinking when possible
562 tocFile android.OptionalPath
Colin Cross4d9c2d12016-07-29 12:48:20 -0700563
Colin Cross4d9c2d12016-07-29 12:48:20 -0700564 flagExporter
Liz Kammerb6a55bf2021-04-12 15:42:51 -0400565 flagExporterInfo *FlagExporterInfo
566 stripper Stripper
Colin Cross4d9c2d12016-07-29 12:48:20 -0700567
Colin Cross4d9c2d12016-07-29 12:48:20 -0700568 // For whole_static_libs
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700569 objects Objects
Colin Cross4d9c2d12016-07-29 12:48:20 -0700570
571 // Uses the module's name if empty, but can be overridden. Does not include
572 // shlib suffix.
573 libName string
Colin Crossb916a382016-07-29 17:28:03 -0700574
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800575 sabi *sabi
576
Dan Willemsen581341d2017-02-09 16:16:31 -0800577 // Output archive of gcno coverage information files
578 coverageOutputFile android.OptionalPath
579
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800580 // linked Source Abi Dump
581 sAbiOutputFile android.OptionalPath
582
583 // Source Abi Diff
584 sAbiDiff android.OptionalPath
585
Colin Cross0875c522017-11-28 17:34:01 -0800586 // Location of the static library in the sysroot. Empty if the library is
587 // not included in the NDK.
588 ndkSysrootPath android.Path
589
Colin Crossb60190a2018-09-04 16:28:17 -0700590 // Location of the linked, unstripped library for shared libraries
591 unstrippedOutputFile android.Path
592
Dan Willemsen569edc52018-11-19 09:33:29 -0800593 // Location of the file that should be copied to dist dir when requested
Jingwen Chen40fd90a2020-06-15 05:24:19 +0000594 distFile android.Path
Dan Willemsen569edc52018-11-19 09:33:29 -0800595
Colin Cross8e21aa52020-09-28 18:28:02 -0700596 versionScriptPath android.OptionalPath
Jiyong Park7ed9de32018-10-15 22:25:07 +0900597
Jaewoong Jung18aefc12020-12-21 09:11:10 -0800598 postInstallCmds []string
Jiyong Parkf1194352019-02-25 11:05:47 +0900599
Vic Yangefd249e2018-11-12 20:19:56 -0800600 // If useCoreVariant is true, the vendor variant of a VNDK library is
601 // not installed.
Vic Yangd92090f2020-01-08 14:32:28 -0800602 useCoreVariant bool
603 checkSameCoreVariant bool
Vic Yangefd249e2018-11-12 20:19:56 -0800604
Colin Cross5ec407b2020-09-30 11:41:33 -0700605 skipAPIDefine bool
606
Martin Stjernholmc5dd4f72020-04-01 20:38:01 +0100607 // Decorated interfaces
Colin Crossb916a382016-07-29 17:28:03 -0700608 *baseCompiler
609 *baseLinker
610 *baseInstaller
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900611
612 collectedSnapshotHeaders android.Paths
sophiez4c4f8032021-08-16 22:54:00 -0700613
614 apiListCoverageXmlPath android.ModuleOutPath
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900615}
616
Chris Parsonsbcc9b882021-06-03 11:16:27 -0400617type ccLibraryBazelHandler struct {
Alex Márquez Pérez Muñíz Díaz Púras Thaureaux0d990452021-08-11 16:46:13 +0000618 android.BazelHandler
Chris Parsons808d84c2021-03-09 20:43:32 -0500619
620 module *Module
621}
622
Chris Parsons94a0bba2021-06-04 15:03:47 -0400623// generateStaticBazelBuildActions constructs the StaticLibraryInfo Soong
624// provider from a Bazel shared library's CcInfo provider.
625func (handler *ccLibraryBazelHandler) generateStaticBazelBuildActions(ctx android.ModuleContext, label string, ccInfo cquery.CcInfo) bool {
Chris Parsonsbcc9b882021-06-03 11:16:27 -0400626 rootStaticArchives := ccInfo.RootStaticArchives
Chris Parsonsbcc9b882021-06-03 11:16:27 -0400627 if len(rootStaticArchives) != 1 {
628 ctx.ModuleErrorf("expected exactly one root archive file for '%s', but got %s", label, rootStaticArchives)
Chris Parsons944e7d02021-03-11 11:08:46 -0500629 return false
630 }
Chris Parsonsbcc9b882021-06-03 11:16:27 -0400631 outputFilePath := android.PathForBazelOut(ctx, rootStaticArchives[0])
Chris Parsons944e7d02021-03-11 11:08:46 -0500632 handler.module.outputFile = android.OptionalPathForPath(outputFilePath)
633
Chris Parsons94a0bba2021-06-04 15:03:47 -0400634 objPaths := ccInfo.CcObjectFiles
Chris Parsons944e7d02021-03-11 11:08:46 -0500635 objFiles := make(android.Paths, len(objPaths))
636 for i, objPath := range objPaths {
637 objFiles[i] = android.PathForBazelOut(ctx, objPath)
638 }
639 objects := Objects{
640 objFiles: objFiles,
641 }
642
643 ctx.SetProvider(StaticLibraryInfoProvider, StaticLibraryInfo{
644 StaticLibrary: outputFilePath,
645 ReuseObjects: objects,
646 Objects: objects,
647
Chris Parsons94a0bba2021-06-04 15:03:47 -0400648 // TODO(b/190524881): Include transitive static libraries in this provider to support
Chris Parsons944e7d02021-03-11 11:08:46 -0500649 // static libraries with deps.
650 TransitiveStaticLibrariesForOrdering: android.NewDepSetBuilder(android.TOPOLOGICAL).
651 Direct(outputFilePath).
652 Build(),
653 })
Chris Parsonsf60ecf02021-04-27 14:48:30 -0400654
Chris Parsons94a0bba2021-06-04 15:03:47 -0400655 return true
656}
657
658// generateSharedBazelBuildActions constructs the SharedLibraryInfo Soong
659// provider from a Bazel shared library's CcInfo provider.
660func (handler *ccLibraryBazelHandler) generateSharedBazelBuildActions(ctx android.ModuleContext, label string, ccInfo cquery.CcInfo) bool {
661 rootDynamicLibraries := ccInfo.RootDynamicLibraries
662
663 if len(rootDynamicLibraries) != 1 {
664 ctx.ModuleErrorf("expected exactly one root dynamic library file for '%s', but got %s", label, rootDynamicLibraries)
665 return false
666 }
667 outputFilePath := android.PathForBazelOut(ctx, rootDynamicLibraries[0])
668 handler.module.outputFile = android.OptionalPathForPath(outputFilePath)
669
670 handler.module.linker.(*libraryDecorator).unstrippedOutputFile = outputFilePath
671
Alex Márquez Pérez Muñíz Díaz Púras Thaureaux62585e82021-09-14 21:19:31 +0000672 var tocFile android.OptionalPath
673 if len(ccInfo.TocFile) > 0 {
674 tocFile = android.OptionalPathForPath(android.PathForBazelOut(ctx, ccInfo.TocFile))
675 }
Chris Parsons94a0bba2021-06-04 15:03:47 -0400676 handler.module.linker.(*libraryDecorator).tocFile = tocFile
677
678 ctx.SetProvider(SharedLibraryInfoProvider, SharedLibraryInfo{
679 TableOfContents: tocFile,
680 SharedLibrary: outputFilePath,
Jingwen Chen702963e2021-06-15 23:44:13 +0000681 Target: ctx.Target(),
Chris Parsons94a0bba2021-06-04 15:03:47 -0400682 // TODO(b/190524881): Include transitive static libraries in this provider to support
Jingwen Chen702963e2021-06-15 23:44:13 +0000683 // static libraries with deps. The provider key for this is TransitiveStaticLibrariesForOrdering.
Chris Parsons94a0bba2021-06-04 15:03:47 -0400684 })
685 return true
686}
687
Alex Márquez Pérez Muñíz Díaz Púras Thaureaux0d990452021-08-11 16:46:13 +0000688func (handler *ccLibraryBazelHandler) GenerateBazelBuildActions(ctx android.ModuleContext, label string) bool {
Chris Parsons94a0bba2021-06-04 15:03:47 -0400689 bazelCtx := ctx.Config().BazelContext
Chris Parsons787fb362021-10-14 18:43:51 -0400690 ccInfo, ok, err := bazelCtx.GetCcInfo(label, android.GetConfigKey(ctx))
Chris Parsons94a0bba2021-06-04 15:03:47 -0400691 if err != nil {
692 ctx.ModuleErrorf("Error getting Bazel CcInfo: %s", err)
693 return false
694 }
695 if !ok {
696 return ok
697 }
698
699 if handler.module.static() {
700 if ok := handler.generateStaticBazelBuildActions(ctx, label, ccInfo); !ok {
701 return false
702 }
703 } else if handler.module.Shared() {
704 if ok := handler.generateSharedBazelBuildActions(ctx, label, ccInfo); !ok {
705 return false
706 }
707 } else {
708 return false
709 }
710
711 handler.module.linker.(*libraryDecorator).setFlagExporterInfoFromCcInfo(ctx, ccInfo)
712 handler.module.maybeUnhideFromMake()
713
Chris Parsonseefc9e62021-04-02 17:36:47 -0400714 if i, ok := handler.module.linker.(snapshotLibraryInterface); ok {
715 // Dependencies on this library will expect collectedSnapshotHeaders to
716 // be set, otherwise validation will fail. For now, set this to an empty
717 // list.
Chris Parsons94a0bba2021-06-04 15:03:47 -0400718 // TODO(b/190533363): More closely mirror the collectHeadersForSnapshot
Chris Parsonseefc9e62021-04-02 17:36:47 -0400719 // implementation.
720 i.(*libraryDecorator).collectedSnapshotHeaders = android.Paths{}
721 }
Chris Parsons808d84c2021-03-09 20:43:32 -0500722 return ok
723}
724
Chris Parsons94a0bba2021-06-04 15:03:47 -0400725func (library *libraryDecorator) setFlagExporterInfoFromCcInfo(ctx android.ModuleContext, ccInfo cquery.CcInfo) {
726 flagExporterInfo := flagExporterInfoFromCcInfo(ctx, ccInfo)
727 // flag exporters consolidates properties like includes, flags, dependencies that should be
728 // exported from this module to other modules
729 ctx.SetProvider(FlagExporterInfoProvider, flagExporterInfo)
730 // Store flag info to be passed along to androidmk
731 // TODO(b/184387147): Androidmk should be done in Bazel, not Soong.
732 library.flagExporterInfo = &flagExporterInfo
733}
734
Ivan Lozanod67a6b02021-05-20 13:01:32 -0400735func GlobHeadersForSnapshot(ctx android.ModuleContext, paths android.Paths) android.Paths {
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900736 ret := android.Paths{}
737
738 // Headers in the source tree should be globbed. On the contrast, generated headers
739 // can't be globbed, and they should be manually collected.
740 // So, we first filter out intermediate directories (which contains generated headers)
741 // from exported directories, and then glob headers under remaining directories.
Ivan Lozanod67a6b02021-05-20 13:01:32 -0400742 for _, path := range paths {
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900743 dir := path.String()
744 // Skip if dir is for generated headers
745 if strings.HasPrefix(dir, android.PathForOutput(ctx).String()) {
746 continue
747 }
Inseob Kim04f2d6a2020-05-29 22:30:58 +0900748 // libeigen wrongly exports the root directory "external/eigen". But only two
749 // subdirectories "Eigen" and "unsupported" contain exported header files. Even worse
750 // some of them have no extension. So we need special treatment for libeigen in order
751 // to glob correctly.
752 if dir == "external/eigen" {
753 // Only these two directories contains exported headers.
754 for _, subdir := range []string{"Eigen", "unsupported/Eigen"} {
755 glob, err := ctx.GlobWithDeps("external/eigen/"+subdir+"/**/*", nil)
756 if err != nil {
757 ctx.ModuleErrorf("glob failed: %#v", err)
Ivan Lozanod67a6b02021-05-20 13:01:32 -0400758 return nil
Inseob Kim04f2d6a2020-05-29 22:30:58 +0900759 }
760 for _, header := range glob {
761 if strings.HasSuffix(header, "/") {
762 continue
763 }
764 ext := filepath.Ext(header)
765 if ext != "" && ext != ".h" {
766 continue
767 }
768 ret = append(ret, android.PathForSource(ctx, header))
769 }
770 }
771 continue
772 }
Colin Crossec118d02021-01-22 18:05:59 +0000773 glob, err := ctx.GlobWithDeps(dir+"/**/*", nil)
774 if err != nil {
775 ctx.ModuleErrorf("glob failed: %#v", err)
Ivan Lozanod67a6b02021-05-20 13:01:32 -0400776 return nil
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900777 }
Colin Crossec118d02021-01-22 18:05:59 +0000778 isLibcxx := strings.HasPrefix(dir, "external/libcxx/include")
Jose Galmes0d736912021-03-30 11:00:06 -0700779 for _, header := range glob {
Colin Crossec118d02021-01-22 18:05:59 +0000780 if isLibcxx {
781 // Glob all files under this special directory, because of C++ headers with no
782 // extension.
Jose Galmes0d736912021-03-30 11:00:06 -0700783 if strings.HasSuffix(header, "/") {
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900784 continue
785 }
Colin Crossec118d02021-01-22 18:05:59 +0000786 } else {
787 // Filter out only the files with extensions that are headers.
788 found := false
Ivan Lozanod67a6b02021-05-20 13:01:32 -0400789 for _, ext := range HeaderExts {
Colin Crossec118d02021-01-22 18:05:59 +0000790 if strings.HasSuffix(header, ext) {
791 found = true
792 break
793 }
794 }
795 if !found {
796 continue
797 }
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900798 }
Jose Galmes0d736912021-03-30 11:00:06 -0700799 ret = append(ret, android.PathForSource(ctx, header))
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900800 }
801 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -0400802 return ret
803}
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900804
Ivan Lozanod67a6b02021-05-20 13:01:32 -0400805func GlobGeneratedHeadersForSnapshot(ctx android.ModuleContext, paths android.Paths) android.Paths {
806 ret := android.Paths{}
807 for _, header := range paths {
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900808 // TODO(b/148123511): remove exportedDeps after cleaning up genrule
809 if strings.HasSuffix(header.Base(), "-phony") {
810 continue
811 }
812 ret = append(ret, header)
813 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -0400814 return ret
815}
816
817// collectHeadersForSnapshot collects all exported headers from library.
818// It globs header files in the source tree for exported include directories,
819// and tracks generated header files separately.
820//
821// This is to be called from GenerateAndroidBuildActions, and then collected
822// header files can be retrieved by snapshotHeaders().
823func (l *libraryDecorator) collectHeadersForSnapshot(ctx android.ModuleContext) {
824 ret := android.Paths{}
825
826 // Headers in the source tree should be globbed. On the contrast, generated headers
827 // can't be globbed, and they should be manually collected.
828 // So, we first filter out intermediate directories (which contains generated headers)
829 // from exported directories, and then glob headers under remaining directories.
830 ret = append(ret, GlobHeadersForSnapshot(ctx, append(android.CopyOfPaths(l.flagExporter.dirs), l.flagExporter.systemDirs...))...)
831
832 // Collect generated headers
833 ret = append(ret, GlobGeneratedHeadersForSnapshot(ctx, append(android.CopyOfPaths(l.flagExporter.headers), l.flagExporter.deps...))...)
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900834
835 l.collectedSnapshotHeaders = ret
836}
837
838// This returns all exported header files, both generated ones and headers from source tree.
839// collectHeadersForSnapshot() must be called before calling this.
840func (l *libraryDecorator) snapshotHeaders() android.Paths {
841 if l.collectedSnapshotHeaders == nil {
842 panic("snapshotHeaders() must be called after collectHeadersForSnapshot()")
843 }
844 return l.collectedSnapshotHeaders
Colin Cross4d9c2d12016-07-29 12:48:20 -0700845}
846
Chris Parsons3c27ca32020-11-20 12:42:07 -0500847// linkerProps returns the list of properties structs relevant for this library. (For example, if
848// the library is cc_shared_library, then static-library properties are omitted.)
Colin Crossb916a382016-07-29 17:28:03 -0700849func (library *libraryDecorator) linkerProps() []interface{} {
850 var props []interface{}
851 props = append(props, library.baseLinker.linkerProps()...)
Colin Crosse1bb5d02019-09-24 14:55:04 -0700852 props = append(props,
Colin Cross4d9c2d12016-07-29 12:48:20 -0700853 &library.Properties,
Colin Crossa48ab5b2017-02-14 15:28:44 -0800854 &library.MutatedProperties,
Colin Cross4d9c2d12016-07-29 12:48:20 -0700855 &library.flagExporter.Properties,
Colin Cross22f37952018-09-05 10:43:13 -0700856 &library.stripper.StripProperties)
Colin Crosse1bb5d02019-09-24 14:55:04 -0700857
858 if library.MutatedProperties.BuildShared {
859 props = append(props, &library.SharedProperties)
860 }
861 if library.MutatedProperties.BuildStatic {
862 props = append(props, &library.StaticProperties)
863 }
864
865 return props
Colin Cross4d9c2d12016-07-29 12:48:20 -0700866}
867
Chris Parsons3c27ca32020-11-20 12:42:07 -0500868// linkerFlags takes a Flags struct and augments it to contain linker flags that are defined by this
869// library, or that are implied by attributes of this library (such as whether this library is a
870// shared library).
Colin Crossb916a382016-07-29 17:28:03 -0700871func (library *libraryDecorator) linkerFlags(ctx ModuleContext, flags Flags) Flags {
Colin Cross42742b82016-08-01 13:20:05 -0700872 flags = library.baseLinker.linkerFlags(ctx, flags)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700873
Colin Crossb916a382016-07-29 17:28:03 -0700874 // MinGW spits out warnings about -fPIC even for -fpie?!) being ignored because
875 // all code is position independent, and then those warnings get promoted to
876 // errors.
Colin Cross3edeee12017-04-04 12:59:48 -0700877 if !ctx.Windows() {
Colin Cross4af21ed2019-11-04 09:37:55 -0800878 flags.Global.CFlags = append(flags.Global.CFlags, "-fPIC")
Colin Crossb916a382016-07-29 17:28:03 -0700879 }
880
881 if library.static() {
Colin Cross4af21ed2019-11-04 09:37:55 -0800882 flags.Local.CFlags = append(flags.Local.CFlags, library.StaticProperties.Static.Cflags...)
Colin Crossa48ab5b2017-02-14 15:28:44 -0800883 } else if library.shared() {
Colin Cross4af21ed2019-11-04 09:37:55 -0800884 flags.Local.CFlags = append(flags.Local.CFlags, library.SharedProperties.Shared.Cflags...)
Colin Crossb916a382016-07-29 17:28:03 -0700885 }
886
Colin Crossa48ab5b2017-02-14 15:28:44 -0800887 if library.shared() {
Colin Cross4d9c2d12016-07-29 12:48:20 -0700888 libName := library.getLibName(ctx)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700889 var f []string
Dan Willemsen01a405a2016-06-13 17:19:03 -0700890 if ctx.toolchain().Bionic() {
Colin Cross4d9c2d12016-07-29 12:48:20 -0700891 f = append(f,
892 "-nostdlib",
893 "-Wl,--gc-sections",
894 )
895 }
896
897 if ctx.Darwin() {
898 f = append(f,
899 "-dynamiclib",
900 "-single_module",
Colin Cross4d9c2d12016-07-29 12:48:20 -0700901 "-install_name @rpath/"+libName+flags.Toolchain.ShlibSuffix(),
902 )
Colin Cross7863cf52016-10-20 10:47:21 -0700903 if ctx.Arch().ArchType == android.X86 {
904 f = append(f,
905 "-read_only_relocs suppress",
906 )
907 }
Colin Cross4d9c2d12016-07-29 12:48:20 -0700908 } else {
Josh Gao75a50a22019-06-07 17:58:59 -0700909 f = append(f, "-shared")
910 if !ctx.Windows() {
911 f = append(f, "-Wl,-soname,"+libName+flags.Toolchain.ShlibSuffix())
912 }
Colin Cross4d9c2d12016-07-29 12:48:20 -0700913 }
914
Colin Cross4af21ed2019-11-04 09:37:55 -0800915 flags.Global.LdFlags = append(flags.Global.LdFlags, f...)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700916 }
917
918 return flags
919}
920
Chris Parsons3c27ca32020-11-20 12:42:07 -0500921// compilerFlags takes a Flags and augments it to contain compile flags from global values,
922// per-target values, module type values, per-module Blueprints properties, extra flags from
923// `flags`, and generated sources from `deps`.
Colin Crossf18e1102017-11-16 14:33:08 -0800924func (library *libraryDecorator) compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags {
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700925 exportIncludeDirs := library.flagExporter.exportedIncludes(ctx)
Dan Willemsen273af7f2016-11-03 15:53:42 -0700926 if len(exportIncludeDirs) > 0 {
Colin Crossdad8c952017-04-26 14:55:27 -0700927 f := includeDirsToFlags(exportIncludeDirs)
Colin Cross4af21ed2019-11-04 09:37:55 -0800928 flags.Local.CommonFlags = append(flags.Local.CommonFlags, f)
929 flags.Local.YasmFlags = append(flags.Local.YasmFlags, f)
Dan Willemsen273af7f2016-11-03 15:53:42 -0700930 }
931
Jiyong Park7ed9de32018-10-15 22:25:07 +0900932 flags = library.baseCompiler.compilerFlags(ctx, flags, deps)
Colin Cross127bb8b2020-12-16 16:46:01 -0800933 if ctx.IsLlndk() {
934 // LLNDK libraries ignore most of the properties on the cc_library and use the
935 // LLNDK-specific properties instead.
936 // Wipe all the module-local properties, leaving only the global properties.
937 flags.Local = LocalOrGlobalFlags{}
938 }
Jiyong Park7ed9de32018-10-15 22:25:07 +0900939 if library.buildStubs() {
Jiyong Park64379952018-12-13 18:37:29 +0900940 // Remove -include <file> when compiling stubs. Otherwise, the force included
941 // headers might cause conflicting types error with the symbols in the
942 // generated stubs source code. e.g.
943 // double acos(double); // in header
944 // void acos() {} // in the generated source code
945 removeInclude := func(flags []string) []string {
946 ret := flags[:0]
947 for _, f := range flags {
948 if strings.HasPrefix(f, "-include ") {
949 continue
950 }
951 ret = append(ret, f)
952 }
953 return ret
954 }
Colin Cross4af21ed2019-11-04 09:37:55 -0800955 flags.Local.CommonFlags = removeInclude(flags.Local.CommonFlags)
956 flags.Local.CFlags = removeInclude(flags.Local.CFlags)
Jiyong Park64379952018-12-13 18:37:29 +0900957
Jiyong Park7ed9de32018-10-15 22:25:07 +0900958 flags = addStubLibraryCompilerFlags(flags)
959 }
960 return flags
Dan Willemsen273af7f2016-11-03 15:53:42 -0700961}
962
Yo Chiang2bbadfa2020-12-14 11:42:16 +0800963func (library *libraryDecorator) headerAbiCheckerEnabled() bool {
964 return Bool(library.Properties.Header_abi_checker.Enabled)
Hsin-Yi Chen53489642019-07-31 17:10:45 +0800965}
966
Yo Chiang2bbadfa2020-12-14 11:42:16 +0800967func (library *libraryDecorator) headerAbiCheckerExplicitlyDisabled() bool {
968 return !BoolDefault(library.Properties.Header_abi_checker.Enabled, true)
Logan Chien41eabe62019-04-10 13:33:58 +0800969}
970
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700971func (library *libraryDecorator) compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects {
Colin Cross127bb8b2020-12-16 16:46:01 -0800972 if ctx.IsLlndk() {
973 // This is the vendor variant of an LLNDK library, build the LLNDK stubs.
974 vndkVer := ctx.Module().(*Module).VndkVersion()
975 if !inList(vndkVer, ctx.Config().PlatformVersionActiveCodenames()) || vndkVer == "" {
976 // For non-enforcing devices, vndkVer is empty. Use "current" in that case, too.
977 vndkVer = "current"
978 }
979 if library.stubsVersion() != "" {
980 vndkVer = library.stubsVersion()
981 }
Dan Albertf1d14c72020-07-30 14:32:55 -0700982 nativeAbiResult := parseNativeAbiDefinition(ctx,
983 String(library.Properties.Llndk.Symbol_file),
984 android.ApiLevelOrPanic(ctx, vndkVer), "--llndk")
985 objs := compileStubLibrary(ctx, flags, nativeAbiResult.stubSrc)
Colin Cross127bb8b2020-12-16 16:46:01 -0800986 if !Bool(library.Properties.Llndk.Unversioned) {
Dan Albertf1d14c72020-07-30 14:32:55 -0700987 library.versionScriptPath = android.OptionalPathForPath(
988 nativeAbiResult.versionScript)
Colin Cross127bb8b2020-12-16 16:46:01 -0800989 }
990 return objs
991 }
Colin Cross5271fea2021-04-27 13:06:04 -0700992 if ctx.IsVendorPublicLibrary() {
Dan Albertf1d14c72020-07-30 14:32:55 -0700993 nativeAbiResult := parseNativeAbiDefinition(ctx,
994 String(library.Properties.Vendor_public_library.Symbol_file),
995 android.FutureApiLevel, "")
996 objs := compileStubLibrary(ctx, flags, nativeAbiResult.stubSrc)
Colin Cross5271fea2021-04-27 13:06:04 -0700997 if !Bool(library.Properties.Vendor_public_library.Unversioned) {
Dan Albertf1d14c72020-07-30 14:32:55 -0700998 library.versionScriptPath = android.OptionalPathForPath(nativeAbiResult.versionScript)
Colin Cross5271fea2021-04-27 13:06:04 -0700999 }
1000 return objs
1001 }
Jiyong Park7ed9de32018-10-15 22:25:07 +09001002 if library.buildStubs() {
Jiyong Parka4175572021-02-04 21:05:47 +09001003 symbolFile := String(library.Properties.Stubs.Symbol_file)
1004 if symbolFile != "" && !strings.HasSuffix(symbolFile, ".map.txt") {
1005 ctx.PropertyErrorf("symbol_file", "%q doesn't have .map.txt suffix", symbolFile)
1006 return Objects{}
1007 }
Dan Albertf1d14c72020-07-30 14:32:55 -07001008 nativeAbiResult := parseNativeAbiDefinition(ctx, symbolFile,
1009 android.ApiLevelOrPanic(ctx, library.MutatedProperties.StubsVersion),
1010 "--apex")
1011 objs := compileStubLibrary(ctx, flags, nativeAbiResult.stubSrc)
1012 library.versionScriptPath = android.OptionalPathForPath(
1013 nativeAbiResult.versionScript)
sophiez4c4f8032021-08-16 22:54:00 -07001014
1015 // Parse symbol file to get API list for coverage
Colin Crossceaa5322021-09-28 16:37:50 -07001016 if library.stubsVersion() == "current" && ctx.PrimaryArch() && !ctx.inRecovery() && !ctx.inProduct() && !ctx.inVendor() {
sophiez4c4f8032021-08-16 22:54:00 -07001017 library.apiListCoverageXmlPath = parseSymbolFileForAPICoverage(ctx, symbolFile)
1018 }
1019
Jiyong Park7ed9de32018-10-15 22:25:07 +09001020 return objs
1021 }
1022
Colin Cross5950f382016-12-13 12:50:57 -08001023 if !library.buildShared() && !library.buildStatic() {
1024 if len(library.baseCompiler.Properties.Srcs) > 0 {
1025 ctx.PropertyErrorf("srcs", "cc_library_headers must not have any srcs")
1026 }
Colin Crosse1bb5d02019-09-24 14:55:04 -07001027 if len(library.StaticProperties.Static.Srcs) > 0 {
Colin Cross5950f382016-12-13 12:50:57 -08001028 ctx.PropertyErrorf("static.srcs", "cc_library_headers must not have any srcs")
1029 }
Colin Crosse1bb5d02019-09-24 14:55:04 -07001030 if len(library.SharedProperties.Shared.Srcs) > 0 {
Colin Cross5950f382016-12-13 12:50:57 -08001031 ctx.PropertyErrorf("shared.srcs", "cc_library_headers must not have any srcs")
1032 }
1033 return Objects{}
1034 }
Yo Chiang2bbadfa2020-12-14 11:42:16 +08001035 if library.sabi.shouldCreateSourceAbiDump() {
Jayant Chowdharya4fce192017-09-06 13:10:03 -07001036 exportIncludeDirs := library.flagExporter.exportedIncludes(ctx)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001037 var SourceAbiFlags []string
1038 for _, dir := range exportIncludeDirs.Strings() {
Jayant Chowdhary715cac32017-04-20 06:53:59 -07001039 SourceAbiFlags = append(SourceAbiFlags, "-I"+dir)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001040 }
Inseob Kim69378442019-06-03 19:10:47 +09001041 for _, reexportedInclude := range library.sabi.Properties.ReexportedIncludes {
1042 SourceAbiFlags = append(SourceAbiFlags, "-I"+reexportedInclude)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07001043 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001044 flags.SAbiFlags = SourceAbiFlags
Jaewoong Jung18aefc12020-12-21 09:11:10 -08001045 totalLength := len(library.baseCompiler.Properties.Srcs) + len(deps.GeneratedSources) +
Colin Crosse1bb5d02019-09-24 14:55:04 -07001046 len(library.SharedProperties.Shared.Srcs) + len(library.StaticProperties.Static.Srcs)
Jaewoong Jung18aefc12020-12-21 09:11:10 -08001047 if totalLength > 0 {
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001048 flags.SAbiDump = true
1049 }
1050 }
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001051 objs := library.baseCompiler.compile(ctx, flags, deps)
1052 library.reuseObjects = objs
Colin Cross2f336352016-10-26 10:03:47 -07001053 buildFlags := flagsToBuilderFlags(flags)
Colin Crossb916a382016-07-29 17:28:03 -07001054
Colin Cross4d9c2d12016-07-29 12:48:20 -07001055 if library.static() {
Colin Crosse1bb5d02019-09-24 14:55:04 -07001056 srcs := android.PathsForModuleSrc(ctx, library.StaticProperties.Static.Srcs)
Chih-Hung Hsieh769a51c2021-09-17 17:18:39 -07001057 objs = objs.Append(compileObjs(ctx, buildFlags, android.DeviceStaticLibrary, srcs,
1058 android.PathsForModuleSrc(ctx, library.StaticProperties.Static.Tidy_disabled_srcs),
1059 library.baseCompiler.pathDeps, library.baseCompiler.cFlagsDeps))
Colin Crossa48ab5b2017-02-14 15:28:44 -08001060 } else if library.shared() {
Colin Crosse1bb5d02019-09-24 14:55:04 -07001061 srcs := android.PathsForModuleSrc(ctx, library.SharedProperties.Shared.Srcs)
Chih-Hung Hsieh769a51c2021-09-17 17:18:39 -07001062 objs = objs.Append(compileObjs(ctx, buildFlags, android.DeviceSharedLibrary, srcs,
1063 android.PathsForModuleSrc(ctx, library.SharedProperties.Shared.Tidy_disabled_srcs),
1064 library.baseCompiler.pathDeps, library.baseCompiler.cFlagsDeps))
Colin Crossb916a382016-07-29 17:28:03 -07001065 }
1066
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001067 return objs
Colin Crossb916a382016-07-29 17:28:03 -07001068}
1069
1070type libraryInterface interface {
Colin Cross3572cf72020-10-01 15:58:11 -07001071 versionedInterface
1072
Colin Crossb916a382016-07-29 17:28:03 -07001073 static() bool
Inseob Kimae553032019-05-14 18:52:49 +09001074 shared() bool
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001075 objs() Objects
Colin Cross0de8a1e2020-09-18 14:15:30 -07001076 reuseObjs() Objects
Colin Cross26c34ed2016-09-30 17:10:16 -07001077 toc() android.OptionalPath
Colin Crossb916a382016-07-29 17:28:03 -07001078
1079 // Returns true if the build options for the module have selected a static or shared build
1080 buildStatic() bool
1081 buildShared() bool
1082
1083 // Sets whether a specific variant is static or shared
Colin Crossa48ab5b2017-02-14 15:28:44 -08001084 setStatic()
1085 setShared()
Logan Chien41eabe62019-04-10 13:33:58 +08001086
Yo Chiang2bbadfa2020-12-14 11:42:16 +08001087 // Check whether header_abi_checker is enabled or explicitly disabled.
1088 headerAbiCheckerEnabled() bool
1089 headerAbiCheckerExplicitlyDisabled() bool
1090
Logan Chien41eabe62019-04-10 13:33:58 +08001091 // Write LOCAL_ADDITIONAL_DEPENDENCIES for ABI diff
1092 androidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer)
Jiyong Parka90ca002019-10-07 15:47:24 +09001093
1094 availableFor(string) bool
Colin Crossceaa5322021-09-28 16:37:50 -07001095
1096 getAPIListCoverageXMLPath() android.ModuleOutPath
Colin Cross1bc94122021-10-28 13:25:54 -07001097
1098 installable() *bool
Colin Crossb916a382016-07-29 17:28:03 -07001099}
1100
Colin Crossc88c2722020-09-28 17:32:47 -07001101type versionedInterface interface {
1102 buildStubs() bool
Jiyong Parkd4a3a132021-03-17 20:21:35 +09001103 setBuildStubs(isLatest bool)
Colin Crossc88c2722020-09-28 17:32:47 -07001104 hasStubsVariants() bool
1105 setStubsVersion(string)
1106 stubsVersion() string
1107
Colin Cross3572cf72020-10-01 15:58:11 -07001108 stubsVersions(ctx android.BaseMutatorContext) []string
Colin Crossc88c2722020-09-28 17:32:47 -07001109 setAllStubsVersions([]string)
1110 allStubsVersions() []string
Colin Cross0477b422020-10-13 18:43:54 -07001111
1112 implementationModuleName(name string) string
Colin Cross127bb8b2020-12-16 16:46:01 -08001113 hasLLNDKStubs() bool
Colin Cross1f3f1302021-04-26 18:37:44 -07001114 hasLLNDKHeaders() bool
Colin Cross5271fea2021-04-27 13:06:04 -07001115 hasVendorPublicLibrary() bool
Colin Crossc88c2722020-09-28 17:32:47 -07001116}
1117
1118var _ libraryInterface = (*libraryDecorator)(nil)
1119var _ versionedInterface = (*libraryDecorator)(nil)
1120
Justin Yun6977e8a2020-10-29 18:24:11 +09001121func (library *libraryDecorator) getLibNameHelper(baseModuleName string, inVendor bool, inProduct bool) string {
Colin Crossb916a382016-07-29 17:28:03 -07001122 name := library.libName
1123 if name == "" {
dimitryd95964a2018-11-07 13:43:34 +01001124 name = String(library.Properties.Stem)
1125 if name == "" {
Jooyung Han0302a842019-10-30 18:43:49 +09001126 name = baseModuleName
dimitryd95964a2018-11-07 13:43:34 +01001127 }
Colin Crossb916a382016-07-29 17:28:03 -07001128 }
1129
Colin Cross0fd6a412019-08-16 14:22:10 -07001130 suffix := ""
Justin Yun6977e8a2020-10-29 18:24:11 +09001131 if inVendor {
Colin Cross0fd6a412019-08-16 14:22:10 -07001132 suffix = String(library.Properties.Target.Vendor.Suffix)
Justin Yun6977e8a2020-10-29 18:24:11 +09001133 } else if inProduct {
1134 suffix = String(library.Properties.Target.Product.Suffix)
Colin Cross0fd6a412019-08-16 14:22:10 -07001135 }
1136 if suffix == "" {
1137 suffix = String(library.Properties.Suffix)
1138 }
1139
Jooyung Han0302a842019-10-30 18:43:49 +09001140 return name + suffix
1141}
1142
Chris Parsons3c27ca32020-11-20 12:42:07 -05001143// getLibName returns the actual canonical name of the library (the name which
1144// should be passed to the linker via linker flags).
Jooyung Han0302a842019-10-30 18:43:49 +09001145func (library *libraryDecorator) getLibName(ctx BaseModuleContext) string {
Justin Yun6977e8a2020-10-29 18:24:11 +09001146 name := library.getLibNameHelper(ctx.baseModuleName(), ctx.inVendor(), ctx.inProduct())
Colin Cross0fd6a412019-08-16 14:22:10 -07001147
Ivan Lozanof9e21722020-12-02 09:00:51 -05001148 if ctx.IsVndkExt() {
Jooyung Han4c2b9422019-10-22 19:53:47 +09001149 // vndk-ext lib should have the same name with original lib
1150 ctx.VisitDirectDepsWithTag(vndkExtDepTag, func(module android.Module) {
1151 originalName := module.(*Module).outputFile.Path()
1152 name = strings.TrimSuffix(originalName.Base(), originalName.Ext())
1153 })
Logan Chienf3511742017-10-31 18:04:35 +08001154 }
1155
Colin Crossb916a382016-07-29 17:28:03 -07001156 if ctx.Host() && Bool(library.Properties.Unique_host_soname) {
1157 if !strings.HasSuffix(name, "-host") {
1158 name = name + "-host"
1159 }
1160 }
1161
Inseob Kim0ce291e2019-07-04 14:38:27 +09001162 return name
Colin Crossb916a382016-07-29 17:28:03 -07001163}
1164
Jiyong Parkda732bd2018-11-02 18:23:15 +09001165var versioningMacroNamesListMutex sync.Mutex
1166
Colin Crossb916a382016-07-29 17:28:03 -07001167func (library *libraryDecorator) linkerInit(ctx BaseModuleContext) {
1168 location := InstallInSystem
Dan Albert61f32122018-07-26 14:00:24 -07001169 if library.baseLinker.sanitize.inSanitizerDir() {
Vishwath Mohan1dd88392017-03-29 22:00:18 -07001170 location = InstallInSanitizerDir
Colin Crossb916a382016-07-29 17:28:03 -07001171 }
1172 library.baseInstaller.location = location
Colin Crossb916a382016-07-29 17:28:03 -07001173 library.baseLinker.linkerInit(ctx)
Jiyong Park7ed9de32018-10-15 22:25:07 +09001174 // Let baseLinker know whether this variant is for stubs or not, so that
1175 // it can omit things that are not required for linking stubs.
1176 library.baseLinker.dynamicProperties.BuildStubs = library.buildStubs()
Jiyong Parkda732bd2018-11-02 18:23:15 +09001177
1178 if library.buildStubs() {
1179 macroNames := versioningMacroNamesList(ctx.Config())
1180 myName := versioningMacroName(ctx.ModuleName())
1181 versioningMacroNamesListMutex.Lock()
1182 defer versioningMacroNamesListMutex.Unlock()
1183 if (*macroNames)[myName] == "" {
1184 (*macroNames)[myName] = ctx.ModuleName()
1185 } else if (*macroNames)[myName] != ctx.ModuleName() {
1186 ctx.ModuleErrorf("Macro name %q for versioning conflicts with macro name from module %q ", myName, (*macroNames)[myName])
1187 }
1188 }
Colin Crossb916a382016-07-29 17:28:03 -07001189}
1190
dimitry0345ad82018-12-05 16:28:14 +01001191func (library *libraryDecorator) compilerDeps(ctx DepsContext, deps Deps) Deps {
Colin Cross127bb8b2020-12-16 16:46:01 -08001192 if ctx.IsLlndk() {
1193 // LLNDK libraries ignore most of the properties on the cc_library and use the
1194 // LLNDK-specific properties instead.
1195 return deps
1196 }
1197
dimitry0345ad82018-12-05 16:28:14 +01001198 deps = library.baseCompiler.compilerDeps(ctx, deps)
1199
dimitry0345ad82018-12-05 16:28:14 +01001200 return deps
1201}
1202
Colin Cross37047f12016-12-13 17:06:13 -08001203func (library *libraryDecorator) linkerDeps(ctx DepsContext, deps Deps) Deps {
Colin Cross127bb8b2020-12-16 16:46:01 -08001204 if ctx.IsLlndk() {
1205 // LLNDK libraries ignore most of the properties on the cc_library and use the
1206 // LLNDK-specific properties instead.
Colin Cross0fb7fcd2021-03-02 11:00:07 -08001207 deps.HeaderLibs = append([]string(nil), library.Properties.Llndk.Export_llndk_headers...)
1208 deps.ReexportHeaderLibHeaders = append([]string(nil), library.Properties.Llndk.Export_llndk_headers...)
Colin Cross127bb8b2020-12-16 16:46:01 -08001209 return deps
1210 }
Colin Cross5271fea2021-04-27 13:06:04 -07001211 if ctx.IsVendorPublicLibrary() {
1212 headers := library.Properties.Vendor_public_library.Export_public_headers
1213 deps.HeaderLibs = append([]string(nil), headers...)
1214 deps.ReexportHeaderLibHeaders = append([]string(nil), headers...)
1215 return deps
1216 }
Colin Cross127bb8b2020-12-16 16:46:01 -08001217
Dan Willemsen3a26eef2018-12-03 15:25:46 -08001218 if library.static() {
Martin Stjernholm10566a02020-03-24 01:19:52 +00001219 // Compare with nil because an empty list needs to be propagated.
Colin Crosse1bb5d02019-09-24 14:55:04 -07001220 if library.StaticProperties.Static.System_shared_libs != nil {
1221 library.baseLinker.Properties.System_shared_libs = library.StaticProperties.Static.System_shared_libs
Dan Willemsen3a26eef2018-12-03 15:25:46 -08001222 }
1223 } else if library.shared() {
Martin Stjernholm10566a02020-03-24 01:19:52 +00001224 // Compare with nil because an empty list needs to be propagated.
Colin Crosse1bb5d02019-09-24 14:55:04 -07001225 if library.SharedProperties.Shared.System_shared_libs != nil {
1226 library.baseLinker.Properties.System_shared_libs = library.SharedProperties.Shared.System_shared_libs
Dan Willemsen3a26eef2018-12-03 15:25:46 -08001227 }
1228 }
1229
Colin Crossb916a382016-07-29 17:28:03 -07001230 deps = library.baseLinker.linkerDeps(ctx, deps)
1231
1232 if library.static() {
1233 deps.WholeStaticLibs = append(deps.WholeStaticLibs,
Colin Crosse1bb5d02019-09-24 14:55:04 -07001234 library.StaticProperties.Static.Whole_static_libs...)
1235 deps.StaticLibs = append(deps.StaticLibs, library.StaticProperties.Static.Static_libs...)
1236 deps.SharedLibs = append(deps.SharedLibs, library.StaticProperties.Static.Shared_libs...)
Colin Crosseefe9a32019-01-22 14:41:08 -08001237
Colin Crosse1bb5d02019-09-24 14:55:04 -07001238 deps.ReexportSharedLibHeaders = append(deps.ReexportSharedLibHeaders, library.StaticProperties.Static.Export_shared_lib_headers...)
1239 deps.ReexportStaticLibHeaders = append(deps.ReexportStaticLibHeaders, library.StaticProperties.Static.Export_static_lib_headers...)
Colin Crossa48ab5b2017-02-14 15:28:44 -08001240 } else if library.shared() {
Colin Crossd1a28132021-06-21 17:34:47 -07001241 if !Bool(library.baseLinker.Properties.Nocrt) {
1242 deps.CrtBegin = append(deps.CrtBegin, ctx.toolchain().CrtBeginSharedLibrary()...)
1243 deps.CrtEnd = append(deps.CrtEnd, ctx.toolchain().CrtEndSharedLibrary()...)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001244 }
Colin Crosse1bb5d02019-09-24 14:55:04 -07001245 deps.WholeStaticLibs = append(deps.WholeStaticLibs, library.SharedProperties.Shared.Whole_static_libs...)
1246 deps.StaticLibs = append(deps.StaticLibs, library.SharedProperties.Shared.Static_libs...)
1247 deps.SharedLibs = append(deps.SharedLibs, library.SharedProperties.Shared.Shared_libs...)
Colin Crosseefe9a32019-01-22 14:41:08 -08001248
Colin Crosse1bb5d02019-09-24 14:55:04 -07001249 deps.ReexportSharedLibHeaders = append(deps.ReexportSharedLibHeaders, library.SharedProperties.Shared.Export_shared_lib_headers...)
1250 deps.ReexportStaticLibHeaders = append(deps.ReexportStaticLibHeaders, library.SharedProperties.Shared.Export_static_lib_headers...)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001251 }
Justin Yun6977e8a2020-10-29 18:24:11 +09001252 if ctx.inVendor() {
Jiyong Park52d25bd2017-10-13 09:17:01 +09001253 deps.WholeStaticLibs = removeListFromList(deps.WholeStaticLibs, library.baseLinker.Properties.Target.Vendor.Exclude_static_libs)
1254 deps.SharedLibs = removeListFromList(deps.SharedLibs, library.baseLinker.Properties.Target.Vendor.Exclude_shared_libs)
1255 deps.StaticLibs = removeListFromList(deps.StaticLibs, library.baseLinker.Properties.Target.Vendor.Exclude_static_libs)
Victor Chang51271c12019-01-30 16:02:22 +00001256 deps.ReexportSharedLibHeaders = removeListFromList(deps.ReexportSharedLibHeaders, library.baseLinker.Properties.Target.Vendor.Exclude_shared_libs)
1257 deps.ReexportStaticLibHeaders = removeListFromList(deps.ReexportStaticLibHeaders, library.baseLinker.Properties.Target.Vendor.Exclude_static_libs)
Jiyong Park52d25bd2017-10-13 09:17:01 +09001258 }
Justin Yun6977e8a2020-10-29 18:24:11 +09001259 if ctx.inProduct() {
1260 deps.WholeStaticLibs = removeListFromList(deps.WholeStaticLibs, library.baseLinker.Properties.Target.Product.Exclude_static_libs)
1261 deps.SharedLibs = removeListFromList(deps.SharedLibs, library.baseLinker.Properties.Target.Product.Exclude_shared_libs)
1262 deps.StaticLibs = removeListFromList(deps.StaticLibs, library.baseLinker.Properties.Target.Product.Exclude_static_libs)
1263 deps.ReexportSharedLibHeaders = removeListFromList(deps.ReexportSharedLibHeaders, library.baseLinker.Properties.Target.Product.Exclude_shared_libs)
1264 deps.ReexportStaticLibHeaders = removeListFromList(deps.ReexportStaticLibHeaders, library.baseLinker.Properties.Target.Product.Exclude_static_libs)
1265 }
Jiyong Parkf9332f12018-02-01 00:54:12 +09001266 if ctx.inRecovery() {
1267 deps.WholeStaticLibs = removeListFromList(deps.WholeStaticLibs, library.baseLinker.Properties.Target.Recovery.Exclude_static_libs)
1268 deps.SharedLibs = removeListFromList(deps.SharedLibs, library.baseLinker.Properties.Target.Recovery.Exclude_shared_libs)
1269 deps.StaticLibs = removeListFromList(deps.StaticLibs, library.baseLinker.Properties.Target.Recovery.Exclude_static_libs)
Victor Chang51271c12019-01-30 16:02:22 +00001270 deps.ReexportSharedLibHeaders = removeListFromList(deps.ReexportSharedLibHeaders, library.baseLinker.Properties.Target.Recovery.Exclude_shared_libs)
1271 deps.ReexportStaticLibHeaders = removeListFromList(deps.ReexportStaticLibHeaders, library.baseLinker.Properties.Target.Recovery.Exclude_static_libs)
Jiyong Parkf9332f12018-02-01 00:54:12 +09001272 }
Yifan Hongcf4832c2020-01-21 17:04:13 -08001273 if ctx.inRamdisk() {
1274 deps.WholeStaticLibs = removeListFromList(deps.WholeStaticLibs, library.baseLinker.Properties.Target.Ramdisk.Exclude_static_libs)
1275 deps.SharedLibs = removeListFromList(deps.SharedLibs, library.baseLinker.Properties.Target.Ramdisk.Exclude_shared_libs)
1276 deps.StaticLibs = removeListFromList(deps.StaticLibs, library.baseLinker.Properties.Target.Ramdisk.Exclude_static_libs)
1277 deps.ReexportSharedLibHeaders = removeListFromList(deps.ReexportSharedLibHeaders, library.baseLinker.Properties.Target.Ramdisk.Exclude_shared_libs)
1278 deps.ReexportStaticLibHeaders = removeListFromList(deps.ReexportStaticLibHeaders, library.baseLinker.Properties.Target.Ramdisk.Exclude_static_libs)
1279 }
Yifan Hong6da33c22020-10-27 15:01:21 -07001280 if ctx.inVendorRamdisk() {
1281 deps.WholeStaticLibs = removeListFromList(deps.WholeStaticLibs, library.baseLinker.Properties.Target.Vendor_ramdisk.Exclude_static_libs)
1282 deps.SharedLibs = removeListFromList(deps.SharedLibs, library.baseLinker.Properties.Target.Vendor_ramdisk.Exclude_shared_libs)
1283 deps.StaticLibs = removeListFromList(deps.StaticLibs, library.baseLinker.Properties.Target.Vendor_ramdisk.Exclude_static_libs)
1284 deps.ReexportSharedLibHeaders = removeListFromList(deps.ReexportSharedLibHeaders, library.baseLinker.Properties.Target.Vendor_ramdisk.Exclude_shared_libs)
1285 deps.ReexportStaticLibHeaders = removeListFromList(deps.ReexportStaticLibHeaders, library.baseLinker.Properties.Target.Vendor_ramdisk.Exclude_static_libs)
1286 }
Colin Cross2383f3b2018-02-06 14:40:13 -08001287
Colin Cross4d9c2d12016-07-29 12:48:20 -07001288 return deps
1289}
1290
Paul Duffin13f02712020-03-06 12:30:43 +00001291func (library *libraryDecorator) linkerSpecifiedDeps(specifiedDeps specifiedDeps) specifiedDeps {
1292 specifiedDeps = library.baseLinker.linkerSpecifiedDeps(specifiedDeps)
1293 var properties StaticOrSharedProperties
1294 if library.static() {
1295 properties = library.StaticProperties.Static
1296 } else if library.shared() {
1297 properties = library.SharedProperties.Shared
1298 }
1299
1300 specifiedDeps.sharedLibs = append(specifiedDeps.sharedLibs, properties.Shared_libs...)
Martin Stjernholm10566a02020-03-24 01:19:52 +00001301
1302 // Must distinguish nil and [] in system_shared_libs - ensure that [] in
1303 // either input list doesn't come out as nil.
1304 if specifiedDeps.systemSharedLibs == nil {
1305 specifiedDeps.systemSharedLibs = properties.System_shared_libs
1306 } else {
1307 specifiedDeps.systemSharedLibs = append(specifiedDeps.systemSharedLibs, properties.System_shared_libs...)
1308 }
Paul Duffin13f02712020-03-06 12:30:43 +00001309
1310 specifiedDeps.sharedLibs = android.FirstUniqueStrings(specifiedDeps.sharedLibs)
Martin Stjernholm10566a02020-03-24 01:19:52 +00001311 if len(specifiedDeps.systemSharedLibs) > 0 {
1312 // Skip this if systemSharedLibs is either nil or [], to ensure they are
1313 // retained.
1314 specifiedDeps.systemSharedLibs = android.FirstUniqueStrings(specifiedDeps.systemSharedLibs)
1315 }
Paul Duffin13f02712020-03-06 12:30:43 +00001316 return specifiedDeps
1317}
1318
Colin Crossb916a382016-07-29 17:28:03 -07001319func (library *libraryDecorator) linkStatic(ctx ModuleContext,
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001320 flags Flags, deps PathDeps, objs Objects) android.Path {
Colin Cross4d9c2d12016-07-29 12:48:20 -07001321
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001322 library.objects = deps.WholeStaticLibObjs.Copy()
1323 library.objects = library.objects.Append(objs)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001324
Inseob Kim0ce291e2019-07-04 14:38:27 +09001325 fileName := ctx.ModuleName() + staticLibraryExtension
Colin Cross86803cf2018-02-15 14:12:26 -08001326 outputFile := android.PathForModuleOut(ctx, fileName)
Dan Willemsen581341d2017-02-09 16:16:31 -08001327 builderFlags := flagsToBuilderFlags(flags)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001328
Dan Willemsen569edc52018-11-19 09:33:29 -08001329 if Bool(library.baseLinker.Properties.Use_version_lib) {
1330 if ctx.Host() {
1331 versionedOutputFile := outputFile
1332 outputFile = android.PathForModuleOut(ctx, "unversioned", fileName)
1333 library.injectVersionSymbol(ctx, outputFile, versionedOutputFile)
1334 } else {
1335 versionedOutputFile := android.PathForModuleOut(ctx, "versioned", fileName)
Jingwen Chen40fd90a2020-06-15 05:24:19 +00001336 library.distFile = versionedOutputFile
Dan Willemsen569edc52018-11-19 09:33:29 -08001337 library.injectVersionSymbol(ctx, outputFile, versionedOutputFile)
1338 }
Colin Cross86803cf2018-02-15 14:12:26 -08001339 }
1340
Chih-Hung Hsieh3bb934f2021-10-25 11:09:19 -07001341 transformObjToStaticLib(ctx, library.objects.objFiles, deps.WholeStaticLibsFromPrebuilts, builderFlags, outputFile, nil, objs.tidyFiles)
Dan Willemsen581341d2017-02-09 16:16:31 -08001342
Chris Parsonsbf4f55f2020-11-23 17:02:44 -05001343 library.coverageOutputFile = transformCoverageFilesToZip(ctx, library.objects, ctx.ModuleName())
Colin Cross4d9c2d12016-07-29 12:48:20 -07001344
Colin Cross4d9c2d12016-07-29 12:48:20 -07001345 ctx.CheckbuildFile(outputFile)
1346
Colin Cross649d8172020-12-10 12:30:21 -08001347 if library.static() {
1348 ctx.SetProvider(StaticLibraryInfoProvider, StaticLibraryInfo{
1349 StaticLibrary: outputFile,
1350 ReuseObjects: library.reuseObjects,
1351 Objects: library.objects,
Colin Cross0de8a1e2020-09-18 14:15:30 -07001352
Colin Cross649d8172020-12-10 12:30:21 -08001353 TransitiveStaticLibrariesForOrdering: android.NewDepSetBuilder(android.TOPOLOGICAL).
1354 Direct(outputFile).
1355 Transitive(deps.TranstiveStaticLibrariesForOrdering).
1356 Build(),
1357 })
1358 }
1359
1360 if library.header() {
1361 ctx.SetProvider(HeaderLibraryInfoProvider, HeaderLibraryInfo{})
1362 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07001363
Colin Cross4d9c2d12016-07-29 12:48:20 -07001364 return outputFile
1365}
1366
Chih-Hung Hsiehf6ca1b92021-12-05 18:02:50 -08001367func ndkSharedLibDeps(ctx ModuleContext) android.Paths {
1368 if ctx.Module().(*Module).IsSdkVariant() {
1369 // The NDK sysroot timestamp file depends on all the NDK
1370 // sysroot header and shared library files.
1371 return android.Paths{getNdkBaseTimestampFile(ctx)}
1372 }
1373 return nil
1374}
1375
Colin Crossb916a382016-07-29 17:28:03 -07001376func (library *libraryDecorator) linkShared(ctx ModuleContext,
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001377 flags Flags, deps PathDeps, objs Objects) android.Path {
Colin Cross4d9c2d12016-07-29 12:48:20 -07001378
1379 var linkerDeps android.Paths
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001380 linkerDeps = append(linkerDeps, flags.LdFlagsDeps...)
Chih-Hung Hsiehf6ca1b92021-12-05 18:02:50 -08001381 linkerDeps = append(linkerDeps, ndkSharedLibDeps(ctx)...)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001382
Colin Cross2383f3b2018-02-06 14:40:13 -08001383 unexportedSymbols := ctx.ExpandOptionalSource(library.Properties.Unexported_symbols_list, "unexported_symbols_list")
1384 forceNotWeakSymbols := ctx.ExpandOptionalSource(library.Properties.Force_symbols_not_weak_list, "force_symbols_not_weak_list")
1385 forceWeakSymbols := ctx.ExpandOptionalSource(library.Properties.Force_symbols_weak_list, "force_symbols_weak_list")
Colin Cross4d9c2d12016-07-29 12:48:20 -07001386 if !ctx.Darwin() {
Colin Cross4d9c2d12016-07-29 12:48:20 -07001387 if unexportedSymbols.Valid() {
1388 ctx.PropertyErrorf("unexported_symbols_list", "Only supported on Darwin")
1389 }
1390 if forceNotWeakSymbols.Valid() {
1391 ctx.PropertyErrorf("force_symbols_not_weak_list", "Only supported on Darwin")
1392 }
1393 if forceWeakSymbols.Valid() {
1394 ctx.PropertyErrorf("force_symbols_weak_list", "Only supported on Darwin")
1395 }
1396 } else {
Colin Cross4d9c2d12016-07-29 12:48:20 -07001397 if unexportedSymbols.Valid() {
Colin Cross4af21ed2019-11-04 09:37:55 -08001398 flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,-unexported_symbols_list,"+unexportedSymbols.String())
Colin Cross4d9c2d12016-07-29 12:48:20 -07001399 linkerDeps = append(linkerDeps, unexportedSymbols.Path())
1400 }
1401 if forceNotWeakSymbols.Valid() {
Colin Cross4af21ed2019-11-04 09:37:55 -08001402 flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,-force_symbols_not_weak_list,"+forceNotWeakSymbols.String())
Colin Cross4d9c2d12016-07-29 12:48:20 -07001403 linkerDeps = append(linkerDeps, forceNotWeakSymbols.Path())
1404 }
1405 if forceWeakSymbols.Valid() {
Colin Cross4af21ed2019-11-04 09:37:55 -08001406 flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,-force_symbols_weak_list,"+forceWeakSymbols.String())
Colin Cross4d9c2d12016-07-29 12:48:20 -07001407 linkerDeps = append(linkerDeps, forceWeakSymbols.Path())
1408 }
1409 }
Colin Cross8e21aa52020-09-28 18:28:02 -07001410 if library.versionScriptPath.Valid() {
Jiyong Parkc1e7f482019-01-12 13:39:10 +09001411 linkerScriptFlags := "-Wl,--version-script," + library.versionScriptPath.String()
Colin Cross4af21ed2019-11-04 09:37:55 -08001412 flags.Local.LdFlags = append(flags.Local.LdFlags, linkerScriptFlags)
Colin Cross8e21aa52020-09-28 18:28:02 -07001413 linkerDeps = append(linkerDeps, library.versionScriptPath.Path())
Jiyong Parkc1e7f482019-01-12 13:39:10 +09001414 }
Colin Cross4d9c2d12016-07-29 12:48:20 -07001415
1416 fileName := library.getLibName(ctx) + flags.Toolchain.ShlibSuffix()
1417 outputFile := android.PathForModuleOut(ctx, fileName)
Colin Cross0de8a1e2020-09-18 14:15:30 -07001418 unstrippedOutputFile := outputFile
Colin Cross4d9c2d12016-07-29 12:48:20 -07001419
Josh Gao75a50a22019-06-07 17:58:59 -07001420 var implicitOutputs android.WritablePaths
1421 if ctx.Windows() {
1422 importLibraryPath := android.PathForModuleOut(ctx, pathtools.ReplaceExtension(fileName, "lib"))
1423
Colin Cross4af21ed2019-11-04 09:37:55 -08001424 flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,--out-implib="+importLibraryPath.String())
Josh Gao75a50a22019-06-07 17:58:59 -07001425 implicitOutputs = append(implicitOutputs, importLibraryPath)
1426 }
1427
Colin Cross4d9c2d12016-07-29 12:48:20 -07001428 builderFlags := flagsToBuilderFlags(flags)
1429
Dan Willemsen47450072021-10-19 20:24:49 -07001430 if ctx.Darwin() && deps.DarwinSecondArchOutput.Valid() {
1431 fatOutputFile := outputFile
1432 outputFile = android.PathForModuleOut(ctx, "pre-fat", fileName)
1433 transformDarwinUniversalBinary(ctx, fatOutputFile, outputFile, deps.DarwinSecondArchOutput.Path())
1434 }
1435
Colin Crossb496cfd2018-09-10 16:50:05 -07001436 // Optimize out relinking against shared libraries whose interface hasn't changed by
1437 // depending on a table of contents file instead of the library itself.
Colin Cross70dda7e2019-10-01 22:05:35 -07001438 tocFile := outputFile.ReplaceExtension(ctx, flags.Toolchain.ShlibSuffix()[1:]+".toc")
Colin Crossb496cfd2018-09-10 16:50:05 -07001439 library.tocFile = android.OptionalPathForPath(tocFile)
Ivan Lozano7b0781d2021-11-03 15:30:18 -04001440 TransformSharedObjectToToc(ctx, outputFile, tocFile)
Colin Cross89562dc2016-10-03 17:47:19 -07001441
Thiébaud Weksteend4587452020-08-19 14:53:01 +02001442 stripFlags := flagsToStripFlags(flags)
Colin Crossadc81a02020-12-14 17:01:55 -08001443 needsStrip := library.stripper.NeedsStrip(ctx)
1444 if library.buildStubs() {
1445 // No need to strip stubs libraries
1446 needsStrip = false
1447 }
1448 if needsStrip {
Yi Kongb5c34d72018-11-07 16:28:49 -08001449 if ctx.Darwin() {
Thiébaud Weksteend4587452020-08-19 14:53:01 +02001450 stripFlags.StripUseGnuStrip = true
Yi Kongb5c34d72018-11-07 16:28:49 -08001451 }
Colin Cross4d9c2d12016-07-29 12:48:20 -07001452 strippedOutputFile := outputFile
1453 outputFile = android.PathForModuleOut(ctx, "unstripped", fileName)
Thiébaud Weksteend4587452020-08-19 14:53:01 +02001454 library.stripper.StripExecutableOrSharedLib(ctx, outputFile, strippedOutputFile, stripFlags)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001455 }
Colin Crossb60190a2018-09-04 16:28:17 -07001456 library.unstrippedOutputFile = outputFile
1457
Colin Crossd7227f92019-09-05 14:26:33 -07001458 outputFile = maybeInjectBoringSSLHash(ctx, outputFile, library.Properties.Inject_bssl_hash, fileName)
Pete Bentley803e1612019-08-06 22:19:59 +01001459
Dan Willemsen569edc52018-11-19 09:33:29 -08001460 if Bool(library.baseLinker.Properties.Use_version_lib) {
1461 if ctx.Host() {
1462 versionedOutputFile := outputFile
1463 outputFile = android.PathForModuleOut(ctx, "unversioned", fileName)
1464 library.injectVersionSymbol(ctx, outputFile, versionedOutputFile)
1465 } else {
1466 versionedOutputFile := android.PathForModuleOut(ctx, "versioned", fileName)
Jingwen Chen40fd90a2020-06-15 05:24:19 +00001467 library.distFile = versionedOutputFile
Dan Willemsen569edc52018-11-19 09:33:29 -08001468
Thiébaud Weksteend4587452020-08-19 14:53:01 +02001469 if library.stripper.NeedsStrip(ctx) {
Dan Willemsen569edc52018-11-19 09:33:29 -08001470 out := android.PathForModuleOut(ctx, "versioned-stripped", fileName)
Jingwen Chen40fd90a2020-06-15 05:24:19 +00001471 library.distFile = out
Thiébaud Weksteend4587452020-08-19 14:53:01 +02001472 library.stripper.StripExecutableOrSharedLib(ctx, versionedOutputFile, out, stripFlags)
Dan Willemsen569edc52018-11-19 09:33:29 -08001473 }
1474
1475 library.injectVersionSymbol(ctx, outputFile, versionedOutputFile)
1476 }
Colin Cross86803cf2018-02-15 14:12:26 -08001477 }
1478
Jiyong Park64a44f22019-01-18 14:37:08 +09001479 sharedLibs := deps.EarlySharedLibs
1480 sharedLibs = append(sharedLibs, deps.SharedLibs...)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001481 sharedLibs = append(sharedLibs, deps.LateSharedLibs...)
1482
Jiyong Park64a44f22019-01-18 14:37:08 +09001483 linkerDeps = append(linkerDeps, deps.EarlySharedLibsDeps...)
Colin Cross26c34ed2016-09-30 17:10:16 -07001484 linkerDeps = append(linkerDeps, deps.SharedLibsDeps...)
1485 linkerDeps = append(linkerDeps, deps.LateSharedLibsDeps...)
Chris Parsonsbf4f55f2020-11-23 17:02:44 -05001486 transformObjToDynamicBinary(ctx, objs.objFiles, sharedLibs,
Colin Cross4d9c2d12016-07-29 12:48:20 -07001487 deps.StaticLibs, deps.LateStaticLibs, deps.WholeStaticLibs,
Chih-Hung Hsieh3bb934f2021-10-25 11:09:19 -07001488 linkerDeps, deps.CrtBegin, deps.CrtEnd, false, builderFlags, outputFile, implicitOutputs, objs.tidyFiles)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001489
Dan Willemsen581341d2017-02-09 16:16:31 -08001490 objs.coverageFiles = append(objs.coverageFiles, deps.StaticLibObjs.coverageFiles...)
1491 objs.coverageFiles = append(objs.coverageFiles, deps.WholeStaticLibObjs.coverageFiles...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001492
1493 objs.sAbiDumpFiles = append(objs.sAbiDumpFiles, deps.StaticLibObjs.sAbiDumpFiles...)
1494 objs.sAbiDumpFiles = append(objs.sAbiDumpFiles, deps.WholeStaticLibObjs.sAbiDumpFiles...)
1495
Chris Parsonsbf4f55f2020-11-23 17:02:44 -05001496 library.coverageOutputFile = transformCoverageFilesToZip(ctx, objs, library.getLibName(ctx))
Colin Cross0de8a1e2020-09-18 14:15:30 -07001497 library.linkSAbiDumpFiles(ctx, objs, fileName, unstrippedOutputFile)
Dan Willemsen581341d2017-02-09 16:16:31 -08001498
Liz Kammeref6dfea2021-06-08 15:37:09 -04001499 var transitiveStaticLibrariesForOrdering *android.DepSet
Colin Cross0de8a1e2020-09-18 14:15:30 -07001500 if static := ctx.GetDirectDepsWithTag(staticVariantTag); len(static) > 0 {
1501 s := ctx.OtherModuleProvider(static[0], StaticLibraryInfoProvider).(StaticLibraryInfo)
Liz Kammeref6dfea2021-06-08 15:37:09 -04001502 transitiveStaticLibrariesForOrdering = s.TransitiveStaticLibrariesForOrdering
Colin Cross0de8a1e2020-09-18 14:15:30 -07001503 }
1504
1505 ctx.SetProvider(SharedLibraryInfoProvider, SharedLibraryInfo{
Liz Kammeref6dfea2021-06-08 15:37:09 -04001506 TableOfContents: android.OptionalPathForPath(tocFile),
1507 SharedLibrary: unstrippedOutputFile,
1508 TransitiveStaticLibrariesForOrdering: transitiveStaticLibrariesForOrdering,
1509 Target: ctx.Target(),
Colin Cross0de8a1e2020-09-18 14:15:30 -07001510 })
1511
1512 stubs := ctx.GetDirectDepsWithTag(stubImplDepTag)
1513 if len(stubs) > 0 {
Chris Parsons3c27ca32020-11-20 12:42:07 -05001514 var stubsInfo []SharedStubLibrary
Colin Cross0de8a1e2020-09-18 14:15:30 -07001515 for _, stub := range stubs {
1516 stubInfo := ctx.OtherModuleProvider(stub, SharedLibraryInfoProvider).(SharedLibraryInfo)
1517 flagInfo := ctx.OtherModuleProvider(stub, FlagExporterInfoProvider).(FlagExporterInfo)
Chris Parsons3c27ca32020-11-20 12:42:07 -05001518 stubsInfo = append(stubsInfo, SharedStubLibrary{
Colin Cross31076b32020-10-23 17:22:06 -07001519 Version: moduleLibraryInterface(stub).stubsVersion(),
Colin Cross0de8a1e2020-09-18 14:15:30 -07001520 SharedLibraryInfo: stubInfo,
1521 FlagExporterInfo: flagInfo,
1522 })
1523 }
Chris Parsons3c27ca32020-11-20 12:42:07 -05001524 ctx.SetProvider(SharedLibraryStubsProvider, SharedLibraryStubsInfo{
1525 SharedStubLibraries: stubsInfo,
Colin Cross0de8a1e2020-09-18 14:15:30 -07001526
Colin Cross127bb8b2020-12-16 16:46:01 -08001527 IsLLNDK: ctx.IsLlndk(),
Colin Cross0de8a1e2020-09-18 14:15:30 -07001528 })
1529 }
1530
1531 return unstrippedOutputFile
Colin Cross4d9c2d12016-07-29 12:48:20 -07001532}
1533
Jiyong Parkaf6d8952019-01-31 12:21:23 +09001534func (library *libraryDecorator) unstrippedOutputFilePath() android.Path {
1535 return library.unstrippedOutputFile
1536}
1537
Thiébaud Weksteend4587452020-08-19 14:53:01 +02001538func (library *libraryDecorator) disableStripping() {
1539 library.stripper.StripProperties.Strip.None = BoolPtr(true)
1540}
1541
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001542func (library *libraryDecorator) nativeCoverage() bool {
1543 if library.header() || library.buildStubs() {
1544 return false
1545 }
1546 return true
1547}
1548
Jiyong Parkee9a98d2019-08-09 14:44:36 +09001549func (library *libraryDecorator) coverageOutputFilePath() android.OptionalPath {
1550 return library.coverageOutputFile
1551}
1552
Logan Chien7eefdc42018-07-11 18:10:41 +08001553func getRefAbiDumpFile(ctx ModuleContext, vndkVersion, fileName string) android.Path {
Hsin-Yi Chen27d235f2020-03-26 17:50:29 +08001554 // The logic must be consistent with classifySourceAbiDump.
Colin Cross95f1ca02020-10-29 20:47:22 -07001555 isNdk := ctx.isNdk(ctx.Config())
Colin Cross127bb8b2020-12-16 16:46:01 -08001556 isLlndkOrVndk := ctx.IsLlndkPublic() || (ctx.useVndk() && ctx.isVndk())
Logan Chien7eefdc42018-07-11 18:10:41 +08001557
Hsin-Yi Chen53489642019-07-31 17:10:45 +08001558 refAbiDumpTextFile := android.PathForVndkRefAbiDump(ctx, vndkVersion, fileName, isNdk, isLlndkOrVndk, false)
1559 refAbiDumpGzipFile := android.PathForVndkRefAbiDump(ctx, vndkVersion, fileName, isNdk, isLlndkOrVndk, true)
Logan Chien7eefdc42018-07-11 18:10:41 +08001560
1561 if refAbiDumpTextFile.Valid() {
1562 if refAbiDumpGzipFile.Valid() {
1563 ctx.ModuleErrorf(
1564 "Two reference ABI dump files are found: %q and %q. Please delete the stale one.",
1565 refAbiDumpTextFile, refAbiDumpGzipFile)
1566 return nil
1567 }
1568 return refAbiDumpTextFile.Path()
1569 }
1570 if refAbiDumpGzipFile.Valid() {
Chris Parsonsbf4f55f2020-11-23 17:02:44 -05001571 return unzipRefDump(ctx, refAbiDumpGzipFile.Path(), fileName)
Logan Chien7eefdc42018-07-11 18:10:41 +08001572 }
1573 return nil
1574}
1575
Jayant Chowdhary6ab3d842017-06-26 12:52:58 -07001576func (library *libraryDecorator) linkSAbiDumpFiles(ctx ModuleContext, objs Objects, fileName string, soFile android.Path) {
Yo Chiang2bbadfa2020-12-14 11:42:16 +08001577 if library.sabi.shouldCreateSourceAbiDump() {
Inseob Kim96f17f02020-06-09 22:05:09 +09001578 var vndkVersion string
1579
1580 if ctx.useVndk() {
1581 // For modules linking against vndk, follow its vndk version
1582 vndkVersion = ctx.Module().(*Module).VndkVersion()
1583 } else {
1584 // Regard the other modules as PLATFORM_VNDK_VERSION
1585 vndkVersion = ctx.DeviceConfig().PlatformVndkVersion()
Logan Chienf3511742017-10-31 18:04:35 +08001586 }
1587
Jayant Chowdharya4fce192017-09-06 13:10:03 -07001588 exportIncludeDirs := library.flagExporter.exportedIncludes(ctx)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001589 var SourceAbiFlags []string
1590 for _, dir := range exportIncludeDirs.Strings() {
Jayant Chowdhary715cac32017-04-20 06:53:59 -07001591 SourceAbiFlags = append(SourceAbiFlags, "-I"+dir)
1592 }
Inseob Kim69378442019-06-03 19:10:47 +09001593 for _, reexportedInclude := range library.sabi.Properties.ReexportedIncludes {
1594 SourceAbiFlags = append(SourceAbiFlags, "-I"+reexportedInclude)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001595 }
1596 exportedHeaderFlags := strings.Join(SourceAbiFlags, " ")
Chris Parsonsbf4f55f2020-11-23 17:02:44 -05001597 library.sAbiOutputFile = transformDumpToLinkedDump(ctx, objs.sAbiDumpFiles, soFile, fileName, exportedHeaderFlags,
Jiyong Parka034b832019-08-27 14:02:19 +09001598 android.OptionalPathForModuleSrc(ctx, library.symbolFileForAbiCheck(ctx)),
Logan Chiene3d7a0d2019-01-17 00:18:02 +08001599 library.Properties.Header_abi_checker.Exclude_symbol_versions,
1600 library.Properties.Header_abi_checker.Exclude_symbol_tags)
Logan Chien2f2b8902018-07-10 15:01:19 +08001601
Yo Chiang2bbadfa2020-12-14 11:42:16 +08001602 addLsdumpPath(classifySourceAbiDump(ctx) + ":" + library.sAbiOutputFile.String())
Hsin-Yi Chen53489642019-07-31 17:10:45 +08001603
Logan Chien7eefdc42018-07-11 18:10:41 +08001604 refAbiDumpFile := getRefAbiDumpFile(ctx, vndkVersion, fileName)
1605 if refAbiDumpFile != nil {
Chris Parsonsbf4f55f2020-11-23 17:02:44 -05001606 library.sAbiDiff = sourceAbiDiff(ctx, library.sAbiOutputFile.Path(),
Logan Chien2a65dda2019-10-01 15:58:07 -07001607 refAbiDumpFile, fileName, exportedHeaderFlags,
1608 Bool(library.Properties.Header_abi_checker.Check_all_apis),
Colin Cross127bb8b2020-12-16 16:46:01 -08001609 ctx.IsLlndk(), ctx.isNdk(ctx.Config()), ctx.IsVndkExt())
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001610 }
1611 }
1612}
1613
Inseob Kimcc12d902021-05-14 20:15:55 +09001614func processLLNDKHeaders(ctx ModuleContext, srcHeaderDir string, outDir android.ModuleGenPath) (timestamp android.Path, installPaths android.WritablePaths) {
Colin Cross127bb8b2020-12-16 16:46:01 -08001615 srcDir := android.PathForModuleSrc(ctx, srcHeaderDir)
1616 srcFiles := ctx.GlobFiles(filepath.Join(srcDir.String(), "**/*.h"), nil)
1617
Colin Cross127bb8b2020-12-16 16:46:01 -08001618 for _, header := range srcFiles {
1619 headerDir := filepath.Dir(header.String())
1620 relHeaderDir, err := filepath.Rel(srcDir.String(), headerDir)
1621 if err != nil {
1622 ctx.ModuleErrorf("filepath.Rel(%q, %q) failed: %s",
1623 srcDir.String(), headerDir, err)
1624 continue
1625 }
1626
1627 installPaths = append(installPaths, outDir.Join(ctx, relHeaderDir, header.Base()))
1628 }
1629
Inseob Kimcc12d902021-05-14 20:15:55 +09001630 return processHeadersWithVersioner(ctx, srcDir, outDir, srcFiles, installPaths), installPaths
Colin Cross127bb8b2020-12-16 16:46:01 -08001631}
1632
Chris Parsons3c27ca32020-11-20 12:42:07 -05001633// link registers actions to link this library, and sets various fields
1634// on this library to reflect information that should be exported up the build
1635// tree (for example, exported flags and include paths).
Colin Crossb916a382016-07-29 17:28:03 -07001636func (library *libraryDecorator) link(ctx ModuleContext,
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001637 flags Flags, deps PathDeps, objs Objects) android.Path {
Colin Cross4d9c2d12016-07-29 12:48:20 -07001638
Colin Cross127bb8b2020-12-16 16:46:01 -08001639 if ctx.IsLlndk() {
1640 if len(library.Properties.Llndk.Export_preprocessed_headers) > 0 {
1641 // This is the vendor variant of an LLNDK library with preprocessed headers.
1642 genHeaderOutDir := android.PathForModuleGen(ctx, "include")
1643
1644 var timestampFiles android.Paths
1645 for _, dir := range library.Properties.Llndk.Export_preprocessed_headers {
Inseob Kimcc12d902021-05-14 20:15:55 +09001646 timestampFile, installPaths := processLLNDKHeaders(ctx, dir, genHeaderOutDir)
1647 timestampFiles = append(timestampFiles, timestampFile)
1648 library.addExportedGeneratedHeaders(installPaths.Paths()...)
Colin Cross127bb8b2020-12-16 16:46:01 -08001649 }
1650
1651 if Bool(library.Properties.Llndk.Export_headers_as_system) {
1652 library.reexportSystemDirs(genHeaderOutDir)
1653 } else {
1654 library.reexportDirs(genHeaderOutDir)
1655 }
1656
1657 library.reexportDeps(timestampFiles...)
1658 }
1659
Colin Cross0fb7fcd2021-03-02 11:00:07 -08001660 // override the module's export_include_dirs with llndk.override_export_include_dirs
1661 // if it is set.
1662 if override := library.Properties.Llndk.Override_export_include_dirs; override != nil {
1663 library.flagExporter.Properties.Export_include_dirs = override
1664 }
1665
Colin Cross127bb8b2020-12-16 16:46:01 -08001666 if Bool(library.Properties.Llndk.Export_headers_as_system) {
1667 library.flagExporter.Properties.Export_system_include_dirs = append(
1668 library.flagExporter.Properties.Export_system_include_dirs,
1669 library.flagExporter.Properties.Export_include_dirs...)
1670 library.flagExporter.Properties.Export_include_dirs = nil
1671 }
1672 }
1673
Colin Cross5271fea2021-04-27 13:06:04 -07001674 if ctx.IsVendorPublicLibrary() {
1675 // override the module's export_include_dirs with vendor_public_library.override_export_include_dirs
1676 // if it is set.
1677 if override := library.Properties.Vendor_public_library.Override_export_include_dirs; override != nil {
1678 library.flagExporter.Properties.Export_include_dirs = override
1679 }
1680 }
1681
Chris Parsons3c27ca32020-11-20 12:42:07 -05001682 // Linking this library consists of linking `deps.Objs` (.o files in dependencies
1683 // of this library), together with `objs` (.o files created by compiling this
1684 // library).
Colin Crossad59e752017-11-16 14:29:11 -08001685 objs = deps.Objs.Copy().Append(objs)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001686 var out android.Path
Colin Crossa48ab5b2017-02-14 15:28:44 -08001687 if library.static() || library.header() {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001688 out = library.linkStatic(ctx, flags, deps, objs)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001689 } else {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001690 out = library.linkShared(ctx, flags, deps, objs)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001691 }
1692
Chris Parsons3c27ca32020-11-20 12:42:07 -05001693 // Export include paths and flags to be propagated up the tree.
Inseob Kim69378442019-06-03 19:10:47 +09001694 library.exportIncludes(ctx)
1695 library.reexportDirs(deps.ReexportedDirs...)
1696 library.reexportSystemDirs(deps.ReexportedSystemDirs...)
1697 library.reexportFlags(deps.ReexportedFlags...)
1698 library.reexportDeps(deps.ReexportedDeps...)
Inseob Kimd110f872019-12-06 13:15:38 +09001699 library.addExportedGeneratedHeaders(deps.ReexportedGeneratedHeaders...)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001700
Chris Parsons3c27ca32020-11-20 12:42:07 -05001701 // Optionally export aidl headers.
Nan Zhang0007d812017-11-07 10:57:05 -08001702 if Bool(library.Properties.Aidl.Export_aidl_headers) {
Dan Willemsene1240db2016-11-03 14:28:51 -07001703 if library.baseCompiler.hasSrcExt(".aidl") {
Jiyong Park74955042019-10-22 20:19:51 +09001704 dir := android.PathForModuleGen(ctx, "aidl")
Inseob Kim69378442019-06-03 19:10:47 +09001705 library.reexportDirs(dir)
Inseob Kimd110f872019-12-06 13:15:38 +09001706
Paul Duffin33056e82021-02-19 13:49:08 +00001707 library.reexportDeps(library.baseCompiler.aidlOrderOnlyDeps...)
1708 library.addExportedGeneratedHeaders(library.baseCompiler.aidlHeaders...)
Dan Willemsene1240db2016-11-03 14:28:51 -07001709 }
1710 }
1711
Chris Parsons3c27ca32020-11-20 12:42:07 -05001712 // Optionally export proto headers.
Nan Zhang0007d812017-11-07 10:57:05 -08001713 if Bool(library.Properties.Proto.Export_proto_headers) {
Dan Willemsene1240db2016-11-03 14:28:51 -07001714 if library.baseCompiler.hasSrcExt(".proto") {
Jiyong Park74955042019-10-22 20:19:51 +09001715 var includes android.Paths
Colin Cross19878da2019-03-28 14:45:07 -07001716 if flags.proto.CanonicalPathFromRoot {
Jiyong Park74955042019-10-22 20:19:51 +09001717 includes = append(includes, flags.proto.SubDir)
Colin Cross10d22312017-05-03 11:01:58 -07001718 }
Jiyong Park74955042019-10-22 20:19:51 +09001719 includes = append(includes, flags.proto.Dir)
Inseob Kim69378442019-06-03 19:10:47 +09001720 library.reexportDirs(includes...)
Inseob Kimd110f872019-12-06 13:15:38 +09001721
Paul Duffin33056e82021-02-19 13:49:08 +00001722 library.reexportDeps(library.baseCompiler.protoOrderOnlyDeps...)
1723 library.addExportedGeneratedHeaders(library.baseCompiler.protoHeaders...)
Colin Cross0c461f12016-10-20 16:11:43 -07001724 }
1725 }
1726
Inseob Kim07def122020-11-23 14:43:02 +09001727 // If the library is sysprop_library, expose either public or internal header selectively.
Inseob Kim21f26902018-09-06 00:55:20 +09001728 if library.baseCompiler.hasSrcExt(".sysprop") {
Jiyong Park74955042019-10-22 20:19:51 +09001729 dir := android.PathForModuleGen(ctx, "sysprop", "include")
Inseob Kimc0907f12019-02-08 21:00:45 +09001730 if library.Properties.Sysprop.Platform != nil {
Inseob Kimc0907f12019-02-08 21:00:45 +09001731 isOwnerPlatform := Bool(library.Properties.Sysprop.Platform)
1732
Inseob Kim07def122020-11-23 14:43:02 +09001733 // If the owner is different from the user, expose public header. That is,
1734 // 1) if the user is product (as owner can only be platform / vendor)
Inseob Kim06410042021-01-18 15:23:28 +09001735 // 2) if the owner is platform and the client is vendor
1736 // We don't care Platform -> Vendor dependency as it's already forbidden.
1737 if ctx.Device() && (ctx.ProductSpecific() || (isOwnerPlatform && ctx.inVendor())) {
Jiyong Park74955042019-10-22 20:19:51 +09001738 dir = android.PathForModuleGen(ctx, "sysprop/public", "include")
Inseob Kimc0907f12019-02-08 21:00:45 +09001739 }
1740 }
1741
Paul Duffin37e0de52021-02-19 17:05:39 +00001742 // Make sure to only export headers which are within the include directory.
1743 _, headers := android.FilterPathListPredicate(library.baseCompiler.syspropHeaders, func(path android.Path) bool {
1744 _, isRel := android.MaybeRel(ctx, dir.String(), path.String())
1745 return isRel
1746 })
1747
Chris Parsons3c27ca32020-11-20 12:42:07 -05001748 // Add sysprop-related directories to the exported directories of this library.
Inseob Kim69378442019-06-03 19:10:47 +09001749 library.reexportDirs(dir)
Paul Duffin33056e82021-02-19 13:49:08 +00001750 library.reexportDeps(library.baseCompiler.syspropOrderOnlyDeps...)
Paul Duffin37e0de52021-02-19 17:05:39 +00001751 library.addExportedGeneratedHeaders(headers...)
Inseob Kim21f26902018-09-06 00:55:20 +09001752 }
1753
Chris Parsons3c27ca32020-11-20 12:42:07 -05001754 // Add stub-related flags if this library is a stub library.
Jiyong Park892a98f2020-12-14 09:20:00 +09001755 library.exportVersioningMacroIfNeeded(ctx)
Jiyong Parkda732bd2018-11-02 18:23:15 +09001756
Chris Parsons3c27ca32020-11-20 12:42:07 -05001757 // Propagate a Provider containing information about exported flags, deps, and include paths.
Colin Cross0de8a1e2020-09-18 14:15:30 -07001758 library.flagExporter.setProvider(ctx)
1759
Colin Cross4d9c2d12016-07-29 12:48:20 -07001760 return out
1761}
1762
Jiyong Park892a98f2020-12-14 09:20:00 +09001763func (library *libraryDecorator) exportVersioningMacroIfNeeded(ctx android.BaseModuleContext) {
Colin Cross127bb8b2020-12-16 16:46:01 -08001764 if library.buildStubs() && library.stubsVersion() != "" && !library.skipAPIDefine {
Jiyong Park892a98f2020-12-14 09:20:00 +09001765 name := versioningMacroName(ctx.Module().(*Module).ImplementationModuleName(ctx))
Jooyung Han11b0fbd2021-02-05 02:28:22 +09001766 apiLevel, err := android.ApiLevelFromUser(ctx, library.stubsVersion())
1767 if err != nil {
1768 ctx.ModuleErrorf("Can't export version macro: %s", err.Error())
1769 }
1770 library.reexportFlags("-D" + name + "=" + strconv.Itoa(apiLevel.FinalOrPreviewInt()))
Jiyong Park892a98f2020-12-14 09:20:00 +09001771 }
1772}
1773
Chris Parsons3c27ca32020-11-20 12:42:07 -05001774// buildStatic returns true if this library should be built as a static library.
Colin Crossb916a382016-07-29 17:28:03 -07001775func (library *libraryDecorator) buildStatic() bool {
Colin Crosse1bb5d02019-09-24 14:55:04 -07001776 return library.MutatedProperties.BuildStatic &&
1777 BoolDefault(library.StaticProperties.Static.Enabled, true)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001778}
1779
Chris Parsons3c27ca32020-11-20 12:42:07 -05001780// buildShared returns true if this library should be built as a shared library.
Colin Crossb916a382016-07-29 17:28:03 -07001781func (library *libraryDecorator) buildShared() bool {
Colin Crosse1bb5d02019-09-24 14:55:04 -07001782 return library.MutatedProperties.BuildShared &&
1783 BoolDefault(library.SharedProperties.Shared.Enabled, true)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001784}
1785
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001786func (library *libraryDecorator) objs() Objects {
1787 return library.objects
Colin Cross4d9c2d12016-07-29 12:48:20 -07001788}
1789
Colin Cross0de8a1e2020-09-18 14:15:30 -07001790func (library *libraryDecorator) reuseObjs() Objects {
1791 return library.reuseObjects
Colin Cross4d9c2d12016-07-29 12:48:20 -07001792}
1793
Colin Cross26c34ed2016-09-30 17:10:16 -07001794func (library *libraryDecorator) toc() android.OptionalPath {
1795 return library.tocFile
1796}
1797
Jiyong Parkf1194352019-02-25 11:05:47 +09001798func (library *libraryDecorator) installSymlinkToRuntimeApex(ctx ModuleContext, file android.Path) {
1799 dir := library.baseInstaller.installDir(ctx)
1800 dirOnDevice := android.InstallPathToOnDevicePath(ctx, dir)
1801 target := "/" + filepath.Join("apex", "com.android.runtime", dir.Base(), "bionic", file.Base())
1802 ctx.InstallAbsoluteSymlink(dir, file.Base(), target)
Jaewoong Jung18aefc12020-12-21 09:11:10 -08001803 library.postInstallCmds = append(library.postInstallCmds, makeSymlinkCmd(dirOnDevice, file.Base(), target))
Jiyong Parkf1194352019-02-25 11:05:47 +09001804}
1805
Colin Crossb916a382016-07-29 17:28:03 -07001806func (library *libraryDecorator) install(ctx ModuleContext, file android.Path) {
Colin Crossc43ae772017-04-14 15:42:53 -07001807 if library.shared() {
Justin Yun8fe12122017-12-07 17:18:15 +09001808 if ctx.Device() && ctx.useVndk() {
Jooyung Han261e1582020-10-20 18:54:21 +09001809 // set subDir for VNDK extensions
Ivan Lozanof9e21722020-12-02 09:00:51 -05001810 if ctx.IsVndkExt() {
Jooyung Han261e1582020-10-20 18:54:21 +09001811 if ctx.isVndkSp() {
1812 library.baseInstaller.subDir = "vndk-sp"
1813 } else {
1814 library.baseInstaller.subDir = "vndk"
1815 }
1816 }
1817
Justin Yun31094b12020-12-24 16:11:23 +09001818 // In some cases we want to use core variant for VNDK-Core libs.
1819 // Skip product variant since VNDKs use only the vendor variant.
1820 if ctx.isVndk() && !ctx.isVndkSp() && !ctx.IsVndkExt() && !ctx.inProduct() {
Vic Yang1a5812a2020-01-31 10:38:40 -08001821 mayUseCoreVariant := true
1822
1823 if ctx.mustUseVendorVariant() {
1824 mayUseCoreVariant = false
1825 }
1826
Elvis Chien9c993542021-06-25 01:15:17 +08001827 if ctx.Config().CFIEnabledForPath(ctx.ModuleDir()) {
Vic Yang1a5812a2020-01-31 10:38:40 -08001828 mayUseCoreVariant = false
1829 }
1830
1831 if mayUseCoreVariant {
Vic Yangd92090f2020-01-08 14:32:28 -08001832 library.checkSameCoreVariant = true
1833 if ctx.DeviceConfig().VndkUseCoreVariant() {
1834 library.useCoreVariant = true
1835 }
Vic Yangefd249e2018-11-12 20:19:56 -08001836 }
Justin Yun8fe12122017-12-07 17:18:15 +09001837 }
Logan Chienf3511742017-10-31 18:04:35 +08001838
Jooyung Han261e1582020-10-20 18:54:21 +09001839 // do not install vndk libs
1840 // vndk libs are packaged into VNDK APEX
Ivan Lozanof9e21722020-12-02 09:00:51 -05001841 if ctx.isVndk() && !ctx.IsVndkExt() {
Jooyung Han261e1582020-10-20 18:54:21 +09001842 return
Justin Yun8effde42017-06-23 19:24:43 +09001843 }
Jiyong Parkd4a3a132021-03-17 20:21:35 +09001844 } else if library.hasStubsVariants() && !ctx.Host() && ctx.directlyInAnyApex() {
Jiyong Parkf1194352019-02-25 11:05:47 +09001845 // Bionic libraries (e.g. libc.so) is installed to the bootstrap subdirectory.
1846 // The original path becomes a symlink to the corresponding file in the
1847 // runtime APEX.
Colin Cross3b19f5d2019-09-17 14:45:31 -07001848 translatedArch := ctx.Target().NativeBridge == android.NativeBridgeEnabled
Colin Cross56a83212020-09-15 18:30:11 -07001849 if InstallToBootstrap(ctx.baseModuleName(), ctx.Config()) && !library.buildStubs() &&
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001850 !translatedArch && !ctx.inRamdisk() && !ctx.inVendorRamdisk() && !ctx.inRecovery() {
Martin Stjernholm279de572019-09-10 23:18:20 +01001851 if ctx.Device() {
Jiyong Parkc3e2c862019-03-16 01:10:08 +09001852 library.installSymlinkToRuntimeApex(ctx, file)
1853 }
Jiyong Park429660f2019-01-16 22:31:11 +09001854 library.baseInstaller.subDir = "bootstrap"
1855 }
Colin Cross127bb8b2020-12-16 16:46:01 -08001856 } else if ctx.directlyInAnyApex() && ctx.IsLlndk() && !isBionic(ctx.baseModuleName()) {
Przemyslaw Szczepaniake6fc5072019-07-12 14:06:23 +01001857 // Skip installing LLNDK (non-bionic) libraries moved to APEX.
Colin Crossa9c8c9f2020-12-16 10:20:23 -08001858 ctx.Module().HideFromMake()
Justin Yun8effde42017-06-23 19:24:43 +09001859 }
Przemyslaw Szczepaniake6fc5072019-07-12 14:06:23 +01001860
Colin Cross4d9c2d12016-07-29 12:48:20 -07001861 library.baseInstaller.install(ctx, file)
1862 }
Dan Albertf563d252017-10-13 00:29:00 -07001863
Dan Albert281f22b2017-12-13 15:03:47 -08001864 if Bool(library.Properties.Static_ndk_lib) && library.static() &&
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001865 !ctx.useVndk() && !ctx.inRamdisk() && !ctx.inVendorRamdisk() && !ctx.inRecovery() && ctx.Device() &&
Jiyong Park7ed9de32018-10-15 22:25:07 +09001866 library.baseLinker.sanitize.isUnsanitizedVariant() &&
Colin Cross95b07f22020-12-16 11:06:50 -08001867 ctx.isForPlatform() && !ctx.isPreventInstall() {
Dan Albertf563d252017-10-13 00:29:00 -07001868 installPath := getNdkSysrootBase(ctx).Join(
Dan Albertea4b7b92018-04-25 16:05:30 -07001869 ctx, "usr/lib", config.NDKTriple(ctx.toolchain()), file.Base())
Dan Albertf563d252017-10-13 00:29:00 -07001870
1871 ctx.ModuleBuild(pctx, android.ModuleBuildParams{
1872 Rule: android.Cp,
1873 Description: "install " + installPath.Base(),
1874 Output: installPath,
1875 Input: file,
1876 })
1877
Colin Cross0875c522017-11-28 17:34:01 -08001878 library.ndkSysrootPath = installPath
Dan Albertf563d252017-10-13 00:29:00 -07001879 }
Colin Cross4d9c2d12016-07-29 12:48:20 -07001880}
1881
Paul Duffin0cb37b92020-03-04 14:52:46 +00001882func (library *libraryDecorator) everInstallable() bool {
1883 // Only shared and static libraries are installed. Header libraries (which are
1884 // neither static or shared) are not installed.
1885 return library.shared() || library.static()
1886}
1887
Chris Parsons3c27ca32020-11-20 12:42:07 -05001888// static returns true if this library is for a "static' variant.
Colin Crossb916a382016-07-29 17:28:03 -07001889func (library *libraryDecorator) static() bool {
Colin Crossa48ab5b2017-02-14 15:28:44 -08001890 return library.MutatedProperties.VariantIsStatic
Colin Cross4d9c2d12016-07-29 12:48:20 -07001891}
1892
Chris Parsons3c27ca32020-11-20 12:42:07 -05001893// shared returns true if this library is for a "shared' variant.
Colin Crossa48ab5b2017-02-14 15:28:44 -08001894func (library *libraryDecorator) shared() bool {
1895 return library.MutatedProperties.VariantIsShared
1896}
1897
Chris Parsons3c27ca32020-11-20 12:42:07 -05001898// header returns true if this library is for a header-only variant.
Colin Crossa48ab5b2017-02-14 15:28:44 -08001899func (library *libraryDecorator) header() bool {
Chris Parsons3c27ca32020-11-20 12:42:07 -05001900 // Neither "static" nor "shared" implies this library is header-only.
Colin Crossa48ab5b2017-02-14 15:28:44 -08001901 return !library.static() && !library.shared()
1902}
1903
Chris Parsons3c27ca32020-11-20 12:42:07 -05001904// setStatic marks the library variant as "static".
Colin Crossa48ab5b2017-02-14 15:28:44 -08001905func (library *libraryDecorator) setStatic() {
1906 library.MutatedProperties.VariantIsStatic = true
1907 library.MutatedProperties.VariantIsShared = false
1908}
1909
Chris Parsons3c27ca32020-11-20 12:42:07 -05001910// setShared marks the library variant as "shared".
Colin Crossa48ab5b2017-02-14 15:28:44 -08001911func (library *libraryDecorator) setShared() {
1912 library.MutatedProperties.VariantIsStatic = false
1913 library.MutatedProperties.VariantIsShared = true
Colin Crossb916a382016-07-29 17:28:03 -07001914}
1915
Chris Parsons3c27ca32020-11-20 12:42:07 -05001916// BuildOnlyStatic disables building this library as a shared library.
Colin Crossab3b7322016-12-09 14:46:15 -08001917func (library *libraryDecorator) BuildOnlyStatic() {
Colin Crossa48ab5b2017-02-14 15:28:44 -08001918 library.MutatedProperties.BuildShared = false
Colin Crossab3b7322016-12-09 14:46:15 -08001919}
1920
Chris Parsons3c27ca32020-11-20 12:42:07 -05001921// BuildOnlyShared disables building this library as a static library.
Colin Crossab3b7322016-12-09 14:46:15 -08001922func (library *libraryDecorator) BuildOnlyShared() {
Colin Crossa48ab5b2017-02-14 15:28:44 -08001923 library.MutatedProperties.BuildStatic = false
Colin Crossab3b7322016-12-09 14:46:15 -08001924}
1925
Chris Parsons3c27ca32020-11-20 12:42:07 -05001926// HeaderOnly disables building this library as a shared or static library;
1927// the library only exists to propagate header file dependencies up the build graph.
Colin Cross5950f382016-12-13 12:50:57 -08001928func (library *libraryDecorator) HeaderOnly() {
Colin Crossa48ab5b2017-02-14 15:28:44 -08001929 library.MutatedProperties.BuildShared = false
1930 library.MutatedProperties.BuildStatic = false
Colin Cross5950f382016-12-13 12:50:57 -08001931}
1932
Colin Cross127bb8b2020-12-16 16:46:01 -08001933// hasLLNDKStubs returns true if this cc_library module has a variant that will build LLNDK stubs.
1934func (library *libraryDecorator) hasLLNDKStubs() bool {
Colin Cross203b4212021-04-26 17:19:41 -07001935 return String(library.Properties.Llndk.Symbol_file) != ""
Colin Cross0fb7fcd2021-03-02 11:00:07 -08001936}
1937
Colin Cross203b4212021-04-26 17:19:41 -07001938// hasLLNDKStubs returns true if this cc_library module has a variant that will build LLNDK stubs.
Colin Cross1f3f1302021-04-26 18:37:44 -07001939func (library *libraryDecorator) hasLLNDKHeaders() bool {
1940 return Bool(library.Properties.Llndk.Llndk_headers)
1941}
1942
Colin Cross5271fea2021-04-27 13:06:04 -07001943// hasVendorPublicLibrary returns true if this cc_library module has a variant that will build
1944// vendor public library stubs.
1945func (library *libraryDecorator) hasVendorPublicLibrary() bool {
1946 return String(library.Properties.Vendor_public_library.Symbol_file) != ""
1947}
1948
Colin Cross0477b422020-10-13 18:43:54 -07001949func (library *libraryDecorator) implementationModuleName(name string) string {
1950 return name
1951}
1952
Jiyong Park7ed9de32018-10-15 22:25:07 +09001953func (library *libraryDecorator) buildStubs() bool {
1954 return library.MutatedProperties.BuildStubs
1955}
1956
Jiyong Parka034b832019-08-27 14:02:19 +09001957func (library *libraryDecorator) symbolFileForAbiCheck(ctx ModuleContext) *string {
1958 if library.Properties.Header_abi_checker.Symbol_file != nil {
1959 return library.Properties.Header_abi_checker.Symbol_file
1960 }
Colin Cross127bb8b2020-12-16 16:46:01 -08001961 if ctx.Module().(*Module).IsLlndk() {
1962 return library.Properties.Llndk.Symbol_file
1963 }
Colin Cross31076b32020-10-23 17:22:06 -07001964 if library.hasStubsVariants() && library.Properties.Stubs.Symbol_file != nil {
Jiyong Parka034b832019-08-27 14:02:19 +09001965 return library.Properties.Stubs.Symbol_file
1966 }
1967 return nil
1968}
1969
Colin Crossc88c2722020-09-28 17:32:47 -07001970func (library *libraryDecorator) hasStubsVariants() bool {
Jiyong Parkd4a3a132021-03-17 20:21:35 +09001971 // Just having stubs.symbol_file is enough to create a stub variant. In that case
1972 // the stub for the future API level is created.
1973 return library.Properties.Stubs.Symbol_file != nil ||
1974 len(library.Properties.Stubs.Versions) > 0
Colin Crossc88c2722020-09-28 17:32:47 -07001975}
1976
Colin Cross3572cf72020-10-01 15:58:11 -07001977func (library *libraryDecorator) stubsVersions(ctx android.BaseMutatorContext) []string {
Jiyong Parkd4a3a132021-03-17 20:21:35 +09001978 if !library.hasStubsVariants() {
1979 return nil
1980 }
1981
Colin Crossc1b36442021-05-06 13:42:48 -07001982 if library.hasLLNDKStubs() && ctx.Module().(*Module).UseVndk() {
1983 // LLNDK libraries only need a single stubs variant.
1984 return []string{android.FutureApiLevel.String()}
1985 }
1986
Jiyong Parkd4a3a132021-03-17 20:21:35 +09001987 // Future API level is implicitly added if there isn't
1988 vers := library.Properties.Stubs.Versions
1989 if inList(android.FutureApiLevel.String(), vers) {
1990 return vers
1991 }
1992 // In some cases, people use the raw value "10000" in the versions property.
1993 // We shouldn't add the future API level in that case, otherwise there will
1994 // be two identical versions.
1995 if inList(strconv.Itoa(android.FutureApiLevel.FinalOrFutureInt()), vers) {
1996 return vers
1997 }
1998 return append(vers, android.FutureApiLevel.String())
Colin Crossc88c2722020-09-28 17:32:47 -07001999}
2000
2001func (library *libraryDecorator) setStubsVersion(version string) {
2002 library.MutatedProperties.StubsVersion = version
2003}
2004
Jiyong Park7ed9de32018-10-15 22:25:07 +09002005func (library *libraryDecorator) stubsVersion() string {
2006 return library.MutatedProperties.StubsVersion
2007}
2008
Jiyong Parkd4a3a132021-03-17 20:21:35 +09002009func (library *libraryDecorator) setBuildStubs(isLatest bool) {
Colin Crossc88c2722020-09-28 17:32:47 -07002010 library.MutatedProperties.BuildStubs = true
Jiyong Parkd4a3a132021-03-17 20:21:35 +09002011 library.MutatedProperties.IsLatestVersion = isLatest
Colin Crossc88c2722020-09-28 17:32:47 -07002012}
2013
2014func (library *libraryDecorator) setAllStubsVersions(versions []string) {
2015 library.MutatedProperties.AllStubsVersions = versions
2016}
2017
2018func (library *libraryDecorator) allStubsVersions() []string {
2019 return library.MutatedProperties.AllStubsVersions
2020}
2021
Jooyung Hanad4c1872020-02-27 17:56:44 +09002022func (library *libraryDecorator) isLatestStubVersion() bool {
Jiyong Parkd4a3a132021-03-17 20:21:35 +09002023 return library.MutatedProperties.IsLatestVersion
Jooyung Hanad4c1872020-02-27 17:56:44 +09002024}
2025
Jiyong Parka90ca002019-10-07 15:47:24 +09002026func (library *libraryDecorator) availableFor(what string) bool {
2027 var list []string
2028 if library.static() {
2029 list = library.StaticProperties.Static.Apex_available
2030 } else if library.shared() {
2031 list = library.SharedProperties.Shared.Apex_available
2032 }
2033 if len(list) == 0 {
2034 return false
2035 }
2036 return android.CheckAvailableForApex(what, list)
2037}
2038
Colin Cross1bc94122021-10-28 13:25:54 -07002039func (library *libraryDecorator) installable() *bool {
2040 if library.static() {
2041 return library.StaticProperties.Static.Installable
2042 } else if library.shared() {
2043 return library.SharedProperties.Shared.Installable
2044 }
2045 return nil
2046}
2047
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01002048func (library *libraryDecorator) makeUninstallable(mod *Module) {
Martin Stjernholmbf37d162020-03-31 16:05:34 +01002049 if library.static() && library.buildStatic() && !library.buildStubs() {
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01002050 // If we're asked to make a static library uninstallable we don't do
2051 // anything since AndroidMkEntries always sets LOCAL_UNINSTALLABLE_MODULE
2052 // for these entries. This is done to still get the make targets for NOTICE
2053 // files from notice_files.mk, which other libraries might depend on.
Martin Stjernholmbf37d162020-03-31 16:05:34 +01002054 return
2055 }
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01002056 mod.ModuleBase.MakeUninstallable()
Martin Stjernholmbf37d162020-03-31 16:05:34 +01002057}
2058
Colin Crossceaa5322021-09-28 16:37:50 -07002059func (library *libraryDecorator) getAPIListCoverageXMLPath() android.ModuleOutPath {
2060 return library.apiListCoverageXmlPath
2061}
2062
Colin Cross571cccf2019-02-04 11:22:08 -08002063var versioningMacroNamesListKey = android.NewOnceKey("versioningMacroNamesList")
2064
Chris Parsons3c27ca32020-11-20 12:42:07 -05002065// versioningMacroNamesList returns a singleton map, where keys are "version macro names",
2066// and values are the module name responsible for registering the version macro name.
2067//
2068// Version macros are used when building against stubs, to provide version information about
2069// the stub. Only stub libraries should have an entry in this list.
2070//
2071// For example, when building against libFoo#ver, __LIBFOO_API__ macro is set to ver so
2072// that headers from libFoo can be conditionally compiled (this may hide APIs
2073// that are not available for the version).
2074//
2075// This map is used to ensure that there aren't conflicts between these version macro names.
Jiyong Parkda732bd2018-11-02 18:23:15 +09002076func versioningMacroNamesList(config android.Config) *map[string]string {
Colin Cross571cccf2019-02-04 11:22:08 -08002077 return config.Once(versioningMacroNamesListKey, func() interface{} {
Jiyong Parkda732bd2018-11-02 18:23:15 +09002078 m := make(map[string]string)
2079 return &m
2080 }).(*map[string]string)
2081}
2082
2083// alphanumeric and _ characters are preserved.
2084// other characters are all converted to _
2085var charsNotForMacro = regexp.MustCompile("[^a-zA-Z0-9_]+")
2086
Chris Parsons3c27ca32020-11-20 12:42:07 -05002087// versioningMacroName returns the canonical version macro name for the given module.
Jiyong Parkda732bd2018-11-02 18:23:15 +09002088func versioningMacroName(moduleName string) string {
2089 macroName := charsNotForMacro.ReplaceAllString(moduleName, "_")
Jooyung Hanb04a4992020-03-13 18:57:35 +09002090 macroName = strings.ToUpper(macroName)
Jiyong Parkda732bd2018-11-02 18:23:15 +09002091 return "__" + macroName + "_API__"
2092}
2093
Chris Parsons3c27ca32020-11-20 12:42:07 -05002094// NewLibrary builds and returns a new Module corresponding to a C++ library.
2095// Individual module implementations which comprise a C++ library (or something like
2096// a C++ library) should call this function, set some fields on the result, and
2097// then call the Init function.
Colin Crossab3b7322016-12-09 14:46:15 -08002098func NewLibrary(hod android.HostOrDeviceSupported) (*Module, *libraryDecorator) {
Colin Cross4d9c2d12016-07-29 12:48:20 -07002099 module := newModule(hod, android.MultilibBoth)
2100
Colin Crossb916a382016-07-29 17:28:03 -07002101 library := &libraryDecorator{
Colin Crossa48ab5b2017-02-14 15:28:44 -08002102 MutatedProperties: LibraryMutatedProperties{
Colin Crossab3b7322016-12-09 14:46:15 -08002103 BuildShared: true,
2104 BuildStatic: true,
Colin Cross4d9c2d12016-07-29 12:48:20 -07002105 },
Colin Crossb916a382016-07-29 17:28:03 -07002106 baseCompiler: NewBaseCompiler(),
Dan Albert61f32122018-07-26 14:00:24 -07002107 baseLinker: NewBaseLinker(module.sanitize),
Colin Crossb916a382016-07-29 17:28:03 -07002108 baseInstaller: NewBaseInstaller("lib", "lib64", InstallInSystem),
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08002109 sabi: module.sabi,
Colin Cross4d9c2d12016-07-29 12:48:20 -07002110 }
2111
Colin Crossb916a382016-07-29 17:28:03 -07002112 module.compiler = library
2113 module.linker = library
2114 module.installer = library
Colin Cross31076b32020-10-23 17:22:06 -07002115 module.library = library
Colin Crossb916a382016-07-29 17:28:03 -07002116
2117 return module, library
2118}
2119
Colin Cross10d22312017-05-03 11:01:58 -07002120// connects a shared library to a static library in order to reuse its .o files to avoid
2121// compiling source files twice.
2122func reuseStaticLibrary(mctx android.BottomUpMutatorContext, static, shared *Module) {
2123 if staticCompiler, ok := static.compiler.(*libraryDecorator); ok {
2124 sharedCompiler := shared.compiler.(*libraryDecorator)
Dan Willemsen3a26eef2018-12-03 15:25:46 -08002125
2126 // Check libraries in addition to cflags, since libraries may be exporting different
2127 // include directories.
Colin Crosse1bb5d02019-09-24 14:55:04 -07002128 if len(staticCompiler.StaticProperties.Static.Cflags) == 0 &&
2129 len(sharedCompiler.SharedProperties.Shared.Cflags) == 0 &&
2130 len(staticCompiler.StaticProperties.Static.Whole_static_libs) == 0 &&
2131 len(sharedCompiler.SharedProperties.Shared.Whole_static_libs) == 0 &&
2132 len(staticCompiler.StaticProperties.Static.Static_libs) == 0 &&
2133 len(sharedCompiler.SharedProperties.Shared.Static_libs) == 0 &&
2134 len(staticCompiler.StaticProperties.Static.Shared_libs) == 0 &&
2135 len(sharedCompiler.SharedProperties.Shared.Shared_libs) == 0 &&
Martin Stjernholm10566a02020-03-24 01:19:52 +00002136 // Compare System_shared_libs properties with nil because empty lists are
2137 // semantically significant for them.
Colin Crosse1bb5d02019-09-24 14:55:04 -07002138 staticCompiler.StaticProperties.Static.System_shared_libs == nil &&
2139 sharedCompiler.SharedProperties.Shared.System_shared_libs == nil {
Colin Cross10d22312017-05-03 11:01:58 -07002140
2141 mctx.AddInterVariantDependency(reuseObjTag, shared, static)
2142 sharedCompiler.baseCompiler.Properties.OriginalSrcs =
2143 sharedCompiler.baseCompiler.Properties.Srcs
2144 sharedCompiler.baseCompiler.Properties.Srcs = nil
2145 sharedCompiler.baseCompiler.Properties.Generated_sources = nil
2146 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07002147
2148 // This dep is just to reference static variant from shared variant
2149 mctx.AddInterVariantDependency(staticVariantTag, shared, static)
Colin Cross10d22312017-05-03 11:01:58 -07002150 }
2151}
2152
Chris Parsons3c27ca32020-11-20 12:42:07 -05002153// LinkageMutator adds "static" or "shared" variants for modules depending
2154// on whether the module can be built as a static library or a shared library.
Colin Crosse40b4ea2018-10-02 22:25:58 -07002155func LinkageMutator(mctx android.BottomUpMutatorContext) {
Jaewoong Jung18aefc12020-12-21 09:11:10 -08002156 ccPrebuilt := false
Colin Crossb916a382016-07-29 17:28:03 -07002157 if m, ok := mctx.Module().(*Module); ok && m.linker != nil {
Jaewoong Jung18aefc12020-12-21 09:11:10 -08002158 _, ccPrebuilt = m.linker.(prebuiltLibraryInterface)
Ivan Lozano52767be2019-10-18 14:49:46 -07002159 }
Jaewoong Jung18aefc12020-12-21 09:11:10 -08002160 if ccPrebuilt {
Ivan Lozano52767be2019-10-18 14:49:46 -07002161 library := mctx.Module().(*Module).linker.(prebuiltLibraryInterface)
Colin Cross33b2fb72019-05-14 14:07:01 -07002162
Paul Duffinf5ea9e12020-02-21 10:57:00 +00002163 // Differentiate between header only and building an actual static/shared library
Colin Cross127bb8b2020-12-16 16:46:01 -08002164 buildStatic := library.buildStatic()
2165 buildShared := library.buildShared()
2166 if buildStatic || buildShared {
Paul Duffinf5ea9e12020-02-21 10:57:00 +00002167 // Always create both the static and shared variants for prebuilt libraries, and then disable the one
2168 // that is not being used. This allows them to share the name of a cc_library module, which requires that
2169 // all the variants of the cc_library also exist on the prebuilt.
2170 modules := mctx.CreateLocalVariations("static", "shared")
2171 static := modules[0].(*Module)
2172 shared := modules[1].(*Module)
Colin Cross33b2fb72019-05-14 14:07:01 -07002173
Paul Duffinf5ea9e12020-02-21 10:57:00 +00002174 static.linker.(prebuiltLibraryInterface).setStatic()
2175 shared.linker.(prebuiltLibraryInterface).setShared()
Colin Cross33b2fb72019-05-14 14:07:01 -07002176
Colin Cross127bb8b2020-12-16 16:46:01 -08002177 if buildShared {
Colin Cross81ca6cd2020-08-06 17:46:48 -07002178 mctx.AliasVariation("shared")
Colin Cross127bb8b2020-12-16 16:46:01 -08002179 } else if buildStatic {
Colin Cross81ca6cd2020-08-06 17:46:48 -07002180 mctx.AliasVariation("static")
2181 }
2182
Colin Cross127bb8b2020-12-16 16:46:01 -08002183 if !buildStatic {
Paul Duffinf5ea9e12020-02-21 10:57:00 +00002184 static.linker.(prebuiltLibraryInterface).disablePrebuilt()
2185 }
Colin Cross127bb8b2020-12-16 16:46:01 -08002186 if !buildShared {
Paul Duffinf5ea9e12020-02-21 10:57:00 +00002187 shared.linker.(prebuiltLibraryInterface).disablePrebuilt()
2188 }
2189 } else {
2190 // Header only
Colin Crossb916a382016-07-29 17:28:03 -07002191 }
Paul Duffinf5ea9e12020-02-21 10:57:00 +00002192
Ivan Lozano52767be2019-10-18 14:49:46 -07002193 } else if library, ok := mctx.Module().(LinkableInterface); ok && library.CcLibraryInterface() {
Ivan Lozano52767be2019-10-18 14:49:46 -07002194
Ivan Lozano2b262972019-11-21 12:30:50 -08002195 // Non-cc.Modules may need an empty variant for their mutators.
2196 variations := []string{}
2197 if library.NonCcVariants() {
2198 variations = append(variations, "")
2199 }
2200
Colin Cross127bb8b2020-12-16 16:46:01 -08002201 isLLNDK := false
2202 if m, ok := mctx.Module().(*Module); ok {
Colin Cross203b4212021-04-26 17:19:41 -07002203 isLLNDK = m.IsLlndk()
Colin Cross127bb8b2020-12-16 16:46:01 -08002204 }
2205 buildStatic := library.BuildStaticVariant() && !isLLNDK
2206 buildShared := library.BuildSharedVariant()
2207 if buildStatic && buildShared {
Ivan Lozano2b262972019-11-21 12:30:50 -08002208 variations := append([]string{"static", "shared"}, variations...)
Ivan Lozano52767be2019-10-18 14:49:46 -07002209
2210 modules := mctx.CreateLocalVariations(variations...)
2211 static := modules[0].(LinkableInterface)
2212 shared := modules[1].(LinkableInterface)
2213
2214 static.SetStatic()
2215 shared.SetShared()
2216
2217 if _, ok := library.(*Module); ok {
2218 reuseStaticLibrary(mctx, static.(*Module), shared.(*Module))
2219 }
Colin Cross81ca6cd2020-08-06 17:46:48 -07002220 mctx.AliasVariation("shared")
Colin Cross127bb8b2020-12-16 16:46:01 -08002221 } else if buildStatic {
Ivan Lozano2b262972019-11-21 12:30:50 -08002222 variations := append([]string{"static"}, variations...)
2223
2224 modules := mctx.CreateLocalVariations(variations...)
Ivan Lozano52767be2019-10-18 14:49:46 -07002225 modules[0].(LinkableInterface).SetStatic()
Colin Cross81ca6cd2020-08-06 17:46:48 -07002226 mctx.AliasVariation("static")
Colin Cross127bb8b2020-12-16 16:46:01 -08002227 } else if buildShared {
Ivan Lozano2b262972019-11-21 12:30:50 -08002228 variations := append([]string{"shared"}, variations...)
Ivan Lozano52767be2019-10-18 14:49:46 -07002229
Ivan Lozano2b262972019-11-21 12:30:50 -08002230 modules := mctx.CreateLocalVariations(variations...)
2231 modules[0].(LinkableInterface).SetShared()
Colin Cross81ca6cd2020-08-06 17:46:48 -07002232 mctx.AliasVariation("shared")
Ivan Lozano2b262972019-11-21 12:30:50 -08002233 } else if len(variations) > 0 {
2234 mctx.CreateLocalVariations(variations...)
Colin Cross81ca6cd2020-08-06 17:46:48 -07002235 mctx.AliasVariation(variations[0])
Ivan Lozano2b262972019-11-21 12:30:50 -08002236 }
Colin Crossb916a382016-07-29 17:28:03 -07002237 }
Colin Cross4d9c2d12016-07-29 12:48:20 -07002238}
Jiyong Park7ed9de32018-10-15 22:25:07 +09002239
Chris Parsons3c27ca32020-11-20 12:42:07 -05002240// normalizeVersions modifies `versions` in place, so that each raw version
2241// string becomes its normalized canonical form.
2242// Validates that the versions in `versions` are specified in least to greatest order.
Jooyung Hanaed150d2020-04-02 01:41:41 +09002243func normalizeVersions(ctx android.BaseModuleContext, versions []string) {
Dan Albertc8060532020-07-22 22:32:17 -07002244 var previous android.ApiLevel
Jooyung Hanad4c1872020-02-27 17:56:44 +09002245 for i, v := range versions {
Dan Albertc8060532020-07-22 22:32:17 -07002246 ver, err := android.ApiLevelFromUser(ctx, v)
Jooyung Hanad4c1872020-02-27 17:56:44 +09002247 if err != nil {
Jooyung Hanaed150d2020-04-02 01:41:41 +09002248 ctx.PropertyErrorf("versions", "%s", err.Error())
2249 return
Jooyung Hanad4c1872020-02-27 17:56:44 +09002250 }
Dan Albertc8060532020-07-22 22:32:17 -07002251 if i > 0 && ver.LessThanOrEqualTo(previous) {
2252 ctx.PropertyErrorf("versions", "not sorted: %v", versions)
2253 }
2254 versions[i] = ver.String()
2255 previous = ver
Jooyung Hanaed150d2020-04-02 01:41:41 +09002256 }
Jooyung Hanad4c1872020-02-27 17:56:44 +09002257}
2258
Jooyung Han61b66e92020-03-21 14:21:46 +00002259func createVersionVariations(mctx android.BottomUpMutatorContext, versions []string) {
Colin Cross127bb8b2020-12-16 16:46:01 -08002260 // "" is for the non-stubs (implementation) variant for system modules, or the LLNDK variant
2261 // for LLNDK modules.
Colin Cross0de8a1e2020-09-18 14:15:30 -07002262 variants := append(android.CopyOf(versions), "")
Jooyung Han61b66e92020-03-21 14:21:46 +00002263
Colin Cross127bb8b2020-12-16 16:46:01 -08002264 m := mctx.Module().(*Module)
2265 isLLNDK := m.IsLlndk()
Colin Cross5271fea2021-04-27 13:06:04 -07002266 isVendorPublicLibrary := m.IsVendorPublicLibrary()
Colin Cross127bb8b2020-12-16 16:46:01 -08002267
Colin Crossd1f898e2020-08-18 18:35:15 -07002268 modules := mctx.CreateLocalVariations(variants...)
Jooyung Han61b66e92020-03-21 14:21:46 +00002269 for i, m := range modules {
Colin Cross127bb8b2020-12-16 16:46:01 -08002270
Colin Cross5271fea2021-04-27 13:06:04 -07002271 if variants[i] != "" || isLLNDK || isVendorPublicLibrary {
Colin Cross127bb8b2020-12-16 16:46:01 -08002272 // A stubs or LLNDK stubs variant.
Colin Cross31076b32020-10-23 17:22:06 -07002273 c := m.(*Module)
Colin Cross31076b32020-10-23 17:22:06 -07002274 c.sanitize = nil
2275 c.stl = nil
2276 c.Properties.PreventInstall = true
2277 lib := moduleLibraryInterface(m)
Jiyong Parkd4a3a132021-03-17 20:21:35 +09002278 isLatest := i == (len(versions) - 1)
2279 lib.setBuildStubs(isLatest)
Colin Cross127bb8b2020-12-16 16:46:01 -08002280
2281 if variants[i] != "" {
2282 // A non-LLNDK stubs module is hidden from make and has a dependency from the
2283 // implementation module to the stubs module.
2284 c.Properties.HideFromMake = true
2285 lib.setStubsVersion(variants[i])
2286 mctx.AddInterVariantDependency(stubImplDepTag, modules[len(modules)-1], modules[i])
2287 }
Jooyung Han61b66e92020-03-21 14:21:46 +00002288 }
2289 }
Colin Cross094faa52020-08-06 17:38:25 -07002290 mctx.AliasVariation("")
Colin Crossd1f898e2020-08-18 18:35:15 -07002291 latestVersion := ""
2292 if len(versions) > 0 {
2293 latestVersion = versions[len(versions)-1]
2294 }
2295 mctx.CreateAliasVariation("latest", latestVersion)
Jooyung Han61b66e92020-03-21 14:21:46 +00002296}
2297
Colin Crossbbc941b2020-09-30 12:27:01 -07002298func createPerApiVersionVariations(mctx android.BottomUpMutatorContext, minSdkVersion string) {
2299 from, err := nativeApiLevelFromUser(mctx, minSdkVersion)
2300 if err != nil {
2301 mctx.PropertyErrorf("min_sdk_version", err.Error())
2302 return
2303 }
2304
2305 versionStrs := ndkLibraryVersions(mctx, from)
2306 modules := mctx.CreateLocalVariations(versionStrs...)
2307
2308 for i, module := range modules {
2309 module.(*Module).Properties.Sdk_version = StringPtr(versionStrs[i])
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09002310 module.(*Module).Properties.Min_sdk_version = StringPtr(versionStrs[i])
Colin Crossbbc941b2020-09-30 12:27:01 -07002311 }
2312}
2313
Colin Cross3146c5c2020-09-30 15:34:40 -07002314func CanBeOrLinkAgainstVersionVariants(module interface {
Jooyung Han624d35c2020-04-10 12:57:24 +09002315 Host() bool
2316 InRamdisk() bool
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002317 InVendorRamdisk() bool
Jooyung Han624d35c2020-04-10 12:57:24 +09002318}) bool {
Jose Galmes6f843bc2020-12-11 13:36:29 -08002319 return !module.Host() && !module.InRamdisk() && !module.InVendorRamdisk()
Jooyung Han624d35c2020-04-10 12:57:24 +09002320}
2321
Colin Cross3146c5c2020-09-30 15:34:40 -07002322func CanBeVersionVariant(module interface {
2323 Host() bool
2324 InRamdisk() bool
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002325 InVendorRamdisk() bool
Colin Cross3146c5c2020-09-30 15:34:40 -07002326 InRecovery() bool
2327 CcLibraryInterface() bool
2328 Shared() bool
Colin Cross3146c5c2020-09-30 15:34:40 -07002329}) bool {
2330 return CanBeOrLinkAgainstVersionVariants(module) &&
Colin Crossa717db72020-10-23 14:53:06 -07002331 module.CcLibraryInterface() && module.Shared()
Colin Cross3146c5c2020-09-30 15:34:40 -07002332}
2333
Colin Cross127bb8b2020-12-16 16:46:01 -08002334func moduleLibraryInterface(module blueprint.Module) libraryInterface {
Colin Cross31076b32020-10-23 17:22:06 -07002335 if m, ok := module.(*Module); ok {
2336 return m.library
2337 }
2338 return nil
2339}
2340
Colin Crossc1b36442021-05-06 13:42:48 -07002341// versionSelector normalizes the versions in the Stubs.Versions property into MutatedProperties.AllStubsVersions.
Colin Crossd1f898e2020-08-18 18:35:15 -07002342func versionSelectorMutator(mctx android.BottomUpMutatorContext) {
Colin Cross31076b32020-10-23 17:22:06 -07002343 if library := moduleLibraryInterface(mctx.Module()); library != nil && CanBeVersionVariant(mctx.Module().(*Module)) {
2344 if library.buildShared() {
2345 versions := library.stubsVersions(mctx)
Colin Cross3572cf72020-10-01 15:58:11 -07002346 if len(versions) > 0 {
2347 normalizeVersions(mctx, versions)
2348 if mctx.Failed() {
Colin Crossbbc941b2020-09-30 12:27:01 -07002349 return
2350 }
Colin Cross3572cf72020-10-01 15:58:11 -07002351 // Set the versions on the pre-mutated module so they can be read by any llndk modules that
2352 // depend on the implementation library and haven't been mutated yet.
Colin Cross31076b32020-10-23 17:22:06 -07002353 library.setAllStubsVersions(versions)
Colin Cross127bb8b2020-12-16 16:46:01 -08002354 }
Jooyung Han61b66e92020-03-21 14:21:46 +00002355 }
Colin Crossd1f898e2020-08-18 18:35:15 -07002356 }
2357}
Jooyung Han61b66e92020-03-21 14:21:46 +00002358
Colin Crossd1f898e2020-08-18 18:35:15 -07002359// versionMutator splits a module into the mandatory non-stubs variant
2360// (which is unnamed) and zero or more stubs variants.
2361func versionMutator(mctx android.BottomUpMutatorContext) {
Colin Cross31076b32020-10-23 17:22:06 -07002362 if library := moduleLibraryInterface(mctx.Module()); library != nil && CanBeVersionVariant(mctx.Module().(*Module)) {
2363 createVersionVariations(mctx, library.allStubsVersions())
Colin Crossbbc941b2020-09-30 12:27:01 -07002364 return
2365 }
2366
2367 if m, ok := mctx.Module().(*Module); ok {
2368 if m.SplitPerApiLevel() && m.IsSdkVariant() {
2369 if mctx.Os() != android.Android {
2370 return
2371 }
2372 createPerApiVersionVariations(mctx, m.MinSdkVersion())
2373 }
Jiyong Park7ed9de32018-10-15 22:25:07 +09002374 }
Jiyong Park7ed9de32018-10-15 22:25:07 +09002375}
Colin Crossd7227f92019-09-05 14:26:33 -07002376
2377// maybeInjectBoringSSLHash adds a rule to run bssl_inject_hash on the output file if the module has the
2378// inject_bssl_hash or if any static library dependencies have inject_bssl_hash set. It returns the output path
2379// that the linked output file should be written to.
2380// TODO(b/137267623): Remove this in favor of a cc_genrule when they support operating on shared libraries.
2381func maybeInjectBoringSSLHash(ctx android.ModuleContext, outputFile android.ModuleOutPath,
2382 inject *bool, fileName string) android.ModuleOutPath {
2383 // TODO(b/137267623): Remove this in favor of a cc_genrule when they support operating on shared libraries.
2384 injectBoringSSLHash := Bool(inject)
2385 ctx.VisitDirectDeps(func(dep android.Module) {
Colin Cross6e511a92020-07-27 21:26:48 -07002386 if tag, ok := ctx.OtherModuleDependencyTag(dep).(libraryDependencyTag); ok && tag.static() {
Colin Crossd7227f92019-09-05 14:26:33 -07002387 if cc, ok := dep.(*Module); ok {
2388 if library, ok := cc.linker.(*libraryDecorator); ok {
2389 if Bool(library.Properties.Inject_bssl_hash) {
2390 injectBoringSSLHash = true
2391 }
2392 }
2393 }
2394 }
2395 })
2396 if injectBoringSSLHash {
2397 hashedOutputfile := outputFile
2398 outputFile = android.PathForModuleOut(ctx, "unhashed", fileName)
2399
Colin Crossf1a035e2020-11-16 17:32:30 -08002400 rule := android.NewRuleBuilder(pctx, ctx)
Colin Crossd7227f92019-09-05 14:26:33 -07002401 rule.Command().
Colin Crossf1a035e2020-11-16 17:32:30 -08002402 BuiltTool("bssl_inject_hash").
Pete Bentley5c4be822019-10-01 17:03:17 +01002403 Flag("-sha256").
Colin Crossd7227f92019-09-05 14:26:33 -07002404 FlagWithInput("-in-object ", outputFile).
2405 FlagWithOutput("-o ", hashedOutputfile)
Colin Crossf1a035e2020-11-16 17:32:30 -08002406 rule.Build("injectCryptoHash", "inject crypto hash")
Colin Crossd7227f92019-09-05 14:26:33 -07002407 }
2408
2409 return outputFile
2410}
Rupert Shuttleworth095081c2021-03-25 09:06:03 +00002411
Liz Kammerbe46fcc2021-11-01 15:32:43 -04002412func sharedOrStaticLibraryBp2Build(ctx android.TopDownMutatorContext, module *Module, isStatic bool) {
Liz Kammere6583482021-10-19 13:56:10 -04002413 baseAttributes := bp2BuildParseBaseProps(ctx, module)
2414 compilerAttrs := baseAttributes.compilerAttributes
2415 linkerAttrs := baseAttributes.linkerAttributes
2416
Liz Kammer1263d9b2021-12-10 14:28:20 -05002417 exportedIncludes := bp2BuildParseExportedIncludes(ctx, module, compilerAttrs.includes)
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002418
2419 // Append shared/static{} stanza properties. These won't be specified on
2420 // cc_library_* itself, but may be specified in cc_defaults that this module
2421 // depends on.
2422 libSharedOrStaticAttrs := bp2BuildParseLibProps(ctx, module, isStatic)
2423
2424 compilerAttrs.srcs.Append(libSharedOrStaticAttrs.Srcs)
2425 compilerAttrs.cSrcs.Append(libSharedOrStaticAttrs.Srcs_c)
2426 compilerAttrs.asSrcs.Append(libSharedOrStaticAttrs.Srcs_as)
2427 compilerAttrs.copts.Append(libSharedOrStaticAttrs.Copts)
Liz Kammer7a210ac2021-09-22 15:52:58 -04002428
2429 linkerAttrs.deps.Append(libSharedOrStaticAttrs.Deps)
2430 linkerAttrs.implementationDeps.Append(libSharedOrStaticAttrs.Implementation_deps)
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002431 linkerAttrs.dynamicDeps.Append(libSharedOrStaticAttrs.Dynamic_deps)
Liz Kammer7a210ac2021-09-22 15:52:58 -04002432 linkerAttrs.implementationDynamicDeps.Append(libSharedOrStaticAttrs.Implementation_dynamic_deps)
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002433 linkerAttrs.systemDynamicDeps.Append(libSharedOrStaticAttrs.System_dynamic_deps)
2434
2435 asFlags := compilerAttrs.asFlags
2436 if compilerAttrs.asSrcs.IsEmpty() {
2437 // Skip asflags for BUILD file simplicity if there are no assembly sources.
2438 asFlags = bazel.MakeStringListAttribute(nil)
2439 }
2440
Liz Kammer7a210ac2021-09-22 15:52:58 -04002441 commonAttrs := staticOrSharedAttributes{
2442 Srcs: compilerAttrs.srcs,
2443 Srcs_c: compilerAttrs.cSrcs,
2444 Srcs_as: compilerAttrs.asSrcs,
2445 Copts: compilerAttrs.copts,
Liz Kammere6583482021-10-19 13:56:10 -04002446 Hdrs: compilerAttrs.hdrs,
Liz Kammer7a210ac2021-09-22 15:52:58 -04002447
Liz Kammer12615db2021-09-28 09:19:17 -04002448 Deps: linkerAttrs.deps,
2449 Implementation_deps: linkerAttrs.implementationDeps,
2450 Dynamic_deps: linkerAttrs.dynamicDeps,
2451 Implementation_dynamic_deps: linkerAttrs.implementationDynamicDeps,
2452 Whole_archive_deps: linkerAttrs.wholeArchiveDeps,
2453 Implementation_whole_archive_deps: linkerAttrs.implementationWholeArchiveDeps,
2454 System_dynamic_deps: linkerAttrs.systemDynamicDeps,
Liz Kammer7a210ac2021-09-22 15:52:58 -04002455 }
2456
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002457 var attrs interface{}
2458 if isStatic {
Liz Kammer12615db2021-09-28 09:19:17 -04002459 commonAttrs.Deps.Add(baseAttributes.protoDependency)
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002460 attrs = &bazelCcLibraryStaticAttributes{
Liz Kammer7a210ac2021-09-22 15:52:58 -04002461 staticOrSharedAttributes: commonAttrs,
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002462
Rupert Shuttleworth484aa252021-12-10 07:22:53 -05002463 Use_libcrt: linkerAttrs.useLibcrt,
2464 Use_version_lib: linkerAttrs.useVersionLib,
2465
Liz Kammer1263d9b2021-12-10 14:28:20 -05002466 Rtti: compilerAttrs.rtti,
2467 Stl: compilerAttrs.stl,
2468 Cpp_std: compilerAttrs.cppStd,
2469 C_std: compilerAttrs.cStd,
2470
2471 Export_includes: exportedIncludes.Includes,
2472 Export_absolute_includes: exportedIncludes.AbsoluteIncludes,
2473 Export_system_includes: exportedIncludes.SystemIncludes,
2474 Local_includes: compilerAttrs.localIncludes,
2475 Absolute_includes: compilerAttrs.absoluteIncludes,
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002476
2477 Cppflags: compilerAttrs.cppFlags,
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002478 Conlyflags: compilerAttrs.conlyFlags,
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002479 Asflags: asFlags,
Liz Kammer0eae52e2021-10-06 10:32:26 -04002480
2481 Features: linkerAttrs.features,
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002482 }
2483 } else {
Liz Kammer12615db2021-09-28 09:19:17 -04002484 commonAttrs.Dynamic_deps.Add(baseAttributes.protoDependency)
2485
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002486 attrs = &bazelCcLibrarySharedAttributes{
Liz Kammer7a210ac2021-09-22 15:52:58 -04002487 staticOrSharedAttributes: commonAttrs,
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002488
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002489 Cppflags: compilerAttrs.cppFlags,
2490 Conlyflags: compilerAttrs.conlyFlags,
2491 Asflags: asFlags,
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002492
Rupert Shuttleworth484aa252021-12-10 07:22:53 -05002493 Linkopts: linkerAttrs.linkopts,
2494 Link_crt: linkerAttrs.linkCrt,
2495 Use_libcrt: linkerAttrs.useLibcrt,
2496 Use_version_lib: linkerAttrs.useVersionLib,
2497
2498 Rtti: compilerAttrs.rtti,
2499 Stl: compilerAttrs.stl,
2500 Cpp_std: compilerAttrs.cppStd,
2501 C_std: compilerAttrs.cStd,
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002502
Liz Kammerd2871182021-10-04 13:54:37 -04002503 Export_includes: exportedIncludes.Includes,
Liz Kammer1263d9b2021-12-10 14:28:20 -05002504 Export_absolute_includes: exportedIncludes.AbsoluteIncludes,
Liz Kammerd2871182021-10-04 13:54:37 -04002505 Export_system_includes: exportedIncludes.SystemIncludes,
2506 Local_includes: compilerAttrs.localIncludes,
2507 Absolute_includes: compilerAttrs.absoluteIncludes,
2508 Additional_linker_inputs: linkerAttrs.additionalLinkerInputs,
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002509
2510 Strip: stripAttributes{
2511 Keep_symbols: linkerAttrs.stripKeepSymbols,
2512 Keep_symbols_and_debug_frame: linkerAttrs.stripKeepSymbolsAndDebugFrame,
2513 Keep_symbols_list: linkerAttrs.stripKeepSymbolsList,
2514 All: linkerAttrs.stripAll,
2515 None: linkerAttrs.stripNone,
2516 },
Liz Kammer0eae52e2021-10-06 10:32:26 -04002517
2518 Features: linkerAttrs.features,
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002519 }
2520 }
2521
Liz Kammerbe46fcc2021-11-01 15:32:43 -04002522 var modType string
2523 if isStatic {
2524 modType = "cc_library_static"
2525 } else {
2526 modType = "cc_library_shared"
2527 }
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002528 props := bazel.BazelTargetModuleProperties{
2529 Rule_class: modType,
2530 Bzl_load_location: fmt.Sprintf("//build/bazel/rules:%s.bzl", modType),
2531 }
2532
Alex Márquez Pérez Muñíz Díaz Púras Thaureaux447f6c92021-08-31 20:30:36 +00002533 ctx.CreateBazelTargetModule(props, android.CommonAttributes{Name: module.Name()}, attrs)
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002534}
2535
2536// TODO(b/199902614): Can this be factored to share with the other Attributes?
Rupert Shuttleworth095081c2021-03-25 09:06:03 +00002537type bazelCcLibraryStaticAttributes struct {
Liz Kammer7a210ac2021-09-22 15:52:58 -04002538 staticOrSharedAttributes
2539
Rupert Shuttleworth484aa252021-12-10 07:22:53 -05002540 Use_libcrt bazel.BoolAttribute
2541 Use_version_lib bazel.BoolAttribute
2542
2543 Rtti bazel.BoolAttribute
2544 Stl *string
2545 Cpp_std *string
2546 C_std *string
Liz Kammer7a210ac2021-09-22 15:52:58 -04002547
Liz Kammer1263d9b2021-12-10 14:28:20 -05002548 Export_includes bazel.StringListAttribute
2549 Export_absolute_includes bazel.StringListAttribute
2550 Export_system_includes bazel.StringListAttribute
2551 Local_includes bazel.StringListAttribute
2552 Absolute_includes bazel.StringListAttribute
2553 Hdrs bazel.LabelListAttribute
Chris Parsons990c4f42021-05-25 12:10:58 -04002554
2555 Cppflags bazel.StringListAttribute
Chris Parsons990c4f42021-05-25 12:10:58 -04002556 Conlyflags bazel.StringListAttribute
Chris Parsons990c4f42021-05-25 12:10:58 -04002557 Asflags bazel.StringListAttribute
Liz Kammer0eae52e2021-10-06 10:32:26 -04002558
2559 Features bazel.StringListAttribute
Jingwen Chen179856a2021-05-03 09:15:48 +00002560}
2561
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002562// TODO(b/199902614): Can this be factored to share with the other Attributes?
2563type bazelCcLibrarySharedAttributes struct {
Liz Kammer7a210ac2021-09-22 15:52:58 -04002564 staticOrSharedAttributes
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002565
Rupert Shuttleworth484aa252021-12-10 07:22:53 -05002566 Linkopts bazel.StringListAttribute
2567 Link_crt bazel.BoolAttribute // Only for linking shared library (and cc_binary)
2568
2569 Use_libcrt bazel.BoolAttribute
2570 Use_version_lib bazel.BoolAttribute
2571
2572 Rtti bazel.BoolAttribute
2573 Stl *string
2574 Cpp_std *string
2575 C_std *string
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002576
Liz Kammer1263d9b2021-12-10 14:28:20 -05002577 Export_includes bazel.StringListAttribute
2578 Export_absolute_includes bazel.StringListAttribute
2579 Export_system_includes bazel.StringListAttribute
2580 Local_includes bazel.StringListAttribute
2581 Absolute_includes bazel.StringListAttribute
2582 Hdrs bazel.LabelListAttribute
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002583
Liz Kammerd2871182021-10-04 13:54:37 -04002584 Strip stripAttributes
2585 Additional_linker_inputs bazel.LabelListAttribute
Liz Kammer7a210ac2021-09-22 15:52:58 -04002586
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002587 Cppflags bazel.StringListAttribute
2588 Conlyflags bazel.StringListAttribute
2589 Asflags bazel.StringListAttribute
Liz Kammer0eae52e2021-10-06 10:32:26 -04002590
2591 Features bazel.StringListAttribute
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxac5097f2021-09-01 21:22:09 +00002592}