graal-compiler: src/share/vm/opto/graphKit.cpp comparison

comparison src/share/vm/opto/graphKit.cpp @ 18041:52b4284cb496

Merge with jdk8u20-b26

author	Gilles Duboscq <duboscq@ssw.jku.at>
date	Wed, 15 Oct 2014 16:02:50 +0200
parents	89152779163c 00c8a1255912
children	7848fc12602b

comparison

equal deleted inserted replaced

-:45d7b2c7029d
+:52b4284cb496
 } else {
 while (dst->req() < region->req())  add_one_req(dst, src);
 }
 const Type* srctype = _gvn.type(src);
 if (phi->type() != srctype) {
-const Type* dsttype = phi->type()->meet(srctype);
+const Type* dsttype = phi->type()->meet_speculative(srctype);
 if (phi->type() != dsttype) {
 phi->set_type(dsttype);
 _gvn.set_type(phi, dsttype);
 }
 }
 // take the uncommon_trap in the BuildCutout below.
 // first must access the should_post_on_exceptions_flag in this thread's JavaThread
 Node* jthread = _gvn.transform(new (C) ThreadLocalNode());
 Node* adr = basic_plus_adr(top(), jthread, in_bytes(JavaThread::should_post_on_exceptions_flag_offset()));
-Node* should_post_flag = make_load(control(), adr, TypeInt::INT, T_INT, Compile::AliasIdxRaw, false);
+Node* should_post_flag = make_load(control(), adr, TypeInt::INT, T_INT, Compile::AliasIdxRaw, MemNode::unordered);
 // Test the should_post_on_exceptions_flag vs. 0
 Node* chk = _gvn.transform( new (C) CmpINode(should_post_flag, intcon(0)) );
 Node* tst = _gvn.transform( new (C) BoolNode(chk, BoolTest::eq) );
 int offset = java_lang_Throwable::get_detailMessage_offset();
 const TypePtr* adr_typ = ex_con->add_offset(offset);
 Node *adr = basic_plus_adr(ex_node, ex_node, offset);
 const TypeOopPtr* val_type = TypeOopPtr::make_from_klass(env()->String_klass());
