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