hotspot/src/share/vm/prims/jni.cpp
author stuefe
Tue, 15 Aug 2017 08:46:32 +0200
changeset 46955 c5a455ec08c0
parent 46589 f1c04490ded1
child 47106 bed18a111b90
permissions -rw-r--r--
8186199: [windows] JNI_DestroyJavaVM not covered by SEH Reviewed-by: dholmes, mdoerr
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
     2
 * Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved.
13958
f5598a86c223 7170638: Use DTRACE_PROBE[N] in JNI Set and SetStatic Field.
coleenp
parents: 13952
diff changeset
     3
 * Copyright (c) 2012 Red Hat, Inc.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    19
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5403
diff changeset
    20
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5403
diff changeset
    21
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5403
diff changeset
    22
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    25
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    26
#include "precompiled.hpp"
14477
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
    27
#include "ci/ciReplay.hpp"
13087
673ea6efaf18 7158800: Improve storage of symbol tables
coleenp
parents: 12939
diff changeset
    28
#include "classfile/altHashing.hpp"
34666
1c7168ea0034 8140485: Class load and creation cleanup
mgronlun
parents: 34649
diff changeset
    29
#include "classfile/classFileStream.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    30
#include "classfile/classLoader.hpp"
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36396
diff changeset
    31
#include "classfile/javaClasses.hpp"
35498
392b50de06c6 8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents: 35219
diff changeset
    32
#include "classfile/javaClasses.inline.hpp"
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36396
diff changeset
    33
#include "classfile/modules.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    34
#include "classfile/symbolTable.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    35
#include "classfile/systemDictionary.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    36
#include "classfile/vmSymbols.hpp"
30764
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30143
diff changeset
    37
#include "gc/shared/gcLocker.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    38
#include "interpreter/linkResolver.hpp"
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13087
diff changeset
    39
#include "memory/allocation.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    40
#include "memory/allocation.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    41
#include "memory/oopFactory.hpp"
37248
11a660dbbb8e 8132524: Missing includes to resourceArea.hpp
jprovino
parents: 37179
diff changeset
    42
#include "memory/resourceArea.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    43
#include "memory/universe.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    44
#include "oops/instanceKlass.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    45
#include "oops/instanceOop.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    46
#include "oops/markOop.hpp"
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
    47
#include "oops/method.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    48
#include "oops/objArrayKlass.hpp"
29081
c61eb4914428 8072911: Remove includes of oop.inline.hpp from .hpp files
stefank
parents: 27685
diff changeset
    49
#include "oops/objArrayOop.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    50
#include "oops/oop.inline.hpp"
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
    51
#include "oops/symbol.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    52
#include "oops/typeArrayKlass.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    53
#include "oops/typeArrayOop.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    54
#include "prims/jni.h"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    55
#include "prims/jniCheck.hpp"
11480
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents: 11247
diff changeset
    56
#include "prims/jniExport.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    57
#include "prims/jniFastGetField.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    58
#include "prims/jvm.h"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    59
#include "prims/jvm_misc.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    60
#include "prims/jvmtiExport.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    61
#include "prims/jvmtiThreadState.hpp"
40655
9f644073d3a0 8157907: Incorrect inclusion of atomic.hpp instead of atomic.inline.hpp
dholmes
parents: 38704
diff changeset
    62
#include "runtime/atomic.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    63
#include "runtime/compilationPolicy.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    64
#include "runtime/fieldDescriptor.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    65
#include "runtime/fprofiler.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    66
#include "runtime/handles.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    67
#include "runtime/interfaceSupport.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    68
#include "runtime/java.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    69
#include "runtime/javaCalls.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    70
#include "runtime/jfieldIDWorkaround.hpp"
24351
61b33cc6d3cf 8042195: Introduce umbrella header orderAccess.inline.hpp.
goetz
parents: 24237
diff changeset
    71
#include "runtime/orderAccess.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    72
#include "runtime/reflection.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    73
#include "runtime/sharedRuntime.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    74
#include "runtime/signature.hpp"
14583
d70ee55535f4 8003935: Simplify the needed includes for using Thread::current()
stefank
parents: 14490
diff changeset
    75
#include "runtime/thread.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    76
#include "runtime/vm_operations.hpp"
25946
1572c9f03fb9 8046598: Scalable Native memory tracking development
zgu
parents: 25633
diff changeset
    77
#include "services/memTracker.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    78
#include "services/runtimeService.hpp"
36384
b0b41336a9a8 8143226: Minor updates to Event Based tracing
mgronlun
parents: 36183
diff changeset
    79
#include "trace/traceMacros.hpp"
11480
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents: 11247
diff changeset
    80
#include "trace/tracing.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    81
#include "utilities/defaultStream.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    82
#include "utilities/dtrace.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    83
#include "utilities/events.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    84
#include "utilities/histogram.hpp"
35519
9200162499f7 8146994: Move internal vm tests to a separate file
ehelin
parents: 35500
diff changeset
    85
#include "utilities/internalVMTests.hpp"
27684
e0391b2bf625 8064581: Move INCLUDE_ALL_GCS include section to the end of the include list
stefank
parents: 27679
diff changeset
    86
#include "utilities/macros.hpp"
46589
f1c04490ded1 8182848: Some functions misplaced in debug.hpp
coleenp
parents: 46431
diff changeset
    87
#include "utilities/vmError.hpp"
27684
e0391b2bf625 8064581: Move INCLUDE_ALL_GCS include section to the end of the include list
stefank
parents: 27679
diff changeset
    88
#if INCLUDE_ALL_GCS
30764
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30143
diff changeset
    89
#include "gc/g1/g1SATBCardTableModRefBS.hpp"
27684
e0391b2bf625 8064581: Move INCLUDE_ALL_GCS include section to the end of the include list
stefank
parents: 27679
diff changeset
    90
#endif // INCLUDE_ALL_GCS
33160
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32598
diff changeset
    91
#if INCLUDE_JVMCI
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32598
diff changeset
    92
#include "jvmci/jvmciCompiler.hpp"
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32598
diff changeset
    93
#include "jvmci/jvmciRuntime.hpp"
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32598
diff changeset
    94
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
36396
26a241a959de 8145098: JNI GetVersion should return JNI_VERSION_9
rprotacio
parents: 36384
diff changeset
    96
static jint CurrentVersion = JNI_VERSION_9;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
30143
7e99f2b4bae5 8074860: Structured Exception Catcher missing around CreateJavaVM on Windows
stuefe
parents: 29081
diff changeset
    98
#ifdef _WIN32
7e99f2b4bae5 8074860: Structured Exception Catcher missing around CreateJavaVM on Windows
stuefe
parents: 29081
diff changeset
    99
