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