blob: 2b38793ffd7d3c350cb45006c7e2b98579bf54a7 [file] [log] [blame]
Colin Cross43f08db2018-11-12 10:13:39 -08001// Copyright 2018 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// The dexpreopt package converts a global dexpreopt config and a module dexpreopt config into rules to perform
Nicolas Geoffrayc1bf7242019-10-18 14:51:38 +010016// dexpreopting.
Colin Cross43f08db2018-11-12 10:13:39 -080017//
18// It is used in two places; in the dexpeopt_gen binary for modules defined in Make, and directly linked into Soong.
19//
20// For Make modules it is built into the dexpreopt_gen binary, which is executed as a Make rule using global config and
21// module config specified in JSON files. The binary writes out two shell scripts, only updating them if they have
22// changed. One script takes an APK or JAR as an input and produces a zip file containing any outputs of preopting,
23// in the location they should be on the device. The Make build rules will unzip the zip file into $(PRODUCT_OUT) when
24// installing the APK, which will install the preopt outputs into $(PRODUCT_OUT)/system or $(PRODUCT_OUT)/system_other
Nicolas Geoffrayc1bf7242019-10-18 14:51:38 +010025// as necessary. The zip file may be empty if preopting was disabled for any reason.
Colin Cross43f08db2018-11-12 10:13:39 -080026//
27// The intermediate shell scripts allow changes to this package or to the global config to regenerate the shell scripts
28// but only require re-executing preopting if the script has changed.
29//
30// For Soong modules this package is linked directly into Soong and run from the java package. It generates the same
31// commands as for make, using athe same global config JSON file used by make, but using a module config structure
32// provided by Soong. The generated commands are then converted into Soong rule and written directly to the ninja file,
33// with no extra shell scripts involved.
34package dexpreopt
35
36import (
37 "fmt"
38 "path/filepath"
Colin Cross69f59a32019-02-15 10:39:37 -080039 "runtime"
Colin Cross43f08db2018-11-12 10:13:39 -080040 "strings"
41
Colin Crossfeec25b2019-01-30 17:32:39 -080042 "android/soong/android"
43
Colin Cross43f08db2018-11-12 10:13:39 -080044 "github.com/google/blueprint/pathtools"
45)
46
47const SystemPartition = "/system/"
48const SystemOtherPartition = "/system_other/"
49
Ulya Trafimovich6cf2c0c2020-04-24 12:15:20 +010050var DexpreoptRunningInSoong = false
51
Colin Cross43f08db2018-11-12 10:13:39 -080052// GenerateDexpreoptRule generates a set of commands that will preopt a module based on a GlobalConfig and a
53// ModuleConfig. The produced files and their install locations will be available through rule.Installs().
Colin Crossf1a035e2020-11-16 17:32:30 -080054func GenerateDexpreoptRule(ctx android.BuilderContext, globalSoong *GlobalSoongConfig,
Martin Stjernholm8d80cee2020-01-31 17:44:54 +000055 global *GlobalConfig, module *ModuleConfig) (rule *android.RuleBuilder, err error) {
Colin Cross69f59a32019-02-15 10:39:37 -080056
Colin Cross43f08db2018-11-12 10:13:39 -080057 defer func() {
58 if r := recover(); r != nil {
Colin Cross69f59a32019-02-15 10:39:37 -080059 if _, ok := r.(runtime.Error); ok {
60 panic(r)
61 } else if e, ok := r.(error); ok {
Colin Cross43f08db2018-11-12 10:13:39 -080062 err = e
63 rule = nil
64 } else {
65 panic(r)
66 }
67 }
68 }()
69
Colin Crossf1a035e2020-11-16 17:32:30 -080070 rule = android.NewRuleBuilder(pctx, ctx)
Colin Cross43f08db2018-11-12 10:13:39 -080071
Colin Cross69f59a32019-02-15 10:39:37 -080072 generateProfile := module.ProfileClassListing.Valid() && !global.DisableGenerateProfile
Nicolas Geoffraye7102422019-07-24 13:19:29 +010073 generateBootProfile := module.ProfileBootListing.Valid() && !global.DisableGenerateProfile
Colin Cross43f08db2018-11-12 10:13:39 -080074
Colin Cross69f59a32019-02-15 10:39:37 -080075 var profile android.WritablePath
Colin Crosscbed6572019-01-08 17:38:37 -080076 if generateProfile {
Martin Stjernholm75a48d82020-01-10 20:32:59 +000077 profile = profileCommand(ctx, globalSoong, global, module, rule)
Colin Crosscbed6572019-01-08 17:38:37 -080078 }
Nicolas Geoffraye7102422019-07-24 13:19:29 +010079 if generateBootProfile {
Martin Stjernholm75a48d82020-01-10 20:32:59 +000080 bootProfileCommand(ctx, globalSoong, global, module, rule)
Nicolas Geoffraye7102422019-07-24 13:19:29 +010081 }
Colin Crosscbed6572019-01-08 17:38:37 -080082
Ulya Trafimovichf3ff0102019-12-03 15:39:23 +000083 if !dexpreoptDisabled(ctx, global, module) {
Ulya Trafimovich8cbc5d22020-11-03 15:15:46 +000084 if valid, err := validateClassLoaderContext(module.ClassLoaderContexts); err != nil {
Ulya Trafimovich69612672020-10-20 17:41:54 +010085 android.ReportPathErrorf(ctx, err.Error())
Ulya Trafimovich8cbc5d22020-11-03 15:15:46 +000086 } else if valid {
87 fixClassLoaderContext(module.ClassLoaderContexts)
88
Colin Crosscbed6572019-01-08 17:38:37 -080089 appImage := (generateProfile || module.ForceCreateAppImage || global.DefaultAppImages) &&
90 !module.NoCreateAppImage
91
92 generateDM := shouldGenerateDM(module, global)
93
Ulya Trafimovich4d2eeed2019-11-08 10:54:21 +000094 for archIdx, _ := range module.Archs {
Ulya Trafimovich8cbc5d22020-11-03 15:15:46 +000095 dexpreoptCommand(ctx, globalSoong, global, module, rule, archIdx, profile, appImage, generateDM)
Colin Crosscbed6572019-01-08 17:38:37 -080096 }
97 }
98 }
99
100 return rule, nil
101}
102
Jiakai Zhangcf61e3c2023-05-08 16:28:38 +0000103// If dexpreopt is applicable to the module, returns whether dexpreopt is disabled. Otherwise, the
104// behavior is undefined.
105// When it returns true, dexpreopt artifacts will not be generated, but profile will still be
106// generated if profile-guided compilation is requested.
Martin Stjernholm8d80cee2020-01-31 17:44:54 +0000107func dexpreoptDisabled(ctx android.PathContext, global *GlobalConfig, module *ModuleConfig) bool {
Jiakai Zhang3317ce72023-02-08 01:19:19 +0800108 if ctx.Config().UnbundledBuild() {
109 return true
110 }
111
Jiakai Zhangcf61e3c2023-05-08 16:28:38 +0000112 if global.DisablePreopt {
113 return true
114 }
115
Colin Crosscbed6572019-01-08 17:38:37 -0800116 if contains(global.DisablePreoptModules, module.Name) {
117 return true
Colin Cross43f08db2018-11-12 10:13:39 -0800118 }
119
Ulya Trafimovichfc24ad32020-08-19 16:32:54 +0100120 // Don't preopt individual boot jars, they will be preopted together.
121 if global.BootJars.ContainsJar(module.Name) {
122 return true
123 }
124
Colin Cross43f08db2018-11-12 10:13:39 -0800125 // If OnlyPreoptBootImageAndSystemServer=true and module is not in boot class path skip
126 // Also preopt system server jars since selinux prevents system server from loading anything from
127 // /data. If we don't do this they will need to be extracted which is not favorable for RAM usage
128 // or performance. If PreoptExtractedApk is true, we ignore the only preopt boot image options.
Ulya Trafimovich249386a2020-07-01 14:31:13 +0100129 if global.OnlyPreoptBootImageAndSystemServer && !global.BootJars.ContainsJar(module.Name) &&
Jiakai Zhang389a6472021-12-14 18:54:06 +0000130 !global.AllSystemServerJars(ctx).ContainsJar(module.Name) && !module.PreoptExtractedApk {
Colin Crosscbed6572019-01-08 17:38:37 -0800131 return true
Colin Cross43f08db2018-11-12 10:13:39 -0800132 }
133
Colin Crosscbed6572019-01-08 17:38:37 -0800134 return false
Colin Cross43f08db2018-11-12 10:13:39 -0800135}
136
Martin Stjernholm8d80cee2020-01-31 17:44:54 +0000137func profileCommand(ctx android.PathContext, globalSoong *GlobalSoongConfig, global *GlobalConfig,
138 module *ModuleConfig, rule *android.RuleBuilder) android.WritablePath {
Colin Cross69f59a32019-02-15 10:39:37 -0800139
140 profilePath := module.BuildPath.InSameDir(ctx, "profile.prof")
Colin Cross43f08db2018-11-12 10:13:39 -0800141 profileInstalledPath := module.DexLocation + ".prof"
142
143 if !module.ProfileIsTextListing {
Vladimir Marko982e3842021-04-29 09:05:18 +0100144 rule.Command().Text("rm -f").Output(profilePath)
145 rule.Command().Text("touch").Output(profilePath)
Colin Cross43f08db2018-11-12 10:13:39 -0800146 }
147
148 cmd := rule.Command().
149 Text(`ANDROID_LOG_TAGS="*:e"`).
Martin Stjernholm75a48d82020-01-10 20:32:59 +0000150 Tool(globalSoong.Profman)
Colin Cross43f08db2018-11-12 10:13:39 -0800151
152 if module.ProfileIsTextListing {
153 // The profile is a test listing of classes (used for framework jars).
154 // We need to generate the actual binary profile before being able to compile.
Colin Cross69f59a32019-02-15 10:39:37 -0800155 cmd.FlagWithInput("--create-profile-from=", module.ProfileClassListing.Path())
Colin Cross43f08db2018-11-12 10:13:39 -0800156 } else {
157 // The profile is binary profile (used for apps). Run it through profman to
158 // ensure the profile keys match the apk.
159 cmd.
160 Flag("--copy-and-update-profile-key").
Colin Cross69f59a32019-02-15 10:39:37 -0800161 FlagWithInput("--profile-file=", module.ProfileClassListing.Path())
Colin Cross43f08db2018-11-12 10:13:39 -0800162 }
163
164 cmd.
Vladimir Marko230bd422021-04-23 15:18:33 +0100165 Flag("--output-profile-type=app").
Colin Cross43f08db2018-11-12 10:13:39 -0800166 FlagWithInput("--apk=", module.DexPath).
167 Flag("--dex-location="+module.DexLocation).
168 FlagWithOutput("--reference-profile-file=", profilePath)
169
170 if !module.ProfileIsTextListing {
171 cmd.Text(fmt.Sprintf(`|| echo "Profile out of date for %s"`, module.DexPath))
172 }
173 rule.Install(profilePath, profileInstalledPath)
174
175 return profilePath
176}
177
Martin Stjernholm8d80cee2020-01-31 17:44:54 +0000178func bootProfileCommand(ctx android.PathContext, globalSoong *GlobalSoongConfig, global *GlobalConfig,
179 module *ModuleConfig, rule *android.RuleBuilder) android.WritablePath {
Nicolas Geoffraye7102422019-07-24 13:19:29 +0100180
181 profilePath := module.BuildPath.InSameDir(ctx, "profile.bprof")
182 profileInstalledPath := module.DexLocation + ".bprof"
183
184 if !module.ProfileIsTextListing {
Vladimir Marko982e3842021-04-29 09:05:18 +0100185 rule.Command().Text("rm -f").Output(profilePath)
186 rule.Command().Text("touch").Output(profilePath)
Nicolas Geoffraye7102422019-07-24 13:19:29 +0100187 }
188
189 cmd := rule.Command().
190 Text(`ANDROID_LOG_TAGS="*:e"`).
Martin Stjernholm75a48d82020-01-10 20:32:59 +0000191 Tool(globalSoong.Profman)
Nicolas Geoffraye7102422019-07-24 13:19:29 +0100192
193 // The profile is a test listing of methods.
194 // We need to generate the actual binary profile.
195 cmd.FlagWithInput("--create-profile-from=", module.ProfileBootListing.Path())
196
197 cmd.
Vladimir Marko230bd422021-04-23 15:18:33 +0100198 Flag("--output-profile-type=bprof").
Nicolas Geoffraye7102422019-07-24 13:19:29 +0100199 FlagWithInput("--apk=", module.DexPath).
200 Flag("--dex-location="+module.DexLocation).
201 FlagWithOutput("--reference-profile-file=", profilePath)
202
203 if !module.ProfileIsTextListing {
204 cmd.Text(fmt.Sprintf(`|| echo "Profile out of date for %s"`, module.DexPath))
205 }
206 rule.Install(profilePath, profileInstalledPath)
207
208 return profilePath
209}
210
Jiakai Zhang519c5c82021-09-16 06:15:39 +0000211// Returns the dex location of a system server java library.
Jiakai Zhang389a6472021-12-14 18:54:06 +0000212func GetSystemServerDexLocation(ctx android.PathContext, global *GlobalConfig, lib string) string {
213 if apex := global.AllApexSystemServerJars(ctx).ApexOfJar(lib); apex != "" {
Jiakai Zhang519c5c82021-09-16 06:15:39 +0000214 return fmt.Sprintf("/apex/%s/javalib/%s.jar", apex, lib)
215 }
liulvping76d56ee2022-05-07 14:40:13 +0800216
217 if apex := global.AllPlatformSystemServerJars(ctx).ApexOfJar(lib); apex == "system_ext" {
218 return fmt.Sprintf("/system_ext/framework/%s.jar", lib)
219 }
220
Jiakai Zhang519c5c82021-09-16 06:15:39 +0000221 return fmt.Sprintf("/system/framework/%s.jar", lib)
222}
223
Jiakai Zhang0a0a2fb2021-09-30 09:38:19 +0000224// Returns the location to the odex file for the dex file at `path`.
225func ToOdexPath(path string, arch android.ArchType) string {
226 if strings.HasPrefix(path, "/apex/") {
227 return filepath.Join("/system/framework/oat", arch.String(),
228 strings.ReplaceAll(path[1:], "/", "@")+"@classes.odex")
229 }
230
231 return filepath.Join(filepath.Dir(path), "oat", arch.String(),
232 pathtools.ReplaceExtension(filepath.Base(path), "odex"))
233}
234
Martin Stjernholm8d80cee2020-01-31 17:44:54 +0000235func dexpreoptCommand(ctx android.PathContext, globalSoong *GlobalSoongConfig, global *GlobalConfig,
Ulya Trafimovich8cbc5d22020-11-03 15:15:46 +0000236 module *ModuleConfig, rule *android.RuleBuilder, archIdx int, profile android.WritablePath,
237 appImage bool, generateDM bool) {
Ulya Trafimovich4d2eeed2019-11-08 10:54:21 +0000238
239 arch := module.Archs[archIdx]
Colin Cross43f08db2018-11-12 10:13:39 -0800240
241 // HACK: make soname in Soong-generated .odex files match Make.
242 base := filepath.Base(module.DexLocation)
243 if filepath.Ext(base) == ".jar" {
244 base = "javalib.jar"
245 } else if filepath.Ext(base) == ".apk" {
246 base = "package.apk"
247 }
248
Colin Cross69f59a32019-02-15 10:39:37 -0800249 odexPath := module.BuildPath.InSameDir(ctx, "oat", arch.String(), pathtools.ReplaceExtension(base, "odex"))
Jiakai Zhang0a0a2fb2021-09-30 09:38:19 +0000250 odexInstallPath := ToOdexPath(module.DexLocation, arch)
Colin Cross43f08db2018-11-12 10:13:39 -0800251 if odexOnSystemOther(module, global) {
Anton Hansson43ab0bc2019-10-03 14:18:45 +0100252 odexInstallPath = filepath.Join(SystemOtherPartition, odexInstallPath)
Colin Cross43f08db2018-11-12 10:13:39 -0800253 }
254
Colin Cross69f59a32019-02-15 10:39:37 -0800255 vdexPath := odexPath.ReplaceExtension(ctx, "vdex")
Colin Cross43f08db2018-11-12 10:13:39 -0800256 vdexInstallPath := pathtools.ReplaceExtension(odexInstallPath, "vdex")
257
Colin Cross69f59a32019-02-15 10:39:37 -0800258 invocationPath := odexPath.ReplaceExtension(ctx, "invocation")
Alex Light5de41962018-12-18 15:16:26 -0800259
Jiakai Zhang389a6472021-12-14 18:54:06 +0000260 systemServerJars := global.AllSystemServerJars(ctx)
261 systemServerClasspathJars := global.AllSystemServerClasspathJars(ctx)
Ulya Trafimovichdacc6c52020-03-11 11:59:34 +0000262
Ulya Trafimovichc4dac262020-06-30 11:25:49 +0100263 rule.Command().FlagWithArg("mkdir -p ", filepath.Dir(odexPath.String()))
264 rule.Command().FlagWithOutput("rm -f ", odexPath)
Ulya Trafimovichc9af5382020-05-29 15:35:06 +0100265
Jiakai Zhang519c5c82021-09-16 06:15:39 +0000266 if jarIndex := systemServerJars.IndexOfJar(module.Name); jarIndex >= 0 {
Ulya Trafimovich8cbc5d22020-11-03 15:15:46 +0000267 // System server jars should be dexpreopted together: class loader context of each jar
268 // should include all preceding jars on the system server classpath.
269
270 var clcHost android.Paths
271 var clcTarget []string
Jiakai Zhang389a6472021-12-14 18:54:06 +0000272 endIndex := systemServerClasspathJars.IndexOfJar(module.Name)
273 if endIndex < 0 {
274 // The jar is a standalone one. Use the full classpath as the class loader context.
275 endIndex = systemServerClasspathJars.Len()
276 }
277 for i := 0; i < endIndex; i++ {
278 lib := systemServerClasspathJars.Jar(i)
Ulya Trafimovich8cbc5d22020-11-03 15:15:46 +0000279 clcHost = append(clcHost, SystemServerDexJarHostPath(ctx, lib))
Jiakai Zhang389a6472021-12-14 18:54:06 +0000280 clcTarget = append(clcTarget, GetSystemServerDexLocation(ctx, global, lib))
Ulya Trafimovich8cbc5d22020-11-03 15:15:46 +0000281 }
282
Ulya Trafimovich29e95d92021-09-21 12:59:39 +0100283 if DexpreoptRunningInSoong {
284 // Copy the system server jar to a predefined location where dex2oat will find it.
285 dexPathHost := SystemServerDexJarHostPath(ctx, module.Name)
286 rule.Command().Text("mkdir -p").Flag(filepath.Dir(dexPathHost.String()))
287 rule.Command().Text("cp -f").Input(module.DexPath).Output(dexPathHost)
288 } else {
289 // For Make modules the copy rule is generated in the makefiles, not in dexpreopt.sh.
290 // This is necessary to expose the rule to Ninja, otherwise it has rules that depend on
291 // the jar (namely, dexpreopt commands for all subsequent system server jars that have
292 // this one in their class loader context), but no rule that creates it (because Ninja
293 // cannot see the rule in the generated dexpreopt.sh script).
294 }
Ulya Trafimovichc4dac262020-06-30 11:25:49 +0100295
Jiakai Zhang389a6472021-12-14 18:54:06 +0000296 clcHostString := "PCL[" + strings.Join(clcHost.Strings(), ":") + "]"
297 clcTargetString := "PCL[" + strings.Join(clcTarget, ":") + "]"
298
299 if systemServerClasspathJars.ContainsJar(module.Name) {
300 checkSystemServerOrder(ctx, jarIndex)
301 } else {
302 // Standalone jars are loaded by separate class loaders with SYSTEMSERVERCLASSPATH as the
303 // parent.
304 clcHostString = "PCL[];" + clcHostString
305 clcTargetString = "PCL[];" + clcTargetString
306 }
Ulya Trafimovichc4dac262020-06-30 11:25:49 +0100307
Ulya Trafimovichc4dac262020-06-30 11:25:49 +0100308 rule.Command().
Jiakai Zhang389a6472021-12-14 18:54:06 +0000309 Text(`class_loader_context_arg=--class-loader-context="` + clcHostString + `"`).
Ulya Trafimovich8cbc5d22020-11-03 15:15:46 +0000310 Implicits(clcHost).
Jiakai Zhang389a6472021-12-14 18:54:06 +0000311 Text(`stored_class_loader_context_arg=--stored-class-loader-context="` + clcTargetString + `"`)
Ulya Trafimovich8cbc5d22020-11-03 15:15:46 +0000312
Ulya Trafimovichbd6b0762021-03-12 12:12:12 +0000313 } else {
314 // There are three categories of Java modules handled here:
315 //
316 // - Modules that have passed verify_uses_libraries check. They are AOT-compiled and
317 // expected to be loaded on device without CLC mismatch errors.
318 //
319 // - Modules that have failed the check in relaxed mode, so it didn't cause a build error.
320 // They are dexpreopted with "verify" filter and not AOT-compiled.
321 // TODO(b/132357300): ensure that CLC mismatch errors are ignored with "verify" filter.
322 //
323 // - Modules that didn't run the check. They are AOT-compiled, but it's unknown if they
324 // will have CLC mismatch errors on device (the check is disabled by default).
325 //
326 // TODO(b/132357300): enable the check by default and eliminate the last category, so that
327 // no time/space is wasted on AOT-compiling modules that will fail CLC check on device.
328
329 var manifestOrApk android.Path
Jeongik Cha33a3a812021-04-15 09:12:49 +0900330 if module.ManifestPath.Valid() {
Ulya Trafimovichbd6b0762021-03-12 12:12:12 +0000331 // Ok, there is an XML manifest.
Jeongik Cha33a3a812021-04-15 09:12:49 +0900332 manifestOrApk = module.ManifestPath.Path()
Ulya Trafimovichbd6b0762021-03-12 12:12:12 +0000333 } else if filepath.Ext(base) == ".apk" {
334 // Ok, there is is an APK with the manifest inside.
Ulya Trafimovich0aba2522021-03-03 16:38:37 +0000335 manifestOrApk = module.DexPath
Colin Cross38b96852019-05-22 10:21:09 -0700336 }
Ulya Trafimovichbd6b0762021-03-12 12:12:12 +0000337
338 // Generate command that saves target SDK version in a shell variable.
339 if manifestOrApk == nil {
340 // There is neither an XML manifest nor APK => nowhere to extract targetSdkVersion from.
341 // Set the latest ("any") version: then construct_context will not add any compatibility
342 // libraries (if this is incorrect, there will be a CLC mismatch and dexopt on device).
343 rule.Command().Textf(`target_sdk_version=%d`, AnySdkVersion)
344 } else {
345 rule.Command().Text(`target_sdk_version="$(`).
346 Tool(globalSoong.ManifestCheck).
347 Flag("--extract-target-sdk-version").
348 Input(manifestOrApk).
Ulya Trafimovichdd622952021-03-25 12:52:49 +0000349 FlagWithInput("--aapt ", globalSoong.Aapt).
Ulya Trafimovichbd6b0762021-03-12 12:12:12 +0000350 Text(`)"`)
351 }
Ulya Trafimovichc4dac262020-06-30 11:25:49 +0100352
Ulya Trafimovich5f364b62020-06-30 12:39:01 +0100353 // Generate command that saves host and target class loader context in shell variables.
Ulya Trafimovich8cbc5d22020-11-03 15:15:46 +0000354 clc, paths := ComputeClassLoaderContext(module.ClassLoaderContexts)
Ulya Trafimovich8c35fcf2021-02-17 16:23:28 +0000355 rule.Command().
Ulya Trafimovichbd6b0762021-03-12 12:12:12 +0000356 Text(`eval "$(`).Tool(globalSoong.ConstructContext).
Ulya Trafimovich8130c482020-10-07 15:17:13 +0100357 Text(` --target-sdk-version ${target_sdk_version}`).
Ulya Trafimovich8c35fcf2021-02-17 16:23:28 +0000358 Text(clc).Implicits(paths).
Ulya Trafimovichbd6b0762021-03-12 12:12:12 +0000359 Text(`)"`)
Colin Cross43f08db2018-11-12 10:13:39 -0800360 }
361
Nicolas Geoffray2464ef42019-03-05 14:07:07 +0000362 // Devices that do not have a product partition use a symlink from /product to /system/product.
363 // Because on-device dexopt will see dex locations starting with /product, we change the paths
364 // to mimic this behavior.
365 dexLocationArg := module.DexLocation
366 if strings.HasPrefix(dexLocationArg, "/system/product/") {
367 dexLocationArg = strings.TrimPrefix(dexLocationArg, "/system")
368 }
369
Colin Cross43f08db2018-11-12 10:13:39 -0800370 cmd := rule.Command().
371 Text(`ANDROID_LOG_TAGS="*:e"`).
Martin Stjernholm75a48d82020-01-10 20:32:59 +0000372 Tool(globalSoong.Dex2oat).
Colin Cross43f08db2018-11-12 10:13:39 -0800373 Flag("--avoid-storing-invocation").
Alex Light5de41962018-12-18 15:16:26 -0800374 FlagWithOutput("--write-invocation-to=", invocationPath).ImplicitOutput(invocationPath).
Colin Cross43f08db2018-11-12 10:13:39 -0800375 Flag("--runtime-arg").FlagWithArg("-Xms", global.Dex2oatXms).
376 Flag("--runtime-arg").FlagWithArg("-Xmx", global.Dex2oatXmx).
Colin Cross800fe132019-02-11 14:21:24 -0800377 Flag("--runtime-arg").FlagWithInputList("-Xbootclasspath:", module.PreoptBootClassPathDexFiles, ":").
378 Flag("--runtime-arg").FlagWithList("-Xbootclasspath-locations:", module.PreoptBootClassPathDexLocations, ":").
Colin Cross43f08db2018-11-12 10:13:39 -0800379 Flag("${class_loader_context_arg}").
Ulya Trafimovichdacc6c52020-03-11 11:59:34 +0000380 Flag("${stored_class_loader_context_arg}").
Jeongik Chaa5969092021-05-07 18:53:21 +0900381 FlagWithArg("--boot-image=", strings.Join(module.DexPreoptImageLocationsOnHost, ":")).Implicits(module.DexPreoptImagesDeps[archIdx].Paths()).
Colin Cross43f08db2018-11-12 10:13:39 -0800382 FlagWithInput("--dex-file=", module.DexPath).
Nicolas Geoffray2464ef42019-03-05 14:07:07 +0000383 FlagWithArg("--dex-location=", dexLocationArg).
Colin Cross43f08db2018-11-12 10:13:39 -0800384 FlagWithOutput("--oat-file=", odexPath).ImplicitOutput(vdexPath).
385 // Pass an empty directory, dex2oat shouldn't be reading arbitrary files
386 FlagWithArg("--android-root=", global.EmptyDirectory).
Colin Cross74ba9622019-02-11 15:11:14 -0800387 FlagWithArg("--instruction-set=", arch.String()).
Colin Cross43f08db2018-11-12 10:13:39 -0800388 FlagWithArg("--instruction-set-variant=", global.CpuVariant[arch]).
389 FlagWithArg("--instruction-set-features=", global.InstructionSetFeatures[arch]).
390 Flag("--no-generate-debug-info").
391 Flag("--generate-build-id").
392 Flag("--abort-on-hard-verifier-error").
393 Flag("--force-determinism").
394 FlagWithArg("--no-inline-from=", "core-oj.jar")
395
396 var preoptFlags []string
397 if len(module.PreoptFlags) > 0 {
398 preoptFlags = module.PreoptFlags
399 } else if len(global.PreoptFlags) > 0 {
400 preoptFlags = global.PreoptFlags
401 }
402
403 if len(preoptFlags) > 0 {
404 cmd.Text(strings.Join(preoptFlags, " "))
405 }
406
407 if module.UncompressedDex {
408 cmd.FlagWithArg("--copy-dex-files=", "false")
409 }
410
Jaewoong Jung3aff5782020-02-11 07:54:35 -0800411 if !android.PrefixInList(preoptFlags, "--compiler-filter=") {
Colin Cross43f08db2018-11-12 10:13:39 -0800412 var compilerFilter string
Jiakai Zhang519c5c82021-09-16 06:15:39 +0000413 if systemServerJars.ContainsJar(module.Name) {
Colin Cross43f08db2018-11-12 10:13:39 -0800414 if global.SystemServerCompilerFilter != "" {
Ulya Trafimovich6fad1d02022-06-30 13:21:35 +0100415 // Use the product option if it is set.
Colin Cross43f08db2018-11-12 10:13:39 -0800416 compilerFilter = global.SystemServerCompilerFilter
Ulya Trafimovich6fad1d02022-06-30 13:21:35 +0100417 } else if profile != nil {
418 // Use "speed-profile" for system server jars that have a profile.
419 compilerFilter = "speed-profile"
Colin Cross43f08db2018-11-12 10:13:39 -0800420 } else {
Ulya Trafimovich6fad1d02022-06-30 13:21:35 +0100421 // Use "speed" for system server jars that do not have a profile.
Colin Cross43f08db2018-11-12 10:13:39 -0800422 compilerFilter = "speed"
423 }
424 } else if contains(global.SpeedApps, module.Name) || contains(global.SystemServerApps, module.Name) {
425 // Apps loaded into system server, and apps the product default to being compiled with the
426 // 'speed' compiler filter.
427 compilerFilter = "speed"
Colin Cross69f59a32019-02-15 10:39:37 -0800428 } else if profile != nil {
Colin Cross43f08db2018-11-12 10:13:39 -0800429 // For non system server jars, use speed-profile when we have a profile.
430 compilerFilter = "speed-profile"
431 } else if global.DefaultCompilerFilter != "" {
432 compilerFilter = global.DefaultCompilerFilter
433 } else {
434 compilerFilter = "quicken"
435 }
Ulya Trafimovich8c35fcf2021-02-17 16:23:28 +0000436 if module.EnforceUsesLibraries {
437 // If the verify_uses_libraries check failed (in this case status file contains a
Ulya Trafimovich4a13acb2021-03-02 12:25:02 +0000438 // non-empty error message), then use "verify" compiler filter to avoid compiling any
Ulya Trafimovich8c35fcf2021-02-17 16:23:28 +0000439 // code (it would be rejected on device because of a class loader context mismatch).
440 cmd.Text("--compiler-filter=$(if test -s ").
441 Input(module.EnforceUsesLibrariesStatusFile).
Ulya Trafimovich4a13acb2021-03-02 12:25:02 +0000442 Text(" ; then echo verify ; else echo " + compilerFilter + " ; fi)")
Ulya Trafimovich8c35fcf2021-02-17 16:23:28 +0000443 } else {
444 cmd.FlagWithArg("--compiler-filter=", compilerFilter)
445 }
Colin Cross43f08db2018-11-12 10:13:39 -0800446 }
447
448 if generateDM {
449 cmd.FlagWithArg("--copy-dex-files=", "false")
Colin Cross69f59a32019-02-15 10:39:37 -0800450 dmPath := module.BuildPath.InSameDir(ctx, "generated.dm")
Colin Cross43f08db2018-11-12 10:13:39 -0800451 dmInstalledPath := pathtools.ReplaceExtension(module.DexLocation, "dm")
Colin Cross69f59a32019-02-15 10:39:37 -0800452 tmpPath := module.BuildPath.InSameDir(ctx, "primary.vdex")
Colin Cross43f08db2018-11-12 10:13:39 -0800453 rule.Command().Text("cp -f").Input(vdexPath).Output(tmpPath)
Martin Stjernholm75a48d82020-01-10 20:32:59 +0000454 rule.Command().Tool(globalSoong.SoongZip).
Colin Cross43f08db2018-11-12 10:13:39 -0800455 FlagWithArg("-L", "9").
456 FlagWithOutput("-o", dmPath).
457 Flag("-j").
458 Input(tmpPath)
459 rule.Install(dmPath, dmInstalledPath)
460 }
461
462 // By default, emit debug info.
463 debugInfo := true
464 if global.NoDebugInfo {
465 // If the global setting suppresses mini-debug-info, disable it.
466 debugInfo = false
467 }
468
469 // PRODUCT_SYSTEM_SERVER_DEBUG_INFO overrides WITH_DEXPREOPT_DEBUG_INFO.
470 // PRODUCT_OTHER_JAVA_DEBUG_INFO overrides WITH_DEXPREOPT_DEBUG_INFO.
Jiakai Zhang519c5c82021-09-16 06:15:39 +0000471 if systemServerJars.ContainsJar(module.Name) {
Colin Cross43f08db2018-11-12 10:13:39 -0800472 if global.AlwaysSystemServerDebugInfo {
473 debugInfo = true
474 } else if global.NeverSystemServerDebugInfo {
475 debugInfo = false
476 }
477 } else {
478 if global.AlwaysOtherDebugInfo {
479 debugInfo = true
480 } else if global.NeverOtherDebugInfo {
481 debugInfo = false
482 }
483 }
484
Colin Cross43f08db2018-11-12 10:13:39 -0800485 if debugInfo {
486 cmd.Flag("--generate-mini-debug-info")
487 } else {
488 cmd.Flag("--no-generate-mini-debug-info")
489 }
490
491 // Set the compiler reason to 'prebuilt' to identify the oat files produced
492 // during the build, as opposed to compiled on the device.
493 cmd.FlagWithArg("--compilation-reason=", "prebuilt")
494
495 if appImage {
Colin Cross69f59a32019-02-15 10:39:37 -0800496 appImagePath := odexPath.ReplaceExtension(ctx, "art")
Colin Cross43f08db2018-11-12 10:13:39 -0800497 appImageInstallPath := pathtools.ReplaceExtension(odexInstallPath, "art")
498 cmd.FlagWithOutput("--app-image-file=", appImagePath).
499 FlagWithArg("--image-format=", "lz4")
Mathieu Chartier3f7ddbb2019-04-29 09:33:50 -0700500 if !global.DontResolveStartupStrings {
501 cmd.FlagWithArg("--resolve-startup-const-strings=", "true")
502 }
Colin Cross43f08db2018-11-12 10:13:39 -0800503 rule.Install(appImagePath, appImageInstallPath)
504 }
505
Colin Cross69f59a32019-02-15 10:39:37 -0800506 if profile != nil {
507 cmd.FlagWithInput("--profile-file=", profile)
Colin Cross43f08db2018-11-12 10:13:39 -0800508 }
509
Jiakai Zhang616be062022-11-16 11:50:59 +0000510 if global.EnableUffdGc {
511 cmd.Flag("--runtime-arg").Flag("-Xgc:CMC")
512 }
513
Colin Cross43f08db2018-11-12 10:13:39 -0800514 rule.Install(odexPath, odexInstallPath)
515 rule.Install(vdexPath, vdexInstallPath)
516}
517
Martin Stjernholm8d80cee2020-01-31 17:44:54 +0000518func shouldGenerateDM(module *ModuleConfig, global *GlobalConfig) bool {
Colin Cross43f08db2018-11-12 10:13:39 -0800519 // Generating DM files only makes sense for verify, avoid doing for non verify compiler filter APKs.
520 // No reason to use a dm file if the dex is already uncompressed.
521 return global.GenerateDMFiles && !module.UncompressedDex &&
522 contains(module.PreoptFlags, "--compiler-filter=verify")
523}
524
Martin Stjernholm8d80cee2020-01-31 17:44:54 +0000525func OdexOnSystemOtherByName(name string, dexLocation string, global *GlobalConfig) bool {
Colin Cross43f08db2018-11-12 10:13:39 -0800526 if !global.HasSystemOther {
527 return false
528 }
529
530 if global.SanitizeLite {
531 return false
532 }
533
Nicolas Geoffrayfa6e9ec2019-02-12 13:12:16 +0000534 if contains(global.SpeedApps, name) || contains(global.SystemServerApps, name) {
Colin Cross43f08db2018-11-12 10:13:39 -0800535 return false
536 }
537
538 for _, f := range global.PatternsOnSystemOther {
Anton Hanssonda4d9d92020-09-15 09:28:55 +0000539 if makefileMatch(filepath.Join(SystemPartition, f), dexLocation) {
Colin Cross43f08db2018-11-12 10:13:39 -0800540 return true
541 }
542 }
543
544 return false
545}
546
Martin Stjernholm8d80cee2020-01-31 17:44:54 +0000547func odexOnSystemOther(module *ModuleConfig, global *GlobalConfig) bool {
Nicolas Geoffrayfa6e9ec2019-02-12 13:12:16 +0000548 return OdexOnSystemOtherByName(module.Name, module.DexLocation, global)
549}
550
Colin Crossc7e40aa2019-02-08 21:37:00 -0800551// PathToLocation converts .../system/framework/arm64/boot.art to .../system/framework/boot.art
Colin Cross69f59a32019-02-15 10:39:37 -0800552func PathToLocation(path android.Path, arch android.ArchType) string {
Jeongik Cha4dda75e2021-04-27 23:56:44 +0900553 return PathStringToLocation(path.String(), arch)
554}
555
556// PathStringToLocation converts .../system/framework/arm64/boot.art to .../system/framework/boot.art
557func PathStringToLocation(path string, arch android.ArchType) string {
558 pathArch := filepath.Base(filepath.Dir(path))
Colin Cross74ba9622019-02-11 15:11:14 -0800559 if pathArch != arch.String() {
560 panic(fmt.Errorf("last directory in %q must be %q", path, arch.String()))
Colin Crossc7e40aa2019-02-08 21:37:00 -0800561 }
Jeongik Cha4dda75e2021-04-27 23:56:44 +0900562 return filepath.Join(filepath.Dir(filepath.Dir(path)), filepath.Base(path))
Colin Crossc7e40aa2019-02-08 21:37:00 -0800563}
564
Colin Cross43f08db2018-11-12 10:13:39 -0800565func makefileMatch(pattern, s string) bool {
566 percent := strings.IndexByte(pattern, '%')
567 switch percent {
568 case -1:
569 return pattern == s
570 case len(pattern) - 1:
571 return strings.HasPrefix(s, pattern[:len(pattern)-1])
572 default:
573 panic(fmt.Errorf("unsupported makefile pattern %q", pattern))
574 }
575}
576
Ulya Trafimovichdacc6c52020-03-11 11:59:34 +0000577// A predefined location for the system server dex jars. This is needed in order to generate
578// class loader context for dex2oat, as the path to the jar in the Soong module may be unknown
579// at that time (Soong processes the jars in dependency order, which may be different from the
580// the system server classpath order).
581func SystemServerDexJarHostPath(ctx android.PathContext, jar string) android.OutputPath {
Ulya Trafimovich6cf2c0c2020-04-24 12:15:20 +0100582 if DexpreoptRunningInSoong {
583 // Soong module, just use the default output directory $OUT/soong.
584 return android.PathForOutput(ctx, "system_server_dexjars", jar+".jar")
585 } else {
586 // Make module, default output directory is $OUT (passed via the "null config" created
587 // by dexpreopt_gen). Append Soong subdirectory to match Soong module paths.
588 return android.PathForOutput(ctx, "soong", "system_server_dexjars", jar+".jar")
589 }
Ulya Trafimovichdacc6c52020-03-11 11:59:34 +0000590}
591
Ulya Trafimovichcd3203f2020-03-27 11:30:00 +0000592// Check the order of jars on the system server classpath and give a warning/error if a jar precedes
593// one of its dependencies. This is not an error, but a missed optimization, as dexpreopt won't
594// have the dependency jar in the class loader context, and it won't be able to resolve any
595// references to its classes and methods.
596func checkSystemServerOrder(ctx android.PathContext, jarIndex int) {
597 mctx, isModule := ctx.(android.ModuleContext)
598 if isModule {
599 config := GetGlobalConfig(ctx)
Jiakai Zhang389a6472021-12-14 18:54:06 +0000600 jars := config.AllSystemServerClasspathJars(ctx)
Ulya Trafimovichcd3203f2020-03-27 11:30:00 +0000601 mctx.WalkDeps(func(dep android.Module, parent android.Module) bool {
Jiakai Zhang519c5c82021-09-16 06:15:39 +0000602 depIndex := jars.IndexOfJar(dep.Name())
Ulya Trafimovichcd3203f2020-03-27 11:30:00 +0000603 if jarIndex < depIndex && !config.BrokenSuboptimalOrderOfSystemServerJars {
Jiakai Zhang519c5c82021-09-16 06:15:39 +0000604 jar := jars.Jar(jarIndex)
605 dep := jars.Jar(depIndex)
Ulya Trafimovichcd3203f2020-03-27 11:30:00 +0000606 mctx.ModuleErrorf("non-optimal order of jars on the system server classpath:"+
607 " '%s' precedes its dependency '%s', so dexpreopt is unable to resolve any"+
608 " references from '%s' to '%s'.\n", jar, dep, jar, dep)
609 }
610 return true
611 })
612 }
613}
614
Ulya Trafimovich8c35fcf2021-02-17 16:23:28 +0000615// Returns path to a file containing the reult of verify_uses_libraries check (empty if the check
616// has succeeded, or an error message if it failed).
617func UsesLibrariesStatusFile(ctx android.ModuleContext) android.WritablePath {
618 return android.PathForModuleOut(ctx, "enforce_uses_libraries.status")
619}
620
Colin Cross43f08db2018-11-12 10:13:39 -0800621func contains(l []string, s string) bool {
622 for _, e := range l {
623 if e == s {
624 return true
625 }
626 }
627 return false
628}
629
Colin Cross454c0872019-02-15 23:03:34 -0800630var copyOf = android.CopyOf