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