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