blob: 4ff65723c67ea4b9f385bc7ff30b02aaf1e11327 [file] [log] [blame]
Colin Cross5049f022015-03-18 13:28:46 -07001// Copyright 2015 Google Inc. All rights reserved.
Colin Cross3f40fa42015-01-30 17:27:36 -08002//
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
17// This file contains the module types for compiling C/C++ for Android, and converts the properties
18// into the flags and filenames necessary to pass to the compiler. The final creation of the rules
19// is handled in builder.go
20
21import (
Colin Cross3f40fa42015-01-30 17:27:36 -080022 "fmt"
23 "path/filepath"
24 "strings"
25
Colin Cross97ba0732015-03-23 17:50:24 -070026 "github.com/google/blueprint"
Colin Cross06a931b2015-10-28 17:23:31 -070027 "github.com/google/blueprint/proptools"
Colin Cross97ba0732015-03-23 17:50:24 -070028
Colin Cross463a90e2015-06-17 14:20:06 -070029 "android/soong"
Colin Cross635c3b02016-05-18 15:37:25 -070030 "android/soong/android"
Colin Cross5049f022015-03-18 13:28:46 -070031 "android/soong/genrule"
Colin Cross3f40fa42015-01-30 17:27:36 -080032)
33
Colin Cross463a90e2015-06-17 14:20:06 -070034func init() {
Colin Crossca860ac2016-01-04 14:34:37 -080035 soong.RegisterModuleType("cc_library_static", libraryStaticFactory)
36 soong.RegisterModuleType("cc_library_shared", librarySharedFactory)
37 soong.RegisterModuleType("cc_library", libraryFactory)
38 soong.RegisterModuleType("cc_object", objectFactory)
39 soong.RegisterModuleType("cc_binary", binaryFactory)
40 soong.RegisterModuleType("cc_test", testFactory)
Colin Crossc7a38dc2016-07-12 13:13:09 -070041 soong.RegisterModuleType("cc_test_library", testLibraryFactory)
Colin Crossca860ac2016-01-04 14:34:37 -080042 soong.RegisterModuleType("cc_benchmark", benchmarkFactory)
43 soong.RegisterModuleType("cc_defaults", defaultsFactory)
Colin Cross463a90e2015-06-17 14:20:06 -070044
Colin Crossca860ac2016-01-04 14:34:37 -080045 soong.RegisterModuleType("toolchain_library", toolchainLibraryFactory)
46 soong.RegisterModuleType("ndk_prebuilt_library", ndkPrebuiltLibraryFactory)
47 soong.RegisterModuleType("ndk_prebuilt_object", ndkPrebuiltObjectFactory)
48 soong.RegisterModuleType("ndk_prebuilt_static_stl", ndkPrebuiltStaticStlFactory)
49 soong.RegisterModuleType("ndk_prebuilt_shared_stl", ndkPrebuiltSharedStlFactory)
Colin Cross463a90e2015-06-17 14:20:06 -070050
Colin Crossca860ac2016-01-04 14:34:37 -080051 soong.RegisterModuleType("cc_library_host_static", libraryHostStaticFactory)
52 soong.RegisterModuleType("cc_library_host_shared", libraryHostSharedFactory)
53 soong.RegisterModuleType("cc_binary_host", binaryHostFactory)
54 soong.RegisterModuleType("cc_test_host", testHostFactory)
55 soong.RegisterModuleType("cc_benchmark_host", benchmarkHostFactory)
Colin Cross463a90e2015-06-17 14:20:06 -070056
57 // LinkageMutator must be registered after common.ArchMutator, but that is guaranteed by
58 // the Go initialization order because this package depends on common, so common's init
59 // functions will run first.
Colin Cross635c3b02016-05-18 15:37:25 -070060 android.RegisterBottomUpMutator("link", linkageMutator)
61 android.RegisterBottomUpMutator("test_per_src", testPerSrcMutator)
62 android.RegisterBottomUpMutator("deps", depsMutator)
Colin Cross16b23492016-01-06 14:41:07 -080063
Colin Cross635c3b02016-05-18 15:37:25 -070064 android.RegisterTopDownMutator("asan_deps", sanitizerDepsMutator(asan))
65 android.RegisterBottomUpMutator("asan", sanitizerMutator(asan))
Colin Cross16b23492016-01-06 14:41:07 -080066
Colin Cross635c3b02016-05-18 15:37:25 -070067 android.RegisterTopDownMutator("tsan_deps", sanitizerDepsMutator(tsan))
68 android.RegisterBottomUpMutator("tsan", sanitizerMutator(tsan))
Colin Cross463a90e2015-06-17 14:20:06 -070069}
70
Colin Cross3f40fa42015-01-30 17:27:36 -080071var (
Colin Cross635c3b02016-05-18 15:37:25 -070072 HostPrebuiltTag = pctx.VariableConfigMethod("HostPrebuiltTag", android.Config.PrebuiltOS)
Colin Cross3f40fa42015-01-30 17:27:36 -080073
Dan Willemsen34cc69e2015-09-23 15:26:20 -070074 LibcRoot = pctx.SourcePathVariable("LibcRoot", "bionic/libc")
Colin Cross3f40fa42015-01-30 17:27:36 -080075)
76
77// Flags used by lots of devices. Putting them in package static variables will save bytes in
78// build.ninja so they aren't repeated for every file
79var (
80 commonGlobalCflags = []string{
81 "-DANDROID",
82 "-fmessage-length=0",
83 "-W",
84 "-Wall",
85 "-Wno-unused",
86 "-Winit-self",
87 "-Wpointer-arith",
88
89 // COMMON_RELEASE_CFLAGS
90 "-DNDEBUG",
91 "-UDEBUG",
92 }
93
94 deviceGlobalCflags = []string{
Dan Willemsen490fd492015-11-24 17:53:15 -080095 "-fdiagnostics-color",
96
Colin Cross3f40fa42015-01-30 17:27:36 -080097 // TARGET_ERROR_FLAGS
98 "-Werror=return-type",
99 "-Werror=non-virtual-dtor",
100 "-Werror=address",
101 "-Werror=sequence-point",
Dan Willemsena6084a32016-03-01 15:16:50 -0800102 "-Werror=date-time",
Colin Cross3f40fa42015-01-30 17:27:36 -0800103 }
104
105 hostGlobalCflags = []string{}
106
107 commonGlobalCppflags = []string{
108 "-Wsign-promo",
Dan Willemsen3bf6b472015-09-11 17:41:10 -0700109 }
110
Dan Willemsenbe03f342016-03-03 17:21:04 -0800111 noOverrideGlobalCflags = []string{
112 "-Werror=int-to-pointer-cast",
113 "-Werror=pointer-to-int-cast",
114 }
115
Dan Willemsen3bf6b472015-09-11 17:41:10 -0700116 illegalFlags = []string{
117 "-w",
Colin Cross3f40fa42015-01-30 17:27:36 -0800118 }
Dan Willemsen97704ed2016-07-07 21:40:39 -0700119
120 ndkPrebuiltSharedLibs = []string{
121 "android",
122 "c",
123 "dl",
124 "EGL",
125 "GLESv1_CM",
126 "GLESv2",
127 "GLESv3",
128 "jnigraphics",
129 "log",
130 "mediandk",
131 "m",
132 "OpenMAXAL",
133 "OpenSLES",
134 "stdc++",
135 "vulkan",
136 "z",
137 }
138 ndkPrebuiltSharedLibraries = addPrefix(append([]string(nil), ndkPrebuiltSharedLibs...), "lib")
Colin Cross3f40fa42015-01-30 17:27:36 -0800139)
140
141func init() {
Colin Crossa1ad8d12016-06-01 17:09:44 -0700142 if android.BuildOs == android.Linux {
Dan Willemsen0c38c5e2016-03-29 17:31:57 -0700143 commonGlobalCflags = append(commonGlobalCflags, "-fdebug-prefix-map=/proc/self/cwd=")
144 }
145
Colin Cross3f40fa42015-01-30 17:27:36 -0800146 pctx.StaticVariable("commonGlobalCflags", strings.Join(commonGlobalCflags, " "))
147 pctx.StaticVariable("deviceGlobalCflags", strings.Join(deviceGlobalCflags, " "))
148 pctx.StaticVariable("hostGlobalCflags", strings.Join(hostGlobalCflags, " "))
Dan Willemsenbe03f342016-03-03 17:21:04 -0800149 pctx.StaticVariable("noOverrideGlobalCflags", strings.Join(noOverrideGlobalCflags, " "))
Colin Cross3f40fa42015-01-30 17:27:36 -0800150
151 pctx.StaticVariable("commonGlobalCppflags", strings.Join(commonGlobalCppflags, " "))
152
153 pctx.StaticVariable("commonClangGlobalCflags",
Dan Willemsenac5e1cb2016-01-12 16:22:40 -0800154 strings.Join(append(clangFilterUnknownCflags(commonGlobalCflags), "${clangExtraCflags}"), " "))
Colin Cross3f40fa42015-01-30 17:27:36 -0800155 pctx.StaticVariable("deviceClangGlobalCflags",
Dan Willemsenac5e1cb2016-01-12 16:22:40 -0800156 strings.Join(append(clangFilterUnknownCflags(deviceGlobalCflags), "${clangExtraTargetCflags}"), " "))
Colin Cross3f40fa42015-01-30 17:27:36 -0800157 pctx.StaticVariable("hostClangGlobalCflags",
158 strings.Join(clangFilterUnknownCflags(hostGlobalCflags), " "))
Dan Willemsenbe03f342016-03-03 17:21:04 -0800159 pctx.StaticVariable("noOverrideClangGlobalCflags",
160 strings.Join(append(clangFilterUnknownCflags(noOverrideGlobalCflags), "${clangExtraNoOverrideCflags}"), " "))
161
Tim Kilbournf2948142015-03-11 12:03:03 -0700162 pctx.StaticVariable("commonClangGlobalCppflags",
Dan Willemsenac5e1cb2016-01-12 16:22:40 -0800163 strings.Join(append(clangFilterUnknownCflags(commonGlobalCppflags), "${clangExtraCppflags}"), " "))
Colin Cross3f40fa42015-01-30 17:27:36 -0800164
165 // Everything in this list is a crime against abstraction and dependency tracking.
166 // Do not add anything to this list.
Dan Willemsen7b310ee2015-12-18 15:11:17 -0800167 pctx.PrefixedPathsForOptionalSourceVariable("commonGlobalIncludes", "-isystem ",
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700168 []string{
169 "system/core/include",
Dan Willemsen98f93c72016-03-01 15:27:03 -0800170 "system/media/audio/include",
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700171 "hardware/libhardware/include",
172 "hardware/libhardware_legacy/include",
173 "hardware/ril/include",
174 "libnativehelper/include",
175 "frameworks/native/include",
176 "frameworks/native/opengl/include",
177 "frameworks/av/include",
178 "frameworks/base/include",
179 })
Dan Willemsene0378dd2016-01-07 17:42:34 -0800180 // This is used by non-NDK modules to get jni.h. export_include_dirs doesn't help
181 // with this, since there is no associated library.
182 pctx.PrefixedPathsForOptionalSourceVariable("commonNativehelperInclude", "-I",
183 []string{"libnativehelper/include/nativehelper"})
Colin Cross3f40fa42015-01-30 17:27:36 -0800184
Dan Willemsendc5d28a2016-03-16 11:37:17 -0700185 pctx.SourcePathVariable("clangDefaultBase", "prebuilts/clang/host")
186 pctx.VariableFunc("clangBase", func(config interface{}) (string, error) {
Colin Cross635c3b02016-05-18 15:37:25 -0700187 if override := config.(android.Config).Getenv("LLVM_PREBUILTS_BASE"); override != "" {
Dan Willemsendc5d28a2016-03-16 11:37:17 -0700188 return override, nil
189 }
190 return "${clangDefaultBase}", nil
191 })
192 pctx.VariableFunc("clangVersion", func(config interface{}) (string, error) {
Colin Cross635c3b02016-05-18 15:37:25 -0700193 if override := config.(android.Config).Getenv("LLVM_PREBUILTS_VERSION"); override != "" {
Dan Willemsendc5d28a2016-03-16 11:37:17 -0700194 return override, nil
195 }
Stephen Hines369f0132016-04-26 14:34:07 -0700196 return "clang-2812033", nil
Dan Willemsendc5d28a2016-03-16 11:37:17 -0700197 })
Colin Cross16b23492016-01-06 14:41:07 -0800198 pctx.StaticVariable("clangPath", "${clangBase}/${HostPrebuiltTag}/${clangVersion}")
199 pctx.StaticVariable("clangBin", "${clangPath}/bin")
Colin Cross3f40fa42015-01-30 17:27:36 -0800200}
201
Colin Crossca860ac2016-01-04 14:34:37 -0800202type Deps struct {
203 SharedLibs, LateSharedLibs []string
204 StaticLibs, LateStaticLibs, WholeStaticLibs []string
Colin Crossc472d572015-03-17 15:06:21 -0700205
Dan Willemsen490a8dc2016-06-06 18:22:19 -0700206 ReexportSharedLibHeaders, ReexportStaticLibHeaders []string
207
Colin Cross81413472016-04-11 14:37:39 -0700208 ObjFiles []string
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700209
Dan Willemsenb40aab62016-04-20 14:21:14 -0700210 GeneratedSources []string
211 GeneratedHeaders []string
212
Colin Cross97ba0732015-03-23 17:50:24 -0700213 CrtBegin, CrtEnd string
Colin Crossc472d572015-03-17 15:06:21 -0700214}
215
Colin Crossca860ac2016-01-04 14:34:37 -0800216type PathDeps struct {
Colin Cross635c3b02016-05-18 15:37:25 -0700217 SharedLibs, LateSharedLibs android.Paths
218 StaticLibs, LateStaticLibs, WholeStaticLibs android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700219
Colin Cross635c3b02016-05-18 15:37:25 -0700220 ObjFiles android.Paths
221 WholeStaticLibObjFiles android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700222
Colin Cross635c3b02016-05-18 15:37:25 -0700223 GeneratedSources android.Paths
224 GeneratedHeaders android.Paths
Dan Willemsenb40aab62016-04-20 14:21:14 -0700225
Dan Willemsen76f08272016-07-09 00:14:08 -0700226 Flags, ReexportedFlags []string
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700227
Colin Cross635c3b02016-05-18 15:37:25 -0700228 CrtBegin, CrtEnd android.OptionalPath
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700229}
230
Colin Crossca860ac2016-01-04 14:34:37 -0800231type Flags struct {
Colin Cross28344522015-04-22 13:07:53 -0700232 GlobalFlags []string // Flags that apply to C, C++, and assembly source files
233 AsFlags []string // Flags that apply to assembly source files
234 CFlags []string // Flags that apply to C and C++ source files
235 ConlyFlags []string // Flags that apply to C source files
236 CppFlags []string // Flags that apply to C++ source files
237 YaccFlags []string // Flags that apply to Yacc source files
238 LdFlags []string // Flags that apply to linker command lines
Colin Cross16b23492016-01-06 14:41:07 -0800239 libFlags []string // Flags to add libraries early to the link order
Colin Cross28344522015-04-22 13:07:53 -0700240
241 Nocrt bool
242 Toolchain Toolchain
243 Clang bool
Colin Crossca860ac2016-01-04 14:34:37 -0800244
245 RequiredInstructionSet string
Colin Cross16b23492016-01-06 14:41:07 -0800246 DynamicLinker string
247
Colin Cross635c3b02016-05-18 15:37:25 -0700248 CFlagsDeps android.Paths // Files depended on by compiler flags
Colin Crossc472d572015-03-17 15:06:21 -0700249}
250
Colin Crossca860ac2016-01-04 14:34:37 -0800251type BaseCompilerProperties struct {
Colin Cross7d5136f2015-05-11 13:39:40 -0700252 // list of source files used to compile the C/C++ module. May be .c, .cpp, or .S files.
Dan Willemsen2ef08f42015-06-30 18:15:24 -0700253 Srcs []string `android:"arch_variant"`
254
255 // list of source files that should not be used to build the C/C++ module.
256 // This is most useful in the arch/multilib variants to remove non-common files
257 Exclude_srcs []string `android:"arch_variant"`
Colin Cross7d5136f2015-05-11 13:39:40 -0700258
259 // list of module-specific flags that will be used for C and C++ compiles.
260 Cflags []string `android:"arch_variant"`
261
262 // list of module-specific flags that will be used for C++ compiles
263 Cppflags []string `android:"arch_variant"`
264
265 // list of module-specific flags that will be used for C compiles
266 Conlyflags []string `android:"arch_variant"`
267
268 // list of module-specific flags that will be used for .S compiles
269 Asflags []string `android:"arch_variant"`
270
Colin Crossca860ac2016-01-04 14:34:37 -0800271 // list of module-specific flags that will be used for C and C++ compiles when
272 // compiling with clang
273 Clang_cflags []string `android:"arch_variant"`
274
275 // list of module-specific flags that will be used for .S compiles when
276 // compiling with clang
277 Clang_asflags []string `android:"arch_variant"`
278
Colin Cross7d5136f2015-05-11 13:39:40 -0700279 // list of module-specific flags that will be used for .y and .yy compiles
280 Yaccflags []string
281
Colin Cross7d5136f2015-05-11 13:39:40 -0700282 // the instruction set architecture to use to compile the C/C++
283 // module.
284 Instruction_set string `android:"arch_variant"`
285
286 // list of directories relative to the root of the source tree that will
287 // be added to the include path using -I.
288 // If possible, don't use this. If adding paths from the current directory use
289 // local_include_dirs, if adding paths from other modules use export_include_dirs in
290 // that module.
291 Include_dirs []string `android:"arch_variant"`
292
293 // list of directories relative to the Blueprints file that will
294 // be added to the include path using -I
295 Local_include_dirs []string `android:"arch_variant"`
296
Dan Willemsenb40aab62016-04-20 14:21:14 -0700297 // list of generated sources to compile. These are the names of gensrcs or
298 // genrule modules.
299 Generated_sources []string `android:"arch_variant"`
300
301 // list of generated headers to add to the include path. These are the names
302 // of genrule modules.
303 Generated_headers []string `android:"arch_variant"`
304
Colin Crossca860ac2016-01-04 14:34:37 -0800305 // pass -frtti instead of -fno-rtti
306 Rtti *bool
Colin Cross7d5136f2015-05-11 13:39:40 -0700307
Colin Crossca860ac2016-01-04 14:34:37 -0800308 Debug, Release struct {
309 // list of module-specific flags that will be used for C and C++ compiles in debug or
310 // release builds
311 Cflags []string `android:"arch_variant"`
312 } `android:"arch_variant"`
313}
Colin Cross7d5136f2015-05-11 13:39:40 -0700314
Colin Crossca860ac2016-01-04 14:34:37 -0800315type BaseLinkerProperties struct {
Colin Cross7d5136f2015-05-11 13:39:40 -0700316 // list of modules whose object files should be linked into this module
317 // in their entirety. For static library modules, all of the .o files from the intermediate
318 // directory of the dependency will be linked into this modules .a file. For a shared library,
319 // the dependency's .a file will be linked into this module using -Wl,--whole-archive.
Colin Cross6ee75b62016-05-05 15:57:15 -0700320 Whole_static_libs []string `android:"arch_variant,variant_prepend"`
Colin Cross7d5136f2015-05-11 13:39:40 -0700321
322 // list of modules that should be statically linked into this module.
Colin Cross6ee75b62016-05-05 15:57:15 -0700323 Static_libs []string `android:"arch_variant,variant_prepend"`
Colin Cross7d5136f2015-05-11 13:39:40 -0700324
325 // list of modules that should be dynamically linked into this module.
326 Shared_libs []string `android:"arch_variant"`
327
Colin Crossca860ac2016-01-04 14:34:37 -0800328 // list of module-specific flags that will be used for all link steps
329 Ldflags []string `android:"arch_variant"`
330
331 // don't insert default compiler flags into asflags, cflags,
332 // cppflags, conlyflags, ldflags, or include_dirs
333 No_default_compiler_flags *bool
334
335 // list of system libraries that will be dynamically linked to
336 // shared library and executable modules. If unset, generally defaults to libc
337 // and libm. Set to [] to prevent linking against libc and libm.
338 System_shared_libs []string
339
Colin Cross7d5136f2015-05-11 13:39:40 -0700340 // allow the module to contain undefined symbols. By default,
341 // modules cannot contain undefined symbols that are not satisified by their immediate
342 // dependencies. Set this flag to true to remove --no-undefined from the linker flags.
343 // This flag should only be necessary for compiling low-level libraries like libc.
Colin Cross06a931b2015-10-28 17:23:31 -0700344 Allow_undefined_symbols *bool
Colin Cross7d5136f2015-05-11 13:39:40 -0700345
Dan Willemsend67be222015-09-16 15:19:33 -0700346 // don't link in libgcc.a
Colin Cross06a931b2015-10-28 17:23:31 -0700347 No_libgcc *bool
Dan Willemsend67be222015-09-16 15:19:33 -0700348
Colin Cross7d5136f2015-05-11 13:39:40 -0700349 // -l arguments to pass to linker for host-provided shared libraries
350 Host_ldlibs []string `android:"arch_variant"`
Dan Willemsen490a8dc2016-06-06 18:22:19 -0700351
352 // list of shared libraries to re-export include directories from. Entries must be
353 // present in shared_libs.
354 Export_shared_lib_headers []string `android:"arch_variant"`
355
356 // list of static libraries to re-export include directories from. Entries must be
357 // present in static_libs.
358 Export_static_lib_headers []string `android:"arch_variant"`
Colin Crossa89d2e12016-01-11 12:48:37 -0800359
360 // don't link in crt_begin and crt_end. This flag should only be necessary for
361 // compiling crt or libc.
362 Nocrt *bool `android:"arch_variant"`
Colin Crossca860ac2016-01-04 14:34:37 -0800363}
Colin Cross7d5136f2015-05-11 13:39:40 -0700364
Colin Crossca860ac2016-01-04 14:34:37 -0800365type LibraryCompilerProperties struct {
366 Static struct {
367 Srcs []string `android:"arch_variant"`
368 Exclude_srcs []string `android:"arch_variant"`
369 Cflags []string `android:"arch_variant"`
Colin Cross7d5136f2015-05-11 13:39:40 -0700370 } `android:"arch_variant"`
Colin Crossca860ac2016-01-04 14:34:37 -0800371 Shared struct {
372 Srcs []string `android:"arch_variant"`
373 Exclude_srcs []string `android:"arch_variant"`
374 Cflags []string `android:"arch_variant"`
375 } `android:"arch_variant"`
376}
377
Colin Cross919281a2016-04-05 16:42:05 -0700378type FlagExporterProperties struct {
379 // list of directories relative to the Blueprints file that will
380 // be added to the include path using -I for any module that links against this module
381 Export_include_dirs []string `android:"arch_variant"`
382}
383
Colin Crossca860ac2016-01-04 14:34:37 -0800384type LibraryLinkerProperties struct {
385 Static struct {
Dan Willemsenfed4d192016-07-06 21:48:39 -0700386 Enabled *bool `android:"arch_variant"`
Colin Crossca860ac2016-01-04 14:34:37 -0800387 Whole_static_libs []string `android:"arch_variant"`
388 Static_libs []string `android:"arch_variant"`
389 Shared_libs []string `android:"arch_variant"`
390 } `android:"arch_variant"`
391 Shared struct {
Dan Willemsenfed4d192016-07-06 21:48:39 -0700392 Enabled *bool `android:"arch_variant"`
Colin Crossca860ac2016-01-04 14:34:37 -0800393 Whole_static_libs []string `android:"arch_variant"`
394 Static_libs []string `android:"arch_variant"`
395 Shared_libs []string `android:"arch_variant"`
396 } `android:"arch_variant"`
397
398 // local file name to pass to the linker as --version_script
399 Version_script *string `android:"arch_variant"`
400 // local file name to pass to the linker as -unexported_symbols_list
401 Unexported_symbols_list *string `android:"arch_variant"`
402 // local file name to pass to the linker as -force_symbols_not_weak_list
403 Force_symbols_not_weak_list *string `android:"arch_variant"`
404 // local file name to pass to the linker as -force_symbols_weak_list
405 Force_symbols_weak_list *string `android:"arch_variant"`
406
Colin Cross16b23492016-01-06 14:41:07 -0800407 VariantName string `blueprint:"mutated"`
Colin Crossca860ac2016-01-04 14:34:37 -0800408}
409
410type BinaryLinkerProperties struct {
411 // compile executable with -static
Dan Willemsen75ab8082016-07-12 15:36:34 -0700412 Static_executable *bool `android:"arch_variant"`
Colin Crossca860ac2016-01-04 14:34:37 -0800413
414 // set the name of the output
415 Stem string `android:"arch_variant"`
416
417 // append to the name of the output
418 Suffix string `android:"arch_variant"`
419
420 // if set, add an extra objcopy --prefix-symbols= step
421 Prefix_symbols string
422}
423
424type TestLinkerProperties struct {
425 // if set, build against the gtest library. Defaults to true.
426 Gtest bool
427
428 // Create a separate binary for each source file. Useful when there is
429 // global state that can not be torn down and reset between each test suite.
430 Test_per_src *bool
431}
432
Colin Cross81413472016-04-11 14:37:39 -0700433type ObjectLinkerProperties struct {
434 // names of other cc_object modules to link into this module using partial linking
435 Objs []string `android:"arch_variant"`
436}
437
Colin Crossca860ac2016-01-04 14:34:37 -0800438// Properties used to compile all C or C++ modules
439type BaseProperties struct {
440 // compile module with clang instead of gcc
441 Clang *bool `android:"arch_variant"`
Colin Cross7d5136f2015-05-11 13:39:40 -0700442
443 // Minimum sdk version supported when compiling against the ndk
444 Sdk_version string
445
Colin Crossca860ac2016-01-04 14:34:37 -0800446 // don't insert default compiler flags into asflags, cflags,
447 // cppflags, conlyflags, ldflags, or include_dirs
448 No_default_compiler_flags *bool
Colin Crossc99deeb2016-04-11 15:06:20 -0700449
450 AndroidMkSharedLibs []string `blueprint:"mutated"`
Colin Crossbc6fb162016-05-24 15:39:04 -0700451 HideFromMake bool `blueprint:"mutated"`
Colin Crossca860ac2016-01-04 14:34:37 -0800452}
453
454type InstallerProperties struct {
Colin Cross7d5136f2015-05-11 13:39:40 -0700455 // install to a subdirectory of the default install path for the module
456 Relative_install_path string
457}
458
Colin Cross665dce92016-04-28 14:50:03 -0700459type StripProperties struct {
460 Strip struct {
461 None bool
462 Keep_symbols bool
463 }
464}
465
Colin Crossca860ac2016-01-04 14:34:37 -0800466type UnusedProperties struct {
Colin Cross21b481b2016-04-15 16:27:17 -0700467 Native_coverage *bool
468 Required []string
Colin Cross21b481b2016-04-15 16:27:17 -0700469 Tags []string
Colin Crosscfad1192015-11-02 16:43:11 -0800470}
471
Colin Crossca860ac2016-01-04 14:34:37 -0800472type ModuleContextIntf interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800473 static() bool
474 staticBinary() bool
475 clang() bool
476 toolchain() Toolchain
477 noDefaultCompilerFlags() bool
478 sdk() bool
479 sdkVersion() string
Dan Willemsen8146b2f2016-03-30 21:00:30 -0700480 selectedStl() string
Colin Crossca860ac2016-01-04 14:34:37 -0800481}
482
483type ModuleContext interface {
Colin Cross635c3b02016-05-18 15:37:25 -0700484 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800485 ModuleContextIntf
486}
487
488type BaseModuleContext interface {
Colin Cross635c3b02016-05-18 15:37:25 -0700489 android.BaseContext
Colin Crossca860ac2016-01-04 14:34:37 -0800490 ModuleContextIntf
491}
492
493type Customizer interface {
494 CustomizeProperties(BaseModuleContext)
495 Properties() []interface{}
496}
497
498type feature interface {
499 begin(ctx BaseModuleContext)
500 deps(ctx BaseModuleContext, deps Deps) Deps
501 flags(ctx ModuleContext, flags Flags) Flags
502 props() []interface{}
503}
504
505type compiler interface {
506 feature
Colin Cross635c3b02016-05-18 15:37:25 -0700507 compile(ctx ModuleContext, flags Flags, deps PathDeps) android.Paths
Colin Crossca860ac2016-01-04 14:34:37 -0800508}
509
510type linker interface {
511 feature
Colin Cross635c3b02016-05-18 15:37:25 -0700512 link(ctx ModuleContext, flags Flags, deps PathDeps, objFiles android.Paths) android.Path
Colin Crossc99deeb2016-04-11 15:06:20 -0700513 installable() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800514}
515
516type installer interface {
517 props() []interface{}
Colin Cross635c3b02016-05-18 15:37:25 -0700518 install(ctx ModuleContext, path android.Path)
Colin Crossca860ac2016-01-04 14:34:37 -0800519 inData() bool
520}
521
Colin Crossc99deeb2016-04-11 15:06:20 -0700522type dependencyTag struct {
523 blueprint.BaseDependencyTag
524 name string
525 library bool
Dan Willemsen490a8dc2016-06-06 18:22:19 -0700526
527 reexportFlags bool
Colin Crossc99deeb2016-04-11 15:06:20 -0700528}
529
530var (
Dan Willemsen490a8dc2016-06-06 18:22:19 -0700531 sharedDepTag = dependencyTag{name: "shared", library: true}
532 sharedExportDepTag = dependencyTag{name: "shared", library: true, reexportFlags: true}
533 lateSharedDepTag = dependencyTag{name: "late shared", library: true}
534 staticDepTag = dependencyTag{name: "static", library: true}
535 staticExportDepTag = dependencyTag{name: "static", library: true, reexportFlags: true}
536 lateStaticDepTag = dependencyTag{name: "late static", library: true}
537 wholeStaticDepTag = dependencyTag{name: "whole static", library: true, reexportFlags: true}
538 genSourceDepTag = dependencyTag{name: "gen source"}
539 genHeaderDepTag = dependencyTag{name: "gen header"}
540 objDepTag = dependencyTag{name: "obj"}
541 crtBeginDepTag = dependencyTag{name: "crtbegin"}
542 crtEndDepTag = dependencyTag{name: "crtend"}
543 reuseObjTag = dependencyTag{name: "reuse objects"}
Colin Crossc99deeb2016-04-11 15:06:20 -0700544)
545
Colin Crossca860ac2016-01-04 14:34:37 -0800546// Module contains the properties and members used by all C/C++ module types, and implements
547// the blueprint.Module interface. It delegates to compiler, linker, and installer interfaces
548// to construct the output file. Behavior can be customized with a Customizer interface
549type Module struct {
Colin Cross635c3b02016-05-18 15:37:25 -0700550 android.ModuleBase
551 android.DefaultableModule
Colin Crossc472d572015-03-17 15:06:21 -0700552
Colin Crossca860ac2016-01-04 14:34:37 -0800553 Properties BaseProperties
554 unused UnusedProperties
Colin Crossfa138792015-04-24 17:31:52 -0700555
Colin Crossca860ac2016-01-04 14:34:37 -0800556 // initialize before calling Init
Colin Cross635c3b02016-05-18 15:37:25 -0700557 hod android.HostOrDeviceSupported
558 multilib android.Multilib
Colin Crossc472d572015-03-17 15:06:21 -0700559
Colin Crossca860ac2016-01-04 14:34:37 -0800560 // delegates, initialize before calling Init
561 customizer Customizer
562 features []feature
563 compiler compiler
564 linker linker
565 installer installer
Colin Crossa8e07cc2016-04-04 15:07:06 -0700566 stl *stl
Colin Cross16b23492016-01-06 14:41:07 -0800567 sanitize *sanitize
568
569 androidMkSharedLibDeps []string
Colin Cross74d1ec02015-04-28 13:30:13 -0700570
Colin Cross635c3b02016-05-18 15:37:25 -0700571 outputFile android.OptionalPath
Colin Crossca860ac2016-01-04 14:34:37 -0800572
573 cachedToolchain Toolchain
Colin Crossc472d572015-03-17 15:06:21 -0700574}
575
Colin Crossca860ac2016-01-04 14:34:37 -0800576func (c *Module) Init() (blueprint.Module, []interface{}) {
577 props := []interface{}{&c.Properties, &c.unused}
578 if c.customizer != nil {
579 props = append(props, c.customizer.Properties()...)
580 }
581 if c.compiler != nil {
582 props = append(props, c.compiler.props()...)
583 }
584 if c.linker != nil {
585 props = append(props, c.linker.props()...)
586 }
587 if c.installer != nil {
588 props = append(props, c.installer.props()...)
589 }
Colin Crossa8e07cc2016-04-04 15:07:06 -0700590 if c.stl != nil {
591 props = append(props, c.stl.props()...)
592 }
Colin Cross16b23492016-01-06 14:41:07 -0800593 if c.sanitize != nil {
594 props = append(props, c.sanitize.props()...)
595 }
Colin Crossca860ac2016-01-04 14:34:37 -0800596 for _, feature := range c.features {
597 props = append(props, feature.props()...)
598 }
Colin Crossc472d572015-03-17 15:06:21 -0700599
Colin Cross635c3b02016-05-18 15:37:25 -0700600 _, props = android.InitAndroidArchModule(c, c.hod, c.multilib, props...)
Colin Crossc472d572015-03-17 15:06:21 -0700601
Colin Cross635c3b02016-05-18 15:37:25 -0700602 return android.InitDefaultableModule(c, c, props...)
Colin Crossc472d572015-03-17 15:06:21 -0700603}
604
Colin Crossca860ac2016-01-04 14:34:37 -0800605type baseModuleContext struct {
Colin Cross635c3b02016-05-18 15:37:25 -0700606 android.BaseContext
Colin Crossca860ac2016-01-04 14:34:37 -0800607 moduleContextImpl
608}
609
610type moduleContext struct {
Colin Cross635c3b02016-05-18 15:37:25 -0700611 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800612 moduleContextImpl
613}
614
615type moduleContextImpl struct {
616 mod *Module
617 ctx BaseModuleContext
618}
619
Colin Crossca860ac2016-01-04 14:34:37 -0800620func (ctx *moduleContextImpl) clang() bool {
621 return ctx.mod.clang(ctx.ctx)
622}
623
624func (ctx *moduleContextImpl) toolchain() Toolchain {
625 return ctx.mod.toolchain(ctx.ctx)
626}
627
628func (ctx *moduleContextImpl) static() bool {
629 if ctx.mod.linker == nil {
630 panic(fmt.Errorf("static called on module %q with no linker", ctx.ctx.ModuleName()))
631 }
632 if linker, ok := ctx.mod.linker.(baseLinkerInterface); ok {
633 return linker.static()
634 } else {
635 panic(fmt.Errorf("static called on module %q that doesn't use base linker", ctx.ctx.ModuleName()))
636 }
637}
638
639func (ctx *moduleContextImpl) staticBinary() bool {
640 if ctx.mod.linker == nil {
641 panic(fmt.Errorf("staticBinary called on module %q with no linker", ctx.ctx.ModuleName()))
642 }
643 if linker, ok := ctx.mod.linker.(baseLinkerInterface); ok {
644 return linker.staticBinary()
645 } else {
646 panic(fmt.Errorf("staticBinary called on module %q that doesn't use base linker", ctx.ctx.ModuleName()))
647 }
648}
649
650func (ctx *moduleContextImpl) noDefaultCompilerFlags() bool {
651 return Bool(ctx.mod.Properties.No_default_compiler_flags)
652}
653
654func (ctx *moduleContextImpl) sdk() bool {
Dan Willemsena96ff642016-06-07 12:34:45 -0700655 if ctx.ctx.Device() {
656 return ctx.mod.Properties.Sdk_version != ""
657 }
658 return false
Colin Crossca860ac2016-01-04 14:34:37 -0800659}
660
661func (ctx *moduleContextImpl) sdkVersion() string {
Dan Willemsena96ff642016-06-07 12:34:45 -0700662 if ctx.ctx.Device() {
663 return ctx.mod.Properties.Sdk_version
664 }
665 return ""
Colin Crossca860ac2016-01-04 14:34:37 -0800666}
667
Dan Willemsen8146b2f2016-03-30 21:00:30 -0700668func (ctx *moduleContextImpl) selectedStl() string {
669 if stl := ctx.mod.stl; stl != nil {
670 return stl.Properties.SelectedStl
671 }
672 return ""
673}
674
Colin Cross635c3b02016-05-18 15:37:25 -0700675func newBaseModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -0800676 return &Module{
677 hod: hod,
678 multilib: multilib,
679 }
680}
681
Colin Cross635c3b02016-05-18 15:37:25 -0700682func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -0800683 module := newBaseModule(hod, multilib)
Colin Crossa8e07cc2016-04-04 15:07:06 -0700684 module.stl = &stl{}
Colin Cross16b23492016-01-06 14:41:07 -0800685 module.sanitize = &sanitize{}
Colin Crossca860ac2016-01-04 14:34:37 -0800686 return module
687}
688
Colin Cross635c3b02016-05-18 15:37:25 -0700689func (c *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
Colin Crossca860ac2016-01-04 14:34:37 -0800690 ctx := &moduleContext{
Colin Cross635c3b02016-05-18 15:37:25 -0700691 ModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -0800692 moduleContextImpl: moduleContextImpl{
693 mod: c,
694 },
695 }
696 ctx.ctx = ctx
697
698 flags := Flags{
699 Toolchain: c.toolchain(ctx),
700 Clang: c.clang(ctx),
701 }
Colin Crossca860ac2016-01-04 14:34:37 -0800702 if c.compiler != nil {
703 flags = c.compiler.flags(ctx, flags)
704 }
705 if c.linker != nil {
706 flags = c.linker.flags(ctx, flags)
707 }
Colin Crossa8e07cc2016-04-04 15:07:06 -0700708 if c.stl != nil {
709 flags = c.stl.flags(ctx, flags)
710 }
Colin Cross16b23492016-01-06 14:41:07 -0800711 if c.sanitize != nil {
712 flags = c.sanitize.flags(ctx, flags)
713 }
Colin Crossca860ac2016-01-04 14:34:37 -0800714 for _, feature := range c.features {
715 flags = feature.flags(ctx, flags)
716 }
Colin Cross3f40fa42015-01-30 17:27:36 -0800717 if ctx.Failed() {
718 return
719 }
720
Colin Crossca860ac2016-01-04 14:34:37 -0800721 flags.CFlags, _ = filterList(flags.CFlags, illegalFlags)
722 flags.CppFlags, _ = filterList(flags.CppFlags, illegalFlags)
723 flags.ConlyFlags, _ = filterList(flags.ConlyFlags, illegalFlags)
Colin Cross3f40fa42015-01-30 17:27:36 -0800724
Colin Crossca860ac2016-01-04 14:34:37 -0800725 // Optimization to reduce size of build.ninja
726 // Replace the long list of flags for each file with a module-local variable
727 ctx.Variable(pctx, "cflags", strings.Join(flags.CFlags, " "))
728 ctx.Variable(pctx, "cppflags", strings.Join(flags.CppFlags, " "))
729 ctx.Variable(pctx, "asflags", strings.Join(flags.AsFlags, " "))
730 flags.CFlags = []string{"$cflags"}
731 flags.CppFlags = []string{"$cppflags"}
732 flags.AsFlags = []string{"$asflags"}
733
Colin Crossc99deeb2016-04-11 15:06:20 -0700734 deps := c.depsToPaths(ctx)
Colin Cross3f40fa42015-01-30 17:27:36 -0800735 if ctx.Failed() {
736 return
737 }
738
Dan Willemsen76f08272016-07-09 00:14:08 -0700739 flags.GlobalFlags = append(flags.GlobalFlags, deps.Flags...)
Colin Crossed9f8682015-03-18 17:17:35 -0700740
Colin Cross635c3b02016-05-18 15:37:25 -0700741 var objFiles android.Paths
Colin Crossca860ac2016-01-04 14:34:37 -0800742 if c.compiler != nil {
Dan Willemsenb40aab62016-04-20 14:21:14 -0700743 objFiles = c.compiler.compile(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -0800744 if ctx.Failed() {
745 return
746 }
Colin Cross3f40fa42015-01-30 17:27:36 -0800747 }
748
Colin Crossca860ac2016-01-04 14:34:37 -0800749 if c.linker != nil {
750 outputFile := c.linker.link(ctx, flags, deps, objFiles)
751 if ctx.Failed() {
752 return
753 }
Colin Cross635c3b02016-05-18 15:37:25 -0700754 c.outputFile = android.OptionalPathForPath(outputFile)
Colin Cross5049f022015-03-18 13:28:46 -0700755
Colin Crossc99deeb2016-04-11 15:06:20 -0700756 if c.installer != nil && c.linker.installable() {
Colin Crossca860ac2016-01-04 14:34:37 -0800757 c.installer.install(ctx, outputFile)
758 if ctx.Failed() {
759 return
760 }
761 }
Dan Albertc403f7c2015-03-18 14:01:18 -0700762 }
Colin Cross3f40fa42015-01-30 17:27:36 -0800763}
764
Colin Crossca860ac2016-01-04 14:34:37 -0800765func (c *Module) toolchain(ctx BaseModuleContext) Toolchain {
766 if c.cachedToolchain == nil {
767 arch := ctx.Arch()
Colin Crossa1ad8d12016-06-01 17:09:44 -0700768 os := ctx.Os()
769 factory := toolchainFactories[os][arch.ArchType]
Colin Crossca860ac2016-01-04 14:34:37 -0800770 if factory == nil {
Colin Crossa1ad8d12016-06-01 17:09:44 -0700771 ctx.ModuleErrorf("Toolchain not found for %s arch %q", os.String(), arch.String())
Colin Crossca860ac2016-01-04 14:34:37 -0800772 return nil
773 }
774 c.cachedToolchain = factory(arch)
Colin Cross3f40fa42015-01-30 17:27:36 -0800775 }
Colin Crossca860ac2016-01-04 14:34:37 -0800776 return c.cachedToolchain
Colin Cross3f40fa42015-01-30 17:27:36 -0800777}
778
Colin Crossca860ac2016-01-04 14:34:37 -0800779func (c *Module) begin(ctx BaseModuleContext) {
780 if c.compiler != nil {
781 c.compiler.begin(ctx)
Colin Cross21b9a242015-03-24 14:15:58 -0700782 }
Colin Crossca860ac2016-01-04 14:34:37 -0800783 if c.linker != nil {
784 c.linker.begin(ctx)
785 }
Colin Crossa8e07cc2016-04-04 15:07:06 -0700786 if c.stl != nil {
787 c.stl.begin(ctx)
788 }
Colin Cross16b23492016-01-06 14:41:07 -0800789 if c.sanitize != nil {
790 c.sanitize.begin(ctx)
791 }
Colin Crossca860ac2016-01-04 14:34:37 -0800792 for _, feature := range c.features {
793 feature.begin(ctx)
794 }
795}
796
Colin Crossc99deeb2016-04-11 15:06:20 -0700797func (c *Module) deps(ctx BaseModuleContext) Deps {
798 deps := Deps{}
799
800 if c.compiler != nil {
801 deps = c.compiler.deps(ctx, deps)
802 }
803 if c.linker != nil {
804 deps = c.linker.deps(ctx, deps)
805 }
Colin Crossa8e07cc2016-04-04 15:07:06 -0700806 if c.stl != nil {
807 deps = c.stl.deps(ctx, deps)
808 }
Colin Cross16b23492016-01-06 14:41:07 -0800809 if c.sanitize != nil {
810 deps = c.sanitize.deps(ctx, deps)
811 }
Colin Crossc99deeb2016-04-11 15:06:20 -0700812 for _, feature := range c.features {
813 deps = feature.deps(ctx, deps)
814 }
815
816 deps.WholeStaticLibs = lastUniqueElements(deps.WholeStaticLibs)
817 deps.StaticLibs = lastUniqueElements(deps.StaticLibs)
818 deps.LateStaticLibs = lastUniqueElements(deps.LateStaticLibs)
819 deps.SharedLibs = lastUniqueElements(deps.SharedLibs)
820 deps.LateSharedLibs = lastUniqueElements(deps.LateSharedLibs)
821
Dan Willemsen490a8dc2016-06-06 18:22:19 -0700822 for _, lib := range deps.ReexportSharedLibHeaders {
823 if !inList(lib, deps.SharedLibs) {
824 ctx.PropertyErrorf("export_shared_lib_headers", "Shared library not in shared_libs: '%s'", lib)
825 }
826 }
827
828 for _, lib := range deps.ReexportStaticLibHeaders {
829 if !inList(lib, deps.StaticLibs) {
830 ctx.PropertyErrorf("export_static_lib_headers", "Static library not in static_libs: '%s'", lib)
831 }
832 }
833
Colin Crossc99deeb2016-04-11 15:06:20 -0700834 return deps
835}
836
Colin Cross635c3b02016-05-18 15:37:25 -0700837func (c *Module) depsMutator(actx android.BottomUpMutatorContext) {
Colin Crossca860ac2016-01-04 14:34:37 -0800838 ctx := &baseModuleContext{
Colin Cross635c3b02016-05-18 15:37:25 -0700839 BaseContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -0800840 moduleContextImpl: moduleContextImpl{
841 mod: c,
842 },
843 }
844 ctx.ctx = ctx
845
846 if c.customizer != nil {
847 c.customizer.CustomizeProperties(ctx)
848 }
849
850 c.begin(ctx)
851
Colin Crossc99deeb2016-04-11 15:06:20 -0700852 deps := c.deps(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -0800853
Colin Crossb5bc4b42016-07-11 16:11:59 -0700854 c.Properties.AndroidMkSharedLibs = append(c.Properties.AndroidMkSharedLibs, deps.SharedLibs...)
855 c.Properties.AndroidMkSharedLibs = append(c.Properties.AndroidMkSharedLibs, deps.LateSharedLibs...)
Dan Willemsen72d39932016-07-08 23:23:48 -0700856
857 if ctx.sdk() {
858 version := "." + ctx.sdkVersion()
859
860 rewriteNdkLibs := func(list []string) []string {
861 for i, entry := range list {
862 if inList(entry, ndkPrebuiltSharedLibraries) {
863 list[i] = "ndk_" + entry + version
864 }
865 }
866 return list
867 }
868
869 deps.SharedLibs = rewriteNdkLibs(deps.SharedLibs)
870 deps.LateSharedLibs = rewriteNdkLibs(deps.LateSharedLibs)
871 }
Colin Crossc99deeb2016-04-11 15:06:20 -0700872
873 actx.AddVariationDependencies([]blueprint.Variation{{"link", "static"}}, wholeStaticDepTag,
874 deps.WholeStaticLibs...)
875
Dan Willemsen490a8dc2016-06-06 18:22:19 -0700876 for _, lib := range deps.StaticLibs {
877 depTag := staticDepTag
878 if inList(lib, deps.ReexportStaticLibHeaders) {
879 depTag = staticExportDepTag
880 }
Colin Cross15a0d462016-07-14 14:49:58 -0700881 actx.AddVariationDependencies([]blueprint.Variation{{"link", "static"}}, depTag, lib)
Dan Willemsen490a8dc2016-06-06 18:22:19 -0700882 }
Colin Crossc99deeb2016-04-11 15:06:20 -0700883
884 actx.AddVariationDependencies([]blueprint.Variation{{"link", "static"}}, lateStaticDepTag,
885 deps.LateStaticLibs...)
886
Dan Willemsen490a8dc2016-06-06 18:22:19 -0700887 for _, lib := range deps.SharedLibs {
888 depTag := sharedDepTag
889 if inList(lib, deps.ReexportSharedLibHeaders) {
890 depTag = sharedExportDepTag
891 }
Colin Cross15a0d462016-07-14 14:49:58 -0700892 actx.AddVariationDependencies([]blueprint.Variation{{"link", "shared"}}, depTag, lib)
Dan Willemsen490a8dc2016-06-06 18:22:19 -0700893 }
Colin Crossc99deeb2016-04-11 15:06:20 -0700894
895 actx.AddVariationDependencies([]blueprint.Variation{{"link", "shared"}}, lateSharedDepTag,
896 deps.LateSharedLibs...)
897
Colin Cross68861832016-07-08 10:41:41 -0700898 actx.AddDependency(c, genSourceDepTag, deps.GeneratedSources...)
899 actx.AddDependency(c, genHeaderDepTag, deps.GeneratedHeaders...)
Dan Willemsenb40aab62016-04-20 14:21:14 -0700900
Colin Cross68861832016-07-08 10:41:41 -0700901 actx.AddDependency(c, objDepTag, deps.ObjFiles...)
Colin Crossc99deeb2016-04-11 15:06:20 -0700902
903 if deps.CrtBegin != "" {
Colin Cross68861832016-07-08 10:41:41 -0700904 actx.AddDependency(c, crtBeginDepTag, deps.CrtBegin)
Colin Crossca860ac2016-01-04 14:34:37 -0800905 }
Colin Crossc99deeb2016-04-11 15:06:20 -0700906 if deps.CrtEnd != "" {
Colin Cross68861832016-07-08 10:41:41 -0700907 actx.AddDependency(c, crtEndDepTag, deps.CrtEnd)
Colin Cross21b9a242015-03-24 14:15:58 -0700908 }
Colin Cross6362e272015-10-29 15:25:03 -0700909}
Colin Cross21b9a242015-03-24 14:15:58 -0700910
Colin Cross635c3b02016-05-18 15:37:25 -0700911func depsMutator(ctx android.BottomUpMutatorContext) {
Dan Willemsen3f32f032016-07-11 14:36:48 -0700912 if c, ok := ctx.Module().(*Module); ok && c.Enabled() {
Colin Cross6362e272015-10-29 15:25:03 -0700913 c.depsMutator(ctx)
914 }
Colin Cross3f40fa42015-01-30 17:27:36 -0800915}
916
Colin Crossca860ac2016-01-04 14:34:37 -0800917func (c *Module) clang(ctx BaseModuleContext) bool {
918 clang := Bool(c.Properties.Clang)
919
920 if c.Properties.Clang == nil {
921 if ctx.Host() {
922 clang = true
923 }
924
925 if ctx.Device() && ctx.AConfig().DeviceUsesClang() {
926 clang = true
927 }
Colin Cross3f40fa42015-01-30 17:27:36 -0800928 }
Colin Cross28344522015-04-22 13:07:53 -0700929
Colin Crossca860ac2016-01-04 14:34:37 -0800930 if !c.toolchain(ctx).ClangSupported() {
931 clang = false
932 }
933
934 return clang
935}
936
Colin Crossc99deeb2016-04-11 15:06:20 -0700937// Convert dependencies to paths. Returns a PathDeps containing paths
Colin Cross635c3b02016-05-18 15:37:25 -0700938func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
Colin Crossca860ac2016-01-04 14:34:37 -0800939 var depPaths PathDeps
Colin Crossca860ac2016-01-04 14:34:37 -0800940
Dan Willemsena96ff642016-06-07 12:34:45 -0700941 // Whether a module can link to another module, taking into
942 // account NDK linking.
943 linkTypeOk := func(from, to *Module) bool {
944 if from.Target().Os != android.Android {
945 // Host code is not restricted
946 return true
947 }
948 if from.Properties.Sdk_version == "" {
949 // Platform code can link to anything
950 return true
951 }
952 if _, ok := to.linker.(*toolchainLibraryLinker); ok {
953 // These are always allowed
954 return true
955 }
956 if _, ok := to.linker.(*ndkPrebuiltLibraryLinker); ok {
957 // These are allowed, but don't set sdk_version
958 return true
959 }
Dan Willemsen3c316bc2016-07-07 20:41:36 -0700960 if _, ok := to.linker.(*ndkPrebuiltStlLinker); ok {
961 // These are allowed, but don't set sdk_version
962 return true
963 }
964 return to.Properties.Sdk_version != ""
Dan Willemsena96ff642016-06-07 12:34:45 -0700965 }
966
Colin Crossc99deeb2016-04-11 15:06:20 -0700967 ctx.VisitDirectDeps(func(m blueprint.Module) {
968 name := ctx.OtherModuleName(m)
969 tag := ctx.OtherModuleDependencyTag(m)
Colin Crossca860ac2016-01-04 14:34:37 -0800970
Colin Cross635c3b02016-05-18 15:37:25 -0700971 a, _ := m.(android.Module)
Colin Crossc99deeb2016-04-11 15:06:20 -0700972 if a == nil {
973 ctx.ModuleErrorf("module %q not an android module", name)
974 return
Colin Crossca860ac2016-01-04 14:34:37 -0800975 }
Colin Crossca860ac2016-01-04 14:34:37 -0800976
Dan Willemsena96ff642016-06-07 12:34:45 -0700977 cc, _ := m.(*Module)
978 if cc == nil {
Dan Willemsenb40aab62016-04-20 14:21:14 -0700979 switch tag {
Colin Cross635c3b02016-05-18 15:37:25 -0700980 case android.DefaultsDepTag:
Dan Willemsenb40aab62016-04-20 14:21:14 -0700981 case genSourceDepTag:
982 if genRule, ok := m.(genrule.SourceFileGenerator); ok {
983 depPaths.GeneratedSources = append(depPaths.GeneratedSources,
984 genRule.GeneratedSourceFiles()...)
985 } else {
986 ctx.ModuleErrorf("module %q is not a gensrcs or genrule", name)
987 }
988 case genHeaderDepTag:
989 if genRule, ok := m.(genrule.SourceFileGenerator); ok {
990 depPaths.GeneratedHeaders = append(depPaths.GeneratedHeaders,
991 genRule.GeneratedSourceFiles()...)
Dan Willemsen76f08272016-07-09 00:14:08 -0700992 depPaths.Flags = append(depPaths.Flags,
Colin Cross635c3b02016-05-18 15:37:25 -0700993 includeDirsToFlags(android.Paths{genRule.GeneratedHeaderDir()}))
Dan Willemsenb40aab62016-04-20 14:21:14 -0700994 } else {
995 ctx.ModuleErrorf("module %q is not a genrule", name)
996 }
997 default:
Colin Crossc99deeb2016-04-11 15:06:20 -0700998 ctx.ModuleErrorf("depends on non-cc module %q", name)
Colin Crossca860ac2016-01-04 14:34:37 -0800999 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001000 return
1001 }
1002
1003 if !a.Enabled() {
1004 ctx.ModuleErrorf("depends on disabled module %q", name)
1005 return
1006 }
1007
Colin Crossa1ad8d12016-06-01 17:09:44 -07001008 if a.Target().Os != ctx.Os() {
1009 ctx.ModuleErrorf("OS mismatch between %q and %q", ctx.ModuleName(), name)
1010 return
1011 }
1012
1013 if a.Target().Arch.ArchType != ctx.Arch().ArchType {
1014 ctx.ModuleErrorf("Arch mismatch between %q and %q", ctx.ModuleName(), name)
Colin Crossc99deeb2016-04-11 15:06:20 -07001015 return
1016 }
1017
Dan Willemsena96ff642016-06-07 12:34:45 -07001018 if !cc.outputFile.Valid() {
Colin Crossc99deeb2016-04-11 15:06:20 -07001019 ctx.ModuleErrorf("module %q missing output file", name)
1020 return
1021 }
1022
1023 if tag == reuseObjTag {
1024 depPaths.ObjFiles = append(depPaths.ObjFiles,
Dan Willemsena96ff642016-06-07 12:34:45 -07001025 cc.compiler.(*libraryCompiler).reuseObjFiles...)
Colin Crossc99deeb2016-04-11 15:06:20 -07001026 return
1027 }
1028
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001029 if t, ok := tag.(dependencyTag); ok && t.library {
Dan Willemsena96ff642016-06-07 12:34:45 -07001030 if i, ok := cc.linker.(exportedFlagsProducer); ok {
Dan Willemsen76f08272016-07-09 00:14:08 -07001031 flags := i.exportedFlags()
1032 depPaths.Flags = append(depPaths.Flags, flags...)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001033
1034 if t.reexportFlags {
Dan Willemsen76f08272016-07-09 00:14:08 -07001035 depPaths.ReexportedFlags = append(depPaths.ReexportedFlags, flags...)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001036 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001037 }
Dan Willemsena96ff642016-06-07 12:34:45 -07001038
1039 if !linkTypeOk(c, cc) {
1040 ctx.ModuleErrorf("depends on non-NDK-built library %q", name)
1041 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001042 }
1043
Colin Cross635c3b02016-05-18 15:37:25 -07001044 var depPtr *android.Paths
Colin Crossc99deeb2016-04-11 15:06:20 -07001045
1046 switch tag {
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001047 case sharedDepTag, sharedExportDepTag:
Colin Crossc99deeb2016-04-11 15:06:20 -07001048 depPtr = &depPaths.SharedLibs
1049 case lateSharedDepTag:
1050 depPtr = &depPaths.LateSharedLibs
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001051 case staticDepTag, staticExportDepTag:
Colin Crossc99deeb2016-04-11 15:06:20 -07001052 depPtr = &depPaths.StaticLibs
1053 case lateStaticDepTag:
1054 depPtr = &depPaths.LateStaticLibs
1055 case wholeStaticDepTag:
1056 depPtr = &depPaths.WholeStaticLibs
Colin Crossc7a38dc2016-07-12 13:13:09 -07001057 staticLib, _ := cc.linker.(libraryInterface)
Colin Crossc99deeb2016-04-11 15:06:20 -07001058 if staticLib == nil || !staticLib.static() {
Dan Willemsena96ff642016-06-07 12:34:45 -07001059 ctx.ModuleErrorf("module %q not a static library", name)
Colin Crossc99deeb2016-04-11 15:06:20 -07001060 return
1061 }
1062
1063 if missingDeps := staticLib.getWholeStaticMissingDeps(); missingDeps != nil {
1064 postfix := " (required by " + ctx.OtherModuleName(m) + ")"
1065 for i := range missingDeps {
1066 missingDeps[i] += postfix
1067 }
1068 ctx.AddMissingDependencies(missingDeps)
1069 }
1070 depPaths.WholeStaticLibObjFiles =
Colin Crossc7a38dc2016-07-12 13:13:09 -07001071 append(depPaths.WholeStaticLibObjFiles, staticLib.objs()...)
Colin Crossc99deeb2016-04-11 15:06:20 -07001072 case objDepTag:
1073 depPtr = &depPaths.ObjFiles
1074 case crtBeginDepTag:
Dan Willemsena96ff642016-06-07 12:34:45 -07001075 depPaths.CrtBegin = cc.outputFile
Colin Crossc99deeb2016-04-11 15:06:20 -07001076 case crtEndDepTag:
Dan Willemsena96ff642016-06-07 12:34:45 -07001077 depPaths.CrtEnd = cc.outputFile
Colin Crossc99deeb2016-04-11 15:06:20 -07001078 default:
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001079 panic(fmt.Errorf("unknown dependency tag: %s", tag))
Colin Crossc99deeb2016-04-11 15:06:20 -07001080 }
1081
1082 if depPtr != nil {
Dan Willemsena96ff642016-06-07 12:34:45 -07001083 *depPtr = append(*depPtr, cc.outputFile.Path())
Colin Crossca860ac2016-01-04 14:34:37 -08001084 }
1085 })
1086
1087 return depPaths
1088}
1089
1090func (c *Module) InstallInData() bool {
1091 if c.installer == nil {
1092 return false
1093 }
1094 return c.installer.inData()
1095}
1096
1097// Compiler
1098
1099type baseCompiler struct {
1100 Properties BaseCompilerProperties
1101}
1102
1103var _ compiler = (*baseCompiler)(nil)
1104
1105func (compiler *baseCompiler) props() []interface{} {
1106 return []interface{}{&compiler.Properties}
1107}
1108
Dan Willemsenb40aab62016-04-20 14:21:14 -07001109func (compiler *baseCompiler) begin(ctx BaseModuleContext) {}
1110
1111func (compiler *baseCompiler) deps(ctx BaseModuleContext, deps Deps) Deps {
1112 deps.GeneratedSources = append(deps.GeneratedSources, compiler.Properties.Generated_sources...)
1113 deps.GeneratedHeaders = append(deps.GeneratedHeaders, compiler.Properties.Generated_headers...)
1114
1115 return deps
1116}
Colin Crossca860ac2016-01-04 14:34:37 -08001117
1118// Create a Flags struct that collects the compile flags from global values,
1119// per-target values, module type values, and per-module Blueprints properties
1120func (compiler *baseCompiler) flags(ctx ModuleContext, flags Flags) Flags {
1121 toolchain := ctx.toolchain()
1122
Dan Willemsen20acc5c2016-05-25 14:47:21 -07001123 CheckBadCompilerFlags(ctx, "cflags", compiler.Properties.Cflags)
1124 CheckBadCompilerFlags(ctx, "cppflags", compiler.Properties.Cppflags)
1125 CheckBadCompilerFlags(ctx, "conlyflags", compiler.Properties.Conlyflags)
1126 CheckBadCompilerFlags(ctx, "asflags", compiler.Properties.Asflags)
1127
Colin Crossca860ac2016-01-04 14:34:37 -08001128 flags.CFlags = append(flags.CFlags, compiler.Properties.Cflags...)
1129 flags.CppFlags = append(flags.CppFlags, compiler.Properties.Cppflags...)
1130 flags.ConlyFlags = append(flags.ConlyFlags, compiler.Properties.Conlyflags...)
1131 flags.AsFlags = append(flags.AsFlags, compiler.Properties.Asflags...)
1132 flags.YaccFlags = append(flags.YaccFlags, compiler.Properties.Yaccflags...)
1133
Colin Cross28344522015-04-22 13:07:53 -07001134 // Include dir cflags
Colin Cross635c3b02016-05-18 15:37:25 -07001135 rootIncludeDirs := android.PathsForSource(ctx, compiler.Properties.Include_dirs)
1136 localIncludeDirs := android.PathsForModuleSrc(ctx, compiler.Properties.Local_include_dirs)
Colin Cross28344522015-04-22 13:07:53 -07001137 flags.GlobalFlags = append(flags.GlobalFlags,
Dan Willemsen1e898b92015-09-23 15:26:32 -07001138 includeDirsToFlags(localIncludeDirs),
1139 includeDirsToFlags(rootIncludeDirs))
Colin Cross28344522015-04-22 13:07:53 -07001140
Colin Crossca860ac2016-01-04 14:34:37 -08001141 if !ctx.noDefaultCompilerFlags() {
1142 if !ctx.sdk() || ctx.Host() {
Colin Cross28344522015-04-22 13:07:53 -07001143 flags.GlobalFlags = append(flags.GlobalFlags,
1144 "${commonGlobalIncludes}",
1145 toolchain.IncludeFlags(),
Dan Willemsene0378dd2016-01-07 17:42:34 -08001146 "${commonNativehelperInclude}")
Colin Cross28344522015-04-22 13:07:53 -07001147 }
1148
1149 flags.GlobalFlags = append(flags.GlobalFlags, []string{
Colin Cross635c3b02016-05-18 15:37:25 -07001150 "-I" + android.PathForModuleSrc(ctx).String(),
1151 "-I" + android.PathForModuleOut(ctx).String(),
1152 "-I" + android.PathForModuleGen(ctx).String(),
Colin Cross28344522015-04-22 13:07:53 -07001153 }...)
1154 }
1155
Colin Crossca860ac2016-01-04 14:34:37 -08001156 instructionSet := compiler.Properties.Instruction_set
1157 if flags.RequiredInstructionSet != "" {
1158 instructionSet = flags.RequiredInstructionSet
Colin Cross3f40fa42015-01-30 17:27:36 -08001159 }
Dan Willemsen6d11dd82015-11-03 14:27:00 -08001160 instructionSetFlags, err := toolchain.InstructionSetFlags(instructionSet)
1161 if flags.Clang {
1162 instructionSetFlags, err = toolchain.ClangInstructionSetFlags(instructionSet)
1163 }
1164 if err != nil {
1165 ctx.ModuleErrorf("%s", err)
1166 }
1167
Dan Willemsen20acc5c2016-05-25 14:47:21 -07001168 CheckBadCompilerFlags(ctx, "release.cflags", compiler.Properties.Release.Cflags)
1169
Dan Willemsen6d11dd82015-11-03 14:27:00 -08001170 // TODO: debug
Colin Crossca860ac2016-01-04 14:34:37 -08001171 flags.CFlags = append(flags.CFlags, compiler.Properties.Release.Cflags...)
Dan Willemsen6d11dd82015-11-03 14:27:00 -08001172
Colin Cross97ba0732015-03-23 17:50:24 -07001173 if flags.Clang {
Dan Willemsen20acc5c2016-05-25 14:47:21 -07001174 CheckBadCompilerFlags(ctx, "clang_cflags", compiler.Properties.Clang_cflags)
1175 CheckBadCompilerFlags(ctx, "clang_asflags", compiler.Properties.Clang_asflags)
1176
Colin Cross97ba0732015-03-23 17:50:24 -07001177 flags.CFlags = clangFilterUnknownCflags(flags.CFlags)
Colin Crossca860ac2016-01-04 14:34:37 -08001178 flags.CFlags = append(flags.CFlags, compiler.Properties.Clang_cflags...)
1179 flags.AsFlags = append(flags.AsFlags, compiler.Properties.Clang_asflags...)
Colin Cross97ba0732015-03-23 17:50:24 -07001180 flags.CppFlags = clangFilterUnknownCflags(flags.CppFlags)
1181 flags.ConlyFlags = clangFilterUnknownCflags(flags.ConlyFlags)
1182 flags.LdFlags = clangFilterUnknownCflags(flags.LdFlags)
Colin Cross3f40fa42015-01-30 17:27:36 -08001183
1184 target := "-target " + toolchain.ClangTriple()
Dan Willemsen3772da12016-05-16 18:01:46 -07001185 var gccPrefix string
1186 if !ctx.Darwin() {
1187 gccPrefix = "-B" + filepath.Join(toolchain.GccRoot(), toolchain.GccTriple(), "bin")
1188 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001189
Colin Cross97ba0732015-03-23 17:50:24 -07001190 flags.CFlags = append(flags.CFlags, target, gccPrefix)
1191 flags.AsFlags = append(flags.AsFlags, target, gccPrefix)
1192 flags.LdFlags = append(flags.LdFlags, target, gccPrefix)
Colin Cross3f40fa42015-01-30 17:27:36 -08001193 }
1194
Colin Crossa1ad8d12016-06-01 17:09:44 -07001195 hod := "host"
1196 if ctx.Os().Class == android.Device {
1197 hod = "device"
1198 }
1199
Colin Crossca860ac2016-01-04 14:34:37 -08001200 if !ctx.noDefaultCompilerFlags() {
Colin Cross56b4d452015-04-21 17:38:44 -07001201 flags.GlobalFlags = append(flags.GlobalFlags, instructionSetFlags)
1202
Colin Cross97ba0732015-03-23 17:50:24 -07001203 if flags.Clang {
Dan Willemsen32968a22016-01-12 22:25:34 -08001204 flags.AsFlags = append(flags.AsFlags, toolchain.ClangAsflags())
Colin Cross97ba0732015-03-23 17:50:24 -07001205 flags.CppFlags = append(flags.CppFlags, "${commonClangGlobalCppflags}")
Colin Cross56b4d452015-04-21 17:38:44 -07001206 flags.GlobalFlags = append(flags.GlobalFlags,
Colin Cross3f40fa42015-01-30 17:27:36 -08001207 toolchain.ClangCflags(),
1208 "${commonClangGlobalCflags}",
Colin Crossa1ad8d12016-06-01 17:09:44 -07001209 fmt.Sprintf("${%sClangGlobalCflags}", hod))
Dan Willemsenac5e1cb2016-01-12 16:22:40 -08001210
1211 flags.ConlyFlags = append(flags.ConlyFlags, "${clangExtraConlyflags}")
Colin Cross3f40fa42015-01-30 17:27:36 -08001212 } else {
Colin Cross97ba0732015-03-23 17:50:24 -07001213 flags.CppFlags = append(flags.CppFlags, "${commonGlobalCppflags}")
Colin Cross56b4d452015-04-21 17:38:44 -07001214 flags.GlobalFlags = append(flags.GlobalFlags,
Colin Cross3f40fa42015-01-30 17:27:36 -08001215 toolchain.Cflags(),
1216 "${commonGlobalCflags}",
Colin Crossa1ad8d12016-06-01 17:09:44 -07001217 fmt.Sprintf("${%sGlobalCflags}", hod))
Colin Cross3f40fa42015-01-30 17:27:36 -08001218 }
1219
Colin Cross7b66f152015-12-15 16:07:43 -08001220 if Bool(ctx.AConfig().ProductVariables.Brillo) {
1221 flags.GlobalFlags = append(flags.GlobalFlags, "-D__BRILLO__")
1222 }
1223
Colin Crossf6566ed2015-03-24 11:13:38 -07001224 if ctx.Device() {
Colin Crossca860ac2016-01-04 14:34:37 -08001225 if Bool(compiler.Properties.Rtti) {
Colin Cross97ba0732015-03-23 17:50:24 -07001226 flags.CppFlags = append(flags.CppFlags, "-frtti")
Colin Cross3f40fa42015-01-30 17:27:36 -08001227 } else {
Colin Cross97ba0732015-03-23 17:50:24 -07001228 flags.CppFlags = append(flags.CppFlags, "-fno-rtti")
Colin Cross3f40fa42015-01-30 17:27:36 -08001229 }
1230 }
1231
Colin Cross97ba0732015-03-23 17:50:24 -07001232 flags.AsFlags = append(flags.AsFlags, "-D__ASSEMBLY__")
Colin Cross3f40fa42015-01-30 17:27:36 -08001233
Colin Cross97ba0732015-03-23 17:50:24 -07001234 if flags.Clang {
1235 flags.CppFlags = append(flags.CppFlags, toolchain.ClangCppflags())
Colin Cross3f40fa42015-01-30 17:27:36 -08001236 } else {
Colin Cross97ba0732015-03-23 17:50:24 -07001237 flags.CppFlags = append(flags.CppFlags, toolchain.Cppflags())
Colin Cross28344522015-04-22 13:07:53 -07001238 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001239 }
1240
Colin Crossc4bde762015-11-23 16:11:30 -08001241 if flags.Clang {
1242 flags.GlobalFlags = append(flags.GlobalFlags, toolchain.ToolchainClangCflags())
1243 } else {
1244 flags.GlobalFlags = append(flags.GlobalFlags, toolchain.ToolchainCflags())
Colin Crossc4bde762015-11-23 16:11:30 -08001245 }
1246
Colin Crossca860ac2016-01-04 14:34:37 -08001247 if !ctx.sdk() {
Dan Willemsen3bf6b472015-09-11 17:41:10 -07001248 if ctx.Host() && !flags.Clang {
1249 // The host GCC doesn't support C++14 (and is deprecated, so likely
1250 // never will). Build these modules with C++11.
1251 flags.CppFlags = append(flags.CppFlags, "-std=gnu++11")
1252 } else {
1253 flags.CppFlags = append(flags.CppFlags, "-std=gnu++14")
1254 }
1255 }
1256
Dan Willemsen52b1cd22016-03-01 13:36:34 -08001257 // We can enforce some rules more strictly in the code we own. strict
1258 // indicates if this is code that we can be stricter with. If we have
1259 // rules that we want to apply to *our* code (but maybe can't for
1260 // vendor/device specific things), we could extend this to be a ternary
1261 // value.
1262 strict := true
Colin Cross635c3b02016-05-18 15:37:25 -07001263 if strings.HasPrefix(android.PathForModuleSrc(ctx).String(), "external/") {
Dan Willemsen52b1cd22016-03-01 13:36:34 -08001264 strict = false
1265 }
1266
1267 // Can be used to make some annotations stricter for code we can fix
1268 // (such as when we mark functions as deprecated).
1269 if strict {
1270 flags.CFlags = append(flags.CFlags, "-DANDROID_STRICT")
1271 }
1272
Colin Cross3f40fa42015-01-30 17:27:36 -08001273 return flags
1274}
1275
Colin Cross635c3b02016-05-18 15:37:25 -07001276func (compiler *baseCompiler) compile(ctx ModuleContext, flags Flags, deps PathDeps) android.Paths {
Colin Crossca860ac2016-01-04 14:34:37 -08001277 // Compile files listed in c.Properties.Srcs into objects
Dan Willemsenb40aab62016-04-20 14:21:14 -07001278 objFiles := compiler.compileObjs(ctx, flags, "",
1279 compiler.Properties.Srcs, compiler.Properties.Exclude_srcs,
1280 deps.GeneratedSources, deps.GeneratedHeaders)
1281
Colin Crossca860ac2016-01-04 14:34:37 -08001282 if ctx.Failed() {
1283 return nil
1284 }
1285
Colin Crossca860ac2016-01-04 14:34:37 -08001286 return objFiles
Colin Cross3f40fa42015-01-30 17:27:36 -08001287}
1288
1289// Compile a list of source files into objects a specified subdirectory
Colin Cross635c3b02016-05-18 15:37:25 -07001290func (compiler *baseCompiler) compileObjs(ctx android.ModuleContext, flags Flags,
1291 subdir string, srcFiles, excludes []string, extraSrcs, deps android.Paths) android.Paths {
Colin Cross581c1892015-04-07 16:50:10 -07001292
Colin Crossca860ac2016-01-04 14:34:37 -08001293 buildFlags := flagsToBuilderFlags(flags)
Colin Cross3f40fa42015-01-30 17:27:36 -08001294
Dan Willemsen34cc69e2015-09-23 15:26:20 -07001295 inputFiles := ctx.ExpandSources(srcFiles, excludes)
Dan Willemsenb40aab62016-04-20 14:21:14 -07001296 inputFiles = append(inputFiles, extraSrcs...)
1297 srcPaths, gendeps := genSources(ctx, inputFiles, buildFlags)
1298
1299 deps = append(deps, gendeps...)
Colin Cross16b23492016-01-06 14:41:07 -08001300 deps = append(deps, flags.CFlagsDeps...)
Colin Cross3f40fa42015-01-30 17:27:36 -08001301
Dan Willemsen34cc69e2015-09-23 15:26:20 -07001302 return TransformSourceToObj(ctx, subdir, srcPaths, buildFlags, deps)
Colin Cross3f40fa42015-01-30 17:27:36 -08001303}
1304
Colin Crossca860ac2016-01-04 14:34:37 -08001305// baseLinker provides support for shared_libs, static_libs, and whole_static_libs properties
1306type baseLinker struct {
1307 Properties BaseLinkerProperties
1308 dynamicProperties struct {
Colin Crossc99deeb2016-04-11 15:06:20 -07001309 VariantIsShared bool `blueprint:"mutated"`
1310 VariantIsStatic bool `blueprint:"mutated"`
1311 VariantIsStaticBinary bool `blueprint:"mutated"`
1312 RunPaths []string `blueprint:"mutated"`
Colin Cross3f40fa42015-01-30 17:27:36 -08001313 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001314}
1315
Dan Willemsend30e6102016-03-30 17:35:50 -07001316func (linker *baseLinker) begin(ctx BaseModuleContext) {
1317 if ctx.toolchain().Is64Bit() {
Colin Crossc99deeb2016-04-11 15:06:20 -07001318 linker.dynamicProperties.RunPaths = []string{"../lib64", "lib64"}
Dan Willemsend30e6102016-03-30 17:35:50 -07001319 } else {
Colin Crossc99deeb2016-04-11 15:06:20 -07001320 linker.dynamicProperties.RunPaths = []string{"../lib", "lib"}
Dan Willemsend30e6102016-03-30 17:35:50 -07001321 }
1322}
Colin Crossed4cf0b2015-03-26 14:43:45 -07001323
Colin Crossca860ac2016-01-04 14:34:37 -08001324func (linker *baseLinker) props() []interface{} {
1325 return []interface{}{&linker.Properties, &linker.dynamicProperties}
Colin Crossed4cf0b2015-03-26 14:43:45 -07001326}
1327
Colin Crossca860ac2016-01-04 14:34:37 -08001328func (linker *baseLinker) deps(ctx BaseModuleContext, deps Deps) Deps {
1329 deps.WholeStaticLibs = append(deps.WholeStaticLibs, linker.Properties.Whole_static_libs...)
1330 deps.StaticLibs = append(deps.StaticLibs, linker.Properties.Static_libs...)
1331 deps.SharedLibs = append(deps.SharedLibs, linker.Properties.Shared_libs...)
Colin Crossed4cf0b2015-03-26 14:43:45 -07001332
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001333 deps.ReexportStaticLibHeaders = append(deps.ReexportStaticLibHeaders, linker.Properties.Export_static_lib_headers...)
1334 deps.ReexportSharedLibHeaders = append(deps.ReexportSharedLibHeaders, linker.Properties.Export_shared_lib_headers...)
1335
Dan Willemsena96ff642016-06-07 12:34:45 -07001336 if !ctx.sdk() && ctx.ModuleName() != "libcompiler_rt-extras" {
Colin Crossca860ac2016-01-04 14:34:37 -08001337 deps.StaticLibs = append(deps.StaticLibs, "libcompiler_rt-extras")
Colin Cross74d1ec02015-04-28 13:30:13 -07001338 }
1339
Colin Crossf6566ed2015-03-24 11:13:38 -07001340 if ctx.Device() {
Colin Cross77b00fa2015-03-16 16:15:49 -07001341 // libgcc and libatomic have to be last on the command line
Colin Crossca860ac2016-01-04 14:34:37 -08001342 deps.LateStaticLibs = append(deps.LateStaticLibs, "libatomic")
1343 if !Bool(linker.Properties.No_libgcc) {
1344 deps.LateStaticLibs = append(deps.LateStaticLibs, "libgcc")
Dan Willemsend67be222015-09-16 15:19:33 -07001345 }
Colin Crossed4cf0b2015-03-26 14:43:45 -07001346
Colin Crossca860ac2016-01-04 14:34:37 -08001347 if !linker.static() {
1348 if linker.Properties.System_shared_libs != nil {
1349 deps.LateSharedLibs = append(deps.LateSharedLibs,
1350 linker.Properties.System_shared_libs...)
1351 } else if !ctx.sdk() {
1352 deps.LateSharedLibs = append(deps.LateSharedLibs, "libc", "libm")
1353 }
Colin Crossed4cf0b2015-03-26 14:43:45 -07001354 }
Colin Cross577f6e42015-03-27 18:23:34 -07001355
Colin Crossca860ac2016-01-04 14:34:37 -08001356 if ctx.sdk() {
Colin Crossca860ac2016-01-04 14:34:37 -08001357 deps.SharedLibs = append(deps.SharedLibs,
Dan Willemsen97704ed2016-07-07 21:40:39 -07001358 "libc",
1359 "libm",
Colin Cross577f6e42015-03-27 18:23:34 -07001360 )
1361 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001362 }
1363
Colin Crossca860ac2016-01-04 14:34:37 -08001364 return deps
Colin Cross3f40fa42015-01-30 17:27:36 -08001365}
1366
Colin Crossca860ac2016-01-04 14:34:37 -08001367func (linker *baseLinker) flags(ctx ModuleContext, flags Flags) Flags {
1368 toolchain := ctx.toolchain()
1369
Colin Crossa89d2e12016-01-11 12:48:37 -08001370 flags.Nocrt = Bool(linker.Properties.Nocrt)
1371
Colin Crossca860ac2016-01-04 14:34:37 -08001372 if !ctx.noDefaultCompilerFlags() {
1373 if ctx.Device() && !Bool(linker.Properties.Allow_undefined_symbols) {
1374 flags.LdFlags = append(flags.LdFlags, "-Wl,--no-undefined")
1375 }
1376
1377 if flags.Clang {
1378 flags.LdFlags = append(flags.LdFlags, toolchain.ClangLdflags())
1379 } else {
1380 flags.LdFlags = append(flags.LdFlags, toolchain.Ldflags())
1381 }
1382
1383 if ctx.Host() {
Dan Willemsen20acc5c2016-05-25 14:47:21 -07001384 CheckBadHostLdlibs(ctx, "host_ldlibs", linker.Properties.Host_ldlibs)
1385
Colin Crossca860ac2016-01-04 14:34:37 -08001386 flags.LdFlags = append(flags.LdFlags, linker.Properties.Host_ldlibs...)
1387 }
1388 }
1389
Dan Willemsen20acc5c2016-05-25 14:47:21 -07001390 CheckBadLinkerFlags(ctx, "ldflags", linker.Properties.Ldflags)
1391
Dan Willemsen00ced762016-05-10 17:31:21 -07001392 flags.LdFlags = append(flags.LdFlags, linker.Properties.Ldflags...)
1393
Dan Willemsend30e6102016-03-30 17:35:50 -07001394 if ctx.Host() && !linker.static() {
1395 rpath_prefix := `\$$ORIGIN/`
1396 if ctx.Darwin() {
1397 rpath_prefix = "@loader_path/"
1398 }
1399
Colin Crossc99deeb2016-04-11 15:06:20 -07001400 for _, rpath := range linker.dynamicProperties.RunPaths {
Dan Willemsend30e6102016-03-30 17:35:50 -07001401 flags.LdFlags = append(flags.LdFlags, "-Wl,-rpath,"+rpath_prefix+rpath)
1402 }
1403 }
1404
Dan Willemsene7174922016-03-30 17:33:52 -07001405 if flags.Clang {
1406 flags.LdFlags = append(flags.LdFlags, toolchain.ToolchainClangLdflags())
1407 } else {
Colin Crossca860ac2016-01-04 14:34:37 -08001408 flags.LdFlags = append(flags.LdFlags, toolchain.ToolchainLdflags())
1409 }
1410
1411 return flags
1412}
1413
1414func (linker *baseLinker) static() bool {
1415 return linker.dynamicProperties.VariantIsStatic
1416}
1417
1418func (linker *baseLinker) staticBinary() bool {
1419 return linker.dynamicProperties.VariantIsStaticBinary
1420}
1421
1422func (linker *baseLinker) setStatic(static bool) {
1423 linker.dynamicProperties.VariantIsStatic = static
1424}
1425
Colin Cross16b23492016-01-06 14:41:07 -08001426func (linker *baseLinker) isDependencyRoot() bool {
1427 return false
1428}
1429
Colin Crossca860ac2016-01-04 14:34:37 -08001430type baseLinkerInterface interface {
Colin Crossed4cf0b2015-03-26 14:43:45 -07001431 // Returns true if the build options for the module have selected a static or shared build
1432 buildStatic() bool
1433 buildShared() bool
1434
1435 // Sets whether a specific variant is static or shared
Colin Cross18b6dc52015-04-28 13:20:37 -07001436 setStatic(bool)
Colin Crossed4cf0b2015-03-26 14:43:45 -07001437
Colin Cross18b6dc52015-04-28 13:20:37 -07001438 // Returns whether a specific variant is a static library or binary
Colin Crossed4cf0b2015-03-26 14:43:45 -07001439 static() bool
Colin Cross18b6dc52015-04-28 13:20:37 -07001440
1441 // Returns whether a module is a static binary
1442 staticBinary() bool
Colin Cross16b23492016-01-06 14:41:07 -08001443
1444 // Returns true for dependency roots (binaries)
1445 // TODO(ccross): also handle dlopenable libraries
1446 isDependencyRoot() bool
Colin Crossed4cf0b2015-03-26 14:43:45 -07001447}
1448
Colin Crossca860ac2016-01-04 14:34:37 -08001449type baseInstaller struct {
1450 Properties InstallerProperties
1451
1452 dir string
1453 dir64 string
1454 data bool
1455
Colin Cross635c3b02016-05-18 15:37:25 -07001456 path android.OutputPath
Colin Crossca860ac2016-01-04 14:34:37 -08001457}
1458
1459var _ installer = (*baseInstaller)(nil)
1460
1461func (installer *baseInstaller) props() []interface{} {
1462 return []interface{}{&installer.Properties}
1463}
1464
Colin Cross635c3b02016-05-18 15:37:25 -07001465func (installer *baseInstaller) install(ctx ModuleContext, file android.Path) {
Colin Crossca860ac2016-01-04 14:34:37 -08001466 subDir := installer.dir
1467 if ctx.toolchain().Is64Bit() && installer.dir64 != "" {
1468 subDir = installer.dir64
1469 }
Dan Willemsen17f05262016-05-31 16:27:00 -07001470 if !ctx.Host() && !ctx.Arch().Native {
1471 subDir = filepath.Join(subDir, ctx.Arch().ArchType.String())
1472 }
Colin Cross635c3b02016-05-18 15:37:25 -07001473 dir := android.PathForModuleInstall(ctx, subDir, installer.Properties.Relative_install_path)
Colin Crossca860ac2016-01-04 14:34:37 -08001474 installer.path = ctx.InstallFile(dir, file)
1475}
1476
1477func (installer *baseInstaller) inData() bool {
1478 return installer.data
1479}
1480
Colin Cross3f40fa42015-01-30 17:27:36 -08001481//
1482// Combined static+shared libraries
1483//
1484
Colin Cross919281a2016-04-05 16:42:05 -07001485type flagExporter struct {
1486 Properties FlagExporterProperties
1487
1488 flags []string
1489}
1490
1491func (f *flagExporter) exportIncludes(ctx ModuleContext, inc string) {
Colin Cross635c3b02016-05-18 15:37:25 -07001492 includeDirs := android.PathsForModuleSrc(ctx, f.Properties.Export_include_dirs)
Dan Willemsene6c7f182016-07-13 10:45:01 -07001493 for _, dir := range includeDirs.Strings() {
Colin Crossf87b2612016-07-13 18:55:43 -07001494 f.flags = append(f.flags, inc+dir)
Dan Willemsene6c7f182016-07-13 10:45:01 -07001495 }
Colin Cross919281a2016-04-05 16:42:05 -07001496}
1497
1498func (f *flagExporter) reexportFlags(flags []string) {
1499 f.flags = append(f.flags, flags...)
1500}
1501
1502func (f *flagExporter) exportedFlags() []string {
1503 return f.flags
1504}
1505
1506type exportedFlagsProducer interface {
1507 exportedFlags() []string
1508}
1509
1510var _ exportedFlagsProducer = (*flagExporter)(nil)
1511
Colin Crossca860ac2016-01-04 14:34:37 -08001512type libraryCompiler struct {
1513 baseCompiler
Colin Crossaee540a2015-07-06 17:48:31 -07001514
Colin Crossca860ac2016-01-04 14:34:37 -08001515 linker *libraryLinker
1516 Properties LibraryCompilerProperties
Colin Cross7d5136f2015-05-11 13:39:40 -07001517
Colin Crossca860ac2016-01-04 14:34:37 -08001518 // For reusing static library objects for shared library
Colin Cross635c3b02016-05-18 15:37:25 -07001519 reuseObjFiles android.Paths
Colin Cross3f40fa42015-01-30 17:27:36 -08001520}
1521
Colin Crossca860ac2016-01-04 14:34:37 -08001522var _ compiler = (*libraryCompiler)(nil)
1523
1524func (library *libraryCompiler) props() []interface{} {
1525 props := library.baseCompiler.props()
1526 return append(props, &library.Properties)
Colin Crossed4cf0b2015-03-26 14:43:45 -07001527}
1528
Colin Crossca860ac2016-01-04 14:34:37 -08001529func (library *libraryCompiler) flags(ctx ModuleContext, flags Flags) Flags {
1530 flags = library.baseCompiler.flags(ctx, flags)
Colin Cross21b9a242015-03-24 14:15:58 -07001531
Dan Willemsen490fd492015-11-24 17:53:15 -08001532 // MinGW spits out warnings about -fPIC even for -fpie?!) being ignored because
1533 // all code is position independent, and then those warnings get promoted to
1534 // errors.
Colin Crossa1ad8d12016-06-01 17:09:44 -07001535 if ctx.Os() != android.Windows {
Dan Willemsen490fd492015-11-24 17:53:15 -08001536 flags.CFlags = append(flags.CFlags, "-fPIC")
1537 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001538
Colin Crossca860ac2016-01-04 14:34:37 -08001539 if library.linker.static() {
1540 flags.CFlags = append(flags.CFlags, library.Properties.Static.Cflags...)
Colin Crossd8e780d2015-04-28 17:39:43 -07001541 } else {
Colin Crossca860ac2016-01-04 14:34:37 -08001542 flags.CFlags = append(flags.CFlags, library.Properties.Shared.Cflags...)
Colin Crossd8e780d2015-04-28 17:39:43 -07001543 }
1544
Colin Crossca860ac2016-01-04 14:34:37 -08001545 return flags
1546}
1547
Colin Cross635c3b02016-05-18 15:37:25 -07001548func (library *libraryCompiler) compile(ctx ModuleContext, flags Flags, deps PathDeps) android.Paths {
1549 var objFiles android.Paths
Colin Crossca860ac2016-01-04 14:34:37 -08001550
Dan Willemsenb40aab62016-04-20 14:21:14 -07001551 objFiles = library.baseCompiler.compile(ctx, flags, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07001552 library.reuseObjFiles = objFiles
Colin Crossca860ac2016-01-04 14:34:37 -08001553
1554 if library.linker.static() {
Colin Cross635c3b02016-05-18 15:37:25 -07001555 objFiles = append(objFiles, library.compileObjs(ctx, flags, android.DeviceStaticLibrary,
Dan Willemsenb40aab62016-04-20 14:21:14 -07001556 library.Properties.Static.Srcs, library.Properties.Static.Exclude_srcs,
1557 nil, deps.GeneratedHeaders)...)
Colin Crossca860ac2016-01-04 14:34:37 -08001558 } else {
Colin Cross635c3b02016-05-18 15:37:25 -07001559 objFiles = append(objFiles, library.compileObjs(ctx, flags, android.DeviceSharedLibrary,
Dan Willemsenb40aab62016-04-20 14:21:14 -07001560 library.Properties.Shared.Srcs, library.Properties.Shared.Exclude_srcs,
1561 nil, deps.GeneratedHeaders)...)
Colin Crossca860ac2016-01-04 14:34:37 -08001562 }
1563
1564 return objFiles
1565}
1566
1567type libraryLinker struct {
1568 baseLinker
Colin Cross919281a2016-04-05 16:42:05 -07001569 flagExporter
Colin Cross665dce92016-04-28 14:50:03 -07001570 stripper
Colin Crossca860ac2016-01-04 14:34:37 -08001571
1572 Properties LibraryLinkerProperties
1573
1574 dynamicProperties struct {
1575 BuildStatic bool `blueprint:"mutated"`
1576 BuildShared bool `blueprint:"mutated"`
1577 }
1578
Colin Crossca860ac2016-01-04 14:34:37 -08001579 // If we're used as a whole_static_lib, our missing dependencies need
1580 // to be given
1581 wholeStaticMissingDeps []string
1582
1583 // For whole_static_libs
Colin Cross635c3b02016-05-18 15:37:25 -07001584 objFiles android.Paths
Colin Crossca860ac2016-01-04 14:34:37 -08001585}
1586
1587var _ linker = (*libraryLinker)(nil)
Colin Crossca860ac2016-01-04 14:34:37 -08001588
Colin Crossc7a38dc2016-07-12 13:13:09 -07001589type libraryInterface interface {
1590 getWholeStaticMissingDeps() []string
1591 static() bool
1592 objs() android.Paths
1593}
1594
Colin Crossca860ac2016-01-04 14:34:37 -08001595func (library *libraryLinker) props() []interface{} {
1596 props := library.baseLinker.props()
Colin Cross919281a2016-04-05 16:42:05 -07001597 return append(props,
1598 &library.Properties,
1599 &library.dynamicProperties,
Colin Cross665dce92016-04-28 14:50:03 -07001600 &library.flagExporter.Properties,
1601 &library.stripper.StripProperties)
Colin Crossca860ac2016-01-04 14:34:37 -08001602}
1603
1604func (library *libraryLinker) flags(ctx ModuleContext, flags Flags) Flags {
1605 flags = library.baseLinker.flags(ctx, flags)
1606
Colin Crossca860ac2016-01-04 14:34:37 -08001607 if !library.static() {
Colin Cross30d5f512016-05-03 18:02:42 -07001608 libName := ctx.ModuleName() + library.Properties.VariantName
Colin Cross3f40fa42015-01-30 17:27:36 -08001609 // GCC for Android assumes that -shared means -Bsymbolic, use -Wl,-shared instead
1610 sharedFlag := "-Wl,-shared"
Dan Willemsendd0e2c32015-10-20 14:29:35 -07001611 if flags.Clang || ctx.Host() {
Colin Cross3f40fa42015-01-30 17:27:36 -08001612 sharedFlag = "-shared"
1613 }
Colin Crossf87b2612016-07-13 18:55:43 -07001614 var f []string
Colin Crossf6566ed2015-03-24 11:13:38 -07001615 if ctx.Device() {
Colin Crossf87b2612016-07-13 18:55:43 -07001616 f = append(f,
Dan Willemsen99db8c32016-03-03 18:05:38 -08001617 "-nostdlib",
1618 "-Wl,--gc-sections",
1619 )
Colin Cross3f40fa42015-01-30 17:27:36 -08001620 }
Colin Cross97ba0732015-03-23 17:50:24 -07001621
Colin Cross0af4b842015-04-30 16:36:18 -07001622 if ctx.Darwin() {
Colin Crossf87b2612016-07-13 18:55:43 -07001623 f = append(f,
Colin Cross0af4b842015-04-30 16:36:18 -07001624 "-dynamiclib",
1625 "-single_module",
1626 //"-read_only_relocs suppress",
Dan Willemsen490fd492015-11-24 17:53:15 -08001627 "-install_name @rpath/"+libName+flags.Toolchain.ShlibSuffix(),
Colin Cross0af4b842015-04-30 16:36:18 -07001628 )
1629 } else {
Colin Crossf87b2612016-07-13 18:55:43 -07001630 f = append(f,
Colin Cross0af4b842015-04-30 16:36:18 -07001631 sharedFlag,
Colin Crossf87b2612016-07-13 18:55:43 -07001632 "-Wl,-soname,"+libName+flags.Toolchain.ShlibSuffix())
Colin Cross0af4b842015-04-30 16:36:18 -07001633 }
Colin Crossf87b2612016-07-13 18:55:43 -07001634
1635 flags.LdFlags = append(f, flags.LdFlags...)
Colin Cross3f40fa42015-01-30 17:27:36 -08001636 }
Colin Cross97ba0732015-03-23 17:50:24 -07001637
1638 return flags
Colin Cross3f40fa42015-01-30 17:27:36 -08001639}
1640
Colin Crossca860ac2016-01-04 14:34:37 -08001641func (library *libraryLinker) deps(ctx BaseModuleContext, deps Deps) Deps {
1642 deps = library.baseLinker.deps(ctx, deps)
1643 if library.static() {
1644 deps.WholeStaticLibs = append(deps.WholeStaticLibs, library.Properties.Static.Whole_static_libs...)
1645 deps.StaticLibs = append(deps.StaticLibs, library.Properties.Static.Static_libs...)
1646 deps.SharedLibs = append(deps.SharedLibs, library.Properties.Static.Shared_libs...)
1647 } else {
Colin Crossa89d2e12016-01-11 12:48:37 -08001648 if ctx.Device() && !Bool(library.baseLinker.Properties.Nocrt) {
Colin Crossca860ac2016-01-04 14:34:37 -08001649 if !ctx.sdk() {
1650 deps.CrtBegin = "crtbegin_so"
1651 deps.CrtEnd = "crtend_so"
1652 } else {
1653 deps.CrtBegin = "ndk_crtbegin_so." + ctx.sdkVersion()
1654 deps.CrtEnd = "ndk_crtend_so." + ctx.sdkVersion()
1655 }
1656 }
1657 deps.WholeStaticLibs = append(deps.WholeStaticLibs, library.Properties.Shared.Whole_static_libs...)
1658 deps.StaticLibs = append(deps.StaticLibs, library.Properties.Shared.Static_libs...)
1659 deps.SharedLibs = append(deps.SharedLibs, library.Properties.Shared.Shared_libs...)
1660 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001661
Colin Crossca860ac2016-01-04 14:34:37 -08001662 return deps
1663}
Colin Cross3f40fa42015-01-30 17:27:36 -08001664
Colin Crossca860ac2016-01-04 14:34:37 -08001665func (library *libraryLinker) linkStatic(ctx ModuleContext,
Colin Cross635c3b02016-05-18 15:37:25 -07001666 flags Flags, deps PathDeps, objFiles android.Paths) android.Path {
Colin Crossca860ac2016-01-04 14:34:37 -08001667
Colin Cross635c3b02016-05-18 15:37:25 -07001668 library.objFiles = append(android.Paths{}, deps.WholeStaticLibObjFiles...)
Dan Willemsen025b4802016-05-11 17:25:48 -07001669 library.objFiles = append(library.objFiles, objFiles...)
Colin Cross3f40fa42015-01-30 17:27:36 -08001670
Colin Cross635c3b02016-05-18 15:37:25 -07001671 outputFile := android.PathForModuleOut(ctx,
Colin Cross16b23492016-01-06 14:41:07 -08001672 ctx.ModuleName()+library.Properties.VariantName+staticLibraryExtension)
Colin Cross3f40fa42015-01-30 17:27:36 -08001673
Colin Cross0af4b842015-04-30 16:36:18 -07001674 if ctx.Darwin() {
Dan Willemsen025b4802016-05-11 17:25:48 -07001675 TransformDarwinObjToStaticLib(ctx, library.objFiles, flagsToBuilderFlags(flags), outputFile)
Colin Cross0af4b842015-04-30 16:36:18 -07001676 } else {
Dan Willemsen025b4802016-05-11 17:25:48 -07001677 TransformObjToStaticLib(ctx, library.objFiles, flagsToBuilderFlags(flags), outputFile)
Colin Cross0af4b842015-04-30 16:36:18 -07001678 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001679
Colin Crossca860ac2016-01-04 14:34:37 -08001680 library.wholeStaticMissingDeps = ctx.GetMissingDependencies()
Colin Cross3f40fa42015-01-30 17:27:36 -08001681
1682 ctx.CheckbuildFile(outputFile)
Colin Crossca860ac2016-01-04 14:34:37 -08001683
1684 return outputFile
Colin Cross3f40fa42015-01-30 17:27:36 -08001685}
1686
Colin Crossca860ac2016-01-04 14:34:37 -08001687func (library *libraryLinker) linkShared(ctx ModuleContext,
Colin Cross635c3b02016-05-18 15:37:25 -07001688 flags Flags, deps PathDeps, objFiles android.Paths) android.Path {
Colin Cross3f40fa42015-01-30 17:27:36 -08001689
Colin Cross635c3b02016-05-18 15:37:25 -07001690 var linkerDeps android.Paths
Colin Crossaee540a2015-07-06 17:48:31 -07001691
Colin Cross635c3b02016-05-18 15:37:25 -07001692 versionScript := android.OptionalPathForModuleSrc(ctx, library.Properties.Version_script)
1693 unexportedSymbols := android.OptionalPathForModuleSrc(ctx, library.Properties.Unexported_symbols_list)
1694 forceNotWeakSymbols := android.OptionalPathForModuleSrc(ctx, library.Properties.Force_symbols_not_weak_list)
1695 forceWeakSymbols := android.OptionalPathForModuleSrc(ctx, library.Properties.Force_symbols_weak_list)
Dan Willemsen93c28312015-12-04 14:59:08 -08001696 if !ctx.Darwin() {
Dan Willemsen34cc69e2015-09-23 15:26:20 -07001697 if versionScript.Valid() {
Colin Crossca860ac2016-01-04 14:34:37 -08001698 flags.LdFlags = append(flags.LdFlags, "-Wl,--version-script,"+versionScript.String())
Dan Willemsen34cc69e2015-09-23 15:26:20 -07001699 linkerDeps = append(linkerDeps, versionScript.Path())
Dan Willemsen93c28312015-12-04 14:59:08 -08001700 }
Dan Willemsen34cc69e2015-09-23 15:26:20 -07001701 if unexportedSymbols.Valid() {
Dan Willemsen93c28312015-12-04 14:59:08 -08001702 ctx.PropertyErrorf("unexported_symbols_list", "Only supported on Darwin")
1703 }
Dan Willemsen34cc69e2015-09-23 15:26:20 -07001704 if forceNotWeakSymbols.Valid() {
Dan Willemsen93c28312015-12-04 14:59:08 -08001705 ctx.PropertyErrorf("force_symbols_not_weak_list", "Only supported on Darwin")
1706 }
Dan Willemsen34cc69e2015-09-23 15:26:20 -07001707 if forceWeakSymbols.Valid() {
Dan Willemsen93c28312015-12-04 14:59:08 -08001708 ctx.PropertyErrorf("force_symbols_weak_list", "Only supported on Darwin")
1709 }
1710 } else {
Dan Willemsen34cc69e2015-09-23 15:26:20 -07001711 if versionScript.Valid() {
Dan Willemsen93c28312015-12-04 14:59:08 -08001712 ctx.PropertyErrorf("version_script", "Not supported on Darwin")
1713 }
Dan Willemsen34cc69e2015-09-23 15:26:20 -07001714 if unexportedSymbols.Valid() {
Colin Crossca860ac2016-01-04 14:34:37 -08001715 flags.LdFlags = append(flags.LdFlags, "-Wl,-unexported_symbols_list,"+unexportedSymbols.String())
Dan Willemsen34cc69e2015-09-23 15:26:20 -07001716 linkerDeps = append(linkerDeps, unexportedSymbols.Path())
Dan Willemsen93c28312015-12-04 14:59:08 -08001717 }
Dan Willemsen34cc69e2015-09-23 15:26:20 -07001718 if forceNotWeakSymbols.Valid() {
Colin Crossca860ac2016-01-04 14:34:37 -08001719 flags.LdFlags = append(flags.LdFlags, "-Wl,-force_symbols_not_weak_list,"+forceNotWeakSymbols.String())
Dan Willemsen34cc69e2015-09-23 15:26:20 -07001720 linkerDeps = append(linkerDeps, forceNotWeakSymbols.Path())
Dan Willemsen93c28312015-12-04 14:59:08 -08001721 }
Dan Willemsen34cc69e2015-09-23 15:26:20 -07001722 if forceWeakSymbols.Valid() {
Colin Crossca860ac2016-01-04 14:34:37 -08001723 flags.LdFlags = append(flags.LdFlags, "-Wl,-force_symbols_weak_list,"+forceWeakSymbols.String())
Dan Willemsen34cc69e2015-09-23 15:26:20 -07001724 linkerDeps = append(linkerDeps, forceWeakSymbols.Path())
Dan Willemsen93c28312015-12-04 14:59:08 -08001725 }
Colin Crossaee540a2015-07-06 17:48:31 -07001726 }
1727
Colin Cross665dce92016-04-28 14:50:03 -07001728 fileName := ctx.ModuleName() + library.Properties.VariantName + flags.Toolchain.ShlibSuffix()
Colin Cross635c3b02016-05-18 15:37:25 -07001729 outputFile := android.PathForModuleOut(ctx, fileName)
Colin Cross665dce92016-04-28 14:50:03 -07001730 ret := outputFile
1731
1732 builderFlags := flagsToBuilderFlags(flags)
1733
1734 if library.stripper.needsStrip(ctx) {
1735 strippedOutputFile := outputFile
Colin Cross635c3b02016-05-18 15:37:25 -07001736 outputFile = android.PathForModuleOut(ctx, "unstripped", fileName)
Colin Cross665dce92016-04-28 14:50:03 -07001737 library.stripper.strip(ctx, outputFile, strippedOutputFile, builderFlags)
1738 }
1739
Colin Crossca860ac2016-01-04 14:34:37 -08001740 sharedLibs := deps.SharedLibs
1741 sharedLibs = append(sharedLibs, deps.LateSharedLibs...)
Colin Cross3f40fa42015-01-30 17:27:36 -08001742
Colin Crossca860ac2016-01-04 14:34:37 -08001743 TransformObjToDynamicBinary(ctx, objFiles, sharedLibs,
1744 deps.StaticLibs, deps.LateStaticLibs, deps.WholeStaticLibs,
Colin Cross665dce92016-04-28 14:50:03 -07001745 linkerDeps, deps.CrtBegin, deps.CrtEnd, false, builderFlags, outputFile)
Colin Crossca860ac2016-01-04 14:34:37 -08001746
Colin Cross665dce92016-04-28 14:50:03 -07001747 return ret
Colin Cross3f40fa42015-01-30 17:27:36 -08001748}
1749
Colin Crossca860ac2016-01-04 14:34:37 -08001750func (library *libraryLinker) link(ctx ModuleContext,
Colin Cross635c3b02016-05-18 15:37:25 -07001751 flags Flags, deps PathDeps, objFiles android.Paths) android.Path {
Colin Cross3f40fa42015-01-30 17:27:36 -08001752
Colin Crossc99deeb2016-04-11 15:06:20 -07001753 objFiles = append(objFiles, deps.ObjFiles...)
1754
Colin Cross635c3b02016-05-18 15:37:25 -07001755 var out android.Path
Colin Crossca860ac2016-01-04 14:34:37 -08001756 if library.static() {
1757 out = library.linkStatic(ctx, flags, deps, objFiles)
Colin Cross3f40fa42015-01-30 17:27:36 -08001758 } else {
Colin Crossca860ac2016-01-04 14:34:37 -08001759 out = library.linkShared(ctx, flags, deps, objFiles)
Colin Cross3f40fa42015-01-30 17:27:36 -08001760 }
1761
Colin Cross919281a2016-04-05 16:42:05 -07001762 library.exportIncludes(ctx, "-I")
Dan Willemsen76f08272016-07-09 00:14:08 -07001763 library.reexportFlags(deps.ReexportedFlags)
Colin Crossca860ac2016-01-04 14:34:37 -08001764
1765 return out
1766}
1767
1768func (library *libraryLinker) buildStatic() bool {
Colin Cross68861832016-07-08 10:41:41 -07001769 return library.dynamicProperties.BuildStatic &&
1770 (library.Properties.Static.Enabled == nil || *library.Properties.Static.Enabled)
Colin Crossca860ac2016-01-04 14:34:37 -08001771}
1772
1773func (library *libraryLinker) buildShared() bool {
Colin Cross68861832016-07-08 10:41:41 -07001774 return library.dynamicProperties.BuildShared &&
1775 (library.Properties.Shared.Enabled == nil || *library.Properties.Shared.Enabled)
Colin Crossca860ac2016-01-04 14:34:37 -08001776}
1777
1778func (library *libraryLinker) getWholeStaticMissingDeps() []string {
1779 return library.wholeStaticMissingDeps
1780}
1781
Colin Crossc99deeb2016-04-11 15:06:20 -07001782func (library *libraryLinker) installable() bool {
1783 return !library.static()
1784}
1785
Colin Crossc7a38dc2016-07-12 13:13:09 -07001786func (library *libraryLinker) objs() android.Paths {
1787 return library.objFiles
1788}
1789
Colin Crossca860ac2016-01-04 14:34:37 -08001790type libraryInstaller struct {
1791 baseInstaller
1792
Colin Cross30d5f512016-05-03 18:02:42 -07001793 linker *libraryLinker
1794 sanitize *sanitize
Colin Crossca860ac2016-01-04 14:34:37 -08001795}
1796
Colin Cross635c3b02016-05-18 15:37:25 -07001797func (library *libraryInstaller) install(ctx ModuleContext, file android.Path) {
Colin Crossca860ac2016-01-04 14:34:37 -08001798 if !library.linker.static() {
1799 library.baseInstaller.install(ctx, file)
Colin Cross3f40fa42015-01-30 17:27:36 -08001800 }
1801}
1802
Colin Cross30d5f512016-05-03 18:02:42 -07001803func (library *libraryInstaller) inData() bool {
1804 return library.baseInstaller.inData() || library.sanitize.inData()
1805}
1806
Colin Cross635c3b02016-05-18 15:37:25 -07001807func NewLibrary(hod android.HostOrDeviceSupported, shared, static bool) *Module {
1808 module := newModule(hod, android.MultilibBoth)
Dan Albertc403f7c2015-03-18 14:01:18 -07001809
Colin Crossca860ac2016-01-04 14:34:37 -08001810 linker := &libraryLinker{}
1811 linker.dynamicProperties.BuildShared = shared
1812 linker.dynamicProperties.BuildStatic = static
1813 module.linker = linker
1814
1815 module.compiler = &libraryCompiler{
1816 linker: linker,
1817 }
1818 module.installer = &libraryInstaller{
1819 baseInstaller: baseInstaller{
1820 dir: "lib",
1821 dir64: "lib64",
1822 },
Colin Cross30d5f512016-05-03 18:02:42 -07001823 linker: linker,
1824 sanitize: module.sanitize,
Dan Albertc403f7c2015-03-18 14:01:18 -07001825 }
1826
Colin Crossca860ac2016-01-04 14:34:37 -08001827 return module
Dan Albertc403f7c2015-03-18 14:01:18 -07001828}
1829
Colin Crossca860ac2016-01-04 14:34:37 -08001830func libraryFactory() (blueprint.Module, []interface{}) {
Colin Cross635c3b02016-05-18 15:37:25 -07001831 module := NewLibrary(android.HostAndDeviceSupported, true, true)
Colin Crossca860ac2016-01-04 14:34:37 -08001832 return module.Init()
Dan Albertc403f7c2015-03-18 14:01:18 -07001833}
1834
Colin Cross3f40fa42015-01-30 17:27:36 -08001835//
1836// Objects (for crt*.o)
1837//
1838
Colin Crossca860ac2016-01-04 14:34:37 -08001839type objectLinker struct {
Colin Cross81413472016-04-11 14:37:39 -07001840 Properties ObjectLinkerProperties
Dan Albertc3144b12015-04-28 18:17:56 -07001841}
1842
Colin Crossca860ac2016-01-04 14:34:37 -08001843func objectFactory() (blueprint.Module, []interface{}) {
Colin Cross635c3b02016-05-18 15:37:25 -07001844 module := newBaseModule(android.DeviceSupported, android.MultilibBoth)
Colin Crossca860ac2016-01-04 14:34:37 -08001845 module.compiler = &baseCompiler{}
1846 module.linker = &objectLinker{}
1847 return module.Init()
Colin Cross3f40fa42015-01-30 17:27:36 -08001848}
1849
Colin Cross81413472016-04-11 14:37:39 -07001850func (object *objectLinker) props() []interface{} {
1851 return []interface{}{&object.Properties}
Dan Albertc3144b12015-04-28 18:17:56 -07001852}
1853
Colin Crossca860ac2016-01-04 14:34:37 -08001854func (*objectLinker) begin(ctx BaseModuleContext) {}
Colin Cross3f40fa42015-01-30 17:27:36 -08001855
Colin Cross81413472016-04-11 14:37:39 -07001856func (object *objectLinker) deps(ctx BaseModuleContext, deps Deps) Deps {
1857 deps.ObjFiles = append(deps.ObjFiles, object.Properties.Objs...)
Colin Crossca860ac2016-01-04 14:34:37 -08001858 return deps
Colin Cross3f40fa42015-01-30 17:27:36 -08001859}
1860
Colin Crossca860ac2016-01-04 14:34:37 -08001861func (*objectLinker) flags(ctx ModuleContext, flags Flags) Flags {
Dan Willemsene7174922016-03-30 17:33:52 -07001862 if flags.Clang {
1863 flags.LdFlags = append(flags.LdFlags, ctx.toolchain().ToolchainClangLdflags())
1864 } else {
1865 flags.LdFlags = append(flags.LdFlags, ctx.toolchain().ToolchainLdflags())
1866 }
1867
Colin Crossca860ac2016-01-04 14:34:37 -08001868 return flags
1869}
1870
1871func (object *objectLinker) link(ctx ModuleContext,
Colin Cross635c3b02016-05-18 15:37:25 -07001872 flags Flags, deps PathDeps, objFiles android.Paths) android.Path {
Colin Cross3f40fa42015-01-30 17:27:36 -08001873
Colin Cross97ba0732015-03-23 17:50:24 -07001874 objFiles = append(objFiles, deps.ObjFiles...)
Colin Cross3f40fa42015-01-30 17:27:36 -08001875
Colin Cross635c3b02016-05-18 15:37:25 -07001876 var outputFile android.Path
Colin Cross3f40fa42015-01-30 17:27:36 -08001877 if len(objFiles) == 1 {
1878 outputFile = objFiles[0]
1879 } else {
Colin Cross635c3b02016-05-18 15:37:25 -07001880 output := android.PathForModuleOut(ctx, ctx.ModuleName()+objectExtension)
Colin Crossca860ac2016-01-04 14:34:37 -08001881 TransformObjsToObj(ctx, objFiles, flagsToBuilderFlags(flags), output)
Dan Willemsen34cc69e2015-09-23 15:26:20 -07001882 outputFile = output
Colin Cross3f40fa42015-01-30 17:27:36 -08001883 }
1884
Colin Cross3f40fa42015-01-30 17:27:36 -08001885 ctx.CheckbuildFile(outputFile)
Colin Crossca860ac2016-01-04 14:34:37 -08001886 return outputFile
Colin Cross3f40fa42015-01-30 17:27:36 -08001887}
1888
Colin Crossc99deeb2016-04-11 15:06:20 -07001889func (*objectLinker) installable() bool {
1890 return false
1891}
1892
Colin Cross3f40fa42015-01-30 17:27:36 -08001893//
1894// Executables
1895//
1896
Colin Crossca860ac2016-01-04 14:34:37 -08001897type binaryLinker struct {
1898 baseLinker
Colin Cross665dce92016-04-28 14:50:03 -07001899 stripper
Colin Cross7d5136f2015-05-11 13:39:40 -07001900
Colin Crossca860ac2016-01-04 14:34:37 -08001901 Properties BinaryLinkerProperties
Colin Cross7d5136f2015-05-11 13:39:40 -07001902
Colin Cross635c3b02016-05-18 15:37:25 -07001903 hostToolPath android.OptionalPath
Colin Cross7d5136f2015-05-11 13:39:40 -07001904}
1905
Colin Crossca860ac2016-01-04 14:34:37 -08001906var _ linker = (*binaryLinker)(nil)
1907
1908func (binary *binaryLinker) props() []interface{} {
Colin Cross665dce92016-04-28 14:50:03 -07001909 return append(binary.baseLinker.props(),
1910 &binary.Properties,
1911 &binary.stripper.StripProperties)
1912
Colin Cross3f40fa42015-01-30 17:27:36 -08001913}
1914
Colin Crossca860ac2016-01-04 14:34:37 -08001915func (binary *binaryLinker) buildStatic() bool {
Dan Willemsen36cff8b2016-05-17 16:35:02 -07001916 return binary.baseLinker.staticBinary()
Colin Crossed4cf0b2015-03-26 14:43:45 -07001917}
1918
Colin Crossca860ac2016-01-04 14:34:37 -08001919func (binary *binaryLinker) buildShared() bool {
Dan Willemsen36cff8b2016-05-17 16:35:02 -07001920 return !binary.baseLinker.staticBinary()
Colin Crossed4cf0b2015-03-26 14:43:45 -07001921}
1922
Colin Crossca860ac2016-01-04 14:34:37 -08001923func (binary *binaryLinker) getStem(ctx BaseModuleContext) string {
Colin Cross4ae185c2015-03-26 15:12:10 -07001924 stem := ctx.ModuleName()
Colin Crossca860ac2016-01-04 14:34:37 -08001925 if binary.Properties.Stem != "" {
1926 stem = binary.Properties.Stem
Colin Cross3f40fa42015-01-30 17:27:36 -08001927 }
Colin Cross4ae185c2015-03-26 15:12:10 -07001928
Colin Crossca860ac2016-01-04 14:34:37 -08001929 return stem + binary.Properties.Suffix
Colin Cross3f40fa42015-01-30 17:27:36 -08001930}
1931
Colin Crossca860ac2016-01-04 14:34:37 -08001932func (binary *binaryLinker) deps(ctx BaseModuleContext, deps Deps) Deps {
1933 deps = binary.baseLinker.deps(ctx, deps)
Colin Crossf6566ed2015-03-24 11:13:38 -07001934 if ctx.Device() {
Colin Crossa89d2e12016-01-11 12:48:37 -08001935 if !Bool(binary.baseLinker.Properties.Nocrt) {
1936 if !ctx.sdk() {
1937 if binary.buildStatic() {
1938 deps.CrtBegin = "crtbegin_static"
1939 } else {
1940 deps.CrtBegin = "crtbegin_dynamic"
1941 }
1942 deps.CrtEnd = "crtend_android"
Dan Albertc3144b12015-04-28 18:17:56 -07001943 } else {
Colin Crossa89d2e12016-01-11 12:48:37 -08001944 if binary.buildStatic() {
1945 deps.CrtBegin = "ndk_crtbegin_static." + ctx.sdkVersion()
1946 } else {
1947 if Bool(binary.Properties.Static_executable) {
1948 deps.CrtBegin = "ndk_crtbegin_static." + ctx.sdkVersion()
1949 } else {
1950 deps.CrtBegin = "ndk_crtbegin_dynamic." + ctx.sdkVersion()
1951 }
1952 deps.CrtEnd = "ndk_crtend_android." + ctx.sdkVersion()
1953 }
Dan Albertc3144b12015-04-28 18:17:56 -07001954 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001955 }
Colin Crossed4cf0b2015-03-26 14:43:45 -07001956
Dan Willemsen36cff8b2016-05-17 16:35:02 -07001957 if binary.buildStatic() {
Colin Crossca860ac2016-01-04 14:34:37 -08001958 if inList("libc++_static", deps.StaticLibs) {
1959 deps.StaticLibs = append(deps.StaticLibs, "libm", "libc", "libdl")
Colin Cross74d1ec02015-04-28 13:30:13 -07001960 }
Colin Crossed4cf0b2015-03-26 14:43:45 -07001961 // static libraries libcompiler_rt, libc and libc_nomalloc need to be linked with
1962 // --start-group/--end-group along with libgcc. If they are in deps.StaticLibs,
1963 // move them to the beginning of deps.LateStaticLibs
1964 var groupLibs []string
Colin Crossca860ac2016-01-04 14:34:37 -08001965 deps.StaticLibs, groupLibs = filterList(deps.StaticLibs,
Colin Crossed4cf0b2015-03-26 14:43:45 -07001966 []string{"libc", "libc_nomalloc", "libcompiler_rt"})
Colin Crossca860ac2016-01-04 14:34:37 -08001967 deps.LateStaticLibs = append(groupLibs, deps.LateStaticLibs...)
Colin Crossed4cf0b2015-03-26 14:43:45 -07001968 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001969 }
Colin Crossca860ac2016-01-04 14:34:37 -08001970
Dan Willemsen36cff8b2016-05-17 16:35:02 -07001971 if binary.buildShared() && inList("libc", deps.StaticLibs) {
Colin Crossca860ac2016-01-04 14:34:37 -08001972 ctx.ModuleErrorf("statically linking libc to dynamic executable, please remove libc\n" +
1973 "from static libs or set static_executable: true")
1974 }
1975 return deps
Colin Cross3f40fa42015-01-30 17:27:36 -08001976}
1977
Colin Crossc99deeb2016-04-11 15:06:20 -07001978func (*binaryLinker) installable() bool {
1979 return true
1980}
1981
Colin Cross16b23492016-01-06 14:41:07 -08001982func (binary *binaryLinker) isDependencyRoot() bool {
1983 return true
1984}
1985
Colin Cross635c3b02016-05-18 15:37:25 -07001986func NewBinary(hod android.HostOrDeviceSupported) *Module {
1987 module := newModule(hod, android.MultilibFirst)
Colin Crossca860ac2016-01-04 14:34:37 -08001988 module.compiler = &baseCompiler{}
1989 module.linker = &binaryLinker{}
1990 module.installer = &baseInstaller{
1991 dir: "bin",
1992 }
1993 return module
Colin Cross3f40fa42015-01-30 17:27:36 -08001994}
1995
Colin Crossca860ac2016-01-04 14:34:37 -08001996func binaryFactory() (blueprint.Module, []interface{}) {
Colin Cross635c3b02016-05-18 15:37:25 -07001997 module := NewBinary(android.HostAndDeviceSupported)
Colin Crossca860ac2016-01-04 14:34:37 -08001998 return module.Init()
Colin Cross3f40fa42015-01-30 17:27:36 -08001999}
2000
Dan Willemsen36cff8b2016-05-17 16:35:02 -07002001func (binary *binaryLinker) begin(ctx BaseModuleContext) {
2002 binary.baseLinker.begin(ctx)
2003
2004 static := Bool(binary.Properties.Static_executable)
2005 if ctx.Host() {
Colin Crossa1ad8d12016-06-01 17:09:44 -07002006 if ctx.Os() == android.Linux {
Dan Willemsen36cff8b2016-05-17 16:35:02 -07002007 if binary.Properties.Static_executable == nil && Bool(ctx.AConfig().ProductVariables.HostStaticBinaries) {
2008 static = true
2009 }
2010 } else {
2011 // Static executables are not supported on Darwin or Windows
2012 static = false
2013 }
Colin Cross0af4b842015-04-30 16:36:18 -07002014 }
Dan Willemsen36cff8b2016-05-17 16:35:02 -07002015 if static {
2016 binary.dynamicProperties.VariantIsStatic = true
Colin Crossca860ac2016-01-04 14:34:37 -08002017 binary.dynamicProperties.VariantIsStaticBinary = true
Colin Cross18b6dc52015-04-28 13:20:37 -07002018 }
2019}
2020
Colin Crossca860ac2016-01-04 14:34:37 -08002021func (binary *binaryLinker) flags(ctx ModuleContext, flags Flags) Flags {
2022 flags = binary.baseLinker.flags(ctx, flags)
Colin Cross21b9a242015-03-24 14:15:58 -07002023
Dan Willemsen36cff8b2016-05-17 16:35:02 -07002024 if ctx.Host() && !binary.staticBinary() {
Dan Willemsen490fd492015-11-24 17:53:15 -08002025 flags.LdFlags = append(flags.LdFlags, "-pie")
Colin Crossa1ad8d12016-06-01 17:09:44 -07002026 if ctx.Os() == android.Windows {
Dan Willemsen490fd492015-11-24 17:53:15 -08002027 flags.LdFlags = append(flags.LdFlags, "-Wl,-e_mainCRTStartup")
2028 }
2029 }
2030
2031 // MinGW spits out warnings about -fPIC even for -fpie?!) being ignored because
2032 // all code is position independent, and then those warnings get promoted to
2033 // errors.
Colin Crossa1ad8d12016-06-01 17:09:44 -07002034 if ctx.Os() != android.Windows {
Dan Willemsen490fd492015-11-24 17:53:15 -08002035 flags.CFlags = append(flags.CFlags, "-fpie")
2036 }
Colin Cross97ba0732015-03-23 17:50:24 -07002037
Colin Crossf6566ed2015-03-24 11:13:38 -07002038 if ctx.Device() {
Dan Willemsen36cff8b2016-05-17 16:35:02 -07002039 if binary.buildStatic() {
Colin Crossed4cf0b2015-03-26 14:43:45 -07002040 // Clang driver needs -static to create static executable.
2041 // However, bionic/linker uses -shared to overwrite.
2042 // Linker for x86 targets does not allow coexistance of -static and -shared,
2043 // so we add -static only if -shared is not used.
2044 if !inList("-shared", flags.LdFlags) {
2045 flags.LdFlags = append(flags.LdFlags, "-static")
2046 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002047
Colin Crossed4cf0b2015-03-26 14:43:45 -07002048 flags.LdFlags = append(flags.LdFlags,
2049 "-nostdlib",
2050 "-Bstatic",
2051 "-Wl,--gc-sections",
2052 )
2053
2054 } else {
Colin Cross16b23492016-01-06 14:41:07 -08002055 if flags.DynamicLinker == "" {
2056 flags.DynamicLinker = "/system/bin/linker"
2057 if flags.Toolchain.Is64Bit() {
2058 flags.DynamicLinker += "64"
2059 }
Colin Crossed4cf0b2015-03-26 14:43:45 -07002060 }
2061
2062 flags.LdFlags = append(flags.LdFlags,
Colin Cross979422c2015-12-01 14:09:48 -08002063 "-pie",
Colin Crossed4cf0b2015-03-26 14:43:45 -07002064 "-nostdlib",
2065 "-Bdynamic",
Colin Crossed4cf0b2015-03-26 14:43:45 -07002066 "-Wl,--gc-sections",
2067 "-Wl,-z,nocopyreloc",
2068 )
2069 }
Dan Willemsen36cff8b2016-05-17 16:35:02 -07002070 } else {
2071 if binary.staticBinary() {
2072 flags.LdFlags = append(flags.LdFlags, "-static")
2073 }
2074 if ctx.Darwin() {
2075 flags.LdFlags = append(flags.LdFlags, "-Wl,-headerpad_max_install_names")
2076 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002077 }
2078
Colin Cross97ba0732015-03-23 17:50:24 -07002079 return flags
Colin Cross3f40fa42015-01-30 17:27:36 -08002080}
2081
Colin Crossca860ac2016-01-04 14:34:37 -08002082func (binary *binaryLinker) link(ctx ModuleContext,
Colin Cross635c3b02016-05-18 15:37:25 -07002083 flags Flags, deps PathDeps, objFiles android.Paths) android.Path {
Colin Cross3f40fa42015-01-30 17:27:36 -08002084
Colin Cross665dce92016-04-28 14:50:03 -07002085 fileName := binary.getStem(ctx) + flags.Toolchain.ExecutableSuffix()
Colin Cross635c3b02016-05-18 15:37:25 -07002086 outputFile := android.PathForModuleOut(ctx, fileName)
Colin Cross665dce92016-04-28 14:50:03 -07002087 ret := outputFile
Colin Crossa1ad8d12016-06-01 17:09:44 -07002088 if ctx.Os().Class == android.Host {
Colin Cross635c3b02016-05-18 15:37:25 -07002089 binary.hostToolPath = android.OptionalPathForPath(outputFile)
Colin Cross3f40fa42015-01-30 17:27:36 -08002090 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002091
Colin Cross635c3b02016-05-18 15:37:25 -07002092 var linkerDeps android.Paths
Colin Crossaee540a2015-07-06 17:48:31 -07002093
Colin Crossca860ac2016-01-04 14:34:37 -08002094 sharedLibs := deps.SharedLibs
2095 sharedLibs = append(sharedLibs, deps.LateSharedLibs...)
2096
Colin Cross16b23492016-01-06 14:41:07 -08002097 if flags.DynamicLinker != "" {
2098 flags.LdFlags = append(flags.LdFlags, " -Wl,-dynamic-linker,"+flags.DynamicLinker)
2099 }
2100
Colin Cross665dce92016-04-28 14:50:03 -07002101 builderFlags := flagsToBuilderFlags(flags)
2102
2103 if binary.stripper.needsStrip(ctx) {
2104 strippedOutputFile := outputFile
Colin Cross635c3b02016-05-18 15:37:25 -07002105 outputFile = android.PathForModuleOut(ctx, "unstripped", fileName)
Colin Cross665dce92016-04-28 14:50:03 -07002106 binary.stripper.strip(ctx, outputFile, strippedOutputFile, builderFlags)
2107 }
2108
2109 if binary.Properties.Prefix_symbols != "" {
2110 afterPrefixSymbols := outputFile
Colin Cross635c3b02016-05-18 15:37:25 -07002111 outputFile = android.PathForModuleOut(ctx, "unprefixed", fileName)
Colin Cross665dce92016-04-28 14:50:03 -07002112 TransformBinaryPrefixSymbols(ctx, binary.Properties.Prefix_symbols, outputFile,
2113 flagsToBuilderFlags(flags), afterPrefixSymbols)
2114 }
2115
Colin Crossca860ac2016-01-04 14:34:37 -08002116 TransformObjToDynamicBinary(ctx, objFiles, sharedLibs, deps.StaticLibs,
Colin Crossaee540a2015-07-06 17:48:31 -07002117 deps.LateStaticLibs, deps.WholeStaticLibs, linkerDeps, deps.CrtBegin, deps.CrtEnd, true,
Colin Cross665dce92016-04-28 14:50:03 -07002118 builderFlags, outputFile)
Colin Crossca860ac2016-01-04 14:34:37 -08002119
2120 return ret
Dan Albertc403f7c2015-03-18 14:01:18 -07002121}
Colin Cross3f40fa42015-01-30 17:27:36 -08002122
Colin Cross635c3b02016-05-18 15:37:25 -07002123func (binary *binaryLinker) HostToolPath() android.OptionalPath {
Colin Crossca860ac2016-01-04 14:34:37 -08002124 return binary.hostToolPath
Colin Crossd350ecd2015-04-28 13:25:36 -07002125}
2126
Colin Cross665dce92016-04-28 14:50:03 -07002127type stripper struct {
2128 StripProperties StripProperties
2129}
2130
2131func (stripper *stripper) needsStrip(ctx ModuleContext) bool {
2132 return !ctx.AConfig().EmbeddedInMake() && !stripper.StripProperties.Strip.None
2133}
2134
Colin Cross635c3b02016-05-18 15:37:25 -07002135func (stripper *stripper) strip(ctx ModuleContext, in, out android.ModuleOutPath,
Colin Cross665dce92016-04-28 14:50:03 -07002136 flags builderFlags) {
Colin Crossb8ecdfe2016-05-03 15:10:29 -07002137 if ctx.Darwin() {
2138 TransformDarwinStrip(ctx, in, out)
2139 } else {
2140 flags.stripKeepSymbols = stripper.StripProperties.Strip.Keep_symbols
2141 // TODO(ccross): don't add gnu debuglink for user builds
2142 flags.stripAddGnuDebuglink = true
2143 TransformStrip(ctx, in, out, flags)
2144 }
Colin Cross665dce92016-04-28 14:50:03 -07002145}
2146
Colin Cross635c3b02016-05-18 15:37:25 -07002147func testPerSrcMutator(mctx android.BottomUpMutatorContext) {
Colin Crossca860ac2016-01-04 14:34:37 -08002148 if m, ok := mctx.Module().(*Module); ok {
Colin Crossc7a38dc2016-07-12 13:13:09 -07002149 if test, ok := m.linker.(*testBinaryLinker); ok {
2150 if Bool(test.testLinker.Properties.Test_per_src) {
Colin Crossca860ac2016-01-04 14:34:37 -08002151 testNames := make([]string, len(m.compiler.(*baseCompiler).Properties.Srcs))
2152 for i, src := range m.compiler.(*baseCompiler).Properties.Srcs {
2153 testNames[i] = strings.TrimSuffix(filepath.Base(src), filepath.Ext(src))
2154 }
2155 tests := mctx.CreateLocalVariations(testNames...)
2156 for i, src := range m.compiler.(*baseCompiler).Properties.Srcs {
2157 tests[i].(*Module).compiler.(*baseCompiler).Properties.Srcs = []string{src}
Colin Crossc7a38dc2016-07-12 13:13:09 -07002158 tests[i].(*Module).linker.(*testBinaryLinker).binaryLinker.Properties.Stem = testNames[i]
Colin Crossca860ac2016-01-04 14:34:37 -08002159 }
Colin Cross6002e052015-09-16 16:00:08 -07002160 }
2161 }
2162 }
Colin Cross7d5136f2015-05-11 13:39:40 -07002163}
2164
Colin Crossca860ac2016-01-04 14:34:37 -08002165type testLinker struct {
Colin Crossca860ac2016-01-04 14:34:37 -08002166 Properties TestLinkerProperties
Dan Willemsen10d52fd2015-12-21 15:25:58 -08002167}
2168
Colin Crossca860ac2016-01-04 14:34:37 -08002169func (test *testLinker) flags(ctx ModuleContext, flags Flags) Flags {
Colin Crossca860ac2016-01-04 14:34:37 -08002170 if !test.Properties.Gtest {
Dan Willemsen10d52fd2015-12-21 15:25:58 -08002171 return flags
2172 }
Dan Albertc403f7c2015-03-18 14:01:18 -07002173
Colin Cross97ba0732015-03-23 17:50:24 -07002174 flags.CFlags = append(flags.CFlags, "-DGTEST_HAS_STD_STRING")
Colin Crossf6566ed2015-03-24 11:13:38 -07002175 if ctx.Host() {
Colin Cross97ba0732015-03-23 17:50:24 -07002176 flags.CFlags = append(flags.CFlags, "-O0", "-g")
Dan Willemsen10d52fd2015-12-21 15:25:58 -08002177
Colin Crossa1ad8d12016-06-01 17:09:44 -07002178 switch ctx.Os() {
Colin Cross635c3b02016-05-18 15:37:25 -07002179 case android.Windows:
Dan Willemsen10d52fd2015-12-21 15:25:58 -08002180 flags.CFlags = append(flags.CFlags, "-DGTEST_OS_WINDOWS")
Colin Cross635c3b02016-05-18 15:37:25 -07002181 case android.Linux:
Dan Willemsen10d52fd2015-12-21 15:25:58 -08002182 flags.CFlags = append(flags.CFlags, "-DGTEST_OS_LINUX")
2183 flags.LdFlags = append(flags.LdFlags, "-lpthread")
Colin Cross635c3b02016-05-18 15:37:25 -07002184 case android.Darwin:
Dan Willemsen4a946832016-05-13 14:13:01 -07002185 flags.CFlags = append(flags.CFlags, "-DGTEST_OS_MAC")
2186 flags.LdFlags = append(flags.LdFlags, "-lpthread")
Dan Willemsen10d52fd2015-12-21 15:25:58 -08002187 }
2188 } else {
2189 flags.CFlags = append(flags.CFlags, "-DGTEST_OS_LINUX_ANDROID")
Dan Albertc403f7c2015-03-18 14:01:18 -07002190 }
2191
Colin Cross21b9a242015-03-24 14:15:58 -07002192 return flags
Dan Albertc403f7c2015-03-18 14:01:18 -07002193}
2194
Colin Crossca860ac2016-01-04 14:34:37 -08002195func (test *testLinker) deps(ctx BaseModuleContext, deps Deps) Deps {
2196 if test.Properties.Gtest {
Dan Willemsen8146b2f2016-03-30 21:00:30 -07002197 if ctx.sdk() && ctx.Device() {
2198 switch ctx.selectedStl() {
2199 case "ndk_libc++_shared", "ndk_libc++_static":
2200 deps.StaticLibs = append(deps.StaticLibs, "libgtest_main_ndk_libcxx", "libgtest_ndk_libcxx")
2201 case "ndk_libgnustl_static":
2202 deps.StaticLibs = append(deps.StaticLibs, "libgtest_main_ndk_gnustl", "libgtest_ndk_gnustl")
2203 default:
2204 deps.StaticLibs = append(deps.StaticLibs, "libgtest_main_ndk", "libgtest_ndk")
2205 }
2206 } else {
2207 deps.StaticLibs = append(deps.StaticLibs, "libgtest_main", "libgtest")
2208 }
Dan Willemsen10d52fd2015-12-21 15:25:58 -08002209 }
Colin Crossc7a38dc2016-07-12 13:13:09 -07002210 return deps
2211}
2212
2213type testBinaryLinker struct {
2214 testLinker
2215 binaryLinker
2216}
2217
2218func (test *testBinaryLinker) begin(ctx BaseModuleContext) {
2219 test.binaryLinker.begin(ctx)
2220 runpath := "../../lib"
2221 if ctx.toolchain().Is64Bit() {
2222 runpath += "64"
2223 }
2224 test.dynamicProperties.RunPaths = append([]string{runpath}, test.dynamicProperties.RunPaths...)
2225}
2226
2227func (test *testBinaryLinker) props() []interface{} {
2228 return append(test.binaryLinker.props(), &test.testLinker.Properties)
2229}
2230
2231func (test *testBinaryLinker) flags(ctx ModuleContext, flags Flags) Flags {
2232 flags = test.binaryLinker.flags(ctx, flags)
2233 flags = test.testLinker.flags(ctx, flags)
2234 return flags
2235}
2236
2237func (test *testBinaryLinker) deps(ctx BaseModuleContext, deps Deps) Deps {
2238 deps = test.testLinker.deps(ctx, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08002239 deps = test.binaryLinker.deps(ctx, deps)
2240 return deps
Dan Albertc403f7c2015-03-18 14:01:18 -07002241}
2242
Colin Crossc7a38dc2016-07-12 13:13:09 -07002243type testLibraryLinker struct {
2244 testLinker
2245 *libraryLinker
2246}
2247
2248func (test *testLibraryLinker) props() []interface{} {
2249 return append(test.libraryLinker.props(), &test.testLinker.Properties)
2250}
2251
2252func (test *testLibraryLinker) flags(ctx ModuleContext, flags Flags) Flags {
2253 flags = test.libraryLinker.flags(ctx, flags)
2254 flags = test.testLinker.flags(ctx, flags)
2255 return flags
2256}
2257
2258func (test *testLibraryLinker) deps(ctx BaseModuleContext, deps Deps) Deps {
2259 deps = test.testLinker.deps(ctx, deps)
2260 deps = test.libraryLinker.deps(ctx, deps)
2261 return deps
2262}
2263
Colin Crossca860ac2016-01-04 14:34:37 -08002264type testInstaller struct {
2265 baseInstaller
Dan Willemsen782a2d12015-12-21 14:55:28 -08002266}
2267
Colin Cross635c3b02016-05-18 15:37:25 -07002268func (installer *testInstaller) install(ctx ModuleContext, file android.Path) {
Colin Crossca860ac2016-01-04 14:34:37 -08002269 installer.dir = filepath.Join(installer.dir, ctx.ModuleName())
2270 installer.dir64 = filepath.Join(installer.dir64, ctx.ModuleName())
2271 installer.baseInstaller.install(ctx, file)
2272}
2273
Colin Cross635c3b02016-05-18 15:37:25 -07002274func NewTest(hod android.HostOrDeviceSupported) *Module {
2275 module := newModule(hod, android.MultilibBoth)
Colin Crossca860ac2016-01-04 14:34:37 -08002276 module.compiler = &baseCompiler{}
Colin Crossc7a38dc2016-07-12 13:13:09 -07002277 linker := &testBinaryLinker{}
2278 linker.testLinker.Properties.Gtest = true
Colin Crossca860ac2016-01-04 14:34:37 -08002279 module.linker = linker
2280 module.installer = &testInstaller{
2281 baseInstaller: baseInstaller{
2282 dir: "nativetest",
2283 dir64: "nativetest64",
2284 data: true,
2285 },
Dan Albertc403f7c2015-03-18 14:01:18 -07002286 }
Colin Crossca860ac2016-01-04 14:34:37 -08002287 return module
Dan Willemsen10d52fd2015-12-21 15:25:58 -08002288}
2289
Colin Crossca860ac2016-01-04 14:34:37 -08002290func testFactory() (blueprint.Module, []interface{}) {
Colin Cross635c3b02016-05-18 15:37:25 -07002291 module := NewTest(android.HostAndDeviceSupported)
Colin Crossca860ac2016-01-04 14:34:37 -08002292 return module.Init()
Dan Albertc403f7c2015-03-18 14:01:18 -07002293}
2294
Colin Crossc7a38dc2016-07-12 13:13:09 -07002295func NewTestLibrary(hod android.HostOrDeviceSupported) *Module {
2296 module := NewLibrary(android.HostAndDeviceSupported, false, true)
2297 linker := &testLibraryLinker{
2298 libraryLinker: module.linker.(*libraryLinker),
2299 }
2300 linker.testLinker.Properties.Gtest = true
2301 module.linker = linker
2302 module.installer = &testInstaller{
2303 baseInstaller: baseInstaller{
2304 dir: "nativetest",
2305 dir64: "nativetest64",
2306 data: true,
2307 },
2308 }
2309 return module
2310}
2311
2312func testLibraryFactory() (blueprint.Module, []interface{}) {
2313 module := NewTestLibrary(android.HostAndDeviceSupported)
2314 return module.Init()
2315}
2316
Colin Crossca860ac2016-01-04 14:34:37 -08002317type benchmarkLinker struct {
Colin Crossaa3bf372016-07-14 10:27:10 -07002318 testBinaryLinker
Colin Cross9ffb4f52015-04-24 17:48:09 -07002319}
2320
Colin Crossca860ac2016-01-04 14:34:37 -08002321func (benchmark *benchmarkLinker) deps(ctx BaseModuleContext, deps Deps) Deps {
Colin Crossaa3bf372016-07-14 10:27:10 -07002322 deps = benchmark.testBinaryLinker.deps(ctx, deps)
Colin Cross26832742016-07-11 14:57:56 -07002323 deps.StaticLibs = append(deps.StaticLibs, "libgoogle-benchmark")
Colin Crossca860ac2016-01-04 14:34:37 -08002324 return deps
Colin Cross9ffb4f52015-04-24 17:48:09 -07002325}
2326
Colin Cross635c3b02016-05-18 15:37:25 -07002327func NewBenchmark(hod android.HostOrDeviceSupported) *Module {
2328 module := newModule(hod, android.MultilibFirst)
Colin Crossca860ac2016-01-04 14:34:37 -08002329 module.compiler = &baseCompiler{}
2330 module.linker = &benchmarkLinker{}
Colin Cross624b8ed2016-07-11 17:20:09 -07002331 module.installer = &testInstaller{
2332 baseInstaller: baseInstaller{
2333 dir: "nativetest",
2334 dir64: "nativetest64",
2335 data: true,
2336 },
Colin Cross2ba19d92015-05-07 15:44:20 -07002337 }
Colin Crossca860ac2016-01-04 14:34:37 -08002338 return module
Colin Cross2ba19d92015-05-07 15:44:20 -07002339}
2340
Colin Crossca860ac2016-01-04 14:34:37 -08002341func benchmarkFactory() (blueprint.Module, []interface{}) {
Colin Cross635c3b02016-05-18 15:37:25 -07002342 module := NewBenchmark(android.HostAndDeviceSupported)
Colin Crossca860ac2016-01-04 14:34:37 -08002343 return module.Init()
Colin Cross2ba19d92015-05-07 15:44:20 -07002344}
2345
Colin Cross3f40fa42015-01-30 17:27:36 -08002346//
2347// Static library
2348//
2349
Colin Crossca860ac2016-01-04 14:34:37 -08002350func libraryStaticFactory() (blueprint.Module, []interface{}) {
Colin Cross635c3b02016-05-18 15:37:25 -07002351 module := NewLibrary(android.HostAndDeviceSupported, false, true)
Colin Crossca860ac2016-01-04 14:34:37 -08002352 return module.Init()
Colin Cross3f40fa42015-01-30 17:27:36 -08002353}
2354
2355//
2356// Shared libraries
2357//
2358
Colin Crossca860ac2016-01-04 14:34:37 -08002359func librarySharedFactory() (blueprint.Module, []interface{}) {
Colin Cross635c3b02016-05-18 15:37:25 -07002360 module := NewLibrary(android.HostAndDeviceSupported, true, false)
Colin Crossca860ac2016-01-04 14:34:37 -08002361 return module.Init()
Colin Cross3f40fa42015-01-30 17:27:36 -08002362}
2363
2364//
2365// Host static library
2366//
2367
Colin Crossca860ac2016-01-04 14:34:37 -08002368func libraryHostStaticFactory() (blueprint.Module, []interface{}) {
Colin Cross635c3b02016-05-18 15:37:25 -07002369 module := NewLibrary(android.HostSupported, false, true)
Colin Crossca860ac2016-01-04 14:34:37 -08002370 return module.Init()
Colin Cross3f40fa42015-01-30 17:27:36 -08002371}
2372
2373//
2374// Host Shared libraries
2375//
2376
Colin Crossca860ac2016-01-04 14:34:37 -08002377func libraryHostSharedFactory() (blueprint.Module, []interface{}) {
Colin Cross635c3b02016-05-18 15:37:25 -07002378 module := NewLibrary(android.HostSupported, true, false)
Colin Crossca860ac2016-01-04 14:34:37 -08002379 return module.Init()
Colin Cross3f40fa42015-01-30 17:27:36 -08002380}
2381
2382//
2383// Host Binaries
2384//
2385
Colin Crossca860ac2016-01-04 14:34:37 -08002386func binaryHostFactory() (blueprint.Module, []interface{}) {
Colin Cross635c3b02016-05-18 15:37:25 -07002387 module := NewBinary(android.HostSupported)
Colin Crossca860ac2016-01-04 14:34:37 -08002388 return module.Init()
Colin Cross3f40fa42015-01-30 17:27:36 -08002389}
2390
2391//
Colin Cross1f8f2342015-03-26 16:09:47 -07002392// Host Tests
2393//
2394
Colin Crossca860ac2016-01-04 14:34:37 -08002395func testHostFactory() (blueprint.Module, []interface{}) {
Colin Cross635c3b02016-05-18 15:37:25 -07002396 module := NewTest(android.HostSupported)
Colin Crossca860ac2016-01-04 14:34:37 -08002397 return module.Init()
Colin Cross1f8f2342015-03-26 16:09:47 -07002398}
2399
2400//
Colin Cross2ba19d92015-05-07 15:44:20 -07002401// Host Benchmarks
2402//
2403
Colin Crossca860ac2016-01-04 14:34:37 -08002404func benchmarkHostFactory() (blueprint.Module, []interface{}) {
Colin Cross635c3b02016-05-18 15:37:25 -07002405 module := NewBenchmark(android.HostSupported)
Colin Crossca860ac2016-01-04 14:34:37 -08002406 return module.Init()
Colin Cross2ba19d92015-05-07 15:44:20 -07002407}
2408
2409//
Colin Crosscfad1192015-11-02 16:43:11 -08002410// Defaults
2411//
Colin Crossca860ac2016-01-04 14:34:37 -08002412type Defaults struct {
Colin Cross635c3b02016-05-18 15:37:25 -07002413 android.ModuleBase
2414 android.DefaultsModule
Colin Crosscfad1192015-11-02 16:43:11 -08002415}
2416
Colin Cross635c3b02016-05-18 15:37:25 -07002417func (*Defaults) GenerateAndroidBuildActions(ctx android.ModuleContext) {
Colin Crosscfad1192015-11-02 16:43:11 -08002418}
2419
Colin Crossca860ac2016-01-04 14:34:37 -08002420func defaultsFactory() (blueprint.Module, []interface{}) {
2421 module := &Defaults{}
Colin Crosscfad1192015-11-02 16:43:11 -08002422
2423 propertyStructs := []interface{}{
Colin Crossca860ac2016-01-04 14:34:37 -08002424 &BaseProperties{},
2425 &BaseCompilerProperties{},
2426 &BaseLinkerProperties{},
2427 &LibraryCompilerProperties{},
Colin Cross919281a2016-04-05 16:42:05 -07002428 &FlagExporterProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08002429 &LibraryLinkerProperties{},
2430 &BinaryLinkerProperties{},
2431 &TestLinkerProperties{},
2432 &UnusedProperties{},
2433 &StlProperties{},
Colin Cross16b23492016-01-06 14:41:07 -08002434 &SanitizeProperties{},
Colin Cross665dce92016-04-28 14:50:03 -07002435 &StripProperties{},
Colin Crosscfad1192015-11-02 16:43:11 -08002436 }
2437
Colin Cross635c3b02016-05-18 15:37:25 -07002438 _, propertyStructs = android.InitAndroidArchModule(module, android.HostAndDeviceDefault,
2439 android.MultilibDefault, propertyStructs...)
Colin Crosscfad1192015-11-02 16:43:11 -08002440
Colin Cross635c3b02016-05-18 15:37:25 -07002441 return android.InitDefaultsModule(module, module, propertyStructs...)
Colin Crosscfad1192015-11-02 16:43:11 -08002442}
2443
2444//
Colin Cross3f40fa42015-01-30 17:27:36 -08002445// Device libraries shipped with gcc
2446//
2447
Colin Crossca860ac2016-01-04 14:34:37 -08002448type toolchainLibraryLinker struct {
2449 baseLinker
Colin Cross3f40fa42015-01-30 17:27:36 -08002450}
2451
Colin Crossca860ac2016-01-04 14:34:37 -08002452var _ baseLinkerInterface = (*toolchainLibraryLinker)(nil)
2453
2454func (*toolchainLibraryLinker) deps(ctx BaseModuleContext, deps Deps) Deps {
Colin Cross3f40fa42015-01-30 17:27:36 -08002455 // toolchain libraries can't have any dependencies
Colin Crossca860ac2016-01-04 14:34:37 -08002456 return deps
Colin Cross3f40fa42015-01-30 17:27:36 -08002457}
2458
Colin Crossca860ac2016-01-04 14:34:37 -08002459func (*toolchainLibraryLinker) buildStatic() bool {
2460 return true
2461}
Colin Cross3f40fa42015-01-30 17:27:36 -08002462
Colin Crossca860ac2016-01-04 14:34:37 -08002463func (*toolchainLibraryLinker) buildShared() bool {
2464 return false
2465}
2466
2467func toolchainLibraryFactory() (blueprint.Module, []interface{}) {
Colin Cross635c3b02016-05-18 15:37:25 -07002468 module := newBaseModule(android.DeviceSupported, android.MultilibBoth)
Colin Crossca860ac2016-01-04 14:34:37 -08002469 module.compiler = &baseCompiler{}
2470 module.linker = &toolchainLibraryLinker{}
Dan Willemsenfc9c28c2016-01-12 16:22:40 -08002471 module.Properties.Clang = proptools.BoolPtr(false)
Colin Crossca860ac2016-01-04 14:34:37 -08002472 return module.Init()
Colin Cross3f40fa42015-01-30 17:27:36 -08002473}
2474
Colin Crossca860ac2016-01-04 14:34:37 -08002475func (library *toolchainLibraryLinker) link(ctx ModuleContext,
Colin Cross635c3b02016-05-18 15:37:25 -07002476 flags Flags, deps PathDeps, objFiles android.Paths) android.Path {
Colin Cross3f40fa42015-01-30 17:27:36 -08002477
2478 libName := ctx.ModuleName() + staticLibraryExtension
Colin Cross635c3b02016-05-18 15:37:25 -07002479 outputFile := android.PathForModuleOut(ctx, libName)
Colin Cross3f40fa42015-01-30 17:27:36 -08002480
Dan Willemsenfc9c28c2016-01-12 16:22:40 -08002481 if flags.Clang {
2482 ctx.ModuleErrorf("toolchain_library must use GCC, not Clang")
2483 }
2484
Colin Crossca860ac2016-01-04 14:34:37 -08002485 CopyGccLib(ctx, libName, flagsToBuilderFlags(flags), outputFile)
Colin Cross3f40fa42015-01-30 17:27:36 -08002486
2487 ctx.CheckbuildFile(outputFile)
Colin Cross3f40fa42015-01-30 17:27:36 -08002488
Colin Crossca860ac2016-01-04 14:34:37 -08002489 return outputFile
Dan Albertc403f7c2015-03-18 14:01:18 -07002490}
2491
Colin Crossc99deeb2016-04-11 15:06:20 -07002492func (*toolchainLibraryLinker) installable() bool {
2493 return false
2494}
2495
Dan Albertbe961682015-03-18 23:38:50 -07002496// NDK prebuilt libraries.
2497//
2498// These differ from regular prebuilts in that they aren't stripped and usually aren't installed
2499// either (with the exception of the shared STLs, which are installed to the app's directory rather
2500// than to the system image).
2501
Colin Cross635c3b02016-05-18 15:37:25 -07002502func getNdkLibDir(ctx android.ModuleContext, toolchain Toolchain, version string) android.SourcePath {
Colin Crossc7fd91a2016-05-17 13:15:15 -07002503 suffix := ""
2504 // Most 64-bit NDK prebuilts store libraries in "lib64", except for arm64 which is not a
2505 // multilib toolchain and stores the libraries in "lib".
Colin Cross635c3b02016-05-18 15:37:25 -07002506 if toolchain.Is64Bit() && ctx.Arch().ArchType != android.Arm64 {
Colin Crossc7fd91a2016-05-17 13:15:15 -07002507 suffix = "64"
2508 }
Colin Cross635c3b02016-05-18 15:37:25 -07002509 return android.PathForSource(ctx, fmt.Sprintf("prebuilts/ndk/current/platforms/android-%s/arch-%s/usr/lib%s",
Colin Crossc7fd91a2016-05-17 13:15:15 -07002510 version, toolchain.Name(), suffix))
Dan Albertbe961682015-03-18 23:38:50 -07002511}
2512
Colin Cross635c3b02016-05-18 15:37:25 -07002513func ndkPrebuiltModuleToPath(ctx android.ModuleContext, toolchain Toolchain,
2514 ext string, version string) android.Path {
Dan Albertc3144b12015-04-28 18:17:56 -07002515
2516 // NDK prebuilts are named like: ndk_NAME.EXT.SDK_VERSION.
2517 // We want to translate to just NAME.EXT
2518 name := strings.Split(strings.TrimPrefix(ctx.ModuleName(), "ndk_"), ".")[0]
2519 dir := getNdkLibDir(ctx, toolchain, version)
Dan Willemsen34cc69e2015-09-23 15:26:20 -07002520 return dir.Join(ctx, name+ext)
Dan Albertc3144b12015-04-28 18:17:56 -07002521}
2522
Colin Crossca860ac2016-01-04 14:34:37 -08002523type ndkPrebuiltObjectLinker struct {
2524 objectLinker
Dan Albertc3144b12015-04-28 18:17:56 -07002525}
2526
Colin Crossca860ac2016-01-04 14:34:37 -08002527func (*ndkPrebuiltObjectLinker) deps(ctx BaseModuleContext, deps Deps) Deps {
Dan Albertc3144b12015-04-28 18:17:56 -07002528 // NDK objects can't have any dependencies
Colin Crossca860ac2016-01-04 14:34:37 -08002529 return deps
Dan Albertc3144b12015-04-28 18:17:56 -07002530}
2531
Colin Crossca860ac2016-01-04 14:34:37 -08002532func ndkPrebuiltObjectFactory() (blueprint.Module, []interface{}) {
Colin Cross635c3b02016-05-18 15:37:25 -07002533 module := newBaseModule(android.DeviceSupported, android.MultilibBoth)
Colin Crossca860ac2016-01-04 14:34:37 -08002534 module.linker = &ndkPrebuiltObjectLinker{}
Dan Willemsen72d39932016-07-08 23:23:48 -07002535 module.Properties.HideFromMake = true
Colin Crossca860ac2016-01-04 14:34:37 -08002536 return module.Init()
Dan Albertc3144b12015-04-28 18:17:56 -07002537}
2538
Colin Crossca860ac2016-01-04 14:34:37 -08002539func (c *ndkPrebuiltObjectLinker) link(ctx ModuleContext, flags Flags,
Colin Cross635c3b02016-05-18 15:37:25 -07002540 deps PathDeps, objFiles android.Paths) android.Path {
Dan Albertc3144b12015-04-28 18:17:56 -07002541 // A null build step, but it sets up the output path.
2542 if !strings.HasPrefix(ctx.ModuleName(), "ndk_crt") {
2543 ctx.ModuleErrorf("NDK prebuilts must have an ndk_crt prefixed name")
2544 }
2545
Colin Crossca860ac2016-01-04 14:34:37 -08002546 return ndkPrebuiltModuleToPath(ctx, flags.Toolchain, objectExtension, ctx.sdkVersion())
Dan Albertc3144b12015-04-28 18:17:56 -07002547}
2548
Colin Crossca860ac2016-01-04 14:34:37 -08002549type ndkPrebuiltLibraryLinker struct {
2550 libraryLinker
Dan Albertc3144b12015-04-28 18:17:56 -07002551}
2552
Colin Crossca860ac2016-01-04 14:34:37 -08002553var _ baseLinkerInterface = (*ndkPrebuiltLibraryLinker)(nil)
2554var _ exportedFlagsProducer = (*libraryLinker)(nil)
Dan Albertc3144b12015-04-28 18:17:56 -07002555
Colin Crossca860ac2016-01-04 14:34:37 -08002556func (ndk *ndkPrebuiltLibraryLinker) props() []interface{} {
Colin Cross919281a2016-04-05 16:42:05 -07002557 return append(ndk.libraryLinker.props(), &ndk.Properties, &ndk.flagExporter.Properties)
Dan Albertbe961682015-03-18 23:38:50 -07002558}
2559
Colin Crossca860ac2016-01-04 14:34:37 -08002560func (*ndkPrebuiltLibraryLinker) deps(ctx BaseModuleContext, deps Deps) Deps {
Dan Albertbe961682015-03-18 23:38:50 -07002561 // NDK libraries can't have any dependencies
Colin Crossca860ac2016-01-04 14:34:37 -08002562 return deps
Dan Albertbe961682015-03-18 23:38:50 -07002563}
2564
Colin Crossca860ac2016-01-04 14:34:37 -08002565func ndkPrebuiltLibraryFactory() (blueprint.Module, []interface{}) {
Colin Cross635c3b02016-05-18 15:37:25 -07002566 module := newBaseModule(android.DeviceSupported, android.MultilibBoth)
Colin Crossca860ac2016-01-04 14:34:37 -08002567 linker := &ndkPrebuiltLibraryLinker{}
2568 linker.dynamicProperties.BuildShared = true
2569 module.linker = linker
Dan Willemsen72d39932016-07-08 23:23:48 -07002570 module.Properties.HideFromMake = true
Colin Crossca860ac2016-01-04 14:34:37 -08002571 return module.Init()
Dan Albertbe961682015-03-18 23:38:50 -07002572}
2573
Colin Crossca860ac2016-01-04 14:34:37 -08002574func (ndk *ndkPrebuiltLibraryLinker) link(ctx ModuleContext, flags Flags,
Colin Cross635c3b02016-05-18 15:37:25 -07002575 deps PathDeps, objFiles android.Paths) android.Path {
Dan Albertbe961682015-03-18 23:38:50 -07002576 // A null build step, but it sets up the output path.
2577 if !strings.HasPrefix(ctx.ModuleName(), "ndk_lib") {
2578 ctx.ModuleErrorf("NDK prebuilts must have an ndk_lib prefixed name")
2579 }
2580
Colin Cross919281a2016-04-05 16:42:05 -07002581 ndk.exportIncludes(ctx, "-isystem")
Dan Albertbe961682015-03-18 23:38:50 -07002582
Colin Crossca860ac2016-01-04 14:34:37 -08002583 return ndkPrebuiltModuleToPath(ctx, flags.Toolchain, flags.Toolchain.ShlibSuffix(),
2584 ctx.sdkVersion())
Dan Albertbe961682015-03-18 23:38:50 -07002585}
2586
2587// The NDK STLs are slightly different from the prebuilt system libraries:
2588// * Are not specific to each platform version.
2589// * The libraries are not in a predictable location for each STL.
2590
Colin Crossca860ac2016-01-04 14:34:37 -08002591type ndkPrebuiltStlLinker struct {
2592 ndkPrebuiltLibraryLinker
Dan Albertbe961682015-03-18 23:38:50 -07002593}
2594
Colin Crossca860ac2016-01-04 14:34:37 -08002595func ndkPrebuiltSharedStlFactory() (blueprint.Module, []interface{}) {
Colin Cross635c3b02016-05-18 15:37:25 -07002596 module := newBaseModule(android.DeviceSupported, android.MultilibBoth)
Colin Crossca860ac2016-01-04 14:34:37 -08002597 linker := &ndkPrebuiltStlLinker{}
2598 linker.dynamicProperties.BuildShared = true
2599 module.linker = linker
Dan Willemsen72d39932016-07-08 23:23:48 -07002600 module.Properties.HideFromMake = true
Colin Crossca860ac2016-01-04 14:34:37 -08002601 return module.Init()
Dan Albertbe961682015-03-18 23:38:50 -07002602}
2603
Colin Crossca860ac2016-01-04 14:34:37 -08002604func ndkPrebuiltStaticStlFactory() (blueprint.Module, []interface{}) {
Colin Cross635c3b02016-05-18 15:37:25 -07002605 module := newBaseModule(android.DeviceSupported, android.MultilibBoth)
Colin Crossca860ac2016-01-04 14:34:37 -08002606 linker := &ndkPrebuiltStlLinker{}
2607 linker.dynamicProperties.BuildStatic = true
2608 module.linker = linker
Dan Willemsen72d39932016-07-08 23:23:48 -07002609 module.Properties.HideFromMake = true
Colin Crossca860ac2016-01-04 14:34:37 -08002610 return module.Init()
Dan Albertbe961682015-03-18 23:38:50 -07002611}
2612
Colin Cross635c3b02016-05-18 15:37:25 -07002613func getNdkStlLibDir(ctx android.ModuleContext, toolchain Toolchain, stl string) android.SourcePath {
Dan Albertbe961682015-03-18 23:38:50 -07002614 gccVersion := toolchain.GccVersion()
2615 var libDir string
2616 switch stl {
2617 case "libstlport":
2618 libDir = "cxx-stl/stlport/libs"
2619 case "libc++":
2620 libDir = "cxx-stl/llvm-libc++/libs"
2621 case "libgnustl":
2622 libDir = fmt.Sprintf("cxx-stl/gnu-libstdc++/%s/libs", gccVersion)
2623 }
2624
2625 if libDir != "" {
Dan Willemsen34cc69e2015-09-23 15:26:20 -07002626 ndkSrcRoot := "prebuilts/ndk/current/sources"
Colin Cross635c3b02016-05-18 15:37:25 -07002627 return android.PathForSource(ctx, ndkSrcRoot).Join(ctx, libDir, ctx.Arch().Abi[0])
Dan Albertbe961682015-03-18 23:38:50 -07002628 }
2629
2630 ctx.ModuleErrorf("Unknown NDK STL: %s", stl)
Colin Cross635c3b02016-05-18 15:37:25 -07002631 return android.PathForSource(ctx, "")
Dan Albertbe961682015-03-18 23:38:50 -07002632}
2633
Colin Crossca860ac2016-01-04 14:34:37 -08002634func (ndk *ndkPrebuiltStlLinker) link(ctx ModuleContext, flags Flags,
Colin Cross635c3b02016-05-18 15:37:25 -07002635 deps PathDeps, objFiles android.Paths) android.Path {
Dan Albertbe961682015-03-18 23:38:50 -07002636 // A null build step, but it sets up the output path.
2637 if !strings.HasPrefix(ctx.ModuleName(), "ndk_lib") {
2638 ctx.ModuleErrorf("NDK prebuilts must have an ndk_lib prefixed name")
2639 }
2640
Colin Cross919281a2016-04-05 16:42:05 -07002641 ndk.exportIncludes(ctx, "-I")
Dan Albertbe961682015-03-18 23:38:50 -07002642
2643 libName := strings.TrimPrefix(ctx.ModuleName(), "ndk_")
Dan Willemsen490fd492015-11-24 17:53:15 -08002644 libExt := flags.Toolchain.ShlibSuffix()
Colin Crossca860ac2016-01-04 14:34:37 -08002645 if ndk.dynamicProperties.BuildStatic {
Dan Albertbe961682015-03-18 23:38:50 -07002646 libExt = staticLibraryExtension
2647 }
2648
2649 stlName := strings.TrimSuffix(libName, "_shared")
2650 stlName = strings.TrimSuffix(stlName, "_static")
2651 libDir := getNdkStlLibDir(ctx, flags.Toolchain, stlName)
Colin Crossca860ac2016-01-04 14:34:37 -08002652 return libDir.Join(ctx, libName+libExt)
Dan Albertbe961682015-03-18 23:38:50 -07002653}
2654
Colin Cross635c3b02016-05-18 15:37:25 -07002655func linkageMutator(mctx android.BottomUpMutatorContext) {
Colin Crossca860ac2016-01-04 14:34:37 -08002656 if m, ok := mctx.Module().(*Module); ok {
2657 if m.linker != nil {
2658 if linker, ok := m.linker.(baseLinkerInterface); ok {
2659 var modules []blueprint.Module
2660 if linker.buildStatic() && linker.buildShared() {
2661 modules = mctx.CreateLocalVariations("static", "shared")
Colin Crossc99deeb2016-04-11 15:06:20 -07002662 static := modules[0].(*Module)
2663 shared := modules[1].(*Module)
2664
2665 static.linker.(baseLinkerInterface).setStatic(true)
2666 shared.linker.(baseLinkerInterface).setStatic(false)
2667
2668 if staticCompiler, ok := static.compiler.(*libraryCompiler); ok {
2669 sharedCompiler := shared.compiler.(*libraryCompiler)
2670 if len(staticCompiler.Properties.Static.Cflags) == 0 &&
2671 len(sharedCompiler.Properties.Shared.Cflags) == 0 {
2672 // Optimize out compiling common .o files twice for static+shared libraries
2673 mctx.AddInterVariantDependency(reuseObjTag, shared, static)
2674 sharedCompiler.baseCompiler.Properties.Srcs = nil
2675 }
2676 }
Colin Crossca860ac2016-01-04 14:34:37 -08002677 } else if linker.buildStatic() {
2678 modules = mctx.CreateLocalVariations("static")
2679 modules[0].(*Module).linker.(baseLinkerInterface).setStatic(true)
2680 } else if linker.buildShared() {
2681 modules = mctx.CreateLocalVariations("shared")
2682 modules[0].(*Module).linker.(baseLinkerInterface).setStatic(false)
2683 } else {
2684 panic(fmt.Errorf("library %q not static or shared", mctx.ModuleName()))
2685 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002686 }
2687 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002688 }
2689}
Colin Cross74d1ec02015-04-28 13:30:13 -07002690
2691// lastUniqueElements returns all unique elements of a slice, keeping the last copy of each
2692// modifies the slice contents in place, and returns a subslice of the original slice
2693func lastUniqueElements(list []string) []string {
2694 totalSkip := 0
2695 for i := len(list) - 1; i >= totalSkip; i-- {
2696 skip := 0
2697 for j := i - 1; j >= totalSkip; j-- {
2698 if list[i] == list[j] {
2699 skip++
2700 } else {
2701 list[j+skip] = list[j]
2702 }
2703 }
2704 totalSkip += skip
2705 }
2706 return list[totalSkip:]
2707}
Colin Cross06a931b2015-10-28 17:23:31 -07002708
2709var Bool = proptools.Bool