1 /* 2 * Copyright (c) 1997, 2022, Oracle and/or its affiliates. All rights reserved. 3 * Copyright (c) 2021, Azul Systems, Inc. All rights reserved. 4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 5 * 6 * This code is free software; you can redistribute it and/or modify it 7 * under the terms of the GNU General Public License version 2 only, as 8 * published by the Free Software Foundation. 9 * 10 * This code is distributed in the hope that it will be useful, but WITHOUT 11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 13 * version 2 for more details (a copy is included in the LICENSE file that 14 * accompanied this code). 15 * 16 * You should have received a copy of the GNU General Public License version 17 * 2 along with this work; if not, write to the Free Software Foundation, 18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 19 * 20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 21 * or visit www.oracle.com if you need additional information or have any 22 * questions. 23 * 24 */ 25 26 #include "precompiled.hpp" 27 #include "classfile/vmSymbols.hpp" 28 #include "code/nmethod.hpp" 29 #include "compiler/compilationPolicy.hpp" 30 #include "compiler/compileBroker.hpp" 31 #include "interpreter/interpreter.hpp" 32 #include "interpreter/linkResolver.hpp" 33 #if INCLUDE_JVMCI 34 #include "jvmci/jvmciJavaClasses.hpp" 35 #endif 36 #include "memory/universe.hpp" 37 #include "oops/method.inline.hpp" 38 #include "oops/oop.inline.hpp" 39 #include "prims/jniCheck.hpp" 40 #include "prims/jvmtiExport.hpp" 41 #include "runtime/handles.inline.hpp" 42 #include "runtime/interfaceSupport.inline.hpp" 43 #include "runtime/javaCalls.hpp" 44 #include "runtime/jniHandles.inline.hpp" 45 #include "runtime/mutexLocker.hpp" 46 #include "runtime/os.inline.hpp" 47 #include "runtime/sharedRuntime.hpp" 48 #include "runtime/signature.hpp" 49 #include "runtime/stubRoutines.hpp" 50 #include "runtime/thread.inline.hpp" 51 52 // ----------------------------------------------------- 53 // Implementation of JavaCallWrapper 54 55 JavaCallWrapper::JavaCallWrapper(const methodHandle& callee_method, Handle receiver, JavaValue* result, TRAPS) { 56 JavaThread* thread = THREAD; 57 58 guarantee(thread->is_Java_thread(), "crucial check - the VM thread cannot and must not escape to Java code"); 59 assert(!thread->owns_locks(), "must release all locks when leaving VM"); 60 guarantee(thread->can_call_java(), "cannot make java calls from the native compiler"); 61 _result = result; 62 63 // Allocate handle block for Java code. This must be done before we change thread_state to _thread_in_Java_or_stub, 64 // since it can potentially block. 65 JNIHandleBlock* new_handles = JNIHandleBlock::allocate_block(thread); 66 67 // clear any pending exception in thread (native calls start with no exception pending) 68 thread->clear_pending_exception(); 69 70 // After this, we are official in JavaCode. This needs to be done before we change any of the thread local 71 // info, since we cannot find oops before the new information is set up completely. 72 ThreadStateTransition::transition_from_vm(thread, _thread_in_Java, true /* check_asyncs */); 73 74 // Make sure to set the oop's after the thread transition - since we can block there. No one is GC'ing 75 // the JavaCallWrapper before the entry frame is on the stack. 76 _callee_method = callee_method(); 77 _receiver = receiver(); 78 79 #ifdef CHECK_UNHANDLED_OOPS 80 THREAD->allow_unhandled_oop(&_receiver); 81 #endif // CHECK_UNHANDLED_OOPS 82 83 _thread = thread; 84 _handles = _thread->active_handles(); // save previous handle block & Java frame linkage 85 86 // For the profiler, the last_Java_frame information in thread must always be in 87 // legal state. We have no last Java frame if last_Java_sp == NULL so 88 // the valid transition is to clear _last_Java_sp and then reset the rest of 89 // the (platform specific) state. 90 91 _anchor.copy(_thread->frame_anchor()); 92 _thread->frame_anchor()->clear(); 93 94 debug_only(_thread->inc_java_call_counter()); 95 _thread->set_active_handles(new_handles); // install new handle block and reset Java frame linkage 96 97 assert (_thread->thread_state() != _thread_in_native, "cannot set native pc to NULL"); 98 99 MACOS_AARCH64_ONLY(_thread->enable_wx(WXExec)); 100 } 101 102 103 JavaCallWrapper::~JavaCallWrapper() { 104 assert(_thread == JavaThread::current(), "must still be the same thread"); 105 106 MACOS_AARCH64_ONLY(_thread->enable_wx(WXWrite)); 107 108 // restore previous handle block & Java frame linkage 109 JNIHandleBlock *_old_handles = _thread->active_handles(); 110 _thread->set_active_handles(_handles); 111 112 _thread->frame_anchor()->zap(); 113 114 debug_only(_thread->dec_java_call_counter()); 115 116 // Old thread-local info. has been restored. We are not back in the VM. 117 ThreadStateTransition::transition_from_java(_thread, _thread_in_vm); 118 119 // State has been restored now make the anchor frame visible for the profiler. 120 // Do this after the transition because this allows us to put an assert 121 // the Java->vm transition which checks to see that stack is not walkable 122 // on sparc/ia64 which will catch violations of the reseting of last_Java_frame 123 // invariants (i.e. _flags always cleared on return to Java) 124 125 _thread->frame_anchor()->copy(&_anchor); 126 127 // Release handles after we are marked as being inside the VM again, since this 128 // operation might block 129 JNIHandleBlock::release_block(_old_handles, _thread); 130 131 if (_thread->has_pending_exception() && _thread->has_last_Java_frame()) { 132 // If we get here, the Java code threw an exception that unwound a frame. 133 // It could be that the new frame anchor has not passed through the required 134 // StackWatermark barriers. Therefore, we process any such deferred unwind 135 // requests here. 136 StackWatermarkSet::after_unwind(_thread); 137 } 138 } 139 140 141 void JavaCallWrapper::oops_do(OopClosure* f) { 142 f->do_oop((oop*)&_receiver); 143 handles()->oops_do(f); 144 } 145 146 147 // Helper methods 148 static BasicType runtime_type_from(JavaValue* result) { 149 switch (result->get_type()) { 150 case T_BOOLEAN: // fall through 151 case T_CHAR : // fall through 152 case T_SHORT : // fall through 153 case T_INT : // fall through 154 #ifndef _LP64 155 case T_OBJECT : // fall through 156 case T_ARRAY : // fall through 157 #endif 158 case T_BYTE : // fall through 159 case T_VOID : return T_INT; 160 case T_LONG : return T_LONG; 161 case T_FLOAT : return T_FLOAT; 162 case T_DOUBLE : return T_DOUBLE; 163 #ifdef _LP64 164 case T_ARRAY : // fall through 165 case T_OBJECT: return T_OBJECT; 166 #endif 167 default: 168 ShouldNotReachHere(); 169 return T_ILLEGAL; 170 } 171 } 172 173 // ============ Virtual calls ============ 174 175 void JavaCalls::call_virtual(JavaValue* result, Klass* spec_klass, Symbol* name, Symbol* signature, JavaCallArguments* args, TRAPS) { 176 CallInfo callinfo; 177 Handle receiver = args->receiver(); 178 Klass* recvrKlass = receiver.is_null() ? (Klass*)NULL : receiver->klass(); 179 LinkInfo link_info(spec_klass, name, signature); 180 LinkResolver::resolve_virtual_call( 181 callinfo, receiver, recvrKlass, link_info, true, CHECK); 182 methodHandle method(THREAD, callinfo.selected_method()); 183 assert(method.not_null(), "should have thrown exception"); 184 185 // Invoke the method 186 JavaCalls::call(result, method, args, CHECK); 187 } 188 189 190 void JavaCalls::call_virtual(JavaValue* result, Handle receiver, Klass* spec_klass, Symbol* name, Symbol* signature, TRAPS) { 191 JavaCallArguments args(receiver); 192 call_virtual(result, spec_klass, name, signature, &args, CHECK); 193 } 194 195 196 void JavaCalls::call_virtual(JavaValue* result, Handle receiver, Klass* spec_klass, Symbol* name, Symbol* signature, Handle arg1, TRAPS) { 197 JavaCallArguments args(receiver); 198 args.push_oop(arg1); 199 call_virtual(result, spec_klass, name, signature, &args, CHECK); 200 } 201 202 203 204 void JavaCalls::call_virtual(JavaValue* result, Handle receiver, Klass* spec_klass, Symbol* name, Symbol* signature, Handle arg1, Handle arg2, TRAPS) { 205 JavaCallArguments args(receiver); 206 args.push_oop(arg1); 207 args.push_oop(arg2); 208 call_virtual(result, spec_klass, name, signature, &args, CHECK); 209 } 210 211 212 // ============ Special calls ============ 213 214 void JavaCalls::call_special(JavaValue* result, Klass* klass, Symbol* name, Symbol* signature, JavaCallArguments* args, TRAPS) { 215 CallInfo callinfo; 216 LinkInfo link_info(klass, name, signature); 217 LinkResolver::resolve_special_call(callinfo, args->receiver(), link_info, CHECK); 218 methodHandle method(THREAD, callinfo.selected_method()); 219 assert(method.not_null(), "should have thrown exception"); 220 221 // Invoke the method 222 JavaCalls::call(result, method, args, CHECK); 223 } 224 225 226 void JavaCalls::call_special(JavaValue* result, Handle receiver, Klass* klass, Symbol* name, Symbol* signature, TRAPS) { 227 JavaCallArguments args(receiver); 228 call_special(result, klass, name, signature, &args, CHECK); 229 } 230 231 232 void JavaCalls::call_special(JavaValue* result, Handle receiver, Klass* klass, Symbol* name, Symbol* signature, Handle arg1, TRAPS) { 233 JavaCallArguments args(receiver); 234 args.push_oop(arg1); 235 call_special(result, klass, name, signature, &args, CHECK); 236 } 237 238 239 void JavaCalls::call_special(JavaValue* result, Handle receiver, Klass* klass, Symbol* name, Symbol* signature, Handle arg1, Handle arg2, TRAPS) { 240 JavaCallArguments args(receiver); 241 args.push_oop(arg1); 242 args.push_oop(arg2); 243 call_special(result, klass, name, signature, &args, CHECK); 244 } 245 246 247 // ============ Static calls ============ 248 249 void JavaCalls::call_static(JavaValue* result, Klass* klass, Symbol* name, Symbol* signature, JavaCallArguments* args, TRAPS) { 250 CallInfo callinfo; 251 LinkInfo link_info(klass, name, signature); 252 LinkResolver::resolve_static_call(callinfo, link_info, true, CHECK); 253 methodHandle method(THREAD, callinfo.selected_method()); 254 assert(method.not_null(), "should have thrown exception"); 255 256 // Invoke the method 257 JavaCalls::call(result, method, args, CHECK); 258 } 259 260 261 void JavaCalls::call_static(JavaValue* result, Klass* klass, Symbol* name, Symbol* signature, TRAPS) { 262 JavaCallArguments args; 263 call_static(result, klass, name, signature, &args, CHECK); 264 } 265 266 267 void JavaCalls::call_static(JavaValue* result, Klass* klass, Symbol* name, Symbol* signature, Handle arg1, TRAPS) { 268 JavaCallArguments args(arg1); 269 call_static(result, klass, name, signature, &args, CHECK); 270 } 271 272 273 void JavaCalls::call_static(JavaValue* result, Klass* klass, Symbol* name, Symbol* signature, Handle arg1, Handle arg2, TRAPS) { 274 JavaCallArguments args; 275 args.push_oop(arg1); 276 args.push_oop(arg2); 277 call_static(result, klass, name, signature, &args, CHECK); 278 } 279 280 281 void JavaCalls::call_static(JavaValue* result, Klass* klass, Symbol* name, Symbol* signature, Handle arg1, Handle arg2, Handle arg3, TRAPS) { 282 JavaCallArguments args; 283 args.push_oop(arg1); 284 args.push_oop(arg2); 285 args.push_oop(arg3); 286 call_static(result, klass, name, signature, &args, CHECK); 287 } 288 289 // ============ allocate and initialize new object instance ============ 290 291 Handle JavaCalls::construct_new_instance(InstanceKlass* klass, Symbol* constructor_signature, JavaCallArguments* args, TRAPS) { 292 klass->initialize(CHECK_NH); // Quick no-op if already initialized. 293 Handle obj = klass->allocate_instance_handle(CHECK_NH); 294 JavaValue void_result(T_VOID); 295 args->set_receiver(obj); // inserts <obj> as the first argument. 296 JavaCalls::call_special(&void_result, klass, 297 vmSymbols::object_initializer_name(), 298 constructor_signature, args, CHECK_NH); 299 // Already returned a Null Handle if any exception is pending. 300 return obj; 301 } 302 303 Handle JavaCalls::construct_new_instance(InstanceKlass* klass, Symbol* constructor_signature, TRAPS) { 304 JavaCallArguments args; 305 return JavaCalls::construct_new_instance(klass, constructor_signature, &args, THREAD); 306 } 307 308 Handle JavaCalls::construct_new_instance(InstanceKlass* klass, Symbol* constructor_signature, Handle arg1, TRAPS) { 309 JavaCallArguments args; 310 args.push_oop(arg1); 311 return JavaCalls::construct_new_instance(klass, constructor_signature, &args, THREAD); 312 } 313 314 Handle JavaCalls::construct_new_instance(InstanceKlass* klass, Symbol* constructor_signature, Handle arg1, Handle arg2, TRAPS) { 315 JavaCallArguments args; 316 args.push_oop(arg1); 317 args.push_oop(arg2); 318 return JavaCalls::construct_new_instance(klass, constructor_signature, &args, THREAD); 319 } 320 321 // ------------------------------------------------- 322 // Implementation of JavaCalls (low level) 323 324 325 void JavaCalls::call(JavaValue* result, const methodHandle& method, JavaCallArguments* args, TRAPS) { 326 // Check if we need to wrap a potential OS exception handler around thread. 327 // This is used for e.g. Win32 structured exception handlers. 328 // Need to wrap each and every time, since there might be native code down the 329 // stack that has installed its own exception handlers. 330 os::os_exception_wrapper(call_helper, result, method, args, THREAD); 331 } 332 333 void JavaCalls::call_helper(JavaValue* result, const methodHandle& method, JavaCallArguments* args, TRAPS) { 334 335 JavaThread* thread = THREAD; 336 assert(method.not_null(), "must have a method to call"); 337 assert(!SafepointSynchronize::is_at_safepoint(), "call to Java code during VM operation"); 338 assert(!thread->handle_area()->no_handle_mark_active(), "cannot call out to Java here"); 339 340 // Verify the arguments 341 if (JVMCI_ONLY(args->alternative_target().is_null() &&) (DEBUG_ONLY(true ||) CheckJNICalls)) { 342 args->verify(method, result->get_type()); 343 } 344 // Ignore call if method is empty 345 if (JVMCI_ONLY(args->alternative_target().is_null() &&) method->is_empty_method()) { 346 assert(result->get_type() == T_VOID, "an empty method must return a void value"); 347 return; 348 } 349 350 #ifdef ASSERT 351 { InstanceKlass* holder = method->method_holder(); 352 // A klass might not be initialized since JavaCall's might be used during the executing of 353 // the <clinit>. For example, a Thread.start might start executing on an object that is 354 // not fully initialized! (bad Java programming style) 355 assert(holder->is_linked(), "rewriting must have taken place"); 356 } 357 #endif 358 359 CompilationPolicy::compile_if_required(method, CHECK); 360 361 // Since the call stub sets up like the interpreter we call the from_interpreted_entry 362 // so we can go compiled via a i2c. Otherwise initial entry method will always 363 // run interpreted. 364 address entry_point = method->from_interpreted_entry(); 365 if (JvmtiExport::can_post_interpreter_events() && thread->is_interp_only_mode()) { 366 entry_point = method->interpreter_entry(); 367 } 368 369 // Figure out if the result value is an oop or not (Note: This is a different value 370 // than result_type. result_type will be T_INT of oops. (it is about size) 371 BasicType result_type = runtime_type_from(result); 372 bool oop_result_flag = is_reference_type(result->get_type()); 373 374 // Find receiver 375 Handle receiver = (!method->is_static()) ? args->receiver() : Handle(); 376 377 // When we reenter Java, we need to reenable the reserved/yellow zone which 378 // might already be disabled when we are in VM. 379 thread->stack_overflow_state()->reguard_stack_if_needed(); 380 381 // Check that there are shadow pages available before changing thread state 382 // to Java. Calculate current_stack_pointer here to make sure 383 // stack_shadow_pages_available() and map_stack_shadow_pages() use the same sp. 384 address sp = os::current_stack_pointer(); 385 if (!os::stack_shadow_pages_available(THREAD, method, sp)) { 386 // Throw stack overflow exception with preinitialized exception. 387 Exceptions::throw_stack_overflow_exception(THREAD, __FILE__, __LINE__, method); 388 return; 389 } else { 390 // Touch pages checked if the OS needs them to be touched to be mapped. 391 os::map_stack_shadow_pages(sp); 392 } 393 394 // do call 395 { JavaCallWrapper link(method, receiver, result, CHECK); 396 { HandleMark hm(thread); // HandleMark used by HandleMarkCleaner 397 398 // NOTE: if we move the computation of the result_val_address inside 399 // the call to call_stub, the optimizer produces wrong code. 400 intptr_t* result_val_address = (intptr_t*)(result->get_value_addr()); 401 intptr_t* parameter_address = args->parameters(); 402 #if INCLUDE_JVMCI 403 // Gets the alternative target (if any) that should be called 404 Handle alternative_target = args->alternative_target(); 405 if (!alternative_target.is_null()) { 406 // Must extract verified entry point from HotSpotNmethod after VM to Java 407 // transition in JavaCallWrapper constructor so that it is safe with 408 // respect to nmethod sweeping. 409 address verified_entry_point = (address) HotSpotJVMCI::InstalledCode::entryPoint(NULL, alternative_target()); 410 if (verified_entry_point != NULL) { 411 thread->set_jvmci_alternate_call_target(verified_entry_point); 412 entry_point = method->adapter()->get_i2c_entry(); 413 } 414 } 415 #endif 416 StubRoutines::call_stub()( 417 (address)&link, 418 // (intptr_t*)&(result->_value), // see NOTE above (compiler problem) 419 result_val_address, // see NOTE above (compiler problem) 420 result_type, 421 method(), 422 entry_point, 423 parameter_address, 424 args->size_of_parameters(), 425 CHECK 426 ); 427 428 result = link.result(); // circumvent MS C++ 5.0 compiler bug (result is clobbered across call) 429 // Preserve oop return value across possible gc points 430 if (oop_result_flag) { 431 thread->set_vm_result(result->get_oop()); 432 } 433 } 434 } // Exit JavaCallWrapper (can block - potential return oop must be preserved) 435 436 // Check if a thread stop or suspend should be executed 437 // The following assert was not realistic. Thread.stop can set that bit at any moment. 438 //assert(!thread->has_special_runtime_exit_condition(), "no async. exceptions should be installed"); 439 440 // Restore possible oop return 441 if (oop_result_flag) { 442 result->set_oop(thread->vm_result()); 443 thread->set_vm_result(NULL); 444 } 445 } 446 447 448 //-------------------------------------------------------------------------------------- 449 // Implementation of JavaCallArguments 450 451 inline bool is_value_state_indirect_oop(uint state) { 452 assert(state != JavaCallArguments::value_state_oop, 453 "Checking for handles after removal"); 454 assert(state < JavaCallArguments::value_state_limit, 455 "Invalid value state %u", state); 456 return state != JavaCallArguments::value_state_primitive; 457 } 458 459 inline oop resolve_indirect_oop(intptr_t value, uint state) { 460 switch (state) { 461 case JavaCallArguments::value_state_handle: 462 { 463 oop* ptr = reinterpret_cast<oop*>(value); 464 return Handle::raw_resolve(ptr); 465 } 466 467 case JavaCallArguments::value_state_jobject: 468 { 469 jobject obj = reinterpret_cast<jobject>(value); 470 return JNIHandles::resolve(obj); 471 } 472 473 default: 474 ShouldNotReachHere(); 475 return NULL; 476 } 477 } 478 479 intptr_t* JavaCallArguments::parameters() { 480 // First convert all handles to oops 481 for(int i = 0; i < _size; i++) { 482 uint state = _value_state[i]; 483 assert(state != value_state_oop, "Multiple handle conversions"); 484 if (is_value_state_indirect_oop(state)) { 485 oop obj = resolve_indirect_oop(_value[i], state); 486 _value[i] = cast_from_oop<intptr_t>(obj); 487 _value_state[i] = value_state_oop; 488 } 489 } 490 // Return argument vector 491 return _value; 492 } 493 494 495 class SignatureChekker : public SignatureIterator { 496 private: 497 int _pos; 498 BasicType _return_type; 499 u_char* _value_state; 500 intptr_t* _value; 501 502 public: 503 SignatureChekker(Symbol* signature, 504 BasicType return_type, 505 bool is_static, 506 u_char* value_state, 507 intptr_t* value) : 508 SignatureIterator(signature), 509 _pos(0), 510 _return_type(return_type), 511 _value_state(value_state), 512 _value(value) 513 { 514 if (!is_static) { 515 check_value(true); // Receiver must be an oop 516 } 517 do_parameters_on(this); 518 check_return_type(return_type); 519 } 520 521 private: 522 void check_value(bool is_reference) { 523 uint state = _value_state[_pos++]; 524 if (is_reference) { 525 guarantee(is_value_state_indirect_oop(state), 526 "signature does not match pushed arguments: %u at %d", 527 state, _pos - 1); 528 } else { 529 guarantee(state == JavaCallArguments::value_state_primitive, 530 "signature does not match pushed arguments: %u at %d", 531 state, _pos - 1); 532 } 533 } 534 535 void check_return_type(BasicType t) { 536 guarantee(t == _return_type, "return type does not match"); 537 } 538 539 void check_single_word() { 540 check_value(false); 541 } 542 543 void check_double_word() { 544 check_value(false); 545 check_value(false); 546 } 547 548 void check_reference() { 549 intptr_t v = _value[_pos]; 550 if (v != 0) { 551 // v is a "handle" referring to an oop, cast to integral type. 552 // There shouldn't be any handles in very low memory. 553 guarantee((size_t)v >= (size_t)os::vm_page_size(), 554 "Bad JNI oop argument %d: " PTR_FORMAT, _pos, v); 555 // Verify the pointee. 556 oop vv = resolve_indirect_oop(v, _value_state[_pos]); 557 guarantee(oopDesc::is_oop_or_null(vv, true), 558 "Bad JNI oop argument %d: " PTR_FORMAT " -> " PTR_FORMAT, 559 _pos, v, p2i(vv)); 560 } 561 562 check_value(true); // Verify value state. 563 } 564 565 friend class SignatureIterator; // so do_parameters_on can call do_type 566 void do_type(BasicType type) { 567 switch (type) { 568 case T_BYTE: 569 case T_BOOLEAN: 570 case T_CHAR: 571 case T_SHORT: 572 case T_INT: 573 case T_FLOAT: // this one also 574 check_single_word(); break; 575 case T_LONG: 576 case T_DOUBLE: 577 check_double_word(); break; 578 case T_ARRAY: 579 case T_OBJECT: 580 check_reference(); break; 581 default: 582 ShouldNotReachHere(); 583 } 584 } 585 }; 586 587 588 void JavaCallArguments::verify(const methodHandle& method, BasicType return_type) { 589 guarantee(method->size_of_parameters() == size_of_parameters(), "wrong no. of arguments pushed"); 590 591 // Treat T_OBJECT and T_ARRAY as the same 592 if (is_reference_type(return_type)) return_type = T_OBJECT; 593 594 // Check that oop information is correct 595 Symbol* signature = method->signature(); 596 597 SignatureChekker sc(signature, 598 return_type, 599 method->is_static(), 600 _value_state, 601 _value); 602 }