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

comparison src/share/vm/opto/graphKit.cpp @ 14518:d8041d695d19

Merged with jdk9/dev/hotspot changeset 3812c088b945

author	twisti
date	Tue, 11 Mar 2014 18:45:59 -0700
parents	096c224171c4 16c705d792be
children	b51e29501f30 4ca6dc0799b6

comparison

equal deleted inserted replaced

-:f97c5ec83832
+:d8041d695d19
 /*
-* Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2001, 2013, 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.
 } 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),
 can_prune_locals = true;
 stack_slots_not_pruned = inputs;
 }
 }
-if (env()->jvmti_can_access_local_variables()) {
+if (env()->should_retain_local_variables()) {
 // At any safepoint, this method can get breakpointed, which would
 // then require an immediate deoptimization.
 can_prune_locals = false;  // do not prune locals
 stack_slots_not_pruned = 0;
 }
 }
 } 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;
 }
 // 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();
 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(TypePtr::NULL_PTR));
+phi->raise_bottom_type(_gvn.type(cast_obj)->meet_speculative(TypePtr::NULL_PTR));
 }
 }
 if (cast_obj == NULL) {
 // Load the object's klass
 }
 }
 }
 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,
 __ 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 > truffle

comparison src/share/vm/opto/graphKit.cpp @ 14518:d8041d695d19