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