1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
|
/*
* 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.
*
*/
/*
* @test
* @bug 8307683
* @library /test/lib /
* @requires vm.compiler2.enabled
* @summary Tests that IfNode is not wrongly chosen as range check by Loop Predication leading to crashes and wrong executions.
* @run main/othervm -Xcomp -XX:CompileCommand=compileonly,compiler.predicates.TestHoistedPredicateForNonRangeCheck::test*
* compiler.predicates.TestHoistedPredicateForNonRangeCheck
* @run main/othervm -Xcomp -XX:CompileCommand=compileonly,compiler.predicates.TestHoistedPredicateForNonRangeCheck::test*
* -XX:LoopMaxUnroll=0 compiler.predicates.TestHoistedPredicateForNonRangeCheck
*/
/*
* @test
* @bug 8307683
* @library /test/lib /
* @summary Tests that IfNode is not wrongly chosen as range check by Loop Predication leading to crashes and wrong executions.
* @run main/othervm -Xbatch compiler.predicates.TestHoistedPredicateForNonRangeCheck calendar
*/
package compiler.predicates;
import jdk.test.lib.Asserts;
import java.util.Calendar;
import java.util.Date;
public class TestHoistedPredicateForNonRangeCheck {
static int iFld, iFld2;
static int[] iArr = new int[100];
public static void main(String[] args) {
if (args.length == 0) {
Integer.compareUnsigned(34, 34); // Ensure Integer class is loaded and we do not emit a trap inside test() for it.
for (int i = 0; i < 2; i++) {
iFld = 0;
iFld2 = 0;
test();
Asserts.assertEQ(iFld, 3604, "wrong value");
Asserts.assertEQ(iFld2, 400, "wrong value");
}
for (int i = 0; i < 2000; i++) {
iFld = -100;
testRangeCheckNode();
}
iFld = -1;
iFld2 = 0;
testRangeCheckNode();
Asserts.assertEQ(iFld2, 36, "wrong value");
} else {
boolean flag = false;
for (int i = 0; i < 10000; i++) {
testCalendar1();
testCalendar2(flag);
}
}
}
public static void test() {
for (int i = -1; i < 1000; i++) {
// We hoist this check and insert a Hoisted Predicate for the lower and upper bound:
// -1 >=u 100 && 1000 >= u 100 -> always true and the predicates are removed.
// Template Assertion Predicates, however, are kept. When splitting this loop further, we insert an Assertion
// Predicate which fails for i = 0 and we halt.
// When not splitting this loop (with LoopMaxUnroll=0), we have a wrong execution due to never executing
// iFld2++ (we remove the check and the branch with the trap when creating the Hoisted Predicates).
if (Integer.compareUnsigned(i, 100) < 0) {
iFld2++;
Float.isNaN(34); // Float class is unloaded with -Xcomp -> inserts trap
} else {
iFld++;
}
// Same but flipped condition and moved trap to other branch - result is the same.
if (Integer.compareUnsigned(i, 100) >= 0) { // Loop Predication creates a Hoisted Range Check Predicate due to trap with Float.isNan().
iFld++;
} else {
iFld2++;
Float.isNaN(34); // Float class is unloaded with -Xcomp -> inserts trap
}
// Same but with LoadRangeNode.
if (Integer.compareUnsigned(i, iArr.length) >= 0) { // Loop Predication creates a Hoisted Range Check Predicate due to trap with Float.isNan().
iFld++;
} else {
iFld2++;
Float.isNaN(34); // Float class is unloaded with -Xcomp -> inserts trap
}
// Same but with LoadRangeNode and flipped condition and moved trap to other branch - result is the same.
if (Integer.compareUnsigned(i, iArr.length) >= 0) { // Loop Predication creates a Hoisted Range Check Predicate due to trap with Float.isNan().
iFld++;
} else {
iFld2++;
Float.isNaN(34); // Float class is unloaded with -Xcomp -> inserts trap
}
}
}
static void testRangeCheckNode() {
int array[] = new int[34];
// Hoisted Range Check Predicate with flipped bool because trap is on success proj and no trap on false proj due
// to catching exception:
// iFld >=u 34 && iFld+36 >=u 34
// This is always false for first 2000 iterations where, initially, iFld = -100
// It is still true in the last iteration where, initially, iFld = -1. But suddenly, in the second iteration,
// where iFld = 0, we would take the true projection for the first time - but we removed that branch when
// creating the Hoisted Range Check Predicate. We therefore run into the same problem as with test(): We either
// halt due to Assertion Predicates catching this case or we have a wrong execution (iFld2 never updated).
for (int i = 0; i < 37; i++) {
try {
array[iFld] = 34; // Normal RangeCheckNode
iFld2++;
Math.ceil(34); // Never taken and unloaded -> trap
} catch (Exception e) {
// False Proj of RangeCheckNode
iFld++;
}
}
}
// Reported in JDK-8307683
static void testCalendar1() {
Calendar c = Calendar.getInstance();
c.setLenient(false);
c.set(Calendar.HOUR_OF_DAY, 0);
c.set(Calendar.MINUTE, 0);
c.getTime();
}
// Reported in JDK-8307978
static void testCalendar2(boolean flag) {
flag = !flag;
Calendar timespan = removeTime(new Date(), flag);
timespan.getTime();
}
static Calendar removeTime(Date date, boolean flag) {
Calendar calendar = Calendar.getInstance();
if (flag) {
calendar.setLenient(false);
}
calendar.setTime(date);
calendar = removeTime(calendar);
return calendar;
}
static Calendar removeTime(Calendar calendar) {
calendar.set(Calendar.HOUR_OF_DAY, 0);
calendar.set(Calendar.MINUTE, 0);
calendar.set(Calendar.SECOND, 0);
calendar.set(Calendar.MILLISECOND, 0);
return calendar;
}
}
|