extern LONG WINAPI topLevelExceptionFilter(_EXCEPTION_POINTERS* );
7e99f2b4bae5 8074860: Structured Exception Catcher missing around CreateJavaVM on Windows
stuefe
parents: 29081
diff changeset
   100
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
// The DT_RETURN_MARK macros create a scoped object to fire the dtrace
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
// '-return' probe regardless of the return path is taken out of the function.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
// Methods that have multiple return paths use this to avoid having to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
// instrument each return path.  Methods that use CHECK or THROW must use this
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
// since those macros can cause an immedate uninstrumented return.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
// In order to get the return value, a reference to the variable containing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
// the return value must be passed to the contructor of the object, and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
// the return value must be set before return (since the mark object has
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
// a reference to it).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
// Example:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
// DT_RETURN_MARK_DECL(SomeFunc, int);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
// JNI_ENTRY(int, SomeFunc, ...)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
//   int return_value = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
//   DT_RETURN_MARK(SomeFunc, int, (const int&)return_value);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
//   foo(CHECK_0)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
//   return_value = 5;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
//   return return_value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
// JNI_END
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   122
#define DT_RETURN_MARK_DECL(name, type, probe)                             \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   123
  DTRACE_ONLY(                                                             \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   124
    class DTraceReturnProbeMark_##name {                                   \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   125
     public:                                                               \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   126
      const type& _ret_ref;                                                \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   127
      DTraceReturnProbeMark_##name(const type& v) : _ret_ref(v) {}         \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   128
      ~DTraceReturnProbeMark_##name() {                                    \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   129
        probe;                                                             \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   130
      }                                                                    \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   131
    }                                                                      \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   132
  )
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   133
// Void functions are simpler since there's no return value
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   134
#define DT_VOID_RETURN_MARK_DECL(name, probe)                              \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   135
  DTRACE_ONLY(                                                             \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   136
    class DTraceReturnProbeMark_##name {                                   \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   137
     public:                                                               \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   138
      ~DTraceReturnProbeMark_##name() {                                    \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   139
        probe;                                                             \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   140
      }                                                                    \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   141
    }                                                                      \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   142
  )
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
// Place these macros in the function to mark the return.  Non-void
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
// functions need the type and address of the return value.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
#define DT_RETURN_MARK(name, type, ref) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
  DTRACE_ONLY( DTraceReturnProbeMark_##name dtrace_return_mark(ref) )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
#define DT_VOID_RETURN_MARK(name) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
  DTRACE_ONLY( DTraceReturnProbeMark_##name dtrace_return_mark )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
// Use these to select distinct code for floating-point vs. non-floating point
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
// situations.  Used from within common macros where we need slightly
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
// different behavior for Float/Double
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
#define FP_SELECT_Boolean(intcode, fpcode) intcode
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
#define FP_SELECT_Byte(intcode, fpcode)    intcode
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
#define FP_SELECT_Char(intcode, fpcode)    intcode
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
#define FP_SELECT_Short(intcode, fpcode)   intcode
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
#define FP_SELECT_Object(intcode, fpcode)  intcode
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
#define FP_SELECT_Int(intcode, fpcode)     intcode
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
#define FP_SELECT_Long(intcode, fpcode)    intcode
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
#define FP_SELECT_Float(intcode, fpcode)   fpcode
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
#define FP_SELECT_Double(intcode, fpcode)  fpcode
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
#define FP_SELECT(TypeName, intcode, fpcode) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
  FP_SELECT_##TypeName(intcode, fpcode)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
// Choose DT_RETURN_MARK macros  based on the type: float/double -> void
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
// (dtrace doesn't do FP yet)
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   169
#define DT_RETURN_MARK_DECL_FOR(TypeName, name, type, probe)    \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   170
  FP_SELECT(TypeName, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   171
    DT_RETURN_MARK_DECL(name, type, probe), DT_VOID_RETURN_MARK_DECL(name, probe) )
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
#define DT_RETURN_MARK_FOR(TypeName, name, type, ref) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
  FP_SELECT(TypeName, \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
    DT_RETURN_MARK(name, type, ref), DT_VOID_RETURN_MARK(name) )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
// out-of-line helpers for class jfieldIDWorkaround:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   179
bool jfieldIDWorkaround::is_valid_jfieldID(Klass* k, jfieldID id) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
  if (jfieldIDWorkaround::is_instance_jfieldID(k, id)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
    uintptr_t as_uint = (uintptr_t) id;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
    intptr_t offset = raw_instance_offset(id);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
    if (is_checked_jfieldID(id)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
      if (!klass_hash_ok(k, id)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
        return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
    }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   188
    return InstanceKlass::cast(k)->contains_field_offset(offset);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
    JNIid* result = (JNIid*) id;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
    return result != NULL && result->is_static_field_id();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
    return result != NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   200
intptr_t jfieldIDWorkaround::encode_klass_hash(Klass* k, intptr_t offset) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
  if (offset <= small_offset_mask) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   202
    Klass* field_klass = k;
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14391
diff changeset
   203
    Klass* super_klass = field_klass->super();
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   204
    // With compressed oops the most super class with nonstatic fields would
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   205
    // be the owner of fields embedded in the header.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   206
    while (InstanceKlass::cast(super_klass)->has_nonstatic_fields() &&
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   207
           InstanceKlass::cast(super_klass)->contains_field_offset(offset)) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
      field_klass = super_klass;   // super contains the field also
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14391
diff changeset
   209
      super_klass = field_klass->super();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
    }
35492
c8c0273e6b91 8146690: Make all classes in GC follow the naming convention.
david
parents: 35219
diff changeset
   211
    debug_only(NoSafepointVerifier nosafepoint;)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
    uintptr_t klass_hash = field_klass->identity_hash();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
    return ((klass_hash & klass_mask) << klass_shift) | checked_mask_in_place;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
#if 0
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
    #ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
    {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
      ResourceMark rm;
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14391
diff changeset
   219
      warning("VerifyJNIFields: long offset %d in %s", offset, k->external_name());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
    #endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
    return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   227
bool jfieldIDWorkaround::klass_hash_ok(Klass* k, jfieldID id) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
  uintptr_t as_uint = (uintptr_t) id;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
  intptr_t klass_hash = (as_uint >> klass_shift) & klass_mask;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
  do {
35492
c8c0273e6b91 8146690: Make all classes in GC follow the naming convention.
david
parents: 35219
diff changeset
   231
    debug_only(NoSafepointVerifier nosafepoint;)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
    // Could use a non-blocking query for identity_hash here...
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
    if ((k->identity_hash() & klass_mask) == klass_hash)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
      return true;
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14391
diff changeset
   235
    k = k->super();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
  } while (k != NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
  return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   240
void jfieldIDWorkaround::verify_instance_jfieldID(Klass* k, jfieldID id) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
  guarantee(jfieldIDWorkaround::is_instance_jfieldID(k, id), "must be an instance field" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
  uintptr_t as_uint = (uintptr_t) id;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
  intptr_t offset = raw_instance_offset(id);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
  if (VerifyJNIFields) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
    if (is_checked_jfieldID(id)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
      guarantee(klass_hash_ok(k, id),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
    "Bug in native code: jfieldID class must match object");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
#if 0
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
      #ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
      if (Verbose) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
  ResourceMark rm;
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14391
diff changeset
   253
  warning("VerifyJNIFields: unverified offset %d for %s", offset, k->external_name());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
      #endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
  }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   259
  guarantee(InstanceKlass::cast(k)->contains_field_offset(offset),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
      "Bug in native code: jfieldID offset must address interior of object");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
// Wrapper to trace JNI functions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
  Histogram* JNIHistogram;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
  static volatile jint JNIHistogram_lock = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
  class JNIHistogramElement : public HistogramElement {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
    public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
     JNIHistogramElement(const char* name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
  JNIHistogramElement::JNIHistogramElement(const char* elementName) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
    _name = elementName;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
    uintx count = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
    while (Atomic::cmpxchg(1, &JNIHistogram_lock, 0) != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
      while (OrderAccess::load_acquire(&JNIHistogram_lock) != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
        count +=1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
        if ( (WarnOnStalledSpinLock > 0)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
          && (count % WarnOnStalledSpinLock == 0)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
          warning("JNIHistogram_lock seems to be stalled");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
     }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
    if(JNIHistogram == NULL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
      JNIHistogram = new Histogram("JNI Call Counts",100);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
    JNIHistogram->add_element(this);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
    Atomic::dec(&JNIHistogram_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
  #define JNICountWrapper(arg)                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
     static JNIHistogramElement* e = new JNIHistogramElement(arg); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
      /* There is a MT-race condition in VC++. So we need to make sure that that e has been initialized */ \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
     if (e != NULL) e->increment_count()
34285
0b07014c15e9 8143155: Remove TraceRuntimeCalls, TraceJNICalls, and TraceJVMCalls rather than convert to UL
rprotacio
parents: 33813
diff changeset
   300
  #define JNIWrapper(arg) JNICountWrapper(arg);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
  #define JNIWrapper(arg)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
// Implementation of JNI entries
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   308
DT_RETURN_MARK_DECL(DefineClass, jclass
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   309
                    , HOTSPOT_JNI_DEFINECLASS_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
JNI_ENTRY(jclass, jni_DefineClass(JNIEnv *env, const char *name, jobject loaderRef,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
                                  const jbyte *buf, jsize bufLen))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
  JNIWrapper("DefineClass");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   315
  HOTSPOT_JNI_DEFINECLASS_ENTRY(
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   316
    env, (char*) name, loaderRef, (char*) buf, bufLen);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   317
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
  jclass cls = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
  DT_RETURN_MARK(DefineClass, jclass, (const jclass&)cls);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
12939
c0a910665895 7171703: JNI DefineClass crashes client VM when first parameter is NULL
fparain
parents: 11480
diff changeset
   321
  TempNewSymbol class_name = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
  // Since exceptions can be thrown, class initialization can take place
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
  // if name is NULL no check for class name in .class stream has to be made.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
  if (name != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
    const int str_len = (int)strlen(name);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
   326
    if (str_len > Symbol::max_length()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
      // It's impossible to create this class;  the name cannot fit
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
      // into the constant pool.
46431
87b0d1afe03e 8056900: Enhance NoClassDefFound exception messaging
hseigel
parents: 46369
diff changeset
   329
      Exceptions::fthrow(THREAD_AND_LOCATION,
87b0d1afe03e 8056900: Enhance NoClassDefFound exception messaging
hseigel
parents: 46369
diff changeset
   330
                         vmSymbols::java_lang_NoClassDefFoundError(),
87b0d1afe03e 8056900: Enhance NoClassDefFound exception messaging
hseigel
parents: 46369
diff changeset
   331
                         "Class name exceeds maximum length of %d: %s",
87b0d1afe03e 8056900: Enhance NoClassDefFound exception messaging
hseigel
parents: 46369
diff changeset
   332
                         Symbol::max_length(),
87b0d1afe03e 8056900: Enhance NoClassDefFound exception messaging
hseigel
parents: 46369
diff changeset
   333
                         name);
87b0d1afe03e 8056900: Enhance NoClassDefFound exception messaging
hseigel
parents: 46369
diff changeset
   334
      return 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
    }
12939
c0a910665895 7171703: JNI DefineClass crashes client VM when first parameter is NULL
fparain
parents: 11480
diff changeset
   336
    class_name = SymbolTable::new_symbol(name, CHECK_NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
  ResourceMark rm(THREAD);
34666
1c7168ea0034 8140485: Class load and creation cleanup
mgronlun
parents: 34649
diff changeset
   339
  ClassFileStream st((u1*)buf, bufLen, NULL, ClassFileStream::verify);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
  Handle class_loader (THREAD, JNIHandles::resolve(loaderRef));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
  if (UsePerfData && !class_loader.is_null()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
    // check whether the current caller thread holds the lock or not.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
    // If not, increment the corresponding counter
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
    if (ObjectSynchronizer::
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
        query_lock_ownership((JavaThread*)THREAD, class_loader) !=
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
        ObjectSynchronizer::owner_self) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
      ClassLoader::sync_JNIDefineClassLockFreeCounter()->inc();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
  }
34666
1c7168ea0034 8140485: Class load and creation cleanup
mgronlun
parents: 34649
diff changeset
   351
  Klass* k = SystemDictionary::resolve_from_stream(class_name,
1c7168ea0034 8140485: Class load and creation cleanup
mgronlun
parents: 34649
diff changeset
   352
                                                   class_loader,
1c7168ea0034 8140485: Class load and creation cleanup
mgronlun
parents: 34649
diff changeset
   353
                                                   Handle(),
1c7168ea0034 8140485: Class load and creation cleanup
mgronlun
parents: 34649
diff changeset
   354
                                                   &st,
1c7168ea0034 8140485: Class load and creation cleanup
mgronlun
parents: 34649
diff changeset
   355
                                                   CHECK_NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
38151
fffedc5e5cf8 8154110: Update class* and safepoint* logging subsystems
mockner
parents: 37483
diff changeset
   357
  if (log_is_enabled(Debug, class, resolve) && k != NULL) {
2269
ee9da33d43ab 6603316: Improve instrumentation for classes loaded at startup
acorn
parents: 2105
diff changeset
   358
    trace_class_resolution(k);
ee9da33d43ab 6603316: Improve instrumentation for classes loaded at startup
acorn
parents: 2105
diff changeset
   359
  }
ee9da33d43ab 6603316: Improve instrumentation for classes loaded at startup
acorn
parents: 2105
diff changeset
   360
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
  cls = (jclass)JNIHandles::make_local(
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14391
diff changeset
   362
    env, k->java_mirror());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
  return cls;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
static bool first_time_FindClass = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   370
DT_RETURN_MARK_DECL(FindClass, jclass
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   371
                    , HOTSPOT_JNI_FINDCLASS_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
JNI_ENTRY(jclass, jni_FindClass(JNIEnv *env, const char *name))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
  JNIWrapper("FindClass");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   375
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   376
  HOTSPOT_JNI_FINDCLASS_ENTRY(env, (char *)name);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
  jclass result = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
  DT_RETURN_MARK(FindClass, jclass, (const jclass&)result);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
  // Remember if we are the first invocation of jni_FindClass
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
  bool first_time = first_time_FindClass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
  first_time_FindClass = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
  // Sanity check the name:  it cannot be null or larger than the maximum size
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
  // name we can fit in the constant pool.
46431
87b0d1afe03e 8056900: Enhance NoClassDefFound exception messaging
hseigel
parents: 46369
diff changeset
   387
  if (name == NULL) {
87b0d1afe03e 8056900: Enhance NoClassDefFound exception messaging
hseigel
parents: 46369
diff changeset
   388
    THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), "No class name given");
87b0d1afe03e 8056900: Enhance NoClassDefFound exception messaging
hseigel
parents: 46369
diff changeset
   389
  }
87b0d1afe03e 8056900: Enhance NoClassDefFound exception messaging
hseigel
parents: 46369
diff changeset
   390
  if ((int)strlen(name) > Symbol::max_length()) {
87b0d1afe03e 8056900: Enhance NoClassDefFound exception messaging
hseigel
parents: 46369
diff changeset
   391
    Exceptions::fthrow(THREAD_AND_LOCATION,
87b0d1afe03e 8056900: Enhance NoClassDefFound exception messaging
hseigel
parents: 46369
diff changeset
   392
                       vmSymbols::java_lang_NoClassDefFoundError(),
87b0d1afe03e 8056900: Enhance NoClassDefFound exception messaging
hseigel
parents: 46369
diff changeset
   393
                       "Class name exceeds maximum length of %d: %s",
87b0d1afe03e 8056900: Enhance NoClassDefFound exception messaging
hseigel
parents: 46369
diff changeset
   394
                       Symbol::max_length(),
87b0d1afe03e 8056900: Enhance NoClassDefFound exception messaging
hseigel
parents: 46369
diff changeset
   395
                       name);
87b0d1afe03e 8056900: Enhance NoClassDefFound exception messaging
hseigel
parents: 46369
diff changeset
   396
    return 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
  //%note jni_3
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
  Handle loader;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
  Handle protection_domain;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
  // Find calling class
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   403
  Klass* k = thread->security_get_caller_class(0);
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   404
  if (k != NULL) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
    loader = Handle(THREAD, k->class_loader());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
    // Special handling to make sure JNI_OnLoad and JNI_OnUnload are executed
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
    // in the correct class context.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
    if (loader.is_null() &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
        k->name() == vmSymbols::java_lang_ClassLoader_NativeLibrary()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
      JavaValue result(T_OBJECT);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
      JavaCalls::call_static(&result, k,
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   412
                             vmSymbols::getFromClass_name(),
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   413
                             vmSymbols::void_class_signature(),
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   414
                             thread);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
      if (HAS_PENDING_EXCEPTION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
        Handle ex(thread, thread->pending_exception());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
        CLEAR_PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
        THROW_HANDLE_0(ex);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
      oop mirror = (oop) result.get_jobject();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
      loader = Handle(THREAD,
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   422
        InstanceKlass::cast(java_lang_Class::as_Klass(mirror))->class_loader());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
      protection_domain = Handle(THREAD,
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   424
        InstanceKlass::cast(java_lang_Class::as_Klass(mirror))->protection_domain());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
    // We call ClassLoader.getSystemClassLoader to obtain the system class loader.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
    loader = Handle(THREAD, SystemDictionary::java_system_loader());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
   431
  TempNewSymbol sym = SymbolTable::new_symbol(name, CHECK_NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
  result = find_class_from_class_loader(env, sym, true, loader,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
                                        protection_domain, true, thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
38151
fffedc5e5cf8 8154110: Update class* and safepoint* logging subsystems
mockner
parents: 37483
diff changeset
   435
  if (log_is_enabled(Debug, class, resolve) && result != NULL) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   436
    trace_class_resolution(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(result)));
2269
ee9da33d43ab 6603316: Improve instrumentation for classes loaded at startup
acorn
parents: 2105
diff changeset
   437
  }
ee9da33d43ab 6603316: Improve instrumentation for classes loaded at startup
acorn
parents: 2105
diff changeset
   438
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
  // If we were the first invocation of jni_FindClass, we enable compilation again
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
  // rather than just allowing invocation counter to overflow and decay.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
  // Controlled by flag DelayCompilationDuringStartup.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
  if (first_time && !CompileTheWorld)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
    CompilationPolicy::completed_vm_startup();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
  return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   448
DT_RETURN_MARK_DECL(FromReflectedMethod, jmethodID
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   449
                    , HOTSPOT_JNI_FROMREFLECTEDMETHOD_RETURN((uintptr_t)_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
JNI_ENTRY(jmethodID, jni_FromReflectedMethod(JNIEnv *env, jobject method))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
  JNIWrapper("FromReflectedMethod");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   453
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   454
  HOTSPOT_JNI_FROMREFLECTEDMETHOD_ENTRY(env, method);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   455
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
  jmethodID ret = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
  DT_RETURN_MARK(FromReflectedMethod, jmethodID, (const jmethodID&)ret);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
  // method is a handle to a java.lang.reflect.Method object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
  oop reflected  = JNIHandles::resolve_non_null(method);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
  oop mirror     = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
  int slot       = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
4571
80b553bddc26 6914300: ciEnv should export all well known classes
never
parents: 4561
diff changeset
   464
  if (reflected->klass() == SystemDictionary::reflect_Constructor_klass()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
    mirror = java_lang_reflect_Constructor::clazz(reflected);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
    slot   = java_lang_reflect_Constructor::slot(reflected);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
  } else {
4571
80b553bddc26 6914300: ciEnv should export all well known classes
never
parents: 4561
diff changeset
   468
    assert(reflected->klass() == SystemDictionary::reflect_Method_klass(), "wrong type");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
    mirror = java_lang_reflect_Method::clazz(reflected);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
    slot   = java_lang_reflect_Method::slot(reflected);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
  }
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   472
  Klass* k1 = java_lang_Class::as_Klass(mirror);
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   473
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
  // Make sure class is initialized before handing id's out to methods
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   475
  k1->initialize(CHECK_NULL);
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   476
  Method* m = InstanceKlass::cast(k1)->method_with_idnum(slot);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
  ret = m==NULL? NULL : m->jmethod_id();  // return NULL if reflected method deleted
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   481
DT_RETURN_MARK_DECL(FromReflectedField, jfieldID
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   482
                    , HOTSPOT_JNI_FROMREFLECTEDFIELD_RETURN((uintptr_t)_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
JNI_ENTRY(jfieldID, jni_FromReflectedField(JNIEnv *env, jobject field))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
  JNIWrapper("FromReflectedField");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   486
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   487
  HOTSPOT_JNI_FROMREFLECTEDFIELD_ENTRY(env, field);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   488
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
  jfieldID ret = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
  DT_RETURN_MARK(FromReflectedField, jfieldID, (const jfieldID&)ret);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
  // field is a handle to a java.lang.reflect.Field object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
  oop reflected   = JNIHandles::resolve_non_null(field);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
  oop mirror      = java_lang_reflect_Field::clazz(reflected);
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   495
  Klass* k1       = java_lang_Class::as_Klass(mirror);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
  int slot        = java_lang_reflect_Field::slot(reflected);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
  int modifiers   = java_lang_reflect_Field::modifiers(reflected);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
  // Make sure class is initialized before handing id's out to fields
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   500
  k1->initialize(CHECK_NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
  // First check if this is a static field
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
  if (modifiers & JVM_ACC_STATIC) {
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   504
    intptr_t offset = InstanceKlass::cast(k1)->field_offset( slot );
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   505
    JNIid* id = InstanceKlass::cast(k1)->jni_id_for(offset);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
    assert(id != NULL, "corrupt Field object");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
    debug_only(id->set_is_static_field_id();)
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   508
    // A jfieldID for a static field is a JNIid specifying the field holder and the offset within the Klass*
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
    ret = jfieldIDWorkaround::to_static_jfieldID(id);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
    return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
  // The slot is the index of the field description in the field-array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
  // The jfieldID is the offset of the field within the object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
  // It may also have hash bits for k, if VerifyJNIFields is turned on.
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   516
  intptr_t offset = InstanceKlass::cast(k1)->field_offset( slot );
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   517
  assert(InstanceKlass::cast(k1)->contains_field_offset(offset), "stay within object");
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   518
  ret = jfieldIDWorkaround::to_instance_jfieldID(k1, offset);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   522
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   523
DT_RETURN_MARK_DECL(ToReflectedMethod, jobject
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   524
                    , HOTSPOT_JNI_TOREFLECTEDMETHOD_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
JNI_ENTRY(jobject, jni_ToReflectedMethod(JNIEnv *env, jclass cls, jmethodID method_id, jboolean isStatic))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
  JNIWrapper("ToReflectedMethod");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   528
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   529
  HOTSPOT_JNI_TOREFLECTEDMETHOD_ENTRY(env, cls, (uintptr_t) method_id, isStatic);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   530
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
  jobject ret = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
  DT_RETURN_MARK(ToReflectedMethod, jobject, (const jobject&)ret);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   534
  methodHandle m (THREAD, Method::resolve_jmethod_id(method_id));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
  assert(m->is_static() == (isStatic != 0), "jni_ToReflectedMethod access flags doesn't match");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
  oop reflection_method;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
  if (m->is_initializer()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
    reflection_method = Reflection::new_constructor(m, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
  } else {
24456
8c7933fa5a1f 8025580: Temporary flags: UseNewReflection and ReflectionWrapResolutionErrors
coleenp
parents: 24424
diff changeset
   540
    reflection_method = Reflection::new_method(m, false, CHECK_NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
  ret = JNIHandles::make_local(env, reflection_method);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   546
DT_RETURN_MARK_DECL(GetSuperclass, jclass
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   547
                    , HOTSPOT_JNI_GETSUPERCLASS_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
JNI_ENTRY(jclass, jni_GetSuperclass(JNIEnv *env, jclass sub))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
  JNIWrapper("GetSuperclass");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   551
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   552
  HOTSPOT_JNI_GETSUPERCLASS_ENTRY(env, sub);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   553
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
  jclass obj = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
  DT_RETURN_MARK(GetSuperclass, jclass, (const jclass&)obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
  oop mirror = JNIHandles::resolve_non_null(sub);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
  // primitive classes return NULL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
  if (java_lang_Class::is_primitive(mirror)) return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
  // Rules of Class.getSuperClass as implemented by KLass::java_super:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
  // arrays return Object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
  // interfaces return NULL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
  // proper classes return Klass::super()
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   565
  Klass* k = java_lang_Class::as_Klass(mirror);
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14391
diff changeset
   566
  if (k->is_interface()) return NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
  // return mirror for superclass
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14391
diff changeset
   569
  Klass* super = k->java_super();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
  // super2 is the value computed by the compiler's getSuperClass intrinsic:
33611
9abd65805e19 8139203: Consistent naming for klass type predicates
coleenp
parents: 33576
diff changeset
   571
  debug_only(Klass* super2 = ( k->is_array_klass()
4571
80b553bddc26 6914300: ciEnv should export all well known classes
never
parents: 4561
diff changeset
   572
                                 ? SystemDictionary::Object_klass()
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14391
diff changeset
   573
                                 : k->super() ) );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
  assert(super == super2,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
         "java_super computation depends on interface, array, other super");
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14391
diff changeset
   576
  obj = (super == NULL) ? NULL : (jclass) JNIHandles::make_local(super->java_mirror());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
  return obj;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
JNI_QUICK_ENTRY(jboolean, jni_IsAssignableFrom(JNIEnv *env, jclass sub, jclass super))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
  JNIWrapper("IsSubclassOf");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   582
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   583
  HOTSPOT_JNI_ISASSIGNABLEFROM_ENTRY(env, sub, super);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   584
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
  oop sub_mirror   = JNIHandles::resolve_non_null(sub);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
  oop super_mirror = JNIHandles::resolve_non_null(super);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
  if (java_lang_Class::is_primitive(sub_mirror) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
      java_lang_Class::is_primitive(super_mirror)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
    jboolean ret = (sub_mirror == super_mirror);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   590
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   591
    HOTSPOT_JNI_ISASSIGNABLEFROM_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
    return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
  }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   594
  Klass* sub_klass   = java_lang_Class::as_Klass(sub_mirror);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   595
  Klass* super_klass = java_lang_Class::as_Klass(super_mirror);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
  assert(sub_klass != NULL && super_klass != NULL, "invalid arguments to jni_IsAssignableFrom");
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14391
diff changeset
   597
  jboolean ret = sub_klass->is_subtype_of(super_klass) ?
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
                   JNI_TRUE : JNI_FALSE;
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   599
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   600
  HOTSPOT_JNI_ISASSIGNABLEFROM_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   604
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   605
DT_RETURN_MARK_DECL(Throw, jint
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   606
                    , HOTSPOT_JNI_THROW_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
JNI_ENTRY(jint, jni_Throw(JNIEnv *env, jthrowable obj))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
  JNIWrapper("Throw");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   610
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   611
  HOTSPOT_JNI_THROW_ENTRY(env, obj);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   612
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
  jint ret = JNI_OK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
  DT_RETURN_MARK(Throw, jint, (const jint&)ret);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
  THROW_OOP_(JNIHandles::resolve(obj), JNI_OK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
  ShouldNotReachHere();
27679
06b3a53d7781 8064786: Fix debug build after 8062808: Turn on the -Wreturn-type warning
goetz
parents: 27247
diff changeset
   618
  return 0;  // Mute compiler.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   621
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   622
DT_RETURN_MARK_DECL(ThrowNew, jint
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   623
                    , HOTSPOT_JNI_THROWNEW_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   624
489c9b5090e2 Initial load
duke
parents:
diff changeset
   625
JNI_ENTRY(jint, jni_ThrowNew(JNIEnv *env, jclass clazz, const char *message))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   626
  JNIWrapper("ThrowNew");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   627
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   628
  HOTSPOT_JNI_THROWNEW_ENTRY(env, clazz, (char *) message);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   629
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
  jint ret = JNI_OK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
  DT_RETURN_MARK(ThrowNew, jint, (const jint&)ret);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   633
  InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz)));
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
   634
  Symbol*  name = k->name();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
  Handle class_loader (THREAD,  k->class_loader());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
  Handle protection_domain (THREAD, k->protection_domain());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
  THROW_MSG_LOADER_(name, (char *)message, class_loader, protection_domain, JNI_OK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
  ShouldNotReachHere();
27679
06b3a53d7781 8064786: Fix debug build after 8062808: Turn on the -Wreturn-type warning
goetz
parents: 27247
diff changeset
   639
  return 0;  // Mute compiler.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   641
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
// JNI functions only transform a pending async exception to a synchronous
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
// exception in ExceptionOccurred and ExceptionCheck calls, since
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
// delivering an async exception in other places won't change the native
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
// code's control flow and would be harmful when native code further calls
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
// JNI functions with a pending exception. Async exception is also checked
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
// during the call, so ExceptionOccurred/ExceptionCheck won't return
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
// false but deliver the async exception at the very end during
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
// state transition.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
static void jni_check_async_exceptions(JavaThread *thread) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
  assert(thread == Thread::current(), "must be itself");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
  thread->check_and_handle_async_exceptions();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
JNI_ENTRY_NO_PRESERVE(jthrowable, jni_ExceptionOccurred(JNIEnv *env))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
  JNIWrapper("ExceptionOccurred");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   659
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   660
  HOTSPOT_JNI_EXCEPTIONOCCURRED_ENTRY(env);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   661
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
  jni_check_async_exceptions(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
  oop exception = thread->pending_exception();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
  jthrowable ret = (jthrowable) JNIHandles::make_local(env, exception);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   665
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   666
  HOTSPOT_JNI_EXCEPTIONOCCURRED_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   668
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
JNI_ENTRY_NO_PRESERVE(void, jni_ExceptionDescribe(JNIEnv *env))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
  JNIWrapper("ExceptionDescribe");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   673
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   674
  HOTSPOT_JNI_EXCEPTIONDESCRIBE_ENTRY(env);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   675
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   676
  if (thread->has_pending_exception()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   677
    Handle ex(thread, thread->pending_exception());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   678
    thread->clear_pending_exception();
4571
80b553bddc26 6914300: ciEnv should export all well known classes
never
parents: 4561
diff changeset
   679
    if (ex->is_a(SystemDictionary::ThreadDeath_klass())) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   680
      // Don't print anything if we are being killed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
      jio_fprintf(defaultStream::error_stream(), "Exception ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
      if (thread != NULL && thread->threadObj() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
        ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
        jio_fprintf(defaultStream::error_stream(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   686
        "in thread \"%s\" ", thread->get_thread_name());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   687
      }
4571
80b553bddc26 6914300: ciEnv should export all well known classes
never
parents: 4561
diff changeset
   688
      if (ex->is_a(SystemDictionary::Throwable_klass())) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   689
        JavaValue result(T_VOID);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   690
        JavaCalls::call_virtual(&result,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   691
                                ex,
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   692
                                SystemDictionary::Throwable_klass(),
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
   693
                                vmSymbols::printStackTrace_name(),
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
   694
                                vmSymbols::void_method_signature(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   695
                                THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   696
        // If an exception is thrown in the call it gets thrown away. Not much
489c9b5090e2 Initial load
duke
parents:
diff changeset
   697
        // we can do with it. The native code that calls this, does not check
489c9b5090e2 Initial load
duke
parents:
diff changeset
   698
        // for the exception - hence, it might still be in the thread when DestroyVM gets
489c9b5090e2 Initial load
duke
parents:
diff changeset
   699
        // called, potentially causing a few asserts to trigger - since no pending exception
489c9b5090e2 Initial load
duke
parents:
diff changeset
   700
        // is expected.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   701
        CLEAR_PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   703
        ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
        jio_fprintf(defaultStream::error_stream(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
        ". Uncaught exception of type %s.",
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14391
diff changeset
   706
        ex->klass()->external_name());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   709
  }
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   710
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   711
  HOTSPOT_JNI_EXCEPTIONDESCRIBE_RETURN();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   712
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   713
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
489c9b5090e2 Initial load
duke
parents:
diff changeset
   715
JNI_QUICK_ENTRY(void, jni_ExceptionClear(JNIEnv *env))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   716
  JNIWrapper("ExceptionClear");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   717
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   718
  HOTSPOT_JNI_EXCEPTIONCLEAR_ENTRY(env);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   719
489c9b5090e2 Initial load
duke
parents:
diff changeset
   720
  // The jni code might be using this API to clear java thrown exception.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   721
  // So just mark jvmti thread exception state as exception caught.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
  JvmtiThreadState *state = JavaThread::current()->jvmti_thread_state();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   723
  if (state != NULL && state->is_exception_detected()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   724
    state->set_exception_caught();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   725
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   726
  thread->clear_pending_exception();
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   727
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   728
  HOTSPOT_JNI_EXCEPTIONCLEAR_RETURN();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   729
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   730
489c9b5090e2 Initial load
duke
parents:
diff changeset
   731
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
JNI_ENTRY(void, jni_FatalError(JNIEnv *env, const char *msg))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   733
  JNIWrapper("FatalError");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   734
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   735
  HOTSPOT_JNI_FATALERROR_ENTRY(env, (char *) msg);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   736
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   737
  tty->print_cr("FATAL ERROR in native method: %s", msg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   738
  thread->print_stack();
773
01daf7c809b1 6694099: Hotspot vm_exit_out_of_memory should dump core
poonam
parents: 360
diff changeset
   739
  os::abort(); // Dump core and abort
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   740
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   741
489c9b5090e2 Initial load
duke
parents:
diff changeset
   742
489c9b5090e2 Initial load
duke
parents:
diff changeset
   743
JNI_ENTRY(jint, jni_PushLocalFrame(JNIEnv *env, jint capacity))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   744
  JNIWrapper("PushLocalFrame");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   745
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   746
  HOTSPOT_JNI_PUSHLOCALFRAME_ENTRY(env, capacity);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   747
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   748
  //%note jni_11
25630
ff281ea14d41 8046919: jni_PushLocalFrame OOM - increase MAX_REASONABLE_LOCAL_CAPACITY
dsimms
parents: 25477
diff changeset
   749
  if (capacity < 0 ||
ff281ea14d41 8046919: jni_PushLocalFrame OOM - increase MAX_REASONABLE_LOCAL_CAPACITY
dsimms
parents: 25477
diff changeset
   750
      ((MaxJNILocalCapacity > 0) && (capacity > MaxJNILocalCapacity))) {
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   751
    HOTSPOT_JNI_PUSHLOCALFRAME_RETURN((uint32_t)JNI_ERR);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   752
    return JNI_ERR;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   754
  JNIHandleBlock* old_handles = thread->active_handles();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   755
  JNIHandleBlock* new_handles = JNIHandleBlock::allocate_block(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   756
  assert(new_handles != NULL, "should not be NULL");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   757
  new_handles->set_pop_frame_link(old_handles);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   758
  thread->set_active_handles(new_handles);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   759
  jint ret = JNI_OK;
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   760
  HOTSPOT_JNI_PUSHLOCALFRAME_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   761
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   762
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   763
489c9b5090e2 Initial load
duke
parents:
diff changeset
   764
489c9b5090e2 Initial load
duke
parents:
diff changeset
   765
JNI_ENTRY(jobject, jni_PopLocalFrame(JNIEnv *env, jobject result))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   766
  JNIWrapper("PopLocalFrame");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   767
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   768
  HOTSPOT_JNI_POPLOCALFRAME_ENTRY(env, result);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   769
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   770
  //%note jni_11
489c9b5090e2 Initial load
duke
parents:
diff changeset
   771
  Handle result_handle(thread, JNIHandles::resolve(result));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   772
  JNIHandleBlock* old_handles = thread->active_handles();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   773
  JNIHandleBlock* new_handles = old_handles->pop_frame_link();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   774
  if (new_handles != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   775
    // As a sanity check we only release the handle blocks if the pop_frame_link is not NULL.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   776
    // This way code will still work if PopLocalFrame is called without a corresponding
489c9b5090e2 Initial load
duke
parents:
diff changeset
   777
    // PushLocalFrame call. Note that we set the pop_frame_link to NULL explicitly, otherwise
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
    // the release_block call will release the blocks.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   779
    thread->set_active_handles(new_handles);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   780
    old_handles->set_pop_frame_link(NULL);              // clear link we won't release new_handles below
489c9b5090e2 Initial load
duke
parents:
diff changeset
   781
    JNIHandleBlock::release_block(old_handles, thread); // may block
489c9b5090e2 Initial load
duke
parents:
diff changeset
   782
    result = JNIHandles::make_local(thread, result_handle());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   783
  }
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   784
  HOTSPOT_JNI_POPLOCALFRAME_RETURN(result);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   785
  return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   786
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   787
489c9b5090e2 Initial load
duke
parents:
diff changeset
   788
489c9b5090e2 Initial load
duke
parents:
diff changeset
   789
JNI_ENTRY(jobject, jni_NewGlobalRef(JNIEnv *env, jobject ref))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   790
  JNIWrapper("NewGlobalRef");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   791
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   792
  HOTSPOT_JNI_NEWGLOBALREF_ENTRY(env, ref);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   793
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   794
  Handle ref_handle(thread, JNIHandles::resolve(ref));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   795
  jobject ret = JNIHandles::make_global(ref_handle);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   796
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   797
  HOTSPOT_JNI_NEWGLOBALREF_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   798
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   799
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   800
489c9b5090e2 Initial load
duke
parents:
diff changeset
   801
// Must be JNI_ENTRY (with HandleMark)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   802
JNI_ENTRY_NO_PRESERVE(void, jni_DeleteGlobalRef(JNIEnv *env, jobject ref))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   803
  JNIWrapper("DeleteGlobalRef");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   804
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   805
  HOTSPOT_JNI_DELETEGLOBALREF_ENTRY(env, ref);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   806
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   807
  JNIHandles::destroy_global(ref);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   808
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   809
  HOTSPOT_JNI_DELETEGLOBALREF_RETURN();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   810
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   811
489c9b5090e2 Initial load
duke
parents:
diff changeset
   812
JNI_QUICK_ENTRY(void, jni_DeleteLocalRef(JNIEnv *env, jobject obj))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   813
  JNIWrapper("DeleteLocalRef");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   814
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   815
  HOTSPOT_JNI_DELETELOCALREF_ENTRY(env, obj);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   816
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   817
  JNIHandles::destroy_local(obj);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   818
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   819
  HOTSPOT_JNI_DELETELOCALREF_RETURN();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   820
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   821
489c9b5090e2 Initial load
duke
parents:
diff changeset
   822
JNI_QUICK_ENTRY(jboolean, jni_IsSameObject(JNIEnv *env, jobject r1, jobject r2))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   823
  JNIWrapper("IsSameObject");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   824
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   825
  HOTSPOT_JNI_ISSAMEOBJECT_ENTRY(env, r1, r2);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   826
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   827
  oop a = JNIHandles::resolve(r1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   828
  oop b = JNIHandles::resolve(r2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   829
  jboolean ret = (a == b) ? JNI_TRUE : JNI_FALSE;
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   830
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   831
  HOTSPOT_JNI_ISSAMEOBJECT_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   832
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   833
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   834
489c9b5090e2 Initial load
duke
parents:
diff changeset
   835
489c9b5090e2 Initial load
duke
parents:
diff changeset
   836
JNI_ENTRY(jobject, jni_NewLocalRef(JNIEnv *env, jobject ref))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   837
  JNIWrapper("NewLocalRef");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   838
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   839
  HOTSPOT_JNI_NEWLOCALREF_ENTRY(env, ref);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   840
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   841
  jobject ret = JNIHandles::make_local(env, JNIHandles::resolve(ref));
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   842
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   843
  HOTSPOT_JNI_NEWLOCALREF_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   844
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   845
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   846
489c9b5090e2 Initial load
duke
parents:
diff changeset
   847
JNI_LEAF(jint, jni_EnsureLocalCapacity(JNIEnv *env, jint capacity))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   848
  JNIWrapper("EnsureLocalCapacity");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   849
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   850
  HOTSPOT_JNI_ENSURELOCALCAPACITY_ENTRY(env, capacity);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   851
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   852
  jint ret;
25630
ff281ea14d41 8046919: jni_PushLocalFrame OOM - increase MAX_REASONABLE_LOCAL_CAPACITY
dsimms
parents: 25477
diff changeset
   853
  if (capacity >= 0 &&
ff281ea14d41 8046919: jni_PushLocalFrame OOM - increase MAX_REASONABLE_LOCAL_CAPACITY
dsimms
parents: 25477
diff changeset
   854
      ((MaxJNILocalCapacity <= 0) || (capacity <= MaxJNILocalCapacity))) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   855
    ret = JNI_OK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   856
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   857
    ret = JNI_ERR;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   858
  }
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   859
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   860
  HOTSPOT_JNI_ENSURELOCALCAPACITY_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   861
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   862
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   863
489c9b5090e2 Initial load
duke
parents:
diff changeset
   864
// Return the Handle Type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   865
JNI_LEAF(jobjectRefType, jni_GetObjectRefType(JNIEnv *env, jobject obj))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   866
  JNIWrapper("GetObjectRefType");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   867
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   868
  HOTSPOT_JNI_GETOBJECTREFTYPE_ENTRY(env, obj);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   869
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   870
  jobjectRefType ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   871
  if (JNIHandles::is_local_handle(thread, obj) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   872
      JNIHandles::is_frame_handle(thread, obj))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   873
    ret = JNILocalRefType;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   874
  else if (JNIHandles::is_global_handle(obj))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   875
    ret = JNIGlobalRefType;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   876
  else if (JNIHandles::is_weak_global_handle(obj))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   877
    ret = JNIWeakGlobalRefType;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   878
  else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   879
    ret = JNIInvalidRefType;
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   880
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   881
  HOTSPOT_JNI_GETOBJECTREFTYPE_RETURN((void *) ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   882
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   883
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   884
489c9b5090e2 Initial load
duke
parents:
diff changeset
   885
489c9b5090e2 Initial load
duke
parents:
diff changeset
   886
class JNI_ArgumentPusher : public SignatureIterator {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   887
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   888
  JavaCallArguments*  _arguments;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   889
489c9b5090e2 Initial load
duke
parents:
diff changeset
   890
  virtual void get_bool   () = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   891
  virtual void get_char   () = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   892
  virtual void get_short  () = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   893
  virtual void get_byte   () = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   894
  virtual void get_int    () = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   895
  virtual void get_long   () = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   896
  virtual void get_float  () = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   897
  virtual void get_double () = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   898
  virtual void get_object () = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   899
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
   900
  JNI_ArgumentPusher(Symbol* signature) : SignatureIterator(signature) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   901
    this->_return_type = T_ILLEGAL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   902
    _arguments = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   903
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   904
489c9b5090e2 Initial load
duke
parents:
diff changeset
   905
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   906
  virtual void iterate( uint64_t fingerprint ) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   907
489c9b5090e2 Initial load
duke
parents:
diff changeset
   908
  void set_java_argument_object(JavaCallArguments *arguments) { _arguments = arguments; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   909
489c9b5090e2 Initial load
duke
parents:
diff changeset
   910
  inline void do_bool()                     { if (!is_return_type()) get_bool();   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   911
  inline void do_char()                     { if (!is_return_type()) get_char();   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   912
  inline void do_short()                    { if (!is_return_type()) get_short();  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   913
  inline void do_byte()                     { if (!is_return_type()) get_byte();   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   914
  inline void do_int()                      { if (!is_return_type()) get_int();    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   915
  inline void do_long()                     { if (!is_return_type()) get_long();   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   916
  inline void do_float()                    { if (!is_return_type()) get_float();  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   917
  inline void do_double()                   { if (!is_return_type()) get_double(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   918
  inline void do_object(int begin, int end) { if (!is_return_type()) get_object(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   919
  inline void do_array(int begin, int end)  { if (!is_return_type()) get_object(); } // do_array uses get_object -- there is no get_array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   920
  inline void do_void()                     { }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   921
489c9b5090e2 Initial load
duke
parents:
diff changeset
   922
  JavaCallArguments* arguments()     { return _arguments; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   923
  void push_receiver(Handle h)       { _arguments->push_oop(h); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   924
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   925
489c9b5090e2 Initial load
duke
parents:
diff changeset
   926
489c9b5090e2 Initial load
duke
parents:
diff changeset
   927
class JNI_ArgumentPusherVaArg : public JNI_ArgumentPusher {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   928
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   929
  va_list _ap;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   930
37483
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
   931
  inline void get_bool()   {
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
   932
    // Normalize boolean arguments from native code by converting 1-255 to JNI_TRUE and
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
   933
    // 0 to JNI_FALSE.  Boolean return values from native are normalized the same in
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
   934
    // TemplateInterpreterGenerator::generate_result_handler_for and
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
   935
    // SharedRuntime::generate_native_wrapper.
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
   936
    jboolean b = va_arg(_ap, jint);
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
   937
    _arguments->push_int((jint)(b == 0 ? JNI_FALSE : JNI_TRUE));
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
   938
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   939
  inline void get_char()   { _arguments->push_int(va_arg(_ap, jint)); } // char is coerced to int when using va_arg
489c9b5090e2 Initial load
duke
parents:
diff changeset
   940
  inline void get_short()  { _arguments->push_int(va_arg(_ap, jint)); } // short is coerced to int when using va_arg
489c9b5090e2 Initial load
duke
parents:
diff changeset
   941
  inline void get_byte()   { _arguments->push_int(va_arg(_ap, jint)); } // byte is coerced to int when using va_arg
489c9b5090e2 Initial load
duke
parents:
diff changeset
   942
  inline void get_int()    { _arguments->push_int(va_arg(_ap, jint)); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   943
489c9b5090e2 Initial load
duke
parents:
diff changeset
   944
  // each of these paths is exercized by the various jck Call[Static,Nonvirtual,][Void,Int,..]Method[A,V,] tests
489c9b5090e2 Initial load
duke
parents:
diff changeset
   945
489c9b5090e2 Initial load
duke
parents:
diff changeset
   946
  inline void get_long()   { _arguments->push_long(va_arg(_ap, jlong)); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   947
  inline void get_float()  { _arguments->push_float((jfloat)va_arg(_ap, jdouble)); } // float is coerced to double w/ va_arg
489c9b5090e2 Initial load
duke
parents:
diff changeset
   948
  inline void get_double() { _arguments->push_double(va_arg(_ap, jdouble)); }
44406
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   949
  inline void get_object() { _arguments->push_jobject(va_arg(_ap, jobject)); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   950
489c9b5090e2 Initial load
duke
parents:
diff changeset
   951
  inline void set_ap(va_list rap) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   952
    va_copy(_ap, rap);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   953
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   954
489c9b5090e2 Initial load
duke
parents:
diff changeset
   955
 public:
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
   956
  JNI_ArgumentPusherVaArg(Symbol* signature, va_list rap)
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
   957
       : JNI_ArgumentPusher(signature) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   958
    set_ap(rap);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   959
  }
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
   960
  JNI_ArgumentPusherVaArg(jmethodID method_id, va_list rap)
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   961
      : JNI_ArgumentPusher(Method::resolve_jmethod_id(method_id)->signature()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   962
    set_ap(rap);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   963
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   964
489c9b5090e2 Initial load
duke
parents:
diff changeset
   965
  // Optimized path if we have the bitvector form of signature
489c9b5090e2 Initial load
duke
parents:
diff changeset
   966
  void iterate( uint64_t fingerprint ) {
27471
6e56277909f1 8062370: Various minor code improvements
goetz
parents: 27247
diff changeset
   967
    if (fingerprint == (uint64_t)CONST64(-1)) {
6e56277909f1 8062370: Various minor code improvements
goetz
parents: 27247
diff changeset
   968
      SignatureIterator::iterate(); // Must be too many arguments
6e56277909f1 8062370: Various minor code improvements
goetz
parents: 27247
diff changeset
   969
    } else {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   970
      _return_type = (BasicType)((fingerprint >> static_feature_size) &
489c9b5090e2 Initial load
duke
parents:
diff changeset
   971
                                  result_feature_mask);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   972
489c9b5090e2 Initial load
duke
parents:
diff changeset
   973
      assert(fingerprint, "Fingerprint should not be 0");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   974
      fingerprint = fingerprint >> (static_feature_size + result_feature_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   975
      while ( 1 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   976
        switch ( fingerprint & parameter_feature_mask ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   977
          case bool_parm:
37483
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
   978
            get_bool();
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
   979
            break;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   980
          case char_parm:
37483
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
   981
            get_char();
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
   982
            break;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   983
          case short_parm:
37483
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
   984
            get_short();
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
   985
            break;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   986
          case byte_parm:
37483
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
   987
            get_byte();
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
   988
            break;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   989
          case int_parm:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   990
            get_int();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   991
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   992
          case obj_parm:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   993
            get_object();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   994
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   995
          case long_parm:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   996
            get_long();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   997
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   998
          case float_parm:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   999
            get_float();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1000
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1001
          case double_parm:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1002
            get_double();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1003
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1004
          case done_parm:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1005
            return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1006
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1007
          default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1008
            ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1009
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1010
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1011
        fingerprint >>= parameter_feature_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1012
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1013
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1014
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1015
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1016
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1017
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1018
class JNI_ArgumentPusherArray : public JNI_ArgumentPusher {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1019
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1020
  const jvalue *_ap;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1021
37483
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
  1022
  inline void get_bool()   {
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
  1023
    // Normalize boolean arguments from native code by converting 1-255 to JNI_TRUE and
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
  1024
    // 0 to JNI_FALSE.  Boolean return values from native are normalized the same in
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
  1025
    // TemplateInterpreterGenerator::generate_result_handler_for and
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
  1026
    // SharedRuntime::generate_native_wrapper.
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
  1027
    jboolean b = (_ap++)->z;
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
  1028
    _arguments->push_int((jint)(b == 0 ? JNI_FALSE : JNI_TRUE));
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
  1029
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1030
  inline void get_char()   { _arguments->push_int((jint)(_ap++)->c); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1031
  inline void get_short()  { _arguments->push_int((jint)(_ap++)->s); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1032
  inline void get_byte()   { _arguments->push_int((jint)(_ap++)->b); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1033
  inline void get_int()    { _arguments->push_int((jint)(_ap++)->i); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1034
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1035
  inline void get_long()   { _arguments->push_long((_ap++)->j);  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1036
  inline void get_float()  { _arguments->push_float((_ap++)->f); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1037
  inline void get_double() { _arguments->push_double((_ap++)->d);}
44406
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
  1038
  inline void get_object() { _arguments->push_jobject((_ap++)->l); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1039
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1040
  inline void set_ap(const jvalue *rap) { _ap = rap; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1041
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1042
 public:
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1043
  JNI_ArgumentPusherArray(Symbol* signature, const jvalue *rap)
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1044
       : JNI_ArgumentPusher(signature) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1045
    set_ap(rap);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1046
  }
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1047
  JNI_ArgumentPusherArray(jmethodID method_id, const jvalue *rap)
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1048
      : JNI_ArgumentPusher(Method::resolve_jmethod_id(method_id)->signature()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1049
    set_ap(rap);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1050
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1051
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1052
  // Optimized path if we have the bitvector form of signature
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1053
  void iterate( uint64_t fingerprint ) {
27471
6e56277909f1 8062370: Various minor code improvements
goetz
parents: 27247
diff changeset
  1054
    if (fingerprint == (uint64_t)CONST64(-1)) {
6e56277909f1 8062370: Various minor code improvements
goetz
parents: 27247
diff changeset
  1055
      SignatureIterator::iterate(); // Must be too many arguments
6e56277909f1 8062370: Various minor code improvements
goetz
parents: 27247
diff changeset
  1056
    } else {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1057
      _return_type = (BasicType)((fingerprint >> static_feature_size) &
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1058
                                  result_feature_mask);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1059
      assert(fingerprint, "Fingerprint should not be 0");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1060
      fingerprint = fingerprint >> (static_feature_size + result_feature_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1061
      while ( 1 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1062
        switch ( fingerprint & parameter_feature_mask ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1063
          case bool_parm:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1064
            get_bool();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1065
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1066
          case char_parm:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1067
            get_char();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1068
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1069
          case short_parm:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1070
            get_short();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1071
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1072
          case byte_parm:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1073
            get_byte();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1074
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1075
          case int_parm:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1076
            get_int();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1077
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1078
          case obj_parm:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1079
            get_object();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1080
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1081
          case long_parm:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1082
            get_long();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1083
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1084
          case float_parm:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1085
            get_float();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1086
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1087
          case double_parm:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1088
            get_double();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1089
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1090
          case done_parm:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1091
            return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1092
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1093
          default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1094
            ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1095
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1096
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1097
        fingerprint >>= parameter_feature_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1098
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1099
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1100
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1101
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1102
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1103
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1104
enum JNICallType {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1105
  JNI_STATIC,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1106
  JNI_VIRTUAL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1107
  JNI_NONVIRTUAL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1108
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1109
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1110
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1111
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1112
static void jni_invoke_static(JNIEnv *env, JavaValue* result, jobject receiver, JNICallType call_type, jmethodID method_id, JNI_ArgumentPusher *args, TRAPS) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1113
  methodHandle method(THREAD, Method::resolve_jmethod_id(method_id));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1114
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1115
  // Create object to hold arguments for the JavaCall, and associate it with
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1116
  // the jni parser
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1117
  ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1118
  int number_of_parameters = method->size_of_parameters();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1119
  JavaCallArguments java_args(number_of_parameters);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1120
  args->set_java_argument_object(&java_args);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1121
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1122
  assert(method->is_static(), "method should be static");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1123
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1124
  // Fill out JavaCallArguments object
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1125
  args->iterate( Fingerprinter(method).fingerprint() );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1126
  // Initialize result type
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1127
  result->set_type(args->get_ret_type());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1128
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1129
  // Invoke the method. Result is returned as oop.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1130
  JavaCalls::call(result, method, &java_args, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1131
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1132
  // Convert result
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1133
  if (result->get_type() == T_OBJECT || result->get_type() == T_ARRAY) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1134
    result->set_jobject(JNIHandles::make_local(env, (oop) result->get_jobject()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1135
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1136
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1137
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1138
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1139
static void jni_invoke_nonstatic(JNIEnv *env, JavaValue* result, jobject receiver, JNICallType call_type, jmethodID method_id, JNI_ArgumentPusher *args, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1140
  oop recv = JNIHandles::resolve(receiver);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1141
  if (recv == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1142
    THROW(vmSymbols::java_lang_NullPointerException());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1143
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1144
  Handle h_recv(THREAD, recv);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1145
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1146
  int number_of_parameters;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1147
  Method* selected_method;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1148
  {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1149
    Method* m = Method::resolve_jmethod_id(method_id);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1150
    number_of_parameters = m->size_of_parameters();
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1151
    Klass* holder = m->method_holder();
31027
6df6a1332f23 8072588: JVM crashes in JNI if toString is declared as an interface method
aeriksso
parents: 30764
diff changeset
  1152
    if (call_type != JNI_VIRTUAL) {
6df6a1332f23 8072588: JVM crashes in JNI if toString is declared as an interface method
aeriksso
parents: 30764
diff changeset
  1153
        selected_method = m;
6df6a1332f23 8072588: JVM crashes in JNI if toString is declared as an interface method
aeriksso
parents: 30764
diff changeset
  1154
    } else if (!m->has_itable_index()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1155
      // non-interface call -- for that little speed boost, don't handlize
35492
c8c0273e6b91 8146690: Make all classes in GC follow the naming convention.
david
parents: 35219
diff changeset
  1156
      debug_only(NoSafepointVerifier nosafepoint;)
31027
6df6a1332f23 8072588: JVM crashes in JNI if toString is declared as an interface method
aeriksso
parents: 30764
diff changeset
  1157
      // jni_GetMethodID makes sure class is linked and initialized
6df6a1332f23 8072588: JVM crashes in JNI if toString is declared as an interface method
aeriksso
parents: 30764
diff changeset
  1158
      // so m should have a valid vtable index.
6df6a1332f23 8072588: JVM crashes in JNI if toString is declared as an interface method
aeriksso
parents: 30764
diff changeset
  1159
      assert(m->valid_vtable_index(), "no valid vtable index");
6df6a1332f23 8072588: JVM crashes in JNI if toString is declared as an interface method
aeriksso
parents: 30764
diff changeset
  1160
      int vtbl_index = m->vtable_index();
6df6a1332f23 8072588: JVM crashes in JNI if toString is declared as an interface method
aeriksso
parents: 30764
diff changeset
  1161
      if (vtbl_index != Method::nonvirtual_vtable_index) {
35900
d64cf9290fc4 8148481: Devirtualize Klass::vtable
mgerdin
parents: 35519
diff changeset
  1162
        selected_method = h_recv->klass()->method_at_vtable(vtbl_index);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1163
      } else {
31027
6df6a1332f23 8072588: JVM crashes in JNI if toString is declared as an interface method
aeriksso
parents: 30764
diff changeset
  1164
        // final method
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1165
        selected_method = m;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1166
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1167
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1168
      // interface call
31027
6df6a1332f23 8072588: JVM crashes in JNI if toString is declared as an interface method
aeriksso
parents: 30764
diff changeset
  1169
      int itbl_index = m->itable_index();
6df6a1332f23 8072588: JVM crashes in JNI if toString is declared as an interface method
aeriksso
parents: 30764
diff changeset
  1170
      Klass* k = h_recv->klass();
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  1171
      selected_method = InstanceKlass::cast(k)->method_at_itable(holder, itbl_index, CHECK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1172
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1173
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1174
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1175
  methodHandle method(THREAD, selected_method);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1176
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1177
  // Create object to hold arguments for the JavaCall, and associate it with
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1178
  // the jni parser
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1179
  ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1180
  JavaCallArguments java_args(number_of_parameters);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1181
  args->set_java_argument_object(&java_args);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1182
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1183
  // handle arguments
41669
2091069b6851 8081800: AbstractMethodError when evaluating a private method in an interface via debugger
dholmes
parents: 40655
diff changeset
  1184
  assert(!method->is_static(), "method %s should not be static", method->name_and_sig_as_C_string());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1185
  args->push_receiver(h_recv); // Push jobject handle
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1186
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1187
  // Fill out JavaCallArguments object
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1188
  args->iterate( Fingerprinter(method).fingerprint() );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1189
  // Initialize result type
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1190
  result->set_type(args->get_ret_type());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1191
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1192
  // Invoke the method. Result is returned as oop.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1193
  JavaCalls::call(result, method, &java_args, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1194
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1195
  // Convert result
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1196
  if (result->get_type() == T_OBJECT || result->get_type() == T_ARRAY) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1197
    result->set_jobject(JNIHandles::make_local(env, (oop) result->get_jobject()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1198
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1199
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1200
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1201
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1202
static instanceOop alloc_object(jclass clazz, TRAPS) {
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  1203
  Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz));
22532
1fc87ea15795 8031427: AllocObject and Unsafe.allocateInstance segfault for primitive types
gdub
parents: 22520
diff changeset
  1204
  if (k == NULL) {
1fc87ea15795 8031427: AllocObject and Unsafe.allocateInstance segfault for primitive types
gdub
parents: 22520
diff changeset
  1205
    ResourceMark rm(THREAD);
1fc87ea15795 8031427: AllocObject and Unsafe.allocateInstance segfault for primitive types
gdub
parents: 22520
diff changeset
  1206
    THROW_(vmSymbols::java_lang_InstantiationException(), NULL);
1fc87ea15795 8031427: AllocObject and Unsafe.allocateInstance segfault for primitive types
gdub
parents: 22520
diff changeset
  1207
  }
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  1208
  k->check_valid_for_instantiation(false, CHECK_NULL);
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  1209
  k->initialize(CHECK_NULL);
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  1210
  instanceOop ih = InstanceKlass::cast(k)->allocate_instance(THREAD);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1211
  return ih;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1212
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1213
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1214
DT_RETURN_MARK_DECL(AllocObject, jobject
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1215
                    , HOTSPOT_JNI_ALLOCOBJECT_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1216
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1217
JNI_ENTRY(jobject, jni_AllocObject(JNIEnv *env, jclass clazz))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1218
  JNIWrapper("AllocObject");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1219
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  1220
  HOTSPOT_JNI_ALLOCOBJECT_ENTRY(env, clazz);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  1221
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1222
  jobject ret = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1223
  DT_RETURN_MARK(AllocObject, jobject, (const jobject&)ret);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1224
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1225
  instanceOop i = alloc_object(clazz, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1226
  ret = JNIHandles::make_local(env, i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1227
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1228
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1229
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1230
DT_RETURN_MARK_DECL(NewObjectA, jobject
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1231
                    , HOTSPOT_JNI_NEWOBJECTA_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1232
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1233
JNI_ENTRY(jobject, jni_NewObjectA(JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1234
  JNIWrapper("NewObjectA");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  1235
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  1236
  HOTSPOT_JNI_NEWOBJECTA_ENTRY(env, clazz, (uintptr_t) methodID);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  1237
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1238
  jobject obj = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1239
  DT_RETURN_MARK(NewObjectA, jobject, (const jobject)obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1240
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1241
  instanceOop i = alloc_object(clazz, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1242
  obj = JNIHandles::make_local(env, i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1243
  JavaValue jvalue(T_VOID);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1244
  JNI_ArgumentPusherArray ap(methodID, args);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1245
  jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1246
  return obj;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1247
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1248
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  1249
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1250
DT_RETURN_MARK_DECL(NewObjectV, jobject
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1251
                    , HOTSPOT_JNI_NEWOBJECTV_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1252
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1253
JNI_ENTRY(jobject, jni_NewObjectV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1254
  JNIWrapper("NewObjectV");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  1255
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  1256
  HOTSPOT_JNI_NEWOBJECTV_ENTRY(env, clazz, (uintptr_t) methodID);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  1257
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1258
  jobject obj = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1259
  DT_RETURN_MARK(NewObjectV, jobject, (const jobject&)obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1260
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1261
  instanceOop i = alloc_object(clazz, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1262
  obj = JNIHandles::make_local(env, i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1263
  JavaValue jvalue(T_VOID);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1264
  JNI_ArgumentPusherVaArg ap(methodID, args);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1265
  jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1266
  return obj;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1267
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1268
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  1269
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1270
DT_RETURN_MARK_DECL(NewObject, jobject
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1271
                    , HOTSPOT_JNI_NEWOBJECT_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1272
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1273
JNI_ENTRY(jobject, jni_NewObject(JNIEnv *env, jclass clazz, jmethodID methodID, ...))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1274
  JNIWrapper("NewObject");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  1275
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  1276
  HOTSPOT_JNI_NEWOBJECT_ENTRY(env, clazz, (uintptr_t) methodID);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  1277
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1278
  jobject obj = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1279
  DT_RETURN_MARK(NewObject, jobject, (const jobject&)obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1280
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1281
  instanceOop i = alloc_object(clazz, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1282
  obj = JNIHandles::make_local(env, i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1283
  va_list args;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1284
  va_start(args, methodID);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1285
  JavaValue jvalue(T_VOID);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1286
  JNI_ArgumentPusherVaArg ap(methodID, args);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1287
  jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1288
  va_end(args);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1289
  return obj;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1290
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1291
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1292
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1293
JNI_ENTRY(jclass, jni_GetObjectClass(JNIEnv *env, jobject obj))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1294
  JNIWrapper("GetObjectClass");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  1295
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  1296
  HOTSPOT_JNI_GETOBJECTCLASS_ENTRY(env, obj);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  1297
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1298
  Klass* k = JNIHandles::resolve_non_null(obj)->klass();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1299
  jclass ret =
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14391
diff changeset
  1300
    (jclass) JNIHandles::make_local(env, k->java_mirror());
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  1301
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  1302
  HOTSPOT_JNI_GETOBJECTCLASS_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1303
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1304
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1305
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1306
JNI_QUICK_ENTRY(jboolean, jni_IsInstanceOf(JNIEnv *env, jobject obj, jclass clazz))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1307
  JNIWrapper("IsInstanceOf");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  1308
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  1309
  HOTSPOT_JNI_ISINSTANCEOF_ENTRY(env, obj, clazz);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  1310
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1311
  jboolean ret = JNI_TRUE;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1312
  if (obj != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1313
    ret = JNI_FALSE;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1314
    Klass* k = java_lang_Class::as_Klass(
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1315
      JNIHandles::resolve_non_null(clazz));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1316
    if (k != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1317
      ret = JNIHandles::resolve_non_null(obj)->is_a(k) ? JNI_TRUE : JNI_FALSE;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1318
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1319
  }
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  1320
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  1321
  HOTSPOT_JNI_ISINSTANCEOF_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1322
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1323
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1324
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1325
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1326
static jmethodID get_method_id(JNIEnv *env, jclass clazz, const char *name_str,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1327
                               const char *sig, bool is_static, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1328
  // %%%% This code should probably just call into a method in the LinkResolver
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1329
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1330
  // The class should have been loaded (we have an instance of the class
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1331
  // passed in) so the method and signature should already be in the symbol
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1332
  // table.  If they're not there, the method doesn't exist.
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1333
  const char *name_to_probe = (name_str == NULL)
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1334
                        ? vmSymbols::object_initializer_name()->as_C_string()
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1335
                        : name_str;
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1336
  TempNewSymbol name = SymbolTable::probe(name_to_probe, (int)strlen(name_to_probe));
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1337
  TempNewSymbol signature = SymbolTable::probe(sig, (int)strlen(sig));
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1338
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1339
  if (name == NULL || signature == NULL) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1340
    THROW_MSG_0(vmSymbols::java_lang_NoSuchMethodError(), name_str);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1341
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1342
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1343
  // Throw a NoSuchMethodError exception if we have an instance of a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1344
  // primitive java.lang.Class
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1345
  if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(clazz))) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1346
    THROW_MSG_0(vmSymbols::java_lang_NoSuchMethodError(), name_str);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1347
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1348
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  1349
  Klass* klass = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1350
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1351
  // Make sure class is linked and initialized before handing id's out to
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1352
  // Method*s.
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  1353
  klass->initialize(CHECK_NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1354
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1355
  Method* m;
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1356
  if (name == vmSymbols::object_initializer_name() ||
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1357
      name == vmSymbols::class_initializer_name()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1358
    // Never search superclasses for constructors
33611
9abd65805e19 8139203: Consistent naming for klass type predicates
coleenp
parents: 33576
diff changeset
  1359
    if (klass->is_instance_klass()) {
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  1360
      m = InstanceKlass::cast(klass)->find_method(name, signature);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1361
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1362
      m = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1363
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1364
  } else {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1365
    m = klass->lookup_method(name, signature);
33611
9abd65805e19 8139203: Consistent naming for klass type predicates
coleenp
parents: 33576
diff changeset
  1366
    if (m == NULL &&  klass->is_instance_klass()) {
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  1367
      m = InstanceKlass::cast(klass)->lookup_method_in_ordered_interfaces(name, signature);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1368
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1369
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1370
  if (m == NULL || (m->is_static() != is_static)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1371
    THROW_MSG_0(vmSymbols::java_lang_NoSuchMethodError(), name_str);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1372
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1373
  return m->jmethod_id();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1374
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1375
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1376
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1377
JNI_ENTRY(jmethodID, jni_GetMethodID(JNIEnv *env, jclass clazz,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1378
          const char *name, const char *sig))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1379
  JNIWrapper("GetMethodID");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  1380
  HOTSPOT_JNI_GETMETHODID_ENTRY(env, clazz, (char *) name, (char *) sig);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1381
  jmethodID ret = get_method_id(env, clazz, name, sig, false, thread);
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  1382
  HOTSPOT_JNI_GETMETHODID_RETURN((uintptr_t) ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1383
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1384
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1385
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1386
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1387
JNI_ENTRY(jmethodID, jni_GetStaticMethodID(JNIEnv *env, jclass clazz,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1388
          const char *name, const char *sig))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1389
  JNIWrapper("GetStaticMethodID");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  1390
  HOTSPOT_JNI_GETSTATICMETHODID_ENTRY(env, (char *) clazz, (char *) name, (char *)sig);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1391
  jmethodID ret = get_method_id(env, clazz, name, sig, true, thread);
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  1392
  HOTSPOT_JNI_GETSTATICMETHODID_RETURN((uintptr_t) ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1393
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1394
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1395
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1396
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1397
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1398
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1399
// Calling Methods
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1400
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1401
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1402
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1403
#define DEFINE_CALLMETHOD(ResultType, Result, Tag \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1404
                          , EntryProbe, ReturnProbe)    \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1405
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1406
  DT_RETURN_MARK_DECL_FOR(Result, Call##Result##Method, ResultType \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1407
                          , ReturnProbe);                          \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1408
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1409
JNI_ENTRY(ResultType, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1410
          jni_Call##Result##Method(JNIEnv *env, jobject obj, jmethodID methodID, ...)) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1411
  JNIWrapper("Call" XSTR(Result) "Method"); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1412
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1413
  EntryProbe; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1414
  ResultType ret = 0;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1415
  DT_RETURN_MARK_FOR(Result, Call##Result##Method, ResultType, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1416
                     (const ResultType&)ret);\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1417
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1418
  va_list args; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1419
  va_start(args, methodID); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1420
  JavaValue jvalue(Tag); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1421
  JNI_ArgumentPusherVaArg ap(methodID, args); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1422
  jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1423
  va_end(args); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1424
  ret = jvalue.get_##ResultType(); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1425
  return ret;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1426
JNI_END
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1427
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1428
// the runtime type of subword integral basic types is integer
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1429
DEFINE_CALLMETHOD(jboolean, Boolean, T_BOOLEAN
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1430
                  , HOTSPOT_JNI_CALLBOOLEANMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1431
                  HOTSPOT_JNI_CALLBOOLEANMETHOD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1432
DEFINE_CALLMETHOD(jbyte,    Byte,    T_BYTE
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1433
                  , HOTSPOT_JNI_CALLBYTEMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1434
                  HOTSPOT_JNI_CALLBYTEMETHOD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1435
DEFINE_CALLMETHOD(jchar,    Char,    T_CHAR
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1436
                  , HOTSPOT_JNI_CALLCHARMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1437
                  HOTSPOT_JNI_CALLCHARMETHOD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1438
DEFINE_CALLMETHOD(jshort,   Short,   T_SHORT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1439
                  , HOTSPOT_JNI_CALLSHORTMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1440
                  HOTSPOT_JNI_CALLSHORTMETHOD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1441
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1442
DEFINE_CALLMETHOD(jobject,  Object,  T_OBJECT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1443
                  , HOTSPOT_JNI_CALLOBJECTMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1444
                  HOTSPOT_JNI_CALLOBJECTMETHOD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1445
DEFINE_CALLMETHOD(jint,     Int,     T_INT,
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1446
                  HOTSPOT_JNI_CALLINTMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1447
                  HOTSPOT_JNI_CALLINTMETHOD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1448
DEFINE_CALLMETHOD(jlong,    Long,    T_LONG
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1449
                  , HOTSPOT_JNI_CALLLONGMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1450
                  HOTSPOT_JNI_CALLLONGMETHOD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1451
// Float and double probes don't return value because dtrace doesn't currently support it
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1452
DEFINE_CALLMETHOD(jfloat,   Float,   T_FLOAT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1453
                  , HOTSPOT_JNI_CALLFLOATMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1454
                  HOTSPOT_JNI_CALLFLOATMETHOD_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1455
DEFINE_CALLMETHOD(jdouble,  Double,  T_DOUBLE
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1456
                  , HOTSPOT_JNI_CALLDOUBLEMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1457
                  HOTSPOT_JNI_CALLDOUBLEMETHOD_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1458
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1459
#define DEFINE_CALLMETHODV(ResultType, Result, Tag \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1460
                          , EntryProbe, ReturnProbe)    \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1461
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1462
  DT_RETURN_MARK_DECL_FOR(Result, Call##Result##MethodV, ResultType \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1463
                          , ReturnProbe);                          \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1464
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1465
JNI_ENTRY(ResultType, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1466
          jni_Call##Result##MethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1467
  JNIWrapper("Call" XSTR(Result) "MethodV"); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1468
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1469
  EntryProbe;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1470
  ResultType ret = 0;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1471
  DT_RETURN_MARK_FOR(Result, Call##Result##MethodV, ResultType, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1472
                     (const ResultType&)ret);\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1473
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1474
  JavaValue jvalue(Tag); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1475
  JNI_ArgumentPusherVaArg ap(methodID, args); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1476
  jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1477
  ret = jvalue.get_##ResultType(); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1478
  return ret;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1479
JNI_END
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1480
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1481
// the runtime type of subword integral basic types is integer
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1482
DEFINE_CALLMETHODV(jboolean, Boolean, T_BOOLEAN
22190
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1483
                  , HOTSPOT_JNI_CALLBOOLEANMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1484
                  HOTSPOT_JNI_CALLBOOLEANMETHODV_RETURN(_ret_ref))
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1485
DEFINE_CALLMETHODV(jbyte,    Byte,    T_BYTE
22190
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1486
                  , HOTSPOT_JNI_CALLBYTEMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1487
                  HOTSPOT_JNI_CALLBYTEMETHODV_RETURN(_ret_ref))
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1488
DEFINE_CALLMETHODV(jchar,    Char,    T_CHAR
22190
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1489
                  , HOTSPOT_JNI_CALLCHARMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1490
                  HOTSPOT_JNI_CALLCHARMETHODV_RETURN(_ret_ref))
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1491
DEFINE_CALLMETHODV(jshort,   Short,   T_SHORT
22190
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1492
                  , HOTSPOT_JNI_CALLSHORTMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1493
                  HOTSPOT_JNI_CALLSHORTMETHODV_RETURN(_ret_ref))
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1494
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1495
DEFINE_CALLMETHODV(jobject,  Object,  T_OBJECT
22190
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1496
                  , HOTSPOT_JNI_CALLOBJECTMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1497
                  HOTSPOT_JNI_CALLOBJECTMETHODV_RETURN(_ret_ref))
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1498
DEFINE_CALLMETHODV(jint,     Int,     T_INT,
22190
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1499
                  HOTSPOT_JNI_CALLINTMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1500
                  HOTSPOT_JNI_CALLINTMETHODV_RETURN(_ret_ref))
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1501
DEFINE_CALLMETHODV(jlong,    Long,    T_LONG
22190
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1502
                  , HOTSPOT_JNI_CALLLONGMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1503
                  HOTSPOT_JNI_CALLLONGMETHODV_RETURN(_ret_ref))
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1504
// Float and double probes don't return value because dtrace doesn't currently support it
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1505
DEFINE_CALLMETHODV(jfloat,   Float,   T_FLOAT
22190
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1506
                  , HOTSPOT_JNI_CALLFLOATMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1507
                  HOTSPOT_JNI_CALLFLOATMETHODV_RETURN())
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1508
DEFINE_CALLMETHODV(jdouble,  Double,  T_DOUBLE
22190
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1509
                  , HOTSPOT_JNI_CALLDOUBLEMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1510
                  HOTSPOT_JNI_CALLDOUBLEMETHODV_RETURN())
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1511
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1512
#define DEFINE_CALLMETHODA(ResultType, Result, Tag \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1513
                          , EntryProbe, ReturnProbe)    \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1514
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1515
  DT_RETURN_MARK_DECL_FOR(Result, Call##Result##MethodA, ResultType \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1516
                          , ReturnProbe);                          \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1517
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1518
JNI_ENTRY(ResultType, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1519
          jni_Call##Result##MethodA(JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args)) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1520
  JNIWrapper("Call" XSTR(Result) "MethodA"); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1521
  EntryProbe; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1522
  ResultType ret = 0;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1523
  DT_RETURN_MARK_FOR(Result, Call##Result##MethodA, ResultType, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1524
                     (const ResultType&)ret);\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1525
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1526
  JavaValue jvalue(Tag); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1527
  JNI_ArgumentPusherArray ap(methodID, args); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1528
  jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1529
  ret = jvalue.get_##ResultType(); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1530
  return ret;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1531
JNI_END
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1532
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1533
// the runtime type of subword integral basic types is integer
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1534
DEFINE_CALLMETHODA(jboolean, Boolean, T_BOOLEAN
22190
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1535
                  , HOTSPOT_JNI_CALLBOOLEANMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1536
                  HOTSPOT_JNI_CALLBOOLEANMETHODA_RETURN(_ret_ref))
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1537
DEFINE_CALLMETHODA(jbyte,    Byte,    T_BYTE
22190
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1538
                  , HOTSPOT_JNI_CALLBYTEMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1539
                  HOTSPOT_JNI_CALLBYTEMETHODA_RETURN(_ret_ref))
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1540
DEFINE_CALLMETHODA(jchar,    Char,    T_CHAR
22190
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1541
                  , HOTSPOT_JNI_CALLCHARMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1542
                  HOTSPOT_JNI_CALLCHARMETHODA_RETURN(_ret_ref))
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1543
DEFINE_CALLMETHODA(jshort,   Short,   T_SHORT
22190
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1544
                  , HOTSPOT_JNI_CALLSHORTMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1545
                  HOTSPOT_JNI_CALLSHORTMETHODA_RETURN(_ret_ref))
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1546
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1547
DEFINE_CALLMETHODA(jobject,  Object,  T_OBJECT
22190
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1548
                  , HOTSPOT_JNI_CALLOBJECTMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1549
                  HOTSPOT_JNI_CALLOBJECTMETHODA_RETURN(_ret_ref))
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1550
DEFINE_CALLMETHODA(jint,     Int,     T_INT,
22190
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1551
                  HOTSPOT_JNI_CALLINTMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1552
                  HOTSPOT_JNI_CALLINTMETHODA_RETURN(_ret_ref))
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1553
DEFINE_CALLMETHODA(jlong,    Long,    T_LONG
22190
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1554
                  , HOTSPOT_JNI_CALLLONGMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1555
                  HOTSPOT_JNI_CALLLONGMETHODA_RETURN(_ret_ref))
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1556
// Float and double probes don't return value because dtrace doesn't currently support it
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1557
DEFINE_CALLMETHODA(jfloat,   Float,   T_FLOAT
22190
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1558
                  , HOTSPOT_JNI_CALLFLOATMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1559
                  HOTSPOT_JNI_CALLFLOATMETHODA_RETURN())
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1560
DEFINE_CALLMETHODA(jdouble,  Double,  T_DOUBLE
22190
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1561
                  , HOTSPOT_JNI_CALLDOUBLEMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1562
                  HOTSPOT_JNI_CALLDOUBLEMETHODA_RETURN())
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1563
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1564
DT_VOID_RETURN_MARK_DECL(CallVoidMethod, HOTSPOT_JNI_CALLVOIDMETHOD_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1565
DT_VOID_RETURN_MARK_DECL(CallVoidMethodV, HOTSPOT_JNI_CALLVOIDMETHODV_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1566
DT_VOID_RETURN_MARK_DECL(CallVoidMethodA, HOTSPOT_JNI_CALLVOIDMETHODA_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1567
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1568
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1569
JNI_ENTRY(void, jni_CallVoidMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1570
  JNIWrapper("CallVoidMethod");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  1571
  HOTSPOT_JNI_CALLVOIDMETHOD_ENTRY(env, obj, (uintptr_t) methodID);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1572
  DT_VOID_RETURN_MARK(CallVoidMethod);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1573
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1574
  va_list args;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1575
  va_start(args, methodID);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1576
  JavaValue jvalue(T_VOID);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1577
  JNI_ArgumentPusherVaArg ap(methodID, args);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1578
  jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1579
  va_end(args);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1580
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1581
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1582
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1583
JNI_ENTRY(void, jni_CallVoidMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1584
  JNIWrapper("CallVoidMethodV");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  1585
  HOTSPOT_JNI_CALLVOIDMETHODV_ENTRY(env, obj, (uintptr_t) methodID);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1586
  DT_VOID_RETURN_MARK(CallVoidMethodV);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1587
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1588
  JavaValue jvalue(T_VOID);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1589
  JNI_ArgumentPusherVaArg ap(methodID, args);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1590
  jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1591
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1592
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1593
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1594
JNI_ENTRY(void, jni_CallVoidMethodA(JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1595
  JNIWrapper("CallVoidMethodA");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  1596
  HOTSPOT_JNI_CALLVOIDMETHODA_ENTRY(env, obj, (uintptr_t) methodID);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1597
  DT_VOID_RETURN_MARK(CallVoidMethodA);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1598
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1599
  JavaValue jvalue(T_VOID);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1600
  JNI_ArgumentPusherArray ap(methodID, args);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1601
  jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1602
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1603
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1604
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1605
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1606
#define DEFINE_CALLNONVIRTUALMETHOD(ResultType, Result, Tag \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1607
                                    , EntryProbe, ReturnProbe)      \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1608
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1609
  DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##Method, ResultType \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1610
                          , ReturnProbe);\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1611
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1612
JNI_ENTRY(ResultType, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1613
          jni_CallNonvirtual##Result##Method(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, ...)) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1614
  JNIWrapper("CallNonvitual" XSTR(Result) "Method"); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1615
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1616
  EntryProbe;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1617
  ResultType ret;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1618
  DT_RETURN_MARK_FOR(Result, CallNonvirtual##Result##Method, ResultType, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1619
                     (const ResultType&)ret);\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1620
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1621
  va_list args; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1622
  va_start(args, methodID); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1623
  JavaValue jvalue(Tag); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1624
  JNI_ArgumentPusherVaArg ap(methodID, args); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1625
  jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1626
  va_end(args); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1627
  ret = jvalue.get_##ResultType(); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1628
  return ret;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1629
JNI_END
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1630
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1631
// the runtime type of subword integral basic types is integer
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1632
DEFINE_CALLNONVIRTUALMETHOD(jboolean, Boolean, T_BOOLEAN
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1633
                            , HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1634
                            HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHOD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1635
DEFINE_CALLNONVIRTUALMETHOD(jbyte,    Byte,    T_BYTE
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1636
                            , HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1637
                            HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHOD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1638
DEFINE_CALLNONVIRTUALMETHOD(jchar,    Char,    T_CHAR
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1639
                            , HOTSPOT_JNI_CALLNONVIRTUALCHARMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1640
                            HOTSPOT_JNI_CALLNONVIRTUALCHARMETHOD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1641
DEFINE_CALLNONVIRTUALMETHOD(jshort,   Short,   T_SHORT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1642
                            , HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1643
                            HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHOD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1644
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1645
DEFINE_CALLNONVIRTUALMETHOD(jobject,  Object,  T_OBJECT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1646
                            , HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1647
                            HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHOD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1648
DEFINE_CALLNONVIRTUALMETHOD(jint,     Int,     T_INT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1649
                            , HOTSPOT_JNI_CALLNONVIRTUALINTMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1650
                            HOTSPOT_JNI_CALLNONVIRTUALINTMETHOD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1651
DEFINE_CALLNONVIRTUALMETHOD(jlong,    Long,    T_LONG
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1652
                            , HOTSPOT_JNI_CALLNONVIRTUALLONGMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1653
// Float and double probes don't return value because dtrace doesn't currently support it
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1654
                            HOTSPOT_JNI_CALLNONVIRTUALLONGMETHOD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1655
DEFINE_CALLNONVIRTUALMETHOD(jfloat,   Float,   T_FLOAT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1656
                            , HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1657
                            HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHOD_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1658
DEFINE_CALLNONVIRTUALMETHOD(jdouble,  Double,  T_DOUBLE
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1659
                            , HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1660
                            HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHOD_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1661
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1662
#define DEFINE_CALLNONVIRTUALMETHODV(ResultType, Result, Tag \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1663
                                    , EntryProbe, ReturnProbe)      \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1664
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1665
  DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##MethodV, ResultType \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1666
                          , ReturnProbe);\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1667
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1668
JNI_ENTRY(ResultType, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1669
          jni_CallNonvirtual##Result##MethodV(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, va_list args)) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1670
  JNIWrapper("CallNonvitual" XSTR(Result) "MethodV"); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1671
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1672
  EntryProbe;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1673
  ResultType ret;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1674
  DT_RETURN_MARK_FOR(Result, CallNonvirtual##Result##MethodV, ResultType, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1675
                     (const ResultType&)ret);\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1676
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1677
  JavaValue jvalue(Tag); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1678
  JNI_ArgumentPusherVaArg ap(methodID, args); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1679
  jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1680
  ret = jvalue.get_##ResultType(); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1681
  return ret;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1682
JNI_END
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1683
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1684
// the runtime type of subword integral basic types is integer
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1685
DEFINE_CALLNONVIRTUALMETHODV(jboolean, Boolean, T_BOOLEAN
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1686
                            , HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1687
                            HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHODV_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1688
DEFINE_CALLNONVIRTUALMETHODV(jbyte,    Byte,    T_BYTE
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1689
                            , HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1690
                            HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHODV_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1691
DEFINE_CALLNONVIRTUALMETHODV(jchar,    Char,    T_CHAR
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1692
                            , HOTSPOT_JNI_CALLNONVIRTUALCHARMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1693
                            HOTSPOT_JNI_CALLNONVIRTUALCHARMETHODV_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1694
DEFINE_CALLNONVIRTUALMETHODV(jshort,   Short,   T_SHORT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1695
                            , HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1696
                            HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHODV_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1697
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1698
DEFINE_CALLNONVIRTUALMETHODV(jobject,  Object,  T_OBJECT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1699
                            , HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1700
                            HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHODV_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1701
DEFINE_CALLNONVIRTUALMETHODV(jint,     Int,     T_INT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1702
                            , HOTSPOT_JNI_CALLNONVIRTUALINTMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1703
                            HOTSPOT_JNI_CALLNONVIRTUALINTMETHODV_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1704
DEFINE_CALLNONVIRTUALMETHODV(jlong,    Long,    T_LONG
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1705
                            , HOTSPOT_JNI_CALLNONVIRTUALLONGMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1706
// Float and double probes don't return value because dtrace doesn't currently support it
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1707
                            HOTSPOT_JNI_CALLNONVIRTUALLONGMETHODV_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1708
DEFINE_CALLNONVIRTUALMETHODV(jfloat,   Float,   T_FLOAT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1709
                            , HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1710
                            HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHODV_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1711
DEFINE_CALLNONVIRTUALMETHODV(jdouble,  Double,  T_DOUBLE
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1712
                            , HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1713
                            HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHODV_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1714
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1715
#define DEFINE_CALLNONVIRTUALMETHODA(ResultType, Result, Tag \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1716
                                    , EntryProbe, ReturnProbe)      \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1717
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1718
  DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##MethodA, ResultType \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1719
                          , ReturnProbe);\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1720
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1721
JNI_ENTRY(ResultType, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1722
          jni_CallNonvirtual##Result##MethodA(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, const jvalue *args)) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1723
  JNIWrapper("CallNonvitual" XSTR(Result) "MethodA"); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1724
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1725
  EntryProbe;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1726
  ResultType ret;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1727
  DT_RETURN_MARK_FOR(Result, CallNonvirtual##Result##MethodA, ResultType, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1728
                     (const ResultType&)ret);\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1729
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1730
  JavaValue jvalue(Tag); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1731
  JNI_ArgumentPusherArray ap(methodID, args); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1732
  jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1733
  ret = jvalue.get_##ResultType(); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1734
  return ret;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1735
JNI_END
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1736
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1737
// the runtime type of subword integral basic types is integer
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1738
DEFINE_CALLNONVIRTUALMETHODA(jboolean, Boolean, T_BOOLEAN
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1739
                            , HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1740
                            HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHODA_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1741
DEFINE_CALLNONVIRTUALMETHODA(jbyte,    Byte,    T_BYTE
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1742
                            , HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1743
                            HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHODA_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1744
DEFINE_CALLNONVIRTUALMETHODA(jchar,    Char,    T_CHAR
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1745
                            , HOTSPOT_JNI_CALLNONVIRTUALCHARMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1746
                            HOTSPOT_JNI_CALLNONVIRTUALCHARMETHODA_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1747
DEFINE_CALLNONVIRTUALMETHODA(jshort,   Short,   T_SHORT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1748
                            , HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1749
                            HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHODA_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1750
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1751
DEFINE_CALLNONVIRTUALMETHODA(jobject,  Object,  T_OBJECT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1752
                            , HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1753
                            HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHODA_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1754
DEFINE_CALLNONVIRTUALMETHODA(jint,     Int,     T_INT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1755
                            , HOTSPOT_JNI_CALLNONVIRTUALINTMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1756
                            HOTSPOT_JNI_CALLNONVIRTUALINTMETHODA_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1757
DEFINE_CALLNONVIRTUALMETHODA(jlong,    Long,    T_LONG
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1758
                            , HOTSPOT_JNI_CALLNONVIRTUALLONGMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1759
// Float and double probes don't return value because dtrace doesn't currently support it
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1760
                            HOTSPOT_JNI_CALLNONVIRTUALLONGMETHODA_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1761
DEFINE_CALLNONVIRTUALMETHODA(jfloat,   Float,   T_FLOAT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1762
                            , HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1763
                            HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHODA_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1764
DEFINE_CALLNONVIRTUALMETHODA(jdouble,  Double,  T_DOUBLE
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1765
                            , HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1766
                            HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHODA_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1767
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1768
DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethod
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1769
                         , HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHOD_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1770
DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodV
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1771
                         , HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODV_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1772
DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodA
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1773
                         , HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODA_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1774
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1775
JNI_ENTRY(void, jni_CallNonvirtualVoidMethod(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, ...))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1776
  JNIWrapper("CallNonvirtualVoidMethod");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1777
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  1778
  HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHOD_ENTRY(env, obj, cls, (uintptr_t) methodID);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1779
  DT_VOID_RETURN_MARK(CallNonvirtualVoidMethod);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1780
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1781
  va_list args;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1782
  va_start(args, methodID);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1783
  JavaValue jvalue(T_VOID);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1784
  JNI_ArgumentPusherVaArg ap(methodID, args);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1785
  jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1786
  va_end(args);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1787
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1788
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1789
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1790
JNI_ENTRY(void, jni_CallNonvirtualVoidMethodV(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, va_list args))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1791
  JNIWrapper("CallNonvirtualVoidMethodV");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1792
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1793
  HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODV_ENTRY(
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1794
               env, obj, cls, (uintptr_t) methodID);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1795
  DT_VOID_RETURN_MARK(CallNonvirtualVoidMethodV);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1796
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1797
  JavaValue jvalue(T_VOID);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1798
  JNI_ArgumentPusherVaArg ap(methodID, args);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1799
  jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1800
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1801
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1802
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1803
JNI_ENTRY(void, jni_CallNonvirtualVoidMethodA(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, const jvalue *args))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1804
  JNIWrapper("CallNonvirtualVoidMethodA");
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1805
  HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODA_ENTRY(
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1806
                env, obj, cls, (uintptr_t) methodID);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1807
  DT_VOID_RETURN_MARK(CallNonvirtualVoidMethodA);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1808
  JavaValue jvalue(T_VOID);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1809
  JNI_ArgumentPusherArray ap(methodID, args);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1810
  jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1811
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1812
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1813
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1814
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1815
#define DEFINE_CALLSTATICMETHOD(ResultType, Result, Tag \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1816
                                , EntryProbe, ResultProbe) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1817
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1818
  DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##Method, ResultType \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1819
                          , ResultProbe);                               \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1820
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1821
JNI_ENTRY(ResultType, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1822
          jni_CallStatic##Result##Method(JNIEnv *env, jclass cls, jmethodID methodID, ...)) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1823
  JNIWrapper("CallStatic" XSTR(Result) "Method"); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1824
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1825
  EntryProbe; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1826
  ResultType ret = 0;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1827
  DT_RETURN_MARK_FOR(Result, CallStatic##Result##Method, ResultType, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1828
                     (const ResultType&)ret);\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1829
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1830
  va_list args; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1831
  va_start(args, methodID); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1832
  JavaValue jvalue(Tag); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1833
  JNI_ArgumentPusherVaArg ap(methodID, args); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1834
  jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK_0); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1835
  va_end(args); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1836
  ret = jvalue.get_##ResultType(); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1837
  return ret;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1838
JNI_END
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1839
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1840
// the runtime type of subword integral basic types is integer
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1841
DEFINE_CALLSTATICMETHOD(jboolean, Boolean, T_BOOLEAN
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1842
                        , HOTSPOT_JNI_CALLSTATICBOOLEANMETHOD_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1843
                        HOTSPOT_JNI_CALLSTATICBOOLEANMETHOD_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1844
DEFINE_CALLSTATICMETHOD(jbyte,    Byte,    T_BYTE
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1845
                        , HOTSPOT_JNI_CALLSTATICBYTEMETHOD_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1846
                        HOTSPOT_JNI_CALLSTATICBYTEMETHOD_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1847
DEFINE_CALLSTATICMETHOD(jchar,    Char,    T_CHAR
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1848
                        , HOTSPOT_JNI_CALLSTATICCHARMETHOD_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1849
                        HOTSPOT_JNI_CALLSTATICCHARMETHOD_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1850
DEFINE_CALLSTATICMETHOD(jshort,   Short,   T_SHORT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1851
                        , HOTSPOT_JNI_CALLSTATICSHORTMETHOD_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1852
                        HOTSPOT_JNI_CALLSTATICSHORTMETHOD_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1853
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1854
DEFINE_CALLSTATICMETHOD(jobject,  Object,  T_OBJECT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1855
                        , HOTSPOT_JNI_CALLSTATICOBJECTMETHOD_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1856
                        HOTSPOT_JNI_CALLSTATICOBJECTMETHOD_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1857
DEFINE_CALLSTATICMETHOD(jint,     Int,     T_INT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1858
                        , HOTSPOT_JNI_CALLSTATICINTMETHOD_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1859
                        HOTSPOT_JNI_CALLSTATICINTMETHOD_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1860
DEFINE_CALLSTATICMETHOD(jlong,    Long,    T_LONG
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1861
                        , HOTSPOT_JNI_CALLSTATICLONGMETHOD_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1862
                        HOTSPOT_JNI_CALLSTATICLONGMETHOD_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1863
// Float and double probes don't return value because dtrace doesn't currently support it
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1864
DEFINE_CALLSTATICMETHOD(jfloat,   Float,   T_FLOAT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1865
                        , HOTSPOT_JNI_CALLSTATICFLOATMETHOD_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1866
                        HOTSPOT_JNI_CALLSTATICFLOATMETHOD_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1867
DEFINE_CALLSTATICMETHOD(jdouble,  Double,  T_DOUBLE
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1868
                        , HOTSPOT_JNI_CALLSTATICDOUBLEMETHOD_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1869
                        HOTSPOT_JNI_CALLSTATICDOUBLEMETHOD_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1870
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1871
#define DEFINE_CALLSTATICMETHODV(ResultType, Result, Tag \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1872
                                , EntryProbe, ResultProbe) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1873
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1874
  DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##MethodV, ResultType \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1875
                          , ResultProbe);                               \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1876
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1877
JNI_ENTRY(ResultType, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1878
          jni_CallStatic##Result##MethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args)) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1879
  JNIWrapper("CallStatic" XSTR(Result) "MethodV"); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1880
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1881
  EntryProbe; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1882
  ResultType ret = 0;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1883
  DT_RETURN_MARK_FOR(Result, CallStatic##Result##MethodV, ResultType, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1884
                     (const ResultType&)ret);\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1885
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1886
  JavaValue jvalue(Tag); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1887
  JNI_ArgumentPusherVaArg ap(methodID, args); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1888
  /* Make sure class is initialized before trying to invoke its method */ \
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  1889
  Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); \
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  1890
  k->initialize(CHECK_0); \
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1891
  jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK_0); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1892
  va_end(args); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1893
  ret = jvalue.get_##ResultType(); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1894
  return ret;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1895
JNI_END
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1896
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1897
// the runtime type of subword integral basic types is integer
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1898
DEFINE_CALLSTATICMETHODV(jboolean, Boolean, T_BOOLEAN
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1899
                        , HOTSPOT_JNI_CALLSTATICBOOLEANMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1900
                        HOTSPOT_JNI_CALLSTATICBOOLEANMETHODV_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1901
DEFINE_CALLSTATICMETHODV(jbyte,    Byte,    T_BYTE
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1902
                        , HOTSPOT_JNI_CALLSTATICBYTEMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1903
                        HOTSPOT_JNI_CALLSTATICBYTEMETHODV_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1904
DEFINE_CALLSTATICMETHODV(jchar,    Char,    T_CHAR
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1905
                        , HOTSPOT_JNI_CALLSTATICCHARMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1906
                        HOTSPOT_JNI_CALLSTATICCHARMETHODV_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1907
DEFINE_CALLSTATICMETHODV(jshort,   Short,   T_SHORT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1908
                        , HOTSPOT_JNI_CALLSTATICSHORTMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1909
                        HOTSPOT_JNI_CALLSTATICSHORTMETHODV_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1910
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1911
DEFINE_CALLSTATICMETHODV(jobject,  Object,  T_OBJECT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1912
                        , HOTSPOT_JNI_CALLSTATICOBJECTMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1913
                        HOTSPOT_JNI_CALLSTATICOBJECTMETHODV_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1914
DEFINE_CALLSTATICMETHODV(jint,     Int,     T_INT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1915
                        , HOTSPOT_JNI_CALLSTATICINTMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1916
                        HOTSPOT_JNI_CALLSTATICINTMETHODV_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1917
DEFINE_CALLSTATICMETHODV(jlong,    Long,    T_LONG
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1918
                        , HOTSPOT_JNI_CALLSTATICLONGMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1919
                        HOTSPOT_JNI_CALLSTATICLONGMETHODV_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1920
// Float and double probes don't return value because dtrace doesn't currently support it
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1921
DEFINE_CALLSTATICMETHODV(jfloat,   Float,   T_FLOAT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1922
                        , HOTSPOT_JNI_CALLSTATICFLOATMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1923
                        HOTSPOT_JNI_CALLSTATICFLOATMETHODV_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1924
DEFINE_CALLSTATICMETHODV(jdouble,  Double,  T_DOUBLE
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1925
                        , HOTSPOT_JNI_CALLSTATICDOUBLEMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1926
                        HOTSPOT_JNI_CALLSTATICDOUBLEMETHODV_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1927
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1928
#define DEFINE_CALLSTATICMETHODA(ResultType, Result, Tag \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1929
                                , EntryProbe, ResultProbe) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1930
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1931
  DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##MethodA, ResultType \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1932
                          , ResultProbe);                               \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1933
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1934
JNI_ENTRY(ResultType, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1935
          jni_CallStatic##Result##MethodA(JNIEnv *env, jclass cls, jmethodID methodID, const jvalue *args)) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1936
  JNIWrapper("CallStatic" XSTR(Result) "MethodA"); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1937
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1938
  EntryProbe; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1939
  ResultType ret = 0;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1940
  DT_RETURN_MARK_FOR(Result, CallStatic##Result##MethodA, ResultType, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1941
                     (const ResultType&)ret);\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1942
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1943
  JavaValue jvalue(Tag); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1944
  JNI_ArgumentPusherArray ap(methodID, args); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1945
  jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK_0); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1946
  ret = jvalue.get_##ResultType(); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1947
  return ret;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1948
JNI_END
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1949
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1950
// the runtime type of subword integral basic types is integer
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1951
DEFINE_CALLSTATICMETHODA(jboolean, Boolean, T_BOOLEAN
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1952
                        , HOTSPOT_JNI_CALLSTATICBOOLEANMETHODA_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1953
                        HOTSPOT_JNI_CALLSTATICBOOLEANMETHODA_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1954
DEFINE_CALLSTATICMETHODA(jbyte,    Byte,    T_BYTE
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1955
                        , HOTSPOT_JNI_CALLSTATICBYTEMETHODA_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1956
                        HOTSPOT_JNI_CALLSTATICBYTEMETHODA_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1957
DEFINE_CALLSTATICMETHODA(jchar,    Char,    T_CHAR
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1958
                        , HOTSPOT_JNI_CALLSTATICCHARMETHODA_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1959
                        HOTSPOT_JNI_CALLSTATICCHARMETHODA_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1960
DEFINE_CALLSTATICMETHODA(jshort,   Short,   T_SHORT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1961
                        , HOTSPOT_JNI_CALLSTATICSHORTMETHODA_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1962
                        HOTSPOT_JNI_CALLSTATICSHORTMETHODA_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1963
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1964
DEFINE_CALLSTATICMETHODA(jobject,  Object,  T_OBJECT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1965
                        , HOTSPOT_JNI_CALLSTATICOBJECTMETHODA_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1966
                        HOTSPOT_JNI_CALLSTATICOBJECTMETHODA_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1967
DEFINE_CALLSTATICMETHODA(jint,     Int,     T_INT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1968
                        , HOTSPOT_JNI_CALLSTATICINTMETHODA_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1969
                        HOTSPOT_JNI_CALLSTATICINTMETHODA_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1970
DEFINE_CALLSTATICMETHODA(jlong,    Long,    T_LONG
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1971
                        , HOTSPOT_JNI_CALLSTATICLONGMETHODA_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1972
                        HOTSPOT_JNI_CALLSTATICLONGMETHODA_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1973
// Float and double probes don't return value because dtrace doesn't currently support it
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1974
DEFINE_CALLSTATICMETHODA(jfloat,   Float,   T_FLOAT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1975
                        , HOTSPOT_JNI_CALLSTATICFLOATMETHODA_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1976
                        HOTSPOT_JNI_CALLSTATICFLOATMETHODA_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1977
DEFINE_CALLSTATICMETHODA(jdouble,  Double,  T_DOUBLE
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1978
                        , HOTSPOT_JNI_CALLSTATICDOUBLEMETHODA_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1979
                        HOTSPOT_JNI_CALLSTATICDOUBLEMETHODA_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1980
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1981
DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethod
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1982
                         , HOTSPOT_JNI_CALLSTATICVOIDMETHOD_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1983
DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodV
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1984
                         , HOTSPOT_JNI_CALLSTATICVOIDMETHODV_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1985
DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodA
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1986
                         , HOTSPOT_JNI_CALLSTATICVOIDMETHODA_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1987
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1988
JNI_ENTRY(void, jni_CallStaticVoidMethod(JNIEnv *env, jclass cls, jmethodID methodID, ...))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1989
  JNIWrapper("CallStaticVoidMethod");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  1990
  HOTSPOT_JNI_CALLSTATICVOIDMETHOD_ENTRY(env, cls, (uintptr_t) methodID);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1991
  DT_VOID_RETURN_MARK(CallStaticVoidMethod);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1992
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1993
  va_list args;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1994
  va_start(args, methodID);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1995
  JavaValue jvalue(T_VOID);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1996
  JNI_ArgumentPusherVaArg ap(methodID, args);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1997
  jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1998
  va_end(args);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1999
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2000
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2001
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2002
JNI_ENTRY(void, jni_CallStaticVoidMethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2003
  JNIWrapper("CallStaticVoidMethodV");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2004
  HOTSPOT_JNI_CALLSTATICVOIDMETHODV_ENTRY(env, cls, (uintptr_t) methodID);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2005
  DT_VOID_RETURN_MARK(CallStaticVoidMethodV);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2006
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2007
  JavaValue jvalue(T_VOID);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  2008
  JNI_ArgumentPusherVaArg ap(methodID, args);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2009
  jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2010
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2011
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2012
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2013
JNI_ENTRY(void, jni_CallStaticVoidMethodA(JNIEnv *env, jclass cls, jmethodID methodID, const jvalue *args))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2014
  JNIWrapper("CallStaticVoidMethodA");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2015
  HOTSPOT_JNI_CALLSTATICVOIDMETHODA_ENTRY(env, cls, (uintptr_t) methodID);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2016
  DT_VOID_RETURN_MARK(CallStaticVoidMethodA);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2017
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2018
  JavaValue jvalue(T_VOID);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  2019
  JNI_ArgumentPusherArray ap(methodID, args);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2020
  jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2021
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2022
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2023
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2024
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2025
// Accessing Fields
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2026
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2027
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2028
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2029
DT_RETURN_MARK_DECL(GetFieldID, jfieldID
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2030
                    , HOTSPOT_JNI_GETFIELDID_RETURN((uintptr_t)_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2031
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2032
JNI_ENTRY(jfieldID, jni_GetFieldID(JNIEnv *env, jclass clazz,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2033
          const char *name, const char *sig))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2034
  JNIWrapper("GetFieldID");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2035
  HOTSPOT_JNI_GETFIELDID_ENTRY(env, clazz, (char *) name, (char *) sig);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2036
  jfieldID ret = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2037
  DT_RETURN_MARK(GetFieldID, jfieldID, (const jfieldID&)ret);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2038
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2039
  // The class should have been loaded (we have an instance of the class
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2040
  // passed in) so the field and signature should already be in the symbol
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2041
  // table.  If they're not there, the field doesn't exist.
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  2042
  TempNewSymbol fieldname = SymbolTable::probe(name, (int)strlen(name));
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  2043
  TempNewSymbol signame = SymbolTable::probe(sig, (int)strlen(sig));
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  2044
  if (fieldname == NULL || signame == NULL) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2045
    THROW_MSG_0(vmSymbols::java_lang_NoSuchFieldError(), (char*) name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2046
  }
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  2047
  Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2048
  // Make sure class is initialized before handing id's out to fields
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  2049
  k->initialize(CHECK_NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2050
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2051
  fieldDescriptor fd;
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  2052
  if (!k->is_instance_klass() ||
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  2053
      !InstanceKlass::cast(k)->find_field(fieldname, signame, false, &fd)) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2054
    THROW_MSG_0(vmSymbols::java_lang_NoSuchFieldError(), (char*) name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2055
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2056
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2057
  // A jfieldID for a non-static field is simply the offset of the field within the instanceOop
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2058
  // It may also have hash bits for k, if VerifyJNIFields is turned on.
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  2059
  ret = jfieldIDWorkaround::to_instance_jfieldID(k, fd.offset());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2060
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2061
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2062
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2063
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2064
JNI_ENTRY(jobject, jni_GetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2065
  JNIWrapper("GetObjectField");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2066
  HOTSPOT_JNI_GETOBJECTFIELD_ENTRY(env, obj, (uintptr_t) fieldID);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2067
  oop o = JNIHandles::resolve_non_null(obj);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  2068
  Klass* k = o->klass();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2069
  int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2070
  // Keep JVMTI addition small and only check enabled flag here.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2071
  // jni_GetField_probe() assumes that is okay to create handles.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2072
  if (JvmtiExport::should_post_field_access()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2073
    o = JvmtiExport::jni_GetField_probe(thread, obj, o, k, fieldID, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2074
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2075
  jobject ret = JNIHandles::make_local(env, o->obj_field(offset));
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14585
diff changeset
  2076
#if INCLUDE_ALL_GCS
9176
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8725
diff changeset
  2077
  // If G1 is enabled and we are accessing the value of the referent
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8725
diff changeset
  2078
  // field in a reference object then we need to register a non-null
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8725
diff changeset
  2079
  // referent with the SATB barrier.
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8725
diff changeset
  2080
  if (UseG1GC) {
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8725
diff changeset
  2081
    bool needs_barrier = false;
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8725
diff changeset
  2082
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8725
diff changeset
  2083
    if (ret != NULL &&
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8725
diff changeset
  2084
        offset == java_lang_ref_Reference::referent_offset &&
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  2085
        InstanceKlass::cast(k)->reference_type() != REF_NONE) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  2086
      assert(InstanceKlass::cast(k)->is_subclass_of(SystemDictionary::Reference_klass()), "sanity");
9176
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8725
diff changeset
  2087
      needs_barrier = true;
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8725
diff changeset
  2088
    }
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8725
diff changeset
  2089
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8725
diff changeset
  2090
    if (needs_barrier) {
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8725
diff changeset
  2091
      oop referent = JNIHandles::resolve(ret);
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8725
diff changeset
  2092
      G1SATBCardTableModRefBS::enqueue(referent);
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8725
diff changeset
  2093
    }
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8725
diff changeset
  2094
  }
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14585
diff changeset
  2095
#endif // INCLUDE_ALL_GCS
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2096
HOTSPOT_JNI_GETOBJECTFIELD_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2097
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2098
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2099
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2100
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2101
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2102
#define DEFINE_GETFIELD(Return,Fieldname,Result \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2103
  , EntryProbe, ReturnProbe) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2104
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2105
  DT_RETURN_MARK_DECL_FOR(Result, Get##Result##Field, Return \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2106
  , ReturnProbe); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2107
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2108
JNI_QUICK_ENTRY(Return, jni_Get##Result##Field(JNIEnv *env, jobject obj, jfieldID fieldID)) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2109
  JNIWrapper("Get" XSTR(Result) "Field"); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2110
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2111
  EntryProbe; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2112
  Return ret = 0;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2113
  DT_RETURN_MARK_FOR(Result, Get##Result##Field, Return, (const Return&)ret);\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2114
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2115
  oop o = JNIHandles::resolve_non_null(obj); \
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  2116
  Klass* k = o->klass(); \
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2117
  int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID);  \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2118
  /* Keep JVMTI addition small and only check enabled flag here.       */ \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2119
  /* jni_GetField_probe_nh() assumes that is not okay to create handles */ \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2120
  /* and creates a ResetNoHandleMark.                                   */ \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2121
  if (JvmtiExport::should_post_field_access()) { \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2122
    o = JvmtiExport::jni_GetField_probe_nh(thread, obj, o, k, fieldID, false); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2123
  } \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2124
  ret = o->Fieldname##_field(offset); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2125
  return ret; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2126
JNI_END
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2127
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2128
DEFINE_GETFIELD(jboolean, bool,   Boolean
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2129
                , HOTSPOT_JNI_GETBOOLEANFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2130
                HOTSPOT_JNI_GETBOOLEANFIELD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2131
DEFINE_GETFIELD(jbyte,    byte,   Byte
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2132
                , HOTSPOT_JNI_GETBYTEFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2133
                HOTSPOT_JNI_GETBYTEFIELD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2134
DEFINE_GETFIELD(jchar,    char,   Char
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2135
                , HOTSPOT_JNI_GETCHARFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2136
                HOTSPOT_JNI_GETCHARFIELD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2137
DEFINE_GETFIELD(jshort,   short,  Short
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2138
                , HOTSPOT_JNI_GETSHORTFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2139
                HOTSPOT_JNI_GETSHORTFIELD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2140
DEFINE_GETFIELD(jint,     int,    Int
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2141
                , HOTSPOT_JNI_GETINTFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2142
                HOTSPOT_JNI_GETINTFIELD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2143
DEFINE_GETFIELD(jlong,    long,   Long
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2144
                , HOTSPOT_JNI_GETLONGFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2145
                HOTSPOT_JNI_GETLONGFIELD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2146
// Float and double probes don't return value because dtrace doesn't currently support it
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2147
DEFINE_GETFIELD(jfloat,   float,  Float
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2148
                , HOTSPOT_JNI_GETFLOATFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2149
                HOTSPOT_JNI_GETFLOATFIELD_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2150
DEFINE_GETFIELD(jdouble,  double, Double
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2151
                , HOTSPOT_JNI_GETDOUBLEFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2152
                HOTSPOT_JNI_GETDOUBLEFIELD_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2153
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2154
address jni_GetBooleanField_addr() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2155
  return (address)jni_GetBooleanField;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2156
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2157
address jni_GetByteField_addr() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2158
  return (address)jni_GetByteField;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2159
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2160
address jni_GetCharField_addr() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2161
  return (address)jni_GetCharField;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2162
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2163
address jni_GetShortField_addr() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2164
  return (address)jni_GetShortField;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2165
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2166
address jni_GetIntField_addr() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2167
  return (address)jni_GetIntField;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2168
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2169
address jni_GetLongField_addr() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2170
  return (address)jni_GetLongField;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2171
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2172
address jni_GetFloatField_addr() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2173
  return (address)jni_GetFloatField;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2174
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2175
address jni_GetDoubleField_addr() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2176
  return (address)jni_GetDoubleField;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2177
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2178
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2179
JNI_QUICK_ENTRY(void, jni_SetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID, jobject value))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2180
  JNIWrapper("SetObjectField");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2181
  HOTSPOT_JNI_SETOBJECTFIELD_ENTRY(env, obj, (uintptr_t) fieldID, value);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2182
  oop o = JNIHandles::resolve_non_null(obj);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  2183
  Klass* k = o->klass();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2184
  int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2185
  // Keep JVMTI addition small and only check enabled flag here.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2186
  // jni_SetField_probe_nh() assumes that is not okay to create handles
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2187
  // and creates a ResetNoHandleMark.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2188
  if (JvmtiExport::should_post_field_modification()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2189
    jvalue field_value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2190
    field_value.l = value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2191
    o = JvmtiExport::jni_SetField_probe_nh(thread, obj, o, k, fieldID, false, 'L', (jvalue *)&field_value);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2192
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2193
  o->obj_field_put(offset, JNIHandles::resolve(value));
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2194
  HOTSPOT_JNI_SETOBJECTFIELD_RETURN();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2195
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2196
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2197
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2198
#define DEFINE_SETFIELD(Argument,Fieldname,Result,SigType,unionType \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2199
                        , EntryProbe, ReturnProbe) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2200
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2201
JNI_QUICK_ENTRY(void, jni_Set##Result##Field(JNIEnv *env, jobject obj, jfieldID fieldID, Argument value)) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2202
  JNIWrapper("Set" XSTR(Result) "Field"); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2203
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2204
  EntryProbe; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2205
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2206
  oop o = JNIHandles::resolve_non_null(obj); \
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  2207
  Klass* k = o->klass(); \
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2208
  int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID);  \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2209
  /* Keep JVMTI addition small and only check enabled flag here.       */ \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2210
  /* jni_SetField_probe_nh() assumes that is not okay to create handles */ \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2211
  /* and creates a ResetNoHandleMark.                                   */ \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2212
  if (JvmtiExport::should_post_field_modification()) { \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2213
    jvalue field_value; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2214
    field_value.unionType = value; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2215
    o = JvmtiExport::jni_SetField_probe_nh(thread, obj, o, k, fieldID, false, SigType, (jvalue *)&field_value); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2216
  } \
37480
291ee208fb72 8132051: Better byte behavior
coleenp
parents: 37248
diff changeset
  2217
  if (SigType == 'Z') { value = ((jboolean)value) & 1; } \
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2218
  o->Fieldname##_field_put(offset, value); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2219
  ReturnProbe; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2220
JNI_END
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2221
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2222
DEFINE_SETFIELD(jboolean, bool,   Boolean, 'Z', z
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2223
                , HOTSPOT_JNI_SETBOOLEANFIELD_ENTRY(env, obj, (uintptr_t)fieldID, value),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2224
                HOTSPOT_JNI_SETBOOLEANFIELD_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2225
DEFINE_SETFIELD(jbyte,    byte,   Byte,    'B', b
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2226
                , HOTSPOT_JNI_SETBYTEFIELD_ENTRY(env, obj, (uintptr_t)fieldID, value),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2227
                HOTSPOT_JNI_SETBYTEFIELD_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2228
DEFINE_SETFIELD(jchar,    char,   Char,    'C', c
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2229
                , HOTSPOT_JNI_SETCHARFIELD_ENTRY(env, obj, (uintptr_t)fieldID, value),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2230
                HOTSPOT_JNI_SETCHARFIELD_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2231
DEFINE_SETFIELD(jshort,   short,  Short,   'S', s
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2232
                , HOTSPOT_JNI_SETSHORTFIELD_ENTRY(env, obj, (uintptr_t)fieldID, value),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2233
                HOTSPOT_JNI_SETSHORTFIELD_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2234
DEFINE_SETFIELD(jint,     int,    Int,     'I', i
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2235
                , HOTSPOT_JNI_SETINTFIELD_ENTRY(env, obj, (uintptr_t)fieldID, value),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2236
                HOTSPOT_JNI_SETINTFIELD_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2237
DEFINE_SETFIELD(jlong,    long,   Long,    'J', j
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2238
                , HOTSPOT_JNI_SETLONGFIELD_ENTRY(env, obj, (uintptr_t)fieldID, value),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2239
                HOTSPOT_JNI_SETLONGFIELD_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2240
// Float and double probes don't return value because dtrace doesn't currently support it
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2241
DEFINE_SETFIELD(jfloat,   float,  Float,   'F', f
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2242
                , HOTSPOT_JNI_SETFLOATFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2243
                HOTSPOT_JNI_SETFLOATFIELD_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2244
DEFINE_SETFIELD(jdouble,  double, Double,  'D', d
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2245
                , HOTSPOT_JNI_SETDOUBLEFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2246
                HOTSPOT_JNI_SETDOUBLEFIELD_RETURN())
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  2247
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2248
DT_RETURN_MARK_DECL(ToReflectedField, jobject
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2249
                    , HOTSPOT_JNI_TOREFLECTEDFIELD_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2250
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2251
JNI_ENTRY(jobject, jni_ToReflectedField(JNIEnv *env, jclass cls, jfieldID fieldID, jboolean isStatic))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2252
  JNIWrapper("ToReflectedField");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2253
  HOTSPOT_JNI_TOREFLECTEDFIELD_ENTRY(env, cls, (uintptr_t) fieldID, isStatic);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2254
  jobject ret = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2255
  DT_RETURN_MARK(ToReflectedField, jobject, (const jobject&)ret);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2256
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2257
  fieldDescriptor fd;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2258
  bool found = false;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  2259
  Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2260
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2261
  assert(jfieldIDWorkaround::is_static_jfieldID(fieldID) == (isStatic != 0), "invalid fieldID");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2262
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2263
  if (isStatic) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  2264
    // Static field. The fieldID a JNIid specifying the field holder and the offset within the Klass*.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2265
    JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2266
    assert(id->is_static_field_id(), "invalid static field id");
8725
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8076
diff changeset
  2267
    found = id->find_local_field(&fd);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2268
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2269
    // Non-static field. The fieldID is really the offset of the field within the instanceOop.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2270
    int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  2271
    found = InstanceKlass::cast(k)->find_field_from_offset(offset, false, &fd);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2272
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2273
  assert(found, "bad fieldID passed into jni_ToReflectedField");
24456
8c7933fa5a1f 8025580: Temporary flags: UseNewReflection and ReflectionWrapResolutionErrors
coleenp
parents: 24424
diff changeset
  2274
  oop reflected = Reflection::new_field(&fd, CHECK_NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2275
  ret = JNIHandles::make_local(env, reflected);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2276
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2277
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2278
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2279
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2280
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2281
// Accessing Static Fields
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2282
//
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2283
DT_RETURN_MARK_DECL(GetStaticFieldID, jfieldID
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2284
                    , HOTSPOT_JNI_GETSTATICFIELDID_RETURN((uintptr_t)_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2285
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2286
JNI_ENTRY(jfieldID, jni_GetStaticFieldID(JNIEnv *env, jclass clazz,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2287
          const char *name, const char *sig))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2288
  JNIWrapper("GetStaticFieldID");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2289
  HOTSPOT_JNI_GETSTATICFIELDID_ENTRY(env, clazz, (char *) name, (char *) sig);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2290
  jfieldID ret = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2291
  DT_RETURN_MARK(GetStaticFieldID, jfieldID, (const jfieldID&)ret);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2292
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2293
  // The class should have been loaded (we have an instance of the class
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2294
  // passed in) so the field and signature should already be in the symbol
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2295
  // table.  If they're not there, the field doesn't exist.
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  2296
  TempNewSymbol fieldname = SymbolTable::probe(name, (int)strlen(name));
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  2297
  TempNewSymbol signame = SymbolTable::probe(sig, (int)strlen(sig));
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  2298
  if (fieldname == NULL || signame == NULL) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2299
    THROW_MSG_0(vmSymbols::java_lang_NoSuchFieldError(), (char*) name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2300
  }
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  2301
  Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2302
  // Make sure class is initialized before handing id's out to static fields
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  2303
  k->initialize(CHECK_NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2304
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2305
  fieldDescriptor fd;
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  2306
  if (!k->is_instance_klass() ||
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  2307
      !InstanceKlass::cast(k)->find_field(fieldname, signame, true, &fd)) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2308
    THROW_MSG_0(vmSymbols::java_lang_NoSuchFieldError(), (char*) name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2309
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2310
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  2311
  // A jfieldID for a static field is a JNIid specifying the field holder and the offset within the Klass*
14391
df0a1573d5bd 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents: 13977
diff changeset
  2312
  JNIid* id = fd.field_holder()->jni_id_for(fd.offset());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2313
  debug_only(id->set_is_static_field_id();)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2314
8725
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8076
diff changeset
  2315
  debug_only(id->verify(fd.field_holder()));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2316
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2317
  ret = jfieldIDWorkaround::to_static_jfieldID(id);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2318
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2319
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2320
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2321
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2322
JNI_ENTRY(jobject, jni_GetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2323
  JNIWrapper("GetStaticObjectField");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2324
  HOTSPOT_JNI_GETSTATICOBJECTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID);
13975
2f7431485cfa 7189254: Change makefiles for more flexibility to override defaults
jprovino
parents: 13728
diff changeset
  2325
#if INCLUDE_JNI_CHECK
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  2326
  DEBUG_ONLY(Klass* param_k = jniCheck::validate_class(thread, clazz);)
13975
2f7431485cfa 7189254: Change makefiles for more flexibility to override defaults
jprovino
parents: 13728
diff changeset
  2327
#endif // INCLUDE_JNI_CHECK
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2328
  JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2329
  assert(id->is_static_field_id(), "invalid static field id");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2330
  // Keep JVMTI addition small and only check enabled flag here.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2331
  // jni_GetField_probe() assumes that is okay to create handles.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2332
  if (JvmtiExport::should_post_field_access()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2333
    JvmtiExport::jni_GetField_probe(thread, NULL, NULL, id->holder(), fieldID, true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2334
  }
8725
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8076
diff changeset
  2335
  jobject ret = JNIHandles::make_local(id->holder()->java_mirror()->obj_field(id->offset()));
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2336
  HOTSPOT_JNI_GETSTATICOBJECTFIELD_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2337
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2338
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2339
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2340
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2341
#define DEFINE_GETSTATICFIELD(Return,Fieldname,Result \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2342
                              , EntryProbe, ReturnProbe) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2343
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2344
  DT_RETURN_MARK_DECL_FOR(Result, GetStatic##Result##Field, Return \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2345
                          , ReturnProbe);                                          \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2346
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2347
JNI_ENTRY(Return, jni_GetStatic##Result##Field(JNIEnv *env, jclass clazz, jfieldID fieldID)) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2348
  JNIWrapper("GetStatic" XSTR(Result) "Field"); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2349
  EntryProbe; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2350
  Return ret = 0;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2351
  DT_RETURN_MARK_FOR(Result, GetStatic##Result##Field, Return, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2352
                     (const Return&)ret);\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2353
  JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2354
  assert(id->is_static_field_id(), "invalid static field id"); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2355
  /* Keep JVMTI addition small and only check enabled flag here. */ \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2356
  /* jni_GetField_probe() assumes that is okay to create handles. */ \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2357
  if (JvmtiExport::should_post_field_access()) { \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2358
    JvmtiExport::jni_GetField_probe(thread, NULL, NULL, id->holder(), fieldID, true); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2359
  } \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2360
  ret = id->holder()->java_mirror()-> Fieldname##_field (id->offset()); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2361
  return ret;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2362
JNI_END
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2363
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2364
DEFINE_GETSTATICFIELD(jboolean, bool,   Boolean
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2365
                      , HOTSPOT_JNI_GETSTATICBOOLEANFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICBOOLEANFIELD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2366
DEFINE_GETSTATICFIELD(jbyte,    byte,   Byte
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2367
                      , HOTSPOT_JNI_GETSTATICBYTEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID),    HOTSPOT_JNI_GETSTATICBYTEFIELD_RETURN(_ret_ref)   )
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2368
DEFINE_GETSTATICFIELD(jchar,    char,   Char
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2369
                      , HOTSPOT_JNI_GETSTATICCHARFIELD_ENTRY(env, clazz, (uintptr_t) fieldID),    HOTSPOT_JNI_GETSTATICCHARFIELD_RETURN(_ret_ref)   )
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2370
DEFINE_GETSTATICFIELD(jshort,   short,  Short
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2371
                      , HOTSPOT_JNI_GETSTATICSHORTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID),   HOTSPOT_JNI_GETSTATICSHORTFIELD_RETURN(_ret_ref)  )
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2372
DEFINE_GETSTATICFIELD(jint,     int,    Int
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2373
                      , HOTSPOT_JNI_GETSTATICINTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID),     HOTSPOT_JNI_GETSTATICINTFIELD_RETURN(_ret_ref)    )
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2374
DEFINE_GETSTATICFIELD(jlong,    long,   Long
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2375
                      , HOTSPOT_JNI_GETSTATICLONGFIELD_ENTRY(env, clazz, (uintptr_t) fieldID),    HOTSPOT_JNI_GETSTATICLONGFIELD_RETURN(_ret_ref)   )
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2376
// Float and double probes don't return value because dtrace doesn't currently support it
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2377
DEFINE_GETSTATICFIELD(jfloat,   float,  Float
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2378
                      , HOTSPOT_JNI_GETSTATICFLOATFIELD_ENTRY(env, clazz, (uintptr_t) fieldID),   HOTSPOT_JNI_GETSTATICFLOATFIELD_RETURN()          )
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2379
DEFINE_GETSTATICFIELD(jdouble,  double, Double
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2380
                      , HOTSPOT_JNI_GETSTATICDOUBLEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID),  HOTSPOT_JNI_GETSTATICDOUBLEFIELD_RETURN()         )
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2381
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2382
JNI_ENTRY(void, jni_SetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2383
  JNIWrapper("SetStaticObjectField");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2384
 HOTSPOT_JNI_SETSTATICOBJECTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2385
  JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2386
  assert(id->is_static_field_id(), "invalid static field id");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2387
  // Keep JVMTI addition small and only check enabled flag here.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2388
  // jni_SetField_probe() assumes that is okay to create handles.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2389
  if (JvmtiExport::should_post_field_modification()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2390
    jvalue field_value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2391
    field_value.l = value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2392
    JvmtiExport::jni_SetField_probe(thread, NULL, NULL, id->holder(), fieldID, true, 'L', (jvalue *)&field_value);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2393
  }
8725
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8076
diff changeset
  2394
  id->holder()->java_mirror()->obj_field_put(id->offset(), JNIHandles::resolve(value));
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2395
  HOTSPOT_JNI_SETSTATICOBJECTFIELD_RETURN();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2396
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2397
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2398
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2399
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2400
#define DEFINE_SETSTATICFIELD(Argument,Fieldname,Result,SigType,unionType \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2401
                              , EntryProbe, ReturnProbe) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2402
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2403
JNI_ENTRY(void, jni_SetStatic##Result##Field(JNIEnv *env, jclass clazz, jfieldID fieldID, Argument value)) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2404
  JNIWrapper("SetStatic" XSTR(Result) "Field"); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2405
  EntryProbe; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2406
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2407
  JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2408
  assert(id->is_static_field_id(), "invalid static field id"); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2409
  /* Keep JVMTI addition small and only check enabled flag here. */ \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2410
  /* jni_SetField_probe() assumes that is okay to create handles. */ \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2411
  if (JvmtiExport::should_post_field_modification()) { \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2412
    jvalue field_value; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2413
    field_value.unionType = value; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2414
    JvmtiExport::jni_SetField_probe(thread, NULL, NULL, id->holder(), fieldID, true, SigType, (jvalue *)&field_value); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2415
  } \
37480
291ee208fb72 8132051: Better byte behavior
coleenp
parents: 37248
diff changeset
  2416
  if (SigType == 'Z') { value = ((jboolean)value) & 1; } \
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2417
  id->holder()->java_mirror()-> Fieldname##_field_put (id->offset(), value); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2418
  ReturnProbe;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2419
JNI_END
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2420
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2421
DEFINE_SETSTATICFIELD(jboolean, bool,   Boolean, 'Z', z
22190
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  2422
                      , HOTSPOT_JNI_SETSTATICBOOLEANFIELD_ENTRY(env, clazz, (uintptr_t)fieldID, value),
23997
73485c7e8122 8039947: Dtrace return probe name for jni_SetStaticBooleanField named incorrectly
dsimms
parents: 23859
diff changeset
  2423
                      HOTSPOT_JNI_SETSTATICBOOLEANFIELD_RETURN())
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2424
DEFINE_SETSTATICFIELD(jbyte,    byte,   Byte,    'B', b
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2425
                      , HOTSPOT_JNI_SETSTATICBYTEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2426
                      HOTSPOT_JNI_SETSTATICBYTEFIELD_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2427
DEFINE_SETSTATICFIELD(jchar,    char,   Char,    'C', c
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2428
                      , HOTSPOT_JNI_SETSTATICCHARFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2429
                      HOTSPOT_JNI_SETSTATICCHARFIELD_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2430
DEFINE_SETSTATICFIELD(jshort,   short,  Short,   'S', s
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2431
                      , HOTSPOT_JNI_SETSTATICSHORTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2432
                      HOTSPOT_JNI_SETSTATICSHORTFIELD_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2433
DEFINE_SETSTATICFIELD(jint,     int,    Int,     'I', i
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2434
                      , HOTSPOT_JNI_SETSTATICINTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2435
                      HOTSPOT_JNI_SETSTATICINTFIELD_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2436
DEFINE_SETSTATICFIELD(jlong,    long,   Long,    'J', j
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2437
                      , HOTSPOT_JNI_SETSTATICLONGFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2438
                      HOTSPOT_JNI_SETSTATICLONGFIELD_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2439
// Float and double probes don't return value because dtrace doesn't currently support it
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2440
DEFINE_SETSTATICFIELD(jfloat,   float,  Float,   'F', f
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2441
                      , HOTSPOT_JNI_SETSTATICFLOATFIELD_ENTRY(env, clazz, (uintptr_t) fieldID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2442
                      HOTSPOT_JNI_SETSTATICFLOATFIELD_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2443
DEFINE_SETSTATICFIELD(jdouble,  double, Double,  'D', d
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2444
                      , HOTSPOT_JNI_SETSTATICDOUBLEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2445
                      HOTSPOT_JNI_SETSTATICDOUBLEFIELD_RETURN())
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2446
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2447
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2448
// String Operations
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2449
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2450
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2451
// Unicode Interface
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2452
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2453
DT_RETURN_MARK_DECL(NewString, jstring
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2454
                    , HOTSPOT_JNI_NEWSTRING_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2455
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2456
JNI_ENTRY(jstring, jni_NewString(JNIEnv *env, const jchar *unicodeChars, jsize len))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2457
  JNIWrapper("NewString");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2458
 HOTSPOT_JNI_NEWSTRING_ENTRY(env, (uint16_t *) unicodeChars, len);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2459
  jstring ret = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2460
  DT_RETURN_MARK(NewString, jstring, (const jstring&)ret);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2461
  oop string=java_lang_String::create_oop_from_unicode((jchar*) unicodeChars, len, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2462
  ret = (jstring) JNIHandles::make_local(env, string);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2463
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2464
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2465
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2466
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2467
JNI_QUICK_ENTRY(jsize, jni_GetStringLength(JNIEnv *env, jstring string))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2468
  JNIWrapper("GetStringLength");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2469
  HOTSPOT_JNI_GETSTRINGLENGTH_ENTRY(env, string);
20387
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2470
  jsize ret = 0;
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2471
  oop s = JNIHandles::resolve_non_null(string);
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2472
  if (java_lang_String::value(s) != NULL) {
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2473
    ret = java_lang_String::length(s);
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2474
  }
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2475
 HOTSPOT_JNI_GETSTRINGLENGTH_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2476
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2477
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2478
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2479
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2480
JNI_QUICK_ENTRY(const jchar*, jni_GetStringChars(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2481
  JNIEnv *env, jstring string, jboolean *isCopy))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2482
  JNIWrapper("GetStringChars");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2483
 HOTSPOT_JNI_GETSTRINGCHARS_ENTRY(env, string, (uintptr_t *) isCopy);
20387
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2484
  jchar* buf = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2485
  oop s = JNIHandles::resolve_non_null(string);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2486
  typeArrayOop s_value = java_lang_String::value(s);
20387
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2487
  if (s_value != NULL) {
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2488
    int s_len = java_lang_String::length(s);
33628
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  2489
    bool is_latin1 = java_lang_String::is_latin1(s);
20387
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2490
    buf = NEW_C_HEAP_ARRAY_RETURN_NULL(jchar, s_len + 1, mtInternal);  // add one for zero termination
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2491
    /* JNI Specification states return NULL on OOM */
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2492
    if (buf != NULL) {
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2493
      if (s_len > 0) {
33628
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  2494
        if (!is_latin1) {
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  2495
          memcpy(buf, s_value->char_at_addr(0), sizeof(jchar)*s_len);
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  2496
        } else {
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  2497
          for (int i = 0; i < s_len; i++) {
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  2498
            buf[i] = ((jchar) s_value->byte_at(i)) & 0xff;
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  2499
          }
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  2500
        }
20387
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2501
      }
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2502
      buf[s_len] = 0;
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2503
      //%note jni_5
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2504
      if (isCopy != NULL) {
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2505
        *isCopy = JNI_TRUE;
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2506
      }
19545
409c50cf1e5d 8022683: JNI GetStringUTFChars should return NULL on allocation failure not abort the VM
dsimms
parents: 18683
diff changeset
  2507
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2508
  }
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2509
  HOTSPOT_JNI_GETSTRINGCHARS_RETURN(buf);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2510
  return buf;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2511
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2512
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2513
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2514
JNI_QUICK_ENTRY(void, jni_ReleaseStringChars(JNIEnv *env, jstring str, const jchar *chars))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2515
  JNIWrapper("ReleaseStringChars");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2516
  HOTSPOT_JNI_RELEASESTRINGCHARS_ENTRY(env, str, (uint16_t *) chars);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2517
  //%note jni_6
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2518
  if (chars != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2519
    // Since String objects are supposed to be immutable, don't copy any
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2520
    // new data back.  A bad user will have to go after the char array.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2521
    FreeHeap((void*) chars);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2522
  }
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2523
  HOTSPOT_JNI_RELEASESTRINGCHARS_RETURN();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2524
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2525
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2526
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2527
// UTF Interface
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2528
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2529
DT_RETURN_MARK_DECL(NewStringUTF, jstring
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2530
                    , HOTSPOT_JNI_NEWSTRINGUTF_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2531
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2532
JNI_ENTRY(jstring, jni_NewStringUTF(JNIEnv *env, const char *bytes))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2533
  JNIWrapper("NewStringUTF");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2534
  HOTSPOT_JNI_NEWSTRINGUTF_ENTRY(env, (char *) bytes);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2535
  jstring ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2536
  DT_RETURN_MARK(NewStringUTF, jstring, (const jstring&)ret);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2537
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2538
  oop result = java_lang_String::create_oop_from_str((char*) bytes, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2539
  ret = (jstring) JNIHandles::make_local(env, result);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2540
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2541
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2542
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2543
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2544
JNI_ENTRY(jsize, jni_GetStringUTFLength(JNIEnv *env, jstring string))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2545
  JNIWrapper("GetStringUTFLength");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2546
 HOTSPOT_JNI_GETSTRINGUTFLENGTH_ENTRY(env, string);
20387
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2547
  jsize ret = 0;
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2548
  oop java_string = JNIHandles::resolve_non_null(string);
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2549
  if (java_lang_String::value(java_string) != NULL) {
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2550
    ret = java_lang_String::utf8_length(java_string);
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2551
  }
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2552
  HOTSPOT_JNI_GETSTRINGUTFLENGTH_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2553
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2554
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2555
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2556
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2557
JNI_ENTRY(const char*, jni_GetStringUTFChars(JNIEnv *env, jstring string, jboolean *isCopy))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2558
  JNIWrapper("GetStringUTFChars");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2559
 HOTSPOT_JNI_GETSTRINGUTFCHARS_ENTRY(env, string, (uintptr_t *) isCopy);
20387
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2560
  char* result = NULL;
7414
940d84ca7fca 6539281: -Xcheck:jni should validate char* argument to ReleaseStringUTFChars
sla
parents: 7405
diff changeset
  2561
  oop java_string = JNIHandles::resolve_non_null(string);
20387
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2562
  if (java_lang_String::value(java_string) != NULL) {
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2563
    size_t length = java_lang_String::utf8_length(java_string);
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2564
    /* JNI Specification states return NULL on OOM */
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2565
    result = AllocateHeap(length + 1, mtInternal, 0, AllocFailStrategy::RETURN_NULL);
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2566
    if (result != NULL) {
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2567
      java_lang_String::as_utf8_string(java_string, result, (int) length + 1);
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2568
      if (isCopy != NULL) {
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2569
        *isCopy = JNI_TRUE;
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2570
      }
19545
409c50cf1e5d 8022683: JNI GetStringUTFChars should return NULL on allocation failure not abort the VM
dsimms
parents: 18683
diff changeset
  2571
    }
409c50cf1e5d 8022683: JNI GetStringUTFChars should return NULL on allocation failure not abort the VM
dsimms
parents: 18683
diff changeset
  2572
  }
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2573
 HOTSPOT_JNI_GETSTRINGUTFCHARS_RETURN(result);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2574
  return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2575
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2576
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2577
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2578
JNI_LEAF(void, jni_ReleaseStringUTFChars(JNIEnv *env, jstring str, const char *chars))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2579
  JNIWrapper("ReleaseStringUTFChars");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2580
 HOTSPOT_JNI_RELEASESTRINGUTFCHARS_ENTRY(env, str, (char *) chars);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2581
  if (chars != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2582
    FreeHeap((char*) chars);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2583
  }
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2584
HOTSPOT_JNI_RELEASESTRINGUTFCHARS_RETURN();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2585
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2586
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2587
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2588
JNI_QUICK_ENTRY(jsize, jni_GetArrayLength(JNIEnv *env, jarray array))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2589
  JNIWrapper("GetArrayLength");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2590
 HOTSPOT_JNI_GETARRAYLENGTH_ENTRY(env, array);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2591
  arrayOop a = arrayOop(JNIHandles::resolve_non_null(array));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2592
  assert(a->is_array(), "must be array");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2593
  jsize ret = a->length();
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2594
 HOTSPOT_JNI_GETARRAYLENGTH_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2595
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2596
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2597
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2598
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2599
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2600
// Object Array Operations
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2601
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2602
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2603
DT_RETURN_MARK_DECL(NewObjectArray, jobjectArray
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2604
                    , HOTSPOT_JNI_NEWOBJECTARRAY_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2605
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2606
JNI_ENTRY(jobjectArray, jni_NewObjectArray(JNIEnv *env, jsize length, jclass elementClass, jobject initialElement))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2607
  JNIWrapper("NewObjectArray");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2608
 HOTSPOT_JNI_NEWOBJECTARRAY_ENTRY(env, length, elementClass, initialElement);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2609
  jobjectArray ret = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2610
  DT_RETURN_MARK(NewObjectArray, jobjectArray, (const jobjectArray&)ret);
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  2611
  Klass* ek = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(elementClass));
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  2612
  Klass* ak = ek->array_klass(CHECK_NULL);
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  2613
  ObjArrayKlass::cast(ak)->initialize(CHECK_NULL);
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  2614
  objArrayOop result = ObjArrayKlass::cast(ak)->allocate(length, CHECK_NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2615
  oop initial_value = JNIHandles::resolve(initialElement);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2616
  if (initial_value != NULL) {  // array already initialized with NULL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2617
    for (int index = 0; index < length; index++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2618
      result->obj_at_put(index, initial_value);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2619
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2620
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2621
  ret = (jobjectArray) JNIHandles::make_local(env, result);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2622
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2623
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2624
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2625
DT_RETURN_MARK_DECL(GetObjectArrayElement, jobject
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2626
                    , HOTSPOT_JNI_GETOBJECTARRAYELEMENT_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2627
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2628
JNI_ENTRY(jobject, jni_GetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2629
  JNIWrapper("GetObjectArrayElement");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2630
 HOTSPOT_JNI_GETOBJECTARRAYELEMENT_ENTRY(env, array, index);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2631
  jobject ret = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2632
  DT_RETURN_MARK(GetObjectArrayElement, jobject, (const jobject&)ret);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2633
  objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2634
  if (a->is_within_bounds(index)) {
4089
14bd2cd13a2c 6893483: DTrace probe return values for a couple JNI methods are wrong
kamg
parents: 3820
diff changeset
  2635
    ret = JNIHandles::make_local(env, a->obj_at(index));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2636
    return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2637
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2638
    char buf[jintAsStringSize];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2639
    sprintf(buf, "%d", index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2640
    THROW_MSG_0(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), buf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2641
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2642
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2643
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2644
DT_VOID_RETURN_MARK_DECL(SetObjectArrayElement
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2645
                         , HOTSPOT_JNI_SETOBJECTARRAYELEMENT_RETURN());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2646
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2647
JNI_ENTRY(void, jni_SetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index, jobject value))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2648
  JNIWrapper("SetObjectArrayElement");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2649
 HOTSPOT_JNI_SETOBJECTARRAYELEMENT_ENTRY(env, array, index, value);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2650
  DT_VOID_RETURN_MARK(SetObjectArrayElement);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2651
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2652
  objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2653
  oop v = JNIHandles::resolve(value);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2654
  if (a->is_within_bounds(index)) {
13952
e3cf184080bc 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents: 13728
diff changeset
  2655
    if (v == NULL || v->is_a(ObjArrayKlass::cast(a->klass())->element_klass())) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2656
      a->obj_at_put(index, v);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2657
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2658
      THROW(vmSymbols::java_lang_ArrayStoreException());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2659
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2660
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2661
    char buf[jintAsStringSize];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2662
    sprintf(buf, "%d", index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2663
    THROW_MSG(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), buf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2664
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2665
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2666
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2667
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2668
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2669
#define DEFINE_NEWSCALARARRAY(Return,Allocator,Result \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2670
                              ,EntryProbe,ReturnProbe)  \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2671
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2672
  DT_RETURN_MARK_DECL(New##Result##Array, Return \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2673
                      , ReturnProbe); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2674
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2675
JNI_ENTRY(Return, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2676
          jni_New##Result##Array(JNIEnv *env, jsize len)) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2677
  JNIWrapper("New" XSTR(Result) "Array"); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2678
  EntryProbe; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2679
  Return ret = NULL;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2680
  DT_RETURN_MARK(New##Result##Array, Return, (const Return&)ret);\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2681
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2682
  oop obj= oopFactory::Allocator(len, CHECK_0); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2683
  ret = (Return) JNIHandles::make_local(env, obj); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2684
  return ret;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2685
JNI_END
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2686
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2687
DEFINE_NEWSCALARARRAY(jbooleanArray, new_boolArray,   Boolean,
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2688
                      HOTSPOT_JNI_NEWBOOLEANARRAY_ENTRY(env, len),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2689
                      HOTSPOT_JNI_NEWBOOLEANARRAY_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2690
DEFINE_NEWSCALARARRAY(jbyteArray,    new_byteArray,   Byte,
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2691
                      HOTSPOT_JNI_NEWBYTEARRAY_ENTRY(env, len),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2692
                      HOTSPOT_JNI_NEWBYTEARRAY_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2693
DEFINE_NEWSCALARARRAY(jshortArray,   new_shortArray,  Short,
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2694
                      HOTSPOT_JNI_NEWSHORTARRAY_ENTRY(env, len),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2695
                      HOTSPOT_JNI_NEWSHORTARRAY_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2696
DEFINE_NEWSCALARARRAY(jcharArray,    new_charArray,   Char,
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2697
                      HOTSPOT_JNI_NEWCHARARRAY_ENTRY(env, len),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2698
                      HOTSPOT_JNI_NEWCHARARRAY_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2699
DEFINE_NEWSCALARARRAY(jintArray,     new_intArray,    Int,
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2700
                      HOTSPOT_JNI_NEWINTARRAY_ENTRY(env, len),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2701
                      HOTSPOT_JNI_NEWINTARRAY_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2702
DEFINE_NEWSCALARARRAY(jlongArray,    new_longArray,   Long,
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2703
                      HOTSPOT_JNI_NEWLONGARRAY_ENTRY(env, len),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2704
                      HOTSPOT_JNI_NEWLONGARRAY_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2705
DEFINE_NEWSCALARARRAY(jfloatArray,   new_singleArray, Float,
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2706
                      HOTSPOT_JNI_NEWFLOATARRAY_ENTRY(env, len),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2707
                      HOTSPOT_JNI_NEWFLOATARRAY_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2708
DEFINE_NEWSCALARARRAY(jdoubleArray,  new_doubleArray, Double,
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2709
                      HOTSPOT_JNI_NEWDOUBLEARRAY_ENTRY(env, len),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2710
                      HOTSPOT_JNI_NEWDOUBLEARRAY_RETURN(_ret_ref))
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2711
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2712
// Return an address which will fault if the caller writes to it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2713
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2714
static char* get_bad_address() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2715
  static char* bad_address = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2716
  if (bad_address == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2717
    size_t size = os::vm_allocation_granularity();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2718
    bad_address = os::reserve_memory(size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2719
    if (bad_address != NULL) {
1664
fc9ed50498fb 6727377: VM stack guard pages on Windows should PAGE_READWRITE not PAGE_EXECUTE_READWRITE
coleenp
parents: 823
diff changeset
  2720
      os::protect_memory(bad_address, size, os::MEM_PROT_READ,
fc9ed50498fb 6727377: VM stack guard pages on Windows should PAGE_READWRITE not PAGE_EXECUTE_READWRITE
coleenp
parents: 823
diff changeset
  2721
                         /*is_committed*/false);
25946
1572c9f03fb9 8046598: Scalable Native memory tracking development
zgu
parents: 25633
diff changeset
  2722
      MemTracker::record_virtual_memory_type((void*)bad_address, mtInternal);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2723
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2724
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2725
  return bad_address;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2726
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2727
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2728
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2729
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2730
#define DEFINE_GETSCALARARRAYELEMENTS(ElementTag,ElementType,Result, Tag \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2731
                                      , EntryProbe, ReturnProbe) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2732
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2733
JNI_QUICK_ENTRY(ElementType*, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2734
          jni_Get##Result##ArrayElements(JNIEnv *env, ElementType##Array array, jboolean *isCopy)) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2735
  JNIWrapper("Get" XSTR(Result) "ArrayElements"); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2736
  EntryProbe; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2737
  /* allocate an chunk of memory in c land */ \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2738
  typeArrayOop a = typeArrayOop(JNIHandles::resolve_non_null(array)); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2739
  ElementType* result; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2740
  int len = a->length(); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2741
  if (len == 0) { \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2742
    /* Empty array: legal but useless, can't return NULL. \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2743
     * Return a pointer to something useless. \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2744
     * Avoid asserts in typeArrayOop. */ \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2745
    result = (ElementType*)get_bad_address(); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2746
  } else { \
19545
409c50cf1e5d 8022683: JNI GetStringUTFChars should return NULL on allocation failure not abort the VM
dsimms
parents: 18683
diff changeset
  2747
    /* JNI Specification states return NULL on OOM */                    \
409c50cf1e5d 8022683: JNI GetStringUTFChars should return NULL on allocation failure not abort the VM
dsimms
parents: 18683
diff changeset
  2748
    result = NEW_C_HEAP_ARRAY_RETURN_NULL(ElementType, len, mtInternal); \
409c50cf1e5d 8022683: JNI GetStringUTFChars should return NULL on allocation failure not abort the VM
dsimms
parents: 18683
diff changeset
  2749
    if (result != NULL) {                                                \
409c50cf1e5d 8022683: JNI GetStringUTFChars should return NULL on allocation failure not abort the VM
dsimms
parents: 18683
diff changeset
  2750
      /* copy the array to the c chunk */                                \
409c50cf1e5d 8022683: JNI GetStringUTFChars should return NULL on allocation failure not abort the VM
dsimms
parents: 18683
diff changeset
  2751
      memcpy(result, a->Tag##_at_addr(0), sizeof(ElementType)*len);      \
409c50cf1e5d 8022683: JNI GetStringUTFChars should return NULL on allocation failure not abort the VM
dsimms
parents: 18683
diff changeset
  2752
      if (isCopy) {                                                      \
409c50cf1e5d 8022683: JNI GetStringUTFChars should return NULL on allocation failure not abort the VM
dsimms
parents: 18683
diff changeset
  2753
        *isCopy = JNI_TRUE;                                              \
409c50cf1e5d 8022683: JNI GetStringUTFChars should return NULL on allocation failure not abort the VM
dsimms
parents: 18683
diff changeset
  2754
      }                                                                  \
409c50cf1e5d 8022683: JNI GetStringUTFChars should return NULL on allocation failure not abort the VM
dsimms
parents: 18683
diff changeset
  2755
    }                                                                    \
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2756
  } \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2757
  ReturnProbe; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2758
  return result; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2759
JNI_END
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2760
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2761
DEFINE_GETSCALARARRAYELEMENTS(T_BOOLEAN, jboolean, Boolean, bool
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2762
                              , HOTSPOT_JNI_GETBOOLEANARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2763
                              HOTSPOT_JNI_GETBOOLEANARRAYELEMENTS_RETURN((uintptr_t*)result))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2764
DEFINE_GETSCALARARRAYELEMENTS(T_BYTE,    jbyte,    Byte,    byte
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2765
                              , HOTSPOT_JNI_GETBYTEARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2766
                              HOTSPOT_JNI_GETBYTEARRAYELEMENTS_RETURN((char*)result))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2767
DEFINE_GETSCALARARRAYELEMENTS(T_SHORT,   jshort,   Short,   short
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2768
                              , HOTSPOT_JNI_GETSHORTARRAYELEMENTS_ENTRY(env, (uint16_t*) array, (uintptr_t *) isCopy),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2769
                              HOTSPOT_JNI_GETSHORTARRAYELEMENTS_RETURN((uint16_t*)result))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2770
DEFINE_GETSCALARARRAYELEMENTS(T_CHAR,    jchar,    Char,    char
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2771
                              , HOTSPOT_JNI_GETCHARARRAYELEMENTS_ENTRY(env, (uint16_t*) array, (uintptr_t *) isCopy),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2772
                              HOTSPOT_JNI_GETCHARARRAYELEMENTS_RETURN(result))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2773
DEFINE_GETSCALARARRAYELEMENTS(T_INT,     jint,     Int,     int
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2774
                              , HOTSPOT_JNI_GETINTARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2775
                              HOTSPOT_JNI_GETINTARRAYELEMENTS_RETURN((uint32_t*)result))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2776
DEFINE_GETSCALARARRAYELEMENTS(T_LONG,    jlong,    Long,    long
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2777
                              , HOTSPOT_JNI_GETLONGARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2778
                              HOTSPOT_JNI_GETLONGARRAYELEMENTS_RETURN(((uintptr_t*)result)))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2779
// Float and double probes don't return value because dtrace doesn't currently support it
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2780
DEFINE_GETSCALARARRAYELEMENTS(T_FLOAT,   jfloat,   Float,   float
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2781
                              , HOTSPOT_JNI_GETFLOATARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2782
                              HOTSPOT_JNI_GETFLOATARRAYELEMENTS_RETURN(result))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2783
DEFINE_GETSCALARARRAYELEMENTS(T_DOUBLE,  jdouble,  Double,  double
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2784
                              , HOTSPOT_JNI_GETDOUBLEARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2785
                              HOTSPOT_JNI_GETDOUBLEARRAYELEMENTS_RETURN(result))
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  2786
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2787
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2788
#define DEFINE_RELEASESCALARARRAYELEMENTS(ElementTag,ElementType,Result,Tag \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2789
                                          , EntryProbe, ReturnProbe);\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2790
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2791
JNI_QUICK_ENTRY(void, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2792
          jni_Release##Result##ArrayElements(JNIEnv *env, ElementType##Array array, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2793
                                             ElementType *buf, jint mode)) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2794
  JNIWrapper("Release" XSTR(Result) "ArrayElements"); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2795
  EntryProbe; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2796
  typeArrayOop a = typeArrayOop(JNIHandles::resolve_non_null(array)); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2797
  int len = a->length(); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2798
  if (len != 0) {   /* Empty array:  nothing to free or copy. */  \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2799
    if ((mode == 0) || (mode == JNI_COMMIT)) { \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2800
      memcpy(a->Tag##_at_addr(0), buf, sizeof(ElementType)*len); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2801
    } \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2802
    if ((mode == 0) || (mode == JNI_ABORT)) { \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2803
      FreeHeap(buf); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2804
    } \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2805
  } \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2806
  ReturnProbe; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2807
JNI_END
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2808
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2809
DEFINE_RELEASESCALARARRAYELEMENTS(T_BOOLEAN, jboolean, Boolean, bool
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2810
                                  , HOTSPOT_JNI_RELEASEBOOLEANARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) buf, mode),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2811
                                  HOTSPOT_JNI_RELEASEBOOLEANARRAYELEMENTS_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2812
DEFINE_RELEASESCALARARRAYELEMENTS(T_BYTE,    jbyte,    Byte,    byte
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2813
                                  , HOTSPOT_JNI_RELEASEBYTEARRAYELEMENTS_ENTRY(env, array, (char *) buf, mode),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2814
                                  HOTSPOT_JNI_RELEASEBYTEARRAYELEMENTS_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2815
DEFINE_RELEASESCALARARRAYELEMENTS(T_SHORT,   jshort,   Short,   short
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2816
                                  ,  HOTSPOT_JNI_RELEASESHORTARRAYELEMENTS_ENTRY(env, array, (uint16_t *) buf, mode),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2817
                                  HOTSPOT_JNI_RELEASESHORTARRAYELEMENTS_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2818
DEFINE_RELEASESCALARARRAYELEMENTS(T_CHAR,    jchar,    Char,    char
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2819
                                  ,  HOTSPOT_JNI_RELEASECHARARRAYELEMENTS_ENTRY(env, array, (uint16_t *) buf, mode),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2820
                                  HOTSPOT_JNI_RELEASECHARARRAYELEMENTS_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2821
DEFINE_RELEASESCALARARRAYELEMENTS(T_INT,     jint,     Int,     int
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2822
                                  , HOTSPOT_JNI_RELEASEINTARRAYELEMENTS_ENTRY(env, array, (uint32_t *) buf, mode),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2823
                                  HOTSPOT_JNI_RELEASEINTARRAYELEMENTS_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2824
DEFINE_RELEASESCALARARRAYELEMENTS(T_LONG,    jlong,    Long,    long
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2825
                                  , HOTSPOT_JNI_RELEASELONGARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) buf, mode),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2826
                                  HOTSPOT_JNI_RELEASELONGARRAYELEMENTS_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2827
DEFINE_RELEASESCALARARRAYELEMENTS(T_FLOAT,   jfloat,   Float,   float
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2828
                                  , HOTSPOT_JNI_RELEASEFLOATARRAYELEMENTS_ENTRY(env, array, (float *) buf, mode),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2829
                                  HOTSPOT_JNI_RELEASEFLOATARRAYELEMENTS_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2830
DEFINE_RELEASESCALARARRAYELEMENTS(T_DOUBLE,  jdouble,  Double,  double
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2831
                                  , HOTSPOT_JNI_RELEASEDOUBLEARRAYELEMENTS_ENTRY(env, array, (double *) buf, mode),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2832
                                  HOTSPOT_JNI_RELEASEDOUBLEARRAYELEMENTS_RETURN())
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  2833
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2834
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2835
#define DEFINE_GETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2836
                                    , EntryProbe, ReturnProbe); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2837
  DT_VOID_RETURN_MARK_DECL(Get##Result##ArrayRegion \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2838
                           , ReturnProbe); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2839
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2840
JNI_ENTRY(void, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2841
jni_Get##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2842
             jsize len, ElementType *buf)) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2843
  JNIWrapper("Get" XSTR(Result) "ArrayRegion"); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2844
  EntryProbe; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2845
  DT_VOID_RETURN_MARK(Get##Result##ArrayRegion); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2846
  typeArrayOop src = typeArrayOop(JNIHandles::resolve_non_null(array)); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2847
  if (start < 0 || len < 0 || ((unsigned int)start + (unsigned int)len > (unsigned int)src->length())) { \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2848
    THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2849
  } else { \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2850
    if (len > 0) { \
13952
e3cf184080bc 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents: 13728
diff changeset
  2851
      int sc = TypeArrayKlass::cast(src->klass())->log2_element_size(); \
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2852
      memcpy((u_char*) buf, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2853
             (u_char*) src->Tag##_at_addr(start), \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2854
             len << sc);                          \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2855
    } \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2856
  } \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2857
JNI_END
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2858
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2859
DEFINE_GETSCALARARRAYREGION(T_BOOLEAN, jboolean,Boolean, bool
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2860
                            , HOTSPOT_JNI_GETBOOLEANARRAYREGION_ENTRY(env, array, start, len, (uintptr_t *) buf),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2861
                            HOTSPOT_JNI_GETBOOLEANARRAYREGION_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2862
DEFINE_GETSCALARARRAYREGION(T_BYTE,    jbyte,   Byte,    byte
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2863
                            ,  HOTSPOT_JNI_GETBYTEARRAYREGION_ENTRY(env, array, start, len, (char *) buf),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2864
                            HOTSPOT_JNI_GETBYTEARRAYREGION_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2865
DEFINE_GETSCALARARRAYREGION(T_SHORT,   jshort,  Short,   short
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2866
                            , HOTSPOT_JNI_GETSHORTARRAYREGION_ENTRY(env, array, start, len, (uint16_t *) buf),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2867
                            HOTSPOT_JNI_GETSHORTARRAYREGION_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2868
DEFINE_GETSCALARARRAYREGION(T_CHAR,    jchar,   Char,    char
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2869
                            ,  HOTSPOT_JNI_GETCHARARRAYREGION_ENTRY(env, array, start, len, (uint16_t*) buf),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2870
                            HOTSPOT_JNI_GETCHARARRAYREGION_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2871
DEFINE_GETSCALARARRAYREGION(T_INT,     jint,    Int,     int
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2872
                            , HOTSPOT_JNI_GETINTARRAYREGION_ENTRY(env, array, start, len, (uint32_t*) buf),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2873
                            HOTSPOT_JNI_GETINTARRAYREGION_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2874
DEFINE_GETSCALARARRAYREGION(T_LONG,    jlong,   Long,    long
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2875
                            ,  HOTSPOT_JNI_GETLONGARRAYREGION_ENTRY(env, array, start, len, (uintptr_t *) buf),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2876
                            HOTSPOT_JNI_GETLONGARRAYREGION_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2877
DEFINE_GETSCALARARRAYREGION(T_FLOAT,   jfloat,  Float,   float
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2878
                            , HOTSPOT_JNI_GETFLOATARRAYREGION_ENTRY(env, array, start, len, (float *) buf),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2879
                            HOTSPOT_JNI_GETFLOATARRAYREGION_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2880
DEFINE_GETSCALARARRAYREGION(T_DOUBLE,  jdouble, Double,  double
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2881
                            , HOTSPOT_JNI_GETDOUBLEARRAYREGION_ENTRY(env, array, start, len, (double *) buf),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2882
                            HOTSPOT_JNI_GETDOUBLEARRAYREGION_RETURN());
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  2883
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2884
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2885
#define DEFINE_SETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2886
                                    , EntryProbe, ReturnProbe); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2887
  DT_VOID_RETURN_MARK_DECL(Set##Result##ArrayRegion \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2888
                           ,ReturnProbe);           \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2889
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2890
JNI_ENTRY(void, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2891
jni_Set##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2892
             jsize len, const ElementType *buf)) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2893
  JNIWrapper("Set" XSTR(Result) "ArrayRegion"); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2894
  EntryProbe; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2895
  DT_VOID_RETURN_MARK(Set##Result##ArrayRegion); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2896
  typeArrayOop dst = typeArrayOop(JNIHandles::resolve_non_null(array)); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2897
  if (start < 0 || len < 0 || ((unsigned int)start + (unsigned int)len > (unsigned int)dst->length())) { \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2898
    THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2899
  } else { \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2900
    if (len > 0) { \
13952
e3cf184080bc 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents: 13728
diff changeset
  2901
      int sc = TypeArrayKlass::cast(dst->klass())->log2_element_size(); \
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2902
      memcpy((u_char*) dst->Tag##_at_addr(start), \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2903
             (u_char*) buf, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2904
             len << sc);    \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2905
    } \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2906
  } \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2907
JNI_END
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2908
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2909
DEFINE_SETSCALARARRAYREGION(T_BOOLEAN, jboolean, Boolean, bool
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2910
                            , HOTSPOT_JNI_SETBOOLEANARRAYREGION_ENTRY(env, array, start, len, (uintptr_t *)buf),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2911
                            HOTSPOT_JNI_SETBOOLEANARRAYREGION_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2912
DEFINE_SETSCALARARRAYREGION(T_BYTE,    jbyte,    Byte,    byte
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2913
                            , HOTSPOT_JNI_SETBYTEARRAYREGION_ENTRY(env, array, start, len, (char *) buf),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2914
                            HOTSPOT_JNI_SETBYTEARRAYREGION_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2915
DEFINE_SETSCALARARRAYREGION(T_SHORT,   jshort,   Short,   short
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2916
                            , HOTSPOT_JNI_SETSHORTARRAYREGION_ENTRY(env, array, start, len, (uint16_t *) buf),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2917
                            HOTSPOT_JNI_SETSHORTARRAYREGION_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2918
DEFINE_SETSCALARARRAYREGION(T_CHAR,    jchar,    Char,    char
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2919
                            , HOTSPOT_JNI_SETCHARARRAYREGION_ENTRY(env, array, start, len, (uint16_t *) buf),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2920
                            HOTSPOT_JNI_SETCHARARRAYREGION_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2921
DEFINE_SETSCALARARRAYREGION(T_INT,     jint,     Int,     int
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2922
                            , HOTSPOT_JNI_SETINTARRAYREGION_ENTRY(env, array, start, len, (uint32_t *) buf),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2923
                            HOTSPOT_JNI_SETINTARRAYREGION_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2924
DEFINE_SETSCALARARRAYREGION(T_LONG,    jlong,    Long,    long
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2925
                            , HOTSPOT_JNI_SETLONGARRAYREGION_ENTRY(env, array, start, len, (uintptr_t *) buf),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2926
                            HOTSPOT_JNI_SETLONGARRAYREGION_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2927
DEFINE_SETSCALARARRAYREGION(T_FLOAT,   jfloat,   Float,   float
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2928
                            , HOTSPOT_JNI_SETFLOATARRAYREGION_ENTRY(env, array, start, len, (float *) buf),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2929
                            HOTSPOT_JNI_SETFLOATARRAYREGION_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2930
DEFINE_SETSCALARARRAYREGION(T_DOUBLE,  jdouble,  Double,  double
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2931
                            , HOTSPOT_JNI_SETDOUBLEARRAYREGION_ENTRY(env, array, start, len, (double *) buf),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2932
                            HOTSPOT_JNI_SETDOUBLEARRAYREGION_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2933
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2934
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2935
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2936
// Interception of natives
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2937
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2938
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2939
// The RegisterNatives call being attempted tried to register with a method that
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2940
// is not native.  Ask JVM TI what prefixes have been specified.  Then check
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2941
// to see if the native method is now wrapped with the prefixes.  See the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2942
// SetNativeMethodPrefix(es) functions in the JVM TI Spec for details.
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  2943
static Method* find_prefixed_native(Klass* k, Symbol* name, Symbol* signature, TRAPS) {
13975
2f7431485cfa 7189254: Change makefiles for more flexibility to override defaults
jprovino
parents: 13728
diff changeset
  2944
#if INCLUDE_JVMTI
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2945
  ResourceMark rm(THREAD);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  2946
  Method* method;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2947
  int name_len = name->utf8_length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2948
  char* name_str = name->as_utf8();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2949
  int prefix_count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2950
  char** prefixes = JvmtiExport::get_all_native_method_prefixes(&prefix_count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2951
  for (int i = 0; i < prefix_count; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2952
    char* prefix = prefixes[i];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2953
    int prefix_len = (int)strlen(prefix);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2954
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2955
    // try adding this prefix to the method name and see if it matches another method name
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2956
    int trial_len = name_len + prefix_len;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2957
    char* trial_name_str = NEW_RESOURCE_ARRAY(char, trial_len + 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2958
    strcpy(trial_name_str, prefix);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2959
    strcat(trial_name_str, name_str);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  2960
    TempNewSymbol trial_name = SymbolTable::probe(trial_name_str, trial_len);
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  2961
    if (trial_name == NULL) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2962
      continue; // no such symbol, so this prefix wasn't used, try the next prefix
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2963
    }
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  2964
    method = k->lookup_method(trial_name, signature);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2965
    if (method == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2966
      continue; // signature doesn't match, try the next prefix
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2967
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2968
    if (method->is_native()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2969
      method->set_is_prefixed_native();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2970
      return method; // wahoo, we found a prefixed version of the method, return it
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2971
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2972
    // found as non-native, so prefix is good, add it, probably just need more prefixes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2973
    name_len = trial_len;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2974
    name_str = trial_name_str;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2975
  }
13975
2f7431485cfa 7189254: Change makefiles for more flexibility to override defaults
jprovino
parents: 13728
diff changeset
  2976
#endif // INCLUDE_JVMTI
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2977
  return NULL; // not found
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2978
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2979
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  2980
static bool register_native(Klass* k, Symbol* name, Symbol* signature, address entry, TRAPS) {
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  2981
  Method* method = k->lookup_method(name, signature);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2982
  if (method == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2983
    ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2984
    stringStream st;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2985
    st.print("Method %s name or signature does not match",
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  2986
             Method::name_and_sig_as_C_string(k, name, signature));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2987
    THROW_MSG_(vmSymbols::java_lang_NoSuchMethodError(), st.as_string(), false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2988
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2989
  if (!method->is_native()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2990
    // trying to register to a non-native method, see if a JVM TI agent has added prefix(es)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2991
    method = find_prefixed_native(k, name, signature, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2992
    if (method == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2993
      ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2994
      stringStream st;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2995
      st.print("Method %s is not declared as native",
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  2996
               Method::name_and_sig_as_C_string(k, name, signature));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2997
      THROW_MSG_(vmSymbols::java_lang_NoSuchMethodError(), st.as_string(), false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2998
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2999
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3000
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3001
  if (entry != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3002
    method->set_native_function(entry,
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  3003
      Method::native_bind_event_is_interesting);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3004
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3005
    method->clear_native_function();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3006
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3007
  if (PrintJNIResolving) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3008
    ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3009
    tty->print_cr("[Registering JNI native method %s.%s]",
14391
df0a1573d5bd 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents: 13977
diff changeset
  3010
      method->method_holder()->external_name(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3011
      method->name()->as_C_string());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3012
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3013
  return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3014
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3015
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  3016
DT_RETURN_MARK_DECL(RegisterNatives, jint
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  3017
                    , HOTSPOT_JNI_REGISTERNATIVES_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3018
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3019
JNI_ENTRY(jint, jni_RegisterNatives(JNIEnv *env, jclass clazz,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3020
                                    const JNINativeMethod *methods,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3021
                                    jint nMethods))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3022
  JNIWrapper("RegisterNatives");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3023
  HOTSPOT_JNI_REGISTERNATIVES_ENTRY(env, clazz, (void *) methods, nMethods);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3024
  jint ret = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3025
  DT_RETURN_MARK(RegisterNatives, jint, (const jint&)ret);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3026
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  3027
  Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3028
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3029
  for (int index = 0; index < nMethods; index++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3030
    const char* meth_name = methods[index].name;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3031
    const char* meth_sig = methods[index].signature;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3032
    int meth_name_len = (int)strlen(meth_name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3033
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3034
    // The class should have been loaded (we have an instance of the class
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3035
    // passed in) so the method and signature should already be in the symbol
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3036
    // table.  If they're not there, the method doesn't exist.
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  3037
    TempNewSymbol  name = SymbolTable::probe(meth_name, meth_name_len);
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  3038
    TempNewSymbol  signature = SymbolTable::probe(meth_sig, (int)strlen(meth_sig));
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  3039
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  3040
    if (name == NULL || signature == NULL) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3041
      ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3042
      stringStream st;
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  3043
      st.print("Method %s.%s%s not found", k->external_name(), meth_name, meth_sig);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3044
      // Must return negative value on failure
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3045
      THROW_MSG_(vmSymbols::java_lang_NoSuchMethodError(), st.as_string(), -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3046
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3047
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  3048
    bool res = register_native(k, name, signature,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3049
                               (address) methods[index].fnPtr, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3050
    if (!res) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3051
      ret = -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3052
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3053
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3054
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3055
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3056
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3057
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3058
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3059
JNI_ENTRY(jint, jni_UnregisterNatives(JNIEnv *env, jclass clazz))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3060
  JNIWrapper("UnregisterNatives");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3061
 HOTSPOT_JNI_UNREGISTERNATIVES_ENTRY(env, clazz);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  3062
  Klass* k   = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3063
  //%note jni_2
33611
9abd65805e19 8139203: Consistent naming for klass type predicates
coleenp
parents: 33576
diff changeset
  3064
  if (k->is_instance_klass()) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  3065
    for (int index = 0; index < InstanceKlass::cast(k)->methods()->length(); index++) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  3066
      Method* m = InstanceKlass::cast(k)->methods()->at(index);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3067
      if (m->is_native()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3068
        m->clear_native_function();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3069
        m->set_signature_handler(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3070
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3071
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3072
  }
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3073
 HOTSPOT_JNI_UNREGISTERNATIVES_RETURN(0);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3074
  return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3075
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3076
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3077
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3078
// Monitor functions
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3079
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3080
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  3081
DT_RETURN_MARK_DECL(MonitorEnter, jint
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  3082
                    , HOTSPOT_JNI_MONITORENTER_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3083
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3084
JNI_ENTRY(jint, jni_MonitorEnter(JNIEnv *env, jobject jobj))
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3085
 HOTSPOT_JNI_MONITORENTER_ENTRY(env, jobj);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3086
  jint ret = JNI_ERR;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3087
  DT_RETURN_MARK(MonitorEnter, jint, (const jint&)ret);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3088
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3089
  // If the object is null, we can't do anything with it
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3090
  if (jobj == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3091
    THROW_(vmSymbols::java_lang_NullPointerException(), JNI_ERR);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3092
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3093
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3094
  Handle obj(thread, JNIHandles::resolve_non_null(jobj));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3095
  ObjectSynchronizer::jni_enter(obj, CHECK_(JNI_ERR));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3096
  ret = JNI_OK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3097
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3098
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3099
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  3100
DT_RETURN_MARK_DECL(MonitorExit, jint
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  3101
                    , HOTSPOT_JNI_MONITOREXIT_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3102
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3103
JNI_ENTRY(jint, jni_MonitorExit(JNIEnv *env, jobject jobj))
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3104
 HOTSPOT_JNI_MONITOREXIT_ENTRY(env, jobj);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3105
  jint ret = JNI_ERR;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3106
  DT_RETURN_MARK(MonitorExit, jint, (const jint&)ret);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3107
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3108
  // Don't do anything with a null object
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3109
  if (jobj == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3110
    THROW_(vmSymbols::java_lang_NullPointerException(), JNI_ERR);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3111
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3112
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3113
  Handle obj(THREAD, JNIHandles::resolve_non_null(jobj));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3114
  ObjectSynchronizer::jni_exit(obj(), CHECK_(JNI_ERR));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3115
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3116
  ret = JNI_OK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3117
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3118
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3119
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3120
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3121
// Extensions
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3122
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3123
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  3124
DT_VOID_RETURN_MARK_DECL(GetStringRegion
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  3125
                         , HOTSPOT_JNI_GETSTRINGREGION_RETURN());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3126
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3127
JNI_ENTRY(void, jni_GetStringRegion(JNIEnv *env, jstring string, jsize start, jsize len, jchar *buf))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3128
  JNIWrapper("GetStringRegion");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3129
 HOTSPOT_JNI_GETSTRINGREGION_ENTRY(env, string, start, len, buf);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3130
  DT_VOID_RETURN_MARK(GetStringRegion);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3131
  oop s = JNIHandles::resolve_non_null(string);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3132
  int s_len = java_lang_String::length(s);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3133
  if (start < 0 || len < 0 || start + len > s_len) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3134
    THROW(vmSymbols::java_lang_StringIndexOutOfBoundsException());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3135
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3136
    if (len > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3137
      typeArrayOop s_value = java_lang_String::value(s);
33628
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3138
      bool is_latin1 = java_lang_String::is_latin1(s);
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3139
      if (!is_latin1) {
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3140
        memcpy(buf, s_value->char_at_addr(start), sizeof(jchar)*len);
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3141
      } else {
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3142
        for (int i = 0; i < len; i++) {
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3143
          buf[i] = ((jchar) s_value->byte_at(i + start)) & 0xff;
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3144
        }
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3145
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3146
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3147
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3148
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3149
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  3150
DT_VOID_RETURN_MARK_DECL(GetStringUTFRegion
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  3151
                         , HOTSPOT_JNI_GETSTRINGUTFREGION_RETURN());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3152
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3153
JNI_ENTRY(void, jni_GetStringUTFRegion(JNIEnv *env, jstring string, jsize start, jsize len, char *buf))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3154
  JNIWrapper("GetStringUTFRegion");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3155
 HOTSPOT_JNI_GETSTRINGUTFREGION_ENTRY(env, string, start, len, buf);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3156
  DT_VOID_RETURN_MARK(GetStringUTFRegion);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3157
  oop s = JNIHandles::resolve_non_null(string);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3158
  int s_len = java_lang_String::length(s);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3159
  if (start < 0 || len < 0 || start + len > s_len) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3160
    THROW(vmSymbols::java_lang_StringIndexOutOfBoundsException());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3161
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3162
    //%note jni_7
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3163
    if (len > 0) {
24237
7b210ef8c830 6664815: Eliminate redundant memcpy operation in jni_GetStringUTFRegion
mgerdin
parents: 23997
diff changeset
  3164
      // Assume the buffer is large enough as the JNI spec. does not require user error checking
7b210ef8c830 6664815: Eliminate redundant memcpy operation in jni_GetStringUTFRegion
mgerdin
parents: 23997
diff changeset
  3165
      java_lang_String::as_utf8_string(s, start, len, buf, INT_MAX);
7b210ef8c830 6664815: Eliminate redundant memcpy operation in jni_GetStringUTFRegion
mgerdin
parents: 23997
diff changeset
  3166
      // as_utf8_string null-terminates the result string
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3167
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3168
      // JDK null-terminates the buffer even in len is zero
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3169
      if (buf != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3170
        buf[0] = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3171
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3172
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3173
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3174
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3175
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3176
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3177
JNI_ENTRY(void*, jni_GetPrimitiveArrayCritical(JNIEnv *env, jarray array, jboolean *isCopy))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3178
  JNIWrapper("GetPrimitiveArrayCritical");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3179
 HOTSPOT_JNI_GETPRIMITIVEARRAYCRITICAL_ENTRY(env, array, (uintptr_t *) isCopy);
35492
c8c0273e6b91 8146690: Make all classes in GC follow the naming convention.
david
parents: 35219
diff changeset
  3180
  GCLocker::lock_critical(thread);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3181
  if (isCopy != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3182
    *isCopy = JNI_FALSE;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3183
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3184
  oop a = JNIHandles::resolve_non_null(array);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3185
  assert(a->is_array(), "just checking");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3186
  BasicType type;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3187
  if (a->is_objArray()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3188
    type = T_OBJECT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3189
  } else {
13952
e3cf184080bc 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents: 13728
diff changeset
  3190
    type = TypeArrayKlass::cast(a->klass())->element_type();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3191
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3192
  void* ret = arrayOop(a)->base(type);
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3193
 HOTSPOT_JNI_GETPRIMITIVEARRAYCRITICAL_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3194
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3195
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3196
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3197
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3198
JNI_ENTRY(void, jni_ReleasePrimitiveArrayCritical(JNIEnv *env, jarray array, void *carray, jint mode))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3199
  JNIWrapper("ReleasePrimitiveArrayCritical");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3200
  HOTSPOT_JNI_RELEASEPRIMITIVEARRAYCRITICAL_ENTRY(env, array, carray, mode);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3201
  // The array, carray and mode arguments are ignored
35492
c8c0273e6b91 8146690: Make all classes in GC follow the naming convention.
david
parents: 35219
diff changeset
  3202
  GCLocker::unlock_critical(thread);
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3203
HOTSPOT_JNI_RELEASEPRIMITIVEARRAYCRITICAL_RETURN();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3204
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3205
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3206
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3207
JNI_ENTRY(const jchar*, jni_GetStringCritical(JNIEnv *env, jstring string, jboolean *isCopy))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3208
  JNIWrapper("GetStringCritical");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3209
  HOTSPOT_JNI_GETSTRINGCRITICAL_ENTRY(env, string, (uintptr_t *) isCopy);
35492
c8c0273e6b91 8146690: Make all classes in GC follow the naming convention.
david
parents: 35219
diff changeset
  3210
  GCLocker::lock_critical(thread);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3211
  oop s = JNIHandles::resolve_non_null(string);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3212
  typeArrayOop s_value = java_lang_String::value(s);
33628
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3213
  bool is_latin1 = java_lang_String::is_latin1(s);
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3214
  if (isCopy != NULL) {
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3215
    *isCopy = is_latin1 ? JNI_TRUE : JNI_FALSE;
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3216
  }
35162
65d0237246b1 8145015: jni_GetStringCritical asserts for empty strings
simonis
parents: 35061
diff changeset
  3217
  jchar* ret;
33628
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3218
  if (!is_latin1) {
35162
65d0237246b1 8145015: jni_GetStringCritical asserts for empty strings
simonis
parents: 35061
diff changeset
  3219
    ret = (jchar*) s_value->base(T_CHAR);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3220
  } else {
33628
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3221
    // Inflate latin1 encoded string to UTF16
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3222
    int s_len = java_lang_String::length(s);
35162
65d0237246b1 8145015: jni_GetStringCritical asserts for empty strings
simonis
parents: 35061
diff changeset
  3223
    ret = NEW_C_HEAP_ARRAY_RETURN_NULL(jchar, s_len + 1, mtInternal);  // add one for zero termination
65d0237246b1 8145015: jni_GetStringCritical asserts for empty strings
simonis
parents: 35061
diff changeset
  3224
    /* JNI Specification states return NULL on OOM */
65d0237246b1 8145015: jni_GetStringCritical asserts for empty strings
simonis
parents: 35061
diff changeset
  3225
    if (ret != NULL) {
65d0237246b1 8145015: jni_GetStringCritical asserts for empty strings
simonis
parents: 35061
diff changeset
  3226
      for (int i = 0; i < s_len; i++) {
65d0237246b1 8145015: jni_GetStringCritical asserts for empty strings
simonis
parents: 35061
diff changeset
  3227
        ret[i] = ((jchar) s_value->byte_at(i)) & 0xff;
65d0237246b1 8145015: jni_GetStringCritical asserts for empty strings
simonis
parents: 35061
diff changeset
  3228
      }
65d0237246b1 8145015: jni_GetStringCritical asserts for empty strings
simonis
parents: 35061
diff changeset
  3229
      ret[s_len] = 0;
33628
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3230
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3231
  }
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3232
 HOTSPOT_JNI_GETSTRINGCRITICAL_RETURN((uint16_t *) ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3233
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3234
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3235
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3236
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3237
JNI_ENTRY(void, jni_ReleaseStringCritical(JNIEnv *env, jstring str, const jchar *chars))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3238
  JNIWrapper("ReleaseStringCritical");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3239
  HOTSPOT_JNI_RELEASESTRINGCRITICAL_ENTRY(env, str, (uint16_t *) chars);
33628
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3240
  // The str and chars arguments are ignored for UTF16 strings
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3241
  oop s = JNIHandles::resolve_non_null(str);
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3242
  bool is_latin1 = java_lang_String::is_latin1(s);
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3243
  if (is_latin1) {
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3244
    // For latin1 string, free jchar array allocated by earlier call to GetStringCritical.
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3245
    // This assumes that ReleaseStringCritical bookends GetStringCritical.
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3246
    FREE_C_HEAP_ARRAY(jchar, chars);
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3247
  }
35492
c8c0273e6b91 8146690: Make all classes in GC follow the naming convention.
david
parents: 35219
diff changeset
  3248
  GCLocker::unlock_critical(thread);
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3249
HOTSPOT_JNI_RELEASESTRINGCRITICAL_RETURN();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3250
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3251
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3252
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3253
JNI_ENTRY(jweak, jni_NewWeakGlobalRef(JNIEnv *env, jobject ref))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3254
  JNIWrapper("jni_NewWeakGlobalRef");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3255
 HOTSPOT_JNI_NEWWEAKGLOBALREF_ENTRY(env, ref);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3256
  Handle ref_handle(thread, JNIHandles::resolve(ref));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3257
  jweak ret = JNIHandles::make_weak_global(ref_handle);
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3258
 HOTSPOT_JNI_NEWWEAKGLOBALREF_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3259
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3260
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3261
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3262
// Must be JNI_ENTRY (with HandleMark)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3263
JNI_ENTRY(void, jni_DeleteWeakGlobalRef(JNIEnv *env, jweak ref))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3264
  JNIWrapper("jni_DeleteWeakGlobalRef");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3265
  HOTSPOT_JNI_DELETEWEAKGLOBALREF_ENTRY(env, ref);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3266
  JNIHandles::destroy_weak_global(ref);
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3267
  HOTSPOT_JNI_DELETEWEAKGLOBALREF_RETURN();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3268
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3269
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3270
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3271
JNI_QUICK_ENTRY(jboolean, jni_ExceptionCheck(JNIEnv *env))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3272
  JNIWrapper("jni_ExceptionCheck");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3273
 HOTSPOT_JNI_EXCEPTIONCHECK_ENTRY(env);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3274
  jni_check_async_exceptions(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3275
  jboolean ret = (thread->has_pending_exception()) ? JNI_TRUE : JNI_FALSE;
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3276
 HOTSPOT_JNI_EXCEPTIONCHECK_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3277
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3278
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3279
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3280
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3281
// Initialization state for three routines below relating to
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3282
// java.nio.DirectBuffers
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3283
static          jint directBufferSupportInitializeStarted = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3284
static volatile jint directBufferSupportInitializeEnded   = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3285
static volatile jint directBufferSupportInitializeFailed  = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3286
static jclass    bufferClass                 = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3287
static jclass    directBufferClass           = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3288
static jclass    directByteBufferClass       = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3289
static jmethodID directByteBufferConstructor = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3290
static jfieldID  directBufferAddressField    = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3291
static jfieldID  bufferCapacityField         = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3292
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3293
static jclass lookupOne(JNIEnv* env, const char* name, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3294
  Handle loader;            // null (bootstrap) loader
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3295
  Handle protection_domain; // null protection domain
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3296
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  3297
  TempNewSymbol sym = SymbolTable::new_symbol(name, CHECK_NULL);
2269
ee9da33d43ab 6603316: Improve instrumentation for classes loaded at startup
acorn
parents: 2105
diff changeset
  3298
  jclass result =  find_class_from_class_loader(env, sym, true, loader, protection_domain, true, CHECK_NULL);
ee9da33d43ab 6603316: Improve instrumentation for classes loaded at startup
acorn
parents: 2105
diff changeset
  3299
38151
fffedc5e5cf8 8154110: Update class* and safepoint* logging subsystems
mockner
parents: 37483
diff changeset
  3300
  if (log_is_enabled(Debug, class, resolve) && result != NULL) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  3301
    trace_class_resolution(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(result)));
2269
ee9da33d43ab 6603316: Improve instrumentation for classes loaded at startup
acorn
parents: 2105
diff changeset
  3302
  }
ee9da33d43ab 6603316: Improve instrumentation for classes loaded at startup
acorn
parents: 2105
diff changeset
  3303
  return result;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3304
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3305
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3306
// These lookups are done with the NULL (bootstrap) ClassLoader to
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3307
// circumvent any security checks that would be done by jni_FindClass.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3308
JNI_ENTRY(bool, lookupDirectBufferClasses(JNIEnv* env))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3309
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3310
  if ((bufferClass           = lookupOne(env, "java/nio/Buffer", thread))           == NULL) { return false; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3311
  if ((directBufferClass     = lookupOne(env, "sun/nio/ch/DirectBuffer", thread))   == NULL) { return false; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3312
  if ((directByteBufferClass = lookupOne(env, "java/nio/DirectByteBuffer", thread)) == NULL) { return false; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3313
  return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3314
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3315
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3316
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3317
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3318
static bool initializeDirectBufferSupport(JNIEnv* env, JavaThread* thread) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3319
  if (directBufferSupportInitializeFailed) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3320
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3321
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3322
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3323
  if (Atomic::cmpxchg(1, &directBufferSupportInitializeStarted, 0) == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3324
    if (!lookupDirectBufferClasses(env)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3325
      directBufferSupportInitializeFailed = 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3326
      return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3327
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3328
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3329
    // Make global references for these
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3330
    bufferClass           = (jclass) env->NewGlobalRef(bufferClass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3331
    directBufferClass     = (jclass) env->NewGlobalRef(directBufferClass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3332
    directByteBufferClass = (jclass) env->NewGlobalRef(directByteBufferClass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3333
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3334
    // Get needed field and method IDs
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3335
    directByteBufferConstructor = env->GetMethodID(directByteBufferClass, "<init>", "(JI)V");
22786
86644d9539c2 8028785: [parfait] warnings from b116 for hotspot.src.share.vm.prims: JNI exception pending
ccheung
parents: 22737
diff changeset
  3336
    if (env->ExceptionCheck()) {
86644d9539c2 8028785: [parfait] warnings from b116 for hotspot.src.share.vm.prims: JNI exception pending
ccheung
parents: 22737
diff changeset
  3337
      env->ExceptionClear();
86644d9539c2 8028785: [parfait] warnings from b116 for hotspot.src.share.vm.prims: JNI exception pending
ccheung
parents: 22737
diff changeset
  3338
      directBufferSupportInitializeFailed = 1;
86644d9539c2 8028785: [parfait] warnings from b116 for hotspot.src.share.vm.prims: JNI exception pending
ccheung
parents: 22737
diff changeset
  3339
      return false;
86644d9539c2 8028785: [parfait] warnings from b116 for hotspot.src.share.vm.prims: JNI exception pending
ccheung
parents: 22737
diff changeset
  3340
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3341
    directBufferAddressField    = env->GetFieldID(bufferClass, "address", "J");
22786
86644d9539c2 8028785: [parfait] warnings from b116 for hotspot.src.share.vm.prims: JNI exception pending
ccheung
parents: 22737
diff changeset
  3342
    if (env->ExceptionCheck()) {
86644d9539c2 8028785: [parfait] warnings from b116 for hotspot.src.share.vm.prims: JNI exception pending
ccheung
parents: 22737
diff changeset
  3343
      env->ExceptionClear();
86644d9539c2 8028785: [parfait] warnings from b116 for hotspot.src.share.vm.prims: JNI exception pending
ccheung
parents: 22737
diff changeset
  3344
      directBufferSupportInitializeFailed = 1;
86644d9539c2 8028785: [parfait] warnings from b116 for hotspot.src.share.vm.prims: JNI exception pending
ccheung
parents: 22737
diff changeset
  3345
      return false;
86644d9539c2 8028785: [parfait] warnings from b116 for hotspot.src.share.vm.prims: JNI exception pending
ccheung
parents: 22737
diff changeset
  3346
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3347
    bufferCapacityField         = env->GetFieldID(bufferClass, "capacity", "I");
22786
86644d9539c2 8028785: [parfait] warnings from b116 for hotspot.src.share.vm.prims: JNI exception pending
ccheung
parents: 22737
diff changeset
  3348
    if (env->ExceptionCheck()) {
86644d9539c2 8028785: [parfait] warnings from b116 for hotspot.src.share.vm.prims: JNI exception pending
ccheung
parents: 22737
diff changeset
  3349
      env->ExceptionClear();
86644d9539c2 8028785: [parfait] warnings from b116 for hotspot.src.share.vm.prims: JNI exception pending
ccheung
parents: 22737
diff changeset
  3350
      directBufferSupportInitializeFailed = 1;
86644d9539c2 8028785: [parfait] warnings from b116 for hotspot.src.share.vm.prims: JNI exception pending
ccheung
parents: 22737
diff changeset
  3351
      return false;
86644d9539c2 8028785: [parfait] warnings from b116 for hotspot.src.share.vm.prims: JNI exception pending
ccheung
parents: 22737
diff changeset
  3352
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3353
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3354
    if ((directByteBufferConstructor == NULL) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3355
        (directBufferAddressField    == NULL) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3356
        (bufferCapacityField         == NULL)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3357
      directBufferSupportInitializeFailed = 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3358
      return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3359
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3360
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3361
    directBufferSupportInitializeEnded = 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3362
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3363
    while (!directBufferSupportInitializeEnded && !directBufferSupportInitializeFailed) {
25477
7dad9f95fd31 8047714: Fix for JDK-6546236 made Solaris os::yield() a no-op
fparain
parents: 25469
diff changeset
  3364
      os::naked_yield();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3365
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3366
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3367
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3368
  return !directBufferSupportInitializeFailed;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3369
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3370
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3371
extern "C" jobject JNICALL jni_NewDirectByteBuffer(JNIEnv *env, void* address, jlong capacity)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3372
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3373
  // thread_from_jni_environment() will block if VM is gone.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3374
  JavaThread* thread = JavaThread::thread_from_jni_environment(env);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3375
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3376
  JNIWrapper("jni_NewDirectByteBuffer");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3377
 HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_ENTRY(env, address, capacity);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3378
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3379
  if (!directBufferSupportInitializeEnded) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3380
    if (!initializeDirectBufferSupport(env, thread)) {
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3381
      HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_RETURN(NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3382
      return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3383
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3384
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3385
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3386
  // Being paranoid about accidental sign extension on address
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3387
  jlong addr = (jlong) ((uintptr_t) address);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3388
  // NOTE that package-private DirectByteBuffer constructor currently
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3389
  // takes int capacity
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3390
  jint  cap  = (jint)  capacity;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3391
  jobject ret = env->NewObject(directByteBufferClass, directByteBufferConstructor, addr, cap);
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3392
  HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3393
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3394
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3395
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  3396
DT_RETURN_MARK_DECL(GetDirectBufferAddress, void*
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  3397
                    , HOTSPOT_JNI_GETDIRECTBUFFERADDRESS_RETURN((void*) _ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3398
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3399
extern "C" void* JNICALL jni_GetDirectBufferAddress(JNIEnv *env, jobject buf)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3400
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3401
  // thread_from_jni_environment() will block if VM is gone.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3402
  JavaThread* thread = JavaThread::thread_from_jni_environment(env);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3403
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3404
  JNIWrapper("jni_GetDirectBufferAddress");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3405
  HOTSPOT_JNI_GETDIRECTBUFFERADDRESS_ENTRY(env, buf);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3406
  void* ret = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3407
  DT_RETURN_MARK(GetDirectBufferAddress, void*, (const void*&)ret);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3408
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3409
  if (!directBufferSupportInitializeEnded) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3410
    if (!initializeDirectBufferSupport(env, thread)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3411
      return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3412
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3413
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3414
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3415
  if ((buf != NULL) && (!env->IsInstanceOf(buf, directBufferClass))) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3416
    return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3417
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3418
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3419
  ret = (void*)(intptr_t)env->GetLongField(buf, directBufferAddressField);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3420
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3421
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3422
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  3423
DT_RETURN_MARK_DECL(GetDirectBufferCapacity, jlong
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  3424
                    , HOTSPOT_JNI_GETDIRECTBUFFERCAPACITY_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3425
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3426
extern "C" jlong JNICALL jni_GetDirectBufferCapacity(JNIEnv *env, jobject buf)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3427
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3428
  // thread_from_jni_environment() will block if VM is gone.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3429
  JavaThread* thread = JavaThread::thread_from_jni_environment(env);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3430
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3431
  JNIWrapper("jni_GetDirectBufferCapacity");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3432
  HOTSPOT_JNI_GETDIRECTBUFFERCAPACITY_ENTRY(env, buf);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3433
  jlong ret = -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3434
  DT_RETURN_MARK(GetDirectBufferCapacity, jlong, (const jlong&)ret);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3435
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3436
  if (!directBufferSupportInitializeEnded) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3437
    if (!initializeDirectBufferSupport(env, thread)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3438
      ret = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3439
      return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3440
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3441
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3442
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3443
  if (buf == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3444
    return -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3445
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3446
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3447
  if (!env->IsInstanceOf(buf, directBufferClass)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3448
    return -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3449
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3450
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3451
  // NOTE that capacity is currently an int in the implementation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3452
  ret = env->GetIntField(buf, bufferCapacityField);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3453
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3454
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3455
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3456
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3457
JNI_LEAF(jint, jni_GetVersion(JNIEnv *env))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3458
  JNIWrapper("GetVersion");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3459
  HOTSPOT_JNI_GETVERSION_ENTRY(env);
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3460
  HOTSPOT_JNI_GETVERSION_RETURN(CurrentVersion);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3461
  return CurrentVersion;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3462
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3463
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3464
extern struct JavaVM_ main_vm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3465
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3466
JNI_LEAF(jint, jni_GetJavaVM(JNIEnv *env, JavaVM **vm))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3467
  JNIWrapper("jni_GetJavaVM");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3468
  HOTSPOT_JNI_GETJAVAVM_ENTRY(env, (void **) vm);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3469
  *vm  = (JavaVM *)(&main_vm);
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3470
  HOTSPOT_JNI_GETJAVAVM_RETURN(JNI_OK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3471
  return JNI_OK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3472
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3473
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36396
diff changeset
  3474
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36396
diff changeset
  3475
JNI_ENTRY(jobject, jni_GetModule(JNIEnv* env, jclass clazz))
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36396
diff changeset
  3476
  JNIWrapper("GetModule");
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36396
diff changeset
  3477
  return Modules::get_module(clazz, THREAD);
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36396
diff changeset
  3478
JNI_END
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36396
diff changeset
  3479
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36396
diff changeset
  3480
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3481
// Structure containing all jni functions
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3482
struct JNINativeInterface_ jni_NativeInterface = {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3483
    NULL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3484
    NULL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3485
    NULL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3486
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3487
    NULL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3488
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3489
    jni_GetVersion,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3490
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3491
    jni_DefineClass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3492
    jni_FindClass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3493
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3494
    jni_FromReflectedMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3495
    jni_FromReflectedField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3496
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3497
    jni_ToReflectedMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3498
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3499
    jni_GetSuperclass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3500
    jni_IsAssignableFrom,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3501
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3502
    jni_ToReflectedField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3503
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3504
    jni_Throw,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3505
    jni_ThrowNew,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3506
    jni_ExceptionOccurred,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3507
    jni_ExceptionDescribe,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3508
    jni_ExceptionClear,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3509
    jni_FatalError,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3510
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3511
    jni_PushLocalFrame,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3512
    jni_PopLocalFrame,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3513
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3514
    jni_NewGlobalRef,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3515
    jni_DeleteGlobalRef,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3516
    jni_DeleteLocalRef,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3517
    jni_IsSameObject,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3518
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3519
    jni_NewLocalRef,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3520
    jni_EnsureLocalCapacity,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3521
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3522
    jni_AllocObject,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3523
    jni_NewObject,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3524
    jni_NewObjectV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3525
    jni_NewObjectA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3526
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3527
    jni_GetObjectClass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3528
    jni_IsInstanceOf,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3529
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3530
    jni_GetMethodID,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3531
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3532
    jni_CallObjectMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3533
    jni_CallObjectMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3534
    jni_CallObjectMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3535
    jni_CallBooleanMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3536
    jni_CallBooleanMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3537
    jni_CallBooleanMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3538
    jni_CallByteMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3539
    jni_CallByteMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3540
    jni_CallByteMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3541
    jni_CallCharMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3542
    jni_CallCharMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3543
    jni_CallCharMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3544
    jni_CallShortMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3545
    jni_CallShortMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3546
    jni_CallShortMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3547
    jni_CallIntMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3548
    jni_CallIntMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3549
    jni_CallIntMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3550
    jni_CallLongMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3551
    jni_CallLongMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3552
    jni_CallLongMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3553
    jni_CallFloatMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3554
    jni_CallFloatMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3555
    jni_CallFloatMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3556
    jni_CallDoubleMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3557
    jni_CallDoubleMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3558
    jni_CallDoubleMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3559
    jni_CallVoidMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3560
    jni_CallVoidMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3561
    jni_CallVoidMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3562
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3563
    jni_CallNonvirtualObjectMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3564
    jni_CallNonvirtualObjectMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3565
    jni_CallNonvirtualObjectMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3566
    jni_CallNonvirtualBooleanMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3567
    jni_CallNonvirtualBooleanMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3568
    jni_CallNonvirtualBooleanMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3569
    jni_CallNonvirtualByteMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3570
    jni_CallNonvirtualByteMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3571
    jni_CallNonvirtualByteMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3572
    jni_CallNonvirtualCharMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3573
    jni_CallNonvirtualCharMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3574
    jni_CallNonvirtualCharMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3575
    jni_CallNonvirtualShortMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3576
    jni_CallNonvirtualShortMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3577
    jni_CallNonvirtualShortMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3578
    jni_CallNonvirtualIntMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3579
    jni_CallNonvirtualIntMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3580
    jni_CallNonvirtualIntMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3581
    jni_CallNonvirtualLongMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3582
    jni_CallNonvirtualLongMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3583
    jni_CallNonvirtualLongMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3584
    jni_CallNonvirtualFloatMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3585
    jni_CallNonvirtualFloatMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3586
    jni_CallNonvirtualFloatMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3587
    jni_CallNonvirtualDoubleMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3588
    jni_CallNonvirtualDoubleMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3589
    jni_CallNonvirtualDoubleMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3590
    jni_CallNonvirtualVoidMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3591
    jni_CallNonvirtualVoidMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3592
    jni_CallNonvirtualVoidMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3593
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3594
    jni_GetFieldID,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3595
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3596
    jni_GetObjectField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3597
    jni_GetBooleanField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3598
    jni_GetByteField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3599
    jni_GetCharField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3600
    jni_GetShortField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3601
    jni_GetIntField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3602
    jni_GetLongField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3603
    jni_GetFloatField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3604
    jni_GetDoubleField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3605
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3606
    jni_SetObjectField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3607
    jni_SetBooleanField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3608
    jni_SetByteField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3609
    jni_SetCharField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3610
    jni_SetShortField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3611
    jni_SetIntField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3612
    jni_SetLongField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3613
    jni_SetFloatField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3614
    jni_SetDoubleField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3615
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3616
    jni_GetStaticMethodID,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3617
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3618
    jni_CallStaticObjectMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3619
    jni_CallStaticObjectMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3620
    jni_CallStaticObjectMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3621
    jni_CallStaticBooleanMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3622
    jni_CallStaticBooleanMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3623
    jni_CallStaticBooleanMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3624
    jni_CallStaticByteMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3625
    jni_CallStaticByteMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3626
    jni_CallStaticByteMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3627
    jni_CallStaticCharMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3628
    jni_CallStaticCharMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3629
    jni_CallStaticCharMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3630
    jni_CallStaticShortMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3631
    jni_CallStaticShortMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3632
    jni_CallStaticShortMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3633
    jni_CallStaticIntMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3634
    jni_CallStaticIntMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3635
    jni_CallStaticIntMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3636
    jni_CallStaticLongMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3637
    jni_CallStaticLongMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3638
    jni_CallStaticLongMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3639
    jni_CallStaticFloatMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3640
    jni_CallStaticFloatMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3641
    jni_CallStaticFloatMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3642
    jni_CallStaticDoubleMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3643
    jni_CallStaticDoubleMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3644
    jni_CallStaticDoubleMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3645
    jni_CallStaticVoidMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3646
    jni_CallStaticVoidMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3647
    jni_CallStaticVoidMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3648
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3649
    jni_GetStaticFieldID,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3650
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3651
    jni_GetStaticObjectField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3652
    jni_GetStaticBooleanField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3653
    jni_GetStaticByteField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3654
    jni_GetStaticCharField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3655
    jni_GetStaticShortField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3656
    jni_GetStaticIntField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3657
    jni_GetStaticLongField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3658
    jni_GetStaticFloatField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3659
    jni_GetStaticDoubleField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3660
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3661
    jni_SetStaticObjectField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3662
    jni_SetStaticBooleanField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3663
    jni_SetStaticByteField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3664
    jni_SetStaticCharField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3665
    jni_SetStaticShortField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3666
    jni_SetStaticIntField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3667
    jni_SetStaticLongField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3668
    jni_SetStaticFloatField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3669
    jni_SetStaticDoubleField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3670
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3671
    jni_NewString,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3672
    jni_GetStringLength,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3673
    jni_GetStringChars,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3674
    jni_ReleaseStringChars,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3675
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3676
    jni_NewStringUTF,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3677
    jni_GetStringUTFLength,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3678
    jni_GetStringUTFChars,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3679
    jni_ReleaseStringUTFChars,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3680
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3681
    jni_GetArrayLength,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3682
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3683
    jni_NewObjectArray,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3684
    jni_GetObjectArrayElement,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3685
    jni_SetObjectArrayElement,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3686
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3687
    jni_NewBooleanArray,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3688
    jni_NewByteArray,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3689
    jni_NewCharArray,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3690
    jni_NewShortArray,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3691
    jni_NewIntArray,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3692
    jni_NewLongArray,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3693
    jni_NewFloatArray,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3694
    jni_NewDoubleArray,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3695
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3696
    jni_GetBooleanArrayElements,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3697
    jni_GetByteArrayElements,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3698
    jni_GetCharArrayElements,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3699
    jni_GetShortArrayElements,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3700
    jni_GetIntArrayElements,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3701
    jni_GetLongArrayElements,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3702
    jni_GetFloatArrayElements,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3703
    jni_GetDoubleArrayElements,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3704
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3705
    jni_ReleaseBooleanArrayElements,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3706
    jni_ReleaseByteArrayElements,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3707
    jni_ReleaseCharArrayElements,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3708
    jni_ReleaseShortArrayElements,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3709
    jni_ReleaseIntArrayElements,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3710
    jni_ReleaseLongArrayElements,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3711
    jni_ReleaseFloatArrayElements,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3712
    jni_ReleaseDoubleArrayElements,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3713
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3714
    jni_GetBooleanArrayRegion,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3715
    jni_GetByteArrayRegion,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3716
    jni_GetCharArrayRegion,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3717
    jni_GetShortArrayRegion,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3718
    jni_GetIntArrayRegion,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3719
    jni_GetLongArrayRegion,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3720
    jni_GetFloatArrayRegion,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3721
    jni_GetDoubleArrayRegion,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3722
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3723
    jni_SetBooleanArrayRegion,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3724
    jni_SetByteArrayRegion,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3725
    jni_SetCharArrayRegion,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3726
    jni_SetShortArrayRegion,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3727
    jni_SetIntArrayRegion,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3728
    jni_SetLongArrayRegion,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3729
    jni_SetFloatArrayRegion,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3730
    jni_SetDoubleArrayRegion,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3731
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3732
    jni_RegisterNatives,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3733
    jni_UnregisterNatives,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3734
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3735
    jni_MonitorEnter,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3736
    jni_MonitorExit,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3737
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3738
    jni_GetJavaVM,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3739
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3740
    jni_GetStringRegion,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3741
    jni_GetStringUTFRegion,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3742
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3743
    jni_GetPrimitiveArrayCritical,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3744
    jni_ReleasePrimitiveArrayCritical,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3745
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3746
    jni_GetStringCritical,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3747
    jni_ReleaseStringCritical,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3748
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3749
    jni_NewWeakGlobalRef,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3750
    jni_DeleteWeakGlobalRef,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3751
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3752
    jni_ExceptionCheck,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3753
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3754
    jni_NewDirectByteBuffer,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3755
    jni_GetDirectBufferAddress,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3756
    jni_GetDirectBufferCapacity,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3757
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3758
    // New 1_6 features
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3759
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36396
diff changeset
  3760
    jni_GetObjectRefType,
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36396
diff changeset
  3761
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36396
diff changeset
  3762
    // Module features
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36396
diff changeset
  3763
42307
cefc81dc1d52 8169069: Module system implementation refresh (11/2016)
alanb
parents: 41669
diff changeset
  3764
    jni_GetModule
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3765
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3766
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3767
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3768
// For jvmti use to modify jni function table.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3769
// Java threads in native contiues to run until it is transitioned
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3770
// to VM at safepoint. Before the transition or before it is blocked
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3771
// for safepoint it may access jni function table. VM could crash if
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3772
// any java thread access the jni function table in the middle of memcpy.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3773
// To avoid this each function pointers are copied automically.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3774
void copy_jni_function_table(const struct JNINativeInterface_ *new_jni_NativeInterface) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3775
  assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3776
  intptr_t *a = (intptr_t *) jni_functions();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3777
  intptr_t *b = (intptr_t *) new_jni_NativeInterface;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3778
  for (uint i=0; i <  sizeof(struct JNINativeInterface_)/sizeof(void *); i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3779
    Atomic::store_ptr(*b++, a++);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3780
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3781
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3782
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3783
void quicken_jni_functions() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3784
  // Replace Get<Primitive>Field with fast versions
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3785
  if (UseFastJNIAccessors && !JvmtiExport::can_post_field_access()
34285
0b07014c15e9 8143155: Remove TraceRuntimeCalls, TraceJNICalls, and TraceJVMCalls rather than convert to UL
rprotacio
parents: 33813
diff changeset
  3786
      && !VerifyJNIFields && !CountJNICalls && !CheckJNICalls
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3787
#if defined(_WINDOWS) && defined(IA32) && defined(COMPILER2)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3788
      // windows x86 currently needs SEH wrapper and the gain of the fast
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3789
      // versions currently isn't certain for server vm on uniprocessor.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3790
      && os::is_MP()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3791
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3792
  ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3793
    address func;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3794
    func = JNI_FastGetField::generate_fast_get_boolean_field();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3795
    if (func != (address)-1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3796
      jni_NativeInterface.GetBooleanField = (GetBooleanField_t)func;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3797
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3798
    func = JNI_FastGetField::generate_fast_get_byte_field();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3799
    if (func != (address)-1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3800
      jni_NativeInterface.GetByteField = (GetByteField_t)func;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3801
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3802
    func = JNI_FastGetField::generate_fast_get_char_field();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3803
    if (func != (address)-1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3804
      jni_NativeInterface.GetCharField = (GetCharField_t)func;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3805
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3806
    func = JNI_FastGetField::generate_fast_get_short_field();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3807
    if (func != (address)-1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3808
      jni_NativeInterface.GetShortField = (GetShortField_t)func;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3809
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3810
    func = JNI_FastGetField::generate_fast_get_int_field();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3811
    if (func != (address)-1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3812
      jni_NativeInterface.GetIntField = (GetIntField_t)func;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3813
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3814
    func = JNI_FastGetField::generate_fast_get_long_field();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3815
    if (func != (address)-1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3816
      jni_NativeInterface.GetLongField = (GetLongField_t)func;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3817
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3818
    func = JNI_FastGetField::generate_fast_get_float_field();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3819
    if (func != (address)-1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3820
      jni_NativeInterface.GetFloatField = (GetFloatField_t)func;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3821
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3822
    func = JNI_FastGetField::generate_fast_get_double_field();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3823
    if (func != (address)-1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3824
      jni_NativeInterface.GetDoubleField = (GetDoubleField_t)func;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3825
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3826
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3827
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3828
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3829
// Returns the function structure
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3830
struct JNINativeInterface_* jni_functions() {
13975
2f7431485cfa 7189254: Change makefiles for more flexibility to override defaults
jprovino
parents: 13728
diff changeset
  3831
#if INCLUDE_JNI_CHECK
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3832
  if (CheckJNICalls) return jni_functions_check();
13975
2f7431485cfa 7189254: Change makefiles for more flexibility to override defaults
jprovino
parents: 13728
diff changeset
  3833
#endif // INCLUDE_JNI_CHECK
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3834
  return &jni_NativeInterface;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3835
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3836
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3837
// Returns the function structure
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3838
struct JNINativeInterface_* jni_functions_nocheck() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3839
  return &jni_NativeInterface;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3840
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3841
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3842
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3843
// Invocation API
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3844
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3845
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3846
// Forward declaration
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3847
extern const struct JNIInvokeInterface_ jni_InvokeInterface;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3848
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3849
// Global invocation API vars
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3850
volatile jint vm_created = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3851
// Indicate whether it is safe to recreate VM
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3852
volatile jint safe_to_recreate_vm = 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3853
struct JavaVM_ main_vm = {&jni_InvokeInterface};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3854
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3855
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3856
#define JAVASTACKSIZE (400 * 1024)    /* Default size of a thread java stack */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3857
enum { VERIFY_NONE, VERIFY_REMOTE, VERIFY_ALL };
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3858
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  3859
DT_RETURN_MARK_DECL(GetDefaultJavaVMInitArgs, jint
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  3860
                    , HOTSPOT_JNI_GETDEFAULTJAVAVMINITARGS_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3861
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3862
_JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_GetDefaultJavaVMInitArgs(void *args_) {
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3863
  HOTSPOT_JNI_GETDEFAULTJAVAVMINITARGS_ENTRY(args_);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3864
  JDK1_1InitArgs *args = (JDK1_1InitArgs *)args_;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3865
  jint ret = JNI_ERR;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3866
  DT_RETURN_MARK(GetDefaultJavaVMInitArgs, jint, (const jint&)ret);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3867
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3868
  if (Threads::is_supported_jni_version(args->version)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3869
    ret = JNI_OK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3870
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3871
  // 1.1 style no longer supported in hotspot.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3872
  // According the JNI spec, we should update args->version on return.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3873
  // We also use the structure to communicate with launcher about default
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3874
  // stack size.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3875
  if (args->version == JNI_VERSION_1_1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3876
    args->version = JNI_VERSION_1_2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3877
    // javaStackSize is int in arguments structure
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3878
    assert(jlong(ThreadStackSize) * K < INT_MAX, "integer overflow");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3879
    args->javaStackSize = (jint)(ThreadStackSize * K);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3880
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3881
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3882
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3883
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  3884
DT_RETURN_MARK_DECL(CreateJavaVM, jint
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  3885
                    , HOTSPOT_JNI_CREATEJAVAVM_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3886
30143
7e99f2b4bae5 8074860: Structured Exception Catcher missing around CreateJavaVM on Windows
stuefe
parents: 29081
diff changeset
  3887
static jint JNI_CreateJavaVM_inner(JavaVM **vm, void **penv, void *args) {
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3888
  HOTSPOT_JNI_CREATEJAVAVM_ENTRY((void **) vm, penv, args);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3889
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3890
  jint result = JNI_ERR;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3891
  DT_RETURN_MARK(CreateJavaVM, jint, (const jint&)result);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3892
4448
d6ec2737186c 6896043: first round of zero fixes
twisti
parents: 4089
diff changeset
  3893
  // We're about to use Atomic::xchg for synchronization.  Some Zero
d6ec2737186c 6896043: first round of zero fixes
twisti
parents: 4089
diff changeset
  3894
  // platforms use the GCC builtin __sync_lock_test_and_set for this,
d6ec2737186c 6896043: first round of zero fixes
twisti
parents: 4089
diff changeset
  3895
  // but __sync_lock_test_and_set is not guaranteed to do what we want
d6ec2737186c 6896043: first round of zero fixes
twisti
parents: 4089
diff changeset
  3896
  // on all architectures.  So we check it works before relying on it.
d6ec2737186c 6896043: first round of zero fixes
twisti
parents: 4089
diff changeset
  3897
#if defined(ZERO) && defined(ASSERT)
d6ec2737186c 6896043: first round of zero fixes
twisti
parents: 4089
diff changeset
  3898
  {
d6ec2737186c 6896043: first round of zero fixes
twisti
parents: 4089
diff changeset
  3899
    jint a = 0xcafebabe;
d6ec2737186c 6896043: first round of zero fixes
twisti
parents: 4089
diff changeset
  3900
    jint b = Atomic::xchg(0xdeadbeef, &a);
d6ec2737186c 6896043: first round of zero fixes
twisti
parents: 4089
diff changeset
  3901
    void *c = &a;
d6ec2737186c 6896043: first round of zero fixes
twisti
parents: 4089
diff changeset
  3902
    void *d = Atomic::xchg_ptr(&b, &c);
4561
4dfa5956fbb9 6913869: Zero assert fix
twisti
parents: 4448
diff changeset
  3903
    assert(a == (jint) 0xdeadbeef && b == (jint) 0xcafebabe, "Atomic::xchg() works");
4448
d6ec2737186c 6896043: first round of zero fixes
twisti
parents: 4089
diff changeset
  3904
    assert(c == &b && d == &a, "Atomic::xchg_ptr() works");
d6ec2737186c 6896043: first round of zero fixes
twisti
parents: 4089
diff changeset
  3905
  }
d6ec2737186c 6896043: first round of zero fixes
twisti
parents: 4089
diff changeset
  3906
#endif // ZERO && ASSERT
d6ec2737186c 6896043: first round of zero fixes
twisti
parents: 4089
diff changeset
  3907
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3908
  // At the moment it's only possible to have one Java VM,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3909
  // since some of the runtime state is in global variables.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3910
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3911
  // We cannot use our mutex locks here, since they only work on
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3912
  // Threads. We do an atomic compare and exchange to ensure only
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3913
  // one thread can call this method at a time
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3914
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3915
  // We use Atomic::xchg rather than Atomic::add/dec since on some platforms
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3916
  // the add/dec implementations are dependent on whether we are running
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3917
  // on a multiprocessor, and at this stage of initialization the os::is_MP
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3918
  // function used to determine this will always return false. Atomic::xchg
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3919
  // does not have this problem.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3920
  if (Atomic::xchg(1, &vm_created) == 1) {
18680
6d5dc445baec 8019833: Wrong JNI error code for preexisting JVM
coleenp
parents: 18486
diff changeset
  3921
    return JNI_EEXIST;   // already created, or create attempt in progress
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3922
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3923
  if (Atomic::xchg(0, &safe_to_recreate_vm) == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3924
    return JNI_ERR;  // someone tried and failed and retry not allowed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3925
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3926
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3927
  assert(vm_created == 1, "vm_created is true during the creation");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3928
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3929
  /**
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3930
   * Certain errors during initialization are recoverable and do not
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3931
   * prevent this method from being called again at a later time
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3932
   * (perhaps with different arguments).  However, at a certain
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3933
   * point during initialization if an error occurs we cannot allow
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3934
   * this function to be called again (or it will crash).  In those
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3935
   * situations, the 'canTryAgain' flag is set to false, which atomically
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3936
   * sets safe_to_recreate_vm to 1, such that any new call to
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3937
   * JNI_CreateJavaVM will immediately fail using the above logic.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3938
   */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3939
  bool can_try_again = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3940
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3941
  result = Threads::create_vm((JavaVMInitArgs*) args, &can_try_again);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3942
  if (result == JNI_OK) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3943
    JavaThread *thread = JavaThread::current();
22539
a27fa687eca8 8028275: Metaspace ShrinkGrowTest causes fatal error if run with JFR
coleenp
parents: 22532
diff changeset
  3944
    assert(!thread->has_pending_exception(), "should have returned not OK");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3945
    /* thread is thread_in_vm here */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3946
    *vm = (JavaVM *)(&main_vm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3947
    *(JNIEnv**)penv = thread->jni_environment();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3948
33160
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32598
diff changeset
  3949
#if INCLUDE_JVMCI
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32598
diff changeset
  3950
    if (EnableJVMCI) {
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32598
diff changeset
  3951
      if (UseJVMCICompiler) {
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32598
diff changeset
  3952
        // JVMCI is initialized on a CompilerThread
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32598
diff changeset
  3953
        if (BootstrapJVMCI) {
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32598
diff changeset
  3954
          JavaThread* THREAD = thread;
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32598
diff changeset
  3955
          JVMCICompiler* compiler = JVMCICompiler::instance(CATCH);
38674
eacc567feae8 8156034: [JVMCI] Notify the jvmci compiler on completion of a bootstrap
never
parents: 38151
diff changeset
  3956
          compiler->bootstrap(THREAD);
eacc567feae8 8156034: [JVMCI] Notify the jvmci compiler on completion of a bootstrap
never
parents: 38151
diff changeset
  3957
          if (HAS_PENDING_EXCEPTION) {
eacc567feae8 8156034: [JVMCI] Notify the jvmci compiler on completion of a bootstrap
never
parents: 38151
diff changeset
  3958
            HandleMark hm;
eacc567feae8 8156034: [JVMCI] Notify the jvmci compiler on completion of a bootstrap
never
parents: 38151
diff changeset
  3959
            vm_exit_during_initialization(Handle(THREAD, PENDING_EXCEPTION));
eacc567feae8 8156034: [JVMCI] Notify the jvmci compiler on completion of a bootstrap
never
parents: 38151
diff changeset
  3960
          }
33160
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32598
diff changeset
  3961
        }
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32598
diff changeset
  3962
      }
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32598
diff changeset
  3963
    }
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32598
diff changeset
  3964
#endif
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32598
diff changeset
  3965
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3966
    // Tracks the time application was running before GC
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3967
    RuntimeService::record_application_start();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3968
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3969
    // Notify JVMTI
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3970
    if (JvmtiExport::should_post_thread_life()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3971
       JvmtiExport::post_thread_start(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3972
    }
11480
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents: 11247
diff changeset
  3973
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17631
diff changeset
  3974
    EventThreadStart event;
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17631
diff changeset
  3975
    if (event.should_commit()) {
36384
b0b41336a9a8 8143226: Minor updates to Event Based tracing
mgronlun
parents: 36183
diff changeset
  3976
      event.set_thread(THREAD_TRACE_ID(thread));
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17631
diff changeset
  3977
      event.commit();
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17631
diff changeset
  3978
    }
11480
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents: 11247
diff changeset
  3979
18683
a6418e038255 8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents: 18680
diff changeset
  3980
#ifndef PRODUCT
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3981
    // Check if we should compile all classes on bootclasspath
18683
a6418e038255 8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents: 18680
diff changeset
  3982
    if (CompileTheWorld) ClassLoader::compile_the_world();
a6418e038255 8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents: 18680
diff changeset
  3983
    if (ReplayCompiles) ciReplay::replay(thread);
a6418e038255 8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents: 18680
diff changeset
  3984
a6418e038255 8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents: 18680
diff changeset
  3985
    // Some platforms (like Win*) need a wrapper around these test
a6418e038255 8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents: 18680
diff changeset
  3986
    // functions in order to properly handle error conditions.
46589
f1c04490ded1 8182848: Some functions misplaced in debug.hpp
coleenp
parents: 46431
diff changeset
  3987
    VMError::test_error_handler();
35519
9200162499f7 8146994: Move internal vm tests to a separate file
ehelin
parents: 35500
diff changeset
  3988
    if (ExecuteInternalVMTests) {
9200162499f7 8146994: Move internal vm tests to a separate file
ehelin
parents: 35500
diff changeset
  3989
      InternalVMTests::run();
9200162499f7 8146994: Move internal vm tests to a separate file
ehelin
parents: 35500
diff changeset
  3990
    }
18683
a6418e038255 8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents: 18680
diff changeset
  3991
#endif
a6418e038255 8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents: 18680
diff changeset
  3992
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3993
    // Since this is not a JVM_ENTRY we have to set the thread state manually before leaving.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3994
    ThreadStateTransition::transition_and_fence(thread, _thread_in_vm, _thread_in_native);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3995
  } else {
22539
a27fa687eca8 8028275: Metaspace ShrinkGrowTest causes fatal error if run with JFR
coleenp
parents: 22532
diff changeset
  3996
    // If create_vm exits because of a pending exception, exit with that
a27fa687eca8 8028275: Metaspace ShrinkGrowTest causes fatal error if run with JFR
coleenp
parents: 22532
diff changeset
  3997
    // exception.  In the future when we figure out how to reclaim memory,
a27fa687eca8 8028275: Metaspace ShrinkGrowTest causes fatal error if run with JFR
coleenp
parents: 22532
diff changeset
  3998
    // we may be able to exit with JNI_ERR and allow the calling application
a27fa687eca8 8028275: Metaspace ShrinkGrowTest causes fatal error if run with JFR
coleenp
parents: 22532
diff changeset
  3999
    // to continue.
a27fa687eca8 8028275: Metaspace ShrinkGrowTest causes fatal error if run with JFR
coleenp
parents: 22532
diff changeset
  4000
    if (Universe::is_fully_initialized()) {
a27fa687eca8 8028275: Metaspace ShrinkGrowTest causes fatal error if run with JFR
coleenp
parents: 22532
diff changeset
  4001
      // otherwise no pending exception possible - VM will already have aborted
a27fa687eca8 8028275: Metaspace ShrinkGrowTest causes fatal error if run with JFR
coleenp
parents: 22532
diff changeset
  4002
      JavaThread* THREAD = JavaThread::current();
a27fa687eca8 8028275: Metaspace ShrinkGrowTest causes fatal error if run with JFR
coleenp
parents: 22532
diff changeset
  4003
      if (HAS_PENDING_EXCEPTION) {
a27fa687eca8 8028275: Metaspace ShrinkGrowTest causes fatal error if run with JFR
coleenp
parents: 22532
diff changeset
  4004
        HandleMark hm;
a27fa687eca8 8028275: Metaspace ShrinkGrowTest causes fatal error if run with JFR
coleenp
parents: 22532
diff changeset
  4005
        vm_exit_during_initialization(Handle(THREAD, PENDING_EXCEPTION));
a27fa687eca8 8028275: Metaspace ShrinkGrowTest causes fatal error if run with JFR
coleenp
parents: 22532
diff changeset
  4006
      }
a27fa687eca8 8028275: Metaspace ShrinkGrowTest causes fatal error if run with JFR
coleenp
parents: 22532
diff changeset
  4007
    }
a27fa687eca8 8028275: Metaspace ShrinkGrowTest causes fatal error if run with JFR
coleenp
parents: 22532
diff changeset
  4008
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4009
    if (can_try_again) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4010
      // reset safe_to_recreate_vm to 1 so that retrial would be possible
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4011
      safe_to_recreate_vm = 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4012
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4013
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4014
    // Creation failed. We must reset vm_created
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4015
    *vm = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4016
    *(JNIEnv**)penv = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4017
    // reset vm_created last to avoid race condition. Use OrderAccess to
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4018
    // control both compiler and architectural-based reordering.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4019
    OrderAccess::release_store(&vm_created, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4020
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4021
33600
922600753f71 8139801: Error message from validation check has wrong order on Windows
sangheki
parents: 33576
diff changeset
  4022
  // Flush stdout and stderr before exit.
922600753f71 8139801: Error message from validation check has wrong order on Windows
sangheki
parents: 33576
diff changeset
  4023
  fflush(stdout);
922600753f71 8139801: Error message from validation check has wrong order on Windows
sangheki
parents: 33576
diff changeset
  4024
  fflush(stderr);
922600753f71 8139801: Error message from validation check has wrong order on Windows
sangheki
parents: 33576
diff changeset
  4025
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4026
  return result;
30143
7e99f2b4bae5 8074860: Structured Exception Catcher missing around CreateJavaVM on Windows
stuefe
parents: 29081
diff changeset
  4027
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4028
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4029
30143
7e99f2b4bae5 8074860: Structured Exception Catcher missing around CreateJavaVM on Windows
stuefe
parents: 29081
diff changeset
  4030
_JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_CreateJavaVM(JavaVM **vm, void **penv, void *args) {
46955
c5a455ec08c0 8186199: [windows] JNI_DestroyJavaVM not covered by SEH
stuefe
parents: 46589
diff changeset
  4031
  jint result = JNI_ERR;
30143
7e99f2b4bae5 8074860: Structured Exception Catcher missing around CreateJavaVM on Windows
stuefe
parents: 29081
diff changeset
  4032
  // On Windows, let CreateJavaVM run with SEH protection
7e99f2b4bae5 8074860: Structured Exception Catcher missing around CreateJavaVM on Windows
stuefe
parents: 29081
diff changeset
  4033
#ifdef _WIN32
7e99f2b4bae5 8074860: Structured Exception Catcher missing around CreateJavaVM on Windows
stuefe
parents: 29081
diff changeset
  4034
  __try {
7e99f2b4bae5 8074860: Structured Exception Catcher missing around CreateJavaVM on Windows
stuefe
parents: 29081
diff changeset
  4035
#endif
7e99f2b4bae5 8074860: Structured Exception Catcher missing around CreateJavaVM on Windows
stuefe
parents: 29081
diff changeset
  4036
    result = JNI_CreateJavaVM_inner(vm, penv, args);
7e99f2b4bae5 8074860: Structured Exception Catcher missing around CreateJavaVM on Windows
stuefe
parents: 29081
diff changeset
  4037
#ifdef _WIN32
7e99f2b4bae5 8074860: Structured Exception Catcher missing around CreateJavaVM on Windows
stuefe
parents: 29081
diff changeset
  4038
  } __except(topLevelExceptionFilter((_EXCEPTION_POINTERS*)_exception_info())) {
7e99f2b4bae5 8074860: Structured Exception Catcher missing around CreateJavaVM on Windows
stuefe
parents: 29081
diff changeset
  4039
    // Nothing to do.
7e99f2b4bae5 8074860: Structured Exception Catcher missing around CreateJavaVM on Windows
stuefe
parents: 29081
diff changeset
  4040
  }
7e99f2b4bae5 8074860: Structured Exception Catcher missing around CreateJavaVM on Windows
stuefe
parents: 29081
diff changeset
  4041
#endif
7e99f2b4bae5 8074860: Structured Exception Catcher missing around CreateJavaVM on Windows
stuefe
parents: 29081
diff changeset
  4042
  return result;
7e99f2b4bae5 8074860: Structured Exception Catcher missing around CreateJavaVM on Windows
stuefe
parents: 29081
diff changeset
  4043
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4044
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4045
_JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_GetCreatedJavaVMs(JavaVM **vm_buf, jsize bufLen, jsize *numVMs) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4046
  // See bug 4367188, the wrapper can sometimes cause VM crashes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4047
  // JNIWrapper("GetCreatedJavaVMs");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  4048
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  4049
  HOTSPOT_JNI_GETCREATEDJAVAVMS_ENTRY((void **) vm_buf, bufLen, (uintptr_t *) numVMs);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  4050
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4051
  if (vm_created) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4052
    if (numVMs != NULL) *numVMs = 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4053
    if (bufLen > 0)     *vm_buf = (JavaVM *)(&main_vm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4054
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4055
    if (numVMs != NULL) *numVMs = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4056
  }
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  4057
  HOTSPOT_JNI_GETCREATEDJAVAVMS_RETURN(JNI_OK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4058
  return JNI_OK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4059
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4060
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4061
extern "C" {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4062
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  4063
DT_RETURN_MARK_DECL(DestroyJavaVM, jint
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  4064
                    , HOTSPOT_JNI_DESTROYJAVAVM_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4065
46955
c5a455ec08c0 8186199: [windows] JNI_DestroyJavaVM not covered by SEH
stuefe
parents: 46589
diff changeset
  4066
static jint JNICALL jni_DestroyJavaVM_inner(JavaVM *vm) {
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  4067
  HOTSPOT_JNI_DESTROYJAVAVM_ENTRY(vm);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4068
  jint res = JNI_ERR;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4069
  DT_RETURN_MARK(DestroyJavaVM, jint, (const jint&)res);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4070
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4071
  if (!vm_created) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4072
    res = JNI_ERR;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4073
    return res;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4074
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4075
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4076
  JNIWrapper("DestroyJavaVM");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4077
  JNIEnv *env;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4078
  JavaVMAttachArgs destroyargs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4079
  destroyargs.version = CurrentVersion;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4080
  destroyargs.name = (char *)"DestroyJavaVM";
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4081
  destroyargs.group = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4082
  res = vm->AttachCurrentThread((void **)&env, (void *)&destroyargs);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4083
  if (res != JNI_OK) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4084
    return res;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4085
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4086
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4087
  // Since this is not a JVM_ENTRY we have to set the thread state manually before entering.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4088
  JavaThread* thread = JavaThread::current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4089
  ThreadStateTransition::transition_from_native(thread, _thread_in_vm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4090
  if (Threads::destroy_vm()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4091
    // Should not change thread state, VM is gone
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4092
    vm_created = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4093
    res = JNI_OK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4094
    return res;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4095
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4096
    ThreadStateTransition::transition_and_fence(thread, _thread_in_vm, _thread_in_native);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4097
    res = JNI_ERR;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4098
    return res;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4099
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4100
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4101
46955
c5a455ec08c0 8186199: [windows] JNI_DestroyJavaVM not covered by SEH
stuefe
parents: 46589
diff changeset
  4102
jint JNICALL jni_DestroyJavaVM(JavaVM *vm) {
c5a455ec08c0 8186199: [windows] JNI_DestroyJavaVM not covered by SEH
stuefe
parents: 46589
diff changeset
  4103
  jint result = JNI_ERR;
c5a455ec08c0 8186199: [windows] JNI_DestroyJavaVM not covered by SEH
stuefe
parents: 46589
diff changeset
  4104
  // On Windows, we need SEH protection
c5a455ec08c0 8186199: [windows] JNI_DestroyJavaVM not covered by SEH
stuefe
parents: 46589
diff changeset
  4105
#ifdef _WIN32
c5a455ec08c0 8186199: [windows] JNI_DestroyJavaVM not covered by SEH
stuefe
parents: 46589
diff changeset
  4106
  __try {
c5a455ec08c0 8186199: [windows] JNI_DestroyJavaVM not covered by SEH
stuefe
parents: 46589
diff changeset
  4107
#endif
c5a455ec08c0 8186199: [windows] JNI_DestroyJavaVM not covered by SEH
stuefe
parents: 46589
diff changeset
  4108
    result = jni_DestroyJavaVM_inner(vm);
c5a455ec08c0 8186199: [windows] JNI_DestroyJavaVM not covered by SEH
stuefe
parents: 46589
diff changeset
  4109
#ifdef _WIN32
c5a455ec08c0 8186199: [windows] JNI_DestroyJavaVM not covered by SEH
stuefe
parents: 46589
diff changeset
  4110
  } __except(topLevelExceptionFilter((_EXCEPTION_POINTERS*)_exception_info())) {
c5a455ec08c0 8186199: [windows] JNI_DestroyJavaVM not covered by SEH
stuefe
parents: 46589
diff changeset
  4111
    // Nothing to do.
c5a455ec08c0 8186199: [windows] JNI_DestroyJavaVM not covered by SEH
stuefe
parents: 46589
diff changeset
  4112
  }
c5a455ec08c0 8186199: [windows] JNI_DestroyJavaVM not covered by SEH
stuefe
parents: 46589
diff changeset
  4113
#endif
c5a455ec08c0 8186199: [windows] JNI_DestroyJavaVM not covered by SEH
stuefe
parents: 46589
diff changeset
  4114
  return result;
c5a455ec08c0 8186199: [windows] JNI_DestroyJavaVM not covered by SEH
stuefe
parents: 46589
diff changeset
  4115
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4116
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4117
static jint attach_current_thread(JavaVM *vm, void **penv, void *_args, bool daemon) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4118
  JavaVMAttachArgs *args = (JavaVMAttachArgs *) _args;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4119
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4120
  // Check below commented out from JDK1.2fcs as well
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4121
  /*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4122
  if (args && (args->version != JNI_VERSION_1_1 || args->version != JNI_VERSION_1_2)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4123
    return JNI_EVERSION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4124
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4125
  */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4126
34633
2a6c7c7b30a7 8132510: Replace ThreadLocalStorage with compiler/language-based thread-local variables
dholmes
parents: 34317
diff changeset
  4127
  Thread* t = Thread::current_or_null();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4128
  if (t != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4129
    // If the thread has been attached this operation is a no-op
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4130
    *(JNIEnv**)penv = ((JavaThread*) t)->jni_environment();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4131
    return JNI_OK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4132
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4133
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4134
  // Create a thread and mark it as attaching so it will be skipped by the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4135
  // ThreadsListEnumerator - see CR 6404306
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4136
  JavaThread* thread = new JavaThread(true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4137
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4138
  // Set correct safepoint info. The thread is going to call into Java when
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4139
  // initializing the Java level thread object. Hence, the correct state must
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4140
  // be set in order for the Safepoint code to deal with it correctly.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4141
  thread->set_thread_state(_thread_in_vm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4142
  thread->record_stack_base_and_size();
34633
2a6c7c7b30a7 8132510: Replace ThreadLocalStorage with compiler/language-based thread-local variables
dholmes
parents: 34317
diff changeset
  4143
  thread->initialize_thread_current();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4144
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4145
  if (!os::create_attached_thread(thread)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4146
    delete thread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4147
    return JNI_ERR;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4148
  }
5041
5bce37d77dde 6914050: jvm assertion "guard pages must be in use" in -Xcomp mode
coleenp
parents: 4571
diff changeset
  4149
  // Enable stack overflow checks
5bce37d77dde 6914050: jvm assertion "guard pages must be in use" in -Xcomp mode
coleenp
parents: 4571
diff changeset
  4150
  thread->create_stack_guard_pages();
5bce37d77dde 6914050: jvm assertion "guard pages must be in use" in -Xcomp mode
coleenp
parents: 4571
diff changeset
  4151
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4152
  thread->initialize_tlab();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4153
6176
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5547
diff changeset
  4154
  thread->cache_global_variables();
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5547
diff changeset
  4155
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4156
  // Crucial that we do not have a safepoint check for this thread, since it has
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4157
  // not been added to the Thread list yet.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4158
  { Threads_lock->lock_without_safepoint_check();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4159
    // This must be inside this lock in order to get FullGCALot to work properly, i.e., to
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4160
    // avoid this thread trying to do a GC before it is added to the thread-list
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4161
    thread->set_active_handles(JNIHandleBlock::allocate_block());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4162
    Threads::add(thread, daemon);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4163
    Threads_lock->unlock();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4164
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4165
  // Create thread group and name info from attach arguments
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4166
  oop group = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4167
  char* thread_name = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4168
  if (args != NULL && Threads::is_supported_jni_version(args->version)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4169
    group = JNIHandles::resolve(args->group);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4170
    thread_name = args->name; // may be NULL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4171
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4172
  if (group == NULL) group = Universe::main_thread_group();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4173
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4174
  // Create Java level thread object and attach it to this thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4175
  bool attach_failed = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4176
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4177
    EXCEPTION_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4178
    HandleMark hm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4179
    Handle thread_group(THREAD, group);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4180
    thread->allocate_threadObj(thread_group, thread_name, daemon, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4181
    if (HAS_PENDING_EXCEPTION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4182
      CLEAR_PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4183
      // cleanup outside the handle mark.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4184
      attach_failed = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4185
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4186
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4187
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4188
  if (attach_failed) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4189
    // Added missing cleanup
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4190
    thread->cleanup_failed_attach_current_thread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4191
    return JNI_ERR;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4192
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4193
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4194
  // mark the thread as no longer attaching
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4195
  // this uses a fence to push the change through so we don't have
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4196
  // to regrab the threads_lock
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  4197
  thread->set_done_attaching_via_jni();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4198
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4199
  // Set java thread status.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4200
  java_lang_Thread::set_thread_status(thread->threadObj(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4201
              java_lang_Thread::RUNNABLE);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4202
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4203
  // Notify the debugger
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4204
  if (JvmtiExport::should_post_thread_life()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4205
    JvmtiExport::post_thread_start(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4206
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4207
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17631
diff changeset
  4208
  EventThreadStart event;
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17631
diff changeset
  4209
  if (event.should_commit()) {
36384
b0b41336a9a8 8143226: Minor updates to Event Based tracing
mgronlun
parents: 36183
diff changeset
  4210
    event.set_thread(THREAD_TRACE_ID(thread));
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17631
diff changeset
  4211
    event.commit();
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17631
diff changeset
  4212
  }
11480
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents: 11247
diff changeset
  4213
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4214
  *(JNIEnv**)penv = thread->jni_environment();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4215
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4216
  // Now leaving the VM, so change thread_state. This is normally automatically taken care
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4217
  // of in the JVM_ENTRY. But in this situation we have to do it manually. Notice, that by
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4218
  // using ThreadStateTransition::transition, we do a callback to the safepoint code if
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4219
  // needed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4220
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4221
  ThreadStateTransition::transition_and_fence(thread, _thread_in_vm, _thread_in_native);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4222
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4223
  // Perform any platform dependent FPU setup
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4224
  os::setup_fpu();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4225
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4226
  return JNI_OK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4227
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4228
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4229
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4230
jint JNICALL jni_AttachCurrentThread(JavaVM *vm, void **penv, void *_args) {
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  4231
  HOTSPOT_JNI_ATTACHCURRENTTHREAD_ENTRY(vm, penv, _args);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4232
  if (!vm_created) {
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  4233
  HOTSPOT_JNI_ATTACHCURRENTTHREAD_RETURN((uint32_t) JNI_ERR);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4234
    return JNI_ERR;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4235
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4236
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4237
  JNIWrapper("AttachCurrentThread");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4238
  jint ret = attach_current_thread(vm, penv, _args, false);
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  4239
  HOTSPOT_JNI_ATTACHCURRENTTHREAD_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4240
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4241
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4242
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4243
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4244
jint JNICALL jni_DetachCurrentThread(JavaVM *vm)  {
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  4245
  HOTSPOT_JNI_DETACHCURRENTTHREAD_ENTRY(vm);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4246
  VM_Exit::block_if_vm_exited();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4247
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4248
  JNIWrapper("DetachCurrentThread");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4249
34633
2a6c7c7b30a7 8132510: Replace ThreadLocalStorage with compiler/language-based thread-local variables
dholmes
parents: 34317
diff changeset
  4250
  // If the thread has already been detached the operation is a no-op
2a6c7c7b30a7 8132510: Replace ThreadLocalStorage with compiler/language-based thread-local variables
dholmes
parents: 34317
diff changeset
  4251
  if (Thread::current_or_null() == NULL) {
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  4252
  HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN(JNI_OK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4253
    return JNI_OK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4254
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4255
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4256
  JavaThread* thread = JavaThread::current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4257
  if (thread->has_last_Java_frame()) {
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  4258
  HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN((uint32_t) JNI_ERR);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4259
    // Can't detach a thread that's running java, that can't work.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4260
    return JNI_ERR;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4261
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4262
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4263
  // Safepoint support. Have to do call-back to safepoint code, if in the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4264
  // middel of a safepoint operation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4265
  ThreadStateTransition::transition_from_native(thread, _thread_in_vm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4266
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4267
  // XXX: Note that JavaThread::exit() call below removes the guards on the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4268
  // stack pages set up via enable_stack_{red,yellow}_zone() calls
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4269
  // above in jni_AttachCurrentThread. Unfortunately, while the setting
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4270
  // of the guards is visible in jni_AttachCurrentThread above,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4271
  // the removal of the guards is buried below in JavaThread::exit()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4272
  // here. The abstraction should be more symmetrically either exposed
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4273
  // or hidden (e.g. it could probably be hidden in the same
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4274
  // (platform-dependent) methods where we do alternate stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4275
  // maintenance work?)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4276
  thread->exit(false, JavaThread::jni_detach);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4277
  delete thread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4278
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  4279
  HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN(JNI_OK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4280
  return JNI_OK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4281
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4282
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  4283
DT_RETURN_MARK_DECL(GetEnv, jint
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  4284
                    , HOTSPOT_JNI_GETENV_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4285
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4286
jint JNICALL jni_GetEnv(JavaVM *vm, void **penv, jint version) {
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  4287
  HOTSPOT_JNI_GETENV_ENTRY(vm, penv, version);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4288
  jint ret = JNI_ERR;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4289
  DT_RETURN_MARK(GetEnv, jint, (const jint&)ret);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4290
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4291
  if (!vm_created) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4292
    *penv = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4293
    ret = JNI_EDETACHED;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4294
    return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4295
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4296
11480
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents: 11247
diff changeset
  4297
  if (JniExportedInterface::GetExportedInterface(vm, penv, version, &ret)) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4298
    return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4299
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4300
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4301
#ifndef JVMPI_VERSION_1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4302
// need these in order to be polite about older agents
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4303
#define JVMPI_VERSION_1   ((jint)0x10000001)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4304
#define JVMPI_VERSION_1_1 ((jint)0x10000002)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4305
#define JVMPI_VERSION_1_2 ((jint)0x10000003)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4306
#endif // !JVMPI_VERSION_1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4307
34633
2a6c7c7b30a7 8132510: Replace ThreadLocalStorage with compiler/language-based thread-local variables
dholmes
parents: 34317
diff changeset
  4308
  Thread* thread = Thread::current_or_null();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4309
  if (thread != NULL && thread->is_Java_thread()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4310
    if (Threads::is_supported_jni_version_including_1_1(version)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4311
      *(JNIEnv**)penv = ((JavaThread*) thread)->jni_environment();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4312
      ret = JNI_OK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4313
      return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4314
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4315
    } else if (version == JVMPI_VERSION_1 ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4316
               version == JVMPI_VERSION_1_1 ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4317
               version == JVMPI_VERSION_1_2) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4318
      tty->print_cr("ERROR: JVMPI, an experimental interface, is no longer supported.");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4319
      tty->print_cr("Please use the supported interface: the JVM Tool Interface (JVM TI).");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4320
      ret = JNI_EVERSION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4321
      return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4322
    } else if (JvmtiExport::is_jvmdi_version(version)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4323
      tty->print_cr("FATAL ERROR: JVMDI is no longer supported.");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4324
      tty->print_cr("Please use the supported interface: the JVM Tool Interface (JVM TI).");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4325
      ret = JNI_EVERSION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4326
      return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4327
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4328
      *penv = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4329
      ret = JNI_EVERSION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4330
      return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4331
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4332
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4333
    *penv = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4334
    ret = JNI_EDETACHED;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4335
    return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4336
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4337
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4338
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4339
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4340
jint JNICALL jni_AttachCurrentThreadAsDaemon(JavaVM *vm, void **penv, void *_args) {
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  4341
  HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_ENTRY(vm, penv, _args);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4342
  if (!vm_created) {
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  4343
  HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_RETURN((uint32_t) JNI_ERR);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4344
    return JNI_ERR;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4345
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4346
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4347
  JNIWrapper("AttachCurrentThreadAsDaemon");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4348
  jint ret = attach_current_thread(vm, penv, _args, true);
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  4349
  HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4350
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4351
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4352
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4353
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4354
} // End extern "C"
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4355
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4356
const struct JNIInvokeInterface_ jni_InvokeInterface = {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4357
    NULL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4358
    NULL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4359
    NULL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4360
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4361
    jni_DestroyJavaVM,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4362
    jni_AttachCurrentThread,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4363
    jni_DetachCurrentThread,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4364
    jni_GetEnv,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4365
    jni_AttachCurrentThreadAsDaemon
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4366
};