How do I know the type of the exception being thrown at the bytecode level?

Question

An explicit call to the throw statement is represented at the bytecode level with an athrow instruction.

For instance, the code snippet below:

private static SQLException thrower() throws SQLException
{
    throw new SQLException();
}

Is translated into the following bytecode:

   private static java.sql.SQLException thrower()   throws java.sql.SQLException;
   Signature: ()Ljava/sql/SQLException;
   Code:
   0:   new #29; //class java/sql/SQLException
   3:   dup
   4:   invokespecial   #31; //Method java/sql/SQLException."<init>":()V
   7:   athrow

My question is: how do I know, by only analyzing the bytecode, the type of the exception being thrown?

Obs.: It is worth mentioning that it is not always the case that we instantiate a new exception type when we call the throw statement in the source code. Thus, looking the type of the argument of the new instruction is not a solution.

See: http://stackoverflow.com/questions/18413094/by-analyzing-the-bytecode-how-can-i-detect-explicit-throw-statement-invocations — sara, Sep 12 '13 at 17:10

score 2 · Answer 1 · answered Sep 12 '13 at 19:39

This is impossible, as a given instruction might throw more than one type of exception.

Consider the code

throw foo ? new ClassCastException() : new IOException();

In more complicated situations, you might be throwing something with a type determined at runtime, or even created from a class constructed at runtime.

score 0 · Answer 2 · answered Sep 12 '13 at 17:15

0

This question is too generic. So, here is generic answer.

You need to identify instruction or instructions that placed value to be consumed by athrow opcode and then walk the data flow up to the point where that value is created.

answered Sep 12 '13 at 17:15

Eugene Kuleshov

31,461
5
66
67

score 0 · Answer 3 · answered Sep 13 '13 at 17:14

It does not matter whether the exception instance comes from a new instruction or something else. All instructions are typed. So it might come from a field read, method invocation or passed as a parameter… in all cases it has a declared type. The only difference is that for new instruction you now that the declared type will match the runtime type exactly. In all other cases it could be a subclass of the declared type.

But you have to interpret the method and model the effect of the instructions on the local variables and the operand stack to find out which type the topmost stack entry has upon the athrow instruction.

How do I know the type of the exception being thrown at the bytecode level?

3 Answers3