git-svn-id: https://svn.code.sf.net/p/jode/code/trunk@78 379699f6-c40d-0410-875b-85095c16579estable
jochen
26 years ago
parent
e2b966818c
commit
dff23235cc
@ -0,0 +1,812 @@ |
|||||||
|
/* TransformExceptionHandlers Copyright (C) 1997-1998 Jochen Hoenicke. |
||||||
|
* |
||||||
|
* 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, 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; see the file COPYING. If not, write to |
||||||
|
* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. |
||||||
|
* |
||||||
|
* $Id$ |
||||||
|
*/ |
||||||
|
package jode.flow; |
||||||
|
import jode.AssertError; |
||||||
|
import jode.Type; |
||||||
|
import jode.LocalInfo; |
||||||
|
import jode.ComplexExpression; |
||||||
|
import jode.LocalStoreOperator; |
||||||
|
import jode.NopOperator; |
||||||
|
import jode.MonitorExitOperator; |
||||||
|
import jode.LocalLoadOperator; |
||||||
|
import jode.Expression; |
||||||
|
import jode.PopOperator; |
||||||
|
import java.util.Enumeration; |
||||||
|
import java.util.Stack; |
||||||
|
|
||||||
|
/** |
||||||
|
* |
||||||
|
* @author Jochen Hoenicke |
||||||
|
*/ |
||||||
|
public class TransformExceptionHandlers { |
||||||
|
FlowBlock[] flows; |
||||||
|
int count; |
||||||
|
int[] startPCs = new int[4]; |
||||||
|
int[] endPCs = new int[4]; |
||||||
|
int[] handlerPCs = new int[4]; |
||||||
|
Type[] types = new Type[4]; |
||||||
|
|
||||||
|
public TransformExceptionHandlers(FlowBlock[] flowBlocks) { |
||||||
|
flows = flowBlocks; |
||||||
|
count = 0; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Add an exception Handler. |
||||||
|
* @param start The start address of the exception range. |
||||||
|
* @param end The end address of the exception range + 1. |
||||||
|
* @param handler The address of the handler. |
||||||
|
* @param type The type of the exception, null for ALL. |
||||||
|
*/ |
||||||
|
public void addHandler(int start, int end, int handler, Type type) { |
||||||
|
int offset = 0; |
||||||
|
/* First sort by start offsets, highest address first...*/ |
||||||
|
while (offset < count && start < startPCs[offset]) |
||||||
|
offset++; |
||||||
|
/* ...Second sort by end offsets, lowest address first... |
||||||
|
* this will move the innermost blocks to the beginning. */ |
||||||
|
while (offset < count && start == startPCs[offset] |
||||||
|
&& end > endPCs[offset]) |
||||||
|
offset++; |
||||||
|
/* ...Last sort by handler offsets, lowest first */ |
||||||
|
while (offset < count && start == startPCs[offset] |
||||||
|
&& end == endPCs[offset] && handler > handlerPCs[offset]) |
||||||
|
offset++; |
||||||
|
|
||||||
|
if (count++ >= startPCs.length) { |
||||||
|
/* We grow the arrays by 50 % */ |
||||||
|
int newSize = startPCs.length * 3 / 2; |
||||||
|
int[] newStartPCs = new int[newSize]; |
||||||
|
int[] newEndPCs = new int[newSize]; |
||||||
|
int[] newHandlerPCs = new int[newSize]; |
||||||
|
Type[] newTypes = new Type[newSize]; |
||||||
|
System.arraycopy(startPCs, 0, newStartPCs, 0, offset); |
||||||
|
System.arraycopy(endPCs, 0, newEndPCs, 0, offset); |
||||||
|
System.arraycopy(handlerPCs, 0, newHandlerPCs, 0, offset); |
||||||
|
System.arraycopy(types, 0, newTypes, 0, offset); |
||||||
|
|
||||||
|
if (offset+1 < count) { |
||||||
|
System.arraycopy(startPCs, offset, newStartPCs, offset+1, |
||||||
|
count-offset-1); |
||||||
|
System.arraycopy(endPCs, offset, newEndPCs, offset+1, |
||||||
|
count-offset-1); |
||||||
|
System.arraycopy(handlerPCs, offset, newHandlerPCs, offset+1, |
||||||
|
count-offset-1); |
||||||
|
System.arraycopy(types, offset, newTypes, offset+1, |
||||||
|
count-offset-1); |
||||||
|
} |
||||||
|
startPCs = newStartPCs; |
||||||
|
endPCs = newEndPCs; |
||||||
|
handlerPCs = newHandlerPCs; |
||||||
|
types = newTypes; |
||||||
|
} else if (offset+1 < count) { |
||||||
|
/* Move the tailing data one place below |
||||||
|
*/ |
||||||
|
System.arraycopy(startPCs, offset, startPCs, offset+1, |
||||||
|
count-offset-1); |
||||||
|
System.arraycopy(endPCs, offset, endPCs, offset+1, |
||||||
|
count-offset-1); |
||||||
|
System.arraycopy(handlerPCs, offset, handlerPCs, offset+1, |
||||||
|
count-offset-1); |
||||||
|
System.arraycopy(types, offset, types, offset+1, |
||||||
|
count-offset-1); |
||||||
|
} |
||||||
|
/* Insert the new handler */ |
||||||
|
startPCs[offset] = start; |
||||||
|
endPCs[offset] = end; |
||||||
|
handlerPCs[offset] = handler; |
||||||
|
types[offset] = type; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Updates the in/out-Vectors of the structured block of the |
||||||
|
* successing flow block for a try catch block. The main difference |
||||||
|
* to updateInOut in FlowBlock is, that this function works, as if |
||||||
|
* every instruction would have a jump. This is because every |
||||||
|
* instruction can throw an exception and thus enter the catch block. |
||||||
|
* |
||||||
|
* @param successor The flow block which is unified with this flow |
||||||
|
* block. |
||||||
|
* @return The variables that must be defined in this block. |
||||||
|
*/ |
||||||
|
static void updateInOutCatch (FlowBlock tryFlow, FlowBlock catchFlow) { |
||||||
|
VariableSet gens = ((TryBlock)tryFlow.block).gen; |
||||||
|
|
||||||
|
/* Merge the locals used in the catch block with those written |
||||||
|
* by the try block |
||||||
|
*/ |
||||||
|
catchFlow.in.merge(gens); |
||||||
|
|
||||||
|
/* The gen/kill sets must be updated for every jump |
||||||
|
* in the catch block */ |
||||||
|
Enumeration stacks = catchFlow.successors.elements(); |
||||||
|
while (stacks.hasMoreElements()) { |
||||||
|
Enumeration enum = ((Stack) stacks.nextElement()).elements(); |
||||||
|
while (enum.hasMoreElements()) { |
||||||
|
|
||||||
|
Jump jump = (Jump) enum.nextElement(); |
||||||
|
if (jump != null) { |
||||||
|
jump.gen.mergeGenKill(gens, jump.kill); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
tryFlow.in.unionExact(catchFlow.in); |
||||||
|
tryFlow.gen.unionExact(catchFlow.gen); |
||||||
|
|
||||||
|
if (jode.Decompiler.debugInOut) { |
||||||
|
System.err.println("UpdateInOutCatch: gens : "+gens); |
||||||
|
System.err.println(" s.in : "+catchFlow.in); |
||||||
|
System.err.println(" in : "+tryFlow.in); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
/* simple try catch block: |
||||||
|
* |
||||||
|
* try-header |
||||||
|
* |- first instruction |
||||||
|
* | ... |
||||||
|
* | last instruction |
||||||
|
* |- optional jump (last+1) |
||||||
|
* | ... |
||||||
|
* `- catch block |
||||||
|
*/ |
||||||
|
static int serialno=0; |
||||||
|
|
||||||
|
static void analyzeCatchBlock(Type type, |
||||||
|
FlowBlock tryFlow, FlowBlock catchFlow) { |
||||||
|
|
||||||
|
StructuredBlock catchBlock = catchFlow.block; |
||||||
|
LocalInfo local = null; |
||||||
|
StructuredBlock firstInstr = (catchBlock instanceof SequentialBlock) |
||||||
|
? catchBlock.getSubBlocks()[0] : catchBlock; |
||||||
|
|
||||||
|
if (firstInstr instanceof InstructionBlock) { |
||||||
|
Expression instr = |
||||||
|
((InstructionBlock) firstInstr).getInstruction(); |
||||||
|
if (instr instanceof PopOperator |
||||||
|
&& ((PopOperator) instr).getCount() == 1) { |
||||||
|
/* The exception is ignored. Create a dummy local for it */ |
||||||
|
local = new LocalInfo(-1); |
||||||
|
local.setName("exception_"+(serialno++)+"_"); |
||||||
|
firstInstr.removeBlock(); |
||||||
|
|
||||||
|
} else if (instr instanceof jode.LocalStoreOperator) { |
||||||
|
/* The exception is stored in a local variable */ |
||||||
|
local = |
||||||
|
((jode.LocalStoreOperator) instr).getLocalInfo(); |
||||||
|
firstInstr.removeBlock(); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
if (local == null) { |
||||||
|
local = new LocalInfo(-1); |
||||||
|
local.setName("ERROR!!!"); |
||||||
|
} |
||||||
|
local.setType(type); |
||||||
|
|
||||||
|
CatchBlock newBlock = new CatchBlock(type, local); |
||||||
|
((TryBlock)tryFlow.block).addCatchBlock(newBlock); |
||||||
|
newBlock.setCatchBlock(catchFlow.block); |
||||||
|
tryFlow.mergeSuccessors(catchFlow); |
||||||
|
tryFlow.length += catchFlow.length; |
||||||
|
} |
||||||
|
|
||||||
|
/* And now the complicated parts. */ |
||||||
|
|
||||||
|
/** |
||||||
|
* This transforms a sub routine, that is checks if the beginning |
||||||
|
* local assignment matches the final ret and then returns. |
||||||
|
*/ |
||||||
|
boolean transformSubRoutine(FlowBlock subRoutine) { |
||||||
|
try { |
||||||
|
SequentialBlock sequBlock = (SequentialBlock) subRoutine.block; |
||||||
|
LocalStoreOperator store = (LocalStoreOperator) |
||||||
|
((InstructionBlock)sequBlock.subBlocks[0]).instr.getOperator(); |
||||||
|
while (sequBlock.subBlocks[1] instanceof SequentialBlock) |
||||||
|
sequBlock = (SequentialBlock) sequBlock.subBlocks[1]; |
||||||
|
RetBlock retBlock = (RetBlock)sequBlock.subBlocks[1]; |
||||||
|
if (! retBlock.local.equals(store.getLocalInfo())) |
||||||
|
/* Ret doesn't match */ |
||||||
|
return false; |
||||||
|
subRoutine.block.getSubBlocks()[0].removeBlock(); |
||||||
|
retBlock.removeBlock(); |
||||||
|
return true; |
||||||
|
} catch (ClassCastException ex) { |
||||||
|
return false; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Remove the JSR's jumping to the specified subRoutine. It |
||||||
|
* is checked if the next block is a leaving instruction, and |
||||||
|
* otherwise the JsrBlock is not removed (to give the user a |
||||||
|
* hint that something went wrong). This will also remove the |
||||||
|
* local javac generates for returns. |
||||||
|
* @param tryFlow the FlowBLock of the try block. |
||||||
|
* @param subRoutine the FlowBlock of the sub routine. |
||||||
|
*/ |
||||||
|
private void removeJSR(FlowBlock tryFlow, FlowBlock subRoutine) { |
||||||
|
Stack jumps = (Stack)tryFlow.successors.remove(subRoutine); |
||||||
|
if (jumps == null) |
||||||
|
return; |
||||||
|
Enumeration enum = jumps.elements(); |
||||||
|
while (enum.hasMoreElements()) { |
||||||
|
Jump jump = (Jump)enum.nextElement(); |
||||||
|
|
||||||
|
StructuredBlock prev = jump.prev; |
||||||
|
prev.removeJump(); |
||||||
|
if (prev instanceof EmptyBlock |
||||||
|
&& prev.outer instanceof JsrBlock) { |
||||||
|
if (prev.outer.getNextFlowBlock() != null) { |
||||||
|
/* The jsr is directly before a jump, okay. */ |
||||||
|
prev.outer.removeBlock(); |
||||||
|
continue; |
||||||
|
} |
||||||
|
if (prev.outer.outer instanceof SequentialBlock |
||||||
|
&& prev.outer.outer.getSubBlocks()[0] == prev.outer) { |
||||||
|
SequentialBlock seq = (SequentialBlock) prev.outer.outer; |
||||||
|
if (seq.subBlocks[1] instanceof JsrBlock) { |
||||||
|
/* The jsr is followed by a jsr, okay. */ |
||||||
|
prev.outer.removeBlock(); |
||||||
|
continue; |
||||||
|
} |
||||||
|
if (seq.subBlocks[1] instanceof ReturnBlock |
||||||
|
&& !(seq.subBlocks[1] instanceof ThrowBlock)) { |
||||||
|
|
||||||
|
/* The jsr is followed by a return, okay. */ |
||||||
|
ReturnBlock ret = (ReturnBlock) seq.subBlocks[1]; |
||||||
|
prev.outer.removeBlock(); |
||||||
|
|
||||||
|
if (ret.outer != null |
||||||
|
&& ret.outer instanceof SequentialBlock) { |
||||||
|
/* Try to eliminate the local that javac uses |
||||||
|
* in this case. |
||||||
|
*/ |
||||||
|
try { |
||||||
|
ComplexExpression expr = (ComplexExpression) |
||||||
|
((InstructionBlock) |
||||||
|
ret.outer.getSubBlocks()[0]).instr; |
||||||
|
LocalStoreOperator store = |
||||||
|
(LocalStoreOperator) expr.getOperator(); |
||||||
|
if (store.matches((LocalLoadOperator) |
||||||
|
ret.getInstruction())) { |
||||||
|
ret.setInstruction(expr. |
||||||
|
getSubExpressions()[0]); |
||||||
|
ret.replace(ret.outer); |
||||||
|
ret.used.removeElement |
||||||
|
(store.getLocalInfo()); |
||||||
|
} |
||||||
|
} catch(ClassCastException ex) { |
||||||
|
/* didn't succeed */ |
||||||
|
} |
||||||
|
} |
||||||
|
continue; |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
/* Now we have a dangling JSR at the wrong place. |
||||||
|
* We don't do anything, so that JSR will show up in |
||||||
|
* the output. |
||||||
|
*/ |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
public void checkAndRemoveJSR(FlowBlock tryFlow, FlowBlock subRoutine) { |
||||||
|
Enumeration keys = tryFlow.successors.keys(); |
||||||
|
Enumeration stacks = tryFlow.successors.elements(); |
||||||
|
while (keys.hasMoreElements()) { |
||||||
|
Stack jumps = (Stack) stacks.nextElement(); |
||||||
|
if (keys.nextElement() == subRoutine) |
||||||
|
continue; |
||||||
|
|
||||||
|
Enumeration enum = jumps.elements(); |
||||||
|
while (enum.hasMoreElements()) { |
||||||
|
Jump jump = (Jump)enum.nextElement(); |
||||||
|
|
||||||
|
StructuredBlock prev = jump.prev; |
||||||
|
if (prev instanceof ThrowBlock) { |
||||||
|
/* The jump is a throw. We have a catch-all block |
||||||
|
* that will do the finally. |
||||||
|
*/ |
||||||
|
continue; |
||||||
|
} |
||||||
|
if (prev instanceof JsrBlock) { |
||||||
|
/* The jump is directly preceeded by a jsr. |
||||||
|
* Everything okay. |
||||||
|
*/ |
||||||
|
continue; |
||||||
|
} |
||||||
|
|
||||||
|
if (prev instanceof EmptyBlock |
||||||
|
&& prev.outer instanceof JsrBlock) { |
||||||
|
/* If jump is a jsr check the outer |
||||||
|
* block instead. |
||||||
|
*/ |
||||||
|
prev = prev.outer; |
||||||
|
} |
||||||
|
if ((prev instanceof ReturnBlock |
||||||
|
|| prev instanceof JsrBlock) |
||||||
|
&& prev.outer instanceof SequentialBlock) { |
||||||
|
SequentialBlock seq = (SequentialBlock) prev.outer; |
||||||
|
if (seq.subBlocks[1] == prev |
||||||
|
&& (seq.subBlocks[0] instanceof JsrBlock)) { |
||||||
|
/* The jump is preceeded by another jsr, okay. |
||||||
|
*/ |
||||||
|
continue; |
||||||
|
} |
||||||
|
if (seq.subBlocks[0] == prev |
||||||
|
&& seq.outer instanceof SequentialBlock |
||||||
|
&& (seq.outer.getSubBlocks()[0] instanceof JsrBlock)) { |
||||||
|
/* Again the jump is preceeded by another jsr, okay. |
||||||
|
*/ |
||||||
|
continue; |
||||||
|
} |
||||||
|
} |
||||||
|
/* Now we have a jump with a wrong destination. |
||||||
|
* Complain! |
||||||
|
*/ |
||||||
|
System.err.println("non well formed try-finally block"); |
||||||
|
} |
||||||
|
} |
||||||
|
removeJSR(tryFlow, subRoutine); |
||||||
|
} |
||||||
|
|
||||||
|
static boolean isMonitorExit(Expression instr, LocalInfo local) { |
||||||
|
if (instr instanceof ComplexExpression) { |
||||||
|
ComplexExpression expr = (ComplexExpression)instr; |
||||||
|
if (expr.getOperator() instanceof MonitorExitOperator |
||||||
|
&& expr.getSubExpressions()[0] instanceof LocalLoadOperator |
||||||
|
&& (((LocalLoadOperator) expr.getSubExpressions()[0]) |
||||||
|
.getLocalInfo().getSlot() == local.getSlot())) { |
||||||
|
return true; |
||||||
|
} |
||||||
|
} |
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
public void checkAndRemoveMonitorExit(FlowBlock tryFlow, LocalInfo local, |
||||||
|
int startMonExit, int endMonExit) { |
||||||
|
FlowBlock subRoutine = null; |
||||||
|
Enumeration stacks = tryFlow.successors.elements(); |
||||||
|
dest_loop: |
||||||
|
while (stacks.hasMoreElements()) { |
||||||
|
Enumeration enum = ((Stack) stacks.nextElement()).elements(); |
||||||
|
while (enum.hasMoreElements()) { |
||||||
|
Jump jump = (Jump)enum.nextElement(); |
||||||
|
|
||||||
|
StructuredBlock prev = jump.prev; |
||||||
|
if (prev instanceof EmptyBlock |
||||||
|
&& prev.outer instanceof JsrBlock |
||||||
|
&& subRoutine == null) { |
||||||
|
|
||||||
|
subRoutine = jump.destination; |
||||||
|
subRoutine.analyze(startMonExit, endMonExit); |
||||||
|
transformSubRoutine(subRoutine); |
||||||
|
|
||||||
|
if (subRoutine.block instanceof InstructionBlock) { |
||||||
|
Expression instr = |
||||||
|
((InstructionBlock)subRoutine.block) |
||||||
|
.getInstruction(); |
||||||
|
if (isMonitorExit(instr, local)) { |
||||||
|
tryFlow.length += subRoutine.length; |
||||||
|
continue dest_loop; |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
if (prev instanceof ThrowBlock) { |
||||||
|
/* The jump is a throw. We have a catch all block |
||||||
|
* that will do the monitorexit. |
||||||
|
*/ |
||||||
|
continue; |
||||||
|
} |
||||||
|
if (prev instanceof JsrBlock) { |
||||||
|
/* The jump is directly preceeded by a jsr. |
||||||
|
*/ |
||||||
|
continue; |
||||||
|
} |
||||||
|
if (prev instanceof EmptyBlock |
||||||
|
&& prev.outer instanceof JsrBlock) { |
||||||
|
/* If jump is a jsr check the outer |
||||||
|
* block instead. |
||||||
|
*/ |
||||||
|
prev = prev.outer; |
||||||
|
} |
||||||
|
|
||||||
|
if ((prev instanceof JsrBlock |
||||||
|
|| prev instanceof ReturnBlock) |
||||||
|
&& prev.outer instanceof SequentialBlock) { |
||||||
|
SequentialBlock seq = (SequentialBlock) prev.outer; |
||||||
|
StructuredBlock pred = null; |
||||||
|
if (seq.subBlocks[1] == prev) |
||||||
|
pred = seq.subBlocks[0]; |
||||||
|
else if (seq.outer instanceof SequentialBlock) |
||||||
|
pred = seq.outer.getSubBlocks()[0]; |
||||||
|
|
||||||
|
if (pred != null) { |
||||||
|
if (pred instanceof JsrBlock || pred.jump != null) |
||||||
|
/* The jump is preceeded by another jump |
||||||
|
* or jsr and last in its block, okay. |
||||||
|
*/ |
||||||
|
continue; |
||||||
|
|
||||||
|
if (pred instanceof InstructionBlock) { |
||||||
|
Expression instr = |
||||||
|
((InstructionBlock)pred).getInstruction(); |
||||||
|
if (instr instanceof ComplexExpression |
||||||
|
&& ((ComplexExpression)instr) |
||||||
|
.getOperator() instanceof MonitorExitOperator |
||||||
|
&& ((ComplexExpression)instr) |
||||||
|
.getSubExpressions()[0] |
||||||
|
instanceof LocalLoadOperator |
||||||
|
&& (((LocalLoadOperator) |
||||||
|
((ComplexExpression)instr) |
||||||
|
.getSubExpressions()[0]).getLocalInfo() |
||||||
|
.getSlot() == local.getSlot())) |
||||||
|
continue; |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
if (prev instanceof InstructionBlock |
||||||
|
&& isMonitorExit(((InstructionBlock)prev).instr, local)) { |
||||||
|
/* This is probably the last expression in the |
||||||
|
* synchronized block, and has the right monitor exit |
||||||
|
* attached. Remove this block. |
||||||
|
*/ |
||||||
|
prev.removeBlock(); |
||||||
|
continue; |
||||||
|
} |
||||||
|
|
||||||
|
/* Now we have a jump that is not preceded by a monitorexit. |
||||||
|
* Complain! |
||||||
|
*/ |
||||||
|
System.err.println("non well formed synchronized block"); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
if (subRoutine != null) |
||||||
|
removeJSR(tryFlow, subRoutine); |
||||||
|
} |
||||||
|
|
||||||
|
private boolean analyzeSynchronized(FlowBlock tryFlow, |
||||||
|
FlowBlock catchFlow, |
||||||
|
int endHandler) { |
||||||
|
if (!(catchFlow.block instanceof SequentialBlock |
||||||
|
&& catchFlow.block.getSubBlocks()[0] |
||||||
|
instanceof InstructionBlock)) |
||||||
|
return false; |
||||||
|
|
||||||
|
SequentialBlock catchBlock = (SequentialBlock) catchFlow.block; |
||||||
|
Expression instr = |
||||||
|
((InstructionBlock)catchBlock.subBlocks[0]).getInstruction(); |
||||||
|
|
||||||
|
if (instr instanceof ComplexExpression |
||||||
|
&& ((ComplexExpression)instr).getOperator() |
||||||
|
instanceof MonitorExitOperator |
||||||
|
&& ((ComplexExpression)instr).getSubExpressions()[0] |
||||||
|
instanceof LocalLoadOperator |
||||||
|
&& catchBlock.subBlocks[1] instanceof ThrowBlock |
||||||
|
&& ((ThrowBlock)catchBlock.subBlocks[1]).instr |
||||||
|
instanceof NopOperator) { |
||||||
|
|
||||||
|
/* This is a synchronized block: |
||||||
|
* |
||||||
|
* local_x = monitor object; // later
|
||||||
|
* monitorenter local_x // later
|
||||||
|
* tryFlow: |
||||||
|
* |- syncronized block |
||||||
|
* | ... |
||||||
|
* | every jump to outside is preceded by jsr subroutine-, |
||||||
|
* | ... | |
||||||
|
* |- monitorexit local_x | |
||||||
|
* ` jump after this block (without jsr monexit) | |
||||||
|
* | |
||||||
|
* catchFlow: | |
||||||
|
* local_n = stack | |
||||||
|
* monitorexit local_x | |
||||||
|
* throw local_n | |
||||||
|
* oprtional subroutine: <----------------------------------' |
||||||
|
* astore_n |
||||||
|
* monitorexit local_x |
||||||
|
* return_n |
||||||
|
*/ |
||||||
|
|
||||||
|
/* Now remove the jump (after the throw) from the |
||||||
|
* catch block so that we can forget about it. |
||||||
|
*/ |
||||||
|
|
||||||
|
catchBlock.subBlocks[1] |
||||||
|
.jump.destination.predecessors.removeElement(catchFlow); |
||||||
|
|
||||||
|
ComplexExpression monexit = (ComplexExpression) |
||||||
|
((InstructionBlock) catchBlock.subBlocks[0]).instr; |
||||||
|
LocalInfo local = |
||||||
|
((LocalLoadOperator)monexit.getSubExpressions()[0]) |
||||||
|
.getLocalInfo(); |
||||||
|
tryFlow.length += catchFlow.length; |
||||||
|
|
||||||
|
checkAndRemoveMonitorExit |
||||||
|
(tryFlow, local, catchFlow.addr+catchFlow.length, endHandler); |
||||||
|
|
||||||
|
SynchronizedBlock syncBlock = new SynchronizedBlock(local); |
||||||
|
TryBlock tryBlock = (TryBlock) tryFlow.block; |
||||||
|
syncBlock.replace(tryBlock); |
||||||
|
syncBlock.moveJump(tryBlock.jump); |
||||||
|
syncBlock.setBodyBlock(tryBlock.subBlocks.length == 1 |
||||||
|
? tryBlock.subBlocks[0] : tryBlock); |
||||||
|
tryFlow.lastModified = syncBlock; |
||||||
|
return true; |
||||||
|
} |
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
private boolean analyzeFinally(FlowBlock tryFlow, FlowBlock catchFlow, |
||||||
|
int end) { |
||||||
|
if (!(catchFlow.block instanceof SequentialBlock |
||||||
|
&& catchFlow.block.getSubBlocks()[0] |
||||||
|
instanceof InstructionBlock)) |
||||||
|
return false; |
||||||
|
|
||||||
|
SequentialBlock catchBlock = (SequentialBlock) catchFlow.block; |
||||||
|
Expression instr = |
||||||
|
((InstructionBlock)catchBlock.subBlocks[0]).getInstruction(); |
||||||
|
|
||||||
|
if (catchBlock.subBlocks[1] instanceof SequentialBlock |
||||||
|
&& catchBlock.subBlocks[1].getSubBlocks()[0] |
||||||
|
instanceof JsrBlock |
||||||
|
&& instr instanceof LocalStoreOperator |
||||||
|
&& catchBlock.subBlocks[1].getSubBlocks()[1] |
||||||
|
instanceof ThrowBlock |
||||||
|
&& ((ThrowBlock)catchBlock.subBlocks[1] |
||||||
|
.getSubBlocks()[1]).instr |
||||||
|
instanceof LocalLoadOperator |
||||||
|
&& ((LocalStoreOperator) instr) |
||||||
|
.matches((LocalLoadOperator) |
||||||
|
((ThrowBlock)catchBlock.subBlocks[1] |
||||||
|
.getSubBlocks()[1]).instr)) { |
||||||
|
|
||||||
|
/* Wow that was complicated :-) |
||||||
|
* But now we know that the catch block looks |
||||||
|
* exactly like an try finally block: |
||||||
|
* |
||||||
|
* tryFlow: |
||||||
|
* |- first instruction |
||||||
|
* | ... |
||||||
|
* | every jump to outside is preceded by jsr finally |
||||||
|
* | ... |
||||||
|
* | jsr finally -----------------, |
||||||
|
* `- jump after finally | |
||||||
|
* | |
||||||
|
* catchFlow: (already checked) | |
||||||
|
* local_n = stack v |
||||||
|
* jsr finally ---------------->| |
||||||
|
* throw local_n; | |
||||||
|
* finally: <-----------------------' |
||||||
|
* astore_n |
||||||
|
* ... |
||||||
|
* return_n |
||||||
|
*/ |
||||||
|
|
||||||
|
FlowBlock subRoutine = |
||||||
|
((JsrBlock)catchBlock.subBlocks[1].getSubBlocks()[0]) |
||||||
|
.innerBlock.jump.destination; |
||||||
|
|
||||||
|
/* Now remove the two jumps of the catch block |
||||||
|
* so that we can forget about them. |
||||||
|
* This are the jsr and the throw. |
||||||
|
*/ |
||||||
|
catchBlock.subBlocks[1].getSubBlocks()[0].getSubBlocks()[0] |
||||||
|
.jump.destination.predecessors.removeElement(catchFlow); |
||||||
|
catchBlock.subBlocks[1].getSubBlocks()[1] |
||||||
|
.jump.destination.predecessors.removeElement(catchFlow); |
||||||
|
|
||||||
|
subRoutine.analyze(catchFlow.addr+catchFlow.length, end); |
||||||
|
if (!transformSubRoutine(subRoutine)) |
||||||
|
return false; |
||||||
|
Stack jumps = (Stack)tryFlow.successors.get(subRoutine); |
||||||
|
if (jumps != null) |
||||||
|
/* jumps may be null, if tryFlow ends with a throw */ |
||||||
|
tryFlow.updateInOut(subRoutine, true, jumps); |
||||||
|
|
||||||
|
tryFlow.length += catchFlow.length; |
||||||
|
checkAndRemoveJSR(tryFlow, subRoutine); |
||||||
|
|
||||||
|
TryBlock tryBlock = (TryBlock)tryFlow.block; |
||||||
|
if (tryBlock.getSubBlocks()[0] instanceof TryBlock) { |
||||||
|
/* remove the nested tryBlock */ |
||||||
|
TryBlock innerTry = (TryBlock)tryBlock.getSubBlocks()[0]; |
||||||
|
innerTry.gen = tryBlock.gen; |
||||||
|
innerTry.replace(tryBlock); |
||||||
|
tryBlock = innerTry; |
||||||
|
tryFlow.lastModified = innerTry; |
||||||
|
} |
||||||
|
FinallyBlock newBlock = new FinallyBlock(); |
||||||
|
newBlock.setCatchBlock(subRoutine.block); |
||||||
|
tryBlock.addCatchBlock(newBlock); |
||||||
|
tryFlow.mergeSuccessors(subRoutine); |
||||||
|
tryFlow.length += subRoutine.length; |
||||||
|
return true; |
||||||
|
} |
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
private boolean analyzeSpecialFinally(FlowBlock tryFlow, |
||||||
|
FlowBlock catchFlow, int end) { |
||||||
|
|
||||||
|
StructuredBlock firstInstr = |
||||||
|
catchFlow.block instanceof SequentialBlock |
||||||
|
? catchFlow.block.getSubBlocks()[0]: catchFlow.block; |
||||||
|
|
||||||
|
if (firstInstr instanceof InstructionBlock |
||||||
|
&& ((InstructionBlock) firstInstr).getInstruction() |
||||||
|
instanceof PopOperator |
||||||
|
&& ((PopOperator) ((InstructionBlock) firstInstr) |
||||||
|
.getInstruction()).getCount() == 1) { |
||||||
|
|
||||||
|
/* This is a special try/finally-block, where |
||||||
|
* the finally block ends with a break, return or |
||||||
|
* similar. |
||||||
|
*/ |
||||||
|
|
||||||
|
FlowBlock succ = (firstInstr.jump != null) ? |
||||||
|
firstInstr.jump.destination : null; |
||||||
|
boolean hasExit = false; |
||||||
|
Enumeration keys = tryFlow.successors.keys(); |
||||||
|
while (keys.hasMoreElements()) { |
||||||
|
Object key = keys.nextElement(); |
||||||
|
if (key == succ) |
||||||
|
continue; |
||||||
|
if (key != tryFlow.END_OF_METHOD) { |
||||||
|
/* There is another exit in the try block, bad */ |
||||||
|
return false; |
||||||
|
} |
||||||
|
Enumeration enum = |
||||||
|
((Stack)tryFlow.successors.get(key)).elements(); |
||||||
|
while (enum.hasMoreElements()) { |
||||||
|
Jump throwJump= (Jump)enum.nextElement(); |
||||||
|
if (!(throwJump.prev instanceof ThrowBlock)) { |
||||||
|
/* There is a return exit in the try block */ |
||||||
|
return false; |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/* remove the pop now */ |
||||||
|
firstInstr.removeBlock(); |
||||||
|
|
||||||
|
if (succ != null) { |
||||||
|
Stack jumps = (Stack) tryFlow.successors.remove(succ); |
||||||
|
succ.predecessors.removeElement(tryFlow); |
||||||
|
/* Handle the jumps in the tryFlow. |
||||||
|
*/ |
||||||
|
tryFlow.updateInOut(succ, true, jumps); |
||||||
|
tryFlow.optimizeJumps(jumps, succ); |
||||||
|
tryFlow.resolveRemaining(jumps); |
||||||
|
} |
||||||
|
|
||||||
|
tryFlow.length += catchFlow.length; |
||||||
|
|
||||||
|
TryBlock tryBlock = (TryBlock)tryFlow.block; |
||||||
|
if (tryBlock.getSubBlocks()[0] instanceof TryBlock) { |
||||||
|
/* remove the unnecessary tryBlock */ |
||||||
|
TryBlock innerTry = (TryBlock)tryBlock.getSubBlocks()[0]; |
||||||
|
innerTry.gen = tryBlock.gen; |
||||||
|
innerTry.replace(tryBlock); |
||||||
|
tryBlock = innerTry; |
||||||
|
tryFlow.lastModified = innerTry; |
||||||
|
} |
||||||
|
FinallyBlock newBlock = new FinallyBlock(); |
||||||
|
tryBlock.addCatchBlock(newBlock); |
||||||
|
/* try block has no successors */ |
||||||
|
|
||||||
|
if (succ != null && succ.predecessors.size() == 1) { |
||||||
|
while (succ.analyze(catchFlow.addr+catchFlow.length, end)); |
||||||
|
tryFlow.length += succ.length; |
||||||
|
tryFlow.successors.remove(succ); |
||||||
|
newBlock.setCatchBlock(succ.block); |
||||||
|
tryFlow.mergeSuccessors(succ); |
||||||
|
} else { |
||||||
|
/* Put the catchBlock in instaed. |
||||||
|
*/ |
||||||
|
newBlock.setCatchBlock(catchFlow.block); |
||||||
|
tryFlow.mergeSuccessors(catchFlow); |
||||||
|
} |
||||||
|
return true; |
||||||
|
} |
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Analyzes all exception handlers to try/catch/finally or |
||||||
|
* synchronized blocks. |
||||||
|
*/ |
||||||
|
public void analyze() { |
||||||
|
/* Check if try/catch ranges are okay. The following succeeds |
||||||
|
* for all classes generated by the sun java compiler, but hand |
||||||
|
* optimized classes will fail this. |
||||||
|
*/ |
||||||
|
for (int i=0; i<count; i++) { |
||||||
|
int start = startPCs[i]; |
||||||
|
int end = endPCs[i]; |
||||||
|
int handler = handlerPCs[i]; |
||||||
|
if (start >= end || handler < end) |
||||||
|
throw new AssertError("ExceptionHandler order failed: not " |
||||||
|
+ start + " < " + end + " <= " + |
||||||
|
handler); |
||||||
|
if (i == 0 |
||||||
|
|| startPCs[i-1] != start || endPCs[i-1] != end) { |
||||||
|
/* The last handler does catch another range. */ |
||||||
|
if ( /*handler > end + 1 || */ |
||||||
|
(i > 0 && end > startPCs[i-1] && end < endPCs[i-1])) |
||||||
|
throw new AssertError("ExceptionHandler" |
||||||
|
+ " at wrong position: " |
||||||
|
+ "end: "+end + " handler: "+handler |
||||||
|
+ (i>0 ? " last: ("+startPCs[i-1] |
||||||
|
+", "+endPCs[i-1]+", " |
||||||
|
+handlerPCs[i-1]+")" |
||||||
|
:"")); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
for (int i=0; i<count; i++) { |
||||||
|
int endHandler = (i< count-1 && endPCs[i+1] > handlerPCs[i]) |
||||||
|
? endPCs[i+1] |
||||||
|
: Integer.MAX_VALUE; |
||||||
|
if (jode.Decompiler.debugAnalyze) |
||||||
|
System.err.println("analyzeCatch(" + startPCs[i] + ", " |
||||||
|
+ endPCs[i] + ", " +handlerPCs[i] + ")"); |
||||||
|
FlowBlock tryFlow = flows[startPCs[i]]; |
||||||
|
while (tryFlow.analyze(startPCs[i], handlerPCs[i])); |
||||||
|
|
||||||
|
if (i == 0 |
||||||
|
|| startPCs[i-1] != startPCs[i] || endPCs[i-1] != endPCs[i]) { |
||||||
|
/* The last handler does catch another range. |
||||||
|
* Create a new try block. |
||||||
|
*/ |
||||||
|
TryBlock tryBlock = new TryBlock(tryFlow); |
||||||
|
} else if (! (tryFlow.block instanceof TryBlock)) |
||||||
|
throw new AssertError("no TryBlock"); |
||||||
|
|
||||||
|
FlowBlock catchFlow = flows[handlerPCs[i]]; |
||||||
|
while (catchFlow.analyze(handlerPCs[i], endHandler)); |
||||||
|
|
||||||
|
if (!catchFlow.predecessors.isEmpty()) |
||||||
|
throw new AssertError("Handler has a predecessors"); |
||||||
|
|
||||||
|
updateInOutCatch(tryFlow, catchFlow); |
||||||
|
if (types[i] != null) { |
||||||
|
analyzeCatchBlock(types[i], tryFlow, catchFlow); |
||||||
|
|
||||||
|
} else if (!analyzeSynchronized(tryFlow, catchFlow, endHandler) |
||||||
|
&& ! analyzeFinally(tryFlow, catchFlow, endHandler) |
||||||
|
&& ! analyzeSpecialFinally(tryFlow, catchFlow, |
||||||
|
endHandler)) |
||||||
|
|
||||||
|
analyzeCatchBlock(jode.Type.tObject, tryFlow, catchFlow); |
||||||
|
|
||||||
|
tryFlow.checkConsistent(); |
||||||
|
if (jode.Decompiler.debugAnalyze) |
||||||
|
System.err.println("analyzeCatch(" + tryFlow.addr + ", " |
||||||
|
+ (tryFlow.addr + tryFlow.length) + |
||||||
|
") done."); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,103 @@ |
|||||||
|
/* jode.flow.TryBlock (c) 1998 Jochen Hoenicke |
||||||
|
* |
||||||
|
* You may distribute under the terms of the GNU General Public License. |
||||||
|
* |
||||||
|
* IN NO EVENT SHALL JOCHEN HOENICKE BE LIABLE TO ANY PARTY FOR DIRECT, |
||||||
|
* INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF |
||||||
|
* THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF JOCHEN HOENICKE |
||||||
|
* HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||||
|
* |
||||||
|
* JOCHEN HOENICKE SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT |
||||||
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A |
||||||
|
* PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" |
||||||
|
* BASIS, AND JOCHEN HOENICKE HAS NO OBLIGATION TO PROVIDE MAINTENANCE, |
||||||
|
* SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. |
||||||
|
* |
||||||
|
* $Id$ |
||||||
|
*/ |
||||||
|
|
||||||
|
package jode.flow; |
||||||
|
import jode.TabbedPrintWriter; |
||||||
|
|
||||||
|
/** |
||||||
|
* A TryBlock is created for each exception in the |
||||||
|
* ExceptionHandlers-Attribute. <p> |
||||||
|
* |
||||||
|
* For each catch block (there may be more than one catch block |
||||||
|
* appending a single try block) and for each finally and each |
||||||
|
* synchronized block such a TryBlock is created. The |
||||||
|
* finally/synchronized-blocks have a null exception type so that they |
||||||
|
* are easily distinguishable from the catch blocks. <p> |
||||||
|
* |
||||||
|
* A TryBlock is an intermediate representation that gets |
||||||
|
* converted later to a CatchBlock, a FinallyBlock or a |
||||||
|
* SynchronizedBlock (after the body is parsed). |
||||||
|
* |
||||||
|
* @date 1998/09/16 |
||||||
|
* @author Jochen Hoenicke |
||||||
|
* @see CatchBlock |
||||||
|
* @see FinallyBlock |
||||||
|
* @see SynchronizedBlock |
||||||
|
*/ |
||||||
|
|
||||||
|
public class TryBlock extends StructuredBlock { |
||||||
|
|
||||||
|
VariableSet gen; |
||||||
|
StructuredBlock[] subBlocks = new StructuredBlock[1]; |
||||||
|
|
||||||
|
public TryBlock(FlowBlock tryFlow) { |
||||||
|
this.gen = (VariableSet) tryFlow.gen.clone(); |
||||||
|
this.flowBlock = tryFlow; |
||||||
|
|
||||||
|
StructuredBlock bodyBlock = tryFlow.block; |
||||||
|
replace(bodyBlock); |
||||||
|
this.subBlocks = new StructuredBlock[] { bodyBlock }; |
||||||
|
bodyBlock.outer = this; |
||||||
|
tryFlow.lastModified = this; |
||||||
|
} |
||||||
|
|
||||||
|
public void addCatchBlock(CatchBlock catchBlock) { |
||||||
|
StructuredBlock[] newSubBlocks = |
||||||
|
new StructuredBlock[subBlocks.length+1]; |
||||||
|
System.arraycopy(subBlocks, 0, newSubBlocks, 0, subBlocks.length); |
||||||
|
newSubBlocks[subBlocks.length] = catchBlock; |
||||||
|
subBlocks = newSubBlocks; |
||||||
|
catchBlock.outer = this; |
||||||
|
catchBlock.setFlowBlock(flowBlock); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Replaces the given sub block with a new block. |
||||||
|
* @param oldBlock the old sub block. |
||||||
|
* @param newBlock the new sub block. |
||||||
|
* @return false, if oldBlock wasn't a direct sub block. |
||||||
|
*/ |
||||||
|
public boolean replaceSubBlock(StructuredBlock oldBlock, |
||||||
|
StructuredBlock newBlock) { |
||||||
|
for (int i=0; i<subBlocks.length; i++) { |
||||||
|
if (subBlocks[i] == oldBlock) { |
||||||
|
subBlocks[i] = newBlock; |
||||||
|
return true; |
||||||
|
} |
||||||
|
} |
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Returns all sub block of this structured block. |
||||||
|
*/ |
||||||
|
public StructuredBlock[] getSubBlocks() { |
||||||
|
return subBlocks; |
||||||
|
} |
||||||
|
|
||||||
|
public void dumpInstruction(TabbedPrintWriter writer) |
||||||
|
throws java.io.IOException { |
||||||
|
writer.println("try {"); |
||||||
|
writer.tab(); |
||||||
|
subBlocks[0].dumpSource(writer); |
||||||
|
writer.untab(); |
||||||
|
for (int i=1; i<subBlocks.length;i++) |
||||||
|
subBlocks[i].dumpSource(writer); |
||||||
|
writer.println("}"); |
||||||
|
} |
||||||
|
} |
||||||
Loading…
Reference in new issue