|
3345
|
1 /*
|
|
|
2 * Copyright (c) 2011 Hewlett-Packard Company. All rights reserved.
|
|
|
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
|
4 *
|
|
|
5 * This code is free software; you can redistribute it and/or modify it
|
|
|
6 * under the terms of the GNU General Public License version 2 only, as
|
|
|
7 * published by the Free Software Foundation.
|
|
|
8 *
|
|
|
9 * This code is distributed in the hope that it will be useful, but WITHOUT
|
|
|
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
12 * version 2 for more details (a copy is included in the LICENSE file that
|
|
|
13 * accompanied this code).
|
|
|
14 *
|
|
|
15 * You should have received a copy of the GNU General Public License version
|
|
|
16 * 2 along with this work; if not, write to the Free Software Foundation,
|
|
|
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
18 *
|
|
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
|
20 * or visit www.oracle.com if you need additional information or have any
|
|
|
21 * questions.
|
|
|
22 *
|
|
|
23 */
|
|
|
24
|
|
|
25 /**
|
|
|
26 * @test
|
|
|
27 * @bug 5091921
|
|
|
28 * @summary Sign flip issues in loop optimizer
|
|
|
29 *
|
|
|
30 * @run main/othervm -Xcomp -XX:CompileOnly=Test5091921 -XX:MaxInlineSize=1 Test5091921
|
|
|
31 */
|
|
|
32
|
|
|
33 public class Test5091921 {
|
|
|
34 private static int result = 0;
|
|
|
35
|
|
|
36
|
|
|
37 /* Test for the bug of transforming indx >= MININT to indx > MININT-1 */
|
|
|
38 public static int test_ge1(int limit) {
|
|
|
39 int indx;
|
|
|
40 int sum = 0;
|
|
|
41 for (indx = 500; indx >= limit; indx -= 2) {
|
|
|
42 sum += 2000 / indx;
|
|
|
43 result = sum;
|
|
|
44 }
|
|
|
45 return sum;
|
|
|
46 }
|
|
|
47
|
|
|
48 /* Test for the bug of transforming indx <= MAXINT to indx < MAXINT+1 */
|
|
|
49 public static int test_le1(int limit) {
|
|
|
50 int indx;
|
|
|
51 int sum = 0;
|
|
|
52 for (indx = -500; indx <= limit; indx += 2)
|
|
|
53 {
|
|
|
54 sum += 3000 / indx;
|
|
|
55 result = sum;
|
|
|
56 }
|
|
|
57 return sum;
|
|
|
58 }
|
|
|
59
|
|
|
60 /* Run with -Xcomp -XX:CompileOnly=wrap1.test1 -XX:MaxInlineSize=1 */
|
|
|
61 /* limit reset to ((limit-init+stride-1)/stride)*stride+init */
|
|
|
62 /* Calculation may overflow */
|
|
|
63 public static volatile int c = 1;
|
|
|
64 public static int test_wrap1(int limit)
|
|
|
65 {
|
|
|
66 int indx;
|
|
|
67 int sum = 0;
|
|
|
68 for (indx = 0xffffffff; indx < limit; indx += 0x20000000)
|
|
|
69 {
|
|
|
70 sum += c;
|
|
|
71 }
|
|
|
72 return sum;
|
|
|
73 }
|
|
|
74
|
|
|
75 /* Test for range check elimination with bit flip issue for
|
|
|
76 scale*i+offset<limit where offset is not 0 */
|
|
|
77 static int[] box5 = {1,2,3,4,5,6,7,8,9};
|
|
|
78 public static int test_rce5(int[] b, int limit)
|
|
|
79 {
|
|
|
80 int indx;
|
|
|
81 int sum = b[1];
|
|
|
82 result = sum;
|
|
|
83 for (indx = 0x80000000; indx < limit; ++indx)
|
|
|
84 {
|
|
|
85 if (indx > 0x80000000)
|
|
|
86 {
|
|
|
87 // this test is not issued in pre-loop but issued in main loop
|
|
|
88 // trick rce into thinking expression is false when indx >= 0
|
|
|
89 // in fact it is false when indx==0x80000001
|
|
|
90 if (indx - 9 < -9)
|
|
|
91 {
|
|
|
92 sum += indx;
|
|
|
93 result = sum;
|
|
|
94 sum ^= b[indx & 7];
|
|
|
95 result = sum;
|
|
|
96 }
|
|
|
97 else
|
|
|
98 break;
|
|
|
99 }
|
|
|
100 else
|
|
|
101 {
|
|
|
102 sum += b[indx & 3];
|
|
|
103 result = sum;
|
|
|
104 }
|
|
|
105 }
|
|
|
106 return sum;
|
|
|
107 }
|
|
|
108
|
|
|
109 /* Test for range check elimination with bit flip issue for
|
|
|
110 scale*i<limit where scale > 1 */
|
|
|
111 static int[] box6 = {1,2,3,4,5,6,7,8,9};
|
|
|
112 public static int test_rce6(int[] b, int limit)
|
|
|
113 {
|
|
|
114 int indx;
|
|
|
115 int sum = b[1];
|
|
|
116 result = sum;
|
|
|
117 for (indx = 0x80000000; indx < limit; ++indx)
|
|
|
118 {
|
|
|
119 if (indx > 0x80000000)
|
|
|
120 {
|
|
|
121 // harmless rce target
|
|
|
122 if (indx < 0)
|
|
|
123 {
|
|
|
124 sum += result;
|
|
|
125 result = sum;
|
|
|
126 }
|
|
|
127 else
|
|
|
128 break;
|
|
|
129 // this test is not issued in pre-loop but issued in main loop
|
|
|
130 // trick rce into thinking expression is false when indx >= 0
|
|
|
131 // in fact it is false when indx==0x80000001
|
|
|
132 // In compilers that transform mulI to shiftI may mask this issue.
|
|
|
133 if (indx * 28 + 1 < 0)
|
|
|
134 {
|
|
|
135 sum += indx;
|
|
|
136 result = sum;
|
|
|
137 sum ^= b[indx & 7];
|
|
|
138 result = sum;
|
|
|
139 }
|
|
|
140 else
|
|
|
141 break;
|
|
|
142 }
|
|
|
143 else
|
|
|
144 {
|
|
|
145 sum += b[indx & 3];
|
|
|
146 result = sum;
|
|
|
147 }
|
|
|
148 }
|
|
|
149 return sum;
|
|
|
150 }
|
|
|
151
|
|
|
152 /* Test for range check elimination with i <= limit */
|
|
|
153 static int[] box7 = {1,2,3,4,5,6,7,8,9,0x7fffffff};
|
|
|
154 public static int test_rce7(int[] b)
|
|
|
155 {
|
|
|
156 int indx;
|
|
|
157 int max = b[9];
|
|
|
158 int sum = b[7];
|
|
|
159 result = sum;
|
|
|
160 for (indx = 0; indx < b.length; ++indx)
|
|
|
161 {
|
|
|
162 if (indx <= max)
|
|
|
163 {
|
|
|
164 sum += (indx ^ 15) + ((result != 0) ? 0 : sum);
|
|
|
165 result = sum;
|
|
|
166 }
|
|
|
167 else
|
|
|
168 throw new RuntimeException();
|
|
|
169 }
|
|
|
170 for (indx = -7; indx < b.length; ++indx)
|
|
|
171 {
|
|
|
172 if (indx <= 9)
|
|
|
173 {
|
|
|
174 sum += (sum ^ 15) + ((result != 0) ? 0 : sum);
|
|
|
175 result = sum;
|
|
|
176 }
|
|
|
177 else
|
|
|
178 throw new RuntimeException();
|
|
|
179 }
|
|
|
180 return sum;
|
|
|
181 }
|
|
|
182
|
|
|
183 /* Test for range check elimination with i >= limit */
|
|
|
184 static int[] box8 = {-1,0,1,2,3,4,5,6,7,8,0x80000000};
|
|
|
185 public static int test_rce8(int[] b)
|
|
|
186 {
|
|
|
187 int indx;
|
|
|
188 int sum = b[5];
|
|
|
189 int min = b[10];
|
|
|
190 result = sum;
|
|
|
191 for (indx = b.length-1; indx >= 0; --indx)
|
|
|
192 {
|
|
|
193 if (indx >= min)
|
|
|
194 {
|
|
|
195 sum += (sum ^ 9) + ((result != 0) ? 0 :sum);
|
|
|
196 result = sum;
|
|
|
197 }
|
|
|
198 else
|
|
|
199 throw new RuntimeException();
|
|
|
200 }
|
|
|
201 return sum;
|
|
|
202 }
|
|
|
203
|
|
|
204 public static void main(String[] args)
|
|
|
205 {
|
|
|
206 result=1;
|
|
|
207 int r = 0;
|
|
|
208 try {
|
|
|
209 r = test_ge1(0x80000000);
|
|
|
210 System.out.println(result);
|
|
|
211 System.out.println("test_ge1 FAILED");
|
|
|
212 System.exit(1);
|
|
|
213 }
|
|
|
214 catch (ArithmeticException e1) {
|
|
|
215 System.out.println("test_ge1: Expected exception caught");
|
|
|
216 if (result != 5986) {
|
|
|
217 System.out.println(result);
|
|
|
218 System.out.println("test_ge1 FAILED");
|
|
|
219 System.exit(97);
|
|
|
220 }
|
|
|
221 }
|
|
|
222 System.out.println("test_ge1 WORKED");
|
|
|
223
|
|
|
224 result=0;
|
|
|
225 try
|
|
|
226 {
|
|
|
227 r = test_le1(0x7fffffff);
|
|
|
228 System.out.println(result);
|
|
|
229 System.out.println("test_le1 FAILED");
|
|
|
230 System.exit(1);
|
|
|
231 }
|
|
|
232 catch (ArithmeticException e1)
|
|
|
233 {
|
|
|
234 System.out.println("test_le1: Expected exception caught");
|
|
|
235 if (result != -9039)
|
|
|
236 {
|
|
|
237 System.out.println(result);
|
|
|
238 System.out.println("test_le1 FAILED");
|
|
|
239 System.exit(97);
|
|
|
240 }
|
|
|
241 }
|
|
|
242 System.out.println("test_le1 WORKED");
|
|
|
243
|
|
|
244 result=0;
|
|
|
245 r = test_wrap1(0x7fffffff);
|
|
|
246 if (r != 4)
|
|
|
247 {
|
|
|
248 System.out.println(result);
|
|
|
249 System.out.println("test_wrap1 FAILED");
|
|
|
250 System.exit(97);
|
|
|
251 }
|
|
|
252 else
|
|
|
253 {
|
|
|
254 System.out.println("test_wrap1 WORKED");
|
|
|
255 }
|
|
|
256
|
|
|
257 result=0;
|
|
|
258 r = test_rce5(box5,0x80000100);
|
|
|
259 if (result != 3)
|
|
|
260 {
|
|
|
261 System.out.println(result);
|
|
|
262 System.out.println("test_rce5 FAILED");
|
|
|
263 System.exit(97);
|
|
|
264 }
|
|
|
265 else
|
|
|
266 {
|
|
|
267 System.out.println("test_rce5 WORKED");
|
|
|
268 }
|
|
|
269
|
|
|
270 result=0;
|
|
|
271 r = test_rce6(box6,0x80000100);
|
|
|
272 if (result != 6)
|
|
|
273 {
|
|
|
274 System.out.println(result);
|
|
|
275 System.out.println("test_rce6 FAILED");
|
|
|
276 System.exit(97);
|
|
|
277 }
|
|
|
278 else
|
|
|
279 {
|
|
|
280 System.out.println("test_rce6 WORKED");
|
|
|
281 }
|
|
|
282
|
|
|
283 result=0;
|
|
|
284 r = test_rce7(box7);
|
|
|
285 if (result != 14680079)
|
|
|
286 {
|
|
|
287 System.out.println(result);
|
|
|
288 System.out.println("test_rce7 FAILED");
|
|
|
289 System.exit(97);
|
|
|
290 }
|
|
|
291 else
|
|
|
292 {
|
|
|
293 System.out.println("test_rce7 WORKED");
|
|
|
294 }
|
|
|
295
|
|
|
296 result=0;
|
|
|
297 r = test_rce8(box8);
|
|
|
298 if (result != 16393)
|
|
|
299 {
|
|
|
300 System.out.println(result);
|
|
|
301 System.out.println("test_rce8 FAILED");
|
|
|
302 System.exit(97);
|
|
|
303 }
|
|
|
304 else
|
|
|
305 {
|
|
|
306 System.out.println("test_rce8 WORKED");
|
|
|
307 }
|
|
|
308 }
|
|
|
309 }
|
