== t1 == fun t1() { try { 1 } finally { 2 } } --------------------- L0: 1 2 mark({ try { 1 } finally { 2 } }) mark(try { 1 } finally { 2 }) jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ 1 })] 3 mark({ 1 }) r(1) -> 2 jmp(L3 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })] L2 [onExceptionToFinallyBlock]: L4 [start finally]: 3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])] r(2) -> L5 [finish finally]: 2 jmp(error) NEXT:[] L3 [skipFinallyToErrorBlock]: 3 mark({ 2 }) PREV:[jmp(L3 [skipFinallyToErrorBlock])] r(2) -> 2 merge(try { 1 } finally { 2 }|) -> L1: 1 NEXT:[] error: PREV:[jmp(error)] sink: PREV:[, ] ===================== == t2 == fun t2() { try { 1 if (2 > 3) { return } } finally { 2 } } --------------------- L0: 1 2 mark({ try { 1 if (2 > 3) { return } } finally { 2 } }) mark(try { 1 if (2 > 3) { return } } finally { 2 }) jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ 1 if (2 > 3) { return } })] 3 mark({ 1 if (2 > 3) { return } }) r(1) -> mark(if (2 > 3) { return }) r(2) -> r(3) -> mark(2 > 3) call(2 > 3, compareTo|, ) -> jf(L3|) NEXT:[read (Unit), mark({ return })] 4 mark({ return }) L4 [start finally]: 5 mark({ 2 }) r(2) -> L5 [finish finally]: 4 ret L1 NEXT:[] - 3 jmp(L6) NEXT:[merge(if (2 > 3) { return }|!) -> ] PREV:[] L3: read (Unit) PREV:[jf(L3|)] L6: merge(if (2 > 3) { return }|!) -> 2 jmp(L7 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })] L2 [onExceptionToFinallyBlock]: 5 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])] r(2) -> 2 jmp(error) NEXT:[] L7 [skipFinallyToErrorBlock]: 5 mark({ 2 }) PREV:[jmp(L7 [skipFinallyToErrorBlock])] r(2) -> 2 merge(try { 1 if (2 > 3) { return } } finally { 2 }|) -> L1: 1 NEXT:[] PREV:[ret L1, merge(try { 1 if (2 > 3) { return } } finally { 2 }|) -> ] error: PREV:[jmp(error)] sink: PREV:[, ] ===================== == t3 == fun t3() { try { 1 @l{ () -> if (2 > 3) { return@l } } } finally { 2 } } --------------------- L0: 1 2 mark({ try { 1 @l{ () -> if (2 > 3) { return@l } } } finally { 2 } }) mark(try { 1 @l{ () -> if (2 > 3) { return@l } } } finally { 2 }) jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ 1 @l{ () -> if (2 > 3) { return@l } } })] 3 mark({ 1 @l{ () -> if (2 > 3) { return@l } } }) r(1) -> mark(@l{ () -> if (2 > 3) { return@l } }) mark({ () -> if (2 > 3) { return@l } }) jmp?(L3) NEXT:[r({ () -> if (2 > 3) { return@l } }) -> , d({ () -> if (2 > 3) { return@l } })] d({ () -> if (2 > 3) { return@l } }) NEXT:[] L3: r({ () -> if (2 > 3) { return@l } }) -> PREV:[jmp?(L3)] 2 jmp(L8 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })] L2 [onExceptionToFinallyBlock]: L9 [start finally]: 3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])] r(2) -> L10 [finish finally]: 2 jmp(error) NEXT:[] L8 [skipFinallyToErrorBlock]: 3 mark({ 2 }) PREV:[jmp(L8 [skipFinallyToErrorBlock])] r(2) -> 2 merge(try { 1 @l{ () -> if (2 > 3) { return@l } } } finally { 2 }|) -> L1: 1 NEXT:[] error: PREV:[jmp(error)] sink: PREV:[, , d({ () -> if (2 > 3) { return@l } })] ===================== == anonymous_0 == { () -> if (2 > 3) { return@l } } --------------------- L4: 4 5 mark(if (2 > 3) { return@l }) mark(if (2 > 3) { return@l }) r(2) -> r(3) -> mark(2 > 3) call(2 > 3, compareTo|, ) -> jf(L6|) NEXT:[read (Unit), mark({ return@l })] 6 mark({ return@l }) ret L5 NEXT:[] - 5 jmp(L7) NEXT:[merge(if (2 > 3) { return@l }|!) -> ] PREV:[] L6: read (Unit) PREV:[jf(L6|)] L7: merge(if (2 > 3) { return@l }|!) -> L5: 4 NEXT:[] PREV:[ret L5, merge(if (2 > 3) { return@l }|!) -> ] error: PREV:[] sink: PREV:[, ] ===================== == t4 == fun t4() { @l{ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } } } --------------------- L0: 1 2 mark({ @l{ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } } }) mark(@l{ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } }) mark({ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } }) jmp?(L2) NEXT:[r({ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } }) -> , d({ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } })] d({ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } }) NEXT:[] L2: r({ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } }) -> PREV:[jmp?(L2)] L1: 1 NEXT:[] error: PREV:[] sink: PREV:[, , d({ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } })] ===================== == anonymous_1 == { () -> try { 1 if (2 > 3) { return@l } } finally { 2 } } --------------------- L3: 3 4 mark(try { 1 if (2 > 3) { return@l } } finally { 2 }) mark(try { 1 if (2 > 3) { return@l } } finally { 2 }) jmp?(L5 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ 1 if (2 > 3) { return@l } })] 5 mark({ 1 if (2 > 3) { return@l } }) r(1) -> mark(if (2 > 3) { return@l }) r(2) -> r(3) -> mark(2 > 3) call(2 > 3, compareTo|, ) -> jf(L6|) NEXT:[read (Unit), mark({ return@l })] 6 mark({ return@l }) L7 [start finally]: 7 mark({ 2 }) r(2) -> L8 [finish finally]: 6 ret L4 NEXT:[] - 5 jmp(L9) NEXT:[merge(if (2 > 3) { return@l }|!) -> ] PREV:[] L6: read (Unit) PREV:[jf(L6|)] L9: merge(if (2 > 3) { return@l }|!) -> 4 jmp(L10 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })] L5 [onExceptionToFinallyBlock]: 7 mark({ 2 }) PREV:[jmp?(L5 [onExceptionToFinallyBlock])] r(2) -> 4 jmp(error) NEXT:[] L10 [skipFinallyToErrorBlock]: 7 mark({ 2 }) PREV:[jmp(L10 [skipFinallyToErrorBlock])] r(2) -> 4 merge(try { 1 if (2 > 3) { return@l } } finally { 2 }|) -> L4: 3 NEXT:[] PREV:[ret L4, merge(try { 1 if (2 > 3) { return@l } } finally { 2 }|) -> ] error: PREV:[jmp(error)] sink: PREV:[, ] ===================== == t5 == fun t5() { @l while(true) { try { 1 if (2 > 3) { break @l } } finally { 2 } } } --------------------- L0: 1 2 mark({ @l while(true) { try { 1 if (2 > 3) { break @l } } finally { 2 } } }) mark(@l while(true) { try { 1 if (2 > 3) { break @l } } finally { 2 } }) L2 [loop entry point]: L5 [condition entry point]: r(true) -> PREV:[mark(@l while(true) { try { 1 if (2 > 3) { break @l } } finally { 2 } }), jmp(L2 [loop entry point])] mark(while(true) { try { 1 if (2 > 3) { break @l } } finally { 2 } }) magic[VALUE_CONSUMER](true|) -> L4 [body entry point]: 3 mark({ try { 1 if (2 > 3) { break @l } } finally { 2 } }) mark(try { 1 if (2 > 3) { break @l } } finally { 2 }) jmp?(L6 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ 1 if (2 > 3) { break @l } })] 4 mark({ 1 if (2 > 3) { break @l } }) r(1) -> mark(if (2 > 3) { break @l }) r(2) -> r(3) -> mark(2 > 3) call(2 > 3, compareTo|, ) -> jf(L7|) NEXT:[read (Unit), mark({ break @l })] 5 mark({ break @l }) L8 [start finally]: 6 mark({ 2 }) r(2) -> L9 [finish finally]: 5 jmp(L3 [loop exit point]) NEXT:[read (Unit)] - 4 jmp(L10) NEXT:[merge(if (2 > 3) { break @l }|!) -> ] PREV:[] L7: read (Unit) PREV:[jf(L7|)] L10: merge(if (2 > 3) { break @l }|!) -> 3 jmp(L11 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })] L6 [onExceptionToFinallyBlock]: 6 mark({ 2 }) PREV:[jmp?(L6 [onExceptionToFinallyBlock])] r(2) -> 3 jmp(error) NEXT:[] L11 [skipFinallyToErrorBlock]: 6 mark({ 2 }) PREV:[jmp(L11 [skipFinallyToErrorBlock])] r(2) -> 3 merge(try { 1 if (2 > 3) { break @l } } finally { 2 }|) -> 2 jmp(L2 [loop entry point]) NEXT:[r(true) -> ] L3 [loop exit point]: read (Unit) PREV:[jmp(L3 [loop exit point])] L1: 1 NEXT:[] error: PREV:[jmp(error)] sink: PREV:[, ] ===================== == t6 == fun t6() { try { @l while(true) { 1 if (2 > 3) { break @l } } 5 } finally { 2 } } --------------------- L0: 1 2 mark({ try { @l while(true) { 1 if (2 > 3) { break @l } } 5 } finally { 2 } }) mark(try { @l while(true) { 1 if (2 > 3) { break @l } } 5 } finally { 2 }) jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ @l while(true) { 1 if (2 > 3) { break @l } } 5 })] 3 mark({ @l while(true) { 1 if (2 > 3) { break @l } } 5 }) mark(@l while(true) { 1 if (2 > 3) { break @l } }) L3 [loop entry point]: L6 [condition entry point]: r(true) -> PREV:[mark(@l while(true) { 1 if (2 > 3) { break @l } }), jmp(L3 [loop entry point])] mark(while(true) { 1 if (2 > 3) { break @l } }) magic[VALUE_CONSUMER](true|) -> L5 [body entry point]: 4 mark({ 1 if (2 > 3) { break @l } }) r(1) -> mark(if (2 > 3) { break @l }) r(2) -> r(3) -> mark(2 > 3) call(2 > 3, compareTo|, ) -> jf(L7|) NEXT:[read (Unit), mark({ break @l })] 5 mark({ break @l }) jmp(L4 [loop exit point]) NEXT:[read (Unit)] - 4 jmp(L8) NEXT:[merge(if (2 > 3) { break @l }|!) -> ] PREV:[] L7: read (Unit) PREV:[jf(L7|)] L8: merge(if (2 > 3) { break @l }|!) -> 3 jmp(L3 [loop entry point]) NEXT:[r(true) -> ] L4 [loop exit point]: read (Unit) PREV:[jmp(L4 [loop exit point])] r(5) -> 2 jmp(L9 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })] L2 [onExceptionToFinallyBlock]: L10 [start finally]: 3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])] r(2) -> L11 [finish finally]: 2 jmp(error) NEXT:[] L9 [skipFinallyToErrorBlock]: 3 mark({ 2 }) PREV:[jmp(L9 [skipFinallyToErrorBlock])] r(2) -> 2 merge(try { @l while(true) { 1 if (2 > 3) { break @l } } 5 } finally { 2 }|) -> L1: 1 NEXT:[] error: PREV:[jmp(error)] sink: PREV:[, ] ===================== == t7 == fun t7() { try { @l while(true) { 1 if (2 > 3) { break @l } } } finally { 2 } } --------------------- L0: 1 2 mark({ try { @l while(true) { 1 if (2 > 3) { break @l } } } finally { 2 } }) mark(try { @l while(true) { 1 if (2 > 3) { break @l } } } finally { 2 }) jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ @l while(true) { 1 if (2 > 3) { break @l } } })] 3 mark({ @l while(true) { 1 if (2 > 3) { break @l } } }) mark(@l while(true) { 1 if (2 > 3) { break @l } }) L3 [loop entry point]: L6 [condition entry point]: r(true) -> PREV:[mark(@l while(true) { 1 if (2 > 3) { break @l } }), jmp(L3 [loop entry point])] mark(while(true) { 1 if (2 > 3) { break @l } }) magic[VALUE_CONSUMER](true|) -> L5 [body entry point]: 4 mark({ 1 if (2 > 3) { break @l } }) r(1) -> mark(if (2 > 3) { break @l }) r(2) -> r(3) -> mark(2 > 3) call(2 > 3, compareTo|, ) -> jf(L7|) NEXT:[read (Unit), mark({ break @l })] 5 mark({ break @l }) jmp(L4 [loop exit point]) NEXT:[read (Unit)] - 4 jmp(L8) NEXT:[merge(if (2 > 3) { break @l }|!) -> ] PREV:[] L7: read (Unit) PREV:[jf(L7|)] L8: merge(if (2 > 3) { break @l }|!) -> 3 jmp(L3 [loop entry point]) NEXT:[r(true) -> ] L4 [loop exit point]: read (Unit) PREV:[jmp(L4 [loop exit point])] 2 jmp(L9 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })] L2 [onExceptionToFinallyBlock]: L10 [start finally]: 3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])] r(2) -> L11 [finish finally]: 2 jmp(error) NEXT:[] L9 [skipFinallyToErrorBlock]: 3 mark({ 2 }) PREV:[jmp(L9 [skipFinallyToErrorBlock])] r(2) -> 2 merge(try { @l while(true) { 1 if (2 > 3) { break @l } } } finally { 2 }|!) -> L1: 1 NEXT:[] error: PREV:[jmp(error)] sink: PREV:[, ] ===================== == t8 == fun t8(a : Int) { @l for (i in 1..a) { try { 1 if (2 > 3) { continue @l } } finally { 2 } } } --------------------- L0: 1 v(a : Int) magic[FAKE_INITIALIZER](a : Int) -> w(a|) 2 mark({ @l for (i in 1..a) { try { 1 if (2 > 3) { continue @l } } finally { 2 } } }) mark(@l for (i in 1..a) { try { 1 if (2 > 3) { continue @l } } finally { 2 } }) 3 r(1) -> r(a) -> mark(1..a) call(1..a, rangeTo|, ) -> v(i) L3: jmp?(L2) NEXT:[read (Unit), magic[LOOP_RANGE_ITERATION](1..a|) -> ] L4 [loop entry point]: L5 [body entry point]: magic[LOOP_RANGE_ITERATION](1..a|) -> PREV:[jmp?(L2), jmp(L4 [loop entry point]), jmp?(L4 [loop entry point])] w(i|) mark(for (i in 1..a) { try { 1 if (2 > 3) { continue @l } } finally { 2 } }) 4 mark({ try { 1 if (2 > 3) { continue @l } } finally { 2 } }) mark(try { 1 if (2 > 3) { continue @l } } finally { 2 }) jmp?(L6 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ 1 if (2 > 3) { continue @l } })] 5 mark({ 1 if (2 > 3) { continue @l } }) r(1) -> mark(if (2 > 3) { continue @l }) r(2) -> r(3) -> mark(2 > 3) call(2 > 3, compareTo|, ) -> jf(L7|) NEXT:[read (Unit), mark({ continue @l })] 6 mark({ continue @l }) L8 [start finally]: 7 mark({ 2 }) r(2) -> L9 [finish finally]: 6 jmp(L4 [loop entry point]) NEXT:[magic[LOOP_RANGE_ITERATION](1..a|) -> ] - 5 jmp(L10) NEXT:[merge(if (2 > 3) { continue @l }|!) -> ] PREV:[] L7: read (Unit) PREV:[jf(L7|)] L10: merge(if (2 > 3) { continue @l }|!) -> 4 jmp(L11 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })] L6 [onExceptionToFinallyBlock]: 7 mark({ 2 }) PREV:[jmp?(L6 [onExceptionToFinallyBlock])] r(2) -> 4 jmp(error) NEXT:[] L11 [skipFinallyToErrorBlock]: 7 mark({ 2 }) PREV:[jmp(L11 [skipFinallyToErrorBlock])] r(2) -> 4 merge(try { 1 if (2 > 3) { continue @l } } finally { 2 }|) -> 3 jmp?(L4 [loop entry point]) NEXT:[magic[LOOP_RANGE_ITERATION](1..a|) -> , read (Unit)] L2: read (Unit) PREV:[jmp?(L2), jmp?(L4 [loop entry point])] L1: 1 NEXT:[] error: PREV:[jmp(error)] sink: PREV:[, ] ===================== == t9 == fun t9(a : Int) { try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } 5 } finally { 2 } } --------------------- L0: 1 v(a : Int) magic[FAKE_INITIALIZER](a : Int) -> w(a|) 2 mark({ try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } 5 } finally { 2 } }) mark(try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } 5 } finally { 2 }) jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } 5 })] 3 mark({ @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } 5 }) mark(@l for (i in 1..a) { 1 if (2 > 3) { continue @l } }) 4 r(1) -> r(a) -> mark(1..a) call(1..a, rangeTo|, ) -> v(i) L4: jmp?(L3) NEXT:[read (Unit), magic[LOOP_RANGE_ITERATION](1..a|) -> ] L5 [loop entry point]: L6 [body entry point]: magic[LOOP_RANGE_ITERATION](1..a|) -> PREV:[jmp?(L3), jmp(L5 [loop entry point]), jmp?(L5 [loop entry point])] w(i|) mark(for (i in 1..a) { 1 if (2 > 3) { continue @l } }) 5 mark({ 1 if (2 > 3) { continue @l } }) r(1) -> mark(if (2 > 3) { continue @l }) r(2) -> r(3) -> mark(2 > 3) call(2 > 3, compareTo|, ) -> jf(L7|) NEXT:[read (Unit), mark({ continue @l })] 6 mark({ continue @l }) jmp(L5 [loop entry point]) NEXT:[magic[LOOP_RANGE_ITERATION](1..a|) -> ] - 5 jmp(L8) NEXT:[merge(if (2 > 3) { continue @l }|!) -> ] PREV:[] L7: read (Unit) PREV:[jf(L7|)] L8: merge(if (2 > 3) { continue @l }|!) -> 4 jmp?(L5 [loop entry point]) NEXT:[magic[LOOP_RANGE_ITERATION](1..a|) -> , read (Unit)] L3: read (Unit) PREV:[jmp?(L3), jmp?(L5 [loop entry point])] 3 r(5) -> 2 jmp(L9 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })] L2 [onExceptionToFinallyBlock]: L10 [start finally]: 3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])] r(2) -> L11 [finish finally]: 2 jmp(error) NEXT:[] L9 [skipFinallyToErrorBlock]: 3 mark({ 2 }) PREV:[jmp(L9 [skipFinallyToErrorBlock])] r(2) -> 2 merge(try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } 5 } finally { 2 }|) -> L1: 1 NEXT:[] error: PREV:[jmp(error)] sink: PREV:[, ] ===================== == t10 == fun t10(a : Int) { try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } } finally { 2 } } --------------------- L0: 1 v(a : Int) magic[FAKE_INITIALIZER](a : Int) -> w(a|) 2 mark({ try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } } finally { 2 } }) mark(try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } } finally { 2 }) jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ 2 }), mark({ @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } })] 3 mark({ @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } }) mark(@l for (i in 1..a) { 1 if (2 > 3) { continue @l } }) 4 r(1) -> r(a) -> mark(1..a) call(1..a, rangeTo|, ) -> v(i) L4: jmp?(L3) NEXT:[read (Unit), magic[LOOP_RANGE_ITERATION](1..a|) -> ] L5 [loop entry point]: L6 [body entry point]: magic[LOOP_RANGE_ITERATION](1..a|) -> PREV:[jmp?(L3), jmp(L5 [loop entry point]), jmp?(L5 [loop entry point])] w(i|) mark(for (i in 1..a) { 1 if (2 > 3) { continue @l } }) 5 mark({ 1 if (2 > 3) { continue @l } }) r(1) -> mark(if (2 > 3) { continue @l }) r(2) -> r(3) -> mark(2 > 3) call(2 > 3, compareTo|, ) -> jf(L7|) NEXT:[read (Unit), mark({ continue @l })] 6 mark({ continue @l }) jmp(L5 [loop entry point]) NEXT:[magic[LOOP_RANGE_ITERATION](1..a|) -> ] - 5 jmp(L8) NEXT:[merge(if (2 > 3) { continue @l }|!) -> ] PREV:[] L7: read (Unit) PREV:[jf(L7|)] L8: merge(if (2 > 3) { continue @l }|!) -> 4 jmp?(L5 [loop entry point]) NEXT:[magic[LOOP_RANGE_ITERATION](1..a|) -> , read (Unit)] L3: read (Unit) PREV:[jmp?(L3), jmp?(L5 [loop entry point])] 2 jmp(L9 [skipFinallyToErrorBlock]) NEXT:[mark({ 2 })] L2 [onExceptionToFinallyBlock]: L10 [start finally]: 3 mark({ 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])] r(2) -> L11 [finish finally]: 2 jmp(error) NEXT:[] L9 [skipFinallyToErrorBlock]: 3 mark({ 2 }) PREV:[jmp(L9 [skipFinallyToErrorBlock])] r(2) -> 2 merge(try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } } finally { 2 }|!) -> L1: 1 NEXT:[] error: PREV:[jmp(error)] sink: PREV:[, ] ===================== == t11 == fun t11() { try { return 1 } finally { return 2 } } --------------------- L0: 1 2 mark({ try { return 1 } finally { return 2 } }) mark(try { return 1 } finally { return 2 }) jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ return 2 }), mark({ return 1 })] 3 mark({ return 1 }) r(1) -> L3 [start finally]: 4 mark({ return 2 }) r(2) -> ret(*|) L1 NEXT:[] L4 [finish finally]: - 3 ret(*|) L1 NEXT:[] PREV:[] - 2 jmp(L5 [skipFinallyToErrorBlock]) NEXT:[mark({ return 2 })] PREV:[] L2 [onExceptionToFinallyBlock]: 4 mark({ return 2 }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])] r(2) -> ret(*|) L1 NEXT:[] - 2 jmp(error) NEXT:[] PREV:[] L5 [skipFinallyToErrorBlock]: - 4 mark({ return 2 }) PREV:[] - r(2) -> PREV:[] - ret(*|) L1 NEXT:[] PREV:[] - 2 merge(try { return 1 } finally { return 2 }|!) -> PREV:[] L1: 1 NEXT:[] PREV:[ret(*|) L1, ret(*|) L1] error: PREV:[] sink: PREV:[, ] ===================== == t12 == fun t12() : Int { try { return 1 } finally { doSmth(3) } } --------------------- L0: 1 2 mark({ try { return 1 } finally { doSmth(3) } }) mark(try { return 1 } finally { doSmth(3) }) jmp?(L2 [onExceptionToFinallyBlock]) NEXT:[mark({ doSmth(3) }), mark({ return 1 })] 3 mark({ return 1 }) r(1) -> L3 [start finally]: 4 mark({ doSmth(3) }) r(3) -> mark(doSmth(3)) call(doSmth(3), doSmth|) -> L4 [finish finally]: 3 ret(*|) L1 NEXT:[] - 2 jmp(L5 [skipFinallyToErrorBlock]) NEXT:[mark({ doSmth(3) })] PREV:[] L2 [onExceptionToFinallyBlock]: 4 mark({ doSmth(3) }) PREV:[jmp?(L2 [onExceptionToFinallyBlock])] r(3) -> mark(doSmth(3)) call(doSmth(3), doSmth|) -> 2 jmp(error) NEXT:[] L5 [skipFinallyToErrorBlock]: - 4 mark({ doSmth(3) }) PREV:[] - r(3) -> PREV:[] - mark(doSmth(3)) PREV:[] - call(doSmth(3), doSmth|) -> PREV:[] - 2 merge(try { return 1 } finally { doSmth(3) }|!) -> PREV:[] L1: 1 NEXT:[] PREV:[ret(*|) L1] error: PREV:[jmp(error)] sink: PREV:[, ] ===================== == t13 == fun t13() : Int { try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) } finally { doSmth(3) } } --------------------- L0: 1 2 mark({ try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) } finally { doSmth(3) } }) mark(try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) } finally { doSmth(3) }) jmp?(L2 [onException]) NEXT:[v(e: UnsupportedOperationException), jmp?(L3 [onExceptionToFinallyBlock])] jmp?(L3 [onExceptionToFinallyBlock]) NEXT:[mark({ doSmth(3) }), mark({ return 1 })] 3 mark({ return 1 }) r(1) -> L4 [start finally]: 4 mark({ doSmth(3) }) r(3) -> mark(doSmth(3)) call(doSmth(3), doSmth|) -> L5 [finish finally]: 3 ret(*|) L1 NEXT:[] - 2 jmp(L6 [afterCatches]) NEXT:[jmp(L7 [skipFinallyToErrorBlock])] PREV:[] L2 [onException]: 3 v(e: UnsupportedOperationException) PREV:[jmp?(L2 [onException])] magic[FAKE_INITIALIZER](e: UnsupportedOperationException) -> w(e|) 4 mark({ doSmth(2) }) r(2) -> mark(doSmth(2)) call(doSmth(2), doSmth|) -> 3 jmp(L6 [afterCatches]) L6 [afterCatches]: 2 jmp(L7 [skipFinallyToErrorBlock]) NEXT:[mark({ doSmth(3) })] L3 [onExceptionToFinallyBlock]: 4 mark({ doSmth(3) }) PREV:[jmp?(L3 [onExceptionToFinallyBlock])] r(3) -> mark(doSmth(3)) call(doSmth(3), doSmth|) -> 2 jmp(error) NEXT:[] L7 [skipFinallyToErrorBlock]: 4 mark({ doSmth(3) }) PREV:[jmp(L7 [skipFinallyToErrorBlock])] r(3) -> mark(doSmth(3)) call(doSmth(3), doSmth|) -> 2 merge(try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) } finally { doSmth(3) }|!, ) -> L1: 1 NEXT:[] PREV:[ret(*|) L1, merge(try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) } finally { doSmth(3) }|!, ) -> ] error: PREV:[jmp(error)] sink: PREV:[, ] ===================== == t14 == fun t14() : Int { try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) } } --------------------- L0: 1 2 mark({ try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) } }) mark(try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) }) jmp?(L2 [onException]) NEXT:[v(e: UnsupportedOperationException), mark({ return 1 })] 3 mark({ return 1 }) r(1) -> ret(*|) L1 NEXT:[] - 2 jmp(L3 [afterCatches]) NEXT:[merge(try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) }|!, ) -> ] PREV:[] L2 [onException]: 3 v(e: UnsupportedOperationException) PREV:[jmp?(L2 [onException])] magic[FAKE_INITIALIZER](e: UnsupportedOperationException) -> w(e|) 4 mark({ doSmth(2) }) r(2) -> mark(doSmth(2)) call(doSmth(2), doSmth|) -> 3 jmp(L3 [afterCatches]) L3 [afterCatches]: 2 merge(try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) }|!, ) -> L1: 1 NEXT:[] PREV:[ret(*|) L1, merge(try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) }|!, ) -> ] error: PREV:[] sink: PREV:[, ] ===================== == t15 == fun t15() : Int { try { return 1 } catch (e: UnsupportedOperationException) { return 2 } finally { doSmth(3) } } --------------------- L0: 1 2 mark({ try { return 1 } catch (e: UnsupportedOperationException) { return 2 } finally { doSmth(3) } }) mark(try { return 1 } catch (e: UnsupportedOperationException) { return 2 } finally { doSmth(3) }) jmp?(L2 [onException]) NEXT:[v(e: UnsupportedOperationException), jmp?(L3 [onExceptionToFinallyBlock])] jmp?(L3 [onExceptionToFinallyBlock]) NEXT:[mark({ doSmth(3) }), mark({ return 1 })] 3 mark({ return 1 }) r(1) -> L4 [start finally]: 4 mark({ doSmth(3) }) r(3) -> mark(doSmth(3)) call(doSmth(3), doSmth|) -> L5 [finish finally]: 3 ret(*|) L1 NEXT:[] - 2 jmp(L6 [afterCatches]) NEXT:[jmp(L7 [skipFinallyToErrorBlock])] PREV:[] L2 [onException]: 3 v(e: UnsupportedOperationException) PREV:[jmp?(L2 [onException])] magic[FAKE_INITIALIZER](e: UnsupportedOperationException) -> w(e|) 4 mark({ return 2 }) r(2) -> mark({ doSmth(3) }) r(3) -> mark(doSmth(3)) call(doSmth(3), doSmth|) -> ret(*|) L1 NEXT:[] - 3 jmp(L6 [afterCatches]) PREV:[] L6 [afterCatches]: - 2 jmp(L7 [skipFinallyToErrorBlock]) NEXT:[mark({ doSmth(3) })] PREV:[] L3 [onExceptionToFinallyBlock]: 4 mark({ doSmth(3) }) PREV:[jmp?(L3 [onExceptionToFinallyBlock])] r(3) -> mark(doSmth(3)) call(doSmth(3), doSmth|) -> 2 jmp(error) NEXT:[] L7 [skipFinallyToErrorBlock]: - 4 mark({ doSmth(3) }) PREV:[] - r(3) -> PREV:[] - mark(doSmth(3)) PREV:[] - call(doSmth(3), doSmth|) -> PREV:[] - 2 merge(try { return 1 } catch (e: UnsupportedOperationException) { return 2 } finally { doSmth(3) }|!, !) -> PREV:[] L1: 1 NEXT:[] PREV:[ret(*|) L1, ret(*|) L1] error: PREV:[jmp(error)] sink: PREV:[, ] ===================== == t16 == fun t16() : Int { try { doSmth(1) } catch (e: UnsupportedOperationException) { return 2 } finally { doSmth(3) } } --------------------- L0: 1 2 mark({ try { doSmth(1) } catch (e: UnsupportedOperationException) { return 2 } finally { doSmth(3) } }) mark(try { doSmth(1) } catch (e: UnsupportedOperationException) { return 2 } finally { doSmth(3) }) jmp?(L2 [onException]) NEXT:[v(e: UnsupportedOperationException), jmp?(L3 [onExceptionToFinallyBlock])] jmp?(L3 [onExceptionToFinallyBlock]) NEXT:[mark({ doSmth(3) }), mark({ doSmth(1) })] 3 mark({ doSmth(1) }) r(1) -> mark(doSmth(1)) call(doSmth(1), doSmth|) -> 2 jmp(L4 [afterCatches]) NEXT:[jmp(L7 [skipFinallyToErrorBlock])] L2 [onException]: 3 v(e: UnsupportedOperationException) PREV:[jmp?(L2 [onException])] magic[FAKE_INITIALIZER](e: UnsupportedOperationException) -> w(e|) 4 mark({ return 2 }) r(2) -> L5 [start finally]: 5 mark({ doSmth(3) }) r(3) -> mark(doSmth(3)) call(doSmth(3), doSmth|) -> L6 [finish finally]: 4 ret(*|) L1 NEXT:[] - 3 jmp(L4 [afterCatches]) PREV:[] L4 [afterCatches]: 2 jmp(L7 [skipFinallyToErrorBlock]) NEXT:[mark({ doSmth(3) })] PREV:[jmp(L4 [afterCatches])] L3 [onExceptionToFinallyBlock]: 5 mark({ doSmth(3) }) PREV:[jmp?(L3 [onExceptionToFinallyBlock])] r(3) -> mark(doSmth(3)) call(doSmth(3), doSmth|) -> 2 jmp(error) NEXT:[] L7 [skipFinallyToErrorBlock]: 5 mark({ doSmth(3) }) PREV:[jmp(L7 [skipFinallyToErrorBlock])] r(3) -> mark(doSmth(3)) call(doSmth(3), doSmth|) -> 2 merge(try { doSmth(1) } catch (e: UnsupportedOperationException) { return 2 } finally { doSmth(3) }|, !) -> L1: 1 NEXT:[] PREV:[ret(*|) L1, merge(try { doSmth(1) } catch (e: UnsupportedOperationException) { return 2 } finally { doSmth(3) }|, !) -> ] error: PREV:[jmp(error)] sink: PREV:[, ] ===================== == doSmth == fun doSmth(i: Int) { } --------------------- L0: 1 v(i: Int) magic[FAKE_INITIALIZER](i: Int) -> w(i|) 2 mark({ }) read (Unit) L1: 1 NEXT:[] error: PREV:[] sink: PREV:[, ] =====================