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.OutputPath { 70 return android.PathForOutput(ctx, "ndk") 71} 72 73// Returns the main install directory for the NDK sysroot. Usable with --sysroot. 74func getNdkSysrootBase(ctx android.PathContext) android.OutputPath { 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 if ctx.Config().ExcludeDraftNdkApis() && m.properties.Draft { 108 return 109 } 110 111 installPaths = append(installPaths, m.installPaths...) 112 licensePaths = append(licensePaths, m.licensePath) 113 } 114 115 if m, ok := module.(*versionedHeaderModule); ok { 116 if ctx.Config().ExcludeDraftNdkApis() && m.properties.Draft { 117 return 118 } 119 120 installPaths = append(installPaths, m.installPaths...) 121 licensePaths = append(licensePaths, m.licensePath) 122 } 123 124 if m, ok := module.(*preprocessedHeadersModule); ok { 125 if ctx.Config().ExcludeDraftNdkApis() && m.properties.Draft { 126 return 127 } 128 129 installPaths = append(installPaths, m.installPaths...) 130 licensePaths = append(licensePaths, m.licensePath) 131 } 132 133 if m, ok := module.(*Module); ok { 134 if installer, ok := m.installer.(*stubDecorator); ok { 135 if ctx.Config().ExcludeDraftNdkApis() && 136 installer.properties.Draft { 137 return 138 } 139 installPaths = append(installPaths, installer.installPath) 140 } 141 142 if library, ok := m.linker.(*libraryDecorator); ok { 143 if library.ndkSysrootPath != nil { 144 staticLibInstallPaths = append( 145 staticLibInstallPaths, library.ndkSysrootPath) 146 } 147 } 148 } 149 }) 150 151 // Include only a single copy of each license file. The Bionic NOTICE is 152 // long and is referenced by multiple Bionic modules. 153 licensePaths = android.FirstUniquePaths(licensePaths) 154 155 combinedLicense := getNdkInstallBase(ctx).Join(ctx, "NOTICE") 156 ctx.Build(pctx, android.BuildParams{ 157 Rule: android.Cat, 158 Description: "combine licenses", 159 Output: combinedLicense, 160 Inputs: licensePaths, 161 }) 162 163 baseDepPaths := append(installPaths, combinedLicense) 164 165 // There's a dummy "ndk" rule defined in ndk/Android.mk that depends on 166 // this. `m ndk` will build the sysroots. 167 ctx.Build(pctx, android.BuildParams{ 168 Rule: android.Touch, 169 Output: getNdkBaseTimestampFile(ctx), 170 Implicits: baseDepPaths, 171 }) 172 173 fullDepPaths := append(staticLibInstallPaths, getNdkBaseTimestampFile(ctx)) 174 175 ctx.Build(pctx, android.BuildParams{ 176 Rule: android.Touch, 177 Output: getNdkFullTimestampFile(ctx), 178 Implicits: fullDepPaths, 179 }) 180} 181