Logo Search packages:      
Sourcecode: sablevm version File versions  Download package

instructions_switch.c

/* This file has been automatically generated from "instructions.m4.c" */

/*
----------------------------------------------------------------------
BIPUSH
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_BIPUSH:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p BIPUSH]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      /* this bytecode should have been replaced by another code */
      _svmm_fatal_error ("impossible control flow");

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
SIPUSH
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_SIPUSH:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p SIPUSH]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      /* this bytecode should have been replaced by another code */
      _svmm_fatal_error ("impossible control flow");

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
LDC
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_LDC:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p LDC]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      /* this bytecode should have been replaced by another code */
      _svmm_fatal_error ("impossible control flow");

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
LDC_W
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_LDC_W:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p LDC_W]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      /* this bytecode should have been replaced by another code */
      _svmm_fatal_error ("impossible control flow");

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
LDC2_W
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_LDC2_W:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p LDC2_W]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      /* this bytecode should have been replaced by another code */
      _svmm_fatal_error ("impossible control flow");

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
GETSTATIC
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_GETSTATIC:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p GETSTATIC]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      /* this bytecode should have been replaced by another code */
      _svmm_fatal_error ("impossible control flow");

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PUTSTATIC
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PUTSTATIC:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PUTSTATIC]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      /* this bytecode should have been replaced by another code */
      _svmm_fatal_error ("impossible control flow");

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
GETFIELD
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_GETFIELD:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p GETFIELD]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      /* this bytecode should have been replaced by another code */
      _svmm_fatal_error ("impossible control flow");

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PUTFIELD
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PUTFIELD:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PUTFIELD]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      /* this bytecode should have been replaced by another code */
      _svmm_fatal_error ("impossible control flow");

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
NEWARRAY
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_NEWARRAY:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p NEWARRAY]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      /* this bytecode should have been replaced by another code */
      _svmm_fatal_error ("impossible control flow");

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
WIDE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_WIDE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p WIDE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      /* this bytecode should have been replaced by another code */
      _svmm_fatal_error ("impossible control flow");

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
GOTO_W
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_GOTO_W:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p GOTO_W]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      /* this bytecode should have been replaced by another code */
      _svmm_fatal_error ("impossible control flow");

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
JSR_W
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_JSR_W:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p JSR_W]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      /* this bytecode should have been replaced by another code */
      _svmm_fatal_error ("impossible control flow");

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
NOP
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_NOP:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p NOP]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ACONST_NULL
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ACONST_NULL:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ACONST_NULL]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      stack[stack_size++].reference = NULL;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ICONST_M1
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ICONST_M1:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ICONST_M1]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      stack[stack_size++].jint = -1;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ICONST_0
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ICONST_0:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ICONST_0]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      stack[stack_size++].jint = 0;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ICONST_1
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ICONST_1:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ICONST_1]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      stack[stack_size++].jint = 1;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ICONST_2
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ICONST_2:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ICONST_2]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      stack[stack_size++].jint = 2;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ICONST_3
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ICONST_3:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ICONST_3]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      stack[stack_size++].jint = 3;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ICONST_4
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ICONST_4:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ICONST_4]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      stack[stack_size++].jint = 4;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ICONST_5
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ICONST_5:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ICONST_5]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      stack[stack_size++].jint = 5;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
LCONST_0
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_LCONST_0:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p LCONST_0]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      *((jlong *) (void *) &stack[stack_size]) = 0;
      stack_size += 2;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
LCONST_1
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_LCONST_1:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p LCONST_1]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      *((jlong *) (void *) &stack[stack_size]) = 1;
      stack_size += 2;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
FCONST_0
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_FCONST_0:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p FCONST_0]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      stack[stack_size++].jfloat = 0;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
FCONST_1
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_FCONST_1:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p FCONST_1]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      stack[stack_size++].jfloat = 1;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
FCONST_2
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_FCONST_2:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p FCONST_2]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      stack[stack_size++].jfloat = 2;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
DCONST_0
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_DCONST_0:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p DCONST_0]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      *((jdouble *) (void *) &stack[stack_size]) = 0;
      stack_size += 2;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
DCONST_1
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_DCONST_1:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p DCONST_1]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      *((jdouble *) (void *) &stack[stack_size]) = 1;
      stack_size += 2;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
LDC_INTEGER
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_LDC_INTEGER:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p LDC_INTEGER]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      stack[stack_size++].jint = (pc++)->jint;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
LDC_FLOAT
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_LDC_FLOAT:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p LDC_FLOAT]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      stack[stack_size++].jfloat = (pc++)->jfloat;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
LDC_STRING
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_LDC_STRING:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p LDC_STRING]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
      
      pc++;             /* skip preparation address */
       
      
      stack[stack_size++].reference = *((pc++)->jobject);

#if defined (MAGIC) && !defined (_SABLEVM_INLINED_THREADED_INTERPRETER)
      assert (stack[stack_size - 1].reference == NULL ||
            strcmp (stack[stack_size - 1].reference->magic,
                  "SableVM") == 0);
#endif

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
LDC_LONG
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_LDC_LONG:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p LDC_LONG]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      *((jlong *) (void *) &stack[stack_size]) = *((pc++)->pjlong);
      stack_size += 2;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
LDC_DOUBLE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_LDC_DOUBLE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p LDC_DOUBLE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      *((jdouble *) (void *) &stack[stack_size]) = *((pc++)->pjdouble);
      stack_size += 2;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ILOAD
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ILOAD:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ILOAD]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jint indx = (pc++)->jint;
        stack[stack_size++].jint = locals[indx].jint;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
LLOAD
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_LLOAD:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p LLOAD]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jint indx = (pc++)->jint;
        *((jlong *) (void *) &stack[stack_size]) =
          *((jlong *) (void *) &locals[indx]);
        stack_size += 2;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
FLOAD
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_FLOAD:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p FLOAD]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jint indx = (pc++)->jint;
        stack[stack_size++].jfloat = locals[indx].jfloat;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
DLOAD
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_DLOAD:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p DLOAD]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jint indx = (pc++)->jint;
        *((jdouble *) (void *) &stack[stack_size]) =
          *((jdouble *) (void *) &locals[indx]);
        stack_size += 2;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ILOAD_0
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ILOAD_0:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ILOAD_0]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      stack[stack_size++].jint = locals[0].jint;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ILOAD_1
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ILOAD_1:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ILOAD_1]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      stack[stack_size++].jint = locals[1].jint;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ILOAD_2
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ILOAD_2:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ILOAD_2]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      stack[stack_size++].jint = locals[2].jint;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ILOAD_3
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ILOAD_3:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ILOAD_3]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      stack[stack_size++].jint = locals[3].jint;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
LLOAD_0
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_LLOAD_0:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p LLOAD_0]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      *((jlong *) (void *) &stack[stack_size]) =
        *((jlong *) (void *) &locals[0]);
      stack_size += 2;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
LLOAD_1
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_LLOAD_1:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p LLOAD_1]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      *((jlong *) (void *) &stack[stack_size]) =
        *((jlong *) (void *) &locals[1]);
      stack_size += 2;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
LLOAD_2
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_LLOAD_2:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p LLOAD_2]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      *((jlong *) (void *) &stack[stack_size]) =
        *((jlong *) (void *) &locals[2]);
      stack_size += 2;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
LLOAD_3
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_LLOAD_3:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p LLOAD_3]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      *((jlong *) (void *) &stack[stack_size]) =
        *((jlong *) (void *) &locals[3]);
      stack_size += 2;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
FLOAD_0
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_FLOAD_0:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p FLOAD_0]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      stack[stack_size++].jfloat = locals[0].jfloat;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
FLOAD_1
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_FLOAD_1:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p FLOAD_1]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      stack[stack_size++].jfloat = locals[1].jfloat;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
FLOAD_2
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_FLOAD_2:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p FLOAD_2]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      stack[stack_size++].jfloat = locals[2].jfloat;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
FLOAD_3
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_FLOAD_3:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p FLOAD_3]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      stack[stack_size++].jfloat = locals[3].jfloat;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
DLOAD_0
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_DLOAD_0:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p DLOAD_0]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      *((jdouble *) (void *) &stack[stack_size]) =
        *((jdouble *) (void *) &locals[0]);
      stack_size += 2;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
DLOAD_1
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_DLOAD_1:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p DLOAD_1]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      *((jdouble *) (void *) &stack[stack_size]) =
        *((jdouble *) (void *) &locals[1]);
      stack_size += 2;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
DLOAD_2
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_DLOAD_2:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p DLOAD_2]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      *((jdouble *) (void *) &stack[stack_size]) =
        *((jdouble *) (void *) &locals[2]);
      stack_size += 2;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
DLOAD_3
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_DLOAD_3:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p DLOAD_3]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      *((jdouble *) (void *) &stack[stack_size]) =
        *((jdouble *) (void *) &locals[3]);
      stack_size += 2;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IALOAD
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IALOAD:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IALOAD]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jint indx = stack[--stack_size].jint;
        size_t stack_top = stack_size - 1;
        _svmt_array_instance *array =
          (_svmt_array_instance *) stack[stack_top].reference;
        jint size;

#ifdef _SABLEVM_SIGNALS_FOR_EXCEPTIONS

#ifndef NDEBUG

        if (array == NULL)
          {
            env->sigsegv_expected = JNI_TRUE;
          }

#endif /* NOT NDEBUG */

        /* save pc in case exception is raised */
        env->stack.current_frame->pc = pc;

#else

        if (array == NULL)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (nullpointerexception_handler);
          }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

        
        size = array->size;   /* can cause sigsegv on NULL array ref */

        
        /* check array bounds */
        if (((_svmt_u32) indx) >= (_svmt_u32) size)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (arrayindexoutofboundsexception_handler);
          }

        stack[stack_top].jint = _svmf_get_int_array_element (array, indx);
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
LALOAD
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_LALOAD:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p LALOAD]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jint indx = stack[stack_size - 1].jint;
        _svmt_array_instance *array =
          (_svmt_array_instance *) stack[stack_size - 2].reference;
        jint size;

#ifdef _SABLEVM_SIGNALS_FOR_EXCEPTIONS

#ifndef NDEBUG

        if (array == NULL)
          {
            env->sigsegv_expected = JNI_TRUE;
          }

#endif /* NOT NDEBUG */

        /* save pc in case exception is raised */
        env->stack.current_frame->pc = pc;

#else

        if (array == NULL)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (nullpointerexception_handler);
          }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

        
        size = array->size;   /* can cause sigsegv on NULL array ref */

        
        if (indx < 0 || indx >= size)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (arrayindexoutofboundsexception_handler);
          }

        *((jlong *) (void *) &stack[stack_size - 2]) =
          _svmf_get_long_array_element (array, indx);
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
FALOAD
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_FALOAD:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p FALOAD]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jint indx = stack[--stack_size].jint;
        size_t stack_top = stack_size - 1;
        _svmt_array_instance *array =
          (_svmt_array_instance *) stack[stack_top].reference;
        jint size;

#ifdef _SABLEVM_SIGNALS_FOR_EXCEPTIONS

#ifndef NDEBUG

        if (array == NULL)
          {
            env->sigsegv_expected = JNI_TRUE;
          }

#endif /* NOT NDEBUG */

        /* save pc in case exception is raised */
        env->stack.current_frame->pc = pc;

#else

        if (array == NULL)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (nullpointerexception_handler);
          }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

        
        size = array->size;   /* can cause sigsegv on NULL array ref */

        
        /* check array bounds */
        if (((_svmt_u32) indx) >= (_svmt_u32) size)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (arrayindexoutofboundsexception_handler);
          }

        stack[stack_top].jfloat = _svmf_get_float_array_element (array, indx);
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
DALOAD
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_DALOAD:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p DALOAD]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jint indx = stack[stack_size - 1].jint;
        _svmt_array_instance *array =
          (_svmt_array_instance *) stack[stack_size - 2].reference;
        jint size;

#ifdef _SABLEVM_SIGNALS_FOR_EXCEPTIONS

#ifndef NDEBUG

        if (array == NULL)
          {
            env->sigsegv_expected = JNI_TRUE;
          }

#endif /* NOT NDEBUG */

        /* save pc in case exception is raised */
        env->stack.current_frame->pc = pc;

#else

        if (array == NULL)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (nullpointerexception_handler);
          }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

        
        size = array->size;   /* can cause sigsegv on NULL array ref */

        
        if (indx < 0 || indx >= size)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (arrayindexoutofboundsexception_handler);
          }

        *((jdouble *) (void *) &stack[stack_size - 2]) =
          _svmf_get_double_array_element (array, indx);
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
CALOAD
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_CALOAD:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p CALOAD]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jint indx = stack[--stack_size].jint;
        size_t stack_top = stack_size - 1;
        _svmt_array_instance *array =
          (_svmt_array_instance *) stack[stack_top].reference;
        jint size;

#ifdef _SABLEVM_SIGNALS_FOR_EXCEPTIONS

#ifndef NDEBUG

        if (array == NULL)
          {
            env->sigsegv_expected = JNI_TRUE;
          }

#endif /* NOT NDEBUG */

        /* save pc in case exception is raised */
        env->stack.current_frame->pc = pc;

#else

        if (array == NULL)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (nullpointerexception_handler);
          }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

        
        size = array->size;   /* can cause sigsegv on NULL array ref */

        
        /* check array bounds */
        if (((_svmt_u32) indx) >= (_svmt_u32) size)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (arrayindexoutofboundsexception_handler);
          }

        stack[stack_top].jint = _svmf_get_char_array_element (array, indx);
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
SALOAD
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_SALOAD:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p SALOAD]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jint indx = stack[--stack_size].jint;
        size_t stack_top = stack_size - 1;
        _svmt_array_instance *array =
          (_svmt_array_instance *) stack[stack_top].reference;
        jint size;

#ifdef _SABLEVM_SIGNALS_FOR_EXCEPTIONS

#ifndef NDEBUG

        if (array == NULL)
          {
            env->sigsegv_expected = JNI_TRUE;
          }

#endif /* NOT NDEBUG */

        /* save pc in case exception is raised */
        env->stack.current_frame->pc = pc;

#else

        if (array == NULL)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (nullpointerexception_handler);
          }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

        
        size = array->size;   /* can cause sigsegv on NULL array ref */

        
        /* check array bounds */
        if (((_svmt_u32) indx) >= (_svmt_u32) size)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (arrayindexoutofboundsexception_handler);
          }

        stack[stack_top].jint = _svmf_get_short_array_element (array, indx);
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ALOAD
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ALOAD:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ALOAD]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jint indx = (pc++)->jint;
        stack[stack_size++].reference = locals[indx].reference;
      }

#if defined (MAGIC) && !defined (_SABLEVM_INLINED_THREADED_INTERPRETER)
      assert (stack[stack_size - 1].reference == NULL
            || strcmp (stack[stack_size - 1].reference->magic,
                     "SableVM") == 0);
#endif

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ALOAD_0
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ALOAD_0:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ALOAD_0]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      stack[stack_size++].reference = locals[0].reference;

#if defined (MAGIC) && !defined (_SABLEVM_INLINED_THREADED_INTERPRETER)
      assert (stack[stack_size - 1].reference == NULL
            || strcmp (stack[stack_size - 1].reference->magic,
                     "SableVM") == 0);
#endif

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ALOAD_1
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ALOAD_1:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ALOAD_1]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      stack[stack_size++].reference = locals[1].reference;

#if defined (MAGIC) && !defined (_SABLEVM_INLINED_THREADED_INTERPRETER)
      assert (stack[stack_size - 1].reference == NULL
            || strcmp (stack[stack_size - 1].reference->magic,
                     "SableVM") == 0);
#endif

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ALOAD_2
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ALOAD_2:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ALOAD_2]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      stack[stack_size++].reference = locals[2].reference;

#if defined (MAGIC) && !defined (_SABLEVM_INLINED_THREADED_INTERPRETER)
      assert (stack[stack_size - 1].reference == NULL
            || strcmp (stack[stack_size - 1].reference->magic,
                     "SableVM") == 0);
#endif

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ALOAD_3
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ALOAD_3:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ALOAD_3]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      stack[stack_size++].reference = locals[3].reference;

#if defined (MAGIC) && !defined (_SABLEVM_INLINED_THREADED_INTERPRETER)
      assert (stack[stack_size - 1].reference == NULL
            || strcmp (stack[stack_size - 1].reference->magic,
                     "SableVM") == 0);
#endif

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
AALOAD
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_AALOAD:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p AALOAD]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jint indx = stack[--stack_size].jint;
        size_t stack_top = stack_size - 1;
        _svmt_array_instance *array =
          (_svmt_array_instance *) stack[stack_top].reference;
        jint size;

#ifdef _SABLEVM_SIGNALS_FOR_EXCEPTIONS

#ifndef NDEBUG

        if (array == NULL)
          {
            env->sigsegv_expected = JNI_TRUE;
          }

#endif /* NOT NDEBUG */

        /* save pc in case exception is raised */
        env->stack.current_frame->pc = pc;

#else

        if (array == NULL)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (nullpointerexception_handler);
          }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

        
        size = array->size;   /* can cause sigsegv on NULL array ref */

        
        /* check array bounds */
        if (((_svmt_u32) indx) >= (_svmt_u32) size)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (arrayindexoutofboundsexception_handler);
          }

        stack[stack_top].reference =
          _svmf_get_reference_array_element (array, indx);
      }

#if defined (MAGIC)
      assert (stack[stack_size - 1].reference == NULL ||
            strcmp (stack[stack_size - 1].reference->magic,
                  "SableVM") == 0);
#endif

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
BALOAD
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_BALOAD:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p BALOAD]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jint indx = stack[--stack_size].jint;
        size_t stack_top = stack_size - 1;
        _svmt_array_instance *array =
          (_svmt_array_instance *) stack[stack_top].reference;
        jint base_type;
        jint size;

#ifdef _SABLEVM_SIGNALS_FOR_EXCEPTIONS

#ifndef NDEBUG

        if (array == NULL)
          {
            env->sigsegv_expected = JNI_TRUE;
          }

#endif /* NOT NDEBUG */

        /* save pc in case exception is raised */
        env->stack.current_frame->pc = pc;

#else

        if (array == NULL)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (nullpointerexception_handler);
          }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

        
        size = array->size;   /* can cause sigsegv on NULL array ref */

        
        /* check array bounds */
        if (((_svmt_u32) indx) >= (_svmt_u32) size)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (arrayindexoutofboundsexception_handler);
          }

        base_type = _svmf_cast_array (array->vtable->type)->base_type;

        switch (base_type)
          {
          case SVM_TYPE_BYTE:
            {
            stack[stack_top].jint =
              _svmf_get_byte_array_element (array, indx);
            }
            break;

          case SVM_TYPE_BOOLEAN:
            {
            stack[stack_top].jint =
              _svmf_get_boolean_array_element (array, indx);
            }
            break;

          default:
            {
            _svmm_fatal_error ("impossible control flow");
            }
            break;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ISTORE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ISTORE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ISTORE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jint indx = (pc++)->jint;
        locals[indx].jint = stack[--stack_size].jint;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
LSTORE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_LSTORE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p LSTORE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jint indx = (pc++)->jint;
        stack_size -= 2;
        *((jlong *) (void *) &locals[indx]) =
          *((jlong *) (void *) &stack[stack_size]);
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
FSTORE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_FSTORE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p FSTORE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jint indx = (pc++)->jint;
        locals[indx].jfloat = stack[--stack_size].jfloat;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
DSTORE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_DSTORE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p DSTORE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jint indx = (pc++)->jint;
        stack_size -= 2;
        *((jdouble *) (void *) &locals[indx]) =
          *((jdouble *) (void *) &stack[stack_size]);
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ASTORE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ASTORE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ASTORE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jint indx = (pc++)->jint;
        locals[indx].reference = stack[--stack_size].reference;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ISTORE_0
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ISTORE_0:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ISTORE_0]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      locals[0].jint = stack[--stack_size].jint;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ISTORE_1
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ISTORE_1:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ISTORE_1]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      locals[1].jint = stack[--stack_size].jint;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ISTORE_2
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ISTORE_2:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ISTORE_2]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      locals[2].jint = stack[--stack_size].jint;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ISTORE_3
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ISTORE_3:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ISTORE_3]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      locals[3].jint = stack[--stack_size].jint;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
LSTORE_0
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_LSTORE_0:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p LSTORE_0]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      stack_size -= 2;
      *((jlong *) (void *) &locals[0]) =
        *((jlong *) (void *) &stack[stack_size]);

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
LSTORE_1
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_LSTORE_1:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p LSTORE_1]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      stack_size -= 2;
      *((jlong *) (void *) &locals[1]) =
        *((jlong *) (void *) &stack[stack_size]);

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
LSTORE_2
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_LSTORE_2:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p LSTORE_2]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      stack_size -= 2;
      *((jlong *) (void *) &locals[2]) =
        *((jlong *) (void *) &stack[stack_size]);

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
LSTORE_3
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_LSTORE_3:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p LSTORE_3]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      stack_size -= 2;
      *((jlong *) (void *) &locals[3]) =
        *((jlong *) (void *) &stack[stack_size]);

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
FSTORE_0
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_FSTORE_0:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p FSTORE_0]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      locals[0].jfloat = stack[--stack_size].jfloat;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
FSTORE_1
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_FSTORE_1:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p FSTORE_1]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      locals[1].jfloat = stack[--stack_size].jfloat;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
FSTORE_2
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_FSTORE_2:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p FSTORE_2]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      locals[2].jfloat = stack[--stack_size].jfloat;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
FSTORE_3
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_FSTORE_3:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p FSTORE_3]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      locals[3].jfloat = stack[--stack_size].jfloat;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
DSTORE_0
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_DSTORE_0:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p DSTORE_0]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      stack_size -= 2;
      *((jdouble *) (void *) &locals[0]) =
        *((jdouble *) (void *) &stack[stack_size]);

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
DSTORE_1
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_DSTORE_1:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p DSTORE_1]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      stack_size -= 2;
      *((jdouble *) (void *) &locals[1]) =
        *((jdouble *) (void *) &stack[stack_size]);

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
DSTORE_2
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_DSTORE_2:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p DSTORE_2]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      stack_size -= 2;
      *((jdouble *) (void *) &locals[2]) =
        *((jdouble *) (void *) &stack[stack_size]);

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
DSTORE_3
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_DSTORE_3:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p DSTORE_3]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      stack_size -= 2;
      *((jdouble *) (void *) &locals[3]) =
        *((jdouble *) (void *) &stack[stack_size]);

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ASTORE_0
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ASTORE_0:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ASTORE_0]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      locals[0].reference = stack[--stack_size].reference;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ASTORE_1
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ASTORE_1:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ASTORE_1]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      locals[1].reference = stack[--stack_size].reference;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ASTORE_2
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ASTORE_2:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ASTORE_2]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      locals[2].reference = stack[--stack_size].reference;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ASTORE_3
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ASTORE_3:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ASTORE_3]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      locals[3].reference = stack[--stack_size].reference;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IASTORE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IASTORE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IASTORE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jint value = stack[--stack_size].jint;
        jint indx = stack[--stack_size].jint;
        _svmt_array_instance *array =
          (_svmt_array_instance *) stack[--stack_size].reference;
        jint size;

