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