/*
* 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 org.apache.cocoon.components.flow.java;
import java.util.ArrayList;
import java.util.Vector;
import org.apache.bcel.Constants;
import org.apache.bcel.Repository;
import org.apache.bcel.classfile.ConstantCP;
import org.apache.bcel.classfile.ConstantNameAndType;
import org.apache.bcel.classfile.ConstantPool;
import org.apache.bcel.classfile.ConstantUtf8;
import org.apache.bcel.classfile.JavaClass;
import org.apache.bcel.classfile.Method;
import org.apache.bcel.generic.ACONST_NULL;
import org.apache.bcel.generic.BasicType;
import org.apache.bcel.generic.ClassGen;
import org.apache.bcel.generic.ConstantPoolGen;
import org.apache.bcel.generic.GOTO;
import org.apache.bcel.generic.IFEQ;
import org.apache.bcel.generic.IFNONNULL;
import org.apache.bcel.generic.IFNULL;
import org.apache.bcel.generic.INVOKESTATIC;
import org.apache.bcel.generic.InstructionConstants;
import org.apache.bcel.generic.InstructionFactory;
import org.apache.bcel.generic.InstructionHandle;
import org.apache.bcel.generic.InstructionList;
import org.apache.bcel.generic.InstructionTargeter;
import org.apache.bcel.generic.InvokeInstruction;
import org.apache.bcel.generic.MethodGen;
import org.apache.bcel.generic.ObjectType;
import org.apache.bcel.generic.PUSH;
import org.apache.bcel.generic.RET;
import org.apache.bcel.generic.ReferenceType;
import org.apache.bcel.generic.ReturnaddressType;
import org.apache.bcel.generic.SWAP;
import org.apache.bcel.generic.TABLESWITCH;
import org.apache.bcel.generic.TargetLostException;
import org.apache.bcel.generic.Type;
import org.apache.bcel.util.ClassLoaderRepository;
import org.apache.bcel.verifier.exc.AssertionViolatedException;
import org.apache.bcel.verifier.structurals.ControlFlowGraph;
import org.apache.bcel.verifier.structurals.ExceptionHandler;
import org.apache.bcel.verifier.structurals.ExecutionVisitor;
import org.apache.bcel.verifier.structurals.Frame;
import org.apache.bcel.verifier.structurals.InstConstraintVisitor;
import org.apache.bcel.verifier.structurals.InstructionContext;
import org.apache.bcel.verifier.structurals.LocalVariables;
import org.apache.bcel.verifier.structurals.OperandStack;
import org.apache.bcel.verifier.structurals.UninitializedObjectType;
/**
* The classloader breakes the methods of the classes into pieces and
* add intercepting code to suspend the execution of the method.
*
* This code is based on the original idea of the BRAKES project.
* (http://www.cs.kuleuven.ac.be/~eddy/BRAKES/brakes.html).
*
* @author <a href="mailto:stephan@apache.org">Stephan Michels</a>
* @author <a href="mailto:tcurdt@apache.org">Torsten Curdt</a>
* @version CVS $Id$
*/
public class ContinuationClassLoader extends ClassLoader {
private static final String CONTINUATION_CLASS = Continuation.class.getName();
private static final ObjectType CONTINUATION_TYPE = new ObjectType(CONTINUATION_CLASS);
private static final String STACK_CLASS = ContinuationStack.class.getName();
private static final ObjectType STACK_TYPE = new ObjectType(STACK_CLASS);
private static final String CONTINUABLE_CLASS = Continuable.class.getName();
private static final String CONTINUATIONCAPABLE_CLASS = ContinuationCapable.class.getName();
private static final String CONTINUATION_METHOD = "currentContinuation";
private static final String STACK_METHOD = "getStack";
private static final String POP_METHOD = "pop";
private static final String PUSH_METHOD = "push";
private static final String RESTORING_METHOD = "isRestoring";
private static final String CAPURING_METHOD = "isCapturing";
private static boolean currentMethodStatic;
public ContinuationClassLoader(ClassLoader parent) {
super(parent);
Repository.setRepository(new ClassLoaderRepository(parent));
}
protected synchronized Class loadClass(String name, boolean resolve)
throws ClassNotFoundException {
// this finds also classes, which are already transformed, via findLoadedClass
Class c = super.loadClass(name, resolve);
// transform class if class is continuable and not continuation capable
if ((Continuable.class.isAssignableFrom(c)) &&
(!ContinuationCapable.class.isAssignableFrom(c)) &&
(!c.isInterface())) {
JavaClass clazz = Repository.lookupClass(c);
byte data[] = transform(clazz);
c = defineClass(name, data, 0, data.length);
}
if (c == null) {
throw new ClassNotFoundException(name);
}
if (resolve) {
resolveClass(c);
}
return c;
}
private byte[] transform(JavaClass javaclazz) throws ClassNotFoundException {
// make all methods of java class continuable
ClassGen clazz = new ClassGen(javaclazz);
ConstantPoolGen cp = clazz.getConstantPool();
// obsolete, but neccesary to execute the InvokeContext
InstConstraintVisitor icv = new InstConstraintVisitor();
icv.setConstantPoolGen(cp);
// vistor to build the frame information
ExecutionVisitor ev = new ExecutionVisitor();
ev.setConstantPoolGen(cp);
Method[] methods = clazz.getMethods();
for (int i = 0; i < methods.length; i++) {
MethodGen method = new MethodGen(methods[i], clazz.getClassName(), cp);
currentMethodStatic = methods[i].isStatic();
if (isValid(method)) {
// analyse the code of the method to create the frame
// information about every instruction
ControlFlowGraph cfg = new ControlFlowGraph(method);
analyse(clazz, method, cfg, icv, ev);
// add intercepting code
rewrite(method, cfg);
// make last optional check for consistency
clazz.replaceMethod(methods[i], method.getMethod());
}
}
clazz.addInterface(CONTINUATIONCAPABLE_CLASS);
return clazz.getJavaClass().getBytes();
}
private boolean isValid(MethodGen m) {
if (m.getName().equals(Constants.CONSTRUCTOR_NAME)
|| m.getName().equals(Constants.STATIC_INITIALIZER_NAME)
|| m.isNative()
|| m.isAbstract()) {
return false;
} else {
return true;
}
}
private void analyse(ClassGen clazz, MethodGen method, ControlFlowGraph cfg,
InstConstraintVisitor icv, ExecutionVisitor ev) {
// build the initial frame situation for this method.
Frame vanillaFrame = new Frame(method.getMaxLocals(), method.getMaxStack());
if (!method.isStatic()) {
if (method.getName().equals(Constants.CONSTRUCTOR_NAME)) {
Frame._this = new UninitializedObjectType(new ObjectType(clazz.getClassName()));
vanillaFrame.getLocals().set(0, new UninitializedObjectType(new ObjectType(clazz.getClassName())));
} else {
Frame._this = null;
vanillaFrame.getLocals().set(0, new ObjectType(clazz.getClassName()));
}
}
// fill local variables with parameter types
Type[] argtypes = method.getArgumentTypes();
int twoslotoffset = 0;
for (int j = 0; j < argtypes.length; j++) {
if ((argtypes[j] == Type.SHORT) ||
(argtypes[j] == Type.BYTE) ||
(argtypes[j] == Type.CHAR) ||
(argtypes[j] == Type.BOOLEAN)) {
argtypes[j] = Type.INT;
}
vanillaFrame.getLocals().set(twoslotoffset + j + (method.isStatic() ? 0 : 1), argtypes[j]);
if (argtypes[j].getSize() == 2) {
twoslotoffset++;
vanillaFrame.getLocals().set(twoslotoffset + j + (method.isStatic() ? 0 : 1), Type.UNKNOWN);
}
}
icv.setMethodGen(method);
Vector ics = new Vector(); // Type: InstructionContext
Vector ecs = new Vector(); // Type: ArrayList (of InstructionContext)
InstructionContext start = cfg.contextOf(method.getInstructionList().getStart());
start.execute(vanillaFrame, new ArrayList(), icv, ev);
// new ArrayList() <=> no Instruction was executed before
// => Top-Level routine (no jsr call before)
ics.add(start);
ecs.add(new ArrayList());
while (!ics.isEmpty()) {
InstructionContext u = (InstructionContext)ics.remove(0);
ArrayList ec = (ArrayList)ecs.remove(0);
ArrayList oldchain = (ArrayList)(ec.clone());
ArrayList newchain = (ArrayList)(ec.clone());
newchain.add(u);
if ((u.getInstruction().getInstruction()) instanceof RET) {
// We can only follow _one_ successor, the one after the
// JSR that was recently executed.
RET ret = (RET)u.getInstruction().getInstruction();
ReturnaddressType t = (ReturnaddressType)u.getOutFrame(oldchain).getLocals().get(ret.getIndex());
InstructionContext theSuccessor = cfg.contextOf(t.getTarget());
if (theSuccessor.execute(u.getOutFrame(oldchain), newchain, icv, ev)) {
ics.add(theSuccessor);
ecs.add(newchain.clone());
}
} else { // "not a ret"
// Normal successors. Add them to the queue of successors.
InstructionContext[] succs = u.getSuccessors();
for (int s = 0; s < succs.length; s++) {
InstructionContext v = succs[s];
if (v.execute(u.getOutFrame(oldchain), newchain, icv, ev)) {
ics.add(v);
ecs.add(newchain.clone());
}
}
}
// Exception Handlers. Add them to the queue of successors.
ExceptionHandler[] exc_hds = u.getExceptionHandlers();
for (int s = 0; s < exc_hds.length; s++) {
InstructionContext v = cfg.contextOf(exc_hds[s].getHandlerStart());
// TODO: the "oldchain" and "newchain" is used to determine the subroutine
// we're in (by searching for the last JSR) by the InstructionContext
// implementation. Therefore, we should not use this chain mechanism
// when dealing with exception handlers.
LocalVariables newLocals = u.getOutFrame(oldchain).getLocals();
OperandStack newStack = new OperandStack(
u.getOutFrame(oldchain).getStack().maxStack(),
(exc_hds[s].getExceptionType() == null
? Type.THROWABLE
: exc_hds[s].getExceptionType()));
Frame newFrame = new Frame(newLocals, newStack);
if (v.execute(newFrame, new ArrayList(), icv, ev)) {
ics.add(v);
ecs.add(new ArrayList());
}
}
}
}
private void rewrite(MethodGen method, ControlFlowGraph cfg)
throws ClassNotFoundException {
InstructionFactory insFactory = new InstructionFactory(method.getConstantPool());
Vector invokeIns = new Vector();
int count = 0;
InstructionList insList = method.getInstructionList();
InstructionHandle ins = insList.getStart();
InstructionList restorer = new InstructionList();
while (ins != null) {
InstructionHandle next = ins.getNext();
// if not traversed by the analyser, then don't rewrite
InstructionContext context = null;
Frame frame = null;
try {
context = cfg.contextOf(ins);
frame = context.getOutFrame(new ArrayList());
} catch (AssertionViolatedException ave) {
// empty
}
if (frame != null) {
if (rewriteable(method, ins)) {
// Add frame saver and restorer for the current breakpoint
// determine type of object for the method invocation
InvokeInstruction invoke = (InvokeInstruction)ins.getInstruction();
Type[] arguments = invoke.getArgumentTypes(method.getConstantPool());
ObjectType objecttype = null;
if (!(invoke instanceof INVOKESTATIC)) {
objecttype = (ObjectType)context.getInFrame().getStack().peek(arguments.length);
}
InstructionList rList = restoreFrame(method, ins, insFactory, frame, objecttype);
insList.append(ins, saveFrame(method, ins, count++, insFactory, frame));
invokeIns.addElement(rList.getStart());
restorer.append(rList);
}
// remove all new's
if (ins.getInstruction().getOpcode() == Constants.NEW) {
try {
// remove additional dup's
while (next != null && next.getInstruction().getOpcode() == Constants.DUP) {
context = cfg.contextOf(next);
frame = context.getOutFrame(new ArrayList());
InstructionHandle newnext = next.getNext();
insList.delete(next);
next = newnext;
}
InstructionTargeter[] targeter = ins.getTargeters();
if (targeter != null) {
InstructionHandle newnext = ins.getNext();
for (int i = 0; i < targeter.length; i++) {
targeter[i].updateTarget(ins, newnext);
}
}
insList.delete(ins);
} catch (TargetLostException tle) {
throw new ClassNotFoundException(tle.getMessage(), tle);
}
} else if (ins.getInstruction().getOpcode() == Constants.INVOKESPECIAL) {
// duplicate stack before invokespecial to insert uninitialized object
frame = context.getInFrame();
InvokeInstruction invoke = (InvokeInstruction)ins.getInstruction();
Type[] arguments = invoke.getArgumentTypes(method.getConstantPool());
OperandStack os = frame.getStack();
Type type = os.peek(arguments.length);
if (type instanceof UninitializedObjectType) {
ObjectType objecttype = ((UninitializedObjectType) type).getInitialized();
InstructionList duplicator = duplicateStack(method, invoke, objecttype);
InstructionTargeter[] targeter = ins.getTargeters();
if (targeter!=null) {
InstructionHandle newnext = duplicator.getStart();
for(int i=0; i < targeter.length; i++) {
targeter[i].updateTarget(ins, newnext);
}
}
insList.insert(ins, duplicator);
}
}
}
ins = next;
}
InstructionHandle firstIns = insList.getStart();
if (count > 0) {
InstructionHandle[] tableTargets = new InstructionHandle[count];
int[] match = new int[count];
for (int i = 0; i < count; i++) {
match[i] = i;
}
invokeIns.copyInto(tableTargets);
insList.insert(restorer);
// select frame restorer
insList.insert(new TABLESWITCH(match, tableTargets, firstIns));
insList.insert(insFactory.createInvoke(STACK_CLASS, getPopMethod(Type.INT), Type.INT, Type.NO_ARGS, Constants.INVOKEVIRTUAL));
insList.insert(InstructionFactory.createLoad(STACK_TYPE, method.getMaxLocals()+1));
// test if the continuation should be restored
insList.insert(new IFEQ(firstIns));
insList.insert(insFactory.createInvoke(CONTINUATION_CLASS, RESTORING_METHOD, Type.BOOLEAN, Type.NO_ARGS, Constants.INVOKEVIRTUAL));
insList.insert(InstructionFactory.createLoad(CONTINUATION_TYPE, method.getMaxLocals()));
}
// get stack from current continuation and store in the last local variable
insList.insert(InstructionFactory.createStore(STACK_TYPE, method.getMaxLocals()+1));
insList.insert(insFactory.createInvoke(CONTINUATION_CLASS, STACK_METHOD, STACK_TYPE,
Type.NO_ARGS, Constants.INVOKEVIRTUAL));
InstructionHandle restore_handle = insList.insert(InstructionFactory.createLoad(CONTINUATION_TYPE, method.getMaxLocals()));
// if not continuation exists, create empty stack
insList.insert(new GOTO(firstIns));
insList.insert(InstructionFactory.createStore(STACK_TYPE, method.getMaxLocals()+1));
insList.insert(insFactory.createInvoke(STACK_CLASS, Constants.CONSTRUCTOR_NAME, Type.VOID, Type.NO_ARGS, Constants. INVOKESPECIAL));
insList.insert(InstructionFactory.createDup(STACK_TYPE.getSize()));
insList.insert(insFactory.createNew(STACK_TYPE));
// test if no current continuation exists
insList.insert(new IFNONNULL(restore_handle));
insList.insert(InstructionFactory.createLoad(CONTINUATION_TYPE, method.getMaxLocals()));
// get current continuation and store in the next to last local variable
insList.insert(InstructionFactory.createStore(CONTINUATION_TYPE, method.getMaxLocals()));
insList.insert(insFactory.createInvoke(CONTINUATION_CLASS, CONTINUATION_METHOD, CONTINUATION_TYPE,
Type.NO_ARGS, Constants.INVOKESTATIC));
// make room for additional objects
method.setMaxLocals(method.getMaxLocals() + 2);
method.setMaxStack(method.getMaxStack() + 2);
}
private InstructionList duplicateStack(MethodGen method, InvokeInstruction invoke,
ObjectType objecttype) throws ClassNotFoundException {
// reconstruction of an uninitialed object to call the constructor.
InstructionFactory insFactory = new InstructionFactory(method.getConstantPool());
InstructionList insList = new InstructionList();
Type[] arguments = invoke.getArgumentTypes(method.getConstantPool());
// pop all arguments for the constructor from the stack
for (int i = arguments.length - 1; i >= 0; i--) {
Type type = arguments[i];
insList.append(InstructionFactory.createLoad(STACK_TYPE, method.getMaxLocals()+1));
insList.append(new SWAP());
if (type instanceof BasicType) {
if (type.getSize() < 2 && !type.equals(Type.FLOAT)) {
type = Type.INT;
}
insList.append(insFactory.createInvoke(STACK_CLASS, getPushMethod(type), Type.VOID, new Type[]{type}, Constants.INVOKEVIRTUAL));
} else if (type instanceof ReferenceType) {
insList.append(insFactory.createInvoke(STACK_CLASS, getPushMethod(Type.OBJECT), Type.VOID, new Type[]{Type.OBJECT}, Constants.INVOKEVIRTUAL));
}
}
// create uninitialzed object
insList.append(insFactory.createNew(objecttype));
insList.append(InstructionFactory.createDup(objecttype.getSize()));
// return the arguments into the stack
for (int i = 0; i < arguments.length; i++) {
Type type = arguments[i];
insList.append(InstructionFactory.createLoad(STACK_TYPE, method.getMaxLocals()+1));
if (type instanceof BasicType) {
if (type.getSize() < 2 && !type.equals(Type.FLOAT)) {
type = Type.INT;
}
insList.append(insFactory.createInvoke(STACK_CLASS, getPopMethod(type), type, Type.NO_ARGS, Constants.INVOKEVIRTUAL));
} else if (type instanceof ReferenceType) {
insList.append(insFactory.createInvoke(STACK_CLASS, getPopMethod(Type.OBJECT), Type.OBJECT, Type.NO_ARGS, Constants.INVOKEVIRTUAL));
if (!type.equals(Type.OBJECT)) {
insList.append(insFactory.createCast(Type.OBJECT, type));
}
}
}
return insList;
}
private boolean rewriteable(MethodGen method, InstructionHandle handle)
throws ClassNotFoundException {
// check in the invocation can be a breakpoint.
int opcode = handle.getInstruction().getOpcode();
boolean invokeSpecialSuper = false;
if (opcode == Constants.INVOKESPECIAL) {
InvokeInstruction ivs = (InvokeInstruction) handle.getInstruction();
String mName = ivs.getMethodName(method.getConstantPool());
invokeSpecialSuper = !mName.equals(Constants.CONSTRUCTOR_NAME);
}
if (opcode == Constants.INVOKEVIRTUAL ||
opcode == Constants.INVOKESTATIC ||
opcode == Constants.INVOKEINTERFACE ||
invokeSpecialSuper) {
int index = ((InvokeInstruction) handle.getInstruction()).getIndex();
String classname = getObjectType(method.getConstantPool().getConstantPool(), index).getClassName();
// rewrite invocation if object is continuable or a continuation object
return Repository.implementationOf(classname, CONTINUABLE_CLASS) ||
Repository.instanceOf(classname, CONTINUATION_CLASS);
}
return false;
}
private InstructionList saveFrame(MethodGen method, InstructionHandle handle, int pc,
InstructionFactory insFactory, Frame frame) {
InstructionList insList = new InstructionList();
// Remove needless return type from stack
InvokeInstruction inv = (InvokeInstruction) handle.getInstruction();
Type returnType = getReturnType(method.getConstantPool().getConstantPool(), inv.getIndex());
if (returnType.getSize() > 0) {
insList.insert(InstructionFactory.createPop(returnType.getSize()));
}
boolean skipFirst = returnType.getSize() > 0;
// save stack
OperandStack os = frame.getStack();
for (int i = skipFirst ? 1 : 0; i < os.size(); i++) {
Type type = os.peek(i);
if (type instanceof BasicType) {
if (type.getSize() < 2 && !type.equals(Type.FLOAT)) {
type = Type.INT;
}
insList.append(InstructionFactory.createLoad(STACK_TYPE, method.getMaxLocals()+1));
insList.append(new SWAP()); // TODO: check for types with two words on stack
insList.append(insFactory.createInvoke(STACK_CLASS, getPushMethod(type), Type.VOID, new Type[]{type}, Constants.INVOKEVIRTUAL));
} else if (type == null) {
insList.append(InstructionConstants.POP);
} else if (type instanceof UninitializedObjectType) {
// After the remove of new, there shouldn't be a
// uninitialized object on the stack
} else if (type instanceof ReferenceType) {
insList.append(InstructionFactory.createLoad(STACK_TYPE, method.getMaxLocals()+1));
insList.append(new SWAP());
insList.append(insFactory.createInvoke(STACK_CLASS, getPushMethod(Type.OBJECT), Type.VOID, new Type[]{Type.OBJECT}, Constants.INVOKEVIRTUAL));
}
}
// add isCapturing test
insList.insert(new IFEQ(handle.getNext()));
// test if the continuation should be captured after the invocation
insList.insert(insFactory.createInvoke(CONTINUATION_CLASS, CAPURING_METHOD, Type.BOOLEAN, Type.NO_ARGS, Constants.INVOKEVIRTUAL));
insList.insert(InstructionFactory.createLoad(CONTINUATION_TYPE, method.getMaxLocals()));
// test if continuation exists
insList.insert(new IFNULL(handle.getNext()));
insList.insert(InstructionFactory.createLoad(CONTINUATION_TYPE, method.getMaxLocals()));
// save local variables
LocalVariables lvs = frame.getLocals();
for (int i = 0; i < lvs.maxLocals(); i++) {
Type type = lvs.get(i);
if (type instanceof BasicType) {
insList.append(InstructionFactory.createLoad(STACK_TYPE, method.getMaxLocals()+1));
insList.append(InstructionFactory.createLoad(type, i));
if (type.getSize() < 2 && !type.equals(Type.FLOAT))
type = Type.INT;
insList.append(insFactory.createInvoke(STACK_CLASS, getPushMethod(type), Type.VOID, new Type[]{type}, Constants.INVOKEVIRTUAL));
} else if (type == null) {
// no need to save null
} else if (type instanceof UninitializedObjectType) {
// no need to save uninitialized objects
} else if (type instanceof ReferenceType) {
if (i == 0 && !currentMethodStatic) {
// remember current object
insList.append(InstructionFactory.createLoad(STACK_TYPE, method.getMaxLocals()+1));
insList.append(InstructionFactory.createLoad(type, i));
insList.append(insFactory.createInvoke(STACK_CLASS, PUSH_METHOD + "Reference", Type.VOID, new Type[]{Type.OBJECT}, Constants.INVOKEVIRTUAL));
}
insList.append(InstructionFactory.createLoad(STACK_TYPE, method.getMaxLocals()+1));
insList.append(InstructionFactory.createLoad(type, i));
insList.append(insFactory.createInvoke(STACK_CLASS, getPushMethod(Type.OBJECT), Type.VOID, new Type[]{Type.OBJECT}, Constants.INVOKEVIRTUAL));
}
}
// save programcounter
insList.append(InstructionFactory.createLoad(STACK_TYPE, method.getMaxLocals()+1));
insList.append(new PUSH(method.getConstantPool(), pc));
insList.append(insFactory.createInvoke(STACK_CLASS, getPushMethod(Type.INT), Type.VOID, new Type[]{Type.INT}, Constants.INVOKEVIRTUAL));
// return NULL result
insList.append(InstructionFactory.createNull(method.getReturnType()));
insList.append(InstructionFactory.createReturn(method.getReturnType()));
return insList;
}
private InstructionList restoreFrame(MethodGen method, InstructionHandle handle,
InstructionFactory insFactory, Frame frame, ObjectType objecttype) {
InstructionList insList = new InstructionList();
// restore local variables
LocalVariables lvs = frame.getLocals();
for (int i = lvs.maxLocals() - 1; i >= 0; i--) {
Type type = lvs.get(i);
if (type instanceof BasicType) {
insList.append(InstructionFactory.createLoad(STACK_TYPE, method.getMaxLocals()+1));
if (type.getSize() < 2 && !type.equals(Type.FLOAT)) {
type = Type.INT;
}
insList.append(insFactory.createInvoke(STACK_CLASS, getPopMethod(type), type, Type.NO_ARGS, Constants.INVOKEVIRTUAL));
insList.append(InstructionFactory.createStore(type, i));
} else if (type == null) {
insList.append(new ACONST_NULL());
insList.append(InstructionFactory.createStore(new ObjectType("<null object>"), i));
} else if (type instanceof UninitializedObjectType) {
// No uninitilaized objects should be found
// in the local variables.
} else if (type instanceof ReferenceType) {
insList.append(InstructionFactory.createLoad(STACK_TYPE, method.getMaxLocals()+1));
insList.append(insFactory.createInvoke(STACK_CLASS, getPopMethod(Type.OBJECT), Type.OBJECT, Type.NO_ARGS, Constants.INVOKEVIRTUAL));
if (!type.equals(Type.OBJECT) && (!type.equals(Type.NULL))) {
insList.append(insFactory.createCast(Type.OBJECT, type));
}
insList.append(InstructionFactory.createStore(type, i));
}
}
InvokeInstruction inv = (InvokeInstruction) handle.getInstruction();
Type returnType = getReturnType(method.getConstantPool().getConstantPool(), inv.getIndex());
boolean skipFirst = returnType.getSize() > 0;
// restore stack
OperandStack os = frame.getStack();
for (int i = os.size() - 1; i >= (skipFirst ? 1 : 0); i--) {
Type type = os.peek(i);
if (type instanceof BasicType) {
if (type.getSize() < 2 && !type.equals(Type.FLOAT)) {
type = Type.INT;
}
insList.append(InstructionFactory.createLoad(STACK_TYPE, method.getMaxLocals()+1));
insList.append(insFactory.createInvoke(STACK_CLASS, getPopMethod(type), type, Type.NO_ARGS, Constants.INVOKEVIRTUAL));
} else if (type == null) {
insList.append(new ACONST_NULL());
} else if (type instanceof UninitializedObjectType) {
// After the remove of new, there shouldn't be a
// uninitialized object on the stack
} else if (type instanceof ReferenceType) {
insList.append(InstructionFactory.createLoad(STACK_TYPE, method.getMaxLocals()+1));
insList.append(insFactory.createInvoke(STACK_CLASS, getPopMethod(Type.OBJECT), Type.OBJECT, Type.NO_ARGS, Constants.INVOKEVIRTUAL));
if (!type.equals(Type.OBJECT))
insList.append(insFactory.createCast(Type.OBJECT, type));
}
}
// retrieve current object
if (!(inv instanceof INVOKESTATIC)) {
insList.append(InstructionFactory.createLoad(STACK_TYPE, method.getMaxLocals()+1));
insList.append(insFactory.createInvoke(STACK_CLASS, POP_METHOD + "Reference", Type.OBJECT, Type.NO_ARGS, Constants.INVOKEVIRTUAL));
insList.append(insFactory.createCast(Type.OBJECT, objecttype));
}
// Create null types for the parameters of the method invocation
Type[] paramTypes = getParamTypes(method.getConstantPool().getConstantPool(), inv.getIndex());
for (int j = 0; j < paramTypes.length; j++) {
insList.append(InstructionFactory.createNull(paramTypes[j]));
}
// go to last invocation
insList.append(new GOTO(handle));
return insList;
}
private ObjectType getObjectType(ConstantPool cp, int index) {
ConstantCP cmr = (ConstantCP) cp.getConstant(index);
String sig = cp.getConstantString(cmr.getClassIndex(), Constants.CONSTANT_Class);
return new ObjectType(sig.replace('/', '.'));
}
private Type[] getParamTypes(ConstantPool cp, int index) {
ConstantCP cmr = (ConstantCP) cp.getConstant(index);
ConstantNameAndType cnat = (ConstantNameAndType) cp.getConstant(cmr.getNameAndTypeIndex());
String sig = ((ConstantUtf8) cp.getConstant(cnat.getSignatureIndex())).getBytes();
return Type.getArgumentTypes(sig);
}
private Type getReturnType(ConstantPool cp, int index) {
ConstantCP cmr = (ConstantCP) cp.getConstant(index);
ConstantNameAndType cnat = (ConstantNameAndType) cp.getConstant(cmr.getNameAndTypeIndex());
String sig = ((ConstantUtf8) cp.getConstant(cnat.getSignatureIndex())).getBytes();
return Type.getReturnType(sig);
}
private String getPopMethod(Type type) {
return POP_METHOD + getTypeSuffix(type);
}
private String getPushMethod(Type type) {
return PUSH_METHOD + getTypeSuffix(type);
}
private String getTypeSuffix(Type type) {
if (type.equals(Type.BOOLEAN))
return "Int";
else if (type.equals(Type.CHAR))
return "Int";
else if (type.equals(Type.FLOAT))
return "Float";
else if (type.equals(Type.DOUBLE))
return "Double";
else if (type.equals(Type.BYTE))
return "Int";
else if (type.equals(Type.SHORT))
return "Int";
else if (type.equals(Type.INT))
return "Int";
else if (type.equals(Type.LONG))
return "Long";
// VOID and OBJECT are "Object"
return "Object";
}
}