graal-compiler: src/share/vm/interpreter/interpreterRuntime.cpp comparison

comparison src/share/vm/interpreter/interpreterRuntime.cpp @ 4137:04b9a2566eec

Merge with hsx23/hotspot.

author	Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
date	Sat, 17 Dec 2011 21:40:27 +0100
parents	be4ca325525a 12d38ffcba2a
children	33df1aeaebbf

comparison

equal deleted inserted replaced

-:9dc19b7d89a3
+:04b9a2566eec
 IRT_ENTRY(void, InterpreterRuntime::resolve_get_put(JavaThread* thread, Bytecodes::Code bytecode))
 // resolve field
 FieldAccessInfo info;
 constantPoolHandle pool(thread, method(thread)->constants());
+bool is_put    = (bytecode == Bytecodes::_putfield  || bytecode == Bytecodes::_putstatic);
 bool is_static = (bytecode == Bytecodes::_getstatic || bytecode == Bytecodes::_putstatic);
 {
 JvmtiHideSingleStepping jhss(thread);
 LinkResolver::resolve_field(info, pool, get_index_u2_cpcache(thread, bytecode),
 // We need to delay resolving put instructions on final fields
 // until we actually invoke one. This is required so we throw
 // exceptions at the correct place. If we do not resolve completely
 // in the current pass, leaving the put_code set to zero will
 // cause the next put instruction to reresolve.
-bool is_put = (bytecode == Bytecodes::_putfield ||
-bytecode == Bytecodes::_putstatic);
 Bytecodes::Code put_code = (Bytecodes::Code)0;
 // We also need to delay resolving getstatic instructions until the
 // class is intitialized.  This is required so that access to the static
 // field will call the initialization function every time until the class
 instanceKlass *klass = instanceKlass::cast(info.klass()->as_klassOop());
 bool uninitialized_static = ((bytecode == Bytecodes::_getstatic || bytecode == Bytecodes::_putstatic) &&
 !klass->is_initialized());
 Bytecodes::Code get_code = (Bytecodes::Code)0;
 if (!uninitialized_static) {
 get_code = ((is_static) ? Bytecodes::_getstatic : Bytecodes::_getfield);
 if (is_put || !info.access_flags().is_final()) {
 put_code = ((is_static) ? Bytecodes::_putstatic : Bytecodes::_putfield);
 }
+}
+if (is_put && !is_static && klass->is_subclass_of(SystemDictionary::CallSite_klass()) && (info.name() == vmSymbols::target_name())) {
+const jint direction = frame::interpreter_frame_expression_stack_direction();
+Handle call_site    (THREAD, *((oop*) thread->last_frame().interpreter_frame_tos_at(-1 * direction)));
+Handle method_handle(THREAD, *((oop*) thread->last_frame().interpreter_frame_tos_at( 0 * direction)));
+assert(call_site    ->is_a(SystemDictionary::CallSite_klass()),     "must be");
+assert(method_handle->is_a(SystemDictionary::MethodHandle_klass()), "must be");
+{
+// Walk all nmethods depending on this call site.
+MutexLocker mu(Compile_lock, thread);
+Universe::flush_dependents_on(call_site, method_handle);
+}
+// Don't allow fast path for setting CallSite.target and sub-classes.
+put_code = (Bytecodes::Code) 0;
 }
 cache_entry(thread)->set_field(
 get_code,
 put_code,
 assert(fr.is_interpreted_frame(), "must come from interpreter");
 methodHandle method(thread, fr.interpreter_frame_method());
 const int branch_bci = branch_bcp != NULL ? method->bci_from(branch_bcp) : InvocationEntryBci;
 const int bci = branch_bcp != NULL ? method->bci_from(fr.interpreter_frame_bcp()) : InvocationEntryBci;
-nmethod* osr_nm = CompilationPolicy::policy()->event(method, method, branch_bci, bci, CompLevel_none, thread);
+nmethod* osr_nm = CompilationPolicy::policy()->event(method, method, branch_bci, bci, CompLevel_none, NULL, thread);
 if (osr_nm != NULL) {
 // We may need to do on-stack replacement which requires that no
 // monitors in the activation are biased because their
 // BasicObjectLocks will need to migrate during OSR. Force
 ConstantPoolCacheEntry *cp_entry))
 // check the access_flags for the field in the klass
 instanceKlass* ik = instanceKlass::cast(java_lang_Class::as_klassOop(cp_entry->f1()));
-typeArrayOop fields = ik->fields();
 int index = cp_entry->field_index();
-assert(index < fields->length(), "holders field index is out of range");
+if ((ik->field_access_flags(index) & JVM_ACC_FIELD_ACCESS_WATCHED) == 0) return;
-// bail out if field accesses are not watched
-if ((fields->ushort_at(index) & JVM_ACC_FIELD_ACCESS_WATCHED) == 0) return;
 switch(cp_entry->flag_state()) {
 case btos:    // fall through
 case ctos:    // fall through
 case stos:    // fall through
 klassOop k = java_lang_Class::as_klassOop(cp_entry->f1());
 // check the access_flags for the field in the klass
 instanceKlass* ik = instanceKlass::cast(k);
-typeArrayOop fields = ik->fields();
 int index = cp_entry->field_index();
-assert(index < fields->length(), "holders field index is out of range");
 // bail out if field modifications are not watched
-if ((fields->ushort_at(index) & JVM_ACC_FIELD_MODIFICATION_WATCHED) == 0) return;
+if ((ik->field_access_flags(index) & JVM_ACC_FIELD_MODIFICATION_WATCHED) == 0) return;
 char sig_type = '\0';
 switch(cp_entry->flag_state()) {
 case btos: sig_type = 'Z'; break;
 // before trying to fetch the native entry point and klass mirror.
 // We must set the signature handler last, so that multiple processors
 // preparing the same method will be sure to see non-null entry & mirror.
 IRT_END
-#if defined(IA32) || defined(AMD64)
+#if defined(IA32) || defined(AMD64) || defined(ARM)
 IRT_LEAF(void, InterpreterRuntime::popframe_move_outgoing_args(JavaThread* thread, void* src_address, void* dest_address))
 if (src_address == dest_address) {
 return;
 }
 ResetNoHandleMark rnm; // In a LEAF entry.

Mercurial > hg > graal-compiler

comparison src/share/vm/interpreter/interpreterRuntime.cpp @ 4137:04b9a2566eec