graal-jvmci-8: src/share/vm/ci/ciMethod.cpp comparison

comparison src/share/vm/ci/ciMethod.cpp @ 1930:2d26b0046e0d

Merge.

author	Thomas Wuerthinger <wuerthinger@ssw.jku.at>
date	Tue, 30 Nov 2010 14:53:30 +0100
parents	3f9a70eb8b1f
children	f95d63e2154a

comparison

equal deleted inserted replaced

-:6b7001391c97
+:2d26b0046e0d
 /*
-* Copyright 1999-2010 Sun Microsystems, Inc.  All Rights Reserved.
+* Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
-* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
-* CA 95054 USA or visit www.sun.com if you need additional information or
+* or visit www.oracle.com if you need additional information or have any
-* have any questions.
+* questions.
 *
 */
 #include "incls/_precompiled.incl"
 #include "incls/_ciMethod.cpp.incl"
 _code_size          = h_m()->code_size();
 _intrinsic_id       = h_m()->intrinsic_id();
 _handler_count      = h_m()->exception_table()->length() / 4;
 _uses_monitors      = h_m()->access_flags().has_monitor_bytecodes();
 _balanced_monitors  = !_uses_monitors || h_m()->access_flags().is_monitor_matching();
-_is_compilable      = !h_m()->is_not_compilable();
+_is_c1_compilable   = !h_m()->is_not_c1_compilable();
+_is_c2_compilable   = !h_m()->is_not_c2_compilable();
 // Lazy fields, filled in on demand.  Require allocation.
 _code               = NULL;
 _exception_handlers = NULL;
 _liveness           = NULL;
-_bcea = NULL;
 _method_blocks = NULL;
-#ifdef COMPILER2
+#if defined(COMPILER2) || defined(SHARK)
 _flow               = NULL;
-#endif // COMPILER2
+_bcea               = NULL;
+#endif // COMPILER2 || SHARK
 ciEnv *env = CURRENT_ENV;
-if (env->jvmti_can_hotswap_or_post_breakpoint() && _is_compilable) {
+if (env->jvmti_can_hotswap_or_post_breakpoint() && can_be_compiled()) {
 // 6328518 check hotswap conditions under the right lock.
 MutexLocker locker(Compile_lock);
 if (Dependencies::check_evol_method(h_m()) != NULL) {
-_is_compilable = false;
+_is_c1_compilable = false;
+_is_c2_compilable = false;
 }
 } else {
 CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops());
 }
 _holder = env->get_object(h_m()->method_holder())->as_instance_klass();
 ciSymbol* sig_symbol = env->get_object(h_m()->signature())->as_symbol();
 _signature = new (env->arena()) ciSignature(_holder, sig_symbol);
 _method_data = NULL;
 // Take a snapshot of these values, so they will be commensurate with the MDO.
-if (ProfileInterpreter) {
+if (ProfileInterpreter || TieredCompilation) {
 int invcnt = h_m()->interpreter_invocation_count();
 // if the value overflowed report it as max int
 _interpreter_invocation_count = invcnt < 0 ? max_jint : invcnt ;
 _interpreter_throwout_count   = h_m()->interpreter_throwout_count();
 } else {
 _holder = holder;
 _signature = new (CURRENT_ENV->arena()) ciSignature(_holder, signature);
 _intrinsic_id = vmIntrinsics::_none;
 _liveness = NULL;
 _can_be_statically_bound = false;
-_bcea = NULL;
 _method_blocks = NULL;
 _method_data = NULL;
-#ifdef COMPILER2
+#if defined(COMPILER2) || defined(SHARK)
 _flow = NULL;
-#endif // COMPILER2
+_bcea = NULL;
+#endif // COMPILER2 || SHARK
 }
 // ------------------------------------------------------------------
 // ciMethod::load_code
 VM_ENTRY_MARK;
 return get_methodOop()->vtable_index();
 }
