blob: 73ed96923775002ea87489b27db805f27d381ad4 [file] [log] [blame]
Colin Cross4d9c2d12016-07-29 12:48:20 -07001// Copyright 2016 Google Inc. All rights reserved.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15package cc
16
17import (
Inseob Kim69378442019-06-03 19:10:47 +090018 "fmt"
Logan Chien41eabe62019-04-10 13:33:58 +080019 "io"
Jiyong Parkf1194352019-02-25 11:05:47 +090020 "path/filepath"
Jiyong Parkda732bd2018-11-02 18:23:15 +090021 "regexp"
Colin Cross4d9c2d12016-07-29 12:48:20 -070022 "strings"
Jiyong Parkda732bd2018-11-02 18:23:15 +090023 "sync"
Colin Cross4d9c2d12016-07-29 12:48:20 -070024
Colin Cross127bb8b2020-12-16 16:46:01 -080025 "github.com/google/blueprint"
Colin Cross26c34ed2016-09-30 17:10:16 -070026 "github.com/google/blueprint/pathtools"
Colin Cross4d9c2d12016-07-29 12:48:20 -070027
Colin Cross4d9c2d12016-07-29 12:48:20 -070028 "android/soong/android"
Dan Albertea4b7b92018-04-25 16:05:30 -070029 "android/soong/cc/config"
Colin Cross4d9c2d12016-07-29 12:48:20 -070030)
31
Chris Parsons3c27ca32020-11-20 12:42:07 -050032// LibraryProperties is a collection of properties shared by cc library rules.
Colin Crossb916a382016-07-29 17:28:03 -070033type LibraryProperties struct {
Colin Cross4d9c2d12016-07-29 12:48:20 -070034 // local file name to pass to the linker as -unexported_symbols_list
Colin Cross27b922f2019-03-04 22:35:41 -080035 Unexported_symbols_list *string `android:"path,arch_variant"`
Colin Cross4d9c2d12016-07-29 12:48:20 -070036 // local file name to pass to the linker as -force_symbols_not_weak_list
Colin Cross27b922f2019-03-04 22:35:41 -080037 Force_symbols_not_weak_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_weak_list
Colin Cross27b922f2019-03-04 22:35:41 -080039 Force_symbols_weak_list *string `android:"path,arch_variant"`
Colin Cross4d9c2d12016-07-29 12:48:20 -070040
41 // rename host libraries to prevent overlap with system installed libraries
42 Unique_host_soname *bool
43
Dan Willemsene1240db2016-11-03 14:28:51 -070044 Aidl struct {
45 // export headers generated from .aidl sources
Nan Zhang0007d812017-11-07 10:57:05 -080046 Export_aidl_headers *bool
Dan Willemsene1240db2016-11-03 14:28:51 -070047 }
48
Colin Cross0c461f12016-10-20 16:11:43 -070049 Proto struct {
50 // export headers generated from .proto sources
Nan Zhang0007d812017-11-07 10:57:05 -080051 Export_proto_headers *bool
Colin Cross0c461f12016-10-20 16:11:43 -070052 }
Dan Albertf563d252017-10-13 00:29:00 -070053
Inseob Kimc0907f12019-02-08 21:00:45 +090054 Sysprop struct {
55 // Whether platform owns this sysprop library.
56 Platform *bool
Inseob Kimb3f22ca2019-03-05 12:40:24 +090057 } `blueprint:"mutated"`
Inseob Kimc0907f12019-02-08 21:00:45 +090058
Nan Zhang0007d812017-11-07 10:57:05 -080059 Static_ndk_lib *bool
Jiyong Park7ed9de32018-10-15 22:25:07 +090060
61 Stubs struct {
62 // Relative path to the symbol map. The symbol map provides the list of
63 // symbols that are exported for stubs variant of this library.
Colin Cross27b922f2019-03-04 22:35:41 -080064 Symbol_file *string `android:"path"`
Jiyong Park7ed9de32018-10-15 22:25:07 +090065
66 // List versions to generate stubs libs for.
67 Versions []string
68 }
dimitryd95964a2018-11-07 13:43:34 +010069
70 // set the name of the output
71 Stem *string `android:"arch_variant"`
72
Colin Cross0fd6a412019-08-16 14:22:10 -070073 // set suffix of the name of the output
74 Suffix *string `android:"arch_variant"`
75
76 Target struct {
Justin Yun63e9ec72020-10-29 16:49:43 +090077 Vendor, Product struct {
Colin Cross0fd6a412019-08-16 14:22:10 -070078 // set suffix of the name of the output
79 Suffix *string `android:"arch_variant"`
80 }
81 }
82
dimitryd95964a2018-11-07 13:43:34 +010083 // Names of modules to be overridden. Listed modules can only be other shared libraries
84 // (in Make or Soong).
85 // This does not completely prevent installation of the overridden libraries, but if both
86 // binaries would be installed by default (in PRODUCT_PACKAGES) the other library will be removed
87 // from PRODUCT_PACKAGES.
88 Overrides []string
Logan Chiene3d7a0d2019-01-17 00:18:02 +080089
90 // Properties for ABI compatibility checker
91 Header_abi_checker struct {
Logan Chien41eabe62019-04-10 13:33:58 +080092 // Enable ABI checks (even if this is not an LLNDK/VNDK lib)
93 Enabled *bool
94
Logan Chiene3d7a0d2019-01-17 00:18:02 +080095 // Path to a symbol file that specifies the symbols to be included in the generated
96 // ABI dump file
Colin Cross27b922f2019-03-04 22:35:41 -080097 Symbol_file *string `android:"path"`
Logan Chiene3d7a0d2019-01-17 00:18:02 +080098
99 // Symbol versions that should be ignored from the symbol file
100 Exclude_symbol_versions []string
101
102 // Symbol tags that should be ignored from the symbol file
103 Exclude_symbol_tags []string
Logan Chien2a65dda2019-10-01 15:58:07 -0700104
105 // Run checks on all APIs (in addition to the ones referred by
106 // one of exported ELF symbols.)
107 Check_all_apis *bool
Logan Chiene3d7a0d2019-01-17 00:18:02 +0800108 }
Vic Yang6cd1be82019-06-24 16:08:48 -0700109
110 // Order symbols in .bss section by their sizes. Only useful for shared libraries.
111 Sort_bss_symbols_by_size *bool
Pete Bentley803e1612019-08-06 22:19:59 +0100112
113 // Inject boringssl hash into the shared library. This is only intended for use by external/boringssl.
114 Inject_bssl_hash *bool `android:"arch_variant"`
Colin Cross0477b422020-10-13 18:43:54 -0700115
116 // If this is an LLNDK library, the name of the equivalent llndk_library module.
117 Llndk_stubs *string
Colin Cross127bb8b2020-12-16 16:46:01 -0800118
119 // 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 Crossa48ab5b2017-02-14 15:28:44 -0800122}
Colin Cross0c461f12016-10-20 16:11:43 -0700123
Chris Parsons3c27ca32020-11-20 12:42:07 -0500124// StaticProperties is a properties stanza to affect only attributes of the "static" variants of a
125// library module.
Colin Crosse1bb5d02019-09-24 14:55:04 -0700126type StaticProperties struct {
127 Static StaticOrSharedProperties `android:"arch_variant"`
128}
129
Chris Parsons3c27ca32020-11-20 12:42:07 -0500130// SharedProperties is a properties stanza to affect only attributes of the "shared" variants of a
131// library module.
Colin Crosse1bb5d02019-09-24 14:55:04 -0700132type SharedProperties struct {
133 Shared StaticOrSharedProperties `android:"arch_variant"`
134}
135
Chris Parsons3c27ca32020-11-20 12:42:07 -0500136// StaticOrSharedProperties is an embedded struct representing properties to affect attributes of
137// either only the "static" variants or only the "shared" variants of a library module. These override
138// the base properties of the same name.
139// Use `StaticProperties` or `SharedProperties`, depending on which variant is needed.
140// `StaticOrSharedProperties` exists only to avoid duplication.
Colin Crosse1bb5d02019-09-24 14:55:04 -0700141type StaticOrSharedProperties struct {
Evgenii Stepanov2080bfe2020-07-24 15:35:40 -0700142 Srcs []string `android:"path,arch_variant"`
143
144 Sanitized Sanitized `android:"arch_variant"`
145
Colin Crosse1bb5d02019-09-24 14:55:04 -0700146 Cflags []string `android:"arch_variant"`
147
148 Enabled *bool `android:"arch_variant"`
149 Whole_static_libs []string `android:"arch_variant"`
150 Static_libs []string `android:"arch_variant"`
151 Shared_libs []string `android:"arch_variant"`
152 System_shared_libs []string `android:"arch_variant"`
153
154 Export_shared_lib_headers []string `android:"arch_variant"`
155 Export_static_lib_headers []string `android:"arch_variant"`
Jiyong Parka90ca002019-10-07 15:47:24 +0900156
157 Apex_available []string `android:"arch_variant"`
Colin Crosse1bb5d02019-09-24 14:55:04 -0700158}
159
Colin Crossa48ab5b2017-02-14 15:28:44 -0800160type LibraryMutatedProperties struct {
Colin Crossb916a382016-07-29 17:28:03 -0700161 // Build a static variant
162 BuildStatic bool `blueprint:"mutated"`
163 // Build a shared variant
164 BuildShared bool `blueprint:"mutated"`
165 // This variant is shared
166 VariantIsShared bool `blueprint:"mutated"`
167 // This variant is static
168 VariantIsStatic bool `blueprint:"mutated"`
Jiyong Park7ed9de32018-10-15 22:25:07 +0900169
170 // This variant is a stubs lib
171 BuildStubs bool `blueprint:"mutated"`
172 // Version of the stubs lib
173 StubsVersion string `blueprint:"mutated"`
Colin Crossd1f898e2020-08-18 18:35:15 -0700174 // List of all stubs versions associated with an implementation lib
175 AllStubsVersions []string `blueprint:"mutated"`
Colin Crossb916a382016-07-29 17:28:03 -0700176}
177
178type FlagExporterProperties struct {
179 // list of directories relative to the Blueprints file that will
Dan Willemsen273af7f2016-11-03 15:53:42 -0700180 // be added to the include path (using -I) for this module and any module that links
Colin Cross5d195602017-10-17 16:15:50 -0700181 // against this module. Directories listed in export_include_dirs do not need to be
182 // listed in local_include_dirs.
Colin Crossb916a382016-07-29 17:28:03 -0700183 Export_include_dirs []string `android:"arch_variant"`
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700184
Jiyong Park73c54ee2019-10-22 20:31:18 +0900185 // list of directories that will be added to the system include path
186 // using -isystem for this module and any module that links against this module.
187 Export_system_include_dirs []string `android:"arch_variant"`
188
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700189 Target struct {
Justin Yun63e9ec72020-10-29 16:49:43 +0900190 Vendor, Product struct {
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700191 // list of exported include directories, like
Justin Yun63e9ec72020-10-29 16:49:43 +0900192 // export_include_dirs, that will be applied to
193 // vendor or product variant of this library.
194 // This will overwrite any other declarations.
Steven Morelandb21df8f2018-01-05 14:42:54 -0800195 Override_export_include_dirs []string
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700196 }
197 }
Colin Cross4d9c2d12016-07-29 12:48:20 -0700198}
199
200func init() {
Paul Duffin6c26dc72019-12-19 15:02:40 +0000201 RegisterLibraryBuildComponents(android.InitRegistrationContext)
202}
203
204func RegisterLibraryBuildComponents(ctx android.RegistrationContext) {
205 ctx.RegisterModuleType("cc_library_static", LibraryStaticFactory)
206 ctx.RegisterModuleType("cc_library_shared", LibrarySharedFactory)
207 ctx.RegisterModuleType("cc_library", LibraryFactory)
208 ctx.RegisterModuleType("cc_library_host_static", LibraryHostStaticFactory)
209 ctx.RegisterModuleType("cc_library_host_shared", LibraryHostSharedFactory)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700210}
211
Patrice Arruda83c89e02019-03-25 15:32:39 -0700212// cc_library creates both static and/or shared libraries for a device and/or
213// host. By default, a cc_library has a single variant that targets the device.
214// Specifying `host_supported: true` also creates a library that targets the
215// host.
Steven Morelandf9e62162017-11-02 17:00:50 -0700216func LibraryFactory() android.Module {
Colin Crossab3b7322016-12-09 14:46:15 -0800217 module, _ := NewLibrary(android.HostAndDeviceSupported)
Paul Duffina0843f62019-12-13 19:50:38 +0000218 // Can be used as both a static and a shared library.
219 module.sdkMemberTypes = []android.SdkMemberType{
220 sharedLibrarySdkMemberType,
221 staticLibrarySdkMemberType,
Paul Duffin9b76c0b2020-03-12 10:24:35 +0000222 staticAndSharedLibrarySdkMemberType,
Paul Duffina0843f62019-12-13 19:50:38 +0000223 }
Colin Cross4d9c2d12016-07-29 12:48:20 -0700224 return module.Init()
225}
226
Patrice Arruda83c89e02019-03-25 15:32:39 -0700227// cc_library_static creates a static library for a device and/or host binary.
Steven Morelandf9e62162017-11-02 17:00:50 -0700228func LibraryStaticFactory() android.Module {
Colin Crossab3b7322016-12-09 14:46:15 -0800229 module, library := NewLibrary(android.HostAndDeviceSupported)
230 library.BuildOnlyStatic()
Paul Duffina0843f62019-12-13 19:50:38 +0000231 module.sdkMemberTypes = []android.SdkMemberType{staticLibrarySdkMemberType}
Colin Cross4d9c2d12016-07-29 12:48:20 -0700232 return module.Init()
233}
234
Patrice Arruda83c89e02019-03-25 15:32:39 -0700235// cc_library_shared creates a shared library for a device and/or host.
Steven Morelandf9e62162017-11-02 17:00:50 -0700236func LibrarySharedFactory() android.Module {
Colin Crossab3b7322016-12-09 14:46:15 -0800237 module, library := NewLibrary(android.HostAndDeviceSupported)
238 library.BuildOnlyShared()
Paul Duffina0843f62019-12-13 19:50:38 +0000239 module.sdkMemberTypes = []android.SdkMemberType{sharedLibrarySdkMemberType}
Colin Cross4d9c2d12016-07-29 12:48:20 -0700240 return module.Init()
241}
242
Patrice Arruda83c89e02019-03-25 15:32:39 -0700243// cc_library_host_static creates a static library that is linkable to a host
244// binary.
Steven Morelandf9e62162017-11-02 17:00:50 -0700245func LibraryHostStaticFactory() android.Module {
Colin Crossab3b7322016-12-09 14:46:15 -0800246 module, library := NewLibrary(android.HostSupported)
247 library.BuildOnlyStatic()
Paul Duffina0843f62019-12-13 19:50:38 +0000248 module.sdkMemberTypes = []android.SdkMemberType{staticLibrarySdkMemberType}
Colin Cross4d9c2d12016-07-29 12:48:20 -0700249 return module.Init()
250}
251
Patrice Arruda83c89e02019-03-25 15:32:39 -0700252// cc_library_host_shared creates a shared library that is usable on a host.
Steven Morelandf9e62162017-11-02 17:00:50 -0700253func LibraryHostSharedFactory() android.Module {
Colin Crossab3b7322016-12-09 14:46:15 -0800254 module, library := NewLibrary(android.HostSupported)
255 library.BuildOnlyShared()
Paul Duffina0843f62019-12-13 19:50:38 +0000256 module.sdkMemberTypes = []android.SdkMemberType{sharedLibrarySdkMemberType}
Colin Cross4d9c2d12016-07-29 12:48:20 -0700257 return module.Init()
258}
259
Chris Parsons3c27ca32020-11-20 12:42:07 -0500260// flagExporter is a separated portion of libraryDecorator pertaining to exported
261// include paths and flags. Keeping this dependency-related information separate
262// from the rest of library information is helpful in keeping data more structured
263// and explicit.
Colin Cross4d9c2d12016-07-29 12:48:20 -0700264type flagExporter struct {
265 Properties FlagExporterProperties
266
Chris Parsons3c27ca32020-11-20 12:42:07 -0500267 dirs android.Paths // Include directories to be included with -I
268 systemDirs android.Paths // System include directories to be included with -isystem
269 flags []string // Exported raw flags.
Inseob Kim69378442019-06-03 19:10:47 +0900270 deps android.Paths
Inseob Kimd110f872019-12-06 13:15:38 +0900271 headers android.Paths
Colin Cross4d9c2d12016-07-29 12:48:20 -0700272}
273
Chris Parsons3c27ca32020-11-20 12:42:07 -0500274// exportedIncludes returns the effective include paths for this module and
275// any module that links against this module. This is obtained from
276// the export_include_dirs property in the appropriate target stanza.
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700277func (f *flagExporter) exportedIncludes(ctx ModuleContext) android.Paths {
Justin Yun6977e8a2020-10-29 18:24:11 +0900278 if ctx.inVendor() && f.Properties.Target.Vendor.Override_export_include_dirs != nil {
Steven Morelandb21df8f2018-01-05 14:42:54 -0800279 return android.PathsForModuleSrc(ctx, f.Properties.Target.Vendor.Override_export_include_dirs)
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700280 }
Justin Yun6977e8a2020-10-29 18:24:11 +0900281 if ctx.inProduct() && f.Properties.Target.Product.Override_export_include_dirs != nil {
282 return android.PathsForModuleSrc(ctx, f.Properties.Target.Product.Override_export_include_dirs)
283 }
284 return android.PathsForModuleSrc(ctx, f.Properties.Export_include_dirs)
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700285}
286
Chris Parsons3c27ca32020-11-20 12:42:07 -0500287// exportIncludes registers the include directories and system include directories to be exported
288// transitively to modules depending on this module.
Inseob Kim69378442019-06-03 19:10:47 +0900289func (f *flagExporter) exportIncludes(ctx ModuleContext) {
Jiyong Park74955042019-10-22 20:19:51 +0900290 f.dirs = append(f.dirs, f.exportedIncludes(ctx)...)
Jiyong Park73c54ee2019-10-22 20:31:18 +0900291 f.systemDirs = append(f.systemDirs, android.PathsForModuleSrc(ctx, f.Properties.Export_system_include_dirs)...)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700292}
293
Chris Parsons3c27ca32020-11-20 12:42:07 -0500294// exportIncludesAsSystem registers the include directories and system include directories to be
295// exported transitively both as system include directories to modules depending on this module.
Inseob Kim69378442019-06-03 19:10:47 +0900296func (f *flagExporter) exportIncludesAsSystem(ctx ModuleContext) {
Jiyong Park73c54ee2019-10-22 20:31:18 +0900297 // all dirs are force exported as system
Jiyong Park74955042019-10-22 20:19:51 +0900298 f.systemDirs = append(f.systemDirs, f.exportedIncludes(ctx)...)
Jiyong Park73c54ee2019-10-22 20:31:18 +0900299 f.systemDirs = append(f.systemDirs, android.PathsForModuleSrc(ctx, f.Properties.Export_system_include_dirs)...)
Inseob Kim69378442019-06-03 19:10:47 +0900300}
301
Chris Parsons3c27ca32020-11-20 12:42:07 -0500302// reexportDirs registers the given directories as include directories to be exported transitively
303// to modules depending on this module.
Jiyong Park74955042019-10-22 20:19:51 +0900304func (f *flagExporter) reexportDirs(dirs ...android.Path) {
Inseob Kim69378442019-06-03 19:10:47 +0900305 f.dirs = append(f.dirs, dirs...)
306}
307
Chris Parsons3c27ca32020-11-20 12:42:07 -0500308// reexportSystemDirs registers the given directories as system include directories
309// to be exported transitively to modules depending on this module.
Jiyong Park74955042019-10-22 20:19:51 +0900310func (f *flagExporter) reexportSystemDirs(dirs ...android.Path) {
Inseob Kim69378442019-06-03 19:10:47 +0900311 f.systemDirs = append(f.systemDirs, dirs...)
312}
313
Chris Parsons3c27ca32020-11-20 12:42:07 -0500314// reexportFlags registers the flags to be exported transitively to modules depending on this
315// module.
Inseob Kim69378442019-06-03 19:10:47 +0900316func (f *flagExporter) reexportFlags(flags ...string) {
Jaewoong Jung3aff5782020-02-11 07:54:35 -0800317 if android.PrefixInList(flags, "-I") || android.PrefixInList(flags, "-isystem") {
318 panic(fmt.Errorf("Exporting invalid flag %q: "+
319 "use reexportDirs or reexportSystemDirs to export directories", flag))
Inseob Kim69378442019-06-03 19:10:47 +0900320 }
Colin Cross4d9c2d12016-07-29 12:48:20 -0700321 f.flags = append(f.flags, flags...)
322}
323
Inseob Kim69378442019-06-03 19:10:47 +0900324func (f *flagExporter) reexportDeps(deps ...android.Path) {
325 f.deps = append(f.deps, deps...)
326}
327
Inseob Kimd110f872019-12-06 13:15:38 +0900328// addExportedGeneratedHeaders does nothing but collects generated header files.
329// This can be differ to exportedDeps which may contain phony files to minimize ninja.
330func (f *flagExporter) addExportedGeneratedHeaders(headers ...android.Path) {
331 f.headers = append(f.headers, headers...)
332}
333
Colin Cross0de8a1e2020-09-18 14:15:30 -0700334func (f *flagExporter) setProvider(ctx android.ModuleContext) {
335 ctx.SetProvider(FlagExporterInfoProvider, FlagExporterInfo{
336 IncludeDirs: f.dirs,
337 SystemIncludeDirs: f.systemDirs,
338 Flags: f.flags,
339 Deps: f.deps,
340 GeneratedHeaders: f.headers,
341 })
Inseob Kim69378442019-06-03 19:10:47 +0900342}
343
Colin Crossb916a382016-07-29 17:28:03 -0700344// libraryDecorator wraps baseCompiler, baseLinker and baseInstaller to provide library-specific
345// functionality: static vs. shared linkage, reusing object files for shared libraries
346type libraryDecorator struct {
Colin Crossa48ab5b2017-02-14 15:28:44 -0800347 Properties LibraryProperties
Colin Crosse1bb5d02019-09-24 14:55:04 -0700348 StaticProperties StaticProperties
349 SharedProperties SharedProperties
Colin Crossa48ab5b2017-02-14 15:28:44 -0800350 MutatedProperties LibraryMutatedProperties
Colin Cross4d9c2d12016-07-29 12:48:20 -0700351
352 // For reusing static library objects for shared library
Inseob Kim69378442019-06-03 19:10:47 +0900353 reuseObjects Objects
Colin Cross10d22312017-05-03 11:01:58 -0700354
Colin Cross26c34ed2016-09-30 17:10:16 -0700355 // table-of-contents file to optimize out relinking when possible
356 tocFile android.OptionalPath
Colin Cross4d9c2d12016-07-29 12:48:20 -0700357
Colin Cross4d9c2d12016-07-29 12:48:20 -0700358 flagExporter
Thiébaud Weksteend4587452020-08-19 14:53:01 +0200359 stripper Stripper
Colin Cross4d9c2d12016-07-29 12:48:20 -0700360
Colin Cross4d9c2d12016-07-29 12:48:20 -0700361 // For whole_static_libs
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700362 objects Objects
Colin Cross4d9c2d12016-07-29 12:48:20 -0700363
364 // Uses the module's name if empty, but can be overridden. Does not include
365 // shlib suffix.
366 libName string
Colin Crossb916a382016-07-29 17:28:03 -0700367
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800368 sabi *sabi
369
Dan Willemsen581341d2017-02-09 16:16:31 -0800370 // Output archive of gcno coverage information files
371 coverageOutputFile android.OptionalPath
372
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800373 // linked Source Abi Dump
374 sAbiOutputFile android.OptionalPath
375
376 // Source Abi Diff
377 sAbiDiff android.OptionalPath
378
Colin Cross0875c522017-11-28 17:34:01 -0800379 // Location of the static library in the sysroot. Empty if the library is
380 // not included in the NDK.
381 ndkSysrootPath android.Path
382
Colin Crossb60190a2018-09-04 16:28:17 -0700383 // Location of the linked, unstripped library for shared libraries
384 unstrippedOutputFile android.Path
385
Dan Willemsen569edc52018-11-19 09:33:29 -0800386 // Location of the file that should be copied to dist dir when requested
Jingwen Chen40fd90a2020-06-15 05:24:19 +0000387 distFile android.Path
Dan Willemsen569edc52018-11-19 09:33:29 -0800388
Colin Cross8e21aa52020-09-28 18:28:02 -0700389 versionScriptPath android.OptionalPath
Jiyong Park7ed9de32018-10-15 22:25:07 +0900390
Jaewoong Jung18aefc12020-12-21 09:11:10 -0800391 postInstallCmds []string
Jiyong Parkf1194352019-02-25 11:05:47 +0900392
Vic Yangefd249e2018-11-12 20:19:56 -0800393 // If useCoreVariant is true, the vendor variant of a VNDK library is
394 // not installed.
Vic Yangd92090f2020-01-08 14:32:28 -0800395 useCoreVariant bool
396 checkSameCoreVariant bool
Vic Yangefd249e2018-11-12 20:19:56 -0800397
Colin Cross5ec407b2020-09-30 11:41:33 -0700398 skipAPIDefine bool
399
Martin Stjernholmc5dd4f72020-04-01 20:38:01 +0100400 // Decorated interfaces
Colin Crossb916a382016-07-29 17:28:03 -0700401 *baseCompiler
402 *baseLinker
403 *baseInstaller
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900404
405 collectedSnapshotHeaders android.Paths
406}
407
408// collectHeadersForSnapshot collects all exported headers from library.
409// It globs header files in the source tree for exported include directories,
410// and tracks generated header files separately.
411//
412// This is to be called from GenerateAndroidBuildActions, and then collected
413// header files can be retrieved by snapshotHeaders().
414func (l *libraryDecorator) collectHeadersForSnapshot(ctx android.ModuleContext) {
415 ret := android.Paths{}
416
417 // Headers in the source tree should be globbed. On the contrast, generated headers
418 // can't be globbed, and they should be manually collected.
419 // So, we first filter out intermediate directories (which contains generated headers)
420 // from exported directories, and then glob headers under remaining directories.
Colin Cross0de8a1e2020-09-18 14:15:30 -0700421 for _, path := range append(android.CopyOfPaths(l.flagExporter.dirs), l.flagExporter.systemDirs...) {
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900422 dir := path.String()
423 // Skip if dir is for generated headers
424 if strings.HasPrefix(dir, android.PathForOutput(ctx).String()) {
425 continue
426 }
Inseob Kim04f2d6a2020-05-29 22:30:58 +0900427 // libeigen wrongly exports the root directory "external/eigen". But only two
428 // subdirectories "Eigen" and "unsupported" contain exported header files. Even worse
429 // some of them have no extension. So we need special treatment for libeigen in order
430 // to glob correctly.
431 if dir == "external/eigen" {
432 // Only these two directories contains exported headers.
433 for _, subdir := range []string{"Eigen", "unsupported/Eigen"} {
434 glob, err := ctx.GlobWithDeps("external/eigen/"+subdir+"/**/*", nil)
435 if err != nil {
436 ctx.ModuleErrorf("glob failed: %#v", err)
437 return
438 }
439 for _, header := range glob {
440 if strings.HasSuffix(header, "/") {
441 continue
442 }
443 ext := filepath.Ext(header)
444 if ext != "" && ext != ".h" {
445 continue
446 }
447 ret = append(ret, android.PathForSource(ctx, header))
448 }
449 }
450 continue
451 }
Colin Crossec118d02021-01-22 18:05:59 +0000452 glob, err := ctx.GlobWithDeps(dir+"/**/*", nil)
453 if err != nil {
454 ctx.ModuleErrorf("glob failed: %#v", err)
455 return
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900456 }
Colin Crossec118d02021-01-22 18:05:59 +0000457 isLibcxx := strings.HasPrefix(dir, "external/libcxx/include")
458 j := 0
459 for i, header := range glob {
460 if isLibcxx {
461 // Glob all files under this special directory, because of C++ headers with no
462 // extension.
463 if !strings.HasSuffix(header, "/") {
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900464 continue
465 }
Colin Crossec118d02021-01-22 18:05:59 +0000466 } else {
467 // Filter out only the files with extensions that are headers.
468 found := false
469 for _, ext := range headerExts {
470 if strings.HasSuffix(header, ext) {
471 found = true
472 break
473 }
474 }
475 if !found {
476 continue
477 }
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900478 }
Colin Crossec118d02021-01-22 18:05:59 +0000479 if i != j {
480 glob[j] = glob[i]
481 }
482 j++
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900483 }
484 }
485
486 // Collect generated headers
Colin Cross0de8a1e2020-09-18 14:15:30 -0700487 for _, header := range append(android.CopyOfPaths(l.flagExporter.headers), l.flagExporter.deps...) {
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900488 // TODO(b/148123511): remove exportedDeps after cleaning up genrule
489 if strings.HasSuffix(header.Base(), "-phony") {
490 continue
491 }
492 ret = append(ret, header)
493 }
494
495 l.collectedSnapshotHeaders = ret
496}
497
498// This returns all exported header files, both generated ones and headers from source tree.
499// collectHeadersForSnapshot() must be called before calling this.
500func (l *libraryDecorator) snapshotHeaders() android.Paths {
501 if l.collectedSnapshotHeaders == nil {
502 panic("snapshotHeaders() must be called after collectHeadersForSnapshot()")
503 }
504 return l.collectedSnapshotHeaders
Colin Cross4d9c2d12016-07-29 12:48:20 -0700505}
506
Chris Parsons3c27ca32020-11-20 12:42:07 -0500507// linkerProps returns the list of properties structs relevant for this library. (For example, if
508// the library is cc_shared_library, then static-library properties are omitted.)
Colin Crossb916a382016-07-29 17:28:03 -0700509func (library *libraryDecorator) linkerProps() []interface{} {
510 var props []interface{}
511 props = append(props, library.baseLinker.linkerProps()...)
Colin Crosse1bb5d02019-09-24 14:55:04 -0700512 props = append(props,
Colin Cross4d9c2d12016-07-29 12:48:20 -0700513 &library.Properties,
Colin Crossa48ab5b2017-02-14 15:28:44 -0800514 &library.MutatedProperties,
Colin Cross4d9c2d12016-07-29 12:48:20 -0700515 &library.flagExporter.Properties,
Colin Cross22f37952018-09-05 10:43:13 -0700516 &library.stripper.StripProperties)
Colin Crosse1bb5d02019-09-24 14:55:04 -0700517
518 if library.MutatedProperties.BuildShared {
519 props = append(props, &library.SharedProperties)
520 }
521 if library.MutatedProperties.BuildStatic {
522 props = append(props, &library.StaticProperties)
523 }
524
525 return props
Colin Cross4d9c2d12016-07-29 12:48:20 -0700526}
527
Chris Parsons3c27ca32020-11-20 12:42:07 -0500528// linkerFlags takes a Flags struct and augments it to contain linker flags that are defined by this
529// library, or that are implied by attributes of this library (such as whether this library is a
530// shared library).
Colin Crossb916a382016-07-29 17:28:03 -0700531func (library *libraryDecorator) linkerFlags(ctx ModuleContext, flags Flags) Flags {
Colin Cross42742b82016-08-01 13:20:05 -0700532 flags = library.baseLinker.linkerFlags(ctx, flags)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700533
Colin Crossb916a382016-07-29 17:28:03 -0700534 // MinGW spits out warnings about -fPIC even for -fpie?!) being ignored because
535 // all code is position independent, and then those warnings get promoted to
536 // errors.
Colin Cross3edeee12017-04-04 12:59:48 -0700537 if !ctx.Windows() {
Colin Cross4af21ed2019-11-04 09:37:55 -0800538 flags.Global.CFlags = append(flags.Global.CFlags, "-fPIC")
Colin Crossb916a382016-07-29 17:28:03 -0700539 }
540
541 if library.static() {
Colin Cross4af21ed2019-11-04 09:37:55 -0800542 flags.Local.CFlags = append(flags.Local.CFlags, library.StaticProperties.Static.Cflags...)
Colin Crossa48ab5b2017-02-14 15:28:44 -0800543 } else if library.shared() {
Colin Cross4af21ed2019-11-04 09:37:55 -0800544 flags.Local.CFlags = append(flags.Local.CFlags, library.SharedProperties.Shared.Cflags...)
Colin Crossb916a382016-07-29 17:28:03 -0700545 }
546
Colin Crossa48ab5b2017-02-14 15:28:44 -0800547 if library.shared() {
Colin Cross4d9c2d12016-07-29 12:48:20 -0700548 libName := library.getLibName(ctx)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700549 var f []string
Dan Willemsen01a405a2016-06-13 17:19:03 -0700550 if ctx.toolchain().Bionic() {
Colin Cross4d9c2d12016-07-29 12:48:20 -0700551 f = append(f,
552 "-nostdlib",
553 "-Wl,--gc-sections",
554 )
555 }
556
557 if ctx.Darwin() {
558 f = append(f,
559 "-dynamiclib",
560 "-single_module",
Colin Cross4d9c2d12016-07-29 12:48:20 -0700561 "-install_name @rpath/"+libName+flags.Toolchain.ShlibSuffix(),
562 )
Colin Cross7863cf52016-10-20 10:47:21 -0700563 if ctx.Arch().ArchType == android.X86 {
564 f = append(f,
565 "-read_only_relocs suppress",
566 )
567 }
Colin Cross4d9c2d12016-07-29 12:48:20 -0700568 } else {
Josh Gao75a50a22019-06-07 17:58:59 -0700569 f = append(f, "-shared")
570 if !ctx.Windows() {
571 f = append(f, "-Wl,-soname,"+libName+flags.Toolchain.ShlibSuffix())
572 }
Colin Cross4d9c2d12016-07-29 12:48:20 -0700573 }
574
Colin Cross4af21ed2019-11-04 09:37:55 -0800575 flags.Global.LdFlags = append(flags.Global.LdFlags, f...)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700576 }
577
578 return flags
579}
580
Chris Parsons3c27ca32020-11-20 12:42:07 -0500581// compilerFlags takes a Flags and augments it to contain compile flags from global values,
582// per-target values, module type values, per-module Blueprints properties, extra flags from
583// `flags`, and generated sources from `deps`.
Colin Crossf18e1102017-11-16 14:33:08 -0800584func (library *libraryDecorator) compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags {
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700585 exportIncludeDirs := library.flagExporter.exportedIncludes(ctx)
Dan Willemsen273af7f2016-11-03 15:53:42 -0700586 if len(exportIncludeDirs) > 0 {
Colin Crossdad8c952017-04-26 14:55:27 -0700587 f := includeDirsToFlags(exportIncludeDirs)
Colin Cross4af21ed2019-11-04 09:37:55 -0800588 flags.Local.CommonFlags = append(flags.Local.CommonFlags, f)
589 flags.Local.YasmFlags = append(flags.Local.YasmFlags, f)
Dan Willemsen273af7f2016-11-03 15:53:42 -0700590 }
591
Jiyong Park7ed9de32018-10-15 22:25:07 +0900592 flags = library.baseCompiler.compilerFlags(ctx, flags, deps)
Colin Cross127bb8b2020-12-16 16:46:01 -0800593 if ctx.IsLlndk() {
594 // LLNDK libraries ignore most of the properties on the cc_library and use the
595 // LLNDK-specific properties instead.
596 // Wipe all the module-local properties, leaving only the global properties.
597 flags.Local = LocalOrGlobalFlags{}
598 }
Jiyong Park7ed9de32018-10-15 22:25:07 +0900599 if library.buildStubs() {
Jiyong Park64379952018-12-13 18:37:29 +0900600 // Remove -include <file> when compiling stubs. Otherwise, the force included
601 // headers might cause conflicting types error with the symbols in the
602 // generated stubs source code. e.g.
603 // double acos(double); // in header
604 // void acos() {} // in the generated source code
605 removeInclude := func(flags []string) []string {
606 ret := flags[:0]
607 for _, f := range flags {
608 if strings.HasPrefix(f, "-include ") {
609 continue
610 }
611 ret = append(ret, f)
612 }
613 return ret
614 }
Colin Cross4af21ed2019-11-04 09:37:55 -0800615 flags.Local.CommonFlags = removeInclude(flags.Local.CommonFlags)
616 flags.Local.CFlags = removeInclude(flags.Local.CFlags)
Jiyong Park64379952018-12-13 18:37:29 +0900617
Jiyong Park7ed9de32018-10-15 22:25:07 +0900618 flags = addStubLibraryCompilerFlags(flags)
619 }
620 return flags
Dan Willemsen273af7f2016-11-03 15:53:42 -0700621}
622
Yo Chiang2bbadfa2020-12-14 11:42:16 +0800623func (library *libraryDecorator) headerAbiCheckerEnabled() bool {
624 return Bool(library.Properties.Header_abi_checker.Enabled)
Hsin-Yi Chen53489642019-07-31 17:10:45 +0800625}
626
Yo Chiang2bbadfa2020-12-14 11:42:16 +0800627func (library *libraryDecorator) headerAbiCheckerExplicitlyDisabled() bool {
628 return !BoolDefault(library.Properties.Header_abi_checker.Enabled, true)
Logan Chien41eabe62019-04-10 13:33:58 +0800629}
630
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700631func (library *libraryDecorator) compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects {
Colin Cross127bb8b2020-12-16 16:46:01 -0800632 if ctx.IsLlndk() {
633 // This is the vendor variant of an LLNDK library, build the LLNDK stubs.
634 vndkVer := ctx.Module().(*Module).VndkVersion()
635 if !inList(vndkVer, ctx.Config().PlatformVersionActiveCodenames()) || vndkVer == "" {
636 // For non-enforcing devices, vndkVer is empty. Use "current" in that case, too.
637 vndkVer = "current"
638 }
639 if library.stubsVersion() != "" {
640 vndkVer = library.stubsVersion()
641 }
642 objs, versionScript := compileStubLibrary(ctx, flags, String(library.Properties.Llndk.Symbol_file), vndkVer, "--llndk")
643 if !Bool(library.Properties.Llndk.Unversioned) {
644 library.versionScriptPath = android.OptionalPathForPath(versionScript)
645 }
646 return objs
647 }
Jiyong Park7ed9de32018-10-15 22:25:07 +0900648 if library.buildStubs() {
Jiyong Park3fd0baf2018-12-07 16:25:39 +0900649 objs, versionScript := compileStubLibrary(ctx, flags, String(library.Properties.Stubs.Symbol_file), library.MutatedProperties.StubsVersion, "--apex")
Colin Cross8e21aa52020-09-28 18:28:02 -0700650 library.versionScriptPath = android.OptionalPathForPath(versionScript)
Jiyong Park7ed9de32018-10-15 22:25:07 +0900651 return objs
652 }
653
Colin Cross5950f382016-12-13 12:50:57 -0800654 if !library.buildShared() && !library.buildStatic() {
655 if len(library.baseCompiler.Properties.Srcs) > 0 {
656 ctx.PropertyErrorf("srcs", "cc_library_headers must not have any srcs")
657 }
Colin Crosse1bb5d02019-09-24 14:55:04 -0700658 if len(library.StaticProperties.Static.Srcs) > 0 {
Colin Cross5950f382016-12-13 12:50:57 -0800659 ctx.PropertyErrorf("static.srcs", "cc_library_headers must not have any srcs")
660 }
Colin Crosse1bb5d02019-09-24 14:55:04 -0700661 if len(library.SharedProperties.Shared.Srcs) > 0 {
Colin Cross5950f382016-12-13 12:50:57 -0800662 ctx.PropertyErrorf("shared.srcs", "cc_library_headers must not have any srcs")
663 }
664 return Objects{}
665 }
Yo Chiang2bbadfa2020-12-14 11:42:16 +0800666 if library.sabi.shouldCreateSourceAbiDump() {
Jayant Chowdharya4fce192017-09-06 13:10:03 -0700667 exportIncludeDirs := library.flagExporter.exportedIncludes(ctx)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800668 var SourceAbiFlags []string
669 for _, dir := range exportIncludeDirs.Strings() {
Jayant Chowdhary715cac32017-04-20 06:53:59 -0700670 SourceAbiFlags = append(SourceAbiFlags, "-I"+dir)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800671 }
Inseob Kim69378442019-06-03 19:10:47 +0900672 for _, reexportedInclude := range library.sabi.Properties.ReexportedIncludes {
673 SourceAbiFlags = append(SourceAbiFlags, "-I"+reexportedInclude)
Jayant Chowdhary715cac32017-04-20 06:53:59 -0700674 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800675 flags.SAbiFlags = SourceAbiFlags
Jaewoong Jung18aefc12020-12-21 09:11:10 -0800676 totalLength := len(library.baseCompiler.Properties.Srcs) + len(deps.GeneratedSources) +
Colin Crosse1bb5d02019-09-24 14:55:04 -0700677 len(library.SharedProperties.Shared.Srcs) + len(library.StaticProperties.Static.Srcs)
Jaewoong Jung18aefc12020-12-21 09:11:10 -0800678 if totalLength > 0 {
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800679 flags.SAbiDump = true
680 }
681 }
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700682 objs := library.baseCompiler.compile(ctx, flags, deps)
683 library.reuseObjects = objs
Colin Cross2f336352016-10-26 10:03:47 -0700684 buildFlags := flagsToBuilderFlags(flags)
Colin Crossb916a382016-07-29 17:28:03 -0700685
Colin Cross4d9c2d12016-07-29 12:48:20 -0700686 if library.static() {
Colin Crosse1bb5d02019-09-24 14:55:04 -0700687 srcs := android.PathsForModuleSrc(ctx, library.StaticProperties.Static.Srcs)
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700688 objs = objs.Append(compileObjs(ctx, buildFlags, android.DeviceStaticLibrary,
Pirama Arumuga Nainarf231b192018-01-23 10:49:04 -0800689 srcs, library.baseCompiler.pathDeps, library.baseCompiler.cFlagsDeps))
Colin Crossa48ab5b2017-02-14 15:28:44 -0800690 } else if library.shared() {
Colin Crosse1bb5d02019-09-24 14:55:04 -0700691 srcs := android.PathsForModuleSrc(ctx, library.SharedProperties.Shared.Srcs)
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700692 objs = objs.Append(compileObjs(ctx, buildFlags, android.DeviceSharedLibrary,
Pirama Arumuga Nainarf231b192018-01-23 10:49:04 -0800693 srcs, library.baseCompiler.pathDeps, library.baseCompiler.cFlagsDeps))
Colin Crossb916a382016-07-29 17:28:03 -0700694 }
695
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700696 return objs
Colin Crossb916a382016-07-29 17:28:03 -0700697}
698
699type libraryInterface interface {
Colin Cross3572cf72020-10-01 15:58:11 -0700700 versionedInterface
701
Colin Crossb916a382016-07-29 17:28:03 -0700702 static() bool
Inseob Kimae553032019-05-14 18:52:49 +0900703 shared() bool
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700704 objs() Objects
Colin Cross0de8a1e2020-09-18 14:15:30 -0700705 reuseObjs() Objects
Colin Cross26c34ed2016-09-30 17:10:16 -0700706 toc() android.OptionalPath
Colin Crossb916a382016-07-29 17:28:03 -0700707
708 // Returns true if the build options for the module have selected a static or shared build
709 buildStatic() bool
710 buildShared() bool
711
712 // Sets whether a specific variant is static or shared
Colin Crossa48ab5b2017-02-14 15:28:44 -0800713 setStatic()
714 setShared()
Logan Chien41eabe62019-04-10 13:33:58 +0800715
Yo Chiang2bbadfa2020-12-14 11:42:16 +0800716 // Check whether header_abi_checker is enabled or explicitly disabled.
717 headerAbiCheckerEnabled() bool
718 headerAbiCheckerExplicitlyDisabled() bool
719
Logan Chien41eabe62019-04-10 13:33:58 +0800720 // Write LOCAL_ADDITIONAL_DEPENDENCIES for ABI diff
721 androidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer)
Jiyong Parka90ca002019-10-07 15:47:24 +0900722
723 availableFor(string) bool
Colin Crossb916a382016-07-29 17:28:03 -0700724}
725
Colin Crossc88c2722020-09-28 17:32:47 -0700726type versionedInterface interface {
727 buildStubs() bool
728 setBuildStubs()
729 hasStubsVariants() bool
730 setStubsVersion(string)
731 stubsVersion() string
732
Colin Cross3572cf72020-10-01 15:58:11 -0700733 stubsVersions(ctx android.BaseMutatorContext) []string
Colin Crossc88c2722020-09-28 17:32:47 -0700734 setAllStubsVersions([]string)
735 allStubsVersions() []string
Colin Cross0477b422020-10-13 18:43:54 -0700736
737 implementationModuleName(name string) string
Colin Cross127bb8b2020-12-16 16:46:01 -0800738 hasLLNDKStubs() bool
Colin Crossc88c2722020-09-28 17:32:47 -0700739}
740
741var _ libraryInterface = (*libraryDecorator)(nil)
742var _ versionedInterface = (*libraryDecorator)(nil)
743
Justin Yun6977e8a2020-10-29 18:24:11 +0900744func (library *libraryDecorator) getLibNameHelper(baseModuleName string, inVendor bool, inProduct bool) string {
Colin Crossb916a382016-07-29 17:28:03 -0700745 name := library.libName
746 if name == "" {
dimitryd95964a2018-11-07 13:43:34 +0100747 name = String(library.Properties.Stem)
748 if name == "" {
Jooyung Han0302a842019-10-30 18:43:49 +0900749 name = baseModuleName
dimitryd95964a2018-11-07 13:43:34 +0100750 }
Colin Crossb916a382016-07-29 17:28:03 -0700751 }
752
Colin Cross0fd6a412019-08-16 14:22:10 -0700753 suffix := ""
Justin Yun6977e8a2020-10-29 18:24:11 +0900754 if inVendor {
Colin Cross0fd6a412019-08-16 14:22:10 -0700755 suffix = String(library.Properties.Target.Vendor.Suffix)
Justin Yun6977e8a2020-10-29 18:24:11 +0900756 } else if inProduct {
757 suffix = String(library.Properties.Target.Product.Suffix)
Colin Cross0fd6a412019-08-16 14:22:10 -0700758 }
759 if suffix == "" {
760 suffix = String(library.Properties.Suffix)
761 }
762
Jooyung Han0302a842019-10-30 18:43:49 +0900763 return name + suffix
764}
765
Chris Parsons3c27ca32020-11-20 12:42:07 -0500766// getLibName returns the actual canonical name of the library (the name which
767// should be passed to the linker via linker flags).
Jooyung Han0302a842019-10-30 18:43:49 +0900768func (library *libraryDecorator) getLibName(ctx BaseModuleContext) string {
Justin Yun6977e8a2020-10-29 18:24:11 +0900769 name := library.getLibNameHelper(ctx.baseModuleName(), ctx.inVendor(), ctx.inProduct())
Colin Cross0fd6a412019-08-16 14:22:10 -0700770
Ivan Lozanof9e21722020-12-02 09:00:51 -0500771 if ctx.IsVndkExt() {
Jooyung Han4c2b9422019-10-22 19:53:47 +0900772 // vndk-ext lib should have the same name with original lib
773 ctx.VisitDirectDepsWithTag(vndkExtDepTag, func(module android.Module) {
774 originalName := module.(*Module).outputFile.Path()
775 name = strings.TrimSuffix(originalName.Base(), originalName.Ext())
776 })
Logan Chienf3511742017-10-31 18:04:35 +0800777 }
778
Colin Crossb916a382016-07-29 17:28:03 -0700779 if ctx.Host() && Bool(library.Properties.Unique_host_soname) {
780 if !strings.HasSuffix(name, "-host") {
781 name = name + "-host"
782 }
783 }
784
Inseob Kim0ce291e2019-07-04 14:38:27 +0900785 return name
Colin Crossb916a382016-07-29 17:28:03 -0700786}
787
Jiyong Parkda732bd2018-11-02 18:23:15 +0900788var versioningMacroNamesListMutex sync.Mutex
789
Colin Crossb916a382016-07-29 17:28:03 -0700790func (library *libraryDecorator) linkerInit(ctx BaseModuleContext) {
791 location := InstallInSystem
Dan Albert61f32122018-07-26 14:00:24 -0700792 if library.baseLinker.sanitize.inSanitizerDir() {
Vishwath Mohan1dd88392017-03-29 22:00:18 -0700793 location = InstallInSanitizerDir
Colin Crossb916a382016-07-29 17:28:03 -0700794 }
795 library.baseInstaller.location = location
Colin Crossb916a382016-07-29 17:28:03 -0700796 library.baseLinker.linkerInit(ctx)
Jiyong Park7ed9de32018-10-15 22:25:07 +0900797 // Let baseLinker know whether this variant is for stubs or not, so that
798 // it can omit things that are not required for linking stubs.
799 library.baseLinker.dynamicProperties.BuildStubs = library.buildStubs()
Jiyong Parkda732bd2018-11-02 18:23:15 +0900800
801 if library.buildStubs() {
802 macroNames := versioningMacroNamesList(ctx.Config())
803 myName := versioningMacroName(ctx.ModuleName())
804 versioningMacroNamesListMutex.Lock()
805 defer versioningMacroNamesListMutex.Unlock()
806 if (*macroNames)[myName] == "" {
807 (*macroNames)[myName] = ctx.ModuleName()
808 } else if (*macroNames)[myName] != ctx.ModuleName() {
809 ctx.ModuleErrorf("Macro name %q for versioning conflicts with macro name from module %q ", myName, (*macroNames)[myName])
810 }
811 }
Colin Crossb916a382016-07-29 17:28:03 -0700812}
813
dimitry0345ad82018-12-05 16:28:14 +0100814func (library *libraryDecorator) compilerDeps(ctx DepsContext, deps Deps) Deps {
Colin Cross127bb8b2020-12-16 16:46:01 -0800815 if ctx.IsLlndk() {
816 // LLNDK libraries ignore most of the properties on the cc_library and use the
817 // LLNDK-specific properties instead.
818 return deps
819 }
820
dimitry0345ad82018-12-05 16:28:14 +0100821 deps = library.baseCompiler.compilerDeps(ctx, deps)
822
dimitry0345ad82018-12-05 16:28:14 +0100823 return deps
824}
825
Colin Cross37047f12016-12-13 17:06:13 -0800826func (library *libraryDecorator) linkerDeps(ctx DepsContext, deps Deps) Deps {
Colin Cross127bb8b2020-12-16 16:46:01 -0800827 if ctx.IsLlndk() {
828 // LLNDK libraries ignore most of the properties on the cc_library and use the
829 // LLNDK-specific properties instead.
830 deps.HeaderLibs = append(deps.HeaderLibs, library.Properties.Llndk.Export_llndk_headers...)
831 deps.ReexportHeaderLibHeaders = append(deps.ReexportHeaderLibHeaders,
832 library.Properties.Llndk.Export_llndk_headers...)
833 return deps
834 }
835
Dan Willemsen3a26eef2018-12-03 15:25:46 -0800836 if library.static() {
Martin Stjernholm10566a02020-03-24 01:19:52 +0000837 // Compare with nil because an empty list needs to be propagated.
Colin Crosse1bb5d02019-09-24 14:55:04 -0700838 if library.StaticProperties.Static.System_shared_libs != nil {
839 library.baseLinker.Properties.System_shared_libs = library.StaticProperties.Static.System_shared_libs
Dan Willemsen3a26eef2018-12-03 15:25:46 -0800840 }
841 } else if library.shared() {
Martin Stjernholm10566a02020-03-24 01:19:52 +0000842 // Compare with nil because an empty list needs to be propagated.
Colin Crosse1bb5d02019-09-24 14:55:04 -0700843 if library.SharedProperties.Shared.System_shared_libs != nil {
844 library.baseLinker.Properties.System_shared_libs = library.SharedProperties.Shared.System_shared_libs
Dan Willemsen3a26eef2018-12-03 15:25:46 -0800845 }
846 }
847
Colin Crossb916a382016-07-29 17:28:03 -0700848 deps = library.baseLinker.linkerDeps(ctx, deps)
849
850 if library.static() {
851 deps.WholeStaticLibs = append(deps.WholeStaticLibs,
Colin Crosse1bb5d02019-09-24 14:55:04 -0700852 library.StaticProperties.Static.Whole_static_libs...)
853 deps.StaticLibs = append(deps.StaticLibs, library.StaticProperties.Static.Static_libs...)
854 deps.SharedLibs = append(deps.SharedLibs, library.StaticProperties.Static.Shared_libs...)
Colin Crosseefe9a32019-01-22 14:41:08 -0800855
Colin Crosse1bb5d02019-09-24 14:55:04 -0700856 deps.ReexportSharedLibHeaders = append(deps.ReexportSharedLibHeaders, library.StaticProperties.Static.Export_shared_lib_headers...)
857 deps.ReexportStaticLibHeaders = append(deps.ReexportStaticLibHeaders, library.StaticProperties.Static.Export_static_lib_headers...)
Colin Crossa48ab5b2017-02-14 15:28:44 -0800858 } else if library.shared() {
Dan Willemsen2e47b342016-11-17 01:02:25 -0800859 if ctx.toolchain().Bionic() && !Bool(library.baseLinker.Properties.Nocrt) {
Dan Albert92fe7402020-07-15 13:33:30 -0700860 deps.CrtBegin = "crtbegin_so"
861 deps.CrtEnd = "crtend_so"
Colin Cross4d9c2d12016-07-29 12:48:20 -0700862 }
Colin Crosse1bb5d02019-09-24 14:55:04 -0700863 deps.WholeStaticLibs = append(deps.WholeStaticLibs, library.SharedProperties.Shared.Whole_static_libs...)
864 deps.StaticLibs = append(deps.StaticLibs, library.SharedProperties.Shared.Static_libs...)
865 deps.SharedLibs = append(deps.SharedLibs, library.SharedProperties.Shared.Shared_libs...)
Colin Crosseefe9a32019-01-22 14:41:08 -0800866
Colin Crosse1bb5d02019-09-24 14:55:04 -0700867 deps.ReexportSharedLibHeaders = append(deps.ReexportSharedLibHeaders, library.SharedProperties.Shared.Export_shared_lib_headers...)
868 deps.ReexportStaticLibHeaders = append(deps.ReexportStaticLibHeaders, library.SharedProperties.Shared.Export_static_lib_headers...)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700869 }
Justin Yun6977e8a2020-10-29 18:24:11 +0900870 if ctx.inVendor() {
Jiyong Park52d25bd2017-10-13 09:17:01 +0900871 deps.WholeStaticLibs = removeListFromList(deps.WholeStaticLibs, library.baseLinker.Properties.Target.Vendor.Exclude_static_libs)
872 deps.SharedLibs = removeListFromList(deps.SharedLibs, library.baseLinker.Properties.Target.Vendor.Exclude_shared_libs)
873 deps.StaticLibs = removeListFromList(deps.StaticLibs, library.baseLinker.Properties.Target.Vendor.Exclude_static_libs)
Victor Chang51271c12019-01-30 16:02:22 +0000874 deps.ReexportSharedLibHeaders = removeListFromList(deps.ReexportSharedLibHeaders, library.baseLinker.Properties.Target.Vendor.Exclude_shared_libs)
875 deps.ReexportStaticLibHeaders = removeListFromList(deps.ReexportStaticLibHeaders, library.baseLinker.Properties.Target.Vendor.Exclude_static_libs)
Jiyong Park52d25bd2017-10-13 09:17:01 +0900876 }
Justin Yun6977e8a2020-10-29 18:24:11 +0900877 if ctx.inProduct() {
878 deps.WholeStaticLibs = removeListFromList(deps.WholeStaticLibs, library.baseLinker.Properties.Target.Product.Exclude_static_libs)
879 deps.SharedLibs = removeListFromList(deps.SharedLibs, library.baseLinker.Properties.Target.Product.Exclude_shared_libs)
880 deps.StaticLibs = removeListFromList(deps.StaticLibs, library.baseLinker.Properties.Target.Product.Exclude_static_libs)
881 deps.ReexportSharedLibHeaders = removeListFromList(deps.ReexportSharedLibHeaders, library.baseLinker.Properties.Target.Product.Exclude_shared_libs)
882 deps.ReexportStaticLibHeaders = removeListFromList(deps.ReexportStaticLibHeaders, library.baseLinker.Properties.Target.Product.Exclude_static_libs)
883 }
Jiyong Parkf9332f12018-02-01 00:54:12 +0900884 if ctx.inRecovery() {
885 deps.WholeStaticLibs = removeListFromList(deps.WholeStaticLibs, library.baseLinker.Properties.Target.Recovery.Exclude_static_libs)
886 deps.SharedLibs = removeListFromList(deps.SharedLibs, library.baseLinker.Properties.Target.Recovery.Exclude_shared_libs)
887 deps.StaticLibs = removeListFromList(deps.StaticLibs, library.baseLinker.Properties.Target.Recovery.Exclude_static_libs)
Victor Chang51271c12019-01-30 16:02:22 +0000888 deps.ReexportSharedLibHeaders = removeListFromList(deps.ReexportSharedLibHeaders, library.baseLinker.Properties.Target.Recovery.Exclude_shared_libs)
889 deps.ReexportStaticLibHeaders = removeListFromList(deps.ReexportStaticLibHeaders, library.baseLinker.Properties.Target.Recovery.Exclude_static_libs)
Jiyong Parkf9332f12018-02-01 00:54:12 +0900890 }
Yifan Hongcf4832c2020-01-21 17:04:13 -0800891 if ctx.inRamdisk() {
892 deps.WholeStaticLibs = removeListFromList(deps.WholeStaticLibs, library.baseLinker.Properties.Target.Ramdisk.Exclude_static_libs)
893 deps.SharedLibs = removeListFromList(deps.SharedLibs, library.baseLinker.Properties.Target.Ramdisk.Exclude_shared_libs)
894 deps.StaticLibs = removeListFromList(deps.StaticLibs, library.baseLinker.Properties.Target.Ramdisk.Exclude_static_libs)
895 deps.ReexportSharedLibHeaders = removeListFromList(deps.ReexportSharedLibHeaders, library.baseLinker.Properties.Target.Ramdisk.Exclude_shared_libs)
896 deps.ReexportStaticLibHeaders = removeListFromList(deps.ReexportStaticLibHeaders, library.baseLinker.Properties.Target.Ramdisk.Exclude_static_libs)
897 }
Yifan Hong6da33c22020-10-27 15:01:21 -0700898 if ctx.inVendorRamdisk() {
899 deps.WholeStaticLibs = removeListFromList(deps.WholeStaticLibs, library.baseLinker.Properties.Target.Vendor_ramdisk.Exclude_static_libs)
900 deps.SharedLibs = removeListFromList(deps.SharedLibs, library.baseLinker.Properties.Target.Vendor_ramdisk.Exclude_shared_libs)
901 deps.StaticLibs = removeListFromList(deps.StaticLibs, library.baseLinker.Properties.Target.Vendor_ramdisk.Exclude_static_libs)
902 deps.ReexportSharedLibHeaders = removeListFromList(deps.ReexportSharedLibHeaders, library.baseLinker.Properties.Target.Vendor_ramdisk.Exclude_shared_libs)
903 deps.ReexportStaticLibHeaders = removeListFromList(deps.ReexportStaticLibHeaders, library.baseLinker.Properties.Target.Vendor_ramdisk.Exclude_static_libs)
904 }
Colin Cross2383f3b2018-02-06 14:40:13 -0800905
Colin Cross4d9c2d12016-07-29 12:48:20 -0700906 return deps
907}
908
Paul Duffin13f02712020-03-06 12:30:43 +0000909func (library *libraryDecorator) linkerSpecifiedDeps(specifiedDeps specifiedDeps) specifiedDeps {
910 specifiedDeps = library.baseLinker.linkerSpecifiedDeps(specifiedDeps)
911 var properties StaticOrSharedProperties
912 if library.static() {
913 properties = library.StaticProperties.Static
914 } else if library.shared() {
915 properties = library.SharedProperties.Shared
916 }
917
918 specifiedDeps.sharedLibs = append(specifiedDeps.sharedLibs, properties.Shared_libs...)
Martin Stjernholm10566a02020-03-24 01:19:52 +0000919
920 // Must distinguish nil and [] in system_shared_libs - ensure that [] in
921 // either input list doesn't come out as nil.
922 if specifiedDeps.systemSharedLibs == nil {
923 specifiedDeps.systemSharedLibs = properties.System_shared_libs
924 } else {
925 specifiedDeps.systemSharedLibs = append(specifiedDeps.systemSharedLibs, properties.System_shared_libs...)
926 }
Paul Duffin13f02712020-03-06 12:30:43 +0000927
928 specifiedDeps.sharedLibs = android.FirstUniqueStrings(specifiedDeps.sharedLibs)
Martin Stjernholm10566a02020-03-24 01:19:52 +0000929 if len(specifiedDeps.systemSharedLibs) > 0 {
930 // Skip this if systemSharedLibs is either nil or [], to ensure they are
931 // retained.
932 specifiedDeps.systemSharedLibs = android.FirstUniqueStrings(specifiedDeps.systemSharedLibs)
933 }
Paul Duffin13f02712020-03-06 12:30:43 +0000934 return specifiedDeps
935}
936
Colin Crossb916a382016-07-29 17:28:03 -0700937func (library *libraryDecorator) linkStatic(ctx ModuleContext,
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700938 flags Flags, deps PathDeps, objs Objects) android.Path {
Colin Cross4d9c2d12016-07-29 12:48:20 -0700939
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700940 library.objects = deps.WholeStaticLibObjs.Copy()
941 library.objects = library.objects.Append(objs)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700942
Inseob Kim0ce291e2019-07-04 14:38:27 +0900943 fileName := ctx.ModuleName() + staticLibraryExtension
Colin Cross86803cf2018-02-15 14:12:26 -0800944 outputFile := android.PathForModuleOut(ctx, fileName)
Dan Willemsen581341d2017-02-09 16:16:31 -0800945 builderFlags := flagsToBuilderFlags(flags)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700946
Dan Willemsen569edc52018-11-19 09:33:29 -0800947 if Bool(library.baseLinker.Properties.Use_version_lib) {
948 if ctx.Host() {
949 versionedOutputFile := outputFile
950 outputFile = android.PathForModuleOut(ctx, "unversioned", fileName)
951 library.injectVersionSymbol(ctx, outputFile, versionedOutputFile)
952 } else {
953 versionedOutputFile := android.PathForModuleOut(ctx, "versioned", fileName)
Jingwen Chen40fd90a2020-06-15 05:24:19 +0000954 library.distFile = versionedOutputFile
Dan Willemsen569edc52018-11-19 09:33:29 -0800955 library.injectVersionSymbol(ctx, outputFile, versionedOutputFile)
956 }
Colin Cross86803cf2018-02-15 14:12:26 -0800957 }
958
Chris Parsonsbf4f55f2020-11-23 17:02:44 -0500959 transformObjToStaticLib(ctx, library.objects.objFiles, deps.WholeStaticLibsFromPrebuilts, builderFlags, outputFile, objs.tidyFiles)
Dan Willemsen581341d2017-02-09 16:16:31 -0800960
Chris Parsonsbf4f55f2020-11-23 17:02:44 -0500961 library.coverageOutputFile = transformCoverageFilesToZip(ctx, library.objects, ctx.ModuleName())
Colin Cross4d9c2d12016-07-29 12:48:20 -0700962
Colin Cross4d9c2d12016-07-29 12:48:20 -0700963 ctx.CheckbuildFile(outputFile)
964
Colin Cross649d8172020-12-10 12:30:21 -0800965 if library.static() {
966 ctx.SetProvider(StaticLibraryInfoProvider, StaticLibraryInfo{
967 StaticLibrary: outputFile,
968 ReuseObjects: library.reuseObjects,
969 Objects: library.objects,
Colin Cross0de8a1e2020-09-18 14:15:30 -0700970
Colin Cross649d8172020-12-10 12:30:21 -0800971 TransitiveStaticLibrariesForOrdering: android.NewDepSetBuilder(android.TOPOLOGICAL).
972 Direct(outputFile).
973 Transitive(deps.TranstiveStaticLibrariesForOrdering).
974 Build(),
975 })
976 }
977
978 if library.header() {
979 ctx.SetProvider(HeaderLibraryInfoProvider, HeaderLibraryInfo{})
980 }
Colin Cross0de8a1e2020-09-18 14:15:30 -0700981
Colin Cross4d9c2d12016-07-29 12:48:20 -0700982 return outputFile
983}
984
Colin Crossb916a382016-07-29 17:28:03 -0700985func (library *libraryDecorator) linkShared(ctx ModuleContext,
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700986 flags Flags, deps PathDeps, objs Objects) android.Path {
Colin Cross4d9c2d12016-07-29 12:48:20 -0700987
988 var linkerDeps android.Paths
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700989 linkerDeps = append(linkerDeps, flags.LdFlagsDeps...)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700990
Colin Cross2383f3b2018-02-06 14:40:13 -0800991 unexportedSymbols := ctx.ExpandOptionalSource(library.Properties.Unexported_symbols_list, "unexported_symbols_list")
992 forceNotWeakSymbols := ctx.ExpandOptionalSource(library.Properties.Force_symbols_not_weak_list, "force_symbols_not_weak_list")
993 forceWeakSymbols := ctx.ExpandOptionalSource(library.Properties.Force_symbols_weak_list, "force_symbols_weak_list")
Colin Cross4d9c2d12016-07-29 12:48:20 -0700994 if !ctx.Darwin() {
Colin Cross4d9c2d12016-07-29 12:48:20 -0700995 if unexportedSymbols.Valid() {
996 ctx.PropertyErrorf("unexported_symbols_list", "Only supported on Darwin")
997 }
998 if forceNotWeakSymbols.Valid() {
999 ctx.PropertyErrorf("force_symbols_not_weak_list", "Only supported on Darwin")
1000 }
1001 if forceWeakSymbols.Valid() {
1002 ctx.PropertyErrorf("force_symbols_weak_list", "Only supported on Darwin")
1003 }
1004 } else {
Colin Cross4d9c2d12016-07-29 12:48:20 -07001005 if unexportedSymbols.Valid() {
Colin Cross4af21ed2019-11-04 09:37:55 -08001006 flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,-unexported_symbols_list,"+unexportedSymbols.String())
Colin Cross4d9c2d12016-07-29 12:48:20 -07001007 linkerDeps = append(linkerDeps, unexportedSymbols.Path())
1008 }
1009 if forceNotWeakSymbols.Valid() {
Colin Cross4af21ed2019-11-04 09:37:55 -08001010 flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,-force_symbols_not_weak_list,"+forceNotWeakSymbols.String())
Colin Cross4d9c2d12016-07-29 12:48:20 -07001011 linkerDeps = append(linkerDeps, forceNotWeakSymbols.Path())
1012 }
1013 if forceWeakSymbols.Valid() {
Colin Cross4af21ed2019-11-04 09:37:55 -08001014 flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,-force_symbols_weak_list,"+forceWeakSymbols.String())
Colin Cross4d9c2d12016-07-29 12:48:20 -07001015 linkerDeps = append(linkerDeps, forceWeakSymbols.Path())
1016 }
1017 }
Colin Cross8e21aa52020-09-28 18:28:02 -07001018 if library.versionScriptPath.Valid() {
Jiyong Parkc1e7f482019-01-12 13:39:10 +09001019 linkerScriptFlags := "-Wl,--version-script," + library.versionScriptPath.String()
Colin Cross4af21ed2019-11-04 09:37:55 -08001020 flags.Local.LdFlags = append(flags.Local.LdFlags, linkerScriptFlags)
Colin Cross8e21aa52020-09-28 18:28:02 -07001021 linkerDeps = append(linkerDeps, library.versionScriptPath.Path())
Jiyong Parkc1e7f482019-01-12 13:39:10 +09001022 }
Colin Cross4d9c2d12016-07-29 12:48:20 -07001023
1024 fileName := library.getLibName(ctx) + flags.Toolchain.ShlibSuffix()
1025 outputFile := android.PathForModuleOut(ctx, fileName)
Colin Cross0de8a1e2020-09-18 14:15:30 -07001026 unstrippedOutputFile := outputFile
Colin Cross4d9c2d12016-07-29 12:48:20 -07001027
Josh Gao75a50a22019-06-07 17:58:59 -07001028 var implicitOutputs android.WritablePaths
1029 if ctx.Windows() {
1030 importLibraryPath := android.PathForModuleOut(ctx, pathtools.ReplaceExtension(fileName, "lib"))
1031
Colin Cross4af21ed2019-11-04 09:37:55 -08001032 flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,--out-implib="+importLibraryPath.String())
Josh Gao75a50a22019-06-07 17:58:59 -07001033 implicitOutputs = append(implicitOutputs, importLibraryPath)
1034 }
1035
Colin Cross4d9c2d12016-07-29 12:48:20 -07001036 builderFlags := flagsToBuilderFlags(flags)
1037
Colin Crossb496cfd2018-09-10 16:50:05 -07001038 // Optimize out relinking against shared libraries whose interface hasn't changed by
1039 // depending on a table of contents file instead of the library itself.
Colin Cross70dda7e2019-10-01 22:05:35 -07001040 tocFile := outputFile.ReplaceExtension(ctx, flags.Toolchain.ShlibSuffix()[1:]+".toc")
Colin Crossb496cfd2018-09-10 16:50:05 -07001041 library.tocFile = android.OptionalPathForPath(tocFile)
Chris Parsonsbf4f55f2020-11-23 17:02:44 -05001042 transformSharedObjectToToc(ctx, outputFile, tocFile, builderFlags)
Colin Cross89562dc2016-10-03 17:47:19 -07001043
Thiébaud Weksteend4587452020-08-19 14:53:01 +02001044 stripFlags := flagsToStripFlags(flags)
Colin Crossadc81a02020-12-14 17:01:55 -08001045 needsStrip := library.stripper.NeedsStrip(ctx)
1046 if library.buildStubs() {
1047 // No need to strip stubs libraries
1048 needsStrip = false
1049 }
1050 if needsStrip {
Yi Kongb5c34d72018-11-07 16:28:49 -08001051 if ctx.Darwin() {
Thiébaud Weksteend4587452020-08-19 14:53:01 +02001052 stripFlags.StripUseGnuStrip = true
Yi Kongb5c34d72018-11-07 16:28:49 -08001053 }
Colin Cross4d9c2d12016-07-29 12:48:20 -07001054 strippedOutputFile := outputFile
1055 outputFile = android.PathForModuleOut(ctx, "unstripped", fileName)
Thiébaud Weksteend4587452020-08-19 14:53:01 +02001056 library.stripper.StripExecutableOrSharedLib(ctx, outputFile, strippedOutputFile, stripFlags)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001057 }
Colin Crossb60190a2018-09-04 16:28:17 -07001058 library.unstrippedOutputFile = outputFile
1059
Colin Crossd7227f92019-09-05 14:26:33 -07001060 outputFile = maybeInjectBoringSSLHash(ctx, outputFile, library.Properties.Inject_bssl_hash, fileName)
Pete Bentley803e1612019-08-06 22:19:59 +01001061
Dan Willemsen569edc52018-11-19 09:33:29 -08001062 if Bool(library.baseLinker.Properties.Use_version_lib) {
1063 if ctx.Host() {
1064 versionedOutputFile := outputFile
1065 outputFile = android.PathForModuleOut(ctx, "unversioned", fileName)
1066 library.injectVersionSymbol(ctx, outputFile, versionedOutputFile)
1067 } else {
1068 versionedOutputFile := android.PathForModuleOut(ctx, "versioned", fileName)
Jingwen Chen40fd90a2020-06-15 05:24:19 +00001069 library.distFile = versionedOutputFile
Dan Willemsen569edc52018-11-19 09:33:29 -08001070
Thiébaud Weksteend4587452020-08-19 14:53:01 +02001071 if library.stripper.NeedsStrip(ctx) {
Dan Willemsen569edc52018-11-19 09:33:29 -08001072 out := android.PathForModuleOut(ctx, "versioned-stripped", fileName)
Jingwen Chen40fd90a2020-06-15 05:24:19 +00001073 library.distFile = out
Thiébaud Weksteend4587452020-08-19 14:53:01 +02001074 library.stripper.StripExecutableOrSharedLib(ctx, versionedOutputFile, out, stripFlags)
Dan Willemsen569edc52018-11-19 09:33:29 -08001075 }
1076
1077 library.injectVersionSymbol(ctx, outputFile, versionedOutputFile)
1078 }
Colin Cross86803cf2018-02-15 14:12:26 -08001079 }
1080
Jiyong Park64a44f22019-01-18 14:37:08 +09001081 sharedLibs := deps.EarlySharedLibs
1082 sharedLibs = append(sharedLibs, deps.SharedLibs...)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001083 sharedLibs = append(sharedLibs, deps.LateSharedLibs...)
1084
Jiyong Park64a44f22019-01-18 14:37:08 +09001085 linkerDeps = append(linkerDeps, deps.EarlySharedLibsDeps...)
Colin Cross26c34ed2016-09-30 17:10:16 -07001086 linkerDeps = append(linkerDeps, deps.SharedLibsDeps...)
1087 linkerDeps = append(linkerDeps, deps.LateSharedLibsDeps...)
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001088 linkerDeps = append(linkerDeps, objs.tidyFiles...)
Colin Cross26c34ed2016-09-30 17:10:16 -07001089
Colin Cross127bb8b2020-12-16 16:46:01 -08001090 if Bool(library.Properties.Sort_bss_symbols_by_size) && !library.buildStubs() {
Vic Yang6cd1be82019-06-24 16:08:48 -07001091 unsortedOutputFile := android.PathForModuleOut(ctx, "unsorted", fileName)
Chris Parsonsbf4f55f2020-11-23 17:02:44 -05001092 transformObjToDynamicBinary(ctx, objs.objFiles, sharedLibs,
Vic Yang6cd1be82019-06-24 16:08:48 -07001093 deps.StaticLibs, deps.LateStaticLibs, deps.WholeStaticLibs,
1094 linkerDeps, deps.CrtBegin, deps.CrtEnd, false, builderFlags, unsortedOutputFile, implicitOutputs)
1095
1096 symbolOrderingFile := android.PathForModuleOut(ctx, "unsorted", fileName+".symbol_order")
1097 symbolOrderingFlag := library.baseLinker.sortBssSymbolsBySize(ctx, unsortedOutputFile, symbolOrderingFile, builderFlags)
Colin Cross6d88dba2019-11-06 07:06:58 -08001098 builderFlags.localLdFlags += " " + symbolOrderingFlag
Vic Yang6cd1be82019-06-24 16:08:48 -07001099 linkerDeps = append(linkerDeps, symbolOrderingFile)
1100 }
1101
Chris Parsonsbf4f55f2020-11-23 17:02:44 -05001102 transformObjToDynamicBinary(ctx, objs.objFiles, sharedLibs,
Colin Cross4d9c2d12016-07-29 12:48:20 -07001103 deps.StaticLibs, deps.LateStaticLibs, deps.WholeStaticLibs,
Josh Gao75a50a22019-06-07 17:58:59 -07001104 linkerDeps, deps.CrtBegin, deps.CrtEnd, false, builderFlags, outputFile, implicitOutputs)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001105
Dan Willemsen581341d2017-02-09 16:16:31 -08001106 objs.coverageFiles = append(objs.coverageFiles, deps.StaticLibObjs.coverageFiles...)
1107 objs.coverageFiles = append(objs.coverageFiles, deps.WholeStaticLibObjs.coverageFiles...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001108
1109 objs.sAbiDumpFiles = append(objs.sAbiDumpFiles, deps.StaticLibObjs.sAbiDumpFiles...)
1110 objs.sAbiDumpFiles = append(objs.sAbiDumpFiles, deps.WholeStaticLibObjs.sAbiDumpFiles...)
1111
Chris Parsonsbf4f55f2020-11-23 17:02:44 -05001112 library.coverageOutputFile = transformCoverageFilesToZip(ctx, objs, library.getLibName(ctx))
Colin Cross0de8a1e2020-09-18 14:15:30 -07001113 library.linkSAbiDumpFiles(ctx, objs, fileName, unstrippedOutputFile)
Dan Willemsen581341d2017-02-09 16:16:31 -08001114
Colin Cross0de8a1e2020-09-18 14:15:30 -07001115 var staticAnalogue *StaticLibraryInfo
1116 if static := ctx.GetDirectDepsWithTag(staticVariantTag); len(static) > 0 {
1117 s := ctx.OtherModuleProvider(static[0], StaticLibraryInfoProvider).(StaticLibraryInfo)
1118 staticAnalogue = &s
1119 }
1120
1121 ctx.SetProvider(SharedLibraryInfoProvider, SharedLibraryInfo{
1122 TableOfContents: android.OptionalPathForPath(tocFile),
1123 SharedLibrary: unstrippedOutputFile,
1124 UnstrippedSharedLibrary: library.unstrippedOutputFile,
1125 CoverageSharedLibrary: library.coverageOutputFile,
1126 StaticAnalogue: staticAnalogue,
1127 })
1128
1129 stubs := ctx.GetDirectDepsWithTag(stubImplDepTag)
1130 if len(stubs) > 0 {
Chris Parsons3c27ca32020-11-20 12:42:07 -05001131 var stubsInfo []SharedStubLibrary
Colin Cross0de8a1e2020-09-18 14:15:30 -07001132 for _, stub := range stubs {
1133 stubInfo := ctx.OtherModuleProvider(stub, SharedLibraryInfoProvider).(SharedLibraryInfo)
1134 flagInfo := ctx.OtherModuleProvider(stub, FlagExporterInfoProvider).(FlagExporterInfo)
Chris Parsons3c27ca32020-11-20 12:42:07 -05001135 stubsInfo = append(stubsInfo, SharedStubLibrary{
Colin Cross31076b32020-10-23 17:22:06 -07001136 Version: moduleLibraryInterface(stub).stubsVersion(),
Colin Cross0de8a1e2020-09-18 14:15:30 -07001137 SharedLibraryInfo: stubInfo,
1138 FlagExporterInfo: flagInfo,
1139 })
1140 }
Chris Parsons3c27ca32020-11-20 12:42:07 -05001141 ctx.SetProvider(SharedLibraryStubsProvider, SharedLibraryStubsInfo{
1142 SharedStubLibraries: stubsInfo,
Colin Cross0de8a1e2020-09-18 14:15:30 -07001143
Colin Cross127bb8b2020-12-16 16:46:01 -08001144 IsLLNDK: ctx.IsLlndk(),
Colin Cross0de8a1e2020-09-18 14:15:30 -07001145 })
1146 }
1147
1148 return unstrippedOutputFile
Colin Cross4d9c2d12016-07-29 12:48:20 -07001149}
1150
Jiyong Parkaf6d8952019-01-31 12:21:23 +09001151func (library *libraryDecorator) unstrippedOutputFilePath() android.Path {
1152 return library.unstrippedOutputFile
1153}
1154
Thiébaud Weksteend4587452020-08-19 14:53:01 +02001155func (library *libraryDecorator) disableStripping() {
1156 library.stripper.StripProperties.Strip.None = BoolPtr(true)
1157}
1158
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001159func (library *libraryDecorator) nativeCoverage() bool {
1160 if library.header() || library.buildStubs() {
1161 return false
1162 }
1163 return true
1164}
1165
Jiyong Parkee9a98d2019-08-09 14:44:36 +09001166func (library *libraryDecorator) coverageOutputFilePath() android.OptionalPath {
1167 return library.coverageOutputFile
1168}
1169
Logan Chien7eefdc42018-07-11 18:10:41 +08001170func getRefAbiDumpFile(ctx ModuleContext, vndkVersion, fileName string) android.Path {
Hsin-Yi Chen27d235f2020-03-26 17:50:29 +08001171 // The logic must be consistent with classifySourceAbiDump.
Colin Cross95f1ca02020-10-29 20:47:22 -07001172 isNdk := ctx.isNdk(ctx.Config())
Colin Cross127bb8b2020-12-16 16:46:01 -08001173 isLlndkOrVndk := ctx.IsLlndkPublic() || (ctx.useVndk() && ctx.isVndk())
Logan Chien7eefdc42018-07-11 18:10:41 +08001174
Hsin-Yi Chen53489642019-07-31 17:10:45 +08001175 refAbiDumpTextFile := android.PathForVndkRefAbiDump(ctx, vndkVersion, fileName, isNdk, isLlndkOrVndk, false)
1176 refAbiDumpGzipFile := android.PathForVndkRefAbiDump(ctx, vndkVersion, fileName, isNdk, isLlndkOrVndk, true)
Logan Chien7eefdc42018-07-11 18:10:41 +08001177
1178 if refAbiDumpTextFile.Valid() {
1179 if refAbiDumpGzipFile.Valid() {
1180 ctx.ModuleErrorf(
1181 "Two reference ABI dump files are found: %q and %q. Please delete the stale one.",
1182 refAbiDumpTextFile, refAbiDumpGzipFile)
1183 return nil
1184 }
1185 return refAbiDumpTextFile.Path()
1186 }
1187 if refAbiDumpGzipFile.Valid() {
Chris Parsonsbf4f55f2020-11-23 17:02:44 -05001188 return unzipRefDump(ctx, refAbiDumpGzipFile.Path(), fileName)
Logan Chien7eefdc42018-07-11 18:10:41 +08001189 }
1190 return nil
1191}
1192
Jayant Chowdhary6ab3d842017-06-26 12:52:58 -07001193func (library *libraryDecorator) linkSAbiDumpFiles(ctx ModuleContext, objs Objects, fileName string, soFile android.Path) {
Yo Chiang2bbadfa2020-12-14 11:42:16 +08001194 if library.sabi.shouldCreateSourceAbiDump() {
Inseob Kim96f17f02020-06-09 22:05:09 +09001195 var vndkVersion string
1196
1197 if ctx.useVndk() {
1198 // For modules linking against vndk, follow its vndk version
1199 vndkVersion = ctx.Module().(*Module).VndkVersion()
1200 } else {
1201 // Regard the other modules as PLATFORM_VNDK_VERSION
1202 vndkVersion = ctx.DeviceConfig().PlatformVndkVersion()
Logan Chienf3511742017-10-31 18:04:35 +08001203 }
1204
Jayant Chowdharya4fce192017-09-06 13:10:03 -07001205 exportIncludeDirs := library.flagExporter.exportedIncludes(ctx)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001206 var SourceAbiFlags []string
1207 for _, dir := range exportIncludeDirs.Strings() {
Jayant Chowdhary715cac32017-04-20 06:53:59 -07001208 SourceAbiFlags = append(SourceAbiFlags, "-I"+dir)
1209 }
Inseob Kim69378442019-06-03 19:10:47 +09001210 for _, reexportedInclude := range library.sabi.Properties.ReexportedIncludes {
1211 SourceAbiFlags = append(SourceAbiFlags, "-I"+reexportedInclude)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001212 }
1213 exportedHeaderFlags := strings.Join(SourceAbiFlags, " ")
Chris Parsonsbf4f55f2020-11-23 17:02:44 -05001214 library.sAbiOutputFile = transformDumpToLinkedDump(ctx, objs.sAbiDumpFiles, soFile, fileName, exportedHeaderFlags,
Jiyong Parka034b832019-08-27 14:02:19 +09001215 android.OptionalPathForModuleSrc(ctx, library.symbolFileForAbiCheck(ctx)),
Logan Chiene3d7a0d2019-01-17 00:18:02 +08001216 library.Properties.Header_abi_checker.Exclude_symbol_versions,
1217 library.Properties.Header_abi_checker.Exclude_symbol_tags)
Logan Chien2f2b8902018-07-10 15:01:19 +08001218
Yo Chiang2bbadfa2020-12-14 11:42:16 +08001219 addLsdumpPath(classifySourceAbiDump(ctx) + ":" + library.sAbiOutputFile.String())
Hsin-Yi Chen53489642019-07-31 17:10:45 +08001220
Logan Chien7eefdc42018-07-11 18:10:41 +08001221 refAbiDumpFile := getRefAbiDumpFile(ctx, vndkVersion, fileName)
1222 if refAbiDumpFile != nil {
Chris Parsonsbf4f55f2020-11-23 17:02:44 -05001223 library.sAbiDiff = sourceAbiDiff(ctx, library.sAbiOutputFile.Path(),
Logan Chien2a65dda2019-10-01 15:58:07 -07001224 refAbiDumpFile, fileName, exportedHeaderFlags,
1225 Bool(library.Properties.Header_abi_checker.Check_all_apis),
Colin Cross127bb8b2020-12-16 16:46:01 -08001226 ctx.IsLlndk(), ctx.isNdk(ctx.Config()), ctx.IsVndkExt())
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001227 }
1228 }
1229}
1230
Colin Cross127bb8b2020-12-16 16:46:01 -08001231func processLLNDKHeaders(ctx ModuleContext, srcHeaderDir string, outDir android.ModuleGenPath) android.Path {
1232 srcDir := android.PathForModuleSrc(ctx, srcHeaderDir)
1233 srcFiles := ctx.GlobFiles(filepath.Join(srcDir.String(), "**/*.h"), nil)
1234
1235 var installPaths []android.WritablePath
1236 for _, header := range srcFiles {
1237 headerDir := filepath.Dir(header.String())
1238 relHeaderDir, err := filepath.Rel(srcDir.String(), headerDir)
1239 if err != nil {
1240 ctx.ModuleErrorf("filepath.Rel(%q, %q) failed: %s",
1241 srcDir.String(), headerDir, err)
1242 continue
1243 }
1244
1245 installPaths = append(installPaths, outDir.Join(ctx, relHeaderDir, header.Base()))
1246 }
1247
1248 return processHeadersWithVersioner(ctx, srcDir, outDir, srcFiles, installPaths)
1249}
1250
Chris Parsons3c27ca32020-11-20 12:42:07 -05001251// link registers actions to link this library, and sets various fields
1252// on this library to reflect information that should be exported up the build
1253// tree (for example, exported flags and include paths).
Colin Crossb916a382016-07-29 17:28:03 -07001254func (library *libraryDecorator) link(ctx ModuleContext,
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001255 flags Flags, deps PathDeps, objs Objects) android.Path {
Colin Cross4d9c2d12016-07-29 12:48:20 -07001256
Colin Cross127bb8b2020-12-16 16:46:01 -08001257 if ctx.IsLlndk() {
1258 if len(library.Properties.Llndk.Export_preprocessed_headers) > 0 {
1259 // This is the vendor variant of an LLNDK library with preprocessed headers.
1260 genHeaderOutDir := android.PathForModuleGen(ctx, "include")
1261
1262 var timestampFiles android.Paths
1263 for _, dir := range library.Properties.Llndk.Export_preprocessed_headers {
1264 timestampFiles = append(timestampFiles, processLLNDKHeaders(ctx, dir, genHeaderOutDir))
1265 }
1266
1267 if Bool(library.Properties.Llndk.Export_headers_as_system) {
1268 library.reexportSystemDirs(genHeaderOutDir)
1269 } else {
1270 library.reexportDirs(genHeaderOutDir)
1271 }
1272
1273 library.reexportDeps(timestampFiles...)
1274 }
1275
1276 if Bool(library.Properties.Llndk.Export_headers_as_system) {
1277 library.flagExporter.Properties.Export_system_include_dirs = append(
1278 library.flagExporter.Properties.Export_system_include_dirs,
1279 library.flagExporter.Properties.Export_include_dirs...)
1280 library.flagExporter.Properties.Export_include_dirs = nil
1281 }
1282 }
1283
Chris Parsons3c27ca32020-11-20 12:42:07 -05001284 // Linking this library consists of linking `deps.Objs` (.o files in dependencies
1285 // of this library), together with `objs` (.o files created by compiling this
1286 // library).
Colin Crossad59e752017-11-16 14:29:11 -08001287 objs = deps.Objs.Copy().Append(objs)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001288 var out android.Path
Colin Crossa48ab5b2017-02-14 15:28:44 -08001289 if library.static() || library.header() {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001290 out = library.linkStatic(ctx, flags, deps, objs)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001291 } else {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001292 out = library.linkShared(ctx, flags, deps, objs)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001293 }
1294
Chris Parsons3c27ca32020-11-20 12:42:07 -05001295 // Export include paths and flags to be propagated up the tree.
Inseob Kim69378442019-06-03 19:10:47 +09001296 library.exportIncludes(ctx)
1297 library.reexportDirs(deps.ReexportedDirs...)
1298 library.reexportSystemDirs(deps.ReexportedSystemDirs...)
1299 library.reexportFlags(deps.ReexportedFlags...)
1300 library.reexportDeps(deps.ReexportedDeps...)
Inseob Kimd110f872019-12-06 13:15:38 +09001301 library.addExportedGeneratedHeaders(deps.ReexportedGeneratedHeaders...)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001302
Chris Parsons3c27ca32020-11-20 12:42:07 -05001303 // Optionally export aidl headers.
Nan Zhang0007d812017-11-07 10:57:05 -08001304 if Bool(library.Properties.Aidl.Export_aidl_headers) {
Dan Willemsene1240db2016-11-03 14:28:51 -07001305 if library.baseCompiler.hasSrcExt(".aidl") {
Jiyong Park74955042019-10-22 20:19:51 +09001306 dir := android.PathForModuleGen(ctx, "aidl")
Inseob Kim69378442019-06-03 19:10:47 +09001307 library.reexportDirs(dir)
Inseob Kimd110f872019-12-06 13:15:38 +09001308
1309 // TODO: restrict to aidl deps
1310 library.reexportDeps(library.baseCompiler.pathDeps...)
1311 library.addExportedGeneratedHeaders(library.baseCompiler.pathDeps...)
Dan Willemsene1240db2016-11-03 14:28:51 -07001312 }
1313 }
1314
Chris Parsons3c27ca32020-11-20 12:42:07 -05001315 // Optionally export proto headers.
Nan Zhang0007d812017-11-07 10:57:05 -08001316 if Bool(library.Properties.Proto.Export_proto_headers) {
Dan Willemsene1240db2016-11-03 14:28:51 -07001317 if library.baseCompiler.hasSrcExt(".proto") {
Jiyong Park74955042019-10-22 20:19:51 +09001318 var includes android.Paths
Colin Cross19878da2019-03-28 14:45:07 -07001319 if flags.proto.CanonicalPathFromRoot {
Jiyong Park74955042019-10-22 20:19:51 +09001320 includes = append(includes, flags.proto.SubDir)
Colin Cross10d22312017-05-03 11:01:58 -07001321 }
Jiyong Park74955042019-10-22 20:19:51 +09001322 includes = append(includes, flags.proto.Dir)
Inseob Kim69378442019-06-03 19:10:47 +09001323 library.reexportDirs(includes...)
Inseob Kimd110f872019-12-06 13:15:38 +09001324
1325 // TODO: restrict to proto deps
1326 library.reexportDeps(library.baseCompiler.pathDeps...)
1327 library.addExportedGeneratedHeaders(library.baseCompiler.pathDeps...)
Colin Cross0c461f12016-10-20 16:11:43 -07001328 }
1329 }
1330
Inseob Kim07def122020-11-23 14:43:02 +09001331 // If the library is sysprop_library, expose either public or internal header selectively.
Inseob Kim21f26902018-09-06 00:55:20 +09001332 if library.baseCompiler.hasSrcExt(".sysprop") {
Jiyong Park74955042019-10-22 20:19:51 +09001333 dir := android.PathForModuleGen(ctx, "sysprop", "include")
Inseob Kimc0907f12019-02-08 21:00:45 +09001334 if library.Properties.Sysprop.Platform != nil {
Inseob Kimc0907f12019-02-08 21:00:45 +09001335 isOwnerPlatform := Bool(library.Properties.Sysprop.Platform)
1336
Inseob Kim07def122020-11-23 14:43:02 +09001337 // If the owner is different from the user, expose public header. That is,
1338 // 1) if the user is product (as owner can only be platform / vendor)
Inseob Kim06410042021-01-18 15:23:28 +09001339 // 2) if the owner is platform and the client is vendor
1340 // We don't care Platform -> Vendor dependency as it's already forbidden.
1341 if ctx.Device() && (ctx.ProductSpecific() || (isOwnerPlatform && ctx.inVendor())) {
Jiyong Park74955042019-10-22 20:19:51 +09001342 dir = android.PathForModuleGen(ctx, "sysprop/public", "include")
Inseob Kimc0907f12019-02-08 21:00:45 +09001343 }
1344 }
1345
Chris Parsons3c27ca32020-11-20 12:42:07 -05001346 // Add sysprop-related directories to the exported directories of this library.
Inseob Kim69378442019-06-03 19:10:47 +09001347 library.reexportDirs(dir)
1348 library.reexportDeps(library.baseCompiler.pathDeps...)
Inseob Kimd110f872019-12-06 13:15:38 +09001349 library.addExportedGeneratedHeaders(library.baseCompiler.pathDeps...)
Inseob Kim21f26902018-09-06 00:55:20 +09001350 }
1351
Chris Parsons3c27ca32020-11-20 12:42:07 -05001352 // Add stub-related flags if this library is a stub library.
Jiyong Park892a98f2020-12-14 09:20:00 +09001353 library.exportVersioningMacroIfNeeded(ctx)
Jiyong Parkda732bd2018-11-02 18:23:15 +09001354
Chris Parsons3c27ca32020-11-20 12:42:07 -05001355 // Propagate a Provider containing information about exported flags, deps, and include paths.
Colin Cross0de8a1e2020-09-18 14:15:30 -07001356 library.flagExporter.setProvider(ctx)
1357
Colin Cross4d9c2d12016-07-29 12:48:20 -07001358 return out
1359}
1360
Jiyong Park892a98f2020-12-14 09:20:00 +09001361func (library *libraryDecorator) exportVersioningMacroIfNeeded(ctx android.BaseModuleContext) {
Colin Cross127bb8b2020-12-16 16:46:01 -08001362 if library.buildStubs() && library.stubsVersion() != "" && !library.skipAPIDefine {
Jiyong Park892a98f2020-12-14 09:20:00 +09001363 name := versioningMacroName(ctx.Module().(*Module).ImplementationModuleName(ctx))
1364 ver := library.stubsVersion()
1365 library.reexportFlags("-D" + name + "=" + ver)
1366 }
1367}
1368
Chris Parsons3c27ca32020-11-20 12:42:07 -05001369// buildStatic returns true if this library should be built as a static library.
Colin Crossb916a382016-07-29 17:28:03 -07001370func (library *libraryDecorator) buildStatic() bool {
Colin Crosse1bb5d02019-09-24 14:55:04 -07001371 return library.MutatedProperties.BuildStatic &&
1372 BoolDefault(library.StaticProperties.Static.Enabled, true)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001373}
1374
Chris Parsons3c27ca32020-11-20 12:42:07 -05001375// buildShared returns true if this library should be built as a shared library.
Colin Crossb916a382016-07-29 17:28:03 -07001376func (library *libraryDecorator) buildShared() bool {
Colin Crosse1bb5d02019-09-24 14:55:04 -07001377 return library.MutatedProperties.BuildShared &&
1378 BoolDefault(library.SharedProperties.Shared.Enabled, true)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001379}
1380
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001381func (library *libraryDecorator) objs() Objects {
1382 return library.objects
Colin Cross4d9c2d12016-07-29 12:48:20 -07001383}
1384
Colin Cross0de8a1e2020-09-18 14:15:30 -07001385func (library *libraryDecorator) reuseObjs() Objects {
1386 return library.reuseObjects
Colin Cross4d9c2d12016-07-29 12:48:20 -07001387}
1388
Colin Cross26c34ed2016-09-30 17:10:16 -07001389func (library *libraryDecorator) toc() android.OptionalPath {
1390 return library.tocFile
1391}
1392
Jiyong Parkf1194352019-02-25 11:05:47 +09001393func (library *libraryDecorator) installSymlinkToRuntimeApex(ctx ModuleContext, file android.Path) {
1394 dir := library.baseInstaller.installDir(ctx)
1395 dirOnDevice := android.InstallPathToOnDevicePath(ctx, dir)
1396 target := "/" + filepath.Join("apex", "com.android.runtime", dir.Base(), "bionic", file.Base())
1397 ctx.InstallAbsoluteSymlink(dir, file.Base(), target)
Jaewoong Jung18aefc12020-12-21 09:11:10 -08001398 library.postInstallCmds = append(library.postInstallCmds, makeSymlinkCmd(dirOnDevice, file.Base(), target))
Jiyong Parkf1194352019-02-25 11:05:47 +09001399}
1400
Colin Crossb916a382016-07-29 17:28:03 -07001401func (library *libraryDecorator) install(ctx ModuleContext, file android.Path) {
Colin Crossc43ae772017-04-14 15:42:53 -07001402 if library.shared() {
Justin Yun8fe12122017-12-07 17:18:15 +09001403 if ctx.Device() && ctx.useVndk() {
Jooyung Han261e1582020-10-20 18:54:21 +09001404 // set subDir for VNDK extensions
Ivan Lozanof9e21722020-12-02 09:00:51 -05001405 if ctx.IsVndkExt() {
Jooyung Han261e1582020-10-20 18:54:21 +09001406 if ctx.isVndkSp() {
1407 library.baseInstaller.subDir = "vndk-sp"
1408 } else {
1409 library.baseInstaller.subDir = "vndk"
1410 }
1411 }
1412
Justin Yun31094b12020-12-24 16:11:23 +09001413 // In some cases we want to use core variant for VNDK-Core libs.
1414 // Skip product variant since VNDKs use only the vendor variant.
1415 if ctx.isVndk() && !ctx.isVndkSp() && !ctx.IsVndkExt() && !ctx.inProduct() {
Vic Yang1a5812a2020-01-31 10:38:40 -08001416 mayUseCoreVariant := true
1417
1418 if ctx.mustUseVendorVariant() {
1419 mayUseCoreVariant = false
1420 }
1421
Vic Yang1a5812a2020-01-31 10:38:40 -08001422 if ctx.Config().CFIEnabledForPath(ctx.ModuleDir()) && ctx.Arch().ArchType == android.Arm64 {
1423 mayUseCoreVariant = false
1424 }
1425
1426 if mayUseCoreVariant {
Vic Yangd92090f2020-01-08 14:32:28 -08001427 library.checkSameCoreVariant = true
1428 if ctx.DeviceConfig().VndkUseCoreVariant() {
1429 library.useCoreVariant = true
1430 }
Vic Yangefd249e2018-11-12 20:19:56 -08001431 }
Justin Yun8fe12122017-12-07 17:18:15 +09001432 }
Logan Chienf3511742017-10-31 18:04:35 +08001433
Jooyung Han261e1582020-10-20 18:54:21 +09001434 // do not install vndk libs
1435 // vndk libs are packaged into VNDK APEX
Ivan Lozanof9e21722020-12-02 09:00:51 -05001436 if ctx.isVndk() && !ctx.IsVndkExt() {
Jooyung Han261e1582020-10-20 18:54:21 +09001437 return
Justin Yun8effde42017-06-23 19:24:43 +09001438 }
Colin Cross56a83212020-09-15 18:30:11 -07001439 } else if len(library.Properties.Stubs.Versions) > 0 && !ctx.Host() && ctx.directlyInAnyApex() {
Jiyong Parkf1194352019-02-25 11:05:47 +09001440 // Bionic libraries (e.g. libc.so) is installed to the bootstrap subdirectory.
1441 // The original path becomes a symlink to the corresponding file in the
1442 // runtime APEX.
Colin Cross3b19f5d2019-09-17 14:45:31 -07001443 translatedArch := ctx.Target().NativeBridge == android.NativeBridgeEnabled
Colin Cross56a83212020-09-15 18:30:11 -07001444 if InstallToBootstrap(ctx.baseModuleName(), ctx.Config()) && !library.buildStubs() &&
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001445 !translatedArch && !ctx.inRamdisk() && !ctx.inVendorRamdisk() && !ctx.inRecovery() {
Martin Stjernholm279de572019-09-10 23:18:20 +01001446 if ctx.Device() {
Jiyong Parkc3e2c862019-03-16 01:10:08 +09001447 library.installSymlinkToRuntimeApex(ctx, file)
1448 }
Jiyong Park429660f2019-01-16 22:31:11 +09001449 library.baseInstaller.subDir = "bootstrap"
1450 }
Colin Cross127bb8b2020-12-16 16:46:01 -08001451 } else if ctx.directlyInAnyApex() && ctx.IsLlndk() && !isBionic(ctx.baseModuleName()) {
Przemyslaw Szczepaniake6fc5072019-07-12 14:06:23 +01001452 // Skip installing LLNDK (non-bionic) libraries moved to APEX.
Colin Crossa9c8c9f2020-12-16 10:20:23 -08001453 ctx.Module().HideFromMake()
Justin Yun8effde42017-06-23 19:24:43 +09001454 }
Przemyslaw Szczepaniake6fc5072019-07-12 14:06:23 +01001455
Colin Cross4d9c2d12016-07-29 12:48:20 -07001456 library.baseInstaller.install(ctx, file)
1457 }
Dan Albertf563d252017-10-13 00:29:00 -07001458
Dan Albert281f22b2017-12-13 15:03:47 -08001459 if Bool(library.Properties.Static_ndk_lib) && library.static() &&
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001460 !ctx.useVndk() && !ctx.inRamdisk() && !ctx.inVendorRamdisk() && !ctx.inRecovery() && ctx.Device() &&
Jiyong Park7ed9de32018-10-15 22:25:07 +09001461 library.baseLinker.sanitize.isUnsanitizedVariant() &&
Colin Cross95b07f22020-12-16 11:06:50 -08001462 ctx.isForPlatform() && !ctx.isPreventInstall() {
Dan Albertf563d252017-10-13 00:29:00 -07001463 installPath := getNdkSysrootBase(ctx).Join(
Dan Albertea4b7b92018-04-25 16:05:30 -07001464 ctx, "usr/lib", config.NDKTriple(ctx.toolchain()), file.Base())
Dan Albertf563d252017-10-13 00:29:00 -07001465
1466 ctx.ModuleBuild(pctx, android.ModuleBuildParams{
1467 Rule: android.Cp,
1468 Description: "install " + installPath.Base(),
1469 Output: installPath,
1470 Input: file,
1471 })
1472
Colin Cross0875c522017-11-28 17:34:01 -08001473 library.ndkSysrootPath = installPath
Dan Albertf563d252017-10-13 00:29:00 -07001474 }
Colin Cross4d9c2d12016-07-29 12:48:20 -07001475}
1476
Paul Duffin0cb37b92020-03-04 14:52:46 +00001477func (library *libraryDecorator) everInstallable() bool {
1478 // Only shared and static libraries are installed. Header libraries (which are
1479 // neither static or shared) are not installed.
1480 return library.shared() || library.static()
1481}
1482
Chris Parsons3c27ca32020-11-20 12:42:07 -05001483// static returns true if this library is for a "static' variant.
Colin Crossb916a382016-07-29 17:28:03 -07001484func (library *libraryDecorator) static() bool {
Colin Crossa48ab5b2017-02-14 15:28:44 -08001485 return library.MutatedProperties.VariantIsStatic
Colin Cross4d9c2d12016-07-29 12:48:20 -07001486}
1487
Chris Parsons3c27ca32020-11-20 12:42:07 -05001488// shared returns true if this library is for a "shared' variant.
Colin Crossa48ab5b2017-02-14 15:28:44 -08001489func (library *libraryDecorator) shared() bool {
1490 return library.MutatedProperties.VariantIsShared
1491}
1492
Chris Parsons3c27ca32020-11-20 12:42:07 -05001493// header returns true if this library is for a header-only variant.
Colin Crossa48ab5b2017-02-14 15:28:44 -08001494func (library *libraryDecorator) header() bool {
Chris Parsons3c27ca32020-11-20 12:42:07 -05001495 // Neither "static" nor "shared" implies this library is header-only.
Colin Crossa48ab5b2017-02-14 15:28:44 -08001496 return !library.static() && !library.shared()
1497}
1498
Chris Parsons3c27ca32020-11-20 12:42:07 -05001499// setStatic marks the library variant as "static".
Colin Crossa48ab5b2017-02-14 15:28:44 -08001500func (library *libraryDecorator) setStatic() {
1501 library.MutatedProperties.VariantIsStatic = true
1502 library.MutatedProperties.VariantIsShared = false
1503}
1504
Chris Parsons3c27ca32020-11-20 12:42:07 -05001505// setShared marks the library variant as "shared".
Colin Crossa48ab5b2017-02-14 15:28:44 -08001506func (library *libraryDecorator) setShared() {
1507 library.MutatedProperties.VariantIsStatic = false
1508 library.MutatedProperties.VariantIsShared = true
Colin Crossb916a382016-07-29 17:28:03 -07001509}
1510
Chris Parsons3c27ca32020-11-20 12:42:07 -05001511// BuildOnlyStatic disables building this library as a shared library.
Colin Crossab3b7322016-12-09 14:46:15 -08001512func (library *libraryDecorator) BuildOnlyStatic() {
Colin Crossa48ab5b2017-02-14 15:28:44 -08001513 library.MutatedProperties.BuildShared = false
Colin Crossab3b7322016-12-09 14:46:15 -08001514}
1515
Chris Parsons3c27ca32020-11-20 12:42:07 -05001516// BuildOnlyShared disables building this library as a static library.
Colin Crossab3b7322016-12-09 14:46:15 -08001517func (library *libraryDecorator) BuildOnlyShared() {
Colin Crossa48ab5b2017-02-14 15:28:44 -08001518 library.MutatedProperties.BuildStatic = false
Colin Crossab3b7322016-12-09 14:46:15 -08001519}
1520
Chris Parsons3c27ca32020-11-20 12:42:07 -05001521// HeaderOnly disables building this library as a shared or static library;
1522// the library only exists to propagate header file dependencies up the build graph.
Colin Cross5950f382016-12-13 12:50:57 -08001523func (library *libraryDecorator) HeaderOnly() {
Colin Crossa48ab5b2017-02-14 15:28:44 -08001524 library.MutatedProperties.BuildShared = false
1525 library.MutatedProperties.BuildStatic = false
Colin Cross5950f382016-12-13 12:50:57 -08001526}
1527
Colin Cross127bb8b2020-12-16 16:46:01 -08001528// hasLLNDKStubs returns true if this cc_library module has a variant that will build LLNDK stubs.
1529func (library *libraryDecorator) hasLLNDKStubs() bool {
1530 return String(library.Properties.Llndk_stubs) != ""
1531}
1532
Colin Cross0477b422020-10-13 18:43:54 -07001533func (library *libraryDecorator) implementationModuleName(name string) string {
1534 return name
1535}
1536
Jiyong Park7ed9de32018-10-15 22:25:07 +09001537func (library *libraryDecorator) buildStubs() bool {
1538 return library.MutatedProperties.BuildStubs
1539}
1540
Jiyong Parka034b832019-08-27 14:02:19 +09001541func (library *libraryDecorator) symbolFileForAbiCheck(ctx ModuleContext) *string {
1542 if library.Properties.Header_abi_checker.Symbol_file != nil {
1543 return library.Properties.Header_abi_checker.Symbol_file
1544 }
Colin Cross127bb8b2020-12-16 16:46:01 -08001545 if ctx.Module().(*Module).IsLlndk() {
1546 return library.Properties.Llndk.Symbol_file
1547 }
Colin Cross31076b32020-10-23 17:22:06 -07001548 if library.hasStubsVariants() && library.Properties.Stubs.Symbol_file != nil {
Jiyong Parka034b832019-08-27 14:02:19 +09001549 return library.Properties.Stubs.Symbol_file
1550 }
1551 return nil
1552}
1553
Colin Crossc88c2722020-09-28 17:32:47 -07001554func (library *libraryDecorator) hasStubsVariants() bool {
1555 return len(library.Properties.Stubs.Versions) > 0
1556}
1557
Colin Cross3572cf72020-10-01 15:58:11 -07001558func (library *libraryDecorator) stubsVersions(ctx android.BaseMutatorContext) []string {
Colin Crossc88c2722020-09-28 17:32:47 -07001559 return library.Properties.Stubs.Versions
1560}
1561
1562func (library *libraryDecorator) setStubsVersion(version string) {
1563 library.MutatedProperties.StubsVersion = version
1564}
1565
Jiyong Park7ed9de32018-10-15 22:25:07 +09001566func (library *libraryDecorator) stubsVersion() string {
1567 return library.MutatedProperties.StubsVersion
1568}
1569
Colin Crossc88c2722020-09-28 17:32:47 -07001570func (library *libraryDecorator) setBuildStubs() {
1571 library.MutatedProperties.BuildStubs = true
1572}
1573
1574func (library *libraryDecorator) setAllStubsVersions(versions []string) {
1575 library.MutatedProperties.AllStubsVersions = versions
1576}
1577
1578func (library *libraryDecorator) allStubsVersions() []string {
1579 return library.MutatedProperties.AllStubsVersions
1580}
1581
Jooyung Hanad4c1872020-02-27 17:56:44 +09001582func (library *libraryDecorator) isLatestStubVersion() bool {
1583 versions := library.Properties.Stubs.Versions
1584 return versions[len(versions)-1] == library.stubsVersion()
1585}
1586
Jiyong Parka90ca002019-10-07 15:47:24 +09001587func (library *libraryDecorator) availableFor(what string) bool {
1588 var list []string
1589 if library.static() {
1590 list = library.StaticProperties.Static.Apex_available
1591 } else if library.shared() {
1592 list = library.SharedProperties.Shared.Apex_available
1593 }
1594 if len(list) == 0 {
1595 return false
1596 }
1597 return android.CheckAvailableForApex(what, list)
1598}
1599
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01001600func (library *libraryDecorator) makeUninstallable(mod *Module) {
Martin Stjernholmbf37d162020-03-31 16:05:34 +01001601 if library.static() && library.buildStatic() && !library.buildStubs() {
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01001602 // If we're asked to make a static library uninstallable we don't do
1603 // anything since AndroidMkEntries always sets LOCAL_UNINSTALLABLE_MODULE
1604 // for these entries. This is done to still get the make targets for NOTICE
1605 // files from notice_files.mk, which other libraries might depend on.
Martin Stjernholmbf37d162020-03-31 16:05:34 +01001606 return
1607 }
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01001608 mod.ModuleBase.MakeUninstallable()
Martin Stjernholmbf37d162020-03-31 16:05:34 +01001609}
1610
Colin Cross571cccf2019-02-04 11:22:08 -08001611var versioningMacroNamesListKey = android.NewOnceKey("versioningMacroNamesList")
1612
Chris Parsons3c27ca32020-11-20 12:42:07 -05001613// versioningMacroNamesList returns a singleton map, where keys are "version macro names",
1614// and values are the module name responsible for registering the version macro name.
1615//
1616// Version macros are used when building against stubs, to provide version information about
1617// the stub. Only stub libraries should have an entry in this list.
1618//
1619// For example, when building against libFoo#ver, __LIBFOO_API__ macro is set to ver so
1620// that headers from libFoo can be conditionally compiled (this may hide APIs
1621// that are not available for the version).
1622//
1623// This map is used to ensure that there aren't conflicts between these version macro names.
Jiyong Parkda732bd2018-11-02 18:23:15 +09001624func versioningMacroNamesList(config android.Config) *map[string]string {
Colin Cross571cccf2019-02-04 11:22:08 -08001625 return config.Once(versioningMacroNamesListKey, func() interface{} {
Jiyong Parkda732bd2018-11-02 18:23:15 +09001626 m := make(map[string]string)
1627 return &m
1628 }).(*map[string]string)
1629}
1630
1631// alphanumeric and _ characters are preserved.
1632// other characters are all converted to _
1633var charsNotForMacro = regexp.MustCompile("[^a-zA-Z0-9_]+")
1634
Chris Parsons3c27ca32020-11-20 12:42:07 -05001635// versioningMacroName returns the canonical version macro name for the given module.
Jiyong Parkda732bd2018-11-02 18:23:15 +09001636func versioningMacroName(moduleName string) string {
1637 macroName := charsNotForMacro.ReplaceAllString(moduleName, "_")
Jooyung Hanb04a4992020-03-13 18:57:35 +09001638 macroName = strings.ToUpper(macroName)
Jiyong Parkda732bd2018-11-02 18:23:15 +09001639 return "__" + macroName + "_API__"
1640}
1641
Chris Parsons3c27ca32020-11-20 12:42:07 -05001642// NewLibrary builds and returns a new Module corresponding to a C++ library.
1643// Individual module implementations which comprise a C++ library (or something like
1644// a C++ library) should call this function, set some fields on the result, and
1645// then call the Init function.
Colin Crossab3b7322016-12-09 14:46:15 -08001646func NewLibrary(hod android.HostOrDeviceSupported) (*Module, *libraryDecorator) {
Colin Cross4d9c2d12016-07-29 12:48:20 -07001647 module := newModule(hod, android.MultilibBoth)
1648
Colin Crossb916a382016-07-29 17:28:03 -07001649 library := &libraryDecorator{
Colin Crossa48ab5b2017-02-14 15:28:44 -08001650 MutatedProperties: LibraryMutatedProperties{
Colin Crossab3b7322016-12-09 14:46:15 -08001651 BuildShared: true,
1652 BuildStatic: true,
Colin Cross4d9c2d12016-07-29 12:48:20 -07001653 },
Colin Crossb916a382016-07-29 17:28:03 -07001654 baseCompiler: NewBaseCompiler(),
Dan Albert61f32122018-07-26 14:00:24 -07001655 baseLinker: NewBaseLinker(module.sanitize),
Colin Crossb916a382016-07-29 17:28:03 -07001656 baseInstaller: NewBaseInstaller("lib", "lib64", InstallInSystem),
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001657 sabi: module.sabi,
Colin Cross4d9c2d12016-07-29 12:48:20 -07001658 }
1659
Colin Crossb916a382016-07-29 17:28:03 -07001660 module.compiler = library
1661 module.linker = library
1662 module.installer = library
Colin Cross31076b32020-10-23 17:22:06 -07001663 module.library = library
Colin Crossb916a382016-07-29 17:28:03 -07001664
1665 return module, library
1666}
1667
Colin Cross10d22312017-05-03 11:01:58 -07001668// connects a shared library to a static library in order to reuse its .o files to avoid
1669// compiling source files twice.
1670func reuseStaticLibrary(mctx android.BottomUpMutatorContext, static, shared *Module) {
1671 if staticCompiler, ok := static.compiler.(*libraryDecorator); ok {
1672 sharedCompiler := shared.compiler.(*libraryDecorator)
Dan Willemsen3a26eef2018-12-03 15:25:46 -08001673
1674 // Check libraries in addition to cflags, since libraries may be exporting different
1675 // include directories.
Colin Crosse1bb5d02019-09-24 14:55:04 -07001676 if len(staticCompiler.StaticProperties.Static.Cflags) == 0 &&
1677 len(sharedCompiler.SharedProperties.Shared.Cflags) == 0 &&
1678 len(staticCompiler.StaticProperties.Static.Whole_static_libs) == 0 &&
1679 len(sharedCompiler.SharedProperties.Shared.Whole_static_libs) == 0 &&
1680 len(staticCompiler.StaticProperties.Static.Static_libs) == 0 &&
1681 len(sharedCompiler.SharedProperties.Shared.Static_libs) == 0 &&
1682 len(staticCompiler.StaticProperties.Static.Shared_libs) == 0 &&
1683 len(sharedCompiler.SharedProperties.Shared.Shared_libs) == 0 &&
Martin Stjernholm10566a02020-03-24 01:19:52 +00001684 // Compare System_shared_libs properties with nil because empty lists are
1685 // semantically significant for them.
Colin Crosse1bb5d02019-09-24 14:55:04 -07001686 staticCompiler.StaticProperties.Static.System_shared_libs == nil &&
1687 sharedCompiler.SharedProperties.Shared.System_shared_libs == nil {
Colin Cross10d22312017-05-03 11:01:58 -07001688
1689 mctx.AddInterVariantDependency(reuseObjTag, shared, static)
1690 sharedCompiler.baseCompiler.Properties.OriginalSrcs =
1691 sharedCompiler.baseCompiler.Properties.Srcs
1692 sharedCompiler.baseCompiler.Properties.Srcs = nil
1693 sharedCompiler.baseCompiler.Properties.Generated_sources = nil
1694 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07001695
1696 // This dep is just to reference static variant from shared variant
1697 mctx.AddInterVariantDependency(staticVariantTag, shared, static)
Colin Cross10d22312017-05-03 11:01:58 -07001698 }
1699}
1700
Chris Parsons3c27ca32020-11-20 12:42:07 -05001701// LinkageMutator adds "static" or "shared" variants for modules depending
1702// on whether the module can be built as a static library or a shared library.
Colin Crosse40b4ea2018-10-02 22:25:58 -07001703func LinkageMutator(mctx android.BottomUpMutatorContext) {
Jaewoong Jung18aefc12020-12-21 09:11:10 -08001704 ccPrebuilt := false
Colin Crossb916a382016-07-29 17:28:03 -07001705 if m, ok := mctx.Module().(*Module); ok && m.linker != nil {
Jaewoong Jung18aefc12020-12-21 09:11:10 -08001706 _, ccPrebuilt = m.linker.(prebuiltLibraryInterface)
Ivan Lozano52767be2019-10-18 14:49:46 -07001707 }
Jaewoong Jung18aefc12020-12-21 09:11:10 -08001708 if ccPrebuilt {
Ivan Lozano52767be2019-10-18 14:49:46 -07001709 library := mctx.Module().(*Module).linker.(prebuiltLibraryInterface)
Colin Cross33b2fb72019-05-14 14:07:01 -07001710
Paul Duffinf5ea9e12020-02-21 10:57:00 +00001711 // Differentiate between header only and building an actual static/shared library
Colin Cross127bb8b2020-12-16 16:46:01 -08001712 buildStatic := library.buildStatic()
1713 buildShared := library.buildShared()
1714 if buildStatic || buildShared {
Paul Duffinf5ea9e12020-02-21 10:57:00 +00001715 // Always create both the static and shared variants for prebuilt libraries, and then disable the one
1716 // that is not being used. This allows them to share the name of a cc_library module, which requires that
1717 // all the variants of the cc_library also exist on the prebuilt.
1718 modules := mctx.CreateLocalVariations("static", "shared")
1719 static := modules[0].(*Module)
1720 shared := modules[1].(*Module)
Colin Cross33b2fb72019-05-14 14:07:01 -07001721
Paul Duffinf5ea9e12020-02-21 10:57:00 +00001722 static.linker.(prebuiltLibraryInterface).setStatic()
1723 shared.linker.(prebuiltLibraryInterface).setShared()
Colin Cross33b2fb72019-05-14 14:07:01 -07001724
Colin Cross127bb8b2020-12-16 16:46:01 -08001725 if buildShared {
Colin Cross81ca6cd2020-08-06 17:46:48 -07001726 mctx.AliasVariation("shared")
Colin Cross127bb8b2020-12-16 16:46:01 -08001727 } else if buildStatic {
Colin Cross81ca6cd2020-08-06 17:46:48 -07001728 mctx.AliasVariation("static")
1729 }
1730
Colin Cross127bb8b2020-12-16 16:46:01 -08001731 if !buildStatic {
Paul Duffinf5ea9e12020-02-21 10:57:00 +00001732 static.linker.(prebuiltLibraryInterface).disablePrebuilt()
1733 }
Colin Cross127bb8b2020-12-16 16:46:01 -08001734 if !buildShared {
Paul Duffinf5ea9e12020-02-21 10:57:00 +00001735 shared.linker.(prebuiltLibraryInterface).disablePrebuilt()
1736 }
1737 } else {
1738 // Header only
Colin Crossb916a382016-07-29 17:28:03 -07001739 }
Paul Duffinf5ea9e12020-02-21 10:57:00 +00001740
Ivan Lozano52767be2019-10-18 14:49:46 -07001741 } else if library, ok := mctx.Module().(LinkableInterface); ok && library.CcLibraryInterface() {
Ivan Lozano52767be2019-10-18 14:49:46 -07001742
Ivan Lozano2b262972019-11-21 12:30:50 -08001743 // Non-cc.Modules may need an empty variant for their mutators.
1744 variations := []string{}
1745 if library.NonCcVariants() {
1746 variations = append(variations, "")
1747 }
1748
Colin Cross127bb8b2020-12-16 16:46:01 -08001749 isLLNDK := false
1750 if m, ok := mctx.Module().(*Module); ok {
Colin Cross127bb8b2020-12-16 16:46:01 -08001751 // Don't count the vestigial llndk_library module as isLLNDK, it needs a static
1752 // variant so that a cc_library_prebuilt can depend on it.
Colin Cross4f4f8eb2021-01-06 14:07:27 -08001753 isLLNDK = m.IsLlndk() && !isVestigialLLNDKModule(m)
Colin Cross127bb8b2020-12-16 16:46:01 -08001754 }
1755 buildStatic := library.BuildStaticVariant() && !isLLNDK
1756 buildShared := library.BuildSharedVariant()
1757 if buildStatic && buildShared {
Ivan Lozano2b262972019-11-21 12:30:50 -08001758 variations := append([]string{"static", "shared"}, variations...)
Ivan Lozano52767be2019-10-18 14:49:46 -07001759
1760 modules := mctx.CreateLocalVariations(variations...)
1761 static := modules[0].(LinkableInterface)
1762 shared := modules[1].(LinkableInterface)
1763
1764 static.SetStatic()
1765 shared.SetShared()
1766
1767 if _, ok := library.(*Module); ok {
1768 reuseStaticLibrary(mctx, static.(*Module), shared.(*Module))
1769 }
Colin Cross81ca6cd2020-08-06 17:46:48 -07001770 mctx.AliasVariation("shared")
Colin Cross127bb8b2020-12-16 16:46:01 -08001771 } else if buildStatic {
Ivan Lozano2b262972019-11-21 12:30:50 -08001772 variations := append([]string{"static"}, variations...)
1773
1774 modules := mctx.CreateLocalVariations(variations...)
Ivan Lozano52767be2019-10-18 14:49:46 -07001775 modules[0].(LinkableInterface).SetStatic()
Colin Cross81ca6cd2020-08-06 17:46:48 -07001776 mctx.AliasVariation("static")
Colin Cross127bb8b2020-12-16 16:46:01 -08001777 } else if buildShared {
Ivan Lozano2b262972019-11-21 12:30:50 -08001778 variations := append([]string{"shared"}, variations...)
Ivan Lozano52767be2019-10-18 14:49:46 -07001779
Ivan Lozano2b262972019-11-21 12:30:50 -08001780 modules := mctx.CreateLocalVariations(variations...)
1781 modules[0].(LinkableInterface).SetShared()
Colin Cross81ca6cd2020-08-06 17:46:48 -07001782 mctx.AliasVariation("shared")
Ivan Lozano2b262972019-11-21 12:30:50 -08001783 } else if len(variations) > 0 {
1784 mctx.CreateLocalVariations(variations...)
Colin Cross81ca6cd2020-08-06 17:46:48 -07001785 mctx.AliasVariation(variations[0])
Ivan Lozano2b262972019-11-21 12:30:50 -08001786 }
Colin Crossb916a382016-07-29 17:28:03 -07001787 }
Colin Cross4d9c2d12016-07-29 12:48:20 -07001788}
Jiyong Park7ed9de32018-10-15 22:25:07 +09001789
Chris Parsons3c27ca32020-11-20 12:42:07 -05001790// normalizeVersions modifies `versions` in place, so that each raw version
1791// string becomes its normalized canonical form.
1792// Validates that the versions in `versions` are specified in least to greatest order.
Jooyung Hanaed150d2020-04-02 01:41:41 +09001793func normalizeVersions(ctx android.BaseModuleContext, versions []string) {
Dan Albertc8060532020-07-22 22:32:17 -07001794 var previous android.ApiLevel
Jooyung Hanad4c1872020-02-27 17:56:44 +09001795 for i, v := range versions {
Dan Albertc8060532020-07-22 22:32:17 -07001796 ver, err := android.ApiLevelFromUser(ctx, v)
Jooyung Hanad4c1872020-02-27 17:56:44 +09001797 if err != nil {
Jooyung Hanaed150d2020-04-02 01:41:41 +09001798 ctx.PropertyErrorf("versions", "%s", err.Error())
1799 return
Jooyung Hanad4c1872020-02-27 17:56:44 +09001800 }
Dan Albertc8060532020-07-22 22:32:17 -07001801 if i > 0 && ver.LessThanOrEqualTo(previous) {
1802 ctx.PropertyErrorf("versions", "not sorted: %v", versions)
1803 }
1804 versions[i] = ver.String()
1805 previous = ver
Jooyung Hanaed150d2020-04-02 01:41:41 +09001806 }
Jooyung Hanad4c1872020-02-27 17:56:44 +09001807}
1808
Jooyung Han61b66e92020-03-21 14:21:46 +00001809func createVersionVariations(mctx android.BottomUpMutatorContext, versions []string) {
Colin Cross127bb8b2020-12-16 16:46:01 -08001810 // "" is for the non-stubs (implementation) variant for system modules, or the LLNDK variant
1811 // for LLNDK modules.
Colin Cross0de8a1e2020-09-18 14:15:30 -07001812 variants := append(android.CopyOf(versions), "")
Jooyung Han61b66e92020-03-21 14:21:46 +00001813
Colin Cross127bb8b2020-12-16 16:46:01 -08001814 m := mctx.Module().(*Module)
1815 isLLNDK := m.IsLlndk()
1816
Colin Crossd1f898e2020-08-18 18:35:15 -07001817 modules := mctx.CreateLocalVariations(variants...)
Jooyung Han61b66e92020-03-21 14:21:46 +00001818 for i, m := range modules {
Colin Cross127bb8b2020-12-16 16:46:01 -08001819
1820 if variants[i] != "" || isLLNDK {
1821 // A stubs or LLNDK stubs variant.
Colin Cross31076b32020-10-23 17:22:06 -07001822 c := m.(*Module)
Colin Cross31076b32020-10-23 17:22:06 -07001823 c.sanitize = nil
1824 c.stl = nil
1825 c.Properties.PreventInstall = true
1826 lib := moduleLibraryInterface(m)
1827 lib.setBuildStubs()
Colin Cross127bb8b2020-12-16 16:46:01 -08001828
1829 if variants[i] != "" {
1830 // A non-LLNDK stubs module is hidden from make and has a dependency from the
1831 // implementation module to the stubs module.
1832 c.Properties.HideFromMake = true
1833 lib.setStubsVersion(variants[i])
1834 mctx.AddInterVariantDependency(stubImplDepTag, modules[len(modules)-1], modules[i])
1835 }
Jooyung Han61b66e92020-03-21 14:21:46 +00001836 }
1837 }
Colin Cross094faa52020-08-06 17:38:25 -07001838 mctx.AliasVariation("")
Colin Crossd1f898e2020-08-18 18:35:15 -07001839 latestVersion := ""
1840 if len(versions) > 0 {
1841 latestVersion = versions[len(versions)-1]
1842 }
1843 mctx.CreateAliasVariation("latest", latestVersion)
Jooyung Han61b66e92020-03-21 14:21:46 +00001844}
1845
Colin Crossbbc941b2020-09-30 12:27:01 -07001846func createPerApiVersionVariations(mctx android.BottomUpMutatorContext, minSdkVersion string) {
1847 from, err := nativeApiLevelFromUser(mctx, minSdkVersion)
1848 if err != nil {
1849 mctx.PropertyErrorf("min_sdk_version", err.Error())
1850 return
1851 }
1852
1853 versionStrs := ndkLibraryVersions(mctx, from)
1854 modules := mctx.CreateLocalVariations(versionStrs...)
1855
1856 for i, module := range modules {
1857 module.(*Module).Properties.Sdk_version = StringPtr(versionStrs[i])
1858 }
1859}
1860
Colin Cross3146c5c2020-09-30 15:34:40 -07001861func CanBeOrLinkAgainstVersionVariants(module interface {
Jooyung Han624d35c2020-04-10 12:57:24 +09001862 Host() bool
1863 InRamdisk() bool
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001864 InVendorRamdisk() bool
Jooyung Han624d35c2020-04-10 12:57:24 +09001865}) bool {
Jose Galmes6f843bc2020-12-11 13:36:29 -08001866 return !module.Host() && !module.InRamdisk() && !module.InVendorRamdisk()
Jooyung Han624d35c2020-04-10 12:57:24 +09001867}
1868
Colin Cross3146c5c2020-09-30 15:34:40 -07001869func CanBeVersionVariant(module interface {
1870 Host() bool
1871 InRamdisk() bool
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001872 InVendorRamdisk() bool
Colin Cross3146c5c2020-09-30 15:34:40 -07001873 InRecovery() bool
1874 CcLibraryInterface() bool
1875 Shared() bool
Colin Cross3146c5c2020-09-30 15:34:40 -07001876}) bool {
1877 return CanBeOrLinkAgainstVersionVariants(module) &&
Colin Crossa717db72020-10-23 14:53:06 -07001878 module.CcLibraryInterface() && module.Shared()
Colin Cross3146c5c2020-09-30 15:34:40 -07001879}
1880
Colin Cross127bb8b2020-12-16 16:46:01 -08001881func moduleLibraryInterface(module blueprint.Module) libraryInterface {
Colin Cross31076b32020-10-23 17:22:06 -07001882 if m, ok := module.(*Module); ok {
1883 return m.library
1884 }
1885 return nil
1886}
1887
Colin Crossd1f898e2020-08-18 18:35:15 -07001888// versionSelector normalizes the versions in the Stubs.Versions property into MutatedProperties.AllStubsVersions,
1889// and propagates the value from implementation libraries to llndk libraries with the same name.
1890func versionSelectorMutator(mctx android.BottomUpMutatorContext) {
Colin Cross31076b32020-10-23 17:22:06 -07001891 if library := moduleLibraryInterface(mctx.Module()); library != nil && CanBeVersionVariant(mctx.Module().(*Module)) {
1892 if library.buildShared() {
1893 versions := library.stubsVersions(mctx)
Colin Cross3572cf72020-10-01 15:58:11 -07001894 if len(versions) > 0 {
1895 normalizeVersions(mctx, versions)
1896 if mctx.Failed() {
Colin Crossbbc941b2020-09-30 12:27:01 -07001897 return
1898 }
Colin Cross3572cf72020-10-01 15:58:11 -07001899 // Set the versions on the pre-mutated module so they can be read by any llndk modules that
1900 // depend on the implementation library and haven't been mutated yet.
Colin Cross31076b32020-10-23 17:22:06 -07001901 library.setAllStubsVersions(versions)
Colin Cross127bb8b2020-12-16 16:46:01 -08001902 }
1903
1904 if mctx.Module().(*Module).UseVndk() && library.hasLLNDKStubs() {
1905 // Propagate the version to the llndk stubs module.
1906 mctx.VisitDirectDepsWithTag(llndkStubDepTag, func(stubs android.Module) {
1907 if stubsLib := moduleLibraryInterface(stubs); stubsLib != nil {
1908 stubsLib.setAllStubsVersions(library.allStubsVersions())
1909 }
1910 })
Jiyong Park7ed9de32018-10-15 22:25:07 +09001911 }
Jooyung Han61b66e92020-03-21 14:21:46 +00001912 }
Colin Crossd1f898e2020-08-18 18:35:15 -07001913 }
1914}
Jooyung Han61b66e92020-03-21 14:21:46 +00001915
Colin Crossd1f898e2020-08-18 18:35:15 -07001916// versionMutator splits a module into the mandatory non-stubs variant
1917// (which is unnamed) and zero or more stubs variants.
1918func versionMutator(mctx android.BottomUpMutatorContext) {
Colin Cross31076b32020-10-23 17:22:06 -07001919 if library := moduleLibraryInterface(mctx.Module()); library != nil && CanBeVersionVariant(mctx.Module().(*Module)) {
1920 createVersionVariations(mctx, library.allStubsVersions())
Colin Crossbbc941b2020-09-30 12:27:01 -07001921 return
1922 }
1923
1924 if m, ok := mctx.Module().(*Module); ok {
1925 if m.SplitPerApiLevel() && m.IsSdkVariant() {
1926 if mctx.Os() != android.Android {
1927 return
1928 }
1929 createPerApiVersionVariations(mctx, m.MinSdkVersion())
1930 }
Jiyong Park7ed9de32018-10-15 22:25:07 +09001931 }
Jiyong Park7ed9de32018-10-15 22:25:07 +09001932}
Colin Crossd7227f92019-09-05 14:26:33 -07001933
1934// maybeInjectBoringSSLHash adds a rule to run bssl_inject_hash on the output file if the module has the
1935// inject_bssl_hash or if any static library dependencies have inject_bssl_hash set. It returns the output path
1936// that the linked output file should be written to.
1937// TODO(b/137267623): Remove this in favor of a cc_genrule when they support operating on shared libraries.
1938func maybeInjectBoringSSLHash(ctx android.ModuleContext, outputFile android.ModuleOutPath,
1939 inject *bool, fileName string) android.ModuleOutPath {
1940 // TODO(b/137267623): Remove this in favor of a cc_genrule when they support operating on shared libraries.
1941 injectBoringSSLHash := Bool(inject)
1942 ctx.VisitDirectDeps(func(dep android.Module) {
Colin Cross6e511a92020-07-27 21:26:48 -07001943 if tag, ok := ctx.OtherModuleDependencyTag(dep).(libraryDependencyTag); ok && tag.static() {
Colin Crossd7227f92019-09-05 14:26:33 -07001944 if cc, ok := dep.(*Module); ok {
1945 if library, ok := cc.linker.(*libraryDecorator); ok {
1946 if Bool(library.Properties.Inject_bssl_hash) {
1947 injectBoringSSLHash = true
1948 }
1949 }
1950 }
1951 }
1952 })
1953 if injectBoringSSLHash {
1954 hashedOutputfile := outputFile
1955 outputFile = android.PathForModuleOut(ctx, "unhashed", fileName)
1956
Colin Crossf1a035e2020-11-16 17:32:30 -08001957 rule := android.NewRuleBuilder(pctx, ctx)
Colin Crossd7227f92019-09-05 14:26:33 -07001958 rule.Command().
Colin Crossf1a035e2020-11-16 17:32:30 -08001959 BuiltTool("bssl_inject_hash").
Pete Bentley5c4be822019-10-01 17:03:17 +01001960 Flag("-sha256").
Colin Crossd7227f92019-09-05 14:26:33 -07001961 FlagWithInput("-in-object ", outputFile).
1962 FlagWithOutput("-o ", hashedOutputfile)
Colin Crossf1a035e2020-11-16 17:32:30 -08001963 rule.Build("injectCryptoHash", "inject crypto hash")
Colin Crossd7227f92019-09-05 14:26:33 -07001964 }
1965
1966 return outputFile
1967}