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

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