#ifdef _SABLEVM_SIGNALS_FOR_EXCEPTIONS

#ifndef NDEBUG

        if (array == NULL)
          {
            env->sigsegv_expected = JNI_TRUE;
          }

#endif /* NOT NDEBUG */

        /* save pc in case exception is raised */
        env->stack.current_frame->pc = pc;

#else

        if (array == NULL)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (nullpointerexception_handler);
          }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

        
        size = array->size;   /* can cause sigsegv on NULL array ref */

        
        /* check array bounds */
        if (((_svmt_u32) indx) >= (_svmt_u32) size)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (arrayindexoutofboundsexception_handler);
          }

        _svmf_set_int_array_element (array, indx, value);
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
LASTORE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_LASTORE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p LASTORE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jlong value = *((jlong *) (void *) &stack[(stack_size -= 2)]);
        jint indx = stack[--stack_size].jint;
        _svmt_array_instance *array =
          (_svmt_array_instance *) stack[--stack_size].reference;
        jint size;

#ifdef _SABLEVM_SIGNALS_FOR_EXCEPTIONS

#ifndef NDEBUG

        if (array == NULL)
          {
            env->sigsegv_expected = JNI_TRUE;
          }

#endif /* NOT NDEBUG */

        /* save pc in case exception is raised */
        env->stack.current_frame->pc = pc;

#else

        if (array == NULL)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (nullpointerexception_handler);
          }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

        
        size = array->size;   /* can cause sigsegv on NULL array ref */

        
        /* check array bounds */
        if (((_svmt_u32) indx) >= (_svmt_u32) size)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (arrayindexoutofboundsexception_handler);
          }

        _svmf_set_long_array_element (array, indx, value);
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
FASTORE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_FASTORE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p FASTORE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jfloat value = stack[--stack_size].jfloat;
        jint indx = stack[--stack_size].jint;
        _svmt_array_instance *array =
          (_svmt_array_instance *) stack[--stack_size].reference;
        jint size;

#ifdef _SABLEVM_SIGNALS_FOR_EXCEPTIONS

#ifndef NDEBUG

        if (array == NULL)
          {
            env->sigsegv_expected = JNI_TRUE;
          }

#endif /* NOT NDEBUG */

        /* save pc in case exception is raised */
        env->stack.current_frame->pc = pc;

#else

        if (array == NULL)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (nullpointerexception_handler);
          }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

        
        size = array->size;   /* can cause sigsegv on NULL array ref */

        
        /* check array bounds */
        if (((_svmt_u32) indx) >= (_svmt_u32) size)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (arrayindexoutofboundsexception_handler);
          }

        _svmf_set_float_array_element (array, indx, value);
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
DASTORE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_DASTORE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p DASTORE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jdouble value = *((jdouble *) (void *) &stack[(stack_size -= 2)]);
        jint indx = stack[--stack_size].jint;
        _svmt_array_instance *array =
          (_svmt_array_instance *) stack[--stack_size].reference;
        jint size;

#ifdef _SABLEVM_SIGNALS_FOR_EXCEPTIONS

#ifndef NDEBUG

        if (array == NULL)
          {
            env->sigsegv_expected = JNI_TRUE;
          }

#endif /* NOT NDEBUG */

        /* save pc in case exception is raised */
        env->stack.current_frame->pc = pc;

#else

        if (array == NULL)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (nullpointerexception_handler);
          }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

        
        size = array->size;   /* can cause sigsegv on NULL array ref */

        
        /* check array bounds */
        if (((_svmt_u32) indx) >= (_svmt_u32) size)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (arrayindexoutofboundsexception_handler);
          }

        _svmf_set_double_array_element (array, indx, value);
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
CASTORE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_CASTORE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p CASTORE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jchar value = stack[--stack_size].jint;
        jint indx = stack[--stack_size].jint;
        _svmt_array_instance *array =
          (_svmt_array_instance *) stack[--stack_size].reference;
        jint size;

#ifdef _SABLEVM_SIGNALS_FOR_EXCEPTIONS

#ifndef NDEBUG

        if (array == NULL)
          {
            env->sigsegv_expected = JNI_TRUE;
          }

#endif /* NOT NDEBUG */

        /* save pc in case exception is raised */
        env->stack.current_frame->pc = pc;

#else

        if (array == NULL)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (nullpointerexception_handler);
          }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

        
        size = array->size;   /* can cause sigsegv on NULL array ref */

        
        /* check array bounds */
        if (((_svmt_u32) indx) >= (_svmt_u32) size)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (arrayindexoutofboundsexception_handler);
          }

        _svmf_set_char_array_element (array, indx, value);
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
SASTORE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_SASTORE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p SASTORE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jshort value = stack[--stack_size].jint;
        jint indx = stack[--stack_size].jint;
        _svmt_array_instance *array =
          (_svmt_array_instance *) stack[--stack_size].reference;
        jint size;

#ifdef _SABLEVM_SIGNALS_FOR_EXCEPTIONS

#ifndef NDEBUG

        if (array == NULL)
          {
            env->sigsegv_expected = JNI_TRUE;
          }

#endif /* NOT NDEBUG */

        /* save pc in case exception is raised */
        env->stack.current_frame->pc = pc;

#else

        if (array == NULL)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (nullpointerexception_handler);
          }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

        
        size = array->size;   /* can cause sigsegv on NULL array ref */

        
        /* check array bounds */
        if (((_svmt_u32) indx) >= (_svmt_u32) size)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (arrayindexoutofboundsexception_handler);
          }

        _svmf_set_short_array_element (array, indx, value);
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
BASTORE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_BASTORE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p BASTORE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jint value = stack[--stack_size].jint;
        jint indx = stack[--stack_size].jint;
        _svmt_array_instance *array =
          (_svmt_array_instance *) stack[--stack_size].reference;
        jint base_type;
        jint size;

#ifdef _SABLEVM_SIGNALS_FOR_EXCEPTIONS

#ifndef NDEBUG

        if (array == NULL)
          {
            env->sigsegv_expected = JNI_TRUE;
          }

#endif /* NOT NDEBUG */

        /* save pc in case exception is raised */
        env->stack.current_frame->pc = pc;

#else

        if (array == NULL)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (nullpointerexception_handler);
          }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

        
        size = array->size;   /* can cause sigsegv on NULL array ref */

        
        if (indx < 0 || indx >= size)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (arrayindexoutofboundsexception_handler);
          }

        base_type = _svmf_cast_array (array->vtable->type)->base_type;

        switch (base_type)
          {
          case SVM_TYPE_BYTE:
            {
            _svmf_set_byte_array_element (array, indx, value);
            }
            break;

          case SVM_TYPE_BOOLEAN:
            {
            _svmf_set_boolean_array_element (array, indx, value);
            }
            break;

          default:
            {
            _svmm_fatal_error ("impossible control flow");
            }
            break;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
AASTORE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_AASTORE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p AASTORE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_object_instance *value = stack[--stack_size].reference;
        jint indx = stack[--stack_size].jint;
        _svmt_array_instance *array =
          (_svmt_array_instance *) stack[--stack_size].reference;
        jint size;

#ifdef _SABLEVM_SIGNALS_FOR_EXCEPTIONS

#ifndef NDEBUG

        if (array == NULL)
          {
            env->sigsegv_expected = JNI_TRUE;
          }

#endif /* NOT NDEBUG */

        /* save pc in case exception is raised */
        env->stack.current_frame->pc = pc;

#else

        if (array == NULL)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (nullpointerexception_handler);
          }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

        
        size = array->size;   /* can cause sigsegv on NULL array ref */

        
        /* check array bounds */
        if (((_svmt_u32) indx) >= (_svmt_u32) size)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (arrayindexoutofboundsexception_handler);
          }

        if (_svmf_set_reference_array_element_no_exception
            (env, array, indx, value) != JNI_OK)
          {             /* TODO: how to get into here using BTF ?! */
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (arraystoreexception_handler);
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
POP
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_POP:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p POP]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      stack_size--;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
POP2
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_POP2:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p POP2]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      stack_size -= 2;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
DUP
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_DUP:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p DUP]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      stack[stack_size] = stack[stack_size - 1];
      stack_size++;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
DUP_X1
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_DUP_X1:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p DUP_X1]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_stack_value value2 = stack[stack_size - 2];
        _svmt_stack_value value1 = stack[stack_size - 1];
        stack[stack_size - 2] = value1;
        stack[stack_size - 1] = value2;
        stack[stack_size] = value1;
        stack_size++;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
DUP_X2
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_DUP_X2:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p DUP_X2]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_stack_value value3 = stack[stack_size - 3];
        _svmt_stack_value value2 = stack[stack_size - 2];
        _svmt_stack_value value1 = stack[stack_size - 1];
        stack[stack_size - 3] = value1;
        stack[stack_size - 2] = value3;
        stack[stack_size - 1] = value2;
        stack[stack_size] = value1;
        stack_size++;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
DUP2
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_DUP2:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p DUP2]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_stack_value value2 = stack[stack_size - 2];
        _svmt_stack_value value1 = stack[stack_size - 1];
        stack[stack_size++] = value2;
        stack[stack_size++] = value1;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
DUP2_X1
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_DUP2_X1:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p DUP2_X1]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_stack_value value3 = stack[stack_size - 3];
        _svmt_stack_value value2 = stack[stack_size - 2];
        _svmt_stack_value value1 = stack[stack_size - 1];
        stack[stack_size - 3] = value2;
        stack[stack_size - 2] = value1;
        stack[stack_size - 1] = value3;
        stack[stack_size++] = value2;
        stack[stack_size++] = value1;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
DUP2_X2
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_DUP2_X2:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p DUP2_X2]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_stack_value value4 = stack[stack_size - 4];
        _svmt_stack_value value3 = stack[stack_size - 3];
        _svmt_stack_value value2 = stack[stack_size - 2];
        _svmt_stack_value value1 = stack[stack_size - 1];
        stack[stack_size - 4] = value2;
        stack[stack_size - 3] = value1;
        stack[stack_size - 2] = value4;
        stack[stack_size - 1] = value3;
        stack[stack_size++] = value2;
        stack[stack_size++] = value1;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
SWAP
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_SWAP:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p SWAP]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_stack_value value2 = stack[stack_size - 2];
        _svmt_stack_value value1 = stack[stack_size - 1];
        stack[stack_size - 2] = value1;
        stack[stack_size - 1] = value2;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IADD
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IADD:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IADD]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jint value1 = stack[stack_size - 2].jint;
        jint value2 = stack[--stack_size].jint;
        stack[stack_size - 1].jint = value1 + value2;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
LADD
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_LADD:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p LADD]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jlong value1 = *((jlong *) (void *) &stack[stack_size - 4]);
        jlong value2 = *((jlong *) (void *) &stack[(stack_size -= 2)]);
        *((jlong *) (void *) &stack[stack_size - 2]) = value1 + value2;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
FADD
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_FADD:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p FADD]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jfloat value1 = stack[stack_size - 2].jfloat;
        jfloat value2 = stack[--stack_size].jfloat;
        stack[stack_size - 1].jfloat = value1 + value2;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
DADD
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_DADD:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p DADD]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jdouble value1 = *((jdouble *) (void *) &stack[stack_size - 4]);
        jdouble value2 = *((jdouble *) (void *) &stack[(stack_size -= 2)]);
        *((jdouble *) (void *) &stack[stack_size - 2]) = value1 + value2;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ISUB
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ISUB:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ISUB]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jint value1 = stack[stack_size - 2].jint;
        jint value2 = stack[--stack_size].jint;
        stack[stack_size - 1].jint = value1 - value2;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
LSUB
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_LSUB:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p LSUB]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jlong value1 = *((jlong *) (void *) &stack[stack_size - 4]);
        jlong value2 = *((jlong *) (void *) &stack[(stack_size -= 2)]);
        *((jlong *) (void *) &stack[stack_size - 2]) = value1 - value2;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
FSUB
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_FSUB:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p FSUB]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jfloat value1 = stack[stack_size - 2].jfloat;
        jfloat value2 = stack[--stack_size].jfloat;
        stack[stack_size - 1].jfloat = value1 - value2;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
DSUB
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_DSUB:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p DSUB]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jdouble value1 = *((jdouble *) (void *) &stack[stack_size - 4]);
        jdouble value2 = *((jdouble *) (void *) &stack[(stack_size -= 2)]);
        *((jdouble *) (void *) &stack[stack_size - 2]) = value1 - value2;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IMUL
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IMUL:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IMUL]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jint value1 = stack[stack_size - 2].jint;
        jint value2 = stack[--stack_size].jint;
        stack[stack_size - 1].jint = value1 * value2;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
LMUL
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_LMUL:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p LMUL]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jlong value1 = *((jlong *) (void *) &stack[stack_size - 4]);
        jlong value2 = *((jlong *) (void *) &stack[(stack_size -= 2)]);
        *((jlong *) (void *) &stack[stack_size - 2]) = value1 * value2;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
FMUL
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_FMUL:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p FMUL]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jfloat value1 = stack[stack_size - 2].jfloat;
        jfloat value2 = stack[--stack_size].jfloat;
        stack[stack_size - 1].jfloat = value1 * value2;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
DMUL
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_DMUL:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p DMUL]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jdouble value1 = *((jdouble *) (void *) &stack[stack_size - 4]);
        jdouble value2 = *((jdouble *) (void *) &stack[(stack_size -= 2)]);
        *((jdouble *) (void *) &stack[stack_size - 2]) = value1 * value2;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
FDIV
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_FDIV:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p FDIV]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jfloat value1 = stack[stack_size - 2].jfloat;
        jfloat value2 = stack[--stack_size].jfloat;
        stack[stack_size - 1].jfloat = value1 / value2;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
DDIV
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_DDIV:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p DDIV]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jdouble value1 = *((jdouble *) (void *) &stack[stack_size - 4]);
        jdouble value2 = *((jdouble *) (void *) &stack[(stack_size -= 2)]);
        *((jdouble *) (void *) &stack[stack_size - 2]) = value1 / value2;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
INEG
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_INEG:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p INEG]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
/* SVM__MAX is never defined. */
#ifdef SVM__MAX
        if ((stack[stack_size - 1].jint) >= SVM__MAX)
          {
            stack[stack_size - 1].jint = SVM__MAX;
          }
        else if ((stack[stack_size - 1].jint) <= SVM__MIN)
          {
            stack[stack_size - 1].jint = SVM__MIN;
          }
        else
#endif
          {
            jint value = stack[stack_size - 1].jint;
            stack[stack_size - 1].jint = - value;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
LNEG
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_LNEG:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p LNEG]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
/* SVM__MAX is never defined. */
#ifdef SVM__MAX
        if ((*((jlong *) (void *) &stack[stack_size - 2])) >= SVM__MAX)
          {
            *((jlong *) (void *) &stack[stack_size - 2]) = SVM__MAX;
          }
        else if ((*((jlong *) (void *) &stack[stack_size - 2])) <= SVM__MIN)
          {
            *((jlong *) (void *) &stack[stack_size - 2]) = SVM__MIN;
          }
        else
#endif
          {
            jlong value = *((jlong *) (void *) &stack[stack_size - 2]);
            *((jlong *) (void *) &stack[stack_size - 2]) = - value;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
FNEG
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_FNEG:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p FNEG]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
/* SVM__MAX is never defined. */
#ifdef SVM__MAX
        if ((stack[stack_size - 1].jfloat) >= SVM__MAX)
          {
            stack[stack_size - 1].jfloat = SVM__MAX;
          }
        else if ((stack[stack_size - 1].jfloat) <= SVM__MIN)
          {
            stack[stack_size - 1].jfloat = SVM__MIN;
          }
        else
#endif
          {
            jfloat value = stack[stack_size - 1].jfloat;
            stack[stack_size - 1].jfloat = - value;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
DNEG
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_DNEG:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p DNEG]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
/* SVM__MAX is never defined. */
#ifdef SVM__MAX
        if ((*((jdouble *) (void *) &stack[stack_size - 2])) >= SVM__MAX)
          {
            *((jdouble *) (void *) &stack[stack_size - 2]) = SVM__MAX;
          }
        else if ((*((jdouble *) (void *) &stack[stack_size - 2])) <= SVM__MIN)
          {
            *((jdouble *) (void *) &stack[stack_size - 2]) = SVM__MIN;
          }
        else
#endif
          {
            jdouble value = *((jdouble *) (void *) &stack[stack_size - 2]);
            *((jdouble *) (void *) &stack[stack_size - 2]) = - value;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IAND
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IAND:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IAND]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jint value1 = stack[stack_size - 2].jint;
        jint value2 = stack[--stack_size].jint;
        stack[stack_size - 1].jint = value1 & value2;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
LAND
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_LAND:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p LAND]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jlong value1 = *((jlong *) (void *) &stack[stack_size - 4]);
        jlong value2 = *((jlong *) (void *) &stack[(stack_size -= 2)]);
        *((jlong *) (void *) &stack[stack_size - 2]) = value1 & value2;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IOR
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IOR:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IOR]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jint value1 = stack[stack_size - 2].jint;
        jint value2 = stack[--stack_size].jint;
        stack[stack_size - 1].jint = value1 | value2;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
LOR
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_LOR:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p LOR]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jlong value1 = *((jlong *) (void *) &stack[stack_size - 4]);
        jlong value2 = *((jlong *) (void *) &stack[(stack_size -= 2)]);
        *((jlong *) (void *) &stack[stack_size - 2]) = value1 | value2;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IXOR
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IXOR:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IXOR]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jint value1 = stack[stack_size - 2].jint;
        jint value2 = stack[--stack_size].jint;
        stack[stack_size - 1].jint = value1 ^ value2;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
LXOR
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_LXOR:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p LXOR]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jlong value1 = *((jlong *) (void *) &stack[stack_size - 4]);
        jlong value2 = *((jlong *) (void *) &stack[(stack_size -= 2)]);
        *((jlong *) (void *) &stack[stack_size - 2]) = value1 ^ value2;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
I2L
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_I2L:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p I2L]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
/* SVM__MAX is never defined. */
#ifdef SVM__MAX
        if ((stack[stack_size - 1].jint) >= SVM__MAX)
          {
            *((jlong *) (void *) &stack[stack_size++ - 1]) = SVM__MAX;
          }
        else if ((stack[stack_size - 1].jint) <= SVM__MIN)
          {
            *((jlong *) (void *) &stack[stack_size++ - 1]) = SVM__MIN;
          }
        else
#endif
          {
            jint value = stack[stack_size - 1].jint;
            *((jlong *) (void *) &stack[stack_size++ - 1]) =  value;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
I2F
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_I2F:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p I2F]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
/* SVM__MAX is never defined. */
#ifdef SVM__MAX
        if ((stack[stack_size - 1].jint) >= SVM__MAX)
          {
            stack[stack_size - 1].jfloat = SVM__MAX;
          }
        else if ((stack[stack_size - 1].jint) <= SVM__MIN)
          {
            stack[stack_size - 1].jfloat = SVM__MIN;
          }
        else
#endif
          {
            jint value = stack[stack_size - 1].jint;
            stack[stack_size - 1].jfloat =  value;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
I2D
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_I2D:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p I2D]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
/* SVM__MAX is never defined. */
#ifdef SVM__MAX
        if ((stack[stack_size - 1].jint) >= SVM__MAX)
          {
            *((jdouble *) (void *) &stack[stack_size++ - 1]) = SVM__MAX;
          }
        else if ((stack[stack_size - 1].jint) <= SVM__MIN)
          {
            *((jdouble *) (void *) &stack[stack_size++ - 1]) = SVM__MIN;
          }
        else
#endif
          {
            jint value = stack[stack_size - 1].jint;
            *((jdouble *) (void *) &stack[stack_size++ - 1]) =  value;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
L2I
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_L2I:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p L2I]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
/* SVM__MAX is never defined. */
#ifdef SVM__MAX
        if ((*((jlong *) (void *) &stack[stack_size - 2])) >= SVM__MAX)
          {
            stack_size--;
            stack[stack_size - 1].jint = SVM__MAX;
          }
        else if ((*((jlong *) (void *) &stack[stack_size - 2])) <= SVM__MIN)
          {
            stack_size--;
            stack[stack_size - 1].jint = SVM__MIN;
          }
        else
#endif
          {
            jlong value = *((jlong *) (void *) &stack[--stack_size - 1]);
            stack[stack_size - 1].jint =  value;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
L2F
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_L2F:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p L2F]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
/* SVM__MAX is never defined. */
#ifdef SVM__MAX
        if ((*((jlong *) (void *) &stack[stack_size - 2])) >= SVM__MAX)
          {
            stack_size--;
            stack[stack_size - 1].jfloat = SVM__MAX;
          }
        else if ((*((jlong *) (void *) &stack[stack_size - 2])) <= SVM__MIN)
          {
            stack_size--;
            stack[stack_size - 1].jfloat = SVM__MIN;
          }
        else
#endif
          {
            jlong value = *((jlong *) (void *) &stack[--stack_size - 1]);
            stack[stack_size - 1].jfloat =  value;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
L2D
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_L2D:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p L2D]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
/* SVM__MAX is never defined. */
#ifdef SVM__MAX
        if ((*((jlong *) (void *) &stack[stack_size - 2])) >= SVM__MAX)
          {
            *((jdouble *) (void *) &stack[stack_size - 2]) = SVM__MAX;
          }
        else if ((*((jlong *) (void *) &stack[stack_size - 2])) <= SVM__MIN)
          {
            *((jdouble *) (void *) &stack[stack_size - 2]) = SVM__MIN;
          }
        else
#endif
          {
            jlong value = *((jlong *) (void *) &stack[stack_size - 2]);
            *((jdouble *) (void *) &stack[stack_size - 2]) =  value;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
F2I
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_F2I:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p F2I]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
/* SVM__MAX is never defined. */
#ifdef SVM_JINT_MAX
        if ((stack[stack_size - 1].jfloat) >= SVM_JINT_MAX)
          {
            stack[stack_size - 1].jint = SVM_JINT_MAX;
          }
        else if ((stack[stack_size - 1].jfloat) <= SVM_JINT_MIN)
          {
            stack[stack_size - 1].jint = SVM_JINT_MIN;
          }
        else
