blob: 97c7ba1b774ddb43ea5e5f686139ba58ef21bf3d [file] [log] [blame]
Colin Cross4d9c2d12016-07-29 12:48:20 -07001// Copyright 2016 Google Inc. All rights reserved.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15package cc
16
17import (
Inseob Kim69378442019-06-03 19:10:47 +090018 "fmt"
Logan Chien41eabe62019-04-10 13:33:58 +080019 "io"
Jiyong Parkf1194352019-02-25 11:05:47 +090020 "path/filepath"
Jiyong Parkda732bd2018-11-02 18:23:15 +090021 "regexp"
Jooyung Han11b0fbd2021-02-05 02:28:22 +090022 "strconv"
Colin Cross4d9c2d12016-07-29 12:48:20 -070023 "strings"
Jiyong Parkda732bd2018-11-02 18:23:15 +090024 "sync"
Colin Cross4d9c2d12016-07-29 12:48:20 -070025
Colin Cross127bb8b2020-12-16 16:46:01 -080026 "github.com/google/blueprint"
Colin Cross26c34ed2016-09-30 17:10:16 -070027 "github.com/google/blueprint/pathtools"
Colin Cross4d9c2d12016-07-29 12:48:20 -070028
Colin Cross4d9c2d12016-07-29 12:48:20 -070029 "android/soong/android"
Rupert Shuttleworth095081c2021-03-25 09:06:03 +000030 "android/soong/bazel"
Dan Albertea4b7b92018-04-25 16:05:30 -070031 "android/soong/cc/config"
Colin Cross4d9c2d12016-07-29 12:48:20 -070032)
33
Chris Parsons3c27ca32020-11-20 12:42:07 -050034// LibraryProperties is a collection of properties shared by cc library rules.
Colin Crossb916a382016-07-29 17:28:03 -070035type LibraryProperties struct {
Colin Cross4d9c2d12016-07-29 12:48:20 -070036 // local file name to pass to the linker as -unexported_symbols_list
Colin Cross27b922f2019-03-04 22:35:41 -080037 Unexported_symbols_list *string `android:"path,arch_variant"`
Colin Cross4d9c2d12016-07-29 12:48:20 -070038 // local file name to pass to the linker as -force_symbols_not_weak_list
Colin Cross27b922f2019-03-04 22:35:41 -080039 Force_symbols_not_weak_list *string `android:"path,arch_variant"`
Colin Cross4d9c2d12016-07-29 12:48:20 -070040 // local file name to pass to the linker as -force_symbols_weak_list
Colin Cross27b922f2019-03-04 22:35:41 -080041 Force_symbols_weak_list *string `android:"path,arch_variant"`
Colin Cross4d9c2d12016-07-29 12:48:20 -070042
43 // rename host libraries to prevent overlap with system installed libraries
44 Unique_host_soname *bool
45
Dan Willemsene1240db2016-11-03 14:28:51 -070046 Aidl struct {
47 // export headers generated from .aidl sources
Nan Zhang0007d812017-11-07 10:57:05 -080048 Export_aidl_headers *bool
Dan Willemsene1240db2016-11-03 14:28:51 -070049 }
50
Colin Cross0c461f12016-10-20 16:11:43 -070051 Proto struct {
52 // export headers generated from .proto sources
Nan Zhang0007d812017-11-07 10:57:05 -080053 Export_proto_headers *bool
Colin Cross0c461f12016-10-20 16:11:43 -070054 }
Dan Albertf563d252017-10-13 00:29:00 -070055
Inseob Kimc0907f12019-02-08 21:00:45 +090056 Sysprop struct {
57 // Whether platform owns this sysprop library.
58 Platform *bool
Inseob Kimb3f22ca2019-03-05 12:40:24 +090059 } `blueprint:"mutated"`
Inseob Kimc0907f12019-02-08 21:00:45 +090060
Nan Zhang0007d812017-11-07 10:57:05 -080061 Static_ndk_lib *bool
Jiyong Park7ed9de32018-10-15 22:25:07 +090062
63 Stubs struct {
64 // Relative path to the symbol map. The symbol map provides the list of
65 // symbols that are exported for stubs variant of this library.
Colin Cross27b922f2019-03-04 22:35:41 -080066 Symbol_file *string `android:"path"`
Jiyong Park7ed9de32018-10-15 22:25:07 +090067
Jiyong Parkd4a3a132021-03-17 20:21:35 +090068 // List versions to generate stubs libs for. The version name "current" is always
69 // implicitly added.
Jiyong Park7ed9de32018-10-15 22:25:07 +090070 Versions []string
71 }
dimitryd95964a2018-11-07 13:43:34 +010072
73 // set the name of the output
74 Stem *string `android:"arch_variant"`
75
Colin Cross0fd6a412019-08-16 14:22:10 -070076 // set suffix of the name of the output
77 Suffix *string `android:"arch_variant"`
78
79 Target struct {
Justin Yun63e9ec72020-10-29 16:49:43 +090080 Vendor, Product struct {
Colin Cross0fd6a412019-08-16 14:22:10 -070081 // set suffix of the name of the output
82 Suffix *string `android:"arch_variant"`
83 }
84 }
85
dimitryd95964a2018-11-07 13:43:34 +010086 // Names of modules to be overridden. Listed modules can only be other shared libraries
87 // (in Make or Soong).
88 // This does not completely prevent installation of the overridden libraries, but if both
89 // binaries would be installed by default (in PRODUCT_PACKAGES) the other library will be removed
90 // from PRODUCT_PACKAGES.
91 Overrides []string
Logan Chiene3d7a0d2019-01-17 00:18:02 +080092
93 // Properties for ABI compatibility checker
94 Header_abi_checker struct {
Logan Chien41eabe62019-04-10 13:33:58 +080095 // Enable ABI checks (even if this is not an LLNDK/VNDK lib)
96 Enabled *bool
97
Logan Chiene3d7a0d2019-01-17 00:18:02 +080098 // Path to a symbol file that specifies the symbols to be included in the generated
99 // ABI dump file
Colin Cross27b922f2019-03-04 22:35:41 -0800100 Symbol_file *string `android:"path"`
Logan Chiene3d7a0d2019-01-17 00:18:02 +0800101
102 // Symbol versions that should be ignored from the symbol file
103 Exclude_symbol_versions []string
104
105 // Symbol tags that should be ignored from the symbol file
106 Exclude_symbol_tags []string
Logan Chien2a65dda2019-10-01 15:58:07 -0700107
108 // Run checks on all APIs (in addition to the ones referred by
109 // one of exported ELF symbols.)
110 Check_all_apis *bool
Logan Chiene3d7a0d2019-01-17 00:18:02 +0800111 }
Vic Yang6cd1be82019-06-24 16:08:48 -0700112
113 // Order symbols in .bss section by their sizes. Only useful for shared libraries.
114 Sort_bss_symbols_by_size *bool
Pete Bentley803e1612019-08-06 22:19:59 +0100115
116 // Inject boringssl hash into the shared library. This is only intended for use by external/boringssl.
117 Inject_bssl_hash *bool `android:"arch_variant"`
Colin Cross0477b422020-10-13 18:43:54 -0700118
119 // If this is an LLNDK library, the name of the equivalent llndk_library module.
120 Llndk_stubs *string
Colin Cross127bb8b2020-12-16 16:46:01 -0800121
122 // If this is an LLNDK library, properties to describe the LLNDK stubs. Will be copied from
123 // the module pointed to by llndk_stubs if it is set.
124 Llndk llndkLibraryProperties
Colin Crossa48ab5b2017-02-14 15:28:44 -0800125}
Colin Cross0c461f12016-10-20 16:11:43 -0700126
Chris Parsons3c27ca32020-11-20 12:42:07 -0500127// StaticProperties is a properties stanza to affect only attributes of the "static" variants of a
128// library module.
Colin Crosse1bb5d02019-09-24 14:55:04 -0700129type StaticProperties struct {
130 Static StaticOrSharedProperties `android:"arch_variant"`
131}
132
Chris Parsons3c27ca32020-11-20 12:42:07 -0500133// SharedProperties is a properties stanza to affect only attributes of the "shared" variants of a
134// library module.
Colin Crosse1bb5d02019-09-24 14:55:04 -0700135type SharedProperties struct {
136 Shared StaticOrSharedProperties `android:"arch_variant"`
137}
138
Chris Parsons3c27ca32020-11-20 12:42:07 -0500139// StaticOrSharedProperties is an embedded struct representing properties to affect attributes of
140// either only the "static" variants or only the "shared" variants of a library module. These override
141// the base properties of the same name.
142// Use `StaticProperties` or `SharedProperties`, depending on which variant is needed.
143// `StaticOrSharedProperties` exists only to avoid duplication.
Colin Crosse1bb5d02019-09-24 14:55:04 -0700144type StaticOrSharedProperties struct {
Evgenii Stepanov2080bfe2020-07-24 15:35:40 -0700145 Srcs []string `android:"path,arch_variant"`
146
147 Sanitized Sanitized `android:"arch_variant"`
148
Colin Crosse1bb5d02019-09-24 14:55:04 -0700149 Cflags []string `android:"arch_variant"`
150
151 Enabled *bool `android:"arch_variant"`
152 Whole_static_libs []string `android:"arch_variant"`
153 Static_libs []string `android:"arch_variant"`
154 Shared_libs []string `android:"arch_variant"`
155 System_shared_libs []string `android:"arch_variant"`
156
157 Export_shared_lib_headers []string `android:"arch_variant"`
158 Export_static_lib_headers []string `android:"arch_variant"`
Jiyong Parka90ca002019-10-07 15:47:24 +0900159
160 Apex_available []string `android:"arch_variant"`
Colin Crosse1bb5d02019-09-24 14:55:04 -0700161}
162
Colin Crossa48ab5b2017-02-14 15:28:44 -0800163type LibraryMutatedProperties struct {
Colin Crossb916a382016-07-29 17:28:03 -0700164 // Build a static variant
165 BuildStatic bool `blueprint:"mutated"`
166 // Build a shared variant
167 BuildShared bool `blueprint:"mutated"`
168 // This variant is shared
169 VariantIsShared bool `blueprint:"mutated"`
170 // This variant is static
171 VariantIsStatic bool `blueprint:"mutated"`
Jiyong Park7ed9de32018-10-15 22:25:07 +0900172
173 // This variant is a stubs lib
174 BuildStubs bool `blueprint:"mutated"`
Jiyong Parkd4a3a132021-03-17 20:21:35 +0900175 // This variant is the latest version
176 IsLatestVersion bool `blueprint:"mutated"`
Jiyong Park7ed9de32018-10-15 22:25:07 +0900177 // Version of the stubs lib
178 StubsVersion string `blueprint:"mutated"`
Colin Crossd1f898e2020-08-18 18:35:15 -0700179 // List of all stubs versions associated with an implementation lib
180 AllStubsVersions []string `blueprint:"mutated"`
Colin Crossb916a382016-07-29 17:28:03 -0700181}
182
183type FlagExporterProperties struct {
184 // list of directories relative to the Blueprints file that will
Dan Willemsen273af7f2016-11-03 15:53:42 -0700185 // be added to the include path (using -I) for this module and any module that links
Colin Cross5d195602017-10-17 16:15:50 -0700186 // against this module. Directories listed in export_include_dirs do not need to be
187 // listed in local_include_dirs.
Colin Crossb916a382016-07-29 17:28:03 -0700188 Export_include_dirs []string `android:"arch_variant"`
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700189
Jiyong Park73c54ee2019-10-22 20:31:18 +0900190 // list of directories that will be added to the system include path
191 // using -isystem for this module and any module that links against this module.
192 Export_system_include_dirs []string `android:"arch_variant"`
193
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700194 Target struct {
Justin Yun63e9ec72020-10-29 16:49:43 +0900195 Vendor, Product struct {
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700196 // list of exported include directories, like
Justin Yun63e9ec72020-10-29 16:49:43 +0900197 // export_include_dirs, that will be applied to
198 // vendor or product variant of this library.
199 // This will overwrite any other declarations.
Steven Morelandb21df8f2018-01-05 14:42:54 -0800200 Override_export_include_dirs []string
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700201 }
202 }
Colin Cross4d9c2d12016-07-29 12:48:20 -0700203}
204
205func init() {
Paul Duffin6c26dc72019-12-19 15:02:40 +0000206 RegisterLibraryBuildComponents(android.InitRegistrationContext)
Rupert Shuttleworth095081c2021-03-25 09:06:03 +0000207
208 android.RegisterBp2BuildMutator("cc_library_static", CcLibraryStaticBp2Build)
Paul Duffin6c26dc72019-12-19 15:02:40 +0000209}
210
211func RegisterLibraryBuildComponents(ctx android.RegistrationContext) {
212 ctx.RegisterModuleType("cc_library_static", LibraryStaticFactory)
213 ctx.RegisterModuleType("cc_library_shared", LibrarySharedFactory)
214 ctx.RegisterModuleType("cc_library", LibraryFactory)
215 ctx.RegisterModuleType("cc_library_host_static", LibraryHostStaticFactory)
216 ctx.RegisterModuleType("cc_library_host_shared", LibraryHostSharedFactory)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700217}
218
Patrice Arruda83c89e02019-03-25 15:32:39 -0700219// cc_library creates both static and/or shared libraries for a device and/or
220// host. By default, a cc_library has a single variant that targets the device.
221// Specifying `host_supported: true` also creates a library that targets the
222// host.
Steven Morelandf9e62162017-11-02 17:00:50 -0700223func LibraryFactory() android.Module {
Colin Crossab3b7322016-12-09 14:46:15 -0800224 module, _ := NewLibrary(android.HostAndDeviceSupported)
Paul Duffina0843f62019-12-13 19:50:38 +0000225 // Can be used as both a static and a shared library.
226 module.sdkMemberTypes = []android.SdkMemberType{
227 sharedLibrarySdkMemberType,
228 staticLibrarySdkMemberType,
Paul Duffin9b76c0b2020-03-12 10:24:35 +0000229 staticAndSharedLibrarySdkMemberType,
Paul Duffina0843f62019-12-13 19:50:38 +0000230 }
Colin Cross4d9c2d12016-07-29 12:48:20 -0700231 return module.Init()
232}
233
Patrice Arruda83c89e02019-03-25 15:32:39 -0700234// cc_library_static creates a static library for a device and/or host binary.
Steven Morelandf9e62162017-11-02 17:00:50 -0700235func LibraryStaticFactory() android.Module {
Colin Crossab3b7322016-12-09 14:46:15 -0800236 module, library := NewLibrary(android.HostAndDeviceSupported)
237 library.BuildOnlyStatic()
Paul Duffina0843f62019-12-13 19:50:38 +0000238 module.sdkMemberTypes = []android.SdkMemberType{staticLibrarySdkMemberType}
Chris Parsons808d84c2021-03-09 20:43:32 -0500239 module.bazelHandler = &staticLibraryBazelHandler{module: module}
Colin Cross4d9c2d12016-07-29 12:48:20 -0700240 return module.Init()
241}
242
Patrice Arruda83c89e02019-03-25 15:32:39 -0700243// cc_library_shared creates a shared library for a device and/or host.
Steven Morelandf9e62162017-11-02 17:00:50 -0700244func LibrarySharedFactory() android.Module {
Colin Crossab3b7322016-12-09 14:46:15 -0800245 module, library := NewLibrary(android.HostAndDeviceSupported)
246 library.BuildOnlyShared()
Paul Duffina0843f62019-12-13 19:50:38 +0000247 module.sdkMemberTypes = []android.SdkMemberType{sharedLibrarySdkMemberType}
Colin Cross4d9c2d12016-07-29 12:48:20 -0700248 return module.Init()
249}
250
Patrice Arruda83c89e02019-03-25 15:32:39 -0700251// cc_library_host_static creates a static library that is linkable to a host
252// binary.
Steven Morelandf9e62162017-11-02 17:00:50 -0700253func LibraryHostStaticFactory() android.Module {
Colin Crossab3b7322016-12-09 14:46:15 -0800254 module, library := NewLibrary(android.HostSupported)
255 library.BuildOnlyStatic()
Paul Duffina0843f62019-12-13 19:50:38 +0000256 module.sdkMemberTypes = []android.SdkMemberType{staticLibrarySdkMemberType}
Colin Cross4d9c2d12016-07-29 12:48:20 -0700257 return module.Init()
258}
259
Patrice Arruda83c89e02019-03-25 15:32:39 -0700260// cc_library_host_shared creates a shared library that is usable on a host.
Steven Morelandf9e62162017-11-02 17:00:50 -0700261func LibraryHostSharedFactory() android.Module {
Colin Crossab3b7322016-12-09 14:46:15 -0800262 module, library := NewLibrary(android.HostSupported)
263 library.BuildOnlyShared()
Paul Duffina0843f62019-12-13 19:50:38 +0000264 module.sdkMemberTypes = []android.SdkMemberType{sharedLibrarySdkMemberType}
Colin Cross4d9c2d12016-07-29 12:48:20 -0700265 return module.Init()
266}
267
Chris Parsons3c27ca32020-11-20 12:42:07 -0500268// flagExporter is a separated portion of libraryDecorator pertaining to exported
269// include paths and flags. Keeping this dependency-related information separate
270// from the rest of library information is helpful in keeping data more structured
271// and explicit.
Colin Cross4d9c2d12016-07-29 12:48:20 -0700272type flagExporter struct {
273 Properties FlagExporterProperties
274
Chris Parsons3c27ca32020-11-20 12:42:07 -0500275 dirs android.Paths // Include directories to be included with -I
276 systemDirs android.Paths // System include directories to be included with -isystem
277 flags []string // Exported raw flags.
Inseob Kim69378442019-06-03 19:10:47 +0900278 deps android.Paths
Inseob Kimd110f872019-12-06 13:15:38 +0900279 headers android.Paths
Colin Cross4d9c2d12016-07-29 12:48:20 -0700280}
281
Chris Parsons3c27ca32020-11-20 12:42:07 -0500282// exportedIncludes returns the effective include paths for this module and
283// any module that links against this module. This is obtained from
284// the export_include_dirs property in the appropriate target stanza.
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700285func (f *flagExporter) exportedIncludes(ctx ModuleContext) android.Paths {
Justin Yun6977e8a2020-10-29 18:24:11 +0900286 if ctx.inVendor() && f.Properties.Target.Vendor.Override_export_include_dirs != nil {
Steven Morelandb21df8f2018-01-05 14:42:54 -0800287 return android.PathsForModuleSrc(ctx, f.Properties.Target.Vendor.Override_export_include_dirs)
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700288 }
Justin Yun6977e8a2020-10-29 18:24:11 +0900289 if ctx.inProduct() && f.Properties.Target.Product.Override_export_include_dirs != nil {
290 return android.PathsForModuleSrc(ctx, f.Properties.Target.Product.Override_export_include_dirs)
291 }
292 return android.PathsForModuleSrc(ctx, f.Properties.Export_include_dirs)
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700293}
294
Chris Parsons3c27ca32020-11-20 12:42:07 -0500295// exportIncludes registers the include directories and system include directories to be exported
296// transitively to modules depending on this module.
Inseob Kim69378442019-06-03 19:10:47 +0900297func (f *flagExporter) exportIncludes(ctx ModuleContext) {
Jiyong Park74955042019-10-22 20:19:51 +0900298 f.dirs = append(f.dirs, 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)...)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700300}
301
Chris Parsons3c27ca32020-11-20 12:42:07 -0500302// exportIncludesAsSystem registers the include directories and system include directories to be
303// exported transitively both as system include directories to modules depending on this module.
Inseob Kim69378442019-06-03 19:10:47 +0900304func (f *flagExporter) exportIncludesAsSystem(ctx ModuleContext) {
Jiyong Park73c54ee2019-10-22 20:31:18 +0900305 // all dirs are force exported as system
Jiyong Park74955042019-10-22 20:19:51 +0900306 f.systemDirs = append(f.systemDirs, f.exportedIncludes(ctx)...)
Jiyong Park73c54ee2019-10-22 20:31:18 +0900307 f.systemDirs = append(f.systemDirs, android.PathsForModuleSrc(ctx, f.Properties.Export_system_include_dirs)...)
Inseob Kim69378442019-06-03 19:10:47 +0900308}
309
Chris Parsons3c27ca32020-11-20 12:42:07 -0500310// reexportDirs registers the given directories as include directories to be exported transitively
311// to modules depending on this module.
Jiyong Park74955042019-10-22 20:19:51 +0900312func (f *flagExporter) reexportDirs(dirs ...android.Path) {
Inseob Kim69378442019-06-03 19:10:47 +0900313 f.dirs = append(f.dirs, dirs...)
314}
315
Chris Parsons3c27ca32020-11-20 12:42:07 -0500316// reexportSystemDirs registers the given directories as system include directories
317// to be exported transitively to modules depending on this module.
Jiyong Park74955042019-10-22 20:19:51 +0900318func (f *flagExporter) reexportSystemDirs(dirs ...android.Path) {
Inseob Kim69378442019-06-03 19:10:47 +0900319 f.systemDirs = append(f.systemDirs, dirs...)
320}
321
Chris Parsons3c27ca32020-11-20 12:42:07 -0500322// reexportFlags registers the flags to be exported transitively to modules depending on this
323// module.
Inseob Kim69378442019-06-03 19:10:47 +0900324func (f *flagExporter) reexportFlags(flags ...string) {
Jaewoong Jung3aff5782020-02-11 07:54:35 -0800325 if android.PrefixInList(flags, "-I") || android.PrefixInList(flags, "-isystem") {
326 panic(fmt.Errorf("Exporting invalid flag %q: "+
327 "use reexportDirs or reexportSystemDirs to export directories", flag))
Inseob Kim69378442019-06-03 19:10:47 +0900328 }
Colin Cross4d9c2d12016-07-29 12:48:20 -0700329 f.flags = append(f.flags, flags...)
330}
331
Inseob Kim69378442019-06-03 19:10:47 +0900332func (f *flagExporter) reexportDeps(deps ...android.Path) {
333 f.deps = append(f.deps, deps...)
334}
335
Inseob Kimd110f872019-12-06 13:15:38 +0900336// addExportedGeneratedHeaders does nothing but collects generated header files.
337// This can be differ to exportedDeps which may contain phony files to minimize ninja.
338func (f *flagExporter) addExportedGeneratedHeaders(headers ...android.Path) {
339 f.headers = append(f.headers, headers...)
340}
341
Colin Cross0de8a1e2020-09-18 14:15:30 -0700342func (f *flagExporter) setProvider(ctx android.ModuleContext) {
343 ctx.SetProvider(FlagExporterInfoProvider, FlagExporterInfo{
344 IncludeDirs: f.dirs,
345 SystemIncludeDirs: f.systemDirs,
346 Flags: f.flags,
347 Deps: f.deps,
348 GeneratedHeaders: f.headers,
349 })
Inseob Kim69378442019-06-03 19:10:47 +0900350}
351
Colin Crossb916a382016-07-29 17:28:03 -0700352// libraryDecorator wraps baseCompiler, baseLinker and baseInstaller to provide library-specific
353// functionality: static vs. shared linkage, reusing object files for shared libraries
354type libraryDecorator struct {
Colin Crossa48ab5b2017-02-14 15:28:44 -0800355 Properties LibraryProperties
Colin Crosse1bb5d02019-09-24 14:55:04 -0700356 StaticProperties StaticProperties
357 SharedProperties SharedProperties
Colin Crossa48ab5b2017-02-14 15:28:44 -0800358 MutatedProperties LibraryMutatedProperties
Colin Cross4d9c2d12016-07-29 12:48:20 -0700359
360 // For reusing static library objects for shared library
Inseob Kim69378442019-06-03 19:10:47 +0900361 reuseObjects Objects
Colin Cross10d22312017-05-03 11:01:58 -0700362
Colin Cross26c34ed2016-09-30 17:10:16 -0700363 // table-of-contents file to optimize out relinking when possible
364 tocFile android.OptionalPath
Colin Cross4d9c2d12016-07-29 12:48:20 -0700365
Colin Cross4d9c2d12016-07-29 12:48:20 -0700366 flagExporter
Thiébaud Weksteend4587452020-08-19 14:53:01 +0200367 stripper Stripper
Colin Cross4d9c2d12016-07-29 12:48:20 -0700368
Colin Cross4d9c2d12016-07-29 12:48:20 -0700369 // For whole_static_libs
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700370 objects Objects
Colin Cross4d9c2d12016-07-29 12:48:20 -0700371
372 // Uses the module's name if empty, but can be overridden. Does not include
373 // shlib suffix.
374 libName string
Colin Crossb916a382016-07-29 17:28:03 -0700375
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800376 sabi *sabi
377
Dan Willemsen581341d2017-02-09 16:16:31 -0800378 // Output archive of gcno coverage information files
379 coverageOutputFile android.OptionalPath
380
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800381 // linked Source Abi Dump
382 sAbiOutputFile android.OptionalPath
383
384 // Source Abi Diff
385 sAbiDiff android.OptionalPath
386
Colin Cross0875c522017-11-28 17:34:01 -0800387 // Location of the static library in the sysroot. Empty if the library is
388 // not included in the NDK.
389 ndkSysrootPath android.Path
390
Colin Crossb60190a2018-09-04 16:28:17 -0700391 // Location of the linked, unstripped library for shared libraries
392 unstrippedOutputFile android.Path
393
Dan Willemsen569edc52018-11-19 09:33:29 -0800394 // Location of the file that should be copied to dist dir when requested
Jingwen Chen40fd90a2020-06-15 05:24:19 +0000395 distFile android.Path
Dan Willemsen569edc52018-11-19 09:33:29 -0800396
Colin Cross8e21aa52020-09-28 18:28:02 -0700397 versionScriptPath android.OptionalPath
Jiyong Park7ed9de32018-10-15 22:25:07 +0900398
Jaewoong Jung18aefc12020-12-21 09:11:10 -0800399 postInstallCmds []string
Jiyong Parkf1194352019-02-25 11:05:47 +0900400
Vic Yangefd249e2018-11-12 20:19:56 -0800401 // If useCoreVariant is true, the vendor variant of a VNDK library is
402 // not installed.
Vic Yangd92090f2020-01-08 14:32:28 -0800403 useCoreVariant bool
404 checkSameCoreVariant bool
Vic Yangefd249e2018-11-12 20:19:56 -0800405
Colin Cross5ec407b2020-09-30 11:41:33 -0700406 skipAPIDefine bool
407
Martin Stjernholmc5dd4f72020-04-01 20:38:01 +0100408 // Decorated interfaces
Colin Crossb916a382016-07-29 17:28:03 -0700409 *baseCompiler
410 *baseLinker
411 *baseInstaller
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900412
413 collectedSnapshotHeaders android.Paths
414}
415
Chris Parsons808d84c2021-03-09 20:43:32 -0500416type staticLibraryBazelHandler struct {
417 bazelHandler
418
419 module *Module
420}
421
422func (handler *staticLibraryBazelHandler) generateBazelBuildActions(ctx android.ModuleContext, label string) bool {
423 bazelCtx := ctx.Config().BazelContext
Chris Parsons944e7d02021-03-11 11:08:46 -0500424 outputPaths, objPaths, ok := bazelCtx.GetOutputFilesAndCcObjectFiles(label, ctx.Arch().ArchType)
425 if !ok {
426 return ok
Chris Parsons808d84c2021-03-09 20:43:32 -0500427 }
Chris Parsons944e7d02021-03-11 11:08:46 -0500428 if len(outputPaths) != 1 {
429 // TODO(cparsons): This is actually expected behavior for static libraries with no srcs.
430 // We should support this.
431 ctx.ModuleErrorf("expected exactly one output file for '%s', but got %s", label, objPaths)
432 return false
433 }
434 outputFilePath := android.PathForBazelOut(ctx, outputPaths[0])
435 handler.module.outputFile = android.OptionalPathForPath(outputFilePath)
436
437 objFiles := make(android.Paths, len(objPaths))
438 for i, objPath := range objPaths {
439 objFiles[i] = android.PathForBazelOut(ctx, objPath)
440 }
441 objects := Objects{
442 objFiles: objFiles,
443 }
444
445 ctx.SetProvider(StaticLibraryInfoProvider, StaticLibraryInfo{
446 StaticLibrary: outputFilePath,
447 ReuseObjects: objects,
448 Objects: objects,
449
450 // TODO(cparsons): Include transitive static libraries in this provider to support
451 // static libraries with deps.
452 TransitiveStaticLibrariesForOrdering: android.NewDepSetBuilder(android.TOPOLOGICAL).
453 Direct(outputFilePath).
454 Build(),
455 })
456 handler.module.outputFile = android.OptionalPathForPath(android.PathForBazelOut(ctx, objPaths[0]))
Chris Parsons808d84c2021-03-09 20:43:32 -0500457 return ok
458}
459
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900460// collectHeadersForSnapshot collects all exported headers from library.
461// It globs header files in the source tree for exported include directories,
462// and tracks generated header files separately.
463//
464// This is to be called from GenerateAndroidBuildActions, and then collected
465// header files can be retrieved by snapshotHeaders().
466func (l *libraryDecorator) collectHeadersForSnapshot(ctx android.ModuleContext) {
467 ret := android.Paths{}
468
469 // Headers in the source tree should be globbed. On the contrast, generated headers
470 // can't be globbed, and they should be manually collected.
471 // So, we first filter out intermediate directories (which contains generated headers)
472 // from exported directories, and then glob headers under remaining directories.
Colin Cross0de8a1e2020-09-18 14:15:30 -0700473 for _, path := range append(android.CopyOfPaths(l.flagExporter.dirs), l.flagExporter.systemDirs...) {
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900474 dir := path.String()
475 // Skip if dir is for generated headers
476 if strings.HasPrefix(dir, android.PathForOutput(ctx).String()) {
477 continue
478 }
Inseob Kim04f2d6a2020-05-29 22:30:58 +0900479 // libeigen wrongly exports the root directory "external/eigen". But only two
480 // subdirectories "Eigen" and "unsupported" contain exported header files. Even worse
481 // some of them have no extension. So we need special treatment for libeigen in order
482 // to glob correctly.
483 if dir == "external/eigen" {
484 // Only these two directories contains exported headers.
485 for _, subdir := range []string{"Eigen", "unsupported/Eigen"} {
486 glob, err := ctx.GlobWithDeps("external/eigen/"+subdir+"/**/*", nil)
487 if err != nil {
488 ctx.ModuleErrorf("glob failed: %#v", err)
489 return
490 }
491 for _, header := range glob {
492 if strings.HasSuffix(header, "/") {
493 continue
494 }
495 ext := filepath.Ext(header)
496 if ext != "" && ext != ".h" {
497 continue
498 }
499 ret = append(ret, android.PathForSource(ctx, header))
500 }
501 }
502 continue
503 }
Colin Crossec118d02021-01-22 18:05:59 +0000504 glob, err := ctx.GlobWithDeps(dir+"/**/*", nil)
505 if err != nil {
506 ctx.ModuleErrorf("glob failed: %#v", err)
507 return
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900508 }
Colin Crossec118d02021-01-22 18:05:59 +0000509 isLibcxx := strings.HasPrefix(dir, "external/libcxx/include")
Jose Galmes0d736912021-03-30 11:00:06 -0700510 for _, header := range glob {
Colin Crossec118d02021-01-22 18:05:59 +0000511 if isLibcxx {
512 // Glob all files under this special directory, because of C++ headers with no
513 // extension.
Jose Galmes0d736912021-03-30 11:00:06 -0700514 if strings.HasSuffix(header, "/") {
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900515 continue
516 }
Colin Crossec118d02021-01-22 18:05:59 +0000517 } else {
518 // Filter out only the files with extensions that are headers.
519 found := false
520 for _, ext := range headerExts {
521 if strings.HasSuffix(header, ext) {
522 found = true
523 break
524 }
525 }
526 if !found {
527 continue
528 }
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900529 }
Jose Galmes0d736912021-03-30 11:00:06 -0700530 ret = append(ret, android.PathForSource(ctx, header))
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900531 }
532 }
533
534 // Collect generated headers
Colin Cross0de8a1e2020-09-18 14:15:30 -0700535 for _, header := range append(android.CopyOfPaths(l.flagExporter.headers), l.flagExporter.deps...) {
Inseob Kimeda2e9c2020-03-03 22:06:32 +0900536 // TODO(b/148123511): remove exportedDeps after cleaning up genrule
537 if strings.HasSuffix(header.Base(), "-phony") {
538 continue
539 }
540 ret = append(ret, header)
541 }
542
543 l.collectedSnapshotHeaders = ret
544}
545
546// This returns all exported header files, both generated ones and headers from source tree.
547// collectHeadersForSnapshot() must be called before calling this.
548func (l *libraryDecorator) snapshotHeaders() android.Paths {
549 if l.collectedSnapshotHeaders == nil {
550 panic("snapshotHeaders() must be called after collectHeadersForSnapshot()")
551 }
552 return l.collectedSnapshotHeaders
Colin Cross4d9c2d12016-07-29 12:48:20 -0700553}
554
Chris Parsons3c27ca32020-11-20 12:42:07 -0500555// linkerProps returns the list of properties structs relevant for this library. (For example, if
556// the library is cc_shared_library, then static-library properties are omitted.)
Colin Crossb916a382016-07-29 17:28:03 -0700557func (library *libraryDecorator) linkerProps() []interface{} {
558 var props []interface{}
559 props = append(props, library.baseLinker.linkerProps()...)
Colin Crosse1bb5d02019-09-24 14:55:04 -0700560 props = append(props,
Colin Cross4d9c2d12016-07-29 12:48:20 -0700561 &library.Properties,
Colin Crossa48ab5b2017-02-14 15:28:44 -0800562 &library.MutatedProperties,
Colin Cross4d9c2d12016-07-29 12:48:20 -0700563 &library.flagExporter.Properties,
Colin Cross22f37952018-09-05 10:43:13 -0700564 &library.stripper.StripProperties)
Colin Crosse1bb5d02019-09-24 14:55:04 -0700565
566 if library.MutatedProperties.BuildShared {
567 props = append(props, &library.SharedProperties)
568 }
569 if library.MutatedProperties.BuildStatic {
570 props = append(props, &library.StaticProperties)
571 }
572
573 return props
Colin Cross4d9c2d12016-07-29 12:48:20 -0700574}
575
Chris Parsons3c27ca32020-11-20 12:42:07 -0500576// linkerFlags takes a Flags struct and augments it to contain linker flags that are defined by this
577// library, or that are implied by attributes of this library (such as whether this library is a
578// shared library).
Colin Crossb916a382016-07-29 17:28:03 -0700579func (library *libraryDecorator) linkerFlags(ctx ModuleContext, flags Flags) Flags {
Colin Cross42742b82016-08-01 13:20:05 -0700580 flags = library.baseLinker.linkerFlags(ctx, flags)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700581
Colin Crossb916a382016-07-29 17:28:03 -0700582 // MinGW spits out warnings about -fPIC even for -fpie?!) being ignored because
583 // all code is position independent, and then those warnings get promoted to
584 // errors.
Colin Cross3edeee12017-04-04 12:59:48 -0700585 if !ctx.Windows() {
Colin Cross4af21ed2019-11-04 09:37:55 -0800586 flags.Global.CFlags = append(flags.Global.CFlags, "-fPIC")
Colin Crossb916a382016-07-29 17:28:03 -0700587 }
588
589 if library.static() {
Colin Cross4af21ed2019-11-04 09:37:55 -0800590 flags.Local.CFlags = append(flags.Local.CFlags, library.StaticProperties.Static.Cflags...)
Colin Crossa48ab5b2017-02-14 15:28:44 -0800591 } else if library.shared() {
Colin Cross4af21ed2019-11-04 09:37:55 -0800592 flags.Local.CFlags = append(flags.Local.CFlags, library.SharedProperties.Shared.Cflags...)
Colin Crossb916a382016-07-29 17:28:03 -0700593 }
594
Colin Crossa48ab5b2017-02-14 15:28:44 -0800595 if library.shared() {
Colin Cross4d9c2d12016-07-29 12:48:20 -0700596 libName := library.getLibName(ctx)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700597 var f []string
Dan Willemsen01a405a2016-06-13 17:19:03 -0700598 if ctx.toolchain().Bionic() {
Colin Cross4d9c2d12016-07-29 12:48:20 -0700599 f = append(f,
600 "-nostdlib",
601 "-Wl,--gc-sections",
602 )
603 }
604
605 if ctx.Darwin() {
606 f = append(f,
607 "-dynamiclib",
608 "-single_module",
Colin Cross4d9c2d12016-07-29 12:48:20 -0700609 "-install_name @rpath/"+libName+flags.Toolchain.ShlibSuffix(),
610 )
Colin Cross7863cf52016-10-20 10:47:21 -0700611 if ctx.Arch().ArchType == android.X86 {
612 f = append(f,
613 "-read_only_relocs suppress",
614 )
615 }
Colin Cross4d9c2d12016-07-29 12:48:20 -0700616 } else {
Josh Gao75a50a22019-06-07 17:58:59 -0700617 f = append(f, "-shared")
618 if !ctx.Windows() {
619 f = append(f, "-Wl,-soname,"+libName+flags.Toolchain.ShlibSuffix())
620 }
Colin Cross4d9c2d12016-07-29 12:48:20 -0700621 }
622
Colin Cross4af21ed2019-11-04 09:37:55 -0800623 flags.Global.LdFlags = append(flags.Global.LdFlags, f...)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700624 }
625
626 return flags
627}
628
Chris Parsons3c27ca32020-11-20 12:42:07 -0500629// compilerFlags takes a Flags and augments it to contain compile flags from global values,
630// per-target values, module type values, per-module Blueprints properties, extra flags from
631// `flags`, and generated sources from `deps`.
Colin Crossf18e1102017-11-16 14:33:08 -0800632func (library *libraryDecorator) compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags {
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700633 exportIncludeDirs := library.flagExporter.exportedIncludes(ctx)
Dan Willemsen273af7f2016-11-03 15:53:42 -0700634 if len(exportIncludeDirs) > 0 {
Colin Crossdad8c952017-04-26 14:55:27 -0700635 f := includeDirsToFlags(exportIncludeDirs)
Colin Cross4af21ed2019-11-04 09:37:55 -0800636 flags.Local.CommonFlags = append(flags.Local.CommonFlags, f)
637 flags.Local.YasmFlags = append(flags.Local.YasmFlags, f)
Dan Willemsen273af7f2016-11-03 15:53:42 -0700638 }
639
Jiyong Park7ed9de32018-10-15 22:25:07 +0900640 flags = library.baseCompiler.compilerFlags(ctx, flags, deps)
Colin Cross127bb8b2020-12-16 16:46:01 -0800641 if ctx.IsLlndk() {
642 // LLNDK libraries ignore most of the properties on the cc_library and use the
643 // LLNDK-specific properties instead.
644 // Wipe all the module-local properties, leaving only the global properties.
645 flags.Local = LocalOrGlobalFlags{}
646 }
Jiyong Park7ed9de32018-10-15 22:25:07 +0900647 if library.buildStubs() {
Jiyong Park64379952018-12-13 18:37:29 +0900648 // Remove -include <file> when compiling stubs. Otherwise, the force included
649 // headers might cause conflicting types error with the symbols in the
650 // generated stubs source code. e.g.
651 // double acos(double); // in header
652 // void acos() {} // in the generated source code
653 removeInclude := func(flags []string) []string {
654 ret := flags[:0]
655 for _, f := range flags {
656 if strings.HasPrefix(f, "-include ") {
657 continue
658 }
659 ret = append(ret, f)
660 }
661 return ret
662 }
Colin Cross4af21ed2019-11-04 09:37:55 -0800663 flags.Local.CommonFlags = removeInclude(flags.Local.CommonFlags)
664 flags.Local.CFlags = removeInclude(flags.Local.CFlags)
Jiyong Park64379952018-12-13 18:37:29 +0900665
Jiyong Park7ed9de32018-10-15 22:25:07 +0900666 flags = addStubLibraryCompilerFlags(flags)
667 }
668 return flags
Dan Willemsen273af7f2016-11-03 15:53:42 -0700669}
670
Yo Chiang2bbadfa2020-12-14 11:42:16 +0800671func (library *libraryDecorator) headerAbiCheckerEnabled() bool {
672 return Bool(library.Properties.Header_abi_checker.Enabled)
Hsin-Yi Chen53489642019-07-31 17:10:45 +0800673}
674
Yo Chiang2bbadfa2020-12-14 11:42:16 +0800675func (library *libraryDecorator) headerAbiCheckerExplicitlyDisabled() bool {
676 return !BoolDefault(library.Properties.Header_abi_checker.Enabled, true)
Logan Chien41eabe62019-04-10 13:33:58 +0800677}
678
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700679func (library *libraryDecorator) compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects {
Colin Cross127bb8b2020-12-16 16:46:01 -0800680 if ctx.IsLlndk() {
681 // This is the vendor variant of an LLNDK library, build the LLNDK stubs.
682 vndkVer := ctx.Module().(*Module).VndkVersion()
683 if !inList(vndkVer, ctx.Config().PlatformVersionActiveCodenames()) || vndkVer == "" {
684 // For non-enforcing devices, vndkVer is empty. Use "current" in that case, too.
685 vndkVer = "current"
686 }
687 if library.stubsVersion() != "" {
688 vndkVer = library.stubsVersion()
689 }
690 objs, versionScript := compileStubLibrary(ctx, flags, String(library.Properties.Llndk.Symbol_file), vndkVer, "--llndk")
691 if !Bool(library.Properties.Llndk.Unversioned) {
692 library.versionScriptPath = android.OptionalPathForPath(versionScript)
693 }
694 return objs
695 }
Jiyong Park7ed9de32018-10-15 22:25:07 +0900696 if library.buildStubs() {
Jiyong Parka4175572021-02-04 21:05:47 +0900697 symbolFile := String(library.Properties.Stubs.Symbol_file)
698 if symbolFile != "" && !strings.HasSuffix(symbolFile, ".map.txt") {
699 ctx.PropertyErrorf("symbol_file", "%q doesn't have .map.txt suffix", symbolFile)
700 return Objects{}
701 }
Jiyong Park3fd0baf2018-12-07 16:25:39 +0900702 objs, versionScript := compileStubLibrary(ctx, flags, String(library.Properties.Stubs.Symbol_file), library.MutatedProperties.StubsVersion, "--apex")
Colin Cross8e21aa52020-09-28 18:28:02 -0700703 library.versionScriptPath = android.OptionalPathForPath(versionScript)
Jiyong Park7ed9de32018-10-15 22:25:07 +0900704 return objs
705 }
706
Colin Cross5950f382016-12-13 12:50:57 -0800707 if !library.buildShared() && !library.buildStatic() {
708 if len(library.baseCompiler.Properties.Srcs) > 0 {
709 ctx.PropertyErrorf("srcs", "cc_library_headers must not have any srcs")
710 }
Colin Crosse1bb5d02019-09-24 14:55:04 -0700711 if len(library.StaticProperties.Static.Srcs) > 0 {
Colin Cross5950f382016-12-13 12:50:57 -0800712 ctx.PropertyErrorf("static.srcs", "cc_library_headers must not have any srcs")
713 }
Colin Crosse1bb5d02019-09-24 14:55:04 -0700714 if len(library.SharedProperties.Shared.Srcs) > 0 {
Colin Cross5950f382016-12-13 12:50:57 -0800715 ctx.PropertyErrorf("shared.srcs", "cc_library_headers must not have any srcs")
716 }
717 return Objects{}
718 }
Yo Chiang2bbadfa2020-12-14 11:42:16 +0800719 if library.sabi.shouldCreateSourceAbiDump() {
Jayant Chowdharya4fce192017-09-06 13:10:03 -0700720 exportIncludeDirs := library.flagExporter.exportedIncludes(ctx)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800721 var SourceAbiFlags []string
722 for _, dir := range exportIncludeDirs.Strings() {
Jayant Chowdhary715cac32017-04-20 06:53:59 -0700723 SourceAbiFlags = append(SourceAbiFlags, "-I"+dir)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800724 }
Inseob Kim69378442019-06-03 19:10:47 +0900725 for _, reexportedInclude := range library.sabi.Properties.ReexportedIncludes {
726 SourceAbiFlags = append(SourceAbiFlags, "-I"+reexportedInclude)
Jayant Chowdhary715cac32017-04-20 06:53:59 -0700727 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800728 flags.SAbiFlags = SourceAbiFlags
Jaewoong Jung18aefc12020-12-21 09:11:10 -0800729 totalLength := len(library.baseCompiler.Properties.Srcs) + len(deps.GeneratedSources) +
Colin Crosse1bb5d02019-09-24 14:55:04 -0700730 len(library.SharedProperties.Shared.Srcs) + len(library.StaticProperties.Static.Srcs)
Jaewoong Jung18aefc12020-12-21 09:11:10 -0800731 if totalLength > 0 {
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800732 flags.SAbiDump = true
733 }
734 }
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700735 objs := library.baseCompiler.compile(ctx, flags, deps)
736 library.reuseObjects = objs
Colin Cross2f336352016-10-26 10:03:47 -0700737 buildFlags := flagsToBuilderFlags(flags)
Colin Crossb916a382016-07-29 17:28:03 -0700738
Colin Cross4d9c2d12016-07-29 12:48:20 -0700739 if library.static() {
Colin Crosse1bb5d02019-09-24 14:55:04 -0700740 srcs := android.PathsForModuleSrc(ctx, library.StaticProperties.Static.Srcs)
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700741 objs = objs.Append(compileObjs(ctx, buildFlags, android.DeviceStaticLibrary,
Pirama Arumuga Nainarf231b192018-01-23 10:49:04 -0800742 srcs, library.baseCompiler.pathDeps, library.baseCompiler.cFlagsDeps))
Colin Crossa48ab5b2017-02-14 15:28:44 -0800743 } else if library.shared() {
Colin Crosse1bb5d02019-09-24 14:55:04 -0700744 srcs := android.PathsForModuleSrc(ctx, library.SharedProperties.Shared.Srcs)
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700745 objs = objs.Append(compileObjs(ctx, buildFlags, android.DeviceSharedLibrary,
Pirama Arumuga Nainarf231b192018-01-23 10:49:04 -0800746 srcs, library.baseCompiler.pathDeps, library.baseCompiler.cFlagsDeps))
Colin Crossb916a382016-07-29 17:28:03 -0700747 }
748
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700749 return objs
Colin Crossb916a382016-07-29 17:28:03 -0700750}
751
752type libraryInterface interface {
Colin Cross3572cf72020-10-01 15:58:11 -0700753 versionedInterface
754
Colin Crossb916a382016-07-29 17:28:03 -0700755 static() bool
Inseob Kimae553032019-05-14 18:52:49 +0900756 shared() bool
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700757 objs() Objects
Colin Cross0de8a1e2020-09-18 14:15:30 -0700758 reuseObjs() Objects
Colin Cross26c34ed2016-09-30 17:10:16 -0700759 toc() android.OptionalPath
Colin Crossb916a382016-07-29 17:28:03 -0700760
761 // Returns true if the build options for the module have selected a static or shared build
762 buildStatic() bool
763 buildShared() bool
764
765 // Sets whether a specific variant is static or shared
Colin Crossa48ab5b2017-02-14 15:28:44 -0800766 setStatic()
767 setShared()
Logan Chien41eabe62019-04-10 13:33:58 +0800768
Yo Chiang2bbadfa2020-12-14 11:42:16 +0800769 // Check whether header_abi_checker is enabled or explicitly disabled.
770 headerAbiCheckerEnabled() bool
771 headerAbiCheckerExplicitlyDisabled() bool
772
Logan Chien41eabe62019-04-10 13:33:58 +0800773 // Write LOCAL_ADDITIONAL_DEPENDENCIES for ABI diff
774 androidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer)
Jiyong Parka90ca002019-10-07 15:47:24 +0900775
776 availableFor(string) bool
Colin Crossb916a382016-07-29 17:28:03 -0700777}
778
Colin Crossc88c2722020-09-28 17:32:47 -0700779type versionedInterface interface {
780 buildStubs() bool
Jiyong Parkd4a3a132021-03-17 20:21:35 +0900781 setBuildStubs(isLatest bool)
Colin Crossc88c2722020-09-28 17:32:47 -0700782 hasStubsVariants() bool
783 setStubsVersion(string)
784 stubsVersion() string
785
Colin Cross3572cf72020-10-01 15:58:11 -0700786 stubsVersions(ctx android.BaseMutatorContext) []string
Colin Crossc88c2722020-09-28 17:32:47 -0700787 setAllStubsVersions([]string)
788 allStubsVersions() []string
Colin Cross0477b422020-10-13 18:43:54 -0700789
790 implementationModuleName(name string) string
Colin Cross127bb8b2020-12-16 16:46:01 -0800791 hasLLNDKStubs() bool
Colin Crossc88c2722020-09-28 17:32:47 -0700792}
793
794var _ libraryInterface = (*libraryDecorator)(nil)
795var _ versionedInterface = (*libraryDecorator)(nil)
796
Justin Yun6977e8a2020-10-29 18:24:11 +0900797func (library *libraryDecorator) getLibNameHelper(baseModuleName string, inVendor bool, inProduct bool) string {
Colin Crossb916a382016-07-29 17:28:03 -0700798 name := library.libName
799 if name == "" {
dimitryd95964a2018-11-07 13:43:34 +0100800 name = String(library.Properties.Stem)
801 if name == "" {
Jooyung Han0302a842019-10-30 18:43:49 +0900802 name = baseModuleName
dimitryd95964a2018-11-07 13:43:34 +0100803 }
Colin Crossb916a382016-07-29 17:28:03 -0700804 }
805
Colin Cross0fd6a412019-08-16 14:22:10 -0700806 suffix := ""
Justin Yun6977e8a2020-10-29 18:24:11 +0900807 if inVendor {
Colin Cross0fd6a412019-08-16 14:22:10 -0700808 suffix = String(library.Properties.Target.Vendor.Suffix)
Justin Yun6977e8a2020-10-29 18:24:11 +0900809 } else if inProduct {
810 suffix = String(library.Properties.Target.Product.Suffix)
Colin Cross0fd6a412019-08-16 14:22:10 -0700811 }
812 if suffix == "" {
813 suffix = String(library.Properties.Suffix)
814 }
815
Jooyung Han0302a842019-10-30 18:43:49 +0900816 return name + suffix
817}
818
Chris Parsons3c27ca32020-11-20 12:42:07 -0500819// getLibName returns the actual canonical name of the library (the name which
820// should be passed to the linker via linker flags).
Jooyung Han0302a842019-10-30 18:43:49 +0900821func (library *libraryDecorator) getLibName(ctx BaseModuleContext) string {
Justin Yun6977e8a2020-10-29 18:24:11 +0900822 name := library.getLibNameHelper(ctx.baseModuleName(), ctx.inVendor(), ctx.inProduct())
Colin Cross0fd6a412019-08-16 14:22:10 -0700823
Ivan Lozanof9e21722020-12-02 09:00:51 -0500824 if ctx.IsVndkExt() {
Jooyung Han4c2b9422019-10-22 19:53:47 +0900825 // vndk-ext lib should have the same name with original lib
826 ctx.VisitDirectDepsWithTag(vndkExtDepTag, func(module android.Module) {
827 originalName := module.(*Module).outputFile.Path()
828 name = strings.TrimSuffix(originalName.Base(), originalName.Ext())
829 })
Logan Chienf3511742017-10-31 18:04:35 +0800830 }
831
Colin Crossb916a382016-07-29 17:28:03 -0700832 if ctx.Host() && Bool(library.Properties.Unique_host_soname) {
833 if !strings.HasSuffix(name, "-host") {
834 name = name + "-host"
835 }
836 }
837
Inseob Kim0ce291e2019-07-04 14:38:27 +0900838 return name
Colin Crossb916a382016-07-29 17:28:03 -0700839}
840
Jiyong Parkda732bd2018-11-02 18:23:15 +0900841var versioningMacroNamesListMutex sync.Mutex
842
Colin Crossb916a382016-07-29 17:28:03 -0700843func (library *libraryDecorator) linkerInit(ctx BaseModuleContext) {
844 location := InstallInSystem
Dan Albert61f32122018-07-26 14:00:24 -0700845 if library.baseLinker.sanitize.inSanitizerDir() {
Vishwath Mohan1dd88392017-03-29 22:00:18 -0700846 location = InstallInSanitizerDir
Colin Crossb916a382016-07-29 17:28:03 -0700847 }
848 library.baseInstaller.location = location
Colin Crossb916a382016-07-29 17:28:03 -0700849 library.baseLinker.linkerInit(ctx)
Jiyong Park7ed9de32018-10-15 22:25:07 +0900850 // Let baseLinker know whether this variant is for stubs or not, so that
851 // it can omit things that are not required for linking stubs.
852 library.baseLinker.dynamicProperties.BuildStubs = library.buildStubs()
Jiyong Parkda732bd2018-11-02 18:23:15 +0900853
854 if library.buildStubs() {
855 macroNames := versioningMacroNamesList(ctx.Config())
856 myName := versioningMacroName(ctx.ModuleName())
857 versioningMacroNamesListMutex.Lock()
858 defer versioningMacroNamesListMutex.Unlock()
859 if (*macroNames)[myName] == "" {
860 (*macroNames)[myName] = ctx.ModuleName()
861 } else if (*macroNames)[myName] != ctx.ModuleName() {
862 ctx.ModuleErrorf("Macro name %q for versioning conflicts with macro name from module %q ", myName, (*macroNames)[myName])
863 }
864 }
Colin Crossb916a382016-07-29 17:28:03 -0700865}
866
dimitry0345ad82018-12-05 16:28:14 +0100867func (library *libraryDecorator) compilerDeps(ctx DepsContext, deps Deps) Deps {
Colin Cross127bb8b2020-12-16 16:46:01 -0800868 if ctx.IsLlndk() {
869 // LLNDK libraries ignore most of the properties on the cc_library and use the
870 // LLNDK-specific properties instead.
871 return deps
872 }
873
dimitry0345ad82018-12-05 16:28:14 +0100874 deps = library.baseCompiler.compilerDeps(ctx, deps)
875
dimitry0345ad82018-12-05 16:28:14 +0100876 return deps
877}
878
Colin Cross37047f12016-12-13 17:06:13 -0800879func (library *libraryDecorator) linkerDeps(ctx DepsContext, deps Deps) Deps {
Colin Cross127bb8b2020-12-16 16:46:01 -0800880 if ctx.IsLlndk() {
881 // LLNDK libraries ignore most of the properties on the cc_library and use the
882 // LLNDK-specific properties instead.
883 deps.HeaderLibs = append(deps.HeaderLibs, library.Properties.Llndk.Export_llndk_headers...)
884 deps.ReexportHeaderLibHeaders = append(deps.ReexportHeaderLibHeaders,
885 library.Properties.Llndk.Export_llndk_headers...)
886 return deps
887 }
888
Dan Willemsen3a26eef2018-12-03 15:25:46 -0800889 if library.static() {
Martin Stjernholm10566a02020-03-24 01:19:52 +0000890 // Compare with nil because an empty list needs to be propagated.
Colin Crosse1bb5d02019-09-24 14:55:04 -0700891 if library.StaticProperties.Static.System_shared_libs != nil {
892 library.baseLinker.Properties.System_shared_libs = library.StaticProperties.Static.System_shared_libs
Dan Willemsen3a26eef2018-12-03 15:25:46 -0800893 }
894 } else if library.shared() {
Martin Stjernholm10566a02020-03-24 01:19:52 +0000895 // Compare with nil because an empty list needs to be propagated.
Colin Crosse1bb5d02019-09-24 14:55:04 -0700896 if library.SharedProperties.Shared.System_shared_libs != nil {
897 library.baseLinker.Properties.System_shared_libs = library.SharedProperties.Shared.System_shared_libs
Dan Willemsen3a26eef2018-12-03 15:25:46 -0800898 }
899 }
900
Colin Crossb916a382016-07-29 17:28:03 -0700901 deps = library.baseLinker.linkerDeps(ctx, deps)
902
903 if library.static() {
904 deps.WholeStaticLibs = append(deps.WholeStaticLibs,
Colin Crosse1bb5d02019-09-24 14:55:04 -0700905 library.StaticProperties.Static.Whole_static_libs...)
906 deps.StaticLibs = append(deps.StaticLibs, library.StaticProperties.Static.Static_libs...)
907 deps.SharedLibs = append(deps.SharedLibs, library.StaticProperties.Static.Shared_libs...)
Colin Crosseefe9a32019-01-22 14:41:08 -0800908
Colin Crosse1bb5d02019-09-24 14:55:04 -0700909 deps.ReexportSharedLibHeaders = append(deps.ReexportSharedLibHeaders, library.StaticProperties.Static.Export_shared_lib_headers...)
910 deps.ReexportStaticLibHeaders = append(deps.ReexportStaticLibHeaders, library.StaticProperties.Static.Export_static_lib_headers...)
Colin Crossa48ab5b2017-02-14 15:28:44 -0800911 } else if library.shared() {
Dan Willemsen2e47b342016-11-17 01:02:25 -0800912 if ctx.toolchain().Bionic() && !Bool(library.baseLinker.Properties.Nocrt) {
Dan Albert92fe7402020-07-15 13:33:30 -0700913 deps.CrtBegin = "crtbegin_so"
914 deps.CrtEnd = "crtend_so"
Colin Cross4d9c2d12016-07-29 12:48:20 -0700915 }
Colin Crosse1bb5d02019-09-24 14:55:04 -0700916 deps.WholeStaticLibs = append(deps.WholeStaticLibs, library.SharedProperties.Shared.Whole_static_libs...)
917 deps.StaticLibs = append(deps.StaticLibs, library.SharedProperties.Shared.Static_libs...)
918 deps.SharedLibs = append(deps.SharedLibs, library.SharedProperties.Shared.Shared_libs...)
Colin Crosseefe9a32019-01-22 14:41:08 -0800919
Colin Crosse1bb5d02019-09-24 14:55:04 -0700920 deps.ReexportSharedLibHeaders = append(deps.ReexportSharedLibHeaders, library.SharedProperties.Shared.Export_shared_lib_headers...)
921 deps.ReexportStaticLibHeaders = append(deps.ReexportStaticLibHeaders, library.SharedProperties.Shared.Export_static_lib_headers...)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700922 }
Justin Yun6977e8a2020-10-29 18:24:11 +0900923 if ctx.inVendor() {
Jiyong Park52d25bd2017-10-13 09:17:01 +0900924 deps.WholeStaticLibs = removeListFromList(deps.WholeStaticLibs, library.baseLinker.Properties.Target.Vendor.Exclude_static_libs)
925 deps.SharedLibs = removeListFromList(deps.SharedLibs, library.baseLinker.Properties.Target.Vendor.Exclude_shared_libs)
926 deps.StaticLibs = removeListFromList(deps.StaticLibs, library.baseLinker.Properties.Target.Vendor.Exclude_static_libs)
Victor Chang51271c12019-01-30 16:02:22 +0000927 deps.ReexportSharedLibHeaders = removeListFromList(deps.ReexportSharedLibHeaders, library.baseLinker.Properties.Target.Vendor.Exclude_shared_libs)
928 deps.ReexportStaticLibHeaders = removeListFromList(deps.ReexportStaticLibHeaders, library.baseLinker.Properties.Target.Vendor.Exclude_static_libs)
Jiyong Park52d25bd2017-10-13 09:17:01 +0900929 }
Justin Yun6977e8a2020-10-29 18:24:11 +0900930 if ctx.inProduct() {
931 deps.WholeStaticLibs = removeListFromList(deps.WholeStaticLibs, library.baseLinker.Properties.Target.Product.Exclude_static_libs)
932 deps.SharedLibs = removeListFromList(deps.SharedLibs, library.baseLinker.Properties.Target.Product.Exclude_shared_libs)
933 deps.StaticLibs = removeListFromList(deps.StaticLibs, library.baseLinker.Properties.Target.Product.Exclude_static_libs)
934 deps.ReexportSharedLibHeaders = removeListFromList(deps.ReexportSharedLibHeaders, library.baseLinker.Properties.Target.Product.Exclude_shared_libs)
935 deps.ReexportStaticLibHeaders = removeListFromList(deps.ReexportStaticLibHeaders, library.baseLinker.Properties.Target.Product.Exclude_static_libs)
936 }
Jiyong Parkf9332f12018-02-01 00:54:12 +0900937 if ctx.inRecovery() {
938 deps.WholeStaticLibs = removeListFromList(deps.WholeStaticLibs, library.baseLinker.Properties.Target.Recovery.Exclude_static_libs)
939 deps.SharedLibs = removeListFromList(deps.SharedLibs, library.baseLinker.Properties.Target.Recovery.Exclude_shared_libs)
940 deps.StaticLibs = removeListFromList(deps.StaticLibs, library.baseLinker.Properties.Target.Recovery.Exclude_static_libs)
Victor Chang51271c12019-01-30 16:02:22 +0000941 deps.ReexportSharedLibHeaders = removeListFromList(deps.ReexportSharedLibHeaders, library.baseLinker.Properties.Target.Recovery.Exclude_shared_libs)
942 deps.ReexportStaticLibHeaders = removeListFromList(deps.ReexportStaticLibHeaders, library.baseLinker.Properties.Target.Recovery.Exclude_static_libs)
Jiyong Parkf9332f12018-02-01 00:54:12 +0900943 }
Yifan Hongcf4832c2020-01-21 17:04:13 -0800944 if ctx.inRamdisk() {
945 deps.WholeStaticLibs = removeListFromList(deps.WholeStaticLibs, library.baseLinker.Properties.Target.Ramdisk.Exclude_static_libs)
946 deps.SharedLibs = removeListFromList(deps.SharedLibs, library.baseLinker.Properties.Target.Ramdisk.Exclude_shared_libs)
947 deps.StaticLibs = removeListFromList(deps.StaticLibs, library.baseLinker.Properties.Target.Ramdisk.Exclude_static_libs)
948 deps.ReexportSharedLibHeaders = removeListFromList(deps.ReexportSharedLibHeaders, library.baseLinker.Properties.Target.Ramdisk.Exclude_shared_libs)
949 deps.ReexportStaticLibHeaders = removeListFromList(deps.ReexportStaticLibHeaders, library.baseLinker.Properties.Target.Ramdisk.Exclude_static_libs)
950 }
Yifan Hong6da33c22020-10-27 15:01:21 -0700951 if ctx.inVendorRamdisk() {
952 deps.WholeStaticLibs = removeListFromList(deps.WholeStaticLibs, library.baseLinker.Properties.Target.Vendor_ramdisk.Exclude_static_libs)
953 deps.SharedLibs = removeListFromList(deps.SharedLibs, library.baseLinker.Properties.Target.Vendor_ramdisk.Exclude_shared_libs)
954 deps.StaticLibs = removeListFromList(deps.StaticLibs, library.baseLinker.Properties.Target.Vendor_ramdisk.Exclude_static_libs)
955 deps.ReexportSharedLibHeaders = removeListFromList(deps.ReexportSharedLibHeaders, library.baseLinker.Properties.Target.Vendor_ramdisk.Exclude_shared_libs)
956 deps.ReexportStaticLibHeaders = removeListFromList(deps.ReexportStaticLibHeaders, library.baseLinker.Properties.Target.Vendor_ramdisk.Exclude_static_libs)
957 }
Colin Cross2383f3b2018-02-06 14:40:13 -0800958
Colin Cross4d9c2d12016-07-29 12:48:20 -0700959 return deps
960}
961
Paul Duffin13f02712020-03-06 12:30:43 +0000962func (library *libraryDecorator) linkerSpecifiedDeps(specifiedDeps specifiedDeps) specifiedDeps {
963 specifiedDeps = library.baseLinker.linkerSpecifiedDeps(specifiedDeps)
964 var properties StaticOrSharedProperties
965 if library.static() {
966 properties = library.StaticProperties.Static
967 } else if library.shared() {
968 properties = library.SharedProperties.Shared
969 }
970
971 specifiedDeps.sharedLibs = append(specifiedDeps.sharedLibs, properties.Shared_libs...)
Martin Stjernholm10566a02020-03-24 01:19:52 +0000972
973 // Must distinguish nil and [] in system_shared_libs - ensure that [] in
974 // either input list doesn't come out as nil.
975 if specifiedDeps.systemSharedLibs == nil {
976 specifiedDeps.systemSharedLibs = properties.System_shared_libs
977 } else {
978 specifiedDeps.systemSharedLibs = append(specifiedDeps.systemSharedLibs, properties.System_shared_libs...)
979 }
Paul Duffin13f02712020-03-06 12:30:43 +0000980
981 specifiedDeps.sharedLibs = android.FirstUniqueStrings(specifiedDeps.sharedLibs)
Martin Stjernholm10566a02020-03-24 01:19:52 +0000982 if len(specifiedDeps.systemSharedLibs) > 0 {
983 // Skip this if systemSharedLibs is either nil or [], to ensure they are
984 // retained.
985 specifiedDeps.systemSharedLibs = android.FirstUniqueStrings(specifiedDeps.systemSharedLibs)
986 }
Paul Duffin13f02712020-03-06 12:30:43 +0000987 return specifiedDeps
988}
989
Colin Crossb916a382016-07-29 17:28:03 -0700990func (library *libraryDecorator) linkStatic(ctx ModuleContext,
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700991 flags Flags, deps PathDeps, objs Objects) android.Path {
Colin Cross4d9c2d12016-07-29 12:48:20 -0700992
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700993 library.objects = deps.WholeStaticLibObjs.Copy()
994 library.objects = library.objects.Append(objs)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700995
Inseob Kim0ce291e2019-07-04 14:38:27 +0900996 fileName := ctx.ModuleName() + staticLibraryExtension
Colin Cross86803cf2018-02-15 14:12:26 -0800997 outputFile := android.PathForModuleOut(ctx, fileName)
Dan Willemsen581341d2017-02-09 16:16:31 -0800998 builderFlags := flagsToBuilderFlags(flags)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700999
Dan Willemsen569edc52018-11-19 09:33:29 -08001000 if Bool(library.baseLinker.Properties.Use_version_lib) {
1001 if ctx.Host() {
1002 versionedOutputFile := outputFile
1003 outputFile = android.PathForModuleOut(ctx, "unversioned", fileName)
1004 library.injectVersionSymbol(ctx, outputFile, versionedOutputFile)
1005 } else {
1006 versionedOutputFile := android.PathForModuleOut(ctx, "versioned", fileName)
Jingwen Chen40fd90a2020-06-15 05:24:19 +00001007 library.distFile = versionedOutputFile
Dan Willemsen569edc52018-11-19 09:33:29 -08001008 library.injectVersionSymbol(ctx, outputFile, versionedOutputFile)
1009 }
Colin Cross86803cf2018-02-15 14:12:26 -08001010 }
1011
Chris Parsonsbf4f55f2020-11-23 17:02:44 -05001012 transformObjToStaticLib(ctx, library.objects.objFiles, deps.WholeStaticLibsFromPrebuilts, builderFlags, outputFile, objs.tidyFiles)
Dan Willemsen581341d2017-02-09 16:16:31 -08001013
Chris Parsonsbf4f55f2020-11-23 17:02:44 -05001014 library.coverageOutputFile = transformCoverageFilesToZip(ctx, library.objects, ctx.ModuleName())
Colin Cross4d9c2d12016-07-29 12:48:20 -07001015
Colin Cross4d9c2d12016-07-29 12:48:20 -07001016 ctx.CheckbuildFile(outputFile)
1017
Colin Cross649d8172020-12-10 12:30:21 -08001018 if library.static() {
1019 ctx.SetProvider(StaticLibraryInfoProvider, StaticLibraryInfo{
1020 StaticLibrary: outputFile,
1021 ReuseObjects: library.reuseObjects,
1022 Objects: library.objects,
Colin Cross0de8a1e2020-09-18 14:15:30 -07001023
Colin Cross649d8172020-12-10 12:30:21 -08001024 TransitiveStaticLibrariesForOrdering: android.NewDepSetBuilder(android.TOPOLOGICAL).
1025 Direct(outputFile).
1026 Transitive(deps.TranstiveStaticLibrariesForOrdering).
1027 Build(),
1028 })
1029 }
1030
1031 if library.header() {
1032 ctx.SetProvider(HeaderLibraryInfoProvider, HeaderLibraryInfo{})
1033 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07001034
Colin Cross4d9c2d12016-07-29 12:48:20 -07001035 return outputFile
1036}
1037
Colin Crossb916a382016-07-29 17:28:03 -07001038func (library *libraryDecorator) linkShared(ctx ModuleContext,
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001039 flags Flags, deps PathDeps, objs Objects) android.Path {
Colin Cross4d9c2d12016-07-29 12:48:20 -07001040
1041 var linkerDeps android.Paths
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001042 linkerDeps = append(linkerDeps, flags.LdFlagsDeps...)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001043
Colin Cross2383f3b2018-02-06 14:40:13 -08001044 unexportedSymbols := ctx.ExpandOptionalSource(library.Properties.Unexported_symbols_list, "unexported_symbols_list")
1045 forceNotWeakSymbols := ctx.ExpandOptionalSource(library.Properties.Force_symbols_not_weak_list, "force_symbols_not_weak_list")
1046 forceWeakSymbols := ctx.ExpandOptionalSource(library.Properties.Force_symbols_weak_list, "force_symbols_weak_list")
Colin Cross4d9c2d12016-07-29 12:48:20 -07001047 if !ctx.Darwin() {
Colin Cross4d9c2d12016-07-29 12:48:20 -07001048 if unexportedSymbols.Valid() {
1049 ctx.PropertyErrorf("unexported_symbols_list", "Only supported on Darwin")
1050 }
1051 if forceNotWeakSymbols.Valid() {
1052 ctx.PropertyErrorf("force_symbols_not_weak_list", "Only supported on Darwin")
1053 }
1054 if forceWeakSymbols.Valid() {
1055 ctx.PropertyErrorf("force_symbols_weak_list", "Only supported on Darwin")
1056 }
1057 } else {
Colin Cross4d9c2d12016-07-29 12:48:20 -07001058 if unexportedSymbols.Valid() {
Colin Cross4af21ed2019-11-04 09:37:55 -08001059 flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,-unexported_symbols_list,"+unexportedSymbols.String())
Colin Cross4d9c2d12016-07-29 12:48:20 -07001060 linkerDeps = append(linkerDeps, unexportedSymbols.Path())
1061 }
1062 if forceNotWeakSymbols.Valid() {
Colin Cross4af21ed2019-11-04 09:37:55 -08001063 flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,-force_symbols_not_weak_list,"+forceNotWeakSymbols.String())
Colin Cross4d9c2d12016-07-29 12:48:20 -07001064 linkerDeps = append(linkerDeps, forceNotWeakSymbols.Path())
1065 }
1066 if forceWeakSymbols.Valid() {
Colin Cross4af21ed2019-11-04 09:37:55 -08001067 flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,-force_symbols_weak_list,"+forceWeakSymbols.String())
Colin Cross4d9c2d12016-07-29 12:48:20 -07001068 linkerDeps = append(linkerDeps, forceWeakSymbols.Path())
1069 }
1070 }
Colin Cross8e21aa52020-09-28 18:28:02 -07001071 if library.versionScriptPath.Valid() {
Jiyong Parkc1e7f482019-01-12 13:39:10 +09001072 linkerScriptFlags := "-Wl,--version-script," + library.versionScriptPath.String()
Colin Cross4af21ed2019-11-04 09:37:55 -08001073 flags.Local.LdFlags = append(flags.Local.LdFlags, linkerScriptFlags)
Colin Cross8e21aa52020-09-28 18:28:02 -07001074 linkerDeps = append(linkerDeps, library.versionScriptPath.Path())
Jiyong Parkc1e7f482019-01-12 13:39:10 +09001075 }
Colin Cross4d9c2d12016-07-29 12:48:20 -07001076
1077 fileName := library.getLibName(ctx) + flags.Toolchain.ShlibSuffix()
1078 outputFile := android.PathForModuleOut(ctx, fileName)
Colin Cross0de8a1e2020-09-18 14:15:30 -07001079 unstrippedOutputFile := outputFile
Colin Cross4d9c2d12016-07-29 12:48:20 -07001080
Josh Gao75a50a22019-06-07 17:58:59 -07001081 var implicitOutputs android.WritablePaths
1082 if ctx.Windows() {
1083 importLibraryPath := android.PathForModuleOut(ctx, pathtools.ReplaceExtension(fileName, "lib"))
1084
Colin Cross4af21ed2019-11-04 09:37:55 -08001085 flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,--out-implib="+importLibraryPath.String())
Josh Gao75a50a22019-06-07 17:58:59 -07001086 implicitOutputs = append(implicitOutputs, importLibraryPath)
1087 }
1088
Colin Cross4d9c2d12016-07-29 12:48:20 -07001089 builderFlags := flagsToBuilderFlags(flags)
1090
Colin Crossb496cfd2018-09-10 16:50:05 -07001091 // Optimize out relinking against shared libraries whose interface hasn't changed by
1092 // depending on a table of contents file instead of the library itself.
Colin Cross70dda7e2019-10-01 22:05:35 -07001093 tocFile := outputFile.ReplaceExtension(ctx, flags.Toolchain.ShlibSuffix()[1:]+".toc")
Colin Crossb496cfd2018-09-10 16:50:05 -07001094 library.tocFile = android.OptionalPathForPath(tocFile)
Chris Parsonsbf4f55f2020-11-23 17:02:44 -05001095 transformSharedObjectToToc(ctx, outputFile, tocFile, builderFlags)
Colin Cross89562dc2016-10-03 17:47:19 -07001096
Thiébaud Weksteend4587452020-08-19 14:53:01 +02001097 stripFlags := flagsToStripFlags(flags)
Colin Crossadc81a02020-12-14 17:01:55 -08001098 needsStrip := library.stripper.NeedsStrip(ctx)
1099 if library.buildStubs() {
1100 // No need to strip stubs libraries
1101 needsStrip = false
1102 }
1103 if needsStrip {
Yi Kongb5c34d72018-11-07 16:28:49 -08001104 if ctx.Darwin() {
Thiébaud Weksteend4587452020-08-19 14:53:01 +02001105 stripFlags.StripUseGnuStrip = true
Yi Kongb5c34d72018-11-07 16:28:49 -08001106 }
Colin Cross4d9c2d12016-07-29 12:48:20 -07001107 strippedOutputFile := outputFile
1108 outputFile = android.PathForModuleOut(ctx, "unstripped", fileName)
Thiébaud Weksteend4587452020-08-19 14:53:01 +02001109 library.stripper.StripExecutableOrSharedLib(ctx, outputFile, strippedOutputFile, stripFlags)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001110 }
Colin Crossb60190a2018-09-04 16:28:17 -07001111 library.unstrippedOutputFile = outputFile
1112
Colin Crossd7227f92019-09-05 14:26:33 -07001113 outputFile = maybeInjectBoringSSLHash(ctx, outputFile, library.Properties.Inject_bssl_hash, fileName)
Pete Bentley803e1612019-08-06 22:19:59 +01001114
Dan Willemsen569edc52018-11-19 09:33:29 -08001115 if Bool(library.baseLinker.Properties.Use_version_lib) {
1116 if ctx.Host() {
1117 versionedOutputFile := outputFile
1118 outputFile = android.PathForModuleOut(ctx, "unversioned", fileName)
1119 library.injectVersionSymbol(ctx, outputFile, versionedOutputFile)
1120 } else {
1121 versionedOutputFile := android.PathForModuleOut(ctx, "versioned", fileName)
Jingwen Chen40fd90a2020-06-15 05:24:19 +00001122 library.distFile = versionedOutputFile
Dan Willemsen569edc52018-11-19 09:33:29 -08001123
Thiébaud Weksteend4587452020-08-19 14:53:01 +02001124 if library.stripper.NeedsStrip(ctx) {
Dan Willemsen569edc52018-11-19 09:33:29 -08001125 out := android.PathForModuleOut(ctx, "versioned-stripped", fileName)
Jingwen Chen40fd90a2020-06-15 05:24:19 +00001126 library.distFile = out
Thiébaud Weksteend4587452020-08-19 14:53:01 +02001127 library.stripper.StripExecutableOrSharedLib(ctx, versionedOutputFile, out, stripFlags)
Dan Willemsen569edc52018-11-19 09:33:29 -08001128 }
1129
1130 library.injectVersionSymbol(ctx, outputFile, versionedOutputFile)
1131 }
Colin Cross86803cf2018-02-15 14:12:26 -08001132 }
1133
Jiyong Park64a44f22019-01-18 14:37:08 +09001134 sharedLibs := deps.EarlySharedLibs
1135 sharedLibs = append(sharedLibs, deps.SharedLibs...)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001136 sharedLibs = append(sharedLibs, deps.LateSharedLibs...)
1137
Jiyong Park64a44f22019-01-18 14:37:08 +09001138 linkerDeps = append(linkerDeps, deps.EarlySharedLibsDeps...)
Colin Cross26c34ed2016-09-30 17:10:16 -07001139 linkerDeps = append(linkerDeps, deps.SharedLibsDeps...)
1140 linkerDeps = append(linkerDeps, deps.LateSharedLibsDeps...)
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001141 linkerDeps = append(linkerDeps, objs.tidyFiles...)
Colin Cross26c34ed2016-09-30 17:10:16 -07001142
Colin Cross127bb8b2020-12-16 16:46:01 -08001143 if Bool(library.Properties.Sort_bss_symbols_by_size) && !library.buildStubs() {
Vic Yang6cd1be82019-06-24 16:08:48 -07001144 unsortedOutputFile := android.PathForModuleOut(ctx, "unsorted", fileName)
Chris Parsonsbf4f55f2020-11-23 17:02:44 -05001145 transformObjToDynamicBinary(ctx, objs.objFiles, sharedLibs,
Vic Yang6cd1be82019-06-24 16:08:48 -07001146 deps.StaticLibs, deps.LateStaticLibs, deps.WholeStaticLibs,
1147 linkerDeps, deps.CrtBegin, deps.CrtEnd, false, builderFlags, unsortedOutputFile, implicitOutputs)
1148
1149 symbolOrderingFile := android.PathForModuleOut(ctx, "unsorted", fileName+".symbol_order")
1150 symbolOrderingFlag := library.baseLinker.sortBssSymbolsBySize(ctx, unsortedOutputFile, symbolOrderingFile, builderFlags)
Colin Cross6d88dba2019-11-06 07:06:58 -08001151 builderFlags.localLdFlags += " " + symbolOrderingFlag
Vic Yang6cd1be82019-06-24 16:08:48 -07001152 linkerDeps = append(linkerDeps, symbolOrderingFile)
1153 }
1154
Chris Parsonsbf4f55f2020-11-23 17:02:44 -05001155 transformObjToDynamicBinary(ctx, objs.objFiles, sharedLibs,
Colin Cross4d9c2d12016-07-29 12:48:20 -07001156 deps.StaticLibs, deps.LateStaticLibs, deps.WholeStaticLibs,
Josh Gao75a50a22019-06-07 17:58:59 -07001157 linkerDeps, deps.CrtBegin, deps.CrtEnd, false, builderFlags, outputFile, implicitOutputs)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001158
Dan Willemsen581341d2017-02-09 16:16:31 -08001159 objs.coverageFiles = append(objs.coverageFiles, deps.StaticLibObjs.coverageFiles...)
1160 objs.coverageFiles = append(objs.coverageFiles, deps.WholeStaticLibObjs.coverageFiles...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001161
1162 objs.sAbiDumpFiles = append(objs.sAbiDumpFiles, deps.StaticLibObjs.sAbiDumpFiles...)
1163 objs.sAbiDumpFiles = append(objs.sAbiDumpFiles, deps.WholeStaticLibObjs.sAbiDumpFiles...)
1164
Chris Parsonsbf4f55f2020-11-23 17:02:44 -05001165 library.coverageOutputFile = transformCoverageFilesToZip(ctx, objs, library.getLibName(ctx))
Colin Cross0de8a1e2020-09-18 14:15:30 -07001166 library.linkSAbiDumpFiles(ctx, objs, fileName, unstrippedOutputFile)
Dan Willemsen581341d2017-02-09 16:16:31 -08001167
Colin Cross0de8a1e2020-09-18 14:15:30 -07001168 var staticAnalogue *StaticLibraryInfo
1169 if static := ctx.GetDirectDepsWithTag(staticVariantTag); len(static) > 0 {
1170 s := ctx.OtherModuleProvider(static[0], StaticLibraryInfoProvider).(StaticLibraryInfo)
1171 staticAnalogue = &s
1172 }
1173
1174 ctx.SetProvider(SharedLibraryInfoProvider, SharedLibraryInfo{
1175 TableOfContents: android.OptionalPathForPath(tocFile),
1176 SharedLibrary: unstrippedOutputFile,
1177 UnstrippedSharedLibrary: library.unstrippedOutputFile,
1178 CoverageSharedLibrary: library.coverageOutputFile,
1179 StaticAnalogue: staticAnalogue,
1180 })
1181
1182 stubs := ctx.GetDirectDepsWithTag(stubImplDepTag)
1183 if len(stubs) > 0 {
Chris Parsons3c27ca32020-11-20 12:42:07 -05001184 var stubsInfo []SharedStubLibrary
Colin Cross0de8a1e2020-09-18 14:15:30 -07001185 for _, stub := range stubs {
1186 stubInfo := ctx.OtherModuleProvider(stub, SharedLibraryInfoProvider).(SharedLibraryInfo)
1187 flagInfo := ctx.OtherModuleProvider(stub, FlagExporterInfoProvider).(FlagExporterInfo)
Chris Parsons3c27ca32020-11-20 12:42:07 -05001188 stubsInfo = append(stubsInfo, SharedStubLibrary{
Colin Cross31076b32020-10-23 17:22:06 -07001189 Version: moduleLibraryInterface(stub).stubsVersion(),
Colin Cross0de8a1e2020-09-18 14:15:30 -07001190 SharedLibraryInfo: stubInfo,
1191 FlagExporterInfo: flagInfo,
1192 })
1193 }
Chris Parsons3c27ca32020-11-20 12:42:07 -05001194 ctx.SetProvider(SharedLibraryStubsProvider, SharedLibraryStubsInfo{
1195 SharedStubLibraries: stubsInfo,
Colin Cross0de8a1e2020-09-18 14:15:30 -07001196
Colin Cross127bb8b2020-12-16 16:46:01 -08001197 IsLLNDK: ctx.IsLlndk(),
Colin Cross0de8a1e2020-09-18 14:15:30 -07001198 })
1199 }
1200
1201 return unstrippedOutputFile
Colin Cross4d9c2d12016-07-29 12:48:20 -07001202}
1203
Jiyong Parkaf6d8952019-01-31 12:21:23 +09001204func (library *libraryDecorator) unstrippedOutputFilePath() android.Path {
1205 return library.unstrippedOutputFile
1206}
1207
Thiébaud Weksteend4587452020-08-19 14:53:01 +02001208func (library *libraryDecorator) disableStripping() {
1209 library.stripper.StripProperties.Strip.None = BoolPtr(true)
1210}
1211
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001212func (library *libraryDecorator) nativeCoverage() bool {
1213 if library.header() || library.buildStubs() {
1214 return false
1215 }
1216 return true
1217}
1218
Jiyong Parkee9a98d2019-08-09 14:44:36 +09001219func (library *libraryDecorator) coverageOutputFilePath() android.OptionalPath {
1220 return library.coverageOutputFile
1221}
1222
Logan Chien7eefdc42018-07-11 18:10:41 +08001223func getRefAbiDumpFile(ctx ModuleContext, vndkVersion, fileName string) android.Path {
Hsin-Yi Chen27d235f2020-03-26 17:50:29 +08001224 // The logic must be consistent with classifySourceAbiDump.
Colin Cross95f1ca02020-10-29 20:47:22 -07001225 isNdk := ctx.isNdk(ctx.Config())
Colin Cross127bb8b2020-12-16 16:46:01 -08001226 isLlndkOrVndk := ctx.IsLlndkPublic() || (ctx.useVndk() && ctx.isVndk())
Logan Chien7eefdc42018-07-11 18:10:41 +08001227
Hsin-Yi Chen53489642019-07-31 17:10:45 +08001228 refAbiDumpTextFile := android.PathForVndkRefAbiDump(ctx, vndkVersion, fileName, isNdk, isLlndkOrVndk, false)
1229 refAbiDumpGzipFile := android.PathForVndkRefAbiDump(ctx, vndkVersion, fileName, isNdk, isLlndkOrVndk, true)
Logan Chien7eefdc42018-07-11 18:10:41 +08001230
1231 if refAbiDumpTextFile.Valid() {
1232 if refAbiDumpGzipFile.Valid() {
1233 ctx.ModuleErrorf(
1234 "Two reference ABI dump files are found: %q and %q. Please delete the stale one.",
1235 refAbiDumpTextFile, refAbiDumpGzipFile)
1236 return nil
1237 }
1238 return refAbiDumpTextFile.Path()
1239 }
1240 if refAbiDumpGzipFile.Valid() {
Chris Parsonsbf4f55f2020-11-23 17:02:44 -05001241 return unzipRefDump(ctx, refAbiDumpGzipFile.Path(), fileName)
Logan Chien7eefdc42018-07-11 18:10:41 +08001242 }
1243 return nil
1244}
1245
Jayant Chowdhary6ab3d842017-06-26 12:52:58 -07001246func (library *libraryDecorator) linkSAbiDumpFiles(ctx ModuleContext, objs Objects, fileName string, soFile android.Path) {
Yo Chiang2bbadfa2020-12-14 11:42:16 +08001247 if library.sabi.shouldCreateSourceAbiDump() {
Inseob Kim96f17f02020-06-09 22:05:09 +09001248 var vndkVersion string
1249
1250 if ctx.useVndk() {
1251 // For modules linking against vndk, follow its vndk version
1252 vndkVersion = ctx.Module().(*Module).VndkVersion()
1253 } else {
1254 // Regard the other modules as PLATFORM_VNDK_VERSION
1255 vndkVersion = ctx.DeviceConfig().PlatformVndkVersion()
Logan Chienf3511742017-10-31 18:04:35 +08001256 }
1257
Jayant Chowdharya4fce192017-09-06 13:10:03 -07001258 exportIncludeDirs := library.flagExporter.exportedIncludes(ctx)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001259 var SourceAbiFlags []string
1260 for _, dir := range exportIncludeDirs.Strings() {
Jayant Chowdhary715cac32017-04-20 06:53:59 -07001261 SourceAbiFlags = append(SourceAbiFlags, "-I"+dir)
1262 }
Inseob Kim69378442019-06-03 19:10:47 +09001263 for _, reexportedInclude := range library.sabi.Properties.ReexportedIncludes {
1264 SourceAbiFlags = append(SourceAbiFlags, "-I"+reexportedInclude)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001265 }
1266 exportedHeaderFlags := strings.Join(SourceAbiFlags, " ")
Chris Parsonsbf4f55f2020-11-23 17:02:44 -05001267 library.sAbiOutputFile = transformDumpToLinkedDump(ctx, objs.sAbiDumpFiles, soFile, fileName, exportedHeaderFlags,
Jiyong Parka034b832019-08-27 14:02:19 +09001268 android.OptionalPathForModuleSrc(ctx, library.symbolFileForAbiCheck(ctx)),
Logan Chiene3d7a0d2019-01-17 00:18:02 +08001269 library.Properties.Header_abi_checker.Exclude_symbol_versions,
1270 library.Properties.Header_abi_checker.Exclude_symbol_tags)
Logan Chien2f2b8902018-07-10 15:01:19 +08001271
Yo Chiang2bbadfa2020-12-14 11:42:16 +08001272 addLsdumpPath(classifySourceAbiDump(ctx) + ":" + library.sAbiOutputFile.String())
Hsin-Yi Chen53489642019-07-31 17:10:45 +08001273
Logan Chien7eefdc42018-07-11 18:10:41 +08001274 refAbiDumpFile := getRefAbiDumpFile(ctx, vndkVersion, fileName)
1275 if refAbiDumpFile != nil {
Chris Parsonsbf4f55f2020-11-23 17:02:44 -05001276 library.sAbiDiff = sourceAbiDiff(ctx, library.sAbiOutputFile.Path(),
Logan Chien2a65dda2019-10-01 15:58:07 -07001277 refAbiDumpFile, fileName, exportedHeaderFlags,
1278 Bool(library.Properties.Header_abi_checker.Check_all_apis),
Colin Cross127bb8b2020-12-16 16:46:01 -08001279 ctx.IsLlndk(), ctx.isNdk(ctx.Config()), ctx.IsVndkExt())
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001280 }
1281 }
1282}
1283
Colin Cross127bb8b2020-12-16 16:46:01 -08001284func processLLNDKHeaders(ctx ModuleContext, srcHeaderDir string, outDir android.ModuleGenPath) android.Path {
1285 srcDir := android.PathForModuleSrc(ctx, srcHeaderDir)
1286 srcFiles := ctx.GlobFiles(filepath.Join(srcDir.String(), "**/*.h"), nil)
1287
1288 var installPaths []android.WritablePath
1289 for _, header := range srcFiles {
1290 headerDir := filepath.Dir(header.String())
1291 relHeaderDir, err := filepath.Rel(srcDir.String(), headerDir)
1292 if err != nil {
1293 ctx.ModuleErrorf("filepath.Rel(%q, %q) failed: %s",
1294 srcDir.String(), headerDir, err)
1295 continue
1296 }
1297
1298 installPaths = append(installPaths, outDir.Join(ctx, relHeaderDir, header.Base()))
1299 }
1300
1301 return processHeadersWithVersioner(ctx, srcDir, outDir, srcFiles, installPaths)
1302}
1303
Chris Parsons3c27ca32020-11-20 12:42:07 -05001304// link registers actions to link this library, and sets various fields
1305// on this library to reflect information that should be exported up the build
1306// tree (for example, exported flags and include paths).
Colin Crossb916a382016-07-29 17:28:03 -07001307func (library *libraryDecorator) link(ctx ModuleContext,
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001308 flags Flags, deps PathDeps, objs Objects) android.Path {
Colin Cross4d9c2d12016-07-29 12:48:20 -07001309
Colin Cross127bb8b2020-12-16 16:46:01 -08001310 if ctx.IsLlndk() {
1311 if len(library.Properties.Llndk.Export_preprocessed_headers) > 0 {
1312 // This is the vendor variant of an LLNDK library with preprocessed headers.
1313 genHeaderOutDir := android.PathForModuleGen(ctx, "include")
1314
1315 var timestampFiles android.Paths
1316 for _, dir := range library.Properties.Llndk.Export_preprocessed_headers {
1317 timestampFiles = append(timestampFiles, processLLNDKHeaders(ctx, dir, genHeaderOutDir))
1318 }
1319
1320 if Bool(library.Properties.Llndk.Export_headers_as_system) {
1321 library.reexportSystemDirs(genHeaderOutDir)
1322 } else {
1323 library.reexportDirs(genHeaderOutDir)
1324 }
1325
1326 library.reexportDeps(timestampFiles...)
1327 }
1328
1329 if Bool(library.Properties.Llndk.Export_headers_as_system) {
1330 library.flagExporter.Properties.Export_system_include_dirs = append(
1331 library.flagExporter.Properties.Export_system_include_dirs,
1332 library.flagExporter.Properties.Export_include_dirs...)
1333 library.flagExporter.Properties.Export_include_dirs = nil
1334 }
1335 }
1336
Chris Parsons3c27ca32020-11-20 12:42:07 -05001337 // Linking this library consists of linking `deps.Objs` (.o files in dependencies
1338 // of this library), together with `objs` (.o files created by compiling this
1339 // library).
Colin Crossad59e752017-11-16 14:29:11 -08001340 objs = deps.Objs.Copy().Append(objs)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001341 var out android.Path
Colin Crossa48ab5b2017-02-14 15:28:44 -08001342 if library.static() || library.header() {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001343 out = library.linkStatic(ctx, flags, deps, objs)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001344 } else {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001345 out = library.linkShared(ctx, flags, deps, objs)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001346 }
1347
Chris Parsons3c27ca32020-11-20 12:42:07 -05001348 // Export include paths and flags to be propagated up the tree.
Inseob Kim69378442019-06-03 19:10:47 +09001349 library.exportIncludes(ctx)
1350 library.reexportDirs(deps.ReexportedDirs...)
1351 library.reexportSystemDirs(deps.ReexportedSystemDirs...)
1352 library.reexportFlags(deps.ReexportedFlags...)
1353 library.reexportDeps(deps.ReexportedDeps...)
Inseob Kimd110f872019-12-06 13:15:38 +09001354 library.addExportedGeneratedHeaders(deps.ReexportedGeneratedHeaders...)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001355
Chris Parsons3c27ca32020-11-20 12:42:07 -05001356 // Optionally export aidl headers.
Nan Zhang0007d812017-11-07 10:57:05 -08001357 if Bool(library.Properties.Aidl.Export_aidl_headers) {
Dan Willemsene1240db2016-11-03 14:28:51 -07001358 if library.baseCompiler.hasSrcExt(".aidl") {
Jiyong Park74955042019-10-22 20:19:51 +09001359 dir := android.PathForModuleGen(ctx, "aidl")
Inseob Kim69378442019-06-03 19:10:47 +09001360 library.reexportDirs(dir)
Inseob Kimd110f872019-12-06 13:15:38 +09001361
Paul Duffin33056e82021-02-19 13:49:08 +00001362 library.reexportDeps(library.baseCompiler.aidlOrderOnlyDeps...)
1363 library.addExportedGeneratedHeaders(library.baseCompiler.aidlHeaders...)
Dan Willemsene1240db2016-11-03 14:28:51 -07001364 }
1365 }
1366
Chris Parsons3c27ca32020-11-20 12:42:07 -05001367 // Optionally export proto headers.
Nan Zhang0007d812017-11-07 10:57:05 -08001368 if Bool(library.Properties.Proto.Export_proto_headers) {
Dan Willemsene1240db2016-11-03 14:28:51 -07001369 if library.baseCompiler.hasSrcExt(".proto") {
Jiyong Park74955042019-10-22 20:19:51 +09001370 var includes android.Paths
Colin Cross19878da2019-03-28 14:45:07 -07001371 if flags.proto.CanonicalPathFromRoot {
Jiyong Park74955042019-10-22 20:19:51 +09001372 includes = append(includes, flags.proto.SubDir)
Colin Cross10d22312017-05-03 11:01:58 -07001373 }
Jiyong Park74955042019-10-22 20:19:51 +09001374 includes = append(includes, flags.proto.Dir)
Inseob Kim69378442019-06-03 19:10:47 +09001375 library.reexportDirs(includes...)
Inseob Kimd110f872019-12-06 13:15:38 +09001376
Paul Duffin33056e82021-02-19 13:49:08 +00001377 library.reexportDeps(library.baseCompiler.protoOrderOnlyDeps...)
1378 library.addExportedGeneratedHeaders(library.baseCompiler.protoHeaders...)
Colin Cross0c461f12016-10-20 16:11:43 -07001379 }
1380 }
1381
Inseob Kim07def122020-11-23 14:43:02 +09001382 // If the library is sysprop_library, expose either public or internal header selectively.
Inseob Kim21f26902018-09-06 00:55:20 +09001383 if library.baseCompiler.hasSrcExt(".sysprop") {
Jiyong Park74955042019-10-22 20:19:51 +09001384 dir := android.PathForModuleGen(ctx, "sysprop", "include")
Inseob Kimc0907f12019-02-08 21:00:45 +09001385 if library.Properties.Sysprop.Platform != nil {
Inseob Kimc0907f12019-02-08 21:00:45 +09001386 isOwnerPlatform := Bool(library.Properties.Sysprop.Platform)
1387
Inseob Kim07def122020-11-23 14:43:02 +09001388 // If the owner is different from the user, expose public header. That is,
1389 // 1) if the user is product (as owner can only be platform / vendor)
Inseob Kim06410042021-01-18 15:23:28 +09001390 // 2) if the owner is platform and the client is vendor
1391 // We don't care Platform -> Vendor dependency as it's already forbidden.
1392 if ctx.Device() && (ctx.ProductSpecific() || (isOwnerPlatform && ctx.inVendor())) {
Jiyong Park74955042019-10-22 20:19:51 +09001393 dir = android.PathForModuleGen(ctx, "sysprop/public", "include")
Inseob Kimc0907f12019-02-08 21:00:45 +09001394 }
1395 }
1396
Paul Duffin37e0de52021-02-19 17:05:39 +00001397 // Make sure to only export headers which are within the include directory.
1398 _, headers := android.FilterPathListPredicate(library.baseCompiler.syspropHeaders, func(path android.Path) bool {
1399 _, isRel := android.MaybeRel(ctx, dir.String(), path.String())
1400 return isRel
1401 })
1402
Chris Parsons3c27ca32020-11-20 12:42:07 -05001403 // Add sysprop-related directories to the exported directories of this library.
Inseob Kim69378442019-06-03 19:10:47 +09001404 library.reexportDirs(dir)
Paul Duffin33056e82021-02-19 13:49:08 +00001405 library.reexportDeps(library.baseCompiler.syspropOrderOnlyDeps...)
Paul Duffin37e0de52021-02-19 17:05:39 +00001406 library.addExportedGeneratedHeaders(headers...)
Inseob Kim21f26902018-09-06 00:55:20 +09001407 }
1408
Chris Parsons3c27ca32020-11-20 12:42:07 -05001409 // Add stub-related flags if this library is a stub library.
Jiyong Park892a98f2020-12-14 09:20:00 +09001410 library.exportVersioningMacroIfNeeded(ctx)
Jiyong Parkda732bd2018-11-02 18:23:15 +09001411
Chris Parsons3c27ca32020-11-20 12:42:07 -05001412 // Propagate a Provider containing information about exported flags, deps, and include paths.
Colin Cross0de8a1e2020-09-18 14:15:30 -07001413 library.flagExporter.setProvider(ctx)
1414
Colin Cross4d9c2d12016-07-29 12:48:20 -07001415 return out
1416}
1417
Jiyong Park892a98f2020-12-14 09:20:00 +09001418func (library *libraryDecorator) exportVersioningMacroIfNeeded(ctx android.BaseModuleContext) {
Colin Cross127bb8b2020-12-16 16:46:01 -08001419 if library.buildStubs() && library.stubsVersion() != "" && !library.skipAPIDefine {
Jiyong Park892a98f2020-12-14 09:20:00 +09001420 name := versioningMacroName(ctx.Module().(*Module).ImplementationModuleName(ctx))
Jooyung Han11b0fbd2021-02-05 02:28:22 +09001421 apiLevel, err := android.ApiLevelFromUser(ctx, library.stubsVersion())
1422 if err != nil {
1423 ctx.ModuleErrorf("Can't export version macro: %s", err.Error())
1424 }
1425 library.reexportFlags("-D" + name + "=" + strconv.Itoa(apiLevel.FinalOrPreviewInt()))
Jiyong Park892a98f2020-12-14 09:20:00 +09001426 }
1427}
1428
Chris Parsons3c27ca32020-11-20 12:42:07 -05001429// buildStatic returns true if this library should be built as a static library.
Colin Crossb916a382016-07-29 17:28:03 -07001430func (library *libraryDecorator) buildStatic() bool {
Colin Crosse1bb5d02019-09-24 14:55:04 -07001431 return library.MutatedProperties.BuildStatic &&
1432 BoolDefault(library.StaticProperties.Static.Enabled, true)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001433}
1434
Chris Parsons3c27ca32020-11-20 12:42:07 -05001435// buildShared returns true if this library should be built as a shared library.
Colin Crossb916a382016-07-29 17:28:03 -07001436func (library *libraryDecorator) buildShared() bool {
Colin Crosse1bb5d02019-09-24 14:55:04 -07001437 return library.MutatedProperties.BuildShared &&
1438 BoolDefault(library.SharedProperties.Shared.Enabled, true)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001439}
1440
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001441func (library *libraryDecorator) objs() Objects {
1442 return library.objects
Colin Cross4d9c2d12016-07-29 12:48:20 -07001443}
1444
Colin Cross0de8a1e2020-09-18 14:15:30 -07001445func (library *libraryDecorator) reuseObjs() Objects {
1446 return library.reuseObjects
Colin Cross4d9c2d12016-07-29 12:48:20 -07001447}
1448
Colin Cross26c34ed2016-09-30 17:10:16 -07001449func (library *libraryDecorator) toc() android.OptionalPath {
1450 return library.tocFile
1451}
1452
Jiyong Parkf1194352019-02-25 11:05:47 +09001453func (library *libraryDecorator) installSymlinkToRuntimeApex(ctx ModuleContext, file android.Path) {
1454 dir := library.baseInstaller.installDir(ctx)
1455 dirOnDevice := android.InstallPathToOnDevicePath(ctx, dir)
1456 target := "/" + filepath.Join("apex", "com.android.runtime", dir.Base(), "bionic", file.Base())
1457 ctx.InstallAbsoluteSymlink(dir, file.Base(), target)
Jaewoong Jung18aefc12020-12-21 09:11:10 -08001458 library.postInstallCmds = append(library.postInstallCmds, makeSymlinkCmd(dirOnDevice, file.Base(), target))
Jiyong Parkf1194352019-02-25 11:05:47 +09001459}
1460
Colin Crossb916a382016-07-29 17:28:03 -07001461func (library *libraryDecorator) install(ctx ModuleContext, file android.Path) {
Colin Crossc43ae772017-04-14 15:42:53 -07001462 if library.shared() {
Justin Yun8fe12122017-12-07 17:18:15 +09001463 if ctx.Device() && ctx.useVndk() {
Jooyung Han261e1582020-10-20 18:54:21 +09001464 // set subDir for VNDK extensions
Ivan Lozanof9e21722020-12-02 09:00:51 -05001465 if ctx.IsVndkExt() {
Jooyung Han261e1582020-10-20 18:54:21 +09001466 if ctx.isVndkSp() {
1467 library.baseInstaller.subDir = "vndk-sp"
1468 } else {
1469 library.baseInstaller.subDir = "vndk"
1470 }
1471 }
1472
Justin Yun31094b12020-12-24 16:11:23 +09001473 // In some cases we want to use core variant for VNDK-Core libs.
1474 // Skip product variant since VNDKs use only the vendor variant.
1475 if ctx.isVndk() && !ctx.isVndkSp() && !ctx.IsVndkExt() && !ctx.inProduct() {
Vic Yang1a5812a2020-01-31 10:38:40 -08001476 mayUseCoreVariant := true
1477
1478 if ctx.mustUseVendorVariant() {
1479 mayUseCoreVariant = false
1480 }
1481
Vic Yang1a5812a2020-01-31 10:38:40 -08001482 if ctx.Config().CFIEnabledForPath(ctx.ModuleDir()) && ctx.Arch().ArchType == android.Arm64 {
1483 mayUseCoreVariant = false
1484 }
1485
1486 if mayUseCoreVariant {
Vic Yangd92090f2020-01-08 14:32:28 -08001487 library.checkSameCoreVariant = true
1488 if ctx.DeviceConfig().VndkUseCoreVariant() {
1489 library.useCoreVariant = true
1490 }
Vic Yangefd249e2018-11-12 20:19:56 -08001491 }
Justin Yun8fe12122017-12-07 17:18:15 +09001492 }
Logan Chienf3511742017-10-31 18:04:35 +08001493
Jooyung Han261e1582020-10-20 18:54:21 +09001494 // do not install vndk libs
1495 // vndk libs are packaged into VNDK APEX
Ivan Lozanof9e21722020-12-02 09:00:51 -05001496 if ctx.isVndk() && !ctx.IsVndkExt() {
Jooyung Han261e1582020-10-20 18:54:21 +09001497 return
Justin Yun8effde42017-06-23 19:24:43 +09001498 }
Jiyong Parkd4a3a132021-03-17 20:21:35 +09001499 } else if library.hasStubsVariants() && !ctx.Host() && ctx.directlyInAnyApex() {
Jiyong Parkf1194352019-02-25 11:05:47 +09001500 // Bionic libraries (e.g. libc.so) is installed to the bootstrap subdirectory.
1501 // The original path becomes a symlink to the corresponding file in the
1502 // runtime APEX.
Colin Cross3b19f5d2019-09-17 14:45:31 -07001503 translatedArch := ctx.Target().NativeBridge == android.NativeBridgeEnabled
Colin Cross56a83212020-09-15 18:30:11 -07001504 if InstallToBootstrap(ctx.baseModuleName(), ctx.Config()) && !library.buildStubs() &&
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001505 !translatedArch && !ctx.inRamdisk() && !ctx.inVendorRamdisk() && !ctx.inRecovery() {
Martin Stjernholm279de572019-09-10 23:18:20 +01001506 if ctx.Device() {
Jiyong Parkc3e2c862019-03-16 01:10:08 +09001507 library.installSymlinkToRuntimeApex(ctx, file)
1508 }
Jiyong Park429660f2019-01-16 22:31:11 +09001509 library.baseInstaller.subDir = "bootstrap"
1510 }
Colin Cross127bb8b2020-12-16 16:46:01 -08001511 } else if ctx.directlyInAnyApex() && ctx.IsLlndk() && !isBionic(ctx.baseModuleName()) {
Przemyslaw Szczepaniake6fc5072019-07-12 14:06:23 +01001512 // Skip installing LLNDK (non-bionic) libraries moved to APEX.
Colin Crossa9c8c9f2020-12-16 10:20:23 -08001513 ctx.Module().HideFromMake()
Justin Yun8effde42017-06-23 19:24:43 +09001514 }
Przemyslaw Szczepaniake6fc5072019-07-12 14:06:23 +01001515
Colin Cross4d9c2d12016-07-29 12:48:20 -07001516 library.baseInstaller.install(ctx, file)
1517 }
Dan Albertf563d252017-10-13 00:29:00 -07001518
Dan Albert281f22b2017-12-13 15:03:47 -08001519 if Bool(library.Properties.Static_ndk_lib) && library.static() &&
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001520 !ctx.useVndk() && !ctx.inRamdisk() && !ctx.inVendorRamdisk() && !ctx.inRecovery() && ctx.Device() &&
Jiyong Park7ed9de32018-10-15 22:25:07 +09001521 library.baseLinker.sanitize.isUnsanitizedVariant() &&
Colin Cross95b07f22020-12-16 11:06:50 -08001522 ctx.isForPlatform() && !ctx.isPreventInstall() {
Dan Albertf563d252017-10-13 00:29:00 -07001523 installPath := getNdkSysrootBase(ctx).Join(
Dan Albertea4b7b92018-04-25 16:05:30 -07001524 ctx, "usr/lib", config.NDKTriple(ctx.toolchain()), file.Base())
Dan Albertf563d252017-10-13 00:29:00 -07001525
1526 ctx.ModuleBuild(pctx, android.ModuleBuildParams{
1527 Rule: android.Cp,
1528 Description: "install " + installPath.Base(),
1529 Output: installPath,
1530 Input: file,
1531 })
1532
Colin Cross0875c522017-11-28 17:34:01 -08001533 library.ndkSysrootPath = installPath
Dan Albertf563d252017-10-13 00:29:00 -07001534 }
Colin Cross4d9c2d12016-07-29 12:48:20 -07001535}
1536
Paul Duffin0cb37b92020-03-04 14:52:46 +00001537func (library *libraryDecorator) everInstallable() bool {
1538 // Only shared and static libraries are installed. Header libraries (which are
1539 // neither static or shared) are not installed.
1540 return library.shared() || library.static()
1541}
1542
Chris Parsons3c27ca32020-11-20 12:42:07 -05001543// static returns true if this library is for a "static' variant.
Colin Crossb916a382016-07-29 17:28:03 -07001544func (library *libraryDecorator) static() bool {
Colin Crossa48ab5b2017-02-14 15:28:44 -08001545 return library.MutatedProperties.VariantIsStatic
Colin Cross4d9c2d12016-07-29 12:48:20 -07001546}
1547
Chris Parsons3c27ca32020-11-20 12:42:07 -05001548// shared returns true if this library is for a "shared' variant.
Colin Crossa48ab5b2017-02-14 15:28:44 -08001549func (library *libraryDecorator) shared() bool {
1550 return library.MutatedProperties.VariantIsShared
1551}
1552
Chris Parsons3c27ca32020-11-20 12:42:07 -05001553// header returns true if this library is for a header-only variant.
Colin Crossa48ab5b2017-02-14 15:28:44 -08001554func (library *libraryDecorator) header() bool {
Chris Parsons3c27ca32020-11-20 12:42:07 -05001555 // Neither "static" nor "shared" implies this library is header-only.
Colin Crossa48ab5b2017-02-14 15:28:44 -08001556 return !library.static() && !library.shared()
1557}
1558
Chris Parsons3c27ca32020-11-20 12:42:07 -05001559// setStatic marks the library variant as "static".
Colin Crossa48ab5b2017-02-14 15:28:44 -08001560func (library *libraryDecorator) setStatic() {
1561 library.MutatedProperties.VariantIsStatic = true
1562 library.MutatedProperties.VariantIsShared = false
1563}
1564
Chris Parsons3c27ca32020-11-20 12:42:07 -05001565// setShared marks the library variant as "shared".
Colin Crossa48ab5b2017-02-14 15:28:44 -08001566func (library *libraryDecorator) setShared() {
1567 library.MutatedProperties.VariantIsStatic = false
1568 library.MutatedProperties.VariantIsShared = true
Colin Crossb916a382016-07-29 17:28:03 -07001569}
1570
Chris Parsons3c27ca32020-11-20 12:42:07 -05001571// BuildOnlyStatic disables building this library as a shared library.
Colin Crossab3b7322016-12-09 14:46:15 -08001572func (library *libraryDecorator) BuildOnlyStatic() {
Colin Crossa48ab5b2017-02-14 15:28:44 -08001573 library.MutatedProperties.BuildShared = false
Colin Crossab3b7322016-12-09 14:46:15 -08001574}
1575
Chris Parsons3c27ca32020-11-20 12:42:07 -05001576// BuildOnlyShared disables building this library as a static library.
Colin Crossab3b7322016-12-09 14:46:15 -08001577func (library *libraryDecorator) BuildOnlyShared() {
Colin Crossa48ab5b2017-02-14 15:28:44 -08001578 library.MutatedProperties.BuildStatic = false
Colin Crossab3b7322016-12-09 14:46:15 -08001579}
1580
Chris Parsons3c27ca32020-11-20 12:42:07 -05001581// HeaderOnly disables building this library as a shared or static library;
1582// the library only exists to propagate header file dependencies up the build graph.
Colin Cross5950f382016-12-13 12:50:57 -08001583func (library *libraryDecorator) HeaderOnly() {
Colin Crossa48ab5b2017-02-14 15:28:44 -08001584 library.MutatedProperties.BuildShared = false
1585 library.MutatedProperties.BuildStatic = false
Colin Cross5950f382016-12-13 12:50:57 -08001586}
1587
Colin Cross127bb8b2020-12-16 16:46:01 -08001588// hasLLNDKStubs returns true if this cc_library module has a variant that will build LLNDK stubs.
1589func (library *libraryDecorator) hasLLNDKStubs() bool {
1590 return String(library.Properties.Llndk_stubs) != ""
1591}
1592
Colin Cross0477b422020-10-13 18:43:54 -07001593func (library *libraryDecorator) implementationModuleName(name string) string {
1594 return name
1595}
1596
Jiyong Park7ed9de32018-10-15 22:25:07 +09001597func (library *libraryDecorator) buildStubs() bool {
1598 return library.MutatedProperties.BuildStubs
1599}
1600
Jiyong Parka034b832019-08-27 14:02:19 +09001601func (library *libraryDecorator) symbolFileForAbiCheck(ctx ModuleContext) *string {
1602 if library.Properties.Header_abi_checker.Symbol_file != nil {
1603 return library.Properties.Header_abi_checker.Symbol_file
1604 }
Colin Cross127bb8b2020-12-16 16:46:01 -08001605 if ctx.Module().(*Module).IsLlndk() {
1606 return library.Properties.Llndk.Symbol_file
1607 }
Colin Cross31076b32020-10-23 17:22:06 -07001608 if library.hasStubsVariants() && library.Properties.Stubs.Symbol_file != nil {
Jiyong Parka034b832019-08-27 14:02:19 +09001609 return library.Properties.Stubs.Symbol_file
1610 }
1611 return nil
1612}
1613
Colin Crossc88c2722020-09-28 17:32:47 -07001614func (library *libraryDecorator) hasStubsVariants() bool {
Jiyong Parkd4a3a132021-03-17 20:21:35 +09001615 // Just having stubs.symbol_file is enough to create a stub variant. In that case
1616 // the stub for the future API level is created.
1617 return library.Properties.Stubs.Symbol_file != nil ||
1618 len(library.Properties.Stubs.Versions) > 0
Colin Crossc88c2722020-09-28 17:32:47 -07001619}
1620
Colin Cross3572cf72020-10-01 15:58:11 -07001621func (library *libraryDecorator) stubsVersions(ctx android.BaseMutatorContext) []string {
Jiyong Parkd4a3a132021-03-17 20:21:35 +09001622 if !library.hasStubsVariants() {
1623 return nil
1624 }
1625
1626 // Future API level is implicitly added if there isn't
1627 vers := library.Properties.Stubs.Versions
1628 if inList(android.FutureApiLevel.String(), vers) {
1629 return vers
1630 }
1631 // In some cases, people use the raw value "10000" in the versions property.
1632 // We shouldn't add the future API level in that case, otherwise there will
1633 // be two identical versions.
1634 if inList(strconv.Itoa(android.FutureApiLevel.FinalOrFutureInt()), vers) {
1635 return vers
1636 }
1637 return append(vers, android.FutureApiLevel.String())
Colin Crossc88c2722020-09-28 17:32:47 -07001638}
1639
1640func (library *libraryDecorator) setStubsVersion(version string) {
1641 library.MutatedProperties.StubsVersion = version
1642}
1643
Jiyong Park7ed9de32018-10-15 22:25:07 +09001644func (library *libraryDecorator) stubsVersion() string {
1645 return library.MutatedProperties.StubsVersion
1646}
1647
Jiyong Parkd4a3a132021-03-17 20:21:35 +09001648func (library *libraryDecorator) setBuildStubs(isLatest bool) {
Colin Crossc88c2722020-09-28 17:32:47 -07001649 library.MutatedProperties.BuildStubs = true
Jiyong Parkd4a3a132021-03-17 20:21:35 +09001650 library.MutatedProperties.IsLatestVersion = isLatest
Colin Crossc88c2722020-09-28 17:32:47 -07001651}
1652
1653func (library *libraryDecorator) setAllStubsVersions(versions []string) {
1654 library.MutatedProperties.AllStubsVersions = versions
1655}
1656
1657func (library *libraryDecorator) allStubsVersions() []string {
1658 return library.MutatedProperties.AllStubsVersions
1659}
1660
Jooyung Hanad4c1872020-02-27 17:56:44 +09001661func (library *libraryDecorator) isLatestStubVersion() bool {
Jiyong Parkd4a3a132021-03-17 20:21:35 +09001662 return library.MutatedProperties.IsLatestVersion
Jooyung Hanad4c1872020-02-27 17:56:44 +09001663}
1664
Jiyong Parka90ca002019-10-07 15:47:24 +09001665func (library *libraryDecorator) availableFor(what string) bool {
1666 var list []string
1667 if library.static() {
1668 list = library.StaticProperties.Static.Apex_available
1669 } else if library.shared() {
1670 list = library.SharedProperties.Shared.Apex_available
1671 }
1672 if len(list) == 0 {
1673 return false
1674 }
1675 return android.CheckAvailableForApex(what, list)
1676}
1677
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01001678func (library *libraryDecorator) makeUninstallable(mod *Module) {
Martin Stjernholmbf37d162020-03-31 16:05:34 +01001679 if library.static() && library.buildStatic() && !library.buildStubs() {
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01001680 // If we're asked to make a static library uninstallable we don't do
1681 // anything since AndroidMkEntries always sets LOCAL_UNINSTALLABLE_MODULE
1682 // for these entries. This is done to still get the make targets for NOTICE
1683 // files from notice_files.mk, which other libraries might depend on.
Martin Stjernholmbf37d162020-03-31 16:05:34 +01001684 return
1685 }
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01001686 mod.ModuleBase.MakeUninstallable()
Martin Stjernholmbf37d162020-03-31 16:05:34 +01001687}
1688
Colin Cross571cccf2019-02-04 11:22:08 -08001689var versioningMacroNamesListKey = android.NewOnceKey("versioningMacroNamesList")
1690
Chris Parsons3c27ca32020-11-20 12:42:07 -05001691// versioningMacroNamesList returns a singleton map, where keys are "version macro names",
1692// and values are the module name responsible for registering the version macro name.
1693//
1694// Version macros are used when building against stubs, to provide version information about
1695// the stub. Only stub libraries should have an entry in this list.
1696//
1697// For example, when building against libFoo#ver, __LIBFOO_API__ macro is set to ver so
1698// that headers from libFoo can be conditionally compiled (this may hide APIs
1699// that are not available for the version).
1700//
1701// This map is used to ensure that there aren't conflicts between these version macro names.
Jiyong Parkda732bd2018-11-02 18:23:15 +09001702func versioningMacroNamesList(config android.Config) *map[string]string {
Colin Cross571cccf2019-02-04 11:22:08 -08001703 return config.Once(versioningMacroNamesListKey, func() interface{} {
Jiyong Parkda732bd2018-11-02 18:23:15 +09001704 m := make(map[string]string)
1705 return &m
1706 }).(*map[string]string)
1707}
1708
1709// alphanumeric and _ characters are preserved.
1710// other characters are all converted to _
1711var charsNotForMacro = regexp.MustCompile("[^a-zA-Z0-9_]+")
1712
Chris Parsons3c27ca32020-11-20 12:42:07 -05001713// versioningMacroName returns the canonical version macro name for the given module.
Jiyong Parkda732bd2018-11-02 18:23:15 +09001714func versioningMacroName(moduleName string) string {
1715 macroName := charsNotForMacro.ReplaceAllString(moduleName, "_")
Jooyung Hanb04a4992020-03-13 18:57:35 +09001716 macroName = strings.ToUpper(macroName)
Jiyong Parkda732bd2018-11-02 18:23:15 +09001717 return "__" + macroName + "_API__"
1718}
1719
Chris Parsons3c27ca32020-11-20 12:42:07 -05001720// NewLibrary builds and returns a new Module corresponding to a C++ library.
1721// Individual module implementations which comprise a C++ library (or something like
1722// a C++ library) should call this function, set some fields on the result, and
1723// then call the Init function.
Colin Crossab3b7322016-12-09 14:46:15 -08001724func NewLibrary(hod android.HostOrDeviceSupported) (*Module, *libraryDecorator) {
Colin Cross4d9c2d12016-07-29 12:48:20 -07001725 module := newModule(hod, android.MultilibBoth)
1726
Colin Crossb916a382016-07-29 17:28:03 -07001727 library := &libraryDecorator{
Colin Crossa48ab5b2017-02-14 15:28:44 -08001728 MutatedProperties: LibraryMutatedProperties{
Colin Crossab3b7322016-12-09 14:46:15 -08001729 BuildShared: true,
1730 BuildStatic: true,
Colin Cross4d9c2d12016-07-29 12:48:20 -07001731 },
Colin Crossb916a382016-07-29 17:28:03 -07001732 baseCompiler: NewBaseCompiler(),
Dan Albert61f32122018-07-26 14:00:24 -07001733 baseLinker: NewBaseLinker(module.sanitize),
Colin Crossb916a382016-07-29 17:28:03 -07001734 baseInstaller: NewBaseInstaller("lib", "lib64", InstallInSystem),
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001735 sabi: module.sabi,
Colin Cross4d9c2d12016-07-29 12:48:20 -07001736 }
1737
Colin Crossb916a382016-07-29 17:28:03 -07001738 module.compiler = library
1739 module.linker = library
1740 module.installer = library
Colin Cross31076b32020-10-23 17:22:06 -07001741 module.library = library
Colin Crossb916a382016-07-29 17:28:03 -07001742
1743 return module, library
1744}
1745
Colin Cross10d22312017-05-03 11:01:58 -07001746// connects a shared library to a static library in order to reuse its .o files to avoid
1747// compiling source files twice.
1748func reuseStaticLibrary(mctx android.BottomUpMutatorContext, static, shared *Module) {
1749 if staticCompiler, ok := static.compiler.(*libraryDecorator); ok {
1750 sharedCompiler := shared.compiler.(*libraryDecorator)
Dan Willemsen3a26eef2018-12-03 15:25:46 -08001751
1752 // Check libraries in addition to cflags, since libraries may be exporting different
1753 // include directories.
Colin Crosse1bb5d02019-09-24 14:55:04 -07001754 if len(staticCompiler.StaticProperties.Static.Cflags) == 0 &&
1755 len(sharedCompiler.SharedProperties.Shared.Cflags) == 0 &&
1756 len(staticCompiler.StaticProperties.Static.Whole_static_libs) == 0 &&
1757 len(sharedCompiler.SharedProperties.Shared.Whole_static_libs) == 0 &&
1758 len(staticCompiler.StaticProperties.Static.Static_libs) == 0 &&
1759 len(sharedCompiler.SharedProperties.Shared.Static_libs) == 0 &&
1760 len(staticCompiler.StaticProperties.Static.Shared_libs) == 0 &&
1761 len(sharedCompiler.SharedProperties.Shared.Shared_libs) == 0 &&
Martin Stjernholm10566a02020-03-24 01:19:52 +00001762 // Compare System_shared_libs properties with nil because empty lists are
1763 // semantically significant for them.
Colin Crosse1bb5d02019-09-24 14:55:04 -07001764 staticCompiler.StaticProperties.Static.System_shared_libs == nil &&
1765 sharedCompiler.SharedProperties.Shared.System_shared_libs == nil {
Colin Cross10d22312017-05-03 11:01:58 -07001766
1767 mctx.AddInterVariantDependency(reuseObjTag, shared, static)
1768 sharedCompiler.baseCompiler.Properties.OriginalSrcs =
1769 sharedCompiler.baseCompiler.Properties.Srcs
1770 sharedCompiler.baseCompiler.Properties.Srcs = nil
1771 sharedCompiler.baseCompiler.Properties.Generated_sources = nil
1772 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07001773
1774 // This dep is just to reference static variant from shared variant
1775 mctx.AddInterVariantDependency(staticVariantTag, shared, static)
Colin Cross10d22312017-05-03 11:01:58 -07001776 }
1777}
1778
Chris Parsons3c27ca32020-11-20 12:42:07 -05001779// LinkageMutator adds "static" or "shared" variants for modules depending
1780// on whether the module can be built as a static library or a shared library.
Colin Crosse40b4ea2018-10-02 22:25:58 -07001781func LinkageMutator(mctx android.BottomUpMutatorContext) {
Jaewoong Jung18aefc12020-12-21 09:11:10 -08001782 ccPrebuilt := false
Colin Crossb916a382016-07-29 17:28:03 -07001783 if m, ok := mctx.Module().(*Module); ok && m.linker != nil {
Jaewoong Jung18aefc12020-12-21 09:11:10 -08001784 _, ccPrebuilt = m.linker.(prebuiltLibraryInterface)
Ivan Lozano52767be2019-10-18 14:49:46 -07001785 }
Jaewoong Jung18aefc12020-12-21 09:11:10 -08001786 if ccPrebuilt {
Ivan Lozano52767be2019-10-18 14:49:46 -07001787 library := mctx.Module().(*Module).linker.(prebuiltLibraryInterface)
Colin Cross33b2fb72019-05-14 14:07:01 -07001788
Paul Duffinf5ea9e12020-02-21 10:57:00 +00001789 // Differentiate between header only and building an actual static/shared library
Colin Cross127bb8b2020-12-16 16:46:01 -08001790 buildStatic := library.buildStatic()
1791 buildShared := library.buildShared()
1792 if buildStatic || buildShared {
Paul Duffinf5ea9e12020-02-21 10:57:00 +00001793 // Always create both the static and shared variants for prebuilt libraries, and then disable the one
1794 // that is not being used. This allows them to share the name of a cc_library module, which requires that
1795 // all the variants of the cc_library also exist on the prebuilt.
1796 modules := mctx.CreateLocalVariations("static", "shared")
1797 static := modules[0].(*Module)
1798 shared := modules[1].(*Module)
Colin Cross33b2fb72019-05-14 14:07:01 -07001799
Paul Duffinf5ea9e12020-02-21 10:57:00 +00001800 static.linker.(prebuiltLibraryInterface).setStatic()
1801 shared.linker.(prebuiltLibraryInterface).setShared()
Colin Cross33b2fb72019-05-14 14:07:01 -07001802
Colin Cross127bb8b2020-12-16 16:46:01 -08001803 if buildShared {
Colin Cross81ca6cd2020-08-06 17:46:48 -07001804 mctx.AliasVariation("shared")
Colin Cross127bb8b2020-12-16 16:46:01 -08001805 } else if buildStatic {
Colin Cross81ca6cd2020-08-06 17:46:48 -07001806 mctx.AliasVariation("static")
1807 }
1808
Colin Cross127bb8b2020-12-16 16:46:01 -08001809 if !buildStatic {
Paul Duffinf5ea9e12020-02-21 10:57:00 +00001810 static.linker.(prebuiltLibraryInterface).disablePrebuilt()
1811 }
Colin Cross127bb8b2020-12-16 16:46:01 -08001812 if !buildShared {
Paul Duffinf5ea9e12020-02-21 10:57:00 +00001813 shared.linker.(prebuiltLibraryInterface).disablePrebuilt()
1814 }
1815 } else {
1816 // Header only
Colin Crossb916a382016-07-29 17:28:03 -07001817 }
Paul Duffinf5ea9e12020-02-21 10:57:00 +00001818
Ivan Lozano52767be2019-10-18 14:49:46 -07001819 } else if library, ok := mctx.Module().(LinkableInterface); ok && library.CcLibraryInterface() {
Ivan Lozano52767be2019-10-18 14:49:46 -07001820
Ivan Lozano2b262972019-11-21 12:30:50 -08001821 // Non-cc.Modules may need an empty variant for their mutators.
1822 variations := []string{}
1823 if library.NonCcVariants() {
1824 variations = append(variations, "")
1825 }
1826
Colin Cross127bb8b2020-12-16 16:46:01 -08001827 isLLNDK := false
1828 if m, ok := mctx.Module().(*Module); ok {
Colin Cross127bb8b2020-12-16 16:46:01 -08001829 // Don't count the vestigial llndk_library module as isLLNDK, it needs a static
1830 // variant so that a cc_library_prebuilt can depend on it.
Colin Cross4f4f8eb2021-01-06 14:07:27 -08001831 isLLNDK = m.IsLlndk() && !isVestigialLLNDKModule(m)
Colin Cross127bb8b2020-12-16 16:46:01 -08001832 }
1833 buildStatic := library.BuildStaticVariant() && !isLLNDK
1834 buildShared := library.BuildSharedVariant()
1835 if buildStatic && buildShared {
Ivan Lozano2b262972019-11-21 12:30:50 -08001836 variations := append([]string{"static", "shared"}, variations...)
Ivan Lozano52767be2019-10-18 14:49:46 -07001837
1838 modules := mctx.CreateLocalVariations(variations...)
1839 static := modules[0].(LinkableInterface)
1840 shared := modules[1].(LinkableInterface)
1841
1842 static.SetStatic()
1843 shared.SetShared()
1844
1845 if _, ok := library.(*Module); ok {
1846 reuseStaticLibrary(mctx, static.(*Module), shared.(*Module))
1847 }
Colin Cross81ca6cd2020-08-06 17:46:48 -07001848 mctx.AliasVariation("shared")
Colin Cross127bb8b2020-12-16 16:46:01 -08001849 } else if buildStatic {
Ivan Lozano2b262972019-11-21 12:30:50 -08001850 variations := append([]string{"static"}, variations...)
1851
1852 modules := mctx.CreateLocalVariations(variations...)
Ivan Lozano52767be2019-10-18 14:49:46 -07001853 modules[0].(LinkableInterface).SetStatic()
Colin Cross81ca6cd2020-08-06 17:46:48 -07001854 mctx.AliasVariation("static")
Colin Cross127bb8b2020-12-16 16:46:01 -08001855 } else if buildShared {
Ivan Lozano2b262972019-11-21 12:30:50 -08001856 variations := append([]string{"shared"}, variations...)
Ivan Lozano52767be2019-10-18 14:49:46 -07001857
Ivan Lozano2b262972019-11-21 12:30:50 -08001858 modules := mctx.CreateLocalVariations(variations...)
1859 modules[0].(LinkableInterface).SetShared()
Colin Cross81ca6cd2020-08-06 17:46:48 -07001860 mctx.AliasVariation("shared")
Ivan Lozano2b262972019-11-21 12:30:50 -08001861 } else if len(variations) > 0 {
1862 mctx.CreateLocalVariations(variations...)
Colin Cross81ca6cd2020-08-06 17:46:48 -07001863 mctx.AliasVariation(variations[0])
Ivan Lozano2b262972019-11-21 12:30:50 -08001864 }
Colin Crossb916a382016-07-29 17:28:03 -07001865 }
Colin Cross4d9c2d12016-07-29 12:48:20 -07001866}
Jiyong Park7ed9de32018-10-15 22:25:07 +09001867
Chris Parsons3c27ca32020-11-20 12:42:07 -05001868// normalizeVersions modifies `versions` in place, so that each raw version
1869// string becomes its normalized canonical form.
1870// Validates that the versions in `versions` are specified in least to greatest order.
Jooyung Hanaed150d2020-04-02 01:41:41 +09001871func normalizeVersions(ctx android.BaseModuleContext, versions []string) {
Dan Albertc8060532020-07-22 22:32:17 -07001872 var previous android.ApiLevel
Jooyung Hanad4c1872020-02-27 17:56:44 +09001873 for i, v := range versions {
Dan Albertc8060532020-07-22 22:32:17 -07001874 ver, err := android.ApiLevelFromUser(ctx, v)
Jooyung Hanad4c1872020-02-27 17:56:44 +09001875 if err != nil {
Jooyung Hanaed150d2020-04-02 01:41:41 +09001876 ctx.PropertyErrorf("versions", "%s", err.Error())
1877 return
Jooyung Hanad4c1872020-02-27 17:56:44 +09001878 }
Dan Albertc8060532020-07-22 22:32:17 -07001879 if i > 0 && ver.LessThanOrEqualTo(previous) {
1880 ctx.PropertyErrorf("versions", "not sorted: %v", versions)
1881 }
1882 versions[i] = ver.String()
1883 previous = ver
Jooyung Hanaed150d2020-04-02 01:41:41 +09001884 }
Jooyung Hanad4c1872020-02-27 17:56:44 +09001885}
1886
Jooyung Han61b66e92020-03-21 14:21:46 +00001887func createVersionVariations(mctx android.BottomUpMutatorContext, versions []string) {
Colin Cross127bb8b2020-12-16 16:46:01 -08001888 // "" is for the non-stubs (implementation) variant for system modules, or the LLNDK variant
1889 // for LLNDK modules.
Colin Cross0de8a1e2020-09-18 14:15:30 -07001890 variants := append(android.CopyOf(versions), "")
Jooyung Han61b66e92020-03-21 14:21:46 +00001891
Colin Cross127bb8b2020-12-16 16:46:01 -08001892 m := mctx.Module().(*Module)
1893 isLLNDK := m.IsLlndk()
1894
Colin Crossd1f898e2020-08-18 18:35:15 -07001895 modules := mctx.CreateLocalVariations(variants...)
Jooyung Han61b66e92020-03-21 14:21:46 +00001896 for i, m := range modules {
Colin Cross127bb8b2020-12-16 16:46:01 -08001897
1898 if variants[i] != "" || isLLNDK {
1899 // A stubs or LLNDK stubs variant.
Colin Cross31076b32020-10-23 17:22:06 -07001900 c := m.(*Module)
Colin Cross31076b32020-10-23 17:22:06 -07001901 c.sanitize = nil
1902 c.stl = nil
1903 c.Properties.PreventInstall = true
1904 lib := moduleLibraryInterface(m)
Jiyong Parkd4a3a132021-03-17 20:21:35 +09001905 isLatest := i == (len(versions) - 1)
1906 lib.setBuildStubs(isLatest)
Colin Cross127bb8b2020-12-16 16:46:01 -08001907
1908 if variants[i] != "" {
1909 // A non-LLNDK stubs module is hidden from make and has a dependency from the
1910 // implementation module to the stubs module.
1911 c.Properties.HideFromMake = true
1912 lib.setStubsVersion(variants[i])
1913 mctx.AddInterVariantDependency(stubImplDepTag, modules[len(modules)-1], modules[i])
1914 }
Jooyung Han61b66e92020-03-21 14:21:46 +00001915 }
1916 }
Colin Cross094faa52020-08-06 17:38:25 -07001917 mctx.AliasVariation("")
Colin Crossd1f898e2020-08-18 18:35:15 -07001918 latestVersion := ""
1919 if len(versions) > 0 {
1920 latestVersion = versions[len(versions)-1]
1921 }
1922 mctx.CreateAliasVariation("latest", latestVersion)
Jooyung Han61b66e92020-03-21 14:21:46 +00001923}
1924
Colin Crossbbc941b2020-09-30 12:27:01 -07001925func createPerApiVersionVariations(mctx android.BottomUpMutatorContext, minSdkVersion string) {
1926 from, err := nativeApiLevelFromUser(mctx, minSdkVersion)
1927 if err != nil {
1928 mctx.PropertyErrorf("min_sdk_version", err.Error())
1929 return
1930 }
1931
1932 versionStrs := ndkLibraryVersions(mctx, from)
1933 modules := mctx.CreateLocalVariations(versionStrs...)
1934
1935 for i, module := range modules {
1936 module.(*Module).Properties.Sdk_version = StringPtr(versionStrs[i])
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001937 module.(*Module).Properties.Min_sdk_version = StringPtr(versionStrs[i])
Colin Crossbbc941b2020-09-30 12:27:01 -07001938 }
1939}
1940
Colin Cross3146c5c2020-09-30 15:34:40 -07001941func CanBeOrLinkAgainstVersionVariants(module interface {
Jooyung Han624d35c2020-04-10 12:57:24 +09001942 Host() bool
1943 InRamdisk() bool
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001944 InVendorRamdisk() bool
Jooyung Han624d35c2020-04-10 12:57:24 +09001945}) bool {
Jose Galmes6f843bc2020-12-11 13:36:29 -08001946 return !module.Host() && !module.InRamdisk() && !module.InVendorRamdisk()
Jooyung Han624d35c2020-04-10 12:57:24 +09001947}
1948
Colin Cross3146c5c2020-09-30 15:34:40 -07001949func CanBeVersionVariant(module interface {
1950 Host() bool
1951 InRamdisk() bool
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001952 InVendorRamdisk() bool
Colin Cross3146c5c2020-09-30 15:34:40 -07001953 InRecovery() bool
1954 CcLibraryInterface() bool
1955 Shared() bool
Colin Cross3146c5c2020-09-30 15:34:40 -07001956}) bool {
1957 return CanBeOrLinkAgainstVersionVariants(module) &&
Colin Crossa717db72020-10-23 14:53:06 -07001958 module.CcLibraryInterface() && module.Shared()
Colin Cross3146c5c2020-09-30 15:34:40 -07001959}
1960
Colin Cross127bb8b2020-12-16 16:46:01 -08001961func moduleLibraryInterface(module blueprint.Module) libraryInterface {
Colin Cross31076b32020-10-23 17:22:06 -07001962 if m, ok := module.(*Module); ok {
1963 return m.library
1964 }
1965 return nil
1966}
1967
Colin Crossd1f898e2020-08-18 18:35:15 -07001968// versionSelector normalizes the versions in the Stubs.Versions property into MutatedProperties.AllStubsVersions,
1969// and propagates the value from implementation libraries to llndk libraries with the same name.
1970func versionSelectorMutator(mctx android.BottomUpMutatorContext) {
Colin Cross31076b32020-10-23 17:22:06 -07001971 if library := moduleLibraryInterface(mctx.Module()); library != nil && CanBeVersionVariant(mctx.Module().(*Module)) {
1972 if library.buildShared() {
1973 versions := library.stubsVersions(mctx)
Colin Cross3572cf72020-10-01 15:58:11 -07001974 if len(versions) > 0 {
1975 normalizeVersions(mctx, versions)
1976 if mctx.Failed() {
Colin Crossbbc941b2020-09-30 12:27:01 -07001977 return
1978 }
Colin Cross3572cf72020-10-01 15:58:11 -07001979 // Set the versions on the pre-mutated module so they can be read by any llndk modules that
1980 // depend on the implementation library and haven't been mutated yet.
Colin Cross31076b32020-10-23 17:22:06 -07001981 library.setAllStubsVersions(versions)
Colin Cross127bb8b2020-12-16 16:46:01 -08001982 }
1983
1984 if mctx.Module().(*Module).UseVndk() && library.hasLLNDKStubs() {
1985 // Propagate the version to the llndk stubs module.
1986 mctx.VisitDirectDepsWithTag(llndkStubDepTag, func(stubs android.Module) {
1987 if stubsLib := moduleLibraryInterface(stubs); stubsLib != nil {
1988 stubsLib.setAllStubsVersions(library.allStubsVersions())
1989 }
1990 })
Jiyong Park7ed9de32018-10-15 22:25:07 +09001991 }
Jooyung Han61b66e92020-03-21 14:21:46 +00001992 }
Colin Crossd1f898e2020-08-18 18:35:15 -07001993 }
1994}
Jooyung Han61b66e92020-03-21 14:21:46 +00001995
Colin Crossd1f898e2020-08-18 18:35:15 -07001996// versionMutator splits a module into the mandatory non-stubs variant
1997// (which is unnamed) and zero or more stubs variants.
1998func versionMutator(mctx android.BottomUpMutatorContext) {
Colin Cross31076b32020-10-23 17:22:06 -07001999 if library := moduleLibraryInterface(mctx.Module()); library != nil && CanBeVersionVariant(mctx.Module().(*Module)) {
2000 createVersionVariations(mctx, library.allStubsVersions())
Colin Crossbbc941b2020-09-30 12:27:01 -07002001 return
2002 }
2003
2004 if m, ok := mctx.Module().(*Module); ok {
2005 if m.SplitPerApiLevel() && m.IsSdkVariant() {
2006 if mctx.Os() != android.Android {
2007 return
2008 }
2009 createPerApiVersionVariations(mctx, m.MinSdkVersion())
2010 }
Jiyong Park7ed9de32018-10-15 22:25:07 +09002011 }
Jiyong Park7ed9de32018-10-15 22:25:07 +09002012}
Colin Crossd7227f92019-09-05 14:26:33 -07002013
2014// maybeInjectBoringSSLHash adds a rule to run bssl_inject_hash on the output file if the module has the
2015// inject_bssl_hash or if any static library dependencies have inject_bssl_hash set. It returns the output path
2016// that the linked output file should be written to.
2017// TODO(b/137267623): Remove this in favor of a cc_genrule when they support operating on shared libraries.
2018func maybeInjectBoringSSLHash(ctx android.ModuleContext, outputFile android.ModuleOutPath,
2019 inject *bool, fileName string) android.ModuleOutPath {
2020 // TODO(b/137267623): Remove this in favor of a cc_genrule when they support operating on shared libraries.
2021 injectBoringSSLHash := Bool(inject)
2022 ctx.VisitDirectDeps(func(dep android.Module) {
Colin Cross6e511a92020-07-27 21:26:48 -07002023 if tag, ok := ctx.OtherModuleDependencyTag(dep).(libraryDependencyTag); ok && tag.static() {
Colin Crossd7227f92019-09-05 14:26:33 -07002024 if cc, ok := dep.(*Module); ok {
2025 if library, ok := cc.linker.(*libraryDecorator); ok {
2026 if Bool(library.Properties.Inject_bssl_hash) {
2027 injectBoringSSLHash = true
2028 }
2029 }
2030 }
2031 }
2032 })
2033 if injectBoringSSLHash {
2034 hashedOutputfile := outputFile
2035 outputFile = android.PathForModuleOut(ctx, "unhashed", fileName)
2036
Colin Crossf1a035e2020-11-16 17:32:30 -08002037 rule := android.NewRuleBuilder(pctx, ctx)
Colin Crossd7227f92019-09-05 14:26:33 -07002038 rule.Command().
Colin Crossf1a035e2020-11-16 17:32:30 -08002039 BuiltTool("bssl_inject_hash").
Pete Bentley5c4be822019-10-01 17:03:17 +01002040 Flag("-sha256").
Colin Crossd7227f92019-09-05 14:26:33 -07002041 FlagWithInput("-in-object ", outputFile).
2042 FlagWithOutput("-o ", hashedOutputfile)
Colin Crossf1a035e2020-11-16 17:32:30 -08002043 rule.Build("injectCryptoHash", "inject crypto hash")
Colin Crossd7227f92019-09-05 14:26:33 -07002044 }
2045
2046 return outputFile
2047}
Rupert Shuttleworth095081c2021-03-25 09:06:03 +00002048
Rupert Shuttleworth095081c2021-03-25 09:06:03 +00002049type bazelCcLibraryStaticAttributes struct {
2050 Copts []string
Jingwen Chen07027912021-03-15 06:02:43 -04002051 Srcs bazel.LabelListAttribute
2052 Deps bazel.LabelListAttribute
Rupert Shuttleworth095081c2021-03-25 09:06:03 +00002053 Linkstatic bool
Rupert Shuttleworthb8151682021-04-06 20:06:21 +00002054 Includes bazel.StringListAttribute
Jingwen Chen07027912021-03-15 06:02:43 -04002055 Hdrs bazel.LabelListAttribute
Rupert Shuttleworth095081c2021-03-25 09:06:03 +00002056}
2057
2058type bazelCcLibraryStatic struct {
2059 android.BazelTargetModuleBase
2060 bazelCcLibraryStaticAttributes
2061}
2062
2063func BazelCcLibraryStaticFactory() android.Module {
2064 module := &bazelCcLibraryStatic{}
2065 module.AddProperties(&module.bazelCcLibraryStaticAttributes)
2066 android.InitBazelTargetModule(module)
2067 return module
2068}
2069
2070func CcLibraryStaticBp2Build(ctx android.TopDownMutatorContext) {
2071 module, ok := ctx.Module().(*Module)
2072 if !ok {
2073 // Not a cc module
2074 return
2075 }
2076 if !module.ConvertWithBp2build(ctx) {
2077 return
2078 }
2079 if ctx.ModuleType() != "cc_library_static" {
2080 return
2081 }
2082
2083 var copts []string
2084 var srcs []string
2085 var includeDirs []string
2086 var localIncludeDirs []string
2087 for _, props := range module.compiler.compilerProps() {
2088 if baseCompilerProps, ok := props.(*BaseCompilerProperties); ok {
2089 copts = baseCompilerProps.Cflags
2090 srcs = baseCompilerProps.Srcs
Rupert Shuttleworthb8151682021-04-06 20:06:21 +00002091 includeDirs = bp2BuildMakePathsRelativeToModule(ctx, baseCompilerProps.Include_dirs)
2092 localIncludeDirs = bp2BuildMakePathsRelativeToModule(ctx, baseCompilerProps.Local_include_dirs)
Rupert Shuttleworth095081c2021-03-25 09:06:03 +00002093 break
2094 }
2095 }
Jingwen Chen07027912021-03-15 06:02:43 -04002096 srcsLabels := bazel.MakeLabelListAttribute(android.BazelLabelForModuleSrc(ctx, srcs))
Rupert Shuttleworth095081c2021-03-25 09:06:03 +00002097
2098 var staticLibs []string
2099 var wholeStaticLibs []string
2100 for _, props := range module.linker.linkerProps() {
2101 if baseLinkerProperties, ok := props.(*BaseLinkerProperties); ok {
2102 staticLibs = baseLinkerProperties.Static_libs
2103 wholeStaticLibs = baseLinkerProperties.Whole_static_libs
2104 break
2105 }
2106 }
2107
2108 // FIXME: Treat Static_libs and Whole_static_libs differently?
2109 allDeps := staticLibs
2110 allDeps = append(allDeps, wholeStaticLibs...)
2111
2112 depsLabels := android.BazelLabelForModuleDeps(ctx, allDeps)
2113
Rupert Shuttleworthb8151682021-04-06 20:06:21 +00002114 exportedIncludes, exportedIncludesHeaders := bp2BuildParseExportedIncludes(ctx, module)
2115
Rupert Shuttleworth095081c2021-03-25 09:06:03 +00002116 // FIXME: Unify absolute vs relative paths
2117 // FIXME: Use -I copts instead of setting includes= ?
Rupert Shuttleworthb8151682021-04-06 20:06:21 +00002118 allIncludes := exportedIncludes
2119 allIncludes.Value = append(allIncludes.Value, includeDirs...)
2120 allIncludes.Value = append(allIncludes.Value, localIncludeDirs...)
Rupert Shuttleworth095081c2021-03-25 09:06:03 +00002121
Jingwen Chen91220d72021-03-24 02:18:33 -04002122 headerLibsLabels := bp2BuildParseHeaderLibs(ctx, module)
Jingwen Chen07027912021-03-15 06:02:43 -04002123 depsLabels.Append(headerLibsLabels.Value)
Rupert Shuttleworth095081c2021-03-25 09:06:03 +00002124
2125 attrs := &bazelCcLibraryStaticAttributes{
2126 Copts: copts,
Jingwen Chen07027912021-03-15 06:02:43 -04002127 Srcs: srcsLabels,
2128 Deps: bazel.MakeLabelListAttribute(depsLabels),
Rupert Shuttleworth095081c2021-03-25 09:06:03 +00002129 Linkstatic: true,
Rupert Shuttleworthb8151682021-04-06 20:06:21 +00002130 Includes: allIncludes,
2131 Hdrs: exportedIncludesHeaders,
Rupert Shuttleworth095081c2021-03-25 09:06:03 +00002132 }
2133
2134 props := bazel.BazelTargetModuleProperties{
2135 Rule_class: "cc_library_static",
2136 Bzl_load_location: "//build/bazel/rules:cc_library_static.bzl",
2137 }
2138
2139 ctx.CreateBazelTargetModule(BazelCcLibraryStaticFactory, module.Name(), props, attrs)
2140}
2141
2142func (m *bazelCcLibraryStatic) Name() string {
2143 return m.BaseModuleName()
2144}
2145
2146func (m *bazelCcLibraryStatic) GenerateAndroidBuildActions(ctx android.ModuleContext) {}