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