hotspot/src/share/vm/runtime/interfaceSupport.hpp
author stefank
Tue, 23 Nov 2010 13:22:55 -0800
changeset 7397 5b173b4ca846
parent 5547 f4b087cbb361
child 8076 96d498ec7ae1
permissions -rw-r--r--
6989984: Use standard include model for Hospot Summary: Replaced MakeDeps and the includeDB files with more standardized solutions. Reviewed-by: coleenp, kvn, kamg
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
     2
 * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
1
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
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    25
#ifndef SHARE_VM_RUNTIME_INTERFACESUPPORT_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    26
#define SHARE_VM_RUNTIME_INTERFACESUPPORT_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    27
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    28
#include "memory/gcLocker.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    29
#include "runtime/handles.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    30
#include "runtime/mutexLocker.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    31
#include "runtime/orderAccess.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    32
#include "runtime/os.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    33
#include "runtime/safepoint.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    34
#include "runtime/vmThread.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    35
#include "utilities/globalDefinitions.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    36
#include "utilities/preserveException.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    37
#include "utilities/top.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    38
#ifdef TARGET_OS_FAMILY_linux
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    39
# include "thread_linux.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    40
#endif
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    41
#ifdef TARGET_OS_FAMILY_solaris
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    42
# include "thread_solaris.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    43
#endif
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    44
#ifdef TARGET_OS_FAMILY_windows
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    45
# include "thread_windows.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    46
#endif
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    47
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
// Wrapper for all entry points to the virtual machine.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
// The HandleMarkCleaner is a faster version of HandleMark.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
// It relies on the fact that there is a HandleMark further
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
// down the stack (in JavaCalls::call_helper), and just resets
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
// to the saved values in that HandleMark.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
class HandleMarkCleaner: public StackObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
  Thread* _thread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
  HandleMarkCleaner(Thread* thread) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
    _thread = thread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
    _thread->last_handle_mark()->push();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
  ~HandleMarkCleaner() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
    _thread->last_handle_mark()->pop_and_restore();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
  inline void* operator new(size_t size, void* ptr) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
    return ptr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