-Node *store = store_oop_to_object(control(), ex_node, adr, adr_typ, null(), val_type, T_OBJECT);
+// Conservatively release stores of object references.
+Node *store = store_oop_to_object(control(), ex_node, adr, adr_typ, null(), val_type, T_OBJECT, MemNode::release);
 add_exception_state(make_exception_state(ex_node));
 return;
 }
 }
 // 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);
 }
 } else {
 // See if mixing in the NULL pointer changes type.
 // If so, then the NULL pointer was not allowed in the original
 // type.  In other words, "value" was not-null.
-if (t->meet(TypePtr::NULL_PTR) != t) {
+if (t->meet(TypePtr::NULL_PTR) != t->remove_speculative()) {
 // same as: if (!TypePtr::NULL_PTR->higher_equal(t)) ...
 explicit_null_checks_elided++;
 return value;           // Elided null check quickly!
 }
 }
 //------------------------------cast_not_null----------------------------------
 // Cast obj to not-null on this path
 Node* GraphKit::cast_not_null(Node* obj, bool do_replace_in_map) {
 const Type *t = _gvn.type(obj);
-const Type *t_not_null = t->join(TypePtr::NOTNULL);
+const Type *t_not_null = t->join_speculative(TypePtr::NOTNULL);
 // Object is already not-null?
 if( t == t_not_null ) return obj;
 Node *cast = new (C) CastPPNode(obj,t_not_null);
 cast->init_req(0, control());
 //
 // factory methods in "int adr_idx"
 Node* GraphKit::make_load(Node* ctl, Node* adr, const Type* t, BasicType bt,
 int adr_idx,
-bool require_atomic_access) {
+MemNode::MemOrd mo, bool require_atomic_access) {
 assert(adr_idx != Compile::AliasIdxTop, "use other make_load factory" );
 const TypePtr* adr_type = NULL; // debug-mode-only argument
 debug_only(adr_type = C->get_adr_type(adr_idx));
 Node* mem = memory(adr_idx);
 Node* ld;
 if (require_atomic_access && bt == T_LONG) {
-ld = LoadLNode::make_atomic(C, ctl, mem, adr, adr_type, t);
+ld = LoadLNode::make_atomic(C, ctl, mem, adr, adr_type, t, mo);
 } else {
-ld = LoadNode::make(_gvn, ctl, mem, adr, adr_type, t, bt);
+ld = LoadNode::make(_gvn, ctl, mem, adr, adr_type, t, bt, mo);
 }
 ld = _gvn.transform(ld);
 if ((bt == T_OBJECT) && C->do_escape_analysis() || C->eliminate_boxing()) {
 // Improve graph before escape analysis and boxing elimination.
 record_for_igvn(ld);
 return ld;
 }
 Node* GraphKit::store_to_memory(Node* ctl, Node* adr, Node *val, BasicType bt,
 int adr_idx,
+MemNode::MemOrd mo,
 bool require_atomic_access) {
 assert(adr_idx != Compile::AliasIdxTop, "use other store_to_memory factory" );
 const TypePtr* adr_type = NULL;
 debug_only(adr_type = C->get_adr_type(adr_idx));
 Node *mem = memory(adr_idx);
 Node* st;
 if (require_atomic_access && bt == T_LONG) {
-st = StoreLNode::make_atomic(C, ctl, mem, adr, adr_type, val);
+st = StoreLNode::make_atomic(C, ctl, mem, adr, adr_type, val, mo);
 } else {
-st = StoreNode::make(_gvn, ctl, mem, adr, adr_type, val, bt);
+st = StoreNode::make(_gvn, ctl, mem, adr, adr_type, val, bt, mo);
 }
 st = _gvn.transform(st);
 set_memory(st, adr_idx);
 // Back-to-back stores can only remove intermediate store with DU info
 // so push on worklist for optimizer.
 Node* adr,
 const TypePtr* adr_type,
 Node* val,
 const TypeOopPtr* val_type,
 BasicType bt,
-bool use_precise) {
+bool use_precise,
+MemNode::MemOrd mo) {
 // Transformation of a value which could be NULL pointer (CastPP #NULL)
 // could be delayed during Parse (for example, in adjust_map_after_if()).
 // Execute transformation here to avoid barrier generation in such case.
 if (_gvn.type(val) == TypePtr::NULL_PTR)
 val = _gvn.makecon(TypePtr::NULL_PTR);
 pre_barrier(true /* do_load */,
 control(), obj, adr, adr_idx, val, val_type,
 NULL /* pre_val */,
 bt);
-Node* store = store_to_memory(control(), adr, val, bt, adr_idx);
+Node* store = store_to_memory(control(), adr, val, bt, adr_idx, mo);
 post_barrier(control(), store, obj, adr, adr_idx, val, bt, use_precise);
 return store;
 }
 // Could be an array or object we don't know at compile time (unsafe ref.)
 Node* GraphKit::store_oop_to_unknown(Node* ctl,
 Node* obj,   // containing obj
 Node* adr,  // actual adress to store val at
 const TypePtr* adr_type,
 Node* val,
-BasicType bt) {
+BasicType bt,
+MemNode::MemOrd mo) {
 Compile::AliasType* at = C->alias_type(adr_type);
 const TypeOopPtr* val_type = NULL;
 if (adr_type->isa_instptr()) {
 if (at->field() != NULL) {
 // known field.  This code is a copy of the do_put_xxx logic.
 val_type = adr_type->is_aryptr()->elem()->make_oopptr();
 }
 if (val_type == NULL) {
 val_type = TypeInstPtr::BOTTOM;
 }
-return store_oop(ctl, obj, adr, adr_type, val, val_type, bt, true);
+return store_oop(ctl, obj, adr, adr_type, val, val_type, bt, true, mo);
 }
 //-------------------------array_element_address-------------------------
 Node* GraphKit::array_element_address(Node* ary, Node* idx, BasicType elembt,
 //-------------------------load_array_element-------------------------
 Node* GraphKit::load_array_element(Node* ctl, Node* ary, Node* idx, const TypeAryPtr* arytype) {
 const Type* elemtype = arytype->elem();
 BasicType elembt = elemtype->array_element_basic_type();
 Node* adr = array_element_address(ary, idx, elembt, arytype->size());
-Node* ld = make_load(ctl, adr, elemtype, elembt, arytype);
+Node* ld = make_load(ctl, adr, elemtype, elembt, arytype, MemNode::unordered);
 return ld;
 }
 //-------------------------set_arguments_for_java_call-------------------------
 // Arguments (pre-popped from the stack) are taken from the JVMS.
 }
 void GraphKit::increment_counter(Node* counter_addr) {
 int adr_type = Compile::AliasIdxRaw;
 Node* ctrl = control();
-Node* cnt  = make_load(ctrl, counter_addr, TypeInt::INT, T_INT, adr_type);
+Node* cnt  = make_load(ctrl, counter_addr, TypeInt::INT, T_INT, adr_type, MemNode::unordered);
 Node* incr = _gvn.transform(new (C) AddINode(cnt, _gvn.intcon(1)));
-store_to_memory( ctrl, counter_addr, incr, T_INT, adr_type );
+store_to_memory(ctrl, counter_addr, incr, T_INT, adr_type, MemNode::unordered);
 }
 //------------------------------uncommon_trap----------------------------------
 // Bail out to the interpreter in mid-method.  Implemented by calling the
 * @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;
 }
 }
 }
 //------------------------------make_slow_call_ex------------------------------
 // Make the exception handler hookups for the slow call
-void GraphKit::make_slow_call_ex(Node* call, ciInstanceKlass* ex_klass, bool separate_io_proj) {
+void GraphKit::make_slow_call_ex(Node* call, ciInstanceKlass* ex_klass, bool separate_io_proj, bool deoptimize) {
 if (stopped())  return;
 // Make a catch node with just two handlers:  fall-through and catch-all
 Node* i_o  = _gvn.transform( new (C) ProjNode(call, TypeFunc::I_O, separate_io_proj) );
 Node* catc = _gvn.transform( new (C) CatchNode(control(), i_o, 2) );
 { PreserveJVMState pjvms(this);
 set_control(excp);
 set_i_o(i_o);
 if (excp != top()) {
-// Create an exception state also.
+if (deoptimize) {
-// Use an exact type if the caller has specified a specific exception.
+// Deoptimize if an exception is caught. Don't construct exception state in this case.
-const Type* ex_type = TypeOopPtr::make_from_klass_unique(ex_klass)->cast_to_ptr_type(TypePtr::NotNull);
+uncommon_trap(Deoptimization::Reason_unhandled,
-Node*       ex_oop  = new (C) CreateExNode(ex_type, control(), i_o);
+Deoptimization::Action_none);
-add_exception_state(make_exception_state(_gvn.transform(ex_oop)));
+} else {
+// Create an exception state also.
+// Use an exact type if the caller has specified a specific exception.
+const Type* ex_type = TypeOopPtr::make_from_klass_unique(ex_klass)->cast_to_ptr_type(TypePtr::NotNull);
+Node*       ex_oop  = new (C) CreateExNode(ex_type, control(), i_o);
+add_exception_state(make_exception_state(_gvn.transform(ex_oop)));
+}
 }
 }
 // Get the no-exception control from the CatchNode.
 set_control(norm);
 // if the subklass is the unique subtype of the superklass, the check
 // will always succeed.  We could leave a dependency behind to ensure this.
 // First load the super-klass's check-offset
 Node *p1 = basic_plus_adr( superklass, superklass, in_bytes(Klass::super_check_offset_offset()) );
-Node *chk_off = _gvn.transform( new (C) LoadINode( NULL, memory(p1), p1, _gvn.type(p1)->is_ptr() ) );
+Node *chk_off = _gvn.transform(new (C) LoadINode(NULL, memory(p1), p1, _gvn.type(p1)->is_ptr(),
+TypeInt::INT, MemNode::unordered));
 int cacheoff_con = in_bytes(Klass::secondary_super_cache_offset());
 bool might_be_cache = (find_int_con(chk_off, cacheoff_con) == cacheoff_con);
 // Load from the sub-klass's super-class display list, or a 1-word cache of
 // the secondary superclass list, or a failing value with a sentinel offset
 //------------------------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(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();
 }
 }
 }
 constant_value = Klass::_lh_neutral_value;  // put in a known value
 Node* lhp = basic_plus_adr(klass_node, klass_node, in_bytes(Klass::layout_helper_offset()));
