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
|