libjava/interpret.cc

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