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

comparison src/share/vm/opto/memnode.cpp @ 6948:e522a00b91aa

Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works

author	Doug Simon <doug.simon@oracle.com>
date	Mon, 12 Nov 2012 23:14:12 +0100
parents	d804e148cff8
children	00af3a3a8df4

comparison

equal deleted inserted replaced

-:ae13cc658b80
+:e522a00b91aa
 case Op_AddP:             // No change to NULL-ness, so peek thru AddP's
 adr = adr->in(AddPNode::Base);
 continue;
 case Op_DecodeN:         // No change to NULL-ness, so peek thru
+case Op_DecodeNKlass:
 adr = adr->in(1);
 continue;
 case Op_EncodeP:
+case Op_EncodePKlass:
 // EncodeP node's control edge could be set by this method
 // when EncodeP node depends on CastPP node.
 //
 // Use its control edge for memory op because EncodeP may go away
 // later when it is folded with following or preceding DecodeN node.
 case Op_LoadN:            // Loading from within a klass
 case Op_LoadKlass:        // Loading from within a klass
 case Op_LoadNKlass:       // Loading from within a klass
 case Op_ConP:             // Loading from a klass
 case Op_ConN:             // Loading from a klass
+case Op_ConNKlass:        // Loading from a klass
 case Op_CreateEx:         // Sucking up the guts of an exception oop
 case Op_Con:              // Reading from TLS
 case Op_CMoveP:           // CMoveP is pinned
 case Op_CMoveN:           // CMoveN is pinned
 break;                  // No progress
 uint LoadNode::size_of() const { return sizeof(*this); }
 uint LoadNode::cmp( const Node &n ) const
 { return !Type::cmp( _type, ((LoadNode&)n)._type ); }
 const Type *LoadNode::bottom_type() const { return _type; }
 uint LoadNode::ideal_reg() const {
-return Matcher::base2reg[_type->base()];
+return _type->ideal_reg();
 }
 #ifndef PRODUCT
 void LoadNode::dump_spec(outputStream *st) const {
 MemNode::dump_spec(st);
 assert( ctl != NULL || C->get_alias_index(adr_type) != Compile::AliasIdxRaw ||
 // oop will be recorded in oop map if load crosses safepoint
 rt->isa_oopptr() || is_immutable_value(adr),
 "raw memory operations should have control edge");
 switch (bt) {
-case T_BOOLEAN: return new (C, 3) LoadUBNode(ctl, mem, adr, adr_type, rt->is_int()    );
+case T_BOOLEAN: return new (C) LoadUBNode(ctl, mem, adr, adr_type, rt->is_int()    );
-case T_BYTE:    return new (C, 3) LoadBNode (ctl, mem, adr, adr_type, rt->is_int()    );
+case T_BYTE:    return new (C) LoadBNode (ctl, mem, adr, adr_type, rt->is_int()    );
-case T_INT:     return new (C, 3) LoadINode (ctl, mem, adr, adr_type, rt->is_int()    );
+case T_INT:     return new (C) LoadINode (ctl, mem, adr, adr_type, rt->is_int()    );
-case T_CHAR:    return new (C, 3) LoadUSNode(ctl, mem, adr, adr_type, rt->is_int()    );
+case T_CHAR:    return new (C) LoadUSNode(ctl, mem, adr, adr_type, rt->is_int()    );
-case T_SHORT:   return new (C, 3) LoadSNode (ctl, mem, adr, adr_type, rt->is_int()    );
+case T_SHORT:   return new (C) LoadSNode (ctl, mem, adr, adr_type, rt->is_int()    );
-case T_LONG:    return new (C, 3) LoadLNode (ctl, mem, adr, adr_type, rt->is_long()   );
+case T_LONG:    return new (C) LoadLNode (ctl, mem, adr, adr_type, rt->is_long()   );
-case T_FLOAT:   return new (C, 3) LoadFNode (ctl, mem, adr, adr_type, rt              );
+case T_FLOAT:   return new (C) LoadFNode (ctl, mem, adr, adr_type, rt              );
-case T_DOUBLE:  return new (C, 3) LoadDNode (ctl, mem, adr, adr_type, rt              );
+case T_DOUBLE:  return new (C) LoadDNode (ctl, mem, adr, adr_type, rt              );
-case T_ADDRESS: return new (C, 3) LoadPNode (ctl, mem, adr, adr_type, rt->is_ptr()    );
+case T_ADDRESS: return new (C) LoadPNode (ctl, mem, adr, adr_type, rt->is_ptr()    );
 case T_OBJECT:
 #ifdef _LP64
 if (adr->bottom_type()->is_ptr_to_narrowoop()) {
-Node* load  = gvn.transform(new (C, 3) LoadNNode(ctl, mem, adr, adr_type, rt->make_narrowoop()));
+Node* load  = gvn.transform(new (C) LoadNNode(ctl, mem, adr, adr_type, rt->make_narrowoop()));
-return new (C, 2) DecodeNNode(load, load->bottom_type()->make_ptr());
+return new (C) DecodeNNode(load, load->bottom_type()->make_ptr());
 } else
 #endif
 {
-assert(!adr->bottom_type()->is_ptr_to_narrowoop(), "should have got back a narrow oop");
+assert(!adr->bottom_type()->is_ptr_to_narrowoop() && !adr->bottom_type()->is_ptr_to_narrowklass(), "should have got back a narrow oop");
-return new (C, 3) LoadPNode(ctl, mem, adr, adr_type, rt->is_oopptr());
+return new (C) LoadPNode(ctl, mem, adr, adr_type, rt->is_oopptr());
 }
 }
 ShouldNotReachHere();
 return (LoadNode*)NULL;
 }
 LoadLNode* LoadLNode::make_atomic(Compile *C, Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, const Type* rt) {
 bool require_atomic = true;
-return new (C, 3) LoadLNode(ctl, mem, adr, adr_type, rt->is_long(), require_atomic);
+return new (C) LoadLNode(ctl, mem, adr, adr_type, rt->is_long(), require_atomic);
 }
 if (count > 0 && fetch_autobox_base(atp, cache_low)) {
 int offset = arrayOopDesc::base_offset_in_bytes(memory_type()) - (cache_low << shift);
 // Add up all the offsets making of the address of the load
 Node* result = elements[0];
 for (int i = 1; i < count; i++) {
-result = phase->transform(new (phase->C, 3) AddXNode(result, elements[i]));
+result = phase->transform(new (phase->C) AddXNode(result, elements[i]));
 }
 // Remove the constant offset from the address and then
 // remove the scaling of the offset to recover the original index.
-result = phase->transform(new (phase->C, 3) AddXNode(result, phase->MakeConX(-offset)));
+result = phase->transform(new (phase->C) AddXNode(result, phase->MakeConX(-offset)));
 if (result->Opcode() == Op_LShiftX && result->in(2) == phase->intcon(shift)) {
 // Peel the shift off directly but wrap it in a dummy node
 // since Ideal can't return existing nodes
-result = new (phase->C, 3) RShiftXNode(result->in(1), phase->intcon(0));
+result = new (phase->C) RShiftXNode(result->in(1), phase->intcon(0));
 } else {
-result = new (phase->C, 3) RShiftXNode(result, phase->intcon(shift));
+result = new (phase->C) RShiftXNode(result, phase->intcon(shift));
 }
 #ifdef _LP64
-result = new (phase->C, 2) ConvL2INode(phase->transform(result));
+result = new (phase->C) ConvL2INode(phase->transform(result));
 #endif
 return result;
 }
 }
 }
 const Type* this_type = this->bottom_type();
 int this_index  = phase->C->get_alias_index(addr_t);
 int this_offset = addr_t->offset();
 int this_iid    = addr_t->is_oopptr()->instance_id();
 PhaseIterGVN *igvn = phase->is_IterGVN();
