Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 1 | // 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 | |
| 15 | package cc |
| 16 | |
| 17 | import ( |
| 18 | "fmt" |
| 19 | "strconv" |
| 20 | "strings" |
Colin Cross | e8a67a7 | 2016-08-07 21:17:54 -0700 | [diff] [blame] | 21 | "sync" |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 22 | |
| 23 | "github.com/google/blueprint" |
| 24 | |
| 25 | "android/soong/android" |
| 26 | ) |
| 27 | |
| 28 | var ( |
| 29 | toolPath = pctx.SourcePathVariable("toolPath", "build/soong/cc/gen_stub_libs.py") |
| 30 | |
Colin Cross | 9d45bb7 | 2016-08-29 16:14:13 -0700 | [diff] [blame^] | 31 | genStubSrc = pctx.AndroidStaticRule("genStubSrc", |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 32 | 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 Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 39 | |
| 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 Cross | e8a67a7 | 2016-08-07 21:17:54 -0700 | [diff] [blame] | 62 | ndkMigratedLibs = []string{} |
| 63 | ndkMigratedLibsLock sync.Mutex // protects ndkMigratedLibs writes during parallel beginMutator |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 64 | ) |
| 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 | // |
| 81 | type 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 Cross | b916a38 | 2016-07-29 17:28:03 -0700 | [diff] [blame] | 94 | type stubDecorator struct { |
| 95 | *libraryDecorator |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 96 | |
| 97 | properties libraryProperties |
Dan Albert | 2bc91ba | 2016-07-28 17:40:28 -0700 | [diff] [blame] | 98 | |
Colin Cross | b916a38 | 2016-07-29 17:28:03 -0700 | [diff] [blame] | 99 | versionScriptPath android.ModuleGenPath |
| 100 | installPath string |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 101 | } |
| 102 | |
| 103 | // OMG GO |
Dan Albert | 7fa7b2e | 2016-08-05 16:37:52 -0700 | [diff] [blame] | 104 | func intMax(a int, b int) int { |
| 105 | if a > b { |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 106 | return a |
| 107 | } else { |
| 108 | return b |
| 109 | } |
| 110 | } |
| 111 | |
Dan Albert | 7fa7b2e | 2016-08-05 16:37:52 -0700 | [diff] [blame] | 112 | func normalizeNdkApiLevel(apiLevel string, arch android.Arch) (int, error) { |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 113 | minVersion := 9 // Minimum version supported by the NDK. |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 114 | 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 Albert | 7fa7b2e | 2016-08-05 16:37:52 -0700 | [diff] [blame] | 124 | // fix up every module that was using it as its SDK version. Clip to the |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 125 | // supported version here instead. |
Dan Albert | 7fa7b2e | 2016-08-05 16:37:52 -0700 | [diff] [blame] | 126 | version, err := strconv.Atoi(apiLevel) |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 127 | if err != nil { |
Dan Albert | 7fa7b2e | 2016-08-05 16:37:52 -0700 | [diff] [blame] | 128 | return -1, fmt.Errorf("API level must be an integer (is %q)", apiLevel) |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 129 | } |
Dan Albert | 7fa7b2e | 2016-08-05 16:37:52 -0700 | [diff] [blame] | 130 | 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 Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 136 | } |
| 137 | |
Dan Albert | 7fa7b2e | 2016-08-05 16:37:52 -0700 | [diff] [blame] | 138 | return intMax(version, firstArchVersion), nil |
| 139 | } |
| 140 | |
| 141 | func 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 Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 157 | } |
Dan Albert | 7fa7b2e | 2016-08-05 16:37:52 -0700 | [diff] [blame] | 158 | |
| 159 | versionStrs := make([]string, maxVersion-firstVersion+1) |
| 160 | for version := firstVersion; version <= maxVersion; version++ { |
| 161 | versionStrs[version-firstVersion] = strconv.Itoa(version) |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 162 | } |
| 163 | |
| 164 | modules := mctx.CreateVariations(versionStrs...) |
| 165 | for i, module := range modules { |
Dan Albert | 7fa7b2e | 2016-08-05 16:37:52 -0700 | [diff] [blame] | 166 | module.(*Module).compiler.(*stubDecorator).properties.ApiLevel = firstVersion + i |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 167 | } |
| 168 | } |
| 169 | |
| 170 | func ndkApiMutator(mctx android.BottomUpMutatorContext) { |
| 171 | if m, ok := mctx.Module().(*Module); ok { |
Colin Cross | b916a38 | 2016-07-29 17:28:03 -0700 | [diff] [blame] | 172 | if compiler, ok := m.compiler.(*stubDecorator); ok { |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 173 | generateStubApiVariants(mctx, compiler) |
| 174 | } |
| 175 | } |
| 176 | } |
| 177 | |
Colin Cross | b916a38 | 2016-07-29 17:28:03 -0700 | [diff] [blame] | 178 | func (c *stubDecorator) compilerInit(ctx BaseModuleContext) { |
Dan Albert | 7e9d295 | 2016-08-04 13:02:36 -0700 | [diff] [blame] | 179 | c.baseCompiler.compilerInit(ctx) |
| 180 | |
| 181 | name := strings.TrimSuffix(ctx.ModuleName(), ".ndk") |
Colin Cross | e8a67a7 | 2016-08-07 21:17:54 -0700 | [diff] [blame] | 182 | ndkMigratedLibsLock.Lock() |
| 183 | defer ndkMigratedLibsLock.Unlock() |
Dan Albert | 7e9d295 | 2016-08-04 13:02:36 -0700 | [diff] [blame] | 184 | for _, lib := range ndkMigratedLibs { |
| 185 | if lib == name { |
| 186 | return |
| 187 | } |
| 188 | } |
| 189 | ndkMigratedLibs = append(ndkMigratedLibs, name) |
| 190 | } |
| 191 | |
Colin Cross | b916a38 | 2016-07-29 17:28:03 -0700 | [diff] [blame] | 192 | func (c *stubDecorator) compile(ctx ModuleContext, flags Flags, deps PathDeps) android.Paths { |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 193 | 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 Cross | b916a38 | 2016-07-29 17:28:03 -0700 | [diff] [blame] | 205 | c.versionScriptPath = versionScriptPath |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 206 | 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 Cross | b916a38 | 2016-07-29 17:28:03 -0700 | [diff] [blame] | 234 | return compileObjs(ctx, flags, subdir, srcs, excludeSrcs, |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 235 | extraSrcs, extraDeps) |
| 236 | } |
| 237 | |
Colin Cross | b916a38 | 2016-07-29 17:28:03 -0700 | [diff] [blame] | 238 | func (linker *stubDecorator) linkerDeps(ctx BaseModuleContext, deps Deps) Deps { |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 239 | return Deps{} |
| 240 | } |
| 241 | |
Colin Cross | b916a38 | 2016-07-29 17:28:03 -0700 | [diff] [blame] | 242 | func (stub *stubDecorator) linkerFlags(ctx ModuleContext, flags Flags) Flags { |
| 243 | stub.libraryDecorator.libName = strings.TrimSuffix(ctx.ModuleName(), |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 244 | ndkLibrarySuffix) |
Colin Cross | b916a38 | 2016-07-29 17:28:03 -0700 | [diff] [blame] | 245 | return stub.libraryDecorator.linkerFlags(ctx, flags) |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 246 | } |
| 247 | |
Colin Cross | b916a38 | 2016-07-29 17:28:03 -0700 | [diff] [blame] | 248 | func (stub *stubDecorator) link(ctx ModuleContext, flags Flags, deps PathDeps, |
Dan Albert | 2bc91ba | 2016-07-28 17:40:28 -0700 | [diff] [blame] | 249 | objFiles android.Paths) android.Path { |
| 250 | |
Colin Cross | b916a38 | 2016-07-29 17:28:03 -0700 | [diff] [blame] | 251 | linkerScriptFlag := "-Wl,--version-script," + stub.versionScriptPath.String() |
Dan Albert | 2bc91ba | 2016-07-28 17:40:28 -0700 | [diff] [blame] | 252 | flags.LdFlags = append(flags.LdFlags, linkerScriptFlag) |
Colin Cross | b916a38 | 2016-07-29 17:28:03 -0700 | [diff] [blame] | 253 | return stub.libraryDecorator.link(ctx, flags, deps, objFiles) |
Dan Albert | 2bc91ba | 2016-07-28 17:40:28 -0700 | [diff] [blame] | 254 | } |
| 255 | |
Colin Cross | b916a38 | 2016-07-29 17:28:03 -0700 | [diff] [blame] | 256 | func (stub *stubDecorator) install(ctx ModuleContext, path android.Path) { |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 257 | arch := ctx.Target().Arch.ArchType.Name |
Colin Cross | b916a38 | 2016-07-29 17:28:03 -0700 | [diff] [blame] | 258 | apiLevel := stub.properties.ApiLevel |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 259 | |
| 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 Cross | b916a38 | 2016-07-29 17:28:03 -0700 | [diff] [blame] | 269 | stub.installPath = ctx.InstallFile(installDir, path).String() |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 270 | } |
| 271 | |
Dan Albert | 705c84b | 2016-08-08 10:45:03 -0700 | [diff] [blame] | 272 | func newStubLibrary() (*Module, []interface{}) { |
Colin Cross | b916a38 | 2016-07-29 17:28:03 -0700 | [diff] [blame] | 273 | module, library := NewLibrary(android.DeviceSupported, true, false) |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 274 | module.stl = nil |
Colin Cross | b916a38 | 2016-07-29 17:28:03 -0700 | [diff] [blame] | 275 | module.sanitize = nil |
| 276 | library.StripProperties.Strip.None = true |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 277 | |
Colin Cross | b916a38 | 2016-07-29 17:28:03 -0700 | [diff] [blame] | 278 | stub := &stubDecorator{ |
| 279 | libraryDecorator: library, |
| 280 | } |
| 281 | module.compiler = stub |
| 282 | module.linker = stub |
| 283 | module.installer = stub |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 284 | |
Dan Albert | 705c84b | 2016-08-08 10:45:03 -0700 | [diff] [blame] | 285 | return module, []interface{}{&stub.properties} |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 286 | } |
| 287 | |
| 288 | func ndkLibraryFactory() (blueprint.Module, []interface{}) { |
Dan Albert | 705c84b | 2016-08-08 10:45:03 -0700 | [diff] [blame] | 289 | module, properties := newStubLibrary() |
| 290 | return android.InitAndroidArchModule(module, android.DeviceSupported, |
| 291 | android.MultilibBoth, properties...) |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 292 | } |