/*
* ProGuard -- shrinking, optimization, obfuscation, and preverification
* of Java bytecode.
*
* Copyright (c) 2002-2010 Eric Lafortune (eric@graphics.cornell.edu)
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the Free
* Software Foundation; either version 2 of the License, or (at your option)
* any later version.
*
* This program 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 for
* more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
package proguard.optimize.info;
import proguard.classfile.*;
import proguard.classfile.attribute.CodeAttribute;
import proguard.classfile.constant.RefConstant;
import proguard.classfile.constant.visitor.ConstantVisitor;
import proguard.classfile.instruction.*;
import proguard.classfile.instruction.visitor.InstructionVisitor;
import proguard.classfile.util.SimplifiedVisitor;
import proguard.classfile.visitor.MemberVisitor;
/**
* This class can tell whether an instruction might throw exceptions.
*
* @author Eric Lafortune
*/
public class ExceptionInstructionChecker
extends SimplifiedVisitor
implements InstructionVisitor
// ConstantVisitor,
// MemberVisitor
{
// A return value for the visitor methods.
private boolean mayThrowExceptions;
/**
* Returns whether the given instruction may throw exceptions.
*/
public boolean mayThrowExceptions(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, Instruction instruction)
{
mayThrowExceptions = false;
instruction.accept(clazz, method, codeAttribute, offset, this);
return mayThrowExceptions;
}
// Implementations for InstructionVisitor.
public void visitAnyInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, Instruction instruction) {}
public void visitSimpleInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, SimpleInstruction simpleInstruction)
{
byte opcode = simpleInstruction.opcode;
// Check for instructions that may throw exceptions.
// Note that monitorexit can not sensibly throw exceptions, except the
// broken and deprecated asynchronous ThreadDeath. Removing the
// artificial infinite looping exception blocks that recent compilers
// add does not strictly follow the JVM specs, but it does have the
// additional benefit of avoiding a bug in the JVM in JDK 1.1.
switch (opcode)
{
case InstructionConstants.OP_IDIV:
case InstructionConstants.OP_LDIV:
case InstructionConstants.OP_IREM:
case InstructionConstants.OP_LREM:
case InstructionConstants.OP_IALOAD:
case InstructionConstants.OP_LALOAD:
case InstructionConstants.OP_FALOAD:
case InstructionConstants.OP_DALOAD:
case InstructionConstants.OP_AALOAD:
case InstructionConstants.OP_BALOAD:
case InstructionConstants.OP_CALOAD:
case InstructionConstants.OP_SALOAD:
case InstructionConstants.OP_IASTORE:
case InstructionConstants.OP_LASTORE:
case InstructionConstants.OP_FASTORE:
case InstructionConstants.OP_DASTORE:
case InstructionConstants.OP_AASTORE:
case InstructionConstants.OP_BASTORE:
case InstructionConstants.OP_CASTORE:
case InstructionConstants.OP_SASTORE:
case InstructionConstants.OP_NEWARRAY:
case InstructionConstants.OP_ARRAYLENGTH:
case InstructionConstants.OP_ATHROW:
case InstructionConstants.OP_MONITORENTER:
// These instructions may throw exceptions.
mayThrowExceptions = true;
}
}
public void visitConstantInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, ConstantInstruction constantInstruction)
{
byte opcode = constantInstruction.opcode;
// Check for instructions that may throw exceptions.
switch (opcode)
{
case InstructionConstants.OP_GETSTATIC:
case InstructionConstants.OP_PUTSTATIC:
case InstructionConstants.OP_GETFIELD:
case InstructionConstants.OP_PUTFIELD:
case InstructionConstants.OP_INVOKEVIRTUAL:
case InstructionConstants.OP_INVOKESPECIAL:
case InstructionConstants.OP_INVOKESTATIC:
case InstructionConstants.OP_INVOKEINTERFACE:
case InstructionConstants.OP_NEW:
case InstructionConstants.OP_ANEWARRAY:
case InstructionConstants.OP_CHECKCAST:
case InstructionConstants.OP_MULTIANEWARRAY:
// These instructions may throw exceptions.
mayThrowExceptions = true;
}
// case InstructionConstants.OP_INVOKEVIRTUAL:
// case InstructionConstants.OP_INVOKESPECIAL:
// case InstructionConstants.OP_INVOKESTATIC:
// case InstructionConstants.OP_INVOKEINTERFACE:
// // Check if the invoking the method may throw an exception.
// clazz.constantPoolEntryAccept(constantInstruction.constantIndex, this);
}
// // Implementations for ConstantVisitor.
//
// public void visitAnyMethodrefConstant(Clazz clazz, RefConstant refConstant)
// {
// Member referencedMember = refConstant.referencedMember;
//
// // Do we have a reference to the method?
// if (referencedMember == null)
// {
// // We'll have to assume invoking the unknown method may throw an
// // an exception.
// mayThrowExceptions = true;
// }
// else
// {
// // First check the referenced method itself.
// refConstant.referencedMemberAccept(this);
//
// // If the result isn't conclusive, check down the hierarchy.
// if (!mayThrowExceptions)
// {
// Clazz referencedClass = refConstant.referencedClass;
// Method referencedMethod = (Method)referencedMember;
//
// // Check all other implementations of the method in the class
// // hierarchy.
// referencedClass.methodImplementationsAccept(referencedMethod,
// false,
// false,
// true,
// true,
// this);
// }
// }
// }
//
//
// // Implementations for MemberVisitor.
//
// public void visitProgramMethod(ProgramClass programClass, ProgramMethod programMethod)
// {
// mayThrowExceptions = mayThrowExceptions ||
// ExceptionMethodMarker.mayThrowExceptions(programMethod);
// }
//
//
// public void visitLibraryMethod(LibraryClass libraryClass, LibraryMethod libraryMethod)
// {
// mayThrowExceptions = mayThrowExceptions ||
// !NoExceptionMethodMarker.doesntThrowExceptions(libraryMethod);
// }
}