427 } 428 429 methodHandle mh(m); 430 MethodCounters* counters = MethodCounters::allocate(mh, THREAD); 431 if (HAS_PENDING_EXCEPTION) { 432 CompileBroker::log_metaspace_failure(); 433 ClassLoaderDataGraph::set_metaspace_oom(true); 434 return NULL; // return the exception (which is cleared) 435 } 436 if (!mh->init_method_counters(counters)) { 437 MetadataFactory::free_metadata(mh->method_holder()->class_loader_data(), counters); 438 } 439 440 if (LogTouchedMethods) { 441 mh->log_touched(CHECK_NULL); 442 } 443 444 return mh->method_counters(); 445 } 446 447 void Method::cleanup_inline_caches() { 448 // The current system doesn't use inline caches in the interpreter 449 // => nothing to do (keep this method around for future use) 450 } 451 452 453 int Method::extra_stack_words() { 454 // not an inline function, to avoid a header dependency on Interpreter 455 return extra_stack_entries() * Interpreter::stackElementSize; 456 } 457 458 459 void Method::compute_size_of_parameters(Thread *thread) { 460 ArgumentSizeComputer asc(signature()); 461 set_size_of_parameters(asc.size() + (is_static() ? 0 : 1)); 462 } 463 464 BasicType Method::result_type() const { 465 ResultTypeFinder rtf(signature()); 466 return rtf.type(); 1092 assert(mh->_from_compiled_entry != NULL, "must be"); 1093 } else { 1094 mh->set_adapter_entry(adapter); 1095 mh->_from_compiled_entry = adapter->get_c2i_entry(); 1096 } 1097 return adapter->get_c2i_entry(); 1098 } 1099 1100 void Method::restore_unshareable_info(TRAPS) { 1101 assert(is_method() && is_valid_method(), "ensure C++ vtable is restored"); 1102 1103 // Since restore_unshareable_info can be called more than once for a method, don't 1104 // redo any work. 1105 if (adapter() == NULL) { 1106 methodHandle mh(THREAD, this); 1107 link_method(mh, CHECK); 1108 } 1109 } 1110 1111 volatile address Method::from_compiled_entry_no_trampoline() const { 1112 nmethod *code = (nmethod *)OrderAccess::load_ptr_acquire(&_code); 1113 if (code) { 1114 return code->verified_entry_point(); 1115 } else { 1116 return adapter()->get_c2i_entry(); 1117 } 1118 } 1119 1120 // The verified_code_entry() must be called when a invoke is resolved 1121 // on this method. 1122 1123 // It returns the compiled code entry point, after asserting not null. 1124 // This function is called after potential safepoints so that nmethod 1125 // or adapter that it points to is still live and valid. 1126 // This function must not hit a safepoint! 1127 address Method::verified_code_entry() { 1128 debug_only(NoSafepointVerifier nsv;) 1129 assert(_from_compiled_entry != NULL, "must be set"); 1130 return _from_compiled_entry; 1131 } 1132 1133 // Check that if an nmethod ref exists, it has a backlink to this or no backlink at all 1134 // (could be racing a deopt). 1135 // Not inline to avoid circular ref. 1136 bool Method::check_code() const { 1137 // cached in a register or local. There's a race on the value of the field. 1138 CompiledMethod *code = (CompiledMethod *)OrderAccess::load_ptr_acquire(&_code); 1139 return code == NULL || (code->method() == NULL) || (code->method() == (Method*)this && !code->is_osr_method()); 1140 } 1141 1142 // Install compiled code. Instantly it can execute. 1143 void Method::set_code(const methodHandle& mh, CompiledMethod *code) { 1144 MutexLockerEx pl(Patching_lock, Mutex::_no_safepoint_check_flag); 1145 assert( code, "use clear_code to remove code" ); 1146 assert( mh->check_code(), "" ); 1147 1148 guarantee(mh->adapter() != NULL, "Adapter blob must already exist!"); 1149 1150 // These writes must happen in this order, because the interpreter will 1151 // directly jump to from_interpreted_entry which jumps to an i2c adapter 1152 // which jumps to _from_compiled_entry. 1153 mh->_code = code; // Assign before allowing compiled code to exec 1154 1155 int comp_level = code->comp_level(); 1156 // In theory there could be a race here. In practice it is unlikely 1157 // and not worth worrying about. 1158 if (comp_level > mh->highest_comp_level()) { | 427 } 428 429 methodHandle mh(m); 430 MethodCounters* counters = MethodCounters::allocate(mh, THREAD); 431 if (HAS_PENDING_EXCEPTION) { 432 CompileBroker::log_metaspace_failure(); 433 ClassLoaderDataGraph::set_metaspace_oom(true); 434 return NULL; // return the exception (which is cleared) 435 } 436 if (!mh->init_method_counters(counters)) { 437 MetadataFactory::free_metadata(mh->method_holder()->class_loader_data(), counters); 438 } 439 440 if (LogTouchedMethods) { 441 mh->log_touched(CHECK_NULL); 442 } 443 444 return mh->method_counters(); 445 } 446 447 bool Method::init_method_counters(MethodCounters* counters) { 448 // Try to install a pointer to MethodCounters, return true on success. 449 return Atomic::cmpxchg(counters, &_method_counters, (MethodCounters*)NULL) == NULL; 450 } 451 452 void Method::cleanup_inline_caches() { 453 // The current system doesn't use inline caches in the interpreter 454 // => nothing to do (keep this method around for future use) 455 } 456 457 458 int Method::extra_stack_words() { 459 // not an inline function, to avoid a header dependency on Interpreter 460 return extra_stack_entries() * Interpreter::stackElementSize; 461 } 462 463 464 void Method::compute_size_of_parameters(Thread *thread) { 465 ArgumentSizeComputer asc(signature()); 466 set_size_of_parameters(asc.size() + (is_static() ? 0 : 1)); 467 } 468 469 BasicType Method::result_type() const { 470 ResultTypeFinder rtf(signature()); 471 return rtf.type(); 1097 assert(mh->_from_compiled_entry != NULL, "must be"); 1098 } else { 1099 mh->set_adapter_entry(adapter); 1100 mh->_from_compiled_entry = adapter->get_c2i_entry(); 1101 } 1102 return adapter->get_c2i_entry(); 1103 } 1104 1105 void Method::restore_unshareable_info(TRAPS) { 1106 assert(is_method() && is_valid_method(), "ensure C++ vtable is restored"); 1107 1108 // Since restore_unshareable_info can be called more than once for a method, don't 1109 // redo any work. 1110 if (adapter() == NULL) { 1111 methodHandle mh(THREAD, this); 1112 link_method(mh, CHECK); 1113 } 1114 } 1115 1116 volatile address Method::from_compiled_entry_no_trampoline() const { 1117 CompiledMethod *code = OrderAccess::load_acquire(&_code); 1118 if (code) { 1119 return code->verified_entry_point(); 1120 } else { 1121 return adapter()->get_c2i_entry(); 1122 } 1123 } 1124 1125 // The verified_code_entry() must be called when a invoke is resolved 1126 // on this method. 1127 1128 // It returns the compiled code entry point, after asserting not null. 1129 // This function is called after potential safepoints so that nmethod 1130 // or adapter that it points to is still live and valid. 1131 // This function must not hit a safepoint! 1132 address Method::verified_code_entry() { 1133 debug_only(NoSafepointVerifier nsv;) 1134 assert(_from_compiled_entry != NULL, "must be set"); 1135 return _from_compiled_entry; 1136 } 1137 1138 // Check that if an nmethod ref exists, it has a backlink to this or no backlink at all 1139 // (could be racing a deopt). 1140 // Not inline to avoid circular ref. 1141 bool Method::check_code() const { 1142 // cached in a register or local. There's a race on the value of the field. 1143 CompiledMethod *code = OrderAccess::load_acquire(&_code); 1144 return code == NULL || (code->method() == NULL) || (code->method() == (Method*)this && !code->is_osr_method()); 1145 } 1146 1147 // Install compiled code. Instantly it can execute. 1148 void Method::set_code(const methodHandle& mh, CompiledMethod *code) { 1149 MutexLockerEx pl(Patching_lock, Mutex::_no_safepoint_check_flag); 1150 assert( code, "use clear_code to remove code" ); 1151 assert( mh->check_code(), "" ); 1152 1153 guarantee(mh->adapter() != NULL, "Adapter blob must already exist!"); 1154 1155 // These writes must happen in this order, because the interpreter will 1156 // directly jump to from_interpreted_entry which jumps to an i2c adapter 1157 // which jumps to _from_compiled_entry. 1158 mh->_code = code; // Assign before allowing compiled code to exec 1159 1160 int comp_level = code->comp_level(); 1161 // In theory there could be a race here. In practice it is unlikely 1162 // and not worth worrying about. 1163 if (comp_level > mh->highest_comp_level()) { |