-Node *phi = new (igvn->C, region->req()) PhiNode(region, this_type, NULL, this_iid, this_index, this_offset);
+Node *phi = new (igvn->C) PhiNode(region, this_type, NULL, this_iid, this_index, this_offset);
 for (uint i = 1; i < region->req(); i++) {
 Node *x;
 Node* the_clone = NULL;
 if (region->in(i) == phase->C->top()) {
 x = phase->C->top();      // Dead path?  Use a dead data op
 // (Folds up type checking code.)
 assert(Opcode() == Op_LoadI, "must load an int from _super_check_offset");
 return TypeInt::make(klass->super_check_offset());
 }
 // Compute index into primary_supers array
-juint depth = (tkls->offset() - in_bytes(Klass::primary_supers_offset())) / sizeof(klassOop);
+juint depth = (tkls->offset() - in_bytes(Klass::primary_supers_offset())) / sizeof(Klass*);
 // Check for overflowing; use unsigned compare to handle the negative case.
 if( depth < ciKlass::primary_super_limit() ) {
 // The field is an element of Klass::_primary_supers.  Return its (constant) value.
 // (Folds up type checking code.)
 assert(Opcode() == Op_LoadKlass, "must load a klass from _primary_supers");
 ciKlass *ss = klass->super_of_depth(depth);
 return ss ? TypeKlassPtr::make(ss) : TypePtr::NULL_PTR;
 }
 const Type* aift = load_array_final_field(tkls, klass);
 if (aift != NULL)  return aift;
-if (tkls->offset() == in_bytes(arrayKlass::component_mirror_offset())
+if (tkls->offset() == in_bytes(ArrayKlass::component_mirror_offset())
 && klass->is_array_klass()) {
-// The field is arrayKlass::_component_mirror.  Return its (constant) value.
+// The field is ArrayKlass::_component_mirror.  Return its (constant) value.
 // (Folds up aClassConstant.getComponentType, common in Arrays.copyOf.)
 assert(Opcode() == Op_LoadP, "must load an oop from _component_mirror");
 return TypeInstPtr::make(klass->as_array_klass()->component_mirror());
 }
 if (tkls->offset() == in_bytes(Klass::java_mirror_offset())) {
 // We can still check if we are loading from the primary_supers array at a
 // shallow enough depth.  Even though the klass is not exact, entries less
 // than or equal to its super depth are correct.
 if (klass->is_loaded() ) {
-ciType *inner = klass->klass();
+ciType *inner = klass;
 while( inner->is_obj_array_klass() )
 inner = inner->as_obj_array_klass()->base_element_type();
 if( inner->is_instance_klass() &&
 !inner->as_instance_klass()->flags().is_interface() ) {
 // Compute index into primary_supers array
-juint depth = (tkls->offset() - in_bytes(Klass::primary_supers_offset())) / sizeof(klassOop);
+juint depth = (tkls->offset() - in_bytes(Klass::primary_supers_offset())) / sizeof(Klass*);
 // Check for overflowing; use unsigned compare to handle the negative case.
 if( depth < ciKlass::primary_super_limit() &&
 depth <= klass->super_depth() ) { // allow self-depth checks to handle self-check case
 // The field is an element of Klass::_primary_supers.  Return its (constant) value.
 // (Folds up type checking code.)
 //
 Node *LoadBNode::Ideal(PhaseGVN *phase, bool can_reshape) {
 Node* mem = in(MemNode::Memory);
 Node* value = can_see_stored_value(mem,phase);
 if( value && !phase->type(value)->higher_equal( _type ) ) {
-Node *result = phase->transform( new (phase->C, 3) LShiftINode(value, phase->intcon(24)) );
+Node *result = phase->transform( new (phase->C) LShiftINode(value, phase->intcon(24)) );
-return new (phase->C, 3) RShiftINode(result, phase->intcon(24));
+return new (phase->C) RShiftINode(result, phase->intcon(24));
 }
 // Identity call will handle the case where truncation is not needed.
 return LoadNode::Ideal(phase, can_reshape);
 }
 //
 Node* LoadUBNode::Ideal(PhaseGVN* phase, bool can_reshape) {
 Node* mem = in(MemNode::Memory);
 Node* value = can_see_stored_value(mem, phase);
 if (value && !phase->type(value)->higher_equal(_type))
-return new (phase->C, 3) AndINode(value, phase->intcon(0xFF));
+return new (phase->C) AndINode(value, phase->intcon(0xFF));
 // Identity call will handle the case where truncation is not needed.
 return LoadNode::Ideal(phase, can_reshape);
 }
 const Type* LoadUBNode::Value(PhaseTransform *phase) const {
 //
 Node *LoadUSNode::Ideal(PhaseGVN *phase, bool can_reshape) {
 Node* mem = in(MemNode::Memory);
 Node* value = can_see_stored_value(mem,phase);
 if( value && !phase->type(value)->higher_equal( _type ) )
-return new (phase->C, 3) AndINode(value,phase->intcon(0xFFFF));
+return new (phase->C) AndINode(value,phase->intcon(0xFFFF));
 // Identity call will handle the case where truncation is not needed.
 return LoadNode::Ideal(phase, can_reshape);
 }
 const Type* LoadUSNode::Value(PhaseTransform *phase) const {
 //
 Node *LoadSNode::Ideal(PhaseGVN *phase, bool can_reshape) {
 Node* mem = in(MemNode::Memory);
 Node* value = can_see_stored_value(mem,phase);
 if( value && !phase->type(value)->higher_equal( _type ) ) {
-Node *result = phase->transform( new (phase->C, 3) LShiftINode(value, phase->intcon(16)) );
+Node *result = phase->transform( new (phase->C) LShiftINode(value, phase->intcon(16)) );
-return new (phase->C, 3) RShiftINode(result, phase->intcon(16));
+return new (phase->C) RShiftINode(result, phase->intcon(16));
 }
 // Identity call will handle the case where truncation is not needed.
 return LoadNode::Ideal(phase, can_reshape);
 }
 // Polymorphic factory method:
 Node *LoadKlassNode::make( PhaseGVN& gvn, Node *mem, Node *adr, const TypePtr* at, const TypeKlassPtr *tk ) {
 Compile* C = gvn.C;
 Node *ctl = NULL;
 // sanity check the alias category against the created node type
-const TypeOopPtr *adr_type = adr->bottom_type()->isa_oopptr();
+const TypePtr *adr_type = adr->bottom_type()->isa_ptr();
-assert(adr_type != NULL, "expecting TypeOopPtr");
+assert(adr_type != NULL, "expecting TypeKlassPtr");
 #ifdef _LP64
-if (adr_type->is_ptr_to_narrowoop()) {
+if (adr_type->is_ptr_to_narrowklass()) {
-Node* load_klass = gvn.transform(new (C, 3) LoadNKlassNode(ctl, mem, adr, at, tk->make_narrowoop()));
+assert(UseCompressedKlassPointers, "no compressed klasses");
-return new (C, 2) DecodeNNode(load_klass, load_klass->bottom_type()->make_ptr());
+Node* load_klass = gvn.transform(new (C) LoadNKlassNode(ctl, mem, adr, at, tk->make_narrowklass()));
+return new (C) DecodeNKlassNode(load_klass, load_klass->bottom_type()->make_ptr());
 }
 #endif
-assert(!adr_type->is_ptr_to_narrowoop(), "should have got back a narrow oop");
+assert(!adr_type->is_ptr_to_narrowklass() && !adr_type->is_ptr_to_narrowoop(), "should have got back a narrow oop");
-return new (C, 3) LoadKlassNode(ctl, mem, adr, at, tk);
+return new (C) LoadKlassNode(ctl, mem, adr, at, tk);
 }
 //------------------------------Value------------------------------------------
 const Type *LoadKlassNode::Value( PhaseTransform *phase ) const {
 return klass_value_common(phase);
 if (tkls != NULL && !StressReflectiveCode) {
 ciKlass* klass = tkls->klass();
 if( !klass->is_loaded() )
 return _type;             // Bail out if not loaded
 if( klass->is_obj_array_klass() &&
-tkls->offset() == in_bytes(objArrayKlass::element_klass_offset())) {
+tkls->offset() == in_bytes(ObjArrayKlass::element_klass_offset())) {
 ciKlass* elem = klass->as_obj_array_klass()->element_klass();
 // // Always returning precise element type is incorrect,
 // // e.g., element type could be object and array may contain strings
 // return TypeKlassPtr::make(TypePtr::Constant, elem, 0);
 if (allocated_klass != NULL) {
 return allocated_klass;
 }
 }
-// Simplify k.java_mirror.as_klass to plain k, where k is a klassOop.
+// Simplify k.java_mirror.as_klass to plain k, where k is a Klass*.
-// Simplify ak.component_mirror.array_klass to plain ak, ak an arrayKlass.
+// Simplify ak.component_mirror.array_klass to plain ak, ak an ArrayKlass.
 // See inline_native_Class_query for occurrences of these patterns.
 // Java Example:  x.getClass().isAssignableFrom(y)
 // Java Example:  Array.newInstance(x.getClass().getComponentType(), n)
 //
 // This improves reflective code, often making the Class
 // mirror go completely dead.  (Current exception:  Class
 // mirrors may appear in debug info, but we could clean them out by
-// introducing a new debug info operator for klassOop.java_mirror).
+// introducing a new debug info operator for Klass*.java_mirror).
 if (toop->isa_instptr() && toop->klass() == phase->C->env()->Class_klass()
 && (offset == java_lang_Class::klass_offset_in_bytes() ||
 offset == java_lang_Class::array_klass_offset_in_bytes())) {
 // We are loading a special hidden field from a Class mirror,
-// the field which points to its Klass or arrayKlass metaobject.
+// the field which points to its Klass or ArrayKlass metaobject.
 if (base->is_Load()) {
 Node* adr2 = base->in(MemNode::Address);
 const TypeKlassPtr* tkls = phase->type(adr2)->isa_klassptr();
 if (tkls != NULL && !tkls->empty()
 && (tkls->klass()->is_instance_klass() ||
 tkls->klass()->is_array_klass())
 && adr2->is_AddP()
 ) {
 int mirror_field = in_bytes(Klass::java_mirror_offset());
 if (offset == java_lang_Class::array_klass_offset_in_bytes()) {
-mirror_field = in_bytes(arrayKlass::component_mirror_offset());
+mirror_field = in_bytes(ArrayKlass::component_mirror_offset());
 }
 if (tkls->offset() == mirror_field) {
 return adr2->in(AddPNode::Base);
 }
 }
 const Type *LoadNKlassNode::Value( PhaseTransform *phase ) const {
 const Type *t = klass_value_common(phase);
 if (t == Type::TOP)
 return t;
-return t->make_narrowoop();
+return t->make_narrowklass();
 }
 //------------------------------Identity---------------------------------------
 // To clean up reflective code, simplify k.java_mirror.as_klass to narrow k.
 // Also feed through the klass in Allocate(...klass...)._klass.
 Node* LoadNKlassNode::Identity( PhaseTransform *phase ) {
 Node *x = klass_identity_common(phase);
 const Type *t = phase->type( x );
 if( t == Type::TOP ) return x;
-if( t->isa_narrowoop()) return x;
+if( t->isa_narrowklass()) return x;
+assert (!t->isa_narrowoop(), "no narrow oop here");
-return phase->transform(new (phase->C, 2) EncodePNode(x, t->make_narrowoop()));
+return phase->transform(new (phase->C) EncodePKlassNode(x, t->make_narrowklass()));
 }
 //------------------------------Value-----------------------------------------
 const Type *LoadRangeNode::Value( PhaseTransform *phase ) const {
 // Either input is TOP ==> the result is TOP
 assert( C->get_alias_index(adr_type) != Compile::AliasIdxRaw ||
 ctl != NULL, "raw memory operations should have control edge");
 switch (bt) {
 case T_BOOLEAN:
-case T_BYTE:    return new (C, 4) StoreBNode(ctl, mem, adr, adr_type, val);
+case T_BYTE:    return new (C) StoreBNode(ctl, mem, adr, adr_type, val);
-case T_INT:     return new (C, 4) StoreINode(ctl, mem, adr, adr_type, val);
+case T_INT:     return new (C) StoreINode(ctl, mem, adr, adr_type, val);
 case T_CHAR:
-case T_SHORT:   return new (C, 4) StoreCNode(ctl, mem, adr, adr_type, val);
+case T_SHORT:   return new (C) StoreCNode(ctl, mem, adr, adr_type, val);
-case T_LONG:    return new (C, 4) StoreLNode(ctl, mem, adr, adr_type, val);
+case T_LONG:    return new (C) StoreLNode(ctl, mem, adr, adr_type, val);
-case T_FLOAT:   return new (C, 4) StoreFNode(ctl, mem, adr, adr_type, val);
+case T_FLOAT:   return new (C) StoreFNode(ctl, mem, adr, adr_type, val);
-case T_DOUBLE:  return new (C, 4) StoreDNode(ctl, mem, adr, adr_type, val);
+case T_DOUBLE:  return new (C) StoreDNode(ctl, mem, adr, adr_type, val);
+case T_METADATA:
 case T_ADDRESS:
 case T_OBJECT:
 #ifdef _LP64
-if (adr->bottom_type()->is_ptr_to_narrowoop() ||
+if (adr->bottom_type()->is_ptr_to_narrowoop()) {
-(UseCompressedOops && val->bottom_type()->isa_klassptr() &&
+val = gvn.transform(new (C) EncodePNode(val, val->bottom_type()->make_narrowoop()));
-adr->bottom_type()->isa_rawptr())) {
+return new (C) StoreNNode(ctl, mem, adr, adr_type, val);
-val = gvn.transform(new (C, 2) EncodePNode(val, val->bottom_type()->make_narrowoop()));
+} else if (adr->bottom_type()->is_ptr_to_narrowklass() ||
-return new (C, 4) StoreNNode(ctl, mem, adr, adr_type, val);
+(UseCompressedKlassPointers && val->bottom_type()->isa_klassptr() &&
-} else
+adr->bottom_type()->isa_rawptr())) {
+val = gvn.transform(new (C) EncodePKlassNode(val, val->bottom_type()->make_narrowklass()));
+return new (C) StoreNKlassNode(ctl, mem, adr, adr_type, val);
+}
 #endif
 {
-return new (C, 4) StorePNode(ctl, mem, adr, adr_type, val);
+return new (C) StorePNode(ctl, mem, adr, adr_type, val);
 }
 }
 ShouldNotReachHere();
 return (StoreNode*)NULL;
 }
 StoreLNode* StoreLNode::make_atomic(Compile *C, Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, Node* val) {
 bool require_atomic = true;
-return new (C, 4) StoreLNode(ctl, mem, adr, adr_type, val, require_atomic);
+return new (C) StoreLNode(ctl, mem, adr, adr_type, val, require_atomic);
 }
 //--------------------------bottom_type----------------------------------------
 const Type *StoreNode::bottom_type() const {
 {
 return bottom_type();
 }
 //=============================================================================
-LoadStoreNode::LoadStoreNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex ) : Node(5) {
+//----------------------------------LoadStoreNode------------------------------
+LoadStoreNode::LoadStoreNode( Node *c, Node *mem, Node *adr, Node *val, const TypePtr* at, const Type* rt, uint required )
+: Node(required),
+_type(rt),
+_adr_type(at)
+{
 init_req(MemNode::Control, c  );
 init_req(MemNode::Memory , mem);
 init_req(MemNode::Address, adr);
 init_req(MemNode::ValueIn, val);
-init_req(         ExpectedIn, ex );
 init_class_id(Class_LoadStore);
+}
+uint LoadStoreNode::ideal_reg() const {
+return _type->ideal_reg();
+}
+bool LoadStoreNode::result_not_used() const {
+for( DUIterator_Fast imax, i = fast_outs(imax); i < imax; i++ ) {
+Node *x = fast_out(i);
+if (x->Opcode() == Op_SCMemProj) continue;
+return false;
+}
+return true;
+}
+uint LoadStoreNode::size_of() const { return sizeof(*this); }
+//=============================================================================
+//----------------------------------LoadStoreConditionalNode--------------------
+LoadStoreConditionalNode::LoadStoreConditionalNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex ) : LoadStoreNode(c, mem, adr, val, NULL, TypeInt::BOOL, 5) {
+init_req(ExpectedIn, ex );
 }
 //=============================================================================
 //-------------------------------adr_type--------------------------------------
 // Do we Match on this edge index or not?  Do not match memory
 if( adr->Opcode() != Op_AddP ) Unimplemented();
 Node *base = adr->in(1);
 Node *zero = phase->makecon(TypeLong::ZERO);
 Node *off  = phase->MakeConX(BytesPerLong);
-mem = new (phase->C, 4) StoreLNode(in(0),mem,adr,atp,zero);
+mem = new (phase->C) StoreLNode(in(0),mem,adr,atp,zero);
 count--;
 while( count-- ) {
 mem = phase->transform(mem);
-adr = phase->transform(new (phase->C, 4) AddPNode(base,adr,off));
+adr = phase->transform(new (phase->C) AddPNode(base,adr,off));
-mem = new (phase->C, 4) StoreLNode(in(0),mem,adr,atp,zero);
+mem = new (phase->C) StoreLNode(in(0),mem,adr,atp,zero);
 }
 return mem;
 }
 //----------------------------step_through----------------------------------
 Compile* C = phase->C;
 intptr_t offset = start_offset;
 int unit = BytesPerLong;
 if ((offset % unit) != 0) {
-Node* adr = new (C, 4) AddPNode(dest, dest, phase->MakeConX(offset));
+Node* adr = new (C) AddPNode(dest, dest, phase->MakeConX(offset));
 adr = phase->transform(adr);
 const TypePtr* atp = TypeRawPtr::BOTTOM;
 mem = StoreNode::make(*phase, ctl, mem, adr, atp, phase->zerocon(T_INT), T_INT);
 mem = phase->transform(mem);
 offset += BytesPerInt;
 Node* zend  = end_offset;
 // Scale to the unit required by the CPU:
 if (!Matcher::init_array_count_is_in_bytes) {
 Node* shift = phase->intcon(exact_log2(unit));
-zbase = phase->transform( new(C,3) URShiftXNode(zbase, shift) );
+zbase = phase->transform( new(C) URShiftXNode(zbase, shift) );
-zend  = phase->transform( new(C,3) URShiftXNode(zend,  shift) );
+zend  = phase->transform( new(C) URShiftXNode(zend,  shift) );
 }
-Node* zsize = phase->transform( new(C,3) SubXNode(zend, zbase) );
+Node* zsize = phase->transform( new(C) SubXNode(zend, zbase) );
 Node* zinit = phase->zerocon((unit == BytesPerLong) ? T_LONG : T_INT);
 // Bulk clear double-words
-Node* adr = phase->transform( new(C,4) AddPNode(dest, dest, start_offset) );
+Node* adr = phase->transform( new(C) AddPNode(dest, dest, start_offset) );
-mem = new (C, 4) ClearArrayNode(ctl, mem, zsize, adr);
+mem = new (C) ClearArrayNode(ctl, mem, zsize, adr);
 return phase->transform(mem);
 }
 Node* ClearArrayNode::clear_memory(Node* ctl, Node* mem, Node* dest,
 intptr_t start_offset,
 if (done_offset > start_offset) {
 mem = clear_memory(ctl, mem, dest,
 start_offset, phase->MakeConX(done_offset), phase);
 }
 if (done_offset < end_offset) { // emit the final 32-bit store
-Node* adr = new (C, 4) AddPNode(dest, dest, phase->MakeConX(done_offset));
+Node* adr = new (C) AddPNode(dest, dest, phase->MakeConX(done_offset));
 adr = phase->transform(adr);
 const TypePtr* atp = TypeRawPtr::BOTTOM;
 mem = StoreNode::make(*phase, ctl, mem, adr, atp, phase->zerocon(T_INT), T_INT);
 mem = phase->transform(mem);
 done_offset += BytesPerInt;
 return (&n == this);          // Always fail except on self
 }
 //------------------------------make-------------------------------------------
 MemBarNode* MemBarNode::make(Compile* C, int opcode, int atp, Node* pn) {
-int len = Precedent + (pn == NULL? 0: 1);
 switch (opcode) {
-case Op_MemBarAcquire:   return new(C, len) MemBarAcquireNode(C,  atp, pn);
+case Op_MemBarAcquire:   return new(C) MemBarAcquireNode(C,  atp, pn);
-case Op_MemBarRelease:   return new(C, len) MemBarReleaseNode(C,  atp, pn);
+case Op_MemBarRelease:   return new(C) MemBarReleaseNode(C,  atp, pn);
-case Op_MemBarAcquireLock: return new(C, len) MemBarAcquireLockNode(C,  atp, pn);
+case Op_MemBarAcquireLock: return new(C) MemBarAcquireLockNode(C,  atp, pn);
-case Op_MemBarReleaseLock: return new(C, len) MemBarReleaseLockNode(C,  atp, pn);
+case Op_MemBarReleaseLock: return new(C) MemBarReleaseLockNode(C,  atp, pn);
-case Op_MemBarVolatile:  return new(C, len) MemBarVolatileNode(C, atp, pn);
+case Op_MemBarVolatile:  return new(C) MemBarVolatileNode(C, atp, pn);
-case Op_MemBarCPUOrder:  return new(C, len) MemBarCPUOrderNode(C, atp, pn);
+case Op_MemBarCPUOrder:  return new(C) MemBarCPUOrderNode(C, atp, pn);
-case Op_Initialize:      return new(C, len) InitializeNode(C,     atp, pn);
+case Op_Initialize:      return new(C) InitializeNode(C,     atp, pn);
-case Op_MemBarStoreStore: return new(C, len) MemBarStoreStoreNode(C,  atp, pn);
+case Op_MemBarStoreStore: return new(C) MemBarStoreStoreNode(C,  atp, pn);
 default:                 ShouldNotReachHere(); return NULL;
 }
 }
 //------------------------------Ideal------------------------------------------
 PhaseIterGVN* igvn = phase->is_IterGVN();
 igvn->replace_node(proj_out(TypeFunc::Memory), in(TypeFunc::Memory));
 igvn->replace_node(proj_out(TypeFunc::Control), in(TypeFunc::Control));
 // Must return either the original node (now dead) or a new node
 // (Do not return a top here, since that would break the uniqueness of top.)
-return new (phase->C, 1) ConINode(TypeInt::ZERO);
+return new (phase->C) ConINode(TypeInt::ZERO);
 }
 }
 }
 return NULL;
 }
 // Construct projections for memory.
 Node *MemBarNode::match( const ProjNode *proj, const Matcher *m ) {
 switch (proj->_con) {
 case TypeFunc::Control:
 case TypeFunc::Memory:
-return new (m->C, 1) MachProjNode(this,proj->_con,RegMask::Empty,MachProjNode::unmatched_proj);
+return new (m->C) MachProjNode(this,proj->_con,RegMask::Empty,MachProjNode::unmatched_proj);
 }
 ShouldNotReachHere();
 return NULL;
 }
 Node* InitializeNode::make_raw_address(intptr_t offset,
 PhaseTransform* phase) {
 Node* addr = in(RawAddress);
 if (offset != 0) {
 Compile* C = phase->C;
-addr = phase->transform( new (C, 4) AddPNode(C->top(), addr,
+addr = phase->transform( new (C) AddPNode(C->top(), addr,
 phase->MakeConX(offset)) );
 }
 return addr;
 }
 }
 // Make a new, untransformed MergeMem with the same base as 'mem'.
 // If mem is itself a MergeMem, populate the result with the same edges.
 MergeMemNode* MergeMemNode::make(Compile* C, Node* mem) {
-return new(C, 1+Compile::AliasIdxRaw) MergeMemNode(mem);
+return new(C) MergeMemNode(mem);
 }
 //------------------------------cmp--------------------------------------------
 uint MergeMemNode::hash() const { return NO_HASH; }
 uint MergeMemNode::cmp( const Node &n ) const {

Mercurial > hg > graal-compiler

comparison src/share/vm/opto/memnode.cpp @ 6948:e522a00b91aa