#endif
          {
            jfloat value = stack[stack_size - 1].jfloat;
            stack[stack_size - 1].jint =  value;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
F2L
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_F2L:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p F2L]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
/* SVM__MAX is never defined. */
#ifdef SVM_JLONG_MAX
        if ((stack[stack_size - 1].jfloat) >= SVM_JLONG_MAX)
          {
            *((jlong *) (void *) &stack[stack_size++ - 1]) = SVM_JLONG_MAX;
          }
        else if ((stack[stack_size - 1].jfloat) <= SVM_JLONG_MIN)
          {
            *((jlong *) (void *) &stack[stack_size++ - 1]) = SVM_JLONG_MIN;
          }
        else
#endif
          {
            jfloat value = stack[stack_size - 1].jfloat;
            *((jlong *) (void *) &stack[stack_size++ - 1]) =  value;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
F2D
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_F2D:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p F2D]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
/* SVM__MAX is never defined. */
#ifdef SVM__MAX
        if ((stack[stack_size - 1].jfloat) >= SVM__MAX)
          {
            *((jdouble *) (void *) &stack[stack_size++ - 1]) = SVM__MAX;
          }
        else if ((stack[stack_size - 1].jfloat) <= SVM__MIN)
          {
            *((jdouble *) (void *) &stack[stack_size++ - 1]) = SVM__MIN;
          }
        else
#endif
          {
            jfloat value = stack[stack_size - 1].jfloat;
            *((jdouble *) (void *) &stack[stack_size++ - 1]) =  value;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
D2I
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_D2I:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p D2I]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
/* SVM__MAX is never defined. */
#ifdef SVM_JINT_MAX
        if ((*((jdouble *) (void *) &stack[stack_size - 2])) >= SVM_JINT_MAX)
          {
            stack_size--;
            stack[stack_size - 1].jint = SVM_JINT_MAX;
          }
        else if ((*((jdouble *) (void *) &stack[stack_size - 2])) <= SVM_JINT_MIN)
          {
            stack_size--;
            stack[stack_size - 1].jint = SVM_JINT_MIN;
          }
        else
#endif
          {
            jdouble value = *((jdouble *) (void *) &stack[--stack_size - 1]);
            stack[stack_size - 1].jint =  value;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
D2L
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_D2L:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p D2L]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
/* SVM__MAX is never defined. */
#ifdef SVM_JLONG_MAX
        if ((*((jdouble *) (void *) &stack[stack_size - 2])) >= SVM_JLONG_MAX)
          {
            *((jlong *) (void *) &stack[stack_size - 2]) = SVM_JLONG_MAX;
          }
        else if ((*((jdouble *) (void *) &stack[stack_size - 2])) <= SVM_JLONG_MIN)
          {
            *((jlong *) (void *) &stack[stack_size - 2]) = SVM_JLONG_MIN;
          }
        else
#endif
          {
            jdouble value = *((jdouble *) (void *) &stack[stack_size - 2]);
            *((jlong *) (void *) &stack[stack_size - 2]) =  value;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
D2F
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_D2F:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p D2F]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
/* SVM__MAX is never defined. */
#ifdef SVM__MAX
        if ((*((jdouble *) (void *) &stack[stack_size - 2])) >= SVM__MAX)
          {
            stack_size--;
            stack[stack_size - 1].jfloat = SVM__MAX;
          }
        else if ((*((jdouble *) (void *) &stack[stack_size - 2])) <= SVM__MIN)
          {
            stack_size--;
            stack[stack_size - 1].jfloat = SVM__MIN;
          }
        else
#endif
          {
            jdouble value = *((jdouble *) (void *) &stack[--stack_size - 1]);
            stack[stack_size - 1].jfloat =  value;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
I2B
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_I2B:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p I2B]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
/* SVM__MAX is never defined. */
#ifdef SVM__MAX
        if ((stack[stack_size - 1].jint) >= SVM__MAX)
          {
            stack[stack_size - 1].jint = SVM__MAX;
          }
        else if ((stack[stack_size - 1].jint) <= SVM__MIN)
          {
            stack[stack_size - 1].jint = SVM__MIN;
          }
        else
#endif
          {
            jint value = stack[stack_size - 1].jint;
            stack[stack_size - 1].jint = (jbyte) value;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
I2C
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_I2C:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p I2C]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
/* SVM__MAX is never defined. */
#ifdef SVM__MAX
        if ((stack[stack_size - 1].jint) >= SVM__MAX)
          {
            stack[stack_size - 1].jint = SVM__MAX;
          }
        else if ((stack[stack_size - 1].jint) <= SVM__MIN)
          {
            stack[stack_size - 1].jint = SVM__MIN;
          }
        else
#endif
          {
            jint value = stack[stack_size - 1].jint;
            stack[stack_size - 1].jint = (jchar) value;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
I2S
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_I2S:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p I2S]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
/* SVM__MAX is never defined. */
#ifdef SVM__MAX
        if ((stack[stack_size - 1].jint) >= SVM__MAX)
          {
            stack[stack_size - 1].jint = SVM__MAX;
          }
        else if ((stack[stack_size - 1].jint) <= SVM__MIN)
          {
            stack[stack_size - 1].jint = SVM__MIN;
          }
        else
#endif
          {
            jint value = stack[stack_size - 1].jint;
            stack[stack_size - 1].jint = (jshort) value;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IDIV
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IDIV:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IDIV]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jint value1 = stack[stack_size - 2].jint;
        jint value2 = stack[--stack_size].jint;


#if defined(_SABLEVM_SIGNALS_FOR_EXCEPTIONS) && \
  !(defined(__hppa__) || defined(__ia64__) || defined(__powerpc__))

#ifndef NDEBUG

        if (value2 == 0)
          {
            env->sigfpe_expected = JNI_TRUE;
          }

#endif

        /* save pc in case exception is raised */
        env->stack.current_frame->pc = pc;

#else

        if (value2 == 0)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (arithmeticexception_handler);
          }
#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */


#if defined(__i386__) || defined(__powerpc__) || defined(__s390__)
        /*
         * i386 arch is broken and will cause a *FLOAT* point error signal on
         * division of MIN_INT / -1 - so we have to fix it by hand
         * 
         * On s390 this also seem to cause an unexpected signal.
         * 
         * On PowerPC no exception is raised but the result is undefined.
         *
         */
        if ((value1 == (jint) 0x80000000) && (value2 == -1))
          {
            stack[stack_size - 1].jint = value1;
          }
        else
#endif
          {
            stack[stack_size - 1].jint = value1 / value2;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
LDIV
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_LDIV:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p LDIV]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jlong value1 = *((jlong *) (void *) &stack[stack_size - 4]);
        jlong value2 = *((jlong *) (void *) &stack[(stack_size -= 2)]);

#if defined(_SABLEVM_SIGNALS_FOR_EXCEPTIONS) && \
  !(defined(__hppa__) || defined(__ia64__) || defined(__powerpc__) || defined(__s390__))

#ifndef NDEBUG

        if (value2 == 0L)
          {
            env->sigfpe_expected = JNI_TRUE;
          }

#endif

        /* save pc in case exception is raised */
        env->stack.current_frame->pc = pc;

#else

        if (value2 == 0L)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (arithmeticexception_handler);
          }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

        *((jlong *) (void *) &stack[stack_size - 2]) = value1 / value2;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IREM
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IREM:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IREM]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jint value1 = stack[stack_size - 2].jint;
        jint value2 = stack[--stack_size].jint;


#if defined(_SABLEVM_SIGNALS_FOR_EXCEPTIONS) && \
  !(defined(__hppa__) || defined(__ia64__) || defined(__powerpc__))

#ifndef NDEBUG

        if (value2 == 0)
          {
            env->sigfpe_expected = JNI_TRUE;
          }

#endif

        /* save pc in case exception is raised */
        env->stack.current_frame->pc = pc;

#else

        if (value2 == 0)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (arithmeticexception_handler);
          }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

        stack[stack_size - 1].jint = value1 % value2;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
LREM
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_LREM:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p LREM]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jlong value1 = *((jlong *) (void *) &stack[stack_size - 4]);
        jlong value2 = *((jlong *) (void *) &stack[(stack_size -= 2)]);

#if defined(_SABLEVM_SIGNALS_FOR_EXCEPTIONS) && \
  !(defined(__hppa__) || defined(__ia64__) || defined(__powerpc__) || defined(__s390__))

#ifndef NDEBUG

        if (value2 == 0L)
          {
            env->sigfpe_expected = JNI_TRUE;
          }

#endif

        /* save pc in case exception is raised */
        env->stack.current_frame->pc = pc;

#else

        if (value2 == 0L)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (arithmeticexception_handler);
          }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

        *((jlong *) (void *) &stack[stack_size - 2]) = value1 % value2;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
FREM
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_FREM:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p FREM]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jfloat value1 = stack[stack_size - 2].jfloat;
        jfloat value2 = stack[--stack_size].jfloat;
        stack[stack_size - 1].jfloat = _svmm_fmod (value1, value2);
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
DREM
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_DREM:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p DREM]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jdouble value1 = *((jdouble *) (void *) &stack[stack_size - 4]);
        jdouble value2 = *((jdouble *) (void *) &stack[(stack_size -= 2)]);
        *((jdouble *) (void *) &stack[stack_size - 2]) =
          _svmm_fmod (value1, value2);
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ISHL
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ISHL:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ISHL]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jint value1 = stack[stack_size - 2].jint;
        jint value2 = stack[--stack_size].jint;
        stack[stack_size - 1].jint = value1 << (value2 & 0x1f);
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
LSHL
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_LSHL:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p LSHL]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jlong value1 = *((jlong *) (void *) &stack[stack_size - 3]);
        jint value2 = stack[--stack_size].jint;
        *((jlong *) (void *) &stack[stack_size - 2]) =
          value1 << (value2 & 0x3f);
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ISHR
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ISHR:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ISHR]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jint value1 = stack[stack_size - 2].jint;
        jint value2 = stack[--stack_size].jint;
#if defined(SVM_SIGNED_SHR)
        stack[stack_size - 1].jint = value1 >> (value2 & 0x1f);
#elif defined(SVM_UNSIGNED_SHR)
        jint sign = value1 >> 31;
        /* unsigned shift */
        jint result = value1 >> (value2 & 0x1f);
        /* add leading 1s if necessary */
        result |= (-1 * sign) << (0x20 - (value2 & 0x1f));
        stack[stack_size - 1].jint = result;
#endif
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
LSHR
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_LSHR:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p LSHR]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jlong value1 = *((jlong *) (void *) &stack[stack_size - 3]);
        jint value2 = stack[--stack_size].jint;

#if defined(SVM_SIGNED_SHR)
        *((jlong *) (void *) &stack[stack_size - 2]) =
          value1 >> (value2 & 0x3f);
#elif defined(SVM_UNSIGNED_SHR)
        jlong sign = value1 >> 63;
        /* unsigned shift */
        jlong result = value1 >> (value2 & 0x3f);
        /* add leading 1s if necessary */
        result |= (-1L * sign) << (0x40 - (value2 & 0x3f));
        *((jlong *) (void *) &stack[stack_size - 2]) = result;
