blob: 37ce2687b2c35571656cb1db90734e583cefe60a [file] [log] [blame]
Dan Albert914449f2016-06-17 16:45:24 -07001// Copyright 2016 Google Inc. All rights reserved.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15package cc
16
17import (
18 "fmt"
19 "strconv"
20 "strings"
Colin Crosse8a67a72016-08-07 21:17:54 -070021 "sync"
Dan Albert914449f2016-06-17 16:45:24 -070022
23 "github.com/google/blueprint"
24
25 "android/soong/android"
26)
27
28var (
29 toolPath = pctx.SourcePathVariable("toolPath", "build/soong/cc/gen_stub_libs.py")
30
Colin Cross9d45bb72016-08-29 16:14:13 -070031 genStubSrc = pctx.AndroidStaticRule("genStubSrc",
Dan Albert914449f2016-06-17 16:45:24 -070032 blueprint.RuleParams{
33 Command: "$toolPath --arch $arch --api $apiLevel $in $out",
34 Description: "genStubSrc $out",
35 CommandDeps: []string{"$toolPath"},
36 }, "arch", "apiLevel")
37
38 ndkLibrarySuffix = ".ndk"
Colin Cross4d9c2d12016-07-29 12:48:20 -070039
40 ndkPrebuiltSharedLibs = []string{
41 "android",
42 "c",
43 "dl",
44 "EGL",
45 "GLESv1_CM",
46 "GLESv2",
47 "GLESv3",
48 "jnigraphics",
49 "log",
50 "mediandk",
51 "m",
52 "OpenMAXAL",
53 "OpenSLES",
54 "stdc++",
55 "vulkan",
56 "z",
57 }
58 ndkPrebuiltSharedLibraries = addPrefix(append([]string(nil), ndkPrebuiltSharedLibs...), "lib")
59
60 // These libraries have migrated over to the new ndk_library, which is added
61 // as a variation dependency via depsMutator.
Colin Crosse8a67a72016-08-07 21:17:54 -070062 ndkMigratedLibs = []string{}
63 ndkMigratedLibsLock sync.Mutex // protects ndkMigratedLibs writes during parallel beginMutator
Dan Albert914449f2016-06-17 16:45:24 -070064)
65
66// Creates a stub shared library based on the provided version file.
67//
68// The name of the generated file will be based on the module name by stripping
69// the ".ndk" suffix from the module name. Module names must end with ".ndk"
70// (as a convention to allow soong to guess the NDK name of a dependency when
71// needed). "libfoo.ndk" will generate "libfoo.so.
72//
73// Example:
74//
75// ndk_library {
76// name: "libfoo.ndk",
77// symbol_file: "libfoo.map.txt",
78// first_version: "9",
79// }
80//
81type libraryProperties struct {
82 // Relative path to the symbol map.
83 // An example file can be seen here: TODO(danalbert): Make an example.
84 Symbol_file string
85
86 // The first API level a library was available. A library will be generated
87 // for every API level beginning with this one.
88 First_version string
89
90 // Private property for use by the mutator that splits per-API level.
91 ApiLevel int `blueprint:"mutated"`
92}
93
Colin Crossb916a382016-07-29 17:28:03 -070094type stubDecorator struct {
95 *libraryDecorator
Dan Albert914449f2016-06-17 16:45:24 -070096
97 properties libraryProperties
Dan Albert2bc91ba2016-07-28 17:40:28 -070098
Colin Crossb916a382016-07-29 17:28:03 -070099 versionScriptPath android.ModuleGenPath
100 installPath string
Dan Albert914449f2016-06-17 16:45:24 -0700101}
102
103// OMG GO
Dan Albert7fa7b2e2016-08-05 16:37:52 -0700104func intMax(a int, b int) int {
105 if a > b {
Dan Albert914449f2016-06-17 16:45:24 -0700106 return a
107 } else {
108 return b
109 }
110}
111
Dan Albert7fa7b2e2016-08-05 16:37:52 -0700112func normalizeNdkApiLevel(apiLevel string, arch android.Arch) (int, error) {
Dan Albert914449f2016-06-17 16:45:24 -0700113 minVersion := 9 // Minimum version supported by the NDK.
Dan Albert914449f2016-06-17 16:45:24 -0700114 firstArchVersions := map[string]int{
115 "arm": 9,
116 "arm64": 21,
117 "mips": 9,
118 "mips64": 21,
119 "x86": 9,
120 "x86_64": 21,
121 }
122
123 // If the NDK drops support for a platform version, we don't want to have to
Dan Albert7fa7b2e2016-08-05 16:37:52 -0700124 // fix up every module that was using it as its SDK version. Clip to the
Dan Albert914449f2016-06-17 16:45:24 -0700125 // supported version here instead.
Dan Albert7fa7b2e2016-08-05 16:37:52 -0700126 version, err := strconv.Atoi(apiLevel)
Dan Albert914449f2016-06-17 16:45:24 -0700127 if err != nil {
Dan Albert7fa7b2e2016-08-05 16:37:52 -0700128 return -1, fmt.Errorf("API level must be an integer (is %q)", apiLevel)
Dan Albert914449f2016-06-17 16:45:24 -0700129 }
Dan Albert7fa7b2e2016-08-05 16:37:52 -0700130 version = intMax(version, minVersion)
131
132 archStr := arch.ArchType.String()
133 firstArchVersion, ok := firstArchVersions[archStr]
134 if !ok {
135 panic(fmt.Errorf("Arch %q not found in firstArchVersions", archStr))
Dan Albert914449f2016-06-17 16:45:24 -0700136 }
137
Dan Albert7fa7b2e2016-08-05 16:37:52 -0700138 return intMax(version, firstArchVersion), nil
139}
140
141func generateStubApiVariants(mctx android.BottomUpMutatorContext, c *stubDecorator) {
142 // TODO(danalbert): Use PlatformSdkVersion when possible.
143 // This is an interesting case because for the moment we actually need 24
144 // even though the latest released version in aosp is 23. prebuilts/ndk/r11
145 // has android-24 versions of libraries, and as platform libraries get
146 // migrated the libraries in prebuilts will need to depend on them.
147 //
148 // Once everything is all moved over to the new stuff (when there isn't a
149 // prebuilts/ndk any more) then this should be fixable, but for now I think
150 // it needs to remain as-is.
151 maxVersion := 24
152
153 firstVersion, err := normalizeNdkApiLevel(c.properties.First_version,
154 mctx.Arch())
155 if err != nil {
156 mctx.PropertyErrorf("first_version", err.Error())
Dan Albert914449f2016-06-17 16:45:24 -0700157 }
Dan Albert7fa7b2e2016-08-05 16:37:52 -0700158
159 versionStrs := make([]string, maxVersion-firstVersion+1)
160 for version := firstVersion; version <= maxVersion; version++ {
161 versionStrs[version-firstVersion] = strconv.Itoa(version)
Dan Albert914449f2016-06-17 16:45:24 -0700162 }
163
164 modules := mctx.CreateVariations(versionStrs...)
165 for i, module := range modules {
Dan Albert7fa7b2e2016-08-05 16:37:52 -0700166 module.(*Module).compiler.(*stubDecorator).properties.ApiLevel = firstVersion + i
Dan Albert914449f2016-06-17 16:45:24 -0700167 }
168}
169
170func ndkApiMutator(mctx android.BottomUpMutatorContext) {
171 if m, ok := mctx.Module().(*Module); ok {
Colin Crossb916a382016-07-29 17:28:03 -0700172 if compiler, ok := m.compiler.(*stubDecorator); ok {
Dan Albert914449f2016-06-17 16:45:24 -0700173 generateStubApiVariants(mctx, compiler)
174 }
175 }
176}
177
Colin Crossb916a382016-07-29 17:28:03 -0700178func (c *stubDecorator) compilerInit(ctx BaseModuleContext) {
Dan Albert7e9d2952016-08-04 13:02:36 -0700179 c.baseCompiler.compilerInit(ctx)
180
181 name := strings.TrimSuffix(ctx.ModuleName(), ".ndk")
Colin Crosse8a67a72016-08-07 21:17:54 -0700182 ndkMigratedLibsLock.Lock()
183 defer ndkMigratedLibsLock.Unlock()
Dan Albert7e9d2952016-08-04 13:02:36 -0700184 for _, lib := range ndkMigratedLibs {
185 if lib == name {
186 return
187 }
188 }
189 ndkMigratedLibs = append(ndkMigratedLibs, name)
190}
191
Colin Crossb916a382016-07-29 17:28:03 -0700192func (c *stubDecorator) compile(ctx ModuleContext, flags Flags, deps PathDeps) android.Paths {
Dan Albert914449f2016-06-17 16:45:24 -0700193 arch := ctx.Arch().ArchType.String()
194
195 if !strings.HasSuffix(ctx.ModuleName(), ndkLibrarySuffix) {
196 ctx.ModuleErrorf("ndk_library modules names must be suffixed with %q\n",
197 ndkLibrarySuffix)
198 }
199 libName := strings.TrimSuffix(ctx.ModuleName(), ndkLibrarySuffix)
200 fileBase := fmt.Sprintf("%s.%s.%d", libName, arch, c.properties.ApiLevel)
201 stubSrcName := fileBase + ".c"
202 stubSrcPath := android.PathForModuleGen(ctx, stubSrcName)
203 versionScriptName := fileBase + ".map"
204 versionScriptPath := android.PathForModuleGen(ctx, versionScriptName)
Colin Crossb916a382016-07-29 17:28:03 -0700205 c.versionScriptPath = versionScriptPath
Dan Albert914449f2016-06-17 16:45:24 -0700206 symbolFilePath := android.PathForModuleSrc(ctx, c.properties.Symbol_file)
207 ctx.ModuleBuild(pctx, android.ModuleBuildParams{
208 Rule: genStubSrc,
209 Outputs: []android.WritablePath{stubSrcPath, versionScriptPath},
210 Input: symbolFilePath,
211 Args: map[string]string{
212 "arch": arch,
213 "apiLevel": strconv.Itoa(c.properties.ApiLevel),
214 },
215 })
216
217 flags.CFlags = append(flags.CFlags,
218 // We're knowingly doing some otherwise unsightly things with builtin
219 // functions here. We're just generating stub libraries, so ignore it.
220 "-Wno-incompatible-library-redeclaration",
221 "-Wno-builtin-requires-header",
222 "-Wno-invalid-noreturn",
223
224 // These libraries aren't actually used. Don't worry about unwinding
225 // (avoids the need to link an unwinder into a fake library).
226 "-fno-unwind-tables",
227 )
228
229 subdir := ""
230 srcs := []string{}
231 excludeSrcs := []string{}
232 extraSrcs := []android.Path{stubSrcPath}
233 extraDeps := []android.Path{}
Colin Crossb916a382016-07-29 17:28:03 -0700234 return compileObjs(ctx, flags, subdir, srcs, excludeSrcs,
Dan Albert914449f2016-06-17 16:45:24 -0700235 extraSrcs, extraDeps)
236}
237
Colin Crossb916a382016-07-29 17:28:03 -0700238func (linker *stubDecorator) linkerDeps(ctx BaseModuleContext, deps Deps) Deps {
Dan Albert914449f2016-06-17 16:45:24 -0700239 return Deps{}
240}
241
Colin Crossb916a382016-07-29 17:28:03 -0700242func (stub *stubDecorator) linkerFlags(ctx ModuleContext, flags Flags) Flags {
243 stub.libraryDecorator.libName = strings.TrimSuffix(ctx.ModuleName(),
Dan Albert914449f2016-06-17 16:45:24 -0700244 ndkLibrarySuffix)
Colin Crossb916a382016-07-29 17:28:03 -0700245 return stub.libraryDecorator.linkerFlags(ctx, flags)
Dan Albert914449f2016-06-17 16:45:24 -0700246}
247
Colin Crossb916a382016-07-29 17:28:03 -0700248func (stub *stubDecorator) link(ctx ModuleContext, flags Flags, deps PathDeps,
Dan Albert2bc91ba2016-07-28 17:40:28 -0700249 objFiles android.Paths) android.Path {
250
Colin Crossb916a382016-07-29 17:28:03 -0700251 linkerScriptFlag := "-Wl,--version-script," + stub.versionScriptPath.String()
Dan Albert2bc91ba2016-07-28 17:40:28 -0700252 flags.LdFlags = append(flags.LdFlags, linkerScriptFlag)
Colin Crossb916a382016-07-29 17:28:03 -0700253 return stub.libraryDecorator.link(ctx, flags, deps, objFiles)
Dan Albert2bc91ba2016-07-28 17:40:28 -0700254}
255
Colin Crossb916a382016-07-29 17:28:03 -0700256func (stub *stubDecorator) install(ctx ModuleContext, path android.Path) {
Dan Albert914449f2016-06-17 16:45:24 -0700257 arch := ctx.Target().Arch.ArchType.Name
Colin Crossb916a382016-07-29 17:28:03 -0700258 apiLevel := stub.properties.ApiLevel
Dan Albert914449f2016-06-17 16:45:24 -0700259
260 // arm64 isn't actually a multilib toolchain, so unlike the other LP64
261 // architectures it's just installed to lib.
262 libDir := "lib"
263 if ctx.toolchain().Is64Bit() && arch != "arm64" {
264 libDir = "lib64"
265 }
266
267 installDir := getNdkInstallBase(ctx).Join(ctx, fmt.Sprintf(
268 "platforms/android-%d/arch-%s/usr/%s", apiLevel, arch, libDir))
Colin Crossb916a382016-07-29 17:28:03 -0700269 stub.installPath = ctx.InstallFile(installDir, path).String()
Dan Albert914449f2016-06-17 16:45:24 -0700270}
271
Dan Albert705c84b2016-08-08 10:45:03 -0700272func newStubLibrary() (*Module, []interface{}) {
Colin Crossb916a382016-07-29 17:28:03 -0700273 module, library := NewLibrary(android.DeviceSupported, true, false)
Dan Albert914449f2016-06-17 16:45:24 -0700274 module.stl = nil
Colin Crossb916a382016-07-29 17:28:03 -0700275 module.sanitize = nil
276 library.StripProperties.Strip.None = true
Dan Albert914449f2016-06-17 16:45:24 -0700277
Colin Crossb916a382016-07-29 17:28:03 -0700278 stub := &stubDecorator{
279 libraryDecorator: library,
280 }
281 module.compiler = stub
282 module.linker = stub
283 module.installer = stub
Dan Albert914449f2016-06-17 16:45:24 -0700284
Dan Albert705c84b2016-08-08 10:45:03 -0700285 return module, []interface{}{&stub.properties}
Dan Albert914449f2016-06-17 16:45:24 -0700286}
287
288func ndkLibraryFactory() (blueprint.Module, []interface{}) {
Dan Albert705c84b2016-08-08 10:45:03 -0700289 module, properties := newStubLibrary()
290 return android.InitAndroidArchModule(module, android.DeviceSupported,
291 android.MultilibBoth, properties...)
Dan Albert914449f2016-06-17 16:45:24 -0700292}