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

comparison src/share/vm/opto/memnode.cpp @ 235:9c2ecc2ffb12 jdk7-b31

Merge

author	trims
date	Fri, 11 Jul 2008 01:14:44 -0700
parents	d1605aabd0a1 1dd146f17531
children	02a35ad4adf8

comparison

equal deleted inserted replaced

-:de141433919f
+:9c2ecc2ffb12
 #endif
 Node *MemNode::optimize_simple_memory_chain(Node *mchain, const TypePtr *t_adr, PhaseGVN *phase) {
 const TypeOopPtr *tinst = t_adr->isa_oopptr();
-if (tinst == NULL || !tinst->is_instance_field())
+if (tinst == NULL || !tinst->is_known_instance_field())
 return mchain;  // don't try to optimize non-instance types
 uint instance_id = tinst->instance_id();
 Node *prev = NULL;
 Node *result = mchain;
 while (prev != result) {
 return result;
 }
 Node *MemNode::optimize_memory_chain(Node *mchain, const TypePtr *t_adr, PhaseGVN *phase) {
 const TypeOopPtr *t_oop = t_adr->isa_oopptr();
-bool is_instance = (t_oop != NULL) && t_oop->is_instance_field();
+bool is_instance = (t_oop != NULL) && t_oop->is_known_instance_field();
 PhaseIterGVN *igvn = phase->is_IterGVN();
 Node *result = mchain;
 result = optimize_simple_memory_chain(result, t_adr, phase);
 if (is_instance && igvn != NULL  && result->is_Phi()) {
 PhiNode *mphi = result->as_Phi();
 assert(mphi->bottom_type() == Type::MEMORY, "memory phi required");
 const TypePtr *t = mphi->adr_type();
 if (t == TypePtr::BOTTOM || t == TypeRawPtr::BOTTOM ||
-t->isa_oopptr() && !t->is_oopptr()->is_instance() &&
+t->isa_oopptr() && !t->is_oopptr()->is_known_instance() &&
-t->is_oopptr()->cast_to_instance(t_oop->instance_id()) == t_oop) {
+t->is_oopptr()->cast_to_instance_id(t_oop->instance_id()) == t_oop) {
 // clone the Phi with our address type
 result = mphi->split_out_instance(t_adr, igvn);
 } else {
 assert(phase->C->get_alias_index(t) == phase->C->get_alias_index(t_adr), "correct memory chain");
 }
 if (known_identical) {
 // From caller, can_see_stored_value will consult find_captured_store.
 return mem;         // let caller handle steps (c), (d)
 }
-} else if (addr_t != NULL && addr_t->is_instance_field()) {
+} else if (addr_t != NULL && addr_t->is_known_instance_field()) {
 // Can't use optimize_simple_memory_chain() since it needs PhaseGVN.
 if (mem->is_Proj() && mem->in(0)->is_Call()) {
 CallNode *call = mem->in(0)->as_Call();
 if (!call->may_modify(addr_t, phase)) {
 mem = call->in(TypeFunc::Memory);
 case T_DOUBLE:  return new (C, 3) 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_OBJECT:
 #ifdef _LP64
 if (adr->bottom_type()->is_ptr_to_narrowoop()) {
-const TypeNarrowOop* narrowtype;
+Node* load  = gvn.transform(new (C, 3) LoadNNode(ctl, mem, adr, adr_type, rt->make_narrowoop()));
-if (rt->isa_narrowoop()) {
+return new (C, 2) DecodeNNode(load, load->bottom_type()->make_ptr());
-narrowtype = rt->is_narrowoop();
-} else {
-narrowtype = rt->is_oopptr()->make_narrowoop();
-}
-Node* load  = gvn.transform(new (C, 3) LoadNNode(ctl, mem, adr, adr_type, narrowtype));
-return DecodeNNode::decode(&gvn, load);
 } else
 #endif
 {
 assert(!adr->bottom_type()->is_ptr_to_narrowoop(), "should have got back a narrow oop");
 return new (C, 3) LoadPNode(ctl, mem, adr, adr_type, rt->is_oopptr());
 bool LoadNode::is_instance_field_load_with_local_phi(Node* ctrl) {
 if( in(MemNode::Memory)->is_Phi() && in(MemNode::Memory)->in(0) == ctrl &&
 in(MemNode::Address)->is_AddP() ) {
 const TypeOopPtr* t_oop = in(MemNode::Address)->bottom_type()->isa_oopptr();
 // Only instances.
-if( t_oop != NULL && t_oop->is_instance_field() &&
+if( t_oop != NULL && t_oop->is_known_instance_field() &&
 t_oop->offset() != Type::OffsetBot &&
 t_oop->offset() != Type::OffsetTop) {
 return true;
 }
 }
 Node* address = in(MemNode::Address);
 const TypePtr *addr_t = phase->type(address)->isa_ptr();
 const TypeOopPtr *t_oop = addr_t->isa_oopptr();
 assert(mem->is_Phi() && (t_oop != NULL) &&
-t_oop->is_instance_field(), "invalide conditions");
+t_oop->is_known_instance_field(), "invalide conditions");
 Node *region = mem->in(0);
 if (region == NULL) {
 return NULL; // Wait stable graph
 }
 set_req(MemNode::Memory, opt_mem);
 return this;
 }
 const TypeOopPtr *t_oop = addr_t->isa_oopptr();
 if (can_reshape && opt_mem->is_Phi() &&
-(t_oop != NULL) && t_oop->is_instance_field()) {
+(t_oop != NULL) && t_oop->is_known_instance_field()) {
 // Split instance field load through Phi.
 Node* result = split_through_phi(phase);
 if (result != NULL) return result;
 }
 }
 if (value != NULL && value->is_Con())
 return value->bottom_type();
 }
 const TypeOopPtr *tinst = tp->isa_oopptr();
-if (tinst != NULL && tinst->is_instance_field()) {
+if (tinst != NULL && tinst->is_known_instance_field()) {
 // If we have an instance type and our memory input is the
 // programs's initial memory state, there is no matching store,
 // so just return a zero of the appropriate type
 Node *mem = in(MemNode::Memory);
 if (mem->is_Parm() && mem->in(0)->is_Start()) {
 // sanity check the alias category against the created node type
 const TypeOopPtr *adr_type = adr->bottom_type()->isa_oopptr();
 assert(adr_type != NULL, "expecting TypeOopPtr");
 #ifdef _LP64
 if (adr_type->is_ptr_to_narrowoop()) {
-const TypeNarrowOop* narrowtype = tk->is_oopptr()->make_narrowoop();
+Node* load_klass = gvn.transform(new (C, 3) LoadNKlassNode(ctl, mem, adr, at, tk->make_narrowoop()));
-Node* load_klass = gvn.transform(new (C, 3) LoadNKlassNode(ctl, mem, adr, at, narrowtype));
+return new (C, 2) DecodeNNode(load_klass, load_klass->bottom_type()->make_ptr());
-return DecodeNNode::decode(&gvn, load_klass);
 }
 #endif
 assert(!adr_type->is_ptr_to_narrowoop(), "should have got back a narrow oop");
 return new (C, 3) LoadKlassNode(ctl, mem, adr, at, tk);
 }
 //------------------------------Value------------------------------------------
 const Type *LoadNKlassNode::Value( PhaseTransform *phase ) const {
 const Type *t = klass_value_common(phase);
+if (t == Type::TOP)
-if (t == TypePtr::NULL_PTR) {
+return t;
-return TypeNarrowOop::NULL_PTR;
-}
+return t->make_narrowoop();
-if (t != Type::TOP && !t->isa_narrowoop()) {
-assert(t->is_oopptr(), "sanity");
-t = t->is_oopptr()->make_narrowoop();
-}
-return t;
 }
 //------------------------------Identity---------------------------------------
 // To clean up reflective code, simplify k.java_mirror.as_klass to narrow k.
 // Also feed through the klass in Allocate(...klass...)._klass.
 const Type *t = phase->type( x );
 if( t == Type::TOP ) return x;
 if( t->isa_narrowoop()) return x;
-return EncodePNode::encode(phase, x);
+return phase->transform(new (phase->C, 2) EncodePNode(x, t->make_narrowoop()));
 }
 //------------------------------Value-----------------------------------------
 const Type *LoadRangeNode::Value( PhaseTransform *phase ) const {
 // Either input is TOP ==> the result is TOP
 case T_OBJECT:
 #ifdef _LP64
 if (adr->bottom_type()->is_ptr_to_narrowoop() ||
 (UseCompressedOops && val->bottom_type()->isa_klassptr() &&
 adr->bottom_type()->isa_rawptr())) {
-const TypePtr* type = val->bottom_type()->is_ptr();
+val = gvn.transform(new (C, 2) EncodePNode(val, val->bottom_type()->make_narrowoop()));
-Node* cp = EncodePNode::encode(&gvn, val);
+return new (C, 4) StoreNNode(ctl, mem, adr, adr_type, val);
-return new (C, 4) StoreNNode(ctl, mem, adr, adr_type, cp);
 } else
 #endif
 {
 return new (C, 4) StorePNode(ctl, mem, adr, adr_type, val);
 }
 }
 ShouldNotReachHere();
 return (StoreNode*)NULL;
 }
 bool StoreNode::value_never_loaded( PhaseTransform *phase) const {
 Node *adr = in(Address);
 const TypeOopPtr *adr_oop = phase->type(adr)->isa_oopptr();
 if (adr_oop == NULL)
 return false;
-if (!adr_oop->is_instance_field())
+if (!adr_oop->is_known_instance_field())
 return false; // if not a distinct instance, there may be aliases of the address
 for (DUIterator_Fast imax, i = adr->fast_outs(imax); i < imax; i++) {
 Node *use = adr->fast_out(i);
 int opc = use->Opcode();
 if (use->is_Load() || use->is_LoadStore()) {

Mercurial > hg > truffle

comparison src/share/vm/opto/memnode.cpp @ 235:9c2ecc2ffb12 jdk7-b31