Mercurial > hg > graal-compiler

comparison src/share/vm/runtime/javaCalls.cpp @ 14768:3e9a960f0da1

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
HSAIL: preliminary deopt support Contributed-by: Tom Deneau <tom.deneau@amd.com>
author Doug Simon <doug.simon@oracle.com>
date Wed, 26 Mar 2014 17:33:54 +0100
parents d8041d695d19
children 4ca6dc0799b6
comparison
equal deleted inserted replaced
14767:ded08e344e4a 14768:3e9a960f0da1
38 #include "runtime/javaCalls.hpp" 38 #include "runtime/javaCalls.hpp"
39 #include "runtime/mutexLocker.hpp" 39 #include "runtime/mutexLocker.hpp"
40 #include "runtime/signature.hpp" 40 #include "runtime/signature.hpp"
41 #include "runtime/stubRoutines.hpp" 41 #include "runtime/stubRoutines.hpp"
42 #include "runtime/thread.inline.hpp" 42 #include "runtime/thread.inline.hpp"
43 #include "graal/graalJavaAccess.hpp"
44 #include "graal/graalCompiler.hpp"
43 45
44 // ----------------------------------------------------- 46 // -----------------------------------------------------
45 // Implementation of JavaCallWrapper 47 // Implementation of JavaCallWrapper
46 48
47 JavaCallWrapper::JavaCallWrapper(methodHandle callee_method, Handle receiver, JavaValue* result, TRAPS) { 49 JavaCallWrapper::JavaCallWrapper(methodHandle callee_method, JavaValue* result, TRAPS) {
48 JavaThread* thread = (JavaThread *)THREAD; 50 JavaThread* thread = (JavaThread *)THREAD;
49 bool clear_pending_exception = true; 51 bool clear_pending_exception = true;
50 52
51 guarantee(thread->is_Java_thread(), "crucial check - the VM thread cannot and must not escape to Java code"); 53 guarantee(thread->is_Java_thread(), "crucial check - the VM thread cannot and must not escape to Java code");
52 assert(!thread->owns_locks(), "must release all locks when leaving VM"); 54 assert(!thread->owns_locks(), "must release all locks when leaving VM");
73 75
74 76
75 // Make sure to set the oop's after the thread transition - since we can block there. No one is GC'ing 77 // Make sure to set the oop's after the thread transition - since we can block there. No one is GC'ing
76 // the JavaCallWrapper before the entry frame is on the stack. 78 // the JavaCallWrapper before the entry frame is on the stack.
77 _callee_method = callee_method(); 79 _callee_method = callee_method();
78 _receiver = receiver();
79 80
80 #ifdef CHECK_UNHANDLED_OOPS 81 #ifdef CHECK_UNHANDLED_OOPS
81 THREAD->allow_unhandled_oop(&_receiver); 82 // THREAD->allow_unhandled_oop(&_receiver);
82 #endif // CHECK_UNHANDLED_OOPS 83 #endif // CHECK_UNHANDLED_OOPS
83 84
84 _thread = (JavaThread *)thread; 85 _thread = (JavaThread *)thread;
85 _handles = _thread->active_handles(); // save previous handle block & Java frame linkage 86 _handles = _thread->active_handles(); // save previous handle block & Java frame linkage
86 87
140 JNIHandleBlock::release_block(_old_handles, _thread); 141 JNIHandleBlock::release_block(_old_handles, _thread);
141 } 142 }
142 143
143 144
144 void JavaCallWrapper::oops_do(OopClosure* f) { 145 void JavaCallWrapper::oops_do(OopClosure* f) {
145 f->do_oop((oop*)&_receiver);
146 handles()->oops_do(f); 146 handles()->oops_do(f);
147 } 147 }
148 148
149 149
150 // Helper methods 150 // Helper methods
333 assert(!thread->handle_area()->no_handle_mark_active(), "cannot call out to Java here"); 333 assert(!thread->handle_area()->no_handle_mark_active(), "cannot call out to Java here");
334 334
335 335
336 CHECK_UNHANDLED_OOPS_ONLY(thread->clear_unhandled_oops();) 336 CHECK_UNHANDLED_OOPS_ONLY(thread->clear_unhandled_oops();)
337 337
338 #ifdef GRAAL
339 nmethod* nm = args->alternative_target();
340 if (nm == NULL) {
341 #endif
338 // Verify the arguments 342 // Verify the arguments
339 343
340 if (CheckJNICalls) { 344 if (CheckJNICalls) {
341 args->verify(method, result->get_type(), thread); 345 args->verify(method, result->get_type(), thread);
342 } 346 }
343 else debug_only(args->verify(method, result->get_type(), thread)); 347 else debug_only(args->verify(method, result->get_type(), thread));
344 348 #ifdef GRAAL
345 #ifndef GRAAL 349 }
350 #else
346 // Ignore call if method is empty 351 // Ignore call if method is empty
347 if (method->is_empty_method()) { 352 if (method->is_empty_method()) {
348 assert(result->get_type() == T_VOID, "an empty method must return a void value"); 353 assert(result->get_type() == T_VOID, "an empty method must return a void value");
349 return; 354 return;
350 } 355 }
382 bool oop_result_flag = (result->get_type() == T_OBJECT || result->get_type() == T_ARRAY); 387 bool oop_result_flag = (result->get_type() == T_OBJECT || result->get_type() == T_ARRAY);
383 388
384 // NOTE: if we move the computation of the result_val_address inside 389 // NOTE: if we move the computation of the result_val_address inside
385 // the call to call_stub, the optimizer produces wrong code. 390 // the call to call_stub, the optimizer produces wrong code.
386 intptr_t* result_val_address = (intptr_t*)(result->get_value_addr()); 391 intptr_t* result_val_address = (intptr_t*)(result->get_value_addr());
387
388 // Find receiver
389 Handle receiver = (!method->is_static()) ? args->receiver() : Handle();
390 392
391 // When we reenter Java, we need to reenable the yellow zone which 393 // When we reenter Java, we need to reenable the yellow zone which
392 // might already be disabled when we are in VM. 394 // might already be disabled when we are in VM.
393 if (thread->stack_yellow_zone_disabled()) { 395 if (thread->stack_yellow_zone_disabled()) {
394 thread->reguard_stack(); 396 thread->reguard_stack();
404 // Touch pages checked if the OS needs them to be touched to be mapped. 406 // Touch pages checked if the OS needs them to be touched to be mapped.
405 os::bang_stack_shadow_pages(); 407 os::bang_stack_shadow_pages();
406 } 408 }
407 409
408 #ifdef GRAAL 410 #ifdef GRAAL
409 nmethod* nm = args->alternative_target();
410 if (nm != NULL) { 411 if (nm != NULL) {
411 if (nm->is_alive()) { 412 if (nm->is_alive()) {
412 ((JavaThread*) THREAD)->set_graal_alternate_call_target(nm->verified_entry_point()); 413 ((JavaThread*) THREAD)->set_graal_alternate_call_target(nm->verified_entry_point());
414 oop graalInstalledCode = nm->graal_installed_code();
415 if (graalInstalledCode != NULL && HotSpotNmethod::isExternal(graalInstalledCode)) {
416 entry_point = GraalCompiler::instance()->get_external_deopt_i2c_entry();
417 } else {
413 entry_point = method->adapter()->get_i2c_entry(); 418 entry_point = method->adapter()->get_i2c_entry();
419 }
414 } else { 420 } else {
415 THROW(vmSymbols::com_oracle_graal_api_code_InvalidInstalledCodeException()); 421 THROW(vmSymbols::com_oracle_graal_api_code_InvalidInstalledCodeException());
416 } 422 }
417 } 423 }
418 #endif 424 #endif
419 425
420 // do call 426 // do call
421 { JavaCallWrapper link(method, receiver, result, CHECK); 427 { JavaCallWrapper link(method, result, CHECK);
422 { HandleMark hm(thread); // HandleMark used by HandleMarkCleaner 428 { HandleMark hm(thread); // HandleMark used by HandleMarkCleaner
423 429
424 StubRoutines::call_stub()( 430 StubRoutines::call_stub()(
425 (address)&link, 431 (address)&link,
426 // (intptr_t*)&(result->_value), // see NOTE above (compiler problem) 432 // (intptr_t*)&(result->_value), // see NOTE above (compiler problem)