Mercurial > hg > truffle

comparison test/compiler/6934604/TestShortBoxing.java @ 10278:6f3fd5150b67

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
6934604: enable parts of EliminateAutoBox by default Summary: Resurrected autobox elimination code and enabled part of it by default. Reviewed-by: roland, twisti
author kvn
date Wed, 08 May 2013 15:08:01 -0700
parents
children
comparison
equal deleted inserted replaced
10277:aabf54ccedb1 10278:6f3fd5150b67
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 */
23
24 /*
25 * @test
26 * @bug 6934604
27 * @summary enable parts of EliminateAutoBox by default
28 * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:+EliminateAutoBox TestShortBoxing
29 * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:+EliminateAutoBox
30 * -XX:CompileCommand=exclude,TestShortBoxing.dummy -XX:CompileCommand=exclude,TestShortBoxing.foo -XX:CompileCommand=exclude,TestShortBoxing.foob TestShortBoxing
31 * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-EliminateAutoBox
32 * -XX:CompileCommand=exclude,TestShortBoxing.dummy -XX:CompileCommand=exclude,TestShortBoxing.foo -XX:CompileCommand=exclude,TestShortBoxing.foob TestShortBoxing
33 *
34 */
35
36 public class TestShortBoxing {
37
38 static final Short ibc = new Short((short)1);
39
40 //===============================================
41 // Non-inlined methods to test deoptimization info
42 static void dummy() { }
43 static short foo(short i) { return i; }
44 static Short foob(short i) { return Short.valueOf(i); }
45
46
47 static short simple(short i) {
48 Short ib = new Short(i);
49 return ib;
50 }
51
52 static short simpleb(short i) {
53 Short ib = Short.valueOf(i);
54 return ib;
55 }
56
57 static short simplec() {
58 Short ib = ibc;
59 return ib;
60 }
61
62 static short simplef(short i) {
63 Short ib = foob(i);
64 return ib;
65 }
66
67 static short simplep(Short ib) {
68 return ib;
69 }
70
71 static short simple2(short i) {
72 Short ib1 = new Short(i);
73 Short ib2 = new Short((short)(i+1));
74 return (short)(ib1 + ib2);
75 }
76
77 static short simpleb2(short i) {
78 Short ib1 = Short.valueOf(i);
79 Short ib2 = Short.valueOf((short)(i+1));
80 return (short)(ib1 + ib2);
81 }
82
83 static short simplem2(short i) {
84 Short ib1 = new Short(i);
85 Short ib2 = Short.valueOf((short)(i+1));
86 return (short)(ib1 + ib2);
87 }
88
89 static short simplep2(short i, Short ib1) {
90 Short ib2 = Short.valueOf((short)(i+1));
91 return (short)(ib1 + ib2);
92 }
93
94 static short simplec2(short i) {
95 Short ib1 = ibc;
96 Short ib2 = Short.valueOf((short)(i+1));
97 return (short)(ib1 + ib2);
98 }
99
100 //===============================================
101 static short test(short i) {
102 Short ib = new Short(i);
103 if ((i&1) == 0)
104 ib = (short)(i+1);
105 return ib;
106 }
107
108 static short testb(short i) {
109 Short ib = i;
110 if ((i&1) == 0)
111 ib = (short)(i+1);
112 return ib;
113 }
114
115 static short testm(short i) {
116 Short ib = i;
117 if ((i&1) == 0)
118 ib = new Short((short)(i+1));
119 return ib;
120 }
121
122 static short testp(short i, Short ib) {
123 if ((i&1) == 0)
124 ib = new Short((short)(i+1));
125 return ib;
126 }
127
128 static short testc(short i) {
129 Short ib = ibc;
130 if ((i&1) == 0)
131 ib = new Short((short)(i+1));
132 return ib;
133 }
134
135 static short test2(short i) {
136 Short ib1 = new Short(i);
137 Short ib2 = new Short((short)(i+1));
138 if ((i&1) == 0) {
139 ib1 = new Short((short)(i+1));
140 ib2 = new Short((short)(i+2));
141 }
142 return (short)(ib1+ib2);
143 }
144
145 static short testb2(short i) {
146 Short ib1 = i;
147 Short ib2 = (short)(i+1);
148 if ((i&1) == 0) {
149 ib1 = (short)(i+1);
150 ib2 = (short)(i+2);
151 }
152 return (short)(ib1 + ib2);
153 }
154
155 static short testm2(short i) {
156 Short ib1 = new Short(i);
157 Short ib2 = (short)(i+1);
158 if ((i&1) == 0) {
159 ib1 = new Short((short)(i+1));
160 ib2 = (short)(i+2);
161 }
162 return (short)(ib1 + ib2);
163 }
164
165 static short testp2(short i, Short ib1) {
166 Short ib2 = (short)(i+1);
167 if ((i&1) == 0) {
168 ib1 = new Short((short)(i+1));
169 ib2 = (short)(i+2);
170 }
171 return (short)(ib1 + ib2);
172 }
173
174 static short testc2(short i) {
175 Short ib1 = ibc;
176 Short ib2 = (short)(i+1);
177 if ((i&1) == 0) {
178 ib1 = (short)(ibc+1);
179 ib2 = (short)(i+2);
180 }
181 return (short)(ib1 + ib2);
182 }
183
184 //===============================================
185 static short sum(short[] a) {
186 short result = 1;
187 for (Short i : a)
188 result += i;
189 return result;
190 }
191
192 static short sumb(short[] a) {
193 Short result = 1;
194 for (Short i : a)
195 result = (short)(result + i);
196 return result;
197 }
198
199 static short sumc(short[] a) {
200 Short result = ibc;
201 for (Short i : a)
202 result = (short)(result + i);
203 return result;
204 }
205
206 static short sumf(short[] a) {
207 Short result = foob((short)1);
208 for (Short i : a)
209 result = (short)(result + i);
210 return result;
211 }
212
213 static short sump(short[] a, Short result) {
214 for (Short i : a)
215 result = (short)(result + i);
216 return result;
217 }
218
219 static short sum2(short[] a) {
220 short result1 = 1;
221 short result2 = 1;
222 for (Short i : a) {
223 result1 += i;
224 result2 += i + 1;
225 }
226 return (short)(result1 + result2);
227 }
228
229 static short sumb2(short[] a) {
230 Short result1 = 1;
231 Short result2 = 1;
232 for (Short i : a) {
233 result1 = (short)(result1 + i);
234 result2 = (short)(result2 + i + 1);
235 }
236 return (short)(result1 + result2);
237 }
238
239 static short summ2(short[] a) {
240 Short result1 = 1;
241 Short result2 = new Short((short)1);
242 for (Short i : a) {
243 result1 = (short)(result1 + i);
244 result2 = (short)(result2 + new Short((short)(i + 1)));
245 }
246 return (short)(result1 + result2);
247 }
248
249 static short sump2(short[] a, Short result2) {
250 Short result1 = 1;
251 for (Short i : a) {
252 result1 = (short)(result1 + i);
253 result2 = (short)(result2 + i + 1);
254 }
255 return (short)(result1 + result2);
256 }
257
258 static short sumc2(short[] a) {
259 Short result1 = 1;
260 Short result2 = ibc;
261 for (Short i : a) {
262 result1 = (short)(result1 + i);
263 result2 = (short)(result2 + i + ibc);
264 }
265 return (short)(result1 + result2);
266 }
267
268 //===============================================
269 static short remi_sum() {
270 Short j = new Short((short)1);
271 for (int i = 0; i< 1000; i++) {
272 j = new Short((short)(j + 1));
273 }
274 return j;
275 }
276
277 static short remi_sumb() {
278 Short j = Short.valueOf((short)1);
279 for (int i = 0; i< 1000; i++) {
280 j = (short)(j + 1);
281 }
282 return j;
283 }
284
285 static short remi_sumf() {
286 Short j = foob((short)1);
287 for (int i = 0; i< 1000; i++) {
288 j = (short)(j + 1);
289 }
290 return j;
291 }
292
293 static short remi_sump(Short j) {
294 for (int i = 0; i< 1000; i++) {
295 j = new Short((short)(j + 1));
296 }
297 return j;
298 }
299
300 static short remi_sumc() {
301 Short j = ibc;
302 for (int i = 0; i< 1000; i++) {
303 j = (short)(j + ibc);
304 }
305 return j;
306 }
307
308 static short remi_sum2() {
309 Short j1 = new Short((short)1);
310 Short j2 = new Short((short)1);
311 for (int i = 0; i< 1000; i++) {
312 j1 = new Short((short)(j1 + 1));
313 j2 = new Short((short)(j2 + 2));
314 }
315 return (short)(j1 + j2);
316 }
317
318 static short remi_sumb2() {
319 Short j1 = Short.valueOf((short)1);
320 Short j2 = Short.valueOf((short)1);
321 for (int i = 0; i< 1000; i++) {
322 j1 = (short)(j1 + 1);
323 j2 = (short)(j2 + 2);
324 }
325 return (short)(j1 + j2);
326 }
327
328 static short remi_summ2() {
329 Short j1 = new Short((short)1);
330 Short j2 = Short.valueOf((short)1);
331 for (int i = 0; i< 1000; i++) {
332 j1 = new Short((short)(j1 + 1));
333 j2 = (short)(j2 + 2);
334 }
335 return (short)(j1 + j2);
336 }
337
338 static short remi_sump2(Short j1) {
339 Short j2 = Short.valueOf((short)1);
340 for (int i = 0; i< 1000; i++) {
341 j1 = new Short((short)(j1 + 1));
342 j2 = (short)(j2 + 2);
343 }
344 return (short)(j1 + j2);
345 }
346
347 static short remi_sumc2() {
348 Short j1 = ibc;
349 Short j2 = Short.valueOf((short)1);
350 for (int i = 0; i< 1000; i++) {
351 j1 = (short)(j1 + ibc);
352 j2 = (short)(j2 + 2);
353 }
354 return (short)(j1 + j2);
355 }
356
357
358 //===============================================
359 // Safepointa and debug info for deoptimization
360 static short simple_deop(short i) {
361 Short ib = new Short(foo(i));
362 dummy();
363 return ib;
364 }
365
366 static short simpleb_deop(short i) {
367 Short ib = Short.valueOf(foo(i));
368 dummy();
369 return ib;
370 }
371
372 static short simplef_deop(short i) {
373 Short ib = foob(i);
374 dummy();
375 return ib;
376 }
377
378 static short simplep_deop(Short ib) {
379 dummy();
380 return ib;
381 }
382
383 static short simplec_deop(short i) {
384 Short ib = ibc;
385 dummy();
386 return ib;
387 }
388
389 static short test_deop(short i) {
390 Short ib = new Short(foo(i));
391 if ((i&1) == 0)
392 ib = foo((short)(i+1));
393 dummy();
394 return ib;
395 }
396
397 static short testb_deop(short i) {
398 Short ib = foo(i);
399 if ((i&1) == 0)
400 ib = foo((short)(i+1));
401 dummy();
402 return ib;
403 }
404
405 static short testf_deop(short i) {
406 Short ib = foob(i);
407 if ((i&1) == 0)
408 ib = foo((short)(i+1));
409 dummy();
410 return ib;
411 }
412
413 static short testp_deop(short i, Short ib) {
414 if ((i&1) == 0)
415 ib = foo((short)(i+1));
416 dummy();
417 return ib;
418 }
419
420 static short testc_deop(short i) {
421 Short ib = ibc;
422 if ((i&1) == 0)
423 ib = foo((short)(i+1));
424 dummy();
425 return ib;
426 }
427
428 static short sum_deop(short[] a) {
429 short result = 1;
430 for (Short i : a)
431 result += foo(i);
432 dummy();
433 return result;
434 }
435
436 static short sumb_deop(short[] a) {
437 Short result = 1;
438 for (Short i : a)
439 result = (short)(result + foo(i));
440 dummy();
441 return result;
442 }
443
444 static short sumf_deop(short[] a) {
445 Short result = 1;
446 for (Short i : a)
447 result = (short)(result + foob(i));
448 dummy();
449 return result;
450 }
451
452 static short sump_deop(short[] a, Short result) {
453 for (Short i : a)
454 result = (short)(result + foob(i));
455 dummy();
456 return result;
457 }
458
459 static short sumc_deop(short[] a) {
460 Short result = ibc;
461 for (Short i : a)
462 result = (short)(result + foo(i));
463 dummy();
464 return result;
465 }
466
467 static short remi_sum_deop() {
468 Short j = new Short(foo((short)1));
469 for (int i = 0; i< 1000; i++) {
470 j = new Short(foo((short)(j + 1)));
471 }
472 dummy();
473 return j;
474 }
475
476 static short remi_sumb_deop() {
477 Short j = Short.valueOf(foo((short)1));
478 for (int i = 0; i< 1000; i++) {
479 j = foo((short)(j + 1));
480 }
481 dummy();
482 return j;
483 }
484
485 static short remi_sumf_deop() {
486 Short j = foob((short)1);
487 for (int i = 0; i< 1000; i++) {
488 j = foo((short)(j + 1));
489 }
490 dummy();
491 return j;
492 }
493
494 static short remi_sump_deop(Short j) {
495 for (int i = 0; i< 1000; i++) {
496 j = foo((short)(j + 1));
497 }
498 dummy();
499 return j;
500 }
501
502 static short remi_sumc_deop() {
503 Short j = ibc;
504 for (int i = 0; i< 1000; i++) {
505 j = foo((short)(j + 1));
506 }
507 dummy();
508 return j;
509 }
510
511 //===============================================
512 // Conditional increment
513 static short remi_sum_cond() {
514 Short j = new Short((short)1);
515 for (int i = 0; i< 1000; i++) {
516 if ((i&1) == 0) {
517 j = new Short((short)(j + 1));
518 }
519 }
520 return j;
521 }
522
523 static short remi_sumb_cond() {
524 Short j = Short.valueOf((short)1);
525 for (int i = 0; i< 1000; i++) {
526 if ((i&1) == 0) {
527 j = (short)(j + 1);
528 }
529 }
530 return j;
531 }
532
533 static short remi_sumf_cond() {
534 Short j = foob((short)1);
535 for (int i = 0; i< 1000; i++) {
536 if ((i&1) == 0) {
537 j = (short)(j + 1);
538 }
539 }
540 return j;
541 }
542
543 static short remi_sump_cond(Short j) {
544 for (int i = 0; i< 1000; i++) {
545 if ((i&1) == 0) {
546 j = (short)(j + 1);
547 }
548 }
549 return j;
550 }
551
552 static short remi_sumc_cond() {
553 Short j = ibc;
554 for (int i = 0; i< 1000; i++) {
555 if ((i&1) == 0) {
556 j = (short)(j + ibc);
557 }
558 }
559 return j;
560 }
561
562 static short remi_sum2_cond() {
563 Short j1 = new Short((short)1);
564 Short j2 = new Short((short)1);
565 for (int i = 0; i< 1000; i++) {
566 if ((i&1) == 0) {
567 j1 = new Short((short)(j1 + 1));
568 } else {
569 j2 = new Short((short)(j2 + 2));
570 }
571 }
572 return (short)(j1 + j2);
573 }
574
575 static short remi_sumb2_cond() {
576 Short j1 = Short.valueOf((short)1);
577 Short j2 = Short.valueOf((short)1);
578 for (int i = 0; i< 1000; i++) {
579 if ((i&1) == 0) {
580 j1 = (short)(j1 + 1);
581 } else {
582 j2 = (short)(j2 + 2);
583 }
584 }
585 return (short)(j1 + j2);
586 }
587
588 static short remi_summ2_cond() {
589 Short j1 = new Short((short)1);
590 Short j2 = Short.valueOf((short)1);
591 for (int i = 0; i< 1000; i++) {
592 if ((i&1) == 0) {
593 j1 = new Short((short)(j1 + 1));
594 } else {
595 j2 = (short)(j2 + 2);
596 }
597 }
598 return (short)(j1 + j2);
599 }
600
601 static short remi_sump2_cond(Short j1) {
602 Short j2 = Short.valueOf((short)1);
603 for (int i = 0; i< 1000; i++) {
604 if ((i&1) == 0) {
605 j1 = new Short((short)(j1 + 1));
606 } else {
607 j2 = (short)(j2 + 2);
608 }
609 }
610 return (short)(j1 + j2);
611 }
612
613 static short remi_sumc2_cond() {
614 Short j1 = ibc;
615 Short j2 = Short.valueOf((short)1);
616 for (int i = 0; i< 1000; i++) {
617 if ((i&1) == 0) {
618 j1 = (short)(j1 + ibc);
619 } else {
620 j2 = (short)(j2 + 2);
621 }
622 }
623 return (short)(j1 + j2);
624 }
625
626
627 public static void main(String[] args) {
628 final int ntests = 70;
629
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 };
646
647 final int[] val = new int[] {
648 71994000, 71994000, 12000, 71994000, 71994000,
649 144000000, 144000000, 72018000, 144000000, 144000000,
650 71994000, 71994000, 12000, 71994000, 71994000,
651 72000000, 72000000, 36006000, 72000000, 72000000,
652 144012000, 144012000, 72030000, 144012000, 144012000,
653 72000000, 72000000, 36006000, 72000000, 72000000,
654 -24787, -24787, -24787, -24787, -24787,
655 16962, 16962, 16962, 16962, 16962,
656 -24787, -24787, -24787, -24787, -24787,
657 1001, 1001, 1001, 1001, 1001,
658 3002, 3002, 3002, 3002, 3002,
659 1001, 1001, 1001, 1001, 1001,
660 501, 501, 501, 501, 501,
661 1502, 1502, 1502, 1502, 1502
662 };
663
664 int[] res = new int[ntests];
665 for (int i = 0; i < ntests; i++) {
666 res[i] = 0;
667 }
668
669
670 for (int i = 0; i < 12000; i++) {
671 res[0] += simple((short)i);
672 res[1] += simpleb((short)i);
673 res[2] += simplec();
674 res[3] += simplef((short)i);
675 res[4] += simplep((short)i);
676
677 res[5] += simple2((short)i);
678 res[6] += simpleb2((short)i);
679 res[7] += simplec2((short)i);
680 res[8] += simplem2((short)i);
681 res[9] += simplep2((short)i, (short)i);
682
683 res[10] += simple_deop((short)i);
684 res[11] += simpleb_deop((short)i);
685 res[12] += simplec_deop((short)i);
686 res[13] += simplef_deop((short)i);
687 res[14] += simplep_deop((short)i);
688
689 res[15] += test((short)i);
690 res[16] += testb((short)i);
691 res[17] += testc((short)i);
692 res[18] += testm((short)i);
693 res[19] += testp((short)i, (short)i);
694
695 res[20] += test2((short)i);
696 res[21] += testb2((short)i);
697 res[22] += testc2((short)i);
698 res[23] += testm2((short)i);
699 res[24] += testp2((short)i, (short)i);
700
701 res[25] += test_deop((short)i);
702 res[26] += testb_deop((short)i);
703 res[27] += testc_deop((short)i);
704 res[28] += testf_deop((short)i);
705 res[29] += testp_deop((short)i, (short)i);
706 }
707
708 short[] ia = new short[1000];
709 for (int i = 0; i < 1000; i++) {
710 ia[i] = (short)i;
711 }
712
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, (short)1);
719
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, (short)1);
725
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, (short)1);
731
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((short)1);
737
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((short)1);
743
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((short)1);
749
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((short)1);
755
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((short)1);
761 }
762
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 }