graal-compiler: src/share/vm/oops/method.cpp comparison

comparison src/share/vm/oops/method.cpp @ 12355:cefad50507d8

Merge with hs25-b53

author	Gilles Duboscq <duboscq@ssw.jku.at>
date	Fri, 11 Oct 2013 10:38:03 +0200
parents	3cce976666d9 510fbd28919c
children	359f7e70ae7f

comparison

equal deleted inserted replaced

-:ccb4f2af2319
+:cefad50507d8
 }
 _access_flags.set_loops_flag_init();
 return _access_flags.has_loops();
 }
+bool Method::is_final_method(AccessFlags class_access_flags) const {
+// or "does_not_require_vtable_entry"
+// overpass can occur, is not final (reuses vtable entry)
+// private methods get vtable entries for backward class compatibility.
+if (is_overpass())  return false;
+return is_final() || class_access_flags.is_final();
+}
 bool Method::is_final_method() const {
-// %%% Should return true for private methods also,
+return is_final_method(method_holder()->access_flags());
-// since there is no way to override them.
+}
-return is_final() || method_holder()->is_final();
-}
+bool Method::can_be_statically_bound(AccessFlags class_access_flags) const {
+if (is_final_method(class_access_flags))  return true;
+#ifdef ASSERT
-bool Method::is_strict_method() const {
+bool is_nonv = (vtable_index() == nonvirtual_vtable_index);
-return is_strict();
+if (class_access_flags.is_interface())  assert(is_nonv == is_static(), err_msg("is_nonv=%s", is_nonv));
-}
+#endif
+assert(valid_vtable_index() || valid_itable_index(), "method must be linked before we ask this question");
+return vtable_index() == nonvirtual_vtable_index;
+}
 bool Method::can_be_statically_bound() const {
-if (is_final_method())  return true;
+return can_be_statically_bound(method_holder()->access_flags());
-return vtable_index() == nonvirtual_vtable_index;
+}
-}
 bool Method::is_accessor() const {
 if (code_size() != 5) return false;
 if (size_of_parameters() != 1) return false;
 if (java_code_at(0) != Bytecodes::_aload_0 ) return false;
 xtty->stamp();
 xtty->end_elem();
 }
 }
+bool Method::is_always_compilable() const {
+// Generated adapters must be compiled
+if (is_method_handle_intrinsic()) {
+bool is_executeCompiled = intrinsic_id() == vmIntrinsics::_CompilerToVMImpl_executeCompiledMethod);
+if (is_synthetic() || is_executeCompiled) {
+assert(!is_not_c1_compilable() || is_executeCompiled, "sanity check");
+assert(!is_not_c2_compilable() || is_executeCompiled, "sanity check");
+return true;
+}
+}
+return false;
+}
 bool Method::is_not_compilable(int comp_level) const {
 if (number_of_breakpoints() > 0)
 return true;
-if (is_method_handle_intrinsic())
+if (is_always_compilable())
-return !is_synthetic() && intrinsic_id() != vmIntrinsics::_CompilerToVMImpl_executeCompiledMethod;  // the generated adapters must be compiled
+return false;
 if (comp_level == CompLevel_any)
 return is_not_c1_compilable() || is_not_c2_compilable();
 if (is_c1_compile(comp_level))
 return is_not_c1_compilable();
 if (is_c2_compile(comp_level))
 return false;
 }
 // call this when compiler finds that this method is not compilable
 void Method::set_not_compilable(int comp_level, bool report, const char* reason) {
+if (is_always_compilable()) {
+// Don't mark a method which should be always compilable
+return;
+}
 print_made_not_compilable(comp_level, /*is_osr*/ false, report, reason);
 if (comp_level == CompLevel_all) {
 set_not_c1_compilable();
 set_not_c2_compilable();
 } else {
 set_not_c1_compilable();
 if (is_c2_compile(comp_level))
 set_not_c2_compilable();
 }
 CompilationPolicy::policy()->disable_compilation(this);
+assert(!CompilationPolicy::can_be_compiled(this, comp_level), "sanity check");
 }
 bool Method::is_not_osr_compilable(int comp_level) const {
 if (is_not_compilable(comp_level))
 return true;
 set_not_c1_osr_compilable();
 if (is_c2_compile(comp_level))
 set_not_c2_osr_compilable();
 }
 CompilationPolicy::policy()->disable_compilation(this);
+assert(!CompilationPolicy::can_be_osr_compiled(this, comp_level), "sanity check");
 }
 // Revert to using the interpreter and clear out the nmethod
 void Method::clear_code() {
 // This function is called after potential safepoints so that nmethod
 // or adapter that it points to is still live and valid.
 // This function must not hit a safepoint!
 address Method::verified_code_entry() {
 debug_only(No_Safepoint_Verifier nsv;)
-nmethod *code = (nmethod *)OrderAccess::load_ptr_acquire(&_code);
-if (code == NULL && UseCodeCacheFlushing) {
-nmethod *saved_code = CodeCache::reanimate_saved_code(this);
-if (saved_code != NULL) {
-methodHandle method(this);
-assert( ! saved_code->is_osr_method(), "should not get here for osr" );
-set_code( method, saved_code );
-}
-}
 assert(_from_compiled_entry != NULL, "must be set");
 return _from_compiled_entry;
 }
 // Check that if an nmethod ref exists, it has a backlink to this or no backlink at all
 return true;
 }
 assert(ik->is_subclass_of(method_holder()), "should be subklass");
 assert(ik->vtable() != NULL, "vtable should exist");
-if (vtable_index() == nonvirtual_vtable_index) {
+if (!has_vtable_index()) {
 return false;
 } else {
 Method* vt_m = ik->method_at_vtable(vtable_index());
 return vt_m != this;
 }
 #endif //PRODUCT
 void Method::print_value_on(outputStream* st) const {
 assert(is_method(), "must be method");
-st->print_cr(internal_name());
+st->print(internal_name());
 print_address_on(st);
 st->print(" ");
 name()->print_value_on(st);
 st->print(" ");
 signature()->print_value_on(st);
 st->print(" in ");
 method_holder()->print_value_on(st);
+if (WizardMode) st->print("#%d", _vtable_index);
 if (WizardMode) st->print("[%d,%d]", size_of_parameters(), max_locals());
 if (WizardMode && code() != NULL) st->print(" ((nmethod*)%p)", code());
 }
 #if INCLUDE_SERVICES

Mercurial > hg > graal-compiler

comparison src/share/vm/oops/method.cpp @ 12355:cefad50507d8