Merge change Iccd6c010
* changes:
Make the traige process for self-verification found divergence easier.
diff --git a/vm/compiler/Compiler.c b/vm/compiler/Compiler.c
index 9db641e..018dc4a 100644
--- a/vm/compiler/Compiler.c
+++ b/vm/compiler/Compiler.c
@@ -73,9 +73,14 @@
i = 0;
}
- gDvmJit.compilerWorkQueue[gDvmJit.compilerWorkEnqueueIndex].pc = pc;
- gDvmJit.compilerWorkQueue[gDvmJit.compilerWorkEnqueueIndex].kind = kind;
- gDvmJit.compilerWorkQueue[gDvmJit.compilerWorkEnqueueIndex].info = info;
+ CompilerWorkOrder *newOrder =
+ &gDvmJit.compilerWorkQueue[gDvmJit.compilerWorkEnqueueIndex];
+ newOrder->pc = pc;
+ newOrder->kind = kind;
+ newOrder->info = info;
+ newOrder->result.codeAddress = NULL;
+ newOrder->result.discardResult =
+ (kind == kWorkOrderTraceDebug) ? true : false;
gDvmJit.compilerWorkEnqueueIndex++;
if (gDvmJit.compilerWorkEnqueueIndex == COMPILER_WORK_QUEUE_SIZE)
gDvmJit.compilerWorkEnqueueIndex = 0;
diff --git a/vm/compiler/Compiler.h b/vm/compiler/Compiler.h
index 47de33d..06367a6 100644
--- a/vm/compiler/Compiler.h
+++ b/vm/compiler/Compiler.h
@@ -36,14 +36,16 @@
/* Description of a compiled trace. */
typedef struct JitTranslationInfo {
- void *codeAddress;
+ void *codeAddress;
JitInstructionSetType instructionSet;
+ bool discardResult; // Used for debugging divergence
} JitTranslationInfo;
typedef enum WorkOrderKind {
kWorkOrderInvalid = 0, // Should never see by the backend
kWorkOrderMethod = 1, // Work is to compile a whole method
kWorkOrderTrace = 2, // Work is to compile code fragment(s)
+ kWorkOrderTraceDebug = 3, // Work is to compile/debug code fragment(s)
} WorkOrderKind;
typedef struct CompilerWorkOrder {
@@ -154,9 +156,11 @@
struct BasicBlock *bb);
void dvmCompilerFindInductionVariables(struct CompilationUnit *cUnit,
struct BasicBlock *bb);
+char *dvmCompilerGetDalvikDisassembly(DecodedInstruction *insn);
char *dvmCompilerGetSSAString(struct CompilationUnit *cUnit,
struct SSARepresentation *ssaRep);
void dvmCompilerDataFlowAnalysisDispatcher(struct CompilationUnit *cUnit,
void (*func)(struct CompilationUnit *, struct BasicBlock *));
+JitTraceDescription *dvmCopyTraceDescriptor(const u2 *pc);
#endif /* _DALVIK_VM_COMPILER */
diff --git a/vm/compiler/Dataflow.c b/vm/compiler/Dataflow.c
index 9a2e5c0..f8e736b 100644
--- a/vm/compiler/Dataflow.c
+++ b/vm/compiler/Dataflow.c
@@ -17,6 +17,7 @@
#include "Dalvik.h"
#include "Dataflow.h"
#include "Loop.h"
+#include "dexdump/OpCodeNames.h"
/*
* Main table containing data flow attributes for each bytecode. The first
@@ -817,6 +818,59 @@
* and subscript pair. Each SSA register can be used to index the
* ssaToDalvikMap list to get the subscript[31..16]/dalvik_reg[15..0] mapping.
*/
+char *dvmCompilerGetDalvikDisassembly(DecodedInstruction *insn)
+{
+ char buffer[256];
+ int opcode = insn->opCode;
+ int dfAttributes = dvmCompilerDataFlowAttributes[opcode];
+ char *ret;
+
+ buffer[0] = 0;
+ strcpy(buffer, getOpcodeName(opcode));
+
+ if (dfAttributes & DF_FORMAT_35C) {
+ unsigned int i;
+ for (i = 0; i < insn->vA; i++) {
+ if (i != 0) strcat(buffer, ",");
+ sprintf(buffer + strlen(buffer), " v%d", insn->arg[i]);
+ }
+ }
+ else if (dfAttributes & DF_FORMAT_3RC) {
+ sprintf(buffer + strlen(buffer),
+ " v%d..v%d", insn->vC, insn->vC + insn->vA - 1);
+ }
+ else {
+ if (dfAttributes & DF_A_IS_REG) {
+ sprintf(buffer + strlen(buffer), " v%d", insn->vA);
+ }
+ if (dfAttributes & DF_B_IS_REG) {
+ sprintf(buffer + strlen(buffer),
+ ", v%d", insn->vB);
+ }
+ else {
+ sprintf(buffer + strlen(buffer),
+ ", (#%d)", insn->vB);
+ }
+ if (dfAttributes & DF_C_IS_REG) {
+ sprintf(buffer + strlen(buffer),
+ ", v%d", insn->vC);
+ }
+ else {
+ sprintf(buffer + strlen(buffer),
+ ", (#%d)", insn->vC);
+ }
+ }
+ int length = strlen(buffer) + 1;
+ ret = dvmCompilerNew(length, false);
+ memcpy(ret, buffer, length);
+ return ret;
+}
+
+/*
+ * Utility function to convert encoded SSA register value into Dalvik register
+ * and subscript pair. Each SSA register can be used to index the
+ * ssaToDalvikMap list to get the subscript[31..16]/dalvik_reg[15..0] mapping.
+ */
char *dvmCompilerGetSSAString(CompilationUnit *cUnit, SSARepresentation *ssaRep)
{
char buffer[256];
diff --git a/vm/compiler/Dataflow.h b/vm/compiler/Dataflow.h
index e4ae93d..384d430 100644
--- a/vm/compiler/Dataflow.h
+++ b/vm/compiler/Dataflow.h
@@ -68,6 +68,10 @@
DF_NULL_N_RANGE_CHECK_1 | \
DF_NULL_N_RANGE_CHECK_2)
+#define DF_A_IS_REG (DF_UA | DF_UA_WIDE | DF_DA | DF_DA_WIDE)
+#define DF_B_IS_REG (DF_UB | DF_UB_WIDE)
+#define DF_C_IS_REG (DF_UC | DF_UC_WIDE)
+
extern int dvmCompilerDataFlowAttributes[MIR_OP_LAST];
typedef struct BasicBlockDataFlow {
diff --git a/vm/compiler/Frontend.c b/vm/compiler/Frontend.c
index 163cdf8..959c99a 100644
--- a/vm/compiler/Frontend.c
+++ b/vm/compiler/Frontend.c
@@ -16,7 +16,6 @@
#include "Dalvik.h"
#include "libdex/OpCode.h"
-#include "dexdump/OpCodeNames.h"
#include "interp/Jit.h"
#include "CompilerInternals.h"
@@ -42,7 +41,8 @@
dexDecodeInstruction(gDvm.instrFormat, codePtr, decInsn);
if (printMe) {
- LOGD("%p: %#06x %s\n", codePtr, opcode, getOpcodeName(opcode));
+ char *decodedString = dvmCompilerGetDalvikDisassembly(decInsn);
+ LOGD("%p: %#06x %s\n", codePtr, opcode, decodedString);
}
return insnWidth;
}
diff --git a/vm/compiler/codegen/arm/ArchUtility.c b/vm/compiler/codegen/arm/ArchUtility.c
index d1f9870..57d5d74 100644
--- a/vm/compiler/codegen/arm/ArchUtility.c
+++ b/vm/compiler/codegen/arm/ArchUtility.c
@@ -276,7 +276,7 @@
break;
case ARM_PSEUDO_DALVIK_BYTECODE_BOUNDARY:
LOGD("-------- dalvik offset: 0x%04x @ %s\n", dest,
- getOpcodeName(lir->operands[1]));
+ (char *) lir->operands[1]);
break;
case ARM_PSEUDO_EXIT_BLOCK:
LOGD("-------- exit offset: 0x%04x\n", dest);
diff --git a/vm/compiler/codegen/arm/Assemble.c b/vm/compiler/codegen/arm/Assemble.c
index e386fac..81dd0e3 100644
--- a/vm/compiler/codegen/arm/Assemble.c
+++ b/vm/compiler/codegen/arm/Assemble.c
@@ -1027,7 +1027,6 @@
ChainCellCounts chainCellCounts;
int descSize = jitTraceDescriptionSize(cUnit->traceDesc);
- info->codeAddress = NULL;
info->instructionSet = cUnit->instructionSet;
/* Beginning offset needs to allow space for chain cell offset */
@@ -1109,6 +1108,8 @@
return;
}
+ /* Don't go all the way if the goal is just to get the verbose output */
+ if (info->discardResult) return;
cUnit->baseAddr = (char *) gDvmJit.codeCache + gDvmJit.codeCacheByteUsed;
gDvmJit.codeCacheByteUsed += offset;
@@ -1137,7 +1138,6 @@
/* Record code entry point and instruction set */
info->codeAddress = (char*)cUnit->baseAddr + cUnit->headerSize;
- info->instructionSet = cUnit->instructionSet;
/* If applicable, mark low bit to denote thumb */
if (info->instructionSet != DALVIK_JIT_ARM)
info->codeAddress = (char*)info->codeAddress + 1;
@@ -1477,6 +1477,31 @@
return *pExecutionCount;
}
+/* Create a copy of the trace descriptor of an existing compilation */
+JitTraceDescription *dvmCopyTraceDescriptor(const u2 *pc)
+{
+ JitEntry *jitEntry = dvmFindJitEntry(pc);
+ if (jitEntry == NULL) return NULL;
+
+ /* Find out the startint point */
+ char *traceBase = getTraceBase(jitEntry);
+
+ /* Then find out the starting point of the chaining cell */
+ u2 *pCellOffset = (u2*) (traceBase + 4);
+ ChainCellCounts *pCellCounts =
+ (ChainCellCounts*) ((char *)pCellOffset + *pCellOffset);
+
+ /* From there we can find out the starting point of the trace descriptor */
+ JitTraceDescription *desc =
+ (JitTraceDescription*) ((char*)pCellCounts + sizeof(*pCellCounts));
+
+ /* Now make a copy and return */
+ int descSize = jitTraceDescriptionSize(desc);
+ JitTraceDescription *newCopy = (JitTraceDescription *) malloc(descSize);
+ memcpy(newCopy, desc, descSize);
+ return newCopy;
+}
+
/* Handy function to retrieve the profile count */
static inline int getProfileCount(const JitEntry *entry)
{
diff --git a/vm/compiler/codegen/arm/Codegen.c b/vm/compiler/codegen/arm/Codegen.c
index 4a85fb2..c0729ab 100644
--- a/vm/compiler/codegen/arm/Codegen.c
+++ b/vm/compiler/codegen/arm/Codegen.c
@@ -3997,7 +3997,9 @@
dexGetInstrFormat(gDvm.instrFormat, dalvikOpCode);
ArmLIR *boundaryLIR =
newLIR2(cUnit, ARM_PSEUDO_DALVIK_BYTECODE_BOUNDARY,
- mir->offset, dalvikOpCode);
+ mir->offset,
+ (int) dvmCompilerGetDalvikDisassembly(&mir->dalvikInsn)
+ );
if (mir->ssaRep) {
char *ssaString = dvmCompilerGetSSAString(cUnit, mir->ssaRep);
newLIR1(cUnit, ARM_PSEUDO_SSA_REP, (int) ssaString);
@@ -4209,25 +4211,33 @@
/* Accept the work and start compiling */
bool dvmCompilerDoWork(CompilerWorkOrder *work)
{
- bool res;
+ bool res;
- if (gDvmJit.codeCacheFull) {
- return false;
- }
+ if (gDvmJit.codeCacheFull) {
+ return false;
+ }
- switch (work->kind) {
- case kWorkOrderMethod:
- res = dvmCompileMethod(work->info, &work->result);
- break;
- case kWorkOrderTrace:
- /* Start compilation with maximally allowed trace length */
- res = dvmCompileTrace(work->info, JIT_MAX_TRACE_LEN, &work->result);
- break;
- default:
- res = false;
- dvmAbort();
- }
- return res;
+ switch (work->kind) {
+ case kWorkOrderMethod:
+ res = dvmCompileMethod(work->info, &work->result);
+ break;
+ case kWorkOrderTrace:
+ /* Start compilation with maximally allowed trace length */
+ res = dvmCompileTrace(work->info, JIT_MAX_TRACE_LEN, &work->result);
+ break;
+ case kWorkOrderTraceDebug: {
+ bool oldPrintMe = gDvmJit.printMe;
+ gDvmJit.printMe = true;
+ /* Start compilation with maximally allowed trace length */
+ res = dvmCompileTrace(work->info, JIT_MAX_TRACE_LEN, &work->result);
+ gDvmJit.printMe = oldPrintMe;;
+ break;
+ }
+ default:
+ res = false;
+ dvmAbort();
+ }
+ return res;
}
/* Architectural-specific debugging helpers go here */
diff --git a/vm/interp/Jit.c b/vm/interp/Jit.c
index d8dcf1e..1d86657 100644
--- a/vm/interp/Jit.c
+++ b/vm/interp/Jit.c
@@ -60,11 +60,10 @@
* Return a pointer to the shadow space for JIT to use.
*/
void* dvmSelfVerificationSaveState(const u2* pc, const void* fp,
- void* interpStatePtr)
+ InterpState* interpState)
{
Thread *self = dvmThreadSelf();
ShadowSpace *shadowSpace = self->shadowSpace;
- InterpState *interpState = (InterpState *) interpStatePtr;
int preBytes = interpState->method->outsSize*4 + sizeof(StackSaveArea);
int postBytes = interpState->method->registersSize*4;
@@ -75,7 +74,7 @@
LOGD("~~~ Save: INCORRECT PREVIOUS STATE(%d): %d",
self->threadId, shadowSpace->selfVerificationState);
LOGD("********** SHADOW STATE DUMP **********");
- LOGD("* PC: 0x%x FP: 0x%x", (int)pc, (int)fp);
+ LOGD("PC: 0x%x FP: 0x%x", (int)pc, (int)fp);
}
shadowSpace->selfVerificationState = kSVSStart;
@@ -90,12 +89,18 @@
// Remember original state
shadowSpace->startPC = pc;
shadowSpace->fp = fp;
- shadowSpace->glue = interpStatePtr;
+ shadowSpace->glue = interpState;
+ /*
+ * Store the original method here in case the trace ends with a
+ * return/invoke, the last method.
+ */
+ shadowSpace->method = interpState->method;
shadowSpace->shadowFP = shadowSpace->registerSpace +
shadowSpace->registerSpaceSize - postBytes/4;
// Create a copy of the InterpState
- memcpy(&(shadowSpace->interpState), interpStatePtr, sizeof(InterpState));
+ //shadowSpace->interpState = *interpState;
+ memcpy(&(shadowSpace->interpState), interpState, sizeof(InterpState));
shadowSpace->interpState.fp = shadowSpace->shadowFP;
shadowSpace->interpState.interpStackEnd = (u1*)shadowSpace->registerSpace;
@@ -132,10 +137,10 @@
LOGD("~~~ Restore: INCORRECT PREVIOUS STATE(%d): %d",
self->threadId, shadowSpace->selfVerificationState);
LOGD("********** SHADOW STATE DUMP **********");
- LOGD("* Dalvik PC: 0x%x endPC: 0x%x", (int)shadowSpace->startPC,
+ LOGD("Dalvik PC: 0x%x endPC: 0x%x", (int)shadowSpace->startPC,
(int)shadowSpace->endPC);
- LOGD("* Interp FP: 0x%x", (int)shadowSpace->fp);
- LOGD("* Shadow FP: 0x%x endFP: 0x%x", (int)shadowSpace->shadowFP,
+ LOGD("Interp FP: 0x%x", (int)shadowSpace->fp);
+ LOGD("Shadow FP: 0x%x endFP: 0x%x", (int)shadowSpace->shadowFP,
(int)shadowSpace->endShadowFP);
}
@@ -150,11 +155,12 @@
}
/* Print contents of virtual registers */
-static void selfVerificationPrintRegisters(int* addr, int numWords)
+static void selfVerificationPrintRegisters(int* addr, int* addrRef,
+ int numWords)
{
int i;
for (i = 0; i < numWords; i++) {
- LOGD("* 0x%x: (v%d) 0x%8x", (int)(addr+i), i, *(addr+i));
+ LOGD("(v%d) 0x%8x%s", i, addr[i], addr[i] != addrRef[i] ? " X" : "");
}
}
@@ -174,19 +180,19 @@
frameBytes2 = (int) shadowSpace->fp - (int) self->curFrame - localRegs;
}
LOGD("********** SHADOW STATE DUMP **********");
- LOGD("* CurrentPC: 0x%x, Offset: 0x%04x", (int)pc,
+ LOGD("CurrentPC: 0x%x, Offset: 0x%04x", (int)pc,
(int)(pc - stackSave->method->insns));
- LOGD("* Class: %s Method: %s", stackSave->method->clazz->descriptor,
- stackSave->method->name);
- LOGD("* Dalvik PC: 0x%x endPC: 0x%x", (int)shadowSpace->startPC,
+ LOGD("Class: %s", shadowSpace->method->clazz->descriptor);
+ LOGD("Method: %s", shadowSpace->method->name);
+ LOGD("Dalvik PC: 0x%x endPC: 0x%x", (int)shadowSpace->startPC,
(int)shadowSpace->endPC);
- LOGD("* Interp FP: 0x%x endFP: 0x%x", (int)shadowSpace->fp,
+ LOGD("Interp FP: 0x%x endFP: 0x%x", (int)shadowSpace->fp,
(int)self->curFrame);
- LOGD("* Shadow FP: 0x%x endFP: 0x%x", (int)shadowSpace->shadowFP,
+ LOGD("Shadow FP: 0x%x endFP: 0x%x", (int)shadowSpace->shadowFP,
(int)shadowSpace->endShadowFP);
- LOGD("* Frame1 Bytes: %d Frame2 Local: %d Bytes: %d", frameBytes,
+ LOGD("Frame1 Bytes: %d Frame2 Local: %d Bytes: %d", frameBytes,
localRegs, frameBytes2);
- LOGD("* Trace length: %d State: %d", shadowSpace->traceLength,
+ LOGD("Trace length: %d State: %d", shadowSpace->traceLength,
shadowSpace->selfVerificationState);
}
@@ -204,15 +210,18 @@
offset = (int)((u2*)addr - stackSave->method->insns);
decInsn = &(shadowSpace->trace[i].decInsn);
/* Not properly decoding instruction, some registers may be garbage */
- LOGD("* 0x%x: (0x%04x) %s v%d, v%d, v%d", addr, offset,
- getOpcodeName(decInsn->opCode), decInsn->vA, decInsn->vB,
- decInsn->vC);
+ LOGD("0x%x: (0x%04x) %s", addr, offset, getOpcodeName(decInsn->opCode));
}
}
/* Code is forced into this spin loop when a divergence is detected */
-static void selfVerificationSpinLoop()
+static void selfVerificationSpinLoop(ShadowSpace *shadowSpace)
{
+ const u2 *startPC = shadowSpace->startPC;
+ JitTraceDescription* desc = dvmCopyTraceDescriptor(startPC);
+ if (desc) {
+ dvmCompilerWorkEnqueue(startPC, kWorkOrderTraceDebug, desc);
+ }
gDvmJit.selfVerificationSpin = true;
while(gDvmJit.selfVerificationSpin) sleep(10);
}
@@ -254,17 +263,20 @@
shadowSpace->registerSpaceSize*4 -
(int) shadowSpace->shadowFP;
if (memcmp(shadowSpace->fp, shadowSpace->shadowFP, frameBytes)) {
- LOGD("~~~ DbgIntp(%d): REGISTERS UNEQUAL!", self->threadId);
+ LOGD("~~~ DbgIntp(%d): REGISTERS DIVERGENCE!", self->threadId);
selfVerificationDumpState(pc, self);
selfVerificationDumpTrace(pc, self);
LOGD("*** Interp Registers: addr: 0x%x bytes: %d",
(int)shadowSpace->fp, frameBytes);
- selfVerificationPrintRegisters((int*)shadowSpace->fp, frameBytes/4);
+ selfVerificationPrintRegisters((int*)shadowSpace->fp,
+ (int*)shadowSpace->shadowFP,
+ frameBytes/4);
LOGD("*** Shadow Registers: addr: 0x%x bytes: %d",
(int)shadowSpace->shadowFP, frameBytes);
selfVerificationPrintRegisters((int*)shadowSpace->shadowFP,
- frameBytes/4);
- selfVerificationSpinLoop();
+ (int*)shadowSpace->fp,
+ frameBytes/4);
+ selfVerificationSpinLoop(shadowSpace);
}
/* Check new frame if it exists (invokes only) */
if (self->curFrame < shadowSpace->fp) {
@@ -275,19 +287,21 @@
(int) self->curFrame - localRegs;
if (memcmp(((char*)self->curFrame)+localRegs,
((char*)shadowSpace->endShadowFP)+localRegs, frameBytes2)) {
- LOGD("~~~ DbgIntp(%d): REGISTERS (FRAME2) UNEQUAL!",
+ LOGD("~~~ DbgIntp(%d): REGISTERS (FRAME2) DIVERGENCE!",
self->threadId);
selfVerificationDumpState(pc, self);
selfVerificationDumpTrace(pc, self);
LOGD("*** Interp Registers: addr: 0x%x l: %d bytes: %d",
(int)self->curFrame, localRegs, frameBytes2);
selfVerificationPrintRegisters((int*)self->curFrame,
- (frameBytes2+localRegs)/4);
+ (int*)shadowSpace->endShadowFP,
+ (frameBytes2+localRegs)/4);
LOGD("*** Shadow Registers: addr: 0x%x l: %d bytes: %d",
(int)shadowSpace->endShadowFP, localRegs, frameBytes2);
selfVerificationPrintRegisters((int*)shadowSpace->endShadowFP,
- (frameBytes2+localRegs)/4);
- selfVerificationSpinLoop();
+ (int*)self->curFrame,
+ (frameBytes2+localRegs)/4);
+ selfVerificationSpinLoop(shadowSpace);
}
}
@@ -298,25 +312,25 @@
heapSpacePtr != shadowSpace->heapSpaceTail; heapSpacePtr++) {
int memData = *((unsigned int*) heapSpacePtr->addr);
if (heapSpacePtr->data != memData) {
- LOGD("~~~ DbgIntp(%d): MEMORY UNEQUAL!", self->threadId);
- LOGD("* Addr: 0x%x Intrp Data: 0x%x Jit Data: 0x%x",
+ LOGD("~~~ DbgIntp(%d): MEMORY DIVERGENCE!", self->threadId);
+ LOGD("Addr: 0x%x Intrp Data: 0x%x Jit Data: 0x%x",
heapSpacePtr->addr, memData, heapSpacePtr->data);
selfVerificationDumpState(pc, self);
selfVerificationDumpTrace(pc, self);
memDiff = true;
}
}
- if (memDiff) selfVerificationSpinLoop();
+ if (memDiff) selfVerificationSpinLoop(shadowSpace);
return true;
/* If end not been reached, make sure max length not exceeded */
} else if (shadowSpace->traceLength >= JIT_MAX_TRACE_LEN) {
LOGD("~~~ DbgIntp(%d): CONTROL DIVERGENCE!", self->threadId);
- LOGD("* startPC: 0x%x endPC: 0x%x currPC: 0x%x",
+ LOGD("startPC: 0x%x endPC: 0x%x currPC: 0x%x",
(int)shadowSpace->startPC, (int)shadowSpace->endPC, (int)pc);
selfVerificationDumpState(pc, self);
selfVerificationDumpTrace(pc, self);
- selfVerificationSpinLoop();
+ selfVerificationSpinLoop(shadowSpace);
return true;
}
@@ -656,7 +670,7 @@
return switchInterp;
}
-static inline JitEntry *findJitEntry(const u2* pc)
+JitEntry *dvmFindJitEntry(const u2* pc)
{
int idx = dvmJitHash(pc);
@@ -674,11 +688,6 @@
return NULL;
}
-JitEntry *dvmFindJitEntry(const u2* pc)
-{
- return findJitEntry(pc);
-}
-
/*
* If a translated code address exists for the davik byte code
* pointer return it. This routine needs to be fast.
diff --git a/vm/interp/Jit.h b/vm/interp/Jit.h
index 70931b8..fe740e5 100644
--- a/vm/interp/Jit.h
+++ b/vm/interp/Jit.h
@@ -43,7 +43,7 @@
typedef struct ShadowSpace {
const u2* startPC; /* starting pc of jitted region */
const void* fp; /* starting fp of jitted region */
- void* glue; /* starting glue ptr of jitted region */
+ const void* glue; /* starting glue of jitted region */
SelfVerificationState selfVerificationState; /* self verification state */
const u2* endPC; /* ending pc of jitted region */
void* shadowFP; /* pointer to fp in shadow space */
@@ -55,6 +55,7 @@
const void* endShadowFP; /* ending fp in shadow space */
InstructionTrace trace[JIT_MAX_TRACE_LEN]; /* opcode trace for debugging */
int traceLength; /* counter for current trace length */
+ const Method* method; /* starting method of jitted region */
} ShadowSpace;
/*
@@ -63,7 +64,7 @@
void* dvmSelfVerificationShadowSpaceAlloc(Thread* self);
void dvmSelfVerificationShadowSpaceFree(Thread* self);
void* dvmSelfVerificationSaveState(const u2* pc, const void* fp,
- void* interpStatePtr);
+ InterpState* interpState);
void* dvmSelfVerificationRestoreState(const u2* pc, const void* fp,
SelfVerificationState exitPoint);
#endif
diff --git a/vm/mterp/armv5te/footer.S b/vm/mterp/armv5te/footer.S
index 461cc66..bca89c1 100644
--- a/vm/mterp/armv5te/footer.S
+++ b/vm/mterp/armv5te/footer.S
@@ -229,17 +229,14 @@
* before jumping to native translation.
*/
dvmJitSelfVerificationStart:
- sub sp,sp,#4 @ allocate stack space
- str r0,[sp,#0] @ save out dvmJitGetCodeAddr(rPC)
+ mov r10, r0 @ r10 <- dvmJitGetCodeAddr(rPC)
mov r0,rPC @ r0<- program counter
mov r1,rFP @ r1<- frame pointer
mov r2,rGLUE @ r2<- InterpState pointer
bl dvmSelfVerificationSaveState @ save registers to shadow space
- ldr rFP,[r0,#20] @ rFP<- fp in shadow space
- add rGLUE,r0,#24 @ rGLUE<- pointer in shadow space
- ldr r0,[sp,#0] @ r0<- dvmJitGetCodeAddr(rPC)
- add sp,sp,#4 @ restore stack
- bx r0 @ jump to the translation
+ ldr rFP,[r0,#offShadowSpace_shadowFP] @ rFP<- fp in shadow space
+ add rGLUE,r0,#offShadowSpace_interpState @ rGLUE<- rGLUE in shadow space
+ bx r10 @ jump to the translation
/*
* Restore PC, registers, and interpState to original values
@@ -248,10 +245,10 @@
dvmJitSelfVerificationEnd:
mov r1,rFP @ pass ending fp
bl dvmSelfVerificationRestoreState @ restore pc and fp values
- ldr rPC,[r0,#0] @ restore PC
- ldr rFP,[r0,#4] @ restore FP
- ldr rGLUE,[r0,#8] @ restore InterpState
- ldr r1,[r0,#12] @ get exitPoint
+ ldr rPC,[r0,#offShadowSpace_startPC] @ restore PC
+ ldr rFP,[r0,#offShadowSpace_fp] @ restore FP
+ ldr rGLUE,[r0,#offShadowSpace_glue] @ restore InterpState
+ ldr r1,[r0,#offShadowSpace_svState] @ get self verification state
cmp r1,#0 @ check for punt condition
beq 1f
mov r2,#kJitSelfVerification @ ask for self verification
diff --git a/vm/mterp/common/asm-constants.h b/vm/mterp/common/asm-constants.h
index e157c37..9dbf6e8 100644
--- a/vm/mterp/common/asm-constants.h
+++ b/vm/mterp/common/asm-constants.h
@@ -169,6 +169,16 @@
MTERP_SIZEOF(sizeofStackSaveArea, StackSaveArea, 20)
#endif
+ /* ShadowSpace fields */
+#if defined(WITH_JIT) && defined(WITH_SELF_VERIFICATION)
+MTERP_OFFSET(offShadowSpace_startPC, ShadowSpace, startPC, 0)
+MTERP_OFFSET(offShadowSpace_fp, ShadowSpace, fp, 4)
+MTERP_OFFSET(offShadowSpace_glue, ShadowSpace, glue, 8)
+MTERP_OFFSET(offShadowSpace_svState, ShadowSpace, selfVerificationState, 12)
+MTERP_OFFSET(offShadowSpace_shadowFP, ShadowSpace, shadowFP, 20)
+MTERP_OFFSET(offShadowSpace_interpState, ShadowSpace, interpState, 24)
+#endif
+
/* InstField fields */
#ifdef PROFILE_FIELD_ACCESS
MTERP_OFFSET(offInstField_byteOffset, InstField, byteOffset, 24)
diff --git a/vm/mterp/out/InterpAsm-armv4t.S b/vm/mterp/out/InterpAsm-armv4t.S
index 07075bb..6153010 100644
--- a/vm/mterp/out/InterpAsm-armv4t.S
+++ b/vm/mterp/out/InterpAsm-armv4t.S
@@ -9701,17 +9701,14 @@
* before jumping to native translation.
*/
dvmJitSelfVerificationStart:
- sub sp,sp,#4 @ allocate stack space
- str r0,[sp,#0] @ save out dvmJitGetCodeAddr(rPC)
+ mov r10, r0 @ r10 <- dvmJitGetCodeAddr(rPC)
mov r0,rPC @ r0<- program counter
mov r1,rFP @ r1<- frame pointer
mov r2,rGLUE @ r2<- InterpState pointer
bl dvmSelfVerificationSaveState @ save registers to shadow space
- ldr rFP,[r0,#20] @ rFP<- fp in shadow space
- add rGLUE,r0,#24 @ rGLUE<- pointer in shadow space
- ldr r0,[sp,#0] @ r0<- dvmJitGetCodeAddr(rPC)
- add sp,sp,#4 @ restore stack
- bx r0 @ jump to the translation
+ ldr rFP,[r0,#offShadowSpace_shadowFP] @ rFP<- fp in shadow space
+ add rGLUE,r0,#offShadowSpace_interpState @ rGLUE<- rGLUE in shadow space
+ bx r10 @ jump to the translation
/*
* Restore PC, registers, and interpState to original values
@@ -9720,10 +9717,10 @@
dvmJitSelfVerificationEnd:
mov r1,rFP @ pass ending fp
bl dvmSelfVerificationRestoreState @ restore pc and fp values
- ldr rPC,[r0,#0] @ restore PC
- ldr rFP,[r0,#4] @ restore FP
- ldr rGLUE,[r0,#8] @ restore InterpState
- ldr r1,[r0,#12] @ get exitPoint
+ ldr rPC,[r0,#offShadowSpace_startPC] @ restore PC
+ ldr rFP,[r0,#offShadowSpace_fp] @ restore FP
+ ldr rGLUE,[r0,#offShadowSpace_glue] @ restore InterpState
+ ldr r1,[r0,#offShadowSpace_svState] @ get self verification state
cmp r1,#0 @ check for punt condition
beq 1f
mov r2,#kJitSelfVerification @ ask for self verification
diff --git a/vm/mterp/out/InterpAsm-armv5te-vfp.S b/vm/mterp/out/InterpAsm-armv5te-vfp.S
index 55ac716..dde4bd5 100644
--- a/vm/mterp/out/InterpAsm-armv5te-vfp.S
+++ b/vm/mterp/out/InterpAsm-armv5te-vfp.S
@@ -9219,17 +9219,14 @@
* before jumping to native translation.
*/
dvmJitSelfVerificationStart:
- sub sp,sp,#4 @ allocate stack space
- str r0,[sp,#0] @ save out dvmJitGetCodeAddr(rPC)
+ mov r10, r0 @ r10 <- dvmJitGetCodeAddr(rPC)
mov r0,rPC @ r0<- program counter
mov r1,rFP @ r1<- frame pointer
mov r2,rGLUE @ r2<- InterpState pointer
bl dvmSelfVerificationSaveState @ save registers to shadow space
- ldr rFP,[r0,#20] @ rFP<- fp in shadow space
- add rGLUE,r0,#24 @ rGLUE<- pointer in shadow space
- ldr r0,[sp,#0] @ r0<- dvmJitGetCodeAddr(rPC)
- add sp,sp,#4 @ restore stack
- bx r0 @ jump to the translation
+ ldr rFP,[r0,#offShadowSpace_shadowFP] @ rFP<- fp in shadow space
+ add rGLUE,r0,#offShadowSpace_interpState @ rGLUE<- rGLUE in shadow space
+ bx r10 @ jump to the translation
/*
* Restore PC, registers, and interpState to original values
@@ -9238,10 +9235,10 @@
dvmJitSelfVerificationEnd:
mov r1,rFP @ pass ending fp
bl dvmSelfVerificationRestoreState @ restore pc and fp values
- ldr rPC,[r0,#0] @ restore PC
- ldr rFP,[r0,#4] @ restore FP
- ldr rGLUE,[r0,#8] @ restore InterpState
- ldr r1,[r0,#12] @ get exitPoint
+ ldr rPC,[r0,#offShadowSpace_startPC] @ restore PC
+ ldr rFP,[r0,#offShadowSpace_fp] @ restore FP
+ ldr rGLUE,[r0,#offShadowSpace_glue] @ restore InterpState
+ ldr r1,[r0,#offShadowSpace_svState] @ get self verification state
cmp r1,#0 @ check for punt condition
beq 1f
mov r2,#kJitSelfVerification @ ask for self verification
diff --git a/vm/mterp/out/InterpAsm-armv5te.S b/vm/mterp/out/InterpAsm-armv5te.S
index 55f6fee..b7d8a6c 100644
--- a/vm/mterp/out/InterpAsm-armv5te.S
+++ b/vm/mterp/out/InterpAsm-armv5te.S
@@ -9695,17 +9695,14 @@
* before jumping to native translation.
*/
dvmJitSelfVerificationStart:
- sub sp,sp,#4 @ allocate stack space
- str r0,[sp,#0] @ save out dvmJitGetCodeAddr(rPC)
+ mov r10, r0 @ r10 <- dvmJitGetCodeAddr(rPC)
mov r0,rPC @ r0<- program counter
mov r1,rFP @ r1<- frame pointer
mov r2,rGLUE @ r2<- InterpState pointer
bl dvmSelfVerificationSaveState @ save registers to shadow space
- ldr rFP,[r0,#20] @ rFP<- fp in shadow space
- add rGLUE,r0,#24 @ rGLUE<- pointer in shadow space
- ldr r0,[sp,#0] @ r0<- dvmJitGetCodeAddr(rPC)
- add sp,sp,#4 @ restore stack
- bx r0 @ jump to the translation
+ ldr rFP,[r0,#offShadowSpace_shadowFP] @ rFP<- fp in shadow space
+ add rGLUE,r0,#offShadowSpace_interpState @ rGLUE<- rGLUE in shadow space
+ bx r10 @ jump to the translation
/*
* Restore PC, registers, and interpState to original values
@@ -9714,10 +9711,10 @@
dvmJitSelfVerificationEnd:
mov r1,rFP @ pass ending fp
bl dvmSelfVerificationRestoreState @ restore pc and fp values
- ldr rPC,[r0,#0] @ restore PC
- ldr rFP,[r0,#4] @ restore FP
- ldr rGLUE,[r0,#8] @ restore InterpState
- ldr r1,[r0,#12] @ get exitPoint
+ ldr rPC,[r0,#offShadowSpace_startPC] @ restore PC
+ ldr rFP,[r0,#offShadowSpace_fp] @ restore FP
+ ldr rGLUE,[r0,#offShadowSpace_glue] @ restore InterpState
+ ldr r1,[r0,#offShadowSpace_svState] @ get self verification state
cmp r1,#0 @ check for punt condition
beq 1f
mov r2,#kJitSelfVerification @ ask for self verification
diff --git a/vm/mterp/out/InterpAsm-armv7-a.S b/vm/mterp/out/InterpAsm-armv7-a.S
index 3c896ae..ea9e713 100644
--- a/vm/mterp/out/InterpAsm-armv7-a.S
+++ b/vm/mterp/out/InterpAsm-armv7-a.S
@@ -9155,17 +9155,14 @@
* before jumping to native translation.
*/
dvmJitSelfVerificationStart:
- sub sp,sp,#4 @ allocate stack space
- str r0,[sp,#0] @ save out dvmJitGetCodeAddr(rPC)
+ mov r10, r0 @ r10 <- dvmJitGetCodeAddr(rPC)
mov r0,rPC @ r0<- program counter
mov r1,rFP @ r1<- frame pointer
mov r2,rGLUE @ r2<- InterpState pointer
bl dvmSelfVerificationSaveState @ save registers to shadow space
- ldr rFP,[r0,#20] @ rFP<- fp in shadow space
- add rGLUE,r0,#24 @ rGLUE<- pointer in shadow space
- ldr r0,[sp,#0] @ r0<- dvmJitGetCodeAddr(rPC)
- add sp,sp,#4 @ restore stack
- bx r0 @ jump to the translation
+ ldr rFP,[r0,#offShadowSpace_shadowFP] @ rFP<- fp in shadow space
+ add rGLUE,r0,#offShadowSpace_interpState @ rGLUE<- rGLUE in shadow space
+ bx r10 @ jump to the translation
/*
* Restore PC, registers, and interpState to original values
@@ -9174,10 +9171,10 @@
dvmJitSelfVerificationEnd:
mov r1,rFP @ pass ending fp
bl dvmSelfVerificationRestoreState @ restore pc and fp values
- ldr rPC,[r0,#0] @ restore PC
- ldr rFP,[r0,#4] @ restore FP
- ldr rGLUE,[r0,#8] @ restore InterpState
- ldr r1,[r0,#12] @ get exitPoint
+ ldr rPC,[r0,#offShadowSpace_startPC] @ restore PC
+ ldr rFP,[r0,#offShadowSpace_fp] @ restore FP
+ ldr rGLUE,[r0,#offShadowSpace_glue] @ restore InterpState
+ ldr r1,[r0,#offShadowSpace_svState] @ get self verification state
cmp r1,#0 @ check for punt condition
beq 1f
mov r2,#kJitSelfVerification @ ask for self verification
