blob: bca9a96808eefbfd35f46a92c06455467418b25e [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"
Jiyong Park25fc6a92018-11-18 18:02:45 +090022 "sort"
23 "strconv"
Colin Cross4d9c2d12016-07-29 12:48:20 -070024 "strings"
Jiyong Parkda732bd2018-11-02 18:23:15 +090025 "sync"
Colin Cross4d9c2d12016-07-29 12:48:20 -070026
Colin 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"
Dan Albertea4b7b92018-04-25 16:05:30 -070030 "android/soong/cc/config"
Jiyong Park7ed9de32018-10-15 22:25:07 +090031 "android/soong/genrule"
Colin Cross4d9c2d12016-07-29 12:48:20 -070032)
33
Colin Crossb916a382016-07-29 17:28:03 -070034type LibraryProperties struct {
Colin Cross4d9c2d12016-07-29 12:48:20 -070035 // local file name to pass to the linker as -unexported_symbols_list
Colin Cross27b922f2019-03-04 22:35:41 -080036 Unexported_symbols_list *string `android:"path,arch_variant"`
Colin Cross4d9c2d12016-07-29 12:48:20 -070037 // local file name to pass to the linker as -force_symbols_not_weak_list
Colin Cross27b922f2019-03-04 22:35:41 -080038 Force_symbols_not_weak_list *string `android:"path,arch_variant"`
Colin Cross4d9c2d12016-07-29 12:48:20 -070039 // local file name to pass to the linker as -force_symbols_weak_list
Colin Cross27b922f2019-03-04 22:35:41 -080040 Force_symbols_weak_list *string `android:"path,arch_variant"`
Colin Cross4d9c2d12016-07-29 12:48:20 -070041
42 // rename host libraries to prevent overlap with system installed libraries
43 Unique_host_soname *bool
44
Dan Willemsene1240db2016-11-03 14:28:51 -070045 Aidl struct {
46 // export headers generated from .aidl sources
Nan Zhang0007d812017-11-07 10:57:05 -080047 Export_aidl_headers *bool
Dan Willemsene1240db2016-11-03 14:28:51 -070048 }
49
Colin Cross0c461f12016-10-20 16:11:43 -070050 Proto struct {
51 // export headers generated from .proto sources
Nan Zhang0007d812017-11-07 10:57:05 -080052 Export_proto_headers *bool
Colin Cross0c461f12016-10-20 16:11:43 -070053 }
Dan Albertf563d252017-10-13 00:29:00 -070054
Inseob Kimc0907f12019-02-08 21:00:45 +090055 Sysprop struct {
56 // Whether platform owns this sysprop library.
57 Platform *bool
Inseob Kimb3f22ca2019-03-05 12:40:24 +090058 } `blueprint:"mutated"`
Inseob Kimc0907f12019-02-08 21:00:45 +090059
Nan Zhang0007d812017-11-07 10:57:05 -080060 Static_ndk_lib *bool
Jiyong Park7ed9de32018-10-15 22:25:07 +090061
62 Stubs struct {
63 // Relative path to the symbol map. The symbol map provides the list of
64 // symbols that are exported for stubs variant of this library.
Colin Cross27b922f2019-03-04 22:35:41 -080065 Symbol_file *string `android:"path"`
Jiyong Park7ed9de32018-10-15 22:25:07 +090066
67 // List versions to generate stubs libs for.
68 Versions []string
69 }
dimitryd95964a2018-11-07 13:43:34 +010070
71 // set the name of the output
72 Stem *string `android:"arch_variant"`
73
Colin Cross0fd6a412019-08-16 14:22:10 -070074 // set suffix of the name of the output
75 Suffix *string `android:"arch_variant"`
76
77 Target struct {
78 Vendor struct {
79 // set suffix of the name of the output
80 Suffix *string `android:"arch_variant"`
81 }
82 }
83
dimitryd95964a2018-11-07 13:43:34 +010084 // Names of modules to be overridden. Listed modules can only be other shared libraries
85 // (in Make or Soong).
86 // This does not completely prevent installation of the overridden libraries, but if both
87 // binaries would be installed by default (in PRODUCT_PACKAGES) the other library will be removed
88 // from PRODUCT_PACKAGES.
89 Overrides []string
Logan Chiene3d7a0d2019-01-17 00:18:02 +080090
91 // Properties for ABI compatibility checker
92 Header_abi_checker struct {
Logan Chien41eabe62019-04-10 13:33:58 +080093 // Enable ABI checks (even if this is not an LLNDK/VNDK lib)
94 Enabled *bool
95
Logan Chiene3d7a0d2019-01-17 00:18:02 +080096 // Path to a symbol file that specifies the symbols to be included in the generated
97 // ABI dump file
Colin Cross27b922f2019-03-04 22:35:41 -080098 Symbol_file *string `android:"path"`
Logan Chiene3d7a0d2019-01-17 00:18:02 +080099
100 // Symbol versions that should be ignored from the symbol file
101 Exclude_symbol_versions []string
102
103 // Symbol tags that should be ignored from the symbol file
104 Exclude_symbol_tags []string
105 }
Vic Yang6cd1be82019-06-24 16:08:48 -0700106
107 // Order symbols in .bss section by their sizes. Only useful for shared libraries.
108 Sort_bss_symbols_by_size *bool
Pete Bentley803e1612019-08-06 22:19:59 +0100109
110 // Inject boringssl hash into the shared library. This is only intended for use by external/boringssl.
111 Inject_bssl_hash *bool `android:"arch_variant"`
Colin Crossa48ab5b2017-02-14 15:28:44 -0800112}
Colin Cross0c461f12016-10-20 16:11:43 -0700113
Colin Crosse1bb5d02019-09-24 14:55:04 -0700114type StaticProperties struct {
115 Static StaticOrSharedProperties `android:"arch_variant"`
116}
117
118type SharedProperties struct {
119 Shared StaticOrSharedProperties `android:"arch_variant"`
120}
121
122type StaticOrSharedProperties struct {
123 Srcs []string `android:"path,arch_variant"`
124 Cflags []string `android:"arch_variant"`
125
126 Enabled *bool `android:"arch_variant"`
127 Whole_static_libs []string `android:"arch_variant"`
128 Static_libs []string `android:"arch_variant"`
129 Shared_libs []string `android:"arch_variant"`
130 System_shared_libs []string `android:"arch_variant"`
131
132 Export_shared_lib_headers []string `android:"arch_variant"`
133 Export_static_lib_headers []string `android:"arch_variant"`
Jiyong Parka90ca002019-10-07 15:47:24 +0900134
135 Apex_available []string `android:"arch_variant"`
Colin Crosse1bb5d02019-09-24 14:55:04 -0700136}
137
Colin Crossa48ab5b2017-02-14 15:28:44 -0800138type LibraryMutatedProperties struct {
Colin Crossb916a382016-07-29 17:28:03 -0700139 // Build a static variant
140 BuildStatic bool `blueprint:"mutated"`
141 // Build a shared variant
142 BuildShared bool `blueprint:"mutated"`
143 // This variant is shared
144 VariantIsShared bool `blueprint:"mutated"`
145 // This variant is static
146 VariantIsStatic bool `blueprint:"mutated"`
Jiyong Park7ed9de32018-10-15 22:25:07 +0900147
148 // This variant is a stubs lib
149 BuildStubs bool `blueprint:"mutated"`
150 // Version of the stubs lib
151 StubsVersion string `blueprint:"mutated"`
Colin Crossb916a382016-07-29 17:28:03 -0700152}
153
154type FlagExporterProperties struct {
155 // list of directories relative to the Blueprints file that will
Dan Willemsen273af7f2016-11-03 15:53:42 -0700156 // be added to the include path (using -I) for this module and any module that links
Colin Cross5d195602017-10-17 16:15:50 -0700157 // against this module. Directories listed in export_include_dirs do not need to be
158 // listed in local_include_dirs.
Colin Crossb916a382016-07-29 17:28:03 -0700159 Export_include_dirs []string `android:"arch_variant"`
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700160
Jiyong Park73c54ee2019-10-22 20:31:18 +0900161 // list of directories that will be added to the system include path
162 // using -isystem for this module and any module that links against this module.
163 Export_system_include_dirs []string `android:"arch_variant"`
164
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700165 Target struct {
166 Vendor struct {
167 // list of exported include directories, like
168 // export_include_dirs, that will be applied to the
169 // vendor variant of this library. This will overwrite
170 // any other declarations.
Steven Morelandb21df8f2018-01-05 14:42:54 -0800171 Override_export_include_dirs []string
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700172 }
173 }
Colin Cross4d9c2d12016-07-29 12:48:20 -0700174}
175
176func init() {
Paul Duffin6c26dc72019-12-19 15:02:40 +0000177 RegisterLibraryBuildComponents(android.InitRegistrationContext)
178}
179
180func RegisterLibraryBuildComponents(ctx android.RegistrationContext) {
181 ctx.RegisterModuleType("cc_library_static", LibraryStaticFactory)
182 ctx.RegisterModuleType("cc_library_shared", LibrarySharedFactory)
183 ctx.RegisterModuleType("cc_library", LibraryFactory)
184 ctx.RegisterModuleType("cc_library_host_static", LibraryHostStaticFactory)
185 ctx.RegisterModuleType("cc_library_host_shared", LibraryHostSharedFactory)
186 ctx.RegisterModuleType("cc_library_headers", LibraryHeaderFactory)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700187}
188
Patrice Arruda83c89e02019-03-25 15:32:39 -0700189// cc_library creates both static and/or shared libraries for a device and/or
190// host. By default, a cc_library has a single variant that targets the device.
191// Specifying `host_supported: true` also creates a library that targets the
192// host.
Steven Morelandf9e62162017-11-02 17:00:50 -0700193func LibraryFactory() android.Module {
Colin Crossab3b7322016-12-09 14:46:15 -0800194 module, _ := NewLibrary(android.HostAndDeviceSupported)
Paul Duffina0843f62019-12-13 19:50:38 +0000195 // Can be used as both a static and a shared library.
196 module.sdkMemberTypes = []android.SdkMemberType{
197 sharedLibrarySdkMemberType,
198 staticLibrarySdkMemberType,
199 }
Colin Cross4d9c2d12016-07-29 12:48:20 -0700200 return module.Init()
201}
202
Patrice Arruda83c89e02019-03-25 15:32:39 -0700203// cc_library_static creates a static library for a device and/or host binary.
Steven Morelandf9e62162017-11-02 17:00:50 -0700204func LibraryStaticFactory() android.Module {
Colin Crossab3b7322016-12-09 14:46:15 -0800205 module, library := NewLibrary(android.HostAndDeviceSupported)
206 library.BuildOnlyStatic()
Paul Duffina0843f62019-12-13 19:50:38 +0000207 module.sdkMemberTypes = []android.SdkMemberType{staticLibrarySdkMemberType}
Colin Cross4d9c2d12016-07-29 12:48:20 -0700208 return module.Init()
209}
210
Patrice Arruda83c89e02019-03-25 15:32:39 -0700211// cc_library_shared creates a shared library for a device and/or host.
Steven Morelandf9e62162017-11-02 17:00:50 -0700212func LibrarySharedFactory() android.Module {
Colin Crossab3b7322016-12-09 14:46:15 -0800213 module, library := NewLibrary(android.HostAndDeviceSupported)
214 library.BuildOnlyShared()
Paul Duffina0843f62019-12-13 19:50:38 +0000215 module.sdkMemberTypes = []android.SdkMemberType{sharedLibrarySdkMemberType}
Colin Cross4d9c2d12016-07-29 12:48:20 -0700216 return module.Init()
217}
218
Patrice Arruda83c89e02019-03-25 15:32:39 -0700219// cc_library_host_static creates a static library that is linkable to a host
220// binary.
Steven Morelandf9e62162017-11-02 17:00:50 -0700221func LibraryHostStaticFactory() android.Module {
Colin Crossab3b7322016-12-09 14:46:15 -0800222 module, library := NewLibrary(android.HostSupported)
223 library.BuildOnlyStatic()
Paul Duffina0843f62019-12-13 19:50:38 +0000224 module.sdkMemberTypes = []android.SdkMemberType{staticLibrarySdkMemberType}
Colin Cross4d9c2d12016-07-29 12:48:20 -0700225 return module.Init()
226}
227
Patrice Arruda83c89e02019-03-25 15:32:39 -0700228// cc_library_host_shared creates a shared library that is usable on a host.
Steven Morelandf9e62162017-11-02 17:00:50 -0700229func LibraryHostSharedFactory() android.Module {
Colin Crossab3b7322016-12-09 14:46:15 -0800230 module, library := NewLibrary(android.HostSupported)
231 library.BuildOnlyShared()
Paul Duffina0843f62019-12-13 19:50:38 +0000232 module.sdkMemberTypes = []android.SdkMemberType{sharedLibrarySdkMemberType}
Colin Cross4d9c2d12016-07-29 12:48:20 -0700233 return module.Init()
234}
235
Patrice Arruda83c89e02019-03-25 15:32:39 -0700236// cc_library_headers contains a set of c/c++ headers which are imported by
237// other soong cc modules using the header_libs property. For best practices,
238// use export_include_dirs property or LOCAL_EXPORT_C_INCLUDE_DIRS for
239// Make.
Steven Morelandf9e62162017-11-02 17:00:50 -0700240func LibraryHeaderFactory() android.Module {
Colin Cross5950f382016-12-13 12:50:57 -0800241 module, library := NewLibrary(android.HostAndDeviceSupported)
242 library.HeaderOnly()
243 return module.Init()
244}
245
Colin Cross4d9c2d12016-07-29 12:48:20 -0700246type flagExporter struct {
247 Properties FlagExporterProperties
248
Jiyong Park74955042019-10-22 20:19:51 +0900249 dirs android.Paths
250 systemDirs android.Paths
Inseob Kim69378442019-06-03 19:10:47 +0900251 flags []string
252 deps android.Paths
Inseob Kimd110f872019-12-06 13:15:38 +0900253 headers android.Paths
Colin Cross4d9c2d12016-07-29 12:48:20 -0700254}
255
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700256func (f *flagExporter) exportedIncludes(ctx ModuleContext) android.Paths {
Steven Morelandb21df8f2018-01-05 14:42:54 -0800257 if ctx.useVndk() && f.Properties.Target.Vendor.Override_export_include_dirs != nil {
258 return android.PathsForModuleSrc(ctx, f.Properties.Target.Vendor.Override_export_include_dirs)
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700259 } else {
260 return android.PathsForModuleSrc(ctx, f.Properties.Export_include_dirs)
261 }
262}
263
Inseob Kim69378442019-06-03 19:10:47 +0900264func (f *flagExporter) exportIncludes(ctx ModuleContext) {
Jiyong Park74955042019-10-22 20:19:51 +0900265 f.dirs = append(f.dirs, f.exportedIncludes(ctx)...)
Jiyong Park73c54ee2019-10-22 20:31:18 +0900266 f.systemDirs = append(f.systemDirs, android.PathsForModuleSrc(ctx, f.Properties.Export_system_include_dirs)...)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700267}
268
Inseob Kim69378442019-06-03 19:10:47 +0900269func (f *flagExporter) exportIncludesAsSystem(ctx ModuleContext) {
Jiyong Park73c54ee2019-10-22 20:31:18 +0900270 // all dirs are force exported as system
Jiyong Park74955042019-10-22 20:19:51 +0900271 f.systemDirs = append(f.systemDirs, f.exportedIncludes(ctx)...)
Jiyong Park73c54ee2019-10-22 20:31:18 +0900272 f.systemDirs = append(f.systemDirs, android.PathsForModuleSrc(ctx, f.Properties.Export_system_include_dirs)...)
Inseob Kim69378442019-06-03 19:10:47 +0900273}
274
Jiyong Park74955042019-10-22 20:19:51 +0900275func (f *flagExporter) reexportDirs(dirs ...android.Path) {
Inseob Kim69378442019-06-03 19:10:47 +0900276 f.dirs = append(f.dirs, dirs...)
277}
278
Jiyong Park74955042019-10-22 20:19:51 +0900279func (f *flagExporter) reexportSystemDirs(dirs ...android.Path) {
Inseob Kim69378442019-06-03 19:10:47 +0900280 f.systemDirs = append(f.systemDirs, dirs...)
281}
282
283func (f *flagExporter) reexportFlags(flags ...string) {
Jaewoong Jung3aff5782020-02-11 07:54:35 -0800284 if android.PrefixInList(flags, "-I") || android.PrefixInList(flags, "-isystem") {
285 panic(fmt.Errorf("Exporting invalid flag %q: "+
286 "use reexportDirs or reexportSystemDirs to export directories", flag))
Inseob Kim69378442019-06-03 19:10:47 +0900287 }
Colin Cross4d9c2d12016-07-29 12:48:20 -0700288 f.flags = append(f.flags, flags...)
289}
290
Inseob Kim69378442019-06-03 19:10:47 +0900291func (f *flagExporter) reexportDeps(deps ...android.Path) {
292 f.deps = append(f.deps, deps...)
293}
294
Inseob Kimd110f872019-12-06 13:15:38 +0900295// addExportedGeneratedHeaders does nothing but collects generated header files.
296// This can be differ to exportedDeps which may contain phony files to minimize ninja.
297func (f *flagExporter) addExportedGeneratedHeaders(headers ...android.Path) {
298 f.headers = append(f.headers, headers...)
299}
300
Jiyong Park74955042019-10-22 20:19:51 +0900301func (f *flagExporter) exportedDirs() android.Paths {
Inseob Kim69378442019-06-03 19:10:47 +0900302 return f.dirs
303}
304
Jiyong Park74955042019-10-22 20:19:51 +0900305func (f *flagExporter) exportedSystemDirs() android.Paths {
Inseob Kim69378442019-06-03 19:10:47 +0900306 return f.systemDirs
Dan Willemsen847dcc72016-09-29 12:13:36 -0700307}
308
Colin Cross4d9c2d12016-07-29 12:48:20 -0700309func (f *flagExporter) exportedFlags() []string {
310 return f.flags
311}
312
Inseob Kim69378442019-06-03 19:10:47 +0900313func (f *flagExporter) exportedDeps() android.Paths {
314 return f.deps
Dan Willemsen847dcc72016-09-29 12:13:36 -0700315}
316
Inseob Kimd110f872019-12-06 13:15:38 +0900317func (f *flagExporter) exportedGeneratedHeaders() android.Paths {
318 return f.headers
319}
320
Colin Cross4d9c2d12016-07-29 12:48:20 -0700321type exportedFlagsProducer interface {
Jiyong Park74955042019-10-22 20:19:51 +0900322 exportedDirs() android.Paths
323 exportedSystemDirs() android.Paths
Colin Cross4d9c2d12016-07-29 12:48:20 -0700324 exportedFlags() []string
Inseob Kim69378442019-06-03 19:10:47 +0900325 exportedDeps() android.Paths
Inseob Kimd110f872019-12-06 13:15:38 +0900326 exportedGeneratedHeaders() android.Paths
Colin Cross4d9c2d12016-07-29 12:48:20 -0700327}
328
329var _ exportedFlagsProducer = (*flagExporter)(nil)
330
Colin Crossb916a382016-07-29 17:28:03 -0700331// libraryDecorator wraps baseCompiler, baseLinker and baseInstaller to provide library-specific
332// functionality: static vs. shared linkage, reusing object files for shared libraries
333type libraryDecorator struct {
Colin Crossa48ab5b2017-02-14 15:28:44 -0800334 Properties LibraryProperties
Colin Crosse1bb5d02019-09-24 14:55:04 -0700335 StaticProperties StaticProperties
336 SharedProperties SharedProperties
Colin Crossa48ab5b2017-02-14 15:28:44 -0800337 MutatedProperties LibraryMutatedProperties
Colin Cross4d9c2d12016-07-29 12:48:20 -0700338
339 // For reusing static library objects for shared library
Inseob Kim69378442019-06-03 19:10:47 +0900340 reuseObjects Objects
Colin Cross10d22312017-05-03 11:01:58 -0700341
Colin Cross26c34ed2016-09-30 17:10:16 -0700342 // table-of-contents file to optimize out relinking when possible
343 tocFile android.OptionalPath
Colin Cross4d9c2d12016-07-29 12:48:20 -0700344
Colin Cross4d9c2d12016-07-29 12:48:20 -0700345 flagExporter
346 stripper
347
Colin Cross4d9c2d12016-07-29 12:48:20 -0700348 // If we're used as a whole_static_lib, our missing dependencies need
349 // to be given
350 wholeStaticMissingDeps []string
351
352 // For whole_static_libs
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700353 objects Objects
Colin Cross4d9c2d12016-07-29 12:48:20 -0700354
355 // Uses the module's name if empty, but can be overridden. Does not include
356 // shlib suffix.
357 libName string
Colin Crossb916a382016-07-29 17:28:03 -0700358
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800359 sabi *sabi
360
Dan Willemsen581341d2017-02-09 16:16:31 -0800361 // Output archive of gcno coverage information files
362 coverageOutputFile android.OptionalPath
363
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800364 // linked Source Abi Dump
365 sAbiOutputFile android.OptionalPath
366
367 // Source Abi Diff
368 sAbiDiff android.OptionalPath
369
Colin Cross0875c522017-11-28 17:34:01 -0800370 // Location of the static library in the sysroot. Empty if the library is
371 // not included in the NDK.
372 ndkSysrootPath android.Path
373
Colin Crossb60190a2018-09-04 16:28:17 -0700374 // Location of the linked, unstripped library for shared libraries
375 unstrippedOutputFile android.Path
376
Dan Willemsen569edc52018-11-19 09:33:29 -0800377 // Location of the file that should be copied to dist dir when requested
378 distFile android.OptionalPath
379
Jiyong Park7ed9de32018-10-15 22:25:07 +0900380 versionScriptPath android.ModuleGenPath
381
Jiyong Parkf1194352019-02-25 11:05:47 +0900382 post_install_cmds []string
383
Vic Yangefd249e2018-11-12 20:19:56 -0800384 // If useCoreVariant is true, the vendor variant of a VNDK library is
385 // not installed.
Vic Yangd92090f2020-01-08 14:32:28 -0800386 useCoreVariant bool
387 checkSameCoreVariant bool
Vic Yangefd249e2018-11-12 20:19:56 -0800388
Colin Crossb916a382016-07-29 17:28:03 -0700389 // Decorated interafaces
390 *baseCompiler
391 *baseLinker
392 *baseInstaller
Colin Cross4d9c2d12016-07-29 12:48:20 -0700393}
394
Colin Crossb916a382016-07-29 17:28:03 -0700395func (library *libraryDecorator) linkerProps() []interface{} {
396 var props []interface{}
397 props = append(props, library.baseLinker.linkerProps()...)
Colin Crosse1bb5d02019-09-24 14:55:04 -0700398 props = append(props,
Colin Cross4d9c2d12016-07-29 12:48:20 -0700399 &library.Properties,
Colin Crossa48ab5b2017-02-14 15:28:44 -0800400 &library.MutatedProperties,
Colin Cross4d9c2d12016-07-29 12:48:20 -0700401 &library.flagExporter.Properties,
Colin Cross22f37952018-09-05 10:43:13 -0700402 &library.stripper.StripProperties)
Colin Crosse1bb5d02019-09-24 14:55:04 -0700403
404 if library.MutatedProperties.BuildShared {
405 props = append(props, &library.SharedProperties)
406 }
407 if library.MutatedProperties.BuildStatic {
408 props = append(props, &library.StaticProperties)
409 }
410
411 return props
Colin Cross4d9c2d12016-07-29 12:48:20 -0700412}
413
Colin Crossb916a382016-07-29 17:28:03 -0700414func (library *libraryDecorator) linkerFlags(ctx ModuleContext, flags Flags) Flags {
Colin Cross42742b82016-08-01 13:20:05 -0700415 flags = library.baseLinker.linkerFlags(ctx, flags)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700416
Colin Crossb916a382016-07-29 17:28:03 -0700417 // MinGW spits out warnings about -fPIC even for -fpie?!) being ignored because
418 // all code is position independent, and then those warnings get promoted to
419 // errors.
Colin Cross3edeee12017-04-04 12:59:48 -0700420 if !ctx.Windows() {
Colin Cross4af21ed2019-11-04 09:37:55 -0800421 flags.Global.CFlags = append(flags.Global.CFlags, "-fPIC")
Colin Crossb916a382016-07-29 17:28:03 -0700422 }
423
424 if library.static() {
Colin Cross4af21ed2019-11-04 09:37:55 -0800425 flags.Local.CFlags = append(flags.Local.CFlags, library.StaticProperties.Static.Cflags...)
Colin Crossa48ab5b2017-02-14 15:28:44 -0800426 } else if library.shared() {
Colin Cross4af21ed2019-11-04 09:37:55 -0800427 flags.Local.CFlags = append(flags.Local.CFlags, library.SharedProperties.Shared.Cflags...)
Colin Crossb916a382016-07-29 17:28:03 -0700428 }
429
Colin Crossa48ab5b2017-02-14 15:28:44 -0800430 if library.shared() {
Colin Cross4d9c2d12016-07-29 12:48:20 -0700431 libName := library.getLibName(ctx)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700432 var f []string
Dan Willemsen01a405a2016-06-13 17:19:03 -0700433 if ctx.toolchain().Bionic() {
Colin Cross4d9c2d12016-07-29 12:48:20 -0700434 f = append(f,
435 "-nostdlib",
436 "-Wl,--gc-sections",
437 )
438 }
439
440 if ctx.Darwin() {
441 f = append(f,
442 "-dynamiclib",
443 "-single_module",
Colin Cross4d9c2d12016-07-29 12:48:20 -0700444 "-install_name @rpath/"+libName+flags.Toolchain.ShlibSuffix(),
445 )
Colin Cross7863cf52016-10-20 10:47:21 -0700446 if ctx.Arch().ArchType == android.X86 {
447 f = append(f,
448 "-read_only_relocs suppress",
449 )
450 }
Colin Cross4d9c2d12016-07-29 12:48:20 -0700451 } else {
Josh Gao75a50a22019-06-07 17:58:59 -0700452 f = append(f, "-shared")
453 if !ctx.Windows() {
454 f = append(f, "-Wl,-soname,"+libName+flags.Toolchain.ShlibSuffix())
455 }
Colin Cross4d9c2d12016-07-29 12:48:20 -0700456 }
457
Colin Cross4af21ed2019-11-04 09:37:55 -0800458 flags.Global.LdFlags = append(flags.Global.LdFlags, f...)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700459 }
460
461 return flags
462}
463
Colin Crossf18e1102017-11-16 14:33:08 -0800464func (library *libraryDecorator) compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags {
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700465 exportIncludeDirs := library.flagExporter.exportedIncludes(ctx)
Dan Willemsen273af7f2016-11-03 15:53:42 -0700466 if len(exportIncludeDirs) > 0 {
Colin Crossdad8c952017-04-26 14:55:27 -0700467 f := includeDirsToFlags(exportIncludeDirs)
Colin Cross4af21ed2019-11-04 09:37:55 -0800468 flags.Local.CommonFlags = append(flags.Local.CommonFlags, f)
469 flags.Local.YasmFlags = append(flags.Local.YasmFlags, f)
Dan Willemsen273af7f2016-11-03 15:53:42 -0700470 }
471
Jiyong Park7ed9de32018-10-15 22:25:07 +0900472 flags = library.baseCompiler.compilerFlags(ctx, flags, deps)
473 if library.buildStubs() {
Jiyong Park64379952018-12-13 18:37:29 +0900474 // Remove -include <file> when compiling stubs. Otherwise, the force included
475 // headers might cause conflicting types error with the symbols in the
476 // generated stubs source code. e.g.
477 // double acos(double); // in header
478 // void acos() {} // in the generated source code
479 removeInclude := func(flags []string) []string {
480 ret := flags[:0]
481 for _, f := range flags {
482 if strings.HasPrefix(f, "-include ") {
483 continue
484 }
485 ret = append(ret, f)
486 }
487 return ret
488 }
Colin Cross4af21ed2019-11-04 09:37:55 -0800489 flags.Local.CommonFlags = removeInclude(flags.Local.CommonFlags)
490 flags.Local.CFlags = removeInclude(flags.Local.CFlags)
Jiyong Park64379952018-12-13 18:37:29 +0900491
Jiyong Park7ed9de32018-10-15 22:25:07 +0900492 flags = addStubLibraryCompilerFlags(flags)
493 }
494 return flags
Dan Willemsen273af7f2016-11-03 15:53:42 -0700495}
496
Hsin-Yi Chen53489642019-07-31 17:10:45 +0800497// Returns a string that represents the class of the ABI dump.
498// Returns an empty string if ABI check is disabled for this library.
499func (library *libraryDecorator) classifySourceAbiDump(ctx ModuleContext) string {
500 enabled := library.Properties.Header_abi_checker.Enabled
501 if enabled != nil && !Bool(enabled) {
502 return ""
503 }
504 // Return NDK if the library is both NDK and LLNDK.
505 if ctx.isNdk() {
506 return "NDK"
507 }
508 if ctx.isLlndkPublic(ctx.Config()) {
509 return "LLNDK"
510 }
511 if ctx.useVndk() && ctx.isVndk() && !ctx.isVndkPrivate(ctx.Config()) {
512 if ctx.isVndkSp() {
513 if ctx.isVndkExt() {
514 return "VNDK-SP-ext"
515 } else {
516 return "VNDK-SP"
517 }
518 } else {
519 if ctx.isVndkExt() {
520 return "VNDK-ext"
521 } else {
522 return "VNDK-core"
523 }
524 }
525 }
Jiyong Parka034b832019-08-27 14:02:19 +0900526 if Bool(enabled) || ctx.hasStubsVariants() {
Hsin-Yi Chen53489642019-07-31 17:10:45 +0800527 return "PLATFORM"
528 }
529 return ""
530}
531
Hsin-Yi Chenaf17d742019-07-29 17:46:59 +0800532func (library *libraryDecorator) shouldCreateSourceAbiDump(ctx ModuleContext) bool {
533 if !ctx.shouldCreateSourceAbiDump() {
534 return false
535 }
Logan Chiene274fc92019-12-03 11:18:32 -0800536 if !ctx.isForPlatform() {
537 if !ctx.hasStubsVariants() {
538 // Skip ABI checks if this library is for APEX but isn't exported.
539 return false
540 }
541 if !Bool(library.Properties.Header_abi_checker.Enabled) {
542 // Skip ABI checks if this library is for APEX and did not explicitly enable
543 // ABI checks.
544 // TODO(b/145608479): ABI checks should be enabled by default. Remove this
545 // after evaluating the extra build time.
546 return false
547 }
548 }
Hsin-Yi Chen53489642019-07-31 17:10:45 +0800549 return library.classifySourceAbiDump(ctx) != ""
Logan Chien41eabe62019-04-10 13:33:58 +0800550}
551
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700552func (library *libraryDecorator) compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects {
Jiyong Park7ed9de32018-10-15 22:25:07 +0900553 if library.buildStubs() {
Jiyong Park3fd0baf2018-12-07 16:25:39 +0900554 objs, versionScript := compileStubLibrary(ctx, flags, String(library.Properties.Stubs.Symbol_file), library.MutatedProperties.StubsVersion, "--apex")
Jiyong Park7ed9de32018-10-15 22:25:07 +0900555 library.versionScriptPath = versionScript
556 return objs
557 }
558
Colin Cross5950f382016-12-13 12:50:57 -0800559 if !library.buildShared() && !library.buildStatic() {
560 if len(library.baseCompiler.Properties.Srcs) > 0 {
561 ctx.PropertyErrorf("srcs", "cc_library_headers must not have any srcs")
562 }
Colin Crosse1bb5d02019-09-24 14:55:04 -0700563 if len(library.StaticProperties.Static.Srcs) > 0 {
Colin Cross5950f382016-12-13 12:50:57 -0800564 ctx.PropertyErrorf("static.srcs", "cc_library_headers must not have any srcs")
565 }
Colin Crosse1bb5d02019-09-24 14:55:04 -0700566 if len(library.SharedProperties.Shared.Srcs) > 0 {
Colin Cross5950f382016-12-13 12:50:57 -0800567 ctx.PropertyErrorf("shared.srcs", "cc_library_headers must not have any srcs")
568 }
569 return Objects{}
570 }
Hsin-Yi Chenaf17d742019-07-29 17:46:59 +0800571 if library.shouldCreateSourceAbiDump(ctx) || library.sabi.Properties.CreateSAbiDumps {
Jayant Chowdharya4fce192017-09-06 13:10:03 -0700572 exportIncludeDirs := library.flagExporter.exportedIncludes(ctx)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800573 var SourceAbiFlags []string
574 for _, dir := range exportIncludeDirs.Strings() {
Jayant Chowdhary715cac32017-04-20 06:53:59 -0700575 SourceAbiFlags = append(SourceAbiFlags, "-I"+dir)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800576 }
Inseob Kim69378442019-06-03 19:10:47 +0900577 for _, reexportedInclude := range library.sabi.Properties.ReexportedIncludes {
578 SourceAbiFlags = append(SourceAbiFlags, "-I"+reexportedInclude)
Jayant Chowdhary715cac32017-04-20 06:53:59 -0700579 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800580 flags.SAbiFlags = SourceAbiFlags
Colin Crosse1bb5d02019-09-24 14:55:04 -0700581 total_length := len(library.baseCompiler.Properties.Srcs) + len(deps.GeneratedSources) +
582 len(library.SharedProperties.Shared.Srcs) + len(library.StaticProperties.Static.Srcs)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800583 if total_length > 0 {
584 flags.SAbiDump = true
585 }
586 }
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700587 objs := library.baseCompiler.compile(ctx, flags, deps)
588 library.reuseObjects = objs
Colin Cross2f336352016-10-26 10:03:47 -0700589 buildFlags := flagsToBuilderFlags(flags)
Colin Crossb916a382016-07-29 17:28:03 -0700590
Colin Cross4d9c2d12016-07-29 12:48:20 -0700591 if library.static() {
Colin Crosse1bb5d02019-09-24 14:55:04 -0700592 srcs := android.PathsForModuleSrc(ctx, library.StaticProperties.Static.Srcs)
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700593 objs = objs.Append(compileObjs(ctx, buildFlags, android.DeviceStaticLibrary,
Pirama Arumuga Nainarf231b192018-01-23 10:49:04 -0800594 srcs, library.baseCompiler.pathDeps, library.baseCompiler.cFlagsDeps))
Colin Crossa48ab5b2017-02-14 15:28:44 -0800595 } else if library.shared() {
Colin Crosse1bb5d02019-09-24 14:55:04 -0700596 srcs := android.PathsForModuleSrc(ctx, library.SharedProperties.Shared.Srcs)
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700597 objs = objs.Append(compileObjs(ctx, buildFlags, android.DeviceSharedLibrary,
Pirama Arumuga Nainarf231b192018-01-23 10:49:04 -0800598 srcs, library.baseCompiler.pathDeps, library.baseCompiler.cFlagsDeps))
Colin Crossb916a382016-07-29 17:28:03 -0700599 }
600
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700601 return objs
Colin Crossb916a382016-07-29 17:28:03 -0700602}
603
604type libraryInterface interface {
605 getWholeStaticMissingDeps() []string
606 static() bool
Inseob Kimae553032019-05-14 18:52:49 +0900607 shared() bool
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700608 objs() Objects
Inseob Kim69378442019-06-03 19:10:47 +0900609 reuseObjs() (Objects, exportedFlagsProducer)
Colin Cross26c34ed2016-09-30 17:10:16 -0700610 toc() android.OptionalPath
Colin Crossb916a382016-07-29 17:28:03 -0700611
612 // Returns true if the build options for the module have selected a static or shared build
613 buildStatic() bool
614 buildShared() bool
615
616 // Sets whether a specific variant is static or shared
Colin Crossa48ab5b2017-02-14 15:28:44 -0800617 setStatic()
618 setShared()
Logan Chien41eabe62019-04-10 13:33:58 +0800619
620 // Write LOCAL_ADDITIONAL_DEPENDENCIES for ABI diff
621 androidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer)
Jiyong Parka90ca002019-10-07 15:47:24 +0900622
623 availableFor(string) bool
Colin Crossb916a382016-07-29 17:28:03 -0700624}
625
Jooyung Han0302a842019-10-30 18:43:49 +0900626func (library *libraryDecorator) getLibNameHelper(baseModuleName string, useVndk bool) string {
Colin Crossb916a382016-07-29 17:28:03 -0700627 name := library.libName
628 if name == "" {
dimitryd95964a2018-11-07 13:43:34 +0100629 name = String(library.Properties.Stem)
630 if name == "" {
Jooyung Han0302a842019-10-30 18:43:49 +0900631 name = baseModuleName
dimitryd95964a2018-11-07 13:43:34 +0100632 }
Colin Crossb916a382016-07-29 17:28:03 -0700633 }
634
Colin Cross0fd6a412019-08-16 14:22:10 -0700635 suffix := ""
Jooyung Han0302a842019-10-30 18:43:49 +0900636 if useVndk {
Colin Cross0fd6a412019-08-16 14:22:10 -0700637 suffix = String(library.Properties.Target.Vendor.Suffix)
638 }
639 if suffix == "" {
640 suffix = String(library.Properties.Suffix)
641 }
642
Jooyung Han0302a842019-10-30 18:43:49 +0900643 return name + suffix
644}
645
646func (library *libraryDecorator) getLibName(ctx BaseModuleContext) string {
647 name := library.getLibNameHelper(ctx.baseModuleName(), ctx.useVndk())
Colin Cross0fd6a412019-08-16 14:22:10 -0700648
Logan Chienf3511742017-10-31 18:04:35 +0800649 if ctx.isVndkExt() {
Jooyung Han4c2b9422019-10-22 19:53:47 +0900650 // vndk-ext lib should have the same name with original lib
651 ctx.VisitDirectDepsWithTag(vndkExtDepTag, func(module android.Module) {
652 originalName := module.(*Module).outputFile.Path()
653 name = strings.TrimSuffix(originalName.Base(), originalName.Ext())
654 })
Logan Chienf3511742017-10-31 18:04:35 +0800655 }
656
Colin Crossb916a382016-07-29 17:28:03 -0700657 if ctx.Host() && Bool(library.Properties.Unique_host_soname) {
658 if !strings.HasSuffix(name, "-host") {
659 name = name + "-host"
660 }
661 }
662
Inseob Kim0ce291e2019-07-04 14:38:27 +0900663 return name
Colin Crossb916a382016-07-29 17:28:03 -0700664}
665
Jiyong Parkda732bd2018-11-02 18:23:15 +0900666var versioningMacroNamesListMutex sync.Mutex
667
Colin Crossb916a382016-07-29 17:28:03 -0700668func (library *libraryDecorator) linkerInit(ctx BaseModuleContext) {
669 location := InstallInSystem
Dan Albert61f32122018-07-26 14:00:24 -0700670 if library.baseLinker.sanitize.inSanitizerDir() {
Vishwath Mohan1dd88392017-03-29 22:00:18 -0700671 location = InstallInSanitizerDir
Colin Crossb916a382016-07-29 17:28:03 -0700672 }
673 library.baseInstaller.location = location
Colin Crossb916a382016-07-29 17:28:03 -0700674 library.baseLinker.linkerInit(ctx)
Jiyong Park7ed9de32018-10-15 22:25:07 +0900675 // Let baseLinker know whether this variant is for stubs or not, so that
676 // it can omit things that are not required for linking stubs.
677 library.baseLinker.dynamicProperties.BuildStubs = library.buildStubs()
Jiyong Parkda732bd2018-11-02 18:23:15 +0900678
679 if library.buildStubs() {
680 macroNames := versioningMacroNamesList(ctx.Config())
681 myName := versioningMacroName(ctx.ModuleName())
682 versioningMacroNamesListMutex.Lock()
683 defer versioningMacroNamesListMutex.Unlock()
684 if (*macroNames)[myName] == "" {
685 (*macroNames)[myName] = ctx.ModuleName()
686 } else if (*macroNames)[myName] != ctx.ModuleName() {
687 ctx.ModuleErrorf("Macro name %q for versioning conflicts with macro name from module %q ", myName, (*macroNames)[myName])
688 }
689 }
Colin Crossb916a382016-07-29 17:28:03 -0700690}
691
dimitry0345ad82018-12-05 16:28:14 +0100692func (library *libraryDecorator) compilerDeps(ctx DepsContext, deps Deps) Deps {
693 deps = library.baseCompiler.compilerDeps(ctx, deps)
694
dimitry0345ad82018-12-05 16:28:14 +0100695 return deps
696}
697
Colin Cross37047f12016-12-13 17:06:13 -0800698func (library *libraryDecorator) linkerDeps(ctx DepsContext, deps Deps) Deps {
Dan Willemsen3a26eef2018-12-03 15:25:46 -0800699 if library.static() {
Colin Crosse1bb5d02019-09-24 14:55:04 -0700700 if library.StaticProperties.Static.System_shared_libs != nil {
701 library.baseLinker.Properties.System_shared_libs = library.StaticProperties.Static.System_shared_libs
Dan Willemsen3a26eef2018-12-03 15:25:46 -0800702 }
703 } else if library.shared() {
Colin Crosse1bb5d02019-09-24 14:55:04 -0700704 if library.SharedProperties.Shared.System_shared_libs != nil {
705 library.baseLinker.Properties.System_shared_libs = library.SharedProperties.Shared.System_shared_libs
Dan Willemsen3a26eef2018-12-03 15:25:46 -0800706 }
707 }
708
Colin Crossb916a382016-07-29 17:28:03 -0700709 deps = library.baseLinker.linkerDeps(ctx, deps)
710
711 if library.static() {
712 deps.WholeStaticLibs = append(deps.WholeStaticLibs,
Colin Crosse1bb5d02019-09-24 14:55:04 -0700713 library.StaticProperties.Static.Whole_static_libs...)
714 deps.StaticLibs = append(deps.StaticLibs, library.StaticProperties.Static.Static_libs...)
715 deps.SharedLibs = append(deps.SharedLibs, library.StaticProperties.Static.Shared_libs...)
Colin Crosseefe9a32019-01-22 14:41:08 -0800716
Colin Crosse1bb5d02019-09-24 14:55:04 -0700717 deps.ReexportSharedLibHeaders = append(deps.ReexportSharedLibHeaders, library.StaticProperties.Static.Export_shared_lib_headers...)
718 deps.ReexportStaticLibHeaders = append(deps.ReexportStaticLibHeaders, library.StaticProperties.Static.Export_static_lib_headers...)
Colin Crossa48ab5b2017-02-14 15:28:44 -0800719 } else if library.shared() {
Dan Willemsen2e47b342016-11-17 01:02:25 -0800720 if ctx.toolchain().Bionic() && !Bool(library.baseLinker.Properties.Nocrt) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700721 if !ctx.useSdk() {
Colin Cross4d9c2d12016-07-29 12:48:20 -0700722 deps.CrtBegin = "crtbegin_so"
723 deps.CrtEnd = "crtend_so"
724 } else {
Dan Albertebedf672016-11-08 15:06:22 -0800725 // TODO(danalbert): Add generation of crt objects.
726 // For `sdk_version: "current"`, we don't actually have a
727 // freshly generated set of CRT objects. Use the last stable
728 // version.
729 version := ctx.sdkVersion()
730 if version == "current" {
Jayant Chowdhary6e8115a2017-05-09 10:21:52 -0700731 version = getCurrentNdkPrebuiltVersion(ctx)
Dan Albertebedf672016-11-08 15:06:22 -0800732 }
733 deps.CrtBegin = "ndk_crtbegin_so." + version
734 deps.CrtEnd = "ndk_crtend_so." + version
Colin Cross4d9c2d12016-07-29 12:48:20 -0700735 }
736 }
Colin Crosse1bb5d02019-09-24 14:55:04 -0700737 deps.WholeStaticLibs = append(deps.WholeStaticLibs, library.SharedProperties.Shared.Whole_static_libs...)
738 deps.StaticLibs = append(deps.StaticLibs, library.SharedProperties.Shared.Static_libs...)
739 deps.SharedLibs = append(deps.SharedLibs, library.SharedProperties.Shared.Shared_libs...)
Colin Crosseefe9a32019-01-22 14:41:08 -0800740
Colin Crosse1bb5d02019-09-24 14:55:04 -0700741 deps.ReexportSharedLibHeaders = append(deps.ReexportSharedLibHeaders, library.SharedProperties.Shared.Export_shared_lib_headers...)
742 deps.ReexportStaticLibHeaders = append(deps.ReexportStaticLibHeaders, library.SharedProperties.Shared.Export_static_lib_headers...)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700743 }
Jiyong Park52d25bd2017-10-13 09:17:01 +0900744 if ctx.useVndk() {
745 deps.WholeStaticLibs = removeListFromList(deps.WholeStaticLibs, library.baseLinker.Properties.Target.Vendor.Exclude_static_libs)
746 deps.SharedLibs = removeListFromList(deps.SharedLibs, library.baseLinker.Properties.Target.Vendor.Exclude_shared_libs)
747 deps.StaticLibs = removeListFromList(deps.StaticLibs, library.baseLinker.Properties.Target.Vendor.Exclude_static_libs)
Victor Chang51271c12019-01-30 16:02:22 +0000748 deps.ReexportSharedLibHeaders = removeListFromList(deps.ReexportSharedLibHeaders, library.baseLinker.Properties.Target.Vendor.Exclude_shared_libs)
749 deps.ReexportStaticLibHeaders = removeListFromList(deps.ReexportStaticLibHeaders, library.baseLinker.Properties.Target.Vendor.Exclude_static_libs)
Jiyong Park52d25bd2017-10-13 09:17:01 +0900750 }
Jiyong Parkf9332f12018-02-01 00:54:12 +0900751 if ctx.inRecovery() {
752 deps.WholeStaticLibs = removeListFromList(deps.WholeStaticLibs, library.baseLinker.Properties.Target.Recovery.Exclude_static_libs)
753 deps.SharedLibs = removeListFromList(deps.SharedLibs, library.baseLinker.Properties.Target.Recovery.Exclude_shared_libs)
754 deps.StaticLibs = removeListFromList(deps.StaticLibs, library.baseLinker.Properties.Target.Recovery.Exclude_static_libs)
Victor Chang51271c12019-01-30 16:02:22 +0000755 deps.ReexportSharedLibHeaders = removeListFromList(deps.ReexportSharedLibHeaders, library.baseLinker.Properties.Target.Recovery.Exclude_shared_libs)
756 deps.ReexportStaticLibHeaders = removeListFromList(deps.ReexportStaticLibHeaders, library.baseLinker.Properties.Target.Recovery.Exclude_static_libs)
Jiyong Parkf9332f12018-02-01 00:54:12 +0900757 }
Yifan Hongcf4832c2020-01-21 17:04:13 -0800758 if ctx.inRamdisk() {
759 deps.WholeStaticLibs = removeListFromList(deps.WholeStaticLibs, library.baseLinker.Properties.Target.Ramdisk.Exclude_static_libs)
760 deps.SharedLibs = removeListFromList(deps.SharedLibs, library.baseLinker.Properties.Target.Ramdisk.Exclude_shared_libs)
761 deps.StaticLibs = removeListFromList(deps.StaticLibs, library.baseLinker.Properties.Target.Ramdisk.Exclude_static_libs)
762 deps.ReexportSharedLibHeaders = removeListFromList(deps.ReexportSharedLibHeaders, library.baseLinker.Properties.Target.Ramdisk.Exclude_shared_libs)
763 deps.ReexportStaticLibHeaders = removeListFromList(deps.ReexportStaticLibHeaders, library.baseLinker.Properties.Target.Ramdisk.Exclude_static_libs)
764 }
Colin Cross2383f3b2018-02-06 14:40:13 -0800765
Colin Cross4d9c2d12016-07-29 12:48:20 -0700766 return deps
767}
768
Colin Crossb916a382016-07-29 17:28:03 -0700769func (library *libraryDecorator) linkStatic(ctx ModuleContext,
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700770 flags Flags, deps PathDeps, objs Objects) android.Path {
Colin Cross4d9c2d12016-07-29 12:48:20 -0700771
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700772 library.objects = deps.WholeStaticLibObjs.Copy()
773 library.objects = library.objects.Append(objs)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700774
Inseob Kim0ce291e2019-07-04 14:38:27 +0900775 fileName := ctx.ModuleName() + staticLibraryExtension
Colin Cross86803cf2018-02-15 14:12:26 -0800776 outputFile := android.PathForModuleOut(ctx, fileName)
Dan Willemsen581341d2017-02-09 16:16:31 -0800777 builderFlags := flagsToBuilderFlags(flags)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700778
Dan Willemsen569edc52018-11-19 09:33:29 -0800779 if Bool(library.baseLinker.Properties.Use_version_lib) {
780 if ctx.Host() {
781 versionedOutputFile := outputFile
782 outputFile = android.PathForModuleOut(ctx, "unversioned", fileName)
783 library.injectVersionSymbol(ctx, outputFile, versionedOutputFile)
784 } else {
785 versionedOutputFile := android.PathForModuleOut(ctx, "versioned", fileName)
786 library.distFile = android.OptionalPathForPath(versionedOutputFile)
787 library.injectVersionSymbol(ctx, outputFile, versionedOutputFile)
788 }
Colin Cross86803cf2018-02-15 14:12:26 -0800789 }
790
Dan Willemsen581341d2017-02-09 16:16:31 -0800791 TransformObjToStaticLib(ctx, library.objects.objFiles, builderFlags, outputFile, objs.tidyFiles)
792
Inseob Kim0ce291e2019-07-04 14:38:27 +0900793 library.coverageOutputFile = TransformCoverageFilesToZip(ctx, library.objects, ctx.ModuleName())
Colin Cross4d9c2d12016-07-29 12:48:20 -0700794
795 library.wholeStaticMissingDeps = ctx.GetMissingDependencies()
796
797 ctx.CheckbuildFile(outputFile)
798
799 return outputFile
800}
801
Colin Crossb916a382016-07-29 17:28:03 -0700802func (library *libraryDecorator) linkShared(ctx ModuleContext,
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700803 flags Flags, deps PathDeps, objs Objects) android.Path {
Colin Cross4d9c2d12016-07-29 12:48:20 -0700804
805 var linkerDeps android.Paths
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700806 linkerDeps = append(linkerDeps, flags.LdFlagsDeps...)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700807
Colin Cross2383f3b2018-02-06 14:40:13 -0800808 unexportedSymbols := ctx.ExpandOptionalSource(library.Properties.Unexported_symbols_list, "unexported_symbols_list")
809 forceNotWeakSymbols := ctx.ExpandOptionalSource(library.Properties.Force_symbols_not_weak_list, "force_symbols_not_weak_list")
810 forceWeakSymbols := ctx.ExpandOptionalSource(library.Properties.Force_symbols_weak_list, "force_symbols_weak_list")
Colin Cross4d9c2d12016-07-29 12:48:20 -0700811 if !ctx.Darwin() {
Colin Cross4d9c2d12016-07-29 12:48:20 -0700812 if unexportedSymbols.Valid() {
813 ctx.PropertyErrorf("unexported_symbols_list", "Only supported on Darwin")
814 }
815 if forceNotWeakSymbols.Valid() {
816 ctx.PropertyErrorf("force_symbols_not_weak_list", "Only supported on Darwin")
817 }
818 if forceWeakSymbols.Valid() {
819 ctx.PropertyErrorf("force_symbols_weak_list", "Only supported on Darwin")
820 }
821 } else {
Colin Cross4d9c2d12016-07-29 12:48:20 -0700822 if unexportedSymbols.Valid() {
Colin Cross4af21ed2019-11-04 09:37:55 -0800823 flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,-unexported_symbols_list,"+unexportedSymbols.String())
Colin Cross4d9c2d12016-07-29 12:48:20 -0700824 linkerDeps = append(linkerDeps, unexportedSymbols.Path())
825 }
826 if forceNotWeakSymbols.Valid() {
Colin Cross4af21ed2019-11-04 09:37:55 -0800827 flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,-force_symbols_not_weak_list,"+forceNotWeakSymbols.String())
Colin Cross4d9c2d12016-07-29 12:48:20 -0700828 linkerDeps = append(linkerDeps, forceNotWeakSymbols.Path())
829 }
830 if forceWeakSymbols.Valid() {
Colin Cross4af21ed2019-11-04 09:37:55 -0800831 flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,-force_symbols_weak_list,"+forceWeakSymbols.String())
Colin Cross4d9c2d12016-07-29 12:48:20 -0700832 linkerDeps = append(linkerDeps, forceWeakSymbols.Path())
833 }
834 }
Jiyong Parkc1e7f482019-01-12 13:39:10 +0900835 if library.buildStubs() {
836 linkerScriptFlags := "-Wl,--version-script," + library.versionScriptPath.String()
Colin Cross4af21ed2019-11-04 09:37:55 -0800837 flags.Local.LdFlags = append(flags.Local.LdFlags, linkerScriptFlags)
Jiyong Parkc1e7f482019-01-12 13:39:10 +0900838 linkerDeps = append(linkerDeps, library.versionScriptPath)
839 }
Colin Cross4d9c2d12016-07-29 12:48:20 -0700840
841 fileName := library.getLibName(ctx) + flags.Toolchain.ShlibSuffix()
842 outputFile := android.PathForModuleOut(ctx, fileName)
843 ret := outputFile
844
Josh Gao75a50a22019-06-07 17:58:59 -0700845 var implicitOutputs android.WritablePaths
846 if ctx.Windows() {
847 importLibraryPath := android.PathForModuleOut(ctx, pathtools.ReplaceExtension(fileName, "lib"))
848
Colin Cross4af21ed2019-11-04 09:37:55 -0800849 flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,--out-implib="+importLibraryPath.String())
Josh Gao75a50a22019-06-07 17:58:59 -0700850 implicitOutputs = append(implicitOutputs, importLibraryPath)
851 }
852
Colin Cross4d9c2d12016-07-29 12:48:20 -0700853 builderFlags := flagsToBuilderFlags(flags)
854
Colin Crossb496cfd2018-09-10 16:50:05 -0700855 // Optimize out relinking against shared libraries whose interface hasn't changed by
856 // depending on a table of contents file instead of the library itself.
Colin Cross70dda7e2019-10-01 22:05:35 -0700857 tocFile := outputFile.ReplaceExtension(ctx, flags.Toolchain.ShlibSuffix()[1:]+".toc")
Colin Crossb496cfd2018-09-10 16:50:05 -0700858 library.tocFile = android.OptionalPathForPath(tocFile)
859 TransformSharedObjectToToc(ctx, outputFile, tocFile, builderFlags)
Colin Cross89562dc2016-10-03 17:47:19 -0700860
Colin Cross4d9c2d12016-07-29 12:48:20 -0700861 if library.stripper.needsStrip(ctx) {
Yi Kongb5c34d72018-11-07 16:28:49 -0800862 if ctx.Darwin() {
863 builderFlags.stripUseGnuStrip = true
864 }
Colin Cross4d9c2d12016-07-29 12:48:20 -0700865 strippedOutputFile := outputFile
866 outputFile = android.PathForModuleOut(ctx, "unstripped", fileName)
Ryan Prichardf979d732019-05-30 20:53:29 -0700867 library.stripper.stripExecutableOrSharedLib(ctx, outputFile, strippedOutputFile, builderFlags)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700868 }
Colin Crossb60190a2018-09-04 16:28:17 -0700869 library.unstrippedOutputFile = outputFile
870
Colin Crossd7227f92019-09-05 14:26:33 -0700871 outputFile = maybeInjectBoringSSLHash(ctx, outputFile, library.Properties.Inject_bssl_hash, fileName)
Pete Bentley803e1612019-08-06 22:19:59 +0100872
Dan Willemsen569edc52018-11-19 09:33:29 -0800873 if Bool(library.baseLinker.Properties.Use_version_lib) {
874 if ctx.Host() {
875 versionedOutputFile := outputFile
876 outputFile = android.PathForModuleOut(ctx, "unversioned", fileName)
877 library.injectVersionSymbol(ctx, outputFile, versionedOutputFile)
878 } else {
879 versionedOutputFile := android.PathForModuleOut(ctx, "versioned", fileName)
880 library.distFile = android.OptionalPathForPath(versionedOutputFile)
881
882 if library.stripper.needsStrip(ctx) {
883 out := android.PathForModuleOut(ctx, "versioned-stripped", fileName)
884 library.distFile = android.OptionalPathForPath(out)
Ryan Prichardf979d732019-05-30 20:53:29 -0700885 library.stripper.stripExecutableOrSharedLib(ctx, versionedOutputFile, out, builderFlags)
Dan Willemsen569edc52018-11-19 09:33:29 -0800886 }
887
888 library.injectVersionSymbol(ctx, outputFile, versionedOutputFile)
889 }
Colin Cross86803cf2018-02-15 14:12:26 -0800890 }
891
Jiyong Park64a44f22019-01-18 14:37:08 +0900892 sharedLibs := deps.EarlySharedLibs
893 sharedLibs = append(sharedLibs, deps.SharedLibs...)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700894 sharedLibs = append(sharedLibs, deps.LateSharedLibs...)
895
Jiyong Park64a44f22019-01-18 14:37:08 +0900896 linkerDeps = append(linkerDeps, deps.EarlySharedLibsDeps...)
Colin Cross26c34ed2016-09-30 17:10:16 -0700897 linkerDeps = append(linkerDeps, deps.SharedLibsDeps...)
898 linkerDeps = append(linkerDeps, deps.LateSharedLibsDeps...)
Dan Willemsena03cf6d2016-09-26 15:45:04 -0700899 linkerDeps = append(linkerDeps, objs.tidyFiles...)
Colin Cross26c34ed2016-09-30 17:10:16 -0700900
Vic Yang6cd1be82019-06-24 16:08:48 -0700901 if Bool(library.Properties.Sort_bss_symbols_by_size) {
902 unsortedOutputFile := android.PathForModuleOut(ctx, "unsorted", fileName)
903 TransformObjToDynamicBinary(ctx, objs.objFiles, sharedLibs,
904 deps.StaticLibs, deps.LateStaticLibs, deps.WholeStaticLibs,
905 linkerDeps, deps.CrtBegin, deps.CrtEnd, false, builderFlags, unsortedOutputFile, implicitOutputs)
906
907 symbolOrderingFile := android.PathForModuleOut(ctx, "unsorted", fileName+".symbol_order")
908 symbolOrderingFlag := library.baseLinker.sortBssSymbolsBySize(ctx, unsortedOutputFile, symbolOrderingFile, builderFlags)
Colin Cross6d88dba2019-11-06 07:06:58 -0800909 builderFlags.localLdFlags += " " + symbolOrderingFlag
Vic Yang6cd1be82019-06-24 16:08:48 -0700910 linkerDeps = append(linkerDeps, symbolOrderingFile)
911 }
912
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700913 TransformObjToDynamicBinary(ctx, objs.objFiles, sharedLibs,
Colin Cross4d9c2d12016-07-29 12:48:20 -0700914 deps.StaticLibs, deps.LateStaticLibs, deps.WholeStaticLibs,
Josh Gao75a50a22019-06-07 17:58:59 -0700915 linkerDeps, deps.CrtBegin, deps.CrtEnd, false, builderFlags, outputFile, implicitOutputs)
Colin Cross4d9c2d12016-07-29 12:48:20 -0700916
Dan Willemsen581341d2017-02-09 16:16:31 -0800917 objs.coverageFiles = append(objs.coverageFiles, deps.StaticLibObjs.coverageFiles...)
918 objs.coverageFiles = append(objs.coverageFiles, deps.WholeStaticLibObjs.coverageFiles...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800919
920 objs.sAbiDumpFiles = append(objs.sAbiDumpFiles, deps.StaticLibObjs.sAbiDumpFiles...)
921 objs.sAbiDumpFiles = append(objs.sAbiDumpFiles, deps.WholeStaticLibObjs.sAbiDumpFiles...)
922
Oliver Nguyenc7434142019-04-24 14:22:25 -0700923 library.coverageOutputFile = TransformCoverageFilesToZip(ctx, objs, library.getLibName(ctx))
Jayant Chowdhary6ab3d842017-06-26 12:52:58 -0700924 library.linkSAbiDumpFiles(ctx, objs, fileName, ret)
Dan Willemsen581341d2017-02-09 16:16:31 -0800925
Colin Cross4d9c2d12016-07-29 12:48:20 -0700926 return ret
927}
928
Jiyong Parkaf6d8952019-01-31 12:21:23 +0900929func (library *libraryDecorator) unstrippedOutputFilePath() android.Path {
930 return library.unstrippedOutputFile
931}
932
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700933func (library *libraryDecorator) nativeCoverage() bool {
934 if library.header() || library.buildStubs() {
935 return false
936 }
937 return true
938}
939
Jiyong Parkee9a98d2019-08-09 14:44:36 +0900940func (library *libraryDecorator) coverageOutputFilePath() android.OptionalPath {
941 return library.coverageOutputFile
942}
943
Logan Chien7eefdc42018-07-11 18:10:41 +0800944func getRefAbiDumpFile(ctx ModuleContext, vndkVersion, fileName string) android.Path {
Hsin-Yi Chen53489642019-07-31 17:10:45 +0800945 isNdk := ctx.isNdk()
946 isLlndkOrVndk := ctx.isLlndkPublic(ctx.Config()) || ctx.isVndk()
Logan Chien7eefdc42018-07-11 18:10:41 +0800947
Hsin-Yi Chen53489642019-07-31 17:10:45 +0800948 refAbiDumpTextFile := android.PathForVndkRefAbiDump(ctx, vndkVersion, fileName, isNdk, isLlndkOrVndk, false)
949 refAbiDumpGzipFile := android.PathForVndkRefAbiDump(ctx, vndkVersion, fileName, isNdk, isLlndkOrVndk, true)
Logan Chien7eefdc42018-07-11 18:10:41 +0800950
951 if refAbiDumpTextFile.Valid() {
952 if refAbiDumpGzipFile.Valid() {
953 ctx.ModuleErrorf(
954 "Two reference ABI dump files are found: %q and %q. Please delete the stale one.",
955 refAbiDumpTextFile, refAbiDumpGzipFile)
956 return nil
957 }
958 return refAbiDumpTextFile.Path()
959 }
960 if refAbiDumpGzipFile.Valid() {
961 return UnzipRefDump(ctx, refAbiDumpGzipFile.Path(), fileName)
962 }
963 return nil
964}
965
Jayant Chowdhary6ab3d842017-06-26 12:52:58 -0700966func (library *libraryDecorator) linkSAbiDumpFiles(ctx ModuleContext, objs Objects, fileName string, soFile android.Path) {
Hsin-Yi Chenaf17d742019-07-29 17:46:59 +0800967 if library.shouldCreateSourceAbiDump(ctx) {
Logan Chiena8f51582018-03-21 11:53:48 +0800968 vndkVersion := ctx.DeviceConfig().PlatformVndkVersion()
969 if ver := ctx.DeviceConfig().VndkVersion(); ver != "" && ver != "current" {
Logan Chienf3511742017-10-31 18:04:35 +0800970 vndkVersion = ver
971 }
972
Jayant Chowdharya4fce192017-09-06 13:10:03 -0700973 exportIncludeDirs := library.flagExporter.exportedIncludes(ctx)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800974 var SourceAbiFlags []string
975 for _, dir := range exportIncludeDirs.Strings() {
Jayant Chowdhary715cac32017-04-20 06:53:59 -0700976 SourceAbiFlags = append(SourceAbiFlags, "-I"+dir)
977 }
Inseob Kim69378442019-06-03 19:10:47 +0900978 for _, reexportedInclude := range library.sabi.Properties.ReexportedIncludes {
979 SourceAbiFlags = append(SourceAbiFlags, "-I"+reexportedInclude)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800980 }
981 exportedHeaderFlags := strings.Join(SourceAbiFlags, " ")
Logan Chiene3d7a0d2019-01-17 00:18:02 +0800982 library.sAbiOutputFile = TransformDumpToLinkedDump(ctx, objs.sAbiDumpFiles, soFile, fileName, exportedHeaderFlags,
Jiyong Parka034b832019-08-27 14:02:19 +0900983 android.OptionalPathForModuleSrc(ctx, library.symbolFileForAbiCheck(ctx)),
Logan Chiene3d7a0d2019-01-17 00:18:02 +0800984 library.Properties.Header_abi_checker.Exclude_symbol_versions,
985 library.Properties.Header_abi_checker.Exclude_symbol_tags)
Logan Chien2f2b8902018-07-10 15:01:19 +0800986
Hsin-Yi Chen53489642019-07-31 17:10:45 +0800987 addLsdumpPath(library.classifySourceAbiDump(ctx) + ":" + library.sAbiOutputFile.String())
988
Logan Chien7eefdc42018-07-11 18:10:41 +0800989 refAbiDumpFile := getRefAbiDumpFile(ctx, vndkVersion, fileName)
990 if refAbiDumpFile != nil {
Logan Chienf3511742017-10-31 18:04:35 +0800991 library.sAbiDiff = SourceAbiDiff(ctx, library.sAbiOutputFile.Path(),
Inseob Kim9516ee92019-05-09 10:56:13 +0900992 refAbiDumpFile, fileName, exportedHeaderFlags, ctx.isLlndk(ctx.Config()), ctx.isNdk(), ctx.isVndkExt())
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800993 }
994 }
995}
996
Colin Crossb916a382016-07-29 17:28:03 -0700997func (library *libraryDecorator) link(ctx ModuleContext,
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700998 flags Flags, deps PathDeps, objs Objects) android.Path {
Colin Cross4d9c2d12016-07-29 12:48:20 -0700999
Colin Crossad59e752017-11-16 14:29:11 -08001000 objs = deps.Objs.Copy().Append(objs)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001001 var out android.Path
Colin Crossa48ab5b2017-02-14 15:28:44 -08001002 if library.static() || library.header() {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001003 out = library.linkStatic(ctx, flags, deps, objs)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001004 } else {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001005 out = library.linkShared(ctx, flags, deps, objs)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001006 }
1007
Inseob Kim69378442019-06-03 19:10:47 +09001008 library.exportIncludes(ctx)
1009 library.reexportDirs(deps.ReexportedDirs...)
1010 library.reexportSystemDirs(deps.ReexportedSystemDirs...)
1011 library.reexportFlags(deps.ReexportedFlags...)
1012 library.reexportDeps(deps.ReexportedDeps...)
Inseob Kimd110f872019-12-06 13:15:38 +09001013 library.addExportedGeneratedHeaders(deps.ReexportedGeneratedHeaders...)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001014
Nan Zhang0007d812017-11-07 10:57:05 -08001015 if Bool(library.Properties.Aidl.Export_aidl_headers) {
Dan Willemsene1240db2016-11-03 14:28:51 -07001016 if library.baseCompiler.hasSrcExt(".aidl") {
Jiyong Park74955042019-10-22 20:19:51 +09001017 dir := android.PathForModuleGen(ctx, "aidl")
Inseob Kim69378442019-06-03 19:10:47 +09001018 library.reexportDirs(dir)
Inseob Kimd110f872019-12-06 13:15:38 +09001019
1020 // TODO: restrict to aidl deps
1021 library.reexportDeps(library.baseCompiler.pathDeps...)
1022 library.addExportedGeneratedHeaders(library.baseCompiler.pathDeps...)
Dan Willemsene1240db2016-11-03 14:28:51 -07001023 }
1024 }
1025
Nan Zhang0007d812017-11-07 10:57:05 -08001026 if Bool(library.Properties.Proto.Export_proto_headers) {
Dan Willemsene1240db2016-11-03 14:28:51 -07001027 if library.baseCompiler.hasSrcExt(".proto") {
Jiyong Park74955042019-10-22 20:19:51 +09001028 var includes android.Paths
Colin Cross19878da2019-03-28 14:45:07 -07001029 if flags.proto.CanonicalPathFromRoot {
Jiyong Park74955042019-10-22 20:19:51 +09001030 includes = append(includes, flags.proto.SubDir)
Colin Cross10d22312017-05-03 11:01:58 -07001031 }
Jiyong Park74955042019-10-22 20:19:51 +09001032 includes = append(includes, flags.proto.Dir)
Inseob Kim69378442019-06-03 19:10:47 +09001033 library.reexportDirs(includes...)
Inseob Kimd110f872019-12-06 13:15:38 +09001034
1035 // TODO: restrict to proto deps
1036 library.reexportDeps(library.baseCompiler.pathDeps...)
1037 library.addExportedGeneratedHeaders(library.baseCompiler.pathDeps...)
Colin Cross0c461f12016-10-20 16:11:43 -07001038 }
1039 }
1040
Inseob Kim21f26902018-09-06 00:55:20 +09001041 if library.baseCompiler.hasSrcExt(".sysprop") {
Jiyong Park74955042019-10-22 20:19:51 +09001042 dir := android.PathForModuleGen(ctx, "sysprop", "include")
Inseob Kimc0907f12019-02-08 21:00:45 +09001043 if library.Properties.Sysprop.Platform != nil {
1044 isProduct := ctx.ProductSpecific() && !ctx.useVndk()
1045 isVendor := ctx.useVndk()
1046 isOwnerPlatform := Bool(library.Properties.Sysprop.Platform)
1047
Yifan Hong1b3348d2020-01-21 15:53:22 -08001048 if !ctx.inRamdisk() && !ctx.inRecovery() && (isProduct || (isOwnerPlatform == isVendor)) {
Jiyong Park74955042019-10-22 20:19:51 +09001049 dir = android.PathForModuleGen(ctx, "sysprop/public", "include")
Inseob Kimc0907f12019-02-08 21:00:45 +09001050 }
1051 }
1052
Inseob Kim69378442019-06-03 19:10:47 +09001053 library.reexportDirs(dir)
1054 library.reexportDeps(library.baseCompiler.pathDeps...)
Inseob Kimd110f872019-12-06 13:15:38 +09001055 library.addExportedGeneratedHeaders(library.baseCompiler.pathDeps...)
Inseob Kim21f26902018-09-06 00:55:20 +09001056 }
1057
Jiyong Parkda732bd2018-11-02 18:23:15 +09001058 if library.buildStubs() {
Inseob Kim69378442019-06-03 19:10:47 +09001059 library.reexportFlags("-D" + versioningMacroName(ctx.ModuleName()) + "=" + library.stubsVersion())
Jiyong Parkda732bd2018-11-02 18:23:15 +09001060 }
1061
Colin Cross4d9c2d12016-07-29 12:48:20 -07001062 return out
1063}
1064
Colin Crossb916a382016-07-29 17:28:03 -07001065func (library *libraryDecorator) buildStatic() bool {
Colin Crosse1bb5d02019-09-24 14:55:04 -07001066 return library.MutatedProperties.BuildStatic &&
1067 BoolDefault(library.StaticProperties.Static.Enabled, true)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001068}
1069
Colin Crossb916a382016-07-29 17:28:03 -07001070func (library *libraryDecorator) buildShared() bool {
Colin Crosse1bb5d02019-09-24 14:55:04 -07001071 return library.MutatedProperties.BuildShared &&
1072 BoolDefault(library.SharedProperties.Shared.Enabled, true)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001073}
1074
Colin Crossb916a382016-07-29 17:28:03 -07001075func (library *libraryDecorator) getWholeStaticMissingDeps() []string {
Colin Crossd2343a32018-04-30 14:50:01 -07001076 return append([]string(nil), library.wholeStaticMissingDeps...)
Colin Cross4d9c2d12016-07-29 12:48:20 -07001077}
1078
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001079func (library *libraryDecorator) objs() Objects {
1080 return library.objects
Colin Cross4d9c2d12016-07-29 12:48:20 -07001081}
1082
Inseob Kim69378442019-06-03 19:10:47 +09001083func (library *libraryDecorator) reuseObjs() (Objects, exportedFlagsProducer) {
1084 return library.reuseObjects, &library.flagExporter
Colin Cross4d9c2d12016-07-29 12:48:20 -07001085}
1086
Colin Cross26c34ed2016-09-30 17:10:16 -07001087func (library *libraryDecorator) toc() android.OptionalPath {
1088 return library.tocFile
1089}
1090
Jiyong Parkf1194352019-02-25 11:05:47 +09001091func (library *libraryDecorator) installSymlinkToRuntimeApex(ctx ModuleContext, file android.Path) {
1092 dir := library.baseInstaller.installDir(ctx)
1093 dirOnDevice := android.InstallPathToOnDevicePath(ctx, dir)
1094 target := "/" + filepath.Join("apex", "com.android.runtime", dir.Base(), "bionic", file.Base())
1095 ctx.InstallAbsoluteSymlink(dir, file.Base(), target)
1096 library.post_install_cmds = append(library.post_install_cmds, makeSymlinkCmd(dirOnDevice, file.Base(), target))
1097}
1098
Colin Crossb916a382016-07-29 17:28:03 -07001099func (library *libraryDecorator) install(ctx ModuleContext, file android.Path) {
Colin Crossc43ae772017-04-14 15:42:53 -07001100 if library.shared() {
Justin Yun8fe12122017-12-07 17:18:15 +09001101 if ctx.Device() && ctx.useVndk() {
1102 if ctx.isVndkSp() {
1103 library.baseInstaller.subDir = "vndk-sp"
1104 } else if ctx.isVndk() {
Vic Yang1a5812a2020-01-31 10:38:40 -08001105 mayUseCoreVariant := true
1106
1107 if ctx.mustUseVendorVariant() {
1108 mayUseCoreVariant = false
1109 }
1110
1111 if ctx.isVndkExt() {
1112 mayUseCoreVariant = false
1113 }
1114
1115 if ctx.Config().CFIEnabledForPath(ctx.ModuleDir()) && ctx.Arch().ArchType == android.Arm64 {
1116 mayUseCoreVariant = false
1117 }
1118
1119 if mayUseCoreVariant {
Vic Yangd92090f2020-01-08 14:32:28 -08001120 library.checkSameCoreVariant = true
1121 if ctx.DeviceConfig().VndkUseCoreVariant() {
1122 library.useCoreVariant = true
1123 }
Vic Yangefd249e2018-11-12 20:19:56 -08001124 }
Justin Yun8fe12122017-12-07 17:18:15 +09001125 library.baseInstaller.subDir = "vndk"
1126 }
Logan Chienf3511742017-10-31 18:04:35 +08001127
1128 // Append a version to vndk or vndk-sp directories on the system partition.
1129 if ctx.isVndk() && !ctx.isVndkExt() {
1130 vndkVersion := ctx.DeviceConfig().PlatformVndkVersion()
1131 if vndkVersion != "current" && vndkVersion != "" {
1132 library.baseInstaller.subDir += "-" + vndkVersion
1133 }
Justin Yun8effde42017-06-23 19:24:43 +09001134 }
Peter Collingbourne49a25cb2019-05-21 16:06:09 -07001135 } else if len(library.Properties.Stubs.Versions) > 0 && android.DirectlyInAnyApex(ctx, ctx.ModuleName()) {
Jiyong Parkf1194352019-02-25 11:05:47 +09001136 // Bionic libraries (e.g. libc.so) is installed to the bootstrap subdirectory.
1137 // The original path becomes a symlink to the corresponding file in the
1138 // runtime APEX.
Colin Cross3b19f5d2019-09-17 14:45:31 -07001139 translatedArch := ctx.Target().NativeBridge == android.NativeBridgeEnabled
Yifan Hong1b3348d2020-01-21 15:53:22 -08001140 if InstallToBootstrap(ctx.baseModuleName(), ctx.Config()) && !library.buildStubs() && !translatedArch && !ctx.inRamdisk() && !ctx.inRecovery() {
Martin Stjernholm279de572019-09-10 23:18:20 +01001141 if ctx.Device() {
Jiyong Parkc3e2c862019-03-16 01:10:08 +09001142 library.installSymlinkToRuntimeApex(ctx, file)
1143 }
Jiyong Park429660f2019-01-16 22:31:11 +09001144 library.baseInstaller.subDir = "bootstrap"
1145 }
Przemyslaw Szczepaniake6fc5072019-07-12 14:06:23 +01001146 } else if android.DirectlyInAnyApex(ctx, ctx.ModuleName()) && ctx.isLlndk(ctx.Config()) && !isBionic(ctx.baseModuleName()) {
1147 // Skip installing LLNDK (non-bionic) libraries moved to APEX.
1148 ctx.Module().SkipInstall()
Justin Yun8effde42017-06-23 19:24:43 +09001149 }
Przemyslaw Szczepaniake6fc5072019-07-12 14:06:23 +01001150
Colin Cross4d9c2d12016-07-29 12:48:20 -07001151 library.baseInstaller.install(ctx, file)
1152 }
Dan Albertf563d252017-10-13 00:29:00 -07001153
Dan Albert281f22b2017-12-13 15:03:47 -08001154 if Bool(library.Properties.Static_ndk_lib) && library.static() &&
Yifan Hong1b3348d2020-01-21 15:53:22 -08001155 !ctx.useVndk() && !ctx.inRamdisk() && !ctx.inRecovery() && ctx.Device() &&
Jiyong Park7ed9de32018-10-15 22:25:07 +09001156 library.baseLinker.sanitize.isUnsanitizedVariant() &&
1157 !library.buildStubs() {
Dan Albertf563d252017-10-13 00:29:00 -07001158 installPath := getNdkSysrootBase(ctx).Join(
Dan Albertea4b7b92018-04-25 16:05:30 -07001159 ctx, "usr/lib", config.NDKTriple(ctx.toolchain()), file.Base())
Dan Albertf563d252017-10-13 00:29:00 -07001160
1161 ctx.ModuleBuild(pctx, android.ModuleBuildParams{
1162 Rule: android.Cp,
1163 Description: "install " + installPath.Base(),
1164 Output: installPath,
1165 Input: file,
1166 })
1167
Colin Cross0875c522017-11-28 17:34:01 -08001168 library.ndkSysrootPath = installPath
Dan Albertf563d252017-10-13 00:29:00 -07001169 }
Colin Cross4d9c2d12016-07-29 12:48:20 -07001170}
1171
Colin Crossb916a382016-07-29 17:28:03 -07001172func (library *libraryDecorator) static() bool {
Colin Crossa48ab5b2017-02-14 15:28:44 -08001173 return library.MutatedProperties.VariantIsStatic
Colin Cross4d9c2d12016-07-29 12:48:20 -07001174}
1175
Colin Crossa48ab5b2017-02-14 15:28:44 -08001176func (library *libraryDecorator) shared() bool {
1177 return library.MutatedProperties.VariantIsShared
1178}
1179
1180func (library *libraryDecorator) header() bool {
1181 return !library.static() && !library.shared()
1182}
1183
1184func (library *libraryDecorator) setStatic() {
1185 library.MutatedProperties.VariantIsStatic = true
1186 library.MutatedProperties.VariantIsShared = false
1187}
1188
1189func (library *libraryDecorator) setShared() {
1190 library.MutatedProperties.VariantIsStatic = false
1191 library.MutatedProperties.VariantIsShared = true
Colin Crossb916a382016-07-29 17:28:03 -07001192}
1193
Colin Crossab3b7322016-12-09 14:46:15 -08001194func (library *libraryDecorator) BuildOnlyStatic() {
Colin Crossa48ab5b2017-02-14 15:28:44 -08001195 library.MutatedProperties.BuildShared = false
Colin Crossab3b7322016-12-09 14:46:15 -08001196}
1197
1198func (library *libraryDecorator) BuildOnlyShared() {
Colin Crossa48ab5b2017-02-14 15:28:44 -08001199 library.MutatedProperties.BuildStatic = false
Colin Crossab3b7322016-12-09 14:46:15 -08001200}
1201
Colin Cross5950f382016-12-13 12:50:57 -08001202func (library *libraryDecorator) HeaderOnly() {
Colin Crossa48ab5b2017-02-14 15:28:44 -08001203 library.MutatedProperties.BuildShared = false
1204 library.MutatedProperties.BuildStatic = false
Colin Cross5950f382016-12-13 12:50:57 -08001205}
1206
Jiyong Park7ed9de32018-10-15 22:25:07 +09001207func (library *libraryDecorator) buildStubs() bool {
1208 return library.MutatedProperties.BuildStubs
1209}
1210
Jiyong Parka034b832019-08-27 14:02:19 +09001211func (library *libraryDecorator) symbolFileForAbiCheck(ctx ModuleContext) *string {
1212 if library.Properties.Header_abi_checker.Symbol_file != nil {
1213 return library.Properties.Header_abi_checker.Symbol_file
1214 }
1215 if ctx.hasStubsVariants() && library.Properties.Stubs.Symbol_file != nil {
1216 return library.Properties.Stubs.Symbol_file
1217 }
1218 return nil
1219}
1220
Jiyong Park7ed9de32018-10-15 22:25:07 +09001221func (library *libraryDecorator) stubsVersion() string {
1222 return library.MutatedProperties.StubsVersion
1223}
1224
Jiyong Parka90ca002019-10-07 15:47:24 +09001225func (library *libraryDecorator) availableFor(what string) bool {
1226 var list []string
1227 if library.static() {
1228 list = library.StaticProperties.Static.Apex_available
1229 } else if library.shared() {
1230 list = library.SharedProperties.Shared.Apex_available
1231 }
1232 if len(list) == 0 {
1233 return false
1234 }
1235 return android.CheckAvailableForApex(what, list)
1236}
1237
Colin Cross571cccf2019-02-04 11:22:08 -08001238var versioningMacroNamesListKey = android.NewOnceKey("versioningMacroNamesList")
1239
Jiyong Parkda732bd2018-11-02 18:23:15 +09001240func versioningMacroNamesList(config android.Config) *map[string]string {
Colin Cross571cccf2019-02-04 11:22:08 -08001241 return config.Once(versioningMacroNamesListKey, func() interface{} {
Jiyong Parkda732bd2018-11-02 18:23:15 +09001242 m := make(map[string]string)
1243 return &m
1244 }).(*map[string]string)
1245}
1246
1247// alphanumeric and _ characters are preserved.
1248// other characters are all converted to _
1249var charsNotForMacro = regexp.MustCompile("[^a-zA-Z0-9_]+")
1250
1251func versioningMacroName(moduleName string) string {
1252 macroName := charsNotForMacro.ReplaceAllString(moduleName, "_")
1253 macroName = strings.ToUpper(moduleName)
1254 return "__" + macroName + "_API__"
1255}
1256
Colin Crossab3b7322016-12-09 14:46:15 -08001257func NewLibrary(hod android.HostOrDeviceSupported) (*Module, *libraryDecorator) {
Colin Cross4d9c2d12016-07-29 12:48:20 -07001258 module := newModule(hod, android.MultilibBoth)
1259
Colin Crossb916a382016-07-29 17:28:03 -07001260 library := &libraryDecorator{
Colin Crossa48ab5b2017-02-14 15:28:44 -08001261 MutatedProperties: LibraryMutatedProperties{
Colin Crossab3b7322016-12-09 14:46:15 -08001262 BuildShared: true,
1263 BuildStatic: true,
Colin Cross4d9c2d12016-07-29 12:48:20 -07001264 },
Colin Crossb916a382016-07-29 17:28:03 -07001265 baseCompiler: NewBaseCompiler(),
Dan Albert61f32122018-07-26 14:00:24 -07001266 baseLinker: NewBaseLinker(module.sanitize),
Colin Crossb916a382016-07-29 17:28:03 -07001267 baseInstaller: NewBaseInstaller("lib", "lib64", InstallInSystem),
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001268 sabi: module.sabi,
Colin Cross4d9c2d12016-07-29 12:48:20 -07001269 }
1270
Colin Crossb916a382016-07-29 17:28:03 -07001271 module.compiler = library
1272 module.linker = library
1273 module.installer = library
1274
1275 return module, library
1276}
1277
Colin Cross10d22312017-05-03 11:01:58 -07001278// connects a shared library to a static library in order to reuse its .o files to avoid
1279// compiling source files twice.
1280func reuseStaticLibrary(mctx android.BottomUpMutatorContext, static, shared *Module) {
1281 if staticCompiler, ok := static.compiler.(*libraryDecorator); ok {
1282 sharedCompiler := shared.compiler.(*libraryDecorator)
Dan Willemsen3a26eef2018-12-03 15:25:46 -08001283
1284 // Check libraries in addition to cflags, since libraries may be exporting different
1285 // include directories.
Colin Crosse1bb5d02019-09-24 14:55:04 -07001286 if len(staticCompiler.StaticProperties.Static.Cflags) == 0 &&
1287 len(sharedCompiler.SharedProperties.Shared.Cflags) == 0 &&
1288 len(staticCompiler.StaticProperties.Static.Whole_static_libs) == 0 &&
1289 len(sharedCompiler.SharedProperties.Shared.Whole_static_libs) == 0 &&
1290 len(staticCompiler.StaticProperties.Static.Static_libs) == 0 &&
1291 len(sharedCompiler.SharedProperties.Shared.Static_libs) == 0 &&
1292 len(staticCompiler.StaticProperties.Static.Shared_libs) == 0 &&
1293 len(sharedCompiler.SharedProperties.Shared.Shared_libs) == 0 &&
1294 staticCompiler.StaticProperties.Static.System_shared_libs == nil &&
1295 sharedCompiler.SharedProperties.Shared.System_shared_libs == nil {
Colin Cross10d22312017-05-03 11:01:58 -07001296
1297 mctx.AddInterVariantDependency(reuseObjTag, shared, static)
1298 sharedCompiler.baseCompiler.Properties.OriginalSrcs =
1299 sharedCompiler.baseCompiler.Properties.Srcs
1300 sharedCompiler.baseCompiler.Properties.Srcs = nil
1301 sharedCompiler.baseCompiler.Properties.Generated_sources = nil
Jiyong Parke4bb9862019-02-01 00:31:10 +09001302 } else {
1303 // This dep is just to reference static variant from shared variant
1304 mctx.AddInterVariantDependency(staticVariantTag, shared, static)
Colin Cross10d22312017-05-03 11:01:58 -07001305 }
1306 }
1307}
1308
Colin Crosse40b4ea2018-10-02 22:25:58 -07001309func LinkageMutator(mctx android.BottomUpMutatorContext) {
Ivan Lozano52767be2019-10-18 14:49:46 -07001310 cc_prebuilt := false
Colin Crossb916a382016-07-29 17:28:03 -07001311 if m, ok := mctx.Module().(*Module); ok && m.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001312 _, cc_prebuilt = m.linker.(prebuiltLibraryInterface)
1313 }
1314 if cc_prebuilt {
1315 library := mctx.Module().(*Module).linker.(prebuiltLibraryInterface)
Colin Cross33b2fb72019-05-14 14:07:01 -07001316
Ivan Lozano52767be2019-10-18 14:49:46 -07001317 // Always create both the static and shared variants for prebuilt libraries, and then disable the one
1318 // that is not being used. This allows them to share the name of a cc_library module, which requires that
1319 // all the variants of the cc_library also exist on the prebuilt.
1320 modules := mctx.CreateLocalVariations("static", "shared")
1321 static := modules[0].(*Module)
1322 shared := modules[1].(*Module)
Colin Cross33b2fb72019-05-14 14:07:01 -07001323
Ivan Lozano52767be2019-10-18 14:49:46 -07001324 static.linker.(prebuiltLibraryInterface).setStatic()
1325 shared.linker.(prebuiltLibraryInterface).setShared()
Colin Cross33b2fb72019-05-14 14:07:01 -07001326
Ivan Lozano52767be2019-10-18 14:49:46 -07001327 if !library.buildStatic() {
1328 static.linker.(prebuiltLibraryInterface).disablePrebuilt()
Colin Crossb916a382016-07-29 17:28:03 -07001329 }
Ivan Lozano52767be2019-10-18 14:49:46 -07001330 if !library.buildShared() {
1331 shared.linker.(prebuiltLibraryInterface).disablePrebuilt()
1332 }
1333 } else if library, ok := mctx.Module().(LinkableInterface); ok && library.CcLibraryInterface() {
Ivan Lozano52767be2019-10-18 14:49:46 -07001334
Ivan Lozano2b262972019-11-21 12:30:50 -08001335 // Non-cc.Modules may need an empty variant for their mutators.
1336 variations := []string{}
1337 if library.NonCcVariants() {
1338 variations = append(variations, "")
1339 }
1340
1341 if library.BuildStaticVariant() && library.BuildSharedVariant() {
1342 variations := append([]string{"static", "shared"}, variations...)
Ivan Lozano52767be2019-10-18 14:49:46 -07001343
1344 modules := mctx.CreateLocalVariations(variations...)
1345 static := modules[0].(LinkableInterface)
1346 shared := modules[1].(LinkableInterface)
1347
1348 static.SetStatic()
1349 shared.SetShared()
1350
1351 if _, ok := library.(*Module); ok {
1352 reuseStaticLibrary(mctx, static.(*Module), shared.(*Module))
1353 }
1354 } else if library.BuildStaticVariant() {
Ivan Lozano2b262972019-11-21 12:30:50 -08001355 variations := append([]string{"static"}, variations...)
1356
1357 modules := mctx.CreateLocalVariations(variations...)
Ivan Lozano52767be2019-10-18 14:49:46 -07001358 modules[0].(LinkableInterface).SetStatic()
1359 } else if library.BuildSharedVariant() {
Ivan Lozano2b262972019-11-21 12:30:50 -08001360 variations := append([]string{"shared"}, variations...)
Ivan Lozano52767be2019-10-18 14:49:46 -07001361
Ivan Lozano2b262972019-11-21 12:30:50 -08001362 modules := mctx.CreateLocalVariations(variations...)
1363 modules[0].(LinkableInterface).SetShared()
1364 } else if len(variations) > 0 {
1365 mctx.CreateLocalVariations(variations...)
1366 }
Colin Crossb916a382016-07-29 17:28:03 -07001367 }
Colin Cross4d9c2d12016-07-29 12:48:20 -07001368}
Jiyong Park7ed9de32018-10-15 22:25:07 +09001369
Colin Cross571cccf2019-02-04 11:22:08 -08001370var stubVersionsKey = android.NewOnceKey("stubVersions")
1371
Jiyong Park25fc6a92018-11-18 18:02:45 +09001372// maps a module name to the list of stubs versions available for the module
1373func stubsVersionsFor(config android.Config) map[string][]string {
Colin Cross571cccf2019-02-04 11:22:08 -08001374 return config.Once(stubVersionsKey, func() interface{} {
Jiyong Park25fc6a92018-11-18 18:02:45 +09001375 return make(map[string][]string)
1376 }).(map[string][]string)
1377}
1378
1379var stubsVersionsLock sync.Mutex
1380
Jiyong Park73c54ee2019-10-22 20:31:18 +09001381func LatestStubsVersionFor(config android.Config, name string) string {
Jiyong Park25fc6a92018-11-18 18:02:45 +09001382 versions, ok := stubsVersionsFor(config)[name]
1383 if ok && len(versions) > 0 {
1384 // the versions are alreay sorted in ascending order
1385 return versions[len(versions)-1]
1386 }
1387 return ""
1388}
1389
Jiyong Park7ed9de32018-10-15 22:25:07 +09001390// Version mutator splits a module into the mandatory non-stubs variant
Jiyong Park25fc6a92018-11-18 18:02:45 +09001391// (which is unnamed) and zero or more stubs variants.
1392func VersionMutator(mctx android.BottomUpMutatorContext) {
Ivan Lozano52767be2019-10-18 14:49:46 -07001393 if library, ok := mctx.Module().(LinkableInterface); ok && !library.InRecovery() {
1394 if library.CcLibrary() && library.BuildSharedVariant() && len(library.StubsVersions()) > 0 {
Jiyong Park25fc6a92018-11-18 18:02:45 +09001395 versions := []string{}
Ivan Lozano52767be2019-10-18 14:49:46 -07001396 for _, v := range library.StubsVersions() {
Jiyong Park25fc6a92018-11-18 18:02:45 +09001397 if _, err := strconv.Atoi(v); err != nil {
1398 mctx.PropertyErrorf("versions", "%q is not a number", v)
1399 }
Jiyong Park7ed9de32018-10-15 22:25:07 +09001400 versions = append(versions, v)
1401 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09001402 sort.Slice(versions, func(i, j int) bool {
1403 left, _ := strconv.Atoi(versions[i])
1404 right, _ := strconv.Atoi(versions[j])
1405 return left < right
1406 })
1407
1408 // save the list of versions for later use
1409 copiedVersions := make([]string, len(versions))
1410 copy(copiedVersions, versions)
1411 stubsVersionsLock.Lock()
1412 defer stubsVersionsLock.Unlock()
1413 stubsVersionsFor(mctx.Config())[mctx.ModuleName()] = copiedVersions
1414
1415 // "" is for the non-stubs variant
Jiyong Park67883b32019-01-03 21:35:58 +09001416 versions = append([]string{""}, versions...)
Jiyong Park25fc6a92018-11-18 18:02:45 +09001417
Jiyong Park7ed9de32018-10-15 22:25:07 +09001418 modules := mctx.CreateVariations(versions...)
1419 for i, m := range modules {
Jiyong Park25fc6a92018-11-18 18:02:45 +09001420 if versions[i] != "" {
Ivan Lozano52767be2019-10-18 14:49:46 -07001421 m.(LinkableInterface).SetBuildStubs()
1422 m.(LinkableInterface).SetStubsVersions(versions[i])
Jiyong Park7ed9de32018-10-15 22:25:07 +09001423 }
Jiyong Park7ed9de32018-10-15 22:25:07 +09001424 }
1425 } else {
1426 mctx.CreateVariations("")
1427 }
1428 return
1429 }
1430 if genrule, ok := mctx.Module().(*genrule.Module); ok {
Colin Cross7228ecd2019-11-18 16:00:16 -08001431 if _, ok := genrule.Extra.(*GenruleExtraProperties); ok {
1432 if !genrule.InRecovery() {
1433 mctx.CreateVariations("")
1434 return
1435 }
Jiyong Park7ed9de32018-10-15 22:25:07 +09001436 }
1437 }
1438}
Colin Crossd7227f92019-09-05 14:26:33 -07001439
1440// maybeInjectBoringSSLHash adds a rule to run bssl_inject_hash on the output file if the module has the
1441// inject_bssl_hash or if any static library dependencies have inject_bssl_hash set. It returns the output path
1442// that the linked output file should be written to.
1443// TODO(b/137267623): Remove this in favor of a cc_genrule when they support operating on shared libraries.
1444func maybeInjectBoringSSLHash(ctx android.ModuleContext, outputFile android.ModuleOutPath,
1445 inject *bool, fileName string) android.ModuleOutPath {
1446 // TODO(b/137267623): Remove this in favor of a cc_genrule when they support operating on shared libraries.
1447 injectBoringSSLHash := Bool(inject)
1448 ctx.VisitDirectDeps(func(dep android.Module) {
1449 tag := ctx.OtherModuleDependencyTag(dep)
Ivan Lozano183a3212019-10-18 14:18:45 -07001450 if tag == StaticDepTag || tag == staticExportDepTag || tag == wholeStaticDepTag || tag == lateStaticDepTag {
Colin Crossd7227f92019-09-05 14:26:33 -07001451 if cc, ok := dep.(*Module); ok {
1452 if library, ok := cc.linker.(*libraryDecorator); ok {
1453 if Bool(library.Properties.Inject_bssl_hash) {
1454 injectBoringSSLHash = true
1455 }
1456 }
1457 }
1458 }
1459 })
1460 if injectBoringSSLHash {
1461 hashedOutputfile := outputFile
1462 outputFile = android.PathForModuleOut(ctx, "unhashed", fileName)
1463
1464 rule := android.NewRuleBuilder()
1465 rule.Command().
1466 BuiltTool(ctx, "bssl_inject_hash").
Pete Bentley5c4be822019-10-01 17:03:17 +01001467 Flag("-sha256").
Colin Crossd7227f92019-09-05 14:26:33 -07001468 FlagWithInput("-in-object ", outputFile).
1469 FlagWithOutput("-o ", hashedOutputfile)
1470 rule.Build(pctx, ctx, "injectCryptoHash", "inject crypto hash")
1471 }
1472
1473 return outputFile
1474}