67 // condition codes alive at once. This is OK on some chips and
68 // bad on others. Hence the machine-dependent table lookup.
69 const char *_must_clone;
70
71 // Find shared Nodes, or Nodes that otherwise are Matcher roots
72 void find_shared( Node *n );
73
74 // Debug and profile information for nodes in old space:
75 GrowableArray<Node_Notes*>* _old_node_note_array;
76
77 // Node labeling iterator for instruction selection
78 Node *Label_Root( const Node *n, State *svec, Node *control, const Node *mem );
79
80 Node *transform( Node *dummy );
81
82 Node_List &_proj_list; // For Machine nodes killing many values
83
84 Node_Array _shared_nodes;
85
86 debug_only(Node_Array _old2new_map;) // Map roots of ideal-trees to machine-roots
87
88 // Accessors for the inherited field PhaseTransform::_nodes:
89 void grow_new_node_array(uint idx_limit) {
90 _nodes.map(idx_limit-1, NULL);
91 }
92 bool has_new_node(const Node* n) const {
93 return _nodes.at(n->_idx) != NULL;
94 }
95 Node* new_node(const Node* n) const {
96 assert(has_new_node(n), "set before get");
97 return _nodes.at(n->_idx);
98 }
99 void set_new_node(const Node* n, Node *nn) {
100 assert(!has_new_node(n), "set only once");
101 _nodes.map(n->_idx, nn);
102 }
103
104 #ifdef ASSERT
105 // Make sure only new nodes are reachable from this node
106 void verify_new_nodes_only(Node* root);
371 }
372
373 // Used by the DFA in dfa_sparc.cpp. Check for a prior FastLock
374 // acting as an Acquire and thus we don't need an Acquire here. We
375 // retain the Node to act as a compiler ordering barrier.
376 static bool prior_fast_lock( const Node *acq );
377
378 // Used by the DFA in dfa_sparc.cpp. Check for a following
379 // FastUnLock acting as a Release and thus we don't need a Release
380 // here. We retain the Node to act as a compiler ordering barrier.
381 static bool post_fast_unlock( const Node *rel );
382
383 // Check for a following volatile memory barrier without an
384 // intervening load and thus we don't need a barrier here. We
385 // retain the Node to act as a compiler ordering barrier.
386 static bool post_store_load_barrier(const Node* mb);
387
388
389 #ifdef ASSERT
390 void dump_old2new_map(); // machine-independent to machine-dependent
391 #endif
392 };
|
67 // condition codes alive at once. This is OK on some chips and
68 // bad on others. Hence the machine-dependent table lookup.
69 const char *_must_clone;
70
71 // Find shared Nodes, or Nodes that otherwise are Matcher roots
72 void find_shared( Node *n );
73
74 // Debug and profile information for nodes in old space:
75 GrowableArray<Node_Notes*>* _old_node_note_array;
76
77 // Node labeling iterator for instruction selection
78 Node *Label_Root( const Node *n, State *svec, Node *control, const Node *mem );
79
80 Node *transform( Node *dummy );
81
82 Node_List &_proj_list; // For Machine nodes killing many values
83
84 Node_Array _shared_nodes;
85
86 debug_only(Node_Array _old2new_map;) // Map roots of ideal-trees to machine-roots
87 debug_only(Node_Array _new2old_map;) // Maps machine nodes back to ideal
88
89 // Accessors for the inherited field PhaseTransform::_nodes:
90 void grow_new_node_array(uint idx_limit) {
91 _nodes.map(idx_limit-1, NULL);
92 }
93 bool has_new_node(const Node* n) const {
94 return _nodes.at(n->_idx) != NULL;
95 }
96 Node* new_node(const Node* n) const {
97 assert(has_new_node(n), "set before get");
98 return _nodes.at(n->_idx);
99 }
100 void set_new_node(const Node* n, Node *nn) {
101 assert(!has_new_node(n), "set only once");
102 _nodes.map(n->_idx, nn);
103 }
104
105 #ifdef ASSERT
106 // Make sure only new nodes are reachable from this node
107 void verify_new_nodes_only(Node* root);
372 }
373
374 // Used by the DFA in dfa_sparc.cpp. Check for a prior FastLock
375 // acting as an Acquire and thus we don't need an Acquire here. We
376 // retain the Node to act as a compiler ordering barrier.
377 static bool prior_fast_lock( const Node *acq );
378
379 // Used by the DFA in dfa_sparc.cpp. Check for a following
380 // FastUnLock acting as a Release and thus we don't need a Release
381 // here. We retain the Node to act as a compiler ordering barrier.
382 static bool post_fast_unlock( const Node *rel );
383
384 // Check for a following volatile memory barrier without an
385 // intervening load and thus we don't need a barrier here. We
386 // retain the Node to act as a compiler ordering barrier.
387 static bool post_store_load_barrier(const Node* mb);
388
389
390 #ifdef ASSERT
391 void dump_old2new_map(); // machine-independent to machine-dependent
392
393 Node* find_old_node(Node* new_node) {
394 return _new2old_map[new_node->_idx];
395 }
396 #endif
397 };
|