#endif

      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IUSHR
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IUSHR:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IUSHR]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jint value1 = stack[stack_size - 2].jint;
        jint value2 = stack[--stack_size].jint;
        stack[stack_size - 1].jint =
          ((_svmt_u32) value1) >> (value2 & 0x1f);
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
LUSHR
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_LUSHR:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p LUSHR]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jlong value1 = *((jlong *) (void *) &stack[stack_size - 3]);
        jint value2 = stack[--stack_size].jint;
        *((jlong *) (void *) &stack[stack_size - 2]) =
          ((_svmt_u64) value1) >> (value2 & 0x3f);
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
LCMP
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_LCMP:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p LCMP]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jlong value1 = *((jlong *) (void *) &stack[stack_size - 4]);
        jlong value2 = *((jlong *) (void *) &stack[stack_size - 2]);
        stack[(stack_size -= 3) - 1].jint =
          (value1 > value2) - (value1 < value2);
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
FCMPL
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_FCMPL:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p FCMPL]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jfloat value1 = stack[stack_size - 2].jfloat;
        jfloat value2 = stack[--stack_size].jfloat;

        if (value1 != value1 || value2 != value2)
          {
            /* NaN */
            stack[stack_size - 1].jint = -1;
          }
        else
          {
            stack[stack_size - 1].jint =
            (value1 > value2) - (value1 < value2);
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
FCMPG
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_FCMPG:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p FCMPG]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jfloat value1 = stack[stack_size - 2].jfloat;
        jfloat value2 = stack[--stack_size].jfloat;

        if (value1 != value1 || value2 != value2)
          {
            /* NaN */
            stack[stack_size - 1].jint = 1;
          }
        else
          {
            stack[stack_size - 1].jint =
            (value1 > value2) - (value1 < value2);
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
DCMPL
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_DCMPL:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p DCMPL]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jdouble value1 = *((jdouble *) (void *) &stack[stack_size - 4]);
        jdouble value2 = *((jdouble *) (void *) &stack[stack_size - 2]);

        if (value1 != value1 || value2 != value2)
          {
            /* NaN */
            stack[(stack_size -= 3) - 1].jint = -1;
          }
        else
          {
            stack[(stack_size -= 3) - 1].jint =
            (value1 > value2) - (value1 < value2);
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
DCMPG
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_DCMPG:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p DCMPG]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jdouble value1 = *((jdouble *) (void *) &stack[stack_size - 4]);
        jdouble value2 = *((jdouble *) (void *) &stack[stack_size - 2]);

        if (value1 != value1 || value2 != value2)
          {
            /* NaN */
            stack[(stack_size -= 3) - 1].jint = 1;
          }
        else
          {
            stack[(stack_size -= 3) - 1].jint =
            (value1 > value2) - (value1 < value2);
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IINC
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IINC:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IINC]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jint indx = (pc++)->jint;
        jint constant = (pc++)->jint;
        locals[indx].jint +=constant;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IFEQ
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IFEQ:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IFEQ]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *destination = (pc++)->addr;
        jint value = stack[--stack_size].jint;

        if (value == 0)
          {
            pc = destination;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IFNE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IFNE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IFNE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *destination = (pc++)->addr;
        jint value = stack[--stack_size].jint;

        if (value != 0)
          {
            pc = destination;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IFLT
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IFLT:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IFLT]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *destination = (pc++)->addr;
        jint value = stack[--stack_size].jint;

        if (value < 0)
          {
            pc = destination;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IFLE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IFLE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IFLE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *destination = (pc++)->addr;
        jint value = stack[--stack_size].jint;

        if (value <= 0)
          {
            pc = destination;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IFGT
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IFGT:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IFGT]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *destination = (pc++)->addr;
        jint value = stack[--stack_size].jint;

        if (value > 0)
          {
            pc = destination;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IFGE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IFGE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IFGE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *destination = (pc++)->addr;
        jint value = stack[--stack_size].jint;

        if (value >= 0)
          {
            pc = destination;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IF_ICMPEQ
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IF_ICMPEQ:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IF_ICMPEQ]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *destination = (pc++)->addr;
        jint value1 = stack[(stack_size -= 2)].jint;
        jint value2 = stack[stack_size + 1].jint;

        if (value1 == value2)
          {
            pc = destination;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IF_ICMPNE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IF_ICMPNE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IF_ICMPNE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *destination = (pc++)->addr;
        jint value1 = stack[(stack_size -= 2)].jint;
        jint value2 = stack[stack_size + 1].jint;

        if (value1 != value2)
          {
            pc = destination;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IF_ICMPLT
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IF_ICMPLT:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IF_ICMPLT]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *destination = (pc++)->addr;
        jint value1 = stack[(stack_size -= 2)].jint;
        jint value2 = stack[stack_size + 1].jint;

        if (value1 < value2)
          {
            pc = destination;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IF_ICMPLE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IF_ICMPLE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IF_ICMPLE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *destination = (pc++)->addr;
        jint value1 = stack[(stack_size -= 2)].jint;
        jint value2 = stack[stack_size + 1].jint;

        if (value1 <= value2)
          {
            pc = destination;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IF_ICMPGT
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IF_ICMPGT:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IF_ICMPGT]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *destination = (pc++)->addr;
        jint value1 = stack[(stack_size -= 2)].jint;
        jint value2 = stack[stack_size + 1].jint;

        if (value1 > value2)
          {
            pc = destination;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IF_ICMPGE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IF_ICMPGE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IF_ICMPGE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *destination = (pc++)->addr;
        jint value1 = stack[(stack_size -= 2)].jint;
        jint value2 = stack[stack_size + 1].jint;

        if (value1 >= value2)
          {
            pc = destination;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IF_ACMPEQ
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IF_ACMPEQ:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IF_ACMPEQ]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *destination = (pc++)->addr;
        _svmt_object_instance *ref1 = stack[(stack_size -= 2)].reference;
        _svmt_object_instance *ref2 = stack[stack_size + 1].reference;

        if (ref1 == ref2)
          {
            pc = destination;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IF_ACMPNE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IF_ACMPNE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IF_ACMPNE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *destination = (pc++)->addr;
        _svmt_object_instance *ref1 = stack[(stack_size -= 2)].reference;
        _svmt_object_instance *ref2 = stack[stack_size + 1].reference;

        if (ref1 != ref2)
          {
            pc = destination;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IFEQ_CHECK
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IFEQ_CHECK:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IFEQ_CHECK]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      /* skip stack map */
      assert (stack_size >= pc->stack_gc_map->size);
      pc++;

      /* save state */
      env->stack.current_frame->pc = pc;
      env->stack.current_frame->stack_size = stack_size;

      /* check */
      _svmf_periodic_check (env);

      {
        _svmt_code *destination = (pc++)->addr;
        jint value = stack[--stack_size].jint;

        if (value == 0)
          {
            pc = destination;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IFNE_CHECK
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IFNE_CHECK:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IFNE_CHECK]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      /* skip stack map */
      assert (stack_size >= pc->stack_gc_map->size);
      pc++;

      /* save state */
      env->stack.current_frame->pc = pc;
      env->stack.current_frame->stack_size = stack_size;

      /* check */
      _svmf_periodic_check (env);

      {
        _svmt_code *destination = (pc++)->addr;
        jint value = stack[--stack_size].jint;

        if (value != 0)
          {
            pc = destination;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IFLT_CHECK
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IFLT_CHECK:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IFLT_CHECK]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      /* skip stack map */
      assert (stack_size >= pc->stack_gc_map->size);
      pc++;

      /* save state */
      env->stack.current_frame->pc = pc;
      env->stack.current_frame->stack_size = stack_size;

      /* check */
      _svmf_periodic_check (env);

      {
        _svmt_code *destination = (pc++)->addr;
        jint value = stack[--stack_size].jint;

        if (value < 0)
          {
            pc = destination;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IFLE_CHECK
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IFLE_CHECK:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IFLE_CHECK]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      /* skip stack map */
      assert (stack_size >= pc->stack_gc_map->size);
      pc++;

      /* save state */
      env->stack.current_frame->pc = pc;
      env->stack.current_frame->stack_size = stack_size;

      /* check */
      _svmf_periodic_check (env);

      {
        _svmt_code *destination = (pc++)->addr;
        jint value = stack[--stack_size].jint;

        if (value <= 0)
          {
            pc = destination;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IFGT_CHECK
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IFGT_CHECK:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IFGT_CHECK]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      /* skip stack map */
      assert (stack_size >= pc->stack_gc_map->size);
      pc++;

      /* save state */
      env->stack.current_frame->pc = pc;
      env->stack.current_frame->stack_size = stack_size;

      /* check */
      _svmf_periodic_check (env);

      {
        _svmt_code *destination = (pc++)->addr;
        jint value = stack[--stack_size].jint;

        if (value > 0)
          {
            pc = destination;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IFGE_CHECK
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IFGE_CHECK:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IFGE_CHECK]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      /* skip stack map */
      assert (stack_size >= pc->stack_gc_map->size);
      pc++;

      /* save state */
      env->stack.current_frame->pc = pc;
      env->stack.current_frame->stack_size = stack_size;

      /* check */
      _svmf_periodic_check (env);

      {
        _svmt_code *destination = (pc++)->addr;
        jint value = stack[--stack_size].jint;

        if (value >= 0)
          {
            pc = destination;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IF_ICMPEQ_CHECK
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IF_ICMPEQ_CHECK:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IF_ICMPEQ_CHECK]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      /* skip stack map */
      assert (stack_size >= pc->stack_gc_map->size);
      pc++;

      /* save state */
      env->stack.current_frame->pc = pc;
      env->stack.current_frame->stack_size = stack_size;

      /* check */
      _svmf_periodic_check (env);

      {
        _svmt_code *destination = (pc++)->addr;
        jint value1 = stack[(stack_size -= 2)].jint;
        jint value2 = stack[stack_size + 1].jint;

        if (value1 == value2)
          {
            pc = destination;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IF_ICMPNE_CHECK
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IF_ICMPNE_CHECK:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IF_ICMPNE_CHECK]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      /* skip stack map */
      assert (stack_size >= pc->stack_gc_map->size);
      pc++;

      /* save state */
      env->stack.current_frame->pc = pc;
      env->stack.current_frame->stack_size = stack_size;

      /* check */
      _svmf_periodic_check (env);

      {
        _svmt_code *destination = (pc++)->addr;
        jint value1 = stack[(stack_size -= 2)].jint;
        jint value2 = stack[stack_size + 1].jint;

        if (value1 != value2)
          {
            pc = destination;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IF_ICMPLT_CHECK
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IF_ICMPLT_CHECK:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IF_ICMPLT_CHECK]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      /* skip stack map */
      assert (stack_size >= pc->stack_gc_map->size);
      pc++;

      /* save state */
      env->stack.current_frame->pc = pc;
      env->stack.current_frame->stack_size = stack_size;

      /* check */
      _svmf_periodic_check (env);

      {
        _svmt_code *destination = (pc++)->addr;
        jint value1 = stack[(stack_size -= 2)].jint;
        jint value2 = stack[stack_size + 1].jint;

        if (value1 < value2)
          {
            pc = destination;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IF_ICMPLE_CHECK
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IF_ICMPLE_CHECK:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IF_ICMPLE_CHECK]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      /* skip stack map */
      assert (stack_size >= pc->stack_gc_map->size);
      pc++;

      /* save state */
      env->stack.current_frame->pc = pc;
      env->stack.current_frame->stack_size = stack_size;

      /* check */
      _svmf_periodic_check (env);

      {
        _svmt_code *destination = (pc++)->addr;
        jint value1 = stack[(stack_size -= 2)].jint;
        jint value2 = stack[stack_size + 1].jint;

        if (value1 <= value2)
          {
            pc = destination;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IF_ICMPGT_CHECK
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IF_ICMPGT_CHECK:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IF_ICMPGT_CHECK]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      /* skip stack map */
      assert (stack_size >= pc->stack_gc_map->size);
      pc++;

      /* save state */
      env->stack.current_frame->pc = pc;
      env->stack.current_frame->stack_size = stack_size;

      /* check */
      _svmf_periodic_check (env);

      {
        _svmt_code *destination = (pc++)->addr;
        jint value1 = stack[(stack_size -= 2)].jint;
        jint value2 = stack[stack_size + 1].jint;

        if (value1 > value2)
          {
            pc = destination;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IF_ICMPGE_CHECK
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IF_ICMPGE_CHECK:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IF_ICMPGE_CHECK]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      /* skip stack map */
      assert (stack_size >= pc->stack_gc_map->size);
      pc++;

      /* save state */
      env->stack.current_frame->pc = pc;
      env->stack.current_frame->stack_size = stack_size;

      /* check */
      _svmf_periodic_check (env);

      {
        _svmt_code *destination = (pc++)->addr;
        jint value1 = stack[(stack_size -= 2)].jint;
        jint value2 = stack[stack_size + 1].jint;

        if (value1 >= value2)
          {
            pc = destination;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IF_ACMPEQ_CHECK
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IF_ACMPEQ_CHECK:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IF_ACMPEQ_CHECK]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      /* skip stack map */
      assert (stack_size >= pc->stack_gc_map->size);
      pc++;

      /* save state */
      env->stack.current_frame->pc = pc;
      env->stack.current_frame->stack_size = stack_size;

      /* check */
      _svmf_periodic_check (env);

      {
        _svmt_code *destination = (pc++)->addr;
        _svmt_object_instance *ref1 = stack[(stack_size -= 2)].reference;
        _svmt_object_instance *ref2 = stack[stack_size + 1].reference;

        if (ref1 == ref2)
          {
            pc = destination;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IF_ACMPNE_CHECK
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IF_ACMPNE_CHECK:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IF_ACMPNE_CHECK]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      /* skip stack map */
      assert (stack_size >= pc->stack_gc_map->size);
      pc++;

      /* save state */
      env->stack.current_frame->pc = pc;
      env->stack.current_frame->stack_size = stack_size;

      /* check */
      _svmf_periodic_check (env);

      {
        _svmt_code *destination = (pc++)->addr;
        _svmt_object_instance *ref1 = stack[(stack_size -= 2)].reference;
        _svmt_object_instance *ref2 = stack[stack_size + 1].reference;

        if (ref1 != ref2)
          {
            pc = destination;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
GOTO
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_GOTO:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p GOTO]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      pc = pc->addr;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
GOTO_CHECK
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_GOTO_CHECK:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p GOTO_CHECK]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      /* skip stack map */
      assert (stack_size >= pc->stack_gc_map->size);
      pc++;

      /* save state */
      env->stack.current_frame->pc = pc;
      env->stack.current_frame->stack_size = stack_size;

      /* check */
      _svmf_periodic_check (env);

      pc = pc->addr;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
JSR
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_JSR:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p JSR]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *destination = (pc++)->addr;
        stack[stack_size++].addr = pc;
        pc = destination;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
JSR_CHECK
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_JSR_CHECK:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p JSR_CHECK]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      /* skip stack map */
      assert (stack_size >= pc->stack_gc_map->size);
      pc++;

      /* save state */
      env->stack.current_frame->pc = pc;
      env->stack.current_frame->stack_size = stack_size;

      /* check */
      _svmf_periodic_check (env);

      {
        _svmt_code *destination = (pc++)->addr;
        stack[stack_size++].addr = pc;
        pc = destination;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
RET
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_RET:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p RET]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jint indx = pc->jint;
        pc = locals[indx].addr;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
TABLESWITCH
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_TABLESWITCH:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p TABLESWITCH]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *default_dest = (pc++)->addr;
        jint low = (pc++)->jint;
        jint high = (pc++)->jint;
        _svmt_code *table = pc;
        jint indx = stack[--stack_size].jint;

        if (indx < low || indx > high)
          {
            pc = default_dest;
          }
        else
          {
            pc = table[indx - low].addr;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
TABLESWITCH_CHECK
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_TABLESWITCH_CHECK:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p TABLESWITCH_CHECK]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      /* skip stack map */
      assert (stack_size >= pc->stack_gc_map->size);
      pc++;

      /* save state */
      env->stack.current_frame->pc = pc;
      env->stack.current_frame->stack_size = stack_size;

      /* check */
      _svmf_periodic_check (env);

      {
        _svmt_code *default_dest = (pc++)->addr;
        jint low = (pc++)->jint;
        jint high = (pc++)->jint;
        _svmt_code *table = pc;
        jint indx = stack[--stack_size].jint;

        if (indx < low || indx > high)
          {
            pc = default_dest;
          }
        else
          {
            pc = table[indx - low].addr;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
LOOKUPSWITCH
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_LOOKUPSWITCH:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p LOOKUPSWITCH]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *default_dest = (pc++)->addr;
        jint npairs = (pc++)->jint;
        _svmt_code *table = pc;
        jint key = stack[--stack_size].jint;

        jint low = 0;
        jint high = npairs - 1;

        while (high >= low)
          {
            jint middle = (low + high) / 2;
            jint match = table[middle * 2].jint;

            if (key == match)
            {
              pc = table[middle * 2 + 1].addr;
              break;
            }

            if (key > match)
            {
              low = middle + 1;
            }
            else
            {
              high = middle - 1;
            }
          }

        if (high < low)
          {
            pc = default_dest;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
LOOKUPSWITCH_CHECK
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_LOOKUPSWITCH_CHECK:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p LOOKUPSWITCH_CHECK]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      /* skip stack map */
      assert (stack_size >= pc->stack_gc_map->size);
      pc++;

      /* save state */
      env->stack.current_frame->pc = pc;
      env->stack.current_frame->stack_size = stack_size;

      /* check */
      _svmf_periodic_check (env);

      {
        _svmt_code *default_dest = (pc++)->addr;
        jint npairs = (pc++)->jint;
        _svmt_code *table = pc;
        jint key = stack[--stack_size].jint;

        jint low = 0;
        jint high = npairs - 1;

        while (high >= low)
          {
            jint middle = (low + high) / 2;
            jint match = table[middle * 2].jint;

            if (key == match)
            {
              pc = table[middle * 2 + 1].addr;
              break;
            }

            if (key > match)
            {
              low = middle + 1;
            }
            else
            {
              high = middle - 1;
            }
          }

        if (high < low)
          {
            pc = default_dest;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IRETURN
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IRETURN:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IRETURN]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      /* structured locking */
      if (env->stack.current_frame->lock_count != 0
          && env->vm->enforce_structured_locking)
        {
          /* pop stack frame */
          _svmt_stack_frame *frame = env->stack.current_frame;
          env->stack.current_frame = (_svmt_stack_frame *) (void *)
            (((char *) frame) - frame->previous_offset);

          _svmf_error_IllegalMonitorStateException (env);
          _svmm_goto_label (exception_handler);
        }

#if !defined(NDEBUG)

      _svmf_verbose_methods_exit (env);

#endif

      {
        _svmt_stack_frame *frame;
        _svmt_method_info *caller_method;
        _svmt_method_info *callee_method;
        _svmt_object_instance *this;

        frame = env->stack.current_frame;
        callee_method = frame->method;
        this = frame->this;

        frame =
          (_svmt_stack_frame *) (void *) (((char *) frame) -
                                  frame->previous_offset);
        env->stack.current_frame = frame;
        caller_method = frame->method;
        locals[0].jint = stack[stack_size - 1].jint;

        locals = (_svmt_stack_value *) (void *)
          (((char *) frame) - caller_method->frame_info->start_offset);
        stack = (_svmt_stack_value *) (void *)
          (((char *) frame) + _svmv_stack_offset);
        stack_size = frame->stack_size + 1;
        pc = frame->pc;

        /* is method synchronized? */
        if (callee_method->synchronized)
          {
            /* release monitor */
            if (_svmf_exit_object_monitor (env, this) != JNI_OK)
            {
              _svmm_goto_label (exception_handler);
            }
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
LRETURN
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_LRETURN:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p LRETURN]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      /* structured locking */
      if (env->stack.current_frame->lock_count != 0
          && env->vm->enforce_structured_locking)
        {
          /* pop stack frame */
          _svmt_stack_frame *frame = env->stack.current_frame;
          env->stack.current_frame = (_svmt_stack_frame *) (void *)
            (((char *) frame) - frame->previous_offset);

          _svmf_error_IllegalMonitorStateException (env);
          _svmm_goto_label (exception_handler);
        }

#if !defined(NDEBUG)

      _svmf_verbose_methods_exit (env);

#endif

      {
        _svmt_stack_frame *frame;
        _svmt_method_info *caller_method;
        _svmt_method_info *callee_method;
        _svmt_object_instance *this;

        frame = env->stack.current_frame;
        callee_method = frame->method;
        this = frame->this;

        frame =
          (_svmt_stack_frame *) (void *) (((char *) frame) -
                                  frame->previous_offset);
        env->stack.current_frame = frame;
        caller_method = frame->method;
        *((jlong *) (void *) &locals[0]) = *((jlong *) (void *) &stack[stack_size - 2]);

        locals = (_svmt_stack_value *) (void *)
          (((char *) frame) - caller_method->frame_info->start_offset);
        stack = (_svmt_stack_value *) (void *)
          (((char *) frame) + _svmv_stack_offset);
        stack_size = frame->stack_size + 2;
        pc = frame->pc;

        /* is method synchronized? */
        if (callee_method->synchronized)
          {
            /* release monitor */
            if (_svmf_exit_object_monitor (env, this) != JNI_OK)
            {
              _svmm_goto_label (exception_handler);
            }
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
FRETURN
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_FRETURN:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p FRETURN]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      /* structured locking */
      if (env->stack.current_frame->lock_count != 0
          && env->vm->enforce_structured_locking)
        {
          /* pop stack frame */
          _svmt_stack_frame *frame = env->stack.current_frame;
          env->stack.current_frame = (_svmt_stack_frame *) (void *)
            (((char *) frame) - frame->previous_offset);

          _svmf_error_IllegalMonitorStateException (env);
          _svmm_goto_label (exception_handler);
        }

#if !defined(NDEBUG)

      _svmf_verbose_methods_exit (env);

#endif

      {
        _svmt_stack_frame *frame;
        _svmt_method_info *caller_method;
        _svmt_method_info *callee_method;
        _svmt_object_instance *this;

        frame = env->stack.current_frame;
        callee_method = frame->method;
        this = frame->this;

        frame =
          (_svmt_stack_frame *) (void *) (((char *) frame) -
                                  frame->previous_offset);
        env->stack.current_frame = frame;
        caller_method = frame->method;
        locals[0].jfloat = stack[stack_size - 1].jfloat;

        locals = (_svmt_stack_value *) (void *)
          (((char *) frame) - caller_method->frame_info->start_offset);
        stack = (_svmt_stack_value *) (void *)
          (((char *) frame) + _svmv_stack_offset);
        stack_size = frame->stack_size + 1;
        pc = frame->pc;

        /* is method synchronized? */
        if (callee_method->synchronized)
          {
            /* release monitor */
            if (_svmf_exit_object_monitor (env, this) != JNI_OK)
            {
              _svmm_goto_label (exception_handler);
            }
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
DRETURN
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_DRETURN:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p DRETURN]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      /* structured locking */
      if (env->stack.current_frame->lock_count != 0
          && env->vm->enforce_structured_locking)
        {
          /* pop stack frame */
          _svmt_stack_frame *frame = env->stack.current_frame;
          env->stack.current_frame = (_svmt_stack_frame *) (void *)
            (((char *) frame) - frame->previous_offset);

          _svmf_error_IllegalMonitorStateException (env);
          _svmm_goto_label (exception_handler);
        }

#if !defined(NDEBUG)

      _svmf_verbose_methods_exit (env);

#endif

      {
        _svmt_stack_frame *frame;
        _svmt_method_info *caller_method;
        _svmt_method_info *callee_method;
        _svmt_object_instance *this;

        frame = env->stack.current_frame;
        callee_method = frame->method;
        this = frame->this;

        frame =
          (_svmt_stack_frame *) (void *) (((char *) frame) -
                                  frame->previous_offset);
        env->stack.current_frame = frame;
        caller_method = frame->method;
        *((jdouble *) (void *) &locals[0]) = *((jdouble *) (void *) &stack[stack_size - 2]);

        locals = (_svmt_stack_value *) (void *)
          (((char *) frame) - caller_method->frame_info->start_offset);
        stack = (_svmt_stack_value *) (void *)
          (((char *) frame) + _svmv_stack_offset);
        stack_size = frame->stack_size + 2;
        pc = frame->pc;

        /* is method synchronized? */
        if (callee_method->synchronized)
          {
            /* release monitor */
            if (_svmf_exit_object_monitor (env, this) != JNI_OK)
            {
              _svmm_goto_label (exception_handler);
            }
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ARETURN
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ARETURN:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ARETURN]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      /* structured locking */
      if (env->stack.current_frame->lock_count != 0
          && env->vm->enforce_structured_locking)
        {
          /* pop stack frame */
          _svmt_stack_frame *frame = env->stack.current_frame;
          env->stack.current_frame = (_svmt_stack_frame *) (void *)
            (((char *) frame) - frame->previous_offset);

          _svmf_error_IllegalMonitorStateException (env);
          _svmm_goto_label (exception_handler);
        }

#if !defined(NDEBUG)

      _svmf_verbose_methods_exit (env);

#endif

      {
        _svmt_stack_frame *frame;
        _svmt_method_info *caller_method;
        _svmt_method_info *callee_method;
        _svmt_object_instance *this;

        frame = env->stack.current_frame;
        callee_method = frame->method;
        this = frame->this;

        frame =
          (_svmt_stack_frame *) (void *) (((char *) frame) -
                                  frame->previous_offset);
        env->stack.current_frame = frame;
        caller_method = frame->method;
        locals[0].reference = stack[stack_size - 1].reference;

        locals = (_svmt_stack_value *) (void *)
          (((char *) frame) - caller_method->frame_info->start_offset);
        stack = (_svmt_stack_value *) (void *)
          (((char *) frame) + _svmv_stack_offset);
        stack_size = frame->stack_size + 1;
        pc = frame->pc;

        /* is method synchronized? */
        if (callee_method->synchronized)
          {
            /* release monitor */
            if (_svmf_exit_object_monitor (env, this) != JNI_OK)
            {
              _svmm_goto_label (exception_handler);
            }
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
RETURN
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_RETURN:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p RETURN]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      /* structured locking */
      if (env->stack.current_frame->lock_count != 0
          && env->vm->enforce_structured_locking)
        {
          /* pop stack frame */
          _svmt_stack_frame *frame = env->stack.current_frame;
          env->stack.current_frame = (_svmt_stack_frame *) (void *)
            (((char *) frame) - frame->previous_offset);

          _svmf_error_IllegalMonitorStateException (env);
          _svmm_goto_label (exception_handler);
        }

#if !defined(NDEBUG)

      _svmf_verbose_methods_exit (env);

#endif

      {
        _svmt_stack_frame *frame;
        _svmt_method_info *caller_method;
        _svmt_method_info *callee_method;
        _svmt_object_instance *this;

        frame = env->stack.current_frame;
        callee_method = frame->method;
        this = frame->this;

        frame =
          (_svmt_stack_frame *) (void *) (((char *) frame) -
                                  frame->previous_offset);
        env->stack.current_frame = frame;
        caller_method = frame->method;
        
        locals = (_svmt_stack_value *) (void *)
          (((char *) frame) - caller_method->frame_info->start_offset);
        stack = (_svmt_stack_value *) (void *)
          (((char *) frame) + _svmv_stack_offset);
        stack_size = frame->stack_size + 0;
        pc = frame->pc;

        /* is method synchronized? */
        if (callee_method->synchronized)
          {
            /* release monitor */
            if (_svmf_exit_object_monitor (env, this) != JNI_OK)
            {
              _svmm_goto_label (exception_handler);
            }
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
INVOKEVIRTUAL
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_INVOKEVIRTUAL:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p INVOKEVIRTUAL]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      pc++;             /* skip preparation address */

      {
        jint args_count = (pc++)->jint;
        size_t method_offset = (pc++)->offset;
        _svmt_object_instance *instance =
          stack[(stack_size -= args_count)].reference;
        _svmt_method_info *method;
        _svmt_method_frame_info *frame_info;
        _svmt_stack_frame *frame;

#ifdef _SABLEVM_SIGNALS_FOR_EXCEPTIONS

#ifndef NDEBUG

        if (instance == NULL)
          {
            env->sigsegv_expected = JNI_TRUE;
          }

#endif /* NOT NDEBUG */

        /* save pc in case exception is raised */
        env->stack.current_frame->pc = pc;

#else

        if (instance == NULL)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (nullpointerexception_handler);
          }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

        
        /* the following can cause a segfault */
        method =
          *((_svmt_method_info **) (void *)
            (((char *) instance->vtable) + method_offset));

        
        assert (_svmf_is_assignable_from
              (env, instance->vtable->type,
               _svmf_cast_type_class (method->class_info)));

        frame_info = method->frame_info;

        pc++;                 /* skip gc map */

        /* store return pc & stack size */
        frame = env->stack.current_frame;
        frame->pc = pc;
        frame->stack_size = stack_size;

        /* syncronized? */
        if (method->synchronized)
          {
            /* preserve references on the stack across GC */
            frame->stack_size = stack_size + args_count;

            if (_svmf_enter_object_monitor (env, instance) != JNI_OK)
            {
              goto exception_handler;
            }

            frame->stack_size = stack_size;
            instance = stack[stack_size].reference;
          }

        if (_svmf_ensure_stack_capacity
            (env, frame_info->java_invoke_frame_size) != JNI_OK)
          {
            goto exception_handler;
          }

        frame = env->stack.current_frame;
        stack = (_svmt_stack_value *) (void *)
          (((char *) frame) + _svmv_stack_offset);
        locals = &stack[stack_size];

        /* initialize reference locals to null */
        {
          jint max = frame_info->non_parameter_ref_locals_count;
          jint java_args_count = method->java_args_count;
          jint i;

          for (i = 0; i < max; i++)
            {
            locals[java_args_count + i].reference = NULL;
            }
        }

        /* setup callee frame */
        frame =
          (_svmt_stack_frame *) (void *)
          (((char *) locals) + frame_info->start_offset);
        stack =
          (_svmt_stack_value *) (void *) (((char *) frame) +
                                  _svmv_stack_offset);
        pc = frame_info->code;
        stack_size = 0;

        frame->previous_offset =
          ((char *) frame) - ((char *) env->stack.current_frame);
        frame->end_offset = frame_info->end_offset;
        frame->method = method;
        frame->stack_trace_element = NULL;
        frame->lock_count = 0;
        frame->this = instance;
        frame->pc = pc;
        frame->stack_size = stack_size;

        env->stack.current_frame = frame;

        /* check */
        _svmf_periodic_check (env);
      }

#if !defined(NDEBUG)

      _svmf_verbose_methods_enter (env);

#endif

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
INVOKESPECIAL
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_INVOKESPECIAL:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p INVOKESPECIAL]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      pc++;             /* skip preparation address */

      {
        jint args_count = (pc++)->jint;
        _svmt_method_info *method = (pc++)->method_info;
        _svmt_object_instance *instance =
          stack[(stack_size -= args_count)].reference;
        _svmt_method_frame_info *frame_info;
        _svmt_stack_frame *frame;

        if (instance == NULL)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (nullpointerexception_handler);
          }

        assert (_svmf_is_assignable_from
              (env, instance->vtable->type,
               _svmf_cast_type_class (method->class_info)));

        frame_info = method->frame_info;

        pc++;                 /* skip gc map */

        /* store return pc & stack size */
        frame = env->stack.current_frame;
        frame->pc = pc;
        frame->stack_size = stack_size;

        /* syncronized? */
        if (method->synchronized)
          {
            /* preserve references on the stack across GC */
            frame->stack_size = stack_size + args_count;

            if (_svmf_enter_object_monitor (env, instance) != JNI_OK)
            {
              _svmm_goto_label (exception_handler);
            }

            frame->stack_size = stack_size;
            instance = stack[stack_size].reference;
          }

        if (_svmf_ensure_stack_capacity
            (env, frame_info->java_invoke_frame_size) != JNI_OK)
          {
            _svmm_goto_label (exception_handler);
          }

        frame = env->stack.current_frame;
        stack = (_svmt_stack_value *) (void *)
          (((char *) frame) + _svmv_stack_offset);
        locals = &stack[stack_size];

        /* initialize reference locals to null */
        {
          jint max = frame_info->non_parameter_ref_locals_count;
          jint java_args_count = method->java_args_count;
          jint i;

          for (i = 0; i < max; i++)
            {
            locals[java_args_count + i].reference = NULL;
            }
        }

        /* setup callee frame */
        frame =
          (_svmt_stack_frame *) (void *)
          (((char *) locals) + frame_info->start_offset);
        stack =
          (_svmt_stack_value *) (void *) (((char *) frame) +
                                  _svmv_stack_offset);
        pc = frame_info->code;
        stack_size = 0;

        frame->previous_offset =
          ((char *) frame) - ((char *) env->stack.current_frame);
        frame->end_offset = frame_info->end_offset;
        frame->method = method;
        frame->stack_trace_element = NULL;
        frame->lock_count = 0;
        frame->this = instance;
        frame->pc = pc;
        frame->stack_size = stack_size;

        env->stack.current_frame = frame;

        /* check */
        _svmf_periodic_check (env);
      }

#if !defined(NDEBUG)

      _svmf_verbose_methods_enter (env);

#endif

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
INVOKESTATIC
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_INVOKESTATIC:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p INVOKESTATIC]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      pc++;             /* skip preparation address */

      {
        jint args_count = (pc++)->jint;
        _svmt_method_info *method = (pc++)->method_info;
        _svmt_method_frame_info *frame_info;
        _svmt_stack_frame *frame;

        frame_info = method->frame_info;
        stack_size -= args_count;

        pc++;                 /* skip gc map */

        /* store return pc & stack size */
        frame = env->stack.current_frame;
        frame->pc = pc;
        frame->stack_size = stack_size;

        /* syncronized? */
        if (method->synchronized)
          {
            /* preserve references on the stack across GC */
            frame->stack_size = stack_size + args_count;

            if (_svmf_enter_object_monitor
              (env, *(method->class_info->class_instance)) != JNI_OK)
            {
              _svmm_goto_label (exception_handler);
            }

            frame->stack_size = stack_size;
          }

        if (_svmf_ensure_stack_capacity
            (env, frame_info->java_invoke_frame_size) != JNI_OK)
          {
            _svmm_goto_label (exception_handler);
          }

        frame = env->stack.current_frame;
        stack = (_svmt_stack_value *) (void *)
          (((char *) frame) + _svmv_stack_offset);
        locals = &stack[stack_size];

        /* initialize reference locals to null */
        {
          jint max = frame_info->non_parameter_ref_locals_count;
          jint java_args_count = method->java_args_count;
          jint i;

          for (i = 0; i < max; i++)
            {
            locals[java_args_count + i].reference = NULL;
            }
        }

        /* setup callee frame */
        frame =
          (_svmt_stack_frame *) (void *)
          (((char *) locals) + frame_info->start_offset);
        stack =
          (_svmt_stack_value *) (void *) (((char *) frame) +
                                  _svmv_stack_offset);
        pc = frame_info->code;
        stack_size = 0;

        frame->previous_offset =
          ((char *) frame) - ((char *) env->stack.current_frame);
        frame->end_offset = frame_info->end_offset;
        frame->method = method;
        frame->stack_trace_element = NULL;
        frame->lock_count = 0;
        frame->this = *(method->class_info->class_instance);
        frame->pc = pc;
        frame->stack_size = stack_size;

        env->stack.current_frame = frame;

        /* check */
        _svmf_periodic_check (env);
      }

#if !defined(NDEBUG)

      _svmf_verbose_methods_enter (env);

#endif

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
INVOKEINTERFACE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_INVOKEINTERFACE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p INVOKEINTERFACE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      pc++;             /* skip preparation address */

      {
        jint args_count = (pc++)->jint;
        size_t method_offset = (pc++)->offset;
        _svmt_object_instance *instance =
          stack[(stack_size -= args_count)].reference;
        _svmt_method_info *method;
        _svmt_method_frame_info *frame_info;
        _svmt_stack_frame *frame;

#ifdef _SABLEVM_SIGNALS_FOR_EXCEPTIONS

#ifndef NDEBUG

        if (instance == NULL)
          {
            env->sigsegv_expected = JNI_TRUE;
          }

#endif /* NOT NDEBUG */

        /* save pc in case exception is raised */
        env->stack.current_frame->pc = pc;

#else

        if (instance == NULL)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (nullpointerexception_handler);
          }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

        
        /* the following can cause a segfault */
        method =
          *((_svmt_method_info **) (void *)
            (((char *) instance->vtable) + method_offset));

        
        assert (_svmf_is_assignable_from
              (env, instance->vtable->type,
               _svmf_cast_type_class (method->class_info)));

        frame_info = method->frame_info;

        pc++;                 /* skip gc map */

        /* store return pc & stack size */
        frame = env->stack.current_frame;
        frame->pc = pc;
        frame->stack_size = stack_size;

        /* syncronized? */
        if (method->synchronized)
          {
            /* preserve references on the stack across GC */
            frame->stack_size = stack_size + args_count;

            if (_svmf_enter_object_monitor (env, instance) != JNI_OK)
            {
              _svmm_goto_label (exception_handler);
            }

            frame->stack_size = stack_size;
            instance = stack[stack_size].reference;
          }

        if (_svmf_ensure_stack_capacity
            (env, frame_info->java_invoke_frame_size) != JNI_OK)
          {
            _svmm_goto_label (exception_handler);
          }

        frame = env->stack.current_frame;
        stack = (_svmt_stack_value *) (void *)
          (((char *) frame) + _svmv_stack_offset);
        locals = &stack[stack_size];

        /* initialize reference locals to null */
        {
          jint max = frame_info->non_parameter_ref_locals_count;
          jint java_args_count = method->java_args_count;
          jint i;

          for (i = 0; i < max; i++)
            {
            locals[java_args_count + i].reference = NULL;
            }
        }

        /* setup callee frame */
        frame =
          (_svmt_stack_frame *) (void *)
          (((char *) locals) + frame_info->start_offset);
        stack =
          (_svmt_stack_value *) (void *) (((char *) frame) +
                                  _svmv_stack_offset);
        pc = frame_info->code;
        stack_size = 0;

        frame->previous_offset =
          ((char *) frame) - ((char *) env->stack.current_frame);
        frame->end_offset = frame_info->end_offset;
        frame->method = method;
        frame->stack_trace_element = NULL;
        frame->lock_count = 0;
        frame->this = instance;
        frame->pc = pc;
        frame->stack_size = stack_size;

        env->stack.current_frame = frame;

        /* check */
        _svmf_periodic_check (env);
      }

#if !defined(NDEBUG)

      _svmf_verbose_methods_enter (env);

#endif

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
NEW
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_NEW:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p NEW]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      pc++;             /* skip preparation address */

      {
        _svmt_class_info *class_info = (pc++)->class_info;
        _svmt_object_instance *instance;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmm_new_object_instance (env, class_info, instance) != JNI_OK)
          {
            _svmm_goto_label (exception_handler);
          }

        stack[stack_size++].reference = instance;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ARRAYLENGTH
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ARRAYLENGTH:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ARRAYLENGTH]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_array_instance *array = (_svmt_array_instance *)
          stack[stack_size - 1].reference;

#ifdef _SABLEVM_SIGNALS_FOR_EXCEPTIONS

#ifndef NDEBUG

        if (array == NULL)
          {
            env->sigsegv_expected = JNI_TRUE;
          }

#endif

        /* save pc in case exception is raised */
        env->stack.current_frame->pc = pc;

#else

        if (array == NULL)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (nullpointerexception_handler);
          }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

        assert (array == NULL || array->vtable->type->is_array);

        
        /* can cause sigsegv on NULL array ref */
        stack[stack_size - 1].jint = array->size;

        
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ATHROW
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ATHROW:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ATHROW]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        *(env->throwable) = stack[stack_size - 1].reference;

        env->stack.current_frame->pc = pc;

        _svmm_goto_label (athrow_handler);
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
CHECKCAST
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_CHECKCAST:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p CHECKCAST]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      pc++;             /* skip preparation address */

      {
        _svmt_object_instance *instance = stack[stack_size - 1].reference;
        _svmt_type_info *T = (pc++)->type_info;

        if (instance != NULL)
          {
            _svmt_type_info *S = instance->vtable->type;

            if (!_svmf_is_assignable_from (env, S, T))
            {
              env->stack.current_frame->pc = pc;
              _svmm_goto_label (classcastexception_handler);
            }
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
INSTANCEOF
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_INSTANCEOF:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p INSTANCEOF]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      pc++;             /* skip preparation address */

      {
        _svmt_object_instance *instance = stack[stack_size - 1].reference;
        _svmt_type_info *T = (pc++)->type_info;

        if (instance != NULL)
          {
            _svmt_type_info *S = instance->vtable->type;

            if (_svmf_is_assignable_from (env, S, T))
            {
              stack[stack_size - 1].jint = 1;
            }
            else
            {
              stack[stack_size - 1].jint = 0;
            }
          }
        else
          {
            stack[stack_size - 1].jint = 0;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
MONITORENTER
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_MONITORENTER:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p MONITORENTER]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_object_instance *instance = stack[stack_size - 1].reference;

        if (instance == NULL)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (nullpointerexception_handler);
          }

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_enter_object_monitor (env, instance) != JNI_OK)
          {
            _svmm_goto_label (exception_handler);
          }

        --stack_size;

        /* structured locking */
        env->stack.current_frame->lock_count++;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
MONITOREXIT
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_MONITOREXIT:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p MONITOREXIT]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_object_instance *instance = stack[--stack_size].reference;

        if (instance == NULL)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (nullpointerexception_handler);
          }

        /* structured locking */
        if (--(env->stack.current_frame->lock_count) < 0
            && env->vm->enforce_structured_locking)
          {
            env->stack.current_frame->pc = pc;
            _svmf_error_IllegalMonitorStateException (env);
            _svmm_goto_label (exception_handler);
          }

        if (_svmf_exit_object_monitor (env, instance) != JNI_OK)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (exception_handler);
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IFNULL
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IFNULL:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IFNULL]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *destination = (pc++)->addr;
        _svmt_object_instance *reference = stack[--stack_size].reference;

        if (reference == NULL)
          {
            pc = destination;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IFNULL_CHECK
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IFNULL_CHECK:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IFNULL_CHECK]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      /* skip stack map */
      assert (stack_size >= pc->stack_gc_map->size);
      pc++;

      /* save state */
      env->stack.current_frame->pc = pc;
      env->stack.current_frame->stack_size = stack_size;

      /* check */
      _svmf_periodic_check (env);

      {
        _svmt_code *destination = (pc++)->addr;
        _svmt_object_instance *reference = stack[--stack_size].reference;

        if (reference == NULL)
          {
            pc = destination;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IFNONNULL
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IFNONNULL:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IFNONNULL]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *destination = (pc++)->addr;
        _svmt_object_instance *reference = stack[--stack_size].reference;

        if (reference != NULL)
          {
            pc = destination;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
IFNONNULL_CHECK
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_IFNONNULL_CHECK:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p IFNONNULL_CHECK]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      /* skip stack map */
      assert (stack_size >= pc->stack_gc_map->size);
      pc++;

      /* save state */
      env->stack.current_frame->pc = pc;
      env->stack.current_frame->stack_size = stack_size;

      /* check */
      _svmf_periodic_check (env);

      {
        _svmt_code *destination = (pc++)->addr;
        _svmt_object_instance *reference = stack[--stack_size].reference;

        if (reference != NULL)
          {
            pc = destination;
          }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
LINK_NATIVE_METHOD
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_LINK_NATIVE_METHOD:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p LINK_NATIVE_METHOD]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_method_info *method = env->stack.current_frame->method;
        _svmt_stack_frame *frame;

        if (_svmf_bind_native_method (env, method) != JNI_OK)
          {
            _svmm_goto_label (exception_handler);
          }

        frame = env->stack.current_frame;
        method = frame->method;

        locals =
          (_svmt_stack_value *) (void *) (((char *) frame) -
                                  method->frame_info->start_offset);
        stack =
          (_svmt_stack_value *) (void *) (((char *) frame) +
                                  _svmv_stack_offset);

        pc = method->frame_info->code;
        stack_size = 0;

      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ABSTRACT_METHOD
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ABSTRACT_METHOD:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ABSTRACT_METHOD]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      _svmm_goto_label (abstractmethoderror_handler);

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
NATIVE_STATIC_METHOD
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_NATIVE_STATIC_METHOD:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p NATIVE_STATIC_METHOD]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_method_info *method;
        _svmt_stack_frame *frame;

        if (_svmf_invoke_native_static (env) != JNI_OK)
          {
            _svmm_goto_label (exception_handler);
          }

        frame = env->stack.current_frame;
        method = frame->method;

        locals = (_svmt_stack_value *) (void *)
          (((char *) frame) - method->frame_info->start_offset);
        stack = (_svmt_stack_value *) (void *)
          (((char *) frame) + _svmv_stack_offset);
        stack_size = frame->stack_size;
        pc = frame->pc;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
NATIVE_NONSTATIC_METHOD
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_NATIVE_NONSTATIC_METHOD:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p NATIVE_NONSTATIC_METHOD]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_method_info *method;
        _svmt_stack_frame *frame;

        if (_svmf_invoke_native_nonstatic (env) != JNI_OK)
          {
            _svmm_goto_label (exception_handler);
          }

        frame = env->stack.current_frame;
        method = frame->method;

        locals = (_svmt_stack_value *) (void *)
          (((char *) frame) - method->frame_info->start_offset);
        stack = (_svmt_stack_value *) (void *)
          (((char *) frame) + _svmv_stack_offset);
        stack_size = frame->stack_size;
        pc = frame->pc;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
GETFIELD_BYTE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_GETFIELD_BYTE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p GETFIELD_BYTE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
      
      pc++;             /* skip preparation address */
       
      
      {
        size_t offset = (pc++)->offset;
        _svmt_object_instance *instance = stack[stack_size - 1].reference;

#if defined(_SABLEVM_SIGNALS_FOR_EXCEPTIONS) && !defined(__s390__)

#ifndef NDEBUG

        if (instance == NULL)
          {
            env->sigsegv_expected = JNI_TRUE;
          }

#endif

        /* save pc in case exception is raised */
        env->stack.current_frame->pc = pc;

#else

        if (instance == NULL)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (nullpointerexception_handler);
          }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

        
        stack[stack_size - 1].jint =
          *((jbyte *) (void *) (((char *) instance) + offset));

            }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
GETFIELD_SHORT
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_GETFIELD_SHORT:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p GETFIELD_SHORT]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
      
      pc++;             /* skip preparation address */
       
      
      {
        size_t offset = (pc++)->offset;
        _svmt_object_instance *instance = stack[stack_size - 1].reference;

#if defined(_SABLEVM_SIGNALS_FOR_EXCEPTIONS) && !defined(__s390__)

#ifndef NDEBUG

        if (instance == NULL)
          {
            env->sigsegv_expected = JNI_TRUE;
          }

#endif

        /* save pc in case exception is raised */
        env->stack.current_frame->pc = pc;

#else

        if (instance == NULL)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (nullpointerexception_handler);
          }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

        
        stack[stack_size - 1].jint =
          *((jshort *) (void *) (((char *) instance) + offset));

            }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
GETFIELD_CHAR
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_GETFIELD_CHAR:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p GETFIELD_CHAR]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
      
      pc++;             /* skip preparation address */
       
      
      {
        size_t offset = (pc++)->offset;
        _svmt_object_instance *instance = stack[stack_size - 1].reference;

#if defined(_SABLEVM_SIGNALS_FOR_EXCEPTIONS) && !defined(__s390__)

#ifndef NDEBUG

        if (instance == NULL)
          {
            env->sigsegv_expected = JNI_TRUE;
          }

#endif

        /* save pc in case exception is raised */
        env->stack.current_frame->pc = pc;

#else

        if (instance == NULL)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (nullpointerexception_handler);
          }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

        
        stack[stack_size - 1].jint =
          *((jchar *) (void *) (((char *) instance) + offset));

            }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
GETFIELD_INT
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_GETFIELD_INT:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p GETFIELD_INT]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
      
      pc++;             /* skip preparation address */
       
      
      {
        size_t offset = (pc++)->offset;
        _svmt_object_instance *instance = stack[stack_size - 1].reference;

#if defined(_SABLEVM_SIGNALS_FOR_EXCEPTIONS) && !defined(__s390__)

#ifndef NDEBUG

        if (instance == NULL)
          {
            env->sigsegv_expected = JNI_TRUE;
          }

#endif

        /* save pc in case exception is raised */
        env->stack.current_frame->pc = pc;

#else

        if (instance == NULL)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (nullpointerexception_handler);
          }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

        
        stack[stack_size - 1].jint =
          *((jint *) (void *) (((char *) instance) + offset));

            }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
GETFIELD_LONG
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_GETFIELD_LONG:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p GETFIELD_LONG]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
      
      pc++;             /* skip preparation address */
       
      
      {
        size_t offset = (pc++)->offset;
        _svmt_object_instance *instance = stack[stack_size - 1].reference;

#ifdef _SABLEVM_SIGNALS_FOR_EXCEPTIONS

#ifndef NDEBUG

        if (instance == NULL)
          {
            env->sigsegv_expected = JNI_TRUE;
          }

#endif

        /* save pc in case exception is raised */
        env->stack.current_frame->pc = pc;

#else

        if (instance == NULL)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (nullpointerexception_handler);
          }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

        
        *((jlong *) (void *) &stack[stack_size++ - 1]) =
          *((jlong *) (void *) (((char *) instance) + offset));

            }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
GETFIELD_FLOAT
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_GETFIELD_FLOAT:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p GETFIELD_FLOAT]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
      
      pc++;             /* skip preparation address */
       
      
      {
        size_t offset = (pc++)->offset;
        _svmt_object_instance *instance = stack[stack_size - 1].reference;

#if defined(_SABLEVM_SIGNALS_FOR_EXCEPTIONS) && !defined(__s390__)

#ifndef NDEBUG

        if (instance == NULL)
          {
            env->sigsegv_expected = JNI_TRUE;
          }

#endif

        /* save pc in case exception is raised */
        env->stack.current_frame->pc = pc;

#else

        if (instance == NULL)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (nullpointerexception_handler);
          }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

        
        stack[stack_size - 1].jfloat =
          *((jfloat *) (void *) (((char *) instance) + offset));

            }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
