blob: 9119821a918f1aaf326608bd26b9527ad6239cec [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"
Kiyoung Kim8487c0b2024-01-11 16:03:13 +090020 "log"
Jiyong Parkf1194352019-02-25 11:05:47 +090021 "path/filepath"
Jiyong Parkda732bd2018-11-02 18:23:15 +090022 "regexp"
Jooyung Han11b0fbd2021-02-05 02:28:22 +090023 "strconv"
Colin Cross4d9c2d12016-07-29 12:48:20 -070024 "strings"
Jiyong Parkda732bd2018-11-02 18:23:15 +090025 "sync"
Colin Cross4d9c2d12016-07-29 12:48:20 -070026
Colin Cross4d9c2d12016-07-29 12:48:20 -070027 "android/soong/android"
Kiyoung Kimaa394802024-01-08 12:55:45 +090028
Chris Parsons51f8c392021-08-03 21:01:05 -040029 "github.com/google/blueprint"
30 "github.com/google/blueprint/pathtools"
Spandan Das4238c652022-09-09 01:38:47 +000031 "github.com/google/blueprint/proptools"
Colin Cross4d9c2d12016-07-29 12:48:20 -070032)
33
Liz Kammer2b376bc2022-01-12 12:00:49 -050034// LibraryProperties is a collection of properties shared by cc library rules/cc.
Colin Crossb916a382016-07-29 17:28:03 -070035type LibraryProperties struct {
Colin Cross4d9c2d12016-07-29 12:48:20 -070036 // local file name to pass to the linker as -unexported_symbols_list
Colin Cross27b922f2019-03-04 22:35:41 -080037 Unexported_symbols_list *string `android:"path,arch_variant"`
Colin Cross4d9c2d12016-07-29 12:48:20 -070038 // local file name to pass to the linker as -force_symbols_not_weak_list
Colin Cross27b922f2019-03-04 22:35:41 -080039 Force_symbols_not_weak_list *string `android:"path,arch_variant"`
Colin Cross4d9c2d12016-07-29 12:48:20 -070040 // local file name to pass to the linker as -force_symbols_weak_list
Colin Cross27b922f2019-03-04 22:35:41 -080041 Force_symbols_weak_list *string `android:"path,arch_variant"`
Colin Cross4d9c2d12016-07-29 12:48:20 -070042
43 // rename host libraries to prevent overlap with system installed libraries
44 Unique_host_soname *bool
45
Dan Willemsene1240db2016-11-03 14:28:51 -070046 Aidl struct {
47 // export headers generated from .aidl sources
Nan Zhang0007d812017-11-07 10:57:05 -080048 Export_aidl_headers *bool
Dan Willemsene1240db2016-11-03 14:28:51 -070049 }
50
Colin Cross0c461f12016-10-20 16:11:43 -070051 Proto struct {
52 // export headers generated from .proto sources
Nan Zhang0007d812017-11-07 10:57:05 -080053 Export_proto_headers *bool
Colin Cross0c461f12016-10-20 16:11:43 -070054 }
Dan Albertf563d252017-10-13 00:29:00 -070055
Inseob Kimc0907f12019-02-08 21:00:45 +090056 Sysprop struct {
57 // Whether platform owns this sysprop library.
58 Platform *bool
Inseob Kimb3f22ca2019-03-05 12:40:24 +090059 } `blueprint:"mutated"`
Inseob Kimc0907f12019-02-08 21:00:45 +090060
Nan Zhang0007d812017-11-07 10:57:05 -080061 Static_ndk_lib *bool
Jiyong Park7ed9de32018-10-15 22:25:07 +090062
Florian Mayer6dab96c2020-12-31 11:39:48 +000063 // Generate stubs to make this library accessible to APEXes.
Jiyong Park7ed9de32018-10-15 22:25:07 +090064 Stubs struct {
65 // Relative path to the symbol map. The symbol map provides the list of
66 // symbols that are exported for stubs variant of this library.
Colin Cross27b922f2019-03-04 22:35:41 -080067 Symbol_file *string `android:"path"`
Jiyong Park7ed9de32018-10-15 22:25:07 +090068
Jiyong Parkd4a3a132021-03-17 20:21:35 +090069 // List versions to generate stubs libs for. The version name "current" is always
70 // implicitly added.
Jiyong Park7ed9de32018-10-15 22:25:07 +090071 Versions []string
Alan Stokes73feba32022-11-14 12:21:24 +000072
73 // Whether to not require the implementation of the library to be installed if a
74 // client of the stubs is installed. Defaults to true; set to false if the
75 // implementation is made available by some other means, e.g. in a Microdroid
76 // virtual machine.
77 Implementation_installable *bool
Jiyong Park7ed9de32018-10-15 22:25:07 +090078 }
dimitryd95964a2018-11-07 13:43:34 +010079
80 // set the name of the output
81 Stem *string `android:"arch_variant"`
82
Colin Cross0fd6a412019-08-16 14:22:10 -070083 // set suffix of the name of the output
84 Suffix *string `android:"arch_variant"`
85
Hsin-Yi Chen8feb4132022-12-26 15:54:36 +080086 // Properties for ABI compatibility checker.
87 Header_abi_checker headerAbiCheckerProperties
88
Colin Cross0fd6a412019-08-16 14:22:10 -070089 Target struct {
Justin Yun63e9ec72020-10-29 16:49:43 +090090 Vendor, Product struct {
Colin Cross0fd6a412019-08-16 14:22:10 -070091 // set suffix of the name of the output
92 Suffix *string `android:"arch_variant"`
Hsin-Yi Chen8feb4132022-12-26 15:54:36 +080093
94 Header_abi_checker headerAbiCheckerProperties
Jooyung Han85707de2023-12-01 14:21:13 +090095
96 // Disable stubs for vendor/product variants
97 // This is a workaround to keep `stubs` only for "core" variant (not product/vendor).
98 // It would be nice if we could put `stubs` into a `target: { core: {} }`
99 // block but it's not supported in soong yet. This could be removed/simplified once we have
100 // a better syntax.
101 No_stubs bool
Hsin-Yi Chen8feb4132022-12-26 15:54:36 +0800102 }
103
104 Platform struct {
105 Header_abi_checker headerAbiCheckerProperties
Colin Cross0fd6a412019-08-16 14:22:10 -0700106 }
107 }
108
dimitryd95964a2018-11-07 13:43:34 +0100109 // Names of modules to be overridden. Listed modules can only be other shared libraries
110 // (in Make or Soong).
111 // This does not completely prevent installation of the overridden libraries, but if both
112 // binaries would be installed by default (in PRODUCT_PACKAGES) the other library will be removed
113 // from PRODUCT_PACKAGES.
114 Overrides []string
Logan Chiene3d7a0d2019-01-17 00:18:02 +0800115
Pete Bentley803e1612019-08-06 22:19:59 +0100116 // Inject boringssl hash into the shared library. This is only intended for use by external/boringssl.
117 Inject_bssl_hash *bool `android:"arch_variant"`
Colin Cross0477b422020-10-13 18:43:54 -0700118
Colin Cross127bb8b2020-12-16 16:46:01 -0800119 // If this is an LLNDK library, properties to describe the LLNDK stubs. Will be copied from
120 // the module pointed to by llndk_stubs if it is set.
121 Llndk llndkLibraryProperties
Colin Cross5271fea2021-04-27 13:06:04 -0700122
123 // If this is a vendor public library, properties to describe the vendor public library stubs.
124 Vendor_public_library vendorPublicLibraryProperties
Colin Crossa48ab5b2017-02-14 15:28:44 -0800125}
Colin Cross0c461f12016-10-20 16:11:43 -0700126
Chris Parsons3c27ca32020-11-20 12:42:07 -0500127// StaticProperties is a properties stanza to affect only attributes of the "static" variants of a
128// library module.
Colin Crosse1bb5d02019-09-24 14:55:04 -0700129type StaticProperties struct {
130 Static StaticOrSharedProperties `android:"arch_variant"`
131}
132
Chris Parsons3c27ca32020-11-20 12:42:07 -0500133// SharedProperties is a properties stanza to affect only attributes of the "shared" variants of a
134// library module.
Colin Crosse1bb5d02019-09-24 14:55:04 -0700135type SharedProperties struct {
136 Shared StaticOrSharedProperties `android:"arch_variant"`
137}
138
Chris Parsons3c27ca32020-11-20 12:42:07 -0500139// StaticOrSharedProperties is an embedded struct representing properties to affect attributes of
140// either only the "static" variants or only the "shared" variants of a library module. These override
141// the base properties of the same name.
142// Use `StaticProperties` or `SharedProperties`, depending on which variant is needed.
143// `StaticOrSharedProperties` exists only to avoid duplication.
Colin Crosse1bb5d02019-09-24 14:55:04 -0700144type StaticOrSharedProperties struct {
Evgenii Stepanov2080bfe2020-07-24 15:35:40 -0700145 Srcs []string `android:"path,arch_variant"`
146
Chih-Hung Hsieh769a51c2021-09-17 17:18:39 -0700147 Tidy_disabled_srcs []string `android:"path,arch_variant"`
148
Chih-Hung Hsieh9db8a0c2022-02-17 12:54:45 -0800149 Tidy_timeout_srcs []string `android:"path,arch_variant"`
150
Evgenii Stepanov2080bfe2020-07-24 15:35:40 -0700151 Sanitized Sanitized `android:"arch_variant"`
152
Colin Crosse1bb5d02019-09-24 14:55:04 -0700153 Cflags []string `android:"arch_variant"`
154
Colin Cross6b8f4252021-07-22 11:39:44 -0700155 Enabled *bool `android:"arch_variant"`
156 Whole_static_libs []string `android:"arch_variant"`
157 Static_libs []string `android:"arch_variant"`
158 Shared_libs []string `android:"arch_variant"`
159 System_shared_libs []string `android:"arch_variant"`
Colin Crosse1bb5d02019-09-24 14:55:04 -0700160
161 Export_shared_lib_headers []string `android:"arch_variant"`
162 Export_static_lib_headers []string `android:"arch_variant"`
Jiyong Parka90ca002019-10-07 15:47:24 +0900163
164 Apex_available []string `android:"arch_variant"`
Colin Cross1bc94122021-10-28 13:25:54 -0700165
166 Installable *bool `android:"arch_variant"`
Colin Crosse1bb5d02019-09-24 14:55:04 -0700167}
168
Colin Crossa48ab5b2017-02-14 15:28:44 -0800169type LibraryMutatedProperties struct {
Colin Crossb916a382016-07-29 17:28:03 -0700170 // Build a static variant
171 BuildStatic bool `blueprint:"mutated"`
172 // Build a shared variant
173 BuildShared bool `blueprint:"mutated"`
174 // This variant is shared
175 VariantIsShared bool `blueprint:"mutated"`
176 // This variant is static
177 VariantIsStatic bool `blueprint:"mutated"`
Jiyong Park7ed9de32018-10-15 22:25:07 +0900178
179 // This variant is a stubs lib
180 BuildStubs bool `blueprint:"mutated"`
Jiyong Parkd4a3a132021-03-17 20:21:35 +0900181 // This variant is the latest version
182 IsLatestVersion bool `blueprint:"mutated"`
Jiyong Park7ed9de32018-10-15 22:25:07 +0900183 // Version of the stubs lib
184 StubsVersion string `blueprint:"mutated"`
Colin Crossd1f898e2020-08-18 18:35:15 -0700185 // List of all stubs versions associated with an implementation lib
186 AllStubsVersions []string `blueprint:"mutated"`
Colin Crossb916a382016-07-29 17:28:03 -0700187}
188
189type FlagExporterProperties struct {
190 // list of directories relative to the Blueprints file that will
Dan Willemsen273af7f2016-11-03 15:53:42 -0700191 // be added to the include path (using -I) for this module and any module that links
Colin Cross5d195602017-10-17 16:15:50 -0700192 // against this module. Directories listed in export_include_dirs do not need to be
193 // listed in local_include_dirs.
Colin Cross0ed579e2021-06-29 00:51:12 +0000194 Export_include_dirs []string `android:"arch_variant,variant_prepend"`
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700195
Jiyong Park73c54ee2019-10-22 20:31:18 +0900196 // list of directories that will be added to the system include path
197 // using -isystem for this module and any module that links against this module.
Colin Cross0ed579e2021-06-29 00:51:12 +0000198 Export_system_include_dirs []string `android:"arch_variant,variant_prepend"`
Jiyong Park73c54ee2019-10-22 20:31:18 +0900199
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700200 Target struct {
Justin Yun63e9ec72020-10-29 16:49:43 +0900201 Vendor, Product struct {
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700202 // list of exported include directories, like
Justin Yun63e9ec72020-10-29 16:49:43 +0900203 // export_include_dirs, that will be applied to
204 // vendor or product variant of this library.
205 // This will overwrite any other declarations.
Steven Morelandb21df8f2018-01-05 14:42:54 -0800206 Override_export_include_dirs []string
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700207 }
208 }
Colin Cross4d9c2d12016-07-29 12:48:20 -0700209}
210
211func init() {
Paul Duffin6c26dc72019-12-19 15:02:40 +0000212 RegisterLibraryBuildComponents(android.InitRegistrationContext)
213}
214
215func RegisterLibraryBuildComponents(ctx android.RegistrationContext) {
216 ctx.RegisterModuleType("cc_library_static", LibraryStaticFactory)
217 ctx.RegisterModuleType("cc_library_shared", LibrarySharedFactory)
218 ctx.RegisterModuleType("cc_library", LibraryFactory)
219 ctx.RegisterModuleType("cc_library_host_static", LibraryHostStaticFactory)
220 ctx.RegisterModuleType("cc_library_host_shared", LibraryHostSharedFactory)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700221}
222
Patrice Arruda83c89e02019-03-25 15:32:39 -0700223// cc_library creates both static and/or shared libraries for a device and/or
224// host. By default, a cc_library has a single variant that targets the device.
225// Specifying `host_supported: true` also creates a library that targets the
226// host.
Steven Morelandf9e62162017-11-02 17:00:50 -0700227func LibraryFactory() android.Module {
Colin Crossab3b7322016-12-09 14:46:15 -0800228 module, _ := NewLibrary(android.HostAndDeviceSupported)
Paul Duffina0843f62019-12-13 19:50:38 +0000229 // Can be used as both a static and a shared library.
230 module.sdkMemberTypes = []android.SdkMemberType{
231 sharedLibrarySdkMemberType,
232 staticLibrarySdkMemberType,
Paul Duffin9b76c0b2020-03-12 10:24:35 +0000233 staticAndSharedLibrarySdkMemberType,
Paul Duffina0843f62019-12-13 19:50:38 +0000234 }
Colin Cross4d9c2d12016-07-29 12:48:20 -0700235 return module.Init()
236}
237
Patrice Arruda83c89e02019-03-25 15:32:39 -0700238// cc_library_static creates a static library for a device and/or host binary.
Steven Morelandf9e62162017-11-02 17:00:50 -0700239func LibraryStaticFactory() android.Module {
Colin Crossab3b7322016-12-09 14:46:15 -0800240 module, library := NewLibrary(android.HostAndDeviceSupported)
241 library.BuildOnlyStatic()
Paul Duffina0843f62019-12-13 19:50:38 +0000242 module.sdkMemberTypes = []android.SdkMemberType{staticLibrarySdkMemberType}
Colin Cross4d9c2d12016-07-29 12:48:20 -0700243 return module.Init()
244}
245
Patrice Arruda83c89e02019-03-25 15:32:39 -0700246// cc_library_shared creates a shared library for a device and/or host.
Steven Morelandf9e62162017-11-02 17:00:50 -0700247func LibrarySharedFactory() android.Module {
Colin Crossab3b7322016-12-09 14:46:15 -0800248 module, library := NewLibrary(android.HostAndDeviceSupported)
249 library.BuildOnlyShared()
Paul Duffina0843f62019-12-13 19:50:38 +0000250 module.sdkMemberTypes = []android.SdkMemberType{sharedLibrarySdkMemberType}
Colin Cross4d9c2d12016-07-29 12:48:20 -0700251 return module.Init()
252}
253
Patrice Arruda83c89e02019-03-25 15:32:39 -0700254// cc_library_host_static creates a static library that is linkable to a host
255// binary.
Steven Morelandf9e62162017-11-02 17:00:50 -0700256func LibraryHostStaticFactory() android.Module {
Colin Crossab3b7322016-12-09 14:46:15 -0800257 module, library := NewLibrary(android.HostSupported)
258 library.BuildOnlyStatic()
Paul Duffina0843f62019-12-13 19:50:38 +0000259 module.sdkMemberTypes = []android.SdkMemberType{staticLibrarySdkMemberType}
Colin Cross4d9c2d12016-07-29 12:48:20 -0700260 return module.Init()
261}
262
Patrice Arruda83c89e02019-03-25 15:32:39 -0700263// cc_library_host_shared creates a shared library that is usable on a host.
Steven Morelandf9e62162017-11-02 17:00:50 -0700264func LibraryHostSharedFactory() android.Module {
Colin Crossab3b7322016-12-09 14:46:15 -0800265 module, library := NewLibrary(android.HostSupported)
266 library.BuildOnlyShared()
Paul Duffina0843f62019-12-13 19:50:38 +0000267 module.sdkMemberTypes = []android.SdkMemberType{sharedLibrarySdkMemberType}
Colin Cross4d9c2d12016-07-29 12:48:20 -0700268 return module.Init()
269}
270
Chris Parsons3c27ca32020-11-20 12:42:07 -0500271// flagExporter is a separated portion of libraryDecorator pertaining to exported
272// include paths and flags. Keeping this dependency-related information separate
273// from the rest of library information is helpful in keeping data more structured
274// and explicit.
Colin Cross4d9c2d12016-07-29 12:48:20 -0700275type flagExporter struct {
276 Properties FlagExporterProperties
277
Chris Parsons3c27ca32020-11-20 12:42:07 -0500278 dirs android.Paths // Include directories to be included with -I
279 systemDirs android.Paths // System include directories to be included with -isystem
280 flags []string // Exported raw flags.
Inseob Kim69378442019-06-03 19:10:47 +0900281 deps android.Paths
Inseob Kimd110f872019-12-06 13:15:38 +0900282 headers android.Paths
Colin Cross4d9c2d12016-07-29 12:48:20 -0700283}
284
Chris Parsons3c27ca32020-11-20 12:42:07 -0500285// exportedIncludes returns the effective include paths for this module and
286// any module that links against this module. This is obtained from
287// the export_include_dirs property in the appropriate target stanza.
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700288func (f *flagExporter) exportedIncludes(ctx ModuleContext) android.Paths {
Justin Yun6977e8a2020-10-29 18:24:11 +0900289 if ctx.inVendor() && f.Properties.Target.Vendor.Override_export_include_dirs != nil {
Steven Morelandb21df8f2018-01-05 14:42:54 -0800290 return android.PathsForModuleSrc(ctx, f.Properties.Target.Vendor.Override_export_include_dirs)
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700291 }
Justin Yun6977e8a2020-10-29 18:24:11 +0900292 if ctx.inProduct() && f.Properties.Target.Product.Override_export_include_dirs != nil {
293 return android.PathsForModuleSrc(ctx, f.Properties.Target.Product.Override_export_include_dirs)
294 }
295 return android.PathsForModuleSrc(ctx, f.Properties.Export_include_dirs)
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700296}
297
Chris Parsons3c27ca32020-11-20 12:42:07 -0500298// exportIncludes registers the include directories and system include directories to be exported
299// transitively to modules depending on this module.
Inseob Kim69378442019-06-03 19:10:47 +0900300func (f *flagExporter) exportIncludes(ctx ModuleContext) {
Jiyong Park74955042019-10-22 20:19:51 +0900301 f.dirs = append(f.dirs, f.exportedIncludes(ctx)...)
Jiyong Park73c54ee2019-10-22 20:31:18 +0900302 f.systemDirs = append(f.systemDirs, android.PathsForModuleSrc(ctx, f.Properties.Export_system_include_dirs)...)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700303}
304
Chris Parsons3c27ca32020-11-20 12:42:07 -0500305// exportIncludesAsSystem registers the include directories and system include directories to be
306// exported transitively both as system include directories to modules depending on this module.
Inseob Kim69378442019-06-03 19:10:47 +0900307func (f *flagExporter) exportIncludesAsSystem(ctx ModuleContext) {
Jiyong Park73c54ee2019-10-22 20:31:18 +0900308 // all dirs are force exported as system
Jiyong Park74955042019-10-22 20:19:51 +0900309 f.systemDirs = append(f.systemDirs, f.exportedIncludes(ctx)...)
Jiyong Park73c54ee2019-10-22 20:31:18 +0900310 f.systemDirs = append(f.systemDirs, android.PathsForModuleSrc(ctx, f.Properties.Export_system_include_dirs)...)
Inseob Kim69378442019-06-03 19:10:47 +0900311}
312
Chris Parsons3c27ca32020-11-20 12:42:07 -0500313// reexportDirs registers the given directories as include directories to be exported transitively
314// to modules depending on this module.
Jiyong Park74955042019-10-22 20:19:51 +0900315func (f *flagExporter) reexportDirs(dirs ...android.Path) {
Inseob Kim69378442019-06-03 19:10:47 +0900316 f.dirs = append(f.dirs, dirs...)
317}
318
Chris Parsons3c27ca32020-11-20 12:42:07 -0500319// reexportSystemDirs registers the given directories as system include directories
320// to be exported transitively to modules depending on this module.
Jiyong Park74955042019-10-22 20:19:51 +0900321func (f *flagExporter) reexportSystemDirs(dirs ...android.Path) {
Inseob Kim69378442019-06-03 19:10:47 +0900322 f.systemDirs = append(f.systemDirs, dirs...)
323}
324
Chris Parsons3c27ca32020-11-20 12:42:07 -0500325// reexportFlags registers the flags to be exported transitively to modules depending on this
326// module.
Inseob Kim69378442019-06-03 19:10:47 +0900327func (f *flagExporter) reexportFlags(flags ...string) {
Jaewoong Jung3aff5782020-02-11 07:54:35 -0800328 if android.PrefixInList(flags, "-I") || android.PrefixInList(flags, "-isystem") {
329 panic(fmt.Errorf("Exporting invalid flag %q: "+
330 "use reexportDirs or reexportSystemDirs to export directories", flag))
Inseob Kim69378442019-06-03 19:10:47 +0900331 }
Colin Cross4d9c2d12016-07-29 12:48:20 -0700332 f.flags = append(f.flags, flags...)
333}
334
Inseob Kim69378442019-06-03 19:10:47 +0900335func (f *flagExporter) reexportDeps(deps ...android.Path) {
336 f.deps = append(f.deps, deps...)
337}
338
Inseob Kimd110f872019-12-06 13:15:38 +0900339// addExportedGeneratedHeaders does nothing but collects generated header files.
340// This can be differ to exportedDeps which may contain phony files to minimize ninja.
341func (f *flagExporter) addExportedGeneratedHeaders(headers ...android.Path) {
342 f.headers = append(f.headers, headers...)
343}
344
Colin Cross0de8a1e2020-09-18 14:15:30 -0700345func (f *flagExporter) setProvider(ctx android.ModuleContext) {
Colin Cross40213022023-12-13 15:19:49 -0800346 android.SetProvider(ctx, FlagExporterInfoProvider, FlagExporterInfo{
Chris Parsonsf60ecf02021-04-27 14:48:30 -0400347 // Comes from Export_include_dirs property, and those of exported transitive deps
348 IncludeDirs: android.FirstUniquePaths(f.dirs),
349 // Comes from Export_system_include_dirs property, and those of exported transitive deps
Colin Crossc82e6e22021-04-20 18:21:50 -0700350 SystemIncludeDirs: android.FirstUniquePaths(f.systemDirs),
Chris Parsonsf60ecf02021-04-27 14:48:30 -0400351 // Used in very few places as a one-off way of adding extra defines.
352 Flags: f.flags,
353 // Used sparingly, for extra files that need to be explicitly exported to dependers,
354 // or for phony files to minimize ninja.
355 Deps: f.deps,
356 // For exported generated headers, such as exported aidl headers, proto headers, or
357 // sysprop headers.
358 GeneratedHeaders: f.headers,
Colin Cross0de8a1e2020-09-18 14:15:30 -0700359 })
Inseob Kim69378442019-06-03 19:10:47 +0900360}
361
Colin Crossb916a382016-07-29 17:28:03 -0700362// libraryDecorator wraps baseCompiler, baseLinker and baseInstaller to provide library-specific
363// functionality: static vs. shared linkage, reusing object files for shared libraries
364type libraryDecorator struct {
Colin Crossa48ab5b2017-02-14 15:28:44 -0800365 Properties LibraryProperties
Colin Crosse1bb5d02019-09-24 14:55:04 -0700366 StaticProperties StaticProperties
367 SharedProperties SharedProperties
Colin Crossa48ab5b2017-02-14 15:28:44 -0800368 MutatedProperties LibraryMutatedProperties
Colin Cross4d9c2d12016-07-29 12:48:20 -0700369
370 // For reusing static library objects for shared library
Inseob Kim69378442019-06-03 19:10:47 +0900371 reuseObjects Objects
Colin Cross10d22312017-05-03 11:01:58 -0700372
Colin Cross26c34ed2016-09-30 17:10:16 -0700373 // table-of-contents file to optimize out relinking when possible
374 tocFile android.OptionalPath
Colin Cross4d9c2d12016-07-29 12:48:20 -0700375
Colin Cross4d9c2d12016-07-29 12:48:20 -0700376 flagExporter
Liz Kammerb6a55bf2021-04-12 15:42:51 -0400377 flagExporterInfo *FlagExporterInfo
378 stripper Stripper
Colin Cross4d9c2d12016-07-29 12:48:20 -0700379
Colin Cross4d9c2d12016-07-29 12:48:20 -0700380 // For whole_static_libs
Colin Crossa2bcf2c2022-02-11 13:11:55 -0800381 objects Objects
382 wholeStaticLibsFromPrebuilts android.Paths
Colin Cross4d9c2d12016-07-29 12:48:20 -0700383
384 // Uses the module's name if empty, but can be overridden. Does not include
385 // shlib suffix.
386 libName string
Colin Crossb916a382016-07-29 17:28:03 -0700387
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800388 sabi *sabi
389
Dan Willemsen581341d2017-02-09 16:16:31 -0800390 // Output archive of gcno coverage information files
391 coverageOutputFile android.OptionalPath
392
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800393 // Source Abi Diff
Hsin-Yi Chena6ddb142022-10-27 14:55:42 +0800394 sAbiDiff android.Paths
Mu-Le Lee0a9005e2022-07-05 09:49:50 +0000395
Colin Cross0875c522017-11-28 17:34:01 -0800396 // Location of the static library in the sysroot. Empty if the library is
397 // not included in the NDK.
398 ndkSysrootPath android.Path
399
Colin Crossb60190a2018-09-04 16:28:17 -0700400 // Location of the linked, unstripped library for shared libraries
401 unstrippedOutputFile android.Path
Wei Li5f5d2712023-12-11 15:40:29 -0800402 // Location of the linked, stripped library for shared libraries, strip: "all"
403 strippedAllOutputFile android.Path
Colin Crossb60190a2018-09-04 16:28:17 -0700404
Dan Willemsen569edc52018-11-19 09:33:29 -0800405 // Location of the file that should be copied to dist dir when requested
Jingwen Chen40fd90a2020-06-15 05:24:19 +0000406 distFile android.Path
Dan Willemsen569edc52018-11-19 09:33:29 -0800407
Colin Cross8e21aa52020-09-28 18:28:02 -0700408 versionScriptPath android.OptionalPath
Jiyong Park7ed9de32018-10-15 22:25:07 +0900409
Jaewoong Jung18aefc12020-12-21 09:11:10 -0800410 postInstallCmds []string
Jiyong Parkf1194352019-02-25 11:05:47 +0900411
Vic Yangefd249e2018-11-12 20:19:56 -0800412 // If useCoreVariant is true, the vendor variant of a VNDK library is
413 // not installed.
Vic Yangd92090f2020-01-08 14:32:28 -0800414 useCoreVariant bool
415 checkSameCoreVariant bool
Vic Yangefd249e2018-11-12 20:19:56 -0800416
Colin Cross5ec407b2020-09-30 11:41:33 -0700417 skipAPIDefine bool
418
Martin Stjernholmc5dd4f72020-04-01 20:38:01 +0100419 // Decorated interfaces
Colin Crossb916a382016-07-29 17:28:03 -0700420 *baseCompiler
421 *baseLinker
422 *baseInstaller
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900423
sophiez4c4f8032021-08-16 22:54:00 -0700424 apiListCoverageXmlPath android.ModuleOutPath
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900425}
426
Chris Parsons3c27ca32020-11-20 12:42:07 -0500427// linkerProps returns the list of properties structs relevant for this library. (For example, if
428// the library is cc_shared_library, then static-library properties are omitted.)
Colin Crossb916a382016-07-29 17:28:03 -0700429func (library *libraryDecorator) linkerProps() []interface{} {
430 var props []interface{}
431 props = append(props, library.baseLinker.linkerProps()...)
Colin Crosse1bb5d02019-09-24 14:55:04 -0700432 props = append(props,
Colin Cross4d9c2d12016-07-29 12:48:20 -0700433 &library.Properties,
Colin Crossa48ab5b2017-02-14 15:28:44 -0800434 &library.MutatedProperties,
Colin Cross4d9c2d12016-07-29 12:48:20 -0700435 &library.flagExporter.Properties,
Colin Cross22f37952018-09-05 10:43:13 -0700436 &library.stripper.StripProperties)
Colin Crosse1bb5d02019-09-24 14:55:04 -0700437
438 if library.MutatedProperties.BuildShared {
439 props = append(props, &library.SharedProperties)
440 }
441 if library.MutatedProperties.BuildStatic {
442 props = append(props, &library.StaticProperties)
443 }
444
445 return props
Colin Cross4d9c2d12016-07-29 12:48:20 -0700446}
447
Chris Parsons3c27ca32020-11-20 12:42:07 -0500448// linkerFlags takes a Flags struct and augments it to contain linker flags that are defined by this
449// library, or that are implied by attributes of this library (such as whether this library is a
450// shared library).
Colin Crossb916a382016-07-29 17:28:03 -0700451func (library *libraryDecorator) linkerFlags(ctx ModuleContext, flags Flags) Flags {
Colin Cross42742b82016-08-01 13:20:05 -0700452 flags = library.baseLinker.linkerFlags(ctx, flags)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700453
Colin Crossb916a382016-07-29 17:28:03 -0700454 // MinGW spits out warnings about -fPIC even for -fpie?!) being ignored because
455 // all code is position independent, and then those warnings get promoted to
456 // errors.
Colin Cross3edeee12017-04-04 12:59:48 -0700457 if !ctx.Windows() {
Colin Cross4af21ed2019-11-04 09:37:55 -0800458 flags.Global.CFlags = append(flags.Global.CFlags, "-fPIC")
Colin Crossb916a382016-07-29 17:28:03 -0700459 }
460
461 if library.static() {
Colin Cross4af21ed2019-11-04 09:37:55 -0800462 flags.Local.CFlags = append(flags.Local.CFlags, library.StaticProperties.Static.Cflags...)
Colin Crossa48ab5b2017-02-14 15:28:44 -0800463 } else if library.shared() {
Colin Cross4af21ed2019-11-04 09:37:55 -0800464 flags.Local.CFlags = append(flags.Local.CFlags, library.SharedProperties.Shared.Cflags...)
Colin Crossb916a382016-07-29 17:28:03 -0700465 }
466
Colin Crossa48ab5b2017-02-14 15:28:44 -0800467 if library.shared() {
Colin Cross4d9c2d12016-07-29 12:48:20 -0700468 libName := library.getLibName(ctx)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700469 var f []string
Dan Willemsen01a405a2016-06-13 17:19:03 -0700470 if ctx.toolchain().Bionic() {
Colin Cross4d9c2d12016-07-29 12:48:20 -0700471 f = append(f,
472 "-nostdlib",
473 "-Wl,--gc-sections",
474 )
475 }
476
477 if ctx.Darwin() {
478 f = append(f,
479 "-dynamiclib",
Colin Cross4d9c2d12016-07-29 12:48:20 -0700480 "-install_name @rpath/"+libName+flags.Toolchain.ShlibSuffix(),
481 )
Colin Cross7863cf52016-10-20 10:47:21 -0700482 if ctx.Arch().ArchType == android.X86 {
483 f = append(f,
484 "-read_only_relocs suppress",
485 )
486 }
Colin Cross4d9c2d12016-07-29 12:48:20 -0700487 } else {
Josh Gao75a50a22019-06-07 17:58:59 -0700488 f = append(f, "-shared")
489 if !ctx.Windows() {
490 f = append(f, "-Wl,-soname,"+libName+flags.Toolchain.ShlibSuffix())
491 }
Colin Cross4d9c2d12016-07-29 12:48:20 -0700492 }
493
Colin Cross4af21ed2019-11-04 09:37:55 -0800494 flags.Global.LdFlags = append(flags.Global.LdFlags, f...)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700495 }
496
497 return flags
498}
499
Chris Parsons3c27ca32020-11-20 12:42:07 -0500500// compilerFlags takes a Flags and augments it to contain compile flags from global values,
501// per-target values, module type values, per-module Blueprints properties, extra flags from
502// `flags`, and generated sources from `deps`.
Colin Crossf18e1102017-11-16 14:33:08 -0800503func (library *libraryDecorator) compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags {
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700504 exportIncludeDirs := library.flagExporter.exportedIncludes(ctx)
Dan Willemsen273af7f2016-11-03 15:53:42 -0700505 if len(exportIncludeDirs) > 0 {
Colin Crossdad8c952017-04-26 14:55:27 -0700506 f := includeDirsToFlags(exportIncludeDirs)
Colin Cross4af21ed2019-11-04 09:37:55 -0800507 flags.Local.CommonFlags = append(flags.Local.CommonFlags, f)
508 flags.Local.YasmFlags = append(flags.Local.YasmFlags, f)
Dan Willemsen273af7f2016-11-03 15:53:42 -0700509 }
510
Jiyong Park7ed9de32018-10-15 22:25:07 +0900511 flags = library.baseCompiler.compilerFlags(ctx, flags, deps)
Colin Cross127bb8b2020-12-16 16:46:01 -0800512 if ctx.IsLlndk() {
513 // LLNDK libraries ignore most of the properties on the cc_library and use the
514 // LLNDK-specific properties instead.
515 // Wipe all the module-local properties, leaving only the global properties.
516 flags.Local = LocalOrGlobalFlags{}
517 }
Jiyong Park7ed9de32018-10-15 22:25:07 +0900518 if library.buildStubs() {
Jiyong Park64379952018-12-13 18:37:29 +0900519 // Remove -include <file> when compiling stubs. Otherwise, the force included
520 // headers might cause conflicting types error with the symbols in the
521 // generated stubs source code. e.g.
522 // double acos(double); // in header
523 // void acos() {} // in the generated source code
524 removeInclude := func(flags []string) []string {
525 ret := flags[:0]
526 for _, f := range flags {
527 if strings.HasPrefix(f, "-include ") {
528 continue
529 }
530 ret = append(ret, f)
531 }
532 return ret
533 }
Colin Cross4af21ed2019-11-04 09:37:55 -0800534 flags.Local.CommonFlags = removeInclude(flags.Local.CommonFlags)
535 flags.Local.CFlags = removeInclude(flags.Local.CFlags)
Jiyong Park64379952018-12-13 18:37:29 +0900536
Jiyong Park7ed9de32018-10-15 22:25:07 +0900537 flags = addStubLibraryCompilerFlags(flags)
538 }
539 return flags
Dan Willemsen273af7f2016-11-03 15:53:42 -0700540}
541
Hsin-Yi Chen8feb4132022-12-26 15:54:36 +0800542func (library *libraryDecorator) getHeaderAbiCheckerProperties(ctx android.BaseModuleContext) headerAbiCheckerProperties {
543 m := ctx.Module().(*Module)
544 variantProps := &library.Properties.Target.Platform.Header_abi_checker
545 if m.InVendor() {
546 variantProps = &library.Properties.Target.Vendor.Header_abi_checker
547 } else if m.InProduct() {
548 variantProps = &library.Properties.Target.Product.Header_abi_checker
549 }
550 props := library.Properties.Header_abi_checker
551 err := proptools.AppendProperties(&props, variantProps, nil)
552 if err != nil {
553 ctx.ModuleErrorf("Cannot merge headerAbiCheckerProperties: %s", err.Error())
554 }
555 return props
Logan Chien41eabe62019-04-10 13:33:58 +0800556}
557
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700558func (library *libraryDecorator) compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects {
Colin Cross127bb8b2020-12-16 16:46:01 -0800559 if ctx.IsLlndk() {
Jooyung Han33eb6152024-03-11 15:46:48 +0900560 vendorApiLevel := ctx.Config().VendorApiLevel()
561 if vendorApiLevel == "" {
562 // TODO(b/321892570): Some tests relying on old fixtures which
563 // doesn't set vendorApiLevel. Needs to fix them.
564 vendorApiLevel = ctx.Config().PlatformSdkVersion().String()
565 }
Colin Cross127bb8b2020-12-16 16:46:01 -0800566 // This is the vendor variant of an LLNDK library, build the LLNDK stubs.
Dan Albertf1d14c72020-07-30 14:32:55 -0700567 nativeAbiResult := parseNativeAbiDefinition(ctx,
568 String(library.Properties.Llndk.Symbol_file),
Jooyung Han33eb6152024-03-11 15:46:48 +0900569 android.ApiLevelOrPanic(ctx, vendorApiLevel), "--llndk")
Dan Albertf1d14c72020-07-30 14:32:55 -0700570 objs := compileStubLibrary(ctx, flags, nativeAbiResult.stubSrc)
Colin Cross127bb8b2020-12-16 16:46:01 -0800571 if !Bool(library.Properties.Llndk.Unversioned) {
Dan Albertf1d14c72020-07-30 14:32:55 -0700572 library.versionScriptPath = android.OptionalPathForPath(
573 nativeAbiResult.versionScript)
Colin Cross127bb8b2020-12-16 16:46:01 -0800574 }
575 return objs
576 }
Colin Cross5271fea2021-04-27 13:06:04 -0700577 if ctx.IsVendorPublicLibrary() {
Dan Albertf1d14c72020-07-30 14:32:55 -0700578 nativeAbiResult := parseNativeAbiDefinition(ctx,
579 String(library.Properties.Vendor_public_library.Symbol_file),
580 android.FutureApiLevel, "")
581 objs := compileStubLibrary(ctx, flags, nativeAbiResult.stubSrc)
Colin Cross5271fea2021-04-27 13:06:04 -0700582 if !Bool(library.Properties.Vendor_public_library.Unversioned) {
Dan Albertf1d14c72020-07-30 14:32:55 -0700583 library.versionScriptPath = android.OptionalPathForPath(nativeAbiResult.versionScript)
Colin Cross5271fea2021-04-27 13:06:04 -0700584 }
585 return objs
586 }
Jiyong Park7ed9de32018-10-15 22:25:07 +0900587 if library.buildStubs() {
Jiyong Parka4175572021-02-04 21:05:47 +0900588 symbolFile := String(library.Properties.Stubs.Symbol_file)
589 if symbolFile != "" && !strings.HasSuffix(symbolFile, ".map.txt") {
590 ctx.PropertyErrorf("symbol_file", "%q doesn't have .map.txt suffix", symbolFile)
591 return Objects{}
592 }
Jiyong Park85cc35a2022-07-17 11:30:47 +0900593 // b/239274367 --apex and --systemapi filters symbols tagged with # apex and #
594 // systemapi, respectively. The former is for symbols defined in platform libraries
595 // and the latter is for symbols defined in APEXes.
Spandan Das934c97d2023-01-18 23:54:13 +0000596 // A single library can contain either # apex or # systemapi, but not both.
597 // The stub generator (ndkstubgen) is additive, so passing _both_ of these to it should be a no-op.
598 // However, having this distinction helps guard accidental
599 // promotion or demotion of API and also helps the API review process b/191371676
Jiyong Park85cc35a2022-07-17 11:30:47 +0900600 var flag string
601 if ctx.Module().(android.ApexModule).NotInPlatform() {
602 flag = "--apex"
603 } else {
Jiyong Parkffea9b32022-07-17 17:32:56 +0900604 flag = "--systemapi"
Jiyong Park85cc35a2022-07-17 11:30:47 +0900605 }
Jiyong Parkaa27c082022-09-26 21:16:09 +0900606 // b/184712170, unless the lib is an NDK library, exclude all public symbols from
607 // the stub so that it is mandated that all symbols are explicitly marked with
608 // either apex or systemapi.
609 if !ctx.Module().(*Module).IsNdk(ctx.Config()) {
610 flag = flag + " --no-ndk"
611 }
Dan Albertf1d14c72020-07-30 14:32:55 -0700612 nativeAbiResult := parseNativeAbiDefinition(ctx, symbolFile,
Jiyong Park85cc35a2022-07-17 11:30:47 +0900613 android.ApiLevelOrPanic(ctx, library.MutatedProperties.StubsVersion), flag)
Dan Albertf1d14c72020-07-30 14:32:55 -0700614 objs := compileStubLibrary(ctx, flags, nativeAbiResult.stubSrc)
615 library.versionScriptPath = android.OptionalPathForPath(
616 nativeAbiResult.versionScript)
sophiez4c4f8032021-08-16 22:54:00 -0700617
618 // Parse symbol file to get API list for coverage
Colin Crossceaa5322021-09-28 16:37:50 -0700619 if library.stubsVersion() == "current" && ctx.PrimaryArch() && !ctx.inRecovery() && !ctx.inProduct() && !ctx.inVendor() {
sophiez4c4f8032021-08-16 22:54:00 -0700620 library.apiListCoverageXmlPath = parseSymbolFileForAPICoverage(ctx, symbolFile)
621 }
622
Jiyong Park7ed9de32018-10-15 22:25:07 +0900623 return objs
624 }
625
Colin Cross5950f382016-12-13 12:50:57 -0800626 if !library.buildShared() && !library.buildStatic() {
627 if len(library.baseCompiler.Properties.Srcs) > 0 {
628 ctx.PropertyErrorf("srcs", "cc_library_headers must not have any srcs")
629 }
Colin Crosse1bb5d02019-09-24 14:55:04 -0700630 if len(library.StaticProperties.Static.Srcs) > 0 {
Colin Cross5950f382016-12-13 12:50:57 -0800631 ctx.PropertyErrorf("static.srcs", "cc_library_headers must not have any srcs")
632 }
Colin Crosse1bb5d02019-09-24 14:55:04 -0700633 if len(library.SharedProperties.Shared.Srcs) > 0 {
Colin Cross5950f382016-12-13 12:50:57 -0800634 ctx.PropertyErrorf("shared.srcs", "cc_library_headers must not have any srcs")
635 }
636 return Objects{}
637 }
Yo Chiang2bbadfa2020-12-14 11:42:16 +0800638 if library.sabi.shouldCreateSourceAbiDump() {
Hsin-Yi Chenaf369882024-03-29 20:10:36 +0800639 dirs := library.exportedIncludeDirsForAbiCheck(ctx)
640 flags.SAbiFlags = make([]string, 0, len(dirs))
641 for _, dir := range dirs {
642 flags.SAbiFlags = append(flags.SAbiFlags, "-I"+dir)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800643 }
Jaewoong Jung18aefc12020-12-21 09:11:10 -0800644 totalLength := len(library.baseCompiler.Properties.Srcs) + len(deps.GeneratedSources) +
Colin Crosse1bb5d02019-09-24 14:55:04 -0700645 len(library.SharedProperties.Shared.Srcs) + len(library.StaticProperties.Static.Srcs)
Jaewoong Jung18aefc12020-12-21 09:11:10 -0800646 if totalLength > 0 {
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800647 flags.SAbiDump = true
648 }
649 }
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700650 objs := library.baseCompiler.compile(ctx, flags, deps)
651 library.reuseObjects = objs
Colin Cross2f336352016-10-26 10:03:47 -0700652 buildFlags := flagsToBuilderFlags(flags)
Colin Crossb916a382016-07-29 17:28:03 -0700653
Colin Cross4d9c2d12016-07-29 12:48:20 -0700654 if library.static() {
Colin Crosse1bb5d02019-09-24 14:55:04 -0700655 srcs := android.PathsForModuleSrc(ctx, library.StaticProperties.Static.Srcs)
Chih-Hung Hsieh769a51c2021-09-17 17:18:39 -0700656 objs = objs.Append(compileObjs(ctx, buildFlags, android.DeviceStaticLibrary, srcs,
657 android.PathsForModuleSrc(ctx, library.StaticProperties.Static.Tidy_disabled_srcs),
Chih-Hung Hsieh9db8a0c2022-02-17 12:54:45 -0800658 android.PathsForModuleSrc(ctx, library.StaticProperties.Static.Tidy_timeout_srcs),
Chih-Hung Hsieh769a51c2021-09-17 17:18:39 -0700659 library.baseCompiler.pathDeps, library.baseCompiler.cFlagsDeps))
Colin Crossa48ab5b2017-02-14 15:28:44 -0800660 } else if library.shared() {
Colin Crosse1bb5d02019-09-24 14:55:04 -0700661 srcs := android.PathsForModuleSrc(ctx, library.SharedProperties.Shared.Srcs)
Chih-Hung Hsieh769a51c2021-09-17 17:18:39 -0700662 objs = objs.Append(compileObjs(ctx, buildFlags, android.DeviceSharedLibrary, srcs,
663 android.PathsForModuleSrc(ctx, library.SharedProperties.Shared.Tidy_disabled_srcs),
Chih-Hung Hsieh9db8a0c2022-02-17 12:54:45 -0800664 android.PathsForModuleSrc(ctx, library.SharedProperties.Shared.Tidy_timeout_srcs),
Chih-Hung Hsieh769a51c2021-09-17 17:18:39 -0700665 library.baseCompiler.pathDeps, library.baseCompiler.cFlagsDeps))
Colin Crossb916a382016-07-29 17:28:03 -0700666 }
667
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700668 return objs
Colin Crossb916a382016-07-29 17:28:03 -0700669}
670
671type libraryInterface interface {
Colin Cross3572cf72020-10-01 15:58:11 -0700672 versionedInterface
673
Colin Crossb916a382016-07-29 17:28:03 -0700674 static() bool
Inseob Kimae553032019-05-14 18:52:49 +0900675 shared() bool
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700676 objs() Objects
Colin Cross0de8a1e2020-09-18 14:15:30 -0700677 reuseObjs() Objects
Colin Cross26c34ed2016-09-30 17:10:16 -0700678 toc() android.OptionalPath
Colin Crossb916a382016-07-29 17:28:03 -0700679
680 // Returns true if the build options for the module have selected a static or shared build
681 buildStatic() bool
682 buildShared() bool
683
684 // Sets whether a specific variant is static or shared
Colin Crossa48ab5b2017-02-14 15:28:44 -0800685 setStatic()
686 setShared()
Logan Chien41eabe62019-04-10 13:33:58 +0800687
Hsin-Yi Chen8feb4132022-12-26 15:54:36 +0800688 // Gets the ABI properties for vendor, product, or platform variant
689 getHeaderAbiCheckerProperties(ctx android.BaseModuleContext) headerAbiCheckerProperties
Yo Chiang2bbadfa2020-12-14 11:42:16 +0800690
Logan Chien41eabe62019-04-10 13:33:58 +0800691 // Write LOCAL_ADDITIONAL_DEPENDENCIES for ABI diff
692 androidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer)
Jiyong Parka90ca002019-10-07 15:47:24 +0900693
694 availableFor(string) bool
Colin Crossceaa5322021-09-28 16:37:50 -0700695
696 getAPIListCoverageXMLPath() android.ModuleOutPath
Colin Cross1bc94122021-10-28 13:25:54 -0700697
698 installable() *bool
Colin Crossb916a382016-07-29 17:28:03 -0700699}
700
Colin Crossc88c2722020-09-28 17:32:47 -0700701type versionedInterface interface {
702 buildStubs() bool
Jiyong Parkd4a3a132021-03-17 20:21:35 +0900703 setBuildStubs(isLatest bool)
Colin Crossc88c2722020-09-28 17:32:47 -0700704 hasStubsVariants() bool
Alan Stokes73feba32022-11-14 12:21:24 +0000705 isStubsImplementationRequired() bool
Colin Crossc88c2722020-09-28 17:32:47 -0700706 setStubsVersion(string)
707 stubsVersion() string
708
Colin Cross3572cf72020-10-01 15:58:11 -0700709 stubsVersions(ctx android.BaseMutatorContext) []string
Colin Crossc88c2722020-09-28 17:32:47 -0700710 setAllStubsVersions([]string)
711 allStubsVersions() []string
Colin Cross0477b422020-10-13 18:43:54 -0700712
713 implementationModuleName(name string) string
Colin Cross127bb8b2020-12-16 16:46:01 -0800714 hasLLNDKStubs() bool
Colin Cross1f3f1302021-04-26 18:37:44 -0700715 hasLLNDKHeaders() bool
Colin Cross5271fea2021-04-27 13:06:04 -0700716 hasVendorPublicLibrary() bool
Colin Crossc88c2722020-09-28 17:32:47 -0700717}
718
719var _ libraryInterface = (*libraryDecorator)(nil)
720var _ versionedInterface = (*libraryDecorator)(nil)
721
Justin Yun6977e8a2020-10-29 18:24:11 +0900722func (library *libraryDecorator) getLibNameHelper(baseModuleName string, inVendor bool, inProduct bool) string {
Colin Crossb916a382016-07-29 17:28:03 -0700723 name := library.libName
724 if name == "" {
dimitryd95964a2018-11-07 13:43:34 +0100725 name = String(library.Properties.Stem)
726 if name == "" {
Jooyung Han0302a842019-10-30 18:43:49 +0900727 name = baseModuleName
dimitryd95964a2018-11-07 13:43:34 +0100728 }
Colin Crossb916a382016-07-29 17:28:03 -0700729 }
730
Colin Cross0fd6a412019-08-16 14:22:10 -0700731 suffix := ""
Justin Yun6977e8a2020-10-29 18:24:11 +0900732 if inVendor {
Colin Cross0fd6a412019-08-16 14:22:10 -0700733 suffix = String(library.Properties.Target.Vendor.Suffix)
Justin Yun6977e8a2020-10-29 18:24:11 +0900734 } else if inProduct {
735 suffix = String(library.Properties.Target.Product.Suffix)
Colin Cross0fd6a412019-08-16 14:22:10 -0700736 }
737 if suffix == "" {
738 suffix = String(library.Properties.Suffix)
739 }
740
Jooyung Han0302a842019-10-30 18:43:49 +0900741 return name + suffix
742}
743
Chris Parsons3c27ca32020-11-20 12:42:07 -0500744// getLibName returns the actual canonical name of the library (the name which
745// should be passed to the linker via linker flags).
Jooyung Han0302a842019-10-30 18:43:49 +0900746func (library *libraryDecorator) getLibName(ctx BaseModuleContext) string {
Justin Yun6977e8a2020-10-29 18:24:11 +0900747 name := library.getLibNameHelper(ctx.baseModuleName(), ctx.inVendor(), ctx.inProduct())
Colin Cross0fd6a412019-08-16 14:22:10 -0700748
Kiyoung Kim8487c0b2024-01-11 16:03:13 +0900749 // Replace name with VNDK ext as original lib only when VNDK is enabled
Ivan Lozanof9e21722020-12-02 09:00:51 -0500750 if ctx.IsVndkExt() {
Kiyoung Kim8487c0b2024-01-11 16:03:13 +0900751 if ctx.DeviceConfig().VndkVersion() != "" {
752 // vndk-ext lib should have the same name with original lib
753 ctx.VisitDirectDepsWithTag(vndkExtDepTag, func(module android.Module) {
754 originalName := module.(*Module).outputFile.Path()
755 name = strings.TrimSuffix(originalName.Base(), originalName.Ext())
756 })
757 } else {
758 // TODO(b/320208784) : Suggest a solution for former VNDK-ext libraries before VNDK deprecation.
759 log.Printf("VNDK Extension on module %s will not be available once VNDK is deprecated", ctx.baseModuleName())
760 }
Logan Chienf3511742017-10-31 18:04:35 +0800761 }
762
Colin Crossb916a382016-07-29 17:28:03 -0700763 if ctx.Host() && Bool(library.Properties.Unique_host_soname) {
764 if !strings.HasSuffix(name, "-host") {
765 name = name + "-host"
766 }
767 }
768
Inseob Kim0ce291e2019-07-04 14:38:27 +0900769 return name
Colin Crossb916a382016-07-29 17:28:03 -0700770}
771
Jiyong Parkda732bd2018-11-02 18:23:15 +0900772var versioningMacroNamesListMutex sync.Mutex
773
Colin Crossb916a382016-07-29 17:28:03 -0700774func (library *libraryDecorator) linkerInit(ctx BaseModuleContext) {
775 location := InstallInSystem
Dan Albert61f32122018-07-26 14:00:24 -0700776 if library.baseLinker.sanitize.inSanitizerDir() {
Vishwath Mohan1dd88392017-03-29 22:00:18 -0700777 location = InstallInSanitizerDir
Colin Crossb916a382016-07-29 17:28:03 -0700778 }
779 library.baseInstaller.location = location
Colin Crossb916a382016-07-29 17:28:03 -0700780 library.baseLinker.linkerInit(ctx)
Jiyong Park7ed9de32018-10-15 22:25:07 +0900781 // Let baseLinker know whether this variant is for stubs or not, so that
782 // it can omit things that are not required for linking stubs.
783 library.baseLinker.dynamicProperties.BuildStubs = library.buildStubs()
Jiyong Parkda732bd2018-11-02 18:23:15 +0900784
785 if library.buildStubs() {
786 macroNames := versioningMacroNamesList(ctx.Config())
787 myName := versioningMacroName(ctx.ModuleName())
788 versioningMacroNamesListMutex.Lock()
789 defer versioningMacroNamesListMutex.Unlock()
790 if (*macroNames)[myName] == "" {
791 (*macroNames)[myName] = ctx.ModuleName()
792 } else if (*macroNames)[myName] != ctx.ModuleName() {
793 ctx.ModuleErrorf("Macro name %q for versioning conflicts with macro name from module %q ", myName, (*macroNames)[myName])
794 }
795 }
Colin Crossb916a382016-07-29 17:28:03 -0700796}
797
dimitry0345ad82018-12-05 16:28:14 +0100798func (library *libraryDecorator) compilerDeps(ctx DepsContext, deps Deps) Deps {
Colin Cross127bb8b2020-12-16 16:46:01 -0800799 if ctx.IsLlndk() {
800 // LLNDK libraries ignore most of the properties on the cc_library and use the
801 // LLNDK-specific properties instead.
802 return deps
803 }
804
dimitry0345ad82018-12-05 16:28:14 +0100805 deps = library.baseCompiler.compilerDeps(ctx, deps)
806
dimitry0345ad82018-12-05 16:28:14 +0100807 return deps
808}
809
Colin Cross37047f12016-12-13 17:06:13 -0800810func (library *libraryDecorator) linkerDeps(ctx DepsContext, deps Deps) Deps {
Colin Cross127bb8b2020-12-16 16:46:01 -0800811 if ctx.IsLlndk() {
812 // LLNDK libraries ignore most of the properties on the cc_library and use the
813 // LLNDK-specific properties instead.
Colin Cross0fb7fcd2021-03-02 11:00:07 -0800814 deps.HeaderLibs = append([]string(nil), library.Properties.Llndk.Export_llndk_headers...)
815 deps.ReexportHeaderLibHeaders = append([]string(nil), library.Properties.Llndk.Export_llndk_headers...)
Colin Cross127bb8b2020-12-16 16:46:01 -0800816 return deps
817 }
Colin Cross5271fea2021-04-27 13:06:04 -0700818 if ctx.IsVendorPublicLibrary() {
819 headers := library.Properties.Vendor_public_library.Export_public_headers
820 deps.HeaderLibs = append([]string(nil), headers...)
821 deps.ReexportHeaderLibHeaders = append([]string(nil), headers...)
822 return deps
823 }
Colin Cross127bb8b2020-12-16 16:46:01 -0800824
Dan Willemsen3a26eef2018-12-03 15:25:46 -0800825 if library.static() {
Martin Stjernholm10566a02020-03-24 01:19:52 +0000826 // Compare with nil because an empty list needs to be propagated.
Colin Crosse1bb5d02019-09-24 14:55:04 -0700827 if library.StaticProperties.Static.System_shared_libs != nil {
828 library.baseLinker.Properties.System_shared_libs = library.StaticProperties.Static.System_shared_libs
Dan Willemsen3a26eef2018-12-03 15:25:46 -0800829 }
830 } else if library.shared() {
Martin Stjernholm10566a02020-03-24 01:19:52 +0000831 // Compare with nil because an empty list needs to be propagated.
Colin Crosse1bb5d02019-09-24 14:55:04 -0700832 if library.SharedProperties.Shared.System_shared_libs != nil {
833 library.baseLinker.Properties.System_shared_libs = library.SharedProperties.Shared.System_shared_libs
Dan Willemsen3a26eef2018-12-03 15:25:46 -0800834 }
835 }
836
Colin Crossb916a382016-07-29 17:28:03 -0700837 deps = library.baseLinker.linkerDeps(ctx, deps)
838
839 if library.static() {
840 deps.WholeStaticLibs = append(deps.WholeStaticLibs,
Colin Crosse1bb5d02019-09-24 14:55:04 -0700841 library.StaticProperties.Static.Whole_static_libs...)
842 deps.StaticLibs = append(deps.StaticLibs, library.StaticProperties.Static.Static_libs...)
843 deps.SharedLibs = append(deps.SharedLibs, library.StaticProperties.Static.Shared_libs...)
Colin Crosseefe9a32019-01-22 14:41:08 -0800844
Colin Crosse1bb5d02019-09-24 14:55:04 -0700845 deps.ReexportSharedLibHeaders = append(deps.ReexportSharedLibHeaders, library.StaticProperties.Static.Export_shared_lib_headers...)
846 deps.ReexportStaticLibHeaders = append(deps.ReexportStaticLibHeaders, library.StaticProperties.Static.Export_static_lib_headers...)
Colin Crossa48ab5b2017-02-14 15:28:44 -0800847 } else if library.shared() {
Alex Márquez Pérez Muñíz Díaz Puras Thaureaux01ec55e2023-01-30 22:53:04 +0000848 if library.baseLinker.Properties.crt() {
Colin Crossd1a28132021-06-21 17:34:47 -0700849 deps.CrtBegin = append(deps.CrtBegin, ctx.toolchain().CrtBeginSharedLibrary()...)
850 deps.CrtEnd = append(deps.CrtEnd, ctx.toolchain().CrtEndSharedLibrary()...)
Kalesh Singhf4ffe0a2024-01-29 13:01:51 -0800851
852 }
853 if library.baseLinker.Properties.crtPadSegment() {
854 deps.CrtEnd = append(deps.CrtEnd, ctx.toolchain().CrtPadSegmentSharedLibrary()...)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700855 }
Colin Crosse1bb5d02019-09-24 14:55:04 -0700856 deps.WholeStaticLibs = append(deps.WholeStaticLibs, library.SharedProperties.Shared.Whole_static_libs...)
857 deps.StaticLibs = append(deps.StaticLibs, library.SharedProperties.Shared.Static_libs...)
858 deps.SharedLibs = append(deps.SharedLibs, library.SharedProperties.Shared.Shared_libs...)
Colin Crosseefe9a32019-01-22 14:41:08 -0800859
Colin Crosse1bb5d02019-09-24 14:55:04 -0700860 deps.ReexportSharedLibHeaders = append(deps.ReexportSharedLibHeaders, library.SharedProperties.Shared.Export_shared_lib_headers...)
861 deps.ReexportStaticLibHeaders = append(deps.ReexportStaticLibHeaders, library.SharedProperties.Shared.Export_static_lib_headers...)
Hsin-Yi Chen715142a2024-03-27 16:31:16 +0800862
863 deps.LlndkHeaderLibs = append(deps.LlndkHeaderLibs, library.Properties.Llndk.Export_llndk_headers...)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700864 }
Justin Yun6977e8a2020-10-29 18:24:11 +0900865 if ctx.inVendor() {
Jiyong Park52d25bd2017-10-13 09:17:01 +0900866 deps.WholeStaticLibs = removeListFromList(deps.WholeStaticLibs, library.baseLinker.Properties.Target.Vendor.Exclude_static_libs)
867 deps.SharedLibs = removeListFromList(deps.SharedLibs, library.baseLinker.Properties.Target.Vendor.Exclude_shared_libs)
868 deps.StaticLibs = removeListFromList(deps.StaticLibs, library.baseLinker.Properties.Target.Vendor.Exclude_static_libs)
Victor Chang51271c12019-01-30 16:02:22 +0000869 deps.ReexportSharedLibHeaders = removeListFromList(deps.ReexportSharedLibHeaders, library.baseLinker.Properties.Target.Vendor.Exclude_shared_libs)
870 deps.ReexportStaticLibHeaders = removeListFromList(deps.ReexportStaticLibHeaders, library.baseLinker.Properties.Target.Vendor.Exclude_static_libs)
Jiyong Park52d25bd2017-10-13 09:17:01 +0900871 }
Justin Yun6977e8a2020-10-29 18:24:11 +0900872 if ctx.inProduct() {
873 deps.WholeStaticLibs = removeListFromList(deps.WholeStaticLibs, library.baseLinker.Properties.Target.Product.Exclude_static_libs)
874 deps.SharedLibs = removeListFromList(deps.SharedLibs, library.baseLinker.Properties.Target.Product.Exclude_shared_libs)
875 deps.StaticLibs = removeListFromList(deps.StaticLibs, library.baseLinker.Properties.Target.Product.Exclude_static_libs)
876 deps.ReexportSharedLibHeaders = removeListFromList(deps.ReexportSharedLibHeaders, library.baseLinker.Properties.Target.Product.Exclude_shared_libs)
877 deps.ReexportStaticLibHeaders = removeListFromList(deps.ReexportStaticLibHeaders, library.baseLinker.Properties.Target.Product.Exclude_static_libs)
878 }
Jiyong Parkf9332f12018-02-01 00:54:12 +0900879 if ctx.inRecovery() {
880 deps.WholeStaticLibs = removeListFromList(deps.WholeStaticLibs, library.baseLinker.Properties.Target.Recovery.Exclude_static_libs)
881 deps.SharedLibs = removeListFromList(deps.SharedLibs, library.baseLinker.Properties.Target.Recovery.Exclude_shared_libs)
882 deps.StaticLibs = removeListFromList(deps.StaticLibs, library.baseLinker.Properties.Target.Recovery.Exclude_static_libs)
Victor Chang51271c12019-01-30 16:02:22 +0000883 deps.ReexportSharedLibHeaders = removeListFromList(deps.ReexportSharedLibHeaders, library.baseLinker.Properties.Target.Recovery.Exclude_shared_libs)
884 deps.ReexportStaticLibHeaders = removeListFromList(deps.ReexportStaticLibHeaders, library.baseLinker.Properties.Target.Recovery.Exclude_static_libs)
Jiyong Parkf9332f12018-02-01 00:54:12 +0900885 }
Yifan Hongcf4832c2020-01-21 17:04:13 -0800886 if ctx.inRamdisk() {
887 deps.WholeStaticLibs = removeListFromList(deps.WholeStaticLibs, library.baseLinker.Properties.Target.Ramdisk.Exclude_static_libs)
888 deps.SharedLibs = removeListFromList(deps.SharedLibs, library.baseLinker.Properties.Target.Ramdisk.Exclude_shared_libs)
889 deps.StaticLibs = removeListFromList(deps.StaticLibs, library.baseLinker.Properties.Target.Ramdisk.Exclude_static_libs)
890 deps.ReexportSharedLibHeaders = removeListFromList(deps.ReexportSharedLibHeaders, library.baseLinker.Properties.Target.Ramdisk.Exclude_shared_libs)
891 deps.ReexportStaticLibHeaders = removeListFromList(deps.ReexportStaticLibHeaders, library.baseLinker.Properties.Target.Ramdisk.Exclude_static_libs)
892 }
Yifan Hong6da33c22020-10-27 15:01:21 -0700893 if ctx.inVendorRamdisk() {
894 deps.WholeStaticLibs = removeListFromList(deps.WholeStaticLibs, library.baseLinker.Properties.Target.Vendor_ramdisk.Exclude_static_libs)
895 deps.SharedLibs = removeListFromList(deps.SharedLibs, library.baseLinker.Properties.Target.Vendor_ramdisk.Exclude_shared_libs)
896 deps.StaticLibs = removeListFromList(deps.StaticLibs, library.baseLinker.Properties.Target.Vendor_ramdisk.Exclude_static_libs)
897 deps.ReexportSharedLibHeaders = removeListFromList(deps.ReexportSharedLibHeaders, library.baseLinker.Properties.Target.Vendor_ramdisk.Exclude_shared_libs)
898 deps.ReexportStaticLibHeaders = removeListFromList(deps.ReexportStaticLibHeaders, library.baseLinker.Properties.Target.Vendor_ramdisk.Exclude_static_libs)
899 }
Colin Cross2383f3b2018-02-06 14:40:13 -0800900
Colin Cross4d9c2d12016-07-29 12:48:20 -0700901 return deps
902}
903
Paul Duffin13f02712020-03-06 12:30:43 +0000904func (library *libraryDecorator) linkerSpecifiedDeps(specifiedDeps specifiedDeps) specifiedDeps {
905 specifiedDeps = library.baseLinker.linkerSpecifiedDeps(specifiedDeps)
906 var properties StaticOrSharedProperties
907 if library.static() {
908 properties = library.StaticProperties.Static
909 } else if library.shared() {
910 properties = library.SharedProperties.Shared
911 }
912
913 specifiedDeps.sharedLibs = append(specifiedDeps.sharedLibs, properties.Shared_libs...)
Martin Stjernholm10566a02020-03-24 01:19:52 +0000914
915 // Must distinguish nil and [] in system_shared_libs - ensure that [] in
916 // either input list doesn't come out as nil.
917 if specifiedDeps.systemSharedLibs == nil {
918 specifiedDeps.systemSharedLibs = properties.System_shared_libs
919 } else {
920 specifiedDeps.systemSharedLibs = append(specifiedDeps.systemSharedLibs, properties.System_shared_libs...)
921 }
Paul Duffin13f02712020-03-06 12:30:43 +0000922
923 specifiedDeps.sharedLibs = android.FirstUniqueStrings(specifiedDeps.sharedLibs)
Martin Stjernholm10566a02020-03-24 01:19:52 +0000924 if len(specifiedDeps.systemSharedLibs) > 0 {
925 // Skip this if systemSharedLibs is either nil or [], to ensure they are
926 // retained.
927 specifiedDeps.systemSharedLibs = android.FirstUniqueStrings(specifiedDeps.systemSharedLibs)
928 }
Paul Duffin13f02712020-03-06 12:30:43 +0000929 return specifiedDeps
930}
931
Colin Cross4a9e6ec2023-12-18 15:29:41 -0800932func (library *libraryDecorator) moduleInfoJSON(ctx ModuleContext, moduleInfoJSON *android.ModuleInfoJSON) {
933 if library.static() {
934 moduleInfoJSON.Class = []string{"STATIC_LIBRARIES"}
935 moduleInfoJSON.Uninstallable = true
936 } else if library.shared() {
937 moduleInfoJSON.Class = []string{"SHARED_LIBRARIES"}
938 } else if library.header() {
939 moduleInfoJSON.Class = []string{"HEADER_LIBRARIES"}
940 moduleInfoJSON.Uninstallable = true
941 }
942
943 if library.buildStubs() && library.stubsVersion() != "" {
944 moduleInfoJSON.SubName += "." + library.stubsVersion()
945 }
946
947 // If a library providing a stub is included in an APEX, the private APIs of the library
948 // is accessible only inside the APEX. From outside of the APEX, clients can only use the
949 // public APIs via the stub. To enforce this, the (latest version of the) stub gets the
950 // name of the library. The impl library instead gets the `.bootstrap` suffix to so that
951 // they can be exceptionally used directly when APEXes are not available (e.g. during the
952 // very early stage in the boot process).
953 if len(library.Properties.Stubs.Versions) > 0 && !ctx.Host() && ctx.notInPlatform() &&
954 !ctx.inRamdisk() && !ctx.inVendorRamdisk() && !ctx.inRecovery() && !ctx.useVndk() && !ctx.static() {
955 if library.buildStubs() && library.isLatestStubVersion() {
956 moduleInfoJSON.SubName = ""
957 }
958 if !library.buildStubs() {
959 moduleInfoJSON.SubName = ".bootstrap"
960 }
961 }
962
963 library.baseLinker.moduleInfoJSON(ctx, moduleInfoJSON)
964}
965
Colin Crossb916a382016-07-29 17:28:03 -0700966func (library *libraryDecorator) linkStatic(ctx ModuleContext,
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700967 flags Flags, deps PathDeps, objs Objects) android.Path {
Colin Cross4d9c2d12016-07-29 12:48:20 -0700968
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700969 library.objects = deps.WholeStaticLibObjs.Copy()
970 library.objects = library.objects.Append(objs)
Colin Crossa2bcf2c2022-02-11 13:11:55 -0800971 library.wholeStaticLibsFromPrebuilts = android.CopyOfPaths(deps.WholeStaticLibsFromPrebuilts)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700972
Inseob Kim0ce291e2019-07-04 14:38:27 +0900973 fileName := ctx.ModuleName() + staticLibraryExtension
Colin Cross86803cf2018-02-15 14:12:26 -0800974 outputFile := android.PathForModuleOut(ctx, fileName)
Dan Willemsen581341d2017-02-09 16:16:31 -0800975 builderFlags := flagsToBuilderFlags(flags)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700976
Dan Willemsen569edc52018-11-19 09:33:29 -0800977 if Bool(library.baseLinker.Properties.Use_version_lib) {
978 if ctx.Host() {
979 versionedOutputFile := outputFile
980 outputFile = android.PathForModuleOut(ctx, "unversioned", fileName)
981 library.injectVersionSymbol(ctx, outputFile, versionedOutputFile)
982 } else {
983 versionedOutputFile := android.PathForModuleOut(ctx, "versioned", fileName)
Jingwen Chen40fd90a2020-06-15 05:24:19 +0000984 library.distFile = versionedOutputFile
Dan Willemsen569edc52018-11-19 09:33:29 -0800985 library.injectVersionSymbol(ctx, outputFile, versionedOutputFile)
986 }
Colin Cross86803cf2018-02-15 14:12:26 -0800987 }
988
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800989 transformObjToStaticLib(ctx, library.objects.objFiles, deps.WholeStaticLibsFromPrebuilts, builderFlags, outputFile, nil, objs.tidyDepFiles)
Dan Willemsen581341d2017-02-09 16:16:31 -0800990
Chris Parsonsbf4f55f2020-11-23 17:02:44 -0500991 library.coverageOutputFile = transformCoverageFilesToZip(ctx, library.objects, ctx.ModuleName())
Colin Cross4d9c2d12016-07-29 12:48:20 -0700992
Colin Cross4d9c2d12016-07-29 12:48:20 -0700993 ctx.CheckbuildFile(outputFile)
994
Colin Cross649d8172020-12-10 12:30:21 -0800995 if library.static() {
Colin Cross40213022023-12-13 15:19:49 -0800996 android.SetProvider(ctx, StaticLibraryInfoProvider, StaticLibraryInfo{
Colin Crossa2bcf2c2022-02-11 13:11:55 -0800997 StaticLibrary: outputFile,
998 ReuseObjects: library.reuseObjects,
999 Objects: library.objects,
1000 WholeStaticLibsFromPrebuilts: library.wholeStaticLibsFromPrebuilts,
Colin Cross0de8a1e2020-09-18 14:15:30 -07001001
Colin Crossc85750b2022-04-21 12:50:51 -07001002 TransitiveStaticLibrariesForOrdering: android.NewDepSetBuilder[android.Path](android.TOPOLOGICAL).
Colin Cross649d8172020-12-10 12:30:21 -08001003 Direct(outputFile).
1004 Transitive(deps.TranstiveStaticLibrariesForOrdering).
1005 Build(),
1006 })
1007 }
1008
1009 if library.header() {
Colin Cross40213022023-12-13 15:19:49 -08001010 android.SetProvider(ctx, HeaderLibraryInfoProvider, HeaderLibraryInfo{})
Colin Cross649d8172020-12-10 12:30:21 -08001011 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07001012
Colin Cross4d9c2d12016-07-29 12:48:20 -07001013 return outputFile
1014}
1015
Chih-Hung Hsiehf6ca1b92021-12-05 18:02:50 -08001016func ndkSharedLibDeps(ctx ModuleContext) android.Paths {
1017 if ctx.Module().(*Module).IsSdkVariant() {
1018 // The NDK sysroot timestamp file depends on all the NDK
1019 // sysroot header and shared library files.
1020 return android.Paths{getNdkBaseTimestampFile(ctx)}
1021 }
1022 return nil
1023}
1024
Colin Crossb916a382016-07-29 17:28:03 -07001025func (library *libraryDecorator) linkShared(ctx ModuleContext,
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001026 flags Flags, deps PathDeps, objs Objects) android.Path {
Colin Cross4d9c2d12016-07-29 12:48:20 -07001027
1028 var linkerDeps android.Paths
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001029 linkerDeps = append(linkerDeps, flags.LdFlagsDeps...)
Chih-Hung Hsiehf6ca1b92021-12-05 18:02:50 -08001030 linkerDeps = append(linkerDeps, ndkSharedLibDeps(ctx)...)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001031
Colin Cross2383f3b2018-02-06 14:40:13 -08001032 unexportedSymbols := ctx.ExpandOptionalSource(library.Properties.Unexported_symbols_list, "unexported_symbols_list")
1033 forceNotWeakSymbols := ctx.ExpandOptionalSource(library.Properties.Force_symbols_not_weak_list, "force_symbols_not_weak_list")
1034 forceWeakSymbols := ctx.ExpandOptionalSource(library.Properties.Force_symbols_weak_list, "force_symbols_weak_list")
Colin Cross4d9c2d12016-07-29 12:48:20 -07001035 if !ctx.Darwin() {
Colin Cross4d9c2d12016-07-29 12:48:20 -07001036 if unexportedSymbols.Valid() {
1037 ctx.PropertyErrorf("unexported_symbols_list", "Only supported on Darwin")
1038 }
1039 if forceNotWeakSymbols.Valid() {
1040 ctx.PropertyErrorf("force_symbols_not_weak_list", "Only supported on Darwin")
1041 }
1042 if forceWeakSymbols.Valid() {
1043 ctx.PropertyErrorf("force_symbols_weak_list", "Only supported on Darwin")
1044 }
1045 } else {
Colin Cross4d9c2d12016-07-29 12:48:20 -07001046 if unexportedSymbols.Valid() {
Colin Cross4af21ed2019-11-04 09:37:55 -08001047 flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,-unexported_symbols_list,"+unexportedSymbols.String())
Colin Cross4d9c2d12016-07-29 12:48:20 -07001048 linkerDeps = append(linkerDeps, unexportedSymbols.Path())
1049 }
1050 if forceNotWeakSymbols.Valid() {
Colin Cross4af21ed2019-11-04 09:37:55 -08001051 flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,-force_symbols_not_weak_list,"+forceNotWeakSymbols.String())
Colin Cross4d9c2d12016-07-29 12:48:20 -07001052 linkerDeps = append(linkerDeps, forceNotWeakSymbols.Path())
1053 }
1054 if forceWeakSymbols.Valid() {
Colin Cross4af21ed2019-11-04 09:37:55 -08001055 flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,-force_symbols_weak_list,"+forceWeakSymbols.String())
Colin Cross4d9c2d12016-07-29 12:48:20 -07001056 linkerDeps = append(linkerDeps, forceWeakSymbols.Path())
1057 }
1058 }
Colin Cross8e21aa52020-09-28 18:28:02 -07001059 if library.versionScriptPath.Valid() {
Jiyong Parkc1e7f482019-01-12 13:39:10 +09001060 linkerScriptFlags := "-Wl,--version-script," + library.versionScriptPath.String()
Colin Cross4af21ed2019-11-04 09:37:55 -08001061 flags.Local.LdFlags = append(flags.Local.LdFlags, linkerScriptFlags)
Colin Cross8e21aa52020-09-28 18:28:02 -07001062 linkerDeps = append(linkerDeps, library.versionScriptPath.Path())
Jiyong Parkc1e7f482019-01-12 13:39:10 +09001063 }
Colin Cross4d9c2d12016-07-29 12:48:20 -07001064
1065 fileName := library.getLibName(ctx) + flags.Toolchain.ShlibSuffix()
1066 outputFile := android.PathForModuleOut(ctx, fileName)
Colin Cross0de8a1e2020-09-18 14:15:30 -07001067 unstrippedOutputFile := outputFile
Colin Cross4d9c2d12016-07-29 12:48:20 -07001068
Josh Gao75a50a22019-06-07 17:58:59 -07001069 var implicitOutputs android.WritablePaths
1070 if ctx.Windows() {
1071 importLibraryPath := android.PathForModuleOut(ctx, pathtools.ReplaceExtension(fileName, "lib"))
1072
Colin Cross4af21ed2019-11-04 09:37:55 -08001073 flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,--out-implib="+importLibraryPath.String())
Josh Gao75a50a22019-06-07 17:58:59 -07001074 implicitOutputs = append(implicitOutputs, importLibraryPath)
1075 }
1076
Colin Cross4d9c2d12016-07-29 12:48:20 -07001077 builderFlags := flagsToBuilderFlags(flags)
1078
Dan Willemsen47450072021-10-19 20:24:49 -07001079 if ctx.Darwin() && deps.DarwinSecondArchOutput.Valid() {
1080 fatOutputFile := outputFile
1081 outputFile = android.PathForModuleOut(ctx, "pre-fat", fileName)
1082 transformDarwinUniversalBinary(ctx, fatOutputFile, outputFile, deps.DarwinSecondArchOutput.Path())
1083 }
1084
Colin Crossb496cfd2018-09-10 16:50:05 -07001085 // Optimize out relinking against shared libraries whose interface hasn't changed by
1086 // depending on a table of contents file instead of the library itself.
Colin Cross70dda7e2019-10-01 22:05:35 -07001087 tocFile := outputFile.ReplaceExtension(ctx, flags.Toolchain.ShlibSuffix()[1:]+".toc")
Colin Crossb496cfd2018-09-10 16:50:05 -07001088 library.tocFile = android.OptionalPathForPath(tocFile)
Ivan Lozano7b0781d2021-11-03 15:30:18 -04001089 TransformSharedObjectToToc(ctx, outputFile, tocFile)
Colin Cross89562dc2016-10-03 17:47:19 -07001090
Thiébaud Weksteend4587452020-08-19 14:53:01 +02001091 stripFlags := flagsToStripFlags(flags)
Colin Crossadc81a02020-12-14 17:01:55 -08001092 needsStrip := library.stripper.NeedsStrip(ctx)
1093 if library.buildStubs() {
1094 // No need to strip stubs libraries
1095 needsStrip = false
1096 }
1097 if needsStrip {
Yi Kongb5c34d72018-11-07 16:28:49 -08001098 if ctx.Darwin() {
Thiébaud Weksteend4587452020-08-19 14:53:01 +02001099 stripFlags.StripUseGnuStrip = true
Yi Kongb5c34d72018-11-07 16:28:49 -08001100 }
Colin Cross4d9c2d12016-07-29 12:48:20 -07001101 strippedOutputFile := outputFile
1102 outputFile = android.PathForModuleOut(ctx, "unstripped", fileName)
Thiébaud Weksteend4587452020-08-19 14:53:01 +02001103 library.stripper.StripExecutableOrSharedLib(ctx, outputFile, strippedOutputFile, stripFlags)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001104 }
Colin Crossb60190a2018-09-04 16:28:17 -07001105 library.unstrippedOutputFile = outputFile
1106
Colin Crossd7227f92019-09-05 14:26:33 -07001107 outputFile = maybeInjectBoringSSLHash(ctx, outputFile, library.Properties.Inject_bssl_hash, fileName)
Pete Bentley803e1612019-08-06 22:19:59 +01001108
Dan Willemsen569edc52018-11-19 09:33:29 -08001109 if Bool(library.baseLinker.Properties.Use_version_lib) {
1110 if ctx.Host() {
1111 versionedOutputFile := outputFile
1112 outputFile = android.PathForModuleOut(ctx, "unversioned", fileName)
1113 library.injectVersionSymbol(ctx, outputFile, versionedOutputFile)
1114 } else {
1115 versionedOutputFile := android.PathForModuleOut(ctx, "versioned", fileName)
Jingwen Chen40fd90a2020-06-15 05:24:19 +00001116 library.distFile = versionedOutputFile
Dan Willemsen569edc52018-11-19 09:33:29 -08001117
Thiébaud Weksteend4587452020-08-19 14:53:01 +02001118 if library.stripper.NeedsStrip(ctx) {
Dan Willemsen569edc52018-11-19 09:33:29 -08001119 out := android.PathForModuleOut(ctx, "versioned-stripped", fileName)
Jingwen Chen40fd90a2020-06-15 05:24:19 +00001120 library.distFile = out
Thiébaud Weksteend4587452020-08-19 14:53:01 +02001121 library.stripper.StripExecutableOrSharedLib(ctx, versionedOutputFile, out, stripFlags)
Dan Willemsen569edc52018-11-19 09:33:29 -08001122 }
1123
1124 library.injectVersionSymbol(ctx, outputFile, versionedOutputFile)
1125 }
Colin Cross86803cf2018-02-15 14:12:26 -08001126 }
1127
Wei Li5f5d2712023-12-11 15:40:29 -08001128 // Generate an output file for dist as if strip: "all" is set on the module.
1129 // Currently this is for layoutlib release process only.
1130 for _, dist := range ctx.Module().(*Module).Dists() {
1131 if dist.Tag != nil && *dist.Tag == "stripped_all" {
1132 strippedAllOutputFile := android.PathForModuleOut(ctx, "stripped_all", fileName)
1133 transformStrip(ctx, outputFile, strippedAllOutputFile, StripFlags{Toolchain: flags.Toolchain})
1134 library.strippedAllOutputFile = strippedAllOutputFile
1135 break
1136 }
1137 }
1138
Jiyong Park64a44f22019-01-18 14:37:08 +09001139 sharedLibs := deps.EarlySharedLibs
1140 sharedLibs = append(sharedLibs, deps.SharedLibs...)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001141 sharedLibs = append(sharedLibs, deps.LateSharedLibs...)
1142
Jiyong Park64a44f22019-01-18 14:37:08 +09001143 linkerDeps = append(linkerDeps, deps.EarlySharedLibsDeps...)
Colin Cross26c34ed2016-09-30 17:10:16 -07001144 linkerDeps = append(linkerDeps, deps.SharedLibsDeps...)
1145 linkerDeps = append(linkerDeps, deps.LateSharedLibsDeps...)
Chris Parsonsbf4f55f2020-11-23 17:02:44 -05001146 transformObjToDynamicBinary(ctx, objs.objFiles, sharedLibs,
Colin Cross4d9c2d12016-07-29 12:48:20 -07001147 deps.StaticLibs, deps.LateStaticLibs, deps.WholeStaticLibs,
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -08001148 linkerDeps, deps.CrtBegin, deps.CrtEnd, false, builderFlags, outputFile, implicitOutputs, objs.tidyDepFiles)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001149
Dan Willemsen581341d2017-02-09 16:16:31 -08001150 objs.coverageFiles = append(objs.coverageFiles, deps.StaticLibObjs.coverageFiles...)
1151 objs.coverageFiles = append(objs.coverageFiles, deps.WholeStaticLibObjs.coverageFiles...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001152 objs.sAbiDumpFiles = append(objs.sAbiDumpFiles, deps.StaticLibObjs.sAbiDumpFiles...)
1153 objs.sAbiDumpFiles = append(objs.sAbiDumpFiles, deps.WholeStaticLibObjs.sAbiDumpFiles...)
1154
Chris Parsonsbf4f55f2020-11-23 17:02:44 -05001155 library.coverageOutputFile = transformCoverageFilesToZip(ctx, objs, library.getLibName(ctx))
Colin Cross0de8a1e2020-09-18 14:15:30 -07001156 library.linkSAbiDumpFiles(ctx, objs, fileName, unstrippedOutputFile)
Dan Willemsen581341d2017-02-09 16:16:31 -08001157
Colin Crossc85750b2022-04-21 12:50:51 -07001158 var transitiveStaticLibrariesForOrdering *android.DepSet[android.Path]
Colin Cross0de8a1e2020-09-18 14:15:30 -07001159 if static := ctx.GetDirectDepsWithTag(staticVariantTag); len(static) > 0 {
Colin Cross313aa542023-12-13 13:47:44 -08001160 s, _ := android.OtherModuleProvider(ctx, static[0], StaticLibraryInfoProvider)
Liz Kammeref6dfea2021-06-08 15:37:09 -04001161 transitiveStaticLibrariesForOrdering = s.TransitiveStaticLibrariesForOrdering
Colin Cross0de8a1e2020-09-18 14:15:30 -07001162 }
1163
Colin Cross40213022023-12-13 15:19:49 -08001164 android.SetProvider(ctx, SharedLibraryInfoProvider, SharedLibraryInfo{
Liz Kammeref6dfea2021-06-08 15:37:09 -04001165 TableOfContents: android.OptionalPathForPath(tocFile),
1166 SharedLibrary: unstrippedOutputFile,
1167 TransitiveStaticLibrariesForOrdering: transitiveStaticLibrariesForOrdering,
1168 Target: ctx.Target(),
Colin Cross0de8a1e2020-09-18 14:15:30 -07001169 })
1170
Sam Delmerico75dbca22023-04-20 13:13:25 +00001171 addStubDependencyProviders(ctx)
1172
1173 return unstrippedOutputFile
1174}
1175
1176func addStubDependencyProviders(ctx ModuleContext) {
Colin Cross0de8a1e2020-09-18 14:15:30 -07001177 stubs := ctx.GetDirectDepsWithTag(stubImplDepTag)
1178 if len(stubs) > 0 {
Chris Parsons3c27ca32020-11-20 12:42:07 -05001179 var stubsInfo []SharedStubLibrary
Colin Cross0de8a1e2020-09-18 14:15:30 -07001180 for _, stub := range stubs {
Colin Cross313aa542023-12-13 13:47:44 -08001181 stubInfo, _ := android.OtherModuleProvider(ctx, stub, SharedLibraryInfoProvider)
1182 flagInfo, _ := android.OtherModuleProvider(ctx, stub, FlagExporterInfoProvider)
Chris Parsons3c27ca32020-11-20 12:42:07 -05001183 stubsInfo = append(stubsInfo, SharedStubLibrary{
Colin Cross31076b32020-10-23 17:22:06 -07001184 Version: moduleLibraryInterface(stub).stubsVersion(),
Colin Cross0de8a1e2020-09-18 14:15:30 -07001185 SharedLibraryInfo: stubInfo,
1186 FlagExporterInfo: flagInfo,
1187 })
1188 }
Colin Cross40213022023-12-13 15:19:49 -08001189 android.SetProvider(ctx, SharedLibraryStubsProvider, SharedLibraryStubsInfo{
Chris Parsons3c27ca32020-11-20 12:42:07 -05001190 SharedStubLibraries: stubsInfo,
Sam Delmerico75dbca22023-04-20 13:13:25 +00001191 IsLLNDK: ctx.IsLlndk(),
Colin Cross0de8a1e2020-09-18 14:15:30 -07001192 })
1193 }
Colin Cross4d9c2d12016-07-29 12:48:20 -07001194}
1195
Jiyong Parkaf6d8952019-01-31 12:21:23 +09001196func (library *libraryDecorator) unstrippedOutputFilePath() android.Path {
1197 return library.unstrippedOutputFile
1198}
1199
Wei Li5f5d2712023-12-11 15:40:29 -08001200func (library *libraryDecorator) strippedAllOutputFilePath() android.Path {
1201 return library.strippedAllOutputFile
1202}
1203
Thiébaud Weksteend4587452020-08-19 14:53:01 +02001204func (library *libraryDecorator) disableStripping() {
1205 library.stripper.StripProperties.Strip.None = BoolPtr(true)
1206}
1207
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001208func (library *libraryDecorator) nativeCoverage() bool {
1209 if library.header() || library.buildStubs() {
1210 return false
1211 }
1212 return true
1213}
1214
Jiyong Parkee9a98d2019-08-09 14:44:36 +09001215func (library *libraryDecorator) coverageOutputFilePath() android.OptionalPath {
1216 return library.coverageOutputFile
1217}
1218
Hsin-Yi Chenaf369882024-03-29 20:10:36 +08001219func (library *libraryDecorator) exportedIncludeDirsForAbiCheck(ctx ModuleContext) []string {
1220 exportIncludeDirs := library.flagExporter.exportedIncludes(ctx).Strings()
1221 exportIncludeDirs = append(exportIncludeDirs, library.sabi.Properties.ReexportedIncludes...)
1222 return exportIncludeDirs
1223}
1224
Hsin-Yi Chen0af4e672022-11-23 14:39:46 +08001225func getRefAbiDumpFile(ctx android.ModuleInstallPathContext,
1226 versionedDumpDir, fileName string) android.OptionalPath {
Mu-Le Leef5ed30b2022-08-30 10:37:21 +00001227
1228 currentArchType := ctx.Arch().ArchType
1229 primaryArchType := ctx.Config().DevicePrimaryArchType()
1230 archName := currentArchType.String()
1231 if currentArchType != primaryArchType {
1232 archName += "_" + primaryArchType.String()
1233 }
1234
Hsin-Yi Chena6ddb142022-10-27 14:55:42 +08001235 return android.ExistentPathForSource(ctx, versionedDumpDir, archName, "source-based",
Hsin-Yi Chen0af4e672022-11-23 14:39:46 +08001236 fileName+".lsdump")
Mu-Le Leef5ed30b2022-08-30 10:37:21 +00001237}
1238
Hsin-Yi Chen2c4a9772024-02-05 17:37:27 +08001239// Return the previous and current SDK versions for cross-version ABI diff.
1240func crossVersionAbiDiffSdkVersions(ctx ModuleContext, dumpDir string) (string, string) {
Mu-Le Lee0a9005e2022-07-05 09:49:50 +00001241 sdkVersionInt := ctx.Config().PlatformSdkVersion().FinalInt()
1242 sdkVersionStr := ctx.Config().PlatformSdkVersion().String()
1243
1244 if ctx.Config().PlatformSdkFinal() {
Hsin-Yi Chen2c4a9772024-02-05 17:37:27 +08001245 return strconv.Itoa(sdkVersionInt - 1), sdkVersionStr
Mu-Le Lee0a9005e2022-07-05 09:49:50 +00001246 } else {
Mu-Le Lee0a9005e2022-07-05 09:49:50 +00001247 // The platform SDK version can be upgraded before finalization while the corresponding abi dumps hasn't
1248 // been generated. Thus the Cross-Version Check chooses PLATFORM_SDK_VERION - 1 as previous version.
1249 // This situation could be identified by checking the existence of the PLATFORM_SDK_VERION dump directory.
Hsin-Yi Chena6ddb142022-10-27 14:55:42 +08001250 versionedDumpDir := android.ExistentPathForSource(ctx, dumpDir, sdkVersionStr)
1251 if versionedDumpDir.Valid() {
Hsin-Yi Chen2c4a9772024-02-05 17:37:27 +08001252 return sdkVersionStr, strconv.Itoa(sdkVersionInt + 1)
Mu-Le Lee0a9005e2022-07-05 09:49:50 +00001253 } else {
Hsin-Yi Chen2c4a9772024-02-05 17:37:27 +08001254 return strconv.Itoa(sdkVersionInt - 1), sdkVersionStr
Mu-Le Lee0a9005e2022-07-05 09:49:50 +00001255 }
1256 }
1257}
1258
Hsin-Yi Chen2c4a9772024-02-05 17:37:27 +08001259// Return the SDK version for same-version ABI diff.
1260func currRefAbiDumpSdkVersion(ctx ModuleContext) string {
Hsin-Yi Chen27bafd02024-01-08 18:38:42 +08001261 if ctx.Config().PlatformSdkFinal() {
Hsin-Yi Chena90bd382022-11-10 16:56:27 +08001262 // After sdk finalization, the ABI of the latest API level must be consistent with the source code,
1263 // so choose PLATFORM_SDK_VERSION as the current version.
1264 return ctx.Config().PlatformSdkVersion().String()
1265 } else {
1266 return "current"
1267 }
1268}
1269
Hsin-Yi Chena6ddb142022-10-27 14:55:42 +08001270// sourceAbiDiff registers a build statement to compare linked sAbi dump files (.lsdump).
Hsin-Yi Chenaf369882024-03-29 20:10:36 +08001271func (library *libraryDecorator) sourceAbiDiff(ctx android.ModuleContext,
1272 sourceDump, referenceDump android.Path,
Hsin-Yi Chena6ddb142022-10-27 14:55:42 +08001273 baseName, nameExt string, isLlndkOrNdk, allowExtensions bool,
1274 sourceVersion, errorMessage string) {
1275
Hsin-Yi Chena6ddb142022-10-27 14:55:42 +08001276 extraFlags := []string{"-target-version", sourceVersion}
Hsin-Yi Chen8feb4132022-12-26 15:54:36 +08001277 headerAbiChecker := library.getHeaderAbiCheckerProperties(ctx)
1278 if Bool(headerAbiChecker.Check_all_apis) {
Hsin-Yi Chena6ddb142022-10-27 14:55:42 +08001279 extraFlags = append(extraFlags, "-check-all-apis")
1280 } else {
1281 extraFlags = append(extraFlags,
1282 "-allow-unreferenced-changes",
1283 "-allow-unreferenced-elf-symbol-changes")
1284 }
1285 if isLlndkOrNdk {
1286 extraFlags = append(extraFlags, "-consider-opaque-types-different")
1287 }
1288 if allowExtensions {
1289 extraFlags = append(extraFlags, "-allow-extensions")
1290 }
Hsin-Yi Chen8feb4132022-12-26 15:54:36 +08001291 extraFlags = append(extraFlags, headerAbiChecker.Diff_flags...)
Hsin-Yi Chena6ddb142022-10-27 14:55:42 +08001292
1293 library.sAbiDiff = append(
1294 library.sAbiDiff,
1295 transformAbiDumpToAbiDiff(ctx, sourceDump, referenceDump,
1296 baseName, nameExt, extraFlags, errorMessage))
1297}
1298
Hsin-Yi Chenaf369882024-03-29 20:10:36 +08001299func (library *libraryDecorator) crossVersionAbiDiff(ctx android.ModuleContext,
1300 sourceDump, referenceDump android.Path,
Hsin-Yi Chena6ddb142022-10-27 14:55:42 +08001301 baseName string, isLlndkOrNdk bool, sourceVersion, prevVersion string) {
1302
Elliott Hughes10363162024-01-09 22:02:03 +00001303 errorMessage := "error: Please follow https://android.googlesource.com/platform/development/+/main/vndk/tools/header-checker/README.md#configure-cross_version-abi-check to resolve the ABI difference between your source code and version " + prevVersion + "."
Hsin-Yi Chena6ddb142022-10-27 14:55:42 +08001304
Hsin-Yi Chenaf369882024-03-29 20:10:36 +08001305 library.sourceAbiDiff(ctx, sourceDump, referenceDump, baseName, prevVersion,
Sasha Smundak39a301c2022-12-29 17:11:49 -08001306 isLlndkOrNdk, true /* allowExtensions */, sourceVersion, errorMessage)
Hsin-Yi Chena6ddb142022-10-27 14:55:42 +08001307}
1308
Hsin-Yi Chenaf369882024-03-29 20:10:36 +08001309func (library *libraryDecorator) sameVersionAbiDiff(ctx android.ModuleContext,
1310 sourceDump, referenceDump android.Path,
Hsin-Yi Chen362c1882024-02-06 15:43:17 +08001311 baseName, nameExt string, isLlndkOrNdk bool) {
Hsin-Yi Chena6ddb142022-10-27 14:55:42 +08001312
1313 libName := strings.TrimSuffix(baseName, filepath.Ext(baseName))
1314 errorMessage := "error: Please update ABI references with: $$ANDROID_BUILD_TOP/development/vndk/tools/header-checker/utils/create_reference_dumps.py -l " + libName
1315
Hsin-Yi Chenaf369882024-03-29 20:10:36 +08001316 library.sourceAbiDiff(ctx, sourceDump, referenceDump, baseName, nameExt,
Hsin-Yi Chen27bafd02024-01-08 18:38:42 +08001317 isLlndkOrNdk, false /* allowExtensions */, "current", errorMessage)
Hsin-Yi Chena6ddb142022-10-27 14:55:42 +08001318}
1319
Hsin-Yi Chenaf369882024-03-29 20:10:36 +08001320func (library *libraryDecorator) optInAbiDiff(ctx android.ModuleContext,
1321 sourceDump, referenceDump android.Path,
Hsin-Yi Chen362c1882024-02-06 15:43:17 +08001322 baseName, nameExt string, refDumpDir string) {
Hsin-Yi Chenf3630122022-11-17 14:29:43 +08001323
1324 libName := strings.TrimSuffix(baseName, filepath.Ext(baseName))
1325 errorMessage := "error: Please update ABI references with: $$ANDROID_BUILD_TOP/development/vndk/tools/header-checker/utils/create_reference_dumps.py -l " + libName + " -ref-dump-dir $$ANDROID_BUILD_TOP/" + refDumpDir
Hsin-Yi Chen8b85d812023-06-29 16:51:27 +08001326 // Most opt-in libraries do not have dumps for all default architectures.
1327 if ctx.Config().HasDeviceProduct() {
1328 errorMessage += " -products " + ctx.Config().DeviceProduct()
1329 }
Hsin-Yi Chenf3630122022-11-17 14:29:43 +08001330
Hsin-Yi Chenaf369882024-03-29 20:10:36 +08001331 library.sourceAbiDiff(ctx, sourceDump, referenceDump, baseName, nameExt,
Hsin-Yi Chen362c1882024-02-06 15:43:17 +08001332 false /* isLlndkOrNdk */, false /* allowExtensions */, "current", errorMessage)
Hsin-Yi Chenf3630122022-11-17 14:29:43 +08001333}
1334
Jayant Chowdhary6ab3d842017-06-26 12:52:58 -07001335func (library *libraryDecorator) linkSAbiDumpFiles(ctx ModuleContext, objs Objects, fileName string, soFile android.Path) {
Yo Chiang2bbadfa2020-12-14 11:42:16 +08001336 if library.sabi.shouldCreateSourceAbiDump() {
Hsin-Yi Chenaf369882024-03-29 20:10:36 +08001337 exportedIncludeDirs := library.exportedIncludeDirsForAbiCheck(ctx)
Hsin-Yi Chen8feb4132022-12-26 15:54:36 +08001338 headerAbiChecker := library.getHeaderAbiCheckerProperties(ctx)
Hsin-Yi Chen2c4a9772024-02-05 17:37:27 +08001339 currSdkVersion := currRefAbiDumpSdkVersion(ctx)
1340 currVendorVersion := ctx.Config().VendorApiLevel()
Hsin-Yi Chenaf369882024-03-29 20:10:36 +08001341 sourceDump := transformDumpToLinkedDump(ctx,
1342 objs.sAbiDumpFiles, soFile, fileName,
1343 exportedIncludeDirs,
Hsin-Yi Chen843c0632023-09-25 15:26:30 +08001344 android.OptionalPathForModuleSrc(ctx, library.symbolFileForAbiCheck(ctx)),
1345 headerAbiChecker.Exclude_symbol_versions,
1346 headerAbiChecker.Exclude_symbol_tags,
Hsin-Yi Chen2c4a9772024-02-05 17:37:27 +08001347 currSdkVersion)
Hsin-Yi Chen843c0632023-09-25 15:26:30 +08001348
Hsin-Yi Chen50884dc2024-01-05 14:41:06 +08001349 for _, tag := range classifySourceAbiDump(ctx) {
Hsin-Yi Chenaf369882024-03-29 20:10:36 +08001350 addLsdumpPath(string(tag) + ":" + sourceDump.String())
Hsin-Yi Chen362c1882024-02-06 15:43:17 +08001351 dumpDirName := tag.dirName()
1352 if dumpDirName == "" {
1353 continue
1354 }
1355 dumpDir := filepath.Join("prebuilts", "abi-dumps", dumpDirName)
1356 isLlndk := (tag == llndkLsdumpTag)
1357 isNdk := (tag == ndkLsdumpTag)
1358 binderBitness := ctx.DeviceConfig().BinderBitness()
1359 nameExt := ""
1360 if isLlndk {
1361 nameExt = "llndk"
1362 }
1363 // Check against the previous version.
Hsin-Yi Chen2c4a9772024-02-05 17:37:27 +08001364 var prevVersion, currVersion string
1365 // If this release config does not define VendorApiLevel, fall back to the old policy.
1366 if isLlndk && currVendorVersion != "" {
1367 prevVersion = ctx.Config().PrevVendorApiLevel()
1368 currVersion = currVendorVersion
1369 } else {
1370 prevVersion, currVersion = crossVersionAbiDiffSdkVersions(ctx, dumpDir)
1371 }
Hsin-Yi Chen362c1882024-02-06 15:43:17 +08001372 prevDumpDir := filepath.Join(dumpDir, prevVersion, binderBitness)
1373 prevDumpFile := getRefAbiDumpFile(ctx, prevDumpDir, fileName)
1374 if prevDumpFile.Valid() {
Hsin-Yi Chenaf369882024-03-29 20:10:36 +08001375 library.crossVersionAbiDiff(ctx, sourceDump, prevDumpFile.Path(),
Hsin-Yi Chen2c4a9772024-02-05 17:37:27 +08001376 fileName, isLlndk || isNdk, currVersion, nameExt+prevVersion)
Hsin-Yi Chen362c1882024-02-06 15:43:17 +08001377 }
1378 // Check against the current version.
Hsin-Yi Chen2c4a9772024-02-05 17:37:27 +08001379 if isLlndk && currVendorVersion != "" {
1380 currVersion = currVendorVersion
1381 } else {
1382 currVersion = currSdkVersion
1383 }
Hsin-Yi Chen362c1882024-02-06 15:43:17 +08001384 currDumpDir := filepath.Join(dumpDir, currVersion, binderBitness)
1385 currDumpFile := getRefAbiDumpFile(ctx, currDumpDir, fileName)
1386 if currDumpFile.Valid() {
Hsin-Yi Chenaf369882024-03-29 20:10:36 +08001387 library.sameVersionAbiDiff(ctx, sourceDump, currDumpFile.Path(),
Hsin-Yi Chen362c1882024-02-06 15:43:17 +08001388 fileName, nameExt, isLlndk || isNdk)
1389 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001390 }
Hsin-Yi Chenf3630122022-11-17 14:29:43 +08001391 // Check against the opt-in reference dumps.
Hsin-Yi Chen8feb4132022-12-26 15:54:36 +08001392 for i, optInDumpDir := range headerAbiChecker.Ref_dump_dirs {
Hsin-Yi Chenf3630122022-11-17 14:29:43 +08001393 optInDumpDirPath := android.PathForModuleSrc(ctx, optInDumpDir)
1394 // Ref_dump_dirs are not versioned.
1395 // They do not contain subdir for binder bitness because 64-bit binder has been mandatory.
1396 optInDumpFile := getRefAbiDumpFile(ctx, optInDumpDirPath.String(), fileName)
1397 if !optInDumpFile.Valid() {
1398 continue
1399 }
Hsin-Yi Chenaf369882024-03-29 20:10:36 +08001400 library.optInAbiDiff(ctx,
1401 sourceDump, optInDumpFile.Path(),
Hsin-Yi Chen362c1882024-02-06 15:43:17 +08001402 fileName, "opt"+strconv.Itoa(i), optInDumpDirPath.String())
Hsin-Yi Chenf3630122022-11-17 14:29:43 +08001403 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001404 }
1405}
1406
Inseob Kimcc12d902021-05-14 20:15:55 +09001407func processLLNDKHeaders(ctx ModuleContext, srcHeaderDir string, outDir android.ModuleGenPath) (timestamp android.Path, installPaths android.WritablePaths) {
Colin Cross127bb8b2020-12-16 16:46:01 -08001408 srcDir := android.PathForModuleSrc(ctx, srcHeaderDir)
1409 srcFiles := ctx.GlobFiles(filepath.Join(srcDir.String(), "**/*.h"), nil)
1410
Colin Cross127bb8b2020-12-16 16:46:01 -08001411 for _, header := range srcFiles {
1412 headerDir := filepath.Dir(header.String())
1413 relHeaderDir, err := filepath.Rel(srcDir.String(), headerDir)
1414 if err != nil {
1415 ctx.ModuleErrorf("filepath.Rel(%q, %q) failed: %s",
1416 srcDir.String(), headerDir, err)
1417 continue
1418 }
1419
1420 installPaths = append(installPaths, outDir.Join(ctx, relHeaderDir, header.Base()))
1421 }
1422
Inseob Kimcc12d902021-05-14 20:15:55 +09001423 return processHeadersWithVersioner(ctx, srcDir, outDir, srcFiles, installPaths), installPaths
Colin Cross127bb8b2020-12-16 16:46:01 -08001424}
1425
Chris Parsons3c27ca32020-11-20 12:42:07 -05001426// link registers actions to link this library, and sets various fields
1427// on this library to reflect information that should be exported up the build
1428// tree (for example, exported flags and include paths).
Colin Crossb916a382016-07-29 17:28:03 -07001429func (library *libraryDecorator) link(ctx ModuleContext,
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001430 flags Flags, deps PathDeps, objs Objects) android.Path {
Colin Cross4d9c2d12016-07-29 12:48:20 -07001431
Colin Cross127bb8b2020-12-16 16:46:01 -08001432 if ctx.IsLlndk() {
1433 if len(library.Properties.Llndk.Export_preprocessed_headers) > 0 {
1434 // This is the vendor variant of an LLNDK library with preprocessed headers.
1435 genHeaderOutDir := android.PathForModuleGen(ctx, "include")
1436
1437 var timestampFiles android.Paths
1438 for _, dir := range library.Properties.Llndk.Export_preprocessed_headers {
Inseob Kimcc12d902021-05-14 20:15:55 +09001439 timestampFile, installPaths := processLLNDKHeaders(ctx, dir, genHeaderOutDir)
1440 timestampFiles = append(timestampFiles, timestampFile)
1441 library.addExportedGeneratedHeaders(installPaths.Paths()...)
Colin Cross127bb8b2020-12-16 16:46:01 -08001442 }
1443
1444 if Bool(library.Properties.Llndk.Export_headers_as_system) {
1445 library.reexportSystemDirs(genHeaderOutDir)
1446 } else {
1447 library.reexportDirs(genHeaderOutDir)
1448 }
1449
1450 library.reexportDeps(timestampFiles...)
1451 }
1452
Colin Cross0fb7fcd2021-03-02 11:00:07 -08001453 // override the module's export_include_dirs with llndk.override_export_include_dirs
1454 // if it is set.
1455 if override := library.Properties.Llndk.Override_export_include_dirs; override != nil {
1456 library.flagExporter.Properties.Export_include_dirs = override
1457 }
1458
Colin Cross127bb8b2020-12-16 16:46:01 -08001459 if Bool(library.Properties.Llndk.Export_headers_as_system) {
1460 library.flagExporter.Properties.Export_system_include_dirs = append(
1461 library.flagExporter.Properties.Export_system_include_dirs,
1462 library.flagExporter.Properties.Export_include_dirs...)
1463 library.flagExporter.Properties.Export_include_dirs = nil
1464 }
1465 }
1466
Colin Cross5271fea2021-04-27 13:06:04 -07001467 if ctx.IsVendorPublicLibrary() {
1468 // override the module's export_include_dirs with vendor_public_library.override_export_include_dirs
1469 // if it is set.
1470 if override := library.Properties.Vendor_public_library.Override_export_include_dirs; override != nil {
1471 library.flagExporter.Properties.Export_include_dirs = override
1472 }
1473 }
1474
Chris Parsons3c27ca32020-11-20 12:42:07 -05001475 // Linking this library consists of linking `deps.Objs` (.o files in dependencies
1476 // of this library), together with `objs` (.o files created by compiling this
1477 // library).
Colin Crossad59e752017-11-16 14:29:11 -08001478 objs = deps.Objs.Copy().Append(objs)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001479 var out android.Path
Colin Crossa48ab5b2017-02-14 15:28:44 -08001480 if library.static() || library.header() {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001481 out = library.linkStatic(ctx, flags, deps, objs)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001482 } else {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001483 out = library.linkShared(ctx, flags, deps, objs)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001484 }
1485
Chris Parsons3c27ca32020-11-20 12:42:07 -05001486 // Export include paths and flags to be propagated up the tree.
Inseob Kim69378442019-06-03 19:10:47 +09001487 library.exportIncludes(ctx)
1488 library.reexportDirs(deps.ReexportedDirs...)
1489 library.reexportSystemDirs(deps.ReexportedSystemDirs...)
1490 library.reexportFlags(deps.ReexportedFlags...)
1491 library.reexportDeps(deps.ReexportedDeps...)
Inseob Kimd110f872019-12-06 13:15:38 +09001492 library.addExportedGeneratedHeaders(deps.ReexportedGeneratedHeaders...)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001493
Chris Parsons3c27ca32020-11-20 12:42:07 -05001494 // Optionally export aidl headers.
Nan Zhang0007d812017-11-07 10:57:05 -08001495 if Bool(library.Properties.Aidl.Export_aidl_headers) {
Vinh Tran367d89d2023-04-28 11:21:25 -04001496 if library.baseCompiler.hasAidl(deps) {
Vinh Tran09581952023-05-16 16:03:20 -04001497 if library.baseCompiler.hasSrcExt(".aidl") {
1498 dir := android.PathForModuleGen(ctx, "aidl")
1499 library.reexportDirs(dir)
1500 }
1501 if len(deps.AidlLibraryInfos) > 0 {
1502 dir := android.PathForModuleGen(ctx, "aidl_library")
1503 library.reexportDirs(dir)
1504 }
Inseob Kimd110f872019-12-06 13:15:38 +09001505
Paul Duffin33056e82021-02-19 13:49:08 +00001506 library.reexportDeps(library.baseCompiler.aidlOrderOnlyDeps...)
1507 library.addExportedGeneratedHeaders(library.baseCompiler.aidlHeaders...)
Dan Willemsene1240db2016-11-03 14:28:51 -07001508 }
1509 }
1510
Chris Parsons3c27ca32020-11-20 12:42:07 -05001511 // Optionally export proto headers.
Nan Zhang0007d812017-11-07 10:57:05 -08001512 if Bool(library.Properties.Proto.Export_proto_headers) {
Dan Willemsene1240db2016-11-03 14:28:51 -07001513 if library.baseCompiler.hasSrcExt(".proto") {
Jiyong Park74955042019-10-22 20:19:51 +09001514 var includes android.Paths
Colin Cross19878da2019-03-28 14:45:07 -07001515 if flags.proto.CanonicalPathFromRoot {
Jiyong Park74955042019-10-22 20:19:51 +09001516 includes = append(includes, flags.proto.SubDir)
Colin Cross10d22312017-05-03 11:01:58 -07001517 }
Jiyong Park74955042019-10-22 20:19:51 +09001518 includes = append(includes, flags.proto.Dir)
Inseob Kim69378442019-06-03 19:10:47 +09001519 library.reexportDirs(includes...)
Inseob Kimd110f872019-12-06 13:15:38 +09001520
Paul Duffin33056e82021-02-19 13:49:08 +00001521 library.reexportDeps(library.baseCompiler.protoOrderOnlyDeps...)
1522 library.addExportedGeneratedHeaders(library.baseCompiler.protoHeaders...)
Colin Cross0c461f12016-10-20 16:11:43 -07001523 }
1524 }
1525
Inseob Kim07def122020-11-23 14:43:02 +09001526 // If the library is sysprop_library, expose either public or internal header selectively.
Inseob Kim21f26902018-09-06 00:55:20 +09001527 if library.baseCompiler.hasSrcExt(".sysprop") {
Jiyong Park74955042019-10-22 20:19:51 +09001528 dir := android.PathForModuleGen(ctx, "sysprop", "include")
Inseob Kimc0907f12019-02-08 21:00:45 +09001529 if library.Properties.Sysprop.Platform != nil {
Inseob Kimc0907f12019-02-08 21:00:45 +09001530 isOwnerPlatform := Bool(library.Properties.Sysprop.Platform)
1531
Inseob Kim07def122020-11-23 14:43:02 +09001532 // If the owner is different from the user, expose public header. That is,
1533 // 1) if the user is product (as owner can only be platform / vendor)
Inseob Kim06410042021-01-18 15:23:28 +09001534 // 2) if the owner is platform and the client is vendor
1535 // We don't care Platform -> Vendor dependency as it's already forbidden.
1536 if ctx.Device() && (ctx.ProductSpecific() || (isOwnerPlatform && ctx.inVendor())) {
Jiyong Park74955042019-10-22 20:19:51 +09001537 dir = android.PathForModuleGen(ctx, "sysprop/public", "include")
Inseob Kimc0907f12019-02-08 21:00:45 +09001538 }
1539 }
1540
Paul Duffin37e0de52021-02-19 17:05:39 +00001541 // Make sure to only export headers which are within the include directory.
1542 _, headers := android.FilterPathListPredicate(library.baseCompiler.syspropHeaders, func(path android.Path) bool {
1543 _, isRel := android.MaybeRel(ctx, dir.String(), path.String())
1544 return isRel
1545 })
1546
Chris Parsons3c27ca32020-11-20 12:42:07 -05001547 // Add sysprop-related directories to the exported directories of this library.
Inseob Kim69378442019-06-03 19:10:47 +09001548 library.reexportDirs(dir)
Paul Duffin33056e82021-02-19 13:49:08 +00001549 library.reexportDeps(library.baseCompiler.syspropOrderOnlyDeps...)
Paul Duffin37e0de52021-02-19 17:05:39 +00001550 library.addExportedGeneratedHeaders(headers...)
Inseob Kim21f26902018-09-06 00:55:20 +09001551 }
1552
Chris Parsons3c27ca32020-11-20 12:42:07 -05001553 // Add stub-related flags if this library is a stub library.
Jiyong Park892a98f2020-12-14 09:20:00 +09001554 library.exportVersioningMacroIfNeeded(ctx)
Jiyong Parkda732bd2018-11-02 18:23:15 +09001555
Chris Parsons3c27ca32020-11-20 12:42:07 -05001556 // Propagate a Provider containing information about exported flags, deps, and include paths.
Colin Cross0de8a1e2020-09-18 14:15:30 -07001557 library.flagExporter.setProvider(ctx)
1558
Colin Cross4d9c2d12016-07-29 12:48:20 -07001559 return out
1560}
1561
Jiyong Park892a98f2020-12-14 09:20:00 +09001562func (library *libraryDecorator) exportVersioningMacroIfNeeded(ctx android.BaseModuleContext) {
Colin Cross127bb8b2020-12-16 16:46:01 -08001563 if library.buildStubs() && library.stubsVersion() != "" && !library.skipAPIDefine {
Jiyong Park892a98f2020-12-14 09:20:00 +09001564 name := versioningMacroName(ctx.Module().(*Module).ImplementationModuleName(ctx))
Jooyung Han11b0fbd2021-02-05 02:28:22 +09001565 apiLevel, err := android.ApiLevelFromUser(ctx, library.stubsVersion())
1566 if err != nil {
1567 ctx.ModuleErrorf("Can't export version macro: %s", err.Error())
1568 }
1569 library.reexportFlags("-D" + name + "=" + strconv.Itoa(apiLevel.FinalOrPreviewInt()))
Jiyong Park892a98f2020-12-14 09:20:00 +09001570 }
1571}
1572
Chris Parsons3c27ca32020-11-20 12:42:07 -05001573// buildStatic returns true if this library should be built as a static library.
Colin Crossb916a382016-07-29 17:28:03 -07001574func (library *libraryDecorator) buildStatic() bool {
Colin Crosse1bb5d02019-09-24 14:55:04 -07001575 return library.MutatedProperties.BuildStatic &&
1576 BoolDefault(library.StaticProperties.Static.Enabled, true)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001577}
1578
Chris Parsons3c27ca32020-11-20 12:42:07 -05001579// buildShared returns true if this library should be built as a shared library.
Colin Crossb916a382016-07-29 17:28:03 -07001580func (library *libraryDecorator) buildShared() bool {
Colin Crosse1bb5d02019-09-24 14:55:04 -07001581 return library.MutatedProperties.BuildShared &&
1582 BoolDefault(library.SharedProperties.Shared.Enabled, true)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001583}
1584
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001585func (library *libraryDecorator) objs() Objects {
1586 return library.objects
Colin Cross4d9c2d12016-07-29 12:48:20 -07001587}
1588
Colin Cross0de8a1e2020-09-18 14:15:30 -07001589func (library *libraryDecorator) reuseObjs() Objects {
1590 return library.reuseObjects
Colin Cross4d9c2d12016-07-29 12:48:20 -07001591}
1592
Colin Cross26c34ed2016-09-30 17:10:16 -07001593func (library *libraryDecorator) toc() android.OptionalPath {
1594 return library.tocFile
1595}
1596
Jiyong Parkf1194352019-02-25 11:05:47 +09001597func (library *libraryDecorator) installSymlinkToRuntimeApex(ctx ModuleContext, file android.Path) {
1598 dir := library.baseInstaller.installDir(ctx)
1599 dirOnDevice := android.InstallPathToOnDevicePath(ctx, dir)
Florian Mayer95cd6db2023-03-23 17:48:07 -07001600 // libc_hwasan has relative_install_dir set, which would mess up the dir.Base() logic.
1601 // hardcode here because it's the only target, if we have other targets that use this
1602 // we can generalise this.
1603 var target string
1604 if ctx.baseModuleName() == "libc_hwasan" {
1605 target = "/" + filepath.Join("apex", "com.android.runtime", "lib64", "bionic", "hwasan", file.Base())
1606 } else {
1607 base := dir.Base()
1608 target = "/" + filepath.Join("apex", "com.android.runtime", base, "bionic", file.Base())
1609 }
Jiyong Parkf1194352019-02-25 11:05:47 +09001610 ctx.InstallAbsoluteSymlink(dir, file.Base(), target)
Jaewoong Jung18aefc12020-12-21 09:11:10 -08001611 library.postInstallCmds = append(library.postInstallCmds, makeSymlinkCmd(dirOnDevice, file.Base(), target))
Jiyong Parkf1194352019-02-25 11:05:47 +09001612}
1613
Colin Crossb916a382016-07-29 17:28:03 -07001614func (library *libraryDecorator) install(ctx ModuleContext, file android.Path) {
Colin Crossc43ae772017-04-14 15:42:53 -07001615 if library.shared() {
Justin Yun8fe12122017-12-07 17:18:15 +09001616 if ctx.Device() && ctx.useVndk() {
Jooyung Han261e1582020-10-20 18:54:21 +09001617 // set subDir for VNDK extensions
Ivan Lozanof9e21722020-12-02 09:00:51 -05001618 if ctx.IsVndkExt() {
Jooyung Han261e1582020-10-20 18:54:21 +09001619 if ctx.isVndkSp() {
1620 library.baseInstaller.subDir = "vndk-sp"
1621 } else {
1622 library.baseInstaller.subDir = "vndk"
1623 }
1624 }
1625
Justin Yun31094b12020-12-24 16:11:23 +09001626 // In some cases we want to use core variant for VNDK-Core libs.
1627 // Skip product variant since VNDKs use only the vendor variant.
1628 if ctx.isVndk() && !ctx.isVndkSp() && !ctx.IsVndkExt() && !ctx.inProduct() {
Vic Yang1a5812a2020-01-31 10:38:40 -08001629 mayUseCoreVariant := true
1630
1631 if ctx.mustUseVendorVariant() {
1632 mayUseCoreVariant = false
1633 }
1634
Elvis Chien9c993542021-06-25 01:15:17 +08001635 if ctx.Config().CFIEnabledForPath(ctx.ModuleDir()) {
Vic Yang1a5812a2020-01-31 10:38:40 -08001636 mayUseCoreVariant = false
1637 }
1638
1639 if mayUseCoreVariant {
Vic Yangd92090f2020-01-08 14:32:28 -08001640 library.checkSameCoreVariant = true
1641 if ctx.DeviceConfig().VndkUseCoreVariant() {
1642 library.useCoreVariant = true
1643 }
Vic Yangefd249e2018-11-12 20:19:56 -08001644 }
Justin Yun8fe12122017-12-07 17:18:15 +09001645 }
Logan Chienf3511742017-10-31 18:04:35 +08001646
Jooyung Han261e1582020-10-20 18:54:21 +09001647 // do not install vndk libs
1648 // vndk libs are packaged into VNDK APEX
Justin Yund5784122023-10-25 13:25:32 +09001649 if ctx.isVndk() && !ctx.IsVndkExt() && !ctx.Config().IsVndkDeprecated() && !ctx.inProduct() {
Jooyung Han261e1582020-10-20 18:54:21 +09001650 return
Justin Yun8effde42017-06-23 19:24:43 +09001651 }
Jiyong Parkd4a3a132021-03-17 20:21:35 +09001652 } else if library.hasStubsVariants() && !ctx.Host() && ctx.directlyInAnyApex() {
Jiyong Parkf1194352019-02-25 11:05:47 +09001653 // Bionic libraries (e.g. libc.so) is installed to the bootstrap subdirectory.
1654 // The original path becomes a symlink to the corresponding file in the
1655 // runtime APEX.
Colin Cross3b19f5d2019-09-17 14:45:31 -07001656 translatedArch := ctx.Target().NativeBridge == android.NativeBridgeEnabled
Colin Cross56a83212020-09-15 18:30:11 -07001657 if InstallToBootstrap(ctx.baseModuleName(), ctx.Config()) && !library.buildStubs() &&
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001658 !translatedArch && !ctx.inRamdisk() && !ctx.inVendorRamdisk() && !ctx.inRecovery() {
Martin Stjernholm279de572019-09-10 23:18:20 +01001659 if ctx.Device() {
Jiyong Parkc3e2c862019-03-16 01:10:08 +09001660 library.installSymlinkToRuntimeApex(ctx, file)
1661 }
Jiyong Park429660f2019-01-16 22:31:11 +09001662 library.baseInstaller.subDir = "bootstrap"
1663 }
Colin Cross127bb8b2020-12-16 16:46:01 -08001664 } else if ctx.directlyInAnyApex() && ctx.IsLlndk() && !isBionic(ctx.baseModuleName()) {
Przemyslaw Szczepaniake6fc5072019-07-12 14:06:23 +01001665 // Skip installing LLNDK (non-bionic) libraries moved to APEX.
Colin Crossa9c8c9f2020-12-16 10:20:23 -08001666 ctx.Module().HideFromMake()
Justin Yun8effde42017-06-23 19:24:43 +09001667 }
Przemyslaw Szczepaniake6fc5072019-07-12 14:06:23 +01001668
Colin Cross4d9c2d12016-07-29 12:48:20 -07001669 library.baseInstaller.install(ctx, file)
1670 }
Dan Albertf563d252017-10-13 00:29:00 -07001671
Dan Albert281f22b2017-12-13 15:03:47 -08001672 if Bool(library.Properties.Static_ndk_lib) && library.static() &&
Kiyoung Kimaa394802024-01-08 12:55:45 +09001673 !ctx.InVendorOrProduct() && !ctx.inRamdisk() && !ctx.inVendorRamdisk() && !ctx.inRecovery() && ctx.Device() &&
Jiyong Park7ed9de32018-10-15 22:25:07 +09001674 library.baseLinker.sanitize.isUnsanitizedVariant() &&
Colin Cross95b07f22020-12-16 11:06:50 -08001675 ctx.isForPlatform() && !ctx.isPreventInstall() {
Dan Albert4048bb02023-04-03 20:19:07 +00001676 installPath := getUnversionedLibraryInstallPath(ctx).Join(ctx, file.Base())
Dan Albertf563d252017-10-13 00:29:00 -07001677
1678 ctx.ModuleBuild(pctx, android.ModuleBuildParams{
1679 Rule: android.Cp,
1680 Description: "install " + installPath.Base(),
1681 Output: installPath,
1682 Input: file,
1683 })
1684
Colin Cross0875c522017-11-28 17:34:01 -08001685 library.ndkSysrootPath = installPath
Dan Albertf563d252017-10-13 00:29:00 -07001686 }
Colin Cross4d9c2d12016-07-29 12:48:20 -07001687}
1688
Paul Duffin0cb37b92020-03-04 14:52:46 +00001689func (library *libraryDecorator) everInstallable() bool {
1690 // Only shared and static libraries are installed. Header libraries (which are
1691 // neither static or shared) are not installed.
1692 return library.shared() || library.static()
1693}
1694
Chris Parsons3c27ca32020-11-20 12:42:07 -05001695// static returns true if this library is for a "static' variant.
Colin Crossb916a382016-07-29 17:28:03 -07001696func (library *libraryDecorator) static() bool {
Colin Crossa48ab5b2017-02-14 15:28:44 -08001697 return library.MutatedProperties.VariantIsStatic
Colin Cross4d9c2d12016-07-29 12:48:20 -07001698}
1699
Chris Parsons3c27ca32020-11-20 12:42:07 -05001700// shared returns true if this library is for a "shared' variant.
Colin Crossa48ab5b2017-02-14 15:28:44 -08001701func (library *libraryDecorator) shared() bool {
1702 return library.MutatedProperties.VariantIsShared
1703}
1704
Chris Parsons3c27ca32020-11-20 12:42:07 -05001705// header returns true if this library is for a header-only variant.
Colin Crossa48ab5b2017-02-14 15:28:44 -08001706func (library *libraryDecorator) header() bool {
Chris Parsons3c27ca32020-11-20 12:42:07 -05001707 // Neither "static" nor "shared" implies this library is header-only.
Colin Crossa48ab5b2017-02-14 15:28:44 -08001708 return !library.static() && !library.shared()
1709}
1710
Chris Parsons3c27ca32020-11-20 12:42:07 -05001711// setStatic marks the library variant as "static".
Colin Crossa48ab5b2017-02-14 15:28:44 -08001712func (library *libraryDecorator) setStatic() {
1713 library.MutatedProperties.VariantIsStatic = true
1714 library.MutatedProperties.VariantIsShared = false
1715}
1716
Chris Parsons3c27ca32020-11-20 12:42:07 -05001717// setShared marks the library variant as "shared".
Colin Crossa48ab5b2017-02-14 15:28:44 -08001718func (library *libraryDecorator) setShared() {
1719 library.MutatedProperties.VariantIsStatic = false
1720 library.MutatedProperties.VariantIsShared = true
Colin Crossb916a382016-07-29 17:28:03 -07001721}
1722
Chris Parsons3c27ca32020-11-20 12:42:07 -05001723// BuildOnlyStatic disables building this library as a shared library.
Colin Crossab3b7322016-12-09 14:46:15 -08001724func (library *libraryDecorator) BuildOnlyStatic() {
Colin Crossa48ab5b2017-02-14 15:28:44 -08001725 library.MutatedProperties.BuildShared = false
Colin Crossab3b7322016-12-09 14:46:15 -08001726}
1727
Chris Parsons3c27ca32020-11-20 12:42:07 -05001728// BuildOnlyShared disables building this library as a static library.
Colin Crossab3b7322016-12-09 14:46:15 -08001729func (library *libraryDecorator) BuildOnlyShared() {
Colin Crossa48ab5b2017-02-14 15:28:44 -08001730 library.MutatedProperties.BuildStatic = false
Colin Crossab3b7322016-12-09 14:46:15 -08001731}
1732
Chris Parsons3c27ca32020-11-20 12:42:07 -05001733// HeaderOnly disables building this library as a shared or static library;
1734// the library only exists to propagate header file dependencies up the build graph.
Colin Cross5950f382016-12-13 12:50:57 -08001735func (library *libraryDecorator) HeaderOnly() {
Colin Crossa48ab5b2017-02-14 15:28:44 -08001736 library.MutatedProperties.BuildShared = false
1737 library.MutatedProperties.BuildStatic = false
Colin Cross5950f382016-12-13 12:50:57 -08001738}
1739
Colin Cross127bb8b2020-12-16 16:46:01 -08001740// hasLLNDKStubs returns true if this cc_library module has a variant that will build LLNDK stubs.
1741func (library *libraryDecorator) hasLLNDKStubs() bool {
Colin Cross203b4212021-04-26 17:19:41 -07001742 return String(library.Properties.Llndk.Symbol_file) != ""
Colin Cross0fb7fcd2021-03-02 11:00:07 -08001743}
1744
Colin Cross203b4212021-04-26 17:19:41 -07001745// hasLLNDKStubs returns true if this cc_library module has a variant that will build LLNDK stubs.
Colin Cross1f3f1302021-04-26 18:37:44 -07001746func (library *libraryDecorator) hasLLNDKHeaders() bool {
1747 return Bool(library.Properties.Llndk.Llndk_headers)
1748}
1749
Colin Cross5271fea2021-04-27 13:06:04 -07001750// hasVendorPublicLibrary returns true if this cc_library module has a variant that will build
1751// vendor public library stubs.
1752func (library *libraryDecorator) hasVendorPublicLibrary() bool {
1753 return String(library.Properties.Vendor_public_library.Symbol_file) != ""
1754}
1755
Colin Cross0477b422020-10-13 18:43:54 -07001756func (library *libraryDecorator) implementationModuleName(name string) string {
1757 return name
1758}
1759
Jiyong Park7ed9de32018-10-15 22:25:07 +09001760func (library *libraryDecorator) buildStubs() bool {
1761 return library.MutatedProperties.BuildStubs
1762}
1763
Jiyong Parka034b832019-08-27 14:02:19 +09001764func (library *libraryDecorator) symbolFileForAbiCheck(ctx ModuleContext) *string {
Hsin-Yi Chen8feb4132022-12-26 15:54:36 +08001765 if props := library.getHeaderAbiCheckerProperties(ctx); props.Symbol_file != nil {
1766 return props.Symbol_file
Jiyong Parka034b832019-08-27 14:02:19 +09001767 }
Colin Cross127bb8b2020-12-16 16:46:01 -08001768 if ctx.Module().(*Module).IsLlndk() {
1769 return library.Properties.Llndk.Symbol_file
1770 }
Colin Cross31076b32020-10-23 17:22:06 -07001771 if library.hasStubsVariants() && library.Properties.Stubs.Symbol_file != nil {
Jiyong Parka034b832019-08-27 14:02:19 +09001772 return library.Properties.Stubs.Symbol_file
1773 }
Hsin-Yi Chenf1f276c2024-03-11 20:02:34 +08001774 // TODO(b/309880485): Distinguish platform, NDK, LLNDK, and APEX version scripts.
1775 if library.baseLinker.Properties.Version_script != nil {
1776 return library.baseLinker.Properties.Version_script
1777 }
Jiyong Parka034b832019-08-27 14:02:19 +09001778 return nil
1779}
1780
Colin Crossc88c2722020-09-28 17:32:47 -07001781func (library *libraryDecorator) hasStubsVariants() bool {
Jiyong Parkd4a3a132021-03-17 20:21:35 +09001782 // Just having stubs.symbol_file is enough to create a stub variant. In that case
1783 // the stub for the future API level is created.
1784 return library.Properties.Stubs.Symbol_file != nil ||
1785 len(library.Properties.Stubs.Versions) > 0
Colin Crossc88c2722020-09-28 17:32:47 -07001786}
1787
Alan Stokes73feba32022-11-14 12:21:24 +00001788func (library *libraryDecorator) isStubsImplementationRequired() bool {
1789 return BoolDefault(library.Properties.Stubs.Implementation_installable, true)
1790}
1791
Colin Cross3572cf72020-10-01 15:58:11 -07001792func (library *libraryDecorator) stubsVersions(ctx android.BaseMutatorContext) []string {
Jiyong Parkd4a3a132021-03-17 20:21:35 +09001793 if !library.hasStubsVariants() {
1794 return nil
1795 }
1796
Kiyoung Kimaa394802024-01-08 12:55:45 +09001797 if library.hasLLNDKStubs() && ctx.Module().(*Module).InVendorOrProduct() {
Jooyung Han5e8994e2024-03-12 14:12:12 +09001798 // LLNDK libraries only need a single stubs variant (""), which is
1799 // added automatically in createVersionVariations().
1800 return nil
Colin Crossc1b36442021-05-06 13:42:48 -07001801 }
1802
Jiyong Parkd4a3a132021-03-17 20:21:35 +09001803 // Future API level is implicitly added if there isn't
Jooyung Han5e8994e2024-03-12 14:12:12 +09001804 versions := addCurrentVersionIfNotPresent(library.Properties.Stubs.Versions)
1805 normalizeVersions(ctx, versions)
1806 return versions
Sam Delmerico75dbca22023-04-20 13:13:25 +00001807}
1808
1809func addCurrentVersionIfNotPresent(vers []string) []string {
Jiyong Parkd4a3a132021-03-17 20:21:35 +09001810 if inList(android.FutureApiLevel.String(), vers) {
1811 return vers
1812 }
1813 // In some cases, people use the raw value "10000" in the versions property.
1814 // We shouldn't add the future API level in that case, otherwise there will
1815 // be two identical versions.
1816 if inList(strconv.Itoa(android.FutureApiLevel.FinalOrFutureInt()), vers) {
1817 return vers
1818 }
1819 return append(vers, android.FutureApiLevel.String())
Colin Crossc88c2722020-09-28 17:32:47 -07001820}
1821
1822func (library *libraryDecorator) setStubsVersion(version string) {
1823 library.MutatedProperties.StubsVersion = version
1824}
1825
Jiyong Park7ed9de32018-10-15 22:25:07 +09001826func (library *libraryDecorator) stubsVersion() string {
1827 return library.MutatedProperties.StubsVersion
1828}
1829
Jiyong Parkd4a3a132021-03-17 20:21:35 +09001830func (library *libraryDecorator) setBuildStubs(isLatest bool) {
Colin Crossc88c2722020-09-28 17:32:47 -07001831 library.MutatedProperties.BuildStubs = true
Jiyong Parkd4a3a132021-03-17 20:21:35 +09001832 library.MutatedProperties.IsLatestVersion = isLatest
Colin Crossc88c2722020-09-28 17:32:47 -07001833}
1834
1835func (library *libraryDecorator) setAllStubsVersions(versions []string) {
1836 library.MutatedProperties.AllStubsVersions = versions
1837}
1838
1839func (library *libraryDecorator) allStubsVersions() []string {
1840 return library.MutatedProperties.AllStubsVersions
1841}
1842
Jooyung Hanad4c1872020-02-27 17:56:44 +09001843func (library *libraryDecorator) isLatestStubVersion() bool {
Jiyong Parkd4a3a132021-03-17 20:21:35 +09001844 return library.MutatedProperties.IsLatestVersion
Jooyung Hanad4c1872020-02-27 17:56:44 +09001845}
1846
Jiyong Parka90ca002019-10-07 15:47:24 +09001847func (library *libraryDecorator) availableFor(what string) bool {
1848 var list []string
1849 if library.static() {
1850 list = library.StaticProperties.Static.Apex_available
1851 } else if library.shared() {
1852 list = library.SharedProperties.Shared.Apex_available
1853 }
1854 if len(list) == 0 {
1855 return false
1856 }
1857 return android.CheckAvailableForApex(what, list)
1858}
1859
Colin Cross1bc94122021-10-28 13:25:54 -07001860func (library *libraryDecorator) installable() *bool {
1861 if library.static() {
1862 return library.StaticProperties.Static.Installable
1863 } else if library.shared() {
1864 return library.SharedProperties.Shared.Installable
1865 }
1866 return nil
1867}
1868
Jingwen Chen8ac7d7d2023-03-20 11:05:16 +00001869func (library *libraryDecorator) makeUninstallable(mod *Module) {
1870 if library.static() && library.buildStatic() && !library.buildStubs() {
1871 // If we're asked to make a static library uninstallable we don't do
1872 // anything since AndroidMkEntries always sets LOCAL_UNINSTALLABLE_MODULE
1873 // for these entries. This is done to still get the make targets for NOTICE
1874 // files from notice_files.mk, which other libraries might depend on.
1875 return
1876 }
1877 mod.ModuleBase.MakeUninstallable()
1878}
1879
Jihoon Kangf78a8902022-09-01 22:47:07 +00001880func (library *libraryDecorator) getPartition() string {
1881 return library.path.Partition()
1882}
1883
Colin Crossceaa5322021-09-28 16:37:50 -07001884func (library *libraryDecorator) getAPIListCoverageXMLPath() android.ModuleOutPath {
1885 return library.apiListCoverageXmlPath
1886}
1887
Inseob Kima1888ce2022-10-04 14:42:02 +09001888func (library *libraryDecorator) overriddenModules() []string {
1889 return library.Properties.Overrides
1890}
1891
1892var _ overridable = (*libraryDecorator)(nil)
1893
Colin Cross571cccf2019-02-04 11:22:08 -08001894var versioningMacroNamesListKey = android.NewOnceKey("versioningMacroNamesList")
1895
Chris Parsons3c27ca32020-11-20 12:42:07 -05001896// versioningMacroNamesList returns a singleton map, where keys are "version macro names",
1897// and values are the module name responsible for registering the version macro name.
1898//
1899// Version macros are used when building against stubs, to provide version information about
1900// the stub. Only stub libraries should have an entry in this list.
1901//
1902// For example, when building against libFoo#ver, __LIBFOO_API__ macro is set to ver so
1903// that headers from libFoo can be conditionally compiled (this may hide APIs
1904// that are not available for the version).
1905//
1906// This map is used to ensure that there aren't conflicts between these version macro names.
Jiyong Parkda732bd2018-11-02 18:23:15 +09001907func versioningMacroNamesList(config android.Config) *map[string]string {
Colin Cross571cccf2019-02-04 11:22:08 -08001908 return config.Once(versioningMacroNamesListKey, func() interface{} {
Jiyong Parkda732bd2018-11-02 18:23:15 +09001909 m := make(map[string]string)
1910 return &m
1911 }).(*map[string]string)
1912}
1913
1914// alphanumeric and _ characters are preserved.
1915// other characters are all converted to _
1916var charsNotForMacro = regexp.MustCompile("[^a-zA-Z0-9_]+")
1917
Chris Parsons3c27ca32020-11-20 12:42:07 -05001918// versioningMacroName returns the canonical version macro name for the given module.
Jiyong Parkda732bd2018-11-02 18:23:15 +09001919func versioningMacroName(moduleName string) string {
1920 macroName := charsNotForMacro.ReplaceAllString(moduleName, "_")
Jooyung Hanb04a4992020-03-13 18:57:35 +09001921 macroName = strings.ToUpper(macroName)
Jiyong Parkda732bd2018-11-02 18:23:15 +09001922 return "__" + macroName + "_API__"
1923}
1924
Chris Parsons3c27ca32020-11-20 12:42:07 -05001925// NewLibrary builds and returns a new Module corresponding to a C++ library.
1926// Individual module implementations which comprise a C++ library (or something like
1927// a C++ library) should call this function, set some fields on the result, and
1928// then call the Init function.
Colin Crossab3b7322016-12-09 14:46:15 -08001929func NewLibrary(hod android.HostOrDeviceSupported) (*Module, *libraryDecorator) {
Colin Cross4d9c2d12016-07-29 12:48:20 -07001930 module := newModule(hod, android.MultilibBoth)
1931
Colin Crossb916a382016-07-29 17:28:03 -07001932 library := &libraryDecorator{
Colin Crossa48ab5b2017-02-14 15:28:44 -08001933 MutatedProperties: LibraryMutatedProperties{
Colin Crossab3b7322016-12-09 14:46:15 -08001934 BuildShared: true,
1935 BuildStatic: true,
Colin Cross4d9c2d12016-07-29 12:48:20 -07001936 },
Colin Crossb916a382016-07-29 17:28:03 -07001937 baseCompiler: NewBaseCompiler(),
Dan Albert61f32122018-07-26 14:00:24 -07001938 baseLinker: NewBaseLinker(module.sanitize),
Colin Crossb916a382016-07-29 17:28:03 -07001939 baseInstaller: NewBaseInstaller("lib", "lib64", InstallInSystem),
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001940 sabi: module.sabi,
Colin Cross4d9c2d12016-07-29 12:48:20 -07001941 }
1942
Colin Crossb916a382016-07-29 17:28:03 -07001943 module.compiler = library
1944 module.linker = library
1945 module.installer = library
Colin Cross31076b32020-10-23 17:22:06 -07001946 module.library = library
Colin Crossb916a382016-07-29 17:28:03 -07001947
1948 return module, library
1949}
1950
Colin Cross10d22312017-05-03 11:01:58 -07001951// connects a shared library to a static library in order to reuse its .o files to avoid
1952// compiling source files twice.
1953func reuseStaticLibrary(mctx android.BottomUpMutatorContext, static, shared *Module) {
1954 if staticCompiler, ok := static.compiler.(*libraryDecorator); ok {
1955 sharedCompiler := shared.compiler.(*libraryDecorator)
Dan Willemsen3a26eef2018-12-03 15:25:46 -08001956
1957 // Check libraries in addition to cflags, since libraries may be exporting different
1958 // include directories.
Colin Crosse1bb5d02019-09-24 14:55:04 -07001959 if len(staticCompiler.StaticProperties.Static.Cflags) == 0 &&
1960 len(sharedCompiler.SharedProperties.Shared.Cflags) == 0 &&
1961 len(staticCompiler.StaticProperties.Static.Whole_static_libs) == 0 &&
1962 len(sharedCompiler.SharedProperties.Shared.Whole_static_libs) == 0 &&
1963 len(staticCompiler.StaticProperties.Static.Static_libs) == 0 &&
1964 len(sharedCompiler.SharedProperties.Shared.Static_libs) == 0 &&
1965 len(staticCompiler.StaticProperties.Static.Shared_libs) == 0 &&
1966 len(sharedCompiler.SharedProperties.Shared.Shared_libs) == 0 &&
Martin Stjernholm10566a02020-03-24 01:19:52 +00001967 // Compare System_shared_libs properties with nil because empty lists are
1968 // semantically significant for them.
Colin Crosse1bb5d02019-09-24 14:55:04 -07001969 staticCompiler.StaticProperties.Static.System_shared_libs == nil &&
1970 sharedCompiler.SharedProperties.Shared.System_shared_libs == nil {
Colin Cross10d22312017-05-03 11:01:58 -07001971
1972 mctx.AddInterVariantDependency(reuseObjTag, shared, static)
1973 sharedCompiler.baseCompiler.Properties.OriginalSrcs =
1974 sharedCompiler.baseCompiler.Properties.Srcs
1975 sharedCompiler.baseCompiler.Properties.Srcs = nil
1976 sharedCompiler.baseCompiler.Properties.Generated_sources = nil
1977 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07001978
1979 // This dep is just to reference static variant from shared variant
1980 mctx.AddInterVariantDependency(staticVariantTag, shared, static)
Colin Cross10d22312017-05-03 11:01:58 -07001981 }
1982}
1983
Chris Parsons3c27ca32020-11-20 12:42:07 -05001984// LinkageMutator adds "static" or "shared" variants for modules depending
1985// on whether the module can be built as a static library or a shared library.
Colin Crosse40b4ea2018-10-02 22:25:58 -07001986func LinkageMutator(mctx android.BottomUpMutatorContext) {
Jaewoong Jung18aefc12020-12-21 09:11:10 -08001987 ccPrebuilt := false
Colin Crossb916a382016-07-29 17:28:03 -07001988 if m, ok := mctx.Module().(*Module); ok && m.linker != nil {
Jaewoong Jung18aefc12020-12-21 09:11:10 -08001989 _, ccPrebuilt = m.linker.(prebuiltLibraryInterface)
Ivan Lozano52767be2019-10-18 14:49:46 -07001990 }
Jaewoong Jung18aefc12020-12-21 09:11:10 -08001991 if ccPrebuilt {
Ivan Lozano52767be2019-10-18 14:49:46 -07001992 library := mctx.Module().(*Module).linker.(prebuiltLibraryInterface)
Colin Cross33b2fb72019-05-14 14:07:01 -07001993
Paul Duffinf5ea9e12020-02-21 10:57:00 +00001994 // Differentiate between header only and building an actual static/shared library
Colin Cross127bb8b2020-12-16 16:46:01 -08001995 buildStatic := library.buildStatic()
1996 buildShared := library.buildShared()
1997 if buildStatic || buildShared {
Paul Duffinf5ea9e12020-02-21 10:57:00 +00001998 // Always create both the static and shared variants for prebuilt libraries, and then disable the one
1999 // that is not being used. This allows them to share the name of a cc_library module, which requires that
2000 // all the variants of the cc_library also exist on the prebuilt.
2001 modules := mctx.CreateLocalVariations("static", "shared")
2002 static := modules[0].(*Module)
2003 shared := modules[1].(*Module)
Colin Cross33b2fb72019-05-14 14:07:01 -07002004
Paul Duffinf5ea9e12020-02-21 10:57:00 +00002005 static.linker.(prebuiltLibraryInterface).setStatic()
2006 shared.linker.(prebuiltLibraryInterface).setShared()
Colin Cross33b2fb72019-05-14 14:07:01 -07002007
Colin Cross127bb8b2020-12-16 16:46:01 -08002008 if buildShared {
Colin Cross81ca6cd2020-08-06 17:46:48 -07002009 mctx.AliasVariation("shared")
Colin Cross127bb8b2020-12-16 16:46:01 -08002010 } else if buildStatic {
Colin Cross81ca6cd2020-08-06 17:46:48 -07002011 mctx.AliasVariation("static")
2012 }
2013
Colin Cross127bb8b2020-12-16 16:46:01 -08002014 if !buildStatic {
Paul Duffinf5ea9e12020-02-21 10:57:00 +00002015 static.linker.(prebuiltLibraryInterface).disablePrebuilt()
2016 }
Colin Cross127bb8b2020-12-16 16:46:01 -08002017 if !buildShared {
Paul Duffinf5ea9e12020-02-21 10:57:00 +00002018 shared.linker.(prebuiltLibraryInterface).disablePrebuilt()
2019 }
2020 } else {
2021 // Header only
Colin Crossb916a382016-07-29 17:28:03 -07002022 }
Paul Duffinf5ea9e12020-02-21 10:57:00 +00002023
Ivan Lozano52767be2019-10-18 14:49:46 -07002024 } else if library, ok := mctx.Module().(LinkableInterface); ok && library.CcLibraryInterface() {
Ivan Lozano52767be2019-10-18 14:49:46 -07002025
Ivan Lozano2b262972019-11-21 12:30:50 -08002026 // Non-cc.Modules may need an empty variant for their mutators.
2027 variations := []string{}
2028 if library.NonCcVariants() {
2029 variations = append(variations, "")
2030 }
2031
Colin Cross127bb8b2020-12-16 16:46:01 -08002032 isLLNDK := false
2033 if m, ok := mctx.Module().(*Module); ok {
Colin Cross203b4212021-04-26 17:19:41 -07002034 isLLNDK = m.IsLlndk()
Colin Cross127bb8b2020-12-16 16:46:01 -08002035 }
2036 buildStatic := library.BuildStaticVariant() && !isLLNDK
2037 buildShared := library.BuildSharedVariant()
2038 if buildStatic && buildShared {
Ivan Lozano2b262972019-11-21 12:30:50 -08002039 variations := append([]string{"static", "shared"}, variations...)
Ivan Lozano52767be2019-10-18 14:49:46 -07002040
2041 modules := mctx.CreateLocalVariations(variations...)
2042 static := modules[0].(LinkableInterface)
2043 shared := modules[1].(LinkableInterface)
2044
2045 static.SetStatic()
2046 shared.SetShared()
2047
2048 if _, ok := library.(*Module); ok {
2049 reuseStaticLibrary(mctx, static.(*Module), shared.(*Module))
2050 }
Colin Cross81ca6cd2020-08-06 17:46:48 -07002051 mctx.AliasVariation("shared")
Colin Cross127bb8b2020-12-16 16:46:01 -08002052 } else if buildStatic {
Ivan Lozano2b262972019-11-21 12:30:50 -08002053 variations := append([]string{"static"}, variations...)
2054
2055 modules := mctx.CreateLocalVariations(variations...)
Ivan Lozano52767be2019-10-18 14:49:46 -07002056 modules[0].(LinkableInterface).SetStatic()
Colin Cross81ca6cd2020-08-06 17:46:48 -07002057 mctx.AliasVariation("static")
Colin Cross127bb8b2020-12-16 16:46:01 -08002058 } else if buildShared {
Ivan Lozano2b262972019-11-21 12:30:50 -08002059 variations := append([]string{"shared"}, variations...)
Ivan Lozano52767be2019-10-18 14:49:46 -07002060
Ivan Lozano2b262972019-11-21 12:30:50 -08002061 modules := mctx.CreateLocalVariations(variations...)
2062 modules[0].(LinkableInterface).SetShared()
Colin Cross81ca6cd2020-08-06 17:46:48 -07002063 mctx.AliasVariation("shared")
Ivan Lozano2b262972019-11-21 12:30:50 -08002064 } else if len(variations) > 0 {
2065 mctx.CreateLocalVariations(variations...)
Colin Cross81ca6cd2020-08-06 17:46:48 -07002066 mctx.AliasVariation(variations[0])
Ivan Lozano2b262972019-11-21 12:30:50 -08002067 }
Colin Crossb916a382016-07-29 17:28:03 -07002068 }
Colin Cross4d9c2d12016-07-29 12:48:20 -07002069}
Jiyong Park7ed9de32018-10-15 22:25:07 +09002070
Chris Parsons3c27ca32020-11-20 12:42:07 -05002071// normalizeVersions modifies `versions` in place, so that each raw version
2072// string becomes its normalized canonical form.
2073// Validates that the versions in `versions` are specified in least to greatest order.
Colin Cross8ff10582023-12-07 13:10:56 -08002074func normalizeVersions(ctx android.BaseModuleContext, versions []string) {
Dan Albertc8060532020-07-22 22:32:17 -07002075 var previous android.ApiLevel
Jooyung Hanad4c1872020-02-27 17:56:44 +09002076 for i, v := range versions {
Dan Albertc8060532020-07-22 22:32:17 -07002077 ver, err := android.ApiLevelFromUser(ctx, v)
Jooyung Hanad4c1872020-02-27 17:56:44 +09002078 if err != nil {
Jooyung Hanaed150d2020-04-02 01:41:41 +09002079 ctx.PropertyErrorf("versions", "%s", err.Error())
2080 return
Jooyung Hanad4c1872020-02-27 17:56:44 +09002081 }
Dan Albertc8060532020-07-22 22:32:17 -07002082 if i > 0 && ver.LessThanOrEqualTo(previous) {
2083 ctx.PropertyErrorf("versions", "not sorted: %v", versions)
2084 }
2085 versions[i] = ver.String()
2086 previous = ver
Jooyung Hanaed150d2020-04-02 01:41:41 +09002087 }
Jooyung Hanad4c1872020-02-27 17:56:44 +09002088}
2089
Jooyung Han61b66e92020-03-21 14:21:46 +00002090func createVersionVariations(mctx android.BottomUpMutatorContext, versions []string) {
Colin Cross127bb8b2020-12-16 16:46:01 -08002091 // "" is for the non-stubs (implementation) variant for system modules, or the LLNDK variant
2092 // for LLNDK modules.
Colin Cross0de8a1e2020-09-18 14:15:30 -07002093 variants := append(android.CopyOf(versions), "")
Jooyung Han61b66e92020-03-21 14:21:46 +00002094
Colin Cross127bb8b2020-12-16 16:46:01 -08002095 m := mctx.Module().(*Module)
2096 isLLNDK := m.IsLlndk()
Colin Cross5271fea2021-04-27 13:06:04 -07002097 isVendorPublicLibrary := m.IsVendorPublicLibrary()
Kiyoung Kimee58c932022-10-25 22:59:41 +09002098 isImportedApiLibrary := m.isImportedApiLibrary()
Colin Cross127bb8b2020-12-16 16:46:01 -08002099
Colin Crossd1f898e2020-08-18 18:35:15 -07002100 modules := mctx.CreateLocalVariations(variants...)
Jooyung Han61b66e92020-03-21 14:21:46 +00002101 for i, m := range modules {
Colin Cross127bb8b2020-12-16 16:46:01 -08002102
Kiyoung Kimee58c932022-10-25 22:59:41 +09002103 if variants[i] != "" || isLLNDK || isVendorPublicLibrary || isImportedApiLibrary {
Colin Cross127bb8b2020-12-16 16:46:01 -08002104 // A stubs or LLNDK stubs variant.
Colin Cross31076b32020-10-23 17:22:06 -07002105 c := m.(*Module)
Colin Cross31076b32020-10-23 17:22:06 -07002106 c.sanitize = nil
2107 c.stl = nil
2108 c.Properties.PreventInstall = true
2109 lib := moduleLibraryInterface(m)
Jiyong Parkd4a3a132021-03-17 20:21:35 +09002110 isLatest := i == (len(versions) - 1)
2111 lib.setBuildStubs(isLatest)
Colin Cross127bb8b2020-12-16 16:46:01 -08002112
2113 if variants[i] != "" {
2114 // A non-LLNDK stubs module is hidden from make and has a dependency from the
2115 // implementation module to the stubs module.
2116 c.Properties.HideFromMake = true
2117 lib.setStubsVersion(variants[i])
2118 mctx.AddInterVariantDependency(stubImplDepTag, modules[len(modules)-1], modules[i])
2119 }
Jooyung Han61b66e92020-03-21 14:21:46 +00002120 }
2121 }
Colin Cross094faa52020-08-06 17:38:25 -07002122 mctx.AliasVariation("")
Colin Crossd1f898e2020-08-18 18:35:15 -07002123 latestVersion := ""
2124 if len(versions) > 0 {
2125 latestVersion = versions[len(versions)-1]
2126 }
2127 mctx.CreateAliasVariation("latest", latestVersion)
Jooyung Han61b66e92020-03-21 14:21:46 +00002128}
2129
Colin Crossbbc941b2020-09-30 12:27:01 -07002130func createPerApiVersionVariations(mctx android.BottomUpMutatorContext, minSdkVersion string) {
2131 from, err := nativeApiLevelFromUser(mctx, minSdkVersion)
2132 if err != nil {
2133 mctx.PropertyErrorf("min_sdk_version", err.Error())
2134 return
2135 }
2136
2137 versionStrs := ndkLibraryVersions(mctx, from)
2138 modules := mctx.CreateLocalVariations(versionStrs...)
2139
2140 for i, module := range modules {
2141 module.(*Module).Properties.Sdk_version = StringPtr(versionStrs[i])
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09002142 module.(*Module).Properties.Min_sdk_version = StringPtr(versionStrs[i])
Colin Crossbbc941b2020-09-30 12:27:01 -07002143 }
2144}
2145
Liz Kammer23942242022-04-08 15:41:00 -04002146func canBeOrLinkAgainstVersionVariants(module interface {
Jooyung Han624d35c2020-04-10 12:57:24 +09002147 Host() bool
2148 InRamdisk() bool
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002149 InVendorRamdisk() bool
Jooyung Han624d35c2020-04-10 12:57:24 +09002150}) bool {
Jose Galmes6f843bc2020-12-11 13:36:29 -08002151 return !module.Host() && !module.InRamdisk() && !module.InVendorRamdisk()
Jooyung Han624d35c2020-04-10 12:57:24 +09002152}
2153
Liz Kammer23942242022-04-08 15:41:00 -04002154func canBeVersionVariant(module interface {
Colin Cross3146c5c2020-09-30 15:34:40 -07002155 Host() bool
2156 InRamdisk() bool
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002157 InVendorRamdisk() bool
Colin Cross3146c5c2020-09-30 15:34:40 -07002158 CcLibraryInterface() bool
2159 Shared() bool
Colin Cross3146c5c2020-09-30 15:34:40 -07002160}) bool {
Liz Kammer23942242022-04-08 15:41:00 -04002161 return canBeOrLinkAgainstVersionVariants(module) &&
Colin Crossa717db72020-10-23 14:53:06 -07002162 module.CcLibraryInterface() && module.Shared()
Colin Cross3146c5c2020-09-30 15:34:40 -07002163}
2164
Colin Cross127bb8b2020-12-16 16:46:01 -08002165func moduleLibraryInterface(module blueprint.Module) libraryInterface {
Colin Cross31076b32020-10-23 17:22:06 -07002166 if m, ok := module.(*Module); ok {
2167 return m.library
2168 }
2169 return nil
2170}
2171
Liz Kammer23942242022-04-08 15:41:00 -04002172// setStubsVersions normalizes the versions in the Stubs.Versions property into MutatedProperties.AllStubsVersions.
2173func setStubsVersions(mctx android.BottomUpMutatorContext, library libraryInterface, module *Module) {
2174 if !library.buildShared() || !canBeVersionVariant(module) {
2175 return
Colin Crossd1f898e2020-08-18 18:35:15 -07002176 }
Liz Kammer23942242022-04-08 15:41:00 -04002177 versions := library.stubsVersions(mctx)
Liz Kammer23942242022-04-08 15:41:00 -04002178 if mctx.Failed() {
2179 return
2180 }
2181 // Set the versions on the pre-mutated module so they can be read by any llndk modules that
2182 // depend on the implementation library and haven't been mutated yet.
2183 library.setAllStubsVersions(versions)
Colin Crossd1f898e2020-08-18 18:35:15 -07002184}
Jooyung Han61b66e92020-03-21 14:21:46 +00002185
Colin Crossd1f898e2020-08-18 18:35:15 -07002186// versionMutator splits a module into the mandatory non-stubs variant
2187// (which is unnamed) and zero or more stubs variants.
2188func versionMutator(mctx android.BottomUpMutatorContext) {
Liz Kammer23942242022-04-08 15:41:00 -04002189 if mctx.Os() != android.Android {
2190 return
2191 }
2192
2193 m, ok := mctx.Module().(*Module)
2194 if library := moduleLibraryInterface(mctx.Module()); library != nil && canBeVersionVariant(m) {
2195 setStubsVersions(mctx, library, m)
2196
Colin Cross31076b32020-10-23 17:22:06 -07002197 createVersionVariations(mctx, library.allStubsVersions())
Colin Crossbbc941b2020-09-30 12:27:01 -07002198 return
2199 }
2200
Liz Kammer23942242022-04-08 15:41:00 -04002201 if ok {
Colin Crossbbc941b2020-09-30 12:27:01 -07002202 if m.SplitPerApiLevel() && m.IsSdkVariant() {
Colin Crossbbc941b2020-09-30 12:27:01 -07002203 createPerApiVersionVariations(mctx, m.MinSdkVersion())
2204 }
Jiyong Park7ed9de32018-10-15 22:25:07 +09002205 }
Jiyong Park7ed9de32018-10-15 22:25:07 +09002206}
Colin Crossd7227f92019-09-05 14:26:33 -07002207
2208// maybeInjectBoringSSLHash adds a rule to run bssl_inject_hash on the output file if the module has the
2209// inject_bssl_hash or if any static library dependencies have inject_bssl_hash set. It returns the output path
2210// that the linked output file should be written to.
2211// TODO(b/137267623): Remove this in favor of a cc_genrule when they support operating on shared libraries.
2212func maybeInjectBoringSSLHash(ctx android.ModuleContext, outputFile android.ModuleOutPath,
2213 inject *bool, fileName string) android.ModuleOutPath {
2214 // TODO(b/137267623): Remove this in favor of a cc_genrule when they support operating on shared libraries.
2215 injectBoringSSLHash := Bool(inject)
2216 ctx.VisitDirectDeps(func(dep android.Module) {
Colin Cross6e511a92020-07-27 21:26:48 -07002217 if tag, ok := ctx.OtherModuleDependencyTag(dep).(libraryDependencyTag); ok && tag.static() {
Colin Crossd7227f92019-09-05 14:26:33 -07002218 if cc, ok := dep.(*Module); ok {
2219 if library, ok := cc.linker.(*libraryDecorator); ok {
2220 if Bool(library.Properties.Inject_bssl_hash) {
2221 injectBoringSSLHash = true
2222 }
2223 }
2224 }
2225 }
2226 })
2227 if injectBoringSSLHash {
2228 hashedOutputfile := outputFile
2229 outputFile = android.PathForModuleOut(ctx, "unhashed", fileName)
2230
Colin Crossf1a035e2020-11-16 17:32:30 -08002231 rule := android.NewRuleBuilder(pctx, ctx)
Colin Crossd7227f92019-09-05 14:26:33 -07002232 rule.Command().
Colin Crossf1a035e2020-11-16 17:32:30 -08002233 BuiltTool("bssl_inject_hash").
Colin Crossd7227f92019-09-05 14:26:33 -07002234 FlagWithInput("-in-object ", outputFile).
2235 FlagWithOutput("-o ", hashedOutputfile)
Colin Crossf1a035e2020-11-16 17:32:30 -08002236 rule.Build("injectCryptoHash", "inject crypto hash")
Colin Crossd7227f92019-09-05 14:26:33 -07002237 }
2238
2239 return outputFile
2240}