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