Mercurial > hg > truffle

comparison src/share/vm/opto/memnode.cpp @ 6853:d804e148cff8

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Merge
author kvn
date Fri, 12 Oct 2012 09:22:52 -0700
parents d8ce2825b193 8e47bac5643a
children 00af3a3a8df4
comparison
equal deleted inserted replaced
6842:b9a9ed0f8eeb 6853:d804e148cff8
712 case Op_AddP: // No change to NULL-ness, so peek thru AddP's 712 case Op_AddP: // No change to NULL-ness, so peek thru AddP's
713 adr = adr->in(AddPNode::Base); 713 adr = adr->in(AddPNode::Base);
714 continue; 714 continue;
715 715
716 case Op_DecodeN: // No change to NULL-ness, so peek thru 716 case Op_DecodeN: // No change to NULL-ness, so peek thru
717 case Op_DecodeNKlass:
717 adr = adr->in(1); 718 adr = adr->in(1);
718 continue; 719 continue;
719 720
720 case Op_EncodeP: 721 case Op_EncodeP:
722 case Op_EncodePKlass:
721 // EncodeP node's control edge could be set by this method 723 // EncodeP node's control edge could be set by this method
722 // when EncodeP node depends on CastPP node. 724 // when EncodeP node depends on CastPP node.
723 // 725 //
724 // Use its control edge for memory op because EncodeP may go away 726 // Use its control edge for memory op because EncodeP may go away
725 // later when it is folded with following or preceding DecodeN node. 727 // later when it is folded with following or preceding DecodeN node.
792 case Op_LoadN: // Loading from within a klass 794 case Op_LoadN: // Loading from within a klass
793 case Op_LoadKlass: // Loading from within a klass 795 case Op_LoadKlass: // Loading from within a klass
794 case Op_LoadNKlass: // Loading from within a klass 796 case Op_LoadNKlass: // Loading from within a klass
795 case Op_ConP: // Loading from a klass 797 case Op_ConP: // Loading from a klass
796 case Op_ConN: // Loading from a klass 798 case Op_ConN: // Loading from a klass
799 case Op_ConNKlass: // Loading from a klass
797 case Op_CreateEx: // Sucking up the guts of an exception oop 800 case Op_CreateEx: // Sucking up the guts of an exception oop
798 case Op_Con: // Reading from TLS 801 case Op_Con: // Reading from TLS
799 case Op_CMoveP: // CMoveP is pinned 802 case Op_CMoveP: // CMoveP is pinned
800 case Op_CMoveN: // CMoveN is pinned 803 case Op_CMoveN: // CMoveN is pinned
801 break; // No progress 804 break; // No progress
898 Node* load = gvn.transform(new (C) LoadNNode(ctl, mem, adr, adr_type, rt->make_narrowoop())); 901 Node* load = gvn.transform(new (C) LoadNNode(ctl, mem, adr, adr_type, rt->make_narrowoop()));
899 return new (C) DecodeNNode(load, load->bottom_type()->make_ptr()); 902 return new (C) DecodeNNode(load, load->bottom_type()->make_ptr());
900 } else 903 } else
901 #endif 904 #endif
902 { 905 {
903 assert(!adr->bottom_type()->is_ptr_to_narrowoop(), "should have got back a narrow oop"); 906 assert(!adr->bottom_type()->is_ptr_to_narrowoop() && !adr->bottom_type()->is_ptr_to_narrowklass(), "should have got back a narrow oop");
904 return new (C) LoadPNode(ctl, mem, adr, adr_type, rt->is_oopptr()); 907 return new (C) LoadPNode(ctl, mem, adr, adr_type, rt->is_oopptr());
905 } 908 }
906 } 909 }
907 ShouldNotReachHere(); 910 ShouldNotReachHere();
908 return (LoadNode*)NULL; 911 return (LoadNode*)NULL;
1892 Node *ctl = NULL; 1895 Node *ctl = NULL;
1893 // sanity check the alias category against the created node type 1896 // sanity check the alias category against the created node type
1894 const TypePtr *adr_type = adr->bottom_type()->isa_ptr(); 1897 const TypePtr *adr_type = adr->bottom_type()->isa_ptr();
1895 assert(adr_type != NULL, "expecting TypeKlassPtr"); 1898 assert(adr_type != NULL, "expecting TypeKlassPtr");
1896 #ifdef _LP64 1899 #ifdef _LP64
1897 if (adr_type->is_ptr_to_narrowoop()) { 1900 if (adr_type->is_ptr_to_narrowklass()) {
1898 assert(UseCompressedKlassPointers, "no compressed klasses"); 1901 assert(UseCompressedKlassPointers, "no compressed klasses");
1899 Node* load_klass = gvn.transform(new (C) LoadNKlassNode(ctl, mem, adr, at, tk->make_narrowoop())); 1902 Node* load_klass = gvn.transform(new (C) LoadNKlassNode(ctl, mem, adr, at, tk->make_narrowklass()));
1900 return new (C) DecodeNNode(load_klass, load_klass->bottom_type()->make_ptr()); 1903 return new (C) DecodeNKlassNode(load_klass, load_klass->bottom_type()->make_ptr());
1901 } 1904 }
1902 #endif 1905 #endif
1903 assert(!adr_type->is_ptr_to_narrowoop(), "should have got back a narrow oop"); 1906 assert(!adr_type->is_ptr_to_narrowklass() && !adr_type->is_ptr_to_narrowoop(), "should have got back a narrow oop");
1904 return new (C) LoadKlassNode(ctl, mem, adr, at, tk); 1907 return new (C) LoadKlassNode(ctl, mem, adr, at, tk);
1905 } 1908 }
1906 1909
1907 //------------------------------Value------------------------------------------ 1910 //------------------------------Value------------------------------------------
1908 const Type *LoadKlassNode::Value( PhaseTransform *phase ) const { 1911 const Type *LoadKlassNode::Value( PhaseTransform *phase ) const {
2108 const Type *LoadNKlassNode::Value( PhaseTransform *phase ) const { 2111 const Type *LoadNKlassNode::Value( PhaseTransform *phase ) const {
2109 const Type *t = klass_value_common(phase); 2112 const Type *t = klass_value_common(phase);
2110 if (t == Type::TOP) 2113 if (t == Type::TOP)
2111 return t; 2114 return t;
2112 2115
2113 return t->make_narrowoop(); 2116 return t->make_narrowklass();
2114 } 2117 }
2115 2118
2116 //------------------------------Identity--------------------------------------- 2119 //------------------------------Identity---------------------------------------
2117 // To clean up reflective code, simplify k.java_mirror.as_klass to narrow k. 2120 // To clean up reflective code, simplify k.java_mirror.as_klass to narrow k.
2118 // Also feed through the klass in Allocate(...klass...)._klass. 2121 // Also feed through the klass in Allocate(...klass...)._klass.
2119 Node* LoadNKlassNode::Identity( PhaseTransform *phase ) { 2122 Node* LoadNKlassNode::Identity( PhaseTransform *phase ) {
2120 Node *x = klass_identity_common(phase); 2123 Node *x = klass_identity_common(phase);
2121 2124
2122 const Type *t = phase->type( x ); 2125 const Type *t = phase->type( x );
2123 if( t == Type::TOP ) return x; 2126 if( t == Type::TOP ) return x;
2124 if( t->isa_narrowoop()) return x; 2127 if( t->isa_narrowklass()) return x;
2125 2128 assert (!t->isa_narrowoop(), "no narrow oop here");
2126 return phase->transform(new (phase->C) EncodePNode(x, t->make_narrowoop())); 2129
2130 return phase->transform(new (phase->C) EncodePKlassNode(x, t->make_narrowklass()));
2127 } 2131 }
2128 2132
2129 //------------------------------Value----------------------------------------- 2133 //------------------------------Value-----------------------------------------
2130 const Type *LoadRangeNode::Value( PhaseTransform *phase ) const { 2134 const Type *LoadRangeNode::Value( PhaseTransform *phase ) const {
2131 // Either input is TOP ==> the result is TOP 2135 // Either input is TOP ==> the result is TOP
2226 case T_DOUBLE: return new (C) StoreDNode(ctl, mem, adr, adr_type, val); 2230 case T_DOUBLE: return new (C) StoreDNode(ctl, mem, adr, adr_type, val);
2227 case T_METADATA: 2231 case T_METADATA:
2228 case T_ADDRESS: 2232 case T_ADDRESS:
2229 case T_OBJECT: 2233 case T_OBJECT:
2230 #ifdef _LP64 2234 #ifdef _LP64
2231 if (adr->bottom_type()->is_ptr_to_narrowoop() || 2235 if (adr->bottom_type()->is_ptr_to_narrowoop()) {
2232 (UseCompressedKlassPointers && val->bottom_type()->isa_klassptr() &&
2233 adr->bottom_type()->isa_rawptr())) {
2234 val = gvn.transform(new (C) EncodePNode(val, val->bottom_type()->make_narrowoop())); 2236 val = gvn.transform(new (C) EncodePNode(val, val->bottom_type()->make_narrowoop()));
2235 return new (C) StoreNNode(ctl, mem, adr, adr_type, val); 2237 return new (C) StoreNNode(ctl, mem, adr, adr_type, val);
2236 } else 2238 } else if (adr->bottom_type()->is_ptr_to_narrowklass() ||
2239 (UseCompressedKlassPointers && val->bottom_type()->isa_klassptr() &&
2240 adr->bottom_type()->isa_rawptr())) {
2241 val = gvn.transform(new (C) EncodePKlassNode(val, val->bottom_type()->make_narrowklass()));
2242 return new (C) StoreNKlassNode(ctl, mem, adr, adr_type, val);
2243 }
2237 #endif 2244 #endif
2238 { 2245 {
2239 return new (C) StorePNode(ctl, mem, adr, adr_type, val); 2246 return new (C) StorePNode(ctl, mem, adr, adr_type, val);
2240 } 2247 }
2241 } 2248 }