Lines Matching refs:Node
41 class MemNode : public Node {
55 MemNode( Node *c0, Node *c1, Node *c2, const TypePtr* at )
56 : Node(c0,c1,c2 ) {
60 MemNode( Node *c0, Node *c1, Node *c2, const TypePtr* at, Node *c3 )
61 : Node(c0,c1,c2,c3) {
65 MemNode( Node *c0, Node *c1, Node *c2, const TypePtr* at, Node *c3, Node *c4)
66 : Node(c0,c1,c2,c3,c4) {
73 static bool detect_ptr_independence(Node* p1, AllocateNode* a1,
74 Node* p2, AllocateNode* a2,
76 static bool adr_phi_is_loop_invariant(Node* adr_phi, Node* cast);
78 static Node *optimize_simple_memory_chain(Node *mchain, const TypePtr *t_adr, PhaseGVN *phase);
79 static Node *optimize_memory_chain(Node *mchain, const TypePtr *t_adr, PhaseGVN *phase);
81 static bool all_controls_dominate(Node* dom, Node* sub);
84 static Node *Ideal_common_DU_postCCP( PhaseCCP *ccp, Node* n, Node* adr );
85 virtual Node *Ideal_DU_postCCP( PhaseCCP *ccp );
90 Node *Ideal_common(PhaseGVN *phase, bool can_reshape); // Return -1 for short-circuit NULL.
122 Node* find_previous_store(PhaseTransform* phase);
126 Node* can_see_stored_value(Node* st, PhaseTransform* phase) const;
129 static void dump_adr_type(const Node* mem, const TypePtr* adr_type, outputStream *st);
138 virtual uint cmp( const Node &n ) const;
143 LoadNode( Node *c, Node *mem, Node *adr, const TypePtr* at, const Type *rt )
149 static Node* make( PhaseGVN& gvn, Node *c, Node *mem, Node *adr,
154 // Handle algebraic identities here. If we have an identity, return the Node
156 virtual Node *Identity( PhaseTransform *phase );
160 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
163 Node* split_through_phi(PhaseGVN *phase);
166 Node *eliminate_autobox(PhaseGVN *phase);
174 Node *klass_identity_common( PhaseTransform *phase );
195 bool is_instance_field_load_with_local_phi(Node* ctrl);
202 static bool is_immutable_value(Node* adr);
213 LoadBNode( Node *c, Node *mem, Node *adr, const TypePtr* at, const TypeInt *ti = TypeInt::BYTE )
217 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
227 LoadUBNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt* ti = TypeInt::UBYTE )
231 virtual Node* Ideal(PhaseGVN *phase, bool can_reshape);
241 LoadUSNode( Node *c, Node *mem, Node *adr, const TypePtr* at, const TypeInt *ti = TypeInt::CHAR )
245 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
255 LoadSNode( Node *c, Node *mem, Node *adr, const TypePtr* at, const TypeInt *ti = TypeInt::SHORT )
259 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
269 LoadINode( Node *c, Node *mem, Node *adr, const TypePtr* at, const TypeInt *ti = TypeInt::INT )
281 LoadRangeNode( Node *c, Node *mem, Node *adr, const TypeInt *ti = TypeInt::POS )
285 virtual Node *Identity( PhaseTransform *phase );
286 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
293 virtual uint cmp( const Node &n ) const {
301 LoadLNode( Node *c, Node *mem, Node *adr, const TypePtr* at,
312 static LoadLNode* make_atomic(Compile *C, Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, const Type* rt);
325 LoadL_unalignedNode( Node *c, Node *mem, Node *adr, const TypePtr* at )
334 LoadFNode( Node *c, Node *mem, Node *adr, const TypePtr* at, const Type *t = Type::FLOAT )
346 LoadDNode( Node *c, Node *mem, Node *adr, const TypePtr* at, const Type *t = Type::DOUBLE )
358 LoadD_unalignedNode( Node *c, Node *mem, Node *adr, const TypePtr* at )
367 LoadPNode( Node *c, Node *mem, Node *adr, const TypePtr *at, const TypePtr* t )
390 LoadNNode( Node *c, Node *mem, Node *adr, const TypePtr *at, const Type* t )
412 LoadKlassNode( Node *c, Node *mem, Node *adr, const TypePtr *at, const TypeKlassPtr *tk )
416 virtual Node *Identity( PhaseTransform *phase );
420 static Node* make( PhaseGVN& gvn, Node *mem, Node *adr, const TypePtr* at,
428 LoadNKlassNode( Node *c, Node *mem, Node *adr, const TypePtr *at, const TypeNarrowOop *tk )
436 virtual Node *Identity( PhaseTransform *phase );
445 virtual uint cmp( const Node &n ) const;
448 Node *Ideal_masked_input (PhaseGVN *phase, uint mask);
449 Node *Ideal_sign_extended_input(PhaseGVN *phase, int num_bits);
452 StoreNode( Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val )
456 StoreNode( Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val, Node *oop_store )
462 static StoreNode* make( PhaseGVN& gvn, Node *c, Node *mem, Node *adr,
463 const TypePtr* at, Node *val, BasicType bt );
469 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
476 virtual Node *Identity( PhaseTransform *phase );
494 StoreBNode( Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val ) : StoreNode(c,mem,adr,at,val) {}
496 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
504 StoreCNode( Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val ) : StoreNode(c,mem,adr,at,val) {}
506 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
514 StoreINode( Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val ) : StoreNode(c,mem,adr,at,val) {}
523 virtual uint cmp( const Node &n ) const {
531 StoreLNode( Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val,
539 static StoreLNode* make_atomic(Compile *C, Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, Node* val);
552 StoreFNode( Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val ) : StoreNode(c,mem,adr,at,val) {}
561 StoreDNode( Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val ) : StoreNode(c,mem,adr,at,val) {}
570 StorePNode( Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val ) : StoreNode(c,mem,adr,at,val) {}
579 StoreNNode( Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val ) : StoreNode(c,mem,adr,at,val) {}
591 virtual uint cmp( const Node &n ) const {
599 StoreCMNode( Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val, Node *oop_store, int oop_alias_idx ) :
607 virtual Node *Identity( PhaseTransform *phase );
608 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
620 LoadPLockedNode( Node *c, Node *mem, Node *adr )
633 SCMemProjNode( Node *src) : ProjNode( src, SCMEMPROJCON) { }
647 class LoadStoreNode : public Node {
653 LoadStoreNode( Node *c, Node *mem, Node *adr, Node *val, const TypePtr* at, const Type* rt, uint required );
669 LoadStoreConditionalNode(Node *c, Node *mem, Node *adr, Node *val, Node *ex);
677 StorePConditionalNode( Node *c, Node *mem, Node *adr, Node *val, Node *ll ) : LoadStoreConditionalNode(c, mem, adr, val, ll) { }
688 StoreIConditionalNode( Node *c, Node *mem, Node *adr, Node *val, Node *ii ) : LoadStoreConditionalNode(c, mem, adr, val, ii) { }
699 StoreLConditionalNode( Node *c, Node *mem, Node *adr, Node *val, Node *ll ) : LoadStoreConditionalNode(c, mem, adr, val, ll) { }
709 CompareAndSwapLNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex) : LoadStoreConditionalNode(c, mem, adr, val, ex) { }
717 CompareAndSwapINode( Node *c, Node *mem, Node *adr, Node *val, Node *ex) : LoadStoreConditionalNode(c, mem, adr, val, ex) { }
725 CompareAndSwapPNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex) : LoadStoreConditionalNode(c, mem, adr, val, ex) { }
732 CompareAndSwapNNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex) : LoadStoreConditionalNode(c, mem, adr, val, ex) { }
739 GetAndAddINode( Node *c, Node *mem, Node *adr, Node *val, const TypePtr* at ) : LoadStoreNode(c, mem, adr, val, at, TypeInt::INT, 4) { }
746 GetAndAddLNode( Node *c, Node *mem, Node *adr, Node *val, const TypePtr* at ) : LoadStoreNode(c, mem, adr, val, at, TypeLong::LONG, 4) { }
754 GetAndSetINode( Node *c, Node *mem, Node *adr, Node *val, const TypePtr* at ) : LoadStoreNode(c, mem, adr, val, at, TypeInt::INT, 4) { }
761 GetAndSetLNode( Node *c, Node *mem, Node *adr, Node *val, const TypePtr* at ) : LoadStoreNode(c, mem, adr, val, at, TypeLong::LONG, 4) { }
768 GetAndSetPNode( Node *c, Node *mem, Node *adr, Node *val, const TypePtr* at, const Type* t ) : LoadStoreNode(c, mem, adr, val, at, t, 4) { }
775 GetAndSetNNode( Node *c, Node *mem, Node *adr, Node *val, const TypePtr* at, const Type* t ) : LoadStoreNode(c, mem, adr, val, at, t, 4) { }
780 class ClearArrayNode: public Node {
782 ClearArrayNode( Node *ctrl, Node *arymem, Node *word_cnt, Node *base )
783 : Node(ctrl,arymem,word_cnt,base) {
791 virtual Node *Identity( PhaseTransform *phase );
792 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
799 static Node* clear_memory(Node* control, Node* mem, Node* dest,
803 static Node* clear_memory(Node* control, Node* mem, Node* dest,
805 Node* end_offset,
807 static Node* clear_memory(Node* control, Node* mem, Node* dest,
808 Node* start_offset,
809 Node* end_offset,
813 static bool step_through(Node** np, uint instance_id, PhaseTransform* phase);
818 class StrIntrinsicNode: public Node {
820 StrIntrinsicNode(Node* control, Node* char_array_mem,
821 Node* s1, Node* c1, Node* s2, Node* c2):
822 Node(control, char_array_mem, s1, c1, s2, c2) {
825 StrIntrinsicNode(Node* control, Node* char_array_mem,
826 Node* s1, Node* s2, Node* c):
827 Node(control, char_array_mem, s1, s2, c) {
830 StrIntrinsicNode(Node* control, Node* char_array_mem,
831 Node* s1, Node* s2):
832 Node(control, char_array_mem, s1, s2) {
839 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
846 StrCompNode(Node* control, Node* char_array_mem,
847 Node* s1, Node* c1, Node* s2, Node* c2):
856 StrEqualsNode(Node* control, Node* char_array_mem,
857 Node* s1, Node* s2, Node* c):
866 StrIndexOfNode(Node* control, Node* char_array_mem,
867 Node* s1, Node* c1, Node* s2, Node* c2):
876 AryEqNode(Node* control, Node* char_array_mem, Node* s1, Node* s2):
893 virtual uint cmp( const Node &n ) const ; // Always fail, except on self
903 MemBarNode(Compile* C, int alias_idx, Node* precedent);
907 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
910 virtual Node *match( const ProjNode *proj, const Matcher *m );
915 Node* precedent = NULL);
923 MemBarAcquireNode(Compile* C, int alias_idx, Node* precedent)
933 MemBarReleaseNode(Compile* C, int alias_idx, Node* precedent)
943 MemBarAcquireLockNode(Compile* C, int alias_idx, Node* precedent)
953 MemBarReleaseLockNode(Compile* C, int alias_idx, Node* precedent)
960 MemBarStoreStoreNode(Compile* C, int alias_idx, Node* precedent)
971 MemBarVolatileNode(Compile* C, int alias_idx, Node* precedent)
981 MemBarCPUOrderNode(Compile* C, int alias_idx, Node* precedent)
1009 InitializeNode(Compile* C, int adr_type, Node* rawoop);
1016 Node* memory(uint alias_idx);
1020 Node* zero_memory() { return memory(Compile::AliasIdxRaw); }
1054 Node* capture_store(StoreNode* st, intptr_t start, PhaseTransform* phase, bool can_reshape);
1059 Node* find_captured_store(intptr_t start, int size_in_bytes, PhaseTransform* phase);
1062 Node* complete_stores(Node* rawctl, Node* rawmem, Node* rawptr,
1063 intptr_t header_size, Node* size_in_bytes,
1073 static intptr_t get_store_offset(Node* st, PhaseTransform* phase);
1075 Node* make_raw_address(intptr_t offset, PhaseTransform* phase);
1077 bool detect_init_independence(Node* n, bool st_is_pinned, int& count);
1079 void coalesce_subword_stores(intptr_t header_size, Node* size_in_bytes,
1087 class MergeMemNode: public Node {
1089 virtual uint cmp( const Node &n ) const ; // Always fail, except on self
1091 MergeMemNode(Node* def); // clients use MergeMemNode::make
1097 static MergeMemNode* make(Compile* C, Node* base_memory);
1100 virtual Node *Identity( PhaseTransform *phase );
1101 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
1110 Node* memory_at(uint alias_idx) const;
1112 void set_memory_at(uint alias_idx, Node* n);
1114 Node* base_memory() const { return in(Compile::AliasIdxBot); }
1116 void set_base_memory(Node* def);
1118 Node* empty_memory() const { return in(Compile::AliasIdxTop); }
1119 static Node* make_empty_memory(); // where the sentinel comes from
1120 bool is_empty_memory(Node* n) const { assert((n == empty_memory()) == n->is_top(), "sanity"); return n->is_top(); }
1135 Node* _mm_base; // loop-invariant base memory of _mm
1138 Node* _mem;
1139 Node* _mem2;
1168 Node* check_memory() const {
1176 Node* check_memory2() const {
1181 static bool match_memory(Node* mem, const MergeMemNode* mm, int idx) PRODUCT_RETURN0;
1217 Node* base_memory() const {
1250 Node* memory() const {
1256 Node* force_memory() const {
1259 Node *mem = _mem->is_top() ? _mm_base : _mem;
1263 Node* memory2() const {
1267 void set_memory(Node* mem) {
1324 class PrefetchReadNode : public Node {
1326 PrefetchReadNode(Node *abio, Node *adr) : Node(0,abio,adr) {}
1334 class PrefetchWriteNode : public Node {
1336 PrefetchWriteNode(Node *abio, Node *adr) : Node(0,abio,adr) {}
1344 class PrefetchAllocationNode : public Node {
1346 PrefetchAllocationNode(Node *mem, Node *adr) : Node(0,mem,adr) {}