hotspot/src/share/vm/interpreter/bytecodeInterpreter.cpp
author duke
Sat, 01 Dec 2007 00:00:00 +0000
changeset 1 489c9b5090e2
child 370 33ba64c16c1f
permissions -rw-r--r--
Initial load
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
     2
 * Copyright 2002-2007 Sun Microsystems, Inc.  All Rights Reserved.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    19
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    20
 * CA 95054 USA or visit www.sun.com if you need additional information or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    21
 * have any questions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
489c9b5090e2 Initial load
duke
parents:
diff changeset
    25
489c9b5090e2 Initial load
duke
parents:
diff changeset
    26
// no precompiled headers
489c9b5090e2 Initial load
duke
parents:
diff changeset
    27
#include "incls/_bytecodeInterpreter.cpp.incl"
489c9b5090e2 Initial load
duke
parents:
diff changeset
    28
489c9b5090e2 Initial load
duke
parents:
diff changeset
    29
#ifdef CC_INTERP
489c9b5090e2 Initial load
duke
parents:
diff changeset
    30
489c9b5090e2 Initial load
duke
parents:
diff changeset
    31
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
    32
 * USELABELS - If using GCC, then use labels for the opcode dispatching
489c9b5090e2 Initial load
duke
parents:
diff changeset
    33
 * rather -then a switch statement. This improves performance because it
489c9b5090e2 Initial load
duke
parents:
diff changeset
    34
 * gives us the oportunity to have the instructions that calculate the
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
 * next opcode to jump to be intermixed with the rest of the instructions
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
 * that implement the opcode (see UPDATE_PC_AND_TOS_AND_CONTINUE macro).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
#undef USELABELS
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
#ifdef __GNUC__
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
   ASSERT signifies debugging. It is much easier to step thru bytecodes if we
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
   don't use the computed goto approach.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
*/
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
#ifndef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
#define USELABELS
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
#undef CASE
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
#ifdef USELABELS
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
#define CASE(opcode) opc ## opcode
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
#define DEFAULT opc_default
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
#define CASE(opcode) case Bytecodes:: opcode
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
#define DEFAULT default
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
 * PREFETCH_OPCCODE - Some compilers do better if you prefetch the next
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
 * opcode before going back to the top of the while loop, rather then having
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
 * the top of the while loop handle it. This provides a better opportunity
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
 * for instruction scheduling. Some compilers just do this prefetch
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
 * automatically. Some actually end up with worse performance if you
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
 * force the prefetch. Solaris gcc seems to do better, but cc does worse.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
#undef PREFETCH_OPCCODE
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
#define PREFETCH_OPCCODE
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
  Interpreter safepoint: it is expected that the interpreter will have no live
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
  handles of its own creation live at an interpreter safepoint. Therefore we
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
  run a HandleMarkCleaner and trash all handles allocated in the call chain
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
  since the JavaCalls::call_helper invocation that initiated the chain.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
  There really shouldn't be any handles remaining to trash but this is cheap
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
  in relation to a safepoint.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
