1// 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 16// dexpreopting. 17// 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 25// as necessary. The zip file may be empty if preopting was disabled for any reason. 26// 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" 39 "runtime" 40 "strings" 41 42 "android/soong/android" 43 44 "github.com/google/blueprint/pathtools" 45) 46 47const SystemPartition = "/system/" 48const SystemOtherPartition = "/system_other/" 49 50var DexpreoptRunningInSoong = false 51 52// 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(). 54func GenerateDexpreoptRule(ctx android.BuilderContext, globalSoong *GlobalSoongConfig, 55 global *GlobalConfig, module *ModuleConfig, productPackages android.Path, copyApexSystemServerJarDex bool) ( 56 rule *android.RuleBuilder, err error) { 57 58 defer func() { 59 if r := recover(); r != nil { 60 if _, ok := r.(runtime.Error); ok { 61 panic(r) 62 } else if e, ok := r.(error); ok { 63 err = e 64 rule = nil 65 } else { 66 panic(r) 67 } 68 } 69 }() 70 71 rule = android.NewRuleBuilder(pctx, ctx) 72 73 generateProfile := module.ProfileClassListing.Valid() && !global.DisableGenerateProfile 74 generateBootProfile := module.ProfileBootListing.Valid() && !global.DisableGenerateProfile 75 76 var profile android.WritablePath 77 if generateProfile { 78 profile = profileCommand(ctx, globalSoong, global, module, rule) 79 } 80 if generateBootProfile { 81 bootProfileCommand(ctx, globalSoong, global, module, rule) 82 } 83 84 if !dexpreoptDisabled(ctx, global, module) { 85 if valid, err := validateClassLoaderContext(module.ClassLoaderContexts); err != nil { 86 android.ReportPathErrorf(ctx, err.Error()) 87 } else if valid { 88 fixClassLoaderContext(module.ClassLoaderContexts) 89 90 appImage := (generateProfile || module.ForceCreateAppImage || global.DefaultAppImages) && 91 !module.NoCreateAppImage 92 93 generateDM := shouldGenerateDM(module, global) 94 95 for archIdx, _ := range module.Archs { 96 dexpreoptCommand(ctx, globalSoong, global, module, rule, archIdx, profile, appImage, 97 generateDM, productPackages, copyApexSystemServerJarDex) 98 } 99 } 100 } 101 102 return rule, nil 103} 104 105// If dexpreopt is applicable to the module, returns whether dexpreopt is disabled. Otherwise, the 106// behavior is undefined. 107// When it returns true, dexpreopt artifacts will not be generated, but profile will still be 108// generated if profile-guided compilation is requested. 109func dexpreoptDisabled(ctx android.PathContext, global *GlobalConfig, module *ModuleConfig) bool { 110 if ctx.Config().UnbundledBuild() { 111 return true 112 } 113 114 if global.DisablePreopt { 115 return true 116 } 117 118 if contains(global.DisablePreoptModules, module.Name) { 119 return true 120 } 121 122 // Don't preopt individual boot jars, they will be preopted together. 123 if global.BootJars.ContainsJar(module.Name) { 124 return true 125 } 126 127 if global.OnlyPreoptArtBootImage { 128 return true 129 } 130 131 return false 132} 133 134func profileCommand(ctx android.PathContext, globalSoong *GlobalSoongConfig, global *GlobalConfig, 135 module *ModuleConfig, rule *android.RuleBuilder) android.WritablePath { 136 137 profilePath := module.BuildPath.InSameDir(ctx, "profile.prof") 138 profileInstalledPath := module.DexLocation + ".prof" 139 140 if !module.ProfileIsTextListing { 141 rule.Command().Text("rm -f").Output(profilePath) 142 rule.Command().Text("touch").Output(profilePath) 143 } 144 145 cmd := rule.Command(). 146 Text(`ANDROID_LOG_TAGS="*:e"`). 147 Tool(globalSoong.Profman) 148 149 if module.ProfileIsTextListing { 150 // The profile is a test listing of classes (used for framework jars). 151 // We need to generate the actual binary profile before being able to compile. 152 cmd.FlagWithInput("--create-profile-from=", module.ProfileClassListing.Path()) 153 } else { 154 // The profile is binary profile (used for apps). Run it through profman to 155 // ensure the profile keys match the apk. 156 cmd. 157 Flag("--copy-and-update-profile-key"). 158 FlagWithInput("--profile-file=", module.ProfileClassListing.Path()) 159 } 160 161 cmd. 162 Flag("--output-profile-type=app"). 163 FlagWithInput("--apk=", module.DexPath). 164 Flag("--dex-location="+module.DexLocation). 165 FlagWithOutput("--reference-profile-file=", profilePath) 166 167 if !module.ProfileIsTextListing { 168 cmd.Text(fmt.Sprintf(`|| echo "Profile out of date for %s"`, module.DexPath)) 169 } 170 rule.Install(profilePath, profileInstalledPath) 171 172 return profilePath 173} 174 175func bootProfileCommand(ctx android.PathContext, globalSoong *GlobalSoongConfig, global *GlobalConfig, 176 module *ModuleConfig, rule *android.RuleBuilder) android.WritablePath { 177 178 profilePath := module.BuildPath.InSameDir(ctx, "profile.bprof") 179 profileInstalledPath := module.DexLocation + ".bprof" 180 181 if !module.ProfileIsTextListing { 182 rule.Command().Text("rm -f").Output(profilePath) 183 rule.Command().Text("touch").Output(profilePath) 184 } 185 186 cmd := rule.Command(). 187 Text(`ANDROID_LOG_TAGS="*:e"`). 188 Tool(globalSoong.Profman) 189 190 // The profile is a test listing of methods. 191 // We need to generate the actual binary profile. 192 cmd.FlagWithInput("--create-profile-from=", module.ProfileBootListing.Path()) 193 194 cmd. 195 Flag("--output-profile-type=bprof"). 196 FlagWithInput("--apk=", module.DexPath). 197 Flag("--dex-location="+module.DexLocation). 198 FlagWithOutput("--reference-profile-file=", profilePath) 199 200 if !module.ProfileIsTextListing { 201 cmd.Text(fmt.Sprintf(`|| echo "Profile out of date for %s"`, module.DexPath)) 202 } 203 rule.Install(profilePath, profileInstalledPath) 204 205 return profilePath 206} 207 208// Returns the dex location of a system server java library. 209func GetSystemServerDexLocation(ctx android.PathContext, global *GlobalConfig, lib string) string { 210 if apex := global.AllApexSystemServerJars(ctx).ApexOfJar(lib); apex != "" { 211 return fmt.Sprintf("/apex/%s/javalib/%s.jar", apex, lib) 212 } 213 214 if apex := global.AllPlatformSystemServerJars(ctx).ApexOfJar(lib); apex == "system_ext" { 215 return fmt.Sprintf("/system_ext/framework/%s.jar", lib) 216 } 217 218 return fmt.Sprintf("/system/framework/%s.jar", lib) 219} 220 221// Returns the location to the odex file for the dex file at `path`. 222func ToOdexPath(path string, arch android.ArchType) string { 223 if strings.HasPrefix(path, "/apex/") { 224 return filepath.Join("/system/framework/oat", arch.String(), 225 strings.ReplaceAll(path[1:], "/", "@")+"@classes.odex") 226 } 227 228 return filepath.Join(filepath.Dir(path), "oat", arch.String(), 229 pathtools.ReplaceExtension(filepath.Base(path), "odex")) 230} 231 232func dexpreoptCommand(ctx android.BuilderContext, globalSoong *GlobalSoongConfig, 233 global *GlobalConfig, module *ModuleConfig, rule *android.RuleBuilder, archIdx int, 234 profile android.WritablePath, appImage bool, generateDM bool, productPackages android.Path, copyApexSystemServerJarDex bool) { 235 236 arch := module.Archs[archIdx] 237 238 // HACK: make soname in Soong-generated .odex files match Make. 239 base := filepath.Base(module.DexLocation) 240 if filepath.Ext(base) == ".jar" { 241 base = "javalib.jar" 242 } else if filepath.Ext(base) == ".apk" { 243 base = "package.apk" 244 } 245 246 odexPath := module.BuildPath.InSameDir(ctx, "oat", arch.String(), pathtools.ReplaceExtension(base, "odex")) 247 odexInstallPath := ToOdexPath(module.DexLocation, arch) 248 if odexOnSystemOther(module, global) { 249 odexInstallPath = filepath.Join(SystemOtherPartition, odexInstallPath) 250 } 251 252 vdexPath := odexPath.ReplaceExtension(ctx, "vdex") 253 vdexInstallPath := pathtools.ReplaceExtension(odexInstallPath, "vdex") 254 255 invocationPath := odexPath.ReplaceExtension(ctx, "invocation") 256 257 systemServerJars := global.AllSystemServerJars(ctx) 258 systemServerClasspathJars := global.AllSystemServerClasspathJars(ctx) 259 260 rule.Command().FlagWithArg("mkdir -p ", filepath.Dir(odexPath.String())) 261 rule.Command().FlagWithOutput("rm -f ", odexPath) 262 263 if jarIndex := systemServerJars.IndexOfJar(module.Name); jarIndex >= 0 { 264 // System server jars should be dexpreopted together: class loader context of each jar 265 // should include all preceding jars on the system server classpath. 266 267 var clcHost android.Paths 268 var clcTarget []string 269 endIndex := systemServerClasspathJars.IndexOfJar(module.Name) 270 if endIndex < 0 { 271 // The jar is a standalone one. Use the full classpath as the class loader context. 272 endIndex = systemServerClasspathJars.Len() 273 } 274 for i := 0; i < endIndex; i++ { 275 lib := systemServerClasspathJars.Jar(i) 276 clcHost = append(clcHost, SystemServerDexJarHostPath(ctx, lib)) 277 clcTarget = append(clcTarget, GetSystemServerDexLocation(ctx, global, lib)) 278 } 279 280 if DexpreoptRunningInSoong && copyApexSystemServerJarDex { 281 // Copy the system server jar to a predefined location where dex2oat will find it. 282 dexPathHost := SystemServerDexJarHostPath(ctx, module.Name) 283 rule.Command().Text("mkdir -p").Flag(filepath.Dir(dexPathHost.String())) 284 rule.Command().Text("cp -f").Input(module.DexPath).Output(dexPathHost) 285 } else { 286 // For Make modules the copy rule is generated in the makefiles, not in dexpreopt.sh. 287 // This is necessary to expose the rule to Ninja, otherwise it has rules that depend on 288 // the jar (namely, dexpreopt commands for all subsequent system server jars that have 289 // this one in their class loader context), but no rule that creates it (because Ninja 290 // cannot see the rule in the generated dexpreopt.sh script). 291 } 292 293 clcHostString := "PCL[" + strings.Join(clcHost.Strings(), ":") + "]" 294 clcTargetString := "PCL[" + strings.Join(clcTarget, ":") + "]" 295 296 if systemServerClasspathJars.ContainsJar(module.Name) { 297 checkSystemServerOrder(ctx, jarIndex) 298 } else { 299 // Standalone jars are loaded by separate class loaders with SYSTEMSERVERCLASSPATH as the 300 // parent. 301 clcHostString = "PCL[];" + clcHostString 302 clcTargetString = "PCL[];" + clcTargetString 303 } 304 305 rule.Command(). 306 Text(`class_loader_context_arg=--class-loader-context="` + clcHostString + `"`). 307 Implicits(clcHost). 308 Text(`stored_class_loader_context_arg=--stored-class-loader-context="` + clcTargetString + `"`) 309 310 } else { 311 // There are three categories of Java modules handled here: 312 // 313 // - Modules that have passed verify_uses_libraries check. They are AOT-compiled and 314 // expected to be loaded on device without CLC mismatch errors. 315 // 316 // - Modules that have failed the check in relaxed mode, so it didn't cause a build error. 317 // They are dexpreopted with "verify" filter and not AOT-compiled. 318 // TODO(b/132357300): ensure that CLC mismatch errors are ignored with "verify" filter. 319 // 320 // - Modules that didn't run the check. They are AOT-compiled, but it's unknown if they 321 // will have CLC mismatch errors on device (the check is disabled by default). 322 // 323 // TODO(b/132357300): enable the check by default and eliminate the last category, so that 324 // no time/space is wasted on AOT-compiling modules that will fail CLC check on device. 325 326 var manifestOrApk android.Path 327 if module.ManifestPath.Valid() { 328 // Ok, there is an XML manifest. 329 manifestOrApk = module.ManifestPath.Path() 330 } else if filepath.Ext(base) == ".apk" { 331 // Ok, there is is an APK with the manifest inside. 332 manifestOrApk = module.DexPath 333 } 334 335 // Generate command that saves target SDK version in a shell variable. 336 if manifestOrApk == nil { 337 // There is neither an XML manifest nor APK => nowhere to extract targetSdkVersion from. 338 // Set the latest ("any") version: then construct_context will not add any compatibility 339 // libraries (if this is incorrect, there will be a CLC mismatch and dexopt on device). 340 rule.Command().Textf(`target_sdk_version=%d`, AnySdkVersion) 341 } else { 342 rule.Command().Text(`target_sdk_version="$(`). 343 Tool(globalSoong.ManifestCheck). 344 Flag("--extract-target-sdk-version"). 345 Input(manifestOrApk). 346 FlagWithInput("--aapt ", globalSoong.Aapt). 347 Text(`)"`) 348 } 349 350 // Generate command that saves host and target class loader context in shell variables. 351 _, paths := ComputeClassLoaderContextDependencies(module.ClassLoaderContexts) 352 rule.Command(). 353 Text(`eval "$(`).Tool(globalSoong.ConstructContext). 354 Text(` --target-sdk-version ${target_sdk_version}`). 355 FlagWithArg("--context-json=", module.ClassLoaderContexts.DumpForFlag()). 356 FlagWithInput("--product-packages=", productPackages). 357 Implicits(paths). 358 Text(`)"`) 359 } 360 361 // Devices that do not have a product partition use a symlink from /product to /system/product. 362 // Because on-device dexopt will see dex locations starting with /product, we change the paths 363 // to mimic this behavior. 364 dexLocationArg := module.DexLocation 365 if strings.HasPrefix(dexLocationArg, "/system/product/") { 366 dexLocationArg = strings.TrimPrefix(dexLocationArg, "/system") 367 } 368 369 cmd := rule.Command(). 370 Text(`ANDROID_LOG_TAGS="*:e"`). 371 Tool(globalSoong.Dex2oat). 372 Flag("--avoid-storing-invocation"). 373 FlagWithOutput("--write-invocation-to=", invocationPath).ImplicitOutput(invocationPath). 374 Flag("--runtime-arg").FlagWithArg("-Xms", global.Dex2oatXms). 375 Flag("--runtime-arg").FlagWithArg("-Xmx", global.Dex2oatXmx). 376 Flag("--runtime-arg").FlagWithInputList("-Xbootclasspath:", module.PreoptBootClassPathDexFiles, ":"). 377 Flag("--runtime-arg").FlagWithList("-Xbootclasspath-locations:", module.PreoptBootClassPathDexLocations, ":"). 378 Flag("${class_loader_context_arg}"). 379 Flag("${stored_class_loader_context_arg}"). 380 FlagWithArg("--boot-image=", strings.Join(module.DexPreoptImageLocationsOnHost, ":")).Implicits(module.DexPreoptImagesDeps[archIdx].Paths()). 381 FlagWithInput("--dex-file=", module.DexPath). 382 FlagWithArg("--dex-location=", dexLocationArg). 383 FlagWithOutput("--oat-file=", odexPath).ImplicitOutput(vdexPath). 384 // Pass an empty directory, dex2oat shouldn't be reading arbitrary files 385 FlagWithArg("--android-root=", global.EmptyDirectory). 386 FlagWithArg("--instruction-set=", arch.String()). 387 FlagWithArg("--instruction-set-variant=", global.CpuVariant[arch]). 388 FlagWithArg("--instruction-set-features=", global.InstructionSetFeatures[arch]). 389 Flag("--no-generate-debug-info"). 390 Flag("--generate-build-id"). 391 Flag("--abort-on-hard-verifier-error"). 392 Flag("--force-determinism"). 393 FlagWithArg("--no-inline-from=", "core-oj.jar"). 394 Text("$(cat").Input(globalSoong.UffdGcFlag).Text(")") 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 411 if !android.PrefixInList(preoptFlags, "--compiler-filter=") { 412 var compilerFilter string 413 if systemServerJars.ContainsJar(module.Name) { 414 if global.SystemServerCompilerFilter != "" { 415 // Use the product option if it is set. 416 compilerFilter = global.SystemServerCompilerFilter 417 } else if profile != nil { 418 // Use "speed-profile" for system server jars that have a profile. 419 compilerFilter = "speed-profile" 420 } else { 421 // Use "speed" for system server jars that do not have a profile. 422 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" 428 } else if profile != nil { 429 // 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 } 436 if module.EnforceUsesLibraries { 437 // If the verify_uses_libraries check failed (in this case status file contains a 438 // non-empty error message), then use "verify" compiler filter to avoid compiling any 439 // 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). 442 Text(" ; then echo verify ; else echo " + compilerFilter + " ; fi)") 443 } else { 444 cmd.FlagWithArg("--compiler-filter=", compilerFilter) 445 } 446 } 447 448 if generateDM { 449 cmd.FlagWithArg("--copy-dex-files=", "false") 450 dmPath := module.BuildPath.InSameDir(ctx, "generated.dm") 451 dmInstalledPath := pathtools.ReplaceExtension(module.DexLocation, "dm") 452 tmpPath := module.BuildPath.InSameDir(ctx, "primary.vdex") 453 rule.Command().Text("cp -f").Input(vdexPath).Output(tmpPath) 454 rule.Command().Tool(globalSoong.SoongZip). 455 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. 471 if systemServerJars.ContainsJar(module.Name) { 472 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 485 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 { 496 appImagePath := odexPath.ReplaceExtension(ctx, "art") 497 appImageInstallPath := pathtools.ReplaceExtension(odexInstallPath, "art") 498 cmd.FlagWithOutput("--app-image-file=", appImagePath). 499 FlagWithArg("--image-format=", "lz4") 500 if !global.DontResolveStartupStrings { 501 cmd.FlagWithArg("--resolve-startup-const-strings=", "true") 502 } 503 rule.Install(appImagePath, appImageInstallPath) 504 } 505 506 if profile != nil { 507 cmd.FlagWithInput("--profile-file=", profile) 508 } 509 510 rule.Install(odexPath, odexInstallPath) 511 rule.Install(vdexPath, vdexInstallPath) 512} 513 514func shouldGenerateDM(module *ModuleConfig, global *GlobalConfig) bool { 515 // Generating DM files only makes sense for verify, avoid doing for non verify compiler filter APKs. 516 // No reason to use a dm file if the dex is already uncompressed. 517 return global.GenerateDMFiles && !module.UncompressedDex && 518 contains(module.PreoptFlags, "--compiler-filter=verify") 519} 520 521func OdexOnSystemOtherByName(name string, dexLocation string, global *GlobalConfig) bool { 522 if !global.HasSystemOther { 523 return false 524 } 525 526 if global.SanitizeLite { 527 return false 528 } 529 530 if contains(global.SpeedApps, name) || contains(global.SystemServerApps, name) { 531 return false 532 } 533 534 for _, f := range global.PatternsOnSystemOther { 535 if makefileMatch(filepath.Join(SystemPartition, f), dexLocation) { 536 return true 537 } 538 } 539 540 return false 541} 542 543func odexOnSystemOther(module *ModuleConfig, global *GlobalConfig) bool { 544 return OdexOnSystemOtherByName(module.Name, module.DexLocation, global) 545} 546 547// PathToLocation converts .../system/framework/arm64/boot.art to .../system/framework/boot.art 548func PathToLocation(path android.Path, arch android.ArchType) string { 549 return PathStringToLocation(path.String(), arch) 550} 551 552// PathStringToLocation converts .../system/framework/arm64/boot.art to .../system/framework/boot.art 553func PathStringToLocation(path string, arch android.ArchType) string { 554 pathArch := filepath.Base(filepath.Dir(path)) 555 if pathArch != arch.String() { 556 panic(fmt.Errorf("last directory in %q must be %q", path, arch.String())) 557 } 558 return filepath.Join(filepath.Dir(filepath.Dir(path)), filepath.Base(path)) 559} 560 561func makefileMatch(pattern, s string) bool { 562 percent := strings.IndexByte(pattern, '%') 563 switch percent { 564 case -1: 565 return pattern == s 566 case len(pattern) - 1: 567 return strings.HasPrefix(s, pattern[:len(pattern)-1]) 568 default: 569 panic(fmt.Errorf("unsupported makefile pattern %q", pattern)) 570 } 571} 572 573// A predefined location for the system server dex jars. This is needed in order to generate 574// class loader context for dex2oat, as the path to the jar in the Soong module may be unknown 575// at that time (Soong processes the jars in dependency order, which may be different from the 576// the system server classpath order). 577func SystemServerDexJarHostPath(ctx android.PathContext, jar string) android.OutputPath { 578 if DexpreoptRunningInSoong { 579 // Soong module, just use the default output directory $OUT/soong. 580 return android.PathForOutput(ctx, "system_server_dexjars", jar+".jar") 581 } else { 582 // Make module, default output directory is $OUT (passed via the "null config" created 583 // by dexpreopt_gen). Append Soong subdirectory to match Soong module paths. 584 return android.PathForOutput(ctx, "soong", "system_server_dexjars", jar+".jar") 585 } 586} 587 588// Check the order of jars on the system server classpath and give a warning/error if a jar precedes 589// one of its dependencies. This is not an error, but a missed optimization, as dexpreopt won't 590// have the dependency jar in the class loader context, and it won't be able to resolve any 591// references to its classes and methods. 592func checkSystemServerOrder(ctx android.PathContext, jarIndex int) { 593 mctx, isModule := ctx.(android.ModuleContext) 594 if isModule { 595 config := GetGlobalConfig(ctx) 596 jars := config.AllSystemServerClasspathJars(ctx) 597 mctx.WalkDeps(func(dep android.Module, parent android.Module) bool { 598 depIndex := jars.IndexOfJar(dep.Name()) 599 if jarIndex < depIndex && !config.BrokenSuboptimalOrderOfSystemServerJars { 600 jar := jars.Jar(jarIndex) 601 dep := jars.Jar(depIndex) 602 mctx.ModuleErrorf("non-optimal order of jars on the system server classpath:"+ 603 " '%s' precedes its dependency '%s', so dexpreopt is unable to resolve any"+ 604 " references from '%s' to '%s'.\n", jar, dep, jar, dep) 605 } 606 return true 607 }) 608 } 609} 610 611// Returns path to a file containing the reult of verify_uses_libraries check (empty if the check 612// has succeeded, or an error message if it failed). 613func UsesLibrariesStatusFile(ctx android.ModuleContext) android.WritablePath { 614 return android.PathForModuleOut(ctx, "enforce_uses_libraries.status") 615} 616 617func contains(l []string, s string) bool { 618 for _, e := range l { 619 if e == s { 620 return true 621 } 622 } 623 return false 624} 625