annotate src/share/vm/prims/jni.cpp @ 3801:8a4fc2990229

7053189: remove some unnecessary platform-dependent includes Reviewed-by: dholmes, never, jwilhelm, kvn
author jcoomes
date Thu, 07 Jul 2011 15:44:34 -0700
parents 04760e41b01e
children e6b1331a51d2
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1 /*
2376
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 2177
diff changeset
2 * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load
duke
parents:
diff changeset
4 *
a61af66fc99e Initial load
duke
parents:
diff changeset
5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load
duke
parents:
diff changeset
6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load
duke
parents:
diff changeset
7 * published by the Free Software Foundation.
a61af66fc99e Initial load
duke
parents:
diff changeset
8 *
a61af66fc99e Initial load
duke
parents:
diff changeset
9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load
duke
parents:
diff changeset
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load
duke
parents:
diff changeset
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load
duke
parents:
diff changeset
12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load
duke
parents:
diff changeset
13 * accompanied this code).
a61af66fc99e Initial load
duke
parents:
diff changeset
14 *
a61af66fc99e Initial load
duke
parents:
diff changeset
15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load
duke
parents:
diff changeset
16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load
duke
parents:
diff changeset
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load
duke
parents:
diff changeset
18 *
1552
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1490
diff changeset
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1490
diff changeset
20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1490
diff changeset
21 * questions.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
22 *
a61af66fc99e Initial load
duke
parents:
diff changeset
23 */
a61af66fc99e Initial load
duke
parents:
diff changeset
24
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
26 #include "classfile/classLoader.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
27 #include "classfile/javaClasses.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
28 #include "classfile/symbolTable.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
29 #include "classfile/systemDictionary.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
30 #include "classfile/vmSymbols.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
31 #include "interpreter/linkResolver.hpp"
3249
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2376
diff changeset
32 #ifndef SERIALGC
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2376
diff changeset
33 #include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp"
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2376
diff changeset
34 #endif // SERIALGC
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
35 #include "memory/allocation.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
36 #include "memory/gcLocker.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
37 #include "memory/oopFactory.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
38 #include "memory/universe.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
39 #include "oops/instanceKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
40 #include "oops/instanceOop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
41 #include "oops/markOop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
42 #include "oops/methodOop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
43 #include "oops/objArrayKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
44 #include "oops/objArrayOop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
45 #include "oops/oop.inline.hpp"
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
46 #include "oops/symbol.hpp"
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
47 #include "oops/typeArrayKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
48 #include "oops/typeArrayOop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
49 #include "prims/jni.h"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
50 #include "prims/jniCheck.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
51 #include "prims/jniFastGetField.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
52 #include "prims/jvm.h"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
53 #include "prims/jvm_misc.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
54 #include "prims/jvmtiExport.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
55 #include "prims/jvmtiThreadState.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
56 #include "runtime/compilationPolicy.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
57 #include "runtime/fieldDescriptor.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
58 #include "runtime/fprofiler.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
59 #include "runtime/handles.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
60 #include "runtime/interfaceSupport.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
61 #include "runtime/java.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
62 #include "runtime/javaCalls.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
63 #include "runtime/jfieldIDWorkaround.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
64 #include "runtime/reflection.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
65 #include "runtime/sharedRuntime.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
66 #include "runtime/signature.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
67 #include "runtime/vm_operations.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
68 #include "services/runtimeService.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
69 #include "utilities/defaultStream.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
70 #include "utilities/dtrace.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
71 #include "utilities/events.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
72 #include "utilities/histogram.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
73 #ifdef TARGET_OS_FAMILY_linux
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
74 # include "os_linux.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
75 # include "thread_linux.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
76 #endif
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
77 #ifdef TARGET_OS_FAMILY_solaris
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
78 # include "os_solaris.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
79 # include "thread_solaris.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
80 #endif
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
81 #ifdef TARGET_OS_FAMILY_windows
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
82 # include "os_windows.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
83 # include "thread_windows.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1681
diff changeset
84 #endif
0
a61af66fc99e Initial load
duke
parents:
diff changeset
85
a61af66fc99e Initial load
duke
parents:
diff changeset
86 static jint CurrentVersion = JNI_VERSION_1_6;
a61af66fc99e Initial load
duke
parents:
diff changeset
87
a61af66fc99e Initial load
duke
parents:
diff changeset
88
a61af66fc99e Initial load
duke
parents:
diff changeset
89 // The DT_RETURN_MARK macros create a scoped object to fire the dtrace
a61af66fc99e Initial load
duke
parents:
diff changeset
90 // '-return' probe regardless of the return path is taken out of the function.
a61af66fc99e Initial load
duke
parents:
diff changeset
91 // Methods that have multiple return paths use this to avoid having to
a61af66fc99e Initial load
duke
parents:
diff changeset
92 // instrument each return path. Methods that use CHECK or THROW must use this
a61af66fc99e Initial load
duke
parents:
diff changeset
93 // since those macros can cause an immedate uninstrumented return.
a61af66fc99e Initial load
duke
parents:
diff changeset
94 //
a61af66fc99e Initial load
duke
parents:
diff changeset
95 // In order to get the return value, a reference to the variable containing
a61af66fc99e Initial load
duke
parents:
diff changeset
96 // the return value must be passed to the contructor of the object, and
a61af66fc99e Initial load
duke
parents:
diff changeset
97 // the return value must be set before return (since the mark object has
a61af66fc99e Initial load
duke
parents:
diff changeset
98 // a reference to it).
a61af66fc99e Initial load
duke
parents:
diff changeset
99 //
a61af66fc99e Initial load
duke
parents:
diff changeset
100 // Example:
a61af66fc99e Initial load
duke
parents:
diff changeset
101 // DT_RETURN_MARK_DECL(SomeFunc, int);
a61af66fc99e Initial load
duke
parents:
diff changeset
102 // JNI_ENTRY(int, SomeFunc, ...)
a61af66fc99e Initial load
duke
parents:
diff changeset
103 // int return_value = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
104 // DT_RETURN_MARK(SomeFunc, int, (const int&)return_value);
a61af66fc99e Initial load
duke
parents:
diff changeset
105 // foo(CHECK_0)
a61af66fc99e Initial load
duke
parents:
diff changeset
106 // return_value = 5;
a61af66fc99e Initial load
duke
parents:
diff changeset
107 // return return_value;
a61af66fc99e Initial load
duke
parents:
diff changeset
108 // JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
109 #define DT_RETURN_MARK_DECL(name, type) \
a61af66fc99e Initial load
duke
parents:
diff changeset
110 HS_DTRACE_PROBE_DECL1(hotspot_jni, name##__return, type); \
a61af66fc99e Initial load
duke
parents:
diff changeset
111 DTRACE_ONLY( \
a61af66fc99e Initial load
duke
parents:
diff changeset
112 class DTraceReturnProbeMark_##name { \
a61af66fc99e Initial load
duke
parents:
diff changeset
113 public: \
a61af66fc99e Initial load
duke
parents:
diff changeset
114 const type& _ret_ref; \
a61af66fc99e Initial load
duke
parents:
diff changeset
115 DTraceReturnProbeMark_##name(const type& v) : _ret_ref(v) {} \
a61af66fc99e Initial load
duke
parents:
diff changeset
116 ~DTraceReturnProbeMark_##name() { \
a61af66fc99e Initial load
duke
parents:
diff changeset
117 HS_DTRACE_PROBE1(hotspot_jni, name##__return, _ret_ref); \
a61af66fc99e Initial load
duke
parents:
diff changeset
118 } \
a61af66fc99e Initial load
duke
parents:
diff changeset
119 } \
a61af66fc99e Initial load
duke
parents:
diff changeset
120 )
a61af66fc99e Initial load
duke
parents:
diff changeset
121 // Void functions are simpler since there's no return value
a61af66fc99e Initial load
duke
parents:
diff changeset
122 #define DT_VOID_RETURN_MARK_DECL(name) \
a61af66fc99e Initial load
duke
parents:
diff changeset
123 HS_DTRACE_PROBE_DECL0(hotspot_jni, name##__return); \
a61af66fc99e Initial load
duke
parents:
diff changeset
124 DTRACE_ONLY( \
a61af66fc99e Initial load
duke
parents:
diff changeset
125 class DTraceReturnProbeMark_##name { \
a61af66fc99e Initial load
duke
parents:
diff changeset
126 public: \
a61af66fc99e Initial load
duke
parents:
diff changeset
127 ~DTraceReturnProbeMark_##name() { \
a61af66fc99e Initial load
duke
parents:
diff changeset
128 HS_DTRACE_PROBE0(hotspot_jni, name##__return); \
a61af66fc99e Initial load
duke
parents:
diff changeset
129 } \
a61af66fc99e Initial load
duke
parents:
diff changeset
130 } \
a61af66fc99e Initial load
duke
parents:
diff changeset
131 )
a61af66fc99e Initial load
duke
parents:
diff changeset
132
a61af66fc99e Initial load
duke
parents:
diff changeset
133
a61af66fc99e Initial load
duke
parents:
diff changeset
134 // Place these macros in the function to mark the return. Non-void
a61af66fc99e Initial load
duke
parents:
diff changeset
135 // functions need the type and address of the return value.
a61af66fc99e Initial load
duke
parents:
diff changeset
136 #define DT_RETURN_MARK(name, type, ref) \
a61af66fc99e Initial load
duke
parents:
diff changeset
137 DTRACE_ONLY( DTraceReturnProbeMark_##name dtrace_return_mark(ref) )
a61af66fc99e Initial load
duke
parents:
diff changeset
138 #define DT_VOID_RETURN_MARK(name) \
a61af66fc99e Initial load
duke
parents:
diff changeset
139 DTRACE_ONLY( DTraceReturnProbeMark_##name dtrace_return_mark )
a61af66fc99e Initial load
duke
parents:
diff changeset
140
a61af66fc99e Initial load
duke
parents:
diff changeset
141
a61af66fc99e Initial load
duke
parents:
diff changeset
142 // Use these to select distinct code for floating-point vs. non-floating point
a61af66fc99e Initial load
duke
parents:
diff changeset
143 // situations. Used from within common macros where we need slightly
a61af66fc99e Initial load
duke
parents:
diff changeset
144 // different behavior for Float/Double
a61af66fc99e Initial load
duke
parents:
diff changeset
145 #define FP_SELECT_Boolean(intcode, fpcode) intcode
a61af66fc99e Initial load
duke
parents:
diff changeset
146 #define FP_SELECT_Byte(intcode, fpcode) intcode
a61af66fc99e Initial load
duke
parents:
diff changeset
147 #define FP_SELECT_Char(intcode, fpcode) intcode
a61af66fc99e Initial load
duke
parents:
diff changeset
148 #define FP_SELECT_Short(intcode, fpcode) intcode
a61af66fc99e Initial load
duke
parents:
diff changeset
149 #define FP_SELECT_Object(intcode, fpcode) intcode
a61af66fc99e Initial load
duke
parents:
diff changeset
150 #define FP_SELECT_Int(intcode, fpcode) intcode
a61af66fc99e Initial load
duke
parents:
diff changeset
151 #define FP_SELECT_Long(intcode, fpcode) intcode
a61af66fc99e Initial load
duke
parents:
diff changeset
152 #define FP_SELECT_Float(intcode, fpcode) fpcode
a61af66fc99e Initial load
duke
parents:
diff changeset
153 #define FP_SELECT_Double(intcode, fpcode) fpcode
a61af66fc99e Initial load
duke
parents:
diff changeset
154 #define FP_SELECT(TypeName, intcode, fpcode) \
a61af66fc99e Initial load
duke
parents:
diff changeset
155 FP_SELECT_##TypeName(intcode, fpcode)
a61af66fc99e Initial load
duke
parents:
diff changeset
156
a61af66fc99e Initial load
duke
parents:
diff changeset
157 #define COMMA ,
a61af66fc99e Initial load
duke
parents:
diff changeset
158
a61af66fc99e Initial load
duke
parents:
diff changeset
159 // Choose DT_RETURN_MARK macros based on the type: float/double -> void
a61af66fc99e Initial load
duke
parents:
diff changeset
160 // (dtrace doesn't do FP yet)
a61af66fc99e Initial load
duke
parents:
diff changeset
161 #define DT_RETURN_MARK_DECL_FOR(TypeName, name, type) \
a61af66fc99e Initial load
duke
parents:
diff changeset
162 FP_SELECT(TypeName, \
a61af66fc99e Initial load
duke
parents:
diff changeset
163 DT_RETURN_MARK_DECL(name, type), DT_VOID_RETURN_MARK_DECL(name) )
a61af66fc99e Initial load
duke
parents:
diff changeset
164 #define DT_RETURN_MARK_FOR(TypeName, name, type, ref) \
a61af66fc99e Initial load
duke
parents:
diff changeset
165 FP_SELECT(TypeName, \
a61af66fc99e Initial load
duke
parents:
diff changeset
166 DT_RETURN_MARK(name, type, ref), DT_VOID_RETURN_MARK(name) )
a61af66fc99e Initial load
duke
parents:
diff changeset
167
a61af66fc99e Initial load
duke
parents:
diff changeset
168
a61af66fc99e Initial load
duke
parents:
diff changeset
169 // out-of-line helpers for class jfieldIDWorkaround:
a61af66fc99e Initial load
duke
parents:
diff changeset
170
a61af66fc99e Initial load
duke
parents:
diff changeset
171 bool jfieldIDWorkaround::is_valid_jfieldID(klassOop k, jfieldID id) {
a61af66fc99e Initial load
duke
parents:
diff changeset
172 if (jfieldIDWorkaround::is_instance_jfieldID(k, id)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
173 uintptr_t as_uint = (uintptr_t) id;
a61af66fc99e Initial load
duke
parents:
diff changeset
174 intptr_t offset = raw_instance_offset(id);
a61af66fc99e Initial load
duke
parents:
diff changeset
175 if (is_checked_jfieldID(id)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
176 if (!klass_hash_ok(k, id)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
177 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
178 }
a61af66fc99e Initial load
duke
parents:
diff changeset
179 }
a61af66fc99e Initial load
duke
parents:
diff changeset
180 return instanceKlass::cast(k)->contains_field_offset(offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
181 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
182 JNIid* result = (JNIid*) id;
a61af66fc99e Initial load
duke
parents:
diff changeset
183 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
184 return result != NULL && result->is_static_field_id();
a61af66fc99e Initial load
duke
parents:
diff changeset
185 #else
a61af66fc99e Initial load
duke
parents:
diff changeset
186 return result != NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
187 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
188 }
a61af66fc99e Initial load
duke
parents:
diff changeset
189 }
a61af66fc99e Initial load
duke
parents:
diff changeset
190
a61af66fc99e Initial load
duke
parents:
diff changeset
191
a61af66fc99e Initial load
duke
parents:
diff changeset
192 intptr_t jfieldIDWorkaround::encode_klass_hash(klassOop k, intptr_t offset) {
a61af66fc99e Initial load
duke
parents:
diff changeset
193 if (offset <= small_offset_mask) {
a61af66fc99e Initial load
duke
parents:
diff changeset
194 klassOop field_klass = k;
a61af66fc99e Initial load
duke
parents:
diff changeset
195 klassOop super_klass = Klass::cast(field_klass)->super();
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
196 // With compressed oops the most super class with nonstatic fields would
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
197 // be the owner of fields embedded in the header.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
198 while (instanceKlass::cast(super_klass)->has_nonstatic_fields() &&
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
199 instanceKlass::cast(super_klass)->contains_field_offset(offset)) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
200 field_klass = super_klass; // super contains the field also
a61af66fc99e Initial load
duke
parents:
diff changeset
201 super_klass = Klass::cast(field_klass)->super();
a61af66fc99e Initial load
duke
parents:
diff changeset
202 }
a61af66fc99e Initial load
duke
parents:
diff changeset
203 debug_only(No_Safepoint_Verifier nosafepoint;)
a61af66fc99e Initial load
duke
parents:
diff changeset
204 uintptr_t klass_hash = field_klass->identity_hash();
a61af66fc99e Initial load
duke
parents:
diff changeset
205 return ((klass_hash & klass_mask) << klass_shift) | checked_mask_in_place;
a61af66fc99e Initial load
duke
parents:
diff changeset
206 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
207 #if 0
a61af66fc99e Initial load
duke
parents:
diff changeset
208 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
209 {
a61af66fc99e Initial load
duke
parents:
diff changeset
210 ResourceMark rm;
a61af66fc99e Initial load
duke
parents:
diff changeset
211 warning("VerifyJNIFields: long offset %d in %s", offset, Klass::cast(k)->external_name());
a61af66fc99e Initial load
duke
parents:
diff changeset
212 }
a61af66fc99e Initial load
duke
parents:
diff changeset
213 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
214 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
215 return 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
216 }
a61af66fc99e Initial load
duke
parents:
diff changeset
217 }
a61af66fc99e Initial load
duke
parents:
diff changeset
218
a61af66fc99e Initial load
duke
parents:
diff changeset
219 bool jfieldIDWorkaround::klass_hash_ok(klassOop k, jfieldID id) {
a61af66fc99e Initial load
duke
parents:
diff changeset
220 uintptr_t as_uint = (uintptr_t) id;
a61af66fc99e Initial load
duke
parents:
diff changeset
221 intptr_t klass_hash = (as_uint >> klass_shift) & klass_mask;
a61af66fc99e Initial load
duke
parents:
diff changeset
222 do {
a61af66fc99e Initial load
duke
parents:
diff changeset
223 debug_only(No_Safepoint_Verifier nosafepoint;)
a61af66fc99e Initial load
duke
parents:
diff changeset
224 // Could use a non-blocking query for identity_hash here...
a61af66fc99e Initial load
duke
parents:
diff changeset
225 if ((k->identity_hash() & klass_mask) == klass_hash)
a61af66fc99e Initial load
duke
parents:
diff changeset
226 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
227 k = Klass::cast(k)->super();
a61af66fc99e Initial load
duke
parents:
diff changeset
228 } while (k != NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
229 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
230 }
a61af66fc99e Initial load
duke
parents:
diff changeset
231
a61af66fc99e Initial load
duke
parents:
diff changeset
232 void jfieldIDWorkaround::verify_instance_jfieldID(klassOop k, jfieldID id) {
a61af66fc99e Initial load
duke
parents:
diff changeset
233 guarantee(jfieldIDWorkaround::is_instance_jfieldID(k, id), "must be an instance field" );
a61af66fc99e Initial load
duke
parents:
diff changeset
234 uintptr_t as_uint = (uintptr_t) id;
a61af66fc99e Initial load
duke
parents:
diff changeset
235 intptr_t offset = raw_instance_offset(id);
a61af66fc99e Initial load
duke
parents:
diff changeset
236 if (VerifyJNIFields) {
a61af66fc99e Initial load
duke
parents:
diff changeset
237 if (is_checked_jfieldID(id)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
238 guarantee(klass_hash_ok(k, id),
a61af66fc99e Initial load
duke
parents:
diff changeset
239 "Bug in native code: jfieldID class must match object");
a61af66fc99e Initial load
duke
parents:
diff changeset
240 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
241 #if 0
a61af66fc99e Initial load
duke
parents:
diff changeset
242 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
243 if (Verbose) {
a61af66fc99e Initial load
duke
parents:
diff changeset
244 ResourceMark rm;
a61af66fc99e Initial load
duke
parents:
diff changeset
245 warning("VerifyJNIFields: unverified offset %d for %s", offset, Klass::cast(k)->external_name());
a61af66fc99e Initial load
duke
parents:
diff changeset
246 }
a61af66fc99e Initial load
duke
parents:
diff changeset
247 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
248 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
249 }
a61af66fc99e Initial load
duke
parents:
diff changeset
250 }
a61af66fc99e Initial load
duke
parents:
diff changeset
251 guarantee(instanceKlass::cast(k)->contains_field_offset(offset),
a61af66fc99e Initial load
duke
parents:
diff changeset
252 "Bug in native code: jfieldID offset must address interior of object");
a61af66fc99e Initial load
duke
parents:
diff changeset
253 }
a61af66fc99e Initial load
duke
parents:
diff changeset
254
a61af66fc99e Initial load
duke
parents:
diff changeset
255 // Pick a reasonable higher bound for local capacity requested
a61af66fc99e Initial load
duke
parents:
diff changeset
256 // for EnsureLocalCapacity and PushLocalFrame. We don't want it too
a61af66fc99e Initial load
duke
parents:
diff changeset
257 // high because a test (or very unusual application) may try to allocate
a61af66fc99e Initial load
duke
parents:
diff changeset
258 // that many handles and run out of swap space. An implementation is
a61af66fc99e Initial load
duke
parents:
diff changeset
259 // permitted to allocate more handles than the ensured capacity, so this
a61af66fc99e Initial load
duke
parents:
diff changeset
260 // value is set high enough to prevent compatibility problems.
a61af66fc99e Initial load
duke
parents:
diff changeset
261 const int MAX_REASONABLE_LOCAL_CAPACITY = 4*K;
a61af66fc99e Initial load
duke
parents:
diff changeset
262
a61af66fc99e Initial load
duke
parents:
diff changeset
263
a61af66fc99e Initial load
duke
parents:
diff changeset
264 // Wrapper to trace JNI functions
a61af66fc99e Initial load
duke
parents:
diff changeset
265
a61af66fc99e Initial load
duke
parents:
diff changeset
266 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
267 Histogram* JNIHistogram;
a61af66fc99e Initial load
duke
parents:
diff changeset
268 static volatile jint JNIHistogram_lock = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
269
a61af66fc99e Initial load
duke
parents:
diff changeset
270 class JNITraceWrapper : public StackObj {
a61af66fc99e Initial load
duke
parents:
diff changeset
271 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
272 JNITraceWrapper(const char* format, ...) {
a61af66fc99e Initial load
duke
parents:
diff changeset
273 if (TraceJNICalls) {
a61af66fc99e Initial load
duke
parents:
diff changeset
274 va_list ap;
a61af66fc99e Initial load
duke
parents:
diff changeset
275 va_start(ap, format);
a61af66fc99e Initial load
duke
parents:
diff changeset
276 tty->print("JNI ");
a61af66fc99e Initial load
duke
parents:
diff changeset
277 tty->vprint_cr(format, ap);
a61af66fc99e Initial load
duke
parents:
diff changeset
278 va_end(ap);
a61af66fc99e Initial load
duke
parents:
diff changeset
279 }
a61af66fc99e Initial load
duke
parents:
diff changeset
280 }
a61af66fc99e Initial load
duke
parents:
diff changeset
281 };
a61af66fc99e Initial load
duke
parents:
diff changeset
282
a61af66fc99e Initial load
duke
parents:
diff changeset
283 class JNIHistogramElement : public HistogramElement {
a61af66fc99e Initial load
duke
parents:
diff changeset
284 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
285 JNIHistogramElement(const char* name);
a61af66fc99e Initial load
duke
parents:
diff changeset
286 };
a61af66fc99e Initial load
duke
parents:
diff changeset
287
a61af66fc99e Initial load
duke
parents:
diff changeset
288 JNIHistogramElement::JNIHistogramElement(const char* elementName) {
a61af66fc99e Initial load
duke
parents:
diff changeset
289 _name = elementName;
a61af66fc99e Initial load
duke
parents:
diff changeset
290 uintx count = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
291
a61af66fc99e Initial load
duke
parents:
diff changeset
292 while (Atomic::cmpxchg(1, &JNIHistogram_lock, 0) != 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
293 while (OrderAccess::load_acquire(&JNIHistogram_lock) != 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
294 count +=1;
a61af66fc99e Initial load
duke
parents:
diff changeset
295 if ( (WarnOnStalledSpinLock > 0)
a61af66fc99e Initial load
duke
parents:
diff changeset
296 && (count % WarnOnStalledSpinLock == 0)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
297 warning("JNIHistogram_lock seems to be stalled");
a61af66fc99e Initial load
duke
parents:
diff changeset
298 }
a61af66fc99e Initial load
duke
parents:
diff changeset
299 }
a61af66fc99e Initial load
duke
parents:
diff changeset
300 }
a61af66fc99e Initial load
duke
parents:
diff changeset
301
a61af66fc99e Initial load
duke
parents:
diff changeset
302
a61af66fc99e Initial load
duke
parents:
diff changeset
303 if(JNIHistogram == NULL)
a61af66fc99e Initial load
duke
parents:
diff changeset
304 JNIHistogram = new Histogram("JNI Call Counts",100);
a61af66fc99e Initial load
duke
parents:
diff changeset
305
a61af66fc99e Initial load
duke
parents:
diff changeset
306 JNIHistogram->add_element(this);
a61af66fc99e Initial load
duke
parents:
diff changeset
307 Atomic::dec(&JNIHistogram_lock);
a61af66fc99e Initial load
duke
parents:
diff changeset
308 }
a61af66fc99e Initial load
duke
parents:
diff changeset
309
a61af66fc99e Initial load
duke
parents:
diff changeset
310 #define JNICountWrapper(arg) \
a61af66fc99e Initial load
duke
parents:
diff changeset
311 static JNIHistogramElement* e = new JNIHistogramElement(arg); \
a61af66fc99e Initial load
duke
parents:
diff changeset
312 /* There is a MT-race condition in VC++. So we need to make sure that that e has been initialized */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
313 if (e != NULL) e->increment_count()
a61af66fc99e Initial load
duke
parents:
diff changeset
314 #define JNIWrapper(arg) JNICountWrapper(arg); JNITraceWrapper(arg)
a61af66fc99e Initial load
duke
parents:
diff changeset
315 #else
a61af66fc99e Initial load
duke
parents:
diff changeset
316 #define JNIWrapper(arg)
a61af66fc99e Initial load
duke
parents:
diff changeset
317 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
318
a61af66fc99e Initial load
duke
parents:
diff changeset
319
a61af66fc99e Initial load
duke
parents:
diff changeset
320 // Implementation of JNI entries
a61af66fc99e Initial load
duke
parents:
diff changeset
321
a61af66fc99e Initial load
duke
parents:
diff changeset
322 DT_RETURN_MARK_DECL(DefineClass, jclass);
a61af66fc99e Initial load
duke
parents:
diff changeset
323
a61af66fc99e Initial load
duke
parents:
diff changeset
324 JNI_ENTRY(jclass, jni_DefineClass(JNIEnv *env, const char *name, jobject loaderRef,
a61af66fc99e Initial load
duke
parents:
diff changeset
325 const jbyte *buf, jsize bufLen))
a61af66fc99e Initial load
duke
parents:
diff changeset
326 JNIWrapper("DefineClass");
a61af66fc99e Initial load
duke
parents:
diff changeset
327
a61af66fc99e Initial load
duke
parents:
diff changeset
328 DTRACE_PROBE5(hotspot_jni, DefineClass__entry,
a61af66fc99e Initial load
duke
parents:
diff changeset
329 env, name, loaderRef, buf, bufLen);
a61af66fc99e Initial load
duke
parents:
diff changeset
330 jclass cls = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
331 DT_RETURN_MARK(DefineClass, jclass, (const jclass&)cls);
a61af66fc99e Initial load
duke
parents:
diff changeset
332
a61af66fc99e Initial load
duke
parents:
diff changeset
333 // Since exceptions can be thrown, class initialization can take place
a61af66fc99e Initial load
duke
parents:
diff changeset
334 // if name is NULL no check for class name in .class stream has to be made.
a61af66fc99e Initial load
duke
parents:
diff changeset
335 if (name != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
336 const int str_len = (int)strlen(name);
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
337 if (str_len > Symbol::max_length()) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
338 // It's impossible to create this class; the name cannot fit
a61af66fc99e Initial load
duke
parents:
diff changeset
339 // into the constant pool.
a61af66fc99e Initial load
duke
parents:
diff changeset
340 THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), name);
a61af66fc99e Initial load
duke
parents:
diff changeset
341 }
a61af66fc99e Initial load
duke
parents:
diff changeset
342 }
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
343 TempNewSymbol class_name = SymbolTable::new_symbol(name, THREAD);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
344
a61af66fc99e Initial load
duke
parents:
diff changeset
345 ResourceMark rm(THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
346 ClassFileStream st((u1*) buf, bufLen, NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
347 Handle class_loader (THREAD, JNIHandles::resolve(loaderRef));
a61af66fc99e Initial load
duke
parents:
diff changeset
348
a61af66fc99e Initial load
duke
parents:
diff changeset
349 if (UsePerfData && !class_loader.is_null()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
350 // check whether the current caller thread holds the lock or not.
a61af66fc99e Initial load
duke
parents:
diff changeset
351 // If not, increment the corresponding counter
a61af66fc99e Initial load
duke
parents:
diff changeset
352 if (ObjectSynchronizer::
a61af66fc99e Initial load
duke
parents:
diff changeset
353 query_lock_ownership((JavaThread*)THREAD, class_loader) !=
a61af66fc99e Initial load
duke
parents:
diff changeset
354 ObjectSynchronizer::owner_self) {
a61af66fc99e Initial load
duke
parents:
diff changeset
355 ClassLoader::sync_JNIDefineClassLockFreeCounter()->inc();
a61af66fc99e Initial load
duke
parents:
diff changeset
356 }
a61af66fc99e Initial load
duke
parents:
diff changeset
357 }
a61af66fc99e Initial load
duke
parents:
diff changeset
358 klassOop k = SystemDictionary::resolve_from_stream(class_name, class_loader,
973
ad6585fd4087 6830542: Performance: JVM_DefineClass already verified.
acorn
parents: 657
diff changeset
359 Handle(), &st, true,
ad6585fd4087 6830542: Performance: JVM_DefineClass already verified.
acorn
parents: 657
diff changeset
360 CHECK_NULL);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
361
657
715dceaa89b7 6603316: Improve instrumentation for classes loaded at startup
acorn
parents: 579
diff changeset
362 if (TraceClassResolution && k != NULL) {
715dceaa89b7 6603316: Improve instrumentation for classes loaded at startup
acorn
parents: 579
diff changeset
363 trace_class_resolution(k);
715dceaa89b7 6603316: Improve instrumentation for classes loaded at startup
acorn
parents: 579
diff changeset
364 }
715dceaa89b7 6603316: Improve instrumentation for classes loaded at startup
acorn
parents: 579
diff changeset
365
0
a61af66fc99e Initial load
duke
parents:
diff changeset
366 cls = (jclass)JNIHandles::make_local(
a61af66fc99e Initial load
duke
parents:
diff changeset
367 env, Klass::cast(k)->java_mirror());
a61af66fc99e Initial load
duke
parents:
diff changeset
368 return cls;
a61af66fc99e Initial load
duke
parents:
diff changeset
369 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
370
a61af66fc99e Initial load
duke
parents:
diff changeset
371
a61af66fc99e Initial load
duke
parents:
diff changeset
372
a61af66fc99e Initial load
duke
parents:
diff changeset
373 static bool first_time_FindClass = true;
a61af66fc99e Initial load
duke
parents:
diff changeset
374
a61af66fc99e Initial load
duke
parents:
diff changeset
375 DT_RETURN_MARK_DECL(FindClass, jclass);
a61af66fc99e Initial load
duke
parents:
diff changeset
376
a61af66fc99e Initial load
duke
parents:
diff changeset
377 JNI_ENTRY(jclass, jni_FindClass(JNIEnv *env, const char *name))
a61af66fc99e Initial load
duke
parents:
diff changeset
378 JNIWrapper("FindClass");
a61af66fc99e Initial load
duke
parents:
diff changeset
379 DTRACE_PROBE2(hotspot_jni, FindClass__entry, env, name);
a61af66fc99e Initial load
duke
parents:
diff changeset
380
a61af66fc99e Initial load
duke
parents:
diff changeset
381 jclass result = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
382 DT_RETURN_MARK(FindClass, jclass, (const jclass&)result);
a61af66fc99e Initial load
duke
parents:
diff changeset
383
a61af66fc99e Initial load
duke
parents:
diff changeset
384 // Remember if we are the first invocation of jni_FindClass
a61af66fc99e Initial load
duke
parents:
diff changeset
385 bool first_time = first_time_FindClass;
a61af66fc99e Initial load
duke
parents:
diff changeset
386 first_time_FindClass = false;
a61af66fc99e Initial load
duke
parents:
diff changeset
387
a61af66fc99e Initial load
duke
parents:
diff changeset
388 // Sanity check the name: it cannot be null or larger than the maximum size
a61af66fc99e Initial load
duke
parents:
diff changeset
389 // name we can fit in the constant pool.
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
390 if (name == NULL || (int)strlen(name) > Symbol::max_length()) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
391 THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), name);
a61af66fc99e Initial load
duke
parents:
diff changeset
392 }
a61af66fc99e Initial load
duke
parents:
diff changeset
393
a61af66fc99e Initial load
duke
parents:
diff changeset
394 //%note jni_3
a61af66fc99e Initial load
duke
parents:
diff changeset
395 Handle loader;
a61af66fc99e Initial load
duke
parents:
diff changeset
396 Handle protection_domain;
a61af66fc99e Initial load
duke
parents:
diff changeset
397 // Find calling class
a61af66fc99e Initial load
duke
parents:
diff changeset
398 instanceKlassHandle k (THREAD, thread->security_get_caller_class(0));
a61af66fc99e Initial load
duke
parents:
diff changeset
399 if (k.not_null()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
400 loader = Handle(THREAD, k->class_loader());
a61af66fc99e Initial load
duke
parents:
diff changeset
401 // Special handling to make sure JNI_OnLoad and JNI_OnUnload are executed
a61af66fc99e Initial load
duke
parents:
diff changeset
402 // in the correct class context.
a61af66fc99e Initial load
duke
parents:
diff changeset
403 if (loader.is_null() &&
a61af66fc99e Initial load
duke
parents:
diff changeset
404 k->name() == vmSymbols::java_lang_ClassLoader_NativeLibrary()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
405 JavaValue result(T_OBJECT);
a61af66fc99e Initial load
duke
parents:
diff changeset
406 JavaCalls::call_static(&result, k,
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
407 vmSymbols::getFromClass_name(),
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
408 vmSymbols::void_class_signature(),
0
a61af66fc99e Initial load
duke
parents:
diff changeset
409 thread);
a61af66fc99e Initial load
duke
parents:
diff changeset
410 if (HAS_PENDING_EXCEPTION) {
a61af66fc99e Initial load
duke
parents:
diff changeset
411 Handle ex(thread, thread->pending_exception());
a61af66fc99e Initial load
duke
parents:
diff changeset
412 CLEAR_PENDING_EXCEPTION;
a61af66fc99e Initial load
duke
parents:
diff changeset
413 THROW_HANDLE_0(ex);
a61af66fc99e Initial load
duke
parents:
diff changeset
414 }
a61af66fc99e Initial load
duke
parents:
diff changeset
415 oop mirror = (oop) result.get_jobject();
a61af66fc99e Initial load
duke
parents:
diff changeset
416 loader = Handle(THREAD,
a61af66fc99e Initial load
duke
parents:
diff changeset
417 instanceKlass::cast(java_lang_Class::as_klassOop(mirror))->class_loader());
a61af66fc99e Initial load
duke
parents:
diff changeset
418 protection_domain = Handle(THREAD,
a61af66fc99e Initial load
duke
parents:
diff changeset
419 instanceKlass::cast(java_lang_Class::as_klassOop(mirror))->protection_domain());
a61af66fc99e Initial load
duke
parents:
diff changeset
420 }
a61af66fc99e Initial load
duke
parents:
diff changeset
421 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
422 // We call ClassLoader.getSystemClassLoader to obtain the system class loader.
a61af66fc99e Initial load
duke
parents:
diff changeset
423 loader = Handle(THREAD, SystemDictionary::java_system_loader());
a61af66fc99e Initial load
duke
parents:
diff changeset
424 }
a61af66fc99e Initial load
duke
parents:
diff changeset
425
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
426 TempNewSymbol sym = SymbolTable::new_symbol(name, CHECK_NULL);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
427 result = find_class_from_class_loader(env, sym, true, loader,
a61af66fc99e Initial load
duke
parents:
diff changeset
428 protection_domain, true, thread);
a61af66fc99e Initial load
duke
parents:
diff changeset
429
657
715dceaa89b7 6603316: Improve instrumentation for classes loaded at startup
acorn
parents: 579
diff changeset
430 if (TraceClassResolution && result != NULL) {
715dceaa89b7 6603316: Improve instrumentation for classes loaded at startup
acorn
parents: 579
diff changeset
431 trace_class_resolution(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(result)));
715dceaa89b7 6603316: Improve instrumentation for classes loaded at startup
acorn
parents: 579
diff changeset
432 }
715dceaa89b7 6603316: Improve instrumentation for classes loaded at startup
acorn
parents: 579
diff changeset
433
0
a61af66fc99e Initial load
duke
parents:
diff changeset
434 // If we were the first invocation of jni_FindClass, we enable compilation again
a61af66fc99e Initial load
duke
parents:
diff changeset
435 // rather than just allowing invocation counter to overflow and decay.
a61af66fc99e Initial load
duke
parents:
diff changeset
436 // Controlled by flag DelayCompilationDuringStartup.
a61af66fc99e Initial load
duke
parents:
diff changeset
437 if (first_time && !CompileTheWorld)
a61af66fc99e Initial load
duke
parents:
diff changeset
438 CompilationPolicy::completed_vm_startup();
a61af66fc99e Initial load
duke
parents:
diff changeset
439
a61af66fc99e Initial load
duke
parents:
diff changeset
440 return result;
a61af66fc99e Initial load
duke
parents:
diff changeset
441 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
442
a61af66fc99e Initial load
duke
parents:
diff changeset
443 DT_RETURN_MARK_DECL(FromReflectedMethod, jmethodID);
a61af66fc99e Initial load
duke
parents:
diff changeset
444
a61af66fc99e Initial load
duke
parents:
diff changeset
445 JNI_ENTRY(jmethodID, jni_FromReflectedMethod(JNIEnv *env, jobject method))
a61af66fc99e Initial load
duke
parents:
diff changeset
446 JNIWrapper("FromReflectedMethod");
a61af66fc99e Initial load
duke
parents:
diff changeset
447 DTRACE_PROBE2(hotspot_jni, FromReflectedMethod__entry, env, method);
a61af66fc99e Initial load
duke
parents:
diff changeset
448 jmethodID ret = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
449 DT_RETURN_MARK(FromReflectedMethod, jmethodID, (const jmethodID&)ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
450
a61af66fc99e Initial load
duke
parents:
diff changeset
451 // method is a handle to a java.lang.reflect.Method object
a61af66fc99e Initial load
duke
parents:
diff changeset
452 oop reflected = JNIHandles::resolve_non_null(method);
a61af66fc99e Initial load
duke
parents:
diff changeset
453 oop mirror = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
454 int slot = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
455
1142
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1132
diff changeset
456 if (reflected->klass() == SystemDictionary::reflect_Constructor_klass()) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
457 mirror = java_lang_reflect_Constructor::clazz(reflected);
a61af66fc99e Initial load
duke
parents:
diff changeset
458 slot = java_lang_reflect_Constructor::slot(reflected);
a61af66fc99e Initial load
duke
parents:
diff changeset
459 } else {
1142
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1132
diff changeset
460 assert(reflected->klass() == SystemDictionary::reflect_Method_klass(), "wrong type");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
461 mirror = java_lang_reflect_Method::clazz(reflected);
a61af66fc99e Initial load
duke
parents:
diff changeset
462 slot = java_lang_reflect_Method::slot(reflected);
a61af66fc99e Initial load
duke
parents:
diff changeset
463 }
a61af66fc99e Initial load
duke
parents:
diff changeset
464 klassOop k = java_lang_Class::as_klassOop(mirror);
a61af66fc99e Initial load
duke
parents:
diff changeset
465
a61af66fc99e Initial load
duke
parents:
diff changeset
466 KlassHandle k1(THREAD, k);
a61af66fc99e Initial load
duke
parents:
diff changeset
467 // Make sure class is initialized before handing id's out to methods
a61af66fc99e Initial load
duke
parents:
diff changeset
468 Klass::cast(k1())->initialize(CHECK_NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
469 methodOop m = instanceKlass::cast(k1())->method_with_idnum(slot);
a61af66fc99e Initial load
duke
parents:
diff changeset
470 ret = m==NULL? NULL : m->jmethod_id(); // return NULL if reflected method deleted
a61af66fc99e Initial load
duke
parents:
diff changeset
471 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
472 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
473
a61af66fc99e Initial load
duke
parents:
diff changeset
474 DT_RETURN_MARK_DECL(FromReflectedField, jfieldID);
a61af66fc99e Initial load
duke
parents:
diff changeset
475
a61af66fc99e Initial load
duke
parents:
diff changeset
476 JNI_ENTRY(jfieldID, jni_FromReflectedField(JNIEnv *env, jobject field))
a61af66fc99e Initial load
duke
parents:
diff changeset
477 JNIWrapper("FromReflectedField");
a61af66fc99e Initial load
duke
parents:
diff changeset
478 DTRACE_PROBE2(hotspot_jni, FromReflectedField__entry, env, field);
a61af66fc99e Initial load
duke
parents:
diff changeset
479 jfieldID ret = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
480 DT_RETURN_MARK(FromReflectedField, jfieldID, (const jfieldID&)ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
481
a61af66fc99e Initial load
duke
parents:
diff changeset
482 // field is a handle to a java.lang.reflect.Field object
a61af66fc99e Initial load
duke
parents:
diff changeset
483 oop reflected = JNIHandles::resolve_non_null(field);
a61af66fc99e Initial load
duke
parents:
diff changeset
484 oop mirror = java_lang_reflect_Field::clazz(reflected);
a61af66fc99e Initial load
duke
parents:
diff changeset
485 klassOop k = java_lang_Class::as_klassOop(mirror);
a61af66fc99e Initial load
duke
parents:
diff changeset
486 int slot = java_lang_reflect_Field::slot(reflected);
a61af66fc99e Initial load
duke
parents:
diff changeset
487 int modifiers = java_lang_reflect_Field::modifiers(reflected);
a61af66fc99e Initial load
duke
parents:
diff changeset
488
a61af66fc99e Initial load
duke
parents:
diff changeset
489 KlassHandle k1(THREAD, k);
a61af66fc99e Initial load
duke
parents:
diff changeset
490 // Make sure class is initialized before handing id's out to fields
a61af66fc99e Initial load
duke
parents:
diff changeset
491 Klass::cast(k1())->initialize(CHECK_NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
492
a61af66fc99e Initial load
duke
parents:
diff changeset
493 // First check if this is a static field
a61af66fc99e Initial load
duke
parents:
diff changeset
494 if (modifiers & JVM_ACC_STATIC) {
a61af66fc99e Initial load
duke
parents:
diff changeset
495 intptr_t offset = instanceKlass::cast(k1())->offset_from_fields( slot );
a61af66fc99e Initial load
duke
parents:
diff changeset
496 JNIid* id = instanceKlass::cast(k1())->jni_id_for(offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
497 assert(id != NULL, "corrupt Field object");
a61af66fc99e Initial load
duke
parents:
diff changeset
498 debug_only(id->set_is_static_field_id();)
a61af66fc99e Initial load
duke
parents:
diff changeset
499 // A jfieldID for a static field is a JNIid specifying the field holder and the offset within the klassOop
a61af66fc99e Initial load
duke
parents:
diff changeset
500 ret = jfieldIDWorkaround::to_static_jfieldID(id);
a61af66fc99e Initial load
duke
parents:
diff changeset
501 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
502 }
a61af66fc99e Initial load
duke
parents:
diff changeset
503
a61af66fc99e Initial load
duke
parents:
diff changeset
504 // The slot is the index of the field description in the field-array
a61af66fc99e Initial load
duke
parents:
diff changeset
505 // The jfieldID is the offset of the field within the object
a61af66fc99e Initial load
duke
parents:
diff changeset
506 // It may also have hash bits for k, if VerifyJNIFields is turned on.
a61af66fc99e Initial load
duke
parents:
diff changeset
507 intptr_t offset = instanceKlass::cast(k1())->offset_from_fields( slot );
a61af66fc99e Initial load
duke
parents:
diff changeset
508 assert(instanceKlass::cast(k1())->contains_field_offset(offset), "stay within object");
a61af66fc99e Initial load
duke
parents:
diff changeset
509 ret = jfieldIDWorkaround::to_instance_jfieldID(k1(), offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
510 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
511 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
512
a61af66fc99e Initial load
duke
parents:
diff changeset
513 DT_RETURN_MARK_DECL(ToReflectedMethod, jobject);
a61af66fc99e Initial load
duke
parents:
diff changeset
514
a61af66fc99e Initial load
duke
parents:
diff changeset
515 JNI_ENTRY(jobject, jni_ToReflectedMethod(JNIEnv *env, jclass cls, jmethodID method_id, jboolean isStatic))
a61af66fc99e Initial load
duke
parents:
diff changeset
516 JNIWrapper("ToReflectedMethod");
a61af66fc99e Initial load
duke
parents:
diff changeset
517 DTRACE_PROBE4(hotspot_jni, ToReflectedMethod__entry, env, cls, method_id, isStatic);
a61af66fc99e Initial load
duke
parents:
diff changeset
518 jobject ret = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
519 DT_RETURN_MARK(ToReflectedMethod, jobject, (const jobject&)ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
520
a61af66fc99e Initial load
duke
parents:
diff changeset
521 methodHandle m (THREAD, JNIHandles::resolve_jmethod_id(method_id));
a61af66fc99e Initial load
duke
parents:
diff changeset
522 assert(m->is_static() == (isStatic != 0), "jni_ToReflectedMethod access flags doesn't match");
a61af66fc99e Initial load
duke
parents:
diff changeset
523 oop reflection_method;
a61af66fc99e Initial load
duke
parents:
diff changeset
524 if (m->is_initializer()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
525 reflection_method = Reflection::new_constructor(m, CHECK_NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
526 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
527 reflection_method = Reflection::new_method(m, UseNewReflection, false, CHECK_NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
528 }
a61af66fc99e Initial load
duke
parents:
diff changeset
529 ret = JNIHandles::make_local(env, reflection_method);
a61af66fc99e Initial load
duke
parents:
diff changeset
530 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
531 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
532
a61af66fc99e Initial load
duke
parents:
diff changeset
533 DT_RETURN_MARK_DECL(GetSuperclass, jclass);
a61af66fc99e Initial load
duke
parents:
diff changeset
534
a61af66fc99e Initial load
duke
parents:
diff changeset
535 JNI_ENTRY(jclass, jni_GetSuperclass(JNIEnv *env, jclass sub))
a61af66fc99e Initial load
duke
parents:
diff changeset
536 JNIWrapper("GetSuperclass");
a61af66fc99e Initial load
duke
parents:
diff changeset
537 DTRACE_PROBE2(hotspot_jni, GetSuperclass__entry, env, sub);
a61af66fc99e Initial load
duke
parents:
diff changeset
538 jclass obj = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
539 DT_RETURN_MARK(GetSuperclass, jclass, (const jclass&)obj);
a61af66fc99e Initial load
duke
parents:
diff changeset
540
a61af66fc99e Initial load
duke
parents:
diff changeset
541 oop mirror = JNIHandles::resolve_non_null(sub);
a61af66fc99e Initial load
duke
parents:
diff changeset
542 // primitive classes return NULL
a61af66fc99e Initial load
duke
parents:
diff changeset
543 if (java_lang_Class::is_primitive(mirror)) return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
544
a61af66fc99e Initial load
duke
parents:
diff changeset
545 // Rules of Class.getSuperClass as implemented by KLass::java_super:
a61af66fc99e Initial load
duke
parents:
diff changeset
546 // arrays return Object
a61af66fc99e Initial load
duke
parents:
diff changeset
547 // interfaces return NULL
a61af66fc99e Initial load
duke
parents:
diff changeset
548 // proper classes return Klass::super()
a61af66fc99e Initial load
duke
parents:
diff changeset
549 klassOop k = java_lang_Class::as_klassOop(mirror);
a61af66fc99e Initial load
duke
parents:
diff changeset
550 if (Klass::cast(k)->is_interface()) return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
551
a61af66fc99e Initial load
duke
parents:
diff changeset
552 // return mirror for superclass
a61af66fc99e Initial load
duke
parents:
diff changeset
553 klassOop super = Klass::cast(k)->java_super();
a61af66fc99e Initial load
duke
parents:
diff changeset
554 // super2 is the value computed by the compiler's getSuperClass intrinsic:
a61af66fc99e Initial load
duke
parents:
diff changeset
555 debug_only(klassOop super2 = ( Klass::cast(k)->oop_is_javaArray()
1142
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1132
diff changeset
556 ? SystemDictionary::Object_klass()
0
a61af66fc99e Initial load
duke
parents:
diff changeset
557 : Klass::cast(k)->super() ) );
a61af66fc99e Initial load
duke
parents:
diff changeset
558 assert(super == super2,
a61af66fc99e Initial load
duke
parents:
diff changeset
559 "java_super computation depends on interface, array, other super");
a61af66fc99e Initial load
duke
parents:
diff changeset
560 obj = (super == NULL) ? NULL : (jclass) JNIHandles::make_local(Klass::cast(super)->java_mirror());
a61af66fc99e Initial load
duke
parents:
diff changeset
561 return obj;
a61af66fc99e Initial load
duke
parents:
diff changeset
562 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
563
a61af66fc99e Initial load
duke
parents:
diff changeset
564 JNI_QUICK_ENTRY(jboolean, jni_IsAssignableFrom(JNIEnv *env, jclass sub, jclass super))
a61af66fc99e Initial load
duke
parents:
diff changeset
565 JNIWrapper("IsSubclassOf");
a61af66fc99e Initial load
duke
parents:
diff changeset
566 DTRACE_PROBE3(hotspot_jni, IsAssignableFrom__entry, env, sub, super);
a61af66fc99e Initial load
duke
parents:
diff changeset
567 oop sub_mirror = JNIHandles::resolve_non_null(sub);
a61af66fc99e Initial load
duke
parents:
diff changeset
568 oop super_mirror = JNIHandles::resolve_non_null(super);
a61af66fc99e Initial load
duke
parents:
diff changeset
569 if (java_lang_Class::is_primitive(sub_mirror) ||
a61af66fc99e Initial load
duke
parents:
diff changeset
570 java_lang_Class::is_primitive(super_mirror)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
571 jboolean ret = (sub_mirror == super_mirror);
a61af66fc99e Initial load
duke
parents:
diff changeset
572 DTRACE_PROBE1(hotspot_jni, IsAssignableFrom__return, ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
573 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
574 }
a61af66fc99e Initial load
duke
parents:
diff changeset
575 klassOop sub_klass = java_lang_Class::as_klassOop(sub_mirror);
a61af66fc99e Initial load
duke
parents:
diff changeset
576 klassOop super_klass = java_lang_Class::as_klassOop(super_mirror);
a61af66fc99e Initial load
duke
parents:
diff changeset
577 assert(sub_klass != NULL && super_klass != NULL, "invalid arguments to jni_IsAssignableFrom");
a61af66fc99e Initial load
duke
parents:
diff changeset
578 jboolean ret = Klass::cast(sub_klass)->is_subtype_of(super_klass) ?
a61af66fc99e Initial load
duke
parents:
diff changeset
579 JNI_TRUE : JNI_FALSE;
a61af66fc99e Initial load
duke
parents:
diff changeset
580 DTRACE_PROBE1(hotspot_jni, IsAssignableFrom__return, ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
581 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
582 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
583
a61af66fc99e Initial load
duke
parents:
diff changeset
584 DT_RETURN_MARK_DECL(Throw, jint);
a61af66fc99e Initial load
duke
parents:
diff changeset
585
a61af66fc99e Initial load
duke
parents:
diff changeset
586 JNI_ENTRY(jint, jni_Throw(JNIEnv *env, jthrowable obj))
a61af66fc99e Initial load
duke
parents:
diff changeset
587 JNIWrapper("Throw");
a61af66fc99e Initial load
duke
parents:
diff changeset
588 DTRACE_PROBE2(hotspot_jni, Throw__entry, env, obj);
a61af66fc99e Initial load
duke
parents:
diff changeset
589 jint ret = JNI_OK;
a61af66fc99e Initial load
duke
parents:
diff changeset
590 DT_RETURN_MARK(Throw, jint, (const jint&)ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
591
a61af66fc99e Initial load
duke
parents:
diff changeset
592 THROW_OOP_(JNIHandles::resolve(obj), JNI_OK);
a61af66fc99e Initial load
duke
parents:
diff changeset
593 ShouldNotReachHere();
a61af66fc99e Initial load
duke
parents:
diff changeset
594 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
595
a61af66fc99e Initial load
duke
parents:
diff changeset
596 DT_RETURN_MARK_DECL(ThrowNew, jint);
a61af66fc99e Initial load
duke
parents:
diff changeset
597
a61af66fc99e Initial load
duke
parents:
diff changeset
598 JNI_ENTRY(jint, jni_ThrowNew(JNIEnv *env, jclass clazz, const char *message))
a61af66fc99e Initial load
duke
parents:
diff changeset
599 JNIWrapper("ThrowNew");
a61af66fc99e Initial load
duke
parents:
diff changeset
600 DTRACE_PROBE3(hotspot_jni, ThrowNew__entry, env, clazz, message);
a61af66fc99e Initial load
duke
parents:
diff changeset
601 jint ret = JNI_OK;
a61af66fc99e Initial load
duke
parents:
diff changeset
602 DT_RETURN_MARK(ThrowNew, jint, (const jint&)ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
603
a61af66fc99e Initial load
duke
parents:
diff changeset
604 instanceKlass* k = instanceKlass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(clazz)));
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
605 Symbol* name = k->name();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
606 Handle class_loader (THREAD, k->class_loader());
a61af66fc99e Initial load
duke
parents:
diff changeset
607 Handle protection_domain (THREAD, k->protection_domain());
a61af66fc99e Initial load
duke
parents:
diff changeset
608 THROW_MSG_LOADER_(name, (char *)message, class_loader, protection_domain, JNI_OK);
a61af66fc99e Initial load
duke
parents:
diff changeset
609 ShouldNotReachHere();
a61af66fc99e Initial load
duke
parents:
diff changeset
610 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
611
a61af66fc99e Initial load
duke
parents:
diff changeset
612
a61af66fc99e Initial load
duke
parents:
diff changeset
613 // JNI functions only transform a pending async exception to a synchronous
a61af66fc99e Initial load
duke
parents:
diff changeset
614 // exception in ExceptionOccurred and ExceptionCheck calls, since
a61af66fc99e Initial load
duke
parents:
diff changeset
615 // delivering an async exception in other places won't change the native
a61af66fc99e Initial load
duke
parents:
diff changeset
616 // code's control flow and would be harmful when native code further calls
a61af66fc99e Initial load
duke
parents:
diff changeset
617 // JNI functions with a pending exception. Async exception is also checked
a61af66fc99e Initial load
duke
parents:
diff changeset
618 // during the call, so ExceptionOccurred/ExceptionCheck won't return
a61af66fc99e Initial load
duke
parents:
diff changeset
619 // false but deliver the async exception at the very end during
a61af66fc99e Initial load
duke
parents:
diff changeset
620 // state transition.
a61af66fc99e Initial load
duke
parents:
diff changeset
621
a61af66fc99e Initial load
duke
parents:
diff changeset
622 static void jni_check_async_exceptions(JavaThread *thread) {
a61af66fc99e Initial load
duke
parents:
diff changeset
623 assert(thread == Thread::current(), "must be itself");
a61af66fc99e Initial load
duke
parents:
diff changeset
624 thread->check_and_handle_async_exceptions();
a61af66fc99e Initial load
duke
parents:
diff changeset
625 }
a61af66fc99e Initial load
duke
parents:
diff changeset
626
a61af66fc99e Initial load
duke
parents:
diff changeset
627 JNI_ENTRY_NO_PRESERVE(jthrowable, jni_ExceptionOccurred(JNIEnv *env))
a61af66fc99e Initial load
duke
parents:
diff changeset
628 JNIWrapper("ExceptionOccurred");
a61af66fc99e Initial load
duke
parents:
diff changeset
629 DTRACE_PROBE1(hotspot_jni, ExceptionOccurred__entry, env);
a61af66fc99e Initial load
duke
parents:
diff changeset
630 jni_check_async_exceptions(thread);
a61af66fc99e Initial load
duke
parents:
diff changeset
631 oop exception = thread->pending_exception();
a61af66fc99e Initial load
duke
parents:
diff changeset
632 jthrowable ret = (jthrowable) JNIHandles::make_local(env, exception);
a61af66fc99e Initial load
duke
parents:
diff changeset
633 DTRACE_PROBE1(hotspot_jni, ExceptionOccurred__return, ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
634 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
635 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
636
a61af66fc99e Initial load
duke
parents:
diff changeset
637
a61af66fc99e Initial load
duke
parents:
diff changeset
638 JNI_ENTRY_NO_PRESERVE(void, jni_ExceptionDescribe(JNIEnv *env))
a61af66fc99e Initial load
duke
parents:
diff changeset
639 JNIWrapper("ExceptionDescribe");
a61af66fc99e Initial load
duke
parents:
diff changeset
640 DTRACE_PROBE1(hotspot_jni, ExceptionDescribe__entry, env);
a61af66fc99e Initial load
duke
parents:
diff changeset
641 if (thread->has_pending_exception()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
642 Handle ex(thread, thread->pending_exception());
a61af66fc99e Initial load
duke
parents:
diff changeset
643 thread->clear_pending_exception();
1142
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1132
diff changeset
644 if (ex->is_a(SystemDictionary::ThreadDeath_klass())) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
645 // Don't print anything if we are being killed.
a61af66fc99e Initial load
duke
parents:
diff changeset
646 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
647 jio_fprintf(defaultStream::error_stream(), "Exception ");
a61af66fc99e Initial load
duke
parents:
diff changeset
648 if (thread != NULL && thread->threadObj() != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
649 ResourceMark rm(THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
650 jio_fprintf(defaultStream::error_stream(),
a61af66fc99e Initial load
duke
parents:
diff changeset
651 "in thread \"%s\" ", thread->get_thread_name());
a61af66fc99e Initial load
duke
parents:
diff changeset
652 }
1142
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1132
diff changeset
653 if (ex->is_a(SystemDictionary::Throwable_klass())) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
654 JavaValue result(T_VOID);
a61af66fc99e Initial load
duke
parents:
diff changeset
655 JavaCalls::call_virtual(&result,
a61af66fc99e Initial load
duke
parents:
diff changeset
656 ex,
a61af66fc99e Initial load
duke
parents:
diff changeset
657 KlassHandle(THREAD,
1142
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1132
diff changeset
658 SystemDictionary::Throwable_klass()),
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
659 vmSymbols::printStackTrace_name(),
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
660 vmSymbols::void_method_signature(),
0
a61af66fc99e Initial load
duke
parents:
diff changeset
661 THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
662 // If an exception is thrown in the call it gets thrown away. Not much
a61af66fc99e Initial load
duke
parents:
diff changeset
663 // we can do with it. The native code that calls this, does not check
a61af66fc99e Initial load
duke
parents:
diff changeset
664 // for the exception - hence, it might still be in the thread when DestroyVM gets
a61af66fc99e Initial load
duke
parents:
diff changeset
665 // called, potentially causing a few asserts to trigger - since no pending exception
a61af66fc99e Initial load
duke
parents:
diff changeset
666 // is expected.
a61af66fc99e Initial load
duke
parents:
diff changeset
667 CLEAR_PENDING_EXCEPTION;
a61af66fc99e Initial load
duke
parents:
diff changeset
668 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
669 ResourceMark rm(THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
670 jio_fprintf(defaultStream::error_stream(),
a61af66fc99e Initial load
duke
parents:
diff changeset
671 ". Uncaught exception of type %s.",
a61af66fc99e Initial load
duke
parents:
diff changeset
672 Klass::cast(ex->klass())->external_name());
a61af66fc99e Initial load
duke
parents:
diff changeset
673 }
a61af66fc99e Initial load
duke
parents:
diff changeset
674 }
a61af66fc99e Initial load
duke
parents:
diff changeset
675 }
a61af66fc99e Initial load
duke
parents:
diff changeset
676 DTRACE_PROBE(hotspot_jni, ExceptionDescribe__return);
a61af66fc99e Initial load
duke
parents:
diff changeset
677 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
678
a61af66fc99e Initial load
duke
parents:
diff changeset
679
a61af66fc99e Initial load
duke
parents:
diff changeset
680 JNI_QUICK_ENTRY(void, jni_ExceptionClear(JNIEnv *env))
a61af66fc99e Initial load
duke
parents:
diff changeset
681 JNIWrapper("ExceptionClear");
a61af66fc99e Initial load
duke
parents:
diff changeset
682 DTRACE_PROBE1(hotspot_jni, ExceptionClear__entry, env);
a61af66fc99e Initial load
duke
parents:
diff changeset
683
a61af66fc99e Initial load
duke
parents:
diff changeset
684 // The jni code might be using this API to clear java thrown exception.
a61af66fc99e Initial load
duke
parents:
diff changeset
685 // So just mark jvmti thread exception state as exception caught.
a61af66fc99e Initial load
duke
parents:
diff changeset
686 JvmtiThreadState *state = JavaThread::current()->jvmti_thread_state();
a61af66fc99e Initial load
duke
parents:
diff changeset
687 if (state != NULL && state->is_exception_detected()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
688 state->set_exception_caught();
a61af66fc99e Initial load
duke
parents:
diff changeset
689 }
a61af66fc99e Initial load
duke
parents:
diff changeset
690 thread->clear_pending_exception();
a61af66fc99e Initial load
duke
parents:
diff changeset
691 DTRACE_PROBE(hotspot_jni, ExceptionClear__return);
a61af66fc99e Initial load
duke
parents:
diff changeset
692 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
693
a61af66fc99e Initial load
duke
parents:
diff changeset
694
a61af66fc99e Initial load
duke
parents:
diff changeset
695 JNI_ENTRY(void, jni_FatalError(JNIEnv *env, const char *msg))
a61af66fc99e Initial load
duke
parents:
diff changeset
696 JNIWrapper("FatalError");
a61af66fc99e Initial load
duke
parents:
diff changeset
697 DTRACE_PROBE2(hotspot_jni, FatalError__entry, env, msg);
a61af66fc99e Initial load
duke
parents:
diff changeset
698 tty->print_cr("FATAL ERROR in native method: %s", msg);
a61af66fc99e Initial load
duke
parents:
diff changeset
699 thread->print_stack();
227
8d852b81e775 6694099: Hotspot vm_exit_out_of_memory should dump core
poonam
parents: 113
diff changeset
700 os::abort(); // Dump core and abort
0
a61af66fc99e Initial load
duke
parents:
diff changeset
701 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
702
a61af66fc99e Initial load
duke
parents:
diff changeset
703
a61af66fc99e Initial load
duke
parents:
diff changeset
704 JNI_ENTRY(jint, jni_PushLocalFrame(JNIEnv *env, jint capacity))
a61af66fc99e Initial load
duke
parents:
diff changeset
705 JNIWrapper("PushLocalFrame");
a61af66fc99e Initial load
duke
parents:
diff changeset
706 DTRACE_PROBE2(hotspot_jni, PushLocalFrame__entry, env, capacity);
a61af66fc99e Initial load
duke
parents:
diff changeset
707 //%note jni_11
a61af66fc99e Initial load
duke
parents:
diff changeset
708 if (capacity < 0 && capacity > MAX_REASONABLE_LOCAL_CAPACITY) {
a61af66fc99e Initial load
duke
parents:
diff changeset
709 DTRACE_PROBE1(hotspot_jni, PushLocalFrame__return, JNI_ERR);
a61af66fc99e Initial load
duke
parents:
diff changeset
710 return JNI_ERR;
a61af66fc99e Initial load
duke
parents:
diff changeset
711 }
a61af66fc99e Initial load
duke
parents:
diff changeset
712 JNIHandleBlock* old_handles = thread->active_handles();
a61af66fc99e Initial load
duke
parents:
diff changeset
713 JNIHandleBlock* new_handles = JNIHandleBlock::allocate_block(thread);
a61af66fc99e Initial load
duke
parents:
diff changeset
714 assert(new_handles != NULL, "should not be NULL");
a61af66fc99e Initial load
duke
parents:
diff changeset
715 new_handles->set_pop_frame_link(old_handles);
a61af66fc99e Initial load
duke
parents:
diff changeset
716 thread->set_active_handles(new_handles);
a61af66fc99e Initial load
duke
parents:
diff changeset
717 jint ret = JNI_OK;
a61af66fc99e Initial load
duke
parents:
diff changeset
718 DTRACE_PROBE1(hotspot_jni, PushLocalFrame__return, ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
719 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
720 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
721
a61af66fc99e Initial load
duke
parents:
diff changeset
722
a61af66fc99e Initial load
duke
parents:
diff changeset
723 JNI_ENTRY(jobject, jni_PopLocalFrame(JNIEnv *env, jobject result))
a61af66fc99e Initial load
duke
parents:
diff changeset
724 JNIWrapper("PopLocalFrame");
a61af66fc99e Initial load
duke
parents:
diff changeset
725 DTRACE_PROBE2(hotspot_jni, PopLocalFrame__entry, env, result);
a61af66fc99e Initial load
duke
parents:
diff changeset
726 //%note jni_11
a61af66fc99e Initial load
duke
parents:
diff changeset
727 Handle result_handle(thread, JNIHandles::resolve(result));
a61af66fc99e Initial load
duke
parents:
diff changeset
728 JNIHandleBlock* old_handles = thread->active_handles();
a61af66fc99e Initial load
duke
parents:
diff changeset
729 JNIHandleBlock* new_handles = old_handles->pop_frame_link();
a61af66fc99e Initial load
duke
parents:
diff changeset
730 if (new_handles != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
731 // As a sanity check we only release the handle blocks if the pop_frame_link is not NULL.
a61af66fc99e Initial load
duke
parents:
diff changeset
732 // This way code will still work if PopLocalFrame is called without a corresponding
a61af66fc99e Initial load
duke
parents:
diff changeset
733 // PushLocalFrame call. Note that we set the pop_frame_link to NULL explicitly, otherwise
a61af66fc99e Initial load
duke
parents:
diff changeset
734 // the release_block call will release the blocks.
a61af66fc99e Initial load
duke
parents:
diff changeset
735 thread->set_active_handles(new_handles);
a61af66fc99e Initial load
duke
parents:
diff changeset
736 old_handles->set_pop_frame_link(NULL); // clear link we won't release new_handles below
a61af66fc99e Initial load
duke
parents:
diff changeset
737 JNIHandleBlock::release_block(old_handles, thread); // may block
a61af66fc99e Initial load
duke
parents:
diff changeset
738 result = JNIHandles::make_local(thread, result_handle());
a61af66fc99e Initial load
duke
parents:
diff changeset
739 }
a61af66fc99e Initial load
duke
parents:
diff changeset
740 DTRACE_PROBE1(hotspot_jni, PopLocalFrame__return, result);
a61af66fc99e Initial load
duke
parents:
diff changeset
741 return result;
a61af66fc99e Initial load
duke
parents:
diff changeset
742 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
743
a61af66fc99e Initial load
duke
parents:
diff changeset
744
a61af66fc99e Initial load
duke
parents:
diff changeset
745 JNI_ENTRY(jobject, jni_NewGlobalRef(JNIEnv *env, jobject ref))
a61af66fc99e Initial load
duke
parents:
diff changeset
746 JNIWrapper("NewGlobalRef");
a61af66fc99e Initial load
duke
parents:
diff changeset
747 DTRACE_PROBE2(hotspot_jni, NewGlobalRef__entry, env, ref);
a61af66fc99e Initial load
duke
parents:
diff changeset
748 Handle ref_handle(thread, JNIHandles::resolve(ref));
a61af66fc99e Initial load
duke
parents:
diff changeset
749 jobject ret = JNIHandles::make_global(ref_handle);
a61af66fc99e Initial load
duke
parents:
diff changeset
750 DTRACE_PROBE1(hotspot_jni, NewGlobalRef__return, ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
751 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
752 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
753
a61af66fc99e Initial load
duke
parents:
diff changeset
754 // Must be JNI_ENTRY (with HandleMark)
a61af66fc99e Initial load
duke
parents:
diff changeset
755 JNI_ENTRY_NO_PRESERVE(void, jni_DeleteGlobalRef(JNIEnv *env, jobject ref))
a61af66fc99e Initial load
duke
parents:
diff changeset
756 JNIWrapper("DeleteGlobalRef");
a61af66fc99e Initial load
duke
parents:
diff changeset
757 DTRACE_PROBE2(hotspot_jni, DeleteGlobalRef__entry, env, ref);
a61af66fc99e Initial load
duke
parents:
diff changeset
758 JNIHandles::destroy_global(ref);
a61af66fc99e Initial load
duke
parents:
diff changeset
759 DTRACE_PROBE(hotspot_jni, DeleteGlobalRef__return);
a61af66fc99e Initial load
duke
parents:
diff changeset
760 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
761
a61af66fc99e Initial load
duke
parents:
diff changeset
762 JNI_QUICK_ENTRY(void, jni_DeleteLocalRef(JNIEnv *env, jobject obj))
a61af66fc99e Initial load
duke
parents:
diff changeset
763 JNIWrapper("DeleteLocalRef");
a61af66fc99e Initial load
duke
parents:
diff changeset
764 DTRACE_PROBE2(hotspot_jni, DeleteLocalRef__entry, env, obj);
a61af66fc99e Initial load
duke
parents:
diff changeset
765 JNIHandles::destroy_local(obj);
a61af66fc99e Initial load
duke
parents:
diff changeset
766 DTRACE_PROBE(hotspot_jni, DeleteLocalRef__return);
a61af66fc99e Initial load
duke
parents:
diff changeset
767 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
768
a61af66fc99e Initial load
duke
parents:
diff changeset
769 JNI_QUICK_ENTRY(jboolean, jni_IsSameObject(JNIEnv *env, jobject r1, jobject r2))
a61af66fc99e Initial load
duke
parents:
diff changeset
770 JNIWrapper("IsSameObject");
a61af66fc99e Initial load
duke
parents:
diff changeset
771 DTRACE_PROBE3(hotspot_jni, IsSameObject__entry, env, r1, r2);
a61af66fc99e Initial load
duke
parents:
diff changeset
772 oop a = JNIHandles::resolve(r1);
a61af66fc99e Initial load
duke
parents:
diff changeset
773 oop b = JNIHandles::resolve(r2);
a61af66fc99e Initial load
duke
parents:
diff changeset
774 jboolean ret = (a == b) ? JNI_TRUE : JNI_FALSE;
a61af66fc99e Initial load
duke
parents:
diff changeset
775 DTRACE_PROBE1(hotspot_jni, IsSameObject__return, ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
776 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
777 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
778
a61af66fc99e Initial load
duke
parents:
diff changeset
779
a61af66fc99e Initial load
duke
parents:
diff changeset
780 JNI_ENTRY(jobject, jni_NewLocalRef(JNIEnv *env, jobject ref))
a61af66fc99e Initial load
duke
parents:
diff changeset
781 JNIWrapper("NewLocalRef");
a61af66fc99e Initial load
duke
parents:
diff changeset
782 DTRACE_PROBE2(hotspot_jni, NewLocalRef__entry, env, ref);
a61af66fc99e Initial load
duke
parents:
diff changeset
783 jobject ret = JNIHandles::make_local(env, JNIHandles::resolve(ref));
a61af66fc99e Initial load
duke
parents:
diff changeset
784 DTRACE_PROBE1(hotspot_jni, NewLocalRef__return, ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
785 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
786 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
787
a61af66fc99e Initial load
duke
parents:
diff changeset
788 JNI_LEAF(jint, jni_EnsureLocalCapacity(JNIEnv *env, jint capacity))
a61af66fc99e Initial load
duke
parents:
diff changeset
789 JNIWrapper("EnsureLocalCapacity");
a61af66fc99e Initial load
duke
parents:
diff changeset
790 DTRACE_PROBE2(hotspot_jni, EnsureLocalCapacity__entry, env, capacity);
a61af66fc99e Initial load
duke
parents:
diff changeset
791 jint ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
792 if (capacity >= 0 && capacity <= MAX_REASONABLE_LOCAL_CAPACITY) {
a61af66fc99e Initial load
duke
parents:
diff changeset
793 ret = JNI_OK;
a61af66fc99e Initial load
duke
parents:
diff changeset
794 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
795 ret = JNI_ERR;
a61af66fc99e Initial load
duke
parents:
diff changeset
796 }
a61af66fc99e Initial load
duke
parents:
diff changeset
797 DTRACE_PROBE1(hotspot_jni, EnsureLocalCapacity__return, ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
798 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
799 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
800
a61af66fc99e Initial load
duke
parents:
diff changeset
801 // Return the Handle Type
a61af66fc99e Initial load
duke
parents:
diff changeset
802 JNI_LEAF(jobjectRefType, jni_GetObjectRefType(JNIEnv *env, jobject obj))
a61af66fc99e Initial load
duke
parents:
diff changeset
803 JNIWrapper("GetObjectRefType");
a61af66fc99e Initial load
duke
parents:
diff changeset
804 DTRACE_PROBE2(hotspot_jni, GetObjectRefType__entry, env, obj);
a61af66fc99e Initial load
duke
parents:
diff changeset
805 jobjectRefType ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
806 if (JNIHandles::is_local_handle(thread, obj) ||
a61af66fc99e Initial load
duke
parents:
diff changeset
807 JNIHandles::is_frame_handle(thread, obj))
a61af66fc99e Initial load
duke
parents:
diff changeset
808 ret = JNILocalRefType;
a61af66fc99e Initial load
duke
parents:
diff changeset
809 else if (JNIHandles::is_global_handle(obj))
a61af66fc99e Initial load
duke
parents:
diff changeset
810 ret = JNIGlobalRefType;
a61af66fc99e Initial load
duke
parents:
diff changeset
811 else if (JNIHandles::is_weak_global_handle(obj))
a61af66fc99e Initial load
duke
parents:
diff changeset
812 ret = JNIWeakGlobalRefType;
a61af66fc99e Initial load
duke
parents:
diff changeset
813 else
a61af66fc99e Initial load
duke
parents:
diff changeset
814 ret = JNIInvalidRefType;
a61af66fc99e Initial load
duke
parents:
diff changeset
815 DTRACE_PROBE1(hotspot_jni, GetObjectRefType__return, ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
816 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
817 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
818
a61af66fc99e Initial load
duke
parents:
diff changeset
819
a61af66fc99e Initial load
duke
parents:
diff changeset
820 class JNI_ArgumentPusher : public SignatureIterator {
a61af66fc99e Initial load
duke
parents:
diff changeset
821 protected:
a61af66fc99e Initial load
duke
parents:
diff changeset
822 JavaCallArguments* _arguments;
a61af66fc99e Initial load
duke
parents:
diff changeset
823
a61af66fc99e Initial load
duke
parents:
diff changeset
824 virtual void get_bool () = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
825 virtual void get_char () = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
826 virtual void get_short () = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
827 virtual void get_byte () = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
828 virtual void get_int () = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
829 virtual void get_long () = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
830 virtual void get_float () = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
831 virtual void get_double () = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
832 virtual void get_object () = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
833
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
834 JNI_ArgumentPusher(Symbol* signature) : SignatureIterator(signature) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
835 this->_return_type = T_ILLEGAL;
a61af66fc99e Initial load
duke
parents:
diff changeset
836 _arguments = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
837 }
a61af66fc99e Initial load
duke
parents:
diff changeset
838
a61af66fc99e Initial load
duke
parents:
diff changeset
839 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
840 virtual void iterate( uint64_t fingerprint ) = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
841
a61af66fc99e Initial load
duke
parents:
diff changeset
842 void set_java_argument_object(JavaCallArguments *arguments) { _arguments = arguments; }
a61af66fc99e Initial load
duke
parents:
diff changeset
843
a61af66fc99e Initial load
duke
parents:
diff changeset
844 inline void do_bool() { if (!is_return_type()) get_bool(); }
a61af66fc99e Initial load
duke
parents:
diff changeset
845 inline void do_char() { if (!is_return_type()) get_char(); }
a61af66fc99e Initial load
duke
parents:
diff changeset
846 inline void do_short() { if (!is_return_type()) get_short(); }
a61af66fc99e Initial load
duke
parents:
diff changeset
847 inline void do_byte() { if (!is_return_type()) get_byte(); }
a61af66fc99e Initial load
duke
parents:
diff changeset
848 inline void do_int() { if (!is_return_type()) get_int(); }
a61af66fc99e Initial load
duke
parents:
diff changeset
849 inline void do_long() { if (!is_return_type()) get_long(); }
a61af66fc99e Initial load
duke
parents:
diff changeset
850 inline void do_float() { if (!is_return_type()) get_float(); }
a61af66fc99e Initial load
duke
parents:
diff changeset
851 inline void do_double() { if (!is_return_type()) get_double(); }
a61af66fc99e Initial load
duke
parents:
diff changeset
852 inline void do_object(int begin, int end) { if (!is_return_type()) get_object(); }
a61af66fc99e Initial load
duke
parents:
diff changeset
853 inline void do_array(int begin, int end) { if (!is_return_type()) get_object(); } // do_array uses get_object -- there is no get_array
a61af66fc99e Initial load
duke
parents:
diff changeset
854 inline void do_void() { }
a61af66fc99e Initial load
duke
parents:
diff changeset
855
a61af66fc99e Initial load
duke
parents:
diff changeset
856 JavaCallArguments* arguments() { return _arguments; }
a61af66fc99e Initial load
duke
parents:
diff changeset
857 void push_receiver(Handle h) { _arguments->push_oop(h); }
a61af66fc99e Initial load
duke
parents:
diff changeset
858 };
a61af66fc99e Initial load
duke
parents:
diff changeset
859
a61af66fc99e Initial load
duke
parents:
diff changeset
860
a61af66fc99e Initial load
duke
parents:
diff changeset
861 class JNI_ArgumentPusherVaArg : public JNI_ArgumentPusher {
a61af66fc99e Initial load
duke
parents:
diff changeset
862 protected:
a61af66fc99e Initial load
duke
parents:
diff changeset
863 va_list _ap;
a61af66fc99e Initial load
duke
parents:
diff changeset
864
a61af66fc99e Initial load
duke
parents:
diff changeset
865 inline void get_bool() { _arguments->push_int(va_arg(_ap, jint)); } // bool is coerced to int when using va_arg
a61af66fc99e Initial load
duke
parents:
diff changeset
866 inline void get_char() { _arguments->push_int(va_arg(_ap, jint)); } // char is coerced to int when using va_arg
a61af66fc99e Initial load
duke
parents:
diff changeset
867 inline void get_short() { _arguments->push_int(va_arg(_ap, jint)); } // short is coerced to int when using va_arg
a61af66fc99e Initial load
duke
parents:
diff changeset
868 inline void get_byte() { _arguments->push_int(va_arg(_ap, jint)); } // byte is coerced to int when using va_arg
a61af66fc99e Initial load
duke
parents:
diff changeset
869 inline void get_int() { _arguments->push_int(va_arg(_ap, jint)); }
a61af66fc99e Initial load
duke
parents:
diff changeset
870
a61af66fc99e Initial load
duke
parents:
diff changeset
871 // each of these paths is exercized by the various jck Call[Static,Nonvirtual,][Void,Int,..]Method[A,V,] tests
a61af66fc99e Initial load
duke
parents:
diff changeset
872
a61af66fc99e Initial load
duke
parents:
diff changeset
873 inline void get_long() { _arguments->push_long(va_arg(_ap, jlong)); }
a61af66fc99e Initial load
duke
parents:
diff changeset
874 inline void get_float() { _arguments->push_float((jfloat)va_arg(_ap, jdouble)); } // float is coerced to double w/ va_arg
a61af66fc99e Initial load
duke
parents:
diff changeset
875 inline void get_double() { _arguments->push_double(va_arg(_ap, jdouble)); }
a61af66fc99e Initial load
duke
parents:
diff changeset
876 inline void get_object() { jobject l = va_arg(_ap, jobject);
a61af66fc99e Initial load
duke
parents:
diff changeset
877 _arguments->push_oop(Handle((oop *)l, false)); }
a61af66fc99e Initial load
duke
parents:
diff changeset
878
a61af66fc99e Initial load
duke
parents:
diff changeset
879 inline void set_ap(va_list rap) {
a61af66fc99e Initial load
duke
parents:
diff changeset
880 #ifdef va_copy
a61af66fc99e Initial load
duke
parents:
diff changeset
881 va_copy(_ap, rap);
a61af66fc99e Initial load
duke
parents:
diff changeset
882 #elif defined (__va_copy)
a61af66fc99e Initial load
duke
parents:
diff changeset
883 __va_copy(_ap, rap);
a61af66fc99e Initial load
duke
parents:
diff changeset
884 #else
a61af66fc99e Initial load
duke
parents:
diff changeset
885 _ap = rap;
a61af66fc99e Initial load
duke
parents:
diff changeset
886 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
887 }
a61af66fc99e Initial load
duke
parents:
diff changeset
888
a61af66fc99e Initial load
duke
parents:
diff changeset
889 public:
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
890 JNI_ArgumentPusherVaArg(Symbol* signature, va_list rap)
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
891 : JNI_ArgumentPusher(signature) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
892 set_ap(rap);
a61af66fc99e Initial load
duke
parents:
diff changeset
893 }
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
894 JNI_ArgumentPusherVaArg(jmethodID method_id, va_list rap)
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
895 : JNI_ArgumentPusher(JNIHandles::resolve_jmethod_id(method_id)->signature()) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
896 set_ap(rap);
a61af66fc99e Initial load
duke
parents:
diff changeset
897 }
a61af66fc99e Initial load
duke
parents:
diff changeset
898
a61af66fc99e Initial load
duke
parents:
diff changeset
899 // Optimized path if we have the bitvector form of signature
a61af66fc99e Initial load
duke
parents:
diff changeset
900 void iterate( uint64_t fingerprint ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
901 if ( fingerprint == UCONST64(-1) ) SignatureIterator::iterate();// Must be too many arguments
a61af66fc99e Initial load
duke
parents:
diff changeset
902 else {
a61af66fc99e Initial load
duke
parents:
diff changeset
903 _return_type = (BasicType)((fingerprint >> static_feature_size) &
a61af66fc99e Initial load
duke
parents:
diff changeset
904 result_feature_mask);
a61af66fc99e Initial load
duke
parents:
diff changeset
905
a61af66fc99e Initial load
duke
parents:
diff changeset
906 assert(fingerprint, "Fingerprint should not be 0");
a61af66fc99e Initial load
duke
parents:
diff changeset
907 fingerprint = fingerprint >> (static_feature_size + result_feature_size);
a61af66fc99e Initial load
duke
parents:
diff changeset
908 while ( 1 ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
909 switch ( fingerprint & parameter_feature_mask ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
910 case bool_parm:
a61af66fc99e Initial load
duke
parents:
diff changeset
911 case char_parm:
a61af66fc99e Initial load
duke
parents:
diff changeset
912 case short_parm:
a61af66fc99e Initial load
duke
parents:
diff changeset
913 case byte_parm:
a61af66fc99e Initial load
duke
parents:
diff changeset
914 case int_parm:
a61af66fc99e Initial load
duke
parents:
diff changeset
915 get_int();
a61af66fc99e Initial load
duke
parents:
diff changeset
916 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
917 case obj_parm:
a61af66fc99e Initial load
duke
parents:
diff changeset
918 get_object();
a61af66fc99e Initial load
duke
parents:
diff changeset
919 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
920 case long_parm:
a61af66fc99e Initial load
duke
parents:
diff changeset
921 get_long();
a61af66fc99e Initial load
duke
parents:
diff changeset
922 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
923 case float_parm:
a61af66fc99e Initial load
duke
parents:
diff changeset
924 get_float();
a61af66fc99e Initial load
duke
parents:
diff changeset
925 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
926 case double_parm:
a61af66fc99e Initial load
duke
parents:
diff changeset
927 get_double();
a61af66fc99e Initial load
duke
parents:
diff changeset
928 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
929 case done_parm:
a61af66fc99e Initial load
duke
parents:
diff changeset
930 return;
a61af66fc99e Initial load
duke
parents:
diff changeset
931 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
932 default:
a61af66fc99e Initial load
duke
parents:
diff changeset
933 ShouldNotReachHere();
a61af66fc99e Initial load
duke
parents:
diff changeset
934 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
935 }
a61af66fc99e Initial load
duke
parents:
diff changeset
936 fingerprint >>= parameter_feature_size;
a61af66fc99e Initial load
duke
parents:
diff changeset
937 }
a61af66fc99e Initial load
duke
parents:
diff changeset
938 }
a61af66fc99e Initial load
duke
parents:
diff changeset
939 }
a61af66fc99e Initial load
duke
parents:
diff changeset
940 };
a61af66fc99e Initial load
duke
parents:
diff changeset
941
a61af66fc99e Initial load
duke
parents:
diff changeset
942
a61af66fc99e Initial load
duke
parents:
diff changeset
943 class JNI_ArgumentPusherArray : public JNI_ArgumentPusher {
a61af66fc99e Initial load
duke
parents:
diff changeset
944 protected:
a61af66fc99e Initial load
duke
parents:
diff changeset
945 const jvalue *_ap;
a61af66fc99e Initial load
duke
parents:
diff changeset
946
a61af66fc99e Initial load
duke
parents:
diff changeset
947 inline void get_bool() { _arguments->push_int((jint)(_ap++)->z); }
a61af66fc99e Initial load
duke
parents:
diff changeset
948 inline void get_char() { _arguments->push_int((jint)(_ap++)->c); }
a61af66fc99e Initial load
duke
parents:
diff changeset
949 inline void get_short() { _arguments->push_int((jint)(_ap++)->s); }
a61af66fc99e Initial load
duke
parents:
diff changeset
950 inline void get_byte() { _arguments->push_int((jint)(_ap++)->b); }
a61af66fc99e Initial load
duke
parents:
diff changeset
951 inline void get_int() { _arguments->push_int((jint)(_ap++)->i); }
a61af66fc99e Initial load
duke
parents:
diff changeset
952
a61af66fc99e Initial load
duke
parents:
diff changeset
953 inline void get_long() { _arguments->push_long((_ap++)->j); }
a61af66fc99e Initial load
duke
parents:
diff changeset
954 inline void get_float() { _arguments->push_float((_ap++)->f); }
a61af66fc99e Initial load
duke
parents:
diff changeset
955 inline void get_double() { _arguments->push_double((_ap++)->d);}
a61af66fc99e Initial load
duke
parents:
diff changeset
956 inline void get_object() { _arguments->push_oop(Handle((oop *)(_ap++)->l, false)); }
a61af66fc99e Initial load
duke
parents:
diff changeset
957
a61af66fc99e Initial load
duke
parents:
diff changeset
958 inline void set_ap(const jvalue *rap) { _ap = rap; }
a61af66fc99e Initial load
duke
parents:
diff changeset
959
a61af66fc99e Initial load
duke
parents:
diff changeset
960 public:
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
961 JNI_ArgumentPusherArray(Symbol* signature, const jvalue *rap)
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
962 : JNI_ArgumentPusher(signature) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
963 set_ap(rap);
a61af66fc99e Initial load
duke
parents:
diff changeset
964 }
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
965 JNI_ArgumentPusherArray(jmethodID method_id, const jvalue *rap)
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
966 : JNI_ArgumentPusher(JNIHandles::resolve_jmethod_id(method_id)->signature()) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
967 set_ap(rap);
a61af66fc99e Initial load
duke
parents:
diff changeset
968 }
a61af66fc99e Initial load
duke
parents:
diff changeset
969
a61af66fc99e Initial load
duke
parents:
diff changeset
970 // Optimized path if we have the bitvector form of signature
a61af66fc99e Initial load
duke
parents:
diff changeset
971 void iterate( uint64_t fingerprint ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
972 if ( fingerprint == UCONST64(-1) ) SignatureIterator::iterate(); // Must be too many arguments
a61af66fc99e Initial load
duke
parents:
diff changeset
973 else {
a61af66fc99e Initial load
duke
parents:
diff changeset
974 _return_type = (BasicType)((fingerprint >> static_feature_size) &
a61af66fc99e Initial load
duke
parents:
diff changeset
975 result_feature_mask);
a61af66fc99e Initial load
duke
parents:
diff changeset
976 assert(fingerprint, "Fingerprint should not be 0");
a61af66fc99e Initial load
duke
parents:
diff changeset
977 fingerprint = fingerprint >> (static_feature_size + result_feature_size);
a61af66fc99e Initial load
duke
parents:
diff changeset
978 while ( 1 ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
979 switch ( fingerprint & parameter_feature_mask ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
980 case bool_parm:
a61af66fc99e Initial load
duke
parents:
diff changeset
981 get_bool();
a61af66fc99e Initial load
duke
parents:
diff changeset
982 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
983 case char_parm:
a61af66fc99e Initial load
duke
parents:
diff changeset
984 get_char();
a61af66fc99e Initial load
duke
parents:
diff changeset
985 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
986 case short_parm:
a61af66fc99e Initial load
duke
parents:
diff changeset
987 get_short();
a61af66fc99e Initial load
duke
parents:
diff changeset
988 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
989 case byte_parm:
a61af66fc99e Initial load
duke
parents:
diff changeset
990 get_byte();
a61af66fc99e Initial load
duke
parents:
diff changeset
991 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
992 case int_parm:
a61af66fc99e Initial load
duke
parents:
diff changeset
993 get_int();
a61af66fc99e Initial load
duke
parents:
diff changeset
994 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
995 case obj_parm:
a61af66fc99e Initial load
duke
parents:
diff changeset
996 get_object();
a61af66fc99e Initial load
duke
parents:
diff changeset
997 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
998 case long_parm:
a61af66fc99e Initial load
duke
parents:
diff changeset
999 get_long();
a61af66fc99e Initial load
duke
parents:
diff changeset
1000 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1001 case float_parm:
a61af66fc99e Initial load
duke
parents:
diff changeset
1002 get_float();
a61af66fc99e Initial load
duke
parents:
diff changeset
1003 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1004 case double_parm:
a61af66fc99e Initial load
duke
parents:
diff changeset
1005 get_double();
a61af66fc99e Initial load
duke
parents:
diff changeset
1006 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1007 case done_parm:
a61af66fc99e Initial load
duke
parents:
diff changeset
1008 return;
a61af66fc99e Initial load
duke
parents:
diff changeset
1009 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1010 default:
a61af66fc99e Initial load
duke
parents:
diff changeset
1011 ShouldNotReachHere();
a61af66fc99e Initial load
duke
parents:
diff changeset
1012 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1013 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1014 fingerprint >>= parameter_feature_size;
a61af66fc99e Initial load
duke
parents:
diff changeset
1015 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1016 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1017 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1018 };
a61af66fc99e Initial load
duke
parents:
diff changeset
1019
a61af66fc99e Initial load
duke
parents:
diff changeset
1020
a61af66fc99e Initial load
duke
parents:
diff changeset
1021 enum JNICallType {
a61af66fc99e Initial load
duke
parents:
diff changeset
1022 JNI_STATIC,
a61af66fc99e Initial load
duke
parents:
diff changeset
1023 JNI_VIRTUAL,
a61af66fc99e Initial load
duke
parents:
diff changeset
1024 JNI_NONVIRTUAL
a61af66fc99e Initial load
duke
parents:
diff changeset
1025 };
a61af66fc99e Initial load
duke
parents:
diff changeset
1026
a61af66fc99e Initial load
duke
parents:
diff changeset
1027 static methodHandle jni_resolve_interface_call(Handle recv, methodHandle method, TRAPS) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1028 assert(!method.is_null() , "method should not be null");
a61af66fc99e Initial load
duke
parents:
diff changeset
1029
a61af66fc99e Initial load
duke
parents:
diff changeset
1030 KlassHandle recv_klass; // Default to NULL (use of ?: can confuse gcc)
a61af66fc99e Initial load
duke
parents:
diff changeset
1031 if (recv.not_null()) recv_klass = KlassHandle(THREAD, recv->klass());
a61af66fc99e Initial load
duke
parents:
diff changeset
1032 KlassHandle spec_klass (THREAD, method->method_holder());
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1033 Symbol* name = method->name();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1034 Symbol* signature = method->signature();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1035 CallInfo info;
a61af66fc99e Initial load
duke
parents:
diff changeset
1036 LinkResolver::resolve_interface_call(info, recv, recv_klass, spec_klass, name, signature, KlassHandle(), false, true, CHECK_(methodHandle()));
a61af66fc99e Initial load
duke
parents:
diff changeset
1037 return info.selected_method();
a61af66fc99e Initial load
duke
parents:
diff changeset
1038 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1039
a61af66fc99e Initial load
duke
parents:
diff changeset
1040 static methodHandle jni_resolve_virtual_call(Handle recv, methodHandle method, TRAPS) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1041 assert(!method.is_null() , "method should not be null");
a61af66fc99e Initial load
duke
parents:
diff changeset
1042
a61af66fc99e Initial load
duke
parents:
diff changeset
1043 KlassHandle recv_klass; // Default to NULL (use of ?: can confuse gcc)
a61af66fc99e Initial load
duke
parents:
diff changeset
1044 if (recv.not_null()) recv_klass = KlassHandle(THREAD, recv->klass());
a61af66fc99e Initial load
duke
parents:
diff changeset
1045 KlassHandle spec_klass (THREAD, method->method_holder());
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1046 Symbol* name = method->name();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1047 Symbol* signature = method->signature();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1048 CallInfo info;
a61af66fc99e Initial load
duke
parents:
diff changeset
1049 LinkResolver::resolve_virtual_call(info, recv, recv_klass, spec_klass, name, signature, KlassHandle(), false, true, CHECK_(methodHandle()));
a61af66fc99e Initial load
duke
parents:
diff changeset
1050 return info.selected_method();
a61af66fc99e Initial load
duke
parents:
diff changeset
1051 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1052
a61af66fc99e Initial load
duke
parents:
diff changeset
1053
a61af66fc99e Initial load
duke
parents:
diff changeset
1054
a61af66fc99e Initial load
duke
parents:
diff changeset
1055 static void jni_invoke_static(JNIEnv *env, JavaValue* result, jobject receiver, JNICallType call_type, jmethodID method_id, JNI_ArgumentPusher *args, TRAPS) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1056 methodHandle method(THREAD, JNIHandles::resolve_jmethod_id(method_id));
a61af66fc99e Initial load
duke
parents:
diff changeset
1057
a61af66fc99e Initial load
duke
parents:
diff changeset
1058 // Create object to hold arguments for the JavaCall, and associate it with
a61af66fc99e Initial load
duke
parents:
diff changeset
1059 // the jni parser
a61af66fc99e Initial load
duke
parents:
diff changeset
1060 ResourceMark rm(THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
1061 int number_of_parameters = method->size_of_parameters();
a61af66fc99e Initial load
duke
parents:
diff changeset
1062 JavaCallArguments java_args(number_of_parameters);
a61af66fc99e Initial load
duke
parents:
diff changeset
1063 args->set_java_argument_object(&java_args);
a61af66fc99e Initial load
duke
parents:
diff changeset
1064
a61af66fc99e Initial load
duke
parents:
diff changeset
1065 assert(method->is_static(), "method should be static");
a61af66fc99e Initial load
duke
parents:
diff changeset
1066
a61af66fc99e Initial load
duke
parents:
diff changeset
1067 // Fill out JavaCallArguments object
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1068 args->iterate( Fingerprinter(method).fingerprint() );
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1069 // Initialize result type
a61af66fc99e Initial load
duke
parents:
diff changeset
1070 result->set_type(args->get_ret_type());
a61af66fc99e Initial load
duke
parents:
diff changeset
1071
a61af66fc99e Initial load
duke
parents:
diff changeset
1072 // Invoke the method. Result is returned as oop.
a61af66fc99e Initial load
duke
parents:
diff changeset
1073 JavaCalls::call(result, method, &java_args, CHECK);
a61af66fc99e Initial load
duke
parents:
diff changeset
1074
a61af66fc99e Initial load
duke
parents:
diff changeset
1075 // Convert result
a61af66fc99e Initial load
duke
parents:
diff changeset
1076 if (result->get_type() == T_OBJECT || result->get_type() == T_ARRAY) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1077 result->set_jobject(JNIHandles::make_local(env, (oop) result->get_jobject()));
a61af66fc99e Initial load
duke
parents:
diff changeset
1078 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1079 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1080
a61af66fc99e Initial load
duke
parents:
diff changeset
1081
a61af66fc99e Initial load
duke
parents:
diff changeset
1082 static void jni_invoke_nonstatic(JNIEnv *env, JavaValue* result, jobject receiver, JNICallType call_type, jmethodID method_id, JNI_ArgumentPusher *args, TRAPS) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1083 oop recv = JNIHandles::resolve(receiver);
a61af66fc99e Initial load
duke
parents:
diff changeset
1084 if (recv == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1085 THROW(vmSymbols::java_lang_NullPointerException());
a61af66fc99e Initial load
duke
parents:
diff changeset
1086 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1087 Handle h_recv(THREAD, recv);
a61af66fc99e Initial load
duke
parents:
diff changeset
1088
a61af66fc99e Initial load
duke
parents:
diff changeset
1089 int number_of_parameters;
a61af66fc99e Initial load
duke
parents:
diff changeset
1090 methodOop selected_method;
a61af66fc99e Initial load
duke
parents:
diff changeset
1091 {
a61af66fc99e Initial load
duke
parents:
diff changeset
1092 methodOop m = JNIHandles::resolve_jmethod_id(method_id);
a61af66fc99e Initial load
duke
parents:
diff changeset
1093 number_of_parameters = m->size_of_parameters();
a61af66fc99e Initial load
duke
parents:
diff changeset
1094 klassOop holder = m->method_holder();
a61af66fc99e Initial load
duke
parents:
diff changeset
1095 if (!(Klass::cast(holder))->is_interface()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1096 // non-interface call -- for that little speed boost, don't handlize
a61af66fc99e Initial load
duke
parents:
diff changeset
1097 debug_only(No_Safepoint_Verifier nosafepoint;)
a61af66fc99e Initial load
duke
parents:
diff changeset
1098 if (call_type == JNI_VIRTUAL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1099 // jni_GetMethodID makes sure class is linked and initialized
a61af66fc99e Initial load
duke
parents:
diff changeset
1100 // so m should have a valid vtable index.
a61af66fc99e Initial load
duke
parents:
diff changeset
1101 int vtbl_index = m->vtable_index();
a61af66fc99e Initial load
duke
parents:
diff changeset
1102 if (vtbl_index != methodOopDesc::nonvirtual_vtable_index) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1103 klassOop k = h_recv->klass();
a61af66fc99e Initial load
duke
parents:
diff changeset
1104 // k might be an arrayKlassOop but all vtables start at
a61af66fc99e Initial load
duke
parents:
diff changeset
1105 // the same place. The cast is to avoid virtual call and assertion.
a61af66fc99e Initial load
duke
parents:
diff changeset
1106 instanceKlass *ik = (instanceKlass*)k->klass_part();
a61af66fc99e Initial load
duke
parents:
diff changeset
1107 selected_method = ik->method_at_vtable(vtbl_index);
a61af66fc99e Initial load
duke
parents:
diff changeset
1108 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
1109 // final method
a61af66fc99e Initial load
duke
parents:
diff changeset
1110 selected_method = m;
a61af66fc99e Initial load
duke
parents:
diff changeset
1111 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1112 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
1113 // JNI_NONVIRTUAL call
a61af66fc99e Initial load
duke
parents:
diff changeset
1114 selected_method = m;
a61af66fc99e Initial load
duke
parents:
diff changeset
1115 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1116 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
1117 // interface call
a61af66fc99e Initial load
duke
parents:
diff changeset
1118 KlassHandle h_holder(THREAD, holder);
a61af66fc99e Initial load
duke
parents:
diff changeset
1119
a61af66fc99e Initial load
duke
parents:
diff changeset
1120 int itbl_index = m->cached_itable_index();
a61af66fc99e Initial load
duke
parents:
diff changeset
1121 if (itbl_index == -1) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1122 itbl_index = klassItable::compute_itable_index(m);
a61af66fc99e Initial load
duke
parents:
diff changeset
1123 m->set_cached_itable_index(itbl_index);
a61af66fc99e Initial load
duke
parents:
diff changeset
1124 // the above may have grabbed a lock, 'm' and anything non-handlized can't be used again
a61af66fc99e Initial load
duke
parents:
diff changeset
1125 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1126 klassOop k = h_recv->klass();
a61af66fc99e Initial load
duke
parents:
diff changeset
1127 selected_method = instanceKlass::cast(k)->method_at_itable(h_holder(), itbl_index, CHECK);
a61af66fc99e Initial load
duke
parents:
diff changeset
1128 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1129 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1130
a61af66fc99e Initial load
duke
parents:
diff changeset
1131 methodHandle method(THREAD, selected_method);
a61af66fc99e Initial load
duke
parents:
diff changeset
1132
a61af66fc99e Initial load
duke
parents:
diff changeset
1133 // Create object to hold arguments for the JavaCall, and associate it with
a61af66fc99e Initial load
duke
parents:
diff changeset
1134 // the jni parser
a61af66fc99e Initial load
duke
parents:
diff changeset
1135 ResourceMark rm(THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
1136 JavaCallArguments java_args(number_of_parameters);
a61af66fc99e Initial load
duke
parents:
diff changeset
1137 args->set_java_argument_object(&java_args);
a61af66fc99e Initial load
duke
parents:
diff changeset
1138
a61af66fc99e Initial load
duke
parents:
diff changeset
1139 // handle arguments
a61af66fc99e Initial load
duke
parents:
diff changeset
1140 assert(!method->is_static(), "method should not be static");
a61af66fc99e Initial load
duke
parents:
diff changeset
1141 args->push_receiver(h_recv); // Push jobject handle
a61af66fc99e Initial load
duke
parents:
diff changeset
1142
a61af66fc99e Initial load
duke
parents:
diff changeset
1143 // Fill out JavaCallArguments object
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1144 args->iterate( Fingerprinter(method).fingerprint() );
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1145 // Initialize result type
a61af66fc99e Initial load
duke
parents:
diff changeset
1146 result->set_type(args->get_ret_type());
a61af66fc99e Initial load
duke
parents:
diff changeset
1147
a61af66fc99e Initial load
duke
parents:
diff changeset
1148 // Invoke the method. Result is returned as oop.
a61af66fc99e Initial load
duke
parents:
diff changeset
1149 JavaCalls::call(result, method, &java_args, CHECK);
a61af66fc99e Initial load
duke
parents:
diff changeset
1150
a61af66fc99e Initial load
duke
parents:
diff changeset
1151 // Convert result
a61af66fc99e Initial load
duke
parents:
diff changeset
1152 if (result->get_type() == T_OBJECT || result->get_type() == T_ARRAY) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1153 result->set_jobject(JNIHandles::make_local(env, (oop) result->get_jobject()));
a61af66fc99e Initial load
duke
parents:
diff changeset
1154 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1155 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1156
a61af66fc99e Initial load
duke
parents:
diff changeset
1157
a61af66fc99e Initial load
duke
parents:
diff changeset
1158 static instanceOop alloc_object(jclass clazz, TRAPS) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1159 KlassHandle k(THREAD, java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(clazz)));
a61af66fc99e Initial load
duke
parents:
diff changeset
1160 Klass::cast(k())->check_valid_for_instantiation(false, CHECK_NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
1161 instanceKlass::cast(k())->initialize(CHECK_NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
1162 instanceOop ih = instanceKlass::cast(k())->allocate_instance(THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
1163 return ih;
a61af66fc99e Initial load
duke
parents:
diff changeset
1164 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1165
a61af66fc99e Initial load
duke
parents:
diff changeset
1166 DT_RETURN_MARK_DECL(AllocObject, jobject);
a61af66fc99e Initial load
duke
parents:
diff changeset
1167
a61af66fc99e Initial load
duke
parents:
diff changeset
1168 JNI_ENTRY(jobject, jni_AllocObject(JNIEnv *env, jclass clazz))
a61af66fc99e Initial load
duke
parents:
diff changeset
1169 JNIWrapper("AllocObject");
a61af66fc99e Initial load
duke
parents:
diff changeset
1170
a61af66fc99e Initial load
duke
parents:
diff changeset
1171 DTRACE_PROBE2(hotspot_jni, AllocObject__entry, env, clazz);
a61af66fc99e Initial load
duke
parents:
diff changeset
1172 jobject ret = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
1173 DT_RETURN_MARK(AllocObject, jobject, (const jobject&)ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
1174
a61af66fc99e Initial load
duke
parents:
diff changeset
1175 instanceOop i = alloc_object(clazz, CHECK_NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
1176 ret = JNIHandles::make_local(env, i);
a61af66fc99e Initial load
duke
parents:
diff changeset
1177 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
1178 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
1179
a61af66fc99e Initial load
duke
parents:
diff changeset
1180 DT_RETURN_MARK_DECL(NewObjectA, jobject);
a61af66fc99e Initial load
duke
parents:
diff changeset
1181
a61af66fc99e Initial load
duke
parents:
diff changeset
1182 JNI_ENTRY(jobject, jni_NewObjectA(JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args))
a61af66fc99e Initial load
duke
parents:
diff changeset
1183 JNIWrapper("NewObjectA");
a61af66fc99e Initial load
duke
parents:
diff changeset
1184 DTRACE_PROBE3(hotspot_jni, NewObjectA__entry, env, clazz, methodID);
a61af66fc99e Initial load
duke
parents:
diff changeset
1185 jobject obj = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
1186 DT_RETURN_MARK(NewObjectA, jobject, (const jobject)obj);
a61af66fc99e Initial load
duke
parents:
diff changeset
1187
a61af66fc99e Initial load
duke
parents:
diff changeset
1188 instanceOop i = alloc_object(clazz, CHECK_NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
1189 obj = JNIHandles::make_local(env, i);
a61af66fc99e Initial load
duke
parents:
diff changeset
1190 JavaValue jvalue(T_VOID);
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1191 JNI_ArgumentPusherArray ap(methodID, args);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1192 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
1193 return obj;
a61af66fc99e Initial load
duke
parents:
diff changeset
1194 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
1195
a61af66fc99e Initial load
duke
parents:
diff changeset
1196 DT_RETURN_MARK_DECL(NewObjectV, jobject);
a61af66fc99e Initial load
duke
parents:
diff changeset
1197
a61af66fc99e Initial load
duke
parents:
diff changeset
1198 JNI_ENTRY(jobject, jni_NewObjectV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args))
a61af66fc99e Initial load
duke
parents:
diff changeset
1199 JNIWrapper("NewObjectV");
a61af66fc99e Initial load
duke
parents:
diff changeset
1200 DTRACE_PROBE3(hotspot_jni, NewObjectV__entry, env, clazz, methodID);
a61af66fc99e Initial load
duke
parents:
diff changeset
1201 jobject obj = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
1202 DT_RETURN_MARK(NewObjectV, jobject, (const jobject&)obj);
a61af66fc99e Initial load
duke
parents:
diff changeset
1203
a61af66fc99e Initial load
duke
parents:
diff changeset
1204 instanceOop i = alloc_object(clazz, CHECK_NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
1205 obj = JNIHandles::make_local(env, i);
a61af66fc99e Initial load
duke
parents:
diff changeset
1206 JavaValue jvalue(T_VOID);
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1207 JNI_ArgumentPusherVaArg ap(methodID, args);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1208 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
1209 return obj;
a61af66fc99e Initial load
duke
parents:
diff changeset
1210 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
1211
a61af66fc99e Initial load
duke
parents:
diff changeset
1212 DT_RETURN_MARK_DECL(NewObject, jobject);
a61af66fc99e Initial load
duke
parents:
diff changeset
1213
a61af66fc99e Initial load
duke
parents:
diff changeset
1214 JNI_ENTRY(jobject, jni_NewObject(JNIEnv *env, jclass clazz, jmethodID methodID, ...))
a61af66fc99e Initial load
duke
parents:
diff changeset
1215 JNIWrapper("NewObject");
a61af66fc99e Initial load
duke
parents:
diff changeset
1216 DTRACE_PROBE3(hotspot_jni, NewObject__entry, env, clazz, methodID);
a61af66fc99e Initial load
duke
parents:
diff changeset
1217 jobject obj = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
1218 DT_RETURN_MARK(NewObject, jobject, (const jobject&)obj);
a61af66fc99e Initial load
duke
parents:
diff changeset
1219
a61af66fc99e Initial load
duke
parents:
diff changeset
1220 instanceOop i = alloc_object(clazz, CHECK_NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
1221 obj = JNIHandles::make_local(env, i);
a61af66fc99e Initial load
duke
parents:
diff changeset
1222 va_list args;
a61af66fc99e Initial load
duke
parents:
diff changeset
1223 va_start(args, methodID);
a61af66fc99e Initial load
duke
parents:
diff changeset
1224 JavaValue jvalue(T_VOID);
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1225 JNI_ArgumentPusherVaArg ap(methodID, args);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1226 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
1227 va_end(args);
a61af66fc99e Initial load
duke
parents:
diff changeset
1228 return obj;
a61af66fc99e Initial load
duke
parents:
diff changeset
1229 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
1230
a61af66fc99e Initial load
duke
parents:
diff changeset
1231
a61af66fc99e Initial load
duke
parents:
diff changeset
1232 JNI_ENTRY(jclass, jni_GetObjectClass(JNIEnv *env, jobject obj))
a61af66fc99e Initial load
duke
parents:
diff changeset
1233 JNIWrapper("GetObjectClass");
a61af66fc99e Initial load
duke
parents:
diff changeset
1234 DTRACE_PROBE2(hotspot_jni, GetObjectClass__entry, env, obj);
a61af66fc99e Initial load
duke
parents:
diff changeset
1235 klassOop k = JNIHandles::resolve_non_null(obj)->klass();
a61af66fc99e Initial load
duke
parents:
diff changeset
1236 jclass ret =
a61af66fc99e Initial load
duke
parents:
diff changeset
1237 (jclass) JNIHandles::make_local(env, Klass::cast(k)->java_mirror());
a61af66fc99e Initial load
duke
parents:
diff changeset
1238 DTRACE_PROBE1(hotspot_jni, GetObjectClass__return, ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
1239 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
1240 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
1241
a61af66fc99e Initial load
duke
parents:
diff changeset
1242 JNI_QUICK_ENTRY(jboolean, jni_IsInstanceOf(JNIEnv *env, jobject obj, jclass clazz))
a61af66fc99e Initial load
duke
parents:
diff changeset
1243 JNIWrapper("IsInstanceOf");
a61af66fc99e Initial load
duke
parents:
diff changeset
1244 DTRACE_PROBE3(hotspot_jni, IsInstanceOf__entry, env, obj, clazz);
a61af66fc99e Initial load
duke
parents:
diff changeset
1245 jboolean ret = JNI_TRUE;
a61af66fc99e Initial load
duke
parents:
diff changeset
1246 if (obj != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1247 ret = JNI_FALSE;
a61af66fc99e Initial load
duke
parents:
diff changeset
1248 klassOop k = java_lang_Class::as_klassOop(
a61af66fc99e Initial load
duke
parents:
diff changeset
1249 JNIHandles::resolve_non_null(clazz));
a61af66fc99e Initial load
duke
parents:
diff changeset
1250 if (k != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1251 ret = JNIHandles::resolve_non_null(obj)->is_a(k) ? JNI_TRUE : JNI_FALSE;
a61af66fc99e Initial load
duke
parents:
diff changeset
1252 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1253 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1254 DTRACE_PROBE1(hotspot_jni, IsInstanceOf__return, ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
1255 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
1256 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
1257
a61af66fc99e Initial load
duke
parents:
diff changeset
1258
a61af66fc99e Initial load
duke
parents:
diff changeset
1259 static jmethodID get_method_id(JNIEnv *env, jclass clazz, const char *name_str,
a61af66fc99e Initial load
duke
parents:
diff changeset
1260 const char *sig, bool is_static, TRAPS) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1261 // %%%% This code should probably just call into a method in the LinkResolver
a61af66fc99e Initial load
duke
parents:
diff changeset
1262 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1263 // The class should have been loaded (we have an instance of the class
a61af66fc99e Initial load
duke
parents:
diff changeset
1264 // passed in) so the method and signature should already be in the symbol
a61af66fc99e Initial load
duke
parents:
diff changeset
1265 // table. If they're not there, the method doesn't exist.
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1266 const char *name_to_probe = (name_str == NULL)
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1267 ? vmSymbols::object_initializer_name()->as_C_string()
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1268 : name_str;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1269 TempNewSymbol name = SymbolTable::probe(name_to_probe, (int)strlen(name_to_probe));
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1270 TempNewSymbol signature = SymbolTable::probe(sig, (int)strlen(sig));
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1271
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1272 if (name == NULL || signature == NULL) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1273 THROW_MSG_0(vmSymbols::java_lang_NoSuchMethodError(), name_str);
a61af66fc99e Initial load
duke
parents:
diff changeset
1274 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1275
a61af66fc99e Initial load
duke
parents:
diff changeset
1276 // Throw a NoSuchMethodError exception if we have an instance of a
a61af66fc99e Initial load
duke
parents:
diff changeset
1277 // primitive java.lang.Class
a61af66fc99e Initial load
duke
parents:
diff changeset
1278 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(clazz))) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1279 THROW_MSG_0(vmSymbols::java_lang_NoSuchMethodError(), name_str);
a61af66fc99e Initial load
duke
parents:
diff changeset
1280 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1281
a61af66fc99e Initial load
duke
parents:
diff changeset
1282 KlassHandle klass(THREAD,
a61af66fc99e Initial load
duke
parents:
diff changeset
1283 java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(clazz)));
a61af66fc99e Initial load
duke
parents:
diff changeset
1284
a61af66fc99e Initial load
duke
parents:
diff changeset
1285 // Make sure class is linked and initialized before handing id's out to
a61af66fc99e Initial load
duke
parents:
diff changeset
1286 // methodOops.
a61af66fc99e Initial load
duke
parents:
diff changeset
1287 Klass::cast(klass())->initialize(CHECK_NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
1288
a61af66fc99e Initial load
duke
parents:
diff changeset
1289 methodOop m;
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1290 if (name == vmSymbols::object_initializer_name() ||
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1291 name == vmSymbols::class_initializer_name()) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1292 // Never search superclasses for constructors
a61af66fc99e Initial load
duke
parents:
diff changeset
1293 if (klass->oop_is_instance()) {
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1294 m = instanceKlass::cast(klass())->find_method(name, signature);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1295 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
1296 m = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
1297 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1298 } else {
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1299 m = klass->lookup_method(name, signature);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1300 // Look up interfaces
a61af66fc99e Initial load
duke
parents:
diff changeset
1301 if (m == NULL && klass->oop_is_instance()) {
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1302 m = instanceKlass::cast(klass())->lookup_method_in_all_interfaces(name,
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1303 signature);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1304 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1305 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1306 if (m == NULL || (m->is_static() != is_static)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1307 THROW_MSG_0(vmSymbols::java_lang_NoSuchMethodError(), name_str);
a61af66fc99e Initial load
duke
parents:
diff changeset
1308 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1309 return m->jmethod_id();
a61af66fc99e Initial load
duke
parents:
diff changeset
1310 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1311
a61af66fc99e Initial load
duke
parents:
diff changeset
1312
a61af66fc99e Initial load
duke
parents:
diff changeset
1313 JNI_ENTRY(jmethodID, jni_GetMethodID(JNIEnv *env, jclass clazz,
a61af66fc99e Initial load
duke
parents:
diff changeset
1314 const char *name, const char *sig))
a61af66fc99e Initial load
duke
parents:
diff changeset
1315 JNIWrapper("GetMethodID");
a61af66fc99e Initial load
duke
parents:
diff changeset
1316 DTRACE_PROBE4(hotspot_jni, GetMethodID__entry, env, clazz, name, sig);
a61af66fc99e Initial load
duke
parents:
diff changeset
1317 jmethodID ret = get_method_id(env, clazz, name, sig, false, thread);
a61af66fc99e Initial load
duke
parents:
diff changeset
1318 DTRACE_PROBE1(hotspot_jni, GetMethodID__return, ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
1319 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
1320 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
1321
a61af66fc99e Initial load
duke
parents:
diff changeset
1322
a61af66fc99e Initial load
duke
parents:
diff changeset
1323 JNI_ENTRY(jmethodID, jni_GetStaticMethodID(JNIEnv *env, jclass clazz,
a61af66fc99e Initial load
duke
parents:
diff changeset
1324 const char *name, const char *sig))
a61af66fc99e Initial load
duke
parents:
diff changeset
1325 JNIWrapper("GetStaticMethodID");
a61af66fc99e Initial load
duke
parents:
diff changeset
1326 DTRACE_PROBE4(hotspot_jni, GetStaticMethodID__entry, env, clazz, name, sig);
a61af66fc99e Initial load
duke
parents:
diff changeset
1327 jmethodID ret = get_method_id(env, clazz, name, sig, true, thread);
a61af66fc99e Initial load
duke
parents:
diff changeset
1328 DTRACE_PROBE1(hotspot_jni, GetStaticMethodID__return, ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
1329 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
1330 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
1331
a61af66fc99e Initial load
duke
parents:
diff changeset
1332
a61af66fc99e Initial load
duke
parents:
diff changeset
1333
a61af66fc99e Initial load
duke
parents:
diff changeset
1334 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1335 // Calling Methods
a61af66fc99e Initial load
duke
parents:
diff changeset
1336 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1337
a61af66fc99e Initial load
duke
parents:
diff changeset
1338
a61af66fc99e Initial load
duke
parents:
diff changeset
1339 #define DEFINE_CALLMETHOD(ResultType, Result, Tag) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1340 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1341 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##Method, ResultType);\
a61af66fc99e Initial load
duke
parents:
diff changeset
1342 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##MethodV, ResultType);\
a61af66fc99e Initial load
duke
parents:
diff changeset
1343 DT_RETURN_MARK_DECL_FOR(Result, Call##Result##MethodA, ResultType);\
a61af66fc99e Initial load
duke
parents:
diff changeset
1344 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1345 JNI_ENTRY(ResultType, \
a61af66fc99e Initial load
duke
parents:
diff changeset
1346 jni_Call##Result##Method(JNIEnv *env, jobject obj, jmethodID methodID, ...)) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1347 JNIWrapper("Call" XSTR(Result) "Method"); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1348 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1349 DTRACE_PROBE3(hotspot_jni, Call##Result##Method__entry, env, obj, methodID);\
a61af66fc99e Initial load
duke
parents:
diff changeset
1350 ResultType ret = 0;\
a61af66fc99e Initial load
duke
parents:
diff changeset
1351 DT_RETURN_MARK_FOR(Result, Call##Result##Method, ResultType, \
a61af66fc99e Initial load
duke
parents:
diff changeset
1352 (const ResultType&)ret);\
a61af66fc99e Initial load
duke
parents:
diff changeset
1353 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1354 va_list args; \
a61af66fc99e Initial load
duke
parents:
diff changeset
1355 va_start(args, methodID); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1356 JavaValue jvalue(Tag); \
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1357 JNI_ArgumentPusherVaArg ap(methodID, args); \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1358 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1359 va_end(args); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1360 ret = jvalue.get_##ResultType(); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1361 return ret;\
a61af66fc99e Initial load
duke
parents:
diff changeset
1362 JNI_END \
a61af66fc99e Initial load
duke
parents:
diff changeset
1363 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1364 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1365 JNI_ENTRY(ResultType, \
a61af66fc99e Initial load
duke
parents:
diff changeset
1366 jni_Call##Result##MethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1367 JNIWrapper("Call" XSTR(Result) "MethodV"); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1368 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1369 DTRACE_PROBE3(hotspot_jni, Call##Result##MethodV__entry, env, obj, methodID);\
a61af66fc99e Initial load
duke
parents:
diff changeset
1370 ResultType ret = 0;\
a61af66fc99e Initial load
duke
parents:
diff changeset
1371 DT_RETURN_MARK_FOR(Result, Call##Result##MethodV, ResultType, \
a61af66fc99e Initial load
duke
parents:
diff changeset
1372 (const ResultType&)ret);\
a61af66fc99e Initial load
duke
parents:
diff changeset
1373 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1374 JavaValue jvalue(Tag); \
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1375 JNI_ArgumentPusherVaArg ap(methodID, args); \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1376 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1377 ret = jvalue.get_##ResultType(); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1378 return ret;\
a61af66fc99e Initial load
duke
parents:
diff changeset
1379 JNI_END \
a61af66fc99e Initial load
duke
parents:
diff changeset
1380 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1381 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1382 JNI_ENTRY(ResultType, \
a61af66fc99e Initial load
duke
parents:
diff changeset
1383 jni_Call##Result##MethodA(JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args)) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1384 JNIWrapper("Call" XSTR(Result) "MethodA"); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1385 DTRACE_PROBE3(hotspot_jni, Call##Result##MethodA__entry, env, obj, methodID);\
a61af66fc99e Initial load
duke
parents:
diff changeset
1386 ResultType ret = 0;\
a61af66fc99e Initial load
duke
parents:
diff changeset
1387 DT_RETURN_MARK_FOR(Result, Call##Result##MethodA, ResultType, \
a61af66fc99e Initial load
duke
parents:
diff changeset
1388 (const ResultType&)ret);\
a61af66fc99e Initial load
duke
parents:
diff changeset
1389 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1390 JavaValue jvalue(Tag); \
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1391 JNI_ArgumentPusherArray ap(methodID, args); \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1392 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1393 ret = jvalue.get_##ResultType(); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1394 return ret;\
a61af66fc99e Initial load
duke
parents:
diff changeset
1395 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
1396
a61af66fc99e Initial load
duke
parents:
diff changeset
1397 // the runtime type of subword integral basic types is integer
a61af66fc99e Initial load
duke
parents:
diff changeset
1398 DEFINE_CALLMETHOD(jboolean, Boolean, T_BOOLEAN)
a61af66fc99e Initial load
duke
parents:
diff changeset
1399 DEFINE_CALLMETHOD(jbyte, Byte, T_BYTE)
a61af66fc99e Initial load
duke
parents:
diff changeset
1400 DEFINE_CALLMETHOD(jchar, Char, T_CHAR)
a61af66fc99e Initial load
duke
parents:
diff changeset
1401 DEFINE_CALLMETHOD(jshort, Short, T_SHORT)
a61af66fc99e Initial load
duke
parents:
diff changeset
1402
a61af66fc99e Initial load
duke
parents:
diff changeset
1403 DEFINE_CALLMETHOD(jobject, Object, T_OBJECT)
a61af66fc99e Initial load
duke
parents:
diff changeset
1404 DEFINE_CALLMETHOD(jint, Int, T_INT)
a61af66fc99e Initial load
duke
parents:
diff changeset
1405 DEFINE_CALLMETHOD(jlong, Long, T_LONG)
a61af66fc99e Initial load
duke
parents:
diff changeset
1406 DEFINE_CALLMETHOD(jfloat, Float, T_FLOAT)
a61af66fc99e Initial load
duke
parents:
diff changeset
1407 DEFINE_CALLMETHOD(jdouble, Double, T_DOUBLE)
a61af66fc99e Initial load
duke
parents:
diff changeset
1408
a61af66fc99e Initial load
duke
parents:
diff changeset
1409 DT_VOID_RETURN_MARK_DECL(CallVoidMethod);
a61af66fc99e Initial load
duke
parents:
diff changeset
1410 DT_VOID_RETURN_MARK_DECL(CallVoidMethodV);
a61af66fc99e Initial load
duke
parents:
diff changeset
1411 DT_VOID_RETURN_MARK_DECL(CallVoidMethodA);
a61af66fc99e Initial load
duke
parents:
diff changeset
1412
a61af66fc99e Initial load
duke
parents:
diff changeset
1413 JNI_ENTRY(void, jni_CallVoidMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...))
a61af66fc99e Initial load
duke
parents:
diff changeset
1414 JNIWrapper("CallVoidMethod");
a61af66fc99e Initial load
duke
parents:
diff changeset
1415 DTRACE_PROBE3(hotspot_jni, CallVoidMethod__entry, env, obj, methodID);
a61af66fc99e Initial load
duke
parents:
diff changeset
1416 DT_VOID_RETURN_MARK(CallVoidMethod);
a61af66fc99e Initial load
duke
parents:
diff changeset
1417
a61af66fc99e Initial load
duke
parents:
diff changeset
1418 va_list args;
a61af66fc99e Initial load
duke
parents:
diff changeset
1419 va_start(args, methodID);
a61af66fc99e Initial load
duke
parents:
diff changeset
1420 JavaValue jvalue(T_VOID);
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1421 JNI_ArgumentPusherVaArg ap(methodID, args);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1422 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK);
a61af66fc99e Initial load
duke
parents:
diff changeset
1423 va_end(args);
a61af66fc99e Initial load
duke
parents:
diff changeset
1424 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
1425
a61af66fc99e Initial load
duke
parents:
diff changeset
1426
a61af66fc99e Initial load
duke
parents:
diff changeset
1427 JNI_ENTRY(void, jni_CallVoidMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args))
a61af66fc99e Initial load
duke
parents:
diff changeset
1428 JNIWrapper("CallVoidMethodV");
a61af66fc99e Initial load
duke
parents:
diff changeset
1429 DTRACE_PROBE3(hotspot_jni, CallVoidMethodV__entry, env, obj, methodID);
a61af66fc99e Initial load
duke
parents:
diff changeset
1430 DT_VOID_RETURN_MARK(CallVoidMethodV);
a61af66fc99e Initial load
duke
parents:
diff changeset
1431
a61af66fc99e Initial load
duke
parents:
diff changeset
1432 JavaValue jvalue(T_VOID);
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1433 JNI_ArgumentPusherVaArg ap(methodID, args);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1434 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK);
a61af66fc99e Initial load
duke
parents:
diff changeset
1435 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
1436
a61af66fc99e Initial load
duke
parents:
diff changeset
1437
a61af66fc99e Initial load
duke
parents:
diff changeset
1438 JNI_ENTRY(void, jni_CallVoidMethodA(JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args))
a61af66fc99e Initial load
duke
parents:
diff changeset
1439 JNIWrapper("CallVoidMethodA");
a61af66fc99e Initial load
duke
parents:
diff changeset
1440 DTRACE_PROBE3(hotspot_jni, CallVoidMethodA__entry, env, obj, methodID);
a61af66fc99e Initial load
duke
parents:
diff changeset
1441 DT_VOID_RETURN_MARK(CallVoidMethodA);
a61af66fc99e Initial load
duke
parents:
diff changeset
1442
a61af66fc99e Initial load
duke
parents:
diff changeset
1443 JavaValue jvalue(T_VOID);
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1444 JNI_ArgumentPusherArray ap(methodID, args);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1445 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK);
a61af66fc99e Initial load
duke
parents:
diff changeset
1446 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
1447
a61af66fc99e Initial load
duke
parents:
diff changeset
1448
a61af66fc99e Initial load
duke
parents:
diff changeset
1449 #define DEFINE_CALLNONVIRTUALMETHOD(ResultType, Result, Tag) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1450 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1451 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##Method, ResultType);\
a61af66fc99e Initial load
duke
parents:
diff changeset
1452 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##MethodV, ResultType);\
a61af66fc99e Initial load
duke
parents:
diff changeset
1453 DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##MethodA, ResultType);\
a61af66fc99e Initial load
duke
parents:
diff changeset
1454 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1455 JNI_ENTRY(ResultType, \
a61af66fc99e Initial load
duke
parents:
diff changeset
1456 jni_CallNonvirtual##Result##Method(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, ...)) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1457 JNIWrapper("CallNonvitual" XSTR(Result) "Method"); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1458 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1459 DTRACE_PROBE4(hotspot_jni, CallNonvirtual##Result##Method__entry, env, obj, cls, methodID);\
a61af66fc99e Initial load
duke
parents:
diff changeset
1460 ResultType ret;\
a61af66fc99e Initial load
duke
parents:
diff changeset
1461 DT_RETURN_MARK_FOR(Result, CallNonvirtual##Result##Method, ResultType, \
a61af66fc99e Initial load
duke
parents:
diff changeset
1462 (const ResultType&)ret);\
a61af66fc99e Initial load
duke
parents:
diff changeset
1463 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1464 va_list args; \
a61af66fc99e Initial load
duke
parents:
diff changeset
1465 va_start(args, methodID); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1466 JavaValue jvalue(Tag); \
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1467 JNI_ArgumentPusherVaArg ap(methodID, args); \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1468 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1469 va_end(args); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1470 ret = jvalue.get_##ResultType(); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1471 return ret;\
a61af66fc99e Initial load
duke
parents:
diff changeset
1472 JNI_END \
a61af66fc99e Initial load
duke
parents:
diff changeset
1473 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1474 JNI_ENTRY(ResultType, \
a61af66fc99e Initial load
duke
parents:
diff changeset
1475 jni_CallNonvirtual##Result##MethodV(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, va_list args)) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1476 JNIWrapper("CallNonvitual" XSTR(Result) "#MethodV"); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1477 DTRACE_PROBE4(hotspot_jni, CallNonvirtual##Result##MethodV__entry, env, obj, cls, methodID);\
a61af66fc99e Initial load
duke
parents:
diff changeset
1478 ResultType ret;\
a61af66fc99e Initial load
duke
parents:
diff changeset
1479 DT_RETURN_MARK_FOR(Result, CallNonvirtual##Result##MethodV, ResultType, \
a61af66fc99e Initial load
duke
parents:
diff changeset
1480 (const ResultType&)ret);\
a61af66fc99e Initial load
duke
parents:
diff changeset
1481 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1482 JavaValue jvalue(Tag); \
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1483 JNI_ArgumentPusherVaArg ap(methodID, args); \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1484 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1485 ret = jvalue.get_##ResultType(); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1486 return ret;\
a61af66fc99e Initial load
duke
parents:
diff changeset
1487 JNI_END \
a61af66fc99e Initial load
duke
parents:
diff changeset
1488 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1489 JNI_ENTRY(ResultType, \
a61af66fc99e Initial load
duke
parents:
diff changeset
1490 jni_CallNonvirtual##Result##MethodA(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, const jvalue *args)) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1491 JNIWrapper("CallNonvitual" XSTR(Result) "MethodA"); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1492 DTRACE_PROBE4(hotspot_jni, CallNonvirtual##Result##MethodA__entry, env, obj, cls, methodID);\
a61af66fc99e Initial load
duke
parents:
diff changeset
1493 ResultType ret;\
a61af66fc99e Initial load
duke
parents:
diff changeset
1494 DT_RETURN_MARK_FOR(Result, CallNonvirtual##Result##MethodA, ResultType, \
a61af66fc99e Initial load
duke
parents:
diff changeset
1495 (const ResultType&)ret);\
a61af66fc99e Initial load
duke
parents:
diff changeset
1496 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1497 JavaValue jvalue(Tag); \
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1498 JNI_ArgumentPusherArray ap(methodID, args); \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1499 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1500 ret = jvalue.get_##ResultType(); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1501 return ret;\
a61af66fc99e Initial load
duke
parents:
diff changeset
1502 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
1503
a61af66fc99e Initial load
duke
parents:
diff changeset
1504 // the runtime type of subword integral basic types is integer
a61af66fc99e Initial load
duke
parents:
diff changeset
1505 DEFINE_CALLNONVIRTUALMETHOD(jboolean, Boolean, T_BOOLEAN)
a61af66fc99e Initial load
duke
parents:
diff changeset
1506 DEFINE_CALLNONVIRTUALMETHOD(jbyte, Byte, T_BYTE)
a61af66fc99e Initial load
duke
parents:
diff changeset
1507 DEFINE_CALLNONVIRTUALMETHOD(jchar, Char, T_CHAR)
a61af66fc99e Initial load
duke
parents:
diff changeset
1508 DEFINE_CALLNONVIRTUALMETHOD(jshort, Short, T_SHORT)
a61af66fc99e Initial load
duke
parents:
diff changeset
1509
a61af66fc99e Initial load
duke
parents:
diff changeset
1510 DEFINE_CALLNONVIRTUALMETHOD(jobject, Object, T_OBJECT)
a61af66fc99e Initial load
duke
parents:
diff changeset
1511 DEFINE_CALLNONVIRTUALMETHOD(jint, Int, T_INT)
a61af66fc99e Initial load
duke
parents:
diff changeset
1512 DEFINE_CALLNONVIRTUALMETHOD(jlong, Long, T_LONG)
a61af66fc99e Initial load
duke
parents:
diff changeset
1513 DEFINE_CALLNONVIRTUALMETHOD(jfloat, Float, T_FLOAT)
a61af66fc99e Initial load
duke
parents:
diff changeset
1514 DEFINE_CALLNONVIRTUALMETHOD(jdouble, Double, T_DOUBLE)
a61af66fc99e Initial load
duke
parents:
diff changeset
1515
a61af66fc99e Initial load
duke
parents:
diff changeset
1516
a61af66fc99e Initial load
duke
parents:
diff changeset
1517 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethod);
a61af66fc99e Initial load
duke
parents:
diff changeset
1518 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodV);
a61af66fc99e Initial load
duke
parents:
diff changeset
1519 DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodA);
a61af66fc99e Initial load
duke
parents:
diff changeset
1520
a61af66fc99e Initial load
duke
parents:
diff changeset
1521 JNI_ENTRY(void, jni_CallNonvirtualVoidMethod(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, ...))
a61af66fc99e Initial load
duke
parents:
diff changeset
1522 JNIWrapper("CallNonvirtualVoidMethod");
a61af66fc99e Initial load
duke
parents:
diff changeset
1523
a61af66fc99e Initial load
duke
parents:
diff changeset
1524 DTRACE_PROBE4(hotspot_jni, CallNonvirtualVoidMethod__entry,
a61af66fc99e Initial load
duke
parents:
diff changeset
1525 env, obj, cls, methodID);
a61af66fc99e Initial load
duke
parents:
diff changeset
1526 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethod);
a61af66fc99e Initial load
duke
parents:
diff changeset
1527
a61af66fc99e Initial load
duke
parents:
diff changeset
1528 va_list args;
a61af66fc99e Initial load
duke
parents:
diff changeset
1529 va_start(args, methodID);
a61af66fc99e Initial load
duke
parents:
diff changeset
1530 JavaValue jvalue(T_VOID);
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1531 JNI_ArgumentPusherVaArg ap(methodID, args);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1532 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK);
a61af66fc99e Initial load
duke
parents:
diff changeset
1533 va_end(args);
a61af66fc99e Initial load
duke
parents:
diff changeset
1534 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
1535
a61af66fc99e Initial load
duke
parents:
diff changeset
1536
a61af66fc99e Initial load
duke
parents:
diff changeset
1537 JNI_ENTRY(void, jni_CallNonvirtualVoidMethodV(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, va_list args))
a61af66fc99e Initial load
duke
parents:
diff changeset
1538 JNIWrapper("CallNonvirtualVoidMethodV");
a61af66fc99e Initial load
duke
parents:
diff changeset
1539
a61af66fc99e Initial load
duke
parents:
diff changeset
1540 DTRACE_PROBE4(hotspot_jni, CallNonvirtualVoidMethodV__entry,
a61af66fc99e Initial load
duke
parents:
diff changeset
1541 env, obj, cls, methodID);
a61af66fc99e Initial load
duke
parents:
diff changeset
1542 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethodV);
a61af66fc99e Initial load
duke
parents:
diff changeset
1543
a61af66fc99e Initial load
duke
parents:
diff changeset
1544 JavaValue jvalue(T_VOID);
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1545 JNI_ArgumentPusherVaArg ap(methodID, args);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1546 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK);
a61af66fc99e Initial load
duke
parents:
diff changeset
1547 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
1548
a61af66fc99e Initial load
duke
parents:
diff changeset
1549
a61af66fc99e Initial load
duke
parents:
diff changeset
1550 JNI_ENTRY(void, jni_CallNonvirtualVoidMethodA(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, const jvalue *args))
a61af66fc99e Initial load
duke
parents:
diff changeset
1551 JNIWrapper("CallNonvirtualVoidMethodA");
a61af66fc99e Initial load
duke
parents:
diff changeset
1552 DTRACE_PROBE4(hotspot_jni, CallNonvirtualVoidMethodA__entry,
a61af66fc99e Initial load
duke
parents:
diff changeset
1553 env, obj, cls, methodID);
a61af66fc99e Initial load
duke
parents:
diff changeset
1554 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethodA);
a61af66fc99e Initial load
duke
parents:
diff changeset
1555 JavaValue jvalue(T_VOID);
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1556 JNI_ArgumentPusherArray ap(methodID, args);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1557 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK);
a61af66fc99e Initial load
duke
parents:
diff changeset
1558 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
1559
a61af66fc99e Initial load
duke
parents:
diff changeset
1560
a61af66fc99e Initial load
duke
parents:
diff changeset
1561 #define DEFINE_CALLSTATICMETHOD(ResultType, Result, Tag) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1562 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1563 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##Method, ResultType);\
a61af66fc99e Initial load
duke
parents:
diff changeset
1564 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##MethodV, ResultType);\
a61af66fc99e Initial load
duke
parents:
diff changeset
1565 DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##MethodA, ResultType);\
a61af66fc99e Initial load
duke
parents:
diff changeset
1566 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1567 JNI_ENTRY(ResultType, \
a61af66fc99e Initial load
duke
parents:
diff changeset
1568 jni_CallStatic##Result##Method(JNIEnv *env, jclass cls, jmethodID methodID, ...)) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1569 JNIWrapper("CallStatic" XSTR(Result) "Method"); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1570 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1571 DTRACE_PROBE3(hotspot_jni, CallStatic##Result##Method__entry, env, cls, methodID);\
a61af66fc99e Initial load
duke
parents:
diff changeset
1572 ResultType ret = 0;\
a61af66fc99e Initial load
duke
parents:
diff changeset
1573 DT_RETURN_MARK_FOR(Result, CallStatic##Result##Method, ResultType, \
a61af66fc99e Initial load
duke
parents:
diff changeset
1574 (const ResultType&)ret);\
a61af66fc99e Initial load
duke
parents:
diff changeset
1575 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1576 va_list args; \
a61af66fc99e Initial load
duke
parents:
diff changeset
1577 va_start(args, methodID); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1578 JavaValue jvalue(Tag); \
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1579 JNI_ArgumentPusherVaArg ap(methodID, args); \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1580 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK_0); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1581 va_end(args); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1582 ret = jvalue.get_##ResultType(); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1583 return ret;\
a61af66fc99e Initial load
duke
parents:
diff changeset
1584 JNI_END \
a61af66fc99e Initial load
duke
parents:
diff changeset
1585 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1586 JNI_ENTRY(ResultType, \
a61af66fc99e Initial load
duke
parents:
diff changeset
1587 jni_CallStatic##Result##MethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args)) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1588 JNIWrapper("CallStatic" XSTR(Result) "MethodV"); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1589 DTRACE_PROBE3(hotspot_jni, CallStatic##Result##MethodV__entry, env, cls, methodID);\
a61af66fc99e Initial load
duke
parents:
diff changeset
1590 ResultType ret = 0;\
a61af66fc99e Initial load
duke
parents:
diff changeset
1591 DT_RETURN_MARK_FOR(Result, CallStatic##Result##MethodV, ResultType, \
a61af66fc99e Initial load
duke
parents:
diff changeset
1592 (const ResultType&)ret);\
a61af66fc99e Initial load
duke
parents:
diff changeset
1593 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1594 JavaValue jvalue(Tag); \
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1595 JNI_ArgumentPusherVaArg ap(methodID, args); \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1596 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK_0); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1597 ret = jvalue.get_##ResultType(); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1598 return ret;\
a61af66fc99e Initial load
duke
parents:
diff changeset
1599 JNI_END \
a61af66fc99e Initial load
duke
parents:
diff changeset
1600 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1601 JNI_ENTRY(ResultType, \
a61af66fc99e Initial load
duke
parents:
diff changeset
1602 jni_CallStatic##Result##MethodA(JNIEnv *env, jclass cls, jmethodID methodID, const jvalue *args)) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1603 JNIWrapper("CallStatic" XSTR(Result) "MethodA"); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1604 DTRACE_PROBE3(hotspot_jni, CallStatic##Result##MethodA__entry, env, cls, methodID);\
a61af66fc99e Initial load
duke
parents:
diff changeset
1605 ResultType ret = 0;\
a61af66fc99e Initial load
duke
parents:
diff changeset
1606 DT_RETURN_MARK_FOR(Result, CallStatic##Result##MethodA, ResultType, \
a61af66fc99e Initial load
duke
parents:
diff changeset
1607 (const ResultType&)ret);\
a61af66fc99e Initial load
duke
parents:
diff changeset
1608 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1609 JavaValue jvalue(Tag); \
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1610 JNI_ArgumentPusherArray ap(methodID, args); \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1611 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK_0); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1612 ret = jvalue.get_##ResultType(); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1613 return ret;\
a61af66fc99e Initial load
duke
parents:
diff changeset
1614 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
1615
a61af66fc99e Initial load
duke
parents:
diff changeset
1616 // the runtime type of subword integral basic types is integer
a61af66fc99e Initial load
duke
parents:
diff changeset
1617 DEFINE_CALLSTATICMETHOD(jboolean, Boolean, T_BOOLEAN)
a61af66fc99e Initial load
duke
parents:
diff changeset
1618 DEFINE_CALLSTATICMETHOD(jbyte, Byte, T_BYTE)
a61af66fc99e Initial load
duke
parents:
diff changeset
1619 DEFINE_CALLSTATICMETHOD(jchar, Char, T_CHAR)
a61af66fc99e Initial load
duke
parents:
diff changeset
1620 DEFINE_CALLSTATICMETHOD(jshort, Short, T_SHORT)
a61af66fc99e Initial load
duke
parents:
diff changeset
1621
a61af66fc99e Initial load
duke
parents:
diff changeset
1622 DEFINE_CALLSTATICMETHOD(jobject, Object, T_OBJECT)
a61af66fc99e Initial load
duke
parents:
diff changeset
1623 DEFINE_CALLSTATICMETHOD(jint, Int, T_INT)
a61af66fc99e Initial load
duke
parents:
diff changeset
1624 DEFINE_CALLSTATICMETHOD(jlong, Long, T_LONG)
a61af66fc99e Initial load
duke
parents:
diff changeset
1625 DEFINE_CALLSTATICMETHOD(jfloat, Float, T_FLOAT)
a61af66fc99e Initial load
duke
parents:
diff changeset
1626 DEFINE_CALLSTATICMETHOD(jdouble, Double, T_DOUBLE)
a61af66fc99e Initial load
duke
parents:
diff changeset
1627
a61af66fc99e Initial load
duke
parents:
diff changeset
1628
a61af66fc99e Initial load
duke
parents:
diff changeset
1629 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethod);
a61af66fc99e Initial load
duke
parents:
diff changeset
1630 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodV);
a61af66fc99e Initial load
duke
parents:
diff changeset
1631 DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodA);
a61af66fc99e Initial load
duke
parents:
diff changeset
1632
a61af66fc99e Initial load
duke
parents:
diff changeset
1633 JNI_ENTRY(void, jni_CallStaticVoidMethod(JNIEnv *env, jclass cls, jmethodID methodID, ...))
a61af66fc99e Initial load
duke
parents:
diff changeset
1634 JNIWrapper("CallStaticVoidMethod");
a61af66fc99e Initial load
duke
parents:
diff changeset
1635 DTRACE_PROBE3(hotspot_jni, CallStaticVoidMethod__entry, env, cls, methodID);
a61af66fc99e Initial load
duke
parents:
diff changeset
1636 DT_VOID_RETURN_MARK(CallStaticVoidMethod);
a61af66fc99e Initial load
duke
parents:
diff changeset
1637
a61af66fc99e Initial load
duke
parents:
diff changeset
1638 va_list args;
a61af66fc99e Initial load
duke
parents:
diff changeset
1639 va_start(args, methodID);
a61af66fc99e Initial load
duke
parents:
diff changeset
1640 JavaValue jvalue(T_VOID);
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1641 JNI_ArgumentPusherVaArg ap(methodID, args);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1642 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK);
a61af66fc99e Initial load
duke
parents:
diff changeset
1643 va_end(args);
a61af66fc99e Initial load
duke
parents:
diff changeset
1644 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
1645
a61af66fc99e Initial load
duke
parents:
diff changeset
1646
a61af66fc99e Initial load
duke
parents:
diff changeset
1647 JNI_ENTRY(void, jni_CallStaticVoidMethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args))
a61af66fc99e Initial load
duke
parents:
diff changeset
1648 JNIWrapper("CallStaticVoidMethodV");
a61af66fc99e Initial load
duke
parents:
diff changeset
1649 DTRACE_PROBE3(hotspot_jni, CallStaticVoidMethodV__entry, env, cls, methodID);
a61af66fc99e Initial load
duke
parents:
diff changeset
1650 DT_VOID_RETURN_MARK(CallStaticVoidMethodV);
a61af66fc99e Initial load
duke
parents:
diff changeset
1651
a61af66fc99e Initial load
duke
parents:
diff changeset
1652 JavaValue jvalue(T_VOID);
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1653 JNI_ArgumentPusherVaArg ap(methodID, args);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1654 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK);
a61af66fc99e Initial load
duke
parents:
diff changeset
1655 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
1656
a61af66fc99e Initial load
duke
parents:
diff changeset
1657
a61af66fc99e Initial load
duke
parents:
diff changeset
1658 JNI_ENTRY(void, jni_CallStaticVoidMethodA(JNIEnv *env, jclass cls, jmethodID methodID, const jvalue *args))
a61af66fc99e Initial load
duke
parents:
diff changeset
1659 JNIWrapper("CallStaticVoidMethodA");
a61af66fc99e Initial load
duke
parents:
diff changeset
1660 DTRACE_PROBE3(hotspot_jni, CallStaticVoidMethodA__entry, env, cls, methodID);
a61af66fc99e Initial load
duke
parents:
diff changeset
1661 DT_VOID_RETURN_MARK(CallStaticVoidMethodA);
a61af66fc99e Initial load
duke
parents:
diff changeset
1662
a61af66fc99e Initial load
duke
parents:
diff changeset
1663 JavaValue jvalue(T_VOID);
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1664 JNI_ArgumentPusherArray ap(methodID, args);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1665 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK);
a61af66fc99e Initial load
duke
parents:
diff changeset
1666 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
1667
a61af66fc99e Initial load
duke
parents:
diff changeset
1668
a61af66fc99e Initial load
duke
parents:
diff changeset
1669 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1670 // Accessing Fields
a61af66fc99e Initial load
duke
parents:
diff changeset
1671 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1672
a61af66fc99e Initial load
duke
parents:
diff changeset
1673
a61af66fc99e Initial load
duke
parents:
diff changeset
1674 DT_RETURN_MARK_DECL(GetFieldID, jfieldID);
a61af66fc99e Initial load
duke
parents:
diff changeset
1675
a61af66fc99e Initial load
duke
parents:
diff changeset
1676 JNI_ENTRY(jfieldID, jni_GetFieldID(JNIEnv *env, jclass clazz,
a61af66fc99e Initial load
duke
parents:
diff changeset
1677 const char *name, const char *sig))
a61af66fc99e Initial load
duke
parents:
diff changeset
1678 JNIWrapper("GetFieldID");
a61af66fc99e Initial load
duke
parents:
diff changeset
1679 DTRACE_PROBE4(hotspot_jni, GetFieldID__entry, env, clazz, name, sig);
a61af66fc99e Initial load
duke
parents:
diff changeset
1680 jfieldID ret = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
1681 DT_RETURN_MARK(GetFieldID, jfieldID, (const jfieldID&)ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
1682
a61af66fc99e Initial load
duke
parents:
diff changeset
1683 // The class should have been loaded (we have an instance of the class
a61af66fc99e Initial load
duke
parents:
diff changeset
1684 // passed in) so the field and signature should already be in the symbol
a61af66fc99e Initial load
duke
parents:
diff changeset
1685 // table. If they're not there, the field doesn't exist.
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1686 TempNewSymbol fieldname = SymbolTable::probe(name, (int)strlen(name));
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1687 TempNewSymbol signame = SymbolTable::probe(sig, (int)strlen(sig));
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1688 if (fieldname == NULL || signame == NULL) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1689 THROW_MSG_0(vmSymbols::java_lang_NoSuchFieldError(), (char*) name);
a61af66fc99e Initial load
duke
parents:
diff changeset
1690 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1691 KlassHandle k(THREAD,
a61af66fc99e Initial load
duke
parents:
diff changeset
1692 java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(clazz)));
a61af66fc99e Initial load
duke
parents:
diff changeset
1693 // Make sure class is initialized before handing id's out to fields
a61af66fc99e Initial load
duke
parents:
diff changeset
1694 Klass::cast(k())->initialize(CHECK_NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
1695
a61af66fc99e Initial load
duke
parents:
diff changeset
1696 fieldDescriptor fd;
a61af66fc99e Initial load
duke
parents:
diff changeset
1697 if (!Klass::cast(k())->oop_is_instance() ||
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1698 !instanceKlass::cast(k())->find_field(fieldname, signame, false, &fd)) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1699 THROW_MSG_0(vmSymbols::java_lang_NoSuchFieldError(), (char*) name);
a61af66fc99e Initial load
duke
parents:
diff changeset
1700 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1701
a61af66fc99e Initial load
duke
parents:
diff changeset
1702 // A jfieldID for a non-static field is simply the offset of the field within the instanceOop
a61af66fc99e Initial load
duke
parents:
diff changeset
1703 // It may also have hash bits for k, if VerifyJNIFields is turned on.
a61af66fc99e Initial load
duke
parents:
diff changeset
1704 ret = jfieldIDWorkaround::to_instance_jfieldID(k(), fd.offset());
a61af66fc99e Initial load
duke
parents:
diff changeset
1705 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
1706 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
1707
a61af66fc99e Initial load
duke
parents:
diff changeset
1708
a61af66fc99e Initial load
duke
parents:
diff changeset
1709 JNI_ENTRY(jobject, jni_GetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID))
a61af66fc99e Initial load
duke
parents:
diff changeset
1710 JNIWrapper("GetObjectField");
a61af66fc99e Initial load
duke
parents:
diff changeset
1711 DTRACE_PROBE3(hotspot_jni, GetObjectField__entry, env, obj, fieldID);
a61af66fc99e Initial load
duke
parents:
diff changeset
1712 oop o = JNIHandles::resolve_non_null(obj);
a61af66fc99e Initial load
duke
parents:
diff changeset
1713 klassOop k = o->klass();
a61af66fc99e Initial load
duke
parents:
diff changeset
1714 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID);
a61af66fc99e Initial load
duke
parents:
diff changeset
1715 // Keep JVMTI addition small and only check enabled flag here.
a61af66fc99e Initial load
duke
parents:
diff changeset
1716 // jni_GetField_probe() assumes that is okay to create handles.
a61af66fc99e Initial load
duke
parents:
diff changeset
1717 if (JvmtiExport::should_post_field_access()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1718 o = JvmtiExport::jni_GetField_probe(thread, obj, o, k, fieldID, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
1719 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1720 jobject ret = JNIHandles::make_local(env, o->obj_field(offset));
3249
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2376
diff changeset
1721 #ifndef SERIALGC
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2376
diff changeset
1722 // If G1 is enabled and we are accessing the value of the referent
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2376
diff changeset
1723 // field in a reference object then we need to register a non-null
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2376
diff changeset
1724 // referent with the SATB barrier.
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2376
diff changeset
1725 if (UseG1GC) {
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2376
diff changeset
1726 bool needs_barrier = false;
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2376
diff changeset
1727
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2376
diff changeset
1728 if (ret != NULL &&
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2376
diff changeset
1729 offset == java_lang_ref_Reference::referent_offset &&
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2376
diff changeset
1730 instanceKlass::cast(k)->reference_type() != REF_NONE) {
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2376
diff changeset
1731 assert(instanceKlass::cast(k)->is_subclass_of(SystemDictionary::Reference_klass()), "sanity");
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2376
diff changeset
1732 needs_barrier = true;
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2376
diff changeset
1733 }
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2376
diff changeset
1734
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2376
diff changeset
1735 if (needs_barrier) {
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2376
diff changeset
1736 oop referent = JNIHandles::resolve(ret);
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2376
diff changeset
1737 G1SATBCardTableModRefBS::enqueue(referent);
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2376
diff changeset
1738 }
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2376
diff changeset
1739 }
e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 2376
diff changeset
1740 #endif // SERIALGC
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1741 DTRACE_PROBE1(hotspot_jni, GetObjectField__return, ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
1742 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
1743 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
1744
a61af66fc99e Initial load
duke
parents:
diff changeset
1745
a61af66fc99e Initial load
duke
parents:
diff changeset
1746 #define DEFINE_GETFIELD(Return,Fieldname,Result) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1747 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1748 DT_RETURN_MARK_DECL_FOR(Result, Get##Result##Field, Return);\
a61af66fc99e Initial load
duke
parents:
diff changeset
1749 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1750 JNI_QUICK_ENTRY(Return, jni_Get##Result##Field(JNIEnv *env, jobject obj, jfieldID fieldID)) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1751 JNIWrapper("Get" XSTR(Result) "Field"); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1752 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1753 DTRACE_PROBE3(hotspot_jni, Get##Result##Field__entry, env, obj, fieldID);\
a61af66fc99e Initial load
duke
parents:
diff changeset
1754 Return ret = 0;\
a61af66fc99e Initial load
duke
parents:
diff changeset
1755 DT_RETURN_MARK_FOR(Result, Get##Result##Field, Return, (const Return&)ret);\
a61af66fc99e Initial load
duke
parents:
diff changeset
1756 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1757 oop o = JNIHandles::resolve_non_null(obj); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1758 klassOop k = o->klass(); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1759 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1760 /* Keep JVMTI addition small and only check enabled flag here. */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1761 /* jni_GetField_probe_nh() assumes that is not okay to create handles */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1762 /* and creates a ResetNoHandleMark. */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1763 if (JvmtiExport::should_post_field_access()) { \
a61af66fc99e Initial load
duke
parents:
diff changeset
1764 o = JvmtiExport::jni_GetField_probe_nh(thread, obj, o, k, fieldID, false); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1765 } \
a61af66fc99e Initial load
duke
parents:
diff changeset
1766 ret = o->Fieldname##_field(offset); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1767 return ret; \
a61af66fc99e Initial load
duke
parents:
diff changeset
1768 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
1769
a61af66fc99e Initial load
duke
parents:
diff changeset
1770 DEFINE_GETFIELD(jboolean, bool, Boolean)
a61af66fc99e Initial load
duke
parents:
diff changeset
1771 DEFINE_GETFIELD(jbyte, byte, Byte)
a61af66fc99e Initial load
duke
parents:
diff changeset
1772 DEFINE_GETFIELD(jchar, char, Char)
a61af66fc99e Initial load
duke
parents:
diff changeset
1773 DEFINE_GETFIELD(jshort, short, Short)
a61af66fc99e Initial load
duke
parents:
diff changeset
1774 DEFINE_GETFIELD(jint, int, Int)
a61af66fc99e Initial load
duke
parents:
diff changeset
1775 DEFINE_GETFIELD(jlong, long, Long)
a61af66fc99e Initial load
duke
parents:
diff changeset
1776 DEFINE_GETFIELD(jfloat, float, Float)
a61af66fc99e Initial load
duke
parents:
diff changeset
1777 DEFINE_GETFIELD(jdouble, double, Double)
a61af66fc99e Initial load
duke
parents:
diff changeset
1778
a61af66fc99e Initial load
duke
parents:
diff changeset
1779 address jni_GetBooleanField_addr() {
a61af66fc99e Initial load
duke
parents:
diff changeset
1780 return (address)jni_GetBooleanField;
a61af66fc99e Initial load
duke
parents:
diff changeset
1781 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1782 address jni_GetByteField_addr() {
a61af66fc99e Initial load
duke
parents:
diff changeset
1783 return (address)jni_GetByteField;
a61af66fc99e Initial load
duke
parents:
diff changeset
1784 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1785 address jni_GetCharField_addr() {
a61af66fc99e Initial load
duke
parents:
diff changeset
1786 return (address)jni_GetCharField;
a61af66fc99e Initial load
duke
parents:
diff changeset
1787 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1788 address jni_GetShortField_addr() {
a61af66fc99e Initial load
duke
parents:
diff changeset
1789 return (address)jni_GetShortField;
a61af66fc99e Initial load
duke
parents:
diff changeset
1790 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1791 address jni_GetIntField_addr() {
a61af66fc99e Initial load
duke
parents:
diff changeset
1792 return (address)jni_GetIntField;
a61af66fc99e Initial load
duke
parents:
diff changeset
1793 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1794 address jni_GetLongField_addr() {
a61af66fc99e Initial load
duke
parents:
diff changeset
1795 return (address)jni_GetLongField;
a61af66fc99e Initial load
duke
parents:
diff changeset
1796 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1797 address jni_GetFloatField_addr() {
a61af66fc99e Initial load
duke
parents:
diff changeset
1798 return (address)jni_GetFloatField;
a61af66fc99e Initial load
duke
parents:
diff changeset
1799 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1800 address jni_GetDoubleField_addr() {
a61af66fc99e Initial load
duke
parents:
diff changeset
1801 return (address)jni_GetDoubleField;
a61af66fc99e Initial load
duke
parents:
diff changeset
1802 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1803
a61af66fc99e Initial load
duke
parents:
diff changeset
1804 JNI_QUICK_ENTRY(void, jni_SetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID, jobject value))
a61af66fc99e Initial load
duke
parents:
diff changeset
1805 JNIWrapper("SetObjectField");
a61af66fc99e Initial load
duke
parents:
diff changeset
1806 DTRACE_PROBE4(hotspot_jni, SetObjectField__entry, env, obj, fieldID, value);
a61af66fc99e Initial load
duke
parents:
diff changeset
1807 oop o = JNIHandles::resolve_non_null(obj);
a61af66fc99e Initial load
duke
parents:
diff changeset
1808 klassOop k = o->klass();
a61af66fc99e Initial load
duke
parents:
diff changeset
1809 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID);
a61af66fc99e Initial load
duke
parents:
diff changeset
1810 // Keep JVMTI addition small and only check enabled flag here.
a61af66fc99e Initial load
duke
parents:
diff changeset
1811 // jni_SetField_probe_nh() assumes that is not okay to create handles
a61af66fc99e Initial load
duke
parents:
diff changeset
1812 // and creates a ResetNoHandleMark.
a61af66fc99e Initial load
duke
parents:
diff changeset
1813 if (JvmtiExport::should_post_field_modification()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1814 jvalue field_value;
a61af66fc99e Initial load
duke
parents:
diff changeset
1815 field_value.l = value;
a61af66fc99e Initial load
duke
parents:
diff changeset
1816 o = JvmtiExport::jni_SetField_probe_nh(thread, obj, o, k, fieldID, false, 'L', (jvalue *)&field_value);
a61af66fc99e Initial load
duke
parents:
diff changeset
1817 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1818 o->obj_field_put(offset, JNIHandles::resolve(value));
a61af66fc99e Initial load
duke
parents:
diff changeset
1819 DTRACE_PROBE(hotspot_jni, SetObjectField__return);
a61af66fc99e Initial load
duke
parents:
diff changeset
1820 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
1821
a61af66fc99e Initial load
duke
parents:
diff changeset
1822 #define DEFINE_SETFIELD(Argument,Fieldname,Result,SigType,unionType) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1823 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1824 JNI_QUICK_ENTRY(void, jni_Set##Result##Field(JNIEnv *env, jobject obj, jfieldID fieldID, Argument value)) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1825 JNIWrapper("Set" XSTR(Result) "Field"); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1826 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1827 HS_DTRACE_PROBE_CDECL_N(hotspot_jni, Set##Result##Field__entry, \
a61af66fc99e Initial load
duke
parents:
diff changeset
1828 ( JNIEnv*, jobject, jfieldID FP_SELECT_##Result(COMMA Argument,/*empty*/) ) ); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1829 HS_DTRACE_PROBE_N(hotspot_jni, Set##Result##Field__entry, \
a61af66fc99e Initial load
duke
parents:
diff changeset
1830 ( env, obj, fieldID FP_SELECT_##Result(COMMA value,/*empty*/) ) ); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1831 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1832 oop o = JNIHandles::resolve_non_null(obj); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1833 klassOop k = o->klass(); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1834 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1835 /* Keep JVMTI addition small and only check enabled flag here. */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1836 /* jni_SetField_probe_nh() assumes that is not okay to create handles */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1837 /* and creates a ResetNoHandleMark. */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1838 if (JvmtiExport::should_post_field_modification()) { \
a61af66fc99e Initial load
duke
parents:
diff changeset
1839 jvalue field_value; \
a61af66fc99e Initial load
duke
parents:
diff changeset
1840 field_value.unionType = value; \
a61af66fc99e Initial load
duke
parents:
diff changeset
1841 o = JvmtiExport::jni_SetField_probe_nh(thread, obj, o, k, fieldID, false, SigType, (jvalue *)&field_value); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1842 } \
a61af66fc99e Initial load
duke
parents:
diff changeset
1843 o->Fieldname##_field_put(offset, value); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1844 DTRACE_PROBE(hotspot_jni, Set##Result##Field__return);\
a61af66fc99e Initial load
duke
parents:
diff changeset
1845 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
1846
a61af66fc99e Initial load
duke
parents:
diff changeset
1847 DEFINE_SETFIELD(jboolean, bool, Boolean, 'Z', z)
a61af66fc99e Initial load
duke
parents:
diff changeset
1848 DEFINE_SETFIELD(jbyte, byte, Byte, 'B', b)
a61af66fc99e Initial load
duke
parents:
diff changeset
1849 DEFINE_SETFIELD(jchar, char, Char, 'C', c)
a61af66fc99e Initial load
duke
parents:
diff changeset
1850 DEFINE_SETFIELD(jshort, short, Short, 'S', s)
a61af66fc99e Initial load
duke
parents:
diff changeset
1851 DEFINE_SETFIELD(jint, int, Int, 'I', i)
a61af66fc99e Initial load
duke
parents:
diff changeset
1852 DEFINE_SETFIELD(jlong, long, Long, 'J', j)
a61af66fc99e Initial load
duke
parents:
diff changeset
1853 DEFINE_SETFIELD(jfloat, float, Float, 'F', f)
a61af66fc99e Initial load
duke
parents:
diff changeset
1854 DEFINE_SETFIELD(jdouble, double, Double, 'D', d)
a61af66fc99e Initial load
duke
parents:
diff changeset
1855
a61af66fc99e Initial load
duke
parents:
diff changeset
1856 DT_RETURN_MARK_DECL(ToReflectedField, jobject);
a61af66fc99e Initial load
duke
parents:
diff changeset
1857
a61af66fc99e Initial load
duke
parents:
diff changeset
1858 JNI_ENTRY(jobject, jni_ToReflectedField(JNIEnv *env, jclass cls, jfieldID fieldID, jboolean isStatic))
a61af66fc99e Initial load
duke
parents:
diff changeset
1859 JNIWrapper("ToReflectedField");
a61af66fc99e Initial load
duke
parents:
diff changeset
1860 DTRACE_PROBE4(hotspot_jni, ToReflectedField__entry,
a61af66fc99e Initial load
duke
parents:
diff changeset
1861 env, cls, fieldID, isStatic);
a61af66fc99e Initial load
duke
parents:
diff changeset
1862 jobject ret = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
1863 DT_RETURN_MARK(ToReflectedField, jobject, (const jobject&)ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
1864
a61af66fc99e Initial load
duke
parents:
diff changeset
1865 fieldDescriptor fd;
a61af66fc99e Initial load
duke
parents:
diff changeset
1866 bool found = false;
a61af66fc99e Initial load
duke
parents:
diff changeset
1867 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));
a61af66fc99e Initial load
duke
parents:
diff changeset
1868
a61af66fc99e Initial load
duke
parents:
diff changeset
1869 assert(jfieldIDWorkaround::is_static_jfieldID(fieldID) == (isStatic != 0), "invalid fieldID");
a61af66fc99e Initial load
duke
parents:
diff changeset
1870
a61af66fc99e Initial load
duke
parents:
diff changeset
1871 if (isStatic) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1872 // Static field. The fieldID a JNIid specifying the field holder and the offset within the klassOop.
a61af66fc99e Initial load
duke
parents:
diff changeset
1873 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID);
a61af66fc99e Initial load
duke
parents:
diff changeset
1874 assert(id->is_static_field_id(), "invalid static field id");
2376
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 2177
diff changeset
1875 found = id->find_local_field(&fd);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1876 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
1877 // Non-static field. The fieldID is really the offset of the field within the instanceOop.
a61af66fc99e Initial load
duke
parents:
diff changeset
1878 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID);
a61af66fc99e Initial load
duke
parents:
diff changeset
1879 found = instanceKlass::cast(k)->find_field_from_offset(offset, false, &fd);
a61af66fc99e Initial load
duke
parents:
diff changeset
1880 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1881 assert(found, "bad fieldID passed into jni_ToReflectedField");
a61af66fc99e Initial load
duke
parents:
diff changeset
1882 oop reflected = Reflection::new_field(&fd, UseNewReflection, CHECK_NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
1883 ret = JNIHandles::make_local(env, reflected);
a61af66fc99e Initial load
duke
parents:
diff changeset
1884 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
1885 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
1886
a61af66fc99e Initial load
duke
parents:
diff changeset
1887
a61af66fc99e Initial load
duke
parents:
diff changeset
1888 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1889 // Accessing Static Fields
a61af66fc99e Initial load
duke
parents:
diff changeset
1890 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1891 DT_RETURN_MARK_DECL(GetStaticFieldID, jfieldID);
a61af66fc99e Initial load
duke
parents:
diff changeset
1892
a61af66fc99e Initial load
duke
parents:
diff changeset
1893 JNI_ENTRY(jfieldID, jni_GetStaticFieldID(JNIEnv *env, jclass clazz,
a61af66fc99e Initial load
duke
parents:
diff changeset
1894 const char *name, const char *sig))
a61af66fc99e Initial load
duke
parents:
diff changeset
1895 JNIWrapper("GetStaticFieldID");
a61af66fc99e Initial load
duke
parents:
diff changeset
1896 DTRACE_PROBE4(hotspot_jni, GetStaticFieldID__entry, env, clazz, name, sig);
a61af66fc99e Initial load
duke
parents:
diff changeset
1897 jfieldID ret = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
1898 DT_RETURN_MARK(GetStaticFieldID, jfieldID, (const jfieldID&)ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
1899
a61af66fc99e Initial load
duke
parents:
diff changeset
1900 // The class should have been loaded (we have an instance of the class
a61af66fc99e Initial load
duke
parents:
diff changeset
1901 // passed in) so the field and signature should already be in the symbol
a61af66fc99e Initial load
duke
parents:
diff changeset
1902 // table. If they're not there, the field doesn't exist.
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1903 TempNewSymbol fieldname = SymbolTable::probe(name, (int)strlen(name));
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1904 TempNewSymbol signame = SymbolTable::probe(sig, (int)strlen(sig));
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1905 if (fieldname == NULL || signame == NULL) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1906 THROW_MSG_0(vmSymbols::java_lang_NoSuchFieldError(), (char*) name);
a61af66fc99e Initial load
duke
parents:
diff changeset
1907 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1908 KlassHandle k(THREAD,
a61af66fc99e Initial load
duke
parents:
diff changeset
1909 java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(clazz)));
a61af66fc99e Initial load
duke
parents:
diff changeset
1910 // Make sure class is initialized before handing id's out to static fields
a61af66fc99e Initial load
duke
parents:
diff changeset
1911 Klass::cast(k())->initialize(CHECK_NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
1912
a61af66fc99e Initial load
duke
parents:
diff changeset
1913 fieldDescriptor fd;
a61af66fc99e Initial load
duke
parents:
diff changeset
1914 if (!Klass::cast(k())->oop_is_instance() ||
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
1915 !instanceKlass::cast(k())->find_field(fieldname, signame, true, &fd)) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1916 THROW_MSG_0(vmSymbols::java_lang_NoSuchFieldError(), (char*) name);
a61af66fc99e Initial load
duke
parents:
diff changeset
1917 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1918
a61af66fc99e Initial load
duke
parents:
diff changeset
1919 // A jfieldID for a static field is a JNIid specifying the field holder and the offset within the klassOop
a61af66fc99e Initial load
duke
parents:
diff changeset
1920 JNIid* id = instanceKlass::cast(fd.field_holder())->jni_id_for(fd.offset());
a61af66fc99e Initial load
duke
parents:
diff changeset
1921 debug_only(id->set_is_static_field_id();)
a61af66fc99e Initial load
duke
parents:
diff changeset
1922
2376
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 2177
diff changeset
1923 debug_only(id->verify(fd.field_holder()));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1924
a61af66fc99e Initial load
duke
parents:
diff changeset
1925 ret = jfieldIDWorkaround::to_static_jfieldID(id);
a61af66fc99e Initial load
duke
parents:
diff changeset
1926 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
1927 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
1928
a61af66fc99e Initial load
duke
parents:
diff changeset
1929
a61af66fc99e Initial load
duke
parents:
diff changeset
1930 JNI_ENTRY(jobject, jni_GetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID))
a61af66fc99e Initial load
duke
parents:
diff changeset
1931 JNIWrapper("GetStaticObjectField");
a61af66fc99e Initial load
duke
parents:
diff changeset
1932 DTRACE_PROBE3(hotspot_jni, GetStaticObjectField__entry, env, clazz, fieldID);
a61af66fc99e Initial load
duke
parents:
diff changeset
1933 #ifndef JNICHECK_KERNEL
a61af66fc99e Initial load
duke
parents:
diff changeset
1934 DEBUG_ONLY(klassOop param_k = jniCheck::validate_class(thread, clazz);)
a61af66fc99e Initial load
duke
parents:
diff changeset
1935 #endif // JNICHECK_KERNEL
a61af66fc99e Initial load
duke
parents:
diff changeset
1936 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID);
a61af66fc99e Initial load
duke
parents:
diff changeset
1937 assert(id->is_static_field_id(), "invalid static field id");
a61af66fc99e Initial load
duke
parents:
diff changeset
1938 // Keep JVMTI addition small and only check enabled flag here.
a61af66fc99e Initial load
duke
parents:
diff changeset
1939 // jni_GetField_probe() assumes that is okay to create handles.
a61af66fc99e Initial load
duke
parents:
diff changeset
1940 if (JvmtiExport::should_post_field_access()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1941 JvmtiExport::jni_GetField_probe(thread, NULL, NULL, id->holder(), fieldID, true);
a61af66fc99e Initial load
duke
parents:
diff changeset
1942 }
2376
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 2177
diff changeset
1943 jobject ret = JNIHandles::make_local(id->holder()->java_mirror()->obj_field(id->offset()));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1944 DTRACE_PROBE1(hotspot_jni, GetStaticObjectField__return, ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
1945 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
1946 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
1947
a61af66fc99e Initial load
duke
parents:
diff changeset
1948 #define DEFINE_GETSTATICFIELD(Return,Fieldname,Result) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1949 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1950 DT_RETURN_MARK_DECL_FOR(Result, GetStatic##Result##Field, Return);\
a61af66fc99e Initial load
duke
parents:
diff changeset
1951 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1952 JNI_ENTRY(Return, jni_GetStatic##Result##Field(JNIEnv *env, jclass clazz, jfieldID fieldID)) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1953 JNIWrapper("GetStatic" XSTR(Result) "Field"); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1954 DTRACE_PROBE3(hotspot_jni, GetStatic##Result##Field__entry, env, clazz, fieldID);\
a61af66fc99e Initial load
duke
parents:
diff changeset
1955 Return ret = 0;\
a61af66fc99e Initial load
duke
parents:
diff changeset
1956 DT_RETURN_MARK_FOR(Result, GetStatic##Result##Field, Return, \
a61af66fc99e Initial load
duke
parents:
diff changeset
1957 (const Return&)ret);\
a61af66fc99e Initial load
duke
parents:
diff changeset
1958 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1959 assert(id->is_static_field_id(), "invalid static field id"); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1960 /* Keep JVMTI addition small and only check enabled flag here. */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1961 /* jni_GetField_probe() assumes that is okay to create handles. */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1962 if (JvmtiExport::should_post_field_access()) { \
a61af66fc99e Initial load
duke
parents:
diff changeset
1963 JvmtiExport::jni_GetField_probe(thread, NULL, NULL, id->holder(), fieldID, true); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1964 } \
2376
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 2177
diff changeset
1965 ret = id->holder()->java_mirror()-> Fieldname##_field (id->offset()); \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1966 return ret;\
a61af66fc99e Initial load
duke
parents:
diff changeset
1967 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
1968
a61af66fc99e Initial load
duke
parents:
diff changeset
1969 DEFINE_GETSTATICFIELD(jboolean, bool, Boolean)
a61af66fc99e Initial load
duke
parents:
diff changeset
1970 DEFINE_GETSTATICFIELD(jbyte, byte, Byte)
a61af66fc99e Initial load
duke
parents:
diff changeset
1971 DEFINE_GETSTATICFIELD(jchar, char, Char)
a61af66fc99e Initial load
duke
parents:
diff changeset
1972 DEFINE_GETSTATICFIELD(jshort, short, Short)
a61af66fc99e Initial load
duke
parents:
diff changeset
1973 DEFINE_GETSTATICFIELD(jint, int, Int)
a61af66fc99e Initial load
duke
parents:
diff changeset
1974 DEFINE_GETSTATICFIELD(jlong, long, Long)
a61af66fc99e Initial load
duke
parents:
diff changeset
1975 DEFINE_GETSTATICFIELD(jfloat, float, Float)
a61af66fc99e Initial load
duke
parents:
diff changeset
1976 DEFINE_GETSTATICFIELD(jdouble, double, Double)
a61af66fc99e Initial load
duke
parents:
diff changeset
1977
a61af66fc99e Initial load
duke
parents:
diff changeset
1978
a61af66fc99e Initial load
duke
parents:
diff changeset
1979 JNI_ENTRY(void, jni_SetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value))
a61af66fc99e Initial load
duke
parents:
diff changeset
1980 JNIWrapper("SetStaticObjectField");
a61af66fc99e Initial load
duke
parents:
diff changeset
1981 DTRACE_PROBE4(hotspot_jni, SetStaticObjectField__entry, env, clazz, fieldID, value);
a61af66fc99e Initial load
duke
parents:
diff changeset
1982 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID);
a61af66fc99e Initial load
duke
parents:
diff changeset
1983 assert(id->is_static_field_id(), "invalid static field id");
a61af66fc99e Initial load
duke
parents:
diff changeset
1984 // Keep JVMTI addition small and only check enabled flag here.
a61af66fc99e Initial load
duke
parents:
diff changeset
1985 // jni_SetField_probe() assumes that is okay to create handles.
a61af66fc99e Initial load
duke
parents:
diff changeset
1986 if (JvmtiExport::should_post_field_modification()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1987 jvalue field_value;
a61af66fc99e Initial load
duke
parents:
diff changeset
1988 field_value.l = value;
a61af66fc99e Initial load
duke
parents:
diff changeset
1989 JvmtiExport::jni_SetField_probe(thread, NULL, NULL, id->holder(), fieldID, true, 'L', (jvalue *)&field_value);
a61af66fc99e Initial load
duke
parents:
diff changeset
1990 }
2376
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 2177
diff changeset
1991 id->holder()->java_mirror()->obj_field_put(id->offset(), JNIHandles::resolve(value));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1992 DTRACE_PROBE(hotspot_jni, SetStaticObjectField__return);
a61af66fc99e Initial load
duke
parents:
diff changeset
1993 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
1994
a61af66fc99e Initial load
duke
parents:
diff changeset
1995
a61af66fc99e Initial load
duke
parents:
diff changeset
1996 #define DEFINE_SETSTATICFIELD(Argument,Fieldname,Result,SigType,unionType) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1997 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1998 JNI_ENTRY(void, jni_SetStatic##Result##Field(JNIEnv *env, jclass clazz, jfieldID fieldID, Argument value)) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1999 JNIWrapper("SetStatic" XSTR(Result) "Field"); \
a61af66fc99e Initial load
duke
parents:
diff changeset
2000 HS_DTRACE_PROBE_CDECL_N(hotspot_jni, SetStatic##Result##Field__entry,\
a61af66fc99e Initial load
duke
parents:
diff changeset
2001 ( JNIEnv*, jclass, jfieldID FP_SELECT_##Result(COMMA Argument,/*empty*/) ) ); \
a61af66fc99e Initial load
duke
parents:
diff changeset
2002 HS_DTRACE_PROBE_N(hotspot_jni, SetStatic##Result##Field__entry, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2003 ( env, clazz, fieldID FP_SELECT_##Result(COMMA value,/*empty*/) ) ); \
a61af66fc99e Initial load
duke
parents:
diff changeset
2004 \
a61af66fc99e Initial load
duke
parents:
diff changeset
2005 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); \
a61af66fc99e Initial load
duke
parents:
diff changeset
2006 assert(id->is_static_field_id(), "invalid static field id"); \
a61af66fc99e Initial load
duke
parents:
diff changeset
2007 /* Keep JVMTI addition small and only check enabled flag here. */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
2008 /* jni_SetField_probe() assumes that is okay to create handles. */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
2009 if (JvmtiExport::should_post_field_modification()) { \
a61af66fc99e Initial load
duke
parents:
diff changeset
2010 jvalue field_value; \
a61af66fc99e Initial load
duke
parents:
diff changeset
2011 field_value.unionType = value; \
a61af66fc99e Initial load
duke
parents:
diff changeset
2012 JvmtiExport::jni_SetField_probe(thread, NULL, NULL, id->holder(), fieldID, true, SigType, (jvalue *)&field_value); \
a61af66fc99e Initial load
duke
parents:
diff changeset
2013 } \
2376
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 2177
diff changeset
2014 id->holder()->java_mirror()-> Fieldname##_field_put (id->offset(), value); \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2015 DTRACE_PROBE(hotspot_jni, SetStatic##Result##Field__return);\
a61af66fc99e Initial load
duke
parents:
diff changeset
2016 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
2017
a61af66fc99e Initial load
duke
parents:
diff changeset
2018 DEFINE_SETSTATICFIELD(jboolean, bool, Boolean, 'Z', z)
a61af66fc99e Initial load
duke
parents:
diff changeset
2019 DEFINE_SETSTATICFIELD(jbyte, byte, Byte, 'B', b)
a61af66fc99e Initial load
duke
parents:
diff changeset
2020 DEFINE_SETSTATICFIELD(jchar, char, Char, 'C', c)
a61af66fc99e Initial load
duke
parents:
diff changeset
2021 DEFINE_SETSTATICFIELD(jshort, short, Short, 'S', s)
a61af66fc99e Initial load
duke
parents:
diff changeset
2022 DEFINE_SETSTATICFIELD(jint, int, Int, 'I', i)
a61af66fc99e Initial load
duke
parents:
diff changeset
2023 DEFINE_SETSTATICFIELD(jlong, long, Long, 'J', j)
a61af66fc99e Initial load
duke
parents:
diff changeset
2024 DEFINE_SETSTATICFIELD(jfloat, float, Float, 'F', f)
a61af66fc99e Initial load
duke
parents:
diff changeset
2025 DEFINE_SETSTATICFIELD(jdouble, double, Double, 'D', d)
a61af66fc99e Initial load
duke
parents:
diff changeset
2026
a61af66fc99e Initial load
duke
parents:
diff changeset
2027
a61af66fc99e Initial load
duke
parents:
diff changeset
2028 //
a61af66fc99e Initial load
duke
parents:
diff changeset
2029 // String Operations
a61af66fc99e Initial load
duke
parents:
diff changeset
2030 //
a61af66fc99e Initial load
duke
parents:
diff changeset
2031
a61af66fc99e Initial load
duke
parents:
diff changeset
2032 // Unicode Interface
a61af66fc99e Initial load
duke
parents:
diff changeset
2033
a61af66fc99e Initial load
duke
parents:
diff changeset
2034 DT_RETURN_MARK_DECL(NewString, jstring);
a61af66fc99e Initial load
duke
parents:
diff changeset
2035
a61af66fc99e Initial load
duke
parents:
diff changeset
2036 JNI_ENTRY(jstring, jni_NewString(JNIEnv *env, const jchar *unicodeChars, jsize len))
a61af66fc99e Initial load
duke
parents:
diff changeset
2037 JNIWrapper("NewString");
a61af66fc99e Initial load
duke
parents:
diff changeset
2038 DTRACE_PROBE3(hotspot_jni, NewString__entry, env, unicodeChars, len);
a61af66fc99e Initial load
duke
parents:
diff changeset
2039 jstring ret = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
2040 DT_RETURN_MARK(NewString, jstring, (const jstring&)ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
2041 oop string=java_lang_String::create_oop_from_unicode((jchar*) unicodeChars, len, CHECK_NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
2042 ret = (jstring) JNIHandles::make_local(env, string);
a61af66fc99e Initial load
duke
parents:
diff changeset
2043 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
2044 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
2045
a61af66fc99e Initial load
duke
parents:
diff changeset
2046
a61af66fc99e Initial load
duke
parents:
diff changeset
2047 JNI_QUICK_ENTRY(jsize, jni_GetStringLength(JNIEnv *env, jstring string))
a61af66fc99e Initial load
duke
parents:
diff changeset
2048 JNIWrapper("GetStringLength");
a61af66fc99e Initial load
duke
parents:
diff changeset
2049 DTRACE_PROBE2(hotspot_jni, GetStringLength__entry, env, string);
a61af66fc99e Initial load
duke
parents:
diff changeset
2050 jsize ret = java_lang_String::length(JNIHandles::resolve_non_null(string));
a61af66fc99e Initial load
duke
parents:
diff changeset
2051 DTRACE_PROBE1(hotspot_jni, GetStringLength__return, ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
2052 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
2053 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
2054
a61af66fc99e Initial load
duke
parents:
diff changeset
2055
a61af66fc99e Initial load
duke
parents:
diff changeset
2056 JNI_QUICK_ENTRY(const jchar*, jni_GetStringChars(
a61af66fc99e Initial load
duke
parents:
diff changeset
2057 JNIEnv *env, jstring string, jboolean *isCopy))
a61af66fc99e Initial load
duke
parents:
diff changeset
2058 JNIWrapper("GetStringChars");
a61af66fc99e Initial load
duke
parents:
diff changeset
2059 DTRACE_PROBE3(hotspot_jni, GetStringChars__entry, env, string, isCopy);
a61af66fc99e Initial load
duke
parents:
diff changeset
2060 //%note jni_5
a61af66fc99e Initial load
duke
parents:
diff changeset
2061 if (isCopy != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2062 *isCopy = JNI_TRUE;
a61af66fc99e Initial load
duke
parents:
diff changeset
2063 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2064 oop s = JNIHandles::resolve_non_null(string);
a61af66fc99e Initial load
duke
parents:
diff changeset
2065 int s_len = java_lang_String::length(s);
a61af66fc99e Initial load
duke
parents:
diff changeset
2066 typeArrayOop s_value = java_lang_String::value(s);
a61af66fc99e Initial load
duke
parents:
diff changeset
2067 int s_offset = java_lang_String::offset(s);
a61af66fc99e Initial load
duke
parents:
diff changeset
2068 jchar* buf = NEW_C_HEAP_ARRAY(jchar, s_len + 1); // add one for zero termination
a61af66fc99e Initial load
duke
parents:
diff changeset
2069 if (s_len > 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2070 memcpy(buf, s_value->char_at_addr(s_offset), sizeof(jchar)*s_len);
a61af66fc99e Initial load
duke
parents:
diff changeset
2071 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2072 buf[s_len] = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
2073 DTRACE_PROBE1(hotspot_jni, GetStringChars__return, buf);
a61af66fc99e Initial load
duke
parents:
diff changeset
2074 return buf;
a61af66fc99e Initial load
duke
parents:
diff changeset
2075 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
2076
a61af66fc99e Initial load
duke
parents:
diff changeset
2077
a61af66fc99e Initial load
duke
parents:
diff changeset
2078 JNI_QUICK_ENTRY(void, jni_ReleaseStringChars(JNIEnv *env, jstring str, const jchar *chars))
a61af66fc99e Initial load
duke
parents:
diff changeset
2079 JNIWrapper("ReleaseStringChars");
a61af66fc99e Initial load
duke
parents:
diff changeset
2080 DTRACE_PROBE3(hotspot_jni, ReleaseStringChars__entry, env, str, chars);
a61af66fc99e Initial load
duke
parents:
diff changeset
2081 //%note jni_6
a61af66fc99e Initial load
duke
parents:
diff changeset
2082 if (chars != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2083 // Since String objects are supposed to be immutable, don't copy any
a61af66fc99e Initial load
duke
parents:
diff changeset
2084 // new data back. A bad user will have to go after the char array.
a61af66fc99e Initial load
duke
parents:
diff changeset
2085 FreeHeap((void*) chars);
a61af66fc99e Initial load
duke
parents:
diff changeset
2086 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2087 DTRACE_PROBE(hotspot_jni, ReleaseStringChars__return);
a61af66fc99e Initial load
duke
parents:
diff changeset
2088 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
2089
a61af66fc99e Initial load
duke
parents:
diff changeset
2090
a61af66fc99e Initial load
duke
parents:
diff changeset
2091 // UTF Interface
a61af66fc99e Initial load
duke
parents:
diff changeset
2092
a61af66fc99e Initial load
duke
parents:
diff changeset
2093 DT_RETURN_MARK_DECL(NewStringUTF, jstring);
a61af66fc99e Initial load
duke
parents:
diff changeset
2094
a61af66fc99e Initial load
duke
parents:
diff changeset
2095 JNI_ENTRY(jstring, jni_NewStringUTF(JNIEnv *env, const char *bytes))
a61af66fc99e Initial load
duke
parents:
diff changeset
2096 JNIWrapper("NewStringUTF");
a61af66fc99e Initial load
duke
parents:
diff changeset
2097 DTRACE_PROBE2(hotspot_jni, NewStringUTF__entry, env, bytes);
a61af66fc99e Initial load
duke
parents:
diff changeset
2098 jstring ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
2099 DT_RETURN_MARK(NewStringUTF, jstring, (const jstring&)ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
2100
a61af66fc99e Initial load
duke
parents:
diff changeset
2101 oop result = java_lang_String::create_oop_from_str((char*) bytes, CHECK_NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
2102 ret = (jstring) JNIHandles::make_local(env, result);
a61af66fc99e Initial load
duke
parents:
diff changeset
2103 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
2104 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
2105
a61af66fc99e Initial load
duke
parents:
diff changeset
2106
a61af66fc99e Initial load
duke
parents:
diff changeset
2107 JNI_ENTRY(jsize, jni_GetStringUTFLength(JNIEnv *env, jstring string))
a61af66fc99e Initial load
duke
parents:
diff changeset
2108 JNIWrapper("GetStringUTFLength");
a61af66fc99e Initial load
duke
parents:
diff changeset
2109 DTRACE_PROBE2(hotspot_jni, GetStringUTFLength__entry, env, string);
a61af66fc99e Initial load
duke
parents:
diff changeset
2110 jsize ret = java_lang_String::utf8_length(JNIHandles::resolve_non_null(string));
a61af66fc99e Initial load
duke
parents:
diff changeset
2111 DTRACE_PROBE1(hotspot_jni, GetStringUTFLength__return, ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
2112 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
2113 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
2114
a61af66fc99e Initial load
duke
parents:
diff changeset
2115
a61af66fc99e Initial load
duke
parents:
diff changeset
2116 JNI_ENTRY(const char*, jni_GetStringUTFChars(JNIEnv *env, jstring string, jboolean *isCopy))
a61af66fc99e Initial load
duke
parents:
diff changeset
2117 JNIWrapper("GetStringUTFChars");
a61af66fc99e Initial load
duke
parents:
diff changeset
2118 DTRACE_PROBE3(hotspot_jni, GetStringUTFChars__entry, env, string, isCopy);
1989
017cd8bce8a8 6539281: -Xcheck:jni should validate char* argument to ReleaseStringUTFChars
sla
parents: 1980
diff changeset
2119 oop java_string = JNIHandles::resolve_non_null(string);
017cd8bce8a8 6539281: -Xcheck:jni should validate char* argument to ReleaseStringUTFChars
sla
parents: 1980
diff changeset
2120 size_t length = java_lang_String::utf8_length(java_string);
017cd8bce8a8 6539281: -Xcheck:jni should validate char* argument to ReleaseStringUTFChars
sla
parents: 1980
diff changeset
2121 char* result = AllocateHeap(length + 1, "GetStringUTFChars");
017cd8bce8a8 6539281: -Xcheck:jni should validate char* argument to ReleaseStringUTFChars
sla
parents: 1980
diff changeset
2122 java_lang_String::as_utf8_string(java_string, result, (int) length + 1);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2123 if (isCopy != NULL) *isCopy = JNI_TRUE;
a61af66fc99e Initial load
duke
parents:
diff changeset
2124 DTRACE_PROBE1(hotspot_jni, GetStringUTFChars__return, result);
a61af66fc99e Initial load
duke
parents:
diff changeset
2125 return result;
a61af66fc99e Initial load
duke
parents:
diff changeset
2126 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
2127
a61af66fc99e Initial load
duke
parents:
diff changeset
2128
a61af66fc99e Initial load
duke
parents:
diff changeset
2129 JNI_LEAF(void, jni_ReleaseStringUTFChars(JNIEnv *env, jstring str, const char *chars))
a61af66fc99e Initial load
duke
parents:
diff changeset
2130 JNIWrapper("ReleaseStringUTFChars");
a61af66fc99e Initial load
duke
parents:
diff changeset
2131 DTRACE_PROBE3(hotspot_jni, ReleaseStringUTFChars__entry, env, str, chars);
a61af66fc99e Initial load
duke
parents:
diff changeset
2132 if (chars != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2133 FreeHeap((char*) chars);
a61af66fc99e Initial load
duke
parents:
diff changeset
2134 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2135 DTRACE_PROBE(hotspot_jni, ReleaseStringUTFChars__return);
a61af66fc99e Initial load
duke
parents:
diff changeset
2136 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
2137
a61af66fc99e Initial load
duke
parents:
diff changeset
2138
a61af66fc99e Initial load
duke
parents:
diff changeset
2139 JNI_QUICK_ENTRY(jsize, jni_GetArrayLength(JNIEnv *env, jarray array))
a61af66fc99e Initial load
duke
parents:
diff changeset
2140 JNIWrapper("GetArrayLength");
a61af66fc99e Initial load
duke
parents:
diff changeset
2141 DTRACE_PROBE2(hotspot_jni, GetArrayLength__entry, env, array);
a61af66fc99e Initial load
duke
parents:
diff changeset
2142 arrayOop a = arrayOop(JNIHandles::resolve_non_null(array));
a61af66fc99e Initial load
duke
parents:
diff changeset
2143 assert(a->is_array(), "must be array");
a61af66fc99e Initial load
duke
parents:
diff changeset
2144 jsize ret = a->length();
a61af66fc99e Initial load
duke
parents:
diff changeset
2145 DTRACE_PROBE1(hotspot_jni, GetArrayLength__return, ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
2146 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
2147 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
2148
a61af66fc99e Initial load
duke
parents:
diff changeset
2149
a61af66fc99e Initial load
duke
parents:
diff changeset
2150 //
a61af66fc99e Initial load
duke
parents:
diff changeset
2151 // Object Array Operations
a61af66fc99e Initial load
duke
parents:
diff changeset
2152 //
a61af66fc99e Initial load
duke
parents:
diff changeset
2153
a61af66fc99e Initial load
duke
parents:
diff changeset
2154 DT_RETURN_MARK_DECL(NewObjectArray, jobjectArray);
a61af66fc99e Initial load
duke
parents:
diff changeset
2155
a61af66fc99e Initial load
duke
parents:
diff changeset
2156 JNI_ENTRY(jobjectArray, jni_NewObjectArray(JNIEnv *env, jsize length, jclass elementClass, jobject initialElement))
a61af66fc99e Initial load
duke
parents:
diff changeset
2157 JNIWrapper("NewObjectArray");
a61af66fc99e Initial load
duke
parents:
diff changeset
2158 DTRACE_PROBE4(hotspot_jni, NewObjectArray__entry, env, length, elementClass, initialElement);
a61af66fc99e Initial load
duke
parents:
diff changeset
2159 jobjectArray ret = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
2160 DT_RETURN_MARK(NewObjectArray, jobjectArray, (const jobjectArray&)ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
2161 KlassHandle ek(THREAD, java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(elementClass)));
a61af66fc99e Initial load
duke
parents:
diff changeset
2162 klassOop ako = Klass::cast(ek())->array_klass(CHECK_NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
2163 KlassHandle ak = KlassHandle(THREAD, ako);
a61af66fc99e Initial load
duke
parents:
diff changeset
2164 objArrayKlass::cast(ak())->initialize(CHECK_NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
2165 objArrayOop result = objArrayKlass::cast(ak())->allocate(length, CHECK_NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
2166 oop initial_value = JNIHandles::resolve(initialElement);
a61af66fc99e Initial load
duke
parents:
diff changeset
2167 if (initial_value != NULL) { // array already initialized with NULL
a61af66fc99e Initial load
duke
parents:
diff changeset
2168 for (int index = 0; index < length; index++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2169 result->obj_at_put(index, initial_value);
a61af66fc99e Initial load
duke
parents:
diff changeset
2170 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2171 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2172 ret = (jobjectArray) JNIHandles::make_local(env, result);
a61af66fc99e Initial load
duke
parents:
diff changeset
2173 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
2174 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
2175
a61af66fc99e Initial load
duke
parents:
diff changeset
2176 DT_RETURN_MARK_DECL(GetObjectArrayElement, jobject);
a61af66fc99e Initial load
duke
parents:
diff changeset
2177
a61af66fc99e Initial load
duke
parents:
diff changeset
2178 JNI_ENTRY(jobject, jni_GetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index))
a61af66fc99e Initial load
duke
parents:
diff changeset
2179 JNIWrapper("GetObjectArrayElement");
a61af66fc99e Initial load
duke
parents:
diff changeset
2180 DTRACE_PROBE3(hotspot_jni, GetObjectArrayElement__entry, env, array, index);
a61af66fc99e Initial load
duke
parents:
diff changeset
2181 jobject ret = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
2182 DT_RETURN_MARK(GetObjectArrayElement, jobject, (const jobject&)ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
2183 objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array));
a61af66fc99e Initial load
duke
parents:
diff changeset
2184 if (a->is_within_bounds(index)) {
1034
08780c8a9f04 6893483: DTrace probe return values for a couple JNI methods are wrong
kamg
parents: 973
diff changeset
2185 ret = JNIHandles::make_local(env, a->obj_at(index));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2186 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
2187 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
2188 char buf[jintAsStringSize];
a61af66fc99e Initial load
duke
parents:
diff changeset
2189 sprintf(buf, "%d", index);
a61af66fc99e Initial load
duke
parents:
diff changeset
2190 THROW_MSG_0(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), buf);
a61af66fc99e Initial load
duke
parents:
diff changeset
2191 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2192 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
2193
a61af66fc99e Initial load
duke
parents:
diff changeset
2194 DT_VOID_RETURN_MARK_DECL(SetObjectArrayElement);
a61af66fc99e Initial load
duke
parents:
diff changeset
2195
a61af66fc99e Initial load
duke
parents:
diff changeset
2196 JNI_ENTRY(void, jni_SetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index, jobject value))
a61af66fc99e Initial load
duke
parents:
diff changeset
2197 JNIWrapper("SetObjectArrayElement");
a61af66fc99e Initial load
duke
parents:
diff changeset
2198 DTRACE_PROBE4(hotspot_jni, SetObjectArrayElement__entry, env, array, index, value);
a61af66fc99e Initial load
duke
parents:
diff changeset
2199 DT_VOID_RETURN_MARK(SetObjectArrayElement);
a61af66fc99e Initial load
duke
parents:
diff changeset
2200
a61af66fc99e Initial load
duke
parents:
diff changeset
2201 objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array));
a61af66fc99e Initial load
duke
parents:
diff changeset
2202 oop v = JNIHandles::resolve(value);
a61af66fc99e Initial load
duke
parents:
diff changeset
2203 if (a->is_within_bounds(index)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2204 if (v == NULL || v->is_a(objArrayKlass::cast(a->klass())->element_klass())) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2205 a->obj_at_put(index, v);
a61af66fc99e Initial load
duke
parents:
diff changeset
2206 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
2207 THROW(vmSymbols::java_lang_ArrayStoreException());
a61af66fc99e Initial load
duke
parents:
diff changeset
2208 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2209 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
2210 char buf[jintAsStringSize];
a61af66fc99e Initial load
duke
parents:
diff changeset
2211 sprintf(buf, "%d", index);
a61af66fc99e Initial load
duke
parents:
diff changeset
2212 THROW_MSG(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), buf);
a61af66fc99e Initial load
duke
parents:
diff changeset
2213 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2214 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
2215
a61af66fc99e Initial load
duke
parents:
diff changeset
2216
a61af66fc99e Initial load
duke
parents:
diff changeset
2217 #define DEFINE_NEWSCALARARRAY(Return,Allocator,Result) \
a61af66fc99e Initial load
duke
parents:
diff changeset
2218 \
1034
08780c8a9f04 6893483: DTrace probe return values for a couple JNI methods are wrong
kamg
parents: 973
diff changeset
2219 DT_RETURN_MARK_DECL(New##Result##Array, Return);\
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2220 \
a61af66fc99e Initial load
duke
parents:
diff changeset
2221 JNI_ENTRY(Return, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2222 jni_New##Result##Array(JNIEnv *env, jsize len)) \
a61af66fc99e Initial load
duke
parents:
diff changeset
2223 JNIWrapper("New" XSTR(Result) "Array"); \
a61af66fc99e Initial load
duke
parents:
diff changeset
2224 DTRACE_PROBE2(hotspot_jni, New##Result##Array__entry, env, len);\
a61af66fc99e Initial load
duke
parents:
diff changeset
2225 Return ret = NULL;\
1034
08780c8a9f04 6893483: DTrace probe return values for a couple JNI methods are wrong
kamg
parents: 973
diff changeset
2226 DT_RETURN_MARK(New##Result##Array, Return, (const Return&)ret);\
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2227 \
a61af66fc99e Initial load
duke
parents:
diff changeset
2228 oop obj= oopFactory::Allocator(len, CHECK_0); \
a61af66fc99e Initial load
duke
parents:
diff changeset
2229 ret = (Return) JNIHandles::make_local(env, obj); \
a61af66fc99e Initial load
duke
parents:
diff changeset
2230 return ret;\
a61af66fc99e Initial load
duke
parents:
diff changeset
2231 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
2232
a61af66fc99e Initial load
duke
parents:
diff changeset
2233 DEFINE_NEWSCALARARRAY(jbooleanArray, new_boolArray, Boolean)
a61af66fc99e Initial load
duke
parents:
diff changeset
2234 DEFINE_NEWSCALARARRAY(jbyteArray, new_byteArray, Byte)
a61af66fc99e Initial load
duke
parents:
diff changeset
2235 DEFINE_NEWSCALARARRAY(jshortArray, new_shortArray, Short)
a61af66fc99e Initial load
duke
parents:
diff changeset
2236 DEFINE_NEWSCALARARRAY(jcharArray, new_charArray, Char)
a61af66fc99e Initial load
duke
parents:
diff changeset
2237 DEFINE_NEWSCALARARRAY(jintArray, new_intArray, Int)
a61af66fc99e Initial load
duke
parents:
diff changeset
2238 DEFINE_NEWSCALARARRAY(jlongArray, new_longArray, Long)
a61af66fc99e Initial load
duke
parents:
diff changeset
2239 DEFINE_NEWSCALARARRAY(jfloatArray, new_singleArray, Float)
a61af66fc99e Initial load
duke
parents:
diff changeset
2240 DEFINE_NEWSCALARARRAY(jdoubleArray, new_doubleArray, Double)
a61af66fc99e Initial load
duke
parents:
diff changeset
2241
a61af66fc99e Initial load
duke
parents:
diff changeset
2242
a61af66fc99e Initial load
duke
parents:
diff changeset
2243 // Return an address which will fault if the caller writes to it.
a61af66fc99e Initial load
duke
parents:
diff changeset
2244
a61af66fc99e Initial load
duke
parents:
diff changeset
2245 static char* get_bad_address() {
a61af66fc99e Initial load
duke
parents:
diff changeset
2246 static char* bad_address = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
2247 if (bad_address == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2248 size_t size = os::vm_allocation_granularity();
a61af66fc99e Initial load
duke
parents:
diff changeset
2249 bad_address = os::reserve_memory(size);
a61af66fc99e Initial load
duke
parents:
diff changeset
2250 if (bad_address != NULL) {
477
24fda36852ce 6727377: VM stack guard pages on Windows should PAGE_READWRITE not PAGE_EXECUTE_READWRITE
coleenp
parents: 237
diff changeset
2251 os::protect_memory(bad_address, size, os::MEM_PROT_READ,
24fda36852ce 6727377: VM stack guard pages on Windows should PAGE_READWRITE not PAGE_EXECUTE_READWRITE
coleenp
parents: 237
diff changeset
2252 /*is_committed*/false);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2253 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2254 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2255 return bad_address;
a61af66fc99e Initial load
duke
parents:
diff changeset
2256 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2257
a61af66fc99e Initial load
duke
parents:
diff changeset
2258
a61af66fc99e Initial load
duke
parents:
diff changeset
2259 #define DEFINE_GETSCALARARRAYELEMENTS(ElementTag,ElementType,Result, Tag) \
a61af66fc99e Initial load
duke
parents:
diff changeset
2260 \
a61af66fc99e Initial load
duke
parents:
diff changeset
2261 JNI_QUICK_ENTRY(ElementType*, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2262 jni_Get##Result##ArrayElements(JNIEnv *env, ElementType##Array array, jboolean *isCopy)) \
a61af66fc99e Initial load
duke
parents:
diff changeset
2263 JNIWrapper("Get" XSTR(Result) "ArrayElements"); \
a61af66fc99e Initial load
duke
parents:
diff changeset
2264 DTRACE_PROBE3(hotspot_jni, Get##Result##ArrayElements__entry, env, array, isCopy);\
a61af66fc99e Initial load
duke
parents:
diff changeset
2265 /* allocate an chunk of memory in c land */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
2266 typeArrayOop a = typeArrayOop(JNIHandles::resolve_non_null(array)); \
a61af66fc99e Initial load
duke
parents:
diff changeset
2267 ElementType* result; \
a61af66fc99e Initial load
duke
parents:
diff changeset
2268 int len = a->length(); \
a61af66fc99e Initial load
duke
parents:
diff changeset
2269 if (len == 0) { \
a61af66fc99e Initial load
duke
parents:
diff changeset
2270 /* Empty array: legal but useless, can't return NULL. \
a61af66fc99e Initial load
duke
parents:
diff changeset
2271 * Return a pointer to something useless. \
a61af66fc99e Initial load
duke
parents:
diff changeset
2272 * Avoid asserts in typeArrayOop. */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
2273 result = (ElementType*)get_bad_address(); \
a61af66fc99e Initial load
duke
parents:
diff changeset
2274 } else { \
a61af66fc99e Initial load
duke
parents:
diff changeset
2275 result = NEW_C_HEAP_ARRAY(ElementType, len); \
a61af66fc99e Initial load
duke
parents:
diff changeset
2276 /* copy the array to the c chunk */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
2277 memcpy(result, a->Tag##_at_addr(0), sizeof(ElementType)*len); \
a61af66fc99e Initial load
duke
parents:
diff changeset
2278 } \
a61af66fc99e Initial load
duke
parents:
diff changeset
2279 if (isCopy) *isCopy = JNI_TRUE; \
a61af66fc99e Initial load
duke
parents:
diff changeset
2280 DTRACE_PROBE1(hotspot_jni, Get##Result##ArrayElements__return, result);\
a61af66fc99e Initial load
duke
parents:
diff changeset
2281 return result; \
a61af66fc99e Initial load
duke
parents:
diff changeset
2282 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
2283
a61af66fc99e Initial load
duke
parents:
diff changeset
2284 DEFINE_GETSCALARARRAYELEMENTS(T_BOOLEAN, jboolean, Boolean, bool)
a61af66fc99e Initial load
duke
parents:
diff changeset
2285 DEFINE_GETSCALARARRAYELEMENTS(T_BYTE, jbyte, Byte, byte)
a61af66fc99e Initial load
duke
parents:
diff changeset
2286 DEFINE_GETSCALARARRAYELEMENTS(T_SHORT, jshort, Short, short)
a61af66fc99e Initial load
duke
parents:
diff changeset
2287 DEFINE_GETSCALARARRAYELEMENTS(T_CHAR, jchar, Char, char)
a61af66fc99e Initial load
duke
parents:
diff changeset
2288 DEFINE_GETSCALARARRAYELEMENTS(T_INT, jint, Int, int)
a61af66fc99e Initial load
duke
parents:
diff changeset
2289 DEFINE_GETSCALARARRAYELEMENTS(T_LONG, jlong, Long, long)
a61af66fc99e Initial load
duke
parents:
diff changeset
2290 DEFINE_GETSCALARARRAYELEMENTS(T_FLOAT, jfloat, Float, float)
a61af66fc99e Initial load
duke
parents:
diff changeset
2291 DEFINE_GETSCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double)
a61af66fc99e Initial load
duke
parents:
diff changeset
2292
a61af66fc99e Initial load
duke
parents:
diff changeset
2293
a61af66fc99e Initial load
duke
parents:
diff changeset
2294 #define DEFINE_RELEASESCALARARRAYELEMENTS(ElementTag,ElementType,Result,Tag) \
a61af66fc99e Initial load
duke
parents:
diff changeset
2295 \
a61af66fc99e Initial load
duke
parents:
diff changeset
2296 JNI_QUICK_ENTRY(void, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2297 jni_Release##Result##ArrayElements(JNIEnv *env, ElementType##Array array, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2298 ElementType *buf, jint mode)) \
a61af66fc99e Initial load
duke
parents:
diff changeset
2299 JNIWrapper("Release" XSTR(Result) "ArrayElements"); \
a61af66fc99e Initial load
duke
parents:
diff changeset
2300 DTRACE_PROBE4(hotspot_jni, Release##Result##ArrayElements__entry, env, array, buf, mode);\
a61af66fc99e Initial load
duke
parents:
diff changeset
2301 typeArrayOop a = typeArrayOop(JNIHandles::resolve_non_null(array)); \
a61af66fc99e Initial load
duke
parents:
diff changeset
2302 int len = a->length(); \
a61af66fc99e Initial load
duke
parents:
diff changeset
2303 if (len != 0) { /* Empty array: nothing to free or copy. */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
2304 if ((mode == 0) || (mode == JNI_COMMIT)) { \
a61af66fc99e Initial load
duke
parents:
diff changeset
2305 memcpy(a->Tag##_at_addr(0), buf, sizeof(ElementType)*len); \
a61af66fc99e Initial load
duke
parents:
diff changeset
2306 } \
a61af66fc99e Initial load
duke
parents:
diff changeset
2307 if ((mode == 0) || (mode == JNI_ABORT)) { \
a61af66fc99e Initial load
duke
parents:
diff changeset
2308 FreeHeap(buf); \
a61af66fc99e Initial load
duke
parents:
diff changeset
2309 } \
a61af66fc99e Initial load
duke
parents:
diff changeset
2310 } \
a61af66fc99e Initial load
duke
parents:
diff changeset
2311 DTRACE_PROBE(hotspot_jni, Release##Result##ArrayElements__return);\
a61af66fc99e Initial load
duke
parents:
diff changeset
2312 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
2313
a61af66fc99e Initial load
duke
parents:
diff changeset
2314 DEFINE_RELEASESCALARARRAYELEMENTS(T_BOOLEAN, jboolean, Boolean, bool)
a61af66fc99e Initial load
duke
parents:
diff changeset
2315 DEFINE_RELEASESCALARARRAYELEMENTS(T_BYTE, jbyte, Byte, byte)
a61af66fc99e Initial load
duke
parents:
diff changeset
2316 DEFINE_RELEASESCALARARRAYELEMENTS(T_SHORT, jshort, Short, short)
a61af66fc99e Initial load
duke
parents:
diff changeset
2317 DEFINE_RELEASESCALARARRAYELEMENTS(T_CHAR, jchar, Char, char)
a61af66fc99e Initial load
duke
parents:
diff changeset
2318 DEFINE_RELEASESCALARARRAYELEMENTS(T_INT, jint, Int, int)
a61af66fc99e Initial load
duke
parents:
diff changeset
2319 DEFINE_RELEASESCALARARRAYELEMENTS(T_LONG, jlong, Long, long)
a61af66fc99e Initial load
duke
parents:
diff changeset
2320 DEFINE_RELEASESCALARARRAYELEMENTS(T_FLOAT, jfloat, Float, float)
a61af66fc99e Initial load
duke
parents:
diff changeset
2321 DEFINE_RELEASESCALARARRAYELEMENTS(T_DOUBLE, jdouble, Double, double)
a61af66fc99e Initial load
duke
parents:
diff changeset
2322
a61af66fc99e Initial load
duke
parents:
diff changeset
2323 #define DEFINE_GETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag) \
a61af66fc99e Initial load
duke
parents:
diff changeset
2324 DT_VOID_RETURN_MARK_DECL(Get##Result##ArrayRegion);\
a61af66fc99e Initial load
duke
parents:
diff changeset
2325 \
a61af66fc99e Initial load
duke
parents:
diff changeset
2326 JNI_ENTRY(void, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2327 jni_Get##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2328 jsize len, ElementType *buf)) \
a61af66fc99e Initial load
duke
parents:
diff changeset
2329 JNIWrapper("Get" XSTR(Result) "ArrayRegion"); \
a61af66fc99e Initial load
duke
parents:
diff changeset
2330 DTRACE_PROBE5(hotspot_jni, Get##Result##ArrayRegion__entry, env, array, start, len, buf);\
a61af66fc99e Initial load
duke
parents:
diff changeset
2331 DT_VOID_RETURN_MARK(Get##Result##ArrayRegion); \
a61af66fc99e Initial load
duke
parents:
diff changeset
2332 typeArrayOop src = typeArrayOop(JNIHandles::resolve_non_null(array)); \
a61af66fc99e Initial load
duke
parents:
diff changeset
2333 if (start < 0 || len < 0 || ((unsigned int)start + (unsigned int)len > (unsigned int)src->length())) { \
a61af66fc99e Initial load
duke
parents:
diff changeset
2334 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); \
a61af66fc99e Initial load
duke
parents:
diff changeset
2335 } else { \
a61af66fc99e Initial load
duke
parents:
diff changeset
2336 if (len > 0) { \
a61af66fc99e Initial load
duke
parents:
diff changeset
2337 int sc = typeArrayKlass::cast(src->klass())->log2_element_size(); \
a61af66fc99e Initial load
duke
parents:
diff changeset
2338 memcpy((u_char*) buf, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2339 (u_char*) src->Tag##_at_addr(start), \
a61af66fc99e Initial load
duke
parents:
diff changeset
2340 len << sc); \
a61af66fc99e Initial load
duke
parents:
diff changeset
2341 } \
a61af66fc99e Initial load
duke
parents:
diff changeset
2342 } \
a61af66fc99e Initial load
duke
parents:
diff changeset
2343 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
2344
a61af66fc99e Initial load
duke
parents:
diff changeset
2345 DEFINE_GETSCALARARRAYREGION(T_BOOLEAN, jboolean,Boolean, bool)
a61af66fc99e Initial load
duke
parents:
diff changeset
2346 DEFINE_GETSCALARARRAYREGION(T_BYTE, jbyte, Byte, byte)
a61af66fc99e Initial load
duke
parents:
diff changeset
2347 DEFINE_GETSCALARARRAYREGION(T_SHORT, jshort, Short, short)
a61af66fc99e Initial load
duke
parents:
diff changeset
2348 DEFINE_GETSCALARARRAYREGION(T_CHAR, jchar, Char, char)
a61af66fc99e Initial load
duke
parents:
diff changeset
2349 DEFINE_GETSCALARARRAYREGION(T_INT, jint, Int, int)
a61af66fc99e Initial load
duke
parents:
diff changeset
2350 DEFINE_GETSCALARARRAYREGION(T_LONG, jlong, Long, long)
a61af66fc99e Initial load
duke
parents:
diff changeset
2351 DEFINE_GETSCALARARRAYREGION(T_FLOAT, jfloat, Float, float)
a61af66fc99e Initial load
duke
parents:
diff changeset
2352 DEFINE_GETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double)
a61af66fc99e Initial load
duke
parents:
diff changeset
2353
a61af66fc99e Initial load
duke
parents:
diff changeset
2354 #define DEFINE_SETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag) \
a61af66fc99e Initial load
duke
parents:
diff changeset
2355 DT_VOID_RETURN_MARK_DECL(Set##Result##ArrayRegion);\
a61af66fc99e Initial load
duke
parents:
diff changeset
2356 \
a61af66fc99e Initial load
duke
parents:
diff changeset
2357 JNI_ENTRY(void, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2358 jni_Set##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2359 jsize len, const ElementType *buf)) \
a61af66fc99e Initial load
duke
parents:
diff changeset
2360 JNIWrapper("Set" XSTR(Result) "ArrayRegion"); \
a61af66fc99e Initial load
duke
parents:
diff changeset
2361 DTRACE_PROBE5(hotspot_jni, Set##Result##ArrayRegion__entry, env, array, start, len, buf);\
a61af66fc99e Initial load
duke
parents:
diff changeset
2362 DT_VOID_RETURN_MARK(Set##Result##ArrayRegion); \
a61af66fc99e Initial load
duke
parents:
diff changeset
2363 typeArrayOop dst = typeArrayOop(JNIHandles::resolve_non_null(array)); \
a61af66fc99e Initial load
duke
parents:
diff changeset
2364 if (start < 0 || len < 0 || ((unsigned int)start + (unsigned int)len > (unsigned int)dst->length())) { \
a61af66fc99e Initial load
duke
parents:
diff changeset
2365 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); \
a61af66fc99e Initial load
duke
parents:
diff changeset
2366 } else { \
a61af66fc99e Initial load
duke
parents:
diff changeset
2367 if (len > 0) { \
a61af66fc99e Initial load
duke
parents:
diff changeset
2368 int sc = typeArrayKlass::cast(dst->klass())->log2_element_size(); \
a61af66fc99e Initial load
duke
parents:
diff changeset
2369 memcpy((u_char*) dst->Tag##_at_addr(start), \
a61af66fc99e Initial load
duke
parents:
diff changeset
2370 (u_char*) buf, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2371 len << sc); \
a61af66fc99e Initial load
duke
parents:
diff changeset
2372 } \
a61af66fc99e Initial load
duke
parents:
diff changeset
2373 } \
a61af66fc99e Initial load
duke
parents:
diff changeset
2374 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
2375
a61af66fc99e Initial load
duke
parents:
diff changeset
2376 DEFINE_SETSCALARARRAYREGION(T_BOOLEAN, jboolean, Boolean, bool)
a61af66fc99e Initial load
duke
parents:
diff changeset
2377 DEFINE_SETSCALARARRAYREGION(T_BYTE, jbyte, Byte, byte)
a61af66fc99e Initial load
duke
parents:
diff changeset
2378 DEFINE_SETSCALARARRAYREGION(T_SHORT, jshort, Short, short)
a61af66fc99e Initial load
duke
parents:
diff changeset
2379 DEFINE_SETSCALARARRAYREGION(T_CHAR, jchar, Char, char)
a61af66fc99e Initial load
duke
parents:
diff changeset
2380 DEFINE_SETSCALARARRAYREGION(T_INT, jint, Int, int)
a61af66fc99e Initial load
duke
parents:
diff changeset
2381 DEFINE_SETSCALARARRAYREGION(T_LONG, jlong, Long, long)
a61af66fc99e Initial load
duke
parents:
diff changeset
2382 DEFINE_SETSCALARARRAYREGION(T_FLOAT, jfloat, Float, float)
a61af66fc99e Initial load
duke
parents:
diff changeset
2383 DEFINE_SETSCALARARRAYREGION(T_DOUBLE, jdouble, Double, double)
a61af66fc99e Initial load
duke
parents:
diff changeset
2384
a61af66fc99e Initial load
duke
parents:
diff changeset
2385
a61af66fc99e Initial load
duke
parents:
diff changeset
2386 //
a61af66fc99e Initial load
duke
parents:
diff changeset
2387 // Interception of natives
a61af66fc99e Initial load
duke
parents:
diff changeset
2388 //
a61af66fc99e Initial load
duke
parents:
diff changeset
2389
a61af66fc99e Initial load
duke
parents:
diff changeset
2390 // The RegisterNatives call being attempted tried to register with a method that
a61af66fc99e Initial load
duke
parents:
diff changeset
2391 // is not native. Ask JVM TI what prefixes have been specified. Then check
a61af66fc99e Initial load
duke
parents:
diff changeset
2392 // to see if the native method is now wrapped with the prefixes. See the
a61af66fc99e Initial load
duke
parents:
diff changeset
2393 // SetNativeMethodPrefix(es) functions in the JVM TI Spec for details.
a61af66fc99e Initial load
duke
parents:
diff changeset
2394 static methodOop find_prefixed_native(KlassHandle k,
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
2395 Symbol* name, Symbol* signature, TRAPS) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2396 ResourceMark rm(THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
2397 methodOop method;
a61af66fc99e Initial load
duke
parents:
diff changeset
2398 int name_len = name->utf8_length();
a61af66fc99e Initial load
duke
parents:
diff changeset
2399 char* name_str = name->as_utf8();
a61af66fc99e Initial load
duke
parents:
diff changeset
2400 int prefix_count;
a61af66fc99e Initial load
duke
parents:
diff changeset
2401 char** prefixes = JvmtiExport::get_all_native_method_prefixes(&prefix_count);
a61af66fc99e Initial load
duke
parents:
diff changeset
2402 for (int i = 0; i < prefix_count; i++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2403 char* prefix = prefixes[i];
a61af66fc99e Initial load
duke
parents:
diff changeset
2404 int prefix_len = (int)strlen(prefix);
a61af66fc99e Initial load
duke
parents:
diff changeset
2405
a61af66fc99e Initial load
duke
parents:
diff changeset
2406 // try adding this prefix to the method name and see if it matches another method name
a61af66fc99e Initial load
duke
parents:
diff changeset
2407 int trial_len = name_len + prefix_len;
a61af66fc99e Initial load
duke
parents:
diff changeset
2408 char* trial_name_str = NEW_RESOURCE_ARRAY(char, trial_len + 1);
a61af66fc99e Initial load
duke
parents:
diff changeset
2409 strcpy(trial_name_str, prefix);
a61af66fc99e Initial load
duke
parents:
diff changeset
2410 strcat(trial_name_str, name_str);
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
2411 TempNewSymbol trial_name = SymbolTable::probe(trial_name_str, trial_len);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
2412 if (trial_name == NULL) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2413 continue; // no such symbol, so this prefix wasn't used, try the next prefix
a61af66fc99e Initial load
duke
parents:
diff changeset
2414 }
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
2415 method = Klass::cast(k())->lookup_method(trial_name, signature);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2416 if (method == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2417 continue; // signature doesn't match, try the next prefix
a61af66fc99e Initial load
duke
parents:
diff changeset
2418 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2419 if (method->is_native()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2420 method->set_is_prefixed_native();
a61af66fc99e Initial load
duke
parents:
diff changeset
2421 return method; // wahoo, we found a prefixed version of the method, return it
a61af66fc99e Initial load
duke
parents:
diff changeset
2422 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2423 // found as non-native, so prefix is good, add it, probably just need more prefixes
a61af66fc99e Initial load
duke
parents:
diff changeset
2424 name_len = trial_len;
a61af66fc99e Initial load
duke
parents:
diff changeset
2425 name_str = trial_name_str;
a61af66fc99e Initial load
duke
parents:
diff changeset
2426 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2427 return NULL; // not found
a61af66fc99e Initial load
duke
parents:
diff changeset
2428 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2429
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
2430 static bool register_native(KlassHandle k, Symbol* name, Symbol* signature, address entry, TRAPS) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
2431 methodOop method = Klass::cast(k())->lookup_method(name, signature);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2432 if (method == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2433 ResourceMark rm;
a61af66fc99e Initial load
duke
parents:
diff changeset
2434 stringStream st;
a61af66fc99e Initial load
duke
parents:
diff changeset
2435 st.print("Method %s name or signature does not match",
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
2436 methodOopDesc::name_and_sig_as_C_string(Klass::cast(k()), name, signature));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2437 THROW_MSG_(vmSymbols::java_lang_NoSuchMethodError(), st.as_string(), false);
a61af66fc99e Initial load
duke
parents:
diff changeset
2438 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2439 if (!method->is_native()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2440 // trying to register to a non-native method, see if a JVM TI agent has added prefix(es)
a61af66fc99e Initial load
duke
parents:
diff changeset
2441 method = find_prefixed_native(k, name, signature, THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
2442 if (method == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2443 ResourceMark rm;
a61af66fc99e Initial load
duke
parents:
diff changeset
2444 stringStream st;
a61af66fc99e Initial load
duke
parents:
diff changeset
2445 st.print("Method %s is not declared as native",
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
2446 methodOopDesc::name_and_sig_as_C_string(Klass::cast(k()), name, signature));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2447 THROW_MSG_(vmSymbols::java_lang_NoSuchMethodError(), st.as_string(), false);
a61af66fc99e Initial load
duke
parents:
diff changeset
2448 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2449 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2450
a61af66fc99e Initial load
duke
parents:
diff changeset
2451 if (entry != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2452 method->set_native_function(entry,
a61af66fc99e Initial load
duke
parents:
diff changeset
2453 methodOopDesc::native_bind_event_is_interesting);
a61af66fc99e Initial load
duke
parents:
diff changeset
2454 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
2455 method->clear_native_function();
a61af66fc99e Initial load
duke
parents:
diff changeset
2456 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2457 if (PrintJNIResolving) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2458 ResourceMark rm(THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
2459 tty->print_cr("[Registering JNI native method %s.%s]",
a61af66fc99e Initial load
duke
parents:
diff changeset
2460 Klass::cast(method->method_holder())->external_name(),
a61af66fc99e Initial load
duke
parents:
diff changeset
2461 method->name()->as_C_string());
a61af66fc99e Initial load
duke
parents:
diff changeset
2462 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2463 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
2464 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2465
a61af66fc99e Initial load
duke
parents:
diff changeset
2466 DT_RETURN_MARK_DECL(RegisterNatives, jint);
a61af66fc99e Initial load
duke
parents:
diff changeset
2467
a61af66fc99e Initial load
duke
parents:
diff changeset
2468 JNI_ENTRY(jint, jni_RegisterNatives(JNIEnv *env, jclass clazz,
a61af66fc99e Initial load
duke
parents:
diff changeset
2469 const JNINativeMethod *methods,
a61af66fc99e Initial load
duke
parents:
diff changeset
2470 jint nMethods))
a61af66fc99e Initial load
duke
parents:
diff changeset
2471 JNIWrapper("RegisterNatives");
a61af66fc99e Initial load
duke
parents:
diff changeset
2472 DTRACE_PROBE4(hotspot_jni, RegisterNatives__entry, env, clazz, methods, nMethods);
a61af66fc99e Initial load
duke
parents:
diff changeset
2473 jint ret = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
2474 DT_RETURN_MARK(RegisterNatives, jint, (const jint&)ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
2475
a61af66fc99e Initial load
duke
parents:
diff changeset
2476 KlassHandle h_k(thread, java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(clazz)));
a61af66fc99e Initial load
duke
parents:
diff changeset
2477
a61af66fc99e Initial load
duke
parents:
diff changeset
2478 for (int index = 0; index < nMethods; index++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2479 const char* meth_name = methods[index].name;
a61af66fc99e Initial load
duke
parents:
diff changeset
2480 const char* meth_sig = methods[index].signature;
a61af66fc99e Initial load
duke
parents:
diff changeset
2481 int meth_name_len = (int)strlen(meth_name);
a61af66fc99e Initial load
duke
parents:
diff changeset
2482
a61af66fc99e Initial load
duke
parents:
diff changeset
2483 // The class should have been loaded (we have an instance of the class
a61af66fc99e Initial load
duke
parents:
diff changeset
2484 // passed in) so the method and signature should already be in the symbol
a61af66fc99e Initial load
duke
parents:
diff changeset
2485 // table. If they're not there, the method doesn't exist.
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
2486 TempNewSymbol name = SymbolTable::probe(meth_name, meth_name_len);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
2487 TempNewSymbol signature = SymbolTable::probe(meth_sig, (int)strlen(meth_sig));
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
2488
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
2489 if (name == NULL || signature == NULL) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2490 ResourceMark rm;
a61af66fc99e Initial load
duke
parents:
diff changeset
2491 stringStream st;
a61af66fc99e Initial load
duke
parents:
diff changeset
2492 st.print("Method %s.%s%s not found", Klass::cast(h_k())->external_name(), meth_name, meth_sig);
a61af66fc99e Initial load
duke
parents:
diff changeset
2493 // Must return negative value on failure
a61af66fc99e Initial load
duke
parents:
diff changeset
2494 THROW_MSG_(vmSymbols::java_lang_NoSuchMethodError(), st.as_string(), -1);
a61af66fc99e Initial load
duke
parents:
diff changeset
2495 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2496
a61af66fc99e Initial load
duke
parents:
diff changeset
2497 bool res = register_native(h_k, name, signature,
a61af66fc99e Initial load
duke
parents:
diff changeset
2498 (address) methods[index].fnPtr, THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
2499 if (!res) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2500 ret = -1;
a61af66fc99e Initial load
duke
parents:
diff changeset
2501 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
2502 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2503 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2504 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
2505 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
2506
a61af66fc99e Initial load
duke
parents:
diff changeset
2507
a61af66fc99e Initial load
duke
parents:
diff changeset
2508 JNI_ENTRY(jint, jni_UnregisterNatives(JNIEnv *env, jclass clazz))
a61af66fc99e Initial load
duke
parents:
diff changeset
2509 JNIWrapper("UnregisterNatives");
a61af66fc99e Initial load
duke
parents:
diff changeset
2510 DTRACE_PROBE2(hotspot_jni, UnregisterNatives__entry, env, clazz);
a61af66fc99e Initial load
duke
parents:
diff changeset
2511 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(clazz));
a61af66fc99e Initial load
duke
parents:
diff changeset
2512 //%note jni_2
a61af66fc99e Initial load
duke
parents:
diff changeset
2513 if (Klass::cast(k)->oop_is_instance()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2514 for (int index = 0; index < instanceKlass::cast(k)->methods()->length(); index++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2515 methodOop m = methodOop(instanceKlass::cast(k)->methods()->obj_at(index));
a61af66fc99e Initial load
duke
parents:
diff changeset
2516 if (m->is_native()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2517 m->clear_native_function();
a61af66fc99e Initial load
duke
parents:
diff changeset
2518 m->set_signature_handler(NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
2519 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2520 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2521 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2522 DTRACE_PROBE1(hotspot_jni, UnregisterNatives__return, 0);
a61af66fc99e Initial load
duke
parents:
diff changeset
2523 return 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
2524 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
2525
a61af66fc99e Initial load
duke
parents:
diff changeset
2526 //
a61af66fc99e Initial load
duke
parents:
diff changeset
2527 // Monitor functions
a61af66fc99e Initial load
duke
parents:
diff changeset
2528 //
a61af66fc99e Initial load
duke
parents:
diff changeset
2529
a61af66fc99e Initial load
duke
parents:
diff changeset
2530 DT_RETURN_MARK_DECL(MonitorEnter, jint);
a61af66fc99e Initial load
duke
parents:
diff changeset
2531
a61af66fc99e Initial load
duke
parents:
diff changeset
2532 JNI_ENTRY(jint, jni_MonitorEnter(JNIEnv *env, jobject jobj))
a61af66fc99e Initial load
duke
parents:
diff changeset
2533 DTRACE_PROBE2(hotspot_jni, MonitorEnter__entry, env, jobj);
a61af66fc99e Initial load
duke
parents:
diff changeset
2534 jint ret = JNI_ERR;
a61af66fc99e Initial load
duke
parents:
diff changeset
2535 DT_RETURN_MARK(MonitorEnter, jint, (const jint&)ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
2536
a61af66fc99e Initial load
duke
parents:
diff changeset
2537 // If the object is null, we can't do anything with it
a61af66fc99e Initial load
duke
parents:
diff changeset
2538 if (jobj == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2539 THROW_(vmSymbols::java_lang_NullPointerException(), JNI_ERR);
a61af66fc99e Initial load
duke
parents:
diff changeset
2540 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2541
a61af66fc99e Initial load
duke
parents:
diff changeset
2542 Handle obj(thread, JNIHandles::resolve_non_null(jobj));
a61af66fc99e Initial load
duke
parents:
diff changeset
2543 ObjectSynchronizer::jni_enter(obj, CHECK_(JNI_ERR));
a61af66fc99e Initial load
duke
parents:
diff changeset
2544 ret = JNI_OK;
a61af66fc99e Initial load
duke
parents:
diff changeset
2545 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
2546 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
2547
a61af66fc99e Initial load
duke
parents:
diff changeset
2548 DT_RETURN_MARK_DECL(MonitorExit, jint);
a61af66fc99e Initial load
duke
parents:
diff changeset
2549
a61af66fc99e Initial load
duke
parents:
diff changeset
2550 JNI_ENTRY(jint, jni_MonitorExit(JNIEnv *env, jobject jobj))
a61af66fc99e Initial load
duke
parents:
diff changeset
2551 DTRACE_PROBE2(hotspot_jni, MonitorExit__entry, env, jobj);
a61af66fc99e Initial load
duke
parents:
diff changeset
2552 jint ret = JNI_ERR;
a61af66fc99e Initial load
duke
parents:
diff changeset
2553 DT_RETURN_MARK(MonitorExit, jint, (const jint&)ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
2554
a61af66fc99e Initial load
duke
parents:
diff changeset
2555 // Don't do anything with a null object
a61af66fc99e Initial load
duke
parents:
diff changeset
2556 if (jobj == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2557 THROW_(vmSymbols::java_lang_NullPointerException(), JNI_ERR);
a61af66fc99e Initial load
duke
parents:
diff changeset
2558 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2559
a61af66fc99e Initial load
duke
parents:
diff changeset
2560 Handle obj(THREAD, JNIHandles::resolve_non_null(jobj));
a61af66fc99e Initial load
duke
parents:
diff changeset
2561 ObjectSynchronizer::jni_exit(obj(), CHECK_(JNI_ERR));
a61af66fc99e Initial load
duke
parents:
diff changeset
2562
a61af66fc99e Initial load
duke
parents:
diff changeset
2563 ret = JNI_OK;
a61af66fc99e Initial load
duke
parents:
diff changeset
2564 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
2565 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
2566
a61af66fc99e Initial load
duke
parents:
diff changeset
2567 //
a61af66fc99e Initial load
duke
parents:
diff changeset
2568 // Extensions
a61af66fc99e Initial load
duke
parents:
diff changeset
2569 //
a61af66fc99e Initial load
duke
parents:
diff changeset
2570
a61af66fc99e Initial load
duke
parents:
diff changeset
2571 DT_VOID_RETURN_MARK_DECL(GetStringRegion);
a61af66fc99e Initial load
duke
parents:
diff changeset
2572
a61af66fc99e Initial load
duke
parents:
diff changeset
2573 JNI_ENTRY(void, jni_GetStringRegion(JNIEnv *env, jstring string, jsize start, jsize len, jchar *buf))
a61af66fc99e Initial load
duke
parents:
diff changeset
2574 JNIWrapper("GetStringRegion");
a61af66fc99e Initial load
duke
parents:
diff changeset
2575 DTRACE_PROBE5(hotspot_jni, GetStringRegion__entry, env, string, start, len, buf);
a61af66fc99e Initial load
duke
parents:
diff changeset
2576 DT_VOID_RETURN_MARK(GetStringRegion);
a61af66fc99e Initial load
duke
parents:
diff changeset
2577 oop s = JNIHandles::resolve_non_null(string);
a61af66fc99e Initial load
duke
parents:
diff changeset
2578 int s_len = java_lang_String::length(s);
a61af66fc99e Initial load
duke
parents:
diff changeset
2579 if (start < 0 || len < 0 || start + len > s_len) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2580 THROW(vmSymbols::java_lang_StringIndexOutOfBoundsException());
a61af66fc99e Initial load
duke
parents:
diff changeset
2581 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
2582 if (len > 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2583 int s_offset = java_lang_String::offset(s);
a61af66fc99e Initial load
duke
parents:
diff changeset
2584 typeArrayOop s_value = java_lang_String::value(s);
a61af66fc99e Initial load
duke
parents:
diff changeset
2585 memcpy(buf, s_value->char_at_addr(s_offset+start), sizeof(jchar)*len);
a61af66fc99e Initial load
duke
parents:
diff changeset
2586 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2587 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2588 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
2589
a61af66fc99e Initial load
duke
parents:
diff changeset
2590 DT_VOID_RETURN_MARK_DECL(GetStringUTFRegion);
a61af66fc99e Initial load
duke
parents:
diff changeset
2591
a61af66fc99e Initial load
duke
parents:
diff changeset
2592 JNI_ENTRY(void, jni_GetStringUTFRegion(JNIEnv *env, jstring string, jsize start, jsize len, char *buf))
a61af66fc99e Initial load
duke
parents:
diff changeset
2593 JNIWrapper("GetStringUTFRegion");
a61af66fc99e Initial load
duke
parents:
diff changeset
2594 DTRACE_PROBE5(hotspot_jni, GetStringUTFRegion__entry, env, string, start, len, buf);
a61af66fc99e Initial load
duke
parents:
diff changeset
2595 DT_VOID_RETURN_MARK(GetStringUTFRegion);
a61af66fc99e Initial load
duke
parents:
diff changeset
2596 oop s = JNIHandles::resolve_non_null(string);
a61af66fc99e Initial load
duke
parents:
diff changeset
2597 int s_len = java_lang_String::length(s);
a61af66fc99e Initial load
duke
parents:
diff changeset
2598 if (start < 0 || len < 0 || start + len > s_len) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2599 THROW(vmSymbols::java_lang_StringIndexOutOfBoundsException());
a61af66fc99e Initial load
duke
parents:
diff changeset
2600 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
2601 //%note jni_7
a61af66fc99e Initial load
duke
parents:
diff changeset
2602 if (len > 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2603 ResourceMark rm(THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
2604 char *utf_region = java_lang_String::as_utf8_string(s, start, len);
a61af66fc99e Initial load
duke
parents:
diff changeset
2605 int utf_len = (int)strlen(utf_region);
a61af66fc99e Initial load
duke
parents:
diff changeset
2606 memcpy(buf, utf_region, utf_len);
a61af66fc99e Initial load
duke
parents:
diff changeset
2607 buf[utf_len] = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
2608 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
2609 // JDK null-terminates the buffer even in len is zero
a61af66fc99e Initial load
duke
parents:
diff changeset
2610 if (buf != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2611 buf[0] = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
2612 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2613 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2614 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2615 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
2616
a61af66fc99e Initial load
duke
parents:
diff changeset
2617
a61af66fc99e Initial load
duke
parents:
diff changeset
2618 JNI_ENTRY(void*, jni_GetPrimitiveArrayCritical(JNIEnv *env, jarray array, jboolean *isCopy))
a61af66fc99e Initial load
duke
parents:
diff changeset
2619 JNIWrapper("GetPrimitiveArrayCritical");
a61af66fc99e Initial load
duke
parents:
diff changeset
2620 DTRACE_PROBE3(hotspot_jni, GetPrimitiveArrayCritical__entry, env, array, isCopy);
a61af66fc99e Initial load
duke
parents:
diff changeset
2621 GC_locker::lock_critical(thread);
a61af66fc99e Initial load
duke
parents:
diff changeset
2622 if (isCopy != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2623 *isCopy = JNI_FALSE;
a61af66fc99e Initial load
duke
parents:
diff changeset
2624 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2625 oop a = JNIHandles::resolve_non_null(array);
a61af66fc99e Initial load
duke
parents:
diff changeset
2626 assert(a->is_array(), "just checking");
a61af66fc99e Initial load
duke
parents:
diff changeset
2627 BasicType type;
a61af66fc99e Initial load
duke
parents:
diff changeset
2628 if (a->is_objArray()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2629 type = T_OBJECT;
a61af66fc99e Initial load
duke
parents:
diff changeset
2630 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
2631 type = typeArrayKlass::cast(a->klass())->element_type();
a61af66fc99e Initial load
duke
parents:
diff changeset
2632 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2633 void* ret = arrayOop(a)->base(type);
a61af66fc99e Initial load
duke
parents:
diff changeset
2634 DTRACE_PROBE1(hotspot_jni, GetPrimitiveArrayCritical__return, ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
2635 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
2636 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
2637
a61af66fc99e Initial load
duke
parents:
diff changeset
2638
a61af66fc99e Initial load
duke
parents:
diff changeset
2639 JNI_ENTRY(void, jni_ReleasePrimitiveArrayCritical(JNIEnv *env, jarray array, void *carray, jint mode))
a61af66fc99e Initial load
duke
parents:
diff changeset
2640 JNIWrapper("ReleasePrimitiveArrayCritical");
a61af66fc99e Initial load
duke
parents:
diff changeset
2641 DTRACE_PROBE4(hotspot_jni, ReleasePrimitiveArrayCritical__entry, env, array, carray, mode);
a61af66fc99e Initial load
duke
parents:
diff changeset
2642 // The array, carray and mode arguments are ignored
a61af66fc99e Initial load
duke
parents:
diff changeset
2643 GC_locker::unlock_critical(thread);
a61af66fc99e Initial load
duke
parents:
diff changeset
2644 DTRACE_PROBE(hotspot_jni, ReleasePrimitiveArrayCritical__return);
a61af66fc99e Initial load
duke
parents:
diff changeset
2645 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
2646
a61af66fc99e Initial load
duke
parents:
diff changeset
2647
a61af66fc99e Initial load
duke
parents:
diff changeset
2648 JNI_ENTRY(const jchar*, jni_GetStringCritical(JNIEnv *env, jstring string, jboolean *isCopy))
a61af66fc99e Initial load
duke
parents:
diff changeset
2649 JNIWrapper("GetStringCritical");
a61af66fc99e Initial load
duke
parents:
diff changeset
2650 DTRACE_PROBE3(hotspot_jni, GetStringCritical__entry, env, string, isCopy);
a61af66fc99e Initial load
duke
parents:
diff changeset
2651 GC_locker::lock_critical(thread);
a61af66fc99e Initial load
duke
parents:
diff changeset
2652 if (isCopy != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2653 *isCopy = JNI_FALSE;
a61af66fc99e Initial load
duke
parents:
diff changeset
2654 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2655 oop s = JNIHandles::resolve_non_null(string);
a61af66fc99e Initial load
duke
parents:
diff changeset
2656 int s_len = java_lang_String::length(s);
a61af66fc99e Initial load
duke
parents:
diff changeset
2657 typeArrayOop s_value = java_lang_String::value(s);
a61af66fc99e Initial load
duke
parents:
diff changeset
2658 int s_offset = java_lang_String::offset(s);
a61af66fc99e Initial load
duke
parents:
diff changeset
2659 const jchar* ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
2660 if (s_len > 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2661 ret = s_value->char_at_addr(s_offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
2662 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
2663 ret = (jchar*) s_value->base(T_CHAR);
a61af66fc99e Initial load
duke
parents:
diff changeset
2664 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2665 DTRACE_PROBE1(hotspot_jni, GetStringCritical__return, ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
2666 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
2667 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
2668
a61af66fc99e Initial load
duke
parents:
diff changeset
2669
a61af66fc99e Initial load
duke
parents:
diff changeset
2670 JNI_ENTRY(void, jni_ReleaseStringCritical(JNIEnv *env, jstring str, const jchar *chars))
a61af66fc99e Initial load
duke
parents:
diff changeset
2671 JNIWrapper("ReleaseStringCritical");
a61af66fc99e Initial load
duke
parents:
diff changeset
2672 DTRACE_PROBE3(hotspot_jni, ReleaseStringCritical__entry, env, str, chars);
a61af66fc99e Initial load
duke
parents:
diff changeset
2673 // The str and chars arguments are ignored
a61af66fc99e Initial load
duke
parents:
diff changeset
2674 GC_locker::unlock_critical(thread);
a61af66fc99e Initial load
duke
parents:
diff changeset
2675 DTRACE_PROBE(hotspot_jni, ReleaseStringCritical__return);
a61af66fc99e Initial load
duke
parents:
diff changeset
2676 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
2677
a61af66fc99e Initial load
duke
parents:
diff changeset
2678
a61af66fc99e Initial load
duke
parents:
diff changeset
2679 JNI_ENTRY(jweak, jni_NewWeakGlobalRef(JNIEnv *env, jobject ref))
a61af66fc99e Initial load
duke
parents:
diff changeset
2680 JNIWrapper("jni_NewWeakGlobalRef");
a61af66fc99e Initial load
duke
parents:
diff changeset
2681 DTRACE_PROBE2(hotspot_jni, NewWeakGlobalRef__entry, env, ref);
a61af66fc99e Initial load
duke
parents:
diff changeset
2682 Handle ref_handle(thread, JNIHandles::resolve(ref));
a61af66fc99e Initial load
duke
parents:
diff changeset
2683 jweak ret = JNIHandles::make_weak_global(ref_handle);
a61af66fc99e Initial load
duke
parents:
diff changeset
2684 DTRACE_PROBE1(hotspot_jni, NewWeakGlobalRef__return, ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
2685 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
2686 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
2687
a61af66fc99e Initial load
duke
parents:
diff changeset
2688 // Must be JNI_ENTRY (with HandleMark)
a61af66fc99e Initial load
duke
parents:
diff changeset
2689 JNI_ENTRY(void, jni_DeleteWeakGlobalRef(JNIEnv *env, jweak ref))
a61af66fc99e Initial load
duke
parents:
diff changeset
2690 JNIWrapper("jni_DeleteWeakGlobalRef");
a61af66fc99e Initial load
duke
parents:
diff changeset
2691 DTRACE_PROBE2(hotspot_jni, DeleteWeakGlobalRef__entry, env, ref);
a61af66fc99e Initial load
duke
parents:
diff changeset
2692 JNIHandles::destroy_weak_global(ref);
a61af66fc99e Initial load
duke
parents:
diff changeset
2693 DTRACE_PROBE(hotspot_jni, DeleteWeakGlobalRef__return);
a61af66fc99e Initial load
duke
parents:
diff changeset
2694 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
2695
a61af66fc99e Initial load
duke
parents:
diff changeset
2696
a61af66fc99e Initial load
duke
parents:
diff changeset
2697 JNI_QUICK_ENTRY(jboolean, jni_ExceptionCheck(JNIEnv *env))
a61af66fc99e Initial load
duke
parents:
diff changeset
2698 JNIWrapper("jni_ExceptionCheck");
a61af66fc99e Initial load
duke
parents:
diff changeset
2699 DTRACE_PROBE1(hotspot_jni, ExceptionCheck__entry, env);
a61af66fc99e Initial load
duke
parents:
diff changeset
2700 jni_check_async_exceptions(thread);
a61af66fc99e Initial load
duke
parents:
diff changeset
2701 jboolean ret = (thread->has_pending_exception()) ? JNI_TRUE : JNI_FALSE;
a61af66fc99e Initial load
duke
parents:
diff changeset
2702 DTRACE_PROBE1(hotspot_jni, ExceptionCheck__return, ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
2703 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
2704 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
2705
a61af66fc99e Initial load
duke
parents:
diff changeset
2706
a61af66fc99e Initial load
duke
parents:
diff changeset
2707 // Initialization state for three routines below relating to
a61af66fc99e Initial load
duke
parents:
diff changeset
2708 // java.nio.DirectBuffers
a61af66fc99e Initial load
duke
parents:
diff changeset
2709 static jint directBufferSupportInitializeStarted = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
2710 static volatile jint directBufferSupportInitializeEnded = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
2711 static volatile jint directBufferSupportInitializeFailed = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
2712 static jclass bufferClass = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
2713 static jclass directBufferClass = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
2714 static jclass directByteBufferClass = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
2715 static jmethodID directByteBufferConstructor = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
2716 static jfieldID directBufferAddressField = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
2717 static jfieldID bufferCapacityField = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
2718
a61af66fc99e Initial load
duke
parents:
diff changeset
2719 static jclass lookupOne(JNIEnv* env, const char* name, TRAPS) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2720 Handle loader; // null (bootstrap) loader
a61af66fc99e Initial load
duke
parents:
diff changeset
2721 Handle protection_domain; // null protection domain
a61af66fc99e Initial load
duke
parents:
diff changeset
2722
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 1989
diff changeset
2723 TempNewSymbol sym = SymbolTable::new_symbol(name, CHECK_NULL);
657
715dceaa89b7 6603316: Improve instrumentation for classes loaded at startup
acorn
parents: 579
diff changeset
2724 jclass result = find_class_from_class_loader(env, sym, true, loader, protection_domain, true, CHECK_NULL);
715dceaa89b7 6603316: Improve instrumentation for classes loaded at startup
acorn
parents: 579
diff changeset
2725
715dceaa89b7 6603316: Improve instrumentation for classes loaded at startup
acorn
parents: 579
diff changeset
2726 if (TraceClassResolution && result != NULL) {
715dceaa89b7 6603316: Improve instrumentation for classes loaded at startup
acorn
parents: 579
diff changeset
2727 trace_class_resolution(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(result)));
715dceaa89b7 6603316: Improve instrumentation for classes loaded at startup
acorn
parents: 579
diff changeset
2728 }
715dceaa89b7 6603316: Improve instrumentation for classes loaded at startup
acorn
parents: 579
diff changeset
2729 return result;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2730 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2731
a61af66fc99e Initial load
duke
parents:
diff changeset
2732 // These lookups are done with the NULL (bootstrap) ClassLoader to
a61af66fc99e Initial load
duke
parents:
diff changeset
2733 // circumvent any security checks that would be done by jni_FindClass.
a61af66fc99e Initial load
duke
parents:
diff changeset
2734 JNI_ENTRY(bool, lookupDirectBufferClasses(JNIEnv* env))
a61af66fc99e Initial load
duke
parents:
diff changeset
2735 {
a61af66fc99e Initial load
duke
parents:
diff changeset
2736 if ((bufferClass = lookupOne(env, "java/nio/Buffer", thread)) == NULL) { return false; }
a61af66fc99e Initial load
duke
parents:
diff changeset
2737 if ((directBufferClass = lookupOne(env, "sun/nio/ch/DirectBuffer", thread)) == NULL) { return false; }
a61af66fc99e Initial load
duke
parents:
diff changeset
2738 if ((directByteBufferClass = lookupOne(env, "java/nio/DirectByteBuffer", thread)) == NULL) { return false; }
a61af66fc99e Initial load
duke
parents:
diff changeset
2739 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
2740 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2741 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
2742
a61af66fc99e Initial load
duke
parents:
diff changeset
2743
a61af66fc99e Initial load
duke
parents:
diff changeset
2744 static bool initializeDirectBufferSupport(JNIEnv* env, JavaThread* thread) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2745 if (directBufferSupportInitializeFailed) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2746 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
2747 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2748
a61af66fc99e Initial load
duke
parents:
diff changeset
2749 if (Atomic::cmpxchg(1, &directBufferSupportInitializeStarted, 0) == 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2750 if (!lookupDirectBufferClasses(env)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2751 directBufferSupportInitializeFailed = 1;
a61af66fc99e Initial load
duke
parents:
diff changeset
2752 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
2753 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2754
a61af66fc99e Initial load
duke
parents:
diff changeset
2755 // Make global references for these
a61af66fc99e Initial load
duke
parents:
diff changeset
2756 bufferClass = (jclass) env->NewGlobalRef(bufferClass);
a61af66fc99e Initial load
duke
parents:
diff changeset
2757 directBufferClass = (jclass) env->NewGlobalRef(directBufferClass);
a61af66fc99e Initial load
duke
parents:
diff changeset
2758 directByteBufferClass = (jclass) env->NewGlobalRef(directByteBufferClass);
a61af66fc99e Initial load
duke
parents:
diff changeset
2759
a61af66fc99e Initial load
duke
parents:
diff changeset
2760 // Get needed field and method IDs
a61af66fc99e Initial load
duke
parents:
diff changeset
2761 directByteBufferConstructor = env->GetMethodID(directByteBufferClass, "<init>", "(JI)V");
a61af66fc99e Initial load
duke
parents:
diff changeset
2762 directBufferAddressField = env->GetFieldID(bufferClass, "address", "J");
a61af66fc99e Initial load
duke
parents:
diff changeset
2763 bufferCapacityField = env->GetFieldID(bufferClass, "capacity", "I");
a61af66fc99e Initial load
duke
parents:
diff changeset
2764
a61af66fc99e Initial load
duke
parents:
diff changeset
2765 if ((directByteBufferConstructor == NULL) ||
a61af66fc99e Initial load
duke
parents:
diff changeset
2766 (directBufferAddressField == NULL) ||
a61af66fc99e Initial load
duke
parents:
diff changeset
2767 (bufferCapacityField == NULL)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2768 directBufferSupportInitializeFailed = 1;
a61af66fc99e Initial load
duke
parents:
diff changeset
2769 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
2770 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2771
a61af66fc99e Initial load
duke
parents:
diff changeset
2772 directBufferSupportInitializeEnded = 1;
a61af66fc99e Initial load
duke
parents:
diff changeset
2773 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
2774 while (!directBufferSupportInitializeEnded && !directBufferSupportInitializeFailed) {
521
4db4e58c16bd 6791815: Fix for 6471657 can cause deadlock on non-Solaris platforms when initializing direct buffer support
xlu
parents: 477
diff changeset
2775 // Set state as yield_all can call os:sleep. On Solaris, yield_all calls
4db4e58c16bd 6791815: Fix for 6471657 can cause deadlock on non-Solaris platforms when initializing direct buffer support
xlu
parents: 477
diff changeset
2776 // os::sleep which requires the VM state transition. On other platforms, it
4db4e58c16bd 6791815: Fix for 6471657 can cause deadlock on non-Solaris platforms when initializing direct buffer support
xlu
parents: 477
diff changeset
2777 // is not necessary. The following call to change the VM state is purposely
4db4e58c16bd 6791815: Fix for 6471657 can cause deadlock on non-Solaris platforms when initializing direct buffer support
xlu
parents: 477
diff changeset
2778 // put inside the loop to avoid potential deadlock when multiple threads
4db4e58c16bd 6791815: Fix for 6471657 can cause deadlock on non-Solaris platforms when initializing direct buffer support
xlu
parents: 477
diff changeset
2779 // try to call this method. See 6791815 for more details.
4db4e58c16bd 6791815: Fix for 6471657 can cause deadlock on non-Solaris platforms when initializing direct buffer support
xlu
parents: 477
diff changeset
2780 ThreadInVMfromNative tivn(thread);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2781 os::yield_all();
a61af66fc99e Initial load
duke
parents:
diff changeset
2782 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2783 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2784
a61af66fc99e Initial load
duke
parents:
diff changeset
2785 return !directBufferSupportInitializeFailed;
a61af66fc99e Initial load
duke
parents:
diff changeset
2786 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2787
a61af66fc99e Initial load
duke
parents:
diff changeset
2788 extern "C" jobject JNICALL jni_NewDirectByteBuffer(JNIEnv *env, void* address, jlong capacity)
a61af66fc99e Initial load
duke
parents:
diff changeset
2789 {
a61af66fc99e Initial load
duke
parents:
diff changeset
2790 // thread_from_jni_environment() will block if VM is gone.
a61af66fc99e Initial load
duke
parents:
diff changeset
2791 JavaThread* thread = JavaThread::thread_from_jni_environment(env);
a61af66fc99e Initial load
duke
parents:
diff changeset
2792
a61af66fc99e Initial load
duke
parents:
diff changeset
2793 JNIWrapper("jni_NewDirectByteBuffer");
a61af66fc99e Initial load
duke
parents:
diff changeset
2794 DTRACE_PROBE3(hotspot_jni, NewDirectByteBuffer__entry, env, address, capacity);
a61af66fc99e Initial load
duke
parents:
diff changeset
2795
a61af66fc99e Initial load
duke
parents:
diff changeset
2796 if (!directBufferSupportInitializeEnded) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2797 if (!initializeDirectBufferSupport(env, thread)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2798 DTRACE_PROBE1(hotspot_jni, NewDirectByteBuffer__return, NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
2799 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
2800 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2801 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2802
a61af66fc99e Initial load
duke
parents:
diff changeset
2803 // Being paranoid about accidental sign extension on address
a61af66fc99e Initial load
duke
parents:
diff changeset
2804 jlong addr = (jlong) ((uintptr_t) address);
a61af66fc99e Initial load
duke
parents:
diff changeset
2805 // NOTE that package-private DirectByteBuffer constructor currently
a61af66fc99e Initial load
duke
parents:
diff changeset
2806 // takes int capacity
a61af66fc99e Initial load
duke
parents:
diff changeset
2807 jint cap = (jint) capacity;
a61af66fc99e Initial load
duke
parents:
diff changeset
2808 jobject ret = env->NewObject(directByteBufferClass, directByteBufferConstructor, addr, cap);
a61af66fc99e Initial load
duke
parents:
diff changeset
2809 DTRACE_PROBE1(hotspot_jni, NewDirectByteBuffer__return, ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
2810 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
2811 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2812
a61af66fc99e Initial load
duke
parents:
diff changeset
2813 DT_RETURN_MARK_DECL(GetDirectBufferAddress, void*);
a61af66fc99e Initial load
duke
parents:
diff changeset
2814
a61af66fc99e Initial load
duke
parents:
diff changeset
2815 extern "C" void* JNICALL jni_GetDirectBufferAddress(JNIEnv *env, jobject buf)
a61af66fc99e Initial load
duke
parents:
diff changeset
2816 {
a61af66fc99e Initial load
duke
parents:
diff changeset
2817 // thread_from_jni_environment() will block if VM is gone.
a61af66fc99e Initial load
duke
parents:
diff changeset
2818 JavaThread* thread = JavaThread::thread_from_jni_environment(env);
a61af66fc99e Initial load
duke
parents:
diff changeset
2819
a61af66fc99e Initial load
duke
parents:
diff changeset
2820 JNIWrapper("jni_GetDirectBufferAddress");
a61af66fc99e Initial load
duke
parents:
diff changeset
2821 DTRACE_PROBE2(hotspot_jni, GetDirectBufferAddress__entry, env, buf);
a61af66fc99e Initial load
duke
parents:
diff changeset
2822 void* ret = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
2823 DT_RETURN_MARK(GetDirectBufferAddress, void*, (const void*&)ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
2824
a61af66fc99e Initial load
duke
parents:
diff changeset
2825 if (!directBufferSupportInitializeEnded) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2826 if (!initializeDirectBufferSupport(env, thread)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2827 return 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
2828 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2829 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2830
a61af66fc99e Initial load
duke
parents:
diff changeset
2831 if ((buf != NULL) && (!env->IsInstanceOf(buf, directBufferClass))) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2832 return 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
2833 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2834
a61af66fc99e Initial load
duke
parents:
diff changeset
2835 ret = (void*)(intptr_t)env->GetLongField(buf, directBufferAddressField);
a61af66fc99e Initial load
duke
parents:
diff changeset
2836 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
2837 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2838
a61af66fc99e Initial load
duke
parents:
diff changeset
2839 DT_RETURN_MARK_DECL(GetDirectBufferCapacity, jlong);
a61af66fc99e Initial load
duke
parents:
diff changeset
2840
a61af66fc99e Initial load
duke
parents:
diff changeset
2841 extern "C" jlong JNICALL jni_GetDirectBufferCapacity(JNIEnv *env, jobject buf)
a61af66fc99e Initial load
duke
parents:
diff changeset
2842 {
a61af66fc99e Initial load
duke
parents:
diff changeset
2843 // thread_from_jni_environment() will block if VM is gone.
a61af66fc99e Initial load
duke
parents:
diff changeset
2844 JavaThread* thread = JavaThread::thread_from_jni_environment(env);
a61af66fc99e Initial load
duke
parents:
diff changeset
2845
a61af66fc99e Initial load
duke
parents:
diff changeset
2846 JNIWrapper("jni_GetDirectBufferCapacity");
a61af66fc99e Initial load
duke
parents:
diff changeset
2847 DTRACE_PROBE2(hotspot_jni, GetDirectBufferCapacity__entry, env, buf);
a61af66fc99e Initial load
duke
parents:
diff changeset
2848 jlong ret = -1;
a61af66fc99e Initial load
duke
parents:
diff changeset
2849 DT_RETURN_MARK(GetDirectBufferCapacity, jlong, (const jlong&)ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
2850
a61af66fc99e Initial load
duke
parents:
diff changeset
2851 if (!directBufferSupportInitializeEnded) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2852 if (!initializeDirectBufferSupport(env, thread)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2853 ret = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
2854 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
2855 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2856 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2857
a61af66fc99e Initial load
duke
parents:
diff changeset
2858 if (buf == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2859 return -1;
a61af66fc99e Initial load
duke
parents:
diff changeset
2860 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2861
a61af66fc99e Initial load
duke
parents:
diff changeset
2862 if (!env->IsInstanceOf(buf, directBufferClass)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2863 return -1;
a61af66fc99e Initial load
duke
parents:
diff changeset
2864 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2865
a61af66fc99e Initial load
duke
parents:
diff changeset
2866 // NOTE that capacity is currently an int in the implementation
a61af66fc99e Initial load
duke
parents:
diff changeset
2867 ret = env->GetIntField(buf, bufferCapacityField);
a61af66fc99e Initial load
duke
parents:
diff changeset
2868 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
2869 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2870
a61af66fc99e Initial load
duke
parents:
diff changeset
2871
a61af66fc99e Initial load
duke
parents:
diff changeset
2872 JNI_LEAF(jint, jni_GetVersion(JNIEnv *env))
a61af66fc99e Initial load
duke
parents:
diff changeset
2873 JNIWrapper("GetVersion");
a61af66fc99e Initial load
duke
parents:
diff changeset
2874 DTRACE_PROBE1(hotspot_jni, GetVersion__entry, env);
a61af66fc99e Initial load
duke
parents:
diff changeset
2875 DTRACE_PROBE1(hotspot_jni, GetVersion__return, CurrentVersion);
a61af66fc99e Initial load
duke
parents:
diff changeset
2876 return CurrentVersion;
a61af66fc99e Initial load
duke
parents:
diff changeset
2877 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
2878
a61af66fc99e Initial load
duke
parents:
diff changeset
2879 extern struct JavaVM_ main_vm;
a61af66fc99e Initial load
duke
parents:
diff changeset
2880
a61af66fc99e Initial load
duke
parents:
diff changeset
2881 JNI_LEAF(jint, jni_GetJavaVM(JNIEnv *env, JavaVM **vm))
a61af66fc99e Initial load
duke
parents:
diff changeset
2882 JNIWrapper("jni_GetJavaVM");
a61af66fc99e Initial load
duke
parents:
diff changeset
2883 DTRACE_PROBE2(hotspot_jni, GetJavaVM__entry, env, vm);
a61af66fc99e Initial load
duke
parents:
diff changeset
2884 *vm = (JavaVM *)(&main_vm);
a61af66fc99e Initial load
duke
parents:
diff changeset
2885 DTRACE_PROBE1(hotspot_jni, GetJavaVM__return, JNI_OK);
a61af66fc99e Initial load
duke
parents:
diff changeset
2886 return JNI_OK;
a61af66fc99e Initial load
duke
parents:
diff changeset
2887 JNI_END
a61af66fc99e Initial load
duke
parents:
diff changeset
2888
a61af66fc99e Initial load
duke
parents:
diff changeset
2889 // Structure containing all jni functions
a61af66fc99e Initial load
duke
parents:
diff changeset
2890 struct JNINativeInterface_ jni_NativeInterface = {
a61af66fc99e Initial load
duke
parents:
diff changeset
2891 NULL,
a61af66fc99e Initial load
duke
parents:
diff changeset
2892 NULL,
a61af66fc99e Initial load
duke
parents:
diff changeset
2893 NULL,
a61af66fc99e Initial load
duke
parents:
diff changeset
2894
a61af66fc99e Initial load
duke
parents:
diff changeset
2895 NULL,
a61af66fc99e Initial load
duke
parents:
diff changeset
2896
a61af66fc99e Initial load
duke
parents:
diff changeset
2897 jni_GetVersion,
a61af66fc99e Initial load
duke
parents:
diff changeset
2898
a61af66fc99e Initial load
duke
parents:
diff changeset
2899 jni_DefineClass,
a61af66fc99e Initial load
duke
parents:
diff changeset
2900 jni_FindClass,
a61af66fc99e Initial load
duke
parents:
diff changeset
2901
a61af66fc99e Initial load
duke
parents:
diff changeset
2902 jni_FromReflectedMethod,
a61af66fc99e Initial load
duke
parents:
diff changeset
2903 jni_FromReflectedField,
a61af66fc99e Initial load
duke
parents:
diff changeset
2904
a61af66fc99e Initial load
duke
parents:
diff changeset
2905 jni_ToReflectedMethod,
a61af66fc99e Initial load
duke
parents:
diff changeset
2906
a61af66fc99e Initial load
duke
parents:
diff changeset
2907 jni_GetSuperclass,
a61af66fc99e Initial load
duke
parents:
diff changeset
2908 jni_IsAssignableFrom,
a61af66fc99e Initial load
duke
parents:
diff changeset
2909
a61af66fc99e Initial load
duke
parents:
diff changeset
2910 jni_ToReflectedField,
a61af66fc99e Initial load
duke
parents:
diff changeset
2911
a61af66fc99e Initial load
duke
parents:
diff changeset
2912 jni_Throw,
a61af66fc99e Initial load
duke
parents:
diff changeset
2913 jni_ThrowNew,
a61af66fc99e Initial load
duke
parents:
diff changeset
2914 jni_ExceptionOccurred,
a61af66fc99e Initial load
duke
parents:
diff changeset
2915 jni_ExceptionDescribe,
a61af66fc99e Initial load
duke
parents:
diff changeset
2916 jni_ExceptionClear,
a61af66fc99e Initial load
duke
parents:
diff changeset
2917 jni_FatalError,
a61af66fc99e Initial load
duke
parents:
diff changeset
2918
a61af66fc99e Initial load
duke
parents:
diff changeset
2919 jni_PushLocalFrame,
a61af66fc99e Initial load
duke
parents:
diff changeset
2920 jni_PopLocalFrame,
a61af66fc99e Initial load
duke
parents:
diff changeset
2921
a61af66fc99e Initial load
duke
parents:
diff changeset
2922 jni_NewGlobalRef,
a61af66fc99e Initial load
duke
parents:
diff changeset
2923 jni_DeleteGlobalRef,
a61af66fc99e Initial load
duke
parents:
diff changeset
2924 jni_DeleteLocalRef,
a61af66fc99e Initial load
duke
parents:
diff changeset
2925 jni_IsSameObject,
a61af66fc99e Initial load
duke
parents:
diff changeset
2926
a61af66fc99e Initial load
duke
parents:
diff changeset
2927 jni_NewLocalRef,
a61af66fc99e Initial load
duke
parents:
diff changeset
2928 jni_EnsureLocalCapacity,
a61af66fc99e Initial load
duke
parents:
diff changeset
2929
a61af66fc99e Initial load
duke
parents:
diff changeset
2930 jni_AllocObject,
a61af66fc99e Initial load
duke
parents:
diff changeset
2931 jni_NewObject,
a61af66fc99e Initial load
duke
parents:
diff changeset
2932 jni_NewObjectV,
a61af66fc99e Initial load
duke
parents:
diff changeset
2933 jni_NewObjectA,
a61af66fc99e Initial load
duke
parents:
diff changeset
2934
a61af66fc99e Initial load
duke
parents:
diff changeset
2935 jni_GetObjectClass,
a61af66fc99e Initial load
duke
parents:
diff changeset
2936 jni_IsInstanceOf,
a61af66fc99e Initial load
duke
parents:
diff changeset
2937
a61af66fc99e Initial load
duke
parents:
diff changeset
2938 jni_GetMethodID,
a61af66fc99e Initial load
duke
parents:
diff changeset
2939
a61af66fc99e Initial load
duke
parents:
diff changeset
2940 jni_CallObjectMethod,
a61af66fc99e Initial load
duke
parents:
diff changeset
2941 jni_CallObjectMethodV,
a61af66fc99e Initial load
duke
parents:
diff changeset
2942 jni_CallObjectMethodA,
a61af66fc99e Initial load
duke
parents:
diff changeset
2943 jni_CallBooleanMethod,
a61af66fc99e Initial load
duke
parents:
diff changeset
2944 jni_CallBooleanMethodV,
a61af66fc99e Initial load
duke
parents:
diff changeset
2945 jni_CallBooleanMethodA,
a61af66fc99e Initial load
duke
parents:
diff changeset
2946 jni_CallByteMethod,
a61af66fc99e Initial load
duke
parents:
diff changeset
2947 jni_CallByteMethodV,
a61af66fc99e Initial load
duke
parents:
diff changeset
2948 jni_CallByteMethodA,
a61af66fc99e Initial load
duke
parents:
diff changeset
2949 jni_CallCharMethod,
a61af66fc99e Initial load
duke
parents:
diff changeset
2950 jni_CallCharMethodV,
a61af66fc99e Initial load
duke
parents:
diff changeset
2951 jni_CallCharMethodA,
a61af66fc99e Initial load
duke
parents:
diff changeset
2952 jni_CallShortMethod,
a61af66fc99e Initial load
duke
parents:
diff changeset
2953 jni_CallShortMethodV,
a61af66fc99e Initial load
duke
parents:
diff changeset
2954 jni_CallShortMethodA,
a61af66fc99e Initial load
duke
parents:
diff changeset
2955 jni_CallIntMethod,
a61af66fc99e Initial load
duke
parents:
diff changeset
2956 jni_CallIntMethodV,
a61af66fc99e Initial load
duke
parents:
diff changeset
2957 jni_CallIntMethodA,
a61af66fc99e Initial load
duke
parents:
diff changeset
2958 jni_CallLongMethod,
a61af66fc99e Initial load
duke
parents:
diff changeset
2959 jni_CallLongMethodV,
a61af66fc99e Initial load
duke
parents:
diff changeset
2960 jni_CallLongMethodA,
a61af66fc99e Initial load
duke
parents:
diff changeset
2961 jni_CallFloatMethod,
a61af66fc99e Initial load
duke
parents:
diff changeset
2962 jni_CallFloatMethodV,
a61af66fc99e Initial load
duke
parents:
diff changeset
2963 jni_CallFloatMethodA,
a61af66fc99e Initial load
duke
parents:
diff changeset
2964 jni_CallDoubleMethod,
a61af66fc99e Initial load
duke
parents:
diff changeset
2965 jni_CallDoubleMethodV,
a61af66fc99e Initial load
duke
parents:
diff changeset
2966 jni_CallDoubleMethodA,
a61af66fc99e Initial load
duke
parents:
diff changeset
2967 jni_CallVoidMethod,
a61af66fc99e Initial load
duke
parents:
diff changeset
2968 jni_CallVoidMethodV,
a61af66fc99e Initial load
duke
parents:
diff changeset
2969 jni_CallVoidMethodA,
a61af66fc99e Initial load
duke
parents:
diff changeset
2970
a61af66fc99e Initial load
duke
parents:
diff changeset
2971 jni_CallNonvirtualObjectMethod,
a61af66fc99e Initial load
duke
parents:
diff changeset
2972 jni_CallNonvirtualObjectMethodV,
a61af66fc99e Initial load
duke
parents:
diff changeset
2973 jni_CallNonvirtualObjectMethodA,
a61af66fc99e Initial load
duke
parents:
diff changeset
2974 jni_CallNonvirtualBooleanMethod,
a61af66fc99e Initial load
duke
parents:
diff changeset
2975 jni_CallNonvirtualBooleanMethodV,
a61af66fc99e Initial load
duke
parents:
diff changeset
2976 jni_CallNonvirtualBooleanMethodA,
a61af66fc99e Initial load
duke
parents:
diff changeset
2977 jni_CallNonvirtualByteMethod,
a61af66fc99e Initial load
duke
parents:
diff changeset
2978 jni_CallNonvirtualByteMethodV,
a61af66fc99e Initial load
duke
parents:
diff changeset
2979 jni_CallNonvirtualByteMethodA,
a61af66fc99e Initial load
duke
parents:
diff changeset
2980 jni_CallNonvirtualCharMethod,
a61af66fc99e Initial load
duke
parents:
diff changeset
2981 jni_CallNonvirtualCharMethodV,
a61af66fc99e Initial load
duke
parents:
diff changeset
2982 jni_CallNonvirtualCharMethodA,
a61af66fc99e Initial load
duke
parents:
diff changeset
2983 jni_CallNonvirtualShortMethod,
a61af66fc99e Initial load
duke
parents:
diff changeset
2984 jni_CallNonvirtualShortMethodV,
a61af66fc99e Initial load
duke
parents:
diff changeset
2985 jni_CallNonvirtualShortMethodA,
a61af66fc99e Initial load
duke
parents:
diff changeset
2986 jni_CallNonvirtualIntMethod,
a61af66fc99e Initial load
duke
parents:
diff changeset
2987 jni_CallNonvirtualIntMethodV,
a61af66fc99e Initial load
duke
parents:
diff changeset
2988 jni_CallNonvirtualIntMethodA,
a61af66fc99e Initial load
duke
parents:
diff changeset
2989 jni_CallNonvirtualLongMethod,
a61af66fc99e Initial load
duke
parents:
diff changeset
2990 jni_CallNonvirtualLongMethodV,
a61af66fc99e Initial load
duke
parents:
diff changeset
2991 jni_CallNonvirtualLongMethodA,
a61af66fc99e Initial load
duke
parents:
diff changeset
2992 jni_CallNonvirtualFloatMethod,
a61af66fc99e Initial load
duke
parents:
diff changeset
2993 jni_CallNonvirtualFloatMethodV,
a61af66fc99e Initial load
duke
parents:
diff changeset
2994 jni_CallNonvirtualFloatMethodA,
a61af66fc99e Initial load
duke
parents:
diff changeset
2995 jni_CallNonvirtualDoubleMethod,
a61af66fc99e Initial load
duke
parents:
diff changeset
2996 jni_CallNonvirtualDoubleMethodV,
a61af66fc99e Initial load
duke
parents:
diff changeset
2997 jni_CallNonvirtualDoubleMethodA,
a61af66fc99e Initial load
duke
parents:
diff changeset
2998 jni_CallNonvirtualVoidMethod,
a61af66fc99e Initial load
duke
parents:
diff changeset
2999 jni_CallNonvirtualVoidMethodV,
a61af66fc99e Initial load
duke
parents:
diff changeset
3000 jni_CallNonvirtualVoidMethodA,
a61af66fc99e Initial load
duke
parents:
diff changeset
3001
a61af66fc99e Initial load
duke
parents:
diff changeset
3002 jni_GetFieldID,
a61af66fc99e Initial load
duke
parents:
diff changeset
3003
a61af66fc99e Initial load
duke
parents:
diff changeset
3004 jni_GetObjectField,
a61af66fc99e Initial load
duke
parents:
diff changeset
3005 jni_GetBooleanField,
a61af66fc99e Initial load
duke
parents:
diff changeset
3006 jni_GetByteField,
a61af66fc99e Initial load
duke
parents:
diff changeset
3007 jni_GetCharField,
a61af66fc99e Initial load
duke
parents:
diff changeset
3008 jni_GetShortField,
a61af66fc99e Initial load
duke
parents:
diff changeset
3009 jni_GetIntField,
a61af66fc99e Initial load
duke
parents:
diff changeset
3010 jni_GetLongField,
a61af66fc99e Initial load
duke
parents:
diff changeset
3011 jni_GetFloatField,
a61af66fc99e Initial load
duke
parents:
diff changeset
3012 jni_GetDoubleField,
a61af66fc99e Initial load
duke
parents:
diff changeset
3013
a61af66fc99e Initial load
duke
parents:
diff changeset
3014 jni_SetObjectField,
a61af66fc99e Initial load
duke
parents:
diff changeset
3015 jni_SetBooleanField,
a61af66fc99e Initial load
duke
parents:
diff changeset
3016 jni_SetByteField,
a61af66fc99e Initial load
duke
parents:
diff changeset
3017 jni_SetCharField,
a61af66fc99e Initial load
duke
parents:
diff changeset
3018 jni_SetShortField,
a61af66fc99e Initial load
duke
parents:
diff changeset
3019 jni_SetIntField,
a61af66fc99e Initial load
duke
parents:
diff changeset
3020 jni_SetLongField,
a61af66fc99e Initial load
duke
parents:
diff changeset
3021 jni_SetFloatField,
a61af66fc99e Initial load
duke
parents:
diff changeset
3022 jni_SetDoubleField,
a61af66fc99e Initial load
duke
parents:
diff changeset
3023
a61af66fc99e Initial load
duke
parents:
diff changeset
3024 jni_GetStaticMethodID,
a61af66fc99e Initial load
duke
parents:
diff changeset
3025
a61af66fc99e Initial load
duke
parents:
diff changeset
3026 jni_CallStaticObjectMethod,
a61af66fc99e Initial load
duke
parents:
diff changeset
3027 jni_CallStaticObjectMethodV,
a61af66fc99e Initial load
duke
parents:
diff changeset
3028 jni_CallStaticObjectMethodA,
a61af66fc99e Initial load
duke
parents:
diff changeset
3029 jni_CallStaticBooleanMethod,
a61af66fc99e Initial load
duke
parents:
diff changeset
3030 jni_CallStaticBooleanMethodV,
a61af66fc99e Initial load
duke
parents:
diff changeset
3031 jni_CallStaticBooleanMethodA,
a61af66fc99e Initial load
duke
parents:
diff changeset
3032 jni_CallStaticByteMethod,
a61af66fc99e Initial load
duke
parents:
diff changeset
3033 jni_CallStaticByteMethodV,
a61af66fc99e Initial load
duke
parents:
diff changeset
3034 jni_CallStaticByteMethodA,
a61af66fc99e Initial load
duke
parents:
diff changeset
3035 jni_CallStaticCharMethod,
a61af66fc99e Initial load
duke
parents:
diff changeset
3036 jni_CallStaticCharMethodV,
a61af66fc99e Initial load
duke
parents:
diff changeset
3037 jni_CallStaticCharMethodA,
a61af66fc99e Initial load
duke
parents:
diff changeset
3038 jni_CallStaticShortMethod,
a61af66fc99e Initial load
duke
parents:
diff changeset
3039 jni_CallStaticShortMethodV,
a61af66fc99e Initial load
duke
parents:
diff changeset
3040 jni_CallStaticShortMethodA,
a61af66fc99e Initial load
duke
parents:
diff changeset
3041 jni_CallStaticIntMethod,
a61af66fc99e Initial load
duke
parents:
diff changeset
3042 jni_CallStaticIntMethodV,
a61af66fc99e Initial load
duke
parents:
diff changeset
3043 jni_CallStaticIntMethodA,
a61af66fc99e Initial load
duke
parents:
diff changeset
3044 jni_CallStaticLongMethod,
a61af66fc99e Initial load
duke
parents:
diff changeset
3045 jni_CallStaticLongMethodV,
a61af66fc99e Initial load
duke
parents:
diff changeset
3046 jni_CallStaticLongMethodA,
a61af66fc99e Initial load
duke
parents:
diff changeset
3047 jni_CallStaticFloatMethod,
a61af66fc99e Initial load
duke
parents:
diff changeset
3048 jni_CallStaticFloatMethodV,
a61af66fc99e Initial load
duke
parents:
diff changeset
3049 jni_CallStaticFloatMethodA,
a61af66fc99e Initial load
duke
parents:
diff changeset
3050 jni_CallStaticDoubleMethod,
a61af66fc99e Initial load
duke
parents:
diff changeset
3051 jni_CallStaticDoubleMethodV,
a61af66fc99e Initial load
duke
parents:
diff changeset
3052 jni_CallStaticDoubleMethodA,
a61af66fc99e Initial load
duke
parents:
diff changeset
3053 jni_CallStaticVoidMethod,
a61af66fc99e Initial load
duke
parents:
diff changeset
3054 jni_CallStaticVoidMethodV,
a61af66fc99e Initial load
duke
parents:
diff changeset
3055 jni_CallStaticVoidMethodA,
a61af66fc99e Initial load
duke
parents:
diff changeset
3056
a61af66fc99e Initial load
duke
parents:
diff changeset
3057 jni_GetStaticFieldID,
a61af66fc99e Initial load
duke
parents:
diff changeset
3058
a61af66fc99e Initial load
duke
parents:
diff changeset
3059 jni_GetStaticObjectField,
a61af66fc99e Initial load
duke
parents:
diff changeset
3060 jni_GetStaticBooleanField,
a61af66fc99e Initial load
duke
parents:
diff changeset
3061 jni_GetStaticByteField,
a61af66fc99e Initial load
duke
parents:
diff changeset
3062 jni_GetStaticCharField,
a61af66fc99e Initial load
duke
parents:
diff changeset
3063 jni_GetStaticShortField,
a61af66fc99e Initial load
duke
parents:
diff changeset
3064 jni_GetStaticIntField,
a61af66fc99e Initial load
duke
parents:
diff changeset
3065 jni_GetStaticLongField,
a61af66fc99e Initial load
duke
parents:
diff changeset
3066 jni_GetStaticFloatField,
a61af66fc99e Initial load
duke
parents:
diff changeset
3067 jni_GetStaticDoubleField,
a61af66fc99e Initial load
duke
parents:
diff changeset
3068
a61af66fc99e Initial load
duke
parents:
diff changeset
3069 jni_SetStaticObjectField,
a61af66fc99e Initial load
duke
parents:
diff changeset
3070 jni_SetStaticBooleanField,
a61af66fc99e Initial load
duke
parents:
diff changeset
3071 jni_SetStaticByteField,
a61af66fc99e Initial load
duke
parents:
diff changeset
3072 jni_SetStaticCharField,
a61af66fc99e Initial load
duke
parents:
diff changeset
3073 jni_SetStaticShortField,
a61af66fc99e Initial load
duke
parents:
diff changeset
3074 jni_SetStaticIntField,
a61af66fc99e Initial load
duke
parents:
diff changeset
3075 jni_SetStaticLongField,
a61af66fc99e Initial load
duke
parents:
diff changeset
3076 jni_SetStaticFloatField,
a61af66fc99e Initial load
duke
parents:
diff changeset
3077 jni_SetStaticDoubleField,
a61af66fc99e Initial load
duke
parents:
diff changeset
3078
a61af66fc99e Initial load
duke
parents:
diff changeset
3079 jni_NewString,
a61af66fc99e Initial load
duke
parents:
diff changeset
3080 jni_GetStringLength,
a61af66fc99e Initial load
duke
parents:
diff changeset
3081 jni_GetStringChars,
a61af66fc99e Initial load
duke
parents:
diff changeset
3082 jni_ReleaseStringChars,
a61af66fc99e Initial load
duke
parents:
diff changeset
3083
a61af66fc99e Initial load
duke
parents:
diff changeset
3084 jni_NewStringUTF,
a61af66fc99e Initial load
duke
parents:
diff changeset
3085 jni_GetStringUTFLength,
a61af66fc99e Initial load
duke
parents:
diff changeset
3086 jni_GetStringUTFChars,
a61af66fc99e Initial load
duke
parents:
diff changeset
3087 jni_ReleaseStringUTFChars,
a61af66fc99e Initial load
duke
parents:
diff changeset
3088
a61af66fc99e Initial load
duke
parents:
diff changeset
3089 jni_GetArrayLength,
a61af66fc99e Initial load
duke
parents:
diff changeset
3090
a61af66fc99e Initial load
duke
parents:
diff changeset
3091 jni_NewObjectArray,
a61af66fc99e Initial load
duke
parents:
diff changeset
3092 jni_GetObjectArrayElement,
a61af66fc99e Initial load
duke
parents:
diff changeset
3093 jni_SetObjectArrayElement,
a61af66fc99e Initial load
duke
parents:
diff changeset
3094
a61af66fc99e Initial load
duke
parents:
diff changeset
3095 jni_NewBooleanArray,
a61af66fc99e Initial load
duke
parents:
diff changeset
3096 jni_NewByteArray,
a61af66fc99e Initial load
duke
parents:
diff changeset
3097 jni_NewCharArray,
a61af66fc99e Initial load
duke
parents:
diff changeset
3098 jni_NewShortArray,
a61af66fc99e Initial load
duke
parents:
diff changeset
3099 jni_NewIntArray,
a61af66fc99e Initial load
duke
parents:
diff changeset
3100 jni_NewLongArray,
a61af66fc99e Initial load
duke
parents:
diff changeset
3101 jni_NewFloatArray,
a61af66fc99e Initial load
duke
parents:
diff changeset
3102 jni_NewDoubleArray,
a61af66fc99e Initial load
duke
parents:
diff changeset
3103
a61af66fc99e Initial load
duke
parents:
diff changeset
3104 jni_GetBooleanArrayElements,
a61af66fc99e Initial load
duke
parents:
diff changeset
3105 jni_GetByteArrayElements,
a61af66fc99e Initial load
duke
parents:
diff changeset
3106 jni_GetCharArrayElements,
a61af66fc99e Initial load
duke
parents:
diff changeset
3107 jni_GetShortArrayElements,
a61af66fc99e Initial load
duke
parents:
diff changeset
3108 jni_GetIntArrayElements,
a61af66fc99e Initial load
duke
parents:
diff changeset
3109 jni_GetLongArrayElements,
a61af66fc99e Initial load
duke
parents:
diff changeset
3110 jni_GetFloatArrayElements,
a61af66fc99e Initial load
duke
parents:
diff changeset
3111 jni_GetDoubleArrayElements,
a61af66fc99e Initial load
duke
parents:
diff changeset
3112
a61af66fc99e Initial load
duke
parents:
diff changeset
3113 jni_ReleaseBooleanArrayElements,
a61af66fc99e Initial load
duke
parents:
diff changeset
3114 jni_ReleaseByteArrayElements,
a61af66fc99e Initial load
duke
parents:
diff changeset
3115 jni_ReleaseCharArrayElements,
a61af66fc99e Initial load
duke
parents:
diff changeset
3116 jni_ReleaseShortArrayElements,
a61af66fc99e Initial load
duke
parents:
diff changeset
3117 jni_ReleaseIntArrayElements,
a61af66fc99e Initial load
duke
parents:
diff changeset
3118 jni_ReleaseLongArrayElements,
a61af66fc99e Initial load
duke
parents:
diff changeset
3119 jni_ReleaseFloatArrayElements,
a61af66fc99e Initial load
duke
parents:
diff changeset
3120 jni_ReleaseDoubleArrayElements,
a61af66fc99e Initial load
duke
parents:
diff changeset
3121
a61af66fc99e Initial load
duke
parents:
diff changeset
3122 jni_GetBooleanArrayRegion,
a61af66fc99e Initial load
duke
parents:
diff changeset
3123 jni_GetByteArrayRegion,
a61af66fc99e Initial load
duke
parents:
diff changeset
3124 jni_GetCharArrayRegion,
a61af66fc99e Initial load
duke
parents:
diff changeset
3125 jni_GetShortArrayRegion,
a61af66fc99e Initial load
duke
parents:
diff changeset
3126 jni_GetIntArrayRegion,
a61af66fc99e Initial load
duke
parents:
diff changeset
3127 jni_GetLongArrayRegion,
a61af66fc99e Initial load
duke
parents:
diff changeset
3128 jni_GetFloatArrayRegion,
a61af66fc99e Initial load
duke
parents:
diff changeset
3129 jni_GetDoubleArrayRegion,
a61af66fc99e Initial load
duke
parents:
diff changeset
3130
a61af66fc99e Initial load
duke
parents:
diff changeset
3131 jni_SetBooleanArrayRegion,
a61af66fc99e Initial load
duke
parents:
diff changeset
3132 jni_SetByteArrayRegion,
a61af66fc99e Initial load
duke
parents:
diff changeset
3133 jni_SetCharArrayRegion,
a61af66fc99e Initial load
duke
parents:
diff changeset
3134 jni_SetShortArrayRegion,
a61af66fc99e Initial load
duke
parents:
diff changeset
3135 jni_SetIntArrayRegion,
a61af66fc99e Initial load
duke
parents:
diff changeset
3136 jni_SetLongArrayRegion,
a61af66fc99e Initial load
duke
parents:
diff changeset
3137 jni_SetFloatArrayRegion,
a61af66fc99e Initial load
duke
parents:
diff changeset
3138 jni_SetDoubleArrayRegion,
a61af66fc99e Initial load
duke
parents:
diff changeset
3139
a61af66fc99e Initial load
duke
parents:
diff changeset
3140 jni_RegisterNatives,
a61af66fc99e Initial load
duke
parents:
diff changeset
3141 jni_UnregisterNatives,
a61af66fc99e Initial load
duke
parents:
diff changeset
3142
a61af66fc99e Initial load
duke
parents:
diff changeset
3143 jni_MonitorEnter,
a61af66fc99e Initial load
duke
parents:
diff changeset
3144 jni_MonitorExit,
a61af66fc99e Initial load
duke
parents:
diff changeset
3145
a61af66fc99e Initial load
duke
parents:
diff changeset
3146 jni_GetJavaVM,
a61af66fc99e Initial load
duke
parents:
diff changeset
3147
a61af66fc99e Initial load
duke
parents:
diff changeset
3148 jni_GetStringRegion,
a61af66fc99e Initial load
duke
parents:
diff changeset
3149 jni_GetStringUTFRegion,
a61af66fc99e Initial load
duke
parents:
diff changeset
3150
a61af66fc99e Initial load
duke
parents:
diff changeset
3151 jni_GetPrimitiveArrayCritical,
a61af66fc99e Initial load
duke
parents:
diff changeset
3152 jni_ReleasePrimitiveArrayCritical,
a61af66fc99e Initial load
duke
parents:
diff changeset
3153
a61af66fc99e Initial load
duke
parents:
diff changeset
3154 jni_GetStringCritical,
a61af66fc99e Initial load
duke
parents:
diff changeset
3155 jni_ReleaseStringCritical,
a61af66fc99e Initial load
duke
parents:
diff changeset
3156
a61af66fc99e Initial load
duke
parents:
diff changeset
3157 jni_NewWeakGlobalRef,
a61af66fc99e Initial load
duke
parents:
diff changeset
3158 jni_DeleteWeakGlobalRef,
a61af66fc99e Initial load
duke
parents:
diff changeset
3159
a61af66fc99e Initial load
duke
parents:
diff changeset
3160 jni_ExceptionCheck,
a61af66fc99e Initial load
duke
parents:
diff changeset
3161
a61af66fc99e Initial load
duke
parents:
diff changeset
3162 jni_NewDirectByteBuffer,
a61af66fc99e Initial load
duke
parents:
diff changeset
3163 jni_GetDirectBufferAddress,
a61af66fc99e Initial load
duke
parents:
diff changeset
3164 jni_GetDirectBufferCapacity,
a61af66fc99e Initial load
duke
parents:
diff changeset
3165
a61af66fc99e Initial load
duke
parents:
diff changeset
3166 // New 1_6 features
a61af66fc99e Initial load
duke
parents:
diff changeset
3167
a61af66fc99e Initial load
duke
parents:
diff changeset
3168 jni_GetObjectRefType
a61af66fc99e Initial load
duke
parents:
diff changeset
3169 };
a61af66fc99e Initial load
duke
parents:
diff changeset
3170
a61af66fc99e Initial load
duke
parents:
diff changeset
3171
a61af66fc99e Initial load
duke
parents:
diff changeset
3172 // For jvmti use to modify jni function table.
a61af66fc99e Initial load
duke
parents:
diff changeset
3173 // Java threads in native contiues to run until it is transitioned
a61af66fc99e Initial load
duke
parents:
diff changeset
3174 // to VM at safepoint. Before the transition or before it is blocked
a61af66fc99e Initial load
duke
parents:
diff changeset
3175 // for safepoint it may access jni function table. VM could crash if
a61af66fc99e Initial load
duke
parents:
diff changeset
3176 // any java thread access the jni function table in the middle of memcpy.
a61af66fc99e Initial load
duke
parents:
diff changeset
3177 // To avoid this each function pointers are copied automically.
a61af66fc99e Initial load
duke
parents:
diff changeset
3178 void copy_jni_function_table(const struct JNINativeInterface_ *new_jni_NativeInterface) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3179 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");
a61af66fc99e Initial load
duke
parents:
diff changeset
3180 intptr_t *a = (intptr_t *) jni_functions();
a61af66fc99e Initial load
duke
parents:
diff changeset
3181 intptr_t *b = (intptr_t *) new_jni_NativeInterface;
a61af66fc99e Initial load
duke
parents:
diff changeset
3182 for (uint i=0; i < sizeof(struct JNINativeInterface_)/sizeof(void *); i++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3183 Atomic::store_ptr(*b++, a++);
a61af66fc99e Initial load
duke
parents:
diff changeset
3184 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3185 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3186
a61af66fc99e Initial load
duke
parents:
diff changeset
3187 void quicken_jni_functions() {
a61af66fc99e Initial load
duke
parents:
diff changeset
3188 // Replace Get<Primitive>Field with fast versions
a61af66fc99e Initial load
duke
parents:
diff changeset
3189 if (UseFastJNIAccessors && !JvmtiExport::can_post_field_access()
a61af66fc99e Initial load
duke
parents:
diff changeset
3190 && !VerifyJNIFields && !TraceJNICalls && !CountJNICalls && !CheckJNICalls
a61af66fc99e Initial load
duke
parents:
diff changeset
3191 #if defined(_WINDOWS) && defined(IA32) && defined(COMPILER2)
a61af66fc99e Initial load
duke
parents:
diff changeset
3192 // windows x86 currently needs SEH wrapper and the gain of the fast
a61af66fc99e Initial load
duke
parents:
diff changeset
3193 // versions currently isn't certain for server vm on uniprocessor.
a61af66fc99e Initial load
duke
parents:
diff changeset
3194 && os::is_MP()
a61af66fc99e Initial load
duke
parents:
diff changeset
3195 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
3196 ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3197 address func;
a61af66fc99e Initial load
duke
parents:
diff changeset
3198 func = JNI_FastGetField::generate_fast_get_boolean_field();
a61af66fc99e Initial load
duke
parents:
diff changeset
3199 if (func != (address)-1) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3200 jni_NativeInterface.GetBooleanField = (GetBooleanField_t)func;
a61af66fc99e Initial load
duke
parents:
diff changeset
3201 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3202 func = JNI_FastGetField::generate_fast_get_byte_field();
a61af66fc99e Initial load
duke
parents:
diff changeset
3203 if (func != (address)-1) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3204 jni_NativeInterface.GetByteField = (GetByteField_t)func;
a61af66fc99e Initial load
duke
parents:
diff changeset
3205 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3206 func = JNI_FastGetField::generate_fast_get_char_field();
a61af66fc99e Initial load
duke
parents:
diff changeset
3207 if (func != (address)-1) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3208 jni_NativeInterface.GetCharField = (GetCharField_t)func;
a61af66fc99e Initial load
duke
parents:
diff changeset
3209 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3210 func = JNI_FastGetField::generate_fast_get_short_field();
a61af66fc99e Initial load
duke
parents:
diff changeset
3211 if (func != (address)-1) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3212 jni_NativeInterface.GetShortField = (GetShortField_t)func;
a61af66fc99e Initial load
duke
parents:
diff changeset
3213 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3214 func = JNI_FastGetField::generate_fast_get_int_field();
a61af66fc99e Initial load
duke
parents:
diff changeset
3215 if (func != (address)-1) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3216 jni_NativeInterface.GetIntField = (GetIntField_t)func;
a61af66fc99e Initial load
duke
parents:
diff changeset
3217 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3218 func = JNI_FastGetField::generate_fast_get_long_field();
a61af66fc99e Initial load
duke
parents:
diff changeset
3219 if (func != (address)-1) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3220 jni_NativeInterface.GetLongField = (GetLongField_t)func;
a61af66fc99e Initial load
duke
parents:
diff changeset
3221 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3222 func = JNI_FastGetField::generate_fast_get_float_field();
a61af66fc99e Initial load
duke
parents:
diff changeset
3223 if (func != (address)-1) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3224 jni_NativeInterface.GetFloatField = (GetFloatField_t)func;
a61af66fc99e Initial load
duke
parents:
diff changeset
3225 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3226 func = JNI_FastGetField::generate_fast_get_double_field();
a61af66fc99e Initial load
duke
parents:
diff changeset
3227 if (func != (address)-1) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3228 jni_NativeInterface.GetDoubleField = (GetDoubleField_t)func;
a61af66fc99e Initial load
duke
parents:
diff changeset
3229 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3230 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3231 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3232
a61af66fc99e Initial load
duke
parents:
diff changeset
3233 // Returns the function structure
a61af66fc99e Initial load
duke
parents:
diff changeset
3234 struct JNINativeInterface_* jni_functions() {
a61af66fc99e Initial load
duke
parents:
diff changeset
3235 #ifndef JNICHECK_KERNEL
a61af66fc99e Initial load
duke
parents:
diff changeset
3236 if (CheckJNICalls) return jni_functions_check();
a61af66fc99e Initial load
duke
parents:
diff changeset
3237 #else // JNICHECK_KERNEL
a61af66fc99e Initial load
duke
parents:
diff changeset
3238 if (CheckJNICalls) warning("-Xcheck:jni is not supported in kernel vm.");
a61af66fc99e Initial load
duke
parents:
diff changeset
3239 #endif // JNICHECK_KERNEL
a61af66fc99e Initial load
duke
parents:
diff changeset
3240 return &jni_NativeInterface;
a61af66fc99e Initial load
duke
parents:
diff changeset
3241 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3242
a61af66fc99e Initial load
duke
parents:
diff changeset
3243 // Returns the function structure
a61af66fc99e Initial load
duke
parents:
diff changeset
3244 struct JNINativeInterface_* jni_functions_nocheck() {
a61af66fc99e Initial load
duke
parents:
diff changeset
3245 return &jni_NativeInterface;
a61af66fc99e Initial load
duke
parents:
diff changeset
3246 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3247
a61af66fc99e Initial load
duke
parents:
diff changeset
3248
a61af66fc99e Initial load
duke
parents:
diff changeset
3249 // Invocation API
a61af66fc99e Initial load
duke
parents:
diff changeset
3250
a61af66fc99e Initial load
duke
parents:
diff changeset
3251
a61af66fc99e Initial load
duke
parents:
diff changeset
3252 // Forward declaration
a61af66fc99e Initial load
duke
parents:
diff changeset
3253 extern const struct JNIInvokeInterface_ jni_InvokeInterface;
a61af66fc99e Initial load
duke
parents:
diff changeset
3254
a61af66fc99e Initial load
duke
parents:
diff changeset
3255 // Global invocation API vars
a61af66fc99e Initial load
duke
parents:
diff changeset
3256 volatile jint vm_created = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
3257 // Indicate whether it is safe to recreate VM
a61af66fc99e Initial load
duke
parents:
diff changeset
3258 volatile jint safe_to_recreate_vm = 1;
a61af66fc99e Initial load
duke
parents:
diff changeset
3259 struct JavaVM_ main_vm = {&jni_InvokeInterface};
a61af66fc99e Initial load
duke
parents:
diff changeset
3260
a61af66fc99e Initial load
duke
parents:
diff changeset
3261
a61af66fc99e Initial load
duke
parents:
diff changeset
3262 #define JAVASTACKSIZE (400 * 1024) /* Default size of a thread java stack */
a61af66fc99e Initial load
duke
parents:
diff changeset
3263 enum { VERIFY_NONE, VERIFY_REMOTE, VERIFY_ALL };
a61af66fc99e Initial load
duke
parents:
diff changeset
3264
a61af66fc99e Initial load
duke
parents:
diff changeset
3265 HS_DTRACE_PROBE_DECL1(hotspot_jni, GetDefaultJavaVMInitArgs__entry, void*);
a61af66fc99e Initial load
duke
parents:
diff changeset
3266 DT_RETURN_MARK_DECL(GetDefaultJavaVMInitArgs, jint);
a61af66fc99e Initial load
duke
parents:
diff changeset
3267
a61af66fc99e Initial load
duke
parents:
diff changeset
3268 _JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_GetDefaultJavaVMInitArgs(void *args_) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3269 HS_DTRACE_PROBE1(hotspot_jni, GetDefaultJavaVMInitArgs__entry, args_);
a61af66fc99e Initial load
duke
parents:
diff changeset
3270 JDK1_1InitArgs *args = (JDK1_1InitArgs *)args_;
a61af66fc99e Initial load
duke
parents:
diff changeset
3271 jint ret = JNI_ERR;
a61af66fc99e Initial load
duke
parents:
diff changeset
3272 DT_RETURN_MARK(GetDefaultJavaVMInitArgs, jint, (const jint&)ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
3273
a61af66fc99e Initial load
duke
parents:
diff changeset
3274 if (Threads::is_supported_jni_version(args->version)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3275 ret = JNI_OK;
a61af66fc99e Initial load
duke
parents:
diff changeset
3276 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3277 // 1.1 style no longer supported in hotspot.
a61af66fc99e Initial load
duke
parents:
diff changeset
3278 // According the JNI spec, we should update args->version on return.
a61af66fc99e Initial load
duke
parents:
diff changeset
3279 // We also use the structure to communicate with launcher about default
a61af66fc99e Initial load
duke
parents:
diff changeset
3280 // stack size.
a61af66fc99e Initial load
duke
parents:
diff changeset
3281 if (args->version == JNI_VERSION_1_1) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3282 args->version = JNI_VERSION_1_2;
a61af66fc99e Initial load
duke
parents:
diff changeset
3283 // javaStackSize is int in arguments structure
a61af66fc99e Initial load
duke
parents:
diff changeset
3284 assert(jlong(ThreadStackSize) * K < INT_MAX, "integer overflow");
a61af66fc99e Initial load
duke
parents:
diff changeset
3285 args->javaStackSize = (jint)(ThreadStackSize * K);
a61af66fc99e Initial load
duke
parents:
diff changeset
3286 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3287 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
3288 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3289
3779
04760e41b01e 7016112: CMS: crash during promotion testing
brutisso
parents: 3249
diff changeset
3290 #ifndef PRODUCT
04760e41b01e 7016112: CMS: crash during promotion testing
brutisso
parents: 3249
diff changeset
3291
04760e41b01e 7016112: CMS: crash during promotion testing
brutisso
parents: 3249
diff changeset
3292 #include "utilities/quickSort.hpp"
04760e41b01e 7016112: CMS: crash during promotion testing
brutisso
parents: 3249
diff changeset
3293
04760e41b01e 7016112: CMS: crash during promotion testing
brutisso
parents: 3249
diff changeset
3294 void execute_internal_vm_tests() {
04760e41b01e 7016112: CMS: crash during promotion testing
brutisso
parents: 3249
diff changeset
3295 if (ExecuteInternalVMTests) {
04760e41b01e 7016112: CMS: crash during promotion testing
brutisso
parents: 3249
diff changeset
3296 assert(QuickSort::test_quick_sort(), "test_quick_sort failed");
04760e41b01e 7016112: CMS: crash during promotion testing
brutisso
parents: 3249
diff changeset
3297 tty->print_cr("All tests passed");
04760e41b01e 7016112: CMS: crash during promotion testing
brutisso
parents: 3249
diff changeset
3298 }
04760e41b01e 7016112: CMS: crash during promotion testing
brutisso
parents: 3249
diff changeset
3299 }
04760e41b01e 7016112: CMS: crash during promotion testing
brutisso
parents: 3249
diff changeset
3300
04760e41b01e 7016112: CMS: crash during promotion testing
brutisso
parents: 3249
diff changeset
3301 #endif
04760e41b01e 7016112: CMS: crash during promotion testing
brutisso
parents: 3249
diff changeset
3302
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3303 HS_DTRACE_PROBE_DECL3(hotspot_jni, CreateJavaVM__entry, vm, penv, args);
a61af66fc99e Initial load
duke
parents:
diff changeset
3304 DT_RETURN_MARK_DECL(CreateJavaVM, jint);
a61af66fc99e Initial load
duke
parents:
diff changeset
3305
a61af66fc99e Initial load
duke
parents:
diff changeset
3306 _JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_CreateJavaVM(JavaVM **vm, void **penv, void *args) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3307 HS_DTRACE_PROBE3(hotspot_jni, CreateJavaVM__entry, vm, penv, args);
a61af66fc99e Initial load
duke
parents:
diff changeset
3308
a61af66fc99e Initial load
duke
parents:
diff changeset
3309 jint result = JNI_ERR;
a61af66fc99e Initial load
duke
parents:
diff changeset
3310 DT_RETURN_MARK(CreateJavaVM, jint, (const jint&)result);
a61af66fc99e Initial load
duke
parents:
diff changeset
3311
1078
8e7adf982378 6896043: first round of zero fixes
twisti
parents: 1034
diff changeset
3312 // We're about to use Atomic::xchg for synchronization. Some Zero
8e7adf982378 6896043: first round of zero fixes
twisti
parents: 1034
diff changeset
3313 // platforms use the GCC builtin __sync_lock_test_and_set for this,
8e7adf982378 6896043: first round of zero fixes
twisti
parents: 1034
diff changeset
3314 // but __sync_lock_test_and_set is not guaranteed to do what we want
8e7adf982378 6896043: first round of zero fixes
twisti
parents: 1034
diff changeset
3315 // on all architectures. So we check it works before relying on it.
8e7adf982378 6896043: first round of zero fixes
twisti
parents: 1034
diff changeset
3316 #if defined(ZERO) && defined(ASSERT)
8e7adf982378 6896043: first round of zero fixes
twisti
parents: 1034
diff changeset
3317 {
8e7adf982378 6896043: first round of zero fixes
twisti
parents: 1034
diff changeset
3318 jint a = 0xcafebabe;
8e7adf982378 6896043: first round of zero fixes
twisti
parents: 1034
diff changeset
3319 jint b = Atomic::xchg(0xdeadbeef, &a);
8e7adf982378 6896043: first round of zero fixes
twisti
parents: 1034
diff changeset
3320 void *c = &a;
8e7adf982378 6896043: first round of zero fixes
twisti
parents: 1034
diff changeset
3321 void *d = Atomic::xchg_ptr(&b, &c);
1132
896da934748c 6913869: Zero assert fix
twisti
parents: 1078
diff changeset
3322 assert(a == (jint) 0xdeadbeef && b == (jint) 0xcafebabe, "Atomic::xchg() works");
1078
8e7adf982378 6896043: first round of zero fixes
twisti
parents: 1034
diff changeset
3323 assert(c == &b && d == &a, "Atomic::xchg_ptr() works");
8e7adf982378 6896043: first round of zero fixes
twisti
parents: 1034
diff changeset
3324 }
8e7adf982378 6896043: first round of zero fixes
twisti
parents: 1034
diff changeset
3325 #endif // ZERO && ASSERT
8e7adf982378 6896043: first round of zero fixes
twisti
parents: 1034
diff changeset
3326
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3327 // At the moment it's only possible to have one Java VM,
a61af66fc99e Initial load
duke
parents:
diff changeset
3328 // since some of the runtime state is in global variables.
a61af66fc99e Initial load
duke
parents:
diff changeset
3329
a61af66fc99e Initial load
duke
parents:
diff changeset
3330 // We cannot use our mutex locks here, since they only work on
a61af66fc99e Initial load
duke
parents:
diff changeset
3331 // Threads. We do an atomic compare and exchange to ensure only
a61af66fc99e Initial load
duke
parents:
diff changeset
3332 // one thread can call this method at a time
a61af66fc99e Initial load
duke
parents:
diff changeset
3333
a61af66fc99e Initial load
duke
parents:
diff changeset
3334 // We use Atomic::xchg rather than Atomic::add/dec since on some platforms
a61af66fc99e Initial load
duke
parents:
diff changeset
3335 // the add/dec implementations are dependent on whether we are running
a61af66fc99e Initial load
duke
parents:
diff changeset
3336 // on a multiprocessor, and at this stage of initialization the os::is_MP
a61af66fc99e Initial load
duke
parents:
diff changeset
3337 // function used to determine this will always return false. Atomic::xchg
a61af66fc99e Initial load
duke
parents:
diff changeset
3338 // does not have this problem.
a61af66fc99e Initial load
duke
parents:
diff changeset
3339 if (Atomic::xchg(1, &vm_created) == 1) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3340 return JNI_ERR; // already created, or create attempt in progress
a61af66fc99e Initial load
duke
parents:
diff changeset
3341 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3342 if (Atomic::xchg(0, &safe_to_recreate_vm) == 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3343 return JNI_ERR; // someone tried and failed and retry not allowed.
a61af66fc99e Initial load
duke
parents:
diff changeset
3344 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3345
a61af66fc99e Initial load
duke
parents:
diff changeset
3346 assert(vm_created == 1, "vm_created is true during the creation");
a61af66fc99e Initial load
duke
parents:
diff changeset
3347
a61af66fc99e Initial load
duke
parents:
diff changeset
3348 /**
a61af66fc99e Initial load
duke
parents:
diff changeset
3349 * Certain errors during initialization are recoverable and do not
a61af66fc99e Initial load
duke
parents:
diff changeset
3350 * prevent this method from being called again at a later time
a61af66fc99e Initial load
duke
parents:
diff changeset
3351 * (perhaps with different arguments). However, at a certain
a61af66fc99e Initial load
duke
parents:
diff changeset
3352 * point during initialization if an error occurs we cannot allow
a61af66fc99e Initial load
duke
parents:
diff changeset
3353 * this function to be called again (or it will crash). In those
a61af66fc99e Initial load
duke
parents:
diff changeset
3354 * situations, the 'canTryAgain' flag is set to false, which atomically
a61af66fc99e Initial load
duke
parents:
diff changeset
3355 * sets safe_to_recreate_vm to 1, such that any new call to
a61af66fc99e Initial load
duke
parents:
diff changeset
3356 * JNI_CreateJavaVM will immediately fail using the above logic.
a61af66fc99e Initial load
duke
parents:
diff changeset
3357 */
a61af66fc99e Initial load
duke
parents:
diff changeset
3358 bool can_try_again = true;
a61af66fc99e Initial load
duke
parents:
diff changeset
3359
a61af66fc99e Initial load
duke
parents:
diff changeset
3360 result = Threads::create_vm((JavaVMInitArgs*) args, &can_try_again);
a61af66fc99e Initial load
duke
parents:
diff changeset
3361 if (result == JNI_OK) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3362 JavaThread *thread = JavaThread::current();
a61af66fc99e Initial load
duke
parents:
diff changeset
3363 /* thread is thread_in_vm here */
a61af66fc99e Initial load
duke
parents:
diff changeset
3364 *vm = (JavaVM *)(&main_vm);
a61af66fc99e Initial load
duke
parents:
diff changeset
3365 *(JNIEnv**)penv = thread->jni_environment();
a61af66fc99e Initial load
duke
parents:
diff changeset
3366
a61af66fc99e Initial load
duke
parents:
diff changeset
3367 // Tracks the time application was running before GC
a61af66fc99e Initial load
duke
parents:
diff changeset
3368 RuntimeService::record_application_start();
a61af66fc99e Initial load
duke
parents:
diff changeset
3369
a61af66fc99e Initial load
duke
parents:
diff changeset
3370 // Notify JVMTI
a61af66fc99e Initial load
duke
parents:
diff changeset
3371 if (JvmtiExport::should_post_thread_life()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3372 JvmtiExport::post_thread_start(thread);
a61af66fc99e Initial load
duke
parents:
diff changeset
3373 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3374 // Check if we should compile all classes on bootclasspath
a61af66fc99e Initial load
duke
parents:
diff changeset
3375 NOT_PRODUCT(if (CompileTheWorld) ClassLoader::compile_the_world();)
a61af66fc99e Initial load
duke
parents:
diff changeset
3376 // Since this is not a JVM_ENTRY we have to set the thread state manually before leaving.
a61af66fc99e Initial load
duke
parents:
diff changeset
3377 ThreadStateTransition::transition_and_fence(thread, _thread_in_vm, _thread_in_native);
a61af66fc99e Initial load
duke
parents:
diff changeset
3378 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
3379 if (can_try_again) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3380 // reset safe_to_recreate_vm to 1 so that retrial would be possible
a61af66fc99e Initial load
duke
parents:
diff changeset
3381 safe_to_recreate_vm = 1;
a61af66fc99e Initial load
duke
parents:
diff changeset
3382 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3383
a61af66fc99e Initial load
duke
parents:
diff changeset
3384 // Creation failed. We must reset vm_created
a61af66fc99e Initial load
duke
parents:
diff changeset
3385 *vm = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
3386 *(JNIEnv**)penv = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
3387 // reset vm_created last to avoid race condition. Use OrderAccess to
a61af66fc99e Initial load
duke
parents:
diff changeset
3388 // control both compiler and architectural-based reordering.
a61af66fc99e Initial load
duke
parents:
diff changeset
3389 OrderAccess::release_store(&vm_created, 0);
a61af66fc99e Initial load
duke
parents:
diff changeset
3390 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3391
1490
f03d0a26bf83 6888954: argument formatting for assert() and friends
jcoomes
parents: 1290
diff changeset
3392 NOT_PRODUCT(test_error_handler(ErrorHandlerTest));
3779
04760e41b01e 7016112: CMS: crash during promotion testing
brutisso
parents: 3249
diff changeset
3393 NOT_PRODUCT(execute_internal_vm_tests());
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3394 return result;
a61af66fc99e Initial load
duke
parents:
diff changeset
3395 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3396
a61af66fc99e Initial load
duke
parents:
diff changeset
3397 HS_DTRACE_PROBE_DECL3(hotspot_jni, GetCreatedJavaVMs__entry, \
a61af66fc99e Initial load
duke
parents:
diff changeset
3398 JavaVM**, jsize, jsize*);
a61af66fc99e Initial load
duke
parents:
diff changeset
3399 HS_DTRACE_PROBE_DECL1(hotspot_jni, GetCreatedJavaVMs__return, jint);
a61af66fc99e Initial load
duke
parents:
diff changeset
3400
a61af66fc99e Initial load
duke
parents:
diff changeset
3401 _JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_GetCreatedJavaVMs(JavaVM **vm_buf, jsize bufLen, jsize *numVMs) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3402 // See bug 4367188, the wrapper can sometimes cause VM crashes
a61af66fc99e Initial load
duke
parents:
diff changeset
3403 // JNIWrapper("GetCreatedJavaVMs");
a61af66fc99e Initial load
duke
parents:
diff changeset
3404 HS_DTRACE_PROBE3(hotspot_jni, GetCreatedJavaVMs__entry, \
a61af66fc99e Initial load
duke
parents:
diff changeset
3405 vm_buf, bufLen, numVMs);
a61af66fc99e Initial load
duke
parents:
diff changeset
3406 if (vm_created) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3407 if (numVMs != NULL) *numVMs = 1;
a61af66fc99e Initial load
duke
parents:
diff changeset
3408 if (bufLen > 0) *vm_buf = (JavaVM *)(&main_vm);
a61af66fc99e Initial load
duke
parents:
diff changeset
3409 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
3410 if (numVMs != NULL) *numVMs = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
3411 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3412 HS_DTRACE_PROBE1(hotspot_jni, GetCreatedJavaVMs__return, JNI_OK);
a61af66fc99e Initial load
duke
parents:
diff changeset
3413 return JNI_OK;
a61af66fc99e Initial load
duke
parents:
diff changeset
3414 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3415
a61af66fc99e Initial load
duke
parents:
diff changeset
3416 extern "C" {
a61af66fc99e Initial load
duke
parents:
diff changeset
3417
a61af66fc99e Initial load
duke
parents:
diff changeset
3418 DT_RETURN_MARK_DECL(DestroyJavaVM, jint);
a61af66fc99e Initial load
duke
parents:
diff changeset
3419
a61af66fc99e Initial load
duke
parents:
diff changeset
3420 jint JNICALL jni_DestroyJavaVM(JavaVM *vm) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3421 DTRACE_PROBE1(hotspot_jni, DestroyJavaVM__entry, vm);
a61af66fc99e Initial load
duke
parents:
diff changeset
3422 jint res = JNI_ERR;
a61af66fc99e Initial load
duke
parents:
diff changeset
3423 DT_RETURN_MARK(DestroyJavaVM, jint, (const jint&)res);
a61af66fc99e Initial load
duke
parents:
diff changeset
3424
a61af66fc99e Initial load
duke
parents:
diff changeset
3425 if (!vm_created) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3426 res = JNI_ERR;
a61af66fc99e Initial load
duke
parents:
diff changeset
3427 return res;
a61af66fc99e Initial load
duke
parents:
diff changeset
3428 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3429
a61af66fc99e Initial load
duke
parents:
diff changeset
3430 JNIWrapper("DestroyJavaVM");
a61af66fc99e Initial load
duke
parents:
diff changeset
3431 JNIEnv *env;
a61af66fc99e Initial load
duke
parents:
diff changeset
3432 JavaVMAttachArgs destroyargs;
a61af66fc99e Initial load
duke
parents:
diff changeset
3433 destroyargs.version = CurrentVersion;
a61af66fc99e Initial load
duke
parents:
diff changeset
3434 destroyargs.name = (char *)"DestroyJavaVM";
a61af66fc99e Initial load
duke
parents:
diff changeset
3435 destroyargs.group = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
3436 res = vm->AttachCurrentThread((void **)&env, (void *)&destroyargs);
a61af66fc99e Initial load
duke
parents:
diff changeset
3437 if (res != JNI_OK) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3438 return res;
a61af66fc99e Initial load
duke
parents:
diff changeset
3439 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3440
a61af66fc99e Initial load
duke
parents:
diff changeset
3441 // Since this is not a JVM_ENTRY we have to set the thread state manually before entering.
a61af66fc99e Initial load
duke
parents:
diff changeset
3442 JavaThread* thread = JavaThread::current();
a61af66fc99e Initial load
duke
parents:
diff changeset
3443 ThreadStateTransition::transition_from_native(thread, _thread_in_vm);
a61af66fc99e Initial load
duke
parents:
diff changeset
3444 if (Threads::destroy_vm()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3445 // Should not change thread state, VM is gone
a61af66fc99e Initial load
duke
parents:
diff changeset
3446 vm_created = false;
a61af66fc99e Initial load
duke
parents:
diff changeset
3447 res = JNI_OK;
a61af66fc99e Initial load
duke
parents:
diff changeset
3448 return res;
a61af66fc99e Initial load
duke
parents:
diff changeset
3449 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
3450 ThreadStateTransition::transition_and_fence(thread, _thread_in_vm, _thread_in_native);
a61af66fc99e Initial load
duke
parents:
diff changeset
3451 res = JNI_ERR;
a61af66fc99e Initial load
duke
parents:
diff changeset
3452 return res;
a61af66fc99e Initial load
duke
parents:
diff changeset
3453 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3454 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3455
a61af66fc99e Initial load
duke
parents:
diff changeset
3456
a61af66fc99e Initial load
duke
parents:
diff changeset
3457 static jint attach_current_thread(JavaVM *vm, void **penv, void *_args, bool daemon) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3458 JavaVMAttachArgs *args = (JavaVMAttachArgs *) _args;
a61af66fc99e Initial load
duke
parents:
diff changeset
3459
a61af66fc99e Initial load
duke
parents:
diff changeset
3460 // Check below commented out from JDK1.2fcs as well
a61af66fc99e Initial load
duke
parents:
diff changeset
3461 /*
a61af66fc99e Initial load
duke
parents:
diff changeset
3462 if (args && (args->version != JNI_VERSION_1_1 || args->version != JNI_VERSION_1_2)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3463 return JNI_EVERSION;
a61af66fc99e Initial load
duke
parents:
diff changeset
3464 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3465 */
a61af66fc99e Initial load
duke
parents:
diff changeset
3466
a61af66fc99e Initial load
duke
parents:
diff changeset
3467 Thread* t = ThreadLocalStorage::get_thread_slow();
a61af66fc99e Initial load
duke
parents:
diff changeset
3468 if (t != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3469 // If the thread has been attached this operation is a no-op
a61af66fc99e Initial load
duke
parents:
diff changeset
3470 *(JNIEnv**)penv = ((JavaThread*) t)->jni_environment();
a61af66fc99e Initial load
duke
parents:
diff changeset
3471 return JNI_OK;
a61af66fc99e Initial load
duke
parents:
diff changeset
3472 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3473
a61af66fc99e Initial load
duke
parents:
diff changeset
3474 // Create a thread and mark it as attaching so it will be skipped by the
a61af66fc99e Initial load
duke
parents:
diff changeset
3475 // ThreadsListEnumerator - see CR 6404306
a61af66fc99e Initial load
duke
parents:
diff changeset
3476 JavaThread* thread = new JavaThread(true);
a61af66fc99e Initial load
duke
parents:
diff changeset
3477
a61af66fc99e Initial load
duke
parents:
diff changeset
3478 // Set correct safepoint info. The thread is going to call into Java when
a61af66fc99e Initial load
duke
parents:
diff changeset
3479 // initializing the Java level thread object. Hence, the correct state must
a61af66fc99e Initial load
duke
parents:
diff changeset
3480 // be set in order for the Safepoint code to deal with it correctly.
a61af66fc99e Initial load
duke
parents:
diff changeset
3481 thread->set_thread_state(_thread_in_vm);
a61af66fc99e Initial load
duke
parents:
diff changeset
3482 // Must do this before initialize_thread_local_storage
a61af66fc99e Initial load
duke
parents:
diff changeset
3483 thread->record_stack_base_and_size();
1290
c8a467bf56ad 6914050: jvm assertion "guard pages must be in use" in -Xcomp mode
coleenp
parents: 1142
diff changeset
3484
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3485 thread->initialize_thread_local_storage();
a61af66fc99e Initial load
duke
parents:
diff changeset
3486
a61af66fc99e Initial load
duke
parents:
diff changeset
3487 if (!os::create_attached_thread(thread)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3488 delete thread;
a61af66fc99e Initial load
duke
parents:
diff changeset
3489 return JNI_ERR;
a61af66fc99e Initial load
duke
parents:
diff changeset
3490 }
1290
c8a467bf56ad 6914050: jvm assertion "guard pages must be in use" in -Xcomp mode
coleenp
parents: 1142
diff changeset
3491 // Enable stack overflow checks
c8a467bf56ad 6914050: jvm assertion "guard pages must be in use" in -Xcomp mode
coleenp
parents: 1142
diff changeset
3492 thread->create_stack_guard_pages();
c8a467bf56ad 6914050: jvm assertion "guard pages must be in use" in -Xcomp mode
coleenp
parents: 1142
diff changeset
3493
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3494 thread->initialize_tlab();
a61af66fc99e Initial load
duke
parents:
diff changeset
3495
1681
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1552
diff changeset
3496 thread->cache_global_variables();
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1552
diff changeset
3497
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3498 // Crucial that we do not have a safepoint check for this thread, since it has
a61af66fc99e Initial load
duke
parents:
diff changeset
3499 // not been added to the Thread list yet.
a61af66fc99e Initial load
duke
parents:
diff changeset
3500 { Threads_lock->lock_without_safepoint_check();
a61af66fc99e Initial load
duke
parents:
diff changeset
3501 // This must be inside this lock in order to get FullGCALot to work properly, i.e., to
a61af66fc99e Initial load
duke
parents:
diff changeset
3502 // avoid this thread trying to do a GC before it is added to the thread-list
a61af66fc99e Initial load
duke
parents:
diff changeset
3503 thread->set_active_handles(JNIHandleBlock::allocate_block());
a61af66fc99e Initial load
duke
parents:
diff changeset
3504 Threads::add(thread, daemon);
a61af66fc99e Initial load
duke
parents:
diff changeset
3505 Threads_lock->unlock();
a61af66fc99e Initial load
duke
parents:
diff changeset
3506 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3507 // Create thread group and name info from attach arguments
a61af66fc99e Initial load
duke
parents:
diff changeset
3508 oop group = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
3509 char* thread_name = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
3510 if (args != NULL && Threads::is_supported_jni_version(args->version)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3511 group = JNIHandles::resolve(args->group);
a61af66fc99e Initial load
duke
parents:
diff changeset
3512 thread_name = args->name; // may be NULL
a61af66fc99e Initial load
duke
parents:
diff changeset
3513 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3514 if (group == NULL) group = Universe::main_thread_group();
a61af66fc99e Initial load
duke
parents:
diff changeset
3515
a61af66fc99e Initial load
duke
parents:
diff changeset
3516 // Create Java level thread object and attach it to this thread
a61af66fc99e Initial load
duke
parents:
diff changeset
3517 bool attach_failed = false;
a61af66fc99e Initial load
duke
parents:
diff changeset
3518 {
a61af66fc99e Initial load
duke
parents:
diff changeset
3519 EXCEPTION_MARK;
a61af66fc99e Initial load
duke
parents:
diff changeset
3520 HandleMark hm(THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
3521 Handle thread_group(THREAD, group);
a61af66fc99e Initial load
duke
parents:
diff changeset
3522 thread->allocate_threadObj(thread_group, thread_name, daemon, THREAD);
a61af66fc99e Initial load
duke
parents:
diff changeset
3523 if (HAS_PENDING_EXCEPTION) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3524 CLEAR_PENDING_EXCEPTION;
a61af66fc99e Initial load
duke
parents:
diff changeset
3525 // cleanup outside the handle mark.
a61af66fc99e Initial load
duke
parents:
diff changeset
3526 attach_failed = true;
a61af66fc99e Initial load
duke
parents:
diff changeset
3527 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3528 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3529
a61af66fc99e Initial load
duke
parents:
diff changeset
3530 if (attach_failed) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3531 // Added missing cleanup
a61af66fc99e Initial load
duke
parents:
diff changeset
3532 thread->cleanup_failed_attach_current_thread();
a61af66fc99e Initial load
duke
parents:
diff changeset
3533 return JNI_ERR;
a61af66fc99e Initial load
duke
parents:
diff changeset
3534 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3535
a61af66fc99e Initial load
duke
parents:
diff changeset
3536 // mark the thread as no longer attaching
a61af66fc99e Initial load
duke
parents:
diff changeset
3537 // this uses a fence to push the change through so we don't have
a61af66fc99e Initial load
duke
parents:
diff changeset
3538 // to regrab the threads_lock
a61af66fc99e Initial load
duke
parents:
diff changeset
3539 thread->set_attached();
a61af66fc99e Initial load
duke
parents:
diff changeset
3540
a61af66fc99e Initial load
duke
parents:
diff changeset
3541 // Set java thread status.
a61af66fc99e Initial load
duke
parents:
diff changeset
3542 java_lang_Thread::set_thread_status(thread->threadObj(),
a61af66fc99e Initial load
duke
parents:
diff changeset
3543 java_lang_Thread::RUNNABLE);
a61af66fc99e Initial load
duke
parents:
diff changeset
3544
a61af66fc99e Initial load
duke
parents:
diff changeset
3545 // Notify the debugger
a61af66fc99e Initial load
duke
parents:
diff changeset
3546 if (JvmtiExport::should_post_thread_life()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3547 JvmtiExport::post_thread_start(thread);
a61af66fc99e Initial load
duke
parents:
diff changeset
3548 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3549
a61af66fc99e Initial load
duke
parents:
diff changeset
3550 *(JNIEnv**)penv = thread->jni_environment();
a61af66fc99e Initial load
duke
parents:
diff changeset
3551
a61af66fc99e Initial load
duke
parents:
diff changeset
3552 // Now leaving the VM, so change thread_state. This is normally automatically taken care
a61af66fc99e Initial load
duke
parents:
diff changeset
3553 // of in the JVM_ENTRY. But in this situation we have to do it manually. Notice, that by
a61af66fc99e Initial load
duke
parents:
diff changeset
3554 // using ThreadStateTransition::transition, we do a callback to the safepoint code if
a61af66fc99e Initial load
duke
parents:
diff changeset
3555 // needed.
a61af66fc99e Initial load
duke
parents:
diff changeset
3556
a61af66fc99e Initial load
duke
parents:
diff changeset
3557 ThreadStateTransition::transition_and_fence(thread, _thread_in_vm, _thread_in_native);
a61af66fc99e Initial load
duke
parents:
diff changeset
3558
a61af66fc99e Initial load
duke
parents:
diff changeset
3559 // Perform any platform dependent FPU setup
a61af66fc99e Initial load
duke
parents:
diff changeset
3560 os::setup_fpu();
a61af66fc99e Initial load
duke
parents:
diff changeset
3561
a61af66fc99e Initial load
duke
parents:
diff changeset
3562 return JNI_OK;
a61af66fc99e Initial load
duke
parents:
diff changeset
3563 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3564
a61af66fc99e Initial load
duke
parents:
diff changeset
3565
a61af66fc99e Initial load
duke
parents:
diff changeset
3566 jint JNICALL jni_AttachCurrentThread(JavaVM *vm, void **penv, void *_args) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3567 DTRACE_PROBE3(hotspot_jni, AttachCurrentThread__entry, vm, penv, _args);
a61af66fc99e Initial load
duke
parents:
diff changeset
3568 if (!vm_created) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3569 DTRACE_PROBE1(hotspot_jni, AttachCurrentThread__return, JNI_ERR);
a61af66fc99e Initial load
duke
parents:
diff changeset
3570 return JNI_ERR;
a61af66fc99e Initial load
duke
parents:
diff changeset
3571 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3572
a61af66fc99e Initial load
duke
parents:
diff changeset
3573 JNIWrapper("AttachCurrentThread");
a61af66fc99e Initial load
duke
parents:
diff changeset
3574 jint ret = attach_current_thread(vm, penv, _args, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
3575 DTRACE_PROBE1(hotspot_jni, AttachCurrentThread__return, ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
3576 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
3577 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3578
a61af66fc99e Initial load
duke
parents:
diff changeset
3579
a61af66fc99e Initial load
duke
parents:
diff changeset
3580 jint JNICALL jni_DetachCurrentThread(JavaVM *vm) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3581 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__entry, vm);
a61af66fc99e Initial load
duke
parents:
diff changeset
3582 VM_Exit::block_if_vm_exited();
a61af66fc99e Initial load
duke
parents:
diff changeset
3583
a61af66fc99e Initial load
duke
parents:
diff changeset
3584 JNIWrapper("DetachCurrentThread");
a61af66fc99e Initial load
duke
parents:
diff changeset
3585
a61af66fc99e Initial load
duke
parents:
diff changeset
3586 // If the thread has been deattacted the operations is a no-op
a61af66fc99e Initial load
duke
parents:
diff changeset
3587 if (ThreadLocalStorage::thread() == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3588 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__return, JNI_OK);
a61af66fc99e Initial load
duke
parents:
diff changeset
3589 return JNI_OK;
a61af66fc99e Initial load
duke
parents:
diff changeset
3590 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3591
a61af66fc99e Initial load
duke
parents:
diff changeset
3592 JavaThread* thread = JavaThread::current();
a61af66fc99e Initial load
duke
parents:
diff changeset
3593 if (thread->has_last_Java_frame()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3594 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__return, JNI_ERR);
a61af66fc99e Initial load
duke
parents:
diff changeset
3595 // Can't detach a thread that's running java, that can't work.
a61af66fc99e Initial load
duke
parents:
diff changeset
3596 return JNI_ERR;
a61af66fc99e Initial load
duke
parents:
diff changeset
3597 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3598
a61af66fc99e Initial load
duke
parents:
diff changeset
3599 // Safepoint support. Have to do call-back to safepoint code, if in the
a61af66fc99e Initial load
duke
parents:
diff changeset
3600 // middel of a safepoint operation
a61af66fc99e Initial load
duke
parents:
diff changeset
3601 ThreadStateTransition::transition_from_native(thread, _thread_in_vm);
a61af66fc99e Initial load
duke
parents:
diff changeset
3602
a61af66fc99e Initial load
duke
parents:
diff changeset
3603 // XXX: Note that JavaThread::exit() call below removes the guards on the
a61af66fc99e Initial load
duke
parents:
diff changeset
3604 // stack pages set up via enable_stack_{red,yellow}_zone() calls
a61af66fc99e Initial load
duke
parents:
diff changeset
3605 // above in jni_AttachCurrentThread. Unfortunately, while the setting
a61af66fc99e Initial load
duke
parents:
diff changeset
3606 // of the guards is visible in jni_AttachCurrentThread above,
a61af66fc99e Initial load
duke
parents:
diff changeset
3607 // the removal of the guards is buried below in JavaThread::exit()
a61af66fc99e Initial load
duke
parents:
diff changeset
3608 // here. The abstraction should be more symmetrically either exposed
a61af66fc99e Initial load
duke
parents:
diff changeset
3609 // or hidden (e.g. it could probably be hidden in the same
a61af66fc99e Initial load
duke
parents:
diff changeset
3610 // (platform-dependent) methods where we do alternate stack
a61af66fc99e Initial load
duke
parents:
diff changeset
3611 // maintenance work?)
a61af66fc99e Initial load
duke
parents:
diff changeset
3612 thread->exit(false, JavaThread::jni_detach);
a61af66fc99e Initial load
duke
parents:
diff changeset
3613 delete thread;
a61af66fc99e Initial load
duke
parents:
diff changeset
3614
a61af66fc99e Initial load
duke
parents:
diff changeset
3615 DTRACE_PROBE1(hotspot_jni, DetachCurrentThread__return, JNI_OK);
a61af66fc99e Initial load
duke
parents:
diff changeset
3616 return JNI_OK;
a61af66fc99e Initial load
duke
parents:
diff changeset
3617 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3618
a61af66fc99e Initial load
duke
parents:
diff changeset
3619 DT_RETURN_MARK_DECL(GetEnv, jint);
a61af66fc99e Initial load
duke
parents:
diff changeset
3620
a61af66fc99e Initial load
duke
parents:
diff changeset
3621 jint JNICALL jni_GetEnv(JavaVM *vm, void **penv, jint version) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3622 DTRACE_PROBE3(hotspot_jni, GetEnv__entry, vm, penv, version);
a61af66fc99e Initial load
duke
parents:
diff changeset
3623 jint ret = JNI_ERR;
a61af66fc99e Initial load
duke
parents:
diff changeset
3624 DT_RETURN_MARK(GetEnv, jint, (const jint&)ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
3625
a61af66fc99e Initial load
duke
parents:
diff changeset
3626 if (!vm_created) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3627 *penv = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
3628 ret = JNI_EDETACHED;
a61af66fc99e Initial load
duke
parents:
diff changeset
3629 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
3630 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3631
a61af66fc99e Initial load
duke
parents:
diff changeset
3632 if (JvmtiExport::is_jvmti_version(version)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3633 ret = JvmtiExport::get_jvmti_interface(vm, penv, version);
a61af66fc99e Initial load
duke
parents:
diff changeset
3634 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
3635 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3636
a61af66fc99e Initial load
duke
parents:
diff changeset
3637 #ifndef JVMPI_VERSION_1
a61af66fc99e Initial load
duke
parents:
diff changeset
3638 // need these in order to be polite about older agents
a61af66fc99e Initial load
duke
parents:
diff changeset
3639 #define JVMPI_VERSION_1 ((jint)0x10000001)
a61af66fc99e Initial load
duke
parents:
diff changeset
3640 #define JVMPI_VERSION_1_1 ((jint)0x10000002)
a61af66fc99e Initial load
duke
parents:
diff changeset
3641 #define JVMPI_VERSION_1_2 ((jint)0x10000003)
a61af66fc99e Initial load
duke
parents:
diff changeset
3642 #endif // !JVMPI_VERSION_1
a61af66fc99e Initial load
duke
parents:
diff changeset
3643
a61af66fc99e Initial load
duke
parents:
diff changeset
3644 Thread* thread = ThreadLocalStorage::thread();
a61af66fc99e Initial load
duke
parents:
diff changeset
3645 if (thread != NULL && thread->is_Java_thread()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3646 if (Threads::is_supported_jni_version_including_1_1(version)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3647 *(JNIEnv**)penv = ((JavaThread*) thread)->jni_environment();
a61af66fc99e Initial load
duke
parents:
diff changeset
3648 ret = JNI_OK;
a61af66fc99e Initial load
duke
parents:
diff changeset
3649 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
3650
a61af66fc99e Initial load
duke
parents:
diff changeset
3651 } else if (version == JVMPI_VERSION_1 ||
a61af66fc99e Initial load
duke
parents:
diff changeset
3652 version == JVMPI_VERSION_1_1 ||
a61af66fc99e Initial load
duke
parents:
diff changeset
3653 version == JVMPI_VERSION_1_2) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3654 tty->print_cr("ERROR: JVMPI, an experimental interface, is no longer supported.");
a61af66fc99e Initial load
duke
parents:
diff changeset
3655 tty->print_cr("Please use the supported interface: the JVM Tool Interface (JVM TI).");
a61af66fc99e Initial load
duke
parents:
diff changeset
3656 ret = JNI_EVERSION;
a61af66fc99e Initial load
duke
parents:
diff changeset
3657 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
3658 } else if (JvmtiExport::is_jvmdi_version(version)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3659 tty->print_cr("FATAL ERROR: JVMDI is no longer supported.");
a61af66fc99e Initial load
duke
parents:
diff changeset
3660 tty->print_cr("Please use the supported interface: the JVM Tool Interface (JVM TI).");
a61af66fc99e Initial load
duke
parents:
diff changeset
3661 ret = JNI_EVERSION;
a61af66fc99e Initial load
duke
parents:
diff changeset
3662 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
3663 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
3664 *penv = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
3665 ret = JNI_EVERSION;
a61af66fc99e Initial load
duke
parents:
diff changeset
3666 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
3667 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3668 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
3669 *penv = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
3670 ret = JNI_EDETACHED;
a61af66fc99e Initial load
duke
parents:
diff changeset
3671 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
3672 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3673 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3674
a61af66fc99e Initial load
duke
parents:
diff changeset
3675
a61af66fc99e Initial load
duke
parents:
diff changeset
3676 jint JNICALL jni_AttachCurrentThreadAsDaemon(JavaVM *vm, void **penv, void *_args) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3677 DTRACE_PROBE3(hotspot_jni, AttachCurrentThreadAsDaemon__entry, vm, penv, _args);
a61af66fc99e Initial load
duke
parents:
diff changeset
3678 if (!vm_created) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3679 DTRACE_PROBE1(hotspot_jni, AttachCurrentThreadAsDaemon__return, JNI_ERR);
a61af66fc99e Initial load
duke
parents:
diff changeset
3680 return JNI_ERR;
a61af66fc99e Initial load
duke
parents:
diff changeset
3681 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3682
a61af66fc99e Initial load
duke
parents:
diff changeset
3683 JNIWrapper("AttachCurrentThreadAsDaemon");
a61af66fc99e Initial load
duke
parents:
diff changeset
3684 jint ret = attach_current_thread(vm, penv, _args, true);
a61af66fc99e Initial load
duke
parents:
diff changeset
3685 DTRACE_PROBE1(hotspot_jni, AttachCurrentThreadAsDaemon__return, ret);
a61af66fc99e Initial load
duke
parents:
diff changeset
3686 return ret;
a61af66fc99e Initial load
duke
parents:
diff changeset
3687 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3688
a61af66fc99e Initial load
duke
parents:
diff changeset
3689
a61af66fc99e Initial load
duke
parents:
diff changeset
3690 } // End extern "C"
a61af66fc99e Initial load
duke
parents:
diff changeset
3691
a61af66fc99e Initial load
duke
parents:
diff changeset
3692 const struct JNIInvokeInterface_ jni_InvokeInterface = {
a61af66fc99e Initial load
duke
parents:
diff changeset
3693 NULL,
a61af66fc99e Initial load
duke
parents:
diff changeset
3694 NULL,
a61af66fc99e Initial load
duke
parents:
diff changeset
3695 NULL,
a61af66fc99e Initial load
duke
parents:
diff changeset
3696
a61af66fc99e Initial load
duke
parents:
diff changeset
3697 jni_DestroyJavaVM,
a61af66fc99e Initial load
duke
parents:
diff changeset
3698 jni_AttachCurrentThread,
a61af66fc99e Initial load
duke
parents:
diff changeset
3699 jni_DetachCurrentThread,
a61af66fc99e Initial load
duke
parents:
diff changeset
3700 jni_GetEnv,
a61af66fc99e Initial load
duke
parents:
diff changeset
3701 jni_AttachCurrentThreadAsDaemon
a61af66fc99e Initial load
duke
parents:
diff changeset
3702 };