// InterfaceSupport provides functionality used by the __LEAF and __ENTRY
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
// macros. These macros are used to guard entry points into the VM and
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
// perform checks upon leave of the VM.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
class InterfaceSupport: AllStatic {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
# ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
  static long _scavenge_alot_counter;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
  static long _fullgc_alot_counter;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
  static long _number_of_calls;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
  static long _fullgc_alot_invocation;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
  // tracing
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
  static void trace(const char* result_type, const char* header);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
  // Helper methods used to implement +ScavengeALot and +FullGCALot
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
  static void check_gc_alot() { if (ScavengeALot || FullGCALot) gc_alot(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
  static void gc_alot();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
  static void walk_stack_from(vframe* start_vf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
  static void walk_stack();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
# ifdef ENABLE_ZAP_DEAD_LOCALS
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
  static void zap_dead_locals_old();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
# endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
  static void zombieAll();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
  static void deoptimizeAll();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
  static void stress_derived_pointers();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
  static void verify_stack();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  static void verify_last_frame();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
# endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
  // OS dependent stuff
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
   108
#ifdef TARGET_OS_FAMILY_linux
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
   109
# include "interfaceSupport_linux.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
   110
#endif
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
   111
#ifdef TARGET_OS_FAMILY_solaris
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
   112
# include "interfaceSupport_solaris.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
   113
#endif
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
   114
#ifdef TARGET_OS_FAMILY_windows
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
   115
# include "interfaceSupport_windows.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
   116
#endif
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
   117
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
// Basic class for all thread transition classes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
class ThreadStateTransition : public StackObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
  JavaThread* _thread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
  ThreadStateTransition(JavaThread *thread) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
    _thread = thread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
    assert(thread != NULL && thread->is_Java_thread(), "must be Java thread");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
  // Change threadstate in a manner, so safepoint can detect changes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
  // Time-critical: called on exit from every runtime routine
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
  static inline void transition(JavaThread *thread, JavaThreadState from, JavaThreadState to) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
    assert(from != _thread_in_Java, "use transition_from_java");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
    assert(from != _thread_in_native, "use transition_from_native");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
    assert((from & 1) == 0 && (to & 1) == 0, "odd numbers are transitions states");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
    assert(thread->thread_state() == from, "coming from wrong thread state");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
    // Change to transition state (assumes total store ordering!  -Urs)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
    thread->set_thread_state((JavaThreadState)(from + 1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
    // Make sure new state is seen by VM thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
    if (os::is_MP()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
      if (UseMembar) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
        // Force a fence between the write above and read below
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
        OrderAccess::fence();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
        // store to serialize page so VM thread can do pseudo remote membar
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
        os::write_memory_serialize_page(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
    if (SafepointSynchronize::do_call_back()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
      SafepointSynchronize::block(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
    thread->set_thread_state(to);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
    CHECK_UNHANDLED_OOPS_ONLY(thread->clear_unhandled_oops();)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
  // transition_and_fence must be used on any thread state transition
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
  // where there might not be a Java call stub on the stack, in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
  // particular on Windows where the Structured Exception Handler is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
  // set up in the call stub. os::write_memory_serialize_page() can
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
  // fault and we can't recover from it on Windows without a SEH in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
  // place.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
  static inline void transition_and_fence(JavaThread *thread, JavaThreadState from, JavaThreadState to) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
    assert(thread->thread_state() == from, "coming from wrong thread state");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
    assert((from & 1) == 0 && (to & 1) == 0, "odd numbers are transitions states");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
    // Change to transition state (assumes total store ordering!  -Urs)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
    thread->set_thread_state((JavaThreadState)(from + 1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
    // Make sure new state is seen by VM thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
    if (os::is_MP()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
      if (UseMembar) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
        // Force a fence between the write above and read below
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
        OrderAccess::fence();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
        // Must use this rather than serialization page in particular on Windows
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
        InterfaceSupport::serialize_memory(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
    if (SafepointSynchronize::do_call_back()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
      SafepointSynchronize::block(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
    thread->set_thread_state(to);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
    CHECK_UNHANDLED_OOPS_ONLY(thread->clear_unhandled_oops();)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
  // Same as above, but assumes from = _thread_in_Java. This is simpler, since we
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
  // never block on entry to the VM. This will break the code, since e.g. preserve arguments
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
  // have not been setup.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
  static inline void transition_from_java(JavaThread *thread, JavaThreadState to) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
    assert(thread->thread_state() == _thread_in_Java, "coming from wrong thread state");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
    thread->set_thread_state(to);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
  static inline void transition_from_native(JavaThread *thread, JavaThreadState to) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
    assert((to & 1) == 0, "odd numbers are transitions states");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
    assert(thread->thread_state() == _thread_in_native, "coming from wrong thread state");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
    // Change to transition state (assumes total store ordering!  -Urs)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
    thread->set_thread_state(_thread_in_native_trans);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
    // Make sure new state is seen by GC thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
    if (os::is_MP()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
      if (UseMembar) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
        // Force a fence between the write above and read below
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
        OrderAccess::fence();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
        // Must use this rather than serialization page in particular on Windows
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
        InterfaceSupport::serialize_memory(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
    // We never install asynchronous exceptions when coming (back) in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
    // to the runtime from native code because the runtime is not set
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
    // up to handle exceptions floating around at arbitrary points.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
    if (SafepointSynchronize::do_call_back() || thread->is_suspend_after_native()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
      JavaThread::check_safepoint_and_suspend_for_native_trans(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
      // Clear unhandled oops anywhere where we could block, even if we don't.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
      CHECK_UNHANDLED_OOPS_ONLY(thread->clear_unhandled_oops();)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
    thread->set_thread_state(to);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
   void trans(JavaThreadState from, JavaThreadState to)  { transition(_thread, from, to); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
   void trans_from_java(JavaThreadState to)              { transition_from_java(_thread, to); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
   void trans_from_native(JavaThreadState to)            { transition_from_native(_thread, to); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
   void trans_and_fence(JavaThreadState from, JavaThreadState to) { transition_and_fence(_thread, from, to); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
class ThreadInVMfromJava : public ThreadStateTransition {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
  ThreadInVMfromJava(JavaThread* thread) : ThreadStateTransition(thread) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
    trans_from_java(_thread_in_vm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
  ~ThreadInVMfromJava()  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
    trans(_thread_in_vm, _thread_in_Java);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
    // Check for pending. async. exceptions or suspends.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
    if (_thread->has_special_runtime_exit_condition()) _thread->handle_special_runtime_exit_condition();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
class ThreadInVMfromUnknown {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
  JavaThread* _thread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
  ThreadInVMfromUnknown() : _thread(NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
    Thread* t = Thread::current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
    if (t->is_Java_thread()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
      JavaThread* t2 = (JavaThread*) t;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
      if (t2->thread_state() == _thread_in_native) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
        _thread = t2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
        ThreadStateTransition::transition_from_native(t2, _thread_in_vm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
        // Used to have a HandleMarkCleaner but that is dangerous as
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
        // it could free a handle in our (indirect, nested) caller.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
        // We expect any handles will be short lived and figure we
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
        // don't need an actual HandleMark.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
  ~ThreadInVMfromUnknown()  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
    if (_thread) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
      ThreadStateTransition::transition_and_fence(_thread, _thread_in_vm, _thread_in_native);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
class ThreadInVMfromNative : public ThreadStateTransition {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
  ThreadInVMfromNative(JavaThread* thread) : ThreadStateTransition(thread) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
    trans_from_native(_thread_in_vm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
  ~ThreadInVMfromNative() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
    trans_and_fence(_thread_in_vm, _thread_in_native);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
class ThreadToNativeFromVM : public ThreadStateTransition {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
  ThreadToNativeFromVM(JavaThread *thread) : ThreadStateTransition(thread) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
    // We are leaving the VM at this point and going directly to native code.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
    // Block, if we are in the middle of a safepoint synchronization.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
    assert(!thread->owns_locks(), "must release all locks when leaving VM");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
    thread->frame_anchor()->make_walkable(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
    trans_and_fence(_thread_in_vm, _thread_in_native);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
    // Check for pending. async. exceptions or suspends.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
    if (_thread->has_special_runtime_exit_condition()) _thread->handle_special_runtime_exit_condition(false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
  ~ThreadToNativeFromVM() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
    trans_from_native(_thread_in_vm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
    // We don't need to clear_walkable because it will happen automagically when we return to java
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
class ThreadBlockInVM : public ThreadStateTransition {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
  ThreadBlockInVM(JavaThread *thread)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
  : ThreadStateTransition(thread) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
    // Once we are blocked vm expects stack to be walkable
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
    thread->frame_anchor()->make_walkable(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
    trans_and_fence(_thread_in_vm, _thread_blocked);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
  ~ThreadBlockInVM() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
    trans_and_fence(_thread_blocked, _thread_in_vm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
    // We don't need to clear_walkable because it will happen automagically when we return to java
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
// This special transition class is only used to prevent asynchronous exceptions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
// from being installed on vm exit in situations where we can't tolerate them.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
// See bugs: 4324348, 4854693, 4998314, 5040492, 5050705.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
class ThreadInVMfromJavaNoAsyncException : public ThreadStateTransition {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
  ThreadInVMfromJavaNoAsyncException(JavaThread* thread) : ThreadStateTransition(thread) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
    trans_from_java(_thread_in_vm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
  ~ThreadInVMfromJavaNoAsyncException()  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
    trans(_thread_in_vm, _thread_in_Java);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
    // NOTE: We do not check for pending. async. exceptions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
    // If we did and moved the pending async exception over into the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
    // pending exception field, we would need to deopt (currently C2
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
    // only). However, to do so would require that we transition back
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
    // to the _thread_in_vm state. Instead we postpone the handling of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
    // the async exception.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
    // Check for pending. suspends only.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
    if (_thread->has_special_runtime_exit_condition())
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
      _thread->handle_special_runtime_exit_condition(false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
// Debug class instantiated in JRT_ENTRY and ITR_ENTRY macro.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
// Can be used to verify properties on enter/exit of the VM.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
class VMEntryWrapper {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
  VMEntryWrapper() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
    if (VerifyLastFrame) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
      InterfaceSupport::verify_last_frame();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
  ~VMEntryWrapper() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
    InterfaceSupport::check_gc_alot();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
    if (WalkStackALot) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
      InterfaceSupport::walk_stack();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
#ifdef ENABLE_ZAP_DEAD_LOCALS
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
    if (ZapDeadLocalsOld) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
      InterfaceSupport::zap_dead_locals_old();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
#ifdef COMPILER2
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
    // This option is not used by Compiler 1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
    if (StressDerivedPointers) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
      InterfaceSupport::stress_derived_pointers();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
    if (DeoptimizeALot || DeoptimizeRandom) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
      InterfaceSupport::deoptimizeAll();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
    if (ZombieALot) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
      InterfaceSupport::zombieAll();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
    // do verification AFTER potential deoptimization
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
    if (VerifyStack) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
      InterfaceSupport::verify_stack();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
  }
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
class VMNativeEntryWrapper {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
  VMNativeEntryWrapper() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
    if (GCALotAtAllSafepoints) InterfaceSupport::check_gc_alot();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
  ~VMNativeEntryWrapper() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
    if (GCALotAtAllSafepoints) InterfaceSupport::check_gc_alot();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
// VM-internal runtime interface support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
class RuntimeHistogramElement : public HistogramElement {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
  public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
   RuntimeHistogramElement(const char* name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
#define TRACE_CALL(result_type, header)                            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
  InterfaceSupport::_number_of_calls++;                            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
  if (TraceRuntimeCalls)                                           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
    InterfaceSupport::trace(#result_type, #header);                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
  if (CountRuntimeCalls) {                                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
    static RuntimeHistogramElement* e = new RuntimeHistogramElement(#header); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
    if (e != NULL) e->increment_count();                           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
#define TRACE_CALL(result_type, header)                            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
  /* do nothing */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
// LEAF routines do not lock, GC or throw exceptions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
#define __LEAF(result_type, header)                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
  TRACE_CALL(result_type, header)                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
  debug_only(NoHandleMark __hm;)                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
  /* begin of body */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
// ENTRY routines may lock, GC and throw exceptions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
#define __ENTRY(result_type, header, thread)                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
  TRACE_CALL(result_type, header)                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
  HandleMarkCleaner __hm(thread);                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
  Thread* THREAD = thread;                                           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
  /* begin of body */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
// QUICK_ENTRY routines behave like ENTRY but without a handle mark
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
#define __QUICK_ENTRY(result_type, header, thread)                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
  TRACE_CALL(result_type, header)                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
  debug_only(NoHandleMark __hm;)                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
  Thread* THREAD = thread;                                           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
  /* begin of body */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
// Definitions for IRT (Interpreter Runtime)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
// (thread is an argument passed in to all these routines)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
#define IRT_ENTRY(result_type, header)                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
  result_type header {                                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
    ThreadInVMfromJava __tiv(thread);                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
    __ENTRY(result_type, header, thread)                             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
    debug_only(VMEntryWrapper __vew;)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
#define IRT_LEAF(result_type, header)                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
  result_type header {                                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
    __LEAF(result_type, header)                                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
    debug_only(No_Safepoint_Verifier __nspv(true);)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
#define IRT_ENTRY_NO_ASYNC(result_type, header)                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
  result_type header {                                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
    ThreadInVMfromJavaNoAsyncException __tiv(thread);                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
    __ENTRY(result_type, header, thread)                             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
    debug_only(VMEntryWrapper __vew;)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
// Another special case for nmethod_entry_point so the nmethod that the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
// interpreter is about to branch to doesn't get flushed before as we
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
// branch to it's interpreter_entry_point.  Skip stress testing here too.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
// Also we don't allow async exceptions because it is just too painful.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
#define IRT_ENTRY_FOR_NMETHOD(result_type, header)                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
  result_type header {                                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
    nmethodLocker _nmlock(nm);                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
    ThreadInVMfromJavaNoAsyncException __tiv(thread);                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
    __ENTRY(result_type, header, thread)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
#define IRT_END }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
// Definitions for JRT (Java (Compiler/Shared) Runtime)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
#define JRT_ENTRY(result_type, header)                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
  result_type header {                                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
    ThreadInVMfromJava __tiv(thread);                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
    __ENTRY(result_type, header, thread)                             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
    debug_only(VMEntryWrapper __vew;)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
#define JRT_LEAF(result_type, header)                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
  result_type header {                                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
  __LEAF(result_type, header)                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
  debug_only(JRT_Leaf_Verifier __jlv;)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
#define JRT_ENTRY_NO_ASYNC(result_type, header)                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
  result_type header {                                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
    ThreadInVMfromJavaNoAsyncException __tiv(thread);                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
    __ENTRY(result_type, header, thread)                             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
    debug_only(VMEntryWrapper __vew;)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
// Same as JRT Entry but allows for return value after the safepoint
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
// to get back into Java from the VM
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
#define JRT_BLOCK_ENTRY(result_type, header)                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
  result_type header {                                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
    TRACE_CALL(result_type, header)                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
    HandleMarkCleaner __hm(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
#define JRT_BLOCK                                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
    {                                                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
    ThreadInVMfromJava __tiv(thread);                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
    Thread* THREAD = thread;                                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
    debug_only(VMEntryWrapper __vew;)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
#define JRT_BLOCK_END }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
#define JRT_END }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
// Definitions for JNI
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
#define JNI_ENTRY(result_type, header)                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
    JNI_ENTRY_NO_PRESERVE(result_type, header)                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
    WeakPreserveExceptionMark __wem(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
#define JNI_ENTRY_NO_PRESERVE(result_type, header)             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
extern "C" {                                                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
  result_type JNICALL header {                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
    JavaThread* thread=JavaThread::thread_from_jni_environment(env); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
    assert( !VerifyJNIEnvThread || (thread == Thread::current()), "JNIEnv is only valid in same thread"); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
    ThreadInVMfromNative __tiv(thread);                              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
    debug_only(VMNativeEntryWrapper __vew;)                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
    __ENTRY(result_type, header, thread)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
// Ensure that the VMNativeEntryWrapper constructor, which can cause
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
// a GC, is called outside the NoHandleMark (set via __QUICK_ENTRY).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
#define JNI_QUICK_ENTRY(result_type, header)                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
extern "C" {                                                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
  result_type JNICALL header {                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
    JavaThread* thread=JavaThread::thread_from_jni_environment(env); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
    assert( !VerifyJNIEnvThread || (thread == Thread::current()), "JNIEnv is only valid in same thread"); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
    ThreadInVMfromNative __tiv(thread);                              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
    debug_only(VMNativeEntryWrapper __vew;)                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
    __QUICK_ENTRY(result_type, header, thread)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
#define JNI_LEAF(result_type, header)                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
extern "C" {                                                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
  result_type JNICALL header {                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
    JavaThread* thread=JavaThread::thread_from_jni_environment(env); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
    assert( !VerifyJNIEnvThread || (thread == Thread::current()), "JNIEnv is only valid in same thread"); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
    __LEAF(result_type, header)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
// Close the routine and the extern "C"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
#define JNI_END } }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
// Definitions for JVM
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
#define JVM_ENTRY(result_type, header)                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
extern "C" {                                                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
  result_type JNICALL header {                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
    JavaThread* thread=JavaThread::thread_from_jni_environment(env); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
    ThreadInVMfromNative __tiv(thread);                              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
    debug_only(VMNativeEntryWrapper __vew;)                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
    __ENTRY(result_type, header, thread)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
#define JVM_ENTRY_NO_ENV(result_type, header)                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
extern "C" {                                                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
  result_type JNICALL header {                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
    JavaThread* thread = (JavaThread*)ThreadLocalStorage::thread();  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
    ThreadInVMfromNative __tiv(thread);                              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
    debug_only(VMNativeEntryWrapper __vew;)                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
    __ENTRY(result_type, header, thread)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
#define JVM_QUICK_ENTRY(result_type, header)                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
extern "C" {                                                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
  result_type JNICALL header {                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
    JavaThread* thread=JavaThread::thread_from_jni_environment(env); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
    ThreadInVMfromNative __tiv(thread);                              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
    debug_only(VMNativeEntryWrapper __vew;)                          \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
    __QUICK_ENTRY(result_type, header, thread)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
#define JVM_LEAF(result_type, header)                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
extern "C" {                                                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
  result_type JNICALL header {                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
    VM_Exit::block_if_vm_exited();                                   \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
    __LEAF(result_type, header)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
#define JVM_END } }
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
   601
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
   602
#endif // SHARE_VM_RUNTIME_INTERFACESUPPORT_HPP