static void tryInlineSingletonCallsite(CompilationUnit *cUnit,
const Method *calleeMethod,
MIR *invokeMIR,
BasicBlock *invokeBB,
bool isRange)
{
/* Not a Java method */
if (dvmIsNativeMethod(calleeMethod)) return;
CompilerMethodStats *methodStats =
dvmCompilerAnalyzeMethodBody(calleeMethod, true);
/* Empty callee - do nothing */
if (methodStats->attributes & METHOD_IS_EMPTY) {
/* The original invoke instruction is effectively turned into NOP */
invokeMIR->OptimizationFlags |= MIR_INLINED;
/*
* Need to insert an explicit branch to catch the falling knife (into
* the PC reconstruction or chaining cell).
*/
invokeBB->needFallThroughBranch = true;
return;
}
if (methodStats->attributes & METHOD_IS_GETTER) {
inlineGetter(cUnit, calleeMethod, invokeMIR, invokeBB, false, isRange);
return;
} else if (methodStats->attributes & METHOD_IS_SETTER) {
inlineSetter(cUnit, calleeMethod, invokeMIR, invokeBB, false, isRange);
return;
}
}
static void tryInlineVirtualCallsite(CompilationUnit *cUnit,
const Method *calleeMethod,
MIR *invokeMIR,
BasicBlock *invokeBB,
bool isRange)
{
/* Not a Java method */
if (dvmIsNativeMethod(calleeMethod)) return;
CompilerMethodStats *methodStats =
dvmCompilerAnalyzeMethodBody(calleeMethod, true);
/* Empty callee - do nothing by checking the clazz pointer */
if (methodStats->attributes & METHOD_IS_EMPTY) {
inlineEmptyVirtualCallee(cUnit, calleeMethod, invokeMIR, invokeBB);
return;
}
if (methodStats->attributes & METHOD_IS_GETTER) {
inlineGetter(cUnit, calleeMethod, invokeMIR, invokeBB, true, isRange);
return;
} else if (methodStats->attributes & METHOD_IS_SETTER) {
inlineSetter(cUnit, calleeMethod, invokeMIR, invokeBB, true, isRange);
return;
}
}
/*
* Pop one frame pushed on by JNI PushLocalFrame.
*
* If we've gone too far, the previous frame is either a break frame or
* an interpreted frame. Either way, the method pointer won't match.
*/
bool dvmPopLocalFrame(Thread* self)
{
StackSaveArea* saveBlock = SAVEAREA_FROM_FP(self->interpSave.curFrame);
assert(!dvmIsBreakFrame((u4*)self->interpSave.curFrame));
if (saveBlock->method != SAVEAREA_FROM_FP(saveBlock->prevFrame)->method) {
/*
* The previous frame doesn't have the same method pointer -- we've
* been asked to pop too much.
*/
assert(dvmIsBreakFrame((u4*)saveBlock->prevFrame) ||
!dvmIsNativeMethod(
SAVEAREA_FROM_FP(saveBlock->prevFrame)->method));
return false;
}
LOGVV("POP JNI local frame: removing %s, now %s",
saveBlock->method->name,
SAVEAREA_FROM_FP(saveBlock->prevFrame)->method->name);
dvmPopJniLocals(self, saveBlock);
self->interpSave.curFrame = saveBlock->prevFrame;
#ifdef WITH_OFFLOAD
offStackFramePopped(self);
#endif
return true;
}
/*
* This is used by the JNI PushLocalFrame call. We push a new frame onto
* the stack that has no ins, outs, or locals, and no break frame above it.
* It's strictly used for tracking JNI local refs, and will be popped off
* by dvmPopFrame if it's not removed explicitly.
*/
bool dvmPushLocalFrame(Thread* self, const Method* method)
{
StackSaveArea* saveBlock;
int stackReq;
u1* stackPtr;
assert(dvmIsNativeMethod(method));
stackReq = sizeof(StackSaveArea); // regular frame
assert(self->curFrame != NULL);
stackPtr = (u1*) SAVEAREA_FROM_FP(self->curFrame);
if (stackPtr - stackReq < self->interpStackEnd) {
/* not enough space; let JNI throw the exception */
LOGW("Stack overflow on PushLocal "
"(req=%d top=%p cur=%p size=%d '%s')\n",
stackReq, self->interpStackStart, self->curFrame,
self->interpStackSize, method->name);
dvmHandleStackOverflow(self, method);
assert(dvmCheckException(self));
return false;
}
/*
* Shift the stack pointer down, leaving space for just the stack save
* area for the break frame, then shift down farther for the full frame.
*/
stackPtr -= sizeof(StackSaveArea);
saveBlock = (StackSaveArea*) stackPtr;
#if !defined(NDEBUG) && !defined(PAD_SAVE_AREA)
/* debug -- memset the new stack */
memset(stackPtr, 0xaf, stackReq);
#endif
#ifdef EASY_GDB
saveBlock->prevSave = FP_FROM_SAVEAREA(self->curFrame);
#endif
saveBlock->prevFrame = self->curFrame;
saveBlock->savedPc = NULL; // not required
#ifdef USE_INDIRECT_REF
saveBlock->xtra.localRefCookie = self->jniLocalRefTable.segmentState.all;
#else
saveBlock->xtra.localRefCookie = self->jniLocalRefTable.nextEntry;
#endif
saveBlock->method = method;
LOGVV("PUSH JNI local frame: old=%p new=%p (size=%d)\n",
self->curFrame, FP_FROM_SAVEAREA(saveBlock),
(u1*)self->curFrame - (u1*)FP_FROM_SAVEAREA(saveBlock));
self->curFrame = FP_FROM_SAVEAREA(saveBlock);
return true;
}
bool HookDalvikMethod(jmethodID jmethod){
Method *method = (Method*)jmethod;
//关键!!将目标方法修改为native方法
SET_METHOD_FLAG(method, ACC_NATIVE);
int argsSize = dvmComputeMethodArgsSize(method);
if (!dvmIsStaticMethod(method))
argsSize++;
method->registersSize = method->insSize = argsSize;
if (dvmIsNativeMethod(method)) {
method->nativeFunc = dvmResolveNativeMethod;
method->jniArgInfo = computeJniArgInfo(&method->prototype);
}
}
/*
* Pop a frame we added. There should be one method frame and one break
* frame.
*
* If JNI Push/PopLocalFrame calls were mismatched, we might end up
* popping multiple method frames before we find the break.
*
* Returns "false" if there was no frame to pop.
*/
static bool dvmPopFrame(Thread* self)
{
StackSaveArea* saveBlock;
if (self->interpSave.curFrame == NULL)
return false;
saveBlock = SAVEAREA_FROM_FP(self->interpSave.curFrame);
assert(!dvmIsBreakFrame((u4*)self->interpSave.curFrame));
/*
* Remove everything up to the break frame. If this was a call into
* native code, pop the JNI local references table.
*/
while (saveBlock->prevFrame != NULL && saveBlock->method != NULL) {
/* probably a native->native JNI call */
if (dvmIsNativeMethod(saveBlock->method)) {
LOGVV("Popping JNI stack frame for %s.%s%s",
saveBlock->method->clazz->descriptor,
saveBlock->method->name,
(SAVEAREA_FROM_FP(saveBlock->prevFrame)->method == NULL) ?
"" : " (JNI local)");
dvmPopJniLocals(self, saveBlock);
}
saveBlock = SAVEAREA_FROM_FP(saveBlock->prevFrame);
}
if (saveBlock->method != NULL) {
ALOGE("PopFrame missed the break");
assert(false);
dvmAbort(); // stack trashed -- nowhere to go in this thread
}
LOGVV("POP frame: cur=%p new=%p",
self->interpSave.curFrame, saveBlock->prevFrame);
self->interpSave.curFrame = saveBlock->prevFrame;
#ifdef WITH_OFFLOAD
offStackFramePopped(self);
self->breakFrames--;
CHECK_BREAK_FRAMES();
#endif
return true;
}
/*
* Pop a frame we added. There should be one method frame and one break
* frame.
*
* If JNI Push/PopLocalFrame calls were mismatched, we might end up
* popping multiple method frames before we find the break.
*
* Returns "false" if there was no frame to pop.
*/
static bool dvmPopFrame(Thread* self)
{
StackSaveArea* saveBlock;
if (self->curFrame == NULL)
return false;
saveBlock = SAVEAREA_FROM_FP(self->curFrame);
assert(!dvmIsBreakFrame(self->curFrame));
/*
* Remove everything up to the break frame. If this was a call into
* native code, pop the JNI local references table.
*/
while (saveBlock->prevFrame != NULL && saveBlock->method != NULL) {
/* probably a native->native JNI call */
if (dvmIsNativeMethod(saveBlock->method)) {
LOGVV("Popping JNI stack frame for %s.%s%s\n",
saveBlock->method->clazz->descriptor,
saveBlock->method->name,
(SAVEAREA_FROM_FP(saveBlock->prevFrame)->method == NULL) ?
"" : " (JNI local)");
assert(saveBlock->xtra.localRefCookie != 0);
//assert(saveBlock->xtra.localRefCookie >= self->jniLocalRefTable.table &&
// saveBlock->xtra.localRefCookie <=self->jniLocalRefTable.nextEntry);
dvmPopJniLocals(self, saveBlock);
}
saveBlock = SAVEAREA_FROM_FP(saveBlock->prevFrame);
}
if (saveBlock->method != NULL) {
LOGE("PopFrame missed the break\n");
assert(false);
dvmAbort(); // stack trashed -- nowhere to go in this thread
}
LOGVV("POP frame: cur=%p new=%p\n",
self->curFrame, saveBlock->prevFrame);
self->curFrame = saveBlock->prevFrame;
return true;
}
/**
* @brief 遍历dalvik栈
* @param thread 线程结构指针
* @param print 是否打印
*/
static void crawlDalvikStack(Thread *thread, bool print)
{
void *fp = thread->interpSave.curFrame; /* 获取栈指针 */
StackSaveArea* saveArea = NULL;
int stackLevel = 0;
if (print) {
ALOGD("Crawling tid %d (%s / %p %s)", thread->systemTid,
dvmGetThreadStatusStr(thread->status),
thread->inJitCodeCache,
thread->inJitCodeCache ? "jit" : "interp");
}
/* Crawl the Dalvik stack frames to clear the returnAddr field */
/* 遍历清除返回地址字段 */
while (fp != NULL) {
saveArea = SAVEAREA_FROM_FP(fp); /* 取出一个单元 */
if (print) {
if (dvmIsBreakFrame((u4*)fp)) {
ALOGD(" #%d: break frame (%p)",
stackLevel, saveArea->returnAddr);
}
else {
ALOGD(" #%d: %s.%s%s (%p)",
stackLevel,
saveArea->method->clazz->descriptor,
saveArea->method->name,
dvmIsNativeMethod(saveArea->method) ?
" (native)" : "",
saveArea->returnAddr);
}
}
stackLevel++;
saveArea->returnAddr = NULL; /* 设置返回值为NULL */
assert(fp != saveArea->prevFrame);
fp = saveArea->prevFrame;
}
/* Make sure the stack is fully unwound to the bottom */
assert(saveArea == NULL ||
(u1 *) (saveArea+1) == thread->interpStackStart);
}
/*
* Dump the contents of a raw stack trace to the log.
*/
void dvmLogRawStackTrace(const int* intVals, int stackDepth)
{
int i;
/*
* Run through the array of stack frame data.
*/
for (i = 0; i < stackDepth; i++) {
Method* meth;
int lineNumber, pc;
const char* sourceFile;
char* dotName;
meth = (Method*) *intVals++;
pc = *intVals++;
if (pc == -1) // broken top frame?
lineNumber = 0;
else
lineNumber = dvmLineNumFromPC(meth, pc);
// probably don't need to do this, but it looks nicer
dotName = dvmDescriptorToDot(meth->clazz->descriptor);
if (dvmIsNativeMethod(meth)) {
LOGI("\tat %s.%s(Native Method)\n", dotName, meth->name);
} else {
LOGI("\tat %s.%s(%s:%d)\n",
dotName, meth->name, dvmGetMethodSourceFile(meth),
dvmLineNumFromPC(meth, pc));
}
free(dotName);
sourceFile = dvmGetMethodSourceFile(meth);
}
}
/*
* Determine the source file line number based on the program counter.
* "pc" is an offset, in 16-bit units, from the start of the method's code.
*
* Returns -1 if no match was found (possibly because the source files were
* compiled without "-g", so no line number information is present).
* Returns -2 for native methods (as expected in exception traces).
*/
int dvmLineNumFromPC(const Method* method, u4 relPc)
{
const DexCode* pDexCode = dvmGetMethodCode(method);
if (pDexCode == NULL) {
if (dvmIsNativeMethod(method) && !dvmIsAbstractMethod(method))
return -2;
return -1; /* can happen for abstract method stub */
}
LineNumFromPcContext context;
memset(&context, 0, sizeof(context));
context.address = relPc;
// A method with no line number info should return -1
context.lineNum = -1;
dexDecodeDebugInfo(method->clazz->pDvmDex->pDexFile, pDexCode,
method->clazz->descriptor,
method->prototype.protoIdx,
method->accessFlags,
lineNumForPcCb, NULL, &context);
return context.lineNum;
}
/*
* We're calling a JNI native method from an internal VM fuction or
* via reflection. This is also used to create the "fake" native-method
* frames at the top of the interpreted stack.
*
* This actually pushes two frames; the first is a "break" frame.
*
* The top frame has additional space for JNI local reference tracking.
*/
bool dvmPushJNIFrame(Thread* self, const Method* method)
{
StackSaveArea* saveBlock;
StackSaveArea* breakSaveBlock;
int stackReq;
u1* stackPtr;
assert(dvmIsNativeMethod(method));
stackReq = method->registersSize * 4 // params only
+ sizeof(StackSaveArea) * 2; // break frame + regular frame
if (self->interpSave.curFrame != NULL)
stackPtr = (u1*) SAVEAREA_FROM_FP(self->interpSave.curFrame);
else
stackPtr = self->interpStackStart;
if (stackPtr - stackReq < self->interpStackEnd) {
/* not enough space */
ALOGW("Stack overflow on call to native "
"(req=%d top=%p cur=%p size=%d '%s')",
stackReq, self->interpStackStart, self->interpSave.curFrame,
self->interpStackSize, method->name);
dvmHandleStackOverflow(self, method);
assert(dvmCheckException(self));
return false;
}
/*
* Shift the stack pointer down, leaving space for just the stack save
* area for the break frame, then shift down farther for the full frame.
* We leave space for the method args, which are copied in later.
*/
stackPtr -= sizeof(StackSaveArea);
breakSaveBlock = (StackSaveArea*)stackPtr;
stackPtr -= method->registersSize * 4 + sizeof(StackSaveArea);
saveBlock = (StackSaveArea*) stackPtr;
#if !defined(NDEBUG) && !defined(PAD_SAVE_AREA)
/* debug -- memset the new stack */
memset(stackPtr, 0xaf, stackReq);
#endif
#ifdef EASY_GDB
if (self->interpSave.curFrame == NULL)
breakSaveBlock->prevSave = NULL;
else {
void* fp = FP_FROM_SAVEAREA(self->interpSave.curFrame);
breakSaveBlock->prevSave = (StackSaveArea*)fp;
}
saveBlock->prevSave = breakSaveBlock;
#endif
breakSaveBlock->prevFrame = self->interpSave.curFrame;
breakSaveBlock->savedPc = NULL; // not required
breakSaveBlock->xtra.localRefCookie = 0; // not required
breakSaveBlock->method = NULL;
saveBlock->prevFrame = FP_FROM_SAVEAREA(breakSaveBlock);
saveBlock->savedPc = NULL; // not required
saveBlock->xtra.localRefCookie = self->jniLocalRefTable.segmentState.all;
saveBlock->method = method;
LOGVV("PUSH JNI frame: old=%p new=%p (size=%d)",
self->interpSave.curFrame, FP_FROM_SAVEAREA(saveBlock),
(u1*)self->interpSave.curFrame - (u1*)FP_FROM_SAVEAREA(saveBlock));
self->interpSave.curFrame = FP_FROM_SAVEAREA(saveBlock);
return true;
}
/*
* Dump stack frames, starting from the specified frame and moving down.
*
* Each frame holds a pointer to the currently executing method, and the
* saved program counter from the caller ("previous" frame). This means
* we don't have the PC for the current method on the stack, which is
* pretty reasonable since it's in the "PC register" for the VM. Because
* exceptions need to show the correct line number we actually *do* have
* an updated version in the fame's "xtra.currentPc", but it's unreliable.
*
* Note "framePtr" could be NULL in rare circumstances.
*/
static void dumpFrames(const DebugOutputTarget* target, void* framePtr,
Thread* thread)
{
const StackSaveArea* saveArea;
const Method* method;
int checkCount = 0;
const u2* currentPc = NULL;
bool first = true;
/*
* We call functions that require us to be holding the thread list lock.
* It's probable that the caller has already done so, but it's not
* guaranteed. If it's not locked, lock it now.
*/
bool needThreadUnlock = dvmTryLockThreadList();
/*
* The "currentPc" is updated whenever we execute an instruction that
* might throw an exception. Show it here.
*/
if (framePtr != NULL && !dvmIsBreakFrame((u4*)framePtr)) {
saveArea = SAVEAREA_FROM_FP(framePtr);
if (saveArea->xtra.currentPc != NULL)
currentPc = saveArea->xtra.currentPc;
}
while (framePtr != NULL) {
saveArea = SAVEAREA_FROM_FP(framePtr);
method = saveArea->method;
if (dvmIsBreakFrame((u4*)framePtr)) {
//dvmPrintDebugMessage(target, " (break frame)\n");
} else {
int relPc;
if (currentPc != NULL)
relPc = currentPc - saveArea->method->insns;
else
relPc = -1;
std::string methodName(dvmHumanReadableMethod(method, false));
if (dvmIsNativeMethod(method)) {
dvmPrintDebugMessage(target, " at %s(Native Method)\n",
methodName.c_str());
} else {
dvmPrintDebugMessage(target, " at %s(%s:%s%d)\n",
methodName.c_str(), dvmGetMethodSourceFile(method),
(relPc >= 0 && first) ? "~" : "",
relPc < 0 ? -1 : dvmLineNumFromPC(method, relPc));
}
if (first) {
/*
* Decorate WAIT and MONITOR threads with some detail on
* the first frame.
*
* warning: wait status not stable, even in suspend
*/
if (thread->status == THREAD_WAIT ||
thread->status == THREAD_TIMED_WAIT)
{
Monitor* mon = thread->waitMonitor;
Object* obj = dvmGetMonitorObject(mon);
if (obj != NULL) {
Thread* joinThread = NULL;
if (obj->clazz == gDvm.classJavaLangVMThread) {
joinThread = dvmGetThreadFromThreadObject(obj);
}
if (joinThread == NULL) {
joinThread = dvmGetObjectLockHolder(obj);
}
printWaitMessage(target, "on", obj, joinThread);
}
} else if (thread->status == THREAD_MONITOR) {
Object* obj;
Thread* owner;
if (extractMonitorEnterObject(thread, &obj, &owner)) {
printWaitMessage(target, "to lock", obj, owner);
}
}
}
}
/*
* Get saved PC for previous frame. There's no savedPc in a "break"
* frame, because that represents native or interpreted code
* invoked by the VM. The saved PC is sitting in the "PC register",
* a local variable on the native stack.
*/
currentPc = saveArea->savedPc;
first = false;
if (saveArea->prevFrame != NULL && saveArea->prevFrame <= framePtr) {
ALOGW("Warning: loop in stack trace at frame %d (%p -> %p)",
checkCount, framePtr, saveArea->prevFrame);
break;
}
framePtr = saveArea->prevFrame;
checkCount++;
if (checkCount > 300) {
dvmPrintDebugMessage(target,
" ***** printed %d frames, not showing any more\n",
checkCount);
break;
}
}
if (needThreadUnlock) {
dvmUnlockThreadList();
}
}
void
hprofFillInStackTrace(void *objectPtr)
{
DvmHeapChunk *chunk;
StackTraceEntry stackTraceEntry;
Thread* self;
void* fp;
int i;
if (objectPtr == NULL) {
return;
}
self = dvmThreadSelf();
if (self == NULL) {
return;
}
fp = self->curFrame;
/* Serial number to be filled in later. */
stackTraceEntry.trace.serialNumber = -1;
/*
* TODO - The HAT tool doesn't care about thread data, so we can defer
* actually emitting thread records and assigning thread serial numbers.
*/
stackTraceEntry.trace.threadSerialNumber = (int) self;
memset(&stackTraceEntry.trace.frameIds, 0,
sizeof(stackTraceEntry.trace.frameIds));
i = 0;
while ((fp != NULL) && (i < STACK_DEPTH)) {
const StackSaveArea* saveArea = SAVEAREA_FROM_FP(fp);
const Method* method = saveArea->method;
StackFrameEntry frame;
if (!dvmIsBreakFrame(fp)) {
frame.frame.method = method;
if (dvmIsNativeMethod(method)) {
frame.frame.pc = 0; /* no saved PC for native methods */
} else {
assert(saveArea->xtra.currentPc >= method->insns &&
saveArea->xtra.currentPc <
method->insns + dvmGetMethodInsnsSize(method));
frame.frame.pc = (int) (saveArea->xtra.currentPc -
method->insns);
}
// Canonicalize the frame and cache it in the hprof context
stackTraceEntry.trace.frameIds[i++] =
hprofLookupStackFrameId(&frame);
}
assert(fp != saveArea->prevFrame);
fp = saveArea->prevFrame;
}
/* Store the stack trace serial number in the object header */
chunk = ptr2chunk(objectPtr);
chunk->stackTraceSerialNumber =
hprofLookupStackSerialNumber(&stackTraceEntry);
}
/*
* Update the debugger on interesting events, such as hitting a breakpoint
* or a single-step point. This is called from the top of the interpreter
* loop, before the current instruction is processed.
*
* Set "methodEntry" if we've just entered the method. This detects
* method exit by checking to see if the next instruction is "return".
*
* This can't catch native method entry/exit, so we have to handle that
* at the point of invocation. We also need to catch it in dvmCallMethod
* if we want to capture native->native calls made through JNI.
*
* Notes to self:
* - Don't want to switch to VMWAIT while posting events to the debugger.
* Let the debugger code decide if we need to change state.
* - We may want to check for debugger-induced thread suspensions on
* every instruction. That would make a "suspend all" more responsive
* and reduce the chances of multiple simultaneous events occurring.
* However, it could change the behavior some.
*
* TODO: method entry/exit events are probably less common than location
* breakpoints. We may be able to speed things up a bit if we don't query
* the event list unless we know there's at least one lurking within.
*/
static void updateDebugger(const Method* method, const u2* pc, const u4* fp,
bool methodEntry, Thread* self)
{
int eventFlags = 0;
/*
* Update xtra.currentPc on every instruction. We need to do this if
* there's a chance that we could get suspended. This can happen if
* eventFlags != 0 here, or somebody manually requests a suspend
* (which gets handled at PERIOD_CHECKS time). One place where this
* needs to be correct is in dvmAddSingleStep().
*/
EXPORT_PC();
if (methodEntry)
eventFlags |= DBG_METHOD_ENTRY;
/*
* See if we have a breakpoint here.
*
* Depending on the "mods" associated with event(s) on this address,
* we may or may not actually send a message to the debugger.
*/
#ifdef WITH_DEBUGGER
if (INST_INST(*pc) == OP_BREAKPOINT) {
LOGV("+++ breakpoint hit at %p\n", pc);
eventFlags |= DBG_BREAKPOINT;
}
#endif
/*
* If the debugger is single-stepping one of our threads, check to
* see if we're that thread and we've reached a step point.
*/
const StepControl* pCtrl = &gDvm.stepControl;
if (pCtrl->active && pCtrl->thread == self) {
int line, frameDepth;
bool doStop = false;
const char* msg = NULL;
assert(!dvmIsNativeMethod(method));
if (pCtrl->depth == SD_INTO) {
/*
* Step into method calls. We break when the line number
* or method pointer changes. If we're in SS_MIN mode, we
* always stop.
*/
if (pCtrl->method != method) {
doStop = true;
msg = "new method";
} else if (pCtrl->size == SS_MIN) {
doStop = true;
msg = "new instruction";
} else if (!dvmAddressSetGet(
pCtrl->pAddressSet, pc - method->insns)) {
doStop = true;
msg = "new line";
}
} else if (pCtrl->depth == SD_OVER) {
/*
* Step over method calls. We break when the line number is
* different and the frame depth is <= the original frame
* depth. (We can't just compare on the method, because we
* might get unrolled past it by an exception, and it's tricky
* to identify recursion.)
*/
frameDepth = dvmComputeVagueFrameDepth(self, fp);
if (frameDepth < pCtrl->frameDepth) {
/* popped up one or more frames, always trigger */
doStop = true;
msg = "method pop";
} else if (frameDepth == pCtrl->frameDepth) {
/* same depth, see if we moved */
if (pCtrl->size == SS_MIN) {
doStop = true;
msg = "new instruction";
} else if (!dvmAddressSetGet(pCtrl->pAddressSet,
pc - method->insns)) {
doStop = true;
msg = "new line";
}
}
} else {
assert(pCtrl->depth == SD_OUT);
/*
* Return from the current method. We break when the frame
* depth pops up.
*
* This differs from the "method exit" break in that it stops
* with the PC at the next instruction in the returned-to
* function, rather than the end of the returning function.
*/
frameDepth = dvmComputeVagueFrameDepth(self, fp);
if (frameDepth < pCtrl->frameDepth) {
doStop = true;
msg = "method pop";
}
}
if (doStop) {
LOGV("#####S %s\n", msg);
eventFlags |= DBG_SINGLE_STEP;
}
}
/*
* Check to see if this is a "return" instruction. JDWP says we should
* send the event *after* the code has been executed, but it also says
* the location we provide is the last instruction. Since the "return"
* instruction has no interesting side effects, we should be safe.
* (We can't just move this down to the returnFromMethod label because
* we potentially need to combine it with other events.)
*
* We're also not supposed to generate a method exit event if the method
* terminates "with a thrown exception".
*/
u2 inst = INST_INST(FETCH(0));
if (inst == OP_RETURN_VOID || inst == OP_RETURN || inst == OP_RETURN_WIDE ||
inst == OP_RETURN_OBJECT)
{
eventFlags |= DBG_METHOD_EXIT;
}
/*
* If there's something interesting going on, see if it matches one
* of the debugger filters.
*/
if (eventFlags != 0) {
Object* thisPtr = dvmGetThisPtr(method, fp);
if (thisPtr != NULL && !dvmIsValidObject(thisPtr)) {
/*
* TODO: remove this check if we're confident that the "this"
* pointer is where it should be -- slows us down, especially
* during single-step.
*/
char* desc = dexProtoCopyMethodDescriptor(&method->prototype);
LOGE("HEY: invalid 'this' ptr %p (%s.%s %s)\n", thisPtr,
method->clazz->descriptor, method->name, desc);
free(desc);
dvmAbort();
}
dvmDbgPostLocationEvent(method, pc - method->insns, thisPtr,
eventFlags);
}
}
/*
* Issue a method call with arguments provided in an array. We process
* the contents of "args" by scanning the method signature.
*
* The values were likely placed into an uninitialized jvalue array using
* the field specifiers, which means that sub-32-bit fields (e.g. short,
* boolean) may not have 32 or 64 bits of valid data. This is different
* from the varargs invocation where the C compiler does a widening
* conversion when calling a function. As a result, we have to be a
* little more precise when pulling stuff out.
*
* "args" may be NULL if the method has no arguments.
*/
void dvmCallMethodA(Thread* self, const Method* method, Object* obj,
bool fromJni, JValue* pResult, const jvalue* args)
{
const char* desc = &(method->shorty[1]); // [0] is the return type.
int verifyCount = 0;
ClassObject* clazz;
u4* ins;
#ifdef WITH_TAINT_TRACKING
int slot_cnt = 0;
bool nativeTarget = dvmIsNativeMethod(method);
#endif
clazz = callPrep(self, method, obj, false);
if (clazz == NULL)
return;
/* "ins" for new frame start at frame pointer plus locals */
#ifdef WITH_TAINT_TRACKING
if (nativeTarget) {
/* native target, no taint tag interleaving */
ins = ((u4*)self->curFrame) + (method->registersSize - method->insSize);
} else {
/* interpreted target, taint tags are interleaved */
ins = ((u4*)self->curFrame) +
((method->registersSize - method->insSize) << 1);
}
#else
ins = ((u4*)self->curFrame) + (method->registersSize - method->insSize);
#endif
/* put "this" pointer into in0 if appropriate */
if (!dvmIsStaticMethod(method)) {
assert(obj != NULL);
*ins++ = (u4) obj; /* obj is a "real" ref */
#ifdef WITH_TAINT_TRACKING
if (!nativeTarget) {
*ins++ = TAINT_CLEAR;
}
slot_cnt++;
#endif
verifyCount++;
}
JNIEnv* env = self->jniEnv;
while (*desc != '\0') {
switch (*desc++) {
case 'D': /* 64-bit quantity; have to use */
case 'J': /* memcpy() in case of mis-alignment */
memcpy(ins, &args->j, 8);
#ifdef WITH_TAINT_TRACKING
if (nativeTarget) {
ins += 2;
} else { /* adjust for taint tag interleaving */
ins[2] = ins[1];
ins[1] = TAINT_CLEAR;
ins[3] = TAINT_CLEAR;
ins += 4;
}
slot_cnt += 2;
#else
ins += 2;
#endif
verifyCount++; /* this needs an extra push */
break;
case 'L': /* includes array refs */
if (fromJni)
*ins++ = (u4) dvmDecodeIndirectRef(env, args->l);
else
*ins++ = (u4) args->l;
#ifdef WITH_TAINT_TRACKING
if (!nativeTarget) {
*ins++ = TAINT_CLEAR;
}
slot_cnt++;
#endif
break;
case 'F':
case 'I':
*ins++ = args->i; /* full 32 bits */
#ifdef WITH_TAINT_TRACKING
if (!nativeTarget) {
*ins++ = TAINT_CLEAR;
}
slot_cnt++;
#endif
break;
case 'S':
*ins++ = args->s; /* 16 bits, sign-extended */
#ifdef WITH_TAINT_TRACKING
if (!nativeTarget) {
*ins++ = TAINT_CLEAR;
}
slot_cnt++;
#endif
break;
case 'C':
*ins++ = args->c; /* 16 bits, unsigned */
#ifdef WITH_TAINT_TRACKING
if (!nativeTarget) {
*ins++ = TAINT_CLEAR;
}
slot_cnt++;
#endif
break;
case 'B':
*ins++ = args->b; /* 8 bits, sign-extended */
#ifdef WITH_TAINT_TRACKING
if (!nativeTarget) {
*ins++ = TAINT_CLEAR;
}
slot_cnt++;
#endif
break;
case 'Z':
*ins++ = args->z; /* 8 bits, zero or non-zero */
#ifdef WITH_TAINT_TRACKING
if (!nativeTarget) {
*ins++ = TAINT_CLEAR;
}
slot_cnt++;
#endif
break;
default:
LOGE("Invalid char %c in short signature of %s.%s\n",
*(desc-1), clazz->descriptor, method->name);
assert(false);
goto bail;
}
verifyCount++;
args++;
}
#ifdef WITH_TAINT_TRACKING
/* native hack spacer */
*ins++ = TAINT_CLEAR; /* if nativeTarget, this is return taint */
{
int i;
if (nativeTarget) {
for (i = 0; i < slot_cnt; i++) {
*ins++ = TAINT_CLEAR;
}
}
}
#endif
#ifndef NDEBUG
if (verifyCount != method->insSize) {
LOGE("Got vfycount=%d insSize=%d for %s.%s\n", verifyCount,
method->insSize, clazz->descriptor, method->name);
assert(false);
goto bail;
}
#endif
if (dvmIsNativeMethod(method)) {
TRACE_METHOD_ENTER(self, method);
/*
* Because we leave no space for local variables, "curFrame" points
* directly at the method arguments.
*/
(*method->nativeFunc)(self->curFrame, pResult, method, self);
TRACE_METHOD_EXIT(self, method);
} else {
#ifdef WITH_TAINT_TRACKING
u4 rtaint; /* not used */
dvmInterpret(self, method, pResult, &rtaint);
#else
dvmInterpret(self, method, pResult);
#endif
}
bail:
dvmPopFrame(self);
}
/*
* Invoke a method, using the specified arguments and return type, through
* one of the reflection interfaces. Could be a virtual or direct method
* (including constructors). Used for reflection.
*
* Deals with boxing/unboxing primitives and performs widening conversions.
*
* "invokeObj" will be null for a static method.
*
* If the invocation returns with an exception raised, we have to wrap it.
*/
Object* dvmInvokeMethod(Object* obj, const Method* method,
ArrayObject* argList, ArrayObject* params, ClassObject* returnType,
bool noAccessCheck)
{
//salma
// __android_log_print(ANDROID_LOG_DEBUG, "DVM DEBUG", "dvmInvokeMethod method name = %s\n,clazz name: %s", method->name, method->clazz->descriptor);
//end salma
ClassObject* clazz;
Object* retObj = NULL;
Thread* self = dvmThreadSelf();
s4* ins;
int verifyCount, argListLength;
JValue retval;
bool needPop = false;
/* verify arg count */
if (argList != NULL)
argListLength = argList->length;
else
argListLength = 0;
if (argListLength != (int) params->length) {
dvmThrowExceptionFmt(gDvm.exIllegalArgumentException,
"wrong number of arguments; expected %d, got %d",
params->length, argListLength);
return NULL;
}
clazz = callPrep(self, method, obj, !noAccessCheck);
if (clazz == NULL)
return NULL;
needPop = true;
/* "ins" for new frame start at frame pointer plus locals */
ins = ((s4*)self->interpSave.curFrame) +
(method->registersSize - method->insSize);
verifyCount = 0;
//ALOGD(" FP is %p, INs live at >= %p", self->interpSave.curFrame, ins);
/* put "this" pointer into in0 if appropriate */
if (!dvmIsStaticMethod(method)) {
assert(obj != NULL);
*ins++ = (s4) obj;
verifyCount++;
}
/*
* Copy the args onto the stack. Primitive types are converted when
* necessary, and object types are verified.
*/
DataObject** args = (DataObject**)(void*)argList->contents;
ClassObject** types = (ClassObject**)(void*)params->contents;
for (int i = 0; i < argListLength; i++) {
int width = dvmConvertArgument(*args++, *types++, ins);
if (width < 0) {
dvmPopFrame(self); // throw wants to pull PC out of stack
needPop = false;
throwArgumentTypeMismatch(i, *(types-1), *(args-1));
goto bail;
}
ins += width;
verifyCount += width;
}
#ifndef NDEBUG
if (verifyCount != method->insSize) {
ALOGE("Got vfycount=%d insSize=%d for %s.%s", verifyCount,
method->insSize, clazz->descriptor, method->name);
assert(false);
goto bail;
}
#endif
if (dvmIsNativeMethod(method)) {
TRACE_METHOD_ENTER(self, method);
/*
* Because we leave no space for local variables, "curFrame" points
* directly at the method arguments.
*/
(*method->nativeFunc)((u4*)self->interpSave.curFrame, &retval,
method, self);
TRACE_METHOD_EXIT(self, method);
} else {
dvmInterpret(self, method, &retval);
}
/*
* Pop the frame immediately. The "wrap" calls below can cause
* allocations, and we don't want the GC to walk the now-dead frame.
*/
dvmPopFrame(self);
needPop = false;
/*
* If an exception is raised, wrap and replace. This is necessary
* because the invoked method could have thrown a checked exception
* that the caller wasn't prepared for.
*
* We might be able to do this up in the interpreted code, but that will
* leave us with a shortened stack trace in the top-level exception.
*/
if (dvmCheckException(self)) {
dvmWrapException("Ljava/lang/reflect/InvocationTargetException;");
} else {
/*
* If this isn't a void method or constructor, convert the return type
* to an appropriate object.
*
* We don't do this when an exception is raised because the value
* in "retval" is undefined.
*/
if (returnType != NULL) {
retObj = (Object*)dvmBoxPrimitive(retval, returnType);
dvmReleaseTrackedAlloc(retObj, NULL);
}
}
bail:
if (needPop) {
dvmPopFrame(self);
}
return retObj;
}
/*
* Issue a method call with arguments provided in an array. We process
* the contents of "args" by scanning the method signature.
*
* The values were likely placed into an uninitialized jvalue array using
* the field specifiers, which means that sub-32-bit fields (e.g. short,
* boolean) may not have 32 or 64 bits of valid data. This is different
* from the varargs invocation where the C compiler does a widening
* conversion when calling a function. As a result, we have to be a
* little more precise when pulling stuff out.
*
* "args" may be NULL if the method has no arguments.
*/
void dvmCallMethodA(Thread* self, const Method* method, Object* obj,
bool fromJni, JValue* pResult, const jvalue* args)
{
//salma
// __android_log_print(ANDROID_LOG_DEBUG, "DVM DEBUG", "dvmCallMethodA method name = %s, clazz name: %s", method->name, method->clazz->descriptor);
//end salma
const char* desc = &(method->shorty[1]); // [0] is the return type.
int verifyCount = 0;
ClassObject* clazz;
u4* ins;
clazz = callPrep(self, method, obj, false);
if (clazz == NULL)
return;
/* "ins" for new frame start at frame pointer plus locals */
ins = ((u4*)self->interpSave.curFrame) +
(method->registersSize - method->insSize);
/* put "this" pointer into in0 if appropriate */
if (!dvmIsStaticMethod(method)) {
assert(obj != NULL);
*ins++ = (u4) obj; /* obj is a "real" ref */
verifyCount++;
}
while (*desc != '\0') {
switch (*desc++) {
case 'D': /* 64-bit quantity; have to use */
case 'J': /* memcpy() in case of mis-alignment */
memcpy(ins, &args->j, 8);
ins += 2;
verifyCount++; /* this needs an extra push */
break;
case 'L': /* includes array refs */
if (fromJni)
*ins++ = (u4) dvmDecodeIndirectRef(self, args->l);
else
*ins++ = (u4) args->l;
break;
case 'F':
case 'I':
*ins++ = args->i; /* full 32 bits */
break;
case 'S':
*ins++ = args->s; /* 16 bits, sign-extended */
break;
case 'C':
*ins++ = args->c; /* 16 bits, unsigned */
break;
case 'B':
*ins++ = args->b; /* 8 bits, sign-extended */
break;
case 'Z':
*ins++ = args->z; /* 8 bits, zero or non-zero */
break;
default:
ALOGE("Invalid char %c in short signature of %s.%s",
*(desc-1), clazz->descriptor, method->name);
assert(false);
goto bail;
}
verifyCount++;
args++;
}
#ifndef NDEBUG
if (verifyCount != method->insSize) {
ALOGE("Got vfycount=%d insSize=%d for %s.%s", verifyCount,
method->insSize, clazz->descriptor, method->name);
assert(false);
goto bail;
}
#endif
if (dvmIsNativeMethod(method)) {
TRACE_METHOD_ENTER(self, method);
/*
* Because we leave no space for local variables, "curFrame" points
* directly at the method arguments.
*/
(*method->nativeFunc)((u4*)self->interpSave.curFrame, pResult,
method, self);
TRACE_METHOD_EXIT(self, method);
} else {
dvmInterpret(self, method, pResult);
}
bail:
dvmPopFrame(self);
}
/*
* Invoke a method, using the specified arguments and return type, through
* one of the reflection interfaces. Could be a virtual or direct method
* (including constructors). Used for reflection.
*
* Deals with boxing/unboxing primitives and performs widening conversions.
*
* "invokeObj" will be null for a static method.
*
* If the invocation returns with an exception raised, we have to wrap it.
*/
Object* dvmInvokeMethod(Object* obj, const Method* method,
ArrayObject* argList, ArrayObject* params, ClassObject* returnType,
bool noAccessCheck)
{
ClassObject* clazz;
Object* retObj = NULL;
Thread* self = dvmThreadSelf();
s4* ins;
int verifyCount, argListLength;
JValue retval;
/* verify arg count */
if (argList != NULL)
argListLength = argList->length;
else
argListLength = 0;
if (argListLength != (int) params->length) {
LOGI("invoke: expected %d args, received %d args\n",
params->length, argListLength);
dvmThrowException("Ljava/lang/IllegalArgumentException;",
"wrong number of arguments");
return NULL;
}
clazz = callPrep(self, method, obj, !noAccessCheck);
if (clazz == NULL)
return NULL;
/* "ins" for new frame start at frame pointer plus locals */
ins = ((s4*)self->curFrame) + (method->registersSize - method->insSize);
verifyCount = 0;
//LOGD(" FP is %p, INs live at >= %p\n", self->curFrame, ins);
/* put "this" pointer into in0 if appropriate */
if (!dvmIsStaticMethod(method)) {
assert(obj != NULL);
*ins++ = (s4) obj;
verifyCount++;
}
/*
* Copy the args onto the stack. Primitive types are converted when
* necessary, and object types are verified.
*/
DataObject** args;
ClassObject** types;
int i;
args = (DataObject**) argList->contents;
types = (ClassObject**) params->contents;
for (i = 0; i < argListLength; i++) {
int width;
width = dvmConvertArgument(*args++, *types++, ins);
if (width < 0) {
if (*(args-1) != NULL) {
LOGV("invoke: type mismatch on arg %d ('%s' '%s')\n",
i, (*(args-1))->obj.clazz->descriptor,
(*(types-1))->descriptor);
}
dvmPopFrame(self); // throw wants to pull PC out of stack
dvmThrowException("Ljava/lang/IllegalArgumentException;",
"argument type mismatch");
goto bail_popped;
}
ins += width;
verifyCount += width;
}
if (verifyCount != method->insSize) {
LOGE("Got vfycount=%d insSize=%d for %s.%s\n", verifyCount,
method->insSize, clazz->descriptor, method->name);
assert(false);
goto bail;
}
//dvmDumpThreadStack(dvmThreadSelf());
if (dvmIsNativeMethod(method)) {
#ifdef WITH_PROFILER
TRACE_METHOD_ENTER(self, method);
#endif
/*
* Because we leave no space for local variables, "curFrame" points
* directly at the method arguments.
*/
(*method->nativeFunc)(self->curFrame, &retval, method, self);
#ifdef WITH_PROFILER
TRACE_METHOD_EXIT(self, method);
#endif
} else {
dvmInterpret(self, method, &retval);
}
/*
* If an exception is raised, wrap and replace. This is necessary
* because the invoked method could have thrown a checked exception
* that the caller wasn't prepared for.
*
* We might be able to do this up in the interpreted code, but that will
* leave us with a shortened stack trace in the top-level exception.
*/
if (dvmCheckException(self)) {
dvmWrapException("Ljava/lang/reflect/InvocationTargetException;");
} else {
/*
* If this isn't a void method or constructor, convert the return type
* to an appropriate object.
*
* We don't do this when an exception is raised because the value
* in "retval" is undefined.
*/
if (returnType != NULL) {
retObj = (Object*)dvmWrapPrimitive(retval, returnType);
dvmReleaseTrackedAlloc(retObj, NULL);
}
}
bail:
dvmPopFrame(self);
bail_popped:
return retObj;
}
/*
* We have to carry the exception's stack trace around, but in many cases
* it will never be examined. It makes sense to keep it in a compact,
* VM-specific object, rather than an array of Objects with strings.
*
* Pass in the thread whose stack we're interested in. If "thread" is
* not self, the thread must be suspended. This implies that the thread
* list lock is held, which means we can't allocate objects or we risk
* jamming the GC. So, we allow this function to return different formats.
* (This shouldn't be called directly -- see the inline functions in the
* header file.)
*
* If "wantObject" is true, this returns a newly-allocated Object, which is
* presently an array of integers, but could become something else in the
* future. If "wantObject" is false, return plain malloc data.
*
* NOTE: if we support class unloading, we will need to scan the class
* object references out of these arrays.
*/
void* dvmFillInStackTraceInternal(Thread* thread, bool wantObject, int* pCount)
{
ArrayObject* stackData = NULL;
int* simpleData = NULL;
void* fp;
void* startFp;
int stackDepth;
int* intPtr;
if (pCount != NULL)
*pCount = 0;
fp = thread->curFrame;
assert(thread == dvmThreadSelf() || dvmIsSuspended(thread));
/*
* We're looking at a stack frame for code running below a Throwable
* constructor. We want to remove the Throwable methods and the
* superclass initializations so the user doesn't see them when they
* read the stack dump.
*
* TODO: this just scrapes off the top layers of Throwable. Might not do
* the right thing if we create an exception object or cause a VM
* exception while in a Throwable method.
*/
while (fp != NULL) {
const StackSaveArea* saveArea = SAVEAREA_FROM_FP(fp);
const Method* method = saveArea->method;
if (dvmIsBreakFrame(fp))
break;
if (!dvmInstanceof(method->clazz, gDvm.classJavaLangThrowable))
break;
//LOGD("EXCEP: ignoring %s.%s\n",
// method->clazz->descriptor, method->name);
fp = saveArea->prevFrame;
}
startFp = fp;
/*
* Compute the stack depth.
*/
stackDepth = 0;
while (fp != NULL) {
const StackSaveArea* saveArea = SAVEAREA_FROM_FP(fp);
if (!dvmIsBreakFrame(fp))
stackDepth++;
assert(fp != saveArea->prevFrame);
fp = saveArea->prevFrame;
}
//LOGD("EXCEP: stack depth is %d\n", stackDepth);
if (!stackDepth)
goto bail;
/*
* We need to store a pointer to the Method and the program counter.
* We have 4-byte pointers, so we use '[I'.
*/
if (wantObject) {
assert(sizeof(Method*) == 4);
stackData = dvmAllocPrimitiveArray('I', stackDepth*2, ALLOC_DEFAULT);
if (stackData == NULL) {
assert(dvmCheckException(dvmThreadSelf()));
goto bail;
}
intPtr = (int*) stackData->contents;
} else {
/* array of ints; first entry is stack depth */
assert(sizeof(Method*) == sizeof(int));
simpleData = (int*) malloc(sizeof(int) * stackDepth*2);
if (simpleData == NULL)
goto bail;
assert(pCount != NULL);
intPtr = simpleData;
}
if (pCount != NULL)
*pCount = stackDepth;
fp = startFp;
while (fp != NULL) {
const StackSaveArea* saveArea = SAVEAREA_FROM_FP(fp);
const Method* method = saveArea->method;
if (!dvmIsBreakFrame(fp)) {
//LOGD("EXCEP keeping %s.%s\n", method->clazz->descriptor,
// method->name);
*intPtr++ = (int) method;
if (dvmIsNativeMethod(method)) {
*intPtr++ = 0; /* no saved PC for native methods */
} else {
assert(saveArea->xtra.currentPc >= method->insns &&
saveArea->xtra.currentPc <
method->insns + dvmGetMethodInsnsSize(method));
*intPtr++ = (int) (saveArea->xtra.currentPc - method->insns);
}
stackDepth--; // for verification
}
assert(fp != saveArea->prevFrame);
fp = saveArea->prevFrame;
}
assert(stackDepth == 0);
bail:
if (wantObject) {
dvmReleaseTrackedAlloc((Object*) stackData, dvmThreadSelf());
return stackData;
} else {
return simpleData;
}
}
/*
* Dump stack frames, starting from the specified frame and moving down.
*
* Each frame holds a pointer to the currently executing method, and the
* saved program counter from the caller ("previous" frame). This means
* we don't have the PC for the current method on the stack, which is
* pretty reasonable since it's in the "PC register" for the VM. Because
* exceptions need to show the correct line number we actually *do* have
* an updated version in the fame's "xtra.currentPc", but it's unreliable.
*
* Note "framePtr" could be NULL in rare circumstances.
*/
static void dumpFrames(const DebugOutputTarget* target, void* framePtr,
Thread* thread)
{
const StackSaveArea* saveArea;
const Method* method;
int checkCount = 0;
const u2* currentPc = NULL;
bool first = true;
/*
* The "currentPc" is updated whenever we execute an instruction that
* might throw an exception. Show it here.
*/
if (framePtr != NULL && !dvmIsBreakFrame(framePtr)) {
saveArea = SAVEAREA_FROM_FP(framePtr);
if (saveArea->xtra.currentPc != NULL)
currentPc = saveArea->xtra.currentPc;
}
while (framePtr != NULL) {
saveArea = SAVEAREA_FROM_FP(framePtr);
method = saveArea->method;
if (dvmIsBreakFrame(framePtr)) {
//dvmPrintDebugMessage(target, " (break frame)\n");
} else {
int relPc;
if (currentPc != NULL)
relPc = currentPc - saveArea->method->insns;
else
relPc = -1;
char* className = dvmDescriptorToDot(method->clazz->descriptor);
if (dvmIsNativeMethod(method))
dvmPrintDebugMessage(target,
" at %s.%s(Native Method)\n", className, method->name);
else {
dvmPrintDebugMessage(target,
" at %s.%s(%s:%s%d)\n",
className, method->name, dvmGetMethodSourceFile(method),
(relPc >= 0 && first) ? "~" : "",
relPc < 0 ? -1 : dvmLineNumFromPC(method, relPc));
}
free(className);
if (first) {
/*
* Decorate WAIT and MONITOR threads with some detail on
* the first frame.
*
* warning: wait status not stable, even in suspend
*/
if (thread->status == THREAD_WAIT ||
thread->status == THREAD_TIMED_WAIT)
{
Monitor* mon = thread->waitMonitor;
Object* obj = dvmGetMonitorObject(mon);
if (obj != NULL) {
className = dvmDescriptorToDot(obj->clazz->descriptor);
dvmPrintDebugMessage(target,
" - waiting on <%p> (a %s)\n", obj, className);
free(className);
}
} else if (thread->status == THREAD_MONITOR) {
Object* obj;
Thread* owner;
if (extractMonitorEnterObject(thread, &obj, &owner)) {
className = dvmDescriptorToDot(obj->clazz->descriptor);
if (owner != NULL) {
char* threadName = dvmGetThreadName(owner);
dvmPrintDebugMessage(target,
" - waiting to lock <%p> (a %s) held by threadid=%d (%s)\n",
obj, className, owner->threadId, threadName);
free(threadName);
} else {
dvmPrintDebugMessage(target,
" - waiting to lock <%p> (a %s) held by ???\n",
obj, className);
}
free(className);
}
}
}
}
/*
* Get saved PC for previous frame. There's no savedPc in a "break"
* frame, because that represents native or interpreted code
* invoked by the VM. The saved PC is sitting in the "PC register",
* a local variable on the native stack.
*/
currentPc = saveArea->savedPc;
first = false;
if (saveArea->prevFrame != NULL && saveArea->prevFrame <= framePtr) {
LOGW("Warning: loop in stack trace at frame %d (%p -> %p)\n",
checkCount, framePtr, saveArea->prevFrame);
break;
}
framePtr = saveArea->prevFrame;
checkCount++;
if (checkCount > 300) {
dvmPrintDebugMessage(target,
" ***** printed %d frames, not showing any more\n",
checkCount);
break;
}
}
dvmPrintDebugMessage(target, "\n");
}
/*
* Optimize instructions in a method.
*
* This does a single pass through the code, examining each instruction.
*
* This is not expected to fail if the class was successfully verified.
* The only significant failure modes on unverified code occur when an
* "essential" update fails, but we can't generally identify those: if we
* can't look up a field, we can't know if the field access was supposed
* to be handled as volatile.
*
* Instead, we give it our best effort, and hope for the best. For 100%
* reliability, only optimize a class after verification succeeds.
*/
static void optimizeMethod(Method* method, bool essentialOnly)
{
bool needRetBar, forSmp;
u4 insnsSize;
u2* insns;
if (dvmIsNativeMethod(method) || dvmIsAbstractMethod(method))
return;
forSmp = gDvm.dexOptForSmp;
needRetBar = needsReturnBarrier(method);
insns = (u2*) method->insns;
assert(insns != NULL);
insnsSize = dvmGetMethodInsnsSize(method);
while (insnsSize > 0) {
Opcode opc, quickOpc, volatileOpc;
size_t width;
bool matched = true;
opc = dexOpcodeFromCodeUnit(*insns);
width = dexGetWidthFromInstruction(insns);
volatileOpc = OP_NOP;
/*
* Each instruction may have:
* - "volatile" replacement
* - may be essential or essential-on-SMP
* - correctness replacement
* - may be essential or essential-on-SMP
* - performance replacement
* - always non-essential
*
* Replacements are considered in the order shown, and the first
* match is applied. For example, iget-wide will convert to
* iget-wide-volatile rather than iget-wide-quick if the target
* field is volatile.
*/
/*
* essential substitutions:
* {iget,iput,sget,sput}-wide --> {op}-wide-volatile
* invoke-direct[/range] --> invoke-object-init/range
*
* essential-on-SMP substitutions:
* {iget,iput,sget,sput}-* --> {op}-volatile
* return-void --> return-void-barrier
*
* non-essential substitutions:
* {iget,iput}-* --> {op}-quick
*
* TODO: might be time to merge this with the other two switches
*/
switch (opc) {
case OP_IGET:
case OP_IGET_BOOLEAN:
case OP_IGET_BYTE:
case OP_IGET_CHAR:
case OP_IGET_SHORT:
quickOpc = OP_IGET_QUICK;
if (forSmp)
volatileOpc = OP_IGET_VOLATILE;
goto rewrite_inst_field;
case OP_IGET_WIDE:
quickOpc = OP_IGET_WIDE_QUICK;
volatileOpc = OP_IGET_WIDE_VOLATILE;
goto rewrite_inst_field;
case OP_IGET_OBJECT:
quickOpc = OP_IGET_OBJECT_QUICK;
if (forSmp)
volatileOpc = OP_IGET_OBJECT_VOLATILE;
goto rewrite_inst_field;
case OP_IPUT:
case OP_IPUT_BOOLEAN:
case OP_IPUT_BYTE:
case OP_IPUT_CHAR:
case OP_IPUT_SHORT:
quickOpc = OP_IPUT_QUICK;
if (forSmp)
volatileOpc = OP_IPUT_VOLATILE;
goto rewrite_inst_field;
case OP_IPUT_WIDE:
quickOpc = OP_IPUT_WIDE_QUICK;
volatileOpc = OP_IPUT_WIDE_VOLATILE;
goto rewrite_inst_field;
case OP_IPUT_OBJECT:
quickOpc = OP_IPUT_OBJECT_QUICK;
if (forSmp)
volatileOpc = OP_IPUT_OBJECT_VOLATILE;
/* fall through */
rewrite_inst_field:
if (essentialOnly)
quickOpc = OP_NOP; /* if essential-only, no "-quick" sub */
if (quickOpc != OP_NOP || volatileOpc != OP_NOP)
rewriteInstField(method, insns, quickOpc, volatileOpc);
break;
case OP_SGET:
case OP_SGET_BOOLEAN:
case OP_SGET_BYTE:
case OP_SGET_CHAR:
case OP_SGET_SHORT:
if (forSmp)
volatileOpc = OP_SGET_VOLATILE;
goto rewrite_static_field;
case OP_SGET_WIDE:
volatileOpc = OP_SGET_WIDE_VOLATILE;
goto rewrite_static_field;
case OP_SGET_OBJECT:
if (forSmp)
volatileOpc = OP_SGET_OBJECT_VOLATILE;
goto rewrite_static_field;
case OP_SPUT:
case OP_SPUT_BOOLEAN:
case OP_SPUT_BYTE:
case OP_SPUT_CHAR:
case OP_SPUT_SHORT:
if (forSmp)
volatileOpc = OP_SPUT_VOLATILE;
goto rewrite_static_field;
case OP_SPUT_WIDE:
volatileOpc = OP_SPUT_WIDE_VOLATILE;
goto rewrite_static_field;
case OP_SPUT_OBJECT:
if (forSmp)
volatileOpc = OP_SPUT_OBJECT_VOLATILE;
/* fall through */
rewrite_static_field:
if (volatileOpc != OP_NOP)
rewriteStaticField(method, insns, volatileOpc);
break;
case OP_INVOKE_DIRECT:
case OP_INVOKE_DIRECT_RANGE:
if (!rewriteInvokeObjectInit(method, insns)) {
/* may want to try execute-inline, below */
matched = false;
}
break;
case OP_RETURN_VOID:
if (needRetBar)
rewriteReturnVoid(method, insns);
break;
default:
matched = false;
break;
}
/*
* non-essential substitutions:
* invoke-{virtual,direct,static}[/range] --> execute-inline
* invoke-{virtual,super}[/range] --> invoke-*-quick
*/
if (!matched && !essentialOnly) {
switch (opc) {
case OP_INVOKE_VIRTUAL:
if (!rewriteExecuteInline(method, insns, METHOD_VIRTUAL)) {
rewriteVirtualInvoke(method, insns,
OP_INVOKE_VIRTUAL_QUICK);
}
break;
case OP_INVOKE_VIRTUAL_RANGE:
if (!rewriteExecuteInlineRange(method, insns, METHOD_VIRTUAL)) {
rewriteVirtualInvoke(method, insns,
OP_INVOKE_VIRTUAL_QUICK_RANGE);
}
break;
case OP_INVOKE_SUPER:
rewriteVirtualInvoke(method, insns, OP_INVOKE_SUPER_QUICK);
break;
case OP_INVOKE_SUPER_RANGE:
rewriteVirtualInvoke(method, insns, OP_INVOKE_SUPER_QUICK_RANGE);
break;
case OP_INVOKE_DIRECT:
rewriteExecuteInline(method, insns, METHOD_DIRECT);
break;
case OP_INVOKE_DIRECT_RANGE:
rewriteExecuteInlineRange(method, insns, METHOD_DIRECT);
break;
case OP_INVOKE_STATIC:
rewriteExecuteInline(method, insns, METHOD_STATIC);
break;
case OP_INVOKE_STATIC_RANGE:
rewriteExecuteInlineRange(method, insns, METHOD_STATIC);
break;
default:
/* nothing to do for this instruction */
;
}
}
assert(width > 0);
assert(width <= insnsSize);
assert(width == dexGetWidthFromInstruction(insns));
insns += width;
insnsSize -= width;
}
assert(insnsSize == 0);
}
/*
* Visits all stack slots. TODO: visit native methods.
*/
static void visitThreadStack(Visitor *visitor, Thread *thread, void *arg)
{
const StackSaveArea *saveArea;
u4 *framePtr;
assert(visitor != NULL);
assert(thread != NULL);
framePtr = (u4 *)thread->curFrame;
for (; framePtr != NULL; framePtr = saveArea->prevFrame) {
Method *method;
saveArea = SAVEAREA_FROM_FP(framePtr);
method = (Method *)saveArea->method;
if (method != NULL && !dvmIsNativeMethod(method)) {
const RegisterMap* pMap = dvmGetExpandedRegisterMap(method);
const u1* regVector = NULL;
size_t i;
if (pMap != NULL) {
/* found map, get registers for this address */
int addr = saveArea->xtra.currentPc - method->insns;
regVector = dvmRegisterMapGetLine(pMap, addr);
}
if (regVector == NULL) {
/*
* Either there was no register map or there is no
* info for the current PC. Perform a conservative
* scan.
*/
for (i = 0; i < method->registersSize; ++i) {
if (dvmIsValidObject((Object *)framePtr[i])) {
(*visitor)(&framePtr[i], arg);
}
}
} else {
/*
* Precise scan. v0 is at the lowest address on the
* interpreted stack, and is the first bit in the
* register vector, so we can walk through the
* register map and memory in the same direction.
*
* A '1' bit indicates a live reference.
*/
u2 bits = 1 << 1;
for (i = 0; i < method->registersSize; ++i) {
bits >>= 1;
if (bits == 1) {
/* set bit 9 so we can tell when we're empty */
bits = *regVector++ | 0x0100;
}
if ((bits & 0x1) != 0) {
/*
* Register is marked as live, it's a valid root.
*/
(*visitor)(&framePtr[i], arg);
}
}
dvmReleaseRegisterMapLine(pMap, regVector);
}
}
/*
* Don't fall into an infinite loop if things get corrupted.
*/
assert((uintptr_t)saveArea->prevFrame > (uintptr_t)framePtr ||
saveArea->prevFrame == NULL);
}
}
/*
* Issue a method call with a variable number of arguments. We process
* the contents of "args" by scanning the method signature.
*
* Pass in NULL for "obj" on calls to static methods.
*
* We don't need to take the class as an argument because, in Dalvik,
* we don't need to worry about static synchronized methods.
*/
void dvmCallMethodV(Thread* self, const Method* method, Object* obj,
bool fromJni, JValue* pResult, va_list args)
{
const char* desc = &(method->shorty[1]); // [0] is the return type.
int verifyCount = 0;
ClassObject* clazz;
u4* ins;
#ifdef WITH_TAINT_TRACKING
int slot_cnt = 0;
bool nativeTarget = dvmIsNativeMethod(method);
#endif
clazz = callPrep(self, method, obj, false);
if (clazz == NULL)
return;
/* "ins" for new frame start at frame pointer plus locals */
#ifdef WITH_TAINT_TRACKING
if (nativeTarget) {
/* native target, no taint tag interleaving */
ins = ((u4*)self->curFrame) + (method->registersSize - method->insSize);
} else {
/* interpreted target, taint tags are interleaved */
ins = ((u4*)self->curFrame) +
((method->registersSize - method->insSize) << 1);
}
#else
ins = ((u4*)self->curFrame) + (method->registersSize - method->insSize);
#endif
//LOGD(" FP is %p, INs live at >= %p\n", self->curFrame, ins);
/* put "this" pointer into in0 if appropriate */
if (!dvmIsStaticMethod(method)) {
#ifdef WITH_EXTRA_OBJECT_VALIDATION
assert(obj != NULL && dvmIsValidObject(obj));
#endif
*ins++ = (u4) obj;
#ifdef WITH_TAINT_TRACKING
if (!nativeTarget) {
*ins++ = TAINT_CLEAR;
}
slot_cnt++;
#endif
verifyCount++;
}
JNIEnv* env = self->jniEnv;
while (*desc != '\0') {
switch (*(desc++)) {
case 'D': case 'J': {
u8 val = va_arg(args, u8);
memcpy(ins, &val, 8); // EABI prevents direct store
#ifdef WITH_TAINT_TRACKING
if (nativeTarget) {
ins += 2;
} else { /* adjust for taint tag interleaving */
ins[2] = ins[1];
ins[1] = TAINT_CLEAR;
ins[3] = TAINT_CLEAR;
ins += 4;
}
slot_cnt += 2;
#else
ins += 2;
#endif
verifyCount += 2;
break;
}
case 'F': {
/* floats were normalized to doubles; convert back */
float f = (float) va_arg(args, double);
*ins++ = dvmFloatToU4(f);
#ifdef WITH_TAINT_TRACKING
if (!nativeTarget) {
*ins++ = TAINT_CLEAR;
}
slot_cnt++;
#endif
verifyCount++;
break;
}
case 'L': { /* 'shorty' descr uses L for all refs, incl array */
void* argObj = va_arg(args, void*);
assert(obj == NULL || dvmIsValidObject(obj));
if (fromJni)
*ins++ = (u4) dvmDecodeIndirectRef(env, argObj);
else
*ins++ = (u4) argObj;
#ifdef WITH_TAINT_TRACKING
if (!nativeTarget) {
*ins++ = TAINT_CLEAR;
}
slot_cnt++;
#endif
verifyCount++;
break;
}
default: {
/* Z B C S I -- all passed as 32-bit integers */
*ins++ = va_arg(args, u4);
#ifdef WITH_TAINT_TRACKING
if (!nativeTarget) {
*ins++ = TAINT_CLEAR;
}
slot_cnt++;
#endif
verifyCount++;
break;
}
}
}
#ifdef WITH_TAINT_TRACKING
/* native hack spacer */
*ins++ = TAINT_CLEAR; /* if nativeTarget, this is return taint */
{
int i;
if (nativeTarget) {
for (i = 0; i < slot_cnt; i++) {
*ins++ = TAINT_CLEAR;
}
}
}
#endif
#ifndef NDEBUG
if (verifyCount != method->insSize) {
LOGE("Got vfycount=%d insSize=%d for %s.%s\n", verifyCount,
method->insSize, clazz->descriptor, method->name);
assert(false);
goto bail;
}
#endif
//dvmDumpThreadStack(dvmThreadSelf());
if (dvmIsNativeMethod(method)) {
TRACE_METHOD_ENTER(self, method);
/*
* Because we leave no space for local variables, "curFrame" points
* directly at the method arguments.
*/
(*method->nativeFunc)(self->curFrame, pResult, method, self);
TRACE_METHOD_EXIT(self, method);
} else {
#ifdef WITH_TAINT_TRACKING
u4 rtaint; /* not used */
dvmInterpret(self, method, pResult, &rtaint);
#else
dvmInterpret(self, method, pResult);
#endif
}
#ifndef NDEBUG
bail:
#endif
dvmPopFrame(self);
}
/*
* Common code for dvmCallMethodV/A and dvmInvokeMethod.
*
* Pushes a call frame on, advancing self->interpSave.curFrame.
*/
static ClassObject* callPrep(Thread* self, const Method* method, Object* obj,
bool checkAccess)
{
ClassObject* clazz;
#ifndef NDEBUG
if (self->status != THREAD_RUNNING) {
ALOGW("threadid=%d: status=%d on call to %s.%s -",
self->threadId, self->status,
method->clazz->descriptor, method->name);
}
#endif
assert(self != NULL);
assert(method != NULL);
if (obj != NULL)
clazz = obj->clazz;
else
clazz = method->clazz;
//salma
// __android_log_print(ANDROID_LOG_DEBUG, "DVM DEBUG","call prep: methodclazz=%s, methodname=%s", clazz->descriptor, method->name);
//endsalma
IF_LOGVV() {
char* desc = dexProtoCopyMethodDescriptor(&method->prototype);
LOGVV("thread=%d native code calling %s.%s %s", self->threadId,
clazz->descriptor, method->name, desc);
free(desc);
}
if (checkAccess) {
/* needed for java.lang.reflect.Method.invoke */
if (!dvmCheckMethodAccess(dvmGetCaller2Class(self->interpSave.curFrame),
method))
{
/* note this throws IAException, not IAError */
dvmThrowIllegalAccessException("access to method denied");
return NULL;
}
}
/*
* Push a call frame on. If there isn't enough room for ins, locals,
* outs, and the saved state, it will throw an exception.
*
* This updates self->interpSave.curFrame.
*/
if (dvmIsNativeMethod(method)) {
/* native code calling native code the hard way */
if (!dvmPushJNIFrame(self, method)) {
assert(dvmCheckException(self));
return NULL;
}
} else {
/* native code calling interpreted code */
if (!dvmPushInterpFrame(self, method)) {
assert(dvmCheckException(self));
return NULL;
}
}
return clazz;
}
/*
* Issue a method call with a variable number of arguments. We process
* the contents of "args" by scanning the method signature.
*
* Pass in NULL for "obj" on calls to static methods.
*
* We don't need to take the class as an argument because, in Dalvik,
* we don't need to worry about static synchronized methods.
*/
void dvmCallMethodV(Thread* self, const Method* method, Object* obj,
bool fromJni, JValue* pResult, va_list args)
{
//salma
//__android_log_print(ANDROID_LOG_DEBUG, "DVM DEBUG", "dvmCallMethodV method name = %s, clazz name: %s", method->name, method->clazz->descriptor);
//end salma
const char* desc = &(method->shorty[1]); // [0] is the return type.
int verifyCount = 0;
ClassObject* clazz;
u4* ins;
clazz = callPrep(self, method, obj, false);
if (clazz == NULL)
return;
/* "ins" for new frame start at frame pointer plus locals */
ins = ((u4*)self->interpSave.curFrame) +
(method->registersSize - method->insSize);
//ALOGD(" FP is %p, INs live at >= %p", self->interpSave.curFrame, ins);
/* put "this" pointer into in0 if appropriate */
if (!dvmIsStaticMethod(method)) {
#ifdef WITH_EXTRA_OBJECT_VALIDATION
assert(obj != NULL && dvmIsHeapAddress(obj));
#endif
*ins++ = (u4) obj;
verifyCount++;
}
while (*desc != '\0') {
switch (*(desc++)) {
case 'D': case 'J': {
u8 val = va_arg(args, u8);
memcpy(ins, &val, 8); // EABI prevents direct store
ins += 2;
verifyCount += 2;
break;
}
case 'F': {
/* floats were normalized to doubles; convert back */
float f = (float) va_arg(args, double);
*ins++ = dvmFloatToU4(f);
verifyCount++;
break;
}
case 'L': { /* 'shorty' descr uses L for all refs, incl array */
void* arg = va_arg(args, void*);
assert(obj == NULL || dvmIsHeapAddress(obj));
jobject argObj = reinterpret_cast<jobject>(arg);
if (fromJni)
*ins++ = (u4) dvmDecodeIndirectRef(self, argObj);
else
*ins++ = (u4) argObj;
verifyCount++;
break;
}
default: {
/* Z B C S I -- all passed as 32-bit integers */
*ins++ = va_arg(args, u4);
verifyCount++;
break;
}
}
}
#ifndef NDEBUG
if (verifyCount != method->insSize) {
ALOGE("Got vfycount=%d insSize=%d for %s.%s", verifyCount,
method->insSize, clazz->descriptor, method->name);
assert(false);
goto bail;
}
#endif
//dvmDumpThreadStack(dvmThreadSelf());
if (dvmIsNativeMethod(method)) {
TRACE_METHOD_ENTER(self, method);
/*
* Because we leave no space for local variables, "curFrame" points
* directly at the method arguments.
*/
(*method->nativeFunc)((u4*)self->interpSave.curFrame, pResult,
method, self);
TRACE_METHOD_EXIT(self, method);
} else {
dvmInterpret(self, method, pResult);
}
#ifndef NDEBUG
bail:
#endif
dvmPopFrame(self);
}
/*
* Visits all stack slots except those belonging to native method
* arguments.
*/
static void visitThreadStack(RootVisitor *visitor, Thread *thread, void *arg)
{
assert(visitor != NULL);
assert(thread != NULL);
u4 threadId = thread->threadId;
const StackSaveArea *saveArea;
for (u4 *fp = (u4 *)thread->interpSave.curFrame;
fp != NULL;
fp = (u4 *)saveArea->prevFrame) {
Method *method;
saveArea = SAVEAREA_FROM_FP(fp);
method = (Method *)saveArea->method;
if (method != NULL && !dvmIsNativeMethod(method)) {
#ifdef FASTIVA
// @zee do not call any malloc in gc task.
// cf) dvmGetExpandedRegisterMap()
const RegisterMap* pMap = NULL;
#else
const RegisterMap* pMap = dvmGetExpandedRegisterMap(method);
#endif
const u1* regVector = NULL;
#ifndef FASTIVA
if (pMap != NULL) {
/* found map, get registers for this address */
int addr = saveArea->xtra.currentPc - method->insns;
regVector = dvmRegisterMapGetLine(pMap, addr);
}
#endif
if (regVector == NULL) {
/*
* Either there was no register map or there is no
* info for the current PC. Perform a conservative
* scan.
*/
for (size_t i = 0; i < method->registersSize; ++i) {
if (dvmIsValidObject((Object *)fp[i])) {
(*visitor)(&fp[i], threadId, ROOT_JAVA_FRAME, arg);
}
}
} else {
/*
* Precise scan. v0 is at the lowest address on the
* interpreted stack, and is the first bit in the
* register vector, so we can walk through the
* register map and memory in the same direction.
*
* A '1' bit indicates a live reference.
*/
u2 bits = 1 << 1;
for (size_t i = 0; i < method->registersSize; ++i) {
bits >>= 1;
if (bits == 1) {
/* set bit 9 so we can tell when we're empty */
bits = *regVector++ | 0x0100;
}
if ((bits & 0x1) != 0) {
/*
* Register is marked as live, it's a valid root.
*/
#if WITH_EXTRA_GC_CHECKS
if (fp[i] != 0 && !dvmIsValidObject((Object *)fp[i])) {
/* this is very bad */
ALOGE("PGC: invalid ref in reg %d: %#x",
method->registersSize - 1 - i, fp[i]);
ALOGE("PGC: %s.%s addr %#x",
method->clazz->descriptor, method->name,
saveArea->xtra.currentPc - method->insns);
continue;
}
#endif
(*visitor)(&fp[i], threadId, ROOT_JAVA_FRAME, arg);
}
}
dvmReleaseRegisterMapLine(pMap, regVector);
}
}
/*
* Don't fall into an infinite loop if things get corrupted.
*/
assert((uintptr_t)saveArea->prevFrame > (uintptr_t)fp ||
saveArea->prevFrame == NULL);
}
#ifdef FASTIVA
int* stack_bottom = (int*)thread->m_pNativeStackBottom;
int* stack_top = (int*)thread->m_pNativeStackPointer;
const bool DUMP_STACK = 0;
if (DUMP_STACK) {
ALOGE("##### scan_stack %i %p~%p", thread->systemTid, stack_top, stack_bottom);
}
assert(thread->status != THREAD_RUNNING || thread == dvmThreadSelf());
while (stack_top < stack_bottom) {
if (dvmIsValidObject((Object*)stack_top[0])) {
(*visitor)(stack_top, threadId, ROOT_JAVA_FRAME, arg);
}
stack_top ++;
}
#endif
}
/*
* We're calling an interpreted method from an internal VM function or
* via reflection.
*
* Push a frame for an interpreted method onto the stack. This is only
* used when calling into interpreted code from native code. (The
* interpreter does its own stack frame manipulation for interp-->interp
* calls.)
*
* The size we need to reserve is the sum of parameters, local variables,
* saved goodies, and outbound parameters.
*
* We start by inserting a "break" frame, which ensures that the interpreter
* hands control back to us after the function we call returns or an
* uncaught exception is thrown.
*/
static bool dvmPushInterpFrame(Thread* self, const Method* method)
{
StackSaveArea* saveBlock;
StackSaveArea* breakSaveBlock;
int stackReq;
u1* stackPtr;
assert(!dvmIsNativeMethod(method));
assert(!dvmIsAbstractMethod(method));
stackReq = method->registersSize * 4 // params + locals
+ sizeof(StackSaveArea) * 2 // break frame + regular frame
+ method->outsSize * 4; // args to other methods
if (self->interpSave.curFrame != NULL)
stackPtr = (u1*) SAVEAREA_FROM_FP(self->interpSave.curFrame);
else
stackPtr = self->interpStackStart;
if (stackPtr - stackReq < self->interpStackEnd) {
/* not enough space */
ALOGW("Stack overflow on call to interp "
"(req=%d top=%p cur=%p size=%d %s.%s)",
stackReq, self->interpStackStart, self->interpSave.curFrame,
self->interpStackSize, method->clazz->descriptor, method->name);
dvmHandleStackOverflow(self, method);
assert(dvmCheckException(self));
return false;
}
/*
* Shift the stack pointer down, leaving space for the function's
* args/registers and save area.
*/
stackPtr -= sizeof(StackSaveArea);
breakSaveBlock = (StackSaveArea*)stackPtr;
stackPtr -= method->registersSize * 4 + sizeof(StackSaveArea);
saveBlock = (StackSaveArea*) stackPtr;
#if !defined(NDEBUG) && !defined(PAD_SAVE_AREA)
/* debug -- memset the new stack, unless we want valgrind's help */
memset(stackPtr - (method->outsSize*4), 0xaf, stackReq);
#endif
#ifdef EASY_GDB
breakSaveBlock->prevSave =
(StackSaveArea*)FP_FROM_SAVEAREA(self->interpSave.curFrame);
saveBlock->prevSave = breakSaveBlock;
#endif
breakSaveBlock->prevFrame = self->interpSave.curFrame;
breakSaveBlock->savedPc = NULL; // not required
breakSaveBlock->xtra.localRefCookie = 0; // not required
breakSaveBlock->method = NULL;
saveBlock->prevFrame = FP_FROM_SAVEAREA(breakSaveBlock);
saveBlock->savedPc = NULL; // not required
saveBlock->xtra.currentPc = NULL; // not required?
saveBlock->method = method;
LOGVV("PUSH frame: old=%p new=%p (size=%d)",
self->interpSave.curFrame, FP_FROM_SAVEAREA(saveBlock),
(u1*)self->interpSave.curFrame - (u1*)FP_FROM_SAVEAREA(saveBlock));
self->interpSave.curFrame = FP_FROM_SAVEAREA(saveBlock);
return true;
}
/*
* Find a matching "catch" block. "pc" is the relative PC within the
* current method, indicating the offset from the start in 16-bit units.
*
* Returns the offset to the catch block, or -1 if we run up against a
* break frame without finding anything.
*
* The class resolution stuff we have to do while evaluating the "catch"
* blocks could cause an exception. The caller should clear the exception
* before calling here and restore it after.
*
* Sets *newFrame to the frame pointer of the frame with the catch block.
* If "scanOnly" is false, self->curFrame is also set to this value.
*/
int dvmFindCatchBlock(Thread* self, int relPc, Object* exception,
bool scanOnly, void** newFrame)
{
void* fp = self->curFrame;
int catchAddr = -1;
assert(!dvmCheckException(self));
while (true) {
StackSaveArea* saveArea = SAVEAREA_FROM_FP(fp);
catchAddr = findCatchInMethod(self, saveArea->method, relPc,
exception->clazz);
if (catchAddr >= 0)
break;
/*
* Normally we'd check for ACC_SYNCHRONIZED methods and unlock
* them as we unroll. Dalvik uses what amount to generated
* "finally" blocks to take care of this for us.
*/
/* output method profiling info */
if (!scanOnly) {
TRACE_METHOD_UNROLL(self, saveArea->method);
}
/*
* Move up one frame. If the next thing up is a break frame,
* break out now so we're left unrolled to the last method frame.
* We need to point there so we can roll up the JNI local refs
* if this was a native method.
*/
assert(saveArea->prevFrame != NULL);
if (dvmIsBreakFrame(saveArea->prevFrame)) {
if (!scanOnly)
break; // bail with catchAddr == -1
/*
* We're scanning for the debugger. It needs to know if this
* exception is going to be caught or not, and we need to figure
* out if it will be caught *ever* not just between the current
* position and the next break frame. We can't tell what native
* code is going to do, so we assume it never catches exceptions.
*
* Start by finding an interpreted code frame.
*/
fp = saveArea->prevFrame; // this is the break frame
saveArea = SAVEAREA_FROM_FP(fp);
fp = saveArea->prevFrame; // this may be a good one
while (fp != NULL) {
if (!dvmIsBreakFrame(fp)) {
saveArea = SAVEAREA_FROM_FP(fp);
if (!dvmIsNativeMethod(saveArea->method))
break;
}
fp = SAVEAREA_FROM_FP(fp)->prevFrame;
}
if (fp == NULL)
break; // bail with catchAddr == -1
/*
* Now fp points to the "good" frame. When the interp code
* invoked the native code, it saved a copy of its current PC
* into xtra.currentPc. Pull it out of there.
*/
relPc =
saveArea->xtra.currentPc - SAVEAREA_FROM_FP(fp)->method->insns;
} else {
fp = saveArea->prevFrame;
/* savedPc in was-current frame goes with method in now-current */
relPc = saveArea->savedPc - SAVEAREA_FROM_FP(fp)->method->insns;
}
}
if (!scanOnly)
self->curFrame = fp;
/*
* The class resolution in findCatchInMethod() could cause an exception.
* Clear it to be safe.
*/
self->exception = NULL;
*newFrame = fp;
return catchAddr;
}
/*
Perform verification on a single method.
执行单个方法的校验
We do this in three passes:
(1) Walk through all code units, determining instruction locations,
widths, and other characteristics.
(2) Walk through all code units, performing static checks on
operands.
(3) Iterate through the method, checking type safety and looking
for code flow problems.
校验分3次处理：
(1) 遍历所有代码单元，确定指令位置，宽度，和其它特征。
(2) 遍历所有代码单元，对操作码执行静态检查。
(3) 通过方法迭代，检查类型安全并且寻找代码流的问题。
Some checks may be bypassed depending on the verification mode. We can't
turn this stuff off completely if we want to do "exact" GC.
一些检查可以避免，这取决于校验模式。我们不能完全关闭这些校验，如果想做“精确”的垃圾回收。
TODO: cite source?
Confirmed here:
- code array must not be empty
- (N/A) code_length must be less than 65536
Confirmed by computeWidthsAndCountOps():
- opcode of first instruction begins at index 0
- only documented instructions may appear
- each instruction follows the last
- last byte of last instruction is at (code_length-1)
*/
static bool verifyMethod(Method* meth)
{
bool result = false;
/*
Verifier state blob. Various values will be cached here so we
can avoid expensive lookups and pass fewer arguments around.
数据校验器数据结构体。不同的值将被缓存到这里，因此我们可以通过极少的参数进行更有效查找。
可以缓存数据。数据结构参见于CodeVerify.h头文件。
*/
VerifierData vdata;
#if 1 // ndef NDEBUG
memset(&vdata, 0x99, sizeof(vdata));
#endif
// 校验器数据初始化
vdata.method = meth;
vdata.insnsSize = dvmGetMethodInsnsSize(meth);
vdata.insnRegCount = meth->registersSize;
vdata.insnFlags = NULL;
vdata.uninitMap = NULL;
vdata.basicBlocks = NULL;
/*
If there aren't any instructions, make sure that's expected, then
exit successfully. Note: for native methods, meth->insns gets set
to a native function pointer on first call, so don't use that as
an indicator.
如果没有任何指令，确保本地方法和抽象方法均可被访问，
然后成功退出。
*/
if (vdata.insnsSize == 0) {
if (!dvmIsNativeMethod(meth) && !dvmIsAbstractMethod(meth)) {
LOG_VFY_METH(meth,
"VFY: zero-length code in concrete non-native method");
goto bail;
}
goto success;
}
/*
Sanity-check the register counts. ins + locals = registers, so make
sure that ins <= registers.
校验寄存器个数。 指令寄存器ins + 本地寄存器locals = All，因此确保指令寄存器<= All。
*/
if (meth->insSize > meth->registersSize) {
LOG_VFY_METH(meth, "VFY: bad register counts (ins=%d regs=%d)",
meth->insSize, meth->registersSize);
goto bail;
}
/*
Allocate and populate an array to hold instruction data.
TODO: Consider keeping a reusable pre-allocated array sitting
around for smaller methods.
给指令分配空间
*/
vdata.insnFlags = (InsnFlags*) calloc(vdata.insnsSize, sizeof(InsnFlags));
if (vdata.insnFlags == NULL)
goto bail;
/*
Compute the width of each instruction and store the result in insnFlags.
Count up the #of occurrences of certain opcodes while we're at it.
计算每条指令宽度并且存储 insnFlags 中的结果。
*/
if (!computeWidthsAndCountOps(&vdata))
goto bail;
/*
Allocate a map to hold the classes of uninitialized instances.
分配一个map来持有未初始化的实例的类(s)
*/
vdata.uninitMap = dvmCreateUninitInstanceMap(meth, vdata.insnFlags,
vdata.newInstanceCount);
if (vdata.uninitMap == NULL)
goto bail;
/*
Set the "in try" flags for all instructions guarded by a "try" block.
Also sets the "branch target" flag on exception handlers.
对所有try块指令设置“in try”标识。
同时在异常句柄处设置“branch target”标识。
*/
if (!scanTryCatchBlocks(meth, vdata.insnFlags))
goto bail;
/*
Perform static instruction verification. Also sets the "branch
target" flags.
执行静态校验。同时设置“brach target”标识。
*/
if (!verifyInstructions(&vdata))
goto bail;
/*
Do code-flow analysis.
We could probably skip this for a method with no registers, but
that's so rare that there's little point in checking.
做代码流分析
也许可能会跳过一个没有寄存器的方法，但这种情况不见罕见，没有必要检查。
*/
if (!dvmVerifyCodeFlow(&vdata)) {
//ALOGD("+++ %s failed code flow", meth->name);
goto bail;
}
success:
result = true;
bail:
dvmFreeVfyBasicBlocks(&vdata);
dvmFreeUninitInstanceMap(vdata.uninitMap);
free(vdata.insnFlags);
return result;
}
/*
* Invoke a method, using the specified arguments and return type, through
* one of the reflection interfaces. Could be a virtual or direct method
* (including constructors). Used for reflection.
*
* Deals with boxing/unboxing primitives and performs widening conversions.
*
* "invokeObj" will be null for a static method.
*
* If the invocation returns with an exception raised, we have to wrap it.
*/
Object* dvmInvokeMethod(Object* obj, const Method* method,
ArrayObject* argList, ArrayObject* params, ClassObject* returnType,
bool noAccessCheck)
{
ClassObject* clazz;
Object* retObj = NULL;
Thread* self = dvmThreadSelf();
s4* ins;
int verifyCount, argListLength;
JValue retval;
bool needPop = false;
#ifdef WITH_TAINT_TRACKING
u4 rtaint = TAINT_CLEAR;
int slot_cnt = 0;
bool nativeTarget = dvmIsNativeMethod(method);
/* For simplicity, argument tags for native targets
* are unioned. This may cause false positives, but
* it is the easiest way to handle this for now.
*/
u4 nativeTag = TAINT_CLEAR;
#endif
/* verify arg count */
if (argList != NULL)
argListLength = argList->length;
else
argListLength = 0;
if (argListLength != (int) params->length) {
LOGI("invoke: expected %d args, received %d args\n",
params->length, argListLength);
dvmThrowException("Ljava/lang/IllegalArgumentException;",
"wrong number of arguments");
return NULL;
}
clazz = callPrep(self, method, obj, !noAccessCheck);
if (clazz == NULL)
return NULL;
needPop = true;
/* "ins" for new frame start at frame pointer plus locals */
#ifdef WITH_TAINT_TRACKING
if (nativeTarget) {
/* native target, no taint tag interleaving */
ins = ((s4*)self->curFrame) + (method->registersSize - method->insSize);
} else {
/* interpreted target, taint tags are interleaved */
ins = ((s4*)self->curFrame) +
((method->registersSize - method->insSize) << 1);
}
#else
ins = ((s4*)self->curFrame) + (method->registersSize - method->insSize);
#endif
verifyCount = 0;
//LOGD(" FP is %p, INs live at >= %p\n", self->curFrame, ins);
/* put "this" pointer into in0 if appropriate */
if (!dvmIsStaticMethod(method)) {
assert(obj != NULL);
*ins++ = (s4) obj;
#ifdef WITH_TAINT_TRACKING
if (!nativeTarget) {
*ins++ = TAINT_CLEAR;
}
slot_cnt++;
#endif
verifyCount++;
}
/*
* Copy the args onto the stack. Primitive types are converted when
* necessary, and object types are verified.
*/
DataObject** args;
ClassObject** types;
int i;
args = (DataObject**) argList->contents;
types = (ClassObject**) params->contents;
for (i = 0; i < argListLength; i++) {
int width;
#ifdef WITH_TAINT_TRACKING
int tag = dvmGetPrimitiveTaint(*args, *types);
#endif
width = dvmConvertArgument(*args++, *types++, ins);
if (width < 0) {
if (*(args-1) != NULL) {
LOGV("invoke: type mismatch on arg %d ('%s' '%s')\n",
i, (*(args-1))->obj.clazz->descriptor,
(*(types-1))->descriptor);
}
dvmPopFrame(self); // throw wants to pull PC out of stack
needPop = false;
dvmThrowException("Ljava/lang/IllegalArgumentException;",
"argument type mismatch");
goto bail;
}
#ifdef WITH_TAINT_TRACKING
/* dvmConvertArgument() returns -1, 1, or 2 */
if (nativeTarget) {
nativeTag |= tag; /* TODO: is there a better way to do this?*/
ins += width;
} else {
if (width == 2) {
ins[2] = ins[1];
ins[1] = tag;
ins[3] = tag;
ins += 4;
} else if (width == 1) {
ins[1] = tag;
ins += 2;
} else { /* error condition duplicated from above */
dvmPopFrame(self);
dvmThrowException("Ljava/lang/IllegalArgumentException;",
"argument type mismatch");
goto bail_popped;
}
}
slot_cnt += width;
#else
ins += width;
#endif
verifyCount += width;
}
#ifdef WITH_TAINT_TRACKING
/* native hack spacer */
*ins++ = TAINT_CLEAR; /* if nativeTarget, this is return taint */
{
int i;
if (nativeTarget) {
for (i = 0; i < slot_cnt; i++) {
*ins++ = nativeTag; /* TODO: better way? */
}
}
}
#endif
if (verifyCount != method->insSize) {
LOGE("Got vfycount=%d insSize=%d for %s.%s\n", verifyCount,
method->insSize, clazz->descriptor, method->name);
assert(false);
goto bail;
}
//dvmDumpThreadStack(dvmThreadSelf());
if (dvmIsNativeMethod(method)) {
TRACE_METHOD_ENTER(self, method);
/*
* Because we leave no space for local variables, "curFrame" points
* directly at the method arguments.
*/
(*method->nativeFunc)(self->curFrame, &retval, method, self);
TRACE_METHOD_EXIT(self, method);
#ifdef WITH_TAINT_TRACKING
rtaint = ((u4*)self->curFrame)[slot_cnt];
#endif
} else {
#ifdef WITH_TAINT_TRACKING
dvmInterpret(self, method, &retval, &rtaint);
#else
dvmInterpret(self, method, &retval);
#endif
}
/*
* Pop the frame immediately. The "wrap" calls below can cause
* allocations, and we don't want the GC to walk the now-dead frame.
*/
dvmPopFrame(self);
needPop = false;
/*
* If an exception is raised, wrap and replace. This is necessary
* because the invoked method could have thrown a checked exception
* that the caller wasn't prepared for.
*
* We might be able to do this up in the interpreted code, but that will
* leave us with a shortened stack trace in the top-level exception.
*/
if (dvmCheckException(self)) {
dvmWrapException("Ljava/lang/reflect/InvocationTargetException;");
} else {
/*
* If this isn't a void method or constructor, convert the return type
* to an appropriate object.
*
* We don't do this when an exception is raised because the value
* in "retval" is undefined.
*/
if (returnType != NULL) {
retObj = (Object*)dvmWrapPrimitive(retval, returnType);
#ifdef WITH_TAINT_TRACKING
dvmSetPrimitiveTaint((DataObject *)retObj, returnType, rtaint);
#endif
dvmReleaseTrackedAlloc(retObj, NULL);
}
}
bail:
if (needPop) {
dvmPopFrame(self);
}
bail_popped:
return retObj;
}
