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 15package cc 16 17// The platform needs to provide the following artifacts for the NDK: 18// 1. Bionic headers. 19// 2. Platform API headers. 20// 3. NDK stub shared libraries. 21// 4. Bionic static libraries. 22// 23// TODO(danalbert): All of the above need to include NOTICE files. 24// 25// Components 1 and 2: Headers 26// The bionic and platform API headers are generalized into a single 27// `ndk_headers` rule. This rule has a `from` property that indicates a base 28// directory from which headers are to be taken, and a `to` property that 29// indicates where in the sysroot they should reside relative to usr/include. 30// There is also a `srcs` property that is glob compatible for specifying which 31// headers to include. 32// 33// Component 3: Stub Libraries 34// The shared libraries in the NDK are not the actual shared libraries they 35// refer to (to prevent people from accidentally loading them), but stub 36// libraries with dummy implementations of everything for use at build time 37// only. 38// 39// Since we don't actually need to know anything about the stub libraries aside 40// from a list of functions and globals to be exposed, we can create these for 41// every platform level in the current tree. This is handled by the 42// ndk_library rule. 43// 44// Component 4: Static Libraries 45// The NDK only provides static libraries for bionic, not the platform APIs. 46// Since these need to be the actual implementation, we can't build old versions 47// in the current platform tree. As such, legacy versions are checked in 48// prebuilt to development/ndk, and a current version is built and archived as 49// part of the platform build. The platfrom already builds these libraries, our 50// NDK build rules only need to archive them for retrieval so they can be added 51// to the prebuilts. 52// 53// TODO(danalbert): Write `ndk_static_library` rule. 54 55import ( 56 "android/soong/android" 57) 58 59func init() { 60 android.RegisterModuleType("ndk_headers", ndkHeadersFactory) 61 android.RegisterModuleType("ndk_library", NdkLibraryFactory) 62 android.RegisterModuleType("versioned_ndk_headers", versionedNdkHeadersFactory) 63 android.RegisterModuleType("preprocessed_ndk_headers", preprocessedNdkHeadersFactory) 64 android.RegisterSingletonType("ndk", NdkSingleton) 65 66 pctx.Import("android/soong/android") 67} 68 69func getNdkInstallBase(ctx android.PathContext) android.InstallPath { 70 return android.PathForNdkInstall(ctx) 71} 72 73// Returns the main install directory for the NDK sysroot. Usable with --sysroot. 74func getNdkSysrootBase(ctx android.PathContext) android.InstallPath { 75 return getNdkInstallBase(ctx).Join(ctx, "sysroot") 76} 77 78// The base timestamp file depends on the NDK headers and stub shared libraries, 79// but not the static libraries. This distinction is needed because the static 80// libraries themselves might need to depend on the base sysroot. 81func getNdkBaseTimestampFile(ctx android.PathContext) android.WritablePath { 82 return android.PathForOutput(ctx, "ndk_base.timestamp") 83} 84 85// The full timestamp file depends on the base timestamp *and* the static 86// libraries. 87func getNdkFullTimestampFile(ctx android.PathContext) android.WritablePath { 88 return android.PathForOutput(ctx, "ndk.timestamp") 89} 90 91func NdkSingleton() android.Singleton { 92 return &ndkSingleton{} 93} 94 95type ndkSingleton struct{} 96 97func (n *ndkSingleton) GenerateBuildActions(ctx android.SingletonContext) { 98 var staticLibInstallPaths android.Paths 99 var installPaths android.Paths 100 var licensePaths android.Paths 101 ctx.VisitAllModules(func(module android.Module) { 102 if m, ok := module.(android.Module); ok && !m.Enabled() { 103 return 104 } 105 106 if m, ok := module.(*headerModule); ok { 107 installPaths = append(installPaths, m.installPaths...) 108 licensePaths = append(licensePaths, m.licensePath) 109 } 110 111 if m, ok := module.(*versionedHeaderModule); ok { 112 installPaths = append(installPaths, m.installPaths...) 113 licensePaths = append(licensePaths, m.licensePath) 114 } 115 116 if m, ok := module.(*preprocessedHeadersModule); ok { 117 installPaths = append(installPaths, m.installPaths...) 118 licensePaths = append(licensePaths, m.licensePath) 119 } 120 121 if m, ok := module.(*Module); ok { 122 if installer, ok := m.installer.(*stubDecorator); ok && m.library.buildStubs() { 123 installPaths = append(installPaths, installer.installPath) 124 } 125 126 if library, ok := m.linker.(*libraryDecorator); ok { 127 if library.ndkSysrootPath != nil { 128 staticLibInstallPaths = append( 129 staticLibInstallPaths, library.ndkSysrootPath) 130 } 131 } 132 } 133 }) 134 135 // Include only a single copy of each license file. The Bionic NOTICE is 136 // long and is referenced by multiple Bionic modules. 137 licensePaths = android.FirstUniquePaths(licensePaths) 138 139 combinedLicense := getNdkInstallBase(ctx).Join(ctx, "NOTICE") 140 ctx.Build(pctx, android.BuildParams{ 141 Rule: android.Cat, 142 Description: "combine licenses", 143 Output: combinedLicense, 144 Inputs: licensePaths, 145 }) 146 147 baseDepPaths := append(installPaths, combinedLicense) 148 149 // There's a dummy "ndk" rule defined in ndk/Android.mk that depends on 150 // this. `m ndk` will build the sysroots. 151 ctx.Build(pctx, android.BuildParams{ 152 Rule: android.Touch, 153 Output: getNdkBaseTimestampFile(ctx), 154 Implicits: baseDepPaths, 155 }) 156 157 fullDepPaths := append(staticLibInstallPaths, getNdkBaseTimestampFile(ctx)) 158 159 ctx.Build(pctx, android.BuildParams{ 160 Rule: android.Touch, 161 Output: getNdkFullTimestampFile(ctx), 162 Implicits: fullDepPaths, 163 }) 164} 165