*/
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
#define SAFEPOINT                                                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
    if ( SafepointSynchronize::is_synchronizing()) {                              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
        {                                                                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
          /* zap freed handles rather than GC'ing them */                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
          HandleMarkCleaner __hmc(THREAD);                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
        }                                                                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
        CALL_VM(SafepointSynchronize::block(THREAD), handle_exception);           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
 * VM_JAVA_ERROR - Macro for throwing a java exception from
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
 * the interpreter loop. Should really be a CALL_VM but there
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
 * is no entry point to do the transition to vm so we just
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
 * do it by hand here.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
#define VM_JAVA_ERROR_NO_JUMP(name, msg)                                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
    DECACHE_STATE();                                                              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
    SET_LAST_JAVA_FRAME();                                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
    {                                                                             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
       ThreadInVMfromJava trans(THREAD);                                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
       Exceptions::_throw_msg(THREAD, __FILE__, __LINE__, name, msg);             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
    }                                                                             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
    RESET_LAST_JAVA_FRAME();                                                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
    CACHE_STATE();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
// Normal throw of a java error
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
#define VM_JAVA_ERROR(name, msg)                                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
    VM_JAVA_ERROR_NO_JUMP(name, msg)                                              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
    goto handle_exception;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
#ifdef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
#define DO_UPDATE_INSTRUCTION_COUNT(opcode)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
#define DO_UPDATE_INSTRUCTION_COUNT(opcode)                                                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
{                                                                                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
    BytecodeCounter::_counter_value++;                                                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
    BytecodeHistogram::_counters[(Bytecodes::Code)opcode]++;                                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
    if (StopInterpreterAt && StopInterpreterAt == BytecodeCounter::_counter_value) os::breakpoint(); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
    if (TraceBytecodes) {                                                                            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
      CALL_VM((void)SharedRuntime::trace_bytecode(THREAD, 0,               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
                                   topOfStack[Interpreter::expr_index_at(1)],   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
                                   topOfStack[Interpreter::expr_index_at(2)]),  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
                                   handle_exception);                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
    }                                                                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
#undef DEBUGGER_SINGLE_STEP_NOTIFY
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
#ifdef VM_JVMTI
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
/* NOTE: (kbr) This macro must be called AFTER the PC has been
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
   incremented. JvmtiExport::at_single_stepping_point() may cause a
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
   breakpoint opcode to get inserted at the current PC to allow the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
   debugger to coalesce single-step events.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
   As a result if we call at_single_stepping_point() we refetch opcode
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
   to get the current opcode. This will override any other prefetching
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
   that might have occurred.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
*/
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
#define DEBUGGER_SINGLE_STEP_NOTIFY()                                            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
{                                                                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
      if (_jvmti_interp_events) {                                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
        if (JvmtiExport::should_post_single_step()) {                            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
          DECACHE_STATE();                                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
          SET_LAST_JAVA_FRAME();                                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
          ThreadInVMfromJava trans(THREAD);                                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
          JvmtiExport::at_single_stepping_point(THREAD,                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
                                          istate->method(),                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
                                          pc);                                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
          RESET_LAST_JAVA_FRAME();                                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
          CACHE_STATE();                                                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
          if (THREAD->pop_frame_pending() &&                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
              !THREAD->pop_frame_in_process()) {                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
            goto handle_Pop_Frame;                                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
          }                                                                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
          opcode = *pc;                                                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
        }                                                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
      }                                                                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
#define DEBUGGER_SINGLE_STEP_NOTIFY()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
 * CONTINUE - Macro for executing the next opcode.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
#undef CONTINUE
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
#ifdef USELABELS
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
// Have to do this dispatch this way in C++ because otherwise gcc complains about crossing an
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
// initialization (which is is the initialization of the table pointer...)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
#define DISPATCH(opcode) goto *dispatch_table[opcode]
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
#define CONTINUE {                              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
        opcode = *pc;                           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
        DO_UPDATE_INSTRUCTION_COUNT(opcode);    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
        DEBUGGER_SINGLE_STEP_NOTIFY();          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
        DISPATCH(opcode);                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
#ifdef PREFETCH_OPCCODE
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
#define CONTINUE {                              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
        opcode = *pc;                           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
        DO_UPDATE_INSTRUCTION_COUNT(opcode);    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
        DEBUGGER_SINGLE_STEP_NOTIFY();          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
        continue;                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
#define CONTINUE {                              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
        DO_UPDATE_INSTRUCTION_COUNT(opcode);    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
        DEBUGGER_SINGLE_STEP_NOTIFY();          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
        continue;                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
// JavaStack Implementation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
#define MORE_STACK(count)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
    (topOfStack -= ((count) * Interpreter::stackElementWords()))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
#define UPDATE_PC(opsize) {pc += opsize; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
 * UPDATE_PC_AND_TOS - Macro for updating the pc and topOfStack.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
#undef UPDATE_PC_AND_TOS
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
#define UPDATE_PC_AND_TOS(opsize, stack) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
    {pc += opsize; MORE_STACK(stack); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
 * UPDATE_PC_AND_TOS_AND_CONTINUE - Macro for updating the pc and topOfStack,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
 * and executing the next opcode. It's somewhat similar to the combination
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
 * of UPDATE_PC_AND_TOS and CONTINUE, but with some minor optimizations.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
#undef UPDATE_PC_AND_TOS_AND_CONTINUE
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
#ifdef USELABELS
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
#define UPDATE_PC_AND_TOS_AND_CONTINUE(opsize, stack) {         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
        pc += opsize; opcode = *pc; MORE_STACK(stack);          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
        DO_UPDATE_INSTRUCTION_COUNT(opcode);                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
        DEBUGGER_SINGLE_STEP_NOTIFY();                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
        DISPATCH(opcode);                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
#define UPDATE_PC_AND_CONTINUE(opsize) {                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
        pc += opsize; opcode = *pc;                             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
        DO_UPDATE_INSTRUCTION_COUNT(opcode);                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
        DEBUGGER_SINGLE_STEP_NOTIFY();                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
        DISPATCH(opcode);                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
#ifdef PREFETCH_OPCCODE
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
#define UPDATE_PC_AND_TOS_AND_CONTINUE(opsize, stack) {         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
        pc += opsize; opcode = *pc; MORE_STACK(stack);          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
        DO_UPDATE_INSTRUCTION_COUNT(opcode);                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
        DEBUGGER_SINGLE_STEP_NOTIFY();                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
        goto do_continue;                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
#define UPDATE_PC_AND_CONTINUE(opsize) {                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
        pc += opsize; opcode = *pc;                             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
        DO_UPDATE_INSTRUCTION_COUNT(opcode);                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
        DEBUGGER_SINGLE_STEP_NOTIFY();                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
        goto do_continue;                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
#define UPDATE_PC_AND_TOS_AND_CONTINUE(opsize, stack) { \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
        pc += opsize; MORE_STACK(stack);                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
        DO_UPDATE_INSTRUCTION_COUNT(opcode);            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
        DEBUGGER_SINGLE_STEP_NOTIFY();                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
        goto do_continue;                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
#define UPDATE_PC_AND_CONTINUE(opsize) {                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
        pc += opsize;                                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
        DO_UPDATE_INSTRUCTION_COUNT(opcode);            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
        DEBUGGER_SINGLE_STEP_NOTIFY();                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
        goto do_continue;                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
#endif /* PREFETCH_OPCCODE */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
#endif /* USELABELS */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
// About to call a new method, update the save the adjusted pc and return to frame manager
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
#define UPDATE_PC_AND_RETURN(opsize)  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
   DECACHE_TOS();                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
   istate->set_bcp(pc+opsize);        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
   return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
#define METHOD istate->method()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
#define INVOCATION_COUNT METHOD->invocation_counter()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
#define BACKEDGE_COUNT METHOD->backedge_counter()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
#define INCR_INVOCATION_COUNT INVOCATION_COUNT->increment()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
#define OSR_REQUEST(res, branch_pc) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
            CALL_VM(res=InterpreterRuntime::frequency_counter_overflow(THREAD, branch_pc), handle_exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
 * For those opcodes that need to have a GC point on a backwards branch
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
// Backedge counting is kind of strange. The asm interpreter will increment
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
// the backedge counter as a separate counter but it does it's comparisons
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
// to the sum (scaled) of invocation counter and backedge count to make
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
// a decision. Seems kind of odd to sum them together like that
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
// skip is delta from current bcp/bci for target, branch_pc is pre-branch bcp
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
#define DO_BACKEDGE_CHECKS(skip, branch_pc)                                                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
    if ((skip) <= 0) {                                                                              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
      if (UseCompiler && UseLoopCounter) {                                                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
        bool do_OSR = UseOnStackReplacement;                                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
        BACKEDGE_COUNT->increment();                                                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
        if (do_OSR) do_OSR = BACKEDGE_COUNT->reached_InvocationLimit();                             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
        if (do_OSR) {                                                                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
          nmethod*  osr_nmethod;                                                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
          OSR_REQUEST(osr_nmethod, branch_pc);                                                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
          if (osr_nmethod != NULL && osr_nmethod->osr_entry_bci() != InvalidOSREntryBci) {          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
            intptr_t* buf;                                                                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
            CALL_VM(buf=SharedRuntime::OSR_migration_begin(THREAD), handle_exception);              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
            istate->set_msg(do_osr);                                                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
            istate->set_osr_buf((address)buf);                                                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
            istate->set_osr_entry(osr_nmethod->osr_entry());                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
            return;                                                                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
          }                                                                                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
        } else {                                                                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
          INCR_INVOCATION_COUNT;                                                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
          SAFEPOINT;                                                                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
        }                                                                                           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
      }  /* UseCompiler ... */                                                                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
      INCR_INVOCATION_COUNT;                                                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
      SAFEPOINT;                                                                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
 * For those opcodes that need to have a GC point on a backwards branch
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
 * Macros for caching and flushing the interpreter state. Some local
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
 * variables need to be flushed out to the frame before we do certain
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
 * things (like pushing frames or becomming gc safe) and some need to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
 * be recached later (like after popping a frame). We could use one
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
 * macro to cache or decache everything, but this would be less then
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
 * optimal because we don't always need to cache or decache everything
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
 * because some things we know are already cached or decached.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
#undef DECACHE_TOS
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
#undef CACHE_TOS
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
#undef CACHE_PREV_TOS
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
#define DECACHE_TOS()    istate->set_stack(topOfStack);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
#define CACHE_TOS()      topOfStack = (intptr_t *)istate->stack();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
#undef DECACHE_PC
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
#undef CACHE_PC
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
#define DECACHE_PC()    istate->set_bcp(pc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
#define CACHE_PC()      pc = istate->bcp();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
#define CACHE_CP()      cp = istate->constants();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
#define CACHE_LOCALS()  locals = istate->locals();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
#undef CACHE_FRAME
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
#define CACHE_FRAME()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
 * CHECK_NULL - Macro for throwing a NullPointerException if the object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
 * passed is a null ref.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
 * On some architectures/platforms it should be possible to do this implicitly
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
#undef CHECK_NULL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
#define CHECK_NULL(obj_)                                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
    if ((obj_) == 0) {                                                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
        VM_JAVA_ERROR(vmSymbols::java_lang_NullPointerException(), "");  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
#define VMdoubleConstZero() 0.0
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
#define VMdoubleConstOne() 1.0
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
#define VMlongConstZero() (max_jlong-max_jlong)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
#define VMlongConstOne() ((max_jlong-max_jlong)+1)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
 * Alignment
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
#define VMalignWordUp(val)          (((uintptr_t)(val) + 3) & ~3)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
// Decache the interpreter state that interpreter modifies directly (i.e. GC is indirect mod)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
#define DECACHE_STATE() DECACHE_PC(); DECACHE_TOS();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
// Reload interpreter state after calling the VM or a possible GC
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
#define CACHE_STATE()   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
        CACHE_TOS();    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
        CACHE_PC();     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
        CACHE_CP();     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
        CACHE_LOCALS();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
// Call the VM don't check for pending exceptions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
#define CALL_VM_NOCHECK(func)                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
          DECACHE_STATE();                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
          SET_LAST_JAVA_FRAME();                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
          func;                                                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
          RESET_LAST_JAVA_FRAME();                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
          CACHE_STATE();                                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
          if (THREAD->pop_frame_pending() &&                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
              !THREAD->pop_frame_in_process()) {                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
            goto handle_Pop_Frame;                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
// Call the VM and check for pending exceptions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
#define CALL_VM(func, label) {                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
          CALL_VM_NOCHECK(func);                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
          if (THREAD->has_pending_exception()) goto label;        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
 * BytecodeInterpreter::run(interpreterState istate)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
 * BytecodeInterpreter::runWithChecks(interpreterState istate)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
 * The real deal. This is where byte codes actually get interpreted.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
 * Basically it's a big while loop that iterates until we return from
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
 * the method passed in.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
 * The runWithChecks is used if JVMTI is enabled.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
#if defined(VM_JVMTI)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
void
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
BytecodeInterpreter::runWithChecks(interpreterState istate) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
void
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
BytecodeInterpreter::run(interpreterState istate) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
  // In order to simplify some tests based on switches set at runtime
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
  // we invoke the interpreter a single time after switches are enabled
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
  // and set simpler to to test variables rather than method calls or complex
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
  // boolean expressions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
  static int initialized = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
  static int checkit = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
  static intptr_t* c_addr = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
  static intptr_t  c_value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
  if (checkit && *c_addr != c_value) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
    os::breakpoint();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
#ifdef VM_JVMTI
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
  static bool _jvmti_interp_events = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
  static int _compiling;  // (UseCompiler || CountCompiledCalls)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
  if (istate->_msg != initialize) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
    assert(abs(istate->_stack_base - istate->_stack_limit) == (istate->_method->max_stack() + 1), "bad stack limit");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
  IA32_ONLY(assert(istate->_stack_limit == istate->_thread->last_Java_sp() + 1, "wrong"));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
  // Verify linkages.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
  interpreterState l = istate;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
  do {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
    assert(l == l->_self_link, "bad link");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
    l = l->_prev_link;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
  } while (l != NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
  // Screwups with stack management usually cause us to overwrite istate
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
  // save a copy so we can verify it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
  interpreterState orig = istate;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
  static volatile jbyte* _byte_map_base; // adjusted card table base for oop store barrier
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
  register intptr_t*        topOfStack = (intptr_t *)istate->stack(); /* access with STACK macros */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
  register address          pc = istate->bcp();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
  register jubyte opcode;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
  register intptr_t*        locals = istate->locals();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
  register constantPoolCacheOop  cp = istate->constants(); // method()->constants()->cache()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
#ifdef LOTS_OF_REGS
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
  register JavaThread*      THREAD = istate->thread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
  register volatile jbyte*  BYTE_MAP_BASE = _byte_map_base;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
#undef THREAD
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
#define THREAD istate->thread()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
#undef BYTE_MAP_BASE
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
#define BYTE_MAP_BASE _byte_map_base
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
#ifdef USELABELS
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
  const static void* const opclabels_data[256] = {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
/* 0x00 */ &&opc_nop,     &&opc_aconst_null,&&opc_iconst_m1,&&opc_iconst_0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
/* 0x04 */ &&opc_iconst_1,&&opc_iconst_2,   &&opc_iconst_3, &&opc_iconst_4,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
/* 0x08 */ &&opc_iconst_5,&&opc_lconst_0,   &&opc_lconst_1, &&opc_fconst_0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
/* 0x0C */ &&opc_fconst_1,&&opc_fconst_2,   &&opc_dconst_0, &&opc_dconst_1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
/* 0x10 */ &&opc_bipush, &&opc_sipush, &&opc_ldc,    &&opc_ldc_w,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
/* 0x14 */ &&opc_ldc2_w, &&opc_iload,  &&opc_lload,  &&opc_fload,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
/* 0x18 */ &&opc_dload,  &&opc_aload,  &&opc_iload_0,&&opc_iload_1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
/* 0x1C */ &&opc_iload_2,&&opc_iload_3,&&opc_lload_0,&&opc_lload_1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
/* 0x20 */ &&opc_lload_2,&&opc_lload_3,&&opc_fload_0,&&opc_fload_1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
/* 0x24 */ &&opc_fload_2,&&opc_fload_3,&&opc_dload_0,&&opc_dload_1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
/* 0x28 */ &&opc_dload_2,&&opc_dload_3,&&opc_aload_0,&&opc_aload_1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
/* 0x2C */ &&opc_aload_2,&&opc_aload_3,&&opc_iaload, &&opc_laload,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
/* 0x30 */ &&opc_faload,  &&opc_daload,  &&opc_aaload,  &&opc_baload,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
/* 0x34 */ &&opc_caload,  &&opc_saload,  &&opc_istore,  &&opc_lstore,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
/* 0x38 */ &&opc_fstore,  &&opc_dstore,  &&opc_astore,  &&opc_istore_0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
/* 0x3C */ &&opc_istore_1,&&opc_istore_2,&&opc_istore_3,&&opc_lstore_0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
/* 0x40 */ &&opc_lstore_1,&&opc_lstore_2,&&opc_lstore_3,&&opc_fstore_0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
/* 0x44 */ &&opc_fstore_1,&&opc_fstore_2,&&opc_fstore_3,&&opc_dstore_0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
/* 0x48 */ &&opc_dstore_1,&&opc_dstore_2,&&opc_dstore_3,&&opc_astore_0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
/* 0x4C */ &&opc_astore_1,&&opc_astore_2,&&opc_astore_3,&&opc_iastore,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
/* 0x50 */ &&opc_lastore,&&opc_fastore,&&opc_dastore,&&opc_aastore,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
/* 0x54 */ &&opc_bastore,&&opc_castore,&&opc_sastore,&&opc_pop,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
/* 0x58 */ &&opc_pop2,   &&opc_dup,    &&opc_dup_x1, &&opc_dup_x2,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
/* 0x5C */ &&opc_dup2,   &&opc_dup2_x1,&&opc_dup2_x2,&&opc_swap,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
/* 0x60 */ &&opc_iadd,&&opc_ladd,&&opc_fadd,&&opc_dadd,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
/* 0x64 */ &&opc_isub,&&opc_lsub,&&opc_fsub,&&opc_dsub,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
/* 0x68 */ &&opc_imul,&&opc_lmul,&&opc_fmul,&&opc_dmul,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
/* 0x6C */ &&opc_idiv,&&opc_ldiv,&&opc_fdiv,&&opc_ddiv,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
/* 0x70 */ &&opc_irem, &&opc_lrem, &&opc_frem,&&opc_drem,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
/* 0x74 */ &&opc_ineg, &&opc_lneg, &&opc_fneg,&&opc_dneg,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
/* 0x78 */ &&opc_ishl, &&opc_lshl, &&opc_ishr,&&opc_lshr,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
/* 0x7C */ &&opc_iushr,&&opc_lushr,&&opc_iand,&&opc_land,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
/* 0x80 */ &&opc_ior, &&opc_lor,&&opc_ixor,&&opc_lxor,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
/* 0x84 */ &&opc_iinc,&&opc_i2l,&&opc_i2f, &&opc_i2d,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
/* 0x88 */ &&opc_l2i, &&opc_l2f,&&opc_l2d, &&opc_f2i,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
/* 0x8C */ &&opc_f2l, &&opc_f2d,&&opc_d2i, &&opc_d2l,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
/* 0x90 */ &&opc_d2f,  &&opc_i2b,  &&opc_i2c,  &&opc_i2s,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
/* 0x94 */ &&opc_lcmp, &&opc_fcmpl,&&opc_fcmpg,&&opc_dcmpl,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
/* 0x98 */ &&opc_dcmpg,&&opc_ifeq, &&opc_ifne, &&opc_iflt,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
/* 0x9C */ &&opc_ifge, &&opc_ifgt, &&opc_ifle, &&opc_if_icmpeq,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
/* 0xA0 */ &&opc_if_icmpne,&&opc_if_icmplt,&&opc_if_icmpge,  &&opc_if_icmpgt,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
/* 0xA4 */ &&opc_if_icmple,&&opc_if_acmpeq,&&opc_if_acmpne,  &&opc_goto,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
/* 0xA8 */ &&opc_jsr,      &&opc_ret,      &&opc_tableswitch,&&opc_lookupswitch,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
/* 0xAC */ &&opc_ireturn,  &&opc_lreturn,  &&opc_freturn,    &&opc_dreturn,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
/* 0xB0 */ &&opc_areturn,     &&opc_return,         &&opc_getstatic,    &&opc_putstatic,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
/* 0xB4 */ &&opc_getfield,    &&opc_putfield,       &&opc_invokevirtual,&&opc_invokespecial,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
/* 0xB8 */ &&opc_invokestatic,&&opc_invokeinterface,NULL,               &&opc_new,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
/* 0xBC */ &&opc_newarray,    &&opc_anewarray,      &&opc_arraylength,  &&opc_athrow,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
/* 0xC0 */ &&opc_checkcast,   &&opc_instanceof,     &&opc_monitorenter, &&opc_monitorexit,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
/* 0xC4 */ &&opc_wide,        &&opc_multianewarray, &&opc_ifnull,       &&opc_ifnonnull,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
/* 0xC8 */ &&opc_goto_w,      &&opc_jsr_w,          &&opc_breakpoint,   &&opc_fast_igetfield,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
/* 0xCC */ &&opc_fastagetfield,&&opc_fast_aload_0,  &&opc_fast_iaccess_0, &&opc__fast_aaccess_0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
/* 0xD0 */ &&opc_fast_linearswitch, &&opc_fast_binaryswitch, &&opc_return_register_finalizer,      &&opc_default,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
/* 0xD4 */ &&opc_default,     &&opc_default,        &&opc_default,      &&opc_default,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
/* 0xD8 */ &&opc_default,     &&opc_default,        &&opc_default,      &&opc_default,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
/* 0xDC */ &&opc_default,     &&opc_default,        &&opc_default,      &&opc_default,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
/* 0xE0 */ &&opc_default,     &&opc_default,        &&opc_default,      &&opc_default,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
/* 0xE4 */ &&opc_default,     &&opc_default,        &&opc_default,      &&opc_default,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
/* 0xE8 */ &&opc_default,     &&opc_default,        &&opc_default,      &&opc_default,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
/* 0xEC */ &&opc_default,     &&opc_default,        &&opc_default,      &&opc_default,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
/* 0xF0 */ &&opc_default,     &&opc_default,        &&opc_default,      &&opc_default,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
/* 0xF4 */ &&opc_default,     &&opc_default,        &&opc_default,      &&opc_default,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
/* 0xF8 */ &&opc_default,     &&opc_default,        &&opc_default,      &&opc_default,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
/* 0xFC */ &&opc_default,     &&opc_default,        &&opc_default,      &&opc_default
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
  register uintptr_t *dispatch_table = (uintptr_t*)&opclabels_data[0];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
#endif /* USELABELS */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
  // this will trigger a VERIFY_OOP on entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
  if (istate->msg() != initialize && ! METHOD->is_static()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
    oop rcvr = LOCALS_OBJECT(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
// #define HACK
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
#ifdef HACK
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
  bool interesting = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
#endif // HACK
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
  /* QQQ this should be a stack method so we don't know actual direction */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
  assert(istate->msg() == initialize ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
         topOfStack >= istate->stack_limit() &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
         topOfStack < istate->stack_base(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
         "Stack top out of range");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
  switch (istate->msg()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
    case initialize: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
      if (initialized++) ShouldNotReachHere(); // Only one initialize call
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
      _compiling = (UseCompiler || CountCompiledCalls);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
#ifdef VM_JVMTI
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
      _jvmti_interp_events = JvmtiExport::can_post_interpreter_events();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
      BarrierSet* bs = Universe::heap()->barrier_set();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
      assert(bs->kind() == BarrierSet::CardTableModRef, "Wrong barrier set kind");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
      _byte_map_base = (volatile jbyte*)(((CardTableModRefBS*)bs)->byte_map_base);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
      return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
    case method_entry: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
      THREAD->set_do_not_unlock();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
      // count invocations
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
      assert(initialized, "Interpreter not initialized");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
      if (_compiling) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
        if (ProfileInterpreter) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
          METHOD->increment_interpreter_invocation_count();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
        INCR_INVOCATION_COUNT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
        if (INVOCATION_COUNT->reached_InvocationLimit()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
            CALL_VM((void)InterpreterRuntime::frequency_counter_overflow(THREAD, NULL), handle_exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
            // We no longer retry on a counter overflow
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
            // istate->set_msg(retry_method);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
            // THREAD->clr_do_not_unlock();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
            // return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
        SAFEPOINT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
      if ((istate->_stack_base - istate->_stack_limit) != istate->method()->max_stack() + 1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
        // initialize
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
        os::breakpoint();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
#ifdef HACK
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
      {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
        ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
        char *method_name = istate->method()->name_and_sig_as_C_string();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
        if (strstr(method_name, "runThese$TestRunner.run()V") != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
          tty->print_cr("entering: depth %d bci: %d",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
                         (istate->_stack_base - istate->_stack),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
                         istate->_bcp - istate->_method->code_base());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
          interesting = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
#endif // HACK
489c9b5090e2 Initial load
duke
parents:
diff changeset
   610
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
      // lock method if synchronized
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
      if (METHOD->is_synchronized()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
          // oop rcvr = locals[0].j.r;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
          oop rcvr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
          if (METHOD->is_static()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
            rcvr = METHOD->constants()->pool_holder()->klass_part()->java_mirror();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   618
          } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
            rcvr = LOCALS_OBJECT(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   621
          // The initial monitor is ours for the taking
489c9b5090e2 Initial load
duke
parents:
diff changeset
   622
          BasicObjectLock* mon = &istate->monitor_base()[-1];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   623
          oop monobj = mon->obj();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   624
          assert(mon->obj() == rcvr, "method monitor mis-initialized");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   625
489c9b5090e2 Initial load
duke
parents:
diff changeset
   626
          bool success = UseBiasedLocking;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
          if (UseBiasedLocking) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   628
            markOop mark = rcvr->mark();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
            if (mark->has_bias_pattern()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
              // The bias pattern is present in the object's header. Need to check
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
              // whether the bias owner and the epoch are both still current.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
              intptr_t xx = ((intptr_t) THREAD) ^ (intptr_t) mark;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
              xx = (intptr_t) rcvr->klass()->klass_part()->prototype_header() ^ xx;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   634
              intptr_t yy = (xx & ~((int) markOopDesc::age_mask_in_place));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
              if (yy != 0 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
                // At this point we know that the header has the bias pattern and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
                // that we are not the bias owner in the current epoch. We need to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
                // figure out more details about the state of the header in order to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   639
                // know what operations can be legally performed on the object's
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
                // header.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   641
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
                // If the low three bits in the xor result aren't clear, that means
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
                // the prototype header is no longer biased and we have to revoke
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
                // the bias on this object.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
                if (yy & markOopDesc::biased_lock_mask_in_place == 0 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
                  // Biasing is still enabled for this data type. See whether the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
                  // epoch of the current bias is still valid, meaning that the epoch
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
                  // bits of the mark word are equal to the epoch bits of the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
                  // prototype header. (Note that the prototype header's epoch bits
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
                  // only change at a safepoint.) If not, attempt to rebias the object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
                  // toward the current thread. Note that we must be absolutely sure
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
                  // that the current epoch is invalid in order to do this because
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
                  // otherwise the manipulations it performs on the mark word are
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
                  // illegal.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
                  if (yy & markOopDesc::epoch_mask_in_place == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
                    // The epoch of the current bias is still valid but we know nothing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
                    // about the owner; it might be set or it might be clear. Try to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
                    // acquire the bias of the object using an atomic operation. If this
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
                    // fails we will go in to the runtime to revoke the object's bias.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
                    // Note that we first construct the presumed unbiased header so we
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
                    // don't accidentally blow away another thread's valid bias.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
                    intptr_t unbiased = (intptr_t) mark & (markOopDesc::biased_lock_mask_in_place |
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
                                                           markOopDesc::age_mask_in_place |
489c9b5090e2 Initial load
duke
parents:
diff changeset
   665
                                                           markOopDesc::epoch_mask_in_place);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   666
                    if (Atomic::cmpxchg_ptr((intptr_t)THREAD | unbiased, (intptr_t*) rcvr->mark_addr(), unbiased) != unbiased) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
                      CALL_VM(InterpreterRuntime::monitorenter(THREAD, mon), handle_exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   668
                    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
                  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
                    try_rebias:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
                    // At this point we know the epoch has expired, meaning that the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
                    // current "bias owner", if any, is actually invalid. Under these
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
                    // circumstances _only_, we are allowed to use the current header's
489c9b5090e2 Initial load
duke
parents:
diff changeset
   674
                    // value as the comparison value when doing the cas to acquire the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   675
                    // bias in the current epoch. In other words, we allow transfer of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   676
                    // the bias from one thread to another directly in this situation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   677
                    xx = (intptr_t) rcvr->klass()->klass_part()->prototype_header() | (intptr_t) THREAD;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   678
                    if (Atomic::cmpxchg_ptr((intptr_t)THREAD | (intptr_t) rcvr->klass()->klass_part()->prototype_header(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   679
                                            (intptr_t*) rcvr->mark_addr(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   680
                                            (intptr_t) mark) != (intptr_t) mark) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
                      CALL_VM(InterpreterRuntime::monitorenter(THREAD, mon), handle_exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
                    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
                  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
                } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
                  try_revoke_bias:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   686
                  // The prototype mark in the klass doesn't have the bias bit set any
489c9b5090e2 Initial load
duke
parents:
diff changeset
   687
                  // more, indicating that objects of this data type are not supposed
489c9b5090e2 Initial load
duke
parents:
diff changeset
   688
                  // to be biased any more. We are going to try to reset the mark of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   689
                  // this object to the prototype value and fall through to the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   690
                  // CAS-based locking scheme. Note that if our CAS fails, it means
489c9b5090e2 Initial load
duke
parents:
diff changeset
   691
                  // that another thread raced us for the privilege of revoking the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   692
                  // bias of this particular object, so it's okay to continue in the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   693
                  // normal locking code.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   694
                  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   695
                  xx = (intptr_t) rcvr->klass()->klass_part()->prototype_header() | (intptr_t) THREAD;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   696
                  if (Atomic::cmpxchg_ptr(rcvr->klass()->klass_part()->prototype_header(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   697
                                          (intptr_t*) rcvr->mark_addr(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   698
                                          mark) == mark) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   699
                    // (*counters->revoked_lock_entry_count_addr())++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   700
                  success = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   701
                  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
                }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   703
              }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
            } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
              cas_label:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
              success = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   709
          if (!success) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
            markOop displaced = rcvr->mark()->set_unlocked();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
            mon->lock()->set_displaced_header(displaced);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   712
            if (Atomic::cmpxchg_ptr(mon, rcvr->mark_addr(), displaced) != displaced) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   713
              // Is it simple recursive case?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
              if (THREAD->is_lock_owned((address) displaced->clear_lock_bits())) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   715
                mon->lock()->set_displaced_header(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   716
              } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   717
                CALL_VM(InterpreterRuntime::monitorenter(THREAD, mon), handle_exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   718
              }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   719
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   720
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   721
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
      THREAD->clr_do_not_unlock();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   723
489c9b5090e2 Initial load
duke
parents:
diff changeset
   724
      // Notify jvmti
489c9b5090e2 Initial load
duke
parents:
diff changeset
   725
#ifdef VM_JVMTI
489c9b5090e2 Initial load
duke
parents:
diff changeset
   726
      if (_jvmti_interp_events) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   727
        // Whenever JVMTI puts a thread in interp_only_mode, method
489c9b5090e2 Initial load
duke
parents:
diff changeset
   728
        // entry/exit events are sent for that thread to track stack depth.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   729
        if (THREAD->is_interp_only_mode()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   730
          CALL_VM(InterpreterRuntime::post_method_entry(THREAD),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   731
                  handle_exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   733
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   734
#endif /* VM_JVMTI */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   735
489c9b5090e2 Initial load
duke
parents:
diff changeset
   736
      goto run;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   737
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   738
489c9b5090e2 Initial load
duke
parents:
diff changeset
   739
    case popping_frame: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   740
      // returned from a java call to pop the frame, restart the call
489c9b5090e2 Initial load
duke
parents:
diff changeset
   741
      // clear the message so we don't confuse ourselves later
489c9b5090e2 Initial load
duke
parents:
diff changeset
   742
      assert(THREAD->pop_frame_in_process(), "wrong frame pop state");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   743
      istate->set_msg(no_request);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   744
      THREAD->clr_pop_frame_in_process();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   745
      goto run;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   746
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   747
489c9b5090e2 Initial load
duke
parents:
diff changeset
   748
    case method_resume: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   749
      if ((istate->_stack_base - istate->_stack_limit) != istate->method()->max_stack() + 1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   750
        // resume
489c9b5090e2 Initial load
duke
parents:
diff changeset
   751
        os::breakpoint();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   752
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
#ifdef HACK
489c9b5090e2 Initial load
duke
parents:
diff changeset
   754
      {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   755
        ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   756
        char *method_name = istate->method()->name_and_sig_as_C_string();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   757
        if (strstr(method_name, "runThese$TestRunner.run()V") != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   758
          tty->print_cr("resume: depth %d bci: %d",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   759
                         (istate->_stack_base - istate->_stack) ,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   760
                         istate->_bcp - istate->_method->code_base());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   761
          interesting = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   762
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   763
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   764
#endif // HACK
489c9b5090e2 Initial load
duke
parents:
diff changeset
   765
      // returned from a java call, continue executing.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   766
      if (THREAD->pop_frame_pending() && !THREAD->pop_frame_in_process()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   767
        goto handle_Pop_Frame;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   768
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   769
489c9b5090e2 Initial load
duke
parents:
diff changeset
   770
      if (THREAD->has_pending_exception()) goto handle_exception;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   771
      // Update the pc by the saved amount of the invoke bytecode size
489c9b5090e2 Initial load
duke
parents:
diff changeset
   772
      UPDATE_PC(istate->bcp_advance());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   773
      goto run;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   774
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   775
489c9b5090e2 Initial load
duke
parents:
diff changeset
   776
    case deopt_resume2: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   777
      // Returned from an opcode that will reexecute. Deopt was
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
      // a result of a PopFrame request.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   779
      //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   780
      goto run;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   781
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   782
489c9b5090e2 Initial load
duke
parents:
diff changeset
   783
    case deopt_resume: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   784
      // Returned from an opcode that has completed. The stack has
489c9b5090e2 Initial load
duke
parents:
diff changeset
   785
      // the result all we need to do is skip across the bytecode
489c9b5090e2 Initial load
duke
parents:
diff changeset
   786
      // and continue (assuming there is no exception pending)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   787
      //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   788
      // compute continuation length
489c9b5090e2 Initial load
duke
parents:
diff changeset
   789
      //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   790
      // Note: it is possible to deopt at a return_register_finalizer opcode
489c9b5090e2 Initial load
duke
parents:
diff changeset
   791
      // because this requires entering the vm to do the registering. While the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   792
      // opcode is complete we can't advance because there are no more opcodes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   793
      // much like trying to deopt at a poll return. In that has we simply
489c9b5090e2 Initial load
duke
parents:
diff changeset
   794
      // get out of here
489c9b5090e2 Initial load
duke
parents:
diff changeset
   795
      //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   796
      if ( Bytecodes::code_at(pc, METHOD) == Bytecodes::_return_register_finalizer) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   797
        // this will do the right thing even if an exception is pending.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   798
        goto handle_return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   799
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   800
      UPDATE_PC(Bytecodes::length_at(pc));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   801
      if (THREAD->has_pending_exception()) goto handle_exception;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   802
      goto run;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   803
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   804
    case got_monitors: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   805
      // continue locking now that we have a monitor to use
489c9b5090e2 Initial load
duke
parents:
diff changeset
   806
      // we expect to find newly allocated monitor at the "top" of the monitor stack.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   807
      oop lockee = STACK_OBJECT(-1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   808
      // derefing's lockee ought to provoke implicit null check
489c9b5090e2 Initial load
duke
parents:
diff changeset
   809
      // find a free monitor
489c9b5090e2 Initial load
duke
parents:
diff changeset
   810
      BasicObjectLock* entry = (BasicObjectLock*) istate->stack_base();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   811
      assert(entry->obj() == NULL, "Frame manager didn't allocate the monitor");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   812
      entry->set_obj(lockee);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   813
489c9b5090e2 Initial load
duke
parents:
diff changeset
   814
      markOop displaced = lockee->mark()->set_unlocked();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   815
      entry->lock()->set_displaced_header(displaced);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   816
      if (Atomic::cmpxchg_ptr(entry, lockee->mark_addr(), displaced) != displaced) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   817
        // Is it simple recursive case?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   818
        if (THREAD->is_lock_owned((address) displaced->clear_lock_bits())) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   819
          entry->lock()->set_displaced_header(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   820
        } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   821
          CALL_VM(InterpreterRuntime::monitorenter(THREAD, entry), handle_exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   822
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   823
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   824
      UPDATE_PC_AND_TOS(1, -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   825
      goto run;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   826
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   827
    default: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   828
      fatal("Unexpected message from frame manager");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   829
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   830
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   831
489c9b5090e2 Initial load
duke
parents:
diff changeset
   832
run:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   833
489c9b5090e2 Initial load
duke
parents:
diff changeset
   834
  DO_UPDATE_INSTRUCTION_COUNT(*pc)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   835
  DEBUGGER_SINGLE_STEP_NOTIFY();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   836
#ifdef PREFETCH_OPCCODE
489c9b5090e2 Initial load
duke
parents:
diff changeset
   837
  opcode = *pc;  /* prefetch first opcode */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   838
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   839
489c9b5090e2 Initial load
duke
parents:
diff changeset
   840
#ifndef USELABELS
489c9b5090e2 Initial load
duke
parents:
diff changeset
   841
  while (1)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   842
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   843
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   844
#ifndef PREFETCH_OPCCODE
489c9b5090e2 Initial load
duke
parents:
diff changeset
   845
      opcode = *pc;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   846
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   847
      // Seems like this happens twice per opcode. At worst this is only
489c9b5090e2 Initial load
duke
parents:
diff changeset
   848
      // need at entry to the loop.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   849
      // DEBUGGER_SINGLE_STEP_NOTIFY();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   850
      /* Using this labels avoids double breakpoints when quickening and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   851
       * when returing from transition frames.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   852
       */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   853
  opcode_switch:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   854
      assert(istate == orig, "Corrupted istate");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   855
      /* QQQ Hmm this has knowledge of direction, ought to be a stack method */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   856
      assert(topOfStack >= istate->stack_limit(), "Stack overrun");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   857
      assert(topOfStack < istate->stack_base(), "Stack underrun");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   858
489c9b5090e2 Initial load
duke
parents:
diff changeset
   859
#ifdef USELABELS
489c9b5090e2 Initial load
duke
parents:
diff changeset
   860
      DISPATCH(opcode);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   861
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   862
      switch (opcode)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   863
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   864
      {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   865
      CASE(_nop):
489c9b5090e2 Initial load
duke
parents:
diff changeset
   866
          UPDATE_PC_AND_CONTINUE(1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   867
489c9b5090e2 Initial load
duke
parents:
diff changeset
   868
          /* Push miscellaneous constants onto the stack. */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   869
489c9b5090e2 Initial load
duke
parents:
diff changeset
   870
      CASE(_aconst_null):
489c9b5090e2 Initial load
duke
parents:
diff changeset
   871
          SET_STACK_OBJECT(NULL, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   872
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   873
489c9b5090e2 Initial load
duke
parents:
diff changeset
   874
#undef  OPC_CONST_n
489c9b5090e2 Initial load
duke
parents:
diff changeset
   875
#define OPC_CONST_n(opcode, const_type, value)                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   876
      CASE(opcode):                                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   877
          SET_STACK_ ## const_type(value, 0);                           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   878
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   879
489c9b5090e2 Initial load
duke
parents:
diff changeset
   880
          OPC_CONST_n(_iconst_m1,   INT,       -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   881
          OPC_CONST_n(_iconst_0,    INT,        0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   882
          OPC_CONST_n(_iconst_1,    INT,        1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   883
          OPC_CONST_n(_iconst_2,    INT,        2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   884
          OPC_CONST_n(_iconst_3,    INT,        3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   885
          OPC_CONST_n(_iconst_4,    INT,        4);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   886
          OPC_CONST_n(_iconst_5,    INT,        5);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   887
          OPC_CONST_n(_fconst_0,    FLOAT,      0.0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   888
          OPC_CONST_n(_fconst_1,    FLOAT,      1.0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   889
          OPC_CONST_n(_fconst_2,    FLOAT,      2.0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   890
489c9b5090e2 Initial load
duke
parents:
diff changeset
   891
#undef  OPC_CONST2_n
489c9b5090e2 Initial load
duke
parents:
diff changeset
   892
#define OPC_CONST2_n(opcname, value, key, kind)                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   893
      CASE(_##opcname):                                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   894
      {                                                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   895
          SET_STACK_ ## kind(VM##key##Const##value(), 1);               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   896
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, 2);                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   897
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   898
         OPC_CONST2_n(dconst_0, Zero, double, DOUBLE);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   899
         OPC_CONST2_n(dconst_1, One,  double, DOUBLE);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   900
         OPC_CONST2_n(lconst_0, Zero, long, LONG);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   901
         OPC_CONST2_n(lconst_1, One,  long, LONG);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   902
489c9b5090e2 Initial load
duke
parents:
diff changeset
   903
         /* Load constant from constant pool: */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   904
489c9b5090e2 Initial load
duke
parents:
diff changeset
   905
          /* Push a 1-byte signed integer value onto the stack. */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   906
      CASE(_bipush):
489c9b5090e2 Initial load
duke
parents:
diff changeset
   907
          SET_STACK_INT((jbyte)(pc[1]), 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   908
          UPDATE_PC_AND_TOS_AND_CONTINUE(2, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   909
489c9b5090e2 Initial load
duke
parents:
diff changeset
   910
          /* Push a 2-byte signed integer constant onto the stack. */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   911
      CASE(_sipush):
489c9b5090e2 Initial load
duke
parents:
diff changeset
   912
          SET_STACK_INT((int16_t)Bytes::get_Java_u2(pc + 1), 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   913
          UPDATE_PC_AND_TOS_AND_CONTINUE(3, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   914
489c9b5090e2 Initial load
duke
parents:
diff changeset
   915
          /* load from local variable */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   916
489c9b5090e2 Initial load
duke
parents:
diff changeset
   917
      CASE(_aload):
489c9b5090e2 Initial load
duke
parents:
diff changeset
   918
          SET_STACK_OBJECT(LOCALS_OBJECT(pc[1]), 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   919
          UPDATE_PC_AND_TOS_AND_CONTINUE(2, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   920
489c9b5090e2 Initial load
duke
parents:
diff changeset
   921
      CASE(_iload):
489c9b5090e2 Initial load
duke
parents:
diff changeset
   922
      CASE(_fload):
489c9b5090e2 Initial load
duke
parents:
diff changeset
   923
          SET_STACK_SLOT(LOCALS_SLOT(pc[1]), 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   924
          UPDATE_PC_AND_TOS_AND_CONTINUE(2, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   925
489c9b5090e2 Initial load
duke
parents:
diff changeset
   926
      CASE(_lload):
489c9b5090e2 Initial load
duke
parents:
diff changeset
   927
          SET_STACK_LONG_FROM_ADDR(LOCALS_LONG_AT(pc[1]), 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   928
          UPDATE_PC_AND_TOS_AND_CONTINUE(2, 2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   929
489c9b5090e2 Initial load
duke
parents:
diff changeset
   930
      CASE(_dload):
489c9b5090e2 Initial load
duke
parents:
diff changeset
   931
          SET_STACK_DOUBLE_FROM_ADDR(LOCALS_DOUBLE_AT(pc[1]), 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   932
          UPDATE_PC_AND_TOS_AND_CONTINUE(2, 2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   933
489c9b5090e2 Initial load
duke
parents:
diff changeset
   934
#undef  OPC_LOAD_n
489c9b5090e2 Initial load
duke
parents:
diff changeset
   935
#define OPC_LOAD_n(num)                                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   936
      CASE(_aload_##num):                                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   937
          SET_STACK_OBJECT(LOCALS_OBJECT(num), 0);                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   938
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, 1);                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   939
                                                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   940
      CASE(_iload_##num):                                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   941
      CASE(_fload_##num):                                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   942
          SET_STACK_SLOT(LOCALS_SLOT(num), 0);                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   943
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, 1);                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   944
                                                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   945
      CASE(_lload_##num):                                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   946
          SET_STACK_LONG_FROM_ADDR(LOCALS_LONG_AT(num), 1);             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   947
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, 2);                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   948
      CASE(_dload_##num):                                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   949
          SET_STACK_DOUBLE_FROM_ADDR(LOCALS_DOUBLE_AT(num), 1);         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   950
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, 2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   951
489c9b5090e2 Initial load
duke
parents:
diff changeset
   952
          OPC_LOAD_n(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   953
          OPC_LOAD_n(1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   954
          OPC_LOAD_n(2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   955
          OPC_LOAD_n(3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   956
489c9b5090e2 Initial load
duke
parents:
diff changeset
   957
          /* store to a local variable */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   958
489c9b5090e2 Initial load
duke
parents:
diff changeset
   959
      CASE(_astore):
489c9b5090e2 Initial load
duke
parents:
diff changeset
   960
          astore(topOfStack, -1, locals, pc[1]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   961
          UPDATE_PC_AND_TOS_AND_CONTINUE(2, -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   962
489c9b5090e2 Initial load
duke
parents:
diff changeset
   963
      CASE(_istore):
489c9b5090e2 Initial load
duke
parents:
diff changeset
   964
      CASE(_fstore):
489c9b5090e2 Initial load
duke
parents:
diff changeset
   965
          SET_LOCALS_SLOT(STACK_SLOT(-1), pc[1]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   966
          UPDATE_PC_AND_TOS_AND_CONTINUE(2, -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   967
489c9b5090e2 Initial load
duke
parents:
diff changeset
   968
      CASE(_lstore):
489c9b5090e2 Initial load
duke
parents:
diff changeset
   969
          SET_LOCALS_LONG(STACK_LONG(-1), pc[1]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   970
          UPDATE_PC_AND_TOS_AND_CONTINUE(2, -2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   971
489c9b5090e2 Initial load
duke
parents:
diff changeset
   972
      CASE(_dstore):
489c9b5090e2 Initial load
duke
parents:
diff changeset
   973
          SET_LOCALS_DOUBLE(STACK_DOUBLE(-1), pc[1]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   974
          UPDATE_PC_AND_TOS_AND_CONTINUE(2, -2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   975
489c9b5090e2 Initial load
duke
parents:
diff changeset
   976
      CASE(_wide): {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   977
          uint16_t reg = Bytes::get_Java_u2(pc + 2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   978
489c9b5090e2 Initial load
duke
parents:
diff changeset
   979
          opcode = pc[1];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   980
          switch(opcode) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   981
              case Bytecodes::_aload:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   982
                  SET_STACK_OBJECT(LOCALS_OBJECT(reg), 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   983
                  UPDATE_PC_AND_TOS_AND_CONTINUE(4, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   984
489c9b5090e2 Initial load
duke
parents:
diff changeset
   985
              case Bytecodes::_iload:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   986
              case Bytecodes::_fload:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   987
                  SET_STACK_SLOT(LOCALS_SLOT(reg), 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   988
                  UPDATE_PC_AND_TOS_AND_CONTINUE(4, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   989
489c9b5090e2 Initial load
duke
parents:
diff changeset
   990
              case Bytecodes::_lload:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   991
                  SET_STACK_LONG_FROM_ADDR(LOCALS_LONG_AT(reg), 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   992
                  UPDATE_PC_AND_TOS_AND_CONTINUE(4, 2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   993
489c9b5090e2 Initial load
duke
parents:
diff changeset
   994
              case Bytecodes::_dload:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   995
                  SET_STACK_DOUBLE_FROM_ADDR(LOCALS_LONG_AT(reg), 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   996
                  UPDATE_PC_AND_TOS_AND_CONTINUE(4, 2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   997
489c9b5090e2 Initial load
duke
parents:
diff changeset
   998
              case Bytecodes::_astore:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   999
                  astore(topOfStack, -1, locals, reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1000
                  UPDATE_PC_AND_TOS_AND_CONTINUE(4, -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1001
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1002
              case Bytecodes::_istore:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1003
              case Bytecodes::_fstore:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1004
                  SET_LOCALS_SLOT(STACK_SLOT(-1), reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1005
                  UPDATE_PC_AND_TOS_AND_CONTINUE(4, -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1006
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1007
              case Bytecodes::_lstore:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1008
                  SET_LOCALS_LONG(STACK_LONG(-1), reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1009
                  UPDATE_PC_AND_TOS_AND_CONTINUE(4, -2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1010
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1011
              case Bytecodes::_dstore:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1012
                  SET_LOCALS_DOUBLE(STACK_DOUBLE(-1), reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1013
                  UPDATE_PC_AND_TOS_AND_CONTINUE(4, -2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1014
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1015
              case Bytecodes::_iinc: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1016
                  int16_t offset = (int16_t)Bytes::get_Java_u2(pc+4);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1017
                  // Be nice to see what this generates.... QQQ
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1018
                  SET_LOCALS_INT(LOCALS_INT(reg) + offset, reg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1019
                  UPDATE_PC_AND_CONTINUE(6);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1020
              }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1021
              case Bytecodes::_ret:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1022
                  pc = istate->method()->code_base() + (intptr_t)(LOCALS_ADDR(reg));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1023
                  UPDATE_PC_AND_CONTINUE(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1024
              default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1025
                  VM_JAVA_ERROR(vmSymbols::java_lang_InternalError(), "undefined opcode");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1026
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1027
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1028
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1029
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1030
#undef  OPC_STORE_n
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1031
#define OPC_STORE_n(num)                                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1032
      CASE(_astore_##num):                                              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1033
          astore(topOfStack, -1, locals, num);                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1034
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, -1);                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1035
      CASE(_istore_##num):                                              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1036
      CASE(_fstore_##num):                                              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1037
          SET_LOCALS_SLOT(STACK_SLOT(-1), num);                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1038
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1039
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1040
          OPC_STORE_n(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1041
          OPC_STORE_n(1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1042
          OPC_STORE_n(2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1043
          OPC_STORE_n(3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1044
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1045
#undef  OPC_DSTORE_n
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1046
#define OPC_DSTORE_n(num)                                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1047
      CASE(_dstore_##num):                                              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1048
          SET_LOCALS_DOUBLE(STACK_DOUBLE(-1), num);                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1049
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, -2);                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1050
      CASE(_lstore_##num):                                              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1051
          SET_LOCALS_LONG(STACK_LONG(-1), num);                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1052
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, -2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1053
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1054
          OPC_DSTORE_n(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1055
          OPC_DSTORE_n(1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1056
          OPC_DSTORE_n(2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1057
          OPC_DSTORE_n(3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1058
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1059
          /* stack pop, dup, and insert opcodes */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1060
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1061
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1062
      CASE(_pop):                /* Discard the top item on the stack */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1063
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1064
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1065
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1066
      CASE(_pop2):               /* Discard the top 2 items on the stack */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1067
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, -2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1068
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1069
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1070
      CASE(_dup):               /* Duplicate the top item on the stack */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1071
          dup(topOfStack);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1072
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1073
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1074
      CASE(_dup2):              /* Duplicate the top 2 items on the stack */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1075
          dup2(topOfStack);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1076
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, 2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1077
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1078
      CASE(_dup_x1):    /* insert top word two down */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1079
          dup_x1(topOfStack);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1080
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1081
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1082
      CASE(_dup_x2):    /* insert top word three down  */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1083
          dup_x2(topOfStack);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1084
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1085
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1086
      CASE(_dup2_x1):   /* insert top 2 slots three down */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1087
          dup2_x1(topOfStack);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1088
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, 2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1089
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1090
      CASE(_dup2_x2):   /* insert top 2 slots four down */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1091
          dup2_x2(topOfStack);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1092
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, 2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1093
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1094
      CASE(_swap): {        /* swap top two elements on the stack */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1095
          swap(topOfStack);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1096
          UPDATE_PC_AND_CONTINUE(1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1097
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1098
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1099
          /* Perform various binary integer operations */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1100
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1101
#undef  OPC_INT_BINARY
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1102
#define OPC_INT_BINARY(opcname, opname, test)                           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1103
      CASE(_i##opcname):                                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1104
          if (test && (STACK_INT(-1) == 0)) {                           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1105
              VM_JAVA_ERROR(vmSymbols::java_lang_ArithmeticException(), \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1106
                            "/ by int zero");                           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1107
          }                                                             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1108
          SET_STACK_INT(VMint##opname(STACK_INT(-2),                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1109
                                      STACK_INT(-1)),                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1110
                                      -2);                              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1111
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, -1);                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1112
      CASE(_l##opcname):                                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1113
      {                                                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1114
          if (test) {                                                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1115
            jlong l1 = STACK_LONG(-1);                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1116
            if (VMlongEqz(l1)) {                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1117
              VM_JAVA_ERROR(vmSymbols::java_lang_ArithmeticException(), \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1118
                            "/ by long zero");                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1119
            }                                                           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1120
          }                                                             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1121
          /* First long at (-1,-2) next long at (-3,-4) */              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1122
          SET_STACK_LONG(VMlong##opname(STACK_LONG(-3),                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1123
                                        STACK_LONG(-1)),                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1124
                                        -3);                            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1125
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, -2);                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1126
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1127
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1128
      OPC_INT_BINARY(add, Add, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1129
      OPC_INT_BINARY(sub, Sub, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1130
      OPC_INT_BINARY(mul, Mul, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1131
      OPC_INT_BINARY(and, And, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1132
      OPC_INT_BINARY(or,  Or,  0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1133
      OPC_INT_BINARY(xor, Xor, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1134
      OPC_INT_BINARY(div, Div, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1135
      OPC_INT_BINARY(rem, Rem, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1136
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1137
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1138
      /* Perform various binary floating number operations */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1139
      /* On some machine/platforms/compilers div zero check can be implicit */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1140
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1141
#undef  OPC_FLOAT_BINARY
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1142
#define OPC_FLOAT_BINARY(opcname, opname)                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1143
      CASE(_d##opcname): {                                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1144
          SET_STACK_DOUBLE(VMdouble##opname(STACK_DOUBLE(-3),              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1145
                                            STACK_DOUBLE(-1)),             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1146
                                            -3);                           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1147
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, -2);                           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1148
      }                                                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1149
      CASE(_f##opcname):                                                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1150
          SET_STACK_FLOAT(VMfloat##opname(STACK_FLOAT(-2),                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1151
                                          STACK_FLOAT(-1)),                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1152
                                          -2);                             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1153
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1154
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1155
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1156
     OPC_FLOAT_BINARY(add, Add);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1157
     OPC_FLOAT_BINARY(sub, Sub);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1158
     OPC_FLOAT_BINARY(mul, Mul);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1159
     OPC_FLOAT_BINARY(div, Div);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1160
     OPC_FLOAT_BINARY(rem, Rem);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1161
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1162
      /* Shift operations
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1163
       * Shift left int and long: ishl, lshl
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1164
       * Logical shift right int and long w/zero extension: iushr, lushr
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1165
       * Arithmetic shift right int and long w/sign extension: ishr, lshr
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1166
       */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1167
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1168
#undef  OPC_SHIFT_BINARY
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1169
#define OPC_SHIFT_BINARY(opcname, opname)                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1170
      CASE(_i##opcname):                                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1171
         SET_STACK_INT(VMint##opname(STACK_INT(-2),                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1172
                                     STACK_INT(-1)),                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1173
                                     -2);                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1174
         UPDATE_PC_AND_TOS_AND_CONTINUE(1, -1);                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1175
      CASE(_l##opcname):                                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1176
      {                                                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1177
         SET_STACK_LONG(VMlong##opname(STACK_LONG(-2),                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1178
                                       STACK_INT(-1)),                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1179
                                       -2);                             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1180
         UPDATE_PC_AND_TOS_AND_CONTINUE(1, -1);                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1181
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1182
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1183
      OPC_SHIFT_BINARY(shl, Shl);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1184
      OPC_SHIFT_BINARY(shr, Shr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1185
      OPC_SHIFT_BINARY(ushr, Ushr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1186
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1187
     /* Increment local variable by constant */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1188
      CASE(_iinc):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1189
      {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1190
          // locals[pc[1]].j.i += (jbyte)(pc[2]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1191
          SET_LOCALS_INT(LOCALS_INT(pc[1]) + (jbyte)(pc[2]), pc[1]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1192
          UPDATE_PC_AND_CONTINUE(3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1193
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1194
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1195
     /* negate the value on the top of the stack */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1196
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1197
      CASE(_ineg):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1198
         SET_STACK_INT(VMintNeg(STACK_INT(-1)), -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1199
         UPDATE_PC_AND_CONTINUE(1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1200
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1201
      CASE(_fneg):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1202
         SET_STACK_FLOAT(VMfloatNeg(STACK_FLOAT(-1)), -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1203
         UPDATE_PC_AND_CONTINUE(1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1204
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1205
      CASE(_lneg):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1206
      {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1207
         SET_STACK_LONG(VMlongNeg(STACK_LONG(-1)), -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1208
         UPDATE_PC_AND_CONTINUE(1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1209
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1210
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1211
      CASE(_dneg):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1212
      {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1213
         SET_STACK_DOUBLE(VMdoubleNeg(STACK_DOUBLE(-1)), -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1214
         UPDATE_PC_AND_CONTINUE(1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1215
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1216
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1217
      /* Conversion operations */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1218
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1219
      CASE(_i2f):       /* convert top of stack int to float */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1220
         SET_STACK_FLOAT(VMint2Float(STACK_INT(-1)), -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1221
         UPDATE_PC_AND_CONTINUE(1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1222
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1223
      CASE(_i2l):       /* convert top of stack int to long */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1224
      {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1225
          // this is ugly QQQ
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1226
          jlong r = VMint2Long(STACK_INT(-1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1227
          MORE_STACK(-1); // Pop
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1228
          SET_STACK_LONG(r, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1229
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1230
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, 2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1231
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1232
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1233
      CASE(_i2d):       /* convert top of stack int to double */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1234
      {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1235
          // this is ugly QQQ (why cast to jlong?? )
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1236
          jdouble r = (jlong)STACK_INT(-1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1237
          MORE_STACK(-1); // Pop
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1238
          SET_STACK_DOUBLE(r, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1239
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1240
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, 2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1241
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1242
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1243
      CASE(_l2i):       /* convert top of stack long to int */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1244
      {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1245
          jint r = VMlong2Int(STACK_LONG(-1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1246
          MORE_STACK(-2); // Pop
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1247
          SET_STACK_INT(r, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1248
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1249
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1250
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1251
      CASE(_l2f):   /* convert top of stack long to float */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1252
      {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1253
          jlong r = STACK_LONG(-1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1254
          MORE_STACK(-2); // Pop
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1255
          SET_STACK_FLOAT(VMlong2Float(r), 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1256
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1257
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1258
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1259
      CASE(_l2d):       /* convert top of stack long to double */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1260
      {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1261
          jlong r = STACK_LONG(-1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1262
          MORE_STACK(-2); // Pop
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1263
          SET_STACK_DOUBLE(VMlong2Double(r), 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1264
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, 2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1265
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1266
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1267
      CASE(_f2i):  /* Convert top of stack float to int */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1268
          SET_STACK_INT(SharedRuntime::f2i(STACK_FLOAT(-1)), -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1269
          UPDATE_PC_AND_CONTINUE(1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1270
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1271
      CASE(_f2l):  /* convert top of stack float to long */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1272
      {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1273
          jlong r = SharedRuntime::f2l(STACK_FLOAT(-1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1274
          MORE_STACK(-1); // POP
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1275
          SET_STACK_LONG(r, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1276
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, 2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1277
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1278
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1279
      CASE(_f2d):  /* convert top of stack float to double */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1280
      {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1281
          jfloat f;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1282
          jdouble r;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1283
          f = STACK_FLOAT(-1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1284
#ifdef IA64
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1285
          // IA64 gcc bug
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1286
          r = ( f == 0.0f ) ? (jdouble) f : (jdouble) f + ia64_double_zero;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1287
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1288
          r = (jdouble) f;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1289
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1290
          MORE_STACK(-1); // POP
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1291
          SET_STACK_DOUBLE(r, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1292
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, 2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1293
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1294
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1295
      CASE(_d2i): /* convert top of stack double to int */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1296
      {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1297
          jint r1 = SharedRuntime::d2i(STACK_DOUBLE(-1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1298
          MORE_STACK(-2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1299
          SET_STACK_INT(r1, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1300
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1301
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1302
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1303
      CASE(_d2f): /* convert top of stack double to float */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1304
      {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1305
          jfloat r1 = VMdouble2Float(STACK_DOUBLE(-1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1306
          MORE_STACK(-2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1307
          SET_STACK_FLOAT(r1, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1308
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1309
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1310
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1311
      CASE(_d2l): /* convert top of stack double to long */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1312
      {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1313
          jlong r1 = SharedRuntime::d2l(STACK_DOUBLE(-1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1314
          MORE_STACK(-2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1315
          SET_STACK_LONG(r1, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1316
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, 2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1317
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1318
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1319
      CASE(_i2b):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1320
          SET_STACK_INT(VMint2Byte(STACK_INT(-1)), -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1321
          UPDATE_PC_AND_CONTINUE(1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1322
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1323
      CASE(_i2c):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1324
          SET_STACK_INT(VMint2Char(STACK_INT(-1)), -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1325
          UPDATE_PC_AND_CONTINUE(1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1326
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1327
      CASE(_i2s):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1328
          SET_STACK_INT(VMint2Short(STACK_INT(-1)), -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1329
          UPDATE_PC_AND_CONTINUE(1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1330
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1331
      /* comparison operators */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1332
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1333
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1334
#define COMPARISON_OP(name, comparison)                                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1335
      CASE(_if_icmp##name): {                                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1336
          int skip = (STACK_INT(-2) comparison STACK_INT(-1))                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1337
                      ? (int16_t)Bytes::get_Java_u2(pc + 1) : 3;             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1338
          address branch_pc = pc;                                            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1339
          UPDATE_PC_AND_TOS(skip, -2);                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1340
          DO_BACKEDGE_CHECKS(skip, branch_pc);                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1341
          CONTINUE;                                                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1342
      }                                                                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1343
      CASE(_if##name): {                                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1344
          int skip = (STACK_INT(-1) comparison 0)                            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1345
                      ? (int16_t)Bytes::get_Java_u2(pc + 1) : 3;             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1346
          address branch_pc = pc;                                            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1347
          UPDATE_PC_AND_TOS(skip, -1);                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1348
          DO_BACKEDGE_CHECKS(skip, branch_pc);                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1349
          CONTINUE;                                                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1350
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1351
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1352
#define COMPARISON_OP2(name, comparison)                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1353
      COMPARISON_OP(name, comparison)                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1354
      CASE(_if_acmp##name): {                                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1355
          int skip = (STACK_OBJECT(-2) comparison STACK_OBJECT(-1))          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1356
                       ? (int16_t)Bytes::get_Java_u2(pc + 1) : 3;            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1357
          address branch_pc = pc;                                            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1358
          UPDATE_PC_AND_TOS(skip, -2);                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1359
          DO_BACKEDGE_CHECKS(skip, branch_pc);                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1360
          CONTINUE;                                                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1361
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1362
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1363
#define NULL_COMPARISON_NOT_OP(name)                                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1364
      CASE(_if##name): {                                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1365
          int skip = (!(STACK_OBJECT(-1) == 0))                              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1366
                      ? (int16_t)Bytes::get_Java_u2(pc + 1) : 3;             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1367
          address branch_pc = pc;                                            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1368
          UPDATE_PC_AND_TOS(skip, -1);                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1369
          DO_BACKEDGE_CHECKS(skip, branch_pc);                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1370
          CONTINUE;                                                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1371
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1372
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1373
#define NULL_COMPARISON_OP(name)                                             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1374
      CASE(_if##name): {                                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1375
          int skip = ((STACK_OBJECT(-1) == 0))                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1376
                      ? (int16_t)Bytes::get_Java_u2(pc + 1) : 3;             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1377
          address branch_pc = pc;                                            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1378
          UPDATE_PC_AND_TOS(skip, -1);                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1379
          DO_BACKEDGE_CHECKS(skip, branch_pc);                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1380
          CONTINUE;                                                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1381
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1382
      COMPARISON_OP(lt, <);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1383
      COMPARISON_OP(gt, >);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1384
      COMPARISON_OP(le, <=);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1385
      COMPARISON_OP(ge, >=);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1386
      COMPARISON_OP2(eq, ==);  /* include ref comparison */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1387
      COMPARISON_OP2(ne, !=);  /* include ref comparison */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1388
      NULL_COMPARISON_OP(null);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1389
      NULL_COMPARISON_NOT_OP(nonnull);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1390
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1391
      /* Goto pc at specified offset in switch table. */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1392
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1393
      CASE(_tableswitch): {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1394
          jint* lpc  = (jint*)VMalignWordUp(pc+1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1395
          int32_t  key  = STACK_INT(-1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1396
          int32_t  low  = Bytes::get_Java_u4((address)&lpc[1]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1397
          int32_t  high = Bytes::get_Java_u4((address)&lpc[2]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1398
          int32_t  skip;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1399
          key -= low;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1400
          skip = ((uint32_t) key > (uint32_t)(high - low))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1401
                      ? Bytes::get_Java_u4((address)&lpc[0])
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1402
                      : Bytes::get_Java_u4((address)&lpc[key + 3]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1403
          // Does this really need a full backedge check (osr?)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1404
          address branch_pc = pc;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1405
          UPDATE_PC_AND_TOS(skip, -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1406
          DO_BACKEDGE_CHECKS(skip, branch_pc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1407
          CONTINUE;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1408
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1409
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1410
      /* Goto pc whose table entry matches specified key */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1411
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1412
      CASE(_lookupswitch): {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1413
          jint* lpc  = (jint*)VMalignWordUp(pc+1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1414
          int32_t  key  = STACK_INT(-1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1415
          int32_t  skip = Bytes::get_Java_u4((address) lpc); /* default amount */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1416
          int32_t  npairs = Bytes::get_Java_u4((address) &lpc[1]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1417
          while (--npairs >= 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1418
              lpc += 2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1419
              if (key == (int32_t)Bytes::get_Java_u4((address)lpc)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1420
                  skip = Bytes::get_Java_u4((address)&lpc[1]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1421
                  break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1422
              }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1423
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1424
          address branch_pc = pc;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1425
          UPDATE_PC_AND_TOS(skip, -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1426
          DO_BACKEDGE_CHECKS(skip, branch_pc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1427
          CONTINUE;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1428
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1429
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1430
      CASE(_fcmpl):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1431
      CASE(_fcmpg):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1432
      {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1433
          SET_STACK_INT(VMfloatCompare(STACK_FLOAT(-2),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1434
                                        STACK_FLOAT(-1),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1435
                                        (opcode == Bytecodes::_fcmpl ? -1 : 1)),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1436
                        -2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1437
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1438
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1439
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1440
      CASE(_dcmpl):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1441
      CASE(_dcmpg):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1442
      {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1443
          int r = VMdoubleCompare(STACK_DOUBLE(-3),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1444
                                  STACK_DOUBLE(-1),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1445
                                  (opcode == Bytecodes::_dcmpl ? -1 : 1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1446
          MORE_STACK(-4); // Pop
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1447
          SET_STACK_INT(r, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1448
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1449
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1450
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1451
      CASE(_lcmp):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1452
      {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1453
          int r = VMlongCompare(STACK_LONG(-3), STACK_LONG(-1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1454
          MORE_STACK(-4);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1455
          SET_STACK_INT(r, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1456
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1457
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1458
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1459
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1460
      /* Return from a method */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1461
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1462
      CASE(_areturn):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1463
      CASE(_ireturn):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1464
      CASE(_freturn):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1465
      {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1466
          // Allow a safepoint before returning to frame manager.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1467
          SAFEPOINT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1468
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1469
          goto handle_return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1470
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1471
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1472
      CASE(_lreturn):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1473
      CASE(_dreturn):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1474
      {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1475
          // Allow a safepoint before returning to frame manager.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1476
          SAFEPOINT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1477
          goto handle_return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1478
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1479
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1480
      CASE(_return_register_finalizer): {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1481
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1482
          oop rcvr = LOCALS_OBJECT(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1483
          if (rcvr->klass()->klass_part()->has_finalizer()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1484
            CALL_VM(InterpreterRuntime::register_finalizer(THREAD, rcvr), handle_exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1485
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1486
          goto handle_return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1487
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1488
      CASE(_return): {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1489
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1490
          // Allow a safepoint before returning to frame manager.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1491
          SAFEPOINT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1492
          goto handle_return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1493
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1494
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1495
      /* Array access byte-codes */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1496
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1497
      /* Every array access byte-code starts out like this */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1498
//        arrayOopDesc* arrObj = (arrayOopDesc*)STACK_OBJECT(arrayOff);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1499
#define ARRAY_INTRO(arrayOff)                                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1500
      arrayOop arrObj = (arrayOop)STACK_OBJECT(arrayOff);                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1501
      jint     index  = STACK_INT(arrayOff + 1);                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1502
      char message[jintAsStringSize];                                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1503
      CHECK_NULL(arrObj);                                                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1504
      if ((uint32_t)index >= (uint32_t)arrObj->length()) {                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1505
          sprintf(message, "%d", index);                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1506
          VM_JAVA_ERROR(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1507
                        message);                                              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1508
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1509
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1510
      /* 32-bit loads. These handle conversion from < 32-bit types */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1511
#define ARRAY_LOADTO32(T, T2, format, stackRes, extra)                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1512
      {                                                                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1513
          ARRAY_INTRO(-2);                                                            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1514
          extra;                                                                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1515
          SET_ ## stackRes(*(T2 *)(((address) arrObj->base(T)) + index * sizeof(T2)), \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1516
                           -2);                                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1517
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, -1);                                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1518
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1519
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1520
      /* 64-bit loads */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1521
#define ARRAY_LOADTO64(T,T2, stackRes, extra)                                              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1522
      {                                                                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1523
          ARRAY_INTRO(-2);                                                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1524
          SET_ ## stackRes(*(T2 *)(((address) arrObj->base(T)) + index * sizeof(T2)), -1); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1525
          extra;                                                                           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1526
          UPDATE_PC_AND_CONTINUE(1);                                            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1527
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1528
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1529
      CASE(_iaload):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1530
          ARRAY_LOADTO32(T_INT, jint,   "%d",   STACK_INT, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1531
      CASE(_faload):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1532
          ARRAY_LOADTO32(T_FLOAT, jfloat, "%f",   STACK_FLOAT, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1533
      CASE(_aaload):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1534
          ARRAY_LOADTO32(T_OBJECT, oop,   INTPTR_FORMAT, STACK_OBJECT, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1535
      CASE(_baload):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1536
          ARRAY_LOADTO32(T_BYTE, jbyte,  "%d",   STACK_INT, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1537
      CASE(_caload):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1538
          ARRAY_LOADTO32(T_CHAR,  jchar, "%d",   STACK_INT, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1539
      CASE(_saload):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1540
          ARRAY_LOADTO32(T_SHORT, jshort, "%d",   STACK_INT, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1541
      CASE(_laload):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1542
          ARRAY_LOADTO64(T_LONG, jlong, STACK_LONG, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1543
      CASE(_daload):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1544
          ARRAY_LOADTO64(T_DOUBLE, jdouble, STACK_DOUBLE, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1545
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1546
      /* 32-bit stores. These handle conversion to < 32-bit types */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1547
#define ARRAY_STOREFROM32(T, T2, format, stackSrc, extra)                            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1548
      {                                                                              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1549
          ARRAY_INTRO(-3);                                                           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1550
          extra;                                                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1551
          *(T2 *)(((address) arrObj->base(T)) + index * sizeof(T2)) = stackSrc( -1); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1552
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, -3);                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1553
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1554
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1555
      /* 64-bit stores */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1556
#define ARRAY_STOREFROM64(T, T2, stackSrc, extra)                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1557
      {                                                                              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1558
          ARRAY_INTRO(-4);                                                           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1559
          extra;                                                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1560
          *(T2 *)(((address) arrObj->base(T)) + index * sizeof(T2)) = stackSrc( -1); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1561
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, -4);                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1562
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1563
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1564
      CASE(_iastore):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1565
          ARRAY_STOREFROM32(T_INT, jint,   "%d",   STACK_INT, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1566
      CASE(_fastore):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1567
          ARRAY_STOREFROM32(T_FLOAT, jfloat, "%f",   STACK_FLOAT, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1568
      /*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1569
       * This one looks different because of the assignability check
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1570
       */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1571
      CASE(_aastore): {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1572
          oop rhsObject = STACK_OBJECT(-1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1573
          ARRAY_INTRO( -3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1574
          // arrObj, index are set
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1575
          if (rhsObject != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1576
            /* Check assignability of rhsObject into arrObj */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1577
            klassOop rhsKlassOop = rhsObject->klass(); // EBX (subclass)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1578
            assert(arrObj->klass()->klass()->klass_part()->oop_is_objArrayKlass(), "Ack not an objArrayKlass");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1579
            klassOop elemKlassOop = ((objArrayKlass*) arrObj->klass()->klass_part())->element_klass(); // superklass EAX
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1580
            //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1581
            // Check for compatibilty. This check must not GC!!
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1582
            // Seems way more expensive now that we must dispatch
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1583
            //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1584
            if (rhsKlassOop != elemKlassOop && !rhsKlassOop->klass_part()->is_subtype_of(elemKlassOop)) { // ebx->is...
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1585
              VM_JAVA_ERROR(vmSymbols::java_lang_ArrayStoreException(), "");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1586
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1587
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1588
          oop* elem_loc = (oop*)(((address) arrObj->base(T_OBJECT)) + index * sizeof(oop));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1589
          // *(oop*)(((address) arrObj->base(T_OBJECT)) + index * sizeof(oop)) = rhsObject;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1590
          *elem_loc = rhsObject;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1591
          // Mark the card
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1592
          OrderAccess::release_store(&BYTE_MAP_BASE[(uintptr_t)elem_loc >> CardTableModRefBS::card_shift], 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1593
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, -3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1594
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1595
      CASE(_bastore):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1596
          ARRAY_STOREFROM32(T_BYTE, jbyte,  "%d",   STACK_INT, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1597
      CASE(_castore):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1598
          ARRAY_STOREFROM32(T_CHAR, jchar,  "%d",   STACK_INT, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1599
      CASE(_sastore):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1600
          ARRAY_STOREFROM32(T_SHORT, jshort, "%d",   STACK_INT, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1601
      CASE(_lastore):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1602
          ARRAY_STOREFROM64(T_LONG, jlong, STACK_LONG, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1603
      CASE(_dastore):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1604
          ARRAY_STOREFROM64(T_DOUBLE, jdouble, STACK_DOUBLE, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1605
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1606
      CASE(_arraylength):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1607
      {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1608
          arrayOop ary = (arrayOop) STACK_OBJECT(-1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1609
          CHECK_NULL(ary);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1610
          SET_STACK_INT(ary->length(), -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1611
          UPDATE_PC_AND_CONTINUE(1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1612
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1613
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1614
      /* monitorenter and monitorexit for locking/unlocking an object */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1615
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1616
      CASE(_monitorenter): {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1617
        oop lockee = STACK_OBJECT(-1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1618
        // derefing's lockee ought to provoke implicit null check
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1619
        CHECK_NULL(lockee);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1620
        // find a free monitor or one already allocated for this object
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1621
        // if we find a matching object then we need a new monitor
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1622
        // since this is recursive enter
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1623
        BasicObjectLock* limit = istate->monitor_base();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1624
        BasicObjectLock* most_recent = (BasicObjectLock*) istate->stack_base();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1625
        BasicObjectLock* entry = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1626
        while (most_recent != limit ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1627
          if (most_recent->obj() == NULL) entry = most_recent;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1628
          else if (most_recent->obj() == lockee) break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1629
          most_recent++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1630
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1631
        if (entry != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1632
          entry->set_obj(lockee);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1633
          markOop displaced = lockee->mark()->set_unlocked();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1634
          entry->lock()->set_displaced_header(displaced);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1635
          if (Atomic::cmpxchg_ptr(entry, lockee->mark_addr(), displaced) != displaced) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1636
            // Is it simple recursive case?
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1637
            if (THREAD->is_lock_owned((address) displaced->clear_lock_bits())) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1638
              entry->lock()->set_displaced_header(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1639
            } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1640
              CALL_VM(InterpreterRuntime::monitorenter(THREAD, entry), handle_exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1641
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1642
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1643
          UPDATE_PC_AND_TOS_AND_CONTINUE(1, -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1644
        } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1645
          istate->set_msg(more_monitors);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1646
          UPDATE_PC_AND_RETURN(0); // Re-execute
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1647
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1648
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1649
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1650
      CASE(_monitorexit): {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1651
        oop lockee = STACK_OBJECT(-1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1652
        CHECK_NULL(lockee);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1653
        // derefing's lockee ought to provoke implicit null check
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1654
        // find our monitor slot
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1655
        BasicObjectLock* limit = istate->monitor_base();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1656
        BasicObjectLock* most_recent = (BasicObjectLock*) istate->stack_base();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1657
        while (most_recent != limit ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1658
          if ((most_recent)->obj() == lockee) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1659
            BasicLock* lock = most_recent->lock();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1660
            markOop header = lock->displaced_header();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1661
            most_recent->set_obj(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1662
            // If it isn't recursive we either must swap old header or call the runtime
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1663
            if (header != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1664
              if (Atomic::cmpxchg_ptr(header, lockee->mark_addr(), lock) != lock) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1665
                // restore object for the slow case
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1666
                most_recent->set_obj(lockee);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1667
                CALL_VM(InterpreterRuntime::monitorexit(THREAD, most_recent), handle_exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1668
              }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1669
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1670
            UPDATE_PC_AND_TOS_AND_CONTINUE(1, -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1671
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1672
          most_recent++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1673
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1674
        // Need to throw illegal monitor state exception
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1675
        CALL_VM(InterpreterRuntime::throw_illegal_monitor_state_exception(THREAD), handle_exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1676
        // Should never reach here...
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1677
        assert(false, "Should have thrown illegal monitor exception");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1678
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1679
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1680
      /* All of the non-quick opcodes. */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1681
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1682
      /* -Set clobbersCpIndex true if the quickened opcode clobbers the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1683
       *  constant pool index in the instruction.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1684
       */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1685
      CASE(_getfield):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1686
      CASE(_getstatic):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1687
        {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1688
          u2 index;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1689
          ConstantPoolCacheEntry* cache;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1690
          index = Bytes::get_native_u2(pc+1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1691
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1692
          // QQQ Need to make this as inlined as possible. Probably need to
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1693
          // split all the bytecode cases out so c++ compiler has a chance
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1694
          // for constant prop to fold everything possible away.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1695
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1696
          cache = cp->entry_at(index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1697
          if (!cache->is_resolved((Bytecodes::Code)opcode)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1698
            CALL_VM(InterpreterRuntime::resolve_get_put(THREAD, (Bytecodes::Code)opcode),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1699
                    handle_exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1700
            cache = cp->entry_at(index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1701
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1702
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1703
#ifdef VM_JVMTI
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1704
          if (_jvmti_interp_events) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1705
            int *count_addr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1706
            oop obj;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1707
            // Check to see if a field modification watch has been set
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1708
            // before we take the time to call into the VM.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1709
            count_addr = (int *)JvmtiExport::get_field_access_count_addr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1710
            if ( *count_addr > 0 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1711
              if ((Bytecodes::Code)opcode == Bytecodes::_getstatic) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1712
                obj = (oop)NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1713
              } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1714
                obj = (oop) STACK_OBJECT(-1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1715
              }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1716
              CALL_VM(InterpreterRuntime::post_field_access(THREAD,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1717
                                          obj,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1718
                                          cache),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1719
                                          handle_exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1720
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1721
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1722
#endif /* VM_JVMTI */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1723
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1724
          oop obj;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1725
          if ((Bytecodes::Code)opcode == Bytecodes::_getstatic) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1726
            obj = (oop) cache->f1();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1727
            MORE_STACK(1);  // Assume single slot push
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1728
          } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1729
            obj = (oop) STACK_OBJECT(-1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1730
            CHECK_NULL(obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1731
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1732
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1733
          //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1734
          // Now store the result on the stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1735
          //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1736
          TosState tos_type = cache->flag_state();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1737
          int field_offset = cache->f2();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1738
          if (cache->is_volatile()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1739
            if (tos_type == atos) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1740
              SET_STACK_OBJECT(obj->obj_field_acquire(field_offset), -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1741
            } else if (tos_type == itos) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1742
              SET_STACK_INT(obj->int_field_acquire(field_offset), -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1743
            } else if (tos_type == ltos) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1744
              SET_STACK_LONG(obj->long_field_acquire(field_offset), 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1745
              MORE_STACK(1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1746
            } else if (tos_type == btos) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1747
              SET_STACK_INT(obj->byte_field_acquire(field_offset), -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1748
            } else if (tos_type == ctos) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1749
              SET_STACK_INT(obj->char_field_acquire(field_offset), -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1750
            } else if (tos_type == stos) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1751
              SET_STACK_INT(obj->short_field_acquire(field_offset), -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1752
            } else if (tos_type == ftos) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1753
              SET_STACK_FLOAT(obj->float_field_acquire(field_offset), -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1754
            } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1755
              SET_STACK_DOUBLE(obj->double_field_acquire(field_offset), 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1756
              MORE_STACK(1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1757
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1758
          } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1759
            if (tos_type == atos) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1760
              SET_STACK_OBJECT(obj->obj_field(field_offset), -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1761
            } else if (tos_type == itos) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1762
              SET_STACK_INT(obj->int_field(field_offset), -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1763
            } else if (tos_type == ltos) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1764
              SET_STACK_LONG(obj->long_field(field_offset), 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1765
              MORE_STACK(1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1766
            } else if (tos_type == btos) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1767
              SET_STACK_INT(obj->byte_field(field_offset), -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1768
            } else if (tos_type == ctos) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1769
              SET_STACK_INT(obj->char_field(field_offset), -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1770
            } else if (tos_type == stos) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1771
              SET_STACK_INT(obj->short_field(field_offset), -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1772
            } else if (tos_type == ftos) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1773
              SET_STACK_FLOAT(obj->float_field(field_offset), -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1774
            } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1775
              SET_STACK_DOUBLE(obj->double_field(field_offset), 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1776
              MORE_STACK(1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1777
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1778
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1779
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1780
          UPDATE_PC_AND_CONTINUE(3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1781
         }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1782
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1783
      CASE(_putfield):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1784
      CASE(_putstatic):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1785
        {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1786
          u2 index = Bytes::get_native_u2(pc+1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1787
          ConstantPoolCacheEntry* cache = cp->entry_at(index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1788
          if (!cache->is_resolved((Bytecodes::Code)opcode)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1789
            CALL_VM(InterpreterRuntime::resolve_get_put(THREAD, (Bytecodes::Code)opcode),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1790
                    handle_exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1791
            cache = cp->entry_at(index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1792
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1793
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1794
#ifdef VM_JVMTI
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1795
          if (_jvmti_interp_events) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1796
            int *count_addr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1797
            oop obj;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1798
            // Check to see if a field modification watch has been set
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1799
            // before we take the time to call into the VM.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1800
            count_addr = (int *)JvmtiExport::get_field_modification_count_addr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1801
            if ( *count_addr > 0 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1802
              if ((Bytecodes::Code)opcode == Bytecodes::_putstatic) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1803
                obj = (oop)NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1804
              }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1805
              else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1806
                if (cache->is_long() || cache->is_double()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1807
                  obj = (oop) STACK_OBJECT(-3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1808
                } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1809
                  obj = (oop) STACK_OBJECT(-2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1810
                }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1811
              }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1812
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1813
              CALL_VM(InterpreterRuntime::post_field_modification(THREAD,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1814
                                          obj,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1815
                                          cache,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1816
                                          (jvalue *)STACK_SLOT(-1)),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1817
                                          handle_exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1818
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1819
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1820
#endif /* VM_JVMTI */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1821
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1822
          // QQQ Need to make this as inlined as possible. Probably need to split all the bytecode cases
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1823
          // out so c++ compiler has a chance for constant prop to fold everything possible away.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1824
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1825
          oop obj;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1826
          int count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1827
          TosState tos_type = cache->flag_state();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1828
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1829
          count = -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1830
          if (tos_type == ltos || tos_type == dtos) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1831
            --count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1832
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1833
          if ((Bytecodes::Code)opcode == Bytecodes::_putstatic) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1834
            obj = (oop) cache->f1();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1835
          } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1836
            --count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1837
            obj = (oop) STACK_OBJECT(count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1838
            CHECK_NULL(obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1839
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1840
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1841
          //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1842
          // Now store the result
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1843
          //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1844
          int field_offset = cache->f2();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1845
          if (cache->is_volatile()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1846
            if (tos_type == itos) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1847
              obj->release_int_field_put(field_offset, STACK_INT(-1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1848
            } else if (tos_type == atos) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1849
              obj->release_obj_field_put(field_offset, STACK_OBJECT(-1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1850
              OrderAccess::release_store(&BYTE_MAP_BASE[(uintptr_t)obj >> CardTableModRefBS::card_shift], 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1851
            } else if (tos_type == btos) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1852
              obj->release_byte_field_put(field_offset, STACK_INT(-1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1853
            } else if (tos_type == ltos) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1854
              obj->release_long_field_put(field_offset, STACK_LONG(-1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1855
            } else if (tos_type == ctos) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1856
              obj->release_char_field_put(field_offset, STACK_INT(-1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1857
            } else if (tos_type == stos) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1858
              obj->release_short_field_put(field_offset, STACK_INT(-1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1859
            } else if (tos_type == ftos) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1860
              obj->release_float_field_put(field_offset, STACK_FLOAT(-1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1861
            } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1862
              obj->release_double_field_put(field_offset, STACK_DOUBLE(-1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1863
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1864
            OrderAccess::storeload();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1865
          } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1866
            if (tos_type == itos) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1867
              obj->int_field_put(field_offset, STACK_INT(-1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1868
            } else if (tos_type == atos) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1869
              obj->obj_field_put(field_offset, STACK_OBJECT(-1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1870
              OrderAccess::release_store(&BYTE_MAP_BASE[(uintptr_t)obj >> CardTableModRefBS::card_shift], 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1871
            } else if (tos_type == btos) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1872
              obj->byte_field_put(field_offset, STACK_INT(-1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1873
            } else if (tos_type == ltos) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1874
              obj->long_field_put(field_offset, STACK_LONG(-1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1875
            } else if (tos_type == ctos) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1876
              obj->char_field_put(field_offset, STACK_INT(-1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1877
            } else if (tos_type == stos) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1878
              obj->short_field_put(field_offset, STACK_INT(-1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1879
            } else if (tos_type == ftos) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1880
              obj->float_field_put(field_offset, STACK_FLOAT(-1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1881
            } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1882
              obj->double_field_put(field_offset, STACK_DOUBLE(-1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1883
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1884
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1885
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1886
          UPDATE_PC_AND_TOS_AND_CONTINUE(3, count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1887
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1888
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1889
      CASE(_new): {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1890
        u2 index = Bytes::get_Java_u2(pc+1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1891
        constantPoolOop constants = istate->method()->constants();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1892
        if (!constants->tag_at(index).is_unresolved_klass()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1893
          // Make sure klass is initialized and doesn't have a finalizer
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1894
          oop entry = (klassOop) *constants->obj_at_addr(index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1895
          assert(entry->is_klass(), "Should be resolved klass");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1896
          klassOop k_entry = (klassOop) entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1897
          assert(k_entry->klass_part()->oop_is_instance(), "Should be instanceKlass");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1898
          instanceKlass* ik = (instanceKlass*) k_entry->klass_part();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1899
          if ( ik->is_initialized() && ik->can_be_fastpath_allocated() ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1900
            size_t obj_size = ik->size_helper();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1901
            oop result = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1902
            // If the TLAB isn't pre-zeroed then we'll have to do it
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1903
            bool need_zero = !ZeroTLAB;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1904
            if (UseTLAB) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1905
              result = (oop) THREAD->tlab().allocate(obj_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1906
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1907
            if (result == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1908
              need_zero = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1909
              // Try allocate in shared eden
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1910
        retry:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1911
              HeapWord* compare_to = *Universe::heap()->top_addr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1912
              HeapWord* new_top = compare_to + obj_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1913
              if (new_top <= *Universe::heap()->end_addr()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1914
                if (Atomic::cmpxchg_ptr(new_top, Universe::heap()->top_addr(), compare_to) != compare_to) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1915
                  goto retry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1916
                }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1917
                result = (oop) compare_to;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1918
              }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1919
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1920
            if (result != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1921
              // Initialize object (if nonzero size and need) and then the header
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1922
              if (need_zero ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1923
                HeapWord* to_zero = (HeapWord*) result + sizeof(oopDesc) / oopSize;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1924
                obj_size -= sizeof(oopDesc) / oopSize;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1925
                if (obj_size > 0 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1926
                  memset(to_zero, 0, obj_size * HeapWordSize);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1927
                }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1928
              }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1929
              if (UseBiasedLocking) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1930
                result->set_mark(ik->prototype_header());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1931
              } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1932
                result->set_mark(markOopDesc::prototype());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1933
              }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1934
              result->set_klass(k_entry);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1935
              SET_STACK_OBJECT(result, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1936
              UPDATE_PC_AND_TOS_AND_CONTINUE(3, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1937
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1938
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1939
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1940
        // Slow case allocation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1941
        CALL_VM(InterpreterRuntime::_new(THREAD, METHOD->constants(), index),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1942
                handle_exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1943
        SET_STACK_OBJECT(THREAD->vm_result(), 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1944
        THREAD->set_vm_result(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1945
        UPDATE_PC_AND_TOS_AND_CONTINUE(3, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1946
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1947
      CASE(_anewarray): {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1948
        u2 index = Bytes::get_Java_u2(pc+1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1949
        jint size = STACK_INT(-1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1950
        CALL_VM(InterpreterRuntime::anewarray(THREAD, METHOD->constants(), index, size),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1951
                handle_exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1952
        SET_STACK_OBJECT(THREAD->vm_result(), -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1953
        THREAD->set_vm_result(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1954
        UPDATE_PC_AND_CONTINUE(3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1955
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1956
      CASE(_multianewarray): {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1957
        jint dims = *(pc+3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1958
        jint size = STACK_INT(-1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1959
        // stack grows down, dimensions are up!
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1960
        jint *dimarray =
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1961
                   (jint*)&topOfStack[dims * Interpreter::stackElementWords()+
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1962
                                      Interpreter::stackElementWords()-1];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1963
        //adjust pointer to start of stack element
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1964
        CALL_VM(InterpreterRuntime::multianewarray(THREAD, dimarray),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1965
                handle_exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1966
        SET_STACK_OBJECT(THREAD->vm_result(), -dims);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1967
        THREAD->set_vm_result(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1968
        UPDATE_PC_AND_TOS_AND_CONTINUE(4, -(dims-1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1969
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1970
      CASE(_checkcast):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1971
          if (STACK_OBJECT(-1) != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1972
            u2 index = Bytes::get_Java_u2(pc+1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1973
            if (ProfileInterpreter) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1974
              // needs Profile_checkcast QQQ
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1975
              ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1976
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1977
            // Constant pool may have actual klass or unresolved klass. If it is
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1978
            // unresolved we must resolve it
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1979
            if (METHOD->constants()->tag_at(index).is_unresolved_klass()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1980
              CALL_VM(InterpreterRuntime::quicken_io_cc(THREAD), handle_exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1981
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1982
            klassOop klassOf = (klassOop) *(METHOD->constants()->obj_at_addr(index));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1983
            klassOop objKlassOop = STACK_OBJECT(-1)->klass(); //ebx
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1984
            //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1985
            // Check for compatibilty. This check must not GC!!
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1986
            // Seems way more expensive now that we must dispatch
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1987
            //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1988
            if (objKlassOop != klassOf &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1989
                !objKlassOop->klass_part()->is_subtype_of(klassOf)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1990
              ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1991
              const char* objName = Klass::cast(objKlassOop)->external_name();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1992
              const char* klassName = Klass::cast(klassOf)->external_name();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1993
              char* message = SharedRuntime::generate_class_cast_message(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1994
                objName, klassName);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1995
              VM_JAVA_ERROR(vmSymbols::java_lang_ClassCastException(), message);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1996
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1997
          } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1998
            if (UncommonNullCast) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1999
//              istate->method()->set_null_cast_seen();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2000
// [RGV] Not sure what to do here!
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2001
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2002
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2003
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2004
          UPDATE_PC_AND_CONTINUE(3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2005
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2006
      CASE(_instanceof):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2007
          if (STACK_OBJECT(-1) == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2008
            SET_STACK_INT(0, -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2009
          } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2010
            u2 index = Bytes::get_Java_u2(pc+1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2011
            // Constant pool may have actual klass or unresolved klass. If it is
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2012
            // unresolved we must resolve it
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2013
            if (METHOD->constants()->tag_at(index).is_unresolved_klass()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2014
              CALL_VM(InterpreterRuntime::quicken_io_cc(THREAD), handle_exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2015
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2016
            klassOop klassOf = (klassOop) *(METHOD->constants()->obj_at_addr(index));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2017
            klassOop objKlassOop = STACK_OBJECT(-1)->klass();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2018
            //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2019
            // Check for compatibilty. This check must not GC!!
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2020
            // Seems way more expensive now that we must dispatch
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2021
            //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2022
            if ( objKlassOop == klassOf || objKlassOop->klass_part()->is_subtype_of(klassOf)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2023
              SET_STACK_INT(1, -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2024
            } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2025
              SET_STACK_INT(0, -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2026
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2027
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2028
          UPDATE_PC_AND_CONTINUE(3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2029
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2030
      CASE(_ldc_w):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2031
      CASE(_ldc):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2032
        {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2033
          u2 index;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2034
          bool wide = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2035
          int incr = 2; // frequent case
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2036
          if (opcode == Bytecodes::_ldc) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2037
            index = pc[1];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2038
          } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2039
            index = Bytes::get_Java_u2(pc+1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2040
            incr = 3;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2041
            wide = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2042
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2043
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2044
          constantPoolOop constants = METHOD->constants();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2045
          switch (constants->tag_at(index).value()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2046
          case JVM_CONSTANT_Integer:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2047
            SET_STACK_INT(constants->int_at(index), 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2048
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2049
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2050
          case JVM_CONSTANT_Float:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2051
            SET_STACK_FLOAT(constants->float_at(index), 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2052
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2053
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2054
          case JVM_CONSTANT_String:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2055
            SET_STACK_OBJECT(constants->resolved_string_at(index), 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2056
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2057
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2058
          case JVM_CONSTANT_Class:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2059
            SET_STACK_OBJECT(constants->resolved_klass_at(index)->klass_part()->java_mirror(), 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2060
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2061
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2062
          case JVM_CONSTANT_UnresolvedString:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2063
          case JVM_CONSTANT_UnresolvedClass:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2064
          case JVM_CONSTANT_UnresolvedClassInError:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2065
            CALL_VM(InterpreterRuntime::ldc(THREAD, wide), handle_exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2066
            SET_STACK_OBJECT(THREAD->vm_result(), 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2067
            THREAD->set_vm_result(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2068
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2069
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2070
#if 0
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2071
          CASE(_fast_igetfield):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2072
          CASE(_fastagetfield):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2073
          CASE(_fast_aload_0):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2074
          CASE(_fast_iaccess_0):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2075
          CASE(__fast_aaccess_0):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2076
          CASE(_fast_linearswitch):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2077
          CASE(_fast_binaryswitch):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2078
            fatal("unsupported fast bytecode");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2079
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2080
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2081
          default:  ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2082
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2083
          UPDATE_PC_AND_TOS_AND_CONTINUE(incr, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2084
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2085
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2086
      CASE(_ldc2_w):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2087
        {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2088
          u2 index = Bytes::get_Java_u2(pc+1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2089
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2090
          constantPoolOop constants = METHOD->constants();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2091
          switch (constants->tag_at(index).value()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2092
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2093
          case JVM_CONSTANT_Long:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2094
             SET_STACK_LONG(constants->long_at(index), 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2095
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2096
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2097
          case JVM_CONSTANT_Double:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2098
             SET_STACK_DOUBLE(constants->double_at(index), 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2099
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2100
          default:  ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2101
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2102
          UPDATE_PC_AND_TOS_AND_CONTINUE(3, 2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2103
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2104
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2105
      CASE(_invokeinterface): {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2106
        u2 index = Bytes::get_native_u2(pc+1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2107
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2108
        // QQQ Need to make this as inlined as possible. Probably need to split all the bytecode cases
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2109
        // out so c++ compiler has a chance for constant prop to fold everything possible away.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2110
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2111
        ConstantPoolCacheEntry* cache = cp->entry_at(index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2112
        if (!cache->is_resolved((Bytecodes::Code)opcode)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2113
          CALL_VM(InterpreterRuntime::resolve_invoke(THREAD, (Bytecodes::Code)opcode),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2114
                  handle_exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2115
          cache = cp->entry_at(index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2116
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2117
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2118
        istate->set_msg(call_method);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2119
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2120
        // Special case of invokeinterface called for virtual method of
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2121
        // java.lang.Object.  See cpCacheOop.cpp for details.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2122
        // This code isn't produced by javac, but could be produced by
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2123
        // another compliant java compiler.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2124
        if (cache->is_methodInterface()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2125
          methodOop callee;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2126
          CHECK_NULL(STACK_OBJECT(-(cache->parameter_size())));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2127
          if (cache->is_vfinal()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2128
            callee = (methodOop) cache->f2();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2129
          } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2130
            // get receiver
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2131
            int parms = cache->parameter_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2132
            // Same comments as invokevirtual apply here
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2133
            instanceKlass* rcvrKlass = (instanceKlass*)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2134
                                 STACK_OBJECT(-parms)->klass()->klass_part();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2135
            callee = (methodOop) rcvrKlass->start_of_vtable()[ cache->f2()];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2136
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2137
          istate->set_callee(callee);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2138
          istate->set_callee_entry_point(callee->from_interpreted_entry());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2139
#ifdef VM_JVMTI
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2140
          if (JvmtiExport::can_post_interpreter_events() && THREAD->is_interp_only_mode()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2141
            istate->set_callee_entry_point(callee->interpreter_entry());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2142
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2143
#endif /* VM_JVMTI */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2144
          istate->set_bcp_advance(5);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2145
          UPDATE_PC_AND_RETURN(0); // I'll be back...
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2146
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2147
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2148
        // this could definitely be cleaned up QQQ
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2149
        methodOop callee;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2150
        klassOop iclass = (klassOop)cache->f1();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2151
        // instanceKlass* interface = (instanceKlass*) iclass->klass_part();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2152
        // get receiver
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2153
        int parms = cache->parameter_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2154
        oop rcvr = STACK_OBJECT(-parms);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2155
        CHECK_NULL(rcvr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2156
        instanceKlass* int2 = (instanceKlass*) rcvr->klass()->klass_part();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2157
        itableOffsetEntry* ki = (itableOffsetEntry*) int2->start_of_itable();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2158
        int i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2159
        for ( i = 0 ; i < int2->itable_length() ; i++, ki++ ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2160
          if (ki->interface_klass() == iclass) break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2161
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2162
        // If the interface isn't found, this class doesn't implement this
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2163
        // interface.  The link resolver checks this but only for the first
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2164
        // time this interface is called.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2165
        if (i == int2->itable_length()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2166
          VM_JAVA_ERROR(vmSymbols::java_lang_IncompatibleClassChangeError(), "");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2167
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2168
        int mindex = cache->f2();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2169
        itableMethodEntry* im = ki->first_method_entry(rcvr->klass());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2170
        callee = im[mindex].method();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2171
        if (callee == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2172
          VM_JAVA_ERROR(vmSymbols::java_lang_AbstractMethodError(), "");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2173
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2174
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2175
        istate->set_callee(callee);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2176
        istate->set_callee_entry_point(callee->from_interpreted_entry());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2177
#ifdef VM_JVMTI
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2178
        if (JvmtiExport::can_post_interpreter_events() && THREAD->is_interp_only_mode()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2179
          istate->set_callee_entry_point(callee->interpreter_entry());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2180
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2181
#endif /* VM_JVMTI */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2182
        istate->set_bcp_advance(5);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2183
        UPDATE_PC_AND_RETURN(0); // I'll be back...
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2184
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2185
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2186
      CASE(_invokevirtual):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2187
      CASE(_invokespecial):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2188
      CASE(_invokestatic): {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2189
        u2 index = Bytes::get_native_u2(pc+1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2190
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2191
        ConstantPoolCacheEntry* cache = cp->entry_at(index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2192
        // QQQ Need to make this as inlined as possible. Probably need to split all the bytecode cases
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2193
        // out so c++ compiler has a chance for constant prop to fold everything possible away.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2194
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2195
        if (!cache->is_resolved((Bytecodes::Code)opcode)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2196
          CALL_VM(InterpreterRuntime::resolve_invoke(THREAD, (Bytecodes::Code)opcode),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2197
                  handle_exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2198
          cache = cp->entry_at(index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2199
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2200
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2201
        istate->set_msg(call_method);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2202
        {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2203
          methodOop callee;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2204
          if ((Bytecodes::Code)opcode == Bytecodes::_invokevirtual) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2205
            CHECK_NULL(STACK_OBJECT(-(cache->parameter_size())));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2206
            if (cache->is_vfinal()) callee = (methodOop) cache->f2();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2207
            else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2208
              // get receiver
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2209
              int parms = cache->parameter_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2210
              // this works but needs a resourcemark and seems to create a vtable on every call:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2211
              // methodOop callee = rcvr->klass()->klass_part()->vtable()->method_at(cache->f2());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2212
              //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2213
              // this fails with an assert
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2214
              // instanceKlass* rcvrKlass = instanceKlass::cast(STACK_OBJECT(-parms)->klass());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2215
              // but this works
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2216
              instanceKlass* rcvrKlass = (instanceKlass*) STACK_OBJECT(-parms)->klass()->klass_part();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2217
              /*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2218
                Executing this code in java.lang.String:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2219
                    public String(char value[]) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2220
                          this.count = value.length;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2221
                          this.value = (char[])value.clone();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2222
                     }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2223
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2224
                 a find on rcvr->klass()->klass_part() reports:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2225
                 {type array char}{type array class}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2226
                  - klass: {other class}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2227
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2228
                  but using instanceKlass::cast(STACK_OBJECT(-parms)->klass()) causes in assertion failure
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2229
                  because rcvr->klass()->klass_part()->oop_is_instance() == 0
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2230
                  However it seems to have a vtable in the right location. Huh?
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2231
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2232
              */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2233
              callee = (methodOop) rcvrKlass->start_of_vtable()[ cache->f2()];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2234
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2235
          } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2236
            if ((Bytecodes::Code)opcode == Bytecodes::_invokespecial) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2237
              CHECK_NULL(STACK_OBJECT(-(cache->parameter_size())));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2238
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2239
            callee = (methodOop) cache->f1();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2240
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2241
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2242
          istate->set_callee(callee);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2243
          istate->set_callee_entry_point(callee->from_interpreted_entry());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2244
#ifdef VM_JVMTI
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2245
          if (JvmtiExport::can_post_interpreter_events() && THREAD->is_interp_only_mode()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2246
            istate->set_callee_entry_point(callee->interpreter_entry());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2247
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2248
#endif /* VM_JVMTI */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2249
          istate->set_bcp_advance(3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2250
          UPDATE_PC_AND_RETURN(0); // I'll be back...
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2251
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2252
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2253
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2254
      /* Allocate memory for a new java object. */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2255
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2256
      CASE(_newarray): {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2257
        BasicType atype = (BasicType) *(pc+1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2258
        jint size = STACK_INT(-1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2259
        CALL_VM(InterpreterRuntime::newarray(THREAD, atype, size),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2260
                handle_exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2261
        SET_STACK_OBJECT(THREAD->vm_result(), -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2262
        THREAD->set_vm_result(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2263
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2264
        UPDATE_PC_AND_CONTINUE(2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2265
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2266
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2267
      /* Throw an exception. */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2268
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2269
      CASE(_athrow): {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2270
          oop except_oop = STACK_OBJECT(-1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2271
          CHECK_NULL(except_oop);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2272
          // set pending_exception so we use common code
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2273
          THREAD->set_pending_exception(except_oop, NULL, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2274
          goto handle_exception;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2275
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2276
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2277
      /* goto and jsr. They are exactly the same except jsr pushes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2278
       * the address of the next instruction first.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2279
       */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2280
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2281
      CASE(_jsr): {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2282
          /* push bytecode index on stack */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2283
          SET_STACK_ADDR(((address)pc - (intptr_t)(istate->method()->code_base()) + 3), 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2284
          MORE_STACK(1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2285
          /* FALL THROUGH */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2286
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2287
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2288
      CASE(_goto):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2289
      {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2290
          int16_t offset = (int16_t)Bytes::get_Java_u2(pc + 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2291
          address branch_pc = pc;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2292
          UPDATE_PC(offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2293
          DO_BACKEDGE_CHECKS(offset, branch_pc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2294
          CONTINUE;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2295
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2296
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2297
      CASE(_jsr_w): {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2298
          /* push return address on the stack */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2299
          SET_STACK_ADDR(((address)pc - (intptr_t)(istate->method()->code_base()) + 5), 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2300
          MORE_STACK(1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2301
          /* FALL THROUGH */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2302
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2303
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2304
      CASE(_goto_w):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2305
      {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2306
          int32_t offset = Bytes::get_Java_u4(pc + 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2307
          address branch_pc = pc;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2308
          UPDATE_PC(offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2309
          DO_BACKEDGE_CHECKS(offset, branch_pc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2310
          CONTINUE;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2311
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2312
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2313
      /* return from a jsr or jsr_w */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2314
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2315
      CASE(_ret): {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2316
          pc = istate->method()->code_base() + (intptr_t)(LOCALS_ADDR(pc[1]));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2317
          UPDATE_PC_AND_CONTINUE(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2318
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2319
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2320
      /* debugger breakpoint */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2321
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2322
      CASE(_breakpoint): {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2323
          Bytecodes::Code original_bytecode;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2324
          DECACHE_STATE();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2325
          SET_LAST_JAVA_FRAME();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2326
          original_bytecode = InterpreterRuntime::get_original_bytecode_at(THREAD,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2327
                              METHOD, pc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2328
          RESET_LAST_JAVA_FRAME();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2329
          CACHE_STATE();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2330
          if (THREAD->has_pending_exception()) goto handle_exception;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2331
            CALL_VM(InterpreterRuntime::_breakpoint(THREAD, METHOD, pc),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2332
                                                    handle_exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2333
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2334
          opcode = (jubyte)original_bytecode;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2335
          goto opcode_switch;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2336
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2337
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2338
      DEFAULT:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2339
          fatal2("\t*** Unimplemented opcode: %d = %s\n",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2340
                 opcode, Bytecodes::name((Bytecodes::Code)opcode));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2341
          goto finish;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2342
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2343
      } /* switch(opc) */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2344
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2345
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2346
#ifdef USELABELS
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2347
    check_for_exception:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2348
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2349
    {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2350
      if (!THREAD->has_pending_exception()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2351
        CONTINUE;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2352
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2353
      /* We will be gcsafe soon, so flush our state. */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2354
      DECACHE_PC();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2355
      goto handle_exception;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2356
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2357
  do_continue: ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2358
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2359
  } /* while (1) interpreter loop */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2360
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2361
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2362
  // An exception exists in the thread state see whether this activation can handle it
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2363
  handle_exception: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2364
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2365
    HandleMarkCleaner __hmc(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2366
    Handle except_oop(THREAD, THREAD->pending_exception());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2367
    // Prevent any subsequent HandleMarkCleaner in the VM
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2368
    // from freeing the except_oop handle.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2369
    HandleMark __hm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2370
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2371
    THREAD->clear_pending_exception();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2372
    assert(except_oop(), "No exception to process");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2373
    intptr_t continuation_bci;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2374
    // expression stack is emptied
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2375
    topOfStack = istate->stack_base() - Interpreter::stackElementWords();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2376
    CALL_VM(continuation_bci = (intptr_t)InterpreterRuntime::exception_handler_for_exception(THREAD, except_oop()),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2377
            handle_exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2378
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2379
    except_oop = (oop) THREAD->vm_result();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2380
    THREAD->set_vm_result(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2381
    if (continuation_bci >= 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2382
      // Place exception on top of stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2383
      SET_STACK_OBJECT(except_oop(), 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2384
      MORE_STACK(1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2385
      pc = METHOD->code_base() + continuation_bci;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2386
      if (TraceExceptions) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2387
        ttyLocker ttyl;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2388
        ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2389
        tty->print_cr("Exception <%s> (" INTPTR_FORMAT ")", except_oop->print_value_string(), except_oop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2390
        tty->print_cr(" thrown in interpreter method <%s>", METHOD->print_value_string());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2391
        tty->print_cr(" at bci %d, continuing at %d for thread " INTPTR_FORMAT,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2392
                      pc - (intptr_t)METHOD->code_base(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2393
                      continuation_bci, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2394
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2395
      // for AbortVMOnException flag
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2396
      NOT_PRODUCT(Exceptions::debug_check_abort(except_oop));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2397
      goto run;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2398
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2399
    if (TraceExceptions) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2400
      ttyLocker ttyl;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2401
      ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2402
      tty->print_cr("Exception <%s> (" INTPTR_FORMAT ")", except_oop->print_value_string(), except_oop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2403
      tty->print_cr(" thrown in interpreter method <%s>", METHOD->print_value_string());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2404
      tty->print_cr(" at bci %d, unwinding for thread " INTPTR_FORMAT,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2405
                    pc  - (intptr_t) METHOD->code_base(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2406
                    THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2407
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2408
    // for AbortVMOnException flag
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2409
    NOT_PRODUCT(Exceptions::debug_check_abort(except_oop));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2410
    // No handler in this activation, unwind and try again
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2411
    THREAD->set_pending_exception(except_oop(), NULL, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2412
    goto handle_return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2413
  }  /* handle_exception: */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2414
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2415
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2416
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2417
  // Return from an interpreter invocation with the result of the interpretation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2418
  // on the top of the Java Stack (or a pending exception)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2419
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2420
handle_Pop_Frame:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2421
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2422
  // We don't really do anything special here except we must be aware
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2423
  // that we can get here without ever locking the method (if sync).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2424
  // Also we skip the notification of the exit.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2425
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2426
  istate->set_msg(popping_frame);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2427
  // Clear pending so while the pop is in process
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2428
  // we don't start another one if a call_vm is done.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2429
  THREAD->clr_pop_frame_pending();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2430
  // Let interpreter (only) see the we're in the process of popping a frame
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2431
  THREAD->set_pop_frame_in_process();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2432
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2433
handle_return:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2434
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2435
    DECACHE_STATE();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2436
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2437
    bool suppress_error = istate->msg() == popping_frame;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2438
    bool suppress_exit_event = THREAD->has_pending_exception() || suppress_error;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2439
    Handle original_exception(THREAD, THREAD->pending_exception());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2440
    Handle illegal_state_oop(THREAD, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2441
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2442
    // We'd like a HandleMark here to prevent any subsequent HandleMarkCleaner
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2443
    // in any following VM entries from freeing our live handles, but illegal_state_oop
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2444
    // isn't really allocated yet and so doesn't become live until later and
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2445
    // in unpredicatable places. Instead we must protect the places where we enter the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2446
    // VM. It would be much simpler (and safer) if we could allocate a real handle with
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2447
    // a NULL oop in it and then overwrite the oop later as needed. This isn't
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2448
    // unfortunately isn't possible.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2449
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2450
    THREAD->clear_pending_exception();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2451
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2452
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2453
    // As far as we are concerned we have returned. If we have a pending exception
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2454
    // that will be returned as this invocation's result. However if we get any
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2455
    // exception(s) while checking monitor state one of those IllegalMonitorStateExceptions
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2456
    // will be our final result (i.e. monitor exception trumps a pending exception).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2457
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2458
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2459
    // If we never locked the method (or really passed the point where we would have),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2460
    // there is no need to unlock it (or look for other monitors), since that
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2461
    // could not have happened.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2462
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2463
    if (THREAD->do_not_unlock()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2464
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2465
      // Never locked, reset the flag now because obviously any caller must
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2466
      // have passed their point of locking for us to have gotten here.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2467
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2468
      THREAD->clr_do_not_unlock();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2469
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2470
      // At this point we consider that we have returned. We now check that the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2471
      // locks were properly block structured. If we find that they were not
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2472
      // used properly we will return with an illegal monitor exception.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2473
      // The exception is checked by the caller not the callee since this
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2474
      // checking is considered to be part of the invocation and therefore
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2475
      // in the callers scope (JVM spec 8.13).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2476
      //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2477
      // Another weird thing to watch for is if the method was locked
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2478
      // recursively and then not exited properly. This means we must
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2479
      // examine all the entries in reverse time(and stack) order and
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2480
      // unlock as we find them. If we find the method monitor before
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2481
      // we are at the initial entry then we should throw an exception.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2482
      // It is not clear the template based interpreter does this
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2483
      // correctly
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2484
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2485
      BasicObjectLock* base = istate->monitor_base();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2486
      BasicObjectLock* end = (BasicObjectLock*) istate->stack_base();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2487
      bool method_unlock_needed = METHOD->is_synchronized();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2488
      // We know the initial monitor was used for the method don't check that
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2489
      // slot in the loop
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2490
      if (method_unlock_needed) base--;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2491
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2492
      // Check all the monitors to see they are unlocked. Install exception if found to be locked.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2493
      while (end < base) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2494
        oop lockee = end->obj();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2495
        if (lockee != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2496
          BasicLock* lock = end->lock();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2497
          markOop header = lock->displaced_header();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2498
          end->set_obj(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2499
          // If it isn't recursive we either must swap old header or call the runtime
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2500
          if (header != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2501
            if (Atomic::cmpxchg_ptr(header, lockee->mark_addr(), lock) != lock) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2502
              // restore object for the slow case
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2503
              end->set_obj(lockee);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2504
              {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2505
                // Prevent any HandleMarkCleaner from freeing our live handles
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2506
                HandleMark __hm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2507
                CALL_VM_NOCHECK(InterpreterRuntime::monitorexit(THREAD, end));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2508
              }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2509
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2510
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2511
          // One error is plenty
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2512
          if (illegal_state_oop() == NULL && !suppress_error) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2513
            {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2514
              // Prevent any HandleMarkCleaner from freeing our live handles
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2515
              HandleMark __hm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2516
              CALL_VM_NOCHECK(InterpreterRuntime::throw_illegal_monitor_state_exception(THREAD));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2517
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2518
            assert(THREAD->has_pending_exception(), "Lost our exception!");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2519
            illegal_state_oop = THREAD->pending_exception();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2520
            THREAD->clear_pending_exception();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2521
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2522
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2523
        end++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2524
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2525
      // Unlock the method if needed
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2526
      if (method_unlock_needed) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2527
        if (base->obj() == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2528
          // The method is already unlocked this is not good.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2529
          if (illegal_state_oop() == NULL && !suppress_error) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2530
            {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2531
              // Prevent any HandleMarkCleaner from freeing our live handles
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2532
              HandleMark __hm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2533
              CALL_VM_NOCHECK(InterpreterRuntime::throw_illegal_monitor_state_exception(THREAD));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2534
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2535
            assert(THREAD->has_pending_exception(), "Lost our exception!");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2536
            illegal_state_oop = THREAD->pending_exception();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2537
            THREAD->clear_pending_exception();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2538
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2539
        } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2540
          //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2541
          // The initial monitor is always used for the method
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2542
          // However if that slot is no longer the oop for the method it was unlocked
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2543
          // and reused by something that wasn't unlocked!
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2544
          //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2545
          // deopt can come in with rcvr dead because c2 knows
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2546
          // its value is preserved in the monitor. So we can't use locals[0] at all
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2547
          // and must use first monitor slot.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2548
          //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2549
          oop rcvr = base->obj();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2550
          if (rcvr == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2551
            if (!suppress_error) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2552
              VM_JAVA_ERROR_NO_JUMP(vmSymbols::java_lang_NullPointerException(), "");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2553
              illegal_state_oop = THREAD->pending_exception();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2554
              THREAD->clear_pending_exception();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2555
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2556
          } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2557
            BasicLock* lock = base->lock();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2558
            markOop header = lock->displaced_header();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2559
            base->set_obj(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2560
            // If it isn't recursive we either must swap old header or call the runtime
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2561
            if (header != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2562
              if (Atomic::cmpxchg_ptr(header, rcvr->mark_addr(), lock) != lock) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2563
                // restore object for the slow case
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2564
                base->set_obj(rcvr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2565
                {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2566
                  // Prevent any HandleMarkCleaner from freeing our live handles
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2567
                  HandleMark __hm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2568
                  CALL_VM_NOCHECK(InterpreterRuntime::monitorexit(THREAD, base));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2569
                }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2570
                if (THREAD->has_pending_exception()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2571
                  if (!suppress_error) illegal_state_oop = THREAD->pending_exception();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2572
                  THREAD->clear_pending_exception();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2573
                }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2574
              }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2575
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2576
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2577
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2578
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2579
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2580
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2581
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2582
    // Notify jvmti/jvmdi
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2583
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2584
    // NOTE: we do not notify a method_exit if we have a pending exception,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2585
    // including an exception we generate for unlocking checks.  In the former
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2586
    // case, JVMDI has already been notified by our call for the exception handler
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2587
    // and in both cases as far as JVMDI is concerned we have already returned.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2588
    // If we notify it again JVMDI will be all confused about how many frames
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2589
    // are still on the stack (4340444).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2590
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2591
    // NOTE Further! It turns out the the JVMTI spec in fact expects to see
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2592
    // method_exit events whenever we leave an activation unless it was done
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2593
    // for popframe. This is nothing like jvmdi. However we are passing the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2594
    // tests at the moment (apparently because they are jvmdi based) so rather
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2595
    // than change this code and possibly fail tests we will leave it alone
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2596
    // (with this note) in anticipation of changing the vm and the tests
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2597
    // simultaneously.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2598
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2599
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2600
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2601
    suppress_exit_event = suppress_exit_event || illegal_state_oop() != NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2602
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2603
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2604
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2605
#ifdef VM_JVMTI
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2606
      if (_jvmti_interp_events) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2607
        // Whenever JVMTI puts a thread in interp_only_mode, method
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2608
        // entry/exit events are sent for that thread to track stack depth.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2609
        if ( !suppress_exit_event && THREAD->is_interp_only_mode() ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2610
          {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2611
            // Prevent any HandleMarkCleaner from freeing our live handles
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2612
            HandleMark __hm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2613
            CALL_VM_NOCHECK(InterpreterRuntime::post_method_exit(THREAD));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2614
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2615
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2616
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2617
#endif /* VM_JVMTI */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2618
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2619
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2620
    // See if we are returning any exception
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2621
    // A pending exception that was pending prior to a possible popping frame
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2622
    // overrides the popping frame.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2623
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2624
    assert(!suppress_error || suppress_error && illegal_state_oop() == NULL, "Error was not suppressed");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2625
    if (illegal_state_oop() != NULL || original_exception() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2626
      // inform the frame manager we have no result
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2627
      istate->set_msg(throwing_exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2628
      if (illegal_state_oop() != NULL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2629
        THREAD->set_pending_exception(illegal_state_oop(), NULL, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2630
      else
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2631
        THREAD->set_pending_exception(original_exception(), NULL, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2632
      istate->set_return_kind((Bytecodes::Code)opcode);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2633
      UPDATE_PC_AND_RETURN(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2634
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2635
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2636
    if (istate->msg() == popping_frame) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2637
      // Make it simpler on the assembly code and set the message for the frame pop.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2638
      // returns
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2639
      if (istate->prev() == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2640
        // We must be returning to a deoptimized frame (because popframe only happens between
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2641
        // two interpreted frames). We need to save the current arguments in C heap so that
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2642
        // the deoptimized frame when it restarts can copy the arguments to its expression
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2643
        // stack and re-execute the call. We also have to notify deoptimization that this
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2644
        // has occured and to pick the preerved args copy them to the deoptimized frame's
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2645
        // java expression stack. Yuck.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2646
        //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2647
        THREAD->popframe_preserve_args(in_ByteSize(METHOD->size_of_parameters() * wordSize),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2648
                                LOCALS_SLOT(METHOD->size_of_parameters() - 1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2649
        THREAD->set_popframe_condition_bit(JavaThread::popframe_force_deopt_reexecution_bit);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2650
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2651
      UPDATE_PC_AND_RETURN(1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2652
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2653
      // Normal return
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2654
      // Advance the pc and return to frame manager
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2655
      istate->set_msg(return_from_method);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2656
      istate->set_return_kind((Bytecodes::Code)opcode);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2657
      UPDATE_PC_AND_RETURN(1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2658
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2659
  } /* handle_return: */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2660
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2661
// This is really a fatal error return
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2662
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2663
finish:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2664
  DECACHE_TOS();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2665
  DECACHE_PC();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2666
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2667
  return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2668
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2669
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2670
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2671
 * All the code following this point is only produced once and is not present
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2672
 * in the JVMTI version of the interpreter
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2673
*/
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2674
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2675
#ifndef VM_JVMTI
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2676
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2677
// This constructor should only be used to contruct the object to signal
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2678
// interpreter initialization. All other instances should be created by
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2679
// the frame manager.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2680
BytecodeInterpreter::BytecodeInterpreter(messages msg) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2681
  if (msg != initialize) ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2682
  _msg = msg;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2683
  _self_link = this;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2684
  _prev_link = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2685
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2686
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2687
// Inline static functions for Java Stack and Local manipulation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2688
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2689
// The implementations are platform dependent. We have to worry about alignment
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2690
// issues on some machines which can change on the same platform depending on
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2691
// whether it is an LP64 machine also.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2692
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2693
void BytecodeInterpreter::verify_stack_tag(intptr_t *tos, frame::Tag tag, int offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2694
  if (TaggedStackInterpreter) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2695
    frame::Tag t = (frame::Tag)tos[Interpreter::expr_tag_index_at(-offset)];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2696
    assert(t == tag, "stack tag mismatch");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2697
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2698
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2699
#endif // ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2700
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2701
address BytecodeInterpreter::stack_slot(intptr_t *tos, int offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2702
  debug_only(verify_stack_tag(tos, frame::TagValue, offset));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2703
  return (address) tos[Interpreter::expr_index_at(-offset)];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2704
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2705
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2706
jint BytecodeInterpreter::stack_int(intptr_t *tos, int offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2707
  debug_only(verify_stack_tag(tos, frame::TagValue, offset));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2708
  return *((jint*) &tos[Interpreter::expr_index_at(-offset)]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2709
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2710
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2711
jfloat BytecodeInterpreter::stack_float(intptr_t *tos, int offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2712
  debug_only(verify_stack_tag(tos, frame::TagValue, offset));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2713
  return *((jfloat *) &tos[Interpreter::expr_index_at(-offset)]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2714
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2715
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2716
oop BytecodeInterpreter::stack_object(intptr_t *tos, int offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2717
  debug_only(verify_stack_tag(tos, frame::TagReference, offset));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2718
  return (oop)tos [Interpreter::expr_index_at(-offset)];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2719
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2720
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2721
jdouble BytecodeInterpreter::stack_double(intptr_t *tos, int offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2722
  debug_only(verify_stack_tag(tos, frame::TagValue, offset));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2723
  debug_only(verify_stack_tag(tos, frame::TagValue, offset-1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2724
  return ((VMJavaVal64*) &tos[Interpreter::expr_index_at(-offset)])->d;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2725
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2726
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2727
jlong BytecodeInterpreter::stack_long(intptr_t *tos, int offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2728
  debug_only(verify_stack_tag(tos, frame::TagValue, offset));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2729
  debug_only(verify_stack_tag(tos, frame::TagValue, offset-1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2730
  return ((VMJavaVal64 *) &tos[Interpreter::expr_index_at(-offset)])->l;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2731
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2732
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2733
void BytecodeInterpreter::tag_stack(intptr_t *tos, frame::Tag tag, int offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2734
  if (TaggedStackInterpreter)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2735
    tos[Interpreter::expr_tag_index_at(-offset)] = (intptr_t)tag;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2736
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2737
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2738
// only used for value types
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2739
void BytecodeInterpreter::set_stack_slot(intptr_t *tos, address value,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2740
                                                        int offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2741
  tag_stack(tos, frame::TagValue, offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2742
  *((address *)&tos[Interpreter::expr_index_at(-offset)]) = value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2743
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2744
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2745
void BytecodeInterpreter::set_stack_int(intptr_t *tos, int value,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2746
                                                       int offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2747
  tag_stack(tos, frame::TagValue, offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2748
  *((jint *)&tos[Interpreter::expr_index_at(-offset)]) = value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2749
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2750
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2751
void BytecodeInterpreter::set_stack_float(intptr_t *tos, jfloat value,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2752
                                                         int offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2753
  tag_stack(tos, frame::TagValue, offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2754
  *((jfloat *)&tos[Interpreter::expr_index_at(-offset)]) = value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2755
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2756
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2757
void BytecodeInterpreter::set_stack_object(intptr_t *tos, oop value,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2758
                                                          int offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2759
  tag_stack(tos, frame::TagReference, offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2760
  *((oop *)&tos[Interpreter::expr_index_at(-offset)]) = value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2761
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2762
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2763
// needs to be platform dep for the 32 bit platforms.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2764
void BytecodeInterpreter::set_stack_double(intptr_t *tos, jdouble value,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2765
                                                          int offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2766
  tag_stack(tos, frame::TagValue, offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2767
  tag_stack(tos, frame::TagValue, offset-1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2768
  ((VMJavaVal64*)&tos[Interpreter::expr_index_at(-offset)])->d = value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2769
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2770
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2771
void BytecodeInterpreter::set_stack_double_from_addr(intptr_t *tos,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2772
                                              address addr, int offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2773
  tag_stack(tos, frame::TagValue, offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2774
  tag_stack(tos, frame::TagValue, offset-1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2775
  (((VMJavaVal64*)&tos[Interpreter::expr_index_at(-offset)])->d =
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2776
                        ((VMJavaVal64*)addr)->d);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2777
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2778
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2779
void BytecodeInterpreter::set_stack_long(intptr_t *tos, jlong value,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2780
                                                        int offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2781
  tag_stack(tos, frame::TagValue, offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2782
  ((VMJavaVal64*)&tos[Interpreter::expr_index_at(-offset+1)])->l = 0xdeedbeeb;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2783
  tag_stack(tos, frame::TagValue, offset-1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2784
  ((VMJavaVal64*)&tos[Interpreter::expr_index_at(-offset)])->l = value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2785
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2786
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2787
void BytecodeInterpreter::set_stack_long_from_addr(intptr_t *tos,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2788
                                            address addr, int offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2789
  tag_stack(tos, frame::TagValue, offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2790
  ((VMJavaVal64*)&tos[Interpreter::expr_index_at(-offset+1)])->l = 0xdeedbeeb;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2791
  tag_stack(tos, frame::TagValue, offset-1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2792
  ((VMJavaVal64*)&tos[Interpreter::expr_index_at(-offset)])->l =
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2793
                        ((VMJavaVal64*)addr)->l;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2794
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2795
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2796
// Locals
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2797
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2798
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2799
void BytecodeInterpreter::verify_locals_tag(intptr_t *locals, frame::Tag tag,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2800
                                     int offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2801
  if (TaggedStackInterpreter) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2802
    frame::Tag t = (frame::Tag)locals[Interpreter::local_tag_index_at(-offset)];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2803
    assert(t == tag, "locals tag mismatch");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2804
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2805
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2806
#endif // ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2807
address BytecodeInterpreter::locals_slot(intptr_t* locals, int offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2808
  debug_only(verify_locals_tag(locals, frame::TagValue, offset));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2809
  return (address)locals[Interpreter::local_index_at(-offset)];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2810
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2811
jint BytecodeInterpreter::locals_int(intptr_t* locals, int offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2812
  debug_only(verify_locals_tag(locals, frame::TagValue, offset));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2813
  return (jint)locals[Interpreter::local_index_at(-offset)];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2814
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2815
jfloat BytecodeInterpreter::locals_float(intptr_t* locals, int offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2816
  debug_only(verify_locals_tag(locals, frame::TagValue, offset));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2817
  return (jfloat)locals[Interpreter::local_index_at(-offset)];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2818
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2819
oop BytecodeInterpreter::locals_object(intptr_t* locals, int offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2820
  debug_only(verify_locals_tag(locals, frame::TagReference, offset));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2821
  return (oop)locals[Interpreter::local_index_at(-offset)];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2822
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2823
jdouble BytecodeInterpreter::locals_double(intptr_t* locals, int offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2824
  debug_only(verify_locals_tag(locals, frame::TagValue, offset));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2825
  debug_only(verify_locals_tag(locals, frame::TagValue, offset));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2826
  return ((VMJavaVal64*)&locals[Interpreter::local_index_at(-(offset+1))])->d;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2827
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2828
jlong BytecodeInterpreter::locals_long(intptr_t* locals, int offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2829
  debug_only(verify_locals_tag(locals, frame::TagValue, offset));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2830
  debug_only(verify_locals_tag(locals, frame::TagValue, offset+1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2831
  return ((VMJavaVal64*)&locals[Interpreter::local_index_at(-(offset+1))])->l;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2832
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2833
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2834
// Returns the address of locals value.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2835
address BytecodeInterpreter::locals_long_at(intptr_t* locals, int offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2836
  debug_only(verify_locals_tag(locals, frame::TagValue, offset));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2837
  debug_only(verify_locals_tag(locals, frame::TagValue, offset+1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2838
  return ((address)&locals[Interpreter::local_index_at(-(offset+1))]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2839
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2840
address BytecodeInterpreter::locals_double_at(intptr_t* locals, int offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2841
  debug_only(verify_locals_tag(locals, frame::TagValue, offset));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2842
  debug_only(verify_locals_tag(locals, frame::TagValue, offset+1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2843
  return ((address)&locals[Interpreter::local_index_at(-(offset+1))]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2844
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2845
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2846
void BytecodeInterpreter::tag_locals(intptr_t *locals, frame::Tag tag, int offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2847
  if (TaggedStackInterpreter)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2848
    locals[Interpreter::local_tag_index_at(-offset)] = (intptr_t)tag;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2849
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2850
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2851
// Used for local value or returnAddress
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2852
void BytecodeInterpreter::set_locals_slot(intptr_t *locals,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2853
                                   address value, int offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2854
  tag_locals(locals, frame::TagValue, offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2855
  *((address*)&locals[Interpreter::local_index_at(-offset)]) = value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2856
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2857
void BytecodeInterpreter::set_locals_int(intptr_t *locals,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2858
                                   jint value, int offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2859
  tag_locals(locals, frame::TagValue, offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2860
  *((jint *)&locals[Interpreter::local_index_at(-offset)]) = value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2861
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2862
void BytecodeInterpreter::set_locals_float(intptr_t *locals,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2863
                                   jfloat value, int offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2864
  tag_locals(locals, frame::TagValue, offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2865
  *((jfloat *)&locals[Interpreter::local_index_at(-offset)]) = value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2866
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2867
void BytecodeInterpreter::set_locals_object(intptr_t *locals,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2868
                                   oop value, int offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2869
  tag_locals(locals, frame::TagReference, offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2870
  *((oop *)&locals[Interpreter::local_index_at(-offset)]) = value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2871
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2872
void BytecodeInterpreter::set_locals_double(intptr_t *locals,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2873
                                   jdouble value, int offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2874
  tag_locals(locals, frame::TagValue, offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2875
  tag_locals(locals, frame::TagValue, offset+1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2876
  ((VMJavaVal64*)&locals[Interpreter::local_index_at(-(offset+1))])->d = value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2877
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2878
void BytecodeInterpreter::set_locals_long(intptr_t *locals,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2879
                                   jlong value, int offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2880
  tag_locals(locals, frame::TagValue, offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2881
  tag_locals(locals, frame::TagValue, offset+1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2882
  ((VMJavaVal64*)&locals[Interpreter::local_index_at(-(offset+1))])->l = value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2883
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2884
void BytecodeInterpreter::set_locals_double_from_addr(intptr_t *locals,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2885
                                   address addr, int offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2886
  tag_locals(locals, frame::TagValue, offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2887
  tag_locals(locals, frame::TagValue, offset+1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2888
  ((VMJavaVal64*)&locals[Interpreter::local_index_at(-(offset+1))])->d = ((VMJavaVal64*)addr)->d;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2889
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2890
void BytecodeInterpreter::set_locals_long_from_addr(intptr_t *locals,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2891
                                   address addr, int offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2892
  tag_locals(locals, frame::TagValue, offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2893
  tag_locals(locals, frame::TagValue, offset+1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2894
  ((VMJavaVal64*)&locals[Interpreter::local_index_at(-(offset+1))])->l = ((VMJavaVal64*)addr)->l;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2895
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2896
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2897
void BytecodeInterpreter::astore(intptr_t* tos,    int stack_offset,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2898
                          intptr_t* locals, int locals_offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2899
  // Copy tag from stack to locals.  astore's operand can be returnAddress
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2900
  // and may not be TagReference
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2901
  if (TaggedStackInterpreter) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2902
    frame::Tag t = (frame::Tag) tos[Interpreter::expr_tag_index_at(-stack_offset)];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2903
    locals[Interpreter::local_tag_index_at(-locals_offset)] = (intptr_t)t;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2904
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2905
  intptr_t value = tos[Interpreter::expr_index_at(-stack_offset)];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2906
  locals[Interpreter::local_index_at(-locals_offset)] = value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2907
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2908
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2909
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2910
void BytecodeInterpreter::copy_stack_slot(intptr_t *tos, int from_offset,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2911
                                   int to_offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2912
  if (TaggedStackInterpreter) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2913
    tos[Interpreter::expr_tag_index_at(-to_offset)] =
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2914
                      (intptr_t)tos[Interpreter::expr_tag_index_at(-from_offset)];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2915
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2916
  tos[Interpreter::expr_index_at(-to_offset)] =
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2917
                      (intptr_t)tos[Interpreter::expr_index_at(-from_offset)];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2918
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2919
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2920
void BytecodeInterpreter::dup(intptr_t *tos) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2921
  copy_stack_slot(tos, -1, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2922
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2923
void BytecodeInterpreter::dup2(intptr_t *tos) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2924
  copy_stack_slot(tos, -2, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2925
  copy_stack_slot(tos, -1, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2926
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2927
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2928
void BytecodeInterpreter::dup_x1(intptr_t *tos) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2929
  /* insert top word two down */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2930
  copy_stack_slot(tos, -1, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2931
  copy_stack_slot(tos, -2, -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2932
  copy_stack_slot(tos, 0, -2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2933
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2934
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2935
void BytecodeInterpreter::dup_x2(intptr_t *tos) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2936
  /* insert top word three down  */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2937
  copy_stack_slot(tos, -1, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2938
  copy_stack_slot(tos, -2, -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2939
  copy_stack_slot(tos, -3, -2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2940
  copy_stack_slot(tos, 0, -3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2941
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2942
void BytecodeInterpreter::dup2_x1(intptr_t *tos) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2943
  /* insert top 2 slots three down */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2944
  copy_stack_slot(tos, -1, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2945
  copy_stack_slot(tos, -2, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2946
  copy_stack_slot(tos, -3, -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2947
  copy_stack_slot(tos, 1, -2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2948
  copy_stack_slot(tos, 0, -3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2949
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2950
void BytecodeInterpreter::dup2_x2(intptr_t *tos) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2951
  /* insert top 2 slots four down */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2952
  copy_stack_slot(tos, -1, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2953
  copy_stack_slot(tos, -2, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2954
  copy_stack_slot(tos, -3, -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2955
  copy_stack_slot(tos, -4, -2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2956
  copy_stack_slot(tos, 1, -3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2957
  copy_stack_slot(tos, 0, -4);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2958
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2959
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2960
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2961
void BytecodeInterpreter::swap(intptr_t *tos) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2962
  // swap top two elements
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2963
  intptr_t val = tos[Interpreter::expr_index_at(1)];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2964
  frame::Tag t;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2965
  if (TaggedStackInterpreter) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2966
    t = (frame::Tag) tos[Interpreter::expr_tag_index_at(1)];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2967
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2968
  // Copy -2 entry to -1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2969
  copy_stack_slot(tos, -2, -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2970
  // Store saved -1 entry into -2
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2971
  if (TaggedStackInterpreter) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2972
    tos[Interpreter::expr_tag_index_at(2)] = (intptr_t)t;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2973
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2974
  tos[Interpreter::expr_index_at(2)] = val;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2975
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2976
// --------------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2977
// Non-product code
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2978
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2979
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2980
const char* BytecodeInterpreter::C_msg(BytecodeInterpreter::messages msg) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2981
  switch (msg) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2982
     case BytecodeInterpreter::no_request:  return("no_request");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2983
     case BytecodeInterpreter::initialize:  return("initialize");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2984
     // status message to C++ interpreter
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2985
     case BytecodeInterpreter::method_entry:  return("method_entry");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2986
     case BytecodeInterpreter::method_resume:  return("method_resume");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2987
     case BytecodeInterpreter::got_monitors:  return("got_monitors");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2988
     case BytecodeInterpreter::rethrow_exception:  return("rethrow_exception");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2989
     // requests to frame manager from C++ interpreter
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2990
     case BytecodeInterpreter::call_method:  return("call_method");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2991
     case BytecodeInterpreter::return_from_method:  return("return_from_method");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2992
     case BytecodeInterpreter::more_monitors:  return("more_monitors");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2993
     case BytecodeInterpreter::throwing_exception:  return("throwing_exception");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2994
     case BytecodeInterpreter::popping_frame:  return("popping_frame");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2995
     case BytecodeInterpreter::do_osr:  return("do_osr");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2996
     // deopt
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2997
     case BytecodeInterpreter::deopt_resume:  return("deopt_resume");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2998
     case BytecodeInterpreter::deopt_resume2:  return("deopt_resume2");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2999
     default: return("BAD MSG");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3000
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3001
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3002
void
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3003
BytecodeInterpreter::print() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3004
  tty->print_cr("thread: " INTPTR_FORMAT, (uintptr_t) this->_thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3005
  tty->print_cr("bcp: " INTPTR_FORMAT, (uintptr_t) this->_bcp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3006
  tty->print_cr("locals: " INTPTR_FORMAT, (uintptr_t) this->_locals);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3007
  tty->print_cr("constants: " INTPTR_FORMAT, (uintptr_t) this->_constants);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3008
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3009
    ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3010
    char *method_name = _method->name_and_sig_as_C_string();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3011
    tty->print_cr("method: " INTPTR_FORMAT "[ %s ]",  (uintptr_t) this->_method, method_name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3012
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3013
  tty->print_cr("mdx: " INTPTR_FORMAT, (uintptr_t) this->_mdx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3014
  tty->print_cr("stack: " INTPTR_FORMAT, (uintptr_t) this->_stack);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3015
  tty->print_cr("msg: %s", C_msg(this->_msg));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3016
  tty->print_cr("result_to_call._callee: " INTPTR_FORMAT, (uintptr_t) this->_result._to_call._callee);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3017
  tty->print_cr("result_to_call._callee_entry_point: " INTPTR_FORMAT, (uintptr_t) this->_result._to_call._callee_entry_point);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3018
  tty->print_cr("result_to_call._bcp_advance: %d ", this->_result._to_call._bcp_advance);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3019
  tty->print_cr("osr._osr_buf: " INTPTR_FORMAT, (uintptr_t) this->_result._osr._osr_buf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3020
  tty->print_cr("osr._osr_entry: " INTPTR_FORMAT, (uintptr_t) this->_result._osr._osr_entry);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3021
  tty->print_cr("result_return_kind 0x%x ", (int) this->_result._return_kind);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3022
  tty->print_cr("prev_link: " INTPTR_FORMAT, (uintptr_t) this->_prev_link);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3023
  tty->print_cr("native_mirror: " INTPTR_FORMAT, (uintptr_t) this->_oop_temp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3024
  tty->print_cr("stack_base: " INTPTR_FORMAT, (uintptr_t) this->_stack_base);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3025
  tty->print_cr("stack_limit: " INTPTR_FORMAT, (uintptr_t) this->_stack_limit);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3026
  tty->print_cr("monitor_base: " INTPTR_FORMAT, (uintptr_t) this->_monitor_base);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3027
#ifdef SPARC
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3028
  tty->print_cr("last_Java_pc: " INTPTR_FORMAT, (uintptr_t) this->_last_Java_pc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3029
  tty->print_cr("frame_bottom: " INTPTR_FORMAT, (uintptr_t) this->_frame_bottom);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3030
  tty->print_cr("&native_fresult: " INTPTR_FORMAT, (uintptr_t) &this->_native_fresult);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3031
  tty->print_cr("native_lresult: " INTPTR_FORMAT, (uintptr_t) this->_native_lresult);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3032
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3033
#ifdef IA64
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3034
  tty->print_cr("last_Java_fp: " INTPTR_FORMAT, (uintptr_t) this->_last_Java_fp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3035
#endif // IA64
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3036
  tty->print_cr("self_link: " INTPTR_FORMAT, (uintptr_t) this->_self_link);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3037
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3038
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3039
extern "C" {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3040
    void PI(uintptr_t arg) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3041
        ((BytecodeInterpreter*)arg)->print();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3042
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3043
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3044
#endif // PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3045
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3046
#endif // JVMTI
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3047
#endif // CC_INTERP