GETFIELD_DOUBLE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_GETFIELD_DOUBLE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p GETFIELD_DOUBLE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
      
      pc++;             /* skip preparation address */
       
      
      {
        size_t offset = (pc++)->offset;
        _svmt_object_instance *instance = stack[stack_size - 1].reference;

#ifdef _SABLEVM_SIGNALS_FOR_EXCEPTIONS

#ifndef NDEBUG

        if (instance == NULL)
          {
            env->sigsegv_expected = JNI_TRUE;
          }

#endif

        /* save pc in case exception is raised */
        env->stack.current_frame->pc = pc;

#else

        if (instance == NULL)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (nullpointerexception_handler);
          }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

        
        *((jdouble *) (void *) &stack[stack_size++ - 1]) =
          *((jdouble *) (void *) (((char *) instance) + offset));

            }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
GETFIELD_REFERENCE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_GETFIELD_REFERENCE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p GETFIELD_REFERENCE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
      
      pc++;             /* skip preparation address */
       
      
      {
        size_t offset = (pc++)->offset;
        _svmt_object_instance *instance = stack[stack_size - 1].reference;

#if defined(_SABLEVM_SIGNALS_FOR_EXCEPTIONS) && !defined(__s390__)

#ifndef NDEBUG

        if (instance == NULL)
          {
            env->sigsegv_expected = JNI_TRUE;
          }

#endif

        /* save pc in case exception is raised */
        env->stack.current_frame->pc = pc;

#else

        if (instance == NULL)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (nullpointerexception_handler);
          }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

        
        stack[stack_size - 1].reference =
          *((_svmt_object_instance * *) (void *) (((char *) instance) + offset));

            }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PUTFIELD_BYTE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PUTFIELD_BYTE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PUTFIELD_BYTE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
      
      pc++;             /* skip preparation address */
       
      
      {
        size_t offset = (pc++)->offset;
        jbyte value = stack[--stack_size].jint;
        _svmt_object_instance *instance = stack[--stack_size].reference;

#if defined(_SABLEVM_SIGNALS_FOR_EXCEPTIONS) && !defined(__s390__)

#ifndef NDEBUG

        if (instance == NULL)
          {
            env->sigsegv_expected = JNI_TRUE;
          }

#endif

        /* save pc in case exception is raised */
        env->stack.current_frame->pc = pc;

#else

        if (instance == NULL)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (nullpointerexception_handler);
          }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

        
        *((jbyte *) (void *) (((char *) instance) + offset)) = value;
/* Note: only _SABLEVM_GC_WRITE_BARRIER_REFERENCE is ever defined */
#if defined (_SABLEVM_GC_WRITE_BARRIER_BYTE)
        _svmf_write_barrier
          (env,
           (_svmt_object_instance **) (void *) ((char *) instance +
                                      offset));
#endif /* _SABLEVM_GC_WRITE_BARRIER */

            }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PUTFIELD_SHORT
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PUTFIELD_SHORT:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PUTFIELD_SHORT]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
      
      pc++;             /* skip preparation address */
       
      
      {
        size_t offset = (pc++)->offset;
        jshort value = stack[--stack_size].jint;
        _svmt_object_instance *instance = stack[--stack_size].reference;

#if defined(_SABLEVM_SIGNALS_FOR_EXCEPTIONS) && !defined(__s390__)

#ifndef NDEBUG

        if (instance == NULL)
          {
            env->sigsegv_expected = JNI_TRUE;
          }

#endif

        /* save pc in case exception is raised */
        env->stack.current_frame->pc = pc;

#else

        if (instance == NULL)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (nullpointerexception_handler);
          }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

        
        *((jshort *) (void *) (((char *) instance) + offset)) = value;
/* Note: only _SABLEVM_GC_WRITE_BARRIER_REFERENCE is ever defined */
#if defined (_SABLEVM_GC_WRITE_BARRIER_SHORT)
        _svmf_write_barrier
          (env,
           (_svmt_object_instance **) (void *) ((char *) instance +
                                      offset));
#endif /* _SABLEVM_GC_WRITE_BARRIER */

            }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PUTFIELD_CHAR
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PUTFIELD_CHAR:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PUTFIELD_CHAR]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
      
      pc++;             /* skip preparation address */
       
      
      {
        size_t offset = (pc++)->offset;
        jchar value = stack[--stack_size].jint;
        _svmt_object_instance *instance = stack[--stack_size].reference;

#if defined(_SABLEVM_SIGNALS_FOR_EXCEPTIONS) && !defined(__s390__)

#ifndef NDEBUG

        if (instance == NULL)
          {
            env->sigsegv_expected = JNI_TRUE;
          }

#endif

        /* save pc in case exception is raised */
        env->stack.current_frame->pc = pc;

#else

        if (instance == NULL)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (nullpointerexception_handler);
          }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

        
        *((jchar *) (void *) (((char *) instance) + offset)) = value;
/* Note: only _SABLEVM_GC_WRITE_BARRIER_REFERENCE is ever defined */
#if defined (_SABLEVM_GC_WRITE_BARRIER_CHAR)
        _svmf_write_barrier
          (env,
           (_svmt_object_instance **) (void *) ((char *) instance +
                                      offset));
#endif /* _SABLEVM_GC_WRITE_BARRIER */

            }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PUTFIELD_INT
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PUTFIELD_INT:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PUTFIELD_INT]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
      
      pc++;             /* skip preparation address */
       
      
      {
        size_t offset = (pc++)->offset;
        jint value = stack[--stack_size].jint;
        _svmt_object_instance *instance = stack[--stack_size].reference;

#if defined(_SABLEVM_SIGNALS_FOR_EXCEPTIONS) && !defined(__s390__)

#ifndef NDEBUG

        if (instance == NULL)
          {
            env->sigsegv_expected = JNI_TRUE;
          }

#endif

        /* save pc in case exception is raised */
        env->stack.current_frame->pc = pc;

#else

        if (instance == NULL)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (nullpointerexception_handler);
          }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

        
        *((jint *) (void *) (((char *) instance) + offset)) = value;
/* Note: only _SABLEVM_GC_WRITE_BARRIER_REFERENCE is ever defined */
#if defined (_SABLEVM_GC_WRITE_BARRIER_INT)
        _svmf_write_barrier
          (env,
           (_svmt_object_instance **) (void *) ((char *) instance +
                                      offset));
