src/hotspot/share/runtime/interfaceSupport.hpp
author erikj
Tue, 12 Sep 2017 19:03:39 +0200
changeset 47216 71c04702a3d5
parent 46604 hotspot/src/share/vm/runtime/interfaceSupport.hpp@d409276ee40c
child 47881 0ce0ac68ace7
permissions -rw-r--r--
8187443: Forest Consolidation: Move files to unified layout Reviewed-by: darcy, ihse
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
46373
e8e9b36783f3 8166927: interfaceSupport.hpp has ancient comments about TSO
dholmes
parents: 41084
diff changeset
     2
 * Copyright (c) 1997, 2017, 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
30764
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 29070
diff changeset
    28
#include "gc/shared/gcLocker.hpp"
7397
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"
14583
d70ee55535f4 8003935: Simplify the needed includes for using Thread::current()
stefank
parents: 13963
diff changeset
    34
#include "runtime/thread.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    35
#include "runtime/vmThread.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    36
#include "utilities/globalDefinitions.hpp"
40010
e32d5e545789 8161258: Simplify including platform files.
goetz
parents: 37466
diff changeset
    37
#include "utilities/macros.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    38
#include "utilities/preserveException.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    39
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
// Wrapper for all entry points to the virtual machine.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
// The HandleMarkCleaner is a faster version of HandleMark.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
// It relies on the fact that there is a HandleMark further
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
// down the stack (in JavaCalls::call_helper), and just resets
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
// to the saved values in that HandleMark.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
class HandleMarkCleaner: public StackObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
  Thread* _thread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
  HandleMarkCleaner(Thread* thread) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
    _thread = thread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
    _thread->last_handle_mark()->push();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
  ~HandleMarkCleaner() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
    _thread->last_handle_mark()->pop_and_restore();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
 private:
