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			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