#endif /* _SABLEVM_GC_WRITE_BARRIER */

            }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PUTFIELD_LONG
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PUTFIELD_LONG:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PUTFIELD_LONG]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
      
      pc++;             /* skip preparation address */
       
      
      {
        size_t offset = (pc++)->offset;
        jlong value = *((jlong *) (void *) &stack[(stack_size -= 2)]);
        _svmt_object_instance *instance = stack[--stack_size].reference;

#ifdef _SABLEVM_SIGNALS_FOR_EXCEPTIONS

#ifndef NDEBUG

        if (instance == NULL)
          {
            env->sigsegv_expected = JNI_TRUE;
          }

#endif

        /* save pc in case exception is raised */
        env->stack.current_frame->pc = pc;

#else

        if (instance == NULL)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (nullpointerexception_handler);
          }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

        
        *((jlong *) (void *) (((char *) instance) + offset)) = value;

            }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PUTFIELD_FLOAT
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PUTFIELD_FLOAT:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PUTFIELD_FLOAT]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
      
      pc++;             /* skip preparation address */
       
      
      {
        size_t offset = (pc++)->offset;
        jfloat value = stack[--stack_size].jfloat;
        _svmt_object_instance *instance = stack[--stack_size].reference;

#if defined(_SABLEVM_SIGNALS_FOR_EXCEPTIONS) && !defined(__s390__)

#ifndef NDEBUG

        if (instance == NULL)
          {
            env->sigsegv_expected = JNI_TRUE;
          }

#endif

        /* save pc in case exception is raised */
        env->stack.current_frame->pc = pc;

#else

        if (instance == NULL)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (nullpointerexception_handler);
          }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

        
        *((jfloat *) (void *) (((char *) instance) + offset)) = value;
/* Note: only _SABLEVM_GC_WRITE_BARRIER_REFERENCE is ever defined */
#if defined (_SABLEVM_GC_WRITE_BARRIER_FLOAT)
        _svmf_write_barrier
          (env,
           (_svmt_object_instance **) (void *) ((char *) instance +
                                      offset));
#endif /* _SABLEVM_GC_WRITE_BARRIER */

            }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PUTFIELD_DOUBLE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PUTFIELD_DOUBLE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PUTFIELD_DOUBLE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
      
      pc++;             /* skip preparation address */
       
      
      {
        size_t offset = (pc++)->offset;
        jdouble value = *((jdouble *) (void *) &stack[(stack_size -= 2)]);
        _svmt_object_instance *instance = stack[--stack_size].reference;

#ifdef _SABLEVM_SIGNALS_FOR_EXCEPTIONS

#ifndef NDEBUG

        if (instance == NULL)
          {
            env->sigsegv_expected = JNI_TRUE;
          }

#endif

        /* save pc in case exception is raised */
        env->stack.current_frame->pc = pc;

#else

        if (instance == NULL)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (nullpointerexception_handler);
          }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

        
        *((jdouble *) (void *) (((char *) instance) + offset)) = value;

            }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PUTFIELD_REFERENCE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PUTFIELD_REFERENCE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PUTFIELD_REFERENCE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
      
      pc++;             /* skip preparation address */
       
      
      {
        size_t offset = (pc++)->offset;
        _svmt_object_instance * value = stack[--stack_size].reference;
        _svmt_object_instance *instance = stack[--stack_size].reference;

#if defined(_SABLEVM_SIGNALS_FOR_EXCEPTIONS) && !defined(__s390__)

#ifndef NDEBUG

        if (instance == NULL)
          {
            env->sigsegv_expected = JNI_TRUE;
          }

#endif

        /* save pc in case exception is raised */
        env->stack.current_frame->pc = pc;

#else

        if (instance == NULL)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (nullpointerexception_handler);
          }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

        
        *((_svmt_object_instance * *) (void *) (((char *) instance) + offset)) = value;
/* Note: only _SABLEVM_GC_WRITE_BARRIER_REFERENCE is ever defined */
#if defined (_SABLEVM_GC_WRITE_BARRIER_REFERENCE)
        _svmf_write_barrier
          (env,
           (_svmt_object_instance **) (void *) ((char *) instance +
                                      offset));
#endif /* _SABLEVM_GC_WRITE_BARRIER */

            }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
GETSTATIC_BOOLEAN
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_GETSTATIC_BOOLEAN:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p GETSTATIC_BOOLEAN]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
      
      pc++;             /* skip preparation address */
       
      
      {
        jvalue *pvalue = (pc++)->pvalue;
        stack[stack_size++].jint = pvalue->z;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
GETSTATIC_BYTE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_GETSTATIC_BYTE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p GETSTATIC_BYTE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
      
      pc++;             /* skip preparation address */
       
      
      {
        jvalue *pvalue = (pc++)->pvalue;
        stack[stack_size++].jint = pvalue->b;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
GETSTATIC_SHORT
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_GETSTATIC_SHORT:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p GETSTATIC_SHORT]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
      
      pc++;             /* skip preparation address */
       
      
      {
        jvalue *pvalue = (pc++)->pvalue;
        stack[stack_size++].jint = pvalue->s;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
GETSTATIC_CHAR
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_GETSTATIC_CHAR:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p GETSTATIC_CHAR]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
      
      pc++;             /* skip preparation address */
       
      
      {
        jvalue *pvalue = (pc++)->pvalue;
        stack[stack_size++].jint = pvalue->c;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
GETSTATIC_INT
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_GETSTATIC_INT:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p GETSTATIC_INT]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
      
      pc++;             /* skip preparation address */
       
      
      {
        jvalue *pvalue = (pc++)->pvalue;
        stack[stack_size++].jint = pvalue->i;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
GETSTATIC_LONG
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_GETSTATIC_LONG:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p GETSTATIC_LONG]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
      
      pc++;             /* skip preparation address */
       
      
      {
        jvalue *pvalue = (pc++)->pvalue;
        *((jlong *) (void *) &stack[stack_size]) = pvalue->j;
        stack_size += 2;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
GETSTATIC_FLOAT
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_GETSTATIC_FLOAT:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p GETSTATIC_FLOAT]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
      
      pc++;             /* skip preparation address */
       
      
      {
        jvalue *pvalue = (pc++)->pvalue;
        stack[stack_size++].jfloat = pvalue->f;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
GETSTATIC_DOUBLE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_GETSTATIC_DOUBLE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p GETSTATIC_DOUBLE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
      
      pc++;             /* skip preparation address */
       
      
      {
        jvalue *pvalue = (pc++)->pvalue;
        *((jdouble *) (void *) &stack[stack_size]) = pvalue->d;
        stack_size += 2;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PUTSTATIC_BOOLEAN
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PUTSTATIC_BOOLEAN:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PUTSTATIC_BOOLEAN]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
      
      pc++;             /* skip preparation address */
       
      
      {
        jvalue *pvalue = (pc++)->pvalue;
        pvalue->z = stack[--stack_size].jint;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PUTSTATIC_BYTE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PUTSTATIC_BYTE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PUTSTATIC_BYTE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
      
      pc++;             /* skip preparation address */
       
      
      {
        jvalue *pvalue = (pc++)->pvalue;
        pvalue->b = stack[--stack_size].jint;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PUTSTATIC_SHORT
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PUTSTATIC_SHORT:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PUTSTATIC_SHORT]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
      
      pc++;             /* skip preparation address */
       
      
      {
        jvalue *pvalue = (pc++)->pvalue;
        pvalue->s = stack[--stack_size].jint;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PUTSTATIC_CHAR
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PUTSTATIC_CHAR:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PUTSTATIC_CHAR]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
      
      pc++;             /* skip preparation address */
       
      
      {
        jvalue *pvalue = (pc++)->pvalue;
        pvalue->c = stack[--stack_size].jint;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PUTSTATIC_INT
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PUTSTATIC_INT:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PUTSTATIC_INT]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
      
      pc++;             /* skip preparation address */
       
      
      {
        jvalue *pvalue = (pc++)->pvalue;
        pvalue->i = stack[--stack_size].jint;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PUTSTATIC_LONG
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PUTSTATIC_LONG:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PUTSTATIC_LONG]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
      
      pc++;             /* skip preparation address */
       
      
      {
        jvalue *pvalue = (pc++)->pvalue;
        pvalue->j = *((jlong *) (void *) &stack[(stack_size -= 2)]);
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PUTSTATIC_FLOAT
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PUTSTATIC_FLOAT:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PUTSTATIC_FLOAT]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
      
      pc++;             /* skip preparation address */
       
      
      {
        jvalue *pvalue = (pc++)->pvalue;
        pvalue->f = stack[--stack_size].jfloat;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PUTSTATIC_DOUBLE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PUTSTATIC_DOUBLE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PUTSTATIC_DOUBLE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
      
      pc++;             /* skip preparation address */
       
      
      {
        jvalue *pvalue = (pc++)->pvalue;
        pvalue->d = *((jdouble *) (void *) &stack[(stack_size -= 2)]);
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
GETFIELD_BOOLEAN
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_GETFIELD_BOOLEAN:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p GETFIELD_BOOLEAN]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
      
      pc++;             /* skip preparation address */
       
      
      {
        size_t offset = (pc++)->offset;
        _svmt_object_instance *instance = stack[stack_size - 1].reference;

#ifdef _SABLEVM_SIGNALS_FOR_EXCEPTIONS

#ifndef NDEBUG

        if (instance == NULL)
          {
            env->sigsegv_expected = JNI_TRUE;
          }

#endif

        /* save pc in case exception is raised */
        env->stack.current_frame->pc = pc;

#else

        if (instance == NULL)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (nullpointerexception_handler);
          }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

        
        stack[stack_size - 1].jint =
          (((_svmt_u8 *) instance)[offset / 8] >> (offset % 8)) & 1;

            }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PUTFIELD_BOOLEAN
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PUTFIELD_BOOLEAN:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PUTFIELD_BOOLEAN]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
      
      pc++;             /* skip preparation address */
       
      
      {
        size_t offset = (pc++)->offset;
        _svmt_u8 value = 0x01 & stack[--stack_size].jint;
        _svmt_u8 nvalue = 0x01 ^ value;
        _svmt_object_instance *instance = stack[--stack_size].reference;

#ifdef _SABLEVM_SIGNALS_FOR_EXCEPTIONS

#ifndef NDEBUG

        if (instance == NULL)
          {
            env->sigsegv_expected = JNI_TRUE;
          }

#endif

        /* save pc in case exception is raised */
        env->stack.current_frame->pc = pc;

#else

        if (instance == NULL)
          {
            env->stack.current_frame->pc = pc;
            _svmm_goto_label (nullpointerexception_handler);
          }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

        
        /* to avoid conditional jumps we use boolean arithmetic */
        ((_svmt_u8 *) instance)[offset / 8] |= (value << (offset % 8));
        ((_svmt_u8 *) instance)[offset / 8] &= ~(nvalue << (offset % 8));

            }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
GETSTATIC_REFERENCE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_GETSTATIC_REFERENCE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p GETSTATIC_REFERENCE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
      
      pc++;             /* skip preparation address */
       
      
      {
        jvalue *pvalue = (pc++)->pvalue;
        stack[stack_size++].reference = *(pvalue->l);

#if defined (MAGIC) && !defined (_SABLEVM_INLINED_THREADED_INTERPRETER)
        assert (stack[stack_size - 1].reference == NULL ||
              strcmp (stack[stack_size - 1].reference->magic,
                    "SableVM") == 0);
#endif
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PUTSTATIC_REFERENCE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PUTSTATIC_REFERENCE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PUTSTATIC_REFERENCE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
      
      pc++;             /* skip preparation address */
       
      
      {
        jvalue *pvalue = (pc++)->pvalue;
        *(pvalue->l) = stack[--stack_size].reference;
#if defined (_SABLEVM_GC_WRITE_BARRIER)
        _svmf_write_barrier (env, (_svmt_object_instance **) pvalue->l);
#endif /* _SABLEVM_GC_WRITE_BARRIER */
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ASTORE_RET
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ASTORE_RET:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ASTORE_RET]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        jint indx = (pc++)->jint;
        locals[indx].addr = stack[--stack_size].addr;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ASTORE_RET_0
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ASTORE_RET_0:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ASTORE_RET_0]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        locals[0].addr = stack[--stack_size].addr;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ASTORE_RET_1
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ASTORE_RET_1:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ASTORE_RET_1]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        locals[1].addr = stack[--stack_size].addr;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ASTORE_RET_2
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ASTORE_RET_2:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ASTORE_RET_2]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        locals[2].addr = stack[--stack_size].addr;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ASTORE_RET_3
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ASTORE_RET_3:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ASTORE_RET_3]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        locals[3].addr = stack[--stack_size].addr;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
NEXT
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_NEXT:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p NEXT]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
#ifdef _SABLEVM_INLINED_THREADED_INTERPRETER

      _svmf_goto ((pc++)->implementation);

#endif

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
NEWARRAY_BOOLEAN
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_NEWARRAY_BOOLEAN:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p NEWARRAY_BOOLEAN]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_JavaVM *vm = env->vm;
        jint count = stack[--stack_size].jint;
        _svmt_array_instance *instance;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (count < 0)
          {
            _svmf_error_NegativeArraySizeException (env);
            _svmm_goto_label (exception_handler);
          }

        if (_svmm_new_array_instance
            (env, vm->class_loading.boot_loader.classes.boolean_array,
             count, instance) != JNI_OK)
          {
            _svmm_goto_label (exception_handler);
          }

        stack[stack_size++].reference =
          _svmf_cast_object_instance (instance);
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
NEWARRAY_BYTE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_NEWARRAY_BYTE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p NEWARRAY_BYTE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_JavaVM *vm = env->vm;
        jint count = stack[--stack_size].jint;
        _svmt_array_instance *instance;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (count < 0)
          {
            _svmf_error_NegativeArraySizeException (env);
            _svmm_goto_label (exception_handler);
          }

        if (_svmm_new_array_instance
            (env, vm->class_loading.boot_loader.classes.byte_array,
             count, instance) != JNI_OK)
          {
            _svmm_goto_label (exception_handler);
          }

        stack[stack_size++].reference =
          _svmf_cast_object_instance (instance);
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
NEWARRAY_SHORT
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_NEWARRAY_SHORT:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p NEWARRAY_SHORT]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_JavaVM *vm = env->vm;
        jint count = stack[--stack_size].jint;
        _svmt_array_instance *instance;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (count < 0)
          {
            _svmf_error_NegativeArraySizeException (env);
            _svmm_goto_label (exception_handler);
          }

        if (_svmm_new_array_instance
            (env, vm->class_loading.boot_loader.classes.short_array,
             count, instance) != JNI_OK)
          {
            _svmm_goto_label (exception_handler);
          }

        stack[stack_size++].reference =
          _svmf_cast_object_instance (instance);
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
NEWARRAY_CHAR
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_NEWARRAY_CHAR:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p NEWARRAY_CHAR]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_JavaVM *vm = env->vm;
        jint count = stack[--stack_size].jint;
        _svmt_array_instance *instance;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (count < 0)
          {
            _svmf_error_NegativeArraySizeException (env);
            _svmm_goto_label (exception_handler);
          }

        if (_svmm_new_array_instance
            (env, vm->class_loading.boot_loader.classes.char_array,
             count, instance) != JNI_OK)
          {
            _svmm_goto_label (exception_handler);
          }

        stack[stack_size++].reference =
          _svmf_cast_object_instance (instance);
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
NEWARRAY_INT
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_NEWARRAY_INT:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p NEWARRAY_INT]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_JavaVM *vm = env->vm;
        jint count = stack[--stack_size].jint;
        _svmt_array_instance *instance;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (count < 0)
          {
            _svmf_error_NegativeArraySizeException (env);
            _svmm_goto_label (exception_handler);
          }

        if (_svmm_new_array_instance
            (env, vm->class_loading.boot_loader.classes.int_array,
             count, instance) != JNI_OK)
          {
            _svmm_goto_label (exception_handler);
          }

        stack[stack_size++].reference =
          _svmf_cast_object_instance (instance);
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
NEWARRAY_LONG
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_NEWARRAY_LONG:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p NEWARRAY_LONG]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_JavaVM *vm = env->vm;
        jint count = stack[--stack_size].jint;
        _svmt_array_instance *instance;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (count < 0)
          {
            _svmf_error_NegativeArraySizeException (env);
            _svmm_goto_label (exception_handler);
          }

        if (_svmm_new_array_instance
            (env, vm->class_loading.boot_loader.classes.long_array,
             count, instance) != JNI_OK)
          {
            _svmm_goto_label (exception_handler);
          }

        stack[stack_size++].reference =
          _svmf_cast_object_instance (instance);
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
NEWARRAY_FLOAT
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_NEWARRAY_FLOAT:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p NEWARRAY_FLOAT]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_JavaVM *vm = env->vm;
        jint count = stack[--stack_size].jint;
        _svmt_array_instance *instance;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (count < 0)
          {
            _svmf_error_NegativeArraySizeException (env);
            _svmm_goto_label (exception_handler);
          }

        if (_svmm_new_array_instance
            (env, vm->class_loading.boot_loader.classes.float_array,
             count, instance) != JNI_OK)
          {
            _svmm_goto_label (exception_handler);
          }

        stack[stack_size++].reference =
          _svmf_cast_object_instance (instance);
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
NEWARRAY_DOUBLE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_NEWARRAY_DOUBLE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p NEWARRAY_DOUBLE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_JavaVM *vm = env->vm;
        jint count = stack[--stack_size].jint;
        _svmt_array_instance *instance;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (count < 0)
          {
            _svmf_error_NegativeArraySizeException (env);
            _svmm_goto_label (exception_handler);
          }

        if (_svmm_new_array_instance
            (env, vm->class_loading.boot_loader.classes.double_array,
             count, instance) != JNI_OK)
          {
            _svmm_goto_label (exception_handler);
          }

        stack[stack_size++].reference =
          _svmf_cast_object_instance (instance);
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ANEWARRAY
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ANEWARRAY:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ANEWARRAY]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      pc++;             /* skip preparation address */

      {
        _svmt_array_info *array_info = (pc++)->array_info;
        jint count = stack[--stack_size].jint;
        _svmt_array_instance *instance;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (count < 0)
          {
            _svmf_error_NegativeArraySizeException (env);
            _svmm_goto_label (exception_handler);
          }

        if (_svmm_new_array_instance
            (env, array_info, count, instance) != JNI_OK)
          {
            _svmm_goto_label (exception_handler);
          }

        stack[stack_size++].reference =
          _svmf_cast_object_instance (instance);
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
MULTIANEWARRAY
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_MULTIANEWARRAY:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p MULTIANEWARRAY]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      pc++;             /* skip preparation address */

      {
        _svmt_array_info *array_info = (pc++)->array_info;
        jint dimensions = (pc++)->jint;
        _svmt_array_instance *instance;

        stack_size -= dimensions;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmm_multianewarray
            (env, array_info, dimensions, stack[stack_size],
             instance) != JNI_OK)
          {
            _svmm_goto_label (exception_handler);
          }

        stack[stack_size++].reference =
          _svmf_cast_object_instance (instance);
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
ERROR
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_ERROR:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p ERROR]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      _svmm_fatal_error ("grave internal VM error");

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
INTERNAL_CALL_END
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_INTERNAL_CALL_END:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p INTERNAL_CALL_END]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
#if defined(_SABLEVM_SIGNALS_FOR_EXCEPTIONS) || defined(_SABLEVM_INLINABILITY_TESTING)
      env->signal_handler = previous_signal_handler;
#endif
      return (*(env->throwable) == NULL) ? JNI_OK : JNI_ERR;

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
SKIP
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_SKIP:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p SKIP]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      pc++;             /* skip preparation address */

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
REPLACE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_REPLACE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p REPLACE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_code code = *(pc++);

        *addr = code;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_METHOD
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_METHOD:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_METHOD]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_stack_frame *frame = env->stack.current_frame;
        _svmt_method_info *method = frame->method;

        if (_svmf_prepare_code (env, method) != JNI_OK)
          {
            goto exception_handler;
          }

        frame = env->stack.current_frame;
        method = frame->method;

        locals =
          (_svmt_stack_value *) (void *) (((char *) frame) -
                                  method->frame_info->start_offset);
        stack =
          (_svmt_stack_value *) (void *) (((char *) frame) +
                                  _svmv_stack_offset);

        pc = method->frame_info->code;
        stack_size = 0;
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_LDC_STRING
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_LDC_STRING:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_LDC_STRING]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_String_info *stringref_info = (pc++)->stringref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_String (env, stringref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->jobject = stringref_info->value;

        /* execute bytecode */
        stack[stack_size++].reference = *(stringref_info->value);
      }

#if defined (MAGIC)
      assert (stack[stack_size - 1].reference == NULL ||
            strcmp (stack[stack_size - 1].reference->magic,
                  "SableVM") == 0);
