2 * Copyright (C) 2008 The Android Open Source Project
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
18 * Main interpreter entry point and support functions.
20 * The entry point selects the "standard" or "debug" interpreter and
21 * facilitates switching between them. The standard interpreter may
22 * use the "fast" or "portable" implementation.
24 * Some debugger support functions are included here.
27 #include "interp/InterpDefs.h"
29 #include "interp/Jit.h"
34 * ===========================================================================
36 * ===========================================================================
40 static BreakpointSet* dvmBreakpointSetAlloc();
41 static void dvmBreakpointSetFree(BreakpointSet* pSet);
44 /* Target-specific save/restore */
45 extern "C" void dvmJitCalleeSave(double *saveArea);
46 extern "C" void dvmJitCalleeRestore(double *saveArea);
47 /* Interpreter entry points from compiled code */
48 extern "C" void dvmJitToInterpNormal();
49 extern "C" void dvmJitToInterpNoChain();
50 extern "C" void dvmJitToInterpPunt();
51 extern "C" void dvmJitToInterpSingleStep();
52 extern "C" void dvmJitToInterpTraceSelect();
53 #if defined(WITH_SELF_VERIFICATION)
54 extern "C" void dvmJitToInterpBackwardBranch();
59 * Initialize global breakpoint structures.
61 bool dvmBreakpointStartup()
63 gDvm.breakpointSet = dvmBreakpointSetAlloc();
64 return (gDvm.breakpointSet != NULL);
70 void dvmBreakpointShutdown()
72 dvmBreakpointSetFree(gDvm.breakpointSet);
77 * This represents a breakpoint inserted in the instruction stream.
79 * The debugger may ask us to create the same breakpoint multiple times.
80 * We only remove the breakpoint when the last instance is cleared.
83 Method* method; /* method we're associated with */
84 u2* addr; /* absolute memory address */
85 u1 originalOpcode; /* original 8-bit opcode value */
86 int setCount; /* #of times this breakpoint was set */
92 struct BreakpointSet {
93 /* grab lock before reading or writing anything else in here */
96 /* vector of breakpoint structures */
99 Breakpoint* breakpoints;
103 * Initialize a BreakpointSet. Initially empty.
105 static BreakpointSet* dvmBreakpointSetAlloc()
107 BreakpointSet* pSet = (BreakpointSet*) calloc(1, sizeof(*pSet));
109 dvmInitMutex(&pSet->lock);
110 /* leave the rest zeroed -- will alloc on first use */
116 * Free storage associated with a BreakpointSet.
118 static void dvmBreakpointSetFree(BreakpointSet* pSet)
123 free(pSet->breakpoints);
128 * Lock the breakpoint set.
130 * It's not currently necessary to switch to VMWAIT in the event of
131 * contention, because nothing in here can block. However, it's possible
132 * that the bytecode-updater code could become fancier in the future, so
133 * we do the trylock dance as a bit of future-proofing.
135 static void dvmBreakpointSetLock(BreakpointSet* pSet)
137 if (dvmTryLockMutex(&pSet->lock) != 0) {
138 Thread* self = dvmThreadSelf();
139 ThreadStatus oldStatus = dvmChangeStatus(self, THREAD_VMWAIT);
140 dvmLockMutex(&pSet->lock);
141 dvmChangeStatus(self, oldStatus);
146 * Unlock the breakpoint set.
148 static void dvmBreakpointSetUnlock(BreakpointSet* pSet)
150 dvmUnlockMutex(&pSet->lock);
154 * Return the #of breakpoints.
156 static int dvmBreakpointSetCount(const BreakpointSet* pSet)
162 * See if we already have an entry for this address.
164 * The BreakpointSet's lock must be acquired before calling here.
166 * Returns the index of the breakpoint entry, or -1 if not found.
168 static int dvmBreakpointSetFind(const BreakpointSet* pSet, const u2* addr)
172 for (i = 0; i < pSet->count; i++) {
173 Breakpoint* pBreak = &pSet->breakpoints[i];
174 if (pBreak->addr == addr)
182 * Retrieve the opcode that was originally at the specified location.
184 * The BreakpointSet's lock must be acquired before calling here.
186 * Returns "true" with the opcode in *pOrig on success.
188 static bool dvmBreakpointSetOriginalOpcode(const BreakpointSet* pSet,
189 const u2* addr, u1* pOrig)
191 int idx = dvmBreakpointSetFind(pSet, addr);
195 *pOrig = pSet->breakpoints[idx].originalOpcode;
200 * Check the opcode. If it's a "magic" NOP, indicating the start of
201 * switch or array data in the instruction stream, we don't want to set
204 * This can happen because the line number information dx generates
205 * associates the switch data with the switch statement's line number,
206 * and some debuggers put breakpoints at every address associated with
207 * a given line. The result is that the breakpoint stomps on the NOP
208 * instruction that doubles as a data table magic number, and an explicit
209 * check in the interpreter results in an exception being thrown.
211 * We don't want to simply refuse to add the breakpoint to the table,
212 * because that confuses the housekeeping. We don't want to reject the
213 * debugger's event request, and we want to be sure that there's exactly
214 * one un-set operation for every set op.
216 static bool instructionIsMagicNop(const u2* addr)
219 return ((GET_OPCODE(curVal)) == OP_NOP && (curVal >> 8) != 0);
223 * Add a breakpoint at a specific address. If the address is already
224 * present in the table, this just increments the count.
226 * For a new entry, this will extract and preserve the current opcode from
227 * the instruction stream, and replace it with a breakpoint opcode.
229 * The BreakpointSet's lock must be acquired before calling here.
231 * Returns "true" on success.
233 static bool dvmBreakpointSetAdd(BreakpointSet* pSet, Method* method,
234 unsigned int instrOffset)
236 const int kBreakpointGrowth = 10;
237 const u2* addr = method->insns + instrOffset;
238 int idx = dvmBreakpointSetFind(pSet, addr);
242 if (pSet->count == pSet->alloc) {
243 int newSize = pSet->alloc + kBreakpointGrowth;
246 ALOGV("+++ increasing breakpoint set size to %d", newSize);
248 /* pSet->breakpoints will be NULL on first entry */
249 newVec = (Breakpoint*)realloc(pSet->breakpoints, newSize * sizeof(Breakpoint));
253 pSet->breakpoints = newVec;
254 pSet->alloc = newSize;
257 pBreak = &pSet->breakpoints[pSet->count++];
258 pBreak->method = method;
259 pBreak->addr = (u2*)addr;
260 pBreak->originalOpcode = *(u1*)addr;
261 pBreak->setCount = 1;
264 * Change the opcode. We must ensure that the BreakpointSet
265 * updates happen before we change the opcode.
267 * If the method has not been verified, we do NOT insert the
268 * breakpoint yet, since that will screw up the verifier. The
269 * debugger is allowed to insert breakpoints in unverified code,
270 * but since we don't execute unverified code we don't need to
271 * alter the bytecode yet.
273 * The class init code will "flush" all pending opcode writes
274 * before verification completes.
276 assert(*(u1*)addr != OP_BREAKPOINT);
277 if (dvmIsClassVerified(method->clazz)) {
278 ALOGV("Class %s verified, adding breakpoint at %p",
279 method->clazz->descriptor, addr);
280 if (instructionIsMagicNop(addr)) {
281 ALOGV("Refusing to set breakpoint on %04x at %s.%s + %#x",
282 *addr, method->clazz->descriptor, method->name,
285 ANDROID_MEMBAR_FULL();
286 dvmDexChangeDex1(method->clazz->pDvmDex, (u1*)addr,
290 ALOGV("Class %s NOT verified, deferring breakpoint at %p",
291 method->clazz->descriptor, addr);
295 * Breakpoint already exists, just increase the count.
297 pBreak = &pSet->breakpoints[idx];
305 * Remove one instance of the specified breakpoint. When the count
306 * reaches zero, the entry is removed from the table, and the original
307 * opcode is restored.
309 * The BreakpointSet's lock must be acquired before calling here.
311 static void dvmBreakpointSetRemove(BreakpointSet* pSet, Method* method,
312 unsigned int instrOffset)
314 const u2* addr = method->insns + instrOffset;
315 int idx = dvmBreakpointSetFind(pSet, addr);
318 /* breakpoint not found in set -- unexpected */
319 if (*(u1*)addr == OP_BREAKPOINT) {
320 ALOGE("Unable to restore breakpoint opcode (%s.%s +%#x)",
321 method->clazz->descriptor, method->name, instrOffset);
324 ALOGW("Breakpoint was already restored? (%s.%s +%#x)",
325 method->clazz->descriptor, method->name, instrOffset);
328 Breakpoint* pBreak = &pSet->breakpoints[idx];
329 if (pBreak->setCount == 1) {
331 * Must restore opcode before removing set entry.
333 * If the breakpoint was never flushed, we could be ovewriting
334 * a value with the same value. Not a problem, though we
335 * could end up causing a copy-on-write here when we didn't
336 * need to. (Not worth worrying about.)
338 dvmDexChangeDex1(method->clazz->pDvmDex, (u1*)addr,
339 pBreak->originalOpcode);
340 ANDROID_MEMBAR_FULL();
342 if (idx != pSet->count-1) {
344 memmove(&pSet->breakpoints[idx], &pSet->breakpoints[idx+1],
345 (pSet->count-1 - idx) * sizeof(pSet->breakpoints[0]));
348 pSet->breakpoints[pSet->count].addr = (u2*) 0xdecadead; // debug
351 assert(pBreak->setCount > 0);
357 * Flush any breakpoints associated with methods in "clazz". We want to
358 * change the opcode, which might not have happened when the breakpoint
359 * was initially set because the class was in the process of being
362 * The BreakpointSet's lock must be acquired before calling here.
364 static void dvmBreakpointSetFlush(BreakpointSet* pSet, ClassObject* clazz)
367 for (i = 0; i < pSet->count; i++) {
368 Breakpoint* pBreak = &pSet->breakpoints[i];
369 if (pBreak->method->clazz == clazz) {
371 * The breakpoint is associated with a method in this class.
372 * It might already be there or it might not; either way,
375 ALOGV("Flushing breakpoint at %p for %s",
376 pBreak->addr, clazz->descriptor);
377 if (instructionIsMagicNop(pBreak->addr)) {
378 ALOGV("Refusing to flush breakpoint on %04x at %s.%s + %#x",
379 *pBreak->addr, pBreak->method->clazz->descriptor,
380 pBreak->method->name, pBreak->addr - pBreak->method->insns);
382 dvmDexChangeDex1(clazz->pDvmDex, (u1*)pBreak->addr,
391 * Do any debugger-attach-time initialization.
393 void dvmInitBreakpoints()
395 /* quick sanity check */
396 BreakpointSet* pSet = gDvm.breakpointSet;
397 dvmBreakpointSetLock(pSet);
398 if (dvmBreakpointSetCount(pSet) != 0) {
399 ALOGW("WARNING: %d leftover breakpoints", dvmBreakpointSetCount(pSet));
400 /* generally not good, but we can keep going */
402 dvmBreakpointSetUnlock(pSet);
406 * Add an address to the list, putting it in the first non-empty slot.
408 * Sometimes the debugger likes to add two entries for one breakpoint.
409 * We add two entries here, so that we get the right behavior when it's
412 * This will only be run from the JDWP thread, and it will happen while
413 * we are updating the event list, which is synchronized. We're guaranteed
414 * to be the only one adding entries, and the lock ensures that nobody
415 * will be trying to remove them while we're in here.
417 * "addr" is the absolute address of the breakpoint bytecode.
419 void dvmAddBreakAddr(Method* method, unsigned int instrOffset)
421 BreakpointSet* pSet = gDvm.breakpointSet;
422 dvmBreakpointSetLock(pSet);
423 dvmBreakpointSetAdd(pSet, method, instrOffset);
424 dvmBreakpointSetUnlock(pSet);
428 * Remove an address from the list by setting the entry to NULL.
430 * This can be called from the JDWP thread (because the debugger has
431 * cancelled the breakpoint) or from an event thread (because it's a
432 * single-shot breakpoint, e.g. "run to line"). We only get here as
433 * the result of removing an entry from the event list, which is
434 * synchronized, so it should not be possible for two threads to be
435 * updating breakpoints at the same time.
437 void dvmClearBreakAddr(Method* method, unsigned int instrOffset)
439 BreakpointSet* pSet = gDvm.breakpointSet;
440 dvmBreakpointSetLock(pSet);
441 dvmBreakpointSetRemove(pSet, method, instrOffset);
442 dvmBreakpointSetUnlock(pSet);
446 * Get the original opcode from under a breakpoint.
448 * On SMP hardware it's possible one core might try to execute a breakpoint
449 * after another core has cleared it. We need to handle the case where
450 * there's no entry in the breakpoint set. (The memory barriers in the
451 * locks and in the breakpoint update code should ensure that, once we've
452 * observed the absence of a breakpoint entry, we will also now observe
453 * the restoration of the original opcode. The fact that we're holding
454 * the lock prevents other threads from confusing things further.)
456 u1 dvmGetOriginalOpcode(const u2* addr)
458 BreakpointSet* pSet = gDvm.breakpointSet;
461 dvmBreakpointSetLock(pSet);
462 if (!dvmBreakpointSetOriginalOpcode(pSet, addr, &orig)) {
464 if (orig == OP_BREAKPOINT) {
465 ALOGE("GLITCH: can't find breakpoint, opcode is still set");
469 dvmBreakpointSetUnlock(pSet);
475 * Flush any breakpoints associated with methods in "clazz".
477 * We don't want to modify the bytecode of a method before the verifier
478 * gets a chance to look at it, so we postpone opcode replacement until
479 * after verification completes.
481 void dvmFlushBreakpoints(ClassObject* clazz)
483 BreakpointSet* pSet = gDvm.breakpointSet;
488 assert(dvmIsClassVerified(clazz));
489 dvmBreakpointSetLock(pSet);
490 dvmBreakpointSetFlush(pSet, clazz);
491 dvmBreakpointSetUnlock(pSet);
495 * Add a single step event. Currently this is a global item.
497 * We set up some initial values based on the thread's current state. This
498 * won't work well if the thread is running, so it's up to the caller to
499 * verify that it's suspended.
501 * This is only called from the JDWP thread.
503 bool dvmAddSingleStep(Thread* thread, int size, int depth)
505 StepControl* pCtrl = &gDvm.stepControl;
507 if (pCtrl->active && thread != pCtrl->thread) {
508 ALOGW("WARNING: single-step active for %p; adding %p",
509 pCtrl->thread, thread);
512 * Keep going, overwriting previous. This can happen if you
513 * suspend a thread in Object.wait, hit the single-step key, then
514 * switch to another thread and do the same thing again.
515 * The first thread's step is still pending.
517 * TODO: consider making single-step per-thread. Adds to the
518 * overhead, but could be useful in rare situations.
522 pCtrl->size = static_cast<JdwpStepSize>(size);
523 pCtrl->depth = static_cast<JdwpStepDepth>(depth);
524 pCtrl->thread = thread;
527 * We may be stepping into or over method calls, or running until we
528 * return from the current method. To make this work we need to track
529 * the current line, current method, and current stack depth. We need
530 * to be checking these after most instructions, notably those that
531 * call methods, return from methods, or are on a different line from the
532 * previous instruction.
534 * We have to start with a snapshot of the current state. If we're in
535 * an interpreted method, everything we need is in the current frame. If
536 * we're in a native method, possibly with some extra JNI frames pushed
537 * on by PushLocalFrame, we want to use the topmost native method.
539 const StackSaveArea* saveArea;
543 for (fp = thread->interpSave.curFrame; fp != NULL;
544 fp = saveArea->prevFrame) {
545 const Method* method;
547 saveArea = SAVEAREA_FROM_FP(fp);
548 method = saveArea->method;
550 if (!dvmIsBreakFrame((u4*)fp) && !dvmIsNativeMethod(method))
555 ALOGW("Unexpected: step req in native-only threadid=%d",
559 if (prevFp != NULL) {
561 * First interpreted frame wasn't the one at the bottom. Break
562 * frames are only inserted when calling from native->interp, so we
563 * don't need to worry about one being here.
565 ALOGV("##### init step while in native method");
567 assert(!dvmIsBreakFrame((u4*)fp));
568 assert(dvmIsNativeMethod(SAVEAREA_FROM_FP(fp)->method));
569 saveArea = SAVEAREA_FROM_FP(fp);
573 * Pull the goodies out. "xtra.currentPc" should be accurate since
574 * we update it on every instruction while the debugger is connected.
576 pCtrl->method = saveArea->method;
577 // Clear out any old address set
578 if (pCtrl->pAddressSet != NULL) {
580 free((void *)pCtrl->pAddressSet);
581 pCtrl->pAddressSet = NULL;
583 if (dvmIsNativeMethod(pCtrl->method)) {
586 pCtrl->line = dvmLineNumFromPC(saveArea->method,
587 saveArea->xtra.currentPc - saveArea->method->insns);
589 = dvmAddressSetForLine(saveArea->method, pCtrl->line);
592 dvmComputeVagueFrameDepth(thread, thread->interpSave.curFrame);
593 pCtrl->active = true;
595 ALOGV("##### step init: thread=%p meth=%p '%s' line=%d frameDepth=%d depth=%s size=%s",
596 pCtrl->thread, pCtrl->method, pCtrl->method->name,
597 pCtrl->line, pCtrl->frameDepth,
598 dvmJdwpStepDepthStr(pCtrl->depth),
599 dvmJdwpStepSizeStr(pCtrl->size));
605 * Disable a single step event.
607 void dvmClearSingleStep(Thread* thread)
609 UNUSED_PARAMETER(thread);
611 gDvm.stepControl.active = false;
615 * The interpreter just threw. Handle any special subMode requirements.
616 * All interpSave state must be valid on entry.
618 void dvmReportExceptionThrow(Thread* self, Object* exception)
620 const Method* curMethod = self->interpSave.method;
621 #if defined(WITH_JIT)
622 if (self->interpBreak.ctl.subMode & kSubModeJitTraceBuild) {
623 dvmJitEndTraceSelect(self, self->interpSave.pc);
625 if (self->interpBreak.ctl.breakFlags & kInterpSingleStep) {
626 /* Discard any single-step native returns to translation */
627 self->jitResumeNPC = NULL;
630 if (self->interpBreak.ctl.subMode & kSubModeDebuggerActive) {
632 int offset = self->interpSave.pc - curMethod->insns;
633 int catchRelPc = dvmFindCatchBlock(self, offset, exception,
635 dvmDbgPostException(self->interpSave.curFrame, offset, catchFrame,
636 catchRelPc, exception);
641 * The interpreter is preparing to do an invoke (both native & normal).
642 * Handle any special subMode requirements. All interpSave state
643 * must be valid on entry.
645 void dvmReportInvoke(Thread* self, const Method* methodToCall)
647 TRACE_METHOD_ENTER(self, methodToCall);
651 * The interpreter is preparing to do a native invoke. Handle any
652 * special subMode requirements. NOTE: for a native invoke,
653 * dvmReportInvoke() and dvmReportPreNativeInvoke() will both
654 * be called prior to the invoke. fp is the Dalvik FP of the calling
657 void dvmReportPreNativeInvoke(const Method* methodToCall, Thread* self, u4* fp)
659 #if defined(WITH_JIT)
661 * Actively building a trace? If so, end it now. The trace
662 * builder can't follow into or through a native method.
664 if (self->interpBreak.ctl.subMode & kSubModeJitTraceBuild) {
665 dvmCheckJit(self->interpSave.pc, self);
668 if (self->interpBreak.ctl.subMode & kSubModeDebuggerActive) {
669 Object* thisPtr = dvmGetThisPtr(self->interpSave.method, fp);
670 assert(thisPtr == NULL || dvmIsHeapAddress(thisPtr));
671 dvmDbgPostLocationEvent(methodToCall, -1, thisPtr, DBG_METHOD_ENTRY);
676 * The interpreter has returned from a native invoke. Handle any
677 * special subMode requirements. fp is the Dalvik FP of the calling
680 void dvmReportPostNativeInvoke(const Method* methodToCall, Thread* self, u4* fp)
682 if (self->interpBreak.ctl.subMode & kSubModeDebuggerActive) {
683 Object* thisPtr = dvmGetThisPtr(self->interpSave.method, fp);
684 assert(thisPtr == NULL || dvmIsHeapAddress(thisPtr));
685 dvmDbgPostLocationEvent(methodToCall, -1, thisPtr, DBG_METHOD_EXIT);
687 if (self->interpBreak.ctl.subMode & kSubModeMethodTrace) {
688 dvmFastNativeMethodTraceExit(methodToCall, self);
693 * The interpreter has returned from a normal method. Handle any special
694 * subMode requirements. All interpSave state must be valid on entry.
696 void dvmReportReturn(Thread* self)
698 TRACE_METHOD_EXIT(self, self->interpSave.method);
699 #if defined(WITH_JIT)
700 if (dvmIsBreakFrame(self->interpSave.curFrame) &&
701 (self->interpBreak.ctl.subMode & kSubModeJitTraceBuild)) {
702 dvmCheckJit(self->interpSave.pc, self);
708 * Update the debugger on interesting events, such as hitting a breakpoint
709 * or a single-step point. This is called from the top of the interpreter
710 * loop, before the current instruction is processed.
712 * Set "methodEntry" if we've just entered the method. This detects
713 * method exit by checking to see if the next instruction is "return".
715 * This can't catch native method entry/exit, so we have to handle that
716 * at the point of invocation. We also need to catch it in dvmCallMethod
717 * if we want to capture native->native calls made through JNI.
720 * - Don't want to switch to VMWAIT while posting events to the debugger.
721 * Let the debugger code decide if we need to change state.
722 * - We may want to check for debugger-induced thread suspensions on
723 * every instruction. That would make a "suspend all" more responsive
724 * and reduce the chances of multiple simultaneous events occurring.
725 * However, it could change the behavior some.
727 * TODO: method entry/exit events are probably less common than location
728 * breakpoints. We may be able to speed things up a bit if we don't query
729 * the event list unless we know there's at least one lurking within.
731 static void updateDebugger(const Method* method, const u2* pc, const u4* fp,
737 * Update xtra.currentPc on every instruction. We need to do this if
738 * there's a chance that we could get suspended. This can happen if
739 * eventFlags != 0 here, or somebody manually requests a suspend
740 * (which gets handled at PERIOD_CHECKS time). One place where this
741 * needs to be correct is in dvmAddSingleStep().
745 if (self->debugIsMethodEntry) {
746 eventFlags |= DBG_METHOD_ENTRY;
747 self->debugIsMethodEntry = false;
751 * See if we have a breakpoint here.
753 * Depending on the "mods" associated with event(s) on this address,
754 * we may or may not actually send a message to the debugger.
756 if (GET_OPCODE(*pc) == OP_BREAKPOINT) {
757 ALOGV("+++ breakpoint hit at %p", pc);
758 eventFlags |= DBG_BREAKPOINT;
762 * If the debugger is single-stepping one of our threads, check to
763 * see if we're that thread and we've reached a step point.
765 const StepControl* pCtrl = &gDvm.stepControl;
766 if (pCtrl->active && pCtrl->thread == self) {
769 const char* msg = NULL;
771 assert(!dvmIsNativeMethod(method));
773 if (pCtrl->depth == SD_INTO) {
775 * Step into method calls. We break when the line number
776 * or method pointer changes. If we're in SS_MIN mode, we
779 if (pCtrl->method != method) {
782 } else if (pCtrl->size == SS_MIN) {
784 msg = "new instruction";
785 } else if (!dvmAddressSetGet(
786 pCtrl->pAddressSet, pc - method->insns)) {
790 } else if (pCtrl->depth == SD_OVER) {
792 * Step over method calls. We break when the line number is
793 * different and the frame depth is <= the original frame
794 * depth. (We can't just compare on the method, because we
795 * might get unrolled past it by an exception, and it's tricky
796 * to identify recursion.)
798 frameDepth = dvmComputeVagueFrameDepth(self, fp);
799 if (frameDepth < pCtrl->frameDepth) {
800 /* popped up one or more frames, always trigger */
803 } else if (frameDepth == pCtrl->frameDepth) {
804 /* same depth, see if we moved */
805 if (pCtrl->size == SS_MIN) {
807 msg = "new instruction";
808 } else if (!dvmAddressSetGet(pCtrl->pAddressSet,
809 pc - method->insns)) {
815 assert(pCtrl->depth == SD_OUT);
817 * Return from the current method. We break when the frame
820 * This differs from the "method exit" break in that it stops
821 * with the PC at the next instruction in the returned-to
822 * function, rather than the end of the returning function.
824 frameDepth = dvmComputeVagueFrameDepth(self, fp);
825 if (frameDepth < pCtrl->frameDepth) {
832 ALOGV("#####S %s", msg);
833 eventFlags |= DBG_SINGLE_STEP;
838 * Check to see if this is a "return" instruction. JDWP says we should
839 * send the event *after* the code has been executed, but it also says
840 * the location we provide is the last instruction. Since the "return"
841 * instruction has no interesting side effects, we should be safe.
842 * (We can't just move this down to the returnFromMethod label because
843 * we potentially need to combine it with other events.)
845 * We're also not supposed to generate a method exit event if the method
846 * terminates "with a thrown exception".
848 u2 opcode = GET_OPCODE(*pc);
849 if (opcode == OP_RETURN_VOID || opcode == OP_RETURN || opcode == OP_RETURN_VOID_BARRIER ||
850 opcode == OP_RETURN_OBJECT || opcode == OP_RETURN_WIDE)
852 eventFlags |= DBG_METHOD_EXIT;
856 * If there's something interesting going on, see if it matches one
857 * of the debugger filters.
859 if (eventFlags != 0) {
860 Object* thisPtr = dvmGetThisPtr(method, fp);
861 if (thisPtr != NULL && !dvmIsHeapAddress(thisPtr)) {
863 * TODO: remove this check if we're confident that the "this"
864 * pointer is where it should be -- slows us down, especially
865 * during single-step.
867 char* desc = dexProtoCopyMethodDescriptor(&method->prototype);
868 ALOGE("HEY: invalid 'this' ptr %p (%s.%s %s)", thisPtr,
869 method->clazz->descriptor, method->name, desc);
873 dvmDbgPostLocationEvent(method, pc - method->insns, thisPtr,
879 * Recover the "this" pointer from the current interpreted method. "this"
880 * is always in "in0" for non-static methods.
882 * The "ins" start at (#of registers - #of ins). Note in0 != v0.
884 * This works because "dx" guarantees that it will work. It's probably
885 * fairly common to have a virtual method that doesn't use its "this"
886 * pointer, in which case we're potentially wasting a register. However,
887 * the debugger doesn't treat "this" as just another argument. For
888 * example, events (such as breakpoints) can be enabled for specific
889 * values of "this". There is also a separate StackFrame.ThisObject call
890 * in JDWP that is expected to work for any non-native non-static method.
892 * Because we need it when setting up debugger event filters, we want to
893 * be able to do this quickly.
895 Object* dvmGetThisPtr(const Method* method, const u4* fp)
897 if (dvmIsStaticMethod(method))
899 return (Object*)fp[method->registersSize - method->insSize];
903 #if defined(WITH_TRACKREF_CHECKS)
905 * Verify that all internally-tracked references have been released. If
906 * they haven't, print them and abort the VM.
908 * "debugTrackedRefStart" indicates how many refs were on the list when
909 * we were first invoked.
911 void dvmInterpCheckTrackedRefs(Thread* self, const Method* method,
912 int debugTrackedRefStart)
914 if (dvmReferenceTableEntries(&self->internalLocalRefTable)
915 != (size_t) debugTrackedRefStart)
921 count = dvmReferenceTableEntries(&self->internalLocalRefTable);
923 ALOGE("TRACK: unreleased internal reference (prev=%d total=%d)",
924 debugTrackedRefStart, count);
925 desc = dexProtoCopyMethodDescriptor(&method->prototype);
926 ALOGE(" current method is %s.%s %s", method->clazz->descriptor,
929 top = self->internalLocalRefTable.table + debugTrackedRefStart;
930 while (top < self->internalLocalRefTable.nextEntry) {
933 ((*top)->clazz != NULL) ? (*top)->clazz->descriptor : "");
936 dvmDumpThread(self, false);
947 * Dump the v-registers. Sent to the ILOG log tag.
949 void dvmDumpRegs(const Method* method, const u4* framePtr, bool inOnly)
953 localCount = method->registersSize - method->insSize;
955 ALOG(LOG_VERBOSE, LOG_TAG"i", "Registers (fp=%p):", framePtr);
956 for (i = method->registersSize-1; i >= 0; i--) {
957 if (i >= localCount) {
958 ALOG(LOG_VERBOSE, LOG_TAG"i", " v%-2d in%-2d : 0x%08x",
959 i, i-localCount, framePtr[i]);
962 ALOG(LOG_VERBOSE, LOG_TAG"i", " [...]");
965 const char* name = "";
966 #if 0 // "locals" structure has changed -- need to rewrite this
968 DexFile* pDexFile = method->clazz->pDexFile;
969 const DexCode* pDexCode = dvmGetMethodCode(method);
970 int localsSize = dexGetLocalsSize(pDexFile, pDexCode);
971 const DexLocal* locals = dvmDexGetLocals(pDexFile, pDexCode);
972 for (j = 0; j < localsSize, j++) {
973 if (locals[j].registerNum == (u4) i) {
974 name = dvmDexStringStr(locals[j].pName);
979 ALOG(LOG_VERBOSE, LOG_TAG"i", " v%-2d : 0x%08x %s",
980 i, framePtr[i], name);
988 * ===========================================================================
989 * Entry point and general support functions
990 * ===========================================================================
994 * Find the matching case. Returns the offset to the handler instructions.
996 * Returns 3 if we don't find a match (it's the size of the packed-switch
999 s4 dvmInterpHandlePackedSwitch(const u2* switchData, s4 testVal)
1001 const int kInstrLen = 3;
1007 * Packed switch data format:
1008 * ushort ident = 0x0100 magic value
1009 * ushort size number of entries in the table
1010 * int first_key first (and lowest) switch case value
1011 * int targets[size] branch targets, relative to switch opcode
1013 * Total size is (4+size*2) 16-bit code units.
1015 if (*switchData++ != kPackedSwitchSignature) {
1016 /* should have been caught by verifier */
1017 dvmThrowInternalError("bad packed switch magic");
1021 size = *switchData++;
1024 firstKey = *switchData++;
1025 firstKey |= (*switchData++) << 16;
1027 if (testVal < firstKey || testVal >= firstKey + size) {
1028 LOGVV("Value %d not found in switch (%d-%d)",
1029 testVal, firstKey, firstKey+size-1);
1033 /* The entries are guaranteed to be aligned on a 32-bit boundary;
1034 * we can treat them as a native int array.
1036 entries = (const s4*) switchData;
1037 assert(((u4)entries & 0x3) == 0);
1039 assert(testVal - firstKey >= 0 && testVal - firstKey < size);
1040 LOGVV("Value %d found in slot %d (goto 0x%02x)",
1041 testVal, testVal - firstKey,
1042 s4FromSwitchData(&entries[testVal - firstKey]));
1043 return s4FromSwitchData(&entries[testVal - firstKey]);
1047 * Find the matching case. Returns the offset to the handler instructions.
1049 * Returns 3 if we don't find a match (it's the size of the sparse-switch
1052 s4 dvmInterpHandleSparseSwitch(const u2* switchData, s4 testVal)
1054 const int kInstrLen = 3;
1060 * Sparse switch data format:
1061 * ushort ident = 0x0200 magic value
1062 * ushort size number of entries in the table; > 0
1063 * int keys[size] keys, sorted low-to-high; 32-bit aligned
1064 * int targets[size] branch targets, relative to switch opcode
1066 * Total size is (2+size*4) 16-bit code units.
1069 if (*switchData++ != kSparseSwitchSignature) {
1070 /* should have been caught by verifier */
1071 dvmThrowInternalError("bad sparse switch magic");
1075 size = *switchData++;
1078 /* The keys are guaranteed to be aligned on a 32-bit boundary;
1079 * we can treat them as a native int array.
1081 keys = (const s4*) switchData;
1082 assert(((u4)keys & 0x3) == 0);
1084 /* The entries are guaranteed to be aligned on a 32-bit boundary;
1085 * we can treat them as a native int array.
1087 entries = keys + size;
1088 assert(((u4)entries & 0x3) == 0);
1091 * Binary-search through the array of keys, which are guaranteed to
1092 * be sorted low-to-high.
1097 int mid = (lo + hi) >> 1;
1099 s4 foundVal = s4FromSwitchData(&keys[mid]);
1100 if (testVal < foundVal) {
1102 } else if (testVal > foundVal) {
1105 LOGVV("Value %d found in entry %d (goto 0x%02x)",
1106 testVal, mid, s4FromSwitchData(&entries[mid]));
1107 return s4FromSwitchData(&entries[mid]);
1111 LOGVV("Value %d not found in switch", testVal);
1116 * Copy data for a fill-array-data instruction. On a little-endian machine
1117 * we can just do a memcpy(), on a big-endian system we have work to do.
1119 * The trick here is that dexopt has byte-swapped each code unit, which is
1120 * exactly what we want for short/char data. For byte data we need to undo
1121 * the swap, and for 4- or 8-byte values we need to swap pieces within
1124 static void copySwappedArrayData(void* dest, const u2* src, u4 size, u2 width)
1126 #if __BYTE_ORDER == __LITTLE_ENDIAN
1127 memcpy(dest, src, size*width);
1133 /* un-swap pairs of bytes as we go */
1134 for (i = (size-1) & ~1; i >= 0; i -= 2) {
1135 ((u1*)dest)[i] = ((u1*)src)[i+1];
1136 ((u1*)dest)[i+1] = ((u1*)src)[i];
1139 * "src" is padded to end on a two-byte boundary, but we don't want to
1140 * assume "dest" is, so we handle odd length specially.
1142 if ((size & 1) != 0) {
1143 ((u1*)dest)[size-1] = ((u1*)src)[size];
1147 /* already swapped correctly */
1148 memcpy(dest, src, size*width);
1151 /* swap word halves */
1152 for (i = 0; i < (int) size; i++) {
1153 ((u4*)dest)[i] = (src[(i << 1) + 1] << 16) | src[i << 1];
1157 /* swap word halves and words */
1158 for (i = 0; i < (int) (size << 1); i += 2) {
1159 ((int*)dest)[i] = (src[(i << 1) + 3] << 16) | src[(i << 1) + 2];
1160 ((int*)dest)[i+1] = (src[(i << 1) + 1] << 16) | src[i << 1];
1164 ALOGE("Unexpected width %d in copySwappedArrayData", width);
1172 * Fill the array with predefined constant values.
1174 * Returns true if job is completed, otherwise false to indicate that
1175 * an exception has been thrown.
1177 bool dvmInterpHandleFillArrayData(ArrayObject* arrayObj, const u2* arrayData)
1182 if (arrayObj == NULL) {
1183 dvmThrowNullPointerException(NULL);
1186 assert (!IS_CLASS_FLAG_SET(((Object *)arrayObj)->clazz,
1187 CLASS_ISOBJECTARRAY));
1190 * Array data table format:
1191 * ushort ident = 0x0300 magic value
1192 * ushort width width of each element in the table
1193 * uint size number of elements in the table
1194 * ubyte data[size*width] table of data values (may contain a single-byte
1195 * padding at the end)
1197 * Total size is 4+(width * size + 1)/2 16-bit code units.
1199 if (arrayData[0] != kArrayDataSignature) {
1200 dvmThrowInternalError("bad array data magic");
1204 width = arrayData[1];
1205 size = arrayData[2] | (((u4)arrayData[3]) << 16);
1207 if (size > arrayObj->length) {
1208 dvmThrowArrayIndexOutOfBoundsException(arrayObj->length, size);
1211 copySwappedArrayData(arrayObj->contents, &arrayData[4], size, width);
1216 * Find the concrete method that corresponds to "methodIdx". The code in
1217 * "method" is executing invoke-method with "thisClass" as its first argument.
1219 * Returns NULL with an exception raised on failure.
1221 Method* dvmInterpFindInterfaceMethod(ClassObject* thisClass, u4 methodIdx,
1222 const Method* method, DvmDex* methodClassDex)
1225 Method* methodToCall;
1229 * Resolve the method. This gives us the abstract method from the
1230 * interface class declaration.
1232 absMethod = dvmDexGetResolvedMethod(methodClassDex, methodIdx);
1233 if (absMethod == NULL) {
1234 absMethod = dvmResolveInterfaceMethod(method->clazz, methodIdx);
1235 if (absMethod == NULL) {
1236 ALOGV("+ unknown method");
1241 /* make sure absMethod->methodIndex means what we think it means */
1242 assert(dvmIsAbstractMethod(absMethod));
1245 * Run through the "this" object's iftable. Find the entry for
1246 * absMethod's class, then use absMethod->methodIndex to find
1247 * the method's entry. The value there is the offset into our
1248 * vtable of the actual method to execute.
1250 * The verifier does not guarantee that objects stored into
1251 * interface references actually implement the interface, so this
1252 * check cannot be eliminated.
1254 for (i = 0; i < thisClass->iftableCount; i++) {
1255 if (thisClass->iftable[i].clazz == absMethod->clazz)
1258 if (i == thisClass->iftableCount) {
1259 /* impossible in verified DEX, need to check for it in unverified */
1260 dvmThrowIncompatibleClassChangeError("interface not implemented");
1264 assert(absMethod->methodIndex <
1265 thisClass->iftable[i].clazz->virtualMethodCount);
1268 thisClass->iftable[i].methodIndexArray[absMethod->methodIndex];
1269 assert(vtableIndex >= 0 && vtableIndex < thisClass->vtableCount);
1270 methodToCall = thisClass->vtable[vtableIndex];
1273 /* this can happen when there's a stale class file */
1274 if (dvmIsAbstractMethod(methodToCall)) {
1275 dvmThrowAbstractMethodError("interface method not implemented");
1279 assert(!dvmIsAbstractMethod(methodToCall) ||
1280 methodToCall->nativeFunc != NULL);
1283 LOGVV("+++ interface=%s.%s concrete=%s.%s",
1284 absMethod->clazz->descriptor, absMethod->name,
1285 methodToCall->clazz->descriptor, methodToCall->name);
1286 assert(methodToCall != NULL);
1288 return methodToCall;
1294 * Helpers for dvmThrowVerificationError().
1296 * Each returns a newly-allocated string.
1298 #define kThrowShow_accessFromClass 1
1299 static std::string classNameFromIndex(const Method* method, int ref,
1300 VerifyErrorRefType refType, int flags)
1302 const DvmDex* pDvmDex = method->clazz->pDvmDex;
1303 if (refType == VERIFY_ERROR_REF_FIELD) {
1304 /* get class ID from field ID */
1305 const DexFieldId* pFieldId = dexGetFieldId(pDvmDex->pDexFile, ref);
1306 ref = pFieldId->classIdx;
1307 } else if (refType == VERIFY_ERROR_REF_METHOD) {
1308 /* get class ID from method ID */
1309 const DexMethodId* pMethodId = dexGetMethodId(pDvmDex->pDexFile, ref);
1310 ref = pMethodId->classIdx;
1313 const char* className = dexStringByTypeIdx(pDvmDex->pDexFile, ref);
1314 std::string dotClassName(dvmHumanReadableDescriptor(className));
1316 return dotClassName;
1320 if ((flags & kThrowShow_accessFromClass) != 0) {
1321 result += "tried to access class " + dotClassName;
1322 result += " from class " + dvmHumanReadableDescriptor(method->clazz->descriptor);
1324 assert(false); // should've been caught above
1329 static std::string fieldNameFromIndex(const Method* method, int ref,
1330 VerifyErrorRefType refType, int flags)
1332 if (refType != VERIFY_ERROR_REF_FIELD) {
1333 ALOGW("Expected ref type %d, got %d", VERIFY_ERROR_REF_FIELD, refType);
1334 return NULL; /* no message */
1337 const DvmDex* pDvmDex = method->clazz->pDvmDex;
1338 const DexFieldId* pFieldId = dexGetFieldId(pDvmDex->pDexFile, ref);
1339 const char* className = dexStringByTypeIdx(pDvmDex->pDexFile, pFieldId->classIdx);
1340 const char* fieldName = dexStringById(pDvmDex->pDexFile, pFieldId->nameIdx);
1342 std::string dotName(dvmHumanReadableDescriptor(className));
1344 if ((flags & kThrowShow_accessFromClass) != 0) {
1346 result += "tried to access field ";
1347 result += dotName + "." + fieldName;
1348 result += " from class ";
1349 result += dvmHumanReadableDescriptor(method->clazz->descriptor);
1352 return dotName + "." + fieldName;
1354 static std::string methodNameFromIndex(const Method* method, int ref,
1355 VerifyErrorRefType refType, int flags)
1357 if (refType != VERIFY_ERROR_REF_METHOD) {
1358 ALOGW("Expected ref type %d, got %d", VERIFY_ERROR_REF_METHOD,refType);
1359 return NULL; /* no message */
1362 const DvmDex* pDvmDex = method->clazz->pDvmDex;
1363 const DexMethodId* pMethodId = dexGetMethodId(pDvmDex->pDexFile, ref);
1364 const char* className = dexStringByTypeIdx(pDvmDex->pDexFile, pMethodId->classIdx);
1365 const char* methodName = dexStringById(pDvmDex->pDexFile, pMethodId->nameIdx);
1367 std::string dotName(dvmHumanReadableDescriptor(className));
1369 if ((flags & kThrowShow_accessFromClass) != 0) {
1370 char* desc = dexProtoCopyMethodDescriptor(&method->prototype);
1372 result += "tried to access method ";
1373 result += dotName + "." + methodName + ":" + desc;
1374 result += " from class " + dvmHumanReadableDescriptor(method->clazz->descriptor);
1378 return dotName + "." + methodName;
1382 * Throw an exception for a problem identified by the verifier.
1384 * This is used by the invoke-verification-error instruction. It always
1385 * throws an exception.
1387 * "kind" indicates the kind of failure encountered by the verifier. It
1388 * has two parts, an error code and an indication of the reference type.
1390 void dvmThrowVerificationError(const Method* method, int kind, int ref)
1392 int errorPart = kind & ~(0xff << kVerifyErrorRefTypeShift);
1393 int errorRefPart = kind >> kVerifyErrorRefTypeShift;
1394 VerifyError errorKind = static_cast<VerifyError>(errorPart);
1395 VerifyErrorRefType refType = static_cast<VerifyErrorRefType>(errorRefPart);
1396 ClassObject* exceptionClass = gDvm.exVerifyError;
1399 switch ((VerifyError) errorKind) {
1400 case VERIFY_ERROR_NO_CLASS:
1401 exceptionClass = gDvm.exNoClassDefFoundError;
1402 msg = classNameFromIndex(method, ref, refType, 0);
1404 case VERIFY_ERROR_NO_FIELD:
1405 exceptionClass = gDvm.exNoSuchFieldError;
1406 msg = fieldNameFromIndex(method, ref, refType, 0);
1408 case VERIFY_ERROR_NO_METHOD:
1409 exceptionClass = gDvm.exNoSuchMethodError;
1410 msg = methodNameFromIndex(method, ref, refType, 0);
1412 case VERIFY_ERROR_ACCESS_CLASS:
1413 exceptionClass = gDvm.exIllegalAccessError;
1414 msg = classNameFromIndex(method, ref, refType,
1415 kThrowShow_accessFromClass);
1417 case VERIFY_ERROR_ACCESS_FIELD:
1418 exceptionClass = gDvm.exIllegalAccessError;
1419 msg = fieldNameFromIndex(method, ref, refType,
1420 kThrowShow_accessFromClass);
1422 case VERIFY_ERROR_ACCESS_METHOD:
1423 exceptionClass = gDvm.exIllegalAccessError;
1424 msg = methodNameFromIndex(method, ref, refType,
1425 kThrowShow_accessFromClass);
1427 case VERIFY_ERROR_CLASS_CHANGE:
1428 exceptionClass = gDvm.exIncompatibleClassChangeError;
1429 msg = classNameFromIndex(method, ref, refType, 0);
1431 case VERIFY_ERROR_INSTANTIATION:
1432 exceptionClass = gDvm.exInstantiationError;
1433 msg = classNameFromIndex(method, ref, refType, 0);
1436 case VERIFY_ERROR_GENERIC:
1437 /* generic VerifyError; use default exception, no message */
1439 case VERIFY_ERROR_NONE:
1440 /* should never happen; use default exception */
1442 msg = "weird - no error specified";
1445 /* no default clause -- want warning if enum updated */
1448 dvmThrowException(exceptionClass, msg.c_str());
1452 * Update interpBreak for a single thread.
1454 void updateInterpBreak(Thread* thread, ExecutionSubModes subMode, bool enable)
1456 InterpBreak oldValue, newValue;
1458 oldValue = newValue = thread->interpBreak;
1459 newValue.ctl.breakFlags = kInterpNoBreak; // Assume full reset
1461 newValue.ctl.subMode |= subMode;
1463 newValue.ctl.subMode &= ~subMode;
1464 if (newValue.ctl.subMode & SINGLESTEP_BREAK_MASK)
1465 newValue.ctl.breakFlags |= kInterpSingleStep;
1466 if (newValue.ctl.subMode & SAFEPOINT_BREAK_MASK)
1467 newValue.ctl.breakFlags |= kInterpSafePoint;
1468 #ifndef DVM_NO_ASM_INTERP
1469 newValue.ctl.curHandlerTable = (newValue.ctl.breakFlags) ?
1470 thread->altHandlerTable : thread->mainHandlerTable;
1472 } while (dvmQuasiAtomicCas64(oldValue.all, newValue.all,
1473 &thread->interpBreak.all) != 0);
1477 * Update interpBreak for all threads.
1479 void updateAllInterpBreak(ExecutionSubModes subMode, bool enable)
1481 Thread* self = dvmThreadSelf();
1484 dvmLockThreadList(self);
1485 for (thread = gDvm.threadList; thread != NULL; thread = thread->next) {
1486 updateInterpBreak(thread, subMode, enable);
1488 dvmUnlockThreadList();
1492 * Update the normal and debugger suspend counts for a thread.
1493 * threadSuspendCount must be acquired before calling this to
1494 * ensure a clean update of suspendCount, dbgSuspendCount and
1495 * sumThreadSuspendCount.
1497 * CLEANUP TODO: Currently only the JIT is using sumThreadSuspendCount.
1498 * Move under WITH_JIT ifdefs.
1500 void dvmAddToSuspendCounts(Thread* thread, int delta, int dbgDelta)
1502 thread->suspendCount += delta;
1503 thread->dbgSuspendCount += dbgDelta;
1504 updateInterpBreak(thread, kSubModeSuspendPending,
1505 (thread->suspendCount != 0));
1506 // Update the global suspend count total
1507 gDvm.sumThreadSuspendCount += delta;
1511 void dvmDisableSubMode(Thread* thread, ExecutionSubModes subMode)
1513 updateInterpBreak(thread, subMode, false);
1516 void dvmEnableSubMode(Thread* thread, ExecutionSubModes subMode)
1518 updateInterpBreak(thread, subMode, true);
1521 void dvmEnableAllSubMode(ExecutionSubModes subMode)
1523 updateAllInterpBreak(subMode, true);
1526 void dvmDisableAllSubMode(ExecutionSubModes subMode)
1528 updateAllInterpBreak(subMode, false);
1532 * Do a sanity check on interpreter state saved to Thread.
1533 * A failure here doesn't necessarily mean that something is wrong,
1534 * so this code should only be used during development to suggest
1535 * a possible problem.
1537 void dvmCheckInterpStateConsistency()
1539 Thread* self = dvmThreadSelf();
1543 #ifndef DVM_NO_ASM_INTERP
1547 dvmLockThreadList(self);
1548 breakFlags = self->interpBreak.ctl.breakFlags;
1549 subMode = self->interpBreak.ctl.subMode;
1550 #ifndef DVM_NO_ASM_INTERP
1551 handlerTable = self->interpBreak.ctl.curHandlerTable;
1553 for (thread = gDvm.threadList; thread != NULL; thread = thread->next) {
1554 if (subMode != thread->interpBreak.ctl.subMode) {
1555 ALOGD("Warning: subMode mismatch - %#x:%#x, tid[%d]",
1556 subMode,thread->interpBreak.ctl.subMode,thread->threadId);
1558 if (breakFlags != thread->interpBreak.ctl.breakFlags) {
1559 ALOGD("Warning: breakFlags mismatch - %#x:%#x, tid[%d]",
1560 breakFlags,thread->interpBreak.ctl.breakFlags,thread->threadId);
1562 #ifndef DVM_NO_ASM_INTERP
1563 if (handlerTable != thread->interpBreak.ctl.curHandlerTable) {
1564 ALOGD("Warning: curHandlerTable mismatch - %#x:%#x, tid[%d]",
1565 (int)handlerTable,(int)thread->interpBreak.ctl.curHandlerTable,
1569 #if defined(WITH_JIT)
1570 if (thread->pJitProfTable != gDvmJit.pProfTable) {
1571 ALOGD("Warning: pJitProfTable mismatch - %#x:%#x, tid[%d]",
1572 (int)thread->pJitProfTable,(int)gDvmJit.pProfTable,
1575 if (thread->jitThreshold != gDvmJit.threshold) {
1576 ALOGD("Warning: jitThreshold mismatch - %#x:%#x, tid[%d]",
1577 (int)thread->jitThreshold,(int)gDvmJit.threshold,
1582 dvmUnlockThreadList();
1586 * Arm a safepoint callback for a thread. If funct is null,
1587 * clear any pending callback.
1588 * TODO: only gc is currently using this feature, and will have
1589 * at most a single outstanding callback request. Until we need
1590 * something more capable and flexible, enforce this limit.
1592 void dvmArmSafePointCallback(Thread* thread, SafePointCallback funct,
1595 dvmLockMutex(&thread->callbackMutex);
1596 if ((funct == NULL) || (thread->callback == NULL)) {
1597 thread->callback = funct;
1598 thread->callbackArg = arg;
1599 if (funct != NULL) {
1600 dvmEnableSubMode(thread, kSubModeCallbackPending);
1602 dvmDisableSubMode(thread, kSubModeCallbackPending);
1605 // Already armed. Different?
1606 if ((funct != thread->callback) ||
1607 (arg != thread->callbackArg)) {
1608 // Yes - report failure and die
1609 ALOGE("ArmSafePointCallback failed, thread %d", thread->threadId);
1610 dvmUnlockMutex(&thread->callbackMutex);
1614 dvmUnlockMutex(&thread->callbackMutex);
1618 * One-time initialization at thread creation. Here we initialize
1621 void dvmInitInterpreterState(Thread* self)
1623 #if defined(WITH_JIT)
1625 * Reserve a static entity here to quickly setup runtime contents as
1626 * gcc will issue block copy instructions.
1628 static struct JitToInterpEntries jitToInterpEntries = {
1629 dvmJitToInterpNormal,
1630 dvmJitToInterpNoChain,
1632 dvmJitToInterpSingleStep,
1633 dvmJitToInterpTraceSelect,
1634 #if defined(WITH_SELF_VERIFICATION)
1635 dvmJitToInterpBackwardBranch,
1642 // Begin initialization
1643 self->cardTable = gDvm.biasedCardTableBase;
1644 #if defined(WITH_JIT)
1645 // One-time initializations
1646 self->jitToInterpEntries = jitToInterpEntries;
1647 self->icRechainCount = PREDICTED_CHAIN_COUNTER_RECHAIN;
1648 self->pProfileCountdown = &gDvmJit.profileCountdown;
1649 // Jit state that can change
1650 dvmJitUpdateThreadStateSingle(self);
1652 dvmInitializeInterpBreak(self);
1656 * For a newly-created thread, we need to start off with interpBreak
1657 * set to any existing global modes. The caller must hold the
1660 void dvmInitializeInterpBreak(Thread* thread)
1662 if (gDvm.instructionCountEnableCount > 0) {
1663 dvmEnableSubMode(thread, kSubModeInstCounting);
1665 if (dvmIsMethodTraceActive()) {
1666 dvmEnableSubMode(thread, kSubModeMethodTrace);
1668 if (gDvm.emulatorTraceEnableCount > 0) {
1669 dvmEnableSubMode(thread, kSubModeEmulatorTrace);
1671 if (gDvm.debuggerActive) {
1672 dvmEnableSubMode(thread, kSubModeDebuggerActive);
1675 // Debugging stress mode - force checkBefore
1676 dvmEnableSubMode(thread, kSubModeCheckAlways);
1681 * Inter-instruction handler invoked in between instruction interpretations
1682 * to handle exceptional events such as debugging housekeeping, instruction
1683 * count profiling, JIT trace building, etc. Dalvik PC has been exported
1684 * prior to call, but Thread copy of dPC & fp are not current.
1686 void dvmCheckBefore(const u2 *pc, u4 *fp, Thread* self)
1688 const Method* method = self->interpSave.method;
1689 assert(pc >= method->insns && pc <
1690 method->insns + dvmGetMethodInsnsSize(method));
1694 * When we hit a specific method, enable verbose instruction logging.
1695 * Sometimes it's helpful to use the debugger attach as a trigger too.
1697 if (*pIsMethodEntry) {
1698 static const char* cd = "Landroid/test/Arithmetic;";
1699 static const char* mn = "shiftTest2";
1700 static const char* sg = "()V";
1702 if (/*self->interpBreak.ctl.subMode & kSubModeDebuggerActive &&*/
1703 strcmp(method->clazz->descriptor, cd) == 0 &&
1704 strcmp(method->name, mn) == 0 &&
1705 strcmp(method->shorty, sg) == 0)
1707 ALOGW("Reached %s.%s, enabling verbose mode",
1708 method->clazz->descriptor, method->name);
1709 android_setMinPriority(LOG_TAG"i", ANDROID_LOG_VERBOSE);
1710 dumpRegs(method, fp, true);
1713 if (!gDvm.debuggerActive)
1714 *pIsMethodEntry = false;
1718 /* Safe point handling */
1719 if (self->suspendCount ||
1720 (self->interpBreak.ctl.subMode & kSubModeCallbackPending)) {
1721 // Are we are a safe point?
1723 flags = dexGetFlagsFromOpcode(dexOpcodeFromCodeUnit(*pc));
1724 if (flags & (VERIFY_GC_INST_MASK & ~kInstrCanThrow)) {
1725 // Yes, at a safe point. Pending callback?
1726 if (self->interpBreak.ctl.subMode & kSubModeCallbackPending) {
1727 SafePointCallback callback;
1729 // Get consistent funct/arg pair
1730 dvmLockMutex(&self->callbackMutex);
1731 callback = self->callback;
1732 arg = self->callbackArg;
1733 dvmUnlockMutex(&self->callbackMutex);
1734 // Update Thread structure
1735 self->interpSave.pc = pc;
1736 self->interpSave.curFrame = fp;
1737 if (callback != NULL) {
1739 if (!callback(self,arg)) {
1741 dvmArmSafePointCallback(self, NULL, NULL);
1746 if (self->suspendCount) {
1747 dvmExportPC(pc, fp);
1748 dvmCheckSuspendPending(self);
1753 if (self->interpBreak.ctl.subMode & kSubModeDebuggerActive) {
1754 updateDebugger(method, pc, fp, self);
1756 if (gDvm.instructionCountEnableCount != 0) {
1758 * Count up the #of executed instructions. This isn't synchronized
1759 * for thread-safety; if we need that we should make this
1760 * thread-local and merge counts into the global area when threads
1761 * exit (perhaps suspending all other threads GC-style and pulling
1762 * the data out of them).
1764 gDvm.executedInstrCounts[GET_OPCODE(*pc)]++;
1768 #if defined(WITH_TRACKREF_CHECKS)
1769 dvmInterpCheckTrackedRefs(self, method,
1770 self->interpSave.debugTrackedRefStart);
1773 #if defined(WITH_JIT)
1774 // Does the JIT need anything done now?
1775 if (self->interpBreak.ctl.subMode &
1776 (kSubModeJitTraceBuild | kSubModeJitSV)) {
1777 // Are we building a trace?
1778 if (self->interpBreak.ctl.subMode & kSubModeJitTraceBuild) {
1779 dvmCheckJit(pc, self);
1782 #if defined(WITH_SELF_VERIFICATION)
1783 // Are we replaying a trace?
1784 if (self->interpBreak.ctl.subMode & kSubModeJitSV) {
1785 dvmCheckSelfVerification(pc, self);
1792 * CountedStep processing. NOTE: must be the last here to allow
1793 * preceeding special case handler to manipulate single-step count.
1795 if (self->interpBreak.ctl.subMode & kSubModeCountedStep) {
1796 if (self->singleStepCount == 0) {
1797 // We've exhausted our single step count
1798 dvmDisableSubMode(self, kSubModeCountedStep);
1799 #if defined(WITH_JIT)
1802 * For debugging. If jitResumeDPC is non-zero, then
1803 * we expect to return to a trace in progress. There
1804 * are valid reasons why we wouldn't (such as an exception
1805 * throw), but here we can keep track.
1807 if (self->jitResumeDPC != NULL) {
1808 if (self->jitResumeDPC == pc) {
1809 if (self->jitResumeNPC != NULL) {
1810 ALOGD("SS return to trace - pc:%#x to 0x:%x",
1811 (int)pc, (int)self->jitResumeNPC);
1813 ALOGD("SS return to interp - pc:%#x",(int)pc);
1816 ALOGD("SS failed to return. Expected %#x, now at %#x",
1817 (int)self->jitResumeDPC, (int)pc);
1822 // TODO - fix JIT single-stepping resume mode (b/5551114)
1823 // self->jitResumeNPC needs to be cleared in callPrep
1825 // If we've got a native return and no other reasons to
1826 // remain in singlestep/break mode, do a long jump
1827 if (self->jitResumeNPC != NULL &&
1828 self->interpBreak.ctl.breakFlags == 0) {
1829 assert(self->jitResumeDPC == pc);
1830 self->jitResumeDPC = NULL;
1831 dvmJitResumeTranslation(self, pc, fp);
1835 // In case resume is blocked by non-zero breakFlags, clear
1836 // jitResumeNPC here.
1837 self->jitResumeNPC = NULL;
1838 self->jitResumeDPC = NULL;
1839 self->inJitCodeCache = NULL;
1843 self->singleStepCount--;
1844 #if defined(WITH_JIT)
1845 if ((self->singleStepCount > 0) && (self->jitResumeNPC != NULL)) {
1847 * Direct return to an existing translation following a
1848 * single step is valid only if we step once. If we're
1849 * here, an additional step was added so we need to invalidate
1850 * the return to translation.
1852 self->jitResumeNPC = NULL;
1853 self->inJitCodeCache = NULL;
1861 * Main interpreter loop entry point.
1863 * This begins executing code at the start of "method". On exit, "pResult"
1864 * holds the return value of the method (or, if "method" returns NULL, it
1865 * holds an undefined value).
1867 * The interpreted stack frame, which holds the method arguments, has
1868 * already been set up.
1870 void dvmInterpret(Thread* self, const Method* method, JValue* pResult)
1872 InterpSaveState interpSaveState;
1873 ExecutionSubModes savedSubModes;
1875 #if defined(WITH_JIT)
1876 /* Target-specific save/restore */
1877 double calleeSave[JIT_CALLEE_SAVE_DOUBLE_COUNT];
1879 * If the previous VM left the code cache through single-stepping the
1880 * inJitCodeCache flag will be set when the VM is re-entered (for example,
1881 * in self-verification mode we single-step NEW_INSTANCE which may re-enter
1882 * the VM through findClassFromLoaderNoInit). Because of that, we cannot
1883 * assert that self->inJitCodeCache is NULL here.
1888 * Save interpreter state from previous activation, linking
1891 interpSaveState = self->interpSave;
1892 self->interpSave.prev = &interpSaveState;
1894 * Strip out and save any flags that should not be inherited by
1895 * nested interpreter activation.
1897 savedSubModes = (ExecutionSubModes)(
1898 self->interpBreak.ctl.subMode & LOCAL_SUBMODE);
1899 if (savedSubModes != kSubModeNormal) {
1900 dvmDisableSubMode(self, savedSubModes);
1902 #if defined(WITH_JIT)
1903 dvmJitCalleeSave(calleeSave);
1907 #if defined(WITH_TRACKREF_CHECKS)
1908 self->interpSave.debugTrackedRefStart =
1909 dvmReferenceTableEntries(&self->internalLocalRefTable);
1911 self->debugIsMethodEntry = true;
1912 #if defined(WITH_JIT)
1913 dvmJitCalleeSave(calleeSave);
1914 /* Initialize the state to kJitNot */
1915 self->jitState = kJitNot;
1919 * Initialize working state.
1921 * No need to initialize "retval".
1923 self->interpSave.method = method;
1924 self->interpSave.curFrame = (u4*) self->interpSave.curFrame;
1925 self->interpSave.pc = method->insns;
1927 assert(!dvmIsNativeMethod(method));
1930 * Make sure the class is ready to go. Shouldn't be possible to get
1933 if (method->clazz->status < CLASS_INITIALIZING ||
1934 method->clazz->status == CLASS_ERROR)
1936 ALOGE("ERROR: tried to execute code in unprepared class '%s' (%d)",
1937 method->clazz->descriptor, method->clazz->status);
1938 dvmDumpThread(self, false);
1942 typedef void (*Interpreter)(Thread*);
1943 Interpreter stdInterp;
1944 if (gDvm.executionMode == kExecutionModeInterpFast)
1945 stdInterp = dvmMterpStd;
1946 #if defined(WITH_JIT)
1947 else if (gDvm.executionMode == kExecutionModeJit ||
1948 gDvm.executionMode == kExecutionModeNcgO0 ||
1949 gDvm.executionMode == kExecutionModeNcgO1)
1950 stdInterp = dvmMterpStd;
1953 stdInterp = dvmInterpretPortable;
1955 // Call the interpreter
1958 *pResult = self->interpSave.retval;
1960 /* Restore interpreter state from previous activation */
1961 self->interpSave = interpSaveState;
1962 #if defined(WITH_JIT)
1963 dvmJitCalleeRestore(calleeSave);
1965 if (savedSubModes != kSubModeNormal) {
1966 dvmEnableSubMode(self, savedSubModes);