1497 lines
36 KiB
Plaintext
1497 lines
36 KiB
Plaintext
/*
|
|
* Copyright (c) 2023, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This code 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
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*
|
|
*/
|
|
|
|
super public class TestDeadIrreducibleLoops
|
|
{
|
|
public Method "<init>":"()V"
|
|
stack 2 locals 1
|
|
{
|
|
aload_0;
|
|
invokespecial Method java/lang/Object."<init>":"()V";
|
|
return;
|
|
}
|
|
|
|
static Method test_001:"(IIII)I"
|
|
stack 20 locals 20
|
|
{
|
|
// Irreducible loop with 3 Regions, 2 are entries, 1 is not entry
|
|
iconst_0;
|
|
istore 10;
|
|
|
|
iload_0;
|
|
ifeq LEND; // runtime check, skip all code
|
|
|
|
iload_1;
|
|
ifeq ENTRY1; // irreducible entry
|
|
goto ENTRY2;
|
|
|
|
ENTRY1:
|
|
// 43 Region - irreducible-entry
|
|
iload 3;
|
|
ifeq L1;
|
|
iinc 10, 1;
|
|
ENTRY2:
|
|
// 44 Region - irreducible-entry
|
|
iinc 10, 2;
|
|
L1:
|
|
// 60 Region - irreducible (but not entry)
|
|
// can be loop-head, if build_loop_tree
|
|
// first reaches ENTRY2
|
|
iinc 10, 4;
|
|
iload_2;
|
|
ifeq ENTRY1; // loop-end
|
|
|
|
LEND:
|
|
iload 10;
|
|
ireturn;
|
|
}
|
|
|
|
static Method test_002:"(I)V"
|
|
stack 10 locals 10
|
|
{
|
|
// split_fall_in splits up an irreducible-entry Region
|
|
iconst_0;
|
|
istore 1;
|
|
iload 0;
|
|
ifle L2;
|
|
L1:
|
|
// bci:8
|
|
// 30 Region (tagged irreducible at parsing)
|
|
iload 0;
|
|
ifne L3;
|
|
L2:
|
|
// bci:13
|
|
// 29 Region (tagged irreducible at parsing)
|
|
// 100 Region
|
|
// 129 Region (produced in split_fall_in, must be tagged irreducible)
|
|
// 134 Loop
|
|
goto L1;
|
|
L3:
|
|
iload 1;
|
|
ifgt L1;
|
|
return;
|
|
}
|
|
|
|
static Method test_003:"(I)I"
|
|
stack 5 locals 25
|
|
{
|
|
// Cut off both entries to irreducible loop at the same time:
|
|
// LOOP_y (empty_loop) collapses -> cut off both entries to irreducible LOOP_3
|
|
// LOOP_3 should be removed during IGVN
|
|
iconst_m1;
|
|
istore 12;
|
|
|
|
// empty loop, where var[20] counts to 0
|
|
// and var[21] counts to 10001
|
|
ldc 10001;
|
|
istore 20;
|
|
iconst_0;
|
|
istore 21;
|
|
LOOP_Y:
|
|
iinc 20, -1;
|
|
iinc 21, 1;
|
|
iload 20;
|
|
ifgt LOOP_Y;
|
|
|
|
// once the empty_loop above collapses, we see this is true
|
|
iload 21;
|
|
ldc 10001;
|
|
if_icmpeq LEND;
|
|
|
|
iload_0;
|
|
ldc 1;
|
|
iand;
|
|
ifeq LOOP_3c; // second entry
|
|
|
|
// first entry
|
|
LOOP_3a:
|
|
iinc 12, 11;
|
|
iload 12;
|
|
ifge LOOP_3c; // skip
|
|
LOOP_3b:
|
|
iinc 12, 7;
|
|
LOOP_3c:
|
|
iinc 12, 3;
|
|
iload 12;
|
|
ldc 1001;
|
|
if_icmpne LOOP_3a; // loop
|
|
LEND:
|
|
iload 12;
|
|
ireturn;
|
|
}
|
|
|
|
static Method test_004:"(Ljava/lang/Object;)Ljava/lang/Object;"
|
|
stack 10 locals 10
|
|
{
|
|
// When we detect irreducible loops, we add more Phi nodes
|
|
// This test generates dead code, where we create a dead-loop
|
|
// of Phi nodes. Phi nodes are considered dead-loop safe,
|
|
// so they should be handled gracefully.
|
|
// This is a regression test for the faulty "sanity" assert
|
|
// in PhiNode::merge_through_phi. Instead of asserting,
|
|
// we now just abort the optimization.
|
|
iconst_1;
|
|
istore 5;
|
|
LOOP:
|
|
iconst_0;
|
|
ifge HEAD;
|
|
goto LOOP;
|
|
HEAD:
|
|
iload 5;
|
|
ifge LCMP;
|
|
iload 5;
|
|
iflt L29;
|
|
L30:
|
|
iload 5;
|
|
iflt BOTTOM;
|
|
L29:
|
|
iload 5;
|
|
ifeq L30;
|
|
BOTTOM:
|
|
goto HEAD;
|
|
LCMP:
|
|
aload_0;
|
|
areturn;
|
|
}
|
|
|
|
static Method test_005:"(II)V"
|
|
stack 20 locals 20
|
|
{
|
|
// Triggers compile bailout: bad CFG: both infinite and irreducible
|
|
|
|
iload_0;
|
|
ifeq LEND; // runtime check, avoid infinte loop below
|
|
|
|
iconst_0;
|
|
istore 10;
|
|
|
|
iload_1;
|
|
ifeq ENTRY2;
|
|
|
|
ENTRY1:
|
|
iinc 10, 1;
|
|
ENTRY2:
|
|
iinc 10, 2;
|
|
goto ENTRY1; // backedge
|
|
|
|
LEND:
|
|
return;
|
|
}
|
|
|
|
static Method test_006:"(I)I"
|
|
stack 5 locals 25
|
|
{
|
|
// check that disconnected irreducible loop collapses instantly
|
|
// and does not create data dead-loop with iinc / AddI
|
|
iconst_m1;
|
|
istore 12;
|
|
|
|
// empty loop, where var[20] counts to 0
|
|
// and var[21] counts to 10001
|
|
ldc 10001;
|
|
istore 20;
|
|
iconst_0;
|
|
istore 21;
|
|
LOOP_Y:
|
|
iinc 20, -1;
|
|
iinc 21, 1;
|
|
iload 20;
|
|
ifgt LOOP_Y;
|
|
|
|
// once the empty_loop above collapses, we see this is true
|
|
iload 21;
|
|
ldc 10001;
|
|
if_icmpeq LEND;
|
|
|
|
// second entry
|
|
iload_0;
|
|
ldc 1;
|
|
iand;
|
|
ifgt LOOP_3d;
|
|
|
|
// first entry
|
|
LOOP_3a:
|
|
iload 12;
|
|
ifge LOOP_3d;
|
|
LOOP_3b:
|
|
iload_0; // eventually, we get TOP and things die from the inside out
|
|
ldc 2;
|
|
if_icmplt LOOP_3b;
|
|
iinc 12, 1; // the problematic AddI
|
|
goto LOOP_3a;
|
|
LOOP_3d:
|
|
iload 12;
|
|
ldc 1001;
|
|
if_icmpne LOOP_3a;
|
|
LEND:
|
|
iload_0;
|
|
ireturn;
|
|
}
|
|
|
|
static Method test_007:"(III)V"
|
|
stack 20 locals 40
|
|
{
|
|
// Irreducible entry Regions lose all loop-internal control
|
|
// Once empty_loop collapses, we never loop-back to
|
|
// ENTRY1 nor ENTRY2. SKIP1 and SKIP2 become the new
|
|
// irreducible loop entries.
|
|
iload_0;
|
|
ifeq LEND; // runtime check, avoid code below
|
|
|
|
// empty loop, where var[20] counts to 0
|
|
// and var[21] counts to 10001
|
|
ldc 10001;
|
|
istore 20;
|
|
iconst_0;
|
|
istore 21;
|
|
EMPTY_LOOP:
|
|
iinc 20, -1;
|
|
iinc 21, 1;
|
|
iload 20;
|
|
ifgt EMPTY_LOOP;
|
|
|
|
iconst_0;
|
|
istore 30; // x = 0
|
|
|
|
iload_1;
|
|
ifeq ENTRY1;
|
|
goto ENTRY2; // the order here is arbitrary
|
|
|
|
ENTRY1:
|
|
iinc 30, 1; // x += 1
|
|
|
|
SKIP1:
|
|
ldc 10001;
|
|
iload 21;
|
|
if_icmpeq SKIP2; // always true after empty_loop collapses
|
|
|
|
ENTRY2:
|
|
iinc 30, 32; // x += 2
|
|
|
|
SKIP2:
|
|
iload_2;
|
|
ifeq LEND; // loop-exit
|
|
|
|
ldc 10001;
|
|
iload 21;
|
|
if_icmpeq SKIP1; // always true after empty_loop collapses
|
|
|
|
goto ENTRY1; // backedge
|
|
|
|
LEND:
|
|
return;
|
|
}
|
|
|
|
static Method test_008:"(III)V"
|
|
stack 20 locals 20
|
|
{
|
|
// Same as test_008, but ENTRY1 and ENTRY2 already
|
|
// lose internal loop control during parsing,
|
|
// and SKIP1 and SKIP2 are new entry Regions.
|
|
|
|
iload_0;
|
|
ifeq LEND; // runtime check, skip code below
|
|
|
|
iconst_0;
|
|
istore 10; // x = 0
|
|
|
|
iload_1;
|
|
ifeq ENTRY2;
|
|
goto ENTRY1; // the order here is arbitrary
|
|
|
|
ENTRY1:
|
|
iinc 10, 1; // x += 1
|
|
|
|
SKIP1:
|
|
iconst_0;
|
|
ifeq SKIP2; // always true
|
|
|
|
ENTRY2:
|
|
iinc 10, 32; // x += 2
|
|
|
|
SKIP2:
|
|
iload_2;
|
|
ifeq LEND; // loop-exit
|
|
|
|
iconst_0;
|
|
ifeq SKIP1; // always true
|
|
|
|
goto ENTRY1; // backedge
|
|
|
|
LEND:
|
|
return;
|
|
}
|
|
|
|
static Method test_009:"(IIIIIII)V"
|
|
stack 20 locals 40
|
|
{
|
|
// same as test_007, except extra ifs in ENTRY1 and ENTRY2
|
|
// once ENTRY1 and ENTRY2 lose "backedges",
|
|
// the ELSE1 and ELSE2 sections are no longer in the irreducible loop
|
|
// and SKIP1 and SKIP2 become the new loop entries
|
|
iload 0;
|
|
ifeq LEND; // runtime check, avoid code below
|
|
|
|
// empty loop, where var[20] counts to 0
|
|
// and var[21] counts to 10001
|
|
ldc 10001;
|
|
istore 20;
|
|
iconst_0;
|
|
istore 21;
|
|
EMPTY_LOOP:
|
|
iinc 20, -1;
|
|
iinc 21, 1;
|
|
iload 20;
|
|
ifgt EMPTY_LOOP;
|
|
|
|
iconst_0;
|
|
istore 30; // x = 0
|
|
|
|
iload 1;
|
|
ifeq ENTRY1;
|
|
goto ENTRY2; // the order here is arbitrary
|
|
|
|
ENTRY1:
|
|
iinc 30, 1; // x += 1
|
|
iload 2;
|
|
ifeq ELSE1;
|
|
|
|
iinc 30, 2; // x += 2
|
|
iload 3;
|
|
ifeq ELSE1;
|
|
|
|
iinc 30, 4; // x += 4
|
|
|
|
ELSE1:
|
|
iinc 30, 8; // x += 8
|
|
|
|
SKIP1:
|
|
ldc 10001;
|
|
iload 21;
|
|
if_icmpeq SKIP2; // always true after empty_loop collapses
|
|
|
|
ENTRY2:
|
|
iinc 30, 16; // x += 16
|
|
iload 4;
|
|
ifeq ELSE2;
|
|
|
|
iinc 30, 32; // x += 32
|
|
iload 5;
|
|
ifeq ELSE2;
|
|
|
|
iinc 30, 64; // x += 64
|
|
|
|
ELSE2:
|
|
iinc 30, 128; // x += 128
|
|
|
|
SKIP2:
|
|
iload 6;
|
|
ifeq LEND; // loop-exit
|
|
|
|
ldc 10001;
|
|
iload 21;
|
|
if_icmpeq SKIP1; // always true after empty_loop collapses
|
|
|
|
goto ENTRY1; // backedge
|
|
|
|
LEND:
|
|
return;
|
|
}
|
|
|
|
static Method test_010:"(IIIII)V"
|
|
stack 10 locals 5
|
|
{
|
|
// outer: irreducible, inner: reducible loop
|
|
// ENTRY1 is loop-head for both
|
|
// test that is_in_irreducible_loop walks up to outermost loop with that loop-head
|
|
iload_0;
|
|
ifeq LEND; // runtime check, avoid code below
|
|
|
|
iload 4;
|
|
ifeq SYMMETRY;
|
|
|
|
iload_1;
|
|
ifeq ENTRY1;
|
|
goto ENTRY2;
|
|
|
|
ENTRY1:
|
|
// loop-head
|
|
iload_2;
|
|
ifeq ENTRY1; // backedge of reducible loop (inner)
|
|
ENTRY2:
|
|
// second-entry block
|
|
iload_3;
|
|
ifeq LEND;
|
|
goto ENTRY1; // backedge of irreducible loop (outer)
|
|
|
|
SYMMETRY: // same as ENTRY1 / ENTRY2
|
|
iload_1;
|
|
ifeq ENTRY4; // but these are swapped
|
|
goto ENTRY3;
|
|
|
|
ENTRY3:
|
|
// loop-head
|
|
iload_2;
|
|
ifeq ENTRY3; // backedge of reducible loop (inner)
|
|
ENTRY4:
|
|
// second-entry block
|
|
iload_3;
|
|
ifeq LEND;
|
|
goto ENTRY3; // backedge of irreducible loop (outer)
|
|
|
|
LEND:
|
|
return;
|
|
}
|
|
|
|
static Method test_011:"(IIIII)V"
|
|
stack 20 locals 20
|
|
{
|
|
// If we define irreducible-entry as the Block / Region
|
|
// that is either the head of the (outermost) irreducible loop,
|
|
// or the location where we found a secondary entry to the loop,
|
|
// we find that this definition depends on the order of the
|
|
// DF traversal.
|
|
// (backtrack, edge 0 -> 29, normal forward edge)
|
|
//
|
|
// bci-order 1:
|
|
// 0, 29, 4, 11, 24 (backedge to 11), 16, 21 (backedge to 11),
|
|
// 8 (second entry to 16, make 11 irreducible loop head)
|
|
//
|
|
// bci-order 2:
|
|
// 0, 4, 8, 16, 21, 11 (backedge to 16), 24 (backedge to 11), 29
|
|
// (backtrack, find edge from 16 -> 24, second entry to 24,
|
|
// 16 is irreducible loop head)
|
|
// (backtrack, find edge from 4 -> 11, second entry to 11,
|
|
// 16 is again irreducible loop head)
|
|
// (backtrack, edge 0 -> 29, normal forward edge)
|
|
//
|
|
// Note: in order 2, bci:24 is a entry, but not for order 1.
|
|
// This makes asserts that check the consistency of entries
|
|
// difficult, if not impossible.
|
|
|
|
// bci: 0
|
|
iload_0;
|
|
ifeq LEND; // runtime check, avoid code below
|
|
|
|
// bci: 4
|
|
iload_1;
|
|
ifeq ENTRY1;
|
|
// bci: 8
|
|
goto ENTRY2;
|
|
|
|
ENTRY1:
|
|
// bci: 11
|
|
iload 2;
|
|
ifeq BOTTOM;
|
|
ENTRY2:
|
|
// bci: 16
|
|
iload 3;
|
|
ifeq BOTTOM;
|
|
// bci: 21
|
|
goto ENTRY1;
|
|
|
|
BOTTOM:
|
|
// bci: 24
|
|
iload 4;
|
|
ifeq ENTRY1;
|
|
|
|
LEND:
|
|
// bci: 29
|
|
return;
|
|
}
|
|
|
|
static Method test_012a:"(IIIIIIII)V"
|
|
stack 20 locals 20
|
|
{
|
|
// reducible loop inside irreducible loop
|
|
// block numbers give order that leads to only
|
|
// ENTRY1 and ENTRY2 being irreducible loop entries
|
|
|
|
// block 0
|
|
iload_0;
|
|
ifeq LEND; // runtime check, avoid code below
|
|
|
|
// block 2
|
|
iload_1;
|
|
ifeq ENTRY1;
|
|
// block 12
|
|
goto ENTRY2;
|
|
|
|
ENTRY1:
|
|
// block 3
|
|
iload 2;
|
|
ifeq BOTTOM1;
|
|
// block 8
|
|
goto ENTRY2;
|
|
ENTRY2:
|
|
// block 9
|
|
iload 3;
|
|
ifeq BOTTOM1;
|
|
// block 10
|
|
iload 7;
|
|
ifeq LEND;
|
|
// block 11
|
|
goto ENTRY1;
|
|
|
|
BOTTOM1:
|
|
// region must be marked as irreducible
|
|
// it is loop-head of irreducible loop, but also
|
|
// itself in the irreducible loop that surrounds it
|
|
// there is also a traversal that makes this a
|
|
// irreducible loop entry:
|
|
// 0, 2, 12, 9, 10, 11, 3, 8 (-> backedge to 9)
|
|
// 4 (-> backedge to 3), 5, 7 (->backedge to 4),
|
|
// 1, 6 (-> backedge to 5, -> backedge to 3) ... backtrack all the way to 9
|
|
// -> irreducible entry edge to 4
|
|
// Since this kind of block / region can be an irreducible loop
|
|
// entry, we should mark the block / region as in the irreducible loop
|
|
// this block is split
|
|
// block 4 (in: 3 7 9, out: 5 3)
|
|
// block 6 (in: 5, out: 5 3)
|
|
iload 4;
|
|
ifeq ENTRY1;
|
|
BOTTOM2:
|
|
// block 5
|
|
iload 5;
|
|
ifeq BOTTOM1;
|
|
// block 7
|
|
iload 6;
|
|
ifeq BOTTOM1;
|
|
|
|
LEND:
|
|
// block 1
|
|
return;
|
|
}
|
|
|
|
static Method test_012b:"(IIIII)V"
|
|
stack 20 locals 20
|
|
{
|
|
// reducible loop inside irreducible loop
|
|
// this nested loop is an infinite loop (no exit)
|
|
|
|
iload_0;
|
|
ifeq LEND; // runtime check, avoid code below
|
|
|
|
iload_1;
|
|
ifeq ENTRY1;
|
|
goto ENTRY2;
|
|
|
|
ENTRY1:
|
|
iload 2;
|
|
ifeq BOTTOM;
|
|
goto ENTRY2;
|
|
ENTRY2:
|
|
iload 3;
|
|
ifeq BOTTOM;
|
|
goto ENTRY1;
|
|
|
|
BOTTOM:
|
|
// this must still be marked as in irreducible loop from above,
|
|
// even though it is the head of a reducible loop
|
|
iload 4;
|
|
ifeq ENTRY1;
|
|
goto BOTTOM; // reducible loop
|
|
|
|
LEND:
|
|
return;
|
|
}
|
|
|
|
static Method test_013:"(IIIIIIIII)V"
|
|
stack 20 locals 40
|
|
{
|
|
// Irreducible loop ENTRY1 / ENTRY2, eventually collapses
|
|
// Reducible loops LOOP1 / LOOP2 inside irreducible loop
|
|
// Irreducible loop BOTTOM, with backedge to ENTRY1 (eventually collapses)
|
|
iload_0;
|
|
ifeq LEND; // runtime check, avoid code below
|
|
|
|
// empty loop
|
|
ldc 10001;
|
|
istore 20;
|
|
iconst_0;
|
|
istore 21;
|
|
EMPTY_LOOP:
|
|
iinc 20, -1;
|
|
iinc 21, 1;
|
|
iload 21;
|
|
ldc 10001;
|
|
if_icmplt EMPTY_LOOP;
|
|
// var[20] == 0
|
|
|
|
iconst_1;
|
|
istore 30; // for LOOP1, LOOP2
|
|
|
|
iload_1;
|
|
ifeq ENTRY1;
|
|
goto ENTRY2;
|
|
|
|
ENTRY1:
|
|
iload 20;
|
|
ifeq LOOP1;
|
|
goto ENTRY2; // removed by empty_loop
|
|
ENTRY2:
|
|
iload 20;
|
|
ifeq LOOP2;
|
|
goto ENTRY1; // removed by empty_loop
|
|
|
|
LOOP1:
|
|
iload 30;
|
|
ldc 2;
|
|
imul;
|
|
istore 30;
|
|
iload 30;
|
|
ldc 10000;
|
|
if_icmple LOOP1;
|
|
goto BOTTOM1;
|
|
LOOP2:
|
|
iload 30;
|
|
ldc 2;
|
|
imul;
|
|
istore 30;
|
|
iload 30;
|
|
ldc 10000;
|
|
if_icmple LOOP2;
|
|
goto BOTTOM2;
|
|
|
|
BOTTOM1:
|
|
iload 3;
|
|
ifeq BOTTOM2;
|
|
iload 4;
|
|
ifeq BOTTOM3;
|
|
iload 20;
|
|
ifne ENTRY1; // removed by empty_loop
|
|
goto LEND;
|
|
BOTTOM2:
|
|
iload 5;
|
|
ifeq BOTTOM3;
|
|
iload 6;
|
|
ifeq BOTTOM1;
|
|
goto LEND;
|
|
BOTTOM3:
|
|
iload 7;
|
|
ifeq BOTTOM1;
|
|
iload 8;
|
|
ifeq BOTTOM2;
|
|
goto LEND;
|
|
|
|
LEND:
|
|
return;
|
|
}
|
|
|
|
static Method test_014a:"(III)V"
|
|
stack 20 locals 40
|
|
{
|
|
// Irreducible loop that becomes normal loop
|
|
// and is then removed as empty loop (#2)
|
|
// which finally takes out ENTRY3 / ENTRY4
|
|
//
|
|
iload_0;
|
|
ifeq LEND; // runtime check, avoid code below
|
|
|
|
// empty_loop #1
|
|
ldc 10001;
|
|
istore 20;
|
|
iconst_0;
|
|
istore 21;
|
|
EMPTY_LOOP:
|
|
iinc 20, -1;
|
|
iinc 21, 1;
|
|
iload 21;
|
|
ldc 10001;
|
|
if_icmplt EMPTY_LOOP;
|
|
// var[20] == 0 // empty_loop (#1)
|
|
|
|
// variables for ENTRY1 / ENTRY2
|
|
// when path to ENTRY2 collapses,
|
|
// the loop becomes reducible and
|
|
// can be removed as empty_loop (#2)
|
|
iconst_0;
|
|
istore 30;
|
|
ldc 20002;
|
|
istore 31;
|
|
|
|
iload 20;
|
|
ifeq ENTRY1;
|
|
goto ENTRY2; // removed by empty_loop (#1)
|
|
|
|
ENTRY1:
|
|
iinc 30, 1;
|
|
ENTRY2:
|
|
iinc 31, -1;
|
|
iload 30;
|
|
ldc 20002;
|
|
if_icmplt ENTRY1;
|
|
// var[31] == 0 // empty_loop (#2)
|
|
|
|
iload 31;
|
|
ifeq LEND; // always taken due to empty_loop (#2)
|
|
|
|
iload_1;
|
|
ifeq ENTRY3;
|
|
goto ENTRY4;
|
|
|
|
// irreducible loop at the end
|
|
// expected to be removed after empty_loop (#2) collapses
|
|
ENTRY3:
|
|
iload_2;
|
|
ifeq LEND;
|
|
ENTRY4:
|
|
goto ENTRY3;
|
|
|
|
LEND:
|
|
return;
|
|
}
|
|
|
|
static Method test_014b:"(III)V"
|
|
stack 200 locals 200
|
|
{
|
|
// Sequence of these loops:
|
|
// Irreducible with 2 entries.
|
|
// One entry collapses, turning the irreducible loop
|
|
// into an empty_loop. This collapses one entry of
|
|
// the next loop. This cascades until all loops are
|
|
// removed.
|
|
iload_0;
|
|
ifeq LEND; // runtime check, avoid code below
|
|
|
|
// setting up all variables for the loops below
|
|
iconst_0;
|
|
istore 100;
|
|
ldc 10001;
|
|
istore 101;
|
|
iconst_0;
|
|
istore 102;
|
|
ldc 10001;
|
|
istore 103;
|
|
iconst_0;
|
|
istore 104;
|
|
ldc 10001;
|
|
istore 105;
|
|
iconst_0;
|
|
istore 106;
|
|
ldc 10001;
|
|
istore 107;
|
|
iconst_0;
|
|
istore 108;
|
|
ldc 10001;
|
|
istore 109;
|
|
iconst_0;
|
|
istore 110;
|
|
ldc 10001;
|
|
istore 111;
|
|
iconst_0;
|
|
istore 112;
|
|
ldc 10001;
|
|
istore 113;
|
|
iconst_0;
|
|
istore 114;
|
|
ldc 10001;
|
|
istore 115;
|
|
|
|
iconst_0; // collapse during parsing
|
|
ifeq ENTRY00;
|
|
goto ENTRY01;
|
|
ENTRY00:
|
|
iinc 100, 1;
|
|
ENTRY01:
|
|
iinc 101, -1;
|
|
iload 100;
|
|
ldc 10001;
|
|
if_icmplt ENTRY00;
|
|
// var[101] == 0 // empty_loop (#1)
|
|
|
|
iload 101; // from last empty_loop
|
|
ifeq ENTRY02;
|
|
goto ENTRY03;
|
|
ENTRY02:
|
|
iinc 102, 1;
|
|
ENTRY03:
|
|
iinc 103, -1;
|
|
iload 102;
|
|
ldc 10001;
|
|
if_icmplt ENTRY02;
|
|
// var[103] == 0 // empty_loop (#2)
|
|
|
|
iload 103; // from last empty_loop
|
|
ifeq ENTRY04;
|
|
goto ENTRY05;
|
|
ENTRY04:
|
|
iinc 104, 1;
|
|
ENTRY05:
|
|
iinc 105, -1;
|
|
iload 104;
|
|
ldc 10001;
|
|
if_icmplt ENTRY04;
|
|
// var[105] == 0 // empty_loop (#3)
|
|
|
|
iload 105; // from last empty_loop
|
|
ifeq ENTRY06;
|
|
goto ENTRY07;
|
|
ENTRY06:
|
|
iinc 106, 1;
|
|
ENTRY07:
|
|
iinc 107, -1;
|
|
iload 106;
|
|
ldc 10001;
|
|
if_icmplt ENTRY06;
|
|
// var[107] == 0 // empty_loop (#4)
|
|
|
|
iload 107; // from last empty_loop
|
|
ifeq ENTRY08;
|
|
goto ENTRY09;
|
|
ENTRY08:
|
|
iinc 108, 1;
|
|
ENTRY09:
|
|
iinc 109, -1;
|
|
iload 108;
|
|
ldc 10001;
|
|
if_icmplt ENTRY08;
|
|
// var[109] == 0 // empty_loop (#5)
|
|
|
|
iload 109; // from last empty_loop
|
|
ifeq ENTRY10;
|
|
goto ENTRY11;
|
|
ENTRY10:
|
|
iinc 110, 1;
|
|
ENTRY11:
|
|
iinc 111, -1;
|
|
iload 110;
|
|
ldc 10001;
|
|
if_icmplt ENTRY10;
|
|
// var[111] == 0 // empty_loop (#6)
|
|
|
|
iload 111; // from last empty_loop
|
|
ifeq ENTRY12;
|
|
goto ENTRY13;
|
|
ENTRY12:
|
|
iinc 112, 1;
|
|
ENTRY13:
|
|
iinc 113, -1;
|
|
iload 112;
|
|
ldc 10001;
|
|
if_icmplt ENTRY12;
|
|
// var[113] == 0 // empty_loop (#7)
|
|
|
|
iload 113; // from last empty_loop
|
|
ifeq ENTRY14;
|
|
goto ENTRY15;
|
|
ENTRY14:
|
|
iinc 114, 1;
|
|
ENTRY15:
|
|
iinc 115, -1;
|
|
iload 114;
|
|
ldc 10001;
|
|
if_icmplt ENTRY14;
|
|
// var[115] == 0 // empty_loop (#8)
|
|
|
|
// final loop, removed after last empty_loop collapses
|
|
iload 115;
|
|
ifeq LEND;
|
|
iload_1;
|
|
ifeq ENTRY3;
|
|
goto ENTRY4;
|
|
ENTRY3:
|
|
iload_2;
|
|
ifeq LEND;
|
|
ENTRY4:
|
|
goto ENTRY3;
|
|
|
|
LEND:
|
|
return;
|
|
}
|
|
|
|
static Method test_015a:"(I)I"
|
|
stack 20 locals 40
|
|
{
|
|
// Irreducible loop that loses second entry already during parsing
|
|
// and later becomes counted loop
|
|
iconst_0;
|
|
istore 30;
|
|
iconst_1;
|
|
istore 31;
|
|
|
|
ldc 0;
|
|
ifeq ENTRY1;
|
|
goto ENTRY2; // removed during parsing
|
|
|
|
ENTRY1:
|
|
iinc 30, 1; // trip count
|
|
ENTRY2:
|
|
iload 31;
|
|
ldc 3; // compute pow(3,x)
|
|
imul;
|
|
istore 31;
|
|
iload 30;
|
|
iload 0;
|
|
if_icmplt ENTRY1;
|
|
|
|
LEND:
|
|
iload 31;
|
|
ireturn;
|
|
}
|
|
|
|
static Method test_015b:"(I)I"
|
|
stack 20 locals 40
|
|
{
|
|
// Similar as test_015a, but the irreducible loop only loses the
|
|
// second entry during loop-opts (empty_loop), and the now
|
|
// reducible loop does not become a CountedLoop any more.
|
|
iconst_0;
|
|
istore 30;
|
|
iconst_1;
|
|
istore 31;
|
|
|
|
// empty_loop
|
|
ldc 10001;
|
|
istore 20;
|
|
iconst_0;
|
|
istore 21;
|
|
EMPTY_LOOP:
|
|
iinc 20, -1;
|
|
iinc 21, 1;
|
|
iload 21;
|
|
ldc 10001;
|
|
if_icmplt EMPTY_LOOP;
|
|
// var[20] == 0 // empty_loop (#1)
|
|
|
|
iload 20;
|
|
ifeq ENTRY1;
|
|
goto ENTRY2; // removed by empty_loop
|
|
|
|
ENTRY1:
|
|
iinc 30, 1; // trip count
|
|
ENTRY2:
|
|
iload 31;
|
|
ldc 3; // compute pow(3,x)
|
|
imul;
|
|
istore 31;
|
|
iload 30;
|
|
iload 0;
|
|
if_icmplt ENTRY1;
|
|
|
|
LEND:
|
|
iload 31;
|
|
ireturn;
|
|
}
|
|
|
|
static Method test_016:"(III)V"
|
|
stack 200 locals 300
|
|
{
|
|
// Similar to test_014b.
|
|
// Same sequence of irreducible loops collapsing to
|
|
// empty_loops, collapsing and cascading to the next
|
|
// loop.
|
|
// In addition: each of the the loops in that sequence
|
|
// controls an entry to a final big irreducible loop,
|
|
// which slowly collapses, losing entry after entry.
|
|
iload_0;
|
|
ifeq LEND; // runtime check, avoid code below
|
|
|
|
// setting up all variables for the loops below
|
|
iconst_0;
|
|
istore 100;
|
|
ldc 10001;
|
|
istore 101;
|
|
iconst_0;
|
|
istore 102;
|
|
ldc 10001;
|
|
istore 103;
|
|
iconst_0;
|
|
istore 104;
|
|
ldc 10001;
|
|
istore 105;
|
|
iconst_0;
|
|
istore 106;
|
|
ldc 10001;
|
|
istore 107;
|
|
iconst_0;
|
|
istore 108;
|
|
ldc 10001;
|
|
istore 109;
|
|
iconst_0;
|
|
istore 110;
|
|
ldc 10001;
|
|
istore 111;
|
|
iconst_0;
|
|
istore 112;
|
|
ldc 10001;
|
|
istore 113;
|
|
iconst_0;
|
|
istore 114;
|
|
ldc 10001;
|
|
istore 115;
|
|
|
|
iconst_0; // collapse during parsing
|
|
ifeq ENTRY00;
|
|
goto ENTRY01;
|
|
ENTRY00:
|
|
iinc 100, 1;
|
|
ENTRY01:
|
|
iinc 101, -1;
|
|
iload 100;
|
|
ldc 10001;
|
|
if_icmplt ENTRY00;
|
|
// var[101] == 0 // empty_loop (#1)
|
|
|
|
iload 101; // from last empty_loop
|
|
ifeq ENTRY02;
|
|
goto ENTRY03;
|
|
ENTRY02:
|
|
iinc 102, 1;
|
|
ENTRY03:
|
|
iinc 103, -1;
|
|
iload 102;
|
|
ldc 10001;
|
|
if_icmplt ENTRY02;
|
|
// var[103] == 0 // empty_loop (#2)
|
|
|
|
iload 103; // from last empty_loop
|
|
ifeq ENTRY04;
|
|
goto ENTRY05;
|
|
ENTRY04:
|
|
iinc 104, 1;
|
|
ENTRY05:
|
|
iinc 105, -1;
|
|
iload 104;
|
|
ldc 10001;
|
|
if_icmplt ENTRY04;
|
|
// var[105] == 0 // empty_loop (#3)
|
|
|
|
iload 105; // from last empty_loop
|
|
ifeq ENTRY06;
|
|
goto ENTRY07;
|
|
ENTRY06:
|
|
iinc 106, 1;
|
|
ENTRY07:
|
|
iinc 107, -1;
|
|
iload 106;
|
|
ldc 10001;
|
|
if_icmplt ENTRY06;
|
|
// var[107] == 0 // empty_loop (#4)
|
|
|
|
iload 107; // from last empty_loop
|
|
ifeq ENTRY08;
|
|
goto ENTRY09;
|
|
ENTRY08:
|
|
iinc 108, 1;
|
|
ENTRY09:
|
|
iinc 109, -1;
|
|
iload 108;
|
|
ldc 10001;
|
|
if_icmplt ENTRY08;
|
|
// var[109] == 0 // empty_loop (#5)
|
|
|
|
iload 109; // from last empty_loop
|
|
ifeq ENTRY10;
|
|
goto ENTRY11;
|
|
ENTRY10:
|
|
iinc 110, 1;
|
|
ENTRY11:
|
|
iinc 111, -1;
|
|
iload 110;
|
|
ldc 10001;
|
|
if_icmplt ENTRY10;
|
|
// var[111] == 0 // empty_loop (#6)
|
|
|
|
iload 111; // from last empty_loop
|
|
ifeq ENTRY12;
|
|
goto ENTRY13;
|
|
ENTRY12:
|
|
iinc 112, 1;
|
|
ENTRY13:
|
|
iinc 113, -1;
|
|
iload 112;
|
|
ldc 10001;
|
|
if_icmplt ENTRY12;
|
|
// var[113] == 0 // empty_loop (#7)
|
|
|
|
iload 113; // from last empty_loop
|
|
ifeq ENTRY14;
|
|
goto ENTRY15;
|
|
ENTRY14:
|
|
iinc 114, 1;
|
|
ENTRY15:
|
|
iinc 115, -1;
|
|
iload 114;
|
|
ldc 10001;
|
|
if_icmplt ENTRY14;
|
|
// var[115] == 0 // empty_loop (#8)
|
|
|
|
// final loop, every empty_loop from above
|
|
// controls one of the entries
|
|
iconst_0;
|
|
istore 200;
|
|
iload 101;
|
|
ifne BOTTOM1;
|
|
iload 103;
|
|
ifne BOTTOM2;
|
|
iload 105;
|
|
ifne BOTTOM3;
|
|
iload 107;
|
|
ifne BOTTOM4;
|
|
iload 109;
|
|
ifne BOTTOM5;
|
|
iload 111;
|
|
ifne BOTTOM6;
|
|
iload 113;
|
|
ifne BOTTOM7;
|
|
iload 115;
|
|
ifeq LEND;
|
|
// finally cut off completely
|
|
// trigger irreducible loop removal
|
|
iload 1;
|
|
ifeq BOTTOM8;
|
|
goto BOTTOM0;
|
|
|
|
BOTTOM0:
|
|
iinc 200, 1;
|
|
BOTTOM1:
|
|
iinc 200, 2;
|
|
BOTTOM2:
|
|
iinc 200, 4;
|
|
BOTTOM3:
|
|
iinc 200, 8;
|
|
BOTTOM4:
|
|
iinc 200, 16;
|
|
BOTTOM5:
|
|
iinc 200, 32;
|
|
BOTTOM6:
|
|
iinc 200, 64;
|
|
BOTTOM7:
|
|
iinc 200, 128;
|
|
BOTTOM8:
|
|
iload 200;
|
|
ldc 30003;
|
|
if_icmpgt LEND;
|
|
goto BOTTOM1;
|
|
|
|
LEND:
|
|
return;
|
|
}
|
|
|
|
static Method test_017:"(III)V"
|
|
stack 20 locals 20
|
|
{
|
|
// Triggers partial_peel and strip-mining for a loop
|
|
// where the head was marked is_in_irreducible_loop
|
|
|
|
iload 2;
|
|
ifeq LEND; // skip code
|
|
|
|
iload 1;
|
|
ifgt L2;
|
|
L1:
|
|
nop;
|
|
L2:
|
|
iinc 1, 1;
|
|
iload 1;
|
|
ifgt L1;
|
|
iload 0;
|
|
ifne LEND;
|
|
goto L2;
|
|
|
|
LEND:
|
|
return;
|
|
}
|
|
|
|
static Method test_018:"(I)V"
|
|
stack 20 locals 20
|
|
{
|
|
// ciTypeFlow: infinite loop has no parent loop
|
|
iload_0;
|
|
ifeq LEND; // skip code
|
|
LOOP:
|
|
goto LOOP; // infinite loop
|
|
LEND:
|
|
return;
|
|
}
|
|
|
|
static Method test_019:"(IIII)V"
|
|
stack 20 locals 20
|
|
{
|
|
// may triggers split_flow_path, because of that aconst_null
|
|
|
|
iload_0;
|
|
ifeq LEND; // skip code
|
|
|
|
aconst_null; // this has a strange side-effect
|
|
goto LOOP3;
|
|
|
|
LOOP1:
|
|
nop;
|
|
LOOP2:
|
|
iload 1;
|
|
ifne LOOP1;
|
|
LOOP3:
|
|
iload 2;
|
|
ifge LOOP2;
|
|
LOOP4:
|
|
iload 3;
|
|
ifle LOOP1;
|
|
iconst_m1;
|
|
iflt LOOP2;
|
|
goto LOOP4;
|
|
|
|
LEND:
|
|
return;
|
|
}
|
|
|
|
static Method test_020:"(IIIII)V"
|
|
stack 20 locals 40
|
|
{
|
|
// Get infinite loop at some point that has no NeverBranch node
|
|
iload_0;
|
|
ifeq LEND; // skip
|
|
|
|
iconst_0;
|
|
istore 20;
|
|
LOOP1:
|
|
iload 1;
|
|
ifeq LOOP3;
|
|
LOOP2:
|
|
iconst_0;
|
|
ifne LEND;
|
|
LOOP3:
|
|
iload 20;
|
|
istore 30; // old
|
|
iload 2;
|
|
iflt LOOP4;
|
|
iconst_1;
|
|
istore 20; // overwrite new
|
|
iload 30;
|
|
iload 3;
|
|
if_icmpgt LOOP1;
|
|
goto LOOP3;
|
|
LOOP4:
|
|
iload 4;
|
|
iflt LOOP2;
|
|
goto LOOP4;
|
|
|
|
LEND:
|
|
return;
|
|
}
|
|
|
|
static Method test_021:"(IIIIII)V"
|
|
stack 20 locals 20
|
|
{
|
|
// Produces a graph where one node is originally located inside
|
|
// a reducible loop, but later that loop collapses, and exposes
|
|
// the node to the outerloop, which is irreducible.
|
|
iload_0;
|
|
ifeq LEND; // skip
|
|
|
|
L1:
|
|
iload 1;
|
|
ifgt MERGE;
|
|
L2:
|
|
iload 2;
|
|
ifge MERGE;
|
|
goto L1;
|
|
|
|
MERGE:
|
|
nop;
|
|
LOOP:
|
|
iload 3;
|
|
ifle L2;
|
|
iconst_0; // always true
|
|
ifeq LOOP;
|
|
iconst_0; // always true
|
|
ifeq LOOP;
|
|
INFTY:
|
|
goto INFTY; // infinite loop
|
|
|
|
LEND:
|
|
return;
|
|
}
|
|
|
|
static Method test_022a:"(IIII)V"
|
|
stack 20 locals 10
|
|
{
|
|
// see test_022b for explanation
|
|
iload_0;
|
|
ifeq LEND;
|
|
|
|
aconst_null;
|
|
astore 9;
|
|
iconst_1;
|
|
ifeq ENTRY1; // eventually collapses
|
|
goto ENTRY2;
|
|
ENTRY1:
|
|
iconst_0;
|
|
ifeq LOOP;
|
|
ENTRY2:
|
|
iload 1;
|
|
ifge LOOP;
|
|
goto ENTRY1;
|
|
|
|
LOOP:
|
|
// head is split -> new irreducible loop
|
|
aload 9;
|
|
pop;
|
|
iconst_0;
|
|
iflt LOOP;
|
|
aconst_null;
|
|
astore 9;
|
|
iload 2;
|
|
ifeq LEND;
|
|
goto LOOP;
|
|
|
|
LEND:
|
|
return;
|
|
}
|
|
|
|
static Method test_022b:"(II)V"
|
|
stack 20 locals 20
|
|
{
|
|
// Triggered split_flow_path for a reducible loop that had multiple fall-in
|
|
// edges. The fall-in edges were split over two Phis/Regions, creating a new
|
|
// undetected irreducible loop. This only seems to happen when there are other
|
|
// irreducible loops present, as it changes the merge-order during parsing.
|
|
// If there are only reducible loops present, we merge the fall-in in a region
|
|
// prior to the loop-head, as far as I understand.
|
|
iload_0;
|
|
ifeq LEND; // skip
|
|
|
|
aconst_null;
|
|
astore 9;
|
|
iload 1;
|
|
ifeq OTHER;
|
|
LOOP:
|
|
iconst_0;
|
|
iflt LEND; // false - old exit?
|
|
aload 9;
|
|
pop;
|
|
iconst_0;
|
|
ifne LOOP; // false
|
|
goto LOOP;
|
|
|
|
OTHER:
|
|
iconst_m1;
|
|
ifeq ENTRY1; // false
|
|
goto ENTRY2;
|
|
ENTRY1:
|
|
iconst_0;
|
|
ifeq LOOP; // true
|
|
ENTRY2:
|
|
goto ENTRY1;
|
|
|
|
LEND:
|
|
return;
|
|
}
|
|
|
|
static Method test_023:"(I)V"
|
|
stack 20 locals 20
|
|
{
|
|
iload_0;
|
|
ifeq LEND;
|
|
|
|
iconst_0;
|
|
istore 7;
|
|
iconst_0;
|
|
ifne L4;
|
|
L2:
|
|
nop;
|
|
L4:
|
|
iload 7;
|
|
ifeq L12;
|
|
L12:
|
|
iconst_0;
|
|
ifeq L2;
|
|
goto L12;
|
|
|
|
LEND:
|
|
return;
|
|
}
|
|
|
|
static Method test_024_inline:"(I)I"
|
|
stack 20 locals 10
|
|
{
|
|
iload_0;
|
|
ldc 3;
|
|
irem;
|
|
ifeq SKIP; // if (v % 3 == 0)
|
|
|
|
// (v % 5)
|
|
iload_0;
|
|
ldc 5;
|
|
irem;
|
|
istore_0;
|
|
goto LEND;
|
|
|
|
SKIP:
|
|
// (v % 7)
|
|
iload_0;
|
|
ldc 7;
|
|
irem;
|
|
istore_0;
|
|
goto LEND;
|
|
|
|
LEND:
|
|
iload_0;
|
|
ireturn;
|
|
}
|
|
|
|
static Method test_024:"()I"
|
|
stack 20 locals 10
|
|
{
|
|
// Outer loop, irreducible inside, and inline call
|
|
// Test that regions in inline are also handled as
|
|
// they are nested in the irreducible loop
|
|
iconst_0;
|
|
istore 1; // i = 0
|
|
iconst_0;
|
|
istore 3; // x = 0
|
|
|
|
LOOP:
|
|
iconst_0;
|
|
istore 2; // j = 0
|
|
iload 1;
|
|
ldc 2;
|
|
irem;
|
|
ifeq ENTRY1; // if (i % 2 == 0)
|
|
goto ENTRY2;
|
|
|
|
ENTRY1:
|
|
iinc 2, 1; // j++
|
|
ENTRY2:
|
|
iload 2;
|
|
invokestatic Method test_024_inline:"(I)I";
|
|
iload 3;
|
|
iadd;
|
|
istore 3;
|
|
iload 2;
|
|
ldc 1000;
|
|
if_icmplt ENTRY1; // while (j < 1000)
|
|
|
|
iinc 1, 1; // i++
|
|
iload 1;
|
|
ldc 10000;
|
|
if_icmplt LOOP; // while (i < 10000)
|
|
|
|
LEND:
|
|
iload 3;
|
|
ireturn;
|
|
}
|
|
}
|