Back to index...

	/*
	* Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
	*/
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package com.sun.org.apache.bcel.internal.generic;

	import com.sun.org.apache.bcel.internal.Const;

	/**
	* Instances of this class may be used, e.g., to generate typed versions of
	* instructions. Its main purpose is to be used as the byte code generating
	* backend of a compiler. You can subclass it to add your own create methods.
	* <p>
	* Note: The static createXXX methods return singleton instances from the
	* {@link InstructionConst} class.
	*
	* @version $Id: InstructionFactory.java 1749603 2016-06-21 20:50:19Z ggregory $
	* @see Const
	* @see InstructionConst
	* @LastModified: Nov 2017
	*/
	public class InstructionFactory {

	// N.N. These must agree with the order of Constants.T_CHAR through T_LONG
	private static final String[] short_names = {
	"C", "F", "D", "B", "S", "I", "L"
	};

	private ClassGen cg;
	private ConstantPoolGen cp;

	public InstructionFactory(final ClassGen cg, final ConstantPoolGen cp) {
	this.cg = cg;
	this.cp = cp;
	}

	/**
	* Initialize with ClassGen object
	*/
	public InstructionFactory(final ClassGen cg) {
	this(cg, cg.getConstantPool());
	}

	/**
	* Initialize just with ConstantPoolGen object
	*/
	public InstructionFactory(final ConstantPoolGen cp) {
	this(null, cp);
	}

	/**
	* Create an invoke instruction. (Except for invokedynamic.)
	*
	* @param class_name name of the called class
	* @param name name of the called method
	* @param ret_type return type of method
	* @param arg_types argument types of method
	* @param kind how to invoke, i.e., INVOKEINTERFACE, INVOKESTATIC,
	* INVOKEVIRTUAL, or INVOKESPECIAL
	* @see Const
	*/
	public InvokeInstruction createInvoke(final String class_name, final String name, final Type ret_type,
	final Type[] arg_types, final short kind) {
	int index;
	int nargs = 0;
	final String signature = Type.getMethodSignature(ret_type, arg_types);
	for (final Type arg_type : arg_types) {
	nargs += arg_type.getSize();
	}
	if (kind == Const.INVOKEINTERFACE) {
	index = cp.addInterfaceMethodref(class_name, name, signature);
	} else {
	index = cp.addMethodref(class_name, name, signature);
	}
	switch (kind) {
	case Const.INVOKESPECIAL:
	return new INVOKESPECIAL(index);
	case Const.INVOKEVIRTUAL:
	return new INVOKEVIRTUAL(index);
	case Const.INVOKESTATIC:
	return new INVOKESTATIC(index);
	case Const.INVOKEINTERFACE:
	return new INVOKEINTERFACE(index, nargs + 1);
	case Const.INVOKEDYNAMIC:
	return new INVOKEDYNAMIC(index);
	default:
	throw new RuntimeException("Oops: Unknown invoke kind: " + kind);
	}
	}

	/**
	* Create an invokedynamic instruction.
	*
	* @param bootstrap_index index into the bootstrap_methods array
	* @param name name of the called method
	* @param ret_type return type of method
	* @param arg_types argument types of method
	* @see Constants
	*/
	/*
	* createInvokeDynamic only needed if instrumention code wants to generate
	* a new invokedynamic instruction. I don't think we need. (markro)
	*
	public InvokeInstruction createInvokeDynamic( int bootstrap_index, String name, Type ret_type,
	Type[] arg_types) {
	int index;
	int nargs = 0;
	String signature = Type.getMethodSignature(ret_type, arg_types);
	for (int i = 0; i < arg_types.length; i++) {
	nargs += arg_types[i].getSize();
	}
	// UNDONE - needs to be added to ConstantPoolGen
	//index = cp.addInvokeDynamic(bootstrap_index, name, signature);
	index = 0;
	return new INVOKEDYNAMIC(index);
	}
	*/
	/**
	* Create a call to the most popular System.out.println() method.
	*
	* @param s the string to print
	*/
	public InstructionList createPrintln(final String s) {
	final InstructionList il = new InstructionList();
	final int out = cp.addFieldref("java.lang.System", "out", "Ljava/io/PrintStream;");
	final int println = cp.addMethodref("java.io.PrintStream", "println", "(Ljava/lang/String;)V");
	il.append(new GETSTATIC(out));
	il.append(new PUSH(cp, s));
	il.append(new INVOKEVIRTUAL(println));
	return il;
	}

	/**
	* Uses PUSH to push a constant value onto the stack.
	*
	* @param value must be of type Number, Boolean, Character or String
	*/
	public Instruction createConstant(final Object value) {
	PUSH push;
	if (value instanceof Number) {
	push = new PUSH(cp, (Number) value);
	} else if (value instanceof String) {
	push = new PUSH(cp, (String) value);
	} else if (value instanceof Boolean) {
	push = new PUSH(cp, (Boolean) value);
	} else if (value instanceof Character) {
	push = new PUSH(cp, (Character) value);
	} else {
	throw new ClassGenException("Illegal type: " + value.getClass());
	}
	return push.getInstruction();
	}

	private static class MethodObject {

	final Type[] arg_types;
	final Type result_type;
	final String class_name;
	final String name;

	MethodObject(final String c, final String n, final Type r, final Type[] a) {
	class_name = c;
	name = n;
	result_type = r;
	arg_types = a;
	}
	}

	private InvokeInstruction createInvoke(final MethodObject m, final short kind) {
	return createInvoke(m.class_name, m.name, m.result_type, m.arg_types, kind);
	}

	private static final MethodObject[] append_mos = {
	new MethodObject("java.lang.StringBuffer", "append", Type.STRINGBUFFER, new Type[]{
	Type.STRING
	}),
	new MethodObject("java.lang.StringBuffer", "append", Type.STRINGBUFFER, new Type[]{
	Type.OBJECT
	}),
	null,
	null, // indices 2, 3
	new MethodObject("java.lang.StringBuffer", "append", Type.STRINGBUFFER, new Type[]{
	Type.BOOLEAN
	}),
	new MethodObject("java.lang.StringBuffer", "append", Type.STRINGBUFFER, new Type[]{
	Type.CHAR
	}),
	new MethodObject("java.lang.StringBuffer", "append", Type.STRINGBUFFER, new Type[]{
	Type.FLOAT
	}),
	new MethodObject("java.lang.StringBuffer", "append", Type.STRINGBUFFER, new Type[]{
	Type.DOUBLE
	}),
	new MethodObject("java.lang.StringBuffer", "append", Type.STRINGBUFFER, new Type[]{
	Type.INT
	}),
	new MethodObject("java.lang.StringBuffer", "append", Type.STRINGBUFFER, // No append(byte)
	new Type[]{
	Type.INT
	}),
	new MethodObject("java.lang.StringBuffer", "append", Type.STRINGBUFFER, // No append(short)
	new Type[]{
	Type.INT
	}),
	new MethodObject("java.lang.StringBuffer", "append", Type.STRINGBUFFER, new Type[]{
	Type.LONG
	})
	};

	private static boolean isString(final Type type) {
	return (type instanceof ObjectType)
	&& ((ObjectType) type).getClassName().equals("java.lang.String");
	}

	public Instruction createAppend(final Type type) {
	final byte t = type.getType();
	if (isString(type)) {
	return createInvoke(append_mos[0], Const.INVOKEVIRTUAL);
	}
	switch (t) {
	case Const.T_BOOLEAN:
	case Const.T_CHAR:
	case Const.T_FLOAT:
	case Const.T_DOUBLE:
	case Const.T_BYTE:
	case Const.T_SHORT:
	case Const.T_INT:
	case Const.T_LONG:
	return createInvoke(append_mos[t], Const.INVOKEVIRTUAL);
	case Const.T_ARRAY:
	case Const.T_OBJECT:
	return createInvoke(append_mos[1], Const.INVOKEVIRTUAL);
	default:
	throw new RuntimeException("Oops: No append for this type? " + type);
	}
	}

	/**
	* Create a field instruction.
	*
	* @param class_name name of the accessed class
	* @param name name of the referenced field
	* @param type type of field
	* @param kind how to access, i.e., GETFIELD, PUTFIELD, GETSTATIC, PUTSTATIC
	* @see Const
	*/
	public FieldInstruction createFieldAccess(final String class_name, final String name, final Type type, final short kind) {
	int index;
	final String signature = type.getSignature();
	index = cp.addFieldref(class_name, name, signature);
	switch (kind) {
	case Const.GETFIELD:
	return new GETFIELD(index);
	case Const.PUTFIELD:
	return new PUTFIELD(index);
	case Const.GETSTATIC:
	return new GETSTATIC(index);
	case Const.PUTSTATIC:
	return new PUTSTATIC(index);
	default:
	throw new RuntimeException("Oops: Unknown getfield kind:" + kind);
	}
	}

	/**
	* Create reference to `this'
	*/
	public static Instruction createThis() {
	return new ALOAD(0);
	}

	/**
	* Create typed return
	*/
	public static ReturnInstruction createReturn(final Type type) {
	switch (type.getType()) {
	case Const.T_ARRAY:
	case Const.T_OBJECT:
	return InstructionConst.ARETURN;
	case Const.T_INT:
	case Const.T_SHORT:
	case Const.T_BOOLEAN:
	case Const.T_CHAR:
	case Const.T_BYTE:
	return InstructionConst.IRETURN;
	case Const.T_FLOAT:
	return InstructionConst.FRETURN;
	case Const.T_DOUBLE:
	return InstructionConst.DRETURN;
	case Const.T_LONG:
	return InstructionConst.LRETURN;
	case Const.T_VOID:
	return InstructionConst.RETURN;
	default:
	throw new RuntimeException("Invalid type: " + type);
	}
	}

	private static ArithmeticInstruction createBinaryIntOp(final char first, final String op) {
	switch (first) {
	case '-':
	return InstructionConst.ISUB;
	case '+':
	return InstructionConst.IADD;
	case '%':
	return InstructionConst.IREM;
	case '*':
	return InstructionConst.IMUL;
	case '/':
	return InstructionConst.IDIV;
	case '&':
	return InstructionConst.IAND;
	case '\|':
	return InstructionConst.IOR;
	case '^':
	return InstructionConst.IXOR;
	case '<':
	return InstructionConst.ISHL;
	case '>':
	return op.equals(">>>") ? InstructionConst.IUSHR : InstructionConst.ISHR;
	default:
	throw new RuntimeException("Invalid operand " + op);
	}
	}

	private static ArithmeticInstruction createBinaryLongOp(final char first, final String op) {
	switch (first) {
	case '-':
	return InstructionConst.LSUB;
	case '+':
	return InstructionConst.LADD;
	case '%':
	return InstructionConst.LREM;
	case '*':
	return InstructionConst.LMUL;
	case '/':
	return InstructionConst.LDIV;
	case '&':
	return InstructionConst.LAND;
	case '\|':
	return InstructionConst.LOR;
	case '^':
	return InstructionConst.LXOR;
	case '<':
	return InstructionConst.LSHL;
	case '>':
	return op.equals(">>>") ? InstructionConst.LUSHR : InstructionConst.LSHR;
	default:
	throw new RuntimeException("Invalid operand " + op);
	}
	}

	private static ArithmeticInstruction createBinaryFloatOp(final char op) {
	switch (op) {
	case '-':
	return InstructionConst.FSUB;
	case '+':
	return InstructionConst.FADD;
	case '*':
	return InstructionConst.FMUL;
	case '/':
	return InstructionConst.FDIV;
	case '%':
	return InstructionConst.FREM;
	default:
	throw new RuntimeException("Invalid operand " + op);
	}
	}

	private static ArithmeticInstruction createBinaryDoubleOp(final char op) {
	switch (op) {
	case '-':
	return InstructionConst.DSUB;
	case '+':
	return InstructionConst.DADD;
	case '*':
	return InstructionConst.DMUL;
	case '/':
	return InstructionConst.DDIV;
	case '%':
	return InstructionConst.DREM;
	default:
	throw new RuntimeException("Invalid operand " + op);
	}
	}

	/**
	* Create binary operation for simple basic types, such as int and float.
	*
	* @param op operation, such as "+", "*", "<<", etc.
	*/
	public static ArithmeticInstruction createBinaryOperation(final String op, final Type type) {
	final char first = op.charAt(0);
	switch (type.getType()) {
	case Const.T_BYTE:
	case Const.T_SHORT:
	case Const.T_INT:
	case Const.T_CHAR:
	return createBinaryIntOp(first, op);
	case Const.T_LONG:
	return createBinaryLongOp(first, op);
	case Const.T_FLOAT:
	return createBinaryFloatOp(first);
	case Const.T_DOUBLE:
	return createBinaryDoubleOp(first);
	default:
	throw new RuntimeException("Invalid type " + type);
	}
	}

	/**
	* @param size size of operand, either 1 (int, e.g.) or 2 (double)
	*/
	public static StackInstruction createPop(final int size) {
	return (size == 2) ? InstructionConst.POP2 : InstructionConst.POP;
	}

	/**
	* @param size size of operand, either 1 (int, e.g.) or 2 (double)
	*/
	public static StackInstruction createDup(final int size) {
	return (size == 2) ? InstructionConst.DUP2 : InstructionConst.DUP;
	}

	/**
	* @param size size of operand, either 1 (int, e.g.) or 2 (double)
	*/
	public static StackInstruction createDup_2(final int size) {
	return (size == 2) ? InstructionConst.DUP2_X2 : InstructionConst.DUP_X2;
	}

	/**
	* @param size size of operand, either 1 (int, e.g.) or 2 (double)
	*/
	public static StackInstruction createDup_1(final int size) {
	return (size == 2) ? InstructionConst.DUP2_X1 : InstructionConst.DUP_X1;
	}

	/**
	* @param index index of local variable
	*/
	public static LocalVariableInstruction createStore(final Type type, final int index) {
	switch (type.getType()) {
	case Const.T_BOOLEAN:
	case Const.T_CHAR:
	case Const.T_BYTE:
	case Const.T_SHORT:
	case Const.T_INT:
	return new ISTORE(index);
	case Const.T_FLOAT:
	return new FSTORE(index);
	case Const.T_DOUBLE:
	return new DSTORE(index);
	case Const.T_LONG:
	return new LSTORE(index);
	case Const.T_ARRAY:
	case Const.T_OBJECT:
	return new ASTORE(index);
	default:
	throw new RuntimeException("Invalid type " + type);
	}
	}

	/**
	* @param index index of local variable
	*/
	public static LocalVariableInstruction createLoad(final Type type, final int index) {
	switch (type.getType()) {
	case Const.T_BOOLEAN:
	case Const.T_CHAR:
	case Const.T_BYTE:
	case Const.T_SHORT:
	case Const.T_INT:
	return new ILOAD(index);
	case Const.T_FLOAT:
	return new FLOAD(index);
	case Const.T_DOUBLE:
	return new DLOAD(index);
	case Const.T_LONG:
	return new LLOAD(index);
	case Const.T_ARRAY:
	case Const.T_OBJECT:
	return new ALOAD(index);
	default:
	throw new RuntimeException("Invalid type " + type);
	}
	}

	/**
	* @param type type of elements of array, i.e., array.getElementType()
	*/
	public static ArrayInstruction createArrayLoad(final Type type) {
	switch (type.getType()) {
	case Const.T_BOOLEAN:
	case Const.T_BYTE:
	return InstructionConst.BALOAD;
	case Const.T_CHAR:
	return InstructionConst.CALOAD;
	case Const.T_SHORT:
	return InstructionConst.SALOAD;
	case Const.T_INT:
	return InstructionConst.IALOAD;
	case Const.T_FLOAT:
	return InstructionConst.FALOAD;
	case Const.T_DOUBLE:
	return InstructionConst.DALOAD;
	case Const.T_LONG:
	return InstructionConst.LALOAD;
	case Const.T_ARRAY:
	case Const.T_OBJECT:
	return InstructionConst.AALOAD;
	default:
	throw new RuntimeException("Invalid type " + type);
	}
	}

	/**
	* @param type type of elements of array, i.e., array.getElementType()
	*/
	public static ArrayInstruction createArrayStore(final Type type) {
	switch (type.getType()) {
	case Const.T_BOOLEAN:
	case Const.T_BYTE:
	return InstructionConst.BASTORE;
	case Const.T_CHAR:
	return InstructionConst.CASTORE;
	case Const.T_SHORT:
	return InstructionConst.SASTORE;
	case Const.T_INT:
	return InstructionConst.IASTORE;
	case Const.T_FLOAT:
	return InstructionConst.FASTORE;
	case Const.T_DOUBLE:
	return InstructionConst.DASTORE;
	case Const.T_LONG:
	return InstructionConst.LASTORE;
	case Const.T_ARRAY:
	case Const.T_OBJECT:
	return InstructionConst.AASTORE;
	default:
	throw new RuntimeException("Invalid type " + type);
	}
	}

	/**
	* Create conversion operation for two stack operands, this may be an I2C,
	* instruction, e.g., if the operands are basic types and CHECKCAST if they
	* are reference types.
	*/
	public Instruction createCast(final Type src_type, final Type dest_type) {
	if ((src_type instanceof BasicType) && (dest_type instanceof BasicType)) {
	final byte dest = dest_type.getType();
	byte src = src_type.getType();
	if (dest == Const.T_LONG
	&& (src == Const.T_CHAR \|\| src == Const.T_BYTE \|\| src == Const.T_SHORT)) {
	src = Const.T_INT;
	}
	final String name = "com.sun.org.apache.bcel.internal.generic." + short_names[src - Const.T_CHAR] + "2"
	+ short_names[dest - Const.T_CHAR];
	Instruction i = null;
	try {
	i = (Instruction) java.lang.Class.forName(name).getDeclaredConstructor().newInstance();
	} catch (final Exception e) {
	throw new RuntimeException("Could not find instruction: " + name, e);
	}
	return i;
	} else if ((src_type instanceof ReferenceType) && (dest_type instanceof ReferenceType)) {
	if (dest_type instanceof ArrayType) {
	return new CHECKCAST(cp.addArrayClass((ArrayType) dest_type));
	}
	return new CHECKCAST(cp.addClass(((ObjectType) dest_type).getClassName()));
	} else {
	throw new RuntimeException("Can not cast " + src_type + " to " + dest_type);
	}
	}

	public GETFIELD createGetField(final String class_name, final String name, final Type t) {
	return new GETFIELD(cp.addFieldref(class_name, name, t.getSignature()));
	}

	public GETSTATIC createGetStatic(final String class_name, final String name, final Type t) {
	return new GETSTATIC(cp.addFieldref(class_name, name, t.getSignature()));
	}

	public PUTFIELD createPutField(final String class_name, final String name, final Type t) {
	return new PUTFIELD(cp.addFieldref(class_name, name, t.getSignature()));
	}

	public PUTSTATIC createPutStatic(final String class_name, final String name, final Type t) {
	return new PUTSTATIC(cp.addFieldref(class_name, name, t.getSignature()));
	}

	public CHECKCAST createCheckCast(final ReferenceType t) {
	if (t instanceof ArrayType) {
	return new CHECKCAST(cp.addArrayClass((ArrayType) t));
	}
	return new CHECKCAST(cp.addClass((ObjectType) t));
	}

	public INSTANCEOF createInstanceOf(final ReferenceType t) {
	if (t instanceof ArrayType) {
	return new INSTANCEOF(cp.addArrayClass((ArrayType) t));
	}
	return new INSTANCEOF(cp.addClass((ObjectType) t));
	}

	public NEW createNew(final ObjectType t) {
	return new NEW(cp.addClass(t));
	}

	public NEW createNew(final String s) {
	return createNew(ObjectType.getInstance(s));
	}

	/**
	* Create new array of given size and type.
	*
	* @return an instruction that creates the corresponding array at runtime,
	* i.e. is an AllocationInstruction
	*/
	public Instruction createNewArray(final Type t, final short dim) {
	if (dim == 1) {
	if (t instanceof ObjectType) {
	return new ANEWARRAY(cp.addClass((ObjectType) t));
	} else if (t instanceof ArrayType) {
	return new ANEWARRAY(cp.addArrayClass((ArrayType) t));
	} else {
	return new NEWARRAY(t.getType());
	}
	}
	ArrayType at;
	if (t instanceof ArrayType) {
	at = (ArrayType) t;
	} else {
	at = new ArrayType(t, dim);
	}
	return new MULTIANEWARRAY(cp.addArrayClass(at), dim);
	}

	/**
	* Create "null" value for reference types, 0 for basic types like int
	*/
	public static Instruction createNull(final Type type) {
	switch (type.getType()) {
	case Const.T_ARRAY:
	case Const.T_OBJECT:
	return InstructionConst.ACONST_NULL;
	case Const.T_INT:
	case Const.T_SHORT:
	case Const.T_BOOLEAN:
	case Const.T_CHAR:
	case Const.T_BYTE:
	return InstructionConst.ICONST_0;
	case Const.T_FLOAT:
	return InstructionConst.FCONST_0;
	case Const.T_DOUBLE:
	return InstructionConst.DCONST_0;
	case Const.T_LONG:
	return InstructionConst.LCONST_0;
	case Const.T_VOID:
	return InstructionConst.NOP;
	default:
	throw new RuntimeException("Invalid type: " + type);
	}
	}

	/**
	* Create branch instruction by given opcode, except LOOKUPSWITCH and
	* TABLESWITCH. For those you should use the SWITCH compound instruction.
	*/
	public static BranchInstruction createBranchInstruction(final short opcode, final InstructionHandle target) {
	switch (opcode) {
	case Const.IFEQ:
	return new IFEQ(target);
	case Const.IFNE:
	return new IFNE(target);
	case Const.IFLT:
	return new IFLT(target);
	case Const.IFGE:
	return new IFGE(target);
	case Const.IFGT:
	return new IFGT(target);
	case Const.IFLE:
	return new IFLE(target);
	case Const.IF_ICMPEQ:
	return new IF_ICMPEQ(target);
	case Const.IF_ICMPNE:
	return new IF_ICMPNE(target);
	case Const.IF_ICMPLT:
	return new IF_ICMPLT(target);
	case Const.IF_ICMPGE:
	return new IF_ICMPGE(target);
	case Const.IF_ICMPGT:
	return new IF_ICMPGT(target);
	case Const.IF_ICMPLE:
	return new IF_ICMPLE(target);
	case Const.IF_ACMPEQ:
	return new IF_ACMPEQ(target);
	case Const.IF_ACMPNE:
	return new IF_ACMPNE(target);
	case Const.GOTO:
	return new GOTO(target);
	case Const.JSR:
	return new JSR(target);
	case Const.IFNULL:
	return new IFNULL(target);
	case Const.IFNONNULL:
	return new IFNONNULL(target);
	case Const.GOTO_W:
	return new GOTO_W(target);
	case Const.JSR_W:
	return new JSR_W(target);
	default:
	throw new RuntimeException("Invalid opcode: " + opcode);
	}
	}

	public void setClassGen(final ClassGen c) {
	cg = c;
	}

	public ClassGen getClassGen() {
	return cg;
	}

	public void setConstantPool(final ConstantPoolGen c) {
	cp = c;
	}

	public ConstantPoolGen getConstantPool() {
	return cp;
	}
	}

Back to index...