Mercurial > jdk8-mips64-public > hotspot / file revision
test/compiler/6934604/TestFloatBoxing.java@dbb05f6d93c4
test/compiler/6934604/TestFloatBoxing.java
Mon, 28 Jul 2014 15:06:38 -0700
- author
- fzhinkin
- date
- Mon, 28 Jul 2014 15:06:38 -0700
- changeset 6997
- dbb05f6d93c4
- parent 0
- f90c822e73f8
- permissions
- -rw-r--r--
8051344: JVM crashed in Compile::start() during method parsing w/ UseRTMDeopt turned on
Summary: call rtm_deopt() only if there were no compilation bailouts before.
Reviewed-by: kvn
1 /*
2 * Copyright (c) 2013, Oracle and/or its affiliates. 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 */
24 /*
25 * @test
26 * @bug 6934604
27 * @summary enable parts of EliminateAutoBox by default
28 * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:+EliminateAutoBox TestFloatBoxing
29 * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:+EliminateAutoBox
30 * -XX:CompileCommand=exclude,TestFloatBoxing.dummy -XX:CompileCommand=exclude,TestFloatBoxing.foo -XX:CompileCommand=exclude,TestFloatBoxing.foob TestFloatBoxing
31 * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-EliminateAutoBox
32 * -XX:CompileCommand=exclude,TestFloatBoxing.dummy -XX:CompileCommand=exclude,TestFloatBoxing.foo -XX:CompileCommand=exclude,TestFloatBoxing.foob TestFloatBoxing
33 *
34 */
36 public class TestFloatBoxing {
38 static final Float ibc = new Float(1.f);
40 //===============================================
41 // Non-inlined methods to test deoptimization info
42 static void dummy() { }
43 static float foo(float i) { return i; }
44 static Float foob(float i) { return Float.valueOf(i); }
47 static float simple(float i) {
48 Float ib = new Float(i);
49 return ib;
50 }
52 static float simpleb(float i) {
53 Float ib = Float.valueOf(i);
54 return ib;
55 }
57 static float simplec() {
58 Float ib = ibc;
59 return ib;
60 }
62 static float simplef(float i) {
63 Float ib = foob(i);
64 return ib;
65 }
67 static float simplep(Float ib) {
68 return ib;
69 }
71 static float simple2(float i) {
72 Float ib1 = new Float(i);
73 Float ib2 = new Float(i+1.f);
74 return ib1 + ib2;
75 }
77 static float simpleb2(float i) {
78 Float ib1 = Float.valueOf(i);
79 Float ib2 = Float.valueOf(i+1.f);
80 return ib1 + ib2;
81 }
83 static float simplem2(float i) {
84 Float ib1 = new Float(i);
85 Float ib2 = Float.valueOf(i+1.f);
86 return ib1 + ib2;
87 }
89 static float simplep2(float i, Float ib1) {
90 Float ib2 = Float.valueOf(i+1.f);
91 return ib1 + ib2;
92 }
94 static float simplec2(float i) {
95 Float ib1 = ibc;
96 Float ib2 = Float.valueOf(i+1.f);
97 return ib1 + ib2;
98 }
100 //===============================================
101 static float test(float f, int i) {
102 Float ib = new Float(f);
103 if ((i&1) == 0)
104 ib = f+1.f;
105 return ib;
106 }
108 static float testb(float f, int i) {
109 Float ib = f;
110 if ((i&1) == 0)
111 ib = (f+1.f);
112 return ib;
113 }
115 static float testm(float f, int i) {
116 Float ib = f;
117 if ((i&1) == 0)
118 ib = new Float(f+1.f);
119 return ib;
120 }
122 static float testp(float f, int i, Float ib) {
123 if ((i&1) == 0)
124 ib = new Float(f+1.f);
125 return ib;
126 }
128 static float testc(float f, int i) {
129 Float ib = ibc;
130 if ((i&1) == 0)
131 ib = new Float(f+1.f);
132 return ib;
133 }
135 static float test2(float f, int i) {
136 Float ib1 = new Float(f);
137 Float ib2 = new Float(f+1.f);
138 if ((i&1) == 0) {
139 ib1 = new Float(f+1.f);
140 ib2 = new Float(f+2.f);
141 }
142 return ib1+ib2;
143 }
145 static float testb2(float f, int i) {
146 Float ib1 = f;
147 Float ib2 = f+1.f;
148 if ((i&1) == 0) {
149 ib1 = (f+1.f);
150 ib2 = (f+2.f);
151 }
152 return ib1+ib2;
153 }
155 static float testm2(float f, int i) {
156 Float ib1 = new Float(f);
157 Float ib2 = f+1.f;
158 if ((i&1) == 0) {
159 ib1 = new Float(f+1.f);
160 ib2 = (f+2.f);
161 }
162 return ib1+ib2;
163 }
165 static float testp2(float f, int i, Float ib1) {
166 Float ib2 = f+1.f;
167 if ((i&1) == 0) {
168 ib1 = new Float(f+1.f);
169 ib2 = (f+2.f);
170 }
171 return ib1+ib2;
172 }
174 static float testc2(float f, int i) {
175 Float ib1 = ibc;
176 Float ib2 = f+1.f;
177 if ((i&1) == 0) {
178 ib1 = (ibc+1.f);
179 ib2 = (f+2.f);
180 }
181 return ib1+ib2;
182 }
184 //===============================================
185 static float sum(float[] a) {
186 float result = 1.f;
187 for (Float i : a)
188 result += i;
189 return result;
190 }
192 static float sumb(float[] a) {
193 Float result = 1.f;
194 for (Float i : a)
195 result += i;
196 return result;
197 }
199 static float sumc(float[] a) {
200 Float result = ibc;
201 for (Float i : a)
202 result += i;
203 return result;
204 }
206 static float sumf(float[] a) {
207 Float result = foob(1.f);
208 for (Float i : a)
209 result += i;
210 return result;
211 }
213 static float sump(float[] a, Float result) {
214 for (Float i : a)
215 result += i;
216 return result;
217 }
219 static float sum2(float[] a) {
220 float result1 = 1.f;
221 float result2 = 1.f;
222 for (Float i : a) {
223 result1 += i;
224 result2 += i + 1.f;
225 }
226 return result1 + result2;
227 }
229 static float sumb2(float[] a) {
230 Float result1 = 1.f;
231 Float result2 = 1.f;
232 for (Float i : a) {
233 result1 += i;
234 result2 += i + 1.f;
235 }
236 return result1 + result2;
237 }
239 static float summ2(float[] a) {
240 Float result1 = 1.f;
241 Float result2 = new Float(1.f);
242 for (Float i : a) {
243 result1 += i;
244 result2 += new Float(i + 1.f);
245 }
246 return result1 + result2;
247 }
249 static float sump2(float[] a, Float result2) {
250 Float result1 = 1.f;
251 for (Float i : a) {
252 result1 += i;
253 result2 += i + 1.f;
254 }
255 return result1 + result2;
256 }
258 static float sumc2(float[] a) {
259 Float result1 = 1.f;
260 Float result2 = ibc;
261 for (Float i : a) {
262 result1 += i;
263 result2 += i + ibc;
264 }
265 return result1 + result2;
266 }
268 //===============================================
269 static float remi_sum() {
270 Float j = new Float(1.f);
271 for (int i = 0; i< 1000; i++) {
272 j = new Float(j + 1.f);
273 }
274 return j;
275 }
277 static float remi_sumb() {
278 Float j = Float.valueOf(1.f);
279 for (int i = 0; i< 1000; i++) {
280 j = j + 1.f;
281 }
282 return j;
283 }
285 static float remi_sumf() {
286 Float j = foob(1.f);
287 for (int i = 0; i< 1000; i++) {
288 j = j + 1.f;
289 }
290 return j;
291 }
293 static float remi_sump(Float j) {
294 for (int i = 0; i< 1000; i++) {
295 j = new Float(j + 1.f);
296 }
297 return j;
298 }
300 static float remi_sumc() {
301 Float j = ibc;
302 for (int i = 0; i< 1000; i++) {
303 j = j + ibc;
304 }
305 return j;
306 }
308 static float remi_sum2() {
309 Float j1 = new Float(1.f);
310 Float j2 = new Float(1.f);
311 for (int i = 0; i< 1000; i++) {
312 j1 = new Float(j1 + 1.f);
313 j2 = new Float(j2 + 2.f);
314 }
315 return j1 + j2;
316 }
318 static float remi_sumb2() {
319 Float j1 = Float.valueOf(1.f);
320 Float j2 = Float.valueOf(1.f);
321 for (int i = 0; i< 1000; i++) {
322 j1 = j1 + 1.f;
323 j2 = j2 + 2.f;
324 }
325 return j1 + j2;
326 }
328 static float remi_summ2() {
329 Float j1 = new Float(1.f);
330 Float j2 = Float.valueOf(1.f);
331 for (int i = 0; i< 1000; i++) {
332 j1 = new Float(j1 + 1.f);
333 j2 = j2 + 2.f;
334 }
335 return j1 + j2;
336 }
338 static float remi_sump2(Float j1) {
339 Float j2 = Float.valueOf(1.f);
340 for (int i = 0; i< 1000; i++) {
341 j1 = new Float(j1 + 1.f);
342 j2 = j2 + 2.f;
343 }
344 return j1 + j2;
345 }
347 static float remi_sumc2() {
348 Float j1 = ibc;
349 Float j2 = Float.valueOf(1.f);
350 for (int i = 0; i< 1000; i++) {
351 j1 = j1 + ibc;
352 j2 = j2 + 2.f;
353 }
354 return j1 + j2;
355 }
358 //===============================================
359 // Safepointa and debug info for deoptimization
360 static float simple_deop(float i) {
361 Float ib = new Float(foo(i));
362 dummy();
363 return ib;
364 }
366 static float simpleb_deop(float i) {
367 Float ib = Float.valueOf(foo(i));
368 dummy();
369 return ib;
370 }
372 static float simplef_deop(float i) {
373 Float ib = foob(i);
374 dummy();
375 return ib;
376 }
378 static float simplep_deop(Float ib) {
379 dummy();
380 return ib;
381 }
383 static float simplec_deop(float i) {
384 Float ib = ibc;
385 dummy();
386 return ib;
387 }
389 static float test_deop(float f, int i) {
390 Float ib = new Float(foo(f));
391 if ((i&1) == 0)
392 ib = foo(f+1.f);
393 dummy();
394 return ib;
395 }
397 static float testb_deop(float f, int i) {
398 Float ib = foo(f);
399 if ((i&1) == 0)
400 ib = foo(f+1.f);
401 dummy();
402 return ib;
403 }
405 static float testf_deop(float f, int i) {
406 Float ib = foob(f);
407 if ((i&1) == 0)
408 ib = foo(f+1.f);
409 dummy();
410 return ib;
411 }
413 static float testp_deop(float f, int i, Float ib) {
414 if ((i&1) == 0)
415 ib = foo(f+1.f);
416 dummy();
417 return ib;
418 }
420 static float testc_deop(float f, int i) {
421 Float ib = ibc;
422 if ((i&1) == 0)
423 ib = foo(f+1.f);
424 dummy();
425 return ib;
426 }
428 static float sum_deop(float[] a) {
429 float result = 1.f;
430 for (Float i : a)
431 result += foo(i);
432 dummy();
433 return result;
434 }
436 static float sumb_deop(float[] a) {
437 Float result = 1.f;
438 for (Float i : a)
439 result += foo(i);
440 dummy();
441 return result;
442 }
444 static float sumf_deop(float[] a) {
445 Float result = 1.f;
446 for (Float i : a)
447 result += foob(i);
448 dummy();
449 return result;
450 }
452 static float sump_deop(float[] a, Float result) {
453 for (Float i : a)
454 result += foob(i);
455 dummy();
456 return result;
457 }
459 static float sumc_deop(float[] a) {
460 Float result = ibc;
461 for (Float i : a)
462 result += foo(i);
463 dummy();
464 return result;
465 }
467 static float remi_sum_deop() {
468 Float j = new Float(foo(1.f));
469 for (int i = 0; i< 1000; i++) {
470 j = new Float(foo(j + 1.f));
471 }
472 dummy();
473 return j;
474 }
476 static float remi_sumb_deop() {
477 Float j = Float.valueOf(foo(1.f));
478 for (int i = 0; i< 1000; i++) {
479 j = foo(j + 1.f);
480 }
481 dummy();
482 return j;
483 }
485 static float remi_sumf_deop() {
486 Float j = foob(1.f);
487 for (int i = 0; i< 1000; i++) {
488 j = foo(j + 1.f);
489 }
490 dummy();
491 return j;
492 }
494 static float remi_sump_deop(Float j) {
495 for (int i = 0; i< 1000; i++) {
496 j = foo(j + 1.f);
497 }
498 dummy();
499 return j;
500 }
502 static float remi_sumc_deop() {
503 Float j = ibc;
504 for (int i = 0; i< 1000; i++) {
505 j = foo(j + 1.f);
506 }
507 dummy();
508 return j;
509 }
511 //===============================================
512 // Conditional increment
513 static float remi_sum_cond() {
514 Float j = new Float(1.f);
515 for (int i = 0; i< 1000; i++) {
516 if ((i&1) == 0) {
517 j = new Float(j + 1.f);
518 }
519 }
520 return j;
521 }
523 static float remi_sumb_cond() {
524 Float j = Float.valueOf(1.f);
525 for (int i = 0; i< 1000; i++) {
526 if ((i&1) == 0) {
527 j = j + 1.f;
528 }
529 }
530 return j;
531 }
533 static float remi_sumf_cond() {
534 Float j = foob(1.f);
535 for (int i = 0; i< 1000; i++) {
536 if ((i&1) == 0) {
537 j = j + 1.f;
538 }
539 }
540 return j;
541 }
543 static float remi_sump_cond(Float j) {
544 for (int i = 0; i< 1000; i++) {
545 if ((i&1) == 0) {
546 j = j + 1.f;
547 }
548 }
549 return j;
550 }
552 static float remi_sumc_cond() {
553 Float j = ibc;
554 for (int i = 0; i< 1000; i++) {
555 if ((i&1) == 0) {
556 j = j + ibc;
557 }
558 }
559 return j;
560 }
562 static float remi_sum2_cond() {
563 Float j1 = new Float(1.f);
564 Float j2 = new Float(1.f);
565 for (int i = 0; i< 1000; i++) {
566 if ((i&1) == 0) {
567 j1 = new Float(j1 + 1.f);
568 } else {
569 j2 = new Float(j2 + 2.f);
570 }
571 }
572 return j1 + j2;
573 }
575 static float remi_sumb2_cond() {
576 Float j1 = Float.valueOf(1.f);
577 Float j2 = Float.valueOf(1.f);
578 for (int i = 0; i< 1000; i++) {
579 if ((i&1) == 0) {
580 j1 = j1 + 1.f;
581 } else {
582 j2 = j2 + 2.f;
583 }
584 }
585 return j1 + j2;
586 }
588 static float remi_summ2_cond() {
589 Float j1 = new Float(1.f);
590 Float j2 = Float.valueOf(1.f);
591 for (int i = 0; i< 1000; i++) {
592 if ((i&1) == 0) {
593 j1 = new Float(j1 + 1.f);
594 } else {
595 j2 = j2 + 2.f;
596 }
597 }
598 return j1 + j2;
599 }
601 static float remi_sump2_cond(Float j1) {
602 Float j2 = Float.valueOf(1.f);
603 for (int i = 0; i< 1000; i++) {
604 if ((i&1) == 0) {
605 j1 = new Float(j1 + 1.f);
606 } else {
607 j2 = j2 + 2.f;
608 }
609 }
610 return j1 + j2;
611 }
613 static float remi_sumc2_cond() {
614 Float j1 = ibc;
615 Float j2 = Float.valueOf(1.f);
616 for (int i = 0; i< 1000; i++) {
617 if ((i&1) == 0) {
618 j1 = j1 + ibc;
619 } else {
620 j2 = j2 + 2;
621 }
622 }
623 return j1 + j2;
624 }
627 public static void main(String[] args) {
628 final int ntests = 70;
630 String[] test_name = new String[] {
631 "simple", "simpleb", "simplec", "simplef", "simplep",
632 "simple2", "simpleb2", "simplec2", "simplem2", "simplep2",
633 "simple_deop", "simpleb_deop", "simplec_deop", "simplef_deop", "simplep_deop",
634 "test", "testb", "testc", "testm", "testp",
635 "test2", "testb2", "testc2", "testm2", "testp2",
636 "test_deop", "testb_deop", "testc_deop", "testf_deop", "testp_deop",
637 "sum", "sumb", "sumc", "sumf", "sump",
638 "sum2", "sumb2", "sumc2", "summ2", "sump2",
639 "sum_deop", "sumb_deop", "sumc_deop", "sumf_deop", "sump_deop",
640 "remi_sum", "remi_sumb", "remi_sumc", "remi_sumf", "remi_sump",
641 "remi_sum2", "remi_sumb2", "remi_sumc2", "remi_summ2", "remi_sump2",
642 "remi_sum_deop", "remi_sumb_deop", "remi_sumc_deop", "remi_sumf_deop", "remi_sump_deop",
643 "remi_sum_cond", "remi_sumb_cond", "remi_sumc_cond", "remi_sumf_cond", "remi_sump_cond",
644 "remi_sum2_cond", "remi_sumb2_cond", "remi_sumc2_cond", "remi_summ2_cond", "remi_sump2_cond"
645 };
647 final float[] val = new float[] {
648 71990896.f, 71990896.f, 12000.f, 71990896.f, 71990896.f,
649 144000000.f, 144000000.f, 72014896.f, 144000000.f, 144000000.f,
650 71990896.f, 71990896.f, 12000.f, 71990896.f, 71990896.f,
651 72000000.f, 72000000.f, 36004096.f, 72000000.f, 72000000.f,
652 144012288.f, 144012288.f, 72033096.f, 144012288.f, 144012288.f,
653 72000000.f, 72000000.f, 36004096.f, 72000000.f, 72000000.f,
654 499501.f, 499501.f, 499501.f, 499501.f, 499501.f,
655 1000002.f, 1000002.f, 1000002.f, 1000002.f, 1000002.f,
656 499501.f, 499501.f, 499501.f, 499501.f, 499501.f,
657 1001.f, 1001.f, 1001.f, 1001.f, 1001.f,
658 3002.f, 3002.f, 3002.f, 3002.f, 3002.f,
659 1001.f, 1001.f, 1001.f, 1001.f, 1001.f,
660 501.f, 501.f, 501.f, 501.f, 501.f,
661 1502.f, 1502.f, 1502.f, 1502.f, 1502.f
662 };
664 float[] res = new float[ntests];
665 for (int i = 0; i < ntests; i++) {
666 res[i] = 0.f;
667 }
670 for (int i = 0; i < 12000; i++) {
671 res[0] += simple(i);
672 res[1] += simpleb(i);
673 res[2] += simplec();
674 res[3] += simplef(i);
675 res[4] += simplep((float)i);
677 res[5] += simple2((float)i);
678 res[6] += simpleb2((float)i);
679 res[7] += simplec2((float)i);
680 res[8] += simplem2((float)i);
681 res[9] += simplep2((float)i, (float)i);
683 res[10] += simple_deop((float)i);
684 res[11] += simpleb_deop((float)i);
685 res[12] += simplec_deop((float)i);
686 res[13] += simplef_deop((float)i);
687 res[14] += simplep_deop((float)i);
689 res[15] += test((float)i, i);
690 res[16] += testb((float)i, i);
691 res[17] += testc((float)i, i);
692 res[18] += testm((float)i, i);
693 res[19] += testp((float)i, i, (float)i);
695 res[20] += test2((float)i, i);
696 res[21] += testb2((float)i, i);
697 res[22] += testc2((float)i, i);
698 res[23] += testm2((float)i, i);
699 res[24] += testp2((float)i, i, (float)i);
701 res[25] += test_deop((float)i, i);
702 res[26] += testb_deop((float)i, i);
703 res[27] += testc_deop((float)i, i);
704 res[28] += testf_deop((float)i, i);
705 res[29] += testp_deop((float)i, i, (float)i);
706 }
708 float[] ia = new float[1000];
709 for (int i = 0; i < 1000; i++) {
710 ia[i] = i;
711 }
713 for (int i = 0; i < 100; i++) {
714 res[30] = sum(ia);
715 res[31] = sumb(ia);
716 res[32] = sumc(ia);
717 res[33] = sumf(ia);
718 res[34] = sump(ia, 1.f);
720 res[35] = sum2(ia);
721 res[36] = sumb2(ia);
722 res[37] = sumc2(ia);
723 res[38] = summ2(ia);
724 res[39] = sump2(ia, 1.f);
726 res[40] = sum_deop(ia);
727 res[41] = sumb_deop(ia);
728 res[42] = sumc_deop(ia);
729 res[43] = sumf_deop(ia);
730 res[44] = sump_deop(ia, 1.f);
732 res[45] = remi_sum();
733 res[46] = remi_sumb();
734 res[47] = remi_sumc();
735 res[48] = remi_sumf();
736 res[49] = remi_sump(1.f);
738 res[50] = remi_sum2();
739 res[51] = remi_sumb2();
740 res[52] = remi_sumc2();
741 res[53] = remi_summ2();
742 res[54] = remi_sump2(1.f);
744 res[55] = remi_sum_deop();
745 res[56] = remi_sumb_deop();
746 res[57] = remi_sumc_deop();
747 res[58] = remi_sumf_deop();
748 res[59] = remi_sump_deop(1.f);
750 res[60] = remi_sum_cond();
751 res[61] = remi_sumb_cond();
752 res[62] = remi_sumc_cond();
753 res[63] = remi_sumf_cond();
754 res[64] = remi_sump_cond(1.f);
756 res[65] = remi_sum2_cond();
757 res[66] = remi_sumb2_cond();
758 res[67] = remi_sumc2_cond();
759 res[68] = remi_summ2_cond();
760 res[69] = remi_sump2_cond(1.f);
761 }
763 int failed = 0;
764 for (int i = 0; i < ntests; i++) {
765 if (res[i] != val[i]) {
766 System.err.println(test_name[i] + ": " + res[i] + " != " + val[i]);
767 failed++;
768 }
769 }
770 if (failed > 0) {
771 System.err.println("Failed " + failed + " tests.");
772 throw new InternalError();
773 } else {
774 System.out.println("Passed.");
775 }
776 }
777 }
