code-analyse.c

基于LWVCL开发的库

/* code-analyse.c
 * Analyse a method's bytecodes.
 *
 * Copyright (c) 1996, 1997
 *	Transvirtual Technologies, Inc.  All rights reserved.
 *
 * See the file "license.terms" for information on usage and redistribution 
 * of this file. 
 */

#define	IDBG(s)
#define	VDBG(s)

#include "config.h"
#include "debug.h"
#include "config-std.h"
#include "gtypes.h"
#include "bytecode.h"
#include "object.h"
#include "constants.h"
#include "access.h"
#include "classMethod.h"
#include "code-analyse.h"
#include "lookup.h"
#include "exception.h"
#include "icode.h"
#include "itypes.h"
#include "locks.h"
#include "thread.h"
#include "jthread.h"
#include "baseClasses.h"
#include "soft.h"
#include "md.h"
#include "gc.h"

static void mergeFrame(codeinfo*, int, int, frameElement*, Method*);
static void updateLocals(codeinfo*, int32, frameElement*);
static bool analyzeCatchClause(jexceptionEntry*, Hjava_lang_Class*, errorInfo*);

static
bool
analyzeBasicBlock(codeinfo* codeInfo, Method* meth, uint32 pc, errorInfo *einfo)
{
	int32 tabpc;
	int32 idx;
	int32 sp;
	int32 opc;
	callInfo call;
	fieldInfo finfo;
	Hjava_lang_Class* type;
	const char* sig;
	frameElement* activeFrame;
	bool wide;
	bool failed;
	bool firsttime;

	opc = pc;
	assert(pc == 0 || IS_STARTOFBASICBLOCK(pc) || IS_STARTOFEXCEPTION(pc));
	assert(IS_STACKPOINTERSET(pc));

	/* If this block hasn't been verified before then note this */
	if (!IS_DONEVERIFY(pc)) {
		firsttime = true;
	}
	else {
		firsttime = false;
	}

	/* Get stack pointer */
	sp = STACKPOINTER(pc);

	/* Allocate frame to hold type data */
	activeFrame = ALLOCFRAME();
	if (activeFrame == 0) {
		postOutOfMemory(einfo);
		return true;
	}

	SET_DONEVERIFY(pc);

	FRAMELOAD(pc);

	/* Process basic block until we get to the beginning of a new one */
	wide = false;
	failed = false;
	do {
		if (sp < meth->localsz || sp > meth->localsz + meth->stacksz) {
			failed = true;
			postExceptionMessage(einfo, JAVA_LANG(VerifyError),
				"In class %s in method %s with signature %s at pc %d: sp %d not in range [%d, %d]",
				meth->class->name->data, meth->name->data, METHOD_SIGD(meth),
				pc, sp, meth->localsz, 
				meth->localsz + meth->stacksz);
			break;
		}

		/* If we're in an exception block, merge locals into
		 * the handler.
		 */
		if (meth->exception_table != 0) {
			for (idx = 0; idx < (int32)meth->exception_table->length; idx++) {
				if (pc >= meth->exception_table->entry[idx].start_pc 
				    && pc < meth->exception_table->entry[idx].end_pc) {
					FRAMEMERGE_LOCALS((int32)(meth->exception_table->entry[idx].handler_pc));
				}
			}
		}

IDBG(		dprintf("%d: %d\n", pc, INSN(pc));		)

		switch (INSN(pc)) {
		int32 lcl;

		case NOP:
			INCPC(1);
			break;

		case ACONST_NULL:
			STKPUSH(1);
			STACKOUT(0, TOBJ);
			INCPC(1);
			break;

		case ICONST_M1:
		case ICONST_0:
		case ICONST_1:
		case ICONST_2:
		case ICONST_3:
		case ICONST_4:
		case ICONST_5:
			STKPUSH(1);
			STACKOUT_CONST(0, TINT, INSN(pc) - ICONST_0);
			INCPC(1);
			break;

		case BIPUSH:
			STKPUSH(1);
			STACKOUT_CONST(0, TINT, BYTE(pc+1));
			INCPC(2);
			break;

		case SIPUSH:
			STKPUSH(1);
			STACKOUT_CONST(0, TINT, WORD(pc+1));
			INCPC(3);
			break;

		case LCONST_0:
		case LCONST_1:
			STKPUSH(2);
			STACKOUT(0, TLONG);
			STACKOUT(1, TVOID);
			INCPC(1);
			break;

		case FCONST_0:
		case FCONST_1:
		case FCONST_2:
			STKPUSH(1);
			STACKOUT(0, TFLOAT);
			INCPC(1);
			break;

		case DCONST_0:
		case DCONST_1:
			STKPUSH(2);
			STACKOUT(0, TDOUBLE);
			STACKOUT(1, TVOID);
			INCPC(1);
			break;

		case LDC1:
			STKPUSH(1);
			lcl = (uint8)BYTE(pc + 1);
			CONSTANTTYPE(type, lcl);
			STACKOUT(0, type);
			INCPC(2);
			break;

		case LDC2:
			STKPUSH(1);
			CONSTANTTYPE(type, (uint16)WORD(pc+1));
			STACKOUT(0, type);
			INCPC(3);
			break;

		case LDC2W:
			STKPUSH(2);
			CONSTANTTYPE(type, (uint16)WORD(pc+1));
			STACKOUT(0, type);
			STACKOUT(1, TVOID);
			INCPC(3);
			break;

		case ILOAD_0:
		case ILOAD_1:
		case ILOAD_2:
		case ILOAD_3:
			lcl = INSN(pc) - ILOAD_0;
			STKPUSH(1);
			STACKOUT_LOCAL(0, TINT, lcl);
			INCPC(1);
			break;

		case ILOAD:
			if (wide) {
				wide = false;
				STKPUSH(1);
				STACKOUT_LOCAL(0, TINT, WORD(pc+1));
				INCPC(3);
			}
			else {
				STKPUSH(1);
				STACKOUT_LOCAL(0, TINT, BYTE(pc+1));
				INCPC(2);
			}
			break;

		case LLOAD_0:
		case LLOAD_1:
		case LLOAD_2:
		case LLOAD_3:
			lcl = INSN(pc) - LLOAD_0;
			STKPUSH(2);
			STACKOUT_LOCAL(0, TLONG, lcl);
			STACKOUT_LOCAL(1, TVOID, lcl+1);
			INCPC(1);
			break;

		case LLOAD:
			if (wide) {
				wide = false;
				STKPUSH(2);
				STACKOUT_LOCAL(0, TLONG, WORD(pc+1));
				STACKOUT_LOCAL(1, TVOID, WORD(pc+1)+1);
				INCPC(3);
			}
			else {
				STKPUSH(2);
				STACKOUT_LOCAL(0, TLONG, BYTE(pc+1));
				STACKOUT_LOCAL(1, TVOID, BYTE(pc+1)+1);
				INCPC(2);
			}
			break;

		case FLOAD_0:
		case FLOAD_1:
		case FLOAD_2:
		case FLOAD_3:
			lcl = INSN(pc) - FLOAD_0;
			STKPUSH(1);
			STACKOUT_LOCAL(0, TFLOAT, lcl);
			INCPC(1);
			break;

		case FLOAD:
			if (wide) {
				wide = false;
				STKPUSH(1);
				STACKOUT_LOCAL(0, TFLOAT, WORD(pc+1));
				INCPC(3);
			}
			else {
				STKPUSH(1);
				STACKOUT_LOCAL(0, TFLOAT, BYTE(pc+1));
				INCPC(2);
			}
			break;

		case DLOAD_0:
		case DLOAD_1:
		case DLOAD_2:
		case DLOAD_3:
			lcl = INSN(pc) - DLOAD_0;
			STKPUSH(2);
			STACKOUT_LOCAL(0, TDOUBLE, lcl);
			STACKOUT_LOCAL(1, TVOID, lcl+1);
			INCPC(1);
			break;

		case DLOAD:
			if (wide) {
				lcl = WORD(pc+1);
				wide = false;
				STKPUSH(2);
				STACKOUT_LOCAL(0, TDOUBLE, lcl);
				STACKOUT_LOCAL(1, TVOID, lcl+1);
				INCPC(3);
			}
			else {
				lcl = BYTE(pc+1);
				STKPUSH(2);
				STACKOUT_LOCAL(0, TDOUBLE, lcl);
				STACKOUT_LOCAL(1, TVOID, lcl+1);
				INCPC(2);
			}
			break;

		case ALOAD_0:
		case ALOAD_1:
		case ALOAD_2:
		case ALOAD_3:
			lcl = INSN(pc) - ALOAD_0;
			STKPUSH(1);
			STACKOUT_LOCAL(0, TOBJ, lcl);
			INCPC(1);
			break;

		case ALOAD:
			if (wide) {
				wide = false;
				STKPUSH(1);
				STACKOUT_LOCAL(0, TOBJ, WORD(pc+1));
				INCPC(3);
			}
			else {
				STKPUSH(1);
				STACKOUT_LOCAL(0, TOBJ, BYTE(pc+1));
				INCPC(2);
			}
			break;

		case IALOAD:
		case BALOAD:
		case CALOAD:
		case SALOAD:
			STACKIN(1, TOBJ);
			STACKIN(0, TINT);
			STKPOP(1);
			STACKOUT(0, TINT);
			INCPC(1);
			break;

		case LALOAD:
			STACKIN(1, TOBJ);
			STACKIN(0, TINT);
			STACKOUT(0, TLONG);
			STACKOUT(1, TVOID);
			INCPC(1);
			break;

		case FALOAD:
			STACKIN(1, TOBJ);
			STACKIN(0, TINT);
			STKPOP(1);
			STACKOUT(0, TFLOAT);
			INCPC(1);
			break;

		case DALOAD:
			STACKIN(1, TOBJ);
			STACKIN(0, TINT);
			STACKOUT(0, TDOUBLE);
			STACKOUT(1, TVOID);
			INCPC(1);
			break;

		case AALOAD:
			STACKIN(1, TOBJ);
			STACKIN(0, TINT);
			STKPOP(1);
			STACKOUT(0, TOBJ);
			INCPC(1);
			break;

		case ISTORE_0:
		case ISTORE_1:
		case ISTORE_2:
		case ISTORE_3:
			lcl = INSN(pc) - ISTORE_0;
			LOCALOUT_STACK(lcl, TINT, 0);
			STKPOP(1);
			INCPC(1);
			break;

		case ISTORE:
			if (wide) {
				LOCALOUT_STACK(WORD(pc+1), TINT, 0);
				INCPC(1);
				wide = false;
			}
			else {
				LOCALOUT_STACK(BYTE(pc+1), TINT, 0);
			}
			STKPOP(1);
			INCPC(2);
			break;

		case LSTORE_0:
		case LSTORE_1:
		case LSTORE_2:
		case LSTORE_3:
			lcl = INSN(pc) - LSTORE_0;
			LOCALOUT_STACK(lcl, TLONG, 0);
			LOCALOUT_STACK(lcl+1, TVOID, 1);
			STKPOP(2);
			INCPC(1);
			break;

		case LSTORE:
			if (wide) {
				lcl = WORD(pc+1);
				LOCALOUT_STACK(lcl, TLONG, 0);
				LOCALOUT_STACK(lcl+1, TVOID, 1);
				INCPC(1);
				wide = false;
			}
			else {
				lcl = BYTE(pc+1);
				LOCALOUT_STACK(lcl, TLONG, 0);
				LOCALOUT_STACK(lcl+1, TVOID, 1);
			}
			STKPOP(2);
			INCPC(2);
			break;

		case FSTORE_0:
		case FSTORE_1:
		case FSTORE_2:
		case FSTORE_3:
			lcl = INSN(pc) - FSTORE_0;
			STACKIN(0, TFLOAT);
			LOCALOUT(lcl, TFLOAT);
			STKPOP(1);
			INCPC(1);
			break;

		case FSTORE:
			STACKIN(0, TFLOAT);
			if (wide) {
				LOCALOUT(WORD(pc+1), TFLOAT);
				INCPC(1);
				wide = false;
			}
			else {
				LOCALOUT(BYTE(pc+1), TFLOAT);
			}
			STKPOP(1);
			INCPC(2);
			break;

		case DSTORE_0:
		case DSTORE_1:
		case DSTORE_2:
		case DSTORE_3:
			lcl = INSN(pc) - DSTORE_0;
			STACKIN(0, TDOUBLE);
			STACKIN(1, TVOID);
			LOCALOUT(lcl, TDOUBLE);
			LOCALOUT(lcl+1, TVOID);
			STKPOP(2);
			INCPC(1);
			break;

		case DSTORE:
			STACKIN(0, TDOUBLE);
			STACKIN(1, TVOID);
			if (wide) {
				LOCALOUT(WORD(pc+1), TDOUBLE);
				LOCALOUT(WORD(pc+1)+1, TVOID);
				INCPC(1);
				wide = false;
			}
			else {
				LOCALOUT(BYTE(pc+1), TDOUBLE);
				LOCALOUT(BYTE(pc+1)+1, TVOID);
			}
			STKPOP(2);
			INCPC(2);
			break;

		case ASTORE_0:
		case ASTORE_1:
		case ASTORE_2:
		case ASTORE_3:
			lcl = INSN(pc) - ASTORE_0;
			LOCALOUT_STACK(lcl, TOBJ, 0);
			STKPOP(1);
			INCPC(1);
			break;

		case ASTORE:
			if (wide) {
				LOCALOUT_STACK(WORD(pc+1), TOBJ, 0);
				INCPC(1);
				wide = false;
			}
			else {
				LOCALOUT_STACK(BYTE(pc+1), TOBJ, 0);
			}
			STKPOP(1);
			INCPC(2);
			break;

		case BASTORE:
			STACKIN(0, TINT);
			STACKIN(1, TINT);
			STACKIN(2, TOBJ);
			STKPOP(3);
			INCPC(1);
			break;

		case IASTORE:
			STACKIN(0, TINT);
			STACKIN(1, TINT);
			STACKIN(2, TOBJ);
			STKPOP(3);
			INCPC(1);
			break;

		case CASTORE:
		case SASTORE:
			STACKIN(0, TINT);
			STACKIN(1, TINT);
			STACKIN(2, TOBJ);
			STKPOP(3);
			INCPC(1);
			break;

		case LASTORE:
			STACKIN(3, TOBJ);
			STACKIN(2, TINT);
			STACKIN(0, TLONG);
			STACKIN(1, TVOID);
			STKPOP(4);
			INCPC(1);
			break;

		case FASTORE:
			STACKIN(2, TOBJ);
			STACKIN(1, TINT);
			STACKIN(0, TFLOAT);
			STKPOP(3);
			INCPC(1);
			break;

		case DASTORE:
			STACKIN(3, TOBJ);
			STACKIN(2, TINT);
			STACKIN(0, TDOUBLE);
			STACKIN(1, TVOID);
			STKPOP(4);
			INCPC(1);
			break;

		case AASTORE:
			STACKIN(2, TOBJ);
			STACKIN(1, TINT);
			STACKIN(0, TOBJ);
			STKPOP(3);
			INCPC(1);
			break;

		case POP:
			STKPOP(1);
			INCPC(1);
			break;

		case POP2:
			STKPOP(2);
			INCPC(1);
			break;

		case DUP:
			STKPUSH(1);
			STACKCOPY(1, 0);
			INCPC(1);
			break;

		case DUP_X1:
			STKPUSH(1);
			STACKCOPY(1, 0);
			STACKCOPY(2, 1);
			STACKCOPY(0, 2);
			INCPC(1);
			break;

		case DUP_X2:
			STKPUSH(1);
			STACKCOPY(1, 0);
			STACKCOPY(2, 1);
			STACKCOPY(3, 2);
			STACKCOPY(0, 3);
			INCPC(1);
			break;

		case DUP2:
			STKPUSH(2);
			STACKCOPY(2, 0);
			STACKCOPY(3, 1);
			STACKCOPY(2, 2);
			STACKCOPY(3, 3);
			INCPC(1);
			break;

		case DUP2_X1:
			STKPUSH(2);
			STACKCOPY(2, 0);
			STACKCOPY(3, 1);
			STACKCOPY(4, 2);
			STACKCOPY(0, 3);
			STACKCOPY(1, 4);
			INCPC(1);
			break;

		case DUP2_X2:
			STKPUSH(2);
			STACKCOPY(2, 0);
			STACKCOPY(3, 1);
			STACKCOPY(4, 2);
			STACKCOPY(5, 3);
			STACKCOPY(0, 4);
			STACKCOPY(1, 5);
			INCPC(1);
			break;

		case SWAP:
			STACKSWAP(0, 1);
			INCPC(1);
			break;

		case IAND:
			STACKIN(0, TINT);
			STACKIN(1, TINT);
			STKPOP(1);
			STACKOUT(0, TINT);
			INCPC(1);
			break;

		case IOR:
			STACKIN(0, TINT);
			STACKIN(1, TINT);
			STKPOP(1);
			STACKOUT(0, TINT);
			INCPC(1);
			break;

		case IXOR:
			STACKIN(0, TINT);
			STACKIN(1, TINT);
			STKPOP(1);
			STACKOUT(0, TINT);
			INCPC(1);
			break;

		case IADD:
			STACKIN(0, TINT);
			STACKIN(1, TINT);
			STKPOP(1);
			STACKOUT(0, TINT);
			INCPC(1);
			break;

		case IMUL:
			STACKIN(0, TINT);
			STACKIN(1, TINT);
			STKPOP(1);
			STACKOUT(0, TINT);
			INCPC(1);
			break;

		case ISUB:
			STACKIN(0, TINT);
			STACKIN(1, TINT);
			STKPOP(1);
			STACKOUT(0, TINT);
			INCPC(1);
			break;

		case IDIV:
			STACKIN(0, TINT);
			STACKIN(1, TINT);
			STKPOP(1);
			STACKOUT(0, TINT);
			INCPC(1);
			break;

		case IREM:
			STACKIN(0, TINT);
			STACKIN(1, TINT);
			STKPOP(1);
			STACKOUT(0, TINT);
			INCPC(1);
			break;

		case LADD:
		case LSUB:
		case LMUL:
		case LDIV:
		case LREM:
		case LAND:
		case LOR:
		case LXOR:
			STACKIN(0, TLONG);
			STACKIN(1, TVOID);
			STACKIN(2, TLONG);
			STACKIN(3, TVOID);
			STKPOP(2);
			STACKOUT(0, TLONG);
			STACKOUT(1, TVOID);
			INCPC(1);
			break;

		case FADD:
		case FSUB:
		case FMUL:
		case FDIV:
		case FREM:
			STACKIN(1, TFLOAT);
			STACKIN(0, TFLOAT);
			STKPOP(1);
			STACKOUT(0, TFLOAT);
			INCPC(1);
			break;

		case DADD: