author | sangheki |
Tue, 05 Apr 2016 16:15:53 -0700 | |
changeset 37264 | d9b0f2b53b73 |
parent 35479 | 62c12ca7a45e |
child 38139 | cf6f5c1b7205 |
permissions | -rw-r--r-- |
1 | 1 |
/* |
35479
62c12ca7a45e
8146410: Interpreter functions are declared and defined in the wrong files
coleenp
parents:
35071
diff
changeset
|
2 |
* Copyright (c) 1997, 2016, Oracle and/or its affiliates. All rights reserved. |
1 | 3 |
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 |
* |
|
5 |
* This code is free software; you can redistribute it and/or modify it |
|
6 |
* under the terms of the GNU General Public License version 2 only, as |
|
7 |
* published by the Free Software Foundation. |
|
8 |
* |
|
9 |
* This code is distributed in the hope that it will be useful, but WITHOUT |
|
10 |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
11 |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
12 |
* version 2 for more details (a copy is included in the LICENSE file that |
|
13 |
* accompanied this code). |
|
14 |
* |
|
15 |
* You should have received a copy of the GNU General Public License version |
|
16 |
* 2 along with this work; if not, write to the Free Software Foundation, |
|
17 |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
18 |
* |
|
5547
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5419
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5419
diff
changeset
|
20 |
* or visit www.oracle.com if you need additional information or have any |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5419
diff
changeset
|
21 |
* questions. |
1 | 22 |
* |
23 |
*/ |
|
24 |
||
7397 | 25 |
#include "precompiled.hpp" |
26 |
#include "classfile/systemDictionary.hpp" |
|
27 |
#include "classfile/vmSymbols.hpp" |
|
28 |
#include "code/nmethod.hpp" |
|
29 |
#include "compiler/compileBroker.hpp" |
|
30 |
#include "interpreter/interpreter.hpp" |
|
31 |
#include "interpreter/linkResolver.hpp" |
|
32 |
#include "memory/universe.inline.hpp" |
|
33 |
#include "oops/oop.inline.hpp" |
|
34 |
#include "prims/jniCheck.hpp" |
|
35 |
#include "runtime/compilationPolicy.hpp" |
|
36 |
#include "runtime/handles.inline.hpp" |
|
37 |
#include "runtime/interfaceSupport.hpp" |
|
38 |
#include "runtime/javaCalls.hpp" |
|
39 |
#include "runtime/mutexLocker.hpp" |
|
25468
5331df506290
8048241: Introduce umbrella header os.inline.hpp and clean up includes
goetz
parents:
22775
diff
changeset
|
40 |
#include "runtime/os.inline.hpp" |
7397 | 41 |
#include "runtime/signature.hpp" |
42 |
#include "runtime/stubRoutines.hpp" |
|
14583
d70ee55535f4
8003935: Simplify the needed includes for using Thread::current()
stefank
parents:
14391
diff
changeset
|
43 |
#include "runtime/thread.inline.hpp" |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
31019
diff
changeset
|
44 |
#if INCLUDE_JVMCI |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
31019
diff
changeset
|
45 |
#include "jvmci/jvmciJavaClasses.hpp" |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
31019
diff
changeset
|
46 |
#include "jvmci/jvmciRuntime.hpp" |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
31019
diff
changeset
|
47 |
#endif |
1 | 48 |
|
49 |
// ----------------------------------------------------- |
|
50 |
// Implementation of JavaCallWrapper |
|
51 |
||
52 |
JavaCallWrapper::JavaCallWrapper(methodHandle callee_method, Handle receiver, JavaValue* result, TRAPS) { |
|
53 |
JavaThread* thread = (JavaThread *)THREAD; |
|
54 |
bool clear_pending_exception = true; |
|
55 |
||
56 |
guarantee(thread->is_Java_thread(), "crucial check - the VM thread cannot and must not escape to Java code"); |
|
57 |
assert(!thread->owns_locks(), "must release all locks when leaving VM"); |
|
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
31019
diff
changeset
|
58 |
guarantee(thread->can_call_java(), "cannot make java calls from the native compiler"); |
1 | 59 |
_result = result; |
60 |
||
61 |
// Allocate handle block for Java code. This must be done before we change thread_state to _thread_in_Java_or_stub, |
|
62 |
// since it can potentially block. |
|
63 |
JNIHandleBlock* new_handles = JNIHandleBlock::allocate_block(thread); |
|
64 |
||
65 |
// After this, we are official in JavaCode. This needs to be done before we change any of the thread local |
|
66 |
// info, since we cannot find oops before the new information is set up completely. |
|
67 |
ThreadStateTransition::transition(thread, _thread_in_vm, _thread_in_Java); |
|
68 |
||
69 |
// Make sure that we handle asynchronous stops and suspends _before_ we clear all thread state |
|
70 |
// in JavaCallWrapper::JavaCallWrapper(). This way, we can decide if we need to do any pd actions |
|
71 |
// to prepare for stop/suspend (flush register windows on sparcs, cache sp, or other state). |
|
72 |
if (thread->has_special_runtime_exit_condition()) { |
|
73 |
thread->handle_special_runtime_exit_condition(); |
|
74 |
if (HAS_PENDING_EXCEPTION) { |
|
75 |
clear_pending_exception = false; |
|
76 |
} |
|
77 |
} |
|
78 |
||
79 |
||
80 |
// Make sure to set the oop's after the thread transition - since we can block there. No one is GC'ing |
|
81 |
// the JavaCallWrapper before the entry frame is on the stack. |
|
82 |
_callee_method = callee_method(); |
|
83 |
_receiver = receiver(); |
|
84 |
||
85 |
#ifdef CHECK_UNHANDLED_OOPS |
|
86 |
THREAD->allow_unhandled_oop(&_receiver); |
|
87 |
#endif // CHECK_UNHANDLED_OOPS |
|
88 |
||
89 |
_thread = (JavaThread *)thread; |
|
90 |
_handles = _thread->active_handles(); // save previous handle block & Java frame linkage |
|
91 |
||
92 |
// For the profiler, the last_Java_frame information in thread must always be in |
|
93 |
// legal state. We have no last Java frame if last_Java_sp == NULL so |
|
94 |
// the valid transition is to clear _last_Java_sp and then reset the rest of |
|
95 |
// the (platform specific) state. |
|
96 |
||
97 |
_anchor.copy(_thread->frame_anchor()); |
|
98 |
_thread->frame_anchor()->clear(); |
|
99 |
||
100 |
debug_only(_thread->inc_java_call_counter()); |
|
101 |
_thread->set_active_handles(new_handles); // install new handle block and reset Java frame linkage |
|
102 |
||
103 |
assert (_thread->thread_state() != _thread_in_native, "cannot set native pc to NULL"); |
|
104 |
||
105 |
// clear any pending exception in thread (native calls start with no exception pending) |
|
106 |
if(clear_pending_exception) { |
|
107 |
_thread->clear_pending_exception(); |
|
108 |
} |
|
109 |
||
110 |
if (_anchor.last_Java_sp() == NULL) { |
|
111 |
_thread->record_base_of_stack_pointer(); |
|
112 |
} |
|
113 |
} |
|
114 |
||
115 |
||
116 |
JavaCallWrapper::~JavaCallWrapper() { |
|
117 |
assert(_thread == JavaThread::current(), "must still be the same thread"); |
|
118 |
||
119 |
// restore previous handle block & Java frame linkage |
|
120 |
JNIHandleBlock *_old_handles = _thread->active_handles(); |
|
121 |
_thread->set_active_handles(_handles); |
|
122 |
||
123 |
_thread->frame_anchor()->zap(); |
|
124 |
||
125 |
debug_only(_thread->dec_java_call_counter()); |
|
126 |
||
127 |
if (_anchor.last_Java_sp() == NULL) { |
|
128 |
_thread->set_base_of_stack_pointer(NULL); |
|
129 |
} |
|
130 |
||
131 |
||
132 |
// Old thread-local info. has been restored. We are not back in the VM. |
|
133 |
ThreadStateTransition::transition_from_java(_thread, _thread_in_vm); |
|
134 |
||
135 |
// State has been restored now make the anchor frame visible for the profiler. |
|
136 |
// Do this after the transition because this allows us to put an assert |
|
137 |
// the Java->vm transition which checks to see that stack is not walkable |
|
138 |
// on sparc/ia64 which will catch violations of the reseting of last_Java_frame |
|
139 |
// invariants (i.e. _flags always cleared on return to Java) |
|
140 |
||
141 |
_thread->frame_anchor()->copy(&_anchor); |
|
142 |
||
143 |
// Release handles after we are marked as being inside the VM again, since this |
|
144 |
// operation might block |
|
145 |
JNIHandleBlock::release_block(_old_handles, _thread); |
|
146 |
} |
|
147 |
||
148 |
||
149 |
void JavaCallWrapper::oops_do(OopClosure* f) { |
|
150 |
f->do_oop((oop*)&_receiver); |
|
151 |
handles()->oops_do(f); |
|
152 |
} |
|
153 |
||
154 |
||
155 |
// Helper methods |
|
156 |
static BasicType runtime_type_from(JavaValue* result) { |
|
157 |
switch (result->get_type()) { |
|
158 |
case T_BOOLEAN: // fall through |
|
159 |
case T_CHAR : // fall through |
|
160 |
case T_SHORT : // fall through |
|
161 |
case T_INT : // fall through |
|
162 |
#ifndef _LP64 |
|
163 |
case T_OBJECT : // fall through |
|
164 |
case T_ARRAY : // fall through |
|
165 |
#endif |
|
166 |
case T_BYTE : // fall through |
|
167 |
case T_VOID : return T_INT; |
|
168 |
case T_LONG : return T_LONG; |
|
169 |
case T_FLOAT : return T_FLOAT; |
|
170 |
case T_DOUBLE : return T_DOUBLE; |
|
171 |
#ifdef _LP64 |
|
172 |
case T_ARRAY : // fall through |
|
173 |
case T_OBJECT: return T_OBJECT; |
|
174 |
#endif |
|
175 |
} |
|
176 |
ShouldNotReachHere(); |
|
177 |
return T_ILLEGAL; |
|
178 |
} |
|
179 |
||
180 |
// ============ Virtual calls ============ |
|
181 |
||
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
182 |
void JavaCalls::call_virtual(JavaValue* result, KlassHandle spec_klass, Symbol* name, Symbol* signature, JavaCallArguments* args, TRAPS) { |
1 | 183 |
CallInfo callinfo; |
184 |
Handle receiver = args->receiver(); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
10565
diff
changeset
|
185 |
KlassHandle recvrKlass(THREAD, receiver.is_null() ? (Klass*)NULL : receiver->klass()); |
34238 | 186 |
LinkInfo link_info(spec_klass, name, signature, KlassHandle(), /*check_access*/false); |
1 | 187 |
LinkResolver::resolve_virtual_call( |
31019 | 188 |
callinfo, receiver, recvrKlass, link_info, true, CHECK); |
1 | 189 |
methodHandle method = callinfo.selected_method(); |
190 |
assert(method.not_null(), "should have thrown exception"); |
|
191 |
||
192 |
// Invoke the method |
|
193 |
JavaCalls::call(result, method, args, CHECK); |
|
194 |
} |
|
195 |
||
196 |
||
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
197 |
void JavaCalls::call_virtual(JavaValue* result, Handle receiver, KlassHandle spec_klass, Symbol* name, Symbol* signature, TRAPS) { |
1 | 198 |
JavaCallArguments args(receiver); // One oop argument |
199 |
call_virtual(result, spec_klass, name, signature, &args, CHECK); |
|
200 |
} |
|
201 |
||
202 |
||
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
203 |
void JavaCalls::call_virtual(JavaValue* result, Handle receiver, KlassHandle spec_klass, Symbol* name, Symbol* signature, Handle arg1, TRAPS) { |
1 | 204 |
JavaCallArguments args(receiver); // One oop argument |
205 |
args.push_oop(arg1); |
|
206 |
call_virtual(result, spec_klass, name, signature, &args, CHECK); |
|
207 |
} |
|
208 |
||
209 |
||
210 |
||
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
211 |
void JavaCalls::call_virtual(JavaValue* result, Handle receiver, KlassHandle spec_klass, Symbol* name, Symbol* signature, Handle arg1, Handle arg2, TRAPS) { |
1 | 212 |
JavaCallArguments args(receiver); // One oop argument |
213 |
args.push_oop(arg1); |
|
214 |
args.push_oop(arg2); |
|
215 |
call_virtual(result, spec_klass, name, signature, &args, CHECK); |
|
216 |
} |
|
217 |
||
218 |
||
219 |
// ============ Special calls ============ |
|
220 |
||
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
221 |
void JavaCalls::call_special(JavaValue* result, KlassHandle klass, Symbol* name, Symbol* signature, JavaCallArguments* args, TRAPS) { |
1 | 222 |
CallInfo callinfo; |
34238 | 223 |
LinkInfo link_info(klass, name, signature, KlassHandle(), /*check_access*/false); |
31019 | 224 |
LinkResolver::resolve_special_call(callinfo, link_info, CHECK); |
1 | 225 |
methodHandle method = callinfo.selected_method(); |
226 |
assert(method.not_null(), "should have thrown exception"); |
|
227 |
||
228 |
// Invoke the method |
|
229 |
JavaCalls::call(result, method, args, CHECK); |
|
230 |
} |
|
231 |
||
232 |
||
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
233 |
void JavaCalls::call_special(JavaValue* result, Handle receiver, KlassHandle klass, Symbol* name, Symbol* signature, TRAPS) { |
1 | 234 |
JavaCallArguments args(receiver); // One oop argument |
235 |
call_special(result, klass, name, signature, &args, CHECK); |
|
236 |
} |
|
237 |
||
238 |
||
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
239 |
void JavaCalls::call_special(JavaValue* result, Handle receiver, KlassHandle klass, Symbol* name, Symbol* signature, Handle arg1, TRAPS) { |
1 | 240 |
JavaCallArguments args(receiver); // One oop argument |
241 |
args.push_oop(arg1); |
|
242 |
call_special(result, klass, name, signature, &args, CHECK); |
|
243 |
} |
|
244 |
||
245 |
||
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
246 |
void JavaCalls::call_special(JavaValue* result, Handle receiver, KlassHandle klass, Symbol* name, Symbol* signature, Handle arg1, Handle arg2, TRAPS) { |
1 | 247 |
JavaCallArguments args(receiver); // One oop argument |
248 |
args.push_oop(arg1); |
|
249 |
args.push_oop(arg2); |
|
250 |
call_special(result, klass, name, signature, &args, CHECK); |
|
251 |
} |
|
252 |
||
253 |
||
254 |
// ============ Static calls ============ |
|
255 |
||
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
256 |
void JavaCalls::call_static(JavaValue* result, KlassHandle klass, Symbol* name, Symbol* signature, JavaCallArguments* args, TRAPS) { |
1 | 257 |
CallInfo callinfo; |
34238 | 258 |
LinkInfo link_info(klass, name, signature, KlassHandle(), /*check_access*/false); |
31019 | 259 |
LinkResolver::resolve_static_call(callinfo, link_info, true, CHECK); |
1 | 260 |
methodHandle method = callinfo.selected_method(); |
261 |
assert(method.not_null(), "should have thrown exception"); |
|
262 |
||
263 |
// Invoke the method |
|
264 |
JavaCalls::call(result, method, args, CHECK); |
|
265 |
} |
|
266 |
||
267 |
||
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
268 |
void JavaCalls::call_static(JavaValue* result, KlassHandle klass, Symbol* name, Symbol* signature, TRAPS) { |
1 | 269 |
JavaCallArguments args; // No argument |
270 |
call_static(result, klass, name, signature, &args, CHECK); |
|
271 |
} |
|
272 |
||
273 |
||
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
274 |
void JavaCalls::call_static(JavaValue* result, KlassHandle klass, Symbol* name, Symbol* signature, Handle arg1, TRAPS) { |
1 | 275 |
JavaCallArguments args(arg1); // One oop argument |
276 |
call_static(result, klass, name, signature, &args, CHECK); |
|
277 |
} |
|
278 |
||
279 |
||
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
280 |
void JavaCalls::call_static(JavaValue* result, KlassHandle klass, Symbol* name, Symbol* signature, Handle arg1, Handle arg2, TRAPS) { |
1 | 281 |
JavaCallArguments args; // One oop argument |
282 |
args.push_oop(arg1); |
|
283 |
args.push_oop(arg2); |
|
284 |
call_static(result, klass, name, signature, &args, CHECK); |
|
285 |
} |
|
286 |
||
287 |
||
288 |
// ------------------------------------------------- |
|
289 |
// Implementation of JavaCalls (low level) |
|
290 |
||
291 |
||
33593
60764a78fa5c
8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents:
33160
diff
changeset
|
292 |
void JavaCalls::call(JavaValue* result, const methodHandle& method, JavaCallArguments* args, TRAPS) { |
1 | 293 |
// Check if we need to wrap a potential OS exception handler around thread |
294 |
// This is used for e.g. Win32 structured exception handlers |
|
295 |
assert(THREAD->is_Java_thread(), "only JavaThreads can make JavaCalls"); |
|
22551 | 296 |
// Need to wrap each and every time, since there might be native code down the |
1 | 297 |
// stack that has installed its own exception handlers |
33593
60764a78fa5c
8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents:
33160
diff
changeset
|
298 |
os::os_exception_wrapper(call_helper, result, method, args, THREAD); |
1 | 299 |
} |
300 |
||
33593
60764a78fa5c
8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents:
33160
diff
changeset
|
301 |
void JavaCalls::call_helper(JavaValue* result, const methodHandle& method, JavaCallArguments* args, TRAPS) { |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
302 |
// During dumping, Java execution environment is not fully initialized. Also, Java execution |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
303 |
// may cause undesirable side-effects in the class metadata. |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
304 |
assert(!DumpSharedSpaces, "must not execute Java bytecodes when dumping"); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25468
diff
changeset
|
305 |
|
1 | 306 |
JavaThread* thread = (JavaThread*)THREAD; |
307 |
assert(thread->is_Java_thread(), "must be called by a java thread"); |
|
308 |
assert(method.not_null(), "must have a method to call"); |
|
309 |
assert(!SafepointSynchronize::is_at_safepoint(), "call to Java code during VM operation"); |
|
310 |
assert(!thread->handle_area()->no_handle_mark_active(), "cannot call out to Java here"); |
|
311 |
||
312 |
||
313 |
CHECK_UNHANDLED_OOPS_ONLY(thread->clear_unhandled_oops();) |
|
314 |
||
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
31019
diff
changeset
|
315 |
#if INCLUDE_JVMCI |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
31019
diff
changeset
|
316 |
// Gets the nmethod (if any) that should be called instead of normal target |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
31019
diff
changeset
|
317 |
nmethod* alternative_target = args->alternative_target(); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
31019
diff
changeset
|
318 |
if (alternative_target == NULL) { |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
31019
diff
changeset
|
319 |
#endif |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
31019
diff
changeset
|
320 |
// Verify the arguments |
1618
2d86b9b84aa5
6739363: Xcheck jni doesn't check native function arguments
poonam
parents:
1
diff
changeset
|
321 |
|
2d86b9b84aa5
6739363: Xcheck jni doesn't check native function arguments
poonam
parents:
1
diff
changeset
|
322 |
if (CheckJNICalls) { |
2d86b9b84aa5
6739363: Xcheck jni doesn't check native function arguments
poonam
parents:
1
diff
changeset
|
323 |
args->verify(method, result->get_type(), thread); |
2d86b9b84aa5
6739363: Xcheck jni doesn't check native function arguments
poonam
parents:
1
diff
changeset
|
324 |
} |
2d86b9b84aa5
6739363: Xcheck jni doesn't check native function arguments
poonam
parents:
1
diff
changeset
|
325 |
else debug_only(args->verify(method, result->get_type(), thread)); |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
31019
diff
changeset
|
326 |
#if INCLUDE_JVMCI |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
31019
diff
changeset
|
327 |
} |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
31019
diff
changeset
|
328 |
#else |
1 | 329 |
|
330 |
// Ignore call if method is empty |
|
331 |
if (method->is_empty_method()) { |
|
332 |
assert(result->get_type() == T_VOID, "an empty method must return a void value"); |
|
333 |
return; |
|
334 |
} |
|
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
31019
diff
changeset
|
335 |
#endif |
1 | 336 |
|
337 |
#ifdef ASSERT |
|
14391
df0a1573d5bd
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
13728
diff
changeset
|
338 |
{ InstanceKlass* holder = method->method_holder(); |
1 | 339 |
// A klass might not be initialized since JavaCall's might be used during the executing of |
340 |
// the <clinit>. For example, a Thread.start might start executing on an object that is |
|
341 |
// not fully initialized! (bad Java programming style) |
|
22775 | 342 |
assert(holder->is_linked(), "rewriting must have taken place"); |
1 | 343 |
} |
344 |
#endif |
|
345 |
||
346 |
||
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
31019
diff
changeset
|
347 |
assert(thread->can_call_java(), "cannot compile from the native compiler"); |
6453 | 348 |
if (CompilationPolicy::must_be_compiled(method)) { |
1 | 349 |
CompileBroker::compile_method(method, InvocationEntryBci, |
10250
0794cd144834
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
9321
diff
changeset
|
350 |
CompilationPolicy::policy()->initial_compile_level(), |
6453 | 351 |
methodHandle(), 0, "must_be_compiled", CHECK); |
1 | 352 |
} |
353 |
||
354 |
// Since the call stub sets up like the interpreter we call the from_interpreted_entry |
|
355 |
// so we can go compiled via a i2c. Otherwise initial entry method will always |
|
356 |
// run interpreted. |
|
357 |
address entry_point = method->from_interpreted_entry(); |
|
358 |
if (JvmtiExport::can_post_interpreter_events() && thread->is_interp_only_mode()) { |
|
359 |
entry_point = method->interpreter_entry(); |
|
360 |
} |
|
361 |
||
362 |
// Figure out if the result value is an oop or not (Note: This is a different value |
|
363 |
// than result_type. result_type will be T_INT of oops. (it is about size) |
|
364 |
BasicType result_type = runtime_type_from(result); |
|
365 |
bool oop_result_flag = (result->get_type() == T_OBJECT || result->get_type() == T_ARRAY); |
|
366 |
||
367 |
// NOTE: if we move the computation of the result_val_address inside |
|
368 |
// the call to call_stub, the optimizer produces wrong code. |
|
369 |
intptr_t* result_val_address = (intptr_t*)(result->get_value_addr()); |
|
370 |
||
371 |
// Find receiver |
|
372 |
Handle receiver = (!method->is_static()) ? args->receiver() : Handle(); |
|
373 |
||
35071
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34238
diff
changeset
|
374 |
// When we reenter Java, we need to reenable the reserved/yellow zone which |
1 | 375 |
// might already be disabled when we are in VM. |
35071
a0910b1d3e0d
8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents:
34238
diff
changeset
|
376 |
if (!thread->stack_guards_enabled()) { |
1 | 377 |
thread->reguard_stack(); |
378 |
} |
|
379 |
||
380 |
// Check that there are shadow pages available before changing thread state |
|
381 |
// to Java |
|
382 |
if (!os::stack_shadow_pages_available(THREAD, method)) { |
|
383 |
// Throw stack overflow exception with preinitialized exception. |
|
9321
c29711c6ae35
7009923: JSR 292: VM crash in JavaThread::last_frame
coleenp
parents:
8921
diff
changeset
|
384 |
Exceptions::throw_stack_overflow_exception(THREAD, __FILE__, __LINE__, method); |
1 | 385 |
return; |
386 |
} else { |
|
387 |
// Touch pages checked if the OS needs them to be touched to be mapped. |
|
35479
62c12ca7a45e
8146410: Interpreter functions are declared and defined in the wrong files
coleenp
parents:
35071
diff
changeset
|
388 |
os::map_stack_shadow_pages(); |
1 | 389 |
} |
390 |
||
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
31019
diff
changeset
|
391 |
#if INCLUDE_JVMCI |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
31019
diff
changeset
|
392 |
if (alternative_target != NULL) { |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
31019
diff
changeset
|
393 |
if (alternative_target->is_alive()) { |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
31019
diff
changeset
|
394 |
thread->set_jvmci_alternate_call_target(alternative_target->verified_entry_point()); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
31019
diff
changeset
|
395 |
entry_point = method->adapter()->get_i2c_entry(); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
31019
diff
changeset
|
396 |
} else { |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
31019
diff
changeset
|
397 |
THROW(vmSymbols::jdk_vm_ci_code_InvalidInstalledCodeException()); |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
31019
diff
changeset
|
398 |
} |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
31019
diff
changeset
|
399 |
} |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
31019
diff
changeset
|
400 |
#endif |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
31019
diff
changeset
|
401 |
|
1 | 402 |
// do call |
403 |
{ JavaCallWrapper link(method, receiver, result, CHECK); |
|
404 |
{ HandleMark hm(thread); // HandleMark used by HandleMarkCleaner |
|
405 |
||
406 |
StubRoutines::call_stub()( |
|
407 |
(address)&link, |
|
408 |
// (intptr_t*)&(result->_value), // see NOTE above (compiler problem) |
|
409 |
result_val_address, // see NOTE above (compiler problem) |
|
410 |
result_type, |
|
411 |
method(), |
|
412 |
entry_point, |
|
413 |
args->parameters(), |
|
414 |
args->size_of_parameters(), |
|
415 |
CHECK |
|
416 |
); |
|
417 |
||
418 |
result = link.result(); // circumvent MS C++ 5.0 compiler bug (result is clobbered across call) |
|
419 |
// Preserve oop return value across possible gc points |
|
420 |
if (oop_result_flag) { |
|
421 |
thread->set_vm_result((oop) result->get_jobject()); |
|
422 |
} |
|
423 |
} |
|
424 |
} // Exit JavaCallWrapper (can block - potential return oop must be preserved) |
|
425 |
||
426 |
// Check if a thread stop or suspend should be executed |
|
427 |
// The following assert was not realistic. Thread.stop can set that bit at any moment. |
|
428 |
//assert(!thread->has_special_runtime_exit_condition(), "no async. exceptions should be installed"); |
|
429 |
||
430 |
// Restore possible oop return |
|
431 |
if (oop_result_flag) { |
|
432 |
result->set_jobject((jobject)thread->vm_result()); |
|
433 |
thread->set_vm_result(NULL); |
|
434 |
} |
|
435 |
} |
|
436 |
||
437 |
||
438 |
//-------------------------------------------------------------------------------------- |
|
439 |
// Implementation of JavaCallArguments |
|
440 |
||
441 |
intptr_t* JavaCallArguments::parameters() { |
|
442 |
// First convert all handles to oops |
|
443 |
for(int i = 0; i < _size; i++) { |
|
444 |
if (_is_oop[i]) { |
|
445 |
// Handle conversion |
|
20282
7f9cbdf89af2
7195622: CheckUnhandledOops has limited usefulness now
hseigel
parents:
14583
diff
changeset
|
446 |
_value[i] = cast_from_oop<intptr_t>(Handle::raw_resolve((oop *)_value[i])); |
1 | 447 |
} |
448 |
} |
|
449 |
// Return argument vector |
|
5419 | 450 |
return _value; |
1 | 451 |
} |
452 |
||
453 |
||
454 |
class SignatureChekker : public SignatureIterator { |
|
455 |
private: |
|
456 |
bool *_is_oop; |
|
457 |
int _pos; |
|
458 |
BasicType _return_type; |
|
1618
2d86b9b84aa5
6739363: Xcheck jni doesn't check native function arguments
poonam
parents:
1
diff
changeset
|
459 |
intptr_t* _value; |
2d86b9b84aa5
6739363: Xcheck jni doesn't check native function arguments
poonam
parents:
1
diff
changeset
|
460 |
Thread* _thread; |
1 | 461 |
|
462 |
public: |
|
463 |
bool _is_return; |
|
464 |
||
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
465 |
SignatureChekker(Symbol* signature, BasicType return_type, bool is_static, bool* is_oop, intptr_t* value, Thread* thread) : SignatureIterator(signature) { |
1 | 466 |
_is_oop = is_oop; |
467 |
_is_return = false; |
|
468 |
_return_type = return_type; |
|
469 |
_pos = 0; |
|
1618
2d86b9b84aa5
6739363: Xcheck jni doesn't check native function arguments
poonam
parents:
1
diff
changeset
|
470 |
_value = value; |
2d86b9b84aa5
6739363: Xcheck jni doesn't check native function arguments
poonam
parents:
1
diff
changeset
|
471 |
_thread = thread; |
2d86b9b84aa5
6739363: Xcheck jni doesn't check native function arguments
poonam
parents:
1
diff
changeset
|
472 |
|
1 | 473 |
if (!is_static) { |
474 |
check_value(true); // Receiver must be an oop |
|
475 |
} |
|
476 |
} |
|
477 |
||
478 |
void check_value(bool type) { |
|
479 |
guarantee(_is_oop[_pos++] == type, "signature does not match pushed arguments"); |
|
480 |
} |
|
481 |
||
482 |
void check_doing_return(bool state) { _is_return = state; } |
|
483 |
||
484 |
void check_return_type(BasicType t) { |
|
485 |
guarantee(_is_return && t == _return_type, "return type does not match"); |
|
486 |
} |
|
487 |
||
488 |
void check_int(BasicType t) { |
|
489 |
if (_is_return) { |
|
490 |
check_return_type(t); |
|
491 |
return; |
|
492 |
} |
|
493 |
check_value(false); |
|
494 |
} |
|
495 |
||
496 |
void check_double(BasicType t) { check_long(t); } |
|
497 |
||
498 |
void check_long(BasicType t) { |
|
499 |
if (_is_return) { |
|
500 |
check_return_type(t); |
|
501 |
return; |
|
502 |
} |
|
503 |
||
504 |
check_value(false); |
|
505 |
check_value(false); |
|
506 |
} |
|
507 |
||
508 |
void check_obj(BasicType t) { |
|
509 |
if (_is_return) { |
|
510 |
check_return_type(t); |
|
511 |
return; |
|
512 |
} |
|
1618
2d86b9b84aa5
6739363: Xcheck jni doesn't check native function arguments
poonam
parents:
1
diff
changeset
|
513 |
|
2d86b9b84aa5
6739363: Xcheck jni doesn't check native function arguments
poonam
parents:
1
diff
changeset
|
514 |
// verify handle and the oop pointed to by handle |
2d86b9b84aa5
6739363: Xcheck jni doesn't check native function arguments
poonam
parents:
1
diff
changeset
|
515 |
int p = _pos; |
2d86b9b84aa5
6739363: Xcheck jni doesn't check native function arguments
poonam
parents:
1
diff
changeset
|
516 |
bool bad = false; |
2d86b9b84aa5
6739363: Xcheck jni doesn't check native function arguments
poonam
parents:
1
diff
changeset
|
517 |
// If argument is oop |
2d86b9b84aa5
6739363: Xcheck jni doesn't check native function arguments
poonam
parents:
1
diff
changeset
|
518 |
if (_is_oop[p]) { |
2d86b9b84aa5
6739363: Xcheck jni doesn't check native function arguments
poonam
parents:
1
diff
changeset
|
519 |
intptr_t v = _value[p]; |
2d86b9b84aa5
6739363: Xcheck jni doesn't check native function arguments
poonam
parents:
1
diff
changeset
|
520 |
if (v != 0 ) { |
2d86b9b84aa5
6739363: Xcheck jni doesn't check native function arguments
poonam
parents:
1
diff
changeset
|
521 |
size_t t = (size_t)v; |
1685
77af56c90c99
6786340: hs14b09a pit: a lot of tests failed in "-server -Xcomp" on solaris-amd64 using fastdebug bits
poonam
parents:
1618
diff
changeset
|
522 |
bad = (t < (size_t)os::vm_page_size() ) || !Handle::raw_resolve((oop *)v)->is_oop_or_null(true); |
1618
2d86b9b84aa5
6739363: Xcheck jni doesn't check native function arguments
poonam
parents:
1
diff
changeset
|
523 |
if (CheckJNICalls && bad) { |
2d86b9b84aa5
6739363: Xcheck jni doesn't check native function arguments
poonam
parents:
1
diff
changeset
|
524 |
ReportJNIFatalError((JavaThread*)_thread, "Bad JNI oop argument"); |
2d86b9b84aa5
6739363: Xcheck jni doesn't check native function arguments
poonam
parents:
1
diff
changeset
|
525 |
} |
2d86b9b84aa5
6739363: Xcheck jni doesn't check native function arguments
poonam
parents:
1
diff
changeset
|
526 |
} |
2d86b9b84aa5
6739363: Xcheck jni doesn't check native function arguments
poonam
parents:
1
diff
changeset
|
527 |
// for the regular debug case. |
2d86b9b84aa5
6739363: Xcheck jni doesn't check native function arguments
poonam
parents:
1
diff
changeset
|
528 |
assert(!bad, "Bad JNI oop argument"); |
2d86b9b84aa5
6739363: Xcheck jni doesn't check native function arguments
poonam
parents:
1
diff
changeset
|
529 |
} |
2d86b9b84aa5
6739363: Xcheck jni doesn't check native function arguments
poonam
parents:
1
diff
changeset
|
530 |
|
1 | 531 |
check_value(true); |
532 |
} |
|
533 |
||
534 |
void do_bool() { check_int(T_BOOLEAN); } |
|
535 |
void do_char() { check_int(T_CHAR); } |
|
536 |
void do_float() { check_int(T_FLOAT); } |
|
537 |
void do_double() { check_double(T_DOUBLE); } |
|
538 |
void do_byte() { check_int(T_BYTE); } |
|
539 |
void do_short() { check_int(T_SHORT); } |
|
540 |
void do_int() { check_int(T_INT); } |
|
541 |
void do_long() { check_long(T_LONG); } |
|
542 |
void do_void() { check_return_type(T_VOID); } |
|
543 |
void do_object(int begin, int end) { check_obj(T_OBJECT); } |
|
544 |
void do_array(int begin, int end) { check_obj(T_OBJECT); } |
|
545 |
}; |
|
546 |
||
1618
2d86b9b84aa5
6739363: Xcheck jni doesn't check native function arguments
poonam
parents:
1
diff
changeset
|
547 |
|
33593
60764a78fa5c
8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents:
33160
diff
changeset
|
548 |
void JavaCallArguments::verify(const methodHandle& method, BasicType return_type, |
1 | 549 |
Thread *thread) { |
550 |
guarantee(method->size_of_parameters() == size_of_parameters(), "wrong no. of arguments pushed"); |
|
551 |
||
552 |
// Treat T_OBJECT and T_ARRAY as the same |
|
553 |
if (return_type == T_ARRAY) return_type = T_OBJECT; |
|
554 |
||
555 |
// Check that oop information is correct |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
556 |
Symbol* signature = method->signature(); |
1 | 557 |
|
1618
2d86b9b84aa5
6739363: Xcheck jni doesn't check native function arguments
poonam
parents:
1
diff
changeset
|
558 |
SignatureChekker sc(signature, return_type, method->is_static(),_is_oop, _value, thread); |
1 | 559 |
sc.iterate_parameters(); |
560 |
sc.check_doing_return(true); |
|
561 |
sc.iterate_returntype(); |
|
562 |
} |