184 bool done() { return _done; } 185 void next(); 186 }; 187 188 189 // ========================= SuperWord ===================== 190 191 // -----------------------------SWNodeInfo--------------------------------- 192 // Per node info needed by SuperWord 193 class SWNodeInfo VALUE_OBJ_CLASS_SPEC { 194 public: 195 int _alignment; // memory alignment for a node 196 int _depth; // Max expression (DAG) depth from block start 197 const Type* _velt_type; // vector element type 198 Node_List* _my_pack; // pack containing this node 199 200 SWNodeInfo() : _alignment(-1), _depth(0), _velt_type(NULL), _my_pack(NULL) {} 201 static const SWNodeInfo initial; 202 }; 203 204 // -----------------------------SuperWord--------------------------------- 205 // Transforms scalar operations into packed (superword) operations. 206 class SuperWord : public ResourceObj { 207 private: 208 PhaseIdealLoop* _phase; 209 Arena* _arena; 210 PhaseIterGVN &_igvn; 211 212 enum consts { top_align = -1, bottom_align = -666 }; 213 214 GrowableArray<Node_List*> _packset; // Packs for the current block 215 216 GrowableArray<int> _bb_idx; // Map from Node _idx to index within block 217 218 GrowableArray<Node*> _block; // Nodes in current block 219 GrowableArray<Node*> _data_entry; // Nodes with all inputs from outside 220 GrowableArray<Node*> _mem_slice_head; // Memory slice head nodes 221 GrowableArray<Node*> _mem_slice_tail; // Memory slice tail nodes 222 223 GrowableArray<SWNodeInfo> _node_info; // Info needed per node 486 (_adr == q._adr || _base == _adr && q._base == q._adr) && 487 _scale == q._scale && 488 _invar == q._invar && 489 _negate_invar == q._negate_invar) { 490 bool overlap = q._offset < _offset + memory_size() && 491 _offset < q._offset + q.memory_size(); 492 return overlap ? Equal : (_offset < q._offset ? Less : Greater); 493 } else { 494 return NotComparable; 495 } 496 } 497 498 bool not_equal(SWPointer& q) { return not_equal(cmp(q)); } 499 bool equal(SWPointer& q) { return equal(cmp(q)); } 500 bool comparable(SWPointer& q) { return comparable(cmp(q)); } 501 static bool not_equal(int cmp) { return cmp <= NotEqual; } 502 static bool equal(int cmp) { return cmp == Equal; } 503 static bool comparable(int cmp) { return cmp < NotComparable; } 504 505 void print(); 506 }; 507 508 509 //------------------------------OrderedPair--------------------------- 510 // Ordered pair of Node*. 511 class OrderedPair VALUE_OBJ_CLASS_SPEC { 512 protected: 513 Node* _p1; 514 Node* _p2; 515 public: 516 OrderedPair() : _p1(NULL), _p2(NULL) {} 517 OrderedPair(Node* p1, Node* p2) { 518 if (p1->_idx < p2->_idx) { 519 _p1 = p1; _p2 = p2; 520 } else { 521 _p1 = p2; _p2 = p1; 522 } 523 } 524 525 bool operator==(const OrderedPair &rhs) { 526 return _p1 == rhs._p1 && _p2 == rhs._p2; 527 } 528 void print() { tty->print(" (%d, %d)", _p1->_idx, _p2->_idx); } 529 530 static const OrderedPair initial; 531 }; 532 533 #endif // SHARE_VM_OPTO_SUPERWORD_HPP | 184 bool done() { return _done; } 185 void next(); 186 }; 187 188 189 // ========================= SuperWord ===================== 190 191 // -----------------------------SWNodeInfo--------------------------------- 192 // Per node info needed by SuperWord 193 class SWNodeInfo VALUE_OBJ_CLASS_SPEC { 194 public: 195 int _alignment; // memory alignment for a node 196 int _depth; // Max expression (DAG) depth from block start 197 const Type* _velt_type; // vector element type 198 Node_List* _my_pack; // pack containing this node 199 200 SWNodeInfo() : _alignment(-1), _depth(0), _velt_type(NULL), _my_pack(NULL) {} 201 static const SWNodeInfo initial; 202 }; 203 204 205 // JVMCI: OrderedPair is moved up to deal with compilation issues on Windows 206 //------------------------------OrderedPair--------------------------- 207 // Ordered pair of Node*. 208 class OrderedPair VALUE_OBJ_CLASS_SPEC { 209 protected: 210 Node* _p1; 211 Node* _p2; 212 public: 213 OrderedPair() : _p1(NULL), _p2(NULL) {} 214 OrderedPair(Node* p1, Node* p2) { 215 if (p1->_idx < p2->_idx) { 216 _p1 = p1; _p2 = p2; 217 } else { 218 _p1 = p2; _p2 = p1; 219 } 220 } 221 222 bool operator==(const OrderedPair &rhs) { 223 return _p1 == rhs._p1 && _p2 == rhs._p2; 224 } 225 void print() { tty->print(" (%d, %d)", _p1->_idx, _p2->_idx); } 226 227 static const OrderedPair initial; 228 }; 229 230 // -----------------------------SuperWord--------------------------------- 231 // Transforms scalar operations into packed (superword) operations. 232 class SuperWord : public ResourceObj { 233 private: 234 PhaseIdealLoop* _phase; 235 Arena* _arena; 236 PhaseIterGVN &_igvn; 237 238 enum consts { top_align = -1, bottom_align = -666 }; 239 240 GrowableArray<Node_List*> _packset; // Packs for the current block 241 242 GrowableArray<int> _bb_idx; // Map from Node _idx to index within block 243 244 GrowableArray<Node*> _block; // Nodes in current block 245 GrowableArray<Node*> _data_entry; // Nodes with all inputs from outside 246 GrowableArray<Node*> _mem_slice_head; // Memory slice head nodes 247 GrowableArray<Node*> _mem_slice_tail; // Memory slice tail nodes 248 249 GrowableArray<SWNodeInfo> _node_info; // Info needed per node 512 (_adr == q._adr || _base == _adr && q._base == q._adr) && 513 _scale == q._scale && 514 _invar == q._invar && 515 _negate_invar == q._negate_invar) { 516 bool overlap = q._offset < _offset + memory_size() && 517 _offset < q._offset + q.memory_size(); 518 return overlap ? Equal : (_offset < q._offset ? Less : Greater); 519 } else { 520 return NotComparable; 521 } 522 } 523 524 bool not_equal(SWPointer& q) { return not_equal(cmp(q)); } 525 bool equal(SWPointer& q) { return equal(cmp(q)); } 526 bool comparable(SWPointer& q) { return comparable(cmp(q)); } 527 static bool not_equal(int cmp) { return cmp <= NotEqual; } 528 static bool equal(int cmp) { return cmp == Equal; } 529 static bool comparable(int cmp) { return cmp < NotComparable; } 530 531 void print(); 532 }; 533 534 #endif // SHARE_VM_OPTO_SUPERWORD_HPP |