19696
bd5a0131bde1 8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced
coleenp
parents: 14583
diff changeset
    59
  inline void* operator new(size_t size, void* ptr) throw() {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
    return ptr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
10969
3ecf25293e5a 7103224: collision between __LEAF define in interfaceSupport.hpp and /usr/include/sys/cdefs.h with gcc
never
parents: 10565
diff changeset
    64
// 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
    65
// 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
    66
// the VM and perform checks upon leave of the VM.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
class InterfaceSupport: AllStatic {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
# ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
  static long _scavenge_alot_counter;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
  static long _fullgc_alot_counter;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
  static long _number_of_calls;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
  static long _fullgc_alot_invocation;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
  // Helper methods used to implement +ScavengeALot and +FullGCALot
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
  static void check_gc_alot() { if (ScavengeALot || FullGCALot) gc_alot(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
  static void gc_alot();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
  static void walk_stack_from(vframe* start_vf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
  static void walk_stack();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
  static void zombieAll();
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
    85
  static void unlinkSymbols();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
  static void deoptimizeAll();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
  static void stress_derived_pointers();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
  static void verify_stack();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
  static void verify_last_frame();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
# endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
 public:
46604
d409276ee40c 8183198: Factor out thread state serialization into a proper helper function
mgerdin
parents: 46373
diff changeset
    93
  static void serialize_thread_state_with_handler(JavaThread* thread) {
d409276ee40c 8183198: Factor out thread state serialization into a proper helper function
mgerdin
parents: 46373
diff changeset
    94
    serialize_thread_state_internal(thread, true);
d409276ee40c 8183198: Factor out thread state serialization into a proper helper function
mgerdin
parents: 46373
diff changeset
    95
  }
d409276ee40c 8183198: Factor out thread state serialization into a proper helper function
mgerdin
parents: 46373
diff changeset
    96
d409276ee40c 8183198: Factor out thread state serialization into a proper helper function
mgerdin
parents: 46373
diff changeset
    97
  // Should only call this if we know that we have a proper SEH set up.
d409276ee40c 8183198: Factor out thread state serialization into a proper helper function
mgerdin
parents: 46373
diff changeset
    98
  static void serialize_thread_state(JavaThread* thread) {
d409276ee40c 8183198: Factor out thread state serialization into a proper helper function
mgerdin
parents: 46373
diff changeset
    99
    serialize_thread_state_internal(thread, false);
d409276ee40c 8183198: Factor out thread state serialization into a proper helper function
mgerdin
parents: 46373
diff changeset
   100
  }
40010
e32d5e545789 8161258: Simplify including platform files.
goetz
parents: 37466
diff changeset
   101
46604
d409276ee40c 8183198: Factor out thread state serialization into a proper helper function
mgerdin
parents: 46373
diff changeset
   102
 private:
d409276ee40c 8183198: Factor out thread state serialization into a proper helper function
mgerdin
parents: 46373
diff changeset
   103
  static void serialize_thread_state_internal(JavaThread* thread, bool needs_exception_handler) {
d409276ee40c 8183198: Factor out thread state serialization into a proper helper function
mgerdin
parents: 46373
diff changeset
   104
    // Make sure new state is seen by VM thread
d409276ee40c 8183198: Factor out thread state serialization into a proper helper function
mgerdin
parents: 46373
diff changeset
   105
    if (os::is_MP()) {
d409276ee40c 8183198: Factor out thread state serialization into a proper helper function
mgerdin
parents: 46373
diff changeset
   106
      if (UseMembar) {
d409276ee40c 8183198: Factor out thread state serialization into a proper helper function
mgerdin
parents: 46373
diff changeset
   107
        // Force a fence between the write above and read below
d409276ee40c 8183198: Factor out thread state serialization into a proper helper function
mgerdin
parents: 46373
diff changeset
   108
        OrderAccess::fence();
d409276ee40c 8183198: Factor out thread state serialization into a proper helper function
mgerdin
parents: 46373
diff changeset
   109
      } else {
d409276ee40c 8183198: Factor out thread state serialization into a proper helper function
mgerdin
parents: 46373
diff changeset
   110
        // store to serialize page so VM thread can do pseudo remote membar
d409276ee40c 8183198: Factor out thread state serialization into a proper helper function
mgerdin
parents: 46373
diff changeset
   111
        if (needs_exception_handler) {
d409276ee40c 8183198: Factor out thread state serialization into a proper helper function
mgerdin
parents: 46373
diff changeset
   112
          os::write_memory_serialize_page_with_handler(thread);
d409276ee40c 8183198: Factor out thread state serialization into a proper helper function
mgerdin
parents: 46373
diff changeset
   113
        } else {
d409276ee40c 8183198: Factor out thread state serialization into a proper helper function
mgerdin
parents: 46373
diff changeset
   114
          os::write_memory_serialize_page(thread);
d409276ee40c 8183198: Factor out thread state serialization into a proper helper function
mgerdin
parents: 46373
diff changeset
   115
        }
d409276ee40c 8183198: Factor out thread state serialization into a proper helper function
mgerdin
parents: 46373
diff changeset
   116
      }
d409276ee40c 8183198: Factor out thread state serialization into a proper helper function
mgerdin
parents: 46373
diff changeset
   117
    }
d409276ee40c 8183198: Factor out thread state serialization into a proper helper function
mgerdin
parents: 46373
diff changeset
   118
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
// Basic class for all thread transition classes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
class ThreadStateTransition : public StackObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
  JavaThread* _thread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
  ThreadStateTransition(JavaThread *thread) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
    _thread = thread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
    assert(thread != NULL && thread->is_Java_thread(), "must be Java thread");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
  // Change threadstate in a manner, so safepoint can detect changes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
  // Time-critical: called on exit from every runtime routine
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
  static inline void transition(JavaThread *thread, JavaThreadState from, JavaThreadState to) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
    assert(from != _thread_in_Java, "use transition_from_java");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
    assert(from != _thread_in_native, "use transition_from_native");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
    assert((from & 1) == 0 && (to & 1) == 0, "odd numbers are transitions states");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
    assert(thread->thread_state() == from, "coming from wrong thread state");
46373
e8e9b36783f3 8166927: interfaceSupport.hpp has ancient comments about TSO
dholmes
parents: 41084
diff changeset
   140
    // Change to transition state
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
    thread->set_thread_state((JavaThreadState)(from + 1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
46604
d409276ee40c 8183198: Factor out thread state serialization into a proper helper function
mgerdin
parents: 46373
diff changeset
   143
    InterfaceSupport::serialize_thread_state(thread);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
    if (SafepointSynchronize::do_call_back()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
      SafepointSynchronize::block(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
    thread->set_thread_state(to);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
    CHECK_UNHANDLED_OOPS_ONLY(thread->clear_unhandled_oops();)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
  // transition_and_fence must be used on any thread state transition
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
  // where there might not be a Java call stub on the stack, in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
  // particular on Windows where the Structured Exception Handler is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
  // set up in the call stub. os::write_memory_serialize_page() can
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
  // fault and we can't recover from it on Windows without a SEH in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
  // place.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
  static inline void transition_and_fence(JavaThread *thread, JavaThreadState from, JavaThreadState to) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
    assert(thread->thread_state() == from, "coming from wrong thread state");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
    assert((from & 1) == 0 && (to & 1) == 0, "odd numbers are transitions states");
46373
e8e9b36783f3 8166927: interfaceSupport.hpp has ancient comments about TSO
dholmes
parents: 41084
diff changeset
   162
    // Change to transition state
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
    thread->set_thread_state((JavaThreadState)(from + 1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
46604
d409276ee40c 8183198: Factor out thread state serialization into a proper helper function
mgerdin
parents: 46373
diff changeset
   165
    InterfaceSupport::serialize_thread_state_with_handler(thread);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
    if (SafepointSynchronize::do_call_back()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
      SafepointSynchronize::block(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
    thread->set_thread_state(to);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
    CHECK_UNHANDLED_OOPS_ONLY(thread->clear_unhandled_oops();)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
  // Same as above, but assumes from = _thread_in_Java. This is simpler, since we
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
  // never block on entry to the VM. This will break the code, since e.g. preserve arguments
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
  // have not been setup.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
  static inline void transition_from_java(JavaThread *thread, JavaThreadState to) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
    assert(thread->thread_state() == _thread_in_Java, "coming from wrong thread state");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
    thread->set_thread_state(to);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
  static inline void transition_from_native(JavaThread *thread, JavaThreadState to) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
    assert((to & 1) == 0, "odd numbers are transitions states");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
    assert(thread->thread_state() == _thread_in_native, "coming from wrong thread state");
46373
e8e9b36783f3 8166927: interfaceSupport.hpp has ancient comments about TSO
dholmes
parents: 41084
diff changeset
   186
    // Change to transition state
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
    thread->set_thread_state(_thread_in_native_trans);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
46604
d409276ee40c 8183198: Factor out thread state serialization into a proper helper function
mgerdin
parents: 46373
diff changeset
   189
    InterfaceSupport::serialize_thread_state_with_handler(thread);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
    // We never install asynchronous exceptions when coming (back) in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
    // to the runtime from native code because the runtime is not set
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
    // up to handle exceptions floating around at arbitrary points.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
    if (SafepointSynchronize::do_call_back() || thread->is_suspend_after_native()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
      JavaThread::check_safepoint_and_suspend_for_native_trans(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
      // Clear unhandled oops anywhere where we could block, even if we don't.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
      CHECK_UNHANDLED_OOPS_ONLY(thread->clear_unhandled_oops();)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
    thread->set_thread_state(to);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
   void trans(JavaThreadState from, JavaThreadState to)  { transition(_thread, from, to); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
   void trans_from_java(JavaThreadState to)              { transition_from_java(_thread, to); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
   void trans_from_native(JavaThreadState to)            { transition_from_native(_thread, to); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
   void trans_and_fence(JavaThreadState from, JavaThreadState to) { transition_and_fence(_thread, from, to); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
class ThreadInVMfromJava : public ThreadStateTransition {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
  ThreadInVMfromJava(JavaThread* thread) : ThreadStateTransition(thread) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
    trans_from_java(_thread_in_vm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
  ~ThreadInVMfromJava()  {
40926
2fd1cf3e70e9 8137035: nsk/stress/stack/stack tests got EXCEPTION_STACK_OVERFLOW on Windows 64 bit
fparain
parents: 40010
diff changeset
   217
    if (_thread->stack_yellow_reserved_zone_disabled()) {
2fd1cf3e70e9 8137035: nsk/stress/stack/stack tests got EXCEPTION_STACK_OVERFLOW on Windows 64 bit
fparain
parents: 40010
diff changeset
   218
      _thread->enable_stack_yellow_reserved_zone();
2fd1cf3e70e9 8137035: nsk/stress/stack/stack tests got EXCEPTION_STACK_OVERFLOW on Windows 64 bit
fparain
parents: 40010
diff changeset
   219
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
    trans(_thread_in_vm, _thread_in_Java);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
    // Check for pending. async. exceptions or suspends.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
    if (_thread->has_special_runtime_exit_condition()) _thread->handle_special_runtime_exit_condition();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
class ThreadInVMfromUnknown {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
  JavaThread* _thread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
  ThreadInVMfromUnknown() : _thread(NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
    Thread* t = Thread::current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
    if (t->is_Java_thread()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
      JavaThread* t2 = (JavaThread*) t;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
      if (t2->thread_state() == _thread_in_native) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
        _thread = t2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
        ThreadStateTransition::transition_from_native(t2, _thread_in_vm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
        // Used to have a HandleMarkCleaner but that is dangerous as
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
        // it could free a handle in our (indirect, nested) caller.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
        // We expect any handles will be short lived and figure we
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
        // don't need an actual HandleMark.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
  ~ThreadInVMfromUnknown()  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
    if (_thread) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
      ThreadStateTransition::transition_and_fence(_thread, _thread_in_vm, _thread_in_native);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
class ThreadInVMfromNative : public ThreadStateTransition {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
  ThreadInVMfromNative(JavaThread* thread) : ThreadStateTransition(thread) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
    trans_from_native(_thread_in_vm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
  ~ThreadInVMfromNative() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
    trans_and_fence(_thread_in_vm, _thread_in_native);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
class ThreadToNativeFromVM : public ThreadStateTransition {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
  ThreadToNativeFromVM(JavaThread *thread) : ThreadStateTransition(thread) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
    // We are leaving the VM at this point and going directly to native code.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
    // Block, if we are in the middle of a safepoint synchronization.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
    assert(!thread->owns_locks(), "must release all locks when leaving VM");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
    thread->frame_anchor()->make_walkable(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
    trans_and_fence(_thread_in_vm, _thread_in_native);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
    // Check for pending. async. exceptions or suspends.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
    if (_thread->has_special_runtime_exit_condition()) _thread->handle_special_runtime_exit_condition(false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
  ~ThreadToNativeFromVM() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
    trans_from_native(_thread_in_vm);
41084
fc5db29fa08e 8164086: Checked JNI pending exception check should be cleared when returning to Java frame
dsimms
parents: 40926
diff changeset
   278
    assert(!_thread->is_pending_jni_exception_check(), "Pending JNI Exception Check");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
    // We don't need to clear_walkable because it will happen automagically when we return to java
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
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
class ThreadBlockInVM : public ThreadStateTransition {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
  ThreadBlockInVM(JavaThread *thread)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
  : ThreadStateTransition(thread) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
    // Once we are blocked vm expects stack to be walkable
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
    thread->frame_anchor()->make_walkable(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
    trans_and_fence(_thread_in_vm, _thread_blocked);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
  ~ThreadBlockInVM() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
    trans_and_fence(_thread_blocked, _thread_in_vm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
    // We don't need to clear_walkable because it will happen automagically when we return to java
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
// This special transition class is only used to prevent asynchronous exceptions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
// from being installed on vm exit in situations where we can't tolerate them.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
// See bugs: 4324348, 4854693, 4998314, 5040492, 5050705.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
class ThreadInVMfromJavaNoAsyncException : public ThreadStateTransition {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
  ThreadInVMfromJavaNoAsyncException(JavaThread* thread) : ThreadStateTransition(thread) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
    trans_from_java(_thread_in_vm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
  ~ThreadInVMfromJavaNoAsyncException()  {
40926
2fd1cf3e70e9 8137035: nsk/stress/stack/stack tests got EXCEPTION_STACK_OVERFLOW on Windows 64 bit
fparain
parents: 40010
diff changeset
   308
    if (_thread->stack_yellow_reserved_zone_disabled()) {
2fd1cf3e70e9 8137035: nsk/stress/stack/stack tests got EXCEPTION_STACK_OVERFLOW on Windows 64 bit
fparain
parents: 40010
diff changeset
   309
      _thread->enable_stack_yellow_reserved_zone();
2fd1cf3e70e9 8137035: nsk/stress/stack/stack tests got EXCEPTION_STACK_OVERFLOW on Windows 64 bit
fparain
parents: 40010
diff changeset
   310
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
    trans(_thread_in_vm, _thread_in_Java);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
    // NOTE: We do not check for pending. async. exceptions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
    // If we did and moved the pending async exception over into the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
    // pending exception field, we would need to deopt (currently C2
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
    // only). However, to do so would require that we transition back
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
    // to the _thread_in_vm state. Instead we postpone the handling of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
    // the async exception.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
40926
2fd1cf3e70e9 8137035: nsk/stress/stack/stack tests got EXCEPTION_STACK_OVERFLOW on Windows 64 bit
fparain
parents: 40010
diff changeset
   319
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
    // Check for pending. suspends only.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
    if (_thread->has_special_runtime_exit_condition())
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
      _thread->handle_special_runtime_exit_condition(false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
// Debug class instantiated in JRT_ENTRY and ITR_ENTRY macro.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
// Can be used to verify properties on enter/exit of the VM.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
class VMEntryWrapper {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
  VMEntryWrapper() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
    if (VerifyLastFrame) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
      InterfaceSupport::verify_last_frame();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
  ~VMEntryWrapper() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
    InterfaceSupport::check_gc_alot();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
    if (WalkStackALot) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
      InterfaceSupport::walk_stack();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
#ifdef COMPILER2
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
    // This option is not used by Compiler 1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
    if (StressDerivedPointers) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
      InterfaceSupport::stress_derived_pointers();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
    if (DeoptimizeALot || DeoptimizeRandom) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
      InterfaceSupport::deoptimizeAll();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
    if (ZombieALot) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
      InterfaceSupport::zombieAll();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
    }
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   355
    if (UnlinkSymbolsALot) {
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   356
      InterfaceSupport::unlinkSymbols();
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   357
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
    // do verification AFTER potential deoptimization
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
    if (VerifyStack) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
      InterfaceSupport::verify_stack();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
class VMNativeEntryWrapper {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
  VMNativeEntryWrapper() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
    if (GCALotAtAllSafepoints) InterfaceSupport::check_gc_alot();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
  ~VMNativeEntryWrapper() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
    if (GCALotAtAllSafepoints) InterfaceSupport::check_gc_alot();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
};
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
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
// VM-internal runtime interface support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
class RuntimeHistogramElement : public HistogramElement {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
  public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
   RuntimeHistogramElement(const char* name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
#define TRACE_CALL(result_type, header)                            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
  InterfaceSupport::_number_of_calls++;                            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
  if (CountRuntimeCalls) {                                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
    static RuntimeHistogramElement* e = new RuntimeHistogramElement(#header); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
    if (e != NULL) e->increment_count();                           \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
#define TRACE_CALL(result_type, header)                            \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
  /* do nothing */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
// LEAF routines do not lock, GC or throw exceptions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
10969
3ecf25293e5a 7103224: collision between __LEAF define in interfaceSupport.hpp and /usr/include/sys/cdefs.h with gcc
never
parents: 10565
diff changeset
   404
#define VM_LEAF_BASE(result_type, header)                            \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
  TRACE_CALL(result_type, header)                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
  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
   407
  os::verify_stack_alignment();                                      \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
  /* begin of body */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
36086
f70e100d3195 8141491: Unaligned memory access in Bits.c
mikael
parents: 35492
diff changeset
   410
#define VM_ENTRY_BASE_FROM_LEAF(result_type, header, thread)         \
f70e100d3195 8141491: Unaligned memory access in Bits.c
mikael
parents: 35492
diff changeset
   411
  TRACE_CALL(result_type, header)                                    \
f70e100d3195 8141491: Unaligned memory access in Bits.c
mikael
parents: 35492
diff changeset
   412
  debug_only(ResetNoHandleMark __rnhm;)                              \
f70e100d3195 8141491: Unaligned memory access in Bits.c
mikael
parents: 35492
diff changeset
   413
  HandleMarkCleaner __hm(thread);                                    \
f70e100d3195 8141491: Unaligned memory access in Bits.c
mikael
parents: 35492
diff changeset
   414
  Thread* THREAD = thread;                                           \
f70e100d3195 8141491: Unaligned memory access in Bits.c
mikael
parents: 35492
diff changeset
   415
  os::verify_stack_alignment();                                      \
f70e100d3195 8141491: Unaligned memory access in Bits.c
mikael
parents: 35492
diff changeset
   416
  /* begin of body */
f70e100d3195 8141491: Unaligned memory access in Bits.c
mikael
parents: 35492
diff changeset
   417
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
// ENTRY routines may lock, GC and throw exceptions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
10969
3ecf25293e5a 7103224: collision between __LEAF define in interfaceSupport.hpp and /usr/include/sys/cdefs.h with gcc
never
parents: 10565
diff changeset
   421
#define VM_ENTRY_BASE(result_type, header, thread)                   \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
  TRACE_CALL(result_type, header)                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
  HandleMarkCleaner __hm(thread);                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
  Thread* THREAD = thread;                                           \
11961
0abd4cd26e5a 7147740: add assertions to check stack alignment on VM entry from generated code (x64)
roland
parents: 10969
diff changeset
   425
  os::verify_stack_alignment();                                      \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
  /* begin of body */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
// QUICK_ENTRY routines behave like ENTRY but without a handle mark
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
10969
3ecf25293e5a 7103224: collision between __LEAF define in interfaceSupport.hpp and /usr/include/sys/cdefs.h with gcc
never
parents: 10565
diff changeset
   431
#define VM_QUICK_ENTRY_BASE(result_type, header, thread)             \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
  TRACE_CALL(result_type, header)                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
  debug_only(NoHandleMark __hm;)                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
  Thread* THREAD = thread;                                           \
11961
0abd4cd26e5a 7147740: add assertions to check stack alignment on VM entry from generated code (x64)
roland
parents: 10969
diff changeset
   435
  os::verify_stack_alignment();                                      \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
  /* begin of body */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
// Definitions for IRT (Interpreter Runtime)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
// (thread is an argument passed in to all these routines)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
#define IRT_ENTRY(result_type, header)                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
  result_type header {                                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
    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
   445
    VM_ENTRY_BASE(result_type, header, thread)                       \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
    debug_only(VMEntryWrapper __vew;)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
#define IRT_LEAF(result_type, header)                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
  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
   451
    VM_LEAF_BASE(result_type, header)                                \
35492
c8c0273e6b91 8146690: Make all classes in GC follow the naming convention.
david
parents: 34633
diff changeset
   452
    debug_only(NoSafepointVerifier __nspv(true);)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
#define IRT_ENTRY_NO_ASYNC(result_type, header)                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
  result_type header {                                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
    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
   458
    VM_ENTRY_BASE(result_type, header, thread)                       \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
    debug_only(VMEntryWrapper __vew;)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
#define IRT_END }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
// Definitions for JRT (Java (Compiler/Shared) Runtime)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
#define JRT_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 JRT_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)                                  \
35492
c8c0273e6b91 8146690: Make all classes in GC follow the naming convention.
david
parents: 34633
diff changeset
   476
  debug_only(JRTLeafVerifier __jlv;)
1
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 JRT_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
// Same as JRT Entry but allows for return value after the safepoint
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
// to get back into Java from the VM
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
#define JRT_BLOCK_ENTRY(result_type, header)                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
  result_type header {                                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
    TRACE_CALL(result_type, header)                                  \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
    HandleMarkCleaner __hm(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
#define JRT_BLOCK                                                    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
    {                                                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
    ThreadInVMfromJava __tiv(thread);                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
    Thread* THREAD = thread;                                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
    debug_only(VMEntryWrapper __vew;)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
29070
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 22838
diff changeset
   498
#define JRT_BLOCK_NO_ASYNC                                           \
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 22838
diff changeset
   499
    {                                                                \
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 22838
diff changeset
   500
    ThreadInVMfromJavaNoAsyncException __tiv(thread);                \
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 22838
diff changeset
   501
    Thread* THREAD = thread;                                         \
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 22838
diff changeset
   502
    debug_only(VMEntryWrapper __vew;)
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 22838
diff changeset
   503
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
#define JRT_BLOCK_END }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
#define JRT_END }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
// Definitions for JNI
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
#define JNI_ENTRY(result_type, header)                               \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
    JNI_ENTRY_NO_PRESERVE(result_type, header)                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
    WeakPreserveExceptionMark __wem(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
36551
77f29c57ed2e 8149159: Clean up Unsafe
mikael
parents: 36086
diff changeset
   514
#define JNI_ENTRY_NO_PRESERVE(result_type, header)                   \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
extern "C" {                                                         \
36551
77f29c57ed2e 8149159: Clean up Unsafe
mikael
parents: 36086
diff changeset
   516
  result_type JNICALL header {                                       \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
    JavaThread* thread=JavaThread::thread_from_jni_environment(env); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
    assert( !VerifyJNIEnvThread || (thread == Thread::current()), "JNIEnv is only valid in same thread"); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
    ThreadInVMfromNative __tiv(thread);                              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
    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
   521
    VM_ENTRY_BASE(result_type, header, thread)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
// 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
   525
// a GC, is called outside the NoHandleMark (set via VM_QUICK_ENTRY_BASE).
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
#define JNI_QUICK_ENTRY(result_type, header)                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
extern "C" {                                                         \
36551
77f29c57ed2e 8149159: Clean up Unsafe
mikael
parents: 36086
diff changeset
   528
  result_type JNICALL header {                                       \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
    JavaThread* thread=JavaThread::thread_from_jni_environment(env); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
    assert( !VerifyJNIEnvThread || (thread == Thread::current()), "JNIEnv is only valid in same thread"); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
    ThreadInVMfromNative __tiv(thread);                              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
    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
   533
    VM_QUICK_ENTRY_BASE(result_type, header, thread)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
#define JNI_LEAF(result_type, header)                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
extern "C" {                                                         \
36551
77f29c57ed2e 8149159: Clean up Unsafe
mikael
parents: 36086
diff changeset
   538
  result_type JNICALL header {                                       \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
    JavaThread* thread=JavaThread::thread_from_jni_environment(env); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
    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
   541
    VM_LEAF_BASE(result_type, header)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
// Close the routine and the extern "C"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
#define JNI_END } }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
// Definitions for JVM
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
#define JVM_ENTRY(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
    ThreadInVMfromNative __tiv(thread);                              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
    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
   557
    VM_ENTRY_BASE(result_type, header, thread)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
#define JVM_ENTRY_NO_ENV(result_type, header)                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
extern "C" {                                                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
  result_type JNICALL header {                                       \
34633
2a6c7c7b30a7 8132510: Replace ThreadLocalStorage with compiler/language-based thread-local variables
dholmes
parents: 34285
diff changeset
   563
    JavaThread* thread = JavaThread::current();                      \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
    ThreadInVMfromNative __tiv(thread);                              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
    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
   566
    VM_ENTRY_BASE(result_type, header, thread)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
#define JVM_QUICK_ENTRY(result_type, header)                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
extern "C" {                                                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
  result_type JNICALL header {                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
    JavaThread* thread=JavaThread::thread_from_jni_environment(env); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
    ThreadInVMfromNative __tiv(thread);                              \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
    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
   575
    VM_QUICK_ENTRY_BASE(result_type, header, thread)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
#define JVM_LEAF(result_type, header)                                \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
extern "C" {                                                         \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
  result_type JNICALL header {                                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
    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
   582
    VM_LEAF_BASE(result_type, header)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
36086
f70e100d3195 8141491: Unaligned memory access in Bits.c
mikael
parents: 35492
diff changeset
   585
#define JVM_ENTRY_FROM_LEAF(env, result_type, header)                \
f70e100d3195 8141491: Unaligned memory access in Bits.c
mikael
parents: 35492
diff changeset
   586
  { {                                                                \
f70e100d3195 8141491: Unaligned memory access in Bits.c
mikael
parents: 35492
diff changeset
   587
    JavaThread* thread=JavaThread::thread_from_jni_environment(env); \
f70e100d3195 8141491: Unaligned memory access in Bits.c
mikael
parents: 35492
diff changeset
   588
    ThreadInVMfromNative __tiv(thread);                              \
f70e100d3195 8141491: Unaligned memory access in Bits.c
mikael
parents: 35492
diff changeset
   589
    debug_only(VMNativeEntryWrapper __vew;)                          \
f70e100d3195 8141491: Unaligned memory access in Bits.c
mikael
parents: 35492
diff changeset
   590
    VM_ENTRY_BASE_FROM_LEAF(result_type, header, thread)
f70e100d3195 8141491: Unaligned memory access in Bits.c
mikael
parents: 35492
diff changeset
   591
f70e100d3195 8141491: Unaligned memory access in Bits.c
mikael
parents: 35492
diff changeset
   592
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
#define JVM_END } }
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
   594
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
   595
#endif // SHARE_VM_RUNTIME_INTERFACESUPPORT_HPP