source: trunk/src/gcc/libjava/interpret.cc@ 1533

Last change on this file since 1533 was 1392, checked in by bird, 21 years ago

This commit was generated by cvs2svn to compensate for changes in r1391,
which included commits to RCS files with non-trunk default branches.
  • Property cvs2svn:cvs-rev set to 1.1.1.2
  • Property svn:eol-style set to native
  • Property svn:executable set to *
File size: 64.0 KB
Line 
1// interpret.cc - Code for the interpreter
2
3/* Copyright (C) 1999, 2000, 2001, 2002 Free Software Foundation
4
5 This file is part of libgcj.
6
7This software is copyrighted work licensed under the terms of the
8Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
9details. */
10
11/* Author: Kresten Krab Thorup <krab@gnu.org> */
12
13#include <config.h>
14
15// Define this to get the direct-threaded interpreter. If undefined,
16// we revert to a basic bytecode interpreter. The former is faster
17// but uses more memory.
18#define DIRECT_THREADED
19
20#pragma implementation "java-interp.h"
21
22#include <jvm.h>
23#include <java-cpool.h>
24#include <java-interp.h>
25#include <java/lang/System.h>
26#include <java/lang/String.h>
27#include <java/lang/Integer.h>
28#include <java/lang/Long.h>
29#include <java/lang/StringBuffer.h>
30#include <java/lang/Class.h>
31#include <java/lang/reflect/Modifier.h>
32#include <java/lang/ClassCastException.h>
33#include <java/lang/VirtualMachineError.h>
34#include <java/lang/InternalError.h>
35#include <java/lang/NullPointerException.h>
36#include <java/lang/ArithmeticException.h>
37#include <java/lang/IncompatibleClassChangeError.h>
38#include <java/lang/Thread.h>
39#include <java-insns.h>
40#include <java-signal.h>
41
42#ifdef INTERPRETER
43
44#include <stdlib.h>
45
46using namespace gcj;
47
48static void throw_internal_error (char *msg)
49 __attribute__ ((__noreturn__));
50static void throw_incompatible_class_change_error (jstring msg)
51 __attribute__ ((__noreturn__));
52#ifndef HANDLE_SEGV
53static void throw_null_pointer_exception ()
54 __attribute__ ((__noreturn__));
55#endif
56
57extern "C" double __ieee754_fmod (double,double);
58
59// This represents a single slot in the "compiled" form of the
60// bytecode.
61union insn_slot
62{
63 // Address of code.
64 void *insn;
65 // An integer value used by an instruction.
66 jint int_val;
67 // A pointer value used by an instruction.
68 void *datum;
69};
70
71// The type of the PC depends on whether we're doing direct threading
72// or a more ordinary bytecode interpreter.
73#ifdef DIRECT_THREADED
74typedef insn_slot *pc_t;
75#else
76typedef unsigned char *pc_t;
77#endif
78
79static inline void dupx (_Jv_word *sp, int n, int x)
80{
81 // first "slide" n+x elements n to the right
82 int top = n-1;
83 for (int i = 0; i < n+x; i++)
84 {
85 sp[(top-i)] = sp[(top-i)-n];
86 }
87
88 // next, copy the n top elements, n+x down
89 for (int i = 0; i < n; i++)
90 {
91 sp[top-(n+x)-i] = sp[top-i];
92 }
93
94};
95
96// Used to convert from floating types to integral types.
97template<typename TO, typename FROM>
98static inline TO
99convert (FROM val, TO min, TO max)
100{
101 TO ret;
102 if (val >= (FROM) max)
103 ret = max;
104 else if (val <= (FROM) min)
105 ret = min;
106 else if (val != val)
107 ret = 0;
108 else
109 ret = (TO) val;
110 return ret;
111}
112
113#define PUSHA(V) (sp++)->o = (V)
114#define PUSHI(V) (sp++)->i = (V)
115#define PUSHF(V) (sp++)->f = (V)
116#if SIZEOF_VOID_P == 8
117# define PUSHL(V) (sp->l = (V), sp += 2)
118# define PUSHD(V) (sp->d = (V), sp += 2)
119#else
120# define PUSHL(V) do { _Jv_word2 w2; w2.l=(V); \
121 (sp++)->ia[0] = w2.ia[0]; \
122 (sp++)->ia[0] = w2.ia[1]; } while (0)
123# define PUSHD(V) do { _Jv_word2 w2; w2.d=(V); \
124 (sp++)->ia[0] = w2.ia[0]; \
125 (sp++)->ia[0] = w2.ia[1]; } while (0)
126#endif
127
128#define POPA() ((--sp)->o)
129#define POPI() ((jint) (--sp)->i) // cast since it may be promoted
130#define POPF() ((jfloat) (--sp)->f)
131#if SIZEOF_VOID_P == 8
132# define POPL() (sp -= 2, (jlong) sp->l)
133# define POPD() (sp -= 2, (jdouble) sp->d)
134#else
135# define POPL() ({ _Jv_word2 w2; \
136 w2.ia[1] = (--sp)->ia[0]; \
137 w2.ia[0] = (--sp)->ia[0]; w2.l; })
138# define POPD() ({ _Jv_word2 w2; \
139 w2.ia[1] = (--sp)->ia[0]; \
140 w2.ia[0] = (--sp)->ia[0]; w2.d; })
141#endif
142
143#define LOADA(I) (sp++)->o = locals[I].o
144#define LOADI(I) (sp++)->i = locals[I].i
145#define LOADF(I) (sp++)->f = locals[I].f
146#if SIZEOF_VOID_P == 8
147# define LOADL(I) (sp->l = locals[I].l, sp += 2)
148# define LOADD(I) (sp->d = locals[I].d, sp += 2)
149#else
150# define LOADL(I) do { jint __idx = (I); \
151 (sp++)->ia[0] = locals[__idx].ia[0]; \
152 (sp++)->ia[0] = locals[__idx+1].ia[0]; \
153 } while (0)
154# define LOADD(I) LOADL(I)
155#endif
156
157#define STOREA(I) locals[I].o = (--sp)->o
158#define STOREI(I) locals[I].i = (--sp)->i
159#define STOREF(I) locals[I].f = (--sp)->f
160#if SIZEOF_VOID_P == 8
161# define STOREL(I) (sp -= 2, locals[I].l = sp->l)
162# define STORED(I) (sp -= 2, locals[I].d = sp->d)
163#else
164# define STOREL(I) do { jint __idx = (I); \
165 locals[__idx+1].ia[0] = (--sp)->ia[0]; \
166 locals[__idx].ia[0] = (--sp)->ia[0]; \
167 } while (0)
168# define STORED(I) STOREL(I)
169#endif
170
171#define PEEKI(I) (locals+(I))->i
172#define PEEKA(I) (locals+(I))->o
173
174#define POKEI(I,V) ((locals+(I))->i = (V))
175
176
177#define BINOPI(OP) { \
178 jint value2 = POPI(); \
179 jint value1 = POPI(); \
180 PUSHI(value1 OP value2); \
181}
182
183#define BINOPF(OP) { \
184 jfloat value2 = POPF(); \
185 jfloat value1 = POPF(); \
186 PUSHF(value1 OP value2); \
187}
188
189#define BINOPL(OP) { \
190 jlong value2 = POPL(); \
191 jlong value1 = POPL(); \
192 PUSHL(value1 OP value2); \
193}
194
195#define BINOPD(OP) { \
196 jdouble value2 = POPD(); \
197 jdouble value1 = POPD(); \
198 PUSHD(value1 OP value2); \
199}
200
201static inline jint get1s(unsigned char* loc) {
202 return *(signed char*)loc;
203}
204
205static inline jint get1u(unsigned char* loc) {
206 return *loc;
207}
208
209static inline jint get2s(unsigned char* loc) {
210 return (((jint)*(signed char*)loc) << 8) | ((jint)*(loc+1));
211}
212
213static inline jint get2u(unsigned char* loc) {
214 return (((jint)(*loc)) << 8) | ((jint)*(loc+1));
215}
216
217static jint get4(unsigned char* loc) {
218 return (((jint)(loc[0])) << 24)
219 | (((jint)(loc[1])) << 16)
220 | (((jint)(loc[2])) << 8)
221 | (((jint)(loc[3])) << 0);
222}
223
224
225#ifdef HANDLE_SEGV
226#define NULLCHECK(X)
227#define NULLARRAYCHECK(X)
228#else
229#define NULLCHECK(X) \
230 do { if ((X)==NULL) throw_null_pointer_exception (); } while (0)
231#define NULLARRAYCHECK(X) \
232 do { if ((X)==NULL) { throw_null_pointer_exception (); } } while (0)
233#endif
234
235#define ARRAYBOUNDSCHECK(array, index) \
236 do \
237 { \
238 if (((unsigned) index) >= (unsigned) (array->length)) \
239 _Jv_ThrowBadArrayIndex (index); \
240 } \
241 while (0)
242
243void _Jv_InterpMethod::run_normal (ffi_cif *,
244 void* ret,
245 ffi_raw * args,
246 void* __this)
247{
248 _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this;
249 _this->run (ret, args);
250}
251
252void _Jv_InterpMethod::run_synch_object (ffi_cif *,
253 void* ret,
254 ffi_raw * args,
255 void* __this)
256{
257 _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this;
258
259 jobject rcv = (jobject) args[0].ptr;
260 JvSynchronize mutex (rcv);
261
262 _this->run (ret, args);
263}
264
265void _Jv_InterpMethod::run_synch_class (ffi_cif *,
266 void* ret,
267 ffi_raw * args,
268 void* __this)
269{
270 _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this;
271
272 jclass sync = _this->defining_class;
273 JvSynchronize mutex (sync);
274
275 _this->run (ret, args);
276}
277
278#ifdef DIRECT_THREADED
279// "Compile" a method by turning it from bytecode to direct-threaded
280// code.
281void
282_Jv_InterpMethod::compile (const void * const *insn_targets)
283{
284 insn_slot *insns = NULL;
285 int next = 0;
286 unsigned char *codestart = bytecode ();
287 unsigned char *end = codestart + code_length;
288 _Jv_word *pool_data = defining_class->constants.data;
289
290#define SET_ONE(Field, Value) \
291 do \
292 { \
293 if (first_pass) \
294 ++next; \
295 else \
296 insns[next++].Field = Value; \
297 } \
298 while (0)
299
300#define SET_INSN(Value) SET_ONE (insn, (void *) Value)
301#define SET_INT(Value) SET_ONE (int_val, Value)
302#define SET_DATUM(Value) SET_ONE (datum, Value)
303
304 // Map from bytecode PC to slot in INSNS.
305 int *pc_mapping = (int *) __builtin_alloca (sizeof (int) * code_length);
306 for (int i = 0; i < code_length; ++i)
307 pc_mapping[i] = -1;
308
309 for (int i = 0; i < 2; ++i)
310 {
311 jboolean first_pass = i == 0;
312
313 if (! first_pass)
314 {
315 insns = (insn_slot *) _Jv_AllocBytes (sizeof (insn_slot) * next);
316 next = 0;
317 }
318
319 unsigned char *pc = codestart;
320 while (pc < end)
321 {
322 int base_pc_val = pc - codestart;
323 if (first_pass)
324 pc_mapping[base_pc_val] = next;
325
326 java_opcode opcode = (java_opcode) *pc++;
327 // Just elide NOPs.
328 if (opcode == op_nop)
329 continue;
330 SET_INSN (insn_targets[opcode]);
331
332 switch (opcode)
333 {
334 case op_nop:
335 case op_aconst_null:
336 case op_iconst_m1:
337 case op_iconst_0:
338 case op_iconst_1:
339 case op_iconst_2:
340 case op_iconst_3:
341 case op_iconst_4:
342 case op_iconst_5:
343 case op_lconst_0:
344 case op_lconst_1:
345 case op_fconst_0:
346 case op_fconst_1:
347 case op_fconst_2:
348 case op_dconst_0:
349 case op_dconst_1:
350 case op_iload_0:
351 case op_iload_1:
352 case op_iload_2:
353 case op_iload_3:
354 case op_lload_0:
355 case op_lload_1:
356 case op_lload_2:
357 case op_lload_3:
358 case op_fload_0:
359 case op_fload_1:
360 case op_fload_2:
361 case op_fload_3:
362 case op_dload_0:
363 case op_dload_1:
364 case op_dload_2:
365 case op_dload_3:
366 case op_aload_0:
367 case op_aload_1:
368 case op_aload_2:
369 case op_aload_3:
370 case op_iaload:
371 case op_laload:
372 case op_faload:
373 case op_daload:
374 case op_aaload:
375 case op_baload:
376 case op_caload:
377 case op_saload:
378 case op_istore_0:
379 case op_istore_1:
380 case op_istore_2:
381 case op_istore_3:
382 case op_lstore_0:
383 case op_lstore_1:
384 case op_lstore_2:
385 case op_lstore_3:
386 case op_fstore_0:
387 case op_fstore_1:
388 case op_fstore_2:
389 case op_fstore_3:
390 case op_dstore_0:
391 case op_dstore_1:
392 case op_dstore_2:
393 case op_dstore_3:
394 case op_astore_0:
395 case op_astore_1:
396 case op_astore_2:
397 case op_astore_3:
398 case op_iastore:
399 case op_lastore:
400 case op_fastore:
401 case op_dastore:
402 case op_aastore:
403 case op_bastore:
404 case op_castore:
405 case op_sastore:
406 case op_pop:
407 case op_pop2:
408 case op_dup:
409 case op_dup_x1:
410 case op_dup_x2:
411 case op_dup2:
412 case op_dup2_x1:
413 case op_dup2_x2:
414 case op_swap:
415 case op_iadd:
416 case op_isub:
417 case op_imul:
418 case op_idiv:
419 case op_irem:
420 case op_ishl:
421 case op_ishr:
422 case op_iushr:
423 case op_iand:
424 case op_ior:
425 case op_ixor:
426 case op_ladd:
427 case op_lsub:
428 case op_lmul:
429 case op_ldiv:
430 case op_lrem:
431 case op_lshl:
432 case op_lshr:
433 case op_lushr:
434 case op_land:
435 case op_lor:
436 case op_lxor:
437 case op_fadd:
438 case op_fsub:
439 case op_fmul:
440 case op_fdiv:
441 case op_frem:
442 case op_dadd:
443 case op_dsub:
444 case op_dmul:
445 case op_ddiv:
446 case op_drem:
447 case op_ineg:
448 case op_i2b:
449 case op_i2c:
450 case op_i2s:
451 case op_lneg:
452 case op_fneg:
453 case op_dneg:
454 case op_i2l:
455 case op_i2f:
456 case op_i2d:
457 case op_l2i:
458 case op_l2f:
459 case op_l2d:
460 case op_f2i:
461 case op_f2l:
462 case op_f2d:
463 case op_d2i:
464 case op_d2l:
465 case op_d2f:
466 case op_lcmp:
467 case op_fcmpl:
468 case op_fcmpg:
469 case op_dcmpl:
470 case op_dcmpg:
471 case op_monitorenter:
472 case op_monitorexit:
473 case op_ireturn:
474 case op_lreturn:
475 case op_freturn:
476 case op_dreturn:
477 case op_areturn:
478 case op_return:
479 case op_athrow:
480 case op_arraylength:
481 // No argument, nothing else to do.
482 break;
483
484 case op_bipush:
485 SET_INT (get1s (pc));
486 ++pc;
487 break;
488
489 case op_ldc:
490 {
491 int index = get1u (pc);
492 ++pc;
493 SET_DATUM (pool_data[index].o);
494 }
495 break;
496
497 case op_ret:
498 case op_iload:
499 case op_lload:
500 case op_fload:
501 case op_dload:
502 case op_aload:
503 case op_istore:
504 case op_lstore:
505 case op_fstore:
506 case op_dstore:
507 case op_astore:
508 case op_newarray:
509 SET_INT (get1u (pc));
510 ++pc;
511 break;
512
513 case op_iinc:
514 SET_INT (get1u (pc));
515 SET_INT (get1s (pc + 1));
516 pc += 2;
517 break;
518
519 case op_ldc_w:
520 {
521 int index = get2u (pc);
522 pc += 2;
523 SET_DATUM (pool_data[index].o);
524 }
525 break;
526
527 case op_ldc2_w:
528 {
529 int index = get2u (pc);
530 pc += 2;
531 SET_DATUM (&pool_data[index]);
532 }
533 break;
534
535 case op_sipush:
536 SET_INT (get2s (pc));
537 pc += 2;
538 break;
539
540 case op_new:
541 case op_getstatic:
542 case op_getfield:
543 case op_putfield:
544 case op_putstatic:
545 case op_anewarray:
546 case op_instanceof:
547 case op_checkcast:
548 case op_invokespecial:
549 case op_invokestatic:
550 case op_invokevirtual:
551 SET_INT (get2u (pc));
552 pc += 2;
553 break;
554
555 case op_multianewarray:
556 SET_INT (get2u (pc));
557 SET_INT (get1u (pc + 2));
558 pc += 3;
559 break;
560
561 case op_jsr:
562 case op_ifeq:
563 case op_ifne:
564 case op_iflt:
565 case op_ifge:
566 case op_ifgt:
567 case op_ifle:
568 case op_if_icmpeq:
569 case op_if_icmpne:
570 case op_if_icmplt:
571 case op_if_icmpge:
572 case op_if_icmpgt:
573 case op_if_icmple:
574 case op_if_acmpeq:
575 case op_if_acmpne:
576 case op_ifnull:
577 case op_ifnonnull:
578 case op_goto:
579 {
580 int offset = get2s (pc);
581 pc += 2;
582
583 int new_pc = base_pc_val + offset;
584
585 bool orig_was_goto = opcode == op_goto;
586
587 // Thread jumps. We limit the loop count; this lets
588 // us avoid infinite loops if the bytecode contains
589 // such. `10' is arbitrary.
590 int count = 10;
591 while (codestart[new_pc] == op_goto && count-- > 0)
592 new_pc += get2s (&codestart[new_pc + 1]);
593
594 // If the jump takes us to a `return' instruction and
595 // the original branch was an unconditional goto, then
596 // we hoist the return.
597 opcode = (java_opcode) codestart[new_pc];
598 if (orig_was_goto
599 && (opcode == op_ireturn || opcode == op_lreturn
600 || opcode == op_freturn || opcode == op_dreturn
601 || opcode == op_areturn || opcode == op_return))
602 {
603 --next;
604 SET_INSN (insn_targets[opcode]);
605 }
606 else
607 SET_DATUM (&insns[pc_mapping[new_pc]]);
608 }
609 break;
610
611 case op_tableswitch:
612 {
613 while ((pc - codestart) % 4 != 0)
614 ++pc;
615
616 jint def = get4 (pc);
617 SET_DATUM (&insns[pc_mapping[base_pc_val + def]]);
618 pc += 4;
619
620 int low = get4 (pc);
621 SET_INT (low);
622 pc += 4;
623 int high = get4 (pc);
624 SET_INT (high);
625 pc += 4;
626
627 for (int i = low; i <= high; ++i)
628 {
629 SET_DATUM (&insns[pc_mapping[base_pc_val + get4 (pc)]]);
630 pc += 4;
631 }
632 }
633 break;
634
635 case op_lookupswitch:
636 {
637 while ((pc - codestart) % 4 != 0)
638 ++pc;
639
640 jint def = get4 (pc);
641 SET_DATUM (&insns[pc_mapping[base_pc_val + def]]);
642 pc += 4;
643
644 jint npairs = get4 (pc);
645 pc += 4;
646 SET_INT (npairs);
647
648 while (npairs-- > 0)
649 {
650 jint match = get4 (pc);
651 jint offset = get4 (pc + 4);
652 SET_INT (match);
653 SET_DATUM (&insns[pc_mapping[base_pc_val + offset]]);
654 pc += 8;
655 }
656 }
657 break;
658
659 case op_invokeinterface:
660 {
661 jint index = get2u (pc);
662 pc += 2;
663 // We ignore the next two bytes.
664 pc += 2;
665 SET_INT (index);
666 }
667 break;
668
669 case op_wide:
670 {
671 opcode = (java_opcode) get1u (pc);
672 pc += 1;
673 jint val = get2u (pc);
674 pc += 2;
675
676 // We implement narrow and wide instructions using the
677 // same code in the interpreter. So we rewrite the
678 // instruction slot here.
679 if (! first_pass)
680 insns[next - 1].insn = (void *) insn_targets[opcode];
681 SET_INT (val);
682
683 if (opcode == op_iinc)
684 {
685 SET_INT (get2s (pc));
686 pc += 2;
687 }
688 }
689 break;
690
691 case op_jsr_w:
692 case op_goto_w:
693 {
694 jint offset = get4 (pc);
695 pc += 4;
696 SET_DATUM (&insns[pc_mapping[base_pc_val + offset]]);
697 }
698 break;
699
700 // Some "can't happen" cases that we include for
701 // error-checking purposes.
702 case op_putfield_1:
703 case op_putfield_2:
704 case op_putfield_4:
705 case op_putfield_8:
706 case op_putfield_a:
707 case op_putstatic_1:
708 case op_putstatic_2:
709 case op_putstatic_4:
710 case op_putstatic_8:
711 case op_putstatic_a:
712 case op_getfield_1:
713 case op_getfield_2s:
714 case op_getfield_2u:
715 case op_getfield_4:
716 case op_getfield_8:
717 case op_getfield_a:
718 case op_getstatic_1:
719 case op_getstatic_2s:
720 case op_getstatic_2u:
721 case op_getstatic_4:
722 case op_getstatic_8:
723 case op_getstatic_a:
724 default:
725 // Fail somehow.
726 break;
727 }
728 }
729 }
730
731 // Now update exceptions.
732 _Jv_InterpException *exc = exceptions ();
733 for (int i = 0; i < exc_count; ++i)
734 {
735 exc[i].start_pc.p = &insns[pc_mapping[exc[i].start_pc.i]];
736 exc[i].end_pc.p = &insns[pc_mapping[exc[i].end_pc.i]];
737 exc[i].handler_pc.p = &insns[pc_mapping[exc[i].handler_pc.i]];
738 jclass handler = (_Jv_ResolvePoolEntry (defining_class,
739 exc[i].handler_type.i)).clazz;
740 exc[i].handler_type.p = handler;
741 }
742
743 prepared = insns;
744}
745#endif /* DIRECT_THREADED */
746
747// This function exists so that the stack-tracing code can find the
748// boundaries of the interpreter.
749void
750_Jv_StartOfInterpreter (void)
751{
752}
753
754void
755_Jv_InterpMethod::run (void *retp, ffi_raw *args)
756{
757 using namespace java::lang::reflect;
758
759 // FRAME_DESC registers this particular invocation as the top-most
760 // interpreter frame. This lets the stack tracing code (for
761 // Throwable) print information about the method being interpreted
762 // rather than about the interpreter itself. FRAME_DESC has a
763 // destructor so it cleans up automatically when the interpreter
764 // returns.
765 java::lang::Thread *thread = java::lang::Thread::currentThread();
766 _Jv_MethodChain frame_desc (this,
767 (_Jv_MethodChain **) &thread->interp_frame);
768
769 _Jv_word stack[max_stack];
770 _Jv_word *sp = stack;
771
772 _Jv_word locals[max_locals];
773
774 /* Go straight at it! the ffi raw format matches the internal
775 stack representation exactly. At least, that's the idea.
776 */
777 memcpy ((void*) locals, (void*) args, args_raw_size);
778
779 _Jv_word *pool_data = defining_class->constants.data;
780
781 /* These three are temporaries for common code used by several
782 instructions. */
783 void (*fun)();
784 _Jv_ResolvedMethod* rmeth;
785 int tmpval;
786
787#define INSN_LABEL(op) &&insn_##op
788
789 static const void *const insn_target[] =
790 {
791 INSN_LABEL(nop),
792 INSN_LABEL(aconst_null),
793 INSN_LABEL(iconst_m1),
794 INSN_LABEL(iconst_0),
795 INSN_LABEL(iconst_1),
796 INSN_LABEL(iconst_2),
797 INSN_LABEL(iconst_3),
798 INSN_LABEL(iconst_4),
799 INSN_LABEL(iconst_5),
800 INSN_LABEL(lconst_0),
801 INSN_LABEL(lconst_1),
802 INSN_LABEL(fconst_0),
803 INSN_LABEL(fconst_1),
804 INSN_LABEL(fconst_2),
805 INSN_LABEL(dconst_0),
806 INSN_LABEL(dconst_1),
807 INSN_LABEL(bipush),
808 INSN_LABEL(sipush),
809 INSN_LABEL(ldc),
810 INSN_LABEL(ldc_w),
811 INSN_LABEL(ldc2_w),
812 INSN_LABEL(iload),
813 INSN_LABEL(lload),
814 INSN_LABEL(fload),
815 INSN_LABEL(dload),
816 INSN_LABEL(aload),
817 INSN_LABEL(iload_0),
818 INSN_LABEL(iload_1),
819 INSN_LABEL(iload_2),
820 INSN_LABEL(iload_3),
821 INSN_LABEL(lload_0),
822 INSN_LABEL(lload_1),
823 INSN_LABEL(lload_2),
824 INSN_LABEL(lload_3),
825 INSN_LABEL(fload_0),
826 INSN_LABEL(fload_1),
827 INSN_LABEL(fload_2),
828 INSN_LABEL(fload_3),
829 INSN_LABEL(dload_0),
830 INSN_LABEL(dload_1),
831 INSN_LABEL(dload_2),
832 INSN_LABEL(dload_3),
833 INSN_LABEL(aload_0),
834 INSN_LABEL(aload_1),
835 INSN_LABEL(aload_2),
836 INSN_LABEL(aload_3),
837 INSN_LABEL(iaload),
838 INSN_LABEL(laload),
839 INSN_LABEL(faload),
840 INSN_LABEL(daload),
841 INSN_LABEL(aaload),
842 INSN_LABEL(baload),
843 INSN_LABEL(caload),
844 INSN_LABEL(saload),
845 INSN_LABEL(istore),
846 INSN_LABEL(lstore),
847 INSN_LABEL(fstore),
848 INSN_LABEL(dstore),
849 INSN_LABEL(astore),
850 INSN_LABEL(istore_0),
851 INSN_LABEL(istore_1),
852 INSN_LABEL(istore_2),
853 INSN_LABEL(istore_3),
854 INSN_LABEL(lstore_0),
855 INSN_LABEL(lstore_1),
856 INSN_LABEL(lstore_2),
857 INSN_LABEL(lstore_3),
858 INSN_LABEL(fstore_0),
859 INSN_LABEL(fstore_1),
860 INSN_LABEL(fstore_2),
861 INSN_LABEL(fstore_3),
862 INSN_LABEL(dstore_0),
863 INSN_LABEL(dstore_1),
864 INSN_LABEL(dstore_2),
865 INSN_LABEL(dstore_3),
866 INSN_LABEL(astore_0),
867 INSN_LABEL(astore_1),
868 INSN_LABEL(astore_2),
869 INSN_LABEL(astore_3),
870 INSN_LABEL(iastore),
871 INSN_LABEL(lastore),
872 INSN_LABEL(fastore),
873 INSN_LABEL(dastore),
874 INSN_LABEL(aastore),
875 INSN_LABEL(bastore),
876 INSN_LABEL(castore),
877 INSN_LABEL(sastore),
878 INSN_LABEL(pop),
879 INSN_LABEL(pop2),
880 INSN_LABEL(dup),
881 INSN_LABEL(dup_x1),
882 INSN_LABEL(dup_x2),
883 INSN_LABEL(dup2),
884 INSN_LABEL(dup2_x1),
885 INSN_LABEL(dup2_x2),
886 INSN_LABEL(swap),
887 INSN_LABEL(iadd),
888 INSN_LABEL(ladd),
889 INSN_LABEL(fadd),
890 INSN_LABEL(dadd),
891 INSN_LABEL(isub),
892 INSN_LABEL(lsub),
893 INSN_LABEL(fsub),
894 INSN_LABEL(dsub),
895 INSN_LABEL(imul),
896 INSN_LABEL(lmul),
897 INSN_LABEL(fmul),
898 INSN_LABEL(dmul),
899 INSN_LABEL(idiv),
900 INSN_LABEL(ldiv),
901 INSN_LABEL(fdiv),
902 INSN_LABEL(ddiv),
903 INSN_LABEL(irem),
904 INSN_LABEL(lrem),
905 INSN_LABEL(frem),
906 INSN_LABEL(drem),
907 INSN_LABEL(ineg),
908 INSN_LABEL(lneg),
909 INSN_LABEL(fneg),
910 INSN_LABEL(dneg),
911 INSN_LABEL(ishl),
912 INSN_LABEL(lshl),
913 INSN_LABEL(ishr),
914 INSN_LABEL(lshr),
915 INSN_LABEL(iushr),
916 INSN_LABEL(lushr),
917 INSN_LABEL(iand),
918 INSN_LABEL(land),
919 INSN_LABEL(ior),
920 INSN_LABEL(lor),
921 INSN_LABEL(ixor),
922 INSN_LABEL(lxor),
923 INSN_LABEL(iinc),
924 INSN_LABEL(i2l),
925 INSN_LABEL(i2f),
926 INSN_LABEL(i2d),
927 INSN_LABEL(l2i),
928 INSN_LABEL(l2f),
929 INSN_LABEL(l2d),
930 INSN_LABEL(f2i),
931 INSN_LABEL(f2l),
932 INSN_LABEL(f2d),
933 INSN_LABEL(d2i),
934 INSN_LABEL(d2l),
935 INSN_LABEL(d2f),
936 INSN_LABEL(i2b),
937 INSN_LABEL(i2c),
938 INSN_LABEL(i2s),
939 INSN_LABEL(lcmp),
940 INSN_LABEL(fcmpl),
941 INSN_LABEL(fcmpg),
942 INSN_LABEL(dcmpl),
943 INSN_LABEL(dcmpg),
944 INSN_LABEL(ifeq),
945 INSN_LABEL(ifne),
946 INSN_LABEL(iflt),
947 INSN_LABEL(ifge),
948 INSN_LABEL(ifgt),
949 INSN_LABEL(ifle),
950 INSN_LABEL(if_icmpeq),
951 INSN_LABEL(if_icmpne),
952 INSN_LABEL(if_icmplt),
953 INSN_LABEL(if_icmpge),
954 INSN_LABEL(if_icmpgt),
955 INSN_LABEL(if_icmple),
956 INSN_LABEL(if_acmpeq),
957 INSN_LABEL(if_acmpne),
958 INSN_LABEL(goto),
959 INSN_LABEL(jsr),
960 INSN_LABEL(ret),
961 INSN_LABEL(tableswitch),
962 INSN_LABEL(lookupswitch),
963 INSN_LABEL(ireturn),
964 INSN_LABEL(lreturn),
965 INSN_LABEL(freturn),
966 INSN_LABEL(dreturn),
967 INSN_LABEL(areturn),
968 INSN_LABEL(return),
969 INSN_LABEL(getstatic),
970 INSN_LABEL(putstatic),
971 INSN_LABEL(getfield),
972 INSN_LABEL(putfield),
973 INSN_LABEL(invokevirtual),
974 INSN_LABEL(invokespecial),
975 INSN_LABEL(invokestatic),
976 INSN_LABEL(invokeinterface),
977 0, /* Unused. */
978 INSN_LABEL(new),
979 INSN_LABEL(newarray),
980 INSN_LABEL(anewarray),
981 INSN_LABEL(arraylength),
982 INSN_LABEL(athrow),
983 INSN_LABEL(checkcast),
984 INSN_LABEL(instanceof),
985 INSN_LABEL(monitorenter),
986 INSN_LABEL(monitorexit),
987#ifdef DIRECT_THREADED
988 0, // wide
989#else
990 INSN_LABEL(wide),
991#endif
992 INSN_LABEL(multianewarray),
993 INSN_LABEL(ifnull),
994 INSN_LABEL(ifnonnull),
995 INSN_LABEL(goto_w),
996 INSN_LABEL(jsr_w),
997 0
998 };
999
1000 pc_t pc;
1001
1002#ifdef DIRECT_THREADED
1003
1004#define NEXT_INSN goto *((pc++)->insn)
1005#define INTVAL() ((pc++)->int_val)
1006#define AVAL() ((pc++)->datum)
1007
1008#define GET1S() INTVAL ()
1009#define GET2S() INTVAL ()
1010#define GET1U() INTVAL ()
1011#define GET2U() INTVAL ()
1012#define AVAL1U() AVAL ()
1013#define AVAL2U() AVAL ()
1014#define AVAL2UP() AVAL ()
1015#define SKIP_GOTO ++pc
1016#define GOTO_VAL() (insn_slot *) pc->datum
1017#define PCVAL(unionval) unionval.p
1018#define AMPAMP(label) &&label
1019
1020 // Compile if we must.
1021 if (prepared == NULL)
1022 compile (insn_target);
1023 pc = (insn_slot *) prepared;
1024
1025#else
1026
1027#define NEXT_INSN goto *(insn_target[*pc++])
1028
1029#define GET1S() get1s (pc++)
1030#define GET2S() (pc += 2, get2s (pc- 2))
1031#define GET1U() get1u (pc++)
1032#define GET2U() (pc += 2, get2u (pc - 2))
1033#define AVAL1U() ({ int index = get1u (pc++); pool_data[index].o; })
1034#define AVAL2U() ({ int index = get2u (pc); pc += 2; pool_data[index].o; })
1035#define AVAL2UP() ({ int index = get2u (pc); pc += 2; &pool_data[index]; })
1036#define SKIP_GOTO pc += 2
1037#define GOTO_VAL() pc - 1 + get2s (pc)
1038#define PCVAL(unionval) unionval.i
1039#define AMPAMP(label) NULL
1040
1041 pc = bytecode ();
1042
1043#endif /* DIRECT_THREADED */
1044
1045#define TAKE_GOTO pc = GOTO_VAL ()
1046
1047 try
1048 {
1049 // We keep nop around. It is used if we're interpreting the
1050 // bytecodes and not doing direct threading.
1051 insn_nop:
1052 NEXT_INSN;
1053
1054 /* The first few instructions here are ordered according to their
1055 frequency, in the hope that this will improve code locality a
1056 little. */
1057
1058 insn_aload_0: // 0x2a
1059 LOADA (0);
1060 NEXT_INSN;
1061
1062 insn_iload: // 0x15
1063 LOADI (GET1U ());
1064 NEXT_INSN;
1065
1066 insn_iload_1: // 0x1b
1067 LOADI (1);
1068 NEXT_INSN;
1069
1070 insn_invokevirtual: // 0xb6
1071 {
1072 int index = GET2U ();
1073
1074 /* _Jv_ResolvePoolEntry returns immediately if the value already
1075 * is resolved. If we want to clutter up the code here to gain
1076 * a little performance, then we can check the corresponding bit
1077 * JV_CONSTANT_ResolvedFlag in the tag directly. For now, I
1078 * don't think it is worth it. */
1079
1080 rmeth = (_Jv_ResolvePoolEntry (defining_class, index)).rmethod;
1081
1082 sp -= rmeth->stack_item_count;
1083 // We don't use NULLCHECK here because we can't rely on that
1084 // working if the method is final. So instead we do an
1085 // explicit test.
1086 if (! sp[0].o)
1087 throw new java::lang::NullPointerException;
1088
1089 if (rmeth->vtable_index == -1)
1090 {
1091 // final methods do not appear in the vtable,
1092 // if it does not appear in the superclass.
1093 fun = (void (*)()) rmeth->method->ncode;
1094 }
1095 else
1096 {
1097 jobject rcv = sp[0].o;
1098 _Jv_VTable *table = *(_Jv_VTable**) rcv;
1099 fun = (void (*)()) table->get_method (rmeth->vtable_index);
1100 }
1101
1102#ifdef DIRECT_THREADED
1103 // Rewrite instruction so that we use a faster pre-resolved
1104 // method.
1105 pc[-2].insn = &&invokevirtual_resolved;
1106 pc[-1].datum = rmeth;
1107#endif /* DIRECT_THREADED */
1108 }
1109 goto perform_invoke;
1110
1111#ifdef DIRECT_THREADED
1112 invokevirtual_resolved:
1113 {
1114 rmeth = (_Jv_ResolvedMethod *) AVAL ();
1115 sp -= rmeth->stack_item_count;
1116 // We don't use NULLCHECK here because we can't rely on that
1117 // working if the method is final. So instead we do an
1118 // explicit test.
1119 if (! sp[0].o)
1120 throw new java::lang::NullPointerException;
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 goto perform_invoke;
1136#endif /* DIRECT_THREADED */
1137
1138 perform_invoke:
1139 {
1140 /* here goes the magic again... */
1141 ffi_cif *cif = &rmeth->cif;
1142 ffi_raw *raw = (ffi_raw*) sp;
1143
1144 jdouble rvalue;
1145
1146#if FFI_NATIVE_RAW_API
1147 /* We assume that this is only implemented if it's correct */
1148 /* to use it here. On a 64 bit machine, it never is. */
1149 ffi_raw_call (cif, fun, (void*)&rvalue, raw);
1150#else
1151 ffi_java_raw_call (cif, fun, (void*)&rvalue, raw);
1152#endif
1153
1154 int rtype = cif->rtype->type;
1155
1156 /* the likelyhood of object, int, or void return is very high,
1157 * so those are checked before the switch */
1158 if (rtype == FFI_TYPE_POINTER)
1159 {
1160 PUSHA (*(jobject*)&rvalue);
1161 }
1162 else if (rtype == FFI_TYPE_SINT32)
1163 {
1164 PUSHI (*(jint*)&rvalue);
1165 }
1166 else if (rtype == FFI_TYPE_VOID)
1167 {
1168 /* skip */
1169 }
1170 else
1171 {
1172 switch (rtype)
1173 {
1174 case FFI_TYPE_SINT8:
1175 {
1176 jbyte value = (*(jint*)&rvalue) & 0xff;
1177 PUSHI (value);
1178 }
1179 break;
1180
1181 case FFI_TYPE_SINT16:
1182 {
1183 jshort value = (*(jint*)&rvalue) & 0xffff;
1184 PUSHI (value);
1185 }
1186 break;
1187
1188 case FFI_TYPE_UINT16:
1189 {
1190 jint value = (*(jint*)&rvalue) & 0xffff;
1191 PUSHI (value);
1192 }
1193 break;
1194
1195 case FFI_TYPE_FLOAT:
1196 PUSHF (*(jfloat*)&rvalue);
1197 break;
1198
1199 case FFI_TYPE_DOUBLE:
1200 PUSHD (rvalue);
1201 break;
1202
1203 case FFI_TYPE_SINT64:
1204 PUSHL (*(jlong*)&rvalue);
1205 break;
1206
1207 default:
1208 throw_internal_error ("unknown return type in invokeXXX");
1209 }
1210 }
1211 }
1212 NEXT_INSN;
1213
1214 insn_aconst_null:
1215 PUSHA (NULL);
1216 NEXT_INSN;
1217
1218 insn_iconst_m1:
1219 PUSHI (-1);
1220 NEXT_INSN;
1221
1222 insn_iconst_0:
1223 PUSHI (0);
1224 NEXT_INSN;
1225
1226 insn_iconst_1:
1227 PUSHI (1);
1228 NEXT_INSN;
1229
1230 insn_iconst_2:
1231 PUSHI (2);
1232 NEXT_INSN;
1233
1234 insn_iconst_3:
1235 PUSHI (3);
1236 NEXT_INSN;
1237
1238 insn_iconst_4:
1239 PUSHI (4);
1240 NEXT_INSN;
1241
1242 insn_iconst_5:
1243 PUSHI (5);
1244 NEXT_INSN;
1245
1246 insn_lconst_0:
1247 PUSHL (0);
1248 NEXT_INSN;
1249
1250 insn_lconst_1:
1251 PUSHL (1);
1252 NEXT_INSN;
1253
1254 insn_fconst_0:
1255 PUSHF (0);
1256 NEXT_INSN;
1257
1258 insn_fconst_1:
1259 PUSHF (1);
1260 NEXT_INSN;
1261
1262 insn_fconst_2:
1263 PUSHF (2);
1264 NEXT_INSN;
1265
1266 insn_dconst_0:
1267 PUSHD (0);
1268 NEXT_INSN;
1269
1270 insn_dconst_1:
1271 PUSHD (1);
1272 NEXT_INSN;
1273
1274 insn_bipush:
1275 // For direct threaded, bipush and sipush are the same.
1276#ifndef DIRECT_THREADED
1277 PUSHI (GET1S ());
1278 NEXT_INSN;
1279#endif /* DIRECT_THREADED */
1280 insn_sipush:
1281 PUSHI (GET2S ());
1282 NEXT_INSN;
1283
1284 insn_ldc:
1285 // For direct threaded, ldc and ldc_w are the same.
1286#ifndef DIRECT_THREADED
1287 PUSHA ((jobject) AVAL1U ());
1288 NEXT_INSN;
1289#endif /* DIRECT_THREADED */
1290 insn_ldc_w:
1291 PUSHA ((jobject) AVAL2U ());
1292 NEXT_INSN;
1293
1294 insn_ldc2_w:
1295 {
1296 void *where = AVAL2UP ();
1297 memcpy (sp, where, 2*sizeof (_Jv_word));
1298 sp += 2;
1299 }
1300 NEXT_INSN;
1301
1302 insn_lload:
1303 LOADL (GET1U ());
1304 NEXT_INSN;
1305
1306 insn_fload:
1307 LOADF (GET1U ());
1308 NEXT_INSN;
1309
1310 insn_dload:
1311 LOADD (GET1U ());
1312 NEXT_INSN;
1313
1314 insn_aload:
1315 LOADA (GET1U ());
1316 NEXT_INSN;
1317
1318 insn_iload_0:
1319 LOADI (0);
1320 NEXT_INSN;
1321
1322 insn_iload_2:
1323 LOADI (2);
1324 NEXT_INSN;
1325
1326 insn_iload_3:
1327 LOADI (3);
1328 NEXT_INSN;
1329
1330 insn_lload_0:
1331 LOADL (0);
1332 NEXT_INSN;
1333
1334 insn_lload_1:
1335 LOADL (1);
1336 NEXT_INSN;
1337
1338 insn_lload_2:
1339 LOADL (2);
1340 NEXT_INSN;
1341
1342 insn_lload_3:
1343 LOADL (3);
1344 NEXT_INSN;
1345
1346 insn_fload_0:
1347 LOADF (0);
1348 NEXT_INSN;
1349
1350 insn_fload_1:
1351 LOADF (1);
1352 NEXT_INSN;
1353
1354 insn_fload_2:
1355 LOADF (2);
1356 NEXT_INSN;
1357
1358 insn_fload_3:
1359 LOADF (3);
1360 NEXT_INSN;
1361
1362 insn_dload_0:
1363 LOADD (0);
1364 NEXT_INSN;
1365
1366 insn_dload_1:
1367 LOADD (1);
1368 NEXT_INSN;
1369
1370 insn_dload_2:
1371 LOADD (2);
1372 NEXT_INSN;
1373
1374 insn_dload_3:
1375 LOADD (3);
1376 NEXT_INSN;
1377
1378 insn_aload_1:
1379 LOADA(1);
1380 NEXT_INSN;
1381
1382 insn_aload_2:
1383 LOADA(2);
1384 NEXT_INSN;
1385
1386 insn_aload_3:
1387 LOADA(3);
1388 NEXT_INSN;
1389
1390 insn_iaload:
1391 {
1392 jint index = POPI();
1393 jintArray arr = (jintArray) POPA();
1394 NULLARRAYCHECK (arr);
1395 ARRAYBOUNDSCHECK (arr, index);
1396 PUSHI( elements(arr)[index] );
1397 }
1398 NEXT_INSN;
1399
1400 insn_laload:
1401 {
1402 jint index = POPI();
1403 jlongArray arr = (jlongArray) POPA();
1404 NULLARRAYCHECK (arr);
1405 ARRAYBOUNDSCHECK (arr, index);
1406 PUSHL( elements(arr)[index] );
1407 }
1408 NEXT_INSN;
1409
1410 insn_faload:
1411 {
1412 jint index = POPI();
1413 jfloatArray arr = (jfloatArray) POPA();
1414 NULLARRAYCHECK (arr);
1415 ARRAYBOUNDSCHECK (arr, index);
1416 PUSHF( elements(arr)[index] );
1417 }
1418 NEXT_INSN;
1419
1420 insn_daload:
1421 {
1422 jint index = POPI();
1423 jdoubleArray arr = (jdoubleArray) POPA();
1424 NULLARRAYCHECK (arr);
1425 ARRAYBOUNDSCHECK (arr, index);
1426 PUSHD( elements(arr)[index] );
1427 }
1428 NEXT_INSN;
1429
1430 insn_aaload:
1431 {
1432 jint index = POPI();
1433 jobjectArray arr = (jobjectArray) POPA();
1434 NULLARRAYCHECK (arr);
1435 ARRAYBOUNDSCHECK (arr, index);
1436 PUSHA( elements(arr)[index] );
1437 }
1438 NEXT_INSN;
1439
1440 insn_baload:
1441 {
1442 jint index = POPI();
1443 jbyteArray arr = (jbyteArray) POPA();
1444 NULLARRAYCHECK (arr);
1445 ARRAYBOUNDSCHECK (arr, index);
1446 PUSHI( elements(arr)[index] );
1447 }
1448 NEXT_INSN;
1449
1450 insn_caload:
1451 {
1452 jint index = POPI();
1453 jcharArray arr = (jcharArray) POPA();
1454 NULLARRAYCHECK (arr);
1455 ARRAYBOUNDSCHECK (arr, index);
1456 PUSHI( elements(arr)[index] );
1457 }
1458 NEXT_INSN;
1459
1460 insn_saload:
1461 {
1462 jint index = POPI();
1463 jshortArray arr = (jshortArray) POPA();
1464 NULLARRAYCHECK (arr);
1465 ARRAYBOUNDSCHECK (arr, index);
1466 PUSHI( elements(arr)[index] );
1467 }
1468 NEXT_INSN;
1469
1470 insn_istore:
1471 STOREI (GET1U ());
1472 NEXT_INSN;
1473
1474 insn_lstore:
1475 STOREL (GET1U ());
1476 NEXT_INSN;
1477
1478 insn_fstore:
1479 STOREF (GET1U ());
1480 NEXT_INSN;
1481
1482 insn_dstore:
1483 STORED (GET1U ());
1484 NEXT_INSN;
1485
1486 insn_astore:
1487 STOREA (GET1U ());
1488 NEXT_INSN;
1489
1490 insn_istore_0:
1491 STOREI (0);
1492 NEXT_INSN;
1493
1494 insn_istore_1:
1495 STOREI (1);
1496 NEXT_INSN;
1497
1498 insn_istore_2:
1499 STOREI (2);
1500 NEXT_INSN;
1501
1502 insn_istore_3:
1503 STOREI (3);
1504 NEXT_INSN;
1505
1506 insn_lstore_0:
1507 STOREL (0);
1508 NEXT_INSN;
1509
1510 insn_lstore_1:
1511 STOREL (1);
1512 NEXT_INSN;
1513
1514 insn_lstore_2:
1515 STOREL (2);
1516 NEXT_INSN;
1517
1518 insn_lstore_3:
1519 STOREL (3);
1520 NEXT_INSN;
1521
1522 insn_fstore_0:
1523 STOREF (0);
1524 NEXT_INSN;
1525
1526 insn_fstore_1:
1527 STOREF (1);
1528 NEXT_INSN;
1529
1530 insn_fstore_2:
1531 STOREF (2);
1532 NEXT_INSN;
1533
1534 insn_fstore_3:
1535 STOREF (3);
1536 NEXT_INSN;
1537
1538 insn_dstore_0:
1539 STORED (0);
1540 NEXT_INSN;
1541
1542 insn_dstore_1:
1543 STORED (1);
1544 NEXT_INSN;
1545
1546 insn_dstore_2:
1547 STORED (2);
1548 NEXT_INSN;
1549
1550 insn_dstore_3:
1551 STORED (3);
1552 NEXT_INSN;
1553
1554 insn_astore_0:
1555 STOREA(0);
1556 NEXT_INSN;
1557
1558 insn_astore_1:
1559 STOREA(1);
1560 NEXT_INSN;
1561
1562 insn_astore_2:
1563 STOREA(2);
1564 NEXT_INSN;
1565
1566 insn_astore_3:
1567 STOREA(3);
1568 NEXT_INSN;
1569
1570 insn_iastore:
1571 {
1572 jint value = POPI();
1573 jint index = POPI();
1574 jintArray arr = (jintArray) POPA();
1575 NULLARRAYCHECK (arr);
1576 ARRAYBOUNDSCHECK (arr, index);
1577 elements(arr)[index] = value;
1578 }
1579 NEXT_INSN;
1580
1581 insn_lastore:
1582 {
1583 jlong value = POPL();
1584 jint index = POPI();
1585 jlongArray arr = (jlongArray) POPA();
1586 NULLARRAYCHECK (arr);
1587 ARRAYBOUNDSCHECK (arr, index);
1588 elements(arr)[index] = value;
1589 }
1590 NEXT_INSN;
1591
1592 insn_fastore:
1593 {
1594 jfloat value = POPF();
1595 jint index = POPI();
1596 jfloatArray arr = (jfloatArray) POPA();
1597 NULLARRAYCHECK (arr);
1598 ARRAYBOUNDSCHECK (arr, index);
1599 elements(arr)[index] = value;
1600 }
1601 NEXT_INSN;
1602
1603 insn_dastore:
1604 {
1605 jdouble value = POPD();
1606 jint index = POPI();
1607 jdoubleArray arr = (jdoubleArray) POPA();
1608 NULLARRAYCHECK (arr);
1609 ARRAYBOUNDSCHECK (arr, index);
1610 elements(arr)[index] = value;
1611 }
1612 NEXT_INSN;
1613
1614 insn_aastore:
1615 {
1616 jobject value = POPA();
1617 jint index = POPI();
1618 jobjectArray arr = (jobjectArray) POPA();
1619 NULLARRAYCHECK (arr);
1620 ARRAYBOUNDSCHECK (arr, index);
1621 _Jv_CheckArrayStore (arr, value);
1622 elements(arr)[index] = value;
1623 }
1624 NEXT_INSN;
1625
1626 insn_bastore:
1627 {
1628 jbyte value = (jbyte) POPI();
1629 jint index = POPI();
1630 jbyteArray arr = (jbyteArray) POPA();
1631 NULLARRAYCHECK (arr);
1632 ARRAYBOUNDSCHECK (arr, index);
1633 elements(arr)[index] = value;
1634 }
1635 NEXT_INSN;
1636
1637 insn_castore:
1638 {
1639 jchar value = (jchar) POPI();
1640 jint index = POPI();
1641 jcharArray arr = (jcharArray) POPA();
1642 NULLARRAYCHECK (arr);
1643 ARRAYBOUNDSCHECK (arr, index);
1644 elements(arr)[index] = value;
1645 }
1646 NEXT_INSN;
1647
1648 insn_sastore:
1649 {
1650 jshort value = (jshort) POPI();
1651 jint index = POPI();
1652 jshortArray arr = (jshortArray) POPA();
1653 NULLARRAYCHECK (arr);
1654 ARRAYBOUNDSCHECK (arr, index);
1655 elements(arr)[index] = value;
1656 }
1657 NEXT_INSN;
1658
1659 insn_pop:
1660 sp -= 1;
1661 NEXT_INSN;
1662
1663 insn_pop2:
1664 sp -= 2;
1665 NEXT_INSN;
1666
1667 insn_dup:
1668 sp[0] = sp[-1];
1669 sp += 1;
1670 NEXT_INSN;
1671
1672 insn_dup_x1:
1673 dupx (sp, 1, 1); sp+=1;
1674 NEXT_INSN;
1675
1676 insn_dup_x2:
1677 dupx (sp, 1, 2); sp+=1;
1678 NEXT_INSN;
1679
1680 insn_dup2:
1681 sp[0] = sp[-2];
1682 sp[1] = sp[-1];
1683 sp += 2;
1684 NEXT_INSN;
1685
1686 insn_dup2_x1:
1687 dupx (sp, 2, 1); sp+=2;
1688 NEXT_INSN;
1689
1690 insn_dup2_x2:
1691 dupx (sp, 2, 2); sp+=2;
1692 NEXT_INSN;
1693
1694 insn_swap:
1695 {
1696 jobject tmp1 = POPA();
1697 jobject tmp2 = POPA();
1698 PUSHA (tmp1);
1699 PUSHA (tmp2);
1700 }
1701 NEXT_INSN;
1702
1703 insn_iadd:
1704 BINOPI(+);
1705 NEXT_INSN;
1706
1707 insn_ladd:
1708 BINOPL(+);
1709 NEXT_INSN;
1710
1711 insn_fadd:
1712 BINOPF(+);
1713 NEXT_INSN;
1714
1715 insn_dadd:
1716 BINOPD(+);
1717 NEXT_INSN;
1718
1719 insn_isub:
1720 BINOPI(-);
1721 NEXT_INSN;
1722
1723 insn_lsub:
1724 BINOPL(-);
1725 NEXT_INSN;
1726
1727 insn_fsub:
1728 BINOPF(-);
1729 NEXT_INSN;
1730
1731 insn_dsub:
1732 BINOPD(-);
1733 NEXT_INSN;
1734
1735 insn_imul:
1736 BINOPI(*);
1737 NEXT_INSN;
1738
1739 insn_lmul:
1740 BINOPL(*);
1741 NEXT_INSN;
1742
1743 insn_fmul:
1744 BINOPF(*);
1745 NEXT_INSN;
1746
1747 insn_dmul:
1748 BINOPD(*);
1749 NEXT_INSN;
1750
1751 insn_idiv:
1752 {
1753 jint value2 = POPI();
1754 jint value1 = POPI();
1755 jint res = _Jv_divI (value1, value2);
1756 PUSHI (res);
1757 }
1758 NEXT_INSN;
1759
1760 insn_ldiv:
1761 {
1762 jlong value2 = POPL();
1763 jlong value1 = POPL();
1764 jlong res = _Jv_divJ (value1, value2);
1765 PUSHL (res);
1766 }
1767 NEXT_INSN;
1768
1769 insn_fdiv:
1770 {
1771 jfloat value2 = POPF();
1772 jfloat value1 = POPF();
1773 jfloat res = value1 / value2;
1774 PUSHF (res);
1775 }
1776 NEXT_INSN;
1777
1778 insn_ddiv:
1779 {
1780 jdouble value2 = POPD();
1781 jdouble value1 = POPD();
1782 jdouble res = value1 / value2;
1783 PUSHD (res);
1784 }
1785 NEXT_INSN;
1786
1787 insn_irem:
1788 {
1789 jint value2 = POPI();
1790 jint value1 = POPI();
1791 jint res = _Jv_remI (value1, value2);
1792 PUSHI (res);
1793 }
1794 NEXT_INSN;
1795
1796 insn_lrem:
1797 {
1798 jlong value2 = POPL();
1799 jlong value1 = POPL();
1800 jlong res = _Jv_remJ (value1, value2);
1801 PUSHL (res);
1802 }
1803 NEXT_INSN;
1804
1805 insn_frem:
1806 {
1807 jfloat value2 = POPF();
1808 jfloat value1 = POPF();
1809 jfloat res = __ieee754_fmod (value1, value2);
1810 PUSHF (res);
1811 }
1812 NEXT_INSN;
1813
1814 insn_drem:
1815 {
1816 jdouble value2 = POPD();
1817 jdouble value1 = POPD();
1818 jdouble res = __ieee754_fmod (value1, value2);
1819 PUSHD (res);
1820 }
1821 NEXT_INSN;
1822
1823 insn_ineg:
1824 {
1825 jint value = POPI();
1826 PUSHI (value * -1);
1827 }
1828 NEXT_INSN;
1829
1830 insn_lneg:
1831 {
1832 jlong value = POPL();
1833 PUSHL (value * -1);
1834 }
1835 NEXT_INSN;
1836
1837 insn_fneg:
1838 {
1839 jfloat value = POPF();
1840 PUSHF (value * -1);
1841 }
1842 NEXT_INSN;
1843
1844 insn_dneg:
1845 {
1846 jdouble value = POPD();
1847 PUSHD (value * -1);
1848 }
1849 NEXT_INSN;
1850
1851 insn_ishl:
1852 {
1853 jint shift = (POPI() & 0x1f);
1854 jint value = POPI();
1855 PUSHI (value << shift);
1856 }
1857 NEXT_INSN;
1858
1859 insn_lshl:
1860 {
1861 jint shift = (POPI() & 0x3f);
1862 jlong value = POPL();
1863 PUSHL (value << shift);
1864 }
1865 NEXT_INSN;
1866
1867 insn_ishr:
1868 {
1869 jint shift = (POPI() & 0x1f);
1870 jint value = POPI();
1871 PUSHI (value >> shift);
1872 }
1873 NEXT_INSN;
1874
1875 insn_lshr:
1876 {
1877 jint shift = (POPI() & 0x3f);
1878 jlong value = POPL();
1879 PUSHL (value >> shift);
1880 }
1881 NEXT_INSN;
1882
1883 insn_iushr:
1884 {
1885 jint shift = (POPI() & 0x1f);
1886 UINT32 value = (UINT32) POPI();
1887 PUSHI ((jint) (value >> shift));
1888 }
1889 NEXT_INSN;
1890
1891 insn_lushr:
1892 {
1893 jint shift = (POPI() & 0x3f);
1894 UINT64 value = (UINT64) POPL();
1895 PUSHL ((value >> shift));
1896 }
1897 NEXT_INSN;
1898
1899 insn_iand:
1900 BINOPI (&);
1901 NEXT_INSN;
1902
1903 insn_land:
1904 BINOPL (&);
1905 NEXT_INSN;
1906
1907 insn_ior:
1908 BINOPI (|);
1909 NEXT_INSN;
1910
1911 insn_lor:
1912 BINOPL (|);
1913 NEXT_INSN;
1914
1915 insn_ixor:
1916 BINOPI (^);
1917 NEXT_INSN;
1918
1919 insn_lxor:
1920 BINOPL (^);
1921 NEXT_INSN;
1922
1923 insn_iinc:
1924 {
1925 jint index = GET1U ();
1926 jint amount = GET1S ();
1927 locals[index].i += amount;
1928 }
1929 NEXT_INSN;
1930
1931 insn_i2l:
1932 {jlong value = POPI(); PUSHL (value);}
1933 NEXT_INSN;
1934
1935 insn_i2f:
1936 {jfloat value = POPI(); PUSHF (value);}
1937 NEXT_INSN;
1938
1939 insn_i2d:
1940 {jdouble value = POPI(); PUSHD (value);}
1941 NEXT_INSN;
1942
1943 insn_l2i:
1944 {jint value = POPL(); PUSHI (value);}
1945 NEXT_INSN;
1946
1947 insn_l2f:
1948 {jfloat value = POPL(); PUSHF (value);}
1949 NEXT_INSN;
1950
1951 insn_l2d:
1952 {jdouble value = POPL(); PUSHD (value);}
1953 NEXT_INSN;
1954
1955 insn_f2i:
1956 {
1957 using namespace java::lang;
1958 jint value = convert (POPF (), Integer::MIN_VALUE, Integer::MAX_VALUE);
1959 PUSHI(value);
1960 }
1961 NEXT_INSN;
1962
1963 insn_f2l:
1964 {
1965 using namespace java::lang;
1966 jlong value = convert (POPF (), Long::MIN_VALUE, Long::MAX_VALUE);
1967 PUSHL(value);
1968 }
1969 NEXT_INSN;
1970
1971 insn_f2d:
1972 { jdouble value = POPF (); PUSHD(value); }
1973 NEXT_INSN;
1974
1975 insn_d2i:
1976 {
1977 using namespace java::lang;
1978 jint value = convert (POPD (), Integer::MIN_VALUE, Integer::MAX_VALUE);
1979 PUSHI(value);
1980 }
1981 NEXT_INSN;
1982
1983 insn_d2l:
1984 {
1985 using namespace java::lang;
1986 jlong value = convert (POPD (), Long::MIN_VALUE, Long::MAX_VALUE);
1987 PUSHL(value);
1988 }
1989 NEXT_INSN;
1990
1991 insn_d2f:
1992 { jfloat value = POPD (); PUSHF(value); }
1993 NEXT_INSN;
1994
1995 insn_i2b:
1996 { jbyte value = POPI (); PUSHI(value); }
1997 NEXT_INSN;
1998
1999 insn_i2c:
2000 { jchar value = POPI (); PUSHI(value); }
2001 NEXT_INSN;
2002
2003 insn_i2s:
2004 { jshort value = POPI (); PUSHI(value); }
2005 NEXT_INSN;
2006
2007 insn_lcmp:
2008 {
2009 jlong value2 = POPL ();
2010 jlong value1 = POPL ();
2011 if (value1 > value2)
2012 { PUSHI (1); }
2013 else if (value1 == value2)
2014 { PUSHI (0); }
2015 else
2016 { PUSHI (-1); }
2017 }
2018 NEXT_INSN;
2019
2020 insn_fcmpl:
2021 tmpval = -1;
2022 goto fcmp;
2023
2024 insn_fcmpg:
2025 tmpval = 1;
2026
2027 fcmp:
2028 {
2029 jfloat value2 = POPF ();
2030 jfloat value1 = POPF ();
2031 if (value1 > value2)
2032 PUSHI (1);
2033 else if (value1 == value2)
2034 PUSHI (0);
2035 else if (value1 < value2)
2036 PUSHI (-1);
2037 else
2038 PUSHI (tmpval);
2039 }
2040 NEXT_INSN;
2041
2042 insn_dcmpl:
2043 tmpval = 1;
2044 goto dcmp;
2045
2046 insn_dcmpg:
2047 tmpval = -1;
2048
2049 dcmp:
2050 {
2051 jdouble value2 = POPD ();
2052 jdouble value1 = POPD ();
2053 if (value1 > value2)
2054 PUSHI (1);
2055 else if (value1 == value2)
2056 PUSHI (0);
2057 else if (value1 < value2)
2058 PUSHI (-1);
2059 else
2060 PUSHI (tmpval);
2061 }
2062 NEXT_INSN;
2063
2064 insn_ifeq:
2065 {
2066 if (POPI() == 0)
2067 TAKE_GOTO;
2068 else
2069 SKIP_GOTO;
2070 }
2071 NEXT_INSN;
2072
2073 insn_ifne:
2074 {
2075 if (POPI() != 0)
2076 TAKE_GOTO;
2077 else
2078 SKIP_GOTO;
2079 }
2080 NEXT_INSN;
2081
2082 insn_iflt:
2083 {
2084 if (POPI() < 0)
2085 TAKE_GOTO;
2086 else
2087 SKIP_GOTO;
2088 }
2089 NEXT_INSN;
2090
2091 insn_ifge:
2092 {
2093 if (POPI() >= 0)
2094 TAKE_GOTO;
2095 else
2096 SKIP_GOTO;
2097 }
2098 NEXT_INSN;
2099
2100 insn_ifgt:
2101 {
2102 if (POPI() > 0)
2103 TAKE_GOTO;
2104 else
2105 SKIP_GOTO;
2106 }
2107 NEXT_INSN;
2108
2109 insn_ifle:
2110 {
2111 if (POPI() <= 0)
2112 TAKE_GOTO;
2113 else
2114 SKIP_GOTO;
2115 }
2116 NEXT_INSN;
2117
2118 insn_if_icmpeq:
2119 {
2120 jint value2 = POPI();
2121 jint value1 = POPI();
2122 if (value1 == value2)
2123 TAKE_GOTO;
2124 else
2125 SKIP_GOTO;
2126 }
2127 NEXT_INSN;
2128
2129 insn_if_icmpne:
2130 {
2131 jint value2 = POPI();
2132 jint value1 = POPI();
2133 if (value1 != value2)
2134 TAKE_GOTO;
2135 else
2136 SKIP_GOTO;
2137 }
2138 NEXT_INSN;
2139
2140 insn_if_icmplt:
2141 {
2142 jint value2 = POPI();
2143 jint value1 = POPI();
2144 if (value1 < value2)
2145 TAKE_GOTO;
2146 else
2147 SKIP_GOTO;
2148 }
2149 NEXT_INSN;
2150
2151 insn_if_icmpge:
2152 {
2153 jint value2 = POPI();
2154 jint value1 = POPI();
2155 if (value1 >= value2)
2156 TAKE_GOTO;
2157 else
2158 SKIP_GOTO;
2159 }
2160 NEXT_INSN;
2161
2162 insn_if_icmpgt:
2163 {
2164 jint value2 = POPI();
2165 jint value1 = POPI();
2166 if (value1 > value2)
2167 TAKE_GOTO;
2168 else
2169 SKIP_GOTO;
2170 }
2171 NEXT_INSN;
2172
2173 insn_if_icmple:
2174 {
2175 jint value2 = POPI();
2176 jint value1 = POPI();
2177 if (value1 <= value2)
2178 TAKE_GOTO;
2179 else
2180 SKIP_GOTO;
2181 }
2182 NEXT_INSN;
2183
2184 insn_if_acmpeq:
2185 {
2186 jobject value2 = POPA();
2187 jobject value1 = POPA();
2188 if (value1 == value2)
2189 TAKE_GOTO;
2190 else
2191 SKIP_GOTO;
2192 }
2193 NEXT_INSN;
2194
2195 insn_if_acmpne:
2196 {
2197 jobject value2 = POPA();
2198 jobject value1 = POPA();
2199 if (value1 != value2)
2200 TAKE_GOTO;
2201 else
2202 SKIP_GOTO;
2203 }
2204 NEXT_INSN;
2205
2206 insn_goto_w:
2207#ifndef DIRECT_THREADED
2208 // For direct threaded, goto and goto_w are the same.
2209 pc = pc - 1 + get4 (pc);
2210 NEXT_INSN;
2211#endif /* DIRECT_THREADED */
2212 insn_goto:
2213 TAKE_GOTO;
2214 NEXT_INSN;
2215
2216 insn_jsr_w:
2217#ifndef DIRECT_THREADED
2218 // For direct threaded, jsr and jsr_w are the same.
2219 {
2220 pc_t next = pc - 1 + get4 (pc);
2221 pc += 4;
2222 PUSHA ((jobject) pc);
2223 pc = next;
2224 }
2225 NEXT_INSN;
2226#endif /* DIRECT_THREADED */
2227 insn_jsr:
2228 {
2229 pc_t next = GOTO_VAL();
2230 SKIP_GOTO;
2231 PUSHA ((jobject) pc);
2232 pc = next;
2233 }
2234 NEXT_INSN;
2235
2236 insn_ret:
2237 {
2238 jint index = GET1U ();
2239 pc = (pc_t) PEEKA (index);
2240 }
2241 NEXT_INSN;
2242
2243 insn_tableswitch:
2244 {
2245#ifdef DIRECT_THREADED
2246 void *def = (pc++)->datum;
2247
2248 int index = POPI();
2249
2250 jint low = INTVAL ();
2251 jint high = INTVAL ();
2252
2253 if (index < low || index > high)
2254 pc = (insn_slot *) def;
2255 else
2256 pc = (insn_slot *) ((pc + index - low)->datum);
2257#else
2258 pc_t base_pc = pc - 1;
2259 int index = POPI ();
2260
2261 pc_t base = (pc_t) bytecode ();
2262 while ((pc - base) % 4 != 0)
2263 ++pc;
2264
2265 jint def = get4 (pc);
2266 jint low = get4 (pc + 4);
2267 jint high = get4 (pc + 8);
2268 if (index < low || index > high)
2269 pc = base_pc + def;
2270 else
2271 pc = base_pc + get4 (pc + 4 * (index - low + 3));
2272#endif /* DIRECT_THREADED */
2273 }
2274 NEXT_INSN;
2275
2276 insn_lookupswitch:
2277 {
2278#ifdef DIRECT_THREADED
2279 void *def = (pc++)->insn;
2280
2281 int index = POPI();
2282
2283 jint npairs = INTVAL ();
2284
2285 int max = npairs - 1;
2286 int min = 0;
2287
2288 // Simple binary search...
2289 while (min < max)
2290 {
2291 int half = (min + max) / 2;
2292 int match = pc[2 * half].int_val;
2293
2294 if (index == match)
2295 {
2296 // Found it.
2297 pc = (insn_slot *) pc[2 * half + 1].datum;
2298 NEXT_INSN;
2299 }
2300 else if (index < match)
2301 // We can use HALF - 1 here because we check again on
2302 // loop exit.
2303 max = half - 1;
2304 else
2305 // We can use HALF + 1 here because we check again on
2306 // loop exit.
2307 min = half + 1;
2308 }
2309 if (index == pc[2 * min].int_val)
2310 pc = (insn_slot *) pc[2 * min + 1].datum;
2311 else
2312 pc = (insn_slot *) def;
2313#else
2314 unsigned char *base_pc = pc-1;
2315 int index = POPI();
2316
2317 unsigned char* base = bytecode ();
2318 while ((pc-base) % 4 != 0)
2319 ++pc;
2320
2321 jint def = get4 (pc);
2322 jint npairs = get4 (pc+4);
2323
2324 int max = npairs-1;
2325 int min = 0;
2326
2327 // Simple binary search...
2328 while (min < max)
2329 {
2330 int half = (min+max)/2;
2331 int match = get4 (pc+ 4*(2 + 2*half));
2332
2333 if (index == match)
2334 min = max = half;
2335 else if (index < match)
2336 // We can use HALF - 1 here because we check again on
2337 // loop exit.
2338 max = half - 1;
2339 else
2340 // We can use HALF + 1 here because we check again on
2341 // loop exit.
2342 min = half + 1;
2343 }
2344
2345 if (index == get4 (pc+ 4*(2 + 2*min)))
2346 pc = base_pc + get4 (pc+ 4*(2 + 2*min + 1));
2347 else
2348 pc = base_pc + def;
2349#endif /* DIRECT_THREADED */
2350 }
2351 NEXT_INSN;
2352
2353 insn_areturn:
2354 *(jobject *) retp = POPA ();
2355 return;
2356
2357 insn_lreturn:
2358 *(jlong *) retp = POPL ();
2359 return;
2360
2361 insn_freturn:
2362 *(jfloat *) retp = POPF ();
2363 return;
2364
2365 insn_dreturn:
2366 *(jdouble *) retp = POPD ();
2367 return;
2368
2369 insn_ireturn:
2370 *(jint *) retp = POPI ();
2371 return;
2372
2373 insn_return:
2374 return;
2375
2376 insn_getstatic:
2377 {
2378 jint fieldref_index = GET2U ();
2379 _Jv_ResolvePoolEntry (defining_class, fieldref_index);
2380 _Jv_Field *field = pool_data[fieldref_index].field;
2381
2382 if ((field->flags & Modifier::STATIC) == 0)
2383 throw_incompatible_class_change_error
2384 (JvNewStringLatin1 ("field no longer static"));
2385
2386 jclass type = field->type;
2387
2388 // We rewrite the instruction once we discover what it refers
2389 // to.
2390 void *newinsn = NULL;
2391 if (type->isPrimitive ())
2392 {
2393 switch (type->size_in_bytes)
2394 {
2395 case 1:
2396 PUSHI (*(jbyte*) (field->u.addr));
2397 newinsn = AMPAMP (getstatic_resolved_1);
2398 break;
2399
2400 case 2:
2401 if (type == JvPrimClass (char))
2402 {
2403 PUSHI(*(jchar*) (field->u.addr));
2404 newinsn = AMPAMP (getstatic_resolved_char);
2405 }
2406 else
2407 {
2408 PUSHI(*(jshort*) (field->u.addr));
2409 newinsn = AMPAMP (getstatic_resolved_short);
2410 }
2411 break;
2412
2413 case 4:
2414 PUSHI(*(jint*) (field->u.addr));
2415 newinsn = AMPAMP (getstatic_resolved_4);
2416 break;
2417
2418 case 8:
2419 PUSHL(*(jlong*) (field->u.addr));
2420 newinsn = AMPAMP (getstatic_resolved_8);
2421 break;
2422 }
2423 }
2424 else
2425 {
2426 PUSHA(*(jobject*) (field->u.addr));
2427 newinsn = AMPAMP (getstatic_resolved_obj);
2428 }
2429
2430#ifdef DIRECT_THREADED
2431 pc[-2].insn = newinsn;
2432 pc[-1].datum = field->u.addr;
2433#endif /* DIRECT_THREADED */
2434 }
2435 NEXT_INSN;
2436
2437#ifdef DIRECT_THREADED
2438 getstatic_resolved_1:
2439 PUSHI (*(jbyte *) AVAL ());
2440 NEXT_INSN;
2441
2442 getstatic_resolved_char:
2443 PUSHI (*(jchar *) AVAL ());
2444 NEXT_INSN;
2445
2446 getstatic_resolved_short:
2447 PUSHI (*(jshort *) AVAL ());
2448 NEXT_INSN;
2449
2450 getstatic_resolved_4:
2451 PUSHI (*(jint *) AVAL ());
2452 NEXT_INSN;
2453
2454 getstatic_resolved_8:
2455 PUSHL (*(jlong *) AVAL ());
2456 NEXT_INSN;
2457
2458 getstatic_resolved_obj:
2459 PUSHA (*(jobject *) AVAL ());
2460 NEXT_INSN;
2461#endif /* DIRECT_THREADED */
2462
2463 insn_getfield:
2464 {
2465 jint fieldref_index = GET2U ();
2466 _Jv_ResolvePoolEntry (defining_class, fieldref_index);
2467 _Jv_Field *field = pool_data[fieldref_index].field;
2468
2469 if ((field->flags & Modifier::STATIC) != 0)
2470 throw_incompatible_class_change_error
2471 (JvNewStringLatin1 ("field is static"));
2472
2473 jclass type = field->type;
2474 jint field_offset = field->u.boffset;
2475 if (field_offset > 0xffff)
2476 throw new java::lang::VirtualMachineError;
2477
2478 jobject obj = POPA();
2479 NULLCHECK(obj);
2480
2481 void *newinsn = NULL;
2482 if (type->isPrimitive ())
2483 {
2484 switch (type->size_in_bytes)
2485 {
2486 case 1:
2487 PUSHI (*(jbyte*) ((char*)obj + field_offset));
2488 newinsn = AMPAMP (getfield_resolved_1);
2489 break;
2490
2491 case 2:
2492 if (type == JvPrimClass (char))
2493 {
2494 PUSHI (*(jchar*) ((char*)obj + field_offset));
2495 newinsn = AMPAMP (getfield_resolved_char);
2496 }
2497 else
2498 {
2499 PUSHI (*(jshort*) ((char*)obj + field_offset));
2500 newinsn = AMPAMP (getfield_resolved_short);
2501 }
2502 break;
2503
2504 case 4:
2505 PUSHI (*(jint*) ((char*)obj + field_offset));
2506 newinsn = AMPAMP (getfield_resolved_4);
2507 break;
2508
2509 case 8:
2510 PUSHL(*(jlong*) ((char*)obj + field_offset));
2511 newinsn = AMPAMP (getfield_resolved_8);
2512 break;
2513 }
2514 }
2515 else
2516 {
2517 PUSHA(*(jobject*) ((char*)obj + field_offset));
2518 newinsn = AMPAMP (getfield_resolved_obj);
2519 }
2520
2521#ifdef DIRECT_THREADED
2522 pc[-2].insn = newinsn;
2523 pc[-1].int_val = field_offset;
2524#endif /* DIRECT_THREADED */
2525 }
2526 NEXT_INSN;
2527
2528#ifdef DIRECT_THREADED
2529 getfield_resolved_1:
2530 {
2531 char *obj = (char *) POPA ();
2532 NULLCHECK (obj);
2533 PUSHI (*(jbyte *) (obj + INTVAL ()));
2534 }
2535 NEXT_INSN;
2536
2537 getfield_resolved_char:
2538 {
2539 char *obj = (char *) POPA ();
2540 NULLCHECK (obj);
2541 PUSHI (*(jchar *) (obj + INTVAL ()));
2542 }
2543 NEXT_INSN;
2544
2545 getfield_resolved_short:
2546 {
2547 char *obj = (char *) POPA ();
2548 NULLCHECK (obj);
2549 PUSHI (*(jshort *) (obj + INTVAL ()));
2550 }
2551 NEXT_INSN;
2552
2553 getfield_resolved_4:
2554 {
2555 char *obj = (char *) POPA ();
2556 NULLCHECK (obj);
2557 PUSHI (*(jint *) (obj + INTVAL ()));
2558 }
2559 NEXT_INSN;
2560
2561 getfield_resolved_8:
2562 {
2563 char *obj = (char *) POPA ();
2564 NULLCHECK (obj);
2565 PUSHL (*(jlong *) (obj + INTVAL ()));
2566 }
2567 NEXT_INSN;
2568
2569 getfield_resolved_obj:
2570 {
2571 char *obj = (char *) POPA ();
2572 NULLCHECK (obj);
2573 PUSHA (*(jobject *) (obj + INTVAL ()));
2574 }
2575 NEXT_INSN;
2576#endif /* DIRECT_THREADED */
2577
2578 insn_putstatic:
2579 {
2580 jint fieldref_index = GET2U ();
2581 _Jv_ResolvePoolEntry (defining_class, fieldref_index);
2582 _Jv_Field *field = pool_data[fieldref_index].field;
2583
2584 jclass type = field->type;
2585
2586 // ResolvePoolEntry cannot check this
2587 if ((field->flags & Modifier::STATIC) == 0)
2588 throw_incompatible_class_change_error
2589 (JvNewStringLatin1 ("field no longer static"));
2590
2591 void *newinsn = NULL;
2592 if (type->isPrimitive ())
2593 {
2594 switch (type->size_in_bytes)
2595 {
2596 case 1:
2597 {
2598 jint value = POPI();
2599 *(jbyte*) (field->u.addr) = value;
2600 newinsn = AMPAMP (putstatic_resolved_1);
2601 break;
2602 }
2603
2604 case 2:
2605 {
2606 jint value = POPI();
2607 *(jchar*) (field->u.addr) = value;
2608 newinsn = AMPAMP (putstatic_resolved_2);
2609 break;
2610 }
2611
2612 case 4:
2613 {
2614 jint value = POPI();
2615 *(jint*) (field->u.addr) = value;
2616 newinsn = AMPAMP (putstatic_resolved_4);
2617 break;
2618 }
2619
2620 case 8:
2621 {
2622 jlong value = POPL();
2623 *(jlong*) (field->u.addr) = value;
2624 newinsn = AMPAMP (putstatic_resolved_8);
2625 break;
2626 }
2627 }
2628 }
2629 else
2630 {
2631 jobject value = POPA();
2632 *(jobject*) (field->u.addr) = value;
2633 newinsn = AMPAMP (putstatic_resolved_obj);
2634 }
2635
2636#ifdef DIRECT_THREADED
2637 pc[-2].insn = newinsn;
2638 pc[-1].datum = field->u.addr;
2639#endif /* DIRECT_THREADED */
2640 }
2641 NEXT_INSN;
2642
2643#ifdef DIRECT_THREADED
2644 putstatic_resolved_1:
2645 *(jbyte *) AVAL () = POPI ();
2646 NEXT_INSN;
2647
2648 putstatic_resolved_2:
2649 *(jchar *) AVAL () = POPI ();
2650 NEXT_INSN;
2651
2652 putstatic_resolved_4:
2653 *(jint *) AVAL () = POPI ();
2654 NEXT_INSN;
2655
2656 putstatic_resolved_8:
2657 *(jlong *) AVAL () = POPL ();
2658 NEXT_INSN;
2659
2660 putstatic_resolved_obj:
2661 *(jobject *) AVAL () = POPA ();
2662 NEXT_INSN;
2663#endif /* DIRECT_THREADED */
2664
2665 insn_putfield:
2666 {
2667 jint fieldref_index = GET2U ();
2668 _Jv_ResolvePoolEntry (defining_class, fieldref_index);
2669 _Jv_Field *field = pool_data[fieldref_index].field;
2670
2671 jclass type = field->type;
2672
2673 if ((field->flags & Modifier::STATIC) != 0)
2674 throw_incompatible_class_change_error
2675 (JvNewStringLatin1 ("field is static"));
2676
2677 jint field_offset = field->u.boffset;
2678 if (field_offset > 0xffff)
2679 throw new java::lang::VirtualMachineError;
2680
2681 void *newinsn = NULL;
2682 if (type->isPrimitive ())
2683 {
2684 switch (type->size_in_bytes)
2685 {
2686 case 1:
2687 {
2688 jint value = POPI();
2689 jobject obj = POPA();
2690 NULLCHECK(obj);
2691 *(jbyte*) ((char*)obj + field_offset) = value;
2692 newinsn = AMPAMP (putfield_resolved_1);
2693 break;
2694 }
2695
2696 case 2:
2697 {
2698 jint value = POPI();
2699 jobject obj = POPA();
2700 NULLCHECK(obj);
2701 *(jchar*) ((char*)obj + field_offset) = value;
2702 newinsn = AMPAMP (putfield_resolved_2);
2703 break;
2704 }
2705
2706 case 4:
2707 {
2708 jint value = POPI();
2709 jobject obj = POPA();
2710 NULLCHECK(obj);
2711 *(jint*) ((char*)obj + field_offset) = value;
2712 newinsn = AMPAMP (putfield_resolved_4);
2713 break;
2714 }
2715
2716 case 8:
2717 {
2718 jlong value = POPL();
2719 jobject obj = POPA();
2720 NULLCHECK(obj);
2721 *(jlong*) ((char*)obj + field_offset) = value;
2722 newinsn = AMPAMP (putfield_resolved_8);
2723 break;
2724 }
2725 }
2726 }
2727 else
2728 {
2729 jobject value = POPA();
2730 jobject obj = POPA();
2731 NULLCHECK(obj);
2732 *(jobject*) ((char*)obj + field_offset) = value;
2733 newinsn = AMPAMP (putfield_resolved_obj);
2734 }
2735
2736#ifdef DIRECT_THREADED
2737 pc[-2].insn = newinsn;
2738 pc[-1].int_val = field_offset;
2739#endif /* DIRECT_THREADED */
2740 }
2741 NEXT_INSN;
2742
2743#ifdef DIRECT_THREADED
2744 putfield_resolved_1:
2745 {
2746 jint val = POPI ();
2747 char *obj = (char *) POPA ();
2748 NULLCHECK (obj);
2749 *(jbyte *) (obj + INTVAL ()) = val;
2750 }
2751 NEXT_INSN;
2752
2753 putfield_resolved_2:
2754 {
2755 jint val = POPI ();
2756 char *obj = (char *) POPA ();
2757 NULLCHECK (obj);
2758 *(jchar *) (obj + INTVAL ()) = val;
2759 }
2760 NEXT_INSN;
2761
2762 putfield_resolved_4:
2763 {
2764 jint val = POPI ();
2765 char *obj = (char *) POPA ();
2766 NULLCHECK (obj);
2767 *(jint *) (obj + INTVAL ()) = val;
2768 }
2769 NEXT_INSN;
2770
2771 putfield_resolved_8:
2772 {
2773 jlong val = POPL ();
2774 char *obj = (char *) POPA ();
2775 NULLCHECK (obj);
2776 *(jlong *) (obj + INTVAL ()) = val;
2777 }
2778 NEXT_INSN;
2779
2780 putfield_resolved_obj:
2781 {
2782 jobject val = POPA ();
2783 char *obj = (char *) POPA ();
2784 NULLCHECK (obj);
2785 *(jobject *) (obj + INTVAL ()) = val;
2786 }
2787 NEXT_INSN;
2788#endif /* DIRECT_THREADED */
2789
2790 insn_invokespecial:
2791 {
2792 int index = GET2U ();
2793
2794 rmeth = (_Jv_ResolvePoolEntry (defining_class, index)).rmethod;
2795
2796 sp -= rmeth->stack_item_count;
2797
2798 // We don't use NULLCHECK here because we can't rely on that
2799 // working for <init>. So instead we do an explicit test.
2800 if (! sp[0].o)
2801 throw new java::lang::NullPointerException;
2802
2803 fun = (void (*)()) rmeth->method->ncode;
2804
2805#ifdef DIRECT_THREADED
2806 // Rewrite instruction so that we use a faster pre-resolved
2807 // method.
2808 pc[-2].insn = &&invokespecial_resolved;
2809 pc[-1].datum = rmeth;
2810#endif /* DIRECT_THREADED */
2811 }
2812 goto perform_invoke;
2813
2814#ifdef DIRECT_THREADED
2815 invokespecial_resolved:
2816 {
2817 rmeth = (_Jv_ResolvedMethod *) AVAL ();
2818 sp -= rmeth->stack_item_count;
2819 // We don't use NULLCHECK here because we can't rely on that
2820 // working for <init>. So instead we do an explicit test.
2821 if (! sp[0].o)
2822 throw new java::lang::NullPointerException;
2823 fun = (void (*)()) rmeth->method->ncode;
2824 }
2825 goto perform_invoke;
2826#endif /* DIRECT_THREADED */
2827
2828 insn_invokestatic:
2829 {
2830 int index = GET2U ();
2831
2832 rmeth = (_Jv_ResolvePoolEntry (defining_class, index)).rmethod;
2833
2834 sp -= rmeth->stack_item_count;
2835
2836 _Jv_InitClass (rmeth->klass);
2837 fun = (void (*)()) rmeth->method->ncode;
2838
2839#ifdef DIRECT_THREADED
2840 // Rewrite instruction so that we use a faster pre-resolved
2841 // method.
2842 pc[-2].insn = &&invokestatic_resolved;
2843 pc[-1].datum = rmeth;
2844#endif /* DIRECT_THREADED */
2845 }
2846 goto perform_invoke;
2847
2848#ifdef DIRECT_THREADED
2849 invokestatic_resolved:
2850 {
2851 rmeth = (_Jv_ResolvedMethod *) AVAL ();
2852 sp -= rmeth->stack_item_count;
2853 fun = (void (*)()) rmeth->method->ncode;
2854 }
2855 goto perform_invoke;
2856#endif /* DIRECT_THREADED */
2857
2858 insn_invokeinterface:
2859 {
2860 int index = GET2U ();
2861
2862 rmeth = (_Jv_ResolvePoolEntry (defining_class, index)).rmethod;
2863
2864 sp -= rmeth->stack_item_count;
2865
2866 jobject rcv = sp[0].o;
2867
2868 NULLCHECK (rcv);
2869
2870 fun = (void (*)())
2871 _Jv_LookupInterfaceMethod (rcv->getClass (),
2872 rmeth->method->name,
2873 rmeth->method->signature);
2874
2875#ifdef DIRECT_THREADED
2876 // Rewrite instruction so that we use a faster pre-resolved
2877 // method.
2878 pc[-2].insn = &&invokeinterface_resolved;
2879 pc[-1].datum = rmeth;
2880#else
2881 // Skip dummy bytes.
2882 pc += 2;
2883#endif /* DIRECT_THREADED */
2884 }
2885 goto perform_invoke;
2886
2887#ifdef DIRECT_THREADED
2888 invokeinterface_resolved:
2889 {
2890 rmeth = (_Jv_ResolvedMethod *) AVAL ();
2891 sp -= rmeth->stack_item_count;
2892 jobject rcv = sp[0].o;
2893 NULLCHECK (rcv);
2894 fun = (void (*)())
2895 _Jv_LookupInterfaceMethod (rcv->getClass (),
2896 rmeth->method->name,
2897 rmeth->method->signature);
2898 }
2899 goto perform_invoke;
2900#endif /* DIRECT_THREADED */
2901
2902 insn_new:
2903 {
2904 int index = GET2U ();
2905 jclass klass = (_Jv_ResolvePoolEntry (defining_class, index)).clazz;
2906 _Jv_InitClass (klass);
2907 jobject res = _Jv_AllocObject (klass, klass->size_in_bytes);
2908 PUSHA (res);
2909
2910#ifdef DIRECT_THREADED
2911 pc[-2].insn = &&new_resolved;
2912 pc[-1].datum = klass;
2913#endif /* DIRECT_THREADED */
2914 }
2915 NEXT_INSN;
2916
2917#ifdef DIRECT_THREADED
2918 new_resolved:
2919 {
2920 jclass klass = (jclass) AVAL ();
2921 jobject res = _Jv_AllocObject (klass, klass->size_in_bytes);
2922 PUSHA (res);
2923 }
2924 NEXT_INSN;
2925#endif /* DIRECT_THREADED */
2926
2927 insn_newarray:
2928 {
2929 int atype = GET1U ();
2930 int size = POPI();
2931 jobject result = _Jv_NewArray (atype, size);
2932 PUSHA (result);
2933 }
2934 NEXT_INSN;
2935
2936 insn_anewarray:
2937 {
2938 int index = GET2U ();
2939 jclass klass = (_Jv_ResolvePoolEntry (defining_class, index)).clazz;
2940 int size = POPI();
2941 _Jv_InitClass (klass);
2942 jobject result = _Jv_NewObjectArray (size, klass, 0);
2943 PUSHA (result);
2944
2945#ifdef DIRECT_THREADED
2946 pc[-2].insn = &&anewarray_resolved;
2947 pc[-1].datum = klass;
2948#endif /* DIRECT_THREADED */
2949 }
2950 NEXT_INSN;
2951
2952#ifdef DIRECT_THREADED
2953 anewarray_resolved:
2954 {
2955 jclass klass = (jclass) AVAL ();
2956 int size = POPI ();
2957 jobject result = _Jv_NewObjectArray (size, klass, 0);
2958 PUSHA (result);
2959 }
2960 NEXT_INSN;
2961#endif /* DIRECT_THREADED */
2962
2963 insn_arraylength:
2964 {
2965 __JArray *arr = (__JArray*)POPA();
2966 NULLARRAYCHECK (arr);
2967 PUSHI (arr->length);
2968 }
2969 NEXT_INSN;
2970
2971 insn_athrow:
2972 {
2973 jobject value = POPA();
2974 throw static_cast<jthrowable>(value);
2975 }
2976 NEXT_INSN;
2977
2978 insn_checkcast:
2979 {
2980 jobject value = POPA();
2981 jint index = GET2U ();
2982 jclass to = (_Jv_ResolvePoolEntry (defining_class, index)).clazz;
2983
2984 if (value != NULL && ! to->isInstance (value))
2985 throw new java::lang::ClassCastException (to->getName());
2986
2987 PUSHA (value);
2988
2989#ifdef DIRECT_THREADED
2990 pc[-2].insn = &&checkcast_resolved;
2991 pc[-1].datum = to;
2992#endif /* DIRECT_THREADED */
2993 }
2994 NEXT_INSN;
2995
2996#ifdef DIRECT_THREADED
2997 checkcast_resolved:
2998 {
2999 jobject value = POPA ();
3000 jclass to = (jclass) AVAL ();
3001 if (value != NULL && ! to->isInstance (value))
3002 throw new java::lang::ClassCastException (to->getName());
3003 PUSHA (value);
3004 }
3005 NEXT_INSN;
3006#endif /* DIRECT_THREADED */
3007
3008 insn_instanceof:
3009 {
3010 jobject value = POPA();
3011 jint index = GET2U ();
3012 jclass to = (_Jv_ResolvePoolEntry (defining_class, index)).clazz;
3013 PUSHI (to->isInstance (value));
3014
3015#ifdef DIRECT_THREADED
3016 pc[-2].insn = &&instanceof_resolved;
3017 pc[-1].datum = to;
3018#endif /* DIRECT_THREADED */
3019 }
3020 NEXT_INSN;
3021
3022#ifdef DIRECT_THREADED
3023 instanceof_resolved:
3024 {
3025 jobject value = POPA ();
3026 jclass to = (jclass) AVAL ();
3027 PUSHI (to->isInstance (value));
3028 }
3029 NEXT_INSN;
3030#endif /* DIRECT_THREADED */
3031
3032 insn_monitorenter:
3033 {
3034 jobject value = POPA();
3035 NULLCHECK(value);
3036 _Jv_MonitorEnter (value);
3037 }
3038 NEXT_INSN;
3039
3040 insn_monitorexit:
3041 {
3042 jobject value = POPA();
3043 NULLCHECK(value);
3044 _Jv_MonitorExit (value);
3045 }
3046 NEXT_INSN;
3047
3048 insn_ifnull:
3049 {
3050 jobject val = POPA();
3051 if (val == NULL)
3052 TAKE_GOTO;
3053 else
3054 SKIP_GOTO;
3055 }
3056 NEXT_INSN;
3057
3058 insn_ifnonnull:
3059 {
3060 jobject val = POPA();
3061 if (val != NULL)
3062 TAKE_GOTO;
3063 else
3064 SKIP_GOTO;
3065 }
3066 NEXT_INSN;
3067
3068 insn_multianewarray:
3069 {
3070 int kind_index = GET2U ();
3071 int dim = GET1U ();
3072
3073 jclass type
3074 = (_Jv_ResolvePoolEntry (defining_class, kind_index)).clazz;
3075 _Jv_InitClass (type);
3076 jint *sizes = (jint*) __builtin_alloca (sizeof (jint)*dim);
3077
3078 for (int i = dim - 1; i >= 0; i--)
3079 {
3080 sizes[i] = POPI ();
3081 }
3082
3083 jobject res = _Jv_NewMultiArray (type,dim, sizes);
3084
3085 PUSHA (res);
3086 }
3087 NEXT_INSN;
3088
3089#ifndef DIRECT_THREADED
3090 insn_wide:
3091 {
3092 jint the_mod_op = get1u (pc++);
3093 jint wide = get2u (pc); pc += 2;
3094
3095 switch (the_mod_op)
3096 {
3097 case op_istore:
3098 STOREI (wide);
3099 NEXT_INSN;
3100
3101 case op_fstore:
3102 STOREF (wide);
3103 NEXT_INSN;
3104
3105 case op_astore:
3106 STOREA (wide);
3107 NEXT_INSN;
3108
3109 case op_lload:
3110 LOADL (wide);
3111 NEXT_INSN;
3112
3113 case op_dload:
3114 LOADD (wide);
3115 NEXT_INSN;
3116
3117 case op_iload:
3118 LOADI (wide);
3119 NEXT_INSN;
3120
3121 case op_aload:
3122 LOADA (wide);
3123 NEXT_INSN;
3124
3125 case op_lstore:
3126 STOREL (wide);
3127 NEXT_INSN;
3128
3129 case op_dstore:
3130 STORED (wide);
3131 NEXT_INSN;
3132
3133 case op_ret:
3134 pc = (unsigned char*) PEEKA (wide);
3135 NEXT_INSN;
3136
3137 case op_iinc:
3138 {
3139 jint amount = get2s (pc); pc += 2;
3140 jint value = PEEKI (wide);
3141 POKEI (wide, value+amount);
3142 }
3143 NEXT_INSN;
3144
3145 default:
3146 throw_internal_error ("illegal bytecode modified by wide");
3147 }
3148
3149 }
3150#endif /* DIRECT_THREADED */
3151 }
3152 catch (java::lang::Throwable *ex)
3153 {
3154#ifdef DIRECT_THREADED
3155 void *logical_pc = (void *) ((insn_slot *) pc - 1);
3156#else
3157 int logical_pc = pc - 1 - bytecode ();
3158#endif
3159 _Jv_InterpException *exc = exceptions ();
3160 jclass exc_class = ex->getClass ();
3161
3162 for (int i = 0; i < exc_count; i++)
3163 {
3164 if (PCVAL (exc[i].start_pc) <= logical_pc
3165 && logical_pc < PCVAL (exc[i].end_pc))
3166 {
3167#ifdef DIRECT_THREADED
3168 jclass handler = (jclass) exc[i].handler_type.p;
3169#else
3170 jclass handler = NULL;
3171 if (exc[i].handler_type.i != 0)
3172 handler = (_Jv_ResolvePoolEntry (defining_class,
3173 exc[i].handler_type.i)).clazz;
3174#endif /* DIRECT_THREADED */
3175
3176 if (handler == NULL || handler->isAssignableFrom (exc_class))
3177 {
3178#ifdef DIRECT_THREADED
3179 pc = (insn_slot *) exc[i].handler_pc.p;
3180#else
3181 pc = bytecode () + exc[i].handler_pc.i;
3182#endif /* DIRECT_THREADED */
3183 sp = stack;
3184 sp++->o = ex; // Push exception.
3185 NEXT_INSN;
3186 }
3187 }
3188 }
3189
3190 // No handler, so re-throw.
3191 throw ex;
3192 }
3193}
3194
3195// This function exists so that the stack-tracing code can find the
3196// boundaries of the interpreter.
3197void
3198_Jv_EndOfInterpreter (void)
3199{
3200}
3201
3202static void
3203throw_internal_error (char *msg)
3204{
3205 throw new java::lang::InternalError (JvNewStringLatin1 (msg));
3206}
3207
3208static void
3209throw_incompatible_class_change_error (jstring msg)
3210{
3211 throw new java::lang::IncompatibleClassChangeError (msg);
3212}
3213
3214#ifndef HANDLE_SEGV
3215static java::lang::NullPointerException *null_pointer_exc;
3216static void
3217throw_null_pointer_exception ()
3218{
3219 if (null_pointer_exc == NULL)
3220 null_pointer_exc = new java::lang::NullPointerException;
3221
3222 throw null_pointer_exc;
3223}
3224#endif
3225
3226#endif // INTERPRETER
Note: See TracBrowser for help on using the repository browser.