jdk-sandbox: comparison hotspot/src/share/vm/ci/ciMethod.cpp

equal deleted inserted replaced

-:caf5eb7dd4a7
+:882756847a04
 #include "ci/ciExceptionHandler.hpp"
 #include "ci/ciInstanceKlass.hpp"
 #include "ci/ciMethod.hpp"
 #include "ci/ciMethodBlocks.hpp"
 #include "ci/ciMethodData.hpp"
-#include "ci/ciMethodKlass.hpp"
 #include "ci/ciStreams.hpp"
 #include "ci/ciSymbol.hpp"
 #include "ci/ciUtilities.hpp"
 #include "classfile/systemDictionary.hpp"
 #include "compiler/abstractCompiler.hpp"
 #include "utilities/bitMap.inline.hpp"
 #include "utilities/xmlstream.hpp"
 #ifdef COMPILER2
 #include "ci/bcEscapeAnalyzer.hpp"
 #include "ci/ciTypeFlow.hpp"
-#include "oops/methodOop.hpp"
+#include "oops/method.hpp"
 #endif
 #ifdef SHARK
 #include "ci/ciTypeFlow.hpp"
-#include "oops/methodOop.hpp"
+#include "oops/method.hpp"
 #endif
 // ciMethod
 //
-// This class represents a methodOop in the HotSpot virtual
+// This class represents a Method* in the HotSpot virtual
 // machine.
 // ------------------------------------------------------------------
 // ciMethod::ciMethod
 //
 // Loaded method.
-ciMethod::ciMethod(methodHandle h_m) : ciObject(h_m) {
+ciMethod::ciMethod(methodHandle h_m) : ciMetadata(h_m()) {
 assert(h_m() != NULL, "no null method");
 // These fields are always filled in in loaded methods.
 _flags = ciFlags(h_m()->access_flags());
 }
 } else {
 CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops());
 }
