b02e4d4aba
Change C2 specific test to be executed only with server compiler. Reviewed-by: roland, kvn, thartmann
1864 lines
49 KiB
Java
1864 lines
49 KiB
Java
/*
|
|
* Copyright (c) 2020, 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.
|
|
*/
|
|
|
|
/*
|
|
* @test
|
|
* @requires vm.compiler2.enabled
|
|
* @bug 8233033 8235984 8240227
|
|
* @summary Tests if partially peeled statements are not executed before the loop predicates by bailing out of loop unswitching.
|
|
*
|
|
* @run main/othervm -Xbatch -XX:LoopStripMiningIter=0
|
|
* -XX:CompileCommand=compileonly,compiler.loopopts.PartialPeelingUnswitch::test*
|
|
* -XX:CompileCommand=dontinline,compiler.loopopts.PartialPeelingUnswitch::dontInline*
|
|
* compiler.loopopts.PartialPeelingUnswitch
|
|
* @run main/othervm -Xbatch -Xcomp -XX:LoopStripMiningIter=0
|
|
* -XX:CompileCommand=compileonly,compiler.loopopts.PartialPeelingUnswitch::test*
|
|
* -XX:CompileCommand=dontinline,compiler.loopopts.PartialPeelingUnswitch::dontInline*
|
|
* compiler.loopopts.PartialPeelingUnswitch
|
|
* @run main/othervm -Xbatch
|
|
* -XX:CompileCommand=compileonly,compiler.loopopts.PartialPeelingUnswitch::test*
|
|
* -XX:CompileCommand=dontinline,compiler.loopopts.PartialPeelingUnswitch::dontInline*
|
|
* compiler.loopopts.PartialPeelingUnswitch
|
|
* @run main/othervm -Xbatch -Xcomp
|
|
* -XX:CompileCommand=compileonly,compiler.loopopts.PartialPeelingUnswitch::test*
|
|
* -XX:CompileCommand=dontinline,compiler.loopopts.PartialPeelingUnswitch::dontInline*
|
|
* compiler.loopopts.PartialPeelingUnswitch
|
|
* @run main/othervm -Xbatch
|
|
* -XX:CompileCommand=compileonly,compiler.loopopts.PartialPeelingUnswitch::*
|
|
* -XX:CompileCommand=dontinline,compiler.loopopts.PartialPeelingUnswitch::dontInline*
|
|
* compiler.loopopts.PartialPeelingUnswitch
|
|
* @run main/othervm -Xbatch -Xcomp
|
|
* -XX:CompileCommand=compileonly,compiler.loopopts.PartialPeelingUnswitch::*
|
|
* -XX:CompileCommand=dontinline,compiler.loopopts.PartialPeelingUnswitch::dontInline*
|
|
* compiler.loopopts.PartialPeelingUnswitch
|
|
*/
|
|
|
|
package compiler.loopopts;
|
|
|
|
public class PartialPeelingUnswitch {
|
|
|
|
public static int iFld;
|
|
public static int w = 88;
|
|
public static int x = 42;
|
|
public static int y = 31;
|
|
public static int z = 22;
|
|
public static int val = 34;
|
|
public static final int iCon = 20;
|
|
|
|
public static int[] iArr = new int[10];
|
|
|
|
public int test() {
|
|
/*
|
|
* The inner loop of this test is first partially peeled and then unswitched. An uncommon trap is hit in one
|
|
* of the cloned loop predicates for the fast loop (set up at unswitching stage). The only partially peeled
|
|
* statement "iFld += 7" was wrongly executed before the predicates (and before the loop itself).
|
|
* When hitting the uncommon trap, "iFld >>= 1" was not yet executed. As a result, the interpreter directly
|
|
* reexecuted "iFld += 7" again. This resulted in a wrong result for "iFld". The fix in 8233033 makes peeled
|
|
* statements control dependant on the cloned loop predicates such that they are executed after them. However,
|
|
* some cases are not handled properly. For now, the new fix in 8235984 just bails out of loop unswitching.
|
|
*/
|
|
iFld = 13;
|
|
for (int i = 0; i < 8; i++) {
|
|
int j = 10;
|
|
while (--j > 0) {
|
|
iFld += -7;
|
|
switch ((i * 5) + 102) {
|
|
case 120:
|
|
break;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
break;
|
|
default:
|
|
iFld >>= 1;
|
|
}
|
|
}
|
|
}
|
|
return iFld;
|
|
}
|
|
|
|
public int test2() {
|
|
/*
|
|
* Same nested loop structure as in test() but with more statements that are partially peeled from the inner loop.
|
|
* Afterwards the inner loop is unswitched.
|
|
*/
|
|
iFld = 13;
|
|
int k = 0;
|
|
for (int i = 0; i < 8; i++) {
|
|
int j = 10;
|
|
while (--j > 0) {
|
|
// All statements before the switch expression are partially peeled
|
|
iFld += -7;
|
|
x = y + iFld;
|
|
y = iArr[5];
|
|
k = 6;
|
|
iArr[5] = 5;
|
|
iArr[6] += 23;
|
|
iArr[7] = iArr[8] + iArr[6];
|
|
iArr[j] = 34;
|
|
switch ((i * 5) + 102) {
|
|
case 120:
|
|
break;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
break;
|
|
default:
|
|
iFld >>= 1;
|
|
}
|
|
}
|
|
}
|
|
return iFld + k;
|
|
}
|
|
|
|
public int test3() {
|
|
iFld = 13;
|
|
if (z < 34) {
|
|
z = 34;
|
|
}
|
|
|
|
for (int i = 0; i < 8; i++) {
|
|
int j = 10;
|
|
while (--j > 0) {
|
|
iFld += -7;
|
|
iArr[5] = 8;
|
|
x = iArr[6];
|
|
y = x;
|
|
for (int k = 50; k < 51; k++) {
|
|
x = iArr[7];
|
|
}
|
|
switch ((i * 5) + 102) {
|
|
case 120:
|
|
return iFld;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
break;
|
|
default:
|
|
if (iFld == -7) {
|
|
return iFld;
|
|
}
|
|
z = iArr[5];
|
|
iFld >>= 1;
|
|
}
|
|
}
|
|
iArr[5] = 34;
|
|
dontInline(iArr[5]);
|
|
}
|
|
return iFld;
|
|
}
|
|
|
|
public int test4() {
|
|
iFld = 13;
|
|
if (z < 34) {
|
|
z = 34;
|
|
}
|
|
|
|
for (int i = 0; i < 8; i++) {
|
|
int j = 10;
|
|
while (--j > 0) {
|
|
iFld += -7;
|
|
iArr[5] = 8;
|
|
x = iArr[6];
|
|
y = x;
|
|
for (int k = 50; k < 51; k++) {
|
|
x = iArr[7];
|
|
}
|
|
switch ((i * 5) + 102) {
|
|
case 120:
|
|
return iFld;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
break;
|
|
default:
|
|
if (iFld == -7) {
|
|
return iFld;
|
|
}
|
|
z = iArr[5];
|
|
iFld >>= 1;
|
|
}
|
|
}
|
|
iArr[5] = 34;
|
|
}
|
|
return iFld;
|
|
}
|
|
|
|
public int test5() {
|
|
iFld = 13;
|
|
for (int i = 0; i < 8; i++) {
|
|
int j = 10;
|
|
while (--j > 0) {
|
|
iFld += -7;
|
|
iArr[5] = 8;
|
|
x = iArr[6];
|
|
y = x;
|
|
for (int k = 50; k < 51; k++) {
|
|
x = iArr[7];
|
|
}
|
|
switch ((i * 5) + 102) {
|
|
case 120:
|
|
return iFld;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
break;
|
|
default:
|
|
iFld >>= 1;
|
|
}
|
|
}
|
|
}
|
|
return iFld;
|
|
}
|
|
|
|
public int test6() {
|
|
iFld = 13;
|
|
for (int i = 0; i < 8; i++) {
|
|
int j = 10;
|
|
while (--j > 0) {
|
|
iFld += -7;
|
|
iArr[5] = 8;
|
|
x = iArr[6];
|
|
y = x;
|
|
switch ((i * 5) + 102) {
|
|
case 120:
|
|
return iFld;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
break;
|
|
default:
|
|
iFld >>= 1;
|
|
}
|
|
}
|
|
}
|
|
return iFld;
|
|
}
|
|
|
|
public int test7() {
|
|
iFld = 13;
|
|
for (int i = 0; i < 8; i++) {
|
|
int j = 10;
|
|
while (--j > 0) {
|
|
iFld += -7;
|
|
iArr[5] = 8;
|
|
switch ((i * 5) + 102) {
|
|
case 120:
|
|
return iFld;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
break;
|
|
default:
|
|
iFld >>= 1;
|
|
}
|
|
}
|
|
}
|
|
return iFld;
|
|
}
|
|
|
|
public int test8() {
|
|
|
|
iFld = 13;
|
|
for (int i = 0; i < 8; i++) {
|
|
int j = 50;
|
|
while (--j > 0) {
|
|
// All statements before the switch expression are partially peeled
|
|
iFld += -7;
|
|
x = y + iFld;
|
|
y = iArr[5];
|
|
iArr[5] = 5;
|
|
iArr[6] += 23;
|
|
iArr[7] = iArr[8] + iArr[6];
|
|
switch ((val * 5) + 102) {
|
|
case 120:
|
|
break;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
break;
|
|
default:
|
|
iFld >>= 1;
|
|
}
|
|
}
|
|
}
|
|
return iFld;
|
|
}
|
|
|
|
|
|
public int test9() {
|
|
iFld = 13;
|
|
for (int i = 0; i < 8; i++) {
|
|
int j = 10;
|
|
while (--j > 0) {
|
|
iFld += -7;
|
|
iArr[4] = 8;
|
|
x = iArr[5];
|
|
switch ((i * 5) + 102) {
|
|
case 120:
|
|
return iFld + 1;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
break;
|
|
default:
|
|
iFld >>= 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
return iFld;
|
|
}
|
|
|
|
public int test10() {
|
|
if (z < 34) {
|
|
z = 34;
|
|
}
|
|
|
|
iFld = 13;
|
|
for (int i = 0; i < 80; i++) {
|
|
int j = 50;
|
|
while (--j > 0) {
|
|
iFld += -7;
|
|
iArr[4] = 8;
|
|
x = iArr[5];
|
|
switch ((i * 5) + 102) {
|
|
case 120:
|
|
break;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
break;
|
|
default:
|
|
iFld >>= 1;
|
|
}
|
|
}
|
|
}
|
|
if (z == 34) {
|
|
x = iArr[6];
|
|
}
|
|
return iFld;
|
|
}
|
|
|
|
|
|
public int test11Xcomp() {
|
|
if (z < 34) {
|
|
z = 34;
|
|
}
|
|
|
|
iFld = 13;
|
|
for (int i = 0; i < 80; i++) {
|
|
int j = 50;
|
|
while (--j > 0) {
|
|
iFld += -7;
|
|
iArr[4] = 8;
|
|
x = iArr[5];
|
|
switch ((i * 5) + 102) {
|
|
case 120:
|
|
break;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
break;
|
|
default:
|
|
iFld >>= 1;
|
|
}
|
|
if (z == 34) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (z == 34) {
|
|
x = iArr[6];
|
|
}
|
|
return iFld;
|
|
}
|
|
|
|
// Phi with multiple inputs from same peeled node
|
|
public int test12Xcomp() {
|
|
if (z < 34) {
|
|
z = 34;
|
|
}
|
|
|
|
iFld = 13;
|
|
for (int i = 0; i < 80; i++) {
|
|
int j = 50;
|
|
while (--j > 0) {
|
|
iFld += -7;
|
|
iArr[4] = 8;
|
|
x = iArr[5];
|
|
switch ((i * 5) + 102) {
|
|
case 120:
|
|
break;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
return z;
|
|
case 106:
|
|
return y;
|
|
case 111:
|
|
return x;
|
|
default:
|
|
iFld >>= 1;
|
|
}
|
|
w = 45;
|
|
}
|
|
|
|
}
|
|
if (z == 34) {
|
|
x = iArr[6];
|
|
}
|
|
return iFld;
|
|
}
|
|
|
|
public int test13Xcomp() {
|
|
if (z < 34) {
|
|
z = 34;
|
|
}
|
|
|
|
iFld = 13;
|
|
for (int i = 0; i < 80; i++) {
|
|
int j = 50;
|
|
while (--j > 0) {
|
|
iFld += -7;
|
|
iArr[4] = 8;
|
|
x = iArr[5];
|
|
switch ((i * 5) + 102) {
|
|
case 120:
|
|
break;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
break;
|
|
default:
|
|
iFld >>= 1;
|
|
}
|
|
w = 45;
|
|
}
|
|
|
|
}
|
|
if (z == 34) {
|
|
x = iArr[6];
|
|
}
|
|
return iFld;
|
|
}
|
|
|
|
// Triggers after peeling with Xcomp
|
|
public int test14Peel() {
|
|
iFld = 13;
|
|
for (int i = 0; i < 8; i++) {
|
|
int j = 10;
|
|
while (--j > 0) {
|
|
iFld += -7;
|
|
iArr[4] = 8;
|
|
x = iArr[5];
|
|
switch ((i * 5) + 102) {
|
|
case 120:
|
|
return iFld;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
break;
|
|
default:
|
|
iFld >>= 1;
|
|
}
|
|
iFld = 3;
|
|
}
|
|
}
|
|
y = iArr[4];
|
|
x = iArr[6];
|
|
|
|
return iFld;
|
|
}
|
|
|
|
|
|
public int test15earlyCtrl() {
|
|
iFld = 13;
|
|
if (z < 34) {
|
|
z = 34;
|
|
}
|
|
|
|
for (int i = 0; i < 8; i++) {
|
|
int j = 10;
|
|
while (--j > 0) {
|
|
iFld += -7;
|
|
iArr[5] = 8;
|
|
x = iArr[6];
|
|
y = x;
|
|
x = iArr[7];
|
|
switch ((i * 5) + 102) {
|
|
case 120:
|
|
return iFld;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
break;
|
|
default:
|
|
if (iFld == -7) {
|
|
return iFld;
|
|
}
|
|
z = iArr[5];
|
|
iFld >>= 1;
|
|
}
|
|
}
|
|
if (iFld == 7) {
|
|
iArr[3] = 3;
|
|
}
|
|
dontInline(7);
|
|
iArr[5] = 34;
|
|
}
|
|
return iFld;
|
|
}
|
|
|
|
// Load after loop -> LoadI after loop from peeled StoreI
|
|
public int test16() {
|
|
iFld = 13;
|
|
if (z < 34) {
|
|
z = 34;
|
|
}
|
|
|
|
for (int i = 0; i < 8; i++) {
|
|
int j = 60;
|
|
while (--j > 0) {
|
|
iFld += -7;
|
|
y += iFld + 1;
|
|
|
|
iArr[5] = 8;
|
|
x = iArr[6];
|
|
x = iArr[7];
|
|
switch ((i * 5) + 102) {
|
|
case 120:
|
|
return iFld;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
break;
|
|
default:
|
|
if (iFld == -7) {
|
|
return iFld;
|
|
}
|
|
z = iArr[5];
|
|
iFld >>= 1;
|
|
}
|
|
}
|
|
w = iArr[9];
|
|
if (iFld == 7) {
|
|
iArr[3] = 3;
|
|
}
|
|
dontInline(7);
|
|
iArr[5] = 34;
|
|
}
|
|
return iFld;
|
|
}
|
|
|
|
// Region 13 before return, which region to choose for MergeMem?
|
|
public int test17Xcomp() {
|
|
A p = dontInlineGetA();
|
|
if (z < 34) {
|
|
z = 34;
|
|
}
|
|
|
|
iFld = 13;
|
|
for (int i = 0; i < 80; i++) {
|
|
int j = 50;
|
|
while (--j > 0) {
|
|
iFld += -7;
|
|
iArr[4] = 8;
|
|
x = iArr[5];
|
|
y = p.i;
|
|
switch ((i * 5) + 102) {
|
|
case 120:
|
|
break;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
return z;
|
|
case 106:
|
|
return y;
|
|
case 111:
|
|
return x;
|
|
default:
|
|
iFld >>= 1;
|
|
}
|
|
w = 45;
|
|
}
|
|
|
|
}
|
|
if (z == 34) {
|
|
x = iArr[6];
|
|
}
|
|
return iFld;
|
|
}
|
|
|
|
// Region 13 before return, which region to choose for MergeMem?
|
|
public int test18Xcomp() {
|
|
if (z < 34) {
|
|
z = 34;
|
|
}
|
|
|
|
iFld = 13;
|
|
for (int i = 0; i < 80; i++) {
|
|
int j = 50;
|
|
while (--j > 0) {
|
|
iFld += -7;
|
|
iArr[4] = 8;
|
|
x = iArr[5];
|
|
y = 85;
|
|
switch ((i * 5) + 102) {
|
|
case 120:
|
|
break;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
return z;
|
|
case 106:
|
|
if (z == 34) {
|
|
x = iArr[7];
|
|
}
|
|
return y;
|
|
case 111:
|
|
return x;
|
|
default:
|
|
iFld >>= 1;
|
|
}
|
|
w = 45;
|
|
}
|
|
|
|
}
|
|
|
|
if (z == 34) {
|
|
x = iArr[6];
|
|
}
|
|
return iFld;
|
|
}
|
|
|
|
public int test19Xcomp() {
|
|
if (z < 34) {
|
|
z = 34;
|
|
}
|
|
|
|
iFld = 13;
|
|
for (int i = 0; i < 80; i++) {
|
|
int j = 50;
|
|
while (--j > 0) {
|
|
iFld += -7;
|
|
iArr[4] = 8;
|
|
x = iArr[5]+ iArr[6];
|
|
y = 85;
|
|
switch ((i * 5) + 102) {
|
|
case 120:
|
|
break;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
break;
|
|
case 106:
|
|
if (z == 34) {
|
|
x = iArr[7];
|
|
}
|
|
return y;
|
|
case 111:
|
|
return x;
|
|
default:
|
|
iFld >>= 1;
|
|
}
|
|
w = 45;
|
|
}
|
|
}
|
|
|
|
if (z == 34) {
|
|
iArr[7] = 34;
|
|
}
|
|
return iFld;
|
|
}
|
|
|
|
public int test20() {
|
|
if (z < 34) {
|
|
z = 34;
|
|
}
|
|
|
|
iFld = 13;
|
|
for (int i = 0; i < 80; i++) {
|
|
int j = 50;
|
|
while (--j > 0) {
|
|
iFld += -7;
|
|
iArr[4] = 8;
|
|
x = iArr[5];
|
|
switch ((i * 5) + 102) {
|
|
case 120:
|
|
break;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
break;
|
|
default:
|
|
iFld >>= 1;
|
|
}
|
|
}
|
|
x = iArr[6];
|
|
}
|
|
if (z == 34) {
|
|
x = iArr[7];
|
|
}
|
|
return iFld;
|
|
}
|
|
|
|
|
|
public int test21() {
|
|
if (z < 34) {
|
|
z = 34;
|
|
}
|
|
|
|
iFld = 13;
|
|
for (int i = 0; i < 80; i++) {
|
|
int j = 50;
|
|
while (--j > 0) {
|
|
iFld += -7;
|
|
iArr[4] = 8;
|
|
x = iArr[5];
|
|
switch ((i * 5) + 102) {
|
|
case 120:
|
|
break;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
break;
|
|
default:
|
|
iFld >>= 1;
|
|
}
|
|
}
|
|
x = iArr[6];
|
|
}
|
|
if (z == 34) {
|
|
y = iArr[7];
|
|
}
|
|
return iFld;
|
|
}
|
|
|
|
public int testNoOuter() {
|
|
iFld = 13;
|
|
int j = 10;
|
|
while (--j > 0) {
|
|
iFld += -7;
|
|
switch ((iCon * 5) + 102) {
|
|
case 120:
|
|
break;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
break;
|
|
default:
|
|
iFld >>= 1;
|
|
}
|
|
}
|
|
return iFld;
|
|
}
|
|
|
|
public int test2NoOuter() {
|
|
/*
|
|
* Same nested loop structure as in test() but with more statements that are partially peeled from the inner loop.
|
|
* Afterwards the inner loop is unswitched.
|
|
*/
|
|
iFld = 13;
|
|
int k = 0;
|
|
int j = 10;
|
|
while (--j > 0) {
|
|
// All statements before the switch expression are partially peeled
|
|
iFld += -7;
|
|
x = y + iFld;
|
|
y = iArr[5];
|
|
k = 6;
|
|
iArr[5] = 5;
|
|
iArr[6] += 23;
|
|
iArr[7] = iArr[8] + iArr[6];
|
|
iArr[j] = 34;
|
|
switch ((iCon * 5) + 102) {
|
|
case 120:
|
|
break;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
break;
|
|
default:
|
|
iFld >>= 1;
|
|
}
|
|
}
|
|
return iFld + k;
|
|
}
|
|
|
|
public int test3NoOuter() {
|
|
iFld = 13;
|
|
if (z < 34) {
|
|
z = 34;
|
|
}
|
|
|
|
int j = 10;
|
|
while (--j > 0) {
|
|
iFld += -7;
|
|
iArr[5] = 8;
|
|
x = iArr[6];
|
|
y = x;
|
|
for (int k = 50; k < 51; k++) {
|
|
x = iArr[7];
|
|
}
|
|
switch ((iCon * 5) + 102) {
|
|
case 120:
|
|
return iFld;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
break;
|
|
default:
|
|
if (iFld == -7) {
|
|
return iFld;
|
|
}
|
|
z = iArr[5];
|
|
iFld >>= 1;
|
|
}
|
|
}
|
|
iArr[5] = 34;
|
|
dontInline(iArr[5]);
|
|
return iFld;
|
|
}
|
|
|
|
public int test4NoOuter() {
|
|
iFld = 13;
|
|
if (z < 34) {
|
|
z = 34;
|
|
}
|
|
|
|
int j = 10;
|
|
while (--j > 0) {
|
|
iFld += -7;
|
|
iArr[5] = 8;
|
|
x = iArr[6];
|
|
y = x;
|
|
for (int k = 50; k < 51; k++) {
|
|
x = iArr[7];
|
|
}
|
|
switch ((iCon * 5) + 102) {
|
|
case 120:
|
|
return iFld;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
break;
|
|
default:
|
|
if (iFld == -7) {
|
|
return iFld;
|
|
}
|
|
z = iArr[5];
|
|
iFld >>= 1;
|
|
}
|
|
}
|
|
iArr[5] = 34;
|
|
return iFld;
|
|
}
|
|
|
|
public int test5NoOuter() {
|
|
iFld = 13;
|
|
int j = 10;
|
|
while (--j > 0) {
|
|
iFld += -7;
|
|
iArr[5] = 8;
|
|
x = iArr[6];
|
|
y = x;
|
|
for (int k = 50; k < 51; k++) {
|
|
x = iArr[7];
|
|
}
|
|
switch ((iCon * 5) + 102) {
|
|
case 120:
|
|
return iFld;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
break;
|
|
default:
|
|
iFld >>= 1;
|
|
}
|
|
}
|
|
return iFld;
|
|
}
|
|
|
|
public int test6NoOuter() {
|
|
iFld = 13;
|
|
int j = 10;
|
|
while (--j > 0) {
|
|
iFld += -7;
|
|
iArr[5] = 8;
|
|
x = iArr[6];
|
|
y = x;
|
|
switch ((iCon * 5) + 102) {
|
|
case 120:
|
|
return iFld;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
break;
|
|
default:
|
|
iFld >>= 1;
|
|
}
|
|
}
|
|
return iFld;
|
|
}
|
|
|
|
public int test7NoOuter() {
|
|
iFld = 13;
|
|
int j = 10;
|
|
while (--j > 0) {
|
|
iFld += -7;
|
|
iArr[5] = 8;
|
|
switch ((iCon * 5) + 102) {
|
|
case 120:
|
|
return iFld;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
break;
|
|
default:
|
|
iFld >>= 1;
|
|
}
|
|
}
|
|
return iFld;
|
|
}
|
|
|
|
public int test8NoOuter() {
|
|
|
|
iFld = 13;
|
|
int j = 50;
|
|
while (--j > 0) {
|
|
// All statements before the switch expression are partially peeled
|
|
iFld += -7;
|
|
x = y + iFld;
|
|
y = iArr[5];
|
|
iArr[5] = 5;
|
|
iArr[6] += 23;
|
|
iArr[7] = iArr[8] + iArr[6];
|
|
switch ((val * 5) + 102) {
|
|
case 120:
|
|
break;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
break;
|
|
default:
|
|
iFld >>= 1;
|
|
}
|
|
}
|
|
return iFld;
|
|
}
|
|
|
|
|
|
public int test9NoOuter() {
|
|
iFld = 13;
|
|
int j = 10;
|
|
while (--j > 0) {
|
|
iFld += -7;
|
|
iArr[4] = 8;
|
|
x = iArr[5];
|
|
switch ((iCon * 5) + 102) {
|
|
case 120:
|
|
return iFld + 1;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
break;
|
|
default:
|
|
iFld >>= 1;
|
|
}
|
|
}
|
|
return iFld;
|
|
}
|
|
|
|
public int test10NoOuter() {
|
|
if (z < 34) {
|
|
z = 34;
|
|
}
|
|
|
|
iFld = 13;
|
|
int j = 50;
|
|
while (--j > 0) {
|
|
iFld += -7;
|
|
iArr[4] = 8;
|
|
x = iArr[5];
|
|
switch ((iCon * 5) + 102) {
|
|
case 120:
|
|
break;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
break;
|
|
default:
|
|
iFld >>= 1;
|
|
}
|
|
}
|
|
if (z == 34) {
|
|
x = iArr[6];
|
|
}
|
|
return iFld;
|
|
}
|
|
|
|
|
|
public int test11XcompNoOuter() {
|
|
if (z < 34) {
|
|
z = 34;
|
|
}
|
|
|
|
iFld = 13;
|
|
int j = 50;
|
|
while (--j > 0) {
|
|
iFld += -7;
|
|
iArr[4] = 8;
|
|
x = iArr[5];
|
|
switch ((iCon * 5) + 102) {
|
|
case 120:
|
|
break;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
break;
|
|
default:
|
|
iFld >>= 1;
|
|
}
|
|
if (z == 34) {
|
|
break;
|
|
}
|
|
}
|
|
if (z == 34) {
|
|
x = iArr[6];
|
|
}
|
|
return iFld;
|
|
}
|
|
|
|
// Phi with multiple inputs from same peeled node
|
|
public int test12XcompNoOuter() {
|
|
if (z < 34) {
|
|
z = 34;
|
|
}
|
|
|
|
iFld = 13;
|
|
int j = 50;
|
|
while (--j > 0) {
|
|
iFld += -7;
|
|
iArr[4] = 8;
|
|
x = iArr[5];
|
|
switch ((iCon * 5) + 102) {
|
|
case 120:
|
|
break;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
return z;
|
|
case 106:
|
|
return y;
|
|
case 111:
|
|
return x;
|
|
default:
|
|
iFld >>= 1;
|
|
}
|
|
w = 45;
|
|
}
|
|
|
|
if (z == 34) {
|
|
x = iArr[6];
|
|
}
|
|
return iFld;
|
|
}
|
|
|
|
public int test13XcompNoOuter() {
|
|
if (z < 34) {
|
|
z = 34;
|
|
}
|
|
|
|
iFld = 13;
|
|
int j = 50;
|
|
while (--j > 0) {
|
|
iFld += -7;
|
|
iArr[4] = 8;
|
|
x = iArr[5];
|
|
switch ((iCon * 5) + 102) {
|
|
case 120:
|
|
break;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
break;
|
|
default:
|
|
iFld >>= 1;
|
|
}
|
|
w = 45;
|
|
}
|
|
|
|
if (z == 34) {
|
|
x = iArr[6];
|
|
}
|
|
return iFld;
|
|
}
|
|
|
|
// Triggers after peeling with Xcomp
|
|
public int test14PeelNoOuter() {
|
|
iFld = 13;
|
|
int j = 10;
|
|
while (--j > 0) {
|
|
iFld += -7;
|
|
iArr[4] = 8;
|
|
x = iArr[5];
|
|
switch ((iCon * 5) + 102) {
|
|
case 120:
|
|
return iFld;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
break;
|
|
default:
|
|
iFld >>= 1;
|
|
}
|
|
iFld = 3;
|
|
}
|
|
y = iArr[4];
|
|
x = iArr[6];
|
|
|
|
return iFld;
|
|
}
|
|
|
|
|
|
public int test15earlyCtrlNoOuter() {
|
|
iFld = 13;
|
|
if (z < 34) {
|
|
z = 34;
|
|
}
|
|
|
|
int j = 10;
|
|
while (--j > 0) {
|
|
iFld += -7;
|
|
iArr[5] = 8;
|
|
x = iArr[6];
|
|
y = x;
|
|
x = iArr[7];
|
|
switch ((iCon * 5) + 102) {
|
|
case 120:
|
|
return iFld;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
break;
|
|
default:
|
|
if (iFld == -7) {
|
|
return iFld;
|
|
}
|
|
z = iArr[5];
|
|
iFld >>= 1;
|
|
}
|
|
}
|
|
if (iFld == 7) {
|
|
iArr[3] = 3;
|
|
}
|
|
dontInline(7);
|
|
iArr[5] = 34;
|
|
return iFld;
|
|
}
|
|
|
|
// Load after loop -> LoadI after loop from peeled StoreI
|
|
public int test16NoOuter() {
|
|
iFld = 13;
|
|
if (z < 34) {
|
|
z = 34;
|
|
}
|
|
|
|
int j = 60;
|
|
while (--j > 0) {
|
|
iFld += -7;
|
|
y += iFld + 1;
|
|
|
|
iArr[5] = 8;
|
|
x = iArr[6];
|
|
x = iArr[7];
|
|
switch ((iCon * 5) + 102) {
|
|
case 120:
|
|
return iFld;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
break;
|
|
default:
|
|
if (iFld == -7) {
|
|
return iFld;
|
|
}
|
|
z = iArr[5];
|
|
iFld >>= 1;
|
|
}
|
|
}
|
|
w = iArr[9];
|
|
if (iFld == 7) {
|
|
iArr[3] = 3;
|
|
}
|
|
dontInline(7);
|
|
iArr[5] = 34;
|
|
return iFld;
|
|
}
|
|
|
|
// Region 13 before return, which region to choose for MergeMem?
|
|
public int test17XcompNoOuter() {
|
|
A p = dontInlineGetA();
|
|
if (z < 34) {
|
|
z = 34;
|
|
}
|
|
|
|
iFld = 13;
|
|
int j = 50;
|
|
while (--j > 0) {
|
|
iFld += -7;
|
|
iArr[4] = 8;
|
|
x = iArr[5];
|
|
y = p.i;
|
|
switch ((iCon * 5) + 102) {
|
|
case 120:
|
|
break;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
return z;
|
|
case 106:
|
|
return y;
|
|
case 111:
|
|
return x;
|
|
default:
|
|
iFld >>= 1;
|
|
}
|
|
w = 45;
|
|
}
|
|
if (z == 34) {
|
|
x = iArr[6];
|
|
}
|
|
return iFld;
|
|
}
|
|
|
|
// Region 13 before return, which region to choose for MergeMem?
|
|
public int test18XcompNoOuter() {
|
|
if (z < 34) {
|
|
z = 34;
|
|
}
|
|
|
|
iFld = 13;
|
|
int j = 50;
|
|
while (--j > 0) {
|
|
iFld += -7;
|
|
iArr[4] = 8;
|
|
x = iArr[5];
|
|
y = 85;
|
|
switch ((iCon * 5) + 102) {
|
|
case 120:
|
|
break;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
return z;
|
|
case 106:
|
|
if (z == 34) {
|
|
x = iArr[7];
|
|
}
|
|
return y;
|
|
case 111:
|
|
return x;
|
|
default:
|
|
iFld >>= 1;
|
|
}
|
|
w = 45;
|
|
}
|
|
|
|
if (z == 34) {
|
|
x = iArr[6];
|
|
}
|
|
return iFld;
|
|
}
|
|
|
|
public int test19XcompNoOuter() {
|
|
if (z < 34) {
|
|
z = 34;
|
|
}
|
|
|
|
iFld = 13;
|
|
int j = 50;
|
|
while (--j > 0) {
|
|
iFld += -7;
|
|
iArr[4] = 8;
|
|
x = iArr[5]+ iArr[6];
|
|
y = 85;
|
|
switch ((iCon * 5) + 102) {
|
|
case 120:
|
|
break;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
break;
|
|
case 106:
|
|
if (z == 34) {
|
|
x = iArr[7];
|
|
}
|
|
return y;
|
|
case 111:
|
|
return x;
|
|
default:
|
|
iFld >>= 1;
|
|
}
|
|
w = 45;
|
|
}
|
|
|
|
if (z == 34) {
|
|
iArr[7] = 34;
|
|
}
|
|
return iFld;
|
|
}
|
|
|
|
|
|
public int test20NoOuter() {
|
|
if (z < 34) {
|
|
z = 34;
|
|
}
|
|
|
|
iFld = 13;
|
|
int j = 50;
|
|
while (--j > 0) {
|
|
iFld += -7;
|
|
iArr[4] = 8;
|
|
x = iArr[5];
|
|
switch ((iCon * 5) + 102) {
|
|
case 120:
|
|
break;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
break;
|
|
default:
|
|
iFld >>= 1;
|
|
}
|
|
}
|
|
x = iArr[6];
|
|
if (z == 34) {
|
|
x = iArr[7];
|
|
}
|
|
return iFld;
|
|
}
|
|
|
|
public int test21NoOuter() {
|
|
if (z < 34) {
|
|
z = 34;
|
|
}
|
|
|
|
iFld = 13;
|
|
int j = 50;
|
|
while (--j > 0) {
|
|
iFld += -7;
|
|
iArr[4] = 8;
|
|
x = iArr[5];
|
|
switch ((iCon * 5) + 102) {
|
|
case 120:
|
|
break;
|
|
case 103:
|
|
break;
|
|
case 116:
|
|
break;
|
|
default:
|
|
iFld >>= 1;
|
|
}
|
|
}
|
|
x = iArr[6];
|
|
if (z == 34) {
|
|
y = iArr[7];
|
|
}
|
|
return iFld;
|
|
}
|
|
public static void main(String[] strArr) {
|
|
BookKeeper[] bookKeeper = new BookKeeper[22];
|
|
for (int i = 0; i < 22; i++) {
|
|
bookKeeper[i] = new BookKeeper();
|
|
}
|
|
|
|
PartialPeelingUnswitch _instance = new PartialPeelingUnswitch();
|
|
for (int i = 0; i < 2000; i++) {
|
|
int result = _instance.test();
|
|
if (result != -7) {
|
|
throw new RuntimeException("Result should always be -7 but was " + result);
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < 2000; i++) {
|
|
int result = _instance.test2();
|
|
check(-1, result);
|
|
check(-7, iFld);
|
|
check(-9, x);
|
|
check(5, y);
|
|
check(5, iArr[5]);
|
|
check(149, iArr[6]);
|
|
check(183, iArr[7]);
|
|
|
|
// Reset fields
|
|
for (int j = 0; j < 10; j++) {
|
|
iArr[j] = 0;
|
|
}
|
|
x = 42;
|
|
y = 31;
|
|
}
|
|
|
|
for (int i = 0; i < 2000; i++) {
|
|
BookKeeper.setup();
|
|
_instance.test3();
|
|
bookKeeper[3].compare();
|
|
BookKeeper.setup();
|
|
_instance.test4();
|
|
bookKeeper[4].compare();
|
|
BookKeeper.setup();
|
|
_instance.test5();
|
|
bookKeeper[5].compare();
|
|
BookKeeper.setup();
|
|
_instance.test6();
|
|
bookKeeper[6].compare();
|
|
BookKeeper.setup();
|
|
_instance.test7();
|
|
bookKeeper[7].compare();
|
|
BookKeeper.setup();
|
|
_instance.test8();
|
|
bookKeeper[8].compare();
|
|
BookKeeper.setup();
|
|
_instance.test9();
|
|
bookKeeper[9].compare();
|
|
BookKeeper.setup();
|
|
_instance.test10();
|
|
bookKeeper[10].compare();
|
|
BookKeeper.setup();
|
|
_instance.test11Xcomp();
|
|
bookKeeper[11].compare();
|
|
BookKeeper.setup();
|
|
_instance.test12Xcomp();
|
|
bookKeeper[12].compare();
|
|
BookKeeper.setup();
|
|
_instance.test13Xcomp();
|
|
bookKeeper[13].compare();
|
|
BookKeeper.setup();
|
|
_instance.test14Peel();
|
|
bookKeeper[14].compare();
|
|
BookKeeper.setup();
|
|
_instance.test15earlyCtrl();
|
|
bookKeeper[15].compare();
|
|
BookKeeper.setup();
|
|
_instance.test16();
|
|
bookKeeper[16].compare();
|
|
BookKeeper.setup();
|
|
_instance.test17Xcomp();
|
|
bookKeeper[17].compare();
|
|
BookKeeper.setup();
|
|
_instance.test18Xcomp();
|
|
bookKeeper[18].compare();
|
|
BookKeeper.setup();
|
|
_instance.test19Xcomp();
|
|
bookKeeper[19].compare();
|
|
BookKeeper.setup();
|
|
_instance.test20();
|
|
bookKeeper[20].compare();
|
|
BookKeeper.setup();
|
|
_instance.test21();
|
|
bookKeeper[21].compare();
|
|
}
|
|
|
|
for (int i = 0; i < 22; i++) {
|
|
bookKeeper[i] = new BookKeeper();
|
|
}
|
|
|
|
for (int i = 0; i < 2000; i++) {
|
|
BookKeeper.setup();
|
|
_instance.testNoOuter();
|
|
bookKeeper[1].compare();
|
|
BookKeeper.setup();
|
|
_instance.test2NoOuter();
|
|
bookKeeper[2].compare();
|
|
BookKeeper.setup();
|
|
_instance.test3NoOuter();
|
|
bookKeeper[3].compare();
|
|
BookKeeper.setup();
|
|
_instance.test4NoOuter();
|
|
bookKeeper[4].compare();
|
|
BookKeeper.setup();
|
|
_instance.test5NoOuter();
|
|
bookKeeper[5].compare();
|
|
BookKeeper.setup();
|
|
_instance.test6NoOuter();
|
|
bookKeeper[6].compare();
|
|
BookKeeper.setup();
|
|
_instance.test7NoOuter();
|
|
bookKeeper[7].compare();
|
|
BookKeeper.setup();
|
|
_instance.test8NoOuter();
|
|
bookKeeper[8].compare();
|
|
BookKeeper.setup();
|
|
_instance.test9NoOuter();
|
|
bookKeeper[9].compare();
|
|
BookKeeper.setup();
|
|
_instance.test10NoOuter();
|
|
bookKeeper[10].compare();
|
|
BookKeeper.setup();
|
|
_instance.test11XcompNoOuter();
|
|
bookKeeper[11].compare();
|
|
BookKeeper.setup();
|
|
_instance.test12XcompNoOuter();
|
|
bookKeeper[12].compare();
|
|
BookKeeper.setup();
|
|
_instance.test13XcompNoOuter();
|
|
bookKeeper[13].compare();
|
|
BookKeeper.setup();
|
|
_instance.test14PeelNoOuter();
|
|
bookKeeper[14].compare();
|
|
BookKeeper.setup();
|
|
_instance.test15earlyCtrlNoOuter();
|
|
bookKeeper[15].compare();
|
|
BookKeeper.setup();
|
|
_instance.test16NoOuter();
|
|
bookKeeper[16].compare();
|
|
BookKeeper.setup();
|
|
_instance.test17XcompNoOuter();
|
|
bookKeeper[17].compare();
|
|
BookKeeper.setup();
|
|
_instance.test18XcompNoOuter();
|
|
bookKeeper[18].compare();
|
|
BookKeeper.setup();
|
|
_instance.test19XcompNoOuter();
|
|
bookKeeper[19].compare();
|
|
BookKeeper.setup();
|
|
_instance.test20NoOuter();
|
|
bookKeeper[20].compare();
|
|
BookKeeper.setup();
|
|
_instance.test21NoOuter();
|
|
bookKeeper[21].compare();
|
|
}
|
|
|
|
for (int i = 0; i < 22; i++) {
|
|
bookKeeper[i] = new BookKeeper();
|
|
}
|
|
|
|
for (int i = 0; i < 2000; i++) {
|
|
BookKeeper.setup();
|
|
setZ(i);
|
|
_instance.test3();
|
|
bookKeeper[3].compare(i);
|
|
BookKeeper.setup();
|
|
setZ(i);
|
|
_instance.test4();
|
|
bookKeeper[4].compare(i);
|
|
BookKeeper.setup();
|
|
setZ(i);
|
|
_instance.test5();
|
|
bookKeeper[5].compare(i);
|
|
BookKeeper.setup();
|
|
setZ(i);
|
|
_instance.test6();
|
|
bookKeeper[6].compare(i);
|
|
BookKeeper.setup();
|
|
setZ(i);
|
|
_instance.test7();
|
|
bookKeeper[7].compare(i);
|
|
BookKeeper.setup();
|
|
setZ(i);
|
|
_instance.test8();
|
|
bookKeeper[8].compare(i);
|
|
BookKeeper.setup();
|
|
setZ(i);
|
|
_instance.test9();
|
|
bookKeeper[9].compare(i);
|
|
BookKeeper.setup();
|
|
setZ(i);
|
|
_instance.test10();
|
|
bookKeeper[10].compare(i);
|
|
setZ(i);
|
|
BookKeeper.setup();
|
|
_instance.test11Xcomp();
|
|
bookKeeper[11].compare(i);
|
|
setZ(i);
|
|
BookKeeper.setup();
|
|
_instance.test12Xcomp();
|
|
bookKeeper[12].compare(i);
|
|
setZ(i);
|
|
BookKeeper.setup();
|
|
_instance.test13Xcomp();
|
|
bookKeeper[13].compare(i);
|
|
setZ(i);
|
|
BookKeeper.setup();
|
|
_instance.test14Peel();
|
|
bookKeeper[14].compare(i);
|
|
setZ(i);
|
|
BookKeeper.setup();
|
|
_instance.test15earlyCtrl();
|
|
bookKeeper[15].compare(i);
|
|
setZ(i);
|
|
BookKeeper.setup();
|
|
_instance.test16();
|
|
bookKeeper[16].compare(i);
|
|
setZ(i);
|
|
BookKeeper.setup();
|
|
_instance.test17Xcomp();
|
|
bookKeeper[17].compare(i);
|
|
setZ(i);
|
|
BookKeeper.setup();
|
|
_instance.test18Xcomp();
|
|
bookKeeper[18].compare(i);
|
|
setZ(i);
|
|
BookKeeper.setup();
|
|
_instance.test19Xcomp();
|
|
bookKeeper[19].compare(i);
|
|
setZ(i);
|
|
BookKeeper.setup();
|
|
_instance.test20();
|
|
bookKeeper[20].compare(i);
|
|
setZ(i);
|
|
BookKeeper.setup();
|
|
_instance.test21();
|
|
bookKeeper[21].compare(i);
|
|
}
|
|
|
|
for (int i = 0; i < 22; i++) {
|
|
bookKeeper[i] = new BookKeeper();
|
|
}
|
|
|
|
for (int i = 0; i < 2000; i++) {
|
|
BookKeeper.setup();
|
|
setZ(i);
|
|
_instance.testNoOuter();
|
|
bookKeeper[1].compare(i);
|
|
BookKeeper.setup();
|
|
setZ(i);
|
|
_instance.test2NoOuter();
|
|
bookKeeper[2].compare(i);
|
|
BookKeeper.setup();
|
|
setZ(i);
|
|
_instance.test3NoOuter();
|
|
bookKeeper[3].compare(i);
|
|
BookKeeper.setup();
|
|
setZ(i);
|
|
_instance.test4NoOuter();
|
|
bookKeeper[4].compare(i);
|
|
BookKeeper.setup();
|
|
setZ(i);
|
|
_instance.test5NoOuter();
|
|
bookKeeper[5].compare(i);
|
|
BookKeeper.setup();
|
|
setZ(i);
|
|
_instance.test6NoOuter();
|
|
bookKeeper[6].compare(i);
|
|
BookKeeper.setup();
|
|
setZ(i);
|
|
_instance.test7NoOuter();
|
|
bookKeeper[7].compare(i);
|
|
BookKeeper.setup();
|
|
setZ(i);
|
|
_instance.test8NoOuter();
|
|
bookKeeper[8].compare(i);
|
|
BookKeeper.setup();
|
|
setZ(i);
|
|
_instance.test9NoOuter();
|
|
bookKeeper[9].compare(i);
|
|
BookKeeper.setup();
|
|
setZ(i);
|
|
_instance.test10NoOuter();
|
|
bookKeeper[10].compare(i);
|
|
BookKeeper.setup();
|
|
setZ(i);
|
|
_instance.test11XcompNoOuter();
|
|
bookKeeper[11].compare(i);
|
|
BookKeeper.setup();
|
|
setZ(i);
|
|
_instance.test12XcompNoOuter();
|
|
bookKeeper[12].compare(i);
|
|
BookKeeper.setup();
|
|
setZ(i);
|
|
_instance.test13XcompNoOuter();
|
|
bookKeeper[13].compare(i);
|
|
BookKeeper.setup();
|
|
setZ(i);
|
|
_instance.test14PeelNoOuter();
|
|
bookKeeper[14].compare(i);
|
|
BookKeeper.setup();
|
|
setZ(i);
|
|
_instance.test15earlyCtrlNoOuter();
|
|
bookKeeper[15].compare(i);
|
|
BookKeeper.setup();
|
|
setZ(i);
|
|
_instance.test16NoOuter();
|
|
bookKeeper[16].compare(i);
|
|
BookKeeper.setup();
|
|
setZ(i);
|
|
_instance.test17XcompNoOuter();
|
|
bookKeeper[17].compare(i);
|
|
BookKeeper.setup();
|
|
setZ(i);
|
|
_instance.test18XcompNoOuter();
|
|
bookKeeper[18].compare(i);
|
|
BookKeeper.setup();
|
|
setZ(i);
|
|
_instance.test19XcompNoOuter();
|
|
bookKeeper[19].compare(i);
|
|
BookKeeper.setup();
|
|
setZ(i);
|
|
_instance.test20NoOuter();
|
|
bookKeeper[20].compare(i);
|
|
BookKeeper.setup();
|
|
setZ(i);
|
|
_instance.test21NoOuter();
|
|
bookKeeper[21].compare(i);
|
|
}
|
|
}
|
|
|
|
public static void setZ(int i) {
|
|
if (i % 2 == 0) {
|
|
z = 23;
|
|
} else {
|
|
z = 35;
|
|
}
|
|
}
|
|
|
|
public static void check(int expected, int actual) {
|
|
if (expected != actual) {
|
|
throw new RuntimeException("Wrong result, expected: " + expected + ", actual: " + actual);
|
|
}
|
|
}
|
|
|
|
public void dontInline(int i) { }
|
|
|
|
class A {
|
|
int i = 3;
|
|
}
|
|
|
|
A dontInlineGetA() {
|
|
return new A();
|
|
}
|
|
|
|
static class BookKeeper {
|
|
public int iFld;
|
|
public int w;
|
|
public int x;
|
|
public int y;
|
|
public int z;
|
|
public int val;
|
|
public int[] iArr;
|
|
|
|
public int iFld2;
|
|
public int w2;
|
|
public int x2;
|
|
public int y2;
|
|
public int z2;
|
|
public int val2;
|
|
public int[] iArr2;
|
|
|
|
public void compare() {
|
|
if (iArr == null) {
|
|
// First compare, initialize values
|
|
this.iFld = PartialPeelingUnswitch.iFld;
|
|
this.w = PartialPeelingUnswitch.w;
|
|
this.x = PartialPeelingUnswitch.x;
|
|
this.y = PartialPeelingUnswitch.y;
|
|
this.z = PartialPeelingUnswitch.z;
|
|
this.val = PartialPeelingUnswitch.val;
|
|
this.iArr = new int[10];
|
|
System.arraycopy(PartialPeelingUnswitch.iArr, 0, this.iArr, 0, 10);
|
|
} else {
|
|
|
|
// Do comparison
|
|
boolean check = PartialPeelingUnswitch.iFld == this.iFld
|
|
&& this.w == PartialPeelingUnswitch.w
|
|
&& this.x == PartialPeelingUnswitch.x
|
|
&& this.y == PartialPeelingUnswitch.y
|
|
&& this.z == PartialPeelingUnswitch.z
|
|
&& this.val == PartialPeelingUnswitch.val;
|
|
for (int i = 0; i < 10; i++) {
|
|
check = check && this.iArr[i] == PartialPeelingUnswitch.iArr[i];
|
|
}
|
|
|
|
if (!check) {
|
|
throw new RuntimeException("Failed comparison");
|
|
}
|
|
}
|
|
}
|
|
|
|
public void compare(int i) {
|
|
if (i % 2 == 0 && iArr == null) {
|
|
// First compare, initialize values
|
|
this.iFld = PartialPeelingUnswitch.iFld;
|
|
this.w = PartialPeelingUnswitch.w;
|
|
this.x = PartialPeelingUnswitch.x;
|
|
this.y = PartialPeelingUnswitch.y;
|
|
this.z = PartialPeelingUnswitch.z;
|
|
this.val = PartialPeelingUnswitch.val;
|
|
this.iArr = new int[10];
|
|
System.arraycopy(PartialPeelingUnswitch.iArr, 0, this.iArr, 0, 10);
|
|
} else if (i % 2 != 0 && iArr2 == null) {
|
|
// First compare, initialize values
|
|
this.iFld2 = PartialPeelingUnswitch.iFld;
|
|
this.w2 = PartialPeelingUnswitch.w;
|
|
this.x2 = PartialPeelingUnswitch.x;
|
|
this.y2 = PartialPeelingUnswitch.y;
|
|
this.z2 = PartialPeelingUnswitch.z;
|
|
this.val2 = PartialPeelingUnswitch.val;
|
|
this.iArr2 = new int[10];
|
|
System.arraycopy(PartialPeelingUnswitch.iArr, 0, this.iArr2, 0, 10);
|
|
} else if (i % 2 == 0) {
|
|
// Do comparison
|
|
boolean check = PartialPeelingUnswitch.iFld == this.iFld
|
|
&& this.w == PartialPeelingUnswitch.w
|
|
&& this.x == PartialPeelingUnswitch.x
|
|
&& this.y == PartialPeelingUnswitch.y
|
|
&& this.z == PartialPeelingUnswitch.z
|
|
&& this.val == PartialPeelingUnswitch.val;
|
|
for (int j = 0; j < 10; j++) {
|
|
check = check && this.iArr[j] == PartialPeelingUnswitch.iArr[j];
|
|
}
|
|
|
|
if (!check) {
|
|
throw new RuntimeException("Failed comparison");
|
|
}
|
|
} else {
|
|
// Do comparison
|
|
boolean check = PartialPeelingUnswitch.iFld == this.iFld2
|
|
&& this.w2 == PartialPeelingUnswitch.w
|
|
&& this.x2 == PartialPeelingUnswitch.x
|
|
&& this.y2 == PartialPeelingUnswitch.y
|
|
&& this.z2 == PartialPeelingUnswitch.z
|
|
&& this.val2 == PartialPeelingUnswitch.val;
|
|
for (int j = 0; j < 10; j++) {
|
|
check = check && this.iArr2[j] == PartialPeelingUnswitch.iArr[j];
|
|
}
|
|
|
|
if (!check) {
|
|
throw new RuntimeException("Failed comparison");
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void setup() {
|
|
PartialPeelingUnswitch.iFld = 0;
|
|
PartialPeelingUnswitch.w = 88;
|
|
PartialPeelingUnswitch.x = 42;
|
|
PartialPeelingUnswitch.y = 31;
|
|
PartialPeelingUnswitch.z = 22;
|
|
PartialPeelingUnswitch.val = 34;
|
|
PartialPeelingUnswitch.iArr = new int[10];
|
|
}
|
|
}
|
|
}
|