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