-if (instanceKlass::cast(h_m()->method_holder())->is_linked()) {
+if (InstanceKlass::cast(h_m()->method_holder())->is_linked()) {
 _can_be_statically_bound = h_m()->can_be_statically_bound();
 } else {
 // Have to use a conservative value in this case.
 _can_be_statically_bound = false;
 }
 _can_be_statically_bound = false;
 // generating _signature may allow GC and therefore move m.
 // These fields are always filled in.
 _name = env->get_symbol(h_m()->name());
-_holder = env->get_object(h_m()->method_holder())->as_instance_klass();
+_holder = env->get_instance_klass(h_m()->method_holder());
 ciSymbol* sig_symbol = env->get_symbol(h_m()->signature());
 constantPoolHandle cpool = h_m()->constants();
 _signature = new (env->arena()) ciSignature(_holder, cpool, sig_symbol);
 _method_data = NULL;
 // Take a snapshot of these values, so they will be commensurate with the MDO.
 // Unloaded method.
 ciMethod::ciMethod(ciInstanceKlass* holder,
 ciSymbol*        name,
 ciSymbol*        signature,
 ciInstanceKlass* accessor) :
-ciObject(ciMethodKlass::make()),
+ciMetadata((Metadata*)NULL),
 _name(                   name),
 _holder(                 holder),
 _intrinsic_id(           vmIntrinsics::_none),
 _liveness(               NULL),
 _can_be_statically_bound(false),
 // Load the bytecodes and exception handler table for this method.
 void ciMethod::load_code() {
 VM_ENTRY_MARK;
 assert(is_loaded(), "only loaded methods have code");
-methodOop me = get_methodOop();
+Method* me = get_Method();
 Arena* arena = CURRENT_THREAD_ENV->arena();
 // Load the bytecodes.
 _code = (address)arena->Amalloc(code_size());
 memcpy(_code, me->code_base(), code_size());
 // Revert any breakpoint bytecodes in ci's copy
 if (me->number_of_breakpoints() > 0) {
-BreakpointInfo* bp = instanceKlass::cast(me->method_holder())->breakpoints();
+BreakpointInfo* bp = InstanceKlass::cast(me->method_holder())->breakpoints();
 for (; bp != NULL; bp = bp->next()) {
 if (bp->match(me)) {
 code_at_put(bp->bci(), bp->orig_bytecode());
 }
 }
 //
 // length unknown until decompression
 bool    ciMethod::has_linenumber_table() const {
 check_is_loaded();
 VM_ENTRY_MARK;
-return get_methodOop()->has_linenumber_table();
+return get_Method()->has_linenumber_table();
 }
 // ------------------------------------------------------------------
 // ciMethod::compressed_linenumber_table
 u_char* ciMethod::compressed_linenumber_table() const {
 check_is_loaded();
 VM_ENTRY_MARK;
-return get_methodOop()->compressed_linenumber_table();
+return get_Method()->compressed_linenumber_table();
 }
 // ------------------------------------------------------------------
 // ciMethod::line_number_from_bci
 int ciMethod::line_number_from_bci(int bci) const {
 check_is_loaded();
 VM_ENTRY_MARK;
-return get_methodOop()->line_number_from_bci(bci);
+return get_Method()->line_number_from_bci(bci);
 }
 // ------------------------------------------------------------------
 // ciMethod::vtable_index
 // Get the position of this method's entry in the vtable, if any.
 int ciMethod::vtable_index() {
 check_is_loaded();
 assert(holder()->is_linked(), "must be linked");
 VM_ENTRY_MARK;
-return get_methodOop()->vtable_index();
+return get_Method()->vtable_index();
 }
 #ifdef SHARK
 // ------------------------------------------------------------------
 // Get the position of this method's entry in the itable, if any.
 int ciMethod::itable_index() {
 check_is_loaded();
 assert(holder()->is_linked(), "must be linked");
 VM_ENTRY_MARK;
-return klassItable::compute_itable_index(get_methodOop());
+return klassItable::compute_itable_index(get_Method());
 }
 #endif // SHARK
 // ------------------------------------------------------------------
 // Get the address of this method's native code, if any.
 address ciMethod::native_entry() {
 check_is_loaded();
 assert(flags().is_native(), "must be native method");
 VM_ENTRY_MARK;
-methodOop method = get_methodOop();
+Method* method = get_Method();
 address entry = method->native_function();
 assert(entry != NULL, "must be valid entry point");
 return entry;
 }
 //
 // Get the entry point for running this method in the interpreter.
 address ciMethod::interpreter_entry() {
 check_is_loaded();
 VM_ENTRY_MARK;
-methodHandle mh(THREAD, get_methodOop());
+methodHandle mh(THREAD, get_Method());
 return Interpreter::entry_for_method(mh);
 }
 // ------------------------------------------------------------------
 check_is_loaded();
 if (_balanced_monitors) return true;
 // Analyze the method to see if monitors are used properly.
 VM_ENTRY_MARK;
-methodHandle method(THREAD, get_methodOop());
+methodHandle method(THREAD, get_Method());
 assert(method->has_monitor_bytecodes(), "should have checked this");
 // Check to see if a previous compilation computed the
 // monitor-matching analysis.
 if (method->guaranteed_monitor_matching()) {
 // OSR when loading the locals.
 BitMap ciMethod::live_local_oops_at_bci(int bci) {
 VM_ENTRY_MARK;
 InterpreterOopMap mask;
-OopMapCache::compute_one_oop_map(get_methodOop(), bci, &mask);
+OopMapCache::compute_one_oop_map(get_Method(), bci, &mask);
 int mask_size = max_locals();
 BitMap result(mask_size);
 result.clear();
 int i;
 for (i = 0; i < mask_size ; i++ ) {
 VM_ENTRY_MARK;
 methodHandle target;
 {
 MutexLocker locker(Compile_lock);
-klassOop context = actual_recv->get_klassOop();
+Klass* context = actual_recv->get_Klass();
 target = Dependencies::find_unique_concrete_method(context,
-root_m->get_methodOop());
+root_m->get_Method());
 // %%% Should upgrade this ciMethod API to look for 1 or 2 concrete methods.
 }
 #ifndef PRODUCT
-if (TraceDependencies && target() != NULL && target() != root_m->get_methodOop()) {
+if (TraceDependencies && target() != NULL && target() != root_m->get_Method()) {
 tty->print("found a non-root unique target method");
-tty->print_cr("  context = %s", instanceKlass::cast(actual_recv->get_klassOop())->external_name());
+tty->print_cr("  context = %s", InstanceKlass::cast(actual_recv->get_Klass())->external_name());
 tty->print("  method  = ");
 target->print_short_name(tty);
 tty->cr();
 }
 #endif //PRODUCT
 if (target() == NULL) {
 return NULL;
 }
-if (target() == root_m->get_methodOop()) {
+if (target() == root_m->get_Method()) {
 return root_m;
 }
 if (!root_m->is_public() &&
 !root_m->is_protected()) {
 // If we are going to reason about inheritance, it's easiest
 // methods in other packages.
 // %%% TO DO: Work out logic for package-private methods
 // with the same name but different vtable indexes.
 return NULL;
 }
-return CURRENT_THREAD_ENV->get_object(target())->as_method();
+return CURRENT_THREAD_ENV->get_method(target());
 }
 // ------------------------------------------------------------------
 // ciMethod::resolve_invoke
 //
 // Return NULL if the call has no target or the target is abstract.
 ciMethod* ciMethod::resolve_invoke(ciKlass* caller, ciKlass* exact_receiver) {
 check_is_loaded();
 VM_ENTRY_MARK;
-KlassHandle caller_klass (THREAD, caller->get_klassOop());
+KlassHandle caller_klass (THREAD, caller->get_Klass());
-KlassHandle h_recv       (THREAD, exact_receiver->get_klassOop());
+KlassHandle h_recv       (THREAD, exact_receiver->get_Klass());
-KlassHandle h_resolved   (THREAD, holder()->get_klassOop());
+KlassHandle h_resolved   (THREAD, holder()->get_Klass());
 Symbol* h_name      = name()->get_symbol();
 Symbol* h_signature = signature()->get_symbol();
 methodHandle m;
 // Only do exact lookup if receiver klass has been linked.  Otherwise,
 // the vtable has not been setup, and the LinkResolver will fail.
-if (h_recv->oop_is_javaArray()
+if (h_recv->oop_is_array()
 ||
-instanceKlass::cast(h_recv())->is_linked() && !exact_receiver->is_interface()) {
+InstanceKlass::cast(h_recv())->is_linked() && !exact_receiver->is_interface()) {
 if (holder()->is_interface()) {
 m = LinkResolver::resolve_interface_call_or_null(h_recv, h_resolved, h_name, h_signature, caller_klass);
 } else {
 m = LinkResolver::resolve_virtual_call_or_null(h_recv, h_resolved, h_name, h_signature, caller_klass);
 }
 // Return NULL only if there was a problem with lookup (uninitialized class, etc.)
 return NULL;
 }
 ciMethod* result = this;
-if (m() != get_methodOop()) {
+if (m() != get_Method()) {
-result = CURRENT_THREAD_ENV->get_object(m())->as_method();
+result = CURRENT_THREAD_ENV->get_method(m());
 }
 // Don't return abstract methods because they aren't
 // optimizable or interesting.
 if (result->is_abstract()) {
 // ------------------------------------------------------------------
 // ciMethod::resolve_vtable_index
 //
 // Given a known receiver klass, find the vtable index for the call.
-// Return methodOopDesc::invalid_vtable_index if the vtable_index is unknown.
+// Return Method::invalid_vtable_index if the vtable_index is unknown.
 int ciMethod::resolve_vtable_index(ciKlass* caller, ciKlass* receiver) {
 check_is_loaded();
-int vtable_index = methodOopDesc::invalid_vtable_index;
+int vtable_index = Method::invalid_vtable_index;
 // Only do lookup if receiver klass has been linked.  Otherwise,
 // the vtable has not been setup, and the LinkResolver will fail.
 if (!receiver->is_interface()
 && (!receiver->is_instance_klass() ||
 receiver->as_instance_klass()->is_linked())) {
 VM_ENTRY_MARK;
-KlassHandle caller_klass (THREAD, caller->get_klassOop());
+KlassHandle caller_klass (THREAD, caller->get_Klass());
-KlassHandle h_recv       (THREAD, receiver->get_klassOop());
+KlassHandle h_recv       (THREAD, receiver->get_Klass());
 Symbol* h_name = name()->get_symbol();
 Symbol* h_signature = signature()->get_symbol();
 vtable_index = LinkResolver::resolve_virtual_vtable_index(h_recv, h_recv, h_name, h_signature, caller_klass);
-if (vtable_index == methodOopDesc::nonvirtual_vtable_index) {
+if (vtable_index == Method::nonvirtual_vtable_index) {
 // A statically bound method.  Return "no such index".
-vtable_index = methodOopDesc::invalid_vtable_index;
+vtable_index = Method::invalid_vtable_index;
 }
 }
 return vtable_index;
 }
 }
 // ------------------------------------------------------------------
 // ciMethod::ensure_method_data
 //
-// Generate new methodDataOop objects at compile time.
+// Generate new MethodData* objects at compile time.
 // Return true if allocation was successful or no MDO is required.
 bool ciMethod::ensure_method_data(methodHandle h_m) {
 EXCEPTION_CONTEXT;
 if (is_native() || is_abstract() || h_m()->is_accessor()) return true;
 if (h_m()->method_data() == NULL) {
-methodOopDesc::build_interpreter_method_data(h_m, THREAD);
+Method::build_interpreter_method_data(h_m, THREAD);
 if (HAS_PENDING_EXCEPTION) {
 CLEAR_PENDING_EXCEPTION;
 }
 }
 if (h_m()->method_data() != NULL) {
-_method_data = CURRENT_ENV->get_object(h_m()->method_data())->as_method_data();
+_method_data = CURRENT_ENV->get_method_data(h_m()->method_data());
 _method_data->load_data();
 return true;
 } else {
 _method_data = CURRENT_ENV->get_empty_methodData();
 return false;
 // public, retroactive version
 bool ciMethod::ensure_method_data() {
 bool result = true;
 if (_method_data == NULL || _method_data->is_empty()) {
 GUARDED_VM_ENTRY({
-result = ensure_method_data(get_methodOop());
+result = ensure_method_data(get_Method());
 });
 }
 return result;
 }
 return _method_data;
 }
 VM_ENTRY_MARK;
 ciEnv* env = CURRENT_ENV;
 Thread* my_thread = JavaThread::current();
-methodHandle h_m(my_thread, get_methodOop());
+methodHandle h_m(my_thread, get_Method());
 if (h_m()->method_data() != NULL) {
-_method_data = CURRENT_ENV->get_object(h_m()->method_data())->as_method_data();
+_method_data = CURRENT_ENV->get_method_data(h_m()->method_data());
 _method_data->load_data();
 } else {
 _method_data = CURRENT_ENV->get_empty_methodData();
 }
 return _method_data;
 //
 // Should this method be excluded from compilation?
 bool ciMethod::should_exclude() {
 check_is_loaded();
 VM_ENTRY_MARK;
-methodHandle mh(THREAD, get_methodOop());
+methodHandle mh(THREAD, get_Method());
 bool ignore;
 return CompilerOracle::should_exclude(mh, ignore);
 }
 // ------------------------------------------------------------------
 //
 // Should this method be inlined during compilation?
 bool ciMethod::should_inline() {
 check_is_loaded();
 VM_ENTRY_MARK;
-methodHandle mh(THREAD, get_methodOop());
+methodHandle mh(THREAD, get_Method());
 return CompilerOracle::should_inline(mh);
 }
 // ------------------------------------------------------------------
 // ciMethod::should_not_inline
 //
 // Should this method be disallowed from inlining during compilation?
 bool ciMethod::should_not_inline() {
 check_is_loaded();
 VM_ENTRY_MARK;
-methodHandle mh(THREAD, get_methodOop());
+methodHandle mh(THREAD, get_Method());
 return CompilerOracle::should_not_inline(mh);
 }
 // ------------------------------------------------------------------
 // ciMethod::should_print_assembly
 //
 // Should the compiler print the generated code for this method?
 bool ciMethod::should_print_assembly() {
 check_is_loaded();
 VM_ENTRY_MARK;
-methodHandle mh(THREAD, get_methodOop());
+methodHandle mh(THREAD, get_Method());
 return CompilerOracle::should_print(mh);
 }
 // ------------------------------------------------------------------
 // ciMethod::break_at_execute
 // Should the compiler insert a breakpoint into the generated code
 // method?
 bool ciMethod::break_at_execute() {
 check_is_loaded();
 VM_ENTRY_MARK;
-methodHandle mh(THREAD, get_methodOop());
+methodHandle mh(THREAD, get_Method());
 return CompilerOracle::should_break_at(mh);
 }
 // ------------------------------------------------------------------
 // ciMethod::has_option
 //
 bool ciMethod::has_option(const char* option) {
 check_is_loaded();
 VM_ENTRY_MARK;
-methodHandle mh(THREAD, get_methodOop());
+methodHandle mh(THREAD, get_Method());
 return CompilerOracle::has_option_string(mh, option);
 }
 // ------------------------------------------------------------------
 // ciMethod::can_be_compiled
 if (is_c1_compile(env->comp_level())) {
 _is_c1_compilable = false;
 } else {
 _is_c2_compilable = false;
 }
-get_methodOop()->set_not_compilable(env->comp_level());
+get_Method()->set_not_compilable(env->comp_level());
 }
 // ------------------------------------------------------------------
 // ciMethod::can_be_osr_compiled
 //
 // is currently unused.
 bool ciMethod::can_be_osr_compiled(int entry_bci) {
 check_is_loaded();
 VM_ENTRY_MARK;
 ciEnv* env = CURRENT_ENV;
-return !get_methodOop()->is_not_osr_compilable(env->comp_level());
+return !get_Method()->is_not_osr_compilable(env->comp_level());
 }
 // ------------------------------------------------------------------
 // ciMethod::has_compiled_code
 bool ciMethod::has_compiled_code() {
 VM_ENTRY_MARK;
-return get_methodOop()->code() != NULL;
+return get_Method()->code() != NULL;
 }
 int ciMethod::comp_level() {
 check_is_loaded();
 VM_ENTRY_MARK;
-nmethod* nm = get_methodOop()->code();
+nmethod* nm = get_Method()->code();
 if (nm != NULL) return nm->comp_level();
 return 0;
 }
 int ciMethod::highest_osr_comp_level() {
 check_is_loaded();
 VM_ENTRY_MARK;
-return get_methodOop()->highest_osr_comp_level();
+return get_Method()->highest_osr_comp_level();
 }
 // ------------------------------------------------------------------
 // ciMethod::code_size_for_inlining
 //
 // Code size for inlining decisions.  This method returns a code
 // size of 1 for methods which has the ForceInline annotation.
 int ciMethod::code_size_for_inlining() {
 check_is_loaded();
-if (get_methodOop()->force_inline()) {
+if (get_Method()->force_inline()) {
 return 1;
 }
 return code_size();
 }
 // junk like exception handler, stubs, and constant table, which are
 // not highly relevant to an inlined method.  So we use the more
 // specific accessor nmethod::insts_size.
 int ciMethod::instructions_size(int comp_level) {
 GUARDED_VM_ENTRY(
-nmethod* code = get_methodOop()->code();
+nmethod* code = get_Method()->code();
 if (code != NULL && (comp_level == CompLevel_any || comp_level == code->comp_level())) {
 return code->insts_end() - code->verified_entry_point();
 }
 return 0;
 )
 // ------------------------------------------------------------------
 // ciMethod::log_nmethod_identity
 void ciMethod::log_nmethod_identity(xmlStream* log) {
 GUARDED_VM_ENTRY(
-nmethod* code = get_methodOop()->code();
+nmethod* code = get_Method()->code();
 if (code != NULL) {
 code->log_identity(log);
 }
 )
 }
 // ciMethod::is_not_reached
 bool ciMethod::is_not_reached(int bci) {
 check_is_loaded();
 VM_ENTRY_MARK;
 return Interpreter::is_not_reached(
-methodHandle(THREAD, get_methodOop()), bci);
+methodHandle(THREAD, get_Method()), bci);
 }
 // ------------------------------------------------------------------
 // ciMethod::was_never_executed
 bool ciMethod::was_executed_more_than(int times) {
 VM_ENTRY_MARK;
-return get_methodOop()->was_executed_more_than(times);
+return get_Method()->was_executed_more_than(times);
 }
 // ------------------------------------------------------------------
 // ciMethod::has_unloaded_classes_in_signature
 bool ciMethod::has_unloaded_classes_in_signature() {
 VM_ENTRY_MARK;
 {
 EXCEPTION_MARK;
-methodHandle m(THREAD, get_methodOop());
+methodHandle m(THREAD, get_Method());
-bool has_unloaded = methodOopDesc::has_unloaded_classes_in_signature(m, (JavaThread *)THREAD);
+bool has_unloaded = Method::has_unloaded_classes_in_signature(m, (JavaThread *)THREAD);
 if( HAS_PENDING_EXCEPTION ) {
 CLEAR_PENDING_EXCEPTION;
 return true;     // Declare that we may have unloaded classes
 }
 return has_unloaded;
 // ------------------------------------------------------------------
 // ciMethod::is_klass_loaded
 bool ciMethod::is_klass_loaded(int refinfo_index, bool must_be_resolved) const {
 VM_ENTRY_MARK;
-return get_methodOop()->is_klass_loaded(refinfo_index, must_be_resolved);
+return get_Method()->is_klass_loaded(refinfo_index, must_be_resolved);
 }
 // ------------------------------------------------------------------
 // ciMethod::check_call
 bool ciMethod::check_call(int refinfo_index, bool is_static) const {
 VM_ENTRY_MARK;
 {
 EXCEPTION_MARK;
 HandleMark hm(THREAD);
-constantPoolHandle pool (THREAD, get_methodOop()->constants());
+constantPoolHandle pool (THREAD, get_Method()->constants());
 methodHandle spec_method;
 KlassHandle  spec_klass;
 Bytecodes::Code code = (is_static ? Bytecodes::_invokestatic : Bytecodes::_invokevirtual);
 LinkResolver::resolve_method_statically(spec_method, spec_klass, code, pool, refinfo_index, THREAD);
 if (HAS_PENDING_EXCEPTION) {
 // ciMethod::print_codes
 //
 // Print the bytecodes for this method.
 void ciMethod::print_codes_on(outputStream* st) {
 check_is_loaded();
-GUARDED_VM_ENTRY(get_methodOop()->print_codes_on(st);)
+GUARDED_VM_ENTRY(get_Method()->print_codes_on(st);)
 }
 #define FETCH_FLAG_FROM_VM(flag_accessor) { \
 check_is_loaded(); \
 VM_ENTRY_MARK; \
-return get_methodOop()->flag_accessor(); \
+return get_Method()->flag_accessor(); \
 }
 bool ciMethod::is_empty_method() const {         FETCH_FLAG_FROM_VM(is_empty_method); }
 bool ciMethod::is_vanilla_constructor() const {  FETCH_FLAG_FROM_VM(is_vanilla_constructor); }
 bool ciMethod::has_loops      () const {         FETCH_FLAG_FROM_VM(has_loops); }
 // ciMethod::print_codes
 //
 // Print a range of the bytecodes for this method.
 void ciMethod::print_codes_on(int from, int to, outputStream* st) {
 check_is_loaded();
-GUARDED_VM_ENTRY(get_methodOop()->print_codes_on(from, to, st);)
+GUARDED_VM_ENTRY(get_Method()->print_codes_on(from, to, st);)
 }
 // ------------------------------------------------------------------
 // ciMethod::print_name
 //
 // Print the name of this method, including signature and some flags.
 void ciMethod::print_name(outputStream* st) {
 check_is_loaded();
-GUARDED_VM_ENTRY(get_methodOop()->print_name(st);)
+GUARDED_VM_ENTRY(get_Method()->print_name(st);)
 }
 // ------------------------------------------------------------------
 // ciMethod::print_short_name
 //
 // Print the name of this method, without signature.
 void ciMethod::print_short_name(outputStream* st) {
 if (is_loaded()) {
-GUARDED_VM_ENTRY(get_methodOop()->print_short_name(st););
+GUARDED_VM_ENTRY(get_Method()->print_short_name(st););
 } else {
 // Fall back if method is not loaded.
 holder()->print_name_on(st);
 st->print("::");
 name()->print_symbol_on(st);
 // ------------------------------------------------------------------
 // ciMethod::print_impl
 //
 // Implementation of the print method.
 void ciMethod::print_impl(outputStream* st) {
-ciObject::print_impl(st);
+ciMetadata::print_impl(st);
 st->print(" name=");
 name()->print_symbol_on(st);
 st->print(" holder=");
 holder()->print_name_on(st);
 st->print(" signature=");

changeset 13728	882756847a04
parent 13522	5ad4627e792a
child 14391	df0a1573d5bd