blob: e94b20c55dc11bf1172749c0fdf8bf7efa876154 [file] [log] [blame]
Colin Cross800fe132019-02-11 14:21:24 -08001// Copyright 2019 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 java
16
17import (
18 "path/filepath"
Vladimir Marko205e6c22020-04-01 13:52:27 +010019 "sort"
Colin Cross800fe132019-02-11 14:21:24 -080020 "strings"
21
22 "android/soong/android"
23 "android/soong/dexpreopt"
24
Colin Cross800fe132019-02-11 14:21:24 -080025 "github.com/google/blueprint/proptools"
26)
27
Paul Duffin1ab61862021-01-20 17:44:53 +000028// =================================================================================================
29// WIP - see http://b/177892522 for details
30//
31// The build support for boot images is currently being migrated away from singleton to modules so
32// the documentation may not be strictly accurate. Rather than update the documentation at every
33// step which will create a lot of churn the changes that have been made will be listed here and the
34// documentation will be updated once it is closer to the final result.
35//
36// Changes:
37// 1) dex_bootjars is now a singleton module and not a plain singleton.
Paul Duffin3451e162021-01-20 15:16:56 +000038// 2) Boot images are now represented by the boot_image module type.
39// 3) The art boot image is called "art-boot-image", the framework boot image is called
40// "framework-boot-image".
41// 4) They are defined in art/build/boot/Android.bp and frameworks/base/boot/Android.bp
42// respectively.
43// 5) Each boot_image retrieves the appropriate boot image configuration from the map returned by
44// genBootImageConfigs() using the image_name specified in the boot_image module.
Paul Duffin1ab61862021-01-20 17:44:53 +000045// =================================================================================================
46
Ulya Trafimovich3bfabf22020-11-20 17:28:51 +000047// This comment describes:
48// 1. ART boot images in general (their types, structure, file layout, etc.)
49// 2. build system support for boot images
50//
51// 1. ART boot images
52// ------------------
53//
54// A boot image in ART is a set of files that contain AOT-compiled native code and a heap snapshot
55// of AOT-initialized classes for the bootclasspath Java libraries. A boot image is compiled from a
56// set of DEX jars by the dex2oat compiler. A boot image is used for two purposes: 1) it is
57// installed on device and loaded at runtime, and 2) other Java libraries and apps are compiled
58// against it (compilation may take place either on host, known as "dexpreopt", or on device, known
59// as "dexopt").
60//
61// A boot image is not a single file, but a collection of interrelated files. Each boot image has a
62// number of components that correspond to the Java libraries that constitute it. For each component
63// there are multiple files:
64// - *.oat or *.odex file with native code (architecture-specific, one per instruction set)
65// - *.art file with pre-initialized Java classes (architecture-specific, one per instruction set)
66// - *.vdex file with verification metadata for the DEX bytecode (architecture independent)
67//
68// *.vdex files for the boot images do not contain the DEX bytecode itself, because the
69// bootclasspath DEX files are stored on disk in uncompressed and aligned form. Consequently a boot
70// image is not self-contained and cannot be used without its DEX files. To simplify the management
71// of boot image files, ART uses a certain naming scheme and associates the following metadata with
72// each boot image:
73// - A stem, which is a symbolic name that is prepended to boot image file names.
74// - A location (on-device path to the boot image files).
75// - A list of boot image locations (on-device paths to dependency boot images).
76// - A set of DEX locations (on-device paths to the DEX files, one location for one DEX file used
77// to compile the boot image).
78//
79// There are two kinds of boot images:
80// - primary boot images
81// - boot image extensions
82//
83// 1.1. Primary boot images
84// ------------------------
85//
86// A primary boot image is compiled for a core subset of bootclasspath Java libraries. It does not
87// depend on any other images, and other boot images may depend on it.
88//
89// For example, assuming that the stem is "boot", the location is /apex/com.android.art/javalib/,
90// the set of core bootclasspath libraries is A B C, and the boot image is compiled for ARM targets
91// (32 and 64 bits), it will have three components with the following files:
92// - /apex/com.android.art/javalib/{arm,arm64}/boot.{art,oat,vdex}
93// - /apex/com.android.art/javalib/{arm,arm64}/boot-B.{art,oat,vdex}
94// - /apex/com.android.art/javalib/{arm,arm64}/boot-C.{art,oat,vdex}
95//
96// The files of the first component are special: they do not have the component name appended after
97// the stem. This naming convention dates back to the times when the boot image was not split into
98// components, and there were just boot.oat and boot.art. The decision to split was motivated by
99// licensing reasons for one of the bootclasspath libraries.
100//
101// As of November 2020 the only primary boot image in Android is the image in the ART APEX
102// com.android.art. The primary ART boot image contains the Core libraries that are part of the ART
103// module. When the ART module gets updated, the primary boot image will be updated with it, and all
104// dependent images will get invalidated (the checksum of the primary image stored in dependent
105// images will not match), unless they are updated in sync with the ART module.
106//
107// 1.2. Boot image extensions
108// --------------------------
109//
110// A boot image extension is compiled for a subset of bootclasspath Java libraries (in particular,
111// this subset does not include the Core bootclasspath libraries that go into the primary boot
112// image). A boot image extension depends on the primary boot image and optionally some other boot
113// image extensions. Other images may depend on it. In other words, boot image extensions can form
114// acyclic dependency graphs.
115//
116// The motivation for boot image extensions comes from the Mainline project. Consider a situation
117// when the list of bootclasspath libraries is A B C, and both A and B are parts of the Android
118// platform, but C is part of an updatable APEX com.android.C. When the APEX is updated, the Java
119// code for C might have changed compared to the code that was used to compile the boot image.
120// Consequently, the whole boot image is obsolete and invalidated (even though the code for A and B
121// that does not depend on C is up to date). To avoid this, the original monolithic boot image is
122// split in two parts: the primary boot image that contains A B, and the boot image extension that
123// contains C and depends on the primary boot image (extends it).
124//
125// For example, assuming that the stem is "boot", the location is /system/framework, the set of
126// bootclasspath libraries is D E (where D is part of the platform and is located in
127// /system/framework, and E is part of a non-updatable APEX com.android.E and is located in
128// /apex/com.android.E/javalib), and the boot image is compiled for ARM targets (32 and 64 bits),
129// it will have two components with the following files:
130// - /system/framework/{arm,arm64}/boot-D.{art,oat,vdex}
131// - /system/framework/{arm,arm64}/boot-E.{art,oat,vdex}
132//
133// As of November 2020 the only boot image extension in Android is the Framework boot image
134// extension. It extends the primary ART boot image and contains Framework libraries and other
135// bootclasspath libraries from the platform and non-updatable APEXes that are not included in the
136// ART image. The Framework boot image extension is updated together with the platform. In the
137// future other boot image extensions may be added for some updatable modules.
138//
139//
140// 2. Build system support for boot images
141// ---------------------------------------
142//
143// The primary ART boot image needs to be compiled with one dex2oat invocation that depends on DEX
144// jars for the core libraries. Framework boot image extension needs to be compiled with one dex2oat
145// invocation that depends on the primary ART boot image and all bootclasspath DEX jars except the
Paul Duffin1ab61862021-01-20 17:44:53 +0000146// core libraries as they are already part of the primary ART boot image.
Ulya Trafimovich3bfabf22020-11-20 17:28:51 +0000147//
148// 2.1. Libraries that go in the boot images
149// -----------------------------------------
150//
151// The contents of each boot image are determined by the PRODUCT variables. The primary ART APEX
152// boot image contains libraries listed in the ART_APEX_JARS variable in the AOSP makefiles. The
153// Framework boot image extension contains libraries specified in the PRODUCT_BOOT_JARS and
154// PRODUCT_BOOT_JARS_EXTRA variables. The AOSP makefiles specify some common Framework libraries,
155// but more product-specific libraries can be added in the product makefiles.
156//
157// Each component of the PRODUCT_BOOT_JARS and PRODUCT_BOOT_JARS_EXTRA variables is either a simple
158// name (if the library is a part of the Platform), or a colon-separated pair <apex, name> (if the
159// library is a part of a non-updatable APEX).
160//
161// A related variable PRODUCT_UPDATABLE_BOOT_JARS contains bootclasspath libraries that are in
162// updatable APEXes. They are not included in the boot image.
163//
164// One exception to the above rules are "coverage" builds (a special build flavor which requires
165// setting environment variable EMMA_INSTRUMENT_FRAMEWORK=true). In coverage builds the Java code in
166// boot image libraries is instrumented, which means that the instrumentation library (jacocoagent)
167// needs to be added to the list of bootclasspath DEX jars.
168//
169// In general, there is a requirement that the source code for a boot image library must be
170// available at build time (e.g. it cannot be a stub that has a separate implementation library).
171//
172// 2.2. Static configs
173// -------------------
174//
175// Because boot images are used to dexpreopt other Java modules, the paths to boot image files must
176// be known by the time dexpreopt build rules for the dependent modules are generated. Boot image
177// configs are constructed very early during the build, before build rule generation. The configs
178// provide predefined paths to boot image files (these paths depend only on static build
179// configuration, such as PRODUCT variables, and use hard-coded directory names).
180//
181// 2.3. Singleton
182// --------------
183//
184// Build rules for the boot images are generated with a Soong singleton. Because a singleton has no
185// dependencies on other modules, it has to find the modules for the DEX jars using VisitAllModules.
186// Soong loops through all modules and compares each module against a list of bootclasspath library
187// names. Then it generates build rules that copy DEX jars from their intermediate module-specific
188// locations to the hard-coded locations predefined in the boot image configs.
189//
190// It would be possible to use a module with proper dependencies instead, but that would require
191// changes in the way Soong generates variables for Make: a singleton can use one MakeVars() method
192// that writes variables to out/soong/make_vars-*.mk, which is included early by the main makefile,
193// but module(s) would have to use out/soong/Android-*.mk which has a group of LOCAL_* variables
194// for each module, and is included later.
195//
196// 2.4. Install rules
197// ------------------
198//
199// The primary boot image and the Framework extension are installed in different ways. The primary
200// boot image is part of the ART APEX: it is copied into the APEX intermediate files, packaged
201// together with other APEX contents, extracted and mounted on device. The Framework boot image
202// extension is installed by the rules defined in makefiles (make/core/dex_preopt_libart.mk). Soong
203// writes out a few DEXPREOPT_IMAGE_* variables for Make; these variables contain boot image names,
204// paths and so on.
205//
206// 2.5. JIT-Zygote configuration
207// -----------------------------
208//
209// One special configuration is JIT-Zygote build, when the primary ART image is used for compiling
210// apps instead of the Framework boot image extension (see DEXPREOPT_USE_ART_IMAGE and UseArtImage).
211//
212
Martin Stjernholmdb513822021-02-16 19:55:58 +0000213var artApexNames = []string{
214 "com.android.art",
215 "com.android.art.debug",
216 "com.android.art,testing",
217 "com.google.android.art",
218 "com.google.android.art.debug",
219 "com.google.android.art.testing",
220}
221
Colin Cross800fe132019-02-11 14:21:24 -0800222func init() {
Ulya Trafimovichb28cc372020-01-13 15:18:16 +0000223 RegisterDexpreoptBootJarsComponents(android.InitRegistrationContext)
Colin Cross800fe132019-02-11 14:21:24 -0800224}
225
Ulya Trafimovich3bfabf22020-11-20 17:28:51 +0000226// Target-independent description of a boot image.
Colin Cross44df5812019-02-15 23:06:46 -0800227type bootImageConfig struct {
David Srbecky1aacc6c2020-03-26 11:10:45 +0000228 // If this image is an extension, the image that it extends.
229 extends *bootImageConfig
Ulya Trafimovich4d2eeed2019-11-08 10:54:21 +0000230
231 // Image name (used in directory names and ninja rule names).
232 name string
233
234 // Basename of the image: the resulting filenames are <stem>[-<jar>].{art,oat,vdex}.
235 stem string
236
237 // Output directory for the image files.
238 dir android.OutputPath
239
240 // Output directory for the image files with debug symbols.
241 symbolsDir android.OutputPath
242
243 // Subdirectory where the image files are installed.
244 installSubdir string
245
Ulya Trafimovich249386a2020-07-01 14:31:13 +0100246 // A list of (location, jar) pairs for the Java modules in this image.
247 modules android.ConfiguredJarList
Ulya Trafimovich4d2eeed2019-11-08 10:54:21 +0000248
Ulya Trafimovich4d2eeed2019-11-08 10:54:21 +0000249 // File paths to jars.
250 dexPaths android.WritablePaths // for this image
251 dexPathsDeps android.WritablePaths // for the dependency images and in this image
252
Ulya Trafimovich4d2eeed2019-11-08 10:54:21 +0000253 // File path to a zip archive with all image files (or nil, if not needed).
254 zip android.WritablePath
David Srbeckyc177ebe2020-02-18 20:43:06 +0000255
256 // Rules which should be used in make to install the outputs.
257 profileInstalls android.RuleBuilderInstalls
258
259 // Target-dependent fields.
260 variants []*bootImageVariant
261}
262
Ulya Trafimovich3bfabf22020-11-20 17:28:51 +0000263// Target-dependent description of a boot image.
David Srbeckyc177ebe2020-02-18 20:43:06 +0000264type bootImageVariant struct {
265 *bootImageConfig
266
267 // Target for which the image is generated.
268 target android.Target
269
David Srbeckyab994982020-03-30 17:24:13 +0100270 // The "locations" of jars.
271 dexLocations []string // for this image
272 dexLocationsDeps []string // for the dependency images and in this image
273
David Srbeckyc177ebe2020-02-18 20:43:06 +0000274 // Paths to image files.
275 images android.OutputPath // first image file
276 imagesDeps android.OutputPaths // all files
277
278 // Only for extensions, paths to the primary boot images.
279 primaryImages android.OutputPath
280
281 // Rules which should be used in make to install the outputs.
282 installs android.RuleBuilderInstalls
283 vdexInstalls android.RuleBuilderInstalls
284 unstrippedInstalls android.RuleBuilderInstalls
285}
286
Ulya Trafimovich3bfabf22020-11-20 17:28:51 +0000287// Get target-specific boot image variant for the given boot image config and target.
David Srbeckyc177ebe2020-02-18 20:43:06 +0000288func (image bootImageConfig) getVariant(target android.Target) *bootImageVariant {
289 for _, variant := range image.variants {
290 if variant.target.Os == target.Os && variant.target.Arch.ArchType == target.Arch.ArchType {
291 return variant
292 }
293 }
294 return nil
Colin Cross800fe132019-02-11 14:21:24 -0800295}
296
Ulya Trafimovich3bfabf22020-11-20 17:28:51 +0000297// Return any (the first) variant which is for the device (as opposed to for the host).
David Srbeckyab994982020-03-30 17:24:13 +0100298func (image bootImageConfig) getAnyAndroidVariant() *bootImageVariant {
299 for _, variant := range image.variants {
300 if variant.target.Os == android.Android {
301 return variant
302 }
303 }
304 return nil
305}
306
Ulya Trafimovich3bfabf22020-11-20 17:28:51 +0000307// Return the name of a boot image module given a boot image config and a component (module) index.
308// A module name is a combination of the Java library name, and the boot image stem (that is stored
309// in the config).
Ulya Trafimovich8640ab92020-05-11 18:06:15 +0100310func (image bootImageConfig) moduleName(ctx android.PathContext, idx int) string {
Ulya Trafimovich3bfabf22020-11-20 17:28:51 +0000311 // The first module of the primary boot image is special: its module name has only the stem, but
312 // not the library name. All other module names are of the form <stem>-<library name>
Ulya Trafimovich249386a2020-07-01 14:31:13 +0100313 m := image.modules.Jar(idx)
Ulya Trafimovich4d2eeed2019-11-08 10:54:21 +0000314 name := image.stem
David Srbecky1aacc6c2020-03-26 11:10:45 +0000315 if idx != 0 || image.extends != nil {
Ulya Trafimovich249386a2020-07-01 14:31:13 +0100316 name += "-" + android.ModuleStem(m)
Ulya Trafimovich4d2eeed2019-11-08 10:54:21 +0000317 }
318 return name
319}
Dan Willemsen0f416782019-06-13 21:44:53 +0000320
Ulya Trafimovich3bfabf22020-11-20 17:28:51 +0000321// Return the name of the first boot image module, or stem if the list of modules is empty.
Ulya Trafimovich8640ab92020-05-11 18:06:15 +0100322func (image bootImageConfig) firstModuleNameOrStem(ctx android.PathContext) string {
Ulya Trafimovich249386a2020-07-01 14:31:13 +0100323 if image.modules.Len() > 0 {
Ulya Trafimovich8640ab92020-05-11 18:06:15 +0100324 return image.moduleName(ctx, 0)
Ulya Trafimovich4d2eeed2019-11-08 10:54:21 +0000325 } else {
326 return image.stem
327 }
328}
329
Ulya Trafimovich3bfabf22020-11-20 17:28:51 +0000330// Return filenames for the given boot image component, given the output directory and a list of
331// extensions.
Ulya Trafimovich4d2eeed2019-11-08 10:54:21 +0000332func (image bootImageConfig) moduleFiles(ctx android.PathContext, dir android.OutputPath, exts ...string) android.OutputPaths {
Ulya Trafimovich249386a2020-07-01 14:31:13 +0100333 ret := make(android.OutputPaths, 0, image.modules.Len()*len(exts))
334 for i := 0; i < image.modules.Len(); i++ {
Ulya Trafimovich8640ab92020-05-11 18:06:15 +0100335 name := image.moduleName(ctx, i)
Dan Willemsen0f416782019-06-13 21:44:53 +0000336 for _, ext := range exts {
337 ret = append(ret, dir.Join(ctx, name+ext))
338 }
339 }
Dan Willemsen0f416782019-06-13 21:44:53 +0000340 return ret
341}
342
Ulya Trafimovich3bfabf22020-11-20 17:28:51 +0000343// Return boot image locations (as a list of symbolic paths).
344//
David Srbecky1aacc6c2020-03-26 11:10:45 +0000345// The image "location" is a symbolic path that, with multiarchitecture support, doesn't really
346// exist on the device. Typically it is /apex/com.android.art/javalib/boot.art and should be the
347// same for all supported architectures on the device. The concrete architecture specific files
348// actually end up in architecture-specific sub-directory such as arm, arm64, x86, or x86_64.
349//
Ulya Trafimovich3bfabf22020-11-20 17:28:51 +0000350// For example a physical file /apex/com.android.art/javalib/x86/boot.art has "image location"
351// /apex/com.android.art/javalib/boot.art (which is not an actual file).
352//
353// For a primary boot image the list of locations has a single element.
354//
355// For a boot image extension the list of locations contains a location for all dependency images
356// (including the primary image) and the location of the extension itself. For example, for the
357// Framework boot image extension that depends on the primary ART boot image the list contains two
358// elements.
David Srbecky1aacc6c2020-03-26 11:10:45 +0000359//
360// The location is passed as an argument to the ART tools like dex2oat instead of the real path.
361// ART tools will then reconstruct the architecture-specific real path.
Ulya Trafimovich3bfabf22020-11-20 17:28:51 +0000362//
David Srbecky1aacc6c2020-03-26 11:10:45 +0000363func (image *bootImageVariant) imageLocations() (imageLocations []string) {
364 if image.extends != nil {
365 imageLocations = image.extends.getVariant(image.target).imageLocations()
366 }
367 return append(imageLocations, dexpreopt.PathToLocation(image.images, image.target.Arch.ArchType))
368}
369
Paul Duffin1ab61862021-01-20 17:44:53 +0000370func dexpreoptBootJarsFactory() android.SingletonModule {
371 m := &dexpreoptBootJars{}
372 android.InitAndroidModule(m)
373 return m
Colin Cross800fe132019-02-11 14:21:24 -0800374}
375
Ulya Trafimovichb28cc372020-01-13 15:18:16 +0000376func RegisterDexpreoptBootJarsComponents(ctx android.RegistrationContext) {
Paul Duffin1ab61862021-01-20 17:44:53 +0000377 ctx.RegisterSingletonModuleType("dex_bootjars", dexpreoptBootJarsFactory)
Ulya Trafimovichb28cc372020-01-13 15:18:16 +0000378}
379
Ulya Trafimovicha4a1c4e2021-01-15 18:40:04 +0000380func SkipDexpreoptBootJars(ctx android.PathContext) bool {
381 return dexpreopt.GetGlobalConfig(ctx).DisablePreoptBootImages
Colin Cross800fe132019-02-11 14:21:24 -0800382}
383
Paul Duffin1ab61862021-01-20 17:44:53 +0000384// Singleton module for generating boot image build rules.
Colin Cross44df5812019-02-15 23:06:46 -0800385type dexpreoptBootJars struct {
Paul Duffin1ab61862021-01-20 17:44:53 +0000386 android.SingletonModuleBase
387
Ulya Trafimovich3bfabf22020-11-20 17:28:51 +0000388 // Default boot image config (currently always the Framework boot image extension). It should be
389 // noted that JIT-Zygote builds use ART APEX image instead of the Framework boot image extension,
390 // but the switch is handled not here, but in the makefiles (triggered with
391 // DEXPREOPT_USE_ART_IMAGE=true).
David Srbeckyc177ebe2020-02-18 20:43:06 +0000392 defaultBootImage *bootImageConfig
Colin Cross2d00f0d2019-05-09 21:50:00 -0700393
Ulya Trafimovich3bfabf22020-11-20 17:28:51 +0000394 // Other boot image configs (currently the list contains only the primary ART APEX image. It
395 // used to contain an experimental JIT-Zygote image (now replaced with the ART APEX image). In
396 // the future other boot image extensions may be added.
397 otherImages []*bootImageConfig
398
399 // Build path to a config file that Soong writes for Make (to be used in makefiles that install
400 // the default boot image).
Colin Cross2d00f0d2019-05-09 21:50:00 -0700401 dexpreoptConfigForMake android.WritablePath
Colin Cross44df5812019-02-15 23:06:46 -0800402}
Colin Cross800fe132019-02-11 14:21:24 -0800403
Paul Duffin1ab61862021-01-20 17:44:53 +0000404// Provide paths to boot images for use by modules that depend upon them.
405//
406// The build rules are created in GenerateSingletonBuildActions().
407func (d *dexpreoptBootJars) GenerateAndroidBuildActions(ctx android.ModuleContext) {
408 // Placeholder for now.
409}
410
Ulya Trafimovich3bfabf22020-11-20 17:28:51 +0000411// Generate build rules for boot images.
Paul Duffin1ab61862021-01-20 17:44:53 +0000412func (d *dexpreoptBootJars) GenerateSingletonBuildActions(ctx android.SingletonContext) {
Ulya Trafimovicha4a1c4e2021-01-15 18:40:04 +0000413 if SkipDexpreoptBootJars(ctx) {
Colin Cross800fe132019-02-11 14:21:24 -0800414 return
415 }
Martin Stjernholm6d415272020-01-31 17:10:36 +0000416 if dexpreopt.GetCachedGlobalSoongConfig(ctx) == nil {
417 // No module has enabled dexpreopting, so we assume there will be no boot image to make.
418 return
419 }
Colin Cross800fe132019-02-11 14:21:24 -0800420
Colin Cross2d00f0d2019-05-09 21:50:00 -0700421 d.dexpreoptConfigForMake = android.PathForOutput(ctx, ctx.Config().DeviceName(), "dexpreopt.config")
422 writeGlobalConfigForMake(ctx, d.dexpreoptConfigForMake)
423
Martin Stjernholm40f9f3c2020-01-20 18:12:23 +0000424 global := dexpreopt.GetGlobalConfig(ctx)
Colin Cross800fe132019-02-11 14:21:24 -0800425
426 // Skip recompiling the boot image for the second sanitization phase. We'll get separate paths
427 // and invalidate first-stage artifacts which are crucial to SANITIZE_LITE builds.
428 // Note: this is technically incorrect. Compiled code contains stack checks which may depend
429 // on ASAN settings.
430 if len(ctx.Config().SanitizeDevice()) == 1 &&
431 ctx.Config().SanitizeDevice()[0] == "address" &&
Colin Cross44df5812019-02-15 23:06:46 -0800432 global.SanitizeLite {
Colin Cross800fe132019-02-11 14:21:24 -0800433 return
434 }
435
Lingfeng Yang54191fa2019-12-19 16:40:09 +0000436 // Always create the default boot image first, to get a unique profile rule for all images.
437 d.defaultBootImage = buildBootImage(ctx, defaultBootImageConfig(ctx))
Ulya Trafimovich44561882020-01-03 13:25:54 +0000438 // Create boot image for the ART apex (build artifacts are accessed via the global boot image config).
439 d.otherImages = append(d.otherImages, buildBootImage(ctx, artBootImageConfig(ctx)))
Colin Crossc9a4c362019-02-26 21:13:48 -0800440
441 dumpOatRules(ctx, d.defaultBootImage)
Colin Cross44df5812019-02-15 23:06:46 -0800442}
443
Ulya Trafimovichb28cc372020-01-13 15:18:16 +0000444// Inspect this module to see if it contains a bootclasspath dex jar.
445// Note that the same jar may occur in multiple modules.
446// This logic is tested in the apex package to avoid import cycle apex <-> java.
Paul Duffindd63d6d2021-02-03 18:34:00 +0000447//
448// This is similar to logic in isModuleInConfiguredList() so any changes needed here are likely to
449// be needed there too.
450//
451// TODO(b/177892522): Avoid having to perform this type of check or if necessary dedup it.
Ulya Trafimovichb28cc372020-01-13 15:18:16 +0000452func getBootImageJar(ctx android.SingletonContext, image *bootImageConfig, module android.Module) (int, android.Path) {
Ulya Trafimovichb28cc372020-01-13 15:18:16 +0000453 name := ctx.ModuleName(module)
Paul Duffin064b70c2020-11-02 17:32:38 +0000454
455 // Strip a prebuilt_ prefix so that this can access the dex jar from a prebuilt module.
456 name = android.RemoveOptionalPrebuiltPrefix(name)
457
458 // Ignore any module that is not listed in the boot image configuration.
Ulya Trafimovich249386a2020-07-01 14:31:13 +0100459 index := image.modules.IndexOfJar(name)
Ulya Trafimovichb28cc372020-01-13 15:18:16 +0000460 if index == -1 {
461 return -1, nil
462 }
463
Paul Duffin064b70c2020-11-02 17:32:38 +0000464 // It is an error if a module configured in the boot image does not support accessing the dex jar.
465 // This is safe because every module that has the same name has to have the same module type.
Paul Duffinfc021662020-12-03 18:06:20 +0000466 jar, hasJar := module.(interface{ DexJarBuildPath() android.Path })
467 if !hasJar {
468 ctx.Errorf("module %q configured in boot image %q does not support accessing dex jar", module, image.name)
469 return -1, nil
470 }
471
472 // It is also an error if the module is not an ApexModule.
473 if _, ok := module.(android.ApexModule); !ok {
474 ctx.Errorf("module %q configured in boot image %q does not support being added to an apex", module, image.name)
475 return -1, nil
476 }
477
Colin Cross56a83212020-09-15 18:30:11 -0700478 apexInfo := ctx.ModuleProvider(module, android.ApexInfoProvider).(android.ApexInfo)
Paul Duffinfc021662020-12-03 18:06:20 +0000479
480 // Now match the apex part of the boot image configuration.
481 requiredApex := image.modules.Apex(index)
482 if requiredApex == "platform" {
483 if len(apexInfo.InApexes) != 0 {
484 // A platform variant is required but this is for an apex so ignore it.
Ulya Trafimovichb28cc372020-01-13 15:18:16 +0000485 return -1, nil
Paul Duffinfc021662020-12-03 18:06:20 +0000486 }
Martin Stjernholm1dc0d6d2021-01-17 21:05:12 +0000487 } else if !apexInfo.InApexByBaseName(requiredApex) {
Paul Duffinfc021662020-12-03 18:06:20 +0000488 // An apex variant for a specific apex is required but this is the wrong apex.
489 return -1, nil
490 }
491
492 // Check that this module satisfies any boot image specific constraints.
493 fromUpdatableApex := apexInfo.Updatable
494
495 switch image.name {
496 case artBootImageName:
Martin Stjernholmdb513822021-02-16 19:55:58 +0000497 inArtApex := false
498 for _, n := range artApexNames {
499 if apexInfo.InApexByBaseName(n) {
500 inArtApex = true
501 break
502 }
503 }
504 if inArtApex {
Paul Duffinfc021662020-12-03 18:06:20 +0000505 // ok: found the jar in the ART apex
Ulya Trafimoviche0ce4ba2020-04-08 15:00:49 +0100506 } else if name == "jacocoagent" && ctx.Config().IsEnvTrue("EMMA_INSTRUMENT_FRAMEWORK") {
Ulya Trafimovich7c140d82020-04-22 18:05:58 +0100507 // exception (skip and continue): Jacoco platform variant for a coverage build
Ulya Trafimoviche0ce4ba2020-04-08 15:00:49 +0100508 return -1, nil
Ulya Trafimovich7c140d82020-04-22 18:05:58 +0100509 } else if fromUpdatableApex {
510 // error: this jar is part of an updatable apex other than ART
Colin Cross56a83212020-09-15 18:30:11 -0700511 ctx.Errorf("module %q from updatable apexes %q is not allowed in the ART boot image", name, apexInfo.InApexes)
Ulya Trafimovichb28cc372020-01-13 15:18:16 +0000512 } else {
Ulya Trafimovich7c140d82020-04-22 18:05:58 +0100513 // error: this jar is part of the platform or a non-updatable apex
Colin Crossaede88c2020-08-11 12:17:01 -0700514 ctx.Errorf("module %q is not allowed in the ART boot image", name)
Ulya Trafimovichb28cc372020-01-13 15:18:16 +0000515 }
Paul Duffinfc021662020-12-03 18:06:20 +0000516
517 case frameworkBootImageName:
Ulya Trafimovich7c140d82020-04-22 18:05:58 +0100518 if !fromUpdatableApex {
519 // ok: this jar is part of the platform or a non-updatable apex
Ulya Trafimovichb28cc372020-01-13 15:18:16 +0000520 } else {
Ulya Trafimovich7c140d82020-04-22 18:05:58 +0100521 // error: this jar is part of an updatable apex
Colin Cross56a83212020-09-15 18:30:11 -0700522 ctx.Errorf("module %q from updatable apexes %q is not allowed in the framework boot image", name, apexInfo.InApexes)
Ulya Trafimovichb28cc372020-01-13 15:18:16 +0000523 }
Paul Duffinfc021662020-12-03 18:06:20 +0000524 default:
Ulya Trafimovichb28cc372020-01-13 15:18:16 +0000525 panic("unknown boot image: " + image.name)
526 }
527
Ulyana Trafimovich5539e7b2020-06-04 14:08:17 +0000528 return index, jar.DexJarBuildPath()
Ulya Trafimovichb28cc372020-01-13 15:18:16 +0000529}
530
David Srbeckyc177ebe2020-02-18 20:43:06 +0000531// buildBootImage takes a bootImageConfig, creates rules to build it, and returns the image.
532func buildBootImage(ctx android.SingletonContext, image *bootImageConfig) *bootImageConfig {
Ulya Trafimovichb28cc372020-01-13 15:18:16 +0000533 // Collect dex jar paths for the boot image modules.
534 // This logic is tested in the apex package to avoid import cycle apex <-> java.
Ulya Trafimovich249386a2020-07-01 14:31:13 +0100535 bootDexJars := make(android.Paths, image.modules.Len())
Martin Stjernholm1dc0d6d2021-01-17 21:05:12 +0000536
Colin Cross800fe132019-02-11 14:21:24 -0800537 ctx.VisitAllModules(func(module android.Module) {
Martin Stjernholm1dc0d6d2021-01-17 21:05:12 +0000538 if !isActiveModule(module) {
539 return
540 }
541
Ulya Trafimovichb28cc372020-01-13 15:18:16 +0000542 if i, j := getBootImageJar(ctx, image, module); i != -1 {
Paul Duffindb77e142020-12-03 19:25:39 +0000543 if existing := bootDexJars[i]; existing != nil {
544 ctx.Errorf("Multiple dex jars found for %s:%s - %s and %s",
545 image.modules.Apex(i), image.modules.Jar(i), existing, j)
546 return
547 }
548
Ulya Trafimovichb28cc372020-01-13 15:18:16 +0000549 bootDexJars[i] = j
Colin Cross800fe132019-02-11 14:21:24 -0800550 }
551 })
552
553 var missingDeps []string
554 // Ensure all modules were converted to paths
555 for i := range bootDexJars {
556 if bootDexJars[i] == nil {
Ulya Trafimovich249386a2020-07-01 14:31:13 +0100557 m := image.modules.Jar(i)
Colin Cross800fe132019-02-11 14:21:24 -0800558 if ctx.Config().AllowMissingDependencies() {
Ulya Trafimovich50c4a4b2020-04-21 15:36:33 +0100559 missingDeps = append(missingDeps, m)
Paul Duffin7f48eef2020-12-03 11:15:58 +0000560 bootDexJars[i] = android.PathForOutput(ctx, "missing/module", m, "from/apex", image.modules.Apex(i))
Colin Cross800fe132019-02-11 14:21:24 -0800561 } else {
Ulya Trafimovichb28cc372020-01-13 15:18:16 +0000562 ctx.Errorf("failed to find a dex jar path for module '%s'"+
Ulya Trafimovich50c4a4b2020-04-21 15:36:33 +0100563 ", note that some jars may be filtered out by module constraints", m)
Colin Cross800fe132019-02-11 14:21:24 -0800564 }
565 }
566 }
567
Ulya Trafimovich3bfabf22020-11-20 17:28:51 +0000568 // The paths to bootclasspath DEX files need to be known at module GenerateAndroidBuildAction
569 // time, before the boot images are built (these paths are used in dexpreopt rule generation for
570 // Java libraries and apps). Generate rules that copy bootclasspath DEX jars to the predefined
571 // paths.
Colin Cross800fe132019-02-11 14:21:24 -0800572 for i := range bootDexJars {
573 ctx.Build(pctx, android.BuildParams{
574 Rule: android.Cp,
575 Input: bootDexJars[i],
Colin Cross44df5812019-02-15 23:06:46 -0800576 Output: image.dexPaths[i],
Colin Cross800fe132019-02-11 14:21:24 -0800577 })
578 }
579
Colin Cross44df5812019-02-15 23:06:46 -0800580 profile := bootImageProfileRule(ctx, image, missingDeps)
Nicolas Geoffraye7102422019-07-24 13:19:29 +0100581 bootFrameworkProfileRule(ctx, image, missingDeps)
Vladimir Marko205e6c22020-04-01 13:52:27 +0100582 updatableBcpPackagesRule(ctx, image, missingDeps)
Colin Cross800fe132019-02-11 14:21:24 -0800583
Ulya Trafimovich9ab49332020-06-10 15:44:25 +0100584 var zipFiles android.Paths
David Srbeckyc177ebe2020-02-18 20:43:06 +0000585 for _, variant := range image.variants {
586 files := buildBootImageVariant(ctx, variant, profile, missingDeps)
Ulya Trafimovich9ab49332020-06-10 15:44:25 +0100587 if variant.target.Os == android.Android {
588 zipFiles = append(zipFiles, files.Paths()...)
589 }
Colin Cross800fe132019-02-11 14:21:24 -0800590 }
Colin Cross44df5812019-02-15 23:06:46 -0800591
Colin Crossdf8eebe2019-04-09 15:29:41 -0700592 if image.zip != nil {
Colin Crossf1a035e2020-11-16 17:32:30 -0800593 rule := android.NewRuleBuilder(pctx, ctx)
Colin Crossdf8eebe2019-04-09 15:29:41 -0700594 rule.Command().
Colin Crossf1a035e2020-11-16 17:32:30 -0800595 BuiltTool("soong_zip").
Colin Crossdf8eebe2019-04-09 15:29:41 -0700596 FlagWithOutput("-o ", image.zip).
Ulya Trafimovich9ab49332020-06-10 15:44:25 +0100597 FlagWithArg("-C ", image.dir.Join(ctx, android.Android.String()).String()).
598 FlagWithInputList("-f ", zipFiles, " -f ")
Colin Crossdf8eebe2019-04-09 15:29:41 -0700599
Colin Crossf1a035e2020-11-16 17:32:30 -0800600 rule.Build("zip_"+image.name, "zip "+image.name+" image")
Colin Crossdf8eebe2019-04-09 15:29:41 -0700601 }
602
Colin Cross44df5812019-02-15 23:06:46 -0800603 return image
Colin Cross800fe132019-02-11 14:21:24 -0800604}
605
Ulya Trafimovich3bfabf22020-11-20 17:28:51 +0000606// Generate boot image build rules for a specific target.
David Srbeckyc177ebe2020-02-18 20:43:06 +0000607func buildBootImageVariant(ctx android.SingletonContext, image *bootImageVariant,
608 profile android.Path, missingDeps []string) android.WritablePaths {
Colin Cross800fe132019-02-11 14:21:24 -0800609
Martin Stjernholm75a48d82020-01-10 20:32:59 +0000610 globalSoong := dexpreopt.GetCachedGlobalSoongConfig(ctx)
Martin Stjernholm40f9f3c2020-01-20 18:12:23 +0000611 global := dexpreopt.GetGlobalConfig(ctx)
Colin Cross44df5812019-02-15 23:06:46 -0800612
David Srbeckyc177ebe2020-02-18 20:43:06 +0000613 arch := image.target.Arch.ArchType
David Srbecky7f8dac12020-02-13 16:00:45 +0000614 os := image.target.Os.String() // We need to distinguish host-x86 and device-x86.
615 symbolsDir := image.symbolsDir.Join(ctx, os, image.installSubdir, arch.String())
Ulyana Trafimovichde534412019-11-08 10:51:01 +0000616 symbolsFile := symbolsDir.Join(ctx, image.stem+".oat")
David Srbecky7f8dac12020-02-13 16:00:45 +0000617 outputDir := image.dir.Join(ctx, os, image.installSubdir, arch.String())
Ulya Trafimovich4d2eeed2019-11-08 10:54:21 +0000618 outputPath := outputDir.Join(ctx, image.stem+".oat")
619 oatLocation := dexpreopt.PathToLocation(outputPath, arch)
620 imagePath := outputPath.ReplaceExtension(ctx, "art")
Colin Cross800fe132019-02-11 14:21:24 -0800621
Colin Crossf1a035e2020-11-16 17:32:30 -0800622 rule := android.NewRuleBuilder(pctx, ctx)
Colin Cross800fe132019-02-11 14:21:24 -0800623 rule.MissingDeps(missingDeps)
624
625 rule.Command().Text("mkdir").Flag("-p").Flag(symbolsDir.String())
626 rule.Command().Text("rm").Flag("-f").
627 Flag(symbolsDir.Join(ctx, "*.art").String()).
628 Flag(symbolsDir.Join(ctx, "*.oat").String()).
629 Flag(symbolsDir.Join(ctx, "*.invocation").String())
630 rule.Command().Text("rm").Flag("-f").
631 Flag(outputDir.Join(ctx, "*.art").String()).
632 Flag(outputDir.Join(ctx, "*.oat").String()).
633 Flag(outputDir.Join(ctx, "*.invocation").String())
634
635 cmd := rule.Command()
636
637 extraFlags := ctx.Config().Getenv("ART_BOOT_IMAGE_EXTRA_ARGS")
638 if extraFlags == "" {
639 // Use ANDROID_LOG_TAGS to suppress most logging by default...
640 cmd.Text(`ANDROID_LOG_TAGS="*:e"`)
641 } else {
642 // ...unless the boot image is generated specifically for testing, then allow all logging.
643 cmd.Text(`ANDROID_LOG_TAGS="*:v"`)
644 }
645
646 invocationPath := outputPath.ReplaceExtension(ctx, "invocation")
647
Martin Stjernholm75a48d82020-01-10 20:32:59 +0000648 cmd.Tool(globalSoong.Dex2oat).
Colin Cross800fe132019-02-11 14:21:24 -0800649 Flag("--avoid-storing-invocation").
Colin Cross69f59a32019-02-15 10:39:37 -0800650 FlagWithOutput("--write-invocation-to=", invocationPath).ImplicitOutput(invocationPath).
Colin Cross44df5812019-02-15 23:06:46 -0800651 Flag("--runtime-arg").FlagWithArg("-Xms", global.Dex2oatImageXms).
652 Flag("--runtime-arg").FlagWithArg("-Xmx", global.Dex2oatImageXmx)
Colin Cross800fe132019-02-11 14:21:24 -0800653
Colin Cross69f59a32019-02-15 10:39:37 -0800654 if profile != nil {
Colin Cross800fe132019-02-11 14:21:24 -0800655 cmd.FlagWithArg("--compiler-filter=", "speed-profile")
Colin Cross69f59a32019-02-15 10:39:37 -0800656 cmd.FlagWithInput("--profile-file=", profile)
Colin Cross800fe132019-02-11 14:21:24 -0800657 }
658
Nicolas Geoffray1086e602021-01-20 14:30:40 +0000659 dirtyImageFile := "frameworks/base/config/dirty-image-objects"
660 dirtyImagePath := android.ExistentPathForSource(ctx, dirtyImageFile)
661 if dirtyImagePath.Valid() {
662 cmd.FlagWithInput("--dirty-image-objects=", dirtyImagePath.Path())
Colin Cross800fe132019-02-11 14:21:24 -0800663 }
664
David Srbecky1aacc6c2020-03-26 11:10:45 +0000665 if image.extends != nil {
Ulya Trafimovich3bfabf22020-11-20 17:28:51 +0000666 // It is a boot image extension, so it needs the boot image it depends on (in this case the
667 // primary ART APEX image).
David Srbeckyc177ebe2020-02-18 20:43:06 +0000668 artImage := image.primaryImages
Ulya Trafimovich4d2eeed2019-11-08 10:54:21 +0000669 cmd.
670 Flag("--runtime-arg").FlagWithInputList("-Xbootclasspath:", image.dexPathsDeps.Paths(), ":").
671 Flag("--runtime-arg").FlagWithList("-Xbootclasspath-locations:", image.dexLocationsDeps, ":").
672 FlagWithArg("--boot-image=", dexpreopt.PathToLocation(artImage, arch)).Implicit(artImage)
673 } else {
Ulya Trafimovich3bfabf22020-11-20 17:28:51 +0000674 // It is a primary image, so it needs a base address.
Ulya Trafimovich4d2eeed2019-11-08 10:54:21 +0000675 cmd.FlagWithArg("--base=", ctx.Config().LibartImgDeviceBaseAddress())
676 }
677
Colin Cross800fe132019-02-11 14:21:24 -0800678 cmd.
Colin Cross44df5812019-02-15 23:06:46 -0800679 FlagForEachInput("--dex-file=", image.dexPaths.Paths()).
680 FlagForEachArg("--dex-location=", image.dexLocations).
Colin Cross800fe132019-02-11 14:21:24 -0800681 Flag("--generate-debug-info").
682 Flag("--generate-build-id").
Mathieu Chartier54fd8072019-07-26 13:50:04 -0700683 Flag("--image-format=lz4hc").
Ulya Trafimovich4d2eeed2019-11-08 10:54:21 +0000684 FlagWithArg("--oat-symbols=", symbolsFile.String()).
Colin Cross800fe132019-02-11 14:21:24 -0800685 Flag("--strip").
Ulya Trafimovich4d2eeed2019-11-08 10:54:21 +0000686 FlagWithArg("--oat-file=", outputPath.String()).
Colin Cross800fe132019-02-11 14:21:24 -0800687 FlagWithArg("--oat-location=", oatLocation).
Ulya Trafimovich4d2eeed2019-11-08 10:54:21 +0000688 FlagWithArg("--image=", imagePath.String()).
Colin Cross800fe132019-02-11 14:21:24 -0800689 FlagWithArg("--instruction-set=", arch.String()).
Colin Cross44df5812019-02-15 23:06:46 -0800690 FlagWithArg("--android-root=", global.EmptyDirectory).
Colin Cross800fe132019-02-11 14:21:24 -0800691 FlagWithArg("--no-inline-from=", "core-oj.jar").
Ulya Trafimovichc0c98d52020-03-09 12:46:06 +0000692 Flag("--force-determinism").
Colin Cross800fe132019-02-11 14:21:24 -0800693 Flag("--abort-on-hard-verifier-error")
694
David Srbecky7f8dac12020-02-13 16:00:45 +0000695 // Use the default variant/features for host builds.
696 // The map below contains only device CPU info (which might be x86 on some devices).
697 if image.target.Os == android.Android {
698 cmd.FlagWithArg("--instruction-set-variant=", global.CpuVariant[arch])
699 cmd.FlagWithArg("--instruction-set-features=", global.InstructionSetFeatures[arch])
700 }
701
Colin Cross44df5812019-02-15 23:06:46 -0800702 if global.BootFlags != "" {
703 cmd.Flag(global.BootFlags)
Colin Cross800fe132019-02-11 14:21:24 -0800704 }
705
706 if extraFlags != "" {
707 cmd.Flag(extraFlags)
708 }
709
Colin Cross0b9f31f2019-02-28 11:00:01 -0800710 cmd.Textf(`|| ( echo %s ; false )`, proptools.ShellEscape(failureMessage))
Colin Cross800fe132019-02-11 14:21:24 -0800711
Ulya Trafimovich4d2eeed2019-11-08 10:54:21 +0000712 installDir := filepath.Join("/", image.installSubdir, arch.String())
Colin Cross800fe132019-02-11 14:21:24 -0800713
Colin Cross800fe132019-02-11 14:21:24 -0800714 var vdexInstalls android.RuleBuilderInstalls
715 var unstrippedInstalls android.RuleBuilderInstalls
716
Colin Crossdf8eebe2019-04-09 15:29:41 -0700717 var zipFiles android.WritablePaths
718
Dan Willemsen0f416782019-06-13 21:44:53 +0000719 for _, artOrOat := range image.moduleFiles(ctx, outputDir, ".art", ".oat") {
720 cmd.ImplicitOutput(artOrOat)
721 zipFiles = append(zipFiles, artOrOat)
Colin Cross800fe132019-02-11 14:21:24 -0800722
Dan Willemsen0f416782019-06-13 21:44:53 +0000723 // Install the .oat and .art files
724 rule.Install(artOrOat, filepath.Join(installDir, artOrOat.Base()))
725 }
Colin Cross800fe132019-02-11 14:21:24 -0800726
Dan Willemsen0f416782019-06-13 21:44:53 +0000727 for _, vdex := range image.moduleFiles(ctx, outputDir, ".vdex") {
728 cmd.ImplicitOutput(vdex)
729 zipFiles = append(zipFiles, vdex)
Colin Cross800fe132019-02-11 14:21:24 -0800730
David Srbecky7f8dac12020-02-13 16:00:45 +0000731 // Note that the vdex files are identical between architectures.
732 // Make rules will create symlinks to share them between architectures.
Colin Cross800fe132019-02-11 14:21:24 -0800733 vdexInstalls = append(vdexInstalls,
David Srbecky7f8dac12020-02-13 16:00:45 +0000734 android.RuleBuilderInstall{vdex, filepath.Join(installDir, vdex.Base())})
Dan Willemsen0f416782019-06-13 21:44:53 +0000735 }
736
737 for _, unstrippedOat := range image.moduleFiles(ctx, symbolsDir, ".oat") {
738 cmd.ImplicitOutput(unstrippedOat)
Colin Cross800fe132019-02-11 14:21:24 -0800739
740 // Install the unstripped oat files. The Make rules will put these in $(TARGET_OUT_UNSTRIPPED)
741 unstrippedInstalls = append(unstrippedInstalls,
Colin Cross69f59a32019-02-15 10:39:37 -0800742 android.RuleBuilderInstall{unstrippedOat, filepath.Join(installDir, unstrippedOat.Base())})
Colin Cross800fe132019-02-11 14:21:24 -0800743 }
744
Colin Crossf1a035e2020-11-16 17:32:30 -0800745 rule.Build(image.name+"JarsDexpreopt_"+image.target.String(), "dexpreopt "+image.name+" jars "+arch.String())
Colin Cross800fe132019-02-11 14:21:24 -0800746
747 // save output and installed files for makevars
David Srbeckyc177ebe2020-02-18 20:43:06 +0000748 image.installs = rule.Installs()
749 image.vdexInstalls = vdexInstalls
750 image.unstrippedInstalls = unstrippedInstalls
Colin Crossdf8eebe2019-04-09 15:29:41 -0700751
752 return zipFiles
Colin Cross800fe132019-02-11 14:21:24 -0800753}
754
755const failureMessage = `ERROR: Dex2oat failed to compile a boot image.
756It is likely that the boot classpath is inconsistent.
757Rebuild with ART_BOOT_IMAGE_EXTRA_ARGS="--runtime-arg -verbose:verifier" to see verification errors.`
758
David Srbeckyc177ebe2020-02-18 20:43:06 +0000759func bootImageProfileRule(ctx android.SingletonContext, image *bootImageConfig, missingDeps []string) android.WritablePath {
Martin Stjernholm75a48d82020-01-10 20:32:59 +0000760 globalSoong := dexpreopt.GetCachedGlobalSoongConfig(ctx)
Martin Stjernholm40f9f3c2020-01-20 18:12:23 +0000761 global := dexpreopt.GetGlobalConfig(ctx)
Nicolas Geoffray27c7cc62019-02-24 16:04:52 +0000762
Ulya Trafimovicha4a1c4e2021-01-15 18:40:04 +0000763 if global.DisableGenerateProfile {
Nicolas Geoffray27c7cc62019-02-24 16:04:52 +0000764 return nil
765 }
Ulyana Trafimovichde534412019-11-08 10:51:01 +0000766 profile := ctx.Config().Once(bootImageProfileRuleKey, func() interface{} {
Ulyana Trafimovichde534412019-11-08 10:51:01 +0000767 defaultProfile := "frameworks/base/config/boot-image-profile.txt"
Colin Cross800fe132019-02-11 14:21:24 -0800768
Colin Crossf1a035e2020-11-16 17:32:30 -0800769 rule := android.NewRuleBuilder(pctx, ctx)
Nicolas Geoffray72892f12019-02-22 15:34:40 +0000770 rule.MissingDeps(missingDeps)
Colin Cross800fe132019-02-11 14:21:24 -0800771
Nicolas Geoffray72892f12019-02-22 15:34:40 +0000772 var bootImageProfile android.Path
773 if len(global.BootImageProfiles) > 1 {
774 combinedBootImageProfile := image.dir.Join(ctx, "boot-image-profile.txt")
775 rule.Command().Text("cat").Inputs(global.BootImageProfiles).Text(">").Output(combinedBootImageProfile)
776 bootImageProfile = combinedBootImageProfile
777 } else if len(global.BootImageProfiles) == 1 {
778 bootImageProfile = global.BootImageProfiles[0]
Ulyana Trafimovichde534412019-11-08 10:51:01 +0000779 } else if path := android.ExistentPathForSource(ctx, defaultProfile); path.Valid() {
780 bootImageProfile = path.Path()
Nicolas Geoffray72892f12019-02-22 15:34:40 +0000781 } else {
Ulyana Trafimovichde534412019-11-08 10:51:01 +0000782 // No profile (not even a default one, which is the case on some branches
783 // like master-art-host that don't have frameworks/base).
784 // Return nil and continue without profile.
785 return nil
Nicolas Geoffray72892f12019-02-22 15:34:40 +0000786 }
Colin Cross800fe132019-02-11 14:21:24 -0800787
Nicolas Geoffray72892f12019-02-22 15:34:40 +0000788 profile := image.dir.Join(ctx, "boot.prof")
Colin Cross800fe132019-02-11 14:21:24 -0800789
Nicolas Geoffray72892f12019-02-22 15:34:40 +0000790 rule.Command().
791 Text(`ANDROID_LOG_TAGS="*:e"`).
Martin Stjernholm75a48d82020-01-10 20:32:59 +0000792 Tool(globalSoong.Profman).
Nicolas Geoffray72892f12019-02-22 15:34:40 +0000793 FlagWithInput("--create-profile-from=", bootImageProfile).
Ulya Trafimovich4d2eeed2019-11-08 10:54:21 +0000794 FlagForEachInput("--apk=", image.dexPathsDeps.Paths()).
David Srbeckyab994982020-03-30 17:24:13 +0100795 FlagForEachArg("--dex-location=", image.getAnyAndroidVariant().dexLocationsDeps).
Nicolas Geoffray72892f12019-02-22 15:34:40 +0000796 FlagWithOutput("--reference-profile-file=", profile)
Colin Cross800fe132019-02-11 14:21:24 -0800797
Nicolas Geoffray72892f12019-02-22 15:34:40 +0000798 rule.Install(profile, "/system/etc/boot-image.prof")
799
Colin Crossf1a035e2020-11-16 17:32:30 -0800800 rule.Build("bootJarsProfile", "profile boot jars")
Nicolas Geoffray72892f12019-02-22 15:34:40 +0000801
802 image.profileInstalls = rule.Installs()
803
804 return profile
Ulyana Trafimovichde534412019-11-08 10:51:01 +0000805 })
806 if profile == nil {
807 return nil // wrap nil into a typed pointer with value nil
808 }
809 return profile.(android.WritablePath)
Colin Cross800fe132019-02-11 14:21:24 -0800810}
811
Nicolas Geoffray72892f12019-02-22 15:34:40 +0000812var bootImageProfileRuleKey = android.NewOnceKey("bootImageProfileRule")
813
David Srbeckyc177ebe2020-02-18 20:43:06 +0000814func bootFrameworkProfileRule(ctx android.SingletonContext, image *bootImageConfig, missingDeps []string) android.WritablePath {
Martin Stjernholm75a48d82020-01-10 20:32:59 +0000815 globalSoong := dexpreopt.GetCachedGlobalSoongConfig(ctx)
Martin Stjernholm40f9f3c2020-01-20 18:12:23 +0000816 global := dexpreopt.GetGlobalConfig(ctx)
Nicolas Geoffraye7102422019-07-24 13:19:29 +0100817
Dan Willemsen9f435972020-05-28 15:28:00 -0700818 if global.DisableGenerateProfile || ctx.Config().UnbundledBuild() {
Nicolas Geoffraye7102422019-07-24 13:19:29 +0100819 return nil
820 }
821 return ctx.Config().Once(bootFrameworkProfileRuleKey, func() interface{} {
Colin Crossf1a035e2020-11-16 17:32:30 -0800822 rule := android.NewRuleBuilder(pctx, ctx)
Nicolas Geoffraye7102422019-07-24 13:19:29 +0100823 rule.MissingDeps(missingDeps)
824
825 // Some branches like master-art-host don't have frameworks/base, so manually
826 // handle the case that the default is missing. Those branches won't attempt to build the profile rule,
827 // and if they do they'll get a missing deps error.
828 defaultProfile := "frameworks/base/config/boot-profile.txt"
829 path := android.ExistentPathForSource(ctx, defaultProfile)
830 var bootFrameworkProfile android.Path
831 if path.Valid() {
832 bootFrameworkProfile = path.Path()
833 } else {
834 missingDeps = append(missingDeps, defaultProfile)
Paul Duffin7f48eef2020-12-03 11:15:58 +0000835 bootFrameworkProfile = android.PathForOutput(ctx, "missing", defaultProfile)
Nicolas Geoffraye7102422019-07-24 13:19:29 +0100836 }
837
838 profile := image.dir.Join(ctx, "boot.bprof")
839
840 rule.Command().
841 Text(`ANDROID_LOG_TAGS="*:e"`).
Martin Stjernholm75a48d82020-01-10 20:32:59 +0000842 Tool(globalSoong.Profman).
Nicolas Geoffraye7102422019-07-24 13:19:29 +0100843 Flag("--generate-boot-profile").
844 FlagWithInput("--create-profile-from=", bootFrameworkProfile).
Ulya Trafimovich4d2eeed2019-11-08 10:54:21 +0000845 FlagForEachInput("--apk=", image.dexPathsDeps.Paths()).
David Srbeckyab994982020-03-30 17:24:13 +0100846 FlagForEachArg("--dex-location=", image.getAnyAndroidVariant().dexLocationsDeps).
Nicolas Geoffraye7102422019-07-24 13:19:29 +0100847 FlagWithOutput("--reference-profile-file=", profile)
848
849 rule.Install(profile, "/system/etc/boot-image.bprof")
Colin Crossf1a035e2020-11-16 17:32:30 -0800850 rule.Build("bootFrameworkProfile", "profile boot framework jars")
Nicolas Geoffraye7102422019-07-24 13:19:29 +0100851 image.profileInstalls = append(image.profileInstalls, rule.Installs()...)
852
853 return profile
854 }).(android.WritablePath)
855}
856
857var bootFrameworkProfileRuleKey = android.NewOnceKey("bootFrameworkProfileRule")
858
Vladimir Marko205e6c22020-04-01 13:52:27 +0100859func updatableBcpPackagesRule(ctx android.SingletonContext, image *bootImageConfig, missingDeps []string) android.WritablePath {
Dan Willemsen9f435972020-05-28 15:28:00 -0700860 if ctx.Config().UnbundledBuild() {
Vladimir Marko205e6c22020-04-01 13:52:27 +0100861 return nil
862 }
863
864 return ctx.Config().Once(updatableBcpPackagesRuleKey, func() interface{} {
865 global := dexpreopt.GetGlobalConfig(ctx)
Ulya Trafimovich249386a2020-07-01 14:31:13 +0100866 updatableModules := global.UpdatableBootJars.CopyOfJars()
Vladimir Marko205e6c22020-04-01 13:52:27 +0100867
868 // Collect `permitted_packages` for updatable boot jars.
869 var updatablePackages []string
870 ctx.VisitAllModules(func(module android.Module) {
Martin Stjernholm1dc0d6d2021-01-17 21:05:12 +0000871 if !isActiveModule(module) {
872 return
873 }
Paul Duffine739f1e2020-05-29 11:24:51 +0100874 if j, ok := module.(PermittedPackagesForUpdatableBootJars); ok {
Vladimir Marko205e6c22020-04-01 13:52:27 +0100875 name := ctx.ModuleName(module)
876 if i := android.IndexList(name, updatableModules); i != -1 {
Paul Duffine739f1e2020-05-29 11:24:51 +0100877 pp := j.PermittedPackagesForUpdatableBootJars()
Vladimir Marko205e6c22020-04-01 13:52:27 +0100878 if len(pp) > 0 {
879 updatablePackages = append(updatablePackages, pp...)
880 } else {
881 ctx.Errorf("Missing permitted_packages for %s", name)
882 }
883 // Do not match the same library repeatedly.
884 updatableModules = append(updatableModules[:i], updatableModules[i+1:]...)
885 }
886 }
887 })
888
889 // Sort updatable packages to ensure deterministic ordering.
890 sort.Strings(updatablePackages)
891
892 updatableBcpPackagesName := "updatable-bcp-packages.txt"
893 updatableBcpPackages := image.dir.Join(ctx, updatableBcpPackagesName)
894
Colin Crosscf371cc2020-11-13 11:48:42 -0800895 // WriteFileRule automatically adds the last end-of-line.
896 android.WriteFileRule(ctx, updatableBcpPackages, strings.Join(updatablePackages, "\n"))
Vladimir Marko205e6c22020-04-01 13:52:27 +0100897
Colin Crossf1a035e2020-11-16 17:32:30 -0800898 rule := android.NewRuleBuilder(pctx, ctx)
Vladimir Marko205e6c22020-04-01 13:52:27 +0100899 rule.MissingDeps(missingDeps)
900 rule.Install(updatableBcpPackages, "/system/etc/"+updatableBcpPackagesName)
901 // TODO: Rename `profileInstalls` to `extraInstalls`?
902 // Maybe even move the field out of the bootImageConfig into some higher level type?
903 image.profileInstalls = append(image.profileInstalls, rule.Installs()...)
904
905 return updatableBcpPackages
906 }).(android.WritablePath)
907}
908
909var updatableBcpPackagesRuleKey = android.NewOnceKey("updatableBcpPackagesRule")
910
David Srbeckyc177ebe2020-02-18 20:43:06 +0000911func dumpOatRules(ctx android.SingletonContext, image *bootImageConfig) {
Colin Crossc9a4c362019-02-26 21:13:48 -0800912 var allPhonies android.Paths
David Srbeckyc177ebe2020-02-18 20:43:06 +0000913 for _, image := range image.variants {
914 arch := image.target.Arch.ArchType
David Srbecky46672322020-03-16 13:27:55 +0000915 suffix := arch.String()
916 // Host and target might both use x86 arch. We need to ensure the names are unique.
917 if image.target.Os.Class == android.Host {
918 suffix = "host-" + suffix
919 }
Colin Crossc9a4c362019-02-26 21:13:48 -0800920 // Create a rule to call oatdump.
David Srbecky7f8dac12020-02-13 16:00:45 +0000921 output := android.PathForOutput(ctx, "boot."+suffix+".oatdump.txt")
Colin Crossf1a035e2020-11-16 17:32:30 -0800922 rule := android.NewRuleBuilder(pctx, ctx)
Colin Crossc9a4c362019-02-26 21:13:48 -0800923 rule.Command().
924 // TODO: for now, use the debug version for better error reporting
Colin Crossf1a035e2020-11-16 17:32:30 -0800925 BuiltTool("oatdumpd").
Ulya Trafimovich4d2eeed2019-11-08 10:54:21 +0000926 FlagWithInputList("--runtime-arg -Xbootclasspath:", image.dexPathsDeps.Paths(), ":").
927 FlagWithList("--runtime-arg -Xbootclasspath-locations:", image.dexLocationsDeps, ":").
David Srbecky1aacc6c2020-03-26 11:10:45 +0000928 FlagWithArg("--image=", strings.Join(image.imageLocations(), ":")).Implicits(image.imagesDeps.Paths()).
Colin Crossc9a4c362019-02-26 21:13:48 -0800929 FlagWithOutput("--output=", output).
930 FlagWithArg("--instruction-set=", arch.String())
Colin Crossf1a035e2020-11-16 17:32:30 -0800931 rule.Build("dump-oat-boot-"+suffix, "dump oat boot "+arch.String())
Colin Crossc9a4c362019-02-26 21:13:48 -0800932
933 // Create a phony rule that depends on the output file and prints the path.
David Srbecky7f8dac12020-02-13 16:00:45 +0000934 phony := android.PathForPhony(ctx, "dump-oat-boot-"+suffix)
Colin Crossf1a035e2020-11-16 17:32:30 -0800935 rule = android.NewRuleBuilder(pctx, ctx)
Colin Crossc9a4c362019-02-26 21:13:48 -0800936 rule.Command().
937 Implicit(output).
938 ImplicitOutput(phony).
939 Text("echo").FlagWithArg("Output in ", output.String())
Colin Crossf1a035e2020-11-16 17:32:30 -0800940 rule.Build("phony-dump-oat-boot-"+suffix, "dump oat boot "+arch.String())
Colin Crossc9a4c362019-02-26 21:13:48 -0800941
David Srbecky1aacc6c2020-03-26 11:10:45 +0000942 allPhonies = append(allPhonies, phony)
Colin Crossc9a4c362019-02-26 21:13:48 -0800943 }
944
945 phony := android.PathForPhony(ctx, "dump-oat-boot")
946 ctx.Build(pctx, android.BuildParams{
947 Rule: android.Phony,
948 Output: phony,
949 Inputs: allPhonies,
950 Description: "dump-oat-boot",
951 })
952
953}
954
Colin Cross2d00f0d2019-05-09 21:50:00 -0700955func writeGlobalConfigForMake(ctx android.SingletonContext, path android.WritablePath) {
Martin Stjernholm40f9f3c2020-01-20 18:12:23 +0000956 data := dexpreopt.GetGlobalConfigRawData(ctx)
Colin Cross2d00f0d2019-05-09 21:50:00 -0700957
Colin Crosscf371cc2020-11-13 11:48:42 -0800958 android.WriteFileRule(ctx, path, string(data))
Colin Cross2d00f0d2019-05-09 21:50:00 -0700959}
960
Ulya Trafimovich3bfabf22020-11-20 17:28:51 +0000961// Define Make variables for boot image names, paths, etc. These variables are used in makefiles
962// (make/core/dex_preopt_libart.mk) to generate install rules that copy boot image files to the
963// correct output directories.
Colin Cross44df5812019-02-15 23:06:46 -0800964func (d *dexpreoptBootJars) MakeVars(ctx android.MakeVarsContext) {
Colin Cross2d00f0d2019-05-09 21:50:00 -0700965 if d.dexpreoptConfigForMake != nil {
966 ctx.Strict("DEX_PREOPT_CONFIG_FOR_MAKE", d.dexpreoptConfigForMake.String())
Martin Stjernholmc52aaf12020-01-06 23:11:37 +0000967 ctx.Strict("DEX_PREOPT_SOONG_CONFIG_FOR_MAKE", android.PathForOutput(ctx, "dexpreopt_soong.config").String())
Colin Cross2d00f0d2019-05-09 21:50:00 -0700968 }
969
Colin Cross44df5812019-02-15 23:06:46 -0800970 image := d.defaultBootImage
971 if image != nil {
Colin Cross44df5812019-02-15 23:06:46 -0800972 ctx.Strict("DEXPREOPT_IMAGE_PROFILE_BUILT_INSTALLED", image.profileInstalls.String())
Ulya Trafimovich4d2eeed2019-11-08 10:54:21 +0000973 ctx.Strict("DEXPREOPT_BOOTCLASSPATH_DEX_FILES", strings.Join(image.dexPathsDeps.Strings(), " "))
David Srbeckyab994982020-03-30 17:24:13 +0100974 ctx.Strict("DEXPREOPT_BOOTCLASSPATH_DEX_LOCATIONS", strings.Join(image.getAnyAndroidVariant().dexLocationsDeps, " "))
Nicolas Geoffray72892f12019-02-22 15:34:40 +0000975
976 var imageNames []string
Ulya Trafimovich3bfabf22020-11-20 17:28:51 +0000977 // TODO: the primary ART boot image should not be exposed to Make, as it is installed in a
978 // different way as a part of the ART APEX. However, there is a special JIT-Zygote build
979 // configuration which uses the primary ART image instead of the Framework boot image
980 // extension, and it relies on the ART image being exposed to Make. To fix this, it is
981 // necessary to rework the logic in makefiles.
Nicolas Geoffray72892f12019-02-22 15:34:40 +0000982 for _, current := range append(d.otherImages, image) {
983 imageNames = append(imageNames, current.name)
David Srbecky1aacc6c2020-03-26 11:10:45 +0000984 for _, variant := range current.variants {
David Srbecky7f8dac12020-02-13 16:00:45 +0000985 suffix := ""
David Srbecky1aacc6c2020-03-26 11:10:45 +0000986 if variant.target.Os.Class == android.Host {
David Srbecky7f8dac12020-02-13 16:00:45 +0000987 suffix = "_host"
988 }
David Srbecky1aacc6c2020-03-26 11:10:45 +0000989 sfx := variant.name + suffix + "_" + variant.target.Arch.ArchType.String()
990 ctx.Strict("DEXPREOPT_IMAGE_VDEX_BUILT_INSTALLED_"+sfx, variant.vdexInstalls.String())
991 ctx.Strict("DEXPREOPT_IMAGE_"+sfx, variant.images.String())
992 ctx.Strict("DEXPREOPT_IMAGE_DEPS_"+sfx, strings.Join(variant.imagesDeps.Strings(), " "))
993 ctx.Strict("DEXPREOPT_IMAGE_BUILT_INSTALLED_"+sfx, variant.installs.String())
994 ctx.Strict("DEXPREOPT_IMAGE_UNSTRIPPED_BUILT_INSTALLED_"+sfx, variant.unstrippedInstalls.String())
Nicolas Geoffray72892f12019-02-22 15:34:40 +0000995 }
David Srbeckyab994982020-03-30 17:24:13 +0100996 imageLocations := current.getAnyAndroidVariant().imageLocations()
David Srbecky1aacc6c2020-03-26 11:10:45 +0000997 ctx.Strict("DEXPREOPT_IMAGE_LOCATIONS_"+current.name, strings.Join(imageLocations, ":"))
Colin Cross31bf00d2019-12-04 13:16:01 -0800998 ctx.Strict("DEXPREOPT_IMAGE_ZIP_"+current.name, current.zip.String())
Nicolas Geoffray72892f12019-02-22 15:34:40 +0000999 }
1000 ctx.Strict("DEXPREOPT_IMAGE_NAMES", strings.Join(imageNames, " "))
Colin Cross800fe132019-02-11 14:21:24 -08001001 }
Colin Cross800fe132019-02-11 14:21:24 -08001002}