-return make_load(NULL, lhp, TypeInt::INT, T_INT);
+return make_load(NULL, lhp, TypeInt::INT, T_INT, MemNode::unordered);
 }
 // We just put in an allocate/initialize with a big raw-memory effect.
 // Hook selected additional alias categories on the initialization.
 static void hook_memory_on_init(GraphKit& kit, int alias_idx,
 kit.set_memory(init_out_raw, alias_idx);
 }
 //---------------------------set_output_for_allocation-------------------------
 Node* GraphKit::set_output_for_allocation(AllocateNode* alloc,
-const TypeOopPtr* oop_type) {
+const TypeOopPtr* oop_type,
+bool deoptimize_on_exception) {
 int rawidx = Compile::AliasIdxRaw;
 alloc->set_req( TypeFunc::FramePtr, frameptr() );
 add_safepoint_edges(alloc);
 Node* allocx = _gvn.transform(alloc);
 set_control( _gvn.transform(new (C) ProjNode(allocx, TypeFunc::Control) ) );
 // create memory projection for i_o
 set_memory ( _gvn.transform( new (C) ProjNode(allocx, TypeFunc::Memory, true) ), rawidx );
-make_slow_call_ex(allocx, env()->Throwable_klass(), true);
+make_slow_call_ex(allocx, env()->Throwable_klass(), true, deoptimize_on_exception);
 // create a memory projection as for the normal control path
 Node* malloc = _gvn.transform(new (C) ProjNode(allocx, TypeFunc::Memory));
 set_memory(malloc, rawidx);
 // for either, and the graph will fold nicely if the optimizer later reduces
 // the type to a constant.
 // The optional arguments are for specialized use by intrinsics:
 //  - If 'extra_slow_test' if not null is an extra condition for the slow-path.
 //  - If 'return_size_val', report the the total object size to the caller.
+//  - deoptimize_on_exception controls how Java exceptions are handled (rethrow vs deoptimize)
 Node* GraphKit::new_instance(Node* klass_node,
 Node* extra_slow_test,
-Node* *return_size_val) {
+Node* *return_size_val,
+bool deoptimize_on_exception) {
 // Compute size in doublewords
 // The size is always an integral number of doublewords, represented
 // as a positive bytewise size stored in the klass's layout_helper.
 // The layout_helper also encodes (in a low bit) the need for a slow path.
 jint  layout_con = Klass::_lh_neutral_value;
 = new (C) AllocateNode(C, AllocateNode::alloc_type(Type::TOP),
 control(), mem, i_o(),
 size, klass_node,
 initial_slow_test);
-return set_output_for_allocation(alloc, oop_type);
+return set_output_for_allocation(alloc, oop_type, deoptimize_on_exception);
 }
 //-------------------------------new_array-------------------------------------
 // helper for both newarray and anewarray
 // The 'length' parameter is (obviously) the length of the array.
 // See comments on new_instance for the meaning of the other arguments.
 Node* GraphKit::new_array(Node* klass_node,     // array klass (maybe variable)
 Node* length,         // number of array elements
 int   nargs,          // number of arguments to push back for uncommon trap
-Node* *return_size_val) {
+Node* *return_size_val,
+bool deoptimize_on_exception) {
 jint  layout_con = Klass::_lh_neutral_value;
 Node* layout_val = get_layout_helper(klass_node, layout_con);
 int   layout_is_con = (layout_val == NULL);
 if (!layout_is_con && !StressReflectiveCode &&
 if (ary_type->isa_aryptr() && length_type != NULL) {
 // Try to get a better type than POS for the size
 ary_type = ary_type->is_aryptr()->cast_to_size(length_type);
 }
-Node* javaoop = set_output_for_allocation(alloc, ary_type);
+Node* javaoop = set_output_for_allocation(alloc, ary_type, deoptimize_on_exception);
 // Cast length on remaining path to be as narrow as possible
 if (map()->find_edge(length) >= 0) {
 Node* ccast = alloc->make_ideal_length(ary_type, &_gvn);
 if (ccast != length) {
 __ if_then(card_val, BoolTest::ne, zero);
 }
 // Smash zero into card
 if( !UseConcMarkSweepGC ) {
-__ store(__ ctrl(), card_adr, zero, bt, adr_type);
+__ store(__ ctrl(), card_adr, zero, bt, adr_type, MemNode::release);
 } else {
 // Specialized path for CM store barrier
 __ storeCM(__ ctrl(), card_adr, zero, oop_store, adr_idx, bt, adr_type);
 }
 // decrement the index
 Node* next_index = _gvn.transform(new (C) SubXNode(index, __ ConX(sizeof(intptr_t))));
 // Now get the buffer location we will log the previous value into and store it
 Node *log_addr = __ AddP(no_base, buffer, next_index);
-__ store(__ ctrl(), log_addr, pre_val, T_OBJECT, Compile::AliasIdxRaw);
+__ store(__ ctrl(), log_addr, pre_val, T_OBJECT, Compile::AliasIdxRaw, MemNode::unordered);
 // update the index
-__ store(__ ctrl(), index_adr, next_index, index_bt, Compile::AliasIdxRaw);
+__ store(__ ctrl(), index_adr, next_index, index_bt, Compile::AliasIdxRaw, MemNode::unordered);
 } __ else_(); {
 // logging buffer is full, call the runtime
 const TypeFunc *tf = OptoRuntime::g1_wb_pre_Type();
 __ if_then(index, BoolTest::ne, zeroX); {
 Node* next_index = _gvn.transform(new (C) SubXNode(index, __ ConX(sizeof(intptr_t))));
 Node* log_addr = __ AddP(no_base, buffer, next_index);
-__ store(__ ctrl(), log_addr, card_adr, T_ADDRESS, Compile::AliasIdxRaw);
+// Order, see storeCM.
-__ store(__ ctrl(), index_adr, next_index, TypeX_X->basic_type(), Compile::AliasIdxRaw);
+__ store(__ ctrl(), log_addr, card_adr, T_ADDRESS, Compile::AliasIdxRaw, MemNode::unordered);
+__ store(__ ctrl(), index_adr, next_index, TypeX_X->basic_type(), Compile::AliasIdxRaw, MemNode::unordered);
 } __ else_(); {
 __ make_leaf_call(tf, CAST_FROM_FN_PTR(address, SharedRuntime::g1_wb_post), "g1_wb_post", card_adr, __ thread());
 } __ end_if();
 false, NULL, 0);
 const TypePtr* offset_field_type = string_type->add_offset(offset_offset);
 int offset_field_idx = C->get_alias_index(offset_field_type);
 return make_load(ctrl,
 basic_plus_adr(str, str, offset_offset),
-TypeInt::INT, T_INT, offset_field_idx);
+TypeInt::INT, T_INT, offset_field_idx, MemNode::unordered);
 } else {
 return intcon(0);
 }
 }
 false, NULL, 0);
 const TypePtr* count_field_type = string_type->add_offset(count_offset);
 int count_field_idx = C->get_alias_index(count_field_type);
 return make_load(ctrl,
 basic_plus_adr(str, str, count_offset),
-TypeInt::INT, T_INT, count_field_idx);
+TypeInt::INT, T_INT, count_field_idx, MemNode::unordered);
 } else {
 return load_array_length(load_String_value(ctrl, str));
 }
 }
 const TypeAryPtr*  value_type = TypeAryPtr::make(TypePtr::NotNull,
 TypeAry::make(TypeInt::CHAR,TypeInt::POS),
 ciTypeArrayKlass::make(T_CHAR), true, 0);
 int value_field_idx = C->get_alias_index(value_field_type);
 Node* load = make_load(ctrl, basic_plus_adr(str, str, value_offset),
-value_type, T_OBJECT, value_field_idx);
+value_type, T_OBJECT, value_field_idx, MemNode::unordered);
 // String.value field is known to be @Stable.
 if (UseImplicitStableValues) {
 load = cast_array_to_stable(load, value_type);
 }
 return load;
 const TypeInstPtr* string_type = TypeInstPtr::make(TypePtr::NotNull, C->env()->String_klass(),
 false, NULL, 0);
 const TypePtr* offset_field_type = string_type->add_offset(offset_offset);
 int offset_field_idx = C->get_alias_index(offset_field_type);
 store_to_memory(ctrl, basic_plus_adr(str, offset_offset),
-value, T_INT, offset_field_idx);
+value, T_INT, offset_field_idx, MemNode::unordered);
 }
 void GraphKit::store_String_value(Node* ctrl, Node* str, Node* value) {
 int value_offset = java_lang_String::value_offset_in_bytes();
 const TypeInstPtr* string_type = TypeInstPtr::make(TypePtr::NotNull, C->env()->String_klass(),
 false, NULL, 0);
 const TypePtr* value_field_type = string_type->add_offset(value_offset);
 store_oop_to_object(ctrl, str,  basic_plus_adr(str, value_offset), value_field_type,
-value, TypeAryPtr::CHARS, T_OBJECT);
+value, TypeAryPtr::CHARS, T_OBJECT, MemNode::unordered);
 }
 void GraphKit::store_String_length(Node* ctrl, Node* str, Node* value) {
 int count_offset = java_lang_String::count_offset_in_bytes();
 const TypeInstPtr* string_type = TypeInstPtr::make(TypePtr::NotNull, C->env()->String_klass(),
 false, NULL, 0);
 const TypePtr* count_field_type = string_type->add_offset(count_offset);
 int count_field_idx = C->get_alias_index(count_field_type);
 store_to_memory(ctrl, basic_plus_adr(str, count_offset),
-value, T_INT, count_field_idx);
+value, T_INT, count_field_idx, MemNode::unordered);
 }
 Node* GraphKit::cast_array_to_stable(Node* ary, const TypeAryPtr* ary_type) {
 // Reify the property as a CastPP node in Ideal graph to comply with monotonicity
 // assumption of CCP analysis.

Mercurial > hg > graal-compiler

comparison src/share/vm/opto/graphKit.cpp @ 18041:52b4284cb496