projects / gcc.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
PR libgcj/26063, PR libgcj/17978, PR libgcj/10598:
[gcc.git] / libjava / interpret.cc
1 // interpret.cc - Code for the interpreter
2
3 /* Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation
4
5 This file is part of libgcj.
6
7 This software is copyrighted work licensed under the terms of the
8 Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
9 details. */
10
11 /* Author: Kresten Krab Thorup <krab@gnu.org> */
12
13 #include <config.h>
14 #include <platform.h>
15
16 #pragma implementation "java-interp.h"
17
18 #include <jvm.h>
19 #include <java-cpool.h>
20 #include <java-interp.h>
21 #include <java/lang/System.h>
22 #include <java/lang/String.h>
23 #include <java/lang/Integer.h>
24 #include <java/lang/Long.h>
25 #include <java/lang/StringBuffer.h>
26 #include <java/lang/Class.h>
27 #include <java/lang/reflect/Modifier.h>
28 #include <java/lang/VirtualMachineError.h>
29 #include <java/lang/InternalError.h>
30 #include <java/lang/NullPointerException.h>
31 #include <java/lang/ArithmeticException.h>
32 #include <java/lang/IncompatibleClassChangeError.h>
33 #include <java/lang/InstantiationException.h>
34 #include <java/lang/Thread.h>
35 #include <java-insns.h>
36 #include <java-signal.h>
37 #include <java/lang/ClassFormatError.h>
38 #include <execution.h>
39 #include <java/lang/reflect/Modifier.h>
40
41 #ifdef INTERPRETER
42
43 // Execution engine for interpreted code.
44 _Jv_InterpreterEngine _Jv_soleInterpreterEngine;
45
46 #include <stdlib.h>
47
48 using namespace gcj;
49
50 static void throw_internal_error (char *msg)
51 __attribute__ ((__noreturn__));
52 static void throw_incompatible_class_change_error (jstring msg)
53 __attribute__ ((__noreturn__));
54 #ifndef HANDLE_SEGV
55 static void throw_null_pointer_exception ()
56 __attribute__ ((__noreturn__));
57 #endif
58
59 static void throw_class_format_error (jstring msg)
60 __attribute__ ((__noreturn__));
61 static void throw_class_format_error (char *msg)
62 __attribute__ ((__noreturn__));
63
64 #ifdef DIRECT_THREADED
65 // Lock to ensure that methods are not compiled concurrently.
66 // We could use a finer-grained lock here, however it is not safe to use
67 // the Class monitor as user code in another thread could hold it.
68 static _Jv_Mutex_t compile_mutex;
69
70 void
71 _Jv_InitInterpreter()
72 {
73 _Jv_MutexInit (&compile_mutex);
74 }
75 #else
76 void _Jv_InitInterpreter() {}
77 #endif
78
79 extern "C" double __ieee754_fmod (double,double);
80
81 static inline void dupx (_Jv_word *sp, int n, int x)
82 {
83 // first "slide" n+x elements n to the right
84 int top = n-1;
85 for (int i = 0; i < n+x; i++)
86 {
87 sp[(top-i)] = sp[(top-i)-n];
88 }
89
90 // next, copy the n top elements, n+x down
91 for (int i = 0; i < n; i++)
92 {
93 sp[top-(n+x)-i] = sp[top-i];
94 }
95 }
96
97 // Used to convert from floating types to integral types.
98 template<typename TO, typename FROM>
99 static inline TO
100 convert (FROM val, TO min, TO max)
101 {
102 TO ret;
103 if (val >= (FROM) max)
104 ret = max;
105 else if (val <= (FROM) min)
106 ret = min;
107 else if (val != val)
108 ret = 0;
109 else
110 ret = (TO) val;
111 return ret;
112 }
113
114 #define PUSHA(V) (sp++)->o = (V)
115 #define PUSHI(V) (sp++)->i = (V)
116 #define PUSHF(V) (sp++)->f = (V)
117 #if SIZEOF_VOID_P == 8
118 # define PUSHL(V) (sp->l = (V), sp += 2)
119 # define PUSHD(V) (sp->d = (V), sp += 2)
120 #else
121 # define PUSHL(V) do { _Jv_word2 w2; w2.l=(V); \
122 (sp++)->ia[0] = w2.ia[0]; \
123 (sp++)->ia[0] = w2.ia[1]; } while (0)
124 # define PUSHD(V) do { _Jv_word2 w2; w2.d=(V); \
125 (sp++)->ia[0] = w2.ia[0]; \
126 (sp++)->ia[0] = w2.ia[1]; } while (0)
127 #endif
128
129 #define POPA() ((--sp)->o)
130 #define POPI() ((jint) (--sp)->i) // cast since it may be promoted
131 #define POPF() ((jfloat) (--sp)->f)
132 #if SIZEOF_VOID_P == 8
133 # define POPL() (sp -= 2, (jlong) sp->l)
134 # define POPD() (sp -= 2, (jdouble) sp->d)
135 #else
136 # define POPL() ({ _Jv_word2 w2; \
137 w2.ia[1] = (--sp)->ia[0]; \
138 w2.ia[0] = (--sp)->ia[0]; w2.l; })
139 # define POPD() ({ _Jv_word2 w2; \
140 w2.ia[1] = (--sp)->ia[0]; \
141 w2.ia[0] = (--sp)->ia[0]; w2.d; })
142 #endif
143
144 #define LOADA(I) (sp++)->o = locals[I].o
145 #define LOADI(I) (sp++)->i = locals[I].i
146 #define LOADF(I) (sp++)->f = locals[I].f
147 #if SIZEOF_VOID_P == 8
148 # define LOADL(I) (sp->l = locals[I].l, sp += 2)
149 # define LOADD(I) (sp->d = locals[I].d, sp += 2)
150 #else
151 # define LOADL(I) do { jint __idx = (I); \
152 (sp++)->ia[0] = locals[__idx].ia[0]; \
153 (sp++)->ia[0] = locals[__idx+1].ia[0]; \
154 } while (0)
155 # define LOADD(I) LOADL(I)
156 #endif
157
158 #define STOREA(I) locals[I].o = (--sp)->o
159 #define STOREI(I) locals[I].i = (--sp)->i
160 #define STOREF(I) locals[I].f = (--sp)->f
161 #if SIZEOF_VOID_P == 8
162 # define STOREL(I) (sp -= 2, locals[I].l = sp->l)
163 # define STORED(I) (sp -= 2, locals[I].d = sp->d)
164 #else
165 # define STOREL(I) do { jint __idx = (I); \
166 locals[__idx+1].ia[0] = (--sp)->ia[0]; \
167 locals[__idx].ia[0] = (--sp)->ia[0]; \
168 } while (0)
169 # define STORED(I) STOREL(I)
170 #endif
171
172 #define PEEKI(I) (locals+(I))->i
173 #define PEEKA(I) (locals+(I))->o
174
175 #define POKEI(I,V) ((locals+(I))->i = (V))
176
177
178 #define BINOPI(OP) { \
179 jint value2 = POPI(); \
180 jint value1 = POPI(); \
181 PUSHI(value1 OP value2); \
182 }
183
184 #define BINOPF(OP) { \
185 jfloat value2 = POPF(); \
186 jfloat value1 = POPF(); \
187 PUSHF(value1 OP value2); \
188 }
189
190 #define BINOPL(OP) { \
191 jlong value2 = POPL(); \
192 jlong value1 = POPL(); \
193 PUSHL(value1 OP value2); \
194 }
195
196 #define BINOPD(OP) { \
197 jdouble value2 = POPD(); \
198 jdouble value1 = POPD(); \
199 PUSHD(value1 OP value2); \
200 }
201
202 static inline jint get1s(unsigned char* loc) {
203 return *(signed char*)loc;
204 }
205
206 static inline jint get1u(unsigned char* loc) {
207 return *loc;
208 }
209
210 static inline jint get2s(unsigned char* loc) {
211 return (((jint)*(signed char*)loc) << 8) | ((jint)*(loc+1));
212 }
213
214 static inline jint get2u(unsigned char* loc) {
215 return (((jint)(*loc)) << 8) | ((jint)*(loc+1));
216 }
217
218 static jint get4(unsigned char* loc) {
219 return (((jint)(loc[0])) << 24)
220 | (((jint)(loc[1])) << 16)
221 | (((jint)(loc[2])) << 8)
222 | (((jint)(loc[3])) << 0);
223 }
224
225 #define SAVE_PC() frame_desc.pc = pc
226
227 #ifdef HANDLE_SEGV
228 #define NULLCHECK(X) SAVE_PC()
229 #define NULLARRAYCHECK(X) SAVE_PC()
230 #else
231 #define NULLCHECK(X) \
232 do { SAVE_PC(); if ((X)==NULL) throw_null_pointer_exception (); } while (0)
233 #define NULLARRAYCHECK(X) \
234 do { SAVE_PC(); if ((X)==NULL) { throw_null_pointer_exception (); } } while (0)
235 #endif
236
237 #define ARRAYBOUNDSCHECK(array, index) \
238 do \
239 { \
240 if (((unsigned) index) >= (unsigned) (array->length)) \
241 _Jv_ThrowBadArrayIndex (index); \
242 } \
243 while (0)
244
245 void
246 _Jv_InterpMethod::run_normal (ffi_cif *,
247 void* ret,
248 ffi_raw * args,
249 void* __this)
250 {
251 _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this;
252 run (ret, args, _this);
253 }
254
255 void
256 _Jv_InterpMethod::run_synch_object (ffi_cif *,
257 void* ret,
258 ffi_raw * args,
259 void* __this)
260 {
261 _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this;
262
263 jobject rcv = (jobject) args[0].ptr;
264 JvSynchronize mutex (rcv);
265
266 run (ret, args, _this);
267 }
268
269 void
270 _Jv_InterpMethod::run_class (ffi_cif *,
271 void* ret,
272 ffi_raw * args,
273 void* __this)
274 {
275 _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this;
276 _Jv_InitClass (_this->defining_class);
277 run (ret, args, _this);
278 }
279
280 void
281 _Jv_InterpMethod::run_synch_class (ffi_cif *,
282 void* ret,
283 ffi_raw * args,
284 void* __this)
285 {
286 _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this;
287
288 jclass sync = _this->defining_class;
289 _Jv_InitClass (sync);
290 JvSynchronize mutex (sync);
291
292 run (ret, args, _this);
293 }
294
295 #ifdef DIRECT_THREADED
296 // "Compile" a method by turning it from bytecode to direct-threaded
297 // code.
298 void
299 _Jv_InterpMethod::compile (const void * const *insn_targets)
300 {
301 insn_slot *insns = NULL;
302 int next = 0;
303 unsigned char *codestart = bytecode ();
304 unsigned char *end = codestart + code_length;
305 _Jv_word *pool_data = defining_class->constants.data;
306
307 #define SET_ONE(Field, Value) \
308 do \
309 { \
310 if (first_pass) \
311 ++next; \
312 else \
313 insns[next++].Field = Value; \
314 } \
315 while (0)
316
317 #define SET_INSN(Value) SET_ONE (insn, (void *) Value)
318 #define SET_INT(Value) SET_ONE (int_val, Value)
319 #define SET_DATUM(Value) SET_ONE (datum, Value)
320
321 // Map from bytecode PC to slot in INSNS.
322 int *pc_mapping = (int *) __builtin_alloca (sizeof (int) * code_length);
323 for (int i = 0; i < code_length; ++i)
324 pc_mapping[i] = -1;
325
326 for (int i = 0; i < 2; ++i)
327 {
328 jboolean first_pass = i == 0;
329
330 if (! first_pass)
331 {
332 insns = (insn_slot *) _Jv_AllocBytes (sizeof (insn_slot) * next);
333 number_insn_slots = next;
334 next = 0;
335 }
336
337 unsigned char *pc = codestart;
338 while (pc < end)
339 {
340 int base_pc_val = pc - codestart;
341 if (first_pass)
342 pc_mapping[base_pc_val] = next;
343
344 java_opcode opcode = (java_opcode) *pc++;
345 // Just elide NOPs.
346 if (opcode == op_nop)
347 continue;
348 SET_INSN (insn_targets[opcode]);
349
350 switch (opcode)
351 {
352 case op_nop:
353 case op_aconst_null:
354 case op_iconst_m1:
355 case op_iconst_0:
356 case op_iconst_1:
357 case op_iconst_2:
358 case op_iconst_3:
359 case op_iconst_4:
360 case op_iconst_5:
361 case op_lconst_0:
362 case op_lconst_1:
363 case op_fconst_0:
364 case op_fconst_1:
365 case op_fconst_2:
366 case op_dconst_0:
367 case op_dconst_1:
368 case op_iload_0:
369 case op_iload_1:
370 case op_iload_2:
371 case op_iload_3:
372 case op_lload_0:
373 case op_lload_1:
374 case op_lload_2:
375 case op_lload_3:
376 case op_fload_0:
377 case op_fload_1:
378 case op_fload_2:
379 case op_fload_3:
380 case op_dload_0:
381 case op_dload_1:
382 case op_dload_2:
383 case op_dload_3:
384 case op_aload_0:
385 case op_aload_1:
386 case op_aload_2:
387 case op_aload_3:
388 case op_iaload:
389 case op_laload:
390 case op_faload:
391 case op_daload:
392 case op_aaload:
393 case op_baload:
394 case op_caload:
395 case op_saload:
396 case op_istore_0:
397 case op_istore_1:
398 case op_istore_2:
399 case op_istore_3:
400 case op_lstore_0:
401 case op_lstore_1:
402 case op_lstore_2:
403 case op_lstore_3:
404 case op_fstore_0:
405 case op_fstore_1:
406 case op_fstore_2:
407 case op_fstore_3:
408 case op_dstore_0:
409 case op_dstore_1:
410 case op_dstore_2:
411 case op_dstore_3:
412 case op_astore_0:
413 case op_astore_1:
414 case op_astore_2:
415 case op_astore_3:
416 case op_iastore:
417 case op_lastore:
418 case op_fastore:
419 case op_dastore:
420 case op_aastore:
421 case op_bastore:
422 case op_castore:
423 case op_sastore:
424 case op_pop:
425 case op_pop2:
426 case op_dup:
427 case op_dup_x1:
428 case op_dup_x2:
429 case op_dup2:
430 case op_dup2_x1:
431 case op_dup2_x2:
432 case op_swap:
433 case op_iadd:
434 case op_isub:
435 case op_imul:
436 case op_idiv:
437 case op_irem:
438 case op_ishl:
439 case op_ishr:
440 case op_iushr:
441 case op_iand:
442 case op_ior:
443 case op_ixor:
444 case op_ladd:
445 case op_lsub:
446 case op_lmul:
447 case op_ldiv:
448 case op_lrem:
449 case op_lshl:
450 case op_lshr:
451 case op_lushr:
452 case op_land:
453 case op_lor:
454 case op_lxor:
455 case op_fadd:
456 case op_fsub:
457 case op_fmul:
458 case op_fdiv:
459 case op_frem:
460 case op_dadd:
461 case op_dsub:
462 case op_dmul:
463 case op_ddiv:
464 case op_drem:
465 case op_ineg:
466 case op_i2b:
467 case op_i2c:
468 case op_i2s:
469 case op_lneg:
470 case op_fneg:
471 case op_dneg:
472 case op_i2l:
473 case op_i2f:
474 case op_i2d:
475 case op_l2i:
476 case op_l2f:
477 case op_l2d:
478 case op_f2i:
479 case op_f2l:
480 case op_f2d:
481 case op_d2i:
482 case op_d2l:
483 case op_d2f:
484 case op_lcmp:
485 case op_fcmpl:
486 case op_fcmpg:
487 case op_dcmpl:
488 case op_dcmpg:
489 case op_monitorenter:
490 case op_monitorexit:
491 case op_ireturn:
492 case op_lreturn:
493 case op_freturn:
494 case op_dreturn:
495 case op_areturn:
496 case op_return:
497 case op_athrow:
498 case op_arraylength:
499 // No argument, nothing else to do.
500 break;
501
502 case op_bipush:
503 SET_INT (get1s (pc));
504 ++pc;
505 break;
506
507 case op_ldc:
508 {
509 int index = get1u (pc);
510 ++pc;
511 // For an unresolved class we want to delay resolution
512 // until execution.
513 if (defining_class->constants.tags[index] == JV_CONSTANT_Class)
514 {
515 --next;
516 SET_INSN (insn_targets[int (op_jsr_w) + 1]);
517 SET_INT (index);
518 }
519 else
520 SET_DATUM (pool_data[index].o);
521 }
522 break;
523
524 case op_ret:
525 case op_iload:
526 case op_lload:
527 case op_fload:
528 case op_dload:
529 case op_aload:
530 case op_istore:
531 case op_lstore:
532 case op_fstore:
533 case op_dstore:
534 case op_astore:
535 case op_newarray:
536 SET_INT (get1u (pc));
537 ++pc;
538 break;
539
540 case op_iinc:
541 SET_INT (get1u (pc));
542 SET_INT (get1s (pc + 1));
543 pc += 2;
544 break;
545
546 case op_ldc_w:
547 {
548 int index = get2u (pc);
549 pc += 2;
550 // For an unresolved class we want to delay resolution
551 // until execution.
552 if (defining_class->constants.tags[index] == JV_CONSTANT_Class)
553 {
554 --next;
555 SET_INSN (insn_targets[int (op_jsr_w) + 1]);
556 SET_INT (index);
557 }
558 else
559 SET_DATUM (pool_data[index].o);
560 }
561 break;
562
563 case op_ldc2_w:
564 {
565 int index = get2u (pc);
566 pc += 2;
567 SET_DATUM (&pool_data[index]);
568 }
569 break;
570
571 case op_sipush:
572 SET_INT (get2s (pc));
573 pc += 2;
574 break;
575
576 case op_new:
577 case op_getstatic:
578 case op_getfield:
579 case op_putfield:
580 case op_putstatic:
581 case op_anewarray:
582 case op_instanceof:
583 case op_checkcast:
584 case op_invokespecial:
585 case op_invokestatic:
586 case op_invokevirtual:
587 SET_INT (get2u (pc));
588 pc += 2;
589 break;
590
591 case op_multianewarray:
592 SET_INT (get2u (pc));
593 SET_INT (get1u (pc + 2));
594 pc += 3;
595 break;
596
597 case op_jsr:
598 case op_ifeq:
599 case op_ifne:
600 case op_iflt:
601 case op_ifge:
602 case op_ifgt:
603 case op_ifle:
604 case op_if_icmpeq:
605 case op_if_icmpne:
606 case op_if_icmplt:
607 case op_if_icmpge:
608 case op_if_icmpgt:
609 case op_if_icmple:
610 case op_if_acmpeq:
611 case op_if_acmpne:
612 case op_ifnull:
613 case op_ifnonnull:
614 case op_goto:
615 {
616 int offset = get2s (pc);
617 pc += 2;
618
619 int new_pc = base_pc_val + offset;
620
621 bool orig_was_goto = opcode == op_goto;
622
623 // Thread jumps. We limit the loop count; this lets
624 // us avoid infinite loops if the bytecode contains
625 // such. `10' is arbitrary.
626 int count = 10;
627 while (codestart[new_pc] == op_goto && count-- > 0)
628 new_pc += get2s (&codestart[new_pc + 1]);
629
630 // If the jump takes us to a `return' instruction and
631 // the original branch was an unconditional goto, then
632 // we hoist the return.
633 opcode = (java_opcode) codestart[new_pc];
634 if (orig_was_goto
635 && (opcode == op_ireturn || opcode == op_lreturn
636 || opcode == op_freturn || opcode == op_dreturn
637 || opcode == op_areturn || opcode == op_return))
638 {
639 --next;
640 SET_INSN (insn_targets[opcode]);
641 }
642 else
643 SET_DATUM (&insns[pc_mapping[new_pc]]);
644 }
645 break;
646
647 case op_tableswitch:
648 {
649 while ((pc - codestart) % 4 != 0)
650 ++pc;
651
652 jint def = get4 (pc);
653 SET_DATUM (&insns[pc_mapping[base_pc_val + def]]);
654 pc += 4;
655
656 int low = get4 (pc);
657 SET_INT (low);
658 pc += 4;
659 int high = get4 (pc);
660 SET_INT (high);
661 pc += 4;
662
663 for (int i = low; i <= high; ++i)
664 {
665 SET_DATUM (&insns[pc_mapping[base_pc_val + get4 (pc)]]);
666 pc += 4;
667 }
668 }
669 break;
670
671 case op_lookupswitch:
672 {
673 while ((pc - codestart) % 4 != 0)
674 ++pc;
675
676 jint def = get4 (pc);
677 SET_DATUM (&insns[pc_mapping[base_pc_val + def]]);
678 pc += 4;
679
680 jint npairs = get4 (pc);
681 pc += 4;
682 SET_INT (npairs);
683
684 while (npairs-- > 0)
685 {
686 jint match = get4 (pc);
687 jint offset = get4 (pc + 4);
688 SET_INT (match);
689 SET_DATUM (&insns[pc_mapping[base_pc_val + offset]]);
690 pc += 8;
691 }
692 }
693 break;
694
695 case op_invokeinterface:
696 {
697 jint index = get2u (pc);
698 pc += 2;
699 // We ignore the next two bytes.
700 pc += 2;
701 SET_INT (index);
702 }
703 break;
704
705 case op_wide:
706 {
707 opcode = (java_opcode) get1u (pc);
708 pc += 1;
709 jint val = get2u (pc);
710 pc += 2;
711
712 // We implement narrow and wide instructions using the
713 // same code in the interpreter. So we rewrite the
714 // instruction slot here.
715 if (! first_pass)
716 insns[next - 1].insn = (void *) insn_targets[opcode];
717 SET_INT (val);
718
719 if (opcode == op_iinc)
720 {
721 SET_INT (get2s (pc));
722 pc += 2;
723 }
724 }
725 break;
726
727 case op_jsr_w:
728 case op_goto_w:
729 {
730 jint offset = get4 (pc);
731 pc += 4;
732 SET_DATUM (&insns[pc_mapping[base_pc_val + offset]]);
733 }
734 break;
735
736 // Some "can't happen" cases that we include for
737 // error-checking purposes.
738 case op_putfield_1:
739 case op_putfield_2:
740 case op_putfield_4:
741 case op_putfield_8:
742 case op_putfield_a:
743 case op_putstatic_1:
744 case op_putstatic_2:
745 case op_putstatic_4:
746 case op_putstatic_8:
747 case op_putstatic_a:
748 case op_getfield_1:
749 case op_getfield_2s:
750 case op_getfield_2u:
751 case op_getfield_4:
752 case op_getfield_8:
753 case op_getfield_a:
754 case op_getstatic_1:
755 case op_getstatic_2s:
756 case op_getstatic_2u:
757 case op_getstatic_4:
758 case op_getstatic_8:
759 case op_getstatic_a:
760 default:
761 // Fail somehow.
762 break;
763 }
764 }
765 }
766
767 // Now update exceptions.
768 _Jv_InterpException *exc = exceptions ();
769 for (int i = 0; i < exc_count; ++i)
770 {
771 exc[i].start_pc.p = &insns[pc_mapping[exc[i].start_pc.i]];
772 exc[i].end_pc.p = &insns[pc_mapping[exc[i].end_pc.i]];
773 exc[i].handler_pc.p = &insns[pc_mapping[exc[i].handler_pc.i]];
774 jclass handler
775 = (_Jv_Linker::resolve_pool_entry (defining_class,
776 exc[i].handler_type.i)).clazz;
777 exc[i].handler_type.p = handler;
778 }
779
780 // Translate entries in the LineNumberTable from bytecode PC's to direct
781 // threaded interpreter instruction values.
782 for (int i = 0; i < line_table_len; i++)
783 {
784 int byte_pc = line_table[i].bytecode_pc;
785 // It isn't worth throwing an exception if this table is
786 // corrupted, but at the same time we don't want a crash.
787 if (byte_pc < 0 || byte_pc >= code_length)
788 byte_pc = 0;
789 line_table[i].pc = &insns[pc_mapping[byte_pc]];
790 }
791
792 prepared = insns;
793 }
794 #endif /* DIRECT_THREADED */
795
796 /* Run the given method.
797 When args is NULL, don't run anything -- just compile it. */
798 void
799 _Jv_InterpMethod::run (void *retp, ffi_raw *args, _Jv_InterpMethod *meth)
800 {
801 using namespace java::lang::reflect;
802
803 // FRAME_DESC registers this particular invocation as the top-most
804 // interpreter frame. This lets the stack tracing code (for
805 // Throwable) print information about the method being interpreted
806 // rather than about the interpreter itself. FRAME_DESC has a
807 // destructor so it cleans up automatically when the interpreter
808 // returns.
809 java::lang::Thread *thread = java::lang::Thread::currentThread();
810 _Jv_InterpFrame frame_desc (meth,
811 (_Jv_InterpFrame **) &thread->interp_frame);
812
813 _Jv_word stack[meth->max_stack];
814 _Jv_word *sp = stack;
815
816 _Jv_word locals[meth->max_locals];
817
818 #define INSN_LABEL(op) &&insn_##op
819
820 static const void *const insn_target[] =
821 {
822 INSN_LABEL(nop),
823 INSN_LABEL(aconst_null),
824 INSN_LABEL(iconst_m1),
825 INSN_LABEL(iconst_0),
826 INSN_LABEL(iconst_1),
827 INSN_LABEL(iconst_2),
828 INSN_LABEL(iconst_3),
829 INSN_LABEL(iconst_4),
830 INSN_LABEL(iconst_5),
831 INSN_LABEL(lconst_0),
832 INSN_LABEL(lconst_1),
833 INSN_LABEL(fconst_0),
834 INSN_LABEL(fconst_1),
835 INSN_LABEL(fconst_2),
836 INSN_LABEL(dconst_0),
837 INSN_LABEL(dconst_1),
838 INSN_LABEL(bipush),
839 INSN_LABEL(sipush),
840 INSN_LABEL(ldc),
841 INSN_LABEL(ldc_w),
842 INSN_LABEL(ldc2_w),
843 INSN_LABEL(iload),
844 INSN_LABEL(lload),
845 INSN_LABEL(fload),
846 INSN_LABEL(dload),
847 INSN_LABEL(aload),
848 INSN_LABEL(iload_0),
849 INSN_LABEL(iload_1),
850 INSN_LABEL(iload_2),
851 INSN_LABEL(iload_3),
852 INSN_LABEL(lload_0),
853 INSN_LABEL(lload_1),
854 INSN_LABEL(lload_2),
855 INSN_LABEL(lload_3),
856 INSN_LABEL(fload_0),
857 INSN_LABEL(fload_1),
858 INSN_LABEL(fload_2),
859 INSN_LABEL(fload_3),
860 INSN_LABEL(dload_0),
861 INSN_LABEL(dload_1),
862 INSN_LABEL(dload_2),
863 INSN_LABEL(dload_3),
864 INSN_LABEL(aload_0),
865 INSN_LABEL(aload_1),
866 INSN_LABEL(aload_2),
867 INSN_LABEL(aload_3),
868 INSN_LABEL(iaload),
869 INSN_LABEL(laload),
870 INSN_LABEL(faload),
871 INSN_LABEL(daload),
872 INSN_LABEL(aaload),
873 INSN_LABEL(baload),
874 INSN_LABEL(caload),
875 INSN_LABEL(saload),
876 INSN_LABEL(istore),
877 INSN_LABEL(lstore),
878 INSN_LABEL(fstore),
879 INSN_LABEL(dstore),
880 INSN_LABEL(astore),
881 INSN_LABEL(istore_0),
882 INSN_LABEL(istore_1),
883 INSN_LABEL(istore_2),
884 INSN_LABEL(istore_3),
885 INSN_LABEL(lstore_0),
886 INSN_LABEL(lstore_1),
887 INSN_LABEL(lstore_2),
888 INSN_LABEL(lstore_3),
889 INSN_LABEL(fstore_0),
890 INSN_LABEL(fstore_1),
891 INSN_LABEL(fstore_2),
892 INSN_LABEL(fstore_3),
893 INSN_LABEL(dstore_0),
894 INSN_LABEL(dstore_1),
895 INSN_LABEL(dstore_2),
896 INSN_LABEL(dstore_3),
897 INSN_LABEL(astore_0),
898 INSN_LABEL(astore_1),
899 INSN_LABEL(astore_2),
900 INSN_LABEL(astore_3),
901 INSN_LABEL(iastore),
902 INSN_LABEL(lastore),
903 INSN_LABEL(fastore),
904 INSN_LABEL(dastore),
905 INSN_LABEL(aastore),
906 INSN_LABEL(bastore),
907 INSN_LABEL(castore),
908 INSN_LABEL(sastore),
909 INSN_LABEL(pop),
910 INSN_LABEL(pop2),
911 INSN_LABEL(dup),
912 INSN_LABEL(dup_x1),
913 INSN_LABEL(dup_x2),
914 INSN_LABEL(dup2),
915 INSN_LABEL(dup2_x1),
916 INSN_LABEL(dup2_x2),
917 INSN_LABEL(swap),
918 INSN_LABEL(iadd),
919 INSN_LABEL(ladd),
920 INSN_LABEL(fadd),
921 INSN_LABEL(dadd),
922 INSN_LABEL(isub),
923 INSN_LABEL(lsub),
924 INSN_LABEL(fsub),
925 INSN_LABEL(dsub),
926 INSN_LABEL(imul),
927 INSN_LABEL(lmul),
928 INSN_LABEL(fmul),
929 INSN_LABEL(dmul),
930 INSN_LABEL(idiv),
931 INSN_LABEL(ldiv),
932 INSN_LABEL(fdiv),
933 INSN_LABEL(ddiv),
934 INSN_LABEL(irem),
935 INSN_LABEL(lrem),
936 INSN_LABEL(frem),
937 INSN_LABEL(drem),
938 INSN_LABEL(ineg),
939 INSN_LABEL(lneg),
940 INSN_LABEL(fneg),
941 INSN_LABEL(dneg),
942 INSN_LABEL(ishl),
943 INSN_LABEL(lshl),
944 INSN_LABEL(ishr),
945 INSN_LABEL(lshr),
946 INSN_LABEL(iushr),
947 INSN_LABEL(lushr),
948 INSN_LABEL(iand),
949 INSN_LABEL(land),
950 INSN_LABEL(ior),
951 INSN_LABEL(lor),
952 INSN_LABEL(ixor),
953 INSN_LABEL(lxor),
954 INSN_LABEL(iinc),
955 INSN_LABEL(i2l),
956 INSN_LABEL(i2f),
957 INSN_LABEL(i2d),
958 INSN_LABEL(l2i),
959 INSN_LABEL(l2f),
960 INSN_LABEL(l2d),
961 INSN_LABEL(f2i),
962 INSN_LABEL(f2l),
963 INSN_LABEL(f2d),
964 INSN_LABEL(d2i),
965 INSN_LABEL(d2l),
966 INSN_LABEL(d2f),
967 INSN_LABEL(i2b),
968 INSN_LABEL(i2c),
969 INSN_LABEL(i2s),
970 INSN_LABEL(lcmp),
971 INSN_LABEL(fcmpl),
972 INSN_LABEL(fcmpg),
973 INSN_LABEL(dcmpl),
974 INSN_LABEL(dcmpg),
975 INSN_LABEL(ifeq),
976 INSN_LABEL(ifne),
977 INSN_LABEL(iflt),
978 INSN_LABEL(ifge),
979 INSN_LABEL(ifgt),
980 INSN_LABEL(ifle),
981 INSN_LABEL(if_icmpeq),
982 INSN_LABEL(if_icmpne),
983 INSN_LABEL(if_icmplt),
984 INSN_LABEL(if_icmpge),
985 INSN_LABEL(if_icmpgt),
986 INSN_LABEL(if_icmple),
987 INSN_LABEL(if_acmpeq),
988 INSN_LABEL(if_acmpne),
989 INSN_LABEL(goto),
990 INSN_LABEL(jsr),
991 INSN_LABEL(ret),
992 INSN_LABEL(tableswitch),
993 INSN_LABEL(lookupswitch),
994 INSN_LABEL(ireturn),
995 INSN_LABEL(lreturn),
996 INSN_LABEL(freturn),
997 INSN_LABEL(dreturn),
998 INSN_LABEL(areturn),
999 INSN_LABEL(return),
1000 INSN_LABEL(getstatic),
1001 INSN_LABEL(putstatic),
1002 INSN_LABEL(getfield),
1003 INSN_LABEL(putfield),
1004 INSN_LABEL(invokevirtual),
1005 INSN_LABEL(invokespecial),
1006 INSN_LABEL(invokestatic),
1007 INSN_LABEL(invokeinterface),
1008 0, /* Unused. */
1009 INSN_LABEL(new),
1010 INSN_LABEL(newarray),
1011 INSN_LABEL(anewarray),
1012 INSN_LABEL(arraylength),
1013 INSN_LABEL(athrow),
1014 INSN_LABEL(checkcast),
1015 INSN_LABEL(instanceof),
1016 INSN_LABEL(monitorenter),
1017 INSN_LABEL(monitorexit),
1018 #ifdef DIRECT_THREADED
1019 0, // wide
1020 #else
1021 INSN_LABEL(wide),
1022 #endif
1023 INSN_LABEL(multianewarray),
1024 INSN_LABEL(ifnull),
1025 INSN_LABEL(ifnonnull),
1026 INSN_LABEL(goto_w),
1027 INSN_LABEL(jsr_w),
1028 #ifdef DIRECT_THREADED
1029 INSN_LABEL (ldc_class)
1030 #else
1031 0
1032 #endif
1033 };
1034
1035 pc_t pc;
1036
1037 #ifdef DIRECT_THREADED
1038
1039 #define NEXT_INSN goto *((pc++)->insn)
1040 #define INTVAL() ((pc++)->int_val)
1041 #define AVAL() ((pc++)->datum)
1042
1043 #define GET1S() INTVAL ()
1044 #define GET2S() INTVAL ()
1045 #define GET1U() INTVAL ()
1046 #define GET2U() INTVAL ()
1047 #define AVAL1U() AVAL ()
1048 #define AVAL2U() AVAL ()
1049 #define AVAL2UP() AVAL ()
1050 #define SKIP_GOTO ++pc
1051 #define GOTO_VAL() (insn_slot *) pc->datum
1052 #define PCVAL(unionval) unionval.p
1053 #define AMPAMP(label) &&label
1054
1055 // Compile if we must. NOTE: Double-check locking.
1056 if (meth->prepared == NULL)
1057 {
1058 _Jv_MutexLock (&compile_mutex);
1059 if (meth->prepared == NULL)
1060 meth->compile (insn_target);
1061 _Jv_MutexUnlock (&compile_mutex);
1062 }
1063
1064 // If we're only compiling, stop here
1065 if (args == NULL)
1066 return;
1067
1068 pc = (insn_slot *) meth->prepared;
1069
1070 #else
1071
1072 #define NEXT_INSN goto *(insn_target[*pc++])
1073
1074 #define GET1S() get1s (pc++)
1075 #define GET2S() (pc += 2, get2s (pc- 2))
1076 #define GET1U() get1u (pc++)
1077 #define GET2U() (pc += 2, get2u (pc - 2))
1078 // Note that these could be more efficient when not handling 'ldc
1079 // class'.
1080 #define AVAL1U() \
1081 ({ int index = get1u (pc++); \
1082 resolve_pool_entry (meth->defining_class, index).o; })
1083 #define AVAL2U() \
1084 ({ int index = get2u (pc); pc += 2; \
1085 resolve_pool_entry (meth->defining_class, index).o; })
1086 // Note that we don't need to resolve the pool entry here as class
1087 // constants are never wide.
1088 #define AVAL2UP() ({ int index = get2u (pc); pc += 2; &pool_data[index]; })
1089 #define SKIP_GOTO pc += 2
1090 #define GOTO_VAL() pc - 1 + get2s (pc)
1091 #define PCVAL(unionval) unionval.i
1092 #define AMPAMP(label) NULL
1093
1094 pc = bytecode ();
1095
1096 #endif /* DIRECT_THREADED */
1097
1098 #define TAKE_GOTO pc = GOTO_VAL ()
1099
1100 /* Go straight at it! the ffi raw format matches the internal
1101 stack representation exactly. At least, that's the idea.
1102 */
1103 memcpy ((void*) locals, (void*) args, meth->args_raw_size);
1104
1105 _Jv_word *pool_data = meth->defining_class->constants.data;
1106
1107 /* These three are temporaries for common code used by several
1108 instructions. */
1109 void (*fun)();
1110 _Jv_ResolvedMethod* rmeth;
1111 int tmpval;
1112
1113 try
1114 {
1115 // We keep nop around. It is used if we're interpreting the
1116 // bytecodes and not doing direct threading.
1117 insn_nop:
1118 NEXT_INSN;
1119
1120 /* The first few instructions here are ordered according to their
1121 frequency, in the hope that this will improve code locality a
1122 little. */
1123
1124 insn_aload_0: // 0x2a
1125 LOADA (0);
1126 NEXT_INSN;
1127
1128 insn_iload: // 0x15
1129 LOADI (GET1U ());
1130 NEXT_INSN;
1131
1132 insn_iload_1: // 0x1b
1133 LOADI (1);
1134 NEXT_INSN;
1135
1136 insn_invokevirtual: // 0xb6
1137 {
1138 int index = GET2U ();
1139
1140 /* _Jv_Linker::resolve_pool_entry returns immediately if the
1141 * value already is resolved. If we want to clutter up the
1142 * code here to gain a little performance, then we can check
1143 * the corresponding bit JV_CONSTANT_ResolvedFlag in the tag
1144 * directly. For now, I don't think it is worth it. */
1145
1146 SAVE_PC();
1147 rmeth = (_Jv_Linker::resolve_pool_entry (meth->defining_class,
1148 index)).rmethod;
1149
1150 sp -= rmeth->stack_item_count;
1151 // We don't use NULLCHECK here because we can't rely on that
1152 // working if the method is final. So instead we do an
1153 // explicit test.
1154 if (! sp[0].o)
1155 {
1156 //printf("invokevirtual pc = %p/%i\n", pc, meth->get_pc_val(pc));
1157 throw new java::lang::NullPointerException;
1158 }
1159
1160 if (rmeth->vtable_index == -1)
1161 {
1162 // final methods do not appear in the vtable,
1163 // if it does not appear in the superclass.
1164 fun = (void (*)()) rmeth->method->ncode;
1165 }
1166 else
1167 {
1168 jobject rcv = sp[0].o;
1169 _Jv_VTable *table = *(_Jv_VTable**) rcv;
1170 fun = (void (*)()) table->get_method (rmeth->vtable_index);
1171 }
1172
1173 #ifdef DIRECT_THREADED
1174 // Rewrite instruction so that we use a faster pre-resolved
1175 // method.
1176 pc[-2].insn = &&invokevirtual_resolved;
1177 pc[-1].datum = rmeth;
1178 #endif /* DIRECT_THREADED */
1179 }
1180 goto perform_invoke;
1181
1182 #ifdef DIRECT_THREADED
1183 invokevirtual_resolved:
1184 {
1185 rmeth = (_Jv_ResolvedMethod *) AVAL ();
1186 sp -= rmeth->stack_item_count;
1187 // We don't use NULLCHECK here because we can't rely on that
1188 // working if the method is final. So instead we do an
1189 // explicit test.
1190 if (! sp[0].o)
1191 {
1192 SAVE_PC();
1193 throw new java::lang::NullPointerException;
1194 }
1195
1196 if (rmeth->vtable_index == -1)
1197 {
1198 // final methods do not appear in the vtable,
1199 // if it does not appear in the superclass.
1200 fun = (void (*)()) rmeth->method->ncode;
1201 }
1202 else
1203 {
1204 jobject rcv = sp[0].o;
1205 _Jv_VTable *table = *(_Jv_VTable**) rcv;
1206 fun = (void (*)()) table->get_method (rmeth->vtable_index);
1207 }
1208 }
1209 goto perform_invoke;
1210 #endif /* DIRECT_THREADED */
1211
1212 perform_invoke:
1213 {
1214 SAVE_PC();
1215
1216 /* here goes the magic again... */
1217 ffi_cif *cif = &rmeth->cif;
1218 ffi_raw *raw = (ffi_raw*) sp;
1219
1220 _Jv_value rvalue;
1221
1222 #if FFI_NATIVE_RAW_API
1223 /* We assume that this is only implemented if it's correct */
1224 /* to use it here. On a 64 bit machine, it never is. */
1225 ffi_raw_call (cif, fun, (void*)&rvalue, raw);
1226 #else
1227 ffi_java_raw_call (cif, fun, (void*)&rvalue, raw);
1228 #endif
1229
1230 int rtype = cif->rtype->type;
1231
1232 /* the likelyhood of object, int, or void return is very high,
1233 * so those are checked before the switch */
1234 if (rtype == FFI_TYPE_POINTER)
1235 {
1236 PUSHA (rvalue.object_value);
1237 }
1238 else if (rtype == FFI_TYPE_SINT32)
1239 {
1240 PUSHI (rvalue.int_value);
1241 }
1242 else if (rtype == FFI_TYPE_VOID)
1243 {
1244 /* skip */
1245 }
1246 else
1247 {
1248 switch (rtype)
1249 {
1250 case FFI_TYPE_SINT8:
1251 PUSHI ((jbyte)(rvalue.int_value & 0xff));
1252 break;
1253
1254 case FFI_TYPE_SINT16:
1255 PUSHI ((jshort)(rvalue.int_value & 0xffff));
1256 break;
1257
1258 case FFI_TYPE_UINT16:
1259 PUSHI (rvalue.int_value & 0xffff);
1260 break;
1261
1262 case FFI_TYPE_FLOAT:
1263 PUSHF (rvalue.float_value);
1264 break;
1265
1266 case FFI_TYPE_DOUBLE:
1267 PUSHD (rvalue.double_value);
1268 break;
1269
1270 case FFI_TYPE_SINT64:
1271 PUSHL (rvalue.long_value);
1272 break;
1273
1274 default:
1275 throw_internal_error ("unknown return type in invokeXXX");
1276 }
1277 }
1278 }
1279 NEXT_INSN;
1280
1281 insn_aconst_null:
1282 PUSHA (NULL);
1283 NEXT_INSN;
1284
1285 insn_iconst_m1:
1286 PUSHI (-1);
1287 NEXT_INSN;
1288
1289 insn_iconst_0:
1290 PUSHI (0);
1291 NEXT_INSN;
1292
1293 insn_iconst_1:
1294 PUSHI (1);
1295 NEXT_INSN;
1296
1297 insn_iconst_2:
1298 PUSHI (2);
1299 NEXT_INSN;
1300
1301 insn_iconst_3:
1302 PUSHI (3);
1303 NEXT_INSN;
1304
1305 insn_iconst_4:
1306 PUSHI (4);
1307 NEXT_INSN;
1308
1309 insn_iconst_5:
1310 PUSHI (5);
1311 NEXT_INSN;
1312
1313 insn_lconst_0:
1314 PUSHL (0);
1315 NEXT_INSN;
1316
1317 insn_lconst_1:
1318 PUSHL (1);
1319 NEXT_INSN;
1320
1321 insn_fconst_0:
1322 PUSHF (0);
1323 NEXT_INSN;
1324
1325 insn_fconst_1:
1326 PUSHF (1);
1327 NEXT_INSN;
1328
1329 insn_fconst_2:
1330 PUSHF (2);
1331 NEXT_INSN;
1332
1333 insn_dconst_0:
1334 PUSHD (0);
1335 NEXT_INSN;
1336
1337 insn_dconst_1:
1338 PUSHD (1);
1339 NEXT_INSN;
1340
1341 insn_bipush:
1342 // For direct threaded, bipush and sipush are the same.
1343 #ifndef DIRECT_THREADED
1344 PUSHI (GET1S ());
1345 NEXT_INSN;
1346 #endif /* DIRECT_THREADED */
1347 insn_sipush:
1348 PUSHI (GET2S ());
1349 NEXT_INSN;
1350
1351 insn_ldc:
1352 // For direct threaded, ldc and ldc_w are the same.
1353 #ifndef DIRECT_THREADED
1354 PUSHA ((jobject) AVAL1U ());
1355 NEXT_INSN;
1356 #endif /* DIRECT_THREADED */
1357 insn_ldc_w:
1358 PUSHA ((jobject) AVAL2U ());
1359 NEXT_INSN;
1360
1361 #ifdef DIRECT_THREADED
1362 // For direct threaded we have a separate 'ldc class' operation.
1363 insn_ldc_class:
1364 {
1365 // We could rewrite the instruction at this point.
1366 int index = INTVAL ();
1367 jobject k = (_Jv_Linker::resolve_pool_entry (meth->defining_class,
1368 index)).o;
1369 PUSHA (k);
1370 }
1371 NEXT_INSN;
1372 #endif /* DIRECT_THREADED */
1373
1374 insn_ldc2_w:
1375 {
1376 void *where = AVAL2UP ();
1377 memcpy (sp, where, 2*sizeof (_Jv_word));
1378 sp += 2;
1379 }
1380 NEXT_INSN;
1381
1382 insn_lload:
1383 LOADL (GET1U ());
1384 NEXT_INSN;
1385
1386 insn_fload:
1387 LOADF (GET1U ());
1388 NEXT_INSN;
1389
1390 insn_dload:
1391 LOADD (GET1U ());
1392 NEXT_INSN;
1393
1394 insn_aload:
1395 LOADA (GET1U ());
1396 NEXT_INSN;
1397
1398 insn_iload_0:
1399 LOADI (0);
1400 NEXT_INSN;
1401
1402 insn_iload_2:
1403 LOADI (2);
1404 NEXT_INSN;
1405
1406 insn_iload_3:
1407 LOADI (3);
1408 NEXT_INSN;
1409
1410 insn_lload_0:
1411 LOADL (0);
1412 NEXT_INSN;
1413
1414 insn_lload_1:
1415 LOADL (1);
1416 NEXT_INSN;
1417
1418 insn_lload_2:
1419 LOADL (2);
1420 NEXT_INSN;
1421
1422 insn_lload_3:
1423 LOADL (3);
1424 NEXT_INSN;
1425
1426 insn_fload_0:
1427 LOADF (0);
1428 NEXT_INSN;
1429
1430 insn_fload_1:
1431 LOADF (1);
1432 NEXT_INSN;
1433
1434 insn_fload_2:
1435 LOADF (2);
1436 NEXT_INSN;
1437
1438 insn_fload_3:
1439 LOADF (3);
1440 NEXT_INSN;
1441
1442 insn_dload_0:
1443 LOADD (0);
1444 NEXT_INSN;
1445
1446 insn_dload_1:
1447 LOADD (1);
1448 NEXT_INSN;
1449
1450 insn_dload_2:
1451 LOADD (2);
1452 NEXT_INSN;
1453
1454 insn_dload_3:
1455 LOADD (3);
1456 NEXT_INSN;
1457
1458 insn_aload_1:
1459 LOADA(1);
1460 NEXT_INSN;
1461
1462 insn_aload_2:
1463 LOADA(2);
1464 NEXT_INSN;
1465
1466 insn_aload_3:
1467 LOADA(3);
1468 NEXT_INSN;
1469
1470 insn_iaload:
1471 {
1472 jint index = POPI();
1473 jintArray arr = (jintArray) POPA();
1474 NULLARRAYCHECK (arr);
1475 ARRAYBOUNDSCHECK (arr, index);
1476 PUSHI( elements(arr)[index] );
1477 }
1478 NEXT_INSN;
1479
1480 insn_laload:
1481 {
1482 jint index = POPI();
1483 jlongArray arr = (jlongArray) POPA();
1484 NULLARRAYCHECK (arr);
1485 ARRAYBOUNDSCHECK (arr, index);
1486 PUSHL( elements(arr)[index] );
1487 }
1488 NEXT_INSN;
1489
1490 insn_faload:
1491 {
1492 jint index = POPI();
1493 jfloatArray arr = (jfloatArray) POPA();
1494 NULLARRAYCHECK (arr);
1495 ARRAYBOUNDSCHECK (arr, index);
1496 PUSHF( elements(arr)[index] );
1497 }
1498 NEXT_INSN;
1499
1500 insn_daload:
1501 {
1502 jint index = POPI();
1503 jdoubleArray arr = (jdoubleArray) POPA();
1504 NULLARRAYCHECK (arr);
1505 ARRAYBOUNDSCHECK (arr, index);
1506 PUSHD( elements(arr)[index] );
1507 }
1508 NEXT_INSN;
1509
1510 insn_aaload:
1511 {
1512 jint index = POPI();
1513 jobjectArray arr = (jobjectArray) POPA();
1514 NULLARRAYCHECK (arr);
1515 ARRAYBOUNDSCHECK (arr, index);
1516 PUSHA( elements(arr)[index] );
1517 }
1518 NEXT_INSN;
1519
1520 insn_baload:
1521 {
1522 jint index = POPI();
1523 jbyteArray arr = (jbyteArray) POPA();
1524 NULLARRAYCHECK (arr);
1525 ARRAYBOUNDSCHECK (arr, index);
1526 PUSHI( elements(arr)[index] );
1527 }
1528 NEXT_INSN;
1529
1530 insn_caload:
1531 {
1532 jint index = POPI();
1533 jcharArray arr = (jcharArray) POPA();
1534 NULLARRAYCHECK (arr);
1535 ARRAYBOUNDSCHECK (arr, index);
1536 PUSHI( elements(arr)[index] );
1537 }
1538 NEXT_INSN;
1539
1540 insn_saload:
1541 {
1542 jint index = POPI();
1543 jshortArray arr = (jshortArray) POPA();
1544 NULLARRAYCHECK (arr);
1545 ARRAYBOUNDSCHECK (arr, index);
1546 PUSHI( elements(arr)[index] );
1547 }
1548 NEXT_INSN;
1549
1550 insn_istore:
1551 STOREI (GET1U ());
1552 NEXT_INSN;
1553
1554 insn_lstore:
1555 STOREL (GET1U ());
1556 NEXT_INSN;
1557
1558 insn_fstore:
1559 STOREF (GET1U ());
1560 NEXT_INSN;
1561
1562 insn_dstore:
1563 STORED (GET1U ());
1564 NEXT_INSN;
1565
1566 insn_astore:
1567 STOREA (GET1U ());
1568 NEXT_INSN;
1569
1570 insn_istore_0:
1571 STOREI (0);
1572 NEXT_INSN;
1573
1574 insn_istore_1:
1575 STOREI (1);
1576 NEXT_INSN;
1577
1578 insn_istore_2:
1579 STOREI (2);
1580 NEXT_INSN;
1581
1582 insn_istore_3:
1583 STOREI (3);
1584 NEXT_INSN;
1585
1586 insn_lstore_0:
1587 STOREL (0);
1588 NEXT_INSN;
1589
1590 insn_lstore_1:
1591 STOREL (1);
1592 NEXT_INSN;
1593
1594 insn_lstore_2:
1595 STOREL (2);
1596 NEXT_INSN;
1597
1598 insn_lstore_3:
1599 STOREL (3);
1600 NEXT_INSN;
1601
1602 insn_fstore_0:
1603 STOREF (0);
1604 NEXT_INSN;
1605
1606 insn_fstore_1:
1607 STOREF (1);
1608 NEXT_INSN;
1609
1610 insn_fstore_2:
1611 STOREF (2);
1612 NEXT_INSN;
1613
1614 insn_fstore_3:
1615 STOREF (3);
1616 NEXT_INSN;
1617
1618 insn_dstore_0:
1619 STORED (0);
1620 NEXT_INSN;
1621
1622 insn_dstore_1:
1623 STORED (1);
1624 NEXT_INSN;
1625
1626 insn_dstore_2:
1627 STORED (2);
1628 NEXT_INSN;
1629
1630 insn_dstore_3:
1631 STORED (3);
1632 NEXT_INSN;
1633
1634 insn_astore_0:
1635 STOREA(0);
1636 NEXT_INSN;
1637
1638 insn_astore_1:
1639 STOREA(1);
1640 NEXT_INSN;
1641
1642 insn_astore_2:
1643 STOREA(2);
1644 NEXT_INSN;
1645
1646 insn_astore_3:
1647 STOREA(3);
1648 NEXT_INSN;
1649
1650 insn_iastore:
1651 {
1652 jint value = POPI();
1653 jint index = POPI();
1654 jintArray arr = (jintArray) POPA();
1655 NULLARRAYCHECK (arr);
1656 ARRAYBOUNDSCHECK (arr, index);
1657 elements(arr)[index] = value;
1658 }
1659 NEXT_INSN;
1660
1661 insn_lastore:
1662 {
1663 jlong value = POPL();
1664 jint index = POPI();
1665 jlongArray arr = (jlongArray) POPA();
1666 NULLARRAYCHECK (arr);
1667 ARRAYBOUNDSCHECK (arr, index);
1668 elements(arr)[index] = value;
1669 }
1670 NEXT_INSN;
1671
1672 insn_fastore:
1673 {
1674 jfloat value = POPF();
1675 jint index = POPI();
1676 jfloatArray arr = (jfloatArray) POPA();
1677 NULLARRAYCHECK (arr);
1678 ARRAYBOUNDSCHECK (arr, index);
1679 elements(arr)[index] = value;
1680 }
1681 NEXT_INSN;
1682
1683 insn_dastore:
1684 {
1685 jdouble value = POPD();
1686 jint index = POPI();
1687 jdoubleArray arr = (jdoubleArray) POPA();
1688 NULLARRAYCHECK (arr);
1689 ARRAYBOUNDSCHECK (arr, index);
1690 elements(arr)[index] = value;
1691 }
1692 NEXT_INSN;
1693
1694 insn_aastore:
1695 {
1696 jobject value = POPA();
1697 jint index = POPI();
1698 jobjectArray arr = (jobjectArray) POPA();
1699 NULLARRAYCHECK (arr);
1700 ARRAYBOUNDSCHECK (arr, index);
1701 _Jv_CheckArrayStore (arr, value);
1702 elements(arr)[index] = value;
1703 }
1704 NEXT_INSN;
1705
1706 insn_bastore:
1707 {
1708 jbyte value = (jbyte) POPI();
1709 jint index = POPI();
1710 jbyteArray arr = (jbyteArray) POPA();
1711 NULLARRAYCHECK (arr);
1712 ARRAYBOUNDSCHECK (arr, index);
1713 elements(arr)[index] = value;
1714 }
1715 NEXT_INSN;
1716
1717 insn_castore:
1718 {
1719 jchar value = (jchar) POPI();
1720 jint index = POPI();
1721 jcharArray arr = (jcharArray) POPA();
1722 NULLARRAYCHECK (arr);
1723 ARRAYBOUNDSCHECK (arr, index);
1724 elements(arr)[index] = value;
1725 }
1726 NEXT_INSN;
1727
1728 insn_sastore:
1729 {
1730 jshort value = (jshort) POPI();
1731 jint index = POPI();
1732 jshortArray arr = (jshortArray) POPA();
1733 NULLARRAYCHECK (arr);
1734 ARRAYBOUNDSCHECK (arr, index);
1735 elements(arr)[index] = value;
1736 }
1737 NEXT_INSN;
1738
1739 insn_pop:
1740 sp -= 1;
1741 NEXT_INSN;
1742
1743 insn_pop2:
1744 sp -= 2;
1745 NEXT_INSN;
1746
1747 insn_dup:
1748 sp[0] = sp[-1];
1749 sp += 1;
1750 NEXT_INSN;
1751
1752 insn_dup_x1:
1753 dupx (sp, 1, 1); sp+=1;
1754 NEXT_INSN;
1755
1756 insn_dup_x2:
1757 dupx (sp, 1, 2); sp+=1;
1758 NEXT_INSN;
1759
1760 insn_dup2:
1761 sp[0] = sp[-2];
1762 sp[1] = sp[-1];
1763 sp += 2;
1764 NEXT_INSN;
1765
1766 insn_dup2_x1:
1767 dupx (sp, 2, 1); sp+=2;
1768 NEXT_INSN;
1769
1770 insn_dup2_x2:
1771 dupx (sp, 2, 2); sp+=2;
1772 NEXT_INSN;
1773
1774 insn_swap:
1775 {
1776 jobject tmp1 = POPA();
1777 jobject tmp2 = POPA();
1778 PUSHA (tmp1);
1779 PUSHA (tmp2);
1780 }
1781 NEXT_INSN;
1782
1783 insn_iadd:
1784 BINOPI(+);
1785 NEXT_INSN;
1786
1787 insn_ladd:
1788 BINOPL(+);
1789 NEXT_INSN;
1790
1791 insn_fadd:
1792 BINOPF(+);
1793 NEXT_INSN;
1794
1795 insn_dadd:
1796 BINOPD(+);
1797 NEXT_INSN;
1798
1799 insn_isub:
1800 BINOPI(-);
1801 NEXT_INSN;
1802
1803 insn_lsub:
1804 BINOPL(-);
1805 NEXT_INSN;
1806
1807 insn_fsub:
1808 BINOPF(-);
1809 NEXT_INSN;
1810
1811 insn_dsub:
1812 BINOPD(-);
1813 NEXT_INSN;
1814
1815 insn_imul:
1816 BINOPI(*);
1817 NEXT_INSN;
1818
1819 insn_lmul:
1820 BINOPL(*);
1821 NEXT_INSN;
1822
1823 insn_fmul:
1824 BINOPF(*);
1825 NEXT_INSN;
1826
1827 insn_dmul:
1828 BINOPD(*);
1829 NEXT_INSN;
1830
1831 insn_idiv:
1832 {
1833 jint value2 = POPI();
1834 jint value1 = POPI();
1835 jint res = _Jv_divI (value1, value2);
1836 PUSHI (res);
1837 }
1838 NEXT_INSN;
1839
1840 insn_ldiv:
1841 {
1842 jlong value2 = POPL();
1843 jlong value1 = POPL();
1844 jlong res = _Jv_divJ (value1, value2);
1845 PUSHL (res);
1846 }
1847 NEXT_INSN;
1848
1849 insn_fdiv:
1850 {
1851 jfloat value2 = POPF();
1852 jfloat value1 = POPF();
1853 jfloat res = value1 / value2;
1854 PUSHF (res);
1855 }
1856 NEXT_INSN;
1857
1858 insn_ddiv:
1859 {
1860 jdouble value2 = POPD();
1861 jdouble value1 = POPD();
1862 jdouble res = value1 / value2;
1863 PUSHD (res);
1864 }
1865 NEXT_INSN;
1866
1867 insn_irem:
1868 {
1869 jint value2 = POPI();
1870 jint value1 = POPI();
1871 jint res = _Jv_remI (value1, value2);
1872 PUSHI (res);
1873 }
1874 NEXT_INSN;
1875
1876 insn_lrem:
1877 {
1878 jlong value2 = POPL();
1879 jlong value1 = POPL();
1880 jlong res = _Jv_remJ (value1, value2);
1881 PUSHL (res);
1882 }
1883 NEXT_INSN;
1884
1885 insn_frem:
1886 {
1887 jfloat value2 = POPF();
1888 jfloat value1 = POPF();
1889 jfloat res = __ieee754_fmod (value1, value2);
1890 PUSHF (res);
1891 }
1892 NEXT_INSN;
1893
1894 insn_drem:
1895 {
1896 jdouble value2 = POPD();
1897 jdouble value1 = POPD();
1898 jdouble res = __ieee754_fmod (value1, value2);
1899 PUSHD (res);
1900 }
1901 NEXT_INSN;
1902
1903 insn_ineg:
1904 {
1905 jint value = POPI();
1906 PUSHI (value * -1);
1907 }
1908 NEXT_INSN;
1909
1910 insn_lneg:
1911 {
1912 jlong value = POPL();
1913 PUSHL (value * -1);
1914 }
1915 NEXT_INSN;
1916
1917 insn_fneg:
1918 {
1919 jfloat value = POPF();
1920 PUSHF (value * -1);
1921 }
1922 NEXT_INSN;
1923
1924 insn_dneg:
1925 {
1926 jdouble value = POPD();
1927 PUSHD (value * -1);
1928 }
1929 NEXT_INSN;
1930
1931 insn_ishl:
1932 {
1933 jint shift = (POPI() & 0x1f);
1934 jint value = POPI();
1935 PUSHI (value << shift);
1936 }
1937 NEXT_INSN;
1938
1939 insn_lshl:
1940 {
1941 jint shift = (POPI() & 0x3f);
1942 jlong value = POPL();
1943 PUSHL (value << shift);
1944 }
1945 NEXT_INSN;
1946
1947 insn_ishr:
1948 {
1949 jint shift = (POPI() & 0x1f);
1950 jint value = POPI();
1951 PUSHI (value >> shift);
1952 }
1953 NEXT_INSN;
1954
1955 insn_lshr:
1956 {
1957 jint shift = (POPI() & 0x3f);
1958 jlong value = POPL();
1959 PUSHL (value >> shift);
1960 }
1961 NEXT_INSN;
1962
1963 insn_iushr:
1964 {
1965 jint shift = (POPI() & 0x1f);
1966 _Jv_uint value = (_Jv_uint) POPI();
1967 PUSHI ((jint) (value >> shift));
1968 }
1969 NEXT_INSN;
1970
1971 insn_lushr:
1972 {
1973 jint shift = (POPI() & 0x3f);
1974 _Jv_ulong value = (_Jv_ulong) POPL();
1975 PUSHL ((jlong) (value >> shift));
1976 }
1977 NEXT_INSN;
1978
1979 insn_iand:
1980 BINOPI (&);
1981 NEXT_INSN;
1982
1983 insn_land:
1984 BINOPL (&);
1985 NEXT_INSN;
1986
1987 insn_ior:
1988 BINOPI (|);
1989 NEXT_INSN;
1990
1991 insn_lor:
1992 BINOPL (|);
1993 NEXT_INSN;
1994
1995 insn_ixor:
1996 BINOPI (^);
1997 NEXT_INSN;
1998
1999 insn_lxor:
2000 BINOPL (^);
2001 NEXT_INSN;
2002
2003 insn_iinc:
2004 {
2005 jint index = GET1U ();
2006 jint amount = GET1S ();
2007 locals[index].i += amount;
2008 }
2009 NEXT_INSN;
2010
2011 insn_i2l:
2012 {jlong value = POPI(); PUSHL (value);}
2013 NEXT_INSN;
2014
2015 insn_i2f:
2016 {jfloat value = POPI(); PUSHF (value);}
2017 NEXT_INSN;
2018
2019 insn_i2d:
2020 {jdouble value = POPI(); PUSHD (value);}
2021 NEXT_INSN;
2022
2023 insn_l2i:
2024 {jint value = POPL(); PUSHI (value);}
2025 NEXT_INSN;
2026
2027 insn_l2f:
2028 {jfloat value = POPL(); PUSHF (value);}
2029 NEXT_INSN;
2030
2031 insn_l2d:
2032 {jdouble value = POPL(); PUSHD (value);}
2033 NEXT_INSN;
2034
2035 insn_f2i:
2036 {
2037 using namespace java::lang;
2038 jint value = convert (POPF (), Integer::MIN_VALUE, Integer::MAX_VALUE);
2039 PUSHI(value);
2040 }
2041 NEXT_INSN;
2042
2043 insn_f2l:
2044 {
2045 using namespace java::lang;
2046 jlong value = convert (POPF (), Long::MIN_VALUE, Long::MAX_VALUE);
2047 PUSHL(value);
2048 }
2049 NEXT_INSN;
2050
2051 insn_f2d:
2052 { jdouble value = POPF (); PUSHD(value); }
2053 NEXT_INSN;
2054
2055 insn_d2i:
2056 {
2057 using namespace java::lang;
2058 jint value = convert (POPD (), Integer::MIN_VALUE, Integer::MAX_VALUE);
2059 PUSHI(value);
2060 }
2061 NEXT_INSN;
2062
2063 insn_d2l:
2064 {
2065 using namespace java::lang;
2066 jlong value = convert (POPD (), Long::MIN_VALUE, Long::MAX_VALUE);
2067 PUSHL(value);
2068 }
2069 NEXT_INSN;
2070
2071 insn_d2f:
2072 { jfloat value = POPD (); PUSHF(value); }
2073 NEXT_INSN;
2074
2075 insn_i2b:
2076 { jbyte value = POPI (); PUSHI(value); }
2077 NEXT_INSN;
2078
2079 insn_i2c:
2080 { jchar value = POPI (); PUSHI(value); }
2081 NEXT_INSN;
2082
2083 insn_i2s:
2084 { jshort value = POPI (); PUSHI(value); }
2085 NEXT_INSN;
2086
2087 insn_lcmp:
2088 {
2089 jlong value2 = POPL ();
2090 jlong value1 = POPL ();
2091 if (value1 > value2)
2092 { PUSHI (1); }
2093 else if (value1 == value2)
2094 { PUSHI (0); }
2095 else
2096 { PUSHI (-1); }
2097 }
2098 NEXT_INSN;
2099
2100 insn_fcmpl:
2101 tmpval = -1;
2102 goto fcmp;
2103
2104 insn_fcmpg:
2105 tmpval = 1;
2106
2107 fcmp:
2108 {
2109 jfloat value2 = POPF ();
2110 jfloat value1 = POPF ();
2111 if (value1 > value2)
2112 PUSHI (1);
2113 else if (value1 == value2)
2114 PUSHI (0);
2115 else if (value1 < value2)
2116 PUSHI (-1);
2117 else
2118 PUSHI (tmpval);
2119 }
2120 NEXT_INSN;
2121
2122 insn_dcmpl:
2123 tmpval = -1;
2124 goto dcmp;
2125
2126 insn_dcmpg:
2127 tmpval = 1;
2128
2129 dcmp:
2130 {
2131 jdouble value2 = POPD ();
2132 jdouble value1 = POPD ();
2133 if (value1 > value2)
2134 PUSHI (1);
2135 else if (value1 == value2)
2136 PUSHI (0);
2137 else if (value1 < value2)
2138 PUSHI (-1);
2139 else
2140 PUSHI (tmpval);
2141 }
2142 NEXT_INSN;
2143
2144 insn_ifeq:
2145 {
2146 if (POPI() == 0)
2147 TAKE_GOTO;
2148 else
2149 SKIP_GOTO;
2150 }
2151 NEXT_INSN;
2152
2153 insn_ifne:
2154 {
2155 if (POPI() != 0)
2156 TAKE_GOTO;
2157 else
2158 SKIP_GOTO;
2159 }
2160 NEXT_INSN;
2161
2162 insn_iflt:
2163 {
2164 if (POPI() < 0)
2165 TAKE_GOTO;
2166 else
2167 SKIP_GOTO;
2168 }
2169 NEXT_INSN;
2170
2171 insn_ifge:
2172 {
2173 if (POPI() >= 0)
2174 TAKE_GOTO;
2175 else
2176 SKIP_GOTO;
2177 }
2178 NEXT_INSN;
2179
2180 insn_ifgt:
2181 {
2182 if (POPI() > 0)
2183 TAKE_GOTO;
2184 else
2185 SKIP_GOTO;
2186 }
2187 NEXT_INSN;
2188
2189 insn_ifle:
2190 {
2191 if (POPI() <= 0)
2192 TAKE_GOTO;
2193 else
2194 SKIP_GOTO;
2195 }
2196 NEXT_INSN;
2197
2198 insn_if_icmpeq:
2199 {
2200 jint value2 = POPI();
2201 jint value1 = POPI();
2202 if (value1 == value2)
2203 TAKE_GOTO;
2204 else
2205 SKIP_GOTO;
2206 }
2207 NEXT_INSN;
2208
2209 insn_if_icmpne:
2210 {
2211 jint value2 = POPI();
2212 jint value1 = POPI();
2213 if (value1 != value2)
2214 TAKE_GOTO;
2215 else
2216 SKIP_GOTO;
2217 }
2218 NEXT_INSN;
2219
2220 insn_if_icmplt:
2221 {
2222 jint value2 = POPI();
2223 jint value1 = POPI();
2224 if (value1 < value2)
2225 TAKE_GOTO;
2226 else
2227 SKIP_GOTO;
2228 }
2229 NEXT_INSN;
2230
2231 insn_if_icmpge:
2232 {
2233 jint value2 = POPI();
2234 jint value1 = POPI();
2235 if (value1 >= value2)
2236 TAKE_GOTO;
2237 else
2238 SKIP_GOTO;
2239 }
2240 NEXT_INSN;
2241
2242 insn_if_icmpgt:
2243 {
2244 jint value2 = POPI();
2245 jint value1 = POPI();
2246 if (value1 > value2)
2247 TAKE_GOTO;
2248 else
2249 SKIP_GOTO;
2250 }
2251 NEXT_INSN;
2252
2253 insn_if_icmple:
2254 {
2255 jint value2 = POPI();
2256 jint value1 = POPI();
2257 if (value1 <= value2)
2258 TAKE_GOTO;
2259 else
2260 SKIP_GOTO;
2261 }
2262 NEXT_INSN;
2263
2264 insn_if_acmpeq:
2265 {
2266 jobject value2 = POPA();
2267 jobject value1 = POPA();
2268 if (value1 == value2)
2269 TAKE_GOTO;
2270 else
2271 SKIP_GOTO;
2272 }
2273 NEXT_INSN;
2274
2275 insn_if_acmpne:
2276 {
2277 jobject value2 = POPA();
2278 jobject value1 = POPA();
2279 if (value1 != value2)
2280 TAKE_GOTO;
2281 else
2282 SKIP_GOTO;
2283 }
2284 NEXT_INSN;
2285
2286 insn_goto_w:
2287 #ifndef DIRECT_THREADED
2288 // For direct threaded, goto and goto_w are the same.
2289 pc = pc - 1 + get4 (pc);
2290 NEXT_INSN;
2291 #endif /* DIRECT_THREADED */
2292 insn_goto:
2293 TAKE_GOTO;
2294 NEXT_INSN;
2295
2296 insn_jsr_w:
2297 #ifndef DIRECT_THREADED
2298 // For direct threaded, jsr and jsr_w are the same.
2299 {
2300 pc_t next = pc - 1 + get4 (pc);
2301 pc += 4;
2302 PUSHA ((jobject) pc);
2303 pc = next;
2304 }
2305 NEXT_INSN;
2306 #endif /* DIRECT_THREADED */
2307 insn_jsr:
2308 {
2309 pc_t next = GOTO_VAL();
2310 SKIP_GOTO;
2311 PUSHA ((jobject) pc);
2312 pc = next;
2313 }
2314 NEXT_INSN;
2315
2316 insn_ret:
2317 {
2318 jint index = GET1U ();
2319 pc = (pc_t) PEEKA (index);
2320 }
2321 NEXT_INSN;
2322
2323 insn_tableswitch:
2324 {
2325 #ifdef DIRECT_THREADED
2326 void *def = (pc++)->datum;
2327
2328 int index = POPI();
2329
2330 jint low = INTVAL ();
2331 jint high = INTVAL ();
2332
2333 if (index < low || index > high)
2334 pc = (insn_slot *) def;
2335 else
2336 pc = (insn_slot *) ((pc + index - low)->datum);
2337 #else
2338 pc_t base_pc = pc - 1;
2339 int index = POPI ();
2340
2341 pc_t base = (pc_t) bytecode ();
2342 while ((pc - base) % 4 != 0)
2343 ++pc;
2344
2345 jint def = get4 (pc);
2346 jint low = get4 (pc + 4);
2347 jint high = get4 (pc + 8);
2348 if (index < low || index > high)
2349 pc = base_pc + def;
2350 else
2351 pc = base_pc + get4 (pc + 4 * (index - low + 3));
2352 #endif /* DIRECT_THREADED */
2353 }
2354 NEXT_INSN;
2355
2356 insn_lookupswitch:
2357 {
2358 #ifdef DIRECT_THREADED
2359 void *def = (pc++)->insn;
2360
2361 int index = POPI();
2362
2363 jint npairs = INTVAL ();
2364
2365 int max = npairs - 1;
2366 int min = 0;
2367
2368 // Simple binary search...
2369 while (min < max)
2370 {
2371 int half = (min + max) / 2;
2372 int match = pc[2 * half].int_val;
2373
2374 if (index == match)
2375 {
2376 // Found it.
2377 pc = (insn_slot *) pc[2 * half + 1].datum;
2378 NEXT_INSN;
2379 }
2380 else if (index < match)
2381 // We can use HALF - 1 here because we check again on
2382 // loop exit.
2383 max = half - 1;
2384 else
2385 // We can use HALF + 1 here because we check again on
2386 // loop exit.
2387 min = half + 1;
2388 }
2389 if (index == pc[2 * min].int_val)
2390 pc = (insn_slot *) pc[2 * min + 1].datum;
2391 else
2392 pc = (insn_slot *) def;
2393 #else
2394 unsigned char *base_pc = pc-1;
2395 int index = POPI();
2396
2397 unsigned char* base = bytecode ();
2398 while ((pc-base) % 4 != 0)
2399 ++pc;
2400
2401 jint def = get4 (pc);
2402 jint npairs = get4 (pc+4);
2403
2404 int max = npairs-1;
2405 int min = 0;
2406
2407 // Simple binary search...
2408 while (min < max)
2409 {
2410 int half = (min+max)/2;
2411 int match = get4 (pc+ 4*(2 + 2*half));
2412
2413 if (index == match)
2414 min = max = half;
2415 else if (index < match)
2416 // We can use HALF - 1 here because we check again on
2417 // loop exit.
2418 max = half - 1;
2419 else
2420 // We can use HALF + 1 here because we check again on
2421 // loop exit.
2422 min = half + 1;
2423 }
2424
2425 if (index == get4 (pc+ 4*(2 + 2*min)))
2426 pc = base_pc + get4 (pc+ 4*(2 + 2*min + 1));
2427 else
2428 pc = base_pc + def;
2429 #endif /* DIRECT_THREADED */
2430 }
2431 NEXT_INSN;
2432
2433 insn_areturn:
2434 *(jobject *) retp = POPA ();
2435 return;
2436
2437 insn_lreturn:
2438 *(jlong *) retp = POPL ();
2439 return;
2440
2441 insn_freturn:
2442 *(jfloat *) retp = POPF ();
2443 return;
2444
2445 insn_dreturn:
2446 *(jdouble *) retp = POPD ();
2447 return;
2448
2449 insn_ireturn:
2450 *(jint *) retp = POPI ();
2451 return;
2452
2453 insn_return:
2454 return;
2455
2456 insn_getstatic:
2457 {
2458 jint fieldref_index = GET2U ();
2459 SAVE_PC(); // Constant pool resolution could throw.
2460 _Jv_Linker::resolve_pool_entry (meth->defining_class, fieldref_index);
2461 _Jv_Field *field = pool_data[fieldref_index].field;
2462
2463 if ((field->flags & Modifier::STATIC) == 0)
2464 throw_incompatible_class_change_error
2465 (JvNewStringLatin1 ("field no longer static"));
2466
2467 jclass type = field->type;
2468
2469 // We rewrite the instruction once we discover what it refers
2470 // to.
2471 void *newinsn = NULL;
2472 if (type->isPrimitive ())
2473 {
2474 switch (type->size_in_bytes)
2475 {
2476 case 1:
2477 PUSHI (*field->u.byte_addr);
2478 newinsn = AMPAMP (getstatic_resolved_1);
2479 break;
2480
2481 case 2:
2482 if (type == JvPrimClass (char))
2483 {
2484 PUSHI (*field->u.char_addr);
2485 newinsn = AMPAMP (getstatic_resolved_char);
2486 }
2487 else
2488 {
2489 PUSHI (*field->u.short_addr);
2490 newinsn = AMPAMP (getstatic_resolved_short);
2491 }
2492 break;
2493
2494 case 4:
2495 PUSHI(*field->u.int_addr);
2496 newinsn = AMPAMP (getstatic_resolved_4);
2497 break;
2498
2499 case 8:
2500 PUSHL(*field->u.long_addr);
2501 newinsn = AMPAMP (getstatic_resolved_8);
2502 break;
2503 }
2504 }
2505 else
2506 {
2507 PUSHA(*field->u.object_addr);
2508 newinsn = AMPAMP (getstatic_resolved_obj);
2509 }
2510
2511 #ifdef DIRECT_THREADED
2512 pc[-2].insn = newinsn;
2513 pc[-1].datum = field->u.addr;
2514 #endif /* DIRECT_THREADED */
2515 }
2516 NEXT_INSN;
2517
2518 #ifdef DIRECT_THREADED
2519 getstatic_resolved_1:
2520 PUSHI (*(jbyte *) AVAL ());
2521 NEXT_INSN;
2522
2523 getstatic_resolved_char:
2524 PUSHI (*(jchar *) AVAL ());
2525 NEXT_INSN;
2526
2527 getstatic_resolved_short:
2528 PUSHI (*(jshort *) AVAL ());
2529 NEXT_INSN;
2530
2531 getstatic_resolved_4:
2532 PUSHI (*(jint *) AVAL ());
2533 NEXT_INSN;
2534
2535 getstatic_resolved_8:
2536 PUSHL (*(jlong *) AVAL ());
2537 NEXT_INSN;
2538
2539 getstatic_resolved_obj:
2540 PUSHA (*(jobject *) AVAL ());
2541 NEXT_INSN;
2542 #endif /* DIRECT_THREADED */
2543
2544 insn_getfield:
2545 {
2546 jint fieldref_index = GET2U ();
2547 _Jv_Linker::resolve_pool_entry (meth->defining_class, fieldref_index);
2548 _Jv_Field *field = pool_data[fieldref_index].field;
2549
2550 if ((field->flags & Modifier::STATIC) != 0)
2551 throw_incompatible_class_change_error
2552 (JvNewStringLatin1 ("field is static"));
2553
2554 jclass type = field->type;
2555 jint field_offset = field->u.boffset;
2556 if (field_offset > 0xffff)
2557 throw new java::lang::VirtualMachineError;
2558
2559 jobject obj = POPA();
2560 NULLCHECK(obj);
2561
2562 void *newinsn = NULL;
2563 _Jv_value *val = (_Jv_value *) ((char *)obj + field_offset);
2564 if (type->isPrimitive ())
2565 {
2566 switch (type->size_in_bytes)
2567 {
2568 case 1:
2569 PUSHI (val->byte_value);
2570 newinsn = AMPAMP (getfield_resolved_1);
2571 break;
2572
2573 case 2:
2574 if (type == JvPrimClass (char))
2575 {
2576 PUSHI (val->char_value);
2577 newinsn = AMPAMP (getfield_resolved_char);
2578 }
2579 else
2580 {
2581 PUSHI (val->short_value);
2582 newinsn = AMPAMP (getfield_resolved_short);
2583 }
2584 break;
2585
2586 case 4:
2587 PUSHI (val->int_value);
2588 newinsn = AMPAMP (getfield_resolved_4);
2589 break;
2590
2591 case 8:
2592 PUSHL (val->long_value);
2593 newinsn = AMPAMP (getfield_resolved_8);
2594 break;
2595 }
2596 }
2597 else
2598 {
2599 PUSHA (val->object_value);
2600 newinsn = AMPAMP (getfield_resolved_obj);
2601 }
2602
2603 #ifdef DIRECT_THREADED
2604 pc[-2].insn = newinsn;
2605 pc[-1].int_val = field_offset;
2606 #endif /* DIRECT_THREADED */
2607 }
2608 NEXT_INSN;
2609
2610 #ifdef DIRECT_THREADED
2611 getfield_resolved_1:
2612 {
2613 char *obj = (char *) POPA ();
2614 NULLCHECK (obj);
2615 PUSHI (*(jbyte *) (obj + INTVAL ()));
2616 }
2617 NEXT_INSN;
2618
2619 getfield_resolved_char:
2620 {
2621 char *obj = (char *) POPA ();
2622 NULLCHECK (obj);
2623 PUSHI (*(jchar *) (obj + INTVAL ()));
2624 }
2625 NEXT_INSN;
2626
2627 getfield_resolved_short:
2628 {
2629 char *obj = (char *) POPA ();
2630 NULLCHECK (obj);
2631 PUSHI (*(jshort *) (obj + INTVAL ()));
2632 }
2633 NEXT_INSN;
2634
2635 getfield_resolved_4:
2636 {
2637 char *obj = (char *) POPA ();
2638 NULLCHECK (obj);
2639 PUSHI (*(jint *) (obj + INTVAL ()));
2640 }
2641 NEXT_INSN;
2642
2643 getfield_resolved_8:
2644 {
2645 char *obj = (char *) POPA ();
2646 NULLCHECK (obj);
2647 PUSHL (*(jlong *) (obj + INTVAL ()));
2648 }
2649 NEXT_INSN;
2650
2651 getfield_resolved_obj:
2652 {
2653 char *obj = (char *) POPA ();
2654 NULLCHECK (obj);
2655 PUSHA (*(jobject *) (obj + INTVAL ()));
2656 }
2657 NEXT_INSN;
2658 #endif /* DIRECT_THREADED */
2659
2660 insn_putstatic:
2661 {
2662 jint fieldref_index = GET2U ();
2663 _Jv_Linker::resolve_pool_entry (meth->defining_class, fieldref_index);
2664 _Jv_Field *field = pool_data[fieldref_index].field;
2665
2666 jclass type = field->type;
2667
2668 // ResolvePoolEntry cannot check this
2669 if ((field->flags & Modifier::STATIC) == 0)
2670 throw_incompatible_class_change_error
2671 (JvNewStringLatin1 ("field no longer static"));
2672
2673 void *newinsn = NULL;
2674 if (type->isPrimitive ())
2675 {
2676 switch (type->size_in_bytes)
2677 {
2678 case 1:
2679 {
2680 jint value = POPI();
2681 *field->u.byte_addr = value;
2682 newinsn = AMPAMP (putstatic_resolved_1);
2683 break;
2684 }
2685
2686 case 2:
2687 {
2688 jint value = POPI();
2689 *field->u.char_addr = value;
2690 newinsn = AMPAMP (putstatic_resolved_2);
2691 break;
2692 }
2693
2694 case 4:
2695 {
2696 jint value = POPI();
2697 *field->u.int_addr = value;
2698 newinsn = AMPAMP (putstatic_resolved_4);
2699 break;
2700 }
2701
2702 case 8:
2703 {
2704 jlong value = POPL();
2705 *field->u.long_addr = value;
2706 newinsn = AMPAMP (putstatic_resolved_8);
2707 break;
2708 }
2709 }
2710 }
2711 else
2712 {
2713 jobject value = POPA();
2714 *field->u.object_addr = value;
2715 newinsn = AMPAMP (putstatic_resolved_obj);
2716 }
2717
2718 #ifdef DIRECT_THREADED
2719 pc[-2].insn = newinsn;
2720 pc[-1].datum = field->u.addr;
2721 #endif /* DIRECT_THREADED */
2722 }
2723 NEXT_INSN;
2724
2725 #ifdef DIRECT_THREADED
2726 putstatic_resolved_1:
2727 *(jbyte *) AVAL () = POPI ();
2728 NEXT_INSN;
2729
2730 putstatic_resolved_2:
2731 *(jchar *) AVAL () = POPI ();
2732 NEXT_INSN;
2733
2734 putstatic_resolved_4:
2735 *(jint *) AVAL () = POPI ();
2736 NEXT_INSN;
2737
2738 putstatic_resolved_8:
2739 *(jlong *) AVAL () = POPL ();
2740 NEXT_INSN;
2741
2742 putstatic_resolved_obj:
2743 *(jobject *) AVAL () = POPA ();
2744 NEXT_INSN;
2745 #endif /* DIRECT_THREADED */
2746
2747 insn_putfield:
2748 {
2749 jint fieldref_index = GET2U ();
2750 _Jv_Linker::resolve_pool_entry (meth->defining_class, fieldref_index);
2751 _Jv_Field *field = pool_data[fieldref_index].field;
2752
2753 jclass type = field->type;
2754
2755 if ((field->flags & Modifier::STATIC) != 0)
2756 throw_incompatible_class_change_error
2757 (JvNewStringLatin1 ("field is static"));
2758
2759 jint field_offset = field->u.boffset;
2760 if (field_offset > 0xffff)
2761 throw new java::lang::VirtualMachineError;
2762
2763 void *newinsn = NULL;
2764 if (type->isPrimitive ())
2765 {
2766 switch (type->size_in_bytes)
2767 {
2768 case 1:
2769 {
2770 jint value = POPI();
2771 jobject obj = POPA();
2772 NULLCHECK(obj);
2773 *(jbyte*) ((char*)obj + field_offset) = value;
2774 newinsn = AMPAMP (putfield_resolved_1);
2775 break;
2776 }
2777
2778 case 2:
2779 {
2780 jint value = POPI();
2781 jobject obj = POPA();
2782 NULLCHECK(obj);
2783 *(jchar*) ((char*)obj + field_offset) = value;
2784 newinsn = AMPAMP (putfield_resolved_2);
2785 break;
2786 }
2787
2788 case 4:
2789 {
2790 jint value = POPI();
2791 jobject obj = POPA();
2792 NULLCHECK(obj);
2793 *(jint*) ((char*)obj + field_offset) = value;
2794 newinsn = AMPAMP (putfield_resolved_4);
2795 break;
2796 }
2797
2798 case 8:
2799 {
2800 jlong value = POPL();
2801 jobject obj = POPA();
2802 NULLCHECK(obj);
2803 *(jlong*) ((char*)obj + field_offset) = value;
2804 newinsn = AMPAMP (putfield_resolved_8);
2805 break;
2806 }
2807 }
2808 }
2809 else
2810 {
2811 jobject value = POPA();
2812 jobject obj = POPA();
2813 NULLCHECK(obj);
2814 *(jobject*) ((char*)obj + field_offset) = value;
2815 newinsn = AMPAMP (putfield_resolved_obj);
2816 }
2817
2818 #ifdef DIRECT_THREADED
2819 pc[-2].insn = newinsn;
2820 pc[-1].int_val = field_offset;
2821 #endif /* DIRECT_THREADED */
2822 }
2823 NEXT_INSN;
2824
2825 #ifdef DIRECT_THREADED
2826 putfield_resolved_1:
2827 {
2828 jint val = POPI ();
2829 char *obj = (char *) POPA ();
2830 NULLCHECK (obj);
2831 *(jbyte *) (obj + INTVAL ()) = val;
2832 }
2833 NEXT_INSN;
2834
2835 putfield_resolved_2:
2836 {
2837 jint val = POPI ();
2838 char *obj = (char *) POPA ();
2839 NULLCHECK (obj);
2840 *(jchar *) (obj + INTVAL ()) = val;
2841 }
2842 NEXT_INSN;
2843
2844 putfield_resolved_4:
2845 {
2846 jint val = POPI ();
2847 char *obj = (char *) POPA ();
2848 NULLCHECK (obj);
2849 *(jint *) (obj + INTVAL ()) = val;
2850 }
2851 NEXT_INSN;
2852
2853 putfield_resolved_8:
2854 {
2855 jlong val = POPL ();
2856 char *obj = (char *) POPA ();
2857 NULLCHECK (obj);
2858 *(jlong *) (obj + INTVAL ()) = val;
2859 }
2860 NEXT_INSN;
2861
2862 putfield_resolved_obj:
2863 {
2864 jobject val = POPA ();
2865 char *obj = (char *) POPA ();
2866 NULLCHECK (obj);
2867 *(jobject *) (obj + INTVAL ()) = val;
2868 }
2869 NEXT_INSN;
2870 #endif /* DIRECT_THREADED */
2871
2872 insn_invokespecial:
2873 {
2874 int index = GET2U ();
2875
2876 rmeth = (_Jv_Linker::resolve_pool_entry (meth->defining_class,
2877 index)).rmethod;
2878
2879 sp -= rmeth->stack_item_count;
2880
2881 // We don't use NULLCHECK here because we can't rely on that
2882 // working for <init>. So instead we do an explicit test.
2883 if (! sp[0].o)
2884 {
2885 SAVE_PC();
2886 throw new java::lang::NullPointerException;
2887 }
2888
2889 fun = (void (*)()) rmeth->method->ncode;
2890
2891 #ifdef DIRECT_THREADED
2892 // Rewrite instruction so that we use a faster pre-resolved
2893 // method.
2894 pc[-2].insn = &&invokespecial_resolved;
2895 pc[-1].datum = rmeth;
2896 #endif /* DIRECT_THREADED */
2897 }
2898 goto perform_invoke;
2899
2900 #ifdef DIRECT_THREADED
2901 invokespecial_resolved:
2902 {
2903 rmeth = (_Jv_ResolvedMethod *) AVAL ();
2904 sp -= rmeth->stack_item_count;
2905 // We don't use NULLCHECK here because we can't rely on that
2906 // working for <init>. So instead we do an explicit test.
2907 if (! sp[0].o)
2908 {
2909 SAVE_PC();
2910 throw new java::lang::NullPointerException;
2911 }
2912 fun = (void (*)()) rmeth->method->ncode;
2913 }
2914 goto perform_invoke;
2915 #endif /* DIRECT_THREADED */
2916
2917 insn_invokestatic:
2918 {
2919 int index = GET2U ();
2920
2921 rmeth = (_Jv_Linker::resolve_pool_entry (meth->defining_class,
2922 index)).rmethod;
2923
2924 sp -= rmeth->stack_item_count;
2925
2926 fun = (void (*)()) rmeth->method->ncode;
2927
2928 #ifdef DIRECT_THREADED
2929 // Rewrite instruction so that we use a faster pre-resolved
2930 // method.
2931 pc[-2].insn = &&invokestatic_resolved;
2932 pc[-1].datum = rmeth;
2933 #endif /* DIRECT_THREADED */
2934 }
2935 goto perform_invoke;
2936
2937 #ifdef DIRECT_THREADED
2938 invokestatic_resolved:
2939 {
2940 rmeth = (_Jv_ResolvedMethod *) AVAL ();
2941 sp -= rmeth->stack_item_count;
2942 fun = (void (*)()) rmeth->method->ncode;
2943 }
2944 goto perform_invoke;
2945 #endif /* DIRECT_THREADED */
2946
2947 insn_invokeinterface:
2948 {
2949 int index = GET2U ();
2950
2951 rmeth = (_Jv_Linker::resolve_pool_entry (meth->defining_class,
2952 index)).rmethod;
2953
2954 sp -= rmeth->stack_item_count;
2955
2956 jobject rcv = sp[0].o;
2957
2958 NULLCHECK (rcv);
2959
2960 fun = (void (*)())
2961 _Jv_LookupInterfaceMethod (rcv->getClass (),
2962 rmeth->method->name,
2963 rmeth->method->signature);
2964
2965 #ifdef DIRECT_THREADED
2966 // Rewrite instruction so that we use a faster pre-resolved
2967 // method.
2968 pc[-2].insn = &&invokeinterface_resolved;
2969 pc[-1].datum = rmeth;
2970 #else
2971 // Skip dummy bytes.
2972 pc += 2;
2973 #endif /* DIRECT_THREADED */
2974 }
2975 goto perform_invoke;
2976
2977 #ifdef DIRECT_THREADED
2978 invokeinterface_resolved:
2979 {
2980 rmeth = (_Jv_ResolvedMethod *) AVAL ();
2981 sp -= rmeth->stack_item_count;
2982 jobject rcv = sp[0].o;
2983 NULLCHECK (rcv);
2984 fun = (void (*)())
2985 _Jv_LookupInterfaceMethod (rcv->getClass (),
2986 rmeth->method->name,
2987 rmeth->method->signature);
2988 }
2989 goto perform_invoke;
2990 #endif /* DIRECT_THREADED */
2991
2992 insn_new:
2993 {
2994 int index = GET2U ();
2995 jclass klass = (_Jv_Linker::resolve_pool_entry (meth->defining_class,
2996 index)).clazz;
2997 /* VM spec, section 3.11.5 */
2998 if ((klass->getModifiers() & Modifier::ABSTRACT)
2999 || klass->isInterface())
3000 throw new java::lang::InstantiationException;
3001 jobject res = _Jv_AllocObject (klass);
3002 PUSHA (res);
3003
3004 #ifdef DIRECT_THREADED
3005 pc[-2].insn = &&new_resolved;
3006 pc[-1].datum = klass;
3007 #endif /* DIRECT_THREADED */
3008 }
3009 NEXT_INSN;
3010
3011 #ifdef DIRECT_THREADED
3012 new_resolved:
3013 {
3014 jclass klass = (jclass) AVAL ();
3015 jobject res = _Jv_AllocObject (klass);
3016 PUSHA (res);
3017 }
3018 NEXT_INSN;
3019 #endif /* DIRECT_THREADED */
3020
3021 insn_newarray:
3022 {
3023 int atype = GET1U ();
3024 int size = POPI();
3025 jobject result = _Jv_NewArray (atype, size);
3026 PUSHA (result);
3027 }
3028 NEXT_INSN;
3029
3030 insn_anewarray:
3031 {
3032 int index = GET2U ();
3033 jclass klass = (_Jv_Linker::resolve_pool_entry (meth->defining_class,
3034 index)).clazz;
3035 int size = POPI();
3036 jobject result = _Jv_NewObjectArray (size, klass, 0);
3037 PUSHA (result);
3038
3039 #ifdef DIRECT_THREADED
3040 pc[-2].insn = &&anewarray_resolved;
3041 pc[-1].datum = klass;
3042 #endif /* DIRECT_THREADED */
3043 }
3044 NEXT_INSN;
3045
3046 #ifdef DIRECT_THREADED
3047 anewarray_resolved:
3048 {
3049 jclass klass = (jclass) AVAL ();
3050 int size = POPI ();
3051 jobject result = _Jv_NewObjectArray (size, klass, 0);
3052 PUSHA (result);
3053 }
3054 NEXT_INSN;
3055 #endif /* DIRECT_THREADED */
3056
3057 insn_arraylength:
3058 {
3059 __JArray *arr = (__JArray*)POPA();
3060 NULLARRAYCHECK (arr);
3061 PUSHI (arr->length);
3062 }
3063 NEXT_INSN;
3064
3065 insn_athrow:
3066 {
3067 jobject value = POPA();
3068 throw static_cast<jthrowable>(value);
3069 }
3070 NEXT_INSN;
3071
3072 insn_checkcast:
3073 {
3074 SAVE_PC();
3075 jobject value = POPA();
3076 jint index = GET2U ();
3077 jclass to = (_Jv_Linker::resolve_pool_entry (meth->defining_class,
3078 index)).clazz;
3079
3080 value = (jobject) _Jv_CheckCast (to, value);
3081
3082 PUSHA (value);
3083
3084 #ifdef DIRECT_THREADED
3085 pc[-2].insn = &&checkcast_resolved;
3086 pc[-1].datum = to;
3087 #endif /* DIRECT_THREADED */
3088 }
3089 NEXT_INSN;
3090
3091 #ifdef DIRECT_THREADED
3092 checkcast_resolved:
3093 {
3094 SAVE_PC();
3095 jobject value = POPA ();
3096 jclass to = (jclass) AVAL ();
3097 value = (jobject) _Jv_CheckCast (to, value);
3098 PUSHA (value);
3099 }
3100 NEXT_INSN;
3101 #endif /* DIRECT_THREADED */
3102
3103 insn_instanceof:
3104 {
3105 SAVE_PC();
3106 jobject value = POPA();
3107 jint index = GET2U ();
3108 jclass to = (_Jv_Linker::resolve_pool_entry (meth->defining_class,
3109 index)).clazz;
3110 PUSHI (to->isInstance (value));
3111
3112 #ifdef DIRECT_THREADED
3113 pc[-2].insn = &&instanceof_resolved;
3114 pc[-1].datum = to;
3115 #endif /* DIRECT_THREADED */
3116 }
3117 NEXT_INSN;
3118
3119 #ifdef DIRECT_THREADED
3120 instanceof_resolved:
3121 {
3122 jobject value = POPA ();
3123 jclass to = (jclass) AVAL ();
3124 PUSHI (to->isInstance (value));
3125 }
3126 NEXT_INSN;
3127 #endif /* DIRECT_THREADED */
3128
3129 insn_monitorenter:
3130 {
3131 jobject value = POPA();
3132 NULLCHECK(value);
3133 _Jv_MonitorEnter (value);
3134 }
3135 NEXT_INSN;
3136
3137 insn_monitorexit:
3138 {
3139 jobject value = POPA();
3140 NULLCHECK(value);
3141 _Jv_MonitorExit (value);
3142 }
3143 NEXT_INSN;
3144
3145 insn_ifnull:
3146 {
3147 jobject val = POPA();
3148 if (val == NULL)
3149 TAKE_GOTO;
3150 else
3151 SKIP_GOTO;
3152 }
3153 NEXT_INSN;
3154
3155 insn_ifnonnull:
3156 {
3157 jobject val = POPA();
3158 if (val != NULL)
3159 TAKE_GOTO;
3160 else
3161 SKIP_GOTO;
3162 }
3163 NEXT_INSN;
3164
3165 insn_multianewarray:
3166 {
3167 int kind_index = GET2U ();
3168 int dim = GET1U ();
3169
3170 jclass type
3171 = (_Jv_Linker::resolve_pool_entry (meth->defining_class,
3172 kind_index)).clazz;
3173 jint *sizes = (jint*) __builtin_alloca (sizeof (jint)*dim);
3174
3175 for (int i = dim - 1; i >= 0; i--)
3176 {
3177 sizes[i] = POPI ();
3178 }
3179
3180 jobject res = _Jv_NewMultiArray (type,dim, sizes);
3181
3182 PUSHA (res);
3183 }
3184 NEXT_INSN;
3185
3186 #ifndef DIRECT_THREADED
3187 insn_wide:
3188 {
3189 jint the_mod_op = get1u (pc++);
3190 jint wide = get2u (pc); pc += 2;
3191
3192 switch (the_mod_op)
3193 {
3194 case op_istore:
3195 STOREI (wide);
3196 NEXT_INSN;
3197
3198 case op_fstore:
3199 STOREF (wide);
3200 NEXT_INSN;
3201
3202 case op_astore:
3203 STOREA (wide);
3204 NEXT_INSN;
3205
3206 case op_lload:
3207 LOADL (wide);
3208 NEXT_INSN;
3209
3210 case op_dload:
3211 LOADD (wide);
3212 NEXT_INSN;
3213
3214 case op_iload:
3215 LOADI (wide);
3216 NEXT_INSN;
3217
3218 case op_fload:
3219 LOADF (wide);
3220 NEXT_INSN;
3221
3222 case op_aload:
3223 LOADA (wide);
3224 NEXT_INSN;
3225
3226 case op_lstore:
3227 STOREL (wide);
3228 NEXT_INSN;
3229
3230 case op_dstore:
3231 STORED (wide);
3232 NEXT_INSN;
3233
3234 case op_ret:
3235 pc = (unsigned char*) PEEKA (wide);
3236 NEXT_INSN;
3237
3238 case op_iinc:
3239 {
3240 jint amount = get2s (pc); pc += 2;
3241 jint value = PEEKI (wide);
3242 POKEI (wide, value+amount);
3243 }
3244 NEXT_INSN;
3245
3246 default:
3247 throw_internal_error ("illegal bytecode modified by wide");
3248 }
3249
3250 }
3251 #endif /* DIRECT_THREADED */
3252 }
3253 catch (java::lang::Throwable *ex)
3254 {
3255 #ifdef DIRECT_THREADED
3256 void *logical_pc = (void *) ((insn_slot *) pc - 1);
3257 #else
3258 int logical_pc = pc - 1 - bytecode ();
3259 #endif
3260 _Jv_InterpException *exc = meth->exceptions ();
3261 jclass exc_class = ex->getClass ();
3262
3263 for (int i = 0; i < meth->exc_count; i++)
3264 {
3265 if (PCVAL (exc[i].start_pc) <= logical_pc
3266 && logical_pc < PCVAL (exc[i].end_pc))
3267 {
3268 #ifdef DIRECT_THREADED
3269 jclass handler = (jclass) exc[i].handler_type.p;
3270 #else
3271 jclass handler = NULL;
3272 if (exc[i].handler_type.i != 0)
3273 handler = (_Jv_Linker::resolve_pool_entry (defining_class,
3274 exc[i].handler_type.i)).clazz;
3275 #endif /* DIRECT_THREADED */
3276
3277 if (handler == NULL || handler->isAssignableFrom (exc_class))
3278 {
3279 #ifdef DIRECT_THREADED
3280 pc = (insn_slot *) exc[i].handler_pc.p;
3281 #else
3282 pc = bytecode () + exc[i].handler_pc.i;
3283 #endif /* DIRECT_THREADED */
3284 sp = stack;
3285 sp++->o = ex; // Push exception.
3286 NEXT_INSN;
3287 }
3288 }
3289 }
3290
3291 // No handler, so re-throw.
3292 throw ex;
3293 }
3294 }
3295
3296 static void
3297 throw_internal_error (char *msg)
3298 {
3299 throw new java::lang::InternalError (JvNewStringLatin1 (msg));
3300 }
3301
3302 static void
3303 throw_incompatible_class_change_error (jstring msg)
3304 {
3305 throw new java::lang::IncompatibleClassChangeError (msg);
3306 }
3307
3308 #ifndef HANDLE_SEGV
3309 static java::lang::NullPointerException *null_pointer_exc;
3310 static void
3311 throw_null_pointer_exception ()
3312 {
3313 if (null_pointer_exc == NULL)
3314 null_pointer_exc = new java::lang::NullPointerException;
3315
3316 throw null_pointer_exc;
3317 }
3318 #endif
3319
3320 /* Look up source code line number for given bytecode (or direct threaded
3321 interpreter) PC. */
3322 int
3323 _Jv_InterpMethod::get_source_line(pc_t mpc)
3324 {
3325 int line = line_table_len > 0 ? line_table[0].line : -1;
3326 for (int i = 1; i < line_table_len; i++)
3327 if (line_table[i].pc > mpc)
3328 break;
3329 else
3330 line = line_table[i].line;
3331
3332 return line;
3333 }
3334
3335 /** Do static initialization for fields with a constant initializer */
3336 void
3337 _Jv_InitField (jobject obj, jclass klass, int index)
3338 {
3339 using namespace java::lang::reflect;
3340
3341 if (obj != 0 && klass == 0)
3342 klass = obj->getClass ();
3343
3344 if (!_Jv_IsInterpretedClass (klass))
3345 return;
3346
3347 _Jv_InterpClass *iclass = (_Jv_InterpClass*)klass->aux_info;
3348
3349 _Jv_Field * field = (&klass->fields[0]) + index;
3350
3351 if (index > klass->field_count)
3352 throw_internal_error ("field out of range");
3353
3354 int init = iclass->field_initializers[index];
3355 if (init == 0)
3356 return;
3357
3358 _Jv_Constants *pool = &klass->constants;
3359 int tag = pool->tags[init];
3360
3361 if (! field->isResolved ())
3362 throw_internal_error ("initializing unresolved field");
3363
3364 if (obj==0 && ((field->flags & Modifier::STATIC) == 0))
3365 throw_internal_error ("initializing non-static field with no object");
3366
3367 void *addr = 0;
3368
3369 if ((field->flags & Modifier::STATIC) != 0)
3370 addr = (void*) field->u.addr;
3371 else
3372 addr = (void*) (((char*)obj) + field->u.boffset);
3373
3374 switch (tag)
3375 {
3376 case JV_CONSTANT_String:
3377 {
3378 jstring str;
3379 str = _Jv_NewStringUtf8Const (pool->data[init].utf8);
3380 pool->data[init].string = str;
3381 pool->tags[init] = JV_CONSTANT_ResolvedString;
3382 }
3383 /* fall through */
3384
3385 case JV_CONSTANT_ResolvedString:
3386 if (! (field->type == &java::lang::String::class$
3387 || field->type == &java::lang::Class::class$))
3388 throw_class_format_error ("string initialiser to non-string field");
3389
3390 *(jstring*)addr = pool->data[init].string;
3391 break;
3392
3393 case JV_CONSTANT_Integer:
3394 {
3395 int value = pool->data[init].i;
3396
3397 if (field->type == JvPrimClass (boolean))
3398 *(jboolean*)addr = (jboolean)value;
3399
3400 else if (field->type == JvPrimClass (byte))
3401 *(jbyte*)addr = (jbyte)value;
3402
3403 else if (field->type == JvPrimClass (char))
3404 *(jchar*)addr = (jchar)value;
3405
3406 else if (field->type == JvPrimClass (short))
3407 *(jshort*)addr = (jshort)value;
3408
3409 else if (field->type == JvPrimClass (int))
3410 *(jint*)addr = (jint)value;
3411
3412 else
3413 throw_class_format_error ("erroneous field initializer");
3414 }
3415 break;
3416
3417 case JV_CONSTANT_Long:
3418 if (field->type != JvPrimClass (long))
3419 throw_class_format_error ("erroneous field initializer");
3420
3421 *(jlong*)addr = _Jv_loadLong (&pool->data[init]);
3422 break;
3423
3424 case JV_CONSTANT_Float:
3425 if (field->type != JvPrimClass (float))
3426 throw_class_format_error ("erroneous field initializer");
3427
3428 *(jfloat*)addr = pool->data[init].f;
3429 break;
3430
3431 case JV_CONSTANT_Double:
3432 if (field->type != JvPrimClass (double))
3433 throw_class_format_error ("erroneous field initializer");
3434
3435 *(jdouble*)addr = _Jv_loadDouble (&pool->data[init]);
3436 break;
3437
3438 default:
3439 throw_class_format_error ("erroneous field initializer");
3440 }
3441 }
3442
3443 inline static unsigned char*
3444 skip_one_type (unsigned char* ptr)
3445 {
3446 int ch = *ptr++;
3447
3448 while (ch == '[')
3449 {
3450 ch = *ptr++;
3451 }
3452
3453 if (ch == 'L')
3454 {
3455 do { ch = *ptr++; } while (ch != ';');
3456 }
3457
3458 return ptr;
3459 }
3460
3461 static ffi_type*
3462 get_ffi_type_from_signature (unsigned char* ptr)
3463 {
3464 switch (*ptr)
3465 {
3466 case 'L':
3467 case '[':
3468 return &ffi_type_pointer;
3469 break;
3470
3471 case 'Z':
3472 // On some platforms a bool is a byte, on others an int.
3473 if (sizeof (jboolean) == sizeof (jbyte))
3474 return &ffi_type_sint8;
3475 else
3476 {
3477 JvAssert (sizeof (jbyte) == sizeof (jint));
3478 return &ffi_type_sint32;
3479 }
3480 break;
3481
3482 case 'B':
3483 return &ffi_type_sint8;
3484 break;
3485
3486 case 'C':
3487 return &ffi_type_uint16;
3488 break;
3489
3490 case 'S':
3491 return &ffi_type_sint16;
3492 break;
3493
3494 case 'I':
3495 return &ffi_type_sint32;
3496 break;
3497
3498 case 'J':
3499 return &ffi_type_sint64;
3500 break;
3501
3502 case 'F':
3503 return &ffi_type_float;
3504 break;
3505
3506 case 'D':
3507 return &ffi_type_double;
3508 break;
3509
3510 case 'V':
3511 return &ffi_type_void;
3512 break;
3513 }
3514
3515 throw_internal_error ("unknown type in signature");
3516 }
3517
3518 /* this function yields the number of actual arguments, that is, if the
3519 * function is non-static, then one is added to the number of elements
3520 * found in the signature */
3521
3522 int
3523 _Jv_count_arguments (_Jv_Utf8Const *signature,
3524 jboolean staticp)
3525 {
3526 unsigned char *ptr = (unsigned char*) signature->chars();
3527 int arg_count = staticp ? 0 : 1;
3528
3529 /* first, count number of arguments */
3530
3531 // skip '('
3532 ptr++;
3533
3534 // count args
3535 while (*ptr != ')')
3536 {
3537 ptr = skip_one_type (ptr);
3538 arg_count += 1;
3539 }
3540
3541 return arg_count;
3542 }
3543
3544 /* This beast will build a cif, given the signature. Memory for
3545 * the cif itself and for the argument types must be allocated by the
3546 * caller.
3547 */
3548
3549 static int
3550 init_cif (_Jv_Utf8Const* signature,
3551 int arg_count,
3552 jboolean staticp,
3553 ffi_cif *cif,
3554 ffi_type **arg_types,
3555 ffi_type **rtype_p)
3556 {
3557 unsigned char *ptr = (unsigned char*) signature->chars();
3558
3559 int arg_index = 0; // arg number
3560 int item_count = 0; // stack-item count
3561
3562 // setup receiver
3563 if (!staticp)
3564 {
3565 arg_types[arg_index++] = &ffi_type_pointer;
3566 item_count += 1;
3567 }
3568
3569 // skip '('
3570 ptr++;
3571
3572 // assign arg types
3573 while (*ptr != ')')
3574 {
3575 arg_types[arg_index++] = get_ffi_type_from_signature (ptr);
3576
3577 if (*ptr == 'J' || *ptr == 'D')
3578 item_count += 2;
3579 else
3580 item_count += 1;
3581
3582 ptr = skip_one_type (ptr);
3583 }
3584
3585 // skip ')'
3586 ptr++;
3587 ffi_type *rtype = get_ffi_type_from_signature (ptr);
3588
3589 ptr = skip_one_type (ptr);
3590 if (ptr != (unsigned char*)signature->chars() + signature->len())
3591 throw_internal_error ("did not find end of signature");
3592
3593 if (ffi_prep_cif (cif, FFI_DEFAULT_ABI,
3594 arg_count, rtype, arg_types) != FFI_OK)
3595 throw_internal_error ("ffi_prep_cif failed");
3596
3597 if (rtype_p != NULL)
3598 *rtype_p = rtype;
3599
3600 return item_count;
3601 }
3602
3603 #if FFI_NATIVE_RAW_API
3604 # define FFI_PREP_RAW_CLOSURE ffi_prep_raw_closure
3605 # define FFI_RAW_SIZE ffi_raw_size
3606 #else
3607 # define FFI_PREP_RAW_CLOSURE ffi_prep_java_raw_closure
3608 # define FFI_RAW_SIZE ffi_java_raw_size
3609 #endif
3610
3611 /* we put this one here, and not in interpret.cc because it
3612 * calls the utility routines _Jv_count_arguments
3613 * which are static to this module. The following struct defines the
3614 * layout we use for the stubs, it's only used in the ncode method. */
3615
3616 typedef struct {
3617 ffi_raw_closure closure;
3618 ffi_cif cif;
3619 ffi_type *arg_types[0];
3620 } ncode_closure;
3621
3622 typedef void (*ffi_closure_fun) (ffi_cif*,void*,ffi_raw*,void*);
3623
3624 void *
3625 _Jv_InterpMethod::ncode ()
3626 {
3627 using namespace java::lang::reflect;
3628
3629 if (self->ncode != 0)
3630 return self->ncode;
3631
3632 jboolean staticp = (self->accflags & Modifier::STATIC) != 0;
3633 int arg_count = _Jv_count_arguments (self->signature, staticp);
3634
3635 ncode_closure *closure =
3636 (ncode_closure*)_Jv_AllocBytes (sizeof (ncode_closure)
3637 + arg_count * sizeof (ffi_type*));
3638
3639 init_cif (self->signature,
3640 arg_count,
3641 staticp,
3642 &closure->cif,
3643 &closure->arg_types[0],
3644 NULL);
3645
3646 ffi_closure_fun fun;
3647
3648 args_raw_size = FFI_RAW_SIZE (&closure->cif);
3649
3650 JvAssert ((self->accflags & Modifier::NATIVE) == 0);
3651
3652 if ((self->accflags & Modifier::SYNCHRONIZED) != 0)
3653 {
3654 if (staticp)
3655 fun = (ffi_closure_fun)&_Jv_InterpMethod::run_synch_class;
3656 else
3657 fun = (ffi_closure_fun)&_Jv_InterpMethod::run_synch_object;
3658 }
3659 else
3660 {
3661 if (staticp)
3662 fun = (ffi_closure_fun)&_Jv_InterpMethod::run_class;
3663 else
3664 fun = (ffi_closure_fun)&_Jv_InterpMethod::run_normal;
3665 }
3666
3667 FFI_PREP_RAW_CLOSURE (&closure->closure,
3668 &closure->cif,
3669 fun,
3670 (void*)this);
3671
3672 self->ncode = (void*)closure;
3673 return self->ncode;
3674 }
3675
3676 #ifdef DIRECT_THREADED
3677 /* Find the index of the given insn in the array of insn slots
3678 for this method. Returns -1 if not found. */
3679 jlong
3680 _Jv_InterpMethod::insn_index (pc_t pc)
3681 {
3682 jlong left = 0;
3683 jlong right = number_insn_slots;
3684 insn_slot* slots = reinterpret_cast<insn_slot*> (prepared);
3685
3686 while (right >= 0)
3687 {
3688 jlong mid = (left + right) / 2;
3689 if (&slots[mid] == pc)
3690 return mid;
3691
3692 if (pc < &slots[mid])
3693 right = mid - 1;
3694 else
3695 left = mid + 1;
3696 }
3697
3698 return -1;
3699 }
3700 #endif // DIRECT_THREADED
3701
3702 void
3703 _Jv_InterpMethod::get_line_table (jlong& start, jlong& end,
3704 jintArray& line_numbers,
3705 jlongArray& code_indices)
3706 {
3707 #ifdef DIRECT_THREADED
3708 /* For the DIRECT_THREADED case, if the method has not yet been
3709 * compiled, the linetable will change to insn slots instead of
3710 * bytecode PCs. It is probably easiest, in this case, to simply
3711 * compile the method and guarantee that we are using insn
3712 * slots.
3713 */
3714 _Jv_CompileMethod (this);
3715
3716 if (line_table_len > 0)
3717 {
3718 start = 0;
3719 end = number_insn_slots;
3720 line_numbers = JvNewIntArray (line_table_len);
3721 code_indices = JvNewLongArray (line_table_len);
3722
3723 jint* lines = elements (line_numbers);
3724 jlong* indices = elements (code_indices);
3725 for (int i = 0; i < line_table_len; ++i)
3726 {
3727 lines[i] = line_table[i].line;
3728 indices[i] = insn_index (line_table[i].pc);
3729 }
3730 }
3731 #else // !DIRECT_THREADED
3732 if (line_table_len > 0)
3733 {
3734 start = 0;
3735 end = code_length;
3736 line_numbers = JvNewIntArray (line_table_len);
3737 code_indices = JvNewLongArray (line_table_len);
3738
3739 jint* lines = elements (line_numbers);
3740 jlong* indices = elements (code_indices);
3741 for (int i = 0; i < line_table_len; ++i)
3742 {
3743 lines[i] = line_table[i].line;
3744 indices[i] = (jlong) line_table[i].bytecode_pc;
3745 }
3746 }
3747 #endif // !DIRECT_THREADED
3748 }
3749
3750 void *
3751 _Jv_JNIMethod::ncode ()
3752 {
3753 using namespace java::lang::reflect;
3754
3755 if (self->ncode != 0)
3756 return self->ncode;
3757
3758 jboolean staticp = (self->accflags & Modifier::STATIC) != 0;
3759 int arg_count = _Jv_count_arguments (self->signature, staticp);
3760
3761 ncode_closure *closure =
3762 (ncode_closure*)_Jv_AllocBytes (sizeof (ncode_closure)
3763 + arg_count * sizeof (ffi_type*));
3764
3765 ffi_type *rtype;
3766 init_cif (self->signature,
3767 arg_count,
3768 staticp,
3769 &closure->cif,
3770 &closure->arg_types[0],
3771 &rtype);
3772
3773 ffi_closure_fun fun;
3774
3775 args_raw_size = FFI_RAW_SIZE (&closure->cif);
3776
3777 // Initialize the argument types and CIF that represent the actual
3778 // underlying JNI function.
3779 int extra_args = 1;
3780 if ((self->accflags & Modifier::STATIC))
3781 ++extra_args;
3782 jni_arg_types = (ffi_type **) _Jv_AllocBytes ((extra_args + arg_count)
3783 * sizeof (ffi_type *));
3784 int offset = 0;
3785 jni_arg_types[offset++] = &ffi_type_pointer;
3786 if ((self->accflags & Modifier::STATIC))
3787 jni_arg_types[offset++] = &ffi_type_pointer;
3788 memcpy (&jni_arg_types[offset], &closure->arg_types[0],
3789 arg_count * sizeof (ffi_type *));
3790
3791 if (ffi_prep_cif (&jni_cif, _Jv_platform_ffi_abi,
3792 extra_args + arg_count, rtype,
3793 jni_arg_types) != FFI_OK)
3794 throw_internal_error ("ffi_prep_cif failed for JNI function");
3795
3796 JvAssert ((self->accflags & Modifier::NATIVE) != 0);
3797
3798 // FIXME: for now we assume that all native methods for
3799 // interpreted code use JNI.
3800 fun = (ffi_closure_fun) &_Jv_JNIMethod::call;
3801
3802 FFI_PREP_RAW_CLOSURE (&closure->closure,
3803 &closure->cif,
3804 fun,
3805 (void*) this);
3806
3807 self->ncode = (void *) closure;
3808 return self->ncode;
3809 }
3810
3811 static void
3812 throw_class_format_error (jstring msg)
3813 {
3814 throw (msg
3815 ? new java::lang::ClassFormatError (msg)
3816 : new java::lang::ClassFormatError);
3817 }
3818
3819 static void
3820 throw_class_format_error (char *msg)
3821 {
3822 throw_class_format_error (JvNewStringLatin1 (msg));
3823 }
3824
3825 \f
3826
3827 void
3828 _Jv_InterpreterEngine::do_verify (jclass klass)
3829 {
3830 _Jv_InterpClass *iclass = (_Jv_InterpClass *) klass->aux_info;
3831 for (int i = 0; i < klass->method_count; i++)
3832 {
3833 using namespace java::lang::reflect;
3834 _Jv_MethodBase *imeth = iclass->interpreted_methods[i];
3835 _Jv_ushort accflags = klass->methods[i].accflags;
3836 if ((accflags & (Modifier::NATIVE | Modifier::ABSTRACT)) == 0)
3837 {
3838 _Jv_InterpMethod *im = reinterpret_cast<_Jv_InterpMethod *> (imeth);
3839 _Jv_VerifyMethod (im);
3840 }
3841 }
3842 }
3843
3844 void
3845 _Jv_InterpreterEngine::do_create_ncode (jclass klass)
3846 {
3847 _Jv_InterpClass *iclass = (_Jv_InterpClass *) klass->aux_info;
3848 for (int i = 0; i < klass->method_count; i++)
3849 {
3850 // Just skip abstract methods. This is particularly important
3851 // because we don't resize the interpreted_methods array when
3852 // miranda methods are added to it.
3853 if ((klass->methods[i].accflags
3854 & java::lang::reflect::Modifier::ABSTRACT)
3855 != 0)
3856 continue;
3857
3858 _Jv_MethodBase *imeth = iclass->interpreted_methods[i];
3859
3860 if ((klass->methods[i].accflags & java::lang::reflect::Modifier::NATIVE)
3861 != 0)
3862 {
3863 // You might think we could use a virtual `ncode' method in
3864 // the _Jv_MethodBase and unify the native and non-native
3865 // cases. Well, we can't, because we don't allocate these
3866 // objects using `new', and thus they don't get a vtable.
3867 _Jv_JNIMethod *jnim = reinterpret_cast<_Jv_JNIMethod *> (imeth);
3868 klass->methods[i].ncode = jnim->ncode ();
3869 }
3870 else if (imeth != 0) // it could be abstract
3871 {
3872 _Jv_InterpMethod *im = reinterpret_cast<_Jv_InterpMethod *> (imeth);
3873 klass->methods[i].ncode = im->ncode ();
3874 }
3875 }
3876 }
3877
3878 void
3879 _Jv_InterpreterEngine::do_allocate_static_fields (jclass klass,
3880 int pointer_size,
3881 int other_size)
3882 {
3883 _Jv_InterpClass *iclass = (_Jv_InterpClass *) klass->aux_info;
3884
3885 // Splitting the allocations here lets us scan reference fields and
3886 // avoid scanning non-reference fields.
3887 char *reference_fields = (char *) _Jv_AllocRawObj (pointer_size);
3888 char *non_reference_fields = (char *) _Jv_AllocBytes (other_size);
3889
3890 for (int i = 0; i < klass->field_count; i++)
3891 {
3892 _Jv_Field *field = &klass->fields[i];
3893
3894 if ((field->flags & java::lang::reflect::Modifier::STATIC) == 0)
3895 continue;
3896
3897 char *base = field->isRef() ? reference_fields : non_reference_fields;
3898 field->u.addr = base + field->u.boffset;
3899
3900 if (iclass->field_initializers[i] != 0)
3901 {
3902 _Jv_Linker::resolve_field (field, klass->loader);
3903 _Jv_InitField (0, klass, i);
3904 }
3905 }
3906
3907 // Now we don't need the field_initializers anymore, so let the
3908 // collector get rid of it.
3909 iclass->field_initializers = 0;
3910 }
3911
3912 _Jv_ResolvedMethod *
3913 _Jv_InterpreterEngine::do_resolve_method (_Jv_Method *method, jclass klass,
3914 jboolean staticp, jint vtable_index)
3915 {
3916 int arg_count = _Jv_count_arguments (method->signature, staticp);
3917
3918 _Jv_ResolvedMethod* result = (_Jv_ResolvedMethod*)
3919 _Jv_AllocBytes (sizeof (_Jv_ResolvedMethod)
3920 + arg_count*sizeof (ffi_type*));
3921
3922 result->stack_item_count
3923 = init_cif (method->signature,
3924 arg_count,
3925 staticp,
3926 &result->cif,
3927 &result->arg_types[0],
3928 NULL);
3929
3930 result->vtable_index = vtable_index;
3931 result->method = method;
3932 result->klass = klass;
3933
3934 return result;
3935 }
3936
3937 void
3938 _Jv_InterpreterEngine::do_post_miranda_hook (jclass klass)
3939 {
3940 _Jv_InterpClass *iclass = (_Jv_InterpClass *) klass->aux_info;
3941 for (int i = 0; i < klass->method_count; i++)
3942 {
3943 // Just skip abstract methods. This is particularly important
3944 // because we don't resize the interpreted_methods array when
3945 // miranda methods are added to it.
3946 if ((klass->methods[i].accflags
3947 & java::lang::reflect::Modifier::ABSTRACT)
3948 != 0)
3949 continue;
3950 // Miranda method additions mean that the `methods' array moves.
3951 // We cache a pointer into this array, so we have to update.
3952 iclass->interpreted_methods[i]->self = &klass->methods[i];
3953 }
3954 }
3955
3956 #ifdef DIRECT_THREADED
3957 void
3958 _Jv_CompileMethod (_Jv_InterpMethod* method)
3959 {
3960 if (method->prepared == NULL)
3961 _Jv_InterpMethod::run (NULL, NULL, method);
3962 }
3963 #endif // DIRECT_THREADED
3964
3965 #endif // INTERPRETER