@ -103,35 +103,62 @@ public class TransformExceptionHandlers {
handlers . add ( new Handler ( tryBlock , endBlock , catchBlock , type ) ) ; handlers . add ( new Handler ( tryBlock , endBlock , catchBlock , type ) ) ;
} }
/ * *
* Merge the try flow block with the catch flow block . This is a kind
* of special T2 transformation , as all jumps to the catch block are
* implicit ( exception can be thrown everywhere ) . < br >
*
* This method doesn ' t actually merge the contents of the blocks . The
* caller should do it right afterwards . < br >
*
* The flow block catchFlow mustn ' t have any predecessors .
* @param tryFlow the flow block containing the try .
* @param catchFlow the flow block containing the catch handler .
* /
static void mergeTryCatch ( FlowBlock tryFlow , FlowBlock catchFlow ) {
if ( ( GlobalOptions . debuggingFlags
& GlobalOptions . DEBUG_ANALYZE ) ! = 0 )
GlobalOptions . err . println
( "mergeTryCatch(" + tryFlow . getBlockNr ( )
+ ", " + catchFlow . getBlockNr ( ) + ")" ) ;
tryFlow . updateInOutCatch ( catchFlow ) ;
tryFlow . mergeSuccessors ( catchFlow ) ;
tryFlow . mergeBlockNr ( catchFlow ) ;
}
/ * simple try catch block : / * *
* Analyzes a simple try / catch block . The try and catch part are both
* analyzed , the try block is already created , but the catch block
* isn ' t . < br >
* The catchFlow block mustn ' t have any predecessors .
* *
* try - header * @param type The type of the exception which is caught .
* | - first instruction * @param tryFlow The flow block containing the try . The contained
* | . . . * block must be a try block .
* | last instruction * @param catchFlow the flow block containing the catch handler .
* | - optional jump ( last + 1 )
* | . . .
* ` - catch block
* / * /
static void analyzeCatchBlock ( Type type , FlowBlock tryFlow , static void analyzeCatchBlock ( Type type , FlowBlock tryFlow ,
StructuredBlock catchBlock ) { FlowBlock catchFlow ) {
/* Merge try and catch flow blocks */
mergeTryCatch ( tryFlow , catchFlow ) ;
/* Insert catch block into tryFlow */
CatchBlock newBlock = new CatchBlock ( type ) ; CatchBlock newBlock = new CatchBlock ( type ) ;
( ( TryBlock ) tryFlow . block ) . addCatchBlock ( newBlock ) ; ( ( TryBlock ) tryFlow . block ) . addCatchBlock ( newBlock ) ;
newBlock . setCatchBlock ( catchBlock ) ; newBlock . setCatchBlock ( catchFlow . block ) ;
tryFlow . lastModified = tryFlow . block ;
} }
/* And now the complicated parts. */
/ * * / * *
* This transforms a sub routine , that is checks if the beginning * This transforms a sub routine , i . e . it checks if the beginning
* local assignment matches the final ret and then returns . * local assignment matches the final ret and removes both . It also
* accepts sub routines that just pop their return address .
* / * /
boolean transformSubRoutine ( StructuredBlock subRoutine ) { boolean transformSubRoutine ( StructuredBlock subRoutineBlock ) {
if ( ! ( subRoutine instanceof SequentialBlock ) ) StructuredBlock firstBlock = subRoutineBlock ;
return false ; if ( firstBlock instanceof SequentialBlock )
SequentialBlock sequBlock = ( SequentialBlock ) subRoutine ; firstBlock = subRoutineBlock . getSubBlocks ( ) [ 0 ] ;
StructuredBlock firstBlock = sequBlock . getSubBlocks ( ) [ 0 ] ;
LocalInfo local = null ; LocalInfo local = null ;
if ( firstBlock instanceof SpecialBlock ) { if ( firstBlock instanceof SpecialBlock ) {
@ -156,24 +183,25 @@ public class TransformExceptionHandlers {
} else } else
return false ; return false ;
/ * We are now committed . Remove the first Statement which / * We are now committed and can start changing code . Remove
* stores / removes the return address . * the first Statement which stores / removes the return
* address .
* / * /
firstBlock . removeBlock ( ) ; firstBlock . removeBlock ( ) ;
/ * XXX - Replace any RET with a jump to end of this flow block . / * We don ' t check if there is a RET in the middle .
* *
* This is a complicated task which isn ' t needed for javac nor * This is a complicated task which isn ' t needed for javac nor
* jikes . We just check if the last instruction is a ret and * jikes . We just check if the last instruction is a ret and
* replac e this . This will never produce code with wrong semantic , * remov e this . This will never produce code with wrong semantic ,
* as long as the bytecode was verified correctly . * as long as the bytecode was verified correctly .
* / * /
while ( sequBlock . subBlocks [ 1 ] instanceof SequentialBlock ) while ( subRoutineBlock instanceof SequentialBlock )
seq uBlock = ( SequentialBlock ) sequBlock . subBlocks [ 1 ] ; subRoutine Block = subRoutineBlock . getSubBlocks ( ) [ 1 ] ;
if ( sequBlock . subBlocks [ 1 ] instanceof RetBlock if ( subRoutineBlock instanceof RetBlock
& & ( ( ( RetBlock ) sequBlock . subBlocks [ 1 ] ) . local . equals ( local ) ) ) { & & ( ( ( RetBlock ) subRoutineBlock ) . local . equals ( local ) ) ) {
sequBlock . subBlocks [ 1 ] . removeBlock ( ) ; subRoutineBlock . removeBlock ( ) ;
} }
return true ; return true ;
} }
@ -203,51 +231,32 @@ public class TransformExceptionHandlers {
} }
/ * * / * *
* Remove the wrongly placed JSRs jumping to the specified * Remove the JSRs jumping to the specified subRoutine . The right
* subRoutine . The right JSRs are already removed , but we have to * JSRs are marked and we can just remove them . For the other JSR
* replace the wrong ones with a warning . * instructions we replace them with a warning .
* @param tryFlow the FlowBL ock of the try block . * @param tryFlow the FlowBl ock of the try block .
* @param subRoutine the FlowBlock of the sub routine . * @param subRoutine the FlowBlock of the sub routine .
* / * /
private void removeJSR ( FlowBlock tryFlow , StructuredBlock catchBlock , private void removeJSR ( FlowBlock tryFlow , FlowBlock subRoutine ) {
FlowBlock subRoutine ) { for ( Jump jumps = tryFlow . removeJumps ( subRoutine ) ;
Jump nextJump ; jumps ! = null ; jumps = jumps . next ) {
for ( Jump jumps = tryFlow . getJumps ( subRoutine ) ;
jumps ! = null ; jumps = nextJump ) {
StructuredBlock prev = jumps . prev ; StructuredBlock prev = jumps . prev ;
nextJump = jumps . next ;
if ( prev instanceof EmptyBlock
& & prev . outer instanceof JsrBlock ) {
JsrBlock jsr = ( JsrBlock ) prev . outer ;
if ( prev . outer = = catchBlock ) {
/* This is the mandatory jsr in the catch block */
continue ;
}
tryFlow . removeSuccessor ( jumps ) ;
prev . removeJump ( ) ; prev . removeJump ( ) ;
if ( jsr . isGood ( ) ) {
StructuredBlock next = jsr . getNextBlock ( ) ; if ( prev instanceof EmptyBlock
jsr . removeBlock ( ) ; & & prev . outer instanceof JsrBlock
& & ( ( JsrBlock ) prev . outer ) . isGood ( ) ) {
StructuredBlock next = prev . outer . getNextBlock ( ) ;
prev . outer . removeBlock ( ) ;
if ( next instanceof ReturnBlock ) if ( next instanceof ReturnBlock )
removeReturnLocal ( ( ReturnBlock ) next ) ; removeReturnLocal ( ( ReturnBlock ) next ) ;
} else { } else {
/ * We have a JSR to the subroutine , which is badly placed . / * We have a jump to the subroutine , that is badly placed .
* We complain here .
* /
DescriptionBlock msg
= new DescriptionBlock ( "ERROR: JSR FINALLY BLOCK!" ) ;
msg . replace ( prev . outer ) ;
}
} else {
/ * We have a jump to the subroutine , that is wrong .
* We complain here . * We complain here .
* / * /
DescriptionBlock msg DescriptionBlock msg = new DescriptionBlock
= new DescriptionBlock ( "ERROR: GOTO FINALLY BLOCK!" ) ; ( "ERROR: invalid jump to finally block!" ) ;
tryFlow . removeSuccessor ( jumps ) ;
prev . removeJump ( ) ;
prev . appendBlock ( msg ) ; prev . appendBlock ( msg ) ;
} }
} }
@ -313,7 +322,6 @@ public class TransformExceptionHandlers {
private void checkAndRemoveJSR ( FlowBlock tryFlow , private void checkAndRemoveJSR ( FlowBlock tryFlow ,
StructuredBlock catchBlock ,
FlowBlock subRoutine , FlowBlock subRoutine ,
int startOutExit , int endOutExit ) { int startOutExit , int endOutExit ) {
Iterator iter = tryFlow . getSuccessors ( ) . iterator ( ) ; Iterator iter = tryFlow . getSuccessors ( ) . iterator ( ) ;
@ -330,8 +338,8 @@ public class TransformExceptionHandlers {
StructuredBlock prev = jumps . prev ; StructuredBlock prev = jumps . prev ;
if ( prev instanceof EmptyBlock if ( prev instanceof EmptyBlock
& & prev . outer instanceof JsrBlock ) { & & prev . outer instanceof JsrBlock ) {
/ * This jump is really a jsr , since it doesn ' t / * This jump is a jsr , since it doesn ' t leave the
* leave the block forever , we can ignore it . * block forever , we can ignore it .
* / * /
continue ; continue ;
} }
@ -382,7 +390,7 @@ public class TransformExceptionHandlers {
* Complain ! * Complain !
* / * /
DescriptionBlock msg DescriptionBlock msg
= new DescriptionBlock ( "ERROR: NO JSR TO FINALLY " ) ; = new DescriptionBlock ( "ERROR: no jsr to finally " ) ;
if ( pred ! = null ) if ( pred ! = null )
pred . prependBlock ( msg ) ; pred . prependBlock ( msg ) ;
else { else {
@ -392,11 +400,10 @@ public class TransformExceptionHandlers {
} }
} }
if ( tryFlow . getSuccessors ( ) . contains ( subRoutine ) ) if ( tryFlow . getSuccessors ( ) . contains ( subRoutine ) )
removeJSR ( tryFlow , catchBlock , subRoutine ) ; removeJSR ( tryFlow , subRoutine ) ;
} }
private void checkAndRemoveMonitorExit ( FlowBlock tryFlow , private void checkAndRemoveMonitorExit ( FlowBlock tryFlow ,
StructuredBlock catchBlock ,
LocalInfo local , LocalInfo local ,
int start , int end ) { int start , int end ) {
FlowBlock subRoutine = null ; FlowBlock subRoutine = null ;
@ -494,7 +501,7 @@ public class TransformExceptionHandlers {
/ * Complain ! / * Complain !
* / * /
DescriptionBlock msg DescriptionBlock msg
= new DescriptionBlock ( "ERROR: NO MONITOREXIT " ) ; = new DescriptionBlock ( "ERROR: no monitorexit " ) ;
prev . appendBlock ( msg ) ; prev . appendBlock ( msg ) ;
msg . moveJump ( jumps ) ; msg . moveJump ( jumps ) ;
} }
@ -502,7 +509,8 @@ public class TransformExceptionHandlers {
if ( subRoutine ! = null ) { if ( subRoutine ! = null ) {
if ( tryFlow . getSuccessors ( ) . contains ( subRoutine ) ) if ( tryFlow . getSuccessors ( ) . contains ( subRoutine ) )
removeJSR ( tryFlow , catchBlock , subRoutine ) ; removeJSR ( tryFlow , subRoutine ) ;
if ( subRoutine . predecessors . size ( ) = = 0 )
tryFlow . mergeBlockNr ( subRoutine ) ; tryFlow . mergeBlockNr ( subRoutine ) ;
} }
} }
@ -526,20 +534,25 @@ public class TransformExceptionHandlers {
} }
private boolean analyzeSynchronized ( FlowBlock tryFlow , private boolean analyzeSynchronized ( FlowBlock tryFlow ,
StructuredBlock catchBlock , FlowBlock catchFlow ,
int endHandler ) { int endHandler ) {
/ * Check if this is a synchronized block . We mustn ' t change
* anything until we are sure .
* /
StructuredBlock catchBlock = catchFlow . block ;
/* Check for a optional exception store and skip it */
StoreInstruction excStore = getExceptionStore ( catchBlock ) ; StoreInstruction excStore = getExceptionStore ( catchBlock ) ;
if ( excStore ! = null ) if ( excStore ! = null )
catchBlock = catchBlock . getSubBlocks ( ) [ 1 ] ; catchBlock = catchBlock . getSubBlocks ( ) [ 1 ] ;
/* Check for the monitorexit instruction */
if ( ! ( catchBlock instanceof SequentialBlock if ( ! ( catchBlock instanceof SequentialBlock
& & catchBlock . getSubBlocks ( ) [ 0 ] & & catchBlock . getSubBlocks ( ) [ 0 ]
instanceof InstructionBlock ) ) instanceof InstructionBlock ) )
return false ; return false ;
Expression instr = Expression instr =
( ( InstructionBlock ) catchBlock . getSubBlocks ( ) [ 0 ] ) . getInstruction ( ) ; ( ( InstructionBlock ) catchBlock . getSubBlocks ( ) [ 0 ] ) . getInstruction ( ) ;
if ( ! ( instr instanceof MonitorExitOperator if ( ! ( instr instanceof MonitorExitOperator
& & instr . getFreeOperandCount ( ) = = 0 & & instr . getFreeOperandCount ( ) = = 0
& & ( ( ( MonitorExitOperator ) instr ) . getSubExpressions ( ) [ 0 ] & & ( ( ( MonitorExitOperator ) instr ) . getSubExpressions ( ) [ 0 ]
@ -547,9 +560,9 @@ public class TransformExceptionHandlers {
& & catchBlock . getSubBlocks ( ) [ 1 ] instanceof ThrowBlock ) ) & & catchBlock . getSubBlocks ( ) [ 1 ] instanceof ThrowBlock ) )
return false ; return false ;
/* Check for the throw instruction */
Expression throwInstr = Expression throwInstr =
( ( ThrowBlock ) catchBlock . getSubBlocks ( ) [ 1 ] ) . getInstruction ( ) ; ( ( ThrowBlock ) catchBlock . getSubBlocks ( ) [ 1 ] ) . getInstruction ( ) ;
if ( excStore ! = null ) { if ( excStore ! = null ) {
if ( ! ( throwInstr instanceof Operator if ( ! ( throwInstr instanceof Operator
& & excStore . lvalueMatches ( ( Operator ) throwInstr ) ) ) & & excStore . lvalueMatches ( ( Operator ) throwInstr ) ) )
@ -584,6 +597,12 @@ public class TransformExceptionHandlers {
* return_n * return_n
* / * /
/ * Merge try and catch flow blocks . No need to insert the
* catchFlow . block into the try flow though , since all its
* instruction are synthetic .
* /
mergeTryCatch ( tryFlow , catchFlow ) ;
MonitorExitOperator monexit = ( MonitorExitOperator ) MonitorExitOperator monexit = ( MonitorExitOperator )
( ( InstructionBlock ) catchBlock . getSubBlocks ( ) [ 0 ] ) . instr ; ( ( InstructionBlock ) catchBlock . getSubBlocks ( ) [ 0 ] ) . instr ;
LocalInfo local = LocalInfo local =
@ -597,7 +616,7 @@ public class TransformExceptionHandlers {
+ "," + tryFlow . getNextBlockNr ( ) + "," + endHandler + ")" ) ; + "," + tryFlow . getNextBlockNr ( ) + "," + endHandler + ")" ) ;
checkAndRemoveMonitorExit checkAndRemoveMonitorExit
( tryFlow , catchBlock , local , tryFlow . getNextBlockNr ( ) , endHandler ) ; ( tryFlow , local , tryFlow . getNextBlockNr ( ) , endHandler ) ;
SynchronizedBlock syncBlock = new SynchronizedBlock ( local ) ; SynchronizedBlock syncBlock = new SynchronizedBlock ( local ) ;
TryBlock tryBlock = ( TryBlock ) tryFlow . block ; TryBlock tryBlock = ( TryBlock ) tryFlow . block ;
@ -609,8 +628,41 @@ public class TransformExceptionHandlers {
return true ; return true ;
} }
/ * *
* Merge try and finally flow blocks .
* @param tryFlow The try flow block . Its contained block must be
* a try block .
* @param catchFlow The catch flow block that contains the finally
* block .
* @param finallyBlock block that either contains the finally block .
* It is part of the catchFlow . The other parts of catchFlow are
* synthetic and can be removed .
* /
private void mergeFinallyBlock ( FlowBlock tryFlow , FlowBlock catchFlow ,
StructuredBlock finallyBlock ) {
TryBlock tryBlock = ( TryBlock ) tryFlow . block ;
if ( tryBlock . getSubBlocks ( ) [ 0 ] instanceof TryBlock ) {
/ * A try { try { } catch { } } finally { } is equivalent
* to a try { } catch { } finally { }
* so remove the surrounding tryBlock .
* /
TryBlock innerTry = ( TryBlock ) tryBlock . getSubBlocks ( ) [ 0 ] ;
innerTry . gen = tryBlock . gen ;
innerTry . replace ( tryBlock ) ;
tryBlock = innerTry ;
tryFlow . lastModified = tryBlock ;
tryFlow . block = tryBlock ;
}
/* Now merge try and catch flow blocks */
mergeTryCatch ( tryFlow , catchFlow ) ;
FinallyBlock newBlock = new FinallyBlock ( ) ;
newBlock . setCatchBlock ( finallyBlock ) ;
tryBlock . addCatchBlock ( newBlock ) ;
}
private boolean analyzeFinally ( FlowBlock tryFlow , private boolean analyzeFinally ( FlowBlock tryFlow ,
StructuredBlock catchBlock , int end ) { FlowBlock catchFlow , int end ) {
/ * Layout of a try - finally block : / * Layout of a try - finally block :
* *
@ -632,6 +684,7 @@ public class TransformExceptionHandlers {
* return_n * return_n
* / * /
StructuredBlock catchBlock = catchFlow . block ;
StoreInstruction excStore = getExceptionStore ( catchBlock ) ; StoreInstruction excStore = getExceptionStore ( catchBlock ) ;
if ( excStore = = null ) if ( excStore = = null )
return false ; return false ;
@ -643,9 +696,10 @@ public class TransformExceptionHandlers {
StructuredBlock finallyBlock = null ; StructuredBlock finallyBlock = null ;
if ( catchBlock . getSubBlocks ( ) [ 0 ] instanceof LoopBlock ) { if ( catchBlock . getSubBlocks ( ) [ 0 ] instanceof LoopBlock ) {
/ * In case the try block has no exit ( that means , it throws / * In case the try block has no exit ( that means , it
* an exception ) , the finallyBlock was already merged with * throws an exception or loops forever ) , the finallyBlock
* the catchBlock . We have to check for this case separately : * was already merged with the catchBlock . We have to
* check for this case separately :
* *
* do { * do {
* JSR * JSR
@ -682,7 +736,7 @@ public class TransformExceptionHandlers {
FlowBlock subRoutine ; FlowBlock subRoutine ;
if ( finallyBlock ! = null ) { if ( finallyBlock ! = null ) {
/ * Check if the jsr breaks ( see two comments above ) . We don ' t / * Check if the jsr breaks ( see comment above ) . We don ' t
* need to check if it breaks to the right block , because * need to check if it breaks to the right block , because
* we know that there is only one Block around the jsr . * we know that there is only one Block around the jsr .
* / * /
@ -690,135 +744,118 @@ public class TransformExceptionHandlers {
return false ; return false ;
/ * Check if the try block has no exit / * Check if the try block has no exit
* XXX - Unfortunately the try block already has the
* successors of catch block .
* / * /
// if (tryFlow.getSuccessors().size() > 0)
if ( tryFlow . getSuccessors ( ) . size ( ) > 0 )
// return false;
return false ;
catchBlock = finallyBlock ; catchBlock = finallyBlock ;
subRoutine = null ; subRoutine = null ;
} else { } else {
if ( ! ( jsrBlock . innerBlock instanceof EmptyBlock ) ) if ( ! ( jsrBlock . innerBlock instanceof EmptyBlock ) )
return false ; return false ;
catchBlock = jsrBlock ; finallyBlock = jsrBlock . innerBlock ;
subRoutine = jsrBlock . innerBlock . jump . destination ; subRoutine = finallyBlock . jump . destination ;
checkAndRemoveJSR ( tryFlow , catchBlock , subRoutine ,
tryFlow . getNextBlockNr ( ) ,
subRoutine . getBlockNr ( ) ) ;
}
/ * Wow that was complicated : - ) / * We are committed now and can start changing the try
* But now we know that the catch block looks * block .
* exactly like it should :
*
* local_n = POP
* catchBlock :
* JSR
* finally
* throw local_n
* / * /
checkAndRemoveJSR ( tryFlow , subRoutine ,
tryFlow . getNextBlockNr ( ) , end ) ;
TryBlock tryBlock = ( TryBlock ) tryFlow . block ;
if ( tryBlock . getSubBlocks ( ) [ 0 ] instanceof TryBlock ) {
/* remove the surrounding tryBlock */
TryBlock innerTry = ( TryBlock ) tryBlock . getSubBlocks ( ) [ 0 ] ;
innerTry . gen = tryBlock . gen ;
innerTry . replace ( tryBlock ) ;
tryBlock = innerTry ;
tryFlow . lastModified = tryBlock ;
tryFlow . block = tryBlock ;
}
FinallyBlock newBlock = new FinallyBlock ( ) ;
newBlock . setCatchBlock ( catchBlock ) ;
tryBlock . addCatchBlock ( newBlock ) ;
if ( subRoutine ! = null ) { / * Now analyze and transform the subroutine .
* /
while ( subRoutine . analyze ( tryFlow . getNextBlockNr ( ) , end ) ) ; while ( subRoutine . analyze ( tryFlow . getNextBlockNr ( ) , end ) ) ;
if ( subRoutine . predecessors . size ( ) = = 1 ) {
/ * Now check if the subroutine is correct and has only the / * catchFlow is synthetic , so we can safely remove it
* catchFlow as predecessor . * here .
* / * /
if ( subRoutine . predecessors . size ( ) = = 1 subRoutine . mergeBlockNr ( catchFlow ) ;
& & transformSubRoutine ( subRoutine . block ) ) { catchFlow = subRoutine ;
tryFlow . removeSuccessor ( jsrBlock . innerBlock . jump ) ; if ( ! transformSubRoutine ( subRoutine . block ) ) {
tryFlow . mergeBlockNr ( subRoutine ) ; finallyBlock = subRoutine . block ;
tryFlow . mergeSuccessors ( subRoutine ) ; DescriptionBlock msg = new DescriptionBlock
subRoutine . block . replace ( catchBlock ) ; ( "ERROR: Missing return address handling" ) ;
tryFlow . updateInOutCatch ( subRoutine ) ; StructuredBlock subblock = subRoutine . block ;
msg . replace ( finallyBlock ) ;
msg . appendBlock ( finallyBlock ) ;
}
finallyBlock = subRoutine . block ;
} }
} }
/ * Now finish it .
* /
mergeFinallyBlock ( tryFlow , catchFlow , finallyBlock ) ;
return true ; return true ;
} }
private boolean analyzeSpecialFinally ( FlowBlock tryFlow , private boolean analyzeSpecialFinally ( FlowBlock tryFlow ,
StructuredBlock catchBlock , FlowBlock catchFlow , int end ) {
int end ) { StructuredBlock finallyBlock = catchFlow . block ;
StructuredBlock firstInstr = StructuredBlock firstInstr =
catch Blockinstanceof SequentialBlock finally Blockinstanceof SequentialBlock
? catch Block. getSubBlocks ( ) [ 0 ] : catch Block; ? finally Block. getSubBlocks ( ) [ 0 ] : finally Block;
if ( ! ( firstInstr instanceof SpecialBlock if ( ! ( firstInstr instanceof SpecialBlock
& & ( ( SpecialBlock ) firstInstr ) . type = = SpecialBlock . POP & & ( ( SpecialBlock ) firstInstr ) . type = = SpecialBlock . POP
& & ( ( SpecialBlock ) firstInstr ) . count = = 1 ) ) & & ( ( SpecialBlock ) firstInstr ) . count = = 1 ) )
return false ; return false ;
/ * This may be a special try / finally - block , where / * This is a special try / finally - block , where
* the finally block ends with a break , return or * the finally block ends with a break , return or
* similar . * similar .
* / * /
FlowBlock succ = null ;
/* remove the pop now */ / * Make sure that resolveJump only works on the inside of the try
if ( catchBlock instanceof SequentialBlock ) * /
catchBlock = catchBlock . getSubBlocks ( ) [ 1 ] ; tryFlow . lastModified = tryFlow . block . getSubBlocks ( ) [ 0 ] ;
if ( finallyBlock instanceof SequentialBlock )
finallyBlock = finallyBlock . getSubBlocks ( ) [ 1 ] ;
else { else {
catchBlock = new EmptyBlock ( ) ; finallyBlock = new EmptyBlock ( ) ;
catchBlock . moveJump ( firstInstr . jump ) ; finallyBlock . moveJump ( firstInstr . jump ) ;
succ = firstInstr . jump . destination ;
}
// Set trySuccs = tryFlow.getSuccessors();
/ * Handle the jumps in the tryFlow to finallyFlow .
// if (trySuccs.size() > 1
// || (trySuccs.size() == 1
// && trySuccs.iterator().next() != succ))
// return false;
if ( succ ! = null ) {
/ * Handle the jumps in the tryFlow .
* / * /
Jump jumps = tryFlow . removeJumps ( succ ) ; FlowBlock finallyFlow = finallyBlock . jump . destination ;
jumps = tryFlow . resolveSomeJumps ( jumps , succ ) ; if ( tryFlow . getSuccessors ( ) . contains ( finallyFlow ) ) {
Jump jumps = tryFlow . removeJumps ( finallyFlow ) ;
jumps = tryFlow . resolveSomeJumps ( jumps , finallyFlow ) ;
tryFlow . resolveRemaining ( jumps ) ; tryFlow . resolveRemaining ( jumps ) ;
} }
}
TryBlock tryBlock = ( TryBlock ) tryFlow . block ; /* Complain about all other jumps in try block */
if ( tryBlock . getSubBlocks ( ) [ 0 ] instanceof TryBlock ) { Set trySuccs = tryFlow . getSuccessors ( ) ;
/* remove the unnecessary tryBlock */ for ( Iterator i = trySuccs . iterator ( ) ; i . hasNext ( ) ; ) {
TryBlock innerTry = ( TryBlock ) tryBlock . getSubBlocks ( ) [ 0 ] ; for ( Jump jumps = tryFlow . getJumps ( ( FlowBlock ) i . next ( ) ) ;
innerTry . gen = tryBlock . gen ; jumps ! = null ; jumps = jumps . next ) {
innerTry . replace ( tryBlock ) ; DescriptionBlock msg =
tryBlock = innerTry ; new DescriptionBlock
tryFlow . lastModified = innerTry ; ( "ERROR: doesn't go through finally block!" ) ;
if ( jumps . prev instanceof ReturnBlock ) {
msg . replace ( jumps . prev ) ;
msg . appendBlock ( jumps . prev ) ;
} else {
jumps . prev . appendBlock ( msg ) ;
msg . moveJump ( jumps ) ;
} }
FinallyBlock newBlock = new FinallyBlock ( ) ; }
tryBlock . addCatchBlock ( newBlock ) ; }
newBlock . setCatchBlock ( catchBlock ) ;
mergeFinallyBlock ( tryFlow , catchFlow , finallyBlock ) ;
/* Following code will work be put inside the finallyBlock */
tryFlow . lastModified = finallyBlock ;
return true ; return true ;
} }
/ * * void checkTryCatchOrder ( ) {
* Analyzes all exception handlers to try / catch / finally or
* synchronized blocks .
* /
public void analyze ( ) {
/ * Check if try / catch ranges are okay . The following succeeds / * Check if try / catch ranges are okay . The following succeeds
* for all classes generated by the sun java compiler , but hand * for all classes generated by the sun java compiler , but hand
* optimized classes ( or generated by other compilers ) will fail . * optimized classes ( or generated by other compilers ) will fail .
* / * /
{
Handler last = null ; Handler last = null ;
for ( Iterator i = handlers . iterator ( ) ; i . hasNext ( ) ; ) { for ( Iterator i = handlers . iterator ( ) ; i . hasNext ( ) ; ) {
Handler exc = ( Handler ) i . next ( ) ; Handler exc = ( Handler ) i . next ( ) ;
@ -849,16 +886,23 @@ public class TransformExceptionHandlers {
} }
} }
{ / * *
* Analyzes all exception handlers to try / catch / finally or
* synchronized blocks .
* /
public void analyze ( ) {
checkTryCatchOrder ( ) ;
Iterator i = handlers . iterator ( ) ; Iterator i = handlers . iterator ( ) ;
Handler exc = null ; Handler exc = null ;
Handler next = i . hasNext ( ) ? ( Handler ) i . next ( ) : null ; Handler next = i . hasNext ( ) ? ( Handler ) i . next ( ) : null ;
while ( next ! = null ) { while ( next ! = null ) {
Handler last = exc ; Handler last = exc ;
exc = next ; exc = next ;
next = i . hasNext ( ) ? ( Handler ) i . next ( ) : null ;
int startNr = exc . start . getBlockNr ( ) ; int startNr = exc . start . getBlockNr ( ) ;
int endNr = exc . end . getBlockNr ( ) ; int endNr = exc . end . getBlockNr ( ) ;
next = i . hasNext ( ) ? ( Handler ) i . next ( ) : null ;
int endHandler = Integer . MAX_VALUE ; int endHandler = Integer . MAX_VALUE ;
/ * If the next exception handler catches a bigger range / * If the next exception handler catches a bigger range
* it must surround the handler completely . * it must surround the handler completely .
@ -881,16 +925,16 @@ public class TransformExceptionHandlers {
GlobalOptions . err . println GlobalOptions . err . println
( "analyzeTry(" + startNr + ", " + endNr + ")" ) ; ( "analyzeTry(" + startNr + ", " + endNr + ")" ) ;
while ( true ) { while ( true ) {
while ( tryFlow . analyze ( startNr , while ( tryFlow . analyze ( startNr , endNr + 1 ) ) ;
endNr + 1 ) ) ;
int nextNr = tryFlow . getNextBlockNr ( ) ; int nextNr = tryFlow . getNextBlockNr ( ) ;
if ( nextNr > endNr ) if ( nextNr > endNr )
break ; break ;
tryFlow = flowBlocks [ nextNr ] ; tryFlow = flowBlocks [ nextNr ] ;
} }
if ( tryFlow . getBlockNr ( ) ! = startNr ) if ( tryFlow . getBlockNr ( ) ! = startNr ) {
GlobalOptions . err . println GlobalOptions . err . println
( "Warning: Can't completely analyze try." ) ; ( "Warning: Can't completely analyze try." ) ;
}
TryBlock tryBlock = new TryBlock ( tryFlow ) ; TryBlock tryBlock = new TryBlock ( tryFlow ) ;
} else if ( ! ( tryFlow . block instanceof TryBlock ) ) } else if ( ! ( tryFlow . block instanceof TryBlock ) )
throw new InternalError ( "no TryBlock" ) ; throw new InternalError ( "no TryBlock" ) ;
@ -930,21 +974,18 @@ public class TransformExceptionHandlers {
endHandler ) ) ; endHandler ) ) ;
} }
/* Merge the try-block with the catch-block now */
tryFlow . updateInOutCatch ( catchFlow ) ;
tryFlow . mergeSuccessors ( catchFlow ) ;
tryFlow . mergeBlockNr ( catchFlow ) ;
if ( exc . type ! = null ) if ( exc . type ! = null )
analyzeCatchBlock ( exc . type , tryFlow , catchFlow . block ) ; analyzeCatchBlock ( exc . type , tryFlow , catchFlow ) ;
else if ( ! analyzeSynchronized ( tryFlow , catchFlow . block , else if ( ! analyzeSynchronized ( tryFlow , catchFlow , endHandler )
endHandler ) & & ! analyzeFinally ( tryFlow , catchFlow , endHandler )
& & ! analyzeFinally ( tryFlow , catchFlow . block , & & ! analyzeSpecialFinally ( tryFlow , catchFlow ,
endHandler )
& & ! analyzeSpecialFinally ( tryFlow , catchFlow . block ,
endHandler ) ) endHandler ) )
/ * As last resort make a catch ( Object ) block . This doesn ' t
analyzeCatchBlock ( Type . tObject , tryFlow , catchFlow . block ) ; * compile , but at least it gives a hint what the code
* does .
* /
analyzeCatchBlock ( Type . tObject , tryFlow , catchFlow ) ;
tryFlow . checkConsistent ( ) ; tryFlow . checkConsistent ( ) ;
if ( ( GlobalOptions . debuggingFlags if ( ( GlobalOptions . debuggingFlags
@ -955,4 +996,3 @@ public class TransformExceptionHandlers {
} }
} }
} }
}
hoenicke
24 years ago