+#ifdef SHARK
+// ------------------------------------------------------------------
+// ciMethod::itable_index
+//
+// 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());
+}
+#endif // SHARK
 // ------------------------------------------------------------------
 // ciMethod::native_entry
 //
 // Get the address of this method's native code, if any.
 address ciMethod::native_entry() {
 // ------------------------------------------------------------------
 // ciMethod::get_flow_analysis
 ciTypeFlow* ciMethod::get_flow_analysis() {
-#ifdef COMPILER2
+#if defined(COMPILER2) || defined(SHARK)
 if (_flow == NULL) {
 ciEnv* env = CURRENT_ENV;
 _flow = new (env->arena()) ciTypeFlow(env, this);
 _flow->do_flow();
 }
 return _flow;
-#else // COMPILER2
+#else // COMPILER2 || SHARK
 ShouldNotReachHere();
 return NULL;
-#endif // COMPILER2
+#endif // COMPILER2 || SHARK
 }
 // ------------------------------------------------------------------
 // ciMethod::get_osr_flow_analysis
 ciTypeFlow* ciMethod::get_osr_flow_analysis(int osr_bci) {
-#ifdef COMPILER2
+#if defined(COMPILER2) || defined(SHARK)
 // OSR entry points are always place after a call bytecode of some sort
 assert(osr_bci >= 0, "must supply valid OSR entry point");
 ciEnv* env = CURRENT_ENV;
 ciTypeFlow* flow = new (env->arena()) ciTypeFlow(env, this, osr_bci);
 flow->do_flow();
 return flow;
-#else // COMPILER2
+#else // COMPILER2 || SHARK
 ShouldNotReachHere();
 return NULL;
-#endif // COMPILER2
+#endif // COMPILER2 || SHARK
 }
 // ------------------------------------------------------------------
 // ciMethod::raw_liveness_at_bci
 //
 } else { // ReceiverTypeData is a subclass of CounterData
 ciReceiverTypeData* call = (ciReceiverTypeData*)data->as_ReceiverTypeData();
 // In addition, virtual call sites have receiver type information
 int receivers_count_total = 0;
 int morphism = 0;
+// Precompute morphism for the possible fixup
 for (uint i = 0; i < call->row_limit(); i++) {
 ciKlass* receiver = call->receiver(i);
 if (receiver == NULL)  continue;
-morphism += 1;
+morphism++;
-int rcount = call->receiver_count(i);
+}
+int epsilon = 0;
+if (TieredCompilation && ProfileInterpreter) {
+// Interpreter and C1 treat final and special invokes differently.
+// C1 will record a type, whereas the interpreter will just
+// increment the count. Detect this case.
+if (morphism == 1 && count > 0) {
+epsilon = count;
+count = 0;
+}
+}
+for (uint i = 0; i < call->row_limit(); i++) {
+ciKlass* receiver = call->receiver(i);
+if (receiver == NULL)  continue;
+int rcount = call->receiver_count(i) + epsilon;
 if (rcount == 0) rcount = 1; // Should be valid value
 receivers_count_total += rcount;
 // Add the receiver to result data.
 result.add_receiver(receiver, rcount);
 // If we extend profiling to record methods,
 // counts in the MDO should be scaled by 4X, so that
 // they can be usefully and stably compared against the
 // invocation counts in methods.
 int ciMethod::scale_count(int count, float prof_factor) {
 if (count > 0 && method_data() != NULL) {
-int current_mileage = method_data()->current_mileage();
+int counter_life;
-int creation_mileage = method_data()->creation_mileage();
-int counter_life = current_mileage - creation_mileage;
 int method_life = interpreter_invocation_count();
+if (TieredCompilation) {
+// In tiered the MDO's life is measured directly, so just use the snapshotted counters
+counter_life = MAX2(method_data()->invocation_count(), method_data()->backedge_count());
+} else {
+int current_mileage = method_data()->current_mileage();
+int creation_mileage = method_data()->creation_mileage();
+counter_life = current_mileage - creation_mileage;
+}
 // counter_life due to backedge_counter could be > method_life
 if (counter_life > method_life)
 counter_life = method_life;
 if (0 < counter_life && counter_life <= method_life) {
 count = (int)((double)count * prof_factor * method_life / counter_life + 0.5);
 return count;
 }
 // ------------------------------------------------------------------
 // invokedynamic support
-//
+// ------------------------------------------------------------------
+// ciMethod::is_method_handle_invoke
+//
+// Return true if the method is an instance of one of the two
+// signature-polymorphic MethodHandle methods, invokeExact or invokeGeneric.
 bool ciMethod::is_method_handle_invoke() const {
-check_is_loaded();
+if (!is_loaded()) {
-bool flag = ((flags().as_int() & JVM_MH_INVOKE_BITS) == JVM_MH_INVOKE_BITS);
+bool flag = (holder()->name() == ciSymbol::java_dyn_MethodHandle() &&
-#ifdef ASSERT
+methodOopDesc::is_method_handle_invoke_name(name()->sid()));
-{
+return flag;
-VM_ENTRY_MARK;
+}
-bool flag2 = get_methodOop()->is_method_handle_invoke();
+VM_ENTRY_MARK;
-assert(flag == flag2, "consistent");
+return get_methodOop()->is_method_handle_invoke();
 }
-#endif //ASSERT
-return flag;
+// ------------------------------------------------------------------
-}
+// ciMethod::is_method_handle_adapter
+//
+// Return true if the method is a generated MethodHandle adapter.
+// These are built by MethodHandleCompiler.
 bool ciMethod::is_method_handle_adapter() const {
-check_is_loaded();
+if (!is_loaded())  return false;
 VM_ENTRY_MARK;
 return get_methodOop()->is_method_handle_adapter();
 }
 ciInstance* ciMethod::method_handle_type() {
 VM_ENTRY_MARK;
 ciEnv* env = CURRENT_ENV;
 Thread* my_thread = JavaThread::current();
 methodHandle h_m(my_thread, get_methodOop());
-if (Tier1UpdateMethodData && is_tier1_compile(env->comp_level())) {
+// Create an MDO for the inlinee
+if (TieredCompilation && is_c1_compile(env->comp_level())) {
 build_method_data(h_m);
 }
 if (h_m()->method_data() != NULL) {
 _method_data = CURRENT_ENV->get_object(h_m()->method_data())->as_method_data();
 // ciMethod::can_be_compiled
 //
 // Have previous compilations of this method succeeded?
 bool ciMethod::can_be_compiled() {
 check_is_loaded();
-return _is_compilable;
+ciEnv* env = CURRENT_ENV;
+if (is_c1_compile(env->comp_level())) {
+return _is_c1_compilable;
+}
+return _is_c2_compilable;
 }
 // ------------------------------------------------------------------
 // ciMethod::set_not_compilable
 //
 // Tell the VM that this method cannot be compiled at all.
 void ciMethod::set_not_compilable() {
 check_is_loaded();
 VM_ENTRY_MARK;
-_is_compilable = false;
+ciEnv* env = CURRENT_ENV;
-get_methodOop()->set_not_compilable();
+if (is_c1_compile(env->comp_level())) {
+_is_c1_compilable = false;
+} else {
+_is_c2_compilable = false;
+}
+get_methodOop()->set_not_compilable(env->comp_level());
 }
 // ------------------------------------------------------------------
 // ciMethod::can_be_osr_compiled
 //
 // of failed OSR compilations per bci.  The entry_bci parameter
 // is currently unused.
 bool ciMethod::can_be_osr_compiled(int entry_bci) {
 check_is_loaded();
 VM_ENTRY_MARK;
-return !get_methodOop()->access_flags().is_not_osr_compilable();
+ciEnv* env = CURRENT_ENV;
+return !get_methodOop()->is_not_osr_compilable(env->comp_level());
 }
 // ------------------------------------------------------------------
 // ciMethod::has_compiled_code
 bool ciMethod::has_compiled_code() {
 VM_ENTRY_MARK;
 return get_methodOop()->code() != NULL;
 }
+int ciMethod::comp_level() {
+check_is_loaded();
+VM_ENTRY_MARK;
+nmethod* nm = get_methodOop()->code();
+if (nm != NULL) return nm->comp_level();
+return 0;
+}
 // ------------------------------------------------------------------
 // ciMethod::instructions_size
-// This is a rough metric for "fat" methods, compared
+//
-// before inlining with InlineSmallCode.
+// This is a rough metric for "fat" methods, compared before inlining
-// The CodeBlob::instructions_size accessor includes
+// with InlineSmallCode.  The CodeBlob::code_size accessor includes
-// junk like exception handler, stubs, and constant table,
+// junk like exception handler, stubs, and constant table, which are
-// which are not highly relevant to an inlined method.
+// not highly relevant to an inlined method.  So we use the more
-// So we use the more specific accessor nmethod::code_size.
+// specific accessor nmethod::insts_size.
-int ciMethod::instructions_size() {
+int ciMethod::instructions_size(int comp_level) {
 GUARDED_VM_ENTRY(
 nmethod* code = get_methodOop()->code();
-// if there's no compiled code or the code was produced by the
+if (code != NULL && (comp_level == CompLevel_any || comp_level == code->comp_level())) {
-// tier1 profiler return 0 for the code size.  This should
+return code->insts_end() - code->verified_entry_point();
-// probably be based on the compilation level of the nmethod but
+}
-// that currently isn't properly recorded.
+return 0;
-if (code == NULL ||
-(TieredCompilation && code->compiler() != NULL && code->compiler()->is_c1())) {
-return 0;
-}
-return code->code_end() - code->verified_entry_point();
 )
 }
 // ------------------------------------------------------------------
 // ciMethod::log_nmethod_identity
 bool ciMethod::has_jsrs       () const {         FETCH_FLAG_FROM_VM(has_jsrs);  }
 bool ciMethod::is_accessor    () const {         FETCH_FLAG_FROM_VM(is_accessor); }
 bool ciMethod::is_initializer () const {         FETCH_FLAG_FROM_VM(is_initializer); }
 BCEscapeAnalyzer  *ciMethod::get_bcea() {
+#ifdef COMPILER2
 if (_bcea == NULL) {
 _bcea = new (CURRENT_ENV->arena()) BCEscapeAnalyzer(this, NULL);
 }
 return _bcea;
+#else // COMPILER2
+ShouldNotReachHere();
+return NULL;
+#endif // COMPILER2
 }
 ciMethodBlocks  *ciMethod::get_method_blocks() {
 Arena *arena = CURRENT_ENV->arena();
 if (_method_blocks == NULL) {

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/ci/ciMethod.cpp @ 1930:2d26b0046e0d