jdk-sandbox: comparison hotspot/src/share/vm/opto/graphKit.cpp

equal deleted inserted replaced

-:d20828de9e39
+:73dd19b96b5d
 //-----------
 // Branch to failure if null
 float ok_prob = PROB_MAX;  // a priori estimate:  nulls never happen
 Deoptimization::DeoptReason reason;
 if (assert_null) {
-reason = Deoptimization::Reason_null_assert;
+reason = Deoptimization::reason_null_assert(speculative);
 } else if (type == T_OBJECT) {
 reason = Deoptimization::reason_null_check(speculative);
 } else {
 reason = Deoptimization::Reason_div0_check;
 }
 * @param exact_kls  type from profiling
 * @param maybe_null did profiling see null?
 *
 * @return           node with improved type
 */
-Node* GraphKit::record_profile_for_speculation(Node* n, ciKlass* exact_kls, bool maybe_null) {
+Node* GraphKit::record_profile_for_speculation(Node* n, ciKlass* exact_kls, ProfilePtrKind ptr_kind) {
 const Type* current_type = _gvn.type(n);
 assert(UseTypeSpeculation, "type speculation must be on");
 const TypePtr* speculative = current_type->speculative();
 if (current_type->would_improve_type(exact_kls, jvms()->depth())) {
 const TypeKlassPtr* tklass = TypeKlassPtr::make(exact_kls);
 const TypeOopPtr* xtype = tklass->as_instance_type();
 assert(xtype->klass_is_exact(), "Should be exact");
 // Any reason to believe n is not null (from this profiling or a previous one)?
-const TypePtr* ptr = (maybe_null && current_type->speculative_maybe_null()) ? TypePtr::BOTTOM : TypePtr::NOTNULL;
+assert(ptr_kind != ProfileAlwaysNull, "impossible here");
+const TypePtr* ptr = (ptr_kind == ProfileMaybeNull && current_type->speculative_maybe_null()) ? TypePtr::BOTTOM : TypePtr::NOTNULL;
 // record the new speculative type's depth
 speculative = xtype->cast_to_ptr_type(ptr->ptr())->is_ptr();
 speculative = speculative->with_inline_depth(jvms()->depth());
-} else if (current_type->would_improve_ptr(maybe_null)) {
+} else if (current_type->would_improve_ptr(ptr_kind)) {
 // Profiling report that null was never seen so we can change the
 // speculative type to non null ptr.
-assert(!maybe_null, "nothing to improve");
+if (ptr_kind == ProfileAlwaysNull) {
-if (speculative == NULL) {
+speculative = TypePtr::NULL_PTR;
-speculative = TypePtr::NOTNULL;
 } else {
+assert(ptr_kind == ProfileNeverNull, "nothing else is an improvement");
 const TypePtr* ptr = TypePtr::NOTNULL;
-speculative = speculative->cast_to_ptr_type(ptr->ptr())->is_ptr();
+if (speculative != NULL) {
+speculative = speculative->cast_to_ptr_type(ptr->ptr())->is_ptr();
+} else {
+speculative = ptr;
+}
 }
 }
 if (speculative != current_type->speculative()) {
 // Build a type with a speculative type (what we think we know
 Node* GraphKit::record_profiled_receiver_for_speculation(Node* n) {
 if (!UseTypeSpeculation) {
 return n;
 }
 ciKlass* exact_kls = profile_has_unique_klass();
-bool maybe_null = true;
+ProfilePtrKind ptr_kind = ProfileMaybeNull;
-if (java_bc() == Bytecodes::_checkcast ||
+if ((java_bc() == Bytecodes::_checkcast ||
 java_bc() == Bytecodes::_instanceof ||
-java_bc() == Bytecodes::_aastore) {
+java_bc() == Bytecodes::_aastore) &&
+method()->method_data()->is_mature()) {
 ciProfileData* data = method()->method_data()->bci_to_data(bci());
-maybe_null = data == NULL ? true : data->as_BitData()->null_seen();
+if (data != NULL) {
-}
+if (!data->as_BitData()->null_seen()) {
-return record_profile_for_speculation(n, exact_kls, maybe_null);
+ptr_kind = ProfileNeverNull;
+} else {
+assert(data->is_ReceiverTypeData(), "bad profile data type");
+ciReceiverTypeData* call = (ciReceiverTypeData*)data->as_ReceiverTypeData();
+uint i = 0;
+for (; i < call->row_limit(); i++) {
+ciKlass* receiver = call->receiver(i);
+if (receiver != NULL) {
+break;
+}
+}
+ptr_kind = (i == call->row_limit()) ? ProfileAlwaysNull : ProfileMaybeNull;
+}
+}
+}
+return record_profile_for_speculation(n, exact_kls, ptr_kind);
 }
 /**
 * Record profiling data from argument profiling at an invoke with the
 * type system so that it can propagate it (speculation)
 int             nargs = tf->domain()->cnt() - TypeFunc::Parms;
 int skip = Bytecodes::has_receiver(bc) ? 1 : 0;
 for (int j = skip, i = 0; j < nargs && i < TypeProfileArgsLimit; j++) {
 const Type *targ = tf->domain()->field_at(j + TypeFunc::Parms);
 if (targ->basic_type() == T_OBJECT || targ->basic_type() == T_ARRAY) {
-bool maybe_null = true;
+ProfilePtrKind ptr_kind = ProfileMaybeNull;
 ciKlass* better_type = NULL;
-if (method()->argument_profiled_type(bci(), i, better_type, maybe_null)) {
+if (method()->argument_profiled_type(bci(), i, better_type, ptr_kind)) {
-record_profile_for_speculation(argument(j), better_type, maybe_null);
+record_profile_for_speculation(argument(j), better_type, ptr_kind);
 }
 i++;
 }
 }
 }
 if (!UseTypeSpeculation) {
 return;
 }
 for (int i = 0, j = 0; i < method()->arg_size() ; i++) {
 if (_gvn.type(local(i))->isa_oopptr()) {
-bool maybe_null = true;
+ProfilePtrKind ptr_kind = ProfileMaybeNull;
 ciKlass* better_type = NULL;
-if (method()->parameter_profiled_type(j, better_type, maybe_null)) {
+if (method()->parameter_profiled_type(j, better_type, ptr_kind)) {
-record_profile_for_speculation(local(i), better_type, maybe_null);
+record_profile_for_speculation(local(i), better_type, ptr_kind);
 }
 j++;
 }
 }
 }
 */
 void GraphKit::record_profiled_return_for_speculation() {
 if (!UseTypeSpeculation) {
 return;
 }
-bool maybe_null = true;
+ProfilePtrKind ptr_kind = ProfileMaybeNull;
 ciKlass* better_type = NULL;
-if (method()->return_profiled_type(bci(), better_type, maybe_null)) {
+if (method()->return_profiled_type(bci(), better_type, ptr_kind)) {
 // If profiling reports a single type for the return value,
 // feed it to the type system so it can propagate it as a
 // speculative type
-record_profile_for_speculation(stack(sp()-1), better_type, maybe_null);
+record_profile_for_speculation(stack(sp()-1), better_type, ptr_kind);
 }
 }
 void GraphKit::round_double_result(ciMethod* dest_method) {
 // A non-strict method may return a double value which has an extended
 int static_res = C->static_subtype_check(superk, subk);
 known_statically = (static_res == Compile::SSC_always_true || static_res == Compile::SSC_always_false);
 }
 }
-if (known_statically && UseTypeSpeculation) {
+if (!known_statically) {
-// If we know the type check always succeeds then we don't use the
-// profiling data at this bytecode. Don't lose it, feed it to the
-// type system as a speculative type.
-not_null_obj = record_profiled_receiver_for_speculation(not_null_obj);
-} else {
 const TypeOopPtr* obj_type = _gvn.type(obj)->is_oopptr();
 // We may not have profiling here or it may not help us. If we
 // have a speculative type use it to perform an exact cast.
 ciKlass* spec_obj_type = obj_type->speculative_type();
 if (spec_obj_type != NULL || (ProfileDynamicTypes && data != NULL)) {
 phi   ->init_req(_fail_path, intcon(0));
 // Return final merged results
 set_control( _gvn.transform(region) );
 record_for_igvn(region);
+// If we know the type check always succeeds then we don't use the
+// profiling data at this bytecode. Don't lose it, feed it to the
+// type system as a speculative type.
+if (safe_for_replace) {
+Node* casted_obj = record_profiled_receiver_for_speculation(obj);
+replace_in_map(obj, casted_obj);
+}
 return _gvn.transform(phi);
 }
 //-------------------------------gen_checkcast---------------------------------
 // Generate a checkcast idiom.  Used by both the checkcast bytecode and the
 //  replace_in_map( obj, res );
 // Return final merged results
 set_control( _gvn.transform(region) );
 record_for_igvn(region);
-return res;
+return record_profiled_receiver_for_speculation(res);
 }
 //------------------------------next_monitor-----------------------------------
 // What number should be given to the next monitor?
 int GraphKit::next_monitor() {

changeset 46542	73dd19b96b5d
parent 46525	3a5c833a43de
child 46620	750c6edff33b