#endif

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_GETFIELD_BOOLEAN
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_GETFIELD_BOOLEAN:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_GETFIELD_BOOLEAN]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Fieldref_info *fieldref_info = (pc++)->fieldref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Fieldref
            (env, env->stack.current_frame->method->class_info,
             fieldref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->offset = fieldref_info->field->data.instance_field.offset;

        /* execute bytecode */
        {
          size_t offset = fieldref_info->field->data.instance_field.offset;
          _svmt_object_instance *instance = stack[stack_size - 1].reference;

          if (instance == NULL)
            {
            goto nullpointerexception_handler;
            }

          stack[stack_size - 1].jint = _svmf_get_BOOLEAN_field (instance, offset);
        }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_GETFIELD_BYTE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_GETFIELD_BYTE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_GETFIELD_BYTE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Fieldref_info *fieldref_info = (pc++)->fieldref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Fieldref
            (env, env->stack.current_frame->method->class_info,
             fieldref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->offset = fieldref_info->field->data.instance_field.offset;

        /* execute bytecode */
        {
          size_t offset = fieldref_info->field->data.instance_field.offset;
          _svmt_object_instance *instance = stack[stack_size - 1].reference;

          if (instance == NULL)
            {
            goto nullpointerexception_handler;
            }

          stack[stack_size - 1].jint = _svmf_get_BYTE_field (instance, offset);
        }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_GETFIELD_SHORT
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_GETFIELD_SHORT:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_GETFIELD_SHORT]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Fieldref_info *fieldref_info = (pc++)->fieldref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Fieldref
            (env, env->stack.current_frame->method->class_info,
             fieldref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->offset = fieldref_info->field->data.instance_field.offset;

        /* execute bytecode */
        {
          size_t offset = fieldref_info->field->data.instance_field.offset;
          _svmt_object_instance *instance = stack[stack_size - 1].reference;

          if (instance == NULL)
            {
            goto nullpointerexception_handler;
            }

          stack[stack_size - 1].jint = _svmf_get_SHORT_field (instance, offset);
        }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_GETFIELD_CHAR
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_GETFIELD_CHAR:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_GETFIELD_CHAR]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Fieldref_info *fieldref_info = (pc++)->fieldref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Fieldref
            (env, env->stack.current_frame->method->class_info,
             fieldref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->offset = fieldref_info->field->data.instance_field.offset;

        /* execute bytecode */
        {
          size_t offset = fieldref_info->field->data.instance_field.offset;
          _svmt_object_instance *instance = stack[stack_size - 1].reference;

          if (instance == NULL)
            {
            goto nullpointerexception_handler;
            }

          stack[stack_size - 1].jint = _svmf_get_CHAR_field (instance, offset);
        }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_GETFIELD_INT
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_GETFIELD_INT:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_GETFIELD_INT]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Fieldref_info *fieldref_info = (pc++)->fieldref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Fieldref
            (env, env->stack.current_frame->method->class_info,
             fieldref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->offset = fieldref_info->field->data.instance_field.offset;

        /* execute bytecode */
        {
          size_t offset = fieldref_info->field->data.instance_field.offset;
          _svmt_object_instance *instance = stack[stack_size - 1].reference;

          if (instance == NULL)
            {
            goto nullpointerexception_handler;
            }

          stack[stack_size - 1].jint = _svmf_get_INT_field (instance, offset);
        }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_GETFIELD_LONG
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_GETFIELD_LONG:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_GETFIELD_LONG]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Fieldref_info *fieldref_info = (pc++)->fieldref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Fieldref
            (env, env->stack.current_frame->method->class_info,
             fieldref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->offset = fieldref_info->field->data.instance_field.offset;

        /* execute bytecode */
        {
          size_t offset = fieldref_info->field->data.instance_field.offset;
          _svmt_object_instance *instance = stack[stack_size - 1].reference;

          if (instance == NULL)
            {
            goto nullpointerexception_handler;
            }

          *((jlong *) (void *) &stack[stack_size++ - 1]) =
            _svmf_get_LONG_field (instance, offset);
        }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_GETFIELD_FLOAT
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_GETFIELD_FLOAT:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_GETFIELD_FLOAT]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Fieldref_info *fieldref_info = (pc++)->fieldref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Fieldref
            (env, env->stack.current_frame->method->class_info,
             fieldref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->offset = fieldref_info->field->data.instance_field.offset;

        /* execute bytecode */
        {
          size_t offset = fieldref_info->field->data.instance_field.offset;
          _svmt_object_instance *instance = stack[stack_size - 1].reference;

          if (instance == NULL)
            {
            goto nullpointerexception_handler;
            }

          stack[stack_size - 1].jfloat = _svmf_get_FLOAT_field (instance, offset);
        }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_GETFIELD_DOUBLE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_GETFIELD_DOUBLE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_GETFIELD_DOUBLE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Fieldref_info *fieldref_info = (pc++)->fieldref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Fieldref
            (env, env->stack.current_frame->method->class_info,
             fieldref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->offset = fieldref_info->field->data.instance_field.offset;

        /* execute bytecode */
        {
          size_t offset = fieldref_info->field->data.instance_field.offset;
          _svmt_object_instance *instance = stack[stack_size - 1].reference;

          if (instance == NULL)
            {
            goto nullpointerexception_handler;
            }

          *((jdouble *) (void *) &stack[stack_size++ - 1]) =
            _svmf_get_DOUBLE_field (instance, offset);
        }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_GETFIELD_REFERENCE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_GETFIELD_REFERENCE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_GETFIELD_REFERENCE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Fieldref_info *fieldref_info = (pc++)->fieldref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Fieldref
            (env, env->stack.current_frame->method->class_info,
             fieldref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->offset = fieldref_info->field->data.instance_field.offset;

        /* execute bytecode */
        {
          size_t offset = fieldref_info->field->data.instance_field.offset;
          _svmt_object_instance *instance = stack[stack_size - 1].reference;

          if (instance == NULL)
            {
            goto nullpointerexception_handler;
            }

          stack[stack_size - 1].reference = _svmf_get_REFERENCE_field (instance, offset);
        }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_PUTFIELD_BOOLEAN
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_PUTFIELD_BOOLEAN:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_PUTFIELD_BOOLEAN]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Fieldref_info *fieldref_info = (pc++)->fieldref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Fieldref
            (env, env->stack.current_frame->method->class_info,
             fieldref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->offset = fieldref_info->field->data.instance_field.offset;

        /* execute bytecode */
        {
          size_t offset = fieldref_info->field->data.instance_field.offset;
          jboolean value = stack[--stack_size].jint;
          _svmt_object_instance *instance = stack[--stack_size].reference;

          if (instance == NULL)
            {
            goto nullpointerexception_handler;
            }

          _svmf_put_BOOLEAN_field (instance, offset, value);
/* Note: only _SABLEVM_GC_WRITE_BARRIER_REFERENCE is ever defined */
#if defined (_SABLEVM_GC_WRITE_BARRIER_BOOLEAN)
          _svmf_write_barrier
            (env,
             (_svmt_object_instance **) (void *) ((char *) instance +
                                        offset));
#endif /* _SABLEVM_GC_WRITE_BARRIER */
        }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_PUTFIELD_BYTE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_PUTFIELD_BYTE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_PUTFIELD_BYTE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Fieldref_info *fieldref_info = (pc++)->fieldref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Fieldref
            (env, env->stack.current_frame->method->class_info,
             fieldref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->offset = fieldref_info->field->data.instance_field.offset;

        /* execute bytecode */
        {
          size_t offset = fieldref_info->field->data.instance_field.offset;
          jbyte value = stack[--stack_size].jint;
          _svmt_object_instance *instance = stack[--stack_size].reference;

          if (instance == NULL)
            {
            goto nullpointerexception_handler;
            }

          _svmf_put_BYTE_field (instance, offset, value);
/* Note: only _SABLEVM_GC_WRITE_BARRIER_REFERENCE is ever defined */
#if defined (_SABLEVM_GC_WRITE_BARRIER_BYTE)
          _svmf_write_barrier
            (env,
             (_svmt_object_instance **) (void *) ((char *) instance +
                                        offset));
#endif /* _SABLEVM_GC_WRITE_BARRIER */
        }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_PUTFIELD_SHORT
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_PUTFIELD_SHORT:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_PUTFIELD_SHORT]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Fieldref_info *fieldref_info = (pc++)->fieldref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Fieldref
            (env, env->stack.current_frame->method->class_info,
             fieldref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->offset = fieldref_info->field->data.instance_field.offset;

        /* execute bytecode */
        {
          size_t offset = fieldref_info->field->data.instance_field.offset;
          jshort value = stack[--stack_size].jint;
          _svmt_object_instance *instance = stack[--stack_size].reference;

          if (instance == NULL)
            {
            goto nullpointerexception_handler;
            }

          _svmf_put_SHORT_field (instance, offset, value);
/* Note: only _SABLEVM_GC_WRITE_BARRIER_REFERENCE is ever defined */
#if defined (_SABLEVM_GC_WRITE_BARRIER_SHORT)
          _svmf_write_barrier
            (env,
             (_svmt_object_instance **) (void *) ((char *) instance +
                                        offset));
#endif /* _SABLEVM_GC_WRITE_BARRIER */
        }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_PUTFIELD_CHAR
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_PUTFIELD_CHAR:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_PUTFIELD_CHAR]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Fieldref_info *fieldref_info = (pc++)->fieldref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Fieldref
            (env, env->stack.current_frame->method->class_info,
             fieldref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->offset = fieldref_info->field->data.instance_field.offset;

        /* execute bytecode */
        {
          size_t offset = fieldref_info->field->data.instance_field.offset;
          jchar value = stack[--stack_size].jint;
          _svmt_object_instance *instance = stack[--stack_size].reference;

          if (instance == NULL)
            {
            goto nullpointerexception_handler;
            }

          _svmf_put_CHAR_field (instance, offset, value);
/* Note: only _SABLEVM_GC_WRITE_BARRIER_REFERENCE is ever defined */
#if defined (_SABLEVM_GC_WRITE_BARRIER_CHAR)
          _svmf_write_barrier
            (env,
             (_svmt_object_instance **) (void *) ((char *) instance +
                                        offset));
#endif /* _SABLEVM_GC_WRITE_BARRIER */
        }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_PUTFIELD_INT
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_PUTFIELD_INT:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_PUTFIELD_INT]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Fieldref_info *fieldref_info = (pc++)->fieldref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Fieldref
            (env, env->stack.current_frame->method->class_info,
             fieldref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->offset = fieldref_info->field->data.instance_field.offset;

        /* execute bytecode */
        {
          size_t offset = fieldref_info->field->data.instance_field.offset;
          jint value = stack[--stack_size].jint;
          _svmt_object_instance *instance = stack[--stack_size].reference;

          if (instance == NULL)
            {
            goto nullpointerexception_handler;
            }

          _svmf_put_INT_field (instance, offset, value);
/* Note: only _SABLEVM_GC_WRITE_BARRIER_REFERENCE is ever defined */
#if defined (_SABLEVM_GC_WRITE_BARRIER_INT)
          _svmf_write_barrier
            (env,
             (_svmt_object_instance **) (void *) ((char *) instance +
                                        offset));
#endif /* _SABLEVM_GC_WRITE_BARRIER */
        }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_PUTFIELD_LONG
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_PUTFIELD_LONG:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_PUTFIELD_LONG]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Fieldref_info *fieldref_info = (pc++)->fieldref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Fieldref
            (env, env->stack.current_frame->method->class_info,
             fieldref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->offset = fieldref_info->field->data.instance_field.offset;

        /* execute bytecode */
        {
          size_t offset = fieldref_info->field->data.instance_field.offset;
          jlong value = *((jlong *) (void *) &stack[(stack_size -= 2)]);
          _svmt_object_instance *instance = stack[--stack_size].reference;

          if (instance == NULL)
            {
            goto nullpointerexception_handler;
            }

          _svmf_put_LONG_field (instance, offset, value);
        }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_PUTFIELD_FLOAT
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_PUTFIELD_FLOAT:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_PUTFIELD_FLOAT]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Fieldref_info *fieldref_info = (pc++)->fieldref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Fieldref
            (env, env->stack.current_frame->method->class_info,
             fieldref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->offset = fieldref_info->field->data.instance_field.offset;

        /* execute bytecode */
        {
          size_t offset = fieldref_info->field->data.instance_field.offset;
          jfloat value = stack[--stack_size].jfloat;
          _svmt_object_instance *instance = stack[--stack_size].reference;

          if (instance == NULL)
            {
            goto nullpointerexception_handler;
            }

          _svmf_put_FLOAT_field (instance, offset, value);
/* Note: only _SABLEVM_GC_WRITE_BARRIER_REFERENCE is ever defined */
#if defined (_SABLEVM_GC_WRITE_BARRIER_FLOAT)
          _svmf_write_barrier
            (env,
             (_svmt_object_instance **) (void *) ((char *) instance +
                                        offset));
#endif /* _SABLEVM_GC_WRITE_BARRIER */
        }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_PUTFIELD_DOUBLE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_PUTFIELD_DOUBLE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_PUTFIELD_DOUBLE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Fieldref_info *fieldref_info = (pc++)->fieldref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Fieldref
            (env, env->stack.current_frame->method->class_info,
             fieldref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->offset = fieldref_info->field->data.instance_field.offset;

        /* execute bytecode */
        {
          size_t offset = fieldref_info->field->data.instance_field.offset;
          jdouble value = *((jdouble *) (void *) &stack[(stack_size -= 2)]);
          _svmt_object_instance *instance = stack[--stack_size].reference;

          if (instance == NULL)
            {
            goto nullpointerexception_handler;
            }

          _svmf_put_DOUBLE_field (instance, offset, value);
        }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_PUTFIELD_REFERENCE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_PUTFIELD_REFERENCE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_PUTFIELD_REFERENCE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Fieldref_info *fieldref_info = (pc++)->fieldref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Fieldref
            (env, env->stack.current_frame->method->class_info,
             fieldref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->offset = fieldref_info->field->data.instance_field.offset;

        /* execute bytecode */
        {
          size_t offset = fieldref_info->field->data.instance_field.offset;
          _svmt_object_instance * value = stack[--stack_size].reference;
          _svmt_object_instance *instance = stack[--stack_size].reference;

          if (instance == NULL)
            {
            goto nullpointerexception_handler;
            }

          _svmf_put_REFERENCE_field (instance, offset, value);
/* Note: only _SABLEVM_GC_WRITE_BARRIER_REFERENCE is ever defined */
#if defined (_SABLEVM_GC_WRITE_BARRIER_REFERENCE)
          _svmf_write_barrier
            (env,
             (_svmt_object_instance **) (void *) ((char *) instance +
                                        offset));
#endif /* _SABLEVM_GC_WRITE_BARRIER */
        }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_GETSTATIC_BOOLEAN
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_GETSTATIC_BOOLEAN:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_GETSTATIC_BOOLEAN]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Fieldref_info *fieldref_info = (pc++)->fieldref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Fieldref
            (env, env->stack.current_frame->method->class_info,
             fieldref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        if (_svmf_class_initialization
            (env, fieldref_info->field->class_info) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->pvalue = &(fieldref_info->field->data.class_field.value);

        /* execute bytecode */
        {
          jvalue *pvalue = &(fieldref_info->field->data.class_field.value);
          stack[stack_size++].jint = _svmf_get_BOOLEAN_static (pvalue);
        }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_GETSTATIC_BYTE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_GETSTATIC_BYTE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_GETSTATIC_BYTE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Fieldref_info *fieldref_info = (pc++)->fieldref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Fieldref
            (env, env->stack.current_frame->method->class_info,
             fieldref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        if (_svmf_class_initialization
            (env, fieldref_info->field->class_info) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->pvalue = &(fieldref_info->field->data.class_field.value);

        /* execute bytecode */
        {
          jvalue *pvalue = &(fieldref_info->field->data.class_field.value);
          stack[stack_size++].jint = _svmf_get_BYTE_static (pvalue);
        }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_GETSTATIC_SHORT
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_GETSTATIC_SHORT:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_GETSTATIC_SHORT]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Fieldref_info *fieldref_info = (pc++)->fieldref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Fieldref
            (env, env->stack.current_frame->method->class_info,
             fieldref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        if (_svmf_class_initialization
            (env, fieldref_info->field->class_info) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->pvalue = &(fieldref_info->field->data.class_field.value);

        /* execute bytecode */
        {
          jvalue *pvalue = &(fieldref_info->field->data.class_field.value);
          stack[stack_size++].jint = _svmf_get_SHORT_static (pvalue);
        }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_GETSTATIC_CHAR
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_GETSTATIC_CHAR:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_GETSTATIC_CHAR]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Fieldref_info *fieldref_info = (pc++)->fieldref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Fieldref
            (env, env->stack.current_frame->method->class_info,
             fieldref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        if (_svmf_class_initialization
            (env, fieldref_info->field->class_info) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->pvalue = &(fieldref_info->field->data.class_field.value);

        /* execute bytecode */
        {
          jvalue *pvalue = &(fieldref_info->field->data.class_field.value);
          stack[stack_size++].jint = _svmf_get_CHAR_static (pvalue);
        }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_GETSTATIC_INT
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_GETSTATIC_INT:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_GETSTATIC_INT]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Fieldref_info *fieldref_info = (pc++)->fieldref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Fieldref
            (env, env->stack.current_frame->method->class_info,
             fieldref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        if (_svmf_class_initialization
            (env, fieldref_info->field->class_info) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->pvalue = &(fieldref_info->field->data.class_field.value);

        /* execute bytecode */
        {
          jvalue *pvalue = &(fieldref_info->field->data.class_field.value);
          stack[stack_size++].jint = _svmf_get_INT_static (pvalue);
        }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_GETSTATIC_LONG
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_GETSTATIC_LONG:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_GETSTATIC_LONG]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Fieldref_info *fieldref_info = (pc++)->fieldref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Fieldref
            (env, env->stack.current_frame->method->class_info,
             fieldref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        if (_svmf_class_initialization
            (env, fieldref_info->field->class_info) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->pvalue = &(fieldref_info->field->data.class_field.value);

        /* execute bytecode */
        {
          jvalue *pvalue = &(fieldref_info->field->data.class_field.value);
          *((jlong *) (void *) &stack[stack_size]) =
            _svmf_get_LONG_static (pvalue);
          stack_size += 2;
        }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_GETSTATIC_FLOAT
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_GETSTATIC_FLOAT:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_GETSTATIC_FLOAT]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Fieldref_info *fieldref_info = (pc++)->fieldref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Fieldref
            (env, env->stack.current_frame->method->class_info,
             fieldref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        if (_svmf_class_initialization
            (env, fieldref_info->field->class_info) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->pvalue = &(fieldref_info->field->data.class_field.value);

        /* execute bytecode */
        {
          jvalue *pvalue = &(fieldref_info->field->data.class_field.value);
          stack[stack_size++].jfloat = _svmf_get_FLOAT_static (pvalue);
        }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_GETSTATIC_DOUBLE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_GETSTATIC_DOUBLE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_GETSTATIC_DOUBLE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Fieldref_info *fieldref_info = (pc++)->fieldref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Fieldref
            (env, env->stack.current_frame->method->class_info,
             fieldref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        if (_svmf_class_initialization
            (env, fieldref_info->field->class_info) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->pvalue = &(fieldref_info->field->data.class_field.value);

        /* execute bytecode */
        {
          jvalue *pvalue = &(fieldref_info->field->data.class_field.value);
          *((jdouble *) (void *) &stack[stack_size]) =
            _svmf_get_DOUBLE_static (pvalue);
          stack_size += 2;
        }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_GETSTATIC_REFERENCE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_GETSTATIC_REFERENCE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_GETSTATIC_REFERENCE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Fieldref_info *fieldref_info = (pc++)->fieldref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Fieldref
            (env, env->stack.current_frame->method->class_info,
             fieldref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        if (_svmf_class_initialization
            (env, fieldref_info->field->class_info) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->pvalue = &(fieldref_info->field->data.class_field.value);

        /* execute bytecode */
        {
          jvalue *pvalue = &(fieldref_info->field->data.class_field.value);
          stack[stack_size++].reference = _svmf_get_REFERENCE_static (pvalue);
        }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_PUTSTATIC_BOOLEAN
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_PUTSTATIC_BOOLEAN:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_PUTSTATIC_BOOLEAN]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Fieldref_info *fieldref_info = (pc++)->fieldref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Fieldref
            (env, env->stack.current_frame->method->class_info,
             fieldref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        if (_svmf_class_initialization
            (env, fieldref_info->field->class_info) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->pvalue = &(fieldref_info->field->data.class_field.value);

        /* execute bytecode */
        {
          jvalue *pvalue = &(fieldref_info->field->data.class_field.value);
          _svmf_put_BOOLEAN_static (pvalue, stack[--stack_size].jint);
/* Note: only _SABLEVM_GC_WRITE_BARRIER_REFERENCE is ever defined */
#if defined (_SABLEVM_GC_WRITE_BARRIER_BOOLEAN)
          _svmf_write_barrier (env, (_svmt_object_instance **) pvalue->l);
#endif /* _SABLEVM_GC_WRITE_BARRIER */
        }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_PUTSTATIC_BYTE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_PUTSTATIC_BYTE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_PUTSTATIC_BYTE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Fieldref_info *fieldref_info = (pc++)->fieldref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Fieldref
            (env, env->stack.current_frame->method->class_info,
             fieldref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        if (_svmf_class_initialization
            (env, fieldref_info->field->class_info) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->pvalue = &(fieldref_info->field->data.class_field.value);

        /* execute bytecode */
        {
          jvalue *pvalue = &(fieldref_info->field->data.class_field.value);
          _svmf_put_BYTE_static (pvalue, stack[--stack_size].jint);
/* Note: only _SABLEVM_GC_WRITE_BARRIER_REFERENCE is ever defined */
#if defined (_SABLEVM_GC_WRITE_BARRIER_BYTE)
          _svmf_write_barrier (env, (_svmt_object_instance **) pvalue->l);
#endif /* _SABLEVM_GC_WRITE_BARRIER */
        }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_PUTSTATIC_SHORT
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_PUTSTATIC_SHORT:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_PUTSTATIC_SHORT]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Fieldref_info *fieldref_info = (pc++)->fieldref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Fieldref
            (env, env->stack.current_frame->method->class_info,
             fieldref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        if (_svmf_class_initialization
            (env, fieldref_info->field->class_info) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->pvalue = &(fieldref_info->field->data.class_field.value);

        /* execute bytecode */
        {
          jvalue *pvalue = &(fieldref_info->field->data.class_field.value);
          _svmf_put_SHORT_static (pvalue, stack[--stack_size].jint);
/* Note: only _SABLEVM_GC_WRITE_BARRIER_REFERENCE is ever defined */
#if defined (_SABLEVM_GC_WRITE_BARRIER_SHORT)
          _svmf_write_barrier (env, (_svmt_object_instance **) pvalue->l);
#endif /* _SABLEVM_GC_WRITE_BARRIER */
        }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_PUTSTATIC_CHAR
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_PUTSTATIC_CHAR:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_PUTSTATIC_CHAR]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Fieldref_info *fieldref_info = (pc++)->fieldref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Fieldref
            (env, env->stack.current_frame->method->class_info,
             fieldref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        if (_svmf_class_initialization
            (env, fieldref_info->field->class_info) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->pvalue = &(fieldref_info->field->data.class_field.value);

        /* execute bytecode */
        {
          jvalue *pvalue = &(fieldref_info->field->data.class_field.value);
          _svmf_put_CHAR_static (pvalue, stack[--stack_size].jint);
/* Note: only _SABLEVM_GC_WRITE_BARRIER_REFERENCE is ever defined */
#if defined (_SABLEVM_GC_WRITE_BARRIER_CHAR)
          _svmf_write_barrier (env, (_svmt_object_instance **) pvalue->l);
#endif /* _SABLEVM_GC_WRITE_BARRIER */
        }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_PUTSTATIC_INT
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_PUTSTATIC_INT:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_PUTSTATIC_INT]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Fieldref_info *fieldref_info = (pc++)->fieldref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Fieldref
            (env, env->stack.current_frame->method->class_info,
             fieldref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        if (_svmf_class_initialization
            (env, fieldref_info->field->class_info) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->pvalue = &(fieldref_info->field->data.class_field.value);

        /* execute bytecode */
        {
          jvalue *pvalue = &(fieldref_info->field->data.class_field.value);
          _svmf_put_INT_static (pvalue, stack[--stack_size].jint);
/* Note: only _SABLEVM_GC_WRITE_BARRIER_REFERENCE is ever defined */
#if defined (_SABLEVM_GC_WRITE_BARRIER_INT)
          _svmf_write_barrier (env, (_svmt_object_instance **) pvalue->l);
#endif /* _SABLEVM_GC_WRITE_BARRIER */
        }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_PUTSTATIC_LONG
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_PUTSTATIC_LONG:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_PUTSTATIC_LONG]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Fieldref_info *fieldref_info = (pc++)->fieldref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Fieldref
            (env, env->stack.current_frame->method->class_info,
             fieldref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        if (_svmf_class_initialization
            (env, fieldref_info->field->class_info) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->pvalue = &(fieldref_info->field->data.class_field.value);

        /* execute bytecode */
        {
          jvalue *pvalue = &(fieldref_info->field->data.class_field.value);
          _svmf_put_LONG_static (pvalue,
                         *((jlong *) (void *)
                           &stack[(stack_size -= 2)]));
        }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_PUTSTATIC_FLOAT
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_PUTSTATIC_FLOAT:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_PUTSTATIC_FLOAT]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Fieldref_info *fieldref_info = (pc++)->fieldref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Fieldref
            (env, env->stack.current_frame->method->class_info,
             fieldref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        if (_svmf_class_initialization
            (env, fieldref_info->field->class_info) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->pvalue = &(fieldref_info->field->data.class_field.value);

        /* execute bytecode */
        {
          jvalue *pvalue = &(fieldref_info->field->data.class_field.value);
          _svmf_put_FLOAT_static (pvalue, stack[--stack_size].jfloat);
/* Note: only _SABLEVM_GC_WRITE_BARRIER_REFERENCE is ever defined */
#if defined (_SABLEVM_GC_WRITE_BARRIER_FLOAT)
          _svmf_write_barrier (env, (_svmt_object_instance **) pvalue->l);
#endif /* _SABLEVM_GC_WRITE_BARRIER */
        }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_PUTSTATIC_DOUBLE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_PUTSTATIC_DOUBLE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_PUTSTATIC_DOUBLE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Fieldref_info *fieldref_info = (pc++)->fieldref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Fieldref
            (env, env->stack.current_frame->method->class_info,
             fieldref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        if (_svmf_class_initialization
            (env, fieldref_info->field->class_info) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->pvalue = &(fieldref_info->field->data.class_field.value);

        /* execute bytecode */
        {
          jvalue *pvalue = &(fieldref_info->field->data.class_field.value);
          _svmf_put_DOUBLE_static (pvalue,
                         *((jdouble *) (void *)
                           &stack[(stack_size -= 2)]));
        }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_PUTSTATIC_REFERENCE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_PUTSTATIC_REFERENCE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_PUTSTATIC_REFERENCE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Fieldref_info *fieldref_info = (pc++)->fieldref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Fieldref
            (env, env->stack.current_frame->method->class_info,
             fieldref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        if (_svmf_class_initialization
            (env, fieldref_info->field->class_info) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->pvalue = &(fieldref_info->field->data.class_field.value);

        /* execute bytecode */
        {
          jvalue *pvalue = &(fieldref_info->field->data.class_field.value);
          _svmf_put_REFERENCE_static (pvalue, stack[--stack_size].reference);
/* Note: only _SABLEVM_GC_WRITE_BARRIER_REFERENCE is ever defined */
#if defined (_SABLEVM_GC_WRITE_BARRIER_REFERENCE)
          _svmf_write_barrier (env, (_svmt_object_instance **) pvalue->l);
#endif /* _SABLEVM_GC_WRITE_BARRIER */
        }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_CHECKCAST
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_CHECKCAST:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_CHECKCAST]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Class_info *classref_info = (pc++)->classref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Class
            (env, env->stack.current_frame->method->class_info,
             classref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        if (_svmf_link_type (env, classref_info->type) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->type_info = classref_info->type;

        /* execute bytecode */
        {
          _svmt_type_info *T = classref_info->type;
          _svmt_object_instance *instance = stack[stack_size - 1].reference;

          if (instance != NULL)
            {
            _svmt_type_info *S = instance->vtable->type;

            if (!_svmf_is_assignable_from (env, S, T))
              {
                goto classcastexception_handler;
              }
            }
        }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_INSTANCEOF
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_INSTANCEOF:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_INSTANCEOF]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Class_info *classref_info = (pc++)->classref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Class
            (env, env->stack.current_frame->method->class_info,
             classref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        if (_svmf_link_type (env, classref_info->type) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->type_info = classref_info->type;

        /* execute bytecode */
        {
          _svmt_type_info *T = classref_info->type;
          _svmt_object_instance *instance = stack[stack_size - 1].reference;

          if (instance != NULL)
            {
            _svmt_type_info *S = instance->vtable->type;

            if (_svmf_is_assignable_from (env, S, T))
              {
                stack[stack_size - 1].jint = 1;
              }
            else
              {
                stack[stack_size - 1].jint = 0;
              }
            }
          else
            {
            stack[stack_size - 1].jint = 0;
            }
        }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_NEW
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_NEW:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_NEW]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Class_info *classref_info = (pc++)->classref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Class
            (env, env->stack.current_frame->method->class_info,
             classref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        if (_svmf_link_type (env, classref_info->type) != JNI_OK)
          {
            goto exception_handler;
          }

        if (_svmf_class_initialization
            (env, _svmf_cast_class (classref_info->type)) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->class_info = _svmf_cast_class (classref_info->type);

        /* execute bytecode */
        {
          _svmt_class_info *class_info =
            _svmf_cast_class (classref_info->type);
          _svmt_object_instance *instance;

          if (_svmm_new_object_instance
            (env, class_info, instance) != JNI_OK)
            {
            goto exception_handler;
            }

          stack[stack_size++].reference = instance;
        }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_ANEWARRAY
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_ANEWARRAY:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_ANEWARRAY]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Class_info *classref_info = (pc++)->classref_info;
        _svmt_type_info *type;
        _svmt_array_info *array_type;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Class
            (env, env->stack.current_frame->method->class_info,
             classref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        if (_svmf_link_type (env, classref_info->type) != JNI_OK)
          {
            goto exception_handler;
          }

        type = classref_info->type;

        if (_svmm_create_array
            (env,
             type->class_loader_info, type->array_type_name,
             array_type) != JNI_OK)
          {
            goto exception_handler;
          }

        if (_svmf_link_array (env, array_type) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->array_info = array_type;

        /* execute bytecode */
        {
          _svmt_array_info *array_info = array_type;
          jint count = stack[--stack_size].jint;
          _svmt_array_instance *instance;

          if (count < 0)
            {
            _svmf_error_NegativeArraySizeException (env);
            goto exception_handler;
            }

          if (_svmm_new_array_instance
            (env, array_info, count, instance) != JNI_OK)
            {
            goto exception_handler;
            }

          stack[stack_size++].reference =
            _svmf_cast_object_instance (instance);
        }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_MULTIANEWARRAY
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_MULTIANEWARRAY:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_MULTIANEWARRAY]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Class_info *classref_info = (pc++)->classref_info;
        jint dimensions = (pc++)->jint;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Class
            (env, env->stack.current_frame->method->class_info,
             classref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        if (_svmf_link_type (env, classref_info->type) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr->array_info = _svmf_cast_array (classref_info->type);

        /* execute bytecode */
        {
          _svmt_array_info *array_info =
            _svmf_cast_array (classref_info->type);
          _svmt_array_instance *instance;

          stack_size -= dimensions;

          if (_svmm_multianewarray
            (env, array_info, dimensions, stack[stack_size],
             instance) != JNI_OK)
            {
            goto exception_handler;
            }

          stack[stack_size++].reference =
            _svmf_cast_object_instance (instance);
        }
      }

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_INVOKEVIRTUAL
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_INVOKEVIRTUAL:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_INVOKEVIRTUAL]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Methodref_info *methodref_info =
          (pc++)->methodref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Methodref
            (env, env->stack.current_frame->method->class_info,
             methodref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr[0].jint = methodref_info->method->java_args_count;

        /*
         * _svmf_resolve_CONSTANT_Methodref() may return an
         * interface method in certain situations (e.g., virtually
         * invoking a method on an abstract class, when this method
         * is inherited from an interface and not implemented in the
         * abstact class).
         */
        if (_svmf_is_set_flag
            (methodref_info->method->class_info->access_flags,
             SVM_ACC_INTERFACE))
          {
            addr[1].offset =
            -((1 + methodref_info->method->method_id) *
              sizeof (_svmt_method_info *));
          }
        else
          {
            addr[1].offset =
            sizeof (_svmt_vtable) +
            (methodref_info->method->method_id *
             sizeof (_svmt_method_info *));
          }

        /* execute bytecode */
        {
          jint args_count = addr[0].jint;
          size_t method_offset = addr[1].offset;
          _svmt_object_instance *instance =
            stack[(stack_size -= args_count)].reference;
          _svmt_method_info *method;
          _svmt_method_frame_info *frame_info;
          _svmt_stack_frame *frame;

#ifdef _SABLEVM_SIGNALS_FOR_EXCEPTIONS

#ifndef NDEBUG

          if (instance == NULL)
            {
            env->sigsegv_expected = JNI_TRUE;
            }

#endif /* NOT NDEBUG */

          /* save pc in case exception is raised */
          env->stack.current_frame->pc = pc;

#else

          if (instance == NULL)
            {
            goto nullpointerexception_handler;
            }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

          /* the following can cause a segfault */
          method =
            *((_svmt_method_info **) (void *)
            (((char *) instance->vtable) + method_offset));

          assert (_svmf_is_assignable_from
                (env, instance->vtable->type,
                 _svmf_cast_type_class (method->class_info)));

          assert (strcmp
                (DREF (method->name, value),
                 DREF (DREF (methodref_info->name_and_type, name),
                     value)) == 0
                && strcmp (DREF (method->descriptor, value),
                         DREF (DREF
                             (methodref_info->name_and_type,
                              descriptor), value)) == 0);

          frame_info = method->frame_info;

          /* store return pc & stack size */
          frame = env->stack.current_frame;
          frame->pc = pc;
          frame->stack_size = stack_size;

          /* syncronized? */
          if (method->synchronized)
            {
            /* preserve references on the stack across GC */
            frame->stack_size = stack_size + args_count;

            if (_svmf_enter_object_monitor (env, instance) != JNI_OK)
              {
                goto exception_handler;
              }

            frame->stack_size = stack_size;
            instance = stack[stack_size].reference;
            }

          if (_svmf_ensure_stack_capacity
            (env, frame_info->java_invoke_frame_size) != JNI_OK)
            {
            goto exception_handler;
            }

          frame = env->stack.current_frame;
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
          locals = &stack[stack_size];

          /* initialize reference locals to null */
          {
            jint max = frame_info->non_parameter_ref_locals_count;
            jint java_args_count = method->java_args_count;
            jint i;

            for (i = 0; i < max; i++)
            {
              locals[java_args_count + i].reference = NULL;
            }
          }

          /* setup callee frame */
          frame =
            (_svmt_stack_frame *) (void *)
            (((char *) locals) + frame_info->start_offset);
          stack =
            (_svmt_stack_value *) (void *) (((char *) frame) +
                                    _svmv_stack_offset);
          pc = frame_info->code;
          stack_size = 0;

          frame->previous_offset =
            ((char *) frame) - ((char *) env->stack.current_frame);
          frame->end_offset = frame_info->end_offset;
          frame->method = method;
          frame->stack_trace_element = NULL;
          frame->lock_count = 0;
          frame->this = instance;
          frame->pc = pc;
          frame->stack_size = stack_size;

          env->stack.current_frame = frame;

          /* check */
          _svmf_periodic_check (env);
        }
      }

#if !defined(NDEBUG)

      _svmf_verbose_methods_enter (env);

#endif

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_INVOKESPECIAL
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_INVOKESPECIAL:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_INVOKESPECIAL]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Methodref_info *methodref_info =
          (pc++)->methodref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Methodref
            (env, env->stack.current_frame->method->class_info,
             methodref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        /* select the appropriate method */
        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          if (_svmf_is_set_flag
            (method->class_info->access_flags, SVM_ACC_SUPER)
            && _svmf_is_super_class (methodref_info->method->class_info,
                               method->class_info)
            && DREF (methodref_info->method->name, value)[0] != '<')
            {
            _svmt_method_info *selected_method =
              _svmf_resolve_special_method
              (_svmf_cast_class
               (DREF (method->class_info->super_class, type)),
               DREF (methodref_info->method->name, value),
               DREF (methodref_info->method->descriptor, value));

            addr[0].jint = selected_method->java_args_count;
            addr[1].method_info = selected_method;
            }
          else
            {
            addr[0].jint = methodref_info->method->java_args_count;
            addr[1].method_info = methodref_info->method;
            }
        }

        /* execute bytecode */
        {
          jint args_count = addr[0].jint;
          _svmt_method_info *method = addr[1].method_info;
          _svmt_object_instance *instance =
            stack[(stack_size -= args_count)].reference;
          _svmt_method_frame_info *frame_info;
          _svmt_stack_frame *frame;

          if (instance == NULL)
            {
            goto nullpointerexception_handler;
            }

          assert (_svmf_is_assignable_from
                (env, instance->vtable->type,
                 _svmf_cast_type_class (method->class_info)));

          assert (strcmp
                (DREF (method->name, value),
                 DREF (DREF (methodref_info->name_and_type, name),
                     value)) == 0
                && strcmp (DREF (method->descriptor, value),
                         DREF (DREF
                             (methodref_info->name_and_type,
                              descriptor), value)) == 0);

          frame_info = method->frame_info;

          /* store return pc & stack size */
          frame = env->stack.current_frame;
          frame->pc = pc;
          frame->stack_size = stack_size;

          /* syncronized? */
          if (method->synchronized)
            {
            /* preserve references on the stack across GC */
            frame->stack_size = stack_size + args_count;

            if (_svmf_enter_object_monitor (env, instance) != JNI_OK)
              {
                goto exception_handler;
              }

            frame->stack_size = stack_size;
            instance = stack[stack_size].reference;
            }

          if (_svmf_ensure_stack_capacity
            (env, frame_info->java_invoke_frame_size) != JNI_OK)
            {
            goto exception_handler;
            }

          frame = env->stack.current_frame;
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
          locals = &stack[stack_size];

          /* initialize reference locals to null */
          {
            jint max = frame_info->non_parameter_ref_locals_count;
            jint java_args_count = method->java_args_count;
            jint i;

            for (i = 0; i < max; i++)
            {
              locals[java_args_count + i].reference = NULL;
            }
          }

          /* setup callee frame */
          frame =
            (_svmt_stack_frame *) (void *)
            (((char *) locals) + frame_info->start_offset);
          stack =
            (_svmt_stack_value *) (void *) (((char *) frame) +
                                    _svmv_stack_offset);
          pc = frame_info->code;
          stack_size = 0;

          frame->previous_offset =
            ((char *) frame) - ((char *) env->stack.current_frame);
          frame->end_offset = frame_info->end_offset;
          frame->method = method;
          frame->stack_trace_element = NULL;
          frame->lock_count = 0;
          frame->this = instance;
          frame->pc = pc;
          frame->stack_size = stack_size;

          env->stack.current_frame = frame;

          /* check */
          _svmf_periodic_check (env);
        }
      }

#if !defined(NDEBUG)

      _svmf_verbose_methods_enter (env);

#endif

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_INVOKESTATIC
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_INVOKESTATIC:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_INVOKESTATIC]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_Methodref_info *methodref_info =
          (pc++)->methodref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_Methodref
            (env, env->stack.current_frame->method->class_info,
             methodref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        if (_svmf_class_initialization
            (env, methodref_info->method->class_info) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr[0].jint = methodref_info->method->java_args_count;
        addr[1].method_info = methodref_info->method;

        /* execute bytecode */
        {
          jint args_count = addr[0].jint;
          _svmt_method_info *method = addr[1].method_info;
          _svmt_method_frame_info *frame_info;
          _svmt_stack_frame *frame;

          assert (strcmp
                (DREF (method->name, value),
                 DREF (DREF (methodref_info->name_and_type, name),
                     value)) == 0
                && strcmp (DREF (method->descriptor, value),
                         DREF (DREF
                             (methodref_info->name_and_type,
                              descriptor), value)) == 0);

          frame_info = method->frame_info;
          stack_size -= args_count;

          /* store return pc & stack size */
          frame = env->stack.current_frame;
          frame->pc = pc;
          frame->stack_size = stack_size;

          /* syncronized? */
          if (method->synchronized)
            {
            /* preserve references on the stack across GC */
            frame->stack_size = stack_size + args_count;

            if (_svmf_enter_object_monitor
                (env, *(method->class_info->class_instance)) != JNI_OK)
              {
                goto exception_handler;
              }

            frame->stack_size = stack_size;
            }

          if (_svmf_ensure_stack_capacity
            (env, frame_info->java_invoke_frame_size) != JNI_OK)
            {
            goto exception_handler;
            }

          frame = env->stack.current_frame;
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
          locals = &stack[stack_size];

          /* initialize reference locals to null */
          {
            jint max = frame_info->non_parameter_ref_locals_count;
            jint java_args_count = method->java_args_count;
            jint i;

            for (i = 0; i < max; i++)
            {
              locals[java_args_count + i].reference = NULL;
            }
          }

          /* setup callee frame */
          frame =
            (_svmt_stack_frame *) (void *)
            (((char *) locals) + frame_info->start_offset);
          stack =
            (_svmt_stack_value *) (void *) (((char *) frame) +
                                    _svmv_stack_offset);
          pc = frame_info->code;
          stack_size = 0;

          frame->previous_offset =
            ((char *) frame) - ((char *) env->stack.current_frame);
          frame->end_offset = frame_info->end_offset;
          frame->method = method;
          frame->stack_trace_element = NULL;
          frame->lock_count = 0;
          frame->this = *(method->class_info->class_instance);
          frame->pc = pc;
          frame->stack_size = stack_size;

          env->stack.current_frame = frame;

          /* check */
          _svmf_periodic_check (env);
        }
      }

#if !defined(NDEBUG)

      _svmf_verbose_methods_enter (env);

#endif

       
      /* dispatch */
      goto dispatch;
      }


/*
----------------------------------------------------------------------
PREPARE_INVOKEINTERFACE
----------------------------------------------------------------------
*/

    case SVM_INSTRUCTION_PREPARE_INVOKEINTERFACE:
      {
#ifndef     NDEBUG

      if (env->vm->verbose_instructions == JNI_TRUE)
        {
          _svmf_printf (env, stderr,
                    "T%d: [verbose instructions: executing @%p PREPARE_INVOKEINTERFACE]\n",
                    env->thread.id, (void *) (pc - 1));
        }

#endif

      /* instruction body */
             
      
      {
        _svmt_code *addr = (pc++)->addr;
        _svmt_CONSTANT_InterfaceMethodref_info *imethodref_info =
          (pc++)->imethodref_info;

        /* skip stack map */
        assert (stack_size >= pc->stack_gc_map->size);
        pc++;

        /* save state */
        env->stack.current_frame->pc = pc;
        env->stack.current_frame->stack_size = stack_size;

        if (_svmf_resolve_CONSTANT_InterfaceMethodref
            (env, env->stack.current_frame->method->class_info,
             imethodref_info) != JNI_OK)
          {
            goto exception_handler;
          }

        {
          _svmt_stack_frame *frame = env->stack.current_frame;
          _svmt_method_info *method = frame->method;

          /* in case stack was moved around  */
          locals = (_svmt_stack_value *) (void *)
            (((char *) frame) - method->frame_info->start_offset);
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
        }

        addr[0].jint = imethodref_info->method->java_args_count;
        addr[1].offset =
          -((1 + imethodref_info->method->method_id) *
            sizeof (_svmt_method_info *));

        /* execute bytecode */
        {
          jint args_count = addr[0].jint;
          size_t method_offset = addr[1].offset;
          _svmt_object_instance *instance =
            stack[(stack_size -= args_count)].reference;
          _svmt_method_info *method;
          _svmt_method_frame_info *frame_info;
          _svmt_stack_frame *frame;

#ifdef _SABLEVM_SIGNALS_FOR_EXCEPTIONS

#ifndef NDEBUG

          if (instance == NULL)
            {
            env->sigsegv_expected = JNI_TRUE;
            }

#endif /* NOT NDEBUG */

          /* save pc in case exception is raised */
          env->stack.current_frame->pc = pc;

#else

          if (instance == NULL)
            {
            goto nullpointerexception_handler;
            }

#endif /* _SABLEVM_SIGNALS_FOR_EXCEPTIONS */

          /* the following can cause a segfault */
          method =
            *((_svmt_method_info **) (void *)
            (((char *) instance->vtable) + method_offset));

          assert (_svmf_is_assignable_from
                (env, instance->vtable->type,
                 _svmf_cast_type_class (method->class_info)));

          assert (strcmp
                (DREF (method->name, value),
                 DREF (DREF (imethodref_info->name_and_type, name),
                     value)) == 0
                && strcmp (DREF (method->descriptor, value),
                         DREF (DREF
                             (imethodref_info->name_and_type,
                              descriptor), value)) == 0);

          frame_info = method->frame_info;

          /* store return pc & stack size */
          frame = env->stack.current_frame;
          frame->pc = pc;
          frame->stack_size = stack_size;

          /* syncronized? */
          if (method->synchronized)
            {
            /* preserve references on the stack across GC */
            frame->stack_size = stack_size + args_count;

            if (_svmf_enter_object_monitor (env, instance) != JNI_OK)
              {
                goto exception_handler;
              }

            frame->stack_size = stack_size;
            instance = stack[stack_size].reference;
            }

          if (_svmf_ensure_stack_capacity
            (env, frame_info->java_invoke_frame_size) != JNI_OK)
            {
            goto exception_handler;
            }

          frame = env->stack.current_frame;
          stack = (_svmt_stack_value *) (void *)
            (((char *) frame) + _svmv_stack_offset);
          locals = &stack[stack_size];

          /* initialize reference locals to null */
          {
            jint max = frame_info->non_parameter_ref_locals_count;
            jint java_args_count = method->java_args_count;
            jint i;

            for (i = 0; i < max; i++)
            {
              locals[java_args_count + i].reference = NULL;
            }
          }

          /* setup callee frame */
          frame =
            (_svmt_stack_frame *) (void *)
            (((char *) locals) + frame_info->start_offset);
          stack =
            (_svmt_stack_value *) (void *) (((char *) frame) +
                                    _svmv_stack_offset);
          pc = frame_info->code;
          stack_size = 0;

          frame->previous_offset =
            ((char *) frame) - ((char *) env->stack.current_frame);
          frame->end_offset = frame_info->end_offset;
          frame->method = method;
          frame->stack_trace_element = NULL;
          frame->lock_count = 0;
          frame->this = instance;
          frame->pc = pc;
          frame->stack_size = stack_size;

          env->stack.current_frame = frame;

          /* check */
          _svmf_periodic_check (env);
        }
      }

#if !defined(NDEBUG)

      _svmf_verbose_methods_enter (env);

#endif

       
      /* dispatch */
      goto dispatch;
      }


Generated by  Doxygen 1.6.0   Back to index