src/hotspot/share/runtime/javaCalls.cpp
author erikj
Tue, 12 Sep 2017 19:03:39 +0200
changeset 47216 71c04702a3d5
parent 47103 hotspot/src/share/vm/runtime/javaCalls.cpp@a993ec29ec75
child 49192 6734eeef4283
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
/*
44406
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
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: 5419
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5419
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: 5419
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: 6453
diff changeset
    25
#include "precompiled.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    26
#include "classfile/systemDictionary.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    27
#include "classfile/vmSymbols.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    28
#include "code/nmethod.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    29
#include "compiler/compileBroker.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    30
#include "interpreter/interpreter.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    31
#include "interpreter/linkResolver.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    32
#include "memory/universe.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    33
#include "oops/oop.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    34
#include "prims/jniCheck.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    35
#include "runtime/compilationPolicy.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    36
#include "runtime/handles.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    37
#include "runtime/interfaceSupport.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    38
#include "runtime/javaCalls.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    39
#include "runtime/mutexLocker.hpp"
25468
5331df506290 8048241: Introduce umbrella header os.inline.hpp and clean up includes
goetz
parents: 22775
diff changeset
    40
#include "runtime/os.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    41
#include "runtime/signature.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    42
#include "runtime/stubRoutines.hpp"
14583
d70ee55535f4 8003935: Simplify the needed includes for using Thread::current()
stefank
parents: 14391
diff changeset
    43
#include "runtime/thread.inline.hpp"
33160
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 31019
diff changeset
    44
#if INCLUDE_JVMCI
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 31019
diff changeset
    45
#include "jvmci/jvmciJavaClasses.hpp"
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 31019
diff changeset
    46
#include "jvmci/jvmciRuntime.hpp"
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 31019
diff changeset
    47
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
// -----------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
// Implementation of JavaCallWrapper
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
46727
6e4a84748e2c 8183039: Re-examine methodHandle methods uninlined by 8144256
coleenp
parents: 46630
diff changeset
    52
JavaCallWrapper::JavaCallWrapper(const methodHandle& callee_method, Handle receiver, JavaValue* result, TRAPS) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
  JavaThread* thread = (JavaThread *)THREAD;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
  bool clear_pending_exception = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
  guarantee(thread->is_Java_thread(), "crucial check - the VM thread cannot and must not escape to Java code");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
  assert(!thread->owns_locks(), "must release all locks when leaving VM");
33160
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 31019
diff changeset
    58
  guarantee(thread->can_call_java(), "cannot make java calls from the native compiler");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
  _result   = result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
  // Allocate handle block for Java code. This must be done before we change thread_state to _thread_in_Java_or_stub,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
  // since it can potentially block.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
  JNIHandleBlock* new_handles = JNIHandleBlock::allocate_block(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
  // After this, we are official in JavaCode. This needs to be done before we change any of the thread local
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
  // info, since we cannot find oops before the new information is set up completely.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
  ThreadStateTransition::transition(thread, _thread_in_vm, _thread_in_Java);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
  // Make sure that we handle asynchronous stops and suspends _before_ we clear all thread state
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
  // in JavaCallWrapper::JavaCallWrapper(). This way, we can decide if we need to do any pd actions
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
  // to prepare for stop/suspend (flush register windows on sparcs, cache sp, or other state).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
  if (thread->has_special_runtime_exit_condition()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
    thread->handle_special_runtime_exit_condition();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
    if (HAS_PENDING_EXCEPTION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
      clear_pending_exception = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
  // Make sure to set the oop's after the thread transition - since we can block there. No one is GC'ing
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
  // the JavaCallWrapper before the entry frame is on the stack.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
  _callee_method = callee_method();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
  _receiver = receiver();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
#ifdef CHECK_UNHANDLED_OOPS
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
  THREAD->allow_unhandled_oop(&_receiver);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
#endif // CHECK_UNHANDLED_OOPS
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
  _thread       = (JavaThread *)thread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
  _handles      = _thread->active_handles();    // save previous handle block & Java frame linkage
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
  // For the profiler, the last_Java_frame information in thread must always be in
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
  // legal state. We have no last Java frame if last_Java_sp == NULL so
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
  // the valid transition is to clear _last_Java_sp and then reset the rest of
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
  // the (platform specific) state.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
  _anchor.copy(_thread->frame_anchor());
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
  _thread->frame_anchor()->clear();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
  debug_only(_thread->inc_java_call_counter());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
  _thread->set_active_handles(new_handles);     // install new handle block and reset Java frame linkage
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  assert (_thread->thread_state() != _thread_in_native, "cannot set native pc to NULL");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
  // clear any pending exception in thread (native calls start with no exception pending)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
  if(clear_pending_exception) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
    _thread->clear_pending_exception();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
  if (_anchor.last_Java_sp() == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
    _thread->record_base_of_stack_pointer();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
JavaCallWrapper::~JavaCallWrapper() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
  assert(_thread == JavaThread::current(), "must still be the same thread");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
  // restore previous handle block & Java frame linkage
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
  JNIHandleBlock *_old_handles = _thread->active_handles();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
  _thread->set_active_handles(_handles);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
  _thread->frame_anchor()->zap();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
  debug_only(_thread->dec_java_call_counter());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
  if (_anchor.last_Java_sp() == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
    _thread->set_base_of_stack_pointer(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
  // Old thread-local info. has been restored. We are not back in the VM.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
  ThreadStateTransition::transition_from_java(_thread, _thread_in_vm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
  // State has been restored now make the anchor frame visible for the profiler.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
  // Do this after the transition because this allows us to put an assert
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
  // the Java->vm transition which checks to see that stack is not walkable
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
  // on sparc/ia64 which will catch violations of the reseting of last_Java_frame
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
  // invariants (i.e. _flags always cleared on return to Java)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
  _thread->frame_anchor()->copy(&_anchor);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
  // Release handles after we are marked as being inside the VM again, since this
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
  // operation might block
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
  JNIHandleBlock::release_block(_old_handles, _thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
void JavaCallWrapper::oops_do(OopClosure* f) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
  f->do_oop((oop*)&_receiver);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
  handles()->oops_do(f);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
// Helper methods
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
static BasicType runtime_type_from(JavaValue* result) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
  switch (result->get_type()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
    case T_BOOLEAN: // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
    case T_CHAR   : // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
    case T_SHORT  : // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
    case T_INT    : // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
#ifndef _LP64
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
    case T_OBJECT : // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
    case T_ARRAY  : // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
    case T_BYTE   : // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
    case T_VOID   : return T_INT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
    case T_LONG   : return T_LONG;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
    case T_FLOAT  : return T_FLOAT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
    case T_DOUBLE : return T_DOUBLE;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
#ifdef _LP64
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
    case T_ARRAY  : // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
    case T_OBJECT:  return T_OBJECT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
#endif
46630
75aa3e39d02c 8182299: Enable disabled clang warnings, build on OSX 10 + Xcode 8
jwilhelm
parents: 46458
diff changeset
   175
    default:
75aa3e39d02c 8182299: Enable disabled clang warnings, build on OSX 10 + Xcode 8
jwilhelm
parents: 46458
diff changeset
   176
      ShouldNotReachHere();
75aa3e39d02c 8182299: Enable disabled clang warnings, build on OSX 10 + Xcode 8
jwilhelm
parents: 46458
diff changeset
   177
      return T_ILLEGAL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
// ============ Virtual calls ============
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   183
void JavaCalls::call_virtual(JavaValue* result, Klass* spec_klass, Symbol* name, Symbol* signature, JavaCallArguments* args, TRAPS) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
  CallInfo callinfo;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
  Handle receiver = args->receiver();
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   186
  Klass* recvrKlass = receiver.is_null() ? (Klass*)NULL : receiver->klass();
38719
133bf85c3f36 8145148: InterfaceMethod CP entry pointing to a class should cause ICCE
coleenp
parents: 38139
diff changeset
   187
  LinkInfo link_info(spec_klass, name, signature);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
  LinkResolver::resolve_virtual_call(
31019
d05fcdd70109 8029567: Clean up linkResolver code
coleenp
parents: 27157
diff changeset
   189
          callinfo, receiver, recvrKlass, link_info, true, CHECK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
  methodHandle method = callinfo.selected_method();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
  assert(method.not_null(), "should have thrown exception");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
  // Invoke the method
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
  JavaCalls::call(result, method, args, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   198
void JavaCalls::call_virtual(JavaValue* result, Handle receiver, Klass* spec_klass, Symbol* name, Symbol* signature, TRAPS) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
  JavaCallArguments args(receiver); // One oop argument
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
  call_virtual(result, spec_klass, name, signature, &args, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   204
void JavaCalls::call_virtual(JavaValue* result, Handle receiver, Klass* spec_klass, Symbol* name, Symbol* signature, Handle arg1, TRAPS) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
  JavaCallArguments args(receiver); // One oop argument
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
  args.push_oop(arg1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
  call_virtual(result, spec_klass, name, signature, &args, CHECK);
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
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   212
void JavaCalls::call_virtual(JavaValue* result, Handle receiver, Klass* spec_klass, Symbol* name, Symbol* signature, Handle arg1, Handle arg2, TRAPS) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
  JavaCallArguments args(receiver); // One oop argument
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
  args.push_oop(arg1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
  args.push_oop(arg2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
  call_virtual(result, spec_klass, name, signature, &args, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
// ============ Special calls ============
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   222
void JavaCalls::call_special(JavaValue* result, Klass* klass, Symbol* name, Symbol* signature, JavaCallArguments* args, TRAPS) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
  CallInfo callinfo;
38719
133bf85c3f36 8145148: InterfaceMethod CP entry pointing to a class should cause ICCE
coleenp
parents: 38139
diff changeset
   224
  LinkInfo link_info(klass, name, signature);
44738
11431bbc9549 8168699: Validate special case invocations
coleenp
parents: 44406
diff changeset
   225
  LinkResolver::resolve_special_call(callinfo, args->receiver(), link_info, CHECK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
  methodHandle method = callinfo.selected_method();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
  assert(method.not_null(), "should have thrown exception");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
  // Invoke the method
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
  JavaCalls::call(result, method, args, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   234
void JavaCalls::call_special(JavaValue* result, Handle receiver, Klass* klass, Symbol* name, Symbol* signature, TRAPS) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
  JavaCallArguments args(receiver); // One oop argument
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
  call_special(result, klass, name, signature, &args, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   240
void JavaCalls::call_special(JavaValue* result, Handle receiver, Klass* klass, Symbol* name, Symbol* signature, Handle arg1, TRAPS) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
  JavaCallArguments args(receiver); // One oop argument
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
  args.push_oop(arg1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
  call_special(result, klass, name, signature, &args, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   247
void JavaCalls::call_special(JavaValue* result, Handle receiver, Klass* klass, Symbol* name, Symbol* signature, Handle arg1, Handle arg2, TRAPS) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
  JavaCallArguments args(receiver); // One oop argument
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
  args.push_oop(arg1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
  args.push_oop(arg2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
  call_special(result, klass, name, signature, &args, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
// ============ Static calls ============
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   257
void JavaCalls::call_static(JavaValue* result, Klass* klass, Symbol* name, Symbol* signature, JavaCallArguments* args, TRAPS) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
  CallInfo callinfo;
38719
133bf85c3f36 8145148: InterfaceMethod CP entry pointing to a class should cause ICCE
coleenp
parents: 38139
diff changeset
   259
  LinkInfo link_info(klass, name, signature);
31019
d05fcdd70109 8029567: Clean up linkResolver code
coleenp
parents: 27157
diff changeset
   260
  LinkResolver::resolve_static_call(callinfo, link_info, true, CHECK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
  methodHandle method = callinfo.selected_method();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
  assert(method.not_null(), "should have thrown exception");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
  // Invoke the method
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
  JavaCalls::call(result, method, args, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   269
void JavaCalls::call_static(JavaValue* result, Klass* klass, Symbol* name, Symbol* signature, TRAPS) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
  JavaCallArguments args; // No argument
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
  call_static(result, klass, name, signature, &args, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   275
void JavaCalls::call_static(JavaValue* result, Klass* klass, Symbol* name, Symbol* signature, Handle arg1, TRAPS) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
  JavaCallArguments args(arg1); // One oop argument
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
  call_static(result, klass, name, signature, &args, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   281
void JavaCalls::call_static(JavaValue* result, Klass* klass, Symbol* name, Symbol* signature, Handle arg1, Handle arg2, TRAPS) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
  JavaCallArguments args; // One oop argument
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
  args.push_oop(arg1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
  args.push_oop(arg2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
  call_static(result, klass, name, signature, &args, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   289
void JavaCalls::call_static(JavaValue* result, Klass* klass, Symbol* name, Symbol* signature, Handle arg1, Handle arg2, Handle arg3, TRAPS) {
42307
cefc81dc1d52 8169069: Module system implementation refresh (11/2016)
alanb
parents: 39390
diff changeset
   290
  JavaCallArguments args; // One oop argument
cefc81dc1d52 8169069: Module system implementation refresh (11/2016)
alanb
parents: 39390
diff changeset
   291
  args.push_oop(arg1);
cefc81dc1d52 8169069: Module system implementation refresh (11/2016)
alanb
parents: 39390
diff changeset
   292
  args.push_oop(arg2);
cefc81dc1d52 8169069: Module system implementation refresh (11/2016)
alanb
parents: 39390
diff changeset
   293
  args.push_oop(arg3);
cefc81dc1d52 8169069: Module system implementation refresh (11/2016)
alanb
parents: 39390
diff changeset
   294
  call_static(result, klass, name, signature, &args, CHECK);
cefc81dc1d52 8169069: Module system implementation refresh (11/2016)
alanb
parents: 39390
diff changeset
   295
}
cefc81dc1d52 8169069: Module system implementation refresh (11/2016)
alanb
parents: 39390
diff changeset
   296
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
// -------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
// Implementation of JavaCalls (low level)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
33593
60764a78fa5c 8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents: 33160
diff changeset
   301
void JavaCalls::call(JavaValue* result, const methodHandle& method, JavaCallArguments* args, TRAPS) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
  // Check if we need to wrap a potential OS exception handler around thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
  // This is used for e.g. Win32 structured exception handlers
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
  assert(THREAD->is_Java_thread(), "only JavaThreads can make JavaCalls");
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 20282
diff changeset
   305
  // Need to wrap each and every time, since there might be native code down the
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
  // stack that has installed its own exception handlers
33593
60764a78fa5c 8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents: 33160
diff changeset
   307
  os::os_exception_wrapper(call_helper, result, method, args, THREAD);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
33593
60764a78fa5c 8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents: 33160
diff changeset
   310
void JavaCalls::call_helper(JavaValue* result, const methodHandle& method, JavaCallArguments* args, TRAPS) {
26135
82b516c550f7 8046070: Class Data Sharing clean up and refactoring
iklam
parents: 25468
diff changeset
   311
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
  JavaThread* thread = (JavaThread*)THREAD;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
  assert(thread->is_Java_thread(), "must be called by a java thread");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
  assert(method.not_null(), "must have a method to call");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
  assert(!SafepointSynchronize::is_at_safepoint(), "call to Java code during VM operation");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
  assert(!thread->handle_area()->no_handle_mark_active(), "cannot call out to Java here");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
  CHECK_UNHANDLED_OOPS_ONLY(thread->clear_unhandled_oops();)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
33160
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 31019
diff changeset
   321
#if INCLUDE_JVMCI
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 31019
diff changeset
   322
  // Gets the nmethod (if any) that should be called instead of normal target
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 31019
diff changeset
   323
  nmethod* alternative_target = args->alternative_target();
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 31019
diff changeset
   324
  if (alternative_target == NULL) {
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 31019
diff changeset
   325
#endif
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 31019
diff changeset
   326
// Verify the arguments
1618
2d86b9b84aa5 6739363: Xcheck jni doesn't check native function arguments
poonam
parents: 1
diff changeset
   327
2d86b9b84aa5 6739363: Xcheck jni doesn't check native function arguments
poonam
parents: 1
diff changeset
   328
  if (CheckJNICalls)  {
44406
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   329
    args->verify(method, result->get_type());
1618
2d86b9b84aa5 6739363: Xcheck jni doesn't check native function arguments
poonam
parents: 1
diff changeset
   330
  }
44406
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   331
  else debug_only(args->verify(method, result->get_type()));
33160
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 31019
diff changeset
   332
#if INCLUDE_JVMCI
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 31019
diff changeset
   333
  }
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 31019
diff changeset
   334
#else
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
  // Ignore call if method is empty
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
  if (method->is_empty_method()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
    assert(result->get_type() == T_VOID, "an empty method must return a void value");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
  }
33160
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 31019
diff changeset
   341
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
#ifdef ASSERT
14391
df0a1573d5bd 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents: 13728
diff changeset
   344
  { InstanceKlass* holder = method->method_holder();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
    // A klass might not be initialized since JavaCall's might be used during the executing of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
    // the <clinit>. For example, a Thread.start might start executing on an object that is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
    // not fully initialized! (bad Java programming style)
22775
52bc5222f5f1 8026849: Fix typos in the GC code, part 2
jwilhelm
parents: 22551
diff changeset
   348
    assert(holder->is_linked(), "rewriting must have taken place");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
38139
cf6f5c1b7205 8152903: [JVMCI] CompilerToVM::resolveMethod should correctly handle private methods in interfaces
never
parents: 35479
diff changeset
   352
  CompilationPolicy::compile_if_required(method, CHECK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
  // Since the call stub sets up like the interpreter we call the from_interpreted_entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
  // so we can go compiled via a i2c. Otherwise initial entry method will always
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
  // run interpreted.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
  address entry_point = method->from_interpreted_entry();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
  if (JvmtiExport::can_post_interpreter_events() && thread->is_interp_only_mode()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
    entry_point = method->interpreter_entry();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
  // Figure out if the result value is an oop or not (Note: This is a different value
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
  // than result_type. result_type will be T_INT of oops. (it is about size)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
  BasicType result_type = runtime_type_from(result);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
  bool oop_result_flag = (result->get_type() == T_OBJECT || result->get_type() == T_ARRAY);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
  // NOTE: if we move the computation of the result_val_address inside
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
  // the call to call_stub, the optimizer produces wrong code.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
  intptr_t* result_val_address = (intptr_t*)(result->get_value_addr());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
  // Find receiver
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
  Handle receiver = (!method->is_static()) ? args->receiver() : Handle();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
35071
a0910b1d3e0d 8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents: 34238
diff changeset
   374
  // When we reenter Java, we need to reenable the reserved/yellow zone which
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
  // might already be disabled when we are in VM.
35071
a0910b1d3e0d 8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents: 34238
diff changeset
   376
  if (!thread->stack_guards_enabled()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
    thread->reguard_stack();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
  // Check that there are shadow pages available before changing thread state
39390
edf6a424a8b7 8159335: Fix problems with stack overflow handling.
goetz
parents: 38719
diff changeset
   381
  // to Java. Calculate current_stack_pointer here to make sure
edf6a424a8b7 8159335: Fix problems with stack overflow handling.
goetz
parents: 38719
diff changeset
   382
  // stack_shadow_pages_available() and bang_stack_shadow_pages() use the same sp.
edf6a424a8b7 8159335: Fix problems with stack overflow handling.
goetz
parents: 38719
diff changeset
   383
  address sp = os::current_stack_pointer();
edf6a424a8b7 8159335: Fix problems with stack overflow handling.
goetz
parents: 38719
diff changeset
   384
  if (!os::stack_shadow_pages_available(THREAD, method, sp)) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
    // Throw stack overflow exception with preinitialized exception.
9321
c29711c6ae35 7009923: JSR 292: VM crash in JavaThread::last_frame
coleenp
parents: 8921
diff changeset
   386
    Exceptions::throw_stack_overflow_exception(THREAD, __FILE__, __LINE__, method);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
    // Touch pages checked if the OS needs them to be touched to be mapped.
39390
edf6a424a8b7 8159335: Fix problems with stack overflow handling.
goetz
parents: 38719
diff changeset
   390
    os::map_stack_shadow_pages(sp);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
33160
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 31019
diff changeset
   393
#if INCLUDE_JVMCI
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 31019
diff changeset
   394
  if (alternative_target != NULL) {
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 31019
diff changeset
   395
    if (alternative_target->is_alive()) {
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 31019
diff changeset
   396
      thread->set_jvmci_alternate_call_target(alternative_target->verified_entry_point());
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 31019
diff changeset
   397
      entry_point = method->adapter()->get_i2c_entry();
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 31019
diff changeset
   398
    } else {
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 31019
diff changeset
   399
      THROW(vmSymbols::jdk_vm_ci_code_InvalidInstalledCodeException());
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 31019
diff changeset
   400
    }
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 31019
diff changeset
   401
  }
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 31019
diff changeset
   402
#endif
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 31019
diff changeset
   403
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
  // do call
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
  { JavaCallWrapper link(method, receiver, result, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
    { HandleMark hm(thread);  // HandleMark used by HandleMarkCleaner
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
      StubRoutines::call_stub()(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
        (address)&link,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
        // (intptr_t*)&(result->_value), // see NOTE above (compiler problem)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
        result_val_address,          // see NOTE above (compiler problem)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
        result_type,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
        method(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
        entry_point,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
        args->parameters(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
        args->size_of_parameters(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
        CHECK
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
      );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
      result = link.result();  // circumvent MS C++ 5.0 compiler bug (result is clobbered across call)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
      // Preserve oop return value across possible gc points
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
      if (oop_result_flag) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
        thread->set_vm_result((oop) result->get_jobject());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
  } // Exit JavaCallWrapper (can block - potential return oop must be preserved)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
  // Check if a thread stop or suspend should be executed
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
  // The following assert was not realistic.  Thread.stop can set that bit at any moment.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
  //assert(!thread->has_special_runtime_exit_condition(), "no async. exceptions should be installed");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
  // Restore possible oop return
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
  if (oop_result_flag) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
    result->set_jobject((jobject)thread->vm_result());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
    thread->set_vm_result(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
//--------------------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
// Implementation of JavaCallArguments
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
44406
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   443
inline bool is_value_state_indirect_oop(uint state) {
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   444
  assert(state != JavaCallArguments::value_state_oop,
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   445
         "Checking for handles after removal");
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   446
  assert(state < JavaCallArguments::value_state_limit,
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   447
         "Invalid value state %u", state);
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   448
  return state != JavaCallArguments::value_state_primitive;
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   449
}
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   450
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   451
inline oop resolve_indirect_oop(intptr_t value, uint state) {
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   452
  switch (state) {
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   453
  case JavaCallArguments::value_state_handle:
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   454
  {
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   455
    oop* ptr = reinterpret_cast<oop*>(value);
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   456
    return Handle::raw_resolve(ptr);
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   457
  }
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   458
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   459
  case JavaCallArguments::value_state_jobject:
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   460
  {
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   461
    jobject obj = reinterpret_cast<jobject>(value);
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   462
    return JNIHandles::resolve(obj);
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   463
  }
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   464
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   465
  default:
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   466
    ShouldNotReachHere();
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   467
    return NULL;
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   468
  }
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   469
}
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   470
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
intptr_t* JavaCallArguments::parameters() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
  // First convert all handles to oops
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
  for(int i = 0; i < _size; i++) {
44406
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   474
    uint state = _value_state[i];
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   475
    assert(state != value_state_oop, "Multiple handle conversions");
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   476
    if (is_value_state_indirect_oop(state)) {
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   477
      oop obj = resolve_indirect_oop(_value[i], state);
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   478
      _value[i] = cast_from_oop<intptr_t>(obj);
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   479
      _value_state[i] = value_state_oop;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
  // Return argument vector
5419
f2e8cc8c12ea 6943304: remove tagged stack interpreter
twisti
parents: 2526
diff changeset
   483
  return _value;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
class SignatureChekker : public SignatureIterator {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
 private:
44406
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   489
   int _pos;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
   BasicType _return_type;
44406
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   491
   u_char* _value_state;
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   492
   intptr_t* _value;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
  bool _is_return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
44406
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   497
  SignatureChekker(Symbol* signature,
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   498
                   BasicType return_type,
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   499
                   bool is_static,
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   500
                   u_char* value_state,
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   501
                   intptr_t* value) :
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   502
    SignatureIterator(signature),
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   503
    _pos(0),
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   504
    _return_type(return_type),
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   505
    _value_state(value_state),
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   506
    _value(value),
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   507
    _is_return(false)
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   508
  {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
    if (!is_static) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
      check_value(true); // Receiver must be an oop
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
  void check_value(bool type) {
44406
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   515
    uint state = _value_state[_pos++];
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   516
    if (type) {
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   517
      guarantee(is_value_state_indirect_oop(state),
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   518
                "signature does not match pushed arguments: %u at %d",
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   519
                state, _pos - 1);
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   520
    } else {
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   521
      guarantee(state == JavaCallArguments::value_state_primitive,
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   522
                "signature does not match pushed arguments: %u at %d",
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   523
                state, _pos - 1);
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   524
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
  void check_doing_return(bool state) { _is_return = state; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
  void check_return_type(BasicType t) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
    guarantee(_is_return && t == _return_type, "return type does not match");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
  void check_int(BasicType t) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
    if (_is_return) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
      check_return_type(t);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
      return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
    check_value(false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
  void check_double(BasicType t) { check_long(t); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
  void check_long(BasicType t) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
    if (_is_return) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
      check_return_type(t);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
      return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
    check_value(false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
    check_value(false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
  void check_obj(BasicType t) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
    if (_is_return) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
      check_return_type(t);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
      return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
    }
1618
2d86b9b84aa5 6739363: Xcheck jni doesn't check native function arguments
poonam
parents: 1
diff changeset
   558
44406
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   559
    intptr_t v = _value[_pos];
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   560
    if (v != 0) {
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   561
      // v is a "handle" referring to an oop, cast to integral type.
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   562
      // There shouldn't be any handles in very low memory.
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   563
      guarantee((size_t)v >= (size_t)os::vm_page_size(),
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   564
                "Bad JNI oop argument %d: " PTR_FORMAT, _pos, v);
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   565
      // Verify the pointee.
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   566
      oop vv = resolve_indirect_oop(v, _value_state[_pos]);
46968
9119841280f4 8160399: is_oop_or_null involves undefined behavior
coleenp
parents: 46727
diff changeset
   567
      guarantee(oopDesc::is_oop_or_null(vv, true),
44406
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   568
                "Bad JNI oop argument %d: " PTR_FORMAT " -> " PTR_FORMAT,
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   569
                _pos, v, p2i(vv));
1618
2d86b9b84aa5 6739363: Xcheck jni doesn't check native function arguments
poonam
parents: 1
diff changeset
   570
    }
2d86b9b84aa5 6739363: Xcheck jni doesn't check native function arguments
poonam
parents: 1
diff changeset
   571
44406
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   572
    check_value(true);          // Verify value state.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
  void do_bool()                       { check_int(T_BOOLEAN);       }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
  void do_char()                       { check_int(T_CHAR);          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
  void do_float()                      { check_int(T_FLOAT);         }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
  void do_double()                     { check_double(T_DOUBLE);     }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
  void do_byte()                       { check_int(T_BYTE);          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
  void do_short()                      { check_int(T_SHORT);         }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
  void do_int()                        { check_int(T_INT);           }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
  void do_long()                       { check_long(T_LONG);         }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
  void do_void()                       { check_return_type(T_VOID);  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
  void do_object(int begin, int end)   { check_obj(T_OBJECT);        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
  void do_array(int begin, int end)    { check_obj(T_OBJECT);        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
1618
2d86b9b84aa5 6739363: Xcheck jni doesn't check native function arguments
poonam
parents: 1
diff changeset
   588
44406
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   589
void JavaCallArguments::verify(const methodHandle& method, BasicType return_type) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
  guarantee(method->size_of_parameters() == size_of_parameters(), "wrong no. of arguments pushed");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
  // Treat T_OBJECT and T_ARRAY as the same
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
  if (return_type == T_ARRAY) return_type = T_OBJECT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
  // Check that oop information is correct
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   596
  Symbol* signature = method->signature();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
44406
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   598
  SignatureChekker sc(signature,
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   599
                      return_type,
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   600
                      method->is_static(),
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   601
                      _value_state,
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   602
                      _value);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
  sc.iterate_parameters();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
  sc.check_doing_return(true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
  sc.iterate_returntype();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
}