From 9f601a917c8878204482c37aec7005054b6776fa Mon Sep 17 00:00:00 2001 From: buzbee Date: Fri, 11 Feb 2011 17:48:20 -0800 Subject: Interpreter restructuring: eliminate InterpState The key datastructure for the interpreter is InterpState. This change eliminates it, merging its data with the Thread structure. Here's why: In principio creavit Fadden Thread et InterpState. And it was good. Thread holds thread-private state, while InterpState captures data associated with a Dalvik interpreter activation. Because JNI calls can result in nested interpreter invocations, we can have more than one InterpState for each actual thread. InterpState was relatively small, and it all worked well. It was used enough that in the Arm version a register (rGLUE) was dedicated to it. Then, along came the JIT guys, who saw InterpState as a convenient place to dump all sorts of useful data that they wanted quick access to through that dedicated register. InterpState grew and grew. In terms of space, this wasn't a big problem - but it did mean that the initialization cost of each interpreter activation grew as well. For applications that do a lot of callbacks from native code into Dalvik, this is measurable. It's also mostly useless cost because much of the JIT-related InterpState initialization was setting up useful constants - things that don't need to be saved and restored all the time. The biggest problem, though, deals with thread control. When something interesting is happening that needs all threads to be stopped (such as GC and debugger attach), we have access to all of the Thread structures, but we don't have access to all of the InterpState structures (which may be buried/nested on the native stack). As a result, polling for thread suspension is done via a one-indirection pointer chase. InterpState itself can't hold the stop bits because we can't always find it, so instead it holds a pointer to the global or thread-specific stop control. Yuck. With this change, we eliminate InterpState and merge all needed data into Thread. Further, we replace the decidated rGLUE register with a pointer to the Thread structure (rSELF). The small subset of state data that needs to be saved and restored across nested interpreter activations is collected into a record that is saved to the interpreter frame, and restored on exit. Further, these small records are linked together to allow tracebacks to show nested activations. Old InterpState variables that simply contain useful constants are initialized once at thread creation time. This CL is large enough by itself that the new ability to streamline suspend checks is not done here - that will happen in a future CL. Here we just focus on consolidation. Change-Id: Ide6b2fb85716fea454ac113f5611263a96687356 --- vm/Profile.c | 16 +- vm/Profile.h | 9 +- vm/Thread.c | 3 + vm/Thread.h | 106 +- vm/compiler/Compiler.h | 77 -- vm/compiler/codegen/CodegenFactory.c | 12 +- vm/compiler/codegen/arm/ArmLIR.h | 4 +- vm/compiler/codegen/arm/ArmRallocUtil.c | 4 +- vm/compiler/codegen/arm/Assemble.c | 6 +- vm/compiler/codegen/arm/CalloutHelper.h | 2 +- vm/compiler/codegen/arm/CodegenDriver.c | 57 +- vm/compiler/codegen/arm/Thumb/Gen.c | 14 +- vm/compiler/codegen/arm/Thumb2/Gen.c | 8 +- vm/compiler/codegen/arm/armv5te-vfp/ArchVariant.c | 4 +- vm/compiler/codegen/arm/armv5te/ArchVariant.c | 4 +- vm/compiler/codegen/arm/armv7-a-neon/ArchVariant.c | 4 +- vm/compiler/codegen/arm/armv7-a/ArchVariant.c | 4 +- vm/compiler/codegen/x86/Assemble.c | 2 +- vm/compiler/codegen/x86/CodegenDriver.c | 4 +- vm/compiler/codegen/x86/ia32/ArchVariant.c | 2 +- .../template/armv5te-vfp/TEMPLATE_RESTORE_STATE.S | 4 +- .../template/armv5te-vfp/TEMPLATE_SAVE_STATE.S | 4 +- vm/compiler/template/armv5te/TEMPLATE_INTERPRET.S | 2 +- .../armv5te/TEMPLATE_INVOKE_METHOD_CHAIN.S | 16 +- .../armv5te/TEMPLATE_INVOKE_METHOD_NATIVE.S | 36 +- .../armv5te/TEMPLATE_INVOKE_METHOD_NO_OPT.S | 16 +- .../TEMPLATE_INVOKE_METHOD_PREDICTED_CHAIN.S | 4 +- .../template/armv5te/TEMPLATE_MONITOR_ENTER.S | 6 +- .../armv5te/TEMPLATE_MONITOR_ENTER_DEBUG.S | 9 +- .../template/armv5te/TEMPLATE_PERIODIC_PROFILING.S | 2 +- .../template/armv5te/TEMPLATE_RESTORE_STATE.S | 4 +- vm/compiler/template/armv5te/TEMPLATE_RETURN.S | 18 +- vm/compiler/template/armv5te/TEMPLATE_SAVE_STATE.S | 4 +- vm/compiler/template/armv5te/footer.S | 32 +- vm/compiler/template/armv5te/header.S | 4 +- vm/compiler/template/ia32/TEMPLATE_INTERPRET.S | 14 +- vm/compiler/template/ia32/header.S | 2 +- .../template/out/CompilerTemplateAsm-armv5te-vfp.S | 235 ++-- .../template/out/CompilerTemplateAsm-armv5te.S | 235 ++-- .../out/CompilerTemplateAsm-armv7-a-neon.S | 235 ++-- .../template/out/CompilerTemplateAsm-armv7-a.S | 235 ++-- .../template/out/CompilerTemplateAsm-ia32.S | 16 +- vm/interp/Interp.c | 114 +- vm/interp/Interp.h | 1 + vm/interp/InterpDefs.h | 152 +-- vm/interp/InterpState.h | 177 +++ vm/interp/Jit.c | 305 +++--- vm/interp/Jit.h | 26 +- vm/mterp/Mterp.c | 53 +- vm/mterp/Mterp.h | 11 +- vm/mterp/armv5te/OP_APUT_OBJECT.S | 2 +- vm/mterp/armv5te/OP_CHECK_CAST.S | 4 +- vm/mterp/armv5te/OP_CHECK_CAST_JUMBO.S | 4 +- vm/mterp/armv5te/OP_CONST_CLASS.S | 4 +- vm/mterp/armv5te/OP_CONST_CLASS_JUMBO.S | 4 +- vm/mterp/armv5te/OP_CONST_STRING.S | 4 +- vm/mterp/armv5te/OP_CONST_STRING_JUMBO.S | 4 +- vm/mterp/armv5te/OP_EXECUTE_INLINE.S | 4 +- vm/mterp/armv5te/OP_EXECUTE_INLINE_RANGE.S | 4 +- vm/mterp/armv5te/OP_FILLED_NEW_ARRAY.S | 14 +- vm/mterp/armv5te/OP_FILLED_NEW_ARRAY_JUMBO.S | 14 +- vm/mterp/armv5te/OP_IGET.S | 4 +- vm/mterp/armv5te/OP_IGET_JUMBO.S | 4 +- vm/mterp/armv5te/OP_IGET_WIDE.S | 4 +- vm/mterp/armv5te/OP_IGET_WIDE_JUMBO.S | 4 +- vm/mterp/armv5te/OP_INSTANCE_OF.S | 4 +- vm/mterp/armv5te/OP_INSTANCE_OF_JUMBO.S | 4 +- vm/mterp/armv5te/OP_INVOKE_DIRECT.S | 4 +- vm/mterp/armv5te/OP_INVOKE_DIRECT_JUMBO.S | 4 +- vm/mterp/armv5te/OP_INVOKE_INTERFACE.S | 4 +- vm/mterp/armv5te/OP_INVOKE_INTERFACE_JUMBO.S | 4 +- vm/mterp/armv5te/OP_INVOKE_STATIC.S | 4 +- vm/mterp/armv5te/OP_INVOKE_STATIC_JUMBO.S | 4 +- vm/mterp/armv5te/OP_INVOKE_SUPER.S | 4 +- vm/mterp/armv5te/OP_INVOKE_SUPER_JUMBO.S | 4 +- vm/mterp/armv5te/OP_INVOKE_SUPER_QUICK.S | 2 +- vm/mterp/armv5te/OP_INVOKE_VIRTUAL.S | 4 +- vm/mterp/armv5te/OP_INVOKE_VIRTUAL_JUMBO.S | 4 +- vm/mterp/armv5te/OP_IPUT.S | 4 +- vm/mterp/armv5te/OP_IPUT_JUMBO.S | 4 +- vm/mterp/armv5te/OP_IPUT_OBJECT.S | 6 +- vm/mterp/armv5te/OP_IPUT_OBJECT_JUMBO.S | 6 +- vm/mterp/armv5te/OP_IPUT_OBJECT_QUICK.S | 2 +- vm/mterp/armv5te/OP_IPUT_WIDE.S | 4 +- vm/mterp/armv5te/OP_IPUT_WIDE_JUMBO.S | 4 +- vm/mterp/armv5te/OP_MONITOR_ENTER.S | 2 +- vm/mterp/armv5te/OP_MONITOR_EXIT.S | 2 +- vm/mterp/armv5te/OP_MOVE_EXCEPTION.S | 5 +- vm/mterp/armv5te/OP_MOVE_RESULT.S | 2 +- vm/mterp/armv5te/OP_MOVE_RESULT_WIDE.S | 2 +- vm/mterp/armv5te/OP_NEW_ARRAY.S | 4 +- vm/mterp/armv5te/OP_NEW_ARRAY_JUMBO.S | 4 +- vm/mterp/armv5te/OP_NEW_INSTANCE.S | 4 +- vm/mterp/armv5te/OP_NEW_INSTANCE_JUMBO.S | 4 +- vm/mterp/armv5te/OP_RETURN.S | 4 +- vm/mterp/armv5te/OP_RETURN_WIDE.S | 4 +- vm/mterp/armv5te/OP_SGET.S | 4 +- vm/mterp/armv5te/OP_SGET_JUMBO.S | 4 +- vm/mterp/armv5te/OP_SGET_WIDE.S | 4 +- vm/mterp/armv5te/OP_SGET_WIDE_JUMBO.S | 4 +- vm/mterp/armv5te/OP_SPUT.S | 4 +- vm/mterp/armv5te/OP_SPUT_JUMBO.S | 4 +- vm/mterp/armv5te/OP_SPUT_OBJECT.S | 6 +- vm/mterp/armv5te/OP_SPUT_OBJECT_JUMBO.S | 6 +- vm/mterp/armv5te/OP_SPUT_WIDE.S | 4 +- vm/mterp/armv5te/OP_SPUT_WIDE_JUMBO.S | 4 +- vm/mterp/armv5te/OP_THROW.S | 3 +- vm/mterp/armv5te/OP_THROW_VERIFICATION_ERROR.S | 2 +- .../armv5te/OP_THROW_VERIFICATION_ERROR_JUMBO.S | 2 +- vm/mterp/armv5te/debug.c | 10 +- vm/mterp/armv5te/entry.S | 27 +- vm/mterp/armv5te/footer.S | 230 ++-- vm/mterp/armv5te/header.S | 22 +- vm/mterp/armv5te/stub.S | 6 +- vm/mterp/armv6t2/OP_IGET.S | 4 +- vm/mterp/armv6t2/OP_IGET_WIDE.S | 4 +- vm/mterp/armv6t2/OP_IPUT.S | 4 +- vm/mterp/armv6t2/OP_IPUT_WIDE.S | 4 +- vm/mterp/common/asm-constants.h | 112 +- vm/mterp/cstubs/entry.c | 22 +- vm/mterp/cstubs/stubdefs.c | 37 +- vm/mterp/out/InterpAsm-armv5te-vfp.S | 763 +++++++------ vm/mterp/out/InterpAsm-armv5te.S | 763 +++++++------ vm/mterp/out/InterpAsm-armv7-a-neon.S | 763 +++++++------ vm/mterp/out/InterpAsm-armv7-a.S | 763 +++++++------ vm/mterp/out/InterpAsm-x86.S | 1122 ++++++++++---------- vm/mterp/out/InterpC-allstubs.c | 59 +- vm/mterp/out/InterpC-armv5te-vfp.c | 47 +- vm/mterp/out/InterpC-armv5te.c | 47 +- vm/mterp/out/InterpC-armv7-a-neon.c | 47 +- vm/mterp/out/InterpC-armv7-a.c | 47 +- vm/mterp/out/InterpC-portdbg.c | 68 +- vm/mterp/out/InterpC-portstd.c | 62 +- vm/mterp/out/InterpC-x86-atom.c | 37 +- vm/mterp/out/InterpC-x86.c | 37 +- vm/mterp/portable/enddefs.c | 16 +- vm/mterp/portable/entry.c | 42 +- vm/mterp/portable/portdbg.c | 6 +- vm/mterp/portable/stubdefs.c | 4 +- vm/mterp/x86-atom/TODO.txt | 2 + vm/mterp/x86/OP_APUT_OBJECT.S | 4 +- vm/mterp/x86/OP_CHECK_CAST.S | 8 +- vm/mterp/x86/OP_CHECK_CAST_JUMBO.S | 8 +- vm/mterp/x86/OP_CONST_CLASS.S | 8 +- vm/mterp/x86/OP_CONST_CLASS_JUMBO.S | 8 +- vm/mterp/x86/OP_CONST_STRING.S | 8 +- vm/mterp/x86/OP_CONST_STRING_JUMBO.S | 8 +- vm/mterp/x86/OP_EXECUTE_INLINE.S | 4 +- vm/mterp/x86/OP_FILLED_NEW_ARRAY.S | 28 +- vm/mterp/x86/OP_FILLED_NEW_ARRAY_JUMBO.S | 24 +- vm/mterp/x86/OP_IGET.S | 8 +- vm/mterp/x86/OP_IGET_JUMBO.S | 8 +- vm/mterp/x86/OP_IGET_WIDE.S | 8 +- vm/mterp/x86/OP_IGET_WIDE_JUMBO.S | 8 +- vm/mterp/x86/OP_INSTANCE_OF.S | 8 +- vm/mterp/x86/OP_INSTANCE_OF_JUMBO.S | 8 +- vm/mterp/x86/OP_INVOKE_DIRECT.S | 8 +- vm/mterp/x86/OP_INVOKE_DIRECT_JUMBO.S | 8 +- vm/mterp/x86/OP_INVOKE_INTERFACE.S | 6 +- vm/mterp/x86/OP_INVOKE_INTERFACE_JUMBO.S | 6 +- vm/mterp/x86/OP_INVOKE_STATIC.S | 8 +- vm/mterp/x86/OP_INVOKE_STATIC_JUMBO.S | 8 +- vm/mterp/x86/OP_INVOKE_SUPER.S | 6 +- vm/mterp/x86/OP_INVOKE_SUPER_JUMBO.S | 6 +- vm/mterp/x86/OP_INVOKE_SUPER_QUICK.S | 4 +- vm/mterp/x86/OP_INVOKE_VIRTUAL.S | 8 +- vm/mterp/x86/OP_INVOKE_VIRTUAL_JUMBO.S | 8 +- vm/mterp/x86/OP_IPUT.S | 8 +- vm/mterp/x86/OP_IPUT_JUMBO.S | 8 +- vm/mterp/x86/OP_IPUT_OBJECT.S | 12 +- vm/mterp/x86/OP_IPUT_OBJECT_JUMBO.S | 12 +- vm/mterp/x86/OP_IPUT_OBJECT_QUICK.S | 4 +- vm/mterp/x86/OP_IPUT_WIDE.S | 8 +- vm/mterp/x86/OP_IPUT_WIDE_JUMBO.S | 8 +- vm/mterp/x86/OP_MONITOR_ENTER.S | 3 +- vm/mterp/x86/OP_MONITOR_EXIT.S | 3 +- vm/mterp/x86/OP_MOVE_EXCEPTION.S | 3 +- vm/mterp/x86/OP_MOVE_RESULT.S | 4 +- vm/mterp/x86/OP_MOVE_RESULT_WIDE.S | 6 +- vm/mterp/x86/OP_NEW_ARRAY.S | 8 +- vm/mterp/x86/OP_NEW_ARRAY_JUMBO.S | 8 +- vm/mterp/x86/OP_NEW_INSTANCE.S | 8 +- vm/mterp/x86/OP_NEW_INSTANCE_JUMBO.S | 8 +- vm/mterp/x86/OP_RETURN.S | 6 +- vm/mterp/x86/OP_RETURN_WIDE.S | 8 +- vm/mterp/x86/OP_SGET.S | 8 +- vm/mterp/x86/OP_SGET_JUMBO.S | 8 +- vm/mterp/x86/OP_SGET_WIDE.S | 8 +- vm/mterp/x86/OP_SGET_WIDE_JUMBO.S | 8 +- vm/mterp/x86/OP_SPUT.S | 8 +- vm/mterp/x86/OP_SPUT_JUMBO.S | 8 +- vm/mterp/x86/OP_SPUT_OBJECT.S | 12 +- vm/mterp/x86/OP_SPUT_OBJECT_JUMBO.S | 12 +- vm/mterp/x86/OP_SPUT_WIDE.S | 8 +- vm/mterp/x86/OP_SPUT_WIDE_JUMBO.S | 8 +- vm/mterp/x86/OP_THROW.S | 3 +- vm/mterp/x86/OP_THROW_VERIFICATION_ERROR.S | 4 +- vm/mterp/x86/OP_THROW_VERIFICATION_ERROR_JUMBO.S | 4 +- vm/mterp/x86/entry.S | 24 +- vm/mterp/x86/footer.S | 118 +- vm/mterp/x86/header.S | 30 +- vm/mterp/x86/stub.S | 8 +- 202 files changed, 4080 insertions(+), 4293 deletions(-) create mode 100644 vm/interp/InterpState.h diff --git a/vm/Profile.c b/vm/Profile.c index d1f5b237f..f8b6f19d5 100644 --- a/vm/Profile.c +++ b/vm/Profile.c @@ -718,23 +718,22 @@ void dvmMethodTraceAdd(Thread* self, const Method* method, int action) * Register the METHOD_TRACE_ENTER action for the fast interpreter and * JIT'ed code. */ -void dvmFastMethodTraceEnter(const Method* method, - const struct InterpState* interpState) +void dvmFastMethodTraceEnter(const Method* method, Thread* self) { if (gDvm.interpBreak & kSubModeMethodTrace) { - dvmMethodTraceAdd(interpState->self, method, METHOD_TRACE_ENTER); + dvmMethodTraceAdd(self, method, METHOD_TRACE_ENTER); } } /* * Register the METHOD_TRACE_EXIT action for the fast interpreter and * JIT'ed code for Java methods. The about-to-return callee method can be - * retrieved from interpState->method. + * retrieved from self->interpSave.method. */ -void dvmFastJavaMethodTraceExit(const struct InterpState* interpState) +void dvmFastJavaMethodTraceExit(Thread* self) { if (gDvm.interpBreak & kSubModeMethodTrace) { - dvmMethodTraceAdd(interpState->self, interpState->method, + dvmMethodTraceAdd(self, self->interpSave.method, METHOD_TRACE_EXIT); } } @@ -744,11 +743,10 @@ void dvmFastJavaMethodTraceExit(const struct InterpState* interpState) * JIT'ed code for JNI methods. The about-to-return JNI callee method is passed * in explicitly. */ -void dvmFastNativeMethodTraceExit(const Method* method, - const struct InterpState* interpState) +void dvmFastNativeMethodTraceExit(const Method* method, Thread* self) { if (gDvm.interpBreak & kSubModeMethodTrace) { - dvmMethodTraceAdd(interpState->self, method, METHOD_TRACE_EXIT); + dvmMethodTraceAdd(self, method, METHOD_TRACE_EXIT); } } diff --git a/vm/Profile.h b/vm/Profile.h index 9d604338b..016984de3 100644 --- a/vm/Profile.h +++ b/vm/Profile.h @@ -141,12 +141,9 @@ void dvmMethodTraceGCEnd(void); void dvmMethodTraceClassPrepBegin(void); void dvmMethodTraceClassPrepEnd(void); -struct InterpState; // extern -void dvmFastMethodTraceEnter(const Method* method, - const struct InterpState* interpState); -void dvmFastJavaMethodTraceExit(const struct InterpState* interpState); -void dvmFastNativeMethodTraceExit(const Method*method, - const struct InterpState* interpState); +void dvmFastMethodTraceEnter(const Method* method, struct Thread* self); +void dvmFastJavaMethodTraceExit(struct Thread* self); +void dvmFastNativeMethodTraceExit(const Method* method, struct Thread* self); /* * Start/stop alloc counting. diff --git a/vm/Thread.c b/vm/Thread.c index 6745dae36..b340f0bb7 100644 --- a/vm/Thread.c +++ b/vm/Thread.c @@ -974,6 +974,9 @@ static Thread* allocThread(int interpStackSize) /* give the thread code a chance to set things up */ dvmInitInterpStack(thread, interpStackSize); + /* One-time setup for interpreter/JIT state */ + dvmInitInterpreterState(thread); + return thread; } diff --git a/vm/Thread.h b/vm/Thread.h index bcd85a918..33277ba8c 100644 --- a/vm/Thread.h +++ b/vm/Thread.h @@ -21,6 +21,7 @@ #define _DALVIK_THREAD #include "jni.h" +#include "interp/InterpState.h" #include #include @@ -86,15 +87,18 @@ void dvmSlayDaemons(void); * These are allocated on the system heap. */ typedef struct Thread { - /* small unique integer; useful for "thin" locks and debug messages */ - u4 threadId; - /* - * Thread's current status. Can only be changed by the thread itself - * (i.e. don't mess with this from other threads). + * Interpreter state which must be preserved across nested + * interpreter invocations (via JNI callbacks). Must be the first + * element in Thread. */ - volatile ThreadStatus status; - + InterpSaveState interpSave; + /* + * Begin interpreter state which does not need to be preserved, but should + * be located towards the beginning of the Thread structure for + * efficiency. + */ + JValue retval; /* * This is the number of times the thread has been suspended. When the * count drops to zero, the thread resumes. @@ -118,57 +122,88 @@ typedef struct Thread { int suspendCount; int dbgSuspendCount; - /* thread handle, as reported by pthread_self() */ - pthread_t handle; - - /* thread ID, only useful under Linux */ - pid_t systemTid; - - /* start (high addr) of interp stack (subtract size to get malloc addr) */ - u1* interpStackStart; + u1* cardTable; /* current limit of stack; flexes for StackOverflowError */ const u1* interpStackEnd; - /* interpreter stack size; our stacks are fixed-length */ - int interpStackSize; - bool stackOverflowed; - /* FP of bottom-most (currently executing) stack frame on interp stack */ void* curFrame; - /* current exception, or NULL if nothing pending */ Object* exception; - /* the java/lang/Thread that we are associated with */ - Object* threadObj; + /* small unique integer; useful for "thin" locks and debug messages */ + u4 threadId; - /* the JNIEnv pointer associated with this thread */ - JNIEnv* jniEnv; + bool debugIsMethodEntry; + /* interpreter stack size; our stacks are fixed-length */ + int interpStackSize; + bool stackOverflowed; - /* internal reference tracking */ - ReferenceTable internalLocalRefTable; + InterpEntry entryPoint; // What to do when we start the interpreter -#if defined(WITH_JIT) + /* JNI local reference tracking */ +#ifdef USE_INDIRECT_REF + IndirectRefTable jniLocalRefTable; +#else + ReferenceTable jniLocalRefTable; +#endif + +#ifdef WITH_JIT + struct JitToInterpEntries jitToInterpEntries; /* * Whether the current top VM frame is in the interpreter or JIT cache: * NULL : in the interpreter * non-NULL: entry address of the JIT'ed code (the actual value doesn't * matter) */ - void* inJitCodeCache; + void* inJitCodeCache; + unsigned char* pJitProfTable; + unsigned char** ppJitProfTable; // Used to refresh pJitProfTable + int jitThreshold; + const void* jitResumeNPC; + const u2* jitResumeDPC; + JitState jitState; + int icRechainCount; + const void* pProfileCountdown; #if defined(WITH_SELF_VERIFICATION) /* Buffer for register state during self verification */ struct ShadowSpace* shadowSpace; #endif + int currTraceRun; + int totalTraceLen; // Number of Dalvik insts in trace + const u2* currTraceHead; // Start of the trace we're building + const u2* currRunHead; // Start of run we're building + int currRunLen; // Length of run in 16-bit words + const u2* lastPC; // Stage the PC for the threaded interpreter + intptr_t threshFilter[JIT_TRACE_THRESH_FILTER_SIZE]; + JitTraceRun trace[MAX_JIT_RUN_LEN]; #endif - /* JNI local reference tracking */ -#ifdef USE_INDIRECT_REF - IndirectRefTable jniLocalRefTable; -#else - ReferenceTable jniLocalRefTable; -#endif + /* + * Thread's current status. Can only be changed by the thread itself + * (i.e. don't mess with this from other threads). + */ + volatile ThreadStatus status; + + /* thread handle, as reported by pthread_self() */ + pthread_t handle; + + /* thread ID, only useful under Linux */ + pid_t systemTid; + + /* start (high addr) of interp stack (subtract size to get malloc addr) */ + u1* interpStackStart; + + /* the java/lang/Thread that we are associated with */ + Object* threadObj; + + /* the JNIEnv pointer associated with this thread */ + JNIEnv* jniEnv; + + /* internal reference tracking */ + ReferenceTable internalLocalRefTable; + /* JNI native monitor reference tracking (initialized on first use) */ ReferenceTable jniMonitorRefTable; @@ -210,6 +245,9 @@ typedef struct Thread { /* JDWP invoke-during-breakpoint support */ DebugInvokeReq invokeReq; + /* Interpreter switching */ + int nextMode; + /* base time for per-thread CPU timing (used by method profiling) */ bool cpuClockBaseSet; u8 cpuClockBase; diff --git a/vm/compiler/Compiler.h b/vm/compiler/Compiler.h index 7533e2630..c566aa6c4 100644 --- a/vm/compiler/Compiler.h +++ b/vm/compiler/Compiler.h @@ -25,7 +25,6 @@ * #define SIGNATURE_BREAKPOINT */ -#define MAX_JIT_RUN_LEN 64 #define COMPILER_WORK_QUEUE_SIZE 100 #define COMPILER_IC_PATCH_QUEUE_SIZE 64 @@ -119,82 +118,6 @@ typedef struct ICPatchWorkOrder { PredictedChainingCell cellContent; /* content of the new cell */ } ICPatchWorkOrder; -/* States of the dbg interpreter when serving a JIT-related request */ -typedef enum JitState { - /* Entering states in the debug interpreter */ - kJitNot = 0, // Non-JIT related reasons */ - kJitTSelectRequest = 1, // Request a trace (subject to filtering) - kJitTSelectRequestHot = 2, // Request a hot trace (bypass the filter) - kJitSelfVerification = 3, // Self Verification Mode - - /* Operational states in the debug interpreter */ - kJitTSelect = 4, // Actively selecting a trace - kJitTSelectEnd = 5, // Done with the trace - wrap it up - kJitSingleStep = 6, // Single step interpretation - kJitSingleStepEnd = 7, // Done with single step, ready return to mterp - kJitDone = 8, // Ready to leave the debug interpreter -} JitState; - -#if defined(WITH_SELF_VERIFICATION) -typedef enum SelfVerificationState { - kSVSIdle = 0, // Idle - kSVSStart = 1, // Shadow space set up, running compiled code - kSVSPunt = 2, // Exiting compiled code by punting - kSVSSingleStep = 3, // Exiting compiled code by single stepping - kSVSNoProfile = 4, // Exiting compiled code and don't collect profiles - kSVSTraceSelect = 5, // Exiting compiled code and compile the next pc - kSVSNormal = 6, // Exiting compiled code normally - kSVSNoChain = 7, // Exiting compiled code by no chain - kSVSBackwardBranch = 8, // Exiting compiled code with backward branch trace - kSVSDebugInterp = 9, // Normal state restored, running debug interpreter -} SelfVerificationState; -#endif - -typedef enum JitHint { - kJitHintNone = 0, - kJitHintTaken = 1, // Last inst in run was taken branch - kJitHintNotTaken = 2, // Last inst in run was not taken branch - kJitHintNoBias = 3, // Last inst in run was unbiased branch -} jitHint; - -/* - * Element of a Jit trace description. If the isCode bit is set, it describes - * a contiguous sequence of Dalvik byte codes. - */ -typedef struct { - unsigned isCode:1; // If set denotes code fragments - unsigned numInsts:8; // Number of Byte codes in run - unsigned runEnd:1; // Run ends with last byte code - jitHint hint:6; // Hint to apply to final code of run - u2 startOffset; // Starting offset for trace run -} JitCodeDesc; - -/* - * A complete list of trace runs passed to the compiler looks like the - * following: - * frag1 - * frag2 - * frag3 - * meta1 - * meta2 - * frag4 - * - * frags 1-4 have the "isCode" field set, and metas 1-2 are plain pointers or - * pointers to auxiliary data structures as long as the LSB is null. - * The meaning of the meta content is loosely defined. It is usually the code - * fragment right before the first meta field (frag3 in this case) to - * understand and parse them. Frag4 could be a dummy one with 0 "numInsts" but - * the "runEnd" field set. - * - * For example, if a trace run contains a method inlining target, the class - * type of "this" and the currently resolved method pointer are two instances - * of meta information stored there. - */ -typedef union { - JitCodeDesc frag; - void* meta; -} JitTraceRun; - /* * Trace description as will appear in the translation cache. Note * flexible array at end, as these will be of variable size. To diff --git a/vm/compiler/codegen/CodegenFactory.c b/vm/compiler/codegen/CodegenFactory.c index aad6512b0..61e29d7d1 100644 --- a/vm/compiler/codegen/CodegenFactory.c +++ b/vm/compiler/codegen/CodegenFactory.c @@ -57,7 +57,7 @@ static void loadValueDirect(CompilationUnit *cUnit, RegLocation rlSrc, if (rlSrc.location == kLocPhysReg) { genRegCopy(cUnit, reg1, rlSrc.lowReg); } else if (rlSrc.location == kLocRetval) { - loadWordDisp(cUnit, rGLUE, offsetof(InterpState, retval), reg1); + loadWordDisp(cUnit, rSELF, offsetof(Thread, retval), reg1); } else { assert(rlSrc.location == kLocDalvikFrame); loadWordDisp(cUnit, rFP, dvmCompilerS2VReg(cUnit, rlSrc.sRegLow) << 2, @@ -90,7 +90,7 @@ static void loadValueDirectWide(CompilationUnit *cUnit, RegLocation rlSrc, if (rlSrc.location == kLocPhysReg) { genRegCopyWide(cUnit, regLo, regHi, rlSrc.lowReg, rlSrc.highReg); } else if (rlSrc.location == kLocRetval) { - loadBaseDispWide(cUnit, NULL, rGLUE, offsetof(InterpState, retval), + loadBaseDispWide(cUnit, NULL, rSELF, offsetof(Thread, retval), regLo, regHi, INVALID_SREG); } else { assert(rlSrc.location == kLocDalvikFrame); @@ -124,7 +124,7 @@ static RegLocation loadValue(CompilationUnit *cUnit, RegLocation rlSrc, rlSrc.location = kLocPhysReg; dvmCompilerMarkLive(cUnit, rlSrc.lowReg, rlSrc.sRegLow); } else if (rlSrc.location == kLocRetval) { - loadWordDisp(cUnit, rGLUE, offsetof(InterpState, retval), rlSrc.lowReg); + loadWordDisp(cUnit, rSELF, offsetof(Thread, retval), rlSrc.lowReg); rlSrc.location = kLocPhysReg; dvmCompilerClobber(cUnit, rlSrc.lowReg); } @@ -164,7 +164,7 @@ static void storeValue(CompilationUnit *cUnit, RegLocation rlDest, if (rlDest.location == kLocRetval) { - storeBaseDisp(cUnit, rGLUE, offsetof(InterpState, retval), + storeBaseDisp(cUnit, rSELF, offsetof(Thread, retval), rlDest.lowReg, kWord); dvmCompilerClobber(cUnit, rlDest.lowReg); } else { @@ -192,7 +192,7 @@ static RegLocation loadValueWide(CompilationUnit *cUnit, RegLocation rlSrc, dvmCompilerMarkLive(cUnit, rlSrc.highReg, dvmCompilerSRegHi(rlSrc.sRegLow)); } else if (rlSrc.location == kLocRetval) { - loadBaseDispWide(cUnit, NULL, rGLUE, offsetof(InterpState, retval), + loadBaseDispWide(cUnit, NULL, rSELF, offsetof(Thread, retval), rlSrc.lowReg, rlSrc.highReg, INVALID_SREG); rlSrc.location = kLocPhysReg; dvmCompilerClobber(cUnit, rlSrc.lowReg); @@ -242,7 +242,7 @@ static void storeValueWide(CompilationUnit *cUnit, RegLocation rlDest, if (rlDest.location == kLocRetval) { - storeBaseDispWide(cUnit, rGLUE, offsetof(InterpState, retval), + storeBaseDispWide(cUnit, rSELF, offsetof(Thread, retval), rlDest.lowReg, rlDest.highReg); dvmCompilerClobber(cUnit, rlDest.lowReg); dvmCompilerClobber(cUnit, rlDest.highReg); diff --git a/vm/compiler/codegen/arm/ArmLIR.h b/vm/compiler/codegen/arm/ArmLIR.h index 5adc1ed8e..1f8b5d097 100644 --- a/vm/compiler/codegen/arm/ArmLIR.h +++ b/vm/compiler/codegen/arm/ArmLIR.h @@ -24,7 +24,7 @@ * r0, r1, r2, r3 are always scratch * r4 (rPC) is scratch for Jit, but most be restored when resuming interp * r5 (rFP) is reserved [holds Dalvik frame pointer] - * r6 (rGLUE) is reserved [holds current &interpState] + * r6 (rSELF) is reserved [holds current &Thread] * r7 (rINST) is scratch for Jit * r8 (rIBASE) is scratch for Jit, but must be restored when resuming interp * r9 is reserved @@ -210,7 +210,7 @@ typedef enum NativeRegisterPool { r3 = 3, r4PC = 4, rFP = 5, - rGLUE = 6, + rSELF = 6, r7 = 7, r8 = 8, r9 = 9, diff --git a/vm/compiler/codegen/arm/ArmRallocUtil.c b/vm/compiler/codegen/arm/ArmRallocUtil.c index bc643c152..d6e73a07a 100644 --- a/vm/compiler/codegen/arm/ArmRallocUtil.c +++ b/vm/compiler/codegen/arm/ArmRallocUtil.c @@ -29,7 +29,7 @@ * Register usage for 16-bit Thumb systems: * r0-r3: Temp/argument * lr(r14): Temp for translations, return address for handlers - * rGLUE(r6): Pointer to InterpState + * rSELF(r6): Pointer to Thread * rFP(r5): Dalvik frame pointer * r4, r7: Temp for translations * r8, r9, r10: Temp preserved across C calls @@ -38,7 +38,7 @@ * Register usage for 32-bit Thumb systems: * r0-r3: Temp/argument * lr(r14): Temp for translations, return address for handlers - * rGLUE(r6): Pointer to InterpState + * rSELF(r6): Pointer to Thread * rFP(r5): Dalvik frame pointer * r4, r7: Temp for translations * r8, r9, r10 Temp preserved across C calls diff --git a/vm/compiler/codegen/arm/Assemble.c b/vm/compiler/codegen/arm/Assemble.c index 34793ee9f..79f5ec758 100644 --- a/vm/compiler/codegen/arm/Assemble.c +++ b/vm/compiler/codegen/arm/Assemble.c @@ -1606,7 +1606,7 @@ static void inlineCachePatchEnqueue(PredictedChainingCell *cellAddr, * next safe point. */ const Method *dvmJitToPatchPredictedChain(const Method *method, - InterpState *interpState, + Thread *self, PredictedChainingCell *cell, const ClassObject *clazz) { @@ -1646,7 +1646,7 @@ const Method *dvmJitToPatchPredictedChain(const Method *method, PredictedChainingCell newCell; if (cell->clazz == NULL) { - newRechainCount = interpState->icRechainCount; + newRechainCount = self->icRechainCount; } int baseAddr = (int) cell + 4; // PC is cur_addr + 4 @@ -1667,7 +1667,7 @@ const Method *dvmJitToPatchPredictedChain(const Method *method, inlineCachePatchEnqueue(cell, &newCell); #endif done: - interpState->icRechainCount = newRechainCount; + self->icRechainCount = newRechainCount; return method; } diff --git a/vm/compiler/codegen/arm/CalloutHelper.h b/vm/compiler/codegen/arm/CalloutHelper.h index 414f8c5c3..931cf0f7e 100644 --- a/vm/compiler/codegen/arm/CalloutHelper.h +++ b/vm/compiler/codegen/arm/CalloutHelper.h @@ -82,7 +82,7 @@ bool dvmInterpHandleFillArrayData(ArrayObject* arrayObject,// OP_FILL_ARRAY_DATA /* Originally declared in compiler/codegen/arm/Assemble.c */ const Method *dvmJitToPatchPredictedChain(const Method *method, - InterpState *interpState, + Thread *self, PredictedChainingCell *cell, const ClassObject *clazz); diff --git a/vm/compiler/codegen/arm/CodegenDriver.c b/vm/compiler/codegen/arm/CodegenDriver.c index 2ed17d629..02e6f877e 100644 --- a/vm/compiler/codegen/arm/CodegenDriver.c +++ b/vm/compiler/codegen/arm/CodegenDriver.c @@ -32,7 +32,7 @@ static void markCard(CompilationUnit *cUnit, int valReg, int tgtAddrReg) int regCardBase = dvmCompilerAllocTemp(cUnit); int regCardNo = dvmCompilerAllocTemp(cUnit); ArmLIR *branchOver = genCmpImmBranch(cUnit, kArmCondEq, valReg, 0); - loadWordDisp(cUnit, rGLUE, offsetof(InterpState, cardTable), + loadWordDisp(cUnit, rSELF, offsetof(Thread, cardTable), regCardBase); opRegRegImm(cUnit, kOpLsr, regCardNo, tgtAddrReg, GC_CARD_SHIFT); storeBaseIndexed(cUnit, regCardBase, regCardNo, regCardBase, 0, @@ -973,7 +973,7 @@ static void genReturnCommon(CompilationUnit *cUnit, MIR *mir) /* Branch to the PC reconstruction code */ branch->generic.target = (LIR *) pcrLabel; } - /* TODO: Move result to InterpState for non-void returns */ + /* TODO: Move result to Thread for non-void returns */ } static void genProcessArgsNoRange(CompilationUnit *cUnit, MIR *mir, @@ -1248,7 +1248,7 @@ static void genInvokeVirtualCommon(CompilationUnit *cUnit, MIR *mir, LOAD_FUNC_ADDR(cUnit, r7, (int) dvmJitToPatchPredictedChain); - genRegCopy(cUnit, r1, rGLUE); + genRegCopy(cUnit, r1, rSELF); /* * r0 = calleeMethod @@ -1287,7 +1287,7 @@ static void genPuntToInterp(CompilationUnit *cUnit, unsigned int offset) /* r0 = dalvik pc */ dvmCompilerFlushAllRegs(cUnit); loadConstant(cUnit, r0, (int) (cUnit->method->insns + offset)); - loadWordDisp(cUnit, rGLUE, offsetof(InterpState, + loadWordDisp(cUnit, rSELF, offsetof(Thread, jitToInterpEntries.dvmJitToInterpPunt), r1); opReg(cUnit, kOpBlx, r1); } @@ -1313,9 +1313,9 @@ static void genInterpSingleStep(CompilationUnit *cUnit, MIR *mir) genPuntToInterp(cUnit, mir->offset); return; } - int entryAddr = offsetof(InterpState, + int entryAddr = offsetof(Thread, jitToInterpEntries.dvmJitToInterpSingleStep); - loadWordDisp(cUnit, rGLUE, entryAddr, r2); + loadWordDisp(cUnit, rSELF, entryAddr, r2); /* r0 = dalvik pc */ loadConstant(cUnit, r0, (int) (cUnit->method->insns + mir->offset)); /* r1 = dalvik pc of following instruction */ @@ -1342,7 +1342,7 @@ static void genMonitorPortable(CompilationUnit *cUnit, MIR *mir) dvmCompilerFlushAllRegs(cUnit); /* Send everything to home location */ RegLocation rlSrc = dvmCompilerGetSrc(cUnit, mir, 0); loadValueDirectFixed(cUnit, rlSrc, r1); - loadWordDisp(cUnit, rGLUE, offsetof(InterpState, self), r0); + genRegCopy(cUnit, r0, rSELF); genNullCheck(cUnit, rlSrc.sRegLow, r1, mir->offset, NULL); if (isEnter) { /* Get dPC of next insn */ @@ -1368,18 +1368,16 @@ static void genMonitorPortable(CompilationUnit *cUnit, MIR *mir) #endif /* - * Fetch *InterpState->pSelfSuspendCount. If the suspend count is non-zero, + * Fetch *self->suspendCount. If the suspend count is non-zero, * punt to the interpreter. */ static void genSuspendPoll(CompilationUnit *cUnit, MIR *mir) { int rTemp = dvmCompilerAllocTemp(cUnit); ArmLIR *ld; - ld = loadWordDisp(cUnit, rGLUE, offsetof(InterpState, pSelfSuspendCount), + ld = loadWordDisp(cUnit, rSELF, offsetof(Thread, suspendCount), rTemp); setMemRefType(ld, true /* isLoad */, kMustNotAlias); - ld = loadWordDisp(cUnit, rTemp, 0, rTemp); - setMemRefType(ld, true /* isLoad */, kMustNotAlias); genRegImmCheck(cUnit, kArmCondNe, rTemp, 0, mir->offset, NULL); } @@ -1834,16 +1832,13 @@ static bool handleFmt11x(CompilationUnit *cUnit, MIR *mir) RegLocation rlResult; switch (dalvikOpcode) { case OP_MOVE_EXCEPTION: { - int offset = offsetof(InterpState, self); int exOffset = offsetof(Thread, exception); - int selfReg = dvmCompilerAllocTemp(cUnit); int resetReg = dvmCompilerAllocTemp(cUnit); RegLocation rlDest = dvmCompilerGetDest(cUnit, mir, 0); rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kCoreReg, true); - loadWordDisp(cUnit, rGLUE, offset, selfReg); + loadWordDisp(cUnit, rSELF, exOffset, rlResult.lowReg); loadConstant(cUnit, resetReg, 0); - loadWordDisp(cUnit, selfReg, exOffset, rlResult.lowReg); - storeWordDisp(cUnit, selfReg, exOffset, resetReg); + storeWordDisp(cUnit, rSELF, exOffset, resetReg); storeValue(cUnit, rlDest, rlResult); break; } @@ -3235,7 +3230,7 @@ static bool handleFmt35c_3rc_5rc(CompilationUnit *cUnit, MIR *mir, LOAD_FUNC_ADDR(cUnit, r7, (int) dvmJitToPatchPredictedChain); - genRegCopy(cUnit, r1, rGLUE); + genRegCopy(cUnit, r1, rSELF); genRegCopy(cUnit, r2, r9); genRegCopy(cUnit, r3, r10); @@ -3584,8 +3579,8 @@ static bool handleExecuteInlineC(CompilationUnit *cUnit, MIR *mir) dvmCompilerClobberCallRegs(cUnit); dvmCompilerClobber(cUnit, r4PC); dvmCompilerClobber(cUnit, r7); - int offset = offsetof(InterpState, retval); - opRegRegImm(cUnit, kOpAdd, r4PC, rGLUE, offset); + int offset = offsetof(Thread, retval); + opRegRegImm(cUnit, kOpAdd, r4PC, rSELF, offset); opImm(cUnit, kOpPush, (1<> 2); newLIR1(cUnit, kThumbBlxR, r0); addWordData(cUnit, (int) (cUnit->method->insns + offset), true); @@ -3732,8 +3727,8 @@ static void handleHotChainingCell(CompilationUnit *cUnit, * instructions fit the predefined cell size. */ insertChainingSwitch(cUnit); - newLIR3(cUnit, kThumbLdrRRI5, r0, rGLUE, - offsetof(InterpState, + newLIR3(cUnit, kThumbLdrRRI5, r0, rSELF, + offsetof(Thread, jitToInterpEntries.dvmJitToInterpTraceSelect) >> 2); newLIR1(cUnit, kThumbBlxR, r0); addWordData(cUnit, (int) (cUnit->method->insns + offset), true); @@ -3749,12 +3744,12 @@ static void handleBackwardBranchChainingCell(CompilationUnit *cUnit, */ insertChainingSwitch(cUnit); #if defined(WITH_SELF_VERIFICATION) - newLIR3(cUnit, kThumbLdrRRI5, r0, rGLUE, - offsetof(InterpState, + newLIR3(cUnit, kThumbLdrRRI5, r0, rSELF, + offsetof(Thread, jitToInterpEntries.dvmJitToInterpBackwardBranch) >> 2); #else - newLIR3(cUnit, kThumbLdrRRI5, r0, rGLUE, - offsetof(InterpState, jitToInterpEntries.dvmJitToInterpNormal) >> 2); + newLIR3(cUnit, kThumbLdrRRI5, r0, rSELF, + offsetof(Thread, jitToInterpEntries.dvmJitToInterpNormal) >> 2); #endif newLIR1(cUnit, kThumbBlxR, r0); addWordData(cUnit, (int) (cUnit->method->insns + offset), true); @@ -3769,8 +3764,8 @@ static void handleInvokeSingletonChainingCell(CompilationUnit *cUnit, * instructions fit the predefined cell size. */ insertChainingSwitch(cUnit); - newLIR3(cUnit, kThumbLdrRRI5, r0, rGLUE, - offsetof(InterpState, + newLIR3(cUnit, kThumbLdrRRI5, r0, rSELF, + offsetof(Thread, jitToInterpEntries.dvmJitToInterpTraceSelect) >> 2); newLIR1(cUnit, kThumbBlxR, r0); addWordData(cUnit, (int) (callee->insns), true); @@ -4231,7 +4226,7 @@ void dvmCompilerMIR2LIR(CompilationUnit *cUnit) case kExceptionHandling: labelList[i].opcode = kArmPseudoEHBlockLabel; if (cUnit->pcReconstructionList.numUsed) { - loadWordDisp(cUnit, rGLUE, offsetof(InterpState, + loadWordDisp(cUnit, rSELF, offsetof(Thread, jitToInterpEntries.dvmJitToInterpPunt), r1); opReg(cUnit, kOpBlx, r1); @@ -4525,7 +4520,7 @@ gen_fallthrough: */ if (cUnit->switchOverflowPad) { loadConstant(cUnit, r0, (int) cUnit->switchOverflowPad); - loadWordDisp(cUnit, rGLUE, offsetof(InterpState, + loadWordDisp(cUnit, rSELF, offsetof(Thread, jitToInterpEntries.dvmJitToInterpNoChain), r2); opRegReg(cUnit, kOpAdd, r1, r1); opRegRegReg(cUnit, kOpAdd, r4PC, r0, r1); diff --git a/vm/compiler/codegen/arm/Thumb/Gen.c b/vm/compiler/codegen/arm/Thumb/Gen.c index c5d06decd..720553094 100644 --- a/vm/compiler/codegen/arm/Thumb/Gen.c +++ b/vm/compiler/codegen/arm/Thumb/Gen.c @@ -214,14 +214,14 @@ static void genCmpLong(CompilationUnit *cUnit, MIR *mir, RegLocation rlDest, static bool genInlinedAbsFloat(CompilationUnit *cUnit, MIR *mir) { - int offset = offsetof(InterpState, retval); + int offset = offsetof(Thread, retval); RegLocation rlSrc = dvmCompilerGetSrc(cUnit, mir, 0); int reg0 = loadValue(cUnit, rlSrc, kCoreReg).lowReg; int signMask = dvmCompilerAllocTemp(cUnit); loadConstant(cUnit, signMask, 0x7fffffff); newLIR2(cUnit, kThumbAndRR, reg0, signMask); dvmCompilerFreeTemp(cUnit, signMask); - storeWordDisp(cUnit, rGLUE, offset, reg0); + storeWordDisp(cUnit, rSELF, offset, reg0); //TUNING: rewrite this to not clobber dvmCompilerClobber(cUnit, reg0); return false; @@ -229,17 +229,17 @@ static bool genInlinedAbsFloat(CompilationUnit *cUnit, MIR *mir) static bool genInlinedAbsDouble(CompilationUnit *cUnit, MIR *mir) { - int offset = offsetof(InterpState, retval); + int offset = offsetof(Thread, retval); RegLocation rlSrc = dvmCompilerGetSrcWide(cUnit, mir, 0, 1); RegLocation regSrc = loadValueWide(cUnit, rlSrc, kCoreReg); int reglo = regSrc.lowReg; int reghi = regSrc.highReg; int signMask = dvmCompilerAllocTemp(cUnit); loadConstant(cUnit, signMask, 0x7fffffff); - storeWordDisp(cUnit, rGLUE, offset, reglo); + storeWordDisp(cUnit, rSELF, offset, reglo); newLIR2(cUnit, kThumbAndRR, reghi, signMask); dvmCompilerFreeTemp(cUnit, signMask); - storeWordDisp(cUnit, rGLUE, offset + 4, reghi); + storeWordDisp(cUnit, rSELF, offset + 4, reghi); //TUNING: rewrite this to not clobber dvmCompilerClobber(cUnit, reghi); return false; @@ -248,7 +248,7 @@ static bool genInlinedAbsDouble(CompilationUnit *cUnit, MIR *mir) /* No select in thumb, so we need to branch. Thumb2 will do better */ static bool genInlinedMinMaxInt(CompilationUnit *cUnit, MIR *mir, bool isMin) { - int offset = offsetof(InterpState, retval); + int offset = offsetof(Thread, retval); RegLocation rlSrc1 = dvmCompilerGetSrc(cUnit, mir, 0); RegLocation rlSrc2 = dvmCompilerGetSrc(cUnit, mir, 1); int reg0 = loadValue(cUnit, rlSrc1, kCoreReg).lowReg; @@ -259,7 +259,7 @@ static bool genInlinedMinMaxInt(CompilationUnit *cUnit, MIR *mir, bool isMin) newLIR2(cUnit, kThumbMovRR, reg0, reg1); ArmLIR *target = newLIR0(cUnit, kArmPseudoTargetLabel); target->defMask = ENCODE_ALL; - newLIR3(cUnit, kThumbStrRRI5, reg0, rGLUE, offset >> 2); + newLIR3(cUnit, kThumbStrRRI5, reg0, rSELF, offset >> 2); branch1->generic.target = (LIR *)target; //TUNING: rewrite this to not clobber dvmCompilerClobber(cUnit,reg0); diff --git a/vm/compiler/codegen/arm/Thumb2/Gen.c b/vm/compiler/codegen/arm/Thumb2/Gen.c index a0195bcaa..864b0b1c6 100644 --- a/vm/compiler/codegen/arm/Thumb2/Gen.c +++ b/vm/compiler/codegen/arm/Thumb2/Gen.c @@ -246,9 +246,8 @@ static void genMonitorEnter(CompilationUnit *cUnit, MIR *mir) loadValueDirectFixed(cUnit, rlSrc, r1); // Get obj dvmCompilerLockAllTemps(cUnit); // Prepare for explicit register usage dvmCompilerFreeTemp(cUnit, r4PC); // Free up r4 for general use - loadWordDisp(cUnit, rGLUE, offsetof(InterpState, self), r0); // Get self genNullCheck(cUnit, rlSrc.sRegLow, r1, mir->offset, NULL); - loadWordDisp(cUnit, r0, offsetof(Thread, threadId), r3); // Get threadId + loadWordDisp(cUnit, rSELF, offsetof(Thread, threadId), r3); // Get threadId newLIR3(cUnit, kThumb2Ldrex, r2, r1, offsetof(Object, lock) >> 2); // Get object->lock opRegImm(cUnit, kOpLsl, r3, LW_LOCK_OWNER_SHIFT); // Align owner @@ -276,6 +275,7 @@ static void genMonitorEnter(CompilationUnit *cUnit, MIR *mir) sizeof(StackSaveArea) - offsetof(StackSaveArea, xtra.currentPc)); /* Call template, and don't return */ + genRegCopy(cUnit, r0, rSELF); genDispatchToHandler(cUnit, TEMPLATE_MONITOR_ENTER); // Resume here target = newLIR0(cUnit, kArmPseudoTargetLabel); @@ -301,10 +301,9 @@ static void genMonitorExit(CompilationUnit *cUnit, MIR *mir) loadValueDirectFixed(cUnit, rlSrc, r1); // Get obj dvmCompilerLockAllTemps(cUnit); // Prepare for explicit register usage dvmCompilerFreeTemp(cUnit, r4PC); // Free up r4 for general use - loadWordDisp(cUnit, rGLUE, offsetof(InterpState, self), r0); // Get self genNullCheck(cUnit, rlSrc.sRegLow, r1, mir->offset, NULL); loadWordDisp(cUnit, r1, offsetof(Object, lock), r2); // Get object->lock - loadWordDisp(cUnit, r0, offsetof(Thread, threadId), r3); // Get threadId + loadWordDisp(cUnit, rSELF, offsetof(Thread, threadId), r3); // Get threadId // Is lock unheld on lock or held by us (==threadId) on unlock? opRegRegImm(cUnit, kOpAnd, r7, r2, (LW_HASH_STATE_MASK << LW_HASH_STATE_SHIFT)); @@ -325,6 +324,7 @@ static void genMonitorExit(CompilationUnit *cUnit, MIR *mir) loadConstant(cUnit, r3, (int) (cUnit->method->insns + mir->offset)); LOAD_FUNC_ADDR(cUnit, r7, (int)dvmUnlockObject); + genRegCopy(cUnit, r0, rSELF); // Export PC (part 2) newLIR3(cUnit, kThumb2StrRRI8Predec, r3, rFP, sizeof(StackSaveArea) - diff --git a/vm/compiler/codegen/arm/armv5te-vfp/ArchVariant.c b/vm/compiler/codegen/arm/armv5te-vfp/ArchVariant.c index c857fa53b..076f5f15a 100644 --- a/vm/compiler/codegen/arm/armv5te-vfp/ArchVariant.c +++ b/vm/compiler/codegen/arm/armv5te-vfp/ArchVariant.c @@ -74,9 +74,9 @@ bool dvmCompilerArchVariantInit(void) * EA is calculated by doing "Rn + imm5 << 2". Make sure that the last * offset from the struct is less than 128. */ - if ((offsetof(InterpState, jitToInterpEntries) + + if ((offsetof(Thread, jitToInterpEntries) + sizeof(struct JitToInterpEntries)) >= 128) { - LOGE("InterpState.jitToInterpEntries size overflow"); + LOGE("Thread.jitToInterpEntries size overflow"); dvmAbort(); } diff --git a/vm/compiler/codegen/arm/armv5te/ArchVariant.c b/vm/compiler/codegen/arm/armv5te/ArchVariant.c index 0f16839ba..73d27f906 100644 --- a/vm/compiler/codegen/arm/armv5te/ArchVariant.c +++ b/vm/compiler/codegen/arm/armv5te/ArchVariant.c @@ -74,9 +74,9 @@ bool dvmCompilerArchVariantInit(void) * EA is calculated by doing "Rn + imm5 << 2". Make sure that the last * offset from the struct is less than 128. */ - if ((offsetof(InterpState, jitToInterpEntries) + + if ((offsetof(Thread, jitToInterpEntries) + sizeof(struct JitToInterpEntries)) >= 128) { - LOGE("InterpState.jitToInterpEntries size overflow"); + LOGE("Thread.jitToInterpEntries size overflow"); dvmAbort(); } diff --git a/vm/compiler/codegen/arm/armv7-a-neon/ArchVariant.c b/vm/compiler/codegen/arm/armv7-a-neon/ArchVariant.c index 3df1095c6..bcd6a4644 100644 --- a/vm/compiler/codegen/arm/armv7-a-neon/ArchVariant.c +++ b/vm/compiler/codegen/arm/armv7-a-neon/ArchVariant.c @@ -69,9 +69,9 @@ bool dvmCompilerArchVariantInit(void) * EA is calculated by doing "Rn + imm5 << 2". Make sure that the last * offset from the struct is less than 128. */ - if ((offsetof(InterpState, jitToInterpEntries) + + if ((offsetof(Thread, jitToInterpEntries) + sizeof(struct JitToInterpEntries)) >= 128) { - LOGE("InterpState.jitToInterpEntries size overflow"); + LOGE("Thread.jitToInterpEntries size overflow"); dvmAbort(); } diff --git a/vm/compiler/codegen/arm/armv7-a/ArchVariant.c b/vm/compiler/codegen/arm/armv7-a/ArchVariant.c index 3df1095c6..bcd6a4644 100644 --- a/vm/compiler/codegen/arm/armv7-a/ArchVariant.c +++ b/vm/compiler/codegen/arm/armv7-a/ArchVariant.c @@ -69,9 +69,9 @@ bool dvmCompilerArchVariantInit(void) * EA is calculated by doing "Rn + imm5 << 2". Make sure that the last * offset from the struct is less than 128. */ - if ((offsetof(InterpState, jitToInterpEntries) + + if ((offsetof(Thread, jitToInterpEntries) + sizeof(struct JitToInterpEntries)) >= 128) { - LOGE("InterpState.jitToInterpEntries size overflow"); + LOGE("Thread.jitToInterpEntries size overflow"); dvmAbort(); } diff --git a/vm/compiler/codegen/x86/Assemble.c b/vm/compiler/codegen/x86/Assemble.c index dbb9b024a..d583001e9 100644 --- a/vm/compiler/codegen/x86/Assemble.c +++ b/vm/compiler/codegen/x86/Assemble.c @@ -99,7 +99,7 @@ void* dvmJitChain(void* tgtAddr, u4* branchAddr) * next safe point. */ const Method *dvmJitToPatchPredictedChain(const Method *method, - InterpState *interpState, + Thread *self, PredictedChainingCell *cell, const ClassObject *clazz) { diff --git a/vm/compiler/codegen/x86/CodegenDriver.c b/vm/compiler/codegen/x86/CodegenDriver.c index e440e37ab..a5ef56afb 100644 --- a/vm/compiler/codegen/x86/CodegenDriver.c +++ b/vm/compiler/codegen/x86/CodegenDriver.c @@ -46,7 +46,7 @@ static void genPuntToInterp(CompilationUnit *cUnit, unsigned int offset) loadConstant(cUnit, rPC, (int)(cUnit->method->insns + offset)); loadWordDisp(cUnit, rEBP, 0, rECX); // Get glue loadWordDisp(cUnit, rECX, - offsetof(InterpState, jitToInterpEntries.dvmJitToInterpPunt), + offsetof(Thread, jitToInterpEntries.dvmJitToInterpPunt), rEAX); opReg(cUnit, kOpUncondBr, rEAX); } @@ -68,7 +68,7 @@ static void genInterpSingleStep(CompilationUnit *cUnit, MIR *mir) genPuntToInterp(cUnit, mir->offset); return; } - int entryAddr = offsetof(InterpState, + int entryAddr = offsetof(Thread, jitToInterpEntries.dvmJitToInterpSingleStep); loadWordDisp(cUnit, rEBP, 0, rECX); // Get glue loadWordDisp(cUnit, rECX, entryAddr, rEAX); // rEAX<- entry address diff --git a/vm/compiler/codegen/x86/ia32/ArchVariant.c b/vm/compiler/codegen/x86/ia32/ArchVariant.c index 931189f19..4ccd56f44 100644 --- a/vm/compiler/codegen/x86/ia32/ArchVariant.c +++ b/vm/compiler/codegen/x86/ia32/ArchVariant.c @@ -74,7 +74,7 @@ bool dvmCompilerArchVariantInit(void) * EA is calculated by doing "Rn + imm5 << 2", make sure that the last * offset from the struct is less than 128. */ - assert((offsetof(InterpState, jitToInterpEntries) + + assert((offsetof(Thread, jitToInterpEntries) + sizeof(struct JitToInterpEntries)) <= 128); return true; } diff --git a/vm/compiler/template/armv5te-vfp/TEMPLATE_RESTORE_STATE.S b/vm/compiler/template/armv5te-vfp/TEMPLATE_RESTORE_STATE.S index ec8013977..196d08281 100644 --- a/vm/compiler/template/armv5te-vfp/TEMPLATE_RESTORE_STATE.S +++ b/vm/compiler/template/armv5te-vfp/TEMPLATE_RESTORE_STATE.S @@ -1,9 +1,9 @@ /* * This handler restores state following a selfVerification memory access. * On entry: - * r0 - offset from rGLUE to the 1st element of the coreRegs save array. + * r0 - offset from rSELF to the 1st element of the coreRegs save array. */ - add r0, r0, rGLUE @ pointer to heapArgSpace.coreRegs[0] + add r0, r0, rSELF @ pointer to heapArgSpace.coreRegs[0] add r0, #64 @ pointer to heapArgSpace.fpRegs[0] vldmia r0, {d0-d15} sub r0, #64 @ pointer to heapArgSpace.coreRegs[0] diff --git a/vm/compiler/template/armv5te-vfp/TEMPLATE_SAVE_STATE.S b/vm/compiler/template/armv5te-vfp/TEMPLATE_SAVE_STATE.S index 1bd02c878..11f62b7f5 100644 --- a/vm/compiler/template/armv5te-vfp/TEMPLATE_SAVE_STATE.S +++ b/vm/compiler/template/armv5te-vfp/TEMPLATE_SAVE_STATE.S @@ -3,7 +3,7 @@ * On entry: * Top of stack + 4: r7 value to save * Top of stack + 0: r0 value to save - * r0 - offset from rGLUE to the beginning of the heapArgSpace record + * r0 - offset from rSELF to the beginning of the heapArgSpace record * r7 - the value of regMap * * The handler must save regMap, r0-r12 and then return with r0-r12 @@ -11,7 +11,7 @@ * the values on the stack - not the ones in those registers on entry. * Finally, the two registers previously pushed must be popped. */ - add r0, r0, rGLUE @ pointer to heapArgSpace + add r0, r0, rSELF @ pointer to heapArgSpace stmia r0!, {r7} @ save regMap ldr r7, [r13, #0] @ recover r0 value stmia r0!, {r7} @ save r0 diff --git a/vm/compiler/template/armv5te/TEMPLATE_INTERPRET.S b/vm/compiler/template/armv5te/TEMPLATE_INTERPRET.S index 0163ce0df..9f24887d8 100644 --- a/vm/compiler/template/armv5te/TEMPLATE_INTERPRET.S +++ b/vm/compiler/template/armv5te/TEMPLATE_INTERPRET.S @@ -9,7 +9,7 @@ * r1 - the Dalvik PC to begin interpretation. * else * [lr, #3] contains Dalvik PC to begin interpretation - * rGLUE - pointer to interpState + * rSELF - pointer to thread * rFP - Dalvik frame pointer */ cmp lr, #0 diff --git a/vm/compiler/template/armv5te/TEMPLATE_INVOKE_METHOD_CHAIN.S b/vm/compiler/template/armv5te/TEMPLATE_INVOKE_METHOD_CHAIN.S index b6a8540ab..503d19074 100644 --- a/vm/compiler/template/armv5te/TEMPLATE_INVOKE_METHOD_CHAIN.S +++ b/vm/compiler/template/armv5te/TEMPLATE_INVOKE_METHOD_CHAIN.S @@ -8,15 +8,14 @@ @ rPC = dalvikCallsite, r7 = methodToCall->registersSize @ methodToCall is guaranteed to be non-native $chaintgt: - ldr r9, [rGLUE, #offGlue_interpStackEnd] @ r9<- interpStackEnd - ldr r8, [rGLUE, #offGlue_pSelfSuspendCount] @ r8<- &suspendCount + ldr r9, [rSELF, #offThread_interpStackEnd] @ r9<- interpStackEnd + ldr r8, [rSELF, #offThread_suspendCount] @ r8<- suspendCount add r3, r1, #1 @ Thumb addr is odd SAVEAREA_FROM_FP(r1, rFP) @ r1<- stack save area sub r1, r1, r7, lsl #2 @ r1<- newFp (old savearea - regsSize) SAVEAREA_FROM_FP(r10, r1) @ r10<- stack save area add r12, lr, #2 @ setup the punt-to-interp address sub r10, r10, r2, lsl #2 @ r10<- bottom (newsave - outsSize) - ldr r8, [r8] @ r8<- suspendCount (int) cmp r10, r9 @ bottom < interpStackEnd? bxlo r12 @ return to raise stack overflow excep. @ r1 = newFP, r0 = methodToCall, r3 = returnCell, rPC = dalvikCallsite @@ -32,17 +31,16 @@ $chaintgt: bxne r12 @ bail to the interpreter ldr r3, [r9, #offClassObject_pDvmDex] @ r3<- method->clazz->pDvmDex - ldr r2, [rGLUE, #offGlue_self] @ r2<- glue->self - @ Update "glue" values for the new method - str r0, [rGLUE, #offGlue_method] @ glue->method = methodToCall - str r3, [rGLUE, #offGlue_methodClassDex] @ glue->methodClassDex = ... + @ Update "thread" values for the new method + str r0, [rSELF, #offThread_method] @ self->method = methodToCall + str r3, [rSELF, #offThread_methodClassDex] @ self->methodClassDex = ... mov rFP, r1 @ fp = newFp - str rFP, [r2, #offThread_curFrame] @ self->curFrame = newFp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = newFp #if defined(TEMPLATE_INLINE_PROFILING) stmfd sp!, {r0-r2,lr} @ preserve clobbered live registers mov r1, r6 - @ r0=methodToCall, r1=rGlue + @ r0=methodToCall, r1=rSELF mov lr, pc ldr pc, .LdvmFastMethodTraceEnter ldmfd sp!, {r0-r2,lr} @ restore registers diff --git a/vm/compiler/template/armv5te/TEMPLATE_INVOKE_METHOD_NATIVE.S b/vm/compiler/template/armv5te/TEMPLATE_INVOKE_METHOD_NATIVE.S index c3390edb8..8681532ca 100644 --- a/vm/compiler/template/armv5te/TEMPLATE_INVOKE_METHOD_NATIVE.S +++ b/vm/compiler/template/armv5te/TEMPLATE_INVOKE_METHOD_NATIVE.S @@ -1,12 +1,11 @@ @ r0 = methodToCall, r1 = returnCell, rPC = dalvikCallsite @ r7 = methodToCall->registersSize - ldr r9, [rGLUE, #offGlue_interpStackEnd] @ r9<- interpStackEnd - ldr r8, [rGLUE, #offGlue_pSelfSuspendCount] @ r8<- &suspendCount + ldr r9, [rSELF, #offThread_interpStackEnd] @ r9<- interpStackEnd + ldr r8, [rSELF, #offThread_suspendCount] @ r8<- suspendCount add r3, r1, #1 @ Thumb addr is odd SAVEAREA_FROM_FP(r1, rFP) @ r1<- stack save area sub r1, r1, r7, lsl #2 @ r1<- newFp (old savearea - regsSize) SAVEAREA_FROM_FP(r10, r1) @ r10<- stack save area - ldr r8, [r8] @ r3<- suspendCount (int) cmp r10, r9 @ bottom < interpStackEnd? bxlo lr @ return to raise stack overflow excep. @ r1 = newFP, r0 = methodToCall, r3 = returnCell, rPC = dalvikCallsite @@ -16,7 +15,6 @@ @ set up newSaveArea str rFP, [r1, #(offStackSaveArea_prevFrame - sizeofStackSaveArea)] str r3, [r1, #(offStackSaveArea_returnAddr - sizeofStackSaveArea)] - ldr r3, [rGLUE, #offGlue_self] @ r3<- glue->self str r0, [r1, #(offStackSaveArea_method - sizeofStackSaveArea)] cmp r8, #0 @ suspendCount != 0 ldr r8, [r0, #offMethod_nativeFunc] @ r8<- method->nativeFunc @@ -27,25 +25,25 @@ #endif @ go ahead and transfer control to the native code - ldr r9, [r3, #offThread_jniLocal_topCookie] @ r9<- thread->localRef->... + ldr r9, [rSELF, #offThread_jniLocal_topCookie]@r9<-thread->localRef->... mov r2, #0 - str r1, [r3, #offThread_curFrame] @ self->curFrame = newFp - str r2, [r3, #offThread_inJitCodeCache] @ not in the jit code cache + str r1, [rSELF, #offThread_curFrame] @ self->curFrame = newFp + str r2, [rSELF, #offThread_inJitCodeCache] @ not in the jit code cache str r9, [r1, #(offStackSaveArea_localRefCookie - sizeofStackSaveArea)] @ newFp->localRefCookie=top - mov r9, r3 @ r9<- glue->self (preserve) SAVEAREA_FROM_FP(r10, r1) @ r10<- new stack save area - mov r2, r0 @ r2<- methodToCall - mov r0, r1 @ r0<- newFP - add r1, rGLUE, #offGlue_retval @ r1<- &retval + mov r2, r0 @ arg2<- methodToCall + mov r0, r1 @ arg0<- newFP + add r1, rSELF, #offThread_retval @ arg1<- &retval + mov r3, rSELF @ arg3<- self #if defined(TEMPLATE_INLINE_PROFILING) - @ r2=methodToCall, r6=rGLUE + @ r2=methodToCall, r6=rSELF stmfd sp!, {r2,r6} @ to be consumed after JNI return stmfd sp!, {r0-r3} @ preserve r0-r3 mov r0, r2 mov r1, r6 - @ r0=JNIMethod, r1=rGlue + @ r0=JNIMethod, r1=rSELF mov lr, pc ldr pc, .LdvmFastMethodTraceEnter ldmfd sp!, {r0-r3} @ restore r0-r3 @@ -55,24 +53,24 @@ #if defined(TEMPLATE_INLINE_PROFILING) ldmfd sp!, {r0-r1} @ restore r2 and r6 - @ r0=JNIMethod, r1=rGlue + @ r0=JNIMethod, r1=rSELF mov lr, pc ldr pc, .LdvmFastNativeMethodTraceExit #endif - @ native return; r9=self, r10=newSaveArea + @ native return; r10=newSaveArea @ equivalent to dvmPopJniLocals ldr r2, [r10, #offStackSaveArea_returnAddr] @ r2 = chaining cell ret ldr r0, [r10, #offStackSaveArea_localRefCookie] @ r0<- saved->top - ldr r1, [r9, #offThread_exception] @ check for exception - str rFP, [r9, #offThread_curFrame] @ self->curFrame = fp + ldr r1, [rSELF, #offThread_exception] @ check for exception + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = fp cmp r1, #0 @ null? - str r0, [r9, #offThread_jniLocal_topCookie] @ new top <- old top + str r0, [rSELF, #offThread_jniLocal_topCookie] @ new top <- old top ldr r0, [rFP, #(offStackSaveArea_currentPc - sizeofStackSaveArea)] @ r0 = dalvikCallsitePC bne .LhandleException @ no, handle exception - str r2, [r9, #offThread_inJitCodeCache] @ set the mode properly + str r2, [rSELF, #offThread_inJitCodeCache] @ set the mode properly cmp r2, #0 @ return chaining cell still exists? bxne r2 @ yes - go ahead diff --git a/vm/compiler/template/armv5te/TEMPLATE_INVOKE_METHOD_NO_OPT.S b/vm/compiler/template/armv5te/TEMPLATE_INVOKE_METHOD_NO_OPT.S index 72fe91005..12b5e61af 100644 --- a/vm/compiler/template/armv5te/TEMPLATE_INVOKE_METHOD_NO_OPT.S +++ b/vm/compiler/template/armv5te/TEMPLATE_INVOKE_METHOD_NO_OPT.S @@ -6,14 +6,13 @@ @ r0 = methodToCall, r1 = returnCell, rPC = dalvikCallsite ldrh r7, [r0, #offMethod_registersSize] @ r7<- methodToCall->regsSize ldrh r2, [r0, #offMethod_outsSize] @ r2<- methodToCall->outsSize - ldr r9, [rGLUE, #offGlue_interpStackEnd] @ r9<- interpStackEnd - ldr r8, [rGLUE, #offGlue_pSelfSuspendCount] @ r8<- &suspendCount + ldr r9, [rSELF, #offThread_interpStackEnd] @ r9<- interpStackEnd + ldr r8, [rSELF, #offThread_suspendCount] @ r8<- suspendCount add r3, r1, #1 @ Thumb addr is odd SAVEAREA_FROM_FP(r1, rFP) @ r1<- stack save area sub r1, r1, r7, lsl #2 @ r1<- newFp (old savearea - regsSize) SAVEAREA_FROM_FP(r10, r1) @ r10<- stack save area sub r10, r10, r2, lsl #2 @ r10<- bottom (newsave - outsSize) - ldr r8, [r8] @ r8<- suspendCount (int) cmp r10, r9 @ bottom < interpStackEnd? bxlo lr @ return to raise stack overflow excep. @ r1 = newFP, r0 = methodToCall, r3 = returnCell, rPC = dalvikCallsite @@ -39,17 +38,16 @@ ldr r10, .LdvmJitToInterpTraceSelectNoChain ldr r3, [r9, #offClassObject_pDvmDex] @ r3<- method->clazz->pDvmDex - ldr r2, [rGLUE, #offGlue_self] @ r2<- glue->self - @ Update "glue" values for the new method - str r0, [rGLUE, #offGlue_method] @ glue->method = methodToCall - str r3, [rGLUE, #offGlue_methodClassDex] @ glue->methodClassDex = ... + @ Update "thread" values for the new method + str r0, [rSELF, #offThread_method] @ self->method = methodToCall + str r3, [rSELF, #offThread_methodClassDex] @ self->methodClassDex = ... mov rFP, r1 @ fp = newFp - str rFP, [r2, #offThread_curFrame] @ self->curFrame = newFp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = newFp #if defined(TEMPLATE_INLINE_PROFILING) stmfd sp!, {r0-r3} @ preserve r0-r3 mov r1, r6 - @ r0=methodToCall, r1=rGlue + @ r0=methodToCall, r1=rSELF mov lr, pc ldr pc, .LdvmFastMethodTraceEnter ldmfd sp!, {r0-r3} @ restore r0-r3 diff --git a/vm/compiler/template/armv5te/TEMPLATE_INVOKE_METHOD_PREDICTED_CHAIN.S b/vm/compiler/template/armv5te/TEMPLATE_INVOKE_METHOD_PREDICTED_CHAIN.S index 6bce7bff9..9dd4ff834 100644 --- a/vm/compiler/template/armv5te/TEMPLATE_INVOKE_METHOD_PREDICTED_CHAIN.S +++ b/vm/compiler/template/armv5te/TEMPLATE_INVOKE_METHOD_PREDICTED_CHAIN.S @@ -26,7 +26,7 @@ ldr r3, [r0, #offObject_clazz] @ r3 <- this->class ldr r8, [r2, #4] @ r8 <- predictedChainCell->clazz ldr r0, [r2, #8] @ r0 <- predictedChainCell->method - ldr r9, [rGLUE, #offGlue_icRechainCount] @ r1 <- shared rechainCount + ldr r9, [rSELF, #offThread_icRechainCount] @ r1 <- shared rechainCount cmp r3, r8 @ predicted class == actual class? #if defined(WITH_JIT_TUNING) ldr r7, .LdvmICHitCount @@ -48,7 +48,7 @@ cmp r8, #0 @ initialized class or not moveq r1, #0 subne r1, r9, #1 @ count-- - strne r1, [rGLUE, #offGlue_icRechainCount] @ write back to InterpState + strne r1, [rSELF, #offThread_icRechainCount] @ write back to thread add lr, lr, #4 @ return to fully-resolve landing pad /* * r1 <- count diff --git a/vm/compiler/template/armv5te/TEMPLATE_MONITOR_ENTER.S b/vm/compiler/template/armv5te/TEMPLATE_MONITOR_ENTER.S index 8e7f72883..344a0daf8 100644 --- a/vm/compiler/template/armv5te/TEMPLATE_MONITOR_ENTER.S +++ b/vm/compiler/template/armv5te/TEMPLATE_MONITOR_ENTER.S @@ -14,10 +14,10 @@ str r3, [r0, #offThread_inJitCodeCache] blx r2 @ dvmLockObject(self, obj) @ refresh Jit's on/off status - ldr r0, [rGLUE, #offGlue_ppJitProfTable] - ldr r0, [r0] + ldr r3, [rSELF, #offThread_ppJitProfTable] + ldr r3, [r3] ldr r2, .LdvmJitToInterpNoChain - str r0, [rGLUE, #offGlue_pJitProfTable] + str r3, [rSELF, #offThread_pJitProfTable] @ Bail to interpreter - no chain [note - r4 still contains rPC] #if defined(WITH_JIT_TUNING) mov r0, #kHeavyweightMonitor diff --git a/vm/compiler/template/armv5te/TEMPLATE_MONITOR_ENTER_DEBUG.S b/vm/compiler/template/armv5te/TEMPLATE_MONITOR_ENTER_DEBUG.S index 5cf26e74d..cc57e2b1d 100644 --- a/vm/compiler/template/armv5te/TEMPLATE_MONITOR_ENTER_DEBUG.S +++ b/vm/compiler/template/armv5te/TEMPLATE_MONITOR_ENTER_DEBUG.S @@ -14,11 +14,10 @@ str r3, [r0, #offThread_inJitCodeCache] blx r2 @ dvmLockObject(self, obj) @ refresh Jit's on/off status & test for exception - ldr r0, [rGLUE, #offGlue_ppJitProfTable] - ldr r1, [rGLUE, #offGlue_self] - ldr r0, [r0] - ldr r1, [r1, #offThread_exception] - str r0, [rGLUE, #offGlue_pJitProfTable] + ldr r3, [rSELF, #offThread_ppJitProfTable] + ldr r3, [r3] + ldr r1, [rSELF, #offThread_exception] + str r3, [rSELF, #offThread_pJitProfTable] cmp r1, #0 beq 1f ldr r2, .LhandleException diff --git a/vm/compiler/template/armv5te/TEMPLATE_PERIODIC_PROFILING.S b/vm/compiler/template/armv5te/TEMPLATE_PERIODIC_PROFILING.S index 7f7109646..c0f7d6e3b 100644 --- a/vm/compiler/template/armv5te/TEMPLATE_PERIODIC_PROFILING.S +++ b/vm/compiler/template/armv5te/TEMPLATE_PERIODIC_PROFILING.S @@ -9,7 +9,7 @@ * we are arriving from thumb mode, lr will have its low bit set. */ ldr r0, [lr,#-11] - ldr r1, [rGLUE, #offGlue_pProfileCountdown] + ldr r1, [rSELF, #offThread_pProfileCountdown] ldr r2, [r0] @ get counter ldr r3, [r1] @ get countdown timer add r2, #1 diff --git a/vm/compiler/template/armv5te/TEMPLATE_RESTORE_STATE.S b/vm/compiler/template/armv5te/TEMPLATE_RESTORE_STATE.S index e3719db47..25b4ffa82 100644 --- a/vm/compiler/template/armv5te/TEMPLATE_RESTORE_STATE.S +++ b/vm/compiler/template/armv5te/TEMPLATE_RESTORE_STATE.S @@ -1,8 +1,8 @@ /* * This handler restores state following a selfVerification memory access. * On entry: - * r0 - offset from rGLUE to the 1st element of the coreRegs save array. + * r0 - offset from rSELF to the 1st element of the coreRegs save array. */ - add r0, r0, rGLUE @ pointer to heapArgSpace.coreRegs[0] + add r0, r0, rSELF @ pointer to heapArgSpace.coreRegs[0] ldmia r0, {r0-r12} bx lr diff --git a/vm/compiler/template/armv5te/TEMPLATE_RETURN.S b/vm/compiler/template/armv5te/TEMPLATE_RETURN.S index d0bbbfc05..c2926a399 100644 --- a/vm/compiler/template/armv5te/TEMPLATE_RETURN.S +++ b/vm/compiler/template/armv5te/TEMPLATE_RETURN.S @@ -8,14 +8,14 @@ #if defined(TEMPLATE_INLINE_PROFILING) stmfd sp!, {r0-r2,lr} @ preserve live registers mov r0, r6 - @ r0=rGlue + @ r0=rSELF mov lr, pc ldr pc, .LdvmFastJavaMethodTraceExit ldmfd sp!, {r0-r2,lr} @ restore live registers #endif SAVEAREA_FROM_FP(r0, rFP) @ r0<- saveArea (old) ldr r10, [r0, #offStackSaveArea_prevFrame] @ r10<- saveArea->prevFrame - ldr r8, [rGLUE, #offGlue_pSelfSuspendCount] @ r8<- &suspendCount + ldr r8, [rSELF, #offThread_suspendCount] @ r8<- suspendCount ldr rPC, [r0, #offStackSaveArea_savedPc] @ rPC<- saveArea->savedPc #if !defined(WITH_SELF_VERIFICATION) ldr r9, [r0, #offStackSaveArea_returnAddr] @ r9<- chaining cell ret @@ -24,7 +24,6 @@ #endif ldr r2, [r10, #(offStackSaveArea_method - sizeofStackSaveArea)] @ r2<- method we're returning to - ldr r3, [rGLUE, #offGlue_self] @ r3<- glue->self cmp r2, #0 @ break frame? #if !defined(WITH_SELF_VERIFICATION) beq 1f @ bail to interpreter @@ -34,16 +33,15 @@ ldr r1, .LdvmJitToInterpNoChainNoProfile @ defined in footer.S mov rFP, r10 @ publish new FP ldr r10, [r2, #offMethod_clazz] @ r10<- method->clazz - ldr r8, [r8] @ r8<- suspendCount - str r2, [rGLUE, #offGlue_method]@ glue->method = newSave->method + str r2, [rSELF, #offThread_method]@ self->method = newSave->method ldr r0, [r10, #offClassObject_pDvmDex] @ r0<- method->clazz->pDvmDex - str rFP, [r3, #offThread_curFrame] @ self->curFrame = fp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = fp add rPC, rPC, #6 @ publish new rPC (advance 6 bytes) - str r0, [rGLUE, #offGlue_methodClassDex] + str r0, [rSELF, #offThread_methodClassDex] cmp r8, #0 @ check the suspendCount movne r9, #0 @ clear the chaining cell address - str r9, [r3, #offThread_inJitCodeCache] @ in code cache or not + str r9, [rSELF, #offThread_inJitCodeCache] @ in code cache or not cmp r9, #0 @ chaining cell exists? blxne r9 @ jump to the chaining cell #if defined(WITH_JIT_TUNING) @@ -51,8 +49,8 @@ #endif mov pc, r1 @ callsite is interpreted 1: - stmia rGLUE, {rPC, rFP} @ SAVE_PC_FP_TO_GLUE() + stmia rSELF, {rPC, rFP} @ SAVE_PC_FP_TO_SELF() ldr r2, .LdvmMterpStdBail @ defined in footer.S mov r1, #0 @ changeInterp = false - mov r0, rGLUE @ Expecting rGLUE in r0 + mov r0, rSELF @ Expecting rSELF in r0 blx r2 @ exit the interpreter diff --git a/vm/compiler/template/armv5te/TEMPLATE_SAVE_STATE.S b/vm/compiler/template/armv5te/TEMPLATE_SAVE_STATE.S index df2d1e6f8..1c3aa4d3d 100644 --- a/vm/compiler/template/armv5te/TEMPLATE_SAVE_STATE.S +++ b/vm/compiler/template/armv5te/TEMPLATE_SAVE_STATE.S @@ -3,7 +3,7 @@ * On entry: * Top of stack + 4: r7 value to save * Top of stack + 0: r0 value to save - * r0 - offset from rGLUE to the beginning of the heapArgSpace record + * r0 - offset from rSELF to the beginning of the heapArgSpace record * r7 - the value of regMap * * The handler must save regMap, r0-r12 and then return with r0-r12 @@ -11,7 +11,7 @@ * the values on the stack - not the ones in those registers on entry. * Finally, the two registers previously pushed must be popped. */ - add r0, r0, rGLUE @ pointer to heapArgSpace + add r0, r0, rSELF @ pointer to heapArgSpace stmia r0!, {r7} @ save regMap ldr r7, [r13, #0] @ recover r0 value stmia r0!, {r7} @ save r0 diff --git a/vm/compiler/template/armv5te/footer.S b/vm/compiler/template/armv5te/footer.S index 0a4e92d81..4164d4e58 100644 --- a/vm/compiler/template/armv5te/footer.S +++ b/vm/compiler/template/armv5te/footer.S @@ -9,24 +9,23 @@ .LinvokeNative: @ Prep for the native call @ r1 = newFP, r0 = methodToCall - ldr r3, [rGLUE, #offGlue_self] @ r3<- glue->self mov r2, #0 - ldr r9, [r3, #offThread_jniLocal_topCookie] @ r9<- thread->localRef->... - str r2, [r3, #offThread_inJitCodeCache] @ not in jit code cache - str r1, [r3, #offThread_curFrame] @ self->curFrame = newFp + ldr r9, [rSELF, #offThread_jniLocal_topCookie]@r9<-thread->localRef->... + str r2, [rSELF, #offThread_inJitCodeCache] @ not in jit code cache + str r1, [rSELF, #offThread_curFrame] @ self->curFrame = newFp str r9, [r1, #(offStackSaveArea_localRefCookie - sizeofStackSaveArea)] @ newFp->localRefCookie=top - mov r9, r3 @ r9<- glue->self (preserve) - ldr lr, [rGLUE, #offGlue_pInterpBreak] + ldr lr, [rSELF, #offThread_pInterpBreak] SAVEAREA_FROM_FP(r10, r1) @ r10<- new stack save area mov r2, r0 @ r2<- methodToCall ldr lr, [lr] @ lr<- set of active profilers mov r0, r1 @ r0<- newFP - add r1, rGLUE, #offGlue_retval @ r1<- &retval + add r1, rSELF, #offThread_retval @ r1<- &retval + mov r3, rSELF @ arg3<- self ands lr, #kSubModeMethodTrace beq 121f @ hop if not profiling - @ r2: methodToCall, r6: rGLUE + @ r2: methodToCall, r6: rSELF stmfd sp!, {r2,r6} stmfd sp!, {r0-r3} mov r0, r2 @@ -47,24 +46,24 @@ ldr pc, [r2, #offMethod_nativeFunc] 212: @ Refresh Jit's on/off status - ldr r3, [rGLUE, #offGlue_ppJitProfTable] + ldr r3, [rSELF, #offThread_ppJitProfTable] - @ native return; r9=self, r10=newSaveArea + @ native return; r10=newSaveArea @ equivalent to dvmPopJniLocals ldr r2, [r10, #offStackSaveArea_returnAddr] @ r2 = chaining cell ret ldr r0, [r10, #offStackSaveArea_localRefCookie] @ r0<- saved->top - ldr r1, [r9, #offThread_exception] @ check for exception + ldr r1, [rSELF, #offThread_exception] @ check for exception ldr r3, [r3] @ r1 <- pointer to Jit profile table - str rFP, [r9, #offThread_curFrame] @ self->curFrame = fp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = fp cmp r1, #0 @ null? - str r0, [r9, #offThread_jniLocal_topCookie] @ new top <- old top + str r0, [rSELF, #offThread_jniLocal_topCookie] @ new top <- old top + str r3, [rSELF, #offThread_pJitProfTable] @ cache current JitProfTable ldr r0, [r10, #offStackSaveArea_savedPc] @ reload rPC - str r3, [rGLUE, #offGlue_pJitProfTable] @ cache current JitProfTable @ r0 = dalvikCallsitePC bne .LhandleException @ no, handle exception - str r2, [r9, #offThread_inJitCodeCache] @ set the new mode + str r2, [rSELF, #offThread_inJitCodeCache] @ set the new mode cmp r2, #0 @ return chaining cell still exists? bxne r2 @ yes - go ahead @@ -86,9 +85,8 @@ .LdeadFood: .word 0xdeadf00d #endif - ldr r3, [rGLUE, #offGlue_self] @ r3<- glue->self mov r2, #0 - str r2, [r3, #offThread_inJitCodeCache] @ in interpreter land + str r2, [rSELF, #offThread_inJitCodeCache] @ in interpreter land ldr r1, .LdvmMterpCommonExceptionThrown @ PIC way of getting &func ldr rIBASE, .LdvmAsmInstructionStart @ same as above mov rPC, r0 @ reload the faulting Dalvik address diff --git a/vm/compiler/template/armv5te/header.S b/vm/compiler/template/armv5te/header.S index e6b33625f..6dcf5b931 100644 --- a/vm/compiler/template/armv5te/header.S +++ b/vm/compiler/template/armv5te/header.S @@ -55,7 +55,7 @@ The following registers have fixed assignments: reg nick purpose r5 rFP interpreted frame pointer, used for accessing locals and args - r6 rGLUE MterpGlue pointer + r6 rSELF thread pointer The following registers have fixed assignments in mterp but are scratch registers in compiled code @@ -73,7 +73,7 @@ unspecified registers or condition codes. /* single-purpose registers, given names for clarity */ #define rPC r4 #define rFP r5 -#define rGLUE r6 +#define rSELF r6 #define rINST r7 #define rIBASE r8 diff --git a/vm/compiler/template/ia32/TEMPLATE_INTERPRET.S b/vm/compiler/template/ia32/TEMPLATE_INTERPRET.S index 68b2d0de0..5c7bf7c87 100644 --- a/vm/compiler/template/ia32/TEMPLATE_INTERPRET.S +++ b/vm/compiler/template/ia32/TEMPLATE_INTERPRET.S @@ -15,12 +15,20 @@ * On entry: * (TOS)<- return pointer or pointer to dPC */ - movl rGLUE,%ecx + +/* + * FIXME - this won't work as-is. The cache boundaries are not + * set up until later. Perhaps rething this whole thing. Do we + * really need an interpret teplate? + */ + + + movl rSELF,%ecx movl $$.LinterpPunt,%edx pop %eax - cmpl %eax,offGlue_jitCacheEnd(%ecx) + /*cmpl %eax,offThread_jitCacheEnd(%ecx)*/ ja 1f - cmpl %eax,offGlue_jitCacheStart(%ecx) + /*cmpl %eax,offThread_jitCacheStart(%ecx)*/ jb 1f movl %eax,rPC 1: diff --git a/vm/compiler/template/ia32/header.S b/vm/compiler/template/ia32/header.S index a67ba6e61..ea2cc0fed 100644 --- a/vm/compiler/template/ia32/header.S +++ b/vm/compiler/template/ia32/header.S @@ -17,7 +17,7 @@ #if defined(WITH_JIT) /* Subset of defines from mterp/x86/header.S */ -#define rGLUE (%ebp) +#define rSELF (%ebp) #define rPC %esi #define rFP %edi #define rINST %ebx diff --git a/vm/compiler/template/out/CompilerTemplateAsm-armv5te-vfp.S b/vm/compiler/template/out/CompilerTemplateAsm-armv5te-vfp.S index 7615b95fe..2e941e521 100644 --- a/vm/compiler/template/out/CompilerTemplateAsm-armv5te-vfp.S +++ b/vm/compiler/template/out/CompilerTemplateAsm-armv5te-vfp.S @@ -62,7 +62,7 @@ The following registers have fixed assignments: reg nick purpose r5 rFP interpreted frame pointer, used for accessing locals and args - r6 rGLUE MterpGlue pointer + r6 rSELF thread pointer The following registers have fixed assignments in mterp but are scratch registers in compiled code @@ -80,7 +80,7 @@ unspecified registers or condition codes. /* single-purpose registers, given names for clarity */ #define rPC r4 #define rFP r5 -#define rGLUE r6 +#define rSELF r6 #define rINST r7 #define rIBASE r8 @@ -169,14 +169,14 @@ dvmCompiler_TEMPLATE_RETURN: #if defined(TEMPLATE_INLINE_PROFILING) stmfd sp!, {r0-r2,lr} @ preserve live registers mov r0, r6 - @ r0=rGlue + @ r0=rSELF mov lr, pc ldr pc, .LdvmFastJavaMethodTraceExit ldmfd sp!, {r0-r2,lr} @ restore live registers #endif SAVEAREA_FROM_FP(r0, rFP) @ r0<- saveArea (old) ldr r10, [r0, #offStackSaveArea_prevFrame] @ r10<- saveArea->prevFrame - ldr r8, [rGLUE, #offGlue_pSelfSuspendCount] @ r8<- &suspendCount + ldr r8, [rSELF, #offThread_suspendCount] @ r8<- suspendCount ldr rPC, [r0, #offStackSaveArea_savedPc] @ rPC<- saveArea->savedPc #if !defined(WITH_SELF_VERIFICATION) ldr r9, [r0, #offStackSaveArea_returnAddr] @ r9<- chaining cell ret @@ -185,7 +185,6 @@ dvmCompiler_TEMPLATE_RETURN: #endif ldr r2, [r10, #(offStackSaveArea_method - sizeofStackSaveArea)] @ r2<- method we're returning to - ldr r3, [rGLUE, #offGlue_self] @ r3<- glue->self cmp r2, #0 @ break frame? #if !defined(WITH_SELF_VERIFICATION) beq 1f @ bail to interpreter @@ -195,16 +194,15 @@ dvmCompiler_TEMPLATE_RETURN: ldr r1, .LdvmJitToInterpNoChainNoProfile @ defined in footer.S mov rFP, r10 @ publish new FP ldr r10, [r2, #offMethod_clazz] @ r10<- method->clazz - ldr r8, [r8] @ r8<- suspendCount - str r2, [rGLUE, #offGlue_method]@ glue->method = newSave->method + str r2, [rSELF, #offThread_method]@ self->method = newSave->method ldr r0, [r10, #offClassObject_pDvmDex] @ r0<- method->clazz->pDvmDex - str rFP, [r3, #offThread_curFrame] @ self->curFrame = fp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = fp add rPC, rPC, #6 @ publish new rPC (advance 6 bytes) - str r0, [rGLUE, #offGlue_methodClassDex] + str r0, [rSELF, #offThread_methodClassDex] cmp r8, #0 @ check the suspendCount movne r9, #0 @ clear the chaining cell address - str r9, [r3, #offThread_inJitCodeCache] @ in code cache or not + str r9, [rSELF, #offThread_inJitCodeCache] @ in code cache or not cmp r9, #0 @ chaining cell exists? blxne r9 @ jump to the chaining cell #if defined(WITH_JIT_TUNING) @@ -212,10 +210,10 @@ dvmCompiler_TEMPLATE_RETURN: #endif mov pc, r1 @ callsite is interpreted 1: - stmia rGLUE, {rPC, rFP} @ SAVE_PC_FP_TO_GLUE() + stmia rSELF, {rPC, rFP} @ SAVE_PC_FP_TO_SELF() ldr r2, .LdvmMterpStdBail @ defined in footer.S mov r1, #0 @ changeInterp = false - mov r0, rGLUE @ Expecting rGLUE in r0 + mov r0, rSELF @ Expecting rSELF in r0 blx r2 @ exit the interpreter /* ------------------------------ */ @@ -231,14 +229,13 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NO_OPT: @ r0 = methodToCall, r1 = returnCell, rPC = dalvikCallsite ldrh r7, [r0, #offMethod_registersSize] @ r7<- methodToCall->regsSize ldrh r2, [r0, #offMethod_outsSize] @ r2<- methodToCall->outsSize - ldr r9, [rGLUE, #offGlue_interpStackEnd] @ r9<- interpStackEnd - ldr r8, [rGLUE, #offGlue_pSelfSuspendCount] @ r8<- &suspendCount + ldr r9, [rSELF, #offThread_interpStackEnd] @ r9<- interpStackEnd + ldr r8, [rSELF, #offThread_suspendCount] @ r8<- suspendCount add r3, r1, #1 @ Thumb addr is odd SAVEAREA_FROM_FP(r1, rFP) @ r1<- stack save area sub r1, r1, r7, lsl #2 @ r1<- newFp (old savearea - regsSize) SAVEAREA_FROM_FP(r10, r1) @ r10<- stack save area sub r10, r10, r2, lsl #2 @ r10<- bottom (newsave - outsSize) - ldr r8, [r8] @ r8<- suspendCount (int) cmp r10, r9 @ bottom < interpStackEnd? bxlo lr @ return to raise stack overflow excep. @ r1 = newFP, r0 = methodToCall, r3 = returnCell, rPC = dalvikCallsite @@ -264,17 +261,16 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NO_OPT: ldr r10, .LdvmJitToInterpTraceSelectNoChain ldr r3, [r9, #offClassObject_pDvmDex] @ r3<- method->clazz->pDvmDex - ldr r2, [rGLUE, #offGlue_self] @ r2<- glue->self - @ Update "glue" values for the new method - str r0, [rGLUE, #offGlue_method] @ glue->method = methodToCall - str r3, [rGLUE, #offGlue_methodClassDex] @ glue->methodClassDex = ... + @ Update "thread" values for the new method + str r0, [rSELF, #offThread_method] @ self->method = methodToCall + str r3, [rSELF, #offThread_methodClassDex] @ self->methodClassDex = ... mov rFP, r1 @ fp = newFp - str rFP, [r2, #offThread_curFrame] @ self->curFrame = newFp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = newFp #if defined(TEMPLATE_INLINE_PROFILING) stmfd sp!, {r0-r3} @ preserve r0-r3 mov r1, r6 - @ r0=methodToCall, r1=rGlue + @ r0=methodToCall, r1=rSELF mov lr, pc ldr pc, .LdvmFastMethodTraceEnter ldmfd sp!, {r0-r3} @ restore r0-r3 @@ -300,15 +296,14 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_CHAIN: @ rPC = dalvikCallsite, r7 = methodToCall->registersSize @ methodToCall is guaranteed to be non-native .LinvokeChain: - ldr r9, [rGLUE, #offGlue_interpStackEnd] @ r9<- interpStackEnd - ldr r8, [rGLUE, #offGlue_pSelfSuspendCount] @ r8<- &suspendCount + ldr r9, [rSELF, #offThread_interpStackEnd] @ r9<- interpStackEnd + ldr r8, [rSELF, #offThread_suspendCount] @ r8<- suspendCount add r3, r1, #1 @ Thumb addr is odd SAVEAREA_FROM_FP(r1, rFP) @ r1<- stack save area sub r1, r1, r7, lsl #2 @ r1<- newFp (old savearea - regsSize) SAVEAREA_FROM_FP(r10, r1) @ r10<- stack save area add r12, lr, #2 @ setup the punt-to-interp address sub r10, r10, r2, lsl #2 @ r10<- bottom (newsave - outsSize) - ldr r8, [r8] @ r8<- suspendCount (int) cmp r10, r9 @ bottom < interpStackEnd? bxlo r12 @ return to raise stack overflow excep. @ r1 = newFP, r0 = methodToCall, r3 = returnCell, rPC = dalvikCallsite @@ -324,17 +319,16 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_CHAIN: bxne r12 @ bail to the interpreter ldr r3, [r9, #offClassObject_pDvmDex] @ r3<- method->clazz->pDvmDex - ldr r2, [rGLUE, #offGlue_self] @ r2<- glue->self - @ Update "glue" values for the new method - str r0, [rGLUE, #offGlue_method] @ glue->method = methodToCall - str r3, [rGLUE, #offGlue_methodClassDex] @ glue->methodClassDex = ... + @ Update "thread" values for the new method + str r0, [rSELF, #offThread_method] @ self->method = methodToCall + str r3, [rSELF, #offThread_methodClassDex] @ self->methodClassDex = ... mov rFP, r1 @ fp = newFp - str rFP, [r2, #offThread_curFrame] @ self->curFrame = newFp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = newFp #if defined(TEMPLATE_INLINE_PROFILING) stmfd sp!, {r0-r2,lr} @ preserve clobbered live registers mov r1, r6 - @ r0=methodToCall, r1=rGlue + @ r0=methodToCall, r1=rSELF mov lr, pc ldr pc, .LdvmFastMethodTraceEnter ldmfd sp!, {r0-r2,lr} @ restore registers @@ -374,7 +368,7 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_PREDICTED_CHAIN: ldr r3, [r0, #offObject_clazz] @ r3 <- this->class ldr r8, [r2, #4] @ r8 <- predictedChainCell->clazz ldr r0, [r2, #8] @ r0 <- predictedChainCell->method - ldr r9, [rGLUE, #offGlue_icRechainCount] @ r1 <- shared rechainCount + ldr r9, [rSELF, #offThread_icRechainCount] @ r1 <- shared rechainCount cmp r3, r8 @ predicted class == actual class? #if defined(WITH_JIT_TUNING) ldr r7, .LdvmICHitCount @@ -396,7 +390,7 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_PREDICTED_CHAIN: cmp r8, #0 @ initialized class or not moveq r1, #0 subne r1, r9, #1 @ count-- - strne r1, [rGLUE, #offGlue_icRechainCount] @ write back to InterpState + strne r1, [rSELF, #offThread_icRechainCount] @ write back to thread add lr, lr, #4 @ return to fully-resolve landing pad /* * r1 <- count @@ -414,13 +408,12 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE: /* File: armv5te/TEMPLATE_INVOKE_METHOD_NATIVE.S */ @ r0 = methodToCall, r1 = returnCell, rPC = dalvikCallsite @ r7 = methodToCall->registersSize - ldr r9, [rGLUE, #offGlue_interpStackEnd] @ r9<- interpStackEnd - ldr r8, [rGLUE, #offGlue_pSelfSuspendCount] @ r8<- &suspendCount + ldr r9, [rSELF, #offThread_interpStackEnd] @ r9<- interpStackEnd + ldr r8, [rSELF, #offThread_suspendCount] @ r8<- suspendCount add r3, r1, #1 @ Thumb addr is odd SAVEAREA_FROM_FP(r1, rFP) @ r1<- stack save area sub r1, r1, r7, lsl #2 @ r1<- newFp (old savearea - regsSize) SAVEAREA_FROM_FP(r10, r1) @ r10<- stack save area - ldr r8, [r8] @ r3<- suspendCount (int) cmp r10, r9 @ bottom < interpStackEnd? bxlo lr @ return to raise stack overflow excep. @ r1 = newFP, r0 = methodToCall, r3 = returnCell, rPC = dalvikCallsite @@ -430,7 +423,6 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE: @ set up newSaveArea str rFP, [r1, #(offStackSaveArea_prevFrame - sizeofStackSaveArea)] str r3, [r1, #(offStackSaveArea_returnAddr - sizeofStackSaveArea)] - ldr r3, [rGLUE, #offGlue_self] @ r3<- glue->self str r0, [r1, #(offStackSaveArea_method - sizeofStackSaveArea)] cmp r8, #0 @ suspendCount != 0 ldr r8, [r0, #offMethod_nativeFunc] @ r8<- method->nativeFunc @@ -441,25 +433,25 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE: #endif @ go ahead and transfer control to the native code - ldr r9, [r3, #offThread_jniLocal_topCookie] @ r9<- thread->localRef->... + ldr r9, [rSELF, #offThread_jniLocal_topCookie]@r9<-thread->localRef->... mov r2, #0 - str r1, [r3, #offThread_curFrame] @ self->curFrame = newFp - str r2, [r3, #offThread_inJitCodeCache] @ not in the jit code cache + str r1, [rSELF, #offThread_curFrame] @ self->curFrame = newFp + str r2, [rSELF, #offThread_inJitCodeCache] @ not in the jit code cache str r9, [r1, #(offStackSaveArea_localRefCookie - sizeofStackSaveArea)] @ newFp->localRefCookie=top - mov r9, r3 @ r9<- glue->self (preserve) SAVEAREA_FROM_FP(r10, r1) @ r10<- new stack save area - mov r2, r0 @ r2<- methodToCall - mov r0, r1 @ r0<- newFP - add r1, rGLUE, #offGlue_retval @ r1<- &retval + mov r2, r0 @ arg2<- methodToCall + mov r0, r1 @ arg0<- newFP + add r1, rSELF, #offThread_retval @ arg1<- &retval + mov r3, rSELF @ arg3<- self #if defined(TEMPLATE_INLINE_PROFILING) - @ r2=methodToCall, r6=rGLUE + @ r2=methodToCall, r6=rSELF stmfd sp!, {r2,r6} @ to be consumed after JNI return stmfd sp!, {r0-r3} @ preserve r0-r3 mov r0, r2 mov r1, r6 - @ r0=JNIMethod, r1=rGlue + @ r0=JNIMethod, r1=rSELF mov lr, pc ldr pc, .LdvmFastMethodTraceEnter ldmfd sp!, {r0-r3} @ restore r0-r3 @@ -469,24 +461,24 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE: #if defined(TEMPLATE_INLINE_PROFILING) ldmfd sp!, {r0-r1} @ restore r2 and r6 - @ r0=JNIMethod, r1=rGlue + @ r0=JNIMethod, r1=rSELF mov lr, pc ldr pc, .LdvmFastNativeMethodTraceExit #endif - @ native return; r9=self, r10=newSaveArea + @ native return; r10=newSaveArea @ equivalent to dvmPopJniLocals ldr r2, [r10, #offStackSaveArea_returnAddr] @ r2 = chaining cell ret ldr r0, [r10, #offStackSaveArea_localRefCookie] @ r0<- saved->top - ldr r1, [r9, #offThread_exception] @ check for exception - str rFP, [r9, #offThread_curFrame] @ self->curFrame = fp + ldr r1, [rSELF, #offThread_exception] @ check for exception + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = fp cmp r1, #0 @ null? - str r0, [r9, #offThread_jniLocal_topCookie] @ new top <- old top + str r0, [rSELF, #offThread_jniLocal_topCookie] @ new top <- old top ldr r0, [rFP, #(offStackSaveArea_currentPc - sizeofStackSaveArea)] @ r0 = dalvikCallsitePC bne .LhandleException @ no, handle exception - str r2, [r9, #offThread_inJitCodeCache] @ set the mode properly + str r2, [rSELF, #offThread_inJitCodeCache] @ set the mode properly cmp r2, #0 @ return chaining cell still exists? bxne r2 @ yes - go ahead @@ -1384,7 +1376,7 @@ dvmCompiler_TEMPLATE_INTERPRET: * r1 - the Dalvik PC to begin interpretation. * else * [lr, #3] contains Dalvik PC to begin interpretation - * rGLUE - pointer to interpState + * rSELF - pointer to thread * rFP - Dalvik frame pointer */ cmp lr, #0 @@ -1425,10 +1417,10 @@ dvmCompiler_TEMPLATE_MONITOR_ENTER: str r3, [r0, #offThread_inJitCodeCache] blx r2 @ dvmLockObject(self, obj) @ refresh Jit's on/off status - ldr r0, [rGLUE, #offGlue_ppJitProfTable] - ldr r0, [r0] + ldr r3, [rSELF, #offThread_ppJitProfTable] + ldr r3, [r3] ldr r2, .LdvmJitToInterpNoChain - str r0, [rGLUE, #offGlue_pJitProfTable] + str r3, [rSELF, #offThread_pJitProfTable] @ Bail to interpreter - no chain [note - r4 still contains rPC] #if defined(WITH_JIT_TUNING) mov r0, #kHeavyweightMonitor @@ -1456,11 +1448,10 @@ dvmCompiler_TEMPLATE_MONITOR_ENTER_DEBUG: str r3, [r0, #offThread_inJitCodeCache] blx r2 @ dvmLockObject(self, obj) @ refresh Jit's on/off status & test for exception - ldr r0, [rGLUE, #offGlue_ppJitProfTable] - ldr r1, [rGLUE, #offGlue_self] - ldr r0, [r0] - ldr r1, [r1, #offThread_exception] - str r0, [rGLUE, #offGlue_pJitProfTable] + ldr r3, [rSELF, #offThread_ppJitProfTable] + ldr r3, [r3] + ldr r1, [rSELF, #offThread_exception] + str r3, [rSELF, #offThread_pJitProfTable] cmp r1, #0 beq 1f ldr r2, .LhandleException @@ -1489,7 +1480,7 @@ dvmCompiler_TEMPLATE_PERIODIC_PROFILING: * we are arriving from thumb mode, lr will have its low bit set. */ ldr r0, [lr,#-11] - ldr r1, [rGLUE, #offGlue_pProfileCountdown] + ldr r1, [rSELF, #offThread_pProfileCountdown] ldr r2, [r0] @ get counter ldr r3, [r1] @ get countdown timer add r2, #1 @@ -1522,14 +1513,14 @@ dvmCompiler_TEMPLATE_RETURN_PROF: #if defined(TEMPLATE_INLINE_PROFILING) stmfd sp!, {r0-r2,lr} @ preserve live registers mov r0, r6 - @ r0=rGlue + @ r0=rSELF mov lr, pc ldr pc, .LdvmFastJavaMethodTraceExit ldmfd sp!, {r0-r2,lr} @ restore live registers #endif SAVEAREA_FROM_FP(r0, rFP) @ r0<- saveArea (old) ldr r10, [r0, #offStackSaveArea_prevFrame] @ r10<- saveArea->prevFrame - ldr r8, [rGLUE, #offGlue_pSelfSuspendCount] @ r8<- &suspendCount + ldr r8, [rSELF, #offThread_suspendCount] @ r8<- suspendCount ldr rPC, [r0, #offStackSaveArea_savedPc] @ rPC<- saveArea->savedPc #if !defined(WITH_SELF_VERIFICATION) ldr r9, [r0, #offStackSaveArea_returnAddr] @ r9<- chaining cell ret @@ -1538,7 +1529,6 @@ dvmCompiler_TEMPLATE_RETURN_PROF: #endif ldr r2, [r10, #(offStackSaveArea_method - sizeofStackSaveArea)] @ r2<- method we're returning to - ldr r3, [rGLUE, #offGlue_self] @ r3<- glue->self cmp r2, #0 @ break frame? #if !defined(WITH_SELF_VERIFICATION) beq 1f @ bail to interpreter @@ -1548,16 +1538,15 @@ dvmCompiler_TEMPLATE_RETURN_PROF: ldr r1, .LdvmJitToInterpNoChainNoProfile @ defined in footer.S mov rFP, r10 @ publish new FP ldr r10, [r2, #offMethod_clazz] @ r10<- method->clazz - ldr r8, [r8] @ r8<- suspendCount - str r2, [rGLUE, #offGlue_method]@ glue->method = newSave->method + str r2, [rSELF, #offThread_method]@ self->method = newSave->method ldr r0, [r10, #offClassObject_pDvmDex] @ r0<- method->clazz->pDvmDex - str rFP, [r3, #offThread_curFrame] @ self->curFrame = fp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = fp add rPC, rPC, #6 @ publish new rPC (advance 6 bytes) - str r0, [rGLUE, #offGlue_methodClassDex] + str r0, [rSELF, #offThread_methodClassDex] cmp r8, #0 @ check the suspendCount movne r9, #0 @ clear the chaining cell address - str r9, [r3, #offThread_inJitCodeCache] @ in code cache or not + str r9, [rSELF, #offThread_inJitCodeCache] @ in code cache or not cmp r9, #0 @ chaining cell exists? blxne r9 @ jump to the chaining cell #if defined(WITH_JIT_TUNING) @@ -1565,10 +1554,10 @@ dvmCompiler_TEMPLATE_RETURN_PROF: #endif mov pc, r1 @ callsite is interpreted 1: - stmia rGLUE, {rPC, rFP} @ SAVE_PC_FP_TO_GLUE() + stmia rSELF, {rPC, rFP} @ SAVE_PC_FP_TO_SELF() ldr r2, .LdvmMterpStdBail @ defined in footer.S mov r1, #0 @ changeInterp = false - mov r0, rGLUE @ Expecting rGLUE in r0 + mov r0, rSELF @ Expecting rSELF in r0 blx r2 @ exit the interpreter #undef TEMPLATE_INLINE_PROFILING @@ -1588,14 +1577,13 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NO_OPT_PROF: @ r0 = methodToCall, r1 = returnCell, rPC = dalvikCallsite ldrh r7, [r0, #offMethod_registersSize] @ r7<- methodToCall->regsSize ldrh r2, [r0, #offMethod_outsSize] @ r2<- methodToCall->outsSize - ldr r9, [rGLUE, #offGlue_interpStackEnd] @ r9<- interpStackEnd - ldr r8, [rGLUE, #offGlue_pSelfSuspendCount] @ r8<- &suspendCount + ldr r9, [rSELF, #offThread_interpStackEnd] @ r9<- interpStackEnd + ldr r8, [rSELF, #offThread_suspendCount] @ r8<- suspendCount add r3, r1, #1 @ Thumb addr is odd SAVEAREA_FROM_FP(r1, rFP) @ r1<- stack save area sub r1, r1, r7, lsl #2 @ r1<- newFp (old savearea - regsSize) SAVEAREA_FROM_FP(r10, r1) @ r10<- stack save area sub r10, r10, r2, lsl #2 @ r10<- bottom (newsave - outsSize) - ldr r8, [r8] @ r8<- suspendCount (int) cmp r10, r9 @ bottom < interpStackEnd? bxlo lr @ return to raise stack overflow excep. @ r1 = newFP, r0 = methodToCall, r3 = returnCell, rPC = dalvikCallsite @@ -1621,17 +1609,16 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NO_OPT_PROF: ldr r10, .LdvmJitToInterpTraceSelectNoChain ldr r3, [r9, #offClassObject_pDvmDex] @ r3<- method->clazz->pDvmDex - ldr r2, [rGLUE, #offGlue_self] @ r2<- glue->self - @ Update "glue" values for the new method - str r0, [rGLUE, #offGlue_method] @ glue->method = methodToCall - str r3, [rGLUE, #offGlue_methodClassDex] @ glue->methodClassDex = ... + @ Update "thread" values for the new method + str r0, [rSELF, #offThread_method] @ self->method = methodToCall + str r3, [rSELF, #offThread_methodClassDex] @ self->methodClassDex = ... mov rFP, r1 @ fp = newFp - str rFP, [r2, #offThread_curFrame] @ self->curFrame = newFp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = newFp #if defined(TEMPLATE_INLINE_PROFILING) stmfd sp!, {r0-r3} @ preserve r0-r3 mov r1, r6 - @ r0=methodToCall, r1=rGlue + @ r0=methodToCall, r1=rSELF mov lr, pc ldr pc, .LdvmFastMethodTraceEnter ldmfd sp!, {r0-r3} @ restore r0-r3 @@ -1661,15 +1648,14 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_CHAIN_PROF: @ rPC = dalvikCallsite, r7 = methodToCall->registersSize @ methodToCall is guaranteed to be non-native .LinvokeChainProf: - ldr r9, [rGLUE, #offGlue_interpStackEnd] @ r9<- interpStackEnd - ldr r8, [rGLUE, #offGlue_pSelfSuspendCount] @ r8<- &suspendCount + ldr r9, [rSELF, #offThread_interpStackEnd] @ r9<- interpStackEnd + ldr r8, [rSELF, #offThread_suspendCount] @ r8<- suspendCount add r3, r1, #1 @ Thumb addr is odd SAVEAREA_FROM_FP(r1, rFP) @ r1<- stack save area sub r1, r1, r7, lsl #2 @ r1<- newFp (old savearea - regsSize) SAVEAREA_FROM_FP(r10, r1) @ r10<- stack save area add r12, lr, #2 @ setup the punt-to-interp address sub r10, r10, r2, lsl #2 @ r10<- bottom (newsave - outsSize) - ldr r8, [r8] @ r8<- suspendCount (int) cmp r10, r9 @ bottom < interpStackEnd? bxlo r12 @ return to raise stack overflow excep. @ r1 = newFP, r0 = methodToCall, r3 = returnCell, rPC = dalvikCallsite @@ -1685,17 +1671,16 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_CHAIN_PROF: bxne r12 @ bail to the interpreter ldr r3, [r9, #offClassObject_pDvmDex] @ r3<- method->clazz->pDvmDex - ldr r2, [rGLUE, #offGlue_self] @ r2<- glue->self - @ Update "glue" values for the new method - str r0, [rGLUE, #offGlue_method] @ glue->method = methodToCall - str r3, [rGLUE, #offGlue_methodClassDex] @ glue->methodClassDex = ... + @ Update "thread" values for the new method + str r0, [rSELF, #offThread_method] @ self->method = methodToCall + str r3, [rSELF, #offThread_methodClassDex] @ self->methodClassDex = ... mov rFP, r1 @ fp = newFp - str rFP, [r2, #offThread_curFrame] @ self->curFrame = newFp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = newFp #if defined(TEMPLATE_INLINE_PROFILING) stmfd sp!, {r0-r2,lr} @ preserve clobbered live registers mov r1, r6 - @ r0=methodToCall, r1=rGlue + @ r0=methodToCall, r1=rSELF mov lr, pc ldr pc, .LdvmFastMethodTraceEnter ldmfd sp!, {r0-r2,lr} @ restore registers @@ -1739,7 +1724,7 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_PREDICTED_CHAIN_PROF: ldr r3, [r0, #offObject_clazz] @ r3 <- this->class ldr r8, [r2, #4] @ r8 <- predictedChainCell->clazz ldr r0, [r2, #8] @ r0 <- predictedChainCell->method - ldr r9, [rGLUE, #offGlue_icRechainCount] @ r1 <- shared rechainCount + ldr r9, [rSELF, #offThread_icRechainCount] @ r1 <- shared rechainCount cmp r3, r8 @ predicted class == actual class? #if defined(WITH_JIT_TUNING) ldr r7, .LdvmICHitCount @@ -1761,7 +1746,7 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_PREDICTED_CHAIN_PROF: cmp r8, #0 @ initialized class or not moveq r1, #0 subne r1, r9, #1 @ count-- - strne r1, [rGLUE, #offGlue_icRechainCount] @ write back to InterpState + strne r1, [rSELF, #offThread_icRechainCount] @ write back to thread add lr, lr, #4 @ return to fully-resolve landing pad /* * r1 <- count @@ -1783,13 +1768,12 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE_PROF: /* File: armv5te/TEMPLATE_INVOKE_METHOD_NATIVE.S */ @ r0 = methodToCall, r1 = returnCell, rPC = dalvikCallsite @ r7 = methodToCall->registersSize - ldr r9, [rGLUE, #offGlue_interpStackEnd] @ r9<- interpStackEnd - ldr r8, [rGLUE, #offGlue_pSelfSuspendCount] @ r8<- &suspendCount + ldr r9, [rSELF, #offThread_interpStackEnd] @ r9<- interpStackEnd + ldr r8, [rSELF, #offThread_suspendCount] @ r8<- suspendCount add r3, r1, #1 @ Thumb addr is odd SAVEAREA_FROM_FP(r1, rFP) @ r1<- stack save area sub r1, r1, r7, lsl #2 @ r1<- newFp (old savearea - regsSize) SAVEAREA_FROM_FP(r10, r1) @ r10<- stack save area - ldr r8, [r8] @ r3<- suspendCount (int) cmp r10, r9 @ bottom < interpStackEnd? bxlo lr @ return to raise stack overflow excep. @ r1 = newFP, r0 = methodToCall, r3 = returnCell, rPC = dalvikCallsite @@ -1799,7 +1783,6 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE_PROF: @ set up newSaveArea str rFP, [r1, #(offStackSaveArea_prevFrame - sizeofStackSaveArea)] str r3, [r1, #(offStackSaveArea_returnAddr - sizeofStackSaveArea)] - ldr r3, [rGLUE, #offGlue_self] @ r3<- glue->self str r0, [r1, #(offStackSaveArea_method - sizeofStackSaveArea)] cmp r8, #0 @ suspendCount != 0 ldr r8, [r0, #offMethod_nativeFunc] @ r8<- method->nativeFunc @@ -1810,25 +1793,25 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE_PROF: #endif @ go ahead and transfer control to the native code - ldr r9, [r3, #offThread_jniLocal_topCookie] @ r9<- thread->localRef->... + ldr r9, [rSELF, #offThread_jniLocal_topCookie]@r9<-thread->localRef->... mov r2, #0 - str r1, [r3, #offThread_curFrame] @ self->curFrame = newFp - str r2, [r3, #offThread_inJitCodeCache] @ not in the jit code cache + str r1, [rSELF, #offThread_curFrame] @ self->curFrame = newFp + str r2, [rSELF, #offThread_inJitCodeCache] @ not in the jit code cache str r9, [r1, #(offStackSaveArea_localRefCookie - sizeofStackSaveArea)] @ newFp->localRefCookie=top - mov r9, r3 @ r9<- glue->self (preserve) SAVEAREA_FROM_FP(r10, r1) @ r10<- new stack save area - mov r2, r0 @ r2<- methodToCall - mov r0, r1 @ r0<- newFP - add r1, rGLUE, #offGlue_retval @ r1<- &retval + mov r2, r0 @ arg2<- methodToCall + mov r0, r1 @ arg0<- newFP + add r1, rSELF, #offThread_retval @ arg1<- &retval + mov r3, rSELF @ arg3<- self #if defined(TEMPLATE_INLINE_PROFILING) - @ r2=methodToCall, r6=rGLUE + @ r2=methodToCall, r6=rSELF stmfd sp!, {r2,r6} @ to be consumed after JNI return stmfd sp!, {r0-r3} @ preserve r0-r3 mov r0, r2 mov r1, r6 - @ r0=JNIMethod, r1=rGlue + @ r0=JNIMethod, r1=rSELF mov lr, pc ldr pc, .LdvmFastMethodTraceEnter ldmfd sp!, {r0-r3} @ restore r0-r3 @@ -1838,24 +1821,24 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE_PROF: #if defined(TEMPLATE_INLINE_PROFILING) ldmfd sp!, {r0-r1} @ restore r2 and r6 - @ r0=JNIMethod, r1=rGlue + @ r0=JNIMethod, r1=rSELF mov lr, pc ldr pc, .LdvmFastNativeMethodTraceExit #endif - @ native return; r9=self, r10=newSaveArea + @ native return; r10=newSaveArea @ equivalent to dvmPopJniLocals ldr r2, [r10, #offStackSaveArea_returnAddr] @ r2 = chaining cell ret ldr r0, [r10, #offStackSaveArea_localRefCookie] @ r0<- saved->top - ldr r1, [r9, #offThread_exception] @ check for exception - str rFP, [r9, #offThread_curFrame] @ self->curFrame = fp + ldr r1, [rSELF, #offThread_exception] @ check for exception + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = fp cmp r1, #0 @ null? - str r0, [r9, #offThread_jniLocal_topCookie] @ new top <- old top + str r0, [rSELF, #offThread_jniLocal_topCookie] @ new top <- old top ldr r0, [rFP, #(offStackSaveArea_currentPc - sizeofStackSaveArea)] @ r0 = dalvikCallsitePC bne .LhandleException @ no, handle exception - str r2, [r9, #offThread_inJitCodeCache] @ set the mode properly + str r2, [rSELF, #offThread_inJitCodeCache] @ set the mode properly cmp r2, #0 @ return chaining cell still exists? bxne r2 @ yes - go ahead @@ -1882,24 +1865,23 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE_PROF: .LinvokeNative: @ Prep for the native call @ r1 = newFP, r0 = methodToCall - ldr r3, [rGLUE, #offGlue_self] @ r3<- glue->self mov r2, #0 - ldr r9, [r3, #offThread_jniLocal_topCookie] @ r9<- thread->localRef->... - str r2, [r3, #offThread_inJitCodeCache] @ not in jit code cache - str r1, [r3, #offThread_curFrame] @ self->curFrame = newFp + ldr r9, [rSELF, #offThread_jniLocal_topCookie]@r9<-thread->localRef->... + str r2, [rSELF, #offThread_inJitCodeCache] @ not in jit code cache + str r1, [rSELF, #offThread_curFrame] @ self->curFrame = newFp str r9, [r1, #(offStackSaveArea_localRefCookie - sizeofStackSaveArea)] @ newFp->localRefCookie=top - mov r9, r3 @ r9<- glue->self (preserve) - ldr lr, [rGLUE, #offGlue_pInterpBreak] + ldr lr, [rSELF, #offThread_pInterpBreak] SAVEAREA_FROM_FP(r10, r1) @ r10<- new stack save area mov r2, r0 @ r2<- methodToCall ldr lr, [lr] @ lr<- set of active profilers mov r0, r1 @ r0<- newFP - add r1, rGLUE, #offGlue_retval @ r1<- &retval + add r1, rSELF, #offThread_retval @ r1<- &retval + mov r3, rSELF @ arg3<- self ands lr, #kSubModeMethodTrace beq 121f @ hop if not profiling - @ r2: methodToCall, r6: rGLUE + @ r2: methodToCall, r6: rSELF stmfd sp!, {r2,r6} stmfd sp!, {r0-r3} mov r0, r2 @@ -1920,24 +1902,24 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE_PROF: ldr pc, [r2, #offMethod_nativeFunc] 212: @ Refresh Jit's on/off status - ldr r3, [rGLUE, #offGlue_ppJitProfTable] + ldr r3, [rSELF, #offThread_ppJitProfTable] - @ native return; r9=self, r10=newSaveArea + @ native return; r10=newSaveArea @ equivalent to dvmPopJniLocals ldr r2, [r10, #offStackSaveArea_returnAddr] @ r2 = chaining cell ret ldr r0, [r10, #offStackSaveArea_localRefCookie] @ r0<- saved->top - ldr r1, [r9, #offThread_exception] @ check for exception + ldr r1, [rSELF, #offThread_exception] @ check for exception ldr r3, [r3] @ r1 <- pointer to Jit profile table - str rFP, [r9, #offThread_curFrame] @ self->curFrame = fp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = fp cmp r1, #0 @ null? - str r0, [r9, #offThread_jniLocal_topCookie] @ new top <- old top + str r0, [rSELF, #offThread_jniLocal_topCookie] @ new top <- old top + str r3, [rSELF, #offThread_pJitProfTable] @ cache current JitProfTable ldr r0, [r10, #offStackSaveArea_savedPc] @ reload rPC - str r3, [rGLUE, #offGlue_pJitProfTable] @ cache current JitProfTable @ r0 = dalvikCallsitePC bne .LhandleException @ no, handle exception - str r2, [r9, #offThread_inJitCodeCache] @ set the new mode + str r2, [rSELF, #offThread_inJitCodeCache] @ set the new mode cmp r2, #0 @ return chaining cell still exists? bxne r2 @ yes - go ahead @@ -1959,9 +1941,8 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE_PROF: .LdeadFood: .word 0xdeadf00d #endif - ldr r3, [rGLUE, #offGlue_self] @ r3<- glue->self mov r2, #0 - str r2, [r3, #offThread_inJitCodeCache] @ in interpreter land + str r2, [rSELF, #offThread_inJitCodeCache] @ in interpreter land ldr r1, .LdvmMterpCommonExceptionThrown @ PIC way of getting &func ldr rIBASE, .LdvmAsmInstructionStart @ same as above mov rPC, r0 @ reload the faulting Dalvik address diff --git a/vm/compiler/template/out/CompilerTemplateAsm-armv5te.S b/vm/compiler/template/out/CompilerTemplateAsm-armv5te.S index 2d69a3d85..aebad92a5 100644 --- a/vm/compiler/template/out/CompilerTemplateAsm-armv5te.S +++ b/vm/compiler/template/out/CompilerTemplateAsm-armv5te.S @@ -62,7 +62,7 @@ The following registers have fixed assignments: reg nick purpose r5 rFP interpreted frame pointer, used for accessing locals and args - r6 rGLUE MterpGlue pointer + r6 rSELF thread pointer The following registers have fixed assignments in mterp but are scratch registers in compiled code @@ -80,7 +80,7 @@ unspecified registers or condition codes. /* single-purpose registers, given names for clarity */ #define rPC r4 #define rFP r5 -#define rGLUE r6 +#define rSELF r6 #define rINST r7 #define rIBASE r8 @@ -169,14 +169,14 @@ dvmCompiler_TEMPLATE_RETURN: #if defined(TEMPLATE_INLINE_PROFILING) stmfd sp!, {r0-r2,lr} @ preserve live registers mov r0, r6 - @ r0=rGlue + @ r0=rSELF mov lr, pc ldr pc, .LdvmFastJavaMethodTraceExit ldmfd sp!, {r0-r2,lr} @ restore live registers #endif SAVEAREA_FROM_FP(r0, rFP) @ r0<- saveArea (old) ldr r10, [r0, #offStackSaveArea_prevFrame] @ r10<- saveArea->prevFrame - ldr r8, [rGLUE, #offGlue_pSelfSuspendCount] @ r8<- &suspendCount + ldr r8, [rSELF, #offThread_suspendCount] @ r8<- suspendCount ldr rPC, [r0, #offStackSaveArea_savedPc] @ rPC<- saveArea->savedPc #if !defined(WITH_SELF_VERIFICATION) ldr r9, [r0, #offStackSaveArea_returnAddr] @ r9<- chaining cell ret @@ -185,7 +185,6 @@ dvmCompiler_TEMPLATE_RETURN: #endif ldr r2, [r10, #(offStackSaveArea_method - sizeofStackSaveArea)] @ r2<- method we're returning to - ldr r3, [rGLUE, #offGlue_self] @ r3<- glue->self cmp r2, #0 @ break frame? #if !defined(WITH_SELF_VERIFICATION) beq 1f @ bail to interpreter @@ -195,16 +194,15 @@ dvmCompiler_TEMPLATE_RETURN: ldr r1, .LdvmJitToInterpNoChainNoProfile @ defined in footer.S mov rFP, r10 @ publish new FP ldr r10, [r2, #offMethod_clazz] @ r10<- method->clazz - ldr r8, [r8] @ r8<- suspendCount - str r2, [rGLUE, #offGlue_method]@ glue->method = newSave->method + str r2, [rSELF, #offThread_method]@ self->method = newSave->method ldr r0, [r10, #offClassObject_pDvmDex] @ r0<- method->clazz->pDvmDex - str rFP, [r3, #offThread_curFrame] @ self->curFrame = fp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = fp add rPC, rPC, #6 @ publish new rPC (advance 6 bytes) - str r0, [rGLUE, #offGlue_methodClassDex] + str r0, [rSELF, #offThread_methodClassDex] cmp r8, #0 @ check the suspendCount movne r9, #0 @ clear the chaining cell address - str r9, [r3, #offThread_inJitCodeCache] @ in code cache or not + str r9, [rSELF, #offThread_inJitCodeCache] @ in code cache or not cmp r9, #0 @ chaining cell exists? blxne r9 @ jump to the chaining cell #if defined(WITH_JIT_TUNING) @@ -212,10 +210,10 @@ dvmCompiler_TEMPLATE_RETURN: #endif mov pc, r1 @ callsite is interpreted 1: - stmia rGLUE, {rPC, rFP} @ SAVE_PC_FP_TO_GLUE() + stmia rSELF, {rPC, rFP} @ SAVE_PC_FP_TO_SELF() ldr r2, .LdvmMterpStdBail @ defined in footer.S mov r1, #0 @ changeInterp = false - mov r0, rGLUE @ Expecting rGLUE in r0 + mov r0, rSELF @ Expecting rSELF in r0 blx r2 @ exit the interpreter /* ------------------------------ */ @@ -231,14 +229,13 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NO_OPT: @ r0 = methodToCall, r1 = returnCell, rPC = dalvikCallsite ldrh r7, [r0, #offMethod_registersSize] @ r7<- methodToCall->regsSize ldrh r2, [r0, #offMethod_outsSize] @ r2<- methodToCall->outsSize - ldr r9, [rGLUE, #offGlue_interpStackEnd] @ r9<- interpStackEnd - ldr r8, [rGLUE, #offGlue_pSelfSuspendCount] @ r8<- &suspendCount + ldr r9, [rSELF, #offThread_interpStackEnd] @ r9<- interpStackEnd + ldr r8, [rSELF, #offThread_suspendCount] @ r8<- suspendCount add r3, r1, #1 @ Thumb addr is odd SAVEAREA_FROM_FP(r1, rFP) @ r1<- stack save area sub r1, r1, r7, lsl #2 @ r1<- newFp (old savearea - regsSize) SAVEAREA_FROM_FP(r10, r1) @ r10<- stack save area sub r10, r10, r2, lsl #2 @ r10<- bottom (newsave - outsSize) - ldr r8, [r8] @ r8<- suspendCount (int) cmp r10, r9 @ bottom < interpStackEnd? bxlo lr @ return to raise stack overflow excep. @ r1 = newFP, r0 = methodToCall, r3 = returnCell, rPC = dalvikCallsite @@ -264,17 +261,16 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NO_OPT: ldr r10, .LdvmJitToInterpTraceSelectNoChain ldr r3, [r9, #offClassObject_pDvmDex] @ r3<- method->clazz->pDvmDex - ldr r2, [rGLUE, #offGlue_self] @ r2<- glue->self - @ Update "glue" values for the new method - str r0, [rGLUE, #offGlue_method] @ glue->method = methodToCall - str r3, [rGLUE, #offGlue_methodClassDex] @ glue->methodClassDex = ... + @ Update "thread" values for the new method + str r0, [rSELF, #offThread_method] @ self->method = methodToCall + str r3, [rSELF, #offThread_methodClassDex] @ self->methodClassDex = ... mov rFP, r1 @ fp = newFp - str rFP, [r2, #offThread_curFrame] @ self->curFrame = newFp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = newFp #if defined(TEMPLATE_INLINE_PROFILING) stmfd sp!, {r0-r3} @ preserve r0-r3 mov r1, r6 - @ r0=methodToCall, r1=rGlue + @ r0=methodToCall, r1=rSELF mov lr, pc ldr pc, .LdvmFastMethodTraceEnter ldmfd sp!, {r0-r3} @ restore r0-r3 @@ -300,15 +296,14 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_CHAIN: @ rPC = dalvikCallsite, r7 = methodToCall->registersSize @ methodToCall is guaranteed to be non-native .LinvokeChain: - ldr r9, [rGLUE, #offGlue_interpStackEnd] @ r9<- interpStackEnd - ldr r8, [rGLUE, #offGlue_pSelfSuspendCount] @ r8<- &suspendCount + ldr r9, [rSELF, #offThread_interpStackEnd] @ r9<- interpStackEnd + ldr r8, [rSELF, #offThread_suspendCount] @ r8<- suspendCount add r3, r1, #1 @ Thumb addr is odd SAVEAREA_FROM_FP(r1, rFP) @ r1<- stack save area sub r1, r1, r7, lsl #2 @ r1<- newFp (old savearea - regsSize) SAVEAREA_FROM_FP(r10, r1) @ r10<- stack save area add r12, lr, #2 @ setup the punt-to-interp address sub r10, r10, r2, lsl #2 @ r10<- bottom (newsave - outsSize) - ldr r8, [r8] @ r8<- suspendCount (int) cmp r10, r9 @ bottom < interpStackEnd? bxlo r12 @ return to raise stack overflow excep. @ r1 = newFP, r0 = methodToCall, r3 = returnCell, rPC = dalvikCallsite @@ -324,17 +319,16 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_CHAIN: bxne r12 @ bail to the interpreter ldr r3, [r9, #offClassObject_pDvmDex] @ r3<- method->clazz->pDvmDex - ldr r2, [rGLUE, #offGlue_self] @ r2<- glue->self - @ Update "glue" values for the new method - str r0, [rGLUE, #offGlue_method] @ glue->method = methodToCall - str r3, [rGLUE, #offGlue_methodClassDex] @ glue->methodClassDex = ... + @ Update "thread" values for the new method + str r0, [rSELF, #offThread_method] @ self->method = methodToCall + str r3, [rSELF, #offThread_methodClassDex] @ self->methodClassDex = ... mov rFP, r1 @ fp = newFp - str rFP, [r2, #offThread_curFrame] @ self->curFrame = newFp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = newFp #if defined(TEMPLATE_INLINE_PROFILING) stmfd sp!, {r0-r2,lr} @ preserve clobbered live registers mov r1, r6 - @ r0=methodToCall, r1=rGlue + @ r0=methodToCall, r1=rSELF mov lr, pc ldr pc, .LdvmFastMethodTraceEnter ldmfd sp!, {r0-r2,lr} @ restore registers @@ -374,7 +368,7 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_PREDICTED_CHAIN: ldr r3, [r0, #offObject_clazz] @ r3 <- this->class ldr r8, [r2, #4] @ r8 <- predictedChainCell->clazz ldr r0, [r2, #8] @ r0 <- predictedChainCell->method - ldr r9, [rGLUE, #offGlue_icRechainCount] @ r1 <- shared rechainCount + ldr r9, [rSELF, #offThread_icRechainCount] @ r1 <- shared rechainCount cmp r3, r8 @ predicted class == actual class? #if defined(WITH_JIT_TUNING) ldr r7, .LdvmICHitCount @@ -396,7 +390,7 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_PREDICTED_CHAIN: cmp r8, #0 @ initialized class or not moveq r1, #0 subne r1, r9, #1 @ count-- - strne r1, [rGLUE, #offGlue_icRechainCount] @ write back to InterpState + strne r1, [rSELF, #offThread_icRechainCount] @ write back to thread add lr, lr, #4 @ return to fully-resolve landing pad /* * r1 <- count @@ -414,13 +408,12 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE: /* File: armv5te/TEMPLATE_INVOKE_METHOD_NATIVE.S */ @ r0 = methodToCall, r1 = returnCell, rPC = dalvikCallsite @ r7 = methodToCall->registersSize - ldr r9, [rGLUE, #offGlue_interpStackEnd] @ r9<- interpStackEnd - ldr r8, [rGLUE, #offGlue_pSelfSuspendCount] @ r8<- &suspendCount + ldr r9, [rSELF, #offThread_interpStackEnd] @ r9<- interpStackEnd + ldr r8, [rSELF, #offThread_suspendCount] @ r8<- suspendCount add r3, r1, #1 @ Thumb addr is odd SAVEAREA_FROM_FP(r1, rFP) @ r1<- stack save area sub r1, r1, r7, lsl #2 @ r1<- newFp (old savearea - regsSize) SAVEAREA_FROM_FP(r10, r1) @ r10<- stack save area - ldr r8, [r8] @ r3<- suspendCount (int) cmp r10, r9 @ bottom < interpStackEnd? bxlo lr @ return to raise stack overflow excep. @ r1 = newFP, r0 = methodToCall, r3 = returnCell, rPC = dalvikCallsite @@ -430,7 +423,6 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE: @ set up newSaveArea str rFP, [r1, #(offStackSaveArea_prevFrame - sizeofStackSaveArea)] str r3, [r1, #(offStackSaveArea_returnAddr - sizeofStackSaveArea)] - ldr r3, [rGLUE, #offGlue_self] @ r3<- glue->self str r0, [r1, #(offStackSaveArea_method - sizeofStackSaveArea)] cmp r8, #0 @ suspendCount != 0 ldr r8, [r0, #offMethod_nativeFunc] @ r8<- method->nativeFunc @@ -441,25 +433,25 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE: #endif @ go ahead and transfer control to the native code - ldr r9, [r3, #offThread_jniLocal_topCookie] @ r9<- thread->localRef->... + ldr r9, [rSELF, #offThread_jniLocal_topCookie]@r9<-thread->localRef->... mov r2, #0 - str r1, [r3, #offThread_curFrame] @ self->curFrame = newFp - str r2, [r3, #offThread_inJitCodeCache] @ not in the jit code cache + str r1, [rSELF, #offThread_curFrame] @ self->curFrame = newFp + str r2, [rSELF, #offThread_inJitCodeCache] @ not in the jit code cache str r9, [r1, #(offStackSaveArea_localRefCookie - sizeofStackSaveArea)] @ newFp->localRefCookie=top - mov r9, r3 @ r9<- glue->self (preserve) SAVEAREA_FROM_FP(r10, r1) @ r10<- new stack save area - mov r2, r0 @ r2<- methodToCall - mov r0, r1 @ r0<- newFP - add r1, rGLUE, #offGlue_retval @ r1<- &retval + mov r2, r0 @ arg2<- methodToCall + mov r0, r1 @ arg0<- newFP + add r1, rSELF, #offThread_retval @ arg1<- &retval + mov r3, rSELF @ arg3<- self #if defined(TEMPLATE_INLINE_PROFILING) - @ r2=methodToCall, r6=rGLUE + @ r2=methodToCall, r6=rSELF stmfd sp!, {r2,r6} @ to be consumed after JNI return stmfd sp!, {r0-r3} @ preserve r0-r3 mov r0, r2 mov r1, r6 - @ r0=JNIMethod, r1=rGlue + @ r0=JNIMethod, r1=rSELF mov lr, pc ldr pc, .LdvmFastMethodTraceEnter ldmfd sp!, {r0-r3} @ restore r0-r3 @@ -469,24 +461,24 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE: #if defined(TEMPLATE_INLINE_PROFILING) ldmfd sp!, {r0-r1} @ restore r2 and r6 - @ r0=JNIMethod, r1=rGlue + @ r0=JNIMethod, r1=rSELF mov lr, pc ldr pc, .LdvmFastNativeMethodTraceExit #endif - @ native return; r9=self, r10=newSaveArea + @ native return; r10=newSaveArea @ equivalent to dvmPopJniLocals ldr r2, [r10, #offStackSaveArea_returnAddr] @ r2 = chaining cell ret ldr r0, [r10, #offStackSaveArea_localRefCookie] @ r0<- saved->top - ldr r1, [r9, #offThread_exception] @ check for exception - str rFP, [r9, #offThread_curFrame] @ self->curFrame = fp + ldr r1, [rSELF, #offThread_exception] @ check for exception + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = fp cmp r1, #0 @ null? - str r0, [r9, #offThread_jniLocal_topCookie] @ new top <- old top + str r0, [rSELF, #offThread_jniLocal_topCookie] @ new top <- old top ldr r0, [rFP, #(offStackSaveArea_currentPc - sizeofStackSaveArea)] @ r0 = dalvikCallsitePC bne .LhandleException @ no, handle exception - str r2, [r9, #offThread_inJitCodeCache] @ set the mode properly + str r2, [rSELF, #offThread_inJitCodeCache] @ set the mode properly cmp r2, #0 @ return chaining cell still exists? bxne r2 @ yes - go ahead @@ -1115,7 +1107,7 @@ dvmCompiler_TEMPLATE_INTERPRET: * r1 - the Dalvik PC to begin interpretation. * else * [lr, #3] contains Dalvik PC to begin interpretation - * rGLUE - pointer to interpState + * rSELF - pointer to thread * rFP - Dalvik frame pointer */ cmp lr, #0 @@ -1156,10 +1148,10 @@ dvmCompiler_TEMPLATE_MONITOR_ENTER: str r3, [r0, #offThread_inJitCodeCache] blx r2 @ dvmLockObject(self, obj) @ refresh Jit's on/off status - ldr r0, [rGLUE, #offGlue_ppJitProfTable] - ldr r0, [r0] + ldr r3, [rSELF, #offThread_ppJitProfTable] + ldr r3, [r3] ldr r2, .LdvmJitToInterpNoChain - str r0, [rGLUE, #offGlue_pJitProfTable] + str r3, [rSELF, #offThread_pJitProfTable] @ Bail to interpreter - no chain [note - r4 still contains rPC] #if defined(WITH_JIT_TUNING) mov r0, #kHeavyweightMonitor @@ -1187,11 +1179,10 @@ dvmCompiler_TEMPLATE_MONITOR_ENTER_DEBUG: str r3, [r0, #offThread_inJitCodeCache] blx r2 @ dvmLockObject(self, obj) @ refresh Jit's on/off status & test for exception - ldr r0, [rGLUE, #offGlue_ppJitProfTable] - ldr r1, [rGLUE, #offGlue_self] - ldr r0, [r0] - ldr r1, [r1, #offThread_exception] - str r0, [rGLUE, #offGlue_pJitProfTable] + ldr r3, [rSELF, #offThread_ppJitProfTable] + ldr r3, [r3] + ldr r1, [rSELF, #offThread_exception] + str r3, [rSELF, #offThread_pJitProfTable] cmp r1, #0 beq 1f ldr r2, .LhandleException @@ -1220,7 +1211,7 @@ dvmCompiler_TEMPLATE_PERIODIC_PROFILING: * we are arriving from thumb mode, lr will have its low bit set. */ ldr r0, [lr,#-11] - ldr r1, [rGLUE, #offGlue_pProfileCountdown] + ldr r1, [rSELF, #offThread_pProfileCountdown] ldr r2, [r0] @ get counter ldr r3, [r1] @ get countdown timer add r2, #1 @@ -1253,14 +1244,14 @@ dvmCompiler_TEMPLATE_RETURN_PROF: #if defined(TEMPLATE_INLINE_PROFILING) stmfd sp!, {r0-r2,lr} @ preserve live registers mov r0, r6 - @ r0=rGlue + @ r0=rSELF mov lr, pc ldr pc, .LdvmFastJavaMethodTraceExit ldmfd sp!, {r0-r2,lr} @ restore live registers #endif SAVEAREA_FROM_FP(r0, rFP) @ r0<- saveArea (old) ldr r10, [r0, #offStackSaveArea_prevFrame] @ r10<- saveArea->prevFrame - ldr r8, [rGLUE, #offGlue_pSelfSuspendCount] @ r8<- &suspendCount + ldr r8, [rSELF, #offThread_suspendCount] @ r8<- suspendCount ldr rPC, [r0, #offStackSaveArea_savedPc] @ rPC<- saveArea->savedPc #if !defined(WITH_SELF_VERIFICATION) ldr r9, [r0, #offStackSaveArea_returnAddr] @ r9<- chaining cell ret @@ -1269,7 +1260,6 @@ dvmCompiler_TEMPLATE_RETURN_PROF: #endif ldr r2, [r10, #(offStackSaveArea_method - sizeofStackSaveArea)] @ r2<- method we're returning to - ldr r3, [rGLUE, #offGlue_self] @ r3<- glue->self cmp r2, #0 @ break frame? #if !defined(WITH_SELF_VERIFICATION) beq 1f @ bail to interpreter @@ -1279,16 +1269,15 @@ dvmCompiler_TEMPLATE_RETURN_PROF: ldr r1, .LdvmJitToInterpNoChainNoProfile @ defined in footer.S mov rFP, r10 @ publish new FP ldr r10, [r2, #offMethod_clazz] @ r10<- method->clazz - ldr r8, [r8] @ r8<- suspendCount - str r2, [rGLUE, #offGlue_method]@ glue->method = newSave->method + str r2, [rSELF, #offThread_method]@ self->method = newSave->method ldr r0, [r10, #offClassObject_pDvmDex] @ r0<- method->clazz->pDvmDex - str rFP, [r3, #offThread_curFrame] @ self->curFrame = fp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = fp add rPC, rPC, #6 @ publish new rPC (advance 6 bytes) - str r0, [rGLUE, #offGlue_methodClassDex] + str r0, [rSELF, #offThread_methodClassDex] cmp r8, #0 @ check the suspendCount movne r9, #0 @ clear the chaining cell address - str r9, [r3, #offThread_inJitCodeCache] @ in code cache or not + str r9, [rSELF, #offThread_inJitCodeCache] @ in code cache or not cmp r9, #0 @ chaining cell exists? blxne r9 @ jump to the chaining cell #if defined(WITH_JIT_TUNING) @@ -1296,10 +1285,10 @@ dvmCompiler_TEMPLATE_RETURN_PROF: #endif mov pc, r1 @ callsite is interpreted 1: - stmia rGLUE, {rPC, rFP} @ SAVE_PC_FP_TO_GLUE() + stmia rSELF, {rPC, rFP} @ SAVE_PC_FP_TO_SELF() ldr r2, .LdvmMterpStdBail @ defined in footer.S mov r1, #0 @ changeInterp = false - mov r0, rGLUE @ Expecting rGLUE in r0 + mov r0, rSELF @ Expecting rSELF in r0 blx r2 @ exit the interpreter #undef TEMPLATE_INLINE_PROFILING @@ -1319,14 +1308,13 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NO_OPT_PROF: @ r0 = methodToCall, r1 = returnCell, rPC = dalvikCallsite ldrh r7, [r0, #offMethod_registersSize] @ r7<- methodToCall->regsSize ldrh r2, [r0, #offMethod_outsSize] @ r2<- methodToCall->outsSize - ldr r9, [rGLUE, #offGlue_interpStackEnd] @ r9<- interpStackEnd - ldr r8, [rGLUE, #offGlue_pSelfSuspendCount] @ r8<- &suspendCount + ldr r9, [rSELF, #offThread_interpStackEnd] @ r9<- interpStackEnd + ldr r8, [rSELF, #offThread_suspendCount] @ r8<- suspendCount add r3, r1, #1 @ Thumb addr is odd SAVEAREA_FROM_FP(r1, rFP) @ r1<- stack save area sub r1, r1, r7, lsl #2 @ r1<- newFp (old savearea - regsSize) SAVEAREA_FROM_FP(r10, r1) @ r10<- stack save area sub r10, r10, r2, lsl #2 @ r10<- bottom (newsave - outsSize) - ldr r8, [r8] @ r8<- suspendCount (int) cmp r10, r9 @ bottom < interpStackEnd? bxlo lr @ return to raise stack overflow excep. @ r1 = newFP, r0 = methodToCall, r3 = returnCell, rPC = dalvikCallsite @@ -1352,17 +1340,16 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NO_OPT_PROF: ldr r10, .LdvmJitToInterpTraceSelectNoChain ldr r3, [r9, #offClassObject_pDvmDex] @ r3<- method->clazz->pDvmDex - ldr r2, [rGLUE, #offGlue_self] @ r2<- glue->self - @ Update "glue" values for the new method - str r0, [rGLUE, #offGlue_method] @ glue->method = methodToCall - str r3, [rGLUE, #offGlue_methodClassDex] @ glue->methodClassDex = ... + @ Update "thread" values for the new method + str r0, [rSELF, #offThread_method] @ self->method = methodToCall + str r3, [rSELF, #offThread_methodClassDex] @ self->methodClassDex = ... mov rFP, r1 @ fp = newFp - str rFP, [r2, #offThread_curFrame] @ self->curFrame = newFp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = newFp #if defined(TEMPLATE_INLINE_PROFILING) stmfd sp!, {r0-r3} @ preserve r0-r3 mov r1, r6 - @ r0=methodToCall, r1=rGlue + @ r0=methodToCall, r1=rSELF mov lr, pc ldr pc, .LdvmFastMethodTraceEnter ldmfd sp!, {r0-r3} @ restore r0-r3 @@ -1392,15 +1379,14 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_CHAIN_PROF: @ rPC = dalvikCallsite, r7 = methodToCall->registersSize @ methodToCall is guaranteed to be non-native .LinvokeChainProf: - ldr r9, [rGLUE, #offGlue_interpStackEnd] @ r9<- interpStackEnd - ldr r8, [rGLUE, #offGlue_pSelfSuspendCount] @ r8<- &suspendCount + ldr r9, [rSELF, #offThread_interpStackEnd] @ r9<- interpStackEnd + ldr r8, [rSELF, #offThread_suspendCount] @ r8<- suspendCount add r3, r1, #1 @ Thumb addr is odd SAVEAREA_FROM_FP(r1, rFP) @ r1<- stack save area sub r1, r1, r7, lsl #2 @ r1<- newFp (old savearea - regsSize) SAVEAREA_FROM_FP(r10, r1) @ r10<- stack save area add r12, lr, #2 @ setup the punt-to-interp address sub r10, r10, r2, lsl #2 @ r10<- bottom (newsave - outsSize) - ldr r8, [r8] @ r8<- suspendCount (int) cmp r10, r9 @ bottom < interpStackEnd? bxlo r12 @ return to raise stack overflow excep. @ r1 = newFP, r0 = methodToCall, r3 = returnCell, rPC = dalvikCallsite @@ -1416,17 +1402,16 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_CHAIN_PROF: bxne r12 @ bail to the interpreter ldr r3, [r9, #offClassObject_pDvmDex] @ r3<- method->clazz->pDvmDex - ldr r2, [rGLUE, #offGlue_self] @ r2<- glue->self - @ Update "glue" values for the new method - str r0, [rGLUE, #offGlue_method] @ glue->method = methodToCall - str r3, [rGLUE, #offGlue_methodClassDex] @ glue->methodClassDex = ... + @ Update "thread" values for the new method + str r0, [rSELF, #offThread_method] @ self->method = methodToCall + str r3, [rSELF, #offThread_methodClassDex] @ self->methodClassDex = ... mov rFP, r1 @ fp = newFp - str rFP, [r2, #offThread_curFrame] @ self->curFrame = newFp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = newFp #if defined(TEMPLATE_INLINE_PROFILING) stmfd sp!, {r0-r2,lr} @ preserve clobbered live registers mov r1, r6 - @ r0=methodToCall, r1=rGlue + @ r0=methodToCall, r1=rSELF mov lr, pc ldr pc, .LdvmFastMethodTraceEnter ldmfd sp!, {r0-r2,lr} @ restore registers @@ -1470,7 +1455,7 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_PREDICTED_CHAIN_PROF: ldr r3, [r0, #offObject_clazz] @ r3 <- this->class ldr r8, [r2, #4] @ r8 <- predictedChainCell->clazz ldr r0, [r2, #8] @ r0 <- predictedChainCell->method - ldr r9, [rGLUE, #offGlue_icRechainCount] @ r1 <- shared rechainCount + ldr r9, [rSELF, #offThread_icRechainCount] @ r1 <- shared rechainCount cmp r3, r8 @ predicted class == actual class? #if defined(WITH_JIT_TUNING) ldr r7, .LdvmICHitCount @@ -1492,7 +1477,7 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_PREDICTED_CHAIN_PROF: cmp r8, #0 @ initialized class or not moveq r1, #0 subne r1, r9, #1 @ count-- - strne r1, [rGLUE, #offGlue_icRechainCount] @ write back to InterpState + strne r1, [rSELF, #offThread_icRechainCount] @ write back to thread add lr, lr, #4 @ return to fully-resolve landing pad /* * r1 <- count @@ -1514,13 +1499,12 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE_PROF: /* File: armv5te/TEMPLATE_INVOKE_METHOD_NATIVE.S */ @ r0 = methodToCall, r1 = returnCell, rPC = dalvikCallsite @ r7 = methodToCall->registersSize - ldr r9, [rGLUE, #offGlue_interpStackEnd] @ r9<- interpStackEnd - ldr r8, [rGLUE, #offGlue_pSelfSuspendCount] @ r8<- &suspendCount + ldr r9, [rSELF, #offThread_interpStackEnd] @ r9<- interpStackEnd + ldr r8, [rSELF, #offThread_suspendCount] @ r8<- suspendCount add r3, r1, #1 @ Thumb addr is odd SAVEAREA_FROM_FP(r1, rFP) @ r1<- stack save area sub r1, r1, r7, lsl #2 @ r1<- newFp (old savearea - regsSize) SAVEAREA_FROM_FP(r10, r1) @ r10<- stack save area - ldr r8, [r8] @ r3<- suspendCount (int) cmp r10, r9 @ bottom < interpStackEnd? bxlo lr @ return to raise stack overflow excep. @ r1 = newFP, r0 = methodToCall, r3 = returnCell, rPC = dalvikCallsite @@ -1530,7 +1514,6 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE_PROF: @ set up newSaveArea str rFP, [r1, #(offStackSaveArea_prevFrame - sizeofStackSaveArea)] str r3, [r1, #(offStackSaveArea_returnAddr - sizeofStackSaveArea)] - ldr r3, [rGLUE, #offGlue_self] @ r3<- glue->self str r0, [r1, #(offStackSaveArea_method - sizeofStackSaveArea)] cmp r8, #0 @ suspendCount != 0 ldr r8, [r0, #offMethod_nativeFunc] @ r8<- method->nativeFunc @@ -1541,25 +1524,25 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE_PROF: #endif @ go ahead and transfer control to the native code - ldr r9, [r3, #offThread_jniLocal_topCookie] @ r9<- thread->localRef->... + ldr r9, [rSELF, #offThread_jniLocal_topCookie]@r9<-thread->localRef->... mov r2, #0 - str r1, [r3, #offThread_curFrame] @ self->curFrame = newFp - str r2, [r3, #offThread_inJitCodeCache] @ not in the jit code cache + str r1, [rSELF, #offThread_curFrame] @ self->curFrame = newFp + str r2, [rSELF, #offThread_inJitCodeCache] @ not in the jit code cache str r9, [r1, #(offStackSaveArea_localRefCookie - sizeofStackSaveArea)] @ newFp->localRefCookie=top - mov r9, r3 @ r9<- glue->self (preserve) SAVEAREA_FROM_FP(r10, r1) @ r10<- new stack save area - mov r2, r0 @ r2<- methodToCall - mov r0, r1 @ r0<- newFP - add r1, rGLUE, #offGlue_retval @ r1<- &retval + mov r2, r0 @ arg2<- methodToCall + mov r0, r1 @ arg0<- newFP + add r1, rSELF, #offThread_retval @ arg1<- &retval + mov r3, rSELF @ arg3<- self #if defined(TEMPLATE_INLINE_PROFILING) - @ r2=methodToCall, r6=rGLUE + @ r2=methodToCall, r6=rSELF stmfd sp!, {r2,r6} @ to be consumed after JNI return stmfd sp!, {r0-r3} @ preserve r0-r3 mov r0, r2 mov r1, r6 - @ r0=JNIMethod, r1=rGlue + @ r0=JNIMethod, r1=rSELF mov lr, pc ldr pc, .LdvmFastMethodTraceEnter ldmfd sp!, {r0-r3} @ restore r0-r3 @@ -1569,24 +1552,24 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE_PROF: #if defined(TEMPLATE_INLINE_PROFILING) ldmfd sp!, {r0-r1} @ restore r2 and r6 - @ r0=JNIMethod, r1=rGlue + @ r0=JNIMethod, r1=rSELF mov lr, pc ldr pc, .LdvmFastNativeMethodTraceExit #endif - @ native return; r9=self, r10=newSaveArea + @ native return; r10=newSaveArea @ equivalent to dvmPopJniLocals ldr r2, [r10, #offStackSaveArea_returnAddr] @ r2 = chaining cell ret ldr r0, [r10, #offStackSaveArea_localRefCookie] @ r0<- saved->top - ldr r1, [r9, #offThread_exception] @ check for exception - str rFP, [r9, #offThread_curFrame] @ self->curFrame = fp + ldr r1, [rSELF, #offThread_exception] @ check for exception + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = fp cmp r1, #0 @ null? - str r0, [r9, #offThread_jniLocal_topCookie] @ new top <- old top + str r0, [rSELF, #offThread_jniLocal_topCookie] @ new top <- old top ldr r0, [rFP, #(offStackSaveArea_currentPc - sizeofStackSaveArea)] @ r0 = dalvikCallsitePC bne .LhandleException @ no, handle exception - str r2, [r9, #offThread_inJitCodeCache] @ set the mode properly + str r2, [rSELF, #offThread_inJitCodeCache] @ set the mode properly cmp r2, #0 @ return chaining cell still exists? bxne r2 @ yes - go ahead @@ -1613,24 +1596,23 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE_PROF: .LinvokeNative: @ Prep for the native call @ r1 = newFP, r0 = methodToCall - ldr r3, [rGLUE, #offGlue_self] @ r3<- glue->self mov r2, #0 - ldr r9, [r3, #offThread_jniLocal_topCookie] @ r9<- thread->localRef->... - str r2, [r3, #offThread_inJitCodeCache] @ not in jit code cache - str r1, [r3, #offThread_curFrame] @ self->curFrame = newFp + ldr r9, [rSELF, #offThread_jniLocal_topCookie]@r9<-thread->localRef->... + str r2, [rSELF, #offThread_inJitCodeCache] @ not in jit code cache + str r1, [rSELF, #offThread_curFrame] @ self->curFrame = newFp str r9, [r1, #(offStackSaveArea_localRefCookie - sizeofStackSaveArea)] @ newFp->localRefCookie=top - mov r9, r3 @ r9<- glue->self (preserve) - ldr lr, [rGLUE, #offGlue_pInterpBreak] + ldr lr, [rSELF, #offThread_pInterpBreak] SAVEAREA_FROM_FP(r10, r1) @ r10<- new stack save area mov r2, r0 @ r2<- methodToCall ldr lr, [lr] @ lr<- set of active profilers mov r0, r1 @ r0<- newFP - add r1, rGLUE, #offGlue_retval @ r1<- &retval + add r1, rSELF, #offThread_retval @ r1<- &retval + mov r3, rSELF @ arg3<- self ands lr, #kSubModeMethodTrace beq 121f @ hop if not profiling - @ r2: methodToCall, r6: rGLUE + @ r2: methodToCall, r6: rSELF stmfd sp!, {r2,r6} stmfd sp!, {r0-r3} mov r0, r2 @@ -1651,24 +1633,24 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE_PROF: ldr pc, [r2, #offMethod_nativeFunc] 212: @ Refresh Jit's on/off status - ldr r3, [rGLUE, #offGlue_ppJitProfTable] + ldr r3, [rSELF, #offThread_ppJitProfTable] - @ native return; r9=self, r10=newSaveArea + @ native return; r10=newSaveArea @ equivalent to dvmPopJniLocals ldr r2, [r10, #offStackSaveArea_returnAddr] @ r2 = chaining cell ret ldr r0, [r10, #offStackSaveArea_localRefCookie] @ r0<- saved->top - ldr r1, [r9, #offThread_exception] @ check for exception + ldr r1, [rSELF, #offThread_exception] @ check for exception ldr r3, [r3] @ r1 <- pointer to Jit profile table - str rFP, [r9, #offThread_curFrame] @ self->curFrame = fp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = fp cmp r1, #0 @ null? - str r0, [r9, #offThread_jniLocal_topCookie] @ new top <- old top + str r0, [rSELF, #offThread_jniLocal_topCookie] @ new top <- old top + str r3, [rSELF, #offThread_pJitProfTable] @ cache current JitProfTable ldr r0, [r10, #offStackSaveArea_savedPc] @ reload rPC - str r3, [rGLUE, #offGlue_pJitProfTable] @ cache current JitProfTable @ r0 = dalvikCallsitePC bne .LhandleException @ no, handle exception - str r2, [r9, #offThread_inJitCodeCache] @ set the new mode + str r2, [rSELF, #offThread_inJitCodeCache] @ set the new mode cmp r2, #0 @ return chaining cell still exists? bxne r2 @ yes - go ahead @@ -1690,9 +1672,8 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE_PROF: .LdeadFood: .word 0xdeadf00d #endif - ldr r3, [rGLUE, #offGlue_self] @ r3<- glue->self mov r2, #0 - str r2, [r3, #offThread_inJitCodeCache] @ in interpreter land + str r2, [rSELF, #offThread_inJitCodeCache] @ in interpreter land ldr r1, .LdvmMterpCommonExceptionThrown @ PIC way of getting &func ldr rIBASE, .LdvmAsmInstructionStart @ same as above mov rPC, r0 @ reload the faulting Dalvik address diff --git a/vm/compiler/template/out/CompilerTemplateAsm-armv7-a-neon.S b/vm/compiler/template/out/CompilerTemplateAsm-armv7-a-neon.S index 5f8e8087a..fb1e04833 100644 --- a/vm/compiler/template/out/CompilerTemplateAsm-armv7-a-neon.S +++ b/vm/compiler/template/out/CompilerTemplateAsm-armv7-a-neon.S @@ -62,7 +62,7 @@ The following registers have fixed assignments: reg nick purpose r5 rFP interpreted frame pointer, used for accessing locals and args - r6 rGLUE MterpGlue pointer + r6 rSELF thread pointer The following registers have fixed assignments in mterp but are scratch registers in compiled code @@ -80,7 +80,7 @@ unspecified registers or condition codes. /* single-purpose registers, given names for clarity */ #define rPC r4 #define rFP r5 -#define rGLUE r6 +#define rSELF r6 #define rINST r7 #define rIBASE r8 @@ -169,14 +169,14 @@ dvmCompiler_TEMPLATE_RETURN: #if defined(TEMPLATE_INLINE_PROFILING) stmfd sp!, {r0-r2,lr} @ preserve live registers mov r0, r6 - @ r0=rGlue + @ r0=rSELF mov lr, pc ldr pc, .LdvmFastJavaMethodTraceExit ldmfd sp!, {r0-r2,lr} @ restore live registers #endif SAVEAREA_FROM_FP(r0, rFP) @ r0<- saveArea (old) ldr r10, [r0, #offStackSaveArea_prevFrame] @ r10<- saveArea->prevFrame - ldr r8, [rGLUE, #offGlue_pSelfSuspendCount] @ r8<- &suspendCount + ldr r8, [rSELF, #offThread_suspendCount] @ r8<- suspendCount ldr rPC, [r0, #offStackSaveArea_savedPc] @ rPC<- saveArea->savedPc #if !defined(WITH_SELF_VERIFICATION) ldr r9, [r0, #offStackSaveArea_returnAddr] @ r9<- chaining cell ret @@ -185,7 +185,6 @@ dvmCompiler_TEMPLATE_RETURN: #endif ldr r2, [r10, #(offStackSaveArea_method - sizeofStackSaveArea)] @ r2<- method we're returning to - ldr r3, [rGLUE, #offGlue_self] @ r3<- glue->self cmp r2, #0 @ break frame? #if !defined(WITH_SELF_VERIFICATION) beq 1f @ bail to interpreter @@ -195,16 +194,15 @@ dvmCompiler_TEMPLATE_RETURN: ldr r1, .LdvmJitToInterpNoChainNoProfile @ defined in footer.S mov rFP, r10 @ publish new FP ldr r10, [r2, #offMethod_clazz] @ r10<- method->clazz - ldr r8, [r8] @ r8<- suspendCount - str r2, [rGLUE, #offGlue_method]@ glue->method = newSave->method + str r2, [rSELF, #offThread_method]@ self->method = newSave->method ldr r0, [r10, #offClassObject_pDvmDex] @ r0<- method->clazz->pDvmDex - str rFP, [r3, #offThread_curFrame] @ self->curFrame = fp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = fp add rPC, rPC, #6 @ publish new rPC (advance 6 bytes) - str r0, [rGLUE, #offGlue_methodClassDex] + str r0, [rSELF, #offThread_methodClassDex] cmp r8, #0 @ check the suspendCount movne r9, #0 @ clear the chaining cell address - str r9, [r3, #offThread_inJitCodeCache] @ in code cache or not + str r9, [rSELF, #offThread_inJitCodeCache] @ in code cache or not cmp r9, #0 @ chaining cell exists? blxne r9 @ jump to the chaining cell #if defined(WITH_JIT_TUNING) @@ -212,10 +210,10 @@ dvmCompiler_TEMPLATE_RETURN: #endif mov pc, r1 @ callsite is interpreted 1: - stmia rGLUE, {rPC, rFP} @ SAVE_PC_FP_TO_GLUE() + stmia rSELF, {rPC, rFP} @ SAVE_PC_FP_TO_SELF() ldr r2, .LdvmMterpStdBail @ defined in footer.S mov r1, #0 @ changeInterp = false - mov r0, rGLUE @ Expecting rGLUE in r0 + mov r0, rSELF @ Expecting rSELF in r0 blx r2 @ exit the interpreter /* ------------------------------ */ @@ -231,14 +229,13 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NO_OPT: @ r0 = methodToCall, r1 = returnCell, rPC = dalvikCallsite ldrh r7, [r0, #offMethod_registersSize] @ r7<- methodToCall->regsSize ldrh r2, [r0, #offMethod_outsSize] @ r2<- methodToCall->outsSize - ldr r9, [rGLUE, #offGlue_interpStackEnd] @ r9<- interpStackEnd - ldr r8, [rGLUE, #offGlue_pSelfSuspendCount] @ r8<- &suspendCount + ldr r9, [rSELF, #offThread_interpStackEnd] @ r9<- interpStackEnd + ldr r8, [rSELF, #offThread_suspendCount] @ r8<- suspendCount add r3, r1, #1 @ Thumb addr is odd SAVEAREA_FROM_FP(r1, rFP) @ r1<- stack save area sub r1, r1, r7, lsl #2 @ r1<- newFp (old savearea - regsSize) SAVEAREA_FROM_FP(r10, r1) @ r10<- stack save area sub r10, r10, r2, lsl #2 @ r10<- bottom (newsave - outsSize) - ldr r8, [r8] @ r8<- suspendCount (int) cmp r10, r9 @ bottom < interpStackEnd? bxlo lr @ return to raise stack overflow excep. @ r1 = newFP, r0 = methodToCall, r3 = returnCell, rPC = dalvikCallsite @@ -264,17 +261,16 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NO_OPT: ldr r10, .LdvmJitToInterpTraceSelectNoChain ldr r3, [r9, #offClassObject_pDvmDex] @ r3<- method->clazz->pDvmDex - ldr r2, [rGLUE, #offGlue_self] @ r2<- glue->self - @ Update "glue" values for the new method - str r0, [rGLUE, #offGlue_method] @ glue->method = methodToCall - str r3, [rGLUE, #offGlue_methodClassDex] @ glue->methodClassDex = ... + @ Update "thread" values for the new method + str r0, [rSELF, #offThread_method] @ self->method = methodToCall + str r3, [rSELF, #offThread_methodClassDex] @ self->methodClassDex = ... mov rFP, r1 @ fp = newFp - str rFP, [r2, #offThread_curFrame] @ self->curFrame = newFp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = newFp #if defined(TEMPLATE_INLINE_PROFILING) stmfd sp!, {r0-r3} @ preserve r0-r3 mov r1, r6 - @ r0=methodToCall, r1=rGlue + @ r0=methodToCall, r1=rSELF mov lr, pc ldr pc, .LdvmFastMethodTraceEnter ldmfd sp!, {r0-r3} @ restore r0-r3 @@ -300,15 +296,14 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_CHAIN: @ rPC = dalvikCallsite, r7 = methodToCall->registersSize @ methodToCall is guaranteed to be non-native .LinvokeChain: - ldr r9, [rGLUE, #offGlue_interpStackEnd] @ r9<- interpStackEnd - ldr r8, [rGLUE, #offGlue_pSelfSuspendCount] @ r8<- &suspendCount + ldr r9, [rSELF, #offThread_interpStackEnd] @ r9<- interpStackEnd + ldr r8, [rSELF, #offThread_suspendCount] @ r8<- suspendCount add r3, r1, #1 @ Thumb addr is odd SAVEAREA_FROM_FP(r1, rFP) @ r1<- stack save area sub r1, r1, r7, lsl #2 @ r1<- newFp (old savearea - regsSize) SAVEAREA_FROM_FP(r10, r1) @ r10<- stack save area add r12, lr, #2 @ setup the punt-to-interp address sub r10, r10, r2, lsl #2 @ r10<- bottom (newsave - outsSize) - ldr r8, [r8] @ r8<- suspendCount (int) cmp r10, r9 @ bottom < interpStackEnd? bxlo r12 @ return to raise stack overflow excep. @ r1 = newFP, r0 = methodToCall, r3 = returnCell, rPC = dalvikCallsite @@ -324,17 +319,16 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_CHAIN: bxne r12 @ bail to the interpreter ldr r3, [r9, #offClassObject_pDvmDex] @ r3<- method->clazz->pDvmDex - ldr r2, [rGLUE, #offGlue_self] @ r2<- glue->self - @ Update "glue" values for the new method - str r0, [rGLUE, #offGlue_method] @ glue->method = methodToCall - str r3, [rGLUE, #offGlue_methodClassDex] @ glue->methodClassDex = ... + @ Update "thread" values for the new method + str r0, [rSELF, #offThread_method] @ self->method = methodToCall + str r3, [rSELF, #offThread_methodClassDex] @ self->methodClassDex = ... mov rFP, r1 @ fp = newFp - str rFP, [r2, #offThread_curFrame] @ self->curFrame = newFp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = newFp #if defined(TEMPLATE_INLINE_PROFILING) stmfd sp!, {r0-r2,lr} @ preserve clobbered live registers mov r1, r6 - @ r0=methodToCall, r1=rGlue + @ r0=methodToCall, r1=rSELF mov lr, pc ldr pc, .LdvmFastMethodTraceEnter ldmfd sp!, {r0-r2,lr} @ restore registers @@ -374,7 +368,7 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_PREDICTED_CHAIN: ldr r3, [r0, #offObject_clazz] @ r3 <- this->class ldr r8, [r2, #4] @ r8 <- predictedChainCell->clazz ldr r0, [r2, #8] @ r0 <- predictedChainCell->method - ldr r9, [rGLUE, #offGlue_icRechainCount] @ r1 <- shared rechainCount + ldr r9, [rSELF, #offThread_icRechainCount] @ r1 <- shared rechainCount cmp r3, r8 @ predicted class == actual class? #if defined(WITH_JIT_TUNING) ldr r7, .LdvmICHitCount @@ -396,7 +390,7 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_PREDICTED_CHAIN: cmp r8, #0 @ initialized class or not moveq r1, #0 subne r1, r9, #1 @ count-- - strne r1, [rGLUE, #offGlue_icRechainCount] @ write back to InterpState + strne r1, [rSELF, #offThread_icRechainCount] @ write back to thread add lr, lr, #4 @ return to fully-resolve landing pad /* * r1 <- count @@ -414,13 +408,12 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE: /* File: armv5te/TEMPLATE_INVOKE_METHOD_NATIVE.S */ @ r0 = methodToCall, r1 = returnCell, rPC = dalvikCallsite @ r7 = methodToCall->registersSize - ldr r9, [rGLUE, #offGlue_interpStackEnd] @ r9<- interpStackEnd - ldr r8, [rGLUE, #offGlue_pSelfSuspendCount] @ r8<- &suspendCount + ldr r9, [rSELF, #offThread_interpStackEnd] @ r9<- interpStackEnd + ldr r8, [rSELF, #offThread_suspendCount] @ r8<- suspendCount add r3, r1, #1 @ Thumb addr is odd SAVEAREA_FROM_FP(r1, rFP) @ r1<- stack save area sub r1, r1, r7, lsl #2 @ r1<- newFp (old savearea - regsSize) SAVEAREA_FROM_FP(r10, r1) @ r10<- stack save area - ldr r8, [r8] @ r3<- suspendCount (int) cmp r10, r9 @ bottom < interpStackEnd? bxlo lr @ return to raise stack overflow excep. @ r1 = newFP, r0 = methodToCall, r3 = returnCell, rPC = dalvikCallsite @@ -430,7 +423,6 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE: @ set up newSaveArea str rFP, [r1, #(offStackSaveArea_prevFrame - sizeofStackSaveArea)] str r3, [r1, #(offStackSaveArea_returnAddr - sizeofStackSaveArea)] - ldr r3, [rGLUE, #offGlue_self] @ r3<- glue->self str r0, [r1, #(offStackSaveArea_method - sizeofStackSaveArea)] cmp r8, #0 @ suspendCount != 0 ldr r8, [r0, #offMethod_nativeFunc] @ r8<- method->nativeFunc @@ -441,25 +433,25 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE: #endif @ go ahead and transfer control to the native code - ldr r9, [r3, #offThread_jniLocal_topCookie] @ r9<- thread->localRef->... + ldr r9, [rSELF, #offThread_jniLocal_topCookie]@r9<-thread->localRef->... mov r2, #0 - str r1, [r3, #offThread_curFrame] @ self->curFrame = newFp - str r2, [r3, #offThread_inJitCodeCache] @ not in the jit code cache + str r1, [rSELF, #offThread_curFrame] @ self->curFrame = newFp + str r2, [rSELF, #offThread_inJitCodeCache] @ not in the jit code cache str r9, [r1, #(offStackSaveArea_localRefCookie - sizeofStackSaveArea)] @ newFp->localRefCookie=top - mov r9, r3 @ r9<- glue->self (preserve) SAVEAREA_FROM_FP(r10, r1) @ r10<- new stack save area - mov r2, r0 @ r2<- methodToCall - mov r0, r1 @ r0<- newFP - add r1, rGLUE, #offGlue_retval @ r1<- &retval + mov r2, r0 @ arg2<- methodToCall + mov r0, r1 @ arg0<- newFP + add r1, rSELF, #offThread_retval @ arg1<- &retval + mov r3, rSELF @ arg3<- self #if defined(TEMPLATE_INLINE_PROFILING) - @ r2=methodToCall, r6=rGLUE + @ r2=methodToCall, r6=rSELF stmfd sp!, {r2,r6} @ to be consumed after JNI return stmfd sp!, {r0-r3} @ preserve r0-r3 mov r0, r2 mov r1, r6 - @ r0=JNIMethod, r1=rGlue + @ r0=JNIMethod, r1=rSELF mov lr, pc ldr pc, .LdvmFastMethodTraceEnter ldmfd sp!, {r0-r3} @ restore r0-r3 @@ -469,24 +461,24 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE: #if defined(TEMPLATE_INLINE_PROFILING) ldmfd sp!, {r0-r1} @ restore r2 and r6 - @ r0=JNIMethod, r1=rGlue + @ r0=JNIMethod, r1=rSELF mov lr, pc ldr pc, .LdvmFastNativeMethodTraceExit #endif - @ native return; r9=self, r10=newSaveArea + @ native return; r10=newSaveArea @ equivalent to dvmPopJniLocals ldr r2, [r10, #offStackSaveArea_returnAddr] @ r2 = chaining cell ret ldr r0, [r10, #offStackSaveArea_localRefCookie] @ r0<- saved->top - ldr r1, [r9, #offThread_exception] @ check for exception - str rFP, [r9, #offThread_curFrame] @ self->curFrame = fp + ldr r1, [rSELF, #offThread_exception] @ check for exception + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = fp cmp r1, #0 @ null? - str r0, [r9, #offThread_jniLocal_topCookie] @ new top <- old top + str r0, [rSELF, #offThread_jniLocal_topCookie] @ new top <- old top ldr r0, [rFP, #(offStackSaveArea_currentPc - sizeofStackSaveArea)] @ r0 = dalvikCallsitePC bne .LhandleException @ no, handle exception - str r2, [r9, #offThread_inJitCodeCache] @ set the mode properly + str r2, [rSELF, #offThread_inJitCodeCache] @ set the mode properly cmp r2, #0 @ return chaining cell still exists? bxne r2 @ yes - go ahead @@ -1384,7 +1376,7 @@ dvmCompiler_TEMPLATE_INTERPRET: * r1 - the Dalvik PC to begin interpretation. * else * [lr, #3] contains Dalvik PC to begin interpretation - * rGLUE - pointer to interpState + * rSELF - pointer to thread * rFP - Dalvik frame pointer */ cmp lr, #0 @@ -1425,10 +1417,10 @@ dvmCompiler_TEMPLATE_MONITOR_ENTER: str r3, [r0, #offThread_inJitCodeCache] blx r2 @ dvmLockObject(self, obj) @ refresh Jit's on/off status - ldr r0, [rGLUE, #offGlue_ppJitProfTable] - ldr r0, [r0] + ldr r3, [rSELF, #offThread_ppJitProfTable] + ldr r3, [r3] ldr r2, .LdvmJitToInterpNoChain - str r0, [rGLUE, #offGlue_pJitProfTable] + str r3, [rSELF, #offThread_pJitProfTable] @ Bail to interpreter - no chain [note - r4 still contains rPC] #if defined(WITH_JIT_TUNING) mov r0, #kHeavyweightMonitor @@ -1456,11 +1448,10 @@ dvmCompiler_TEMPLATE_MONITOR_ENTER_DEBUG: str r3, [r0, #offThread_inJitCodeCache] blx r2 @ dvmLockObject(self, obj) @ refresh Jit's on/off status & test for exception - ldr r0, [rGLUE, #offGlue_ppJitProfTable] - ldr r1, [rGLUE, #offGlue_self] - ldr r0, [r0] - ldr r1, [r1, #offThread_exception] - str r0, [rGLUE, #offGlue_pJitProfTable] + ldr r3, [rSELF, #offThread_ppJitProfTable] + ldr r3, [r3] + ldr r1, [rSELF, #offThread_exception] + str r3, [rSELF, #offThread_pJitProfTable] cmp r1, #0 beq 1f ldr r2, .LhandleException @@ -1489,7 +1480,7 @@ dvmCompiler_TEMPLATE_PERIODIC_PROFILING: * we are arriving from thumb mode, lr will have its low bit set. */ ldr r0, [lr,#-11] - ldr r1, [rGLUE, #offGlue_pProfileCountdown] + ldr r1, [rSELF, #offThread_pProfileCountdown] ldr r2, [r0] @ get counter ldr r3, [r1] @ get countdown timer add r2, #1 @@ -1522,14 +1513,14 @@ dvmCompiler_TEMPLATE_RETURN_PROF: #if defined(TEMPLATE_INLINE_PROFILING) stmfd sp!, {r0-r2,lr} @ preserve live registers mov r0, r6 - @ r0=rGlue + @ r0=rSELF mov lr, pc ldr pc, .LdvmFastJavaMethodTraceExit ldmfd sp!, {r0-r2,lr} @ restore live registers #endif SAVEAREA_FROM_FP(r0, rFP) @ r0<- saveArea (old) ldr r10, [r0, #offStackSaveArea_prevFrame] @ r10<- saveArea->prevFrame - ldr r8, [rGLUE, #offGlue_pSelfSuspendCount] @ r8<- &suspendCount + ldr r8, [rSELF, #offThread_suspendCount] @ r8<- suspendCount ldr rPC, [r0, #offStackSaveArea_savedPc] @ rPC<- saveArea->savedPc #if !defined(WITH_SELF_VERIFICATION) ldr r9, [r0, #offStackSaveArea_returnAddr] @ r9<- chaining cell ret @@ -1538,7 +1529,6 @@ dvmCompiler_TEMPLATE_RETURN_PROF: #endif ldr r2, [r10, #(offStackSaveArea_method - sizeofStackSaveArea)] @ r2<- method we're returning to - ldr r3, [rGLUE, #offGlue_self] @ r3<- glue->self cmp r2, #0 @ break frame? #if !defined(WITH_SELF_VERIFICATION) beq 1f @ bail to interpreter @@ -1548,16 +1538,15 @@ dvmCompiler_TEMPLATE_RETURN_PROF: ldr r1, .LdvmJitToInterpNoChainNoProfile @ defined in footer.S mov rFP, r10 @ publish new FP ldr r10, [r2, #offMethod_clazz] @ r10<- method->clazz - ldr r8, [r8] @ r8<- suspendCount - str r2, [rGLUE, #offGlue_method]@ glue->method = newSave->method + str r2, [rSELF, #offThread_method]@ self->method = newSave->method ldr r0, [r10, #offClassObject_pDvmDex] @ r0<- method->clazz->pDvmDex - str rFP, [r3, #offThread_curFrame] @ self->curFrame = fp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = fp add rPC, rPC, #6 @ publish new rPC (advance 6 bytes) - str r0, [rGLUE, #offGlue_methodClassDex] + str r0, [rSELF, #offThread_methodClassDex] cmp r8, #0 @ check the suspendCount movne r9, #0 @ clear the chaining cell address - str r9, [r3, #offThread_inJitCodeCache] @ in code cache or not + str r9, [rSELF, #offThread_inJitCodeCache] @ in code cache or not cmp r9, #0 @ chaining cell exists? blxne r9 @ jump to the chaining cell #if defined(WITH_JIT_TUNING) @@ -1565,10 +1554,10 @@ dvmCompiler_TEMPLATE_RETURN_PROF: #endif mov pc, r1 @ callsite is interpreted 1: - stmia rGLUE, {rPC, rFP} @ SAVE_PC_FP_TO_GLUE() + stmia rSELF, {rPC, rFP} @ SAVE_PC_FP_TO_SELF() ldr r2, .LdvmMterpStdBail @ defined in footer.S mov r1, #0 @ changeInterp = false - mov r0, rGLUE @ Expecting rGLUE in r0 + mov r0, rSELF @ Expecting rSELF in r0 blx r2 @ exit the interpreter #undef TEMPLATE_INLINE_PROFILING @@ -1588,14 +1577,13 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NO_OPT_PROF: @ r0 = methodToCall, r1 = returnCell, rPC = dalvikCallsite ldrh r7, [r0, #offMethod_registersSize] @ r7<- methodToCall->regsSize ldrh r2, [r0, #offMethod_outsSize] @ r2<- methodToCall->outsSize - ldr r9, [rGLUE, #offGlue_interpStackEnd] @ r9<- interpStackEnd - ldr r8, [rGLUE, #offGlue_pSelfSuspendCount] @ r8<- &suspendCount + ldr r9, [rSELF, #offThread_interpStackEnd] @ r9<- interpStackEnd + ldr r8, [rSELF, #offThread_suspendCount] @ r8<- suspendCount add r3, r1, #1 @ Thumb addr is odd SAVEAREA_FROM_FP(r1, rFP) @ r1<- stack save area sub r1, r1, r7, lsl #2 @ r1<- newFp (old savearea - regsSize) SAVEAREA_FROM_FP(r10, r1) @ r10<- stack save area sub r10, r10, r2, lsl #2 @ r10<- bottom (newsave - outsSize) - ldr r8, [r8] @ r8<- suspendCount (int) cmp r10, r9 @ bottom < interpStackEnd? bxlo lr @ return to raise stack overflow excep. @ r1 = newFP, r0 = methodToCall, r3 = returnCell, rPC = dalvikCallsite @@ -1621,17 +1609,16 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NO_OPT_PROF: ldr r10, .LdvmJitToInterpTraceSelectNoChain ldr r3, [r9, #offClassObject_pDvmDex] @ r3<- method->clazz->pDvmDex - ldr r2, [rGLUE, #offGlue_self] @ r2<- glue->self - @ Update "glue" values for the new method - str r0, [rGLUE, #offGlue_method] @ glue->method = methodToCall - str r3, [rGLUE, #offGlue_methodClassDex] @ glue->methodClassDex = ... + @ Update "thread" values for the new method + str r0, [rSELF, #offThread_method] @ self->method = methodToCall + str r3, [rSELF, #offThread_methodClassDex] @ self->methodClassDex = ... mov rFP, r1 @ fp = newFp - str rFP, [r2, #offThread_curFrame] @ self->curFrame = newFp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = newFp #if defined(TEMPLATE_INLINE_PROFILING) stmfd sp!, {r0-r3} @ preserve r0-r3 mov r1, r6 - @ r0=methodToCall, r1=rGlue + @ r0=methodToCall, r1=rSELF mov lr, pc ldr pc, .LdvmFastMethodTraceEnter ldmfd sp!, {r0-r3} @ restore r0-r3 @@ -1661,15 +1648,14 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_CHAIN_PROF: @ rPC = dalvikCallsite, r7 = methodToCall->registersSize @ methodToCall is guaranteed to be non-native .LinvokeChainProf: - ldr r9, [rGLUE, #offGlue_interpStackEnd] @ r9<- interpStackEnd - ldr r8, [rGLUE, #offGlue_pSelfSuspendCount] @ r8<- &suspendCount + ldr r9, [rSELF, #offThread_interpStackEnd] @ r9<- interpStackEnd + ldr r8, [rSELF, #offThread_suspendCount] @ r8<- suspendCount add r3, r1, #1 @ Thumb addr is odd SAVEAREA_FROM_FP(r1, rFP) @ r1<- stack save area sub r1, r1, r7, lsl #2 @ r1<- newFp (old savearea - regsSize) SAVEAREA_FROM_FP(r10, r1) @ r10<- stack save area add r12, lr, #2 @ setup the punt-to-interp address sub r10, r10, r2, lsl #2 @ r10<- bottom (newsave - outsSize) - ldr r8, [r8] @ r8<- suspendCount (int) cmp r10, r9 @ bottom < interpStackEnd? bxlo r12 @ return to raise stack overflow excep. @ r1 = newFP, r0 = methodToCall, r3 = returnCell, rPC = dalvikCallsite @@ -1685,17 +1671,16 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_CHAIN_PROF: bxne r12 @ bail to the interpreter ldr r3, [r9, #offClassObject_pDvmDex] @ r3<- method->clazz->pDvmDex - ldr r2, [rGLUE, #offGlue_self] @ r2<- glue->self - @ Update "glue" values for the new method - str r0, [rGLUE, #offGlue_method] @ glue->method = methodToCall - str r3, [rGLUE, #offGlue_methodClassDex] @ glue->methodClassDex = ... + @ Update "thread" values for the new method + str r0, [rSELF, #offThread_method] @ self->method = methodToCall + str r3, [rSELF, #offThread_methodClassDex] @ self->methodClassDex = ... mov rFP, r1 @ fp = newFp - str rFP, [r2, #offThread_curFrame] @ self->curFrame = newFp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = newFp #if defined(TEMPLATE_INLINE_PROFILING) stmfd sp!, {r0-r2,lr} @ preserve clobbered live registers mov r1, r6 - @ r0=methodToCall, r1=rGlue + @ r0=methodToCall, r1=rSELF mov lr, pc ldr pc, .LdvmFastMethodTraceEnter ldmfd sp!, {r0-r2,lr} @ restore registers @@ -1739,7 +1724,7 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_PREDICTED_CHAIN_PROF: ldr r3, [r0, #offObject_clazz] @ r3 <- this->class ldr r8, [r2, #4] @ r8 <- predictedChainCell->clazz ldr r0, [r2, #8] @ r0 <- predictedChainCell->method - ldr r9, [rGLUE, #offGlue_icRechainCount] @ r1 <- shared rechainCount + ldr r9, [rSELF, #offThread_icRechainCount] @ r1 <- shared rechainCount cmp r3, r8 @ predicted class == actual class? #if defined(WITH_JIT_TUNING) ldr r7, .LdvmICHitCount @@ -1761,7 +1746,7 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_PREDICTED_CHAIN_PROF: cmp r8, #0 @ initialized class or not moveq r1, #0 subne r1, r9, #1 @ count-- - strne r1, [rGLUE, #offGlue_icRechainCount] @ write back to InterpState + strne r1, [rSELF, #offThread_icRechainCount] @ write back to thread add lr, lr, #4 @ return to fully-resolve landing pad /* * r1 <- count @@ -1783,13 +1768,12 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE_PROF: /* File: armv5te/TEMPLATE_INVOKE_METHOD_NATIVE.S */ @ r0 = methodToCall, r1 = returnCell, rPC = dalvikCallsite @ r7 = methodToCall->registersSize - ldr r9, [rGLUE, #offGlue_interpStackEnd] @ r9<- interpStackEnd - ldr r8, [rGLUE, #offGlue_pSelfSuspendCount] @ r8<- &suspendCount + ldr r9, [rSELF, #offThread_interpStackEnd] @ r9<- interpStackEnd + ldr r8, [rSELF, #offThread_suspendCount] @ r8<- suspendCount add r3, r1, #1 @ Thumb addr is odd SAVEAREA_FROM_FP(r1, rFP) @ r1<- stack save area sub r1, r1, r7, lsl #2 @ r1<- newFp (old savearea - regsSize) SAVEAREA_FROM_FP(r10, r1) @ r10<- stack save area - ldr r8, [r8] @ r3<- suspendCount (int) cmp r10, r9 @ bottom < interpStackEnd? bxlo lr @ return to raise stack overflow excep. @ r1 = newFP, r0 = methodToCall, r3 = returnCell, rPC = dalvikCallsite @@ -1799,7 +1783,6 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE_PROF: @ set up newSaveArea str rFP, [r1, #(offStackSaveArea_prevFrame - sizeofStackSaveArea)] str r3, [r1, #(offStackSaveArea_returnAddr - sizeofStackSaveArea)] - ldr r3, [rGLUE, #offGlue_self] @ r3<- glue->self str r0, [r1, #(offStackSaveArea_method - sizeofStackSaveArea)] cmp r8, #0 @ suspendCount != 0 ldr r8, [r0, #offMethod_nativeFunc] @ r8<- method->nativeFunc @@ -1810,25 +1793,25 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE_PROF: #endif @ go ahead and transfer control to the native code - ldr r9, [r3, #offThread_jniLocal_topCookie] @ r9<- thread->localRef->... + ldr r9, [rSELF, #offThread_jniLocal_topCookie]@r9<-thread->localRef->... mov r2, #0 - str r1, [r3, #offThread_curFrame] @ self->curFrame = newFp - str r2, [r3, #offThread_inJitCodeCache] @ not in the jit code cache + str r1, [rSELF, #offThread_curFrame] @ self->curFrame = newFp + str r2, [rSELF, #offThread_inJitCodeCache] @ not in the jit code cache str r9, [r1, #(offStackSaveArea_localRefCookie - sizeofStackSaveArea)] @ newFp->localRefCookie=top - mov r9, r3 @ r9<- glue->self (preserve) SAVEAREA_FROM_FP(r10, r1) @ r10<- new stack save area - mov r2, r0 @ r2<- methodToCall - mov r0, r1 @ r0<- newFP - add r1, rGLUE, #offGlue_retval @ r1<- &retval + mov r2, r0 @ arg2<- methodToCall + mov r0, r1 @ arg0<- newFP + add r1, rSELF, #offThread_retval @ arg1<- &retval + mov r3, rSELF @ arg3<- self #if defined(TEMPLATE_INLINE_PROFILING) - @ r2=methodToCall, r6=rGLUE + @ r2=methodToCall, r6=rSELF stmfd sp!, {r2,r6} @ to be consumed after JNI return stmfd sp!, {r0-r3} @ preserve r0-r3 mov r0, r2 mov r1, r6 - @ r0=JNIMethod, r1=rGlue + @ r0=JNIMethod, r1=rSELF mov lr, pc ldr pc, .LdvmFastMethodTraceEnter ldmfd sp!, {r0-r3} @ restore r0-r3 @@ -1838,24 +1821,24 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE_PROF: #if defined(TEMPLATE_INLINE_PROFILING) ldmfd sp!, {r0-r1} @ restore r2 and r6 - @ r0=JNIMethod, r1=rGlue + @ r0=JNIMethod, r1=rSELF mov lr, pc ldr pc, .LdvmFastNativeMethodTraceExit #endif - @ native return; r9=self, r10=newSaveArea + @ native return; r10=newSaveArea @ equivalent to dvmPopJniLocals ldr r2, [r10, #offStackSaveArea_returnAddr] @ r2 = chaining cell ret ldr r0, [r10, #offStackSaveArea_localRefCookie] @ r0<- saved->top - ldr r1, [r9, #offThread_exception] @ check for exception - str rFP, [r9, #offThread_curFrame] @ self->curFrame = fp + ldr r1, [rSELF, #offThread_exception] @ check for exception + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = fp cmp r1, #0 @ null? - str r0, [r9, #offThread_jniLocal_topCookie] @ new top <- old top + str r0, [rSELF, #offThread_jniLocal_topCookie] @ new top <- old top ldr r0, [rFP, #(offStackSaveArea_currentPc - sizeofStackSaveArea)] @ r0 = dalvikCallsitePC bne .LhandleException @ no, handle exception - str r2, [r9, #offThread_inJitCodeCache] @ set the mode properly + str r2, [rSELF, #offThread_inJitCodeCache] @ set the mode properly cmp r2, #0 @ return chaining cell still exists? bxne r2 @ yes - go ahead @@ -1882,24 +1865,23 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE_PROF: .LinvokeNative: @ Prep for the native call @ r1 = newFP, r0 = methodToCall - ldr r3, [rGLUE, #offGlue_self] @ r3<- glue->self mov r2, #0 - ldr r9, [r3, #offThread_jniLocal_topCookie] @ r9<- thread->localRef->... - str r2, [r3, #offThread_inJitCodeCache] @ not in jit code cache - str r1, [r3, #offThread_curFrame] @ self->curFrame = newFp + ldr r9, [rSELF, #offThread_jniLocal_topCookie]@r9<-thread->localRef->... + str r2, [rSELF, #offThread_inJitCodeCache] @ not in jit code cache + str r1, [rSELF, #offThread_curFrame] @ self->curFrame = newFp str r9, [r1, #(offStackSaveArea_localRefCookie - sizeofStackSaveArea)] @ newFp->localRefCookie=top - mov r9, r3 @ r9<- glue->self (preserve) - ldr lr, [rGLUE, #offGlue_pInterpBreak] + ldr lr, [rSELF, #offThread_pInterpBreak] SAVEAREA_FROM_FP(r10, r1) @ r10<- new stack save area mov r2, r0 @ r2<- methodToCall ldr lr, [lr] @ lr<- set of active profilers mov r0, r1 @ r0<- newFP - add r1, rGLUE, #offGlue_retval @ r1<- &retval + add r1, rSELF, #offThread_retval @ r1<- &retval + mov r3, rSELF @ arg3<- self ands lr, #kSubModeMethodTrace beq 121f @ hop if not profiling - @ r2: methodToCall, r6: rGLUE + @ r2: methodToCall, r6: rSELF stmfd sp!, {r2,r6} stmfd sp!, {r0-r3} mov r0, r2 @@ -1920,24 +1902,24 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE_PROF: ldr pc, [r2, #offMethod_nativeFunc] 212: @ Refresh Jit's on/off status - ldr r3, [rGLUE, #offGlue_ppJitProfTable] + ldr r3, [rSELF, #offThread_ppJitProfTable] - @ native return; r9=self, r10=newSaveArea + @ native return; r10=newSaveArea @ equivalent to dvmPopJniLocals ldr r2, [r10, #offStackSaveArea_returnAddr] @ r2 = chaining cell ret ldr r0, [r10, #offStackSaveArea_localRefCookie] @ r0<- saved->top - ldr r1, [r9, #offThread_exception] @ check for exception + ldr r1, [rSELF, #offThread_exception] @ check for exception ldr r3, [r3] @ r1 <- pointer to Jit profile table - str rFP, [r9, #offThread_curFrame] @ self->curFrame = fp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = fp cmp r1, #0 @ null? - str r0, [r9, #offThread_jniLocal_topCookie] @ new top <- old top + str r0, [rSELF, #offThread_jniLocal_topCookie] @ new top <- old top + str r3, [rSELF, #offThread_pJitProfTable] @ cache current JitProfTable ldr r0, [r10, #offStackSaveArea_savedPc] @ reload rPC - str r3, [rGLUE, #offGlue_pJitProfTable] @ cache current JitProfTable @ r0 = dalvikCallsitePC bne .LhandleException @ no, handle exception - str r2, [r9, #offThread_inJitCodeCache] @ set the new mode + str r2, [rSELF, #offThread_inJitCodeCache] @ set the new mode cmp r2, #0 @ return chaining cell still exists? bxne r2 @ yes - go ahead @@ -1959,9 +1941,8 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE_PROF: .LdeadFood: .word 0xdeadf00d #endif - ldr r3, [rGLUE, #offGlue_self] @ r3<- glue->self mov r2, #0 - str r2, [r3, #offThread_inJitCodeCache] @ in interpreter land + str r2, [rSELF, #offThread_inJitCodeCache] @ in interpreter land ldr r1, .LdvmMterpCommonExceptionThrown @ PIC way of getting &func ldr rIBASE, .LdvmAsmInstructionStart @ same as above mov rPC, r0 @ reload the faulting Dalvik address diff --git a/vm/compiler/template/out/CompilerTemplateAsm-armv7-a.S b/vm/compiler/template/out/CompilerTemplateAsm-armv7-a.S index 0b24631c3..7ea4647b3 100644 --- a/vm/compiler/template/out/CompilerTemplateAsm-armv7-a.S +++ b/vm/compiler/template/out/CompilerTemplateAsm-armv7-a.S @@ -62,7 +62,7 @@ The following registers have fixed assignments: reg nick purpose r5 rFP interpreted frame pointer, used for accessing locals and args - r6 rGLUE MterpGlue pointer + r6 rSELF thread pointer The following registers have fixed assignments in mterp but are scratch registers in compiled code @@ -80,7 +80,7 @@ unspecified registers or condition codes. /* single-purpose registers, given names for clarity */ #define rPC r4 #define rFP r5 -#define rGLUE r6 +#define rSELF r6 #define rINST r7 #define rIBASE r8 @@ -169,14 +169,14 @@ dvmCompiler_TEMPLATE_RETURN: #if defined(TEMPLATE_INLINE_PROFILING) stmfd sp!, {r0-r2,lr} @ preserve live registers mov r0, r6 - @ r0=rGlue + @ r0=rSELF mov lr, pc ldr pc, .LdvmFastJavaMethodTraceExit ldmfd sp!, {r0-r2,lr} @ restore live registers #endif SAVEAREA_FROM_FP(r0, rFP) @ r0<- saveArea (old) ldr r10, [r0, #offStackSaveArea_prevFrame] @ r10<- saveArea->prevFrame - ldr r8, [rGLUE, #offGlue_pSelfSuspendCount] @ r8<- &suspendCount + ldr r8, [rSELF, #offThread_suspendCount] @ r8<- suspendCount ldr rPC, [r0, #offStackSaveArea_savedPc] @ rPC<- saveArea->savedPc #if !defined(WITH_SELF_VERIFICATION) ldr r9, [r0, #offStackSaveArea_returnAddr] @ r9<- chaining cell ret @@ -185,7 +185,6 @@ dvmCompiler_TEMPLATE_RETURN: #endif ldr r2, [r10, #(offStackSaveArea_method - sizeofStackSaveArea)] @ r2<- method we're returning to - ldr r3, [rGLUE, #offGlue_self] @ r3<- glue->self cmp r2, #0 @ break frame? #if !defined(WITH_SELF_VERIFICATION) beq 1f @ bail to interpreter @@ -195,16 +194,15 @@ dvmCompiler_TEMPLATE_RETURN: ldr r1, .LdvmJitToInterpNoChainNoProfile @ defined in footer.S mov rFP, r10 @ publish new FP ldr r10, [r2, #offMethod_clazz] @ r10<- method->clazz - ldr r8, [r8] @ r8<- suspendCount - str r2, [rGLUE, #offGlue_method]@ glue->method = newSave->method + str r2, [rSELF, #offThread_method]@ self->method = newSave->method ldr r0, [r10, #offClassObject_pDvmDex] @ r0<- method->clazz->pDvmDex - str rFP, [r3, #offThread_curFrame] @ self->curFrame = fp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = fp add rPC, rPC, #6 @ publish new rPC (advance 6 bytes) - str r0, [rGLUE, #offGlue_methodClassDex] + str r0, [rSELF, #offThread_methodClassDex] cmp r8, #0 @ check the suspendCount movne r9, #0 @ clear the chaining cell address - str r9, [r3, #offThread_inJitCodeCache] @ in code cache or not + str r9, [rSELF, #offThread_inJitCodeCache] @ in code cache or not cmp r9, #0 @ chaining cell exists? blxne r9 @ jump to the chaining cell #if defined(WITH_JIT_TUNING) @@ -212,10 +210,10 @@ dvmCompiler_TEMPLATE_RETURN: #endif mov pc, r1 @ callsite is interpreted 1: - stmia rGLUE, {rPC, rFP} @ SAVE_PC_FP_TO_GLUE() + stmia rSELF, {rPC, rFP} @ SAVE_PC_FP_TO_SELF() ldr r2, .LdvmMterpStdBail @ defined in footer.S mov r1, #0 @ changeInterp = false - mov r0, rGLUE @ Expecting rGLUE in r0 + mov r0, rSELF @ Expecting rSELF in r0 blx r2 @ exit the interpreter /* ------------------------------ */ @@ -231,14 +229,13 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NO_OPT: @ r0 = methodToCall, r1 = returnCell, rPC = dalvikCallsite ldrh r7, [r0, #offMethod_registersSize] @ r7<- methodToCall->regsSize ldrh r2, [r0, #offMethod_outsSize] @ r2<- methodToCall->outsSize - ldr r9, [rGLUE, #offGlue_interpStackEnd] @ r9<- interpStackEnd - ldr r8, [rGLUE, #offGlue_pSelfSuspendCount] @ r8<- &suspendCount + ldr r9, [rSELF, #offThread_interpStackEnd] @ r9<- interpStackEnd + ldr r8, [rSELF, #offThread_suspendCount] @ r8<- suspendCount add r3, r1, #1 @ Thumb addr is odd SAVEAREA_FROM_FP(r1, rFP) @ r1<- stack save area sub r1, r1, r7, lsl #2 @ r1<- newFp (old savearea - regsSize) SAVEAREA_FROM_FP(r10, r1) @ r10<- stack save area sub r10, r10, r2, lsl #2 @ r10<- bottom (newsave - outsSize) - ldr r8, [r8] @ r8<- suspendCount (int) cmp r10, r9 @ bottom < interpStackEnd? bxlo lr @ return to raise stack overflow excep. @ r1 = newFP, r0 = methodToCall, r3 = returnCell, rPC = dalvikCallsite @@ -264,17 +261,16 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NO_OPT: ldr r10, .LdvmJitToInterpTraceSelectNoChain ldr r3, [r9, #offClassObject_pDvmDex] @ r3<- method->clazz->pDvmDex - ldr r2, [rGLUE, #offGlue_self] @ r2<- glue->self - @ Update "glue" values for the new method - str r0, [rGLUE, #offGlue_method] @ glue->method = methodToCall - str r3, [rGLUE, #offGlue_methodClassDex] @ glue->methodClassDex = ... + @ Update "thread" values for the new method + str r0, [rSELF, #offThread_method] @ self->method = methodToCall + str r3, [rSELF, #offThread_methodClassDex] @ self->methodClassDex = ... mov rFP, r1 @ fp = newFp - str rFP, [r2, #offThread_curFrame] @ self->curFrame = newFp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = newFp #if defined(TEMPLATE_INLINE_PROFILING) stmfd sp!, {r0-r3} @ preserve r0-r3 mov r1, r6 - @ r0=methodToCall, r1=rGlue + @ r0=methodToCall, r1=rSELF mov lr, pc ldr pc, .LdvmFastMethodTraceEnter ldmfd sp!, {r0-r3} @ restore r0-r3 @@ -300,15 +296,14 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_CHAIN: @ rPC = dalvikCallsite, r7 = methodToCall->registersSize @ methodToCall is guaranteed to be non-native .LinvokeChain: - ldr r9, [rGLUE, #offGlue_interpStackEnd] @ r9<- interpStackEnd - ldr r8, [rGLUE, #offGlue_pSelfSuspendCount] @ r8<- &suspendCount + ldr r9, [rSELF, #offThread_interpStackEnd] @ r9<- interpStackEnd + ldr r8, [rSELF, #offThread_suspendCount] @ r8<- suspendCount add r3, r1, #1 @ Thumb addr is odd SAVEAREA_FROM_FP(r1, rFP) @ r1<- stack save area sub r1, r1, r7, lsl #2 @ r1<- newFp (old savearea - regsSize) SAVEAREA_FROM_FP(r10, r1) @ r10<- stack save area add r12, lr, #2 @ setup the punt-to-interp address sub r10, r10, r2, lsl #2 @ r10<- bottom (newsave - outsSize) - ldr r8, [r8] @ r8<- suspendCount (int) cmp r10, r9 @ bottom < interpStackEnd? bxlo r12 @ return to raise stack overflow excep. @ r1 = newFP, r0 = methodToCall, r3 = returnCell, rPC = dalvikCallsite @@ -324,17 +319,16 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_CHAIN: bxne r12 @ bail to the interpreter ldr r3, [r9, #offClassObject_pDvmDex] @ r3<- method->clazz->pDvmDex - ldr r2, [rGLUE, #offGlue_self] @ r2<- glue->self - @ Update "glue" values for the new method - str r0, [rGLUE, #offGlue_method] @ glue->method = methodToCall - str r3, [rGLUE, #offGlue_methodClassDex] @ glue->methodClassDex = ... + @ Update "thread" values for the new method + str r0, [rSELF, #offThread_method] @ self->method = methodToCall + str r3, [rSELF, #offThread_methodClassDex] @ self->methodClassDex = ... mov rFP, r1 @ fp = newFp - str rFP, [r2, #offThread_curFrame] @ self->curFrame = newFp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = newFp #if defined(TEMPLATE_INLINE_PROFILING) stmfd sp!, {r0-r2,lr} @ preserve clobbered live registers mov r1, r6 - @ r0=methodToCall, r1=rGlue + @ r0=methodToCall, r1=rSELF mov lr, pc ldr pc, .LdvmFastMethodTraceEnter ldmfd sp!, {r0-r2,lr} @ restore registers @@ -374,7 +368,7 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_PREDICTED_CHAIN: ldr r3, [r0, #offObject_clazz] @ r3 <- this->class ldr r8, [r2, #4] @ r8 <- predictedChainCell->clazz ldr r0, [r2, #8] @ r0 <- predictedChainCell->method - ldr r9, [rGLUE, #offGlue_icRechainCount] @ r1 <- shared rechainCount + ldr r9, [rSELF, #offThread_icRechainCount] @ r1 <- shared rechainCount cmp r3, r8 @ predicted class == actual class? #if defined(WITH_JIT_TUNING) ldr r7, .LdvmICHitCount @@ -396,7 +390,7 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_PREDICTED_CHAIN: cmp r8, #0 @ initialized class or not moveq r1, #0 subne r1, r9, #1 @ count-- - strne r1, [rGLUE, #offGlue_icRechainCount] @ write back to InterpState + strne r1, [rSELF, #offThread_icRechainCount] @ write back to thread add lr, lr, #4 @ return to fully-resolve landing pad /* * r1 <- count @@ -414,13 +408,12 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE: /* File: armv5te/TEMPLATE_INVOKE_METHOD_NATIVE.S */ @ r0 = methodToCall, r1 = returnCell, rPC = dalvikCallsite @ r7 = methodToCall->registersSize - ldr r9, [rGLUE, #offGlue_interpStackEnd] @ r9<- interpStackEnd - ldr r8, [rGLUE, #offGlue_pSelfSuspendCount] @ r8<- &suspendCount + ldr r9, [rSELF, #offThread_interpStackEnd] @ r9<- interpStackEnd + ldr r8, [rSELF, #offThread_suspendCount] @ r8<- suspendCount add r3, r1, #1 @ Thumb addr is odd SAVEAREA_FROM_FP(r1, rFP) @ r1<- stack save area sub r1, r1, r7, lsl #2 @ r1<- newFp (old savearea - regsSize) SAVEAREA_FROM_FP(r10, r1) @ r10<- stack save area - ldr r8, [r8] @ r3<- suspendCount (int) cmp r10, r9 @ bottom < interpStackEnd? bxlo lr @ return to raise stack overflow excep. @ r1 = newFP, r0 = methodToCall, r3 = returnCell, rPC = dalvikCallsite @@ -430,7 +423,6 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE: @ set up newSaveArea str rFP, [r1, #(offStackSaveArea_prevFrame - sizeofStackSaveArea)] str r3, [r1, #(offStackSaveArea_returnAddr - sizeofStackSaveArea)] - ldr r3, [rGLUE, #offGlue_self] @ r3<- glue->self str r0, [r1, #(offStackSaveArea_method - sizeofStackSaveArea)] cmp r8, #0 @ suspendCount != 0 ldr r8, [r0, #offMethod_nativeFunc] @ r8<- method->nativeFunc @@ -441,25 +433,25 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE: #endif @ go ahead and transfer control to the native code - ldr r9, [r3, #offThread_jniLocal_topCookie] @ r9<- thread->localRef->... + ldr r9, [rSELF, #offThread_jniLocal_topCookie]@r9<-thread->localRef->... mov r2, #0 - str r1, [r3, #offThread_curFrame] @ self->curFrame = newFp - str r2, [r3, #offThread_inJitCodeCache] @ not in the jit code cache + str r1, [rSELF, #offThread_curFrame] @ self->curFrame = newFp + str r2, [rSELF, #offThread_inJitCodeCache] @ not in the jit code cache str r9, [r1, #(offStackSaveArea_localRefCookie - sizeofStackSaveArea)] @ newFp->localRefCookie=top - mov r9, r3 @ r9<- glue->self (preserve) SAVEAREA_FROM_FP(r10, r1) @ r10<- new stack save area - mov r2, r0 @ r2<- methodToCall - mov r0, r1 @ r0<- newFP - add r1, rGLUE, #offGlue_retval @ r1<- &retval + mov r2, r0 @ arg2<- methodToCall + mov r0, r1 @ arg0<- newFP + add r1, rSELF, #offThread_retval @ arg1<- &retval + mov r3, rSELF @ arg3<- self #if defined(TEMPLATE_INLINE_PROFILING) - @ r2=methodToCall, r6=rGLUE + @ r2=methodToCall, r6=rSELF stmfd sp!, {r2,r6} @ to be consumed after JNI return stmfd sp!, {r0-r3} @ preserve r0-r3 mov r0, r2 mov r1, r6 - @ r0=JNIMethod, r1=rGlue + @ r0=JNIMethod, r1=rSELF mov lr, pc ldr pc, .LdvmFastMethodTraceEnter ldmfd sp!, {r0-r3} @ restore r0-r3 @@ -469,24 +461,24 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE: #if defined(TEMPLATE_INLINE_PROFILING) ldmfd sp!, {r0-r1} @ restore r2 and r6 - @ r0=JNIMethod, r1=rGlue + @ r0=JNIMethod, r1=rSELF mov lr, pc ldr pc, .LdvmFastNativeMethodTraceExit #endif - @ native return; r9=self, r10=newSaveArea + @ native return; r10=newSaveArea @ equivalent to dvmPopJniLocals ldr r2, [r10, #offStackSaveArea_returnAddr] @ r2 = chaining cell ret ldr r0, [r10, #offStackSaveArea_localRefCookie] @ r0<- saved->top - ldr r1, [r9, #offThread_exception] @ check for exception - str rFP, [r9, #offThread_curFrame] @ self->curFrame = fp + ldr r1, [rSELF, #offThread_exception] @ check for exception + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = fp cmp r1, #0 @ null? - str r0, [r9, #offThread_jniLocal_topCookie] @ new top <- old top + str r0, [rSELF, #offThread_jniLocal_topCookie] @ new top <- old top ldr r0, [rFP, #(offStackSaveArea_currentPc - sizeofStackSaveArea)] @ r0 = dalvikCallsitePC bne .LhandleException @ no, handle exception - str r2, [r9, #offThread_inJitCodeCache] @ set the mode properly + str r2, [rSELF, #offThread_inJitCodeCache] @ set the mode properly cmp r2, #0 @ return chaining cell still exists? bxne r2 @ yes - go ahead @@ -1384,7 +1376,7 @@ dvmCompiler_TEMPLATE_INTERPRET: * r1 - the Dalvik PC to begin interpretation. * else * [lr, #3] contains Dalvik PC to begin interpretation - * rGLUE - pointer to interpState + * rSELF - pointer to thread * rFP - Dalvik frame pointer */ cmp lr, #0 @@ -1425,10 +1417,10 @@ dvmCompiler_TEMPLATE_MONITOR_ENTER: str r3, [r0, #offThread_inJitCodeCache] blx r2 @ dvmLockObject(self, obj) @ refresh Jit's on/off status - ldr r0, [rGLUE, #offGlue_ppJitProfTable] - ldr r0, [r0] + ldr r3, [rSELF, #offThread_ppJitProfTable] + ldr r3, [r3] ldr r2, .LdvmJitToInterpNoChain - str r0, [rGLUE, #offGlue_pJitProfTable] + str r3, [rSELF, #offThread_pJitProfTable] @ Bail to interpreter - no chain [note - r4 still contains rPC] #if defined(WITH_JIT_TUNING) mov r0, #kHeavyweightMonitor @@ -1456,11 +1448,10 @@ dvmCompiler_TEMPLATE_MONITOR_ENTER_DEBUG: str r3, [r0, #offThread_inJitCodeCache] blx r2 @ dvmLockObject(self, obj) @ refresh Jit's on/off status & test for exception - ldr r0, [rGLUE, #offGlue_ppJitProfTable] - ldr r1, [rGLUE, #offGlue_self] - ldr r0, [r0] - ldr r1, [r1, #offThread_exception] - str r0, [rGLUE, #offGlue_pJitProfTable] + ldr r3, [rSELF, #offThread_ppJitProfTable] + ldr r3, [r3] + ldr r1, [rSELF, #offThread_exception] + str r3, [rSELF, #offThread_pJitProfTable] cmp r1, #0 beq 1f ldr r2, .LhandleException @@ -1489,7 +1480,7 @@ dvmCompiler_TEMPLATE_PERIODIC_PROFILING: * we are arriving from thumb mode, lr will have its low bit set. */ ldr r0, [lr,#-11] - ldr r1, [rGLUE, #offGlue_pProfileCountdown] + ldr r1, [rSELF, #offThread_pProfileCountdown] ldr r2, [r0] @ get counter ldr r3, [r1] @ get countdown timer add r2, #1 @@ -1522,14 +1513,14 @@ dvmCompiler_TEMPLATE_RETURN_PROF: #if defined(TEMPLATE_INLINE_PROFILING) stmfd sp!, {r0-r2,lr} @ preserve live registers mov r0, r6 - @ r0=rGlue + @ r0=rSELF mov lr, pc ldr pc, .LdvmFastJavaMethodTraceExit ldmfd sp!, {r0-r2,lr} @ restore live registers #endif SAVEAREA_FROM_FP(r0, rFP) @ r0<- saveArea (old) ldr r10, [r0, #offStackSaveArea_prevFrame] @ r10<- saveArea->prevFrame - ldr r8, [rGLUE, #offGlue_pSelfSuspendCount] @ r8<- &suspendCount + ldr r8, [rSELF, #offThread_suspendCount] @ r8<- suspendCount ldr rPC, [r0, #offStackSaveArea_savedPc] @ rPC<- saveArea->savedPc #if !defined(WITH_SELF_VERIFICATION) ldr r9, [r0, #offStackSaveArea_returnAddr] @ r9<- chaining cell ret @@ -1538,7 +1529,6 @@ dvmCompiler_TEMPLATE_RETURN_PROF: #endif ldr r2, [r10, #(offStackSaveArea_method - sizeofStackSaveArea)] @ r2<- method we're returning to - ldr r3, [rGLUE, #offGlue_self] @ r3<- glue->self cmp r2, #0 @ break frame? #if !defined(WITH_SELF_VERIFICATION) beq 1f @ bail to interpreter @@ -1548,16 +1538,15 @@ dvmCompiler_TEMPLATE_RETURN_PROF: ldr r1, .LdvmJitToInterpNoChainNoProfile @ defined in footer.S mov rFP, r10 @ publish new FP ldr r10, [r2, #offMethod_clazz] @ r10<- method->clazz - ldr r8, [r8] @ r8<- suspendCount - str r2, [rGLUE, #offGlue_method]@ glue->method = newSave->method + str r2, [rSELF, #offThread_method]@ self->method = newSave->method ldr r0, [r10, #offClassObject_pDvmDex] @ r0<- method->clazz->pDvmDex - str rFP, [r3, #offThread_curFrame] @ self->curFrame = fp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = fp add rPC, rPC, #6 @ publish new rPC (advance 6 bytes) - str r0, [rGLUE, #offGlue_methodClassDex] + str r0, [rSELF, #offThread_methodClassDex] cmp r8, #0 @ check the suspendCount movne r9, #0 @ clear the chaining cell address - str r9, [r3, #offThread_inJitCodeCache] @ in code cache or not + str r9, [rSELF, #offThread_inJitCodeCache] @ in code cache or not cmp r9, #0 @ chaining cell exists? blxne r9 @ jump to the chaining cell #if defined(WITH_JIT_TUNING) @@ -1565,10 +1554,10 @@ dvmCompiler_TEMPLATE_RETURN_PROF: #endif mov pc, r1 @ callsite is interpreted 1: - stmia rGLUE, {rPC, rFP} @ SAVE_PC_FP_TO_GLUE() + stmia rSELF, {rPC, rFP} @ SAVE_PC_FP_TO_SELF() ldr r2, .LdvmMterpStdBail @ defined in footer.S mov r1, #0 @ changeInterp = false - mov r0, rGLUE @ Expecting rGLUE in r0 + mov r0, rSELF @ Expecting rSELF in r0 blx r2 @ exit the interpreter #undef TEMPLATE_INLINE_PROFILING @@ -1588,14 +1577,13 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NO_OPT_PROF: @ r0 = methodToCall, r1 = returnCell, rPC = dalvikCallsite ldrh r7, [r0, #offMethod_registersSize] @ r7<- methodToCall->regsSize ldrh r2, [r0, #offMethod_outsSize] @ r2<- methodToCall->outsSize - ldr r9, [rGLUE, #offGlue_interpStackEnd] @ r9<- interpStackEnd - ldr r8, [rGLUE, #offGlue_pSelfSuspendCount] @ r8<- &suspendCount + ldr r9, [rSELF, #offThread_interpStackEnd] @ r9<- interpStackEnd + ldr r8, [rSELF, #offThread_suspendCount] @ r8<- suspendCount add r3, r1, #1 @ Thumb addr is odd SAVEAREA_FROM_FP(r1, rFP) @ r1<- stack save area sub r1, r1, r7, lsl #2 @ r1<- newFp (old savearea - regsSize) SAVEAREA_FROM_FP(r10, r1) @ r10<- stack save area sub r10, r10, r2, lsl #2 @ r10<- bottom (newsave - outsSize) - ldr r8, [r8] @ r8<- suspendCount (int) cmp r10, r9 @ bottom < interpStackEnd? bxlo lr @ return to raise stack overflow excep. @ r1 = newFP, r0 = methodToCall, r3 = returnCell, rPC = dalvikCallsite @@ -1621,17 +1609,16 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NO_OPT_PROF: ldr r10, .LdvmJitToInterpTraceSelectNoChain ldr r3, [r9, #offClassObject_pDvmDex] @ r3<- method->clazz->pDvmDex - ldr r2, [rGLUE, #offGlue_self] @ r2<- glue->self - @ Update "glue" values for the new method - str r0, [rGLUE, #offGlue_method] @ glue->method = methodToCall - str r3, [rGLUE, #offGlue_methodClassDex] @ glue->methodClassDex = ... + @ Update "thread" values for the new method + str r0, [rSELF, #offThread_method] @ self->method = methodToCall + str r3, [rSELF, #offThread_methodClassDex] @ self->methodClassDex = ... mov rFP, r1 @ fp = newFp - str rFP, [r2, #offThread_curFrame] @ self->curFrame = newFp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = newFp #if defined(TEMPLATE_INLINE_PROFILING) stmfd sp!, {r0-r3} @ preserve r0-r3 mov r1, r6 - @ r0=methodToCall, r1=rGlue + @ r0=methodToCall, r1=rSELF mov lr, pc ldr pc, .LdvmFastMethodTraceEnter ldmfd sp!, {r0-r3} @ restore r0-r3 @@ -1661,15 +1648,14 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_CHAIN_PROF: @ rPC = dalvikCallsite, r7 = methodToCall->registersSize @ methodToCall is guaranteed to be non-native .LinvokeChainProf: - ldr r9, [rGLUE, #offGlue_interpStackEnd] @ r9<- interpStackEnd - ldr r8, [rGLUE, #offGlue_pSelfSuspendCount] @ r8<- &suspendCount + ldr r9, [rSELF, #offThread_interpStackEnd] @ r9<- interpStackEnd + ldr r8, [rSELF, #offThread_suspendCount] @ r8<- suspendCount add r3, r1, #1 @ Thumb addr is odd SAVEAREA_FROM_FP(r1, rFP) @ r1<- stack save area sub r1, r1, r7, lsl #2 @ r1<- newFp (old savearea - regsSize) SAVEAREA_FROM_FP(r10, r1) @ r10<- stack save area add r12, lr, #2 @ setup the punt-to-interp address sub r10, r10, r2, lsl #2 @ r10<- bottom (newsave - outsSize) - ldr r8, [r8] @ r8<- suspendCount (int) cmp r10, r9 @ bottom < interpStackEnd? bxlo r12 @ return to raise stack overflow excep. @ r1 = newFP, r0 = methodToCall, r3 = returnCell, rPC = dalvikCallsite @@ -1685,17 +1671,16 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_CHAIN_PROF: bxne r12 @ bail to the interpreter ldr r3, [r9, #offClassObject_pDvmDex] @ r3<- method->clazz->pDvmDex - ldr r2, [rGLUE, #offGlue_self] @ r2<- glue->self - @ Update "glue" values for the new method - str r0, [rGLUE, #offGlue_method] @ glue->method = methodToCall - str r3, [rGLUE, #offGlue_methodClassDex] @ glue->methodClassDex = ... + @ Update "thread" values for the new method + str r0, [rSELF, #offThread_method] @ self->method = methodToCall + str r3, [rSELF, #offThread_methodClassDex] @ self->methodClassDex = ... mov rFP, r1 @ fp = newFp - str rFP, [r2, #offThread_curFrame] @ self->curFrame = newFp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = newFp #if defined(TEMPLATE_INLINE_PROFILING) stmfd sp!, {r0-r2,lr} @ preserve clobbered live registers mov r1, r6 - @ r0=methodToCall, r1=rGlue + @ r0=methodToCall, r1=rSELF mov lr, pc ldr pc, .LdvmFastMethodTraceEnter ldmfd sp!, {r0-r2,lr} @ restore registers @@ -1739,7 +1724,7 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_PREDICTED_CHAIN_PROF: ldr r3, [r0, #offObject_clazz] @ r3 <- this->class ldr r8, [r2, #4] @ r8 <- predictedChainCell->clazz ldr r0, [r2, #8] @ r0 <- predictedChainCell->method - ldr r9, [rGLUE, #offGlue_icRechainCount] @ r1 <- shared rechainCount + ldr r9, [rSELF, #offThread_icRechainCount] @ r1 <- shared rechainCount cmp r3, r8 @ predicted class == actual class? #if defined(WITH_JIT_TUNING) ldr r7, .LdvmICHitCount @@ -1761,7 +1746,7 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_PREDICTED_CHAIN_PROF: cmp r8, #0 @ initialized class or not moveq r1, #0 subne r1, r9, #1 @ count-- - strne r1, [rGLUE, #offGlue_icRechainCount] @ write back to InterpState + strne r1, [rSELF, #offThread_icRechainCount] @ write back to thread add lr, lr, #4 @ return to fully-resolve landing pad /* * r1 <- count @@ -1783,13 +1768,12 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE_PROF: /* File: armv5te/TEMPLATE_INVOKE_METHOD_NATIVE.S */ @ r0 = methodToCall, r1 = returnCell, rPC = dalvikCallsite @ r7 = methodToCall->registersSize - ldr r9, [rGLUE, #offGlue_interpStackEnd] @ r9<- interpStackEnd - ldr r8, [rGLUE, #offGlue_pSelfSuspendCount] @ r8<- &suspendCount + ldr r9, [rSELF, #offThread_interpStackEnd] @ r9<- interpStackEnd + ldr r8, [rSELF, #offThread_suspendCount] @ r8<- suspendCount add r3, r1, #1 @ Thumb addr is odd SAVEAREA_FROM_FP(r1, rFP) @ r1<- stack save area sub r1, r1, r7, lsl #2 @ r1<- newFp (old savearea - regsSize) SAVEAREA_FROM_FP(r10, r1) @ r10<- stack save area - ldr r8, [r8] @ r3<- suspendCount (int) cmp r10, r9 @ bottom < interpStackEnd? bxlo lr @ return to raise stack overflow excep. @ r1 = newFP, r0 = methodToCall, r3 = returnCell, rPC = dalvikCallsite @@ -1799,7 +1783,6 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE_PROF: @ set up newSaveArea str rFP, [r1, #(offStackSaveArea_prevFrame - sizeofStackSaveArea)] str r3, [r1, #(offStackSaveArea_returnAddr - sizeofStackSaveArea)] - ldr r3, [rGLUE, #offGlue_self] @ r3<- glue->self str r0, [r1, #(offStackSaveArea_method - sizeofStackSaveArea)] cmp r8, #0 @ suspendCount != 0 ldr r8, [r0, #offMethod_nativeFunc] @ r8<- method->nativeFunc @@ -1810,25 +1793,25 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE_PROF: #endif @ go ahead and transfer control to the native code - ldr r9, [r3, #offThread_jniLocal_topCookie] @ r9<- thread->localRef->... + ldr r9, [rSELF, #offThread_jniLocal_topCookie]@r9<-thread->localRef->... mov r2, #0 - str r1, [r3, #offThread_curFrame] @ self->curFrame = newFp - str r2, [r3, #offThread_inJitCodeCache] @ not in the jit code cache + str r1, [rSELF, #offThread_curFrame] @ self->curFrame = newFp + str r2, [rSELF, #offThread_inJitCodeCache] @ not in the jit code cache str r9, [r1, #(offStackSaveArea_localRefCookie - sizeofStackSaveArea)] @ newFp->localRefCookie=top - mov r9, r3 @ r9<- glue->self (preserve) SAVEAREA_FROM_FP(r10, r1) @ r10<- new stack save area - mov r2, r0 @ r2<- methodToCall - mov r0, r1 @ r0<- newFP - add r1, rGLUE, #offGlue_retval @ r1<- &retval + mov r2, r0 @ arg2<- methodToCall + mov r0, r1 @ arg0<- newFP + add r1, rSELF, #offThread_retval @ arg1<- &retval + mov r3, rSELF @ arg3<- self #if defined(TEMPLATE_INLINE_PROFILING) - @ r2=methodToCall, r6=rGLUE + @ r2=methodToCall, r6=rSELF stmfd sp!, {r2,r6} @ to be consumed after JNI return stmfd sp!, {r0-r3} @ preserve r0-r3 mov r0, r2 mov r1, r6 - @ r0=JNIMethod, r1=rGlue + @ r0=JNIMethod, r1=rSELF mov lr, pc ldr pc, .LdvmFastMethodTraceEnter ldmfd sp!, {r0-r3} @ restore r0-r3 @@ -1838,24 +1821,24 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE_PROF: #if defined(TEMPLATE_INLINE_PROFILING) ldmfd sp!, {r0-r1} @ restore r2 and r6 - @ r0=JNIMethod, r1=rGlue + @ r0=JNIMethod, r1=rSELF mov lr, pc ldr pc, .LdvmFastNativeMethodTraceExit #endif - @ native return; r9=self, r10=newSaveArea + @ native return; r10=newSaveArea @ equivalent to dvmPopJniLocals ldr r2, [r10, #offStackSaveArea_returnAddr] @ r2 = chaining cell ret ldr r0, [r10, #offStackSaveArea_localRefCookie] @ r0<- saved->top - ldr r1, [r9, #offThread_exception] @ check for exception - str rFP, [r9, #offThread_curFrame] @ self->curFrame = fp + ldr r1, [rSELF, #offThread_exception] @ check for exception + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = fp cmp r1, #0 @ null? - str r0, [r9, #offThread_jniLocal_topCookie] @ new top <- old top + str r0, [rSELF, #offThread_jniLocal_topCookie] @ new top <- old top ldr r0, [rFP, #(offStackSaveArea_currentPc - sizeofStackSaveArea)] @ r0 = dalvikCallsitePC bne .LhandleException @ no, handle exception - str r2, [r9, #offThread_inJitCodeCache] @ set the mode properly + str r2, [rSELF, #offThread_inJitCodeCache] @ set the mode properly cmp r2, #0 @ return chaining cell still exists? bxne r2 @ yes - go ahead @@ -1882,24 +1865,23 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE_PROF: .LinvokeNative: @ Prep for the native call @ r1 = newFP, r0 = methodToCall - ldr r3, [rGLUE, #offGlue_self] @ r3<- glue->self mov r2, #0 - ldr r9, [r3, #offThread_jniLocal_topCookie] @ r9<- thread->localRef->... - str r2, [r3, #offThread_inJitCodeCache] @ not in jit code cache - str r1, [r3, #offThread_curFrame] @ self->curFrame = newFp + ldr r9, [rSELF, #offThread_jniLocal_topCookie]@r9<-thread->localRef->... + str r2, [rSELF, #offThread_inJitCodeCache] @ not in jit code cache + str r1, [rSELF, #offThread_curFrame] @ self->curFrame = newFp str r9, [r1, #(offStackSaveArea_localRefCookie - sizeofStackSaveArea)] @ newFp->localRefCookie=top - mov r9, r3 @ r9<- glue->self (preserve) - ldr lr, [rGLUE, #offGlue_pInterpBreak] + ldr lr, [rSELF, #offThread_pInterpBreak] SAVEAREA_FROM_FP(r10, r1) @ r10<- new stack save area mov r2, r0 @ r2<- methodToCall ldr lr, [lr] @ lr<- set of active profilers mov r0, r1 @ r0<- newFP - add r1, rGLUE, #offGlue_retval @ r1<- &retval + add r1, rSELF, #offThread_retval @ r1<- &retval + mov r3, rSELF @ arg3<- self ands lr, #kSubModeMethodTrace beq 121f @ hop if not profiling - @ r2: methodToCall, r6: rGLUE + @ r2: methodToCall, r6: rSELF stmfd sp!, {r2,r6} stmfd sp!, {r0-r3} mov r0, r2 @@ -1920,24 +1902,24 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE_PROF: ldr pc, [r2, #offMethod_nativeFunc] 212: @ Refresh Jit's on/off status - ldr r3, [rGLUE, #offGlue_ppJitProfTable] + ldr r3, [rSELF, #offThread_ppJitProfTable] - @ native return; r9=self, r10=newSaveArea + @ native return; r10=newSaveArea @ equivalent to dvmPopJniLocals ldr r2, [r10, #offStackSaveArea_returnAddr] @ r2 = chaining cell ret ldr r0, [r10, #offStackSaveArea_localRefCookie] @ r0<- saved->top - ldr r1, [r9, #offThread_exception] @ check for exception + ldr r1, [rSELF, #offThread_exception] @ check for exception ldr r3, [r3] @ r1 <- pointer to Jit profile table - str rFP, [r9, #offThread_curFrame] @ self->curFrame = fp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = fp cmp r1, #0 @ null? - str r0, [r9, #offThread_jniLocal_topCookie] @ new top <- old top + str r0, [rSELF, #offThread_jniLocal_topCookie] @ new top <- old top + str r3, [rSELF, #offThread_pJitProfTable] @ cache current JitProfTable ldr r0, [r10, #offStackSaveArea_savedPc] @ reload rPC - str r3, [rGLUE, #offGlue_pJitProfTable] @ cache current JitProfTable @ r0 = dalvikCallsitePC bne .LhandleException @ no, handle exception - str r2, [r9, #offThread_inJitCodeCache] @ set the new mode + str r2, [rSELF, #offThread_inJitCodeCache] @ set the new mode cmp r2, #0 @ return chaining cell still exists? bxne r2 @ yes - go ahead @@ -1959,9 +1941,8 @@ dvmCompiler_TEMPLATE_INVOKE_METHOD_NATIVE_PROF: .LdeadFood: .word 0xdeadf00d #endif - ldr r3, [rGLUE, #offGlue_self] @ r3<- glue->self mov r2, #0 - str r2, [r3, #offThread_inJitCodeCache] @ in interpreter land + str r2, [rSELF, #offThread_inJitCodeCache] @ in interpreter land ldr r1, .LdvmMterpCommonExceptionThrown @ PIC way of getting &func ldr rIBASE, .LdvmAsmInstructionStart @ same as above mov rPC, r0 @ reload the faulting Dalvik address diff --git a/vm/compiler/template/out/CompilerTemplateAsm-ia32.S b/vm/compiler/template/out/CompilerTemplateAsm-ia32.S index ae548e413..4e86d095d 100644 --- a/vm/compiler/template/out/CompilerTemplateAsm-ia32.S +++ b/vm/compiler/template/out/CompilerTemplateAsm-ia32.S @@ -24,7 +24,7 @@ #if defined(WITH_JIT) /* Subset of defines from mterp/x86/header.S */ -#define rGLUE (%ebp) +#define rSELF (%ebp) #define rPC %esi #define rFP %edi #define rINST %ebx @@ -73,12 +73,20 @@ dvmCompiler_TEMPLATE_INTERPRET: * On entry: * (TOS)<- return pointer or pointer to dPC */ - movl rGLUE,%ecx + +/* + * FIXME - this won't work as-is. The cache boundaries are not + * set up until later. Perhaps rething this whole thing. Do we + * really need an interpret teplate? + */ + + + movl rSELF,%ecx movl $.LinterpPunt,%edx pop %eax - cmpl %eax,offGlue_jitCacheEnd(%ecx) + /*cmpl %eax,offThread_jitCacheEnd(%ecx)*/ ja 1f - cmpl %eax,offGlue_jitCacheStart(%ecx) + /*cmpl %eax,offThread_jitCacheStart(%ecx)*/ jb 1f movl %eax,rPC 1: diff --git a/vm/interp/Interp.c b/vm/interp/Interp.c index ef11547a3..82f137290 100644 --- a/vm/interp/Interp.c +++ b/vm/interp/Interp.c @@ -1232,24 +1232,12 @@ void dvmUpdateInterpBreak(int newMode, bool enable) } /* - * Main interpreter loop entry point. Select "standard" or "debug" - * interpreter and switch between them as required. - * - * This begins executing code at the start of "method". On exit, "pResult" - * holds the return value of the method (or, if "method" returns NULL, it - * holds an undefined value). - * - * The interpreted stack frame, which holds the method arguments, has - * already been set up. + * One-time initialization at thread creation. Here we initialize + * useful constants. */ -void dvmInterpret(Thread* self, const Method* method, JValue* pResult) +void dvmInitInterpreterState(Thread* self) { - InterpState interpState; - bool change; #if defined(WITH_JIT) - /* Target-specific save/restore */ - extern void dvmJitCalleeSave(double *saveArea); - extern void dvmJitCalleeRestore(double *saveArea); /* Interpreter entry points from compiled code */ extern void dvmJitToInterpNormal(); extern void dvmJitToInterpNoChain(); @@ -1259,7 +1247,6 @@ void dvmInterpret(Thread* self, const Method* method, JValue* pResult) #if defined(WITH_SELF_VERIFICATION) extern void dvmJitToInterpBackwardBranch(); #endif - /* * Reserve a static entity here to quickly setup runtime contents as * gcc will issue block copy instructions. @@ -1272,9 +1259,47 @@ void dvmInterpret(Thread* self, const Method* method, JValue* pResult) dvmJitToInterpTraceSelect, #if defined(WITH_SELF_VERIFICATION) dvmJitToInterpBackwardBranch, +#else + NULL, #endif }; +#endif + + // Begin initialization + self->cardTable = gDvm.biasedCardTableBase; + self->interpSave.pInterpBreak = &gDvm.interpBreak; +#if defined(WITH_JIT) + self->jitToInterpEntries = jitToInterpEntries; + self->icRechainCount = PREDICTED_CHAIN_COUNTER_RECHAIN; + self->pJitProfTable = gDvmJit.pProfTable; + self->ppJitProfTable = &gDvmJit.pProfTable; + self->jitThreshold = gDvmJit.threshold; + self->pProfileCountdown = &gDvmJit.profileCountdown; +#endif +} + + +/* + * Main interpreter loop entry point. Select "standard" or "debug" + * interpreter and switch between them as required. + * + * This begins executing code at the start of "method". On exit, "pResult" + * holds the return value of the method (or, if "method" returns NULL, it + * holds an undefined value). + * + * The interpreted stack frame, which holds the method arguments, has + * already been set up. + */ +void dvmInterpret(Thread* self, const Method* method, JValue* pResult) +{ + bool change; + InterpSaveState interpSaveState; +#if defined(WITH_JIT) + /* Target-specific save/restore */ + extern void dvmJitCalleeSave(double *saveArea); + extern void dvmJitCalleeRestore(double *saveArea); + double calleeSave[JIT_CALLEE_SAVE_DOUBLE_COUNT]; /* * If the previous VM left the code cache through single-stepping the * inJitCodeCache flag will be set when the VM is re-entered (for example, @@ -1284,28 +1309,26 @@ void dvmInterpret(Thread* self, const Method* method, JValue* pResult) */ #endif + /* + * Save interpreter state from previous activation, linking + * new to last. + */ + interpSaveState = self->interpSave; + self->interpSave.prev = &interpSaveState; +#if defined(WITH_JIT) + dvmJitCalleeSave(calleeSave); +#endif + #if defined(WITH_TRACKREF_CHECKS) - interpState.debugTrackedRefStart = + self->debugTrackedRefStart = dvmReferenceTableEntries(&self->internalLocalRefTable); #endif - interpState.debugIsMethodEntry = true; + self->debugIsMethodEntry = true; #if defined(WITH_JIT) - dvmJitCalleeSave(interpState.calleeSave); + dvmJitCalleeSave(calleeSave); /* Initialize the state to kJitNot */ - interpState.jitState = kJitNot; - - /* Setup the Jit-to-interpreter entry points */ - interpState.jitToInterpEntries = jitToInterpEntries; - - /* - * Initialize the threshold filter [don't bother to zero out the - * actual table. We're looking for matches, and an occasional - * false positive is acceptible. - */ - interpState.lastThreshFilter = 0; - - interpState.icRechainCount = PREDICTED_CHAIN_COUNTER_RECHAIN; + self->jitState = kJitNot; #endif /* @@ -1313,15 +1336,15 @@ void dvmInterpret(Thread* self, const Method* method, JValue* pResult) * * No need to initialize "retval". */ - interpState.method = method; - interpState.fp = (u4*) self->curFrame; - interpState.pc = method->insns; - interpState.entryPoint = kInterpEntryInstr; + self->interpSave.method = method; + self->interpSave.fp = (u4*) self->curFrame; + self->interpSave.pc = method->insns; + self->entryPoint = kInterpEntryInstr; if (dvmDebuggerOrProfilerActive()) - interpState.nextMode = INTERP_DBG; + self->nextMode = INTERP_DBG; else - interpState.nextMode = INTERP_STD; + self->nextMode = INTERP_STD; assert(!dvmIsNativeMethod(method)); @@ -1338,7 +1361,7 @@ void dvmInterpret(Thread* self, const Method* method, JValue* pResult) dvmAbort(); } - typedef bool (*Interpreter)(Thread*, InterpState*); + typedef bool (*Interpreter)(Thread*); Interpreter stdInterp; if (gDvm.executionMode == kExecutionModeInterpFast) stdInterp = dvmMterpStd; @@ -1355,22 +1378,25 @@ void dvmInterpret(Thread* self, const Method* method, JValue* pResult) change = true; while (change) { - switch (interpState.nextMode) { + switch (self->nextMode) { case INTERP_STD: LOGVV("threadid=%d: interp STD\n", self->threadId); - change = (*stdInterp)(self, &interpState); + change = (*stdInterp)(self); break; case INTERP_DBG: LOGVV("threadid=%d: interp DBG\n", self->threadId); - change = dvmInterpretDbg(self, &interpState); + change = dvmInterpretDbg(self); break; default: dvmAbort(); } } - *pResult = interpState.retval; + *pResult = self->retval; + + /* Restore interpreter state from previous activation */ + self->interpSave = interpSaveState; #if defined(WITH_JIT) - dvmJitCalleeRestore(interpState.calleeSave); + dvmJitCalleeRestore(calleeSave); #endif } diff --git a/vm/interp/Interp.h b/vm/interp/Interp.h index e5a4fdcac..55968ce12 100644 --- a/vm/interp/Interp.h +++ b/vm/interp/Interp.h @@ -39,6 +39,7 @@ void dvmThrowVerificationError(const Method* method, int kind, int ref); */ bool dvmBreakpointStartup(void); void dvmBreakpointShutdown(void); +void dvmInitInterpreterState(Thread* self); /* * Breakpoint implementation. diff --git a/vm/interp/InterpDefs.h b/vm/interp/InterpDefs.h index 40eb51d97..10a77a2b5 100644 --- a/vm/interp/InterpDefs.h +++ b/vm/interp/InterpDefs.h @@ -24,56 +24,7 @@ #ifndef _DALVIK_INTERP_DEFS #define _DALVIK_INTERP_DEFS - -/* - * Specify the starting point when switching between interpreters. - */ -typedef enum InterpEntry { - kInterpEntryInstr = 0, // continue to next instruction - kInterpEntryReturn = 1, // jump to method return - kInterpEntryThrow = 2, // jump to exception throw -#if defined(WITH_JIT) - kInterpEntryResume = 3, // Resume after single-step -#endif -} InterpEntry; - #if defined(WITH_JIT) -/* - * NOTE: Only entry points dispatched via [&InterpState + #offset] are put - * in this struct, and there are six of them: - * 1) dvmJitToInterpNormal: find if there is a corresponding compilation for - * the new dalvik PC. If so, chain the originating compilation with the - * target then jump to it. If the destination trace doesn't exist, update - * the profile count for that Dalvik PC. - * 2) dvmJitToInterpNoChain: similar to dvmJitToInterpNormal but chaining is - * not performed. - * 3) dvmJitToInterpPunt: use the fast interpreter to execute the next - * instruction(s) and stay there as long as it is appropriate to return - * to the compiled land. This is used when the jit'ed code is about to - * throw an exception. - * 4) dvmJitToInterpSingleStep: use the portable interpreter to execute the - * next instruction only and return to pre-specified location in the - * compiled code to resume execution. This is mainly used as debugging - * feature to bypass problematic opcode implementations without - * disturbing the trace formation. - * 5) dvmJitToTraceSelect: Similar to dvmJitToInterpNormal except for the - * profiling operation. If the new Dalvik PC is dominated by an already - * translated trace, directly request a new translation if the destinaion - * trace doesn't exist. - * 6) dvmJitToBackwardBranch: special case for SELF_VERIFICATION when the - * destination Dalvik PC is included by the trace itself. - */ -struct JitToInterpEntries { - void *dvmJitToInterpNormal; - void *dvmJitToInterpNoChain; - void *dvmJitToInterpPunt; - void *dvmJitToInterpSingleStep; - void *dvmJitToInterpTraceSelect; -#if defined(WITH_SELF_VERIFICATION) - void *dvmJitToInterpBackwardBranch; -#endif -}; - /* * Size of save area for callee-save FP regs, which are not automatically * saved by interpreter main because it doesn't use them (but Jit'd code @@ -82,115 +33,20 @@ struct JitToInterpEntries { */ #define JIT_CALLEE_SAVE_DOUBLE_COUNT 8 -/* Number of entries in the 2nd level JIT profiler filter cache */ -#define JIT_TRACE_THRESH_FILTER_SIZE 32 -/* Number of low dalvik pc address bits to include in 2nd level filter key */ -#define JIT_TRACE_THRESH_FILTER_PC_BITS 4 #endif /* - * Interpreter context, used when switching from one interpreter to - * another. We also tuck "mterp" state in here. - */ -typedef struct InterpState { - /* - * To make some mterp state updates easier, "pc" and "fp" MUST come - * first and MUST appear in this order. - */ - const u2* pc; // program counter - u4* fp; // frame pointer - - JValue retval; // return value -- "out" only - const Method* method; // method being executed - - - /* ---------------------------------------------------------------------- - * Mterp-only state - */ - DvmDex* methodClassDex; - Thread* self; - - /* housekeeping */ - void* bailPtr; - - /* - * These are available globally, from gDvm, or from another glue field - * (self/method). They're copied in here for speed. - */ - /* copy of self->interpStackEnd */ - const u1* interpStackEnd; - /* points at self->suspendCount */ - volatile int* pSelfSuspendCount; - /* Biased base of GC's card table */ - u1* cardTable; - /* points at gDvm.interpBreak */ - volatile int* pInterpBreak; - /* ---------------------------------------------------------------------- - */ - - /* - * Interpreter switching. - */ - InterpEntry entryPoint; // what to do when we start - int nextMode; // INTERP_STD, INTERP_DBG - -#if defined(WITH_JIT) - /* - * Local copies of field from gDvm placed here for fast access - */ - unsigned char* pJitProfTable; - JitState jitState; - const void* jitResumeNPC; // Native PC of compiled code - const u2* jitResumeDPC; // Dalvik PC corresponding to NPC - int jitThreshold; - /* - * ppJitProfTable holds the address of gDvmJit.pJitProfTable, which - * doubles as an on/off switch for the Jit. Because a change in - * the value of gDvmJit.pJitProfTable isn't reflected in the cached - * copy above (pJitProfTable), we need to periodically refresh it. - * ppJitProfTable is used for that purpose. - */ - unsigned char** ppJitProfTable; // Used to refresh pJitProfTable - int icRechainCount; // Count down to next rechain request - const void* pProfileCountdown; // Address of profile countdown timer - - struct JitToInterpEntries jitToInterpEntries; - - const void* jitCacheStart; // Code cache boundaries - const void* jitCacheEnd; - - int currTraceRun; - int totalTraceLen; // Number of Dalvik insts in trace - const u2* currTraceHead; // Start of the trace we're building - const u2* currRunHead; // Start of run we're building - int currRunLen; // Length of run in 16-bit words - int lastThreshFilter; - const u2* lastPC; // Stage the PC first for the threaded interpreter - intptr_t threshFilter[JIT_TRACE_THRESH_FILTER_SIZE]; - JitTraceRun trace[MAX_JIT_RUN_LEN]; - double calleeSave[JIT_CALLEE_SAVE_DOUBLE_COUNT]; -#endif - - bool debugIsMethodEntry; // used for method entry event triggers -#if defined(WITH_TRACKREF_CHECKS) - int debugTrackedRefStart; // tracked refs from prior invocations -#endif - - -} InterpState; - -/* - * These are generated from InterpCore.h. + * Portable interpreter. */ -extern bool dvmInterpretDbg(Thread* self, InterpState* interpState); -extern bool dvmInterpretStd(Thread* self, InterpState* interpState); +extern bool dvmInterpretDbg(Thread* self); +extern bool dvmInterpretStd(Thread* self); #define INTERP_STD 0 #define INTERP_DBG 1 /* * "mterp" interpreter. */ -extern bool dvmMterpStd(Thread* self, InterpState* interpState); +extern bool dvmMterpStd(Thread* self); /* * Get the "this" pointer from the current frame. diff --git a/vm/interp/InterpState.h b/vm/interp/InterpState.h new file mode 100644 index 000000000..62a29b322 --- /dev/null +++ b/vm/interp/InterpState.h @@ -0,0 +1,177 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/* + * Dalvik interpreter definitions. These are internal to the interpreter. + * + * This includes defines, types, function declarations, and inline functions + * that are common to all interpreter implementations. + * + * Functions and globals declared here are defined in Interp.c. + */ +#ifndef _DALVIK_INTERP_STATE +#define _DALVIK_INTERP_STATE + +/* + * Specify the starting point when switching between interpreters. + */ +typedef enum InterpEntry { + kInterpEntryInstr = 0, // continue to next instruction + kInterpEntryReturn = 1, // jump to method return + kInterpEntryThrow = 2, // jump to exception throw +#if defined(WITH_JIT) + kInterpEntryResume = 3, // Resume after single-step +#endif +} InterpEntry; + +typedef struct InterpSaveState { + const u2* pc; // Dalvik PC + u4* fp; // Dalvik frame pointer + const Method *method; // Method being executed + DvmDex* methodClassDex; + void* bailPtr; + volatile int* pInterpBreak; // FIXME - use directly +#if defined(WITH_TRACKREF_CHECKS) + int debugTrackedRefStart; +#else + int unused; // Keep struct size constant +#endif + struct InterpSaveState* prev; // To follow nested activations +} InterpSaveState; + +#ifdef WITH_JIT +/* + * NOTE: Only entry points dispatched via [self + #offset] are put + * in this struct, and there are six of them: + * 1) dvmJitToInterpNormal: find if there is a corresponding compilation for + * the new dalvik PC. If so, chain the originating compilation with the + * target then jump to it. If the destination trace doesn't exist, update + * the profile count for that Dalvik PC. + * 2) dvmJitToInterpNoChain: similar to dvmJitToInterpNormal but chaining is + * not performed. + * 3) dvmJitToInterpPunt: use the fast interpreter to execute the next + * instruction(s) and stay there as long as it is appropriate to return + * to the compiled land. This is used when the jit'ed code is about to + * throw an exception. + * 4) dvmJitToInterpSingleStep: use the portable interpreter to execute the + * next instruction only and return to pre-specified location in the + * compiled code to resume execution. This is mainly used as debugging + * feature to bypass problematic opcode implementations without + * disturbing the trace formation. + * 5) dvmJitToTraceSelect: Similar to dvmJitToInterpNormal except for the + * profiling operation. If the new Dalvik PC is dominated by an already + * translated trace, directly request a new translation if the destinaion + * trace doesn't exist. + * 6) dvmJitToBackwardBranch: special case for SELF_VERIFICATION when the + * destination Dalvik PC is included by the trace itself. + */ +struct JitToInterpEntries { + void *dvmJitToInterpNormal; + void *dvmJitToInterpNoChain; + void *dvmJitToInterpPunt; + void *dvmJitToInterpSingleStep; + void *dvmJitToInterpTraceSelect; +#if defined(WITH_SELF_VERIFICATION) + void *dvmJitToInterpBackwardBranch; +#else + void *unused; // Keep structure size constant +#endif +}; + +/* States of the dbg interpreter when serving a JIT-related request */ +typedef enum JitState { + /* Entering states in the debug interpreter */ + kJitNot = 0, // Non-JIT related reasons */ + kJitTSelectRequest = 1, // Request a trace (subject to filtering) + kJitTSelectRequestHot = 2, // Request a hot trace (bypass the filter) + kJitSelfVerification = 3, // Self Verification Mode + + /* Operational states in the debug interpreter */ + kJitTSelect = 4, // Actively selecting a trace + kJitTSelectEnd = 5, // Done with the trace - wrap it up + kJitSingleStep = 6, // Single step interpretation + kJitSingleStepEnd = 7, // Done with single step, ready return to mterp + kJitDone = 8, // Ready to leave the debug interpreter +} JitState; + +#if defined(WITH_SELF_VERIFICATION) +typedef enum SelfVerificationState { + kSVSIdle = 0, // Idle + kSVSStart = 1, // Shadow space set up, running compiled code + kSVSPunt = 2, // Exiting compiled code by punting + kSVSSingleStep = 3, // Exiting compiled code by single stepping + kSVSNoProfile = 4, // Exiting compiled code and don't collect profiles + kSVSTraceSelect = 5, // Exiting compiled code and compile the next pc + kSVSNormal = 6, // Exiting compiled code normally + kSVSNoChain = 7, // Exiting compiled code by no chain + kSVSBackwardBranch = 8, // Exiting compiled code with backward branch trace + kSVSDebugInterp = 9, // Normal state restored, running debug interpreter +} SelfVerificationState; +#endif + +/* Number of entries in the 2nd level JIT profiler filter cache */ +#define JIT_TRACE_THRESH_FILTER_SIZE 32 +/* Number of low dalvik pc address bits to include in 2nd level filter key */ +#define JIT_TRACE_THRESH_FILTER_PC_BITS 4 +#define MAX_JIT_RUN_LEN 64 + +typedef enum JitHint { + kJitHintNone = 0, + kJitHintTaken = 1, // Last inst in run was taken branch + kJitHintNotTaken = 2, // Last inst in run was not taken branch + kJitHintNoBias = 3, // Last inst in run was unbiased branch +} jitHint; + +/* + * Element of a Jit trace description. If the isCode bit is set, it describes + * a contiguous sequence of Dalvik byte codes. + */ +typedef struct { + unsigned isCode:1; // If set denotes code fragments + unsigned numInsts:8; // Number of Byte codes in run + unsigned runEnd:1; // Run ends with last byte code + jitHint hint:6; // Hint to apply to final code of run + u2 startOffset; // Starting offset for trace run +} JitCodeDesc; + +/* + * A complete list of trace runs passed to the compiler looks like the + * following: + * frag1 + * frag2 + * frag3 + * meta1 + * meta2 + * frag4 + * + * frags 1-4 have the "isCode" field set, and metas 1-2 are plain pointers or + * pointers to auxiliary data structures as long as the LSB is null. + * The meaning of the meta content is loosely defined. It is usually the code + * fragment right before the first meta field (frag3 in this case) to + * understand and parse them. Frag4 could be a dummy one with 0 "numInsts" but + * the "runEnd" field set. + * + * For example, if a trace run contains a method inlining target, the class + * type of "this" and the currently resolved method pointer are two instances + * of meta information stored there. + */ +typedef union { + JitCodeDesc frag; + void* meta; +} JitTraceRun; + +#endif + +#endif /*_DALVIK_INTERP_STATE*/ diff --git a/vm/interp/Jit.c b/vm/interp/Jit.c index 6d7ea5266..d5ba07cde 100644 --- a/vm/interp/Jit.c +++ b/vm/interp/Jit.c @@ -56,16 +56,24 @@ void dvmSelfVerificationShadowSpaceFree(Thread* self) } /* - * Save out PC, FP, InterpState, and registers to shadow space. + * Save out PC, FP, thread state, and registers to shadow space. * Return a pointer to the shadow space for JIT to use. + * + * The set of saved state from the Thread structure is: + * pc (Dalvik PC) + * fp (Dalvik FP) + * retval + * method + * methodClassDex + * interpStackEnd */ -void* dvmSelfVerificationSaveState(const u2* pc, const void* fp, - InterpState* interpState, int targetTrace) +void* dvmSelfVerificationSaveState(const u2* pc, u4* fp, + Thread* self, int targetTrace) { - Thread *self = dvmThreadSelf(); ShadowSpace *shadowSpace = self->shadowSpace; - unsigned preBytes = interpState->method->outsSize*4 + sizeof(StackSaveArea); - unsigned postBytes = interpState->method->registersSize*4; + unsigned preBytes = self->interpSave.method->outsSize*4 + + sizeof(StackSaveArea); + unsigned postBytes = self->interpSave.method->registersSize*4; //LOGD("### selfVerificationSaveState(%d) pc: 0x%x fp: 0x%x", // self->threadId, (int)pc, (int)fp); @@ -78,16 +86,16 @@ void* dvmSelfVerificationSaveState(const u2* pc, const void* fp, } shadowSpace->selfVerificationState = kSVSStart; - if (interpState->entryPoint == kInterpEntryResume) { - interpState->entryPoint = kInterpEntryInstr; + if (self->entryPoint == kInterpEntryResume) { + self->entryPoint = kInterpEntryInstr; #if 0 /* Tracking the success rate of resume after single-stepping */ - if (interpState->jitResumeDPC == pc) { + if (self->jitResumeDPC == pc) { LOGD("SV single step resumed at %p", pc); } else { - LOGD("real %p DPC %p NPC %p", pc, interpState->jitResumeDPC, - interpState->jitResumeNPC); + LOGD("real %p DPC %p NPC %p", pc, self->jitResumeDPC, + self->jitResumeNPC); } #endif } @@ -103,19 +111,21 @@ void* dvmSelfVerificationSaveState(const u2* pc, const void* fp, // Remember original state shadowSpace->startPC = pc; shadowSpace->fp = fp; - shadowSpace->glue = interpState; + shadowSpace->retval = self->retval; + shadowSpace->interpStackEnd = self->interpStackEnd; + /* * Store the original method here in case the trace ends with a * return/invoke, the last method. */ - shadowSpace->method = interpState->method; + shadowSpace->method = self->interpSave.method; + shadowSpace->methodClassDex = self->interpSave.methodClassDex; + shadowSpace->shadowFP = shadowSpace->registerSpace + shadowSpace->registerSpaceSize - postBytes/4; - // Create a copy of the InterpState - memcpy(&(shadowSpace->interpState), interpState, sizeof(InterpState)); - shadowSpace->interpState.fp = (u4*)shadowSpace->shadowFP; - shadowSpace->interpState.interpStackEnd = (u1*)shadowSpace->registerSpace; + self->interpSave.fp = (u4*)shadowSpace->shadowFP; + self->interpStackEnd = (u1*)shadowSpace->registerSpace; // Create a copy of the stack memcpy(((char*)shadowSpace->shadowFP)-preBytes, ((char*)fp)-preBytes, @@ -134,13 +144,11 @@ void* dvmSelfVerificationSaveState(const u2* pc, const void* fp, * Save ending PC, FP and compiled code exit point to shadow space. * Return a pointer to the shadow space for JIT to restore state. */ -void* dvmSelfVerificationRestoreState(const u2* pc, const void* fp, - SelfVerificationState exitState) +void* dvmSelfVerificationRestoreState(const u2* pc, u4* fp, + SelfVerificationState exitState, + Thread* self) { - Thread *self = dvmThreadSelf(); ShadowSpace *shadowSpace = self->shadowSpace; - // Official InterpState structure - InterpState *realGlue = (InterpState*)shadowSpace->glue; shadowSpace->endPC = pc; shadowSpace->endShadowFP = fp; shadowSpace->jitExitState = exitState; @@ -160,16 +168,6 @@ void* dvmSelfVerificationRestoreState(const u2* pc, const void* fp, (int)shadowSpace->endShadowFP); } - // Move the resume [ND]PC from the shadow space to the real space so that - // the debug interpreter can return to the translation - if (exitState == kSVSSingleStep) { - realGlue->jitResumeNPC = shadowSpace->interpState.jitResumeNPC; - realGlue->jitResumeDPC = shadowSpace->interpState.jitResumeDPC; - } else { - realGlue->jitResumeNPC = NULL; - realGlue->jitResumeDPC = NULL; - } - // Special case when punting after a single instruction if (exitState == kSVSPunt && pc == shadowSpace->startPC) { shadowSpace->selfVerificationState = kSVSIdle; @@ -200,6 +198,14 @@ void* dvmSelfVerificationRestoreState(const u2* pc, const void* fp, shadowSpace->selfVerificationState = exitState; } + /* Restore state before returning */ + self->interpSave.pc = shadowSpace->startPC; + self->interpSave.fp = shadowSpace->fp; + self->interpSave.method = shadowSpace->method; + self->interpSave.methodClassDex = shadowSpace->methodClassDex; + self->retval = shadowSpace->retval; + self->interpStackEnd = shadowSpace->interpStackEnd; + return shadowSpace; } @@ -223,7 +229,7 @@ static void selfVerificationDumpState(const u2* pc, Thread* self) (int) shadowSpace->shadowFP; int localRegs = 0; int frameBytes2 = 0; - if (self->curFrame < shadowSpace->fp) { + if ((uintptr_t)self->curFrame < (uintptr_t)shadowSpace->fp) { localRegs = (stackSave->method->registersSize - stackSave->method->insSize)*4; frameBytes2 = (int) shadowSpace->fp - (int) self->curFrame - localRegs; @@ -281,8 +287,7 @@ static void selfVerificationSpinLoop(ShadowSpace *shadowSpace) } /* Manage self verification while in the debug interpreter */ -static bool selfVerificationDebugInterp(const u2* pc, Thread* self, - InterpState *interpState) +static bool selfVerificationDebugInterp(const u2* pc, Thread* self) { ShadowSpace *shadowSpace = self->shadowSpace; SelfVerificationState state = shadowSpace->selfVerificationState; @@ -337,7 +342,7 @@ static bool selfVerificationDebugInterp(const u2* pc, Thread* self, selfVerificationSpinLoop(shadowSpace); } /* Check new frame if it exists (invokes only) */ - if (self->curFrame < shadowSpace->fp) { + if ((uintptr_t)self->curFrame < (uintptr_t)shadowSpace->fp) { StackSaveArea* stackSave = SAVEAREA_FROM_FP(self->curFrame); int localRegs = (stackSave->method->registersSize - stackSave->method->insSize)*4; @@ -385,7 +390,7 @@ static bool selfVerificationDebugInterp(const u2* pc, Thread* self, * one more instruction */ if (state == kSVSSingleStep) { - interpState->jitState = kJitSingleStepEnd; + self->jitState = kJitSingleStepEnd; } return true; @@ -418,7 +423,7 @@ void dvmJitStopTranslationRequests() /* * Note 1: This won't necessarily stop all translation requests, and * operates on a delayed mechanism. Running threads look to the copy - * of this value in their private InterpState structures and won't see + * of this value in their private thread structures and won't see * this change until it is refreshed (which happens on interpreter * entry). * Note 2: This is a one-shot memory leak on this table. Because this is a @@ -519,10 +524,10 @@ void dvmJitStats() /* End current trace after last successful instruction */ -void dvmJitEndTraceSelect(InterpState* interpState) +void dvmJitEndTraceSelect(Thread* self) { - if (interpState->jitState == kJitTSelect) - interpState->jitState = kJitTSelectEnd; + if (self->jitState == kJitTSelect) + self->jitState = kJitTSelectEnd; } /* @@ -633,15 +638,15 @@ static JitEntry *lookupAndAdd(const u2* dPC, bool callerLocked, * + thisClass (new) * + calleeMethod (new) */ -static void insertClassMethodInfo(InterpState* interpState, +static void insertClassMethodInfo(Thread* self, const ClassObject* thisClass, const Method* calleeMethod, const DecodedInstruction* insn) { - int currTraceRun = ++interpState->currTraceRun; - interpState->trace[currTraceRun].meta = (void *) thisClass; - currTraceRun = ++interpState->currTraceRun; - interpState->trace[currTraceRun].meta = (void *) calleeMethod; + int currTraceRun = ++self->currTraceRun; + self->trace[currTraceRun].meta = (void *) thisClass; + currTraceRun = ++self->currTraceRun; + self->trace[currTraceRun].meta = (void *) calleeMethod; } /* @@ -657,7 +662,7 @@ static void insertClassMethodInfo(InterpState* interpState, * lastPC, len, offset are all from the preceding invoke instruction */ static void insertMoveResult(const u2 *lastPC, int len, int offset, - InterpState *interpState) + Thread *self) { DecodedInstruction nextDecInsn; const u2 *moveResultPC = lastPC + len; @@ -669,16 +674,16 @@ static void insertMoveResult(const u2 *lastPC, int len, int offset, return; /* We need to start a new trace run */ - int currTraceRun = ++interpState->currTraceRun; - interpState->currRunHead = moveResultPC; - interpState->trace[currTraceRun].frag.startOffset = offset + len; - interpState->trace[currTraceRun].frag.numInsts = 1; - interpState->trace[currTraceRun].frag.runEnd = false; - interpState->trace[currTraceRun].frag.hint = kJitHintNone; - interpState->trace[currTraceRun].frag.isCode = true; - interpState->totalTraceLen++; - - interpState->currRunLen = dexGetWidthFromInstruction(moveResultPC); + int currTraceRun = ++self->currTraceRun; + self->currRunHead = moveResultPC; + self->trace[currTraceRun].frag.startOffset = offset + len; + self->trace[currTraceRun].frag.numInsts = 1; + self->trace[currTraceRun].frag.runEnd = false; + self->trace[currTraceRun].frag.hint = kJitHintNone; + self->trace[currTraceRun].frag.isCode = true; + self->totalTraceLen++; + + self->currRunLen = dexGetWidthFromInstruction(moveResultPC); } /* @@ -697,8 +702,8 @@ static void insertMoveResult(const u2 *lastPC, int len, int offset, * because returns cannot throw in a way that causes problems for the * translated code. */ -int dvmCheckJit(const u2* pc, Thread* self, InterpState* interpState, - const ClassObject* thisClass, const Method* curMethod) +int dvmCheckJit(const u2* pc, Thread* self, const ClassObject* thisClass, + const Method* curMethod) { int flags, len; int switchInterp = false; @@ -712,13 +717,13 @@ int dvmCheckJit(const u2* pc, Thread* self, InterpState* interpState, * Reset the entry point to the default value. If needed it will be set to a * specific value in the corresponding case statement (eg kJitSingleStepEnd) */ - interpState->entryPoint = kInterpEntryInstr; + self->entryPoint = kInterpEntryInstr; /* Prepare to handle last PC and stage the current PC */ - const u2 *lastPC = interpState->lastPC; - interpState->lastPC = pc; + const u2 *lastPC = self->lastPC; + self->lastPC = pc; - switch (interpState->jitState) { + switch (self->jitState) { int offset; DecodedInstruction decInsn; case kJitTSelect: @@ -732,10 +737,10 @@ int dvmCheckJit(const u2* pc, Thread* self, InterpState* interpState, * to the amount of space it takes to generate the chaining * cells. */ - if (interpState->totalTraceLen != 0 && + if (self->totalTraceLen != 0 && (decInsn.opcode == OP_PACKED_SWITCH || decInsn.opcode == OP_SPARSE_SWITCH)) { - interpState->jitState = kJitTSelectEnd; + self->jitState = kJitTSelectEnd; break; } @@ -745,24 +750,24 @@ int dvmCheckJit(const u2* pc, Thread* self, InterpState* interpState, #endif flags = dexGetFlagsFromOpcode(decInsn.opcode); len = dexGetWidthFromInstruction(lastPC); - offset = lastPC - interpState->method->insns; + offset = lastPC - self->interpSave.method->insns; assert((unsigned) offset < - dvmGetMethodInsnsSize(interpState->method)); - if (lastPC != interpState->currRunHead + interpState->currRunLen) { + dvmGetMethodInsnsSize(self->interpSave.method)); + if (lastPC != self->currRunHead + self->currRunLen) { int currTraceRun; /* We need to start a new trace run */ - currTraceRun = ++interpState->currTraceRun; - interpState->currRunLen = 0; - interpState->currRunHead = (u2*)lastPC; - interpState->trace[currTraceRun].frag.startOffset = offset; - interpState->trace[currTraceRun].frag.numInsts = 0; - interpState->trace[currTraceRun].frag.runEnd = false; - interpState->trace[currTraceRun].frag.hint = kJitHintNone; - interpState->trace[currTraceRun].frag.isCode = true; + currTraceRun = ++self->currTraceRun; + self->currRunLen = 0; + self->currRunHead = (u2*)lastPC; + self->trace[currTraceRun].frag.startOffset = offset; + self->trace[currTraceRun].frag.numInsts = 0; + self->trace[currTraceRun].frag.runEnd = false; + self->trace[currTraceRun].frag.hint = kJitHintNone; + self->trace[currTraceRun].frag.isCode = true; } - interpState->trace[interpState->currTraceRun].frag.numInsts++; - interpState->totalTraceLen++; - interpState->currRunLen += len; + self->trace[self->currTraceRun].frag.numInsts++; + self->totalTraceLen++; + self->currRunLen += len; /* * If the last instruction is an invoke, we will try to sneak in @@ -771,9 +776,9 @@ int dvmCheckJit(const u2* pc, Thread* self, InterpState* interpState, int needReservedRun = (flags & kInstrInvoke) ? 1 : 0; /* Will probably never hit this with the current trace buildier */ - if (interpState->currTraceRun == + if (self->currTraceRun == (MAX_JIT_RUN_LEN - 1 - needReservedRun)) { - interpState->jitState = kJitTSelectEnd; + self->jitState = kJitTSelectEnd; } if (!dexIsGoto(flags) && @@ -781,7 +786,7 @@ int dvmCheckJit(const u2* pc, Thread* self, InterpState* interpState, kInstrCanSwitch | kInstrCanReturn | kInstrInvoke)) != 0)) { - interpState->jitState = kJitTSelectEnd; + self->jitState = kJitTSelectEnd; #if defined(SHOW_TRACE) LOGD("TraceGen: ending on %s, basic block end", dexGetOpcodeName(decInsn.opcode)); @@ -794,21 +799,21 @@ int dvmCheckJit(const u2* pc, Thread* self, InterpState* interpState, * it to the trace too. */ if (flags & kInstrInvoke) { - insertClassMethodInfo(interpState, thisClass, curMethod, + insertClassMethodInfo(self, thisClass, curMethod, &decInsn); - insertMoveResult(lastPC, len, offset, interpState); + insertMoveResult(lastPC, len, offset, self); } } /* Break on throw or self-loop */ if ((decInsn.opcode == OP_THROW) || (lastPC == pc)){ - interpState->jitState = kJitTSelectEnd; + self->jitState = kJitTSelectEnd; } - if (interpState->totalTraceLen >= JIT_MAX_TRACE_LEN) { - interpState->jitState = kJitTSelectEnd; + if (self->totalTraceLen >= JIT_MAX_TRACE_LEN) { + self->jitState = kJitTSelectEnd; } /* Abandon the trace request if debugger/profiler is attached */ if (debugOrProfile) { - interpState->jitState = kJitDone; + self->jitState = kJitDone; break; } if ((flags & kInstrCanReturn) != kInstrCanReturn) { @@ -830,51 +835,51 @@ int dvmCheckJit(const u2* pc, Thread* self, InterpState* interpState, case kJitTSelectEnd: { /* Empty trace - set to bail to interpreter */ - if (interpState->totalTraceLen == 0) { - dvmJitSetCodeAddr(interpState->currTraceHead, + if (self->totalTraceLen == 0) { + dvmJitSetCodeAddr(self->currTraceHead, dvmCompilerGetInterpretTemplate(), dvmCompilerGetInterpretTemplateSet(), false /* Not method entry */, 0); - interpState->jitState = kJitDone; + self->jitState = kJitDone; switchInterp = true; break; } - int lastTraceDesc = interpState->currTraceRun; + int lastTraceDesc = self->currTraceRun; /* Extend a new empty desc if the last slot is meta info */ - if (!interpState->trace[lastTraceDesc].frag.isCode) { - lastTraceDesc = ++interpState->currTraceRun; - interpState->trace[lastTraceDesc].frag.startOffset = 0; - interpState->trace[lastTraceDesc].frag.numInsts = 0; - interpState->trace[lastTraceDesc].frag.hint = kJitHintNone; - interpState->trace[lastTraceDesc].frag.isCode = true; + if (!self->trace[lastTraceDesc].frag.isCode) { + lastTraceDesc = ++self->currTraceRun; + self->trace[lastTraceDesc].frag.startOffset = 0; + self->trace[lastTraceDesc].frag.numInsts = 0; + self->trace[lastTraceDesc].frag.hint = kJitHintNone; + self->trace[lastTraceDesc].frag.isCode = true; } /* Mark the end of the trace runs */ - interpState->trace[lastTraceDesc].frag.runEnd = true; + self->trace[lastTraceDesc].frag.runEnd = true; JitTraceDescription* desc = (JitTraceDescription*)malloc(sizeof(JitTraceDescription) + - sizeof(JitTraceRun) * (interpState->currTraceRun+1)); + sizeof(JitTraceRun) * (self->currTraceRun+1)); if (desc == NULL) { LOGE("Out of memory in trace selection"); dvmJitStopTranslationRequests(); - interpState->jitState = kJitDone; + self->jitState = kJitDone; switchInterp = true; break; } - desc->method = interpState->method; + desc->method = self->interpSave.method; memcpy((char*)&(desc->trace[0]), - (char*)&(interpState->trace[0]), - sizeof(JitTraceRun) * (interpState->currTraceRun+1)); + (char*)&(self->trace[0]), + sizeof(JitTraceRun) * (self->currTraceRun+1)); #if defined(SHOW_TRACE) LOGD("TraceGen: trace done, adding to queue"); #endif if (dvmCompilerWorkEnqueue( - interpState->currTraceHead,kWorkOrderTrace,desc)) { + self->currTraceHead,kWorkOrderTrace,desc)) { /* Work order successfully enqueued */ if (gDvmJit.blockingMode) { dvmCompilerDrainQueue(); @@ -886,12 +891,12 @@ int dvmCheckJit(const u2* pc, Thread* self, InterpState* interpState, */ free(desc); } - interpState->jitState = kJitDone; + self->jitState = kJitDone; switchInterp = true; } break; case kJitSingleStep: - interpState->jitState = kJitSingleStepEnd; + self->jitState = kJitSingleStepEnd; break; case kJitSingleStepEnd: /* @@ -902,12 +907,12 @@ int dvmCheckJit(const u2* pc, Thread* self, InterpState* interpState, * cannot be reset. */ if (dvmJitStayInPortableInterpreter()) { - interpState->entryPoint = kInterpEntryInstr; + self->entryPoint = kInterpEntryInstr; self->inJitCodeCache = 0; } else { - interpState->entryPoint = kInterpEntryResume; + self->entryPoint = kInterpEntryResume; } - interpState->jitState = kJitDone; + self->jitState = kJitDone; switchInterp = true; break; case kJitDone: @@ -915,13 +920,13 @@ int dvmCheckJit(const u2* pc, Thread* self, InterpState* interpState, break; #if defined(WITH_SELF_VERIFICATION) case kJitSelfVerification: - if (selfVerificationDebugInterp(pc, self, interpState)) { + if (selfVerificationDebugInterp(pc, self)) { /* * If the next state is not single-step end, we can switch * interpreter now. */ - if (interpState->jitState != kJitSingleStepEnd) { - interpState->jitState = kJitDone; + if (self->jitState != kJitSingleStepEnd) { + self->jitState = kJitDone; switchInterp = true; } } @@ -932,7 +937,7 @@ int dvmCheckJit(const u2* pc, Thread* self, InterpState* interpState, break; default: LOGE("Unexpected JIT state: %d entry point: %d", - interpState->jitState, interpState->entryPoint); + self->jitState, self->entryPoint); dvmAbort(); break; } @@ -940,8 +945,8 @@ int dvmCheckJit(const u2* pc, Thread* self, InterpState* interpState, * Final check to see if we can really switch the interpreter. Make sure * the jitState is kJitDone or kJitNot when switchInterp is set to true. */ - assert(switchInterp == false || interpState->jitState == kJitDone || - interpState->jitState == kJitNot); + assert(switchInterp == false || self->jitState == kJitDone || + self->jitState == kJitNot); return switchInterp && !debugOrProfile && !stayOneMoreInst && !dvmJitStayInPortableInterpreter(); } @@ -1070,7 +1075,7 @@ void dvmJitSetCodeAddr(const u2* dPC, void *nPC, JitInstructionSetType set, * if we need to abort and switch back to the fast interpreter, false * otherwise. */ -bool dvmJitCheckTraceRequest(Thread* self, InterpState* interpState) +bool dvmJitCheckTraceRequest(Thread* self) { bool switchInterp = false; /* Assume success */ int i; @@ -1092,7 +1097,7 @@ bool dvmJitCheckTraceRequest(Thread* self, InterpState* interpState) * number of very hot loops, we would want the second-level filter * to be very selective. A good selective filter is requiring an * exact match of the Dalvik PC. In other words, defining filterKey as: - * intptr_t filterKey = (intptr_t)interpState->pc + * intptr_t filterKey = (intptr_t)self->interpSave.pc * * However, for flat execution profiles we do best when aggressively * translating. A heuristically decent proxy for this is to use @@ -1100,7 +1105,7 @@ bool dvmJitCheckTraceRequest(Thread* self, InterpState* interpState) * Intuitively, this is saying that once any trace in a method appears hot, * immediately translate any other trace from that same method that * survives the first-level filter. Here, filterKey would be defined as: - * intptr_t filterKey = (intptr_t)interpState->method + * intptr_t filterKey = (intptr_t)self->interpSave.method * * The problem is that we can't easily detect whether we're dealing * with a spiky or flat profile. If we go with the "pc" match approach, @@ -1122,9 +1127,9 @@ bool dvmJitCheckTraceRequest(Thread* self, InterpState* interpState) * alignment for method pointers, and half-word alignment of the Dalvik pc. * for method pointers and half-word alignment for dalvik pc. */ - u4 methodKey = (u4)interpState->method << + u4 methodKey = (u4)self->interpSave.method << (JIT_TRACE_THRESH_FILTER_PC_BITS - 2); - u4 pcKey = ((u4)interpState->pc >> 1) & + u4 pcKey = ((u4)self->interpSave.pc >> 1) & ((1 << JIT_TRACE_THRESH_FILTER_PC_BITS) - 1); intptr_t filterKey = (intptr_t)(methodKey | pcKey); bool debugOrProfile = dvmDebuggerOrProfilerActive(); @@ -1132,12 +1137,12 @@ bool dvmJitCheckTraceRequest(Thread* self, InterpState* interpState) /* Check if the JIT request can be handled now */ if (gDvmJit.pJitEntryTable != NULL && debugOrProfile == false) { /* Bypass the filter for hot trace requests or during stress mode */ - if (interpState->jitState == kJitTSelectRequest && + if (self->jitState == kJitTSelectRequest && gDvmJit.threshold > 6) { /* Two-level filtering scheme */ for (i=0; i< JIT_TRACE_THRESH_FILTER_SIZE; i++) { - if (filterKey == interpState->threshFilter[i]) { - interpState->threshFilter[i] = 0; // Reset filter entry + if (filterKey == self->threshFilter[i]) { + self->threshFilter[i] = 0; // Reset filter entry break; } } @@ -1148,27 +1153,27 @@ bool dvmJitCheckTraceRequest(Thread* self, InterpState* interpState) * filter array. */ i = rand() % JIT_TRACE_THRESH_FILTER_SIZE; - interpState->threshFilter[i] = filterKey; - interpState->jitState = kJitDone; + self->threshFilter[i] = filterKey; + self->jitState = kJitDone; } } /* If the compiler is backlogged, cancel any JIT actions */ if (gDvmJit.compilerQueueLength >= gDvmJit.compilerHighWater) { - interpState->jitState = kJitDone; + self->jitState = kJitDone; } /* * Check for additional reasons that might force the trace select * request to be dropped */ - if (interpState->jitState == kJitTSelectRequest || - interpState->jitState == kJitTSelectRequestHot) { - if (dvmJitFindEntry(interpState->pc, false)) { + if (self->jitState == kJitTSelectRequest || + self->jitState == kJitTSelectRequestHot) { + if (dvmJitFindEntry(self->interpSave.pc, false)) { /* In progress - nothing do do */ - interpState->jitState = kJitDone; + self->jitState = kJitDone; } else { - JitEntry *slot = lookupAndAdd(interpState->pc, + JitEntry *slot = lookupAndAdd(self->interpSave.pc, false /* lock */, false /* method entry */); if (slot == NULL) { @@ -1178,29 +1183,29 @@ bool dvmJitCheckTraceRequest(Thread* self, InterpState* interpState) * resized before we run into it here. Assume bad things * are afoot and disable profiling. */ - interpState->jitState = kJitDone; + self->jitState = kJitDone; LOGD("JIT: JitTable full, disabling profiling"); dvmJitStopTranslationRequests(); } } } - switch (interpState->jitState) { + switch (self->jitState) { case kJitTSelectRequest: case kJitTSelectRequestHot: - interpState->jitState = kJitTSelect; - interpState->currTraceHead = interpState->pc; - interpState->currTraceRun = 0; - interpState->totalTraceLen = 0; - interpState->currRunHead = interpState->pc; - interpState->currRunLen = 0; - interpState->trace[0].frag.startOffset = - interpState->pc - interpState->method->insns; - interpState->trace[0].frag.numInsts = 0; - interpState->trace[0].frag.runEnd = false; - interpState->trace[0].frag.hint = kJitHintNone; - interpState->trace[0].frag.isCode = true; - interpState->lastPC = 0; + self->jitState = kJitTSelect; + self->currTraceHead = self->interpSave.pc; + self->currTraceRun = 0; + self->totalTraceLen = 0; + self->currRunHead = self->interpSave.pc; + self->currRunLen = 0; + self->trace[0].frag.startOffset = + self->interpSave.pc - self->interpSave.method->insns; + self->trace[0].frag.numInsts = 0; + self->trace[0].frag.runEnd = false; + self->trace[0].frag.hint = kJitHintNone; + self->trace[0].frag.isCode = true; + self->lastPC = 0; break; /* * For JIT's perspective there is no need to stay in the debug @@ -1211,14 +1216,14 @@ bool dvmJitCheckTraceRequest(Thread* self, InterpState* interpState) break; default: LOGE("Unexpected JIT state: %d entry point: %d", - interpState->jitState, interpState->entryPoint); + self->jitState, self->entryPoint); dvmAbort(); } } else { /* * Cannot build trace this time - ready to leave the dbg interpreter */ - interpState->jitState = kJitDone; + self->jitState = kJitDone; switchInterp = true; } @@ -1226,7 +1231,7 @@ bool dvmJitCheckTraceRequest(Thread* self, InterpState* interpState) * Final check to see if we can really switch the interpreter. Make sure * the jitState is kJitDone when switchInterp is set to true. */ - assert(switchInterp == false || interpState->jitState == kJitDone); + assert(switchInterp == false || self->jitState == kJitDone); return switchInterp && !debugOrProfile && !dvmJitStayInPortableInterpreter(); } diff --git a/vm/interp/Jit.h b/vm/interp/Jit.h index c49b3658e..1565c4760 100644 --- a/vm/interp/Jit.h +++ b/vm/interp/Jit.h @@ -41,13 +41,15 @@ typedef struct InstructionTrace { typedef struct ShadowSpace { const u2* startPC; /* starting pc of jitted region */ - const void* fp; /* starting fp of jitted region */ - void* glue; /* starting glue of jitted region */ + u4* fp; /* starting fp of jitted region */ + const Method *method; + DvmDex* methodClassDex; + JValue retval; + const u1* interpStackEnd; SelfVerificationState jitExitState; /* exit point for JIT'ed code */ SelfVerificationState selfVerificationState; /* current SV running state */ const u2* endPC; /* ending pc of jitted region */ void* shadowFP; /* pointer to fp in shadow space */ - InterpState interpState; /* copy of interpState */ int* registerSpace; /* copy of register state */ int registerSpaceSize; /* current size of register space */ ShadowHeap heapSpace[HEAP_SPACE]; /* copy of heap space */ @@ -55,7 +57,6 @@ typedef struct ShadowSpace { 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,11 +64,12 @@ typedef struct ShadowSpace { */ void* dvmSelfVerificationShadowSpaceAlloc(Thread* self); void dvmSelfVerificationShadowSpaceFree(Thread* self); -void* dvmSelfVerificationSaveState(const u2* pc, const void* fp, - InterpState* interpState, +void* dvmSelfVerificationSaveState(const u2* pc, u4* fp, + Thread* self, int targetTrace); -void* dvmSelfVerificationRestoreState(const u2* pc, const void* fp, - SelfVerificationState exitPoint); +void* dvmSelfVerificationRestoreState(const u2* pc, u4* fp, + SelfVerificationState exitPoint, + Thread *self); #endif /* @@ -132,11 +134,11 @@ typedef struct JitEntry { void* codeAddress; /* Code address of native translation */ } JitEntry; -int dvmCheckJit(const u2* pc, Thread* self, InterpState* interpState, - const ClassObject *callsiteClass, const Method* curMethod); +int dvmCheckJit(const u2* pc, Thread* self, const ClassObject *callsiteClass, + const Method* curMethod); void* dvmJitGetTraceAddr(const u2* dPC); void* dvmJitGetMethodAddr(const u2* dPC); -bool dvmJitCheckTraceRequest(Thread* self, InterpState* interpState); +bool dvmJitCheckTraceRequest(Thread* self); void dvmJitStopTranslationRequests(void); void dvmJitStats(void); bool dvmJitResizeJitTable(unsigned int size); @@ -146,7 +148,7 @@ s8 dvmJitd2l(double d); s8 dvmJitf2l(float f); void dvmJitSetCodeAddr(const u2* dPC, void *nPC, JitInstructionSetType set, bool isMethodEntry, int profilePrefixSize); -void dvmJitEndTraceSelect(InterpState* interpState); +void dvmJitEndTraceSelect(Thread* self); JitTraceCounter_t *dvmJitNextTraceCounter(void); void dvmJitTraceProfilingOff(void); void dvmJitTraceProfilingOn(void); diff --git a/vm/mterp/Mterp.c b/vm/mterp/Mterp.c index 907618eb5..1f7052c2f 100644 --- a/vm/mterp/Mterp.c +++ b/vm/mterp/Mterp.c @@ -61,56 +61,51 @@ bool dvmCheckAsmConstants(void) /* - * "Standard" mterp entry point. This sets up a "glue" structure and then - * calls into the assembly interpreter implementation. - * + * "Standard" mterp entry point. * (There is presently no "debug" entry point.) */ -bool dvmMterpStd(Thread* self, InterpState* glue) +bool dvmMterpStd(Thread* self) { int changeInterp; /* configure mterp items */ - glue->self = self; - glue->methodClassDex = glue->method->clazz->pDvmDex; + self->interpSave.methodClassDex = self->interpSave.method->clazz->pDvmDex; - glue->interpStackEnd = self->interpStackEnd; - glue->pSelfSuspendCount = &self->suspendCount; - glue->cardTable = gDvm.biasedCardTableBase; #if defined(WITH_JIT) - glue->pJitProfTable = gDvmJit.pProfTable; - glue->ppJitProfTable = &gDvmJit.pProfTable; - glue->jitThreshold = gDvmJit.threshold; - glue->jitCacheStart = gDvmJit.codeCache; - glue->jitCacheEnd = (char*)gDvmJit.codeCache + gDvmJit.codeCacheSize; - glue->pProfileCountdown = &gDvmJit.profileCountdown; + /* + * FIXME: temporary workaround. When we have the ability to + * walk through the thread list to initialize mterp & JIT state, + * elminate this line. + */ + self->jitThreshold = gDvmJit.threshold; #endif - glue->pInterpBreak = &gDvm.interpBreak; /* Handle method entry bookkeeping */ - if (glue->debugIsMethodEntry) { - glue->debugIsMethodEntry = false; - TRACE_METHOD_ENTER(self, glue->method); + if (self->debugIsMethodEntry) { + self->debugIsMethodEntry = false; + TRACE_METHOD_ENTER(self, self->interpSave.method); } IF_LOGVV() { - char* desc = dexProtoCopyMethodDescriptor(&glue->method->prototype); + char* desc = dexProtoCopyMethodDescriptor( + &self->interpSave.method->prototype); LOGVV("mterp threadid=%d entry %d: %s.%s %s\n", dvmThreadSelf()->threadId, - glue->entryPoint, - glue->method->clazz->descriptor, - glue->method->name, + self->entryPoint, + self->method->clazz->descriptor, + self->method->name, desc); free(desc); } - //LOGI("glue is %p, pc=%p, fp=%p\n", glue, glue->pc, glue->fp); - //LOGI("first instruction is 0x%04x\n", glue->pc[0]); + //LOGI("self is %p, pc=%p, fp=%p\n", self, self->interpSave.pc, + // self->interpSave.fp); + //LOGI("first instruction is 0x%04x\n", self->interpSave.pc[0]); - changeInterp = dvmMterpStdRun(glue); + changeInterp = dvmMterpStdRun(self); #if defined(WITH_JIT) - if (glue->jitState != kJitSingleStep) { - glue->self->inJitCodeCache = NULL; + if (self->jitState != kJitSingleStep) { + self->inJitCodeCache = NULL; } #endif @@ -123,7 +118,7 @@ bool dvmMterpStd(Thread* self, InterpState* glue) } else { /* we're "standard", so switch to "debug" */ LOGVV(" mterp returned, changeInterp=%d\n", changeInterp); - glue->nextMode = INTERP_DBG; + self->nextMode = INTERP_DBG; return true; } } diff --git a/vm/mterp/Mterp.h b/vm/mterp/Mterp.h index 8b3f7b48b..69e5a2c57 100644 --- a/vm/mterp/Mterp.h +++ b/vm/mterp/Mterp.h @@ -26,13 +26,6 @@ #include "interp/Jit.h" #endif -/* - * Interpreter state, passed into C functions from assembly stubs. The - * assembly code exports all registers into the "glue" structure before - * calling, then extracts them when the call returns. - */ -typedef InterpState MterpGlue; - /* * Call this during initialization to verify that the values in asm-constants.h * are still correct. @@ -49,7 +42,7 @@ bool dvmCheckAsmConstants(void); * * The "mterp" interpreter is always "standard". */ -bool dvmMterpStdRun(MterpGlue* glue); -void dvmMterpStdBail(MterpGlue* glue, bool changeInterp); +bool dvmMterpStdRun(Thread* self); +void dvmMterpStdBail(Thread* self, bool changeInterp); #endif /*_DALVIK_MTERP_MTERP*/ diff --git a/vm/mterp/armv5te/OP_APUT_OBJECT.S b/vm/mterp/armv5te/OP_APUT_OBJECT.S index 00b3cc80e..8d9a84cdf 100644 --- a/vm/mterp/armv5te/OP_APUT_OBJECT.S +++ b/vm/mterp/armv5te/OP_APUT_OBJECT.S @@ -35,7 +35,7 @@ beq .L${opcode}_throw @ no mov r1, rINST @ r1<- arrayObj FETCH_ADVANCE_INST(2) @ advance rPC, load rINST - ldr r2, [rGLUE, #offGlue_cardTable] @ get biased CT base + ldr r2, [rSELF, #offThread_cardTable] @ get biased CT base add r10, #offArrayObject_contents @ r0<- pointer to slot GET_INST_OPCODE(ip) @ extract opcode from rINST str r9, [r10] @ vBB[vCC]<- vAA diff --git a/vm/mterp/armv5te/OP_CHECK_CAST.S b/vm/mterp/armv5te/OP_CHECK_CAST.S index 3a07ea38a..57df60e90 100644 --- a/vm/mterp/armv5te/OP_CHECK_CAST.S +++ b/vm/mterp/armv5te/OP_CHECK_CAST.S @@ -12,7 +12,7 @@ mov r3, rINST, lsr #8 @ r3<- AA FETCH(r2, 1) @ r2<- BBBB GET_VREG(r9, r3) @ r9<- object - ldr r0, [rGLUE, #offGlue_methodClassDex] @ r0<- pDvmDex + ldr r0, [rSELF, #offThread_methodClassDex] @ r0<- pDvmDex cmp r9, #0 @ is object null? ldr r0, [r0, #offDvmDex_pResClasses] @ r0<- pDvmDex->pResClasses beq .L${opcode}_okay @ null obj, cast always succeeds @@ -56,7 +56,7 @@ */ .L${opcode}_resolve: EXPORT_PC() @ resolve() could throw - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r1, r2 @ r1<- BBBB mov r2, #0 @ r2<- false ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz diff --git a/vm/mterp/armv5te/OP_CHECK_CAST_JUMBO.S b/vm/mterp/armv5te/OP_CHECK_CAST_JUMBO.S index 233057adf..3140ec408 100644 --- a/vm/mterp/armv5te/OP_CHECK_CAST_JUMBO.S +++ b/vm/mterp/armv5te/OP_CHECK_CAST_JUMBO.S @@ -14,7 +14,7 @@ FETCH(r3, 3) @ r3<- BBBB orr r2, r0, r2, lsl #16 @ r2<- AAAAaaaa GET_VREG(r9, r3) @ r9<- object - ldr r0, [rGLUE, #offGlue_methodClassDex] @ r0<- pDvmDex + ldr r0, [rSELF, #offThread_methodClassDex] @ r0<- pDvmDex cmp r9, #0 @ is object null? ldr r0, [r0, #offDvmDex_pResClasses] @ r0<- pDvmDex->pResClasses beq .L${opcode}_okay @ null obj, cast always succeeds @@ -63,7 +63,7 @@ */ .L${opcode}_resolve: EXPORT_PC() @ resolve() could throw - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r1, r2 @ r1<- AAAAAAAA mov r2, #0 @ r2<- false ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz diff --git a/vm/mterp/armv5te/OP_CONST_CLASS.S b/vm/mterp/armv5te/OP_CONST_CLASS.S index 665e58298..9256bf97e 100644 --- a/vm/mterp/armv5te/OP_CONST_CLASS.S +++ b/vm/mterp/armv5te/OP_CONST_CLASS.S @@ -4,7 +4,7 @@ %verify "Class cannot be resolved" /* const/class vAA, Class@BBBB */ FETCH(r1, 1) @ r1<- BBBB - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- glue->methodClassDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- self->methodClassDex mov r9, rINST, lsr #8 @ r9<- AA ldr r2, [r2, #offDvmDex_pResClasses] @ r2<- dvmDex->pResClasses ldr r0, [r2, r1, lsl #2] @ r0<- pResClasses[BBBB] @@ -23,7 +23,7 @@ */ .L${opcode}_resolve: EXPORT_PC() - ldr r0, [rGLUE, #offGlue_method] @ r0<- glue->method + ldr r0, [rSELF, #offThread_method] @ r0<- self->method mov r2, #1 @ r2<- true ldr r0, [r0, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveClass @ r0<- Class reference diff --git a/vm/mterp/armv5te/OP_CONST_CLASS_JUMBO.S b/vm/mterp/armv5te/OP_CONST_CLASS_JUMBO.S index afefd8a3d..4dd973ee2 100644 --- a/vm/mterp/armv5te/OP_CONST_CLASS_JUMBO.S +++ b/vm/mterp/armv5te/OP_CONST_CLASS_JUMBO.S @@ -4,7 +4,7 @@ %verify "Class cannot be resolved" /* const-class/jumbo vBBBB, Class@AAAAAAAA */ FETCH(r0, 1) @ r0<- aaaa (lo) - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- glue->methodClassDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<-self>methodClassDex FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResClasses] @ r2<- dvmDex->pResClasses orr r1, r0, r1, lsl #16 @ r1<- AAAAaaaa @@ -25,7 +25,7 @@ */ .L${opcode}_resolve: EXPORT_PC() - ldr r0, [rGLUE, #offGlue_method] @ r0<- glue->method + ldr r0, [rSELF, #offThread_method] @ r0<- self->method mov r2, #1 @ r2<- true ldr r0, [r0, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveClass @ r0<- Class reference diff --git a/vm/mterp/armv5te/OP_CONST_STRING.S b/vm/mterp/armv5te/OP_CONST_STRING.S index 2df3fdaba..bad36e46f 100644 --- a/vm/mterp/armv5te/OP_CONST_STRING.S +++ b/vm/mterp/armv5te/OP_CONST_STRING.S @@ -4,7 +4,7 @@ %verify "String cannot be resolved" /* const/string vAA, String@BBBB */ FETCH(r1, 1) @ r1<- BBBB - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- glue->methodClassDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- self->methodClassDex mov r9, rINST, lsr #8 @ r9<- AA ldr r2, [r2, #offDvmDex_pResStrings] @ r2<- dvmDex->pResStrings ldr r0, [r2, r1, lsl #2] @ r0<- pResStrings[BBBB] @@ -23,7 +23,7 @@ */ .L${opcode}_resolve: EXPORT_PC() - ldr r0, [rGLUE, #offGlue_method] @ r0<- glue->method + ldr r0, [rSELF, #offThread_method] @ r0<- self->method ldr r0, [r0, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveString @ r0<- String reference cmp r0, #0 @ failed? diff --git a/vm/mterp/armv5te/OP_CONST_STRING_JUMBO.S b/vm/mterp/armv5te/OP_CONST_STRING_JUMBO.S index cf9b00991..05897f756 100644 --- a/vm/mterp/armv5te/OP_CONST_STRING_JUMBO.S +++ b/vm/mterp/armv5te/OP_CONST_STRING_JUMBO.S @@ -5,7 +5,7 @@ /* const/string vAA, String@BBBBBBBB */ FETCH(r0, 1) @ r0<- bbbb (low) FETCH(r1, 2) @ r1<- BBBB (high) - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- glue->methodClassDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- self->methodClassDex mov r9, rINST, lsr #8 @ r9<- AA ldr r2, [r2, #offDvmDex_pResStrings] @ r2<- dvmDex->pResStrings orr r1, r0, r1, lsl #16 @ r1<- BBBBbbbb @@ -25,7 +25,7 @@ */ .L${opcode}_resolve: EXPORT_PC() - ldr r0, [rGLUE, #offGlue_method] @ r0<- glue->method + ldr r0, [rSELF, #offThread_method] @ r0<- self->method ldr r0, [r0, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveString @ r0<- String reference cmp r0, #0 @ failed? diff --git a/vm/mterp/armv5te/OP_EXECUTE_INLINE.S b/vm/mterp/armv5te/OP_EXECUTE_INLINE.S index d29523d28..e97ff3651 100644 --- a/vm/mterp/armv5te/OP_EXECUTE_INLINE.S +++ b/vm/mterp/armv5te/OP_EXECUTE_INLINE.S @@ -12,11 +12,11 @@ */ /* [opt] execute-inline vAA, {vC, vD, vE, vF}, inline@BBBB */ FETCH(r10, 1) @ r10<- BBBB - add r1, rGLUE, #offGlue_retval @ r1<- &glue->retval + add r1, rSELF, #offThread_retval @ r1<- &self->retval EXPORT_PC() @ can throw sub sp, sp, #8 @ make room for arg, +64 bit align mov r0, rINST, lsr #12 @ r0<- B - str r1, [sp] @ push &glue->retval + str r1, [sp] @ push &self->retval bl .L${opcode}_continue @ make call; will return after add sp, sp, #8 @ pop stack cmp r0, #0 @ test boolean result of inline diff --git a/vm/mterp/armv5te/OP_EXECUTE_INLINE_RANGE.S b/vm/mterp/armv5te/OP_EXECUTE_INLINE_RANGE.S index 38ab35b62..7ef2400de 100644 --- a/vm/mterp/armv5te/OP_EXECUTE_INLINE_RANGE.S +++ b/vm/mterp/armv5te/OP_EXECUTE_INLINE_RANGE.S @@ -13,11 +13,11 @@ */ /* [opt] execute-inline/range {vCCCC..v(CCCC+AA-1)}, inline@BBBB */ FETCH(r10, 1) @ r10<- BBBB - add r1, rGLUE, #offGlue_retval @ r1<- &glue->retval + add r1, rSELF, #offThread_retval @ r1<- &self->retval EXPORT_PC() @ can throw sub sp, sp, #8 @ make room for arg, +64 bit align mov r0, rINST, lsr #8 @ r0<- AA - str r1, [sp] @ push &glue->retval + str r1, [sp] @ push &self->retval bl .L${opcode}_continue @ make call; will return after add sp, sp, #8 @ pop stack cmp r0, #0 @ test boolean result of inline diff --git a/vm/mterp/armv5te/OP_FILLED_NEW_ARRAY.S b/vm/mterp/armv5te/OP_FILLED_NEW_ARRAY.S index 5bb2d43b3..41a62a25c 100644 --- a/vm/mterp/armv5te/OP_FILLED_NEW_ARRAY.S +++ b/vm/mterp/armv5te/OP_FILLED_NEW_ARRAY.S @@ -8,7 +8,7 @@ */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op {vCCCC..v(CCCC+AA-1)}, type@BBBB */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r1, 1) @ r1<- BBBB ldr r3, [r3, #offDvmDex_pResClasses] @ r3<- pDvmDex->pResClasses EXPORT_PC() @ need for resolve and alloc @@ -16,7 +16,7 @@ mov r10, rINST, lsr #8 @ r10<- AA or BA cmp r0, #0 @ already resolved? bne .L${opcode}_continue @ yes, continue on -8: ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method +8: ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r2, #0 @ r2<- false ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveClass @ r0<- call(clazz, ref) @@ -49,8 +49,8 @@ beq common_exceptionThrown @ alloc failed, handle exception FETCH(r1, 2) @ r1<- FEDC or CCCC - str r0, [rGLUE, #offGlue_retval] @ retval.l <- new array - str rINST, [rGLUE, #offGlue_retval+4] @ retval.h <- type + str r0, [rSELF, #offThread_retval] @ retval.l <- new array + str rINST, [rSELF, #offThread_retval+4] @ retval.h <- type add r0, r0, #offArrayObject_contents @ r0<- newArray->contents subs r9, r9, #1 @ length--, check for neg FETCH_ADVANCE_INST(3) @ advance to next instr, load rINST @@ -82,9 +82,9 @@ .endif 2: - ldr r0, [rGLUE, #offGlue_retval] @ r0<- object - ldr r1, [rGLUE, #offGlue_retval+4] @ r1<- type - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r0, [rSELF, #offThread_retval] @ r0<- object + ldr r1, [rSELF, #offThread_retval+4] @ r1<- type + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base GET_INST_OPCODE(ip) @ ip<- opcode from rINST cmp r1, #'I' @ Is int array? strneb r2, [r2, r0, lsr #GC_CARD_SHIFT] @ Mark card based on object head diff --git a/vm/mterp/armv5te/OP_FILLED_NEW_ARRAY_JUMBO.S b/vm/mterp/armv5te/OP_FILLED_NEW_ARRAY_JUMBO.S index aefd4dac1..0c43cc8bb 100644 --- a/vm/mterp/armv5te/OP_FILLED_NEW_ARRAY_JUMBO.S +++ b/vm/mterp/armv5te/OP_FILLED_NEW_ARRAY_JUMBO.S @@ -7,7 +7,7 @@ * OP_FILLED_NEW_ARRAY.S. */ /* filled-new-array/jumbo {vCCCC..v(CCCC+BBBB-1)}, type@AAAAAAAA */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r3, [r3, #offDvmDex_pResClasses] @ r3<- pDvmDex->pResClasses @@ -16,7 +16,7 @@ EXPORT_PC() @ need for resolve and alloc cmp r0, #0 @ already resolved? bne .L${opcode}_continue @ yes, continue on -8: ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method +8: ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r2, #0 @ r2<- false ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveClass @ r0<- call(clazz, ref) @@ -44,8 +44,8 @@ beq common_exceptionThrown @ alloc failed, handle exception FETCH(r1, 4) @ r1<- CCCC - str r0, [rGLUE, #offGlue_retval] @ retval.l <- new array - str rINST, [rGLUE, #offGlue_retval+4] @ retval.h <- type + str r0, [rSELF, #offThread_retval] @ retval.l <- new array + str rINST, [rSELF, #offThread_retval+4] @ retval.h <- type add r0, r0, #offArrayObject_contents @ r0<- newArray->contents subs r9, r9, #1 @ length--, check for neg FETCH_ADVANCE_INST(5) @ advance to next instr, load rINST @@ -59,9 +59,9 @@ str r3, [r0], #4 @ *contents++ = vX bpl 1b -2: ldr r0, [rGLUE, #offGlue_retval] @ r0<- object - ldr r1, [rGLUE, #offGlue_retval+4] @ r1<- type - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base +2: ldr r0, [rSELF, #offThread_retval] @ r0<- object + ldr r1, [rSELF, #offThread_retval+4] @ r1<- type + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base GET_INST_OPCODE(ip) @ ip<- opcode from rINST cmp r1, #'I' @ Is int array? strneb r2, [r2, r0, lsr #GC_CARD_SHIFT] @ Mark card based on object head diff --git a/vm/mterp/armv5te/OP_IGET.S b/vm/mterp/armv5te/OP_IGET.S index b9cdee435..a81467cb1 100644 --- a/vm/mterp/armv5te/OP_IGET.S +++ b/vm/mterp/armv5te/OP_IGET.S @@ -11,14 +11,14 @@ */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .L${opcode}_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr diff --git a/vm/mterp/armv5te/OP_IGET_JUMBO.S b/vm/mterp/armv5te/OP_IGET_JUMBO.S index 6636111e5..6ed201faa 100644 --- a/vm/mterp/armv5te/OP_IGET_JUMBO.S +++ b/vm/mterp/armv5te/OP_IGET_JUMBO.S @@ -14,14 +14,14 @@ FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .L${opcode}_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr diff --git a/vm/mterp/armv5te/OP_IGET_WIDE.S b/vm/mterp/armv5te/OP_IGET_WIDE.S index 95944de17..c73edfd13 100644 --- a/vm/mterp/armv5te/OP_IGET_WIDE.S +++ b/vm/mterp/armv5te/OP_IGET_WIDE.S @@ -9,14 +9,14 @@ */ /* iget-wide vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .L${opcode}_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr diff --git a/vm/mterp/armv5te/OP_IGET_WIDE_JUMBO.S b/vm/mterp/armv5te/OP_IGET_WIDE_JUMBO.S index 912f85e46..edba5e1bd 100644 --- a/vm/mterp/armv5te/OP_IGET_WIDE_JUMBO.S +++ b/vm/mterp/armv5te/OP_IGET_WIDE_JUMBO.S @@ -10,14 +10,14 @@ FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .L${opcode}_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr diff --git a/vm/mterp/armv5te/OP_INSTANCE_OF.S b/vm/mterp/armv5te/OP_INSTANCE_OF.S index 66f0df342..73911b174 100644 --- a/vm/mterp/armv5te/OP_INSTANCE_OF.S +++ b/vm/mterp/armv5te/OP_INSTANCE_OF.S @@ -17,7 +17,7 @@ GET_VREG(r0, r3) @ r0<- vB (object) and r9, r9, #15 @ r9<- A cmp r0, #0 @ is object null? - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- pDvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- pDvmDex beq .L${opcode}_store @ null obj, not an instance, store r0 FETCH(r3, 1) @ r3<- CCCC ldr r2, [r2, #offDvmDex_pResClasses] @ r2<- pDvmDex->pResClasses @@ -71,7 +71,7 @@ */ .L${opcode}_resolve: EXPORT_PC() @ resolve() could throw - ldr r0, [rGLUE, #offGlue_method] @ r0<- glue->method + ldr r0, [rSELF, #offThread_method] @ r0<- self->method mov r1, r3 @ r1<- BBBB mov r2, #1 @ r2<- true ldr r0, [r0, #offMethod_clazz] @ r0<- method->clazz diff --git a/vm/mterp/armv5te/OP_INSTANCE_OF_JUMBO.S b/vm/mterp/armv5te/OP_INSTANCE_OF_JUMBO.S index 57345ba80..1de1222cd 100644 --- a/vm/mterp/armv5te/OP_INSTANCE_OF_JUMBO.S +++ b/vm/mterp/armv5te/OP_INSTANCE_OF_JUMBO.S @@ -18,7 +18,7 @@ FETCH(r3, 4) @ r3<- vCCCC FETCH(r9, 3) @ r9<- vBBBB GET_VREG(r0, r3) @ r0<- vCCCC (object) - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- pDvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- pDvmDex cmp r0, #0 @ is object null? beq .L${opcode}_store @ null obj, not an instance, store r0 FETCH(r1, 1) @ r1<- aaaa (lo) @@ -84,7 +84,7 @@ .L${opcode}_resolve: EXPORT_PC() @ resolve() could throw - ldr r0, [rGLUE, #offGlue_method] @ r0<- glue->method + ldr r0, [rSELF, #offThread_method] @ r0<- self->method mov r1, r3 @ r1<- AAAAAAAA mov r2, #1 @ r2<- true ldr r0, [r0, #offMethod_clazz] @ r0<- method->clazz diff --git a/vm/mterp/armv5te/OP_INVOKE_DIRECT.S b/vm/mterp/armv5te/OP_INVOKE_DIRECT.S index 14ba8f77a..15b173f01 100644 --- a/vm/mterp/armv5te/OP_INVOKE_DIRECT.S +++ b/vm/mterp/armv5te/OP_INVOKE_DIRECT.S @@ -13,7 +13,7 @@ */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r1, 1) @ r1<- BBBB ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods FETCH(r10, 2) @ r10<- GFED or CCCC @@ -37,7 +37,7 @@ * r10 = "this" register */ .L${opcode}_resolve: - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_DIRECT @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) diff --git a/vm/mterp/armv5te/OP_INVOKE_DIRECT_JUMBO.S b/vm/mterp/armv5te/OP_INVOKE_DIRECT_JUMBO.S index 72538891e..5613fbbae 100644 --- a/vm/mterp/armv5te/OP_INVOKE_DIRECT_JUMBO.S +++ b/vm/mterp/armv5te/OP_INVOKE_DIRECT_JUMBO.S @@ -10,7 +10,7 @@ * */ /* invoke-direct/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r0, 1) @ r1<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods @@ -33,7 +33,7 @@ * r10 = "this" register */ .L${opcode}_resolve: - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_DIRECT @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) diff --git a/vm/mterp/armv5te/OP_INVOKE_INTERFACE.S b/vm/mterp/armv5te/OP_INVOKE_INTERFACE.S index 7d52454b5..3149775b8 100644 --- a/vm/mterp/armv5te/OP_INVOKE_INTERFACE.S +++ b/vm/mterp/armv5te/OP_INVOKE_INTERFACE.S @@ -16,9 +16,9 @@ .endif EXPORT_PC() @ must export for invoke GET_VREG(r0, r2) @ r0<- first arg ("this") - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- methodClassDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- methodClassDex cmp r0, #0 @ null obj? - ldr r2, [rGLUE, #offGlue_method] @ r2<- method + ldr r2, [rSELF, #offThread_method] @ r2<- method beq common_errNullObject @ yes, fail ldr r0, [r0, #offObject_clazz] @ r0<- thisPtr->clazz bl dvmFindInterfaceMethodInCache @ r0<- call(class, ref, method, dex) diff --git a/vm/mterp/armv5te/OP_INVOKE_INTERFACE_JUMBO.S b/vm/mterp/armv5te/OP_INVOKE_INTERFACE_JUMBO.S index 3e26b80da..930d7d51c 100644 --- a/vm/mterp/armv5te/OP_INVOKE_INTERFACE_JUMBO.S +++ b/vm/mterp/armv5te/OP_INVOKE_INTERFACE_JUMBO.S @@ -11,9 +11,9 @@ EXPORT_PC() @ must export for invoke orr r1, r0, r1, lsl #16 @ r1<- AAAAaaaa GET_VREG(r0, r2) @ r0<- first arg ("this") - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- methodClassDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- methodClassDex cmp r0, #0 @ null obj? - ldr r2, [rGLUE, #offGlue_method] @ r2<- method + ldr r2, [rSELF, #offThread_method] @ r2<- method beq common_errNullObject @ yes, fail ldr r0, [r0, #offObject_clazz] @ r0<- thisPtr->clazz bl dvmFindInterfaceMethodInCache @ r0<- call(class, ref, method, dex) diff --git a/vm/mterp/armv5te/OP_INVOKE_STATIC.S b/vm/mterp/armv5te/OP_INVOKE_STATIC.S index cb359e63b..47718c6db 100644 --- a/vm/mterp/armv5te/OP_INVOKE_STATIC.S +++ b/vm/mterp/armv5te/OP_INVOKE_STATIC.S @@ -8,14 +8,14 @@ */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r1, 1) @ r1<- BBBB ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods ldr r0, [r3, r1, lsl #2] @ r0<- resolved methodToCall cmp r0, #0 @ already resolved? EXPORT_PC() @ must export for invoke bne common_invokeMethod${routine} @ yes, continue on -0: ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method +0: ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_STATIC @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) diff --git a/vm/mterp/armv5te/OP_INVOKE_STATIC_JUMBO.S b/vm/mterp/armv5te/OP_INVOKE_STATIC_JUMBO.S index 18eb7305c..3d045348c 100644 --- a/vm/mterp/armv5te/OP_INVOKE_STATIC_JUMBO.S +++ b/vm/mterp/armv5te/OP_INVOKE_STATIC_JUMBO.S @@ -4,7 +4,7 @@ * Handle a static method call. */ /* invoke-static/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r0, 1) @ r1<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods @@ -13,7 +13,7 @@ cmp r0, #0 @ already resolved? EXPORT_PC() @ must export for invoke bne common_invokeMethodJumbo @ yes, continue on -0: ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method +0: ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_STATIC @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) diff --git a/vm/mterp/armv5te/OP_INVOKE_SUPER.S b/vm/mterp/armv5te/OP_INVOKE_SUPER.S index 6117947b4..bf3458c1a 100644 --- a/vm/mterp/armv5te/OP_INVOKE_SUPER.S +++ b/vm/mterp/armv5te/OP_INVOKE_SUPER.S @@ -9,7 +9,7 @@ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ FETCH(r10, 2) @ r10<- GFED or CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex .if (!$isrange) and r10, r10, #15 @ r10<- D (or stays CCCC) .endif @@ -18,7 +18,7 @@ GET_VREG(r2, r10) @ r2<- "this" ptr ldr r0, [r3, r1, lsl #2] @ r0<- resolved baseMethod cmp r2, #0 @ null "this"? - ldr r9, [rGLUE, #offGlue_method] @ r9<- current method + ldr r9, [rSELF, #offThread_method] @ r9<- current method beq common_errNullObject @ null "this", throw exception cmp r0, #0 @ already resolved? ldr r9, [r9, #offMethod_clazz] @ r9<- method->clazz diff --git a/vm/mterp/armv5te/OP_INVOKE_SUPER_JUMBO.S b/vm/mterp/armv5te/OP_INVOKE_SUPER_JUMBO.S index c72428d2a..85327cc6d 100644 --- a/vm/mterp/armv5te/OP_INVOKE_SUPER_JUMBO.S +++ b/vm/mterp/armv5te/OP_INVOKE_SUPER_JUMBO.S @@ -5,7 +5,7 @@ */ /* invoke-super/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ FETCH(r10, 4) @ r10<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r0, 1) @ r1<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods @@ -13,7 +13,7 @@ GET_VREG(r2, r10) @ r2<- "this" ptr ldr r0, [r3, r1, lsl #2] @ r0<- resolved baseMethod cmp r2, #0 @ null "this"? - ldr r9, [rGLUE, #offGlue_method] @ r9<- current method + ldr r9, [rSELF, #offThread_method] @ r9<- current method beq common_errNullObject @ null "this", throw exception cmp r0, #0 @ already resolved? ldr r9, [r9, #offMethod_clazz] @ r9<- method->clazz diff --git a/vm/mterp/armv5te/OP_INVOKE_SUPER_QUICK.S b/vm/mterp/armv5te/OP_INVOKE_SUPER_QUICK.S index bd07d0680..e967b46b3 100644 --- a/vm/mterp/armv5te/OP_INVOKE_SUPER_QUICK.S +++ b/vm/mterp/armv5te/OP_INVOKE_SUPER_QUICK.S @@ -9,7 +9,7 @@ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ FETCH(r10, 2) @ r10<- GFED or CCCC - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method .if (!$isrange) and r10, r10, #15 @ r10<- D (or stays CCCC) .endif diff --git a/vm/mterp/armv5te/OP_INVOKE_VIRTUAL.S b/vm/mterp/armv5te/OP_INVOKE_VIRTUAL.S index d92c6a991..371006bf6 100644 --- a/vm/mterp/armv5te/OP_INVOKE_VIRTUAL.S +++ b/vm/mterp/armv5te/OP_INVOKE_VIRTUAL.S @@ -9,7 +9,7 @@ */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r1, 1) @ r1<- BBBB ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods FETCH(r10, 2) @ r10<- GFED or CCCC @@ -20,7 +20,7 @@ cmp r0, #0 @ already resolved? EXPORT_PC() @ must export for invoke bne .L${opcode}_continue @ yes, continue on - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_VIRTUAL @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) diff --git a/vm/mterp/armv5te/OP_INVOKE_VIRTUAL_JUMBO.S b/vm/mterp/armv5te/OP_INVOKE_VIRTUAL_JUMBO.S index 14c90c85a..3d770724c 100644 --- a/vm/mterp/armv5te/OP_INVOKE_VIRTUAL_JUMBO.S +++ b/vm/mterp/armv5te/OP_INVOKE_VIRTUAL_JUMBO.S @@ -5,7 +5,7 @@ * Handle a virtual method call. */ /* invoke-virtual/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r0, 1) @ r1<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods @@ -14,7 +14,7 @@ cmp r0, #0 @ already resolved? EXPORT_PC() @ must export for invoke bne .L${opcode}_continue @ yes, continue on - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_VIRTUAL @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) diff --git a/vm/mterp/armv5te/OP_IPUT.S b/vm/mterp/armv5te/OP_IPUT.S index 53f4b4e2f..13836fb0e 100644 --- a/vm/mterp/armv5te/OP_IPUT.S +++ b/vm/mterp/armv5te/OP_IPUT.S @@ -11,14 +11,14 @@ */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .L${opcode}_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr diff --git a/vm/mterp/armv5te/OP_IPUT_JUMBO.S b/vm/mterp/armv5te/OP_IPUT_JUMBO.S index 5f05e4a3c..2c11dac07 100644 --- a/vm/mterp/armv5te/OP_IPUT_JUMBO.S +++ b/vm/mterp/armv5te/OP_IPUT_JUMBO.S @@ -14,14 +14,14 @@ FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .L${opcode}_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr diff --git a/vm/mterp/armv5te/OP_IPUT_OBJECT.S b/vm/mterp/armv5te/OP_IPUT_OBJECT.S index 079094e9b..7cab4c5f1 100644 --- a/vm/mterp/armv5te/OP_IPUT_OBJECT.S +++ b/vm/mterp/armv5te/OP_IPUT_OBJECT.S @@ -11,14 +11,14 @@ */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .L${opcode}_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -39,7 +39,7 @@ and r1, r1, #15 @ r1<- A cmp r9, #0 @ check object for null GET_VREG(r0, r1) @ r0<- fp[A] - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base beq common_errNullObject @ object was null FETCH_ADVANCE_INST(2) @ advance rPC, load rINST GET_INST_OPCODE(ip) @ extract opcode from rINST diff --git a/vm/mterp/armv5te/OP_IPUT_OBJECT_JUMBO.S b/vm/mterp/armv5te/OP_IPUT_OBJECT_JUMBO.S index 97186aa92..11b6d689b 100644 --- a/vm/mterp/armv5te/OP_IPUT_OBJECT_JUMBO.S +++ b/vm/mterp/armv5te/OP_IPUT_OBJECT_JUMBO.S @@ -11,14 +11,14 @@ FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .L${opcode}_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -46,7 +46,7 @@ FETCH(r1, 3) @ r1<- BBBB cmp r9, #0 @ check object for null GET_VREG(r0, r1) @ r0<- fp[BBBB] - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base beq common_errNullObject @ object was null FETCH_ADVANCE_INST(5) @ advance rPC, load rINST GET_INST_OPCODE(ip) @ extract opcode from rINST diff --git a/vm/mterp/armv5te/OP_IPUT_OBJECT_QUICK.S b/vm/mterp/armv5te/OP_IPUT_OBJECT_QUICK.S index 7e7144a02..7bf9b21ef 100644 --- a/vm/mterp/armv5te/OP_IPUT_OBJECT_QUICK.S +++ b/vm/mterp/armv5te/OP_IPUT_OBJECT_QUICK.S @@ -10,7 +10,7 @@ beq common_errNullObject @ object was null and r2, r2, #15 GET_VREG(r0, r2) @ r0<- fp[A] - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base FETCH_ADVANCE_INST(2) @ advance rPC, load rINST str r0, [r3, r1] @ obj.field (always 32 bits)<- r0 cmp r0, #0 diff --git a/vm/mterp/armv5te/OP_IPUT_WIDE.S b/vm/mterp/armv5te/OP_IPUT_WIDE.S index 8796cbbcc..d9a6fc3c5 100644 --- a/vm/mterp/armv5te/OP_IPUT_WIDE.S +++ b/vm/mterp/armv5te/OP_IPUT_WIDE.S @@ -6,14 +6,14 @@ %verify "field cannot be resolved" /* iput-wide vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .L${opcode}_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr diff --git a/vm/mterp/armv5te/OP_IPUT_WIDE_JUMBO.S b/vm/mterp/armv5te/OP_IPUT_WIDE_JUMBO.S index ea7d24e95..c8151fc88 100644 --- a/vm/mterp/armv5te/OP_IPUT_WIDE_JUMBO.S +++ b/vm/mterp/armv5te/OP_IPUT_WIDE_JUMBO.S @@ -7,14 +7,14 @@ FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .L${opcode}_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr diff --git a/vm/mterp/armv5te/OP_MONITOR_ENTER.S b/vm/mterp/armv5te/OP_MONITOR_ENTER.S index b3f74b07c..ba5a1440b 100644 --- a/vm/mterp/armv5te/OP_MONITOR_ENTER.S +++ b/vm/mterp/armv5te/OP_MONITOR_ENTER.S @@ -6,7 +6,7 @@ /* monitor-enter vAA */ mov r2, rINST, lsr #8 @ r2<- AA GET_VREG(r1, r2) @ r1<- vAA (object) - ldr r0, [rGLUE, #offGlue_self] @ r0<- glue->self + mov r0, rSELF @ r0<- self cmp r1, #0 @ null object? EXPORT_PC() @ need for precise GC beq common_errNullObject @ null object, throw an exception diff --git a/vm/mterp/armv5te/OP_MONITOR_EXIT.S b/vm/mterp/armv5te/OP_MONITOR_EXIT.S index 5c1b3c740..9f36f0e5b 100644 --- a/vm/mterp/armv5te/OP_MONITOR_EXIT.S +++ b/vm/mterp/armv5te/OP_MONITOR_EXIT.S @@ -14,7 +14,7 @@ GET_VREG(r1, r2) @ r1<- vAA (object) cmp r1, #0 @ null object? beq 1f @ yes - ldr r0, [rGLUE, #offGlue_self] @ r0<- glue->self + mov r0, rSELF @ r0<- self bl dvmUnlockObject @ r0<- success for unlock(self, obj) cmp r0, #0 @ failed? FETCH_ADVANCE_INST(1) @ before throw: advance rPC, load rINST diff --git a/vm/mterp/armv5te/OP_MOVE_EXCEPTION.S b/vm/mterp/armv5te/OP_MOVE_EXCEPTION.S index f9e4cff94..e2fc66fcc 100644 --- a/vm/mterp/armv5te/OP_MOVE_EXCEPTION.S +++ b/vm/mterp/armv5te/OP_MOVE_EXCEPTION.S @@ -1,11 +1,10 @@ %verify "executed" /* move-exception vAA */ - ldr r0, [rGLUE, #offGlue_self] @ r0<- glue->self mov r2, rINST, lsr #8 @ r2<- AA - ldr r3, [r0, #offThread_exception] @ r3<- dvmGetException bypass + ldr r3, [rSELF, #offThread_exception] @ r3<- dvmGetException bypass mov r1, #0 @ r1<- 0 FETCH_ADVANCE_INST(1) @ advance rPC, load rINST SET_VREG(r3, r2) @ fp[AA]<- exception obj GET_INST_OPCODE(ip) @ extract opcode from rINST - str r1, [r0, #offThread_exception] @ dvmClearException bypass + str r1, [rSELF, #offThread_exception] @ dvmClearException bypass GOTO_OPCODE(ip) @ jump to next instruction diff --git a/vm/mterp/armv5te/OP_MOVE_RESULT.S b/vm/mterp/armv5te/OP_MOVE_RESULT.S index 9de84017a..72377f880 100644 --- a/vm/mterp/armv5te/OP_MOVE_RESULT.S +++ b/vm/mterp/armv5te/OP_MOVE_RESULT.S @@ -3,7 +3,7 @@ /* op vAA */ mov r2, rINST, lsr #8 @ r2<- AA FETCH_ADVANCE_INST(1) @ advance rPC, load rINST - ldr r0, [rGLUE, #offGlue_retval] @ r0<- glue->retval.i + ldr r0, [rSELF, #offThread_retval] @ r0<- self->retval.i GET_INST_OPCODE(ip) @ extract opcode from rINST SET_VREG(r0, r2) @ fp[AA]<- r0 GOTO_OPCODE(ip) @ jump to next instruction diff --git a/vm/mterp/armv5te/OP_MOVE_RESULT_WIDE.S b/vm/mterp/armv5te/OP_MOVE_RESULT_WIDE.S index 92f744316..4eb019869 100644 --- a/vm/mterp/armv5te/OP_MOVE_RESULT_WIDE.S +++ b/vm/mterp/armv5te/OP_MOVE_RESULT_WIDE.S @@ -1,7 +1,7 @@ %verify "executed" /* move-result-wide vAA */ mov r2, rINST, lsr #8 @ r2<- AA - add r3, rGLUE, #offGlue_retval @ r3<- &glue->retval + add r3, rSELF, #offThread_retval @ r3<- &self->retval add r2, rFP, r2, lsl #2 @ r2<- &fp[AA] ldmia r3, {r0-r1} @ r0/r1<- retval.j FETCH_ADVANCE_INST(1) @ advance rPC, load rINST diff --git a/vm/mterp/armv5te/OP_NEW_ARRAY.S b/vm/mterp/armv5te/OP_NEW_ARRAY.S index da93c45ce..a9c4e93aa 100644 --- a/vm/mterp/armv5te/OP_NEW_ARRAY.S +++ b/vm/mterp/armv5te/OP_NEW_ARRAY.S @@ -11,7 +11,7 @@ /* new-array vA, vB, class@CCCC */ mov r0, rINST, lsr #12 @ r0<- B FETCH(r2, 1) @ r2<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex GET_VREG(r1, r0) @ r1<- vB (array length) ldr r3, [r3, #offDvmDex_pResClasses] @ r3<- pDvmDex->pResClasses cmp r1, #0 @ check length @@ -31,7 +31,7 @@ * r2 holds class ref CCCC */ .L${opcode}_resolve: - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r9, r1 @ r9<- length (save) mov r1, r2 @ r1<- CCCC mov r2, #0 @ r2<- false diff --git a/vm/mterp/armv5te/OP_NEW_ARRAY_JUMBO.S b/vm/mterp/armv5te/OP_NEW_ARRAY_JUMBO.S index c1cea24b7..e0e10ae6f 100644 --- a/vm/mterp/armv5te/OP_NEW_ARRAY_JUMBO.S +++ b/vm/mterp/armv5te/OP_NEW_ARRAY_JUMBO.S @@ -13,7 +13,7 @@ FETCH(r3, 2) @ r3<- AAAA (hi) FETCH(r0, 4) @ r0<- vCCCC orr r2, r2, r3, lsl #16 @ r2<- AAAAaaaa - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex GET_VREG(r1, r0) @ r1<- vCCCC (array length) ldr r3, [r3, #offDvmDex_pResClasses] @ r3<- pDvmDex->pResClasses cmp r1, #0 @ check length @@ -33,7 +33,7 @@ * r2 holds class ref AAAAAAAA */ .L${opcode}_resolve: - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r9, r1 @ r9<- length (save) mov r1, r2 @ r1<- AAAAAAAA mov r2, #0 @ r2<- false diff --git a/vm/mterp/armv5te/OP_NEW_INSTANCE.S b/vm/mterp/armv5te/OP_NEW_INSTANCE.S index 2687e550e..cb9ce6854 100644 --- a/vm/mterp/armv5te/OP_NEW_INSTANCE.S +++ b/vm/mterp/armv5te/OP_NEW_INSTANCE.S @@ -10,7 +10,7 @@ * Create a new instance of a class. */ /* new-instance vAA, class@BBBB */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r1, 1) @ r1<- BBBB ldr r3, [r3, #offDvmDex_pResClasses] @ r3<- pDvmDex->pResClasses ldr r0, [r3, r1, lsl #2] @ r0<- resolved class @@ -56,7 +56,7 @@ * r1 holds BBBB */ .L${opcode}_resolve: - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r2, #0 @ r2<- false ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveClass @ r0<- resolved ClassObject ptr diff --git a/vm/mterp/armv5te/OP_NEW_INSTANCE_JUMBO.S b/vm/mterp/armv5te/OP_NEW_INSTANCE_JUMBO.S index d4f8b3328..fad14a8df 100644 --- a/vm/mterp/armv5te/OP_NEW_INSTANCE_JUMBO.S +++ b/vm/mterp/armv5te/OP_NEW_INSTANCE_JUMBO.S @@ -12,7 +12,7 @@ /* new-instance/jumbo vBBBB, class@AAAAAAAA */ FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex orr r1, r0, r1, lsl #16 @ r1<- AAAAaaaa ldr r3, [r3, #offDvmDex_pResClasses] @ r3<- pDvmDex->pResClasses ldr r0, [r3, r1, lsl #2] @ r0<- resolved class @@ -58,7 +58,7 @@ * r1 holds AAAAAAAA */ .L${opcode}_resolve: - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r2, #0 @ r2<- false ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveClass @ r0<- resolved ClassObject ptr diff --git a/vm/mterp/armv5te/OP_RETURN.S b/vm/mterp/armv5te/OP_RETURN.S index 8838182ec..5f7350a3d 100644 --- a/vm/mterp/armv5te/OP_RETURN.S +++ b/vm/mterp/armv5te/OP_RETURN.S @@ -1,6 +1,6 @@ %verify "executed" /* - * Return a 32-bit value. Copies the return value into the "glue" + * Return a 32-bit value. Copies the return value into the "thread" * structure, then jumps to the return handler. * * for: return, return-object @@ -8,5 +8,5 @@ /* op vAA */ mov r2, rINST, lsr #8 @ r2<- AA GET_VREG(r0, r2) @ r0<- vAA - str r0, [rGLUE, #offGlue_retval] @ retval.i <- vAA + str r0, [rSELF, #offThread_retval] @ retval.i <- vAA b common_returnFromMethod diff --git a/vm/mterp/armv5te/OP_RETURN_WIDE.S b/vm/mterp/armv5te/OP_RETURN_WIDE.S index 33880de7c..c1850779d 100644 --- a/vm/mterp/armv5te/OP_RETURN_WIDE.S +++ b/vm/mterp/armv5te/OP_RETURN_WIDE.S @@ -1,12 +1,12 @@ %verify "executed" /* - * Return a 64-bit value. Copies the return value into the "glue" + * Return a 64-bit value. Copies the return value into the "thread" * structure, then jumps to the return handler. */ /* return-wide vAA */ mov r2, rINST, lsr #8 @ r2<- AA add r2, rFP, r2, lsl #2 @ r2<- &fp[AA] - add r3, rGLUE, #offGlue_retval @ r3<- &glue->retval + add r3, rSELF, #offThread_retval @ r3<- &self->retval ldmia r2, {r0-r1} @ r0/r1 <- vAA/vAA+1 stmia r3, {r0-r1} @ retval<- r0/r1 b common_returnFromMethod diff --git a/vm/mterp/armv5te/OP_SGET.S b/vm/mterp/armv5te/OP_SGET.S index c803d2708..14fc63a57 100644 --- a/vm/mterp/armv5te/OP_SGET.S +++ b/vm/mterp/armv5te/OP_SGET.S @@ -9,7 +9,7 @@ * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -30,7 +30,7 @@ * r1: BBBB field ref */ .L${opcode}_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr diff --git a/vm/mterp/armv5te/OP_SGET_JUMBO.S b/vm/mterp/armv5te/OP_SGET_JUMBO.S index afb558e6f..374b34c6c 100644 --- a/vm/mterp/armv5te/OP_SGET_JUMBO.S +++ b/vm/mterp/armv5te/OP_SGET_JUMBO.S @@ -10,7 +10,7 @@ * sget-char/jumbo, sget-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -33,7 +33,7 @@ * r1: AAAAAAAA field ref */ .L${opcode}_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr diff --git a/vm/mterp/armv5te/OP_SGET_WIDE.S b/vm/mterp/armv5te/OP_SGET_WIDE.S index 768b9da59..73105c62f 100644 --- a/vm/mterp/armv5te/OP_SGET_WIDE.S +++ b/vm/mterp/armv5te/OP_SGET_WIDE.S @@ -7,7 +7,7 @@ * 64-bit SGET handler. */ /* sget-wide vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -35,7 +35,7 @@ * Returns StaticField pointer in r0. */ .L${opcode}_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr diff --git a/vm/mterp/armv5te/OP_SGET_WIDE_JUMBO.S b/vm/mterp/armv5te/OP_SGET_WIDE_JUMBO.S index 3eb37e6d2..6479a67df 100644 --- a/vm/mterp/armv5te/OP_SGET_WIDE_JUMBO.S +++ b/vm/mterp/armv5te/OP_SGET_WIDE_JUMBO.S @@ -6,7 +6,7 @@ * Jumbo 64-bit SGET handler. */ /* sget-wide/jumbo vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -31,7 +31,7 @@ * Returns StaticField pointer in r0. */ .L${opcode}_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr diff --git a/vm/mterp/armv5te/OP_SPUT.S b/vm/mterp/armv5te/OP_SPUT.S index e709b2256..0208ccc4d 100644 --- a/vm/mterp/armv5te/OP_SPUT.S +++ b/vm/mterp/armv5te/OP_SPUT.S @@ -9,7 +9,7 @@ * for: sput, sput-boolean, sput-byte, sput-char, sput-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -30,7 +30,7 @@ * r1: BBBB field ref */ .L${opcode}_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr diff --git a/vm/mterp/armv5te/OP_SPUT_JUMBO.S b/vm/mterp/armv5te/OP_SPUT_JUMBO.S index 0f9234f01..7011b67fb 100644 --- a/vm/mterp/armv5te/OP_SPUT_JUMBO.S +++ b/vm/mterp/armv5te/OP_SPUT_JUMBO.S @@ -10,7 +10,7 @@ * sput-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -33,7 +33,7 @@ * r1: AAAAAAAA field ref */ .L${opcode}_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr diff --git a/vm/mterp/armv5te/OP_SPUT_OBJECT.S b/vm/mterp/armv5te/OP_SPUT_OBJECT.S index fe9fa4c33..8e0c16df6 100644 --- a/vm/mterp/armv5te/OP_SPUT_OBJECT.S +++ b/vm/mterp/armv5te/OP_SPUT_OBJECT.S @@ -9,13 +9,13 @@ * for: sput-object, sput-object-volatile */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr cmp r0, #0 @ is resolved entry null? bne .L${opcode}_finish @ no, continue - ldr r9, [rGLUE, #offGlue_method] @ r9<- current method + ldr r9, [rSELF, #offThread_method] @ r9<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r9, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -28,7 +28,7 @@ mov r2, rINST, lsr #8 @ r2<- AA FETCH_ADVANCE_INST(2) @ advance rPC, load rINST GET_VREG(r1, r2) @ r1<- fp[AA] - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base ldr r9, [r0, #offField_clazz] @ r9<- field->clazz GET_INST_OPCODE(ip) @ extract opcode from rINST $barrier @ releasing store diff --git a/vm/mterp/armv5te/OP_SPUT_OBJECT_JUMBO.S b/vm/mterp/armv5te/OP_SPUT_OBJECT_JUMBO.S index e2b23c2d6..e10c79360 100644 --- a/vm/mterp/armv5te/OP_SPUT_OBJECT_JUMBO.S +++ b/vm/mterp/armv5te/OP_SPUT_OBJECT_JUMBO.S @@ -7,7 +7,7 @@ * Jumbo 32-bit SPUT handler for objects */ /* sput-object/jumbo vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -15,7 +15,7 @@ ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr cmp r0, #0 @ is resolved entry null? bne .L${opcode}_finish @ no, continue - ldr r9, [rGLUE, #offGlue_method] @ r9<- current method + ldr r9, [rSELF, #offThread_method] @ r9<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r9, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -28,7 +28,7 @@ FETCH(r2, 3) @ r2<- BBBB FETCH_ADVANCE_INST(4) @ advance rPC, load rINST GET_VREG(r1, r2) @ r1<- fp[BBBB] - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base ldr r9, [r0, #offField_clazz] @ r9<- field->clazz GET_INST_OPCODE(ip) @ extract opcode from rINST $barrier @ releasing store diff --git a/vm/mterp/armv5te/OP_SPUT_WIDE.S b/vm/mterp/armv5te/OP_SPUT_WIDE.S index 330c72b2c..1f650f255 100644 --- a/vm/mterp/armv5te/OP_SPUT_WIDE.S +++ b/vm/mterp/armv5te/OP_SPUT_WIDE.S @@ -7,7 +7,7 @@ * 64-bit SPUT handler. */ /* sput-wide vAA, field@BBBB */ - ldr r0, [rGLUE, #offGlue_methodClassDex] @ r0<- DvmDex + ldr r0, [rSELF, #offThread_methodClassDex] @ r0<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r0, [r0, #offDvmDex_pResFields] @ r0<- dvmDex->pResFields mov r9, rINST, lsr #8 @ r9<- AA @@ -36,7 +36,7 @@ * Returns StaticField pointer in r2. */ .L${opcode}_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr diff --git a/vm/mterp/armv5te/OP_SPUT_WIDE_JUMBO.S b/vm/mterp/armv5te/OP_SPUT_WIDE_JUMBO.S index 1e659044b..87abc580a 100644 --- a/vm/mterp/armv5te/OP_SPUT_WIDE_JUMBO.S +++ b/vm/mterp/armv5te/OP_SPUT_WIDE_JUMBO.S @@ -6,7 +6,7 @@ * Jumbo 64-bit SPUT handler. */ /* sput-wide/jumbo vBBBB, field@AAAAAAAA */ - ldr r0, [rGLUE, #offGlue_methodClassDex] @ r0<- DvmDex + ldr r0, [rSELF, #offThread_methodClassDex] @ r0<- DvmDex FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) ldr r0, [r0, #offDvmDex_pResFields] @ r0<- dvmDex->pResFields @@ -32,7 +32,7 @@ * Returns StaticField pointer in r2. */ .L${opcode}_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr diff --git a/vm/mterp/armv5te/OP_THROW.S b/vm/mterp/armv5te/OP_THROW.S index dd0a0b8bd..6e157b422 100644 --- a/vm/mterp/armv5te/OP_THROW.S +++ b/vm/mterp/armv5te/OP_THROW.S @@ -6,10 +6,9 @@ /* throw vAA */ mov r2, rINST, lsr #8 @ r2<- AA GET_VREG(r1, r2) @ r1<- vAA (exception object) - ldr r0, [rGLUE, #offGlue_self] @ r0<- glue->self EXPORT_PC() @ exception handler can throw cmp r1, #0 @ null object? beq common_errNullObject @ yes, throw an NPE instead @ bypass dvmSetException, just store it - str r1, [r0, #offThread_exception] @ thread->exception<- obj + str r1, [rSELF, #offThread_exception] @ thread->exception<- obj b common_exceptionThrown diff --git a/vm/mterp/armv5te/OP_THROW_VERIFICATION_ERROR.S b/vm/mterp/armv5te/OP_THROW_VERIFICATION_ERROR.S index 8bd4f356f..afe9fd866 100644 --- a/vm/mterp/armv5te/OP_THROW_VERIFICATION_ERROR.S +++ b/vm/mterp/armv5te/OP_THROW_VERIFICATION_ERROR.S @@ -5,7 +5,7 @@ * exception is indicated by AA, with some detail provided by BBBB. */ /* op AA, ref@BBBB */ - ldr r0, [rGLUE, #offGlue_method] @ r0<- glue->method + ldr r0, [rSELF, #offThread_method] @ r0<- self->method FETCH(r2, 1) @ r2<- BBBB EXPORT_PC() @ export the PC mov r1, rINST, lsr #8 @ r1<- AA diff --git a/vm/mterp/armv5te/OP_THROW_VERIFICATION_ERROR_JUMBO.S b/vm/mterp/armv5te/OP_THROW_VERIFICATION_ERROR_JUMBO.S index fb6e5923f..f42ba76b9 100644 --- a/vm/mterp/armv5te/OP_THROW_VERIFICATION_ERROR_JUMBO.S +++ b/vm/mterp/armv5te/OP_THROW_VERIFICATION_ERROR_JUMBO.S @@ -7,7 +7,7 @@ /* exop BBBB, Class@AAAAAAAA */ FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) - ldr r0, [rGLUE, #offGlue_method] @ r0<- glue->method + ldr r0, [rSELF, #offThread_method] @ r0<- self->method orr r2, r1, r2, lsl #16 @ r2<- AAAAaaaa EXPORT_PC() @ export the PC FETCH(r1, 3) @ r1<- BBBB diff --git a/vm/mterp/armv5te/debug.c b/vm/mterp/armv5te/debug.c index 9f893fe56..1b546180b 100644 --- a/vm/mterp/armv5te/debug.c +++ b/vm/mterp/armv5te/debug.c @@ -12,7 +12,7 @@ void dvmMterpDumpArmRegs(uint32_t r0, uint32_t r1, uint32_t r2, uint32_t r3) { register uint32_t rPC asm("r4"); register uint32_t rFP asm("r5"); - register uint32_t rGLUE asm("r6"); + register uint32_t rSELF asm("r6"); register uint32_t rINST asm("r7"); register uint32_t rIBASE asm("r8"); register uint32_t r9 asm("r9"); @@ -21,12 +21,12 @@ void dvmMterpDumpArmRegs(uint32_t r0, uint32_t r1, uint32_t r2, uint32_t r3) //extern char dvmAsmInstructionStart[]; printf("REGS: r0=%08x r1=%08x r2=%08x r3=%08x\n", r0, r1, r2, r3); - printf(" : rPC=%08x rFP=%08x rGLUE=%08x rINST=%08x\n", - rPC, rFP, rGLUE, rINST); + printf(" : rPC=%08x rFP=%08x rSELF=%08x rINST=%08x\n", + rPC, rFP, rSELF, rINST); printf(" : rIBASE=%08x r9=%08x r10=%08x\n", rIBASE, r9, r10); - //MterpGlue* glue = (MterpGlue*) rGLUE; - //const Method* method = glue->method; + //Thread* self = (Thread*) rSELF; + //const Method* method = self->method; printf(" + self is %p\n", dvmThreadSelf()); //printf(" + currently in %s.%s %s\n", // method->clazz->descriptor, method->name, method->shorty); diff --git a/vm/mterp/armv5te/entry.S b/vm/mterp/armv5te/entry.S index 12721c04b..14543a37a 100644 --- a/vm/mterp/armv5te/entry.S +++ b/vm/mterp/armv5te/entry.S @@ -38,7 +38,7 @@ /* * On entry: - * r0 MterpGlue* glue + * r0 Thread* self * * This function returns a boolean "changeInterp" value. The return comes * via a call to dvmMterpStdBail(). @@ -56,29 +56,28 @@ dvmMterpStdRun: MTERP_ENTRY2 /* save stack pointer, add magic word for debuggerd */ - str sp, [r0, #offGlue_bailPtr] @ save SP for eventual return + str sp, [r0, #offThread_bailPtr] @ save SP for eventual return /* set up "named" registers, figure out entry point */ - mov rGLUE, r0 @ set rGLUE - ldr r1, [r0, #offGlue_entryPoint] @ enum is 4 bytes in aapcs-EABI - LOAD_PC_FP_FROM_GLUE() @ load rPC and rFP from "glue" + mov rSELF, r0 @ set rSELF + ldr r1, [r0, #offThread_entryPoint] @ enum is 4 bytes in aapcs-EABI + LOAD_PC_FP_FROM_SELF() @ load rPC and rFP from "thread" adr rIBASE, dvmAsmInstructionStart @ set rIBASE cmp r1, #kInterpEntryInstr @ usual case? bne .Lnot_instr @ no, handle it #if defined(WITH_JIT) .LentryInstr: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self /* Entry is always a possible trace start */ GET_JIT_PROF_TABLE(r0) FETCH_INST() mov r1, #0 @ prepare the value for the new state - str r1, [r10, #offThread_inJitCodeCache] @ back to the interp land + str r1, [rSELF, #offThread_inJitCodeCache] @ back to the interp land cmp r0,#0 @ is profiling disabled? #if !defined(WITH_SELF_VERIFICATION) bne common_updateProfile @ profiling is enabled #else - ldr r2, [r10, #offThread_shadowSpace] @ to find out the jit exit state + ldr r2, [rSELF, #offThread_shadowSpace] @ to find out the jit exit state beq 1f @ profiling is disabled ldr r3, [r2, #offShadowSpace_jitExitState] @ jit exit state cmp r3, #kSVSTraceSelect @ hot trace following? @@ -108,20 +107,20 @@ dvmMterpStdRun: #if defined(WITH_JIT) .Lnot_throw: - ldr r10,[rGLUE, #offGlue_jitResumeNPC] - ldr r2,[rGLUE, #offGlue_jitResumeDPC] + ldr r10,[rSELF, #offThread_jitResumeNPC] + ldr r2,[rSELF, #offThread_jitResumeDPC] cmp r1, #kInterpEntryResume @ resuming after Jit single-step? bne .Lbad_arg cmp rPC,r2 bne .LentryInstr @ must have branched, don't resume #if defined(WITH_SELF_VERIFICATION) - @ glue->entryPoint will be set in dvmSelfVerificationSaveState + @ self->entryPoint will be set in dvmSelfVerificationSaveState b jitSVShadowRunStart @ re-enter the translation after the @ single-stepped instruction @noreturn #endif mov r1, #kInterpEntryInstr - str r1, [rGLUE, #offGlue_entryPoint] + str r1, [rSELF, #offThread_entryPoint] bx r10 @ re-enter the translation #endif @@ -147,11 +146,11 @@ dvmMterpStdRun: * LR to PC. * * On entry: - * r0 MterpGlue* glue + * r0 Thread* self * r1 bool changeInterp */ dvmMterpStdBail: - ldr sp, [r0, #offGlue_bailPtr] @ sp<- saved SP + ldr sp, [r0, #offThread_bailPtr] @ sp<- saved SP mov r0, r1 @ return the changeInterp value add sp, sp, #4 @ un-align 64 ldmfd sp!, {r4-r10,fp,pc} @ restore 9 regs and return diff --git a/vm/mterp/armv5te/footer.S b/vm/mterp/armv5te/footer.S index 1081a1e22..50fbda634 100644 --- a/vm/mterp/armv5te/footer.S +++ b/vm/mterp/armv5te/footer.S @@ -14,71 +14,64 @@ #if defined(WITH_SELF_VERIFICATION) .global dvmJitToInterpPunt dvmJitToInterpPunt: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self mov r2,#kSVSPunt @ r2<- interpreter entry point mov r3, #0 - str r3, [r10, #offThread_inJitCodeCache] @ Back to the interp land + str r3, [rSELF, #offThread_inJitCodeCache] @ Back to the interp land b jitSVShadowRunEnd @ doesn't return .global dvmJitToInterpSingleStep dvmJitToInterpSingleStep: - str lr,[rGLUE,#offGlue_jitResumeNPC] - str r1,[rGLUE,#offGlue_jitResumeDPC] + str lr,[rSELF,#offThread_jitResumeNPC] + str r1,[rSELF,#offThread_jitResumeDPC] mov r2,#kSVSSingleStep @ r2<- interpreter entry point b jitSVShadowRunEnd @ doesn't return .global dvmJitToInterpNoChainNoProfile dvmJitToInterpNoChainNoProfile: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self mov r0,rPC @ pass our target PC mov r2,#kSVSNoProfile @ r2<- interpreter entry point mov r3, #0 @ 0 means !inJitCodeCache - str r3, [r10, #offThread_inJitCodeCache] @ back to the interp land + str r3, [rSELF, #offThread_inJitCodeCache] @ back to the interp land b jitSVShadowRunEnd @ doesn't return .global dvmJitToInterpTraceSelectNoChain dvmJitToInterpTraceSelectNoChain: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self mov r0,rPC @ pass our target PC mov r2,#kSVSTraceSelect @ r2<- interpreter entry point mov r3, #0 @ 0 means !inJitCodeCache - str r3, [r10, #offThread_inJitCodeCache] @ Back to the interp land + str r3, [rSELF, #offThread_inJitCodeCache] @ Back to the interp land b jitSVShadowRunEnd @ doesn't return .global dvmJitToInterpTraceSelect dvmJitToInterpTraceSelect: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self ldr r0,[lr, #-1] @ pass our target PC mov r2,#kSVSTraceSelect @ r2<- interpreter entry point mov r3, #0 @ 0 means !inJitCodeCache - str r3, [r10, #offThread_inJitCodeCache] @ Back to the interp land + str r3, [rSELF, #offThread_inJitCodeCache] @ Back to the interp land b jitSVShadowRunEnd @ doesn't return .global dvmJitToInterpBackwardBranch dvmJitToInterpBackwardBranch: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self ldr r0,[lr, #-1] @ pass our target PC mov r2,#kSVSBackwardBranch @ r2<- interpreter entry point mov r3, #0 @ 0 means !inJitCodeCache - str r3, [r10, #offThread_inJitCodeCache] @ Back to the interp land + str r3, [rSELF, #offThread_inJitCodeCache] @ Back to the interp land b jitSVShadowRunEnd @ doesn't return .global dvmJitToInterpNormal dvmJitToInterpNormal: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self ldr r0,[lr, #-1] @ pass our target PC mov r2,#kSVSNormal @ r2<- interpreter entry point mov r3, #0 @ 0 means !inJitCodeCache - str r3, [r10, #offThread_inJitCodeCache] @ Back to the interp land + str r3, [rSELF, #offThread_inJitCodeCache] @ Back to the interp land b jitSVShadowRunEnd @ doesn't return .global dvmJitToInterpNoChain dvmJitToInterpNoChain: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self mov r0,rPC @ pass our target PC mov r2,#kSVSNoChain @ r2<- interpreter entry point mov r3, #0 @ 0 means !inJitCodeCache - str r3, [r10, #offThread_inJitCodeCache] @ Back to the interp land + str r3, [rSELF, #offThread_inJitCodeCache] @ Back to the interp land b jitSVShadowRunEnd @ doesn't return #else /* @@ -90,7 +83,6 @@ dvmJitToInterpNoChain: */ .global dvmJitToInterpPunt dvmJitToInterpPunt: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self mov rPC, r0 #if defined(WITH_JIT_TUNING) mov r0,lr @@ -98,7 +90,7 @@ dvmJitToInterpPunt: #endif EXPORT_PC() mov r0, #0 - str r0, [r10, #offThread_inJitCodeCache] @ Back to the interp land + str r0, [rSELF, #offThread_inJitCodeCache] @ Back to the interp land adrl rIBASE, dvmAsmInstructionStart FETCH_INST() GET_INST_OPCODE(ip) @@ -113,17 +105,17 @@ dvmJitToInterpPunt: */ .global dvmJitToInterpSingleStep dvmJitToInterpSingleStep: - str lr,[rGLUE,#offGlue_jitResumeNPC] - str r1,[rGLUE,#offGlue_jitResumeDPC] + str lr,[rSELF,#offThread_jitResumeNPC] + str r1,[rSELF,#offThread_jitResumeDPC] mov r1,#kInterpEntryInstr @ enum is 4 byte in aapcs-EABI - str r1, [rGLUE, #offGlue_entryPoint] + str r1, [rSELF, #offThread_entryPoint] mov rPC,r0 EXPORT_PC() adrl rIBASE, dvmAsmInstructionStart mov r2,#kJitSingleStep @ Ask for single step and then revert - str r2,[rGLUE,#offGlue_jitState] + str r2,[rSELF,#offThread_jitState] mov r1,#1 @ set changeInterp to bail to debug interp b common_gotoBail @@ -136,10 +128,9 @@ dvmJitToInterpTraceSelectNoChain: #if defined(WITH_JIT_TUNING) bl dvmBumpNoChain #endif - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self mov r0,rPC bl dvmJitGetTraceAddr @ Is there a translation? - str r0, [r10, #offThread_inJitCodeCache] @ set the inJitCodeCache flag + str r0, [rSELF, #offThread_inJitCodeCache] @ set the inJitCodeCache flag mov r1, rPC @ arg1 of translation may need this mov lr, #0 @ in case target is HANDLER_INTERPRET cmp r0,#0 @ !0 means translation exists @@ -154,12 +145,11 @@ dvmJitToInterpTraceSelectNoChain: .global dvmJitToInterpTraceSelect dvmJitToInterpTraceSelect: ldr rPC,[lr, #-1] @ get our target PC - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self add rINST,lr,#-5 @ save start of chain branch add rINST, #-4 @ .. which is 9 bytes back mov r0,rPC bl dvmJitGetTraceAddr @ Is there a translation? - str r0, [r10, #offThread_inJitCodeCache] @ set the inJitCodeCache flag + str r0, [rSELF, #offThread_inJitCodeCache] @ set the inJitCodeCache flag cmp r0,#0 beq 2f mov r1,rINST @@ -198,7 +188,6 @@ dvmJitToInterpTraceSelect: .global dvmJitToInterpNormal dvmJitToInterpNormal: ldr rPC,[lr, #-1] @ get our target PC - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self add rINST,lr,#-5 @ save start of chain branch add rINST,#-4 @ .. which is 9 bytes back #if defined(WITH_JIT_TUNING) @@ -206,7 +195,7 @@ dvmJitToInterpNormal: #endif mov r0,rPC bl dvmJitGetTraceAddr @ Is there a translation? - str r0, [r10, #offThread_inJitCodeCache] @ set the inJitCodeCache flag + str r0, [rSELF, #offThread_inJitCodeCache] @ set the inJitCodeCache flag cmp r0,#0 beq toInterpreter @ go if not, otherwise do chain mov r1,rINST @@ -226,10 +215,9 @@ dvmJitToInterpNoChainNoProfile: #if defined(WITH_JIT_TUNING) bl dvmBumpNoChain #endif - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self mov r0,rPC bl dvmJitGetTraceAddr @ Is there a translation? - str r0, [r10, #offThread_inJitCodeCache] @ set the inJitCodeCache flag + str r0, [rSELF, #offThread_inJitCodeCache] @ set the inJitCodeCache flag mov r1, rPC @ arg1 of translation may need this mov lr, #0 @ in case target is HANDLER_INTERPRET cmp r0,#0 @@ -249,10 +237,9 @@ dvmJitToInterpNoChain: #if defined(WITH_JIT_TUNING) bl dvmBumpNoChain #endif - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self mov r0,rPC bl dvmJitGetTraceAddr @ Is there a translation? - str r0, [r10, #offThread_inJitCodeCache] @ set the inJitCodeCache flag + str r0, [rSELF, #offThread_inJitCodeCache] @ set the inJitCodeCache flag mov r1, rPC @ arg1 of translation may need this mov lr, #0 @ in case target is HANDLER_INTERPRET cmp r0,#0 @@ -261,7 +248,7 @@ dvmJitToInterpNoChain: /* * No translation, restore interpreter regs and start interpreting. - * rGLUE & rFP were preserved in the translated code, and rPC has + * rSELF & rFP were preserved in the translated code, and rPC has * already been restored by the time we get here. We'll need to set * up rIBASE & rINST, and load the address of the JitTable into r0. */ @@ -299,13 +286,13 @@ common_updateProfile: * is already a native translation in place (and, if so, * jump to it now). */ + GET_JIT_THRESHOLD(r1) - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self strb r1,[r0,r3,lsr #(32 - JIT_PROF_SIZE_LOG_2)] @ reset counter EXPORT_PC() mov r0,rPC bl dvmJitGetTraceAddr @ r0<- dvmJitGetTraceAddr(rPC) - str r0, [r10, #offThread_inJitCodeCache] @ set the inJitCodeCache flag + str r0, [rSELF, #offThread_inJitCodeCache] @ set the inJitCodeCache flag mov r1, rPC @ arg1 of translation may need this mov lr, #0 @ in case target is HANDLER_INTERPRET cmp r0,#0 @@ -326,9 +313,8 @@ common_updateProfile: cmp r0, r10 @ special case? bne jitSVShadowRunStart @ set up self verification shadow space @ Need to clear the inJitCodeCache flag - ldr r10, [rGLUE, #offGlue_self] @ r10 <- glue->self mov r3, #0 @ 0 means not in the JIT code cache - str r3, [r10, #offThread_inJitCodeCache] @ back to the interp land + str r3, [rSELF, #offThread_inJitCodeCache] @ back to the interp land GET_INST_OPCODE(ip) GOTO_OPCODE(ip) /* no return */ @@ -339,9 +325,10 @@ common_updateProfile: * r2 is jit state, e.g. kJitTSelectRequest or kJitTSelectRequestHot */ common_selectTrace: - str r2,[rGLUE,#offGlue_jitState] + + str r2,[rSELF,#offThread_jitState] mov r2,#kInterpEntryInstr @ normal entry reason - str r2,[rGLUE,#offGlue_entryPoint] + str r2,[rSELF,#offThread_entryPoint] mov r1,#1 @ set changeInterp b common_gotoBail @@ -350,36 +337,35 @@ common_selectTrace: * Save PC and registers to shadow memory for self verification mode * before jumping to native translation. * On entry: - * rPC, rFP, rGLUE: the values that they should contain + * rPC, rFP, rSELF: the values that they should contain * r10: the address of the target translation. */ jitSVShadowRunStart: mov r0,rPC @ r0<- program counter mov r1,rFP @ r1<- frame pointer - mov r2,rGLUE @ r2<- InterpState pointer + mov r2,rSELF @ r2<- self (Thread) pointer mov r3,r10 @ r3<- target translation bl dvmSelfVerificationSaveState @ save registers to shadow space 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 + * Restore PC, registers, and interpreter state to original values * before jumping back to the interpreter. */ jitSVShadowRunEnd: mov r1,rFP @ pass ending fp + mov r3,rSELF @ pass self ptr for convenience bl dvmSelfVerificationRestoreState @ restore pc and fp values - ldr rPC,[r0,#offShadowSpace_startPC] @ restore PC - ldr rFP,[r0,#offShadowSpace_fp] @ restore FP - ldr rGLUE,[r0,#offShadowSpace_glue] @ restore InterpState + ldr rPC,[rSELF,#offThread_pc] @ restore PC + ldr rFP,[rSELF,#offThread_fp] @ restore FP 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 - str r2,[rGLUE,#offGlue_jitState] + str r2,[rSELF,#offThread_jitState] mov r2,#kInterpEntryInstr @ normal entry reason - str r2,[rGLUE,#offGlue_entryPoint] + str r2,[rSELF,#offThread_entryPoint] mov r1,#1 @ set changeInterp b common_gotoBail @@ -440,12 +426,11 @@ common_backwardBranch: * r9 is trampoline PC adjustment *in bytes* */ common_periodicChecks: - ldr r1, [rGLUE, #offGlue_pInterpBreak] @ r3<- &interpBreak - /* speculatively load address of thread-specific suspend count */ - ldr r3, [rGLUE, #offGlue_pSelfSuspendCount] @ r3<- &suspendCount +/* TUNING - make this a direct load when interpBreak moved to Thread */ + ldr r1, [rSELF, #offThread_pInterpBreak] @ r3<- &interpBreak + /* speculatively thread-specific suspend count */ + ldr ip, [rSELF, #offThread_suspendCount] ldr r1, [r1] @ r1<- interpBreak - /* speculatively load thread-specific suspend count */ - ldr ip, [r3] @ ip<- suspendCount (int) cmp r1, #0 @ anything unusual? bxeq lr @ return if not /* @@ -462,13 +447,13 @@ common_periodicChecks: * Refresh the Jit's cached copy of profile table pointer. This pointer * doubles as the Jit's on/off switch. */ - ldr r3, [rGLUE, #offGlue_ppJitProfTable] @ r3<-&gDvmJit.pJitProfTable - ldr r0, [rGLUE, #offGlue_self] @ r0<- glue->self + ldr r3, [rSELF, #offThread_ppJitProfTable] @ r3<-&gDvmJit.pJitProfTable + mov r0, rSELF @ r0<- self ldr r3, [r3] @ r3 <- pJitProfTable EXPORT_PC() @ need for precise GC - str r3, [rGLUE, #offGlue_pJitProfTable] @ refresh Jit's on/off switch + str r3, [rSELF, #offThread_pJitProfTable] @ refresh Jit's on/off switch #else - ldr r0, [rGLUE, #offGlue_self] @ r0<- glue->self + mov r0, rSELF @ r0<- self EXPORT_PC() @ need for precise GC #endif bl dvmCheckSuspendPending @ do full check, suspend if necessary @@ -478,7 +463,8 @@ common_periodicChecks: * Reload the interpBreak flags - they may have changed while we * were suspended. */ - ldr r1, [rGLUE, #offGlue_pInterpBreak] @ r1<- &interpBreak +/* TUNING - direct load when InterpBreak moved to Thread */ + ldr r1, [rSELF, #offThread_pInterpBreak] @ r1<- &interpBreak ldr r1, [r1] @ r1<- interpBreak 3: /* @@ -492,8 +478,8 @@ common_periodicChecks: ands r1, #(kSubModeDebuggerActive | kSubModeEmulatorTrace | kSubModeInstCounting) bxeq lr @ nothing to do, return - @ debugger/profiler enabled, bail out; glue->entryPoint was set above - str r0, [rGLUE, #offGlue_entryPoint] @ store r0, need for debug/prof + @ debugger/profiler enabled, bail out; self->entryPoint was set above + str r0, [rSELF, #offThread_entryPoint] @ store r0, need for debug/prof add rPC, rPC, r9 @ update rPC mov r1, #1 @ "want switch" = true b common_gotoBail @ side exit @@ -502,19 +488,19 @@ common_periodicChecks: /* * The equivalent of "goto bail", this calls through the "bail handler". * - * State registers will be saved to the "glue" area before bailing. + * State registers will be saved to the "thread" area before bailing. * * On entry: * r1 is "bool changeInterp", indicating if we want to switch to the * other interpreter or just bail all the way out */ common_gotoBail: - SAVE_PC_FP_TO_GLUE() @ export state to "glue" - mov r0, rGLUE @ r0<- glue ptr - b dvmMterpStdBail @ call(glue, changeInterp) + SAVE_PC_FP_TO_SELF() @ export state to "thread" + mov r0, rSELF @ r0<- self ptr + b dvmMterpStdBail @ call(self, changeInterp) @add r1, r1, #1 @ using (boolean+1) - @add r0, rGLUE, #offGlue_jmpBuf @ r0<- &glue->jmpBuf + @add r0, rSELF, #offThread_jmpBuf @ r0<- &self->jmpBuf @bl _longjmp @ does not return @bl common_abort @@ -616,10 +602,10 @@ common_invokeMethodNoRange: sub r1, r1, r9, lsl #2 @ r1<- newFp (old savearea - regsSize) SAVEAREA_FROM_FP(r10, r1) @ r10<- newSaveArea @ bl common_dumpRegs - ldr r9, [rGLUE, #offGlue_interpStackEnd] @ r9<- interpStackEnd + ldr r9, [rSELF, #offThread_interpStackEnd] @ r9<- interpStackEnd sub r3, r10, r3, lsl #2 @ r3<- bottom (newsave - outsSize) cmp r3, r9 @ bottom < interpStackEnd? - ldr lr, [rGLUE, #offGlue_pInterpBreak] + ldr lr, [rSELF, #offThread_pInterpBreak] ldr r3, [r0, #offMethod_accessFlags] @ r3<- methodToCall->accessFlags blo .LstackOverflow @ yes, this frame will overflow stack @@ -639,7 +625,7 @@ common_invokeMethodNoRange: beq 1f @ skip if not stmfd sp!, {r0-r3} @ preserve r0-r3 mov r1, r6 - @ r0=methodToCall, r1=rGlue + @ r0=methodToCall, r1=rSELF bl dvmFastMethodTraceEnter ldmfd sp!, {r0-r3} @ restore r0-r3 1: @@ -665,18 +651,17 @@ common_invokeMethodNoRange: ldrh r9, [r2] @ r9 <- load INST from new PC ldr r3, [rINST, #offClassObject_pDvmDex] @ r3<- method->clazz->pDvmDex mov rPC, r2 @ publish new rPC - ldr r2, [rGLUE, #offGlue_self] @ r2<- glue->self - @ Update "glue" values for the new method - @ r0=methodToCall, r1=newFp, r2=self, r3=newMethodClass, r9=newINST - str r0, [rGLUE, #offGlue_method] @ glue->method = methodToCall - str r3, [rGLUE, #offGlue_methodClassDex] @ glue->methodClassDex = ... + @ Update state values for the new method + @ r0=methodToCall, r1=newFp, r3=newMethodClass, r9=newINST + str r0, [rSELF, #offThread_method] @ self->method = methodToCall + str r3, [rSELF, #offThread_methodClassDex] @ self->methodClassDex = ... #if defined(WITH_JIT) GET_JIT_PROF_TABLE(r0) mov rFP, r1 @ fp = newFp GET_PREFETCHED_OPCODE(ip, r9) @ extract prefetched opcode from r9 mov rINST, r9 @ publish new rINST - str r1, [r2, #offThread_curFrame] @ self->curFrame = newFp + str r1, [rSELF, #offThread_curFrame] @ self->curFrame = newFp cmp r0,#0 bne common_updateProfile GOTO_OPCODE(ip) @ jump to next instruction @@ -684,24 +669,23 @@ common_invokeMethodNoRange: mov rFP, r1 @ fp = newFp GET_PREFETCHED_OPCODE(ip, r9) @ extract prefetched opcode from r9 mov rINST, r9 @ publish new rINST - str r1, [r2, #offThread_curFrame] @ self->curFrame = newFp + str r1, [rSELF, #offThread_curFrame] @ self->curFrame = newFp GOTO_OPCODE(ip) @ jump to next instruction #endif .LinvokeNative: @ Prep for the native call @ r0=methodToCall, r1=newFp, r10=newSaveArea - ldr r3, [rGLUE, #offGlue_self] @ r3<- glue->self - ldr lr, [rGLUE, #offGlue_pInterpBreak] - ldr r9, [r3, #offThread_jniLocal_topCookie] @ r9<- thread->localRef->... - str r1, [r3, #offThread_curFrame] @ self->curFrame = newFp + ldr lr, [rSELF, #offThread_pInterpBreak] + ldr r9, [rSELF, #offThread_jniLocal_topCookie]@r9<-thread->localRef->... + str r1, [rSELF, #offThread_curFrame] @ self->curFrame = newFp str r9, [r10, #offStackSaveArea_localRefCookie] @newFp->localRefCookie=top ldr lr, [lr] @ lr<- active submodes - mov r9, r3 @ r9<- glue->self (preserve) mov r2, r0 @ r2<- methodToCall mov r0, r1 @ r0<- newFp (points to args) - add r1, rGLUE, #offGlue_retval @ r1<- &retval + add r1, rSELF, #offThread_retval @ r1<- &retval + mov r3, rSELF @ arg3<- self #ifdef ASSIST_DEBUGGER /* insert fake function header to help gdb find the stack frame */ @@ -716,13 +700,13 @@ dalvik_mterp: ands lr, #kSubModeMethodTrace @ method tracing? beq 110f @ hop if not - @ r2=JNIMethod, r6=rGLUE + @ r2=JNIMethod, r6=rSELF stmfd sp!, {r2,r6} mov lr, pc @ set return addr ldr pc, [r2, #offMethod_nativeFunc] @ pc<- methodToCall->nativeFunc - @ r0=JNIMethod, r1=rGLUE + @ r0=JNIMethod, r1=rSELF ldmfd sp!, {r0-r1} bl dvmFastNativeMethodTraceExit b 220f @@ -731,21 +715,21 @@ dalvik_mterp: ldr pc, [r2, #offMethod_nativeFunc] @ pc<- methodToCall->nativeFunc 220: #if defined(WITH_JIT) - ldr r3, [rGLUE, #offGlue_ppJitProfTable] @ Refresh Jit's on/off status + ldr r3, [rSELF, #offThread_ppJitProfTable] @ Refresh Jit's on/off status #endif - @ native return; r9=self, r10=newSaveArea + @ native return; r10=newSaveArea @ equivalent to dvmPopJniLocals ldr r0, [r10, #offStackSaveArea_localRefCookie] @ r0<- saved top - ldr r1, [r9, #offThread_exception] @ check for exception + ldr r1, [rSELF, #offThread_exception] @ check for exception #if defined(WITH_JIT) ldr r3, [r3] @ r3 <- gDvmJit.pProfTable #endif - str rFP, [r9, #offThread_curFrame] @ self->curFrame = fp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = fp cmp r1, #0 @ null? - str r0, [r9, #offThread_jniLocal_topCookie] @ new top <- old top + str r0, [rSELF, #offThread_jniLocal_topCookie] @ new top <- old top #if defined(WITH_JIT) - str r3, [rGLUE, #offGlue_pJitProfTable] @ refresh cached on/off switch + str r3, [rSELF, #offThread_pJitProfTable] @ refresh cached on/off switch #endif bne common_exceptionThrown @ no, handle exception @@ -755,7 +739,7 @@ dalvik_mterp: .LstackOverflow: @ r0=methodToCall mov r1, r0 @ r1<- methodToCall - ldr r0, [rGLUE, #offGlue_self] @ r0<- self + mov r0, rSELF @ r0<- self bl dvmHandleStackOverflow b common_exceptionThrown #ifdef ASSIST_DEBUGGER @@ -780,8 +764,8 @@ dalvik_mterp: sub sp, sp, #8 @ space for args + pad FETCH(ip, 2) @ ip<- FEDC or CCCC mov r2, r0 @ A2<- methodToCall - mov r0, rGLUE @ A0<- glue - SAVE_PC_FP_TO_GLUE() @ export state to "glue" + mov r0, rSELF @ A0<- self + SAVE_PC_FP_TO_SELF() @ export state to "self" mov r1, r9 @ A1<- methodCallRange mov r3, rINST, lsr #8 @ A3<- AA str ip, [sp, #0] @ A4<- ip @@ -803,7 +787,7 @@ common_returnFromMethod: mov r9, #0 bl common_periodicChecks - ldr lr, [rGLUE, #offGlue_pInterpBreak] + ldr lr, [rSELF, #offThread_pInterpBreak] SAVEAREA_FROM_FP(r0, rFP) ldr lr, [lr] @ lr<- active submodes ldr r9, [r0, #offStackSaveArea_savedPc] @ r9 = saveArea->savedPc @@ -811,12 +795,11 @@ common_returnFromMethod: beq 333f stmfd sp!, {r0-r3} @ preserve r0-r3 mov r0, r6 - @ r0=rGlue + @ r0=rSELF bl dvmFastJavaMethodTraceExit ldmfd sp!, {r0-r3} @ restore r0-r3 333: ldr rFP, [r0, #offStackSaveArea_prevFrame] @ fp = saveArea->prevFrame - ldr r3, [rGLUE, #offGlue_self] @ r3<- glue->self ldr r2, [rFP, #(offStackSaveArea_method - sizeofStackSaveArea)] @ r2<- method we're returning to cmp r2, #0 @ is this a break frame? @@ -832,14 +815,14 @@ common_returnFromMethod: beq common_gotoBail @ break frame, bail out completely PREFETCH_ADVANCE_INST(rINST, r9, 3) @ advance r9, update new rINST - str r2, [rGLUE, #offGlue_method]@ glue->method = newSave->method + str r2, [rSELF, #offThread_method]@ self->method = newSave->method ldr r1, [r10, #offClassObject_pDvmDex] @ r1<- method->clazz->pDvmDex - str rFP, [r3, #offThread_curFrame] @ self->curFrame = fp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = fp #if defined(WITH_JIT) ldr r10, [r0, #offStackSaveArea_returnAddr] @ r10 = saveArea->returnAddr mov rPC, r9 @ publish new rPC - str r1, [rGLUE, #offGlue_methodClassDex] - str r10, [r3, #offThread_inJitCodeCache] @ may return to JIT'ed land + str r1, [rSELF, #offThread_methodClassDex] + str r10, [rSELF, #offThread_inJitCodeCache] @ may return to JIT'ed land cmp r10, #0 @ caller is compiled code blxne r10 GET_INST_OPCODE(ip) @ extract opcode from rINST @@ -847,7 +830,7 @@ common_returnFromMethod: #else GET_INST_OPCODE(ip) @ extract opcode from rINST mov rPC, r9 @ publish new rPC - str r1, [rGLUE, #offGlue_methodClassDex] + str r1, [rSELF, #offThread_methodClassDex] GOTO_OPCODE(ip) @ jump to next instruction #endif @@ -856,8 +839,8 @@ common_returnFromMethod: */ .if 0 .LreturnOld: - SAVE_PC_FP_TO_GLUE() @ export state - mov r0, rGLUE @ arg to function + SAVE_PC_FP_TO_SELF() @ export state + mov r0, rSELF @ arg to function bl dvmMterp_returnFromMethod b common_resumeAfterGlueCall .endif @@ -880,13 +863,12 @@ common_exceptionThrown: mov r9, #0 bl common_periodicChecks - ldr r10, [rGLUE, #offGlue_self] @ r10<- glue->self - ldr r9, [r10, #offThread_exception] @ r9<- self->exception - mov r1, r10 @ r1<- self + ldr r9, [rSELF, #offThread_exception] @ r9<- self->exception + mov r1, rSELF @ r1<- self mov r0, r9 @ r0<- exception bl dvmAddTrackedAlloc @ don't let the exception be GCed mov r3, #0 @ r3<- NULL - str r3, [r10, #offThread_exception] @ self->exception = NULL + str r3, [rSELF, #offThread_exception] @ self->exception = NULL /* set up args and a local for "&fp" */ /* (str sp, [sp, #-4]! would be perfect here, but is discouraged) */ @@ -894,8 +876,8 @@ common_exceptionThrown: mov ip, sp @ ip<- &fp mov r3, #0 @ r3<- false str ip, [sp, #-4]! @ *--sp = &fp - ldr r1, [rGLUE, #offGlue_method] @ r1<- glue->method - mov r0, r10 @ r0<- self + ldr r1, [rSELF, #offThread_method] @ r1<- self->method + mov r0, rSELF @ r0<- self ldr r1, [r1, #offMethod_insns] @ r1<- method->insns mov r2, r9 @ r2<- exception sub r1, rPC, r1 @ r1<- pc - method->insns @@ -905,11 +887,11 @@ common_exceptionThrown: bl dvmFindCatchBlock @ call(self, relPc, exc, scan?, &fp) /* fix earlier stack overflow if necessary; may trash rFP */ - ldrb r1, [r10, #offThread_stackOverflowed] + ldrb r1, [rSELF, #offThread_stackOverflowed] cmp r1, #0 @ did we overflow earlier? beq 1f @ no, skip ahead mov rFP, r0 @ save relPc result in rFP - mov r0, r10 @ r0<- self + mov r0, rSELF @ r0<- self mov r1, r9 @ r1<- exception bl dvmCleanupStackOverflow @ call(self) mov r0, rFP @ restore result @@ -924,30 +906,30 @@ common_exceptionThrown: /* adjust locals to match self->curFrame and updated PC */ SAVEAREA_FROM_FP(r1, rFP) @ r1<- new save area ldr r1, [r1, #offStackSaveArea_method] @ r1<- new method - str r1, [rGLUE, #offGlue_method] @ glue->method = new method + str r1, [rSELF, #offThread_method] @ self->method = new method ldr r2, [r1, #offMethod_clazz] @ r2<- method->clazz ldr r3, [r1, #offMethod_insns] @ r3<- method->insns ldr r2, [r2, #offClassObject_pDvmDex] @ r2<- method->clazz->pDvmDex add rPC, r3, r0, asl #1 @ rPC<- method->insns + catchRelPc - str r2, [rGLUE, #offGlue_methodClassDex] @ glue->pDvmDex = meth... + str r2, [rSELF, #offThread_methodClassDex] @ self->pDvmDex = meth... /* release the tracked alloc on the exception */ mov r0, r9 @ r0<- exception - mov r1, r10 @ r1<- self + mov r1, rSELF @ r1<- self bl dvmReleaseTrackedAlloc @ release the exception /* restore the exception if the handler wants it */ FETCH_INST() @ load rINST from rPC GET_INST_OPCODE(ip) @ extract opcode from rINST cmp ip, #OP_MOVE_EXCEPTION @ is it "move-exception"? - streq r9, [r10, #offThread_exception] @ yes, restore the exception + streq r9, [rSELF, #offThread_exception] @ yes, restore the exception GOTO_OPCODE(ip) @ jump to next instruction -.LnotCaughtLocally: @ r9=exception, r10=self +.LnotCaughtLocally: @ r9=exception /* fix stack overflow if necessary */ - ldrb r1, [r10, #offThread_stackOverflowed] + ldrb r1, [rSELF, #offThread_stackOverflowed] cmp r1, #0 @ did we overflow earlier? - movne r0, r10 @ if yes: r0<- self + movne r0, rSELF @ if yes: r0<- self movne r1, r9 @ if yes: r1<- exception blne dvmCleanupStackOverflow @ if yes: call(self) @@ -956,14 +938,14 @@ common_exceptionThrown: /* call __android_log_print(prio, tag, format, ...) */ /* "Exception %s from %s:%d not caught locally" */ @ dvmLineNumFromPC(method, pc - method->insns) - ldr r0, [rGLUE, #offGlue_method] + ldr r0, [rSELF, #offThread_method] ldr r1, [r0, #offMethod_insns] sub r1, rPC, r1 asr r1, r1, #1 bl dvmLineNumFromPC str r0, [sp, #-4]! @ dvmGetMethodSourceFile(method) - ldr r0, [rGLUE, #offGlue_method] + ldr r0, [rSELF, #offThread_method] bl dvmGetMethodSourceFile str r0, [sp, #-4]! @ exception->clazz->descriptor @@ -975,9 +957,9 @@ common_exceptionThrown: mov r0, #3 @ LOG_DEBUG bl __android_log_print #endif - str r9, [r10, #offThread_exception] @ restore exception + str r9, [rSELF, #offThread_exception] @ restore exception mov r0, r9 @ r0<- exception - mov r1, r10 @ r1<- self + mov r1, rSELF @ r1<- self bl dvmReleaseTrackedAlloc @ release the exception mov r1, #0 @ "want switch" = false b common_gotoBail @ bail out @@ -988,8 +970,8 @@ common_exceptionThrown: */ .if 0 .LexceptionOld: - SAVE_PC_FP_TO_GLUE() @ export state - mov r0, rGLUE @ arg to function + SAVE_PC_FP_TO_SELF() @ export state + mov r0, rSELF @ arg to function bl dvmMterp_exceptionThrown b common_resumeAfterGlueCall .endif @@ -1000,7 +982,7 @@ common_exceptionThrown: * values and start executing at the next instruction. */ common_resumeAfterGlueCall: - LOAD_PC_FP_FROM_GLUE() @ pull rPC and rFP out of glue + LOAD_PC_FP_FROM_SELF() @ pull rPC and rFP out of thread FETCH_INST() @ load rINST from rPC GET_INST_OPCODE(ip) @ extract opcode from rINST GOTO_OPCODE(ip) @ jump to next instruction diff --git a/vm/mterp/armv5te/header.S b/vm/mterp/armv5te/header.S index bd6b7eec8..3d755a239 100644 --- a/vm/mterp/armv5te/header.S +++ b/vm/mterp/armv5te/header.S @@ -56,7 +56,7 @@ The following registers have fixed assignments: reg nick purpose r4 rPC interpreted program counter, used for fetching instructions r5 rFP interpreted frame pointer, used for accessing locals and args - r6 rGLUE MterpGlue pointer + r6 rSELF self (Thread) pointer r7 rINST first 16-bit code unit of current instruction r8 rIBASE interpreted instruction base pointer, used for computed goto @@ -68,17 +68,17 @@ unspecified registers or condition codes. /* single-purpose registers, given names for clarity */ #define rPC r4 #define rFP r5 -#define rGLUE r6 +#define rSELF r6 #define rINST r7 #define rIBASE r8 -/* save/restore the PC and/or FP from the glue struct */ -#define LOAD_PC_FROM_GLUE() ldr rPC, [rGLUE, #offGlue_pc] -#define SAVE_PC_TO_GLUE() str rPC, [rGLUE, #offGlue_pc] -#define LOAD_FP_FROM_GLUE() ldr rFP, [rGLUE, #offGlue_fp] -#define SAVE_FP_TO_GLUE() str rFP, [rGLUE, #offGlue_fp] -#define LOAD_PC_FP_FROM_GLUE() ldmia rGLUE, {rPC, rFP} -#define SAVE_PC_FP_TO_GLUE() stmia rGLUE, {rPC, rFP} +/* save/restore the PC and/or FP from the thread struct */ +#define LOAD_PC_FROM_SELF() ldr rPC, [rSELF, #offThread_pc] +#define SAVE_PC_TO_SELF() str rPC, [rSELF, #offThread_pc] +#define LOAD_FP_FROM_SELF() ldr rFP, [rSELF, #offThread_fp] +#define SAVE_FP_TO_SELF() str rFP, [rSELF, #offThread_fp] +#define LOAD_PC_FP_FROM_SELF() ldmia rSELF, {rPC, rFP} +#define SAVE_PC_FP_TO_SELF() stmia rSELF, {rPC, rFP} /* * "export" the PC to the stack frame, f/b/o future exception objects. Must @@ -179,8 +179,8 @@ unspecified registers or condition codes. #define SET_VREG(_reg, _vreg) str _reg, [rFP, _vreg, lsl #2] #if defined(WITH_JIT) -#define GET_JIT_PROF_TABLE(_reg) ldr _reg,[rGLUE,#offGlue_pJitProfTable] -#define GET_JIT_THRESHOLD(_reg) ldr _reg,[rGLUE,#offGlue_jitThreshold] +#define GET_JIT_PROF_TABLE(_reg) ldr _reg,[rSELF,#offThread_pJitProfTable] +#define GET_JIT_THRESHOLD(_reg) ldr _reg,[rSELF,#offThread_jitThreshold] #endif /* diff --git a/vm/mterp/armv5te/stub.S b/vm/mterp/armv5te/stub.S index 54f0778c8..767427beb 100644 --- a/vm/mterp/armv5te/stub.S +++ b/vm/mterp/armv5te/stub.S @@ -1,8 +1,8 @@ /* (stub) */ - SAVE_PC_FP_TO_GLUE() @ only need to export these two - mov r0, rGLUE @ glue is first arg to function + SAVE_PC_FP_TO_SELF() @ only need to export these two + mov r0, rSELF @ self is first arg to function bl dvmMterp_${opcode} @ call - LOAD_PC_FP_FROM_GLUE() @ retrieve updated values + LOAD_PC_FP_FROM_SELF() @ retrieve updated values FETCH_INST() @ load next instruction from rPC GET_INST_OPCODE(ip) @ ...trim down to just the opcode GOTO_OPCODE(ip) @ ...and jump to the handler diff --git a/vm/mterp/armv6t2/OP_IGET.S b/vm/mterp/armv6t2/OP_IGET.S index f5a21eb5b..14ddf4436 100644 --- a/vm/mterp/armv6t2/OP_IGET.S +++ b/vm/mterp/armv6t2/OP_IGET.S @@ -11,14 +11,14 @@ */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .L${opcode}_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr diff --git a/vm/mterp/armv6t2/OP_IGET_WIDE.S b/vm/mterp/armv6t2/OP_IGET_WIDE.S index 92cd1a6fd..3e826ddb0 100644 --- a/vm/mterp/armv6t2/OP_IGET_WIDE.S +++ b/vm/mterp/armv6t2/OP_IGET_WIDE.S @@ -8,14 +8,14 @@ */ /* iget-wide vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .L${opcode}_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr diff --git a/vm/mterp/armv6t2/OP_IPUT.S b/vm/mterp/armv6t2/OP_IPUT.S index b69443bef..4bc8e1b73 100644 --- a/vm/mterp/armv6t2/OP_IPUT.S +++ b/vm/mterp/armv6t2/OP_IPUT.S @@ -11,14 +11,14 @@ */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .L${opcode}_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr diff --git a/vm/mterp/armv6t2/OP_IPUT_WIDE.S b/vm/mterp/armv6t2/OP_IPUT_WIDE.S index 334e352ed..f4ddb43b4 100644 --- a/vm/mterp/armv6t2/OP_IPUT_WIDE.S +++ b/vm/mterp/armv6t2/OP_IPUT_WIDE.S @@ -5,14 +5,14 @@ %verify "field cannot be resolved" /* iput-wide vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .L${opcode}_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr diff --git a/vm/mterp/common/asm-constants.h b/vm/mterp/common/asm-constants.h index df72f08e2..9cf0e852d 100644 --- a/vm/mterp/common/asm-constants.h +++ b/vm/mterp/common/asm-constants.h @@ -81,42 +81,6 @@ * values are incorrect. */ -/* MterpGlue fields */ -MTERP_OFFSET(offGlue_pc, MterpGlue, pc, 0) -MTERP_OFFSET(offGlue_fp, MterpGlue, fp, 4) -MTERP_OFFSET(offGlue_retval, MterpGlue, retval, 8) -MTERP_OFFSET(offGlue_method, MterpGlue, method, 16) -MTERP_OFFSET(offGlue_methodClassDex, MterpGlue, methodClassDex, 20) -MTERP_OFFSET(offGlue_self, MterpGlue, self, 24) -MTERP_OFFSET(offGlue_bailPtr, MterpGlue, bailPtr, 28) -MTERP_OFFSET(offGlue_interpStackEnd, MterpGlue, interpStackEnd, 32) -MTERP_OFFSET(offGlue_pSelfSuspendCount, MterpGlue, pSelfSuspendCount, 36) -MTERP_OFFSET(offGlue_cardTable, MterpGlue, cardTable, 40) -MTERP_OFFSET(offGlue_pInterpBreak, MterpGlue, pInterpBreak, 44) -MTERP_OFFSET(offGlue_entryPoint, MterpGlue, entryPoint, 48) -#if defined(WITH_JIT) -MTERP_OFFSET(offGlue_pJitProfTable, MterpGlue, pJitProfTable, 56) -MTERP_OFFSET(offGlue_jitState, MterpGlue, jitState, 60) -MTERP_OFFSET(offGlue_jitResumeNPC, MterpGlue, jitResumeNPC, 64) -MTERP_OFFSET(offGlue_jitResumeDPC, MterpGlue, jitResumeDPC, 68) -MTERP_OFFSET(offGlue_jitThreshold, MterpGlue, jitThreshold, 72) -MTERP_OFFSET(offGlue_ppJitProfTable, MterpGlue, ppJitProfTable, 76) -MTERP_OFFSET(offGlue_icRechainCount, MterpGlue, icRechainCount, 80) -MTERP_OFFSET(offGlue_pProfileCountdown, MterpGlue, pProfileCountdown, 84) -#if defined(WITH_SELF_VERIFICATION) -MTERP_OFFSET(offGlue_jitCacheStart, MterpGlue, jitCacheStart, 112) -MTERP_OFFSET(offGlue_jitCacheEnd, MterpGlue, jitCacheEnd, 116) -#else -MTERP_OFFSET(offGlue_jitCacheStart, MterpGlue, jitCacheStart, 108) -MTERP_OFFSET(offGlue_jitCacheEnd, MterpGlue, jitCacheEnd, 112) -#endif -#endif -/* make sure all JValue union members are stored at the same offset */ -MTERP_OFFSET(offGlue_retval_z, MterpGlue, retval.z, 8) -MTERP_OFFSET(offGlue_retval_i, MterpGlue, retval.i, 8) -MTERP_OFFSET(offGlue_retval_j, MterpGlue, retval.j, 8) -MTERP_OFFSET(offGlue_retval_l, MterpGlue, retval.l, 8) - /* DvmDex fields */ MTERP_OFFSET(offDvmDex_pResStrings, DvmDex, pResStrings, 8) MTERP_OFFSET(offDvmDex_pResClasses, DvmDex, pResClasses, 12) @@ -150,11 +114,13 @@ MTERP_SIZEOF(sizeofStackSaveArea, StackSaveArea, 20) #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_jitExitState,ShadowSpace, jitExitState, 12) -MTERP_OFFSET(offShadowSpace_svState, ShadowSpace, selfVerificationState, 16) -MTERP_OFFSET(offShadowSpace_shadowFP, ShadowSpace, shadowFP, 24) -MTERP_OFFSET(offShadowSpace_interpState, ShadowSpace, interpState, 32) +MTERP_OFFSET(offShadowSpace_method, ShadowSpace, method, 8) +MTERP_OFFSET(offShadowSpace_methodClassDex, ShadowSpace, methodClassDex, 12) +MTERP_OFFSET(offShadowSpace_retval, ShadowSpace, retval, 16) +MTERP_OFFSET(offShadowSpace_interpStackEnd, ShadowSpace, interpStackEnd, 24) +MTERP_OFFSET(offShadowSpace_jitExitState,ShadowSpace, jitExitState, 28) +MTERP_OFFSET(offShadowSpace_svState, ShadowSpace, selfVerificationState, 32) +MTERP_OFFSET(offShadowSpace_shadowFP, ShadowSpace, shadowFP, 40) #endif /* InstField fields */ @@ -188,37 +154,51 @@ MTERP_OFFSET(offMethod_nativeFunc, Method, nativeFunc, 40) MTERP_OFFSET(offInlineOperation_func, InlineOperation, func, 0) /* Thread fields */ -MTERP_OFFSET(offThread_stackOverflowed, Thread, stackOverflowed, 36) -MTERP_OFFSET(offThread_curFrame, Thread, curFrame, 40) -MTERP_OFFSET(offThread_exception, Thread, exception, 44) +MTERP_OFFSET(offThread_pc, InterpSaveState, pc, 0) +MTERP_OFFSET(offThread_fp, InterpSaveState, fp, 4) +MTERP_OFFSET(offThread_method, InterpSaveState, method, 8) +MTERP_OFFSET(offThread_methodClassDex, InterpSaveState, methodClassDex, 12) +MTERP_OFFSET(offThread_bailPtr, InterpSaveState, bailPtr, 16) +MTERP_OFFSET(offThread_pInterpBreak, InterpSaveState, pInterpBreak, 20) -#if defined(WITH_JIT) -MTERP_OFFSET(offThread_inJitCodeCache, Thread, inJitCodeCache, 72) -#if defined(WITH_SELF_VERIFICATION) -MTERP_OFFSET(offThread_shadowSpace, Thread, shadowSpace, 76) -#ifdef USE_INDIRECT_REF -MTERP_OFFSET(offThread_jniLocal_topCookie, \ - Thread, jniLocalRefTable.segmentState.all, 80) -#else -MTERP_OFFSET(offThread_jniLocal_topCookie, \ - Thread, jniLocalRefTable.nextEntry, 80) -#endif -#else +/* make sure all JValue union members are stored at the same offset */ +MTERP_OFFSET(offThread_retval, Thread, retval, 32) +MTERP_OFFSET(offThread_retval_z, Thread, retval.z, 32) +MTERP_OFFSET(offThread_retval_i, Thread, retval.i, 32) +MTERP_OFFSET(offThread_retval_j, Thread, retval.j, 32) +MTERP_OFFSET(offThread_retval_l, Thread, retval.l, 32) +MTERP_OFFSET(offThread_suspendCount, Thread, suspendCount, 40) +MTERP_OFFSET(offThread_dbgSuspendCount, Thread, dbgSuspendCount, 44) +MTERP_OFFSET(offThread_cardTable, Thread, cardTable, 48) +MTERP_OFFSET(offThread_interpStackEnd, Thread, interpStackEnd, 52) +MTERP_OFFSET(offThread_curFrame, Thread, curFrame, 56) +MTERP_OFFSET(offThread_exception, Thread, exception, 60) +MTERP_OFFSET(offThread_threadId, Thread, threadId, 64) +MTERP_OFFSET(offThread_debugIsMethodEntry, Thread, debugIsMethodEntry, 68) +MTERP_OFFSET(offThread_interpStackSize, Thread, interpStackSize, 72) +MTERP_OFFSET(offThread_stackOverflowed, Thread, stackOverflowed, 76) +MTERP_OFFSET(offThread_entryPoint, Thread, entryPoint, 80) #ifdef USE_INDIRECT_REF MTERP_OFFSET(offThread_jniLocal_topCookie, \ - Thread, jniLocalRefTable.segmentState.all, 76) + Thread, jniLocalRefTable.segmentState.all, 84) #else MTERP_OFFSET(offThread_jniLocal_topCookie, \ - Thread, jniLocalRefTable.nextEntry, 76) -#endif + Thread, jniLocalRefTable.nextEntry, 84) #endif -#else -#ifdef USE_INDIRECT_REF -MTERP_OFFSET(offThread_jniLocal_topCookie, \ - Thread, jniLocalRefTable.segmentState.all, 72) -#else -MTERP_OFFSET(offThread_jniLocal_topCookie, \ - Thread, jniLocalRefTable.nextEntry, 72) + +#ifdef WITH_JIT +MTERP_OFFSET(offThread_jitToInterpEntries,Thread, jitToInterpEntries, 100) +MTERP_OFFSET(offThread_inJitCodeCache, Thread, inJitCodeCache, 124) +MTERP_OFFSET(offThread_pJitProfTable, Thread, pJitProfTable, 128) +MTERP_OFFSET(offThread_ppJitProfTable, Thread, ppJitProfTable, 132) +MTERP_OFFSET(offThread_jitThreshold, Thread, jitThreshold, 136) +MTERP_OFFSET(offThread_jitResumeNPC, Thread, jitResumeNPC, 140) +MTERP_OFFSET(offThread_jitResumeDPC, Thread, jitResumeDPC, 144) +MTERP_OFFSET(offThread_jitState, Thread, jitState, 148) +MTERP_OFFSET(offThread_icRechainCount, Thread, icRechainCount, 152) +MTERP_OFFSET(offThread_pProfileCountdown, Thread, pProfileCountdown, 156) +#if defined(WITH_SELF_VERIFICATION) +MTERP_OFFSET(offThread_shadowSpace, Thread, shadowSpace, 160) #endif #endif diff --git a/vm/mterp/cstubs/entry.c b/vm/mterp/cstubs/entry.c index 4fe0d2cad..58add8521 100644 --- a/vm/mterp/cstubs/entry.c +++ b/vm/mterp/cstubs/entry.c @@ -17,12 +17,12 @@ DEFINE_GOTO_TABLE(gDvmMterpHandlerNames) * * This is only used for the "allstubs" variant. */ -bool dvmMterpStdRun(MterpGlue* glue) +bool dvmMterpStdRun(Thread* self) { jmp_buf jmpBuf; int changeInterp; - glue->bailPtr = &jmpBuf; + self->bailPtr = &jmpBuf; /* * We want to return "changeInterp" as a boolean, but we can't return @@ -40,18 +40,18 @@ bool dvmMterpStdRun(MterpGlue* glue) * We need to pick up where the other interpreter left off. * * In some cases we need to call into a throw/return handler which - * will do some processing and then either return to us (updating "glue") + * will do some processing and then either return to us (updating "self") * or longjmp back out. */ - switch (glue->entryPoint) { + switch (self->entryPoint) { case kInterpEntryInstr: /* just start at the start */ break; case kInterpEntryReturn: - dvmMterp_returnFromMethod(glue); + dvmMterp_returnFromMethod(self); break; case kInterpEntryThrow: - dvmMterp_exceptionThrown(glue); + dvmMterp_exceptionThrown(self); break; default: dvmAbort(); @@ -59,22 +59,22 @@ bool dvmMterpStdRun(MterpGlue* glue) /* run until somebody longjmp()s out */ while (true) { - typedef void (*Handler)(MterpGlue* glue); + typedef void (*Handler)(Thread* self); - u2 inst = /*glue->*/pc[0]; + u2 inst = /*self->*/pc[0]; Handler handler = (Handler) gDvmMterpHandlers[inst & 0xff]; (void) gDvmMterpHandlerNames; /* avoid gcc "defined but not used" */ LOGVV("handler %p %s\n", handler, (const char*) gDvmMterpHandlerNames[inst & 0xff]); - (*handler)(glue); + (*handler)(self); } } /* * C mterp exit point. Call here to bail out of the interpreter. */ -void dvmMterpStdBail(MterpGlue* glue, bool changeInterp) +void dvmMterpStdBail(Thread* self, bool changeInterp) { - jmp_buf* pJmpBuf = glue->bailPtr; + jmp_buf* pJmpBuf = self->bailPtr; longjmp(*pJmpBuf, ((int)changeInterp)+1); } diff --git a/vm/mterp/cstubs/stubdefs.c b/vm/mterp/cstubs/stubdefs.c index ea061ea6d..1b5695aa7 100644 --- a/vm/mterp/cstubs/stubdefs.c +++ b/vm/mterp/cstubs/stubdefs.c @@ -12,11 +12,11 @@ */ #define GOTO_TARGET_DECL(_target, ...) \ - void dvmMterp_##_target(MterpGlue* glue, ## __VA_ARGS__); + void dvmMterp_##_target(Thread* self, ## __VA_ARGS__); /* (void)xxx to quiet unused variable compiler warnings. */ #define GOTO_TARGET(_target, ...) \ - void dvmMterp_##_target(MterpGlue* glue, ## __VA_ARGS__) { \ + void dvmMterp_##_target(Thread* self, ## __VA_ARGS__) { \ u2 ref, vsrc1, vsrc2, vdst; \ u2 inst = FETCH(0); \ const Method* methodToCall; \ @@ -27,16 +27,15 @@ #define GOTO_TARGET_END } /* - * Redefine what used to be local variable accesses into MterpGlue struct + * Redefine what used to be local variable accesses into Thread struct * references. (These are undefined down in "footer.c".) */ -#define retval glue->retval -#define pc glue->pc -#define fp glue->fp -#define curMethod glue->method -#define methodClassDex glue->methodClassDex -#define self glue->self -#define debugTrackedRefStart glue->debugTrackedRefStart +#define retval self->retval +#define pc self->interpSave.pc +#define fp self->interpSave.fp +#define curMethod self->interpSave.method +#define methodClassDex self->interpSave.methodClassDex +#define debugTrackedRefStart self->interpSave.debugTrackedRefStart /* ugh */ #define STUB_HACK(x) x @@ -44,12 +43,12 @@ /* * Opcode handler framing macros. Here, each opcode is a separate function - * that takes a "glue" argument and returns void. We can't declare + * that takes a "self" argument and returns void. We can't declare * these "static" because they may be called from an assembly stub. * (void)xxx to quiet unused variable compiler warnings. */ #define HANDLE_OPCODE(_op) \ - void dvmMterp_##_op(MterpGlue* glue) { \ + void dvmMterp_##_op(Thread* self) { \ u2 ref, vsrc1, vsrc2, vdst; \ u2 inst = FETCH(0); \ (void)ref; (void)vsrc1; (void)vsrc2; (void)vdst; (void)inst; @@ -76,25 +75,25 @@ #define GOTO_exceptionThrown() \ do { \ - dvmMterp_exceptionThrown(glue); \ + dvmMterp_exceptionThrown(self); \ return; \ } while(false) #define GOTO_returnFromMethod() \ do { \ - dvmMterp_returnFromMethod(glue); \ + dvmMterp_returnFromMethod(self); \ return; \ } while(false) #define GOTO_invoke(_target, _methodCallRange, _jumboFormat) \ do { \ - dvmMterp_##_target(glue, _methodCallRange, _jumboFormat); \ + dvmMterp_##_target(self, _methodCallRange, _jumboFormat); \ return; \ } while(false) #define GOTO_invokeMethod(_methodCallRange, _methodToCall, _vsrc1, _vdst) \ do { \ - dvmMterp_invokeMethod(glue, _methodCallRange, _methodToCall, \ + dvmMterp_invokeMethod(self, _methodCallRange, _methodToCall, \ _vsrc1, _vdst); \ return; \ } while(false) @@ -104,9 +103,9 @@ * if we need to switch to the other interpreter upon our return. */ #define GOTO_bail() \ - dvmMterpStdBail(glue, false); + dvmMterpStdBail(self, false); #define GOTO_bail_switch() \ - dvmMterpStdBail(glue, true); + dvmMterpStdBail(self, true); /* * Periodically check for thread suspension. @@ -121,7 +120,7 @@ } \ if (NEED_INTERP_SWITCH(INTERP_TYPE)) { \ ADJUST_PC(_pcadj); \ - glue->entryPoint = _entryPoint; \ + self->entryPoint = _entryPoint; \ LOGVV("threadid=%d: switch to STD ep=%d adj=%d\n", \ self->threadId, (_entryPoint), (_pcadj)); \ GOTO_bail_switch(); \ diff --git a/vm/mterp/out/InterpAsm-armv5te-vfp.S b/vm/mterp/out/InterpAsm-armv5te-vfp.S index 1d2abb3c5..affb80721 100644 --- a/vm/mterp/out/InterpAsm-armv5te-vfp.S +++ b/vm/mterp/out/InterpAsm-armv5te-vfp.S @@ -63,7 +63,7 @@ The following registers have fixed assignments: reg nick purpose r4 rPC interpreted program counter, used for fetching instructions r5 rFP interpreted frame pointer, used for accessing locals and args - r6 rGLUE MterpGlue pointer + r6 rSELF self (Thread) pointer r7 rINST first 16-bit code unit of current instruction r8 rIBASE interpreted instruction base pointer, used for computed goto @@ -75,17 +75,17 @@ unspecified registers or condition codes. /* single-purpose registers, given names for clarity */ #define rPC r4 #define rFP r5 -#define rGLUE r6 +#define rSELF r6 #define rINST r7 #define rIBASE r8 -/* save/restore the PC and/or FP from the glue struct */ -#define LOAD_PC_FROM_GLUE() ldr rPC, [rGLUE, #offGlue_pc] -#define SAVE_PC_TO_GLUE() str rPC, [rGLUE, #offGlue_pc] -#define LOAD_FP_FROM_GLUE() ldr rFP, [rGLUE, #offGlue_fp] -#define SAVE_FP_TO_GLUE() str rFP, [rGLUE, #offGlue_fp] -#define LOAD_PC_FP_FROM_GLUE() ldmia rGLUE, {rPC, rFP} -#define SAVE_PC_FP_TO_GLUE() stmia rGLUE, {rPC, rFP} +/* save/restore the PC and/or FP from the thread struct */ +#define LOAD_PC_FROM_SELF() ldr rPC, [rSELF, #offThread_pc] +#define SAVE_PC_TO_SELF() str rPC, [rSELF, #offThread_pc] +#define LOAD_FP_FROM_SELF() ldr rFP, [rSELF, #offThread_fp] +#define SAVE_FP_TO_SELF() str rFP, [rSELF, #offThread_fp] +#define LOAD_PC_FP_FROM_SELF() ldmia rSELF, {rPC, rFP} +#define SAVE_PC_FP_TO_SELF() stmia rSELF, {rPC, rFP} /* * "export" the PC to the stack frame, f/b/o future exception objects. Must @@ -186,8 +186,8 @@ unspecified registers or condition codes. #define SET_VREG(_reg, _vreg) str _reg, [rFP, _vreg, lsl #2] #if defined(WITH_JIT) -#define GET_JIT_PROF_TABLE(_reg) ldr _reg,[rGLUE,#offGlue_pJitProfTable] -#define GET_JIT_THRESHOLD(_reg) ldr _reg,[rGLUE,#offGlue_jitThreshold] +#define GET_JIT_PROF_TABLE(_reg) ldr _reg,[rSELF,#offThread_pJitProfTable] +#define GET_JIT_THRESHOLD(_reg) ldr _reg,[rSELF,#offThread_jitThreshold] #endif /* @@ -266,7 +266,7 @@ unspecified registers or condition codes. /* * On entry: - * r0 MterpGlue* glue + * r0 Thread* self * * This function returns a boolean "changeInterp" value. The return comes * via a call to dvmMterpStdBail(). @@ -284,29 +284,28 @@ dvmMterpStdRun: MTERP_ENTRY2 /* save stack pointer, add magic word for debuggerd */ - str sp, [r0, #offGlue_bailPtr] @ save SP for eventual return + str sp, [r0, #offThread_bailPtr] @ save SP for eventual return /* set up "named" registers, figure out entry point */ - mov rGLUE, r0 @ set rGLUE - ldr r1, [r0, #offGlue_entryPoint] @ enum is 4 bytes in aapcs-EABI - LOAD_PC_FP_FROM_GLUE() @ load rPC and rFP from "glue" + mov rSELF, r0 @ set rSELF + ldr r1, [r0, #offThread_entryPoint] @ enum is 4 bytes in aapcs-EABI + LOAD_PC_FP_FROM_SELF() @ load rPC and rFP from "thread" adr rIBASE, dvmAsmInstructionStart @ set rIBASE cmp r1, #kInterpEntryInstr @ usual case? bne .Lnot_instr @ no, handle it #if defined(WITH_JIT) .LentryInstr: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self /* Entry is always a possible trace start */ GET_JIT_PROF_TABLE(r0) FETCH_INST() mov r1, #0 @ prepare the value for the new state - str r1, [r10, #offThread_inJitCodeCache] @ back to the interp land + str r1, [rSELF, #offThread_inJitCodeCache] @ back to the interp land cmp r0,#0 @ is profiling disabled? #if !defined(WITH_SELF_VERIFICATION) bne common_updateProfile @ profiling is enabled #else - ldr r2, [r10, #offThread_shadowSpace] @ to find out the jit exit state + ldr r2, [rSELF, #offThread_shadowSpace] @ to find out the jit exit state beq 1f @ profiling is disabled ldr r3, [r2, #offShadowSpace_jitExitState] @ jit exit state cmp r3, #kSVSTraceSelect @ hot trace following? @@ -336,20 +335,20 @@ dvmMterpStdRun: #if defined(WITH_JIT) .Lnot_throw: - ldr r10,[rGLUE, #offGlue_jitResumeNPC] - ldr r2,[rGLUE, #offGlue_jitResumeDPC] + ldr r10,[rSELF, #offThread_jitResumeNPC] + ldr r2,[rSELF, #offThread_jitResumeDPC] cmp r1, #kInterpEntryResume @ resuming after Jit single-step? bne .Lbad_arg cmp rPC,r2 bne .LentryInstr @ must have branched, don't resume #if defined(WITH_SELF_VERIFICATION) - @ glue->entryPoint will be set in dvmSelfVerificationSaveState + @ self->entryPoint will be set in dvmSelfVerificationSaveState b jitSVShadowRunStart @ re-enter the translation after the @ single-stepped instruction @noreturn #endif mov r1, #kInterpEntryInstr - str r1, [rGLUE, #offGlue_entryPoint] + str r1, [rSELF, #offThread_entryPoint] bx r10 @ re-enter the translation #endif @@ -375,11 +374,11 @@ dvmMterpStdRun: * LR to PC. * * On entry: - * r0 MterpGlue* glue + * r0 Thread* self * r1 bool changeInterp */ dvmMterpStdBail: - ldr sp, [r0, #offGlue_bailPtr] @ sp<- saved SP + ldr sp, [r0, #offThread_bailPtr] @ sp<- saved SP mov r0, r1 @ return the changeInterp value add sp, sp, #4 @ un-align 64 ldmfd sp!, {r4-r10,fp,pc} @ restore 9 regs and return @@ -564,7 +563,7 @@ dalvik_inst: /* op vAA */ mov r2, rINST, lsr #8 @ r2<- AA FETCH_ADVANCE_INST(1) @ advance rPC, load rINST - ldr r0, [rGLUE, #offGlue_retval] @ r0<- glue->retval.i + ldr r0, [rSELF, #offThread_retval] @ r0<- self->retval.i GET_INST_OPCODE(ip) @ extract opcode from rINST SET_VREG(r0, r2) @ fp[AA]<- r0 GOTO_OPCODE(ip) @ jump to next instruction @@ -575,7 +574,7 @@ dalvik_inst: /* File: armv5te/OP_MOVE_RESULT_WIDE.S */ /* move-result-wide vAA */ mov r2, rINST, lsr #8 @ r2<- AA - add r3, rGLUE, #offGlue_retval @ r3<- &glue->retval + add r3, rSELF, #offThread_retval @ r3<- &self->retval add r2, rFP, r2, lsl #2 @ r2<- &fp[AA] ldmia r3, {r0-r1} @ r0/r1<- retval.j FETCH_ADVANCE_INST(1) @ advance rPC, load rINST @@ -592,7 +591,7 @@ dalvik_inst: /* op vAA */ mov r2, rINST, lsr #8 @ r2<- AA FETCH_ADVANCE_INST(1) @ advance rPC, load rINST - ldr r0, [rGLUE, #offGlue_retval] @ r0<- glue->retval.i + ldr r0, [rSELF, #offThread_retval] @ r0<- self->retval.i GET_INST_OPCODE(ip) @ extract opcode from rINST SET_VREG(r0, r2) @ fp[AA]<- r0 GOTO_OPCODE(ip) @ jump to next instruction @@ -603,14 +602,13 @@ dalvik_inst: .L_OP_MOVE_EXCEPTION: /* 0x0d */ /* File: armv5te/OP_MOVE_EXCEPTION.S */ /* move-exception vAA */ - ldr r0, [rGLUE, #offGlue_self] @ r0<- glue->self mov r2, rINST, lsr #8 @ r2<- AA - ldr r3, [r0, #offThread_exception] @ r3<- dvmGetException bypass + ldr r3, [rSELF, #offThread_exception] @ r3<- dvmGetException bypass mov r1, #0 @ r1<- 0 FETCH_ADVANCE_INST(1) @ advance rPC, load rINST SET_VREG(r3, r2) @ fp[AA]<- exception obj GET_INST_OPCODE(ip) @ extract opcode from rINST - str r1, [r0, #offThread_exception] @ dvmClearException bypass + str r1, [rSELF, #offThread_exception] @ dvmClearException bypass GOTO_OPCODE(ip) @ jump to next instruction /* ------------------------------ */ @@ -624,7 +622,7 @@ dalvik_inst: .L_OP_RETURN: /* 0x0f */ /* File: armv5te/OP_RETURN.S */ /* - * Return a 32-bit value. Copies the return value into the "glue" + * Return a 32-bit value. Copies the return value into the "thread" * structure, then jumps to the return handler. * * for: return, return-object @@ -632,7 +630,7 @@ dalvik_inst: /* op vAA */ mov r2, rINST, lsr #8 @ r2<- AA GET_VREG(r0, r2) @ r0<- vAA - str r0, [rGLUE, #offGlue_retval] @ retval.i <- vAA + str r0, [rSELF, #offThread_retval] @ retval.i <- vAA b common_returnFromMethod /* ------------------------------ */ @@ -640,13 +638,13 @@ dalvik_inst: .L_OP_RETURN_WIDE: /* 0x10 */ /* File: armv5te/OP_RETURN_WIDE.S */ /* - * Return a 64-bit value. Copies the return value into the "glue" + * Return a 64-bit value. Copies the return value into the "thread" * structure, then jumps to the return handler. */ /* return-wide vAA */ mov r2, rINST, lsr #8 @ r2<- AA add r2, rFP, r2, lsl #2 @ r2<- &fp[AA] - add r3, rGLUE, #offGlue_retval @ r3<- &glue->retval + add r3, rSELF, #offThread_retval @ r3<- &self->retval ldmia r2, {r0-r1} @ r0/r1 <- vAA/vAA+1 stmia r3, {r0-r1} @ retval<- r0/r1 b common_returnFromMethod @@ -657,7 +655,7 @@ dalvik_inst: /* File: armv5te/OP_RETURN_OBJECT.S */ /* File: armv5te/OP_RETURN.S */ /* - * Return a 32-bit value. Copies the return value into the "glue" + * Return a 32-bit value. Copies the return value into the "thread" * structure, then jumps to the return handler. * * for: return, return-object @@ -665,7 +663,7 @@ dalvik_inst: /* op vAA */ mov r2, rINST, lsr #8 @ r2<- AA GET_VREG(r0, r2) @ r0<- vAA - str r0, [rGLUE, #offGlue_retval] @ retval.i <- vAA + str r0, [rSELF, #offThread_retval] @ retval.i <- vAA b common_returnFromMethod @@ -791,7 +789,7 @@ dalvik_inst: /* File: armv5te/OP_CONST_STRING.S */ /* const/string vAA, String@BBBB */ FETCH(r1, 1) @ r1<- BBBB - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- glue->methodClassDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- self->methodClassDex mov r9, rINST, lsr #8 @ r9<- AA ldr r2, [r2, #offDvmDex_pResStrings] @ r2<- dvmDex->pResStrings ldr r0, [r2, r1, lsl #2] @ r0<- pResStrings[BBBB] @@ -809,7 +807,7 @@ dalvik_inst: /* const/string vAA, String@BBBBBBBB */ FETCH(r0, 1) @ r0<- bbbb (low) FETCH(r1, 2) @ r1<- BBBB (high) - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- glue->methodClassDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- self->methodClassDex mov r9, rINST, lsr #8 @ r9<- AA ldr r2, [r2, #offDvmDex_pResStrings] @ r2<- dvmDex->pResStrings orr r1, r0, r1, lsl #16 @ r1<- BBBBbbbb @@ -827,7 +825,7 @@ dalvik_inst: /* File: armv5te/OP_CONST_CLASS.S */ /* const/class vAA, Class@BBBB */ FETCH(r1, 1) @ r1<- BBBB - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- glue->methodClassDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- self->methodClassDex mov r9, rINST, lsr #8 @ r9<- AA ldr r2, [r2, #offDvmDex_pResClasses] @ r2<- dvmDex->pResClasses ldr r0, [r2, r1, lsl #2] @ r0<- pResClasses[BBBB] @@ -848,7 +846,7 @@ dalvik_inst: /* monitor-enter vAA */ mov r2, rINST, lsr #8 @ r2<- AA GET_VREG(r1, r2) @ r1<- vAA (object) - ldr r0, [rGLUE, #offGlue_self] @ r0<- glue->self + mov r0, rSELF @ r0<- self cmp r1, #0 @ null object? EXPORT_PC() @ need for precise GC beq common_errNullObject @ null object, throw an exception @@ -874,7 +872,7 @@ dalvik_inst: GET_VREG(r1, r2) @ r1<- vAA (object) cmp r1, #0 @ null object? beq 1f @ yes - ldr r0, [rGLUE, #offGlue_self] @ r0<- glue->self + mov r0, rSELF @ r0<- self bl dvmUnlockObject @ r0<- success for unlock(self, obj) cmp r0, #0 @ failed? FETCH_ADVANCE_INST(1) @ before throw: advance rPC, load rINST @@ -896,7 +894,7 @@ dalvik_inst: mov r3, rINST, lsr #8 @ r3<- AA FETCH(r2, 1) @ r2<- BBBB GET_VREG(r9, r3) @ r9<- object - ldr r0, [rGLUE, #offGlue_methodClassDex] @ r0<- pDvmDex + ldr r0, [rSELF, #offThread_methodClassDex] @ r0<- pDvmDex cmp r9, #0 @ is object null? ldr r0, [r0, #offDvmDex_pResClasses] @ r0<- pDvmDex->pResClasses beq .LOP_CHECK_CAST_okay @ null obj, cast always succeeds @@ -928,7 +926,7 @@ dalvik_inst: GET_VREG(r0, r3) @ r0<- vB (object) and r9, r9, #15 @ r9<- A cmp r0, #0 @ is object null? - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- pDvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- pDvmDex beq .LOP_INSTANCE_OF_store @ null obj, not an instance, store r0 FETCH(r3, 1) @ r3<- CCCC ldr r2, [r2, #offDvmDex_pResClasses] @ r2<- pDvmDex->pResClasses @@ -968,7 +966,7 @@ dalvik_inst: * Create a new instance of a class. */ /* new-instance vAA, class@BBBB */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r1, 1) @ r1<- BBBB ldr r3, [r3, #offDvmDex_pResClasses] @ r3<- pDvmDex->pResClasses ldr r0, [r3, r1, lsl #2] @ r0<- resolved class @@ -998,7 +996,7 @@ dalvik_inst: /* new-array vA, vB, class@CCCC */ mov r0, rINST, lsr #12 @ r0<- B FETCH(r2, 1) @ r2<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex GET_VREG(r1, r0) @ r1<- vB (array length) ldr r3, [r3, #offDvmDex_pResClasses] @ r3<- pDvmDex->pResClasses cmp r1, #0 @ check length @@ -1020,7 +1018,7 @@ dalvik_inst: */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op {vCCCC..v(CCCC+AA-1)}, type@BBBB */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r1, 1) @ r1<- BBBB ldr r3, [r3, #offDvmDex_pResClasses] @ r3<- pDvmDex->pResClasses EXPORT_PC() @ need for resolve and alloc @@ -1028,7 +1026,7 @@ dalvik_inst: mov r10, rINST, lsr #8 @ r10<- AA or BA cmp r0, #0 @ already resolved? bne .LOP_FILLED_NEW_ARRAY_continue @ yes, continue on -8: ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method +8: ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r2, #0 @ r2<- false ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveClass @ r0<- call(clazz, ref) @@ -1048,7 +1046,7 @@ dalvik_inst: */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op {vCCCC..v(CCCC+AA-1)}, type@BBBB */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r1, 1) @ r1<- BBBB ldr r3, [r3, #offDvmDex_pResClasses] @ r3<- pDvmDex->pResClasses EXPORT_PC() @ need for resolve and alloc @@ -1056,7 +1054,7 @@ dalvik_inst: mov r10, rINST, lsr #8 @ r10<- AA or BA cmp r0, #0 @ already resolved? bne .LOP_FILLED_NEW_ARRAY_RANGE_continue @ yes, continue on -8: ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method +8: ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r2, #0 @ r2<- false ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveClass @ r0<- call(clazz, ref) @@ -1094,12 +1092,11 @@ dalvik_inst: /* throw vAA */ mov r2, rINST, lsr #8 @ r2<- AA GET_VREG(r1, r2) @ r1<- vAA (exception object) - ldr r0, [rGLUE, #offGlue_self] @ r0<- glue->self EXPORT_PC() @ exception handler can throw cmp r1, #0 @ null object? beq common_errNullObject @ yes, throw an NPE instead @ bypass dvmSetException, just store it - str r1, [r0, #offThread_exception] @ thread->exception<- obj + str r1, [rSELF, #offThread_exception] @ thread->exception<- obj b common_exceptionThrown /* ------------------------------ */ @@ -2383,14 +2380,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2407,14 +2404,14 @@ dalvik_inst: */ /* iget-wide vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_WIDE_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2434,14 +2431,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_OBJECT_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2463,14 +2460,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_BOOLEAN_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2492,14 +2489,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_BYTE_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2521,14 +2518,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_CHAR_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2550,14 +2547,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_SHORT_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2577,14 +2574,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2598,14 +2595,14 @@ dalvik_inst: /* File: armv5te/OP_IPUT_WIDE.S */ /* iput-wide vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_WIDE_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2624,14 +2621,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_OBJECT_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2652,14 +2649,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_BOOLEAN_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2681,14 +2678,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_BYTE_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2710,14 +2707,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_CHAR_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2739,14 +2736,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_SHORT_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2765,7 +2762,7 @@ dalvik_inst: * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -2788,7 +2785,7 @@ dalvik_inst: * 64-bit SGET handler. */ /* sget-wide vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -2819,7 +2816,7 @@ dalvik_inst: * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -2846,7 +2843,7 @@ dalvik_inst: * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -2873,7 +2870,7 @@ dalvik_inst: * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -2900,7 +2897,7 @@ dalvik_inst: * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -2927,7 +2924,7 @@ dalvik_inst: * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -2953,7 +2950,7 @@ dalvik_inst: * for: sput, sput-boolean, sput-byte, sput-char, sput-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -2976,7 +2973,7 @@ dalvik_inst: * 64-bit SPUT handler. */ /* sput-wide vAA, field@BBBB */ - ldr r0, [rGLUE, #offGlue_methodClassDex] @ r0<- DvmDex + ldr r0, [rSELF, #offThread_methodClassDex] @ r0<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r0, [r0, #offDvmDex_pResFields] @ r0<- dvmDex->pResFields mov r9, rINST, lsr #8 @ r9<- AA @@ -3006,13 +3003,13 @@ dalvik_inst: * for: sput-object, sput-object-volatile */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_SPUT_OBJECT_finish @ no, continue - ldr r9, [rGLUE, #offGlue_method] @ r9<- current method + ldr r9, [rSELF, #offThread_method] @ r9<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r9, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -3032,7 +3029,7 @@ dalvik_inst: * for: sput, sput-boolean, sput-byte, sput-char, sput-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -3059,7 +3056,7 @@ dalvik_inst: * for: sput, sput-boolean, sput-byte, sput-char, sput-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -3086,7 +3083,7 @@ dalvik_inst: * for: sput, sput-boolean, sput-byte, sput-char, sput-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -3113,7 +3110,7 @@ dalvik_inst: * for: sput, sput-boolean, sput-byte, sput-char, sput-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -3140,7 +3137,7 @@ dalvik_inst: */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r1, 1) @ r1<- BBBB ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods FETCH(r10, 2) @ r10<- GFED or CCCC @@ -3151,7 +3148,7 @@ dalvik_inst: cmp r0, #0 @ already resolved? EXPORT_PC() @ must export for invoke bne .LOP_INVOKE_VIRTUAL_continue @ yes, continue on - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_VIRTUAL @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) @@ -3171,7 +3168,7 @@ dalvik_inst: /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ FETCH(r10, 2) @ r10<- GFED or CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex .if (!0) and r10, r10, #15 @ r10<- D (or stays CCCC) .endif @@ -3180,7 +3177,7 @@ dalvik_inst: GET_VREG(r2, r10) @ r2<- "this" ptr ldr r0, [r3, r1, lsl #2] @ r0<- resolved baseMethod cmp r2, #0 @ null "this"? - ldr r9, [rGLUE, #offGlue_method] @ r9<- current method + ldr r9, [rSELF, #offThread_method] @ r9<- current method beq common_errNullObject @ null "this", throw exception cmp r0, #0 @ already resolved? ldr r9, [r9, #offMethod_clazz] @ r9<- method->clazz @@ -3204,7 +3201,7 @@ dalvik_inst: */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r1, 1) @ r1<- BBBB ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods FETCH(r10, 2) @ r10<- GFED or CCCC @@ -3232,14 +3229,14 @@ dalvik_inst: */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r1, 1) @ r1<- BBBB ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods ldr r0, [r3, r1, lsl #2] @ r0<- resolved methodToCall cmp r0, #0 @ already resolved? EXPORT_PC() @ must export for invoke bne common_invokeMethodNoRange @ yes, continue on -0: ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method +0: ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_STATIC @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) @@ -3265,9 +3262,9 @@ dalvik_inst: .endif EXPORT_PC() @ must export for invoke GET_VREG(r0, r2) @ r0<- first arg ("this") - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- methodClassDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- methodClassDex cmp r0, #0 @ null obj? - ldr r2, [rGLUE, #offGlue_method] @ r2<- method + ldr r2, [rSELF, #offThread_method] @ r2<- method beq common_errNullObject @ yes, fail ldr r0, [r0, #offObject_clazz] @ r0<- thisPtr->clazz bl dvmFindInterfaceMethodInCache @ r0<- call(class, ref, method, dex) @@ -3295,7 +3292,7 @@ dalvik_inst: */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r1, 1) @ r1<- BBBB ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods FETCH(r10, 2) @ r10<- GFED or CCCC @@ -3306,7 +3303,7 @@ dalvik_inst: cmp r0, #0 @ already resolved? EXPORT_PC() @ must export for invoke bne .LOP_INVOKE_VIRTUAL_RANGE_continue @ yes, continue on - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_VIRTUAL @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) @@ -3328,7 +3325,7 @@ dalvik_inst: /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ FETCH(r10, 2) @ r10<- GFED or CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex .if (!1) and r10, r10, #15 @ r10<- D (or stays CCCC) .endif @@ -3337,7 +3334,7 @@ dalvik_inst: GET_VREG(r2, r10) @ r2<- "this" ptr ldr r0, [r3, r1, lsl #2] @ r0<- resolved baseMethod cmp r2, #0 @ null "this"? - ldr r9, [rGLUE, #offGlue_method] @ r9<- current method + ldr r9, [rSELF, #offThread_method] @ r9<- current method beq common_errNullObject @ null "this", throw exception cmp r0, #0 @ already resolved? ldr r9, [r9, #offMethod_clazz] @ r9<- method->clazz @@ -3363,7 +3360,7 @@ dalvik_inst: */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r1, 1) @ r1<- BBBB ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods FETCH(r10, 2) @ r10<- GFED or CCCC @@ -3393,14 +3390,14 @@ dalvik_inst: */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r1, 1) @ r1<- BBBB ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods ldr r0, [r3, r1, lsl #2] @ r0<- resolved methodToCall cmp r0, #0 @ already resolved? EXPORT_PC() @ must export for invoke bne common_invokeMethodRange @ yes, continue on -0: ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method +0: ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_STATIC @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) @@ -3428,9 +3425,9 @@ dalvik_inst: .endif EXPORT_PC() @ must export for invoke GET_VREG(r0, r2) @ r0<- first arg ("this") - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- methodClassDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- methodClassDex cmp r0, #0 @ null obj? - ldr r2, [rGLUE, #offGlue_method] @ r2<- method + ldr r2, [rSELF, #offThread_method] @ r2<- method beq common_errNullObject @ yes, fail ldr r0, [r0, #offObject_clazz] @ r0<- thisPtr->clazz bl dvmFindInterfaceMethodInCache @ r0<- call(class, ref, method, dex) @@ -7088,14 +7085,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_VOLATILE_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -7116,14 +7113,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_VOLATILE_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -7143,7 +7140,7 @@ dalvik_inst: * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -7170,7 +7167,7 @@ dalvik_inst: * for: sput, sput-boolean, sput-byte, sput-char, sput-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -7198,14 +7195,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_OBJECT_VOLATILE_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -7224,14 +7221,14 @@ dalvik_inst: */ /* iget-wide vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_WIDE_VOLATILE_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -7247,14 +7244,14 @@ dalvik_inst: /* File: armv5te/OP_IPUT_WIDE.S */ /* iput-wide vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_WIDE_VOLATILE_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -7272,7 +7269,7 @@ dalvik_inst: * 64-bit SGET handler. */ /* sget-wide vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -7302,7 +7299,7 @@ dalvik_inst: * 64-bit SPUT handler. */ /* sput-wide vAA, field@BBBB */ - ldr r0, [rGLUE, #offGlue_methodClassDex] @ r0<- DvmDex + ldr r0, [rSELF, #offThread_methodClassDex] @ r0<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r0, [r0, #offDvmDex_pResFields] @ r0<- dvmDex->pResFields mov r9, rINST, lsr #8 @ r9<- AA @@ -7341,7 +7338,7 @@ dalvik_inst: * exception is indicated by AA, with some detail provided by BBBB. */ /* op AA, ref@BBBB */ - ldr r0, [rGLUE, #offGlue_method] @ r0<- glue->method + ldr r0, [rSELF, #offThread_method] @ r0<- self->method FETCH(r2, 1) @ r2<- BBBB EXPORT_PC() @ export the PC mov r1, rINST, lsr #8 @ r1<- AA @@ -7364,11 +7361,11 @@ dalvik_inst: */ /* [opt] execute-inline vAA, {vC, vD, vE, vF}, inline@BBBB */ FETCH(r10, 1) @ r10<- BBBB - add r1, rGLUE, #offGlue_retval @ r1<- &glue->retval + add r1, rSELF, #offThread_retval @ r1<- &self->retval EXPORT_PC() @ can throw sub sp, sp, #8 @ make room for arg, +64 bit align mov r0, rINST, lsr #12 @ r0<- B - str r1, [sp] @ push &glue->retval + str r1, [sp] @ push &self->retval bl .LOP_EXECUTE_INLINE_continue @ make call; will return after add sp, sp, #8 @ pop stack cmp r0, #0 @ test boolean result of inline @@ -7394,11 +7391,11 @@ dalvik_inst: */ /* [opt] execute-inline/range {vCCCC..v(CCCC+AA-1)}, inline@BBBB */ FETCH(r10, 1) @ r10<- BBBB - add r1, rGLUE, #offGlue_retval @ r1<- &glue->retval + add r1, rSELF, #offThread_retval @ r1<- &self->retval EXPORT_PC() @ can throw sub sp, sp, #8 @ make room for arg, +64 bit align mov r0, rINST, lsr #8 @ r0<- AA - str r1, [sp] @ push &glue->retval + str r1, [sp] @ push &self->retval bl .LOP_EXECUTE_INLINE_RANGE_continue @ make call; will return after add sp, sp, #8 @ pop stack cmp r0, #0 @ test boolean result of inline @@ -7548,7 +7545,7 @@ dalvik_inst: beq common_errNullObject @ object was null and r2, r2, #15 GET_VREG(r0, r2) @ r0<- fp[A] - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base FETCH_ADVANCE_INST(2) @ advance rPC, load rINST str r0, [r3, r1] @ obj.field (always 32 bits)<- r0 cmp r0, #0 @@ -7620,7 +7617,7 @@ dalvik_inst: /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ FETCH(r10, 2) @ r10<- GFED or CCCC - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method .if (!0) and r10, r10, #15 @ r10<- D (or stays CCCC) .endif @@ -7648,7 +7645,7 @@ dalvik_inst: /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ FETCH(r10, 2) @ r10<- GFED or CCCC - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method .if (!1) and r10, r10, #15 @ r10<- D (or stays CCCC) .endif @@ -7676,14 +7673,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_OBJECT_VOLATILE_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -7703,7 +7700,7 @@ dalvik_inst: * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -7730,13 +7727,13 @@ dalvik_inst: * for: sput-object, sput-object-volatile */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_SPUT_OBJECT_VOLATILE_finish @ no, continue - ldr r9, [rGLUE, #offGlue_method] @ r9<- current method + ldr r9, [rSELF, #offThread_method] @ r9<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r9, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -7761,7 +7758,7 @@ dalvik_inst: /* File: armv5te/OP_CONST_CLASS_JUMBO.S */ /* const-class/jumbo vBBBB, Class@AAAAAAAA */ FETCH(r0, 1) @ r0<- aaaa (lo) - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- glue->methodClassDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<-self>methodClassDex FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResClasses] @ r2<- dvmDex->pResClasses orr r1, r0, r1, lsl #16 @ r1<- AAAAaaaa @@ -7787,7 +7784,7 @@ dalvik_inst: FETCH(r3, 3) @ r3<- BBBB orr r2, r0, r2, lsl #16 @ r2<- AAAAaaaa GET_VREG(r9, r3) @ r9<- object - ldr r0, [rGLUE, #offGlue_methodClassDex] @ r0<- pDvmDex + ldr r0, [rSELF, #offThread_methodClassDex] @ r0<- pDvmDex cmp r9, #0 @ is object null? ldr r0, [r0, #offDvmDex_pResClasses] @ r0<- pDvmDex->pResClasses beq .LOP_CHECK_CAST_JUMBO_okay @ null obj, cast always succeeds @@ -7817,7 +7814,7 @@ dalvik_inst: FETCH(r3, 4) @ r3<- vCCCC FETCH(r9, 3) @ r9<- vBBBB GET_VREG(r0, r3) @ r0<- vCCCC (object) - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- pDvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- pDvmDex cmp r0, #0 @ is object null? beq .LOP_INSTANCE_OF_JUMBO_store @ null obj, not an instance, store r0 FETCH(r1, 1) @ r1<- aaaa (lo) @@ -7840,7 +7837,7 @@ dalvik_inst: /* new-instance/jumbo vBBBB, class@AAAAAAAA */ FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex orr r1, r0, r1, lsl #16 @ r1<- AAAAaaaa ldr r3, [r3, #offDvmDex_pResClasses] @ r3<- pDvmDex->pResClasses ldr r0, [r3, r1, lsl #2] @ r0<- resolved class @@ -7872,7 +7869,7 @@ dalvik_inst: FETCH(r3, 2) @ r3<- AAAA (hi) FETCH(r0, 4) @ r0<- vCCCC orr r2, r2, r3, lsl #16 @ r2<- AAAAaaaa - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex GET_VREG(r1, r0) @ r1<- vCCCC (array length) ldr r3, [r3, #offDvmDex_pResClasses] @ r3<- pDvmDex->pResClasses cmp r1, #0 @ check length @@ -7894,7 +7891,7 @@ dalvik_inst: * OP_FILLED_NEW_ARRAY.S. */ /* filled-new-array/jumbo {vCCCC..v(CCCC+BBBB-1)}, type@AAAAAAAA */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r3, [r3, #offDvmDex_pResClasses] @ r3<- pDvmDex->pResClasses @@ -7903,7 +7900,7 @@ dalvik_inst: EXPORT_PC() @ need for resolve and alloc cmp r0, #0 @ already resolved? bne .LOP_FILLED_NEW_ARRAY_JUMBO_continue @ yes, continue on -8: ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method +8: ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r2, #0 @ r2<- false ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveClass @ r0<- call(clazz, ref) @@ -7925,14 +7922,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -7949,14 +7946,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_WIDE_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -7977,14 +7974,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_OBJECT_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8007,14 +8004,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_BOOLEAN_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8037,14 +8034,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_BYTE_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8067,14 +8064,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_CHAR_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8097,14 +8094,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_SHORT_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8125,14 +8122,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8146,14 +8143,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_WIDE_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8170,14 +8167,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_OBJECT_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8199,14 +8196,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_BOOLEAN_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8229,14 +8226,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_BYTE_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8259,14 +8256,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_CHAR_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8289,14 +8286,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_SHORT_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8314,7 +8311,7 @@ dalvik_inst: * sget-char/jumbo, sget-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8339,7 +8336,7 @@ dalvik_inst: * Jumbo 64-bit SGET handler. */ /* sget-wide/jumbo vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8368,7 +8365,7 @@ dalvik_inst: * sget-char/jumbo, sget-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8398,7 +8395,7 @@ dalvik_inst: * sget-char/jumbo, sget-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8428,7 +8425,7 @@ dalvik_inst: * sget-char/jumbo, sget-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8458,7 +8455,7 @@ dalvik_inst: * sget-char/jumbo, sget-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8488,7 +8485,7 @@ dalvik_inst: * sget-char/jumbo, sget-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8517,7 +8514,7 @@ dalvik_inst: * sput-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8542,7 +8539,7 @@ dalvik_inst: * Jumbo 64-bit SPUT handler. */ /* sput-wide/jumbo vBBBB, field@AAAAAAAA */ - ldr r0, [rGLUE, #offGlue_methodClassDex] @ r0<- DvmDex + ldr r0, [rSELF, #offThread_methodClassDex] @ r0<- DvmDex FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) ldr r0, [r0, #offDvmDex_pResFields] @ r0<- dvmDex->pResFields @@ -8567,7 +8564,7 @@ dalvik_inst: * Jumbo 32-bit SPUT handler for objects */ /* sput-object/jumbo vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8575,7 +8572,7 @@ dalvik_inst: ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_SPUT_OBJECT_JUMBO_finish @ no, continue - ldr r9, [rGLUE, #offGlue_method] @ r9<- current method + ldr r9, [rSELF, #offThread_method] @ r9<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r9, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -8595,7 +8592,7 @@ dalvik_inst: * sput-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8625,7 +8622,7 @@ dalvik_inst: * sput-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8655,7 +8652,7 @@ dalvik_inst: * sput-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8685,7 +8682,7 @@ dalvik_inst: * sput-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8711,7 +8708,7 @@ dalvik_inst: * Handle a virtual method call. */ /* invoke-virtual/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r0, 1) @ r1<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods @@ -8720,7 +8717,7 @@ dalvik_inst: cmp r0, #0 @ already resolved? EXPORT_PC() @ must export for invoke bne .LOP_INVOKE_VIRTUAL_JUMBO_continue @ yes, continue on - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_VIRTUAL @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) @@ -8737,7 +8734,7 @@ dalvik_inst: */ /* invoke-super/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ FETCH(r10, 4) @ r10<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r0, 1) @ r1<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods @@ -8745,7 +8742,7 @@ dalvik_inst: GET_VREG(r2, r10) @ r2<- "this" ptr ldr r0, [r3, r1, lsl #2] @ r0<- resolved baseMethod cmp r2, #0 @ null "this"? - ldr r9, [rGLUE, #offGlue_method] @ r9<- current method + ldr r9, [rSELF, #offThread_method] @ r9<- current method beq common_errNullObject @ null "this", throw exception cmp r0, #0 @ already resolved? ldr r9, [r9, #offMethod_clazz] @ r9<- method->clazz @@ -8767,7 +8764,7 @@ dalvik_inst: * */ /* invoke-direct/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r0, 1) @ r1<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods @@ -8791,7 +8788,7 @@ dalvik_inst: * Handle a static method call. */ /* invoke-static/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r0, 1) @ r1<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods @@ -8800,7 +8797,7 @@ dalvik_inst: cmp r0, #0 @ already resolved? EXPORT_PC() @ must export for invoke bne common_invokeMethodJumbo @ yes, continue on -0: ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method +0: ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_STATIC @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) @@ -8822,9 +8819,9 @@ dalvik_inst: EXPORT_PC() @ must export for invoke orr r1, r0, r1, lsl #16 @ r1<- AAAAaaaa GET_VREG(r0, r2) @ r0<- first arg ("this") - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- methodClassDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- methodClassDex cmp r0, #0 @ null obj? - ldr r2, [rGLUE, #offGlue_method] @ r2<- method + ldr r2, [rSELF, #offThread_method] @ r2<- method beq common_errNullObject @ yes, fail ldr r0, [r0, #offObject_clazz] @ r0<- thisPtr->clazz bl dvmFindInterfaceMethodInCache @ r0<- call(class, ref, method, dex) @@ -10572,7 +10569,7 @@ dalvik_inst: /* exop BBBB, Class@AAAAAAAA */ FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) - ldr r0, [rGLUE, #offGlue_method] @ r0<- glue->method + ldr r0, [rSELF, #offThread_method] @ r0<- self->method orr r2, r1, r2, lsl #16 @ r2<- AAAAaaaa EXPORT_PC() @ export the PC FETCH(r1, 3) @ r1<- BBBB @@ -10605,7 +10602,7 @@ dvmAsmSisterStart: */ .LOP_CONST_STRING_resolve: EXPORT_PC() - ldr r0, [rGLUE, #offGlue_method] @ r0<- glue->method + ldr r0, [rSELF, #offThread_method] @ r0<- self->method ldr r0, [r0, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveString @ r0<- String reference cmp r0, #0 @ failed? @@ -10624,7 +10621,7 @@ dvmAsmSisterStart: */ .LOP_CONST_STRING_JUMBO_resolve: EXPORT_PC() - ldr r0, [rGLUE, #offGlue_method] @ r0<- glue->method + ldr r0, [rSELF, #offThread_method] @ r0<- self->method ldr r0, [r0, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveString @ r0<- String reference cmp r0, #0 @ failed? @@ -10643,7 +10640,7 @@ dvmAsmSisterStart: */ .LOP_CONST_CLASS_resolve: EXPORT_PC() - ldr r0, [rGLUE, #offGlue_method] @ r0<- glue->method + ldr r0, [rSELF, #offThread_method] @ r0<- self->method mov r2, #1 @ r2<- true ldr r0, [r0, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveClass @ r0<- Class reference @@ -10683,7 +10680,7 @@ dvmAsmSisterStart: */ .LOP_CHECK_CAST_resolve: EXPORT_PC() @ resolve() could throw - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r1, r2 @ r1<- BBBB mov r2, #0 @ r2<- false ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz @@ -10736,7 +10733,7 @@ dvmAsmSisterStart: */ .LOP_INSTANCE_OF_resolve: EXPORT_PC() @ resolve() could throw - ldr r0, [rGLUE, #offGlue_method] @ r0<- glue->method + ldr r0, [rSELF, #offThread_method] @ r0<- self->method mov r1, r3 @ r1<- BBBB mov r2, #1 @ r2<- true ldr r0, [r0, #offMethod_clazz] @ r0<- method->clazz @@ -10780,7 +10777,7 @@ dvmAsmSisterStart: * r1 holds BBBB */ .LOP_NEW_INSTANCE_resolve: - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r2, #0 @ r2<- false ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveClass @ r0<- resolved ClassObject ptr @@ -10801,7 +10798,7 @@ dvmAsmSisterStart: * r2 holds class ref CCCC */ .LOP_NEW_ARRAY_resolve: - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r9, r1 @ r9<- length (save) mov r1, r2 @ r1<- CCCC mov r2, #0 @ r2<- false @@ -10856,8 +10853,8 @@ dvmAsmSisterStart: beq common_exceptionThrown @ alloc failed, handle exception FETCH(r1, 2) @ r1<- FEDC or CCCC - str r0, [rGLUE, #offGlue_retval] @ retval.l <- new array - str rINST, [rGLUE, #offGlue_retval+4] @ retval.h <- type + str r0, [rSELF, #offThread_retval] @ retval.l <- new array + str rINST, [rSELF, #offThread_retval+4] @ retval.h <- type add r0, r0, #offArrayObject_contents @ r0<- newArray->contents subs r9, r9, #1 @ length--, check for neg FETCH_ADVANCE_INST(3) @ advance to next instr, load rINST @@ -10889,9 +10886,9 @@ dvmAsmSisterStart: .endif 2: - ldr r0, [rGLUE, #offGlue_retval] @ r0<- object - ldr r1, [rGLUE, #offGlue_retval+4] @ r1<- type - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r0, [rSELF, #offThread_retval] @ r0<- object + ldr r1, [rSELF, #offThread_retval+4] @ r1<- type + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base GET_INST_OPCODE(ip) @ ip<- opcode from rINST cmp r1, #'I' @ Is int array? strneb r2, [r2, r0, lsr #GC_CARD_SHIFT] @ Mark card based on object head @@ -10940,8 +10937,8 @@ dvmAsmSisterStart: beq common_exceptionThrown @ alloc failed, handle exception FETCH(r1, 2) @ r1<- FEDC or CCCC - str r0, [rGLUE, #offGlue_retval] @ retval.l <- new array - str rINST, [rGLUE, #offGlue_retval+4] @ retval.h <- type + str r0, [rSELF, #offThread_retval] @ retval.l <- new array + str rINST, [rSELF, #offThread_retval+4] @ retval.h <- type add r0, r0, #offArrayObject_contents @ r0<- newArray->contents subs r9, r9, #1 @ length--, check for neg FETCH_ADVANCE_INST(3) @ advance to next instr, load rINST @@ -10973,9 +10970,9 @@ dvmAsmSisterStart: .endif 2: - ldr r0, [rGLUE, #offGlue_retval] @ r0<- object - ldr r1, [rGLUE, #offGlue_retval+4] @ r1<- type - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r0, [rSELF, #offThread_retval] @ r0<- object + ldr r1, [rSELF, #offThread_retval+4] @ r1<- type + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base GET_INST_OPCODE(ip) @ ip<- opcode from rINST cmp r1, #'I' @ Is int array? strneb r2, [r2, r0, lsr #GC_CARD_SHIFT] @ Mark card based on object head @@ -11075,7 +11072,7 @@ dvmAsmSisterStart: beq .LOP_APUT_OBJECT_throw @ no mov r1, rINST @ r1<- arrayObj FETCH_ADVANCE_INST(2) @ advance rPC, load rINST - ldr r2, [rGLUE, #offGlue_cardTable] @ get biased CT base + ldr r2, [rSELF, #offThread_cardTable] @ get biased CT base add r10, #offArrayObject_contents @ r0<- pointer to slot GET_INST_OPCODE(ip) @ extract opcode from rINST str r9, [r10] @ vBB[vCC]<- vAA @@ -11305,7 +11302,7 @@ dvmAsmSisterStart: and r1, r1, #15 @ r1<- A cmp r9, #0 @ check object for null GET_VREG(r0, r1) @ r0<- fp[A] - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base beq common_errNullObject @ object was null FETCH_ADVANCE_INST(2) @ advance rPC, load rINST GET_INST_OPCODE(ip) @ extract opcode from rINST @@ -11406,7 +11403,7 @@ dvmAsmSisterStart: * r1: BBBB field ref */ .LOP_SGET_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11423,7 +11420,7 @@ dvmAsmSisterStart: * Returns StaticField pointer in r0. */ .LOP_SGET_WIDE_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11438,7 +11435,7 @@ dvmAsmSisterStart: * r1: BBBB field ref */ .LOP_SGET_OBJECT_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11453,7 +11450,7 @@ dvmAsmSisterStart: * r1: BBBB field ref */ .LOP_SGET_BOOLEAN_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11468,7 +11465,7 @@ dvmAsmSisterStart: * r1: BBBB field ref */ .LOP_SGET_BYTE_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11483,7 +11480,7 @@ dvmAsmSisterStart: * r1: BBBB field ref */ .LOP_SGET_CHAR_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11498,7 +11495,7 @@ dvmAsmSisterStart: * r1: BBBB field ref */ .LOP_SGET_SHORT_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11513,7 +11510,7 @@ dvmAsmSisterStart: * r1: BBBB field ref */ .LOP_SPUT_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11531,7 +11528,7 @@ dvmAsmSisterStart: * Returns StaticField pointer in r2. */ .LOP_SPUT_WIDE_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11545,7 +11542,7 @@ dvmAsmSisterStart: mov r2, rINST, lsr #8 @ r2<- AA FETCH_ADVANCE_INST(2) @ advance rPC, load rINST GET_VREG(r1, r2) @ r1<- fp[AA] - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base ldr r9, [r0, #offField_clazz] @ r9<- field->clazz GET_INST_OPCODE(ip) @ extract opcode from rINST @ no-op @ releasing store @@ -11561,7 +11558,7 @@ dvmAsmSisterStart: * r1: BBBB field ref */ .LOP_SPUT_BOOLEAN_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11576,7 +11573,7 @@ dvmAsmSisterStart: * r1: BBBB field ref */ .LOP_SPUT_BYTE_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11591,7 +11588,7 @@ dvmAsmSisterStart: * r1: BBBB field ref */ .LOP_SPUT_CHAR_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11606,7 +11603,7 @@ dvmAsmSisterStart: * r1: BBBB field ref */ .LOP_SPUT_SHORT_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11673,7 +11670,7 @@ dvmAsmSisterStart: * r10 = "this" register */ .LOP_INVOKE_DIRECT_resolve: - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_DIRECT @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) @@ -11741,7 +11738,7 @@ dvmAsmSisterStart: * r10 = "this" register */ .LOP_INVOKE_DIRECT_RANGE_resolve: - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_DIRECT @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) @@ -11938,7 +11935,7 @@ d2l_doconv: * r1: BBBB field ref */ .LOP_SGET_VOLATILE_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11953,7 +11950,7 @@ d2l_doconv: * r1: BBBB field ref */ .LOP_SPUT_VOLATILE_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12041,7 +12038,7 @@ d2l_doconv: * Returns StaticField pointer in r0. */ .LOP_SGET_WIDE_VOLATILE_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12059,7 +12056,7 @@ d2l_doconv: * Returns StaticField pointer in r2. */ .LOP_SPUT_WIDE_VOLATILE_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12146,7 +12143,7 @@ d2l_doconv: and r1, r1, #15 @ r1<- A cmp r9, #0 @ check object for null GET_VREG(r0, r1) @ r0<- fp[A] - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base beq common_errNullObject @ object was null FETCH_ADVANCE_INST(2) @ advance rPC, load rINST GET_INST_OPCODE(ip) @ extract opcode from rINST @@ -12163,7 +12160,7 @@ d2l_doconv: * r1: BBBB field ref */ .LOP_SGET_OBJECT_VOLATILE_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12176,7 +12173,7 @@ d2l_doconv: mov r2, rINST, lsr #8 @ r2<- AA FETCH_ADVANCE_INST(2) @ advance rPC, load rINST GET_VREG(r1, r2) @ r1<- fp[AA] - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base ldr r9, [r0, #offField_clazz] @ r9<- field->clazz GET_INST_OPCODE(ip) @ extract opcode from rINST SMP_DMB @ releasing store @@ -12194,7 +12191,7 @@ d2l_doconv: */ .LOP_CONST_CLASS_JUMBO_resolve: EXPORT_PC() - ldr r0, [rGLUE, #offGlue_method] @ r0<- glue->method + ldr r0, [rSELF, #offThread_method] @ r0<- self->method mov r2, #1 @ r2<- true ldr r0, [r0, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveClass @ r0<- Class reference @@ -12242,7 +12239,7 @@ d2l_doconv: */ .LOP_CHECK_CAST_JUMBO_resolve: EXPORT_PC() @ resolve() could throw - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r1, r2 @ r1<- AAAAAAAA mov r2, #0 @ r2<- false ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz @@ -12307,7 +12304,7 @@ d2l_doconv: .LOP_INSTANCE_OF_JUMBO_resolve: EXPORT_PC() @ resolve() could throw - ldr r0, [rGLUE, #offGlue_method] @ r0<- glue->method + ldr r0, [rSELF, #offThread_method] @ r0<- self->method mov r1, r3 @ r1<- AAAAAAAA mov r2, #1 @ r2<- true ldr r0, [r0, #offMethod_clazz] @ r0<- method->clazz @@ -12351,7 +12348,7 @@ d2l_doconv: * r1 holds AAAAAAAA */ .LOP_NEW_INSTANCE_JUMBO_resolve: - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r2, #0 @ r2<- false ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveClass @ r0<- resolved ClassObject ptr @@ -12369,7 +12366,7 @@ d2l_doconv: * r2 holds class ref AAAAAAAA */ .LOP_NEW_ARRAY_JUMBO_resolve: - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r9, r1 @ r9<- length (save) mov r1, r2 @ r1<- AAAAAAAA mov r2, #0 @ r2<- false @@ -12418,8 +12415,8 @@ d2l_doconv: beq common_exceptionThrown @ alloc failed, handle exception FETCH(r1, 4) @ r1<- CCCC - str r0, [rGLUE, #offGlue_retval] @ retval.l <- new array - str rINST, [rGLUE, #offGlue_retval+4] @ retval.h <- type + str r0, [rSELF, #offThread_retval] @ retval.l <- new array + str rINST, [rSELF, #offThread_retval+4] @ retval.h <- type add r0, r0, #offArrayObject_contents @ r0<- newArray->contents subs r9, r9, #1 @ length--, check for neg FETCH_ADVANCE_INST(5) @ advance to next instr, load rINST @@ -12433,9 +12430,9 @@ d2l_doconv: str r3, [r0], #4 @ *contents++ = vX bpl 1b -2: ldr r0, [rGLUE, #offGlue_retval] @ r0<- object - ldr r1, [rGLUE, #offGlue_retval+4] @ r1<- type - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base +2: ldr r0, [rSELF, #offThread_retval] @ r0<- object + ldr r1, [rSELF, #offThread_retval+4] @ r1<- type + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base GET_INST_OPCODE(ip) @ ip<- opcode from rINST cmp r1, #'I' @ Is int array? strneb r2, [r2, r0, lsr #GC_CARD_SHIFT] @ Mark card based on object head @@ -12742,7 +12739,7 @@ d2l_doconv: FETCH(r1, 3) @ r1<- BBBB cmp r9, #0 @ check object for null GET_VREG(r0, r1) @ r0<- fp[BBBB] - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base beq common_errNullObject @ object was null FETCH_ADVANCE_INST(5) @ advance rPC, load rINST GET_INST_OPCODE(ip) @ extract opcode from rINST @@ -12879,7 +12876,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SGET_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12896,7 +12893,7 @@ d2l_doconv: * Returns StaticField pointer in r0. */ .LOP_SGET_WIDE_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12911,7 +12908,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SGET_OBJECT_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12926,7 +12923,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SGET_BOOLEAN_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12941,7 +12938,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SGET_BYTE_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12956,7 +12953,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SGET_CHAR_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12971,7 +12968,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SGET_SHORT_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12986,7 +12983,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SPUT_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -13004,7 +13001,7 @@ d2l_doconv: * Returns StaticField pointer in r2. */ .LOP_SPUT_WIDE_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -13019,7 +13016,7 @@ d2l_doconv: FETCH(r2, 3) @ r2<- BBBB FETCH_ADVANCE_INST(4) @ advance rPC, load rINST GET_VREG(r1, r2) @ r1<- fp[BBBB] - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base ldr r9, [r0, #offField_clazz] @ r9<- field->clazz GET_INST_OPCODE(ip) @ extract opcode from rINST @ no-op @ releasing store @@ -13035,7 +13032,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SPUT_BOOLEAN_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -13050,7 +13047,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SPUT_BYTE_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -13065,7 +13062,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SPUT_CHAR_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -13080,7 +13077,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SPUT_SHORT_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -13147,7 +13144,7 @@ d2l_doconv: * r10 = "this" register */ .LOP_INVOKE_DIRECT_JUMBO_resolve: - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_DIRECT @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) @@ -13177,71 +13174,64 @@ dvmAsmSisterEnd: #if defined(WITH_SELF_VERIFICATION) .global dvmJitToInterpPunt dvmJitToInterpPunt: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self mov r2,#kSVSPunt @ r2<- interpreter entry point mov r3, #0 - str r3, [r10, #offThread_inJitCodeCache] @ Back to the interp land + str r3, [rSELF, #offThread_inJitCodeCache] @ Back to the interp land b jitSVShadowRunEnd @ doesn't return .global dvmJitToInterpSingleStep dvmJitToInterpSingleStep: - str lr,[rGLUE,#offGlue_jitResumeNPC] - str r1,[rGLUE,#offGlue_jitResumeDPC] + str lr,[rSELF,#offThread_jitResumeNPC] + str r1,[rSELF,#offThread_jitResumeDPC] mov r2,#kSVSSingleStep @ r2<- interpreter entry point b jitSVShadowRunEnd @ doesn't return .global dvmJitToInterpNoChainNoProfile dvmJitToInterpNoChainNoProfile: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self mov r0,rPC @ pass our target PC mov r2,#kSVSNoProfile @ r2<- interpreter entry point mov r3, #0 @ 0 means !inJitCodeCache - str r3, [r10, #offThread_inJitCodeCache] @ back to the interp land + str r3, [rSELF, #offThread_inJitCodeCache] @ back to the interp land b jitSVShadowRunEnd @ doesn't return .global dvmJitToInterpTraceSelectNoChain dvmJitToInterpTraceSelectNoChain: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self mov r0,rPC @ pass our target PC mov r2,#kSVSTraceSelect @ r2<- interpreter entry point mov r3, #0 @ 0 means !inJitCodeCache - str r3, [r10, #offThread_inJitCodeCache] @ Back to the interp land + str r3, [rSELF, #offThread_inJitCodeCache] @ Back to the interp land b jitSVShadowRunEnd @ doesn't return .global dvmJitToInterpTraceSelect dvmJitToInterpTraceSelect: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self ldr r0,[lr, #-1] @ pass our target PC mov r2,#kSVSTraceSelect @ r2<- interpreter entry point mov r3, #0 @ 0 means !inJitCodeCache - str r3, [r10, #offThread_inJitCodeCache] @ Back to the interp land + str r3, [rSELF, #offThread_inJitCodeCache] @ Back to the interp land b jitSVShadowRunEnd @ doesn't return .global dvmJitToInterpBackwardBranch dvmJitToInterpBackwardBranch: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self ldr r0,[lr, #-1] @ pass our target PC mov r2,#kSVSBackwardBranch @ r2<- interpreter entry point mov r3, #0 @ 0 means !inJitCodeCache - str r3, [r10, #offThread_inJitCodeCache] @ Back to the interp land + str r3, [rSELF, #offThread_inJitCodeCache] @ Back to the interp land b jitSVShadowRunEnd @ doesn't return .global dvmJitToInterpNormal dvmJitToInterpNormal: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self ldr r0,[lr, #-1] @ pass our target PC mov r2,#kSVSNormal @ r2<- interpreter entry point mov r3, #0 @ 0 means !inJitCodeCache - str r3, [r10, #offThread_inJitCodeCache] @ Back to the interp land + str r3, [rSELF, #offThread_inJitCodeCache] @ Back to the interp land b jitSVShadowRunEnd @ doesn't return .global dvmJitToInterpNoChain dvmJitToInterpNoChain: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self mov r0,rPC @ pass our target PC mov r2,#kSVSNoChain @ r2<- interpreter entry point mov r3, #0 @ 0 means !inJitCodeCache - str r3, [r10, #offThread_inJitCodeCache] @ Back to the interp land + str r3, [rSELF, #offThread_inJitCodeCache] @ Back to the interp land b jitSVShadowRunEnd @ doesn't return #else /* @@ -13253,7 +13243,6 @@ dvmJitToInterpNoChain: */ .global dvmJitToInterpPunt dvmJitToInterpPunt: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self mov rPC, r0 #if defined(WITH_JIT_TUNING) mov r0,lr @@ -13261,7 +13250,7 @@ dvmJitToInterpPunt: #endif EXPORT_PC() mov r0, #0 - str r0, [r10, #offThread_inJitCodeCache] @ Back to the interp land + str r0, [rSELF, #offThread_inJitCodeCache] @ Back to the interp land adrl rIBASE, dvmAsmInstructionStart FETCH_INST() GET_INST_OPCODE(ip) @@ -13276,17 +13265,17 @@ dvmJitToInterpPunt: */ .global dvmJitToInterpSingleStep dvmJitToInterpSingleStep: - str lr,[rGLUE,#offGlue_jitResumeNPC] - str r1,[rGLUE,#offGlue_jitResumeDPC] + str lr,[rSELF,#offThread_jitResumeNPC] + str r1,[rSELF,#offThread_jitResumeDPC] mov r1,#kInterpEntryInstr @ enum is 4 byte in aapcs-EABI - str r1, [rGLUE, #offGlue_entryPoint] + str r1, [rSELF, #offThread_entryPoint] mov rPC,r0 EXPORT_PC() adrl rIBASE, dvmAsmInstructionStart mov r2,#kJitSingleStep @ Ask for single step and then revert - str r2,[rGLUE,#offGlue_jitState] + str r2,[rSELF,#offThread_jitState] mov r1,#1 @ set changeInterp to bail to debug interp b common_gotoBail @@ -13299,10 +13288,9 @@ dvmJitToInterpTraceSelectNoChain: #if defined(WITH_JIT_TUNING) bl dvmBumpNoChain #endif - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self mov r0,rPC bl dvmJitGetTraceAddr @ Is there a translation? - str r0, [r10, #offThread_inJitCodeCache] @ set the inJitCodeCache flag + str r0, [rSELF, #offThread_inJitCodeCache] @ set the inJitCodeCache flag mov r1, rPC @ arg1 of translation may need this mov lr, #0 @ in case target is HANDLER_INTERPRET cmp r0,#0 @ !0 means translation exists @@ -13317,12 +13305,11 @@ dvmJitToInterpTraceSelectNoChain: .global dvmJitToInterpTraceSelect dvmJitToInterpTraceSelect: ldr rPC,[lr, #-1] @ get our target PC - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self add rINST,lr,#-5 @ save start of chain branch add rINST, #-4 @ .. which is 9 bytes back mov r0,rPC bl dvmJitGetTraceAddr @ Is there a translation? - str r0, [r10, #offThread_inJitCodeCache] @ set the inJitCodeCache flag + str r0, [rSELF, #offThread_inJitCodeCache] @ set the inJitCodeCache flag cmp r0,#0 beq 2f mov r1,rINST @@ -13361,7 +13348,6 @@ dvmJitToInterpTraceSelect: .global dvmJitToInterpNormal dvmJitToInterpNormal: ldr rPC,[lr, #-1] @ get our target PC - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self add rINST,lr,#-5 @ save start of chain branch add rINST,#-4 @ .. which is 9 bytes back #if defined(WITH_JIT_TUNING) @@ -13369,7 +13355,7 @@ dvmJitToInterpNormal: #endif mov r0,rPC bl dvmJitGetTraceAddr @ Is there a translation? - str r0, [r10, #offThread_inJitCodeCache] @ set the inJitCodeCache flag + str r0, [rSELF, #offThread_inJitCodeCache] @ set the inJitCodeCache flag cmp r0,#0 beq toInterpreter @ go if not, otherwise do chain mov r1,rINST @@ -13389,10 +13375,9 @@ dvmJitToInterpNoChainNoProfile: #if defined(WITH_JIT_TUNING) bl dvmBumpNoChain #endif - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self mov r0,rPC bl dvmJitGetTraceAddr @ Is there a translation? - str r0, [r10, #offThread_inJitCodeCache] @ set the inJitCodeCache flag + str r0, [rSELF, #offThread_inJitCodeCache] @ set the inJitCodeCache flag mov r1, rPC @ arg1 of translation may need this mov lr, #0 @ in case target is HANDLER_INTERPRET cmp r0,#0 @@ -13412,10 +13397,9 @@ dvmJitToInterpNoChain: #if defined(WITH_JIT_TUNING) bl dvmBumpNoChain #endif - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self mov r0,rPC bl dvmJitGetTraceAddr @ Is there a translation? - str r0, [r10, #offThread_inJitCodeCache] @ set the inJitCodeCache flag + str r0, [rSELF, #offThread_inJitCodeCache] @ set the inJitCodeCache flag mov r1, rPC @ arg1 of translation may need this mov lr, #0 @ in case target is HANDLER_INTERPRET cmp r0,#0 @@ -13424,7 +13408,7 @@ dvmJitToInterpNoChain: /* * No translation, restore interpreter regs and start interpreting. - * rGLUE & rFP were preserved in the translated code, and rPC has + * rSELF & rFP were preserved in the translated code, and rPC has * already been restored by the time we get here. We'll need to set * up rIBASE & rINST, and load the address of the JitTable into r0. */ @@ -13462,13 +13446,13 @@ common_updateProfile: * is already a native translation in place (and, if so, * jump to it now). */ + GET_JIT_THRESHOLD(r1) - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self strb r1,[r0,r3,lsr #(32 - JIT_PROF_SIZE_LOG_2)] @ reset counter EXPORT_PC() mov r0,rPC bl dvmJitGetTraceAddr @ r0<- dvmJitGetTraceAddr(rPC) - str r0, [r10, #offThread_inJitCodeCache] @ set the inJitCodeCache flag + str r0, [rSELF, #offThread_inJitCodeCache] @ set the inJitCodeCache flag mov r1, rPC @ arg1 of translation may need this mov lr, #0 @ in case target is HANDLER_INTERPRET cmp r0,#0 @@ -13489,9 +13473,8 @@ common_updateProfile: cmp r0, r10 @ special case? bne jitSVShadowRunStart @ set up self verification shadow space @ Need to clear the inJitCodeCache flag - ldr r10, [rGLUE, #offGlue_self] @ r10 <- glue->self mov r3, #0 @ 0 means not in the JIT code cache - str r3, [r10, #offThread_inJitCodeCache] @ back to the interp land + str r3, [rSELF, #offThread_inJitCodeCache] @ back to the interp land GET_INST_OPCODE(ip) GOTO_OPCODE(ip) /* no return */ @@ -13502,9 +13485,10 @@ common_updateProfile: * r2 is jit state, e.g. kJitTSelectRequest or kJitTSelectRequestHot */ common_selectTrace: - str r2,[rGLUE,#offGlue_jitState] + + str r2,[rSELF,#offThread_jitState] mov r2,#kInterpEntryInstr @ normal entry reason - str r2,[rGLUE,#offGlue_entryPoint] + str r2,[rSELF,#offThread_entryPoint] mov r1,#1 @ set changeInterp b common_gotoBail @@ -13513,36 +13497,35 @@ common_selectTrace: * Save PC and registers to shadow memory for self verification mode * before jumping to native translation. * On entry: - * rPC, rFP, rGLUE: the values that they should contain + * rPC, rFP, rSELF: the values that they should contain * r10: the address of the target translation. */ jitSVShadowRunStart: mov r0,rPC @ r0<- program counter mov r1,rFP @ r1<- frame pointer - mov r2,rGLUE @ r2<- InterpState pointer + mov r2,rSELF @ r2<- self (Thread) pointer mov r3,r10 @ r3<- target translation bl dvmSelfVerificationSaveState @ save registers to shadow space 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 + * Restore PC, registers, and interpreter state to original values * before jumping back to the interpreter. */ jitSVShadowRunEnd: mov r1,rFP @ pass ending fp + mov r3,rSELF @ pass self ptr for convenience bl dvmSelfVerificationRestoreState @ restore pc and fp values - ldr rPC,[r0,#offShadowSpace_startPC] @ restore PC - ldr rFP,[r0,#offShadowSpace_fp] @ restore FP - ldr rGLUE,[r0,#offShadowSpace_glue] @ restore InterpState + ldr rPC,[rSELF,#offThread_pc] @ restore PC + ldr rFP,[rSELF,#offThread_fp] @ restore FP 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 - str r2,[rGLUE,#offGlue_jitState] + str r2,[rSELF,#offThread_jitState] mov r2,#kInterpEntryInstr @ normal entry reason - str r2,[rGLUE,#offGlue_entryPoint] + str r2,[rSELF,#offThread_entryPoint] mov r1,#1 @ set changeInterp b common_gotoBail @@ -13603,12 +13586,11 @@ common_backwardBranch: * r9 is trampoline PC adjustment *in bytes* */ common_periodicChecks: - ldr r1, [rGLUE, #offGlue_pInterpBreak] @ r3<- &interpBreak - /* speculatively load address of thread-specific suspend count */ - ldr r3, [rGLUE, #offGlue_pSelfSuspendCount] @ r3<- &suspendCount +/* TUNING - make this a direct load when interpBreak moved to Thread */ + ldr r1, [rSELF, #offThread_pInterpBreak] @ r3<- &interpBreak + /* speculatively thread-specific suspend count */ + ldr ip, [rSELF, #offThread_suspendCount] ldr r1, [r1] @ r1<- interpBreak - /* speculatively load thread-specific suspend count */ - ldr ip, [r3] @ ip<- suspendCount (int) cmp r1, #0 @ anything unusual? bxeq lr @ return if not /* @@ -13625,13 +13607,13 @@ common_periodicChecks: * Refresh the Jit's cached copy of profile table pointer. This pointer * doubles as the Jit's on/off switch. */ - ldr r3, [rGLUE, #offGlue_ppJitProfTable] @ r3<-&gDvmJit.pJitProfTable - ldr r0, [rGLUE, #offGlue_self] @ r0<- glue->self + ldr r3, [rSELF, #offThread_ppJitProfTable] @ r3<-&gDvmJit.pJitProfTable + mov r0, rSELF @ r0<- self ldr r3, [r3] @ r3 <- pJitProfTable EXPORT_PC() @ need for precise GC - str r3, [rGLUE, #offGlue_pJitProfTable] @ refresh Jit's on/off switch + str r3, [rSELF, #offThread_pJitProfTable] @ refresh Jit's on/off switch #else - ldr r0, [rGLUE, #offGlue_self] @ r0<- glue->self + mov r0, rSELF @ r0<- self EXPORT_PC() @ need for precise GC #endif bl dvmCheckSuspendPending @ do full check, suspend if necessary @@ -13641,7 +13623,8 @@ common_periodicChecks: * Reload the interpBreak flags - they may have changed while we * were suspended. */ - ldr r1, [rGLUE, #offGlue_pInterpBreak] @ r1<- &interpBreak +/* TUNING - direct load when InterpBreak moved to Thread */ + ldr r1, [rSELF, #offThread_pInterpBreak] @ r1<- &interpBreak ldr r1, [r1] @ r1<- interpBreak 3: /* @@ -13655,8 +13638,8 @@ common_periodicChecks: ands r1, #(kSubModeDebuggerActive | kSubModeEmulatorTrace | kSubModeInstCounting) bxeq lr @ nothing to do, return - @ debugger/profiler enabled, bail out; glue->entryPoint was set above - str r0, [rGLUE, #offGlue_entryPoint] @ store r0, need for debug/prof + @ debugger/profiler enabled, bail out; self->entryPoint was set above + str r0, [rSELF, #offThread_entryPoint] @ store r0, need for debug/prof add rPC, rPC, r9 @ update rPC mov r1, #1 @ "want switch" = true b common_gotoBail @ side exit @@ -13665,19 +13648,19 @@ common_periodicChecks: /* * The equivalent of "goto bail", this calls through the "bail handler". * - * State registers will be saved to the "glue" area before bailing. + * State registers will be saved to the "thread" area before bailing. * * On entry: * r1 is "bool changeInterp", indicating if we want to switch to the * other interpreter or just bail all the way out */ common_gotoBail: - SAVE_PC_FP_TO_GLUE() @ export state to "glue" - mov r0, rGLUE @ r0<- glue ptr - b dvmMterpStdBail @ call(glue, changeInterp) + SAVE_PC_FP_TO_SELF() @ export state to "thread" + mov r0, rSELF @ r0<- self ptr + b dvmMterpStdBail @ call(self, changeInterp) @add r1, r1, #1 @ using (boolean+1) - @add r0, rGLUE, #offGlue_jmpBuf @ r0<- &glue->jmpBuf + @add r0, rSELF, #offThread_jmpBuf @ r0<- &self->jmpBuf @bl _longjmp @ does not return @bl common_abort @@ -13779,10 +13762,10 @@ common_invokeMethodNoRange: sub r1, r1, r9, lsl #2 @ r1<- newFp (old savearea - regsSize) SAVEAREA_FROM_FP(r10, r1) @ r10<- newSaveArea @ bl common_dumpRegs - ldr r9, [rGLUE, #offGlue_interpStackEnd] @ r9<- interpStackEnd + ldr r9, [rSELF, #offThread_interpStackEnd] @ r9<- interpStackEnd sub r3, r10, r3, lsl #2 @ r3<- bottom (newsave - outsSize) cmp r3, r9 @ bottom < interpStackEnd? - ldr lr, [rGLUE, #offGlue_pInterpBreak] + ldr lr, [rSELF, #offThread_pInterpBreak] ldr r3, [r0, #offMethod_accessFlags] @ r3<- methodToCall->accessFlags blo .LstackOverflow @ yes, this frame will overflow stack @@ -13802,7 +13785,7 @@ common_invokeMethodNoRange: beq 1f @ skip if not stmfd sp!, {r0-r3} @ preserve r0-r3 mov r1, r6 - @ r0=methodToCall, r1=rGlue + @ r0=methodToCall, r1=rSELF bl dvmFastMethodTraceEnter ldmfd sp!, {r0-r3} @ restore r0-r3 1: @@ -13828,18 +13811,17 @@ common_invokeMethodNoRange: ldrh r9, [r2] @ r9 <- load INST from new PC ldr r3, [rINST, #offClassObject_pDvmDex] @ r3<- method->clazz->pDvmDex mov rPC, r2 @ publish new rPC - ldr r2, [rGLUE, #offGlue_self] @ r2<- glue->self - @ Update "glue" values for the new method - @ r0=methodToCall, r1=newFp, r2=self, r3=newMethodClass, r9=newINST - str r0, [rGLUE, #offGlue_method] @ glue->method = methodToCall - str r3, [rGLUE, #offGlue_methodClassDex] @ glue->methodClassDex = ... + @ Update state values for the new method + @ r0=methodToCall, r1=newFp, r3=newMethodClass, r9=newINST + str r0, [rSELF, #offThread_method] @ self->method = methodToCall + str r3, [rSELF, #offThread_methodClassDex] @ self->methodClassDex = ... #if defined(WITH_JIT) GET_JIT_PROF_TABLE(r0) mov rFP, r1 @ fp = newFp GET_PREFETCHED_OPCODE(ip, r9) @ extract prefetched opcode from r9 mov rINST, r9 @ publish new rINST - str r1, [r2, #offThread_curFrame] @ self->curFrame = newFp + str r1, [rSELF, #offThread_curFrame] @ self->curFrame = newFp cmp r0,#0 bne common_updateProfile GOTO_OPCODE(ip) @ jump to next instruction @@ -13847,24 +13829,23 @@ common_invokeMethodNoRange: mov rFP, r1 @ fp = newFp GET_PREFETCHED_OPCODE(ip, r9) @ extract prefetched opcode from r9 mov rINST, r9 @ publish new rINST - str r1, [r2, #offThread_curFrame] @ self->curFrame = newFp + str r1, [rSELF, #offThread_curFrame] @ self->curFrame = newFp GOTO_OPCODE(ip) @ jump to next instruction #endif .LinvokeNative: @ Prep for the native call @ r0=methodToCall, r1=newFp, r10=newSaveArea - ldr r3, [rGLUE, #offGlue_self] @ r3<- glue->self - ldr lr, [rGLUE, #offGlue_pInterpBreak] - ldr r9, [r3, #offThread_jniLocal_topCookie] @ r9<- thread->localRef->... - str r1, [r3, #offThread_curFrame] @ self->curFrame = newFp + ldr lr, [rSELF, #offThread_pInterpBreak] + ldr r9, [rSELF, #offThread_jniLocal_topCookie]@r9<-thread->localRef->... + str r1, [rSELF, #offThread_curFrame] @ self->curFrame = newFp str r9, [r10, #offStackSaveArea_localRefCookie] @newFp->localRefCookie=top ldr lr, [lr] @ lr<- active submodes - mov r9, r3 @ r9<- glue->self (preserve) mov r2, r0 @ r2<- methodToCall mov r0, r1 @ r0<- newFp (points to args) - add r1, rGLUE, #offGlue_retval @ r1<- &retval + add r1, rSELF, #offThread_retval @ r1<- &retval + mov r3, rSELF @ arg3<- self #ifdef ASSIST_DEBUGGER /* insert fake function header to help gdb find the stack frame */ @@ -13879,13 +13860,13 @@ dalvik_mterp: ands lr, #kSubModeMethodTrace @ method tracing? beq 110f @ hop if not - @ r2=JNIMethod, r6=rGLUE + @ r2=JNIMethod, r6=rSELF stmfd sp!, {r2,r6} mov lr, pc @ set return addr ldr pc, [r2, #offMethod_nativeFunc] @ pc<- methodToCall->nativeFunc - @ r0=JNIMethod, r1=rGLUE + @ r0=JNIMethod, r1=rSELF ldmfd sp!, {r0-r1} bl dvmFastNativeMethodTraceExit b 220f @@ -13894,21 +13875,21 @@ dalvik_mterp: ldr pc, [r2, #offMethod_nativeFunc] @ pc<- methodToCall->nativeFunc 220: #if defined(WITH_JIT) - ldr r3, [rGLUE, #offGlue_ppJitProfTable] @ Refresh Jit's on/off status + ldr r3, [rSELF, #offThread_ppJitProfTable] @ Refresh Jit's on/off status #endif - @ native return; r9=self, r10=newSaveArea + @ native return; r10=newSaveArea @ equivalent to dvmPopJniLocals ldr r0, [r10, #offStackSaveArea_localRefCookie] @ r0<- saved top - ldr r1, [r9, #offThread_exception] @ check for exception + ldr r1, [rSELF, #offThread_exception] @ check for exception #if defined(WITH_JIT) ldr r3, [r3] @ r3 <- gDvmJit.pProfTable #endif - str rFP, [r9, #offThread_curFrame] @ self->curFrame = fp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = fp cmp r1, #0 @ null? - str r0, [r9, #offThread_jniLocal_topCookie] @ new top <- old top + str r0, [rSELF, #offThread_jniLocal_topCookie] @ new top <- old top #if defined(WITH_JIT) - str r3, [rGLUE, #offGlue_pJitProfTable] @ refresh cached on/off switch + str r3, [rSELF, #offThread_pJitProfTable] @ refresh cached on/off switch #endif bne common_exceptionThrown @ no, handle exception @@ -13918,7 +13899,7 @@ dalvik_mterp: .LstackOverflow: @ r0=methodToCall mov r1, r0 @ r1<- methodToCall - ldr r0, [rGLUE, #offGlue_self] @ r0<- self + mov r0, rSELF @ r0<- self bl dvmHandleStackOverflow b common_exceptionThrown #ifdef ASSIST_DEBUGGER @@ -13943,8 +13924,8 @@ dalvik_mterp: sub sp, sp, #8 @ space for args + pad FETCH(ip, 2) @ ip<- FEDC or CCCC mov r2, r0 @ A2<- methodToCall - mov r0, rGLUE @ A0<- glue - SAVE_PC_FP_TO_GLUE() @ export state to "glue" + mov r0, rSELF @ A0<- self + SAVE_PC_FP_TO_SELF() @ export state to "self" mov r1, r9 @ A1<- methodCallRange mov r3, rINST, lsr #8 @ A3<- AA str ip, [sp, #0] @ A4<- ip @@ -13966,7 +13947,7 @@ common_returnFromMethod: mov r9, #0 bl common_periodicChecks - ldr lr, [rGLUE, #offGlue_pInterpBreak] + ldr lr, [rSELF, #offThread_pInterpBreak] SAVEAREA_FROM_FP(r0, rFP) ldr lr, [lr] @ lr<- active submodes ldr r9, [r0, #offStackSaveArea_savedPc] @ r9 = saveArea->savedPc @@ -13974,12 +13955,11 @@ common_returnFromMethod: beq 333f stmfd sp!, {r0-r3} @ preserve r0-r3 mov r0, r6 - @ r0=rGlue + @ r0=rSELF bl dvmFastJavaMethodTraceExit ldmfd sp!, {r0-r3} @ restore r0-r3 333: ldr rFP, [r0, #offStackSaveArea_prevFrame] @ fp = saveArea->prevFrame - ldr r3, [rGLUE, #offGlue_self] @ r3<- glue->self ldr r2, [rFP, #(offStackSaveArea_method - sizeofStackSaveArea)] @ r2<- method we're returning to cmp r2, #0 @ is this a break frame? @@ -13995,14 +13975,14 @@ common_returnFromMethod: beq common_gotoBail @ break frame, bail out completely PREFETCH_ADVANCE_INST(rINST, r9, 3) @ advance r9, update new rINST - str r2, [rGLUE, #offGlue_method]@ glue->method = newSave->method + str r2, [rSELF, #offThread_method]@ self->method = newSave->method ldr r1, [r10, #offClassObject_pDvmDex] @ r1<- method->clazz->pDvmDex - str rFP, [r3, #offThread_curFrame] @ self->curFrame = fp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = fp #if defined(WITH_JIT) ldr r10, [r0, #offStackSaveArea_returnAddr] @ r10 = saveArea->returnAddr mov rPC, r9 @ publish new rPC - str r1, [rGLUE, #offGlue_methodClassDex] - str r10, [r3, #offThread_inJitCodeCache] @ may return to JIT'ed land + str r1, [rSELF, #offThread_methodClassDex] + str r10, [rSELF, #offThread_inJitCodeCache] @ may return to JIT'ed land cmp r10, #0 @ caller is compiled code blxne r10 GET_INST_OPCODE(ip) @ extract opcode from rINST @@ -14010,7 +13990,7 @@ common_returnFromMethod: #else GET_INST_OPCODE(ip) @ extract opcode from rINST mov rPC, r9 @ publish new rPC - str r1, [rGLUE, #offGlue_methodClassDex] + str r1, [rSELF, #offThread_methodClassDex] GOTO_OPCODE(ip) @ jump to next instruction #endif @@ -14019,8 +13999,8 @@ common_returnFromMethod: */ .if 0 .LreturnOld: - SAVE_PC_FP_TO_GLUE() @ export state - mov r0, rGLUE @ arg to function + SAVE_PC_FP_TO_SELF() @ export state + mov r0, rSELF @ arg to function bl dvmMterp_returnFromMethod b common_resumeAfterGlueCall .endif @@ -14043,13 +14023,12 @@ common_exceptionThrown: mov r9, #0 bl common_periodicChecks - ldr r10, [rGLUE, #offGlue_self] @ r10<- glue->self - ldr r9, [r10, #offThread_exception] @ r9<- self->exception - mov r1, r10 @ r1<- self + ldr r9, [rSELF, #offThread_exception] @ r9<- self->exception + mov r1, rSELF @ r1<- self mov r0, r9 @ r0<- exception bl dvmAddTrackedAlloc @ don't let the exception be GCed mov r3, #0 @ r3<- NULL - str r3, [r10, #offThread_exception] @ self->exception = NULL + str r3, [rSELF, #offThread_exception] @ self->exception = NULL /* set up args and a local for "&fp" */ /* (str sp, [sp, #-4]! would be perfect here, but is discouraged) */ @@ -14057,8 +14036,8 @@ common_exceptionThrown: mov ip, sp @ ip<- &fp mov r3, #0 @ r3<- false str ip, [sp, #-4]! @ *--sp = &fp - ldr r1, [rGLUE, #offGlue_method] @ r1<- glue->method - mov r0, r10 @ r0<- self + ldr r1, [rSELF, #offThread_method] @ r1<- self->method + mov r0, rSELF @ r0<- self ldr r1, [r1, #offMethod_insns] @ r1<- method->insns mov r2, r9 @ r2<- exception sub r1, rPC, r1 @ r1<- pc - method->insns @@ -14068,11 +14047,11 @@ common_exceptionThrown: bl dvmFindCatchBlock @ call(self, relPc, exc, scan?, &fp) /* fix earlier stack overflow if necessary; may trash rFP */ - ldrb r1, [r10, #offThread_stackOverflowed] + ldrb r1, [rSELF, #offThread_stackOverflowed] cmp r1, #0 @ did we overflow earlier? beq 1f @ no, skip ahead mov rFP, r0 @ save relPc result in rFP - mov r0, r10 @ r0<- self + mov r0, rSELF @ r0<- self mov r1, r9 @ r1<- exception bl dvmCleanupStackOverflow @ call(self) mov r0, rFP @ restore result @@ -14087,30 +14066,30 @@ common_exceptionThrown: /* adjust locals to match self->curFrame and updated PC */ SAVEAREA_FROM_FP(r1, rFP) @ r1<- new save area ldr r1, [r1, #offStackSaveArea_method] @ r1<- new method - str r1, [rGLUE, #offGlue_method] @ glue->method = new method + str r1, [rSELF, #offThread_method] @ self->method = new method ldr r2, [r1, #offMethod_clazz] @ r2<- method->clazz ldr r3, [r1, #offMethod_insns] @ r3<- method->insns ldr r2, [r2, #offClassObject_pDvmDex] @ r2<- method->clazz->pDvmDex add rPC, r3, r0, asl #1 @ rPC<- method->insns + catchRelPc - str r2, [rGLUE, #offGlue_methodClassDex] @ glue->pDvmDex = meth... + str r2, [rSELF, #offThread_methodClassDex] @ self->pDvmDex = meth... /* release the tracked alloc on the exception */ mov r0, r9 @ r0<- exception - mov r1, r10 @ r1<- self + mov r1, rSELF @ r1<- self bl dvmReleaseTrackedAlloc @ release the exception /* restore the exception if the handler wants it */ FETCH_INST() @ load rINST from rPC GET_INST_OPCODE(ip) @ extract opcode from rINST cmp ip, #OP_MOVE_EXCEPTION @ is it "move-exception"? - streq r9, [r10, #offThread_exception] @ yes, restore the exception + streq r9, [rSELF, #offThread_exception] @ yes, restore the exception GOTO_OPCODE(ip) @ jump to next instruction -.LnotCaughtLocally: @ r9=exception, r10=self +.LnotCaughtLocally: @ r9=exception /* fix stack overflow if necessary */ - ldrb r1, [r10, #offThread_stackOverflowed] + ldrb r1, [rSELF, #offThread_stackOverflowed] cmp r1, #0 @ did we overflow earlier? - movne r0, r10 @ if yes: r0<- self + movne r0, rSELF @ if yes: r0<- self movne r1, r9 @ if yes: r1<- exception blne dvmCleanupStackOverflow @ if yes: call(self) @@ -14119,14 +14098,14 @@ common_exceptionThrown: /* call __android_log_print(prio, tag, format, ...) */ /* "Exception %s from %s:%d not caught locally" */ @ dvmLineNumFromPC(method, pc - method->insns) - ldr r0, [rGLUE, #offGlue_method] + ldr r0, [rSELF, #offThread_method] ldr r1, [r0, #offMethod_insns] sub r1, rPC, r1 asr r1, r1, #1 bl dvmLineNumFromPC str r0, [sp, #-4]! @ dvmGetMethodSourceFile(method) - ldr r0, [rGLUE, #offGlue_method] + ldr r0, [rSELF, #offThread_method] bl dvmGetMethodSourceFile str r0, [sp, #-4]! @ exception->clazz->descriptor @@ -14138,9 +14117,9 @@ common_exceptionThrown: mov r0, #3 @ LOG_DEBUG bl __android_log_print #endif - str r9, [r10, #offThread_exception] @ restore exception + str r9, [rSELF, #offThread_exception] @ restore exception mov r0, r9 @ r0<- exception - mov r1, r10 @ r1<- self + mov r1, rSELF @ r1<- self bl dvmReleaseTrackedAlloc @ release the exception mov r1, #0 @ "want switch" = false b common_gotoBail @ bail out @@ -14151,8 +14130,8 @@ common_exceptionThrown: */ .if 0 .LexceptionOld: - SAVE_PC_FP_TO_GLUE() @ export state - mov r0, rGLUE @ arg to function + SAVE_PC_FP_TO_SELF() @ export state + mov r0, rSELF @ arg to function bl dvmMterp_exceptionThrown b common_resumeAfterGlueCall .endif @@ -14163,7 +14142,7 @@ common_exceptionThrown: * values and start executing at the next instruction. */ common_resumeAfterGlueCall: - LOAD_PC_FP_FROM_GLUE() @ pull rPC and rFP out of glue + LOAD_PC_FP_FROM_SELF() @ pull rPC and rFP out of thread FETCH_INST() @ load rINST from rPC GET_INST_OPCODE(ip) @ extract opcode from rINST GOTO_OPCODE(ip) @ jump to next instruction diff --git a/vm/mterp/out/InterpAsm-armv5te.S b/vm/mterp/out/InterpAsm-armv5te.S index 62cdd2e79..b318c8714 100644 --- a/vm/mterp/out/InterpAsm-armv5te.S +++ b/vm/mterp/out/InterpAsm-armv5te.S @@ -63,7 +63,7 @@ The following registers have fixed assignments: reg nick purpose r4 rPC interpreted program counter, used for fetching instructions r5 rFP interpreted frame pointer, used for accessing locals and args - r6 rGLUE MterpGlue pointer + r6 rSELF self (Thread) pointer r7 rINST first 16-bit code unit of current instruction r8 rIBASE interpreted instruction base pointer, used for computed goto @@ -75,17 +75,17 @@ unspecified registers or condition codes. /* single-purpose registers, given names for clarity */ #define rPC r4 #define rFP r5 -#define rGLUE r6 +#define rSELF r6 #define rINST r7 #define rIBASE r8 -/* save/restore the PC and/or FP from the glue struct */ -#define LOAD_PC_FROM_GLUE() ldr rPC, [rGLUE, #offGlue_pc] -#define SAVE_PC_TO_GLUE() str rPC, [rGLUE, #offGlue_pc] -#define LOAD_FP_FROM_GLUE() ldr rFP, [rGLUE, #offGlue_fp] -#define SAVE_FP_TO_GLUE() str rFP, [rGLUE, #offGlue_fp] -#define LOAD_PC_FP_FROM_GLUE() ldmia rGLUE, {rPC, rFP} -#define SAVE_PC_FP_TO_GLUE() stmia rGLUE, {rPC, rFP} +/* save/restore the PC and/or FP from the thread struct */ +#define LOAD_PC_FROM_SELF() ldr rPC, [rSELF, #offThread_pc] +#define SAVE_PC_TO_SELF() str rPC, [rSELF, #offThread_pc] +#define LOAD_FP_FROM_SELF() ldr rFP, [rSELF, #offThread_fp] +#define SAVE_FP_TO_SELF() str rFP, [rSELF, #offThread_fp] +#define LOAD_PC_FP_FROM_SELF() ldmia rSELF, {rPC, rFP} +#define SAVE_PC_FP_TO_SELF() stmia rSELF, {rPC, rFP} /* * "export" the PC to the stack frame, f/b/o future exception objects. Must @@ -186,8 +186,8 @@ unspecified registers or condition codes. #define SET_VREG(_reg, _vreg) str _reg, [rFP, _vreg, lsl #2] #if defined(WITH_JIT) -#define GET_JIT_PROF_TABLE(_reg) ldr _reg,[rGLUE,#offGlue_pJitProfTable] -#define GET_JIT_THRESHOLD(_reg) ldr _reg,[rGLUE,#offGlue_jitThreshold] +#define GET_JIT_PROF_TABLE(_reg) ldr _reg,[rSELF,#offThread_pJitProfTable] +#define GET_JIT_THRESHOLD(_reg) ldr _reg,[rSELF,#offThread_jitThreshold] #endif /* @@ -266,7 +266,7 @@ unspecified registers or condition codes. /* * On entry: - * r0 MterpGlue* glue + * r0 Thread* self * * This function returns a boolean "changeInterp" value. The return comes * via a call to dvmMterpStdBail(). @@ -284,29 +284,28 @@ dvmMterpStdRun: MTERP_ENTRY2 /* save stack pointer, add magic word for debuggerd */ - str sp, [r0, #offGlue_bailPtr] @ save SP for eventual return + str sp, [r0, #offThread_bailPtr] @ save SP for eventual return /* set up "named" registers, figure out entry point */ - mov rGLUE, r0 @ set rGLUE - ldr r1, [r0, #offGlue_entryPoint] @ enum is 4 bytes in aapcs-EABI - LOAD_PC_FP_FROM_GLUE() @ load rPC and rFP from "glue" + mov rSELF, r0 @ set rSELF + ldr r1, [r0, #offThread_entryPoint] @ enum is 4 bytes in aapcs-EABI + LOAD_PC_FP_FROM_SELF() @ load rPC and rFP from "thread" adr rIBASE, dvmAsmInstructionStart @ set rIBASE cmp r1, #kInterpEntryInstr @ usual case? bne .Lnot_instr @ no, handle it #if defined(WITH_JIT) .LentryInstr: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self /* Entry is always a possible trace start */ GET_JIT_PROF_TABLE(r0) FETCH_INST() mov r1, #0 @ prepare the value for the new state - str r1, [r10, #offThread_inJitCodeCache] @ back to the interp land + str r1, [rSELF, #offThread_inJitCodeCache] @ back to the interp land cmp r0,#0 @ is profiling disabled? #if !defined(WITH_SELF_VERIFICATION) bne common_updateProfile @ profiling is enabled #else - ldr r2, [r10, #offThread_shadowSpace] @ to find out the jit exit state + ldr r2, [rSELF, #offThread_shadowSpace] @ to find out the jit exit state beq 1f @ profiling is disabled ldr r3, [r2, #offShadowSpace_jitExitState] @ jit exit state cmp r3, #kSVSTraceSelect @ hot trace following? @@ -336,20 +335,20 @@ dvmMterpStdRun: #if defined(WITH_JIT) .Lnot_throw: - ldr r10,[rGLUE, #offGlue_jitResumeNPC] - ldr r2,[rGLUE, #offGlue_jitResumeDPC] + ldr r10,[rSELF, #offThread_jitResumeNPC] + ldr r2,[rSELF, #offThread_jitResumeDPC] cmp r1, #kInterpEntryResume @ resuming after Jit single-step? bne .Lbad_arg cmp rPC,r2 bne .LentryInstr @ must have branched, don't resume #if defined(WITH_SELF_VERIFICATION) - @ glue->entryPoint will be set in dvmSelfVerificationSaveState + @ self->entryPoint will be set in dvmSelfVerificationSaveState b jitSVShadowRunStart @ re-enter the translation after the @ single-stepped instruction @noreturn #endif mov r1, #kInterpEntryInstr - str r1, [rGLUE, #offGlue_entryPoint] + str r1, [rSELF, #offThread_entryPoint] bx r10 @ re-enter the translation #endif @@ -375,11 +374,11 @@ dvmMterpStdRun: * LR to PC. * * On entry: - * r0 MterpGlue* glue + * r0 Thread* self * r1 bool changeInterp */ dvmMterpStdBail: - ldr sp, [r0, #offGlue_bailPtr] @ sp<- saved SP + ldr sp, [r0, #offThread_bailPtr] @ sp<- saved SP mov r0, r1 @ return the changeInterp value add sp, sp, #4 @ un-align 64 ldmfd sp!, {r4-r10,fp,pc} @ restore 9 regs and return @@ -564,7 +563,7 @@ dalvik_inst: /* op vAA */ mov r2, rINST, lsr #8 @ r2<- AA FETCH_ADVANCE_INST(1) @ advance rPC, load rINST - ldr r0, [rGLUE, #offGlue_retval] @ r0<- glue->retval.i + ldr r0, [rSELF, #offThread_retval] @ r0<- self->retval.i GET_INST_OPCODE(ip) @ extract opcode from rINST SET_VREG(r0, r2) @ fp[AA]<- r0 GOTO_OPCODE(ip) @ jump to next instruction @@ -575,7 +574,7 @@ dalvik_inst: /* File: armv5te/OP_MOVE_RESULT_WIDE.S */ /* move-result-wide vAA */ mov r2, rINST, lsr #8 @ r2<- AA - add r3, rGLUE, #offGlue_retval @ r3<- &glue->retval + add r3, rSELF, #offThread_retval @ r3<- &self->retval add r2, rFP, r2, lsl #2 @ r2<- &fp[AA] ldmia r3, {r0-r1} @ r0/r1<- retval.j FETCH_ADVANCE_INST(1) @ advance rPC, load rINST @@ -592,7 +591,7 @@ dalvik_inst: /* op vAA */ mov r2, rINST, lsr #8 @ r2<- AA FETCH_ADVANCE_INST(1) @ advance rPC, load rINST - ldr r0, [rGLUE, #offGlue_retval] @ r0<- glue->retval.i + ldr r0, [rSELF, #offThread_retval] @ r0<- self->retval.i GET_INST_OPCODE(ip) @ extract opcode from rINST SET_VREG(r0, r2) @ fp[AA]<- r0 GOTO_OPCODE(ip) @ jump to next instruction @@ -603,14 +602,13 @@ dalvik_inst: .L_OP_MOVE_EXCEPTION: /* 0x0d */ /* File: armv5te/OP_MOVE_EXCEPTION.S */ /* move-exception vAA */ - ldr r0, [rGLUE, #offGlue_self] @ r0<- glue->self mov r2, rINST, lsr #8 @ r2<- AA - ldr r3, [r0, #offThread_exception] @ r3<- dvmGetException bypass + ldr r3, [rSELF, #offThread_exception] @ r3<- dvmGetException bypass mov r1, #0 @ r1<- 0 FETCH_ADVANCE_INST(1) @ advance rPC, load rINST SET_VREG(r3, r2) @ fp[AA]<- exception obj GET_INST_OPCODE(ip) @ extract opcode from rINST - str r1, [r0, #offThread_exception] @ dvmClearException bypass + str r1, [rSELF, #offThread_exception] @ dvmClearException bypass GOTO_OPCODE(ip) @ jump to next instruction /* ------------------------------ */ @@ -624,7 +622,7 @@ dalvik_inst: .L_OP_RETURN: /* 0x0f */ /* File: armv5te/OP_RETURN.S */ /* - * Return a 32-bit value. Copies the return value into the "glue" + * Return a 32-bit value. Copies the return value into the "thread" * structure, then jumps to the return handler. * * for: return, return-object @@ -632,7 +630,7 @@ dalvik_inst: /* op vAA */ mov r2, rINST, lsr #8 @ r2<- AA GET_VREG(r0, r2) @ r0<- vAA - str r0, [rGLUE, #offGlue_retval] @ retval.i <- vAA + str r0, [rSELF, #offThread_retval] @ retval.i <- vAA b common_returnFromMethod /* ------------------------------ */ @@ -640,13 +638,13 @@ dalvik_inst: .L_OP_RETURN_WIDE: /* 0x10 */ /* File: armv5te/OP_RETURN_WIDE.S */ /* - * Return a 64-bit value. Copies the return value into the "glue" + * Return a 64-bit value. Copies the return value into the "thread" * structure, then jumps to the return handler. */ /* return-wide vAA */ mov r2, rINST, lsr #8 @ r2<- AA add r2, rFP, r2, lsl #2 @ r2<- &fp[AA] - add r3, rGLUE, #offGlue_retval @ r3<- &glue->retval + add r3, rSELF, #offThread_retval @ r3<- &self->retval ldmia r2, {r0-r1} @ r0/r1 <- vAA/vAA+1 stmia r3, {r0-r1} @ retval<- r0/r1 b common_returnFromMethod @@ -657,7 +655,7 @@ dalvik_inst: /* File: armv5te/OP_RETURN_OBJECT.S */ /* File: armv5te/OP_RETURN.S */ /* - * Return a 32-bit value. Copies the return value into the "glue" + * Return a 32-bit value. Copies the return value into the "thread" * structure, then jumps to the return handler. * * for: return, return-object @@ -665,7 +663,7 @@ dalvik_inst: /* op vAA */ mov r2, rINST, lsr #8 @ r2<- AA GET_VREG(r0, r2) @ r0<- vAA - str r0, [rGLUE, #offGlue_retval] @ retval.i <- vAA + str r0, [rSELF, #offThread_retval] @ retval.i <- vAA b common_returnFromMethod @@ -791,7 +789,7 @@ dalvik_inst: /* File: armv5te/OP_CONST_STRING.S */ /* const/string vAA, String@BBBB */ FETCH(r1, 1) @ r1<- BBBB - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- glue->methodClassDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- self->methodClassDex mov r9, rINST, lsr #8 @ r9<- AA ldr r2, [r2, #offDvmDex_pResStrings] @ r2<- dvmDex->pResStrings ldr r0, [r2, r1, lsl #2] @ r0<- pResStrings[BBBB] @@ -809,7 +807,7 @@ dalvik_inst: /* const/string vAA, String@BBBBBBBB */ FETCH(r0, 1) @ r0<- bbbb (low) FETCH(r1, 2) @ r1<- BBBB (high) - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- glue->methodClassDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- self->methodClassDex mov r9, rINST, lsr #8 @ r9<- AA ldr r2, [r2, #offDvmDex_pResStrings] @ r2<- dvmDex->pResStrings orr r1, r0, r1, lsl #16 @ r1<- BBBBbbbb @@ -827,7 +825,7 @@ dalvik_inst: /* File: armv5te/OP_CONST_CLASS.S */ /* const/class vAA, Class@BBBB */ FETCH(r1, 1) @ r1<- BBBB - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- glue->methodClassDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- self->methodClassDex mov r9, rINST, lsr #8 @ r9<- AA ldr r2, [r2, #offDvmDex_pResClasses] @ r2<- dvmDex->pResClasses ldr r0, [r2, r1, lsl #2] @ r0<- pResClasses[BBBB] @@ -848,7 +846,7 @@ dalvik_inst: /* monitor-enter vAA */ mov r2, rINST, lsr #8 @ r2<- AA GET_VREG(r1, r2) @ r1<- vAA (object) - ldr r0, [rGLUE, #offGlue_self] @ r0<- glue->self + mov r0, rSELF @ r0<- self cmp r1, #0 @ null object? EXPORT_PC() @ need for precise GC beq common_errNullObject @ null object, throw an exception @@ -874,7 +872,7 @@ dalvik_inst: GET_VREG(r1, r2) @ r1<- vAA (object) cmp r1, #0 @ null object? beq 1f @ yes - ldr r0, [rGLUE, #offGlue_self] @ r0<- glue->self + mov r0, rSELF @ r0<- self bl dvmUnlockObject @ r0<- success for unlock(self, obj) cmp r0, #0 @ failed? FETCH_ADVANCE_INST(1) @ before throw: advance rPC, load rINST @@ -896,7 +894,7 @@ dalvik_inst: mov r3, rINST, lsr #8 @ r3<- AA FETCH(r2, 1) @ r2<- BBBB GET_VREG(r9, r3) @ r9<- object - ldr r0, [rGLUE, #offGlue_methodClassDex] @ r0<- pDvmDex + ldr r0, [rSELF, #offThread_methodClassDex] @ r0<- pDvmDex cmp r9, #0 @ is object null? ldr r0, [r0, #offDvmDex_pResClasses] @ r0<- pDvmDex->pResClasses beq .LOP_CHECK_CAST_okay @ null obj, cast always succeeds @@ -928,7 +926,7 @@ dalvik_inst: GET_VREG(r0, r3) @ r0<- vB (object) and r9, r9, #15 @ r9<- A cmp r0, #0 @ is object null? - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- pDvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- pDvmDex beq .LOP_INSTANCE_OF_store @ null obj, not an instance, store r0 FETCH(r3, 1) @ r3<- CCCC ldr r2, [r2, #offDvmDex_pResClasses] @ r2<- pDvmDex->pResClasses @@ -968,7 +966,7 @@ dalvik_inst: * Create a new instance of a class. */ /* new-instance vAA, class@BBBB */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r1, 1) @ r1<- BBBB ldr r3, [r3, #offDvmDex_pResClasses] @ r3<- pDvmDex->pResClasses ldr r0, [r3, r1, lsl #2] @ r0<- resolved class @@ -998,7 +996,7 @@ dalvik_inst: /* new-array vA, vB, class@CCCC */ mov r0, rINST, lsr #12 @ r0<- B FETCH(r2, 1) @ r2<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex GET_VREG(r1, r0) @ r1<- vB (array length) ldr r3, [r3, #offDvmDex_pResClasses] @ r3<- pDvmDex->pResClasses cmp r1, #0 @ check length @@ -1020,7 +1018,7 @@ dalvik_inst: */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op {vCCCC..v(CCCC+AA-1)}, type@BBBB */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r1, 1) @ r1<- BBBB ldr r3, [r3, #offDvmDex_pResClasses] @ r3<- pDvmDex->pResClasses EXPORT_PC() @ need for resolve and alloc @@ -1028,7 +1026,7 @@ dalvik_inst: mov r10, rINST, lsr #8 @ r10<- AA or BA cmp r0, #0 @ already resolved? bne .LOP_FILLED_NEW_ARRAY_continue @ yes, continue on -8: ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method +8: ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r2, #0 @ r2<- false ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveClass @ r0<- call(clazz, ref) @@ -1048,7 +1046,7 @@ dalvik_inst: */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op {vCCCC..v(CCCC+AA-1)}, type@BBBB */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r1, 1) @ r1<- BBBB ldr r3, [r3, #offDvmDex_pResClasses] @ r3<- pDvmDex->pResClasses EXPORT_PC() @ need for resolve and alloc @@ -1056,7 +1054,7 @@ dalvik_inst: mov r10, rINST, lsr #8 @ r10<- AA or BA cmp r0, #0 @ already resolved? bne .LOP_FILLED_NEW_ARRAY_RANGE_continue @ yes, continue on -8: ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method +8: ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r2, #0 @ r2<- false ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveClass @ r0<- call(clazz, ref) @@ -1094,12 +1092,11 @@ dalvik_inst: /* throw vAA */ mov r2, rINST, lsr #8 @ r2<- AA GET_VREG(r1, r2) @ r1<- vAA (exception object) - ldr r0, [rGLUE, #offGlue_self] @ r0<- glue->self EXPORT_PC() @ exception handler can throw cmp r1, #0 @ null object? beq common_errNullObject @ yes, throw an NPE instead @ bypass dvmSetException, just store it - str r1, [r0, #offThread_exception] @ thread->exception<- obj + str r1, [rSELF, #offThread_exception] @ thread->exception<- obj b common_exceptionThrown /* ------------------------------ */ @@ -2405,14 +2402,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2429,14 +2426,14 @@ dalvik_inst: */ /* iget-wide vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_WIDE_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2456,14 +2453,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_OBJECT_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2485,14 +2482,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_BOOLEAN_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2514,14 +2511,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_BYTE_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2543,14 +2540,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_CHAR_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2572,14 +2569,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_SHORT_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2599,14 +2596,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2620,14 +2617,14 @@ dalvik_inst: /* File: armv5te/OP_IPUT_WIDE.S */ /* iput-wide vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_WIDE_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2646,14 +2643,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_OBJECT_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2674,14 +2671,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_BOOLEAN_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2703,14 +2700,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_BYTE_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2732,14 +2729,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_CHAR_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2761,14 +2758,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_SHORT_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2787,7 +2784,7 @@ dalvik_inst: * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -2810,7 +2807,7 @@ dalvik_inst: * 64-bit SGET handler. */ /* sget-wide vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -2841,7 +2838,7 @@ dalvik_inst: * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -2868,7 +2865,7 @@ dalvik_inst: * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -2895,7 +2892,7 @@ dalvik_inst: * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -2922,7 +2919,7 @@ dalvik_inst: * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -2949,7 +2946,7 @@ dalvik_inst: * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -2975,7 +2972,7 @@ dalvik_inst: * for: sput, sput-boolean, sput-byte, sput-char, sput-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -2998,7 +2995,7 @@ dalvik_inst: * 64-bit SPUT handler. */ /* sput-wide vAA, field@BBBB */ - ldr r0, [rGLUE, #offGlue_methodClassDex] @ r0<- DvmDex + ldr r0, [rSELF, #offThread_methodClassDex] @ r0<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r0, [r0, #offDvmDex_pResFields] @ r0<- dvmDex->pResFields mov r9, rINST, lsr #8 @ r9<- AA @@ -3028,13 +3025,13 @@ dalvik_inst: * for: sput-object, sput-object-volatile */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_SPUT_OBJECT_finish @ no, continue - ldr r9, [rGLUE, #offGlue_method] @ r9<- current method + ldr r9, [rSELF, #offThread_method] @ r9<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r9, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -3054,7 +3051,7 @@ dalvik_inst: * for: sput, sput-boolean, sput-byte, sput-char, sput-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -3081,7 +3078,7 @@ dalvik_inst: * for: sput, sput-boolean, sput-byte, sput-char, sput-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -3108,7 +3105,7 @@ dalvik_inst: * for: sput, sput-boolean, sput-byte, sput-char, sput-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -3135,7 +3132,7 @@ dalvik_inst: * for: sput, sput-boolean, sput-byte, sput-char, sput-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -3162,7 +3159,7 @@ dalvik_inst: */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r1, 1) @ r1<- BBBB ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods FETCH(r10, 2) @ r10<- GFED or CCCC @@ -3173,7 +3170,7 @@ dalvik_inst: cmp r0, #0 @ already resolved? EXPORT_PC() @ must export for invoke bne .LOP_INVOKE_VIRTUAL_continue @ yes, continue on - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_VIRTUAL @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) @@ -3193,7 +3190,7 @@ dalvik_inst: /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ FETCH(r10, 2) @ r10<- GFED or CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex .if (!0) and r10, r10, #15 @ r10<- D (or stays CCCC) .endif @@ -3202,7 +3199,7 @@ dalvik_inst: GET_VREG(r2, r10) @ r2<- "this" ptr ldr r0, [r3, r1, lsl #2] @ r0<- resolved baseMethod cmp r2, #0 @ null "this"? - ldr r9, [rGLUE, #offGlue_method] @ r9<- current method + ldr r9, [rSELF, #offThread_method] @ r9<- current method beq common_errNullObject @ null "this", throw exception cmp r0, #0 @ already resolved? ldr r9, [r9, #offMethod_clazz] @ r9<- method->clazz @@ -3226,7 +3223,7 @@ dalvik_inst: */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r1, 1) @ r1<- BBBB ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods FETCH(r10, 2) @ r10<- GFED or CCCC @@ -3254,14 +3251,14 @@ dalvik_inst: */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r1, 1) @ r1<- BBBB ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods ldr r0, [r3, r1, lsl #2] @ r0<- resolved methodToCall cmp r0, #0 @ already resolved? EXPORT_PC() @ must export for invoke bne common_invokeMethodNoRange @ yes, continue on -0: ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method +0: ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_STATIC @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) @@ -3287,9 +3284,9 @@ dalvik_inst: .endif EXPORT_PC() @ must export for invoke GET_VREG(r0, r2) @ r0<- first arg ("this") - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- methodClassDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- methodClassDex cmp r0, #0 @ null obj? - ldr r2, [rGLUE, #offGlue_method] @ r2<- method + ldr r2, [rSELF, #offThread_method] @ r2<- method beq common_errNullObject @ yes, fail ldr r0, [r0, #offObject_clazz] @ r0<- thisPtr->clazz bl dvmFindInterfaceMethodInCache @ r0<- call(class, ref, method, dex) @@ -3317,7 +3314,7 @@ dalvik_inst: */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r1, 1) @ r1<- BBBB ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods FETCH(r10, 2) @ r10<- GFED or CCCC @@ -3328,7 +3325,7 @@ dalvik_inst: cmp r0, #0 @ already resolved? EXPORT_PC() @ must export for invoke bne .LOP_INVOKE_VIRTUAL_RANGE_continue @ yes, continue on - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_VIRTUAL @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) @@ -3350,7 +3347,7 @@ dalvik_inst: /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ FETCH(r10, 2) @ r10<- GFED or CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex .if (!1) and r10, r10, #15 @ r10<- D (or stays CCCC) .endif @@ -3359,7 +3356,7 @@ dalvik_inst: GET_VREG(r2, r10) @ r2<- "this" ptr ldr r0, [r3, r1, lsl #2] @ r0<- resolved baseMethod cmp r2, #0 @ null "this"? - ldr r9, [rGLUE, #offGlue_method] @ r9<- current method + ldr r9, [rSELF, #offThread_method] @ r9<- current method beq common_errNullObject @ null "this", throw exception cmp r0, #0 @ already resolved? ldr r9, [r9, #offMethod_clazz] @ r9<- method->clazz @@ -3385,7 +3382,7 @@ dalvik_inst: */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r1, 1) @ r1<- BBBB ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods FETCH(r10, 2) @ r10<- GFED or CCCC @@ -3415,14 +3412,14 @@ dalvik_inst: */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r1, 1) @ r1<- BBBB ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods ldr r0, [r3, r1, lsl #2] @ r0<- resolved methodToCall cmp r0, #0 @ already resolved? EXPORT_PC() @ must export for invoke bne common_invokeMethodRange @ yes, continue on -0: ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method +0: ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_STATIC @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) @@ -3450,9 +3447,9 @@ dalvik_inst: .endif EXPORT_PC() @ must export for invoke GET_VREG(r0, r2) @ r0<- first arg ("this") - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- methodClassDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- methodClassDex cmp r0, #0 @ null obj? - ldr r2, [rGLUE, #offGlue_method] @ r2<- method + ldr r2, [rSELF, #offThread_method] @ r2<- method beq common_errNullObject @ yes, fail ldr r0, [r0, #offObject_clazz] @ r0<- thisPtr->clazz bl dvmFindInterfaceMethodInCache @ r0<- call(class, ref, method, dex) @@ -7410,14 +7407,14 @@ d2i_doconv: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_VOLATILE_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -7438,14 +7435,14 @@ d2i_doconv: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_VOLATILE_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -7465,7 +7462,7 @@ d2i_doconv: * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -7492,7 +7489,7 @@ d2i_doconv: * for: sput, sput-boolean, sput-byte, sput-char, sput-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -7520,14 +7517,14 @@ d2i_doconv: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_OBJECT_VOLATILE_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -7546,14 +7543,14 @@ d2i_doconv: */ /* iget-wide vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_WIDE_VOLATILE_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -7569,14 +7566,14 @@ d2i_doconv: /* File: armv5te/OP_IPUT_WIDE.S */ /* iput-wide vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_WIDE_VOLATILE_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -7594,7 +7591,7 @@ d2i_doconv: * 64-bit SGET handler. */ /* sget-wide vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -7624,7 +7621,7 @@ d2i_doconv: * 64-bit SPUT handler. */ /* sput-wide vAA, field@BBBB */ - ldr r0, [rGLUE, #offGlue_methodClassDex] @ r0<- DvmDex + ldr r0, [rSELF, #offThread_methodClassDex] @ r0<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r0, [r0, #offDvmDex_pResFields] @ r0<- dvmDex->pResFields mov r9, rINST, lsr #8 @ r9<- AA @@ -7663,7 +7660,7 @@ d2i_doconv: * exception is indicated by AA, with some detail provided by BBBB. */ /* op AA, ref@BBBB */ - ldr r0, [rGLUE, #offGlue_method] @ r0<- glue->method + ldr r0, [rSELF, #offThread_method] @ r0<- self->method FETCH(r2, 1) @ r2<- BBBB EXPORT_PC() @ export the PC mov r1, rINST, lsr #8 @ r1<- AA @@ -7686,11 +7683,11 @@ d2i_doconv: */ /* [opt] execute-inline vAA, {vC, vD, vE, vF}, inline@BBBB */ FETCH(r10, 1) @ r10<- BBBB - add r1, rGLUE, #offGlue_retval @ r1<- &glue->retval + add r1, rSELF, #offThread_retval @ r1<- &self->retval EXPORT_PC() @ can throw sub sp, sp, #8 @ make room for arg, +64 bit align mov r0, rINST, lsr #12 @ r0<- B - str r1, [sp] @ push &glue->retval + str r1, [sp] @ push &self->retval bl .LOP_EXECUTE_INLINE_continue @ make call; will return after add sp, sp, #8 @ pop stack cmp r0, #0 @ test boolean result of inline @@ -7716,11 +7713,11 @@ d2i_doconv: */ /* [opt] execute-inline/range {vCCCC..v(CCCC+AA-1)}, inline@BBBB */ FETCH(r10, 1) @ r10<- BBBB - add r1, rGLUE, #offGlue_retval @ r1<- &glue->retval + add r1, rSELF, #offThread_retval @ r1<- &self->retval EXPORT_PC() @ can throw sub sp, sp, #8 @ make room for arg, +64 bit align mov r0, rINST, lsr #8 @ r0<- AA - str r1, [sp] @ push &glue->retval + str r1, [sp] @ push &self->retval bl .LOP_EXECUTE_INLINE_RANGE_continue @ make call; will return after add sp, sp, #8 @ pop stack cmp r0, #0 @ test boolean result of inline @@ -7870,7 +7867,7 @@ d2i_doconv: beq common_errNullObject @ object was null and r2, r2, #15 GET_VREG(r0, r2) @ r0<- fp[A] - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base FETCH_ADVANCE_INST(2) @ advance rPC, load rINST str r0, [r3, r1] @ obj.field (always 32 bits)<- r0 cmp r0, #0 @@ -7942,7 +7939,7 @@ d2i_doconv: /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ FETCH(r10, 2) @ r10<- GFED or CCCC - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method .if (!0) and r10, r10, #15 @ r10<- D (or stays CCCC) .endif @@ -7970,7 +7967,7 @@ d2i_doconv: /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ FETCH(r10, 2) @ r10<- GFED or CCCC - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method .if (!1) and r10, r10, #15 @ r10<- D (or stays CCCC) .endif @@ -7998,14 +7995,14 @@ d2i_doconv: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_OBJECT_VOLATILE_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8025,7 +8022,7 @@ d2i_doconv: * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -8052,13 +8049,13 @@ d2i_doconv: * for: sput-object, sput-object-volatile */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_SPUT_OBJECT_VOLATILE_finish @ no, continue - ldr r9, [rGLUE, #offGlue_method] @ r9<- current method + ldr r9, [rSELF, #offThread_method] @ r9<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r9, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -8083,7 +8080,7 @@ d2i_doconv: /* File: armv5te/OP_CONST_CLASS_JUMBO.S */ /* const-class/jumbo vBBBB, Class@AAAAAAAA */ FETCH(r0, 1) @ r0<- aaaa (lo) - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- glue->methodClassDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<-self>methodClassDex FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResClasses] @ r2<- dvmDex->pResClasses orr r1, r0, r1, lsl #16 @ r1<- AAAAaaaa @@ -8109,7 +8106,7 @@ d2i_doconv: FETCH(r3, 3) @ r3<- BBBB orr r2, r0, r2, lsl #16 @ r2<- AAAAaaaa GET_VREG(r9, r3) @ r9<- object - ldr r0, [rGLUE, #offGlue_methodClassDex] @ r0<- pDvmDex + ldr r0, [rSELF, #offThread_methodClassDex] @ r0<- pDvmDex cmp r9, #0 @ is object null? ldr r0, [r0, #offDvmDex_pResClasses] @ r0<- pDvmDex->pResClasses beq .LOP_CHECK_CAST_JUMBO_okay @ null obj, cast always succeeds @@ -8139,7 +8136,7 @@ d2i_doconv: FETCH(r3, 4) @ r3<- vCCCC FETCH(r9, 3) @ r9<- vBBBB GET_VREG(r0, r3) @ r0<- vCCCC (object) - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- pDvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- pDvmDex cmp r0, #0 @ is object null? beq .LOP_INSTANCE_OF_JUMBO_store @ null obj, not an instance, store r0 FETCH(r1, 1) @ r1<- aaaa (lo) @@ -8162,7 +8159,7 @@ d2i_doconv: /* new-instance/jumbo vBBBB, class@AAAAAAAA */ FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex orr r1, r0, r1, lsl #16 @ r1<- AAAAaaaa ldr r3, [r3, #offDvmDex_pResClasses] @ r3<- pDvmDex->pResClasses ldr r0, [r3, r1, lsl #2] @ r0<- resolved class @@ -8194,7 +8191,7 @@ d2i_doconv: FETCH(r3, 2) @ r3<- AAAA (hi) FETCH(r0, 4) @ r0<- vCCCC orr r2, r2, r3, lsl #16 @ r2<- AAAAaaaa - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex GET_VREG(r1, r0) @ r1<- vCCCC (array length) ldr r3, [r3, #offDvmDex_pResClasses] @ r3<- pDvmDex->pResClasses cmp r1, #0 @ check length @@ -8216,7 +8213,7 @@ d2i_doconv: * OP_FILLED_NEW_ARRAY.S. */ /* filled-new-array/jumbo {vCCCC..v(CCCC+BBBB-1)}, type@AAAAAAAA */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r3, [r3, #offDvmDex_pResClasses] @ r3<- pDvmDex->pResClasses @@ -8225,7 +8222,7 @@ d2i_doconv: EXPORT_PC() @ need for resolve and alloc cmp r0, #0 @ already resolved? bne .LOP_FILLED_NEW_ARRAY_JUMBO_continue @ yes, continue on -8: ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method +8: ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r2, #0 @ r2<- false ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveClass @ r0<- call(clazz, ref) @@ -8247,14 +8244,14 @@ d2i_doconv: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8271,14 +8268,14 @@ d2i_doconv: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_WIDE_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8299,14 +8296,14 @@ d2i_doconv: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_OBJECT_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8329,14 +8326,14 @@ d2i_doconv: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_BOOLEAN_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8359,14 +8356,14 @@ d2i_doconv: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_BYTE_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8389,14 +8386,14 @@ d2i_doconv: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_CHAR_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8419,14 +8416,14 @@ d2i_doconv: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_SHORT_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8447,14 +8444,14 @@ d2i_doconv: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8468,14 +8465,14 @@ d2i_doconv: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_WIDE_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8492,14 +8489,14 @@ d2i_doconv: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_OBJECT_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8521,14 +8518,14 @@ d2i_doconv: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_BOOLEAN_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8551,14 +8548,14 @@ d2i_doconv: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_BYTE_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8581,14 +8578,14 @@ d2i_doconv: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_CHAR_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8611,14 +8608,14 @@ d2i_doconv: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_SHORT_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8636,7 +8633,7 @@ d2i_doconv: * sget-char/jumbo, sget-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8661,7 +8658,7 @@ d2i_doconv: * Jumbo 64-bit SGET handler. */ /* sget-wide/jumbo vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8690,7 +8687,7 @@ d2i_doconv: * sget-char/jumbo, sget-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8720,7 +8717,7 @@ d2i_doconv: * sget-char/jumbo, sget-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8750,7 +8747,7 @@ d2i_doconv: * sget-char/jumbo, sget-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8780,7 +8777,7 @@ d2i_doconv: * sget-char/jumbo, sget-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8810,7 +8807,7 @@ d2i_doconv: * sget-char/jumbo, sget-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8839,7 +8836,7 @@ d2i_doconv: * sput-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8864,7 +8861,7 @@ d2i_doconv: * Jumbo 64-bit SPUT handler. */ /* sput-wide/jumbo vBBBB, field@AAAAAAAA */ - ldr r0, [rGLUE, #offGlue_methodClassDex] @ r0<- DvmDex + ldr r0, [rSELF, #offThread_methodClassDex] @ r0<- DvmDex FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) ldr r0, [r0, #offDvmDex_pResFields] @ r0<- dvmDex->pResFields @@ -8889,7 +8886,7 @@ d2i_doconv: * Jumbo 32-bit SPUT handler for objects */ /* sput-object/jumbo vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8897,7 +8894,7 @@ d2i_doconv: ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_SPUT_OBJECT_JUMBO_finish @ no, continue - ldr r9, [rGLUE, #offGlue_method] @ r9<- current method + ldr r9, [rSELF, #offThread_method] @ r9<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r9, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -8917,7 +8914,7 @@ d2i_doconv: * sput-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8947,7 +8944,7 @@ d2i_doconv: * sput-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8977,7 +8974,7 @@ d2i_doconv: * sput-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -9007,7 +9004,7 @@ d2i_doconv: * sput-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -9033,7 +9030,7 @@ d2i_doconv: * Handle a virtual method call. */ /* invoke-virtual/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r0, 1) @ r1<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods @@ -9042,7 +9039,7 @@ d2i_doconv: cmp r0, #0 @ already resolved? EXPORT_PC() @ must export for invoke bne .LOP_INVOKE_VIRTUAL_JUMBO_continue @ yes, continue on - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_VIRTUAL @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) @@ -9059,7 +9056,7 @@ d2i_doconv: */ /* invoke-super/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ FETCH(r10, 4) @ r10<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r0, 1) @ r1<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods @@ -9067,7 +9064,7 @@ d2i_doconv: GET_VREG(r2, r10) @ r2<- "this" ptr ldr r0, [r3, r1, lsl #2] @ r0<- resolved baseMethod cmp r2, #0 @ null "this"? - ldr r9, [rGLUE, #offGlue_method] @ r9<- current method + ldr r9, [rSELF, #offThread_method] @ r9<- current method beq common_errNullObject @ null "this", throw exception cmp r0, #0 @ already resolved? ldr r9, [r9, #offMethod_clazz] @ r9<- method->clazz @@ -9089,7 +9086,7 @@ d2i_doconv: * */ /* invoke-direct/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r0, 1) @ r1<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods @@ -9113,7 +9110,7 @@ d2i_doconv: * Handle a static method call. */ /* invoke-static/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r0, 1) @ r1<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods @@ -9122,7 +9119,7 @@ d2i_doconv: cmp r0, #0 @ already resolved? EXPORT_PC() @ must export for invoke bne common_invokeMethodJumbo @ yes, continue on -0: ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method +0: ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_STATIC @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) @@ -9144,9 +9141,9 @@ d2i_doconv: EXPORT_PC() @ must export for invoke orr r1, r0, r1, lsl #16 @ r1<- AAAAaaaa GET_VREG(r0, r2) @ r0<- first arg ("this") - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- methodClassDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- methodClassDex cmp r0, #0 @ null obj? - ldr r2, [rGLUE, #offGlue_method] @ r2<- method + ldr r2, [rSELF, #offThread_method] @ r2<- method beq common_errNullObject @ yes, fail ldr r0, [r0, #offObject_clazz] @ r0<- thisPtr->clazz bl dvmFindInterfaceMethodInCache @ r0<- call(class, ref, method, dex) @@ -10894,7 +10891,7 @@ d2i_doconv: /* exop BBBB, Class@AAAAAAAA */ FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) - ldr r0, [rGLUE, #offGlue_method] @ r0<- glue->method + ldr r0, [rSELF, #offThread_method] @ r0<- self->method orr r2, r1, r2, lsl #16 @ r2<- AAAAaaaa EXPORT_PC() @ export the PC FETCH(r1, 3) @ r1<- BBBB @@ -10927,7 +10924,7 @@ dvmAsmSisterStart: */ .LOP_CONST_STRING_resolve: EXPORT_PC() - ldr r0, [rGLUE, #offGlue_method] @ r0<- glue->method + ldr r0, [rSELF, #offThread_method] @ r0<- self->method ldr r0, [r0, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveString @ r0<- String reference cmp r0, #0 @ failed? @@ -10946,7 +10943,7 @@ dvmAsmSisterStart: */ .LOP_CONST_STRING_JUMBO_resolve: EXPORT_PC() - ldr r0, [rGLUE, #offGlue_method] @ r0<- glue->method + ldr r0, [rSELF, #offThread_method] @ r0<- self->method ldr r0, [r0, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveString @ r0<- String reference cmp r0, #0 @ failed? @@ -10965,7 +10962,7 @@ dvmAsmSisterStart: */ .LOP_CONST_CLASS_resolve: EXPORT_PC() - ldr r0, [rGLUE, #offGlue_method] @ r0<- glue->method + ldr r0, [rSELF, #offThread_method] @ r0<- self->method mov r2, #1 @ r2<- true ldr r0, [r0, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveClass @ r0<- Class reference @@ -11005,7 +11002,7 @@ dvmAsmSisterStart: */ .LOP_CHECK_CAST_resolve: EXPORT_PC() @ resolve() could throw - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r1, r2 @ r1<- BBBB mov r2, #0 @ r2<- false ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz @@ -11058,7 +11055,7 @@ dvmAsmSisterStart: */ .LOP_INSTANCE_OF_resolve: EXPORT_PC() @ resolve() could throw - ldr r0, [rGLUE, #offGlue_method] @ r0<- glue->method + ldr r0, [rSELF, #offThread_method] @ r0<- self->method mov r1, r3 @ r1<- BBBB mov r2, #1 @ r2<- true ldr r0, [r0, #offMethod_clazz] @ r0<- method->clazz @@ -11102,7 +11099,7 @@ dvmAsmSisterStart: * r1 holds BBBB */ .LOP_NEW_INSTANCE_resolve: - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r2, #0 @ r2<- false ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveClass @ r0<- resolved ClassObject ptr @@ -11123,7 +11120,7 @@ dvmAsmSisterStart: * r2 holds class ref CCCC */ .LOP_NEW_ARRAY_resolve: - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r9, r1 @ r9<- length (save) mov r1, r2 @ r1<- CCCC mov r2, #0 @ r2<- false @@ -11178,8 +11175,8 @@ dvmAsmSisterStart: beq common_exceptionThrown @ alloc failed, handle exception FETCH(r1, 2) @ r1<- FEDC or CCCC - str r0, [rGLUE, #offGlue_retval] @ retval.l <- new array - str rINST, [rGLUE, #offGlue_retval+4] @ retval.h <- type + str r0, [rSELF, #offThread_retval] @ retval.l <- new array + str rINST, [rSELF, #offThread_retval+4] @ retval.h <- type add r0, r0, #offArrayObject_contents @ r0<- newArray->contents subs r9, r9, #1 @ length--, check for neg FETCH_ADVANCE_INST(3) @ advance to next instr, load rINST @@ -11211,9 +11208,9 @@ dvmAsmSisterStart: .endif 2: - ldr r0, [rGLUE, #offGlue_retval] @ r0<- object - ldr r1, [rGLUE, #offGlue_retval+4] @ r1<- type - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r0, [rSELF, #offThread_retval] @ r0<- object + ldr r1, [rSELF, #offThread_retval+4] @ r1<- type + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base GET_INST_OPCODE(ip) @ ip<- opcode from rINST cmp r1, #'I' @ Is int array? strneb r2, [r2, r0, lsr #GC_CARD_SHIFT] @ Mark card based on object head @@ -11262,8 +11259,8 @@ dvmAsmSisterStart: beq common_exceptionThrown @ alloc failed, handle exception FETCH(r1, 2) @ r1<- FEDC or CCCC - str r0, [rGLUE, #offGlue_retval] @ retval.l <- new array - str rINST, [rGLUE, #offGlue_retval+4] @ retval.h <- type + str r0, [rSELF, #offThread_retval] @ retval.l <- new array + str rINST, [rSELF, #offThread_retval+4] @ retval.h <- type add r0, r0, #offArrayObject_contents @ r0<- newArray->contents subs r9, r9, #1 @ length--, check for neg FETCH_ADVANCE_INST(3) @ advance to next instr, load rINST @@ -11295,9 +11292,9 @@ dvmAsmSisterStart: .endif 2: - ldr r0, [rGLUE, #offGlue_retval] @ r0<- object - ldr r1, [rGLUE, #offGlue_retval+4] @ r1<- type - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r0, [rSELF, #offThread_retval] @ r0<- object + ldr r1, [rSELF, #offThread_retval+4] @ r1<- type + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base GET_INST_OPCODE(ip) @ ip<- opcode from rINST cmp r1, #'I' @ Is int array? strneb r2, [r2, r0, lsr #GC_CARD_SHIFT] @ Mark card based on object head @@ -11533,7 +11530,7 @@ OP_CMPG_FLOAT_nan: beq .LOP_APUT_OBJECT_throw @ no mov r1, rINST @ r1<- arrayObj FETCH_ADVANCE_INST(2) @ advance rPC, load rINST - ldr r2, [rGLUE, #offGlue_cardTable] @ get biased CT base + ldr r2, [rSELF, #offThread_cardTable] @ get biased CT base add r10, #offArrayObject_contents @ r0<- pointer to slot GET_INST_OPCODE(ip) @ extract opcode from rINST str r9, [r10] @ vBB[vCC]<- vAA @@ -11763,7 +11760,7 @@ OP_CMPG_FLOAT_nan: and r1, r1, #15 @ r1<- A cmp r9, #0 @ check object for null GET_VREG(r0, r1) @ r0<- fp[A] - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base beq common_errNullObject @ object was null FETCH_ADVANCE_INST(2) @ advance rPC, load rINST GET_INST_OPCODE(ip) @ extract opcode from rINST @@ -11864,7 +11861,7 @@ OP_CMPG_FLOAT_nan: * r1: BBBB field ref */ .LOP_SGET_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11881,7 +11878,7 @@ OP_CMPG_FLOAT_nan: * Returns StaticField pointer in r0. */ .LOP_SGET_WIDE_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11896,7 +11893,7 @@ OP_CMPG_FLOAT_nan: * r1: BBBB field ref */ .LOP_SGET_OBJECT_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11911,7 +11908,7 @@ OP_CMPG_FLOAT_nan: * r1: BBBB field ref */ .LOP_SGET_BOOLEAN_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11926,7 +11923,7 @@ OP_CMPG_FLOAT_nan: * r1: BBBB field ref */ .LOP_SGET_BYTE_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11941,7 +11938,7 @@ OP_CMPG_FLOAT_nan: * r1: BBBB field ref */ .LOP_SGET_CHAR_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11956,7 +11953,7 @@ OP_CMPG_FLOAT_nan: * r1: BBBB field ref */ .LOP_SGET_SHORT_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11971,7 +11968,7 @@ OP_CMPG_FLOAT_nan: * r1: BBBB field ref */ .LOP_SPUT_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11989,7 +11986,7 @@ OP_CMPG_FLOAT_nan: * Returns StaticField pointer in r2. */ .LOP_SPUT_WIDE_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12003,7 +12000,7 @@ OP_CMPG_FLOAT_nan: mov r2, rINST, lsr #8 @ r2<- AA FETCH_ADVANCE_INST(2) @ advance rPC, load rINST GET_VREG(r1, r2) @ r1<- fp[AA] - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base ldr r9, [r0, #offField_clazz] @ r9<- field->clazz GET_INST_OPCODE(ip) @ extract opcode from rINST @ no-op @ releasing store @@ -12019,7 +12016,7 @@ OP_CMPG_FLOAT_nan: * r1: BBBB field ref */ .LOP_SPUT_BOOLEAN_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12034,7 +12031,7 @@ OP_CMPG_FLOAT_nan: * r1: BBBB field ref */ .LOP_SPUT_BYTE_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12049,7 +12046,7 @@ OP_CMPG_FLOAT_nan: * r1: BBBB field ref */ .LOP_SPUT_CHAR_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12064,7 +12061,7 @@ OP_CMPG_FLOAT_nan: * r1: BBBB field ref */ .LOP_SPUT_SHORT_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12131,7 +12128,7 @@ OP_CMPG_FLOAT_nan: * r10 = "this" register */ .LOP_INVOKE_DIRECT_resolve: - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_DIRECT @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) @@ -12199,7 +12196,7 @@ OP_CMPG_FLOAT_nan: * r10 = "this" register */ .LOP_INVOKE_DIRECT_RANGE_resolve: - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_DIRECT @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) @@ -12396,7 +12393,7 @@ d2l_doconv: * r1: BBBB field ref */ .LOP_SGET_VOLATILE_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12411,7 +12408,7 @@ d2l_doconv: * r1: BBBB field ref */ .LOP_SPUT_VOLATILE_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12499,7 +12496,7 @@ d2l_doconv: * Returns StaticField pointer in r0. */ .LOP_SGET_WIDE_VOLATILE_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12517,7 +12514,7 @@ d2l_doconv: * Returns StaticField pointer in r2. */ .LOP_SPUT_WIDE_VOLATILE_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12604,7 +12601,7 @@ d2l_doconv: and r1, r1, #15 @ r1<- A cmp r9, #0 @ check object for null GET_VREG(r0, r1) @ r0<- fp[A] - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base beq common_errNullObject @ object was null FETCH_ADVANCE_INST(2) @ advance rPC, load rINST GET_INST_OPCODE(ip) @ extract opcode from rINST @@ -12621,7 +12618,7 @@ d2l_doconv: * r1: BBBB field ref */ .LOP_SGET_OBJECT_VOLATILE_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12634,7 +12631,7 @@ d2l_doconv: mov r2, rINST, lsr #8 @ r2<- AA FETCH_ADVANCE_INST(2) @ advance rPC, load rINST GET_VREG(r1, r2) @ r1<- fp[AA] - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base ldr r9, [r0, #offField_clazz] @ r9<- field->clazz GET_INST_OPCODE(ip) @ extract opcode from rINST SMP_DMB @ releasing store @@ -12652,7 +12649,7 @@ d2l_doconv: */ .LOP_CONST_CLASS_JUMBO_resolve: EXPORT_PC() - ldr r0, [rGLUE, #offGlue_method] @ r0<- glue->method + ldr r0, [rSELF, #offThread_method] @ r0<- self->method mov r2, #1 @ r2<- true ldr r0, [r0, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveClass @ r0<- Class reference @@ -12700,7 +12697,7 @@ d2l_doconv: */ .LOP_CHECK_CAST_JUMBO_resolve: EXPORT_PC() @ resolve() could throw - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r1, r2 @ r1<- AAAAAAAA mov r2, #0 @ r2<- false ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz @@ -12765,7 +12762,7 @@ d2l_doconv: .LOP_INSTANCE_OF_JUMBO_resolve: EXPORT_PC() @ resolve() could throw - ldr r0, [rGLUE, #offGlue_method] @ r0<- glue->method + ldr r0, [rSELF, #offThread_method] @ r0<- self->method mov r1, r3 @ r1<- AAAAAAAA mov r2, #1 @ r2<- true ldr r0, [r0, #offMethod_clazz] @ r0<- method->clazz @@ -12809,7 +12806,7 @@ d2l_doconv: * r1 holds AAAAAAAA */ .LOP_NEW_INSTANCE_JUMBO_resolve: - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r2, #0 @ r2<- false ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveClass @ r0<- resolved ClassObject ptr @@ -12827,7 +12824,7 @@ d2l_doconv: * r2 holds class ref AAAAAAAA */ .LOP_NEW_ARRAY_JUMBO_resolve: - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r9, r1 @ r9<- length (save) mov r1, r2 @ r1<- AAAAAAAA mov r2, #0 @ r2<- false @@ -12876,8 +12873,8 @@ d2l_doconv: beq common_exceptionThrown @ alloc failed, handle exception FETCH(r1, 4) @ r1<- CCCC - str r0, [rGLUE, #offGlue_retval] @ retval.l <- new array - str rINST, [rGLUE, #offGlue_retval+4] @ retval.h <- type + str r0, [rSELF, #offThread_retval] @ retval.l <- new array + str rINST, [rSELF, #offThread_retval+4] @ retval.h <- type add r0, r0, #offArrayObject_contents @ r0<- newArray->contents subs r9, r9, #1 @ length--, check for neg FETCH_ADVANCE_INST(5) @ advance to next instr, load rINST @@ -12891,9 +12888,9 @@ d2l_doconv: str r3, [r0], #4 @ *contents++ = vX bpl 1b -2: ldr r0, [rGLUE, #offGlue_retval] @ r0<- object - ldr r1, [rGLUE, #offGlue_retval+4] @ r1<- type - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base +2: ldr r0, [rSELF, #offThread_retval] @ r0<- object + ldr r1, [rSELF, #offThread_retval+4] @ r1<- type + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base GET_INST_OPCODE(ip) @ ip<- opcode from rINST cmp r1, #'I' @ Is int array? strneb r2, [r2, r0, lsr #GC_CARD_SHIFT] @ Mark card based on object head @@ -13200,7 +13197,7 @@ d2l_doconv: FETCH(r1, 3) @ r1<- BBBB cmp r9, #0 @ check object for null GET_VREG(r0, r1) @ r0<- fp[BBBB] - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base beq common_errNullObject @ object was null FETCH_ADVANCE_INST(5) @ advance rPC, load rINST GET_INST_OPCODE(ip) @ extract opcode from rINST @@ -13337,7 +13334,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SGET_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -13354,7 +13351,7 @@ d2l_doconv: * Returns StaticField pointer in r0. */ .LOP_SGET_WIDE_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -13369,7 +13366,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SGET_OBJECT_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -13384,7 +13381,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SGET_BOOLEAN_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -13399,7 +13396,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SGET_BYTE_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -13414,7 +13411,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SGET_CHAR_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -13429,7 +13426,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SGET_SHORT_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -13444,7 +13441,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SPUT_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -13462,7 +13459,7 @@ d2l_doconv: * Returns StaticField pointer in r2. */ .LOP_SPUT_WIDE_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -13477,7 +13474,7 @@ d2l_doconv: FETCH(r2, 3) @ r2<- BBBB FETCH_ADVANCE_INST(4) @ advance rPC, load rINST GET_VREG(r1, r2) @ r1<- fp[BBBB] - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base ldr r9, [r0, #offField_clazz] @ r9<- field->clazz GET_INST_OPCODE(ip) @ extract opcode from rINST @ no-op @ releasing store @@ -13493,7 +13490,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SPUT_BOOLEAN_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -13508,7 +13505,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SPUT_BYTE_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -13523,7 +13520,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SPUT_CHAR_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -13538,7 +13535,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SPUT_SHORT_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -13605,7 +13602,7 @@ d2l_doconv: * r10 = "this" register */ .LOP_INVOKE_DIRECT_JUMBO_resolve: - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_DIRECT @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) @@ -13635,71 +13632,64 @@ dvmAsmSisterEnd: #if defined(WITH_SELF_VERIFICATION) .global dvmJitToInterpPunt dvmJitToInterpPunt: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self mov r2,#kSVSPunt @ r2<- interpreter entry point mov r3, #0 - str r3, [r10, #offThread_inJitCodeCache] @ Back to the interp land + str r3, [rSELF, #offThread_inJitCodeCache] @ Back to the interp land b jitSVShadowRunEnd @ doesn't return .global dvmJitToInterpSingleStep dvmJitToInterpSingleStep: - str lr,[rGLUE,#offGlue_jitResumeNPC] - str r1,[rGLUE,#offGlue_jitResumeDPC] + str lr,[rSELF,#offThread_jitResumeNPC] + str r1,[rSELF,#offThread_jitResumeDPC] mov r2,#kSVSSingleStep @ r2<- interpreter entry point b jitSVShadowRunEnd @ doesn't return .global dvmJitToInterpNoChainNoProfile dvmJitToInterpNoChainNoProfile: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self mov r0,rPC @ pass our target PC mov r2,#kSVSNoProfile @ r2<- interpreter entry point mov r3, #0 @ 0 means !inJitCodeCache - str r3, [r10, #offThread_inJitCodeCache] @ back to the interp land + str r3, [rSELF, #offThread_inJitCodeCache] @ back to the interp land b jitSVShadowRunEnd @ doesn't return .global dvmJitToInterpTraceSelectNoChain dvmJitToInterpTraceSelectNoChain: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self mov r0,rPC @ pass our target PC mov r2,#kSVSTraceSelect @ r2<- interpreter entry point mov r3, #0 @ 0 means !inJitCodeCache - str r3, [r10, #offThread_inJitCodeCache] @ Back to the interp land + str r3, [rSELF, #offThread_inJitCodeCache] @ Back to the interp land b jitSVShadowRunEnd @ doesn't return .global dvmJitToInterpTraceSelect dvmJitToInterpTraceSelect: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self ldr r0,[lr, #-1] @ pass our target PC mov r2,#kSVSTraceSelect @ r2<- interpreter entry point mov r3, #0 @ 0 means !inJitCodeCache - str r3, [r10, #offThread_inJitCodeCache] @ Back to the interp land + str r3, [rSELF, #offThread_inJitCodeCache] @ Back to the interp land b jitSVShadowRunEnd @ doesn't return .global dvmJitToInterpBackwardBranch dvmJitToInterpBackwardBranch: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self ldr r0,[lr, #-1] @ pass our target PC mov r2,#kSVSBackwardBranch @ r2<- interpreter entry point mov r3, #0 @ 0 means !inJitCodeCache - str r3, [r10, #offThread_inJitCodeCache] @ Back to the interp land + str r3, [rSELF, #offThread_inJitCodeCache] @ Back to the interp land b jitSVShadowRunEnd @ doesn't return .global dvmJitToInterpNormal dvmJitToInterpNormal: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self ldr r0,[lr, #-1] @ pass our target PC mov r2,#kSVSNormal @ r2<- interpreter entry point mov r3, #0 @ 0 means !inJitCodeCache - str r3, [r10, #offThread_inJitCodeCache] @ Back to the interp land + str r3, [rSELF, #offThread_inJitCodeCache] @ Back to the interp land b jitSVShadowRunEnd @ doesn't return .global dvmJitToInterpNoChain dvmJitToInterpNoChain: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self mov r0,rPC @ pass our target PC mov r2,#kSVSNoChain @ r2<- interpreter entry point mov r3, #0 @ 0 means !inJitCodeCache - str r3, [r10, #offThread_inJitCodeCache] @ Back to the interp land + str r3, [rSELF, #offThread_inJitCodeCache] @ Back to the interp land b jitSVShadowRunEnd @ doesn't return #else /* @@ -13711,7 +13701,6 @@ dvmJitToInterpNoChain: */ .global dvmJitToInterpPunt dvmJitToInterpPunt: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self mov rPC, r0 #if defined(WITH_JIT_TUNING) mov r0,lr @@ -13719,7 +13708,7 @@ dvmJitToInterpPunt: #endif EXPORT_PC() mov r0, #0 - str r0, [r10, #offThread_inJitCodeCache] @ Back to the interp land + str r0, [rSELF, #offThread_inJitCodeCache] @ Back to the interp land adrl rIBASE, dvmAsmInstructionStart FETCH_INST() GET_INST_OPCODE(ip) @@ -13734,17 +13723,17 @@ dvmJitToInterpPunt: */ .global dvmJitToInterpSingleStep dvmJitToInterpSingleStep: - str lr,[rGLUE,#offGlue_jitResumeNPC] - str r1,[rGLUE,#offGlue_jitResumeDPC] + str lr,[rSELF,#offThread_jitResumeNPC] + str r1,[rSELF,#offThread_jitResumeDPC] mov r1,#kInterpEntryInstr @ enum is 4 byte in aapcs-EABI - str r1, [rGLUE, #offGlue_entryPoint] + str r1, [rSELF, #offThread_entryPoint] mov rPC,r0 EXPORT_PC() adrl rIBASE, dvmAsmInstructionStart mov r2,#kJitSingleStep @ Ask for single step and then revert - str r2,[rGLUE,#offGlue_jitState] + str r2,[rSELF,#offThread_jitState] mov r1,#1 @ set changeInterp to bail to debug interp b common_gotoBail @@ -13757,10 +13746,9 @@ dvmJitToInterpTraceSelectNoChain: #if defined(WITH_JIT_TUNING) bl dvmBumpNoChain #endif - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self mov r0,rPC bl dvmJitGetTraceAddr @ Is there a translation? - str r0, [r10, #offThread_inJitCodeCache] @ set the inJitCodeCache flag + str r0, [rSELF, #offThread_inJitCodeCache] @ set the inJitCodeCache flag mov r1, rPC @ arg1 of translation may need this mov lr, #0 @ in case target is HANDLER_INTERPRET cmp r0,#0 @ !0 means translation exists @@ -13775,12 +13763,11 @@ dvmJitToInterpTraceSelectNoChain: .global dvmJitToInterpTraceSelect dvmJitToInterpTraceSelect: ldr rPC,[lr, #-1] @ get our target PC - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self add rINST,lr,#-5 @ save start of chain branch add rINST, #-4 @ .. which is 9 bytes back mov r0,rPC bl dvmJitGetTraceAddr @ Is there a translation? - str r0, [r10, #offThread_inJitCodeCache] @ set the inJitCodeCache flag + str r0, [rSELF, #offThread_inJitCodeCache] @ set the inJitCodeCache flag cmp r0,#0 beq 2f mov r1,rINST @@ -13819,7 +13806,6 @@ dvmJitToInterpTraceSelect: .global dvmJitToInterpNormal dvmJitToInterpNormal: ldr rPC,[lr, #-1] @ get our target PC - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self add rINST,lr,#-5 @ save start of chain branch add rINST,#-4 @ .. which is 9 bytes back #if defined(WITH_JIT_TUNING) @@ -13827,7 +13813,7 @@ dvmJitToInterpNormal: #endif mov r0,rPC bl dvmJitGetTraceAddr @ Is there a translation? - str r0, [r10, #offThread_inJitCodeCache] @ set the inJitCodeCache flag + str r0, [rSELF, #offThread_inJitCodeCache] @ set the inJitCodeCache flag cmp r0,#0 beq toInterpreter @ go if not, otherwise do chain mov r1,rINST @@ -13847,10 +13833,9 @@ dvmJitToInterpNoChainNoProfile: #if defined(WITH_JIT_TUNING) bl dvmBumpNoChain #endif - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self mov r0,rPC bl dvmJitGetTraceAddr @ Is there a translation? - str r0, [r10, #offThread_inJitCodeCache] @ set the inJitCodeCache flag + str r0, [rSELF, #offThread_inJitCodeCache] @ set the inJitCodeCache flag mov r1, rPC @ arg1 of translation may need this mov lr, #0 @ in case target is HANDLER_INTERPRET cmp r0,#0 @@ -13870,10 +13855,9 @@ dvmJitToInterpNoChain: #if defined(WITH_JIT_TUNING) bl dvmBumpNoChain #endif - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self mov r0,rPC bl dvmJitGetTraceAddr @ Is there a translation? - str r0, [r10, #offThread_inJitCodeCache] @ set the inJitCodeCache flag + str r0, [rSELF, #offThread_inJitCodeCache] @ set the inJitCodeCache flag mov r1, rPC @ arg1 of translation may need this mov lr, #0 @ in case target is HANDLER_INTERPRET cmp r0,#0 @@ -13882,7 +13866,7 @@ dvmJitToInterpNoChain: /* * No translation, restore interpreter regs and start interpreting. - * rGLUE & rFP were preserved in the translated code, and rPC has + * rSELF & rFP were preserved in the translated code, and rPC has * already been restored by the time we get here. We'll need to set * up rIBASE & rINST, and load the address of the JitTable into r0. */ @@ -13920,13 +13904,13 @@ common_updateProfile: * is already a native translation in place (and, if so, * jump to it now). */ + GET_JIT_THRESHOLD(r1) - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self strb r1,[r0,r3,lsr #(32 - JIT_PROF_SIZE_LOG_2)] @ reset counter EXPORT_PC() mov r0,rPC bl dvmJitGetTraceAddr @ r0<- dvmJitGetTraceAddr(rPC) - str r0, [r10, #offThread_inJitCodeCache] @ set the inJitCodeCache flag + str r0, [rSELF, #offThread_inJitCodeCache] @ set the inJitCodeCache flag mov r1, rPC @ arg1 of translation may need this mov lr, #0 @ in case target is HANDLER_INTERPRET cmp r0,#0 @@ -13947,9 +13931,8 @@ common_updateProfile: cmp r0, r10 @ special case? bne jitSVShadowRunStart @ set up self verification shadow space @ Need to clear the inJitCodeCache flag - ldr r10, [rGLUE, #offGlue_self] @ r10 <- glue->self mov r3, #0 @ 0 means not in the JIT code cache - str r3, [r10, #offThread_inJitCodeCache] @ back to the interp land + str r3, [rSELF, #offThread_inJitCodeCache] @ back to the interp land GET_INST_OPCODE(ip) GOTO_OPCODE(ip) /* no return */ @@ -13960,9 +13943,10 @@ common_updateProfile: * r2 is jit state, e.g. kJitTSelectRequest or kJitTSelectRequestHot */ common_selectTrace: - str r2,[rGLUE,#offGlue_jitState] + + str r2,[rSELF,#offThread_jitState] mov r2,#kInterpEntryInstr @ normal entry reason - str r2,[rGLUE,#offGlue_entryPoint] + str r2,[rSELF,#offThread_entryPoint] mov r1,#1 @ set changeInterp b common_gotoBail @@ -13971,36 +13955,35 @@ common_selectTrace: * Save PC and registers to shadow memory for self verification mode * before jumping to native translation. * On entry: - * rPC, rFP, rGLUE: the values that they should contain + * rPC, rFP, rSELF: the values that they should contain * r10: the address of the target translation. */ jitSVShadowRunStart: mov r0,rPC @ r0<- program counter mov r1,rFP @ r1<- frame pointer - mov r2,rGLUE @ r2<- InterpState pointer + mov r2,rSELF @ r2<- self (Thread) pointer mov r3,r10 @ r3<- target translation bl dvmSelfVerificationSaveState @ save registers to shadow space 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 + * Restore PC, registers, and interpreter state to original values * before jumping back to the interpreter. */ jitSVShadowRunEnd: mov r1,rFP @ pass ending fp + mov r3,rSELF @ pass self ptr for convenience bl dvmSelfVerificationRestoreState @ restore pc and fp values - ldr rPC,[r0,#offShadowSpace_startPC] @ restore PC - ldr rFP,[r0,#offShadowSpace_fp] @ restore FP - ldr rGLUE,[r0,#offShadowSpace_glue] @ restore InterpState + ldr rPC,[rSELF,#offThread_pc] @ restore PC + ldr rFP,[rSELF,#offThread_fp] @ restore FP 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 - str r2,[rGLUE,#offGlue_jitState] + str r2,[rSELF,#offThread_jitState] mov r2,#kInterpEntryInstr @ normal entry reason - str r2,[rGLUE,#offGlue_entryPoint] + str r2,[rSELF,#offThread_entryPoint] mov r1,#1 @ set changeInterp b common_gotoBail @@ -14061,12 +14044,11 @@ common_backwardBranch: * r9 is trampoline PC adjustment *in bytes* */ common_periodicChecks: - ldr r1, [rGLUE, #offGlue_pInterpBreak] @ r3<- &interpBreak - /* speculatively load address of thread-specific suspend count */ - ldr r3, [rGLUE, #offGlue_pSelfSuspendCount] @ r3<- &suspendCount +/* TUNING - make this a direct load when interpBreak moved to Thread */ + ldr r1, [rSELF, #offThread_pInterpBreak] @ r3<- &interpBreak + /* speculatively thread-specific suspend count */ + ldr ip, [rSELF, #offThread_suspendCount] ldr r1, [r1] @ r1<- interpBreak - /* speculatively load thread-specific suspend count */ - ldr ip, [r3] @ ip<- suspendCount (int) cmp r1, #0 @ anything unusual? bxeq lr @ return if not /* @@ -14083,13 +14065,13 @@ common_periodicChecks: * Refresh the Jit's cached copy of profile table pointer. This pointer * doubles as the Jit's on/off switch. */ - ldr r3, [rGLUE, #offGlue_ppJitProfTable] @ r3<-&gDvmJit.pJitProfTable - ldr r0, [rGLUE, #offGlue_self] @ r0<- glue->self + ldr r3, [rSELF, #offThread_ppJitProfTable] @ r3<-&gDvmJit.pJitProfTable + mov r0, rSELF @ r0<- self ldr r3, [r3] @ r3 <- pJitProfTable EXPORT_PC() @ need for precise GC - str r3, [rGLUE, #offGlue_pJitProfTable] @ refresh Jit's on/off switch + str r3, [rSELF, #offThread_pJitProfTable] @ refresh Jit's on/off switch #else - ldr r0, [rGLUE, #offGlue_self] @ r0<- glue->self + mov r0, rSELF @ r0<- self EXPORT_PC() @ need for precise GC #endif bl dvmCheckSuspendPending @ do full check, suspend if necessary @@ -14099,7 +14081,8 @@ common_periodicChecks: * Reload the interpBreak flags - they may have changed while we * were suspended. */ - ldr r1, [rGLUE, #offGlue_pInterpBreak] @ r1<- &interpBreak +/* TUNING - direct load when InterpBreak moved to Thread */ + ldr r1, [rSELF, #offThread_pInterpBreak] @ r1<- &interpBreak ldr r1, [r1] @ r1<- interpBreak 3: /* @@ -14113,8 +14096,8 @@ common_periodicChecks: ands r1, #(kSubModeDebuggerActive | kSubModeEmulatorTrace | kSubModeInstCounting) bxeq lr @ nothing to do, return - @ debugger/profiler enabled, bail out; glue->entryPoint was set above - str r0, [rGLUE, #offGlue_entryPoint] @ store r0, need for debug/prof + @ debugger/profiler enabled, bail out; self->entryPoint was set above + str r0, [rSELF, #offThread_entryPoint] @ store r0, need for debug/prof add rPC, rPC, r9 @ update rPC mov r1, #1 @ "want switch" = true b common_gotoBail @ side exit @@ -14123,19 +14106,19 @@ common_periodicChecks: /* * The equivalent of "goto bail", this calls through the "bail handler". * - * State registers will be saved to the "glue" area before bailing. + * State registers will be saved to the "thread" area before bailing. * * On entry: * r1 is "bool changeInterp", indicating if we want to switch to the * other interpreter or just bail all the way out */ common_gotoBail: - SAVE_PC_FP_TO_GLUE() @ export state to "glue" - mov r0, rGLUE @ r0<- glue ptr - b dvmMterpStdBail @ call(glue, changeInterp) + SAVE_PC_FP_TO_SELF() @ export state to "thread" + mov r0, rSELF @ r0<- self ptr + b dvmMterpStdBail @ call(self, changeInterp) @add r1, r1, #1 @ using (boolean+1) - @add r0, rGLUE, #offGlue_jmpBuf @ r0<- &glue->jmpBuf + @add r0, rSELF, #offThread_jmpBuf @ r0<- &self->jmpBuf @bl _longjmp @ does not return @bl common_abort @@ -14237,10 +14220,10 @@ common_invokeMethodNoRange: sub r1, r1, r9, lsl #2 @ r1<- newFp (old savearea - regsSize) SAVEAREA_FROM_FP(r10, r1) @ r10<- newSaveArea @ bl common_dumpRegs - ldr r9, [rGLUE, #offGlue_interpStackEnd] @ r9<- interpStackEnd + ldr r9, [rSELF, #offThread_interpStackEnd] @ r9<- interpStackEnd sub r3, r10, r3, lsl #2 @ r3<- bottom (newsave - outsSize) cmp r3, r9 @ bottom < interpStackEnd? - ldr lr, [rGLUE, #offGlue_pInterpBreak] + ldr lr, [rSELF, #offThread_pInterpBreak] ldr r3, [r0, #offMethod_accessFlags] @ r3<- methodToCall->accessFlags blo .LstackOverflow @ yes, this frame will overflow stack @@ -14260,7 +14243,7 @@ common_invokeMethodNoRange: beq 1f @ skip if not stmfd sp!, {r0-r3} @ preserve r0-r3 mov r1, r6 - @ r0=methodToCall, r1=rGlue + @ r0=methodToCall, r1=rSELF bl dvmFastMethodTraceEnter ldmfd sp!, {r0-r3} @ restore r0-r3 1: @@ -14286,18 +14269,17 @@ common_invokeMethodNoRange: ldrh r9, [r2] @ r9 <- load INST from new PC ldr r3, [rINST, #offClassObject_pDvmDex] @ r3<- method->clazz->pDvmDex mov rPC, r2 @ publish new rPC - ldr r2, [rGLUE, #offGlue_self] @ r2<- glue->self - @ Update "glue" values for the new method - @ r0=methodToCall, r1=newFp, r2=self, r3=newMethodClass, r9=newINST - str r0, [rGLUE, #offGlue_method] @ glue->method = methodToCall - str r3, [rGLUE, #offGlue_methodClassDex] @ glue->methodClassDex = ... + @ Update state values for the new method + @ r0=methodToCall, r1=newFp, r3=newMethodClass, r9=newINST + str r0, [rSELF, #offThread_method] @ self->method = methodToCall + str r3, [rSELF, #offThread_methodClassDex] @ self->methodClassDex = ... #if defined(WITH_JIT) GET_JIT_PROF_TABLE(r0) mov rFP, r1 @ fp = newFp GET_PREFETCHED_OPCODE(ip, r9) @ extract prefetched opcode from r9 mov rINST, r9 @ publish new rINST - str r1, [r2, #offThread_curFrame] @ self->curFrame = newFp + str r1, [rSELF, #offThread_curFrame] @ self->curFrame = newFp cmp r0,#0 bne common_updateProfile GOTO_OPCODE(ip) @ jump to next instruction @@ -14305,24 +14287,23 @@ common_invokeMethodNoRange: mov rFP, r1 @ fp = newFp GET_PREFETCHED_OPCODE(ip, r9) @ extract prefetched opcode from r9 mov rINST, r9 @ publish new rINST - str r1, [r2, #offThread_curFrame] @ self->curFrame = newFp + str r1, [rSELF, #offThread_curFrame] @ self->curFrame = newFp GOTO_OPCODE(ip) @ jump to next instruction #endif .LinvokeNative: @ Prep for the native call @ r0=methodToCall, r1=newFp, r10=newSaveArea - ldr r3, [rGLUE, #offGlue_self] @ r3<- glue->self - ldr lr, [rGLUE, #offGlue_pInterpBreak] - ldr r9, [r3, #offThread_jniLocal_topCookie] @ r9<- thread->localRef->... - str r1, [r3, #offThread_curFrame] @ self->curFrame = newFp + ldr lr, [rSELF, #offThread_pInterpBreak] + ldr r9, [rSELF, #offThread_jniLocal_topCookie]@r9<-thread->localRef->... + str r1, [rSELF, #offThread_curFrame] @ self->curFrame = newFp str r9, [r10, #offStackSaveArea_localRefCookie] @newFp->localRefCookie=top ldr lr, [lr] @ lr<- active submodes - mov r9, r3 @ r9<- glue->self (preserve) mov r2, r0 @ r2<- methodToCall mov r0, r1 @ r0<- newFp (points to args) - add r1, rGLUE, #offGlue_retval @ r1<- &retval + add r1, rSELF, #offThread_retval @ r1<- &retval + mov r3, rSELF @ arg3<- self #ifdef ASSIST_DEBUGGER /* insert fake function header to help gdb find the stack frame */ @@ -14337,13 +14318,13 @@ dalvik_mterp: ands lr, #kSubModeMethodTrace @ method tracing? beq 110f @ hop if not - @ r2=JNIMethod, r6=rGLUE + @ r2=JNIMethod, r6=rSELF stmfd sp!, {r2,r6} mov lr, pc @ set return addr ldr pc, [r2, #offMethod_nativeFunc] @ pc<- methodToCall->nativeFunc - @ r0=JNIMethod, r1=rGLUE + @ r0=JNIMethod, r1=rSELF ldmfd sp!, {r0-r1} bl dvmFastNativeMethodTraceExit b 220f @@ -14352,21 +14333,21 @@ dalvik_mterp: ldr pc, [r2, #offMethod_nativeFunc] @ pc<- methodToCall->nativeFunc 220: #if defined(WITH_JIT) - ldr r3, [rGLUE, #offGlue_ppJitProfTable] @ Refresh Jit's on/off status + ldr r3, [rSELF, #offThread_ppJitProfTable] @ Refresh Jit's on/off status #endif - @ native return; r9=self, r10=newSaveArea + @ native return; r10=newSaveArea @ equivalent to dvmPopJniLocals ldr r0, [r10, #offStackSaveArea_localRefCookie] @ r0<- saved top - ldr r1, [r9, #offThread_exception] @ check for exception + ldr r1, [rSELF, #offThread_exception] @ check for exception #if defined(WITH_JIT) ldr r3, [r3] @ r3 <- gDvmJit.pProfTable #endif - str rFP, [r9, #offThread_curFrame] @ self->curFrame = fp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = fp cmp r1, #0 @ null? - str r0, [r9, #offThread_jniLocal_topCookie] @ new top <- old top + str r0, [rSELF, #offThread_jniLocal_topCookie] @ new top <- old top #if defined(WITH_JIT) - str r3, [rGLUE, #offGlue_pJitProfTable] @ refresh cached on/off switch + str r3, [rSELF, #offThread_pJitProfTable] @ refresh cached on/off switch #endif bne common_exceptionThrown @ no, handle exception @@ -14376,7 +14357,7 @@ dalvik_mterp: .LstackOverflow: @ r0=methodToCall mov r1, r0 @ r1<- methodToCall - ldr r0, [rGLUE, #offGlue_self] @ r0<- self + mov r0, rSELF @ r0<- self bl dvmHandleStackOverflow b common_exceptionThrown #ifdef ASSIST_DEBUGGER @@ -14401,8 +14382,8 @@ dalvik_mterp: sub sp, sp, #8 @ space for args + pad FETCH(ip, 2) @ ip<- FEDC or CCCC mov r2, r0 @ A2<- methodToCall - mov r0, rGLUE @ A0<- glue - SAVE_PC_FP_TO_GLUE() @ export state to "glue" + mov r0, rSELF @ A0<- self + SAVE_PC_FP_TO_SELF() @ export state to "self" mov r1, r9 @ A1<- methodCallRange mov r3, rINST, lsr #8 @ A3<- AA str ip, [sp, #0] @ A4<- ip @@ -14424,7 +14405,7 @@ common_returnFromMethod: mov r9, #0 bl common_periodicChecks - ldr lr, [rGLUE, #offGlue_pInterpBreak] + ldr lr, [rSELF, #offThread_pInterpBreak] SAVEAREA_FROM_FP(r0, rFP) ldr lr, [lr] @ lr<- active submodes ldr r9, [r0, #offStackSaveArea_savedPc] @ r9 = saveArea->savedPc @@ -14432,12 +14413,11 @@ common_returnFromMethod: beq 333f stmfd sp!, {r0-r3} @ preserve r0-r3 mov r0, r6 - @ r0=rGlue + @ r0=rSELF bl dvmFastJavaMethodTraceExit ldmfd sp!, {r0-r3} @ restore r0-r3 333: ldr rFP, [r0, #offStackSaveArea_prevFrame] @ fp = saveArea->prevFrame - ldr r3, [rGLUE, #offGlue_self] @ r3<- glue->self ldr r2, [rFP, #(offStackSaveArea_method - sizeofStackSaveArea)] @ r2<- method we're returning to cmp r2, #0 @ is this a break frame? @@ -14453,14 +14433,14 @@ common_returnFromMethod: beq common_gotoBail @ break frame, bail out completely PREFETCH_ADVANCE_INST(rINST, r9, 3) @ advance r9, update new rINST - str r2, [rGLUE, #offGlue_method]@ glue->method = newSave->method + str r2, [rSELF, #offThread_method]@ self->method = newSave->method ldr r1, [r10, #offClassObject_pDvmDex] @ r1<- method->clazz->pDvmDex - str rFP, [r3, #offThread_curFrame] @ self->curFrame = fp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = fp #if defined(WITH_JIT) ldr r10, [r0, #offStackSaveArea_returnAddr] @ r10 = saveArea->returnAddr mov rPC, r9 @ publish new rPC - str r1, [rGLUE, #offGlue_methodClassDex] - str r10, [r3, #offThread_inJitCodeCache] @ may return to JIT'ed land + str r1, [rSELF, #offThread_methodClassDex] + str r10, [rSELF, #offThread_inJitCodeCache] @ may return to JIT'ed land cmp r10, #0 @ caller is compiled code blxne r10 GET_INST_OPCODE(ip) @ extract opcode from rINST @@ -14468,7 +14448,7 @@ common_returnFromMethod: #else GET_INST_OPCODE(ip) @ extract opcode from rINST mov rPC, r9 @ publish new rPC - str r1, [rGLUE, #offGlue_methodClassDex] + str r1, [rSELF, #offThread_methodClassDex] GOTO_OPCODE(ip) @ jump to next instruction #endif @@ -14477,8 +14457,8 @@ common_returnFromMethod: */ .if 0 .LreturnOld: - SAVE_PC_FP_TO_GLUE() @ export state - mov r0, rGLUE @ arg to function + SAVE_PC_FP_TO_SELF() @ export state + mov r0, rSELF @ arg to function bl dvmMterp_returnFromMethod b common_resumeAfterGlueCall .endif @@ -14501,13 +14481,12 @@ common_exceptionThrown: mov r9, #0 bl common_periodicChecks - ldr r10, [rGLUE, #offGlue_self] @ r10<- glue->self - ldr r9, [r10, #offThread_exception] @ r9<- self->exception - mov r1, r10 @ r1<- self + ldr r9, [rSELF, #offThread_exception] @ r9<- self->exception + mov r1, rSELF @ r1<- self mov r0, r9 @ r0<- exception bl dvmAddTrackedAlloc @ don't let the exception be GCed mov r3, #0 @ r3<- NULL - str r3, [r10, #offThread_exception] @ self->exception = NULL + str r3, [rSELF, #offThread_exception] @ self->exception = NULL /* set up args and a local for "&fp" */ /* (str sp, [sp, #-4]! would be perfect here, but is discouraged) */ @@ -14515,8 +14494,8 @@ common_exceptionThrown: mov ip, sp @ ip<- &fp mov r3, #0 @ r3<- false str ip, [sp, #-4]! @ *--sp = &fp - ldr r1, [rGLUE, #offGlue_method] @ r1<- glue->method - mov r0, r10 @ r0<- self + ldr r1, [rSELF, #offThread_method] @ r1<- self->method + mov r0, rSELF @ r0<- self ldr r1, [r1, #offMethod_insns] @ r1<- method->insns mov r2, r9 @ r2<- exception sub r1, rPC, r1 @ r1<- pc - method->insns @@ -14526,11 +14505,11 @@ common_exceptionThrown: bl dvmFindCatchBlock @ call(self, relPc, exc, scan?, &fp) /* fix earlier stack overflow if necessary; may trash rFP */ - ldrb r1, [r10, #offThread_stackOverflowed] + ldrb r1, [rSELF, #offThread_stackOverflowed] cmp r1, #0 @ did we overflow earlier? beq 1f @ no, skip ahead mov rFP, r0 @ save relPc result in rFP - mov r0, r10 @ r0<- self + mov r0, rSELF @ r0<- self mov r1, r9 @ r1<- exception bl dvmCleanupStackOverflow @ call(self) mov r0, rFP @ restore result @@ -14545,30 +14524,30 @@ common_exceptionThrown: /* adjust locals to match self->curFrame and updated PC */ SAVEAREA_FROM_FP(r1, rFP) @ r1<- new save area ldr r1, [r1, #offStackSaveArea_method] @ r1<- new method - str r1, [rGLUE, #offGlue_method] @ glue->method = new method + str r1, [rSELF, #offThread_method] @ self->method = new method ldr r2, [r1, #offMethod_clazz] @ r2<- method->clazz ldr r3, [r1, #offMethod_insns] @ r3<- method->insns ldr r2, [r2, #offClassObject_pDvmDex] @ r2<- method->clazz->pDvmDex add rPC, r3, r0, asl #1 @ rPC<- method->insns + catchRelPc - str r2, [rGLUE, #offGlue_methodClassDex] @ glue->pDvmDex = meth... + str r2, [rSELF, #offThread_methodClassDex] @ self->pDvmDex = meth... /* release the tracked alloc on the exception */ mov r0, r9 @ r0<- exception - mov r1, r10 @ r1<- self + mov r1, rSELF @ r1<- self bl dvmReleaseTrackedAlloc @ release the exception /* restore the exception if the handler wants it */ FETCH_INST() @ load rINST from rPC GET_INST_OPCODE(ip) @ extract opcode from rINST cmp ip, #OP_MOVE_EXCEPTION @ is it "move-exception"? - streq r9, [r10, #offThread_exception] @ yes, restore the exception + streq r9, [rSELF, #offThread_exception] @ yes, restore the exception GOTO_OPCODE(ip) @ jump to next instruction -.LnotCaughtLocally: @ r9=exception, r10=self +.LnotCaughtLocally: @ r9=exception /* fix stack overflow if necessary */ - ldrb r1, [r10, #offThread_stackOverflowed] + ldrb r1, [rSELF, #offThread_stackOverflowed] cmp r1, #0 @ did we overflow earlier? - movne r0, r10 @ if yes: r0<- self + movne r0, rSELF @ if yes: r0<- self movne r1, r9 @ if yes: r1<- exception blne dvmCleanupStackOverflow @ if yes: call(self) @@ -14577,14 +14556,14 @@ common_exceptionThrown: /* call __android_log_print(prio, tag, format, ...) */ /* "Exception %s from %s:%d not caught locally" */ @ dvmLineNumFromPC(method, pc - method->insns) - ldr r0, [rGLUE, #offGlue_method] + ldr r0, [rSELF, #offThread_method] ldr r1, [r0, #offMethod_insns] sub r1, rPC, r1 asr r1, r1, #1 bl dvmLineNumFromPC str r0, [sp, #-4]! @ dvmGetMethodSourceFile(method) - ldr r0, [rGLUE, #offGlue_method] + ldr r0, [rSELF, #offThread_method] bl dvmGetMethodSourceFile str r0, [sp, #-4]! @ exception->clazz->descriptor @@ -14596,9 +14575,9 @@ common_exceptionThrown: mov r0, #3 @ LOG_DEBUG bl __android_log_print #endif - str r9, [r10, #offThread_exception] @ restore exception + str r9, [rSELF, #offThread_exception] @ restore exception mov r0, r9 @ r0<- exception - mov r1, r10 @ r1<- self + mov r1, rSELF @ r1<- self bl dvmReleaseTrackedAlloc @ release the exception mov r1, #0 @ "want switch" = false b common_gotoBail @ bail out @@ -14609,8 +14588,8 @@ common_exceptionThrown: */ .if 0 .LexceptionOld: - SAVE_PC_FP_TO_GLUE() @ export state - mov r0, rGLUE @ arg to function + SAVE_PC_FP_TO_SELF() @ export state + mov r0, rSELF @ arg to function bl dvmMterp_exceptionThrown b common_resumeAfterGlueCall .endif @@ -14621,7 +14600,7 @@ common_exceptionThrown: * values and start executing at the next instruction. */ common_resumeAfterGlueCall: - LOAD_PC_FP_FROM_GLUE() @ pull rPC and rFP out of glue + LOAD_PC_FP_FROM_SELF() @ pull rPC and rFP out of thread FETCH_INST() @ load rINST from rPC GET_INST_OPCODE(ip) @ extract opcode from rINST GOTO_OPCODE(ip) @ jump to next instruction diff --git a/vm/mterp/out/InterpAsm-armv7-a-neon.S b/vm/mterp/out/InterpAsm-armv7-a-neon.S index 3ae8c21c9..7a6e19c50 100644 --- a/vm/mterp/out/InterpAsm-armv7-a-neon.S +++ b/vm/mterp/out/InterpAsm-armv7-a-neon.S @@ -63,7 +63,7 @@ The following registers have fixed assignments: reg nick purpose r4 rPC interpreted program counter, used for fetching instructions r5 rFP interpreted frame pointer, used for accessing locals and args - r6 rGLUE MterpGlue pointer + r6 rSELF self (Thread) pointer r7 rINST first 16-bit code unit of current instruction r8 rIBASE interpreted instruction base pointer, used for computed goto @@ -75,17 +75,17 @@ unspecified registers or condition codes. /* single-purpose registers, given names for clarity */ #define rPC r4 #define rFP r5 -#define rGLUE r6 +#define rSELF r6 #define rINST r7 #define rIBASE r8 -/* save/restore the PC and/or FP from the glue struct */ -#define LOAD_PC_FROM_GLUE() ldr rPC, [rGLUE, #offGlue_pc] -#define SAVE_PC_TO_GLUE() str rPC, [rGLUE, #offGlue_pc] -#define LOAD_FP_FROM_GLUE() ldr rFP, [rGLUE, #offGlue_fp] -#define SAVE_FP_TO_GLUE() str rFP, [rGLUE, #offGlue_fp] -#define LOAD_PC_FP_FROM_GLUE() ldmia rGLUE, {rPC, rFP} -#define SAVE_PC_FP_TO_GLUE() stmia rGLUE, {rPC, rFP} +/* save/restore the PC and/or FP from the thread struct */ +#define LOAD_PC_FROM_SELF() ldr rPC, [rSELF, #offThread_pc] +#define SAVE_PC_TO_SELF() str rPC, [rSELF, #offThread_pc] +#define LOAD_FP_FROM_SELF() ldr rFP, [rSELF, #offThread_fp] +#define SAVE_FP_TO_SELF() str rFP, [rSELF, #offThread_fp] +#define LOAD_PC_FP_FROM_SELF() ldmia rSELF, {rPC, rFP} +#define SAVE_PC_FP_TO_SELF() stmia rSELF, {rPC, rFP} /* * "export" the PC to the stack frame, f/b/o future exception objects. Must @@ -186,8 +186,8 @@ unspecified registers or condition codes. #define SET_VREG(_reg, _vreg) str _reg, [rFP, _vreg, lsl #2] #if defined(WITH_JIT) -#define GET_JIT_PROF_TABLE(_reg) ldr _reg,[rGLUE,#offGlue_pJitProfTable] -#define GET_JIT_THRESHOLD(_reg) ldr _reg,[rGLUE,#offGlue_jitThreshold] +#define GET_JIT_PROF_TABLE(_reg) ldr _reg,[rSELF,#offThread_pJitProfTable] +#define GET_JIT_THRESHOLD(_reg) ldr _reg,[rSELF,#offThread_jitThreshold] #endif /* @@ -280,7 +280,7 @@ unspecified registers or condition codes. /* * On entry: - * r0 MterpGlue* glue + * r0 Thread* self * * This function returns a boolean "changeInterp" value. The return comes * via a call to dvmMterpStdBail(). @@ -298,29 +298,28 @@ dvmMterpStdRun: MTERP_ENTRY2 /* save stack pointer, add magic word for debuggerd */ - str sp, [r0, #offGlue_bailPtr] @ save SP for eventual return + str sp, [r0, #offThread_bailPtr] @ save SP for eventual return /* set up "named" registers, figure out entry point */ - mov rGLUE, r0 @ set rGLUE - ldr r1, [r0, #offGlue_entryPoint] @ enum is 4 bytes in aapcs-EABI - LOAD_PC_FP_FROM_GLUE() @ load rPC and rFP from "glue" + mov rSELF, r0 @ set rSELF + ldr r1, [r0, #offThread_entryPoint] @ enum is 4 bytes in aapcs-EABI + LOAD_PC_FP_FROM_SELF() @ load rPC and rFP from "thread" adr rIBASE, dvmAsmInstructionStart @ set rIBASE cmp r1, #kInterpEntryInstr @ usual case? bne .Lnot_instr @ no, handle it #if defined(WITH_JIT) .LentryInstr: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self /* Entry is always a possible trace start */ GET_JIT_PROF_TABLE(r0) FETCH_INST() mov r1, #0 @ prepare the value for the new state - str r1, [r10, #offThread_inJitCodeCache] @ back to the interp land + str r1, [rSELF, #offThread_inJitCodeCache] @ back to the interp land cmp r0,#0 @ is profiling disabled? #if !defined(WITH_SELF_VERIFICATION) bne common_updateProfile @ profiling is enabled #else - ldr r2, [r10, #offThread_shadowSpace] @ to find out the jit exit state + ldr r2, [rSELF, #offThread_shadowSpace] @ to find out the jit exit state beq 1f @ profiling is disabled ldr r3, [r2, #offShadowSpace_jitExitState] @ jit exit state cmp r3, #kSVSTraceSelect @ hot trace following? @@ -350,20 +349,20 @@ dvmMterpStdRun: #if defined(WITH_JIT) .Lnot_throw: - ldr r10,[rGLUE, #offGlue_jitResumeNPC] - ldr r2,[rGLUE, #offGlue_jitResumeDPC] + ldr r10,[rSELF, #offThread_jitResumeNPC] + ldr r2,[rSELF, #offThread_jitResumeDPC] cmp r1, #kInterpEntryResume @ resuming after Jit single-step? bne .Lbad_arg cmp rPC,r2 bne .LentryInstr @ must have branched, don't resume #if defined(WITH_SELF_VERIFICATION) - @ glue->entryPoint will be set in dvmSelfVerificationSaveState + @ self->entryPoint will be set in dvmSelfVerificationSaveState b jitSVShadowRunStart @ re-enter the translation after the @ single-stepped instruction @noreturn #endif mov r1, #kInterpEntryInstr - str r1, [rGLUE, #offGlue_entryPoint] + str r1, [rSELF, #offThread_entryPoint] bx r10 @ re-enter the translation #endif @@ -389,11 +388,11 @@ dvmMterpStdRun: * LR to PC. * * On entry: - * r0 MterpGlue* glue + * r0 Thread* self * r1 bool changeInterp */ dvmMterpStdBail: - ldr sp, [r0, #offGlue_bailPtr] @ sp<- saved SP + ldr sp, [r0, #offThread_bailPtr] @ sp<- saved SP mov r0, r1 @ return the changeInterp value add sp, sp, #4 @ un-align 64 ldmfd sp!, {r4-r10,fp,pc} @ restore 9 regs and return @@ -576,7 +575,7 @@ dalvik_inst: /* op vAA */ mov r2, rINST, lsr #8 @ r2<- AA FETCH_ADVANCE_INST(1) @ advance rPC, load rINST - ldr r0, [rGLUE, #offGlue_retval] @ r0<- glue->retval.i + ldr r0, [rSELF, #offThread_retval] @ r0<- self->retval.i GET_INST_OPCODE(ip) @ extract opcode from rINST SET_VREG(r0, r2) @ fp[AA]<- r0 GOTO_OPCODE(ip) @ jump to next instruction @@ -587,7 +586,7 @@ dalvik_inst: /* File: armv5te/OP_MOVE_RESULT_WIDE.S */ /* move-result-wide vAA */ mov r2, rINST, lsr #8 @ r2<- AA - add r3, rGLUE, #offGlue_retval @ r3<- &glue->retval + add r3, rSELF, #offThread_retval @ r3<- &self->retval add r2, rFP, r2, lsl #2 @ r2<- &fp[AA] ldmia r3, {r0-r1} @ r0/r1<- retval.j FETCH_ADVANCE_INST(1) @ advance rPC, load rINST @@ -604,7 +603,7 @@ dalvik_inst: /* op vAA */ mov r2, rINST, lsr #8 @ r2<- AA FETCH_ADVANCE_INST(1) @ advance rPC, load rINST - ldr r0, [rGLUE, #offGlue_retval] @ r0<- glue->retval.i + ldr r0, [rSELF, #offThread_retval] @ r0<- self->retval.i GET_INST_OPCODE(ip) @ extract opcode from rINST SET_VREG(r0, r2) @ fp[AA]<- r0 GOTO_OPCODE(ip) @ jump to next instruction @@ -615,14 +614,13 @@ dalvik_inst: .L_OP_MOVE_EXCEPTION: /* 0x0d */ /* File: armv5te/OP_MOVE_EXCEPTION.S */ /* move-exception vAA */ - ldr r0, [rGLUE, #offGlue_self] @ r0<- glue->self mov r2, rINST, lsr #8 @ r2<- AA - ldr r3, [r0, #offThread_exception] @ r3<- dvmGetException bypass + ldr r3, [rSELF, #offThread_exception] @ r3<- dvmGetException bypass mov r1, #0 @ r1<- 0 FETCH_ADVANCE_INST(1) @ advance rPC, load rINST SET_VREG(r3, r2) @ fp[AA]<- exception obj GET_INST_OPCODE(ip) @ extract opcode from rINST - str r1, [r0, #offThread_exception] @ dvmClearException bypass + str r1, [rSELF, #offThread_exception] @ dvmClearException bypass GOTO_OPCODE(ip) @ jump to next instruction /* ------------------------------ */ @@ -636,7 +634,7 @@ dalvik_inst: .L_OP_RETURN: /* 0x0f */ /* File: armv5te/OP_RETURN.S */ /* - * Return a 32-bit value. Copies the return value into the "glue" + * Return a 32-bit value. Copies the return value into the "thread" * structure, then jumps to the return handler. * * for: return, return-object @@ -644,7 +642,7 @@ dalvik_inst: /* op vAA */ mov r2, rINST, lsr #8 @ r2<- AA GET_VREG(r0, r2) @ r0<- vAA - str r0, [rGLUE, #offGlue_retval] @ retval.i <- vAA + str r0, [rSELF, #offThread_retval] @ retval.i <- vAA b common_returnFromMethod /* ------------------------------ */ @@ -652,13 +650,13 @@ dalvik_inst: .L_OP_RETURN_WIDE: /* 0x10 */ /* File: armv5te/OP_RETURN_WIDE.S */ /* - * Return a 64-bit value. Copies the return value into the "glue" + * Return a 64-bit value. Copies the return value into the "thread" * structure, then jumps to the return handler. */ /* return-wide vAA */ mov r2, rINST, lsr #8 @ r2<- AA add r2, rFP, r2, lsl #2 @ r2<- &fp[AA] - add r3, rGLUE, #offGlue_retval @ r3<- &glue->retval + add r3, rSELF, #offThread_retval @ r3<- &self->retval ldmia r2, {r0-r1} @ r0/r1 <- vAA/vAA+1 stmia r3, {r0-r1} @ retval<- r0/r1 b common_returnFromMethod @@ -669,7 +667,7 @@ dalvik_inst: /* File: armv5te/OP_RETURN_OBJECT.S */ /* File: armv5te/OP_RETURN.S */ /* - * Return a 32-bit value. Copies the return value into the "glue" + * Return a 32-bit value. Copies the return value into the "thread" * structure, then jumps to the return handler. * * for: return, return-object @@ -677,7 +675,7 @@ dalvik_inst: /* op vAA */ mov r2, rINST, lsr #8 @ r2<- AA GET_VREG(r0, r2) @ r0<- vAA - str r0, [rGLUE, #offGlue_retval] @ retval.i <- vAA + str r0, [rSELF, #offThread_retval] @ retval.i <- vAA b common_returnFromMethod @@ -802,7 +800,7 @@ dalvik_inst: /* File: armv5te/OP_CONST_STRING.S */ /* const/string vAA, String@BBBB */ FETCH(r1, 1) @ r1<- BBBB - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- glue->methodClassDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- self->methodClassDex mov r9, rINST, lsr #8 @ r9<- AA ldr r2, [r2, #offDvmDex_pResStrings] @ r2<- dvmDex->pResStrings ldr r0, [r2, r1, lsl #2] @ r0<- pResStrings[BBBB] @@ -820,7 +818,7 @@ dalvik_inst: /* const/string vAA, String@BBBBBBBB */ FETCH(r0, 1) @ r0<- bbbb (low) FETCH(r1, 2) @ r1<- BBBB (high) - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- glue->methodClassDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- self->methodClassDex mov r9, rINST, lsr #8 @ r9<- AA ldr r2, [r2, #offDvmDex_pResStrings] @ r2<- dvmDex->pResStrings orr r1, r0, r1, lsl #16 @ r1<- BBBBbbbb @@ -838,7 +836,7 @@ dalvik_inst: /* File: armv5te/OP_CONST_CLASS.S */ /* const/class vAA, Class@BBBB */ FETCH(r1, 1) @ r1<- BBBB - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- glue->methodClassDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- self->methodClassDex mov r9, rINST, lsr #8 @ r9<- AA ldr r2, [r2, #offDvmDex_pResClasses] @ r2<- dvmDex->pResClasses ldr r0, [r2, r1, lsl #2] @ r0<- pResClasses[BBBB] @@ -859,7 +857,7 @@ dalvik_inst: /* monitor-enter vAA */ mov r2, rINST, lsr #8 @ r2<- AA GET_VREG(r1, r2) @ r1<- vAA (object) - ldr r0, [rGLUE, #offGlue_self] @ r0<- glue->self + mov r0, rSELF @ r0<- self cmp r1, #0 @ null object? EXPORT_PC() @ need for precise GC beq common_errNullObject @ null object, throw an exception @@ -885,7 +883,7 @@ dalvik_inst: GET_VREG(r1, r2) @ r1<- vAA (object) cmp r1, #0 @ null object? beq 1f @ yes - ldr r0, [rGLUE, #offGlue_self] @ r0<- glue->self + mov r0, rSELF @ r0<- self bl dvmUnlockObject @ r0<- success for unlock(self, obj) cmp r0, #0 @ failed? FETCH_ADVANCE_INST(1) @ before throw: advance rPC, load rINST @@ -907,7 +905,7 @@ dalvik_inst: mov r3, rINST, lsr #8 @ r3<- AA FETCH(r2, 1) @ r2<- BBBB GET_VREG(r9, r3) @ r9<- object - ldr r0, [rGLUE, #offGlue_methodClassDex] @ r0<- pDvmDex + ldr r0, [rSELF, #offThread_methodClassDex] @ r0<- pDvmDex cmp r9, #0 @ is object null? ldr r0, [r0, #offDvmDex_pResClasses] @ r0<- pDvmDex->pResClasses beq .LOP_CHECK_CAST_okay @ null obj, cast always succeeds @@ -939,7 +937,7 @@ dalvik_inst: GET_VREG(r0, r3) @ r0<- vB (object) and r9, r9, #15 @ r9<- A cmp r0, #0 @ is object null? - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- pDvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- pDvmDex beq .LOP_INSTANCE_OF_store @ null obj, not an instance, store r0 FETCH(r3, 1) @ r3<- CCCC ldr r2, [r2, #offDvmDex_pResClasses] @ r2<- pDvmDex->pResClasses @@ -978,7 +976,7 @@ dalvik_inst: * Create a new instance of a class. */ /* new-instance vAA, class@BBBB */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r1, 1) @ r1<- BBBB ldr r3, [r3, #offDvmDex_pResClasses] @ r3<- pDvmDex->pResClasses ldr r0, [r3, r1, lsl #2] @ r0<- resolved class @@ -1008,7 +1006,7 @@ dalvik_inst: /* new-array vA, vB, class@CCCC */ mov r0, rINST, lsr #12 @ r0<- B FETCH(r2, 1) @ r2<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex GET_VREG(r1, r0) @ r1<- vB (array length) ldr r3, [r3, #offDvmDex_pResClasses] @ r3<- pDvmDex->pResClasses cmp r1, #0 @ check length @@ -1030,7 +1028,7 @@ dalvik_inst: */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op {vCCCC..v(CCCC+AA-1)}, type@BBBB */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r1, 1) @ r1<- BBBB ldr r3, [r3, #offDvmDex_pResClasses] @ r3<- pDvmDex->pResClasses EXPORT_PC() @ need for resolve and alloc @@ -1038,7 +1036,7 @@ dalvik_inst: mov r10, rINST, lsr #8 @ r10<- AA or BA cmp r0, #0 @ already resolved? bne .LOP_FILLED_NEW_ARRAY_continue @ yes, continue on -8: ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method +8: ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r2, #0 @ r2<- false ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveClass @ r0<- call(clazz, ref) @@ -1058,7 +1056,7 @@ dalvik_inst: */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op {vCCCC..v(CCCC+AA-1)}, type@BBBB */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r1, 1) @ r1<- BBBB ldr r3, [r3, #offDvmDex_pResClasses] @ r3<- pDvmDex->pResClasses EXPORT_PC() @ need for resolve and alloc @@ -1066,7 +1064,7 @@ dalvik_inst: mov r10, rINST, lsr #8 @ r10<- AA or BA cmp r0, #0 @ already resolved? bne .LOP_FILLED_NEW_ARRAY_RANGE_continue @ yes, continue on -8: ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method +8: ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r2, #0 @ r2<- false ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveClass @ r0<- call(clazz, ref) @@ -1104,12 +1102,11 @@ dalvik_inst: /* throw vAA */ mov r2, rINST, lsr #8 @ r2<- AA GET_VREG(r1, r2) @ r1<- vAA (exception object) - ldr r0, [rGLUE, #offGlue_self] @ r0<- glue->self EXPORT_PC() @ exception handler can throw cmp r1, #0 @ null object? beq common_errNullObject @ yes, throw an NPE instead @ bypass dvmSetException, just store it - str r1, [r0, #offThread_exception] @ thread->exception<- obj + str r1, [rSELF, #offThread_exception] @ thread->exception<- obj b common_exceptionThrown /* ------------------------------ */ @@ -2387,14 +2384,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2411,14 +2408,14 @@ dalvik_inst: */ /* iget-wide vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_WIDE_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2438,14 +2435,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_OBJECT_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2467,14 +2464,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_BOOLEAN_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2496,14 +2493,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_BYTE_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2525,14 +2522,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_CHAR_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2554,14 +2551,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_SHORT_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2581,14 +2578,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2602,14 +2599,14 @@ dalvik_inst: /* File: armv6t2/OP_IPUT_WIDE.S */ /* iput-wide vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_WIDE_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2628,14 +2625,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_OBJECT_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2656,14 +2653,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_BOOLEAN_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2685,14 +2682,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_BYTE_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2714,14 +2711,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_CHAR_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2743,14 +2740,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_SHORT_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2769,7 +2766,7 @@ dalvik_inst: * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -2792,7 +2789,7 @@ dalvik_inst: * 64-bit SGET handler. */ /* sget-wide vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -2823,7 +2820,7 @@ dalvik_inst: * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -2850,7 +2847,7 @@ dalvik_inst: * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -2877,7 +2874,7 @@ dalvik_inst: * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -2904,7 +2901,7 @@ dalvik_inst: * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -2931,7 +2928,7 @@ dalvik_inst: * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -2957,7 +2954,7 @@ dalvik_inst: * for: sput, sput-boolean, sput-byte, sput-char, sput-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -2980,7 +2977,7 @@ dalvik_inst: * 64-bit SPUT handler. */ /* sput-wide vAA, field@BBBB */ - ldr r0, [rGLUE, #offGlue_methodClassDex] @ r0<- DvmDex + ldr r0, [rSELF, #offThread_methodClassDex] @ r0<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r0, [r0, #offDvmDex_pResFields] @ r0<- dvmDex->pResFields mov r9, rINST, lsr #8 @ r9<- AA @@ -3010,13 +3007,13 @@ dalvik_inst: * for: sput-object, sput-object-volatile */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_SPUT_OBJECT_finish @ no, continue - ldr r9, [rGLUE, #offGlue_method] @ r9<- current method + ldr r9, [rSELF, #offThread_method] @ r9<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r9, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -3036,7 +3033,7 @@ dalvik_inst: * for: sput, sput-boolean, sput-byte, sput-char, sput-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -3063,7 +3060,7 @@ dalvik_inst: * for: sput, sput-boolean, sput-byte, sput-char, sput-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -3090,7 +3087,7 @@ dalvik_inst: * for: sput, sput-boolean, sput-byte, sput-char, sput-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -3117,7 +3114,7 @@ dalvik_inst: * for: sput, sput-boolean, sput-byte, sput-char, sput-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -3144,7 +3141,7 @@ dalvik_inst: */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r1, 1) @ r1<- BBBB ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods FETCH(r10, 2) @ r10<- GFED or CCCC @@ -3155,7 +3152,7 @@ dalvik_inst: cmp r0, #0 @ already resolved? EXPORT_PC() @ must export for invoke bne .LOP_INVOKE_VIRTUAL_continue @ yes, continue on - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_VIRTUAL @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) @@ -3175,7 +3172,7 @@ dalvik_inst: /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ FETCH(r10, 2) @ r10<- GFED or CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex .if (!0) and r10, r10, #15 @ r10<- D (or stays CCCC) .endif @@ -3184,7 +3181,7 @@ dalvik_inst: GET_VREG(r2, r10) @ r2<- "this" ptr ldr r0, [r3, r1, lsl #2] @ r0<- resolved baseMethod cmp r2, #0 @ null "this"? - ldr r9, [rGLUE, #offGlue_method] @ r9<- current method + ldr r9, [rSELF, #offThread_method] @ r9<- current method beq common_errNullObject @ null "this", throw exception cmp r0, #0 @ already resolved? ldr r9, [r9, #offMethod_clazz] @ r9<- method->clazz @@ -3208,7 +3205,7 @@ dalvik_inst: */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r1, 1) @ r1<- BBBB ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods FETCH(r10, 2) @ r10<- GFED or CCCC @@ -3236,14 +3233,14 @@ dalvik_inst: */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r1, 1) @ r1<- BBBB ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods ldr r0, [r3, r1, lsl #2] @ r0<- resolved methodToCall cmp r0, #0 @ already resolved? EXPORT_PC() @ must export for invoke bne common_invokeMethodNoRange @ yes, continue on -0: ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method +0: ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_STATIC @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) @@ -3269,9 +3266,9 @@ dalvik_inst: .endif EXPORT_PC() @ must export for invoke GET_VREG(r0, r2) @ r0<- first arg ("this") - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- methodClassDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- methodClassDex cmp r0, #0 @ null obj? - ldr r2, [rGLUE, #offGlue_method] @ r2<- method + ldr r2, [rSELF, #offThread_method] @ r2<- method beq common_errNullObject @ yes, fail ldr r0, [r0, #offObject_clazz] @ r0<- thisPtr->clazz bl dvmFindInterfaceMethodInCache @ r0<- call(class, ref, method, dex) @@ -3299,7 +3296,7 @@ dalvik_inst: */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r1, 1) @ r1<- BBBB ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods FETCH(r10, 2) @ r10<- GFED or CCCC @@ -3310,7 +3307,7 @@ dalvik_inst: cmp r0, #0 @ already resolved? EXPORT_PC() @ must export for invoke bne .LOP_INVOKE_VIRTUAL_RANGE_continue @ yes, continue on - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_VIRTUAL @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) @@ -3332,7 +3329,7 @@ dalvik_inst: /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ FETCH(r10, 2) @ r10<- GFED or CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex .if (!1) and r10, r10, #15 @ r10<- D (or stays CCCC) .endif @@ -3341,7 +3338,7 @@ dalvik_inst: GET_VREG(r2, r10) @ r2<- "this" ptr ldr r0, [r3, r1, lsl #2] @ r0<- resolved baseMethod cmp r2, #0 @ null "this"? - ldr r9, [rGLUE, #offGlue_method] @ r9<- current method + ldr r9, [rSELF, #offThread_method] @ r9<- current method beq common_errNullObject @ null "this", throw exception cmp r0, #0 @ already resolved? ldr r9, [r9, #offMethod_clazz] @ r9<- method->clazz @@ -3367,7 +3364,7 @@ dalvik_inst: */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r1, 1) @ r1<- BBBB ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods FETCH(r10, 2) @ r10<- GFED or CCCC @@ -3397,14 +3394,14 @@ dalvik_inst: */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r1, 1) @ r1<- BBBB ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods ldr r0, [r3, r1, lsl #2] @ r0<- resolved methodToCall cmp r0, #0 @ already resolved? EXPORT_PC() @ must export for invoke bne common_invokeMethodRange @ yes, continue on -0: ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method +0: ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_STATIC @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) @@ -3432,9 +3429,9 @@ dalvik_inst: .endif EXPORT_PC() @ must export for invoke GET_VREG(r0, r2) @ r0<- first arg ("this") - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- methodClassDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- methodClassDex cmp r0, #0 @ null obj? - ldr r2, [rGLUE, #offGlue_method] @ r2<- method + ldr r2, [rSELF, #offThread_method] @ r2<- method beq common_errNullObject @ yes, fail ldr r0, [r0, #offObject_clazz] @ r0<- thisPtr->clazz bl dvmFindInterfaceMethodInCache @ r0<- call(class, ref, method, dex) @@ -7046,14 +7043,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_VOLATILE_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -7074,14 +7071,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_VOLATILE_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -7101,7 +7098,7 @@ dalvik_inst: * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -7128,7 +7125,7 @@ dalvik_inst: * for: sput, sput-boolean, sput-byte, sput-char, sput-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -7156,14 +7153,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_OBJECT_VOLATILE_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -7182,14 +7179,14 @@ dalvik_inst: */ /* iget-wide vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_WIDE_VOLATILE_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -7205,14 +7202,14 @@ dalvik_inst: /* File: armv5te/OP_IPUT_WIDE.S */ /* iput-wide vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_WIDE_VOLATILE_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -7230,7 +7227,7 @@ dalvik_inst: * 64-bit SGET handler. */ /* sget-wide vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -7260,7 +7257,7 @@ dalvik_inst: * 64-bit SPUT handler. */ /* sput-wide vAA, field@BBBB */ - ldr r0, [rGLUE, #offGlue_methodClassDex] @ r0<- DvmDex + ldr r0, [rSELF, #offThread_methodClassDex] @ r0<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r0, [r0, #offDvmDex_pResFields] @ r0<- dvmDex->pResFields mov r9, rINST, lsr #8 @ r9<- AA @@ -7299,7 +7296,7 @@ dalvik_inst: * exception is indicated by AA, with some detail provided by BBBB. */ /* op AA, ref@BBBB */ - ldr r0, [rGLUE, #offGlue_method] @ r0<- glue->method + ldr r0, [rSELF, #offThread_method] @ r0<- self->method FETCH(r2, 1) @ r2<- BBBB EXPORT_PC() @ export the PC mov r1, rINST, lsr #8 @ r1<- AA @@ -7322,11 +7319,11 @@ dalvik_inst: */ /* [opt] execute-inline vAA, {vC, vD, vE, vF}, inline@BBBB */ FETCH(r10, 1) @ r10<- BBBB - add r1, rGLUE, #offGlue_retval @ r1<- &glue->retval + add r1, rSELF, #offThread_retval @ r1<- &self->retval EXPORT_PC() @ can throw sub sp, sp, #8 @ make room for arg, +64 bit align mov r0, rINST, lsr #12 @ r0<- B - str r1, [sp] @ push &glue->retval + str r1, [sp] @ push &self->retval bl .LOP_EXECUTE_INLINE_continue @ make call; will return after add sp, sp, #8 @ pop stack cmp r0, #0 @ test boolean result of inline @@ -7352,11 +7349,11 @@ dalvik_inst: */ /* [opt] execute-inline/range {vCCCC..v(CCCC+AA-1)}, inline@BBBB */ FETCH(r10, 1) @ r10<- BBBB - add r1, rGLUE, #offGlue_retval @ r1<- &glue->retval + add r1, rSELF, #offThread_retval @ r1<- &self->retval EXPORT_PC() @ can throw sub sp, sp, #8 @ make room for arg, +64 bit align mov r0, rINST, lsr #8 @ r0<- AA - str r1, [sp] @ push &glue->retval + str r1, [sp] @ push &self->retval bl .LOP_EXECUTE_INLINE_RANGE_continue @ make call; will return after add sp, sp, #8 @ pop stack cmp r0, #0 @ test boolean result of inline @@ -7502,7 +7499,7 @@ dalvik_inst: beq common_errNullObject @ object was null and r2, r2, #15 GET_VREG(r0, r2) @ r0<- fp[A] - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base FETCH_ADVANCE_INST(2) @ advance rPC, load rINST str r0, [r3, r1] @ obj.field (always 32 bits)<- r0 cmp r0, #0 @@ -7574,7 +7571,7 @@ dalvik_inst: /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ FETCH(r10, 2) @ r10<- GFED or CCCC - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method .if (!0) and r10, r10, #15 @ r10<- D (or stays CCCC) .endif @@ -7602,7 +7599,7 @@ dalvik_inst: /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ FETCH(r10, 2) @ r10<- GFED or CCCC - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method .if (!1) and r10, r10, #15 @ r10<- D (or stays CCCC) .endif @@ -7630,14 +7627,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_OBJECT_VOLATILE_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -7657,7 +7654,7 @@ dalvik_inst: * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -7684,13 +7681,13 @@ dalvik_inst: * for: sput-object, sput-object-volatile */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_SPUT_OBJECT_VOLATILE_finish @ no, continue - ldr r9, [rGLUE, #offGlue_method] @ r9<- current method + ldr r9, [rSELF, #offThread_method] @ r9<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r9, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -7715,7 +7712,7 @@ dalvik_inst: /* File: armv5te/OP_CONST_CLASS_JUMBO.S */ /* const-class/jumbo vBBBB, Class@AAAAAAAA */ FETCH(r0, 1) @ r0<- aaaa (lo) - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- glue->methodClassDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<-self>methodClassDex FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResClasses] @ r2<- dvmDex->pResClasses orr r1, r0, r1, lsl #16 @ r1<- AAAAaaaa @@ -7741,7 +7738,7 @@ dalvik_inst: FETCH(r3, 3) @ r3<- BBBB orr r2, r0, r2, lsl #16 @ r2<- AAAAaaaa GET_VREG(r9, r3) @ r9<- object - ldr r0, [rGLUE, #offGlue_methodClassDex] @ r0<- pDvmDex + ldr r0, [rSELF, #offThread_methodClassDex] @ r0<- pDvmDex cmp r9, #0 @ is object null? ldr r0, [r0, #offDvmDex_pResClasses] @ r0<- pDvmDex->pResClasses beq .LOP_CHECK_CAST_JUMBO_okay @ null obj, cast always succeeds @@ -7771,7 +7768,7 @@ dalvik_inst: FETCH(r3, 4) @ r3<- vCCCC FETCH(r9, 3) @ r9<- vBBBB GET_VREG(r0, r3) @ r0<- vCCCC (object) - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- pDvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- pDvmDex cmp r0, #0 @ is object null? beq .LOP_INSTANCE_OF_JUMBO_store @ null obj, not an instance, store r0 FETCH(r1, 1) @ r1<- aaaa (lo) @@ -7794,7 +7791,7 @@ dalvik_inst: /* new-instance/jumbo vBBBB, class@AAAAAAAA */ FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex orr r1, r0, r1, lsl #16 @ r1<- AAAAaaaa ldr r3, [r3, #offDvmDex_pResClasses] @ r3<- pDvmDex->pResClasses ldr r0, [r3, r1, lsl #2] @ r0<- resolved class @@ -7826,7 +7823,7 @@ dalvik_inst: FETCH(r3, 2) @ r3<- AAAA (hi) FETCH(r0, 4) @ r0<- vCCCC orr r2, r2, r3, lsl #16 @ r2<- AAAAaaaa - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex GET_VREG(r1, r0) @ r1<- vCCCC (array length) ldr r3, [r3, #offDvmDex_pResClasses] @ r3<- pDvmDex->pResClasses cmp r1, #0 @ check length @@ -7848,7 +7845,7 @@ dalvik_inst: * OP_FILLED_NEW_ARRAY.S. */ /* filled-new-array/jumbo {vCCCC..v(CCCC+BBBB-1)}, type@AAAAAAAA */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r3, [r3, #offDvmDex_pResClasses] @ r3<- pDvmDex->pResClasses @@ -7857,7 +7854,7 @@ dalvik_inst: EXPORT_PC() @ need for resolve and alloc cmp r0, #0 @ already resolved? bne .LOP_FILLED_NEW_ARRAY_JUMBO_continue @ yes, continue on -8: ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method +8: ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r2, #0 @ r2<- false ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveClass @ r0<- call(clazz, ref) @@ -7879,14 +7876,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -7903,14 +7900,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_WIDE_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -7931,14 +7928,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_OBJECT_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -7961,14 +7958,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_BOOLEAN_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -7991,14 +7988,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_BYTE_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8021,14 +8018,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_CHAR_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8051,14 +8048,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_SHORT_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8079,14 +8076,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8100,14 +8097,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_WIDE_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8124,14 +8121,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_OBJECT_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8153,14 +8150,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_BOOLEAN_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8183,14 +8180,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_BYTE_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8213,14 +8210,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_CHAR_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8243,14 +8240,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_SHORT_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8268,7 +8265,7 @@ dalvik_inst: * sget-char/jumbo, sget-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8293,7 +8290,7 @@ dalvik_inst: * Jumbo 64-bit SGET handler. */ /* sget-wide/jumbo vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8322,7 +8319,7 @@ dalvik_inst: * sget-char/jumbo, sget-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8352,7 +8349,7 @@ dalvik_inst: * sget-char/jumbo, sget-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8382,7 +8379,7 @@ dalvik_inst: * sget-char/jumbo, sget-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8412,7 +8409,7 @@ dalvik_inst: * sget-char/jumbo, sget-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8442,7 +8439,7 @@ dalvik_inst: * sget-char/jumbo, sget-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8471,7 +8468,7 @@ dalvik_inst: * sput-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8496,7 +8493,7 @@ dalvik_inst: * Jumbo 64-bit SPUT handler. */ /* sput-wide/jumbo vBBBB, field@AAAAAAAA */ - ldr r0, [rGLUE, #offGlue_methodClassDex] @ r0<- DvmDex + ldr r0, [rSELF, #offThread_methodClassDex] @ r0<- DvmDex FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) ldr r0, [r0, #offDvmDex_pResFields] @ r0<- dvmDex->pResFields @@ -8521,7 +8518,7 @@ dalvik_inst: * Jumbo 32-bit SPUT handler for objects */ /* sput-object/jumbo vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8529,7 +8526,7 @@ dalvik_inst: ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_SPUT_OBJECT_JUMBO_finish @ no, continue - ldr r9, [rGLUE, #offGlue_method] @ r9<- current method + ldr r9, [rSELF, #offThread_method] @ r9<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r9, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -8549,7 +8546,7 @@ dalvik_inst: * sput-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8579,7 +8576,7 @@ dalvik_inst: * sput-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8609,7 +8606,7 @@ dalvik_inst: * sput-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8639,7 +8636,7 @@ dalvik_inst: * sput-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8665,7 +8662,7 @@ dalvik_inst: * Handle a virtual method call. */ /* invoke-virtual/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r0, 1) @ r1<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods @@ -8674,7 +8671,7 @@ dalvik_inst: cmp r0, #0 @ already resolved? EXPORT_PC() @ must export for invoke bne .LOP_INVOKE_VIRTUAL_JUMBO_continue @ yes, continue on - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_VIRTUAL @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) @@ -8691,7 +8688,7 @@ dalvik_inst: */ /* invoke-super/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ FETCH(r10, 4) @ r10<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r0, 1) @ r1<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods @@ -8699,7 +8696,7 @@ dalvik_inst: GET_VREG(r2, r10) @ r2<- "this" ptr ldr r0, [r3, r1, lsl #2] @ r0<- resolved baseMethod cmp r2, #0 @ null "this"? - ldr r9, [rGLUE, #offGlue_method] @ r9<- current method + ldr r9, [rSELF, #offThread_method] @ r9<- current method beq common_errNullObject @ null "this", throw exception cmp r0, #0 @ already resolved? ldr r9, [r9, #offMethod_clazz] @ r9<- method->clazz @@ -8721,7 +8718,7 @@ dalvik_inst: * */ /* invoke-direct/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r0, 1) @ r1<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods @@ -8745,7 +8742,7 @@ dalvik_inst: * Handle a static method call. */ /* invoke-static/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r0, 1) @ r1<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods @@ -8754,7 +8751,7 @@ dalvik_inst: cmp r0, #0 @ already resolved? EXPORT_PC() @ must export for invoke bne common_invokeMethodJumbo @ yes, continue on -0: ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method +0: ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_STATIC @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) @@ -8776,9 +8773,9 @@ dalvik_inst: EXPORT_PC() @ must export for invoke orr r1, r0, r1, lsl #16 @ r1<- AAAAaaaa GET_VREG(r0, r2) @ r0<- first arg ("this") - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- methodClassDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- methodClassDex cmp r0, #0 @ null obj? - ldr r2, [rGLUE, #offGlue_method] @ r2<- method + ldr r2, [rSELF, #offThread_method] @ r2<- method beq common_errNullObject @ yes, fail ldr r0, [r0, #offObject_clazz] @ r0<- thisPtr->clazz bl dvmFindInterfaceMethodInCache @ r0<- call(class, ref, method, dex) @@ -10526,7 +10523,7 @@ dalvik_inst: /* exop BBBB, Class@AAAAAAAA */ FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) - ldr r0, [rGLUE, #offGlue_method] @ r0<- glue->method + ldr r0, [rSELF, #offThread_method] @ r0<- self->method orr r2, r1, r2, lsl #16 @ r2<- AAAAaaaa EXPORT_PC() @ export the PC FETCH(r1, 3) @ r1<- BBBB @@ -10559,7 +10556,7 @@ dvmAsmSisterStart: */ .LOP_CONST_STRING_resolve: EXPORT_PC() - ldr r0, [rGLUE, #offGlue_method] @ r0<- glue->method + ldr r0, [rSELF, #offThread_method] @ r0<- self->method ldr r0, [r0, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveString @ r0<- String reference cmp r0, #0 @ failed? @@ -10578,7 +10575,7 @@ dvmAsmSisterStart: */ .LOP_CONST_STRING_JUMBO_resolve: EXPORT_PC() - ldr r0, [rGLUE, #offGlue_method] @ r0<- glue->method + ldr r0, [rSELF, #offThread_method] @ r0<- self->method ldr r0, [r0, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveString @ r0<- String reference cmp r0, #0 @ failed? @@ -10597,7 +10594,7 @@ dvmAsmSisterStart: */ .LOP_CONST_CLASS_resolve: EXPORT_PC() - ldr r0, [rGLUE, #offGlue_method] @ r0<- glue->method + ldr r0, [rSELF, #offThread_method] @ r0<- self->method mov r2, #1 @ r2<- true ldr r0, [r0, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveClass @ r0<- Class reference @@ -10637,7 +10634,7 @@ dvmAsmSisterStart: */ .LOP_CHECK_CAST_resolve: EXPORT_PC() @ resolve() could throw - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r1, r2 @ r1<- BBBB mov r2, #0 @ r2<- false ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz @@ -10690,7 +10687,7 @@ dvmAsmSisterStart: */ .LOP_INSTANCE_OF_resolve: EXPORT_PC() @ resolve() could throw - ldr r0, [rGLUE, #offGlue_method] @ r0<- glue->method + ldr r0, [rSELF, #offThread_method] @ r0<- self->method mov r1, r3 @ r1<- BBBB mov r2, #1 @ r2<- true ldr r0, [r0, #offMethod_clazz] @ r0<- method->clazz @@ -10734,7 +10731,7 @@ dvmAsmSisterStart: * r1 holds BBBB */ .LOP_NEW_INSTANCE_resolve: - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r2, #0 @ r2<- false ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveClass @ r0<- resolved ClassObject ptr @@ -10755,7 +10752,7 @@ dvmAsmSisterStart: * r2 holds class ref CCCC */ .LOP_NEW_ARRAY_resolve: - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r9, r1 @ r9<- length (save) mov r1, r2 @ r1<- CCCC mov r2, #0 @ r2<- false @@ -10810,8 +10807,8 @@ dvmAsmSisterStart: beq common_exceptionThrown @ alloc failed, handle exception FETCH(r1, 2) @ r1<- FEDC or CCCC - str r0, [rGLUE, #offGlue_retval] @ retval.l <- new array - str rINST, [rGLUE, #offGlue_retval+4] @ retval.h <- type + str r0, [rSELF, #offThread_retval] @ retval.l <- new array + str rINST, [rSELF, #offThread_retval+4] @ retval.h <- type add r0, r0, #offArrayObject_contents @ r0<- newArray->contents subs r9, r9, #1 @ length--, check for neg FETCH_ADVANCE_INST(3) @ advance to next instr, load rINST @@ -10843,9 +10840,9 @@ dvmAsmSisterStart: .endif 2: - ldr r0, [rGLUE, #offGlue_retval] @ r0<- object - ldr r1, [rGLUE, #offGlue_retval+4] @ r1<- type - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r0, [rSELF, #offThread_retval] @ r0<- object + ldr r1, [rSELF, #offThread_retval+4] @ r1<- type + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base GET_INST_OPCODE(ip) @ ip<- opcode from rINST cmp r1, #'I' @ Is int array? strneb r2, [r2, r0, lsr #GC_CARD_SHIFT] @ Mark card based on object head @@ -10894,8 +10891,8 @@ dvmAsmSisterStart: beq common_exceptionThrown @ alloc failed, handle exception FETCH(r1, 2) @ r1<- FEDC or CCCC - str r0, [rGLUE, #offGlue_retval] @ retval.l <- new array - str rINST, [rGLUE, #offGlue_retval+4] @ retval.h <- type + str r0, [rSELF, #offThread_retval] @ retval.l <- new array + str rINST, [rSELF, #offThread_retval+4] @ retval.h <- type add r0, r0, #offArrayObject_contents @ r0<- newArray->contents subs r9, r9, #1 @ length--, check for neg FETCH_ADVANCE_INST(3) @ advance to next instr, load rINST @@ -10927,9 +10924,9 @@ dvmAsmSisterStart: .endif 2: - ldr r0, [rGLUE, #offGlue_retval] @ r0<- object - ldr r1, [rGLUE, #offGlue_retval+4] @ r1<- type - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r0, [rSELF, #offThread_retval] @ r0<- object + ldr r1, [rSELF, #offThread_retval+4] @ r1<- type + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base GET_INST_OPCODE(ip) @ ip<- opcode from rINST cmp r1, #'I' @ Is int array? strneb r2, [r2, r0, lsr #GC_CARD_SHIFT] @ Mark card based on object head @@ -11029,7 +11026,7 @@ dvmAsmSisterStart: beq .LOP_APUT_OBJECT_throw @ no mov r1, rINST @ r1<- arrayObj FETCH_ADVANCE_INST(2) @ advance rPC, load rINST - ldr r2, [rGLUE, #offGlue_cardTable] @ get biased CT base + ldr r2, [rSELF, #offThread_cardTable] @ get biased CT base add r10, #offArrayObject_contents @ r0<- pointer to slot GET_INST_OPCODE(ip) @ extract opcode from rINST str r9, [r10] @ vBB[vCC]<- vAA @@ -11243,7 +11240,7 @@ dvmAsmSisterStart: and r1, r1, #15 @ r1<- A cmp r9, #0 @ check object for null GET_VREG(r0, r1) @ r0<- fp[A] - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base beq common_errNullObject @ object was null FETCH_ADVANCE_INST(2) @ advance rPC, load rINST GET_INST_OPCODE(ip) @ extract opcode from rINST @@ -11344,7 +11341,7 @@ dvmAsmSisterStart: * r1: BBBB field ref */ .LOP_SGET_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11361,7 +11358,7 @@ dvmAsmSisterStart: * Returns StaticField pointer in r0. */ .LOP_SGET_WIDE_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11376,7 +11373,7 @@ dvmAsmSisterStart: * r1: BBBB field ref */ .LOP_SGET_OBJECT_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11391,7 +11388,7 @@ dvmAsmSisterStart: * r1: BBBB field ref */ .LOP_SGET_BOOLEAN_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11406,7 +11403,7 @@ dvmAsmSisterStart: * r1: BBBB field ref */ .LOP_SGET_BYTE_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11421,7 +11418,7 @@ dvmAsmSisterStart: * r1: BBBB field ref */ .LOP_SGET_CHAR_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11436,7 +11433,7 @@ dvmAsmSisterStart: * r1: BBBB field ref */ .LOP_SGET_SHORT_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11451,7 +11448,7 @@ dvmAsmSisterStart: * r1: BBBB field ref */ .LOP_SPUT_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11469,7 +11466,7 @@ dvmAsmSisterStart: * Returns StaticField pointer in r2. */ .LOP_SPUT_WIDE_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11483,7 +11480,7 @@ dvmAsmSisterStart: mov r2, rINST, lsr #8 @ r2<- AA FETCH_ADVANCE_INST(2) @ advance rPC, load rINST GET_VREG(r1, r2) @ r1<- fp[AA] - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base ldr r9, [r0, #offField_clazz] @ r9<- field->clazz GET_INST_OPCODE(ip) @ extract opcode from rINST @ no-op @ releasing store @@ -11499,7 +11496,7 @@ dvmAsmSisterStart: * r1: BBBB field ref */ .LOP_SPUT_BOOLEAN_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11514,7 +11511,7 @@ dvmAsmSisterStart: * r1: BBBB field ref */ .LOP_SPUT_BYTE_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11529,7 +11526,7 @@ dvmAsmSisterStart: * r1: BBBB field ref */ .LOP_SPUT_CHAR_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11544,7 +11541,7 @@ dvmAsmSisterStart: * r1: BBBB field ref */ .LOP_SPUT_SHORT_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11611,7 +11608,7 @@ dvmAsmSisterStart: * r10 = "this" register */ .LOP_INVOKE_DIRECT_resolve: - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_DIRECT @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) @@ -11679,7 +11676,7 @@ dvmAsmSisterStart: * r10 = "this" register */ .LOP_INVOKE_DIRECT_RANGE_resolve: - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_DIRECT @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) @@ -11876,7 +11873,7 @@ d2l_doconv: * r1: BBBB field ref */ .LOP_SGET_VOLATILE_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11891,7 +11888,7 @@ d2l_doconv: * r1: BBBB field ref */ .LOP_SPUT_VOLATILE_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11979,7 +11976,7 @@ d2l_doconv: * Returns StaticField pointer in r0. */ .LOP_SGET_WIDE_VOLATILE_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11997,7 +11994,7 @@ d2l_doconv: * Returns StaticField pointer in r2. */ .LOP_SPUT_WIDE_VOLATILE_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12084,7 +12081,7 @@ d2l_doconv: and r1, r1, #15 @ r1<- A cmp r9, #0 @ check object for null GET_VREG(r0, r1) @ r0<- fp[A] - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base beq common_errNullObject @ object was null FETCH_ADVANCE_INST(2) @ advance rPC, load rINST GET_INST_OPCODE(ip) @ extract opcode from rINST @@ -12101,7 +12098,7 @@ d2l_doconv: * r1: BBBB field ref */ .LOP_SGET_OBJECT_VOLATILE_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12114,7 +12111,7 @@ d2l_doconv: mov r2, rINST, lsr #8 @ r2<- AA FETCH_ADVANCE_INST(2) @ advance rPC, load rINST GET_VREG(r1, r2) @ r1<- fp[AA] - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base ldr r9, [r0, #offField_clazz] @ r9<- field->clazz GET_INST_OPCODE(ip) @ extract opcode from rINST SMP_DMB @ releasing store @@ -12132,7 +12129,7 @@ d2l_doconv: */ .LOP_CONST_CLASS_JUMBO_resolve: EXPORT_PC() - ldr r0, [rGLUE, #offGlue_method] @ r0<- glue->method + ldr r0, [rSELF, #offThread_method] @ r0<- self->method mov r2, #1 @ r2<- true ldr r0, [r0, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveClass @ r0<- Class reference @@ -12180,7 +12177,7 @@ d2l_doconv: */ .LOP_CHECK_CAST_JUMBO_resolve: EXPORT_PC() @ resolve() could throw - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r1, r2 @ r1<- AAAAAAAA mov r2, #0 @ r2<- false ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz @@ -12245,7 +12242,7 @@ d2l_doconv: .LOP_INSTANCE_OF_JUMBO_resolve: EXPORT_PC() @ resolve() could throw - ldr r0, [rGLUE, #offGlue_method] @ r0<- glue->method + ldr r0, [rSELF, #offThread_method] @ r0<- self->method mov r1, r3 @ r1<- AAAAAAAA mov r2, #1 @ r2<- true ldr r0, [r0, #offMethod_clazz] @ r0<- method->clazz @@ -12289,7 +12286,7 @@ d2l_doconv: * r1 holds AAAAAAAA */ .LOP_NEW_INSTANCE_JUMBO_resolve: - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r2, #0 @ r2<- false ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveClass @ r0<- resolved ClassObject ptr @@ -12307,7 +12304,7 @@ d2l_doconv: * r2 holds class ref AAAAAAAA */ .LOP_NEW_ARRAY_JUMBO_resolve: - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r9, r1 @ r9<- length (save) mov r1, r2 @ r1<- AAAAAAAA mov r2, #0 @ r2<- false @@ -12356,8 +12353,8 @@ d2l_doconv: beq common_exceptionThrown @ alloc failed, handle exception FETCH(r1, 4) @ r1<- CCCC - str r0, [rGLUE, #offGlue_retval] @ retval.l <- new array - str rINST, [rGLUE, #offGlue_retval+4] @ retval.h <- type + str r0, [rSELF, #offThread_retval] @ retval.l <- new array + str rINST, [rSELF, #offThread_retval+4] @ retval.h <- type add r0, r0, #offArrayObject_contents @ r0<- newArray->contents subs r9, r9, #1 @ length--, check for neg FETCH_ADVANCE_INST(5) @ advance to next instr, load rINST @@ -12371,9 +12368,9 @@ d2l_doconv: str r3, [r0], #4 @ *contents++ = vX bpl 1b -2: ldr r0, [rGLUE, #offGlue_retval] @ r0<- object - ldr r1, [rGLUE, #offGlue_retval+4] @ r1<- type - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base +2: ldr r0, [rSELF, #offThread_retval] @ r0<- object + ldr r1, [rSELF, #offThread_retval+4] @ r1<- type + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base GET_INST_OPCODE(ip) @ ip<- opcode from rINST cmp r1, #'I' @ Is int array? strneb r2, [r2, r0, lsr #GC_CARD_SHIFT] @ Mark card based on object head @@ -12680,7 +12677,7 @@ d2l_doconv: FETCH(r1, 3) @ r1<- BBBB cmp r9, #0 @ check object for null GET_VREG(r0, r1) @ r0<- fp[BBBB] - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base beq common_errNullObject @ object was null FETCH_ADVANCE_INST(5) @ advance rPC, load rINST GET_INST_OPCODE(ip) @ extract opcode from rINST @@ -12817,7 +12814,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SGET_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12834,7 +12831,7 @@ d2l_doconv: * Returns StaticField pointer in r0. */ .LOP_SGET_WIDE_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12849,7 +12846,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SGET_OBJECT_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12864,7 +12861,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SGET_BOOLEAN_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12879,7 +12876,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SGET_BYTE_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12894,7 +12891,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SGET_CHAR_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12909,7 +12906,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SGET_SHORT_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12924,7 +12921,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SPUT_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12942,7 +12939,7 @@ d2l_doconv: * Returns StaticField pointer in r2. */ .LOP_SPUT_WIDE_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12957,7 +12954,7 @@ d2l_doconv: FETCH(r2, 3) @ r2<- BBBB FETCH_ADVANCE_INST(4) @ advance rPC, load rINST GET_VREG(r1, r2) @ r1<- fp[BBBB] - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base ldr r9, [r0, #offField_clazz] @ r9<- field->clazz GET_INST_OPCODE(ip) @ extract opcode from rINST @ no-op @ releasing store @@ -12973,7 +12970,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SPUT_BOOLEAN_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12988,7 +12985,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SPUT_BYTE_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -13003,7 +13000,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SPUT_CHAR_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -13018,7 +13015,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SPUT_SHORT_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -13085,7 +13082,7 @@ d2l_doconv: * r10 = "this" register */ .LOP_INVOKE_DIRECT_JUMBO_resolve: - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_DIRECT @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) @@ -13115,71 +13112,64 @@ dvmAsmSisterEnd: #if defined(WITH_SELF_VERIFICATION) .global dvmJitToInterpPunt dvmJitToInterpPunt: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self mov r2,#kSVSPunt @ r2<- interpreter entry point mov r3, #0 - str r3, [r10, #offThread_inJitCodeCache] @ Back to the interp land + str r3, [rSELF, #offThread_inJitCodeCache] @ Back to the interp land b jitSVShadowRunEnd @ doesn't return .global dvmJitToInterpSingleStep dvmJitToInterpSingleStep: - str lr,[rGLUE,#offGlue_jitResumeNPC] - str r1,[rGLUE,#offGlue_jitResumeDPC] + str lr,[rSELF,#offThread_jitResumeNPC] + str r1,[rSELF,#offThread_jitResumeDPC] mov r2,#kSVSSingleStep @ r2<- interpreter entry point b jitSVShadowRunEnd @ doesn't return .global dvmJitToInterpNoChainNoProfile dvmJitToInterpNoChainNoProfile: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self mov r0,rPC @ pass our target PC mov r2,#kSVSNoProfile @ r2<- interpreter entry point mov r3, #0 @ 0 means !inJitCodeCache - str r3, [r10, #offThread_inJitCodeCache] @ back to the interp land + str r3, [rSELF, #offThread_inJitCodeCache] @ back to the interp land b jitSVShadowRunEnd @ doesn't return .global dvmJitToInterpTraceSelectNoChain dvmJitToInterpTraceSelectNoChain: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self mov r0,rPC @ pass our target PC mov r2,#kSVSTraceSelect @ r2<- interpreter entry point mov r3, #0 @ 0 means !inJitCodeCache - str r3, [r10, #offThread_inJitCodeCache] @ Back to the interp land + str r3, [rSELF, #offThread_inJitCodeCache] @ Back to the interp land b jitSVShadowRunEnd @ doesn't return .global dvmJitToInterpTraceSelect dvmJitToInterpTraceSelect: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self ldr r0,[lr, #-1] @ pass our target PC mov r2,#kSVSTraceSelect @ r2<- interpreter entry point mov r3, #0 @ 0 means !inJitCodeCache - str r3, [r10, #offThread_inJitCodeCache] @ Back to the interp land + str r3, [rSELF, #offThread_inJitCodeCache] @ Back to the interp land b jitSVShadowRunEnd @ doesn't return .global dvmJitToInterpBackwardBranch dvmJitToInterpBackwardBranch: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self ldr r0,[lr, #-1] @ pass our target PC mov r2,#kSVSBackwardBranch @ r2<- interpreter entry point mov r3, #0 @ 0 means !inJitCodeCache - str r3, [r10, #offThread_inJitCodeCache] @ Back to the interp land + str r3, [rSELF, #offThread_inJitCodeCache] @ Back to the interp land b jitSVShadowRunEnd @ doesn't return .global dvmJitToInterpNormal dvmJitToInterpNormal: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self ldr r0,[lr, #-1] @ pass our target PC mov r2,#kSVSNormal @ r2<- interpreter entry point mov r3, #0 @ 0 means !inJitCodeCache - str r3, [r10, #offThread_inJitCodeCache] @ Back to the interp land + str r3, [rSELF, #offThread_inJitCodeCache] @ Back to the interp land b jitSVShadowRunEnd @ doesn't return .global dvmJitToInterpNoChain dvmJitToInterpNoChain: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self mov r0,rPC @ pass our target PC mov r2,#kSVSNoChain @ r2<- interpreter entry point mov r3, #0 @ 0 means !inJitCodeCache - str r3, [r10, #offThread_inJitCodeCache] @ Back to the interp land + str r3, [rSELF, #offThread_inJitCodeCache] @ Back to the interp land b jitSVShadowRunEnd @ doesn't return #else /* @@ -13191,7 +13181,6 @@ dvmJitToInterpNoChain: */ .global dvmJitToInterpPunt dvmJitToInterpPunt: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self mov rPC, r0 #if defined(WITH_JIT_TUNING) mov r0,lr @@ -13199,7 +13188,7 @@ dvmJitToInterpPunt: #endif EXPORT_PC() mov r0, #0 - str r0, [r10, #offThread_inJitCodeCache] @ Back to the interp land + str r0, [rSELF, #offThread_inJitCodeCache] @ Back to the interp land adrl rIBASE, dvmAsmInstructionStart FETCH_INST() GET_INST_OPCODE(ip) @@ -13214,17 +13203,17 @@ dvmJitToInterpPunt: */ .global dvmJitToInterpSingleStep dvmJitToInterpSingleStep: - str lr,[rGLUE,#offGlue_jitResumeNPC] - str r1,[rGLUE,#offGlue_jitResumeDPC] + str lr,[rSELF,#offThread_jitResumeNPC] + str r1,[rSELF,#offThread_jitResumeDPC] mov r1,#kInterpEntryInstr @ enum is 4 byte in aapcs-EABI - str r1, [rGLUE, #offGlue_entryPoint] + str r1, [rSELF, #offThread_entryPoint] mov rPC,r0 EXPORT_PC() adrl rIBASE, dvmAsmInstructionStart mov r2,#kJitSingleStep @ Ask for single step and then revert - str r2,[rGLUE,#offGlue_jitState] + str r2,[rSELF,#offThread_jitState] mov r1,#1 @ set changeInterp to bail to debug interp b common_gotoBail @@ -13237,10 +13226,9 @@ dvmJitToInterpTraceSelectNoChain: #if defined(WITH_JIT_TUNING) bl dvmBumpNoChain #endif - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self mov r0,rPC bl dvmJitGetTraceAddr @ Is there a translation? - str r0, [r10, #offThread_inJitCodeCache] @ set the inJitCodeCache flag + str r0, [rSELF, #offThread_inJitCodeCache] @ set the inJitCodeCache flag mov r1, rPC @ arg1 of translation may need this mov lr, #0 @ in case target is HANDLER_INTERPRET cmp r0,#0 @ !0 means translation exists @@ -13255,12 +13243,11 @@ dvmJitToInterpTraceSelectNoChain: .global dvmJitToInterpTraceSelect dvmJitToInterpTraceSelect: ldr rPC,[lr, #-1] @ get our target PC - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self add rINST,lr,#-5 @ save start of chain branch add rINST, #-4 @ .. which is 9 bytes back mov r0,rPC bl dvmJitGetTraceAddr @ Is there a translation? - str r0, [r10, #offThread_inJitCodeCache] @ set the inJitCodeCache flag + str r0, [rSELF, #offThread_inJitCodeCache] @ set the inJitCodeCache flag cmp r0,#0 beq 2f mov r1,rINST @@ -13299,7 +13286,6 @@ dvmJitToInterpTraceSelect: .global dvmJitToInterpNormal dvmJitToInterpNormal: ldr rPC,[lr, #-1] @ get our target PC - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self add rINST,lr,#-5 @ save start of chain branch add rINST,#-4 @ .. which is 9 bytes back #if defined(WITH_JIT_TUNING) @@ -13307,7 +13293,7 @@ dvmJitToInterpNormal: #endif mov r0,rPC bl dvmJitGetTraceAddr @ Is there a translation? - str r0, [r10, #offThread_inJitCodeCache] @ set the inJitCodeCache flag + str r0, [rSELF, #offThread_inJitCodeCache] @ set the inJitCodeCache flag cmp r0,#0 beq toInterpreter @ go if not, otherwise do chain mov r1,rINST @@ -13327,10 +13313,9 @@ dvmJitToInterpNoChainNoProfile: #if defined(WITH_JIT_TUNING) bl dvmBumpNoChain #endif - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self mov r0,rPC bl dvmJitGetTraceAddr @ Is there a translation? - str r0, [r10, #offThread_inJitCodeCache] @ set the inJitCodeCache flag + str r0, [rSELF, #offThread_inJitCodeCache] @ set the inJitCodeCache flag mov r1, rPC @ arg1 of translation may need this mov lr, #0 @ in case target is HANDLER_INTERPRET cmp r0,#0 @@ -13350,10 +13335,9 @@ dvmJitToInterpNoChain: #if defined(WITH_JIT_TUNING) bl dvmBumpNoChain #endif - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self mov r0,rPC bl dvmJitGetTraceAddr @ Is there a translation? - str r0, [r10, #offThread_inJitCodeCache] @ set the inJitCodeCache flag + str r0, [rSELF, #offThread_inJitCodeCache] @ set the inJitCodeCache flag mov r1, rPC @ arg1 of translation may need this mov lr, #0 @ in case target is HANDLER_INTERPRET cmp r0,#0 @@ -13362,7 +13346,7 @@ dvmJitToInterpNoChain: /* * No translation, restore interpreter regs and start interpreting. - * rGLUE & rFP were preserved in the translated code, and rPC has + * rSELF & rFP were preserved in the translated code, and rPC has * already been restored by the time we get here. We'll need to set * up rIBASE & rINST, and load the address of the JitTable into r0. */ @@ -13400,13 +13384,13 @@ common_updateProfile: * is already a native translation in place (and, if so, * jump to it now). */ + GET_JIT_THRESHOLD(r1) - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self strb r1,[r0,r3,lsr #(32 - JIT_PROF_SIZE_LOG_2)] @ reset counter EXPORT_PC() mov r0,rPC bl dvmJitGetTraceAddr @ r0<- dvmJitGetTraceAddr(rPC) - str r0, [r10, #offThread_inJitCodeCache] @ set the inJitCodeCache flag + str r0, [rSELF, #offThread_inJitCodeCache] @ set the inJitCodeCache flag mov r1, rPC @ arg1 of translation may need this mov lr, #0 @ in case target is HANDLER_INTERPRET cmp r0,#0 @@ -13427,9 +13411,8 @@ common_updateProfile: cmp r0, r10 @ special case? bne jitSVShadowRunStart @ set up self verification shadow space @ Need to clear the inJitCodeCache flag - ldr r10, [rGLUE, #offGlue_self] @ r10 <- glue->self mov r3, #0 @ 0 means not in the JIT code cache - str r3, [r10, #offThread_inJitCodeCache] @ back to the interp land + str r3, [rSELF, #offThread_inJitCodeCache] @ back to the interp land GET_INST_OPCODE(ip) GOTO_OPCODE(ip) /* no return */ @@ -13440,9 +13423,10 @@ common_updateProfile: * r2 is jit state, e.g. kJitTSelectRequest or kJitTSelectRequestHot */ common_selectTrace: - str r2,[rGLUE,#offGlue_jitState] + + str r2,[rSELF,#offThread_jitState] mov r2,#kInterpEntryInstr @ normal entry reason - str r2,[rGLUE,#offGlue_entryPoint] + str r2,[rSELF,#offThread_entryPoint] mov r1,#1 @ set changeInterp b common_gotoBail @@ -13451,36 +13435,35 @@ common_selectTrace: * Save PC and registers to shadow memory for self verification mode * before jumping to native translation. * On entry: - * rPC, rFP, rGLUE: the values that they should contain + * rPC, rFP, rSELF: the values that they should contain * r10: the address of the target translation. */ jitSVShadowRunStart: mov r0,rPC @ r0<- program counter mov r1,rFP @ r1<- frame pointer - mov r2,rGLUE @ r2<- InterpState pointer + mov r2,rSELF @ r2<- self (Thread) pointer mov r3,r10 @ r3<- target translation bl dvmSelfVerificationSaveState @ save registers to shadow space 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 + * Restore PC, registers, and interpreter state to original values * before jumping back to the interpreter. */ jitSVShadowRunEnd: mov r1,rFP @ pass ending fp + mov r3,rSELF @ pass self ptr for convenience bl dvmSelfVerificationRestoreState @ restore pc and fp values - ldr rPC,[r0,#offShadowSpace_startPC] @ restore PC - ldr rFP,[r0,#offShadowSpace_fp] @ restore FP - ldr rGLUE,[r0,#offShadowSpace_glue] @ restore InterpState + ldr rPC,[rSELF,#offThread_pc] @ restore PC + ldr rFP,[rSELF,#offThread_fp] @ restore FP 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 - str r2,[rGLUE,#offGlue_jitState] + str r2,[rSELF,#offThread_jitState] mov r2,#kInterpEntryInstr @ normal entry reason - str r2,[rGLUE,#offGlue_entryPoint] + str r2,[rSELF,#offThread_entryPoint] mov r1,#1 @ set changeInterp b common_gotoBail @@ -13541,12 +13524,11 @@ common_backwardBranch: * r9 is trampoline PC adjustment *in bytes* */ common_periodicChecks: - ldr r1, [rGLUE, #offGlue_pInterpBreak] @ r3<- &interpBreak - /* speculatively load address of thread-specific suspend count */ - ldr r3, [rGLUE, #offGlue_pSelfSuspendCount] @ r3<- &suspendCount +/* TUNING - make this a direct load when interpBreak moved to Thread */ + ldr r1, [rSELF, #offThread_pInterpBreak] @ r3<- &interpBreak + /* speculatively thread-specific suspend count */ + ldr ip, [rSELF, #offThread_suspendCount] ldr r1, [r1] @ r1<- interpBreak - /* speculatively load thread-specific suspend count */ - ldr ip, [r3] @ ip<- suspendCount (int) cmp r1, #0 @ anything unusual? bxeq lr @ return if not /* @@ -13563,13 +13545,13 @@ common_periodicChecks: * Refresh the Jit's cached copy of profile table pointer. This pointer * doubles as the Jit's on/off switch. */ - ldr r3, [rGLUE, #offGlue_ppJitProfTable] @ r3<-&gDvmJit.pJitProfTable - ldr r0, [rGLUE, #offGlue_self] @ r0<- glue->self + ldr r3, [rSELF, #offThread_ppJitProfTable] @ r3<-&gDvmJit.pJitProfTable + mov r0, rSELF @ r0<- self ldr r3, [r3] @ r3 <- pJitProfTable EXPORT_PC() @ need for precise GC - str r3, [rGLUE, #offGlue_pJitProfTable] @ refresh Jit's on/off switch + str r3, [rSELF, #offThread_pJitProfTable] @ refresh Jit's on/off switch #else - ldr r0, [rGLUE, #offGlue_self] @ r0<- glue->self + mov r0, rSELF @ r0<- self EXPORT_PC() @ need for precise GC #endif bl dvmCheckSuspendPending @ do full check, suspend if necessary @@ -13579,7 +13561,8 @@ common_periodicChecks: * Reload the interpBreak flags - they may have changed while we * were suspended. */ - ldr r1, [rGLUE, #offGlue_pInterpBreak] @ r1<- &interpBreak +/* TUNING - direct load when InterpBreak moved to Thread */ + ldr r1, [rSELF, #offThread_pInterpBreak] @ r1<- &interpBreak ldr r1, [r1] @ r1<- interpBreak 3: /* @@ -13593,8 +13576,8 @@ common_periodicChecks: ands r1, #(kSubModeDebuggerActive | kSubModeEmulatorTrace | kSubModeInstCounting) bxeq lr @ nothing to do, return - @ debugger/profiler enabled, bail out; glue->entryPoint was set above - str r0, [rGLUE, #offGlue_entryPoint] @ store r0, need for debug/prof + @ debugger/profiler enabled, bail out; self->entryPoint was set above + str r0, [rSELF, #offThread_entryPoint] @ store r0, need for debug/prof add rPC, rPC, r9 @ update rPC mov r1, #1 @ "want switch" = true b common_gotoBail @ side exit @@ -13603,19 +13586,19 @@ common_periodicChecks: /* * The equivalent of "goto bail", this calls through the "bail handler". * - * State registers will be saved to the "glue" area before bailing. + * State registers will be saved to the "thread" area before bailing. * * On entry: * r1 is "bool changeInterp", indicating if we want to switch to the * other interpreter or just bail all the way out */ common_gotoBail: - SAVE_PC_FP_TO_GLUE() @ export state to "glue" - mov r0, rGLUE @ r0<- glue ptr - b dvmMterpStdBail @ call(glue, changeInterp) + SAVE_PC_FP_TO_SELF() @ export state to "thread" + mov r0, rSELF @ r0<- self ptr + b dvmMterpStdBail @ call(self, changeInterp) @add r1, r1, #1 @ using (boolean+1) - @add r0, rGLUE, #offGlue_jmpBuf @ r0<- &glue->jmpBuf + @add r0, rSELF, #offThread_jmpBuf @ r0<- &self->jmpBuf @bl _longjmp @ does not return @bl common_abort @@ -13717,10 +13700,10 @@ common_invokeMethodNoRange: sub r1, r1, r9, lsl #2 @ r1<- newFp (old savearea - regsSize) SAVEAREA_FROM_FP(r10, r1) @ r10<- newSaveArea @ bl common_dumpRegs - ldr r9, [rGLUE, #offGlue_interpStackEnd] @ r9<- interpStackEnd + ldr r9, [rSELF, #offThread_interpStackEnd] @ r9<- interpStackEnd sub r3, r10, r3, lsl #2 @ r3<- bottom (newsave - outsSize) cmp r3, r9 @ bottom < interpStackEnd? - ldr lr, [rGLUE, #offGlue_pInterpBreak] + ldr lr, [rSELF, #offThread_pInterpBreak] ldr r3, [r0, #offMethod_accessFlags] @ r3<- methodToCall->accessFlags blo .LstackOverflow @ yes, this frame will overflow stack @@ -13740,7 +13723,7 @@ common_invokeMethodNoRange: beq 1f @ skip if not stmfd sp!, {r0-r3} @ preserve r0-r3 mov r1, r6 - @ r0=methodToCall, r1=rGlue + @ r0=methodToCall, r1=rSELF bl dvmFastMethodTraceEnter ldmfd sp!, {r0-r3} @ restore r0-r3 1: @@ -13766,18 +13749,17 @@ common_invokeMethodNoRange: ldrh r9, [r2] @ r9 <- load INST from new PC ldr r3, [rINST, #offClassObject_pDvmDex] @ r3<- method->clazz->pDvmDex mov rPC, r2 @ publish new rPC - ldr r2, [rGLUE, #offGlue_self] @ r2<- glue->self - @ Update "glue" values for the new method - @ r0=methodToCall, r1=newFp, r2=self, r3=newMethodClass, r9=newINST - str r0, [rGLUE, #offGlue_method] @ glue->method = methodToCall - str r3, [rGLUE, #offGlue_methodClassDex] @ glue->methodClassDex = ... + @ Update state values for the new method + @ r0=methodToCall, r1=newFp, r3=newMethodClass, r9=newINST + str r0, [rSELF, #offThread_method] @ self->method = methodToCall + str r3, [rSELF, #offThread_methodClassDex] @ self->methodClassDex = ... #if defined(WITH_JIT) GET_JIT_PROF_TABLE(r0) mov rFP, r1 @ fp = newFp GET_PREFETCHED_OPCODE(ip, r9) @ extract prefetched opcode from r9 mov rINST, r9 @ publish new rINST - str r1, [r2, #offThread_curFrame] @ self->curFrame = newFp + str r1, [rSELF, #offThread_curFrame] @ self->curFrame = newFp cmp r0,#0 bne common_updateProfile GOTO_OPCODE(ip) @ jump to next instruction @@ -13785,24 +13767,23 @@ common_invokeMethodNoRange: mov rFP, r1 @ fp = newFp GET_PREFETCHED_OPCODE(ip, r9) @ extract prefetched opcode from r9 mov rINST, r9 @ publish new rINST - str r1, [r2, #offThread_curFrame] @ self->curFrame = newFp + str r1, [rSELF, #offThread_curFrame] @ self->curFrame = newFp GOTO_OPCODE(ip) @ jump to next instruction #endif .LinvokeNative: @ Prep for the native call @ r0=methodToCall, r1=newFp, r10=newSaveArea - ldr r3, [rGLUE, #offGlue_self] @ r3<- glue->self - ldr lr, [rGLUE, #offGlue_pInterpBreak] - ldr r9, [r3, #offThread_jniLocal_topCookie] @ r9<- thread->localRef->... - str r1, [r3, #offThread_curFrame] @ self->curFrame = newFp + ldr lr, [rSELF, #offThread_pInterpBreak] + ldr r9, [rSELF, #offThread_jniLocal_topCookie]@r9<-thread->localRef->... + str r1, [rSELF, #offThread_curFrame] @ self->curFrame = newFp str r9, [r10, #offStackSaveArea_localRefCookie] @newFp->localRefCookie=top ldr lr, [lr] @ lr<- active submodes - mov r9, r3 @ r9<- glue->self (preserve) mov r2, r0 @ r2<- methodToCall mov r0, r1 @ r0<- newFp (points to args) - add r1, rGLUE, #offGlue_retval @ r1<- &retval + add r1, rSELF, #offThread_retval @ r1<- &retval + mov r3, rSELF @ arg3<- self #ifdef ASSIST_DEBUGGER /* insert fake function header to help gdb find the stack frame */ @@ -13817,13 +13798,13 @@ dalvik_mterp: ands lr, #kSubModeMethodTrace @ method tracing? beq 110f @ hop if not - @ r2=JNIMethod, r6=rGLUE + @ r2=JNIMethod, r6=rSELF stmfd sp!, {r2,r6} mov lr, pc @ set return addr ldr pc, [r2, #offMethod_nativeFunc] @ pc<- methodToCall->nativeFunc - @ r0=JNIMethod, r1=rGLUE + @ r0=JNIMethod, r1=rSELF ldmfd sp!, {r0-r1} bl dvmFastNativeMethodTraceExit b 220f @@ -13832,21 +13813,21 @@ dalvik_mterp: ldr pc, [r2, #offMethod_nativeFunc] @ pc<- methodToCall->nativeFunc 220: #if defined(WITH_JIT) - ldr r3, [rGLUE, #offGlue_ppJitProfTable] @ Refresh Jit's on/off status + ldr r3, [rSELF, #offThread_ppJitProfTable] @ Refresh Jit's on/off status #endif - @ native return; r9=self, r10=newSaveArea + @ native return; r10=newSaveArea @ equivalent to dvmPopJniLocals ldr r0, [r10, #offStackSaveArea_localRefCookie] @ r0<- saved top - ldr r1, [r9, #offThread_exception] @ check for exception + ldr r1, [rSELF, #offThread_exception] @ check for exception #if defined(WITH_JIT) ldr r3, [r3] @ r3 <- gDvmJit.pProfTable #endif - str rFP, [r9, #offThread_curFrame] @ self->curFrame = fp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = fp cmp r1, #0 @ null? - str r0, [r9, #offThread_jniLocal_topCookie] @ new top <- old top + str r0, [rSELF, #offThread_jniLocal_topCookie] @ new top <- old top #if defined(WITH_JIT) - str r3, [rGLUE, #offGlue_pJitProfTable] @ refresh cached on/off switch + str r3, [rSELF, #offThread_pJitProfTable] @ refresh cached on/off switch #endif bne common_exceptionThrown @ no, handle exception @@ -13856,7 +13837,7 @@ dalvik_mterp: .LstackOverflow: @ r0=methodToCall mov r1, r0 @ r1<- methodToCall - ldr r0, [rGLUE, #offGlue_self] @ r0<- self + mov r0, rSELF @ r0<- self bl dvmHandleStackOverflow b common_exceptionThrown #ifdef ASSIST_DEBUGGER @@ -13881,8 +13862,8 @@ dalvik_mterp: sub sp, sp, #8 @ space for args + pad FETCH(ip, 2) @ ip<- FEDC or CCCC mov r2, r0 @ A2<- methodToCall - mov r0, rGLUE @ A0<- glue - SAVE_PC_FP_TO_GLUE() @ export state to "glue" + mov r0, rSELF @ A0<- self + SAVE_PC_FP_TO_SELF() @ export state to "self" mov r1, r9 @ A1<- methodCallRange mov r3, rINST, lsr #8 @ A3<- AA str ip, [sp, #0] @ A4<- ip @@ -13904,7 +13885,7 @@ common_returnFromMethod: mov r9, #0 bl common_periodicChecks - ldr lr, [rGLUE, #offGlue_pInterpBreak] + ldr lr, [rSELF, #offThread_pInterpBreak] SAVEAREA_FROM_FP(r0, rFP) ldr lr, [lr] @ lr<- active submodes ldr r9, [r0, #offStackSaveArea_savedPc] @ r9 = saveArea->savedPc @@ -13912,12 +13893,11 @@ common_returnFromMethod: beq 333f stmfd sp!, {r0-r3} @ preserve r0-r3 mov r0, r6 - @ r0=rGlue + @ r0=rSELF bl dvmFastJavaMethodTraceExit ldmfd sp!, {r0-r3} @ restore r0-r3 333: ldr rFP, [r0, #offStackSaveArea_prevFrame] @ fp = saveArea->prevFrame - ldr r3, [rGLUE, #offGlue_self] @ r3<- glue->self ldr r2, [rFP, #(offStackSaveArea_method - sizeofStackSaveArea)] @ r2<- method we're returning to cmp r2, #0 @ is this a break frame? @@ -13933,14 +13913,14 @@ common_returnFromMethod: beq common_gotoBail @ break frame, bail out completely PREFETCH_ADVANCE_INST(rINST, r9, 3) @ advance r9, update new rINST - str r2, [rGLUE, #offGlue_method]@ glue->method = newSave->method + str r2, [rSELF, #offThread_method]@ self->method = newSave->method ldr r1, [r10, #offClassObject_pDvmDex] @ r1<- method->clazz->pDvmDex - str rFP, [r3, #offThread_curFrame] @ self->curFrame = fp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = fp #if defined(WITH_JIT) ldr r10, [r0, #offStackSaveArea_returnAddr] @ r10 = saveArea->returnAddr mov rPC, r9 @ publish new rPC - str r1, [rGLUE, #offGlue_methodClassDex] - str r10, [r3, #offThread_inJitCodeCache] @ may return to JIT'ed land + str r1, [rSELF, #offThread_methodClassDex] + str r10, [rSELF, #offThread_inJitCodeCache] @ may return to JIT'ed land cmp r10, #0 @ caller is compiled code blxne r10 GET_INST_OPCODE(ip) @ extract opcode from rINST @@ -13948,7 +13928,7 @@ common_returnFromMethod: #else GET_INST_OPCODE(ip) @ extract opcode from rINST mov rPC, r9 @ publish new rPC - str r1, [rGLUE, #offGlue_methodClassDex] + str r1, [rSELF, #offThread_methodClassDex] GOTO_OPCODE(ip) @ jump to next instruction #endif @@ -13957,8 +13937,8 @@ common_returnFromMethod: */ .if 0 .LreturnOld: - SAVE_PC_FP_TO_GLUE() @ export state - mov r0, rGLUE @ arg to function + SAVE_PC_FP_TO_SELF() @ export state + mov r0, rSELF @ arg to function bl dvmMterp_returnFromMethod b common_resumeAfterGlueCall .endif @@ -13981,13 +13961,12 @@ common_exceptionThrown: mov r9, #0 bl common_periodicChecks - ldr r10, [rGLUE, #offGlue_self] @ r10<- glue->self - ldr r9, [r10, #offThread_exception] @ r9<- self->exception - mov r1, r10 @ r1<- self + ldr r9, [rSELF, #offThread_exception] @ r9<- self->exception + mov r1, rSELF @ r1<- self mov r0, r9 @ r0<- exception bl dvmAddTrackedAlloc @ don't let the exception be GCed mov r3, #0 @ r3<- NULL - str r3, [r10, #offThread_exception] @ self->exception = NULL + str r3, [rSELF, #offThread_exception] @ self->exception = NULL /* set up args and a local for "&fp" */ /* (str sp, [sp, #-4]! would be perfect here, but is discouraged) */ @@ -13995,8 +13974,8 @@ common_exceptionThrown: mov ip, sp @ ip<- &fp mov r3, #0 @ r3<- false str ip, [sp, #-4]! @ *--sp = &fp - ldr r1, [rGLUE, #offGlue_method] @ r1<- glue->method - mov r0, r10 @ r0<- self + ldr r1, [rSELF, #offThread_method] @ r1<- self->method + mov r0, rSELF @ r0<- self ldr r1, [r1, #offMethod_insns] @ r1<- method->insns mov r2, r9 @ r2<- exception sub r1, rPC, r1 @ r1<- pc - method->insns @@ -14006,11 +13985,11 @@ common_exceptionThrown: bl dvmFindCatchBlock @ call(self, relPc, exc, scan?, &fp) /* fix earlier stack overflow if necessary; may trash rFP */ - ldrb r1, [r10, #offThread_stackOverflowed] + ldrb r1, [rSELF, #offThread_stackOverflowed] cmp r1, #0 @ did we overflow earlier? beq 1f @ no, skip ahead mov rFP, r0 @ save relPc result in rFP - mov r0, r10 @ r0<- self + mov r0, rSELF @ r0<- self mov r1, r9 @ r1<- exception bl dvmCleanupStackOverflow @ call(self) mov r0, rFP @ restore result @@ -14025,30 +14004,30 @@ common_exceptionThrown: /* adjust locals to match self->curFrame and updated PC */ SAVEAREA_FROM_FP(r1, rFP) @ r1<- new save area ldr r1, [r1, #offStackSaveArea_method] @ r1<- new method - str r1, [rGLUE, #offGlue_method] @ glue->method = new method + str r1, [rSELF, #offThread_method] @ self->method = new method ldr r2, [r1, #offMethod_clazz] @ r2<- method->clazz ldr r3, [r1, #offMethod_insns] @ r3<- method->insns ldr r2, [r2, #offClassObject_pDvmDex] @ r2<- method->clazz->pDvmDex add rPC, r3, r0, asl #1 @ rPC<- method->insns + catchRelPc - str r2, [rGLUE, #offGlue_methodClassDex] @ glue->pDvmDex = meth... + str r2, [rSELF, #offThread_methodClassDex] @ self->pDvmDex = meth... /* release the tracked alloc on the exception */ mov r0, r9 @ r0<- exception - mov r1, r10 @ r1<- self + mov r1, rSELF @ r1<- self bl dvmReleaseTrackedAlloc @ release the exception /* restore the exception if the handler wants it */ FETCH_INST() @ load rINST from rPC GET_INST_OPCODE(ip) @ extract opcode from rINST cmp ip, #OP_MOVE_EXCEPTION @ is it "move-exception"? - streq r9, [r10, #offThread_exception] @ yes, restore the exception + streq r9, [rSELF, #offThread_exception] @ yes, restore the exception GOTO_OPCODE(ip) @ jump to next instruction -.LnotCaughtLocally: @ r9=exception, r10=self +.LnotCaughtLocally: @ r9=exception /* fix stack overflow if necessary */ - ldrb r1, [r10, #offThread_stackOverflowed] + ldrb r1, [rSELF, #offThread_stackOverflowed] cmp r1, #0 @ did we overflow earlier? - movne r0, r10 @ if yes: r0<- self + movne r0, rSELF @ if yes: r0<- self movne r1, r9 @ if yes: r1<- exception blne dvmCleanupStackOverflow @ if yes: call(self) @@ -14057,14 +14036,14 @@ common_exceptionThrown: /* call __android_log_print(prio, tag, format, ...) */ /* "Exception %s from %s:%d not caught locally" */ @ dvmLineNumFromPC(method, pc - method->insns) - ldr r0, [rGLUE, #offGlue_method] + ldr r0, [rSELF, #offThread_method] ldr r1, [r0, #offMethod_insns] sub r1, rPC, r1 asr r1, r1, #1 bl dvmLineNumFromPC str r0, [sp, #-4]! @ dvmGetMethodSourceFile(method) - ldr r0, [rGLUE, #offGlue_method] + ldr r0, [rSELF, #offThread_method] bl dvmGetMethodSourceFile str r0, [sp, #-4]! @ exception->clazz->descriptor @@ -14076,9 +14055,9 @@ common_exceptionThrown: mov r0, #3 @ LOG_DEBUG bl __android_log_print #endif - str r9, [r10, #offThread_exception] @ restore exception + str r9, [rSELF, #offThread_exception] @ restore exception mov r0, r9 @ r0<- exception - mov r1, r10 @ r1<- self + mov r1, rSELF @ r1<- self bl dvmReleaseTrackedAlloc @ release the exception mov r1, #0 @ "want switch" = false b common_gotoBail @ bail out @@ -14089,8 +14068,8 @@ common_exceptionThrown: */ .if 0 .LexceptionOld: - SAVE_PC_FP_TO_GLUE() @ export state - mov r0, rGLUE @ arg to function + SAVE_PC_FP_TO_SELF() @ export state + mov r0, rSELF @ arg to function bl dvmMterp_exceptionThrown b common_resumeAfterGlueCall .endif @@ -14101,7 +14080,7 @@ common_exceptionThrown: * values and start executing at the next instruction. */ common_resumeAfterGlueCall: - LOAD_PC_FP_FROM_GLUE() @ pull rPC and rFP out of glue + LOAD_PC_FP_FROM_SELF() @ pull rPC and rFP out of thread FETCH_INST() @ load rINST from rPC GET_INST_OPCODE(ip) @ extract opcode from rINST GOTO_OPCODE(ip) @ jump to next instruction diff --git a/vm/mterp/out/InterpAsm-armv7-a.S b/vm/mterp/out/InterpAsm-armv7-a.S index f276cd5fb..ad25794b0 100644 --- a/vm/mterp/out/InterpAsm-armv7-a.S +++ b/vm/mterp/out/InterpAsm-armv7-a.S @@ -63,7 +63,7 @@ The following registers have fixed assignments: reg nick purpose r4 rPC interpreted program counter, used for fetching instructions r5 rFP interpreted frame pointer, used for accessing locals and args - r6 rGLUE MterpGlue pointer + r6 rSELF self (Thread) pointer r7 rINST first 16-bit code unit of current instruction r8 rIBASE interpreted instruction base pointer, used for computed goto @@ -75,17 +75,17 @@ unspecified registers or condition codes. /* single-purpose registers, given names for clarity */ #define rPC r4 #define rFP r5 -#define rGLUE r6 +#define rSELF r6 #define rINST r7 #define rIBASE r8 -/* save/restore the PC and/or FP from the glue struct */ -#define LOAD_PC_FROM_GLUE() ldr rPC, [rGLUE, #offGlue_pc] -#define SAVE_PC_TO_GLUE() str rPC, [rGLUE, #offGlue_pc] -#define LOAD_FP_FROM_GLUE() ldr rFP, [rGLUE, #offGlue_fp] -#define SAVE_FP_TO_GLUE() str rFP, [rGLUE, #offGlue_fp] -#define LOAD_PC_FP_FROM_GLUE() ldmia rGLUE, {rPC, rFP} -#define SAVE_PC_FP_TO_GLUE() stmia rGLUE, {rPC, rFP} +/* save/restore the PC and/or FP from the thread struct */ +#define LOAD_PC_FROM_SELF() ldr rPC, [rSELF, #offThread_pc] +#define SAVE_PC_TO_SELF() str rPC, [rSELF, #offThread_pc] +#define LOAD_FP_FROM_SELF() ldr rFP, [rSELF, #offThread_fp] +#define SAVE_FP_TO_SELF() str rFP, [rSELF, #offThread_fp] +#define LOAD_PC_FP_FROM_SELF() ldmia rSELF, {rPC, rFP} +#define SAVE_PC_FP_TO_SELF() stmia rSELF, {rPC, rFP} /* * "export" the PC to the stack frame, f/b/o future exception objects. Must @@ -186,8 +186,8 @@ unspecified registers or condition codes. #define SET_VREG(_reg, _vreg) str _reg, [rFP, _vreg, lsl #2] #if defined(WITH_JIT) -#define GET_JIT_PROF_TABLE(_reg) ldr _reg,[rGLUE,#offGlue_pJitProfTable] -#define GET_JIT_THRESHOLD(_reg) ldr _reg,[rGLUE,#offGlue_jitThreshold] +#define GET_JIT_PROF_TABLE(_reg) ldr _reg,[rSELF,#offThread_pJitProfTable] +#define GET_JIT_THRESHOLD(_reg) ldr _reg,[rSELF,#offThread_jitThreshold] #endif /* @@ -280,7 +280,7 @@ unspecified registers or condition codes. /* * On entry: - * r0 MterpGlue* glue + * r0 Thread* self * * This function returns a boolean "changeInterp" value. The return comes * via a call to dvmMterpStdBail(). @@ -298,29 +298,28 @@ dvmMterpStdRun: MTERP_ENTRY2 /* save stack pointer, add magic word for debuggerd */ - str sp, [r0, #offGlue_bailPtr] @ save SP for eventual return + str sp, [r0, #offThread_bailPtr] @ save SP for eventual return /* set up "named" registers, figure out entry point */ - mov rGLUE, r0 @ set rGLUE - ldr r1, [r0, #offGlue_entryPoint] @ enum is 4 bytes in aapcs-EABI - LOAD_PC_FP_FROM_GLUE() @ load rPC and rFP from "glue" + mov rSELF, r0 @ set rSELF + ldr r1, [r0, #offThread_entryPoint] @ enum is 4 bytes in aapcs-EABI + LOAD_PC_FP_FROM_SELF() @ load rPC and rFP from "thread" adr rIBASE, dvmAsmInstructionStart @ set rIBASE cmp r1, #kInterpEntryInstr @ usual case? bne .Lnot_instr @ no, handle it #if defined(WITH_JIT) .LentryInstr: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self /* Entry is always a possible trace start */ GET_JIT_PROF_TABLE(r0) FETCH_INST() mov r1, #0 @ prepare the value for the new state - str r1, [r10, #offThread_inJitCodeCache] @ back to the interp land + str r1, [rSELF, #offThread_inJitCodeCache] @ back to the interp land cmp r0,#0 @ is profiling disabled? #if !defined(WITH_SELF_VERIFICATION) bne common_updateProfile @ profiling is enabled #else - ldr r2, [r10, #offThread_shadowSpace] @ to find out the jit exit state + ldr r2, [rSELF, #offThread_shadowSpace] @ to find out the jit exit state beq 1f @ profiling is disabled ldr r3, [r2, #offShadowSpace_jitExitState] @ jit exit state cmp r3, #kSVSTraceSelect @ hot trace following? @@ -350,20 +349,20 @@ dvmMterpStdRun: #if defined(WITH_JIT) .Lnot_throw: - ldr r10,[rGLUE, #offGlue_jitResumeNPC] - ldr r2,[rGLUE, #offGlue_jitResumeDPC] + ldr r10,[rSELF, #offThread_jitResumeNPC] + ldr r2,[rSELF, #offThread_jitResumeDPC] cmp r1, #kInterpEntryResume @ resuming after Jit single-step? bne .Lbad_arg cmp rPC,r2 bne .LentryInstr @ must have branched, don't resume #if defined(WITH_SELF_VERIFICATION) - @ glue->entryPoint will be set in dvmSelfVerificationSaveState + @ self->entryPoint will be set in dvmSelfVerificationSaveState b jitSVShadowRunStart @ re-enter the translation after the @ single-stepped instruction @noreturn #endif mov r1, #kInterpEntryInstr - str r1, [rGLUE, #offGlue_entryPoint] + str r1, [rSELF, #offThread_entryPoint] bx r10 @ re-enter the translation #endif @@ -389,11 +388,11 @@ dvmMterpStdRun: * LR to PC. * * On entry: - * r0 MterpGlue* glue + * r0 Thread* self * r1 bool changeInterp */ dvmMterpStdBail: - ldr sp, [r0, #offGlue_bailPtr] @ sp<- saved SP + ldr sp, [r0, #offThread_bailPtr] @ sp<- saved SP mov r0, r1 @ return the changeInterp value add sp, sp, #4 @ un-align 64 ldmfd sp!, {r4-r10,fp,pc} @ restore 9 regs and return @@ -576,7 +575,7 @@ dalvik_inst: /* op vAA */ mov r2, rINST, lsr #8 @ r2<- AA FETCH_ADVANCE_INST(1) @ advance rPC, load rINST - ldr r0, [rGLUE, #offGlue_retval] @ r0<- glue->retval.i + ldr r0, [rSELF, #offThread_retval] @ r0<- self->retval.i GET_INST_OPCODE(ip) @ extract opcode from rINST SET_VREG(r0, r2) @ fp[AA]<- r0 GOTO_OPCODE(ip) @ jump to next instruction @@ -587,7 +586,7 @@ dalvik_inst: /* File: armv5te/OP_MOVE_RESULT_WIDE.S */ /* move-result-wide vAA */ mov r2, rINST, lsr #8 @ r2<- AA - add r3, rGLUE, #offGlue_retval @ r3<- &glue->retval + add r3, rSELF, #offThread_retval @ r3<- &self->retval add r2, rFP, r2, lsl #2 @ r2<- &fp[AA] ldmia r3, {r0-r1} @ r0/r1<- retval.j FETCH_ADVANCE_INST(1) @ advance rPC, load rINST @@ -604,7 +603,7 @@ dalvik_inst: /* op vAA */ mov r2, rINST, lsr #8 @ r2<- AA FETCH_ADVANCE_INST(1) @ advance rPC, load rINST - ldr r0, [rGLUE, #offGlue_retval] @ r0<- glue->retval.i + ldr r0, [rSELF, #offThread_retval] @ r0<- self->retval.i GET_INST_OPCODE(ip) @ extract opcode from rINST SET_VREG(r0, r2) @ fp[AA]<- r0 GOTO_OPCODE(ip) @ jump to next instruction @@ -615,14 +614,13 @@ dalvik_inst: .L_OP_MOVE_EXCEPTION: /* 0x0d */ /* File: armv5te/OP_MOVE_EXCEPTION.S */ /* move-exception vAA */ - ldr r0, [rGLUE, #offGlue_self] @ r0<- glue->self mov r2, rINST, lsr #8 @ r2<- AA - ldr r3, [r0, #offThread_exception] @ r3<- dvmGetException bypass + ldr r3, [rSELF, #offThread_exception] @ r3<- dvmGetException bypass mov r1, #0 @ r1<- 0 FETCH_ADVANCE_INST(1) @ advance rPC, load rINST SET_VREG(r3, r2) @ fp[AA]<- exception obj GET_INST_OPCODE(ip) @ extract opcode from rINST - str r1, [r0, #offThread_exception] @ dvmClearException bypass + str r1, [rSELF, #offThread_exception] @ dvmClearException bypass GOTO_OPCODE(ip) @ jump to next instruction /* ------------------------------ */ @@ -636,7 +634,7 @@ dalvik_inst: .L_OP_RETURN: /* 0x0f */ /* File: armv5te/OP_RETURN.S */ /* - * Return a 32-bit value. Copies the return value into the "glue" + * Return a 32-bit value. Copies the return value into the "thread" * structure, then jumps to the return handler. * * for: return, return-object @@ -644,7 +642,7 @@ dalvik_inst: /* op vAA */ mov r2, rINST, lsr #8 @ r2<- AA GET_VREG(r0, r2) @ r0<- vAA - str r0, [rGLUE, #offGlue_retval] @ retval.i <- vAA + str r0, [rSELF, #offThread_retval] @ retval.i <- vAA b common_returnFromMethod /* ------------------------------ */ @@ -652,13 +650,13 @@ dalvik_inst: .L_OP_RETURN_WIDE: /* 0x10 */ /* File: armv5te/OP_RETURN_WIDE.S */ /* - * Return a 64-bit value. Copies the return value into the "glue" + * Return a 64-bit value. Copies the return value into the "thread" * structure, then jumps to the return handler. */ /* return-wide vAA */ mov r2, rINST, lsr #8 @ r2<- AA add r2, rFP, r2, lsl #2 @ r2<- &fp[AA] - add r3, rGLUE, #offGlue_retval @ r3<- &glue->retval + add r3, rSELF, #offThread_retval @ r3<- &self->retval ldmia r2, {r0-r1} @ r0/r1 <- vAA/vAA+1 stmia r3, {r0-r1} @ retval<- r0/r1 b common_returnFromMethod @@ -669,7 +667,7 @@ dalvik_inst: /* File: armv5te/OP_RETURN_OBJECT.S */ /* File: armv5te/OP_RETURN.S */ /* - * Return a 32-bit value. Copies the return value into the "glue" + * Return a 32-bit value. Copies the return value into the "thread" * structure, then jumps to the return handler. * * for: return, return-object @@ -677,7 +675,7 @@ dalvik_inst: /* op vAA */ mov r2, rINST, lsr #8 @ r2<- AA GET_VREG(r0, r2) @ r0<- vAA - str r0, [rGLUE, #offGlue_retval] @ retval.i <- vAA + str r0, [rSELF, #offThread_retval] @ retval.i <- vAA b common_returnFromMethod @@ -802,7 +800,7 @@ dalvik_inst: /* File: armv5te/OP_CONST_STRING.S */ /* const/string vAA, String@BBBB */ FETCH(r1, 1) @ r1<- BBBB - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- glue->methodClassDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- self->methodClassDex mov r9, rINST, lsr #8 @ r9<- AA ldr r2, [r2, #offDvmDex_pResStrings] @ r2<- dvmDex->pResStrings ldr r0, [r2, r1, lsl #2] @ r0<- pResStrings[BBBB] @@ -820,7 +818,7 @@ dalvik_inst: /* const/string vAA, String@BBBBBBBB */ FETCH(r0, 1) @ r0<- bbbb (low) FETCH(r1, 2) @ r1<- BBBB (high) - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- glue->methodClassDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- self->methodClassDex mov r9, rINST, lsr #8 @ r9<- AA ldr r2, [r2, #offDvmDex_pResStrings] @ r2<- dvmDex->pResStrings orr r1, r0, r1, lsl #16 @ r1<- BBBBbbbb @@ -838,7 +836,7 @@ dalvik_inst: /* File: armv5te/OP_CONST_CLASS.S */ /* const/class vAA, Class@BBBB */ FETCH(r1, 1) @ r1<- BBBB - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- glue->methodClassDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- self->methodClassDex mov r9, rINST, lsr #8 @ r9<- AA ldr r2, [r2, #offDvmDex_pResClasses] @ r2<- dvmDex->pResClasses ldr r0, [r2, r1, lsl #2] @ r0<- pResClasses[BBBB] @@ -859,7 +857,7 @@ dalvik_inst: /* monitor-enter vAA */ mov r2, rINST, lsr #8 @ r2<- AA GET_VREG(r1, r2) @ r1<- vAA (object) - ldr r0, [rGLUE, #offGlue_self] @ r0<- glue->self + mov r0, rSELF @ r0<- self cmp r1, #0 @ null object? EXPORT_PC() @ need for precise GC beq common_errNullObject @ null object, throw an exception @@ -885,7 +883,7 @@ dalvik_inst: GET_VREG(r1, r2) @ r1<- vAA (object) cmp r1, #0 @ null object? beq 1f @ yes - ldr r0, [rGLUE, #offGlue_self] @ r0<- glue->self + mov r0, rSELF @ r0<- self bl dvmUnlockObject @ r0<- success for unlock(self, obj) cmp r0, #0 @ failed? FETCH_ADVANCE_INST(1) @ before throw: advance rPC, load rINST @@ -907,7 +905,7 @@ dalvik_inst: mov r3, rINST, lsr #8 @ r3<- AA FETCH(r2, 1) @ r2<- BBBB GET_VREG(r9, r3) @ r9<- object - ldr r0, [rGLUE, #offGlue_methodClassDex] @ r0<- pDvmDex + ldr r0, [rSELF, #offThread_methodClassDex] @ r0<- pDvmDex cmp r9, #0 @ is object null? ldr r0, [r0, #offDvmDex_pResClasses] @ r0<- pDvmDex->pResClasses beq .LOP_CHECK_CAST_okay @ null obj, cast always succeeds @@ -939,7 +937,7 @@ dalvik_inst: GET_VREG(r0, r3) @ r0<- vB (object) and r9, r9, #15 @ r9<- A cmp r0, #0 @ is object null? - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- pDvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- pDvmDex beq .LOP_INSTANCE_OF_store @ null obj, not an instance, store r0 FETCH(r3, 1) @ r3<- CCCC ldr r2, [r2, #offDvmDex_pResClasses] @ r2<- pDvmDex->pResClasses @@ -978,7 +976,7 @@ dalvik_inst: * Create a new instance of a class. */ /* new-instance vAA, class@BBBB */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r1, 1) @ r1<- BBBB ldr r3, [r3, #offDvmDex_pResClasses] @ r3<- pDvmDex->pResClasses ldr r0, [r3, r1, lsl #2] @ r0<- resolved class @@ -1008,7 +1006,7 @@ dalvik_inst: /* new-array vA, vB, class@CCCC */ mov r0, rINST, lsr #12 @ r0<- B FETCH(r2, 1) @ r2<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex GET_VREG(r1, r0) @ r1<- vB (array length) ldr r3, [r3, #offDvmDex_pResClasses] @ r3<- pDvmDex->pResClasses cmp r1, #0 @ check length @@ -1030,7 +1028,7 @@ dalvik_inst: */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op {vCCCC..v(CCCC+AA-1)}, type@BBBB */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r1, 1) @ r1<- BBBB ldr r3, [r3, #offDvmDex_pResClasses] @ r3<- pDvmDex->pResClasses EXPORT_PC() @ need for resolve and alloc @@ -1038,7 +1036,7 @@ dalvik_inst: mov r10, rINST, lsr #8 @ r10<- AA or BA cmp r0, #0 @ already resolved? bne .LOP_FILLED_NEW_ARRAY_continue @ yes, continue on -8: ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method +8: ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r2, #0 @ r2<- false ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveClass @ r0<- call(clazz, ref) @@ -1058,7 +1056,7 @@ dalvik_inst: */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op {vCCCC..v(CCCC+AA-1)}, type@BBBB */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r1, 1) @ r1<- BBBB ldr r3, [r3, #offDvmDex_pResClasses] @ r3<- pDvmDex->pResClasses EXPORT_PC() @ need for resolve and alloc @@ -1066,7 +1064,7 @@ dalvik_inst: mov r10, rINST, lsr #8 @ r10<- AA or BA cmp r0, #0 @ already resolved? bne .LOP_FILLED_NEW_ARRAY_RANGE_continue @ yes, continue on -8: ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method +8: ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r2, #0 @ r2<- false ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveClass @ r0<- call(clazz, ref) @@ -1104,12 +1102,11 @@ dalvik_inst: /* throw vAA */ mov r2, rINST, lsr #8 @ r2<- AA GET_VREG(r1, r2) @ r1<- vAA (exception object) - ldr r0, [rGLUE, #offGlue_self] @ r0<- glue->self EXPORT_PC() @ exception handler can throw cmp r1, #0 @ null object? beq common_errNullObject @ yes, throw an NPE instead @ bypass dvmSetException, just store it - str r1, [r0, #offThread_exception] @ thread->exception<- obj + str r1, [rSELF, #offThread_exception] @ thread->exception<- obj b common_exceptionThrown /* ------------------------------ */ @@ -2387,14 +2384,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2411,14 +2408,14 @@ dalvik_inst: */ /* iget-wide vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_WIDE_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2438,14 +2435,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_OBJECT_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2467,14 +2464,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_BOOLEAN_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2496,14 +2493,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_BYTE_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2525,14 +2522,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_CHAR_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2554,14 +2551,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_SHORT_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2581,14 +2578,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2602,14 +2599,14 @@ dalvik_inst: /* File: armv6t2/OP_IPUT_WIDE.S */ /* iput-wide vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_WIDE_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2628,14 +2625,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_OBJECT_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2656,14 +2653,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_BOOLEAN_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2685,14 +2682,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_BYTE_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2714,14 +2711,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_CHAR_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2743,14 +2740,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_SHORT_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -2769,7 +2766,7 @@ dalvik_inst: * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -2792,7 +2789,7 @@ dalvik_inst: * 64-bit SGET handler. */ /* sget-wide vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -2823,7 +2820,7 @@ dalvik_inst: * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -2850,7 +2847,7 @@ dalvik_inst: * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -2877,7 +2874,7 @@ dalvik_inst: * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -2904,7 +2901,7 @@ dalvik_inst: * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -2931,7 +2928,7 @@ dalvik_inst: * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -2957,7 +2954,7 @@ dalvik_inst: * for: sput, sput-boolean, sput-byte, sput-char, sput-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -2980,7 +2977,7 @@ dalvik_inst: * 64-bit SPUT handler. */ /* sput-wide vAA, field@BBBB */ - ldr r0, [rGLUE, #offGlue_methodClassDex] @ r0<- DvmDex + ldr r0, [rSELF, #offThread_methodClassDex] @ r0<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r0, [r0, #offDvmDex_pResFields] @ r0<- dvmDex->pResFields mov r9, rINST, lsr #8 @ r9<- AA @@ -3010,13 +3007,13 @@ dalvik_inst: * for: sput-object, sput-object-volatile */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_SPUT_OBJECT_finish @ no, continue - ldr r9, [rGLUE, #offGlue_method] @ r9<- current method + ldr r9, [rSELF, #offThread_method] @ r9<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r9, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -3036,7 +3033,7 @@ dalvik_inst: * for: sput, sput-boolean, sput-byte, sput-char, sput-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -3063,7 +3060,7 @@ dalvik_inst: * for: sput, sput-boolean, sput-byte, sput-char, sput-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -3090,7 +3087,7 @@ dalvik_inst: * for: sput, sput-boolean, sput-byte, sput-char, sput-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -3117,7 +3114,7 @@ dalvik_inst: * for: sput, sput-boolean, sput-byte, sput-char, sput-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -3144,7 +3141,7 @@ dalvik_inst: */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r1, 1) @ r1<- BBBB ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods FETCH(r10, 2) @ r10<- GFED or CCCC @@ -3155,7 +3152,7 @@ dalvik_inst: cmp r0, #0 @ already resolved? EXPORT_PC() @ must export for invoke bne .LOP_INVOKE_VIRTUAL_continue @ yes, continue on - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_VIRTUAL @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) @@ -3175,7 +3172,7 @@ dalvik_inst: /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ FETCH(r10, 2) @ r10<- GFED or CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex .if (!0) and r10, r10, #15 @ r10<- D (or stays CCCC) .endif @@ -3184,7 +3181,7 @@ dalvik_inst: GET_VREG(r2, r10) @ r2<- "this" ptr ldr r0, [r3, r1, lsl #2] @ r0<- resolved baseMethod cmp r2, #0 @ null "this"? - ldr r9, [rGLUE, #offGlue_method] @ r9<- current method + ldr r9, [rSELF, #offThread_method] @ r9<- current method beq common_errNullObject @ null "this", throw exception cmp r0, #0 @ already resolved? ldr r9, [r9, #offMethod_clazz] @ r9<- method->clazz @@ -3208,7 +3205,7 @@ dalvik_inst: */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r1, 1) @ r1<- BBBB ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods FETCH(r10, 2) @ r10<- GFED or CCCC @@ -3236,14 +3233,14 @@ dalvik_inst: */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r1, 1) @ r1<- BBBB ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods ldr r0, [r3, r1, lsl #2] @ r0<- resolved methodToCall cmp r0, #0 @ already resolved? EXPORT_PC() @ must export for invoke bne common_invokeMethodNoRange @ yes, continue on -0: ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method +0: ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_STATIC @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) @@ -3269,9 +3266,9 @@ dalvik_inst: .endif EXPORT_PC() @ must export for invoke GET_VREG(r0, r2) @ r0<- first arg ("this") - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- methodClassDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- methodClassDex cmp r0, #0 @ null obj? - ldr r2, [rGLUE, #offGlue_method] @ r2<- method + ldr r2, [rSELF, #offThread_method] @ r2<- method beq common_errNullObject @ yes, fail ldr r0, [r0, #offObject_clazz] @ r0<- thisPtr->clazz bl dvmFindInterfaceMethodInCache @ r0<- call(class, ref, method, dex) @@ -3299,7 +3296,7 @@ dalvik_inst: */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r1, 1) @ r1<- BBBB ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods FETCH(r10, 2) @ r10<- GFED or CCCC @@ -3310,7 +3307,7 @@ dalvik_inst: cmp r0, #0 @ already resolved? EXPORT_PC() @ must export for invoke bne .LOP_INVOKE_VIRTUAL_RANGE_continue @ yes, continue on - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_VIRTUAL @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) @@ -3332,7 +3329,7 @@ dalvik_inst: /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ FETCH(r10, 2) @ r10<- GFED or CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex .if (!1) and r10, r10, #15 @ r10<- D (or stays CCCC) .endif @@ -3341,7 +3338,7 @@ dalvik_inst: GET_VREG(r2, r10) @ r2<- "this" ptr ldr r0, [r3, r1, lsl #2] @ r0<- resolved baseMethod cmp r2, #0 @ null "this"? - ldr r9, [rGLUE, #offGlue_method] @ r9<- current method + ldr r9, [rSELF, #offThread_method] @ r9<- current method beq common_errNullObject @ null "this", throw exception cmp r0, #0 @ already resolved? ldr r9, [r9, #offMethod_clazz] @ r9<- method->clazz @@ -3367,7 +3364,7 @@ dalvik_inst: */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r1, 1) @ r1<- BBBB ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods FETCH(r10, 2) @ r10<- GFED or CCCC @@ -3397,14 +3394,14 @@ dalvik_inst: */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r1, 1) @ r1<- BBBB ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods ldr r0, [r3, r1, lsl #2] @ r0<- resolved methodToCall cmp r0, #0 @ already resolved? EXPORT_PC() @ must export for invoke bne common_invokeMethodRange @ yes, continue on -0: ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method +0: ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_STATIC @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) @@ -3432,9 +3429,9 @@ dalvik_inst: .endif EXPORT_PC() @ must export for invoke GET_VREG(r0, r2) @ r0<- first arg ("this") - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- methodClassDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- methodClassDex cmp r0, #0 @ null obj? - ldr r2, [rGLUE, #offGlue_method] @ r2<- method + ldr r2, [rSELF, #offThread_method] @ r2<- method beq common_errNullObject @ yes, fail ldr r0, [r0, #offObject_clazz] @ r0<- thisPtr->clazz bl dvmFindInterfaceMethodInCache @ r0<- call(class, ref, method, dex) @@ -7046,14 +7043,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_VOLATILE_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -7074,14 +7071,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_VOLATILE_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -7101,7 +7098,7 @@ dalvik_inst: * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -7128,7 +7125,7 @@ dalvik_inst: * for: sput, sput-boolean, sput-byte, sput-char, sput-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -7156,14 +7153,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_OBJECT_VOLATILE_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -7182,14 +7179,14 @@ dalvik_inst: */ /* iget-wide vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_WIDE_VOLATILE_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -7205,14 +7202,14 @@ dalvik_inst: /* File: armv5te/OP_IPUT_WIDE.S */ /* iput-wide vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_WIDE_VOLATILE_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -7230,7 +7227,7 @@ dalvik_inst: * 64-bit SGET handler. */ /* sget-wide vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -7260,7 +7257,7 @@ dalvik_inst: * 64-bit SPUT handler. */ /* sput-wide vAA, field@BBBB */ - ldr r0, [rGLUE, #offGlue_methodClassDex] @ r0<- DvmDex + ldr r0, [rSELF, #offThread_methodClassDex] @ r0<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r0, [r0, #offDvmDex_pResFields] @ r0<- dvmDex->pResFields mov r9, rINST, lsr #8 @ r9<- AA @@ -7299,7 +7296,7 @@ dalvik_inst: * exception is indicated by AA, with some detail provided by BBBB. */ /* op AA, ref@BBBB */ - ldr r0, [rGLUE, #offGlue_method] @ r0<- glue->method + ldr r0, [rSELF, #offThread_method] @ r0<- self->method FETCH(r2, 1) @ r2<- BBBB EXPORT_PC() @ export the PC mov r1, rINST, lsr #8 @ r1<- AA @@ -7322,11 +7319,11 @@ dalvik_inst: */ /* [opt] execute-inline vAA, {vC, vD, vE, vF}, inline@BBBB */ FETCH(r10, 1) @ r10<- BBBB - add r1, rGLUE, #offGlue_retval @ r1<- &glue->retval + add r1, rSELF, #offThread_retval @ r1<- &self->retval EXPORT_PC() @ can throw sub sp, sp, #8 @ make room for arg, +64 bit align mov r0, rINST, lsr #12 @ r0<- B - str r1, [sp] @ push &glue->retval + str r1, [sp] @ push &self->retval bl .LOP_EXECUTE_INLINE_continue @ make call; will return after add sp, sp, #8 @ pop stack cmp r0, #0 @ test boolean result of inline @@ -7352,11 +7349,11 @@ dalvik_inst: */ /* [opt] execute-inline/range {vCCCC..v(CCCC+AA-1)}, inline@BBBB */ FETCH(r10, 1) @ r10<- BBBB - add r1, rGLUE, #offGlue_retval @ r1<- &glue->retval + add r1, rSELF, #offThread_retval @ r1<- &self->retval EXPORT_PC() @ can throw sub sp, sp, #8 @ make room for arg, +64 bit align mov r0, rINST, lsr #8 @ r0<- AA - str r1, [sp] @ push &glue->retval + str r1, [sp] @ push &self->retval bl .LOP_EXECUTE_INLINE_RANGE_continue @ make call; will return after add sp, sp, #8 @ pop stack cmp r0, #0 @ test boolean result of inline @@ -7502,7 +7499,7 @@ dalvik_inst: beq common_errNullObject @ object was null and r2, r2, #15 GET_VREG(r0, r2) @ r0<- fp[A] - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base FETCH_ADVANCE_INST(2) @ advance rPC, load rINST str r0, [r3, r1] @ obj.field (always 32 bits)<- r0 cmp r0, #0 @@ -7574,7 +7571,7 @@ dalvik_inst: /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ FETCH(r10, 2) @ r10<- GFED or CCCC - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method .if (!0) and r10, r10, #15 @ r10<- D (or stays CCCC) .endif @@ -7602,7 +7599,7 @@ dalvik_inst: /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ FETCH(r10, 2) @ r10<- GFED or CCCC - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method .if (!1) and r10, r10, #15 @ r10<- D (or stays CCCC) .endif @@ -7630,14 +7627,14 @@ dalvik_inst: */ /* op vA, vB, field@CCCC */ mov r0, rINST, lsr #12 @ r0<- B - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex FETCH(r1, 1) @ r1<- field ref CCCC ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_OBJECT_VOLATILE_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -7657,7 +7654,7 @@ dalvik_inst: * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr @@ -7684,13 +7681,13 @@ dalvik_inst: * for: sput-object, sput-object-volatile */ /* op vAA, field@BBBB */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r1, 1) @ r1<- field ref BBBB ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_SPUT_OBJECT_VOLATILE_finish @ no, continue - ldr r9, [rGLUE, #offGlue_method] @ r9<- current method + ldr r9, [rSELF, #offThread_method] @ r9<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r9, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -7715,7 +7712,7 @@ dalvik_inst: /* File: armv5te/OP_CONST_CLASS_JUMBO.S */ /* const-class/jumbo vBBBB, Class@AAAAAAAA */ FETCH(r0, 1) @ r0<- aaaa (lo) - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- glue->methodClassDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<-self>methodClassDex FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResClasses] @ r2<- dvmDex->pResClasses orr r1, r0, r1, lsl #16 @ r1<- AAAAaaaa @@ -7741,7 +7738,7 @@ dalvik_inst: FETCH(r3, 3) @ r3<- BBBB orr r2, r0, r2, lsl #16 @ r2<- AAAAaaaa GET_VREG(r9, r3) @ r9<- object - ldr r0, [rGLUE, #offGlue_methodClassDex] @ r0<- pDvmDex + ldr r0, [rSELF, #offThread_methodClassDex] @ r0<- pDvmDex cmp r9, #0 @ is object null? ldr r0, [r0, #offDvmDex_pResClasses] @ r0<- pDvmDex->pResClasses beq .LOP_CHECK_CAST_JUMBO_okay @ null obj, cast always succeeds @@ -7771,7 +7768,7 @@ dalvik_inst: FETCH(r3, 4) @ r3<- vCCCC FETCH(r9, 3) @ r9<- vBBBB GET_VREG(r0, r3) @ r0<- vCCCC (object) - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- pDvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- pDvmDex cmp r0, #0 @ is object null? beq .LOP_INSTANCE_OF_JUMBO_store @ null obj, not an instance, store r0 FETCH(r1, 1) @ r1<- aaaa (lo) @@ -7794,7 +7791,7 @@ dalvik_inst: /* new-instance/jumbo vBBBB, class@AAAAAAAA */ FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex orr r1, r0, r1, lsl #16 @ r1<- AAAAaaaa ldr r3, [r3, #offDvmDex_pResClasses] @ r3<- pDvmDex->pResClasses ldr r0, [r3, r1, lsl #2] @ r0<- resolved class @@ -7826,7 +7823,7 @@ dalvik_inst: FETCH(r3, 2) @ r3<- AAAA (hi) FETCH(r0, 4) @ r0<- vCCCC orr r2, r2, r3, lsl #16 @ r2<- AAAAaaaa - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex GET_VREG(r1, r0) @ r1<- vCCCC (array length) ldr r3, [r3, #offDvmDex_pResClasses] @ r3<- pDvmDex->pResClasses cmp r1, #0 @ check length @@ -7848,7 +7845,7 @@ dalvik_inst: * OP_FILLED_NEW_ARRAY.S. */ /* filled-new-array/jumbo {vCCCC..v(CCCC+BBBB-1)}, type@AAAAAAAA */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r3, [r3, #offDvmDex_pResClasses] @ r3<- pDvmDex->pResClasses @@ -7857,7 +7854,7 @@ dalvik_inst: EXPORT_PC() @ need for resolve and alloc cmp r0, #0 @ already resolved? bne .LOP_FILLED_NEW_ARRAY_JUMBO_continue @ yes, continue on -8: ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method +8: ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r2, #0 @ r2<- false ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveClass @ r0<- call(clazz, ref) @@ -7879,14 +7876,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -7903,14 +7900,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_WIDE_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -7931,14 +7928,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_OBJECT_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -7961,14 +7958,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_BOOLEAN_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -7991,14 +7988,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_BYTE_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8021,14 +8018,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_CHAR_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8051,14 +8048,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IGET_SHORT_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8079,14 +8076,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8100,14 +8097,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pResFields GET_VREG(r9, r0) @ r9<- fp[B], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_WIDE_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8124,14 +8121,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_OBJECT_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8153,14 +8150,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_BOOLEAN_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8183,14 +8180,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_BYTE_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8213,14 +8210,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_CHAR_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8243,14 +8240,14 @@ dalvik_inst: FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) FETCH(r0, 4) @ r0<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- DvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- DvmDex orr r1, r1, r2, lsl #16 @ r1<- AAAAaaaa ldr r2, [r3, #offDvmDex_pResFields] @ r2<- pDvmDex->pResFields GET_VREG(r9, r0) @ r9<- fp[CCCC], the object pointer ldr r0, [r2, r1, lsl #2] @ r0<- resolved InstField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_IPUT_SHORT_JUMBO_finish @ no, already resolved -8: ldr r2, [rGLUE, #offGlue_method] @ r2<- current method +8: ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveInstField @ r0<- resolved InstField ptr @@ -8268,7 +8265,7 @@ dalvik_inst: * sget-char/jumbo, sget-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8293,7 +8290,7 @@ dalvik_inst: * Jumbo 64-bit SGET handler. */ /* sget-wide/jumbo vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8322,7 +8319,7 @@ dalvik_inst: * sget-char/jumbo, sget-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8352,7 +8349,7 @@ dalvik_inst: * sget-char/jumbo, sget-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8382,7 +8379,7 @@ dalvik_inst: * sget-char/jumbo, sget-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8412,7 +8409,7 @@ dalvik_inst: * sget-char/jumbo, sget-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8442,7 +8439,7 @@ dalvik_inst: * sget-char/jumbo, sget-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8471,7 +8468,7 @@ dalvik_inst: * sput-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8496,7 +8493,7 @@ dalvik_inst: * Jumbo 64-bit SPUT handler. */ /* sput-wide/jumbo vBBBB, field@AAAAAAAA */ - ldr r0, [rGLUE, #offGlue_methodClassDex] @ r0<- DvmDex + ldr r0, [rSELF, #offThread_methodClassDex] @ r0<- DvmDex FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) ldr r0, [r0, #offDvmDex_pResFields] @ r0<- dvmDex->pResFields @@ -8521,7 +8518,7 @@ dalvik_inst: * Jumbo 32-bit SPUT handler for objects */ /* sput-object/jumbo vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8529,7 +8526,7 @@ dalvik_inst: ldr r0, [r2, r1, lsl #2] @ r0<- resolved StaticField ptr cmp r0, #0 @ is resolved entry null? bne .LOP_SPUT_OBJECT_JUMBO_finish @ no, continue - ldr r9, [rGLUE, #offGlue_method] @ r9<- current method + ldr r9, [rSELF, #offThread_method] @ r9<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r9, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -8549,7 +8546,7 @@ dalvik_inst: * sput-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8579,7 +8576,7 @@ dalvik_inst: * sput-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8609,7 +8606,7 @@ dalvik_inst: * sput-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8639,7 +8636,7 @@ dalvik_inst: * sput-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - ldr r2, [rGLUE, #offGlue_methodClassDex] @ r2<- DvmDex + ldr r2, [rSELF, #offThread_methodClassDex] @ r2<- DvmDex FETCH(r0, 1) @ r0<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r2, [r2, #offDvmDex_pResFields] @ r2<- dvmDex->pResFields @@ -8665,7 +8662,7 @@ dalvik_inst: * Handle a virtual method call. */ /* invoke-virtual/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r0, 1) @ r1<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods @@ -8674,7 +8671,7 @@ dalvik_inst: cmp r0, #0 @ already resolved? EXPORT_PC() @ must export for invoke bne .LOP_INVOKE_VIRTUAL_JUMBO_continue @ yes, continue on - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_VIRTUAL @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) @@ -8691,7 +8688,7 @@ dalvik_inst: */ /* invoke-super/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ FETCH(r10, 4) @ r10<- CCCC - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r0, 1) @ r1<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods @@ -8699,7 +8696,7 @@ dalvik_inst: GET_VREG(r2, r10) @ r2<- "this" ptr ldr r0, [r3, r1, lsl #2] @ r0<- resolved baseMethod cmp r2, #0 @ null "this"? - ldr r9, [rGLUE, #offGlue_method] @ r9<- current method + ldr r9, [rSELF, #offThread_method] @ r9<- current method beq common_errNullObject @ null "this", throw exception cmp r0, #0 @ already resolved? ldr r9, [r9, #offMethod_clazz] @ r9<- method->clazz @@ -8721,7 +8718,7 @@ dalvik_inst: * */ /* invoke-direct/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r0, 1) @ r1<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods @@ -8745,7 +8742,7 @@ dalvik_inst: * Handle a static method call. */ /* invoke-static/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- pDvmDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- pDvmDex FETCH(r0, 1) @ r1<- aaaa (lo) FETCH(r1, 2) @ r1<- AAAA (hi) ldr r3, [r3, #offDvmDex_pResMethods] @ r3<- pDvmDex->pResMethods @@ -8754,7 +8751,7 @@ dalvik_inst: cmp r0, #0 @ already resolved? EXPORT_PC() @ must export for invoke bne common_invokeMethodJumbo @ yes, continue on -0: ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method +0: ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_STATIC @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) @@ -8776,9 +8773,9 @@ dalvik_inst: EXPORT_PC() @ must export for invoke orr r1, r0, r1, lsl #16 @ r1<- AAAAaaaa GET_VREG(r0, r2) @ r0<- first arg ("this") - ldr r3, [rGLUE, #offGlue_methodClassDex] @ r3<- methodClassDex + ldr r3, [rSELF, #offThread_methodClassDex] @ r3<- methodClassDex cmp r0, #0 @ null obj? - ldr r2, [rGLUE, #offGlue_method] @ r2<- method + ldr r2, [rSELF, #offThread_method] @ r2<- method beq common_errNullObject @ yes, fail ldr r0, [r0, #offObject_clazz] @ r0<- thisPtr->clazz bl dvmFindInterfaceMethodInCache @ r0<- call(class, ref, method, dex) @@ -10526,7 +10523,7 @@ dalvik_inst: /* exop BBBB, Class@AAAAAAAA */ FETCH(r1, 1) @ r1<- aaaa (lo) FETCH(r2, 2) @ r2<- AAAA (hi) - ldr r0, [rGLUE, #offGlue_method] @ r0<- glue->method + ldr r0, [rSELF, #offThread_method] @ r0<- self->method orr r2, r1, r2, lsl #16 @ r2<- AAAAaaaa EXPORT_PC() @ export the PC FETCH(r1, 3) @ r1<- BBBB @@ -10559,7 +10556,7 @@ dvmAsmSisterStart: */ .LOP_CONST_STRING_resolve: EXPORT_PC() - ldr r0, [rGLUE, #offGlue_method] @ r0<- glue->method + ldr r0, [rSELF, #offThread_method] @ r0<- self->method ldr r0, [r0, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveString @ r0<- String reference cmp r0, #0 @ failed? @@ -10578,7 +10575,7 @@ dvmAsmSisterStart: */ .LOP_CONST_STRING_JUMBO_resolve: EXPORT_PC() - ldr r0, [rGLUE, #offGlue_method] @ r0<- glue->method + ldr r0, [rSELF, #offThread_method] @ r0<- self->method ldr r0, [r0, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveString @ r0<- String reference cmp r0, #0 @ failed? @@ -10597,7 +10594,7 @@ dvmAsmSisterStart: */ .LOP_CONST_CLASS_resolve: EXPORT_PC() - ldr r0, [rGLUE, #offGlue_method] @ r0<- glue->method + ldr r0, [rSELF, #offThread_method] @ r0<- self->method mov r2, #1 @ r2<- true ldr r0, [r0, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveClass @ r0<- Class reference @@ -10637,7 +10634,7 @@ dvmAsmSisterStart: */ .LOP_CHECK_CAST_resolve: EXPORT_PC() @ resolve() could throw - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r1, r2 @ r1<- BBBB mov r2, #0 @ r2<- false ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz @@ -10690,7 +10687,7 @@ dvmAsmSisterStart: */ .LOP_INSTANCE_OF_resolve: EXPORT_PC() @ resolve() could throw - ldr r0, [rGLUE, #offGlue_method] @ r0<- glue->method + ldr r0, [rSELF, #offThread_method] @ r0<- self->method mov r1, r3 @ r1<- BBBB mov r2, #1 @ r2<- true ldr r0, [r0, #offMethod_clazz] @ r0<- method->clazz @@ -10734,7 +10731,7 @@ dvmAsmSisterStart: * r1 holds BBBB */ .LOP_NEW_INSTANCE_resolve: - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r2, #0 @ r2<- false ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveClass @ r0<- resolved ClassObject ptr @@ -10755,7 +10752,7 @@ dvmAsmSisterStart: * r2 holds class ref CCCC */ .LOP_NEW_ARRAY_resolve: - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r9, r1 @ r9<- length (save) mov r1, r2 @ r1<- CCCC mov r2, #0 @ r2<- false @@ -10810,8 +10807,8 @@ dvmAsmSisterStart: beq common_exceptionThrown @ alloc failed, handle exception FETCH(r1, 2) @ r1<- FEDC or CCCC - str r0, [rGLUE, #offGlue_retval] @ retval.l <- new array - str rINST, [rGLUE, #offGlue_retval+4] @ retval.h <- type + str r0, [rSELF, #offThread_retval] @ retval.l <- new array + str rINST, [rSELF, #offThread_retval+4] @ retval.h <- type add r0, r0, #offArrayObject_contents @ r0<- newArray->contents subs r9, r9, #1 @ length--, check for neg FETCH_ADVANCE_INST(3) @ advance to next instr, load rINST @@ -10843,9 +10840,9 @@ dvmAsmSisterStart: .endif 2: - ldr r0, [rGLUE, #offGlue_retval] @ r0<- object - ldr r1, [rGLUE, #offGlue_retval+4] @ r1<- type - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r0, [rSELF, #offThread_retval] @ r0<- object + ldr r1, [rSELF, #offThread_retval+4] @ r1<- type + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base GET_INST_OPCODE(ip) @ ip<- opcode from rINST cmp r1, #'I' @ Is int array? strneb r2, [r2, r0, lsr #GC_CARD_SHIFT] @ Mark card based on object head @@ -10894,8 +10891,8 @@ dvmAsmSisterStart: beq common_exceptionThrown @ alloc failed, handle exception FETCH(r1, 2) @ r1<- FEDC or CCCC - str r0, [rGLUE, #offGlue_retval] @ retval.l <- new array - str rINST, [rGLUE, #offGlue_retval+4] @ retval.h <- type + str r0, [rSELF, #offThread_retval] @ retval.l <- new array + str rINST, [rSELF, #offThread_retval+4] @ retval.h <- type add r0, r0, #offArrayObject_contents @ r0<- newArray->contents subs r9, r9, #1 @ length--, check for neg FETCH_ADVANCE_INST(3) @ advance to next instr, load rINST @@ -10927,9 +10924,9 @@ dvmAsmSisterStart: .endif 2: - ldr r0, [rGLUE, #offGlue_retval] @ r0<- object - ldr r1, [rGLUE, #offGlue_retval+4] @ r1<- type - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r0, [rSELF, #offThread_retval] @ r0<- object + ldr r1, [rSELF, #offThread_retval+4] @ r1<- type + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base GET_INST_OPCODE(ip) @ ip<- opcode from rINST cmp r1, #'I' @ Is int array? strneb r2, [r2, r0, lsr #GC_CARD_SHIFT] @ Mark card based on object head @@ -11029,7 +11026,7 @@ dvmAsmSisterStart: beq .LOP_APUT_OBJECT_throw @ no mov r1, rINST @ r1<- arrayObj FETCH_ADVANCE_INST(2) @ advance rPC, load rINST - ldr r2, [rGLUE, #offGlue_cardTable] @ get biased CT base + ldr r2, [rSELF, #offThread_cardTable] @ get biased CT base add r10, #offArrayObject_contents @ r0<- pointer to slot GET_INST_OPCODE(ip) @ extract opcode from rINST str r9, [r10] @ vBB[vCC]<- vAA @@ -11243,7 +11240,7 @@ dvmAsmSisterStart: and r1, r1, #15 @ r1<- A cmp r9, #0 @ check object for null GET_VREG(r0, r1) @ r0<- fp[A] - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base beq common_errNullObject @ object was null FETCH_ADVANCE_INST(2) @ advance rPC, load rINST GET_INST_OPCODE(ip) @ extract opcode from rINST @@ -11344,7 +11341,7 @@ dvmAsmSisterStart: * r1: BBBB field ref */ .LOP_SGET_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11361,7 +11358,7 @@ dvmAsmSisterStart: * Returns StaticField pointer in r0. */ .LOP_SGET_WIDE_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11376,7 +11373,7 @@ dvmAsmSisterStart: * r1: BBBB field ref */ .LOP_SGET_OBJECT_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11391,7 +11388,7 @@ dvmAsmSisterStart: * r1: BBBB field ref */ .LOP_SGET_BOOLEAN_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11406,7 +11403,7 @@ dvmAsmSisterStart: * r1: BBBB field ref */ .LOP_SGET_BYTE_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11421,7 +11418,7 @@ dvmAsmSisterStart: * r1: BBBB field ref */ .LOP_SGET_CHAR_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11436,7 +11433,7 @@ dvmAsmSisterStart: * r1: BBBB field ref */ .LOP_SGET_SHORT_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11451,7 +11448,7 @@ dvmAsmSisterStart: * r1: BBBB field ref */ .LOP_SPUT_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11469,7 +11466,7 @@ dvmAsmSisterStart: * Returns StaticField pointer in r2. */ .LOP_SPUT_WIDE_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11483,7 +11480,7 @@ dvmAsmSisterStart: mov r2, rINST, lsr #8 @ r2<- AA FETCH_ADVANCE_INST(2) @ advance rPC, load rINST GET_VREG(r1, r2) @ r1<- fp[AA] - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base ldr r9, [r0, #offField_clazz] @ r9<- field->clazz GET_INST_OPCODE(ip) @ extract opcode from rINST @ no-op @ releasing store @@ -11499,7 +11496,7 @@ dvmAsmSisterStart: * r1: BBBB field ref */ .LOP_SPUT_BOOLEAN_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11514,7 +11511,7 @@ dvmAsmSisterStart: * r1: BBBB field ref */ .LOP_SPUT_BYTE_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11529,7 +11526,7 @@ dvmAsmSisterStart: * r1: BBBB field ref */ .LOP_SPUT_CHAR_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11544,7 +11541,7 @@ dvmAsmSisterStart: * r1: BBBB field ref */ .LOP_SPUT_SHORT_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11611,7 +11608,7 @@ dvmAsmSisterStart: * r10 = "this" register */ .LOP_INVOKE_DIRECT_resolve: - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_DIRECT @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) @@ -11679,7 +11676,7 @@ dvmAsmSisterStart: * r10 = "this" register */ .LOP_INVOKE_DIRECT_RANGE_resolve: - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_DIRECT @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) @@ -11876,7 +11873,7 @@ d2l_doconv: * r1: BBBB field ref */ .LOP_SGET_VOLATILE_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11891,7 +11888,7 @@ d2l_doconv: * r1: BBBB field ref */ .LOP_SPUT_VOLATILE_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11979,7 +11976,7 @@ d2l_doconv: * Returns StaticField pointer in r0. */ .LOP_SGET_WIDE_VOLATILE_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -11997,7 +11994,7 @@ d2l_doconv: * Returns StaticField pointer in r2. */ .LOP_SPUT_WIDE_VOLATILE_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12084,7 +12081,7 @@ d2l_doconv: and r1, r1, #15 @ r1<- A cmp r9, #0 @ check object for null GET_VREG(r0, r1) @ r0<- fp[A] - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base beq common_errNullObject @ object was null FETCH_ADVANCE_INST(2) @ advance rPC, load rINST GET_INST_OPCODE(ip) @ extract opcode from rINST @@ -12101,7 +12098,7 @@ d2l_doconv: * r1: BBBB field ref */ .LOP_SGET_OBJECT_VOLATILE_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12114,7 +12111,7 @@ d2l_doconv: mov r2, rINST, lsr #8 @ r2<- AA FETCH_ADVANCE_INST(2) @ advance rPC, load rINST GET_VREG(r1, r2) @ r1<- fp[AA] - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base ldr r9, [r0, #offField_clazz] @ r9<- field->clazz GET_INST_OPCODE(ip) @ extract opcode from rINST SMP_DMB @ releasing store @@ -12132,7 +12129,7 @@ d2l_doconv: */ .LOP_CONST_CLASS_JUMBO_resolve: EXPORT_PC() - ldr r0, [rGLUE, #offGlue_method] @ r0<- glue->method + ldr r0, [rSELF, #offThread_method] @ r0<- self->method mov r2, #1 @ r2<- true ldr r0, [r0, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveClass @ r0<- Class reference @@ -12180,7 +12177,7 @@ d2l_doconv: */ .LOP_CHECK_CAST_JUMBO_resolve: EXPORT_PC() @ resolve() could throw - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r1, r2 @ r1<- AAAAAAAA mov r2, #0 @ r2<- false ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz @@ -12245,7 +12242,7 @@ d2l_doconv: .LOP_INSTANCE_OF_JUMBO_resolve: EXPORT_PC() @ resolve() could throw - ldr r0, [rGLUE, #offGlue_method] @ r0<- glue->method + ldr r0, [rSELF, #offThread_method] @ r0<- self->method mov r1, r3 @ r1<- AAAAAAAA mov r2, #1 @ r2<- true ldr r0, [r0, #offMethod_clazz] @ r0<- method->clazz @@ -12289,7 +12286,7 @@ d2l_doconv: * r1 holds AAAAAAAA */ .LOP_NEW_INSTANCE_JUMBO_resolve: - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r2, #0 @ r2<- false ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveClass @ r0<- resolved ClassObject ptr @@ -12307,7 +12304,7 @@ d2l_doconv: * r2 holds class ref AAAAAAAA */ .LOP_NEW_ARRAY_JUMBO_resolve: - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method mov r9, r1 @ r9<- length (save) mov r1, r2 @ r1<- AAAAAAAA mov r2, #0 @ r2<- false @@ -12356,8 +12353,8 @@ d2l_doconv: beq common_exceptionThrown @ alloc failed, handle exception FETCH(r1, 4) @ r1<- CCCC - str r0, [rGLUE, #offGlue_retval] @ retval.l <- new array - str rINST, [rGLUE, #offGlue_retval+4] @ retval.h <- type + str r0, [rSELF, #offThread_retval] @ retval.l <- new array + str rINST, [rSELF, #offThread_retval+4] @ retval.h <- type add r0, r0, #offArrayObject_contents @ r0<- newArray->contents subs r9, r9, #1 @ length--, check for neg FETCH_ADVANCE_INST(5) @ advance to next instr, load rINST @@ -12371,9 +12368,9 @@ d2l_doconv: str r3, [r0], #4 @ *contents++ = vX bpl 1b -2: ldr r0, [rGLUE, #offGlue_retval] @ r0<- object - ldr r1, [rGLUE, #offGlue_retval+4] @ r1<- type - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base +2: ldr r0, [rSELF, #offThread_retval] @ r0<- object + ldr r1, [rSELF, #offThread_retval+4] @ r1<- type + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base GET_INST_OPCODE(ip) @ ip<- opcode from rINST cmp r1, #'I' @ Is int array? strneb r2, [r2, r0, lsr #GC_CARD_SHIFT] @ Mark card based on object head @@ -12680,7 +12677,7 @@ d2l_doconv: FETCH(r1, 3) @ r1<- BBBB cmp r9, #0 @ check object for null GET_VREG(r0, r1) @ r0<- fp[BBBB] - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base beq common_errNullObject @ object was null FETCH_ADVANCE_INST(5) @ advance rPC, load rINST GET_INST_OPCODE(ip) @ extract opcode from rINST @@ -12817,7 +12814,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SGET_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12834,7 +12831,7 @@ d2l_doconv: * Returns StaticField pointer in r0. */ .LOP_SGET_WIDE_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12849,7 +12846,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SGET_OBJECT_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12864,7 +12861,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SGET_BOOLEAN_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12879,7 +12876,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SGET_BYTE_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12894,7 +12891,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SGET_CHAR_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12909,7 +12906,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SGET_SHORT_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12924,7 +12921,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SPUT_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12942,7 +12939,7 @@ d2l_doconv: * Returns StaticField pointer in r2. */ .LOP_SPUT_WIDE_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12957,7 +12954,7 @@ d2l_doconv: FETCH(r2, 3) @ r2<- BBBB FETCH_ADVANCE_INST(4) @ advance rPC, load rINST GET_VREG(r1, r2) @ r1<- fp[BBBB] - ldr r2, [rGLUE, #offGlue_cardTable] @ r2<- card table base + ldr r2, [rSELF, #offThread_cardTable] @ r2<- card table base ldr r9, [r0, #offField_clazz] @ r9<- field->clazz GET_INST_OPCODE(ip) @ extract opcode from rINST @ no-op @ releasing store @@ -12973,7 +12970,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SPUT_BOOLEAN_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -12988,7 +12985,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SPUT_BYTE_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -13003,7 +13000,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SPUT_CHAR_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -13018,7 +13015,7 @@ d2l_doconv: * r1: AAAAAAAA field ref */ .LOP_SPUT_SHORT_JUMBO_resolve: - ldr r2, [rGLUE, #offGlue_method] @ r2<- current method + ldr r2, [rSELF, #offThread_method] @ r2<- current method EXPORT_PC() @ resolve() could throw, so export now ldr r0, [r2, #offMethod_clazz] @ r0<- method->clazz bl dvmResolveStaticField @ r0<- resolved StaticField ptr @@ -13085,7 +13082,7 @@ d2l_doconv: * r10 = "this" register */ .LOP_INVOKE_DIRECT_JUMBO_resolve: - ldr r3, [rGLUE, #offGlue_method] @ r3<- glue->method + ldr r3, [rSELF, #offThread_method] @ r3<- self->method ldr r0, [r3, #offMethod_clazz] @ r0<- method->clazz mov r2, #METHOD_DIRECT @ resolver method type bl dvmResolveMethod @ r0<- call(clazz, ref, flags) @@ -13115,71 +13112,64 @@ dvmAsmSisterEnd: #if defined(WITH_SELF_VERIFICATION) .global dvmJitToInterpPunt dvmJitToInterpPunt: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self mov r2,#kSVSPunt @ r2<- interpreter entry point mov r3, #0 - str r3, [r10, #offThread_inJitCodeCache] @ Back to the interp land + str r3, [rSELF, #offThread_inJitCodeCache] @ Back to the interp land b jitSVShadowRunEnd @ doesn't return .global dvmJitToInterpSingleStep dvmJitToInterpSingleStep: - str lr,[rGLUE,#offGlue_jitResumeNPC] - str r1,[rGLUE,#offGlue_jitResumeDPC] + str lr,[rSELF,#offThread_jitResumeNPC] + str r1,[rSELF,#offThread_jitResumeDPC] mov r2,#kSVSSingleStep @ r2<- interpreter entry point b jitSVShadowRunEnd @ doesn't return .global dvmJitToInterpNoChainNoProfile dvmJitToInterpNoChainNoProfile: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self mov r0,rPC @ pass our target PC mov r2,#kSVSNoProfile @ r2<- interpreter entry point mov r3, #0 @ 0 means !inJitCodeCache - str r3, [r10, #offThread_inJitCodeCache] @ back to the interp land + str r3, [rSELF, #offThread_inJitCodeCache] @ back to the interp land b jitSVShadowRunEnd @ doesn't return .global dvmJitToInterpTraceSelectNoChain dvmJitToInterpTraceSelectNoChain: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self mov r0,rPC @ pass our target PC mov r2,#kSVSTraceSelect @ r2<- interpreter entry point mov r3, #0 @ 0 means !inJitCodeCache - str r3, [r10, #offThread_inJitCodeCache] @ Back to the interp land + str r3, [rSELF, #offThread_inJitCodeCache] @ Back to the interp land b jitSVShadowRunEnd @ doesn't return .global dvmJitToInterpTraceSelect dvmJitToInterpTraceSelect: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self ldr r0,[lr, #-1] @ pass our target PC mov r2,#kSVSTraceSelect @ r2<- interpreter entry point mov r3, #0 @ 0 means !inJitCodeCache - str r3, [r10, #offThread_inJitCodeCache] @ Back to the interp land + str r3, [rSELF, #offThread_inJitCodeCache] @ Back to the interp land b jitSVShadowRunEnd @ doesn't return .global dvmJitToInterpBackwardBranch dvmJitToInterpBackwardBranch: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self ldr r0,[lr, #-1] @ pass our target PC mov r2,#kSVSBackwardBranch @ r2<- interpreter entry point mov r3, #0 @ 0 means !inJitCodeCache - str r3, [r10, #offThread_inJitCodeCache] @ Back to the interp land + str r3, [rSELF, #offThread_inJitCodeCache] @ Back to the interp land b jitSVShadowRunEnd @ doesn't return .global dvmJitToInterpNormal dvmJitToInterpNormal: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self ldr r0,[lr, #-1] @ pass our target PC mov r2,#kSVSNormal @ r2<- interpreter entry point mov r3, #0 @ 0 means !inJitCodeCache - str r3, [r10, #offThread_inJitCodeCache] @ Back to the interp land + str r3, [rSELF, #offThread_inJitCodeCache] @ Back to the interp land b jitSVShadowRunEnd @ doesn't return .global dvmJitToInterpNoChain dvmJitToInterpNoChain: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self mov r0,rPC @ pass our target PC mov r2,#kSVSNoChain @ r2<- interpreter entry point mov r3, #0 @ 0 means !inJitCodeCache - str r3, [r10, #offThread_inJitCodeCache] @ Back to the interp land + str r3, [rSELF, #offThread_inJitCodeCache] @ Back to the interp land b jitSVShadowRunEnd @ doesn't return #else /* @@ -13191,7 +13181,6 @@ dvmJitToInterpNoChain: */ .global dvmJitToInterpPunt dvmJitToInterpPunt: - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self mov rPC, r0 #if defined(WITH_JIT_TUNING) mov r0,lr @@ -13199,7 +13188,7 @@ dvmJitToInterpPunt: #endif EXPORT_PC() mov r0, #0 - str r0, [r10, #offThread_inJitCodeCache] @ Back to the interp land + str r0, [rSELF, #offThread_inJitCodeCache] @ Back to the interp land adrl rIBASE, dvmAsmInstructionStart FETCH_INST() GET_INST_OPCODE(ip) @@ -13214,17 +13203,17 @@ dvmJitToInterpPunt: */ .global dvmJitToInterpSingleStep dvmJitToInterpSingleStep: - str lr,[rGLUE,#offGlue_jitResumeNPC] - str r1,[rGLUE,#offGlue_jitResumeDPC] + str lr,[rSELF,#offThread_jitResumeNPC] + str r1,[rSELF,#offThread_jitResumeDPC] mov r1,#kInterpEntryInstr @ enum is 4 byte in aapcs-EABI - str r1, [rGLUE, #offGlue_entryPoint] + str r1, [rSELF, #offThread_entryPoint] mov rPC,r0 EXPORT_PC() adrl rIBASE, dvmAsmInstructionStart mov r2,#kJitSingleStep @ Ask for single step and then revert - str r2,[rGLUE,#offGlue_jitState] + str r2,[rSELF,#offThread_jitState] mov r1,#1 @ set changeInterp to bail to debug interp b common_gotoBail @@ -13237,10 +13226,9 @@ dvmJitToInterpTraceSelectNoChain: #if defined(WITH_JIT_TUNING) bl dvmBumpNoChain #endif - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self mov r0,rPC bl dvmJitGetTraceAddr @ Is there a translation? - str r0, [r10, #offThread_inJitCodeCache] @ set the inJitCodeCache flag + str r0, [rSELF, #offThread_inJitCodeCache] @ set the inJitCodeCache flag mov r1, rPC @ arg1 of translation may need this mov lr, #0 @ in case target is HANDLER_INTERPRET cmp r0,#0 @ !0 means translation exists @@ -13255,12 +13243,11 @@ dvmJitToInterpTraceSelectNoChain: .global dvmJitToInterpTraceSelect dvmJitToInterpTraceSelect: ldr rPC,[lr, #-1] @ get our target PC - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self add rINST,lr,#-5 @ save start of chain branch add rINST, #-4 @ .. which is 9 bytes back mov r0,rPC bl dvmJitGetTraceAddr @ Is there a translation? - str r0, [r10, #offThread_inJitCodeCache] @ set the inJitCodeCache flag + str r0, [rSELF, #offThread_inJitCodeCache] @ set the inJitCodeCache flag cmp r0,#0 beq 2f mov r1,rINST @@ -13299,7 +13286,6 @@ dvmJitToInterpTraceSelect: .global dvmJitToInterpNormal dvmJitToInterpNormal: ldr rPC,[lr, #-1] @ get our target PC - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self add rINST,lr,#-5 @ save start of chain branch add rINST,#-4 @ .. which is 9 bytes back #if defined(WITH_JIT_TUNING) @@ -13307,7 +13293,7 @@ dvmJitToInterpNormal: #endif mov r0,rPC bl dvmJitGetTraceAddr @ Is there a translation? - str r0, [r10, #offThread_inJitCodeCache] @ set the inJitCodeCache flag + str r0, [rSELF, #offThread_inJitCodeCache] @ set the inJitCodeCache flag cmp r0,#0 beq toInterpreter @ go if not, otherwise do chain mov r1,rINST @@ -13327,10 +13313,9 @@ dvmJitToInterpNoChainNoProfile: #if defined(WITH_JIT_TUNING) bl dvmBumpNoChain #endif - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self mov r0,rPC bl dvmJitGetTraceAddr @ Is there a translation? - str r0, [r10, #offThread_inJitCodeCache] @ set the inJitCodeCache flag + str r0, [rSELF, #offThread_inJitCodeCache] @ set the inJitCodeCache flag mov r1, rPC @ arg1 of translation may need this mov lr, #0 @ in case target is HANDLER_INTERPRET cmp r0,#0 @@ -13350,10 +13335,9 @@ dvmJitToInterpNoChain: #if defined(WITH_JIT_TUNING) bl dvmBumpNoChain #endif - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self mov r0,rPC bl dvmJitGetTraceAddr @ Is there a translation? - str r0, [r10, #offThread_inJitCodeCache] @ set the inJitCodeCache flag + str r0, [rSELF, #offThread_inJitCodeCache] @ set the inJitCodeCache flag mov r1, rPC @ arg1 of translation may need this mov lr, #0 @ in case target is HANDLER_INTERPRET cmp r0,#0 @@ -13362,7 +13346,7 @@ dvmJitToInterpNoChain: /* * No translation, restore interpreter regs and start interpreting. - * rGLUE & rFP were preserved in the translated code, and rPC has + * rSELF & rFP were preserved in the translated code, and rPC has * already been restored by the time we get here. We'll need to set * up rIBASE & rINST, and load the address of the JitTable into r0. */ @@ -13400,13 +13384,13 @@ common_updateProfile: * is already a native translation in place (and, if so, * jump to it now). */ + GET_JIT_THRESHOLD(r1) - ldr r10, [rGLUE, #offGlue_self] @ callee saved r10 <- glue->self strb r1,[r0,r3,lsr #(32 - JIT_PROF_SIZE_LOG_2)] @ reset counter EXPORT_PC() mov r0,rPC bl dvmJitGetTraceAddr @ r0<- dvmJitGetTraceAddr(rPC) - str r0, [r10, #offThread_inJitCodeCache] @ set the inJitCodeCache flag + str r0, [rSELF, #offThread_inJitCodeCache] @ set the inJitCodeCache flag mov r1, rPC @ arg1 of translation may need this mov lr, #0 @ in case target is HANDLER_INTERPRET cmp r0,#0 @@ -13427,9 +13411,8 @@ common_updateProfile: cmp r0, r10 @ special case? bne jitSVShadowRunStart @ set up self verification shadow space @ Need to clear the inJitCodeCache flag - ldr r10, [rGLUE, #offGlue_self] @ r10 <- glue->self mov r3, #0 @ 0 means not in the JIT code cache - str r3, [r10, #offThread_inJitCodeCache] @ back to the interp land + str r3, [rSELF, #offThread_inJitCodeCache] @ back to the interp land GET_INST_OPCODE(ip) GOTO_OPCODE(ip) /* no return */ @@ -13440,9 +13423,10 @@ common_updateProfile: * r2 is jit state, e.g. kJitTSelectRequest or kJitTSelectRequestHot */ common_selectTrace: - str r2,[rGLUE,#offGlue_jitState] + + str r2,[rSELF,#offThread_jitState] mov r2,#kInterpEntryInstr @ normal entry reason - str r2,[rGLUE,#offGlue_entryPoint] + str r2,[rSELF,#offThread_entryPoint] mov r1,#1 @ set changeInterp b common_gotoBail @@ -13451,36 +13435,35 @@ common_selectTrace: * Save PC and registers to shadow memory for self verification mode * before jumping to native translation. * On entry: - * rPC, rFP, rGLUE: the values that they should contain + * rPC, rFP, rSELF: the values that they should contain * r10: the address of the target translation. */ jitSVShadowRunStart: mov r0,rPC @ r0<- program counter mov r1,rFP @ r1<- frame pointer - mov r2,rGLUE @ r2<- InterpState pointer + mov r2,rSELF @ r2<- self (Thread) pointer mov r3,r10 @ r3<- target translation bl dvmSelfVerificationSaveState @ save registers to shadow space 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 + * Restore PC, registers, and interpreter state to original values * before jumping back to the interpreter. */ jitSVShadowRunEnd: mov r1,rFP @ pass ending fp + mov r3,rSELF @ pass self ptr for convenience bl dvmSelfVerificationRestoreState @ restore pc and fp values - ldr rPC,[r0,#offShadowSpace_startPC] @ restore PC - ldr rFP,[r0,#offShadowSpace_fp] @ restore FP - ldr rGLUE,[r0,#offShadowSpace_glue] @ restore InterpState + ldr rPC,[rSELF,#offThread_pc] @ restore PC + ldr rFP,[rSELF,#offThread_fp] @ restore FP 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 - str r2,[rGLUE,#offGlue_jitState] + str r2,[rSELF,#offThread_jitState] mov r2,#kInterpEntryInstr @ normal entry reason - str r2,[rGLUE,#offGlue_entryPoint] + str r2,[rSELF,#offThread_entryPoint] mov r1,#1 @ set changeInterp b common_gotoBail @@ -13541,12 +13524,11 @@ common_backwardBranch: * r9 is trampoline PC adjustment *in bytes* */ common_periodicChecks: - ldr r1, [rGLUE, #offGlue_pInterpBreak] @ r3<- &interpBreak - /* speculatively load address of thread-specific suspend count */ - ldr r3, [rGLUE, #offGlue_pSelfSuspendCount] @ r3<- &suspendCount +/* TUNING - make this a direct load when interpBreak moved to Thread */ + ldr r1, [rSELF, #offThread_pInterpBreak] @ r3<- &interpBreak + /* speculatively thread-specific suspend count */ + ldr ip, [rSELF, #offThread_suspendCount] ldr r1, [r1] @ r1<- interpBreak - /* speculatively load thread-specific suspend count */ - ldr ip, [r3] @ ip<- suspendCount (int) cmp r1, #0 @ anything unusual? bxeq lr @ return if not /* @@ -13563,13 +13545,13 @@ common_periodicChecks: * Refresh the Jit's cached copy of profile table pointer. This pointer * doubles as the Jit's on/off switch. */ - ldr r3, [rGLUE, #offGlue_ppJitProfTable] @ r3<-&gDvmJit.pJitProfTable - ldr r0, [rGLUE, #offGlue_self] @ r0<- glue->self + ldr r3, [rSELF, #offThread_ppJitProfTable] @ r3<-&gDvmJit.pJitProfTable + mov r0, rSELF @ r0<- self ldr r3, [r3] @ r3 <- pJitProfTable EXPORT_PC() @ need for precise GC - str r3, [rGLUE, #offGlue_pJitProfTable] @ refresh Jit's on/off switch + str r3, [rSELF, #offThread_pJitProfTable] @ refresh Jit's on/off switch #else - ldr r0, [rGLUE, #offGlue_self] @ r0<- glue->self + mov r0, rSELF @ r0<- self EXPORT_PC() @ need for precise GC #endif bl dvmCheckSuspendPending @ do full check, suspend if necessary @@ -13579,7 +13561,8 @@ common_periodicChecks: * Reload the interpBreak flags - they may have changed while we * were suspended. */ - ldr r1, [rGLUE, #offGlue_pInterpBreak] @ r1<- &interpBreak +/* TUNING - direct load when InterpBreak moved to Thread */ + ldr r1, [rSELF, #offThread_pInterpBreak] @ r1<- &interpBreak ldr r1, [r1] @ r1<- interpBreak 3: /* @@ -13593,8 +13576,8 @@ common_periodicChecks: ands r1, #(kSubModeDebuggerActive | kSubModeEmulatorTrace | kSubModeInstCounting) bxeq lr @ nothing to do, return - @ debugger/profiler enabled, bail out; glue->entryPoint was set above - str r0, [rGLUE, #offGlue_entryPoint] @ store r0, need for debug/prof + @ debugger/profiler enabled, bail out; self->entryPoint was set above + str r0, [rSELF, #offThread_entryPoint] @ store r0, need for debug/prof add rPC, rPC, r9 @ update rPC mov r1, #1 @ "want switch" = true b common_gotoBail @ side exit @@ -13603,19 +13586,19 @@ common_periodicChecks: /* * The equivalent of "goto bail", this calls through the "bail handler". * - * State registers will be saved to the "glue" area before bailing. + * State registers will be saved to the "thread" area before bailing. * * On entry: * r1 is "bool changeInterp", indicating if we want to switch to the * other interpreter or just bail all the way out */ common_gotoBail: - SAVE_PC_FP_TO_GLUE() @ export state to "glue" - mov r0, rGLUE @ r0<- glue ptr - b dvmMterpStdBail @ call(glue, changeInterp) + SAVE_PC_FP_TO_SELF() @ export state to "thread" + mov r0, rSELF @ r0<- self ptr + b dvmMterpStdBail @ call(self, changeInterp) @add r1, r1, #1 @ using (boolean+1) - @add r0, rGLUE, #offGlue_jmpBuf @ r0<- &glue->jmpBuf + @add r0, rSELF, #offThread_jmpBuf @ r0<- &self->jmpBuf @bl _longjmp @ does not return @bl common_abort @@ -13717,10 +13700,10 @@ common_invokeMethodNoRange: sub r1, r1, r9, lsl #2 @ r1<- newFp (old savearea - regsSize) SAVEAREA_FROM_FP(r10, r1) @ r10<- newSaveArea @ bl common_dumpRegs - ldr r9, [rGLUE, #offGlue_interpStackEnd] @ r9<- interpStackEnd + ldr r9, [rSELF, #offThread_interpStackEnd] @ r9<- interpStackEnd sub r3, r10, r3, lsl #2 @ r3<- bottom (newsave - outsSize) cmp r3, r9 @ bottom < interpStackEnd? - ldr lr, [rGLUE, #offGlue_pInterpBreak] + ldr lr, [rSELF, #offThread_pInterpBreak] ldr r3, [r0, #offMethod_accessFlags] @ r3<- methodToCall->accessFlags blo .LstackOverflow @ yes, this frame will overflow stack @@ -13740,7 +13723,7 @@ common_invokeMethodNoRange: beq 1f @ skip if not stmfd sp!, {r0-r3} @ preserve r0-r3 mov r1, r6 - @ r0=methodToCall, r1=rGlue + @ r0=methodToCall, r1=rSELF bl dvmFastMethodTraceEnter ldmfd sp!, {r0-r3} @ restore r0-r3 1: @@ -13766,18 +13749,17 @@ common_invokeMethodNoRange: ldrh r9, [r2] @ r9 <- load INST from new PC ldr r3, [rINST, #offClassObject_pDvmDex] @ r3<- method->clazz->pDvmDex mov rPC, r2 @ publish new rPC - ldr r2, [rGLUE, #offGlue_self] @ r2<- glue->self - @ Update "glue" values for the new method - @ r0=methodToCall, r1=newFp, r2=self, r3=newMethodClass, r9=newINST - str r0, [rGLUE, #offGlue_method] @ glue->method = methodToCall - str r3, [rGLUE, #offGlue_methodClassDex] @ glue->methodClassDex = ... + @ Update state values for the new method + @ r0=methodToCall, r1=newFp, r3=newMethodClass, r9=newINST + str r0, [rSELF, #offThread_method] @ self->method = methodToCall + str r3, [rSELF, #offThread_methodClassDex] @ self->methodClassDex = ... #if defined(WITH_JIT) GET_JIT_PROF_TABLE(r0) mov rFP, r1 @ fp = newFp GET_PREFETCHED_OPCODE(ip, r9) @ extract prefetched opcode from r9 mov rINST, r9 @ publish new rINST - str r1, [r2, #offThread_curFrame] @ self->curFrame = newFp + str r1, [rSELF, #offThread_curFrame] @ self->curFrame = newFp cmp r0,#0 bne common_updateProfile GOTO_OPCODE(ip) @ jump to next instruction @@ -13785,24 +13767,23 @@ common_invokeMethodNoRange: mov rFP, r1 @ fp = newFp GET_PREFETCHED_OPCODE(ip, r9) @ extract prefetched opcode from r9 mov rINST, r9 @ publish new rINST - str r1, [r2, #offThread_curFrame] @ self->curFrame = newFp + str r1, [rSELF, #offThread_curFrame] @ self->curFrame = newFp GOTO_OPCODE(ip) @ jump to next instruction #endif .LinvokeNative: @ Prep for the native call @ r0=methodToCall, r1=newFp, r10=newSaveArea - ldr r3, [rGLUE, #offGlue_self] @ r3<- glue->self - ldr lr, [rGLUE, #offGlue_pInterpBreak] - ldr r9, [r3, #offThread_jniLocal_topCookie] @ r9<- thread->localRef->... - str r1, [r3, #offThread_curFrame] @ self->curFrame = newFp + ldr lr, [rSELF, #offThread_pInterpBreak] + ldr r9, [rSELF, #offThread_jniLocal_topCookie]@r9<-thread->localRef->... + str r1, [rSELF, #offThread_curFrame] @ self->curFrame = newFp str r9, [r10, #offStackSaveArea_localRefCookie] @newFp->localRefCookie=top ldr lr, [lr] @ lr<- active submodes - mov r9, r3 @ r9<- glue->self (preserve) mov r2, r0 @ r2<- methodToCall mov r0, r1 @ r0<- newFp (points to args) - add r1, rGLUE, #offGlue_retval @ r1<- &retval + add r1, rSELF, #offThread_retval @ r1<- &retval + mov r3, rSELF @ arg3<- self #ifdef ASSIST_DEBUGGER /* insert fake function header to help gdb find the stack frame */ @@ -13817,13 +13798,13 @@ dalvik_mterp: ands lr, #kSubModeMethodTrace @ method tracing? beq 110f @ hop if not - @ r2=JNIMethod, r6=rGLUE + @ r2=JNIMethod, r6=rSELF stmfd sp!, {r2,r6} mov lr, pc @ set return addr ldr pc, [r2, #offMethod_nativeFunc] @ pc<- methodToCall->nativeFunc - @ r0=JNIMethod, r1=rGLUE + @ r0=JNIMethod, r1=rSELF ldmfd sp!, {r0-r1} bl dvmFastNativeMethodTraceExit b 220f @@ -13832,21 +13813,21 @@ dalvik_mterp: ldr pc, [r2, #offMethod_nativeFunc] @ pc<- methodToCall->nativeFunc 220: #if defined(WITH_JIT) - ldr r3, [rGLUE, #offGlue_ppJitProfTable] @ Refresh Jit's on/off status + ldr r3, [rSELF, #offThread_ppJitProfTable] @ Refresh Jit's on/off status #endif - @ native return; r9=self, r10=newSaveArea + @ native return; r10=newSaveArea @ equivalent to dvmPopJniLocals ldr r0, [r10, #offStackSaveArea_localRefCookie] @ r0<- saved top - ldr r1, [r9, #offThread_exception] @ check for exception + ldr r1, [rSELF, #offThread_exception] @ check for exception #if defined(WITH_JIT) ldr r3, [r3] @ r3 <- gDvmJit.pProfTable #endif - str rFP, [r9, #offThread_curFrame] @ self->curFrame = fp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = fp cmp r1, #0 @ null? - str r0, [r9, #offThread_jniLocal_topCookie] @ new top <- old top + str r0, [rSELF, #offThread_jniLocal_topCookie] @ new top <- old top #if defined(WITH_JIT) - str r3, [rGLUE, #offGlue_pJitProfTable] @ refresh cached on/off switch + str r3, [rSELF, #offThread_pJitProfTable] @ refresh cached on/off switch #endif bne common_exceptionThrown @ no, handle exception @@ -13856,7 +13837,7 @@ dalvik_mterp: .LstackOverflow: @ r0=methodToCall mov r1, r0 @ r1<- methodToCall - ldr r0, [rGLUE, #offGlue_self] @ r0<- self + mov r0, rSELF @ r0<- self bl dvmHandleStackOverflow b common_exceptionThrown #ifdef ASSIST_DEBUGGER @@ -13881,8 +13862,8 @@ dalvik_mterp: sub sp, sp, #8 @ space for args + pad FETCH(ip, 2) @ ip<- FEDC or CCCC mov r2, r0 @ A2<- methodToCall - mov r0, rGLUE @ A0<- glue - SAVE_PC_FP_TO_GLUE() @ export state to "glue" + mov r0, rSELF @ A0<- self + SAVE_PC_FP_TO_SELF() @ export state to "self" mov r1, r9 @ A1<- methodCallRange mov r3, rINST, lsr #8 @ A3<- AA str ip, [sp, #0] @ A4<- ip @@ -13904,7 +13885,7 @@ common_returnFromMethod: mov r9, #0 bl common_periodicChecks - ldr lr, [rGLUE, #offGlue_pInterpBreak] + ldr lr, [rSELF, #offThread_pInterpBreak] SAVEAREA_FROM_FP(r0, rFP) ldr lr, [lr] @ lr<- active submodes ldr r9, [r0, #offStackSaveArea_savedPc] @ r9 = saveArea->savedPc @@ -13912,12 +13893,11 @@ common_returnFromMethod: beq 333f stmfd sp!, {r0-r3} @ preserve r0-r3 mov r0, r6 - @ r0=rGlue + @ r0=rSELF bl dvmFastJavaMethodTraceExit ldmfd sp!, {r0-r3} @ restore r0-r3 333: ldr rFP, [r0, #offStackSaveArea_prevFrame] @ fp = saveArea->prevFrame - ldr r3, [rGLUE, #offGlue_self] @ r3<- glue->self ldr r2, [rFP, #(offStackSaveArea_method - sizeofStackSaveArea)] @ r2<- method we're returning to cmp r2, #0 @ is this a break frame? @@ -13933,14 +13913,14 @@ common_returnFromMethod: beq common_gotoBail @ break frame, bail out completely PREFETCH_ADVANCE_INST(rINST, r9, 3) @ advance r9, update new rINST - str r2, [rGLUE, #offGlue_method]@ glue->method = newSave->method + str r2, [rSELF, #offThread_method]@ self->method = newSave->method ldr r1, [r10, #offClassObject_pDvmDex] @ r1<- method->clazz->pDvmDex - str rFP, [r3, #offThread_curFrame] @ self->curFrame = fp + str rFP, [rSELF, #offThread_curFrame] @ self->curFrame = fp #if defined(WITH_JIT) ldr r10, [r0, #offStackSaveArea_returnAddr] @ r10 = saveArea->returnAddr mov rPC, r9 @ publish new rPC - str r1, [rGLUE, #offGlue_methodClassDex] - str r10, [r3, #offThread_inJitCodeCache] @ may return to JIT'ed land + str r1, [rSELF, #offThread_methodClassDex] + str r10, [rSELF, #offThread_inJitCodeCache] @ may return to JIT'ed land cmp r10, #0 @ caller is compiled code blxne r10 GET_INST_OPCODE(ip) @ extract opcode from rINST @@ -13948,7 +13928,7 @@ common_returnFromMethod: #else GET_INST_OPCODE(ip) @ extract opcode from rINST mov rPC, r9 @ publish new rPC - str r1, [rGLUE, #offGlue_methodClassDex] + str r1, [rSELF, #offThread_methodClassDex] GOTO_OPCODE(ip) @ jump to next instruction #endif @@ -13957,8 +13937,8 @@ common_returnFromMethod: */ .if 0 .LreturnOld: - SAVE_PC_FP_TO_GLUE() @ export state - mov r0, rGLUE @ arg to function + SAVE_PC_FP_TO_SELF() @ export state + mov r0, rSELF @ arg to function bl dvmMterp_returnFromMethod b common_resumeAfterGlueCall .endif @@ -13981,13 +13961,12 @@ common_exceptionThrown: mov r9, #0 bl common_periodicChecks - ldr r10, [rGLUE, #offGlue_self] @ r10<- glue->self - ldr r9, [r10, #offThread_exception] @ r9<- self->exception - mov r1, r10 @ r1<- self + ldr r9, [rSELF, #offThread_exception] @ r9<- self->exception + mov r1, rSELF @ r1<- self mov r0, r9 @ r0<- exception bl dvmAddTrackedAlloc @ don't let the exception be GCed mov r3, #0 @ r3<- NULL - str r3, [r10, #offThread_exception] @ self->exception = NULL + str r3, [rSELF, #offThread_exception] @ self->exception = NULL /* set up args and a local for "&fp" */ /* (str sp, [sp, #-4]! would be perfect here, but is discouraged) */ @@ -13995,8 +13974,8 @@ common_exceptionThrown: mov ip, sp @ ip<- &fp mov r3, #0 @ r3<- false str ip, [sp, #-4]! @ *--sp = &fp - ldr r1, [rGLUE, #offGlue_method] @ r1<- glue->method - mov r0, r10 @ r0<- self + ldr r1, [rSELF, #offThread_method] @ r1<- self->method + mov r0, rSELF @ r0<- self ldr r1, [r1, #offMethod_insns] @ r1<- method->insns mov r2, r9 @ r2<- exception sub r1, rPC, r1 @ r1<- pc - method->insns @@ -14006,11 +13985,11 @@ common_exceptionThrown: bl dvmFindCatchBlock @ call(self, relPc, exc, scan?, &fp) /* fix earlier stack overflow if necessary; may trash rFP */ - ldrb r1, [r10, #offThread_stackOverflowed] + ldrb r1, [rSELF, #offThread_stackOverflowed] cmp r1, #0 @ did we overflow earlier? beq 1f @ no, skip ahead mov rFP, r0 @ save relPc result in rFP - mov r0, r10 @ r0<- self + mov r0, rSELF @ r0<- self mov r1, r9 @ r1<- exception bl dvmCleanupStackOverflow @ call(self) mov r0, rFP @ restore result @@ -14025,30 +14004,30 @@ common_exceptionThrown: /* adjust locals to match self->curFrame and updated PC */ SAVEAREA_FROM_FP(r1, rFP) @ r1<- new save area ldr r1, [r1, #offStackSaveArea_method] @ r1<- new method - str r1, [rGLUE, #offGlue_method] @ glue->method = new method + str r1, [rSELF, #offThread_method] @ self->method = new method ldr r2, [r1, #offMethod_clazz] @ r2<- method->clazz ldr r3, [r1, #offMethod_insns] @ r3<- method->insns ldr r2, [r2, #offClassObject_pDvmDex] @ r2<- method->clazz->pDvmDex add rPC, r3, r0, asl #1 @ rPC<- method->insns + catchRelPc - str r2, [rGLUE, #offGlue_methodClassDex] @ glue->pDvmDex = meth... + str r2, [rSELF, #offThread_methodClassDex] @ self->pDvmDex = meth... /* release the tracked alloc on the exception */ mov r0, r9 @ r0<- exception - mov r1, r10 @ r1<- self + mov r1, rSELF @ r1<- self bl dvmReleaseTrackedAlloc @ release the exception /* restore the exception if the handler wants it */ FETCH_INST() @ load rINST from rPC GET_INST_OPCODE(ip) @ extract opcode from rINST cmp ip, #OP_MOVE_EXCEPTION @ is it "move-exception"? - streq r9, [r10, #offThread_exception] @ yes, restore the exception + streq r9, [rSELF, #offThread_exception] @ yes, restore the exception GOTO_OPCODE(ip) @ jump to next instruction -.LnotCaughtLocally: @ r9=exception, r10=self +.LnotCaughtLocally: @ r9=exception /* fix stack overflow if necessary */ - ldrb r1, [r10, #offThread_stackOverflowed] + ldrb r1, [rSELF, #offThread_stackOverflowed] cmp r1, #0 @ did we overflow earlier? - movne r0, r10 @ if yes: r0<- self + movne r0, rSELF @ if yes: r0<- self movne r1, r9 @ if yes: r1<- exception blne dvmCleanupStackOverflow @ if yes: call(self) @@ -14057,14 +14036,14 @@ common_exceptionThrown: /* call __android_log_print(prio, tag, format, ...) */ /* "Exception %s from %s:%d not caught locally" */ @ dvmLineNumFromPC(method, pc - method->insns) - ldr r0, [rGLUE, #offGlue_method] + ldr r0, [rSELF, #offThread_method] ldr r1, [r0, #offMethod_insns] sub r1, rPC, r1 asr r1, r1, #1 bl dvmLineNumFromPC str r0, [sp, #-4]! @ dvmGetMethodSourceFile(method) - ldr r0, [rGLUE, #offGlue_method] + ldr r0, [rSELF, #offThread_method] bl dvmGetMethodSourceFile str r0, [sp, #-4]! @ exception->clazz->descriptor @@ -14076,9 +14055,9 @@ common_exceptionThrown: mov r0, #3 @ LOG_DEBUG bl __android_log_print #endif - str r9, [r10, #offThread_exception] @ restore exception + str r9, [rSELF, #offThread_exception] @ restore exception mov r0, r9 @ r0<- exception - mov r1, r10 @ r1<- self + mov r1, rSELF @ r1<- self bl dvmReleaseTrackedAlloc @ release the exception mov r1, #0 @ "want switch" = false b common_gotoBail @ bail out @@ -14089,8 +14068,8 @@ common_exceptionThrown: */ .if 0 .LexceptionOld: - SAVE_PC_FP_TO_GLUE() @ export state - mov r0, rGLUE @ arg to function + SAVE_PC_FP_TO_SELF() @ export state + mov r0, rSELF @ arg to function bl dvmMterp_exceptionThrown b common_resumeAfterGlueCall .endif @@ -14101,7 +14080,7 @@ common_exceptionThrown: * values and start executing at the next instruction. */ common_resumeAfterGlueCall: - LOAD_PC_FP_FROM_GLUE() @ pull rPC and rFP out of glue + LOAD_PC_FP_FROM_SELF() @ pull rPC and rFP out of thread FETCH_INST() @ load rINST from rPC GET_INST_OPCODE(ip) @ extract opcode from rINST GOTO_OPCODE(ip) @ jump to next instruction diff --git a/vm/mterp/out/InterpAsm-x86.S b/vm/mterp/out/InterpAsm-x86.S index 6e5290f26..efb8be82a 100644 --- a/vm/mterp/out/InterpAsm-x86.S +++ b/vm/mterp/out/InterpAsm-x86.S @@ -72,7 +72,7 @@ Notes: */ -#define rGLUE (%ebp) +#define rSELF (%ebp) #define rPC %esi #define rFP %edi #define rINST %ebx @@ -85,7 +85,7 @@ Notes: #define IN_ARG0 ( 12) #define CALLER_RP ( 8) #define PREV_FP ( 4) -#define rGLUE_SPILL ( 0) /* <- dvmMterpStdRun ebp */ +#define rSELF_SPILL ( 0) /* <- dvmMterpStdRun ebp */ /* Spill offsets relative to %ebp */ #define EDI_SPILL ( -4) #define ESI_SPILL ( -8) @@ -118,25 +118,25 @@ Notes: #define UNSPILL_TMP3(reg) movl TMP_SPILL3(%ebp),reg #if defined(WITH_JIT) -.macro GET_JIT_PROF_TABLE _glue _reg - movl offGlue_pJitProfTable(\_glue),\_reg +.macro GET_JIT_PROF_TABLE _self _reg + movl offThread_pJitProfTable(\_self),\_reg .endm -.macro GET_JIT_THRESHOLD _glue _reg - movl offGlue_jitThreshold(\_glue),\_reg +.macro GET_JIT_THRESHOLD _self _reg + movl offThread_jitThreshold(\_self),\_reg .endm #endif -/* save/restore the PC and/or FP from the glue struct */ -.macro SAVE_PC_FP_TO_GLUE _reg - movl rGLUE,\_reg - movl rPC,offGlue_pc(\_reg) - movl rFP,offGlue_fp(\_reg) +/* save/restore the PC and/or FP from the self struct */ +.macro SAVE_PC_FP_TO_SELF _reg + movl rSELF,\_reg + movl rPC,offThread_pc(\_reg) + movl rFP,offThread_fp(\_reg) .endm -.macro LOAD_PC_FP_FROM_GLUE - movl rGLUE,rFP - movl offGlue_pc(rFP),rPC - movl offGlue_fp(rFP),rFP +.macro LOAD_PC_FP_FROM_SELF + movl rSELF,rFP + movl offThread_pc(rFP),rPC + movl offThread_fp(rFP),rFP .endm /* The interpreter assumes a properly aligned stack on entry, and @@ -775,9 +775,9 @@ dvmAsmInstructionStart = .L_OP_NOP /* File: x86/OP_MOVE_RESULT.S */ /* for: move-result, move-result-object */ /* op vAA */ - movl rGLUE,%eax # eax<- rGLUE + movl rSELF,%eax # eax<- rSELF movzx rINSTbl,%ecx # ecx<- AA - movl offGlue_retval(%eax),%eax # eax<- glue->retval.l + movl offThread_retval(%eax),%eax # eax<- self->retval.l FETCH_INST_OPCODE 1 %edx ADVANCE_PC 1 SET_VREG %eax %ecx # fp[AA]<- retval.l @@ -788,9 +788,9 @@ dvmAsmInstructionStart = .L_OP_NOP .L_OP_MOVE_RESULT_WIDE: /* 0x0b */ /* File: x86/OP_MOVE_RESULT_WIDE.S */ /* move-result-wide vAA */ - movl rGLUE,%ecx - movl offGlue_retval(%ecx),%eax - movl 4+offGlue_retval(%ecx),%ecx + movl rSELF,%ecx + movl offThread_retval(%ecx),%eax + movl 4+offThread_retval(%ecx),%ecx FETCH_INST_OPCODE 1 %edx SET_VREG_WORD %eax rINST 0 # v[AA+0] <- eax SET_VREG_WORD %ecx rINST 1 # v[AA+1] <- ecx @@ -804,9 +804,9 @@ dvmAsmInstructionStart = .L_OP_NOP /* File: x86/OP_MOVE_RESULT.S */ /* for: move-result, move-result-object */ /* op vAA */ - movl rGLUE,%eax # eax<- rGLUE + movl rSELF,%eax # eax<- rSELF movzx rINSTbl,%ecx # ecx<- AA - movl offGlue_retval(%eax),%eax # eax<- glue->retval.l + movl offThread_retval(%eax),%eax # eax<- self->retval.l FETCH_INST_OPCODE 1 %edx ADVANCE_PC 1 SET_VREG %eax %ecx # fp[AA]<- retval.l @@ -818,8 +818,7 @@ dvmAsmInstructionStart = .L_OP_NOP .L_OP_MOVE_EXCEPTION: /* 0x0d */ /* File: x86/OP_MOVE_EXCEPTION.S */ /* move-exception vAA */ - movl rGLUE,%ecx - movl offGlue_self(%ecx),%ecx # ecx<- glue->self + movl rSELF,%ecx movl offThread_exception(%ecx),%eax # eax<- dvmGetException bypass SET_VREG %eax rINST # fp[AA]<- exception object FETCH_INST_OPCODE 1 %edx @@ -838,15 +837,15 @@ dvmAsmInstructionStart = .L_OP_NOP .L_OP_RETURN: /* 0x0f */ /* File: x86/OP_RETURN.S */ /* - * Return a 32-bit value. Copies the return value into the "glue" + * Return a 32-bit value. Copies the return value into the "self" * structure, then jumps to the return handler. * * for: return, return-object */ /* op vAA */ - movl rGLUE,%ecx + movl rSELF,%ecx GET_VREG_R %eax rINST # eax<- vAA - movl %eax,offGlue_retval(%ecx) # retval.i <- AA + movl %eax,offThread_retval(%ecx) # retval.i <- AA jmp common_returnFromMethod /* ------------------------------ */ @@ -854,15 +853,15 @@ dvmAsmInstructionStart = .L_OP_NOP .L_OP_RETURN_WIDE: /* 0x10 */ /* File: x86/OP_RETURN_WIDE.S */ /* - * Return a 64-bit value. Copies the return value into the "glue" + * Return a 64-bit value. Copies the return value into the "self" * structure, then jumps to the return handler. */ /* return-wide vAA */ - movl rGLUE,%ecx + movl rSELF,%ecx GET_VREG_WORD %eax rINST 0 # eax<- v[AA+0] GET_VREG_WORD rINST rINST 1 # rINST<- v[AA+1] - movl %eax,offGlue_retval(%ecx) - movl rINST,4+offGlue_retval(%ecx) + movl %eax,offThread_retval(%ecx) + movl rINST,4+offThread_retval(%ecx) jmp common_returnFromMethod /* ------------------------------ */ @@ -871,15 +870,15 @@ dvmAsmInstructionStart = .L_OP_NOP /* File: x86/OP_RETURN_OBJECT.S */ /* File: x86/OP_RETURN.S */ /* - * Return a 32-bit value. Copies the return value into the "glue" + * Return a 32-bit value. Copies the return value into the "self" * structure, then jumps to the return handler. * * for: return, return-object */ /* op vAA */ - movl rGLUE,%ecx + movl rSELF,%ecx GET_VREG_R %eax rINST # eax<- vAA - movl %eax,offGlue_retval(%ecx) # retval.i <- AA + movl %eax,offThread_retval(%ecx) # retval.i <- AA jmp common_returnFromMethod @@ -995,9 +994,9 @@ dvmAsmInstructionStart = .L_OP_NOP /* File: x86/OP_CONST_STRING.S */ /* const/string vAA, String@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- BBBB - movl offGlue_methodClassDex(%ecx),%ecx# ecx<- glue->methodClassDex + movl offThread_methodClassDex(%ecx),%ecx# ecx<- self->methodClassDex movl offDvmDex_pResStrings(%ecx),%ecx # ecx<- dvmDex->pResStrings movl (%ecx,%eax,4),%eax # eax<- rResString[BBBB] movl rINST,%ecx @@ -1014,9 +1013,9 @@ dvmAsmInstructionStart = .L_OP_NOP /* File: x86/OP_CONST_STRING_JUMBO.S */ /* const/string vAA, String@BBBBBBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%eax # eax<- BBBBBBBB - movl offGlue_methodClassDex(%ecx),%ecx# ecx<- glue->methodClassDex + movl offThread_methodClassDex(%ecx),%ecx# ecx<- self->methodClassDex movl offDvmDex_pResStrings(%ecx),%ecx # ecx<- dvmDex->pResStrings movl (%ecx,%eax,4),%eax # eax<- rResString[BBBB] movl rINST,%ecx @@ -1033,9 +1032,9 @@ dvmAsmInstructionStart = .L_OP_NOP /* File: x86/OP_CONST_CLASS.S */ /* const/class vAA, Class@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- BBBB - movl offGlue_methodClassDex(%ecx),%ecx# ecx<- glue->methodClassDex + movl offThread_methodClassDex(%ecx),%ecx# ecx<- self->methodClassDex movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- dvmDex->pResClasses movl (%ecx,%eax,4),%eax # eax<- rResClasses[BBBB] movl rINST,%ecx @@ -1054,9 +1053,8 @@ dvmAsmInstructionStart = .L_OP_NOP * Synchronize on an object. */ /* monitor-enter vAA */ - movl rGLUE,%ecx + movl rSELF,%ecx GET_VREG_R %eax rINST # eax<- vAA - movl offGlue_self(%ecx),%ecx # ecx<- glue->self FETCH_INST_WORD 1 testl %eax,%eax # null object? EXPORT_PC # need for precise GC @@ -1076,11 +1074,10 @@ dvmAsmInstructionStart = .L_OP_NOP */ /* monitor-exit vAA */ GET_VREG_R %eax rINST - movl rGLUE,%ecx + movl rSELF,%ecx EXPORT_PC testl %eax,%eax # null object? je .LOP_MONITOR_EXIT_errNullObject # go if so - movl offGlue_self(%ecx),%ecx # ecx<- glue->self movl %eax,OUT_ARG1(%esp) movl %ecx,OUT_ARG0(%esp) jmp .LOP_MONITOR_EXIT_continue @@ -1093,10 +1090,10 @@ dvmAsmInstructionStart = .L_OP_NOP * Check to see if a cast from one class to another is allowed. */ /* check-cast vAA, class@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx GET_VREG_R rINST,rINST # rINST<- vAA (object) movzwl 2(rPC),%eax # eax<- BBBB - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- pDvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex testl rINST,rINST # is oject null? movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses je .LOP_CHECK_CAST_okay # null obj, cast always succeeds @@ -1126,9 +1123,9 @@ dvmAsmInstructionStart = .L_OP_NOP movl rINST,%eax # eax<- BA sarl $4,%eax # eax<- B GET_VREG_R %eax %eax # eax<- vB (obj) - movl rGLUE,%ecx + movl rSELF,%ecx testl %eax,%eax # object null? - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- pDvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex je .LOP_INSTANCE_OF_store # null obj, not instance, store it movzwl 2(rPC),%edx # edx<- CCCC movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses @@ -1168,9 +1165,9 @@ dvmAsmInstructionStart = .L_OP_NOP * Create a new instance of a class. */ /* new-instance vAA, class@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- BBBB - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- pDvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses EXPORT_PC movl (%ecx,%eax,4),%ecx # ecx<- resolved class @@ -1193,9 +1190,9 @@ dvmAsmInstructionStart = .L_OP_NOP * check for it here. */ /* new-array vA, vB, class@CCCC */ - movl rGLUE,%ecx + movl rSELF,%ecx EXPORT_PC - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- pDvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex movzwl 2(rPC),%eax # eax<- CCCC movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses movl (%ecx,%eax,4),%ecx # ecx<- resolved class @@ -1220,8 +1217,8 @@ dvmAsmInstructionStart = .L_OP_NOP */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op {vCCCC..v(CCCC+AA-1)}, type@BBBB */ - movl rGLUE,%eax - movl offGlue_methodClassDex(%eax),%eax # eax<- pDvmDex + movl rSELF,%eax + movl offThread_methodClassDex(%eax),%eax # eax<- pDvmDex movzwl 2(rPC),%ecx # ecx<- BBBB movl offDvmDex_pResClasses(%eax),%eax # eax<- pDvmDex->pResClasses movl (%eax,%ecx,4),%eax # eax<- resolved class @@ -1229,10 +1226,10 @@ dvmAsmInstructionStart = .L_OP_NOP testl %eax,%eax # already resolved? jne .LOP_FILLED_NEW_ARRAY_continue # yes, continue # less frequent path, so we'll redo some work - movl rGLUE,%eax + movl rSELF,%eax movl $0,OUT_ARG2(%esp) # arg2<- false movl %ecx,OUT_ARG1(%esp) # arg1<- BBBB - movl offGlue_method(%eax),%eax # eax<- glue->method + movl offThread_method(%eax),%eax # eax<- self->method jmp .LOP_FILLED_NEW_ARRAY_more /* ------------------------------ */ @@ -1247,8 +1244,8 @@ dvmAsmInstructionStart = .L_OP_NOP */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op {vCCCC..v(CCCC+AA-1)}, type@BBBB */ - movl rGLUE,%eax - movl offGlue_methodClassDex(%eax),%eax # eax<- pDvmDex + movl rSELF,%eax + movl offThread_methodClassDex(%eax),%eax # eax<- pDvmDex movzwl 2(rPC),%ecx # ecx<- BBBB movl offDvmDex_pResClasses(%eax),%eax # eax<- pDvmDex->pResClasses movl (%eax,%ecx,4),%eax # eax<- resolved class @@ -1256,10 +1253,10 @@ dvmAsmInstructionStart = .L_OP_NOP testl %eax,%eax # already resolved? jne .LOP_FILLED_NEW_ARRAY_RANGE_continue # yes, continue # less frequent path, so we'll redo some work - movl rGLUE,%eax + movl rSELF,%eax movl $0,OUT_ARG2(%esp) # arg2<- false movl %ecx,OUT_ARG1(%esp) # arg1<- BBBB - movl offGlue_method(%eax),%eax # eax<- glue->method + movl offThread_method(%eax),%eax # eax<- self->method jmp .LOP_FILLED_NEW_ARRAY_RANGE_more @@ -1289,10 +1286,9 @@ dvmAsmInstructionStart = .L_OP_NOP * Throw an exception object in the current thread. */ /* throw vAA */ - movl rGLUE,%ecx EXPORT_PC GET_VREG_R %eax rINST # eax<- exception object - movl offGlue_self(%ecx),%ecx # ecx<- glue->self + movl rSELF,%ecx # ecx<- self testl %eax,%eax # null object? je common_errNullObject movl %eax,offThread_exception(%ecx) # thread->exception<- obj @@ -2338,9 +2334,9 @@ dvmAsmInstructionStart = .L_OP_NOP * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short */ /* op vA, vB, field@CCCC */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%edx # edx<- 0000CCCC - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzbl rINSTbl,%ecx # ecx<- BA sarl $4,%ecx # ecx<- B movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields @@ -2350,7 +2346,7 @@ dvmAsmInstructionStart = .L_OP_NOP testl %eax,%eax # is resolved entry null? jne .LOP_IGET_finish # no, already resolved movl %edx,OUT_ARG1(%esp) # needed by dvmResolveInstField - movl rGLUE,%edx + movl rSELF,%edx jmp .LOP_IGET_resolve /* ------------------------------ */ @@ -2362,9 +2358,9 @@ dvmAsmInstructionStart = .L_OP_NOP * */ /* op vA, vB, field@CCCC */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%edx # edx<- 0000CCCC - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzbl rINSTbl,%ecx # ecx<- BA sarl $4,%ecx # ecx<- B movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields @@ -2374,7 +2370,7 @@ dvmAsmInstructionStart = .L_OP_NOP testl %eax,%eax # is resolved entry null? jne .LOP_IGET_WIDE_finish # no, already resolved movl %edx,OUT_ARG1(%esp) # for dvmResolveInstField - movl rGLUE,%edx + movl rSELF,%edx jmp .LOP_IGET_WIDE_resolve /* ------------------------------ */ @@ -2388,9 +2384,9 @@ dvmAsmInstructionStart = .L_OP_NOP * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short */ /* op vA, vB, field@CCCC */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%edx # edx<- 0000CCCC - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzbl rINSTbl,%ecx # ecx<- BA sarl $4,%ecx # ecx<- B movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields @@ -2400,7 +2396,7 @@ dvmAsmInstructionStart = .L_OP_NOP testl %eax,%eax # is resolved entry null? jne .LOP_IGET_OBJECT_finish # no, already resolved movl %edx,OUT_ARG1(%esp) # needed by dvmResolveInstField - movl rGLUE,%edx + movl rSELF,%edx jmp .LOP_IGET_OBJECT_resolve @@ -2415,9 +2411,9 @@ dvmAsmInstructionStart = .L_OP_NOP * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short */ /* op vA, vB, field@CCCC */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%edx # edx<- 0000CCCC - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzbl rINSTbl,%ecx # ecx<- BA sarl $4,%ecx # ecx<- B movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields @@ -2427,7 +2423,7 @@ dvmAsmInstructionStart = .L_OP_NOP testl %eax,%eax # is resolved entry null? jne .LOP_IGET_BOOLEAN_finish # no, already resolved movl %edx,OUT_ARG1(%esp) # needed by dvmResolveInstField - movl rGLUE,%edx + movl rSELF,%edx jmp .LOP_IGET_BOOLEAN_resolve @@ -2442,9 +2438,9 @@ dvmAsmInstructionStart = .L_OP_NOP * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short */ /* op vA, vB, field@CCCC */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%edx # edx<- 0000CCCC - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzbl rINSTbl,%ecx # ecx<- BA sarl $4,%ecx # ecx<- B movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields @@ -2454,7 +2450,7 @@ dvmAsmInstructionStart = .L_OP_NOP testl %eax,%eax # is resolved entry null? jne .LOP_IGET_BYTE_finish # no, already resolved movl %edx,OUT_ARG1(%esp) # needed by dvmResolveInstField - movl rGLUE,%edx + movl rSELF,%edx jmp .LOP_IGET_BYTE_resolve @@ -2469,9 +2465,9 @@ dvmAsmInstructionStart = .L_OP_NOP * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short */ /* op vA, vB, field@CCCC */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%edx # edx<- 0000CCCC - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzbl rINSTbl,%ecx # ecx<- BA sarl $4,%ecx # ecx<- B movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields @@ -2481,7 +2477,7 @@ dvmAsmInstructionStart = .L_OP_NOP testl %eax,%eax # is resolved entry null? jne .LOP_IGET_CHAR_finish # no, already resolved movl %edx,OUT_ARG1(%esp) # needed by dvmResolveInstField - movl rGLUE,%edx + movl rSELF,%edx jmp .LOP_IGET_CHAR_resolve @@ -2496,9 +2492,9 @@ dvmAsmInstructionStart = .L_OP_NOP * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short */ /* op vA, vB, field@CCCC */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%edx # edx<- 0000CCCC - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzbl rINSTbl,%ecx # ecx<- BA sarl $4,%ecx # ecx<- B movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields @@ -2508,7 +2504,7 @@ dvmAsmInstructionStart = .L_OP_NOP testl %eax,%eax # is resolved entry null? jne .LOP_IGET_SHORT_finish # no, already resolved movl %edx,OUT_ARG1(%esp) # needed by dvmResolveInstField - movl rGLUE,%edx + movl rSELF,%edx jmp .LOP_IGET_SHORT_resolve @@ -2523,9 +2519,9 @@ dvmAsmInstructionStart = .L_OP_NOP * for: iput, iput-object, iput-boolean, iput-byte, iput-char, iput-short */ /* op vA, vB, field@CCCC */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%edx # %edx<- 0000CCCC - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzbl rINSTbl,%ecx # ecx<- BA sarl $4,%ecx # ecx<- B movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields @@ -2535,7 +2531,7 @@ dvmAsmInstructionStart = .L_OP_NOP testl %eax,%eax # is resolved entry null? jne .LOP_IPUT_finish # no, already resolved movl %edx,OUT_ARG1(%esp) - movl rGLUE,%edx + movl rSELF,%edx jmp .LOP_IPUT_resolve /* ------------------------------ */ @@ -2547,9 +2543,9 @@ dvmAsmInstructionStart = .L_OP_NOP * */ /* op vA, vB, field@CCCC */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%edx # edx<- 0000CCCC - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzbl rINSTbl,%ecx # ecx<- BA sarl $4,%ecx # ecx<- B movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields @@ -2559,7 +2555,7 @@ dvmAsmInstructionStart = .L_OP_NOP testl %eax,%eax # is resolved entry null? jne .LOP_IPUT_WIDE_finish # no, already resolved movl %edx,OUT_ARG1(%esp) - movl rGLUE,%edx + movl rSELF,%edx jmp .LOP_IPUT_WIDE_resolve /* ------------------------------ */ @@ -2572,9 +2568,9 @@ dvmAsmInstructionStart = .L_OP_NOP * for: iput-object */ /* op vA, vB, field@CCCC */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%edx # edx<- 0000CCCC - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzbl rINSTbl,%ecx # ecx<- BA sarl $4,%ecx # ecx<- B movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields @@ -2584,7 +2580,7 @@ dvmAsmInstructionStart = .L_OP_NOP testl %eax,%eax # is resolved entry null? jne .LOP_IPUT_OBJECT_finish # no, already resolved movl %edx,OUT_ARG1(%esp) - movl rGLUE,%edx + movl rSELF,%edx jmp .LOP_IPUT_OBJECT_resolve /* ------------------------------ */ @@ -2599,9 +2595,9 @@ dvmAsmInstructionStart = .L_OP_NOP * for: iput, iput-object, iput-boolean, iput-byte, iput-char, iput-short */ /* op vA, vB, field@CCCC */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%edx # %edx<- 0000CCCC - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzbl rINSTbl,%ecx # ecx<- BA sarl $4,%ecx # ecx<- B movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields @@ -2611,7 +2607,7 @@ dvmAsmInstructionStart = .L_OP_NOP testl %eax,%eax # is resolved entry null? jne .LOP_IPUT_BOOLEAN_finish # no, already resolved movl %edx,OUT_ARG1(%esp) - movl rGLUE,%edx + movl rSELF,%edx jmp .LOP_IPUT_BOOLEAN_resolve @@ -2627,9 +2623,9 @@ dvmAsmInstructionStart = .L_OP_NOP * for: iput, iput-object, iput-boolean, iput-byte, iput-char, iput-short */ /* op vA, vB, field@CCCC */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%edx # %edx<- 0000CCCC - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzbl rINSTbl,%ecx # ecx<- BA sarl $4,%ecx # ecx<- B movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields @@ -2639,7 +2635,7 @@ dvmAsmInstructionStart = .L_OP_NOP testl %eax,%eax # is resolved entry null? jne .LOP_IPUT_BYTE_finish # no, already resolved movl %edx,OUT_ARG1(%esp) - movl rGLUE,%edx + movl rSELF,%edx jmp .LOP_IPUT_BYTE_resolve @@ -2655,9 +2651,9 @@ dvmAsmInstructionStart = .L_OP_NOP * for: iput, iput-object, iput-boolean, iput-byte, iput-char, iput-short */ /* op vA, vB, field@CCCC */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%edx # %edx<- 0000CCCC - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzbl rINSTbl,%ecx # ecx<- BA sarl $4,%ecx # ecx<- B movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields @@ -2667,7 +2663,7 @@ dvmAsmInstructionStart = .L_OP_NOP testl %eax,%eax # is resolved entry null? jne .LOP_IPUT_CHAR_finish # no, already resolved movl %edx,OUT_ARG1(%esp) - movl rGLUE,%edx + movl rSELF,%edx jmp .LOP_IPUT_CHAR_resolve @@ -2683,9 +2679,9 @@ dvmAsmInstructionStart = .L_OP_NOP * for: iput, iput-object, iput-boolean, iput-byte, iput-char, iput-short */ /* op vA, vB, field@CCCC */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%edx # %edx<- 0000CCCC - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzbl rINSTbl,%ecx # ecx<- BA sarl $4,%ecx # ecx<- B movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields @@ -2695,7 +2691,7 @@ dvmAsmInstructionStart = .L_OP_NOP testl %eax,%eax # is resolved entry null? jne .LOP_IPUT_SHORT_finish # no, already resolved movl %edx,OUT_ARG1(%esp) - movl rGLUE,%edx + movl rSELF,%edx jmp .LOP_IPUT_SHORT_resolve @@ -2709,9 +2705,9 @@ dvmAsmInstructionStart = .L_OP_NOP * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr testl %eax,%eax # resolved entry null? @@ -2732,9 +2728,9 @@ dvmAsmInstructionStart = .L_OP_NOP * */ /* sget-wide vAA, field@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr testl %eax,%eax # resolved entry null? @@ -2759,9 +2755,9 @@ dvmAsmInstructionStart = .L_OP_NOP * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr testl %eax,%eax # resolved entry null? @@ -2785,9 +2781,9 @@ dvmAsmInstructionStart = .L_OP_NOP * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr testl %eax,%eax # resolved entry null? @@ -2811,9 +2807,9 @@ dvmAsmInstructionStart = .L_OP_NOP * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr testl %eax,%eax # resolved entry null? @@ -2837,9 +2833,9 @@ dvmAsmInstructionStart = .L_OP_NOP * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr testl %eax,%eax # resolved entry null? @@ -2863,9 +2859,9 @@ dvmAsmInstructionStart = .L_OP_NOP * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr testl %eax,%eax # resolved entry null? @@ -2888,9 +2884,9 @@ dvmAsmInstructionStart = .L_OP_NOP * for: sput, sput-boolean, sput-byte, sput-char, sput-short */ /* op vAA, field@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr testl %eax,%eax # resolved entry null? @@ -2912,9 +2908,9 @@ dvmAsmInstructionStart = .L_OP_NOP * for: sput, sput-object, sput-boolean, sput-byte, sput-char, sput-short */ /* op vAA, field@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr testl %eax,%eax # resolved entry null? @@ -2936,9 +2932,9 @@ dvmAsmInstructionStart = .L_OP_NOP * SPUT object handler. */ /* op vAA, field@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField testl %eax,%eax # resolved entry null? @@ -2959,9 +2955,9 @@ dvmAsmInstructionStart = .L_OP_NOP * for: sput, sput-boolean, sput-byte, sput-char, sput-short */ /* op vAA, field@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr testl %eax,%eax # resolved entry null? @@ -2985,9 +2981,9 @@ dvmAsmInstructionStart = .L_OP_NOP * for: sput, sput-boolean, sput-byte, sput-char, sput-short */ /* op vAA, field@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr testl %eax,%eax # resolved entry null? @@ -3011,9 +3007,9 @@ dvmAsmInstructionStart = .L_OP_NOP * for: sput, sput-boolean, sput-byte, sput-char, sput-short */ /* op vAA, field@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr testl %eax,%eax # resolved entry null? @@ -3037,9 +3033,9 @@ dvmAsmInstructionStart = .L_OP_NOP * for: sput, sput-boolean, sput-byte, sput-char, sput-short */ /* op vAA, field@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr testl %eax,%eax # resolved entry null? @@ -3064,17 +3060,17 @@ dvmAsmInstructionStart = .L_OP_NOP */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - movl rGLUE,%eax + movl rSELF,%eax movzwl 2(rPC),%ecx # ecx<- BBBB - movl offGlue_methodClassDex(%eax),%eax # eax<- pDvmDex + movl offThread_methodClassDex(%eax),%eax # eax<- pDvmDex EXPORT_PC movl offDvmDex_pResMethods(%eax),%eax # eax<- pDvmDex->pResMethods movl (%eax,%ecx,4),%eax # eax<- resolved baseMethod testl %eax,%eax # already resolved? jne .LOP_INVOKE_VIRTUAL_continue # yes, continue - movl rGLUE,%eax + movl rSELF,%eax movl %ecx,OUT_ARG1(%esp) # arg1<- ref - movl offGlue_method(%eax),%eax # eax<- glue->method + movl offThread_method(%eax),%eax # eax<- self->method jmp .LOP_INVOKE_VIRTUAL_more /* ------------------------------ */ @@ -3088,13 +3084,13 @@ dvmAsmInstructionStart = .L_OP_NOP */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - movl rGLUE,rINST + movl rSELF,rINST movzwl 2(rPC),%eax # eax<- BBBB - movl offGlue_methodClassDex(rINST),%ecx # ecx<- pDvmDex + movl offThread_methodClassDex(rINST),%ecx # ecx<- pDvmDex EXPORT_PC movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods movl (%ecx,%eax,4),%ecx # ecx<- resolved baseMethod - movl offGlue_method(rINST),%eax # eax<- method + movl offThread_method(rINST),%eax # eax<- method movzwl 4(rPC),rINST # rINST<- GFED or CCCC .if (!0) andl $0xf,rINST # rINST<- D (or stays CCCC) @@ -3123,9 +3119,9 @@ dvmAsmInstructionStart = .L_OP_NOP */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- BBBB - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- pDvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex EXPORT_PC movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods movzwl 4(rPC),%edx # edx<- GFED or CCCC @@ -3152,16 +3148,16 @@ dvmAsmInstructionStart = .L_OP_NOP */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- BBBB - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- pDvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex EXPORT_PC movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods movl (%ecx,%eax,4),%eax # eax<- resolved methodToCall testl %eax,%eax jne common_invokeMethodNoRange - movl rGLUE,%ecx - movl offGlue_method(%ecx),%ecx # ecx<- glue->method + movl rSELF,%ecx + movl offThread_method(%ecx),%ecx # ecx<- self->method movzwl 2(rPC),%eax movl offMethod_clazz(%ecx),%ecx# ecx<- method->clazz movl %eax,OUT_ARG1(%esp) # arg1<- BBBB @@ -3180,7 +3176,7 @@ dvmAsmInstructionStart = .L_OP_NOP /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ movzwl 4(rPC),%eax # eax<- FEDC or CCCC - movl rGLUE,%ecx + movl rSELF,%ecx .if (!0) andl $0xf,%eax # eax<- C (or stays CCCC) .endif @@ -3190,8 +3186,8 @@ dvmAsmInstructionStart = .L_OP_NOP je common_errNullObject # yes, fail movl offObject_clazz(%eax),%eax# eax<- thisPtr->clazz movl %eax,OUT_ARG0(%esp) # arg0<- class - movl offGlue_methodClassDex(%ecx),%eax # eax<- methodClassDex - movl offGlue_method(%ecx),%ecx # ecx<- method + movl offThread_methodClassDex(%ecx),%eax # eax<- methodClassDex + movl offThread_method(%ecx),%ecx # ecx<- method movl %eax,OUT_ARG3(%esp) # arg3<- dex movzwl 2(rPC),%eax # eax<- BBBB movl %ecx,OUT_ARG2(%esp) # arg2<- method @@ -3219,17 +3215,17 @@ dvmAsmInstructionStart = .L_OP_NOP */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - movl rGLUE,%eax + movl rSELF,%eax movzwl 2(rPC),%ecx # ecx<- BBBB - movl offGlue_methodClassDex(%eax),%eax # eax<- pDvmDex + movl offThread_methodClassDex(%eax),%eax # eax<- pDvmDex EXPORT_PC movl offDvmDex_pResMethods(%eax),%eax # eax<- pDvmDex->pResMethods movl (%eax,%ecx,4),%eax # eax<- resolved baseMethod testl %eax,%eax # already resolved? jne .LOP_INVOKE_VIRTUAL_RANGE_continue # yes, continue - movl rGLUE,%eax + movl rSELF,%eax movl %ecx,OUT_ARG1(%esp) # arg1<- ref - movl offGlue_method(%eax),%eax # eax<- glue->method + movl offThread_method(%eax),%eax # eax<- self->method jmp .LOP_INVOKE_VIRTUAL_RANGE_more @@ -3245,13 +3241,13 @@ dvmAsmInstructionStart = .L_OP_NOP */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - movl rGLUE,rINST + movl rSELF,rINST movzwl 2(rPC),%eax # eax<- BBBB - movl offGlue_methodClassDex(rINST),%ecx # ecx<- pDvmDex + movl offThread_methodClassDex(rINST),%ecx # ecx<- pDvmDex EXPORT_PC movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods movl (%ecx,%eax,4),%ecx # ecx<- resolved baseMethod - movl offGlue_method(rINST),%eax # eax<- method + movl offThread_method(rINST),%eax # eax<- method movzwl 4(rPC),rINST # rINST<- GFED or CCCC .if (!1) andl $0xf,rINST # rINST<- D (or stays CCCC) @@ -3282,9 +3278,9 @@ dvmAsmInstructionStart = .L_OP_NOP */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- BBBB - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- pDvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex EXPORT_PC movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods movzwl 4(rPC),%edx # edx<- GFED or CCCC @@ -3313,16 +3309,16 @@ dvmAsmInstructionStart = .L_OP_NOP */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- BBBB - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- pDvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex EXPORT_PC movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods movl (%ecx,%eax,4),%eax # eax<- resolved methodToCall testl %eax,%eax jne common_invokeMethodRange - movl rGLUE,%ecx - movl offGlue_method(%ecx),%ecx # ecx<- glue->method + movl rSELF,%ecx + movl offThread_method(%ecx),%ecx # ecx<- self->method movzwl 2(rPC),%eax movl offMethod_clazz(%ecx),%ecx# ecx<- method->clazz movl %eax,OUT_ARG1(%esp) # arg1<- BBBB @@ -3343,7 +3339,7 @@ dvmAsmInstructionStart = .L_OP_NOP /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ movzwl 4(rPC),%eax # eax<- FEDC or CCCC - movl rGLUE,%ecx + movl rSELF,%ecx .if (!1) andl $0xf,%eax # eax<- C (or stays CCCC) .endif @@ -3353,8 +3349,8 @@ dvmAsmInstructionStart = .L_OP_NOP je common_errNullObject # yes, fail movl offObject_clazz(%eax),%eax# eax<- thisPtr->clazz movl %eax,OUT_ARG0(%esp) # arg0<- class - movl offGlue_methodClassDex(%ecx),%eax # eax<- methodClassDex - movl offGlue_method(%ecx),%ecx # ecx<- method + movl offThread_methodClassDex(%ecx),%eax # eax<- methodClassDex + movl offThread_method(%ecx),%ecx # ecx<- method movl %eax,OUT_ARG3(%esp) # arg3<- dex movzwl 2(rPC),%eax # eax<- BBBB movl %ecx,OUT_ARG2(%esp) # arg2<- method @@ -5889,9 +5885,9 @@ dvmAsmInstructionStart = .L_OP_NOP * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short */ /* op vA, vB, field@CCCC */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%edx # edx<- 0000CCCC - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzbl rINSTbl,%ecx # ecx<- BA sarl $4,%ecx # ecx<- B movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields @@ -5901,7 +5897,7 @@ dvmAsmInstructionStart = .L_OP_NOP testl %eax,%eax # is resolved entry null? jne .LOP_IGET_VOLATILE_finish # no, already resolved movl %edx,OUT_ARG1(%esp) # needed by dvmResolveInstField - movl rGLUE,%edx + movl rSELF,%edx jmp .LOP_IGET_VOLATILE_resolve @@ -5917,9 +5913,9 @@ dvmAsmInstructionStart = .L_OP_NOP * for: iput, iput-object, iput-boolean, iput-byte, iput-char, iput-short */ /* op vA, vB, field@CCCC */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%edx # %edx<- 0000CCCC - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzbl rINSTbl,%ecx # ecx<- BA sarl $4,%ecx # ecx<- B movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields @@ -5929,7 +5925,7 @@ dvmAsmInstructionStart = .L_OP_NOP testl %eax,%eax # is resolved entry null? jne .LOP_IPUT_VOLATILE_finish # no, already resolved movl %edx,OUT_ARG1(%esp) - movl rGLUE,%edx + movl rSELF,%edx jmp .LOP_IPUT_VOLATILE_resolve @@ -5944,9 +5940,9 @@ dvmAsmInstructionStart = .L_OP_NOP * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr testl %eax,%eax # resolved entry null? @@ -5970,9 +5966,9 @@ dvmAsmInstructionStart = .L_OP_NOP * for: sput, sput-boolean, sput-byte, sput-char, sput-short */ /* op vAA, field@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr testl %eax,%eax # resolved entry null? @@ -5996,9 +5992,9 @@ dvmAsmInstructionStart = .L_OP_NOP * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short */ /* op vA, vB, field@CCCC */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%edx # edx<- 0000CCCC - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzbl rINSTbl,%ecx # ecx<- BA sarl $4,%ecx # ecx<- B movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields @@ -6008,7 +6004,7 @@ dvmAsmInstructionStart = .L_OP_NOP testl %eax,%eax # is resolved entry null? jne .LOP_IGET_OBJECT_VOLATILE_finish # no, already resolved movl %edx,OUT_ARG1(%esp) # needed by dvmResolveInstField - movl rGLUE,%edx + movl rSELF,%edx jmp .LOP_IGET_OBJECT_VOLATILE_resolve @@ -6016,44 +6012,44 @@ dvmAsmInstructionStart = .L_OP_NOP .balign 64 .L_OP_IGET_WIDE_VOLATILE: /* 0xe8 */ /* (stub) */ - SAVE_PC_FP_TO_GLUE %ecx # leaves rGLUE in %ecx - movl %ecx,OUT_ARG0(%esp) # glue is first arg to function + SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx + movl %ecx,OUT_ARG0(%esp) # self is first arg to function call dvmMterp_OP_IGET_WIDE_VOLATILE # do the real work - mov rGLUE,%ecx - LOAD_PC_FP_FROM_GLUE # retrieve updated values + mov rSELF,%ecx + LOAD_PC_FP_FROM_SELF # retrieve updated values FETCH_INST GOTO_NEXT /* ------------------------------ */ .balign 64 .L_OP_IPUT_WIDE_VOLATILE: /* 0xe9 */ /* (stub) */ - SAVE_PC_FP_TO_GLUE %ecx # leaves rGLUE in %ecx - movl %ecx,OUT_ARG0(%esp) # glue is first arg to function + SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx + movl %ecx,OUT_ARG0(%esp) # self is first arg to function call dvmMterp_OP_IPUT_WIDE_VOLATILE # do the real work - mov rGLUE,%ecx - LOAD_PC_FP_FROM_GLUE # retrieve updated values + mov rSELF,%ecx + LOAD_PC_FP_FROM_SELF # retrieve updated values FETCH_INST GOTO_NEXT /* ------------------------------ */ .balign 64 .L_OP_SGET_WIDE_VOLATILE: /* 0xea */ /* (stub) */ - SAVE_PC_FP_TO_GLUE %ecx # leaves rGLUE in %ecx - movl %ecx,OUT_ARG0(%esp) # glue is first arg to function + SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx + movl %ecx,OUT_ARG0(%esp) # self is first arg to function call dvmMterp_OP_SGET_WIDE_VOLATILE # do the real work - mov rGLUE,%ecx - LOAD_PC_FP_FROM_GLUE # retrieve updated values + mov rSELF,%ecx + LOAD_PC_FP_FROM_SELF # retrieve updated values FETCH_INST GOTO_NEXT /* ------------------------------ */ .balign 64 .L_OP_SPUT_WIDE_VOLATILE: /* 0xeb */ /* (stub) */ - SAVE_PC_FP_TO_GLUE %ecx # leaves rGLUE in %ecx - movl %ecx,OUT_ARG0(%esp) # glue is first arg to function + SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx + movl %ecx,OUT_ARG0(%esp) # self is first arg to function call dvmMterp_OP_SPUT_WIDE_VOLATILE # do the real work - mov rGLUE,%ecx - LOAD_PC_FP_FROM_GLUE # retrieve updated values + mov rSELF,%ecx + LOAD_PC_FP_FROM_SELF # retrieve updated values FETCH_INST GOTO_NEXT /* ------------------------------ */ @@ -6074,9 +6070,9 @@ dvmAsmInstructionStart = .L_OP_NOP * exception is indicated by AA, with some detail provided by BBBB. */ /* op AA, ref@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- BBBB - movl offGlue_method(%ecx),%ecx # ecx<- glue->method + movl offThread_method(%ecx),%ecx # ecx<- self->method EXPORT_PC movl %eax,OUT_ARG2(%esp) # arg2<- BBBB movl rINST,OUT_ARG1(%esp) # arg1<- AA @@ -6099,10 +6095,10 @@ dvmAsmInstructionStart = .L_OP_NOP * */ /* [opt] execute-inline vAA, {vC, vD, vE, vF}, inline@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx EXPORT_PC movzwl 2(rPC),%eax # eax<- BBBB - leal offGlue_retval(%ecx),%ecx # ecx<- & glue->retval + leal offThread_retval(%ecx),%ecx # ecx<- & self->retval movl %ecx,OUT_ARG4(%esp) call .LOP_EXECUTE_INLINE_continue # make call; will return after testl %eax,%eax # successful? @@ -6115,33 +6111,33 @@ dvmAsmInstructionStart = .L_OP_NOP .balign 64 .L_OP_EXECUTE_INLINE_RANGE: /* 0xef */ /* (stub) */ - SAVE_PC_FP_TO_GLUE %ecx # leaves rGLUE in %ecx - movl %ecx,OUT_ARG0(%esp) # glue is first arg to function + SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx + movl %ecx,OUT_ARG0(%esp) # self is first arg to function call dvmMterp_OP_EXECUTE_INLINE_RANGE # do the real work - mov rGLUE,%ecx - LOAD_PC_FP_FROM_GLUE # retrieve updated values + mov rSELF,%ecx + LOAD_PC_FP_FROM_SELF # retrieve updated values FETCH_INST GOTO_NEXT /* ------------------------------ */ .balign 64 .L_OP_INVOKE_OBJECT_INIT: /* 0xf0 */ /* (stub) */ - SAVE_PC_FP_TO_GLUE %ecx # leaves rGLUE in %ecx - movl %ecx,OUT_ARG0(%esp) # glue is first arg to function + SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx + movl %ecx,OUT_ARG0(%esp) # self is first arg to function call dvmMterp_OP_INVOKE_OBJECT_INIT # do the real work - mov rGLUE,%ecx - LOAD_PC_FP_FROM_GLUE # retrieve updated values + mov rSELF,%ecx + LOAD_PC_FP_FROM_SELF # retrieve updated values FETCH_INST GOTO_NEXT /* ------------------------------ */ .balign 64 .L_OP_RETURN_VOID_BARRIER: /* 0xf1 */ /* (stub) */ - SAVE_PC_FP_TO_GLUE %ecx # leaves rGLUE in %ecx - movl %ecx,OUT_ARG0(%esp) # glue is first arg to function + SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx + movl %ecx,OUT_ARG0(%esp) # self is first arg to function call dvmMterp_OP_RETURN_VOID_BARRIER # do the real work - mov rGLUE,%ecx - LOAD_PC_FP_FROM_GLUE # retrieve updated values + mov rSELF,%ecx + LOAD_PC_FP_FROM_SELF # retrieve updated values FETCH_INST GOTO_NEXT /* ------------------------------ */ @@ -6262,7 +6258,7 @@ dvmAsmInstructionStart = .L_OP_NOP testl %ecx,%ecx # is object null? je common_errNullObject movl rINST,(%ecx,%eax,1) - movl rGLUE,%eax + movl rSELF,%eax jmp .LOP_IPUT_OBJECT_QUICK_finish /* ------------------------------ */ @@ -6328,9 +6324,9 @@ dvmAsmInstructionStart = .L_OP_NOP */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 4(rPC),%eax # eax<- GFED or CCCC - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method .if (!0) andl $0xf,%eax # eax<- D (or stays CCCC) .endif @@ -6357,9 +6353,9 @@ dvmAsmInstructionStart = .L_OP_NOP */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 4(rPC),%eax # eax<- GFED or CCCC - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method .if (!1) andl $0xf,%eax # eax<- D (or stays CCCC) .endif @@ -6386,9 +6382,9 @@ dvmAsmInstructionStart = .L_OP_NOP * for: iput-object */ /* op vA, vB, field@CCCC */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%edx # edx<- 0000CCCC - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzbl rINSTbl,%ecx # ecx<- BA sarl $4,%ecx # ecx<- B movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields @@ -6398,7 +6394,7 @@ dvmAsmInstructionStart = .L_OP_NOP testl %eax,%eax # is resolved entry null? jne .LOP_IPUT_OBJECT_VOLATILE_finish # no, already resolved movl %edx,OUT_ARG1(%esp) - movl rGLUE,%edx + movl rSELF,%edx jmp .LOP_IPUT_OBJECT_VOLATILE_resolve @@ -6413,9 +6409,9 @@ dvmAsmInstructionStart = .L_OP_NOP * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr testl %eax,%eax # resolved entry null? @@ -6437,9 +6433,9 @@ dvmAsmInstructionStart = .L_OP_NOP * SPUT object handler. */ /* op vAA, field@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField testl %eax,%eax # resolved entry null? @@ -6462,9 +6458,9 @@ dvmAsmInstructionStart = .L_OP_NOP .L_OP_CONST_CLASS_JUMBO: /* 0x100 */ /* File: x86/OP_CONST_CLASS_JUMBO.S */ /* const-class/jumbo vBBBB, Class@AAAAAAAA */ - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%eax # eax<- AAAAAAAA - movl offGlue_methodClassDex(%ecx),%ecx# ecx<- glue->methodClassDex + movl offThread_methodClassDex(%ecx),%ecx# ecx<- self->methodClassDex movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- dvmDex->pResClasses movl (%ecx,%eax,4),%eax # eax<- rResClasses[AAAAAAAA] FETCH_INST_OPCODE 4 %edx @@ -6482,10 +6478,10 @@ dvmAsmInstructionStart = .L_OP_NOP * Check to see if a cast from one class to another is allowed. */ /* check-cast/jumbo vBBBB, class@AAAAAAAA */ - movl rGLUE,%ecx + movl rSELF,%ecx GET_VREG_R rINST,rINST # rINST<- vBBBB (object) movl 2(rPC),%eax # eax<- AAAAAAAA - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- pDvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex testl rINST,rINST # is oject null? movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses je .LOP_CHECK_CAST_JUMBO_okay # null obj, cast always succeeds @@ -6514,9 +6510,9 @@ dvmAsmInstructionStart = .L_OP_NOP /* instance-of/jumbo vBBBB, vCCCC, class@AAAAAAAA */ movzwl 8(rPC),%eax # eax<- CCCC GET_VREG_R %eax %eax # eax<- vCCCC (obj) - movl rGLUE,%ecx + movl rSELF,%ecx testl %eax,%eax # object null? - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- pDvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex je .LOP_INSTANCE_OF_JUMBO_store # null obj, not instance, store it movl 2(rPC),%edx # edx<- AAAAAAAA movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses @@ -6537,9 +6533,9 @@ dvmAsmInstructionStart = .L_OP_NOP * Create a new instance of a class. */ /* new-instance/jumbo vBBBB, class@AAAAAAAA */ - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%eax # eax<- AAAAAAAA - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- pDvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses EXPORT_PC movl (%ecx,%eax,4),%ecx # ecx<- resolved class @@ -6562,9 +6558,9 @@ dvmAsmInstructionStart = .L_OP_NOP * check for it here. */ /* new-array/jumbo vBBBB, vCCCC, class@AAAAAAAA */ - movl rGLUE,%ecx + movl rSELF,%ecx EXPORT_PC - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- pDvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex movl 2(rPC),%eax # eax<- AAAAAAAA movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses movl (%ecx,%eax,4),%ecx # ecx<- resolved class @@ -6584,8 +6580,8 @@ dvmAsmInstructionStart = .L_OP_NOP * Create a new array with elements filled from registers. */ /* filled-new-array/jumbo {vCCCC..v(CCCC+BBBB-1)}, type@AAAAAAAA */ - movl rGLUE,%eax - movl offGlue_methodClassDex(%eax),%eax # eax<- pDvmDex + movl rSELF,%eax + movl offThread_methodClassDex(%eax),%eax # eax<- pDvmDex movl 2(rPC),%ecx # ecx<- AAAAAAAA movl offDvmDex_pResClasses(%eax),%eax # eax<- pDvmDex->pResClasses movl (%eax,%ecx,4),%eax # eax<- resolved class @@ -6593,10 +6589,10 @@ dvmAsmInstructionStart = .L_OP_NOP testl %eax,%eax # already resolved? jne .LOP_FILLED_NEW_ARRAY_JUMBO_continue # yes, continue # less frequent path, so we'll redo some work - movl rGLUE,%eax + movl rSELF,%eax movl $0,OUT_ARG2(%esp) # arg2<- false movl %ecx,OUT_ARG1(%esp) # arg1<- AAAAAAAA - movl offGlue_method(%eax),%eax # eax<- glue->method + movl offThread_method(%eax),%eax # eax<- self->method jmp .LOP_FILLED_NEW_ARRAY_JUMBO_more /* ------------------------------ */ @@ -6610,9 +6606,9 @@ dvmAsmInstructionStart = .L_OP_NOP * iget-char/jumbo, iget-short/jumbo */ /* exop vBBBB, vCCCC, field@AAAAAAAA */ - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%edx # edx<- AAAAAAAA - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzwl 8(rPC),%ecx # ecx<- CCCC movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr @@ -6620,7 +6616,7 @@ dvmAsmInstructionStart = .L_OP_NOP testl %eax,%eax # is resolved entry null? jne .LOP_IGET_JUMBO_finish # no, already resolved movl %edx,OUT_ARG1(%esp) # needed by dvmResolveInstField - movl rGLUE,%edx + movl rSELF,%edx jmp .LOP_IGET_JUMBO_resolve /* ------------------------------ */ @@ -6631,9 +6627,9 @@ dvmAsmInstructionStart = .L_OP_NOP * Jumbo 64-bit instance field get. */ /* iget-wide/jumbo vBBBB, vCCCC, field@AAAA */ - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%edx # edx<- AAAAAAAA - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzwl 8(rPC),%ecx # ecx<- CCCC movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr @@ -6641,7 +6637,7 @@ dvmAsmInstructionStart = .L_OP_NOP testl %eax,%eax # is resolved entry null? jne .LOP_IGET_WIDE_JUMBO_finish # no, already resolved movl %edx,OUT_ARG1(%esp) # for dvmResolveInstField - movl rGLUE,%edx + movl rSELF,%edx jmp .LOP_IGET_WIDE_JUMBO_resolve /* ------------------------------ */ @@ -6656,9 +6652,9 @@ dvmAsmInstructionStart = .L_OP_NOP * iget-char/jumbo, iget-short/jumbo */ /* exop vBBBB, vCCCC, field@AAAAAAAA */ - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%edx # edx<- AAAAAAAA - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzwl 8(rPC),%ecx # ecx<- CCCC movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr @@ -6666,7 +6662,7 @@ dvmAsmInstructionStart = .L_OP_NOP testl %eax,%eax # is resolved entry null? jne .LOP_IGET_OBJECT_JUMBO_finish # no, already resolved movl %edx,OUT_ARG1(%esp) # needed by dvmResolveInstField - movl rGLUE,%edx + movl rSELF,%edx jmp .LOP_IGET_OBJECT_JUMBO_resolve @@ -6682,9 +6678,9 @@ dvmAsmInstructionStart = .L_OP_NOP * iget-char/jumbo, iget-short/jumbo */ /* exop vBBBB, vCCCC, field@AAAAAAAA */ - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%edx # edx<- AAAAAAAA - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzwl 8(rPC),%ecx # ecx<- CCCC movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr @@ -6692,7 +6688,7 @@ dvmAsmInstructionStart = .L_OP_NOP testl %eax,%eax # is resolved entry null? jne .LOP_IGET_BOOLEAN_JUMBO_finish # no, already resolved movl %edx,OUT_ARG1(%esp) # needed by dvmResolveInstField - movl rGLUE,%edx + movl rSELF,%edx jmp .LOP_IGET_BOOLEAN_JUMBO_resolve @@ -6708,9 +6704,9 @@ dvmAsmInstructionStart = .L_OP_NOP * iget-char/jumbo, iget-short/jumbo */ /* exop vBBBB, vCCCC, field@AAAAAAAA */ - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%edx # edx<- AAAAAAAA - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzwl 8(rPC),%ecx # ecx<- CCCC movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr @@ -6718,7 +6714,7 @@ dvmAsmInstructionStart = .L_OP_NOP testl %eax,%eax # is resolved entry null? jne .LOP_IGET_BYTE_JUMBO_finish # no, already resolved movl %edx,OUT_ARG1(%esp) # needed by dvmResolveInstField - movl rGLUE,%edx + movl rSELF,%edx jmp .LOP_IGET_BYTE_JUMBO_resolve @@ -6734,9 +6730,9 @@ dvmAsmInstructionStart = .L_OP_NOP * iget-char/jumbo, iget-short/jumbo */ /* exop vBBBB, vCCCC, field@AAAAAAAA */ - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%edx # edx<- AAAAAAAA - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzwl 8(rPC),%ecx # ecx<- CCCC movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr @@ -6744,7 +6740,7 @@ dvmAsmInstructionStart = .L_OP_NOP testl %eax,%eax # is resolved entry null? jne .LOP_IGET_CHAR_JUMBO_finish # no, already resolved movl %edx,OUT_ARG1(%esp) # needed by dvmResolveInstField - movl rGLUE,%edx + movl rSELF,%edx jmp .LOP_IGET_CHAR_JUMBO_resolve @@ -6760,9 +6756,9 @@ dvmAsmInstructionStart = .L_OP_NOP * iget-char/jumbo, iget-short/jumbo */ /* exop vBBBB, vCCCC, field@AAAAAAAA */ - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%edx # edx<- AAAAAAAA - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzwl 8(rPC),%ecx # ecx<- CCCC movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr @@ -6770,7 +6766,7 @@ dvmAsmInstructionStart = .L_OP_NOP testl %eax,%eax # is resolved entry null? jne .LOP_IGET_SHORT_JUMBO_finish # no, already resolved movl %edx,OUT_ARG1(%esp) # needed by dvmResolveInstField - movl rGLUE,%edx + movl rSELF,%edx jmp .LOP_IGET_SHORT_JUMBO_resolve @@ -6785,9 +6781,9 @@ dvmAsmInstructionStart = .L_OP_NOP iput-char/jumbo, iput-short/jumbo */ /* exop vBBBB, vCCCC, field@AAAAAAAA */ - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%edx # edx<- AAAAAAAA - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzwl 8(rPC),%ecx # ecx<- CCCC movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr @@ -6795,7 +6791,7 @@ dvmAsmInstructionStart = .L_OP_NOP testl %eax,%eax # is resolved entry null? jne .LOP_IPUT_JUMBO_finish # no, already resolved movl %edx,OUT_ARG1(%esp) - movl rGLUE,%edx + movl rSELF,%edx jmp .LOP_IPUT_JUMBO_resolve /* ------------------------------ */ @@ -6806,9 +6802,9 @@ dvmAsmInstructionStart = .L_OP_NOP * Jumbo 64-bit instance field put. */ /* iput-wide/jumbo vBBBB, vCCCC, field@AAAAAAAA */ - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%edx # edx<- AAAAAAAA - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzwl 8(rPC),%ecx # ecx<- CCCC movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr @@ -6816,7 +6812,7 @@ dvmAsmInstructionStart = .L_OP_NOP testl %eax,%eax # is resolved entry null? jne .LOP_IPUT_WIDE_JUMBO_finish # no, already resolved movl %edx,OUT_ARG1(%esp) - movl rGLUE,%edx + movl rSELF,%edx jmp .LOP_IPUT_WIDE_JUMBO_resolve /* ------------------------------ */ @@ -6827,9 +6823,9 @@ dvmAsmInstructionStart = .L_OP_NOP * Jumbo object field put. */ /* iput-object/jumbo vBBBB, vCCCC, field@AAAAAAAA */ - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%edx # edx<- AAAAAAAA - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzwl 8(rPC),%ecx # ecx<- CCCC movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr @@ -6837,7 +6833,7 @@ dvmAsmInstructionStart = .L_OP_NOP testl %eax,%eax # is resolved entry null? jne .LOP_IPUT_OBJECT_JUMBO_finish # no, already resolved movl %edx,OUT_ARG1(%esp) - movl rGLUE,%edx + movl rSELF,%edx jmp .LOP_IPUT_OBJECT_JUMBO_resolve /* ------------------------------ */ @@ -6852,9 +6848,9 @@ dvmAsmInstructionStart = .L_OP_NOP iput-char/jumbo, iput-short/jumbo */ /* exop vBBBB, vCCCC, field@AAAAAAAA */ - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%edx # edx<- AAAAAAAA - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzwl 8(rPC),%ecx # ecx<- CCCC movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr @@ -6862,7 +6858,7 @@ dvmAsmInstructionStart = .L_OP_NOP testl %eax,%eax # is resolved entry null? jne .LOP_IPUT_BOOLEAN_JUMBO_finish # no, already resolved movl %edx,OUT_ARG1(%esp) - movl rGLUE,%edx + movl rSELF,%edx jmp .LOP_IPUT_BOOLEAN_JUMBO_resolve @@ -6878,9 +6874,9 @@ dvmAsmInstructionStart = .L_OP_NOP iput-char/jumbo, iput-short/jumbo */ /* exop vBBBB, vCCCC, field@AAAAAAAA */ - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%edx # edx<- AAAAAAAA - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzwl 8(rPC),%ecx # ecx<- CCCC movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr @@ -6888,7 +6884,7 @@ dvmAsmInstructionStart = .L_OP_NOP testl %eax,%eax # is resolved entry null? jne .LOP_IPUT_BYTE_JUMBO_finish # no, already resolved movl %edx,OUT_ARG1(%esp) - movl rGLUE,%edx + movl rSELF,%edx jmp .LOP_IPUT_BYTE_JUMBO_resolve @@ -6904,9 +6900,9 @@ dvmAsmInstructionStart = .L_OP_NOP iput-char/jumbo, iput-short/jumbo */ /* exop vBBBB, vCCCC, field@AAAAAAAA */ - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%edx # edx<- AAAAAAAA - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzwl 8(rPC),%ecx # ecx<- CCCC movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr @@ -6914,7 +6910,7 @@ dvmAsmInstructionStart = .L_OP_NOP testl %eax,%eax # is resolved entry null? jne .LOP_IPUT_CHAR_JUMBO_finish # no, already resolved movl %edx,OUT_ARG1(%esp) - movl rGLUE,%edx + movl rSELF,%edx jmp .LOP_IPUT_CHAR_JUMBO_resolve @@ -6930,9 +6926,9 @@ dvmAsmInstructionStart = .L_OP_NOP iput-char/jumbo, iput-short/jumbo */ /* exop vBBBB, vCCCC, field@AAAAAAAA */ - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%edx # edx<- AAAAAAAA - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzwl 8(rPC),%ecx # ecx<- CCCC movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr @@ -6940,7 +6936,7 @@ dvmAsmInstructionStart = .L_OP_NOP testl %eax,%eax # is resolved entry null? jne .LOP_IPUT_SHORT_JUMBO_finish # no, already resolved movl %edx,OUT_ARG1(%esp) - movl rGLUE,%edx + movl rSELF,%edx jmp .LOP_IPUT_SHORT_JUMBO_resolve @@ -6955,8 +6951,8 @@ dvmAsmInstructionStart = .L_OP_NOP * sget-char/jumbo, sget-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - movl rGLUE,%ecx - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl rSELF,%ecx + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl 2(rPC),%eax # eax<- field ref AAAAAAAA movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr @@ -6978,8 +6974,8 @@ dvmAsmInstructionStart = .L_OP_NOP * */ /* sget-wide/jumbo vBBBB, field@AAAAAAAA */ - movl rGLUE,%ecx - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl rSELF,%ecx + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl 2(rPC),%eax # eax<- field ref AAAAAAAA movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr @@ -7006,8 +7002,8 @@ dvmAsmInstructionStart = .L_OP_NOP * sget-char/jumbo, sget-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - movl rGLUE,%ecx - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl rSELF,%ecx + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl 2(rPC),%eax # eax<- field ref AAAAAAAA movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr @@ -7033,8 +7029,8 @@ dvmAsmInstructionStart = .L_OP_NOP * sget-char/jumbo, sget-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - movl rGLUE,%ecx - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl rSELF,%ecx + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl 2(rPC),%eax # eax<- field ref AAAAAAAA movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr @@ -7060,8 +7056,8 @@ dvmAsmInstructionStart = .L_OP_NOP * sget-char/jumbo, sget-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - movl rGLUE,%ecx - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl rSELF,%ecx + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl 2(rPC),%eax # eax<- field ref AAAAAAAA movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr @@ -7087,8 +7083,8 @@ dvmAsmInstructionStart = .L_OP_NOP * sget-char/jumbo, sget-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - movl rGLUE,%ecx - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl rSELF,%ecx + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl 2(rPC),%eax # eax<- field ref AAAAAAAA movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr @@ -7114,8 +7110,8 @@ dvmAsmInstructionStart = .L_OP_NOP * sget-char/jumbo, sget-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - movl rGLUE,%ecx - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl rSELF,%ecx + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl 2(rPC),%eax # eax<- field ref AAAAAAAA movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr @@ -7140,8 +7136,8 @@ dvmAsmInstructionStart = .L_OP_NOP * sput-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - movl rGLUE,%ecx - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl rSELF,%ecx + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl 2(rPC),%eax # eax<- field ref AAAAAAAA movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr @@ -7162,8 +7158,8 @@ dvmAsmInstructionStart = .L_OP_NOP * Jumbo 64-bit SPUT handler. */ /* sput-wide/jumbo vBBBB, field@AAAAAAAA */ - movl rGLUE,%ecx - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl rSELF,%ecx + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl 2(rPC),%eax # eax<- field ref AAAAAAAA movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr @@ -7186,9 +7182,9 @@ dvmAsmInstructionStart = .L_OP_NOP * Jumbo SPUT object handler. */ /* sput-object/jumbo vBBBB, field@AAAAAAAA */ - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%eax # eax<- field ref AAAAAAAA - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField testl %eax,%eax # resolved entry null? @@ -7209,8 +7205,8 @@ dvmAsmInstructionStart = .L_OP_NOP * sput-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - movl rGLUE,%ecx - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl rSELF,%ecx + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl 2(rPC),%eax # eax<- field ref AAAAAAAA movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr @@ -7236,8 +7232,8 @@ dvmAsmInstructionStart = .L_OP_NOP * sput-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - movl rGLUE,%ecx - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl rSELF,%ecx + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl 2(rPC),%eax # eax<- field ref AAAAAAAA movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr @@ -7263,8 +7259,8 @@ dvmAsmInstructionStart = .L_OP_NOP * sput-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - movl rGLUE,%ecx - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl rSELF,%ecx + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl 2(rPC),%eax # eax<- field ref AAAAAAAA movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr @@ -7290,8 +7286,8 @@ dvmAsmInstructionStart = .L_OP_NOP * sput-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - movl rGLUE,%ecx - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl rSELF,%ecx + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl 2(rPC),%eax # eax<- field ref AAAAAAAA movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr @@ -7313,17 +7309,17 @@ dvmAsmInstructionStart = .L_OP_NOP * Handle a jumbo virtual method call. */ /* invoke-virtual/jumbo vBBBB, {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ - movl rGLUE,%eax + movl rSELF,%eax movl 2(rPC),%ecx # ecx<- AAAAAAAA - movl offGlue_methodClassDex(%eax),%eax # eax<- pDvmDex + movl offThread_methodClassDex(%eax),%eax # eax<- pDvmDex EXPORT_PC movl offDvmDex_pResMethods(%eax),%eax # eax<- pDvmDex->pResMethods movl (%eax,%ecx,4),%eax # eax<- resolved baseMethod testl %eax,%eax # already resolved? jne .LOP_INVOKE_VIRTUAL_JUMBO_continue # yes, continue - movl rGLUE,%eax + movl rSELF,%eax movl %ecx,OUT_ARG1(%esp) # arg1<- ref - movl offGlue_method(%eax),%eax # eax<- glue->method + movl offThread_method(%eax),%eax # eax<- self->method jmp .LOP_INVOKE_VIRTUAL_JUMBO_more /* ------------------------------ */ @@ -7334,13 +7330,13 @@ dvmAsmInstructionStart = .L_OP_NOP * Handle a jumbo "super" method call. */ /* invoke-super/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ - movl rGLUE,rINST + movl rSELF,rINST movl 2(rPC),%eax # eax<- AAAAAAAA - movl offGlue_methodClassDex(rINST),%ecx # ecx<- pDvmDex + movl offThread_methodClassDex(rINST),%ecx # ecx<- pDvmDex EXPORT_PC movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods movl (%ecx,%eax,4),%ecx # ecx<- resolved baseMethod - movl offGlue_method(rINST),%eax # eax<- method + movl offThread_method(rINST),%eax # eax<- method movzwl 8(rPC),rINST # rINST<- CCCC GET_VREG_R rINST rINST # rINST<- "this" ptr testl rINST,rINST # null "this"? @@ -7363,9 +7359,9 @@ dvmAsmInstructionStart = .L_OP_NOP * out we could avoiding loading the first arg twice.) */ /* invoke-direct/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%eax # eax<- AAAAAAAA - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- pDvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex EXPORT_PC movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods movzwl 8(rPC),%edx # edx<- CCCC @@ -7386,16 +7382,16 @@ dvmAsmInstructionStart = .L_OP_NOP * Handle a jumbo static method call. */ /* invoke-static/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%eax # eax<- AAAAAAAA - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- pDvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex EXPORT_PC movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods movl (%ecx,%eax,4),%eax # eax<- resolved methodToCall testl %eax,%eax jne common_invokeMethodJumbo - movl rGLUE,%ecx - movl offGlue_method(%ecx),%ecx # ecx<- glue->method + movl rSELF,%ecx + movl offThread_method(%ecx),%ecx # ecx<- self->method movl 2(rPC),%eax # eax<- AAAAAAAA movl offMethod_clazz(%ecx),%ecx# ecx<- method->clazz movl %eax,OUT_ARG1(%esp) # arg1<- AAAAAAAA @@ -7411,15 +7407,15 @@ dvmAsmInstructionStart = .L_OP_NOP */ /* invoke-interface/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ movzwl 8(rPC),%eax # eax<- CCCC - movl rGLUE,%ecx + movl rSELF,%ecx GET_VREG_R %eax %eax # eax<- "this" EXPORT_PC testl %eax,%eax # null this? je common_errNullObject # yes, fail movl offObject_clazz(%eax),%eax# eax<- thisPtr->clazz movl %eax,OUT_ARG0(%esp) # arg0<- class - movl offGlue_methodClassDex(%ecx),%eax # eax<- methodClassDex - movl offGlue_method(%ecx),%ecx # ecx<- method + movl offThread_methodClassDex(%ecx),%eax # eax<- methodClassDex + movl offThread_method(%ecx),%ecx # ecx<- method movl %eax,OUT_ARG3(%esp) # arg3<- dex movl 2(rPC),%eax # eax<- AAAAAAAA movl %ecx,OUT_ARG2(%esp) # arg2<- method @@ -9164,9 +9160,9 @@ dvmAsmInstructionStart = .L_OP_NOP * exception is indicated by BBBB, with some detail provided by AAAAAAAA. */ /* exop BBBB, ref@AAAAAAAA */ - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%eax # eax<- AAAAAAAA - movl offGlue_method(%ecx),%ecx # ecx<- glue->method + movl offThread_method(%ecx),%ecx # ecx<- self->method EXPORT_PC movl %eax,OUT_ARG2(%esp) # arg2<- AAAAAAAA movl rINST,OUT_ARG1(%esp) # arg1<- BBBB @@ -9196,10 +9192,10 @@ dvmAsmSisterStart: /* This is the less common path, so we'll redo some work here rather than force spills on the common path */ .LOP_CONST_STRING_resolve: - movl rGLUE,%eax + movl rSELF,%eax movl %ecx,rINST # rINST<- AA EXPORT_PC - movl offGlue_method(%eax),%eax # eax<- glue->method + movl offThread_method(%eax),%eax # eax<- self->method movzwl 2(rPC),%ecx # ecx<- BBBB movl offMethod_clazz(%eax),%eax movl %ecx,OUT_ARG1(%esp) @@ -9217,10 +9213,10 @@ dvmAsmSisterStart: /* This is the less common path, so we'll redo some work here rather than force spills on the common path */ .LOP_CONST_STRING_JUMBO_resolve: - movl rGLUE,%eax + movl rSELF,%eax movl %ecx,rINST # rINST<- AA EXPORT_PC - movl offGlue_method(%eax),%eax # eax<- glue->method + movl offThread_method(%eax),%eax # eax<- self->method movl 2(rPC),%ecx # ecx<- BBBBBBBB movl offMethod_clazz(%eax),%eax movl %ecx,OUT_ARG1(%esp) @@ -9238,10 +9234,10 @@ dvmAsmSisterStart: /* This is the less common path, so we'll redo some work here rather than force spills on the common path */ .LOP_CONST_CLASS_resolve: - movl rGLUE,%eax + movl rSELF,%eax movl %ecx,rINST # rINST<- AA EXPORT_PC - movl offGlue_method(%eax),%eax # eax<- glue->method + movl offThread_method(%eax),%eax # eax<- self->method movl $1,OUT_ARG2(%esp) # true movzwl 2(rPC),%ecx # ecx<- BBBB movl offMethod_clazz(%eax),%eax @@ -9309,10 +9305,10 @@ dvmAsmSisterStart: * rINST holds object */ .LOP_CHECK_CAST_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx EXPORT_PC movzwl 2(rPC),%eax # eax<- BBBB - movl offGlue_method(%ecx),%ecx # ecx<- glue->method + movl offThread_method(%ecx),%ecx # ecx<- self->method movl %eax,OUT_ARG1(%esp) # arg1<- BBBB movl offMethod_clazz(%ecx),%ecx # ecx<- metho->clazz movl $0,OUT_ARG2(%esp) # arg2<- false @@ -9368,8 +9364,8 @@ dvmAsmSisterStart: */ .LOP_INSTANCE_OF_resolve: movl %edx,OUT_ARG1(%esp) # arg1<- BBBB - movl rGLUE,%ecx - movl offGlue_method(%ecx),%ecx + movl rSELF,%ecx + movl offThread_method(%ecx),%ecx movl $1,OUT_ARG2(%esp) # arg2<- true movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz EXPORT_PC @@ -9423,9 +9419,9 @@ dvmAsmSisterStart: * */ .LOP_NEW_INSTANCE_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax - movl offGlue_method(%ecx),%ecx # ecx<- glue->method + movl offThread_method(%ecx),%ecx # ecx<- self->method movl %eax,OUT_ARG1(%esp) movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl $0,OUT_ARG2(%esp) @@ -9458,9 +9454,9 @@ dvmAsmSisterStart: * eax holds array length (vB) */ .LOP_NEW_ARRAY_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx SPILL_TMP1(%eax) # save array length - movl offGlue_method(%ecx),%ecx # ecx<- glue->method + movl offThread_method(%ecx),%ecx # ecx<- self->method movzwl 2(rPC),%eax # eax<- CCCC movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) @@ -9513,7 +9509,7 @@ dvmAsmSisterStart: movl $ALLOC_DONT_TRACK,OUT_ARG2(%esp) # arg2<- flags movzbl 1(%ecx),%ecx # ecx<- descriptor[1] movl %eax,OUT_ARG0(%esp) # arg0<- arrayClass - movl rGLUE,%eax + movl rSELF,%eax cmpb $'I',%cl # supported? je 1f cmpb $'L',%cl @@ -9521,17 +9517,17 @@ dvmAsmSisterStart: cmpb $'[',%cl jne .LOP_FILLED_NEW_ARRAY_notimpl # no, not handled yet 1: - movl %ecx,offGlue_retval+4(%eax) # save type + movl %ecx,offThread_retval+4(%eax) # save type .if (!0) SPILL_TMP1(rINST) # save copy, need "B" later sarl $4,rINST .endif movl rINST,OUT_ARG1(%esp) # arg1<- A or AA (length) call dvmAllocArrayByClass # eax<- call(arrayClass, length, flags) - movl rGLUE,%ecx + movl rSELF,%ecx testl %eax,%eax # alloc successful? je common_exceptionThrown # no, handle exception - movl %eax,offGlue_retval(%ecx) # retval.l<- new array + movl %eax,offThread_retval(%ecx) # retval.l<- new array movzwl 4(rPC),%ecx # ecx<- FEDC or CCCC leal offArrayObject_contents(%eax),%eax # eax<- newArray->contents @@ -9554,8 +9550,8 @@ dvmAsmSisterStart: movsd UNSPILL_TMP2(%esi) UNSPILL_TMP3(%edi) - movl rGLUE,%ecx - movl offGlue_retval+4(%ecx),%eax # eax<- type + movl rSELF,%ecx + movl offThread_retval+4(%ecx),%eax # eax<- type FETCH_INST_OPCODE 3 %edx .else testl rINST,rINST @@ -9574,15 +9570,15 @@ dvmAsmSisterStart: sub $1,rINST jne 3b 4: - movl rGLUE,%ecx - movl offGlue_retval+4(%ecx),%eax # eax<- type + movl rSELF,%ecx + movl offThread_retval+4(%ecx),%eax # eax<- type FETCH_INST_OPCODE 3 %edx .endif cmpb $'I',%al # Int array? je 5f # skip card mark if so - movl offGlue_retval(%ecx),%eax # eax<- object head - movl offGlue_cardTable(%ecx),%ecx # card table base + movl offThread_retval(%ecx),%eax # eax<- object head + movl offThread_cardTable(%ecx),%ecx # card table base shrl $GC_CARD_SHIFT,%eax # convert to card num movb %cl,(%ecx,%eax) # mark card based on object head 5: @@ -9624,7 +9620,7 @@ dvmAsmSisterStart: movl $ALLOC_DONT_TRACK,OUT_ARG2(%esp) # arg2<- flags movzbl 1(%ecx),%ecx # ecx<- descriptor[1] movl %eax,OUT_ARG0(%esp) # arg0<- arrayClass - movl rGLUE,%eax + movl rSELF,%eax cmpb $'I',%cl # supported? je 1f cmpb $'L',%cl @@ -9632,17 +9628,17 @@ dvmAsmSisterStart: cmpb $'[',%cl jne .LOP_FILLED_NEW_ARRAY_RANGE_notimpl # no, not handled yet 1: - movl %ecx,offGlue_retval+4(%eax) # save type + movl %ecx,offThread_retval+4(%eax) # save type .if (!1) SPILL_TMP1(rINST) # save copy, need "B" later sarl $4,rINST .endif movl rINST,OUT_ARG1(%esp) # arg1<- A or AA (length) call dvmAllocArrayByClass # eax<- call(arrayClass, length, flags) - movl rGLUE,%ecx + movl rSELF,%ecx testl %eax,%eax # alloc successful? je common_exceptionThrown # no, handle exception - movl %eax,offGlue_retval(%ecx) # retval.l<- new array + movl %eax,offThread_retval(%ecx) # retval.l<- new array movzwl 4(rPC),%ecx # ecx<- FEDC or CCCC leal offArrayObject_contents(%eax),%eax # eax<- newArray->contents @@ -9665,8 +9661,8 @@ dvmAsmSisterStart: movsd UNSPILL_TMP2(%esi) UNSPILL_TMP3(%edi) - movl rGLUE,%ecx - movl offGlue_retval+4(%ecx),%eax # eax<- type + movl rSELF,%ecx + movl offThread_retval+4(%ecx),%eax # eax<- type FETCH_INST_OPCODE 3 %edx .else testl rINST,rINST @@ -9685,15 +9681,15 @@ dvmAsmSisterStart: sub $1,rINST jne 3b 4: - movl rGLUE,%ecx - movl offGlue_retval+4(%ecx),%eax # eax<- type + movl rSELF,%ecx + movl offThread_retval+4(%ecx),%eax # eax<- type FETCH_INST_OPCODE 3 %edx .endif cmpb $'I',%al # Int array? je 5f # skip card mark if so - movl offGlue_retval(%ecx),%eax # eax<- object head - movl offGlue_cardTable(%ecx),%ecx # card table base + movl offThread_retval(%ecx),%eax # eax<- object head + movl offThread_cardTable(%ecx),%ecx # card table base shrl $GC_CARD_SHIFT,%eax # convert to card num movb %cl,(%ecx,%eax) # mark card based on object head 5: @@ -9796,7 +9792,7 @@ dvmAsmSisterStart: call dvmCanPutArrayElement # test object type vs. array type UNSPILL_TMP1(%ecx) # recover target address testl %eax,%eax - movl rGLUE,%eax + movl rSELF,%eax jne .LOP_APUT_OBJECT_types_okay # The types don't match. We need to throw an ArrayStoreException. @@ -9809,7 +9805,7 @@ dvmAsmSisterStart: jmp common_exceptionThrown .LOP_APUT_OBJECT_types_okay: - movl offGlue_cardTable(%eax),%eax # get card table base + movl offThread_cardTable(%eax),%eax # get card table base movl rINST,(%ecx) # store into array UNSPILL_TMP2(%ecx) # recover object head FETCH_INST_OPCODE 2 %edx @@ -9829,7 +9825,7 @@ dvmAsmSisterStart: .LOP_IGET_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save obj pointer across call movl %edx,OUT_ARG0(%esp) # pass in method->clazz @@ -9861,7 +9857,7 @@ dvmAsmSisterStart: .LOP_IGET_WIDE_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save objpointer across call movl rPC,OUT_ARG0(%esp) # pass in method->clazz @@ -9895,7 +9891,7 @@ dvmAsmSisterStart: .LOP_IGET_OBJECT_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save obj pointer across call movl %edx,OUT_ARG0(%esp) # pass in method->clazz @@ -9927,7 +9923,7 @@ dvmAsmSisterStart: .LOP_IGET_BOOLEAN_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save obj pointer across call movl %edx,OUT_ARG0(%esp) # pass in method->clazz @@ -9959,7 +9955,7 @@ dvmAsmSisterStart: .LOP_IGET_BYTE_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save obj pointer across call movl %edx,OUT_ARG0(%esp) # pass in method->clazz @@ -9991,7 +9987,7 @@ dvmAsmSisterStart: .LOP_IGET_CHAR_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save obj pointer across call movl %edx,OUT_ARG0(%esp) # pass in method->clazz @@ -10023,7 +10019,7 @@ dvmAsmSisterStart: .LOP_IGET_SHORT_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save obj pointer across call movl %edx,OUT_ARG0(%esp) # pass in method->clazz @@ -10055,7 +10051,7 @@ dvmAsmSisterStart: .LOP_IPUT_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save obj pointer across call movl %edx,OUT_ARG0(%esp) # pass in method->clazz @@ -10086,7 +10082,7 @@ dvmAsmSisterStart: .LOP_IPUT_WIDE_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save obj pointer across call movl %edx,OUT_ARG0(%esp) # pass in method->clazz @@ -10121,7 +10117,7 @@ dvmAsmSisterStart: .LOP_IPUT_OBJECT_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save obj pointer across call movl %edx,OUT_ARG0(%esp) # pass in method->clazz @@ -10144,9 +10140,9 @@ dvmAsmSisterStart: testl %ecx,%ecx # object null? je common_errNullObject # object was null movl rINST,(%ecx,%eax) # obj.field <- v[A](8/16/32 bits) - movl rGLUE,%eax + movl rSELF,%eax testl rINST,rINST # stored a NULL? - movl offGlue_cardTable(%eax),%eax # get card table base + movl offThread_cardTable(%eax),%eax # get card table base FETCH_INST_OPCODE 2 %edx je 1f # skip card mark if null store shrl $GC_CARD_SHIFT,%ecx # object head to card number @@ -10160,7 +10156,7 @@ dvmAsmSisterStart: .LOP_IPUT_BOOLEAN_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save obj pointer across call movl %edx,OUT_ARG0(%esp) # pass in method->clazz @@ -10191,7 +10187,7 @@ dvmAsmSisterStart: .LOP_IPUT_BYTE_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save obj pointer across call movl %edx,OUT_ARG0(%esp) # pass in method->clazz @@ -10222,7 +10218,7 @@ dvmAsmSisterStart: .LOP_IPUT_CHAR_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save obj pointer across call movl %edx,OUT_ARG0(%esp) # pass in method->clazz @@ -10253,7 +10249,7 @@ dvmAsmSisterStart: .LOP_IPUT_SHORT_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save obj pointer across call movl %edx,OUT_ARG0(%esp) # pass in method->clazz @@ -10285,9 +10281,9 @@ dvmAsmSisterStart: * Go resolve the field */ .LOP_SGET_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) @@ -10303,9 +10299,9 @@ dvmAsmSisterStart: * Go resolve the field */ .LOP_SGET_WIDE_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) @@ -10321,9 +10317,9 @@ dvmAsmSisterStart: * Go resolve the field */ .LOP_SGET_OBJECT_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) @@ -10339,9 +10335,9 @@ dvmAsmSisterStart: * Go resolve the field */ .LOP_SGET_BOOLEAN_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) @@ -10357,9 +10353,9 @@ dvmAsmSisterStart: * Go resolve the field */ .LOP_SGET_BYTE_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) @@ -10375,9 +10371,9 @@ dvmAsmSisterStart: * Go resolve the field */ .LOP_SGET_CHAR_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) @@ -10393,9 +10389,9 @@ dvmAsmSisterStart: * Go resolve the field */ .LOP_SGET_SHORT_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) @@ -10411,9 +10407,9 @@ dvmAsmSisterStart: * Go resolve the field */ .LOP_SPUT_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) @@ -10429,9 +10425,9 @@ dvmAsmSisterStart: * Go resolve the field */ .LOP_SPUT_WIDE_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) @@ -10449,9 +10445,9 @@ dvmAsmSisterStart: testl %ecx,%ecx # stored null object ptr? FETCH_INST_OPCODE 2 %edx je 1f # skip card mark if null - movl rGLUE,%ecx + movl rSELF,%ecx movl offField_clazz(%eax),%eax # eax<- method->clazz - movl offGlue_cardTable(%ecx),%ecx # get card table base + movl offThread_cardTable(%ecx),%ecx # get card table base shrl $GC_CARD_SHIFT,%eax # head to card number movb %cl,(%ecx,%eax) # mark card 1: @@ -10459,9 +10455,9 @@ dvmAsmSisterStart: GOTO_NEXT_R %edx .LOP_SPUT_OBJECT_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) @@ -10477,9 +10473,9 @@ dvmAsmSisterStart: * Go resolve the field */ .LOP_SPUT_BOOLEAN_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) @@ -10495,9 +10491,9 @@ dvmAsmSisterStart: * Go resolve the field */ .LOP_SPUT_BYTE_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) @@ -10513,9 +10509,9 @@ dvmAsmSisterStart: * Go resolve the field */ .LOP_SPUT_CHAR_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) @@ -10531,9 +10527,9 @@ dvmAsmSisterStart: * Go resolve the field */ .LOP_SPUT_SHORT_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) @@ -10626,8 +10622,8 @@ dvmAsmSisterStart: */ .LOP_INVOKE_DIRECT_resolve: SPILL_TMP1(%ecx) - movl rGLUE,%ecx - movl offGlue_method(%ecx),%ecx # ecx<- glue->method + movl rSELF,%ecx + movl offThread_method(%ecx),%ecx # ecx<- self->method movzwl 2(rPC),%eax # reference (BBBB or CCCC) movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl $METHOD_DIRECT,OUT_ARG2(%esp) @@ -10740,8 +10736,8 @@ dvmAsmSisterStart: */ .LOP_INVOKE_DIRECT_RANGE_resolve: SPILL_TMP1(%ecx) - movl rGLUE,%ecx - movl offGlue_method(%ecx),%ecx # ecx<- glue->method + movl rSELF,%ecx + movl offThread_method(%ecx),%ecx # ecx<- self->method movzwl 2(rPC),%eax # reference (BBBB or CCCC) movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl $METHOD_DIRECT,OUT_ARG2(%esp) @@ -11183,7 +11179,7 @@ dvmAsmSisterStart: .LOP_IGET_VOLATILE_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save obj pointer across call movl %edx,OUT_ARG0(%esp) # pass in method->clazz @@ -11215,7 +11211,7 @@ dvmAsmSisterStart: .LOP_IPUT_VOLATILE_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save obj pointer across call movl %edx,OUT_ARG0(%esp) # pass in method->clazz @@ -11247,9 +11243,9 @@ dvmAsmSisterStart: * Go resolve the field */ .LOP_SGET_VOLATILE_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) @@ -11265,9 +11261,9 @@ dvmAsmSisterStart: * Go resolve the field */ .LOP_SPUT_VOLATILE_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) @@ -11282,7 +11278,7 @@ dvmAsmSisterStart: .LOP_IGET_OBJECT_VOLATILE_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save obj pointer across call movl %edx,OUT_ARG0(%esp) # pass in method->clazz @@ -11356,7 +11352,7 @@ dvmAsmSisterStart: .LOP_IPUT_OBJECT_QUICK_finish: testl rINST,rINST # did we store null? FETCH_INST_OPCODE 2 %edx - movl offGlue_cardTable(%eax),%eax # get card table base + movl offThread_cardTable(%eax),%eax # get card table base je 1f # skip card mark if null store shrl $GC_CARD_SHIFT,%ecx # object head to card number movb %al,(%eax,%ecx) # mark card based on object head @@ -11369,7 +11365,7 @@ dvmAsmSisterStart: .LOP_IPUT_OBJECT_VOLATILE_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save obj pointer across call movl %edx,OUT_ARG0(%esp) # pass in method->clazz @@ -11392,9 +11388,9 @@ dvmAsmSisterStart: testl %ecx,%ecx # object null? je common_errNullObject # object was null movl rINST,(%ecx,%eax) # obj.field <- v[A](8/16/32 bits) - movl rGLUE,%eax + movl rSELF,%eax testl rINST,rINST # stored a NULL? - movl offGlue_cardTable(%eax),%eax # get card table base + movl offThread_cardTable(%eax),%eax # get card table base FETCH_INST_OPCODE 2 %edx je 1f # skip card mark if null store shrl $GC_CARD_SHIFT,%ecx # object head to card number @@ -11409,9 +11405,9 @@ dvmAsmSisterStart: * Go resolve the field */ .LOP_SGET_OBJECT_VOLATILE_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) @@ -11429,9 +11425,9 @@ dvmAsmSisterStart: testl %ecx,%ecx # stored null object ptr? FETCH_INST_OPCODE 2 %edx je 1f # skip card mark if null - movl rGLUE,%ecx + movl rSELF,%ecx movl offField_clazz(%eax),%eax # eax<- method->clazz - movl offGlue_cardTable(%ecx),%ecx # get card table base + movl offThread_cardTable(%ecx),%ecx # get card table base shrl $GC_CARD_SHIFT,%eax # head to card number movb %cl,(%ecx,%eax) # mark card 1: @@ -11439,9 +11435,9 @@ dvmAsmSisterStart: GOTO_NEXT_R %edx .LOP_SPUT_OBJECT_VOLATILE_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) @@ -11456,9 +11452,9 @@ dvmAsmSisterStart: /* This is the less common path, so we'll redo some work here rather than force spills on the common path */ .LOP_CONST_CLASS_JUMBO_resolve: - movl rGLUE,%eax + movl rSELF,%eax EXPORT_PC - movl offGlue_method(%eax),%eax # eax<- glue->method + movl offThread_method(%eax),%eax # eax<- self->method movl $1,OUT_ARG2(%esp) # true movl 2(rPC),%ecx # ecx<- AAAAAAAA movl offMethod_clazz(%eax),%eax @@ -11504,10 +11500,10 @@ dvmAsmSisterStart: * rINST holds object */ .LOP_CHECK_CAST_JUMBO_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx EXPORT_PC movl 2(rPC),%eax # eax<- AAAAAAAA - movl offGlue_method(%ecx),%ecx # ecx<- glue->method + movl offThread_method(%ecx),%ecx # ecx<- self->method movl %eax,OUT_ARG1(%esp) # arg1<- AAAAAAAA movl offMethod_clazz(%ecx),%ecx # ecx<- metho->clazz movl $0,OUT_ARG2(%esp) # arg2<- false @@ -11560,8 +11556,8 @@ dvmAsmSisterStart: */ .LOP_INSTANCE_OF_JUMBO_resolve: movl %edx,OUT_ARG1(%esp) # arg1<- AAAAAAAA - movl rGLUE,%ecx - movl offGlue_method(%ecx),%ecx + movl rSELF,%ecx + movl offThread_method(%ecx),%ecx movl $1,OUT_ARG2(%esp) # arg2<- true movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz EXPORT_PC @@ -11614,9 +11610,9 @@ dvmAsmSisterStart: * */ .LOP_NEW_INSTANCE_JUMBO_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%eax # eax<- AAAAAAAA - movl offGlue_method(%ecx),%ecx # ecx<- glue->method + movl offThread_method(%ecx),%ecx # ecx<- self->method movl %eax,OUT_ARG1(%esp) movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl $0,OUT_ARG2(%esp) @@ -11649,9 +11645,9 @@ dvmAsmSisterStart: * eax holds array length (vCCCC) */ .LOP_NEW_ARRAY_JUMBO_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx SPILL_TMP1(%eax) # save array length - movl offGlue_method(%ecx),%ecx # ecx<- glue->method + movl offThread_method(%ecx),%ecx # ecx<- self->method movl 2(rPC),%eax # eax<- AAAAAAAA movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) @@ -11703,7 +11699,7 @@ dvmAsmSisterStart: movl $ALLOC_DONT_TRACK,OUT_ARG2(%esp) # arg2<- flags movzbl 1(%ecx),%ecx # ecx<- descriptor[1] movl %eax,OUT_ARG0(%esp) # arg0<- arrayClass - movl rGLUE,%eax + movl rSELF,%eax cmpb $'I',%cl # supported? je 1f cmpb $'L',%cl @@ -11711,13 +11707,13 @@ dvmAsmSisterStart: cmpb $'[',%cl jne .LOP_FILLED_NEW_ARRAY_JUMBO_notimpl # no, not handled yet 1: - movl %ecx,offGlue_retval+4(%eax) # save type + movl %ecx,offThread_retval+4(%eax) # save type movl rINST,OUT_ARG1(%esp) # arg1<- BBBB (length) call dvmAllocArrayByClass # eax<- call(arrayClass, length, flags) - movl rGLUE,%ecx + movl rSELF,%ecx testl %eax,%eax # alloc successful? je common_exceptionThrown # no, handle exception - movl %eax,offGlue_retval(%ecx) # retval.l<- new array + movl %eax,offThread_retval(%ecx) # retval.l<- new array movzwl 8(rPC),%ecx # ecx<- CCCC leal offArrayObject_contents(%eax),%eax # eax<- newArray->contents @@ -11738,14 +11734,14 @@ dvmAsmSisterStart: movsd UNSPILL_TMP2(%esi) UNSPILL_TMP3(%edi) - movl rGLUE,%ecx - movl offGlue_retval+4(%ecx),%eax # eax<- type + movl rSELF,%ecx + movl offThread_retval+4(%ecx),%eax # eax<- type FETCH_INST_OPCODE 5 %edx cmpb $'I',%al # Int array? je 5f # skip card mark if so - movl offGlue_retval(%ecx),%eax # eax<- object head - movl offGlue_cardTable(%ecx),%ecx # card table base + movl offThread_retval(%ecx),%eax # eax<- object head + movl offThread_cardTable(%ecx),%ecx # card table base shrl $GC_CARD_SHIFT,%eax # convert to card num movb %cl,(%ecx,%eax) # mark card based on object head 5: @@ -11770,7 +11766,7 @@ dvmAsmSisterStart: .LOP_IGET_JUMBO_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save obj pointer across call movl %edx,OUT_ARG0(%esp) # pass in method->clazz @@ -11802,7 +11798,7 @@ dvmAsmSisterStart: .LOP_IGET_WIDE_JUMBO_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save objpointer across call movl rPC,OUT_ARG0(%esp) # pass in method->clazz @@ -11836,7 +11832,7 @@ dvmAsmSisterStart: .LOP_IGET_OBJECT_JUMBO_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save obj pointer across call movl %edx,OUT_ARG0(%esp) # pass in method->clazz @@ -11868,7 +11864,7 @@ dvmAsmSisterStart: .LOP_IGET_BOOLEAN_JUMBO_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save obj pointer across call movl %edx,OUT_ARG0(%esp) # pass in method->clazz @@ -11900,7 +11896,7 @@ dvmAsmSisterStart: .LOP_IGET_BYTE_JUMBO_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save obj pointer across call movl %edx,OUT_ARG0(%esp) # pass in method->clazz @@ -11932,7 +11928,7 @@ dvmAsmSisterStart: .LOP_IGET_CHAR_JUMBO_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save obj pointer across call movl %edx,OUT_ARG0(%esp) # pass in method->clazz @@ -11964,7 +11960,7 @@ dvmAsmSisterStart: .LOP_IGET_SHORT_JUMBO_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save obj pointer across call movl %edx,OUT_ARG0(%esp) # pass in method->clazz @@ -11996,7 +11992,7 @@ dvmAsmSisterStart: .LOP_IPUT_JUMBO_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save obj pointer across call movl %edx,OUT_ARG0(%esp) # pass in method->clazz @@ -12027,7 +12023,7 @@ dvmAsmSisterStart: .LOP_IPUT_WIDE_JUMBO_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save obj pointer across call movl %edx,OUT_ARG0(%esp) # pass in method->clazz @@ -12062,7 +12058,7 @@ dvmAsmSisterStart: .LOP_IPUT_OBJECT_JUMBO_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save obj pointer across call movl %edx,OUT_ARG0(%esp) # pass in method->clazz @@ -12085,9 +12081,9 @@ dvmAsmSisterStart: testl %ecx,%ecx # object null? je common_errNullObject # object was null movl rINST,(%ecx,%eax) # obj.field <- v[BBBB](8/16/32 bits) - movl rGLUE,%eax + movl rSELF,%eax testl rINST,rINST # stored a NULL? - movl offGlue_cardTable(%eax),%eax # get card table base + movl offThread_cardTable(%eax),%eax # get card table base FETCH_INST_OPCODE 5 %edx je 1f # skip card mark if null store shrl $GC_CARD_SHIFT,%ecx # object head to card number @@ -12101,7 +12097,7 @@ dvmAsmSisterStart: .LOP_IPUT_BOOLEAN_JUMBO_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save obj pointer across call movl %edx,OUT_ARG0(%esp) # pass in method->clazz @@ -12132,7 +12128,7 @@ dvmAsmSisterStart: .LOP_IPUT_BYTE_JUMBO_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save obj pointer across call movl %edx,OUT_ARG0(%esp) # pass in method->clazz @@ -12163,7 +12159,7 @@ dvmAsmSisterStart: .LOP_IPUT_CHAR_JUMBO_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save obj pointer across call movl %edx,OUT_ARG0(%esp) # pass in method->clazz @@ -12194,7 +12190,7 @@ dvmAsmSisterStart: .LOP_IPUT_SHORT_JUMBO_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save obj pointer across call movl %edx,OUT_ARG0(%esp) # pass in method->clazz @@ -12226,9 +12222,9 @@ dvmAsmSisterStart: * Go resolve the field */ .LOP_SGET_JUMBO_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%eax # eax<- field ref AAAAAAAA - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) @@ -12244,9 +12240,9 @@ dvmAsmSisterStart: * Go resolve the field */ .LOP_SGET_WIDE_JUMBO_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%eax # eax<- field ref AAAAAAAA - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) @@ -12262,9 +12258,9 @@ dvmAsmSisterStart: * Go resolve the field */ .LOP_SGET_OBJECT_JUMBO_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%eax # eax<- field ref AAAAAAAA - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) @@ -12280,9 +12276,9 @@ dvmAsmSisterStart: * Go resolve the field */ .LOP_SGET_BOOLEAN_JUMBO_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%eax # eax<- field ref AAAAAAAA - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) @@ -12298,9 +12294,9 @@ dvmAsmSisterStart: * Go resolve the field */ .LOP_SGET_BYTE_JUMBO_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%eax # eax<- field ref AAAAAAAA - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) @@ -12316,9 +12312,9 @@ dvmAsmSisterStart: * Go resolve the field */ .LOP_SGET_CHAR_JUMBO_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%eax # eax<- field ref AAAAAAAA - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) @@ -12334,9 +12330,9 @@ dvmAsmSisterStart: * Go resolve the field */ .LOP_SGET_SHORT_JUMBO_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%eax # eax<- field ref AAAAAAAA - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) @@ -12352,9 +12348,9 @@ dvmAsmSisterStart: * Go resolve the field */ .LOP_SPUT_JUMBO_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%eax # eax<- field ref AAAAAAAA - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) @@ -12370,9 +12366,9 @@ dvmAsmSisterStart: * Go resolve the field */ .LOP_SPUT_WIDE_JUMBO_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%eax # eax<- field ref AAAAAAAA - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) @@ -12390,9 +12386,9 @@ dvmAsmSisterStart: testl %ecx,%ecx # stored null object ptr? FETCH_INST_OPCODE 4 %edx je 1f # skip card mark if null - movl rGLUE,%ecx + movl rSELF,%ecx movl offField_clazz(%eax),%eax # eax<- method->clazz - movl offGlue_cardTable(%ecx),%ecx # get card table base + movl offThread_cardTable(%ecx),%ecx # get card table base shrl $GC_CARD_SHIFT,%eax # head to card number movb %cl,(%ecx,%eax) # mark card 1: @@ -12400,9 +12396,9 @@ dvmAsmSisterStart: GOTO_NEXT_R %edx .LOP_SPUT_OBJECT_JUMBO_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%eax # eax<- field ref AAAAAAAA - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) @@ -12418,9 +12414,9 @@ dvmAsmSisterStart: * Go resolve the field */ .LOP_SPUT_BOOLEAN_JUMBO_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%eax # eax<- field ref AAAAAAAA - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) @@ -12436,9 +12432,9 @@ dvmAsmSisterStart: * Go resolve the field */ .LOP_SPUT_BYTE_JUMBO_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%eax # eax<- field ref AAAAAAAA - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) @@ -12454,9 +12450,9 @@ dvmAsmSisterStart: * Go resolve the field */ .LOP_SPUT_CHAR_JUMBO_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%eax # eax<- field ref AAAAAAAA - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) @@ -12472,9 +12468,9 @@ dvmAsmSisterStart: * Go resolve the field */ .LOP_SPUT_SHORT_JUMBO_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%eax # eax<- field ref AAAAAAAA - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) @@ -12564,8 +12560,8 @@ dvmAsmSisterStart: */ .LOP_INVOKE_DIRECT_JUMBO_resolve: SPILL_TMP1(%ecx) - movl rGLUE,%ecx - movl offGlue_method(%ecx),%ecx # ecx<- glue->method + movl rSELF,%ecx + movl offThread_method(%ecx),%ecx # ecx<- self->method movl 2(rPC),%eax # reference AAAAAAAA movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl $METHOD_DIRECT,OUT_ARG2(%esp) @@ -12621,15 +12617,15 @@ dvmAsmSisterEnd: .global dvmMterpStdRun .type dvmMterpStdRun, %function /* - * bool dvmMterpStdRun(MterpGlue* glue) + * bool dvmMterpStdRun(Thread* self) * * Interpreter entry point. Returns changeInterp. * */ dvmMterpStdRun: - movl 4(%esp), %ecx # get incoming rGLUE + movl 4(%esp), %ecx # get incoming rSELF push %ebp # save caller base pointer - push %ecx # save rGLUE at (%ebp) + push %ecx # save rSELF at (%ebp) movl %esp, %ebp # set our %ebp /* * At this point we've allocated two slots on the stack @@ -12645,14 +12641,14 @@ dvmMterpStdRun: movl %ebx,EBX_SPILL(%ebp) /* Set up "named" registers */ - movl offGlue_pc(%ecx),rPC - movl offGlue_fp(%ecx),rFP + movl offThread_pc(%ecx),rPC + movl offThread_fp(%ecx),rFP /* Remember %esp for future "longjmp" */ - movl %esp,offGlue_bailPtr(%ecx) + movl %esp,offThread_bailPtr(%ecx) /* How to start? */ - movb offGlue_entryPoint(%ecx),%al + movb offThread_entryPoint(%ecx),%al /* Normal start? */ cmpb $kInterpEntryInstr,%al @@ -12664,7 +12660,7 @@ dvmMterpStdRun: .Lnot_instr: /* Reset to normal case */ - movb $kInterpEntryInstr,offGlue_entryPoint(%ecx) + movb $kInterpEntryInstr,offThread_entryPoint(%ecx) cmpb $kInterpEntryReturn,%al je common_returnFromMethod cmpb $kInterpEntryThrow,%al @@ -12680,7 +12676,7 @@ dvmMterpStdRun: .global dvmMterpStdBail .type dvmMterpStdBail, %function /* - * void dvmMterpStdBail(MterpGlue* glue, bool changeInterp) + * void dvmMterpStdBail(Thread* self, bool changeInterp) * * Restore the stack pointer and PC from the save point established on entry. * This is essentially the same as a longjmp, but should be cheaper. The @@ -12690,13 +12686,13 @@ dvmMterpStdRun: * look a little strange. * * On entry: - * esp+4 (arg0) MterpGlue* glue + * esp+4 (arg0) Thread* self * esp+8 (arg1) bool changeInterp */ dvmMterpStdBail: - movl 4(%esp),%ecx # grab glue + movl 4(%esp),%ecx # grab self movl 8(%esp),%eax # changeInterp to return reg - movl offGlue_bailPtr(%ecx),%esp # Restore "setjmp" esp + movl offThread_bailPtr(%ecx),%esp # Restore "setjmp" esp movl %esp,%ebp addl $(FRAME_SIZE-8), %ebp # Restore %ebp at point of setjmp movl EDI_SPILL(%ebp),%edi @@ -13292,11 +13288,11 @@ dvmJitToInterpPunt: */ dvmJitToInterpSingleStep: pop %eax - movl rGLUE, %ecx + movl rSELF, %ecx movl OUT_ARG0(%esp), %edx - movl %eax,offGlue_jitResumeNPC(%ecx) - movl %edx,offGlue_jitResumeDPC(%ecx) - movl $kInterpEntryInstr,offGlue_entryPoint(%ecx) + movl %eax,offThread_jitResumeNPC(%ecx) + movl %edx,offThread_jitResumeDPC(%ecx) + movl $kInterpEntryInstr,offThread_entryPoint(%ecx) movl $1,rINST # changeInterp <= true jmp common_gotoBail @@ -13312,8 +13308,7 @@ dvmJitToInterpNoChainNoProfile: #endif movl rPC,OUT_ARG0(%esp) call dvmJitGetTraceAddr # is there a translation? - movl rGLUE,%ecx - movl offGlue_self(%ecx), %ecx # ecx <- glue->self + movl rSELF,%ecx # ecx <- self movl %eax,offThread_inJitCodeCache(%ecx) # set inJitCodeCache flag cmpl $0, %eax jz 1f @@ -13335,8 +13330,7 @@ dvmJitToInterpTraceSelectNoChain: #endif movl rPC,OUT_ARG0(%esp) call dvmJitGetTraceAddr # is there a translation? - movl rGLUE,%ecx - movl offGlue_self(%ecx),%ecx + movl rSELF,%ecx cmpl $0,%eax movl %eax,offThread_inJitCodeCache(%ecx) # set inJitCodeCache flag jz 1f @@ -13396,8 +13390,8 @@ toInterpreter: * ebx (a.k.a. rINST) -> PC adjustment in 16-bit words */ common_backwardBranch: - movl rGLUE,%ecx - call common_periodicChecks # rPC and ecx/rGLUE preserved + movl rSELF,%ecx + call common_periodicChecks # rPC and ecx/rSELF preserved #if defined(WITH_JIT) GET_JIT_PROF_TABLE %ecx %edx ADVANCE_PC_INDEXED rINST @@ -13423,10 +13417,10 @@ common_updateProfile: * is already a native translation in place (and, if so, * jump to it now. */ - GET_JIT_THRESHOLD %ecx rINST + GET_JIT_THRESHOLD %ecx rINST # leaves rSELF in %ecx EXPORT_PC movb rINSTbl,(%edx,%eax) # reset counter - movl offGlue_self(%ecx),rINST + movl %ecx,rINST # preserve rSELF movl rPC,OUT_ARG0(%esp) call dvmJitGetTraceAddr # already have one? movl %eax,offThread_inJitCodeCache(rINST) # set the inJitCodeCache flag @@ -13437,9 +13431,10 @@ common_updateProfile: movl $kJitTSelectRequest,%eax # On entry, eax<- jitState, rPC valid common_selectTrace: - movl rGLUE,%ecx - movl %eax,offGlue_jitState(%ecx) - movl $kInterpEntryInstr,offGlue_entryPoint(%ecx) + + movl rSELF,%ecx + movl %eax,offThread_jitState(%ecx) + movl $kInterpEntryInstr,offThread_entryPoint(%ecx) movl $1,rINST jmp common_gotoBail #else @@ -13587,11 +13582,11 @@ common_invokeMethodNoRange: shl $2, %edx # %edx<- update offset SAVEAREA_FROM_FP %eax # %eax<- &StackSaveArea subl %edx, %eax # %eax<- newFP; (old savearea - regsSize) - movl rGLUE,%edx # %edx<- pMterpGlue + movl rSELF,%edx # %edx<- pthread movl %eax, LOCAL1_OFFSET(%ebp) # LOCAL1_OFFSET(%ebp)<- &outs subl $sizeofStackSaveArea, %eax # %eax<- newSaveArea (stack save area using newFP) - movl offGlue_interpStackEnd(%edx), %edx # %edx<- glue->interpStackEnd - movl %edx, LOCAL2_OFFSET(%ebp) # LOCAL2_OFFSET<- glue->interpStackEnd + movl offThread_interpStackEnd(%edx), %edx # %edx<- self->interpStackEnd + movl %edx, LOCAL2_OFFSET(%ebp) # LOCAL2_OFFSET<- self->interpStackEnd shl $2, %ecx # %ecx<- update offset for outsSize movl %eax, %edx # %edx<- newSaveArea sub %ecx, %eax # %eax<- bottom; (newSaveArea - outsSize) @@ -13614,19 +13609,18 @@ common_invokeMethodNoRange: jne .LinvokeNative # handle native call /* - * Update "glue" values for the new method + * Update "self" values for the new method * %eax=methodToCall, LOCAL1_OFFSET(%ebp)=newFp */ movl offMethod_clazz(%eax), %edx # %edx<- method->clazz - movl rGLUE,%ecx # %ecx<- pMterpGlue + movl rSELF,%ecx # %ecx<- pthread movl offClassObject_pDvmDex(%edx), %edx # %edx<- method->clazz->pDvmDex - movl %eax, offGlue_method(%ecx) # glue->method<- methodToCall - movl %edx, offGlue_methodClassDex(%ecx) # glue->methodClassDex<- method->clazz->pDvmDex + movl %eax, offThread_method(%ecx) # self->method<- methodToCall + movl %edx, offThread_methodClassDex(%ecx) # self->methodClassDex<- method->clazz->pDvmDex movl offMethod_insns(%eax), rPC # rPC<- methodToCall->insns - movl offGlue_self(%ecx), %eax # %eax<- glue->self movl LOCAL1_OFFSET(%ebp), rFP # rFP<- newFP - movl rFP, offThread_curFrame(%eax) # glue->self->curFrame<- newFP + movl rFP, offThread_curFrame(%ecx) # self->curFrame<- newFP FETCH_INST GOTO_NEXT # jump to methodToCall->insns @@ -13636,29 +13630,28 @@ common_invokeMethodNoRange: */ .LinvokeNative: - movl rGLUE,%ecx # %ecx<- pMterpGlue + movl rSELF,%ecx # %ecx<- pthread movl %eax, OUT_ARG1(%esp) # push parameter methodToCall - movl offGlue_self(%ecx), %ecx # %ecx<- glue->self movl offThread_jniLocal_topCookie(%ecx), %eax # %eax<- self->localRef->... movl %eax, offStackSaveArea_localRefCookie(%edx) # newSaveArea->localRefCookie<- top movl %edx, OUT_ARG4(%esp) # save newSaveArea movl LOCAL1_OFFSET(%ebp), %edx # %edx<- newFP - movl %edx, offThread_curFrame(%ecx) # glue->self->curFrame<- newFP - movl %ecx, OUT_ARG3(%esp) # save glue->self - movl %ecx, OUT_ARG2(%esp) # push parameter glue->self - movl rGLUE,%ecx # %ecx<- pMterpGlue + movl %edx, offThread_curFrame(%ecx) # self->self->curFrame<- newFP + movl %ecx, OUT_ARG3(%esp) # save self->self + movl %ecx, OUT_ARG2(%esp) # push parameter self->self + movl rSELF,%ecx # %ecx<- pthread movl OUT_ARG1(%esp), %eax # %eax<- methodToCall - lea offGlue_retval(%ecx), %ecx # %ecx<- &retval - movl %ecx, OUT_ARG0(%esp) # push parameter pMterpGlue + lea offThread_retval(%ecx), %ecx # %ecx<- &retval + movl %ecx, OUT_ARG0(%esp) # push parameter pthread push %edx # push parameter newFP call *offMethod_nativeFunc(%eax) # call methodToCall->nativeFunc lea 4(%esp), %esp movl OUT_ARG4(%esp), %ecx # %ecx<- newSaveArea - movl OUT_ARG3(%esp), %eax # %eax<- glue->self + movl OUT_ARG3(%esp), %eax # %eax<- self->self movl offStackSaveArea_localRefCookie(%ecx), %edx # %edx<- old top cmp $0, offThread_exception(%eax) # check for exception - movl rFP, offThread_curFrame(%eax) # glue->self->curFrame<- rFP + movl rFP, offThread_curFrame(%eax) # self->self->curFrame<- rFP movl %edx, offThread_jniLocal_topCookie(%eax) # new top <- old top jne common_exceptionThrown # handle exception FETCH_INST_OPCODE 3 %edx @@ -13667,8 +13660,7 @@ common_invokeMethodNoRange: .LstackOverflow: # eax=methodToCall movl %eax, OUT_ARG1(%esp) # push parameter methodToCall - movl rGLUE,%eax # %eax<- pMterpGlue - movl offGlue_self(%eax), %eax # %eax<- glue->self + movl rSELF,%eax # %eax<- self movl %eax, OUT_ARG0(%esp) # push parameter self call dvmHandleStackOverflow # call: (Thread* self, Method* meth) jmp common_exceptionThrown # handle exception @@ -13679,8 +13671,8 @@ common_invokeMethodNoRange: * * On entry: * ebx -> PC adjustment in 16-bit words (must be preserved) - * ecx -> GLUE pointer - * reentry type, e.g. kInterpEntryInstr stored in rGLUE->entryPoint + * ecx -> SELF pointer + * reentry type, e.g. kInterpEntryInstr stored in rSELF->entryPoint * * Note: A call will normally kill %eax and %ecx. To * streamline the normal case, this routine will preserve @@ -13691,12 +13683,11 @@ common_invokeMethodNoRange: * TUNING: Improve scheduling here & do initial single test for all. */ common_periodicChecks: - movl offGlue_pSelfSuspendCount(%ecx),%eax # eax <- &suspendCount - cmpl $0,(%eax) + cmpl $0,offThread_suspendCount(%ecx) # non-zero suspendCount? jne 1f 6: - movl offGlue_pInterpBreak(%ecx),%eax # eax <- &interpBreak + movl offThread_pInterpBreak(%ecx),%eax # eax <- &interpBreak cmpl $0,(%eax) # something interesting happening? jne 3f # yes - switch interpreters ret @@ -13705,13 +13696,13 @@ common_periodicChecks: 1: /* At this point, the return pointer to the caller of * common_periodicChecks is on the top of stack. We need to preserve - * GLUE(ecx). + * SELF(ecx). * The outgoing profile is: * bool dvmCheckSuspendPending(Thread* self) * Because we reached here via a call, go ahead and build a new frame. */ EXPORT_PC # need for precise GC - movl offGlue_self(%ecx),%eax # eax<- glue->self + movl %ecx,%eax # eax<- self push %ebp movl %esp,%ebp subl $24,%esp @@ -13719,7 +13710,7 @@ common_periodicChecks: call dvmCheckSuspendPending addl $24,%esp pop %ebp - movl rGLUE,%ecx + movl rSELF,%ecx /* * Need to check to see if debugger or profiler flags got set @@ -13739,7 +13730,7 @@ common_periodicChecks: */ 3: leal (rPC,%ebx,2),rPC # adjust pc to show target - movl rGLUE,%ecx # bail expect GLUE already loaded + movl rSELF,%ecx # bail expect SELF already loaded movl $1,rINST # set changeInterp to true jmp common_gotoBail @@ -13748,9 +13739,9 @@ common_periodicChecks: * Common code for handling a return instruction */ common_returnFromMethod: - movl rGLUE,%ecx + movl rSELF,%ecx /* Set entry mode in case we bail */ - movb $kInterpEntryReturn,offGlue_entryPoint(%ecx) + movb $kInterpEntryReturn,offThread_entryPoint(%ecx) xorl rINST,rINST # zero offset in case we switch interps call common_periodicChecks # Note: expects %ecx to be preserved @@ -13761,16 +13752,15 @@ common_returnFromMethod: je common_gotoBail # break frame, bail out completely movl offStackSaveArea_savedPc(%eax),rPC # pc<- saveArea->savedPC - movl offGlue_self(%ecx),%eax # eax<- self - movl rINST,offGlue_method(%ecx) # glue->method = newSave->meethod - movl rFP,offThread_curFrame(%eax) # self->curFrame = fp + movl rINST,offThread_method(%ecx) # self->method = newSave->meethod + movl rFP,offThread_curFrame(%ecx) # self->curFrame = fp movl offMethod_clazz(rINST),%eax # eax<- method->clazz FETCH_INST_OPCODE 3 %edx movl offClassObject_pDvmDex(%eax),%eax # eax<- method->clazz->pDvmDex ADVANCE_PC 3 - movl %eax,offGlue_methodClassDex(%ecx) + movl %eax,offThread_methodClassDex(%ecx) /* not bailing - restore entry mode to default */ - movb $kInterpEntryInstr,offGlue_entryPoint(%ecx) + movb $kInterpEntryInstr,offThread_entryPoint(%ecx) GOTO_NEXT_R %edx /* @@ -13779,24 +13769,24 @@ common_returnFromMethod: * * on entry: * rINST holds changeInterp - * ecx holds glue pointer + * ecx holds self pointer * - * expected profile: dvmMterpStdBail(MterpGlue *glue, bool changeInterp) + * expected profile: dvmMterpStdBail(Thread *self, bool changeInterp) */ common_gotoBail: - movl rPC,offGlue_pc(%ecx) # export state to glue - movl rFP,offGlue_fp(%ecx) - movl %ecx,OUT_ARG0(%esp) # glue in arg0 + movl rPC,offThread_pc(%ecx) # export state to self + movl rFP,offThread_fp(%ecx) + movl %ecx,OUT_ARG0(%esp) # self in arg0 movl rINST,OUT_ARG1(%esp) # changeInterp in arg1 call dvmMterpStdBail # bail out.... /* - * After returning from a "glued" function, pull out the updated values + * After returning from a "selfd" function, pull out the updated values * and start executing at the next instruction. */ common_resumeAfterGlueCall: - LOAD_PC_FP_FROM_GLUE + LOAD_PC_FP_FROM_SELF FETCH_INST GOTO_NEXT @@ -13874,9 +13864,9 @@ common_errArrayIndex: * This does not return. */ common_exceptionThrown: - movl rGLUE,%ecx - movl rPC,offGlue_pc(%ecx) - movl rFP,offGlue_fp(%ecx) + movl rSELF,%ecx + movl rPC,offThread_pc(%ecx) + movl rFP,offThread_fp(%ecx) movl %ecx,OUT_ARG0(%esp) call dvmMterp_exceptionThrown jmp common_resumeAfterGlueCall diff --git a/vm/mterp/out/InterpC-allstubs.c b/vm/mterp/out/InterpC-allstubs.c index eda4f6993..2e1667bcb 100644 --- a/vm/mterp/out/InterpC-allstubs.c +++ b/vm/mterp/out/InterpC-allstubs.c @@ -425,11 +425,11 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) */ #define GOTO_TARGET_DECL(_target, ...) \ - void dvmMterp_##_target(MterpGlue* glue, ## __VA_ARGS__); + void dvmMterp_##_target(Thread* self, ## __VA_ARGS__); /* (void)xxx to quiet unused variable compiler warnings. */ #define GOTO_TARGET(_target, ...) \ - void dvmMterp_##_target(MterpGlue* glue, ## __VA_ARGS__) { \ + void dvmMterp_##_target(Thread* self, ## __VA_ARGS__) { \ u2 ref, vsrc1, vsrc2, vdst; \ u2 inst = FETCH(0); \ const Method* methodToCall; \ @@ -440,16 +440,15 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) #define GOTO_TARGET_END } /* - * Redefine what used to be local variable accesses into MterpGlue struct + * Redefine what used to be local variable accesses into Thread struct * references. (These are undefined down in "footer.c".) */ -#define retval glue->retval -#define pc glue->pc -#define fp glue->fp -#define curMethod glue->method -#define methodClassDex glue->methodClassDex -#define self glue->self -#define debugTrackedRefStart glue->debugTrackedRefStart +#define retval self->retval +#define pc self->interpSave.pc +#define fp self->interpSave.fp +#define curMethod self->interpSave.method +#define methodClassDex self->interpSave.methodClassDex +#define debugTrackedRefStart self->interpSave.debugTrackedRefStart /* ugh */ #define STUB_HACK(x) x @@ -457,12 +456,12 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) /* * Opcode handler framing macros. Here, each opcode is a separate function - * that takes a "glue" argument and returns void. We can't declare + * that takes a "self" argument and returns void. We can't declare * these "static" because they may be called from an assembly stub. * (void)xxx to quiet unused variable compiler warnings. */ #define HANDLE_OPCODE(_op) \ - void dvmMterp_##_op(MterpGlue* glue) { \ + void dvmMterp_##_op(Thread* self) { \ u2 ref, vsrc1, vsrc2, vdst; \ u2 inst = FETCH(0); \ (void)ref; (void)vsrc1; (void)vsrc2; (void)vdst; (void)inst; @@ -489,25 +488,25 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) #define GOTO_exceptionThrown() \ do { \ - dvmMterp_exceptionThrown(glue); \ + dvmMterp_exceptionThrown(self); \ return; \ } while(false) #define GOTO_returnFromMethod() \ do { \ - dvmMterp_returnFromMethod(glue); \ + dvmMterp_returnFromMethod(self); \ return; \ } while(false) #define GOTO_invoke(_target, _methodCallRange, _jumboFormat) \ do { \ - dvmMterp_##_target(glue, _methodCallRange, _jumboFormat); \ + dvmMterp_##_target(self, _methodCallRange, _jumboFormat); \ return; \ } while(false) #define GOTO_invokeMethod(_methodCallRange, _methodToCall, _vsrc1, _vdst) \ do { \ - dvmMterp_invokeMethod(glue, _methodCallRange, _methodToCall, \ + dvmMterp_invokeMethod(self, _methodCallRange, _methodToCall, \ _vsrc1, _vdst); \ return; \ } while(false) @@ -517,9 +516,9 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) * if we need to switch to the other interpreter upon our return. */ #define GOTO_bail() \ - dvmMterpStdBail(glue, false); + dvmMterpStdBail(self, false); #define GOTO_bail_switch() \ - dvmMterpStdBail(glue, true); + dvmMterpStdBail(self, true); /* * Periodically check for thread suspension. @@ -534,7 +533,7 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) } \ if (NEED_INTERP_SWITCH(INTERP_TYPE)) { \ ADJUST_PC(_pcadj); \ - glue->entryPoint = _entryPoint; \ + self->entryPoint = _entryPoint; \ LOGVV("threadid=%d: switch to STD ep=%d adj=%d\n", \ self->threadId, (_entryPoint), (_pcadj)); \ GOTO_bail_switch(); \ @@ -4382,12 +4381,12 @@ DEFINE_GOTO_TABLE(gDvmMterpHandlerNames) * * This is only used for the "allstubs" variant. */ -bool dvmMterpStdRun(MterpGlue* glue) +bool dvmMterpStdRun(Thread* self) { jmp_buf jmpBuf; int changeInterp; - glue->bailPtr = &jmpBuf; + self->bailPtr = &jmpBuf; /* * We want to return "changeInterp" as a boolean, but we can't return @@ -4405,18 +4404,18 @@ bool dvmMterpStdRun(MterpGlue* glue) * We need to pick up where the other interpreter left off. * * In some cases we need to call into a throw/return handler which - * will do some processing and then either return to us (updating "glue") + * will do some processing and then either return to us (updating "self") * or longjmp back out. */ - switch (glue->entryPoint) { + switch (self->entryPoint) { case kInterpEntryInstr: /* just start at the start */ break; case kInterpEntryReturn: - dvmMterp_returnFromMethod(glue); + dvmMterp_returnFromMethod(self); break; case kInterpEntryThrow: - dvmMterp_exceptionThrown(glue); + dvmMterp_exceptionThrown(self); break; default: dvmAbort(); @@ -4424,23 +4423,23 @@ bool dvmMterpStdRun(MterpGlue* glue) /* run until somebody longjmp()s out */ while (true) { - typedef void (*Handler)(MterpGlue* glue); + typedef void (*Handler)(Thread* self); - u2 inst = /*glue->*/pc[0]; + u2 inst = /*self->*/pc[0]; Handler handler = (Handler) gDvmMterpHandlers[inst & 0xff]; (void) gDvmMterpHandlerNames; /* avoid gcc "defined but not used" */ LOGVV("handler %p %s\n", handler, (const char*) gDvmMterpHandlerNames[inst & 0xff]); - (*handler)(glue); + (*handler)(self); } } /* * C mterp exit point. Call here to bail out of the interpreter. */ -void dvmMterpStdBail(MterpGlue* glue, bool changeInterp) +void dvmMterpStdBail(Thread* self, bool changeInterp) { - jmp_buf* pJmpBuf = glue->bailPtr; + jmp_buf* pJmpBuf = self->bailPtr; longjmp(*pJmpBuf, ((int)changeInterp)+1); } diff --git a/vm/mterp/out/InterpC-armv5te-vfp.c b/vm/mterp/out/InterpC-armv5te-vfp.c index 8fc5605b9..87f59e3e4 100644 --- a/vm/mterp/out/InterpC-armv5te-vfp.c +++ b/vm/mterp/out/InterpC-armv5te-vfp.c @@ -425,11 +425,11 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) */ #define GOTO_TARGET_DECL(_target, ...) \ - void dvmMterp_##_target(MterpGlue* glue, ## __VA_ARGS__); + void dvmMterp_##_target(Thread* self, ## __VA_ARGS__); /* (void)xxx to quiet unused variable compiler warnings. */ #define GOTO_TARGET(_target, ...) \ - void dvmMterp_##_target(MterpGlue* glue, ## __VA_ARGS__) { \ + void dvmMterp_##_target(Thread* self, ## __VA_ARGS__) { \ u2 ref, vsrc1, vsrc2, vdst; \ u2 inst = FETCH(0); \ const Method* methodToCall; \ @@ -440,16 +440,15 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) #define GOTO_TARGET_END } /* - * Redefine what used to be local variable accesses into MterpGlue struct + * Redefine what used to be local variable accesses into Thread struct * references. (These are undefined down in "footer.c".) */ -#define retval glue->retval -#define pc glue->pc -#define fp glue->fp -#define curMethod glue->method -#define methodClassDex glue->methodClassDex -#define self glue->self -#define debugTrackedRefStart glue->debugTrackedRefStart +#define retval self->retval +#define pc self->interpSave.pc +#define fp self->interpSave.fp +#define curMethod self->interpSave.method +#define methodClassDex self->interpSave.methodClassDex +#define debugTrackedRefStart self->interpSave.debugTrackedRefStart /* ugh */ #define STUB_HACK(x) x @@ -457,12 +456,12 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) /* * Opcode handler framing macros. Here, each opcode is a separate function - * that takes a "glue" argument and returns void. We can't declare + * that takes a "self" argument and returns void. We can't declare * these "static" because they may be called from an assembly stub. * (void)xxx to quiet unused variable compiler warnings. */ #define HANDLE_OPCODE(_op) \ - void dvmMterp_##_op(MterpGlue* glue) { \ + void dvmMterp_##_op(Thread* self) { \ u2 ref, vsrc1, vsrc2, vdst; \ u2 inst = FETCH(0); \ (void)ref; (void)vsrc1; (void)vsrc2; (void)vdst; (void)inst; @@ -489,25 +488,25 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) #define GOTO_exceptionThrown() \ do { \ - dvmMterp_exceptionThrown(glue); \ + dvmMterp_exceptionThrown(self); \ return; \ } while(false) #define GOTO_returnFromMethod() \ do { \ - dvmMterp_returnFromMethod(glue); \ + dvmMterp_returnFromMethod(self); \ return; \ } while(false) #define GOTO_invoke(_target, _methodCallRange, _jumboFormat) \ do { \ - dvmMterp_##_target(glue, _methodCallRange, _jumboFormat); \ + dvmMterp_##_target(self, _methodCallRange, _jumboFormat); \ return; \ } while(false) #define GOTO_invokeMethod(_methodCallRange, _methodToCall, _vsrc1, _vdst) \ do { \ - dvmMterp_invokeMethod(glue, _methodCallRange, _methodToCall, \ + dvmMterp_invokeMethod(self, _methodCallRange, _methodToCall, \ _vsrc1, _vdst); \ return; \ } while(false) @@ -517,9 +516,9 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) * if we need to switch to the other interpreter upon our return. */ #define GOTO_bail() \ - dvmMterpStdBail(glue, false); + dvmMterpStdBail(self, false); #define GOTO_bail_switch() \ - dvmMterpStdBail(glue, true); + dvmMterpStdBail(self, true); /* * Periodically check for thread suspension. @@ -534,7 +533,7 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) } \ if (NEED_INTERP_SWITCH(INTERP_TYPE)) { \ ADJUST_PC(_pcadj); \ - glue->entryPoint = _entryPoint; \ + self->entryPoint = _entryPoint; \ LOGVV("threadid=%d: switch to STD ep=%d adj=%d\n", \ self->threadId, (_entryPoint), (_pcadj)); \ GOTO_bail_switch(); \ @@ -1325,7 +1324,7 @@ void dvmMterpDumpArmRegs(uint32_t r0, uint32_t r1, uint32_t r2, uint32_t r3) { register uint32_t rPC asm("r4"); register uint32_t rFP asm("r5"); - register uint32_t rGLUE asm("r6"); + register uint32_t rSELF asm("r6"); register uint32_t rINST asm("r7"); register uint32_t rIBASE asm("r8"); register uint32_t r9 asm("r9"); @@ -1334,12 +1333,12 @@ void dvmMterpDumpArmRegs(uint32_t r0, uint32_t r1, uint32_t r2, uint32_t r3) //extern char dvmAsmInstructionStart[]; printf("REGS: r0=%08x r1=%08x r2=%08x r3=%08x\n", r0, r1, r2, r3); - printf(" : rPC=%08x rFP=%08x rGLUE=%08x rINST=%08x\n", - rPC, rFP, rGLUE, rINST); + printf(" : rPC=%08x rFP=%08x rSELF=%08x rINST=%08x\n", + rPC, rFP, rSELF, rINST); printf(" : rIBASE=%08x r9=%08x r10=%08x\n", rIBASE, r9, r10); - //MterpGlue* glue = (MterpGlue*) rGLUE; - //const Method* method = glue->method; + //Thread* self = (Thread*) rSELF; + //const Method* method = self->method; printf(" + self is %p\n", dvmThreadSelf()); //printf(" + currently in %s.%s %s\n", // method->clazz->descriptor, method->name, method->shorty); diff --git a/vm/mterp/out/InterpC-armv5te.c b/vm/mterp/out/InterpC-armv5te.c index 261891ee4..591450133 100644 --- a/vm/mterp/out/InterpC-armv5te.c +++ b/vm/mterp/out/InterpC-armv5te.c @@ -425,11 +425,11 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) */ #define GOTO_TARGET_DECL(_target, ...) \ - void dvmMterp_##_target(MterpGlue* glue, ## __VA_ARGS__); + void dvmMterp_##_target(Thread* self, ## __VA_ARGS__); /* (void)xxx to quiet unused variable compiler warnings. */ #define GOTO_TARGET(_target, ...) \ - void dvmMterp_##_target(MterpGlue* glue, ## __VA_ARGS__) { \ + void dvmMterp_##_target(Thread* self, ## __VA_ARGS__) { \ u2 ref, vsrc1, vsrc2, vdst; \ u2 inst = FETCH(0); \ const Method* methodToCall; \ @@ -440,16 +440,15 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) #define GOTO_TARGET_END } /* - * Redefine what used to be local variable accesses into MterpGlue struct + * Redefine what used to be local variable accesses into Thread struct * references. (These are undefined down in "footer.c".) */ -#define retval glue->retval -#define pc glue->pc -#define fp glue->fp -#define curMethod glue->method -#define methodClassDex glue->methodClassDex -#define self glue->self -#define debugTrackedRefStart glue->debugTrackedRefStart +#define retval self->retval +#define pc self->interpSave.pc +#define fp self->interpSave.fp +#define curMethod self->interpSave.method +#define methodClassDex self->interpSave.methodClassDex +#define debugTrackedRefStart self->interpSave.debugTrackedRefStart /* ugh */ #define STUB_HACK(x) x @@ -457,12 +456,12 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) /* * Opcode handler framing macros. Here, each opcode is a separate function - * that takes a "glue" argument and returns void. We can't declare + * that takes a "self" argument and returns void. We can't declare * these "static" because they may be called from an assembly stub. * (void)xxx to quiet unused variable compiler warnings. */ #define HANDLE_OPCODE(_op) \ - void dvmMterp_##_op(MterpGlue* glue) { \ + void dvmMterp_##_op(Thread* self) { \ u2 ref, vsrc1, vsrc2, vdst; \ u2 inst = FETCH(0); \ (void)ref; (void)vsrc1; (void)vsrc2; (void)vdst; (void)inst; @@ -489,25 +488,25 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) #define GOTO_exceptionThrown() \ do { \ - dvmMterp_exceptionThrown(glue); \ + dvmMterp_exceptionThrown(self); \ return; \ } while(false) #define GOTO_returnFromMethod() \ do { \ - dvmMterp_returnFromMethod(glue); \ + dvmMterp_returnFromMethod(self); \ return; \ } while(false) #define GOTO_invoke(_target, _methodCallRange, _jumboFormat) \ do { \ - dvmMterp_##_target(glue, _methodCallRange, _jumboFormat); \ + dvmMterp_##_target(self, _methodCallRange, _jumboFormat); \ return; \ } while(false) #define GOTO_invokeMethod(_methodCallRange, _methodToCall, _vsrc1, _vdst) \ do { \ - dvmMterp_invokeMethod(glue, _methodCallRange, _methodToCall, \ + dvmMterp_invokeMethod(self, _methodCallRange, _methodToCall, \ _vsrc1, _vdst); \ return; \ } while(false) @@ -517,9 +516,9 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) * if we need to switch to the other interpreter upon our return. */ #define GOTO_bail() \ - dvmMterpStdBail(glue, false); + dvmMterpStdBail(self, false); #define GOTO_bail_switch() \ - dvmMterpStdBail(glue, true); + dvmMterpStdBail(self, true); /* * Periodically check for thread suspension. @@ -534,7 +533,7 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) } \ if (NEED_INTERP_SWITCH(INTERP_TYPE)) { \ ADJUST_PC(_pcadj); \ - glue->entryPoint = _entryPoint; \ + self->entryPoint = _entryPoint; \ LOGVV("threadid=%d: switch to STD ep=%d adj=%d\n", \ self->threadId, (_entryPoint), (_pcadj)); \ GOTO_bail_switch(); \ @@ -1325,7 +1324,7 @@ void dvmMterpDumpArmRegs(uint32_t r0, uint32_t r1, uint32_t r2, uint32_t r3) { register uint32_t rPC asm("r4"); register uint32_t rFP asm("r5"); - register uint32_t rGLUE asm("r6"); + register uint32_t rSELF asm("r6"); register uint32_t rINST asm("r7"); register uint32_t rIBASE asm("r8"); register uint32_t r9 asm("r9"); @@ -1334,12 +1333,12 @@ void dvmMterpDumpArmRegs(uint32_t r0, uint32_t r1, uint32_t r2, uint32_t r3) //extern char dvmAsmInstructionStart[]; printf("REGS: r0=%08x r1=%08x r2=%08x r3=%08x\n", r0, r1, r2, r3); - printf(" : rPC=%08x rFP=%08x rGLUE=%08x rINST=%08x\n", - rPC, rFP, rGLUE, rINST); + printf(" : rPC=%08x rFP=%08x rSELF=%08x rINST=%08x\n", + rPC, rFP, rSELF, rINST); printf(" : rIBASE=%08x r9=%08x r10=%08x\n", rIBASE, r9, r10); - //MterpGlue* glue = (MterpGlue*) rGLUE; - //const Method* method = glue->method; + //Thread* self = (Thread*) rSELF; + //const Method* method = self->method; printf(" + self is %p\n", dvmThreadSelf()); //printf(" + currently in %s.%s %s\n", // method->clazz->descriptor, method->name, method->shorty); diff --git a/vm/mterp/out/InterpC-armv7-a-neon.c b/vm/mterp/out/InterpC-armv7-a-neon.c index 28603ef0f..05a821df2 100644 --- a/vm/mterp/out/InterpC-armv7-a-neon.c +++ b/vm/mterp/out/InterpC-armv7-a-neon.c @@ -425,11 +425,11 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) */ #define GOTO_TARGET_DECL(_target, ...) \ - void dvmMterp_##_target(MterpGlue* glue, ## __VA_ARGS__); + void dvmMterp_##_target(Thread* self, ## __VA_ARGS__); /* (void)xxx to quiet unused variable compiler warnings. */ #define GOTO_TARGET(_target, ...) \ - void dvmMterp_##_target(MterpGlue* glue, ## __VA_ARGS__) { \ + void dvmMterp_##_target(Thread* self, ## __VA_ARGS__) { \ u2 ref, vsrc1, vsrc2, vdst; \ u2 inst = FETCH(0); \ const Method* methodToCall; \ @@ -440,16 +440,15 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) #define GOTO_TARGET_END } /* - * Redefine what used to be local variable accesses into MterpGlue struct + * Redefine what used to be local variable accesses into Thread struct * references. (These are undefined down in "footer.c".) */ -#define retval glue->retval -#define pc glue->pc -#define fp glue->fp -#define curMethod glue->method -#define methodClassDex glue->methodClassDex -#define self glue->self -#define debugTrackedRefStart glue->debugTrackedRefStart +#define retval self->retval +#define pc self->interpSave.pc +#define fp self->interpSave.fp +#define curMethod self->interpSave.method +#define methodClassDex self->interpSave.methodClassDex +#define debugTrackedRefStart self->interpSave.debugTrackedRefStart /* ugh */ #define STUB_HACK(x) x @@ -457,12 +456,12 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) /* * Opcode handler framing macros. Here, each opcode is a separate function - * that takes a "glue" argument and returns void. We can't declare + * that takes a "self" argument and returns void. We can't declare * these "static" because they may be called from an assembly stub. * (void)xxx to quiet unused variable compiler warnings. */ #define HANDLE_OPCODE(_op) \ - void dvmMterp_##_op(MterpGlue* glue) { \ + void dvmMterp_##_op(Thread* self) { \ u2 ref, vsrc1, vsrc2, vdst; \ u2 inst = FETCH(0); \ (void)ref; (void)vsrc1; (void)vsrc2; (void)vdst; (void)inst; @@ -489,25 +488,25 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) #define GOTO_exceptionThrown() \ do { \ - dvmMterp_exceptionThrown(glue); \ + dvmMterp_exceptionThrown(self); \ return; \ } while(false) #define GOTO_returnFromMethod() \ do { \ - dvmMterp_returnFromMethod(glue); \ + dvmMterp_returnFromMethod(self); \ return; \ } while(false) #define GOTO_invoke(_target, _methodCallRange, _jumboFormat) \ do { \ - dvmMterp_##_target(glue, _methodCallRange, _jumboFormat); \ + dvmMterp_##_target(self, _methodCallRange, _jumboFormat); \ return; \ } while(false) #define GOTO_invokeMethod(_methodCallRange, _methodToCall, _vsrc1, _vdst) \ do { \ - dvmMterp_invokeMethod(glue, _methodCallRange, _methodToCall, \ + dvmMterp_invokeMethod(self, _methodCallRange, _methodToCall, \ _vsrc1, _vdst); \ return; \ } while(false) @@ -517,9 +516,9 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) * if we need to switch to the other interpreter upon our return. */ #define GOTO_bail() \ - dvmMterpStdBail(glue, false); + dvmMterpStdBail(self, false); #define GOTO_bail_switch() \ - dvmMterpStdBail(glue, true); + dvmMterpStdBail(self, true); /* * Periodically check for thread suspension. @@ -534,7 +533,7 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) } \ if (NEED_INTERP_SWITCH(INTERP_TYPE)) { \ ADJUST_PC(_pcadj); \ - glue->entryPoint = _entryPoint; \ + self->entryPoint = _entryPoint; \ LOGVV("threadid=%d: switch to STD ep=%d adj=%d\n", \ self->threadId, (_entryPoint), (_pcadj)); \ GOTO_bail_switch(); \ @@ -1325,7 +1324,7 @@ void dvmMterpDumpArmRegs(uint32_t r0, uint32_t r1, uint32_t r2, uint32_t r3) { register uint32_t rPC asm("r4"); register uint32_t rFP asm("r5"); - register uint32_t rGLUE asm("r6"); + register uint32_t rSELF asm("r6"); register uint32_t rINST asm("r7"); register uint32_t rIBASE asm("r8"); register uint32_t r9 asm("r9"); @@ -1334,12 +1333,12 @@ void dvmMterpDumpArmRegs(uint32_t r0, uint32_t r1, uint32_t r2, uint32_t r3) //extern char dvmAsmInstructionStart[]; printf("REGS: r0=%08x r1=%08x r2=%08x r3=%08x\n", r0, r1, r2, r3); - printf(" : rPC=%08x rFP=%08x rGLUE=%08x rINST=%08x\n", - rPC, rFP, rGLUE, rINST); + printf(" : rPC=%08x rFP=%08x rSELF=%08x rINST=%08x\n", + rPC, rFP, rSELF, rINST); printf(" : rIBASE=%08x r9=%08x r10=%08x\n", rIBASE, r9, r10); - //MterpGlue* glue = (MterpGlue*) rGLUE; - //const Method* method = glue->method; + //Thread* self = (Thread*) rSELF; + //const Method* method = self->method; printf(" + self is %p\n", dvmThreadSelf()); //printf(" + currently in %s.%s %s\n", // method->clazz->descriptor, method->name, method->shorty); diff --git a/vm/mterp/out/InterpC-armv7-a.c b/vm/mterp/out/InterpC-armv7-a.c index 0d0c8c468..117c86068 100644 --- a/vm/mterp/out/InterpC-armv7-a.c +++ b/vm/mterp/out/InterpC-armv7-a.c @@ -425,11 +425,11 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) */ #define GOTO_TARGET_DECL(_target, ...) \ - void dvmMterp_##_target(MterpGlue* glue, ## __VA_ARGS__); + void dvmMterp_##_target(Thread* self, ## __VA_ARGS__); /* (void)xxx to quiet unused variable compiler warnings. */ #define GOTO_TARGET(_target, ...) \ - void dvmMterp_##_target(MterpGlue* glue, ## __VA_ARGS__) { \ + void dvmMterp_##_target(Thread* self, ## __VA_ARGS__) { \ u2 ref, vsrc1, vsrc2, vdst; \ u2 inst = FETCH(0); \ const Method* methodToCall; \ @@ -440,16 +440,15 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) #define GOTO_TARGET_END } /* - * Redefine what used to be local variable accesses into MterpGlue struct + * Redefine what used to be local variable accesses into Thread struct * references. (These are undefined down in "footer.c".) */ -#define retval glue->retval -#define pc glue->pc -#define fp glue->fp -#define curMethod glue->method -#define methodClassDex glue->methodClassDex -#define self glue->self -#define debugTrackedRefStart glue->debugTrackedRefStart +#define retval self->retval +#define pc self->interpSave.pc +#define fp self->interpSave.fp +#define curMethod self->interpSave.method +#define methodClassDex self->interpSave.methodClassDex +#define debugTrackedRefStart self->interpSave.debugTrackedRefStart /* ugh */ #define STUB_HACK(x) x @@ -457,12 +456,12 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) /* * Opcode handler framing macros. Here, each opcode is a separate function - * that takes a "glue" argument and returns void. We can't declare + * that takes a "self" argument and returns void. We can't declare * these "static" because they may be called from an assembly stub. * (void)xxx to quiet unused variable compiler warnings. */ #define HANDLE_OPCODE(_op) \ - void dvmMterp_##_op(MterpGlue* glue) { \ + void dvmMterp_##_op(Thread* self) { \ u2 ref, vsrc1, vsrc2, vdst; \ u2 inst = FETCH(0); \ (void)ref; (void)vsrc1; (void)vsrc2; (void)vdst; (void)inst; @@ -489,25 +488,25 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) #define GOTO_exceptionThrown() \ do { \ - dvmMterp_exceptionThrown(glue); \ + dvmMterp_exceptionThrown(self); \ return; \ } while(false) #define GOTO_returnFromMethod() \ do { \ - dvmMterp_returnFromMethod(glue); \ + dvmMterp_returnFromMethod(self); \ return; \ } while(false) #define GOTO_invoke(_target, _methodCallRange, _jumboFormat) \ do { \ - dvmMterp_##_target(glue, _methodCallRange, _jumboFormat); \ + dvmMterp_##_target(self, _methodCallRange, _jumboFormat); \ return; \ } while(false) #define GOTO_invokeMethod(_methodCallRange, _methodToCall, _vsrc1, _vdst) \ do { \ - dvmMterp_invokeMethod(glue, _methodCallRange, _methodToCall, \ + dvmMterp_invokeMethod(self, _methodCallRange, _methodToCall, \ _vsrc1, _vdst); \ return; \ } while(false) @@ -517,9 +516,9 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) * if we need to switch to the other interpreter upon our return. */ #define GOTO_bail() \ - dvmMterpStdBail(glue, false); + dvmMterpStdBail(self, false); #define GOTO_bail_switch() \ - dvmMterpStdBail(glue, true); + dvmMterpStdBail(self, true); /* * Periodically check for thread suspension. @@ -534,7 +533,7 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) } \ if (NEED_INTERP_SWITCH(INTERP_TYPE)) { \ ADJUST_PC(_pcadj); \ - glue->entryPoint = _entryPoint; \ + self->entryPoint = _entryPoint; \ LOGVV("threadid=%d: switch to STD ep=%d adj=%d\n", \ self->threadId, (_entryPoint), (_pcadj)); \ GOTO_bail_switch(); \ @@ -1325,7 +1324,7 @@ void dvmMterpDumpArmRegs(uint32_t r0, uint32_t r1, uint32_t r2, uint32_t r3) { register uint32_t rPC asm("r4"); register uint32_t rFP asm("r5"); - register uint32_t rGLUE asm("r6"); + register uint32_t rSELF asm("r6"); register uint32_t rINST asm("r7"); register uint32_t rIBASE asm("r8"); register uint32_t r9 asm("r9"); @@ -1334,12 +1333,12 @@ void dvmMterpDumpArmRegs(uint32_t r0, uint32_t r1, uint32_t r2, uint32_t r3) //extern char dvmAsmInstructionStart[]; printf("REGS: r0=%08x r1=%08x r2=%08x r3=%08x\n", r0, r1, r2, r3); - printf(" : rPC=%08x rFP=%08x rGLUE=%08x rINST=%08x\n", - rPC, rFP, rGLUE, rINST); + printf(" : rPC=%08x rFP=%08x rSELF=%08x rINST=%08x\n", + rPC, rFP, rSELF, rINST); printf(" : rIBASE=%08x r9=%08x r10=%08x\n", rIBASE, r9, r10); - //MterpGlue* glue = (MterpGlue*) rGLUE; - //const Method* method = glue->method; + //Thread* self = (Thread*) rSELF; + //const Method* method = self->method; printf(" + self is %p\n", dvmThreadSelf()); //printf(" + currently in %s.%s %s\n", // method->clazz->descriptor, method->name, method->shorty); diff --git a/vm/mterp/out/InterpC-portdbg.c b/vm/mterp/out/InterpC-portdbg.c index 9cd97eba0..b7bb5283b 100644 --- a/vm/mterp/out/InterpC-portdbg.c +++ b/vm/mterp/out/InterpC-portdbg.c @@ -418,11 +418,11 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) checkDebugAndProf(pc, fp, self, curMethod, &debugIsMethodEntry) #if defined(WITH_JIT) -#define CHECK_JIT_BOOL() (dvmCheckJit(pc, self, interpState, callsiteClass,\ +#define CHECK_JIT_BOOL() (dvmCheckJit(pc, self, callsiteClass,\ methodToCall)) -#define CHECK_JIT_VOID() (dvmCheckJit(pc, self, interpState, callsiteClass,\ +#define CHECK_JIT_VOID() (dvmCheckJit(pc, self, callsiteClass,\ methodToCall)) -#define END_JIT_TSELECT() (dvmJitEndTraceSelect(interpState)) +#define END_JIT_TSELECT() (dvmJitEndTraceSelect(self)) #else #define CHECK_JIT_BOOL() (false) #define CHECK_JIT_VOID() @@ -523,10 +523,10 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) } \ if (NEED_INTERP_SWITCH(INTERP_TYPE)) { \ ADJUST_PC(_pcadj); \ - interpState->entryPoint = _entryPoint; \ + self->entryPoint = _entryPoint; \ LOGVV("threadid=%d: switch to %s ep=%d adj=%d\n", \ self->threadId, \ - (interpState->nextMode == INTERP_STD) ? "STD" : "DBG", \ + (self->nextMode == INTERP_STD) ? "STD" : "DBG", \ (_entryPoint), (_pcadj)); \ GOTO_bail_switch(); \ } \ @@ -1537,17 +1537,17 @@ static void checkDebugAndProf(const u2* pc, const u4* fp, Thread* self, * * This was written with an ARM implementation in mind. */ -bool INTERP_FUNC_NAME(Thread* self, InterpState* interpState) +bool INTERP_FUNC_NAME(Thread* self) { #if defined(EASY_GDB) StackSaveArea* debugSaveArea = SAVEAREA_FROM_FP(self->curFrame); #endif #if INTERP_TYPE == INTERP_DBG bool debugIsMethodEntry = false; - debugIsMethodEntry = interpState->debugIsMethodEntry; + debugIsMethodEntry = self->debugIsMethodEntry; #endif #if defined(WITH_TRACKREF_CHECKS) - int debugTrackedRefStart = interpState->debugTrackedRefStart; + int debugTrackedRefStart = self->debugTrackedRefStart; #endif DvmDex* methodClassDex; // curMethod->clazz->pDvmDex JValue retval; @@ -1574,16 +1574,16 @@ bool INTERP_FUNC_NAME(Thread* self, InterpState* interpState) #if defined(WITH_JIT) #if 0 LOGD("*DebugInterp - entrypoint is %d, tgt is 0x%x, %s\n", - interpState->entryPoint, - interpState->pc, - interpState->method->name); + self->entryPoint, + self->interpSave.pc, + self->interpSave.method->name); #endif #if INTERP_TYPE == INTERP_DBG const ClassObject* callsiteClass = NULL; #if defined(WITH_SELF_VERIFICATION) - if (interpState->jitState != kJitSelfVerification) { - interpState->self->shadowSpace->jitExitState = kSVSIdle; + if (self->jitState != kJitSelfVerification) { + self->shadowSpace->jitExitState = kSVSIdle; } #endif @@ -1596,11 +1596,11 @@ bool INTERP_FUNC_NAME(Thread* self, InterpState* interpState) * dvmJitCheckTraceRequest will change the jitState to kJitDone but * but stay in the dbg interpreter. */ - (interpState->entryPoint == kInterpEntryInstr) && - (interpState->jitState == kJitTSelectRequest || - interpState->jitState == kJitTSelectRequestHot) && - dvmJitCheckTraceRequest(self, interpState)) { - interpState->nextMode = INTERP_STD; + (self->entryPoint == kInterpEntryInstr) && + (self->jitState == kJitTSelectRequest || + self->jitState == kJitTSelectRequestHot) && + dvmJitCheckTraceRequest(self)) { + self->nextMode = INTERP_STD; //LOGD("Invalid trace request, exiting\n"); return true; } @@ -1608,17 +1608,17 @@ bool INTERP_FUNC_NAME(Thread* self, InterpState* interpState) #endif /* WITH_JIT */ /* copy state in */ - curMethod = interpState->method; - pc = interpState->pc; - fp = interpState->fp; - retval = interpState->retval; /* only need for kInterpEntryReturn? */ + curMethod = self->interpSave.method; + pc = self->interpSave.pc; + fp = self->interpSave.fp; + retval = self->retval; /* only need for kInterpEntryReturn? */ methodClassDex = curMethod->clazz->pDvmDex; LOGVV("threadid=%d: entry(%s) %s.%s pc=0x%x fp=%p ep=%d\n", - self->threadId, (interpState->nextMode == INTERP_STD) ? "STD" : "DBG", + self->threadId, (self->nextMode == INTERP_STD) ? "STD" : "DBG", curMethod->clazz->descriptor, curMethod->name, pc - curMethod->insns, - fp, interpState->entryPoint); + fp, self->entryPoint); /* * DEBUG: scramble this to ensure we're not relying on it. @@ -1629,11 +1629,11 @@ bool INTERP_FUNC_NAME(Thread* self, InterpState* interpState) if (debugIsMethodEntry) { ILOGD("|-- Now interpreting %s.%s", curMethod->clazz->descriptor, curMethod->name); - DUMP_REGS(curMethod, interpState->fp, false); + DUMP_REGS(curMethod, self->interpSave.fp, false); } #endif - switch (interpState->entryPoint) { + switch (self->entryPoint) { case kInterpEntryInstr: /* just fall through to instruction loop or threaded kickstart */ break; @@ -5794,7 +5794,7 @@ GOTO_TARGET_END bail: ILOGD("|-- Leaving interpreter loop"); // note "curMethod" may be NULL - interpState->retval = retval; + self->retval = retval; return false; bail_switch: @@ -5806,18 +5806,18 @@ bail_switch: * TODO: figure out if preserving this makes any sense. */ #if INTERP_TYPE == INTERP_DBG - interpState->debugIsMethodEntry = debugIsMethodEntry; + self->debugIsMethodEntry = debugIsMethodEntry; #else - interpState->debugIsMethodEntry = false; + self->debugIsMethodEntry = false; #endif /* export state changes */ - interpState->method = curMethod; - interpState->pc = pc; - interpState->fp = fp; + self->interpSave.method = curMethod; + self->interpSave.pc = pc; + self->interpSave.fp = fp; /* debugTrackedRefStart doesn't change */ - interpState->retval = retval; /* need for _entryPoint=ret */ - interpState->nextMode = + self->retval = retval; /* need for _entryPoint=ret */ + self->nextMode = (INTERP_TYPE == INTERP_STD) ? INTERP_DBG : INTERP_STD; LOGVV(" meth='%s.%s' pc=0x%x fp=%p\n", curMethod->clazz->descriptor, curMethod->name, diff --git a/vm/mterp/out/InterpC-portstd.c b/vm/mterp/out/InterpC-portstd.c index 43bcb441f..1501ae651 100644 --- a/vm/mterp/out/InterpC-portstd.c +++ b/vm/mterp/out/InterpC-portstd.c @@ -514,10 +514,10 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) } \ if (NEED_INTERP_SWITCH(INTERP_TYPE)) { \ ADJUST_PC(_pcadj); \ - interpState->entryPoint = _entryPoint; \ + self->entryPoint = _entryPoint; \ LOGVV("threadid=%d: switch to %s ep=%d adj=%d\n", \ self->threadId, \ - (interpState->nextMode == INTERP_STD) ? "STD" : "DBG", \ + (self->nextMode == INTERP_STD) ? "STD" : "DBG", \ (_entryPoint), (_pcadj)); \ GOTO_bail_switch(); \ } \ @@ -1287,17 +1287,17 @@ GOTO_TARGET_DECL(exceptionThrown); * * This was written with an ARM implementation in mind. */ -bool INTERP_FUNC_NAME(Thread* self, InterpState* interpState) +bool INTERP_FUNC_NAME(Thread* self) { #if defined(EASY_GDB) StackSaveArea* debugSaveArea = SAVEAREA_FROM_FP(self->curFrame); #endif #if INTERP_TYPE == INTERP_DBG bool debugIsMethodEntry = false; - debugIsMethodEntry = interpState->debugIsMethodEntry; + debugIsMethodEntry = self->debugIsMethodEntry; #endif #if defined(WITH_TRACKREF_CHECKS) - int debugTrackedRefStart = interpState->debugTrackedRefStart; + int debugTrackedRefStart = self->debugTrackedRefStart; #endif DvmDex* methodClassDex; // curMethod->clazz->pDvmDex JValue retval; @@ -1324,16 +1324,16 @@ bool INTERP_FUNC_NAME(Thread* self, InterpState* interpState) #if defined(WITH_JIT) #if 0 LOGD("*DebugInterp - entrypoint is %d, tgt is 0x%x, %s\n", - interpState->entryPoint, - interpState->pc, - interpState->method->name); + self->entryPoint, + self->interpSave.pc, + self->interpSave.method->name); #endif #if INTERP_TYPE == INTERP_DBG const ClassObject* callsiteClass = NULL; #if defined(WITH_SELF_VERIFICATION) - if (interpState->jitState != kJitSelfVerification) { - interpState->self->shadowSpace->jitExitState = kSVSIdle; + if (self->jitState != kJitSelfVerification) { + self->shadowSpace->jitExitState = kSVSIdle; } #endif @@ -1346,11 +1346,11 @@ bool INTERP_FUNC_NAME(Thread* self, InterpState* interpState) * dvmJitCheckTraceRequest will change the jitState to kJitDone but * but stay in the dbg interpreter. */ - (interpState->entryPoint == kInterpEntryInstr) && - (interpState->jitState == kJitTSelectRequest || - interpState->jitState == kJitTSelectRequestHot) && - dvmJitCheckTraceRequest(self, interpState)) { - interpState->nextMode = INTERP_STD; + (self->entryPoint == kInterpEntryInstr) && + (self->jitState == kJitTSelectRequest || + self->jitState == kJitTSelectRequestHot) && + dvmJitCheckTraceRequest(self)) { + self->nextMode = INTERP_STD; //LOGD("Invalid trace request, exiting\n"); return true; } @@ -1358,17 +1358,17 @@ bool INTERP_FUNC_NAME(Thread* self, InterpState* interpState) #endif /* WITH_JIT */ /* copy state in */ - curMethod = interpState->method; - pc = interpState->pc; - fp = interpState->fp; - retval = interpState->retval; /* only need for kInterpEntryReturn? */ + curMethod = self->interpSave.method; + pc = self->interpSave.pc; + fp = self->interpSave.fp; + retval = self->retval; /* only need for kInterpEntryReturn? */ methodClassDex = curMethod->clazz->pDvmDex; LOGVV("threadid=%d: entry(%s) %s.%s pc=0x%x fp=%p ep=%d\n", - self->threadId, (interpState->nextMode == INTERP_STD) ? "STD" : "DBG", + self->threadId, (self->nextMode == INTERP_STD) ? "STD" : "DBG", curMethod->clazz->descriptor, curMethod->name, pc - curMethod->insns, - fp, interpState->entryPoint); + fp, self->entryPoint); /* * DEBUG: scramble this to ensure we're not relying on it. @@ -1379,11 +1379,11 @@ bool INTERP_FUNC_NAME(Thread* self, InterpState* interpState) if (debugIsMethodEntry) { ILOGD("|-- Now interpreting %s.%s", curMethod->clazz->descriptor, curMethod->name); - DUMP_REGS(curMethod, interpState->fp, false); + DUMP_REGS(curMethod, self->interpSave.fp, false); } #endif - switch (interpState->entryPoint) { + switch (self->entryPoint) { case kInterpEntryInstr: /* just fall through to instruction loop or threaded kickstart */ break; @@ -5544,7 +5544,7 @@ GOTO_TARGET_END bail: ILOGD("|-- Leaving interpreter loop"); // note "curMethod" may be NULL - interpState->retval = retval; + self->retval = retval; return false; bail_switch: @@ -5556,18 +5556,18 @@ bail_switch: * TODO: figure out if preserving this makes any sense. */ #if INTERP_TYPE == INTERP_DBG - interpState->debugIsMethodEntry = debugIsMethodEntry; + self->debugIsMethodEntry = debugIsMethodEntry; #else - interpState->debugIsMethodEntry = false; + self->debugIsMethodEntry = false; #endif /* export state changes */ - interpState->method = curMethod; - interpState->pc = pc; - interpState->fp = fp; + self->interpSave.method = curMethod; + self->interpSave.pc = pc; + self->interpSave.fp = fp; /* debugTrackedRefStart doesn't change */ - interpState->retval = retval; /* need for _entryPoint=ret */ - interpState->nextMode = + self->retval = retval; /* need for _entryPoint=ret */ + self->nextMode = (INTERP_TYPE == INTERP_STD) ? INTERP_DBG : INTERP_STD; LOGVV(" meth='%s.%s' pc=0x%x fp=%p\n", curMethod->clazz->descriptor, curMethod->name, diff --git a/vm/mterp/out/InterpC-x86-atom.c b/vm/mterp/out/InterpC-x86-atom.c index f98969a61..791023048 100644 --- a/vm/mterp/out/InterpC-x86-atom.c +++ b/vm/mterp/out/InterpC-x86-atom.c @@ -425,11 +425,11 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) */ #define GOTO_TARGET_DECL(_target, ...) \ - void dvmMterp_##_target(MterpGlue* glue, ## __VA_ARGS__); + void dvmMterp_##_target(Thread* self, ## __VA_ARGS__); /* (void)xxx to quiet unused variable compiler warnings. */ #define GOTO_TARGET(_target, ...) \ - void dvmMterp_##_target(MterpGlue* glue, ## __VA_ARGS__) { \ + void dvmMterp_##_target(Thread* self, ## __VA_ARGS__) { \ u2 ref, vsrc1, vsrc2, vdst; \ u2 inst = FETCH(0); \ const Method* methodToCall; \ @@ -440,16 +440,15 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) #define GOTO_TARGET_END } /* - * Redefine what used to be local variable accesses into MterpGlue struct + * Redefine what used to be local variable accesses into Thread struct * references. (These are undefined down in "footer.c".) */ -#define retval glue->retval -#define pc glue->pc -#define fp glue->fp -#define curMethod glue->method -#define methodClassDex glue->methodClassDex -#define self glue->self -#define debugTrackedRefStart glue->debugTrackedRefStart +#define retval self->retval +#define pc self->interpSave.pc +#define fp self->interpSave.fp +#define curMethod self->interpSave.method +#define methodClassDex self->interpSave.methodClassDex +#define debugTrackedRefStart self->interpSave.debugTrackedRefStart /* ugh */ #define STUB_HACK(x) x @@ -457,12 +456,12 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) /* * Opcode handler framing macros. Here, each opcode is a separate function - * that takes a "glue" argument and returns void. We can't declare + * that takes a "self" argument and returns void. We can't declare * these "static" because they may be called from an assembly stub. * (void)xxx to quiet unused variable compiler warnings. */ #define HANDLE_OPCODE(_op) \ - void dvmMterp_##_op(MterpGlue* glue) { \ + void dvmMterp_##_op(Thread* self) { \ u2 ref, vsrc1, vsrc2, vdst; \ u2 inst = FETCH(0); \ (void)ref; (void)vsrc1; (void)vsrc2; (void)vdst; (void)inst; @@ -489,25 +488,25 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) #define GOTO_exceptionThrown() \ do { \ - dvmMterp_exceptionThrown(glue); \ + dvmMterp_exceptionThrown(self); \ return; \ } while(false) #define GOTO_returnFromMethod() \ do { \ - dvmMterp_returnFromMethod(glue); \ + dvmMterp_returnFromMethod(self); \ return; \ } while(false) #define GOTO_invoke(_target, _methodCallRange, _jumboFormat) \ do { \ - dvmMterp_##_target(glue, _methodCallRange, _jumboFormat); \ + dvmMterp_##_target(self, _methodCallRange, _jumboFormat); \ return; \ } while(false) #define GOTO_invokeMethod(_methodCallRange, _methodToCall, _vsrc1, _vdst) \ do { \ - dvmMterp_invokeMethod(glue, _methodCallRange, _methodToCall, \ + dvmMterp_invokeMethod(self, _methodCallRange, _methodToCall, \ _vsrc1, _vdst); \ return; \ } while(false) @@ -517,9 +516,9 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) * if we need to switch to the other interpreter upon our return. */ #define GOTO_bail() \ - dvmMterpStdBail(glue, false); + dvmMterpStdBail(self, false); #define GOTO_bail_switch() \ - dvmMterpStdBail(glue, true); + dvmMterpStdBail(self, true); /* * Periodically check for thread suspension. @@ -534,7 +533,7 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) } \ if (NEED_INTERP_SWITCH(INTERP_TYPE)) { \ ADJUST_PC(_pcadj); \ - glue->entryPoint = _entryPoint; \ + self->entryPoint = _entryPoint; \ LOGVV("threadid=%d: switch to STD ep=%d adj=%d\n", \ self->threadId, (_entryPoint), (_pcadj)); \ GOTO_bail_switch(); \ diff --git a/vm/mterp/out/InterpC-x86.c b/vm/mterp/out/InterpC-x86.c index 7445ad4f3..e8182db3a 100644 --- a/vm/mterp/out/InterpC-x86.c +++ b/vm/mterp/out/InterpC-x86.c @@ -425,11 +425,11 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) */ #define GOTO_TARGET_DECL(_target, ...) \ - void dvmMterp_##_target(MterpGlue* glue, ## __VA_ARGS__); + void dvmMterp_##_target(Thread* self, ## __VA_ARGS__); /* (void)xxx to quiet unused variable compiler warnings. */ #define GOTO_TARGET(_target, ...) \ - void dvmMterp_##_target(MterpGlue* glue, ## __VA_ARGS__) { \ + void dvmMterp_##_target(Thread* self, ## __VA_ARGS__) { \ u2 ref, vsrc1, vsrc2, vdst; \ u2 inst = FETCH(0); \ const Method* methodToCall; \ @@ -440,16 +440,15 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) #define GOTO_TARGET_END } /* - * Redefine what used to be local variable accesses into MterpGlue struct + * Redefine what used to be local variable accesses into Thread struct * references. (These are undefined down in "footer.c".) */ -#define retval glue->retval -#define pc glue->pc -#define fp glue->fp -#define curMethod glue->method -#define methodClassDex glue->methodClassDex -#define self glue->self -#define debugTrackedRefStart glue->debugTrackedRefStart +#define retval self->retval +#define pc self->interpSave.pc +#define fp self->interpSave.fp +#define curMethod self->interpSave.method +#define methodClassDex self->interpSave.methodClassDex +#define debugTrackedRefStart self->interpSave.debugTrackedRefStart /* ugh */ #define STUB_HACK(x) x @@ -457,12 +456,12 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) /* * Opcode handler framing macros. Here, each opcode is a separate function - * that takes a "glue" argument and returns void. We can't declare + * that takes a "self" argument and returns void. We can't declare * these "static" because they may be called from an assembly stub. * (void)xxx to quiet unused variable compiler warnings. */ #define HANDLE_OPCODE(_op) \ - void dvmMterp_##_op(MterpGlue* glue) { \ + void dvmMterp_##_op(Thread* self) { \ u2 ref, vsrc1, vsrc2, vdst; \ u2 inst = FETCH(0); \ (void)ref; (void)vsrc1; (void)vsrc2; (void)vdst; (void)inst; @@ -489,25 +488,25 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) #define GOTO_exceptionThrown() \ do { \ - dvmMterp_exceptionThrown(glue); \ + dvmMterp_exceptionThrown(self); \ return; \ } while(false) #define GOTO_returnFromMethod() \ do { \ - dvmMterp_returnFromMethod(glue); \ + dvmMterp_returnFromMethod(self); \ return; \ } while(false) #define GOTO_invoke(_target, _methodCallRange, _jumboFormat) \ do { \ - dvmMterp_##_target(glue, _methodCallRange, _jumboFormat); \ + dvmMterp_##_target(self, _methodCallRange, _jumboFormat); \ return; \ } while(false) #define GOTO_invokeMethod(_methodCallRange, _methodToCall, _vsrc1, _vdst) \ do { \ - dvmMterp_invokeMethod(glue, _methodCallRange, _methodToCall, \ + dvmMterp_invokeMethod(self, _methodCallRange, _methodToCall, \ _vsrc1, _vdst); \ return; \ } while(false) @@ -517,9 +516,9 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) * if we need to switch to the other interpreter upon our return. */ #define GOTO_bail() \ - dvmMterpStdBail(glue, false); + dvmMterpStdBail(self, false); #define GOTO_bail_switch() \ - dvmMterpStdBail(glue, true); + dvmMterpStdBail(self, true); /* * Periodically check for thread suspension. @@ -534,7 +533,7 @@ static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc) } \ if (NEED_INTERP_SWITCH(INTERP_TYPE)) { \ ADJUST_PC(_pcadj); \ - glue->entryPoint = _entryPoint; \ + self->entryPoint = _entryPoint; \ LOGVV("threadid=%d: switch to STD ep=%d adj=%d\n", \ self->threadId, (_entryPoint), (_pcadj)); \ GOTO_bail_switch(); \ diff --git a/vm/mterp/portable/enddefs.c b/vm/mterp/portable/enddefs.c index 30deedc11..6f28d8b11 100644 --- a/vm/mterp/portable/enddefs.c +++ b/vm/mterp/portable/enddefs.c @@ -8,7 +8,7 @@ bail: ILOGD("|-- Leaving interpreter loop"); // note "curMethod" may be NULL - interpState->retval = retval; + self->retval = retval; return false; bail_switch: @@ -20,18 +20,18 @@ bail_switch: * TODO: figure out if preserving this makes any sense. */ #if INTERP_TYPE == INTERP_DBG - interpState->debugIsMethodEntry = debugIsMethodEntry; + self->debugIsMethodEntry = debugIsMethodEntry; #else - interpState->debugIsMethodEntry = false; + self->debugIsMethodEntry = false; #endif /* export state changes */ - interpState->method = curMethod; - interpState->pc = pc; - interpState->fp = fp; + self->interpSave.method = curMethod; + self->interpSave.pc = pc; + self->interpSave.fp = fp; /* debugTrackedRefStart doesn't change */ - interpState->retval = retval; /* need for _entryPoint=ret */ - interpState->nextMode = + self->retval = retval; /* need for _entryPoint=ret */ + self->nextMode = (INTERP_TYPE == INTERP_STD) ? INTERP_DBG : INTERP_STD; LOGVV(" meth='%s.%s' pc=0x%x fp=%p\n", curMethod->clazz->descriptor, curMethod->name, diff --git a/vm/mterp/portable/entry.c b/vm/mterp/portable/entry.c index fa3a1b615..c80a25ec5 100644 --- a/vm/mterp/portable/entry.c +++ b/vm/mterp/portable/entry.c @@ -3,17 +3,17 @@ * * This was written with an ARM implementation in mind. */ -bool INTERP_FUNC_NAME(Thread* self, InterpState* interpState) +bool INTERP_FUNC_NAME(Thread* self) { #if defined(EASY_GDB) StackSaveArea* debugSaveArea = SAVEAREA_FROM_FP(self->curFrame); #endif #if INTERP_TYPE == INTERP_DBG bool debugIsMethodEntry = false; - debugIsMethodEntry = interpState->debugIsMethodEntry; + debugIsMethodEntry = self->debugIsMethodEntry; #endif #if defined(WITH_TRACKREF_CHECKS) - int debugTrackedRefStart = interpState->debugTrackedRefStart; + int debugTrackedRefStart = self->debugTrackedRefStart; #endif DvmDex* methodClassDex; // curMethod->clazz->pDvmDex JValue retval; @@ -40,16 +40,16 @@ bool INTERP_FUNC_NAME(Thread* self, InterpState* interpState) #if defined(WITH_JIT) #if 0 LOGD("*DebugInterp - entrypoint is %d, tgt is 0x%x, %s\n", - interpState->entryPoint, - interpState->pc, - interpState->method->name); + self->entryPoint, + self->interpSave.pc, + self->interpSave.method->name); #endif #if INTERP_TYPE == INTERP_DBG const ClassObject* callsiteClass = NULL; #if defined(WITH_SELF_VERIFICATION) - if (interpState->jitState != kJitSelfVerification) { - interpState->self->shadowSpace->jitExitState = kSVSIdle; + if (self->jitState != kJitSelfVerification) { + self->shadowSpace->jitExitState = kSVSIdle; } #endif @@ -62,11 +62,11 @@ bool INTERP_FUNC_NAME(Thread* self, InterpState* interpState) * dvmJitCheckTraceRequest will change the jitState to kJitDone but * but stay in the dbg interpreter. */ - (interpState->entryPoint == kInterpEntryInstr) && - (interpState->jitState == kJitTSelectRequest || - interpState->jitState == kJitTSelectRequestHot) && - dvmJitCheckTraceRequest(self, interpState)) { - interpState->nextMode = INTERP_STD; + (self->entryPoint == kInterpEntryInstr) && + (self->jitState == kJitTSelectRequest || + self->jitState == kJitTSelectRequestHot) && + dvmJitCheckTraceRequest(self)) { + self->nextMode = INTERP_STD; //LOGD("Invalid trace request, exiting\n"); return true; } @@ -74,17 +74,17 @@ bool INTERP_FUNC_NAME(Thread* self, InterpState* interpState) #endif /* WITH_JIT */ /* copy state in */ - curMethod = interpState->method; - pc = interpState->pc; - fp = interpState->fp; - retval = interpState->retval; /* only need for kInterpEntryReturn? */ + curMethod = self->interpSave.method; + pc = self->interpSave.pc; + fp = self->interpSave.fp; + retval = self->retval; /* only need for kInterpEntryReturn? */ methodClassDex = curMethod->clazz->pDvmDex; LOGVV("threadid=%d: entry(%s) %s.%s pc=0x%x fp=%p ep=%d\n", - self->threadId, (interpState->nextMode == INTERP_STD) ? "STD" : "DBG", + self->threadId, (self->nextMode == INTERP_STD) ? "STD" : "DBG", curMethod->clazz->descriptor, curMethod->name, pc - curMethod->insns, - fp, interpState->entryPoint); + fp, self->entryPoint); /* * DEBUG: scramble this to ensure we're not relying on it. @@ -95,11 +95,11 @@ bool INTERP_FUNC_NAME(Thread* self, InterpState* interpState) if (debugIsMethodEntry) { ILOGD("|-- Now interpreting %s.%s", curMethod->clazz->descriptor, curMethod->name); - DUMP_REGS(curMethod, interpState->fp, false); + DUMP_REGS(curMethod, self->interpSave.fp, false); } #endif - switch (interpState->entryPoint) { + switch (self->entryPoint) { case kInterpEntryInstr: /* just fall through to instruction loop or threaded kickstart */ break; diff --git a/vm/mterp/portable/portdbg.c b/vm/mterp/portable/portdbg.c index 8eb11637b..4334627ed 100644 --- a/vm/mterp/portable/portdbg.c +++ b/vm/mterp/portable/portdbg.c @@ -5,11 +5,11 @@ checkDebugAndProf(pc, fp, self, curMethod, &debugIsMethodEntry) #if defined(WITH_JIT) -#define CHECK_JIT_BOOL() (dvmCheckJit(pc, self, interpState, callsiteClass,\ +#define CHECK_JIT_BOOL() (dvmCheckJit(pc, self, callsiteClass,\ methodToCall)) -#define CHECK_JIT_VOID() (dvmCheckJit(pc, self, interpState, callsiteClass,\ +#define CHECK_JIT_VOID() (dvmCheckJit(pc, self, callsiteClass,\ methodToCall)) -#define END_JIT_TSELECT() (dvmJitEndTraceSelect(interpState)) +#define END_JIT_TSELECT() (dvmJitEndTraceSelect(self)) #else #define CHECK_JIT_BOOL() (false) #define CHECK_JIT_VOID() diff --git a/vm/mterp/portable/stubdefs.c b/vm/mterp/portable/stubdefs.c index 4376bb790..84bb6d381 100644 --- a/vm/mterp/portable/stubdefs.c +++ b/vm/mterp/portable/stubdefs.c @@ -91,10 +91,10 @@ } \ if (NEED_INTERP_SWITCH(INTERP_TYPE)) { \ ADJUST_PC(_pcadj); \ - interpState->entryPoint = _entryPoint; \ + self->entryPoint = _entryPoint; \ LOGVV("threadid=%d: switch to %s ep=%d adj=%d\n", \ self->threadId, \ - (interpState->nextMode == INTERP_STD) ? "STD" : "DBG", \ + (self->nextMode == INTERP_STD) ? "STD" : "DBG", \ (_entryPoint), (_pcadj)); \ GOTO_bail_switch(); \ } \ diff --git a/vm/mterp/x86-atom/TODO.txt b/vm/mterp/x86-atom/TODO.txt index df094a6be..4d06bb30a 100644 --- a/vm/mterp/x86-atom/TODO.txt +++ b/vm/mterp/x86-atom/TODO.txt @@ -12,6 +12,8 @@ Items requiring attention: (hi) Implement OP_DISPATCH_FF for real. (Right now it's treated as an unused instruction.) (hi) Rename dvmJitGetCodeAddr to dvmJitGetTraceAddr. +(hi) Remove references to rGLUE and replace with rSELF +(hi) Rework footer.s's suspend check to reflect suspendCount change (md) Correct OP_MONITOR_EXIT (need to adjust PC before throw) (md) OP_THROW needs to export the PC diff --git a/vm/mterp/x86/OP_APUT_OBJECT.S b/vm/mterp/x86/OP_APUT_OBJECT.S index 9c93f395c..64d7e9482 100644 --- a/vm/mterp/x86/OP_APUT_OBJECT.S +++ b/vm/mterp/x86/OP_APUT_OBJECT.S @@ -39,7 +39,7 @@ call dvmCanPutArrayElement # test object type vs. array type UNSPILL_TMP1(%ecx) # recover target address testl %eax,%eax - movl rGLUE,%eax + movl rSELF,%eax jne .L${opcode}_types_okay # The types don't match. We need to throw an ArrayStoreException. @@ -52,7 +52,7 @@ jmp common_exceptionThrown .L${opcode}_types_okay: - movl offGlue_cardTable(%eax),%eax # get card table base + movl offThread_cardTable(%eax),%eax # get card table base movl rINST,(%ecx) # store into array UNSPILL_TMP2(%ecx) # recover object head FETCH_INST_OPCODE 2 %edx diff --git a/vm/mterp/x86/OP_CHECK_CAST.S b/vm/mterp/x86/OP_CHECK_CAST.S index 6fb8415b8..53fdd7789 100644 --- a/vm/mterp/x86/OP_CHECK_CAST.S +++ b/vm/mterp/x86/OP_CHECK_CAST.S @@ -9,10 +9,10 @@ * Check to see if a cast from one class to another is allowed. */ /* check-cast vAA, class@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx GET_VREG_R rINST,rINST # rINST<- vAA (object) movzwl 2(rPC),%eax # eax<- BBBB - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- pDvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex testl rINST,rINST # is oject null? movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses je .L${opcode}_okay # null obj, cast always succeeds @@ -59,10 +59,10 @@ * rINST holds object */ .L${opcode}_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx EXPORT_PC movzwl 2(rPC),%eax # eax<- BBBB - movl offGlue_method(%ecx),%ecx # ecx<- glue->method + movl offThread_method(%ecx),%ecx # ecx<- self->method movl %eax,OUT_ARG1(%esp) # arg1<- BBBB movl offMethod_clazz(%ecx),%ecx # ecx<- metho->clazz movl $$0,OUT_ARG2(%esp) # arg2<- false diff --git a/vm/mterp/x86/OP_CHECK_CAST_JUMBO.S b/vm/mterp/x86/OP_CHECK_CAST_JUMBO.S index 7bb03ee82..e16119719 100644 --- a/vm/mterp/x86/OP_CHECK_CAST_JUMBO.S +++ b/vm/mterp/x86/OP_CHECK_CAST_JUMBO.S @@ -9,10 +9,10 @@ * Check to see if a cast from one class to another is allowed. */ /* check-cast/jumbo vBBBB, class@AAAAAAAA */ - movl rGLUE,%ecx + movl rSELF,%ecx GET_VREG_R rINST,rINST # rINST<- vBBBB (object) movl 2(rPC),%eax # eax<- AAAAAAAA - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- pDvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex testl rINST,rINST # is oject null? movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses je .L${opcode}_okay # null obj, cast always succeeds @@ -59,10 +59,10 @@ * rINST holds object */ .L${opcode}_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx EXPORT_PC movl 2(rPC),%eax # eax<- AAAAAAAA - movl offGlue_method(%ecx),%ecx # ecx<- glue->method + movl offThread_method(%ecx),%ecx # ecx<- self->method movl %eax,OUT_ARG1(%esp) # arg1<- AAAAAAAA movl offMethod_clazz(%ecx),%ecx # ecx<- metho->clazz movl $$0,OUT_ARG2(%esp) # arg2<- false diff --git a/vm/mterp/x86/OP_CONST_CLASS.S b/vm/mterp/x86/OP_CONST_CLASS.S index 96890f536..5320c28a8 100644 --- a/vm/mterp/x86/OP_CONST_CLASS.S +++ b/vm/mterp/x86/OP_CONST_CLASS.S @@ -3,9 +3,9 @@ %verify "Class not yet resolved" %verify "Class cannot be resolved" /* const/class vAA, Class@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- BBBB - movl offGlue_methodClassDex(%ecx),%ecx# ecx<- glue->methodClassDex + movl offThread_methodClassDex(%ecx),%ecx# ecx<- self->methodClassDex movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- dvmDex->pResClasses movl (%ecx,%eax,4),%eax # eax<- rResClasses[BBBB] movl rINST,%ecx @@ -20,10 +20,10 @@ /* This is the less common path, so we'll redo some work here rather than force spills on the common path */ .L${opcode}_resolve: - movl rGLUE,%eax + movl rSELF,%eax movl %ecx,rINST # rINST<- AA EXPORT_PC - movl offGlue_method(%eax),%eax # eax<- glue->method + movl offThread_method(%eax),%eax # eax<- self->method movl $$1,OUT_ARG2(%esp) # true movzwl 2(rPC),%ecx # ecx<- BBBB movl offMethod_clazz(%eax),%eax diff --git a/vm/mterp/x86/OP_CONST_CLASS_JUMBO.S b/vm/mterp/x86/OP_CONST_CLASS_JUMBO.S index 7014d2563..9fa6742f9 100644 --- a/vm/mterp/x86/OP_CONST_CLASS_JUMBO.S +++ b/vm/mterp/x86/OP_CONST_CLASS_JUMBO.S @@ -2,9 +2,9 @@ %verify "Class not yet resolved" %verify "Class cannot be resolved" /* const-class/jumbo vBBBB, Class@AAAAAAAA */ - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%eax # eax<- AAAAAAAA - movl offGlue_methodClassDex(%ecx),%ecx# ecx<- glue->methodClassDex + movl offThread_methodClassDex(%ecx),%ecx# ecx<- self->methodClassDex movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- dvmDex->pResClasses movl (%ecx,%eax,4),%eax # eax<- rResClasses[AAAAAAAA] FETCH_INST_OPCODE 4 %edx @@ -18,9 +18,9 @@ /* This is the less common path, so we'll redo some work here rather than force spills on the common path */ .L${opcode}_resolve: - movl rGLUE,%eax + movl rSELF,%eax EXPORT_PC - movl offGlue_method(%eax),%eax # eax<- glue->method + movl offThread_method(%eax),%eax # eax<- self->method movl $$1,OUT_ARG2(%esp) # true movl 2(rPC),%ecx # ecx<- AAAAAAAA movl offMethod_clazz(%eax),%eax diff --git a/vm/mterp/x86/OP_CONST_STRING.S b/vm/mterp/x86/OP_CONST_STRING.S index 8fd9590b3..f73c352dd 100644 --- a/vm/mterp/x86/OP_CONST_STRING.S +++ b/vm/mterp/x86/OP_CONST_STRING.S @@ -3,9 +3,9 @@ %verify "String not yet resolved" %verify "String cannot be resolved" /* const/string vAA, String@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- BBBB - movl offGlue_methodClassDex(%ecx),%ecx# ecx<- glue->methodClassDex + movl offThread_methodClassDex(%ecx),%ecx# ecx<- self->methodClassDex movl offDvmDex_pResStrings(%ecx),%ecx # ecx<- dvmDex->pResStrings movl (%ecx,%eax,4),%eax # eax<- rResString[BBBB] movl rINST,%ecx @@ -20,10 +20,10 @@ /* This is the less common path, so we'll redo some work here rather than force spills on the common path */ .L${opcode}_resolve: - movl rGLUE,%eax + movl rSELF,%eax movl %ecx,rINST # rINST<- AA EXPORT_PC - movl offGlue_method(%eax),%eax # eax<- glue->method + movl offThread_method(%eax),%eax # eax<- self->method movzwl 2(rPC),%ecx # ecx<- BBBB movl offMethod_clazz(%eax),%eax movl %ecx,OUT_ARG1(%esp) diff --git a/vm/mterp/x86/OP_CONST_STRING_JUMBO.S b/vm/mterp/x86/OP_CONST_STRING_JUMBO.S index 9f5e16a7b..424d6b913 100644 --- a/vm/mterp/x86/OP_CONST_STRING_JUMBO.S +++ b/vm/mterp/x86/OP_CONST_STRING_JUMBO.S @@ -3,9 +3,9 @@ %verify "String not yet resolved" %verify "String cannot be resolved" /* const/string vAA, String@BBBBBBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%eax # eax<- BBBBBBBB - movl offGlue_methodClassDex(%ecx),%ecx# ecx<- glue->methodClassDex + movl offThread_methodClassDex(%ecx),%ecx# ecx<- self->methodClassDex movl offDvmDex_pResStrings(%ecx),%ecx # ecx<- dvmDex->pResStrings movl (%ecx,%eax,4),%eax # eax<- rResString[BBBB] movl rINST,%ecx @@ -20,10 +20,10 @@ /* This is the less common path, so we'll redo some work here rather than force spills on the common path */ .L${opcode}_resolve: - movl rGLUE,%eax + movl rSELF,%eax movl %ecx,rINST # rINST<- AA EXPORT_PC - movl offGlue_method(%eax),%eax # eax<- glue->method + movl offThread_method(%eax),%eax # eax<- self->method movl 2(rPC),%ecx # ecx<- BBBBBBBB movl offMethod_clazz(%eax),%eax movl %ecx,OUT_ARG1(%esp) diff --git a/vm/mterp/x86/OP_EXECUTE_INLINE.S b/vm/mterp/x86/OP_EXECUTE_INLINE.S index 85f9fcfc5..17b6edb0d 100644 --- a/vm/mterp/x86/OP_EXECUTE_INLINE.S +++ b/vm/mterp/x86/OP_EXECUTE_INLINE.S @@ -11,10 +11,10 @@ * */ /* [opt] execute-inline vAA, {vC, vD, vE, vF}, inline@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx EXPORT_PC movzwl 2(rPC),%eax # eax<- BBBB - leal offGlue_retval(%ecx),%ecx # ecx<- & glue->retval + leal offThread_retval(%ecx),%ecx # ecx<- & self->retval movl %ecx,OUT_ARG4(%esp) call .L${opcode}_continue # make call; will return after testl %eax,%eax # successful? diff --git a/vm/mterp/x86/OP_FILLED_NEW_ARRAY.S b/vm/mterp/x86/OP_FILLED_NEW_ARRAY.S index 4e303ad73..e51b163c5 100644 --- a/vm/mterp/x86/OP_FILLED_NEW_ARRAY.S +++ b/vm/mterp/x86/OP_FILLED_NEW_ARRAY.S @@ -8,8 +8,8 @@ */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op {vCCCC..v(CCCC+AA-1)}, type@BBBB */ - movl rGLUE,%eax - movl offGlue_methodClassDex(%eax),%eax # eax<- pDvmDex + movl rSELF,%eax + movl offThread_methodClassDex(%eax),%eax # eax<- pDvmDex movzwl 2(rPC),%ecx # ecx<- BBBB movl offDvmDex_pResClasses(%eax),%eax # eax<- pDvmDex->pResClasses movl (%eax,%ecx,4),%eax # eax<- resolved class @@ -17,10 +17,10 @@ testl %eax,%eax # already resolved? jne .L${opcode}_continue # yes, continue # less frequent path, so we'll redo some work - movl rGLUE,%eax + movl rSELF,%eax movl $$0,OUT_ARG2(%esp) # arg2<- false movl %ecx,OUT_ARG1(%esp) # arg1<- BBBB - movl offGlue_method(%eax),%eax # eax<- glue->method + movl offThread_method(%eax),%eax # eax<- self->method jmp .L${opcode}_more %break @@ -44,7 +44,7 @@ movl $$ALLOC_DONT_TRACK,OUT_ARG2(%esp) # arg2<- flags movzbl 1(%ecx),%ecx # ecx<- descriptor[1] movl %eax,OUT_ARG0(%esp) # arg0<- arrayClass - movl rGLUE,%eax + movl rSELF,%eax cmpb $$'I',%cl # supported? je 1f cmpb $$'L',%cl @@ -52,17 +52,17 @@ cmpb $$'[',%cl jne .L${opcode}_notimpl # no, not handled yet 1: - movl %ecx,offGlue_retval+4(%eax) # save type + movl %ecx,offThread_retval+4(%eax) # save type .if (!$isrange) SPILL_TMP1(rINST) # save copy, need "B" later sarl $$4,rINST .endif movl rINST,OUT_ARG1(%esp) # arg1<- A or AA (length) call dvmAllocArrayByClass # eax<- call(arrayClass, length, flags) - movl rGLUE,%ecx + movl rSELF,%ecx testl %eax,%eax # alloc successful? je common_exceptionThrown # no, handle exception - movl %eax,offGlue_retval(%ecx) # retval.l<- new array + movl %eax,offThread_retval(%ecx) # retval.l<- new array movzwl 4(rPC),%ecx # ecx<- FEDC or CCCC leal offArrayObject_contents(%eax),%eax # eax<- newArray->contents @@ -85,8 +85,8 @@ movsd UNSPILL_TMP2(%esi) UNSPILL_TMP3(%edi) - movl rGLUE,%ecx - movl offGlue_retval+4(%ecx),%eax # eax<- type + movl rSELF,%ecx + movl offThread_retval+4(%ecx),%eax # eax<- type FETCH_INST_OPCODE 3 %edx .else testl rINST,rINST @@ -105,15 +105,15 @@ sub $$1,rINST jne 3b 4: - movl rGLUE,%ecx - movl offGlue_retval+4(%ecx),%eax # eax<- type + movl rSELF,%ecx + movl offThread_retval+4(%ecx),%eax # eax<- type FETCH_INST_OPCODE 3 %edx .endif cmpb $$'I',%al # Int array? je 5f # skip card mark if so - movl offGlue_retval(%ecx),%eax # eax<- object head - movl offGlue_cardTable(%ecx),%ecx # card table base + movl offThread_retval(%ecx),%eax # eax<- object head + movl offThread_cardTable(%ecx),%ecx # card table base shrl $$GC_CARD_SHIFT,%eax # convert to card num movb %cl,(%ecx,%eax) # mark card based on object head 5: diff --git a/vm/mterp/x86/OP_FILLED_NEW_ARRAY_JUMBO.S b/vm/mterp/x86/OP_FILLED_NEW_ARRAY_JUMBO.S index 7ba73db97..3a9bff73a 100644 --- a/vm/mterp/x86/OP_FILLED_NEW_ARRAY_JUMBO.S +++ b/vm/mterp/x86/OP_FILLED_NEW_ARRAY_JUMBO.S @@ -4,8 +4,8 @@ * Create a new array with elements filled from registers. */ /* filled-new-array/jumbo {vCCCC..v(CCCC+BBBB-1)}, type@AAAAAAAA */ - movl rGLUE,%eax - movl offGlue_methodClassDex(%eax),%eax # eax<- pDvmDex + movl rSELF,%eax + movl offThread_methodClassDex(%eax),%eax # eax<- pDvmDex movl 2(rPC),%ecx # ecx<- AAAAAAAA movl offDvmDex_pResClasses(%eax),%eax # eax<- pDvmDex->pResClasses movl (%eax,%ecx,4),%eax # eax<- resolved class @@ -13,10 +13,10 @@ testl %eax,%eax # already resolved? jne .L${opcode}_continue # yes, continue # less frequent path, so we'll redo some work - movl rGLUE,%eax + movl rSELF,%eax movl $$0,OUT_ARG2(%esp) # arg2<- false movl %ecx,OUT_ARG1(%esp) # arg1<- AAAAAAAA - movl offGlue_method(%eax),%eax # eax<- glue->method + movl offThread_method(%eax),%eax # eax<- self->method jmp .L${opcode}_more %break @@ -39,7 +39,7 @@ movl $$ALLOC_DONT_TRACK,OUT_ARG2(%esp) # arg2<- flags movzbl 1(%ecx),%ecx # ecx<- descriptor[1] movl %eax,OUT_ARG0(%esp) # arg0<- arrayClass - movl rGLUE,%eax + movl rSELF,%eax cmpb $$'I',%cl # supported? je 1f cmpb $$'L',%cl @@ -47,13 +47,13 @@ cmpb $$'[',%cl jne .L${opcode}_notimpl # no, not handled yet 1: - movl %ecx,offGlue_retval+4(%eax) # save type + movl %ecx,offThread_retval+4(%eax) # save type movl rINST,OUT_ARG1(%esp) # arg1<- BBBB (length) call dvmAllocArrayByClass # eax<- call(arrayClass, length, flags) - movl rGLUE,%ecx + movl rSELF,%ecx testl %eax,%eax # alloc successful? je common_exceptionThrown # no, handle exception - movl %eax,offGlue_retval(%ecx) # retval.l<- new array + movl %eax,offThread_retval(%ecx) # retval.l<- new array movzwl 8(rPC),%ecx # ecx<- CCCC leal offArrayObject_contents(%eax),%eax # eax<- newArray->contents @@ -74,14 +74,14 @@ movsd UNSPILL_TMP2(%esi) UNSPILL_TMP3(%edi) - movl rGLUE,%ecx - movl offGlue_retval+4(%ecx),%eax # eax<- type + movl rSELF,%ecx + movl offThread_retval+4(%ecx),%eax # eax<- type FETCH_INST_OPCODE 5 %edx cmpb $$'I',%al # Int array? je 5f # skip card mark if so - movl offGlue_retval(%ecx),%eax # eax<- object head - movl offGlue_cardTable(%ecx),%ecx # card table base + movl offThread_retval(%ecx),%eax # eax<- object head + movl offThread_cardTable(%ecx),%ecx # card table base shrl $$GC_CARD_SHIFT,%eax # convert to card num movb %cl,(%ecx,%eax) # mark card based on object head 5: diff --git a/vm/mterp/x86/OP_IGET.S b/vm/mterp/x86/OP_IGET.S index 0495827e8..3f383d46d 100644 --- a/vm/mterp/x86/OP_IGET.S +++ b/vm/mterp/x86/OP_IGET.S @@ -10,9 +10,9 @@ * for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short */ /* op vA, vB, field@CCCC */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%edx # edx<- 0000CCCC - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzbl rINSTbl,%ecx # ecx<- BA sarl $$4,%ecx # ecx<- B movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields @@ -22,14 +22,14 @@ testl %eax,%eax # is resolved entry null? jne .L${opcode}_finish # no, already resolved movl %edx,OUT_ARG1(%esp) # needed by dvmResolveInstField - movl rGLUE,%edx + movl rSELF,%edx jmp .L${opcode}_resolve %break .L${opcode}_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save obj pointer across call movl %edx,OUT_ARG0(%esp) # pass in method->clazz diff --git a/vm/mterp/x86/OP_IGET_JUMBO.S b/vm/mterp/x86/OP_IGET_JUMBO.S index cb90ff088..580422f44 100644 --- a/vm/mterp/x86/OP_IGET_JUMBO.S +++ b/vm/mterp/x86/OP_IGET_JUMBO.S @@ -11,9 +11,9 @@ * iget-char/jumbo, iget-short/jumbo */ /* exop vBBBB, vCCCC, field@AAAAAAAA */ - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%edx # edx<- AAAAAAAA - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzwl 8(rPC),%ecx # ecx<- CCCC movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr @@ -21,14 +21,14 @@ testl %eax,%eax # is resolved entry null? jne .L${opcode}_finish # no, already resolved movl %edx,OUT_ARG1(%esp) # needed by dvmResolveInstField - movl rGLUE,%edx + movl rSELF,%edx jmp .L${opcode}_resolve %break .L${opcode}_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save obj pointer across call movl %edx,OUT_ARG0(%esp) # pass in method->clazz diff --git a/vm/mterp/x86/OP_IGET_WIDE.S b/vm/mterp/x86/OP_IGET_WIDE.S index 3e22dd2ca..f49fb5c38 100644 --- a/vm/mterp/x86/OP_IGET_WIDE.S +++ b/vm/mterp/x86/OP_IGET_WIDE.S @@ -8,9 +8,9 @@ * */ /* op vA, vB, field@CCCC */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%edx # edx<- 0000CCCC - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzbl rINSTbl,%ecx # ecx<- BA sarl $$4,%ecx # ecx<- B movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields @@ -20,14 +20,14 @@ testl %eax,%eax # is resolved entry null? jne .L${opcode}_finish # no, already resolved movl %edx,OUT_ARG1(%esp) # for dvmResolveInstField - movl rGLUE,%edx + movl rSELF,%edx jmp .L${opcode}_resolve %break .L${opcode}_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save objpointer across call movl rPC,OUT_ARG0(%esp) # pass in method->clazz diff --git a/vm/mterp/x86/OP_IGET_WIDE_JUMBO.S b/vm/mterp/x86/OP_IGET_WIDE_JUMBO.S index 9237b4062..c21b235c1 100644 --- a/vm/mterp/x86/OP_IGET_WIDE_JUMBO.S +++ b/vm/mterp/x86/OP_IGET_WIDE_JUMBO.S @@ -7,9 +7,9 @@ * Jumbo 64-bit instance field get. */ /* iget-wide/jumbo vBBBB, vCCCC, field@AAAA */ - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%edx # edx<- AAAAAAAA - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzwl 8(rPC),%ecx # ecx<- CCCC movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr @@ -17,14 +17,14 @@ testl %eax,%eax # is resolved entry null? jne .L${opcode}_finish # no, already resolved movl %edx,OUT_ARG1(%esp) # for dvmResolveInstField - movl rGLUE,%edx + movl rSELF,%edx jmp .L${opcode}_resolve %break .L${opcode}_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save objpointer across call movl rPC,OUT_ARG0(%esp) # pass in method->clazz diff --git a/vm/mterp/x86/OP_INSTANCE_OF.S b/vm/mterp/x86/OP_INSTANCE_OF.S index fddb5c8d2..41390569d 100644 --- a/vm/mterp/x86/OP_INSTANCE_OF.S +++ b/vm/mterp/x86/OP_INSTANCE_OF.S @@ -15,9 +15,9 @@ movl rINST,%eax # eax<- BA sarl $$4,%eax # eax<- B GET_VREG_R %eax %eax # eax<- vB (obj) - movl rGLUE,%ecx + movl rSELF,%ecx testl %eax,%eax # object null? - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- pDvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex je .L${opcode}_store # null obj, not instance, store it movzwl 2(rPC),%edx # edx<- CCCC movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses @@ -74,8 +74,8 @@ */ .L${opcode}_resolve: movl %edx,OUT_ARG1(%esp) # arg1<- BBBB - movl rGLUE,%ecx - movl offGlue_method(%ecx),%ecx + movl rSELF,%ecx + movl offThread_method(%ecx),%ecx movl $$1,OUT_ARG2(%esp) # arg2<- true movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz EXPORT_PC diff --git a/vm/mterp/x86/OP_INSTANCE_OF_JUMBO.S b/vm/mterp/x86/OP_INSTANCE_OF_JUMBO.S index 9a76218e6..2888c7610 100644 --- a/vm/mterp/x86/OP_INSTANCE_OF_JUMBO.S +++ b/vm/mterp/x86/OP_INSTANCE_OF_JUMBO.S @@ -14,9 +14,9 @@ /* instance-of/jumbo vBBBB, vCCCC, class@AAAAAAAA */ movzwl 8(rPC),%eax # eax<- CCCC GET_VREG_R %eax %eax # eax<- vCCCC (obj) - movl rGLUE,%ecx + movl rSELF,%ecx testl %eax,%eax # object null? - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- pDvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex je .L${opcode}_store # null obj, not instance, store it movl 2(rPC),%edx # edx<- AAAAAAAA movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses @@ -70,8 +70,8 @@ */ .L${opcode}_resolve: movl %edx,OUT_ARG1(%esp) # arg1<- AAAAAAAA - movl rGLUE,%ecx - movl offGlue_method(%ecx),%ecx + movl rSELF,%ecx + movl offThread_method(%ecx),%ecx movl $$1,OUT_ARG2(%esp) # arg2<- true movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz EXPORT_PC diff --git a/vm/mterp/x86/OP_INVOKE_DIRECT.S b/vm/mterp/x86/OP_INVOKE_DIRECT.S index 37181013d..9070228de 100644 --- a/vm/mterp/x86/OP_INVOKE_DIRECT.S +++ b/vm/mterp/x86/OP_INVOKE_DIRECT.S @@ -13,9 +13,9 @@ */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- BBBB - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- pDvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex EXPORT_PC movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods movzwl 4(rPC),%edx # edx<- GFED or CCCC @@ -40,8 +40,8 @@ */ .L${opcode}_resolve: SPILL_TMP1(%ecx) - movl rGLUE,%ecx - movl offGlue_method(%ecx),%ecx # ecx<- glue->method + movl rSELF,%ecx + movl offThread_method(%ecx),%ecx # ecx<- self->method movzwl 2(rPC),%eax # reference (BBBB or CCCC) movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl $$METHOD_DIRECT,OUT_ARG2(%esp) diff --git a/vm/mterp/x86/OP_INVOKE_DIRECT_JUMBO.S b/vm/mterp/x86/OP_INVOKE_DIRECT_JUMBO.S index d7998d7a8..1040775d5 100644 --- a/vm/mterp/x86/OP_INVOKE_DIRECT_JUMBO.S +++ b/vm/mterp/x86/OP_INVOKE_DIRECT_JUMBO.S @@ -9,9 +9,9 @@ * out we could avoiding loading the first arg twice.) */ /* invoke-direct/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%eax # eax<- AAAAAAAA - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- pDvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex EXPORT_PC movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods movzwl 8(rPC),%edx # edx<- CCCC @@ -33,8 +33,8 @@ */ .L${opcode}_resolve: SPILL_TMP1(%ecx) - movl rGLUE,%ecx - movl offGlue_method(%ecx),%ecx # ecx<- glue->method + movl rSELF,%ecx + movl offThread_method(%ecx),%ecx # ecx<- self->method movl 2(rPC),%eax # reference AAAAAAAA movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl $$METHOD_DIRECT,OUT_ARG2(%esp) diff --git a/vm/mterp/x86/OP_INVOKE_INTERFACE.S b/vm/mterp/x86/OP_INVOKE_INTERFACE.S index aab94bee5..1e2032d30 100644 --- a/vm/mterp/x86/OP_INVOKE_INTERFACE.S +++ b/vm/mterp/x86/OP_INVOKE_INTERFACE.S @@ -10,7 +10,7 @@ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ movzwl 4(rPC),%eax # eax<- FEDC or CCCC - movl rGLUE,%ecx + movl rSELF,%ecx .if (!$isrange) andl $$0xf,%eax # eax<- C (or stays CCCC) .endif @@ -20,8 +20,8 @@ je common_errNullObject # yes, fail movl offObject_clazz(%eax),%eax# eax<- thisPtr->clazz movl %eax,OUT_ARG0(%esp) # arg0<- class - movl offGlue_methodClassDex(%ecx),%eax # eax<- methodClassDex - movl offGlue_method(%ecx),%ecx # ecx<- method + movl offThread_methodClassDex(%ecx),%eax # eax<- methodClassDex + movl offThread_method(%ecx),%ecx # ecx<- method movl %eax,OUT_ARG3(%esp) # arg3<- dex movzwl 2(rPC),%eax # eax<- BBBB movl %ecx,OUT_ARG2(%esp) # arg2<- method diff --git a/vm/mterp/x86/OP_INVOKE_INTERFACE_JUMBO.S b/vm/mterp/x86/OP_INVOKE_INTERFACE_JUMBO.S index 5fbcfb4e8..7da63b8b7 100644 --- a/vm/mterp/x86/OP_INVOKE_INTERFACE_JUMBO.S +++ b/vm/mterp/x86/OP_INVOKE_INTERFACE_JUMBO.S @@ -6,15 +6,15 @@ */ /* invoke-interface/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ movzwl 8(rPC),%eax # eax<- CCCC - movl rGLUE,%ecx + movl rSELF,%ecx GET_VREG_R %eax %eax # eax<- "this" EXPORT_PC testl %eax,%eax # null this? je common_errNullObject # yes, fail movl offObject_clazz(%eax),%eax# eax<- thisPtr->clazz movl %eax,OUT_ARG0(%esp) # arg0<- class - movl offGlue_methodClassDex(%ecx),%eax # eax<- methodClassDex - movl offGlue_method(%ecx),%ecx # ecx<- method + movl offThread_methodClassDex(%ecx),%eax # eax<- methodClassDex + movl offThread_method(%ecx),%ecx # ecx<- method movl %eax,OUT_ARG3(%esp) # arg3<- dex movl 2(rPC),%eax # eax<- AAAAAAAA movl %ecx,OUT_ARG2(%esp) # arg2<- method diff --git a/vm/mterp/x86/OP_INVOKE_STATIC.S b/vm/mterp/x86/OP_INVOKE_STATIC.S index ca89cff15..d677f2b04 100644 --- a/vm/mterp/x86/OP_INVOKE_STATIC.S +++ b/vm/mterp/x86/OP_INVOKE_STATIC.S @@ -8,16 +8,16 @@ */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- BBBB - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- pDvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex EXPORT_PC movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods movl (%ecx,%eax,4),%eax # eax<- resolved methodToCall testl %eax,%eax jne common_invokeMethod${routine} - movl rGLUE,%ecx - movl offGlue_method(%ecx),%ecx # ecx<- glue->method + movl rSELF,%ecx + movl offThread_method(%ecx),%ecx # ecx<- self->method movzwl 2(rPC),%eax movl offMethod_clazz(%ecx),%ecx# ecx<- method->clazz movl %eax,OUT_ARG1(%esp) # arg1<- BBBB diff --git a/vm/mterp/x86/OP_INVOKE_STATIC_JUMBO.S b/vm/mterp/x86/OP_INVOKE_STATIC_JUMBO.S index dbe3a62b5..80496d656 100644 --- a/vm/mterp/x86/OP_INVOKE_STATIC_JUMBO.S +++ b/vm/mterp/x86/OP_INVOKE_STATIC_JUMBO.S @@ -4,16 +4,16 @@ * Handle a jumbo static method call. */ /* invoke-static/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%eax # eax<- AAAAAAAA - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- pDvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex EXPORT_PC movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods movl (%ecx,%eax,4),%eax # eax<- resolved methodToCall testl %eax,%eax jne common_invokeMethodJumbo - movl rGLUE,%ecx - movl offGlue_method(%ecx),%ecx # ecx<- glue->method + movl rSELF,%ecx + movl offThread_method(%ecx),%ecx # ecx<- self->method movl 2(rPC),%eax # eax<- AAAAAAAA movl offMethod_clazz(%ecx),%ecx# ecx<- method->clazz movl %eax,OUT_ARG1(%esp) # arg1<- AAAAAAAA diff --git a/vm/mterp/x86/OP_INVOKE_SUPER.S b/vm/mterp/x86/OP_INVOKE_SUPER.S index 42bd6a6ca..02ec6f4f8 100644 --- a/vm/mterp/x86/OP_INVOKE_SUPER.S +++ b/vm/mterp/x86/OP_INVOKE_SUPER.S @@ -8,13 +8,13 @@ */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - movl rGLUE,rINST + movl rSELF,rINST movzwl 2(rPC),%eax # eax<- BBBB - movl offGlue_methodClassDex(rINST),%ecx # ecx<- pDvmDex + movl offThread_methodClassDex(rINST),%ecx # ecx<- pDvmDex EXPORT_PC movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods movl (%ecx,%eax,4),%ecx # ecx<- resolved baseMethod - movl offGlue_method(rINST),%eax # eax<- method + movl offThread_method(rINST),%eax # eax<- method movzwl 4(rPC),rINST # rINST<- GFED or CCCC .if (!$isrange) andl $$0xf,rINST # rINST<- D (or stays CCCC) diff --git a/vm/mterp/x86/OP_INVOKE_SUPER_JUMBO.S b/vm/mterp/x86/OP_INVOKE_SUPER_JUMBO.S index 40f6ded2d..631aa3c2e 100644 --- a/vm/mterp/x86/OP_INVOKE_SUPER_JUMBO.S +++ b/vm/mterp/x86/OP_INVOKE_SUPER_JUMBO.S @@ -4,13 +4,13 @@ * Handle a jumbo "super" method call. */ /* invoke-super/jumbo {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ - movl rGLUE,rINST + movl rSELF,rINST movl 2(rPC),%eax # eax<- AAAAAAAA - movl offGlue_methodClassDex(rINST),%ecx # ecx<- pDvmDex + movl offThread_methodClassDex(rINST),%ecx # ecx<- pDvmDex EXPORT_PC movl offDvmDex_pResMethods(%ecx),%ecx # ecx<- pDvmDex->pResMethods movl (%ecx,%eax,4),%ecx # ecx<- resolved baseMethod - movl offGlue_method(rINST),%eax # eax<- method + movl offThread_method(rINST),%eax # eax<- method movzwl 8(rPC),rINST # rINST<- CCCC GET_VREG_R rINST rINST # rINST<- "this" ptr testl rINST,rINST # null "this"? diff --git a/vm/mterp/x86/OP_INVOKE_SUPER_QUICK.S b/vm/mterp/x86/OP_INVOKE_SUPER_QUICK.S index d02cf13eb..5fe098cd8 100644 --- a/vm/mterp/x86/OP_INVOKE_SUPER_QUICK.S +++ b/vm/mterp/x86/OP_INVOKE_SUPER_QUICK.S @@ -8,9 +8,9 @@ */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 4(rPC),%eax # eax<- GFED or CCCC - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method .if (!$isrange) andl $$0xf,%eax # eax<- D (or stays CCCC) .endif diff --git a/vm/mterp/x86/OP_INVOKE_VIRTUAL.S b/vm/mterp/x86/OP_INVOKE_VIRTUAL.S index ab4dc9532..63ecb1818 100644 --- a/vm/mterp/x86/OP_INVOKE_VIRTUAL.S +++ b/vm/mterp/x86/OP_INVOKE_VIRTUAL.S @@ -10,17 +10,17 @@ */ /* op vB, {vD, vE, vF, vG, vA}, class@CCCC */ /* op vAA, {vCCCC..v(CCCC+AA-1)}, meth@BBBB */ - movl rGLUE,%eax + movl rSELF,%eax movzwl 2(rPC),%ecx # ecx<- BBBB - movl offGlue_methodClassDex(%eax),%eax # eax<- pDvmDex + movl offThread_methodClassDex(%eax),%eax # eax<- pDvmDex EXPORT_PC movl offDvmDex_pResMethods(%eax),%eax # eax<- pDvmDex->pResMethods movl (%eax,%ecx,4),%eax # eax<- resolved baseMethod testl %eax,%eax # already resolved? jne .L${opcode}_continue # yes, continue - movl rGLUE,%eax + movl rSELF,%eax movl %ecx,OUT_ARG1(%esp) # arg1<- ref - movl offGlue_method(%eax),%eax # eax<- glue->method + movl offThread_method(%eax),%eax # eax<- self->method jmp .L${opcode}_more %break diff --git a/vm/mterp/x86/OP_INVOKE_VIRTUAL_JUMBO.S b/vm/mterp/x86/OP_INVOKE_VIRTUAL_JUMBO.S index 35b798f7a..6d73151ec 100644 --- a/vm/mterp/x86/OP_INVOKE_VIRTUAL_JUMBO.S +++ b/vm/mterp/x86/OP_INVOKE_VIRTUAL_JUMBO.S @@ -5,17 +5,17 @@ * Handle a jumbo virtual method call. */ /* invoke-virtual/jumbo vBBBB, {vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA */ - movl rGLUE,%eax + movl rSELF,%eax movl 2(rPC),%ecx # ecx<- AAAAAAAA - movl offGlue_methodClassDex(%eax),%eax # eax<- pDvmDex + movl offThread_methodClassDex(%eax),%eax # eax<- pDvmDex EXPORT_PC movl offDvmDex_pResMethods(%eax),%eax # eax<- pDvmDex->pResMethods movl (%eax,%ecx,4),%eax # eax<- resolved baseMethod testl %eax,%eax # already resolved? jne .L${opcode}_continue # yes, continue - movl rGLUE,%eax + movl rSELF,%eax movl %ecx,OUT_ARG1(%esp) # arg1<- ref - movl offGlue_method(%eax),%eax # eax<- glue->method + movl offThread_method(%eax),%eax # eax<- self->method jmp .L${opcode}_more %break diff --git a/vm/mterp/x86/OP_IPUT.S b/vm/mterp/x86/OP_IPUT.S index 20d4a1af4..ec8a780e3 100644 --- a/vm/mterp/x86/OP_IPUT.S +++ b/vm/mterp/x86/OP_IPUT.S @@ -11,9 +11,9 @@ * for: iput, iput-object, iput-boolean, iput-byte, iput-char, iput-short */ /* op vA, vB, field@CCCC */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%edx # %edx<- 0000CCCC - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzbl rINSTbl,%ecx # ecx<- BA sarl $$4,%ecx # ecx<- B movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields @@ -23,14 +23,14 @@ testl %eax,%eax # is resolved entry null? jne .L${opcode}_finish # no, already resolved movl %edx,OUT_ARG1(%esp) - movl rGLUE,%edx + movl rSELF,%edx jmp .L${opcode}_resolve %break .L${opcode}_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save obj pointer across call movl %edx,OUT_ARG0(%esp) # pass in method->clazz diff --git a/vm/mterp/x86/OP_IPUT_JUMBO.S b/vm/mterp/x86/OP_IPUT_JUMBO.S index 89028634d..b01cd8c73 100644 --- a/vm/mterp/x86/OP_IPUT_JUMBO.S +++ b/vm/mterp/x86/OP_IPUT_JUMBO.S @@ -11,9 +11,9 @@ iput-char/jumbo, iput-short/jumbo */ /* exop vBBBB, vCCCC, field@AAAAAAAA */ - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%edx # edx<- AAAAAAAA - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzwl 8(rPC),%ecx # ecx<- CCCC movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr @@ -21,14 +21,14 @@ testl %eax,%eax # is resolved entry null? jne .L${opcode}_finish # no, already resolved movl %edx,OUT_ARG1(%esp) - movl rGLUE,%edx + movl rSELF,%edx jmp .L${opcode}_resolve %break .L${opcode}_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save obj pointer across call movl %edx,OUT_ARG0(%esp) # pass in method->clazz diff --git a/vm/mterp/x86/OP_IPUT_OBJECT.S b/vm/mterp/x86/OP_IPUT_OBJECT.S index 03dcb0802..65aa18622 100644 --- a/vm/mterp/x86/OP_IPUT_OBJECT.S +++ b/vm/mterp/x86/OP_IPUT_OBJECT.S @@ -10,9 +10,9 @@ * for: iput-object */ /* op vA, vB, field@CCCC */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%edx # edx<- 0000CCCC - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzbl rINSTbl,%ecx # ecx<- BA sarl $$4,%ecx # ecx<- B movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields @@ -22,14 +22,14 @@ testl %eax,%eax # is resolved entry null? jne .L${opcode}_finish # no, already resolved movl %edx,OUT_ARG1(%esp) - movl rGLUE,%edx + movl rSELF,%edx jmp .L${opcode}_resolve %break .L${opcode}_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save obj pointer across call movl %edx,OUT_ARG0(%esp) # pass in method->clazz @@ -52,9 +52,9 @@ testl %ecx,%ecx # object null? je common_errNullObject # object was null movl rINST,(%ecx,%eax) # obj.field <- v[A](8/16/32 bits) - movl rGLUE,%eax + movl rSELF,%eax testl rINST,rINST # stored a NULL? - movl offGlue_cardTable(%eax),%eax # get card table base + movl offThread_cardTable(%eax),%eax # get card table base FETCH_INST_OPCODE 2 %edx je 1f # skip card mark if null store shrl $$GC_CARD_SHIFT,%ecx # object head to card number diff --git a/vm/mterp/x86/OP_IPUT_OBJECT_JUMBO.S b/vm/mterp/x86/OP_IPUT_OBJECT_JUMBO.S index b0535a161..7b6589fdd 100644 --- a/vm/mterp/x86/OP_IPUT_OBJECT_JUMBO.S +++ b/vm/mterp/x86/OP_IPUT_OBJECT_JUMBO.S @@ -8,9 +8,9 @@ * Jumbo object field put. */ /* iput-object/jumbo vBBBB, vCCCC, field@AAAAAAAA */ - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%edx # edx<- AAAAAAAA - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzwl 8(rPC),%ecx # ecx<- CCCC movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr @@ -18,14 +18,14 @@ testl %eax,%eax # is resolved entry null? jne .L${opcode}_finish # no, already resolved movl %edx,OUT_ARG1(%esp) - movl rGLUE,%edx + movl rSELF,%edx jmp .L${opcode}_resolve %break .L${opcode}_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save obj pointer across call movl %edx,OUT_ARG0(%esp) # pass in method->clazz @@ -48,9 +48,9 @@ testl %ecx,%ecx # object null? je common_errNullObject # object was null movl rINST,(%ecx,%eax) # obj.field <- v[BBBB](8/16/32 bits) - movl rGLUE,%eax + movl rSELF,%eax testl rINST,rINST # stored a NULL? - movl offGlue_cardTable(%eax),%eax # get card table base + movl offThread_cardTable(%eax),%eax # get card table base FETCH_INST_OPCODE 5 %edx je 1f # skip card mark if null store shrl $$GC_CARD_SHIFT,%ecx # object head to card number diff --git a/vm/mterp/x86/OP_IPUT_OBJECT_QUICK.S b/vm/mterp/x86/OP_IPUT_OBJECT_QUICK.S index 7fa99a87c..8f5db6fef 100644 --- a/vm/mterp/x86/OP_IPUT_OBJECT_QUICK.S +++ b/vm/mterp/x86/OP_IPUT_OBJECT_QUICK.S @@ -11,14 +11,14 @@ testl %ecx,%ecx # is object null? je common_errNullObject movl rINST,(%ecx,%eax,1) - movl rGLUE,%eax + movl rSELF,%eax jmp .L${opcode}_finish %break .L${opcode}_finish: testl rINST,rINST # did we store null? FETCH_INST_OPCODE 2 %edx - movl offGlue_cardTable(%eax),%eax # get card table base + movl offThread_cardTable(%eax),%eax # get card table base je 1f # skip card mark if null store shrl $$GC_CARD_SHIFT,%ecx # object head to card number movb %al,(%eax,%ecx) # mark card based on object head diff --git a/vm/mterp/x86/OP_IPUT_WIDE.S b/vm/mterp/x86/OP_IPUT_WIDE.S index 435d474c5..8c8b465ec 100644 --- a/vm/mterp/x86/OP_IPUT_WIDE.S +++ b/vm/mterp/x86/OP_IPUT_WIDE.S @@ -8,9 +8,9 @@ * */ /* op vA, vB, field@CCCC */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%edx # edx<- 0000CCCC - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzbl rINSTbl,%ecx # ecx<- BA sarl $$4,%ecx # ecx<- B movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields @@ -20,14 +20,14 @@ testl %eax,%eax # is resolved entry null? jne .L${opcode}_finish # no, already resolved movl %edx,OUT_ARG1(%esp) - movl rGLUE,%edx + movl rSELF,%edx jmp .L${opcode}_resolve %break .L${opcode}_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save obj pointer across call movl %edx,OUT_ARG0(%esp) # pass in method->clazz diff --git a/vm/mterp/x86/OP_IPUT_WIDE_JUMBO.S b/vm/mterp/x86/OP_IPUT_WIDE_JUMBO.S index 9cc4e7f9e..37495d2dd 100644 --- a/vm/mterp/x86/OP_IPUT_WIDE_JUMBO.S +++ b/vm/mterp/x86/OP_IPUT_WIDE_JUMBO.S @@ -7,9 +7,9 @@ * Jumbo 64-bit instance field put. */ /* iput-wide/jumbo vBBBB, vCCCC, field@AAAAAAAA */ - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%edx # edx<- AAAAAAAA - movl offGlue_methodClassDex(%ecx),%eax # eax<- DvmDex + movl offThread_methodClassDex(%ecx),%eax # eax<- DvmDex movzwl 8(rPC),%ecx # ecx<- CCCC movl offDvmDex_pResFields(%eax),%eax # eax<- pDvmDex->pResFields GET_VREG_R %ecx %ecx # ecx<- fp[CCCC], the object ptr @@ -17,14 +17,14 @@ testl %eax,%eax # is resolved entry null? jne .L${opcode}_finish # no, already resolved movl %edx,OUT_ARG1(%esp) - movl rGLUE,%edx + movl rSELF,%edx jmp .L${opcode}_resolve %break .L${opcode}_resolve: EXPORT_PC - movl offGlue_method(%edx),%edx # edx<- current method + movl offThread_method(%edx),%edx # edx<- current method movl offMethod_clazz(%edx),%edx # edx<- method->clazz SPILL_TMP1(%ecx) # save obj pointer across call movl %edx,OUT_ARG0(%esp) # pass in method->clazz diff --git a/vm/mterp/x86/OP_MONITOR_ENTER.S b/vm/mterp/x86/OP_MONITOR_ENTER.S index a26726662..aa8d1055e 100644 --- a/vm/mterp/x86/OP_MONITOR_ENTER.S +++ b/vm/mterp/x86/OP_MONITOR_ENTER.S @@ -4,9 +4,8 @@ * Synchronize on an object. */ /* monitor-enter vAA */ - movl rGLUE,%ecx + movl rSELF,%ecx GET_VREG_R %eax rINST # eax<- vAA - movl offGlue_self(%ecx),%ecx # ecx<- glue->self FETCH_INST_WORD 1 testl %eax,%eax # null object? EXPORT_PC # need for precise GC diff --git a/vm/mterp/x86/OP_MONITOR_EXIT.S b/vm/mterp/x86/OP_MONITOR_EXIT.S index 7e4e3d0ad..4e4c0b442 100644 --- a/vm/mterp/x86/OP_MONITOR_EXIT.S +++ b/vm/mterp/x86/OP_MONITOR_EXIT.S @@ -10,11 +10,10 @@ */ /* monitor-exit vAA */ GET_VREG_R %eax rINST - movl rGLUE,%ecx + movl rSELF,%ecx EXPORT_PC testl %eax,%eax # null object? je .L${opcode}_errNullObject # go if so - movl offGlue_self(%ecx),%ecx # ecx<- glue->self movl %eax,OUT_ARG1(%esp) movl %ecx,OUT_ARG0(%esp) jmp .L${opcode}_continue diff --git a/vm/mterp/x86/OP_MOVE_EXCEPTION.S b/vm/mterp/x86/OP_MOVE_EXCEPTION.S index f9542ae02..0aeb4432e 100644 --- a/vm/mterp/x86/OP_MOVE_EXCEPTION.S +++ b/vm/mterp/x86/OP_MOVE_EXCEPTION.S @@ -1,7 +1,6 @@ %verify "executed" /* move-exception vAA */ - movl rGLUE,%ecx - movl offGlue_self(%ecx),%ecx # ecx<- glue->self + movl rSELF,%ecx movl offThread_exception(%ecx),%eax # eax<- dvmGetException bypass SET_VREG %eax rINST # fp[AA]<- exception object FETCH_INST_OPCODE 1 %edx diff --git a/vm/mterp/x86/OP_MOVE_RESULT.S b/vm/mterp/x86/OP_MOVE_RESULT.S index 07770cbde..4c01e2d44 100644 --- a/vm/mterp/x86/OP_MOVE_RESULT.S +++ b/vm/mterp/x86/OP_MOVE_RESULT.S @@ -1,9 +1,9 @@ %verify "executed" /* for: move-result, move-result-object */ /* op vAA */ - movl rGLUE,%eax # eax<- rGLUE + movl rSELF,%eax # eax<- rSELF movzx rINSTbl,%ecx # ecx<- AA - movl offGlue_retval(%eax),%eax # eax<- glue->retval.l + movl offThread_retval(%eax),%eax # eax<- self->retval.l FETCH_INST_OPCODE 1 %edx ADVANCE_PC 1 SET_VREG %eax %ecx # fp[AA]<- retval.l diff --git a/vm/mterp/x86/OP_MOVE_RESULT_WIDE.S b/vm/mterp/x86/OP_MOVE_RESULT_WIDE.S index 9f8d315e3..13e2f1644 100644 --- a/vm/mterp/x86/OP_MOVE_RESULT_WIDE.S +++ b/vm/mterp/x86/OP_MOVE_RESULT_WIDE.S @@ -1,8 +1,8 @@ %verify "executed" /* move-result-wide vAA */ - movl rGLUE,%ecx - movl offGlue_retval(%ecx),%eax - movl 4+offGlue_retval(%ecx),%ecx + movl rSELF,%ecx + movl offThread_retval(%ecx),%eax + movl 4+offThread_retval(%ecx),%ecx FETCH_INST_OPCODE 1 %edx SET_VREG_WORD %eax rINST 0 # v[AA+0] <- eax SET_VREG_WORD %ecx rINST 1 # v[AA+1] <- ecx diff --git a/vm/mterp/x86/OP_NEW_ARRAY.S b/vm/mterp/x86/OP_NEW_ARRAY.S index 4f36ac22c..35a14f71e 100644 --- a/vm/mterp/x86/OP_NEW_ARRAY.S +++ b/vm/mterp/x86/OP_NEW_ARRAY.S @@ -9,9 +9,9 @@ * check for it here. */ /* new-array vA, vB, class@CCCC */ - movl rGLUE,%ecx + movl rSELF,%ecx EXPORT_PC - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- pDvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex movzwl 2(rPC),%eax # eax<- CCCC movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses movl (%ecx,%eax,4),%ecx # ecx<- resolved class @@ -32,9 +32,9 @@ * eax holds array length (vB) */ .L${opcode}_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx SPILL_TMP1(%eax) # save array length - movl offGlue_method(%ecx),%ecx # ecx<- glue->method + movl offThread_method(%ecx),%ecx # ecx<- self->method movzwl 2(rPC),%eax # eax<- CCCC movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) diff --git a/vm/mterp/x86/OP_NEW_ARRAY_JUMBO.S b/vm/mterp/x86/OP_NEW_ARRAY_JUMBO.S index 031874b5a..b0a2ccdd3 100644 --- a/vm/mterp/x86/OP_NEW_ARRAY_JUMBO.S +++ b/vm/mterp/x86/OP_NEW_ARRAY_JUMBO.S @@ -9,9 +9,9 @@ * check for it here. */ /* new-array/jumbo vBBBB, vCCCC, class@AAAAAAAA */ - movl rGLUE,%ecx + movl rSELF,%ecx EXPORT_PC - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- pDvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex movl 2(rPC),%eax # eax<- AAAAAAAA movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses movl (%ecx,%eax,4),%ecx # ecx<- resolved class @@ -30,9 +30,9 @@ * eax holds array length (vCCCC) */ .L${opcode}_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx SPILL_TMP1(%eax) # save array length - movl offGlue_method(%ecx),%ecx # ecx<- glue->method + movl offThread_method(%ecx),%ecx # ecx<- self->method movl 2(rPC),%eax # eax<- AAAAAAAA movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) diff --git a/vm/mterp/x86/OP_NEW_INSTANCE.S b/vm/mterp/x86/OP_NEW_INSTANCE.S index 6ceb933f0..fe9f2cae2 100644 --- a/vm/mterp/x86/OP_NEW_INSTANCE.S +++ b/vm/mterp/x86/OP_NEW_INSTANCE.S @@ -10,9 +10,9 @@ * Create a new instance of a class. */ /* new-instance vAA, class@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- BBBB - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- pDvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses EXPORT_PC movl (%ecx,%eax,4),%ecx # ecx<- resolved class @@ -58,9 +58,9 @@ * */ .L${opcode}_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax - movl offGlue_method(%ecx),%ecx # ecx<- glue->method + movl offThread_method(%ecx),%ecx # ecx<- self->method movl %eax,OUT_ARG1(%esp) movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl $$0,OUT_ARG2(%esp) diff --git a/vm/mterp/x86/OP_NEW_INSTANCE_JUMBO.S b/vm/mterp/x86/OP_NEW_INSTANCE_JUMBO.S index 78251c140..bc8a950d8 100644 --- a/vm/mterp/x86/OP_NEW_INSTANCE_JUMBO.S +++ b/vm/mterp/x86/OP_NEW_INSTANCE_JUMBO.S @@ -10,9 +10,9 @@ * Create a new instance of a class. */ /* new-instance/jumbo vBBBB, class@AAAAAAAA */ - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%eax # eax<- AAAAAAAA - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- pDvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- pDvmDex movl offDvmDex_pResClasses(%ecx),%ecx # ecx<- pDvmDex->pResClasses EXPORT_PC movl (%ecx,%eax,4),%ecx # ecx<- resolved class @@ -58,9 +58,9 @@ * */ .L${opcode}_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%eax # eax<- AAAAAAAA - movl offGlue_method(%ecx),%ecx # ecx<- glue->method + movl offThread_method(%ecx),%ecx # ecx<- self->method movl %eax,OUT_ARG1(%esp) movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl $$0,OUT_ARG2(%esp) diff --git a/vm/mterp/x86/OP_RETURN.S b/vm/mterp/x86/OP_RETURN.S index 657903de1..082b82e0f 100644 --- a/vm/mterp/x86/OP_RETURN.S +++ b/vm/mterp/x86/OP_RETURN.S @@ -1,12 +1,12 @@ %verify "executed" /* - * Return a 32-bit value. Copies the return value into the "glue" + * Return a 32-bit value. Copies the return value into the "self" * structure, then jumps to the return handler. * * for: return, return-object */ /* op vAA */ - movl rGLUE,%ecx + movl rSELF,%ecx GET_VREG_R %eax rINST # eax<- vAA - movl %eax,offGlue_retval(%ecx) # retval.i <- AA + movl %eax,offThread_retval(%ecx) # retval.i <- AA jmp common_returnFromMethod diff --git a/vm/mterp/x86/OP_RETURN_WIDE.S b/vm/mterp/x86/OP_RETURN_WIDE.S index 049030f2a..c8e7df599 100644 --- a/vm/mterp/x86/OP_RETURN_WIDE.S +++ b/vm/mterp/x86/OP_RETURN_WIDE.S @@ -1,12 +1,12 @@ %verify "executed" /* - * Return a 64-bit value. Copies the return value into the "glue" + * Return a 64-bit value. Copies the return value into the "self" * structure, then jumps to the return handler. */ /* return-wide vAA */ - movl rGLUE,%ecx + movl rSELF,%ecx GET_VREG_WORD %eax rINST 0 # eax<- v[AA+0] GET_VREG_WORD rINST rINST 1 # rINST<- v[AA+1] - movl %eax,offGlue_retval(%ecx) - movl rINST,4+offGlue_retval(%ecx) + movl %eax,offThread_retval(%ecx) + movl rINST,4+offThread_retval(%ecx) jmp common_returnFromMethod diff --git a/vm/mterp/x86/OP_SGET.S b/vm/mterp/x86/OP_SGET.S index 0be038a82..3152cb066 100644 --- a/vm/mterp/x86/OP_SGET.S +++ b/vm/mterp/x86/OP_SGET.S @@ -8,9 +8,9 @@ * for: sget, sget-object, sget-boolean, sget-byte, sget-char, sget-short */ /* op vAA, field@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr testl %eax,%eax # resolved entry null? @@ -27,9 +27,9 @@ * Go resolve the field */ .L${opcode}_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) diff --git a/vm/mterp/x86/OP_SGET_JUMBO.S b/vm/mterp/x86/OP_SGET_JUMBO.S index 07655d29b..a46759a84 100644 --- a/vm/mterp/x86/OP_SGET_JUMBO.S +++ b/vm/mterp/x86/OP_SGET_JUMBO.S @@ -9,8 +9,8 @@ * sget-char/jumbo, sget-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - movl rGLUE,%ecx - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl rSELF,%ecx + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl 2(rPC),%eax # eax<- field ref AAAAAAAA movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr @@ -28,9 +28,9 @@ * Go resolve the field */ .L${opcode}_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%eax # eax<- field ref AAAAAAAA - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) diff --git a/vm/mterp/x86/OP_SGET_WIDE.S b/vm/mterp/x86/OP_SGET_WIDE.S index 54e7f1044..6dac296ff 100644 --- a/vm/mterp/x86/OP_SGET_WIDE.S +++ b/vm/mterp/x86/OP_SGET_WIDE.S @@ -7,9 +7,9 @@ * */ /* sget-wide vAA, field@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr testl %eax,%eax # resolved entry null? @@ -28,9 +28,9 @@ * Go resolve the field */ .L${opcode}_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) diff --git a/vm/mterp/x86/OP_SGET_WIDE_JUMBO.S b/vm/mterp/x86/OP_SGET_WIDE_JUMBO.S index b4af026fe..887ff3d01 100644 --- a/vm/mterp/x86/OP_SGET_WIDE_JUMBO.S +++ b/vm/mterp/x86/OP_SGET_WIDE_JUMBO.S @@ -7,8 +7,8 @@ * */ /* sget-wide/jumbo vBBBB, field@AAAAAAAA */ - movl rGLUE,%ecx - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl rSELF,%ecx + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl 2(rPC),%eax # eax<- field ref AAAAAAAA movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr @@ -28,9 +28,9 @@ * Go resolve the field */ .L${opcode}_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%eax # eax<- field ref AAAAAAAA - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) diff --git a/vm/mterp/x86/OP_SPUT.S b/vm/mterp/x86/OP_SPUT.S index e29383801..7a4296d93 100644 --- a/vm/mterp/x86/OP_SPUT.S +++ b/vm/mterp/x86/OP_SPUT.S @@ -8,9 +8,9 @@ * for: sput, sput-boolean, sput-byte, sput-char, sput-short */ /* op vAA, field@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr testl %eax,%eax # resolved entry null? @@ -27,9 +27,9 @@ * Go resolve the field */ .L${opcode}_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) diff --git a/vm/mterp/x86/OP_SPUT_JUMBO.S b/vm/mterp/x86/OP_SPUT_JUMBO.S index 9b958ff7e..5c10b453a 100644 --- a/vm/mterp/x86/OP_SPUT_JUMBO.S +++ b/vm/mterp/x86/OP_SPUT_JUMBO.S @@ -9,8 +9,8 @@ * sput-short/jumbo */ /* exop vBBBB, field@AAAAAAAA */ - movl rGLUE,%ecx - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl rSELF,%ecx + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl 2(rPC),%eax # eax<- field ref AAAAAAAA movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr @@ -28,9 +28,9 @@ * Go resolve the field */ .L${opcode}_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%eax # eax<- field ref AAAAAAAA - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) diff --git a/vm/mterp/x86/OP_SPUT_OBJECT.S b/vm/mterp/x86/OP_SPUT_OBJECT.S index dbfcd0268..8e325f3c0 100644 --- a/vm/mterp/x86/OP_SPUT_OBJECT.S +++ b/vm/mterp/x86/OP_SPUT_OBJECT.S @@ -6,9 +6,9 @@ * SPUT object handler. */ /* op vAA, field@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField testl %eax,%eax # resolved entry null? @@ -25,9 +25,9 @@ testl %ecx,%ecx # stored null object ptr? FETCH_INST_OPCODE 2 %edx je 1f # skip card mark if null - movl rGLUE,%ecx + movl rSELF,%ecx movl offField_clazz(%eax),%eax # eax<- method->clazz - movl offGlue_cardTable(%ecx),%ecx # get card table base + movl offThread_cardTable(%ecx),%ecx # get card table base shrl $$GC_CARD_SHIFT,%eax # head to card number movb %cl,(%ecx,%eax) # mark card 1: @@ -35,9 +35,9 @@ GOTO_NEXT_R %edx .L${opcode}_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) diff --git a/vm/mterp/x86/OP_SPUT_OBJECT_JUMBO.S b/vm/mterp/x86/OP_SPUT_OBJECT_JUMBO.S index 9860531ad..0ab1b201c 100644 --- a/vm/mterp/x86/OP_SPUT_OBJECT_JUMBO.S +++ b/vm/mterp/x86/OP_SPUT_OBJECT_JUMBO.S @@ -6,9 +6,9 @@ * Jumbo SPUT object handler. */ /* sput-object/jumbo vBBBB, field@AAAAAAAA */ - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%eax # eax<- field ref AAAAAAAA - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField testl %eax,%eax # resolved entry null? @@ -24,9 +24,9 @@ testl %ecx,%ecx # stored null object ptr? FETCH_INST_OPCODE 4 %edx je 1f # skip card mark if null - movl rGLUE,%ecx + movl rSELF,%ecx movl offField_clazz(%eax),%eax # eax<- method->clazz - movl offGlue_cardTable(%ecx),%ecx # get card table base + movl offThread_cardTable(%ecx),%ecx # get card table base shrl $$GC_CARD_SHIFT,%eax # head to card number movb %cl,(%ecx,%eax) # mark card 1: @@ -34,9 +34,9 @@ GOTO_NEXT_R %edx .L${opcode}_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%eax # eax<- field ref AAAAAAAA - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) diff --git a/vm/mterp/x86/OP_SPUT_WIDE.S b/vm/mterp/x86/OP_SPUT_WIDE.S index 43d5509e6..6855911ed 100644 --- a/vm/mterp/x86/OP_SPUT_WIDE.S +++ b/vm/mterp/x86/OP_SPUT_WIDE.S @@ -8,9 +8,9 @@ * for: sput, sput-object, sput-boolean, sput-byte, sput-char, sput-short */ /* op vAA, field@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr testl %eax,%eax # resolved entry null? @@ -29,9 +29,9 @@ * Go resolve the field */ .L${opcode}_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- field ref BBBB - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) diff --git a/vm/mterp/x86/OP_SPUT_WIDE_JUMBO.S b/vm/mterp/x86/OP_SPUT_WIDE_JUMBO.S index 170f05042..22448d94c 100644 --- a/vm/mterp/x86/OP_SPUT_WIDE_JUMBO.S +++ b/vm/mterp/x86/OP_SPUT_WIDE_JUMBO.S @@ -6,8 +6,8 @@ * Jumbo 64-bit SPUT handler. */ /* sput-wide/jumbo vBBBB, field@AAAAAAAA */ - movl rGLUE,%ecx - movl offGlue_methodClassDex(%ecx),%ecx # ecx<- DvmDex + movl rSELF,%ecx + movl offThread_methodClassDex(%ecx),%ecx # ecx<- DvmDex movl 2(rPC),%eax # eax<- field ref AAAAAAAA movl offDvmDex_pResFields(%ecx),%ecx # ecx<- dvmDex->pResFields movl (%ecx,%eax,4),%eax # eax<- resolved StaticField ptr @@ -27,9 +27,9 @@ * Go resolve the field */ .L${opcode}_resolve: - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%eax # eax<- field ref AAAAAAAA - movl offGlue_method(%ecx),%ecx # ecx<- current method + movl offThread_method(%ecx),%ecx # ecx<- current method EXPORT_PC # could throw, need to export movl offMethod_clazz(%ecx),%ecx # ecx<- method->clazz movl %eax,OUT_ARG1(%esp) diff --git a/vm/mterp/x86/OP_THROW.S b/vm/mterp/x86/OP_THROW.S index 6884f7894..6559a295c 100644 --- a/vm/mterp/x86/OP_THROW.S +++ b/vm/mterp/x86/OP_THROW.S @@ -4,10 +4,9 @@ * Throw an exception object in the current thread. */ /* throw vAA */ - movl rGLUE,%ecx EXPORT_PC GET_VREG_R %eax rINST # eax<- exception object - movl offGlue_self(%ecx),%ecx # ecx<- glue->self + movl rSELF,%ecx # ecx<- self testl %eax,%eax # null object? je common_errNullObject movl %eax,offThread_exception(%ecx) # thread->exception<- obj diff --git a/vm/mterp/x86/OP_THROW_VERIFICATION_ERROR.S b/vm/mterp/x86/OP_THROW_VERIFICATION_ERROR.S index c32e2d7e0..c934bdba9 100644 --- a/vm/mterp/x86/OP_THROW_VERIFICATION_ERROR.S +++ b/vm/mterp/x86/OP_THROW_VERIFICATION_ERROR.S @@ -5,9 +5,9 @@ * exception is indicated by AA, with some detail provided by BBBB. */ /* op AA, ref@BBBB */ - movl rGLUE,%ecx + movl rSELF,%ecx movzwl 2(rPC),%eax # eax<- BBBB - movl offGlue_method(%ecx),%ecx # ecx<- glue->method + movl offThread_method(%ecx),%ecx # ecx<- self->method EXPORT_PC movl %eax,OUT_ARG2(%esp) # arg2<- BBBB movl rINST,OUT_ARG1(%esp) # arg1<- AA diff --git a/vm/mterp/x86/OP_THROW_VERIFICATION_ERROR_JUMBO.S b/vm/mterp/x86/OP_THROW_VERIFICATION_ERROR_JUMBO.S index b89d3c12e..a9e092d29 100644 --- a/vm/mterp/x86/OP_THROW_VERIFICATION_ERROR_JUMBO.S +++ b/vm/mterp/x86/OP_THROW_VERIFICATION_ERROR_JUMBO.S @@ -5,9 +5,9 @@ * exception is indicated by BBBB, with some detail provided by AAAAAAAA. */ /* exop BBBB, ref@AAAAAAAA */ - movl rGLUE,%ecx + movl rSELF,%ecx movl 2(rPC),%eax # eax<- AAAAAAAA - movl offGlue_method(%ecx),%ecx # ecx<- glue->method + movl offThread_method(%ecx),%ecx # ecx<- self->method EXPORT_PC movl %eax,OUT_ARG2(%esp) # arg2<- AAAAAAAA movl rINST,OUT_ARG1(%esp) # arg1<- BBBB diff --git a/vm/mterp/x86/entry.S b/vm/mterp/x86/entry.S index 69f2ae5ce..5a3aeecb6 100644 --- a/vm/mterp/x86/entry.S +++ b/vm/mterp/x86/entry.S @@ -19,15 +19,15 @@ .global dvmMterpStdRun .type dvmMterpStdRun, %function /* - * bool dvmMterpStdRun(MterpGlue* glue) + * bool dvmMterpStdRun(Thread* self) * * Interpreter entry point. Returns changeInterp. * */ dvmMterpStdRun: - movl 4(%esp), %ecx # get incoming rGLUE + movl 4(%esp), %ecx # get incoming rSELF push %ebp # save caller base pointer - push %ecx # save rGLUE at (%ebp) + push %ecx # save rSELF at (%ebp) movl %esp, %ebp # set our %ebp /* * At this point we've allocated two slots on the stack @@ -43,14 +43,14 @@ dvmMterpStdRun: movl %ebx,EBX_SPILL(%ebp) /* Set up "named" registers */ - movl offGlue_pc(%ecx),rPC - movl offGlue_fp(%ecx),rFP + movl offThread_pc(%ecx),rPC + movl offThread_fp(%ecx),rFP /* Remember %esp for future "longjmp" */ - movl %esp,offGlue_bailPtr(%ecx) + movl %esp,offThread_bailPtr(%ecx) /* How to start? */ - movb offGlue_entryPoint(%ecx),%al + movb offThread_entryPoint(%ecx),%al /* Normal start? */ cmpb $$kInterpEntryInstr,%al @@ -62,7 +62,7 @@ dvmMterpStdRun: .Lnot_instr: /* Reset to normal case */ - movb $$kInterpEntryInstr,offGlue_entryPoint(%ecx) + movb $$kInterpEntryInstr,offThread_entryPoint(%ecx) cmpb $$kInterpEntryReturn,%al je common_returnFromMethod cmpb $$kInterpEntryThrow,%al @@ -78,7 +78,7 @@ dvmMterpStdRun: .global dvmMterpStdBail .type dvmMterpStdBail, %function /* - * void dvmMterpStdBail(MterpGlue* glue, bool changeInterp) + * void dvmMterpStdBail(Thread* self, bool changeInterp) * * Restore the stack pointer and PC from the save point established on entry. * This is essentially the same as a longjmp, but should be cheaper. The @@ -88,13 +88,13 @@ dvmMterpStdRun: * look a little strange. * * On entry: - * esp+4 (arg0) MterpGlue* glue + * esp+4 (arg0) Thread* self * esp+8 (arg1) bool changeInterp */ dvmMterpStdBail: - movl 4(%esp),%ecx # grab glue + movl 4(%esp),%ecx # grab self movl 8(%esp),%eax # changeInterp to return reg - movl offGlue_bailPtr(%ecx),%esp # Restore "setjmp" esp + movl offThread_bailPtr(%ecx),%esp # Restore "setjmp" esp movl %esp,%ebp addl $$(FRAME_SIZE-8), %ebp # Restore %ebp at point of setjmp movl EDI_SPILL(%ebp),%edi diff --git a/vm/mterp/x86/footer.S b/vm/mterp/x86/footer.S index 053871a77..87ed7cdbd 100644 --- a/vm/mterp/x86/footer.S +++ b/vm/mterp/x86/footer.S @@ -53,11 +53,11 @@ dvmJitToInterpPunt: */ dvmJitToInterpSingleStep: pop %eax - movl rGLUE, %ecx + movl rSELF, %ecx movl OUT_ARG0(%esp), %edx - movl %eax,offGlue_jitResumeNPC(%ecx) - movl %edx,offGlue_jitResumeDPC(%ecx) - movl $$kInterpEntryInstr,offGlue_entryPoint(%ecx) + movl %eax,offThread_jitResumeNPC(%ecx) + movl %edx,offThread_jitResumeDPC(%ecx) + movl $$kInterpEntryInstr,offThread_entryPoint(%ecx) movl $$1,rINST # changeInterp <= true jmp common_gotoBail @@ -73,8 +73,7 @@ dvmJitToInterpNoChainNoProfile: #endif movl rPC,OUT_ARG0(%esp) call dvmJitGetTraceAddr # is there a translation? - movl rGLUE,%ecx - movl offGlue_self(%ecx), %ecx # ecx <- glue->self + movl rSELF,%ecx # ecx <- self movl %eax,offThread_inJitCodeCache(%ecx) # set inJitCodeCache flag cmpl $$0, %eax jz 1f @@ -96,8 +95,7 @@ dvmJitToInterpTraceSelectNoChain: #endif movl rPC,OUT_ARG0(%esp) call dvmJitGetTraceAddr # is there a translation? - movl rGLUE,%ecx - movl offGlue_self(%ecx),%ecx + movl rSELF,%ecx cmpl $$0,%eax movl %eax,offThread_inJitCodeCache(%ecx) # set inJitCodeCache flag jz 1f @@ -157,8 +155,8 @@ toInterpreter: * ebx (a.k.a. rINST) -> PC adjustment in 16-bit words */ common_backwardBranch: - movl rGLUE,%ecx - call common_periodicChecks # rPC and ecx/rGLUE preserved + movl rSELF,%ecx + call common_periodicChecks # rPC and ecx/rSELF preserved #if defined(WITH_JIT) GET_JIT_PROF_TABLE %ecx %edx ADVANCE_PC_INDEXED rINST @@ -184,10 +182,10 @@ common_updateProfile: * is already a native translation in place (and, if so, * jump to it now. */ - GET_JIT_THRESHOLD %ecx rINST + GET_JIT_THRESHOLD %ecx rINST # leaves rSELF in %ecx EXPORT_PC movb rINSTbl,(%edx,%eax) # reset counter - movl offGlue_self(%ecx),rINST + movl %ecx,rINST # preserve rSELF movl rPC,OUT_ARG0(%esp) call dvmJitGetTraceAddr # already have one? movl %eax,offThread_inJitCodeCache(rINST) # set the inJitCodeCache flag @@ -198,9 +196,10 @@ common_updateProfile: movl $$kJitTSelectRequest,%eax # On entry, eax<- jitState, rPC valid common_selectTrace: - movl rGLUE,%ecx - movl %eax,offGlue_jitState(%ecx) - movl $$kInterpEntryInstr,offGlue_entryPoint(%ecx) + + movl rSELF,%ecx + movl %eax,offThread_jitState(%ecx) + movl $$kInterpEntryInstr,offThread_entryPoint(%ecx) movl $$1,rINST jmp common_gotoBail #else @@ -348,11 +347,11 @@ common_invokeMethodNoRange: shl $$2, %edx # %edx<- update offset SAVEAREA_FROM_FP %eax # %eax<- &StackSaveArea subl %edx, %eax # %eax<- newFP; (old savearea - regsSize) - movl rGLUE,%edx # %edx<- pMterpGlue + movl rSELF,%edx # %edx<- pthread movl %eax, LOCAL1_OFFSET(%ebp) # LOCAL1_OFFSET(%ebp)<- &outs subl $$sizeofStackSaveArea, %eax # %eax<- newSaveArea (stack save area using newFP) - movl offGlue_interpStackEnd(%edx), %edx # %edx<- glue->interpStackEnd - movl %edx, LOCAL2_OFFSET(%ebp) # LOCAL2_OFFSET<- glue->interpStackEnd + movl offThread_interpStackEnd(%edx), %edx # %edx<- self->interpStackEnd + movl %edx, LOCAL2_OFFSET(%ebp) # LOCAL2_OFFSET<- self->interpStackEnd shl $$2, %ecx # %ecx<- update offset for outsSize movl %eax, %edx # %edx<- newSaveArea sub %ecx, %eax # %eax<- bottom; (newSaveArea - outsSize) @@ -375,19 +374,18 @@ common_invokeMethodNoRange: jne .LinvokeNative # handle native call /* - * Update "glue" values for the new method + * Update "self" values for the new method * %eax=methodToCall, LOCAL1_OFFSET(%ebp)=newFp */ movl offMethod_clazz(%eax), %edx # %edx<- method->clazz - movl rGLUE,%ecx # %ecx<- pMterpGlue + movl rSELF,%ecx # %ecx<- pthread movl offClassObject_pDvmDex(%edx), %edx # %edx<- method->clazz->pDvmDex - movl %eax, offGlue_method(%ecx) # glue->method<- methodToCall - movl %edx, offGlue_methodClassDex(%ecx) # glue->methodClassDex<- method->clazz->pDvmDex + movl %eax, offThread_method(%ecx) # self->method<- methodToCall + movl %edx, offThread_methodClassDex(%ecx) # self->methodClassDex<- method->clazz->pDvmDex movl offMethod_insns(%eax), rPC # rPC<- methodToCall->insns - movl offGlue_self(%ecx), %eax # %eax<- glue->self movl LOCAL1_OFFSET(%ebp), rFP # rFP<- newFP - movl rFP, offThread_curFrame(%eax) # glue->self->curFrame<- newFP + movl rFP, offThread_curFrame(%ecx) # self->curFrame<- newFP FETCH_INST GOTO_NEXT # jump to methodToCall->insns @@ -397,29 +395,28 @@ common_invokeMethodNoRange: */ .LinvokeNative: - movl rGLUE,%ecx # %ecx<- pMterpGlue + movl rSELF,%ecx # %ecx<- pthread movl %eax, OUT_ARG1(%esp) # push parameter methodToCall - movl offGlue_self(%ecx), %ecx # %ecx<- glue->self movl offThread_jniLocal_topCookie(%ecx), %eax # %eax<- self->localRef->... movl %eax, offStackSaveArea_localRefCookie(%edx) # newSaveArea->localRefCookie<- top movl %edx, OUT_ARG4(%esp) # save newSaveArea movl LOCAL1_OFFSET(%ebp), %edx # %edx<- newFP - movl %edx, offThread_curFrame(%ecx) # glue->self->curFrame<- newFP - movl %ecx, OUT_ARG3(%esp) # save glue->self - movl %ecx, OUT_ARG2(%esp) # push parameter glue->self - movl rGLUE,%ecx # %ecx<- pMterpGlue + movl %edx, offThread_curFrame(%ecx) # self->self->curFrame<- newFP + movl %ecx, OUT_ARG3(%esp) # save self->self + movl %ecx, OUT_ARG2(%esp) # push parameter self->self + movl rSELF,%ecx # %ecx<- pthread movl OUT_ARG1(%esp), %eax # %eax<- methodToCall - lea offGlue_retval(%ecx), %ecx # %ecx<- &retval - movl %ecx, OUT_ARG0(%esp) # push parameter pMterpGlue + lea offThread_retval(%ecx), %ecx # %ecx<- &retval + movl %ecx, OUT_ARG0(%esp) # push parameter pthread push %edx # push parameter newFP call *offMethod_nativeFunc(%eax) # call methodToCall->nativeFunc lea 4(%esp), %esp movl OUT_ARG4(%esp), %ecx # %ecx<- newSaveArea - movl OUT_ARG3(%esp), %eax # %eax<- glue->self + movl OUT_ARG3(%esp), %eax # %eax<- self->self movl offStackSaveArea_localRefCookie(%ecx), %edx # %edx<- old top cmp $$0, offThread_exception(%eax) # check for exception - movl rFP, offThread_curFrame(%eax) # glue->self->curFrame<- rFP + movl rFP, offThread_curFrame(%eax) # self->self->curFrame<- rFP movl %edx, offThread_jniLocal_topCookie(%eax) # new top <- old top jne common_exceptionThrown # handle exception FETCH_INST_OPCODE 3 %edx @@ -428,8 +425,7 @@ common_invokeMethodNoRange: .LstackOverflow: # eax=methodToCall movl %eax, OUT_ARG1(%esp) # push parameter methodToCall - movl rGLUE,%eax # %eax<- pMterpGlue - movl offGlue_self(%eax), %eax # %eax<- glue->self + movl rSELF,%eax # %eax<- self movl %eax, OUT_ARG0(%esp) # push parameter self call dvmHandleStackOverflow # call: (Thread* self, Method* meth) jmp common_exceptionThrown # handle exception @@ -440,8 +436,8 @@ common_invokeMethodNoRange: * * On entry: * ebx -> PC adjustment in 16-bit words (must be preserved) - * ecx -> GLUE pointer - * reentry type, e.g. kInterpEntryInstr stored in rGLUE->entryPoint + * ecx -> SELF pointer + * reentry type, e.g. kInterpEntryInstr stored in rSELF->entryPoint * * Note: A call will normally kill %eax and %ecx. To * streamline the normal case, this routine will preserve @@ -452,12 +448,11 @@ common_invokeMethodNoRange: * TUNING: Improve scheduling here & do initial single test for all. */ common_periodicChecks: - movl offGlue_pSelfSuspendCount(%ecx),%eax # eax <- &suspendCount - cmpl $$0,(%eax) + cmpl $$0,offThread_suspendCount(%ecx) # non-zero suspendCount? jne 1f 6: - movl offGlue_pInterpBreak(%ecx),%eax # eax <- &interpBreak + movl offThread_pInterpBreak(%ecx),%eax # eax <- &interpBreak cmpl $$0,(%eax) # something interesting happening? jne 3f # yes - switch interpreters ret @@ -466,13 +461,13 @@ common_periodicChecks: 1: /* At this point, the return pointer to the caller of * common_periodicChecks is on the top of stack. We need to preserve - * GLUE(ecx). + * SELF(ecx). * The outgoing profile is: * bool dvmCheckSuspendPending(Thread* self) * Because we reached here via a call, go ahead and build a new frame. */ EXPORT_PC # need for precise GC - movl offGlue_self(%ecx),%eax # eax<- glue->self + movl %ecx,%eax # eax<- self push %ebp movl %esp,%ebp subl $$24,%esp @@ -480,7 +475,7 @@ common_periodicChecks: call dvmCheckSuspendPending addl $$24,%esp pop %ebp - movl rGLUE,%ecx + movl rSELF,%ecx /* * Need to check to see if debugger or profiler flags got set @@ -500,7 +495,7 @@ common_periodicChecks: */ 3: leal (rPC,%ebx,2),rPC # adjust pc to show target - movl rGLUE,%ecx # bail expect GLUE already loaded + movl rSELF,%ecx # bail expect SELF already loaded movl $$1,rINST # set changeInterp to true jmp common_gotoBail @@ -509,9 +504,9 @@ common_periodicChecks: * Common code for handling a return instruction */ common_returnFromMethod: - movl rGLUE,%ecx + movl rSELF,%ecx /* Set entry mode in case we bail */ - movb $$kInterpEntryReturn,offGlue_entryPoint(%ecx) + movb $$kInterpEntryReturn,offThread_entryPoint(%ecx) xorl rINST,rINST # zero offset in case we switch interps call common_periodicChecks # Note: expects %ecx to be preserved @@ -522,16 +517,15 @@ common_returnFromMethod: je common_gotoBail # break frame, bail out completely movl offStackSaveArea_savedPc(%eax),rPC # pc<- saveArea->savedPC - movl offGlue_self(%ecx),%eax # eax<- self - movl rINST,offGlue_method(%ecx) # glue->method = newSave->meethod - movl rFP,offThread_curFrame(%eax) # self->curFrame = fp + movl rINST,offThread_method(%ecx) # self->method = newSave->meethod + movl rFP,offThread_curFrame(%ecx) # self->curFrame = fp movl offMethod_clazz(rINST),%eax # eax<- method->clazz FETCH_INST_OPCODE 3 %edx movl offClassObject_pDvmDex(%eax),%eax # eax<- method->clazz->pDvmDex ADVANCE_PC 3 - movl %eax,offGlue_methodClassDex(%ecx) + movl %eax,offThread_methodClassDex(%ecx) /* not bailing - restore entry mode to default */ - movb $$kInterpEntryInstr,offGlue_entryPoint(%ecx) + movb $$kInterpEntryInstr,offThread_entryPoint(%ecx) GOTO_NEXT_R %edx /* @@ -540,24 +534,24 @@ common_returnFromMethod: * * on entry: * rINST holds changeInterp - * ecx holds glue pointer + * ecx holds self pointer * - * expected profile: dvmMterpStdBail(MterpGlue *glue, bool changeInterp) + * expected profile: dvmMterpStdBail(Thread *self, bool changeInterp) */ common_gotoBail: - movl rPC,offGlue_pc(%ecx) # export state to glue - movl rFP,offGlue_fp(%ecx) - movl %ecx,OUT_ARG0(%esp) # glue in arg0 + movl rPC,offThread_pc(%ecx) # export state to self + movl rFP,offThread_fp(%ecx) + movl %ecx,OUT_ARG0(%esp) # self in arg0 movl rINST,OUT_ARG1(%esp) # changeInterp in arg1 call dvmMterpStdBail # bail out.... /* - * After returning from a "glued" function, pull out the updated values + * After returning from a "selfd" function, pull out the updated values * and start executing at the next instruction. */ common_resumeAfterGlueCall: - LOAD_PC_FP_FROM_GLUE + LOAD_PC_FP_FROM_SELF FETCH_INST GOTO_NEXT @@ -635,9 +629,9 @@ common_errArrayIndex: * This does not return. */ common_exceptionThrown: - movl rGLUE,%ecx - movl rPC,offGlue_pc(%ecx) - movl rFP,offGlue_fp(%ecx) + movl rSELF,%ecx + movl rPC,offThread_pc(%ecx) + movl rFP,offThread_fp(%ecx) movl %ecx,OUT_ARG0(%esp) call dvmMterp_exceptionThrown jmp common_resumeAfterGlueCall diff --git a/vm/mterp/x86/header.S b/vm/mterp/x86/header.S index 8b23471ac..b3791b8cd 100644 --- a/vm/mterp/x86/header.S +++ b/vm/mterp/x86/header.S @@ -65,7 +65,7 @@ Notes: */ -#define rGLUE (%ebp) +#define rSELF (%ebp) #define rPC %esi #define rFP %edi #define rINST %ebx @@ -78,7 +78,7 @@ Notes: #define IN_ARG0 ( 12) #define CALLER_RP ( 8) #define PREV_FP ( 4) -#define rGLUE_SPILL ( 0) /* <- dvmMterpStdRun ebp */ +#define rSELF_SPILL ( 0) /* <- dvmMterpStdRun ebp */ /* Spill offsets relative to %ebp */ #define EDI_SPILL ( -4) #define ESI_SPILL ( -8) @@ -111,25 +111,25 @@ Notes: #define UNSPILL_TMP3(reg) movl TMP_SPILL3(%ebp),reg #if defined(WITH_JIT) -.macro GET_JIT_PROF_TABLE _glue _reg - movl offGlue_pJitProfTable(\_glue),\_reg +.macro GET_JIT_PROF_TABLE _self _reg + movl offThread_pJitProfTable(\_self),\_reg .endm -.macro GET_JIT_THRESHOLD _glue _reg - movl offGlue_jitThreshold(\_glue),\_reg +.macro GET_JIT_THRESHOLD _self _reg + movl offThread_jitThreshold(\_self),\_reg .endm #endif -/* save/restore the PC and/or FP from the glue struct */ -.macro SAVE_PC_FP_TO_GLUE _reg - movl rGLUE,\_reg - movl rPC,offGlue_pc(\_reg) - movl rFP,offGlue_fp(\_reg) +/* save/restore the PC and/or FP from the self struct */ +.macro SAVE_PC_FP_TO_SELF _reg + movl rSELF,\_reg + movl rPC,offThread_pc(\_reg) + movl rFP,offThread_fp(\_reg) .endm -.macro LOAD_PC_FP_FROM_GLUE - movl rGLUE,rFP - movl offGlue_pc(rFP),rPC - movl offGlue_fp(rFP),rFP +.macro LOAD_PC_FP_FROM_SELF + movl rSELF,rFP + movl offThread_pc(rFP),rPC + movl offThread_fp(rFP),rFP .endm /* The interpreter assumes a properly aligned stack on entry, and diff --git a/vm/mterp/x86/stub.S b/vm/mterp/x86/stub.S index 886bdf778..9799bed2d 100644 --- a/vm/mterp/x86/stub.S +++ b/vm/mterp/x86/stub.S @@ -1,8 +1,8 @@ /* (stub) */ - SAVE_PC_FP_TO_GLUE %ecx # leaves rGLUE in %ecx - movl %ecx,OUT_ARG0(%esp) # glue is first arg to function + SAVE_PC_FP_TO_SELF %ecx # leaves rSELF in %ecx + movl %ecx,OUT_ARG0(%esp) # self is first arg to function call dvmMterp_${opcode} # do the real work - mov rGLUE,%ecx - LOAD_PC_FP_FROM_GLUE # retrieve updated values + mov rSELF,%ecx + LOAD_PC_FP_FROM_SELF # retrieve updated values FETCH_INST GOTO_NEXT -- cgit v1.2.3