Back to index...

	/*
	* Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package com.sun.java.util.jar.pack;

	import java.io.IOException;
	import java.util.Arrays;
	import static com.sun.java.util.jar.pack.Constants.*;

	/**
	* A parsed bytecode instruction.
	* Provides accessors to various relevant bits.
	* @author John Rose
	*/
	class Instruction {
	protected byte[] bytes; // bytecodes
	protected int pc; // location of this instruction
	protected int bc; // opcode of this instruction
	protected int w; // 0 if normal, 1 if a _wide prefix at pc
	protected int length; // bytes in this instruction

	protected boolean special;

	protected Instruction(byte[] bytes, int pc, int bc, int w, int length) {
	reset(bytes, pc, bc, w, length);
	}
	private void reset(byte[] bytes, int pc, int bc, int w, int length) {
	this.bytes = bytes;
	this.pc = pc;
	this.bc = bc;
	this.w = w;
	this.length = length;
	}

	public int getBC() {
	return bc;
	}
	public boolean isWide() {
	return w != 0;
	}
	public byte[] getBytes() {
	return bytes;
	}
	public int getPC() {
	return pc;
	}
	public int getLength() {
	return length;
	}
	public int getNextPC() {
	return pc + length;
	}

	public Instruction next() {
	int npc = pc + length;
	if (npc == bytes.length)
	return null;
	else
	return Instruction.at(bytes, npc, this);
	}

	public boolean isNonstandard() {
	return isNonstandard(bc);
	}

	public void setNonstandardLength(int length) {
	assert(isNonstandard());
	this.length = length;
	}


	/** A fake instruction at this pc whose next() will be at nextpc. */
	public Instruction forceNextPC(int nextpc) {
	int llength = nextpc - pc;
	return new Instruction(bytes, pc, -1, -1, llength);
	}

	public static Instruction at(byte[] bytes, int pc) {
	return Instruction.at(bytes, pc, null);
	}

	public static Instruction at(byte[] bytes, int pc, Instruction reuse) {
	int bc = getByte(bytes, pc);
	int prefix = -1;
	int w = 0;
	int length = BC_LENGTH[w][bc];
	if (length == 0) {
	// Hard cases:
	switch (bc) {
	case _wide:
	bc = getByte(bytes, pc+1);
	w = 1;
	length = BC_LENGTH[w][bc];
	if (length == 0) {
	// unknown instruction; treat as one byte
	length = 1;
	}
	break;
	case _tableswitch:
	return new TableSwitch(bytes, pc);
	case _lookupswitch:
	return new LookupSwitch(bytes, pc);
	default:
	// unknown instruction; treat as one byte
	length = 1;
	break;
	}
	}
	assert(length > 0);
	assert(pc+length <= bytes.length);
	// Speed hack: Instruction.next reuses self if possible.
	if (reuse != null && !reuse.special) {
	reuse.reset(bytes, pc, bc, w, length);
	return reuse;
	}
	return new Instruction(bytes, pc, bc, w, length);
	}

	// Return the constant pool reference type, or 0 if none.
	public byte getCPTag() {
	return BC_TAG[w][bc];
	}

	// Return the constant pool index, or -1 if none.
	public int getCPIndex() {
	int indexLoc = BC_INDEX[w][bc];
	if (indexLoc == 0) return -1;
	assert(w == 0);
	if (length == 2)
	return getByte(bytes, pc+indexLoc); // _ldc opcode only
	else
	return getShort(bytes, pc+indexLoc);
	}

	public void setCPIndex(int cpi) {
	int indexLoc = BC_INDEX[w][bc];
	assert(indexLoc != 0);
	if (length == 2)
	setByte(bytes, pc+indexLoc, cpi); // _ldc opcode only
	else
	setShort(bytes, pc+indexLoc, cpi);
	assert(getCPIndex() == cpi);
	}

	public ConstantPool.Entry getCPRef(ConstantPool.Entry[] cpMap) {
	int index = getCPIndex();
	return (index < 0) ? null : cpMap[index];
	}

	// Return the slot of the affected local, or -1 if none.
	public int getLocalSlot() {
	int slotLoc = BC_SLOT[w][bc];
	if (slotLoc == 0) return -1;
	if (w == 0)
	return getByte(bytes, pc+slotLoc);
	else
	return getShort(bytes, pc+slotLoc);
	}

	// Return the target of the branch, or -1 if none.
	public int getBranchLabel() {
	int branchLoc = BC_BRANCH[w][bc];
	if (branchLoc == 0) return -1;
	assert(w == 0);
	assert(length == 3 \|\| length == 5);
	int offset;
	if (length == 3)
	offset = (short)getShort(bytes, pc+branchLoc);
	else
	offset = getInt(bytes, pc+branchLoc);
	assert(offset+pc >= 0);
	assert(offset+pc <= bytes.length);
	return offset+pc;
	}

	public void setBranchLabel(int targetPC) {
	int branchLoc = BC_BRANCH[w][bc];
	assert(branchLoc != 0);
	if (length == 3)
	setShort(bytes, pc+branchLoc, targetPC-pc);
	else
	setInt(bytes, pc+branchLoc, targetPC-pc);
	assert(targetPC == getBranchLabel());
	}

	// Return the trailing constant in the instruction (as a signed value).
	// Return 0 if there is none.
	public int getConstant() {
	int conLoc = BC_CON[w][bc];
	if (conLoc == 0) return 0;
	switch (length - conLoc) {
	case 1: return (byte) getByte(bytes, pc+conLoc);
	case 2: return (short) getShort(bytes, pc+conLoc);
	}
	assert(false);
	return 0;
	}

	public void setConstant(int con) {
	int conLoc = BC_CON[w][bc];
	assert(conLoc != 0);
	switch (length - conLoc) {
	case 1: setByte(bytes, pc+conLoc, con); break;
	case 2: setShort(bytes, pc+conLoc, con); break;
	}
	assert(con == getConstant());
	}

	public abstract static class Switch extends Instruction {
	// Each case is a (value, label) pair, indexed 0 <= n < caseCount
	public abstract int getCaseCount();
	public abstract int getCaseValue(int n);
	public abstract int getCaseLabel(int n);
	public abstract void setCaseCount(int caseCount);
	public abstract void setCaseValue(int n, int value);
	public abstract void setCaseLabel(int n, int targetPC);
	protected abstract int getLength(int caseCount);

	public int getDefaultLabel() { return intAt(0)+pc; }
	public void setDefaultLabel(int targetPC) { setIntAt(0, targetPC-pc); }

	protected int apc; // aligned pc (table base)
	protected int intAt(int n) { return getInt(bytes, apc + n*4); }
	protected void setIntAt(int n, int x) { setInt(bytes, apc + n*4, x); }
	protected Switch(byte[] bytes, int pc, int bc) {
	super(bytes, pc, bc, /w/0, /length/0);
	this.apc = alignPC(pc+1);
	this.special = true;
	length = getLength(getCaseCount());
	}
	public int getAlignedPC() { return apc; }
	public String toString() {
	String s = super.toString();
	s += " Default:"+labstr(getDefaultLabel());
	int caseCount = getCaseCount();
	for (int i = 0; i < caseCount; i++) {
	s += "\n\tCase "+getCaseValue(i)+":"+labstr(getCaseLabel(i));
	}
	return s;
	}
	public static int alignPC(int apc) {
	while (apc % 4 != 0) ++apc;
	return apc;
	}
	}

	public static class TableSwitch extends Switch {
	// apc: (df, lo, hi, (hi-lo+1)*(label))
	public int getLowCase() { return intAt(1); }
	public int getHighCase() { return intAt(2); }
	public int getCaseCount() { return intAt(2)-intAt(1)+1; }
	public int getCaseValue(int n) { return getLowCase()+n; }
	public int getCaseLabel(int n) { return intAt(3+n)+pc; }

	public void setLowCase(int val) { setIntAt(1, val); }
	public void setHighCase(int val) { setIntAt(2, val); }
	public void setCaseLabel(int n, int tpc) { setIntAt(3+n, tpc-pc); }
	public void setCaseCount(int caseCount) {
	setHighCase(getLowCase() + caseCount - 1);
	length = getLength(caseCount);
	}
	public void setCaseValue(int n, int val) {
	if (n != 0) throw new UnsupportedOperationException();
	int caseCount = getCaseCount();
	setLowCase(val);
	setCaseCount(caseCount); // keep invariant
	}

	TableSwitch(byte[] bytes, int pc) {
	super(bytes, pc, _tableswitch);
	}
	protected int getLength(int caseCount) {
	return (apc-pc) + (3 + caseCount) * 4;
	}
	}

	public static class LookupSwitch extends Switch {
	// apc: (df, nc, nc*(case, label))
	public int getCaseCount() { return intAt(1); }
	public int getCaseValue(int n) { return intAt(2+n*2+0); }
	public int getCaseLabel(int n) { return intAt(2+n*2+1)+pc; }

	public void setCaseCount(int caseCount) {
	setIntAt(1, caseCount);
	length = getLength(caseCount);
	}
	public void setCaseValue(int n, int val) { setIntAt(2+n*2+0, val); }
	public void setCaseLabel(int n, int tpc) { setIntAt(2+n*2+1, tpc-pc); }

	LookupSwitch(byte[] bytes, int pc) {
	super(bytes, pc, _lookupswitch);
	}
	protected int getLength(int caseCount) {
	return (apc-pc) + (2 + caseCount2) 4;
	}
	}

	/** Two instructions are equal if they have the same bytes. */
	public boolean equals(Object o) {
	return (o != null) && (o.getClass() == Instruction.class)
	&& equals((Instruction) o);
	}

	public int hashCode() {
	int hash = 3;
	hash = 11 * hash + Arrays.hashCode(this.bytes);
	hash = 11 * hash + this.pc;
	hash = 11 * hash + this.bc;
	hash = 11 * hash + this.w;
	hash = 11 * hash + this.length;
	return hash;
	}

	public boolean equals(Instruction that) {
	if (this.pc != that.pc) return false;
	if (this.bc != that.bc) return false;
	if (this.w != that.w) return false;
	if (this.length != that.length) return false;
	for (int i = 1; i < length; i++) {
	if (this.bytes[this.pc+i] != that.bytes[that.pc+i])
	return false;
	}
	return true;
	}

	static String labstr(int pc) {
	if (pc >= 0 && pc < 100000)
	return ((100000+pc)+"").substring(1);
	return pc+"";
	}
	public String toString() {
	return toString(null);
	}
	public String toString(ConstantPool.Entry[] cpMap) {
	String s = labstr(pc) + ": ";
	if (bc >= _bytecode_limit) {
	s += Integer.toHexString(bc);
	return s;
	}
	if (w == 1) s += "wide ";
	String bcname = (bc < BC_NAME.length)? BC_NAME[bc]: null;
	if (bcname == null) {
	return s+"opcode#"+bc;
	}
	s += bcname;
	int tag = getCPTag();
	if (tag != 0) s += " "+ConstantPool.tagName(tag)+":";
	int idx = getCPIndex();
	if (idx >= 0) s += (cpMap == null) ? ""+idx : "="+cpMap[idx].stringValue();
	int slt = getLocalSlot();
	if (slt >= 0) s += " Local:"+slt;
	int lab = getBranchLabel();
	if (lab >= 0) s += " To:"+labstr(lab);
	int con = getConstant();
	if (con != 0) s += " Con:"+con;
	return s;
	}


	//public static byte constantPoolTagFor(int bc) { return BC_TAG[0][bc]; }

	/// Fetching values from byte arrays:

	public int getIntAt(int off) {
	return getInt(bytes, pc+off);
	}
	public int getShortAt(int off) {
	return getShort(bytes, pc+off);
	}
	public int getByteAt(int off) {
	return getByte(bytes, pc+off);
	}


	public static int getInt(byte[] bytes, int pc) {
	return (getShort(bytes, pc+0) << 16) + (getShort(bytes, pc+2) << 0);
	}
	public static int getShort(byte[] bytes, int pc) {
	return (getByte(bytes, pc+0) << 8) + (getByte(bytes, pc+1) << 0);
	}
	public static int getByte(byte[] bytes, int pc) {
	return bytes[pc] & 0xFF;
	}


	public static void setInt(byte[] bytes, int pc, int x) {
	setShort(bytes, pc+0, x >> 16);
	setShort(bytes, pc+2, x >> 0);
	}
	public static void setShort(byte[] bytes, int pc, int x) {
	setByte(bytes, pc+0, x >> 8);
	setByte(bytes, pc+1, x >> 0);
	}
	public static void setByte(byte[] bytes, int pc, int x) {
	bytes[pc] = (byte)x;
	}

	// some bytecode classifiers


	public static boolean isNonstandard(int bc) {
	return BC_LENGTH[0][bc] < 0;
	}

	public static int opLength(int bc) {
	int l = BC_LENGTH[0][bc];
	assert(l > 0);
	return l;
	}
	public static int opWideLength(int bc) {
	int l = BC_LENGTH[1][bc];
	assert(l > 0);
	return l;
	}

	public static boolean isLocalSlotOp(int bc) {
	return (bc < BC_SLOT[0].length && BC_SLOT[0][bc] > 0);
	}

	public static boolean isBranchOp(int bc) {
	return (bc < BC_BRANCH[0].length && BC_BRANCH[0][bc] > 0);
	}

	public static boolean isCPRefOp(int bc) {
	if (bc < BC_INDEX[0].length && BC_INDEX[0][bc] > 0) return true;
	if (bc >= _xldc_op && bc < _xldc_limit) return true;
	if (bc == _invokespecial_int \|\| bc == _invokestatic_int) return true;
	return false;
	}

	public static byte getCPRefOpTag(int bc) {
	if (bc < BC_INDEX[0].length && BC_INDEX[0][bc] > 0) return BC_TAG[0][bc];
	if (bc >= _xldc_op && bc < _xldc_limit) return CONSTANT_LoadableValue;
	if (bc == _invokestatic_int \|\| bc == _invokespecial_int) return CONSTANT_InterfaceMethodref;
	return CONSTANT_None;
	}

	public static boolean isFieldOp(int bc) {
	return (bc >= _getstatic && bc <= _putfield);
	}

	public static boolean isInvokeInitOp(int bc) {
	return (bc >= _invokeinit_op && bc < _invokeinit_limit);
	}

	public static boolean isSelfLinkerOp(int bc) {
	return (bc >= _self_linker_op && bc < _self_linker_limit);
	}

	/// Format definitions.

	private static final byte[][] BC_LENGTH = new byte[2][0x100];
	private static final byte[][] BC_INDEX = new byte[2][0x100];
	private static final byte[][] BC_TAG = new byte[2][0x100];
	private static final byte[][] BC_BRANCH = new byte[2][0x100];
	private static final byte[][] BC_SLOT = new byte[2][0x100];
	private static final byte[][] BC_CON = new byte[2][0x100];
	private static final String[] BC_NAME = new String[0x100]; // debug only
	private static final String[][] BC_FORMAT = new String[2][_bytecode_limit]; // debug only
	static {
	for (int i = 0; i < _bytecode_limit; i++) {
	BC_LENGTH[0][i] = -1;
	BC_LENGTH[1][i] = -1;
	}
	def("b", _nop, _dconst_1);
	def("bx", _bipush);
	def("bxx", _sipush);
	def("bk", _ldc); // do not pack
	def("bkk", _ldc_w, _ldc2_w); // do not pack
	def("blwbll", _iload, _aload);
	def("b", _iload_0, _saload);
	def("blwbll", _istore, _astore);
	def("b", _istore_0, _lxor);
	def("blxwbllxx", _iinc);
	def("b", _i2l, _dcmpg);
	def("boo", _ifeq, _jsr); // pack oo
	def("blwbll", _ret);
	def("", _tableswitch, _lookupswitch); // pack all ints, omit padding
	def("b", _ireturn, _return);
	def("bkf", _getstatic, _putfield); // pack kf (base=Field)
	def("bkm", _invokevirtual, _invokestatic); // pack kn (base=Method)
	def("bkixx", _invokeinterface); // pack ki (base=IMethod), omit xx
	def("bkyxx", _invokedynamic); // pack ky (base=Any), omit xx
	def("bkc", _new); // pack kc
	def("bx", _newarray);
	def("bkc", _anewarray); // pack kc
	def("b", _arraylength, _athrow);
	def("bkc", _checkcast, _instanceof); // pack kc
	def("b", _monitorenter, _monitorexit);
	def("", _wide);
	def("bkcx", _multianewarray); // pack kc
	def("boo", _ifnull, _ifnonnull); // pack oo
	def("boooo", _goto_w, _jsr_w); // pack oooo
	for (int i = 0; i < _bytecode_limit; i++) {
	//System.out.println(i+": l="+BC_LENGTH[0][i]+" i="+BC_INDEX[0][i]);
	//assert(BC_LENGTH[0][i] != -1);
	if (BC_LENGTH[0][i] == -1) {
	continue; // unknown opcode
	}

	// Have a complete mapping, to support spurious _wide prefixes.
	if (BC_LENGTH[1][i] == -1)
	BC_LENGTH[1][i] = (byte)(1+BC_LENGTH[0][i]);
	}

	String names =
	"nop aconst_null iconst_m1 iconst_0 iconst_1 iconst_2 iconst_3 iconst_4 "+
	"iconst_5 lconst_0 lconst_1 fconst_0 fconst_1 fconst_2 dconst_0 dconst_1 "+
	"bipush sipush ldc ldc_w ldc2_w iload lload fload dload aload iload_0 "+
	"iload_1 iload_2 iload_3 lload_0 lload_1 lload_2 lload_3 fload_0 fload_1 "+
	"fload_2 fload_3 dload_0 dload_1 dload_2 dload_3 aload_0 aload_1 aload_2 "+
	"aload_3 iaload laload faload daload aaload baload caload saload istore "+
	"lstore fstore dstore astore istore_0 istore_1 istore_2 istore_3 lstore_0 "+
	"lstore_1 lstore_2 lstore_3 fstore_0 fstore_1 fstore_2 fstore_3 dstore_0 "+
	"dstore_1 dstore_2 dstore_3 astore_0 astore_1 astore_2 astore_3 iastore "+
	"lastore fastore dastore aastore bastore castore sastore pop pop2 dup "+
	"dup_x1 dup_x2 dup2 dup2_x1 dup2_x2 swap iadd ladd fadd dadd isub lsub "+
	"fsub dsub imul lmul fmul dmul idiv ldiv fdiv ddiv irem lrem frem drem "+
	"ineg lneg fneg dneg ishl lshl ishr lshr iushr lushr iand land ior lor "+
	"ixor lxor iinc i2l i2f i2d l2i l2f l2d f2i f2l f2d d2i d2l d2f i2b i2c "+
	"i2s lcmp fcmpl fcmpg dcmpl dcmpg ifeq ifne iflt ifge ifgt ifle if_icmpeq "+
	"if_icmpne if_icmplt if_icmpge if_icmpgt if_icmple if_acmpeq if_acmpne "+
	"goto jsr ret tableswitch lookupswitch ireturn lreturn freturn dreturn "+
	"areturn return getstatic putstatic getfield putfield invokevirtual "+
	"invokespecial invokestatic invokeinterface invokedynamic new newarray "+
	"anewarray arraylength athrow checkcast instanceof monitorenter "+
	"monitorexit wide multianewarray ifnull ifnonnull goto_w jsr_w ";
	for (int bc = 0; names.length() > 0; bc++) {
	int sp = names.indexOf(' ');
	BC_NAME[bc] = names.substring(0, sp);
	names = names.substring(sp+1);
	}
	}
	public static String byteName(int bc) {
	String iname;
	if (bc < BC_NAME.length && BC_NAME[bc] != null) {
	iname = BC_NAME[bc];
	} else if (isSelfLinkerOp(bc)) {
	int idx = (bc - _self_linker_op);
	boolean isSuper = (idx >= _self_linker_super_flag);
	if (isSuper) idx -= _self_linker_super_flag;
	boolean isAload = (idx >= _self_linker_aload_flag);
	if (isAload) idx -= _self_linker_aload_flag;
	int origBC = _first_linker_op + idx;
	assert(origBC >= _first_linker_op && origBC <= _last_linker_op);
	iname = BC_NAME[origBC];
	iname += (isSuper ? "_super" : "_this");
	if (isAload) iname = "aload_0&" + iname;
	iname = "*"+iname;
	} else if (isInvokeInitOp(bc)) {
	int idx = (bc - _invokeinit_op);
	switch (idx) {
	case _invokeinit_self_option:
	iname = "*invokespecial_init_this"; break;
	case _invokeinit_super_option:
	iname = "*invokespecial_init_super"; break;
	default:
	assert(idx == _invokeinit_new_option);
	iname = "*invokespecial_init_new"; break;
	}
	} else {
	switch (bc) {
	case _ildc: iname = "*ildc"; break;
	case _fldc: iname = "*fldc"; break;
	case _ildc_w: iname = "*ildc_w"; break;
	case _fldc_w: iname = "*fldc_w"; break;
	case _dldc2_w: iname = "*dldc2_w"; break;
	case _cldc: iname = "*cldc"; break;
	case _cldc_w: iname = "*cldc_w"; break;
	case _qldc: iname = "*qldc"; break;
	case _qldc_w: iname = "*qldc_w"; break;
	case _byte_escape: iname = "*byte_escape"; break;
	case _ref_escape: iname = "*ref_escape"; break;
	case _end_marker: iname = "*end"; break;
	default: iname = "*bc#"+bc; break;
	}
	}
	return iname;
	}
	private static int BW = 4; // width of classification field
	private static void def(String fmt, int bc) {
	def(fmt, bc, bc);
	}
	private static void def(String fmt, int from_bc, int to_bc) {
	String[] fmts = { fmt, null };
	if (fmt.indexOf('w') > 0) {
	fmts[1] = fmt.substring(fmt.indexOf('w'));
	fmts[0] = fmt.substring(0, fmt.indexOf('w'));
	}
	for (int w = 0; w <= 1; w++) {
	fmt = fmts[w];
	if (fmt == null) continue;
	int length = fmt.length();
	int index = Math.max(0, fmt.indexOf('k'));
	int tag = CONSTANT_None;
	int branch = Math.max(0, fmt.indexOf('o'));
	int slot = Math.max(0, fmt.indexOf('l'));
	int con = Math.max(0, fmt.indexOf('x'));
	if (index > 0 && index+1 < length) {
	switch (fmt.charAt(index+1)) {
	case 'c': tag = CONSTANT_Class; break;
	case 'k': tag = CONSTANT_LoadableValue; break;
	case 'f': tag = CONSTANT_Fieldref; break;
	case 'm': tag = CONSTANT_Methodref; break;
	case 'i': tag = CONSTANT_InterfaceMethodref; break;
	case 'y': tag = CONSTANT_InvokeDynamic; break;
	}
	assert(tag != CONSTANT_None);
	} else if (index > 0 && length == 2) {
	assert(from_bc == _ldc);
	tag = CONSTANT_LoadableValue; // _ldc opcode only
	}
	for (int bc = from_bc; bc <= to_bc; bc++) {
	BC_FORMAT[w][bc] = fmt;
	assert(BC_LENGTH[w][bc] == -1);
	BC_LENGTH[w][bc] = (byte) length;
	BC_INDEX[w][bc] = (byte) index;
	BC_TAG[w][bc] = (byte) tag;
	assert(!(index == 0 && tag != CONSTANT_None));
	BC_BRANCH[w][bc] = (byte) branch;
	BC_SLOT[w][bc] = (byte) slot;
	assert(branch == 0 \|\| slot == 0); // not both branch & local
	assert(branch == 0 \|\| index == 0); // not both branch & cp
	assert(slot == 0 \|\| index == 0); // not both local & cp
	BC_CON[w][bc] = (byte) con;
	}
	}
	}

	public static void opcodeChecker(byte[] code, ConstantPool.Entry[] cpMap,
	Package.Version clsVersion) throws FormatException {
	Instruction i = at(code, 0);
	while (i != null) {
	int opcode = i.getBC();
	if (opcode < _nop \|\| opcode > _jsr_w) {
	String message = "illegal opcode: " + opcode + " " + i;
	throw new FormatException(message);
	}
	ConstantPool.Entry e = i.getCPRef(cpMap);
	if (e != null) {
	byte tag = i.getCPTag();
	boolean match = e.tagMatches(tag);
	if (!match &&
	(i.bc == _invokespecial \|\| i.bc == _invokestatic) &&
	e.tagMatches(CONSTANT_InterfaceMethodref) &&
	clsVersion.greaterThan(Constants.JAVA7_MAX_CLASS_VERSION)) {
	match = true;
	}
	if (!match) {
	String message = "illegal reference, expected type="
	+ ConstantPool.tagName(tag) + ": "
	+ i.toString(cpMap);
	throw new FormatException(message);
	}
	}
	i = i.next();
	}
	}
	static class FormatException extends IOException {
	private static final long serialVersionUID = 3175572275651367015L;

	FormatException(String message) {
	super(message);
	}
	}
	}

Back to index...