1 /* 2 * Copyright (C) 2008 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 /* 18 * Convert the output from "dx" into a locally-optimized DEX file. 19 * 20 * TODO: the format of the optimized header is currently "whatever we 21 * happen to write", since the VM that writes it is by definition the same 22 * as the VM that reads it. Still, it should be better documented and 23 * more rigorously structured. 24 */ 25 #include "Dalvik.h" 26 #include "libdex/InstrUtils.h" 27 #include "libdex/OptInvocation.h" 28 #include "analysis/RegisterMap.h" 29 30 #include <zlib.h> 31 32 #include <stdlib.h> 33 #include <unistd.h> 34 #include <sys/mman.h> 35 #include <sys/stat.h> 36 #include <sys/file.h> 37 #include <sys/wait.h> 38 #include <fcntl.h> 39 #include <errno.h> 40 41 /* 42 * Virtual/direct calls to "method" are replaced with an execute-inline 43 * instruction with index "idx". 44 */ 45 typedef struct InlineSub { 46 Method* method; 47 int inlineIdx; 48 } InlineSub; 49 50 51 /* fwd */ 52 static int writeDependencies(int fd, u4 modWhen, u4 crc); 53 static bool writeAuxData(int fd, const DexClassLookup* pClassLookup,\ 54 const IndexMapSet* pIndexMapSet, const RegisterMapBuilder* pRegMapBuilder); 55 static void logFailedWrite(size_t expected, ssize_t actual, const char* msg, 56 int err); 57 static bool computeFileChecksum(int fd, off_t start, size_t length, u4* pSum); 58 59 static bool rewriteDex(u1* addr, int len, bool doVerify, bool doOpt,\ 60 u4* pHeaderFlags, DexClassLookup** ppClassLookup); 61 static void updateChecksum(u1* addr, int len, DexHeader* pHeader); 62 static bool loadAllClasses(DvmDex* pDvmDex); 63 static void optimizeLoadedClasses(DexFile* pDexFile); 64 static void optimizeClass(ClassObject* clazz, const InlineSub* inlineSubs); 65 static bool optimizeMethod(Method* method, const InlineSub* inlineSubs); 66 static void rewriteInstField(Method* method, u2* insns, OpCode newOpc); 67 static bool rewriteVirtualInvoke(Method* method, u2* insns, OpCode newOpc); 68 static bool rewriteEmptyDirectInvoke(Method* method, u2* insns); 69 static bool rewriteExecuteInline(Method* method, u2* insns, 70 MethodType methodType, const InlineSub* inlineSubs); 71 static bool rewriteExecuteInlineRange(Method* method, u2* insns, 72 MethodType methodType, const InlineSub* inlineSubs); 73 74 75 /* 76 * Return the fd of an open file in the DEX file cache area. If the cache 77 * file doesn't exist or is out of date, this will remove the old entry, 78 * create a new one (writing only the file header), and return with the 79 * "new file" flag set. 80 * 81 * It's possible to execute from an unoptimized DEX file directly, 82 * assuming the byte ordering and structure alignment is correct, but 83 * disadvantageous because some significant optimizations are not possible. 84 * It's not generally possible to do the same from an uncompressed Jar 85 * file entry, because we have to guarantee 32-bit alignment in the 86 * memory-mapped file. 87 * 88 * For a Jar/APK file (a zip archive with "classes.dex" inside), "modWhen" 89 * and "crc32" come from the Zip directory entry. For a stand-alone DEX 90 * file, it's the modification date of the file and the Adler32 from the 91 * DEX header (which immediately follows the magic). If these don't 92 * match what's stored in the opt header, we reject the file immediately. 93 * 94 * On success, the file descriptor will be positioned just past the "opt" 95 * file header, and will be locked with flock. "*pCachedName" will point 96 * to newly-allocated storage. 97 */ 98 int dvmOpenCachedDexFile(const char* fileName, const char* cacheFileName, 99 u4 modWhen, u4 crc, bool isBootstrap, bool* pNewFile, bool createIfMissing) 100 { 101 int fd, cc; 102 struct stat fdStat, fileStat; 103 bool readOnly = false; 104 105 *pNewFile = false; 106 107 retry: 108 /* 109 * Try to open the cache file. If we've been asked to, 110 * create it if it doesn't exist. 111 */ 112 fd = createIfMissing ? open(cacheFileName, O_CREAT|O_RDWR, 0644) : -1; 113 if (fd < 0) { 114 fd = open(cacheFileName, O_RDONLY, 0); 115 if (fd < 0) { 116 if (createIfMissing) { 117 LOGE("Can't open dex cache '%s': %s\n", 118 cacheFileName, strerror(errno)); 119 } 120 return fd; 121 } 122 readOnly = true; 123 } 124 125 /* 126 * Grab an exclusive lock on the cache file. If somebody else is 127 * working on it, we'll block here until they complete. Because 128 * we're waiting on an external resource, we go into VMWAIT mode. 129 */ 130 int oldStatus; 131 LOGV("DexOpt: locking cache file %s (fd=%d, boot=%d)\n", 132 cacheFileName, fd, isBootstrap); 133 oldStatus = dvmChangeStatus(NULL, THREAD_VMWAIT); 134 cc = flock(fd, LOCK_EX | LOCK_NB); 135 if (cc != 0) { 136 LOGD("DexOpt: sleeping on flock(%s)\n", cacheFileName); 137 cc = flock(fd, LOCK_EX); 138 } 139 dvmChangeStatus(NULL, oldStatus); 140 if (cc != 0) { 141 LOGE("Can't lock dex cache '%s': %d\n", cacheFileName, cc); 142 close(fd); 143 return -1; 144 } 145 LOGV("DexOpt: locked cache file\n"); 146 147 /* 148 * Check to see if the fd we opened and locked matches the file in 149 * the filesystem. If they don't, then somebody else unlinked ours 150 * and created a new file, and we need to use that one instead. (If 151 * we caught them between the unlink and the create, we'll get an 152 * ENOENT from the file stat.) 153 */ 154 cc = fstat(fd, &fdStat); 155 if (cc != 0) { 156 LOGE("Can't stat open file '%s'\n", cacheFileName); 157 LOGVV("DexOpt: unlocking cache file %s\n", cacheFileName); 158 goto close_fail; 159 } 160 cc = stat(cacheFileName, &fileStat); 161 if (cc != 0 || 162 fdStat.st_dev != fileStat.st_dev || fdStat.st_ino != fileStat.st_ino) 163 { 164 LOGD("DexOpt: our open cache file is stale; sleeping and retrying\n"); 165 LOGVV("DexOpt: unlocking cache file %s\n", cacheFileName); 166 flock(fd, LOCK_UN); 167 close(fd); 168 usleep(250 * 1000); /* if something is hosed, don't peg machine */ 169 goto retry; 170 } 171 172 /* 173 * We have the correct file open and locked. If the file size is zero, 174 * then it was just created by us, and we want to fill in some fields 175 * in the "opt" header and set "*pNewFile". Otherwise, we want to 176 * verify that the fields in the header match our expectations, and 177 * reset the file if they don't. 178 */ 179 if (fdStat.st_size == 0) { 180 if (readOnly) { 181 LOGW("DexOpt: file has zero length and isn't writable\n"); 182 goto close_fail; 183 } 184 cc = dexOptCreateEmptyHeader(fd); 185 if (cc != 0) 186 goto close_fail; 187 *pNewFile = true; 188 LOGV("DexOpt: successfully initialized new cache file\n"); 189 } else { 190 bool expectVerify, expectOpt; 191 192 if (gDvm.classVerifyMode == VERIFY_MODE_NONE) 193 expectVerify = false; 194 else if (gDvm.classVerifyMode == VERIFY_MODE_REMOTE) 195 expectVerify = !isBootstrap; 196 else /*if (gDvm.classVerifyMode == VERIFY_MODE_ALL)*/ 197 expectVerify = true; 198 199 if (gDvm.dexOptMode == OPTIMIZE_MODE_NONE) 200 expectOpt = false; 201 else if (gDvm.dexOptMode == OPTIMIZE_MODE_VERIFIED) 202 expectOpt = expectVerify; 203 else /*if (gDvm.dexOptMode == OPTIMIZE_MODE_ALL)*/ 204 expectOpt = true; 205 206 LOGV("checking deps, expecting vfy=%d opt=%d\n", 207 expectVerify, expectOpt); 208 209 if (!dvmCheckOptHeaderAndDependencies(fd, true, modWhen, crc, 210 expectVerify, expectOpt)) 211 { 212 if (readOnly) { 213 /* 214 * We could unlink and rewrite the file if we own it or 215 * the "sticky" bit isn't set on the directory. However, 216 * we're not able to truncate it, which spoils things. So, 217 * give up now. 218 */ 219 if (createIfMissing) { 220 LOGW("Cached DEX '%s' (%s) is stale and not writable\n", 221 fileName, cacheFileName); 222 } 223 goto close_fail; 224 } 225 226 /* 227 * If we truncate the existing file before unlinking it, any 228 * process that has it mapped will fail when it tries to touch 229 * the pages. 230 * 231 * This is very important. The zygote process will have the 232 * boot DEX files (core, framework, etc.) mapped early. If 233 * (say) core.dex gets updated, and somebody launches an app 234 * that uses App.dex, then App.dex gets reoptimized because it's 235 * dependent upon the boot classes. However, dexopt will be 236 * using the *new* core.dex to do the optimizations, while the 237 * app will actually be running against the *old* core.dex 238 * because it starts from zygote. 239 * 240 * Even without zygote, it's still possible for a class loader 241 * to pull in an APK that was optimized against an older set 242 * of DEX files. We must ensure that everything fails when a 243 * boot DEX gets updated, and for general "why aren't my 244 * changes doing anything" purposes its best if we just make 245 * everything crash when a DEX they're using gets updated. 246 */ 247 LOGD("Stale deps in cache file; removing and retrying\n"); 248 if (ftruncate(fd, 0) != 0) { 249 LOGW("Warning: unable to truncate cache file '%s': %s\n", 250 cacheFileName, strerror(errno)); 251 /* keep going */ 252 } 253 if (unlink(cacheFileName) != 0) { 254 LOGW("Warning: unable to remove cache file '%s': %d %s\n", 255 cacheFileName, errno, strerror(errno)); 256 /* keep going; permission failure should probably be fatal */ 257 } 258 LOGVV("DexOpt: unlocking cache file %s\n", cacheFileName); 259 flock(fd, LOCK_UN); 260 close(fd); 261 goto retry; 262 } else { 263 LOGV("DexOpt: good deps in cache file\n"); 264 } 265 } 266 267 assert(fd >= 0); 268 return fd; 269 270 close_fail: 271 flock(fd, LOCK_UN); 272 close(fd); 273 return -1; 274 } 275 276 /* 277 * Unlock the file descriptor. 278 * 279 * Returns "true" on success. 280 */ 281 bool dvmUnlockCachedDexFile(int fd) 282 { 283 LOGVV("DexOpt: unlocking cache file fd=%d\n", fd); 284 return (flock(fd, LOCK_UN) == 0); 285 } 286 287 288 /* 289 * Given a descriptor for a file with DEX data in it, produce an 290 * optimized version. 291 * 292 * The file pointed to by "fd" is expected to be a locked shared resource 293 * (or private); we make no efforts to enforce multi-process correctness 294 * here. 295 * 296 * "fileName" is only used for debug output. "modWhen" and "crc" are stored 297 * in the dependency set. 298 * 299 * The "isBootstrap" flag determines how the optimizer and verifier handle 300 * package-scope access checks. When optimizing, we only load the bootstrap 301 * class DEX files and the target DEX, so the flag determines whether the 302 * target DEX classes are given a (synthetic) non-NULL classLoader pointer. 303 * This only really matters if the target DEX contains classes that claim to 304 * be in the same package as bootstrap classes. 305 * 306 * The optimizer will need to load every class in the target DEX file. 307 * This is generally undesirable, so we start a subprocess to do the 308 * work and wait for it to complete. 309 * 310 * Returns "true" on success. All data will have been written to "fd". 311 */ 312 bool dvmOptimizeDexFile(int fd, off_t dexOffset, long dexLength, 313 const char* fileName, u4 modWhen, u4 crc, bool isBootstrap) 314 { 315 const char* lastPart = strrchr(fileName, '/'); 316 if (lastPart != NULL) 317 lastPart++; 318 else 319 lastPart = fileName; 320 321 /* 322 * For basic optimizations (byte-swapping and structure aligning) we 323 * don't need to fork(). It looks like fork+exec is causing problems 324 * with gdb on our bewildered Linux distro, so in some situations we 325 * want to avoid this. 326 * 327 * For optimization and/or verification, we need to load all the classes. 328 * 329 * We don't check gDvm.generateRegisterMaps, since that is dependent 330 * upon the verifier state. 331 */ 332 if (gDvm.classVerifyMode == VERIFY_MODE_NONE && 333 (gDvm.dexOptMode == OPTIMIZE_MODE_NONE || 334 gDvm.dexOptMode == OPTIMIZE_MODE_VERIFIED)) 335 { 336 LOGD("DexOpt: --- BEGIN (quick) '%s' ---\n", lastPart); 337 return dvmContinueOptimization(fd, dexOffset, dexLength, 338 fileName, modWhen, crc, isBootstrap); 339 } 340 341 342 LOGD("DexOpt: --- BEGIN '%s' (bootstrap=%d) ---\n", lastPart, isBootstrap); 343 344 pid_t pid; 345 346 /* 347 * This could happen if something in our bootclasspath, which we thought 348 * was all optimized, got rejected. 349 */ 350 if (gDvm.optimizing) { 351 LOGW("Rejecting recursive optimization attempt on '%s'\n", fileName); 352 return false; 353 } 354 355 pid = fork(); 356 if (pid == 0) { 357 static const int kUseValgrind = 0; 358 static const char* kDexOptBin = "/bin/dexopt"; 359 static const char* kValgrinder = "/usr/bin/valgrind"; 360 static const int kFixedArgCount = 10; 361 static const int kValgrindArgCount = 5; 362 static const int kMaxIntLen = 12; // '-'+10dig+'\0' -OR- 0x+8dig 363 int bcpSize = dvmGetBootPathSize(); 364 int argc = kFixedArgCount + bcpSize 365 + (kValgrindArgCount * kUseValgrind); 366 char* argv[argc+1]; // last entry is NULL 367 char values[argc][kMaxIntLen]; 368 char* execFile; 369 char* androidRoot; 370 int flags; 371 372 /* change process groups, so we don't clash with ProcessManager */ 373 setpgid(0, 0); 374 375 /* full path to optimizer */ 376 androidRoot = getenv("ANDROID_ROOT"); 377 if (androidRoot == NULL) { 378 LOGW("ANDROID_ROOT not set, defaulting to /system\n"); 379 androidRoot = "/system"; 380 } 381 execFile = malloc(strlen(androidRoot) + strlen(kDexOptBin) + 1); 382 strcpy(execFile, androidRoot); 383 strcat(execFile, kDexOptBin); 384 385 /* 386 * Create arg vector. 387 */ 388 int curArg = 0; 389 390 if (kUseValgrind) { 391 /* probably shouldn't ship the hard-coded path */ 392 argv[curArg++] = (char*)kValgrinder; 393 argv[curArg++] = "--tool=memcheck"; 394 argv[curArg++] = "--leak-check=yes"; // check for leaks too 395 argv[curArg++] = "--leak-resolution=med"; // increase from 2 to 4 396 argv[curArg++] = "--num-callers=16"; // default is 12 397 assert(curArg == kValgrindArgCount); 398 } 399 argv[curArg++] = execFile; 400 401 argv[curArg++] = "--dex"; 402 403 sprintf(values[2], "%d", DALVIK_VM_BUILD); 404 argv[curArg++] = values[2]; 405 406 sprintf(values[3], "%d", fd); 407 argv[curArg++] = values[3]; 408 409 sprintf(values[4], "%d", (int) dexOffset); 410 argv[curArg++] = values[4]; 411 412 sprintf(values[5], "%d", (int) dexLength); 413 argv[curArg++] = values[5]; 414 415 argv[curArg++] = (char*)fileName; 416 417 sprintf(values[7], "%d", (int) modWhen); 418 argv[curArg++] = values[7]; 419 420 sprintf(values[8], "%d", (int) crc); 421 argv[curArg++] = values[8]; 422 423 flags = 0; 424 if (gDvm.dexOptMode != OPTIMIZE_MODE_NONE) { 425 flags |= DEXOPT_OPT_ENABLED; 426 if (gDvm.dexOptMode == OPTIMIZE_MODE_ALL) 427 flags |= DEXOPT_OPT_ALL; 428 } 429 if (gDvm.classVerifyMode != VERIFY_MODE_NONE) { 430 flags |= DEXOPT_VERIFY_ENABLED; 431 if (gDvm.classVerifyMode == VERIFY_MODE_ALL) 432 flags |= DEXOPT_VERIFY_ALL; 433 } 434 if (isBootstrap) 435 flags |= DEXOPT_IS_BOOTSTRAP; 436 if (gDvm.generateRegisterMaps) 437 flags |= DEXOPT_GEN_REGISTER_MAP; 438 sprintf(values[9], "%d", flags); 439 argv[curArg++] = values[9]; 440 441 assert(((!kUseValgrind && curArg == kFixedArgCount) || 442 ((kUseValgrind && curArg == kFixedArgCount+kValgrindArgCount)))); 443 444 ClassPathEntry* cpe; 445 for (cpe = gDvm.bootClassPath; cpe->ptr != NULL; cpe++) { 446 argv[curArg++] = cpe->fileName; 447 } 448 assert(curArg == argc); 449 450 argv[curArg] = NULL; 451 452 if (kUseValgrind) 453 execv(kValgrinder, argv); 454 else 455 execv(execFile, argv); 456 457 LOGE("execv '%s'%s failed: %s\n", execFile, 458 kUseValgrind ? " [valgrind]" : "", strerror(errno)); 459 exit(1); 460 } else { 461 LOGV("DexOpt: waiting for verify+opt, pid=%d\n", (int) pid); 462 int status; 463 pid_t gotPid; 464 int oldStatus; 465 466 /* 467 * Wait for the optimization process to finish. We go into VMWAIT 468 * mode here so GC suspension won't have to wait for us. 469 */ 470 oldStatus = dvmChangeStatus(NULL, THREAD_VMWAIT); 471 while (true) { 472 gotPid = waitpid(pid, &status, 0); 473 if (gotPid == -1 && errno == EINTR) { 474 LOGD("waitpid interrupted, retrying\n"); 475 } else { 476 break; 477 } 478 } 479 dvmChangeStatus(NULL, oldStatus); 480 if (gotPid != pid) { 481 LOGE("waitpid failed: wanted %d, got %d: %s\n", 482 (int) pid, (int) gotPid, strerror(errno)); 483 return false; 484 } 485 486 if (WIFEXITED(status) && WEXITSTATUS(status) == 0) { 487 LOGD("DexOpt: --- END '%s' (success) ---\n", lastPart); 488 return true; 489 } else { 490 LOGW("DexOpt: --- END '%s' --- status=0x%04x, process failed\n", 491 lastPart, status); 492 return false; 493 } 494 } 495 } 496 497 /* 498 * Do the actual optimization. This is called directly for "minimal" 499 * optimization, or from a newly-created process for "full" optimization. 500 * 501 * For best use of disk/memory, we want to extract once and perform 502 * optimizations in place. If the file has to expand or contract 503 * to match local structure padding/alignment expectations, we want 504 * to do the rewrite as part of the extract, rather than extracting 505 * into a temp file and slurping it back out. (The structure alignment 506 * is currently correct for all platforms, and this isn't expected to 507 * change, so we should be okay with having it already extracted.) 508 * 509 * Returns "true" on success. 510 */ 511 bool dvmContinueOptimization(int fd, off_t dexOffset, long dexLength, 512 const char* fileName, u4 modWhen, u4 crc, bool isBootstrap) 513 { 514 DexClassLookup* pClassLookup = NULL; 515 IndexMapSet* pIndexMapSet = NULL; 516 RegisterMapBuilder* pRegMapBuilder = NULL; 517 bool doVerify, doOpt; 518 u4 headerFlags = 0; 519 520 if (gDvm.classVerifyMode == VERIFY_MODE_NONE) 521 doVerify = false; 522 else if (gDvm.classVerifyMode == VERIFY_MODE_REMOTE) 523 doVerify = !isBootstrap; 524 else /*if (gDvm.classVerifyMode == VERIFY_MODE_ALL)*/ 525 doVerify = true; 526 527 if (gDvm.dexOptMode == OPTIMIZE_MODE_NONE) 528 doOpt = false; 529 else if (gDvm.dexOptMode == OPTIMIZE_MODE_VERIFIED) 530 doOpt = doVerify; 531 else /*if (gDvm.dexOptMode == OPTIMIZE_MODE_ALL)*/ 532 doOpt = true; 533 534 LOGV("Continuing optimization (%s, isb=%d, vfy=%d, opt=%d)\n", 535 fileName, isBootstrap, doVerify, doOpt); 536 537 assert(dexOffset >= 0); 538 539 /* quick test so we don't blow up on empty file */ 540 if (dexLength < (int) sizeof(DexHeader)) { 541 LOGE("too small to be DEX\n"); 542 return false; 543 } 544 if (dexOffset < (int) sizeof(DexOptHeader)) { 545 LOGE("not enough room for opt header\n"); 546 return false; 547 } 548 549 bool result = false; 550 551 /* 552 * Drop this into a global so we don't have to pass it around. We could 553 * also add a field to DexFile, but since it only pertains to DEX 554 * creation that probably doesn't make sense. 555 */ 556 gDvm.optimizingBootstrapClass = isBootstrap; 557 558 { 559 /* 560 * Map the entire file (so we don't have to worry about page 561 * alignment). The expectation is that the output file contains 562 * our DEX data plus room for a small header. 563 */ 564 bool success; 565 void* mapAddr; 566 mapAddr = mmap(NULL, dexOffset + dexLength, PROT_READ|PROT_WRITE, 567 MAP_SHARED, fd, 0); 568 if (mapAddr == MAP_FAILED) { 569 LOGE("unable to mmap DEX cache: %s\n", strerror(errno)); 570 goto bail; 571 } 572 573 /* 574 * Rewrite the file. Byte reordering, structure realigning, 575 * class verification, and bytecode optimization are all performed 576 * here. 577 * 578 * In theory the file could change size and bits could shift around. 579 * In practice this would be annoying to deal with, so the file 580 * layout is designed so that it can always be rewritten in place. 581 * 582 * This sets "headerFlags" and creates the class lookup table as 583 * part of doing the processing. 584 */ 585 success = rewriteDex(((u1*) mapAddr) + dexOffset, dexLength, 586 doVerify, doOpt, &headerFlags, &pClassLookup); 587 588 if (success) { 589 DvmDex* pDvmDex = NULL; 590 u1* dexAddr = ((u1*) mapAddr) + dexOffset; 591 592 if (dvmDexFileOpenPartial(dexAddr, dexLength, &pDvmDex) != 0) { 593 LOGE("Unable to create DexFile\n"); 594 success = false; 595 } else { 596 /* 597 * If configured to do so, scan the instructions, looking 598 * for ways to reduce the size of the resolved-constant table. 599 * This is done post-optimization, across the instructions 600 * in all methods in all classes (even the ones that failed 601 * to load). 602 */ 603 pIndexMapSet = dvmRewriteConstants(pDvmDex); 604 605 /* 606 * If configured to do so, generate a full set of register 607 * maps for all verified classes. 608 */ 609 if (gDvm.generateRegisterMaps) { 610 pRegMapBuilder = dvmGenerateRegisterMaps(pDvmDex); 611 if (pRegMapBuilder == NULL) { 612 LOGE("Failed generating register maps\n"); 613 success = false; 614 } 615 } 616 617 DexHeader* pHeader = (DexHeader*)pDvmDex->pHeader; 618 updateChecksum(dexAddr, dexLength, pHeader); 619 620 dvmDexFileFree(pDvmDex); 621 } 622 } 623 624 /* unmap the read-write version, forcing writes to disk */ 625 if (msync(mapAddr, dexOffset + dexLength, MS_SYNC) != 0) { 626 LOGW("msync failed: %s\n", strerror(errno)); 627 // weird, but keep going 628 } 629 #if 1 630 /* 631 * This causes clean shutdown to fail, because we have loaded classes 632 * that point into it. For the optimizer this isn't a problem, 633 * because it's more efficient for the process to simply exit. 634 * Exclude this code when doing clean shutdown for valgrind. 635 */ 636 if (munmap(mapAddr, dexOffset + dexLength) != 0) { 637 LOGE("munmap failed: %s\n", strerror(errno)); 638 goto bail; 639 } 640 #endif 641 642 if (!success) 643 goto bail; 644 } 645 646 /* get start offset, and adjust deps start for 64-bit alignment */ 647 off_t depsOffset, auxOffset, endOffset, adjOffset; 648 int depsLength, auxLength; 649 u4 optChecksum; 650 651 depsOffset = lseek(fd, 0, SEEK_END); 652 if (depsOffset < 0) { 653 LOGE("lseek to EOF failed: %s\n", strerror(errno)); 654 goto bail; 655 } 656 adjOffset = (depsOffset + 7) & ~(0x07); 657 if (adjOffset != depsOffset) { 658 LOGV("Adjusting deps start from %d to %d\n", 659 (int) depsOffset, (int) adjOffset); 660 depsOffset = adjOffset; 661 lseek(fd, depsOffset, SEEK_SET); 662 } 663 664 /* 665 * Append the dependency list. 666 */ 667 if (writeDependencies(fd, modWhen, crc) != 0) { 668 LOGW("Failed writing dependencies\n"); 669 goto bail; 670 } 671 672 /* compute deps length, then adjust aux start for 64-bit alignment */ 673 auxOffset = lseek(fd, 0, SEEK_END); 674 depsLength = auxOffset - depsOffset; 675 676 adjOffset = (auxOffset + 7) & ~(0x07); 677 if (adjOffset != auxOffset) { 678 LOGV("Adjusting aux start from %d to %d\n", 679 (int) auxOffset, (int) adjOffset); 680 auxOffset = adjOffset; 681 lseek(fd, auxOffset, SEEK_SET); 682 } 683 684 /* 685 * Append any auxillary pre-computed data structures. 686 */ 687 if (!writeAuxData(fd, pClassLookup, pIndexMapSet, pRegMapBuilder)) { 688 LOGW("Failed writing aux data\n"); 689 goto bail; 690 } 691 692 endOffset = lseek(fd, 0, SEEK_END); 693 auxLength = endOffset - auxOffset; 694 695 /* compute checksum from start of deps to end of aux area */ 696 if (!computeFileChecksum(fd, depsOffset, 697 (auxOffset+auxLength) - depsOffset, &optChecksum)) 698 { 699 goto bail; 700 } 701 702 /* 703 * Output the "opt" header with all values filled in and a correct 704 * magic number. 705 */ 706 DexOptHeader optHdr; 707 memset(&optHdr, 0xff, sizeof(optHdr)); 708 memcpy(optHdr.magic, DEX_OPT_MAGIC, 4); 709 memcpy(optHdr.magic+4, DEX_OPT_MAGIC_VERS, 4); 710 optHdr.dexOffset = (u4) dexOffset; 711 optHdr.dexLength = (u4) dexLength; 712 optHdr.depsOffset = (u4) depsOffset; 713 optHdr.depsLength = (u4) depsLength; 714 optHdr.auxOffset = (u4) auxOffset; 715 optHdr.auxLength = (u4) auxLength; 716 717 optHdr.flags = headerFlags; 718 optHdr.checksum = optChecksum; 719 720 ssize_t actual; 721 lseek(fd, 0, SEEK_SET); 722 actual = write(fd, &optHdr, sizeof(optHdr)); 723 if (actual != sizeof(optHdr)) { 724 logFailedWrite(sizeof(optHdr), actual, "opt header", errno); 725 goto bail; 726 } 727 728 LOGV("Successfully wrote DEX header\n"); 729 result = true; 730 731 //dvmRegisterMapDumpStats(); 732 733 bail: 734 dvmFreeIndexMapSet(pIndexMapSet); 735 dvmFreeRegisterMapBuilder(pRegMapBuilder); 736 free(pClassLookup); 737 return result; 738 } 739 740 741 /* 742 * Get the cache file name from a ClassPathEntry. 743 */ 744 static const char* getCacheFileName(const ClassPathEntry* cpe) 745 { 746 switch (cpe->kind) { 747 case kCpeJar: 748 return dvmGetJarFileCacheFileName((JarFile*) cpe->ptr); 749 case kCpeDex: 750 return dvmGetRawDexFileCacheFileName((RawDexFile*) cpe->ptr); 751 default: 752 LOGE("DexOpt: unexpected cpe kind %d\n", cpe->kind); 753 dvmAbort(); 754 return NULL; 755 } 756 } 757 758 /* 759 * Get the SHA-1 signature. 760 */ 761 static const u1* getSignature(const ClassPathEntry* cpe) 762 { 763 DvmDex* pDvmDex; 764 765 switch (cpe->kind) { 766 case kCpeJar: 767 pDvmDex = dvmGetJarFileDex((JarFile*) cpe->ptr); 768 break; 769 case kCpeDex: 770 pDvmDex = dvmGetRawDexFileDex((RawDexFile*) cpe->ptr); 771 break; 772 default: 773 LOGE("unexpected cpe kind %d\n", cpe->kind); 774 dvmAbort(); 775 pDvmDex = NULL; // make gcc happy 776 } 777 778 assert(pDvmDex != NULL); 779 return pDvmDex->pDexFile->pHeader->signature; 780 } 781 782 783 /* 784 * Dependency layout: 785 * 4b Source file modification time, in seconds since 1970 UTC 786 * 4b CRC-32 from Zip entry, or Adler32 from source DEX header 787 * 4b Dalvik VM build number 788 * 4b Number of dependency entries that follow 789 * Dependency entries: 790 * 4b Name length (including terminating null) 791 * var Full path of cache entry (null terminated) 792 * 20b SHA-1 signature from source DEX file 793 * 794 * If this changes, update DEX_OPT_MAGIC_VERS. 795 */ 796 static const size_t kMinDepSize = 4 * 4; 797 static const size_t kMaxDepSize = 4 * 4 + 1024; // sanity check 798 799 /* 800 * Read the "opt" header, verify it, then read the dependencies section 801 * and verify that data as well. 802 * 803 * If "sourceAvail" is "true", this will verify that "modWhen" and "crc" 804 * match up with what is stored in the header. If they don't, we reject 805 * the file so that it can be recreated from the updated original. If 806 * "sourceAvail" isn't set, e.g. for a .odex file, we ignore these arguments. 807 * 808 * On successful return, the file will be seeked immediately past the 809 * "opt" header. 810 */ 811 bool dvmCheckOptHeaderAndDependencies(int fd, bool sourceAvail, u4 modWhen, 812 u4 crc, bool expectVerify, bool expectOpt) 813 { 814 DexOptHeader optHdr; 815 u1* depData = NULL; 816 const u1* magic; 817 off_t posn; 818 int result = false; 819 ssize_t actual; 820 821 /* 822 * Start at the start. The "opt" header, when present, will always be 823 * the first thing in the file. 824 */ 825 if (lseek(fd, 0, SEEK_SET) != 0) { 826 LOGE("DexOpt: failed to seek to start of file: %s\n", strerror(errno)); 827 goto bail; 828 } 829 830 /* 831 * Read and do trivial verification on the opt header. The header is 832 * always in host byte order. 833 */ 834 if (read(fd, &optHdr, sizeof(optHdr)) != sizeof(optHdr)) { 835 LOGE("DexOpt: failed reading opt header: %s\n", strerror(errno)); 836 goto bail; 837 } 838 839 magic = optHdr.magic; 840 if (memcmp(magic, DEX_OPT_MAGIC, 4) != 0) { 841 /* not a DEX file, or previous attempt was interrupted */ 842 LOGD("DexOpt: incorrect opt magic number (0x%02x %02x %02x %02x)\n", 843 magic[0], magic[1], magic[2], magic[3]); 844 goto bail; 845 } 846 if (memcmp(magic+4, DEX_OPT_MAGIC_VERS, 4) != 0) { 847 LOGW("DexOpt: stale opt version (0x%02x %02x %02x %02x)\n", 848 magic[4], magic[5], magic[6], magic[7]); 849 goto bail; 850 } 851 if (optHdr.depsLength < kMinDepSize || optHdr.depsLength > kMaxDepSize) { 852 LOGW("DexOpt: weird deps length %d, bailing\n", optHdr.depsLength); 853 goto bail; 854 } 855 856 /* 857 * Do the header flags match up with what we want? 858 * 859 * This is useful because it allows us to automatically regenerate 860 * a file when settings change (e.g. verification is now mandatory), 861 * but can cause difficulties if the bootstrap classes we depend upon 862 * were handled differently than the current options specify. We get 863 * upset because they're not verified or optimized, but we're not able 864 * to regenerate them because the installer won't let us. 865 * 866 * (This is also of limited value when !sourceAvail.) 867 * 868 * So, for now, we essentially ignore "expectVerify" and "expectOpt" 869 * by limiting the match mask. 870 * 871 * The only thing we really can't handle is incorrect byte-ordering. 872 */ 873 const u4 matchMask = DEX_OPT_FLAG_BIG; 874 u4 expectedFlags = 0; 875 #if __BYTE_ORDER != __LITTLE_ENDIAN 876 expectedFlags |= DEX_OPT_FLAG_BIG; 877 #endif 878 if (expectVerify) 879 expectedFlags |= DEX_FLAG_VERIFIED; 880 if (expectOpt) 881 expectedFlags |= DEX_OPT_FLAG_FIELDS | DEX_OPT_FLAG_INVOCATIONS; 882 if ((expectedFlags & matchMask) != (optHdr.flags & matchMask)) { 883 LOGI("DexOpt: header flag mismatch (0x%02x vs 0x%02x, mask=0x%02x)\n", 884 expectedFlags, optHdr.flags, matchMask); 885 goto bail; 886 } 887 888 posn = lseek(fd, optHdr.depsOffset, SEEK_SET); 889 if (posn < 0) { 890 LOGW("DexOpt: seek to deps failed: %s\n", strerror(errno)); 891 goto bail; 892 } 893 894 /* 895 * Read all of the dependency stuff into memory. 896 */ 897 depData = (u1*) malloc(optHdr.depsLength); 898 if (depData == NULL) { 899 LOGW("DexOpt: unable to allocate %d bytes for deps\n", 900 optHdr.depsLength); 901 goto bail; 902 } 903 actual = read(fd, depData, optHdr.depsLength); 904 if (actual != (ssize_t) optHdr.depsLength) { 905 LOGW("DexOpt: failed reading deps: %d of %d (err=%s)\n", 906 (int) actual, optHdr.depsLength, strerror(errno)); 907 goto bail; 908 } 909 910 /* 911 * Verify simple items. 912 */ 913 const u1* ptr; 914 u4 val; 915 916 ptr = depData; 917 val = read4LE(&ptr); 918 if (sourceAvail && val != modWhen) { 919 LOGI("DexOpt: source file mod time mismatch (%08x vs %08x)\n", 920 val, modWhen); 921 goto bail; 922 } 923 val = read4LE(&ptr); 924 if (sourceAvail && val != crc) { 925 LOGI("DexOpt: source file CRC mismatch (%08x vs %08x)\n", val, crc); 926 goto bail; 927 } 928 val = read4LE(&ptr); 929 if (val != DALVIK_VM_BUILD) { 930 LOGD("DexOpt: VM build version mismatch (%d vs %d)\n", 931 val, DALVIK_VM_BUILD); 932 goto bail; 933 } 934 935 /* 936 * Verify dependencies on other cached DEX files. It must match 937 * exactly with what is currently defined in the bootclasspath. 938 */ 939 ClassPathEntry* cpe; 940 u4 numDeps; 941 942 numDeps = read4LE(&ptr); 943 LOGV("+++ DexOpt: numDeps = %d\n", numDeps); 944 for (cpe = gDvm.bootClassPath; cpe->ptr != NULL; cpe++) { 945 const char* cacheFileName = getCacheFileName(cpe); 946 const u1* signature = getSignature(cpe); 947 size_t len = strlen(cacheFileName) +1; 948 u4 storedStrLen; 949 950 if (numDeps == 0) { 951 /* more entries in bootclasspath than in deps list */ 952 LOGI("DexOpt: not all deps represented\n"); 953 goto bail; 954 } 955 956 storedStrLen = read4LE(&ptr); 957 if (len != storedStrLen || 958 strcmp(cacheFileName, (const char*) ptr) != 0) 959 { 960 LOGI("DexOpt: mismatch dep name: '%s' vs. '%s'\n", 961 cacheFileName, ptr); 962 goto bail; 963 } 964 965 ptr += storedStrLen; 966 967 if (memcmp(signature, ptr, kSHA1DigestLen) != 0) { 968 LOGI("DexOpt: mismatch dep signature for '%s'\n", cacheFileName); 969 goto bail; 970 } 971 ptr += kSHA1DigestLen; 972 973 LOGV("DexOpt: dep match on '%s'\n", cacheFileName); 974 975 numDeps--; 976 } 977 978 if (numDeps != 0) { 979 /* more entries in deps list than in classpath */ 980 LOGI("DexOpt: Some deps went away\n"); 981 goto bail; 982 } 983 984 // consumed all data and no more? 985 if (ptr != depData + optHdr.depsLength) { 986 LOGW("DexOpt: Spurious dep data? %d vs %d\n", 987 (int) (ptr - depData), optHdr.depsLength); 988 assert(false); 989 } 990 991 result = true; 992 993 bail: 994 free(depData); 995 return result; 996 } 997 998 /* 999 * Write the dependency info to "fd" at the current file position. 1000 */ 1001 static int writeDependencies(int fd, u4 modWhen, u4 crc) 1002 { 1003 u1* buf = NULL; 1004 ssize_t actual; 1005 int result = -1; 1006 ssize_t bufLen; 1007 ClassPathEntry* cpe; 1008 int i, numDeps; 1009 1010 /* 1011 * Count up the number of completed entries in the bootclasspath. 1012 */ 1013 numDeps = 0; 1014 bufLen = 0; 1015 for (cpe = gDvm.bootClassPath; cpe->ptr != NULL; cpe++) { 1016 const char* cacheFileName = getCacheFileName(cpe); 1017 LOGV("+++ DexOpt: found dep '%s'\n", cacheFileName); 1018 1019 numDeps++; 1020 bufLen += strlen(cacheFileName) +1; 1021 } 1022 1023 bufLen += 4*4 + numDeps * (4+kSHA1DigestLen); 1024 1025 buf = malloc(bufLen); 1026 1027 set4LE(buf+0, modWhen); 1028 set4LE(buf+4, crc); 1029 set4LE(buf+8, DALVIK_VM_BUILD); 1030 set4LE(buf+12, numDeps); 1031 1032 // TODO: do we want to add dvmGetInlineOpsTableLength() here? Won't 1033 // help us if somebody replaces an existing entry, but it'd catch 1034 // additions/removals. 1035 1036 u1* ptr = buf + 4*4; 1037 for (cpe = gDvm.bootClassPath; cpe->ptr != NULL; cpe++) { 1038 const char* cacheFileName = getCacheFileName(cpe); 1039 const u1* signature = getSignature(cpe); 1040 int len = strlen(cacheFileName) +1; 1041 1042 if (ptr + 4 + len + kSHA1DigestLen > buf + bufLen) { 1043 LOGE("DexOpt: overran buffer\n"); 1044 dvmAbort(); 1045 } 1046 1047 set4LE(ptr, len); 1048 ptr += 4; 1049 memcpy(ptr, cacheFileName, len); 1050 ptr += len; 1051 memcpy(ptr, signature, kSHA1DigestLen); 1052 ptr += kSHA1DigestLen; 1053 } 1054 1055 assert(ptr == buf + bufLen); 1056 1057 actual = write(fd, buf, bufLen); 1058 if (actual != bufLen) { 1059 result = (errno != 0) ? errno : -1; 1060 logFailedWrite(bufLen, actual, "dep info", errno); 1061 } else { 1062 result = 0; 1063 } 1064 1065 free(buf); 1066 return result; 1067 } 1068 1069 1070 /* 1071 * Write a block of data in "chunk" format. 1072 * 1073 * The chunk header fields are always in "native" byte order. If "size" 1074 * is not a multiple of 8 bytes, the data area is padded out. 1075 */ 1076 static bool writeChunk(int fd, u4 type, const void* data, size_t size) 1077 { 1078 ssize_t actual; 1079 union { /* save a syscall by grouping these together */ 1080 char raw[8]; 1081 struct { 1082 u4 type; 1083 u4 size; 1084 } ts; 1085 } header; 1086 1087 assert(sizeof(header) == 8); 1088 1089 LOGV("Writing chunk, type=%.4s size=%d\n", (char*) &type, size); 1090 1091 header.ts.type = type; 1092 header.ts.size = (u4) size; 1093 actual = write(fd, &header, sizeof(header)); 1094 if (actual != sizeof(header)) { 1095 logFailedWrite(size, actual, "aux chunk header write", errno); 1096 return false; 1097 } 1098 1099 if (size > 0) { 1100 actual = write(fd, data, size); 1101 if (actual != (ssize_t) size) { 1102 logFailedWrite(size, actual, "aux chunk write", errno); 1103 return false; 1104 } 1105 } 1106 1107 /* if necessary, pad to 64-bit alignment */ 1108 if ((size & 7) != 0) { 1109 int padSize = 8 - (size & 7); 1110 LOGV("size was %d, inserting %d pad bytes\n", size, padSize); 1111 lseek(fd, padSize, SEEK_CUR); 1112 } 1113 1114 assert( ((int)lseek(fd, 0, SEEK_CUR) & 7) == 0); 1115 1116 return true; 1117 } 1118 1119 /* 1120 * Write aux data. 1121 * 1122 * We have different pieces, some of which may be optional. To make the 1123 * most effective use of space, we use a "chunk" format, with a 4-byte 1124 * type and a 4-byte length. We guarantee 64-bit alignment for the data, 1125 * so it can be used directly when the file is mapped for reading. 1126 */ 1127 static bool writeAuxData(int fd, const DexClassLookup* pClassLookup, 1128 const IndexMapSet* pIndexMapSet, const RegisterMapBuilder* pRegMapBuilder) 1129 { 1130 /* pre-computed class lookup hash table */ 1131 if (!writeChunk(fd, (u4) kDexChunkClassLookup, 1132 pClassLookup, pClassLookup->size)) 1133 { 1134 return false; 1135 } 1136 1137 /* remapped constants (optional) */ 1138 if (pIndexMapSet != NULL) { 1139 if (!writeChunk(fd, pIndexMapSet->chunkType, 1140 pIndexMapSet->chunkData, pIndexMapSet->chunkDataLen)) 1141 { 1142 return false; 1143 } 1144 } 1145 1146 /* register maps (optional) */ 1147 if (pRegMapBuilder != NULL) { 1148 if (!writeChunk(fd, (u4) kDexChunkRegisterMaps, 1149 pRegMapBuilder->data, pRegMapBuilder->size)) 1150 { 1151 return false; 1152 } 1153 } 1154 1155 /* write the end marker */ 1156 if (!writeChunk(fd, (u4) kDexChunkEnd, NULL, 0)) { 1157 return false; 1158 } 1159 1160 return true; 1161 } 1162 1163 /* 1164 * Log a failed write. 1165 */ 1166 static void logFailedWrite(size_t expected, ssize_t actual, const char* msg, 1167 int err) 1168 { 1169 LOGE("Write failed: %s (%d of %d): %s\n", 1170 msg, (int)actual, (int)expected, strerror(err)); 1171 } 1172 1173 /* 1174 * Compute a checksum on a piece of an open file. 1175 * 1176 * File will be positioned at end of checksummed area. 1177 * 1178 * Returns "true" on success. 1179 */ 1180 static bool computeFileChecksum(int fd, off_t start, size_t length, u4* pSum) 1181 { 1182 unsigned char readBuf[8192]; 1183 ssize_t actual; 1184 uLong adler; 1185 1186 if (lseek(fd, start, SEEK_SET) != start) { 1187 LOGE("Unable to seek to start of checksum area (%ld): %s\n", 1188 (long) start, strerror(errno)); 1189 return false; 1190 } 1191 1192 adler = adler32(0L, Z_NULL, 0); 1193 1194 while (length != 0) { 1195 size_t wanted = (length < sizeof(readBuf)) ? length : sizeof(readBuf); 1196 actual = read(fd, readBuf, wanted); 1197 if (actual <= 0) { 1198 LOGE("Read failed (%d) while computing checksum (len=%zu): %s\n", 1199 (int) actual, length, strerror(errno)); 1200 return false; 1201 } 1202 1203 adler = adler32(adler, readBuf, actual); 1204 1205 length -= actual; 1206 } 1207 1208 *pSum = adler; 1209 return true; 1210 } 1211 1212 1213 /* 1214 * =========================================================================== 1215 * Optimizations 1216 * =========================================================================== 1217 */ 1218 1219 /* 1220 * Perform in-place rewrites on a memory-mapped DEX file. 1221 * 1222 * This happens in a short-lived child process, so we can go nutty with 1223 * loading classes and allocating memory. 1224 */ 1225 static bool rewriteDex(u1* addr, int len, bool doVerify, bool doOpt, 1226 u4* pHeaderFlags, DexClassLookup** ppClassLookup) 1227 { 1228 u8 prepWhen, loadWhen, verifyWhen, optWhen; 1229 DvmDex* pDvmDex = NULL; 1230 bool result = false; 1231 1232 *pHeaderFlags = 0; 1233 1234 LOGV("+++ swapping bytes\n"); 1235 if (dexFixByteOrdering(addr, len) != 0) 1236 goto bail; 1237 #if __BYTE_ORDER != __LITTLE_ENDIAN 1238 *pHeaderFlags |= DEX_OPT_FLAG_BIG; 1239 #endif 1240 1241 /* 1242 * Now that the DEX file can be read directly, create a DexFile for it. 1243 */ 1244 if (dvmDexFileOpenPartial(addr, len, &pDvmDex) != 0) { 1245 LOGE("Unable to create DexFile\n"); 1246 goto bail; 1247 } 1248 1249 /* 1250 * Create the class lookup table. 1251 */ 1252 //startWhen = dvmGetRelativeTimeUsec(); 1253 *ppClassLookup = dexCreateClassLookup(pDvmDex->pDexFile); 1254 if (*ppClassLookup == NULL) 1255 goto bail; 1256 1257 /* 1258 * Bail out early if they don't want The Works. The current implementation 1259 * doesn't fork a new process if this flag isn't set, so we really don't 1260 * want to continue on with the crazy class loading. 1261 */ 1262 if (!doVerify && !doOpt) { 1263 result = true; 1264 goto bail; 1265 } 1266 1267 /* this is needed for the next part */ 1268 pDvmDex->pDexFile->pClassLookup = *ppClassLookup; 1269 1270 prepWhen = dvmGetRelativeTimeUsec(); 1271 1272 /* 1273 * Load all classes found in this DEX file. If they fail to load for 1274 * some reason, they won't get verified (which is as it should be). 1275 */ 1276 if (!loadAllClasses(pDvmDex)) 1277 goto bail; 1278 loadWhen = dvmGetRelativeTimeUsec(); 1279 1280 /* 1281 * Verify all classes in the DEX file. Export the "is verified" flag 1282 * to the DEX file we're creating. 1283 */ 1284 if (doVerify) { 1285 dvmVerifyAllClasses(pDvmDex->pDexFile); 1286 *pHeaderFlags |= DEX_FLAG_VERIFIED; 1287 } 1288 verifyWhen = dvmGetRelativeTimeUsec(); 1289 1290 /* 1291 * Optimize the classes we successfully loaded. If the opt mode is 1292 * OPTIMIZE_MODE_VERIFIED, each class must have been successfully 1293 * verified or we'll skip it. 1294 */ 1295 #ifndef PROFILE_FIELD_ACCESS 1296 if (doOpt) { 1297 optimizeLoadedClasses(pDvmDex->pDexFile); 1298 *pHeaderFlags |= DEX_OPT_FLAG_FIELDS | DEX_OPT_FLAG_INVOCATIONS; 1299 } 1300 #endif 1301 optWhen = dvmGetRelativeTimeUsec(); 1302 1303 LOGD("DexOpt: load %dms, verify %dms, opt %dms\n", 1304 (int) (loadWhen - prepWhen) / 1000, 1305 (int) (verifyWhen - loadWhen) / 1000, 1306 (int) (optWhen - verifyWhen) / 1000); 1307 1308 result = true; 1309 1310 bail: 1311 /* free up storage */ 1312 dvmDexFileFree(pDvmDex); 1313 1314 return result; 1315 } 1316 1317 /* 1318 * Update the Adler-32 checksum stored in the DEX file. This covers the 1319 * swapped and optimized DEX data, but does not include the opt header 1320 * or auxillary data. 1321 */ 1322 static void updateChecksum(u1* addr, int len, DexHeader* pHeader) 1323 { 1324 /* 1325 * Rewrite the checksum. We leave the SHA-1 signature alone. 1326 */ 1327 uLong adler = adler32(0L, Z_NULL, 0); 1328 const int nonSum = sizeof(pHeader->magic) + sizeof(pHeader->checksum); 1329 1330 adler = adler32(adler, addr + nonSum, len - nonSum); 1331 pHeader->checksum = adler; 1332 } 1333 1334 /* 1335 * Try to load all classes in the specified DEX. If they have some sort 1336 * of broken dependency, e.g. their superclass lives in a different DEX 1337 * that wasn't previously loaded into the bootstrap class path, loading 1338 * will fail. This is the desired behavior. 1339 * 1340 * We have no notion of class loader at this point, so we load all of 1341 * the classes with the bootstrap class loader. It turns out this has 1342 * exactly the behavior we want, and has no ill side effects because we're 1343 * running in a separate process and anything we load here will be forgotten. 1344 * 1345 * We set the CLASS_MULTIPLE_DEFS flag here if we see multiple definitions. 1346 * This works because we only call here as part of optimization / pre-verify, 1347 * not during verification as part of loading a class into a running VM. 1348 * 1349 * This returns "false" if the world is too screwed up to do anything 1350 * useful at all. 1351 */ 1352 static bool loadAllClasses(DvmDex* pDvmDex) 1353 { 1354 u4 count = pDvmDex->pDexFile->pHeader->classDefsSize; 1355 u4 idx; 1356 int loaded = 0; 1357 1358 LOGV("DexOpt: +++ trying to load %d classes\n", count); 1359 1360 dvmSetBootPathExtraDex(pDvmDex); 1361 1362 /* 1363 * We have some circularity issues with Class and Object that are most 1364 * easily avoided by ensuring that Object is never the first thing we 1365 * try to find. Take care of that here. (We only need to do this when 1366 * loading classes from the DEX file that contains Object, and only 1367 * when Object comes first in the list, but it costs very little to 1368 * do it in all cases.) 1369 */ 1370 if (dvmFindSystemClass("Ljava/lang/Class;") == NULL) { 1371 LOGE("ERROR: java.lang.Class does not exist!\n"); 1372 return false; 1373 } 1374 1375 for (idx = 0; idx < count; idx++) { 1376 const DexClassDef* pClassDef; 1377 const char* classDescriptor; 1378 ClassObject* newClass; 1379 1380 pClassDef = dexGetClassDef(pDvmDex->pDexFile, idx); 1381 classDescriptor = 1382 dexStringByTypeIdx(pDvmDex->pDexFile, pClassDef->classIdx); 1383 1384 LOGV("+++ loading '%s'", classDescriptor); 1385 //newClass = dvmDefineClass(pDexFile, classDescriptor, 1386 // NULL); 1387 newClass = dvmFindSystemClassNoInit(classDescriptor); 1388 if (newClass == NULL) { 1389 LOGV("DexOpt: failed loading '%s'\n", classDescriptor); 1390 dvmClearOptException(dvmThreadSelf()); 1391 } else if (newClass->pDvmDex != pDvmDex) { 1392 /* 1393 * We don't load the new one, and we tag the first one found 1394 * with the "multiple def" flag so the resolver doesn't try 1395 * to make it available. 1396 */ 1397 LOGD("DexOpt: '%s' has an earlier definition; blocking out\n", 1398 classDescriptor); 1399 SET_CLASS_FLAG(newClass, CLASS_MULTIPLE_DEFS); 1400 } else { 1401 loaded++; 1402 } 1403 } 1404 LOGV("DexOpt: +++ successfully loaded %d classes\n", loaded); 1405 1406 dvmSetBootPathExtraDex(NULL); 1407 return true; 1408 } 1409 1410 1411 /* 1412 * Create a table of inline substitutions. 1413 * 1414 * TODO: this is currently just a linear array. We will want to put this 1415 * into a hash table as the list size increases. 1416 */ 1417 static InlineSub* createInlineSubsTable(void) 1418 { 1419 const InlineOperation* ops = dvmGetInlineOpsTable(); 1420 const int count = dvmGetInlineOpsTableLength(); 1421 InlineSub* table; 1422 Method* method; 1423 ClassObject* clazz; 1424 int i, tableIndex; 1425 1426 /* 1427 * Allocate for optimism: one slot per entry, plus an end-of-list marker. 1428 */ 1429 table = malloc(sizeof(InlineSub) * (count+1)); 1430 1431 tableIndex = 0; 1432 for (i = 0; i < count; i++) { 1433 clazz = dvmFindClassNoInit(ops[i].classDescriptor, NULL); 1434 if (clazz == NULL) { 1435 LOGV("DexOpt: can't inline for class '%s': not found\n", 1436 ops[i].classDescriptor); 1437 dvmClearOptException(dvmThreadSelf()); 1438 } else { 1439 /* 1440 * Method could be virtual or direct. Try both. Don't use 1441 * the "hier" versions. 1442 */ 1443 method = dvmFindDirectMethodByDescriptor(clazz, ops[i].methodName, 1444 ops[i].methodSignature); 1445 if (method == NULL) 1446 method = dvmFindVirtualMethodByDescriptor(clazz, ops[i].methodName, 1447 ops[i].methodSignature); 1448 if (method == NULL) { 1449 LOGW("DexOpt: can't inline %s.%s %s: method not found\n", 1450 ops[i].classDescriptor, ops[i].methodName, 1451 ops[i].methodSignature); 1452 } else { 1453 if (!dvmIsFinalClass(clazz) && !dvmIsFinalMethod(method)) { 1454 LOGW("DexOpt: WARNING: inline op on non-final class/method " 1455 "%s.%s\n", 1456 clazz->descriptor, method->name); 1457 /* fail? */ 1458 } 1459 if (dvmIsSynchronizedMethod(method) || 1460 dvmIsDeclaredSynchronizedMethod(method)) 1461 { 1462 LOGW("DexOpt: WARNING: inline op on synchronized method " 1463 "%s.%s\n", 1464 clazz->descriptor, method->name); 1465 /* fail? */ 1466 } 1467 1468 table[tableIndex].method = method; 1469 table[tableIndex].inlineIdx = i; 1470 tableIndex++; 1471 1472 LOGV("DexOpt: will inline %d: %s.%s %s\n", i, 1473 ops[i].classDescriptor, ops[i].methodName, 1474 ops[i].methodSignature); 1475 } 1476 } 1477 } 1478 1479 /* mark end of table */ 1480 table[tableIndex].method = NULL; 1481 LOGV("DexOpt: inline table has %d entries\n", tableIndex); 1482 1483 return table; 1484 } 1485 1486 /* 1487 * Run through all classes that were successfully loaded from this DEX 1488 * file and optimize their code sections. 1489 */ 1490 static void optimizeLoadedClasses(DexFile* pDexFile) 1491 { 1492 u4 count = pDexFile->pHeader->classDefsSize; 1493 u4 idx; 1494 InlineSub* inlineSubs = NULL; 1495 1496 LOGV("DexOpt: +++ optimizing up to %d classes\n", count); 1497 assert(gDvm.dexOptMode != OPTIMIZE_MODE_NONE); 1498 1499 inlineSubs = createInlineSubsTable(); 1500 1501 for (idx = 0; idx < count; idx++) { 1502 const DexClassDef* pClassDef; 1503 const char* classDescriptor; 1504 ClassObject* clazz; 1505 1506 pClassDef = dexGetClassDef(pDexFile, idx); 1507 classDescriptor = dexStringByTypeIdx(pDexFile, pClassDef->classIdx); 1508 1509 /* all classes are loaded into the bootstrap class loader */ 1510 clazz = dvmLookupClass(classDescriptor, NULL, false); 1511 if (clazz != NULL) { 1512 if ((pClassDef->accessFlags & CLASS_ISPREVERIFIED) == 0 && 1513 gDvm.dexOptMode == OPTIMIZE_MODE_VERIFIED) 1514 { 1515 LOGV("DexOpt: not optimizing '%s': not verified\n", 1516 classDescriptor); 1517 } else if (clazz->pDvmDex->pDexFile != pDexFile) { 1518 /* shouldn't be here -- verifier should have caught */ 1519 LOGD("DexOpt: not optimizing '%s': multiple definitions\n", 1520 classDescriptor); 1521 } else { 1522 optimizeClass(clazz, inlineSubs); 1523 1524 /* set the flag whether or not we actually did anything */ 1525 ((DexClassDef*)pClassDef)->accessFlags |= 1526 CLASS_ISOPTIMIZED; 1527 } 1528 } else { 1529 LOGV("DexOpt: not optimizing unavailable class '%s'\n", 1530 classDescriptor); 1531 } 1532 } 1533 1534 free(inlineSubs); 1535 } 1536 1537 /* 1538 * Optimize the specified class. 1539 */ 1540 static void optimizeClass(ClassObject* clazz, const InlineSub* inlineSubs) 1541 { 1542 int i; 1543 1544 for (i = 0; i < clazz->directMethodCount; i++) { 1545 if (!optimizeMethod(&clazz->directMethods[i], inlineSubs)) 1546 goto fail; 1547 } 1548 for (i = 0; i < clazz->virtualMethodCount; i++) { 1549 if (!optimizeMethod(&clazz->virtualMethods[i], inlineSubs)) 1550 goto fail; 1551 } 1552 1553 return; 1554 1555 fail: 1556 LOGV("DexOpt: ceasing optimization attempts on %s\n", clazz->descriptor); 1557 } 1558 1559 /* 1560 * Optimize instructions in a method. 1561 * 1562 * Returns "true" if all went well, "false" if we bailed out early when 1563 * something failed. 1564 */ 1565 static bool optimizeMethod(Method* method, const InlineSub* inlineSubs) 1566 { 1567 u4 insnsSize; 1568 u2* insns; 1569 u2 inst; 1570 1571 if (dvmIsNativeMethod(method) || dvmIsAbstractMethod(method)) 1572 return true; 1573 1574 insns = (u2*) method->insns; 1575 assert(insns != NULL); 1576 insnsSize = dvmGetMethodInsnsSize(method); 1577 1578 while (insnsSize > 0) { 1579 int width; 1580 1581 inst = *insns & 0xff; 1582 1583 switch (inst) { 1584 case OP_IGET: 1585 case OP_IGET_BOOLEAN: 1586 case OP_IGET_BYTE: 1587 case OP_IGET_CHAR: 1588 case OP_IGET_SHORT: 1589 rewriteInstField(method, insns, OP_IGET_QUICK); 1590 break; 1591 case OP_IGET_WIDE: 1592 rewriteInstField(method, insns, OP_IGET_WIDE_QUICK); 1593 break; 1594 case OP_IGET_OBJECT: 1595 rewriteInstField(method, insns, OP_IGET_OBJECT_QUICK); 1596 break; 1597 case OP_IPUT: 1598 case OP_IPUT_BOOLEAN: 1599 case OP_IPUT_BYTE: 1600 case OP_IPUT_CHAR: 1601 case OP_IPUT_SHORT: 1602 rewriteInstField(method, insns, OP_IPUT_QUICK); 1603 break; 1604 case OP_IPUT_WIDE: 1605 rewriteInstField(method, insns, OP_IPUT_WIDE_QUICK); 1606 break; 1607 case OP_IPUT_OBJECT: 1608 rewriteInstField(method, insns, OP_IPUT_OBJECT_QUICK); 1609 break; 1610 1611 case OP_INVOKE_VIRTUAL: 1612 if (!rewriteExecuteInline(method, insns, METHOD_VIRTUAL,inlineSubs)) 1613 { 1614 if (!rewriteVirtualInvoke(method, insns, OP_INVOKE_VIRTUAL_QUICK)) 1615 return false; 1616 } 1617 break; 1618 case OP_INVOKE_VIRTUAL_RANGE: 1619 if (!rewriteExecuteInlineRange(method, insns, METHOD_VIRTUAL, 1620 inlineSubs)) 1621 { 1622 if (!rewriteVirtualInvoke(method, insns, 1623 OP_INVOKE_VIRTUAL_QUICK_RANGE)) 1624 { 1625 return false; 1626 } 1627 } 1628 break; 1629 case OP_INVOKE_SUPER: 1630 if (!rewriteVirtualInvoke(method, insns, OP_INVOKE_SUPER_QUICK)) 1631 return false; 1632 break; 1633 case OP_INVOKE_SUPER_RANGE: 1634 if (!rewriteVirtualInvoke(method, insns, OP_INVOKE_SUPER_QUICK_RANGE)) 1635 return false; 1636 break; 1637 1638 case OP_INVOKE_DIRECT: 1639 if (!rewriteExecuteInline(method, insns, METHOD_DIRECT, inlineSubs)) 1640 { 1641 if (!rewriteEmptyDirectInvoke(method, insns)) 1642 return false; 1643 } 1644 break; 1645 case OP_INVOKE_DIRECT_RANGE: 1646 rewriteExecuteInlineRange(method, insns, METHOD_DIRECT, inlineSubs); 1647 break; 1648 1649 case OP_INVOKE_STATIC: 1650 rewriteExecuteInline(method, insns, METHOD_STATIC, inlineSubs); 1651 break; 1652 case OP_INVOKE_STATIC_RANGE: 1653 rewriteExecuteInlineRange(method, insns, METHOD_STATIC, inlineSubs); 1654 break; 1655 1656 default: 1657 // ignore this instruction 1658 ; 1659 } 1660 1661 if (*insns == kPackedSwitchSignature) { 1662 width = 4 + insns[1] * 2; 1663 } else if (*insns == kSparseSwitchSignature) { 1664 width = 2 + insns[1] * 4; 1665 } else if (*insns == kArrayDataSignature) { 1666 u2 elemWidth = insns[1]; 1667 u4 len = insns[2] | (((u4)insns[3]) << 16); 1668 width = 4 + (elemWidth * len + 1) / 2; 1669 } else { 1670 width = dexGetInstrWidth(gDvm.instrWidth, inst); 1671 } 1672 assert(width > 0); 1673 1674 insns += width; 1675 insnsSize -= width; 1676 } 1677 1678 assert(insnsSize == 0); 1679 return true; 1680 } 1681 1682 1683 /* 1684 * If "referrer" and "resClass" don't come from the same DEX file, and 1685 * the DEX we're working on is not destined for the bootstrap class path, 1686 * tweak the class loader so package-access checks work correctly. 1687 * 1688 * Only do this if we're doing pre-verification or optimization. 1689 */ 1690 static void tweakLoader(ClassObject* referrer, ClassObject* resClass) 1691 { 1692 if (!gDvm.optimizing) 1693 return; 1694 assert(referrer->classLoader == NULL); 1695 assert(resClass->classLoader == NULL); 1696 1697 if (!gDvm.optimizingBootstrapClass) { 1698 /* class loader for an array class comes from element type */ 1699 if (dvmIsArrayClass(resClass)) 1700 resClass = resClass->elementClass; 1701 if (referrer->pDvmDex != resClass->pDvmDex) 1702 resClass->classLoader = (Object*) 0xdead3333; 1703 } 1704 } 1705 1706 /* 1707 * Undo the effects of tweakLoader. 1708 */ 1709 static void untweakLoader(ClassObject* referrer, ClassObject* resClass) 1710 { 1711 if (!gDvm.optimizing || gDvm.optimizingBootstrapClass) 1712 return; 1713 1714 if (dvmIsArrayClass(resClass)) 1715 resClass = resClass->elementClass; 1716 resClass->classLoader = NULL; 1717 } 1718 1719 1720 /* 1721 * Alternate version of dvmResolveClass for use with verification and 1722 * optimization. Performs access checks on every resolve, and refuses 1723 * to acknowledge the existence of classes defined in more than one DEX 1724 * file. 1725 * 1726 * Exceptions caused by failures are cleared before returning. 1727 * 1728 * On failure, returns NULL, and sets *pFailure if pFailure is not NULL. 1729 */ 1730 ClassObject* dvmOptResolveClass(ClassObject* referrer, u4 classIdx, 1731 VerifyError* pFailure) 1732 { 1733 DvmDex* pDvmDex = referrer->pDvmDex; 1734 ClassObject* resClass; 1735 1736 /* 1737 * Check the table first. If not there, do the lookup by name. 1738 */ 1739 resClass = dvmDexGetResolvedClass(pDvmDex, classIdx); 1740 if (resClass == NULL) { 1741 const char* className = dexStringByTypeIdx(pDvmDex->pDexFile, classIdx); 1742 if (className[0] != '\0' && className[1] == '\0') { 1743 /* primitive type */ 1744 resClass = dvmFindPrimitiveClass(className[0]); 1745 } else { 1746 resClass = dvmFindClassNoInit(className, referrer->classLoader); 1747 } 1748 if (resClass == NULL) { 1749 /* not found, exception should be raised */ 1750 LOGV("DexOpt: class %d (%s) not found\n", 1751 classIdx, 1752 dexStringByTypeIdx(pDvmDex->pDexFile, classIdx)); 1753 if (pFailure != NULL) { 1754 /* dig through the wrappers to find the original failure */ 1755 Object* excep = dvmGetException(dvmThreadSelf()); 1756 while (true) { 1757 Object* cause = dvmGetExceptionCause(excep); 1758 if (cause == NULL) 1759 break; 1760 excep = cause; 1761 } 1762 if (strcmp(excep->clazz->descriptor, 1763 "Ljava/lang/IncompatibleClassChangeError;") == 0) 1764 { 1765 *pFailure = VERIFY_ERROR_CLASS_CHANGE; 1766 } else { 1767 *pFailure = VERIFY_ERROR_NO_CLASS; 1768 } 1769 } 1770 dvmClearOptException(dvmThreadSelf()); 1771 return NULL; 1772 } 1773 1774 /* 1775 * Add it to the resolved table so we're faster on the next lookup. 1776 */ 1777 dvmDexSetResolvedClass(pDvmDex, classIdx, resClass); 1778 } 1779 1780 /* multiple definitions? */ 1781 if (IS_CLASS_FLAG_SET(resClass, CLASS_MULTIPLE_DEFS)) { 1782 LOGI("DexOpt: not resolving ambiguous class '%s'\n", 1783 resClass->descriptor); 1784 if (pFailure != NULL) 1785 *pFailure = VERIFY_ERROR_NO_CLASS; 1786 return NULL; 1787 } 1788 1789 /* access allowed? */ 1790 tweakLoader(referrer, resClass); 1791 bool allowed = dvmCheckClassAccess(referrer, resClass); 1792 untweakLoader(referrer, resClass); 1793 if (!allowed) { 1794 LOGW("DexOpt: resolve class illegal access: %s -> %s\n", 1795 referrer->descriptor, resClass->descriptor); 1796 if (pFailure != NULL) 1797 *pFailure = VERIFY_ERROR_ACCESS_CLASS; 1798 return NULL; 1799 } 1800 1801 return resClass; 1802 } 1803 1804 /* 1805 * Alternate version of dvmResolveInstField(). 1806 * 1807 * On failure, returns NULL, and sets *pFailure if pFailure is not NULL. 1808 */ 1809 InstField* dvmOptResolveInstField(ClassObject* referrer, u4 ifieldIdx, 1810 VerifyError* pFailure) 1811 { 1812 DvmDex* pDvmDex = referrer->pDvmDex; 1813 InstField* resField; 1814 1815 resField = (InstField*) dvmDexGetResolvedField(pDvmDex, ifieldIdx); 1816 if (resField == NULL) { 1817 const DexFieldId* pFieldId; 1818 ClassObject* resClass; 1819 1820 pFieldId = dexGetFieldId(pDvmDex->pDexFile, ifieldIdx); 1821 1822 /* 1823 * Find the field's class. 1824 */ 1825 resClass = dvmOptResolveClass(referrer, pFieldId->classIdx, pFailure); 1826 if (resClass == NULL) { 1827 //dvmClearOptException(dvmThreadSelf()); 1828 assert(!dvmCheckException(dvmThreadSelf())); 1829 if (pFailure != NULL) { assert(!VERIFY_OK(*pFailure)); } 1830 return NULL; 1831 } 1832 1833 resField = (InstField*)dvmFindFieldHier(resClass, 1834 dexStringById(pDvmDex->pDexFile, pFieldId->nameIdx), 1835 dexStringByTypeIdx(pDvmDex->pDexFile, pFieldId->typeIdx)); 1836 if (resField == NULL) { 1837 LOGD("DexOpt: couldn't find field %s.%s\n", 1838 resClass->descriptor, 1839 dexStringById(pDvmDex->pDexFile, pFieldId->nameIdx)); 1840 if (pFailure != NULL) 1841 *pFailure = VERIFY_ERROR_NO_FIELD; 1842 return NULL; 1843 } 1844 if (dvmIsStaticField(&resField->field)) { 1845 LOGD("DexOpt: wanted instance, got static for field %s.%s\n", 1846 resClass->descriptor, 1847 dexStringById(pDvmDex->pDexFile, pFieldId->nameIdx)); 1848 if (pFailure != NULL) 1849 *pFailure = VERIFY_ERROR_CLASS_CHANGE; 1850 return NULL; 1851 } 1852 1853 /* 1854 * Add it to the resolved table so we're faster on the next lookup. 1855 */ 1856 dvmDexSetResolvedField(pDvmDex, ifieldIdx, (Field*) resField); 1857 } 1858 1859 /* access allowed? */ 1860 tweakLoader(referrer, resField->field.clazz); 1861 bool allowed = dvmCheckFieldAccess(referrer, (Field*)resField); 1862 untweakLoader(referrer, resField->field.clazz); 1863 if (!allowed) { 1864 LOGI("DexOpt: access denied from %s to field %s.%s\n", 1865 referrer->descriptor, resField->field.clazz->descriptor, 1866 resField->field.name); 1867 if (pFailure != NULL) 1868 *pFailure = VERIFY_ERROR_ACCESS_FIELD; 1869 return NULL; 1870 } 1871 1872 return resField; 1873 } 1874 1875 /* 1876 * Alternate version of dvmResolveStaticField(). 1877 * 1878 * Does not force initialization of the resolved field's class. 1879 * 1880 * On failure, returns NULL, and sets *pFailure if pFailure is not NULL. 1881 */ 1882 StaticField* dvmOptResolveStaticField(ClassObject* referrer, u4 sfieldIdx, 1883 VerifyError* pFailure) 1884 { 1885 DvmDex* pDvmDex = referrer->pDvmDex; 1886 StaticField* resField; 1887 1888 resField = (StaticField*)dvmDexGetResolvedField(pDvmDex, sfieldIdx); 1889 if (resField == NULL) { 1890 const DexFieldId* pFieldId; 1891 ClassObject* resClass; 1892 1893 pFieldId = dexGetFieldId(pDvmDex->pDexFile, sfieldIdx); 1894 1895 /* 1896 * Find the field's class. 1897 */ 1898 resClass = dvmOptResolveClass(referrer, pFieldId->classIdx, pFailure); 1899 if (resClass == NULL) { 1900 //dvmClearOptException(dvmThreadSelf()); 1901 assert(!dvmCheckException(dvmThreadSelf())); 1902 if (pFailure != NULL) { assert(!VERIFY_OK(*pFailure)); } 1903 return NULL; 1904 } 1905 1906 resField = (StaticField*)dvmFindFieldHier(resClass, 1907 dexStringById(pDvmDex->pDexFile, pFieldId->nameIdx), 1908 dexStringByTypeIdx(pDvmDex->pDexFile, pFieldId->typeIdx)); 1909 if (resField == NULL) { 1910 LOGD("DexOpt: couldn't find static field\n"); 1911 if (pFailure != NULL) 1912 *pFailure = VERIFY_ERROR_NO_FIELD; 1913 return NULL; 1914 } 1915 if (!dvmIsStaticField(&resField->field)) { 1916 LOGD("DexOpt: wanted static, got instance for field %s.%s\n", 1917 resClass->descriptor, 1918 dexStringById(pDvmDex->pDexFile, pFieldId->nameIdx)); 1919 if (pFailure != NULL) 1920 *pFailure = VERIFY_ERROR_CLASS_CHANGE; 1921 return NULL; 1922 } 1923 1924 /* 1925 * Add it to the resolved table so we're faster on the next lookup. 1926 * 1927 * We can only do this if we're in "dexopt", because the presence 1928 * of a valid value in the resolution table implies that the class 1929 * containing the static field has been initialized. 1930 */ 1931 if (gDvm.optimizing) 1932 dvmDexSetResolvedField(pDvmDex, sfieldIdx, (Field*) resField); 1933 } 1934 1935 /* access allowed? */ 1936 tweakLoader(referrer, resField->field.clazz); 1937 bool allowed = dvmCheckFieldAccess(referrer, (Field*)resField); 1938 untweakLoader(referrer, resField->field.clazz); 1939 if (!allowed) { 1940 LOGI("DexOpt: access denied from %s to field %s.%s\n", 1941 referrer->descriptor, resField->field.clazz->descriptor, 1942 resField->field.name); 1943 if (pFailure != NULL) 1944 *pFailure = VERIFY_ERROR_ACCESS_FIELD; 1945 return NULL; 1946 } 1947 1948 return resField; 1949 } 1950 1951 1952 /* 1953 * Rewrite an iget/iput instruction. These all have the form: 1954 * op vA, vB, field@CCCC 1955 * 1956 * Where vA holds the value, vB holds the object reference, and CCCC is 1957 * the field reference constant pool offset. We want to replace CCCC 1958 * with the byte offset from the start of the object. 1959 * 1960 * "clazz" is the referring class. We need this because we verify 1961 * access rights here. 1962 */ 1963 static void rewriteInstField(Method* method, u2* insns, OpCode newOpc) 1964 { 1965 ClassObject* clazz = method->clazz; 1966 u2 fieldIdx = insns[1]; 1967 InstField* field; 1968 int byteOffset; 1969 1970 field = dvmOptResolveInstField(clazz, fieldIdx, NULL); 1971 if (field == NULL) { 1972 LOGI("DexOpt: unable to optimize field ref 0x%04x at 0x%02x in %s.%s\n", 1973 fieldIdx, (int) (insns - method->insns), clazz->descriptor, 1974 method->name); 1975 return; 1976 } 1977 1978 if (field->byteOffset >= 65536) { 1979 LOGI("DexOpt: field offset exceeds 64K (%d)\n", field->byteOffset); 1980 return; 1981 } 1982 1983 insns[0] = (insns[0] & 0xff00) | (u2) newOpc; 1984 insns[1] = (u2) field->byteOffset; 1985 LOGVV("DexOpt: rewrote access to %s.%s --> %d\n", 1986 field->field.clazz->descriptor, field->field.name, 1987 field->byteOffset); 1988 } 1989 1990 /* 1991 * Alternate version of dvmResolveMethod(). 1992 * 1993 * Doesn't throw exceptions, and checks access on every lookup. 1994 * 1995 * On failure, returns NULL, and sets *pFailure if pFailure is not NULL. 1996 */ 1997 Method* dvmOptResolveMethod(ClassObject* referrer, u4 methodIdx, 1998 MethodType methodType, VerifyError* pFailure) 1999 { 2000 DvmDex* pDvmDex = referrer->pDvmDex; 2001 Method* resMethod; 2002 2003 assert(methodType == METHOD_DIRECT || 2004 methodType == METHOD_VIRTUAL || 2005 methodType == METHOD_STATIC); 2006 2007 LOGVV("--- resolving method %u (referrer=%s)\n", methodIdx, 2008 referrer->descriptor); 2009 2010 resMethod = dvmDexGetResolvedMethod(pDvmDex, methodIdx); 2011 if (resMethod == NULL) { 2012 const DexMethodId* pMethodId; 2013 ClassObject* resClass; 2014 2015 pMethodId = dexGetMethodId(pDvmDex->pDexFile, methodIdx); 2016 2017 resClass = dvmOptResolveClass(referrer, pMethodId->classIdx, pFailure); 2018 if (resClass == NULL) { 2019 /* 2020 * Can't find the class that the method is a part of, or don't 2021 * have permission to access the class. 2022 */ 2023 LOGV("DexOpt: can't find called method's class (?.%s)\n", 2024 dexStringById(pDvmDex->pDexFile, pMethodId->nameIdx)); 2025 if (pFailure != NULL) { assert(!VERIFY_OK(*pFailure)); } 2026 return NULL; 2027 } 2028 if (dvmIsInterfaceClass(resClass)) { 2029 /* method is part of an interface; this is wrong method for that */ 2030 LOGW("DexOpt: method is in an interface\n"); 2031 if (pFailure != NULL) 2032 *pFailure = VERIFY_ERROR_GENERIC; 2033 return NULL; 2034 } 2035 2036 /* 2037 * We need to chase up the class hierarchy to find methods defined 2038 * in super-classes. (We only want to check the current class 2039 * if we're looking for a constructor.) 2040 */ 2041 DexProto proto; 2042 dexProtoSetFromMethodId(&proto, pDvmDex->pDexFile, pMethodId); 2043 2044 if (methodType == METHOD_DIRECT) { 2045 resMethod = dvmFindDirectMethod(resClass, 2046 dexStringById(pDvmDex->pDexFile, pMethodId->nameIdx), &proto); 2047 } else { 2048 /* METHOD_STATIC or METHOD_VIRTUAL */ 2049 resMethod = dvmFindMethodHier(resClass, 2050 dexStringById(pDvmDex->pDexFile, pMethodId->nameIdx), &proto); 2051 } 2052 2053 if (resMethod == NULL) { 2054 LOGV("DexOpt: couldn't find method '%s'\n", 2055 dexStringById(pDvmDex->pDexFile, pMethodId->nameIdx)); 2056 if (pFailure != NULL) 2057 *pFailure = VERIFY_ERROR_NO_METHOD; 2058 return NULL; 2059 } 2060 if (methodType == METHOD_STATIC) { 2061 if (!dvmIsStaticMethod(resMethod)) { 2062 LOGD("DexOpt: wanted static, got instance for method %s.%s\n", 2063 resClass->descriptor, resMethod->name); 2064 if (pFailure != NULL) 2065 *pFailure = VERIFY_ERROR_CLASS_CHANGE; 2066 return NULL; 2067 } 2068 } else if (methodType == METHOD_VIRTUAL) { 2069 if (dvmIsStaticMethod(resMethod)) { 2070 LOGD("DexOpt: wanted instance, got static for method %s.%s\n", 2071 resClass->descriptor, resMethod->name); 2072 if (pFailure != NULL) 2073 *pFailure = VERIFY_ERROR_CLASS_CHANGE; 2074 return NULL; 2075 } 2076 } 2077 2078 /* see if this is a pure-abstract method */ 2079 if (dvmIsAbstractMethod(resMethod) && !dvmIsAbstractClass(resClass)) { 2080 LOGW("DexOpt: pure-abstract method '%s' in %s\n", 2081 dexStringById(pDvmDex->pDexFile, pMethodId->nameIdx), 2082 resClass->descriptor); 2083 if (pFailure != NULL) 2084 *pFailure = VERIFY_ERROR_GENERIC; 2085 return NULL; 2086 } 2087 2088 /* 2089 * Add it to the resolved table so we're faster on the next lookup. 2090 * 2091 * We can only do this for static methods if we're not in "dexopt", 2092 * because the presence of a valid value in the resolution table 2093 * implies that the class containing the static field has been 2094 * initialized. 2095 */ 2096 if (methodType != METHOD_STATIC || gDvm.optimizing) 2097 dvmDexSetResolvedMethod(pDvmDex, methodIdx, resMethod); 2098 } 2099 2100 LOGVV("--- found method %d (%s.%s)\n", 2101 methodIdx, resMethod->clazz->descriptor, resMethod->name); 2102 2103 /* access allowed? */ 2104 tweakLoader(referrer, resMethod->clazz); 2105 bool allowed = dvmCheckMethodAccess(referrer, resMethod); 2106 untweakLoader(referrer, resMethod->clazz); 2107 if (!allowed) { 2108 IF_LOGI() { 2109 char* desc = dexProtoCopyMethodDescriptor(&resMethod->prototype); 2110 LOGI("DexOpt: illegal method access (call %s.%s %s from %s)\n", 2111 resMethod->clazz->descriptor, resMethod->name, desc, 2112 referrer->descriptor); 2113 free(desc); 2114 } 2115 if (pFailure != NULL) 2116 *pFailure = VERIFY_ERROR_ACCESS_METHOD; 2117 return NULL; 2118 } 2119 2120 return resMethod; 2121 } 2122 2123 /* 2124 * Rewrite invoke-virtual, invoke-virtual/range, invoke-super, and 2125 * invoke-super/range. These all have the form: 2126 * op vAA, meth@BBBB, reg stuff @CCCC 2127 * 2128 * We want to replace the method constant pool index BBBB with the 2129 * vtable index. 2130 */ 2131 static bool rewriteVirtualInvoke(Method* method, u2* insns, OpCode newOpc) 2132 { 2133 ClassObject* clazz = method->clazz; 2134 Method* baseMethod; 2135 u2 methodIdx = insns[1]; 2136 2137 baseMethod = dvmOptResolveMethod(clazz, methodIdx, METHOD_VIRTUAL, NULL); 2138 if (baseMethod == NULL) { 2139 LOGD("DexOpt: unable to optimize virt call 0x%04x at 0x%02x in %s.%s\n", 2140 methodIdx, 2141 (int) (insns - method->insns), clazz->descriptor, 2142 method->name); 2143 return false; 2144 } 2145 2146 assert((insns[0] & 0xff) == OP_INVOKE_VIRTUAL || 2147 (insns[0] & 0xff) == OP_INVOKE_VIRTUAL_RANGE || 2148 (insns[0] & 0xff) == OP_INVOKE_SUPER || 2149 (insns[0] & 0xff) == OP_INVOKE_SUPER_RANGE); 2150 2151 /* 2152 * Note: Method->methodIndex is a u2 and is range checked during the 2153 * initial load. 2154 */ 2155 insns[0] = (insns[0] & 0xff00) | (u2) newOpc; 2156 insns[1] = baseMethod->methodIndex; 2157 2158 //LOGI("DexOpt: rewrote call to %s.%s --> %s.%s\n", 2159 // method->clazz->descriptor, method->name, 2160 // baseMethod->clazz->descriptor, baseMethod->name); 2161 2162 return true; 2163 } 2164 2165 /* 2166 * Rewrite invoke-direct, which has the form: 2167 * op vAA, meth@BBBB, reg stuff @CCCC 2168 * 2169 * There isn't a lot we can do to make this faster, but in some situations 2170 * we can make it go away entirely. 2171 * 2172 * This must only be used when the invoked method does nothing and has 2173 * no return value (the latter being very important for verification). 2174 */ 2175 static bool rewriteEmptyDirectInvoke(Method* method, u2* insns) 2176 { 2177 ClassObject* clazz = method->clazz; 2178 Method* calledMethod; 2179 u2 methodIdx = insns[1]; 2180 2181 calledMethod = dvmOptResolveMethod(clazz, methodIdx, METHOD_DIRECT, NULL); 2182 if (calledMethod == NULL) { 2183 LOGD("DexOpt: unable to opt direct call 0x%04x at 0x%02x in %s.%s\n", 2184 methodIdx, 2185 (int) (insns - method->insns), clazz->descriptor, 2186 method->name); 2187 return false; 2188 } 2189 2190 /* TODO: verify that java.lang.Object() is actually empty! */ 2191 if (calledMethod->clazz == gDvm.classJavaLangObject && 2192 dvmCompareNameDescriptorAndMethod("<init>", "()V", calledMethod) == 0) 2193 { 2194 /* 2195 * Replace with "empty" instruction. DO NOT disturb anything 2196 * else about it, as we want it to function the same as 2197 * OP_INVOKE_DIRECT when debugging is enabled. 2198 */ 2199 assert((insns[0] & 0xff) == OP_INVOKE_DIRECT); 2200 insns[0] = (insns[0] & 0xff00) | (u2) OP_INVOKE_DIRECT_EMPTY; 2201 2202 //LOGI("DexOpt: marked-empty call to %s.%s --> %s.%s\n", 2203 // method->clazz->descriptor, method->name, 2204 // calledMethod->clazz->descriptor, calledMethod->name); 2205 } 2206 2207 return true; 2208 } 2209 2210 /* 2211 * Resolve an interface method reference. 2212 * 2213 * No method access check here -- interface methods are always public. 2214 * 2215 * Returns NULL if the method was not found. Does not throw an exception. 2216 */ 2217 Method* dvmOptResolveInterfaceMethod(ClassObject* referrer, u4 methodIdx) 2218 { 2219 DvmDex* pDvmDex = referrer->pDvmDex; 2220 Method* resMethod; 2221 int i; 2222 2223 LOGVV("--- resolving interface method %d (referrer=%s)\n", 2224 methodIdx, referrer->descriptor); 2225 2226 resMethod = dvmDexGetResolvedMethod(pDvmDex, methodIdx); 2227 if (resMethod == NULL) { 2228 const DexMethodId* pMethodId; 2229 ClassObject* resClass; 2230 2231 pMethodId = dexGetMethodId(pDvmDex->pDexFile, methodIdx); 2232 2233 resClass = dvmOptResolveClass(referrer, pMethodId->classIdx, NULL); 2234 if (resClass == NULL) { 2235 /* can't find the class that the method is a part of */ 2236 dvmClearOptException(dvmThreadSelf()); 2237 return NULL; 2238 } 2239 if (!dvmIsInterfaceClass(resClass)) { 2240 /* whoops */ 2241 LOGI("Interface method not part of interface class\n"); 2242 return NULL; 2243 } 2244 2245 const char* methodName = 2246 dexStringById(pDvmDex->pDexFile, pMethodId->nameIdx); 2247 DexProto proto; 2248 dexProtoSetFromMethodId(&proto, pDvmDex->pDexFile, pMethodId); 2249 2250 LOGVV("+++ looking for '%s' '%s' in resClass='%s'\n", 2251 methodName, methodSig, resClass->descriptor); 2252 resMethod = dvmFindVirtualMethod(resClass, methodName, &proto); 2253 if (resMethod == NULL) { 2254 /* scan superinterfaces and superclass interfaces */ 2255 LOGVV("+++ did not resolve immediately\n"); 2256 for (i = 0; i < resClass->iftableCount; i++) { 2257 resMethod = dvmFindVirtualMethod(resClass->iftable[i].clazz, 2258 methodName, &proto); 2259 if (resMethod != NULL) 2260 break; 2261 } 2262 2263 if (resMethod == NULL) { 2264 LOGVV("+++ unable to resolve method %s\n", methodName); 2265 return NULL; 2266 } 2267 } else { 2268 LOGVV("+++ resolved immediately: %s (%s %d)\n", resMethod->name, 2269 resMethod->clazz->descriptor, (u4) resMethod->methodIndex); 2270 } 2271 2272 /* we're expecting this to be abstract */ 2273 if (!dvmIsAbstractMethod(resMethod)) { 2274 char* desc = dexProtoCopyMethodDescriptor(&resMethod->prototype); 2275 LOGW("Found non-abstract interface method %s.%s %s\n", 2276 resMethod->clazz->descriptor, resMethod->name, desc); 2277 free(desc); 2278 return NULL; 2279 } 2280 2281 /* 2282 * Add it to the resolved table so we're faster on the next lookup. 2283 */ 2284 dvmDexSetResolvedMethod(pDvmDex, methodIdx, resMethod); 2285 } 2286 2287 LOGVV("--- found interface method %d (%s.%s)\n", 2288 methodIdx, resMethod->clazz->descriptor, resMethod->name); 2289 2290 /* interface methods are always public; no need to check access */ 2291 2292 return resMethod; 2293 } 2294 2295 /* 2296 * See if the method being called can be rewritten as an inline operation. 2297 * Works for invoke-virtual, invoke-direct, and invoke-static. 2298 * 2299 * Returns "true" if we replace it. 2300 */ 2301 static bool rewriteExecuteInline(Method* method, u2* insns, 2302 MethodType methodType, const InlineSub* inlineSubs) 2303 { 2304 ClassObject* clazz = method->clazz; 2305 Method* calledMethod; 2306 u2 methodIdx = insns[1]; 2307 2308 //return false; 2309 2310 calledMethod = dvmOptResolveMethod(clazz, methodIdx, methodType, NULL); 2311 if (calledMethod == NULL) { 2312 LOGV("+++ DexOpt inline: can't find %d\n", methodIdx); 2313 return false; 2314 } 2315 2316 while (inlineSubs->method != NULL) { 2317 /* 2318 if (extra) { 2319 LOGI("comparing %p vs %p %s.%s %s\n", 2320 inlineSubs->method, calledMethod, 2321 inlineSubs->method->clazz->descriptor, 2322 inlineSubs->method->name, 2323 inlineSubs->method->signature); 2324 } 2325 */ 2326 if (inlineSubs->method == calledMethod) { 2327 assert((insns[0] & 0xff) == OP_INVOKE_DIRECT || 2328 (insns[0] & 0xff) == OP_INVOKE_STATIC || 2329 (insns[0] & 0xff) == OP_INVOKE_VIRTUAL); 2330 insns[0] = (insns[0] & 0xff00) | (u2) OP_EXECUTE_INLINE; 2331 insns[1] = (u2) inlineSubs->inlineIdx; 2332 2333 //LOGI("DexOpt: execute-inline %s.%s --> %s.%s\n", 2334 // method->clazz->descriptor, method->name, 2335 // calledMethod->clazz->descriptor, calledMethod->name); 2336 return true; 2337 } 2338 2339 inlineSubs++; 2340 } 2341 2342 return false; 2343 } 2344 2345 /* 2346 * See if the method being called can be rewritten as an inline operation. 2347 * Works for invoke-virtual/range, invoke-direct/range, and invoke-static/range. 2348 * 2349 * Returns "true" if we replace it. 2350 */ 2351 static bool rewriteExecuteInlineRange(Method* method, u2* insns, 2352 MethodType methodType, const InlineSub* inlineSubs) 2353 { 2354 ClassObject* clazz = method->clazz; 2355 Method* calledMethod; 2356 u2 methodIdx = insns[1]; 2357 2358 calledMethod = dvmOptResolveMethod(clazz, methodIdx, methodType, NULL); 2359 if (calledMethod == NULL) { 2360 LOGV("+++ DexOpt inline/range: can't find %d\n", methodIdx); 2361 return false; 2362 } 2363 2364 while (inlineSubs->method != NULL) { 2365 if (inlineSubs->method == calledMethod) { 2366 assert((insns[0] & 0xff) == OP_INVOKE_DIRECT_RANGE || 2367 (insns[0] & 0xff) == OP_INVOKE_STATIC_RANGE || 2368 (insns[0] & 0xff) == OP_INVOKE_VIRTUAL_RANGE); 2369 insns[0] = (insns[0] & 0xff00) | (u2) OP_EXECUTE_INLINE_RANGE; 2370 insns[1] = (u2) inlineSubs->inlineIdx; 2371 2372 //LOGI("DexOpt: execute-inline/range %s.%s --> %s.%s\n", 2373 // method->clazz->descriptor, method->name, 2374 // calledMethod->clazz->descriptor, calledMethod->name); 2375 return true; 2376 } 2377 2378 inlineSubs++; 2379 } 2380 2381 return false; 2382 } 2383 2384
