Exception.cpp revision 8552f4498a720a6fcb34ebab69d6e3c34bee491d
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 * Exception handling. 18 */ 19#include "Dalvik.h" 20#include "libdex/DexCatch.h" 21 22#include <stdlib.h> 23 24/* 25Notes on Exception Handling 26 27We have one fairly sticky issue to deal with: creating the exception stack 28trace. The trouble is that we need the current value of the program 29counter for the method now being executed, but that's only held in a local 30variable or hardware register in the main interpreter loop. 31 32The exception mechanism requires that the current stack trace be associated 33with a Throwable at the time the Throwable is constructed. The construction 34may or may not be associated with a throw. We have three situations to 35consider: 36 37 (1) A Throwable is created with a "new Throwable" statement in the 38 application code, for immediate or deferred use with a "throw" statement. 39 (2) The VM throws an exception from within the interpreter core, e.g. 40 after an integer divide-by-zero. 41 (3) The VM throws an exception from somewhere deeper down, e.g. while 42 trying to link a class. 43 44We need to have the current value for the PC, which means that for 45situation (3) the interpreter loop must copy it to an externally-accessible 46location before handling any opcode that could cause the VM to throw 47an exception. We can't store it globally, because the various threads 48would trample each other. We can't store it in the Thread structure, 49because it'll get overwritten as soon as the Throwable constructor starts 50executing. It needs to go on the stack, but our stack frames hold the 51caller's *saved* PC, not the current PC. 52 53Situation #1 doesn't require special handling. Situation #2 could be dealt 54with by passing the PC into the exception creation function. The trick 55is to solve situation #3 in a way that adds minimal overhead to common 56operations. Making it more costly to throw an exception is acceptable. 57 58There are a few ways to deal with this: 59 60 (a) Change "savedPc" to "currentPc" in the stack frame. All of the 61 stack logic gets offset by one frame. The current PC is written 62 to the current stack frame when necessary. 63 (b) Write the current PC into the current stack frame, but without 64 replacing "savedPc". The JNI local refs pointer, which is only 65 used for native code, can be overloaded to save space. 66 (c) In dvmThrowException(), push an extra stack frame on, with the 67 current PC in it. The current PC is written into the Thread struct 68 when necessary, and copied out when the VM throws. 69 (d) Before doing something that might throw an exception, push a 70 temporary frame on with the saved PC in it. 71 72Solution (a) is the simplest, but breaks Dalvik's goal of mingling native 73and interpreted stacks. 74 75Solution (b) retains the simplicity of (a) without rearranging the stack, 76but now in some cases we're storing the PC twice, which feels wrong. 77 78Solution (c) usually works, because we push the saved PC onto the stack 79before the Throwable construction can overwrite the copy in Thread. One 80way solution (c) could break is: 81 - Interpreter saves the PC 82 - Execute some bytecode, which runs successfully (and alters the saved PC) 83 - Throw an exception before re-saving the PC (i.e in the same opcode) 84This is a risk for anything that could cause <clinit> to execute, e.g. 85executing a static method or accessing a static field. Attemping to access 86a field that doesn't exist in a class that does exist might cause this. 87It may be possible to simply bracket the dvmCallMethod*() functions to 88save/restore it. 89 90Solution (d) incurs additional overhead, but may have other benefits (e.g. 91it's easy to find the stack frames that should be removed before storage 92in the Throwable). 93 94Current plan is option (b), because it's simple, fast, and doesn't change 95the way the stack works. 96*/ 97 98/* fwd */ 99static bool initException(Object* exception, const char* msg, Object* cause, 100 Thread* self); 101 102 103/* 104 * Cache pointers to some of the exception classes we use locally. 105 * 106 * Note this is NOT called during dexopt optimization. Some of the fields 107 * are initialized by the verifier (dvmVerifyCodeFlow). 108 */ 109bool dvmExceptionStartup(void) 110{ 111 gDvm.classJavaLangThrowable = 112 dvmFindSystemClassNoInit("Ljava/lang/Throwable;"); 113 gDvm.classJavaLangRuntimeException = 114 dvmFindSystemClassNoInit("Ljava/lang/RuntimeException;"); 115 gDvm.classJavaLangStackOverflowError = 116 dvmFindSystemClassNoInit("Ljava/lang/StackOverflowError;"); 117 gDvm.classJavaLangError = 118 dvmFindSystemClassNoInit("Ljava/lang/Error;"); 119 gDvm.classJavaLangStackTraceElement = 120 dvmFindSystemClassNoInit("Ljava/lang/StackTraceElement;"); 121 gDvm.classJavaLangStackTraceElementArray = 122 dvmFindArrayClass("[Ljava/lang/StackTraceElement;", NULL); 123 if (gDvm.classJavaLangThrowable == NULL || 124 gDvm.classJavaLangStackTraceElement == NULL || 125 gDvm.classJavaLangStackTraceElementArray == NULL) 126 { 127 LOGE("Could not find one or more essential exception classes\n"); 128 return false; 129 } 130 131 /* 132 * Find the constructor. Note that, unlike other saved method lookups, 133 * we're using a Method* instead of a vtable offset. This is because 134 * constructors don't have vtable offsets. (Also, since we're creating 135 * the object in question, it's impossible for anyone to sub-class it.) 136 */ 137 Method* meth; 138 meth = dvmFindDirectMethodByDescriptor(gDvm.classJavaLangStackTraceElement, 139 "<init>", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;I)V"); 140 if (meth == NULL) { 141 LOGE("Unable to find constructor for StackTraceElement\n"); 142 return false; 143 } 144 gDvm.methJavaLangStackTraceElement_init = meth; 145 146 /* grab an offset for the stackData field */ 147 gDvm.offJavaLangThrowable_stackState = 148 dvmFindFieldOffset(gDvm.classJavaLangThrowable, 149 "stackState", "Ljava/lang/Object;"); 150 if (gDvm.offJavaLangThrowable_stackState < 0) { 151 LOGE("Unable to find Throwable.stackState\n"); 152 return false; 153 } 154 155 /* and one for the cause field, just 'cause */ 156 gDvm.offJavaLangThrowable_cause = 157 dvmFindFieldOffset(gDvm.classJavaLangThrowable, 158 "cause", "Ljava/lang/Throwable;"); 159 if (gDvm.offJavaLangThrowable_cause < 0) { 160 LOGE("Unable to find Throwable.cause\n"); 161 return false; 162 } 163 164 return true; 165} 166 167/* 168 * Clean up. 169 */ 170void dvmExceptionShutdown(void) 171{ 172 // nothing to do 173} 174 175 176/* 177 * Format the message into a small buffer and pass it along. 178 */ 179void dvmThrowExceptionFmtV(const char* exceptionDescriptor, const char* fmt, 180 va_list args) 181{ 182 char msgBuf[512]; 183 184 vsnprintf(msgBuf, sizeof(msgBuf), fmt, args); 185 dvmThrowChainedException(exceptionDescriptor, msgBuf, NULL); 186} 187 188/* 189 * Create a Throwable and throw an exception in the current thread (where 190 * "throwing" just means "set the thread's exception pointer"). 191 * 192 * "msg" and/or "cause" may be NULL. 193 * 194 * If we have a bad exception hierarchy -- something in Throwable.<init> 195 * is missing -- then every attempt to throw an exception will result 196 * in another exception. Exceptions are generally allowed to "chain" 197 * to other exceptions, so it's hard to auto-detect this problem. It can 198 * only happen if the system classes are broken, so it's probably not 199 * worth spending cycles to detect it. 200 * 201 * We do have one case to worry about: if the classpath is completely 202 * wrong, we'll go into a death spin during startup because we can't find 203 * the initial class and then we can't find NoClassDefFoundError. We have 204 * to handle this case. 205 * 206 * [Do we want to cache pointers to common exception classes?] 207 */ 208void dvmThrowChainedException(const char* exceptionDescriptor, const char* msg, 209 Object* cause) 210{ 211 ClassObject* excepClass; 212 213 LOGV("THROW '%s' msg='%s' cause=%s\n", 214 exceptionDescriptor, msg, 215 (cause != NULL) ? cause->clazz->descriptor : "(none)"); 216 217 if (gDvm.initializing) { 218 if (++gDvm.initExceptionCount >= 2) { 219 LOGE("Too many exceptions during init (failed on '%s' '%s')\n", 220 exceptionDescriptor, msg); 221 dvmAbort(); 222 } 223 } 224 225 excepClass = dvmFindSystemClass(exceptionDescriptor); 226 if (excepClass == NULL) { 227 /* 228 * We couldn't find the exception class. The attempt to find a 229 * nonexistent class should have raised an exception. If no 230 * exception is currently raised, then we're pretty clearly unable 231 * to throw ANY sort of exception, and we need to pack it in. 232 * 233 * If we were able to throw the "class load failed" exception, 234 * stick with that. Ideally we'd stuff the original exception 235 * into the "cause" field, but since we can't find it we can't 236 * do that. The exception class name should be in the "message" 237 * field. 238 */ 239 if (!dvmCheckException(dvmThreadSelf())) { 240 LOGE("FATAL: unable to throw exception (failed on '%s' '%s')\n", 241 exceptionDescriptor, msg); 242 dvmAbort(); 243 } 244 return; 245 } 246 247 dvmThrowChainedExceptionByClass(excepClass, msg, cause); 248} 249 250/* 251 * Start/continue throwing process now that we have a class reference. 252 */ 253void dvmThrowChainedExceptionByClass(ClassObject* excepClass, const char* msg, 254 Object* cause) 255{ 256 Thread* self = dvmThreadSelf(); 257 Object* exception; 258 259 /* make sure the exception is initialized */ 260 if (!dvmIsClassInitialized(excepClass) && !dvmInitClass(excepClass)) { 261 LOGE("ERROR: unable to initialize exception class '%s'\n", 262 excepClass->descriptor); 263 if (strcmp(excepClass->descriptor, "Ljava/lang/InternalError;") == 0) 264 dvmAbort(); 265 dvmThrowChainedException("Ljava/lang/InternalError;", 266 "failed to init original exception class", cause); 267 return; 268 } 269 270 exception = dvmAllocObject(excepClass, ALLOC_DEFAULT); 271 if (exception == NULL) { 272 /* 273 * We're in a lot of trouble. We might be in the process of 274 * throwing an out-of-memory exception, in which case the 275 * pre-allocated object will have been thrown when our object alloc 276 * failed. So long as there's an exception raised, return and 277 * allow the system to try to recover. If not, something is broken 278 * and we need to bail out. 279 */ 280 if (dvmCheckException(self)) 281 goto bail; 282 LOGE("FATAL: unable to allocate exception '%s' '%s'\n", 283 excepClass->descriptor, msg != NULL ? msg : "(no msg)"); 284 dvmAbort(); 285 } 286 287 /* 288 * Init the exception. 289 */ 290 if (gDvm.optimizing) { 291 /* need the exception object, but can't invoke interpreted code */ 292 LOGV("Skipping init of exception %s '%s'\n", 293 excepClass->descriptor, msg); 294 } else { 295 assert(excepClass == exception->clazz); 296 if (!initException(exception, msg, cause, self)) { 297 /* 298 * Whoops. If we can't initialize the exception, we can't use 299 * it. If there's an exception already set, the constructor 300 * probably threw an OutOfMemoryError. 301 */ 302 if (!dvmCheckException(self)) { 303 /* 304 * We're required to throw something, so we just 305 * throw the pre-constructed internal error. 306 */ 307 self->exception = gDvm.internalErrorObj; 308 } 309 goto bail; 310 } 311 } 312 313 self->exception = exception; 314 315bail: 316 dvmReleaseTrackedAlloc(exception, self); 317} 318 319/* 320 * Throw the named exception using the dotted form of the class 321 * descriptor as the exception message, and with the specified cause. 322 */ 323void dvmThrowChainedExceptionWithClassMessage(const char* exceptionDescriptor, 324 const char* messageDescriptor, Object* cause) 325{ 326 char* message = dvmDescriptorToDot(messageDescriptor); 327 328 dvmThrowChainedException(exceptionDescriptor, message, cause); 329 free(message); 330} 331 332/* 333 * Like dvmThrowExceptionWithMessageFromDescriptor, but take a 334 * class object instead of a name. 335 */ 336void dvmThrowExceptionByClassWithClassMessage(ClassObject* exceptionClass, 337 const char* messageDescriptor) 338{ 339 char* message = dvmDescriptorToName(messageDescriptor); 340 341 dvmThrowExceptionByClass(exceptionClass, message); 342 free(message); 343} 344 345/* 346 * Find and return an exception constructor method that can take the 347 * indicated parameters, or return NULL if no such constructor exists. 348 */ 349static Method* findExceptionInitMethod(ClassObject* excepClass, 350 bool hasMessage, bool hasCause) 351{ 352 if (hasMessage) { 353 Method* result; 354 355 if (hasCause) { 356 result = dvmFindDirectMethodByDescriptor( 357 excepClass, "<init>", 358 "(Ljava/lang/String;Ljava/lang/Throwable;)V"); 359 } else { 360 result = dvmFindDirectMethodByDescriptor( 361 excepClass, "<init>", "(Ljava/lang/String;)V"); 362 } 363 364 if (result != NULL) { 365 return result; 366 } 367 368 if (hasCause) { 369 return dvmFindDirectMethodByDescriptor( 370 excepClass, "<init>", 371 "(Ljava/lang/Object;Ljava/lang/Throwable;)V"); 372 } else { 373 return dvmFindDirectMethodByDescriptor( 374 excepClass, "<init>", "(Ljava/lang/Object;)V"); 375 } 376 } else if (hasCause) { 377 return dvmFindDirectMethodByDescriptor( 378 excepClass, "<init>", "(Ljava/lang/Throwable;)V"); 379 } else { 380 return dvmFindDirectMethodByDescriptor(excepClass, "<init>", "()V"); 381 } 382} 383 384/* 385 * Initialize an exception with an appropriate constructor. 386 * 387 * "exception" is the exception object to initialize. 388 * Either or both of "msg" and "cause" may be null. 389 * "self" is dvmThreadSelf(), passed in so we don't have to look it up again. 390 * 391 * If the process of initializing the exception causes another 392 * exception (e.g., OutOfMemoryError) to be thrown, return an error 393 * and leave self->exception intact. 394 */ 395static bool initException(Object* exception, const char* msg, Object* cause, 396 Thread* self) 397{ 398 enum { 399 kInitUnknown, 400 kInitNoarg, 401 kInitMsg, 402 kInitMsgThrow, 403 kInitThrow 404 } initKind = kInitUnknown; 405 Method* initMethod = NULL; 406 ClassObject* excepClass = exception->clazz; 407 StringObject* msgStr = NULL; 408 bool result = false; 409 bool needInitCause = false; 410 411 assert(self != NULL); 412 assert(self->exception == NULL); 413 414 /* if we have a message, create a String */ 415 if (msg == NULL) 416 msgStr = NULL; 417 else { 418 msgStr = dvmCreateStringFromCstr(msg); 419 if (msgStr == NULL) { 420 LOGW("Could not allocate message string \"%s\" while " 421 "throwing internal exception (%s)\n", 422 msg, excepClass->descriptor); 423 goto bail; 424 } 425 } 426 427 if (cause != NULL) { 428 if (!dvmInstanceof(cause->clazz, gDvm.classJavaLangThrowable)) { 429 LOGE("Tried to init exception with cause '%s'\n", 430 cause->clazz->descriptor); 431 dvmAbort(); 432 } 433 } 434 435 /* 436 * The Throwable class has four public constructors: 437 * (1) Throwable() 438 * (2) Throwable(String message) 439 * (3) Throwable(String message, Throwable cause) (added in 1.4) 440 * (4) Throwable(Throwable cause) (added in 1.4) 441 * 442 * The first two are part of the original design, and most exception 443 * classes should support them. The third prototype was used by 444 * individual exceptions. e.g. ClassNotFoundException added it in 1.2. 445 * The general "cause" mechanism was added in 1.4. Some classes, 446 * such as IllegalArgumentException, initially supported the first 447 * two, but added the second two in a later release. 448 * 449 * Exceptions may be picky about how their "cause" field is initialized. 450 * If you call ClassNotFoundException(String), it may choose to 451 * initialize its "cause" field to null. Doing so prevents future 452 * calls to Throwable.initCause(). 453 * 454 * So, if "cause" is not NULL, we need to look for a constructor that 455 * takes a throwable. If we can't find one, we fall back on calling 456 * #1/#2 and making a separate call to initCause(). Passing a null ref 457 * for "message" into Throwable(String, Throwable) is allowed, but we 458 * prefer to use the Throwable-only version because it has different 459 * behavior. 460 * 461 * java.lang.TypeNotPresentException is a strange case -- it has #3 but 462 * not #2. (Some might argue that the constructor is actually not #3, 463 * because it doesn't take the message string as an argument, but it 464 * has the same effect and we can work with it here.) 465 * 466 * java.lang.AssertionError is also a strange case -- it has a 467 * constructor that takes an Object, but not one that takes a String. 468 * There may be other cases like this, as well, so we generally look 469 * for an Object-taking constructor if we can't find one that takes 470 * a String. 471 */ 472 if (cause == NULL) { 473 if (msgStr == NULL) { 474 initMethod = findExceptionInitMethod(excepClass, false, false); 475 initKind = kInitNoarg; 476 } else { 477 initMethod = findExceptionInitMethod(excepClass, true, false); 478 if (initMethod != NULL) { 479 initKind = kInitMsg; 480 } else { 481 /* no #2, try #3 */ 482 initMethod = findExceptionInitMethod(excepClass, true, true); 483 if (initMethod != NULL) { 484 initKind = kInitMsgThrow; 485 } 486 } 487 } 488 } else { 489 if (msgStr == NULL) { 490 initMethod = findExceptionInitMethod(excepClass, false, true); 491 if (initMethod != NULL) { 492 initKind = kInitThrow; 493 } else { 494 initMethod = findExceptionInitMethod(excepClass, false, false); 495 initKind = kInitNoarg; 496 needInitCause = true; 497 } 498 } else { 499 initMethod = findExceptionInitMethod(excepClass, true, true); 500 if (initMethod != NULL) { 501 initKind = kInitMsgThrow; 502 } else { 503 initMethod = findExceptionInitMethod(excepClass, true, false); 504 initKind = kInitMsg; 505 needInitCause = true; 506 } 507 } 508 } 509 510 if (initMethod == NULL) { 511 /* 512 * We can't find the desired constructor. This can happen if a 513 * subclass of java/lang/Throwable doesn't define an expected 514 * constructor, e.g. it doesn't provide one that takes a string 515 * when a message has been provided. 516 */ 517 LOGW("WARNING: exception class '%s' missing constructor " 518 "(msg='%s' kind=%d)\n", 519 excepClass->descriptor, msg, initKind); 520 assert(strcmp(excepClass->descriptor, 521 "Ljava/lang/RuntimeException;") != 0); 522 dvmThrowChainedException("Ljava/lang/RuntimeException;", 523 "re-throw on exception class missing constructor", NULL); 524 goto bail; 525 } 526 527 /* 528 * Call the constructor with the appropriate arguments. 529 */ 530 JValue unused; 531 switch (initKind) { 532 case kInitNoarg: 533 LOGVV("+++ exc noarg (ic=%d)\n", needInitCause); 534 dvmCallMethod(self, initMethod, exception, &unused); 535 break; 536 case kInitMsg: 537 LOGVV("+++ exc msg (ic=%d)\n", needInitCause); 538 dvmCallMethod(self, initMethod, exception, &unused, msgStr); 539 break; 540 case kInitThrow: 541 LOGVV("+++ exc throw"); 542 assert(!needInitCause); 543 dvmCallMethod(self, initMethod, exception, &unused, cause); 544 break; 545 case kInitMsgThrow: 546 LOGVV("+++ exc msg+throw"); 547 assert(!needInitCause); 548 dvmCallMethod(self, initMethod, exception, &unused, msgStr, cause); 549 break; 550 default: 551 assert(false); 552 goto bail; 553 } 554 555 /* 556 * It's possible the constructor has thrown an exception. If so, we 557 * return an error and let our caller deal with it. 558 */ 559 if (self->exception != NULL) { 560 LOGW("Exception thrown (%s) while throwing internal exception (%s)\n", 561 self->exception->clazz->descriptor, exception->clazz->descriptor); 562 goto bail; 563 } 564 565 /* 566 * If this exception was caused by another exception, and we weren't 567 * able to find a cause-setting constructor, set the "cause" field 568 * with an explicit call. 569 */ 570 if (needInitCause) { 571 Method* initCause; 572 initCause = dvmFindVirtualMethodHierByDescriptor(excepClass, "initCause", 573 "(Ljava/lang/Throwable;)Ljava/lang/Throwable;"); 574 if (initCause != NULL) { 575 dvmCallMethod(self, initCause, exception, &unused, cause); 576 if (self->exception != NULL) { 577 /* initCause() threw an exception; return an error and 578 * let the caller deal with it. 579 */ 580 LOGW("Exception thrown (%s) during initCause() " 581 "of internal exception (%s)\n", 582 self->exception->clazz->descriptor, 583 exception->clazz->descriptor); 584 goto bail; 585 } 586 } else { 587 LOGW("WARNING: couldn't find initCause in '%s'\n", 588 excepClass->descriptor); 589 } 590 } 591 592 593 result = true; 594 595bail: 596 dvmReleaseTrackedAlloc((Object*) msgStr, self); // NULL is ok 597 return result; 598} 599 600 601/* 602 * Clear the pending exception and the "initExceptionCount" counter. This 603 * is used by the optimization and verification code, which has to run with 604 * "initializing" set to avoid going into a death-spin if the "class not 605 * found" exception can't be found. 606 * 607 * This can also be called when the VM is in a "normal" state, e.g. when 608 * verifying classes that couldn't be verified at optimization time. The 609 * reset of initExceptionCount should be harmless in that case. 610 */ 611void dvmClearOptException(Thread* self) 612{ 613 self->exception = NULL; 614 gDvm.initExceptionCount = 0; 615} 616 617/* 618 * Returns "true" if this is a "checked" exception, i.e. it's a subclass 619 * of Throwable (assumed) but not a subclass of RuntimeException or Error. 620 */ 621bool dvmIsCheckedException(const Object* exception) 622{ 623 if (dvmInstanceof(exception->clazz, gDvm.classJavaLangError) || 624 dvmInstanceof(exception->clazz, gDvm.classJavaLangRuntimeException)) 625 { 626 return false; 627 } else { 628 return true; 629 } 630} 631 632/* 633 * Wrap the now-pending exception in a different exception. This is useful 634 * for reflection stuff that wants to hand a checked exception back from a 635 * method that doesn't declare it. 636 * 637 * If something fails, an (unchecked) exception related to that failure 638 * will be pending instead. 639 */ 640void dvmWrapException(const char* newExcepStr) 641{ 642 Thread* self = dvmThreadSelf(); 643 Object* origExcep; 644 ClassObject* iteClass; 645 646 origExcep = dvmGetException(self); 647 dvmAddTrackedAlloc(origExcep, self); // don't let the GC free it 648 649 dvmClearException(self); // clear before class lookup 650 iteClass = dvmFindSystemClass(newExcepStr); 651 if (iteClass != NULL) { 652 Object* iteExcep; 653 Method* initMethod; 654 655 iteExcep = dvmAllocObject(iteClass, ALLOC_DEFAULT); 656 if (iteExcep != NULL) { 657 initMethod = dvmFindDirectMethodByDescriptor(iteClass, "<init>", 658 "(Ljava/lang/Throwable;)V"); 659 if (initMethod != NULL) { 660 JValue unused; 661 dvmCallMethod(self, initMethod, iteExcep, &unused, 662 origExcep); 663 664 /* if <init> succeeded, replace the old exception */ 665 if (!dvmCheckException(self)) 666 dvmSetException(self, iteExcep); 667 } 668 dvmReleaseTrackedAlloc(iteExcep, NULL); 669 670 /* if initMethod doesn't exist, or failed... */ 671 if (!dvmCheckException(self)) 672 dvmSetException(self, origExcep); 673 } else { 674 /* leave OutOfMemoryError pending */ 675 } 676 } else { 677 /* leave ClassNotFoundException pending */ 678 } 679 680 assert(dvmCheckException(self)); 681 dvmReleaseTrackedAlloc(origExcep, self); 682} 683 684/* 685 * Get the "cause" field from an exception. 686 * 687 * The Throwable class initializes the "cause" field to "this" to 688 * differentiate between being initialized to null and never being 689 * initialized. We check for that here and convert it to NULL. 690 */ 691Object* dvmGetExceptionCause(const Object* exception) 692{ 693 if (!dvmInstanceof(exception->clazz, gDvm.classJavaLangThrowable)) { 694 LOGE("Tried to get cause from object of type '%s'\n", 695 exception->clazz->descriptor); 696 dvmAbort(); 697 } 698 Object* cause = 699 dvmGetFieldObject(exception, gDvm.offJavaLangThrowable_cause); 700 if (cause == exception) 701 return NULL; 702 else 703 return cause; 704} 705 706/* 707 * Print the stack trace of the current exception on stderr. This is called 708 * from the JNI ExceptionDescribe call. 709 * 710 * For consistency we just invoke the Throwable printStackTrace method, 711 * which might be overridden in the exception object. 712 * 713 * Exceptions thrown during the course of printing the stack trace are 714 * ignored. 715 */ 716void dvmPrintExceptionStackTrace(void) 717{ 718 Thread* self = dvmThreadSelf(); 719 Object* exception; 720 Method* printMethod; 721 722 exception = self->exception; 723 if (exception == NULL) 724 return; 725 726 self->exception = NULL; 727 printMethod = dvmFindVirtualMethodHierByDescriptor(exception->clazz, 728 "printStackTrace", "()V"); 729 if (printMethod != NULL) { 730 JValue unused; 731 dvmCallMethod(self, printMethod, exception, &unused); 732 } else { 733 LOGW("WARNING: could not find printStackTrace in %s\n", 734 exception->clazz->descriptor); 735 } 736 737 if (self->exception != NULL) { 738 LOGW("NOTE: exception thrown while printing stack trace: %s\n", 739 self->exception->clazz->descriptor); 740 } 741 742 self->exception = exception; 743} 744 745/* 746 * Search the method's list of exceptions for a match. 747 * 748 * Returns the offset of the catch block on success, or -1 on failure. 749 */ 750static int findCatchInMethod(Thread* self, const Method* method, int relPc, 751 ClassObject* excepClass) 752{ 753 /* 754 * Need to clear the exception before entry. Otherwise, dvmResolveClass 755 * might think somebody threw an exception while it was loading a class. 756 */ 757 assert(!dvmCheckException(self)); 758 assert(!dvmIsNativeMethod(method)); 759 760 LOGVV("findCatchInMethod %s.%s excep=%s depth=%d\n", 761 method->clazz->descriptor, method->name, excepClass->descriptor, 762 dvmComputeExactFrameDepth(self->curFrame)); 763 764 DvmDex* pDvmDex = method->clazz->pDvmDex; 765 const DexCode* pCode = dvmGetMethodCode(method); 766 DexCatchIterator iterator; 767 768 if (dexFindCatchHandler(&iterator, pCode, relPc)) { 769 for (;;) { 770 DexCatchHandler* handler = dexCatchIteratorNext(&iterator); 771 772 if (handler == NULL) { 773 break; 774 } 775 776 if (handler->typeIdx == kDexNoIndex) { 777 /* catch-all */ 778 LOGV("Match on catch-all block at 0x%02x in %s.%s for %s\n", 779 relPc, method->clazz->descriptor, 780 method->name, excepClass->descriptor); 781 return handler->address; 782 } 783 784 ClassObject* throwable = 785 dvmDexGetResolvedClass(pDvmDex, handler->typeIdx); 786 if (throwable == NULL) { 787 /* 788 * TODO: this behaves badly if we run off the stack 789 * while trying to throw an exception. The problem is 790 * that, if we're in a class loaded by a class loader, 791 * the call to dvmResolveClass has to ask the class 792 * loader for help resolving any previously-unresolved 793 * classes. If this particular class loader hasn't 794 * resolved StackOverflowError, it will call into 795 * interpreted code, and blow up. 796 * 797 * We currently replace the previous exception with 798 * the StackOverflowError, which means they won't be 799 * catching it *unless* they explicitly catch 800 * StackOverflowError, in which case we'll be unable 801 * to resolve the class referred to by the "catch" 802 * block. 803 * 804 * We end up getting a huge pile of warnings if we do 805 * a simple synthetic test, because this method gets 806 * called on every stack frame up the tree, and it 807 * fails every time. 808 * 809 * This eventually bails out, effectively becoming an 810 * uncatchable exception, so other than the flurry of 811 * warnings it's not really a problem. Still, we could 812 * probably handle this better. 813 */ 814 throwable = dvmResolveClass(method->clazz, handler->typeIdx, 815 true); 816 if (throwable == NULL) { 817 /* 818 * We couldn't find the exception they wanted in 819 * our class files (or, perhaps, the stack blew up 820 * while we were querying a class loader). Cough 821 * up a warning, then move on to the next entry. 822 * Keep the exception status clear. 823 */ 824 LOGW("Could not resolve class ref'ed in exception " 825 "catch list (class index %d, exception %s)\n", 826 handler->typeIdx, 827 (self->exception != NULL) ? 828 self->exception->clazz->descriptor : "(none)"); 829 dvmClearException(self); 830 continue; 831 } 832 } 833 834 //LOGD("ADDR MATCH, check %s instanceof %s\n", 835 // excepClass->descriptor, pEntry->excepClass->descriptor); 836 837 if (dvmInstanceof(excepClass, throwable)) { 838 LOGV("Match on catch block at 0x%02x in %s.%s for %s\n", 839 relPc, method->clazz->descriptor, 840 method->name, excepClass->descriptor); 841 return handler->address; 842 } 843 } 844 } 845 846 LOGV("No matching catch block at 0x%02x in %s for %s\n", 847 relPc, method->name, excepClass->descriptor); 848 return -1; 849} 850 851/* 852 * Find a matching "catch" block. "pc" is the relative PC within the 853 * current method, indicating the offset from the start in 16-bit units. 854 * 855 * Returns the offset to the catch block, or -1 if we run up against a 856 * break frame without finding anything. 857 * 858 * The class resolution stuff we have to do while evaluating the "catch" 859 * blocks could cause an exception. The caller should clear the exception 860 * before calling here and restore it after. 861 * 862 * Sets *newFrame to the frame pointer of the frame with the catch block. 863 * If "scanOnly" is false, self->curFrame is also set to this value. 864 */ 865int dvmFindCatchBlock(Thread* self, int relPc, Object* exception, 866 bool scanOnly, void** newFrame) 867{ 868 void* fp = self->curFrame; 869 int catchAddr = -1; 870 871 assert(!dvmCheckException(self)); 872 873 while (true) { 874 StackSaveArea* saveArea = SAVEAREA_FROM_FP(fp); 875 catchAddr = findCatchInMethod(self, saveArea->method, relPc, 876 exception->clazz); 877 if (catchAddr >= 0) 878 break; 879 880 /* 881 * Normally we'd check for ACC_SYNCHRONIZED methods and unlock 882 * them as we unroll. Dalvik uses what amount to generated 883 * "finally" blocks to take care of this for us. 884 */ 885 886 /* output method profiling info */ 887 if (!scanOnly) { 888 TRACE_METHOD_UNROLL(self, saveArea->method); 889 } 890 891 /* 892 * Move up one frame. If the next thing up is a break frame, 893 * break out now so we're left unrolled to the last method frame. 894 * We need to point there so we can roll up the JNI local refs 895 * if this was a native method. 896 */ 897 assert(saveArea->prevFrame != NULL); 898 if (dvmIsBreakFrame(saveArea->prevFrame)) { 899 if (!scanOnly) 900 break; // bail with catchAddr == -1 901 902 /* 903 * We're scanning for the debugger. It needs to know if this 904 * exception is going to be caught or not, and we need to figure 905 * out if it will be caught *ever* not just between the current 906 * position and the next break frame. We can't tell what native 907 * code is going to do, so we assume it never catches exceptions. 908 * 909 * Start by finding an interpreted code frame. 910 */ 911 fp = saveArea->prevFrame; // this is the break frame 912 saveArea = SAVEAREA_FROM_FP(fp); 913 fp = saveArea->prevFrame; // this may be a good one 914 while (fp != NULL) { 915 if (!dvmIsBreakFrame(fp)) { 916 saveArea = SAVEAREA_FROM_FP(fp); 917 if (!dvmIsNativeMethod(saveArea->method)) 918 break; 919 } 920 921 fp = SAVEAREA_FROM_FP(fp)->prevFrame; 922 } 923 if (fp == NULL) 924 break; // bail with catchAddr == -1 925 926 /* 927 * Now fp points to the "good" frame. When the interp code 928 * invoked the native code, it saved a copy of its current PC 929 * into xtra.currentPc. Pull it out of there. 930 */ 931 relPc = 932 saveArea->xtra.currentPc - SAVEAREA_FROM_FP(fp)->method->insns; 933 } else { 934 fp = saveArea->prevFrame; 935 936 /* savedPc in was-current frame goes with method in now-current */ 937 relPc = saveArea->savedPc - SAVEAREA_FROM_FP(fp)->method->insns; 938 } 939 } 940 941 if (!scanOnly) 942 self->curFrame = fp; 943 944 /* 945 * The class resolution in findCatchInMethod() could cause an exception. 946 * Clear it to be safe. 947 */ 948 self->exception = NULL; 949 950 *newFrame = fp; 951 return catchAddr; 952} 953 954/* 955 * We have to carry the exception's stack trace around, but in many cases 956 * it will never be examined. It makes sense to keep it in a compact, 957 * VM-specific object, rather than an array of Objects with strings. 958 * 959 * Pass in the thread whose stack we're interested in. If "thread" is 960 * not self, the thread must be suspended. This implies that the thread 961 * list lock is held, which means we can't allocate objects or we risk 962 * jamming the GC. So, we allow this function to return different formats. 963 * (This shouldn't be called directly -- see the inline functions in the 964 * header file.) 965 * 966 * If "wantObject" is true, this returns a newly-allocated Object, which is 967 * presently an array of integers, but could become something else in the 968 * future. If "wantObject" is false, return plain malloc data. 969 * 970 * NOTE: if we support class unloading, we will need to scan the class 971 * object references out of these arrays. 972 */ 973void* dvmFillInStackTraceInternal(Thread* thread, bool wantObject, int* pCount) 974{ 975 ArrayObject* stackData = NULL; 976 int* simpleData = NULL; 977 void* fp; 978 void* startFp; 979 int stackDepth; 980 int* intPtr; 981 982 if (pCount != NULL) 983 *pCount = 0; 984 fp = thread->curFrame; 985 986 assert(thread == dvmThreadSelf() || dvmIsSuspended(thread)); 987 988 /* 989 * We're looking at a stack frame for code running below a Throwable 990 * constructor. We want to remove the Throwable methods and the 991 * superclass initializations so the user doesn't see them when they 992 * read the stack dump. 993 * 994 * TODO: this just scrapes off the top layers of Throwable. Might not do 995 * the right thing if we create an exception object or cause a VM 996 * exception while in a Throwable method. 997 */ 998 while (fp != NULL) { 999 const StackSaveArea* saveArea = SAVEAREA_FROM_FP(fp); 1000 const Method* method = saveArea->method; 1001 1002 if (dvmIsBreakFrame(fp)) 1003 break; 1004 if (!dvmInstanceof(method->clazz, gDvm.classJavaLangThrowable)) 1005 break; 1006 //LOGD("EXCEP: ignoring %s.%s\n", 1007 // method->clazz->descriptor, method->name); 1008 fp = saveArea->prevFrame; 1009 } 1010 startFp = fp; 1011 1012 /* 1013 * Compute the stack depth. 1014 */ 1015 stackDepth = 0; 1016 while (fp != NULL) { 1017 const StackSaveArea* saveArea = SAVEAREA_FROM_FP(fp); 1018 1019 if (!dvmIsBreakFrame(fp)) 1020 stackDepth++; 1021 1022 assert(fp != saveArea->prevFrame); 1023 fp = saveArea->prevFrame; 1024 } 1025 //LOGD("EXCEP: stack depth is %d\n", stackDepth); 1026 1027 if (!stackDepth) 1028 goto bail; 1029 1030 /* 1031 * We need to store a pointer to the Method and the program counter. 1032 * We have 4-byte pointers, so we use '[I'. 1033 */ 1034 if (wantObject) { 1035 assert(sizeof(Method*) == 4); 1036 stackData = dvmAllocPrimitiveArray('I', stackDepth*2, ALLOC_DEFAULT); 1037 if (stackData == NULL) { 1038 assert(dvmCheckException(dvmThreadSelf())); 1039 goto bail; 1040 } 1041 intPtr = (int*) stackData->contents; 1042 } else { 1043 /* array of ints; first entry is stack depth */ 1044 assert(sizeof(Method*) == sizeof(int)); 1045 simpleData = (int*) malloc(sizeof(int) * stackDepth*2); 1046 if (simpleData == NULL) 1047 goto bail; 1048 1049 assert(pCount != NULL); 1050 intPtr = simpleData; 1051 } 1052 if (pCount != NULL) 1053 *pCount = stackDepth; 1054 1055 fp = startFp; 1056 while (fp != NULL) { 1057 const StackSaveArea* saveArea = SAVEAREA_FROM_FP(fp); 1058 const Method* method = saveArea->method; 1059 1060 if (!dvmIsBreakFrame(fp)) { 1061 //LOGD("EXCEP keeping %s.%s\n", method->clazz->descriptor, 1062 // method->name); 1063 1064 *intPtr++ = (int) method; 1065 if (dvmIsNativeMethod(method)) { 1066 *intPtr++ = 0; /* no saved PC for native methods */ 1067 } else { 1068 assert(saveArea->xtra.currentPc >= method->insns && 1069 saveArea->xtra.currentPc < 1070 method->insns + dvmGetMethodInsnsSize(method)); 1071 *intPtr++ = (int) (saveArea->xtra.currentPc - method->insns); 1072 } 1073 1074 stackDepth--; // for verification 1075 } 1076 1077 assert(fp != saveArea->prevFrame); 1078 fp = saveArea->prevFrame; 1079 } 1080 assert(stackDepth == 0); 1081 1082bail: 1083 if (wantObject) { 1084 dvmReleaseTrackedAlloc((Object*) stackData, dvmThreadSelf()); 1085 return stackData; 1086 } else { 1087 return simpleData; 1088 } 1089} 1090 1091 1092/* 1093 * Given an Object previously created by dvmFillInStackTrace(), use the 1094 * contents of the saved stack trace to generate an array of 1095 * java/lang/StackTraceElement objects. 1096 * 1097 * The returned array is not added to the "local refs" list. 1098 */ 1099ArrayObject* dvmGetStackTrace(const Object* ostackData) 1100{ 1101 const ArrayObject* stackData = (const ArrayObject*) ostackData; 1102 const int* intVals; 1103 int stackSize; 1104 1105 stackSize = stackData->length / 2; 1106 intVals = (const int*) stackData->contents; 1107 return dvmGetStackTraceRaw(intVals, stackSize); 1108} 1109 1110/* 1111 * Generate an array of StackTraceElement objects from the raw integer 1112 * data encoded by dvmFillInStackTrace(). 1113 * 1114 * "intVals" points to the first {method,pc} pair. 1115 * 1116 * The returned array is not added to the "local refs" list. 1117 */ 1118ArrayObject* dvmGetStackTraceRaw(const int* intVals, int stackDepth) 1119{ 1120 ArrayObject* steArray = NULL; 1121 int i; 1122 1123 /* init this if we haven't yet */ 1124 if (!dvmIsClassInitialized(gDvm.classJavaLangStackTraceElement)) 1125 dvmInitClass(gDvm.classJavaLangStackTraceElement); 1126 1127 /* allocate a StackTraceElement array */ 1128 steArray = dvmAllocArray(gDvm.classJavaLangStackTraceElementArray, 1129 stackDepth, kObjectArrayRefWidth, ALLOC_DEFAULT); 1130 if (steArray == NULL) 1131 goto bail; 1132 1133 /* 1134 * Allocate and initialize a StackTraceElement for each stack frame. 1135 * We use the standard constructor to configure the object. 1136 */ 1137 for (i = 0; i < stackDepth; i++) { 1138 Object* ste; 1139 Method* meth; 1140 StringObject* className; 1141 StringObject* methodName; 1142 StringObject* fileName; 1143 int lineNumber, pc; 1144 const char* sourceFile; 1145 char* dotName; 1146 1147 ste = dvmAllocObject(gDvm.classJavaLangStackTraceElement,ALLOC_DEFAULT); 1148 if (ste == NULL) 1149 goto bail; 1150 1151 meth = (Method*) *intVals++; 1152 pc = *intVals++; 1153 1154 if (pc == -1) // broken top frame? 1155 lineNumber = 0; 1156 else 1157 lineNumber = dvmLineNumFromPC(meth, pc); 1158 1159 dotName = dvmDescriptorToDot(meth->clazz->descriptor); 1160 className = dvmCreateStringFromCstr(dotName); 1161 free(dotName); 1162 1163 methodName = dvmCreateStringFromCstr(meth->name); 1164 sourceFile = dvmGetMethodSourceFile(meth); 1165 if (sourceFile != NULL) 1166 fileName = dvmCreateStringFromCstr(sourceFile); 1167 else 1168 fileName = NULL; 1169 1170 /* 1171 * Invoke: 1172 * public StackTraceElement(String declaringClass, String methodName, 1173 * String fileName, int lineNumber) 1174 * (where lineNumber==-2 means "native") 1175 */ 1176 JValue unused; 1177 dvmCallMethod(dvmThreadSelf(), gDvm.methJavaLangStackTraceElement_init, 1178 ste, &unused, className, methodName, fileName, lineNumber); 1179 1180 dvmReleaseTrackedAlloc(ste, NULL); 1181 dvmReleaseTrackedAlloc((Object*) className, NULL); 1182 dvmReleaseTrackedAlloc((Object*) methodName, NULL); 1183 dvmReleaseTrackedAlloc((Object*) fileName, NULL); 1184 1185 if (dvmCheckException(dvmThreadSelf())) 1186 goto bail; 1187 1188 dvmSetObjectArrayElement(steArray, i, ste); 1189 } 1190 1191bail: 1192 dvmReleaseTrackedAlloc((Object*) steArray, NULL); 1193 return steArray; 1194} 1195 1196/* 1197 * Dump the contents of a raw stack trace to the log. 1198 */ 1199void dvmLogRawStackTrace(const int* intVals, int stackDepth) 1200{ 1201 int i; 1202 1203 /* 1204 * Run through the array of stack frame data. 1205 */ 1206 for (i = 0; i < stackDepth; i++) { 1207 Method* meth; 1208 int lineNumber, pc; 1209 const char* sourceFile; 1210 char* dotName; 1211 1212 meth = (Method*) *intVals++; 1213 pc = *intVals++; 1214 1215 if (pc == -1) // broken top frame? 1216 lineNumber = 0; 1217 else 1218 lineNumber = dvmLineNumFromPC(meth, pc); 1219 1220 // probably don't need to do this, but it looks nicer 1221 dotName = dvmDescriptorToDot(meth->clazz->descriptor); 1222 1223 if (dvmIsNativeMethod(meth)) { 1224 LOGI("\tat %s.%s(Native Method)\n", dotName, meth->name); 1225 } else { 1226 LOGI("\tat %s.%s(%s:%d)\n", 1227 dotName, meth->name, dvmGetMethodSourceFile(meth), 1228 dvmLineNumFromPC(meth, pc)); 1229 } 1230 1231 free(dotName); 1232 1233 sourceFile = dvmGetMethodSourceFile(meth); 1234 } 1235} 1236 1237/* 1238 * Get the message string. We'd like to just grab the field out of 1239 * Throwable, but the getMessage() function can be overridden by the 1240 * sub-class. 1241 * 1242 * Returns the message string object, or NULL if it wasn't set or 1243 * we encountered a failure trying to retrieve it. The string will 1244 * be added to the tracked references table. 1245 */ 1246static StringObject* getExceptionMessage(Object* exception) 1247{ 1248 Thread* self = dvmThreadSelf(); 1249 Method* getMessageMethod; 1250 StringObject* messageStr = NULL; 1251 1252 assert(exception == self->exception); 1253 self->exception = NULL; 1254 1255 getMessageMethod = dvmFindVirtualMethodHierByDescriptor(exception->clazz, 1256 "getMessage", "()Ljava/lang/String;"); 1257 if (getMessageMethod != NULL) { 1258 /* could be in NATIVE mode from CheckJNI, so switch state */ 1259 ThreadStatus oldStatus = dvmChangeStatus(self, THREAD_RUNNING); 1260 JValue result; 1261 1262 dvmCallMethod(self, getMessageMethod, exception, &result); 1263 messageStr = (StringObject*) result.l; 1264 dvmAddTrackedAlloc((Object*) messageStr, self); 1265 1266 dvmChangeStatus(self, oldStatus); 1267 } else { 1268 LOGW("WARNING: could not find getMessage in %s\n", 1269 exception->clazz->descriptor); 1270 } 1271 1272 if (self->exception != NULL) { 1273 LOGW("NOTE: exception thrown while retrieving exception message: %s\n", 1274 self->exception->clazz->descriptor); 1275 } 1276 1277 self->exception = exception; 1278 return messageStr; 1279} 1280 1281/* 1282 * Print the direct stack trace of the given exception to the log. 1283 */ 1284static void logStackTraceOf(Object* exception) 1285{ 1286 const ArrayObject* stackData; 1287 StringObject* messageStr; 1288 int stackSize; 1289 const int* intVals; 1290 char* className; 1291 1292 className = dvmDescriptorToDot(exception->clazz->descriptor); 1293 messageStr = getExceptionMessage(exception); 1294 if (messageStr != NULL) { 1295 char* cp = dvmCreateCstrFromString(messageStr); 1296 dvmReleaseTrackedAlloc((Object*) messageStr, dvmThreadSelf()); 1297 messageStr = NULL; 1298 1299 LOGI("%s: %s\n", className, cp); 1300 free(cp); 1301 } else { 1302 LOGI("%s:\n", className); 1303 } 1304 free(className); 1305 1306 /* 1307 * This relies on the stackState field, which contains the "raw" 1308 * form of the stack. The Throwable class may clear this field 1309 * after it generates the "cooked" form, in which case we'll have 1310 * nothing to show. 1311 */ 1312 stackData = (const ArrayObject*) dvmGetFieldObject(exception, 1313 gDvm.offJavaLangThrowable_stackState); 1314 if (stackData == NULL) { 1315 LOGI(" (raw stack trace not found)\n"); 1316 return; 1317 } 1318 1319 stackSize = stackData->length / 2; 1320 intVals = (const int*) stackData->contents; 1321 1322 dvmLogRawStackTrace(intVals, stackSize); 1323} 1324 1325/* 1326 * Print the stack trace of the current thread's exception, as well as 1327 * the stack traces of any chained exceptions, to the log. We extract 1328 * the stored stack trace and process it internally instead of calling 1329 * interpreted code. 1330 */ 1331void dvmLogExceptionStackTrace(void) 1332{ 1333 Object* exception = dvmThreadSelf()->exception; 1334 Object* cause; 1335 1336 if (exception == NULL) { 1337 LOGW("tried to log a null exception?\n"); 1338 return; 1339 } 1340 1341 for (;;) { 1342 logStackTraceOf(exception); 1343 cause = dvmGetExceptionCause(exception); 1344 if (cause == NULL) { 1345 break; 1346 } 1347 LOGI("Caused by:\n"); 1348 exception = cause; 1349 } 1350} 1351