truffle: src/share/vm/opto/graphKit.cpp comparison

comparison src/share/vm/opto/graphKit.cpp @ 17810:62c54fcc0a35

Merge

author	kvn
date	Tue, 25 Mar 2014 17:07:36 -0700
parents	752ba2e5f6d0 606acabe7b5c
children	00c8a1255912

comparison

equal deleted inserted replaced

-:a433eb716ce1
+:62c54fcc0a35
 // create the stack trace.
 // Usual case:  Bail to interpreter.
 // Reserve the right to recompile if we haven't seen anything yet.
+assert(!Deoptimization::reason_is_speculate(reason), "unsupported");
 Deoptimization::DeoptAction action = Deoptimization::Action_maybe_recompile;
 if (treat_throw_as_hot
-&& (method()->method_data()->trap_recompiled_at(bci())
+&& (method()->method_data()->trap_recompiled_at(bci(), NULL)
 || C->too_many_traps(reason))) {
 // We cannot afford to take more traps here.  Suffer in the interpreter.
 if (C->log() != NULL)
 C->log()->elem("hot_throw preallocated='0' reason='%s' mcount='%d'",
 Deoptimization::trap_reason_name(reason),
 if (offset_con != Type::OffsetBot) {
 return longcon((jlong) offset_con);
 }
 return _gvn.transform( new (C) ConvI2LNode(offset));
 }
+Node* GraphKit::ConvI2UL(Node* offset) {
+juint offset_con = (juint) find_int_con(offset, Type::OffsetBot);
+if (offset_con != (juint) Type::OffsetBot) {
+return longcon((julong) offset_con);
+}
+Node* conv = _gvn.transform( new (C) ConvI2LNode(offset));
+Node* mask = _gvn.transform( ConLNode::make(C, (julong) max_juint) );
+return _gvn.transform( new (C) AndLNode(conv, mask) );
+}
 Node* GraphKit::ConvL2I(Node* offset) {
 // short-circuit a common case
 jlong offset_con = find_long_con(offset, (jlong)Type::OffsetBot);
 if (offset_con != (jlong)Type::OffsetBot) {
 return intcon((int) offset_con);
 * @param exact_kls  type from profiling
 *
 * @return           node with improved type
 */
 Node* GraphKit::record_profile_for_speculation(Node* n, ciKlass* exact_kls) {
-const TypeOopPtr* current_type = _gvn.type(n)->isa_oopptr();
+const Type* current_type = _gvn.type(n);
 assert(UseTypeSpeculation, "type speculation must be on");
-if (exact_kls != NULL &&
-// nothing to improve if type is already exact
+const TypeOopPtr* speculative = current_type->speculative();
-(current_type == NULL ||
-(!current_type->klass_is_exact() &&
+if (current_type->would_improve_type(exact_kls, jvms()->depth())) {
-(current_type->speculative() == NULL ||
-!current_type->speculative()->klass_is_exact())))) {
 const TypeKlassPtr* tklass = TypeKlassPtr::make(exact_kls);
 const TypeOopPtr* xtype = tklass->as_instance_type();
 assert(xtype->klass_is_exact(), "Should be exact");
+// record the new speculative type's depth
+speculative = xtype->with_inline_depth(jvms()->depth());
+}
+if (speculative != current_type->speculative()) {
 // Build a type with a speculative type (what we think we know
 // about the type but will need a guard when we use it)
-const TypeOopPtr* spec_type = TypeOopPtr::make(TypePtr::BotPTR, Type::OffsetBot, TypeOopPtr::InstanceBot, xtype);
+const TypeOopPtr* spec_type = TypeOopPtr::make(TypePtr::BotPTR, Type::OffsetBot, TypeOopPtr::InstanceBot, speculative);
-// We're changing the type, we need a new cast node to carry the
+// We're changing the type, we need a new CheckCast node to carry
-// new type. The new type depends on the control: what profiling
+// the new type. The new type depends on the control: what
-// tells us is only valid from here as far as we can tell.
+// profiling tells us is only valid from here as far as we can
-Node* cast = new(C) CastPPNode(n, spec_type);
+// tell.
-cast->init_req(0, control());
+Node* cast = new(C) CheckCastPPNode(control(), n, current_type->remove_speculative()->join_speculative(spec_type));
 cast = _gvn.transform(cast);
 replace_in_map(n, cast);
 n = cast;
 }
 return n;
 }
 /**
 * Record profiling data from receiver profiling at an invoke with the
 * type system so that it can propagate it (speculation)
 *
 * @param n  receiver node
 *
-* @return           node with improved type
+* @return   node with improved type
 */
 Node* GraphKit::record_profiled_receiver_for_speculation(Node* n) {
 if (!UseTypeSpeculation) {
 return n;
 }
 //------------------------maybe_cast_profiled_receiver-------------------------
 // If the profile has seen exactly one type, narrow to exactly that type.
 // Subsequent type checks will always fold up.
 Node* GraphKit::maybe_cast_profiled_receiver(Node* not_null_obj,
 ciKlass* require_klass,
 ciKlass* spec_klass,
 bool safe_for_replace) {
 if (!UseTypeProfile || !TypeProfileCasts) return NULL;
+Deoptimization::DeoptReason reason = spec_klass == NULL ? Deoptimization::Reason_class_check : Deoptimization::Reason_speculate_class_check;
 // Make sure we haven't already deoptimized from this tactic.
-if (too_many_traps(Deoptimization::Reason_class_check))
+if (too_many_traps(reason))
 return NULL;
 // (No, this isn't a call, but it's enough like a virtual call
 // to use the same ciMethod accessor to get the profile info...)
 // If we have a speculative type use it instead of profiling (which
 Node* exact_obj = not_null_obj; // will get updated in place...
 Node* slow_ctl  = type_check_receiver(exact_obj, exact_kls, 1.0,
 &exact_obj);
 { PreserveJVMState pjvms(this);
 set_control(slow_ctl);
-uncommon_trap(Deoptimization::Reason_class_check,
+uncommon_trap(reason,
 Deoptimization::Action_maybe_recompile);
 }
 if (safe_for_replace) {
 replace_in_map(not_null_obj, exact_obj);
 }
 Node* GraphKit::maybe_cast_profiled_obj(Node* obj,
 ciKlass* type,
 bool not_null) {
 // type == NULL if profiling tells us this object is always null
 if (type != NULL) {
-if (!too_many_traps(Deoptimization::Reason_null_check) &&
+Deoptimization::DeoptReason class_reason = Deoptimization::Reason_speculate_class_check;
-!too_many_traps(Deoptimization::Reason_class_check)) {
+Deoptimization::DeoptReason null_reason = Deoptimization::Reason_null_check;
+if (!too_many_traps(null_reason) &&
+!too_many_traps(class_reason)) {
 Node* not_null_obj = NULL;
 // not_null is true if we know the object is not null and
 // there's no need for a null check
 if (!not_null) {
 Node* null_ctl = top();
 Node* slow_ctl  = type_check_receiver(exact_obj, exact_kls, 1.0,
 &exact_obj);
 {
 PreserveJVMState pjvms(this);
 set_control(slow_ctl);
-uncommon_trap(Deoptimization::Reason_class_check,
+uncommon_trap(class_reason,
 Deoptimization::Action_maybe_recompile);
 }
 replace_in_map(not_null_obj, exact_obj);
 obj = exact_obj;
 }
 known_statically = (static_res == SSC_always_true || static_res == SSC_always_false);
 }
 }
 if (known_statically && UseTypeSpeculation) {
-// If we know the type check always succeed then we don't use the
+// 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();
 region->del_req(_null_path);
 phi   ->del_req(_null_path);
 }
 Node* cast_obj = NULL;
-const TypeOopPtr* obj_type = _gvn.type(obj)->is_oopptr();
+if (tk->klass_is_exact()) {
-// We may not have profiling here or it may not help us. If we have
+// The following optimization tries to statically cast the speculative type of the object
-// a speculative type use it to perform an exact cast.
+// (for example obtained during profiling) to the type of the superklass and then do a
-ciKlass* spec_obj_type = obj_type->speculative_type();
+// dynamic check that the type of the object is what we expect. To work correctly
-if (spec_obj_type != NULL ||
+// for checkcast and aastore the type of superklass should be exact.
-(data != NULL &&
+const TypeOopPtr* obj_type = _gvn.type(obj)->is_oopptr();
-// Counter has never been decremented (due to cast failure).
+// We may not have profiling here or it may not help us. If we have
-// ...This is a reasonable thing to expect.  It is true of
+// a speculative type use it to perform an exact cast.
-// all casts inserted by javac to implement generic types.
+ciKlass* spec_obj_type = obj_type->speculative_type();
-data->as_CounterData()->count() >= 0)) {
+if (spec_obj_type != NULL ||
-cast_obj = maybe_cast_profiled_receiver(not_null_obj, tk->klass(), spec_obj_type, safe_for_replace);
+(data != NULL &&
-if (cast_obj != NULL) {
+// Counter has never been decremented (due to cast failure).
-if (failure_control != NULL) // failure is now impossible
+// ...This is a reasonable thing to expect.  It is true of
-(*failure_control) = top();
+// all casts inserted by javac to implement generic types.
-// adjust the type of the phi to the exact klass:
+data->as_CounterData()->count() >= 0)) {
-phi->raise_bottom_type(_gvn.type(cast_obj)->meet_speculative(TypePtr::NULL_PTR));
+cast_obj = maybe_cast_profiled_receiver(not_null_obj, tk->klass(), spec_obj_type, safe_for_replace);
+if (cast_obj != NULL) {
+if (failure_control != NULL) // failure is now impossible
+(*failure_control) = top();
+// adjust the type of the phi to the exact klass:
+phi->raise_bottom_type(_gvn.type(cast_obj)->meet_speculative(TypePtr::NULL_PTR));
+}
 }
 }
 if (cast_obj == NULL) {
 // Load the object's klass
 // Box the stack location
 Node* box = _gvn.transform(new (C) BoxLockNode(next_monitor()));
 Node* mem = reset_memory();
 FastLockNode * flock = _gvn.transform(new (C) FastLockNode(0, obj, box) )->as_FastLock();
-if (PrintPreciseBiasedLockingStatistics) {
+if (UseBiasedLocking && PrintPreciseBiasedLockingStatistics) {
 // Create the counters for this fast lock.
 flock->create_lock_counter(sync_jvms()); // sync_jvms used to get current bci
 }
+// Create the rtm counters for this fast lock if needed.
+flock->create_rtm_lock_counter(sync_jvms()); // sync_jvms used to get current bci
 // Add monitor to debug info for the slow path.  If we block inside the
 // slow path and de-opt, we need the monitor hanging around
 map()->push_monitor( flock );
 const TypeFunc *tf = LockNode::lock_type();

Mercurial > hg > truffle

comparison src/share/vm/opto/graphKit.cpp @ 17810:62c54fcc0a35