Blame - vm/mterp/out/InterpC-allstubs.cpp - fp2-dev/platform/dalvik

blob: 7859c2d5200ab742d45968731741eeefabf4496e [file] [log] [blame]

Carl Shapiro	cd8f5e7	2011-04-20 16:12:46 -0700	[diff] [blame^]	1	/*
				2	* This file was generated automatically by gen-mterp.py for 'allstubs'.
				3	*
				4	* --> DO NOT EDIT <--
				5	*/
				6
				7	/* File: c/header.cpp */
				8	/*
				9	* Copyright (C) 2008 The Android Open Source Project
				10	*
				11	* Licensed under the Apache License, Version 2.0 (the "License");
				12	* you may not use this file except in compliance with the License.
				13	* You may obtain a copy of the License at
				14	*
				15	* http://www.apache.org/licenses/LICENSE-2.0
				16	*
				17	* Unless required by applicable law or agreed to in writing, software
				18	* distributed under the License is distributed on an "AS IS" BASIS,
				19	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
				20	* See the License for the specific language governing permissions and
				21	* limitations under the License.
				22	*/
				23
				24	/* common includes */
				25	#include "Dalvik.h"
				26	#include "interp/InterpDefs.h"
				27	#include "mterp/Mterp.h"
				28	#include <math.h> // needed for fmod, fmodf
				29	#include "mterp/common/FindInterface.h"
				30
				31	/*
				32	* Configuration defines. These affect the C implementations, i.e. the
				33	* portable interpreter(s) and C stubs.
				34	*
				35	* Some defines are controlled by the Makefile, e.g.:
				36	* WITH_INSTR_CHECKS
				37	* WITH_TRACKREF_CHECKS
				38	* EASY_GDB
				39	* NDEBUG
				40	*/
				41
				42	#ifdef WITH_INSTR_CHECKS /* instruction-level paranoia (slow!) */
				43	# define CHECK_BRANCH_OFFSETS
				44	# define CHECK_REGISTER_INDICES
				45	#endif
				46
				47	/*
				48	* Some architectures require 64-bit alignment for access to 64-bit data
				49	* types. We can't just use pointers to copy 64-bit values out of our
				50	* interpreted register set, because gcc may assume the pointer target is
				51	* aligned and generate invalid code.
				52	*
				53	* There are two common approaches:
				54	* (1) Use a union that defines a 32-bit pair and a 64-bit value.
				55	* (2) Call memcpy().
				56	*
				57	* Depending upon what compiler you're using and what options are specified,
				58	* one may be faster than the other. For example, the compiler might
				59	* convert a memcpy() of 8 bytes into a series of instructions and omit
				60	* the call. The union version could cause some strange side-effects,
				61	* e.g. for a while ARM gcc thought it needed separate storage for each
				62	* inlined instance, and generated instructions to zero out ~700 bytes of
				63	* stack space at the top of the interpreter.
				64	*
				65	* The default is to use memcpy(). The current gcc for ARM seems to do
				66	* better with the union.
				67	*/
				68	#if defined(__ARM_EABI__)
				69	# define NO_UNALIGN_64__UNION
				70	#endif
				71
				72
				73	//#define LOG_INSTR /* verbose debugging */
				74	/* set and adjust ANDROID_LOG_TAGS=':i jdwp:i dalvikvm:i dalvikvmi:i' /
				75
				76	/*
				77	* Keep a tally of accesses to fields. Currently only works if full DEX
				78	* optimization is disabled.
				79	*/
				80	#ifdef PROFILE_FIELD_ACCESS
				81	# define UPDATE_FIELD_GET(_field) { (_field)->gets++; }
				82	# define UPDATE_FIELD_PUT(_field) { (_field)->puts++; }
				83	#else
				84	# define UPDATE_FIELD_GET(_field) ((void)0)
				85	# define UPDATE_FIELD_PUT(_field) ((void)0)
				86	#endif
				87
				88	/*
				89	* Export another copy of the PC on every instruction; this is largely
				90	* redundant with EXPORT_PC and the debugger code. This value can be
				91	* compared against what we have stored on the stack with EXPORT_PC to
				92	* help ensure that we aren't missing any export calls.
				93	*/
				94	#if WITH_EXTRA_GC_CHECKS > 1
				95	# define EXPORT_EXTRA_PC() (self->currentPc2 = pc)
				96	#else
				97	# define EXPORT_EXTRA_PC()
				98	#endif
				99
				100	/*
				101	* Adjust the program counter. "_offset" is a signed int, in 16-bit units.
				102	*
				103	* Assumes the existence of "const u2* pc" and "const u2* curMethod->insns".
				104	*
				105	* We don't advance the program counter until we finish an instruction or
				106	* branch, because we do want to have to unroll the PC if there's an
				107	* exception.
				108	*/
				109	#ifdef CHECK_BRANCH_OFFSETS
				110	# define ADJUST_PC(_offset) do { \
				111	int myoff = _offset; /* deref only once */ \
				112	if (pc + myoff < curMethod->insns \|\| \
				113	pc + myoff >= curMethod->insns + dvmGetMethodInsnsSize(curMethod)) \
				114	{ \
				115	char* desc; \
				116	desc = dexProtoCopyMethodDescriptor(&curMethod->prototype); \
				117	LOGE("Invalid branch %d at 0x%04x in %s.%s %s\n", \
				118	myoff, (int) (pc - curMethod->insns), \
				119	curMethod->clazz->descriptor, curMethod->name, desc); \
				120	free(desc); \
				121	dvmAbort(); \
				122	} \
				123	pc += myoff; \
				124	EXPORT_EXTRA_PC(); \
				125	} while (false)
				126	#else
				127	# define ADJUST_PC(_offset) do { \
				128	pc += _offset; \
				129	EXPORT_EXTRA_PC(); \
				130	} while (false)
				131	#endif
				132
				133	/*
				134	* If enabled, log instructions as we execute them.
				135	*/
				136	#ifdef LOG_INSTR
				137	# define ILOGD(...) ILOG(LOG_DEBUG, __VA_ARGS__)
				138	# define ILOGV(...) ILOG(LOG_VERBOSE, __VA_ARGS__)
				139	# define ILOG(_level, ...) do { \
				140	char debugStrBuf[128]; \
				141	snprintf(debugStrBuf, sizeof(debugStrBuf), __VA_ARGS__); \
				142	if (curMethod != NULL) \
				143	LOG(_level, LOG_TAG"i", "%-2d\|%04x%s\n", \
				144	self->threadId, (int)(pc - curMethod->insns), debugStrBuf); \
				145	else \
				146	LOG(_level, LOG_TAG"i", "%-2d\|####%s\n", \
				147	self->threadId, debugStrBuf); \
				148	} while(false)
				149	void dvmDumpRegs(const Method* method, const u4* framePtr, bool inOnly);
				150	# define DUMP_REGS(_meth, _frame, _inOnly) dvmDumpRegs(_meth, _frame, _inOnly)
				151	static const char kSpacing[] = " ";
				152	#else
				153	# define ILOGD(...) ((void)0)
				154	# define ILOGV(...) ((void)0)
				155	# define DUMP_REGS(_meth, _frame, _inOnly) ((void)0)
				156	#endif
				157
				158	/* get a long from an array of u4 */
				159	static inline s8 getLongFromArray(const u4* ptr, int idx)
				160	{
				161	#if defined(NO_UNALIGN_64__UNION)
				162	union { s8 ll; u4 parts[2]; } conv;
				163
				164	ptr += idx;
				165	conv.parts[0] = ptr[0];
				166	conv.parts[1] = ptr[1];
				167	return conv.ll;
				168	#else
				169	s8 val;
				170	memcpy(&val, &ptr[idx], 8);
				171	return val;
				172	#endif
				173	}
				174
				175	/* store a long into an array of u4 */
				176	static inline void putLongToArray(u4* ptr, int idx, s8 val)
				177	{
				178	#if defined(NO_UNALIGN_64__UNION)
				179	union { s8 ll; u4 parts[2]; } conv;
				180
				181	ptr += idx;
				182	conv.ll = val;
				183	ptr[0] = conv.parts[0];
				184	ptr[1] = conv.parts[1];
				185	#else
				186	memcpy(&ptr[idx], &val, 8);
				187	#endif
				188	}
				189
				190	/* get a double from an array of u4 */
				191	static inline double getDoubleFromArray(const u4* ptr, int idx)
				192	{
				193	#if defined(NO_UNALIGN_64__UNION)
				194	union { double d; u4 parts[2]; } conv;
				195
				196	ptr += idx;
				197	conv.parts[0] = ptr[0];
				198	conv.parts[1] = ptr[1];
				199	return conv.d;
				200	#else
				201	double dval;
				202	memcpy(&dval, &ptr[idx], 8);
				203	return dval;
				204	#endif
				205	}
				206
				207	/* store a double into an array of u4 */
				208	static inline void putDoubleToArray(u4* ptr, int idx, double dval)
				209	{
				210	#if defined(NO_UNALIGN_64__UNION)
				211	union { double d; u4 parts[2]; } conv;
				212
				213	ptr += idx;
				214	conv.d = dval;
				215	ptr[0] = conv.parts[0];
				216	ptr[1] = conv.parts[1];
				217	#else
				218	memcpy(&ptr[idx], &dval, 8);
				219	#endif
				220	}
				221
				222	/*
				223	* If enabled, validate the register number on every access. Otherwise,
				224	* just do an array access.
				225	*
				226	* Assumes the existence of "u4* fp".
				227	*
				228	* "_idx" may be referenced more than once.
				229	*/
				230	#ifdef CHECK_REGISTER_INDICES
				231	# define GET_REGISTER(_idx) \
				232	( (_idx) < curMethod->registersSize ? \
				233	(fp[(_idx)]) : (assert(!"bad reg"),1969) )
				234	# define SET_REGISTER(_idx, _val) \
				235	( (_idx) < curMethod->registersSize ? \
				236	(fp[(_idx)] = (u4)(_val)) : (assert(!"bad reg"),1969) )
				237	# define GET_REGISTER_AS_OBJECT(_idx) ((Object *)GET_REGISTER(_idx))
				238	# define SET_REGISTER_AS_OBJECT(_idx, _val) SET_REGISTER(_idx, (s4)_val)
				239	# define GET_REGISTER_INT(_idx) ((s4) GET_REGISTER(_idx))
				240	# define SET_REGISTER_INT(_idx, _val) SET_REGISTER(_idx, (s4)_val)
				241	# define GET_REGISTER_WIDE(_idx) \
				242	( (_idx) < curMethod->registersSize-1 ? \
				243	getLongFromArray(fp, (_idx)) : (assert(!"bad reg"),1969) )
				244	# define SET_REGISTER_WIDE(_idx, _val) \
				245	( (_idx) < curMethod->registersSize-1 ? \
				246	putLongToArray(fp, (_idx), (_val)) : (assert(!"bad reg"),1969) )
				247	# define GET_REGISTER_FLOAT(_idx) \
				248	( (_idx) < curMethod->registersSize ? \
				249	(((float) &fp[(_idx)])) : (assert(!"bad reg"),1969.0f) )
				250	# define SET_REGISTER_FLOAT(_idx, _val) \
				251	( (_idx) < curMethod->registersSize ? \
				252	(((float) &fp[(_idx)]) = (_val)) : (assert(!"bad reg"),1969.0f) )
				253	# define GET_REGISTER_DOUBLE(_idx) \
				254	( (_idx) < curMethod->registersSize-1 ? \
				255	getDoubleFromArray(fp, (_idx)) : (assert(!"bad reg"),1969.0) )
				256	# define SET_REGISTER_DOUBLE(_idx, _val) \
				257	( (_idx) < curMethod->registersSize-1 ? \
				258	putDoubleToArray(fp, (_idx), (_val)) : (assert(!"bad reg"),1969.0) )
				259	#else
				260	# define GET_REGISTER(_idx) (fp[(_idx)])
				261	# define SET_REGISTER(_idx, _val) (fp[(_idx)] = (_val))
				262	# define GET_REGISTER_AS_OBJECT(_idx) ((Object*) fp[(_idx)])
				263	# define SET_REGISTER_AS_OBJECT(_idx, _val) (fp[(_idx)] = (u4)(_val))
				264	# define GET_REGISTER_INT(_idx) ((s4)GET_REGISTER(_idx))
				265	# define SET_REGISTER_INT(_idx, _val) SET_REGISTER(_idx, (s4)_val)
				266	# define GET_REGISTER_WIDE(_idx) getLongFromArray(fp, (_idx))
				267	# define SET_REGISTER_WIDE(_idx, _val) putLongToArray(fp, (_idx), (_val))
				268	# define GET_REGISTER_FLOAT(_idx) (((float) &fp[(_idx)]))
				269	# define SET_REGISTER_FLOAT(_idx, _val) (((float) &fp[(_idx)]) = (_val))
				270	# define GET_REGISTER_DOUBLE(_idx) getDoubleFromArray(fp, (_idx))
				271	# define SET_REGISTER_DOUBLE(_idx, _val) putDoubleToArray(fp, (_idx), (_val))
				272	#endif
				273
				274	/*
				275	* Get 16 bits from the specified offset of the program counter. We always
				276	* want to load 16 bits at a time from the instruction stream -- it's more
				277	* efficient than 8 and won't have the alignment problems that 32 might.
				278	*
				279	* Assumes existence of "const u2* pc".
				280	*/
				281	#define FETCH(_offset) (pc[(_offset)])
				282
				283	/*
				284	* Extract instruction byte from 16-bit fetch (_inst is a u2).
				285	*/
				286	#define INST_INST(_inst) ((_inst) & 0xff)
				287
				288	/*
				289	* Replace the opcode (used when handling breakpoints). _opcode is a u1.
				290	*/
				291	#define INST_REPLACE_OP(_inst, _opcode) (((_inst) & 0xff00) \| _opcode)
				292
				293	/*
				294	* Extract the "vA, vB" 4-bit registers from the instruction word (_inst is u2).
				295	*/
				296	#define INST_A(_inst) (((_inst) >> 8) & 0x0f)
				297	#define INST_B(_inst) ((_inst) >> 12)
				298
				299	/*
				300	* Get the 8-bit "vAA" 8-bit register index from the instruction word.
				301	* (_inst is u2)
				302	*/
				303	#define INST_AA(_inst) ((_inst) >> 8)
				304
				305	/*
				306	* The current PC must be available to Throwable constructors, e.g.
				307	* those created by the various exception throw routines, so that the
				308	* exception stack trace can be generated correctly. If we don't do this,
				309	* the offset within the current method won't be shown correctly. See the
				310	* notes in Exception.c.
				311	*
				312	* This is also used to determine the address for precise GC.
				313	*
				314	* Assumes existence of "u4* fp" and "const u2* pc".
				315	*/
				316	#define EXPORT_PC() (SAVEAREA_FROM_FP(fp)->xtra.currentPc = pc)
				317
				318	/*
				319	* Check to see if "obj" is NULL. If so, throw an exception. Assumes the
				320	* pc has already been exported to the stack.
				321	*
				322	* Perform additional checks on debug builds.
				323	*
				324	* Use this to check for NULL when the instruction handler calls into
				325	* something that could throw an exception (so we have already called
				326	* EXPORT_PC at the top).
				327	*/
				328	static inline bool checkForNull(Object* obj)
				329	{
				330	if (obj == NULL) {
				331	dvmThrowNullPointerException(NULL);
				332	return false;
				333	}
				334	#ifdef WITH_EXTRA_OBJECT_VALIDATION
				335	if (!dvmIsValidObject(obj)) {
				336	LOGE("Invalid object %p\n", obj);
				337	dvmAbort();
				338	}
				339	#endif
				340	#ifndef NDEBUG
				341	if (obj->clazz == NULL \|\| ((u4) obj->clazz) <= 65536) {
				342	/* probable heap corruption */
				343	LOGE("Invalid object class %p (in %p)\n", obj->clazz, obj);
				344	dvmAbort();
				345	}
				346	#endif
				347	return true;
				348	}
				349
				350	/*
				351	* Check to see if "obj" is NULL. If so, export the PC into the stack
				352	* frame and throw an exception.
				353	*
				354	* Perform additional checks on debug builds.
				355	*
				356	* Use this to check for NULL when the instruction handler doesn't do
				357	* anything else that can throw an exception.
				358	*/
				359	static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc)
				360	{
				361	if (obj == NULL) {
				362	EXPORT_PC();
				363	dvmThrowNullPointerException(NULL);
				364	return false;
				365	}
				366	#ifdef WITH_EXTRA_OBJECT_VALIDATION
				367	if (!dvmIsValidObject(obj)) {
				368	LOGE("Invalid object %p\n", obj);
				369	dvmAbort();
				370	}
				371	#endif
				372	#ifndef NDEBUG
				373	if (obj->clazz == NULL \|\| ((u4) obj->clazz) <= 65536) {
				374	/* probable heap corruption */
				375	LOGE("Invalid object class %p (in %p)\n", obj->clazz, obj);
				376	dvmAbort();
				377	}
				378	#endif
				379	return true;
				380	}
				381
				382	/* File: cstubs/stubdefs.cpp */
				383	/*
				384	* In the C mterp stubs, "goto" is a function call followed immediately
				385	* by a return.
				386	*/
				387
				388	#define GOTO_TARGET_DECL(_target, ...) \
				389	extern "C" void dvmMterp_##_target(Thread* self, ## __VA_ARGS__);
				390
				391	/* (void)xxx to quiet unused variable compiler warnings. */
				392	#define GOTO_TARGET(_target, ...) \
				393	void dvmMterp_##_target(Thread* self, ## __VA_ARGS__) { \
				394	u2 ref, vsrc1, vsrc2, vdst; \
				395	u2 inst = FETCH(0); \
				396	const Method* methodToCall; \
				397	StackSaveArea* debugSaveArea; \
				398	(void)ref; (void)vsrc1; (void)vsrc2; (void)vdst; (void)inst; \
				399	(void)methodToCall; (void)debugSaveArea;
				400
				401	#define GOTO_TARGET_END }
				402
				403	/*
				404	* Redefine what used to be local variable accesses into Thread struct
				405	* references. (These are undefined down in "footer.c".)
				406	*/
				407	#define retval self->retval
				408	#define pc self->interpSave.pc
				409	#define fp self->interpSave.fp
				410	#define curMethod self->interpSave.method
				411	#define methodClassDex self->interpSave.methodClassDex
				412	#define debugTrackedRefStart self->interpSave.debugTrackedRefStart
				413
				414	/* ugh */
				415	#define STUB_HACK(x) x
				416	#if defined(WITH_JIT)
				417	#define JIT_STUB_HACK(x) x
				418	#else
				419	#define JIT_STUB_HACK(x)
				420	#endif
				421
				422	/*
				423	* InterpSave's pc and fp must be valid when breaking out to a
				424	* "Reportxxx" routine. Because the portable interpreter uses local
				425	* variables for these, we must flush prior. Stubs, however, use
				426	* the interpSave vars directly, so this is a nop for stubs.
				427	*/
				428	#define PC_FP_TO_SELF()
				429
				430	/*
				431	* Opcode handler framing macros. Here, each opcode is a separate function
				432	* that takes a "self" argument and returns void. We can't declare
				433	* these "static" because they may be called from an assembly stub.
				434	* (void)xxx to quiet unused variable compiler warnings.
				435	*/
				436	#define HANDLE_OPCODE(_op) \
				437	extern "C" void dvmMterp_##_op(Thread* self); \
				438	void dvmMterp_##_op(Thread* self) { \
				439	u4 ref; \
				440	u2 vsrc1, vsrc2, vdst; \
				441	u2 inst = FETCH(0); \
				442	(void)ref; (void)vsrc1; (void)vsrc2; (void)vdst; (void)inst;
				443
				444	#define OP_END }
				445
				446	/*
				447	* Like the "portable" FINISH, but don't reload "inst", and return to caller
				448	* when done. Further, debugger/profiler checks are handled
				449	* before handler execution in mterp, so we don't do them here either.
				450	*/
				451	#if defined(WITH_JIT)
				452	#define FINISH(_offset) { \
				453	ADJUST_PC(_offset); \
				454	if (self->interpBreak.ctl.subMode & kSubModeJitTraceBuild) { \
				455	dvmCheckJit(pc, self); \
				456	} \
				457	return; \
				458	}
				459	#else
				460	#define FINISH(_offset) { \
				461	ADJUST_PC(_offset); \
				462	return; \
				463	}
				464	#endif
				465
				466
				467	/*
				468	* The "goto label" statements turn into function calls followed by
				469	* return statements. Some of the functions take arguments, which in the
				470	* portable interpreter are handled by assigning values to globals.
				471	*/
				472
				473	#define GOTO_exceptionThrown() \
				474	do { \
				475	dvmMterp_exceptionThrown(self); \
				476	return; \
				477	} while(false)
				478
				479	#define GOTO_returnFromMethod() \
				480	do { \
				481	dvmMterp_returnFromMethod(self); \
				482	return; \
				483	} while(false)
				484
				485	#define GOTO_invoke(_target, _methodCallRange, _jumboFormat) \
				486	do { \
				487	dvmMterp_##_target(self, _methodCallRange, _jumboFormat); \
				488	return; \
				489	} while(false)
				490
				491	#define GOTO_invokeMethod(_methodCallRange, _methodToCall, _vsrc1, _vdst) \
				492	do { \
				493	dvmMterp_invokeMethod(self, _methodCallRange, _methodToCall, \
				494	_vsrc1, _vdst); \
				495	return; \
				496	} while(false)
				497
				498	/*
				499	* As a special case, "goto bail" turns into a longjmp.
				500	*/
				501	#define GOTO_bail() \
				502	dvmMterpStdBail(self, false);
				503
				504	/*
				505	* Periodically check for thread suspension.
				506	*
				507	* While we're at it, see if a debugger has attached or the profiler has
				508	* started.
				509	*/
				510	#define PERIODIC_CHECKS(_pcadj) { \
				511	if (dvmCheckSuspendQuick(self)) { \
				512	EXPORT_PC(); /* need for precise GC */ \
				513	dvmCheckSuspendPending(self); \
				514	} \
				515	}
				516
				517	/* File: c/opcommon.cpp */
				518	/* forward declarations of goto targets */
				519	GOTO_TARGET_DECL(filledNewArray, bool methodCallRange, bool jumboFormat);
				520	GOTO_TARGET_DECL(invokeVirtual, bool methodCallRange, bool jumboFormat);
				521	GOTO_TARGET_DECL(invokeSuper, bool methodCallRange, bool jumboFormat);
				522	GOTO_TARGET_DECL(invokeInterface, bool methodCallRange, bool jumboFormat);
				523	GOTO_TARGET_DECL(invokeDirect, bool methodCallRange, bool jumboFormat);
				524	GOTO_TARGET_DECL(invokeStatic, bool methodCallRange, bool jumboFormat);
				525	GOTO_TARGET_DECL(invokeVirtualQuick, bool methodCallRange, bool jumboFormat);
				526	GOTO_TARGET_DECL(invokeSuperQuick, bool methodCallRange, bool jumboFormat);
				527	GOTO_TARGET_DECL(invokeMethod, bool methodCallRange, const Method* methodToCall,
				528	u2 count, u2 regs);
				529	GOTO_TARGET_DECL(returnFromMethod);
				530	GOTO_TARGET_DECL(exceptionThrown);
				531
				532	/*
				533	* ===========================================================================
				534	*
				535	* What follows are opcode definitions shared between multiple opcodes with
				536	* minor substitutions handled by the C pre-processor. These should probably
				537	* use the mterp substitution mechanism instead, with the code here moved
				538	* into common fragment files (like the asm "binop.S"), although it's hard
				539	* to give up the C preprocessor in favor of the much simpler text subst.
				540	*
				541	* ===========================================================================
				542	*/
				543
				544	#define HANDLE_NUMCONV(_opcode, _opname, _fromtype, _totype) \
				545	HANDLE_OPCODE(_opcode /vA, vB/) \
				546	vdst = INST_A(inst); \
				547	vsrc1 = INST_B(inst); \
				548	ILOGV("\|%s v%d,v%d", (_opname), vdst, vsrc1); \
				549	SET_REGISTER##_totype(vdst, \
				550	GET_REGISTER##_fromtype(vsrc1)); \
				551	FINISH(1);
				552
				553	#define HANDLE_FLOAT_TO_INT(_opcode, _opname, _fromvtype, _fromrtype, \
				554	_tovtype, _tortype) \
				555	HANDLE_OPCODE(_opcode /vA, vB/) \
				556	{ \
				557	/* spec defines specific handling for +/- inf and NaN values */ \
				558	_fromvtype val; \
				559	_tovtype intMin, intMax, result; \
				560	vdst = INST_A(inst); \
				561	vsrc1 = INST_B(inst); \
				562	ILOGV("\|%s v%d,v%d", (_opname), vdst, vsrc1); \
				563	val = GET_REGISTER##_fromrtype(vsrc1); \
				564	intMin = (_tovtype) 1 << (sizeof(_tovtype) * 8 -1); \
				565	intMax = ~intMin; \
				566	result = (_tovtype) val; \
				567	if (val >= intMax) /* +inf */ \
				568	result = intMax; \
				569	else if (val <= intMin) /* -inf */ \
				570	result = intMin; \
				571	else if (val != val) /* NaN */ \
				572	result = 0; \
				573	else \
				574	result = (_tovtype) val; \
				575	SET_REGISTER##_tortype(vdst, result); \
				576	} \
				577	FINISH(1);
				578
				579	#define HANDLE_INT_TO_SMALL(_opcode, _opname, _type) \
				580	HANDLE_OPCODE(_opcode /vA, vB/) \
				581	vdst = INST_A(inst); \
				582	vsrc1 = INST_B(inst); \
				583	ILOGV("\|int-to-%s v%d,v%d", (_opname), vdst, vsrc1); \
				584	SET_REGISTER(vdst, (_type) GET_REGISTER(vsrc1)); \
				585	FINISH(1);
				586
				587	/* NOTE: the comparison result is always a signed 4-byte integer */
				588	#define HANDLE_OP_CMPX(_opcode, _opname, _varType, _type, _nanVal) \
				589	HANDLE_OPCODE(_opcode /vAA, vBB, vCC/) \
				590	{ \
				591	int result; \
				592	u2 regs; \
				593	_varType val1, val2; \
				594	vdst = INST_AA(inst); \
				595	regs = FETCH(1); \
				596	vsrc1 = regs & 0xff; \
				597	vsrc2 = regs >> 8; \
				598	ILOGV("\|cmp%s v%d,v%d,v%d", (_opname), vdst, vsrc1, vsrc2); \
				599	val1 = GET_REGISTER##_type(vsrc1); \
				600	val2 = GET_REGISTER##_type(vsrc2); \
				601	if (val1 == val2) \
				602	result = 0; \
				603	else if (val1 < val2) \
				604	result = -1; \
				605	else if (val1 > val2) \
				606	result = 1; \
				607	else \
				608	result = (_nanVal); \
				609	ILOGV("+ result=%d\n", result); \
				610	SET_REGISTER(vdst, result); \
				611	} \
				612	FINISH(2);
				613
				614	#define HANDLE_OP_IF_XX(_opcode, _opname, _cmp) \
				615	HANDLE_OPCODE(_opcode /vA, vB, +CCCC/) \
				616	vsrc1 = INST_A(inst); \
				617	vsrc2 = INST_B(inst); \
				618	if ((s4) GET_REGISTER(vsrc1) _cmp (s4) GET_REGISTER(vsrc2)) { \
				619	int branchOffset = (s2)FETCH(1); /* sign-extended */ \
				620	ILOGV("\|if-%s v%d,v%d,+0x%04x", (_opname), vsrc1, vsrc2, \
				621	branchOffset); \
				622	ILOGV("> branch taken"); \
				623	if (branchOffset < 0) \
				624	PERIODIC_CHECKS(branchOffset); \
				625	FINISH(branchOffset); \
				626	} else { \
				627	ILOGV("\|if-%s v%d,v%d,-", (_opname), vsrc1, vsrc2); \
				628	FINISH(2); \
				629	}
				630
				631	#define HANDLE_OP_IF_XXZ(_opcode, _opname, _cmp) \
				632	HANDLE_OPCODE(_opcode /vAA, +BBBB/) \
				633	vsrc1 = INST_AA(inst); \
				634	if ((s4) GET_REGISTER(vsrc1) _cmp 0) { \
				635	int branchOffset = (s2)FETCH(1); /* sign-extended */ \
				636	ILOGV("\|if-%s v%d,+0x%04x", (_opname), vsrc1, branchOffset); \
				637	ILOGV("> branch taken"); \
				638	if (branchOffset < 0) \
				639	PERIODIC_CHECKS(branchOffset); \
				640	FINISH(branchOffset); \
				641	} else { \
				642	ILOGV("\|if-%s v%d,-", (_opname), vsrc1); \
				643	FINISH(2); \
				644	}
				645
				646	#define HANDLE_UNOP(_opcode, _opname, _pfx, _sfx, _type) \
				647	HANDLE_OPCODE(_opcode /vA, vB/) \
				648	vdst = INST_A(inst); \
				649	vsrc1 = INST_B(inst); \
				650	ILOGV("\|%s v%d,v%d", (_opname), vdst, vsrc1); \
				651	SET_REGISTER##_type(vdst, _pfx GET_REGISTER##_type(vsrc1) _sfx); \
				652	FINISH(1);
				653
				654	#define HANDLE_OP_X_INT(_opcode, _opname, _op, _chkdiv) \
				655	HANDLE_OPCODE(_opcode /vAA, vBB, vCC/) \
				656	{ \
				657	u2 srcRegs; \
				658	vdst = INST_AA(inst); \
				659	srcRegs = FETCH(1); \
				660	vsrc1 = srcRegs & 0xff; \
				661	vsrc2 = srcRegs >> 8; \
				662	ILOGV("\|%s-int v%d,v%d", (_opname), vdst, vsrc1); \
				663	if (_chkdiv != 0) { \
				664	s4 firstVal, secondVal, result; \
				665	firstVal = GET_REGISTER(vsrc1); \
				666	secondVal = GET_REGISTER(vsrc2); \
				667	if (secondVal == 0) { \
				668	EXPORT_PC(); \
				669	dvmThrowArithmeticException("divide by zero"); \
				670	GOTO_exceptionThrown(); \
				671	} \
				672	if ((u4)firstVal == 0x80000000 && secondVal == -1) { \
				673	if (_chkdiv == 1) \
				674	result = firstVal; /* division */ \
				675	else \
				676	result = 0; /* remainder */ \
				677	} else { \
				678	result = firstVal _op secondVal; \
				679	} \
				680	SET_REGISTER(vdst, result); \
				681	} else { \
				682	/* non-div/rem case */ \
				683	SET_REGISTER(vdst, \
				684	(s4) GET_REGISTER(vsrc1) _op (s4) GET_REGISTER(vsrc2)); \
				685	} \
				686	} \
				687	FINISH(2);
				688
				689	#define HANDLE_OP_SHX_INT(_opcode, _opname, _cast, _op) \
				690	HANDLE_OPCODE(_opcode /vAA, vBB, vCC/) \
				691	{ \
				692	u2 srcRegs; \
				693	vdst = INST_AA(inst); \
				694	srcRegs = FETCH(1); \
				695	vsrc1 = srcRegs & 0xff; \
				696	vsrc2 = srcRegs >> 8; \
				697	ILOGV("\|%s-int v%d,v%d", (_opname), vdst, vsrc1); \
				698	SET_REGISTER(vdst, \
				699	_cast GET_REGISTER(vsrc1) _op (GET_REGISTER(vsrc2) & 0x1f)); \
				700	} \
				701	FINISH(2);
				702
				703	#define HANDLE_OP_X_INT_LIT16(_opcode, _opname, _op, _chkdiv) \
				704	HANDLE_OPCODE(_opcode /vA, vB, #+CCCC/) \
				705	vdst = INST_A(inst); \
				706	vsrc1 = INST_B(inst); \
				707	vsrc2 = FETCH(1); \
				708	ILOGV("\|%s-int/lit16 v%d,v%d,#+0x%04x", \
				709	(_opname), vdst, vsrc1, vsrc2); \
				710	if (_chkdiv != 0) { \
				711	s4 firstVal, result; \
				712	firstVal = GET_REGISTER(vsrc1); \
				713	if ((s2) vsrc2 == 0) { \
				714	EXPORT_PC(); \
				715	dvmThrowArithmeticException("divide by zero"); \
				716	GOTO_exceptionThrown(); \
				717	} \
				718	if ((u4)firstVal == 0x80000000 && ((s2) vsrc2) == -1) { \
				719	/* won't generate /lit16 instr for this; check anyway */ \
				720	if (_chkdiv == 1) \
				721	result = firstVal; /* division */ \
				722	else \
				723	result = 0; /* remainder */ \
				724	} else { \
				725	result = firstVal _op (s2) vsrc2; \
				726	} \
				727	SET_REGISTER(vdst, result); \
				728	} else { \
				729	/* non-div/rem case */ \
				730	SET_REGISTER(vdst, GET_REGISTER(vsrc1) _op (s2) vsrc2); \
				731	} \
				732	FINISH(2);
				733
				734	#define HANDLE_OP_X_INT_LIT8(_opcode, _opname, _op, _chkdiv) \
				735	HANDLE_OPCODE(_opcode /vAA, vBB, #+CC/) \
				736	{ \
				737	u2 litInfo; \
				738	vdst = INST_AA(inst); \
				739	litInfo = FETCH(1); \
				740	vsrc1 = litInfo & 0xff; \
				741	vsrc2 = litInfo >> 8; /* constant */ \
				742	ILOGV("\|%s-int/lit8 v%d,v%d,#+0x%02x", \
				743	(_opname), vdst, vsrc1, vsrc2); \
				744	if (_chkdiv != 0) { \
				745	s4 firstVal, result; \
				746	firstVal = GET_REGISTER(vsrc1); \
				747	if ((s1) vsrc2 == 0) { \
				748	EXPORT_PC(); \
				749	dvmThrowArithmeticException("divide by zero"); \
				750	GOTO_exceptionThrown(); \
				751	} \
				752	if ((u4)firstVal == 0x80000000 && ((s1) vsrc2) == -1) { \
				753	if (_chkdiv == 1) \
				754	result = firstVal; /* division */ \
				755	else \
				756	result = 0; /* remainder */ \
				757	} else { \
				758	result = firstVal _op ((s1) vsrc2); \
				759	} \
				760	SET_REGISTER(vdst, result); \
				761	} else { \
				762	SET_REGISTER(vdst, \
				763	(s4) GET_REGISTER(vsrc1) _op (s1) vsrc2); \
				764	} \
				765	} \
				766	FINISH(2);
				767
				768	#define HANDLE_OP_SHX_INT_LIT8(_opcode, _opname, _cast, _op) \
				769	HANDLE_OPCODE(_opcode /vAA, vBB, #+CC/) \
				770	{ \
				771	u2 litInfo; \
				772	vdst = INST_AA(inst); \
				773	litInfo = FETCH(1); \
				774	vsrc1 = litInfo & 0xff; \
				775	vsrc2 = litInfo >> 8; /* constant */ \
				776	ILOGV("\|%s-int/lit8 v%d,v%d,#+0x%02x", \
				777	(_opname), vdst, vsrc1, vsrc2); \
				778	SET_REGISTER(vdst, \
				779	_cast GET_REGISTER(vsrc1) _op (vsrc2 & 0x1f)); \
				780	} \
				781	FINISH(2);
				782
				783	#define HANDLE_OP_X_INT_2ADDR(_opcode, _opname, _op, _chkdiv) \
				784	HANDLE_OPCODE(_opcode /vA, vB/) \
				785	vdst = INST_A(inst); \
				786	vsrc1 = INST_B(inst); \
				787	ILOGV("\|%s-int-2addr v%d,v%d", (_opname), vdst, vsrc1); \
				788	if (_chkdiv != 0) { \
				789	s4 firstVal, secondVal, result; \
				790	firstVal = GET_REGISTER(vdst); \
				791	secondVal = GET_REGISTER(vsrc1); \
				792	if (secondVal == 0) { \
				793	EXPORT_PC(); \
				794	dvmThrowArithmeticException("divide by zero"); \
				795	GOTO_exceptionThrown(); \
				796	} \
				797	if ((u4)firstVal == 0x80000000 && secondVal == -1) { \
				798	if (_chkdiv == 1) \
				799	result = firstVal; /* division */ \
				800	else \
				801	result = 0; /* remainder */ \
				802	} else { \
				803	result = firstVal _op secondVal; \
				804	} \
				805	SET_REGISTER(vdst, result); \
				806	} else { \
				807	SET_REGISTER(vdst, \
				808	(s4) GET_REGISTER(vdst) _op (s4) GET_REGISTER(vsrc1)); \
				809	} \
				810	FINISH(1);
				811
				812	#define HANDLE_OP_SHX_INT_2ADDR(_opcode, _opname, _cast, _op) \
				813	HANDLE_OPCODE(_opcode /vA, vB/) \
				814	vdst = INST_A(inst); \
				815	vsrc1 = INST_B(inst); \
				816	ILOGV("\|%s-int-2addr v%d,v%d", (_opname), vdst, vsrc1); \
				817	SET_REGISTER(vdst, \
				818	_cast GET_REGISTER(vdst) _op (GET_REGISTER(vsrc1) & 0x1f)); \
				819	FINISH(1);
				820
				821	#define HANDLE_OP_X_LONG(_opcode, _opname, _op, _chkdiv) \
				822	HANDLE_OPCODE(_opcode /vAA, vBB, vCC/) \
				823	{ \
				824	u2 srcRegs; \
				825	vdst = INST_AA(inst); \
				826	srcRegs = FETCH(1); \
				827	vsrc1 = srcRegs & 0xff; \
				828	vsrc2 = srcRegs >> 8; \
				829	ILOGV("\|%s-long v%d,v%d,v%d", (_opname), vdst, vsrc1, vsrc2); \
				830	if (_chkdiv != 0) { \
				831	s8 firstVal, secondVal, result; \
				832	firstVal = GET_REGISTER_WIDE(vsrc1); \
				833	secondVal = GET_REGISTER_WIDE(vsrc2); \
				834	if (secondVal == 0LL) { \
				835	EXPORT_PC(); \
				836	dvmThrowArithmeticException("divide by zero"); \
				837	GOTO_exceptionThrown(); \
				838	} \
				839	if ((u8)firstVal == 0x8000000000000000ULL && \
				840	secondVal == -1LL) \
				841	{ \
				842	if (_chkdiv == 1) \
				843	result = firstVal; /* division */ \
				844	else \
				845	result = 0; /* remainder */ \
				846	} else { \
				847	result = firstVal _op secondVal; \
				848	} \
				849	SET_REGISTER_WIDE(vdst, result); \
				850	} else { \
				851	SET_REGISTER_WIDE(vdst, \
				852	(s8) GET_REGISTER_WIDE(vsrc1) _op (s8) GET_REGISTER_WIDE(vsrc2)); \
				853	} \
				854	} \
				855	FINISH(2);
				856
				857	#define HANDLE_OP_SHX_LONG(_opcode, _opname, _cast, _op) \
				858	HANDLE_OPCODE(_opcode /vAA, vBB, vCC/) \
				859	{ \
				860	u2 srcRegs; \
				861	vdst = INST_AA(inst); \
				862	srcRegs = FETCH(1); \
				863	vsrc1 = srcRegs & 0xff; \
				864	vsrc2 = srcRegs >> 8; \
				865	ILOGV("\|%s-long v%d,v%d,v%d", (_opname), vdst, vsrc1, vsrc2); \
				866	SET_REGISTER_WIDE(vdst, \
				867	_cast GET_REGISTER_WIDE(vsrc1) _op (GET_REGISTER(vsrc2) & 0x3f)); \
				868	} \
				869	FINISH(2);
				870
				871	#define HANDLE_OP_X_LONG_2ADDR(_opcode, _opname, _op, _chkdiv) \
				872	HANDLE_OPCODE(_opcode /vA, vB/) \
				873	vdst = INST_A(inst); \
				874	vsrc1 = INST_B(inst); \
				875	ILOGV("\|%s-long-2addr v%d,v%d", (_opname), vdst, vsrc1); \
				876	if (_chkdiv != 0) { \
				877	s8 firstVal, secondVal, result; \
				878	firstVal = GET_REGISTER_WIDE(vdst); \
				879	secondVal = GET_REGISTER_WIDE(vsrc1); \
				880	if (secondVal == 0LL) { \
				881	EXPORT_PC(); \
				882	dvmThrowArithmeticException("divide by zero"); \
				883	GOTO_exceptionThrown(); \
				884	} \
				885	if ((u8)firstVal == 0x8000000000000000ULL && \
				886	secondVal == -1LL) \
				887	{ \
				888	if (_chkdiv == 1) \
				889	result = firstVal; /* division */ \
				890	else \
				891	result = 0; /* remainder */ \
				892	} else { \
				893	result = firstVal _op secondVal; \
				894	} \
				895	SET_REGISTER_WIDE(vdst, result); \
				896	} else { \
				897	SET_REGISTER_WIDE(vdst, \
				898	(s8) GET_REGISTER_WIDE(vdst) _op (s8)GET_REGISTER_WIDE(vsrc1));\
				899	} \
				900	FINISH(1);
				901
				902	#define HANDLE_OP_SHX_LONG_2ADDR(_opcode, _opname, _cast, _op) \
				903	HANDLE_OPCODE(_opcode /vA, vB/) \
				904	vdst = INST_A(inst); \
				905	vsrc1 = INST_B(inst); \
				906	ILOGV("\|%s-long-2addr v%d,v%d", (_opname), vdst, vsrc1); \
				907	SET_REGISTER_WIDE(vdst, \
				908	_cast GET_REGISTER_WIDE(vdst) _op (GET_REGISTER(vsrc1) & 0x3f)); \
				909	FINISH(1);
				910
				911	#define HANDLE_OP_X_FLOAT(_opcode, _opname, _op) \
				912	HANDLE_OPCODE(_opcode /vAA, vBB, vCC/) \
				913	{ \
				914	u2 srcRegs; \
				915	vdst = INST_AA(inst); \
				916	srcRegs = FETCH(1); \
				917	vsrc1 = srcRegs & 0xff; \
				918	vsrc2 = srcRegs >> 8; \
				919	ILOGV("\|%s-float v%d,v%d,v%d", (_opname), vdst, vsrc1, vsrc2); \
				920	SET_REGISTER_FLOAT(vdst, \
				921	GET_REGISTER_FLOAT(vsrc1) _op GET_REGISTER_FLOAT(vsrc2)); \
				922	} \
				923	FINISH(2);
				924
				925	#define HANDLE_OP_X_DOUBLE(_opcode, _opname, _op) \
				926	HANDLE_OPCODE(_opcode /vAA, vBB, vCC/) \
				927	{ \
				928	u2 srcRegs; \
				929	vdst = INST_AA(inst); \
				930	srcRegs = FETCH(1); \
				931	vsrc1 = srcRegs & 0xff; \
				932	vsrc2 = srcRegs >> 8; \
				933	ILOGV("\|%s-double v%d,v%d,v%d", (_opname), vdst, vsrc1, vsrc2); \
				934	SET_REGISTER_DOUBLE(vdst, \
				935	GET_REGISTER_DOUBLE(vsrc1) _op GET_REGISTER_DOUBLE(vsrc2)); \
				936	} \
				937	FINISH(2);
				938
				939	#define HANDLE_OP_X_FLOAT_2ADDR(_opcode, _opname, _op) \
				940	HANDLE_OPCODE(_opcode /vA, vB/) \
				941	vdst = INST_A(inst); \
				942	vsrc1 = INST_B(inst); \
				943	ILOGV("\|%s-float-2addr v%d,v%d", (_opname), vdst, vsrc1); \
				944	SET_REGISTER_FLOAT(vdst, \
				945	GET_REGISTER_FLOAT(vdst) _op GET_REGISTER_FLOAT(vsrc1)); \
				946	FINISH(1);
				947
				948	#define HANDLE_OP_X_DOUBLE_2ADDR(_opcode, _opname, _op) \
				949	HANDLE_OPCODE(_opcode /vA, vB/) \
				950	vdst = INST_A(inst); \
				951	vsrc1 = INST_B(inst); \
				952	ILOGV("\|%s-double-2addr v%d,v%d", (_opname), vdst, vsrc1); \
				953	SET_REGISTER_DOUBLE(vdst, \
				954	GET_REGISTER_DOUBLE(vdst) _op GET_REGISTER_DOUBLE(vsrc1)); \
				955	FINISH(1);
				956
				957	#define HANDLE_OP_AGET(_opcode, _opname, _type, _regsize) \
				958	HANDLE_OPCODE(_opcode /vAA, vBB, vCC/) \
				959	{ \
				960	ArrayObject* arrayObj; \
				961	u2 arrayInfo; \
				962	EXPORT_PC(); \
				963	vdst = INST_AA(inst); \
				964	arrayInfo = FETCH(1); \
				965	vsrc1 = arrayInfo & 0xff; /* array ptr */ \
				966	vsrc2 = arrayInfo >> 8; /* index */ \
				967	ILOGV("\|aget%s v%d,v%d,v%d", (_opname), vdst, vsrc1, vsrc2); \
				968	arrayObj = (ArrayObject*) GET_REGISTER(vsrc1); \
				969	if (!checkForNull((Object*) arrayObj)) \
				970	GOTO_exceptionThrown(); \
				971	if (GET_REGISTER(vsrc2) >= arrayObj->length) { \
				972	dvmThrowArrayIndexOutOfBoundsException( \
				973	arrayObj->length, GET_REGISTER(vsrc2)); \
				974	GOTO_exceptionThrown(); \
				975	} \
				976	SET_REGISTER##_regsize(vdst, \
				977	((_type)(void)arrayObj->contents)[GET_REGISTER(vsrc2)]); \
				978	ILOGV("+ AGET[%d]=0x%x", GET_REGISTER(vsrc2), GET_REGISTER(vdst)); \
				979	} \
				980	FINISH(2);
				981
				982	#define HANDLE_OP_APUT(_opcode, _opname, _type, _regsize) \
				983	HANDLE_OPCODE(_opcode /vAA, vBB, vCC/) \
				984	{ \
				985	ArrayObject* arrayObj; \
				986	u2 arrayInfo; \
				987	EXPORT_PC(); \
				988	vdst = INST_AA(inst); /* AA: source value */ \
				989	arrayInfo = FETCH(1); \
				990	vsrc1 = arrayInfo & 0xff; /* BB: array ptr */ \
				991	vsrc2 = arrayInfo >> 8; /* CC: index */ \
				992	ILOGV("\|aput%s v%d,v%d,v%d", (_opname), vdst, vsrc1, vsrc2); \
				993	arrayObj = (ArrayObject*) GET_REGISTER(vsrc1); \
				994	if (!checkForNull((Object*) arrayObj)) \
				995	GOTO_exceptionThrown(); \
				996	if (GET_REGISTER(vsrc2) >= arrayObj->length) { \
				997	dvmThrowArrayIndexOutOfBoundsException( \
				998	arrayObj->length, GET_REGISTER(vsrc2)); \
				999	GOTO_exceptionThrown(); \
				1000	} \
				1001	ILOGV("+ APUT[%d]=0x%08x", GET_REGISTER(vsrc2), GET_REGISTER(vdst));\
				1002	((_type)(void)arrayObj->contents)[GET_REGISTER(vsrc2)] = \
				1003	GET_REGISTER##_regsize(vdst); \
				1004	} \
				1005	FINISH(2);
				1006
				1007	/*
				1008	* It's possible to get a bad value out of a field with sub-32-bit stores
				1009	* because the -quick versions always operate on 32 bits. Consider:
				1010	* short foo = -1 (sets a 32-bit register to 0xffffffff)
				1011	* iput-quick foo (writes all 32 bits to the field)
				1012	* short bar = 1 (sets a 32-bit register to 0x00000001)
				1013	* iput-short (writes the low 16 bits to the field)
				1014	* iget-quick foo (reads all 32 bits from the field, yielding 0xffff0001)
				1015	* This can only happen when optimized and non-optimized code has interleaved
				1016	* access to the same field. This is unlikely but possible.
				1017	*
				1018	* The easiest way to fix this is to always read/write 32 bits at a time. On
				1019	* a device with a 16-bit data bus this is sub-optimal. (The alternative
				1020	* approach is to have sub-int versions of iget-quick, but now we're wasting
				1021	* Dalvik instruction space and making it less likely that handler code will
				1022	* already be in the CPU i-cache.)
				1023	*/
				1024	#define HANDLE_IGET_X(_opcode, _opname, _ftype, _regsize) \
				1025	HANDLE_OPCODE(_opcode /vA, vB, field@CCCC/) \
				1026	{ \
				1027	InstField* ifield; \
				1028	Object* obj; \
				1029	EXPORT_PC(); \
				1030	vdst = INST_A(inst); \
				1031	vsrc1 = INST_B(inst); /* object ptr */ \
				1032	ref = FETCH(1); /* field ref */ \
				1033	ILOGV("\|iget%s v%d,v%d,field@0x%04x", (_opname), vdst, vsrc1, ref); \
				1034	obj = (Object*) GET_REGISTER(vsrc1); \
				1035	if (!checkForNull(obj)) \
				1036	GOTO_exceptionThrown(); \
				1037	ifield = (InstField*) dvmDexGetResolvedField(methodClassDex, ref); \
				1038	if (ifield == NULL) { \
				1039	ifield = dvmResolveInstField(curMethod->clazz, ref); \
				1040	if (ifield == NULL) \
				1041	GOTO_exceptionThrown(); \
				1042	} \
				1043	SET_REGISTER##_regsize(vdst, \
				1044	dvmGetField##_ftype(obj, ifield->byteOffset)); \
				1045	ILOGV("+ IGET '%s'=0x%08llx", ifield->field.name, \
				1046	(u8) GET_REGISTER##_regsize(vdst)); \
				1047	UPDATE_FIELD_GET(&ifield->field); \
				1048	} \
				1049	FINISH(2);
				1050
				1051	#define HANDLE_IGET_X_JUMBO(_opcode, _opname, _ftype, _regsize) \
				1052	HANDLE_OPCODE(_opcode /vBBBB, vCCCC, class@AAAAAAAA/) \
				1053	{ \
				1054	InstField* ifield; \
				1055	Object* obj; \
				1056	EXPORT_PC(); \
				1057	ref = FETCH(1) \| (u4)FETCH(2) << 16; /* field ref */ \
				1058	vdst = FETCH(3); \
				1059	vsrc1 = FETCH(4); /* object ptr */ \
				1060	ILOGV("\|iget%s/jumbo v%d,v%d,field@0x%08x", \
				1061	(_opname), vdst, vsrc1, ref); \
				1062	obj = (Object*) GET_REGISTER(vsrc1); \
				1063	if (!checkForNull(obj)) \
				1064	GOTO_exceptionThrown(); \
				1065	ifield = (InstField*) dvmDexGetResolvedField(methodClassDex, ref); \
				1066	if (ifield == NULL) { \
				1067	ifield = dvmResolveInstField(curMethod->clazz, ref); \
				1068	if (ifield == NULL) \
				1069	GOTO_exceptionThrown(); \
				1070	} \
				1071	SET_REGISTER##_regsize(vdst, \
				1072	dvmGetField##_ftype(obj, ifield->byteOffset)); \
				1073	ILOGV("+ IGET '%s'=0x%08llx", ifield->field.name, \
				1074	(u8) GET_REGISTER##_regsize(vdst)); \
				1075	UPDATE_FIELD_GET(&ifield->field); \
				1076	} \
				1077	FINISH(5);
				1078
				1079	#define HANDLE_IGET_X_QUICK(_opcode, _opname, _ftype, _regsize) \
				1080	HANDLE_OPCODE(_opcode /vA, vB, field@CCCC/) \
				1081	{ \
				1082	Object* obj; \
				1083	vdst = INST_A(inst); \
				1084	vsrc1 = INST_B(inst); /* object ptr */ \
				1085	ref = FETCH(1); /* field offset */ \
				1086	ILOGV("\|iget%s-quick v%d,v%d,field@+%u", \
				1087	(_opname), vdst, vsrc1, ref); \
				1088	obj = (Object*) GET_REGISTER(vsrc1); \
				1089	if (!checkForNullExportPC(obj, fp, pc)) \
				1090	GOTO_exceptionThrown(); \
				1091	SET_REGISTER##_regsize(vdst, dvmGetField##_ftype(obj, ref)); \
				1092	ILOGV("+ IGETQ %d=0x%08llx", ref, \
				1093	(u8) GET_REGISTER##_regsize(vdst)); \
				1094	} \
				1095	FINISH(2);
				1096
				1097	#define HANDLE_IPUT_X(_opcode, _opname, _ftype, _regsize) \
				1098	HANDLE_OPCODE(_opcode /vA, vB, field@CCCC/) \
				1099	{ \
				1100	InstField* ifield; \
				1101	Object* obj; \
				1102	EXPORT_PC(); \
				1103	vdst = INST_A(inst); \
				1104	vsrc1 = INST_B(inst); /* object ptr */ \
				1105	ref = FETCH(1); /* field ref */ \
				1106	ILOGV("\|iput%s v%d,v%d,field@0x%04x", (_opname), vdst, vsrc1, ref); \
				1107	obj = (Object*) GET_REGISTER(vsrc1); \
				1108	if (!checkForNull(obj)) \
				1109	GOTO_exceptionThrown(); \
				1110	ifield = (InstField*) dvmDexGetResolvedField(methodClassDex, ref); \
				1111	if (ifield == NULL) { \
				1112	ifield = dvmResolveInstField(curMethod->clazz, ref); \
				1113	if (ifield == NULL) \
				1114	GOTO_exceptionThrown(); \
				1115	} \
				1116	dvmSetField##_ftype(obj, ifield->byteOffset, \
				1117	GET_REGISTER##_regsize(vdst)); \
				1118	ILOGV("+ IPUT '%s'=0x%08llx", ifield->field.name, \
				1119	(u8) GET_REGISTER##_regsize(vdst)); \
				1120	UPDATE_FIELD_PUT(&ifield->field); \
				1121	} \
				1122	FINISH(2);
				1123
				1124	#define HANDLE_IPUT_X_JUMBO(_opcode, _opname, _ftype, _regsize) \
				1125	HANDLE_OPCODE(_opcode /vBBBB, vCCCC, class@AAAAAAAA/) \
				1126	{ \
				1127	InstField* ifield; \
				1128	Object* obj; \
				1129	EXPORT_PC(); \
				1130	ref = FETCH(1) \| (u4)FETCH(2) << 16; /* field ref */ \
				1131	vdst = FETCH(3); \
				1132	vsrc1 = FETCH(4); /* object ptr */ \
				1133	ILOGV("\|iput%s/jumbo v%d,v%d,field@0x%08x", \
				1134	(_opname), vdst, vsrc1, ref); \
				1135	obj = (Object*) GET_REGISTER(vsrc1); \
				1136	if (!checkForNull(obj)) \
				1137	GOTO_exceptionThrown(); \
				1138	ifield = (InstField*) dvmDexGetResolvedField(methodClassDex, ref); \
				1139	if (ifield == NULL) { \
				1140	ifield = dvmResolveInstField(curMethod->clazz, ref); \
				1141	if (ifield == NULL) \
				1142	GOTO_exceptionThrown(); \
				1143	} \
				1144	dvmSetField##_ftype(obj, ifield->byteOffset, \
				1145	GET_REGISTER##_regsize(vdst)); \
				1146	ILOGV("+ IPUT '%s'=0x%08llx", ifield->field.name, \
				1147	(u8) GET_REGISTER##_regsize(vdst)); \
				1148	UPDATE_FIELD_PUT(&ifield->field); \
				1149	} \
				1150	FINISH(5);
				1151
				1152	#define HANDLE_IPUT_X_QUICK(_opcode, _opname, _ftype, _regsize) \
				1153	HANDLE_OPCODE(_opcode /vA, vB, field@CCCC/) \
				1154	{ \
				1155	Object* obj; \
				1156	vdst = INST_A(inst); \
				1157	vsrc1 = INST_B(inst); /* object ptr */ \
				1158	ref = FETCH(1); /* field offset */ \
				1159	ILOGV("\|iput%s-quick v%d,v%d,field@0x%04x", \
				1160	(_opname), vdst, vsrc1, ref); \
				1161	obj = (Object*) GET_REGISTER(vsrc1); \
				1162	if (!checkForNullExportPC(obj, fp, pc)) \
				1163	GOTO_exceptionThrown(); \
				1164	dvmSetField##_ftype(obj, ref, GET_REGISTER##_regsize(vdst)); \
				1165	ILOGV("+ IPUTQ %d=0x%08llx", ref, \
				1166	(u8) GET_REGISTER##_regsize(vdst)); \
				1167	} \
				1168	FINISH(2);
				1169
				1170	/*
				1171	* The JIT needs dvmDexGetResolvedField() to return non-null.
				1172	* Because the portable interpreter is not involved with the JIT
				1173	* and trace building, we only need the extra check here when this
				1174	* code is massaged into a stub called from an assembly interpreter.
				1175	* This is controlled by the JIT_STUB_HACK maco.
				1176	*/
				1177
				1178	#define HANDLE_SGET_X(_opcode, _opname, _ftype, _regsize) \
				1179	HANDLE_OPCODE(_opcode /vAA, field@BBBB/) \
				1180	{ \
				1181	StaticField* sfield; \
				1182	vdst = INST_AA(inst); \
				1183	ref = FETCH(1); /* field ref */ \
				1184	ILOGV("\|sget%s v%d,sfield@0x%04x", (_opname), vdst, ref); \
				1185	sfield = (StaticField*)dvmDexGetResolvedField(methodClassDex, ref); \
				1186	if (sfield == NULL) { \
				1187	EXPORT_PC(); \
				1188	sfield = dvmResolveStaticField(curMethod->clazz, ref); \
				1189	if (sfield == NULL) \
				1190	GOTO_exceptionThrown(); \
				1191	if (dvmDexGetResolvedField(methodClassDex, ref) == NULL) { \
				1192	JIT_STUB_HACK(dvmJitEndTraceSelect(self,pc)); \
				1193	} \
				1194	} \
				1195	SET_REGISTER##_regsize(vdst, dvmGetStaticField##_ftype(sfield)); \
				1196	ILOGV("+ SGET '%s'=0x%08llx", \
				1197	sfield->field.name, (u8)GET_REGISTER##_regsize(vdst)); \
				1198	UPDATE_FIELD_GET(&sfield->field); \
				1199	} \
				1200	FINISH(2);
				1201
				1202	#define HANDLE_SGET_X_JUMBO(_opcode, _opname, _ftype, _regsize) \
				1203	HANDLE_OPCODE(_opcode /vBBBB, class@AAAAAAAA/) \
				1204	{ \
				1205	StaticField* sfield; \
				1206	ref = FETCH(1) \| (u4)FETCH(2) << 16; /* field ref */ \
				1207	vdst = FETCH(3); \
				1208	ILOGV("\|sget%s/jumbo v%d,sfield@0x%08x", (_opname), vdst, ref); \
				1209	sfield = (StaticField*)dvmDexGetResolvedField(methodClassDex, ref); \
				1210	if (sfield == NULL) { \
				1211	EXPORT_PC(); \
				1212	sfield = dvmResolveStaticField(curMethod->clazz, ref); \
				1213	if (sfield == NULL) \
				1214	GOTO_exceptionThrown(); \
				1215	if (dvmDexGetResolvedField(methodClassDex, ref) == NULL) { \
				1216	JIT_STUB_HACK(dvmJitEndTraceSelect(self,pc)); \
				1217	} \
				1218	} \
				1219	SET_REGISTER##_regsize(vdst, dvmGetStaticField##_ftype(sfield)); \
				1220	ILOGV("+ SGET '%s'=0x%08llx", \
				1221	sfield->field.name, (u8)GET_REGISTER##_regsize(vdst)); \
				1222	UPDATE_FIELD_GET(&sfield->field); \
				1223	} \
				1224	FINISH(4);
				1225
				1226	#define HANDLE_SPUT_X(_opcode, _opname, _ftype, _regsize) \
				1227	HANDLE_OPCODE(_opcode /vAA, field@BBBB/) \
				1228	{ \
				1229	StaticField* sfield; \
				1230	vdst = INST_AA(inst); \
				1231	ref = FETCH(1); /* field ref */ \
				1232	ILOGV("\|sput%s v%d,sfield@0x%04x", (_opname), vdst, ref); \
				1233	sfield = (StaticField*)dvmDexGetResolvedField(methodClassDex, ref); \
				1234	if (sfield == NULL) { \
				1235	EXPORT_PC(); \
				1236	sfield = dvmResolveStaticField(curMethod->clazz, ref); \
				1237	if (sfield == NULL) \
				1238	GOTO_exceptionThrown(); \
				1239	if (dvmDexGetResolvedField(methodClassDex, ref) == NULL) { \
				1240	JIT_STUB_HACK(dvmJitEndTraceSelect(self,pc)); \
				1241	} \
				1242	} \
				1243	dvmSetStaticField##_ftype(sfield, GET_REGISTER##_regsize(vdst)); \
				1244	ILOGV("+ SPUT '%s'=0x%08llx", \
				1245	sfield->field.name, (u8)GET_REGISTER##_regsize(vdst)); \
				1246	UPDATE_FIELD_PUT(&sfield->field); \
				1247	} \
				1248	FINISH(2);
				1249
				1250	#define HANDLE_SPUT_X_JUMBO(_opcode, _opname, _ftype, _regsize) \
				1251	HANDLE_OPCODE(_opcode /vBBBB, class@AAAAAAAA/) \
				1252	{ \
				1253	StaticField* sfield; \
				1254	ref = FETCH(1) \| (u4)FETCH(2) << 16; /* field ref */ \
				1255	vdst = FETCH(3); \
				1256	ILOGV("\|sput%s/jumbo v%d,sfield@0x%08x", (_opname), vdst, ref); \
				1257	sfield = (StaticField*)dvmDexGetResolvedField(methodClassDex, ref); \
				1258	if (sfield == NULL) { \
				1259	EXPORT_PC(); \
				1260	sfield = dvmResolveStaticField(curMethod->clazz, ref); \
				1261	if (sfield == NULL) \
				1262	GOTO_exceptionThrown(); \
				1263	if (dvmDexGetResolvedField(methodClassDex, ref) == NULL) { \
				1264	JIT_STUB_HACK(dvmJitEndTraceSelect(self,pc)); \
				1265	} \
				1266	} \
				1267	dvmSetStaticField##_ftype(sfield, GET_REGISTER##_regsize(vdst)); \
				1268	ILOGV("+ SPUT '%s'=0x%08llx", \
				1269	sfield->field.name, (u8)GET_REGISTER##_regsize(vdst)); \
				1270	UPDATE_FIELD_PUT(&sfield->field); \
				1271	} \
				1272	FINISH(4);
				1273
				1274	/* File: c/OP_NOP.cpp */
				1275	HANDLE_OPCODE(OP_NOP)
				1276	FINISH(1);
				1277	OP_END
				1278
				1279	/* File: c/OP_MOVE.cpp */
				1280	HANDLE_OPCODE(OP_MOVE /vA, vB/)
				1281	vdst = INST_A(inst);
				1282	vsrc1 = INST_B(inst);
				1283	ILOGV("\|move%s v%d,v%d %s(v%d=0x%08x)",
				1284	(INST_INST(inst) == OP_MOVE) ? "" : "-object", vdst, vsrc1,
				1285	kSpacing, vdst, GET_REGISTER(vsrc1));
				1286	SET_REGISTER(vdst, GET_REGISTER(vsrc1));
				1287	FINISH(1);
				1288	OP_END
				1289
				1290	/* File: c/OP_MOVE_FROM16.cpp */
				1291	HANDLE_OPCODE(OP_MOVE_FROM16 /vAA, vBBBB/)
				1292	vdst = INST_AA(inst);
				1293	vsrc1 = FETCH(1);
				1294	ILOGV("\|move%s/from16 v%d,v%d %s(v%d=0x%08x)",
				1295	(INST_INST(inst) == OP_MOVE_FROM16) ? "" : "-object", vdst, vsrc1,
				1296	kSpacing, vdst, GET_REGISTER(vsrc1));
				1297	SET_REGISTER(vdst, GET_REGISTER(vsrc1));
				1298	FINISH(2);
				1299	OP_END
				1300
				1301	/* File: c/OP_MOVE_16.cpp */
				1302	HANDLE_OPCODE(OP_MOVE_16 /vAAAA, vBBBB/)
				1303	vdst = FETCH(1);
				1304	vsrc1 = FETCH(2);
				1305	ILOGV("\|move%s/16 v%d,v%d %s(v%d=0x%08x)",
				1306	(INST_INST(inst) == OP_MOVE_16) ? "" : "-object", vdst, vsrc1,
				1307	kSpacing, vdst, GET_REGISTER(vsrc1));
				1308	SET_REGISTER(vdst, GET_REGISTER(vsrc1));
				1309	FINISH(3);
				1310	OP_END
				1311
				1312	/* File: c/OP_MOVE_WIDE.cpp */
				1313	HANDLE_OPCODE(OP_MOVE_WIDE /vA, vB/)
				1314	/* IMPORTANT: must correctly handle overlapping registers, e.g. both
				1315	* "move-wide v6, v7" and "move-wide v7, v6" */
				1316	vdst = INST_A(inst);
				1317	vsrc1 = INST_B(inst);
				1318	ILOGV("\|move-wide v%d,v%d %s(v%d=0x%08llx)", vdst, vsrc1,
				1319	kSpacing+5, vdst, GET_REGISTER_WIDE(vsrc1));
				1320	SET_REGISTER_WIDE(vdst, GET_REGISTER_WIDE(vsrc1));
				1321	FINISH(1);
				1322	OP_END
				1323
				1324	/* File: c/OP_MOVE_WIDE_FROM16.cpp */
				1325	HANDLE_OPCODE(OP_MOVE_WIDE_FROM16 /vAA, vBBBB/)
				1326	vdst = INST_AA(inst);
				1327	vsrc1 = FETCH(1);
				1328	ILOGV("\|move-wide/from16 v%d,v%d (v%d=0x%08llx)", vdst, vsrc1,
				1329	vdst, GET_REGISTER_WIDE(vsrc1));
				1330	SET_REGISTER_WIDE(vdst, GET_REGISTER_WIDE(vsrc1));
				1331	FINISH(2);
				1332	OP_END
				1333
				1334	/* File: c/OP_MOVE_WIDE_16.cpp */
				1335	HANDLE_OPCODE(OP_MOVE_WIDE_16 /vAAAA, vBBBB/)
				1336	vdst = FETCH(1);
				1337	vsrc1 = FETCH(2);
				1338	ILOGV("\|move-wide/16 v%d,v%d %s(v%d=0x%08llx)", vdst, vsrc1,
				1339	kSpacing+8, vdst, GET_REGISTER_WIDE(vsrc1));
				1340	SET_REGISTER_WIDE(vdst, GET_REGISTER_WIDE(vsrc1));
				1341	FINISH(3);
				1342	OP_END
				1343
				1344	/* File: c/OP_MOVE_OBJECT.cpp */
				1345	/* File: c/OP_MOVE.cpp */
				1346	HANDLE_OPCODE(OP_MOVE_OBJECT /vA, vB/)
				1347	vdst = INST_A(inst);
				1348	vsrc1 = INST_B(inst);
				1349	ILOGV("\|move%s v%d,v%d %s(v%d=0x%08x)",
				1350	(INST_INST(inst) == OP_MOVE) ? "" : "-object", vdst, vsrc1,
				1351	kSpacing, vdst, GET_REGISTER(vsrc1));
				1352	SET_REGISTER(vdst, GET_REGISTER(vsrc1));
				1353	FINISH(1);
				1354	OP_END
				1355
				1356
				1357	/* File: c/OP_MOVE_OBJECT_FROM16.cpp */
				1358	/* File: c/OP_MOVE_FROM16.cpp */
				1359	HANDLE_OPCODE(OP_MOVE_OBJECT_FROM16 /vAA, vBBBB/)
				1360	vdst = INST_AA(inst);
				1361	vsrc1 = FETCH(1);
				1362	ILOGV("\|move%s/from16 v%d,v%d %s(v%d=0x%08x)",
				1363	(INST_INST(inst) == OP_MOVE_FROM16) ? "" : "-object", vdst, vsrc1,
				1364	kSpacing, vdst, GET_REGISTER(vsrc1));
				1365	SET_REGISTER(vdst, GET_REGISTER(vsrc1));
				1366	FINISH(2);
				1367	OP_END
				1368
				1369
				1370	/* File: c/OP_MOVE_OBJECT_16.cpp */
				1371	/* File: c/OP_MOVE_16.cpp */
				1372	HANDLE_OPCODE(OP_MOVE_OBJECT_16 /vAAAA, vBBBB/)
				1373	vdst = FETCH(1);
				1374	vsrc1 = FETCH(2);
				1375	ILOGV("\|move%s/16 v%d,v%d %s(v%d=0x%08x)",
				1376	(INST_INST(inst) == OP_MOVE_16) ? "" : "-object", vdst, vsrc1,
				1377	kSpacing, vdst, GET_REGISTER(vsrc1));
				1378	SET_REGISTER(vdst, GET_REGISTER(vsrc1));
				1379	FINISH(3);
				1380	OP_END
				1381
				1382
				1383	/* File: c/OP_MOVE_RESULT.cpp */
				1384	HANDLE_OPCODE(OP_MOVE_RESULT /vAA/)
				1385	vdst = INST_AA(inst);
				1386	ILOGV("\|move-result%s v%d %s(v%d=0x%08x)",
				1387	(INST_INST(inst) == OP_MOVE_RESULT) ? "" : "-object",
				1388	vdst, kSpacing+4, vdst,retval.i);
				1389	SET_REGISTER(vdst, retval.i);
				1390	FINISH(1);
				1391	OP_END
				1392
				1393	/* File: c/OP_MOVE_RESULT_WIDE.cpp */
				1394	HANDLE_OPCODE(OP_MOVE_RESULT_WIDE /vAA/)
				1395	vdst = INST_AA(inst);
				1396	ILOGV("\|move-result-wide v%d %s(0x%08llx)", vdst, kSpacing, retval.j);
				1397	SET_REGISTER_WIDE(vdst, retval.j);
				1398	FINISH(1);
				1399	OP_END
				1400
				1401	/* File: c/OP_MOVE_RESULT_OBJECT.cpp */
				1402	/* File: c/OP_MOVE_RESULT.cpp */
				1403	HANDLE_OPCODE(OP_MOVE_RESULT_OBJECT /vAA/)
				1404	vdst = INST_AA(inst);
				1405	ILOGV("\|move-result%s v%d %s(v%d=0x%08x)",
				1406	(INST_INST(inst) == OP_MOVE_RESULT) ? "" : "-object",
				1407	vdst, kSpacing+4, vdst,retval.i);
				1408	SET_REGISTER(vdst, retval.i);
				1409	FINISH(1);
				1410	OP_END
				1411
				1412
				1413	/* File: c/OP_MOVE_EXCEPTION.cpp */
				1414	HANDLE_OPCODE(OP_MOVE_EXCEPTION /vAA/)
				1415	vdst = INST_AA(inst);
				1416	ILOGV("\|move-exception v%d", vdst);
				1417	assert(self->exception != NULL);
				1418	SET_REGISTER(vdst, (u4)self->exception);
				1419	dvmClearException(self);
				1420	FINISH(1);
				1421	OP_END
				1422
				1423	/* File: c/OP_RETURN_VOID.cpp */
				1424	HANDLE_OPCODE(OP_RETURN_VOID /**/)
				1425	ILOGV("\|return-void");
				1426	#ifndef NDEBUG
				1427	retval.j = 0xababababULL; // placate valgrind
				1428	#endif
				1429	GOTO_returnFromMethod();
				1430	OP_END
				1431
				1432	/* File: c/OP_RETURN.cpp */
				1433	HANDLE_OPCODE(OP_RETURN /vAA/)
				1434	vsrc1 = INST_AA(inst);
				1435	ILOGV("\|return%s v%d",
				1436	(INST_INST(inst) == OP_RETURN) ? "" : "-object", vsrc1);
				1437	retval.i = GET_REGISTER(vsrc1);
				1438	GOTO_returnFromMethod();
				1439	OP_END
				1440
				1441	/* File: c/OP_RETURN_WIDE.cpp */
				1442	HANDLE_OPCODE(OP_RETURN_WIDE /vAA/)
				1443	vsrc1 = INST_AA(inst);
				1444	ILOGV("\|return-wide v%d", vsrc1);
				1445	retval.j = GET_REGISTER_WIDE(vsrc1);
				1446	GOTO_returnFromMethod();
				1447	OP_END
				1448
				1449	/* File: c/OP_RETURN_OBJECT.cpp */
				1450	/* File: c/OP_RETURN.cpp */
				1451	HANDLE_OPCODE(OP_RETURN_OBJECT /vAA/)
				1452	vsrc1 = INST_AA(inst);
				1453	ILOGV("\|return%s v%d",
				1454	(INST_INST(inst) == OP_RETURN) ? "" : "-object", vsrc1);
				1455	retval.i = GET_REGISTER(vsrc1);
				1456	GOTO_returnFromMethod();
				1457	OP_END
				1458
				1459
				1460	/* File: c/OP_CONST_4.cpp */
				1461	HANDLE_OPCODE(OP_CONST_4 /vA, #+B/)
				1462	{
				1463	s4 tmp;
				1464
				1465	vdst = INST_A(inst);
				1466	tmp = (s4) (INST_B(inst) << 28) >> 28; // sign extend 4-bit value
				1467	ILOGV("\|const/4 v%d,#0x%02x", vdst, (s4)tmp);
				1468	SET_REGISTER(vdst, tmp);
				1469	}
				1470	FINISH(1);
				1471	OP_END
				1472
				1473	/* File: c/OP_CONST_16.cpp */
				1474	HANDLE_OPCODE(OP_CONST_16 /vAA, #+BBBB/)
				1475	vdst = INST_AA(inst);
				1476	vsrc1 = FETCH(1);
				1477	ILOGV("\|const/16 v%d,#0x%04x", vdst, (s2)vsrc1);
				1478	SET_REGISTER(vdst, (s2) vsrc1);
				1479	FINISH(2);
				1480	OP_END
				1481
				1482	/* File: c/OP_CONST.cpp */
				1483	HANDLE_OPCODE(OP_CONST /vAA, #+BBBBBBBB/)
				1484	{
				1485	u4 tmp;
				1486
				1487	vdst = INST_AA(inst);
				1488	tmp = FETCH(1);
				1489	tmp \|= (u4)FETCH(2) << 16;
				1490	ILOGV("\|const v%d,#0x%08x", vdst, tmp);
				1491	SET_REGISTER(vdst, tmp);
				1492	}
				1493	FINISH(3);
				1494	OP_END
				1495
				1496	/* File: c/OP_CONST_HIGH16.cpp */
				1497	HANDLE_OPCODE(OP_CONST_HIGH16 /vAA, #+BBBB0000/)
				1498	vdst = INST_AA(inst);
				1499	vsrc1 = FETCH(1);
				1500	ILOGV("\|const/high16 v%d,#0x%04x0000", vdst, vsrc1);
				1501	SET_REGISTER(vdst, vsrc1 << 16);
				1502	FINISH(2);
				1503	OP_END
				1504
				1505	/* File: c/OP_CONST_WIDE_16.cpp */
				1506	HANDLE_OPCODE(OP_CONST_WIDE_16 /vAA, #+BBBB/)
				1507	vdst = INST_AA(inst);
				1508	vsrc1 = FETCH(1);
				1509	ILOGV("\|const-wide/16 v%d,#0x%04x", vdst, (s2)vsrc1);
				1510	SET_REGISTER_WIDE(vdst, (s2)vsrc1);
				1511	FINISH(2);
				1512	OP_END
				1513
				1514	/* File: c/OP_CONST_WIDE_32.cpp */
				1515	HANDLE_OPCODE(OP_CONST_WIDE_32 /vAA, #+BBBBBBBB/)
				1516	{
				1517	u4 tmp;
				1518
				1519	vdst = INST_AA(inst);
				1520	tmp = FETCH(1);
				1521	tmp \|= (u4)FETCH(2) << 16;
				1522	ILOGV("\|const-wide/32 v%d,#0x%08x", vdst, tmp);
				1523	SET_REGISTER_WIDE(vdst, (s4) tmp);
				1524	}
				1525	FINISH(3);
				1526	OP_END
				1527
				1528	/* File: c/OP_CONST_WIDE.cpp */
				1529	HANDLE_OPCODE(OP_CONST_WIDE /vAA, #+BBBBBBBBBBBBBBBB/)
				1530	{
				1531	u8 tmp;
				1532
				1533	vdst = INST_AA(inst);
				1534	tmp = FETCH(1);
				1535	tmp \|= (u8)FETCH(2) << 16;
				1536	tmp \|= (u8)FETCH(3) << 32;
				1537	tmp \|= (u8)FETCH(4) << 48;
				1538	ILOGV("\|const-wide v%d,#0x%08llx", vdst, tmp);
				1539	SET_REGISTER_WIDE(vdst, tmp);
				1540	}
				1541	FINISH(5);
				1542	OP_END
				1543
				1544	/* File: c/OP_CONST_WIDE_HIGH16.cpp */
				1545	HANDLE_OPCODE(OP_CONST_WIDE_HIGH16 /vAA, #+BBBB000000000000/)
				1546	vdst = INST_AA(inst);
				1547	vsrc1 = FETCH(1);
				1548	ILOGV("\|const-wide/high16 v%d,#0x%04x000000000000", vdst, vsrc1);
				1549	SET_REGISTER_WIDE(vdst, ((u8) vsrc1) << 48);
				1550	FINISH(2);
				1551	OP_END
				1552
				1553	/* File: c/OP_CONST_STRING.cpp */
				1554	HANDLE_OPCODE(OP_CONST_STRING /vAA, string@BBBB/)
				1555	{
				1556	StringObject* strObj;
				1557
				1558	vdst = INST_AA(inst);
				1559	ref = FETCH(1);
				1560	ILOGV("\|const-string v%d string@0x%04x", vdst, ref);
				1561	strObj = dvmDexGetResolvedString(methodClassDex, ref);
				1562	if (strObj == NULL) {
				1563	EXPORT_PC();
				1564	strObj = dvmResolveString(curMethod->clazz, ref);
				1565	if (strObj == NULL)
				1566	GOTO_exceptionThrown();
				1567	}
				1568	SET_REGISTER(vdst, (u4) strObj);
				1569	}
				1570	FINISH(2);
				1571	OP_END
				1572
				1573	/* File: c/OP_CONST_STRING_JUMBO.cpp */
				1574	HANDLE_OPCODE(OP_CONST_STRING_JUMBO /vAA, string@BBBBBBBB/)
				1575	{
				1576	StringObject* strObj;
				1577	u4 tmp;
				1578
				1579	vdst = INST_AA(inst);
				1580	tmp = FETCH(1);
				1581	tmp \|= (u4)FETCH(2) << 16;
				1582	ILOGV("\|const-string/jumbo v%d string@0x%08x", vdst, tmp);
				1583	strObj = dvmDexGetResolvedString(methodClassDex, tmp);
				1584	if (strObj == NULL) {
				1585	EXPORT_PC();
				1586	strObj = dvmResolveString(curMethod->clazz, tmp);
				1587	if (strObj == NULL)
				1588	GOTO_exceptionThrown();
				1589	}
				1590	SET_REGISTER(vdst, (u4) strObj);
				1591	}
				1592	FINISH(3);
				1593	OP_END
				1594
				1595	/* File: c/OP_CONST_CLASS.cpp */
				1596	HANDLE_OPCODE(OP_CONST_CLASS /vAA, class@BBBB/)
				1597	{
				1598	ClassObject* clazz;
				1599
				1600	vdst = INST_AA(inst);
				1601	ref = FETCH(1);
				1602	ILOGV("\|const-class v%d class@0x%04x", vdst, ref);
				1603	clazz = dvmDexGetResolvedClass(methodClassDex, ref);
				1604	if (clazz == NULL) {
				1605	EXPORT_PC();
				1606	clazz = dvmResolveClass(curMethod->clazz, ref, true);
				1607	if (clazz == NULL)
				1608	GOTO_exceptionThrown();
				1609	}
				1610	SET_REGISTER(vdst, (u4) clazz);
				1611	}
				1612	FINISH(2);
				1613	OP_END
				1614
				1615	/* File: c/OP_MONITOR_ENTER.cpp */
				1616	HANDLE_OPCODE(OP_MONITOR_ENTER /vAA/)
				1617	{
				1618	Object* obj;
				1619
				1620	vsrc1 = INST_AA(inst);
				1621	ILOGV("\|monitor-enter v%d %s(0x%08x)",
				1622	vsrc1, kSpacing+6, GET_REGISTER(vsrc1));
				1623	obj = (Object*)GET_REGISTER(vsrc1);
				1624	if (!checkForNullExportPC(obj, fp, pc))
				1625	GOTO_exceptionThrown();
				1626	ILOGV("+ locking %p %s\n", obj, obj->clazz->descriptor);
				1627	EXPORT_PC(); /* need for precise GC */
				1628	dvmLockObject(self, obj);
				1629	}
				1630	FINISH(1);
				1631	OP_END
				1632
				1633	/* File: c/OP_MONITOR_EXIT.cpp */
				1634	HANDLE_OPCODE(OP_MONITOR_EXIT /vAA/)
				1635	{
				1636	Object* obj;
				1637
				1638	EXPORT_PC();
				1639
				1640	vsrc1 = INST_AA(inst);
				1641	ILOGV("\|monitor-exit v%d %s(0x%08x)",
				1642	vsrc1, kSpacing+5, GET_REGISTER(vsrc1));
				1643	obj = (Object*)GET_REGISTER(vsrc1);
				1644	if (!checkForNull(obj)) {
				1645	/*
				1646	* The exception needs to be processed at the following
				1647	* instruction, not the current instruction (see the Dalvik
				1648	* spec). Because we're jumping to an exception handler,
				1649	* we're not actually at risk of skipping an instruction
				1650	* by doing so.
				1651	*/
				1652	ADJUST_PC(1); /* monitor-exit width is 1 */
				1653	GOTO_exceptionThrown();
				1654	}
				1655	ILOGV("+ unlocking %p %s\n", obj, obj->clazz->descriptor);
				1656	if (!dvmUnlockObject(self, obj)) {
				1657	assert(dvmCheckException(self));
				1658	ADJUST_PC(1);
				1659	GOTO_exceptionThrown();
				1660	}
				1661	}
				1662	FINISH(1);
				1663	OP_END
				1664
				1665	/* File: c/OP_CHECK_CAST.cpp */
				1666	HANDLE_OPCODE(OP_CHECK_CAST /vAA, class@BBBB/)
				1667	{
				1668	ClassObject* clazz;
				1669	Object* obj;
				1670
				1671	EXPORT_PC();
				1672
				1673	vsrc1 = INST_AA(inst);
				1674	ref = FETCH(1); /* class to check against */
				1675	ILOGV("\|check-cast v%d,class@0x%04x", vsrc1, ref);
				1676
				1677	obj = (Object*)GET_REGISTER(vsrc1);
				1678	if (obj != NULL) {
				1679	#if defined(WITH_EXTRA_OBJECT_VALIDATION)
				1680	if (!checkForNull(obj))
				1681	GOTO_exceptionThrown();
				1682	#endif
				1683	clazz = dvmDexGetResolvedClass(methodClassDex, ref);
				1684	if (clazz == NULL) {
				1685	clazz = dvmResolveClass(curMethod->clazz, ref, false);
				1686	if (clazz == NULL)
				1687	GOTO_exceptionThrown();
				1688	}
				1689	if (!dvmInstanceof(obj->clazz, clazz)) {
				1690	dvmThrowClassCastException(obj->clazz, clazz);
				1691	GOTO_exceptionThrown();
				1692	}
				1693	}
				1694	}
				1695	FINISH(2);
				1696	OP_END
				1697
				1698	/* File: c/OP_INSTANCE_OF.cpp */
				1699	HANDLE_OPCODE(OP_INSTANCE_OF /vA, vB, class@CCCC/)
				1700	{
				1701	ClassObject* clazz;
				1702	Object* obj;
				1703
				1704	vdst = INST_A(inst);
				1705	vsrc1 = INST_B(inst); /* object to check */
				1706	ref = FETCH(1); /* class to check against */
				1707	ILOGV("\|instance-of v%d,v%d,class@0x%04x", vdst, vsrc1, ref);
				1708
				1709	obj = (Object*)GET_REGISTER(vsrc1);
				1710	if (obj == NULL) {
				1711	SET_REGISTER(vdst, 0);
				1712	} else {
				1713	#if defined(WITH_EXTRA_OBJECT_VALIDATION)
				1714	if (!checkForNullExportPC(obj, fp, pc))
				1715	GOTO_exceptionThrown();
				1716	#endif
				1717	clazz = dvmDexGetResolvedClass(methodClassDex, ref);
				1718	if (clazz == NULL) {
				1719	EXPORT_PC();
				1720	clazz = dvmResolveClass(curMethod->clazz, ref, true);
				1721	if (clazz == NULL)
				1722	GOTO_exceptionThrown();
				1723	}
				1724	SET_REGISTER(vdst, dvmInstanceof(obj->clazz, clazz));
				1725	}
				1726	}
				1727	FINISH(2);
				1728	OP_END
				1729
				1730	/* File: c/OP_ARRAY_LENGTH.cpp */
				1731	HANDLE_OPCODE(OP_ARRAY_LENGTH /vA, vB/)
				1732	{
				1733	ArrayObject* arrayObj;
				1734
				1735	vdst = INST_A(inst);
				1736	vsrc1 = INST_B(inst);
				1737	arrayObj = (ArrayObject*) GET_REGISTER(vsrc1);
				1738	ILOGV("\|array-length v%d,v%d (%p)", vdst, vsrc1, arrayObj);
				1739	if (!checkForNullExportPC((Object*) arrayObj, fp, pc))
				1740	GOTO_exceptionThrown();
				1741	/* verifier guarantees this is an array reference */
				1742	SET_REGISTER(vdst, arrayObj->length);
				1743	}
				1744	FINISH(1);
				1745	OP_END
				1746
				1747	/* File: c/OP_NEW_INSTANCE.cpp */
				1748	HANDLE_OPCODE(OP_NEW_INSTANCE /vAA, class@BBBB/)
				1749	{
				1750	ClassObject* clazz;
				1751	Object* newObj;
				1752
				1753	EXPORT_PC();
				1754
				1755	vdst = INST_AA(inst);
				1756	ref = FETCH(1);
				1757	ILOGV("\|new-instance v%d,class@0x%04x", vdst, ref);
				1758	clazz = dvmDexGetResolvedClass(methodClassDex, ref);
				1759	if (clazz == NULL) {
				1760	clazz = dvmResolveClass(curMethod->clazz, ref, false);
				1761	if (clazz == NULL)
				1762	GOTO_exceptionThrown();
				1763	}
				1764
				1765	if (!dvmIsClassInitialized(clazz) && !dvmInitClass(clazz))
				1766	GOTO_exceptionThrown();
				1767
				1768	#if defined(WITH_JIT)
				1769	/*
				1770	* The JIT needs dvmDexGetResolvedClass() to return non-null.
				1771	* Since we use the portable interpreter to build the trace, this extra
				1772	* check is not needed for mterp.
				1773	*/
				1774	if ((self->interpBreak.ctl.subMode & kSubModeJitTraceBuild) &&
				1775	(!dvmDexGetResolvedClass(methodClassDex, ref))) {
				1776	/* Class initialization is still ongoing - end the trace */
				1777	dvmJitEndTraceSelect(self,pc);
				1778	}
				1779	#endif
				1780
				1781	/*
				1782	* Verifier now tests for interface/abstract class.
				1783	*/
				1784	//if (dvmIsInterfaceClass(clazz) \|\| dvmIsAbstractClass(clazz)) {
				1785	// dvmThrowExceptionWithClassMessage(gDvm.exInstantiationError,
				1786	// clazz->descriptor);
				1787	// GOTO_exceptionThrown();
				1788	//}
				1789	newObj = dvmAllocObject(clazz, ALLOC_DONT_TRACK);
				1790	if (newObj == NULL)
				1791	GOTO_exceptionThrown();
				1792	SET_REGISTER(vdst, (u4) newObj);
				1793	}
				1794	FINISH(2);
				1795	OP_END
				1796
				1797	/* File: c/OP_NEW_ARRAY.cpp */
				1798	HANDLE_OPCODE(OP_NEW_ARRAY /vA, vB, class@CCCC/)
				1799	{
				1800	ClassObject* arrayClass;
				1801	ArrayObject* newArray;
				1802	s4 length;
				1803
				1804	EXPORT_PC();
				1805
				1806	vdst = INST_A(inst);
				1807	vsrc1 = INST_B(inst); /* length reg */
				1808	ref = FETCH(1);
				1809	ILOGV("\|new-array v%d,v%d,class@0x%04x (%d elements)",
				1810	vdst, vsrc1, ref, (s4) GET_REGISTER(vsrc1));
				1811	length = (s4) GET_REGISTER(vsrc1);
				1812	if (length < 0) {
				1813	dvmThrowNegativeArraySizeException(length);
				1814	GOTO_exceptionThrown();
				1815	}
				1816	arrayClass = dvmDexGetResolvedClass(methodClassDex, ref);
				1817	if (arrayClass == NULL) {
				1818	arrayClass = dvmResolveClass(curMethod->clazz, ref, false);
				1819	if (arrayClass == NULL)
				1820	GOTO_exceptionThrown();
				1821	}
				1822	/* verifier guarantees this is an array class */
				1823	assert(dvmIsArrayClass(arrayClass));
				1824	assert(dvmIsClassInitialized(arrayClass));
				1825
				1826	newArray = dvmAllocArrayByClass(arrayClass, length, ALLOC_DONT_TRACK);
				1827	if (newArray == NULL)
				1828	GOTO_exceptionThrown();
				1829	SET_REGISTER(vdst, (u4) newArray);
				1830	}
				1831	FINISH(2);
				1832	OP_END
				1833
				1834	/* File: c/OP_FILLED_NEW_ARRAY.cpp */
				1835	HANDLE_OPCODE(OP_FILLED_NEW_ARRAY /vB, {vD, vE, vF, vG, vA}, class@CCCC/)
				1836	GOTO_invoke(filledNewArray, false, false);
				1837	OP_END
				1838
				1839	/* File: c/OP_FILLED_NEW_ARRAY_RANGE.cpp */
				1840	HANDLE_OPCODE(OP_FILLED_NEW_ARRAY_RANGE /{vCCCC..v(CCCC+AA-1)}, class@BBBB/)
				1841	GOTO_invoke(filledNewArray, true, false);
				1842	OP_END
				1843
				1844	/* File: c/OP_FILL_ARRAY_DATA.cpp */
				1845	HANDLE_OPCODE(OP_FILL_ARRAY_DATA) /vAA, +BBBBBBBB/
				1846	{
				1847	const u2* arrayData;
				1848	s4 offset;
				1849	ArrayObject* arrayObj;
				1850
				1851	EXPORT_PC();
				1852	vsrc1 = INST_AA(inst);
				1853	offset = FETCH(1) \| (((s4) FETCH(2)) << 16);
				1854	ILOGV("\|fill-array-data v%d +0x%04x", vsrc1, offset);
				1855	arrayData = pc + offset; // offset in 16-bit units
				1856	#ifndef NDEBUG
				1857	if (arrayData < curMethod->insns \|\|
				1858	arrayData >= curMethod->insns + dvmGetMethodInsnsSize(curMethod))
				1859	{
				1860	/* should have been caught in verifier */
				1861	dvmThrowInternalError("bad fill array data");
				1862	GOTO_exceptionThrown();
				1863	}
				1864	#endif
				1865	arrayObj = (ArrayObject*) GET_REGISTER(vsrc1);
				1866	if (!dvmInterpHandleFillArrayData(arrayObj, arrayData)) {
				1867	GOTO_exceptionThrown();
				1868	}
				1869	FINISH(3);
				1870	}
				1871	OP_END
				1872
				1873	/* File: c/OP_THROW.cpp */
				1874	HANDLE_OPCODE(OP_THROW /vAA/)
				1875	{
				1876	Object* obj;
				1877
				1878	/*
				1879	* We don't create an exception here, but the process of searching
				1880	* for a catch block can do class lookups and throw exceptions.
				1881	* We need to update the saved PC.
				1882	*/
				1883	EXPORT_PC();
				1884
				1885	vsrc1 = INST_AA(inst);
				1886	ILOGV("\|throw v%d (%p)", vsrc1, (void*)GET_REGISTER(vsrc1));
				1887	obj = (Object*) GET_REGISTER(vsrc1);
				1888	if (!checkForNull(obj)) {
				1889	/* will throw a null pointer exception */
				1890	LOGVV("Bad exception\n");
				1891	} else {
				1892	/* use the requested exception */
				1893	dvmSetException(self, obj);
				1894	}
				1895	GOTO_exceptionThrown();
				1896	}
				1897	OP_END
				1898
				1899	/* File: c/OP_GOTO.cpp */
				1900	HANDLE_OPCODE(OP_GOTO /+AA/)
				1901	vdst = INST_AA(inst);
				1902	if ((s1)vdst < 0)
				1903	ILOGV("\|goto -0x%02x", -((s1)vdst));
				1904	else
				1905	ILOGV("\|goto +0x%02x", ((s1)vdst));
				1906	ILOGV("> branch taken");
				1907	if ((s1)vdst < 0)
				1908	PERIODIC_CHECKS((s1)vdst);
				1909	FINISH((s1)vdst);
				1910	OP_END
				1911
				1912	/* File: c/OP_GOTO_16.cpp */
				1913	HANDLE_OPCODE(OP_GOTO_16 /+AAAA/)
				1914	{
				1915	s4 offset = (s2) FETCH(1); /* sign-extend next code unit */
				1916
				1917	if (offset < 0)
				1918	ILOGV("\|goto/16 -0x%04x", -offset);
				1919	else
				1920	ILOGV("\|goto/16 +0x%04x", offset);
				1921	ILOGV("> branch taken");
				1922	if (offset < 0)
				1923	PERIODIC_CHECKS(offset);
				1924	FINISH(offset);
				1925	}
				1926	OP_END
				1927
				1928	/* File: c/OP_GOTO_32.cpp */
				1929	HANDLE_OPCODE(OP_GOTO_32 /+AAAAAAAA/)
				1930	{
				1931	s4 offset = FETCH(1); /* low-order 16 bits */
				1932	offset \|= ((s4) FETCH(2)) << 16; /* high-order 16 bits */
				1933
				1934	if (offset < 0)
				1935	ILOGV("\|goto/32 -0x%08x", -offset);
				1936	else
				1937	ILOGV("\|goto/32 +0x%08x", offset);
				1938	ILOGV("> branch taken");
				1939	if (offset <= 0) /* allowed to branch to self */
				1940	PERIODIC_CHECKS(offset);
				1941	FINISH(offset);
				1942	}
				1943	OP_END
				1944
				1945	/* File: c/OP_PACKED_SWITCH.cpp */
				1946	HANDLE_OPCODE(OP_PACKED_SWITCH /vAA, +BBBB/)
				1947	{
				1948	const u2* switchData;
				1949	u4 testVal;
				1950	s4 offset;
				1951
				1952	vsrc1 = INST_AA(inst);
				1953	offset = FETCH(1) \| (((s4) FETCH(2)) << 16);
				1954	ILOGV("\|packed-switch v%d +0x%04x", vsrc1, vsrc2);
				1955	switchData = pc + offset; // offset in 16-bit units
				1956	#ifndef NDEBUG
				1957	if (switchData < curMethod->insns \|\|
				1958	switchData >= curMethod->insns + dvmGetMethodInsnsSize(curMethod))
				1959	{
				1960	/* should have been caught in verifier */
				1961	EXPORT_PC();
				1962	dvmThrowInternalError("bad packed switch");
				1963	GOTO_exceptionThrown();
				1964	}
				1965	#endif
				1966	testVal = GET_REGISTER(vsrc1);
				1967
				1968	offset = dvmInterpHandlePackedSwitch(switchData, testVal);
				1969	ILOGV("> branch taken (0x%04x)\n", offset);
				1970	if (offset <= 0) /* uncommon */
				1971	PERIODIC_CHECKS(offset);
				1972	FINISH(offset);
				1973	}
				1974	OP_END
				1975
				1976	/* File: c/OP_SPARSE_SWITCH.cpp */
				1977	HANDLE_OPCODE(OP_SPARSE_SWITCH /vAA, +BBBB/)
				1978	{
				1979	const u2* switchData;
				1980	u4 testVal;
				1981	s4 offset;
				1982
				1983	vsrc1 = INST_AA(inst);
				1984	offset = FETCH(1) \| (((s4) FETCH(2)) << 16);
				1985	ILOGV("\|sparse-switch v%d +0x%04x", vsrc1, vsrc2);
				1986	switchData = pc + offset; // offset in 16-bit units
				1987	#ifndef NDEBUG
				1988	if (switchData < curMethod->insns \|\|
				1989	switchData >= curMethod->insns + dvmGetMethodInsnsSize(curMethod))
				1990	{
				1991	/* should have been caught in verifier */
				1992	EXPORT_PC();
				1993	dvmThrowInternalError("bad sparse switch");
				1994	GOTO_exceptionThrown();
				1995	}
				1996	#endif
				1997	testVal = GET_REGISTER(vsrc1);
				1998
				1999	offset = dvmInterpHandleSparseSwitch(switchData, testVal);
				2000	ILOGV("> branch taken (0x%04x)\n", offset);
				2001	if (offset <= 0) /* uncommon */
				2002	PERIODIC_CHECKS(offset);
				2003	FINISH(offset);
				2004	}
				2005	OP_END
				2006
				2007	/* File: c/OP_CMPL_FLOAT.cpp */
				2008	HANDLE_OP_CMPX(OP_CMPL_FLOAT, "l-float", float, _FLOAT, -1)
				2009	OP_END
				2010
				2011	/* File: c/OP_CMPG_FLOAT.cpp */
				2012	HANDLE_OP_CMPX(OP_CMPG_FLOAT, "g-float", float, _FLOAT, 1)
				2013	OP_END
				2014
				2015	/* File: c/OP_CMPL_DOUBLE.cpp */
				2016	HANDLE_OP_CMPX(OP_CMPL_DOUBLE, "l-double", double, _DOUBLE, -1)
				2017	OP_END
				2018
				2019	/* File: c/OP_CMPG_DOUBLE.cpp */
				2020	HANDLE_OP_CMPX(OP_CMPG_DOUBLE, "g-double", double, _DOUBLE, 1)
				2021	OP_END
				2022
				2023	/* File: c/OP_CMP_LONG.cpp */
				2024	HANDLE_OP_CMPX(OP_CMP_LONG, "-long", s8, _WIDE, 0)
				2025	OP_END
				2026
				2027	/* File: c/OP_IF_EQ.cpp */
				2028	HANDLE_OP_IF_XX(OP_IF_EQ, "eq", ==)
				2029	OP_END
				2030
				2031	/* File: c/OP_IF_NE.cpp */
				2032	HANDLE_OP_IF_XX(OP_IF_NE, "ne", !=)
				2033	OP_END
				2034
				2035	/* File: c/OP_IF_LT.cpp */
				2036	HANDLE_OP_IF_XX(OP_IF_LT, "lt", <)
				2037	OP_END
				2038
				2039	/* File: c/OP_IF_GE.cpp */
				2040	HANDLE_OP_IF_XX(OP_IF_GE, "ge", >=)
				2041	OP_END
				2042
				2043	/* File: c/OP_IF_GT.cpp */
				2044	HANDLE_OP_IF_XX(OP_IF_GT, "gt", >)
				2045	OP_END
				2046
				2047	/* File: c/OP_IF_LE.cpp */
				2048	HANDLE_OP_IF_XX(OP_IF_LE, "le", <=)
				2049	OP_END
				2050
				2051	/* File: c/OP_IF_EQZ.cpp */
				2052	HANDLE_OP_IF_XXZ(OP_IF_EQZ, "eqz", ==)
				2053	OP_END
				2054
				2055	/* File: c/OP_IF_NEZ.cpp */
				2056	HANDLE_OP_IF_XXZ(OP_IF_NEZ, "nez", !=)
				2057	OP_END
				2058
				2059	/* File: c/OP_IF_LTZ.cpp */
				2060	HANDLE_OP_IF_XXZ(OP_IF_LTZ, "ltz", <)
				2061	OP_END
				2062
				2063	/* File: c/OP_IF_GEZ.cpp */
				2064	HANDLE_OP_IF_XXZ(OP_IF_GEZ, "gez", >=)
				2065	OP_END
				2066
				2067	/* File: c/OP_IF_GTZ.cpp */
				2068	HANDLE_OP_IF_XXZ(OP_IF_GTZ, "gtz", >)
				2069	OP_END
				2070
				2071	/* File: c/OP_IF_LEZ.cpp */
				2072	HANDLE_OP_IF_XXZ(OP_IF_LEZ, "lez", <=)
				2073	OP_END
				2074
				2075	/* File: c/OP_UNUSED_3E.cpp */
				2076	HANDLE_OPCODE(OP_UNUSED_3E)
				2077	OP_END
				2078
				2079	/* File: c/OP_UNUSED_3F.cpp */
				2080	HANDLE_OPCODE(OP_UNUSED_3F)
				2081	OP_END
				2082
				2083	/* File: c/OP_UNUSED_40.cpp */
				2084	HANDLE_OPCODE(OP_UNUSED_40)
				2085	OP_END
				2086
				2087	/* File: c/OP_UNUSED_41.cpp */
				2088	HANDLE_OPCODE(OP_UNUSED_41)
				2089	OP_END
				2090
				2091	/* File: c/OP_UNUSED_42.cpp */
				2092	HANDLE_OPCODE(OP_UNUSED_42)
				2093	OP_END
				2094
				2095	/* File: c/OP_UNUSED_43.cpp */
				2096	HANDLE_OPCODE(OP_UNUSED_43)
				2097	OP_END
				2098
				2099	/* File: c/OP_AGET.cpp */
				2100	HANDLE_OP_AGET(OP_AGET, "", u4, )
				2101	OP_END
				2102
				2103	/* File: c/OP_AGET_WIDE.cpp */
				2104	HANDLE_OP_AGET(OP_AGET_WIDE, "-wide", s8, _WIDE)
				2105	OP_END
				2106
				2107	/* File: c/OP_AGET_OBJECT.cpp */
				2108	HANDLE_OP_AGET(OP_AGET_OBJECT, "-object", u4, )
				2109	OP_END
				2110
				2111	/* File: c/OP_AGET_BOOLEAN.cpp */
				2112	HANDLE_OP_AGET(OP_AGET_BOOLEAN, "-boolean", u1, )
				2113	OP_END
				2114
				2115	/* File: c/OP_AGET_BYTE.cpp */
				2116	HANDLE_OP_AGET(OP_AGET_BYTE, "-byte", s1, )
				2117	OP_END
				2118
				2119	/* File: c/OP_AGET_CHAR.cpp */
				2120	HANDLE_OP_AGET(OP_AGET_CHAR, "-char", u2, )
				2121	OP_END
				2122
				2123	/* File: c/OP_AGET_SHORT.cpp */
				2124	HANDLE_OP_AGET(OP_AGET_SHORT, "-short", s2, )
				2125	OP_END
				2126
				2127	/* File: c/OP_APUT.cpp */
				2128	HANDLE_OP_APUT(OP_APUT, "", u4, )
				2129	OP_END
				2130
				2131	/* File: c/OP_APUT_WIDE.cpp */
				2132	HANDLE_OP_APUT(OP_APUT_WIDE, "-wide", s8, _WIDE)
				2133	OP_END
				2134
				2135	/* File: c/OP_APUT_OBJECT.cpp */
				2136	HANDLE_OPCODE(OP_APUT_OBJECT /vAA, vBB, vCC/)
				2137	{
				2138	ArrayObject* arrayObj;
				2139	Object* obj;
				2140	u2 arrayInfo;
				2141	EXPORT_PC();
				2142	vdst = INST_AA(inst); /* AA: source value */
				2143	arrayInfo = FETCH(1);
				2144	vsrc1 = arrayInfo & 0xff; /* BB: array ptr */
				2145	vsrc2 = arrayInfo >> 8; /* CC: index */
				2146	ILOGV("\|aput%s v%d,v%d,v%d", "-object", vdst, vsrc1, vsrc2);
				2147	arrayObj = (ArrayObject*) GET_REGISTER(vsrc1);
				2148	if (!checkForNull((Object*) arrayObj))
				2149	GOTO_exceptionThrown();
				2150	if (GET_REGISTER(vsrc2) >= arrayObj->length) {
				2151	dvmThrowArrayIndexOutOfBoundsException(
				2152	arrayObj->length, GET_REGISTER(vsrc2));
				2153	GOTO_exceptionThrown();
				2154	}
				2155	obj = (Object*) GET_REGISTER(vdst);
				2156	if (obj != NULL) {
				2157	if (!checkForNull(obj))
				2158	GOTO_exceptionThrown();
				2159	if (!dvmCanPutArrayElement(obj->clazz, arrayObj->obj.clazz)) {
				2160	LOGV("Can't put a '%s'(%p) into array type='%s'(%p)\n",
				2161	obj->clazz->descriptor, obj,
				2162	arrayObj->obj.clazz->descriptor, arrayObj);
				2163	dvmThrowArrayStoreExceptionIncompatibleElement(obj->clazz, arrayObj->obj.clazz);
				2164	GOTO_exceptionThrown();
				2165	}
				2166	}
				2167	ILOGV("+ APUT[%d]=0x%08x", GET_REGISTER(vsrc2), GET_REGISTER(vdst));
				2168	dvmSetObjectArrayElement(arrayObj,
				2169	GET_REGISTER(vsrc2),
				2170	(Object *)GET_REGISTER(vdst));
				2171	}
				2172	FINISH(2);
				2173	OP_END
				2174
				2175	/* File: c/OP_APUT_BOOLEAN.cpp */
				2176	HANDLE_OP_APUT(OP_APUT_BOOLEAN, "-boolean", u1, )
				2177	OP_END
				2178
				2179	/* File: c/OP_APUT_BYTE.cpp */
				2180	HANDLE_OP_APUT(OP_APUT_BYTE, "-byte", s1, )
				2181	OP_END
				2182
				2183	/* File: c/OP_APUT_CHAR.cpp */
				2184	HANDLE_OP_APUT(OP_APUT_CHAR, "-char", u2, )
				2185	OP_END
				2186
				2187	/* File: c/OP_APUT_SHORT.cpp */
				2188	HANDLE_OP_APUT(OP_APUT_SHORT, "-short", s2, )
				2189	OP_END
				2190
				2191	/* File: c/OP_IGET.cpp */
				2192	HANDLE_IGET_X(OP_IGET, "", Int, )
				2193	OP_END
				2194
				2195	/* File: c/OP_IGET_WIDE.cpp */
				2196	HANDLE_IGET_X(OP_IGET_WIDE, "-wide", Long, _WIDE)
				2197	OP_END
				2198
				2199	/* File: c/OP_IGET_OBJECT.cpp */
				2200	HANDLE_IGET_X(OP_IGET_OBJECT, "-object", Object, _AS_OBJECT)
				2201	OP_END
				2202
				2203	/* File: c/OP_IGET_BOOLEAN.cpp */
				2204	HANDLE_IGET_X(OP_IGET_BOOLEAN, "", Int, )
				2205	OP_END
				2206
				2207	/* File: c/OP_IGET_BYTE.cpp */
				2208	HANDLE_IGET_X(OP_IGET_BYTE, "", Int, )
				2209	OP_END
				2210
				2211	/* File: c/OP_IGET_CHAR.cpp */
				2212	HANDLE_IGET_X(OP_IGET_CHAR, "", Int, )
				2213	OP_END
				2214
				2215	/* File: c/OP_IGET_SHORT.cpp */
				2216	HANDLE_IGET_X(OP_IGET_SHORT, "", Int, )
				2217	OP_END
				2218
				2219	/* File: c/OP_IPUT.cpp */
				2220	HANDLE_IPUT_X(OP_IPUT, "", Int, )
				2221	OP_END
				2222
				2223	/* File: c/OP_IPUT_WIDE.cpp */
				2224	HANDLE_IPUT_X(OP_IPUT_WIDE, "-wide", Long, _WIDE)
				2225	OP_END
				2226
				2227	/* File: c/OP_IPUT_OBJECT.cpp */
				2228	/*
				2229	* The VM spec says we should verify that the reference being stored into
				2230	* the field is assignment compatible. In practice, many popular VMs don't
				2231	* do this because it slows down a very common operation. It's not so bad
				2232	* for us, since "dexopt" quickens it whenever possible, but it's still an
				2233	* issue.
				2234	*
				2235	* To make this spec-complaint, we'd need to add a ClassObject pointer to
				2236	* the Field struct, resolve the field's type descriptor at link or class
				2237	* init time, and then verify the type here.
				2238	*/
				2239	HANDLE_IPUT_X(OP_IPUT_OBJECT, "-object", Object, _AS_OBJECT)
				2240	OP_END
				2241
				2242	/* File: c/OP_IPUT_BOOLEAN.cpp */
				2243	HANDLE_IPUT_X(OP_IPUT_BOOLEAN, "", Int, )
				2244	OP_END
				2245
				2246	/* File: c/OP_IPUT_BYTE.cpp */
				2247	HANDLE_IPUT_X(OP_IPUT_BYTE, "", Int, )
				2248	OP_END
				2249
				2250	/* File: c/OP_IPUT_CHAR.cpp */
				2251	HANDLE_IPUT_X(OP_IPUT_CHAR, "", Int, )
				2252	OP_END
				2253
				2254	/* File: c/OP_IPUT_SHORT.cpp */
				2255	HANDLE_IPUT_X(OP_IPUT_SHORT, "", Int, )
				2256	OP_END
				2257
				2258	/* File: c/OP_SGET.cpp */
				2259	HANDLE_SGET_X(OP_SGET, "", Int, )
				2260	OP_END
				2261
				2262	/* File: c/OP_SGET_WIDE.cpp */
				2263	HANDLE_SGET_X(OP_SGET_WIDE, "-wide", Long, _WIDE)
				2264	OP_END
				2265
				2266	/* File: c/OP_SGET_OBJECT.cpp */
				2267	HANDLE_SGET_X(OP_SGET_OBJECT, "-object", Object, _AS_OBJECT)
				2268	OP_END
				2269
				2270	/* File: c/OP_SGET_BOOLEAN.cpp */
				2271	HANDLE_SGET_X(OP_SGET_BOOLEAN, "", Int, )
				2272	OP_END
				2273
				2274	/* File: c/OP_SGET_BYTE.cpp */
				2275	HANDLE_SGET_X(OP_SGET_BYTE, "", Int, )
				2276	OP_END
				2277
				2278	/* File: c/OP_SGET_CHAR.cpp */
				2279	HANDLE_SGET_X(OP_SGET_CHAR, "", Int, )
				2280	OP_END
				2281
				2282	/* File: c/OP_SGET_SHORT.cpp */
				2283	HANDLE_SGET_X(OP_SGET_SHORT, "", Int, )
				2284	OP_END
				2285
				2286	/* File: c/OP_SPUT.cpp */
				2287	HANDLE_SPUT_X(OP_SPUT, "", Int, )
				2288	OP_END
				2289
				2290	/* File: c/OP_SPUT_WIDE.cpp */
				2291	HANDLE_SPUT_X(OP_SPUT_WIDE, "-wide", Long, _WIDE)
				2292	OP_END
				2293
				2294	/* File: c/OP_SPUT_OBJECT.cpp */
				2295	HANDLE_SPUT_X(OP_SPUT_OBJECT, "-object", Object, _AS_OBJECT)
				2296	OP_END
				2297
				2298	/* File: c/OP_SPUT_BOOLEAN.cpp */
				2299	HANDLE_SPUT_X(OP_SPUT_BOOLEAN, "", Int, )
				2300	OP_END
				2301
				2302	/* File: c/OP_SPUT_BYTE.cpp */
				2303	HANDLE_SPUT_X(OP_SPUT_BYTE, "", Int, )
				2304	OP_END
				2305
				2306	/* File: c/OP_SPUT_CHAR.cpp */
				2307	HANDLE_SPUT_X(OP_SPUT_CHAR, "", Int, )
				2308	OP_END
				2309
				2310	/* File: c/OP_SPUT_SHORT.cpp */
				2311	HANDLE_SPUT_X(OP_SPUT_SHORT, "", Int, )
				2312	OP_END
				2313
				2314	/* File: c/OP_INVOKE_VIRTUAL.cpp */
				2315	HANDLE_OPCODE(OP_INVOKE_VIRTUAL /vB, {vD, vE, vF, vG, vA}, meth@CCCC/)
				2316	GOTO_invoke(invokeVirtual, false, false);
				2317	OP_END
				2318
				2319	/* File: c/OP_INVOKE_SUPER.cpp */
				2320	HANDLE_OPCODE(OP_INVOKE_SUPER /vB, {vD, vE, vF, vG, vA}, meth@CCCC/)
				2321	GOTO_invoke(invokeSuper, false, false);
				2322	OP_END
				2323
				2324	/* File: c/OP_INVOKE_DIRECT.cpp */
				2325	HANDLE_OPCODE(OP_INVOKE_DIRECT /vB, {vD, vE, vF, vG, vA}, meth@CCCC/)
				2326	GOTO_invoke(invokeDirect, false, false);
				2327	OP_END
				2328
				2329	/* File: c/OP_INVOKE_STATIC.cpp */
				2330	HANDLE_OPCODE(OP_INVOKE_STATIC /vB, {vD, vE, vF, vG, vA}, meth@CCCC/)
				2331	GOTO_invoke(invokeStatic, false, false);
				2332	OP_END
				2333
				2334	/* File: c/OP_INVOKE_INTERFACE.cpp */
				2335	HANDLE_OPCODE(OP_INVOKE_INTERFACE /vB, {vD, vE, vF, vG, vA}, meth@CCCC/)
				2336	GOTO_invoke(invokeInterface, false, false);
				2337	OP_END
				2338
				2339	/* File: c/OP_UNUSED_73.cpp */
				2340	HANDLE_OPCODE(OP_UNUSED_73)
				2341	OP_END
				2342
				2343	/* File: c/OP_INVOKE_VIRTUAL_RANGE.cpp */
				2344	HANDLE_OPCODE(OP_INVOKE_VIRTUAL_RANGE /{vCCCC..v(CCCC+AA-1)}, meth@BBBB/)
				2345	GOTO_invoke(invokeVirtual, true, false);
				2346	OP_END
				2347
				2348	/* File: c/OP_INVOKE_SUPER_RANGE.cpp */
				2349	HANDLE_OPCODE(OP_INVOKE_SUPER_RANGE /{vCCCC..v(CCCC+AA-1)}, meth@BBBB/)
				2350	GOTO_invoke(invokeSuper, true, false);
				2351	OP_END
				2352
				2353	/* File: c/OP_INVOKE_DIRECT_RANGE.cpp */
				2354	HANDLE_OPCODE(OP_INVOKE_DIRECT_RANGE /{vCCCC..v(CCCC+AA-1)}, meth@BBBB/)
				2355	GOTO_invoke(invokeDirect, true, false);
				2356	OP_END
				2357
				2358	/* File: c/OP_INVOKE_STATIC_RANGE.cpp */
				2359	HANDLE_OPCODE(OP_INVOKE_STATIC_RANGE /{vCCCC..v(CCCC+AA-1)}, meth@BBBB/)
				2360	GOTO_invoke(invokeStatic, true, false);
				2361	OP_END
				2362
				2363	/* File: c/OP_INVOKE_INTERFACE_RANGE.cpp */
				2364	HANDLE_OPCODE(OP_INVOKE_INTERFACE_RANGE /{vCCCC..v(CCCC+AA-1)}, meth@BBBB/)
				2365	GOTO_invoke(invokeInterface, true, false);
				2366	OP_END
				2367
				2368	/* File: c/OP_UNUSED_79.cpp */
				2369	HANDLE_OPCODE(OP_UNUSED_79)
				2370	OP_END
				2371
				2372	/* File: c/OP_UNUSED_7A.cpp */
				2373	HANDLE_OPCODE(OP_UNUSED_7A)
				2374	OP_END
				2375
				2376	/* File: c/OP_NEG_INT.cpp */
				2377	HANDLE_UNOP(OP_NEG_INT, "neg-int", -, , )
				2378	OP_END
				2379
				2380	/* File: c/OP_NOT_INT.cpp */
				2381	HANDLE_UNOP(OP_NOT_INT, "not-int", , ^ 0xffffffff, )
				2382	OP_END
				2383
				2384	/* File: c/OP_NEG_LONG.cpp */
				2385	HANDLE_UNOP(OP_NEG_LONG, "neg-long", -, , _WIDE)
				2386	OP_END
				2387
				2388	/* File: c/OP_NOT_LONG.cpp */
				2389	HANDLE_UNOP(OP_NOT_LONG, "not-long", , ^ 0xffffffffffffffffULL, _WIDE)
				2390	OP_END
				2391
				2392	/* File: c/OP_NEG_FLOAT.cpp */
				2393	HANDLE_UNOP(OP_NEG_FLOAT, "neg-float", -, , _FLOAT)
				2394	OP_END
				2395
				2396	/* File: c/OP_NEG_DOUBLE.cpp */
				2397	HANDLE_UNOP(OP_NEG_DOUBLE, "neg-double", -, , _DOUBLE)
				2398	OP_END
				2399
				2400	/* File: c/OP_INT_TO_LONG.cpp */
				2401	HANDLE_NUMCONV(OP_INT_TO_LONG, "int-to-long", _INT, _WIDE)
				2402	OP_END
				2403
				2404	/* File: c/OP_INT_TO_FLOAT.cpp */
				2405	HANDLE_NUMCONV(OP_INT_TO_FLOAT, "int-to-float", _INT, _FLOAT)
				2406	OP_END
				2407
				2408	/* File: c/OP_INT_TO_DOUBLE.cpp */
				2409	HANDLE_NUMCONV(OP_INT_TO_DOUBLE, "int-to-double", _INT, _DOUBLE)
				2410	OP_END
				2411
				2412	/* File: c/OP_LONG_TO_INT.cpp */
				2413	HANDLE_NUMCONV(OP_LONG_TO_INT, "long-to-int", _WIDE, _INT)
				2414	OP_END
				2415
				2416	/* File: c/OP_LONG_TO_FLOAT.cpp */
				2417	HANDLE_NUMCONV(OP_LONG_TO_FLOAT, "long-to-float", _WIDE, _FLOAT)
				2418	OP_END
				2419
				2420	/* File: c/OP_LONG_TO_DOUBLE.cpp */
				2421	HANDLE_NUMCONV(OP_LONG_TO_DOUBLE, "long-to-double", _WIDE, _DOUBLE)
				2422	OP_END
				2423
				2424	/* File: c/OP_FLOAT_TO_INT.cpp */
				2425	HANDLE_FLOAT_TO_INT(OP_FLOAT_TO_INT, "float-to-int",
				2426	float, _FLOAT, s4, _INT)
				2427	OP_END
				2428
				2429	/* File: c/OP_FLOAT_TO_LONG.cpp */
				2430	HANDLE_FLOAT_TO_INT(OP_FLOAT_TO_LONG, "float-to-long",
				2431	float, _FLOAT, s8, _WIDE)
				2432	OP_END
				2433
				2434	/* File: c/OP_FLOAT_TO_DOUBLE.cpp */
				2435	HANDLE_NUMCONV(OP_FLOAT_TO_DOUBLE, "float-to-double", _FLOAT, _DOUBLE)
				2436	OP_END
				2437
				2438	/* File: c/OP_DOUBLE_TO_INT.cpp */
				2439	HANDLE_FLOAT_TO_INT(OP_DOUBLE_TO_INT, "double-to-int",
				2440	double, _DOUBLE, s4, _INT)
				2441	OP_END
				2442
				2443	/* File: c/OP_DOUBLE_TO_LONG.cpp */
				2444	HANDLE_FLOAT_TO_INT(OP_DOUBLE_TO_LONG, "double-to-long",
				2445	double, _DOUBLE, s8, _WIDE)
				2446	OP_END
				2447
				2448	/* File: c/OP_DOUBLE_TO_FLOAT.cpp */
				2449	HANDLE_NUMCONV(OP_DOUBLE_TO_FLOAT, "double-to-float", _DOUBLE, _FLOAT)
				2450	OP_END
				2451
				2452	/* File: c/OP_INT_TO_BYTE.cpp */
				2453	HANDLE_INT_TO_SMALL(OP_INT_TO_BYTE, "byte", s1)
				2454	OP_END
				2455
				2456	/* File: c/OP_INT_TO_CHAR.cpp */
				2457	HANDLE_INT_TO_SMALL(OP_INT_TO_CHAR, "char", u2)
				2458	OP_END
				2459
				2460	/* File: c/OP_INT_TO_SHORT.cpp */
				2461	HANDLE_INT_TO_SMALL(OP_INT_TO_SHORT, "short", s2) /* want sign bit */
				2462	OP_END
				2463
				2464	/* File: c/OP_ADD_INT.cpp */
				2465	HANDLE_OP_X_INT(OP_ADD_INT, "add", +, 0)
				2466	OP_END
				2467
				2468	/* File: c/OP_SUB_INT.cpp */
				2469	HANDLE_OP_X_INT(OP_SUB_INT, "sub", -, 0)
				2470	OP_END
				2471
				2472	/* File: c/OP_MUL_INT.cpp */
				2473	HANDLE_OP_X_INT(OP_MUL_INT, "mul", *, 0)
				2474	OP_END
				2475
				2476	/* File: c/OP_DIV_INT.cpp */
				2477	HANDLE_OP_X_INT(OP_DIV_INT, "div", /, 1)
				2478	OP_END
				2479
				2480	/* File: c/OP_REM_INT.cpp */
				2481	HANDLE_OP_X_INT(OP_REM_INT, "rem", %, 2)
				2482	OP_END
				2483
				2484	/* File: c/OP_AND_INT.cpp */
				2485	HANDLE_OP_X_INT(OP_AND_INT, "and", &, 0)
				2486	OP_END
				2487
				2488	/* File: c/OP_OR_INT.cpp */
				2489	HANDLE_OP_X_INT(OP_OR_INT, "or", \|, 0)
				2490	OP_END
				2491
				2492	/* File: c/OP_XOR_INT.cpp */
				2493	HANDLE_OP_X_INT(OP_XOR_INT, "xor", ^, 0)
				2494	OP_END
				2495
				2496	/* File: c/OP_SHL_INT.cpp */
				2497	HANDLE_OP_SHX_INT(OP_SHL_INT, "shl", (s4), <<)
				2498	OP_END
				2499
				2500	/* File: c/OP_SHR_INT.cpp */
				2501	HANDLE_OP_SHX_INT(OP_SHR_INT, "shr", (s4), >>)
				2502	OP_END
				2503
				2504	/* File: c/OP_USHR_INT.cpp */
				2505	HANDLE_OP_SHX_INT(OP_USHR_INT, "ushr", (u4), >>)
				2506	OP_END
				2507
				2508	/* File: c/OP_ADD_LONG.cpp */
				2509	HANDLE_OP_X_LONG(OP_ADD_LONG, "add", +, 0)
				2510	OP_END
				2511
				2512	/* File: c/OP_SUB_LONG.cpp */
				2513	HANDLE_OP_X_LONG(OP_SUB_LONG, "sub", -, 0)
				2514	OP_END
				2515
				2516	/* File: c/OP_MUL_LONG.cpp */
				2517	HANDLE_OP_X_LONG(OP_MUL_LONG, "mul", *, 0)
				2518	OP_END
				2519
				2520	/* File: c/OP_DIV_LONG.cpp */
				2521	HANDLE_OP_X_LONG(OP_DIV_LONG, "div", /, 1)
				2522	OP_END
				2523
				2524	/* File: c/OP_REM_LONG.cpp */
				2525	HANDLE_OP_X_LONG(OP_REM_LONG, "rem", %, 2)
				2526	OP_END
				2527
				2528	/* File: c/OP_AND_LONG.cpp */
				2529	HANDLE_OP_X_LONG(OP_AND_LONG, "and", &, 0)
				2530	OP_END
				2531
				2532	/* File: c/OP_OR_LONG.cpp */
				2533	HANDLE_OP_X_LONG(OP_OR_LONG, "or", \|, 0)
				2534	OP_END
				2535
				2536	/* File: c/OP_XOR_LONG.cpp */
				2537	HANDLE_OP_X_LONG(OP_XOR_LONG, "xor", ^, 0)
				2538	OP_END
				2539
				2540	/* File: c/OP_SHL_LONG.cpp */
				2541	HANDLE_OP_SHX_LONG(OP_SHL_LONG, "shl", (s8), <<)
				2542	OP_END
				2543
				2544	/* File: c/OP_SHR_LONG.cpp */
				2545	HANDLE_OP_SHX_LONG(OP_SHR_LONG, "shr", (s8), >>)
				2546	OP_END
				2547
				2548	/* File: c/OP_USHR_LONG.cpp */
				2549	HANDLE_OP_SHX_LONG(OP_USHR_LONG, "ushr", (u8), >>)
				2550	OP_END
				2551
				2552	/* File: c/OP_ADD_FLOAT.cpp */
				2553	HANDLE_OP_X_FLOAT(OP_ADD_FLOAT, "add", +)
				2554	OP_END
				2555
				2556	/* File: c/OP_SUB_FLOAT.cpp */
				2557	HANDLE_OP_X_FLOAT(OP_SUB_FLOAT, "sub", -)
				2558	OP_END
				2559
				2560	/* File: c/OP_MUL_FLOAT.cpp */
				2561	HANDLE_OP_X_FLOAT(OP_MUL_FLOAT, "mul", *)
				2562	OP_END
				2563
				2564	/* File: c/OP_DIV_FLOAT.cpp */
				2565	HANDLE_OP_X_FLOAT(OP_DIV_FLOAT, "div", /)
				2566	OP_END
				2567
				2568	/* File: c/OP_REM_FLOAT.cpp */
				2569	HANDLE_OPCODE(OP_REM_FLOAT /vAA, vBB, vCC/)
				2570	{
				2571	u2 srcRegs;
				2572	vdst = INST_AA(inst);
				2573	srcRegs = FETCH(1);
				2574	vsrc1 = srcRegs & 0xff;
				2575	vsrc2 = srcRegs >> 8;
				2576	ILOGV("\|%s-float v%d,v%d,v%d", "mod", vdst, vsrc1, vsrc2);
				2577	SET_REGISTER_FLOAT(vdst,
				2578	fmodf(GET_REGISTER_FLOAT(vsrc1), GET_REGISTER_FLOAT(vsrc2)));
				2579	}
				2580	FINISH(2);
				2581	OP_END
				2582
				2583	/* File: c/OP_ADD_DOUBLE.cpp */
				2584	HANDLE_OP_X_DOUBLE(OP_ADD_DOUBLE, "add", +)
				2585	OP_END
				2586
				2587	/* File: c/OP_SUB_DOUBLE.cpp */
				2588	HANDLE_OP_X_DOUBLE(OP_SUB_DOUBLE, "sub", -)
				2589	OP_END
				2590
				2591	/* File: c/OP_MUL_DOUBLE.cpp */
				2592	HANDLE_OP_X_DOUBLE(OP_MUL_DOUBLE, "mul", *)
				2593	OP_END
				2594
				2595	/* File: c/OP_DIV_DOUBLE.cpp */
				2596	HANDLE_OP_X_DOUBLE(OP_DIV_DOUBLE, "div", /)
				2597	OP_END
				2598
				2599	/* File: c/OP_REM_DOUBLE.cpp */
				2600	HANDLE_OPCODE(OP_REM_DOUBLE /vAA, vBB, vCC/)
				2601	{
				2602	u2 srcRegs;
				2603	vdst = INST_AA(inst);
				2604	srcRegs = FETCH(1);
				2605	vsrc1 = srcRegs & 0xff;
				2606	vsrc2 = srcRegs >> 8;
				2607	ILOGV("\|%s-double v%d,v%d,v%d", "mod", vdst, vsrc1, vsrc2);
				2608	SET_REGISTER_DOUBLE(vdst,
				2609	fmod(GET_REGISTER_DOUBLE(vsrc1), GET_REGISTER_DOUBLE(vsrc2)));
				2610	}
				2611	FINISH(2);
				2612	OP_END
				2613
				2614	/* File: c/OP_ADD_INT_2ADDR.cpp */
				2615	HANDLE_OP_X_INT_2ADDR(OP_ADD_INT_2ADDR, "add", +, 0)
				2616	OP_END
				2617
				2618	/* File: c/OP_SUB_INT_2ADDR.cpp */
				2619	HANDLE_OP_X_INT_2ADDR(OP_SUB_INT_2ADDR, "sub", -, 0)
				2620	OP_END
				2621
				2622	/* File: c/OP_MUL_INT_2ADDR.cpp */
				2623	HANDLE_OP_X_INT_2ADDR(OP_MUL_INT_2ADDR, "mul", *, 0)
				2624	OP_END
				2625
				2626	/* File: c/OP_DIV_INT_2ADDR.cpp */
				2627	HANDLE_OP_X_INT_2ADDR(OP_DIV_INT_2ADDR, "div", /, 1)
				2628	OP_END
				2629
				2630	/* File: c/OP_REM_INT_2ADDR.cpp */
				2631	HANDLE_OP_X_INT_2ADDR(OP_REM_INT_2ADDR, "rem", %, 2)
				2632	OP_END
				2633
				2634	/* File: c/OP_AND_INT_2ADDR.cpp */
				2635	HANDLE_OP_X_INT_2ADDR(OP_AND_INT_2ADDR, "and", &, 0)
				2636	OP_END
				2637
				2638	/* File: c/OP_OR_INT_2ADDR.cpp */
				2639	HANDLE_OP_X_INT_2ADDR(OP_OR_INT_2ADDR, "or", \|, 0)
				2640	OP_END
				2641
				2642	/* File: c/OP_XOR_INT_2ADDR.cpp */
				2643	HANDLE_OP_X_INT_2ADDR(OP_XOR_INT_2ADDR, "xor", ^, 0)
				2644	OP_END
				2645
				2646	/* File: c/OP_SHL_INT_2ADDR.cpp */
				2647	HANDLE_OP_SHX_INT_2ADDR(OP_SHL_INT_2ADDR, "shl", (s4), <<)
				2648	OP_END
				2649
				2650	/* File: c/OP_SHR_INT_2ADDR.cpp */
				2651	HANDLE_OP_SHX_INT_2ADDR(OP_SHR_INT_2ADDR, "shr", (s4), >>)
				2652	OP_END
				2653
				2654	/* File: c/OP_USHR_INT_2ADDR.cpp */
				2655	HANDLE_OP_SHX_INT_2ADDR(OP_USHR_INT_2ADDR, "ushr", (u4), >>)
				2656	OP_END
				2657
				2658	/* File: c/OP_ADD_LONG_2ADDR.cpp */
				2659	HANDLE_OP_X_LONG_2ADDR(OP_ADD_LONG_2ADDR, "add", +, 0)
				2660	OP_END
				2661
				2662	/* File: c/OP_SUB_LONG_2ADDR.cpp */
				2663	HANDLE_OP_X_LONG_2ADDR(OP_SUB_LONG_2ADDR, "sub", -, 0)
				2664	OP_END
				2665
				2666	/* File: c/OP_MUL_LONG_2ADDR.cpp */
				2667	HANDLE_OP_X_LONG_2ADDR(OP_MUL_LONG_2ADDR, "mul", *, 0)
				2668	OP_END
				2669
				2670	/* File: c/OP_DIV_LONG_2ADDR.cpp */
				2671	HANDLE_OP_X_LONG_2ADDR(OP_DIV_LONG_2ADDR, "div", /, 1)
				2672	OP_END
				2673
				2674	/* File: c/OP_REM_LONG_2ADDR.cpp */
				2675	HANDLE_OP_X_LONG_2ADDR(OP_REM_LONG_2ADDR, "rem", %, 2)
				2676	OP_END
				2677
				2678	/* File: c/OP_AND_LONG_2ADDR.cpp */
				2679	HANDLE_OP_X_LONG_2ADDR(OP_AND_LONG_2ADDR, "and", &, 0)
				2680	OP_END
				2681
				2682	/* File: c/OP_OR_LONG_2ADDR.cpp */
				2683	HANDLE_OP_X_LONG_2ADDR(OP_OR_LONG_2ADDR, "or", \|, 0)
				2684	OP_END
				2685
				2686	/* File: c/OP_XOR_LONG_2ADDR.cpp */
				2687	HANDLE_OP_X_LONG_2ADDR(OP_XOR_LONG_2ADDR, "xor", ^, 0)
				2688	OP_END
				2689
				2690	/* File: c/OP_SHL_LONG_2ADDR.cpp */
				2691	HANDLE_OP_SHX_LONG_2ADDR(OP_SHL_LONG_2ADDR, "shl", (s8), <<)
				2692	OP_END
				2693
				2694	/* File: c/OP_SHR_LONG_2ADDR.cpp */
				2695	HANDLE_OP_SHX_LONG_2ADDR(OP_SHR_LONG_2ADDR, "shr", (s8), >>)
				2696	OP_END
				2697
				2698	/* File: c/OP_USHR_LONG_2ADDR.cpp */
				2699	HANDLE_OP_SHX_LONG_2ADDR(OP_USHR_LONG_2ADDR, "ushr", (u8), >>)
				2700	OP_END
				2701
				2702	/* File: c/OP_ADD_FLOAT_2ADDR.cpp */
				2703	HANDLE_OP_X_FLOAT_2ADDR(OP_ADD_FLOAT_2ADDR, "add", +)
				2704	OP_END
				2705
				2706	/* File: c/OP_SUB_FLOAT_2ADDR.cpp */
				2707	HANDLE_OP_X_FLOAT_2ADDR(OP_SUB_FLOAT_2ADDR, "sub", -)
				2708	OP_END
				2709
				2710	/* File: c/OP_MUL_FLOAT_2ADDR.cpp */
				2711	HANDLE_OP_X_FLOAT_2ADDR(OP_MUL_FLOAT_2ADDR, "mul", *)
				2712	OP_END
				2713
				2714	/* File: c/OP_DIV_FLOAT_2ADDR.cpp */
				2715	HANDLE_OP_X_FLOAT_2ADDR(OP_DIV_FLOAT_2ADDR, "div", /)
				2716	OP_END
				2717
				2718	/* File: c/OP_REM_FLOAT_2ADDR.cpp */
				2719	HANDLE_OPCODE(OP_REM_FLOAT_2ADDR /vA, vB/)
				2720	vdst = INST_A(inst);
				2721	vsrc1 = INST_B(inst);
				2722	ILOGV("\|%s-float-2addr v%d,v%d", "mod", vdst, vsrc1);
				2723	SET_REGISTER_FLOAT(vdst,
				2724	fmodf(GET_REGISTER_FLOAT(vdst), GET_REGISTER_FLOAT(vsrc1)));
				2725	FINISH(1);
				2726	OP_END
				2727
				2728	/* File: c/OP_ADD_DOUBLE_2ADDR.cpp */
				2729	HANDLE_OP_X_DOUBLE_2ADDR(OP_ADD_DOUBLE_2ADDR, "add", +)
				2730	OP_END
				2731
				2732	/* File: c/OP_SUB_DOUBLE_2ADDR.cpp */
				2733	HANDLE_OP_X_DOUBLE_2ADDR(OP_SUB_DOUBLE_2ADDR, "sub", -)
				2734	OP_END
				2735
				2736	/* File: c/OP_MUL_DOUBLE_2ADDR.cpp */
				2737	HANDLE_OP_X_DOUBLE_2ADDR(OP_MUL_DOUBLE_2ADDR, "mul", *)
				2738	OP_END
				2739
				2740	/* File: c/OP_DIV_DOUBLE_2ADDR.cpp */
				2741	HANDLE_OP_X_DOUBLE_2ADDR(OP_DIV_DOUBLE_2ADDR, "div", /)
				2742	OP_END
				2743
				2744	/* File: c/OP_REM_DOUBLE_2ADDR.cpp */
				2745	HANDLE_OPCODE(OP_REM_DOUBLE_2ADDR /vA, vB/)
				2746	vdst = INST_A(inst);
				2747	vsrc1 = INST_B(inst);
				2748	ILOGV("\|%s-double-2addr v%d,v%d", "mod", vdst, vsrc1);
				2749	SET_REGISTER_DOUBLE(vdst,
				2750	fmod(GET_REGISTER_DOUBLE(vdst), GET_REGISTER_DOUBLE(vsrc1)));
				2751	FINISH(1);
				2752	OP_END
				2753
				2754	/* File: c/OP_ADD_INT_LIT16.cpp */
				2755	HANDLE_OP_X_INT_LIT16(OP_ADD_INT_LIT16, "add", +, 0)
				2756	OP_END
				2757
				2758	/* File: c/OP_RSUB_INT.cpp */
				2759	HANDLE_OPCODE(OP_RSUB_INT /vA, vB, #+CCCC/)
				2760	{
				2761	vdst = INST_A(inst);
				2762	vsrc1 = INST_B(inst);
				2763	vsrc2 = FETCH(1);
				2764	ILOGV("\|rsub-int v%d,v%d,#+0x%04x", vdst, vsrc1, vsrc2);
				2765	SET_REGISTER(vdst, (s2) vsrc2 - (s4) GET_REGISTER(vsrc1));
				2766	}
				2767	FINISH(2);
				2768	OP_END
				2769
				2770	/* File: c/OP_MUL_INT_LIT16.cpp */
				2771	HANDLE_OP_X_INT_LIT16(OP_MUL_INT_LIT16, "mul", *, 0)
				2772	OP_END
				2773
				2774	/* File: c/OP_DIV_INT_LIT16.cpp */
				2775	HANDLE_OP_X_INT_LIT16(OP_DIV_INT_LIT16, "div", /, 1)
				2776	OP_END
				2777
				2778	/* File: c/OP_REM_INT_LIT16.cpp */
				2779	HANDLE_OP_X_INT_LIT16(OP_REM_INT_LIT16, "rem", %, 2)
				2780	OP_END
				2781
				2782	/* File: c/OP_AND_INT_LIT16.cpp */
				2783	HANDLE_OP_X_INT_LIT16(OP_AND_INT_LIT16, "and", &, 0)
				2784	OP_END
				2785
				2786	/* File: c/OP_OR_INT_LIT16.cpp */
				2787	HANDLE_OP_X_INT_LIT16(OP_OR_INT_LIT16, "or", \|, 0)
				2788	OP_END
				2789
				2790	/* File: c/OP_XOR_INT_LIT16.cpp */
				2791	HANDLE_OP_X_INT_LIT16(OP_XOR_INT_LIT16, "xor", ^, 0)
				2792	OP_END
				2793
				2794	/* File: c/OP_ADD_INT_LIT8.cpp */
				2795	HANDLE_OP_X_INT_LIT8(OP_ADD_INT_LIT8, "add", +, 0)
				2796	OP_END
				2797
				2798	/* File: c/OP_RSUB_INT_LIT8.cpp */
				2799	HANDLE_OPCODE(OP_RSUB_INT_LIT8 /vAA, vBB, #+CC/)
				2800	{
				2801	u2 litInfo;
				2802	vdst = INST_AA(inst);
				2803	litInfo = FETCH(1);
				2804	vsrc1 = litInfo & 0xff;
				2805	vsrc2 = litInfo >> 8;
				2806	ILOGV("\|%s-int/lit8 v%d,v%d,#+0x%02x", "rsub", vdst, vsrc1, vsrc2);
				2807	SET_REGISTER(vdst, (s1) vsrc2 - (s4) GET_REGISTER(vsrc1));
				2808	}
				2809	FINISH(2);
				2810	OP_END
				2811
				2812	/* File: c/OP_MUL_INT_LIT8.cpp */
				2813	HANDLE_OP_X_INT_LIT8(OP_MUL_INT_LIT8, "mul", *, 0)
				2814	OP_END
				2815
				2816	/* File: c/OP_DIV_INT_LIT8.cpp */
				2817	HANDLE_OP_X_INT_LIT8(OP_DIV_INT_LIT8, "div", /, 1)
				2818	OP_END
				2819
				2820	/* File: c/OP_REM_INT_LIT8.cpp */
				2821	HANDLE_OP_X_INT_LIT8(OP_REM_INT_LIT8, "rem", %, 2)
				2822	OP_END
				2823
				2824	/* File: c/OP_AND_INT_LIT8.cpp */
				2825	HANDLE_OP_X_INT_LIT8(OP_AND_INT_LIT8, "and", &, 0)
				2826	OP_END
				2827
				2828	/* File: c/OP_OR_INT_LIT8.cpp */
				2829	HANDLE_OP_X_INT_LIT8(OP_OR_INT_LIT8, "or", \|, 0)
				2830	OP_END
				2831
				2832	/* File: c/OP_XOR_INT_LIT8.cpp */
				2833	HANDLE_OP_X_INT_LIT8(OP_XOR_INT_LIT8, "xor", ^, 0)
				2834	OP_END
				2835
				2836	/* File: c/OP_SHL_INT_LIT8.cpp */
				2837	HANDLE_OP_SHX_INT_LIT8(OP_SHL_INT_LIT8, "shl", (s4), <<)
				2838	OP_END
				2839
				2840	/* File: c/OP_SHR_INT_LIT8.cpp */
				2841	HANDLE_OP_SHX_INT_LIT8(OP_SHR_INT_LIT8, "shr", (s4), >>)
				2842	OP_END
				2843
				2844	/* File: c/OP_USHR_INT_LIT8.cpp */
				2845	HANDLE_OP_SHX_INT_LIT8(OP_USHR_INT_LIT8, "ushr", (u4), >>)
				2846	OP_END
				2847
				2848	/* File: c/OP_IGET_VOLATILE.cpp */
				2849	HANDLE_IGET_X(OP_IGET_VOLATILE, "-volatile", IntVolatile, )
				2850	OP_END
				2851
				2852	/* File: c/OP_IPUT_VOLATILE.cpp */
				2853	HANDLE_IPUT_X(OP_IPUT_VOLATILE, "-volatile", IntVolatile, )
				2854	OP_END
				2855
				2856	/* File: c/OP_SGET_VOLATILE.cpp */
				2857	HANDLE_SGET_X(OP_SGET_VOLATILE, "-volatile", IntVolatile, )
				2858	OP_END
				2859
				2860	/* File: c/OP_SPUT_VOLATILE.cpp */
				2861	HANDLE_SPUT_X(OP_SPUT_VOLATILE, "-volatile", IntVolatile, )
				2862	OP_END
				2863
				2864	/* File: c/OP_IGET_OBJECT_VOLATILE.cpp */
				2865	HANDLE_IGET_X(OP_IGET_OBJECT_VOLATILE, "-object-volatile", ObjectVolatile, _AS_OBJECT)
				2866	OP_END
				2867
				2868	/* File: c/OP_IGET_WIDE_VOLATILE.cpp */
				2869	HANDLE_IGET_X(OP_IGET_WIDE_VOLATILE, "-wide-volatile", LongVolatile, _WIDE)
				2870	OP_END
				2871
				2872	/* File: c/OP_IPUT_WIDE_VOLATILE.cpp */
				2873	HANDLE_IPUT_X(OP_IPUT_WIDE_VOLATILE, "-wide-volatile", LongVolatile, _WIDE)
				2874	OP_END
				2875
				2876	/* File: c/OP_SGET_WIDE_VOLATILE.cpp */
				2877	HANDLE_SGET_X(OP_SGET_WIDE_VOLATILE, "-wide-volatile", LongVolatile, _WIDE)
				2878	OP_END
				2879
				2880	/* File: c/OP_SPUT_WIDE_VOLATILE.cpp */
				2881	HANDLE_SPUT_X(OP_SPUT_WIDE_VOLATILE, "-wide-volatile", LongVolatile, _WIDE)
				2882	OP_END
				2883
				2884	/* File: c/OP_BREAKPOINT.cpp */
				2885	HANDLE_OPCODE(OP_BREAKPOINT)
				2886	{
				2887	/*
				2888	* Restart this instruction with the original opcode. We do
				2889	* this by simply jumping to the handler.
				2890	*
				2891	* It's probably not necessary to update "inst", but we do it
				2892	* for the sake of anything that needs to do disambiguation in a
				2893	* common handler with INST_INST.
				2894	*
				2895	* The breakpoint itself is handled over in updateDebugger(),
				2896	* because we need to detect other events (method entry, single
				2897	* step) and report them in the same event packet, and we're not
				2898	* yet handling those through breakpoint instructions. By the
				2899	* time we get here, the breakpoint has already been handled and
				2900	* the thread resumed.
				2901	*/
				2902	u1 originalOpcode = dvmGetOriginalOpcode(pc);
				2903	LOGV("+++ break 0x%02x (0x%04x -> 0x%04x)\n", originalOpcode, inst,
				2904	INST_REPLACE_OP(inst, originalOpcode));
				2905	inst = INST_REPLACE_OP(inst, originalOpcode);
				2906	FINISH_BKPT(originalOpcode);
				2907	}
				2908	OP_END
				2909
				2910	/* File: c/OP_THROW_VERIFICATION_ERROR.cpp */
				2911	HANDLE_OPCODE(OP_THROW_VERIFICATION_ERROR)
				2912	EXPORT_PC();
				2913	vsrc1 = INST_AA(inst);
				2914	ref = FETCH(1); /* class/field/method ref */
				2915	dvmThrowVerificationError(curMethod, vsrc1, ref);
				2916	GOTO_exceptionThrown();
				2917	OP_END
				2918
				2919	/* File: c/OP_EXECUTE_INLINE.cpp */
				2920	HANDLE_OPCODE(OP_EXECUTE_INLINE /vB, {vD, vE, vF, vG}, inline@CCCC/)
				2921	{
				2922	/*
				2923	* This has the same form as other method calls, but we ignore
				2924	* the 5th argument (vA). This is chiefly because the first four
				2925	* arguments to a function on ARM are in registers.
				2926	*
				2927	* We only set the arguments that are actually used, leaving
				2928	* the rest uninitialized. We're assuming that, if the method
				2929	* needs them, they'll be specified in the call.
				2930	*
				2931	* However, this annoys gcc when optimizations are enabled,
				2932	* causing a "may be used uninitialized" warning. Quieting
				2933	* the warnings incurs a slight penalty (5%: 373ns vs. 393ns
				2934	* on empty method). Note that valgrind is perfectly happy
				2935	* either way as the uninitialiezd values are never actually
				2936	* used.
				2937	*/
				2938	u4 arg0, arg1, arg2, arg3;
				2939	arg0 = arg1 = arg2 = arg3 = 0;
				2940
				2941	EXPORT_PC();
				2942
				2943	vsrc1 = INST_B(inst); /* #of args */
				2944	ref = FETCH(1); /* inline call "ref" */
				2945	vdst = FETCH(2); /* 0-4 register indices */
				2946	ILOGV("\|execute-inline args=%d @%d {regs=0x%04x}",
				2947	vsrc1, ref, vdst);
				2948
				2949	assert((vdst >> 16) == 0); // 16-bit type -or- high 16 bits clear
				2950	assert(vsrc1 <= 4);
				2951
				2952	switch (vsrc1) {
				2953	case 4:
				2954	arg3 = GET_REGISTER(vdst >> 12);
				2955	/* fall through */
				2956	case 3:
				2957	arg2 = GET_REGISTER((vdst & 0x0f00) >> 8);
				2958	/* fall through */
				2959	case 2:
				2960	arg1 = GET_REGISTER((vdst & 0x00f0) >> 4);
				2961	/* fall through */
				2962	case 1:
				2963	arg0 = GET_REGISTER(vdst & 0x0f);
				2964	/* fall through */
				2965	default: // case 0
				2966	;
				2967	}
				2968
				2969	if (self->interpBreak.ctl.subMode & kSubModeDebuggerActive) {
				2970	if (!dvmPerformInlineOp4Dbg(arg0, arg1, arg2, arg3, &retval, ref))
				2971	GOTO_exceptionThrown();
				2972	} else {
				2973	if (!dvmPerformInlineOp4Std(arg0, arg1, arg2, arg3, &retval, ref))
				2974	GOTO_exceptionThrown();
				2975	}
				2976	}
				2977	FINISH(3);
				2978	OP_END
				2979
				2980	/* File: c/OP_EXECUTE_INLINE_RANGE.cpp */
				2981	HANDLE_OPCODE(OP_EXECUTE_INLINE_RANGE /{vCCCC..v(CCCC+AA-1)}, inline@BBBB/)
				2982	{
				2983	u4 arg0, arg1, arg2, arg3;
				2984	arg0 = arg1 = arg2 = arg3 = 0; /* placate gcc */
				2985
				2986	EXPORT_PC();
				2987
				2988	vsrc1 = INST_AA(inst); /* #of args */
				2989	ref = FETCH(1); /* inline call "ref" */
				2990	vdst = FETCH(2); /* range base */
				2991	ILOGV("\|execute-inline-range args=%d @%d {regs=v%d-v%d}",
				2992	vsrc1, ref, vdst, vdst+vsrc1-1);
				2993
				2994	assert((vdst >> 16) == 0); // 16-bit type -or- high 16 bits clear
				2995	assert(vsrc1 <= 4);
				2996
				2997	switch (vsrc1) {
				2998	case 4:
				2999	arg3 = GET_REGISTER(vdst+3);
				3000	/* fall through */
				3001	case 3:
				3002	arg2 = GET_REGISTER(vdst+2);
				3003	/* fall through */
				3004	case 2:
				3005	arg1 = GET_REGISTER(vdst+1);
				3006	/* fall through */
				3007	case 1:
				3008	arg0 = GET_REGISTER(vdst+0);
				3009	/* fall through */
				3010	default: // case 0
				3011	;
				3012	}
				3013
				3014	if (self->interpBreak.ctl.subMode & kSubModeDebuggerActive) {
				3015	if (!dvmPerformInlineOp4Dbg(arg0, arg1, arg2, arg3, &retval, ref))
				3016	GOTO_exceptionThrown();
				3017	} else {
				3018	if (!dvmPerformInlineOp4Std(arg0, arg1, arg2, arg3, &retval, ref))
				3019	GOTO_exceptionThrown();
				3020	}
				3021	}
				3022	FINISH(3);
				3023	OP_END
				3024
				3025	/* File: c/OP_INVOKE_OBJECT_INIT_RANGE.cpp */
				3026	HANDLE_OPCODE(OP_INVOKE_OBJECT_INIT_RANGE /{vCCCC..v(CCCC+AA-1)}, meth@BBBB/)
				3027	{
				3028	Object* obj;
				3029
				3030	vsrc1 = FETCH(2); /* reg number of "this" pointer */
				3031	obj = GET_REGISTER_AS_OBJECT(vsrc1);
				3032
				3033	if (!checkForNullExportPC(obj, fp, pc))
				3034	GOTO_exceptionThrown();
				3035
				3036	/*
				3037	* The object should be marked "finalizable" when Object.<init>
				3038	* completes normally. We're going to assume it does complete
				3039	* (by virtue of being nothing but a return-void) and set it now.
				3040	*/
				3041	if (IS_CLASS_FLAG_SET(obj->clazz, CLASS_ISFINALIZABLE)) {
				3042	EXPORT_PC();
				3043	dvmSetFinalizable(obj);
				3044	if (dvmGetException(self))
				3045	GOTO_exceptionThrown();
				3046	}
				3047
				3048	if (self->interpBreak.ctl.subMode & kSubModeDebuggerActive) {
				3049	/* behave like OP_INVOKE_DIRECT_RANGE */
				3050	GOTO_invoke(invokeDirect, true, false);
				3051	}
				3052	FINISH(3);
				3053	}
				3054	OP_END
				3055
				3056	/* File: c/OP_RETURN_VOID_BARRIER.cpp */
				3057	HANDLE_OPCODE(OP_RETURN_VOID_BARRIER /**/)
				3058	ILOGV("\|return-void");
				3059	#ifndef NDEBUG
				3060	retval.j = 0xababababULL; /* placate valgrind */
				3061	#endif
				3062	ANDROID_MEMBAR_STORE();
				3063	GOTO_returnFromMethod();
				3064	OP_END
				3065
				3066	/* File: c/OP_IGET_QUICK.cpp */
				3067	HANDLE_IGET_X_QUICK(OP_IGET_QUICK, "", Int, )
				3068	OP_END
				3069
				3070	/* File: c/OP_IGET_WIDE_QUICK.cpp */
				3071	HANDLE_IGET_X_QUICK(OP_IGET_WIDE_QUICK, "-wide", Long, _WIDE)
				3072	OP_END
				3073
				3074	/* File: c/OP_IGET_OBJECT_QUICK.cpp */
				3075	HANDLE_IGET_X_QUICK(OP_IGET_OBJECT_QUICK, "-object", Object, _AS_OBJECT)
				3076	OP_END
				3077
				3078	/* File: c/OP_IPUT_QUICK.cpp */
				3079	HANDLE_IPUT_X_QUICK(OP_IPUT_QUICK, "", Int, )
				3080	OP_END
				3081
				3082	/* File: c/OP_IPUT_WIDE_QUICK.cpp */
				3083	HANDLE_IPUT_X_QUICK(OP_IPUT_WIDE_QUICK, "-wide", Long, _WIDE)
				3084	OP_END
				3085
				3086	/* File: c/OP_IPUT_OBJECT_QUICK.cpp */
				3087	HANDLE_IPUT_X_QUICK(OP_IPUT_OBJECT_QUICK, "-object", Object, _AS_OBJECT)
				3088	OP_END
				3089
				3090	/* File: c/OP_INVOKE_VIRTUAL_QUICK.cpp */
				3091	HANDLE_OPCODE(OP_INVOKE_VIRTUAL_QUICK /vB, {vD, vE, vF, vG, vA}, meth@CCCC/)
				3092	GOTO_invoke(invokeVirtualQuick, false, false);
				3093	OP_END
				3094
				3095	/* File: c/OP_INVOKE_VIRTUAL_QUICK_RANGE.cpp */
				3096	HANDLE_OPCODE(OP_INVOKE_VIRTUAL_QUICK_RANGE/{vCCCC..v(CCCC+AA-1)}, meth@BBBB/)
				3097	GOTO_invoke(invokeVirtualQuick, true, false);
				3098	OP_END
				3099
				3100	/* File: c/OP_INVOKE_SUPER_QUICK.cpp */
				3101	HANDLE_OPCODE(OP_INVOKE_SUPER_QUICK /vB, {vD, vE, vF, vG, vA}, meth@CCCC/)
				3102	GOTO_invoke(invokeSuperQuick, false, false);
				3103	OP_END
				3104
				3105	/* File: c/OP_INVOKE_SUPER_QUICK_RANGE.cpp */
				3106	HANDLE_OPCODE(OP_INVOKE_SUPER_QUICK_RANGE /{vCCCC..v(CCCC+AA-1)}, meth@BBBB/)
				3107	GOTO_invoke(invokeSuperQuick, true, false);
				3108	OP_END
				3109
				3110	/* File: c/OP_IPUT_OBJECT_VOLATILE.cpp */
				3111	HANDLE_IPUT_X(OP_IPUT_OBJECT_VOLATILE, "-object-volatile", ObjectVolatile, _AS_OBJECT)
				3112	OP_END
				3113
				3114	/* File: c/OP_SGET_OBJECT_VOLATILE.cpp */
				3115	HANDLE_SGET_X(OP_SGET_OBJECT_VOLATILE, "-object-volatile", ObjectVolatile, _AS_OBJECT)
				3116	OP_END
				3117
				3118	/* File: c/OP_SPUT_OBJECT_VOLATILE.cpp */
				3119	HANDLE_SPUT_X(OP_SPUT_OBJECT_VOLATILE, "-object-volatile", ObjectVolatile, _AS_OBJECT)
				3120	OP_END
				3121
				3122	/* File: c/OP_DISPATCH_FF.cpp */
				3123	HANDLE_OPCODE(OP_DISPATCH_FF)
				3124	/*
				3125	* Indicates extended opcode. Use next 8 bits to choose where to branch.
				3126	*/
				3127	DISPATCH_EXTENDED(INST_AA(inst));
				3128	OP_END
				3129
				3130	/* File: c/OP_CONST_CLASS_JUMBO.cpp */
				3131	HANDLE_OPCODE(OP_CONST_CLASS_JUMBO /vBBBB, class@AAAAAAAA/)
				3132	{
				3133	ClassObject* clazz;
				3134
				3135	ref = FETCH(1) \| (u4)FETCH(2) << 16;
				3136	vdst = FETCH(3);
				3137	ILOGV("\|const-class/jumbo v%d class@0x%08x", vdst, ref);
				3138	clazz = dvmDexGetResolvedClass(methodClassDex, ref);
				3139	if (clazz == NULL) {
				3140	EXPORT_PC();
				3141	clazz = dvmResolveClass(curMethod->clazz, ref, true);
				3142	if (clazz == NULL)
				3143	GOTO_exceptionThrown();
				3144	}
				3145	SET_REGISTER(vdst, (u4) clazz);
				3146	}
				3147	FINISH(4);
				3148	OP_END
				3149
				3150	/* File: c/OP_CHECK_CAST_JUMBO.cpp */
				3151	HANDLE_OPCODE(OP_CHECK_CAST_JUMBO /vBBBB, class@AAAAAAAA/)
				3152	{
				3153	ClassObject* clazz;
				3154	Object* obj;
				3155
				3156	EXPORT_PC();
				3157
				3158	ref = FETCH(1) \| (u4)FETCH(2) << 16; /* class to check against */
				3159	vsrc1 = FETCH(3);
				3160	ILOGV("\|check-cast/jumbo v%d,class@0x%08x", vsrc1, ref);
				3161
				3162	obj = (Object*)GET_REGISTER(vsrc1);
				3163	if (obj != NULL) {
				3164	#if defined(WITH_EXTRA_OBJECT_VALIDATION)
				3165	if (!checkForNull(obj))
				3166	GOTO_exceptionThrown();
				3167	#endif
				3168	clazz = dvmDexGetResolvedClass(methodClassDex, ref);
				3169	if (clazz == NULL) {
				3170	clazz = dvmResolveClass(curMethod->clazz, ref, false);
				3171	if (clazz == NULL)
				3172	GOTO_exceptionThrown();
				3173	}
				3174	if (!dvmInstanceof(obj->clazz, clazz)) {
				3175	dvmThrowClassCastException(obj->clazz, clazz);
				3176	GOTO_exceptionThrown();
				3177	}
				3178	}
				3179	}
				3180	FINISH(4);
				3181	OP_END
				3182
				3183	/* File: c/OP_INSTANCE_OF_JUMBO.cpp */
				3184	HANDLE_OPCODE(OP_INSTANCE_OF_JUMBO /vBBBB, vCCCC, class@AAAAAAAA/)
				3185	{
				3186	ClassObject* clazz;
				3187	Object* obj;
				3188
				3189	ref = FETCH(1) \| (u4)FETCH(2) << 16; /* class to check against */
				3190	vdst = FETCH(3);
				3191	vsrc1 = FETCH(4); /* object to check */
				3192	ILOGV("\|instance-of/jumbo v%d,v%d,class@0x%08x", vdst, vsrc1, ref);
				3193
				3194	obj = (Object*)GET_REGISTER(vsrc1);
				3195	if (obj == NULL) {
				3196	SET_REGISTER(vdst, 0);
				3197	} else {
				3198	#if defined(WITH_EXTRA_OBJECT_VALIDATION)
				3199	if (!checkForNullExportPC(obj, fp, pc))
				3200	GOTO_exceptionThrown();
				3201	#endif
				3202	clazz = dvmDexGetResolvedClass(methodClassDex, ref);
				3203	if (clazz == NULL) {
				3204	EXPORT_PC();
				3205	clazz = dvmResolveClass(curMethod->clazz, ref, true);
				3206	if (clazz == NULL)
				3207	GOTO_exceptionThrown();
				3208	}
				3209	SET_REGISTER(vdst, dvmInstanceof(obj->clazz, clazz));
				3210	}
				3211	}
				3212	FINISH(5);
				3213	OP_END
				3214
				3215	/* File: c/OP_NEW_INSTANCE_JUMBO.cpp */
				3216	HANDLE_OPCODE(OP_NEW_INSTANCE_JUMBO /vBBBB, class@AAAAAAAA/)
				3217	{
				3218	ClassObject* clazz;
				3219	Object* newObj;
				3220
				3221	EXPORT_PC();
				3222
				3223	ref = FETCH(1) \| (u4)FETCH(2) << 16;
				3224	vdst = FETCH(3);
				3225	ILOGV("\|new-instance/jumbo v%d,class@0x%08x", vdst, ref);
				3226	clazz = dvmDexGetResolvedClass(methodClassDex, ref);
				3227	if (clazz == NULL) {
				3228	clazz = dvmResolveClass(curMethod->clazz, ref, false);
				3229	if (clazz == NULL)
				3230	GOTO_exceptionThrown();
				3231	}
				3232
				3233	if (!dvmIsClassInitialized(clazz) && !dvmInitClass(clazz))
				3234	GOTO_exceptionThrown();
				3235
				3236	#if defined(WITH_JIT)
				3237	/*
				3238	* The JIT needs dvmDexGetResolvedClass() to return non-null.
				3239	* Since we use the portable interpreter to build the trace, this extra
				3240	* check is not needed for mterp.
				3241	*/
				3242	if ((self->interpBreak.ctl.subMode & kSubModeJitTraceBuild) &&
				3243	(!dvmDexGetResolvedClass(methodClassDex, ref))) {
				3244	/* Class initialization is still ongoing - end the trace */
				3245	dvmJitEndTraceSelect(self,pc);
				3246	}
				3247	#endif
				3248
				3249	/*
				3250	* Verifier now tests for interface/abstract class.
				3251	*/
				3252	//if (dvmIsInterfaceClass(clazz) \|\| dvmIsAbstractClass(clazz)) {
				3253	// dvmThrowExceptionWithClassMessage(gDvm.exInstantiationError,
				3254	// clazz->descriptor);
				3255	// GOTO_exceptionThrown();
				3256	//}
				3257	newObj = dvmAllocObject(clazz, ALLOC_DONT_TRACK);
				3258	if (newObj == NULL)
				3259	GOTO_exceptionThrown();
				3260	SET_REGISTER(vdst, (u4) newObj);
				3261	}
				3262	FINISH(4);
				3263	OP_END
				3264
				3265	/* File: c/OP_NEW_ARRAY_JUMBO.cpp */
				3266	HANDLE_OPCODE(OP_NEW_ARRAY_JUMBO /vBBBB, vCCCC, class@AAAAAAAA/)
				3267	{
				3268	ClassObject* arrayClass;
				3269	ArrayObject* newArray;
				3270	s4 length;
				3271
				3272	EXPORT_PC();
				3273
				3274	ref = FETCH(1) \| (u4)FETCH(2) << 16;
				3275	vdst = FETCH(3);
				3276	vsrc1 = FETCH(4); /* length reg */
				3277	ILOGV("\|new-array/jumbo v%d,v%d,class@0x%08x (%d elements)",
				3278	vdst, vsrc1, ref, (s4) GET_REGISTER(vsrc1));
				3279	length = (s4) GET_REGISTER(vsrc1);
				3280	if (length < 0) {
				3281	dvmThrowNegativeArraySizeException(length);
				3282	GOTO_exceptionThrown();
				3283	}
				3284	arrayClass = dvmDexGetResolvedClass(methodClassDex, ref);
				3285	if (arrayClass == NULL) {
				3286	arrayClass = dvmResolveClass(curMethod->clazz, ref, false);
				3287	if (arrayClass == NULL)
				3288	GOTO_exceptionThrown();
				3289	}
				3290	/* verifier guarantees this is an array class */
				3291	assert(dvmIsArrayClass(arrayClass));
				3292	assert(dvmIsClassInitialized(arrayClass));
				3293
				3294	newArray = dvmAllocArrayByClass(arrayClass, length, ALLOC_DONT_TRACK);
				3295	if (newArray == NULL)
				3296	GOTO_exceptionThrown();
				3297	SET_REGISTER(vdst, (u4) newArray);
				3298	}
				3299	FINISH(5);
				3300	OP_END
				3301
				3302	/* File: c/OP_FILLED_NEW_ARRAY_JUMBO.cpp */
				3303	HANDLE_OPCODE(OP_FILLED_NEW_ARRAY_JUMBO /{vCCCC..v(CCCC+BBBB-1)}, class@AAAAAAAA/)
				3304	GOTO_invoke(filledNewArray, true, true);
				3305	OP_END
				3306
				3307	/* File: c/OP_IGET_JUMBO.cpp */
				3308	HANDLE_IGET_X_JUMBO(OP_IGET_JUMBO, "", Int, )
				3309	OP_END
				3310
				3311	/* File: c/OP_IGET_WIDE_JUMBO.cpp */
				3312	HANDLE_IGET_X_JUMBO(OP_IGET_WIDE_JUMBO, "-wide", Long, _WIDE)
				3313	OP_END
				3314
				3315	/* File: c/OP_IGET_OBJECT_JUMBO.cpp */
				3316	HANDLE_IGET_X_JUMBO(OP_IGET_OBJECT_JUMBO, "-object", Object, _AS_OBJECT)
				3317	OP_END
				3318
				3319	/* File: c/OP_IGET_BOOLEAN_JUMBO.cpp */
				3320	HANDLE_IGET_X_JUMBO(OP_IGET_BOOLEAN_JUMBO, "", Int, )
				3321	OP_END
				3322
				3323	/* File: c/OP_IGET_BYTE_JUMBO.cpp */
				3324	HANDLE_IGET_X_JUMBO(OP_IGET_BYTE_JUMBO, "", Int, )
				3325	OP_END
				3326
				3327	/* File: c/OP_IGET_CHAR_JUMBO.cpp */
				3328	HANDLE_IGET_X_JUMBO(OP_IGET_CHAR_JUMBO, "", Int, )
				3329	OP_END
				3330
				3331	/* File: c/OP_IGET_SHORT_JUMBO.cpp */
				3332	HANDLE_IGET_X_JUMBO(OP_IGET_SHORT_JUMBO, "", Int, )
				3333	OP_END
				3334
				3335	/* File: c/OP_IPUT_JUMBO.cpp */
				3336	HANDLE_IPUT_X_JUMBO(OP_IPUT_JUMBO, "", Int, )
				3337	OP_END
				3338
				3339	/* File: c/OP_IPUT_WIDE_JUMBO.cpp */
				3340	HANDLE_IPUT_X_JUMBO(OP_IPUT_WIDE_JUMBO, "-wide", Long, _WIDE)
				3341	OP_END
				3342
				3343	/* File: c/OP_IPUT_OBJECT_JUMBO.cpp */
				3344	/*
				3345	* The VM spec says we should verify that the reference being stored into
				3346	* the field is assignment compatible. In practice, many popular VMs don't
				3347	* do this because it slows down a very common operation. It's not so bad
				3348	* for us, since "dexopt" quickens it whenever possible, but it's still an
				3349	* issue.
				3350	*
				3351	* To make this spec-complaint, we'd need to add a ClassObject pointer to
				3352	* the Field struct, resolve the field's type descriptor at link or class
				3353	* init time, and then verify the type here.
				3354	*/
				3355	HANDLE_IPUT_X_JUMBO(OP_IPUT_OBJECT_JUMBO, "-object", Object, _AS_OBJECT)
				3356	OP_END
				3357
				3358	/* File: c/OP_IPUT_BOOLEAN_JUMBO.cpp */
				3359	HANDLE_IPUT_X_JUMBO(OP_IPUT_BOOLEAN_JUMBO, "", Int, )
				3360	OP_END
				3361
				3362	/* File: c/OP_IPUT_BYTE_JUMBO.cpp */
				3363	HANDLE_IPUT_X_JUMBO(OP_IPUT_BYTE_JUMBO, "", Int, )
				3364	OP_END
				3365
				3366	/* File: c/OP_IPUT_CHAR_JUMBO.cpp */
				3367	HANDLE_IPUT_X_JUMBO(OP_IPUT_CHAR_JUMBO, "", Int, )
				3368	OP_END
				3369
				3370	/* File: c/OP_IPUT_SHORT_JUMBO.cpp */
				3371	HANDLE_IPUT_X_JUMBO(OP_IPUT_SHORT_JUMBO, "", Int, )
				3372	OP_END
				3373
				3374	/* File: c/OP_SGET_JUMBO.cpp */
				3375	HANDLE_SGET_X_JUMBO(OP_SGET_JUMBO, "", Int, )
				3376	OP_END
				3377
				3378	/* File: c/OP_SGET_WIDE_JUMBO.cpp */
				3379	HANDLE_SGET_X_JUMBO(OP_SGET_WIDE_JUMBO, "-wide", Long, _WIDE)
				3380	OP_END
				3381
				3382	/* File: c/OP_SGET_OBJECT_JUMBO.cpp */
				3383	HANDLE_SGET_X_JUMBO(OP_SGET_OBJECT_JUMBO, "-object", Object, _AS_OBJECT)
				3384	OP_END
				3385
				3386	/* File: c/OP_SGET_BOOLEAN_JUMBO.cpp */
				3387	HANDLE_SGET_X_JUMBO(OP_SGET_BOOLEAN_JUMBO, "", Int, )
				3388	OP_END
				3389
				3390	/* File: c/OP_SGET_BYTE_JUMBO.cpp */
				3391	HANDLE_SGET_X_JUMBO(OP_SGET_BYTE_JUMBO, "", Int, )
				3392	OP_END
				3393
				3394	/* File: c/OP_SGET_CHAR_JUMBO.cpp */
				3395	HANDLE_SGET_X_JUMBO(OP_SGET_CHAR_JUMBO, "", Int, )
				3396	OP_END
				3397
				3398	/* File: c/OP_SGET_SHORT_JUMBO.cpp */
				3399	HANDLE_SGET_X_JUMBO(OP_SGET_SHORT_JUMBO, "", Int, )
				3400	OP_END
				3401
				3402	/* File: c/OP_SPUT_JUMBO.cpp */
				3403	HANDLE_SPUT_X_JUMBO(OP_SPUT_JUMBO, "", Int, )
				3404	OP_END
				3405
				3406	/* File: c/OP_SPUT_WIDE_JUMBO.cpp */
				3407	HANDLE_SPUT_X_JUMBO(OP_SPUT_WIDE_JUMBO, "-wide", Long, _WIDE)
				3408	OP_END
				3409
				3410	/* File: c/OP_SPUT_OBJECT_JUMBO.cpp */
				3411	HANDLE_SPUT_X_JUMBO(OP_SPUT_OBJECT_JUMBO, "-object", Object, _AS_OBJECT)
				3412	OP_END
				3413
				3414	/* File: c/OP_SPUT_BOOLEAN_JUMBO.cpp */
				3415	HANDLE_SPUT_X_JUMBO(OP_SPUT_BOOLEAN_JUMBO, "", Int, )
				3416	OP_END
				3417
				3418	/* File: c/OP_SPUT_BYTE_JUMBO.cpp */
				3419	HANDLE_SPUT_X_JUMBO(OP_SPUT_BYTE_JUMBO, "", Int, )
				3420	OP_END
				3421
				3422	/* File: c/OP_SPUT_CHAR_JUMBO.cpp */
				3423	HANDLE_SPUT_X_JUMBO(OP_SPUT_CHAR_JUMBO, "", Int, )
				3424	OP_END
				3425
				3426	/* File: c/OP_SPUT_SHORT_JUMBO.cpp */
				3427	HANDLE_SPUT_X_JUMBO(OP_SPUT_SHORT_JUMBO, "", Int, )
				3428	OP_END
				3429
				3430	/* File: c/OP_INVOKE_VIRTUAL_JUMBO.cpp */
				3431	HANDLE_OPCODE(OP_INVOKE_VIRTUAL_JUMBO /{vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA/)
				3432	GOTO_invoke(invokeVirtual, true, true);
				3433	OP_END
				3434
				3435	/* File: c/OP_INVOKE_SUPER_JUMBO.cpp */
				3436	HANDLE_OPCODE(OP_INVOKE_SUPER_JUMBO /{vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA/)
				3437	GOTO_invoke(invokeSuper, true, true);
				3438	OP_END
				3439
				3440	/* File: c/OP_INVOKE_DIRECT_JUMBO.cpp */
				3441	HANDLE_OPCODE(OP_INVOKE_DIRECT_JUMBO /{vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA/)
				3442	GOTO_invoke(invokeDirect, true, true);
				3443	OP_END
				3444
				3445	/* File: c/OP_INVOKE_STATIC_JUMBO.cpp */
				3446	HANDLE_OPCODE(OP_INVOKE_STATIC_JUMBO /{vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA/)
				3447	GOTO_invoke(invokeStatic, true, true);
				3448	OP_END
				3449
				3450	/* File: c/OP_INVOKE_INTERFACE_JUMBO.cpp */
				3451	HANDLE_OPCODE(OP_INVOKE_INTERFACE_JUMBO /{vCCCC..v(CCCC+BBBB-1)}, meth@AAAAAAAA/)
				3452	GOTO_invoke(invokeInterface, true, true);
				3453	OP_END
				3454
				3455	/* File: c/OP_UNUSED_27FF.cpp */
				3456	HANDLE_OPCODE(OP_UNUSED_27FF)
				3457	OP_END
				3458
				3459	/* File: c/OP_UNUSED_28FF.cpp */
				3460	HANDLE_OPCODE(OP_UNUSED_28FF)
				3461	OP_END
				3462
				3463	/* File: c/OP_UNUSED_29FF.cpp */
				3464	HANDLE_OPCODE(OP_UNUSED_29FF)
				3465	OP_END
				3466
				3467	/* File: c/OP_UNUSED_2AFF.cpp */
				3468	HANDLE_OPCODE(OP_UNUSED_2AFF)
				3469	OP_END
				3470
				3471	/* File: c/OP_UNUSED_2BFF.cpp */
				3472	HANDLE_OPCODE(OP_UNUSED_2BFF)
				3473	OP_END
				3474
				3475	/* File: c/OP_UNUSED_2CFF.cpp */
				3476	HANDLE_OPCODE(OP_UNUSED_2CFF)
				3477	OP_END
				3478
				3479	/* File: c/OP_UNUSED_2DFF.cpp */
				3480	HANDLE_OPCODE(OP_UNUSED_2DFF)
				3481	OP_END
				3482
				3483	/* File: c/OP_UNUSED_2EFF.cpp */
				3484	HANDLE_OPCODE(OP_UNUSED_2EFF)
				3485	OP_END
				3486
				3487	/* File: c/OP_UNUSED_2FFF.cpp */
				3488	HANDLE_OPCODE(OP_UNUSED_2FFF)
				3489	OP_END
				3490
				3491	/* File: c/OP_UNUSED_30FF.cpp */
				3492	HANDLE_OPCODE(OP_UNUSED_30FF)
				3493	OP_END
				3494
				3495	/* File: c/OP_UNUSED_31FF.cpp */
				3496	HANDLE_OPCODE(OP_UNUSED_31FF)
				3497	OP_END
				3498
				3499	/* File: c/OP_UNUSED_32FF.cpp */
				3500	HANDLE_OPCODE(OP_UNUSED_32FF)
				3501	OP_END
				3502
				3503	/* File: c/OP_UNUSED_33FF.cpp */
				3504	HANDLE_OPCODE(OP_UNUSED_33FF)
				3505	OP_END
				3506
				3507	/* File: c/OP_UNUSED_34FF.cpp */
				3508	HANDLE_OPCODE(OP_UNUSED_34FF)
				3509	OP_END
				3510
				3511	/* File: c/OP_UNUSED_35FF.cpp */
				3512	HANDLE_OPCODE(OP_UNUSED_35FF)
				3513	OP_END
				3514
				3515	/* File: c/OP_UNUSED_36FF.cpp */
				3516	HANDLE_OPCODE(OP_UNUSED_36FF)
				3517	OP_END
				3518
				3519	/* File: c/OP_UNUSED_37FF.cpp */
				3520	HANDLE_OPCODE(OP_UNUSED_37FF)
				3521	OP_END
				3522
				3523	/* File: c/OP_UNUSED_38FF.cpp */
				3524	HANDLE_OPCODE(OP_UNUSED_38FF)
				3525	OP_END
				3526
				3527	/* File: c/OP_UNUSED_39FF.cpp */
				3528	HANDLE_OPCODE(OP_UNUSED_39FF)
				3529	OP_END
				3530
				3531	/* File: c/OP_UNUSED_3AFF.cpp */
				3532	HANDLE_OPCODE(OP_UNUSED_3AFF)
				3533	OP_END
				3534
				3535	/* File: c/OP_UNUSED_3BFF.cpp */
				3536	HANDLE_OPCODE(OP_UNUSED_3BFF)
				3537	OP_END
				3538
				3539	/* File: c/OP_UNUSED_3CFF.cpp */
				3540	HANDLE_OPCODE(OP_UNUSED_3CFF)
				3541	OP_END
				3542
				3543	/* File: c/OP_UNUSED_3DFF.cpp */
				3544	HANDLE_OPCODE(OP_UNUSED_3DFF)
				3545	OP_END
				3546
				3547	/* File: c/OP_UNUSED_3EFF.cpp */
				3548	HANDLE_OPCODE(OP_UNUSED_3EFF)
				3549	OP_END
				3550
				3551	/* File: c/OP_UNUSED_3FFF.cpp */
				3552	HANDLE_OPCODE(OP_UNUSED_3FFF)
				3553	OP_END
				3554
				3555	/* File: c/OP_UNUSED_40FF.cpp */
				3556	HANDLE_OPCODE(OP_UNUSED_40FF)
				3557	OP_END
				3558
				3559	/* File: c/OP_UNUSED_41FF.cpp */
				3560	HANDLE_OPCODE(OP_UNUSED_41FF)
				3561	OP_END
				3562
				3563	/* File: c/OP_UNUSED_42FF.cpp */
				3564	HANDLE_OPCODE(OP_UNUSED_42FF)
				3565	OP_END
				3566
				3567	/* File: c/OP_UNUSED_43FF.cpp */
				3568	HANDLE_OPCODE(OP_UNUSED_43FF)
				3569	OP_END
				3570
				3571	/* File: c/OP_UNUSED_44FF.cpp */
				3572	HANDLE_OPCODE(OP_UNUSED_44FF)
				3573	OP_END
				3574
				3575	/* File: c/OP_UNUSED_45FF.cpp */
				3576	HANDLE_OPCODE(OP_UNUSED_45FF)
				3577	OP_END
				3578
				3579	/* File: c/OP_UNUSED_46FF.cpp */
				3580	HANDLE_OPCODE(OP_UNUSED_46FF)
				3581	OP_END
				3582
				3583	/* File: c/OP_UNUSED_47FF.cpp */
				3584	HANDLE_OPCODE(OP_UNUSED_47FF)
				3585	OP_END
				3586
				3587	/* File: c/OP_UNUSED_48FF.cpp */
				3588	HANDLE_OPCODE(OP_UNUSED_48FF)
				3589	OP_END
				3590
				3591	/* File: c/OP_UNUSED_49FF.cpp */
				3592	HANDLE_OPCODE(OP_UNUSED_49FF)
				3593	OP_END
				3594
				3595	/* File: c/OP_UNUSED_4AFF.cpp */
				3596	HANDLE_OPCODE(OP_UNUSED_4AFF)
				3597	OP_END
				3598
				3599	/* File: c/OP_UNUSED_4BFF.cpp */
				3600	HANDLE_OPCODE(OP_UNUSED_4BFF)
				3601	OP_END
				3602
				3603	/* File: c/OP_UNUSED_4CFF.cpp */
				3604	HANDLE_OPCODE(OP_UNUSED_4CFF)
				3605	OP_END
				3606
				3607	/* File: c/OP_UNUSED_4DFF.cpp */
				3608	HANDLE_OPCODE(OP_UNUSED_4DFF)
				3609	OP_END
				3610
				3611	/* File: c/OP_UNUSED_4EFF.cpp */
				3612	HANDLE_OPCODE(OP_UNUSED_4EFF)
				3613	OP_END
				3614
				3615	/* File: c/OP_UNUSED_4FFF.cpp */
				3616	HANDLE_OPCODE(OP_UNUSED_4FFF)
				3617	OP_END
				3618
				3619	/* File: c/OP_UNUSED_50FF.cpp */
				3620	HANDLE_OPCODE(OP_UNUSED_50FF)
				3621	OP_END
				3622
				3623	/* File: c/OP_UNUSED_51FF.cpp */
				3624	HANDLE_OPCODE(OP_UNUSED_51FF)
				3625	OP_END
				3626
				3627	/* File: c/OP_UNUSED_52FF.cpp */
				3628	HANDLE_OPCODE(OP_UNUSED_52FF)
				3629	OP_END
				3630
				3631	/* File: c/OP_UNUSED_53FF.cpp */
				3632	HANDLE_OPCODE(OP_UNUSED_53FF)
				3633	OP_END
				3634
				3635	/* File: c/OP_UNUSED_54FF.cpp */
				3636	HANDLE_OPCODE(OP_UNUSED_54FF)
				3637	OP_END
				3638
				3639	/* File: c/OP_UNUSED_55FF.cpp */
				3640	HANDLE_OPCODE(OP_UNUSED_55FF)
				3641	OP_END
				3642
				3643	/* File: c/OP_UNUSED_56FF.cpp */
				3644	HANDLE_OPCODE(OP_UNUSED_56FF)
				3645	OP_END
				3646
				3647	/* File: c/OP_UNUSED_57FF.cpp */
				3648	HANDLE_OPCODE(OP_UNUSED_57FF)
				3649	OP_END
				3650
				3651	/* File: c/OP_UNUSED_58FF.cpp */
				3652	HANDLE_OPCODE(OP_UNUSED_58FF)
				3653	OP_END
				3654
				3655	/* File: c/OP_UNUSED_59FF.cpp */
				3656	HANDLE_OPCODE(OP_UNUSED_59FF)
				3657	OP_END
				3658
				3659	/* File: c/OP_UNUSED_5AFF.cpp */
				3660	HANDLE_OPCODE(OP_UNUSED_5AFF)
				3661	OP_END
				3662
				3663	/* File: c/OP_UNUSED_5BFF.cpp */
				3664	HANDLE_OPCODE(OP_UNUSED_5BFF)
				3665	OP_END
				3666
				3667	/* File: c/OP_UNUSED_5CFF.cpp */
				3668	HANDLE_OPCODE(OP_UNUSED_5CFF)
				3669	OP_END
				3670
				3671	/* File: c/OP_UNUSED_5DFF.cpp */
				3672	HANDLE_OPCODE(OP_UNUSED_5DFF)
				3673	OP_END
				3674
				3675	/* File: c/OP_UNUSED_5EFF.cpp */
				3676	HANDLE_OPCODE(OP_UNUSED_5EFF)
				3677	OP_END
				3678
				3679	/* File: c/OP_UNUSED_5FFF.cpp */
				3680	HANDLE_OPCODE(OP_UNUSED_5FFF)
				3681	OP_END
				3682
				3683	/* File: c/OP_UNUSED_60FF.cpp */
				3684	HANDLE_OPCODE(OP_UNUSED_60FF)
				3685	OP_END
				3686
				3687	/* File: c/OP_UNUSED_61FF.cpp */
				3688	HANDLE_OPCODE(OP_UNUSED_61FF)
				3689	OP_END
				3690
				3691	/* File: c/OP_UNUSED_62FF.cpp */
				3692	HANDLE_OPCODE(OP_UNUSED_62FF)
				3693	OP_END
				3694
				3695	/* File: c/OP_UNUSED_63FF.cpp */
				3696	HANDLE_OPCODE(OP_UNUSED_63FF)
				3697	OP_END
				3698
				3699	/* File: c/OP_UNUSED_64FF.cpp */
				3700	HANDLE_OPCODE(OP_UNUSED_64FF)
				3701	OP_END
				3702
				3703	/* File: c/OP_UNUSED_65FF.cpp */
				3704	HANDLE_OPCODE(OP_UNUSED_65FF)
				3705	OP_END
				3706
				3707	/* File: c/OP_UNUSED_66FF.cpp */
				3708	HANDLE_OPCODE(OP_UNUSED_66FF)
				3709	OP_END
				3710
				3711	/* File: c/OP_UNUSED_67FF.cpp */
				3712	HANDLE_OPCODE(OP_UNUSED_67FF)
				3713	OP_END
				3714
				3715	/* File: c/OP_UNUSED_68FF.cpp */
				3716	HANDLE_OPCODE(OP_UNUSED_68FF)
				3717	OP_END
				3718
				3719	/* File: c/OP_UNUSED_69FF.cpp */
				3720	HANDLE_OPCODE(OP_UNUSED_69FF)
				3721	OP_END
				3722
				3723	/* File: c/OP_UNUSED_6AFF.cpp */
				3724	HANDLE_OPCODE(OP_UNUSED_6AFF)
				3725	OP_END
				3726
				3727	/* File: c/OP_UNUSED_6BFF.cpp */
				3728	HANDLE_OPCODE(OP_UNUSED_6BFF)
				3729	OP_END
				3730
				3731	/* File: c/OP_UNUSED_6CFF.cpp */
				3732	HANDLE_OPCODE(OP_UNUSED_6CFF)
				3733	OP_END
				3734
				3735	/* File: c/OP_UNUSED_6DFF.cpp */
				3736	HANDLE_OPCODE(OP_UNUSED_6DFF)
				3737	OP_END
				3738
				3739	/* File: c/OP_UNUSED_6EFF.cpp */
				3740	HANDLE_OPCODE(OP_UNUSED_6EFF)
				3741	OP_END
				3742
				3743	/* File: c/OP_UNUSED_6FFF.cpp */
				3744	HANDLE_OPCODE(OP_UNUSED_6FFF)
				3745	OP_END
				3746
				3747	/* File: c/OP_UNUSED_70FF.cpp */
				3748	HANDLE_OPCODE(OP_UNUSED_70FF)
				3749	OP_END
				3750
				3751	/* File: c/OP_UNUSED_71FF.cpp */
				3752	HANDLE_OPCODE(OP_UNUSED_71FF)
				3753	OP_END
				3754
				3755	/* File: c/OP_UNUSED_72FF.cpp */
				3756	HANDLE_OPCODE(OP_UNUSED_72FF)
				3757	OP_END
				3758
				3759	/* File: c/OP_UNUSED_73FF.cpp */
				3760	HANDLE_OPCODE(OP_UNUSED_73FF)
				3761	OP_END
				3762
				3763	/* File: c/OP_UNUSED_74FF.cpp */
				3764	HANDLE_OPCODE(OP_UNUSED_74FF)
				3765	OP_END
				3766
				3767	/* File: c/OP_UNUSED_75FF.cpp */
				3768	HANDLE_OPCODE(OP_UNUSED_75FF)
				3769	OP_END
				3770
				3771	/* File: c/OP_UNUSED_76FF.cpp */
				3772	HANDLE_OPCODE(OP_UNUSED_76FF)
				3773	OP_END
				3774
				3775	/* File: c/OP_UNUSED_77FF.cpp */
				3776	HANDLE_OPCODE(OP_UNUSED_77FF)
				3777	OP_END
				3778
				3779	/* File: c/OP_UNUSED_78FF.cpp */
				3780	HANDLE_OPCODE(OP_UNUSED_78FF)
				3781	OP_END
				3782
				3783	/* File: c/OP_UNUSED_79FF.cpp */
				3784	HANDLE_OPCODE(OP_UNUSED_79FF)
				3785	OP_END
				3786
				3787	/* File: c/OP_UNUSED_7AFF.cpp */
				3788	HANDLE_OPCODE(OP_UNUSED_7AFF)
				3789	OP_END
				3790
				3791	/* File: c/OP_UNUSED_7BFF.cpp */
				3792	HANDLE_OPCODE(OP_UNUSED_7BFF)
				3793	OP_END
				3794
				3795	/* File: c/OP_UNUSED_7CFF.cpp */
				3796	HANDLE_OPCODE(OP_UNUSED_7CFF)
				3797	OP_END
				3798
				3799	/* File: c/OP_UNUSED_7DFF.cpp */
				3800	HANDLE_OPCODE(OP_UNUSED_7DFF)
				3801	OP_END
				3802
				3803	/* File: c/OP_UNUSED_7EFF.cpp */
				3804	HANDLE_OPCODE(OP_UNUSED_7EFF)
				3805	OP_END
				3806
				3807	/* File: c/OP_UNUSED_7FFF.cpp */
				3808	HANDLE_OPCODE(OP_UNUSED_7FFF)
				3809	OP_END
				3810
				3811	/* File: c/OP_UNUSED_80FF.cpp */
				3812	HANDLE_OPCODE(OP_UNUSED_80FF)
				3813	OP_END
				3814
				3815	/* File: c/OP_UNUSED_81FF.cpp */
				3816	HANDLE_OPCODE(OP_UNUSED_81FF)
				3817	OP_END
				3818
				3819	/* File: c/OP_UNUSED_82FF.cpp */
				3820	HANDLE_OPCODE(OP_UNUSED_82FF)
				3821	OP_END
				3822
				3823	/* File: c/OP_UNUSED_83FF.cpp */
				3824	HANDLE_OPCODE(OP_UNUSED_83FF)
				3825	OP_END
				3826
				3827	/* File: c/OP_UNUSED_84FF.cpp */
				3828	HANDLE_OPCODE(OP_UNUSED_84FF)
				3829	OP_END
				3830
				3831	/* File: c/OP_UNUSED_85FF.cpp */
				3832	HANDLE_OPCODE(OP_UNUSED_85FF)
				3833	OP_END
				3834
				3835	/* File: c/OP_UNUSED_86FF.cpp */
				3836	HANDLE_OPCODE(OP_UNUSED_86FF)
				3837	OP_END
				3838
				3839	/* File: c/OP_UNUSED_87FF.cpp */
				3840	HANDLE_OPCODE(OP_UNUSED_87FF)
				3841	OP_END
				3842
				3843	/* File: c/OP_UNUSED_88FF.cpp */
				3844	HANDLE_OPCODE(OP_UNUSED_88FF)
				3845	OP_END
				3846
				3847	/* File: c/OP_UNUSED_89FF.cpp */
				3848	HANDLE_OPCODE(OP_UNUSED_89FF)
				3849	OP_END
				3850
				3851	/* File: c/OP_UNUSED_8AFF.cpp */
				3852	HANDLE_OPCODE(OP_UNUSED_8AFF)
				3853	OP_END
				3854
				3855	/* File: c/OP_UNUSED_8BFF.cpp */
				3856	HANDLE_OPCODE(OP_UNUSED_8BFF)
				3857	OP_END
				3858
				3859	/* File: c/OP_UNUSED_8CFF.cpp */
				3860	HANDLE_OPCODE(OP_UNUSED_8CFF)
				3861	OP_END
				3862
				3863	/* File: c/OP_UNUSED_8DFF.cpp */
				3864	HANDLE_OPCODE(OP_UNUSED_8DFF)
				3865	OP_END
				3866
				3867	/* File: c/OP_UNUSED_8EFF.cpp */
				3868	HANDLE_OPCODE(OP_UNUSED_8EFF)
				3869	OP_END
				3870
				3871	/* File: c/OP_UNUSED_8FFF.cpp */
				3872	HANDLE_OPCODE(OP_UNUSED_8FFF)
				3873	OP_END
				3874
				3875	/* File: c/OP_UNUSED_90FF.cpp */
				3876	HANDLE_OPCODE(OP_UNUSED_90FF)
				3877	OP_END
				3878
				3879	/* File: c/OP_UNUSED_91FF.cpp */
				3880	HANDLE_OPCODE(OP_UNUSED_91FF)
				3881	OP_END
				3882
				3883	/* File: c/OP_UNUSED_92FF.cpp */
				3884	HANDLE_OPCODE(OP_UNUSED_92FF)
				3885	OP_END
				3886
				3887	/* File: c/OP_UNUSED_93FF.cpp */
				3888	HANDLE_OPCODE(OP_UNUSED_93FF)
				3889	OP_END
				3890
				3891	/* File: c/OP_UNUSED_94FF.cpp */
				3892	HANDLE_OPCODE(OP_UNUSED_94FF)
				3893	OP_END
				3894
				3895	/* File: c/OP_UNUSED_95FF.cpp */
				3896	HANDLE_OPCODE(OP_UNUSED_95FF)
				3897	OP_END
				3898
				3899	/* File: c/OP_UNUSED_96FF.cpp */
				3900	HANDLE_OPCODE(OP_UNUSED_96FF)
				3901	OP_END
				3902
				3903	/* File: c/OP_UNUSED_97FF.cpp */
				3904	HANDLE_OPCODE(OP_UNUSED_97FF)
				3905	OP_END
				3906
				3907	/* File: c/OP_UNUSED_98FF.cpp */
				3908	HANDLE_OPCODE(OP_UNUSED_98FF)
				3909	OP_END
				3910
				3911	/* File: c/OP_UNUSED_99FF.cpp */
				3912	HANDLE_OPCODE(OP_UNUSED_99FF)
				3913	OP_END
				3914
				3915	/* File: c/OP_UNUSED_9AFF.cpp */
				3916	HANDLE_OPCODE(OP_UNUSED_9AFF)
				3917	OP_END
				3918
				3919	/* File: c/OP_UNUSED_9BFF.cpp */
				3920	HANDLE_OPCODE(OP_UNUSED_9BFF)
				3921	OP_END
				3922
				3923	/* File: c/OP_UNUSED_9CFF.cpp */
				3924	HANDLE_OPCODE(OP_UNUSED_9CFF)
				3925	OP_END
				3926
				3927	/* File: c/OP_UNUSED_9DFF.cpp */
				3928	HANDLE_OPCODE(OP_UNUSED_9DFF)
				3929	OP_END
				3930
				3931	/* File: c/OP_UNUSED_9EFF.cpp */
				3932	HANDLE_OPCODE(OP_UNUSED_9EFF)
				3933	OP_END
				3934
				3935	/* File: c/OP_UNUSED_9FFF.cpp */
				3936	HANDLE_OPCODE(OP_UNUSED_9FFF)
				3937	OP_END
				3938
				3939	/* File: c/OP_UNUSED_A0FF.cpp */
				3940	HANDLE_OPCODE(OP_UNUSED_A0FF)
				3941	OP_END
				3942
				3943	/* File: c/OP_UNUSED_A1FF.cpp */
				3944	HANDLE_OPCODE(OP_UNUSED_A1FF)
				3945	OP_END
				3946
				3947	/* File: c/OP_UNUSED_A2FF.cpp */
				3948	HANDLE_OPCODE(OP_UNUSED_A2FF)
				3949	OP_END
				3950
				3951	/* File: c/OP_UNUSED_A3FF.cpp */
				3952	HANDLE_OPCODE(OP_UNUSED_A3FF)
				3953	OP_END
				3954
				3955	/* File: c/OP_UNUSED_A4FF.cpp */
				3956	HANDLE_OPCODE(OP_UNUSED_A4FF)
				3957	OP_END
				3958
				3959	/* File: c/OP_UNUSED_A5FF.cpp */
				3960	HANDLE_OPCODE(OP_UNUSED_A5FF)
				3961	OP_END
				3962
				3963	/* File: c/OP_UNUSED_A6FF.cpp */
				3964	HANDLE_OPCODE(OP_UNUSED_A6FF)
				3965	OP_END
				3966
				3967	/* File: c/OP_UNUSED_A7FF.cpp */
				3968	HANDLE_OPCODE(OP_UNUSED_A7FF)
				3969	OP_END
				3970
				3971	/* File: c/OP_UNUSED_A8FF.cpp */
				3972	HANDLE_OPCODE(OP_UNUSED_A8FF)
				3973	OP_END
				3974
				3975	/* File: c/OP_UNUSED_A9FF.cpp */
				3976	HANDLE_OPCODE(OP_UNUSED_A9FF)
				3977	OP_END
				3978
				3979	/* File: c/OP_UNUSED_AAFF.cpp */
				3980	HANDLE_OPCODE(OP_UNUSED_AAFF)
				3981	OP_END
				3982
				3983	/* File: c/OP_UNUSED_ABFF.cpp */
				3984	HANDLE_OPCODE(OP_UNUSED_ABFF)
				3985	OP_END
				3986
				3987	/* File: c/OP_UNUSED_ACFF.cpp */
				3988	HANDLE_OPCODE(OP_UNUSED_ACFF)
				3989	OP_END
				3990
				3991	/* File: c/OP_UNUSED_ADFF.cpp */
				3992	HANDLE_OPCODE(OP_UNUSED_ADFF)
				3993	OP_END
				3994
				3995	/* File: c/OP_UNUSED_AEFF.cpp */
				3996	HANDLE_OPCODE(OP_UNUSED_AEFF)
				3997	OP_END
				3998
				3999	/* File: c/OP_UNUSED_AFFF.cpp */
				4000	HANDLE_OPCODE(OP_UNUSED_AFFF)
				4001	OP_END
				4002
				4003	/* File: c/OP_UNUSED_B0FF.cpp */
				4004	HANDLE_OPCODE(OP_UNUSED_B0FF)
				4005	OP_END
				4006
				4007	/* File: c/OP_UNUSED_B1FF.cpp */
				4008	HANDLE_OPCODE(OP_UNUSED_B1FF)
				4009	OP_END
				4010
				4011	/* File: c/OP_UNUSED_B2FF.cpp */
				4012	HANDLE_OPCODE(OP_UNUSED_B2FF)
				4013	OP_END
				4014
				4015	/* File: c/OP_UNUSED_B3FF.cpp */
				4016	HANDLE_OPCODE(OP_UNUSED_B3FF)
				4017	OP_END
				4018
				4019	/* File: c/OP_UNUSED_B4FF.cpp */
				4020	HANDLE_OPCODE(OP_UNUSED_B4FF)
				4021	OP_END
				4022
				4023	/* File: c/OP_UNUSED_B5FF.cpp */
				4024	HANDLE_OPCODE(OP_UNUSED_B5FF)
				4025	OP_END
				4026
				4027	/* File: c/OP_UNUSED_B6FF.cpp */
				4028	HANDLE_OPCODE(OP_UNUSED_B6FF)
				4029	OP_END
				4030
				4031	/* File: c/OP_UNUSED_B7FF.cpp */
				4032	HANDLE_OPCODE(OP_UNUSED_B7FF)
				4033	OP_END
				4034
				4035	/* File: c/OP_UNUSED_B8FF.cpp */
				4036	HANDLE_OPCODE(OP_UNUSED_B8FF)
				4037	OP_END
				4038
				4039	/* File: c/OP_UNUSED_B9FF.cpp */
				4040	HANDLE_OPCODE(OP_UNUSED_B9FF)
				4041	OP_END
				4042
				4043	/* File: c/OP_UNUSED_BAFF.cpp */
				4044	HANDLE_OPCODE(OP_UNUSED_BAFF)
				4045	OP_END
				4046
				4047	/* File: c/OP_UNUSED_BBFF.cpp */
				4048	HANDLE_OPCODE(OP_UNUSED_BBFF)
				4049	OP_END
				4050
				4051	/* File: c/OP_UNUSED_BCFF.cpp */
				4052	HANDLE_OPCODE(OP_UNUSED_BCFF)
				4053	OP_END
				4054
				4055	/* File: c/OP_UNUSED_BDFF.cpp */
				4056	HANDLE_OPCODE(OP_UNUSED_BDFF)
				4057	OP_END
				4058
				4059	/* File: c/OP_UNUSED_BEFF.cpp */
				4060	HANDLE_OPCODE(OP_UNUSED_BEFF)
				4061	OP_END
				4062
				4063	/* File: c/OP_UNUSED_BFFF.cpp */
				4064	HANDLE_OPCODE(OP_UNUSED_BFFF)
				4065	OP_END
				4066
				4067	/* File: c/OP_UNUSED_C0FF.cpp */
				4068	HANDLE_OPCODE(OP_UNUSED_C0FF)
				4069	OP_END
				4070
				4071	/* File: c/OP_UNUSED_C1FF.cpp */
				4072	HANDLE_OPCODE(OP_UNUSED_C1FF)
				4073	OP_END
				4074
				4075	/* File: c/OP_UNUSED_C2FF.cpp */
				4076	HANDLE_OPCODE(OP_UNUSED_C2FF)
				4077	OP_END
				4078
				4079	/* File: c/OP_UNUSED_C3FF.cpp */
				4080	HANDLE_OPCODE(OP_UNUSED_C3FF)
				4081	OP_END
				4082
				4083	/* File: c/OP_UNUSED_C4FF.cpp */
				4084	HANDLE_OPCODE(OP_UNUSED_C4FF)
				4085	OP_END
				4086
				4087	/* File: c/OP_UNUSED_C5FF.cpp */
				4088	HANDLE_OPCODE(OP_UNUSED_C5FF)
				4089	OP_END
				4090
				4091	/* File: c/OP_UNUSED_C6FF.cpp */
				4092	HANDLE_OPCODE(OP_UNUSED_C6FF)
				4093	OP_END
				4094
				4095	/* File: c/OP_UNUSED_C7FF.cpp */
				4096	HANDLE_OPCODE(OP_UNUSED_C7FF)
				4097	OP_END
				4098
				4099	/* File: c/OP_UNUSED_C8FF.cpp */
				4100	HANDLE_OPCODE(OP_UNUSED_C8FF)
				4101	OP_END
				4102
				4103	/* File: c/OP_UNUSED_C9FF.cpp */
				4104	HANDLE_OPCODE(OP_UNUSED_C9FF)
				4105	OP_END
				4106
				4107	/* File: c/OP_UNUSED_CAFF.cpp */
				4108	HANDLE_OPCODE(OP_UNUSED_CAFF)
				4109	OP_END
				4110
				4111	/* File: c/OP_UNUSED_CBFF.cpp */
				4112	HANDLE_OPCODE(OP_UNUSED_CBFF)
				4113	OP_END
				4114
				4115	/* File: c/OP_UNUSED_CCFF.cpp */
				4116	HANDLE_OPCODE(OP_UNUSED_CCFF)
				4117	OP_END
				4118
				4119	/* File: c/OP_UNUSED_CDFF.cpp */
				4120	HANDLE_OPCODE(OP_UNUSED_CDFF)
				4121	OP_END
				4122
				4123	/* File: c/OP_UNUSED_CEFF.cpp */
				4124	HANDLE_OPCODE(OP_UNUSED_CEFF)
				4125	OP_END
				4126
				4127	/* File: c/OP_UNUSED_CFFF.cpp */
				4128	HANDLE_OPCODE(OP_UNUSED_CFFF)
				4129	OP_END
				4130
				4131	/* File: c/OP_UNUSED_D0FF.cpp */
				4132	HANDLE_OPCODE(OP_UNUSED_D0FF)
				4133	OP_END
				4134
				4135	/* File: c/OP_UNUSED_D1FF.cpp */
				4136	HANDLE_OPCODE(OP_UNUSED_D1FF)
				4137	OP_END
				4138
				4139	/* File: c/OP_UNUSED_D2FF.cpp */
				4140	HANDLE_OPCODE(OP_UNUSED_D2FF)
				4141	OP_END
				4142
				4143	/* File: c/OP_UNUSED_D3FF.cpp */
				4144	HANDLE_OPCODE(OP_UNUSED_D3FF)
				4145	OP_END
				4146
				4147	/* File: c/OP_UNUSED_D4FF.cpp */
				4148	HANDLE_OPCODE(OP_UNUSED_D4FF)
				4149	OP_END
				4150
				4151	/* File: c/OP_UNUSED_D5FF.cpp */
				4152	HANDLE_OPCODE(OP_UNUSED_D5FF)
				4153	OP_END
				4154
				4155	/* File: c/OP_UNUSED_D6FF.cpp */
				4156	HANDLE_OPCODE(OP_UNUSED_D6FF)
				4157	OP_END
				4158
				4159	/* File: c/OP_UNUSED_D7FF.cpp */
				4160	HANDLE_OPCODE(OP_UNUSED_D7FF)
				4161	OP_END
				4162
				4163	/* File: c/OP_UNUSED_D8FF.cpp */
				4164	HANDLE_OPCODE(OP_UNUSED_D8FF)
				4165	OP_END
				4166
				4167	/* File: c/OP_UNUSED_D9FF.cpp */
				4168	HANDLE_OPCODE(OP_UNUSED_D9FF)
				4169	OP_END
				4170
				4171	/* File: c/OP_UNUSED_DAFF.cpp */
				4172	HANDLE_OPCODE(OP_UNUSED_DAFF)
				4173	OP_END
				4174
				4175	/* File: c/OP_UNUSED_DBFF.cpp */
				4176	HANDLE_OPCODE(OP_UNUSED_DBFF)
				4177	OP_END
				4178
				4179	/* File: c/OP_UNUSED_DCFF.cpp */
				4180	HANDLE_OPCODE(OP_UNUSED_DCFF)
				4181	OP_END
				4182
				4183	/* File: c/OP_UNUSED_DDFF.cpp */
				4184	HANDLE_OPCODE(OP_UNUSED_DDFF)
				4185	OP_END
				4186
				4187	/* File: c/OP_UNUSED_DEFF.cpp */
				4188	HANDLE_OPCODE(OP_UNUSED_DEFF)
				4189	OP_END
				4190
				4191	/* File: c/OP_UNUSED_DFFF.cpp */
				4192	HANDLE_OPCODE(OP_UNUSED_DFFF)
				4193	OP_END
				4194
				4195	/* File: c/OP_UNUSED_E0FF.cpp */
				4196	HANDLE_OPCODE(OP_UNUSED_E0FF)
				4197	OP_END
				4198
				4199	/* File: c/OP_UNUSED_E1FF.cpp */
				4200	HANDLE_OPCODE(OP_UNUSED_E1FF)
				4201	OP_END
				4202
				4203	/* File: c/OP_UNUSED_E2FF.cpp */
				4204	HANDLE_OPCODE(OP_UNUSED_E2FF)
				4205	OP_END
				4206
				4207	/* File: c/OP_UNUSED_E3FF.cpp */
				4208	HANDLE_OPCODE(OP_UNUSED_E3FF)
				4209	OP_END
				4210
				4211	/* File: c/OP_UNUSED_E4FF.cpp */
				4212	HANDLE_OPCODE(OP_UNUSED_E4FF)
				4213	OP_END
				4214
				4215	/* File: c/OP_UNUSED_E5FF.cpp */
				4216	HANDLE_OPCODE(OP_UNUSED_E5FF)
				4217	OP_END
				4218
				4219	/* File: c/OP_UNUSED_E6FF.cpp */
				4220	HANDLE_OPCODE(OP_UNUSED_E6FF)
				4221	OP_END
				4222
				4223	/* File: c/OP_UNUSED_E7FF.cpp */
				4224	HANDLE_OPCODE(OP_UNUSED_E7FF)
				4225	OP_END
				4226
				4227	/* File: c/OP_UNUSED_E8FF.cpp */
				4228	HANDLE_OPCODE(OP_UNUSED_E8FF)
				4229	OP_END
				4230
				4231	/* File: c/OP_UNUSED_E9FF.cpp */
				4232	HANDLE_OPCODE(OP_UNUSED_E9FF)
				4233	OP_END
				4234
				4235	/* File: c/OP_UNUSED_EAFF.cpp */
				4236	HANDLE_OPCODE(OP_UNUSED_EAFF)
				4237	OP_END
				4238
				4239	/* File: c/OP_UNUSED_EBFF.cpp */
				4240	HANDLE_OPCODE(OP_UNUSED_EBFF)
				4241	OP_END
				4242
				4243	/* File: c/OP_UNUSED_ECFF.cpp */
				4244	HANDLE_OPCODE(OP_UNUSED_ECFF)
				4245	OP_END
				4246
				4247	/* File: c/OP_UNUSED_EDFF.cpp */
				4248	HANDLE_OPCODE(OP_UNUSED_EDFF)
				4249	OP_END
				4250
				4251	/* File: c/OP_UNUSED_EEFF.cpp */
				4252	HANDLE_OPCODE(OP_UNUSED_EEFF)
				4253	OP_END
				4254
				4255	/* File: c/OP_UNUSED_EFFF.cpp */
				4256	HANDLE_OPCODE(OP_UNUSED_EFFF)
				4257	OP_END
				4258
				4259	/* File: c/OP_UNUSED_F0FF.cpp */
				4260	HANDLE_OPCODE(OP_UNUSED_F0FF)
				4261	OP_END
				4262
				4263	/* File: c/OP_UNUSED_F1FF.cpp */
				4264	HANDLE_OPCODE(OP_UNUSED_F1FF)
				4265	/*
				4266	* In portable interp, most unused opcodes will fall through to here.
				4267	*/
				4268	LOGE("unknown opcode 0x%04x\n", inst);
				4269	dvmAbort();
				4270	FINISH(1);
				4271	OP_END
				4272
				4273	/* File: c/OP_INVOKE_OBJECT_INIT_JUMBO.cpp */
				4274	HANDLE_OPCODE(OP_INVOKE_OBJECT_INIT_JUMBO /{vCCCC..vNNNN}, meth@AAAAAAAA/)
				4275	{
				4276	Object* obj;
				4277
				4278	vsrc1 = FETCH(4); /* reg number of "this" pointer */
				4279	obj = GET_REGISTER_AS_OBJECT(vsrc1);
				4280
				4281	if (!checkForNullExportPC(obj, fp, pc))
				4282	GOTO_exceptionThrown();
				4283
				4284	/*
				4285	* The object should be marked "finalizable" when Object.<init>
				4286	* completes normally. We're going to assume it does complete
				4287	* (by virtue of being nothing but a return-void) and set it now.
				4288	*/
				4289	if (IS_CLASS_FLAG_SET(obj->clazz, CLASS_ISFINALIZABLE)) {
				4290	EXPORT_PC();
				4291	dvmSetFinalizable(obj);
				4292	if (dvmGetException(self))
				4293	GOTO_exceptionThrown();
				4294	}
				4295
				4296	if (self->interpBreak.ctl.subMode & kSubModeDebuggerActive) {
				4297	/* behave like OP_INVOKE_DIRECT_RANGE */
				4298	GOTO_invoke(invokeDirect, true, true);
				4299	}
				4300	FINISH(5);
				4301	}
				4302	OP_END
				4303
				4304	/* File: c/OP_IGET_VOLATILE_JUMBO.cpp */
				4305	HANDLE_IGET_X_JUMBO(OP_IGET_VOLATILE_JUMBO, "-volatile/jumbo", IntVolatile, )
				4306	OP_END
				4307
				4308	/* File: c/OP_IGET_WIDE_VOLATILE_JUMBO.cpp */
				4309	HANDLE_IGET_X_JUMBO(OP_IGET_WIDE_VOLATILE_JUMBO, "-wide-volatile/jumbo", LongVolatile, _WIDE)
				4310	OP_END
				4311
				4312	/* File: c/OP_IGET_OBJECT_VOLATILE_JUMBO.cpp */
				4313	HANDLE_IGET_X_JUMBO(OP_IGET_OBJECT_VOLATILE_JUMBO, "-object-volatile/jumbo", ObjectVolatile, _AS_OBJECT)
				4314	OP_END
				4315
				4316	/* File: c/OP_IPUT_VOLATILE_JUMBO.cpp */
				4317	HANDLE_IPUT_X_JUMBO(OP_IPUT_VOLATILE_JUMBO, "-volatile/jumbo", IntVolatile, )
				4318	OP_END
				4319
				4320	/* File: c/OP_IPUT_WIDE_VOLATILE_JUMBO.cpp */
				4321	HANDLE_IPUT_X_JUMBO(OP_IPUT_WIDE_VOLATILE_JUMBO, "-wide-volatile/jumbo", LongVolatile, _WIDE)
				4322	OP_END
				4323
				4324	/* File: c/OP_IPUT_OBJECT_VOLATILE_JUMBO.cpp */
				4325	HANDLE_IPUT_X_JUMBO(OP_IPUT_OBJECT_VOLATILE_JUMBO, "-object-volatile/jumbo", ObjectVolatile, _AS_OBJECT)
				4326	OP_END
				4327
				4328	/* File: c/OP_SGET_VOLATILE_JUMBO.cpp */
				4329	HANDLE_SGET_X_JUMBO(OP_SGET_VOLATILE_JUMBO, "-volatile/jumbo", IntVolatile, )
				4330	OP_END
				4331
				4332	/* File: c/OP_SGET_WIDE_VOLATILE_JUMBO.cpp */
				4333	HANDLE_SGET_X_JUMBO(OP_SGET_WIDE_VOLATILE_JUMBO, "-wide-volatile/jumbo", LongVolatile, _WIDE)
				4334	OP_END
				4335
				4336	/* File: c/OP_SGET_OBJECT_VOLATILE_JUMBO.cpp */
				4337	HANDLE_SGET_X_JUMBO(OP_SGET_OBJECT_VOLATILE_JUMBO, "-object-volatile/jumbo", ObjectVolatile, _AS_OBJECT)
				4338	OP_END
				4339
				4340	/* File: c/OP_SPUT_VOLATILE_JUMBO.cpp */
				4341	HANDLE_SPUT_X_JUMBO(OP_SPUT_VOLATILE_JUMBO, "-volatile", IntVolatile, )
				4342	OP_END
				4343
				4344	/* File: c/OP_SPUT_WIDE_VOLATILE_JUMBO.cpp */
				4345	HANDLE_SPUT_X_JUMBO(OP_SPUT_WIDE_VOLATILE_JUMBO, "-wide-volatile/jumbo", LongVolatile, _WIDE)
				4346	OP_END
				4347
				4348	/* File: c/OP_SPUT_OBJECT_VOLATILE_JUMBO.cpp */
				4349	HANDLE_SPUT_X_JUMBO(OP_SPUT_OBJECT_VOLATILE_JUMBO, "-object-volatile/jumbo", ObjectVolatile, _AS_OBJECT)
				4350	OP_END
				4351
				4352	/* File: c/OP_THROW_VERIFICATION_ERROR_JUMBO.cpp */
				4353	HANDLE_OPCODE(OP_THROW_VERIFICATION_ERROR_JUMBO)
				4354	EXPORT_PC();
				4355	vsrc1 = FETCH(3);
				4356	ref = FETCH(1) \| (u4)FETCH(2) << 16; /* class/field/method ref */
				4357	dvmThrowVerificationError(curMethod, vsrc1, ref);
				4358	GOTO_exceptionThrown();
				4359	OP_END
				4360
				4361	/* File: cstubs/entry.cpp */
				4362	/*
				4363	* Handler function table, one entry per opcode.
				4364	*/
				4365	#undef H
				4366	#define H(_op) dvmMterp_##_op
				4367	DEFINE_GOTO_TABLE(gDvmMterpHandlers)
				4368
				4369	#undef H
				4370	#define H(_op) #_op
				4371	DEFINE_GOTO_TABLE(gDvmMterpHandlerNames)
				4372
				4373	#include <setjmp.h>
				4374
				4375	/*
				4376	* C mterp entry point. This just calls the various C fallbacks, making
				4377	* this a slow but portable interpeter.
				4378	*
				4379	* This is only used for the "allstubs" variant.
				4380	*/
				4381	void dvmMterpStdRun(Thread* self)
				4382	{
				4383	jmp_buf jmpBuf;
				4384
				4385	self->bailPtr = &jmpBuf;
				4386
				4387	/* We exit via a longjmp */
				4388	if (setjmp(jmpBuf)) {
				4389	LOGVV("mterp threadid=%d returning\n", dvmThreadSelf()->threadId);
				4390	return
				4391	}
				4392
				4393	/* run until somebody longjmp()s out */
				4394	while (true) {
				4395	typedef void (Handler)(Thread self);
				4396
				4397	u2 inst = /self->interpSave./pc[0];
				4398	/*
				4399	* In mterp, dvmCheckBefore is handled via the altHandlerTable,
				4400	* while in the portable interpreter it is part of the handler
				4401	* FINISH code. For allstubs, we must do an explicit check
				4402	* in the interpretation loop.
				4403	*/
				4404	if (self-interpBreak.ctl.subMode) {
				4405	dvmCheckBefore(pc, fp, self, curMethod);
				4406	}
				4407	Handler handler = (Handler) gDvmMterpHandlers[inst & 0xff];
				4408	(void) gDvmMterpHandlerNames; /* avoid gcc "defined but not used" */
				4409	LOGVV("handler %p %s\n",
				4410	handler, (const char*) gDvmMterpHandlerNames[inst & 0xff]);
				4411	(*handler)(self);
				4412	}
				4413	}
				4414
				4415	/*
				4416	* C mterp exit point. Call here to bail out of the interpreter.
				4417	*/
				4418	void dvmMterpStdBail(Thread* self)
				4419	{
				4420	jmp_buf* pJmpBuf = self->bailPtr;
				4421	longjmp(*pJmpBuf, 1);
				4422	}
				4423
				4424	/* File: c/gotoTargets.cpp */
				4425	/*
				4426	* C footer. This has some common code shared by the various targets.
				4427	*/
				4428
				4429	/*
				4430	* Everything from here on is a "goto target". In the basic interpreter
				4431	* we jump into these targets and then jump directly to the handler for
				4432	* next instruction. Here, these are subroutines that return to the caller.
				4433	*/
				4434
				4435	GOTO_TARGET(filledNewArray, bool methodCallRange, bool jumboFormat)
				4436	{
				4437	ClassObject* arrayClass;
				4438	ArrayObject* newArray;
				4439	u4* contents;
				4440	char typeCh;
				4441	int i;
				4442	u4 arg5;
				4443
				4444	EXPORT_PC();
				4445
				4446	if (jumboFormat) {
				4447	ref = FETCH(1) \| (u4)FETCH(2) << 16; /* class ref */
				4448	vsrc1 = FETCH(3); /* #of elements */
				4449	vdst = FETCH(4); /* range base */
				4450	arg5 = -1; /* silence compiler warning */
				4451	ILOGV("\|filled-new-array/jumbo args=%d @0x%08x {regs=v%d-v%d}",
				4452	vsrc1, ref, vdst, vdst+vsrc1-1);
				4453	} else {
				4454	ref = FETCH(1); /* class ref */
				4455	vdst = FETCH(2); /* first 4 regs -or- range base */
				4456
				4457	if (methodCallRange) {
				4458	vsrc1 = INST_AA(inst); /* #of elements */
				4459	arg5 = -1; /* silence compiler warning */
				4460	ILOGV("\|filled-new-array-range args=%d @0x%04x {regs=v%d-v%d}",
				4461	vsrc1, ref, vdst, vdst+vsrc1-1);
				4462	} else {
				4463	arg5 = INST_A(inst);
				4464	vsrc1 = INST_B(inst); /* #of elements */
				4465	ILOGV("\|filled-new-array args=%d @0x%04x {regs=0x%04x %x}",
				4466	vsrc1, ref, vdst, arg5);
				4467	}
				4468	}
				4469
				4470	/*
				4471	* Resolve the array class.
				4472	*/
				4473	arrayClass = dvmDexGetResolvedClass(methodClassDex, ref);
				4474	if (arrayClass == NULL) {
				4475	arrayClass = dvmResolveClass(curMethod->clazz, ref, false);
				4476	if (arrayClass == NULL)
				4477	GOTO_exceptionThrown();
				4478	}
				4479	/*
				4480	if (!dvmIsArrayClass(arrayClass)) {
				4481	dvmThrowRuntimeException(
				4482	"filled-new-array needs array class");
				4483	GOTO_exceptionThrown();
				4484	}
				4485	*/
				4486	/* verifier guarantees this is an array class */
				4487	assert(dvmIsArrayClass(arrayClass));
				4488	assert(dvmIsClassInitialized(arrayClass));
				4489
				4490	/*
				4491	* Create an array of the specified type.
				4492	*/
				4493	LOGVV("+++ filled-new-array type is '%s'\n", arrayClass->descriptor);
				4494	typeCh = arrayClass->descriptor[1];
				4495	if (typeCh == 'D' \|\| typeCh == 'J') {
				4496	/* category 2 primitives not allowed */
				4497	dvmThrowRuntimeException("bad filled array req");
				4498	GOTO_exceptionThrown();
				4499	} else if (typeCh != 'L' && typeCh != '[' && typeCh != 'I') {
				4500	/* TODO: requires multiple "fill in" loops with different widths */
				4501	LOGE("non-int primitives not implemented\n");
				4502	dvmThrowInternalError(
				4503	"filled-new-array not implemented for anything but 'int'");
				4504	GOTO_exceptionThrown();
				4505	}
				4506
				4507	newArray = dvmAllocArrayByClass(arrayClass, vsrc1, ALLOC_DONT_TRACK);
				4508	if (newArray == NULL)
				4509	GOTO_exceptionThrown();
				4510
				4511	/*
				4512	* Fill in the elements. It's legal for vsrc1 to be zero.
				4513	*/
				4514	contents = (u4)(void)newArray->contents;
				4515	if (methodCallRange) {
				4516	for (i = 0; i < vsrc1; i++)
				4517	contents[i] = GET_REGISTER(vdst+i);
				4518	} else {
				4519	assert(vsrc1 <= 5);
				4520	if (vsrc1 == 5) {
				4521	contents[4] = GET_REGISTER(arg5);
				4522	vsrc1--;
				4523	}
				4524	for (i = 0; i < vsrc1; i++) {
				4525	contents[i] = GET_REGISTER(vdst & 0x0f);
				4526	vdst >>= 4;
				4527	}
				4528	}
				4529	if (typeCh == 'L' \|\| typeCh == '[') {
				4530	dvmWriteBarrierArray(newArray, 0, newArray->length);
				4531	}
				4532
				4533	retval.l = newArray;
				4534	}
				4535	if (jumboFormat) {
				4536	FINISH(5);
				4537	} else {
				4538	FINISH(3);
				4539	}
				4540	GOTO_TARGET_END
				4541
				4542
				4543	GOTO_TARGET(invokeVirtual, bool methodCallRange, bool jumboFormat)
				4544	{
				4545	Method* baseMethod;
				4546	Object* thisPtr;
				4547
				4548	EXPORT_PC();
				4549
				4550	if (jumboFormat) {
				4551	ref = FETCH(1) \| (u4)FETCH(2) << 16; /* method ref */
				4552	vsrc1 = FETCH(3); /* count */
				4553	vdst = FETCH(4); /* first reg */
				4554	ADJUST_PC(2); /* advance pc partially to make returns easier */
				4555	ILOGV("\|invoke-virtual/jumbo args=%d @0x%08x {regs=v%d-v%d}",
				4556	vsrc1, ref, vdst, vdst+vsrc1-1);
				4557	thisPtr = (Object*) GET_REGISTER(vdst);
				4558	} else {
				4559	vsrc1 = INST_AA(inst); /* AA (count) or BA (count + arg 5) */
				4560	ref = FETCH(1); /* method ref */
				4561	vdst = FETCH(2); /* 4 regs -or- first reg */
				4562
				4563	/*
				4564	* The object against which we are executing a method is always
				4565	* in the first argument.
				4566	*/
				4567	if (methodCallRange) {
				4568	assert(vsrc1 > 0);
				4569	ILOGV("\|invoke-virtual-range args=%d @0x%04x {regs=v%d-v%d}",
				4570	vsrc1, ref, vdst, vdst+vsrc1-1);
				4571	thisPtr = (Object*) GET_REGISTER(vdst);
				4572	} else {
				4573	assert((vsrc1>>4) > 0);
				4574	ILOGV("\|invoke-virtual args=%d @0x%04x {regs=0x%04x %x}",
				4575	vsrc1 >> 4, ref, vdst, vsrc1 & 0x0f);
				4576	thisPtr = (Object*) GET_REGISTER(vdst & 0x0f);
				4577	}
				4578	}
				4579
				4580	if (!checkForNull(thisPtr))
				4581	GOTO_exceptionThrown();
				4582
				4583	/*
				4584	* Resolve the method. This is the correct method for the static
				4585	* type of the object. We also verify access permissions here.
				4586	*/
				4587	baseMethod = dvmDexGetResolvedMethod(methodClassDex, ref);
				4588	if (baseMethod == NULL) {
				4589	baseMethod = dvmResolveMethod(curMethod->clazz, ref,METHOD_VIRTUAL);
				4590	if (baseMethod == NULL) {
				4591	ILOGV("+ unknown method or access denied\n");
				4592	GOTO_exceptionThrown();
				4593	}
				4594	}
				4595
				4596	/*
				4597	* Combine the object we found with the vtable offset in the
				4598	* method.
				4599	*/
				4600	assert(baseMethod->methodIndex < thisPtr->clazz->vtableCount);
				4601	methodToCall = thisPtr->clazz->vtable[baseMethod->methodIndex];
				4602
				4603	#if defined(WITH_JIT) && defined(MTERP_STUB)
				4604	self->methodToCall = methodToCall;
				4605	self->callsiteClass = thisPtr->clazz;
				4606	#endif
				4607
				4608	#if 0
				4609	if (dvmIsAbstractMethod(methodToCall)) {
				4610	/*
				4611	* This can happen if you create two classes, Base and Sub, where
				4612	* Sub is a sub-class of Base. Declare a protected abstract
				4613	* method foo() in Base, and invoke foo() from a method in Base.
				4614	* Base is an "abstract base class" and is never instantiated
				4615	* directly. Now, Override foo() in Sub, and use Sub. This
				4616	* Works fine unless Sub stops providing an implementation of
				4617	* the method.
				4618	*/
				4619	dvmThrowAbstractMethodError("abstract method not implemented");
				4620	GOTO_exceptionThrown();
				4621	}
				4622	#else
				4623	assert(!dvmIsAbstractMethod(methodToCall) \|\|
				4624	methodToCall->nativeFunc != NULL);
				4625	#endif
				4626
				4627	LOGVV("+++ base=%s.%s virtual[%d]=%s.%s\n",
				4628	baseMethod->clazz->descriptor, baseMethod->name,
				4629	(u4) baseMethod->methodIndex,
				4630	methodToCall->clazz->descriptor, methodToCall->name);
				4631	assert(methodToCall != NULL);
				4632
				4633	#if 0
				4634	if (vsrc1 != methodToCall->insSize) {
				4635	LOGW("WRONG METHOD: base=%s.%s virtual[%d]=%s.%s\n",
				4636	baseMethod->clazz->descriptor, baseMethod->name,
				4637	(u4) baseMethod->methodIndex,
				4638	methodToCall->clazz->descriptor, methodToCall->name);
				4639	//dvmDumpClass(baseMethod->clazz);
				4640	//dvmDumpClass(methodToCall->clazz);
				4641	dvmDumpAllClasses(0);
				4642	}
				4643	#endif
				4644
				4645	GOTO_invokeMethod(methodCallRange, methodToCall, vsrc1, vdst);
				4646	}
				4647	GOTO_TARGET_END
				4648
				4649	GOTO_TARGET(invokeSuper, bool methodCallRange, bool jumboFormat)
				4650	{
				4651	Method* baseMethod;
				4652	u2 thisReg;
				4653
				4654	EXPORT_PC();
				4655
				4656	if (jumboFormat) {
				4657	ref = FETCH(1) \| (u4)FETCH(2) << 16; /* method ref */
				4658	vsrc1 = FETCH(3); /* count */
				4659	vdst = FETCH(4); /* first reg */
				4660	ADJUST_PC(2); /* advance pc partially to make returns easier */
				4661	ILOGV("\|invoke-super/jumbo args=%d @0x%08x {regs=v%d-v%d}",
				4662	vsrc1, ref, vdst, vdst+vsrc1-1);
				4663	thisReg = vdst;
				4664	} else {
				4665	vsrc1 = INST_AA(inst); /* AA (count) or BA (count + arg 5) */
				4666	ref = FETCH(1); /* method ref */
				4667	vdst = FETCH(2); /* 4 regs -or- first reg */
				4668
				4669	if (methodCallRange) {
				4670	ILOGV("\|invoke-super-range args=%d @0x%04x {regs=v%d-v%d}",
				4671	vsrc1, ref, vdst, vdst+vsrc1-1);
				4672	thisReg = vdst;
				4673	} else {
				4674	ILOGV("\|invoke-super args=%d @0x%04x {regs=0x%04x %x}",
				4675	vsrc1 >> 4, ref, vdst, vsrc1 & 0x0f);
				4676	thisReg = vdst & 0x0f;
				4677	}
				4678	}
				4679
				4680	/* impossible in well-formed code, but we must check nevertheless */
				4681	if (!checkForNull((Object*) GET_REGISTER(thisReg)))
				4682	GOTO_exceptionThrown();
				4683
				4684	/*
				4685	* Resolve the method. This is the correct method for the static
				4686	* type of the object. We also verify access permissions here.
				4687	* The first arg to dvmResolveMethod() is just the referring class
				4688	* (used for class loaders and such), so we don't want to pass
				4689	* the superclass into the resolution call.
				4690	*/
				4691	baseMethod = dvmDexGetResolvedMethod(methodClassDex, ref);
				4692	if (baseMethod == NULL) {
				4693	baseMethod = dvmResolveMethod(curMethod->clazz, ref,METHOD_VIRTUAL);
				4694	if (baseMethod == NULL) {
				4695	ILOGV("+ unknown method or access denied\n");
				4696	GOTO_exceptionThrown();
				4697	}
				4698	}
				4699
				4700	/*
				4701	* Combine the object we found with the vtable offset in the
				4702	* method's class.
				4703	*
				4704	* We're using the current method's class' superclass, not the
				4705	* superclass of "this". This is because we might be executing
				4706	* in a method inherited from a superclass, and we want to run
				4707	* in that class' superclass.
				4708	*/
				4709	if (baseMethod->methodIndex >= curMethod->clazz->super->vtableCount) {
				4710	/*
				4711	* Method does not exist in the superclass. Could happen if
				4712	* superclass gets updated.
				4713	*/
				4714	dvmThrowNoSuchMethodError(baseMethod->name);
				4715	GOTO_exceptionThrown();
				4716	}
				4717	methodToCall = curMethod->clazz->super->vtable[baseMethod->methodIndex];
				4718
				4719	#if 0
				4720	if (dvmIsAbstractMethod(methodToCall)) {
				4721	dvmThrowAbstractMethodError("abstract method not implemented");
				4722	GOTO_exceptionThrown();
				4723	}
				4724	#else
				4725	assert(!dvmIsAbstractMethod(methodToCall) \|\|
				4726	methodToCall->nativeFunc != NULL);
				4727	#endif
				4728	LOGVV("+++ base=%s.%s super-virtual=%s.%s\n",
				4729	baseMethod->clazz->descriptor, baseMethod->name,
				4730	methodToCall->clazz->descriptor, methodToCall->name);
				4731	assert(methodToCall != NULL);
				4732
				4733	GOTO_invokeMethod(methodCallRange, methodToCall, vsrc1, vdst);
				4734	}
				4735	GOTO_TARGET_END
				4736
				4737	GOTO_TARGET(invokeInterface, bool methodCallRange, bool jumboFormat)
				4738	{
				4739	Object* thisPtr;
				4740	ClassObject* thisClass;
				4741
				4742	EXPORT_PC();
				4743
				4744	if (jumboFormat) {
				4745	ref = FETCH(1) \| (u4)FETCH(2) << 16; /* method ref */
				4746	vsrc1 = FETCH(3); /* count */
				4747	vdst = FETCH(4); /* first reg */
				4748	ADJUST_PC(2); /* advance pc partially to make returns easier */
				4749	ILOGV("\|invoke-interface/jumbo args=%d @0x%08x {regs=v%d-v%d}",
				4750	vsrc1, ref, vdst, vdst+vsrc1-1);
				4751	thisPtr = (Object*) GET_REGISTER(vdst);
				4752	} else {
				4753	vsrc1 = INST_AA(inst); /* AA (count) or BA (count + arg 5) */
				4754	ref = FETCH(1); /* method ref */
				4755	vdst = FETCH(2); /* 4 regs -or- first reg */
				4756
				4757	/*
				4758	* The object against which we are executing a method is always
				4759	* in the first argument.
				4760	*/
				4761	if (methodCallRange) {
				4762	assert(vsrc1 > 0);
				4763	ILOGV("\|invoke-interface-range args=%d @0x%04x {regs=v%d-v%d}",
				4764	vsrc1, ref, vdst, vdst+vsrc1-1);
				4765	thisPtr = (Object*) GET_REGISTER(vdst);
				4766	} else {
				4767	assert((vsrc1>>4) > 0);
				4768	ILOGV("\|invoke-interface args=%d @0x%04x {regs=0x%04x %x}",
				4769	vsrc1 >> 4, ref, vdst, vsrc1 & 0x0f);
				4770	thisPtr = (Object*) GET_REGISTER(vdst & 0x0f);
				4771	}
				4772	}
				4773
				4774	if (!checkForNull(thisPtr))
				4775	GOTO_exceptionThrown();
				4776
				4777	thisClass = thisPtr->clazz;
				4778
				4779
				4780	/*
				4781	* Given a class and a method index, find the Method* with the
				4782	* actual code we want to execute.
				4783	*/
				4784	methodToCall = dvmFindInterfaceMethodInCache(thisClass, ref, curMethod,
				4785	methodClassDex);
				4786	#if defined(WITH_JIT) && defined(MTERP_STUB)
				4787	self->callsiteClass = thisClass;
				4788	self->methodToCall = methodToCall;
				4789	#endif
				4790	if (methodToCall == NULL) {
				4791	assert(dvmCheckException(self));
				4792	GOTO_exceptionThrown();
				4793	}
				4794
				4795	GOTO_invokeMethod(methodCallRange, methodToCall, vsrc1, vdst);
				4796	}
				4797	GOTO_TARGET_END
				4798
				4799	GOTO_TARGET(invokeDirect, bool methodCallRange, bool jumboFormat)
				4800	{
				4801	u2 thisReg;
				4802
				4803	EXPORT_PC();
				4804
				4805	if (jumboFormat) {
				4806	ref = FETCH(1) \| (u4)FETCH(2) << 16; /* method ref */
				4807	vsrc1 = FETCH(3); /* count */
				4808	vdst = FETCH(4); /* first reg */
				4809	ADJUST_PC(2); /* advance pc partially to make returns easier */
				4810	ILOGV("\|invoke-direct/jumbo args=%d @0x%08x {regs=v%d-v%d}",
				4811	vsrc1, ref, vdst, vdst+vsrc1-1);
				4812	thisReg = vdst;
				4813	} else {
				4814	vsrc1 = INST_AA(inst); /* AA (count) or BA (count + arg 5) */
				4815	ref = FETCH(1); /* method ref */
				4816	vdst = FETCH(2); /* 4 regs -or- first reg */
				4817
				4818	if (methodCallRange) {
				4819	ILOGV("\|invoke-direct-range args=%d @0x%04x {regs=v%d-v%d}",
				4820	vsrc1, ref, vdst, vdst+vsrc1-1);
				4821	thisReg = vdst;
				4822	} else {
				4823	ILOGV("\|invoke-direct args=%d @0x%04x {regs=0x%04x %x}",
				4824	vsrc1 >> 4, ref, vdst, vsrc1 & 0x0f);
				4825	thisReg = vdst & 0x0f;
				4826	}
				4827	}
				4828
				4829	if (!checkForNull((Object*) GET_REGISTER(thisReg)))
				4830	GOTO_exceptionThrown();
				4831
				4832	methodToCall = dvmDexGetResolvedMethod(methodClassDex, ref);
				4833	if (methodToCall == NULL) {
				4834	methodToCall = dvmResolveMethod(curMethod->clazz, ref,
				4835	METHOD_DIRECT);
				4836	if (methodToCall == NULL) {
				4837	ILOGV("+ unknown direct method\n"); // should be impossible
				4838	GOTO_exceptionThrown();
				4839	}
				4840	}
				4841	GOTO_invokeMethod(methodCallRange, methodToCall, vsrc1, vdst);
				4842	}
				4843	GOTO_TARGET_END
				4844
				4845	GOTO_TARGET(invokeStatic, bool methodCallRange, bool jumboFormat)
				4846	EXPORT_PC();
				4847
				4848	if (jumboFormat) {
				4849	ref = FETCH(1) \| (u4)FETCH(2) << 16; /* method ref */
				4850	vsrc1 = FETCH(3); /* count */
				4851	vdst = FETCH(4); /* first reg */
				4852	ADJUST_PC(2); /* advance pc partially to make returns easier */
				4853	ILOGV("\|invoke-static/jumbo args=%d @0x%08x {regs=v%d-v%d}",
				4854	vsrc1, ref, vdst, vdst+vsrc1-1);
				4855	} else {
				4856	vsrc1 = INST_AA(inst); /* AA (count) or BA (count + arg 5) */
				4857	ref = FETCH(1); /* method ref */
				4858	vdst = FETCH(2); /* 4 regs -or- first reg */
				4859
				4860	if (methodCallRange)
				4861	ILOGV("\|invoke-static-range args=%d @0x%04x {regs=v%d-v%d}",
				4862	vsrc1, ref, vdst, vdst+vsrc1-1);
				4863	else
				4864	ILOGV("\|invoke-static args=%d @0x%04x {regs=0x%04x %x}",
				4865	vsrc1 >> 4, ref, vdst, vsrc1 & 0x0f);
				4866	}
				4867
				4868	methodToCall = dvmDexGetResolvedMethod(methodClassDex, ref);
				4869	if (methodToCall == NULL) {
				4870	methodToCall = dvmResolveMethod(curMethod->clazz, ref, METHOD_STATIC);
				4871	if (methodToCall == NULL) {
				4872	ILOGV("+ unknown method\n");
				4873	GOTO_exceptionThrown();
				4874	}
				4875
				4876	#if defined(WITH_JIT) && defined(MTERP_STUB)
				4877	/*
				4878	* The JIT needs dvmDexGetResolvedMethod() to return non-null.
				4879	* Include the check if this code is being used as a stub
				4880	* called from the assembly interpreter.
				4881	*/
				4882	if ((self->interpBreak.ctl.subMode & kSubModeJitTraceBuild) &&
				4883	(dvmDexGetResolvedMethod(methodClassDex, ref) == NULL)) {
				4884	/* Class initialization is still ongoing */
				4885	dvmJitEndTraceSelect(self,pc);
				4886	}
				4887	#endif
				4888	}
				4889	GOTO_invokeMethod(methodCallRange, methodToCall, vsrc1, vdst);
				4890	GOTO_TARGET_END
				4891
				4892	GOTO_TARGET(invokeVirtualQuick, bool methodCallRange, bool jumboFormat)
				4893	{
				4894	Object* thisPtr;
				4895
				4896	EXPORT_PC();
				4897
				4898	vsrc1 = INST_AA(inst); /* AA (count) or BA (count + arg 5) */
				4899	ref = FETCH(1); /* vtable index */
				4900	vdst = FETCH(2); /* 4 regs -or- first reg */
				4901
				4902	/*
				4903	* The object against which we are executing a method is always
				4904	* in the first argument.
				4905	*/
				4906	if (methodCallRange) {
				4907	assert(vsrc1 > 0);
				4908	ILOGV("\|invoke-virtual-quick-range args=%d @0x%04x {regs=v%d-v%d}",
				4909	vsrc1, ref, vdst, vdst+vsrc1-1);
				4910	thisPtr = (Object*) GET_REGISTER(vdst);
				4911	} else {
				4912	assert((vsrc1>>4) > 0);
				4913	ILOGV("\|invoke-virtual-quick args=%d @0x%04x {regs=0x%04x %x}",
				4914	vsrc1 >> 4, ref, vdst, vsrc1 & 0x0f);
				4915	thisPtr = (Object*) GET_REGISTER(vdst & 0x0f);
				4916	}
				4917
				4918	if (!checkForNull(thisPtr))
				4919	GOTO_exceptionThrown();
				4920
				4921
				4922	/*
				4923	* Combine the object we found with the vtable offset in the
				4924	* method.
				4925	*/
				4926	assert(ref < (unsigned int) thisPtr->clazz->vtableCount);
				4927	methodToCall = thisPtr->clazz->vtable[ref];
				4928	#if defined(WITH_JIT) && defined(MTERP_STUB)
				4929	self->callsiteClass = thisPtr->clazz;
				4930	self->methodToCall = methodToCall;
				4931	#endif
				4932
				4933	#if 0
				4934	if (dvmIsAbstractMethod(methodToCall)) {
				4935	dvmThrowAbstractMethodError("abstract method not implemented");
				4936	GOTO_exceptionThrown();
				4937	}
				4938	#else
				4939	assert(!dvmIsAbstractMethod(methodToCall) \|\|
				4940	methodToCall->nativeFunc != NULL);
				4941	#endif
				4942
				4943	LOGVV("+++ virtual[%d]=%s.%s\n",
				4944	ref, methodToCall->clazz->descriptor, methodToCall->name);
				4945	assert(methodToCall != NULL);
				4946
				4947	GOTO_invokeMethod(methodCallRange, methodToCall, vsrc1, vdst);
				4948	}
				4949	GOTO_TARGET_END
				4950
				4951	GOTO_TARGET(invokeSuperQuick, bool methodCallRange, bool jumboFormat)
				4952	{
				4953	u2 thisReg;
				4954
				4955	EXPORT_PC();
				4956
				4957	vsrc1 = INST_AA(inst); /* AA (count) or BA (count + arg 5) */
				4958	ref = FETCH(1); /* vtable index */
				4959	vdst = FETCH(2); /* 4 regs -or- first reg */
				4960
				4961	if (methodCallRange) {
				4962	ILOGV("\|invoke-super-quick-range args=%d @0x%04x {regs=v%d-v%d}",
				4963	vsrc1, ref, vdst, vdst+vsrc1-1);
				4964	thisReg = vdst;
				4965	} else {
				4966	ILOGV("\|invoke-super-quick args=%d @0x%04x {regs=0x%04x %x}",
				4967	vsrc1 >> 4, ref, vdst, vsrc1 & 0x0f);
				4968	thisReg = vdst & 0x0f;
				4969	}
				4970	/* impossible in well-formed code, but we must check nevertheless */
				4971	if (!checkForNull((Object*) GET_REGISTER(thisReg)))
				4972	GOTO_exceptionThrown();
				4973
				4974	#if 0 /* impossible in optimized + verified code */
				4975	if (ref >= curMethod->clazz->super->vtableCount) {
				4976	dvmThrowNoSuchMethodError(NULL);
				4977	GOTO_exceptionThrown();
				4978	}
				4979	#else
				4980	assert(ref < (unsigned int) curMethod->clazz->super->vtableCount);
				4981	#endif
				4982
				4983	/*
				4984	* Combine the object we found with the vtable offset in the
				4985	* method's class.
				4986	*
				4987	* We're using the current method's class' superclass, not the
				4988	* superclass of "this". This is because we might be executing
				4989	* in a method inherited from a superclass, and we want to run
				4990	* in the method's class' superclass.
				4991	*/
				4992	methodToCall = curMethod->clazz->super->vtable[ref];
				4993
				4994	#if 0
				4995	if (dvmIsAbstractMethod(methodToCall)) {
				4996	dvmThrowAbstractMethodError("abstract method not implemented");
				4997	GOTO_exceptionThrown();
				4998	}
				4999	#else
				5000	assert(!dvmIsAbstractMethod(methodToCall) \|\|
				5001	methodToCall->nativeFunc != NULL);
				5002	#endif
				5003	LOGVV("+++ super-virtual[%d]=%s.%s\n",
				5004	ref, methodToCall->clazz->descriptor, methodToCall->name);
				5005	assert(methodToCall != NULL);
				5006	GOTO_invokeMethod(methodCallRange, methodToCall, vsrc1, vdst);
				5007	}
				5008	GOTO_TARGET_END
				5009
				5010
				5011	/*
				5012	* General handling for return-void, return, and return-wide. Put the
				5013	* return value in "retval" before jumping here.
				5014	*/
				5015	GOTO_TARGET(returnFromMethod)
				5016	{
				5017	StackSaveArea* saveArea;
				5018
				5019	/*
				5020	* We must do this BEFORE we pop the previous stack frame off, so
				5021	* that the GC can see the return value (if any) in the local vars.
				5022	*
				5023	* Since this is now an interpreter switch point, we must do it before
				5024	* we do anything at all.
				5025	*/
				5026	PERIODIC_CHECKS(0);
				5027
				5028	ILOGV("> retval=0x%llx (leaving %s.%s %s)",
				5029	retval.j, curMethod->clazz->descriptor, curMethod->name,
				5030	curMethod->shorty);
				5031	//DUMP_REGS(curMethod, fp);
				5032
				5033	saveArea = SAVEAREA_FROM_FP(fp);
				5034
				5035	#ifdef EASY_GDB
				5036	debugSaveArea = saveArea;
				5037	#endif
				5038
				5039	/* back up to previous frame and see if we hit a break */
				5040	fp = (u4*)saveArea->prevFrame;
				5041	assert(fp != NULL);
				5042
				5043	/* Handle any special subMode requirements */
				5044	if (self->interpBreak.ctl.subMode != 0) {
				5045	PC_FP_TO_SELF();
				5046	dvmReportReturn(self);
				5047	}
				5048
				5049	if (dvmIsBreakFrame(fp)) {
				5050	/* bail without popping the method frame from stack */
				5051	LOGVV("+++ returned into break frame\n");
				5052	GOTO_bail();
				5053	}
				5054
				5055	/* update thread FP, and reset local variables */
				5056	self->curFrame = fp;
				5057	curMethod = SAVEAREA_FROM_FP(fp)->method;
				5058	self->interpSave.method = curMethod;
				5059	//methodClass = curMethod->clazz;
				5060	methodClassDex = curMethod->clazz->pDvmDex;
				5061	pc = saveArea->savedPc;
				5062	ILOGD("> (return to %s.%s %s)", curMethod->clazz->descriptor,
				5063	curMethod->name, curMethod->shorty);
				5064
				5065	/* use FINISH on the caller's invoke instruction */
				5066	//u2 invokeInstr = INST_INST(FETCH(0));
				5067	if (true /*invokeInstr >= OP_INVOKE_VIRTUAL &&
				5068	invokeInstr <= OP_INVOKE_INTERFACE*/)
				5069	{
				5070	FINISH(3);
				5071	} else {
				5072	//LOGE("Unknown invoke instr %02x at %d\n",
				5073	// invokeInstr, (int) (pc - curMethod->insns));
				5074	assert(false);
				5075	}
				5076	}
				5077	GOTO_TARGET_END
				5078
				5079
				5080	/*
				5081	* Jump here when the code throws an exception.
				5082	*
				5083	* By the time we get here, the Throwable has been created and the stack
				5084	* trace has been saved off.
				5085	*/
				5086	GOTO_TARGET(exceptionThrown)
				5087	{
				5088	Object* exception;
				5089	int catchRelPc;
				5090
				5091	PERIODIC_CHECKS(0);
				5092
				5093	/*
				5094	* We save off the exception and clear the exception status. While
				5095	* processing the exception we might need to load some Throwable
				5096	* classes, and we don't want class loader exceptions to get
				5097	* confused with this one.
				5098	*/
				5099	assert(dvmCheckException(self));
				5100	exception = dvmGetException(self);
				5101	dvmAddTrackedAlloc(exception, self);
				5102	dvmClearException(self);
				5103
				5104	LOGV("Handling exception %s at %s:%d\n",
				5105	exception->clazz->descriptor, curMethod->name,
				5106	dvmLineNumFromPC(curMethod, pc - curMethod->insns));
				5107
				5108	/*
				5109	* Report the exception throw to any "subMode" watchers.
				5110	*
				5111	* TODO: if the exception was thrown by interpreted code, control
				5112	* fell through native, and then back to us, we will report the
				5113	* exception at the point of the throw and again here. We can avoid
				5114	* this by not reporting exceptions when we jump here directly from
				5115	* the native call code above, but then we won't report exceptions
				5116	* that were thrown from the JNI code (as opposed to through it).
				5117	*
				5118	* The correct solution is probably to ignore from-native exceptions
				5119	* here, and have the JNI exception code do the reporting to the
				5120	* debugger.
				5121	*/
				5122	if (self->interpBreak.ctl.subMode != 0) {
				5123	PC_FP_TO_SELF();
				5124	dvmReportExceptionThrow(self, exception);
				5125	}
				5126
				5127	/*
				5128	* We need to unroll to the catch block or the nearest "break"
				5129	* frame.
				5130	*
				5131	* A break frame could indicate that we have reached an intermediate
				5132	* native call, or have gone off the top of the stack and the thread
				5133	* needs to exit. Either way, we return from here, leaving the
				5134	* exception raised.
				5135	*
				5136	* If we do find a catch block, we want to transfer execution to
				5137	* that point.
				5138	*
				5139	* Note this can cause an exception while resolving classes in
				5140	* the "catch" blocks.
				5141	*/
				5142	catchRelPc = dvmFindCatchBlock(self, pc - curMethod->insns,
				5143	exception, false, (void*)(void)&fp);
				5144
				5145	/*
				5146	* Restore the stack bounds after an overflow. This isn't going to
				5147	* be correct in all circumstances, e.g. if JNI code devours the
				5148	* exception this won't happen until some other exception gets
				5149	* thrown. If the code keeps pushing the stack bounds we'll end
				5150	* up aborting the VM.
				5151	*
				5152	* Note we want to do this after the call to dvmFindCatchBlock,
				5153	* because that may need extra stack space to resolve exception
				5154	* classes (e.g. through a class loader).
				5155	*
				5156	* It's possible for the stack overflow handling to cause an
				5157	* exception (specifically, class resolution in a "catch" block
				5158	* during the call above), so we could see the thread's overflow
				5159	* flag raised but actually be running in a "nested" interpreter
				5160	* frame. We don't allow doubled-up StackOverflowErrors, so
				5161	* we can check for this by just looking at the exception type
				5162	* in the cleanup function. Also, we won't unroll past the SOE
				5163	* point because the more-recent exception will hit a break frame
				5164	* as it unrolls to here.
				5165	*/
				5166	if (self->stackOverflowed)
				5167	dvmCleanupStackOverflow(self, exception);
				5168
				5169	if (catchRelPc < 0) {
				5170	/* falling through to JNI code or off the bottom of the stack */
				5171	#if DVM_SHOW_EXCEPTION >= 2
				5172	LOGD("Exception %s from %s:%d not caught locally\n",
				5173	exception->clazz->descriptor, dvmGetMethodSourceFile(curMethod),
				5174	dvmLineNumFromPC(curMethod, pc - curMethod->insns));
				5175	#endif
				5176	dvmSetException(self, exception);
				5177	dvmReleaseTrackedAlloc(exception, self);
				5178	GOTO_bail();
				5179	}
				5180
				5181	#if DVM_SHOW_EXCEPTION >= 3
				5182	{
				5183	const Method* catchMethod = SAVEAREA_FROM_FP(fp)->method;
				5184	LOGD("Exception %s thrown from %s:%d to %s:%d\n",
				5185	exception->clazz->descriptor, dvmGetMethodSourceFile(curMethod),
				5186	dvmLineNumFromPC(curMethod, pc - curMethod->insns),
				5187	dvmGetMethodSourceFile(catchMethod),
				5188	dvmLineNumFromPC(catchMethod, catchRelPc));
				5189	}
				5190	#endif
				5191
				5192	/*
				5193	* Adjust local variables to match self->curFrame and the
				5194	* updated PC.
				5195	*/
				5196	//fp = (u4*) self->curFrame;
				5197	curMethod = SAVEAREA_FROM_FP(fp)->method;
				5198	self->interpSave.method = curMethod;
				5199	//methodClass = curMethod->clazz;
				5200	methodClassDex = curMethod->clazz->pDvmDex;
				5201	pc = curMethod->insns + catchRelPc;
				5202	ILOGV("> pc <-- %s.%s %s", curMethod->clazz->descriptor,
				5203	curMethod->name, curMethod->shorty);
				5204	DUMP_REGS(curMethod, fp, false); // show all regs
				5205
				5206	/*
				5207	* Restore the exception if the handler wants it.
				5208	*
				5209	* The Dalvik spec mandates that, if an exception handler wants to
				5210	* do something with the exception, the first instruction executed
				5211	* must be "move-exception". We can pass the exception along
				5212	* through the thread struct, and let the move-exception instruction
				5213	* clear it for us.
				5214	*
				5215	* If the handler doesn't call move-exception, we don't want to
				5216	* finish here with an exception still pending.
				5217	*/
				5218	if (INST_INST(FETCH(0)) == OP_MOVE_EXCEPTION)
				5219	dvmSetException(self, exception);
				5220
				5221	dvmReleaseTrackedAlloc(exception, self);
				5222	FINISH(0);
				5223	}
				5224	GOTO_TARGET_END
				5225
				5226
				5227
				5228	/*
				5229	* General handling for invoke-{virtual,super,direct,static,interface},
				5230	* including "quick" variants.
				5231	*
				5232	* Set "methodToCall" to the Method we're calling, and "methodCallRange"
				5233	* depending on whether this is a "/range" instruction.
				5234	*
				5235	* For a range call:
				5236	* "vsrc1" holds the argument count (8 bits)
				5237	* "vdst" holds the first argument in the range
				5238	* For a non-range call:
				5239	* "vsrc1" holds the argument count (4 bits) and the 5th argument index
				5240	* "vdst" holds four 4-bit register indices
				5241	*
				5242	* The caller must EXPORT_PC before jumping here, because any method
				5243	* call can throw a stack overflow exception.
				5244	*/
				5245	GOTO_TARGET(invokeMethod, bool methodCallRange, const Method* _methodToCall,
				5246	u2 count, u2 regs)
				5247	{
				5248	STUB_HACK(vsrc1 = count; vdst = regs; methodToCall = _methodToCall;);
				5249
				5250	//printf("range=%d call=%p count=%d regs=0x%04x\n",
				5251	// methodCallRange, methodToCall, count, regs);
				5252	//printf(" --> %s.%s %s\n", methodToCall->clazz->descriptor,
				5253	// methodToCall->name, methodToCall->shorty);
				5254
				5255	u4* outs;
				5256	int i;
				5257
				5258	/*
				5259	* Copy args. This may corrupt vsrc1/vdst.
				5260	*/
				5261	if (methodCallRange) {
				5262	// could use memcpy or a "Duff's device"; most functions have
				5263	// so few args it won't matter much
				5264	assert(vsrc1 <= curMethod->outsSize);
				5265	assert(vsrc1 == methodToCall->insSize);
				5266	outs = OUTS_FROM_FP(fp, vsrc1);
				5267	for (i = 0; i < vsrc1; i++)
				5268	outs[i] = GET_REGISTER(vdst+i);
				5269	} else {
				5270	u4 count = vsrc1 >> 4;
				5271
				5272	assert(count <= curMethod->outsSize);
				5273	assert(count == methodToCall->insSize);
				5274	assert(count <= 5);
				5275
				5276	outs = OUTS_FROM_FP(fp, count);
				5277	#if 0
				5278	if (count == 5) {
				5279	outs[4] = GET_REGISTER(vsrc1 & 0x0f);
				5280	count--;
				5281	}
				5282	for (i = 0; i < (int) count; i++) {
				5283	outs[i] = GET_REGISTER(vdst & 0x0f);
				5284	vdst >>= 4;
				5285	}
				5286	#else
				5287	// This version executes fewer instructions but is larger
				5288	// overall. Seems to be a teensy bit faster.
				5289	assert((vdst >> 16) == 0); // 16 bits -or- high 16 bits clear
				5290	switch (count) {
				5291	case 5:
				5292	outs[4] = GET_REGISTER(vsrc1 & 0x0f);
				5293	case 4:
				5294	outs[3] = GET_REGISTER(vdst >> 12);
				5295	case 3:
				5296	outs[2] = GET_REGISTER((vdst & 0x0f00) >> 8);
				5297	case 2:
				5298	outs[1] = GET_REGISTER((vdst & 0x00f0) >> 4);
				5299	case 1:
				5300	outs[0] = GET_REGISTER(vdst & 0x0f);
				5301	default:
				5302	;
				5303	}
				5304	#endif
				5305	}
				5306	}
				5307
				5308	/*
				5309	* (This was originally a "goto" target; I've kept it separate from the
				5310	* stuff above in case we want to refactor things again.)
				5311	*
				5312	* At this point, we have the arguments stored in the "outs" area of
				5313	* the current method's stack frame, and the method to call in
				5314	* "methodToCall". Push a new stack frame.
				5315	*/
				5316	{
				5317	StackSaveArea* newSaveArea;
				5318	u4* newFp;
				5319
				5320	ILOGV("> %s%s.%s %s",
				5321	dvmIsNativeMethod(methodToCall) ? "(NATIVE) " : "",
				5322	methodToCall->clazz->descriptor, methodToCall->name,
				5323	methodToCall->shorty);
				5324
				5325	newFp = (u4*) SAVEAREA_FROM_FP(fp) - methodToCall->registersSize;
				5326	newSaveArea = SAVEAREA_FROM_FP(newFp);
				5327
				5328	/* verify that we have enough space */
				5329	if (true) {
				5330	u1* bottom;
				5331	bottom = (u1) newSaveArea - methodToCall->outsSize sizeof(u4);
				5332	if (bottom < self->interpStackEnd) {
				5333	/* stack overflow */
				5334	LOGV("Stack overflow on method call (start=%p end=%p newBot=%p(%d) size=%d '%s')\n",
				5335	self->interpStackStart, self->interpStackEnd, bottom,
				5336	(u1*) fp - bottom, self->interpStackSize,
				5337	methodToCall->name);
				5338	dvmHandleStackOverflow(self, methodToCall);
				5339	assert(dvmCheckException(self));
				5340	GOTO_exceptionThrown();
				5341	}
				5342	//LOGD("+++ fp=%p newFp=%p newSave=%p bottom=%p\n",
				5343	// fp, newFp, newSaveArea, bottom);
				5344	}
				5345
				5346	#ifdef LOG_INSTR
				5347	if (methodToCall->registersSize > methodToCall->insSize) {
				5348	/*
				5349	* This makes valgrind quiet when we print registers that
				5350	* haven't been initialized. Turn it off when the debug
				5351	* messages are disabled -- we want valgrind to report any
				5352	* used-before-initialized issues.
				5353	*/
				5354	memset(newFp, 0xcc,
				5355	(methodToCall->registersSize - methodToCall->insSize) * 4);
				5356	}
				5357	#endif
				5358
				5359	#ifdef EASY_GDB
				5360	newSaveArea->prevSave = SAVEAREA_FROM_FP(fp);
				5361	#endif
				5362	newSaveArea->prevFrame = fp;
				5363	newSaveArea->savedPc = pc;
				5364	#if defined(WITH_JIT) && defined(MTERP_STUB)
				5365	newSaveArea->returnAddr = 0;
				5366	#endif
				5367	newSaveArea->method = methodToCall;
				5368
				5369	if (self->interpBreak.ctl.subMode != 0) {
				5370	/*
				5371	* We mark ENTER here for both native and non-native
				5372	* calls. For native calls, we'll mark EXIT on return.
				5373	* For non-native calls, EXIT is marked in the RETURN op.
				5374	*/
				5375	PC_FP_TO_SELF();
				5376	dvmReportInvoke(self, methodToCall);
				5377	}
				5378
				5379	if (!dvmIsNativeMethod(methodToCall)) {
				5380	/*
				5381	* "Call" interpreted code. Reposition the PC, update the
				5382	* frame pointer and other local state, and continue.
				5383	*/
				5384	curMethod = methodToCall;
				5385	self->interpSave.method = curMethod;
				5386	methodClassDex = curMethod->clazz->pDvmDex;
				5387	pc = methodToCall->insns;
				5388	self->curFrame = fp = newFp;
				5389	#ifdef EASY_GDB
				5390	debugSaveArea = SAVEAREA_FROM_FP(newFp);
				5391	#endif
				5392	self->debugIsMethodEntry = true; // profiling, debugging
				5393	ILOGD("> pc <-- %s.%s %s", curMethod->clazz->descriptor,
				5394	curMethod->name, curMethod->shorty);
				5395	DUMP_REGS(curMethod, fp, true); // show input args
				5396	FINISH(0); // jump to method start
				5397	} else {
				5398	/* set this up for JNI locals, even if not a JNI native */
				5399	newSaveArea->xtra.localRefCookie = self->jniLocalRefTable.segmentState.all;
				5400
				5401	self->curFrame = newFp;
				5402
				5403	DUMP_REGS(methodToCall, newFp, true); // show input args
				5404
				5405	if (self->interpBreak.ctl.subMode != 0) {
				5406	PC_FP_TO_SELF();
				5407	dvmReportPreNativeInvoke(methodToCall, self);
				5408	}
				5409
				5410	ILOGD("> native <-- %s.%s %s", methodToCall->clazz->descriptor,
				5411	methodToCall->name, methodToCall->shorty);
				5412
				5413	/*
				5414	* Jump through native call bridge. Because we leave no
				5415	* space for locals on native calls, "newFp" points directly
				5416	* to the method arguments.
				5417	*/
				5418	(*methodToCall->nativeFunc)(newFp, &retval, methodToCall, self);
				5419
				5420	if (self->interpBreak.ctl.subMode != 0) {
				5421	PC_FP_TO_SELF();
				5422	dvmReportPostNativeInvoke(methodToCall, self);
				5423	}
				5424
				5425	/* pop frame off */
				5426	dvmPopJniLocals(self, newSaveArea);
				5427	self->curFrame = fp;
				5428
				5429	/*
				5430	* If the native code threw an exception, or interpreted code
				5431	* invoked by the native call threw one and nobody has cleared
				5432	* it, jump to our local exception handling.
				5433	*/
				5434	if (dvmCheckException(self)) {
				5435	LOGV("Exception thrown by/below native code\n");
				5436	GOTO_exceptionThrown();
				5437	}
				5438
				5439	ILOGD("> retval=0x%llx (leaving native)", retval.j);
				5440	ILOGD("> (return from native %s.%s to %s.%s %s)",
				5441	methodToCall->clazz->descriptor, methodToCall->name,
				5442	curMethod->clazz->descriptor, curMethod->name,
				5443	curMethod->shorty);
				5444
				5445	//u2 invokeInstr = INST_INST(FETCH(0));
				5446	if (true /*invokeInstr >= OP_INVOKE_VIRTUAL &&
				5447	invokeInstr <= OP_INVOKE_INTERFACE*/)
				5448	{
				5449	FINISH(3);
				5450	} else {
				5451	//LOGE("Unknown invoke instr %02x at %d\n",
				5452	// invokeInstr, (int) (pc - curMethod->insns));
				5453	assert(false);
				5454	}
				5455	}
				5456	}
				5457	assert(false); // should not get here
				5458	GOTO_TARGET_END
				5459
				5460	/* File: cstubs/enddefs.cpp */
				5461
				5462	/* undefine "magic" name remapping */
				5463	#undef retval
				5464	#undef pc
				5465	#undef fp
				5466	#undef curMethod
				5467	#undef methodClassDex
				5468	#undef self
				5469	#undef debugTrackedRefStart
				5470