truffle: src/share/vm/opto/library

comparison src/share/vm/opto/library_call.cpp @ 4771:22cee0ee8927

Merge

author	kvn
date	Fri, 06 Jan 2012 20:09:20 -0800
parents	52b5d32fbfaf 1dc233a8c7fe
children	35acf8f0a2e4

comparison

equal deleted inserted replaced

-:2b3acb34791f
+:22cee0ee8927
 float unlikely  = PROB_UNLIKELY(0.999);
 IdealKit ideal(this);
 #define __ ideal.
-const int reference_type_offset = instanceKlass::reference_type_offset_in_bytes() +
+const int reference_type_offset = in_bytes(instanceKlass::reference_type_offset());
-sizeof(oopDesc);
 Node* referent_off = __ ConX(java_lang_ref_Reference::referent_offset);
 __ if_then(offset, BoolTest::eq, referent_off, unlikely); {
 __ if_then(base_oop, BoolTest::ne, null(), likely); {
 if (stopped())  return true;  // argument was like int.class
 // Note:  The argument might still be an illegal value like
 // Serializable.class or Object[].class.   The runtime will handle it.
 // But we must make an explicit check for initialization.
-Node* insp = basic_plus_adr(kls, instanceKlass::init_state_offset_in_bytes() + sizeof(oopDesc));
+Node* insp = basic_plus_adr(kls, in_bytes(instanceKlass::init_state_offset()));
 // Use T_BOOLEAN for instanceKlass::_init_state so the compiler
 // can generate code to load it as unsigned byte.
 Node* inst = make_load(NULL, insp, TypeInt::UBYTE, T_BOOLEAN);
 Node* bits = intcon(instanceKlass::fully_initialized);
 Node* test = _gvn.transform( new (C, 3) SubINode(inst, bits) );
 }
 //---------------------------load_mirror_from_klass----------------------------
 // Given a klass oop, load its java mirror (a java.lang.Class oop).
 Node* LibraryCallKit::load_mirror_from_klass(Node* klass) {
-Node* p = basic_plus_adr(klass, Klass::java_mirror_offset_in_bytes() + sizeof(oopDesc));
+Node* p = basic_plus_adr(klass, in_bytes(Klass::java_mirror_offset()));
 return make_load(NULL, p, TypeInstPtr::MIRROR, T_OBJECT);
 }
 //-----------------------load_klass_from_mirror_common-------------------------
 // Given a java mirror (a java.lang.Class oop), load its corresponding klass oop.
 // Use this for JVM_ACC_INTERFACE, JVM_ACC_IS_CLONEABLE, JVM_ACC_HAS_FINALIZER.
 // Fall through if (mods & mask) == bits, take the guard otherwise.
 Node* LibraryCallKit::generate_access_flags_guard(Node* kls, int modifier_mask, int modifier_bits, RegionNode* region) {
 // Branch around if the given klass has the given modifier bit set.
 // Like generate_guard, adds a new path onto the region.
-Node* modp = basic_plus_adr(kls, Klass::access_flags_offset_in_bytes() + sizeof(oopDesc));
+Node* modp = basic_plus_adr(kls, in_bytes(Klass::access_flags_offset()));
 Node* mods = make_load(NULL, modp, TypeInt::INT, T_INT);
 Node* mask = intcon(modifier_mask);
 Node* bits = intcon(modifier_bits);
 Node* mbit = _gvn.transform( new (C, 3) AndINode(mods, mask) );
 Node* cmp  = _gvn.transform( new (C, 3) CmpINode(mbit, bits) );
 query_value = gen_instanceof(obj, kls);
 _sp -= nargs;
 break;
 case vmIntrinsics::_getModifiers:
-p = basic_plus_adr(kls, Klass::modifier_flags_offset_in_bytes() + sizeof(oopDesc));
+p = basic_plus_adr(kls, in_bytes(Klass::modifier_flags_offset()));
 query_value = make_load(NULL, p, TypeInt::INT, T_INT);
 break;
 case vmIntrinsics::_isInterface:
 // (To verify this code sequence, check the asserts in JVM_IsInterface.)
 phi->add_req(null());
 if (generate_array_guard(kls, region) != NULL)
 // A guard was added.  If the guard is taken, it was an array.
 phi->add_req(makecon(TypeInstPtr::make(env()->Object_klass()->java_mirror())));
 // If we fall through, it's a plain class.  Get its _super.
-p = basic_plus_adr(kls, Klass::super_offset_in_bytes() + sizeof(oopDesc));
+p = basic_plus_adr(kls, in_bytes(Klass::super_offset()));
 kls = _gvn.transform( LoadKlassNode::make(_gvn, immutable_memory(), p, TypeRawPtr::BOTTOM, TypeKlassPtr::OBJECT_OR_NULL) );
 null_ctl = top();
 kls = null_check_oop(kls, &null_ctl);
 if (null_ctl != top()) {
 // If the guard is taken, Object.superClass is null (both klass and mirror).
 case vmIntrinsics::_getComponentType:
 if (generate_array_guard(kls, region) != NULL) {
 // Be sure to pin the oop load to the guard edge just created:
 Node* is_array_ctrl = region->in(region->req()-1);
-Node* cma = basic_plus_adr(kls, in_bytes(arrayKlass::component_mirror_offset()) + sizeof(oopDesc));
+Node* cma = basic_plus_adr(kls, in_bytes(arrayKlass::component_mirror_offset()));
 Node* cmo = make_load(is_array_ctrl, cma, TypeInstPtr::MIRROR, T_OBJECT);
 phi->add_req(cmo);
 }
 query_value = null();  // non-array case is null
 break;
 case vmIntrinsics::_getClassAccessFlags:
-p = basic_plus_adr(kls, Klass::access_flags_offset_in_bytes() + sizeof(oopDesc));
+p = basic_plus_adr(kls, in_bytes(Klass::access_flags_offset()));
 query_value = make_load(NULL, p, TypeInt::INT, T_INT);
 break;
 default:
 ShouldNotReachHere();
 void LibraryCallKit::copy_to_clone(Node* obj, Node* alloc_obj, Node* obj_size, bool is_array, bool card_mark) {
 assert(obj_size != NULL, "");
 Node* raw_obj = alloc_obj->in(1);
 assert(alloc_obj->is_CheckCastPP() && raw_obj->is_Proj() && raw_obj->in(0)->is_Allocate(), "");
+AllocateNode* alloc = NULL;
 if (ReduceBulkZeroing) {
 // We will be completely responsible for initializing this object -
 // mark Initialize node as complete.
-AllocateNode* alloc = AllocateNode::Ideal_allocation(alloc_obj, &_gvn);
+alloc = AllocateNode::Ideal_allocation(alloc_obj, &_gvn);
 // The object was just allocated - there should be no any stores!
 guarantee(alloc != NULL && alloc->maybe_set_complete(&_gvn), "");
+// Mark as complete_with_arraycopy so that on AllocateNode
+// expansion, we know this AllocateNode is initialized by an array
+// copy and a StoreStore barrier exists after the array copy.
+alloc->initialization()->set_complete_with_arraycopy();
 }
 // Copy the fastest available way.
 // TODO: generate fields copies for small objects instead.
 Node* src  = obj;
 T_OBJECT,
 false);
 }
 // Do not let reads from the cloned object float above the arraycopy.
-insert_mem_bar(Op_MemBarCPUOrder);
+if (alloc != NULL) {
+// Do not let stores that initialize this object be reordered with
+// a subsequent store that would make this object accessible by
+// other threads.
+// Record what AllocateNode this StoreStore protects so that
+// escape analysis can go from the MemBarStoreStoreNode to the
+// AllocateNode and eliminate the MemBarStoreStoreNode if possible
+// based on the escape status of the AllocateNode.
+insert_mem_bar(Op_MemBarStoreStore, alloc->proj_out(AllocateNode::RawAddress));
+} else {
+insert_mem_bar(Op_MemBarCPUOrder);
+}
 }
 //------------------------inline_native_clone----------------------------
 // Here are the simple edge cases:
 //  null receiver => normal trap
 // Plug failing path into checked_oop_disjoint_arraycopy
 if (not_subtype_ctrl != top()) {
 PreserveJVMState pjvms(this);
 set_control(not_subtype_ctrl);
 // (At this point we can assume disjoint_bases, since types differ.)
-int ek_offset = objArrayKlass::element_klass_offset_in_bytes() + sizeof(oopDesc);
+int ek_offset = in_bytes(objArrayKlass::element_klass_offset());
 Node* p1 = basic_plus_adr(dest_klass, ek_offset);
 Node* n1 = LoadKlassNode::make(_gvn, immutable_memory(), p1, TypeRawPtr::BOTTOM);
 Node* dest_elem_klass = _gvn.transform(n1);
 Node* cv = generate_checkcast_arraycopy(adr_type,
 dest_elem_klass,
 // The next memory barrier is added to avoid it. If the arraycopy can be
 // optimized away (which it can, sometimes) then we can manually remove
 // the membar also.
 //
 // Do not let reads from the cloned object float above the arraycopy.
-if (InsertMemBarAfterArraycopy || alloc != NULL)
+if (alloc != NULL) {
+// Do not let stores that initialize this object be reordered with
+// a subsequent store that would make this object accessible by
+// other threads.
+// Record what AllocateNode this StoreStore protects so that
+// escape analysis can go from the MemBarStoreStoreNode to the
+// AllocateNode and eliminate the MemBarStoreStoreNode if possible
+// based on the escape status of the AllocateNode.
+insert_mem_bar(Op_MemBarStoreStore, alloc->proj_out(AllocateNode::RawAddress));
+} else if (InsertMemBarAfterArraycopy)
 insert_mem_bar(Op_MemBarCPUOrder);
 }
 // Helper function which determines if an arraycopy immediately follows
 // Pick out the parameters required to perform a store-check
 // for the target array.  This is an optimistic check.  It will
 // look in each non-null element's class, at the desired klass's
 // super_check_offset, for the desired klass.
-int sco_offset = Klass::super_check_offset_offset_in_bytes() + sizeof(oopDesc);
+int sco_offset = in_bytes(Klass::super_check_offset_offset());
 Node* p3 = basic_plus_adr(dest_elem_klass, sco_offset);
 Node* n3 = new(C, 3) LoadINode(NULL, memory(p3), p3, _gvn.type(p3)->is_ptr());
 Node* check_offset = ConvI2X(_gvn.transform(n3));
 Node* check_value  = dest_elem_klass;

Mercurial > hg > truffle

comparison src/share/vm/opto/library_call.cpp @ 4771:22cee0ee8927