< prev index next >

src/hotspot/share/interpreter/interpreterRuntime.cpp

Print this page


  70 
  71 class UnlockFlagSaver {
  72   private:
  73     JavaThread* _thread;
  74     bool _do_not_unlock;
  75   public:
  76     UnlockFlagSaver(JavaThread* t) {
  77       _thread = t;
  78       _do_not_unlock = t->do_not_unlock_if_synchronized();
  79       t->set_do_not_unlock_if_synchronized(false);
  80     }
  81     ~UnlockFlagSaver() {
  82       _thread->set_do_not_unlock_if_synchronized(_do_not_unlock);
  83     }
  84 };
  85 
  86 //------------------------------------------------------------------------------------------------------------------------
  87 // State accessors
  88 
  89 void InterpreterRuntime::set_bcp_and_mdp(address bcp, JavaThread *thread) {
  90   last_frame(thread).interpreter_frame_set_bcp(bcp);

  91   if (ProfileInterpreter) {
  92     // ProfileTraps uses MDOs independently of ProfileInterpreter.
  93     // That is why we must check both ProfileInterpreter and mdo != NULL.
  94     MethodData* mdo = last_frame(thread).interpreter_frame_method()->method_data();
  95     if (mdo != NULL) {
  96       NEEDS_CLEANUP;
  97       last_frame(thread).interpreter_frame_set_mdp(mdo->bci_to_dp(last_frame(thread).interpreter_frame_bci()));
  98     }
  99   }
 100 }
 101 
 102 //------------------------------------------------------------------------------------------------------------------------
 103 // Constants
 104 
 105 
 106 IRT_ENTRY(void, InterpreterRuntime::ldc(JavaThread* thread, bool wide))
 107   // access constant pool
 108   ConstantPool* pool = method(thread)->constants();
 109   int index = wide ? get_index_u2(thread, Bytecodes::_ldc_w) : get_index_u1(thread, Bytecodes::_ldc);

 110   constantTag tag = pool->tag_at(index);
 111 
 112   assert (tag.is_unresolved_klass() || tag.is_klass(), "wrong ldc call");
 113   Klass* klass = pool->klass_at(index, CHECK);
 114     oop java_class = klass->java_mirror();
 115     thread->set_vm_result(java_class);
 116 IRT_END
 117 
 118 IRT_ENTRY(void, InterpreterRuntime::resolve_ldc(JavaThread* thread, Bytecodes::Code bytecode)) {
 119   assert(bytecode == Bytecodes::_fast_aldc ||
 120          bytecode == Bytecodes::_fast_aldc_w, "wrong bc");
 121   ResourceMark rm(thread);
 122   methodHandle m (thread, method(thread));
 123   Bytecode_loadconstant ldc(m, bci(thread));

 124   oop result = ldc.resolve_constant(CHECK);
 125 #ifdef ASSERT
 126   {
 127     // The bytecode wrappers aren't GC-safe so construct a new one
 128     Bytecode_loadconstant ldc2(m, bci(thread));
 129     oop coop = m->constants()->resolved_references()->obj_at(ldc2.cache_index());
 130     assert(result == coop, "expected result for assembly code");
 131   }
 132 #endif
 133   thread->set_vm_result(result);
 134 }
 135 IRT_END
 136 
 137 
 138 //------------------------------------------------------------------------------------------------------------------------
 139 // Allocation
 140 
 141 IRT_ENTRY(void, InterpreterRuntime::_new(JavaThread* thread, ConstantPool* pool, int index))
 142   Klass* k = pool->klass_at(index, CHECK);
 143   InstanceKlass* klass = InstanceKlass::cast(k);
 144 
 145   // Make sure we are not instantiating an abstract klass
 146   klass->check_valid_for_instantiation(true, CHECK);
 147 
 148   // Make sure klass is initialized


 165   oop obj = klass->allocate_instance(CHECK);
 166   thread->set_vm_result(obj);
 167 IRT_END
 168 
 169 
 170 IRT_ENTRY(void, InterpreterRuntime::newarray(JavaThread* thread, BasicType type, jint size))
 171   oop obj = oopFactory::new_typeArray(type, size, CHECK);
 172   thread->set_vm_result(obj);
 173 IRT_END
 174 
 175 
 176 IRT_ENTRY(void, InterpreterRuntime::anewarray(JavaThread* thread, ConstantPool* pool, int index, jint size))
 177   Klass*    klass = pool->klass_at(index, CHECK);
 178   objArrayOop obj = oopFactory::new_objArray(klass, size, CHECK);
 179   thread->set_vm_result(obj);
 180 IRT_END
 181 
 182 
 183 IRT_ENTRY(void, InterpreterRuntime::multianewarray(JavaThread* thread, jint* first_size_address))
 184   // We may want to pass in more arguments - could make this slightly faster
 185   ConstantPool* constants = method(thread)->constants();
 186   int          i = get_index_u2(thread, Bytecodes::_multianewarray);

 187   Klass* klass = constants->klass_at(i, CHECK);
 188   int   nof_dims = number_of_dimensions(thread);
 189   assert(klass->is_klass(), "not a class");
 190   assert(nof_dims >= 1, "multianewarray rank must be nonzero");
 191 
 192   // We must create an array of jints to pass to multi_allocate.
 193   ResourceMark rm(thread);
 194   const int small_dims = 10;
 195   jint dim_array[small_dims];
 196   jint *dims = &dim_array[0];
 197   if (nof_dims > small_dims) {
 198     dims = (jint*) NEW_RESOURCE_ARRAY(jint, nof_dims);
 199   }
 200   for (int index = 0; index < nof_dims; index++) {
 201     // offset from first_size_address is addressed as local[index]
 202     int n = Interpreter::local_offset_in_bytes(index)/jintSize;
 203     dims[index] = first_size_address[n];
 204   }
 205   oop obj = ArrayKlass::cast(klass)->multi_allocate(nof_dims, dims, CHECK);
 206   thread->set_vm_result(obj);
 207 IRT_END
 208 
 209 
 210 IRT_ENTRY(void, InterpreterRuntime::register_finalizer(JavaThread* thread, oopDesc* obj))
 211   assert(oopDesc::is_oop(obj), "must be a valid oop");
 212   assert(obj->klass()->has_finalizer(), "shouldn't be here otherwise");
 213   InstanceKlass::register_finalizer(instanceOop(obj), CHECK);
 214 IRT_END
 215 
 216 
 217 // Quicken instance-of and check-cast bytecodes
 218 IRT_ENTRY(void, InterpreterRuntime::quicken_io_cc(JavaThread* thread))
 219   // Force resolving; quicken the bytecode
 220   int which = get_index_u2(thread, Bytecodes::_checkcast);
 221   ConstantPool* cpool = method(thread)->constants();

 222   // We'd expect to assert that we're only here to quicken bytecodes, but in a multithreaded
 223   // program we might have seen an unquick'd bytecode in the interpreter but have another
 224   // thread quicken the bytecode before we get here.
 225   // assert( cpool->tag_at(which).is_unresolved_klass(), "should only come here to quicken bytecodes" );
 226   Klass* klass = cpool->klass_at(which, CHECK);
 227   thread->set_vm_result_2(klass);
 228 IRT_END
 229 
 230 
 231 //------------------------------------------------------------------------------------------------------------------------
 232 // Exceptions
 233 
 234 void InterpreterRuntime::note_trap_inner(JavaThread* thread, int reason,
 235                                          const methodHandle& trap_method, int trap_bci, TRAPS) {
 236   if (trap_method.not_null()) {
 237     MethodData* trap_mdo = trap_method->method_data();
 238     if (trap_mdo == NULL) {
 239       Method::build_interpreter_method_data(trap_method, THREAD);
 240       if (HAS_PENDING_EXCEPTION) {
 241         assert((PENDING_EXCEPTION->is_a(SystemDictionary::OutOfMemoryError_klass())),
 242                "we expect only an OOM error here");
 243         CLEAR_PENDING_EXCEPTION;
 244       }
 245       trap_mdo = trap_method->method_data();
 246       // and fall through...
 247     }
 248     if (trap_mdo != NULL) {
 249       // Update per-method count of trap events.  The interpreter
 250       // is updating the MDO to simulate the effect of compiler traps.
 251       Deoptimization::update_method_data_from_interpreter(trap_mdo, trap_bci, reason);
 252     }
 253   }
 254 }
 255 
 256 // Assume the compiler is (or will be) interested in this event.
 257 // If necessary, create an MDO to hold the information, and record it.
 258 void InterpreterRuntime::note_trap(JavaThread* thread, int reason, TRAPS) {
 259   assert(ProfileTraps, "call me only if profiling");
 260   methodHandle trap_method(thread, method(thread));
 261   int trap_bci = trap_method->bci_from(bcp(thread));

 262   note_trap_inner(thread, reason, trap_method, trap_bci, THREAD);
 263 }
 264 
 265 #ifdef CC_INTERP
 266 // As legacy note_trap, but we have more arguments.
 267 IRT_ENTRY(void, InterpreterRuntime::note_trap(JavaThread* thread, int reason, Method *method, int trap_bci))
 268   methodHandle trap_method(method);
 269   note_trap_inner(thread, reason, trap_method, trap_bci, THREAD);
 270 IRT_END
 271 
 272 // Class Deoptimization is not visible in BytecodeInterpreter, so we need a wrapper
 273 // for each exception.
 274 void InterpreterRuntime::note_nullCheck_trap(JavaThread* thread, Method *method, int trap_bci)
 275   { if (ProfileTraps) note_trap(thread, Deoptimization::Reason_null_check, method, trap_bci); }
 276 void InterpreterRuntime::note_div0Check_trap(JavaThread* thread, Method *method, int trap_bci)
 277   { if (ProfileTraps) note_trap(thread, Deoptimization::Reason_div0_check, method, trap_bci); }
 278 void InterpreterRuntime::note_rangeCheck_trap(JavaThread* thread, Method *method, int trap_bci)
 279   { if (ProfileTraps) note_trap(thread, Deoptimization::Reason_range_check, method, trap_bci); }
 280 void InterpreterRuntime::note_classCheck_trap(JavaThread* thread, Method *method, int trap_bci)
 281   { if (ProfileTraps) note_trap(thread, Deoptimization::Reason_class_check, method, trap_bci); }


 374     thread, obj->klass());
 375 
 376   if (ProfileTraps) {
 377     note_trap(thread, Deoptimization::Reason_class_check, CHECK);
 378   }
 379 
 380   // create exception
 381   THROW_MSG(vmSymbols::java_lang_ClassCastException(), message);
 382 IRT_END
 383 
 384 // exception_handler_for_exception(...) returns the continuation address,
 385 // the exception oop (via TLS) and sets the bci/bcp for the continuation.
 386 // The exception oop is returned to make sure it is preserved over GC (it
 387 // is only on the stack if the exception was thrown explicitly via athrow).
 388 // During this operation, the expression stack contains the values for the
 389 // bci where the exception happened. If the exception was propagated back
 390 // from a call, the expression stack contains the values for the bci at the
 391 // invoke w/o arguments (i.e., as if one were inside the call).
 392 IRT_ENTRY(address, InterpreterRuntime::exception_handler_for_exception(JavaThread* thread, oopDesc* exception))
 393 

 394   Handle             h_exception(thread, exception);
 395   methodHandle       h_method   (thread, method(thread));
 396   constantPoolHandle h_constants(thread, h_method->constants());
 397   bool               should_repeat;
 398   int                handler_bci;
 399   int                current_bci = bci(thread);
 400 
 401   if (thread->frames_to_pop_failed_realloc() > 0) {
 402     // Allocation of scalar replaced object used in this frame
 403     // failed. Unconditionally pop the frame.
 404     thread->dec_frames_to_pop_failed_realloc();
 405     thread->set_vm_result(h_exception());
 406     // If the method is synchronized we already unlocked the monitor
 407     // during deoptimization so the interpreter needs to skip it when
 408     // the frame is popped.
 409     thread->set_do_not_unlock_if_synchronized(true);
 410 #ifdef CC_INTERP
 411     return (address) -1;
 412 #else
 413     return Interpreter::remove_activation_entry();
 414 #endif
 415   }
 416 
 417   // Need to do this check first since when _do_not_unlock_if_synchronized
 418   // is set, we don't want to trigger any classloading which may make calls
 419   // into java, or surprisingly find a matching exception handler for bci 0


 476         current_bci = handler_bci;
 477         should_repeat = true;
 478       }
 479     }
 480   } while (should_repeat == true);
 481 
 482 #if INCLUDE_JVMCI
 483   if (EnableJVMCI && h_method->method_data() != NULL) {
 484     ResourceMark rm(thread);
 485     ProfileData* pdata = h_method->method_data()->allocate_bci_to_data(current_bci, NULL);
 486     if (pdata != NULL && pdata->is_BitData()) {
 487       BitData* bit_data = (BitData*) pdata;
 488       bit_data->set_exception_seen();
 489     }
 490   }
 491 #endif
 492 
 493   // notify JVMTI of an exception throw; JVMTI will detect if this is a first
 494   // time throw or a stack unwinding throw and accordingly notify the debugger
 495   if (JvmtiExport::can_post_on_exceptions()) {
 496     JvmtiExport::post_exception_throw(thread, h_method(), bcp(thread), h_exception());
 497   }
 498 
 499 #ifdef CC_INTERP
 500   address continuation = (address)(intptr_t) handler_bci;
 501 #else
 502   address continuation = NULL;
 503 #endif
 504   address handler_pc = NULL;
 505   if (handler_bci < 0 || !thread->reguard_stack((address) &continuation)) {
 506     // Forward exception to callee (leaving bci/bcp untouched) because (a) no
 507     // handler in this method, or (b) after a stack overflow there is not yet
 508     // enough stack space available to reprotect the stack.
 509 #ifndef CC_INTERP
 510     continuation = Interpreter::remove_activation_entry();
 511 #endif
 512 #if COMPILER2_OR_JVMCI
 513     // Count this for compilation purposes
 514     h_method->interpreter_throwout_increment(THREAD);
 515 #endif
 516   } else {


 539 
 540 
 541 IRT_ENTRY(void, InterpreterRuntime::throw_AbstractMethodError(JavaThread* thread))
 542   THROW(vmSymbols::java_lang_AbstractMethodError());
 543 IRT_END
 544 
 545 
 546 IRT_ENTRY(void, InterpreterRuntime::throw_IncompatibleClassChangeError(JavaThread* thread))
 547   THROW(vmSymbols::java_lang_IncompatibleClassChangeError());
 548 IRT_END
 549 
 550 
 551 //------------------------------------------------------------------------------------------------------------------------
 552 // Fields
 553 //
 554 
 555 void InterpreterRuntime::resolve_get_put(JavaThread* thread, Bytecodes::Code bytecode) {
 556   Thread* THREAD = thread;
 557   // resolve field
 558   fieldDescriptor info;
 559   constantPoolHandle pool(thread, method(thread)->constants());
 560   methodHandle m(thread, method(thread));

 561   bool is_put    = (bytecode == Bytecodes::_putfield  || bytecode == Bytecodes::_nofast_putfield ||
 562                     bytecode == Bytecodes::_putstatic);
 563   bool is_static = (bytecode == Bytecodes::_getstatic || bytecode == Bytecodes::_putstatic);
 564 
 565   {
 566     JvmtiHideSingleStepping jhss(thread);
 567     LinkResolver::resolve_field_access(info, pool, get_index_u2_cpcache(thread, bytecode),
 568                                        m, bytecode, CHECK);
 569   } // end JvmtiHideSingleStepping
 570 
 571   // check if link resolution caused cpCache to be updated
 572   ConstantPoolCacheEntry* cp_cache_entry = cache_entry(thread);
 573   if (cp_cache_entry->is_resolved(bytecode)) return;
 574 
 575   // compute auxiliary field attributes
 576   TosState state  = as_TosState(info.field_type());
 577 
 578   // Resolution of put instructions on final fields is delayed. That is required so that
 579   // exceptions are thrown at the correct place (when the instruction is actually invoked).
 580   // If we do not resolve an instruction in the current pass, leaving the put_code
 581   // set to zero will cause the next put instruction to the same field to reresolve.
 582 
 583   // Resolution of put instructions to final instance fields with invalid updates (i.e.,
 584   // to final instance fields with updates originating from a method different than <init>)
 585   // is inhibited. A putfield instruction targeting an instance final field must throw
 586   // an IllegalAccessError if the instruction is not in an instance
 587   // initializer method <init>. If resolution were not inhibited, a putfield
 588   // in an initializer method could be resolved in the initializer. Subsequent
 589   // putfield instructions to the same field would then use cached information.
 590   // As a result, those instructions would not pass through the VM. That is,
 591   // checks in resolve_field_access() would not be executed for those instructions
 592   // and the required IllegalAccessError would not be thrown.


 701 IRT_END
 702 
 703 
 704 //------------------------------------------------------------------------------------------------------------------------
 705 // Invokes
 706 
 707 IRT_ENTRY(Bytecodes::Code, InterpreterRuntime::get_original_bytecode_at(JavaThread* thread, Method* method, address bcp))
 708   return method->orig_bytecode_at(method->bci_from(bcp));
 709 IRT_END
 710 
 711 IRT_ENTRY(void, InterpreterRuntime::set_original_bytecode_at(JavaThread* thread, Method* method, address bcp, Bytecodes::Code new_code))
 712   method->set_orig_bytecode_at(method->bci_from(bcp), new_code);
 713 IRT_END
 714 
 715 IRT_ENTRY(void, InterpreterRuntime::_breakpoint(JavaThread* thread, Method* method, address bcp))
 716   JvmtiExport::post_raw_breakpoint(thread, method, bcp);
 717 IRT_END
 718 
 719 void InterpreterRuntime::resolve_invoke(JavaThread* thread, Bytecodes::Code bytecode) {
 720   Thread* THREAD = thread;

 721   // extract receiver from the outgoing argument list if necessary
 722   Handle receiver(thread, NULL);
 723   if (bytecode == Bytecodes::_invokevirtual || bytecode == Bytecodes::_invokeinterface ||
 724       bytecode == Bytecodes::_invokespecial) {
 725     ResourceMark rm(thread);
 726     methodHandle m (thread, method(thread));
 727     Bytecode_invoke call(m, bci(thread));
 728     Symbol* signature = call.signature();
 729     receiver = Handle(thread,
 730                   thread->last_frame().interpreter_callee_receiver(signature));
 731     assert(Universe::heap()->is_in_reserved_or_null(receiver()),
 732            "sanity check");
 733     assert(receiver.is_null() ||
 734            !Universe::heap()->is_in_reserved(receiver->klass()),
 735            "sanity check");
 736   }
 737 
 738   // resolve method
 739   CallInfo info;
 740   constantPoolHandle pool(thread, method(thread)->constants());
 741 
 742   {
 743     JvmtiHideSingleStepping jhss(thread);
 744     LinkResolver::resolve_invoke(info, receiver, pool,
 745                                  get_index_u2_cpcache(thread, bytecode), bytecode,
 746                                  CHECK);
 747     if (JvmtiExport::can_hotswap_or_post_breakpoint()) {
 748       int retry_count = 0;
 749       while (info.resolved_method()->is_old()) {
 750         // It is very unlikely that method is redefined more than 100 times
 751         // in the middle of resolve. If it is looping here more than 100 times
 752         // means then there could be a bug here.
 753         guarantee((retry_count++ < 100),
 754                   "Could not resolve to latest version of redefined method");
 755         // method is redefined in the middle of resolve so re-try.
 756         LinkResolver::resolve_invoke(info, receiver, pool,
 757                                      get_index_u2_cpcache(thread, bytecode), bytecode,
 758                                      CHECK);
 759       }
 760     }
 761   } // end JvmtiHideSingleStepping
 762 
 763   // check if link resolution caused cpCache to be updated
 764   ConstantPoolCacheEntry* cp_cache_entry = cache_entry(thread);
 765   if (cp_cache_entry->is_resolved(bytecode)) return;
 766 
 767 #ifdef ASSERT
 768   if (bytecode == Bytecodes::_invokeinterface) {
 769     if (info.resolved_method()->method_holder() ==
 770                                             SystemDictionary::Object_klass()) {
 771       // NOTE: THIS IS A FIX FOR A CORNER CASE in the JVM spec
 772       // (see also CallInfo::set_interface for details)
 773       assert(info.call_kind() == CallInfo::vtable_call ||
 774              info.call_kind() == CallInfo::direct_call, "");
 775       methodHandle rm = info.resolved_method();
 776       assert(rm->is_final() || info.has_vtable_index(),
 777              "should have been set already");
 778     } else if (!info.resolved_method()->has_itable_index()) {
 779       // Resolved something like CharSequence.toString.  Use vtable not itable.
 780       assert(info.call_kind() != CallInfo::itable_call, "");
 781     } else {
 782       // Setup itable entry
 783       assert(info.call_kind() == CallInfo::itable_call, "");
 784       int index = info.resolved_method()->itable_index();


 808     cp_cache_entry->set_vtable_call(
 809       bytecode,
 810       info.resolved_method(),
 811       info.vtable_index());
 812     break;
 813   case CallInfo::itable_call:
 814     cp_cache_entry->set_itable_call(
 815       bytecode,
 816       info.resolved_method(),
 817       info.itable_index());
 818     break;
 819   default:  ShouldNotReachHere();
 820   }
 821 }
 822 
 823 
 824 // First time execution:  Resolve symbols, create a permanent MethodType object.
 825 void InterpreterRuntime::resolve_invokehandle(JavaThread* thread) {
 826   Thread* THREAD = thread;
 827   const Bytecodes::Code bytecode = Bytecodes::_invokehandle;

 828 
 829   // resolve method
 830   CallInfo info;
 831   constantPoolHandle pool(thread, method(thread)->constants());
 832   {
 833     JvmtiHideSingleStepping jhss(thread);
 834     LinkResolver::resolve_invoke(info, Handle(), pool,
 835                                  get_index_u2_cpcache(thread, bytecode), bytecode,
 836                                  CHECK);
 837   } // end JvmtiHideSingleStepping
 838 
 839   ConstantPoolCacheEntry* cp_cache_entry = cache_entry(thread);
 840   cp_cache_entry->set_method_handle(pool, info);
 841 }
 842 
 843 // First time execution:  Resolve symbols, create a permanent CallSite object.
 844 void InterpreterRuntime::resolve_invokedynamic(JavaThread* thread) {
 845   Thread* THREAD = thread;

 846   const Bytecodes::Code bytecode = Bytecodes::_invokedynamic;
 847 
 848   //TO DO: consider passing BCI to Java.
 849   //  int caller_bci = method(thread)->bci_from(bcp(thread));
 850 
 851   // resolve method
 852   CallInfo info;
 853   constantPoolHandle pool(thread, method(thread)->constants());
 854   int index = get_index_u4(thread, bytecode);
 855   {
 856     JvmtiHideSingleStepping jhss(thread);
 857     LinkResolver::resolve_invoke(info, Handle(), pool,
 858                                  index, bytecode, CHECK);
 859   } // end JvmtiHideSingleStepping
 860 
 861   ConstantPoolCacheEntry* cp_cache_entry = pool->invokedynamic_cp_cache_entry_at(index);
 862   cp_cache_entry->set_dynamic_call(pool, info);
 863 }
 864 
 865 // This function is the interface to the assembly code. It returns the resolved
 866 // cpCache entry.  This doesn't safepoint, but the helper routines safepoint.
 867 // This function will check for redefinition!
 868 IRT_ENTRY(void, InterpreterRuntime::resolve_from_cache(JavaThread* thread, Bytecodes::Code bytecode)) {
 869   switch (bytecode) {
 870   case Bytecodes::_getstatic:
 871   case Bytecodes::_putstatic:
 872   case Bytecodes::_getfield:
 873   case Bytecodes::_putfield:
 874     resolve_get_put(thread, bytecode);


 888   default:
 889     fatal("unexpected bytecode: %s", Bytecodes::name(bytecode));
 890     break;
 891   }
 892 }
 893 IRT_END
 894 
 895 //------------------------------------------------------------------------------------------------------------------------
 896 // Miscellaneous
 897 
 898 
 899 nmethod* InterpreterRuntime::frequency_counter_overflow(JavaThread* thread, address branch_bcp) {
 900   nmethod* nm = frequency_counter_overflow_inner(thread, branch_bcp);
 901   assert(branch_bcp != NULL || nm == NULL, "always returns null for non OSR requests");
 902   if (branch_bcp != NULL && nm != NULL) {
 903     // This was a successful request for an OSR nmethod.  Because
 904     // frequency_counter_overflow_inner ends with a safepoint check,
 905     // nm could have been unloaded so look it up again.  It's unsafe
 906     // to examine nm directly since it might have been freed and used
 907     // for something else.
 908     frame fr = thread->last_frame();
 909     Method* method =  fr.interpreter_frame_method();
 910     int bci = method->bci_from(fr.interpreter_frame_bcp());
 911     nm = method->lookup_osr_nmethod_for(bci, CompLevel_none, false);
 912   }
 913 #ifndef PRODUCT
 914   if (TraceOnStackReplacement) {
 915     if (nm != NULL) {
 916       tty->print("OSR entry @ pc: " INTPTR_FORMAT ": ", p2i(nm->osr_entry()));
 917       nm->print();
 918     }
 919   }
 920 #endif
 921   return nm;
 922 }
 923 
 924 IRT_ENTRY(nmethod*,
 925           InterpreterRuntime::frequency_counter_overflow_inner(JavaThread* thread, address branch_bcp))
 926   // use UnlockFlagSaver to clear and restore the _do_not_unlock_if_synchronized
 927   // flag, in case this method triggers classloading which will call into Java.
 928   UnlockFlagSaver fs(thread);
 929 
 930   frame fr = thread->last_frame();
 931   assert(fr.is_interpreted_frame(), "must come from interpreter");
 932   methodHandle method(thread, fr.interpreter_frame_method());
 933   const int branch_bci = branch_bcp != NULL ? method->bci_from(branch_bcp) : InvocationEntryBci;
 934   const int bci = branch_bcp != NULL ? method->bci_from(fr.interpreter_frame_bcp()) : InvocationEntryBci;
 935 
 936   assert(!HAS_PENDING_EXCEPTION, "Should not have any exceptions pending");
 937   nmethod* osr_nm = CompilationPolicy::policy()->event(method, method, branch_bci, bci, CompLevel_none, NULL, thread);
 938   assert(!HAS_PENDING_EXCEPTION, "Event handler should not throw any exceptions");
 939 
 940   if (osr_nm != NULL) {
 941     // We may need to do on-stack replacement which requires that no
 942     // monitors in the activation are biased because their
 943     // BasicObjectLocks will need to migrate during OSR. Force
 944     // unbiasing of all monitors in the activation now (even though
 945     // the OSR nmethod might be invalidated) because we don't have a
 946     // safepoint opportunity later once the migration begins.
 947     if (UseBiasedLocking) {
 948       ResourceMark rm;
 949       GrowableArray<Handle>* objects_to_revoke = new GrowableArray<Handle>();
 950       for( BasicObjectLock *kptr = fr.interpreter_frame_monitor_end();
 951            kptr < fr.interpreter_frame_monitor_begin();
 952            kptr = fr.next_monitor_in_interpreter_frame(kptr) ) {
 953         if( kptr->obj() != NULL ) {
 954           objects_to_revoke->append(Handle(THREAD, kptr->obj()));
 955         }
 956       }
 957       BiasedLocking::revoke(objects_to_revoke);
 958     }
 959   }
 960   return osr_nm;
 961 IRT_END
 962 
 963 IRT_LEAF(jint, InterpreterRuntime::bcp_to_di(Method* method, address cur_bcp))
 964   assert(ProfileInterpreter, "must be profiling interpreter");
 965   int bci = method->bci_from(cur_bcp);
 966   MethodData* mdo = method->method_data();
 967   if (mdo == NULL)  return 0;
 968   return mdo->bci_to_di(bci);
 969 IRT_END
 970 
 971 IRT_ENTRY(void, InterpreterRuntime::profile_method(JavaThread* thread))
 972   // use UnlockFlagSaver to clear and restore the _do_not_unlock_if_synchronized
 973   // flag, in case this method triggers classloading which will call into Java.
 974   UnlockFlagSaver fs(thread);
 975 
 976   assert(ProfileInterpreter, "must be profiling interpreter");
 977   frame fr = thread->last_frame();
 978   assert(fr.is_interpreted_frame(), "must come from interpreter");
 979   methodHandle method(thread, fr.interpreter_frame_method());
 980   Method::build_interpreter_method_data(method, THREAD);
 981   if (HAS_PENDING_EXCEPTION) {
 982     assert((PENDING_EXCEPTION->is_a(SystemDictionary::OutOfMemoryError_klass())), "we expect only an OOM error here");
 983     CLEAR_PENDING_EXCEPTION;
 984     // and fall through...
 985   }
 986 IRT_END
 987 
 988 
 989 #ifdef ASSERT
 990 IRT_LEAF(void, InterpreterRuntime::verify_mdp(Method* method, address bcp, address mdp))
 991   assert(ProfileInterpreter, "must be profiling interpreter");
 992 
 993   MethodData* mdo = method->method_data();
 994   assert(mdo != NULL, "must not be null");
 995 
 996   int bci = method->bci_from(bcp);
 997 
 998   address mdp2 = mdo->bci_to_dp(bci);
 999   if (mdp != mdp2) {


1004     int current_di = mdo->dp_to_di(mdp);
1005     int expected_di  = mdo->dp_to_di(mdp2);
1006     tty->print_cr("  actual di %d   expected di %d", current_di, expected_di);
1007     int expected_approx_bci = mdo->data_at(expected_di)->bci();
1008     int approx_bci = -1;
1009     if (current_di >= 0) {
1010       approx_bci = mdo->data_at(current_di)->bci();
1011     }
1012     tty->print_cr("  actual bci is %d  expected bci %d", approx_bci, expected_approx_bci);
1013     mdo->print_on(tty);
1014     method->print_codes();
1015   }
1016   assert(mdp == mdp2, "wrong mdp");
1017 IRT_END
1018 #endif // ASSERT
1019 
1020 IRT_ENTRY(void, InterpreterRuntime::update_mdp_for_ret(JavaThread* thread, int return_bci))
1021   assert(ProfileInterpreter, "must be profiling interpreter");
1022   ResourceMark rm(thread);
1023   HandleMark hm(thread);
1024   frame fr = thread->last_frame();
1025   assert(fr.is_interpreted_frame(), "must come from interpreter");
1026   MethodData* h_mdo = fr.interpreter_frame_method()->method_data();
1027 
1028   // Grab a lock to ensure atomic access to setting the return bci and
1029   // the displacement.  This can block and GC, invalidating all naked oops.
1030   MutexLocker ml(RetData_lock);
1031 
1032   // ProfileData is essentially a wrapper around a derived oop, so we
1033   // need to take the lock before making any ProfileData structures.
1034   ProfileData* data = h_mdo->data_at(h_mdo->dp_to_di(fr.interpreter_frame_mdp()));
1035   guarantee(data != NULL, "profile data must be valid");
1036   RetData* rdata = data->as_RetData();
1037   address new_mdp = rdata->fixup_ret(return_bci, h_mdo);
1038   fr.interpreter_frame_set_mdp(new_mdp);
1039 IRT_END
1040 
1041 IRT_ENTRY(MethodCounters*, InterpreterRuntime::build_method_counters(JavaThread* thread, Method* m))
1042   MethodCounters* mcs = Method::build_method_counters(m, thread);
1043   if (HAS_PENDING_EXCEPTION) {
1044     assert((PENDING_EXCEPTION->is_a(SystemDictionary::OutOfMemoryError_klass())), "we expect only an OOM error here");
1045     CLEAR_PENDING_EXCEPTION;
1046   }
1047   return mcs;
1048 IRT_END
1049 
1050 
1051 IRT_ENTRY(void, InterpreterRuntime::at_safepoint(JavaThread* thread))
1052   // We used to need an explict preserve_arguments here for invoke bytecodes. However,
1053   // stack traversal automatically takes care of preserving arguments for invoke, so
1054   // this is no longer needed.
1055 
1056   // IRT_END does an implicit safepoint check, hence we are guaranteed to block
1057   // if this is called during a safepoint
1058 
1059   if (JvmtiExport::should_post_single_step()) {
1060     // We are called during regular safepoints and when the VM is
1061     // single stepping. If any thread is marked for single stepping,
1062     // then we may have JVMTI work to do.
1063     JvmtiExport::at_single_stepping_point(thread, method(thread), bcp(thread));

1064   }
1065 IRT_END
1066 
1067 IRT_ENTRY(void, InterpreterRuntime::post_field_access(JavaThread *thread, oopDesc* obj,
1068 ConstantPoolCacheEntry *cp_entry))
1069 
1070   // check the access_flags for the field in the klass
1071 
1072   InstanceKlass* ik = InstanceKlass::cast(cp_entry->f1_as_klass());
1073   int index = cp_entry->field_index();
1074   if ((ik->field_access_flags(index) & JVM_ACC_FIELD_ACCESS_WATCHED) == 0) return;
1075 
1076   bool is_static = (obj == NULL);
1077   HandleMark hm(thread);
1078 
1079   Handle h_obj;
1080   if (!is_static) {
1081     // non-static field accessors have an object, but we need a handle
1082     h_obj = Handle(thread, obj);
1083   }
1084   InstanceKlass* cp_entry_f1 = InstanceKlass::cast(cp_entry->f1_as_klass());
1085   jfieldID fid = jfieldIDWorkaround::to_jfieldID(cp_entry_f1, cp_entry->f2_as_index(), is_static);
1086   JvmtiExport::post_field_access(thread, method(thread), bcp(thread), cp_entry_f1, h_obj, fid);

1087 IRT_END
1088 
1089 IRT_ENTRY(void, InterpreterRuntime::post_field_modification(JavaThread *thread,
1090   oopDesc* obj, ConstantPoolCacheEntry *cp_entry, jvalue *value))
1091 
1092   Klass* k = cp_entry->f1_as_klass();
1093 
1094   // check the access_flags for the field in the klass
1095   InstanceKlass* ik = InstanceKlass::cast(k);
1096   int index = cp_entry->field_index();
1097   // bail out if field modifications are not watched
1098   if ((ik->field_access_flags(index) & JVM_ACC_FIELD_MODIFICATION_WATCHED) == 0) return;
1099 
1100   char sig_type = '\0';
1101 
1102   switch(cp_entry->flag_state()) {
1103     case btos: sig_type = 'B'; break;
1104     case ztos: sig_type = 'Z'; break;
1105     case ctos: sig_type = 'C'; break;
1106     case stos: sig_type = 'S'; break;


1121 #else
1122   // Long/double values are stored unaligned and also noncontiguously with
1123   // tagged stacks.  We can't just do a simple assignment even in the non-
1124   // J/D cases because a C++ compiler is allowed to assume that a jvalue is
1125   // 8-byte aligned, and interpreter stack slots are only 4-byte aligned.
1126   // We assume that the two halves of longs/doubles are stored in interpreter
1127   // stack slots in platform-endian order.
1128   jlong_accessor u;
1129   jint* newval = (jint*)value;
1130   u.words[0] = newval[0];
1131   u.words[1] = newval[Interpreter::stackElementWords]; // skip if tag
1132   fvalue.j = u.long_value;
1133 #endif // _LP64
1134 
1135   Handle h_obj;
1136   if (!is_static) {
1137     // non-static field accessors have an object, but we need a handle
1138     h_obj = Handle(thread, obj);
1139   }
1140 
1141   JvmtiExport::post_raw_field_modification(thread, method(thread), bcp(thread), ik, h_obj,

1142                                            fid, sig_type, &fvalue);
1143 IRT_END
1144 
1145 IRT_ENTRY(void, InterpreterRuntime::post_method_entry(JavaThread *thread))
1146   JvmtiExport::post_method_entry(thread, InterpreterRuntime::method(thread), InterpreterRuntime::last_frame(thread));

1147 IRT_END
1148 
1149 
1150 IRT_ENTRY(void, InterpreterRuntime::post_method_exit(JavaThread *thread))
1151   JvmtiExport::post_method_exit(thread, InterpreterRuntime::method(thread), InterpreterRuntime::last_frame(thread));

1152 IRT_END
1153 
1154 IRT_LEAF(int, InterpreterRuntime::interpreter_contains(address pc))
1155 {
1156   return (Interpreter::contains(pc) ? 1 : 0);
1157 }
1158 IRT_END
1159 
1160 
1161 // Implementation of SignatureHandlerLibrary
1162 
1163 #ifndef SHARING_FAST_NATIVE_FINGERPRINTS
1164 // Dummy definition (else normalization method is defined in CPU
1165 // dependant code)
1166 uint64_t InterpreterRuntime::normalize_fast_native_fingerprint(uint64_t fingerprint) {
1167   return fingerprint;
1168 }
1169 #endif
1170 
1171 address SignatureHandlerLibrary::set_handler_blob() {


1355   bool in_base_library;
1356   if (!m->has_native_function()) {
1357     NativeLookup::lookup(m, in_base_library, CHECK);
1358   }
1359   // make sure signature handler is installed
1360   SignatureHandlerLibrary::add(m);
1361   // The interpreter entry point checks the signature handler first,
1362   // before trying to fetch the native entry point and klass mirror.
1363   // We must set the signature handler last, so that multiple processors
1364   // preparing the same method will be sure to see non-null entry & mirror.
1365 IRT_END
1366 
1367 #if defined(IA32) || defined(AMD64) || defined(ARM)
1368 IRT_LEAF(void, InterpreterRuntime::popframe_move_outgoing_args(JavaThread* thread, void* src_address, void* dest_address))
1369   if (src_address == dest_address) {
1370     return;
1371   }
1372   ResetNoHandleMark rnm; // In a LEAF entry.
1373   HandleMark hm;
1374   ResourceMark rm;
1375   frame fr = thread->last_frame();
1376   assert(fr.is_interpreted_frame(), "");
1377   jint bci = fr.interpreter_frame_bci();
1378   methodHandle mh(thread, fr.interpreter_frame_method());
1379   Bytecode_invoke invoke(mh, bci);
1380   ArgumentSizeComputer asc(invoke.signature());
1381   int size_of_arguments = (asc.size() + (invoke.has_receiver() ? 1 : 0)); // receiver
1382   Copy::conjoint_jbytes(src_address, dest_address,
1383                        size_of_arguments * Interpreter::stackElementSize);
1384 IRT_END
1385 #endif
1386 
1387 #if INCLUDE_JVMTI
1388 // This is a support of the JVMTI PopFrame interface.
1389 // Make sure it is an invokestatic of a polymorphic intrinsic that has a member_name argument
1390 // and return it as a vm_result so that it can be reloaded in the list of invokestatic parameters.
1391 // The member_name argument is a saved reference (in local#0) to the member_name.
1392 // For backward compatibility with some JDK versions (7, 8) it can also be a direct method handle.
1393 // FIXME: remove DMH case after j.l.i.InvokerBytecodeGenerator code shape is updated.
1394 IRT_ENTRY(void, InterpreterRuntime::member_name_arg_or_null(JavaThread* thread, address member_name,
1395                                                             Method* method, address bcp))
1396   Bytecodes::Code code = Bytecodes::code_at(method, bcp);
1397   if (code != Bytecodes::_invokestatic) {
1398     return;


1404 
1405   if (MethodHandles::has_member_arg(cname, mname)) {
1406     oop member_name_oop = (oop) member_name;
1407     if (java_lang_invoke_DirectMethodHandle::is_instance(member_name_oop)) {
1408       // FIXME: remove after j.l.i.InvokerBytecodeGenerator code shape is updated.
1409       member_name_oop = java_lang_invoke_DirectMethodHandle::member(member_name_oop);
1410     }
1411     thread->set_vm_result(member_name_oop);
1412   } else {
1413     thread->set_vm_result(NULL);
1414   }
1415 IRT_END
1416 #endif // INCLUDE_JVMTI
1417 
1418 #ifndef PRODUCT
1419 // This must be a IRT_LEAF function because the interpreter must save registers on x86 to
1420 // call this, which changes rsp and makes the interpreter's expression stack not walkable.
1421 // The generated code still uses call_VM because that will set up the frame pointer for
1422 // bcp and method.
1423 IRT_LEAF(intptr_t, InterpreterRuntime::trace_bytecode(JavaThread* thread, intptr_t preserve_this_value, intptr_t tos, intptr_t tos2))
1424   const frame f = thread->last_frame();
1425   assert(f.is_interpreted_frame(), "must be an interpreted frame");
1426   methodHandle mh(thread, f.interpreter_frame_method());
1427   BytecodeTracer::trace(mh, f.interpreter_frame_bcp(), tos, tos2);
1428   return preserve_this_value;
1429 IRT_END
1430 #endif // !PRODUCT


  70 
  71 class UnlockFlagSaver {
  72   private:
  73     JavaThread* _thread;
  74     bool _do_not_unlock;
  75   public:
  76     UnlockFlagSaver(JavaThread* t) {
  77       _thread = t;
  78       _do_not_unlock = t->do_not_unlock_if_synchronized();
  79       t->set_do_not_unlock_if_synchronized(false);
  80     }
  81     ~UnlockFlagSaver() {
  82       _thread->set_do_not_unlock_if_synchronized(_do_not_unlock);
  83     }
  84 };
  85 
  86 //------------------------------------------------------------------------------------------------------------------------
  87 // State accessors
  88 
  89 void InterpreterRuntime::set_bcp_and_mdp(address bcp, JavaThread *thread) {
  90   LastFrameAccessor last_frame(thread);
  91   last_frame.set_bcp(bcp);
  92   if (ProfileInterpreter) {
  93     // ProfileTraps uses MDOs independently of ProfileInterpreter.
  94     // That is why we must check both ProfileInterpreter and mdo != NULL.
  95     MethodData* mdo = last_frame.method()->method_data();
  96     if (mdo != NULL) {
  97       NEEDS_CLEANUP;
  98       last_frame.set_mdp(mdo->bci_to_dp(last_frame.bci()));
  99     }
 100   }
 101 }
 102 
 103 //------------------------------------------------------------------------------------------------------------------------
 104 // Constants
 105 
 106 
 107 IRT_ENTRY(void, InterpreterRuntime::ldc(JavaThread* thread, bool wide))
 108   // access constant pool
 109   LastFrameAccessor last_frame(thread);
 110   ConstantPool* pool = last_frame.method()->constants();
 111   int index = wide ? last_frame.get_index_u2(Bytecodes::_ldc_w) : last_frame.get_index_u1(Bytecodes::_ldc);
 112   constantTag tag = pool->tag_at(index);
 113 
 114   assert (tag.is_unresolved_klass() || tag.is_klass(), "wrong ldc call");
 115   Klass* klass = pool->klass_at(index, CHECK);
 116     oop java_class = klass->java_mirror();
 117     thread->set_vm_result(java_class);
 118 IRT_END
 119 
 120 IRT_ENTRY(void, InterpreterRuntime::resolve_ldc(JavaThread* thread, Bytecodes::Code bytecode)) {
 121   assert(bytecode == Bytecodes::_fast_aldc ||
 122          bytecode == Bytecodes::_fast_aldc_w, "wrong bc");
 123   ResourceMark rm(thread);
 124   LastFrameAccessor last_frame(thread);
 125   methodHandle m (thread, last_frame.method());
 126   Bytecode_loadconstant ldc(m, last_frame.bci());
 127   oop result = ldc.resolve_constant(CHECK);
 128 #ifdef ASSERT
 129   {
 130     // The bytecode wrappers aren't GC-safe so construct a new one
 131     Bytecode_loadconstant ldc2(m, last_frame.bci());
 132     oop coop = m->constants()->resolved_references()->obj_at(ldc2.cache_index());
 133     assert(result == coop, "expected result for assembly code");
 134   }
 135 #endif
 136   thread->set_vm_result(result);
 137 }
 138 IRT_END
 139 
 140 
 141 //------------------------------------------------------------------------------------------------------------------------
 142 // Allocation
 143 
 144 IRT_ENTRY(void, InterpreterRuntime::_new(JavaThread* thread, ConstantPool* pool, int index))
 145   Klass* k = pool->klass_at(index, CHECK);
 146   InstanceKlass* klass = InstanceKlass::cast(k);
 147 
 148   // Make sure we are not instantiating an abstract klass
 149   klass->check_valid_for_instantiation(true, CHECK);
 150 
 151   // Make sure klass is initialized


 168   oop obj = klass->allocate_instance(CHECK);
 169   thread->set_vm_result(obj);
 170 IRT_END
 171 
 172 
 173 IRT_ENTRY(void, InterpreterRuntime::newarray(JavaThread* thread, BasicType type, jint size))
 174   oop obj = oopFactory::new_typeArray(type, size, CHECK);
 175   thread->set_vm_result(obj);
 176 IRT_END
 177 
 178 
 179 IRT_ENTRY(void, InterpreterRuntime::anewarray(JavaThread* thread, ConstantPool* pool, int index, jint size))
 180   Klass*    klass = pool->klass_at(index, CHECK);
 181   objArrayOop obj = oopFactory::new_objArray(klass, size, CHECK);
 182   thread->set_vm_result(obj);
 183 IRT_END
 184 
 185 
 186 IRT_ENTRY(void, InterpreterRuntime::multianewarray(JavaThread* thread, jint* first_size_address))
 187   // We may want to pass in more arguments - could make this slightly faster
 188   LastFrameAccessor last_frame(thread);
 189   ConstantPool* constants = last_frame.method()->constants();
 190   int          i = last_frame.get_index_u2(Bytecodes::_multianewarray);
 191   Klass* klass   = constants->klass_at(i, CHECK);
 192   int   nof_dims = last_frame.number_of_dimensions();
 193   assert(klass->is_klass(), "not a class");
 194   assert(nof_dims >= 1, "multianewarray rank must be nonzero");
 195 
 196   // We must create an array of jints to pass to multi_allocate.
 197   ResourceMark rm(thread);
 198   const int small_dims = 10;
 199   jint dim_array[small_dims];
 200   jint *dims = &dim_array[0];
 201   if (nof_dims > small_dims) {
 202     dims = (jint*) NEW_RESOURCE_ARRAY(jint, nof_dims);
 203   }
 204   for (int index = 0; index < nof_dims; index++) {
 205     // offset from first_size_address is addressed as local[index]
 206     int n = Interpreter::local_offset_in_bytes(index)/jintSize;
 207     dims[index] = first_size_address[n];
 208   }
 209   oop obj = ArrayKlass::cast(klass)->multi_allocate(nof_dims, dims, CHECK);
 210   thread->set_vm_result(obj);
 211 IRT_END
 212 
 213 
 214 IRT_ENTRY(void, InterpreterRuntime::register_finalizer(JavaThread* thread, oopDesc* obj))
 215   assert(oopDesc::is_oop(obj), "must be a valid oop");
 216   assert(obj->klass()->has_finalizer(), "shouldn't be here otherwise");
 217   InstanceKlass::register_finalizer(instanceOop(obj), CHECK);
 218 IRT_END
 219 
 220 
 221 // Quicken instance-of and check-cast bytecodes
 222 IRT_ENTRY(void, InterpreterRuntime::quicken_io_cc(JavaThread* thread))
 223   // Force resolving; quicken the bytecode
 224   LastFrameAccessor last_frame(thread);
 225   int which = last_frame.get_index_u2(Bytecodes::_checkcast);
 226   ConstantPool* cpool = last_frame.method()->constants();
 227   // We'd expect to assert that we're only here to quicken bytecodes, but in a multithreaded
 228   // program we might have seen an unquick'd bytecode in the interpreter but have another
 229   // thread quicken the bytecode before we get here.
 230   // assert( cpool->tag_at(which).is_unresolved_klass(), "should only come here to quicken bytecodes" );
 231   Klass* klass = cpool->klass_at(which, CHECK);
 232   thread->set_vm_result_2(klass);
 233 IRT_END
 234 
 235 
 236 //------------------------------------------------------------------------------------------------------------------------
 237 // Exceptions
 238 
 239 void InterpreterRuntime::note_trap_inner(JavaThread* thread, int reason,
 240                                          const methodHandle& trap_method, int trap_bci, TRAPS) {
 241   if (trap_method.not_null()) {
 242     MethodData* trap_mdo = trap_method->method_data();
 243     if (trap_mdo == NULL) {
 244       Method::build_interpreter_method_data(trap_method, THREAD);
 245       if (HAS_PENDING_EXCEPTION) {
 246         assert((PENDING_EXCEPTION->is_a(SystemDictionary::OutOfMemoryError_klass())),
 247                "we expect only an OOM error here");
 248         CLEAR_PENDING_EXCEPTION;
 249       }
 250       trap_mdo = trap_method->method_data();
 251       // and fall through...
 252     }
 253     if (trap_mdo != NULL) {
 254       // Update per-method count of trap events.  The interpreter
 255       // is updating the MDO to simulate the effect of compiler traps.
 256       Deoptimization::update_method_data_from_interpreter(trap_mdo, trap_bci, reason);
 257     }
 258   }
 259 }
 260 
 261 // Assume the compiler is (or will be) interested in this event.
 262 // If necessary, create an MDO to hold the information, and record it.
 263 void InterpreterRuntime::note_trap(JavaThread* thread, int reason, TRAPS) {
 264   assert(ProfileTraps, "call me only if profiling");
 265   LastFrameAccessor last_frame(thread);
 266   methodHandle trap_method(thread, last_frame.method());
 267   int trap_bci = trap_method->bci_from(last_frame.bcp());
 268   note_trap_inner(thread, reason, trap_method, trap_bci, THREAD);
 269 }
 270 
 271 #ifdef CC_INTERP
 272 // As legacy note_trap, but we have more arguments.
 273 IRT_ENTRY(void, InterpreterRuntime::note_trap(JavaThread* thread, int reason, Method *method, int trap_bci))
 274   methodHandle trap_method(method);
 275   note_trap_inner(thread, reason, trap_method, trap_bci, THREAD);
 276 IRT_END
 277 
 278 // Class Deoptimization is not visible in BytecodeInterpreter, so we need a wrapper
 279 // for each exception.
 280 void InterpreterRuntime::note_nullCheck_trap(JavaThread* thread, Method *method, int trap_bci)
 281   { if (ProfileTraps) note_trap(thread, Deoptimization::Reason_null_check, method, trap_bci); }
 282 void InterpreterRuntime::note_div0Check_trap(JavaThread* thread, Method *method, int trap_bci)
 283   { if (ProfileTraps) note_trap(thread, Deoptimization::Reason_div0_check, method, trap_bci); }
 284 void InterpreterRuntime::note_rangeCheck_trap(JavaThread* thread, Method *method, int trap_bci)
 285   { if (ProfileTraps) note_trap(thread, Deoptimization::Reason_range_check, method, trap_bci); }
 286 void InterpreterRuntime::note_classCheck_trap(JavaThread* thread, Method *method, int trap_bci)
 287   { if (ProfileTraps) note_trap(thread, Deoptimization::Reason_class_check, method, trap_bci); }


 380     thread, obj->klass());
 381 
 382   if (ProfileTraps) {
 383     note_trap(thread, Deoptimization::Reason_class_check, CHECK);
 384   }
 385 
 386   // create exception
 387   THROW_MSG(vmSymbols::java_lang_ClassCastException(), message);
 388 IRT_END
 389 
 390 // exception_handler_for_exception(...) returns the continuation address,
 391 // the exception oop (via TLS) and sets the bci/bcp for the continuation.
 392 // The exception oop is returned to make sure it is preserved over GC (it
 393 // is only on the stack if the exception was thrown explicitly via athrow).
 394 // During this operation, the expression stack contains the values for the
 395 // bci where the exception happened. If the exception was propagated back
 396 // from a call, the expression stack contains the values for the bci at the
 397 // invoke w/o arguments (i.e., as if one were inside the call).
 398 IRT_ENTRY(address, InterpreterRuntime::exception_handler_for_exception(JavaThread* thread, oopDesc* exception))
 399 
 400   LastFrameAccessor last_frame(thread);
 401   Handle             h_exception(thread, exception);
 402   methodHandle       h_method   (thread, last_frame.method());
 403   constantPoolHandle h_constants(thread, h_method->constants());
 404   bool               should_repeat;
 405   int                handler_bci;
 406   int                current_bci = last_frame.bci();
 407 
 408   if (thread->frames_to_pop_failed_realloc() > 0) {
 409     // Allocation of scalar replaced object used in this frame
 410     // failed. Unconditionally pop the frame.
 411     thread->dec_frames_to_pop_failed_realloc();
 412     thread->set_vm_result(h_exception());
 413     // If the method is synchronized we already unlocked the monitor
 414     // during deoptimization so the interpreter needs to skip it when
 415     // the frame is popped.
 416     thread->set_do_not_unlock_if_synchronized(true);
 417 #ifdef CC_INTERP
 418     return (address) -1;
 419 #else
 420     return Interpreter::remove_activation_entry();
 421 #endif
 422   }
 423 
 424   // Need to do this check first since when _do_not_unlock_if_synchronized
 425   // is set, we don't want to trigger any classloading which may make calls
 426   // into java, or surprisingly find a matching exception handler for bci 0


 483         current_bci = handler_bci;
 484         should_repeat = true;
 485       }
 486     }
 487   } while (should_repeat == true);
 488 
 489 #if INCLUDE_JVMCI
 490   if (EnableJVMCI && h_method->method_data() != NULL) {
 491     ResourceMark rm(thread);
 492     ProfileData* pdata = h_method->method_data()->allocate_bci_to_data(current_bci, NULL);
 493     if (pdata != NULL && pdata->is_BitData()) {
 494       BitData* bit_data = (BitData*) pdata;
 495       bit_data->set_exception_seen();
 496     }
 497   }
 498 #endif
 499 
 500   // notify JVMTI of an exception throw; JVMTI will detect if this is a first
 501   // time throw or a stack unwinding throw and accordingly notify the debugger
 502   if (JvmtiExport::can_post_on_exceptions()) {
 503     JvmtiExport::post_exception_throw(thread, h_method(), last_frame.bcp(), h_exception());
 504   }
 505 
 506 #ifdef CC_INTERP
 507   address continuation = (address)(intptr_t) handler_bci;
 508 #else
 509   address continuation = NULL;
 510 #endif
 511   address handler_pc = NULL;
 512   if (handler_bci < 0 || !thread->reguard_stack((address) &continuation)) {
 513     // Forward exception to callee (leaving bci/bcp untouched) because (a) no
 514     // handler in this method, or (b) after a stack overflow there is not yet
 515     // enough stack space available to reprotect the stack.
 516 #ifndef CC_INTERP
 517     continuation = Interpreter::remove_activation_entry();
 518 #endif
 519 #if COMPILER2_OR_JVMCI
 520     // Count this for compilation purposes
 521     h_method->interpreter_throwout_increment(THREAD);
 522 #endif
 523   } else {


 546 
 547 
 548 IRT_ENTRY(void, InterpreterRuntime::throw_AbstractMethodError(JavaThread* thread))
 549   THROW(vmSymbols::java_lang_AbstractMethodError());
 550 IRT_END
 551 
 552 
 553 IRT_ENTRY(void, InterpreterRuntime::throw_IncompatibleClassChangeError(JavaThread* thread))
 554   THROW(vmSymbols::java_lang_IncompatibleClassChangeError());
 555 IRT_END
 556 
 557 
 558 //------------------------------------------------------------------------------------------------------------------------
 559 // Fields
 560 //
 561 
 562 void InterpreterRuntime::resolve_get_put(JavaThread* thread, Bytecodes::Code bytecode) {
 563   Thread* THREAD = thread;
 564   // resolve field
 565   fieldDescriptor info;
 566   LastFrameAccessor last_frame(thread);
 567   constantPoolHandle pool(thread, last_frame.method()->constants());
 568   methodHandle m(thread, last_frame.method());
 569   bool is_put    = (bytecode == Bytecodes::_putfield  || bytecode == Bytecodes::_nofast_putfield ||
 570                     bytecode == Bytecodes::_putstatic);
 571   bool is_static = (bytecode == Bytecodes::_getstatic || bytecode == Bytecodes::_putstatic);
 572 
 573   {
 574     JvmtiHideSingleStepping jhss(thread);
 575     LinkResolver::resolve_field_access(info, pool, last_frame.get_index_u2_cpcache(bytecode),
 576                                        m, bytecode, CHECK);
 577   } // end JvmtiHideSingleStepping
 578 
 579   // check if link resolution caused cpCache to be updated
 580   ConstantPoolCacheEntry* cp_cache_entry = last_frame.cache_entry();
 581   if (cp_cache_entry->is_resolved(bytecode)) return;
 582 
 583   // compute auxiliary field attributes
 584   TosState state  = as_TosState(info.field_type());
 585 
 586   // Resolution of put instructions on final fields is delayed. That is required so that
 587   // exceptions are thrown at the correct place (when the instruction is actually invoked).
 588   // If we do not resolve an instruction in the current pass, leaving the put_code
 589   // set to zero will cause the next put instruction to the same field to reresolve.
 590 
 591   // Resolution of put instructions to final instance fields with invalid updates (i.e.,
 592   // to final instance fields with updates originating from a method different than <init>)
 593   // is inhibited. A putfield instruction targeting an instance final field must throw
 594   // an IllegalAccessError if the instruction is not in an instance
 595   // initializer method <init>. If resolution were not inhibited, a putfield
 596   // in an initializer method could be resolved in the initializer. Subsequent
 597   // putfield instructions to the same field would then use cached information.
 598   // As a result, those instructions would not pass through the VM. That is,
 599   // checks in resolve_field_access() would not be executed for those instructions
 600   // and the required IllegalAccessError would not be thrown.


 709 IRT_END
 710 
 711 
 712 //------------------------------------------------------------------------------------------------------------------------
 713 // Invokes
 714 
 715 IRT_ENTRY(Bytecodes::Code, InterpreterRuntime::get_original_bytecode_at(JavaThread* thread, Method* method, address bcp))
 716   return method->orig_bytecode_at(method->bci_from(bcp));
 717 IRT_END
 718 
 719 IRT_ENTRY(void, InterpreterRuntime::set_original_bytecode_at(JavaThread* thread, Method* method, address bcp, Bytecodes::Code new_code))
 720   method->set_orig_bytecode_at(method->bci_from(bcp), new_code);
 721 IRT_END
 722 
 723 IRT_ENTRY(void, InterpreterRuntime::_breakpoint(JavaThread* thread, Method* method, address bcp))
 724   JvmtiExport::post_raw_breakpoint(thread, method, bcp);
 725 IRT_END
 726 
 727 void InterpreterRuntime::resolve_invoke(JavaThread* thread, Bytecodes::Code bytecode) {
 728   Thread* THREAD = thread;
 729   LastFrameAccessor last_frame(thread);
 730   // extract receiver from the outgoing argument list if necessary
 731   Handle receiver(thread, NULL);
 732   if (bytecode == Bytecodes::_invokevirtual || bytecode == Bytecodes::_invokeinterface ||
 733       bytecode == Bytecodes::_invokespecial) {
 734     ResourceMark rm(thread);
 735     methodHandle m (thread, last_frame.method());
 736     Bytecode_invoke call(m, last_frame.bci());
 737     Symbol* signature = call.signature();
 738     receiver = Handle(thread, last_frame.callee_receiver(signature));
 739 
 740     assert(Universe::heap()->is_in_reserved_or_null(receiver()),
 741            "sanity check");
 742     assert(receiver.is_null() ||
 743            !Universe::heap()->is_in_reserved(receiver->klass()),
 744            "sanity check");
 745   }
 746 
 747   // resolve method
 748   CallInfo info;
 749   constantPoolHandle pool(thread, last_frame.method()->constants());
 750 
 751   {
 752     JvmtiHideSingleStepping jhss(thread);
 753     LinkResolver::resolve_invoke(info, receiver, pool,
 754                                  last_frame.get_index_u2_cpcache(bytecode), bytecode,
 755                                  CHECK);
 756     if (JvmtiExport::can_hotswap_or_post_breakpoint()) {
 757       int retry_count = 0;
 758       while (info.resolved_method()->is_old()) {
 759         // It is very unlikely that method is redefined more than 100 times
 760         // in the middle of resolve. If it is looping here more than 100 times
 761         // means then there could be a bug here.
 762         guarantee((retry_count++ < 100),
 763                   "Could not resolve to latest version of redefined method");
 764         // method is redefined in the middle of resolve so re-try.
 765         LinkResolver::resolve_invoke(info, receiver, pool,
 766                                      last_frame.get_index_u2_cpcache(bytecode), bytecode,
 767                                      CHECK);
 768       }
 769     }
 770   } // end JvmtiHideSingleStepping
 771 
 772   // check if link resolution caused cpCache to be updated
 773   ConstantPoolCacheEntry* cp_cache_entry = last_frame.cache_entry();
 774   if (cp_cache_entry->is_resolved(bytecode)) return;
 775 
 776 #ifdef ASSERT
 777   if (bytecode == Bytecodes::_invokeinterface) {
 778     if (info.resolved_method()->method_holder() ==
 779                                             SystemDictionary::Object_klass()) {
 780       // NOTE: THIS IS A FIX FOR A CORNER CASE in the JVM spec
 781       // (see also CallInfo::set_interface for details)
 782       assert(info.call_kind() == CallInfo::vtable_call ||
 783              info.call_kind() == CallInfo::direct_call, "");
 784       methodHandle rm = info.resolved_method();
 785       assert(rm->is_final() || info.has_vtable_index(),
 786              "should have been set already");
 787     } else if (!info.resolved_method()->has_itable_index()) {
 788       // Resolved something like CharSequence.toString.  Use vtable not itable.
 789       assert(info.call_kind() != CallInfo::itable_call, "");
 790     } else {
 791       // Setup itable entry
 792       assert(info.call_kind() == CallInfo::itable_call, "");
 793       int index = info.resolved_method()->itable_index();


 817     cp_cache_entry->set_vtable_call(
 818       bytecode,
 819       info.resolved_method(),
 820       info.vtable_index());
 821     break;
 822   case CallInfo::itable_call:
 823     cp_cache_entry->set_itable_call(
 824       bytecode,
 825       info.resolved_method(),
 826       info.itable_index());
 827     break;
 828   default:  ShouldNotReachHere();
 829   }
 830 }
 831 
 832 
 833 // First time execution:  Resolve symbols, create a permanent MethodType object.
 834 void InterpreterRuntime::resolve_invokehandle(JavaThread* thread) {
 835   Thread* THREAD = thread;
 836   const Bytecodes::Code bytecode = Bytecodes::_invokehandle;
 837   LastFrameAccessor last_frame(thread);
 838 
 839   // resolve method
 840   CallInfo info;
 841   constantPoolHandle pool(thread, last_frame.method()->constants());
 842   {
 843     JvmtiHideSingleStepping jhss(thread);
 844     LinkResolver::resolve_invoke(info, Handle(), pool,
 845                                  last_frame.get_index_u2_cpcache(bytecode), bytecode,
 846                                  CHECK);
 847   } // end JvmtiHideSingleStepping
 848 
 849   ConstantPoolCacheEntry* cp_cache_entry = last_frame.cache_entry();
 850   cp_cache_entry->set_method_handle(pool, info);
 851 }
 852 
 853 // First time execution:  Resolve symbols, create a permanent CallSite object.
 854 void InterpreterRuntime::resolve_invokedynamic(JavaThread* thread) {
 855   Thread* THREAD = thread;
 856   LastFrameAccessor last_frame(thread);
 857   const Bytecodes::Code bytecode = Bytecodes::_invokedynamic;
 858 
 859   //TO DO: consider passing BCI to Java.
 860   //  int caller_bci = last_frame.method()->bci_from(last_frame.bcp());
 861 
 862   // resolve method
 863   CallInfo info;
 864   constantPoolHandle pool(thread, last_frame.method()->constants());
 865   int index = last_frame.get_index_u4(bytecode);
 866   {
 867     JvmtiHideSingleStepping jhss(thread);
 868     LinkResolver::resolve_invoke(info, Handle(), pool,
 869                                  index, bytecode, CHECK);
 870   } // end JvmtiHideSingleStepping
 871 
 872   ConstantPoolCacheEntry* cp_cache_entry = pool->invokedynamic_cp_cache_entry_at(index);
 873   cp_cache_entry->set_dynamic_call(pool, info);
 874 }
 875 
 876 // This function is the interface to the assembly code. It returns the resolved
 877 // cpCache entry.  This doesn't safepoint, but the helper routines safepoint.
 878 // This function will check for redefinition!
 879 IRT_ENTRY(void, InterpreterRuntime::resolve_from_cache(JavaThread* thread, Bytecodes::Code bytecode)) {
 880   switch (bytecode) {
 881   case Bytecodes::_getstatic:
 882   case Bytecodes::_putstatic:
 883   case Bytecodes::_getfield:
 884   case Bytecodes::_putfield:
 885     resolve_get_put(thread, bytecode);


 899   default:
 900     fatal("unexpected bytecode: %s", Bytecodes::name(bytecode));
 901     break;
 902   }
 903 }
 904 IRT_END
 905 
 906 //------------------------------------------------------------------------------------------------------------------------
 907 // Miscellaneous
 908 
 909 
 910 nmethod* InterpreterRuntime::frequency_counter_overflow(JavaThread* thread, address branch_bcp) {
 911   nmethod* nm = frequency_counter_overflow_inner(thread, branch_bcp);
 912   assert(branch_bcp != NULL || nm == NULL, "always returns null for non OSR requests");
 913   if (branch_bcp != NULL && nm != NULL) {
 914     // This was a successful request for an OSR nmethod.  Because
 915     // frequency_counter_overflow_inner ends with a safepoint check,
 916     // nm could have been unloaded so look it up again.  It's unsafe
 917     // to examine nm directly since it might have been freed and used
 918     // for something else.
 919     LastFrameAccessor last_frame(thread);
 920     Method* method =  last_frame.method();
 921     int bci = method->bci_from(last_frame.bcp());
 922     nm = method->lookup_osr_nmethod_for(bci, CompLevel_none, false);
 923   }
 924 #ifndef PRODUCT
 925   if (TraceOnStackReplacement) {
 926     if (nm != NULL) {
 927       tty->print("OSR entry @ pc: " INTPTR_FORMAT ": ", p2i(nm->osr_entry()));
 928       nm->print();
 929     }
 930   }
 931 #endif
 932   return nm;
 933 }
 934 
 935 IRT_ENTRY(nmethod*,
 936           InterpreterRuntime::frequency_counter_overflow_inner(JavaThread* thread, address branch_bcp))
 937   // use UnlockFlagSaver to clear and restore the _do_not_unlock_if_synchronized
 938   // flag, in case this method triggers classloading which will call into Java.
 939   UnlockFlagSaver fs(thread);
 940 
 941   LastFrameAccessor last_frame(thread);
 942   assert(last_frame.is_interpreted_frame(), "must come from interpreter");
 943   methodHandle method(thread, last_frame.method());
 944   const int branch_bci = branch_bcp != NULL ? method->bci_from(branch_bcp) : InvocationEntryBci;
 945   const int bci = branch_bcp != NULL ? method->bci_from(last_frame.bcp()) : InvocationEntryBci;
 946 
 947   assert(!HAS_PENDING_EXCEPTION, "Should not have any exceptions pending");
 948   nmethod* osr_nm = CompilationPolicy::policy()->event(method, method, branch_bci, bci, CompLevel_none, NULL, thread);
 949   assert(!HAS_PENDING_EXCEPTION, "Event handler should not throw any exceptions");
 950 
 951   if (osr_nm != NULL) {
 952     // We may need to do on-stack replacement which requires that no
 953     // monitors in the activation are biased because their
 954     // BasicObjectLocks will need to migrate during OSR. Force
 955     // unbiasing of all monitors in the activation now (even though
 956     // the OSR nmethod might be invalidated) because we don't have a
 957     // safepoint opportunity later once the migration begins.
 958     if (UseBiasedLocking) {
 959       ResourceMark rm;
 960       GrowableArray<Handle>* objects_to_revoke = new GrowableArray<Handle>();
 961       for( BasicObjectLock *kptr = last_frame.monitor_end();
 962            kptr < last_frame.monitor_begin();
 963            kptr = last_frame.next_monitor(kptr) ) {
 964         if( kptr->obj() != NULL ) {
 965           objects_to_revoke->append(Handle(THREAD, kptr->obj()));
 966         }
 967       }
 968       BiasedLocking::revoke(objects_to_revoke);
 969     }
 970   }
 971   return osr_nm;
 972 IRT_END
 973 
 974 IRT_LEAF(jint, InterpreterRuntime::bcp_to_di(Method* method, address cur_bcp))
 975   assert(ProfileInterpreter, "must be profiling interpreter");
 976   int bci = method->bci_from(cur_bcp);
 977   MethodData* mdo = method->method_data();
 978   if (mdo == NULL)  return 0;
 979   return mdo->bci_to_di(bci);
 980 IRT_END
 981 
 982 IRT_ENTRY(void, InterpreterRuntime::profile_method(JavaThread* thread))
 983   // use UnlockFlagSaver to clear and restore the _do_not_unlock_if_synchronized
 984   // flag, in case this method triggers classloading which will call into Java.
 985   UnlockFlagSaver fs(thread);
 986 
 987   assert(ProfileInterpreter, "must be profiling interpreter");
 988   LastFrameAccessor last_frame(thread);
 989   assert(last_frame.is_interpreted_frame(), "must come from interpreter");
 990   methodHandle method(thread, last_frame.method());
 991   Method::build_interpreter_method_data(method, THREAD);
 992   if (HAS_PENDING_EXCEPTION) {
 993     assert((PENDING_EXCEPTION->is_a(SystemDictionary::OutOfMemoryError_klass())), "we expect only an OOM error here");
 994     CLEAR_PENDING_EXCEPTION;
 995     // and fall through...
 996   }
 997 IRT_END
 998 
 999 
1000 #ifdef ASSERT
1001 IRT_LEAF(void, InterpreterRuntime::verify_mdp(Method* method, address bcp, address mdp))
1002   assert(ProfileInterpreter, "must be profiling interpreter");
1003 
1004   MethodData* mdo = method->method_data();
1005   assert(mdo != NULL, "must not be null");
1006 
1007   int bci = method->bci_from(bcp);
1008 
1009   address mdp2 = mdo->bci_to_dp(bci);
1010   if (mdp != mdp2) {


1015     int current_di = mdo->dp_to_di(mdp);
1016     int expected_di  = mdo->dp_to_di(mdp2);
1017     tty->print_cr("  actual di %d   expected di %d", current_di, expected_di);
1018     int expected_approx_bci = mdo->data_at(expected_di)->bci();
1019     int approx_bci = -1;
1020     if (current_di >= 0) {
1021       approx_bci = mdo->data_at(current_di)->bci();
1022     }
1023     tty->print_cr("  actual bci is %d  expected bci %d", approx_bci, expected_approx_bci);
1024     mdo->print_on(tty);
1025     method->print_codes();
1026   }
1027   assert(mdp == mdp2, "wrong mdp");
1028 IRT_END
1029 #endif // ASSERT
1030 
1031 IRT_ENTRY(void, InterpreterRuntime::update_mdp_for_ret(JavaThread* thread, int return_bci))
1032   assert(ProfileInterpreter, "must be profiling interpreter");
1033   ResourceMark rm(thread);
1034   HandleMark hm(thread);
1035   LastFrameAccessor last_frame(thread);
1036   assert(last_frame.is_interpreted_frame(), "must come from interpreter");
1037   MethodData* h_mdo = last_frame.method()->method_data();
1038 
1039   // Grab a lock to ensure atomic access to setting the return bci and
1040   // the displacement.  This can block and GC, invalidating all naked oops.
1041   MutexLocker ml(RetData_lock);
1042 
1043   // ProfileData is essentially a wrapper around a derived oop, so we
1044   // need to take the lock before making any ProfileData structures.
1045   ProfileData* data = h_mdo->data_at(h_mdo->dp_to_di(last_frame.mdp()));
1046   guarantee(data != NULL, "profile data must be valid");
1047   RetData* rdata = data->as_RetData();
1048   address new_mdp = rdata->fixup_ret(return_bci, h_mdo);
1049   last_frame.set_mdp(new_mdp);
1050 IRT_END
1051 
1052 IRT_ENTRY(MethodCounters*, InterpreterRuntime::build_method_counters(JavaThread* thread, Method* m))
1053   MethodCounters* mcs = Method::build_method_counters(m, thread);
1054   if (HAS_PENDING_EXCEPTION) {
1055     assert((PENDING_EXCEPTION->is_a(SystemDictionary::OutOfMemoryError_klass())), "we expect only an OOM error here");
1056     CLEAR_PENDING_EXCEPTION;
1057   }
1058   return mcs;
1059 IRT_END
1060 
1061 
1062 IRT_ENTRY(void, InterpreterRuntime::at_safepoint(JavaThread* thread))
1063   // We used to need an explict preserve_arguments here for invoke bytecodes. However,
1064   // stack traversal automatically takes care of preserving arguments for invoke, so
1065   // this is no longer needed.
1066 
1067   // IRT_END does an implicit safepoint check, hence we are guaranteed to block
1068   // if this is called during a safepoint
1069 
1070   if (JvmtiExport::should_post_single_step()) {
1071     // We are called during regular safepoints and when the VM is
1072     // single stepping. If any thread is marked for single stepping,
1073     // then we may have JVMTI work to do.
1074     LastFrameAccessor last_frame(thread);
1075     JvmtiExport::at_single_stepping_point(thread, last_frame.method(), last_frame.bcp());
1076   }
1077 IRT_END
1078 
1079 IRT_ENTRY(void, InterpreterRuntime::post_field_access(JavaThread *thread, oopDesc* obj,
1080 ConstantPoolCacheEntry *cp_entry))
1081 
1082   // check the access_flags for the field in the klass
1083 
1084   InstanceKlass* ik = InstanceKlass::cast(cp_entry->f1_as_klass());
1085   int index = cp_entry->field_index();
1086   if ((ik->field_access_flags(index) & JVM_ACC_FIELD_ACCESS_WATCHED) == 0) return;
1087 
1088   bool is_static = (obj == NULL);
1089   HandleMark hm(thread);
1090 
1091   Handle h_obj;
1092   if (!is_static) {
1093     // non-static field accessors have an object, but we need a handle
1094     h_obj = Handle(thread, obj);
1095   }
1096   InstanceKlass* cp_entry_f1 = InstanceKlass::cast(cp_entry->f1_as_klass());
1097   jfieldID fid = jfieldIDWorkaround::to_jfieldID(cp_entry_f1, cp_entry->f2_as_index(), is_static);
1098   LastFrameAccessor last_frame(thread);
1099   JvmtiExport::post_field_access(thread, last_frame.method(), last_frame.bcp(), cp_entry_f1, h_obj, fid);
1100 IRT_END
1101 
1102 IRT_ENTRY(void, InterpreterRuntime::post_field_modification(JavaThread *thread,
1103   oopDesc* obj, ConstantPoolCacheEntry *cp_entry, jvalue *value))
1104 
1105   Klass* k = cp_entry->f1_as_klass();
1106 
1107   // check the access_flags for the field in the klass
1108   InstanceKlass* ik = InstanceKlass::cast(k);
1109   int index = cp_entry->field_index();
1110   // bail out if field modifications are not watched
1111   if ((ik->field_access_flags(index) & JVM_ACC_FIELD_MODIFICATION_WATCHED) == 0) return;
1112 
1113   char sig_type = '\0';
1114 
1115   switch(cp_entry->flag_state()) {
1116     case btos: sig_type = 'B'; break;
1117     case ztos: sig_type = 'Z'; break;
1118     case ctos: sig_type = 'C'; break;
1119     case stos: sig_type = 'S'; break;


1134 #else
1135   // Long/double values are stored unaligned and also noncontiguously with
1136   // tagged stacks.  We can't just do a simple assignment even in the non-
1137   // J/D cases because a C++ compiler is allowed to assume that a jvalue is
1138   // 8-byte aligned, and interpreter stack slots are only 4-byte aligned.
1139   // We assume that the two halves of longs/doubles are stored in interpreter
1140   // stack slots in platform-endian order.
1141   jlong_accessor u;
1142   jint* newval = (jint*)value;
1143   u.words[0] = newval[0];
1144   u.words[1] = newval[Interpreter::stackElementWords]; // skip if tag
1145   fvalue.j = u.long_value;
1146 #endif // _LP64
1147 
1148   Handle h_obj;
1149   if (!is_static) {
1150     // non-static field accessors have an object, but we need a handle
1151     h_obj = Handle(thread, obj);
1152   }
1153 
1154   LastFrameAccessor last_frame(thread);
1155   JvmtiExport::post_raw_field_modification(thread, last_frame.method(), last_frame.bcp(), ik, h_obj,
1156                                            fid, sig_type, &fvalue);
1157 IRT_END
1158 
1159 IRT_ENTRY(void, InterpreterRuntime::post_method_entry(JavaThread *thread))
1160   LastFrameAccessor last_frame(thread);
1161   JvmtiExport::post_method_entry(thread, last_frame.method(), last_frame.get_frame());
1162 IRT_END
1163 
1164 
1165 IRT_ENTRY(void, InterpreterRuntime::post_method_exit(JavaThread *thread))
1166   LastFrameAccessor last_frame(thread);
1167   JvmtiExport::post_method_exit(thread, last_frame.method(), last_frame.get_frame());
1168 IRT_END
1169 
1170 IRT_LEAF(int, InterpreterRuntime::interpreter_contains(address pc))
1171 {
1172   return (Interpreter::contains(pc) ? 1 : 0);
1173 }
1174 IRT_END
1175 
1176 
1177 // Implementation of SignatureHandlerLibrary
1178 
1179 #ifndef SHARING_FAST_NATIVE_FINGERPRINTS
1180 // Dummy definition (else normalization method is defined in CPU
1181 // dependant code)
1182 uint64_t InterpreterRuntime::normalize_fast_native_fingerprint(uint64_t fingerprint) {
1183   return fingerprint;
1184 }
1185 #endif
1186 
1187 address SignatureHandlerLibrary::set_handler_blob() {


1371   bool in_base_library;
1372   if (!m->has_native_function()) {
1373     NativeLookup::lookup(m, in_base_library, CHECK);
1374   }
1375   // make sure signature handler is installed
1376   SignatureHandlerLibrary::add(m);
1377   // The interpreter entry point checks the signature handler first,
1378   // before trying to fetch the native entry point and klass mirror.
1379   // We must set the signature handler last, so that multiple processors
1380   // preparing the same method will be sure to see non-null entry & mirror.
1381 IRT_END
1382 
1383 #if defined(IA32) || defined(AMD64) || defined(ARM)
1384 IRT_LEAF(void, InterpreterRuntime::popframe_move_outgoing_args(JavaThread* thread, void* src_address, void* dest_address))
1385   if (src_address == dest_address) {
1386     return;
1387   }
1388   ResetNoHandleMark rnm; // In a LEAF entry.
1389   HandleMark hm;
1390   ResourceMark rm;
1391   LastFrameAccessor last_frame(thread);
1392   assert(last_frame.is_interpreted_frame(), "");
1393   jint bci = last_frame.bci();
1394   methodHandle mh(thread, last_frame.method());
1395   Bytecode_invoke invoke(mh, bci);
1396   ArgumentSizeComputer asc(invoke.signature());
1397   int size_of_arguments = (asc.size() + (invoke.has_receiver() ? 1 : 0)); // receiver
1398   Copy::conjoint_jbytes(src_address, dest_address,
1399                        size_of_arguments * Interpreter::stackElementSize);
1400 IRT_END
1401 #endif
1402 
1403 #if INCLUDE_JVMTI
1404 // This is a support of the JVMTI PopFrame interface.
1405 // Make sure it is an invokestatic of a polymorphic intrinsic that has a member_name argument
1406 // and return it as a vm_result so that it can be reloaded in the list of invokestatic parameters.
1407 // The member_name argument is a saved reference (in local#0) to the member_name.
1408 // For backward compatibility with some JDK versions (7, 8) it can also be a direct method handle.
1409 // FIXME: remove DMH case after j.l.i.InvokerBytecodeGenerator code shape is updated.
1410 IRT_ENTRY(void, InterpreterRuntime::member_name_arg_or_null(JavaThread* thread, address member_name,
1411                                                             Method* method, address bcp))
1412   Bytecodes::Code code = Bytecodes::code_at(method, bcp);
1413   if (code != Bytecodes::_invokestatic) {
1414     return;


1420 
1421   if (MethodHandles::has_member_arg(cname, mname)) {
1422     oop member_name_oop = (oop) member_name;
1423     if (java_lang_invoke_DirectMethodHandle::is_instance(member_name_oop)) {
1424       // FIXME: remove after j.l.i.InvokerBytecodeGenerator code shape is updated.
1425       member_name_oop = java_lang_invoke_DirectMethodHandle::member(member_name_oop);
1426     }
1427     thread->set_vm_result(member_name_oop);
1428   } else {
1429     thread->set_vm_result(NULL);
1430   }
1431 IRT_END
1432 #endif // INCLUDE_JVMTI
1433 
1434 #ifndef PRODUCT
1435 // This must be a IRT_LEAF function because the interpreter must save registers on x86 to
1436 // call this, which changes rsp and makes the interpreter's expression stack not walkable.
1437 // The generated code still uses call_VM because that will set up the frame pointer for
1438 // bcp and method.
1439 IRT_LEAF(intptr_t, InterpreterRuntime::trace_bytecode(JavaThread* thread, intptr_t preserve_this_value, intptr_t tos, intptr_t tos2))
1440   LastFrameAccessor last_frame(thread);
1441   assert(last_frame.is_interpreted_frame(), "must be an interpreted frame");
1442   methodHandle mh(thread, last_frame.method());
1443   BytecodeTracer::trace(mh, last_frame.bcp(), tos, tos2);
1444   return preserve_this_value;
1445 IRT_END
1446 #endif // !PRODUCT
< prev index next >