1 /*
2 * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
3 * Copyright 2008, 2009, 2010 Red Hat, Inc.
4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 *
6 * This code is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License version 2 only, as
8 * published by the Free Software Foundation.
9 *
10 * This code is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 * version 2 for more details (a copy is included in the LICENSE file that
14 * accompanied this code).
15 *
16 * You should have received a copy of the GNU General Public License version
17 * 2 along with this work; if not, write to the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 * or visit www.oracle.com if you need additional information or have any
22 * questions.
23 *
24 */
25
26 #include "precompiled.hpp"
27 #include "interpreter/bytecodes.hpp"
28 #include "shark/llvmHeaders.hpp"
29 #include "shark/llvmValue.hpp"
30 #include "shark/sharkBlock.hpp"
31 #include "shark/sharkBuilder.hpp"
32 #include "shark/sharkConstant.hpp"
33 #include "shark/sharkState.hpp"
34 #include "shark/sharkValue.hpp"
35 #include "shark/shark_globals.hpp"
36 #include "utilities/debug.hpp"
37
38 using namespace llvm;
39
40 void SharkBlock::parse_bytecode(int start, int limit) {
41 SharkValue *a, *b, *c, *d;
42 int i;
43
44 // Ensure the current state is initialized before we emit any code,
45 // so that any setup code for the state is at the start of the block
46 current_state();
47
48 // Parse the bytecodes
49 iter()->reset_to_bci(start);
50 while (iter()->next_bci() < limit) {
51 NOT_PRODUCT(a = b = c = d = NULL);
52 iter()->next();
53
54 if (SharkTraceBytecodes)
55 tty->print_cr("%4d: %s", bci(), Bytecodes::name(bc()));
56
57 if (has_trap() && trap_bci() == bci()) {
58 do_trap(trap_request());
59 return;
60 }
61
62 if (UseLoopSafepoints) {
63 // XXX if a lcmp is followed by an if_?? then C2 maybe-inserts
64 // the safepoint before the lcmp rather than before the if.
65 // Maybe we should do this too. See parse2.cpp for details.
66 switch (bc()) {
67 case Bytecodes::_goto:
68 case Bytecodes::_ifnull:
69 case Bytecodes::_ifnonnull:
70 case Bytecodes::_if_acmpeq:
71 case Bytecodes::_if_acmpne:
72 case Bytecodes::_ifeq:
73 case Bytecodes::_ifne:
74 case Bytecodes::_iflt:
75 case Bytecodes::_ifle:
76 case Bytecodes::_ifgt:
77 case Bytecodes::_ifge:
78 case Bytecodes::_if_icmpeq:
79 case Bytecodes::_if_icmpne:
80 case Bytecodes::_if_icmplt:
81 case Bytecodes::_if_icmple:
82 case Bytecodes::_if_icmpgt:
83 case Bytecodes::_if_icmpge:
84 if (iter()->get_dest() <= bci())
85 maybe_add_backedge_safepoint();
86 break;
87
88 case Bytecodes::_goto_w:
89 if (iter()->get_far_dest() <= bci())
90 maybe_add_backedge_safepoint();
91 break;
92
93 case Bytecodes::_tableswitch:
94 case Bytecodes::_lookupswitch:
95 if (switch_default_dest() <= bci()) {
96 maybe_add_backedge_safepoint();
97 break;
98 }
99 int len = switch_table_length();
100 for (int i = 0; i < len; i++) {
101 if (switch_dest(i) <= bci()) {
102 maybe_add_backedge_safepoint();
103 break;
104 }
105 }
106 break;
107 }
108 }
109
110 switch (bc()) {
111 case Bytecodes::_nop:
112 break;
113
114 case Bytecodes::_aconst_null:
115 push(SharkValue::null());
116 break;
117
118 case Bytecodes::_iconst_m1:
119 push(SharkValue::jint_constant(-1));
120 break;
121 case Bytecodes::_iconst_0:
122 push(SharkValue::jint_constant(0));
123 break;
124 case Bytecodes::_iconst_1:
125 push(SharkValue::jint_constant(1));
126 break;
127 case Bytecodes::_iconst_2:
128 push(SharkValue::jint_constant(2));
129 break;
130 case Bytecodes::_iconst_3:
131 push(SharkValue::jint_constant(3));
132 break;
133 case Bytecodes::_iconst_4:
134 push(SharkValue::jint_constant(4));
135 break;
136 case Bytecodes::_iconst_5:
137 push(SharkValue::jint_constant(5));
138 break;
139
140 case Bytecodes::_lconst_0:
141 push(SharkValue::jlong_constant(0));
142 break;
143 case Bytecodes::_lconst_1:
144 push(SharkValue::jlong_constant(1));
145 break;
146
147 case Bytecodes::_fconst_0:
148 push(SharkValue::jfloat_constant(0));
149 break;
150 case Bytecodes::_fconst_1:
151 push(SharkValue::jfloat_constant(1));
152 break;
153 case Bytecodes::_fconst_2:
154 push(SharkValue::jfloat_constant(2));
155 break;
156
157 case Bytecodes::_dconst_0:
158 push(SharkValue::jdouble_constant(0));
159 break;
160 case Bytecodes::_dconst_1:
161 push(SharkValue::jdouble_constant(1));
162 break;
163
164 case Bytecodes::_bipush:
165 push(SharkValue::jint_constant(iter()->get_constant_u1()));
166 break;
167 case Bytecodes::_sipush:
168 push(SharkValue::jint_constant(iter()->get_constant_u2()));
169 break;
170
171 case Bytecodes::_ldc:
172 case Bytecodes::_ldc_w:
173 case Bytecodes::_ldc2_w:
174 push(SharkConstant::for_ldc(iter())->value(builder()));
175 break;
176
177 case Bytecodes::_iload_0:
178 case Bytecodes::_lload_0:
179 case Bytecodes::_fload_0:
180 case Bytecodes::_dload_0:
181 case Bytecodes::_aload_0:
182 push(local(0));
183 break;
184 case Bytecodes::_iload_1:
185 case Bytecodes::_lload_1:
186 case Bytecodes::_fload_1:
187 case Bytecodes::_dload_1:
188 case Bytecodes::_aload_1:
189 push(local(1));
190 break;
191 case Bytecodes::_iload_2:
192 case Bytecodes::_lload_2:
193 case Bytecodes::_fload_2:
194 case Bytecodes::_dload_2:
195 case Bytecodes::_aload_2:
196 push(local(2));
197 break;
198 case Bytecodes::_iload_3:
199 case Bytecodes::_lload_3:
200 case Bytecodes::_fload_3:
201 case Bytecodes::_dload_3:
202 case Bytecodes::_aload_3:
203 push(local(3));
204 break;
205 case Bytecodes::_iload:
206 case Bytecodes::_lload:
207 case Bytecodes::_fload:
208 case Bytecodes::_dload:
209 case Bytecodes::_aload:
210 push(local(iter()->get_index()));
211 break;
212
213 case Bytecodes::_baload:
214 do_aload(T_BYTE);
215 break;
216 case Bytecodes::_caload:
217 do_aload(T_CHAR);
218 break;
219 case Bytecodes::_saload:
220 do_aload(T_SHORT);
221 break;
222 case Bytecodes::_iaload:
223 do_aload(T_INT);
224 break;
225 case Bytecodes::_laload:
226 do_aload(T_LONG);
227 break;
228 case Bytecodes::_faload:
229 do_aload(T_FLOAT);
230 break;
231 case Bytecodes::_daload:
232 do_aload(T_DOUBLE);
233 break;
234 case Bytecodes::_aaload:
235 do_aload(T_OBJECT);
236 break;
237
238 case Bytecodes::_istore_0:
239 case Bytecodes::_lstore_0:
240 case Bytecodes::_fstore_0:
241 case Bytecodes::_dstore_0:
242 case Bytecodes::_astore_0:
243 set_local(0, pop());
244 break;
245 case Bytecodes::_istore_1:
246 case Bytecodes::_lstore_1:
247 case Bytecodes::_fstore_1:
248 case Bytecodes::_dstore_1:
249 case Bytecodes::_astore_1:
250 set_local(1, pop());
251 break;
252 case Bytecodes::_istore_2:
253 case Bytecodes::_lstore_2:
254 case Bytecodes::_fstore_2:
255 case Bytecodes::_dstore_2:
256 case Bytecodes::_astore_2:
257 set_local(2, pop());
258 break;
259 case Bytecodes::_istore_3:
260 case Bytecodes::_lstore_3:
261 case Bytecodes::_fstore_3:
262 case Bytecodes::_dstore_3:
263 case Bytecodes::_astore_3:
264 set_local(3, pop());
265 break;
266 case Bytecodes::_istore:
267 case Bytecodes::_lstore:
268 case Bytecodes::_fstore:
269 case Bytecodes::_dstore:
270 case Bytecodes::_astore:
271 set_local(iter()->get_index(), pop());
272 break;
273
274 case Bytecodes::_bastore:
275 do_astore(T_BYTE);
276 break;
277 case Bytecodes::_castore:
278 do_astore(T_CHAR);
279 break;
280 case Bytecodes::_sastore:
281 do_astore(T_SHORT);
282 break;
283 case Bytecodes::_iastore:
284 do_astore(T_INT);
285 break;
286 case Bytecodes::_lastore:
287 do_astore(T_LONG);
288 break;
289 case Bytecodes::_fastore:
290 do_astore(T_FLOAT);
291 break;
292 case Bytecodes::_dastore:
293 do_astore(T_DOUBLE);
294 break;
295 case Bytecodes::_aastore:
296 do_astore(T_OBJECT);
297 break;
298
299 case Bytecodes::_pop:
300 xpop();
301 break;
302 case Bytecodes::_pop2:
303 xpop();
304 xpop();
305 break;
306 case Bytecodes::_swap:
307 a = xpop();
308 b = xpop();
309 xpush(a);
310 xpush(b);
311 break;
312 case Bytecodes::_dup:
313 a = xpop();
314 xpush(a);
315 xpush(a);
316 break;
317 case Bytecodes::_dup_x1:
318 a = xpop();
319 b = xpop();
320 xpush(a);
321 xpush(b);
322 xpush(a);
323 break;
324 case Bytecodes::_dup_x2:
325 a = xpop();
326 b = xpop();
327 c = xpop();
328 xpush(a);
329 xpush(c);
330 xpush(b);
331 xpush(a);
332 break;
333 case Bytecodes::_dup2:
334 a = xpop();
335 b = xpop();
336 xpush(b);
337 xpush(a);
338 xpush(b);
339 xpush(a);
340 break;
341 case Bytecodes::_dup2_x1:
342 a = xpop();
343 b = xpop();
344 c = xpop();
345 xpush(b);
346 xpush(a);
347 xpush(c);
348 xpush(b);
349 xpush(a);
350 break;
351 case Bytecodes::_dup2_x2:
352 a = xpop();
353 b = xpop();
354 c = xpop();
355 d = xpop();
356 xpush(b);
357 xpush(a);
358 xpush(d);
359 xpush(c);
360 xpush(b);
361 xpush(a);
362 break;
363
364 case Bytecodes::_arraylength:
365 do_arraylength();
366 break;
367
368 case Bytecodes::_getfield:
369 do_getfield();
370 break;
371 case Bytecodes::_getstatic:
372 do_getstatic();
373 break;
374 case Bytecodes::_putfield:
375 do_putfield();
376 break;
377 case Bytecodes::_putstatic:
378 do_putstatic();
379 break;
380
381 case Bytecodes::_iadd:
382 b = pop();
383 a = pop();
384 push(SharkValue::create_jint(
385 builder()->CreateAdd(a->jint_value(), b->jint_value()), false));
386 break;
387 case Bytecodes::_isub:
388 b = pop();
389 a = pop();
390 push(SharkValue::create_jint(
391 builder()->CreateSub(a->jint_value(), b->jint_value()), false));
392 break;
393 case Bytecodes::_imul:
394 b = pop();
395 a = pop();
396 push(SharkValue::create_jint(
397 builder()->CreateMul(a->jint_value(), b->jint_value()), false));
398 break;
399 case Bytecodes::_idiv:
400 do_idiv();
401 break;
402 case Bytecodes::_irem:
403 do_irem();
404 break;
405 case Bytecodes::_ineg:
406 a = pop();
407 push(SharkValue::create_jint(
408 builder()->CreateNeg(a->jint_value()), a->zero_checked()));
409 break;
410 case Bytecodes::_ishl:
411 b = pop();
412 a = pop();
413 push(SharkValue::create_jint(
414 builder()->CreateShl(
415 a->jint_value(),
416 builder()->CreateAnd(
417 b->jint_value(), LLVMValue::jint_constant(0x1f))), false));
418 break;
419 case Bytecodes::_ishr:
420 b = pop();
421 a = pop();
422 push(SharkValue::create_jint(
423 builder()->CreateAShr(
424 a->jint_value(),
425 builder()->CreateAnd(
426 b->jint_value(), LLVMValue::jint_constant(0x1f))), false));
427 break;
428 case Bytecodes::_iushr:
429 b = pop();
430 a = pop();
431 push(SharkValue::create_jint(
432 builder()->CreateLShr(
433 a->jint_value(),
434 builder()->CreateAnd(
435 b->jint_value(), LLVMValue::jint_constant(0x1f))), false));
436 break;
437 case Bytecodes::_iand:
438 b = pop();
439 a = pop();
440 push(SharkValue::create_jint(
441 builder()->CreateAnd(a->jint_value(), b->jint_value()), false));
442 break;
443 case Bytecodes::_ior:
444 b = pop();
445 a = pop();
446 push(SharkValue::create_jint(
447 builder()->CreateOr(a->jint_value(), b->jint_value()),
448 a->zero_checked() && b->zero_checked()));
449 break;
450 case Bytecodes::_ixor:
451 b = pop();
452 a = pop();
453 push(SharkValue::create_jint(
454 builder()->CreateXor(a->jint_value(), b->jint_value()), false));
455 break;
456
457 case Bytecodes::_ladd:
458 b = pop();
459 a = pop();
460 push(SharkValue::create_jlong(
461 builder()->CreateAdd(a->jlong_value(), b->jlong_value()), false));
462 break;
463 case Bytecodes::_lsub:
464 b = pop();
465 a = pop();
466 push(SharkValue::create_jlong(
467 builder()->CreateSub(a->jlong_value(), b->jlong_value()), false));
468 break;
469 case Bytecodes::_lmul:
470 b = pop();
471 a = pop();
472 push(SharkValue::create_jlong(
473 builder()->CreateMul(a->jlong_value(), b->jlong_value()), false));
474 break;
475 case Bytecodes::_ldiv:
476 do_ldiv();
477 break;
478 case Bytecodes::_lrem:
479 do_lrem();
480 break;
481 case Bytecodes::_lneg:
482 a = pop();
483 push(SharkValue::create_jlong(
484 builder()->CreateNeg(a->jlong_value()), a->zero_checked()));
485 break;
486 case Bytecodes::_lshl:
487 b = pop();
488 a = pop();
489 push(SharkValue::create_jlong(
490 builder()->CreateShl(
491 a->jlong_value(),
492 builder()->CreateIntCast(
493 builder()->CreateAnd(
494 b->jint_value(), LLVMValue::jint_constant(0x3f)),
495 SharkType::jlong_type(), true)), false));
496 break;
497 case Bytecodes::_lshr:
498 b = pop();
499 a = pop();
500 push(SharkValue::create_jlong(
501 builder()->CreateAShr(
502 a->jlong_value(),
503 builder()->CreateIntCast(
504 builder()->CreateAnd(
505 b->jint_value(), LLVMValue::jint_constant(0x3f)),
506 SharkType::jlong_type(), true)), false));
507 break;
508 case Bytecodes::_lushr:
509 b = pop();
510 a = pop();
511 push(SharkValue::create_jlong(
512 builder()->CreateLShr(
513 a->jlong_value(),
514 builder()->CreateIntCast(
515 builder()->CreateAnd(
516 b->jint_value(), LLVMValue::jint_constant(0x3f)),
517 SharkType::jlong_type(), true)), false));
518 break;
519 case Bytecodes::_land:
520 b = pop();
521 a = pop();
522 push(SharkValue::create_jlong(
523 builder()->CreateAnd(a->jlong_value(), b->jlong_value()), false));
524 break;
525 case Bytecodes::_lor:
526 b = pop();
527 a = pop();
528 push(SharkValue::create_jlong(
529 builder()->CreateOr(a->jlong_value(), b->jlong_value()),
530 a->zero_checked() && b->zero_checked()));
531 break;
532 case Bytecodes::_lxor:
533 b = pop();
534 a = pop();
535 push(SharkValue::create_jlong(
536 builder()->CreateXor(a->jlong_value(), b->jlong_value()), false));
537 break;
538
539 case Bytecodes::_fadd:
540 b = pop();
541 a = pop();
542 push(SharkValue::create_jfloat(
543 builder()->CreateFAdd(a->jfloat_value(), b->jfloat_value())));
544 break;
545 case Bytecodes::_fsub:
546 b = pop();
547 a = pop();
548 push(SharkValue::create_jfloat(
549 builder()->CreateFSub(a->jfloat_value(), b->jfloat_value())));
550 break;
551 case Bytecodes::_fmul:
552 b = pop();
553 a = pop();
554 push(SharkValue::create_jfloat(
555 builder()->CreateFMul(a->jfloat_value(), b->jfloat_value())));
556 break;
557 case Bytecodes::_fdiv:
558 b = pop();
559 a = pop();
560 push(SharkValue::create_jfloat(
561 builder()->CreateFDiv(a->jfloat_value(), b->jfloat_value())));
562 break;
563 case Bytecodes::_frem:
564 b = pop();
565 a = pop();
566 push(SharkValue::create_jfloat(
567 builder()->CreateFRem(a->jfloat_value(), b->jfloat_value())));
568 break;
569 case Bytecodes::_fneg:
570 a = pop();
571 push(SharkValue::create_jfloat(
572 builder()->CreateFNeg(a->jfloat_value())));
573 break;
574
575 case Bytecodes::_dadd:
576 b = pop();
577 a = pop();
578 push(SharkValue::create_jdouble(
579 builder()->CreateFAdd(a->jdouble_value(), b->jdouble_value())));
580 break;
581 case Bytecodes::_dsub:
582 b = pop();
583 a = pop();
584 push(SharkValue::create_jdouble(
585 builder()->CreateFSub(a->jdouble_value(), b->jdouble_value())));
586 break;
587 case Bytecodes::_dmul:
588 b = pop();
589 a = pop();
590 push(SharkValue::create_jdouble(
591 builder()->CreateFMul(a->jdouble_value(), b->jdouble_value())));
592 break;
593 case Bytecodes::_ddiv:
594 b = pop();
595 a = pop();
596 push(SharkValue::create_jdouble(
597 builder()->CreateFDiv(a->jdouble_value(), b->jdouble_value())));
598 break;
599 case Bytecodes::_drem:
600 b = pop();
601 a = pop();
602 push(SharkValue::create_jdouble(
603 builder()->CreateFRem(a->jdouble_value(), b->jdouble_value())));
604 break;
605 case Bytecodes::_dneg:
606 a = pop();
607 push(SharkValue::create_jdouble(
608 builder()->CreateFNeg(a->jdouble_value())));
609 break;
610
611 case Bytecodes::_iinc:
612 i = iter()->get_index();
613 set_local(
614 i,
615 SharkValue::create_jint(
616 builder()->CreateAdd(
617 LLVMValue::jint_constant(iter()->get_iinc_con()),
618 local(i)->jint_value()), false));
619 break;
620
621 case Bytecodes::_lcmp:
622 do_lcmp();
623 break;
624
625 case Bytecodes::_fcmpl:
626 do_fcmp(false, false);
627 break;
628 case Bytecodes::_fcmpg:
629 do_fcmp(false, true);
630 break;
631 case Bytecodes::_dcmpl:
632 do_fcmp(true, false);
633 break;
634 case Bytecodes::_dcmpg:
635 do_fcmp(true, true);
636 break;
637
638 case Bytecodes::_i2l:
639 a = pop();
640 push(SharkValue::create_jlong(
641 builder()->CreateIntCast(
642 a->jint_value(), SharkType::jlong_type(), true), a->zero_checked()));
643 break;
644 case Bytecodes::_i2f:
645 push(SharkValue::create_jfloat(
646 builder()->CreateSIToFP(
647 pop()->jint_value(), SharkType::jfloat_type())));
648 break;
649 case Bytecodes::_i2d:
650 push(SharkValue::create_jdouble(
651 builder()->CreateSIToFP(
652 pop()->jint_value(), SharkType::jdouble_type())));
653 break;
654
655 case Bytecodes::_l2i:
656 push(SharkValue::create_jint(
657 builder()->CreateIntCast(
658 pop()->jlong_value(), SharkType::jint_type(), true), false));
659 break;
660 case Bytecodes::_l2f:
661 push(SharkValue::create_jfloat(
662 builder()->CreateSIToFP(
663 pop()->jlong_value(), SharkType::jfloat_type())));
664 break;
665 case Bytecodes::_l2d:
666 push(SharkValue::create_jdouble(
667 builder()->CreateSIToFP(
668 pop()->jlong_value(), SharkType::jdouble_type())));
669 break;
670
671 case Bytecodes::_f2i:
672 push(SharkValue::create_jint(
673 builder()->CreateCall(
674 builder()->f2i(), pop()->jfloat_value()), false));
675 break;
676 case Bytecodes::_f2l:
677 push(SharkValue::create_jlong(
678 builder()->CreateCall(
679 builder()->f2l(), pop()->jfloat_value()), false));
680 break;
681 case Bytecodes::_f2d:
682 push(SharkValue::create_jdouble(
683 builder()->CreateFPExt(
684 pop()->jfloat_value(), SharkType::jdouble_type())));
685 break;
686
687 case Bytecodes::_d2i:
688 push(SharkValue::create_jint(
689 builder()->CreateCall(
690 builder()->d2i(), pop()->jdouble_value()), false));
691 break;
692 case Bytecodes::_d2l:
693 push(SharkValue::create_jlong(
694 builder()->CreateCall(
695 builder()->d2l(), pop()->jdouble_value()), false));
696 break;
697 case Bytecodes::_d2f:
698 push(SharkValue::create_jfloat(
699 builder()->CreateFPTrunc(
700 pop()->jdouble_value(), SharkType::jfloat_type())));
701 break;
702
703 case Bytecodes::_i2b:
704 push(SharkValue::create_jint(
705 builder()->CreateAShr(
706 builder()->CreateShl(
707 pop()->jint_value(),
708 LLVMValue::jint_constant(24)),
709 LLVMValue::jint_constant(24)), false));
710 break;
711 case Bytecodes::_i2c:
712 push(SharkValue::create_jint(
713 builder()->CreateAnd(
714 pop()->jint_value(),
715 LLVMValue::jint_constant(0xffff)), false));
716 break;
717 case Bytecodes::_i2s:
718 push(SharkValue::create_jint(
719 builder()->CreateAShr(
720 builder()->CreateShl(
721 pop()->jint_value(),
722 LLVMValue::jint_constant(16)),
723 LLVMValue::jint_constant(16)), false));
724 break;
725
726 case Bytecodes::_return:
727 do_return(T_VOID);
728 break;
729 case Bytecodes::_ireturn:
730 do_return(T_INT);
731 break;
732 case Bytecodes::_lreturn:
733 do_return(T_LONG);
734 break;
735 case Bytecodes::_freturn:
736 do_return(T_FLOAT);
737 break;
738 case Bytecodes::_dreturn:
739 do_return(T_DOUBLE);
740 break;
741 case Bytecodes::_areturn:
742 do_return(T_OBJECT);
743 break;
744
745 case Bytecodes::_athrow:
746 do_athrow();
747 break;
748
749 case Bytecodes::_goto:
750 case Bytecodes::_goto_w:
751 do_goto();
752 break;
753
754 case Bytecodes::_jsr:
755 case Bytecodes::_jsr_w:
756 do_jsr();
757 break;
758
759 case Bytecodes::_ret:
760 do_ret();
761 break;
762
763 case Bytecodes::_ifnull:
764 do_if(ICmpInst::ICMP_EQ, SharkValue::null(), pop());
765 break;
766 case Bytecodes::_ifnonnull:
767 do_if(ICmpInst::ICMP_NE, SharkValue::null(), pop());
768 break;
769 case Bytecodes::_if_acmpeq:
770 b = pop();
771 a = pop();
772 do_if(ICmpInst::ICMP_EQ, b, a);
773 break;
774 case Bytecodes::_if_acmpne:
775 b = pop();
776 a = pop();
777 do_if(ICmpInst::ICMP_NE, b, a);
778 break;
779 case Bytecodes::_ifeq:
780 do_if(ICmpInst::ICMP_EQ, SharkValue::jint_constant(0), pop());
781 break;
782 case Bytecodes::_ifne:
783 do_if(ICmpInst::ICMP_NE, SharkValue::jint_constant(0), pop());
784 break;
785 case Bytecodes::_iflt:
786 do_if(ICmpInst::ICMP_SLT, SharkValue::jint_constant(0), pop());
787 break;
788 case Bytecodes::_ifle:
789 do_if(ICmpInst::ICMP_SLE, SharkValue::jint_constant(0), pop());
790 break;
791 case Bytecodes::_ifgt:
792 do_if(ICmpInst::ICMP_SGT, SharkValue::jint_constant(0), pop());
793 break;
794 case Bytecodes::_ifge:
795 do_if(ICmpInst::ICMP_SGE, SharkValue::jint_constant(0), pop());
796 break;
797 case Bytecodes::_if_icmpeq:
798 b = pop();
799 a = pop();
800 do_if(ICmpInst::ICMP_EQ, b, a);
801 break;
802 case Bytecodes::_if_icmpne:
803 b = pop();
804 a = pop();
805 do_if(ICmpInst::ICMP_NE, b, a);
806 break;
807 case Bytecodes::_if_icmplt:
808 b = pop();
809 a = pop();
810 do_if(ICmpInst::ICMP_SLT, b, a);
811 break;
812 case Bytecodes::_if_icmple:
813 b = pop();
814 a = pop();
815 do_if(ICmpInst::ICMP_SLE, b, a);
816 break;
817 case Bytecodes::_if_icmpgt:
818 b = pop();
819 a = pop();
820 do_if(ICmpInst::ICMP_SGT, b, a);
821 break;
822 case Bytecodes::_if_icmpge:
823 b = pop();
824 a = pop();
825 do_if(ICmpInst::ICMP_SGE, b, a);
826 break;
827
828 case Bytecodes::_tableswitch:
829 case Bytecodes::_lookupswitch:
830 do_switch();
831 break;
832
833 case Bytecodes::_invokestatic:
834 case Bytecodes::_invokespecial:
835 case Bytecodes::_invokevirtual:
836 case Bytecodes::_invokeinterface:
837 do_call();
838 break;
839
840 case Bytecodes::_instanceof:
841 // This is a very common construct:
842 //
843 // if (object instanceof Klass) {
844 // something = (Klass) object;
845 // ...
846 // }
847 //
848 // which gets compiled to something like this:
849 //
850 // 28: aload 9
851 // 30: instanceof <Class Klass>
852 // 33: ifeq 52
853 // 36: aload 9
854 // 38: checkcast <Class Klass>
855 //
856 // Handling both bytecodes at once allows us
857 // to eliminate the checkcast.
858 if (iter()->next_bci() < limit &&
859 (iter()->next_bc() == Bytecodes::_ifeq ||
860 iter()->next_bc() == Bytecodes::_ifne) &&
861 (!UseLoopSafepoints ||
862 iter()->next_get_dest() > iter()->next_bci())) {
863 if (maybe_do_instanceof_if()) {
864 iter()->next();
865 if (SharkTraceBytecodes)
866 tty->print_cr("%4d: %s", bci(), Bytecodes::name(bc()));
867 break;
868 }
869 }
870 // fall through
871 case Bytecodes::_checkcast:
872 do_instance_check();
873 break;
874
875 case Bytecodes::_new:
876 do_new();
877 break;
878 case Bytecodes::_newarray:
879 do_newarray();
880 break;
881 case Bytecodes::_anewarray:
882 do_anewarray();
883 break;
884 case Bytecodes::_multianewarray:
885 do_multianewarray();
886 break;
887
888 case Bytecodes::_monitorenter:
889 do_monitorenter();
890 break;
891 case Bytecodes::_monitorexit:
892 do_monitorexit();
893 break;
894
895 default:
896 ShouldNotReachHere();
897 }
898 }
899 }
900
901 SharkState* SharkBlock::initial_current_state() {
902 return entry_state()->copy();
903 }
904
905 int SharkBlock::switch_default_dest() {
906 return iter()->get_dest_table(0);
907 }
908
909 int SharkBlock::switch_table_length() {
910 switch(bc()) {
911 case Bytecodes::_tableswitch:
912 return iter()->get_int_table(2) - iter()->get_int_table(1) + 1;
913
914 case Bytecodes::_lookupswitch:
915 return iter()->get_int_table(1);
916
917 default:
918 ShouldNotReachHere();
919 }
920 }
921
922 int SharkBlock::switch_key(int i) {
923 switch(bc()) {
924 case Bytecodes::_tableswitch:
925 return iter()->get_int_table(1) + i;
926
927 case Bytecodes::_lookupswitch:
928 return iter()->get_int_table(2 + 2 * i);
929
930 default:
931 ShouldNotReachHere();
932 }
933 }
934
935 int SharkBlock::switch_dest(int i) {
936 switch(bc()) {
937 case Bytecodes::_tableswitch:
938 return iter()->get_dest_table(i + 3);
939
940 case Bytecodes::_lookupswitch:
941 return iter()->get_dest_table(2 + 2 * i + 1);
942
943 default:
944 ShouldNotReachHere();
945 }
946 }
947
948 void SharkBlock::do_div_or_rem(bool is_long, bool is_rem) {
949 SharkValue *sb = pop();
950 SharkValue *sa = pop();
951
952 check_divide_by_zero(sb);
953
954 Value *a, *b, *p, *q;
955 if (is_long) {
956 a = sa->jlong_value();
957 b = sb->jlong_value();
958 p = LLVMValue::jlong_constant(0x8000000000000000LL);
959 q = LLVMValue::jlong_constant(-1);
960 }
961 else {
962 a = sa->jint_value();
963 b = sb->jint_value();
964 p = LLVMValue::jint_constant(0x80000000);
965 q = LLVMValue::jint_constant(-1);
966 }
967
968 BasicBlock *ip = builder()->GetBlockInsertionPoint();
969 BasicBlock *special_case = builder()->CreateBlock(ip, "special_case");
970 BasicBlock *general_case = builder()->CreateBlock(ip, "general_case");
971 BasicBlock *done = builder()->CreateBlock(ip, "done");
972
973 builder()->CreateCondBr(
974 builder()->CreateAnd(
975 builder()->CreateICmpEQ(a, p),
976 builder()->CreateICmpEQ(b, q)),
977 special_case, general_case);
978
979 builder()->SetInsertPoint(special_case);
980 Value *special_result;
981 if (is_rem) {
982 if (is_long)
983 special_result = LLVMValue::jlong_constant(0);
984 else
985 special_result = LLVMValue::jint_constant(0);
986 }
987 else {
988 special_result = a;
989 }
990 builder()->CreateBr(done);
991
992 builder()->SetInsertPoint(general_case);
993 Value *general_result;
994 if (is_rem)
995 general_result = builder()->CreateSRem(a, b);
996 else
997 general_result = builder()->CreateSDiv(a, b);
998 builder()->CreateBr(done);
999
1000 builder()->SetInsertPoint(done);
1001 PHINode *result;
1002 if (is_long)
1003 result = builder()->CreatePHI(SharkType::jlong_type(), "result");
1004 else
1005 result = builder()->CreatePHI(SharkType::jint_type(), "result");
1006 result->addIncoming(special_result, special_case);
1007 result->addIncoming(general_result, general_case);
1008
1009 if (is_long)
1010 push(SharkValue::create_jlong(result, false));
1011 else
1012 push(SharkValue::create_jint(result, false));
1013 }
1014
1015 void SharkBlock::do_field_access(bool is_get, bool is_field) {
1016 bool will_link;
1017 ciField *field = iter()->get_field(will_link);
1018 assert(will_link, "typeflow responsibility");
1019 assert(is_field != field->is_static(), "mismatch");
1020
1021 // Pop the value off the stack where necessary
1022 SharkValue *value = NULL;
1023 if (!is_get)
1024 value = pop();
1025
1026 // Find the object we're accessing, if necessary
1027 Value *object = NULL;
1028 if (is_field) {
1029 SharkValue *value = pop();
1030 check_null(value);
1031 object = value->generic_value();
1032 }
1033 if (is_get && field->is_constant()) {
1034 SharkConstant *constant = SharkConstant::for_field(iter());
1035 if (constant->is_loaded())
1036 value = constant->value(builder());
1037 }
1038 if (!is_get || value == NULL) {
1039 if (!is_field)
1040 object = builder()->CreateInlineOop(field->holder());
1041
1042 BasicType basic_type = field->type()->basic_type();
1043 const Type *stack_type = SharkType::to_stackType(basic_type);
1044 const Type *field_type = SharkType::to_arrayType(basic_type);
1045
1046 Value *addr = builder()->CreateAddressOfStructEntry(
1047 object, in_ByteSize(field->offset_in_bytes()),
1048 PointerType::getUnqual(field_type),
1049 "addr");
1050
1051 // Do the access
1052 if (is_get) {
1053 Value *field_value = builder()->CreateLoad(addr);
1054
1055 if (field_type != stack_type) {
1056 field_value = builder()->CreateIntCast(
1057 field_value, stack_type, basic_type != T_CHAR);
1058 }
1059
1060 value = SharkValue::create_generic(field->type(), field_value, false);
1061 }
1062 else {
1063 Value *field_value = value->generic_value();
1064
1065 if (field_type != stack_type) {
1066 field_value = builder()->CreateIntCast(
1067 field_value, field_type, basic_type != T_CHAR);
1068 }
1069
1070 builder()->CreateStore(field_value, addr);
1071
1072 if (!field->type()->is_primitive_type())
1073 builder()->CreateUpdateBarrierSet(oopDesc::bs(), addr);
1074
1075 if (field->is_volatile())
1076 builder()->CreateMemoryBarrier(SharkBuilder::BARRIER_STORELOAD);
1077 }
1078 }
1079
1080 // Push the value onto the stack where necessary
1081 if (is_get)
1082 push(value);
1083 }
1084
1085 void SharkBlock::do_lcmp() {
1086 Value *b = pop()->jlong_value();
1087 Value *a = pop()->jlong_value();
1088
1089 BasicBlock *ip = builder()->GetBlockInsertionPoint();
1090 BasicBlock *ne = builder()->CreateBlock(ip, "lcmp_ne");
1091 BasicBlock *lt = builder()->CreateBlock(ip, "lcmp_lt");
1092 BasicBlock *gt = builder()->CreateBlock(ip, "lcmp_gt");
1093 BasicBlock *done = builder()->CreateBlock(ip, "done");
1094
1095 BasicBlock *eq = builder()->GetInsertBlock();
1096 builder()->CreateCondBr(builder()->CreateICmpEQ(a, b), done, ne);
1097
1098 builder()->SetInsertPoint(ne);
1099 builder()->CreateCondBr(builder()->CreateICmpSLT(a, b), lt, gt);
1100
1101 builder()->SetInsertPoint(lt);
1102 builder()->CreateBr(done);
1103
1104 builder()->SetInsertPoint(gt);
1105 builder()->CreateBr(done);
1106
1107 builder()->SetInsertPoint(done);
1108 PHINode *result = builder()->CreatePHI(SharkType::jint_type(), "result");
1109 result->addIncoming(LLVMValue::jint_constant(-1), lt);
1110 result->addIncoming(LLVMValue::jint_constant(0), eq);
1111 result->addIncoming(LLVMValue::jint_constant(1), gt);
1112
1113 push(SharkValue::create_jint(result, false));
1114 }
1115
1116 void SharkBlock::do_fcmp(bool is_double, bool unordered_is_greater) {
1117 Value *a, *b;
1118 if (is_double) {
1119 b = pop()->jdouble_value();
1120 a = pop()->jdouble_value();
1121 }
1122 else {
1123 b = pop()->jfloat_value();
1124 a = pop()->jfloat_value();
1125 }
1126
1127 BasicBlock *ip = builder()->GetBlockInsertionPoint();
1128 BasicBlock *ordered = builder()->CreateBlock(ip, "ordered");
1129 BasicBlock *ge = builder()->CreateBlock(ip, "fcmp_ge");
1130 BasicBlock *lt = builder()->CreateBlock(ip, "fcmp_lt");
1131 BasicBlock *eq = builder()->CreateBlock(ip, "fcmp_eq");
1132 BasicBlock *gt = builder()->CreateBlock(ip, "fcmp_gt");
1133 BasicBlock *done = builder()->CreateBlock(ip, "done");
1134
1135 builder()->CreateCondBr(
1136 builder()->CreateFCmpUNO(a, b),
1137 unordered_is_greater ? gt : lt, ordered);
1138
1139 builder()->SetInsertPoint(ordered);
1140 builder()->CreateCondBr(builder()->CreateFCmpULT(a, b), lt, ge);
1141
1142 builder()->SetInsertPoint(ge);
1143 builder()->CreateCondBr(builder()->CreateFCmpUGT(a, b), gt, eq);
1144
1145 builder()->SetInsertPoint(lt);
1146 builder()->CreateBr(done);
1147
1148 builder()->SetInsertPoint(gt);
1149 builder()->CreateBr(done);
1150
1151 builder()->SetInsertPoint(eq);
1152 builder()->CreateBr(done);
1153
1154 builder()->SetInsertPoint(done);
1155 PHINode *result = builder()->CreatePHI(SharkType::jint_type(), "result");
1156 result->addIncoming(LLVMValue::jint_constant(-1), lt);
1157 result->addIncoming(LLVMValue::jint_constant(0), eq);
1158 result->addIncoming(LLVMValue::jint_constant(1), gt);
1159
1160 push(SharkValue::create_jint(result, false));
1161 }
1162
1163 void SharkBlock::emit_IR() {
1164 ShouldNotCallThis();
1165 }
1166
1167 SharkState* SharkBlock::entry_state() {
1168 ShouldNotCallThis();
1169 }
1170
1171 void SharkBlock::do_zero_check(SharkValue* value) {
1172 ShouldNotCallThis();
1173 }
1174
1175 void SharkBlock::maybe_add_backedge_safepoint() {
1176 ShouldNotCallThis();
1177 }
1178
1179 bool SharkBlock::has_trap() {
1180 return false;
1181 }
1182
1183 int SharkBlock::trap_request() {
1184 ShouldNotCallThis();
1185 }
1186
1187 int SharkBlock::trap_bci() {
1188 ShouldNotCallThis();
1189 }
1190
1191 void SharkBlock::do_trap(int trap_request) {
1192 ShouldNotCallThis();
1193 }
1194
1195 void SharkBlock::do_arraylength() {
1196 ShouldNotCallThis();
1197 }
1198
1199 void SharkBlock::do_aload(BasicType basic_type) {
1200 ShouldNotCallThis();
1201 }
1202
1203 void SharkBlock::do_astore(BasicType basic_type) {
1204 ShouldNotCallThis();
1205 }
1206
1207 void SharkBlock::do_return(BasicType type) {
1208 ShouldNotCallThis();
1209 }
1210
1211 void SharkBlock::do_athrow() {
1212 ShouldNotCallThis();
1213 }
1214
1215 void SharkBlock::do_goto() {
1216 ShouldNotCallThis();
1217 }
1218
1219 void SharkBlock::do_jsr() {
1220 ShouldNotCallThis();
1221 }
1222
1223 void SharkBlock::do_ret() {
1224 ShouldNotCallThis();
1225 }
1226
1227 void SharkBlock::do_if(ICmpInst::Predicate p, SharkValue* b, SharkValue* a) {
1228 ShouldNotCallThis();
1229 }
1230
1231 void SharkBlock::do_switch() {
1232 ShouldNotCallThis();
1233 }
1234
1235 void SharkBlock::do_call() {
1236 ShouldNotCallThis();
1237 }
1238
1239 void SharkBlock::do_instance_check() {
1240 ShouldNotCallThis();
1241 }
1242
1243 bool SharkBlock::maybe_do_instanceof_if() {
1244 ShouldNotCallThis();
1245 }
1246
1247 void SharkBlock::do_new() {
1248 ShouldNotCallThis();
1249 }
1250
1251 void SharkBlock::do_newarray() {
1252 ShouldNotCallThis();
1253 }
1254
1255 void SharkBlock::do_anewarray() {
1256 ShouldNotCallThis();
1257 }
1258
1259 void SharkBlock::do_multianewarray() {
1260 ShouldNotCallThis();
1261 }
1262
1263 void SharkBlock::do_monitorenter() {
1264 ShouldNotCallThis();
1265 }
1266
1267 void SharkBlock::do_monitorexit() {
1268 ShouldNotCallThis();
1269 }