1 // interpret.cc - Code for the interpreter
2
3 /* Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation
4
5 This file is part of libgcj.
6
7 This software is copyrighted work licensed under the terms of the
8 Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
9 details. */
10
11 /* Author: Kresten Krab Thorup <krab@gnu.org> */
12
13 #include <config.h>
14 #include <platform.h>
15
16 #pragma implementation "java-interp.h"
17
18 #include <jvm.h>
19 #include <java-cpool.h>
20 #include <java-interp.h>
21 #include <java/lang/System.h>
22 #include <java/lang/String.h>
23 #include <java/lang/Integer.h>
24 #include <java/lang/Long.h>
25 #include <java/lang/StringBuffer.h>
26 #include <java/lang/Class.h>
27 #include <java/lang/reflect/Modifier.h>
28 #include <java/lang/InternalError.h>
29 #include <java/lang/NullPointerException.h>
30 #include <java/lang/ArithmeticException.h>
31 #include <java/lang/IncompatibleClassChangeError.h>
32 #include <java/lang/InstantiationException.h>
33 #include <java/lang/Thread.h>
34 #include <java-insns.h>
35 #include <java-signal.h>
36 #include <java/lang/ClassFormatError.h>
37 #include <execution.h>
38 #include <java/lang/reflect/Modifier.h>
39
40 #include <jvmti.h>
41 #include "jvmti-int.h"
42
43 #include <gnu/gcj/jvmti/Breakpoint.h>
44 #include <gnu/gcj/jvmti/BreakpointManager.h>
45
46 // Execution engine for interpreted code.
47 _Jv_InterpreterEngine _Jv_soleInterpreterEngine;
48
49 #include <stdlib.h>
50
51 using namespace gcj;
52
53 static void throw_internal_error (const char *msg)
54 __attribute__ ((__noreturn__));
55 static void throw_incompatible_class_change_error (jstring msg)
56 __attribute__ ((__noreturn__));
57 static void throw_null_pointer_exception ()
58 __attribute__ ((__noreturn__));
59
60 static void throw_class_format_error (jstring msg)
61 __attribute__ ((__noreturn__));
62 static void throw_class_format_error (const char *msg)
63 __attribute__ ((__noreturn__));
64
65 static void find_catch_location (jthrowable, jthread, jmethodID *, jlong *);
66
67 // A macro to facilitate JVMTI exception reporting
68 #define REPORT_EXCEPTION(Jthrowable) \
69 do { \
70 if (JVMTI_REQUESTED_EVENT (Exception)) \
71 _Jv_ReportJVMTIExceptionThrow (Jthrowable); \
72 } \
73 while (0)
74
75 #ifdef DIRECT_THREADED
76 // Lock to ensure that methods are not compiled concurrently.
77 // We could use a finer-grained lock here, however it is not safe to use
78 // the Class monitor as user code in another thread could hold it.
79 static _Jv_Mutex_t compile_mutex;
80
81 // See class ThreadCountAdjuster and REWRITE_INSN for how this is
82 // used.
83 _Jv_Mutex_t _Jv_InterpMethod::rewrite_insn_mutex;
84
85 void
_Jv_InitInterpreter()86 _Jv_InitInterpreter()
87 {
88 _Jv_MutexInit (&compile_mutex);
89 _Jv_MutexInit (&_Jv_InterpMethod::rewrite_insn_mutex);
90 }
91 #else
_Jv_InitInterpreter()92 void _Jv_InitInterpreter() {}
93 #endif
94
95 // The breakpoint instruction. For the direct threaded case,
96 // _Jv_InterpMethod::compile will initialize breakpoint_insn
97 // the first time it is called.
98 #ifdef DIRECT_THREADED
99 insn_slot _Jv_InterpMethod::bp_insn_slot;
100 pc_t _Jv_InterpMethod::breakpoint_insn = NULL;
101 #else
102 unsigned char _Jv_InterpMethod::bp_insn_opcode
103 = static_cast<unsigned char> (op_breakpoint);
104 pc_t _Jv_InterpMethod::breakpoint_insn = &_Jv_InterpMethod::bp_insn_opcode;
105 #endif
106
107 extern "C" double __ieee754_fmod (double,double);
108
dupx(_Jv_word * sp,int n,int x)109 static inline void dupx (_Jv_word *sp, int n, int x)
110 {
111 // first "slide" n+x elements n to the right
112 int top = n-1;
113 for (int i = 0; i < n+x; i++)
114 {
115 sp[(top-i)] = sp[(top-i)-n];
116 }
117
118 // next, copy the n top elements, n+x down
119 for (int i = 0; i < n; i++)
120 {
121 sp[top-(n+x)-i] = sp[top-i];
122 }
123 }
124
125 // Used to convert from floating types to integral types.
126 template<typename TO, typename FROM>
127 static inline TO
convert(FROM val,TO min,TO max)128 convert (FROM val, TO min, TO max)
129 {
130 TO ret;
131 if (val >= (FROM) max)
132 ret = max;
133 else if (val <= (FROM) min)
134 ret = min;
135 else if (val != val)
136 ret = 0;
137 else
138 ret = (TO) val;
139 return ret;
140 }
141
142 #define PUSHA(V) (sp++)->o = (V)
143 #define PUSHI(V) (sp++)->i = (V)
144 #define PUSHF(V) (sp++)->f = (V)
145 #if SIZEOF_VOID_P == 8
146 # define PUSHL(V) (sp->l = (V), sp += 2)
147 # define PUSHD(V) (sp->d = (V), sp += 2)
148 #else
149 # define PUSHL(V) do { _Jv_word2 w2; w2.l=(V); \
150 (sp++)->ia[0] = w2.ia[0]; \
151 (sp++)->ia[0] = w2.ia[1]; } while (0)
152 # define PUSHD(V) do { _Jv_word2 w2; w2.d=(V); \
153 (sp++)->ia[0] = w2.ia[0]; \
154 (sp++)->ia[0] = w2.ia[1]; } while (0)
155 #endif
156
157 #define POPA() ((--sp)->o)
158 #define POPI() ((jint) (--sp)->i) // cast since it may be promoted
159 #define POPF() ((jfloat) (--sp)->f)
160 #if SIZEOF_VOID_P == 8
161 # define POPL() (sp -= 2, (jlong) sp->l)
162 # define POPD() (sp -= 2, (jdouble) sp->d)
163 #else
164 # define POPL() ({ _Jv_word2 w2; \
165 w2.ia[1] = (--sp)->ia[0]; \
166 w2.ia[0] = (--sp)->ia[0]; w2.l; })
167 # define POPD() ({ _Jv_word2 w2; \
168 w2.ia[1] = (--sp)->ia[0]; \
169 w2.ia[0] = (--sp)->ia[0]; w2.d; })
170 #endif
171
172 #define LOADA(I) (sp++)->o = locals[I].o
173 #define LOADI(I) (sp++)->i = locals[I].i
174 #define LOADF(I) (sp++)->f = locals[I].f
175 #if SIZEOF_VOID_P == 8
176 # define LOADL(I) (sp->l = locals[I].l, sp += 2)
177 # define LOADD(I) (sp->d = locals[I].d, sp += 2)
178 #else
179 # define LOADL(I) do { jint __idx = (I); \
180 (sp++)->ia[0] = locals[__idx].ia[0]; \
181 (sp++)->ia[0] = locals[__idx+1].ia[0]; \
182 } while (0)
183 # define LOADD(I) LOADL(I)
184 #endif
185
186 #define STOREA(I) \
187 do \
188 { \
189 jint __idx = (I); \
190 DEBUG_LOCALS_INSN (__idx, 'o'); \
191 locals[__idx].o = (--sp)->o; \
192 } \
193 while (0)
194 #define STOREI(I) \
195 do \
196 { \
197 jint __idx = (I); \
198 DEBUG_LOCALS_INSN (__idx, 'i'); \
199 locals[__idx].i = (--sp)->i; \
200 } while (0)
201 #define STOREF(I) \
202 do \
203 { \
204 jint __idx = (I); \
205 DEBUG_LOCALS_INSN (__idx, 'f'); \
206 locals[__idx].f = (--sp)->f; \
207 } \
208 while (0)
209 #if SIZEOF_VOID_P == 8
210 # define STOREL(I) \
211 do \
212 { \
213 jint __idx = (I); \
214 DEBUG_LOCALS_INSN (__idx, 'l'); \
215 DEBUG_LOCALS_INSN (__idx + 1, 'x'); \
216 (sp -= 2, locals[__idx].l = sp->l); \
217 } \
218 while (0)
219 # define STORED(I) \
220 do \
221 { \
222 jint __idx = (I); \
223 DEBUG_LOCALS_INSN (__idx, 'd'); \
224 DEBUG_LOCALS_INSN (__idx + 1, 'x'); \
225 (sp -= 2, locals[__idx].d = sp->d); \
226 } \
227 while (0)
228
229 #else
230 # define STOREL(I) \
231 do \
232 { \
233 jint __idx = (I); \
234 DEBUG_LOCALS_INSN (__idx, 'l'); \
235 DEBUG_LOCALS_INSN (__idx + 1, 'x'); \
236 locals[__idx + 1].ia[0] = (--sp)->ia[0]; \
237 locals[__idx].ia[0] = (--sp)->ia[0]; \
238 } \
239 while (0)
240 # define STORED(I) \
241 do { \
242 jint __idx = (I); \
243 DEBUG_LOCALS_INSN (__idx, 'd'); \
244 DEBUG_LOCALS_INSN (__idx + 1, 'x'); \
245 locals[__idx + 1].ia[0] = (--sp)->ia[0]; \
246 locals[__idx].ia[0] = (--sp)->ia[0]; \
247 } while (0)
248 #endif
249
250 #define PEEKI(I) (locals+(I))->i
251 #define PEEKA(I) (locals+(I))->o
252
253 #define POKEI(I,V) \
254 do \
255 { \
256 jint __idx = (I); \
257 DEBUG_LOCALS_INSN (__idx, 'i'); \
258 ((locals + __idx)->i = (V)); \
259 } \
260 while (0)
261
262
263 #define BINOPI(OP) { \
264 jint value2 = POPI(); \
265 jint value1 = POPI(); \
266 PUSHI(value1 OP value2); \
267 }
268
269 #define BINOPF(OP) { \
270 jfloat value2 = POPF(); \
271 jfloat value1 = POPF(); \
272 PUSHF(value1 OP value2); \
273 }
274
275 #define BINOPL(OP) { \
276 jlong value2 = POPL(); \
277 jlong value1 = POPL(); \
278 PUSHL(value1 OP value2); \
279 }
280
281 #define BINOPD(OP) { \
282 jdouble value2 = POPD(); \
283 jdouble value1 = POPD(); \
284 PUSHD(value1 OP value2); \
285 }
286
287 static inline jint
get1s(unsigned char * loc)288 get1s (unsigned char* loc)
289 {
290 return *(signed char*)loc;
291 }
292
293 static inline jint
get1u(unsigned char * loc)294 get1u (unsigned char* loc)
295 {
296 return *loc;
297 }
298
299 static inline jint
get2s(unsigned char * loc)300 get2s(unsigned char* loc)
301 {
302 return (((jint)*(signed char*)loc) << 8) | ((jint)*(loc+1));
303 }
304
305 static inline jint
get2u(unsigned char * loc)306 get2u (unsigned char* loc)
307 {
308 return (((jint)(*loc)) << 8) | ((jint)*(loc+1));
309 }
310
311 static jint
get4(unsigned char * loc)312 get4 (unsigned char* loc)
313 {
314 return (((jint)(loc[0])) << 24)
315 | (((jint)(loc[1])) << 16)
316 | (((jint)(loc[2])) << 8)
317 | (((jint)(loc[3])) << 0);
318 }
319
320 #define SAVE_PC() frame_desc.pc = pc
321
322 // We used to define this conditionally, depending on HANDLE_SEGV.
323 // However, that runs into a problem if a chunk in low memory is
324 // mapped and we try to look at a field near the end of a large
325 // object. See PR 26858 for details. It is, most likely, relatively
326 // inexpensive to simply do this check always.
327 #define NULLCHECK(X) \
328 do { SAVE_PC(); if ((X)==NULL) throw_null_pointer_exception (); } while (0)
329
330 // Note that we can still conditionally define NULLARRAYCHECK, since
331 // we know that all uses of an array will first reference the length
332 // field, which is first -- and thus will trigger a SEGV.
333 #ifdef HANDLE_SEGV
334 #define NULLARRAYCHECK(X) SAVE_PC()
335 #else
336 #define NULLARRAYCHECK(X) \
337 do \
338 { \
339 SAVE_PC(); \
340 if ((X) == NULL) { throw_null_pointer_exception (); } \
341 } while (0)
342 #endif
343
344 #define ARRAYBOUNDSCHECK(array, index) \
345 do \
346 { \
347 if (((unsigned) index) >= (unsigned) (array->length)) \
348 _Jv_ThrowBadArrayIndex (index); \
349 } while (0)
350
351 void
run_normal(ffi_cif *,void * ret,INTERP_FFI_RAW_TYPE * args,void * __this)352 _Jv_InterpMethod::run_normal (ffi_cif *,
353 void *ret,
354 INTERP_FFI_RAW_TYPE *args,
355 void *__this)
356 {
357 _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this;
358 run (ret, args, _this);
359 }
360
361 void
run_normal_debug(ffi_cif *,void * ret,INTERP_FFI_RAW_TYPE * args,void * __this)362 _Jv_InterpMethod::run_normal_debug (ffi_cif *,
363 void *ret,
364 INTERP_FFI_RAW_TYPE *args,
365 void *__this)
366 {
367 _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this;
368 run_debug (ret, args, _this);
369 }
370
371 void
run_synch_object(ffi_cif *,void * ret,INTERP_FFI_RAW_TYPE * args,void * __this)372 _Jv_InterpMethod::run_synch_object (ffi_cif *,
373 void *ret,
374 INTERP_FFI_RAW_TYPE *args,
375 void *__this)
376 {
377 _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this;
378
379 jobject rcv = (jobject) args[0].ptr;
380 JvSynchronize mutex (rcv);
381
382 run (ret, args, _this);
383 }
384
385 void
run_synch_object_debug(ffi_cif *,void * ret,INTERP_FFI_RAW_TYPE * args,void * __this)386 _Jv_InterpMethod::run_synch_object_debug (ffi_cif *,
387 void *ret,
388 INTERP_FFI_RAW_TYPE *args,
389 void *__this)
390 {
391 _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this;
392
393 jobject rcv = (jobject) args[0].ptr;
394 JvSynchronize mutex (rcv);
395
396 run_debug (ret, args, _this);
397 }
398
399 void
run_class(ffi_cif *,void * ret,INTERP_FFI_RAW_TYPE * args,void * __this)400 _Jv_InterpMethod::run_class (ffi_cif *,
401 void *ret,
402 INTERP_FFI_RAW_TYPE *args,
403 void *__this)
404 {
405 _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this;
406 _Jv_InitClass (_this->defining_class);
407 run (ret, args, _this);
408 }
409
410 void
run_class_debug(ffi_cif *,void * ret,INTERP_FFI_RAW_TYPE * args,void * __this)411 _Jv_InterpMethod::run_class_debug (ffi_cif *,
412 void *ret,
413 INTERP_FFI_RAW_TYPE *args,
414 void *__this)
415 {
416 _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this;
417 _Jv_InitClass (_this->defining_class);
418 run_debug (ret, args, _this);
419 }
420
421 void
run_synch_class(ffi_cif *,void * ret,INTERP_FFI_RAW_TYPE * args,void * __this)422 _Jv_InterpMethod::run_synch_class (ffi_cif *,
423 void *ret,
424 INTERP_FFI_RAW_TYPE *args,
425 void *__this)
426 {
427 _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this;
428
429 jclass sync = _this->defining_class;
430 _Jv_InitClass (sync);
431 JvSynchronize mutex (sync);
432
433 run (ret, args, _this);
434 }
435
436 void
run_synch_class_debug(ffi_cif *,void * ret,INTERP_FFI_RAW_TYPE * args,void * __this)437 _Jv_InterpMethod::run_synch_class_debug (ffi_cif *,
438 void *ret,
439 INTERP_FFI_RAW_TYPE *args,
440 void *__this)
441 {
442 _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this;
443
444 jclass sync = _this->defining_class;
445 _Jv_InitClass (sync);
446 JvSynchronize mutex (sync);
447
448 run_debug (ret, args, _this);
449 }
450
451 #ifdef DIRECT_THREADED
452 // "Compile" a method by turning it from bytecode to direct-threaded
453 // code.
454 void
compile(const void * const * insn_targets)455 _Jv_InterpMethod::compile (const void * const *insn_targets)
456 {
457 insn_slot *insns = NULL;
458 int next = 0;
459 unsigned char *codestart = bytecode ();
460 unsigned char *end = codestart + code_length;
461 _Jv_word *pool_data = defining_class->constants.data;
462
463 #define SET_ONE(Field, Value) \
464 do \
465 { \
466 if (first_pass) \
467 ++next; \
468 else \
469 insns[next++].Field = Value; \
470 } \
471 while (0)
472
473 #define SET_INSN(Value) SET_ONE (insn, (void *) Value)
474 #define SET_INT(Value) SET_ONE (int_val, Value)
475 #define SET_DATUM(Value) SET_ONE (datum, Value)
476
477 // Map from bytecode PC to slot in INSNS.
478 int *pc_mapping = (int *) __builtin_alloca (sizeof (int) * code_length);
479 for (int i = 0; i < code_length; ++i)
480 pc_mapping[i] = -1;
481
482 for (int i = 0; i < 2; ++i)
483 {
484 jboolean first_pass = i == 0;
485
486 if (! first_pass)
487 {
488 insns = (insn_slot *) _Jv_AllocBytes (sizeof (insn_slot) * next);
489 number_insn_slots = next;
490 next = 0;
491 }
492
493 unsigned char *pc = codestart;
494 while (pc < end)
495 {
496 int base_pc_val = pc - codestart;
497 if (first_pass)
498 pc_mapping[base_pc_val] = next;
499
500 java_opcode opcode = (java_opcode) *pc++;
501 // Just elide NOPs.
502 if (opcode == op_nop)
503 continue;
504 SET_INSN (insn_targets[opcode]);
505
506 switch (opcode)
507 {
508 case op_nop:
509 case op_aconst_null:
510 case op_iconst_m1:
511 case op_iconst_0:
512 case op_iconst_1:
513 case op_iconst_2:
514 case op_iconst_3:
515 case op_iconst_4:
516 case op_iconst_5:
517 case op_lconst_0:
518 case op_lconst_1:
519 case op_fconst_0:
520 case op_fconst_1:
521 case op_fconst_2:
522 case op_dconst_0:
523 case op_dconst_1:
524 case op_iload_0:
525 case op_iload_1:
526 case op_iload_2:
527 case op_iload_3:
528 case op_lload_0:
529 case op_lload_1:
530 case op_lload_2:
531 case op_lload_3:
532 case op_fload_0:
533 case op_fload_1:
534 case op_fload_2:
535 case op_fload_3:
536 case op_dload_0:
537 case op_dload_1:
538 case op_dload_2:
539 case op_dload_3:
540 case op_aload_0:
541 case op_aload_1:
542 case op_aload_2:
543 case op_aload_3:
544 case op_iaload:
545 case op_laload:
546 case op_faload:
547 case op_daload:
548 case op_aaload:
549 case op_baload:
550 case op_caload:
551 case op_saload:
552 case op_istore_0:
553 case op_istore_1:
554 case op_istore_2:
555 case op_istore_3:
556 case op_lstore_0:
557 case op_lstore_1:
558 case op_lstore_2:
559 case op_lstore_3:
560 case op_fstore_0:
561 case op_fstore_1:
562 case op_fstore_2:
563 case op_fstore_3:
564 case op_dstore_0:
565 case op_dstore_1:
566 case op_dstore_2:
567 case op_dstore_3:
568 case op_astore_0:
569 case op_astore_1:
570 case op_astore_2:
571 case op_astore_3:
572 case op_iastore:
573 case op_lastore:
574 case op_fastore:
575 case op_dastore:
576 case op_aastore:
577 case op_bastore:
578 case op_castore:
579 case op_sastore:
580 case op_pop:
581 case op_pop2:
582 case op_dup:
583 case op_dup_x1:
584 case op_dup_x2:
585 case op_dup2:
586 case op_dup2_x1:
587 case op_dup2_x2:
588 case op_swap:
589 case op_iadd:
590 case op_isub:
591 case op_imul:
592 case op_idiv:
593 case op_irem:
594 case op_ishl:
595 case op_ishr:
596 case op_iushr:
597 case op_iand:
598 case op_ior:
599 case op_ixor:
600 case op_ladd:
601 case op_lsub:
602 case op_lmul:
603 case op_ldiv:
604 case op_lrem:
605 case op_lshl:
606 case op_lshr:
607 case op_lushr:
608 case op_land:
609 case op_lor:
610 case op_lxor:
611 case op_fadd:
612 case op_fsub:
613 case op_fmul:
614 case op_fdiv:
615 case op_frem:
616 case op_dadd:
617 case op_dsub:
618 case op_dmul:
619 case op_ddiv:
620 case op_drem:
621 case op_ineg:
622 case op_i2b:
623 case op_i2c:
624 case op_i2s:
625 case op_lneg:
626 case op_fneg:
627 case op_dneg:
628 case op_i2l:
629 case op_i2f:
630 case op_i2d:
631 case op_l2i:
632 case op_l2f:
633 case op_l2d:
634 case op_f2i:
635 case op_f2l:
636 case op_f2d:
637 case op_d2i:
638 case op_d2l:
639 case op_d2f:
640 case op_lcmp:
641 case op_fcmpl:
642 case op_fcmpg:
643 case op_dcmpl:
644 case op_dcmpg:
645 case op_monitorenter:
646 case op_monitorexit:
647 case op_ireturn:
648 case op_lreturn:
649 case op_freturn:
650 case op_dreturn:
651 case op_areturn:
652 case op_return:
653 case op_athrow:
654 case op_arraylength:
655 // No argument, nothing else to do.
656 break;
657
658 case op_bipush:
659 SET_INT (get1s (pc));
660 ++pc;
661 break;
662
663 case op_ldc:
664 {
665 int index = get1u (pc);
666 ++pc;
667 // For an unresolved class we want to delay resolution
668 // until execution.
669 if (defining_class->constants.tags[index] == JV_CONSTANT_Class)
670 {
671 --next;
672 SET_INSN (insn_targets[int (op_jsr_w) + 1]);
673 SET_INT (index);
674 }
675 else
676 SET_DATUM (pool_data[index].o);
677 }
678 break;
679
680 case op_ret:
681 case op_iload:
682 case op_lload:
683 case op_fload:
684 case op_dload:
685 case op_aload:
686 case op_istore:
687 case op_lstore:
688 case op_fstore:
689 case op_dstore:
690 case op_astore:
691 case op_newarray:
692 SET_INT (get1u (pc));
693 ++pc;
694 break;
695
696 case op_iinc:
697 SET_INT (get1u (pc));
698 SET_INT (get1s (pc + 1));
699 pc += 2;
700 break;
701
702 case op_ldc_w:
703 {
704 int index = get2u (pc);
705 pc += 2;
706 // For an unresolved class we want to delay resolution
707 // until execution.
708 if (defining_class->constants.tags[index] == JV_CONSTANT_Class)
709 {
710 --next;
711 SET_INSN (insn_targets[int (op_jsr_w) + 1]);
712 SET_INT (index);
713 }
714 else
715 SET_DATUM (pool_data[index].o);
716 }
717 break;
718
719 case op_ldc2_w:
720 {
721 int index = get2u (pc);
722 pc += 2;
723 SET_DATUM (&pool_data[index]);
724 }
725 break;
726
727 case op_sipush:
728 SET_INT (get2s (pc));
729 pc += 2;
730 break;
731
732 case op_new:
733 case op_getstatic:
734 case op_getfield:
735 case op_putfield:
736 case op_putstatic:
737 case op_anewarray:
738 case op_instanceof:
739 case op_checkcast:
740 case op_invokespecial:
741 case op_invokestatic:
742 case op_invokevirtual:
743 SET_INT (get2u (pc));
744 pc += 2;
745 break;
746
747 case op_multianewarray:
748 SET_INT (get2u (pc));
749 SET_INT (get1u (pc + 2));
750 pc += 3;
751 break;
752
753 case op_jsr:
754 case op_ifeq:
755 case op_ifne:
756 case op_iflt:
757 case op_ifge:
758 case op_ifgt:
759 case op_ifle:
760 case op_if_icmpeq:
761 case op_if_icmpne:
762 case op_if_icmplt:
763 case op_if_icmpge:
764 case op_if_icmpgt:
765 case op_if_icmple:
766 case op_if_acmpeq:
767 case op_if_acmpne:
768 case op_ifnull:
769 case op_ifnonnull:
770 case op_goto:
771 {
772 int offset = get2s (pc);
773 pc += 2;
774
775 int new_pc = base_pc_val + offset;
776
777 bool orig_was_goto = opcode == op_goto;
778
779 // Thread jumps. We limit the loop count; this lets
780 // us avoid infinite loops if the bytecode contains
781 // such. `10' is arbitrary.
782 int count = 10;
783 while (codestart[new_pc] == op_goto && count-- > 0)
784 new_pc += get2s (&codestart[new_pc + 1]);
785
786 // If the jump takes us to a `return' instruction and
787 // the original branch was an unconditional goto, then
788 // we hoist the return.
789 opcode = (java_opcode) codestart[new_pc];
790 if (orig_was_goto
791 && (opcode == op_ireturn || opcode == op_lreturn
792 || opcode == op_freturn || opcode == op_dreturn
793 || opcode == op_areturn || opcode == op_return))
794 {
795 --next;
796 SET_INSN (insn_targets[opcode]);
797 }
798 else
799 SET_DATUM (&insns[pc_mapping[new_pc]]);
800 }
801 break;
802
803 case op_tableswitch:
804 {
805 while ((pc - codestart) % 4 != 0)
806 ++pc;
807
808 jint def = get4 (pc);
809 SET_DATUM (&insns[pc_mapping[base_pc_val + def]]);
810 pc += 4;
811
812 int low = get4 (pc);
813 SET_INT (low);
814 pc += 4;
815 int high = get4 (pc);
816 SET_INT (high);
817 pc += 4;
818
819 for (int i = low; i <= high; ++i)
820 {
821 SET_DATUM (&insns[pc_mapping[base_pc_val + get4 (pc)]]);
822 pc += 4;
823 }
824 }
825 break;
826
827 case op_lookupswitch:
828 {
829 while ((pc - codestart) % 4 != 0)
830 ++pc;
831
832 jint def = get4 (pc);
833 SET_DATUM (&insns[pc_mapping[base_pc_val + def]]);
834 pc += 4;
835
836 jint npairs = get4 (pc);
837 pc += 4;
838 SET_INT (npairs);
839
840 while (npairs-- > 0)
841 {
842 jint match = get4 (pc);
843 jint offset = get4 (pc + 4);
844 SET_INT (match);
845 SET_DATUM (&insns[pc_mapping[base_pc_val + offset]]);
846 pc += 8;
847 }
848 }
849 break;
850
851 case op_invokeinterface:
852 {
853 jint index = get2u (pc);
854 pc += 2;
855 // We ignore the next two bytes.
856 pc += 2;
857 SET_INT (index);
858 }
859 break;
860
861 case op_wide:
862 {
863 opcode = (java_opcode) get1u (pc);
864 pc += 1;
865 jint val = get2u (pc);
866 pc += 2;
867
868 // We implement narrow and wide instructions using the
869 // same code in the interpreter. So we rewrite the
870 // instruction slot here.
871 if (! first_pass)
872 insns[next - 1].insn = (void *) insn_targets[opcode];
873 SET_INT (val);
874
875 if (opcode == op_iinc)
876 {
877 SET_INT (get2s (pc));
878 pc += 2;
879 }
880 }
881 break;
882
883 case op_jsr_w:
884 case op_goto_w:
885 {
886 jint offset = get4 (pc);
887 pc += 4;
888 SET_DATUM (&insns[pc_mapping[base_pc_val + offset]]);
889 }
890 break;
891
892 // Some "can't happen" cases that we include for
893 // error-checking purposes.
894 case op_putfield_1:
895 case op_putfield_2:
896 case op_putfield_4:
897 case op_putfield_8:
898 case op_putfield_a:
899 case op_putstatic_1:
900 case op_putstatic_2:
901 case op_putstatic_4:
902 case op_putstatic_8:
903 case op_putstatic_a:
904 case op_getfield_1:
905 case op_getfield_2s:
906 case op_getfield_2u:
907 case op_getfield_4:
908 case op_getfield_8:
909 case op_getfield_a:
910 case op_getstatic_1:
911 case op_getstatic_2s:
912 case op_getstatic_2u:
913 case op_getstatic_4:
914 case op_getstatic_8:
915 case op_getstatic_a:
916 case op_breakpoint:
917 default:
918 // Fail somehow.
919 break;
920 }
921 }
922 }
923
924 // Now update exceptions.
925 _Jv_InterpException *exc = exceptions ();
926 for (int i = 0; i < exc_count; ++i)
927 {
928 exc[i].start_pc.p = &insns[pc_mapping[exc[i].start_pc.i]];
929 exc[i].end_pc.p = &insns[pc_mapping[exc[i].end_pc.i]];
930 exc[i].handler_pc.p = &insns[pc_mapping[exc[i].handler_pc.i]];
931 // FIXME: resolve_pool_entry can throw - we shouldn't be doing this
932 // during compilation.
933 jclass handler
934 = (_Jv_Linker::resolve_pool_entry (defining_class,
935 exc[i].handler_type.i)).clazz;
936 exc[i].handler_type.p = handler;
937 }
938
939 // Translate entries in the LineNumberTable from bytecode PC's to direct
940 // threaded interpreter instruction values.
941 for (int i = 0; i < line_table_len; i++)
942 {
943 int byte_pc = line_table[i].bytecode_pc;
944 // It isn't worth throwing an exception if this table is
945 // corrupted, but at the same time we don't want a crash.
946 if (byte_pc < 0 || byte_pc >= code_length)
947 byte_pc = 0;
948 line_table[i].pc = &insns[pc_mapping[byte_pc]];
949 }
950
951 prepared = insns;
952
953 // Now remap the variable table for this method.
954 for (int i = 0; i < local_var_table_len; ++i)
955 {
956 int start_byte = local_var_table[i].bytecode_pc;
957 if (start_byte < 0 || start_byte >= code_length)
958 start_byte = 0;
959 jlocation start = pc_mapping[start_byte];
960
961 int end_byte = start_byte + local_var_table[i].length;
962 if (end_byte < 0)
963 end_byte = 0;
964 jlocation end = ((end_byte >= code_length)
965 ? number_insn_slots
966 : pc_mapping[end_byte]);
967
968 local_var_table[i].pc = &insns[start];
969 local_var_table[i].length = end - start + 1;
970 }
971
972 if (breakpoint_insn == NULL)
973 {
974 bp_insn_slot.insn = const_cast<void *> (insn_targets[op_breakpoint]);
975 breakpoint_insn = &bp_insn_slot;
976 }
977 }
978 #endif /* DIRECT_THREADED */
979
980 /* Run the given method.
981 When args is NULL, don't run anything -- just compile it. */
982 void
run(void * retp,INTERP_FFI_RAW_TYPE * args,_Jv_InterpMethod * meth)983 _Jv_InterpMethod::run (void *retp, INTERP_FFI_RAW_TYPE *args,
984 _Jv_InterpMethod *meth)
985 {
986 #undef __GCJ_DEBUG
987 #undef DEBUG_LOCALS_INSN
988 #define DEBUG_LOCALS_INSN(s, t) do {} while (0)
989
990 #include "interpret-run.cc"
991 }
992
993 void
run_debug(void * retp,INTERP_FFI_RAW_TYPE * args,_Jv_InterpMethod * meth)994 _Jv_InterpMethod::run_debug (void *retp, INTERP_FFI_RAW_TYPE *args,
995 _Jv_InterpMethod *meth)
996 {
997 #define __GCJ_DEBUG
998 #undef DEBUG_LOCALS_INSN
999 #define DEBUG_LOCALS_INSN(s, t) \
1000 do \
1001 { \
1002 frame_desc.locals_type[s] = t; \
1003 } \
1004 while (0)
1005
1006 #include "interpret-run.cc"
1007 }
1008
1009 static void
throw_internal_error(const char * msg)1010 throw_internal_error (const char *msg)
1011 {
1012 jthrowable t = new java::lang::InternalError (JvNewStringLatin1 (msg));
1013 REPORT_EXCEPTION (t);
1014 throw t;
1015 }
1016
1017 static void
throw_incompatible_class_change_error(jstring msg)1018 throw_incompatible_class_change_error (jstring msg)
1019 {
1020 jthrowable t = new java::lang::IncompatibleClassChangeError (msg);
1021 REPORT_EXCEPTION (t);
1022 throw t;
1023 }
1024
1025 static void
throw_null_pointer_exception()1026 throw_null_pointer_exception ()
1027 {
1028 jthrowable t = new java::lang::NullPointerException;
1029 REPORT_EXCEPTION (t);
1030 throw t;
1031 }
1032
1033 /* Look up source code line number for given bytecode (or direct threaded
1034 interpreter) PC. */
1035 int
get_source_line(pc_t mpc)1036 _Jv_InterpMethod::get_source_line(pc_t mpc)
1037 {
1038 int line = line_table_len > 0 ? line_table[0].line : -1;
1039 for (int i = 1; i < line_table_len; i++)
1040 if (line_table[i].pc > mpc)
1041 break;
1042 else
1043 line = line_table[i].line;
1044
1045 return line;
1046 }
1047
1048 /** Do static initialization for fields with a constant initializer */
1049 void
_Jv_InitField(jobject obj,jclass klass,int index)1050 _Jv_InitField (jobject obj, jclass klass, int index)
1051 {
1052 using namespace java::lang::reflect;
1053
1054 if (obj != 0 && klass == 0)
1055 klass = obj->getClass ();
1056
1057 if (!_Jv_IsInterpretedClass (klass))
1058 return;
1059
1060 _Jv_InterpClass *iclass = (_Jv_InterpClass*)klass->aux_info;
1061
1062 _Jv_Field * field = (&klass->fields[0]) + index;
1063
1064 if (index > klass->field_count)
1065 throw_internal_error ("field out of range");
1066
1067 int init = iclass->field_initializers[index];
1068 if (init == 0)
1069 return;
1070
1071 _Jv_Constants *pool = &klass->constants;
1072 int tag = pool->tags[init];
1073
1074 if (! field->isResolved ())
1075 throw_internal_error ("initializing unresolved field");
1076
1077 if (obj==0 && ((field->flags & Modifier::STATIC) == 0))
1078 throw_internal_error ("initializing non-static field with no object");
1079
1080 void *addr = 0;
1081
1082 if ((field->flags & Modifier::STATIC) != 0)
1083 addr = (void*) field->u.addr;
1084 else
1085 addr = (void*) (((char*)obj) + field->u.boffset);
1086
1087 switch (tag)
1088 {
1089 case JV_CONSTANT_String:
1090 {
1091 jstring str;
1092 str = _Jv_NewStringUtf8Const (pool->data[init].utf8);
1093 pool->data[init].string = str;
1094 pool->tags[init] = JV_CONSTANT_ResolvedString;
1095 }
1096 /* fall through */
1097
1098 case JV_CONSTANT_ResolvedString:
1099 if (! (field->type == &java::lang::String::class$
1100 || field->type == &java::lang::Class::class$))
1101 throw_class_format_error ("string initialiser to non-string field");
1102
1103 *(jstring*)addr = pool->data[init].string;
1104 break;
1105
1106 case JV_CONSTANT_Integer:
1107 {
1108 int value = pool->data[init].i;
1109
1110 if (field->type == JvPrimClass (boolean))
1111 *(jboolean*)addr = (jboolean)value;
1112
1113 else if (field->type == JvPrimClass (byte))
1114 *(jbyte*)addr = (jbyte)value;
1115
1116 else if (field->type == JvPrimClass (char))
1117 *(jchar*)addr = (jchar)value;
1118
1119 else if (field->type == JvPrimClass (short))
1120 *(jshort*)addr = (jshort)value;
1121
1122 else if (field->type == JvPrimClass (int))
1123 *(jint*)addr = (jint)value;
1124
1125 else
1126 throw_class_format_error ("erroneous field initializer");
1127 }
1128 break;
1129
1130 case JV_CONSTANT_Long:
1131 if (field->type != JvPrimClass (long))
1132 throw_class_format_error ("erroneous field initializer");
1133
1134 *(jlong*)addr = _Jv_loadLong (&pool->data[init]);
1135 break;
1136
1137 case JV_CONSTANT_Float:
1138 if (field->type != JvPrimClass (float))
1139 throw_class_format_error ("erroneous field initializer");
1140
1141 *(jfloat*)addr = pool->data[init].f;
1142 break;
1143
1144 case JV_CONSTANT_Double:
1145 if (field->type != JvPrimClass (double))
1146 throw_class_format_error ("erroneous field initializer");
1147
1148 *(jdouble*)addr = _Jv_loadDouble (&pool->data[init]);
1149 break;
1150
1151 default:
1152 throw_class_format_error ("erroneous field initializer");
1153 }
1154 }
1155
1156 inline static unsigned char*
skip_one_type(unsigned char * ptr)1157 skip_one_type (unsigned char* ptr)
1158 {
1159 int ch = *ptr++;
1160
1161 while (ch == '[')
1162 {
1163 ch = *ptr++;
1164 }
1165
1166 if (ch == 'L')
1167 {
1168 do { ch = *ptr++; } while (ch != ';');
1169 }
1170
1171 return ptr;
1172 }
1173
1174 static ffi_type*
get_ffi_type_from_signature(unsigned char * ptr)1175 get_ffi_type_from_signature (unsigned char* ptr)
1176 {
1177 switch (*ptr)
1178 {
1179 case 'L':
1180 case '[':
1181 return &ffi_type_pointer;
1182 break;
1183
1184 case 'Z':
1185 // On some platforms a bool is a byte, on others an int.
1186 if (sizeof (jboolean) == sizeof (jbyte))
1187 return &ffi_type_sint8;
1188 else
1189 {
1190 JvAssert (sizeof (jbyte) == sizeof (jint));
1191 return &ffi_type_sint32;
1192 }
1193 break;
1194
1195 case 'B':
1196 return &ffi_type_sint8;
1197 break;
1198
1199 case 'C':
1200 return &ffi_type_uint16;
1201 break;
1202
1203 case 'S':
1204 return &ffi_type_sint16;
1205 break;
1206
1207 case 'I':
1208 return &ffi_type_sint32;
1209 break;
1210
1211 case 'J':
1212 return &ffi_type_sint64;
1213 break;
1214
1215 case 'F':
1216 return &ffi_type_float;
1217 break;
1218
1219 case 'D':
1220 return &ffi_type_double;
1221 break;
1222
1223 case 'V':
1224 return &ffi_type_void;
1225 break;
1226 }
1227
1228 throw_internal_error ("unknown type in signature");
1229 }
1230
1231 /* this function yields the number of actual arguments, that is, if the
1232 * function is non-static, then one is added to the number of elements
1233 * found in the signature */
1234
1235 int
_Jv_count_arguments(_Jv_Utf8Const * signature,jboolean staticp)1236 _Jv_count_arguments (_Jv_Utf8Const *signature,
1237 jboolean staticp)
1238 {
1239 unsigned char *ptr = (unsigned char*) signature->chars();
1240 int arg_count = staticp ? 0 : 1;
1241
1242 /* first, count number of arguments */
1243
1244 // skip '('
1245 ptr++;
1246
1247 // count args
1248 while (*ptr != ')')
1249 {
1250 ptr = skip_one_type (ptr);
1251 arg_count += 1;
1252 }
1253
1254 return arg_count;
1255 }
1256
1257 /* This beast will build a cif, given the signature. Memory for
1258 * the cif itself and for the argument types must be allocated by the
1259 * caller.
1260 */
1261
1262 int
_Jv_init_cif(_Jv_Utf8Const * signature,int arg_count,jboolean staticp,ffi_cif * cif,ffi_type ** arg_types,ffi_type ** rtype_p)1263 _Jv_init_cif (_Jv_Utf8Const* signature,
1264 int arg_count,
1265 jboolean staticp,
1266 ffi_cif *cif,
1267 ffi_type **arg_types,
1268 ffi_type **rtype_p)
1269 {
1270 unsigned char *ptr = (unsigned char*) signature->chars();
1271
1272 int arg_index = 0; // arg number
1273 int item_count = 0; // stack-item count
1274
1275 // setup receiver
1276 if (!staticp)
1277 {
1278 arg_types[arg_index++] = &ffi_type_pointer;
1279 item_count += 1;
1280 }
1281
1282 // skip '('
1283 ptr++;
1284
1285 // assign arg types
1286 while (*ptr != ')')
1287 {
1288 arg_types[arg_index++] = get_ffi_type_from_signature (ptr);
1289
1290 if (*ptr == 'J' || *ptr == 'D')
1291 item_count += 2;
1292 else
1293 item_count += 1;
1294
1295 ptr = skip_one_type (ptr);
1296 }
1297
1298 // skip ')'
1299 ptr++;
1300 ffi_type *rtype = get_ffi_type_from_signature (ptr);
1301
1302 ptr = skip_one_type (ptr);
1303 if (ptr != (unsigned char*)signature->chars() + signature->len())
1304 throw_internal_error ("did not find end of signature");
1305
1306 ffi_abi cabi = FFI_DEFAULT_ABI;
1307 #if defined (X86_WIN32) && !defined (__CYGWIN__)
1308 if (!staticp)
1309 cabi = FFI_THISCALL;
1310 #endif
1311 if (ffi_prep_cif (cif, cabi,
1312 arg_count, rtype, arg_types) != FFI_OK)
1313 throw_internal_error ("ffi_prep_cif failed");
1314
1315 if (rtype_p != NULL)
1316 *rtype_p = rtype;
1317
1318 return item_count;
1319 }
1320
1321 /* we put this one here, and not in interpret.cc because it
1322 * calls the utility routines _Jv_count_arguments
1323 * which are static to this module. The following struct defines the
1324 * layout we use for the stubs, it's only used in the ncode method. */
1325
1326 #if FFI_NATIVE_RAW_API
1327 # define FFI_PREP_RAW_CLOSURE ffi_prep_raw_closure_loc
1328 # define FFI_RAW_SIZE ffi_raw_size
1329 typedef struct {
1330 ffi_raw_closure closure;
1331 _Jv_ClosureList list;
1332 ffi_cif cif;
1333 ffi_type *arg_types[0];
1334 } ncode_closure;
1335 typedef void (*ffi_closure_fun) (ffi_cif*,void*,INTERP_FFI_RAW_TYPE*,void*);
1336 #else
1337 # define FFI_PREP_RAW_CLOSURE ffi_prep_java_raw_closure_loc
1338 # define FFI_RAW_SIZE ffi_java_raw_size
1339 typedef struct {
1340 ffi_java_raw_closure closure;
1341 _Jv_ClosureList list;
1342 ffi_cif cif;
1343 ffi_type *arg_types[0];
1344 } ncode_closure;
1345 typedef void (*ffi_closure_fun) (ffi_cif*,void*,ffi_java_raw*,void*);
1346 #endif
1347
1348 void *
ncode(jclass klass)1349 _Jv_InterpMethod::ncode (jclass klass)
1350 {
1351 using namespace java::lang::reflect;
1352
1353 if (self->ncode != 0)
1354 return self->ncode;
1355
1356 jboolean staticp = (self->accflags & Modifier::STATIC) != 0;
1357 int arg_count = _Jv_count_arguments (self->signature, staticp);
1358
1359 void *code;
1360 ncode_closure *closure =
1361 (ncode_closure*)ffi_closure_alloc (sizeof (ncode_closure)
1362 + arg_count * sizeof (ffi_type*),
1363 &code);
1364 closure->list.registerClosure (klass, closure);
1365
1366 _Jv_init_cif (self->signature,
1367 arg_count,
1368 staticp,
1369 &closure->cif,
1370 &closure->arg_types[0],
1371 NULL);
1372
1373 ffi_closure_fun fun;
1374
1375 args_raw_size = FFI_RAW_SIZE (&closure->cif);
1376
1377 JvAssert ((self->accflags & Modifier::NATIVE) == 0);
1378
1379 if ((self->accflags & Modifier::SYNCHRONIZED) != 0)
1380 {
1381 if (staticp)
1382 {
1383 if (JVMTI::enabled)
1384 fun = (ffi_closure_fun)&_Jv_InterpMethod::run_synch_class_debug;
1385 else
1386 fun = (ffi_closure_fun)&_Jv_InterpMethod::run_synch_class;
1387 }
1388 else
1389 {
1390 if (JVMTI::enabled)
1391 fun = (ffi_closure_fun)&_Jv_InterpMethod::run_synch_object_debug;
1392 else
1393 fun = (ffi_closure_fun)&_Jv_InterpMethod::run_synch_object;
1394 }
1395 }
1396 else
1397 {
1398 if (staticp)
1399 {
1400 if (JVMTI::enabled)
1401 fun = (ffi_closure_fun)&_Jv_InterpMethod::run_class_debug;
1402 else
1403 fun = (ffi_closure_fun)&_Jv_InterpMethod::run_class;
1404 }
1405 else
1406 {
1407 if (JVMTI::enabled)
1408 fun = (ffi_closure_fun)&_Jv_InterpMethod::run_normal_debug;
1409 else
1410 fun = (ffi_closure_fun)&_Jv_InterpMethod::run_normal;
1411 }
1412 }
1413
1414 FFI_PREP_RAW_CLOSURE (&closure->closure,
1415 &closure->cif,
1416 fun,
1417 (void*)this,
1418 code);
1419
1420 self->ncode = code;
1421
1422 return self->ncode;
1423 }
1424
1425 /* Find the index of the given insn in the array of insn slots
1426 for this method. Returns -1 if not found. */
1427 jlong
insn_index(pc_t pc)1428 _Jv_InterpMethod::insn_index (pc_t pc)
1429 {
1430 jlong left = 0;
1431 #ifdef DIRECT_THREADED
1432 jlong right = number_insn_slots;
1433 pc_t insns = prepared;
1434 #else
1435 jlong right = code_length;
1436 pc_t insns = bytecode ();
1437 #endif
1438
1439 while (right >= 0)
1440 {
1441 jlong mid = (left + right) / 2;
1442 if (&insns[mid] == pc)
1443 return mid;
1444
1445 if (pc < &insns[mid])
1446 right = mid - 1;
1447 else
1448 left = mid + 1;
1449 }
1450
1451 return -1;
1452 }
1453
1454 // Method to check if an exception is caught at some location in a method
1455 // (meth). Returns true if this method (meth) contains a catch block for the
1456 // exception (ex). False otherwise. If there is a catch block, it sets the pc
1457 // to the location of the beginning of the catch block.
1458 jboolean
check_handler(pc_t * pc,_Jv_InterpMethod * meth,java::lang::Throwable * ex)1459 _Jv_InterpMethod::check_handler (pc_t *pc, _Jv_InterpMethod *meth,
1460 java::lang::Throwable *ex)
1461 {
1462 #ifdef DIRECT_THREADED
1463 void *logical_pc = (void *) ((insn_slot *) (*pc) - 1);
1464 #else
1465 int logical_pc = (*pc) - 1 - meth->bytecode ();
1466 #endif
1467 _Jv_InterpException *exc = meth->exceptions ();
1468 jclass exc_class = ex->getClass ();
1469
1470 for (int i = 0; i < meth->exc_count; i++)
1471 {
1472 if (PCVAL (exc[i].start_pc) <= logical_pc
1473 && logical_pc < PCVAL (exc[i].end_pc))
1474 {
1475 #ifdef DIRECT_THREADED
1476 jclass handler = (jclass) exc[i].handler_type.p;
1477 #else
1478 jclass handler = NULL;
1479 if (exc[i].handler_type.i != 0)
1480 handler
1481 = (_Jv_Linker::resolve_pool_entry (meth->defining_class,
1482 exc[i].handler_type.i)).clazz;
1483 #endif /* DIRECT_THREADED */
1484 if (handler == NULL || handler->isAssignableFrom (exc_class))
1485 {
1486 #ifdef DIRECT_THREADED
1487 (*pc) = (insn_slot *) exc[i].handler_pc.p;
1488 #else
1489 (*pc) = meth->bytecode () + exc[i].handler_pc.i;
1490 #endif /* DIRECT_THREADED */
1491 return true;
1492 }
1493 }
1494 }
1495 return false;
1496 }
1497
1498
1499 void
get_line_table(jlong & start,jlong & end,jintArray & line_numbers,jlongArray & code_indices)1500 _Jv_InterpMethod::get_line_table (jlong& start, jlong& end,
1501 jintArray& line_numbers,
1502 jlongArray& code_indices)
1503 {
1504 #ifdef DIRECT_THREADED
1505 /* For the DIRECT_THREADED case, if the method has not yet been
1506 * compiled, the linetable will change to insn slots instead of
1507 * bytecode PCs. It is probably easiest, in this case, to simply
1508 * compile the method and guarantee that we are using insn
1509 * slots.
1510 */
1511 _Jv_CompileMethod (this);
1512
1513 if (line_table_len > 0)
1514 {
1515 start = 0;
1516 end = number_insn_slots;
1517 line_numbers = JvNewIntArray (line_table_len);
1518 code_indices = JvNewLongArray (line_table_len);
1519
1520 jint* lines = elements (line_numbers);
1521 jlong* indices = elements (code_indices);
1522 for (int i = 0; i < line_table_len; ++i)
1523 {
1524 lines[i] = line_table[i].line;
1525 indices[i] = insn_index (line_table[i].pc);
1526 }
1527 }
1528 #else // !DIRECT_THREADED
1529 if (line_table_len > 0)
1530 {
1531 start = 0;
1532 end = code_length;
1533 line_numbers = JvNewIntArray (line_table_len);
1534 code_indices = JvNewLongArray (line_table_len);
1535
1536 jint* lines = elements (line_numbers);
1537 jlong* indices = elements (code_indices);
1538 for (int i = 0; i < line_table_len; ++i)
1539 {
1540 lines[i] = line_table[i].line;
1541 indices[i] = (jlong) line_table[i].bytecode_pc;
1542 }
1543 }
1544 #endif // !DIRECT_THREADED
1545 }
1546
1547 int
get_local_var_table(char ** name,char ** sig,char ** generic_sig,jlong * startloc,jint * length,jint * slot,int table_slot)1548 _Jv_InterpMethod::get_local_var_table (char **name, char **sig,
1549 char **generic_sig, jlong *startloc,
1550 jint *length, jint *slot,
1551 int table_slot)
1552 {
1553 #ifdef DIRECT_THREADED
1554 _Jv_CompileMethod (this);
1555 #endif
1556
1557 if (local_var_table == NULL)
1558 return -2;
1559 if (table_slot >= local_var_table_len)
1560 return -1;
1561 else
1562 {
1563 *name = local_var_table[table_slot].name;
1564 *sig = local_var_table[table_slot].descriptor;
1565 *generic_sig = local_var_table[table_slot].descriptor;
1566
1567 #ifdef DIRECT_THREADED
1568 *startloc = insn_index (local_var_table[table_slot].pc);
1569 #else
1570 *startloc = static_cast<jlong> (local_var_table[table_slot].bytecode_pc);
1571 #endif
1572 *length = static_cast<jint> (local_var_table[table_slot].length);
1573 *slot = static_cast<jint> (local_var_table[table_slot].slot);
1574 }
1575 return local_var_table_len - table_slot - 1;
1576 }
1577
1578 pc_t
install_break(jlong index)1579 _Jv_InterpMethod::install_break (jlong index)
1580 {
1581 return set_insn (index, breakpoint_insn);
1582 }
1583
1584 pc_t
get_insn(jlong index)1585 _Jv_InterpMethod::get_insn (jlong index)
1586 {
1587 pc_t code;
1588
1589 #ifdef DIRECT_THREADED
1590 if (index >= number_insn_slots || index < 0)
1591 return NULL;
1592
1593 code = prepared;
1594 #else // !DIRECT_THREADED
1595 if (index >= code_length || index < 0)
1596 return NULL;
1597
1598 code = reinterpret_cast<pc_t> (bytecode ());
1599 #endif // !DIRECT_THREADED
1600
1601 return &code[index];
1602 }
1603
1604 pc_t
set_insn(jlong index,pc_t insn)1605 _Jv_InterpMethod::set_insn (jlong index, pc_t insn)
1606 {
1607 #ifdef DIRECT_THREADED
1608 if (index >= number_insn_slots || index < 0)
1609 return NULL;
1610
1611 pc_t code = prepared;
1612 code[index].insn = insn->insn;
1613 #else // !DIRECT_THREADED
1614 if (index >= code_length || index < 0)
1615 return NULL;
1616
1617 pc_t code = reinterpret_cast<pc_t> (bytecode ());
1618 code[index] = *insn;
1619 #endif // !DIRECT_THREADED
1620
1621 return &code[index];
1622 }
1623
1624 bool
breakpoint_at(jlong index)1625 _Jv_InterpMethod::breakpoint_at (jlong index)
1626 {
1627 pc_t insn = get_insn (index);
1628 if (insn != NULL)
1629 {
1630 #ifdef DIRECT_THREADED
1631 return (insn->insn == breakpoint_insn->insn);
1632 #else
1633 pc_t code = reinterpret_cast<pc_t> (bytecode ());
1634 return (code[index] == bp_insn_opcode);
1635 #endif
1636 }
1637
1638 return false;
1639 }
1640
1641 void *
ncode(jclass klass)1642 _Jv_JNIMethod::ncode (jclass klass)
1643 {
1644 using namespace java::lang::reflect;
1645
1646 if (self->ncode != 0)
1647 return self->ncode;
1648
1649 jboolean staticp = (self->accflags & Modifier::STATIC) != 0;
1650 int arg_count = _Jv_count_arguments (self->signature, staticp);
1651
1652 void *code;
1653 ncode_closure *closure =
1654 (ncode_closure*)ffi_closure_alloc (sizeof (ncode_closure)
1655 + arg_count * sizeof (ffi_type*),
1656 &code);
1657 closure->list.registerClosure (klass, closure);
1658
1659 ffi_type *rtype;
1660 _Jv_init_cif (self->signature,
1661 arg_count,
1662 staticp,
1663 &closure->cif,
1664 &closure->arg_types[0],
1665 &rtype);
1666
1667 ffi_closure_fun fun;
1668
1669 args_raw_size = FFI_RAW_SIZE (&closure->cif);
1670
1671 // Initialize the argument types and CIF that represent the actual
1672 // underlying JNI function.
1673 int extra_args = 1;
1674 if ((self->accflags & Modifier::STATIC))
1675 ++extra_args;
1676 jni_arg_types = (ffi_type **) _Jv_AllocBytes ((extra_args + arg_count)
1677 * sizeof (ffi_type *));
1678 int offset = 0;
1679 jni_arg_types[offset++] = &ffi_type_pointer;
1680 if ((self->accflags & Modifier::STATIC))
1681 jni_arg_types[offset++] = &ffi_type_pointer;
1682 memcpy (&jni_arg_types[offset], &closure->arg_types[0],
1683 arg_count * sizeof (ffi_type *));
1684
1685 if (ffi_prep_cif (&jni_cif, _Jv_platform_ffi_abi,
1686 extra_args + arg_count, rtype,
1687 jni_arg_types) != FFI_OK)
1688 throw_internal_error ("ffi_prep_cif failed for JNI function");
1689
1690 JvAssert ((self->accflags & Modifier::NATIVE) != 0);
1691
1692 // FIXME: for now we assume that all native methods for
1693 // interpreted code use JNI.
1694 fun = (ffi_closure_fun) &_Jv_JNIMethod::call;
1695
1696 FFI_PREP_RAW_CLOSURE (&closure->closure,
1697 &closure->cif,
1698 fun,
1699 (void*) this,
1700 code);
1701
1702 self->ncode = code;
1703 return self->ncode;
1704 }
1705
1706 static void
throw_class_format_error(jstring msg)1707 throw_class_format_error (jstring msg)
1708 {
1709 jthrowable t = (msg
1710 ? new java::lang::ClassFormatError (msg)
1711 : new java::lang::ClassFormatError);
1712 REPORT_EXCEPTION (t);
1713 throw t;
1714 }
1715
1716 static void
throw_class_format_error(const char * msg)1717 throw_class_format_error (const char *msg)
1718 {
1719 throw_class_format_error (JvNewStringLatin1 (msg));
1720 }
1721
1722 /* This function finds the method and location where the exception EXC
1723 is caught in the stack frame. On return, it sets CATCH_METHOD and
1724 CATCH_LOCATION with the method and location where the catch will
1725 occur. If the exception is not caught, these are set to 0.
1726
1727 This function should only be used with the __GCJ_DEBUG interpreter. */
1728 static void
find_catch_location(::java::lang::Throwable * exc,jthread thread,jmethodID * catch_method,jlong * catch_loc)1729 find_catch_location (::java::lang::Throwable *exc, jthread thread,
1730 jmethodID *catch_method, jlong *catch_loc)
1731 {
1732 *catch_method = 0;
1733 *catch_loc = 0;
1734
1735 _Jv_InterpFrame *frame
1736 = reinterpret_cast<_Jv_InterpFrame *> (thread->interp_frame);
1737 while (frame != NULL)
1738 {
1739 pc_t pc = frame->get_pc ();
1740 _Jv_InterpMethod *imeth
1741 = reinterpret_cast<_Jv_InterpMethod *> (frame->self);
1742 if (imeth->check_handler (&pc, imeth, exc))
1743 {
1744 // This method handles the exception.
1745 *catch_method = imeth->get_method ();
1746 *catch_loc = imeth->insn_index (pc);
1747 return;
1748 }
1749
1750 frame = frame->next_interp;
1751 }
1752 }
1753
1754 /* This method handles JVMTI notifications of thrown exceptions. It
1755 calls find_catch_location to figure out where the exception is
1756 caught (if it is caught).
1757
1758 Like find_catch_location, this should only be called with the
1759 __GCJ_DEBUG interpreter. Since a few exceptions occur outside the
1760 interpreter proper, it is important to not call this function
1761 without checking JVMTI_REQUESTED_EVENT(Exception) first. */
1762 void
_Jv_ReportJVMTIExceptionThrow(jthrowable ex)1763 _Jv_ReportJVMTIExceptionThrow (jthrowable ex)
1764 {
1765 jthread thread = ::java::lang::Thread::currentThread ();
1766 _Jv_Frame *frame = reinterpret_cast<_Jv_Frame *> (thread->frame);
1767 jmethodID throw_meth = frame->self->get_method ();
1768 jlocation throw_loc = -1;
1769 if (frame->frame_type == frame_interpreter)
1770 {
1771 _Jv_InterpFrame * iframe
1772 = reinterpret_cast<_Jv_InterpFrame *> (frame);
1773 _Jv_InterpMethod *imeth
1774 = reinterpret_cast<_Jv_InterpMethod *> (frame->self);
1775 throw_loc = imeth->insn_index (iframe->get_pc ());
1776 }
1777
1778 jlong catch_loc;
1779 jmethodID catch_method;
1780 find_catch_location (ex, thread, &catch_method, &catch_loc);
1781 _Jv_JVMTI_PostEvent (JVMTI_EVENT_EXCEPTION, thread,
1782 _Jv_GetCurrentJNIEnv (), throw_meth, throw_loc,
1783 ex, catch_method, catch_loc);
1784 }
1785
1786
1787
1788 void
do_verify(jclass klass)1789 _Jv_InterpreterEngine::do_verify (jclass klass)
1790 {
1791 _Jv_InterpClass *iclass = (_Jv_InterpClass *) klass->aux_info;
1792 for (int i = 0; i < klass->method_count; i++)
1793 {
1794 using namespace java::lang::reflect;
1795 _Jv_MethodBase *imeth = iclass->interpreted_methods[i];
1796 _Jv_ushort accflags = klass->methods[i].accflags;
1797 if ((accflags & (Modifier::NATIVE | Modifier::ABSTRACT)) == 0)
1798 {
1799 _Jv_InterpMethod *im = reinterpret_cast<_Jv_InterpMethod *> (imeth);
1800 _Jv_VerifyMethod (im);
1801 }
1802 }
1803 }
1804
1805 void
do_create_ncode(jclass klass)1806 _Jv_InterpreterEngine::do_create_ncode (jclass klass)
1807 {
1808 _Jv_InterpClass *iclass = (_Jv_InterpClass *) klass->aux_info;
1809 for (int i = 0; i < klass->method_count; i++)
1810 {
1811 // Just skip abstract methods. This is particularly important
1812 // because we don't resize the interpreted_methods array when
1813 // miranda methods are added to it.
1814 if ((klass->methods[i].accflags
1815 & java::lang::reflect::Modifier::ABSTRACT)
1816 != 0)
1817 continue;
1818
1819 _Jv_MethodBase *imeth = iclass->interpreted_methods[i];
1820
1821 if ((klass->methods[i].accflags & java::lang::reflect::Modifier::NATIVE)
1822 != 0)
1823 {
1824 // You might think we could use a virtual `ncode' method in
1825 // the _Jv_MethodBase and unify the native and non-native
1826 // cases. Well, we can't, because we don't allocate these
1827 // objects using `new', and thus they don't get a vtable.
1828 _Jv_JNIMethod *jnim = reinterpret_cast<_Jv_JNIMethod *> (imeth);
1829 klass->methods[i].ncode = jnim->ncode (klass);
1830 }
1831 else if (imeth != 0) // it could be abstract
1832 {
1833 _Jv_InterpMethod *im = reinterpret_cast<_Jv_InterpMethod *> (imeth);
1834 klass->methods[i].ncode = im->ncode (klass);
1835 }
1836 }
1837 }
1838
1839 _Jv_ClosureList **
do_get_closure_list(jclass klass)1840 _Jv_InterpreterEngine::do_get_closure_list (jclass klass)
1841 {
1842 _Jv_InterpClass *iclass = (_Jv_InterpClass *) klass->aux_info;
1843
1844 if (!iclass->closures)
1845 iclass->closures = _Jv_ClosureListFinalizer ();
1846
1847 return iclass->closures;
1848 }
1849
1850 void
do_allocate_static_fields(jclass klass,int pointer_size,int other_size)1851 _Jv_InterpreterEngine::do_allocate_static_fields (jclass klass,
1852 int pointer_size,
1853 int other_size)
1854 {
1855 _Jv_InterpClass *iclass = (_Jv_InterpClass *) klass->aux_info;
1856
1857 // Splitting the allocations here lets us scan reference fields and
1858 // avoid scanning non-reference fields. How reference fields are
1859 // scanned is a bit tricky: we allocate using _Jv_AllocRawObj, which
1860 // means that this memory will be scanned conservatively (same
1861 // difference, since we know all the contents here are pointers).
1862 // Then we put pointers into this memory into the 'fields'
1863 // structure. Most of these are interior pointers, which is ok (but
1864 // even so the pointer to the first reference field will be used and
1865 // that is not an interior pointer). The 'fields' array is also
1866 // allocated with _Jv_AllocRawObj (see defineclass.cc), so it will
1867 // be scanned. A pointer to this array is held by Class and thus
1868 // seen by the collector.
1869 char *reference_fields = (char *) _Jv_AllocRawObj (pointer_size);
1870 char *non_reference_fields = (char *) _Jv_AllocBytes (other_size);
1871
1872 for (int i = 0; i < klass->field_count; i++)
1873 {
1874 _Jv_Field *field = &klass->fields[i];
1875
1876 if ((field->flags & java::lang::reflect::Modifier::STATIC) == 0)
1877 continue;
1878
1879 char *base = field->isRef() ? reference_fields : non_reference_fields;
1880 field->u.addr = base + field->u.boffset;
1881
1882 if (iclass->field_initializers[i] != 0)
1883 {
1884 _Jv_Linker::resolve_field (field, klass->loader);
1885 _Jv_InitField (0, klass, i);
1886 }
1887 }
1888
1889 // Now we don't need the field_initializers anymore, so let the
1890 // collector get rid of it.
1891 iclass->field_initializers = 0;
1892 }
1893
1894 _Jv_ResolvedMethod *
do_resolve_method(_Jv_Method * method,jclass klass,jboolean staticp)1895 _Jv_InterpreterEngine::do_resolve_method (_Jv_Method *method, jclass klass,
1896 jboolean staticp)
1897 {
1898 int arg_count = _Jv_count_arguments (method->signature, staticp);
1899
1900 _Jv_ResolvedMethod* result = (_Jv_ResolvedMethod*)
1901 _Jv_AllocBytes (sizeof (_Jv_ResolvedMethod)
1902 + arg_count*sizeof (ffi_type*));
1903
1904 result->stack_item_count
1905 = _Jv_init_cif (method->signature,
1906 arg_count,
1907 staticp,
1908 &result->cif,
1909 &result->arg_types[0],
1910 NULL);
1911
1912 result->method = method;
1913 result->klass = klass;
1914
1915 return result;
1916 }
1917
1918 void
do_post_miranda_hook(jclass klass)1919 _Jv_InterpreterEngine::do_post_miranda_hook (jclass klass)
1920 {
1921 _Jv_InterpClass *iclass = (_Jv_InterpClass *) klass->aux_info;
1922 for (int i = 0; i < klass->method_count; i++)
1923 {
1924 // Just skip abstract methods. This is particularly important
1925 // because we don't resize the interpreted_methods array when
1926 // miranda methods are added to it.
1927 if ((klass->methods[i].accflags
1928 & java::lang::reflect::Modifier::ABSTRACT)
1929 != 0)
1930 continue;
1931 // Miranda method additions mean that the `methods' array moves.
1932 // We cache a pointer into this array, so we have to update.
1933 iclass->interpreted_methods[i]->self = &klass->methods[i];
1934 }
1935 }
1936
1937 #ifdef DIRECT_THREADED
1938 void
_Jv_CompileMethod(_Jv_InterpMethod * method)1939 _Jv_CompileMethod (_Jv_InterpMethod* method)
1940 {
1941 if (method->prepared == NULL)
1942 {
1943 if (JVMTI::enabled)
1944 _Jv_InterpMethod::run_debug (NULL, NULL, method);
1945 else
1946 _Jv_InterpMethod::run (NULL, NULL, method);
1947 }
1948 }
1949 #endif // DIRECT_THREADED
1950