vectornode.hpp revision 0:a61af66fc99e 
1/*
2 * Copyright 2007 Sun Microsystems, Inc.  All Rights Reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
20 * CA 95054 USA or visit www.sun.com if you need additional information or
21 * have any questions.
22 */
23
24//------------------------------VectorNode--------------------------------------
25// Vector Operation
26class VectorNode : public Node {
27 protected:
28  uint _length; // vector length
29  virtual BasicType elt_basic_type() const = 0; // Vector element basic type
30
31  static const Type* vect_type(BasicType elt_bt, uint len);
32  static const Type* vect_type(const Type* elt_type, uint len) {
33    return vect_type(elt_type->array_element_basic_type(), len);
34  }
35
36 public:
37  friend class VectorLoadNode;  // For vect_type
38  friend class VectorStoreNode; // ditto.
39
40  VectorNode(Node* n1, uint vlen) : Node(NULL, n1), _length(vlen) {
41    init_flags(Flag_is_Vector);
42  }
43  VectorNode(Node* n1, Node* n2, uint vlen) : Node(NULL, n1, n2), _length(vlen) {
44    init_flags(Flag_is_Vector);
45  }
46  virtual int Opcode() const;
47
48  uint length() const { return _length; } // Vector length
49
50  static uint max_vlen(BasicType bt) { // max vector length
51    return (uint)(Matcher::vector_width_in_bytes() / type2aelembytes[bt]);
52  }
53
54  // Element and vector type
55  const Type* elt_type()  const { return Type::get_const_basic_type(elt_basic_type()); }
56  const Type* vect_type() const { return vect_type(elt_basic_type(), length()); }
57
58  virtual const Type *bottom_type() const { return vect_type(); }
59  virtual uint        ideal_reg()   const { return Matcher::vector_ideal_reg(); }
60
61  // Vector opcode from scalar opcode
62  static int opcode(int sopc, uint vlen, const Type* opd_t);
63
64  static VectorNode* scalar2vector(Compile* C, Node* s, uint vlen, const Type* opd_t);
65
66  static VectorNode* make(Compile* C, int sopc, Node* n1, Node* n2, uint vlen, const Type* elt_t);
67
68};
69
70//===========================Vector=ALU=Operations====================================
71
72//------------------------------AddVBNode---------------------------------------
73// Vector add byte
74class AddVBNode : public VectorNode {
75 protected:
76  virtual BasicType elt_basic_type() const { return T_BYTE; }
77 public:
78  AddVBNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
79  virtual int Opcode() const;
80};
81
82//------------------------------AddVCNode---------------------------------------
83// Vector add char
84class AddVCNode : public VectorNode {
85 protected:
86  virtual BasicType elt_basic_type() const { return T_CHAR; }
87 public:
88  AddVCNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
89  virtual int Opcode() const;
90};
91
92//------------------------------AddVSNode---------------------------------------
93// Vector add short
94class AddVSNode : public VectorNode {
95 protected:
96  virtual BasicType elt_basic_type() const { return T_SHORT; }
97 public:
98  AddVSNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
99  virtual int Opcode() const;
100};
101
102//------------------------------AddVINode---------------------------------------
103// Vector add int
104class AddVINode : public VectorNode {
105 protected:
106  virtual BasicType elt_basic_type() const { return T_INT; }
107 public:
108  AddVINode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
109  virtual int Opcode() const;
110};
111
112//------------------------------AddVLNode---------------------------------------
113// Vector add long
114class AddVLNode : public VectorNode {
115 protected:
116  virtual BasicType elt_basic_type() const { return T_LONG; }
117 public:
118  AddVLNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
119  virtual int Opcode() const;
120};
121
122//------------------------------AddVFNode---------------------------------------
123// Vector add float
124class AddVFNode : public VectorNode {
125 protected:
126  virtual BasicType elt_basic_type() const { return T_FLOAT; }
127 public:
128  AddVFNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
129  virtual int Opcode() const;
130};
131
132//------------------------------AddVDNode---------------------------------------
133// Vector add double
134class AddVDNode : public VectorNode {
135 protected:
136  virtual BasicType elt_basic_type() const { return T_DOUBLE; }
137 public:
138  AddVDNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
139  virtual int Opcode() const;
140};
141
142//------------------------------SubVBNode---------------------------------------
143// Vector subtract byte
144class SubVBNode : public VectorNode {
145 protected:
146  virtual BasicType elt_basic_type() const { return T_BYTE; }
147 public:
148  SubVBNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
149  virtual int Opcode() const;
150};
151
152//------------------------------SubVCNode---------------------------------------
153// Vector subtract char
154class SubVCNode : public VectorNode {
155 protected:
156  virtual BasicType elt_basic_type() const { return T_CHAR; }
157 public:
158  SubVCNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
159  virtual int Opcode() const;
160};
161
162//------------------------------SubVSNode---------------------------------------
163// Vector subtract short
164class SubVSNode : public VectorNode {
165 protected:
166  virtual BasicType elt_basic_type() const { return T_SHORT; }
167 public:
168  SubVSNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
169  virtual int Opcode() const;
170};
171
172//------------------------------SubVINode---------------------------------------
173// Vector subtract int
174class SubVINode : public VectorNode {
175 protected:
176  virtual BasicType elt_basic_type() const { return T_INT; }
177 public:
178  SubVINode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
179  virtual int Opcode() const;
180};
181
182//------------------------------SubVLNode---------------------------------------
183// Vector subtract long
184class SubVLNode : public VectorNode {
185 protected:
186  virtual BasicType elt_basic_type() const { return T_LONG; }
187 public:
188  SubVLNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
189  virtual int Opcode() const;
190};
191
192//------------------------------SubVFNode---------------------------------------
193// Vector subtract float
194class SubVFNode : public VectorNode {
195 protected:
196  virtual BasicType elt_basic_type() const { return T_FLOAT; }
197 public:
198  SubVFNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
199  virtual int Opcode() const;
200};
201
202//------------------------------SubVDNode---------------------------------------
203// Vector subtract double
204class SubVDNode : public VectorNode {
205 protected:
206  virtual BasicType elt_basic_type() const { return T_DOUBLE; }
207 public:
208  SubVDNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
209  virtual int Opcode() const;
210};
211
212//------------------------------MulVFNode---------------------------------------
213// Vector multiply float
214class MulVFNode : public VectorNode {
215 protected:
216  virtual BasicType elt_basic_type() const { return T_FLOAT; }
217 public:
218  MulVFNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
219  virtual int Opcode() const;
220};
221
222//------------------------------MulVDNode---------------------------------------
223// Vector multiply double
224class MulVDNode : public VectorNode {
225 protected:
226  virtual BasicType elt_basic_type() const { return T_DOUBLE; }
227 public:
228  MulVDNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
229  virtual int Opcode() const;
230};
231
232//------------------------------DivVFNode---------------------------------------
233// Vector divide float
234class DivVFNode : public VectorNode {
235 protected:
236  virtual BasicType elt_basic_type() const { return T_FLOAT; }
237 public:
238  DivVFNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
239  virtual int Opcode() const;
240};
241
242//------------------------------DivVDNode---------------------------------------
243// Vector Divide double
244class DivVDNode : public VectorNode {
245 protected:
246  virtual BasicType elt_basic_type() const { return T_DOUBLE; }
247 public:
248  DivVDNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
249  virtual int Opcode() const;
250};
251
252//------------------------------LShiftVBNode---------------------------------------
253// Vector lshift byte
254class LShiftVBNode : public VectorNode {
255 protected:
256  virtual BasicType elt_basic_type() const { return T_BYTE; }
257 public:
258  LShiftVBNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
259  virtual int Opcode() const;
260};
261
262//------------------------------LShiftVCNode---------------------------------------
263// Vector lshift chars
264class LShiftVCNode : public VectorNode {
265 protected:
266  virtual BasicType elt_basic_type() const { return T_CHAR; }
267 public:
268  LShiftVCNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
269  virtual int Opcode() const;
270};
271
272//------------------------------LShiftVSNode---------------------------------------
273// Vector lshift shorts
274class LShiftVSNode : public VectorNode {
275 protected:
276  virtual BasicType elt_basic_type() const { return T_SHORT; }
277 public:
278  LShiftVSNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
279  virtual int Opcode() const;
280};
281
282//------------------------------LShiftVINode---------------------------------------
283// Vector lshift ints
284class LShiftVINode : public VectorNode {
285 protected:
286  virtual BasicType elt_basic_type() const { return T_INT; }
287 public:
288  LShiftVINode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
289  virtual int Opcode() const;
290};
291
292//------------------------------URShiftVBNode---------------------------------------
293// Vector urshift bytes
294class URShiftVBNode : public VectorNode {
295 protected:
296  virtual BasicType elt_basic_type() const { return T_BYTE; }
297 public:
298  URShiftVBNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
299  virtual int Opcode() const;
300};
301
302//------------------------------URShiftVCNode---------------------------------------
303// Vector urshift char
304class URShiftVCNode : public VectorNode {
305 protected:
306  virtual BasicType elt_basic_type() const { return T_SHORT; }
307 public:
308  URShiftVCNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
309  virtual int Opcode() const;
310};
311
312//------------------------------URShiftVSNode---------------------------------------
313// Vector urshift shorts
314class URShiftVSNode : public VectorNode {
315 protected:
316  virtual BasicType elt_basic_type() const { return T_SHORT; }
317 public:
318  URShiftVSNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
319  virtual int Opcode() const;
320};
321
322//------------------------------URShiftVINode---------------------------------------
323// Vector urshift ints
324class URShiftVINode : public VectorNode {
325 protected:
326  virtual BasicType elt_basic_type() const { return T_INT; }
327 public:
328  URShiftVINode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
329  virtual int Opcode() const;
330};
331
332//------------------------------AndVNode---------------------------------------
333// Vector and
334class AndVNode : public VectorNode {
335 protected:
336  BasicType _bt;
337  virtual BasicType elt_basic_type() const { return _bt; }
338 public:
339  AndVNode(Node* in1, Node* in2, uint vlen, BasicType bt) : VectorNode(in1,in2,vlen), _bt(bt) {}
340  virtual int Opcode() const;
341};
342
343//------------------------------OrVNode---------------------------------------
344// Vector or
345class OrVNode : public VectorNode {
346 protected:
347  BasicType _bt;
348  virtual BasicType elt_basic_type() const { return _bt; }
349 public:
350  OrVNode(Node* in1, Node* in2, uint vlen, BasicType bt) : VectorNode(in1,in2,vlen), _bt(bt) {}
351  virtual int Opcode() const;
352};
353
354//------------------------------XorVNode---------------------------------------
355// Vector xor
356class XorVNode : public VectorNode {
357 protected:
358  BasicType _bt;
359  virtual BasicType elt_basic_type() const { return _bt; }
360 public:
361  XorVNode(Node* in1, Node* in2, uint vlen, BasicType bt) : VectorNode(in1,in2,vlen), _bt(bt) {}
362  virtual int Opcode() const;
363};
364
365//================================= M E M O R Y ==================================
366
367
368//------------------------------VectorLoadNode--------------------------------------
369// Vector Load from memory
370class VectorLoadNode : public LoadNode {
371  virtual uint size_of() const { return sizeof(*this); }
372
373 protected:
374  virtual BasicType elt_basic_type()  const = 0; // Vector element basic type
375  // For use in constructor
376  static const Type* vect_type(const Type* elt_type, uint len) {
377    return VectorNode::vect_type(elt_type, len);
378  }
379
380 public:
381  VectorLoadNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const Type *rt)
382    : LoadNode(c,mem,adr,at,rt) {
383      init_flags(Flag_is_Vector);
384  }
385  virtual int Opcode() const;
386
387  virtual uint  length() const = 0; // Vector length
388
389  // Element and vector type
390  const Type* elt_type()  const { return Type::get_const_basic_type(elt_basic_type()); }
391  const Type* vect_type() const { return VectorNode::vect_type(elt_basic_type(), length()); }
392
393  virtual uint ideal_reg() const  { return Matcher::vector_ideal_reg(); }
394  virtual BasicType memory_type() const { return T_VOID; }
395  virtual int memory_size() const { return length()*type2aelembytes[elt_basic_type()]; }
396
397  // Vector opcode from scalar opcode
398  static int opcode(int sopc, uint vlen);
399
400  static VectorLoadNode* make(Compile* C, int opc, Node* ctl, Node* mem,
401                              Node* adr, const TypePtr* atyp, uint vlen);
402};
403
404//------------------------------Load16BNode--------------------------------------
405// Vector load of 16 bytes (8bits signed) from memory
406class Load16BNode : public VectorLoadNode {
407 protected:
408  virtual BasicType elt_basic_type() const { return T_BYTE; }
409 public:
410  Load16BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::BYTE)
411    : VectorLoadNode(c,mem,adr,at,vect_type(ti,16)) {}
412  virtual int Opcode() const;
413  virtual int store_Opcode() const { return Op_Store16B; }
414  virtual uint length() const { return 16; }
415};
416
417//------------------------------Load8BNode--------------------------------------
418// Vector load of 8 bytes (8bits signed) from memory
419class Load8BNode : public VectorLoadNode {
420 protected:
421  virtual BasicType elt_basic_type() const { return T_BYTE; }
422 public:
423  Load8BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::BYTE)
424    : VectorLoadNode(c,mem,adr,at,vect_type(ti,8)) {}
425  virtual int Opcode() const;
426  virtual int store_Opcode() const { return Op_Store8B; }
427  virtual uint length() const { return 8; }
428};
429
430//------------------------------Load4BNode--------------------------------------
431// Vector load of 4 bytes (8bits signed) from memory
432class Load4BNode : public VectorLoadNode {
433 protected:
434  virtual BasicType elt_basic_type() const { return T_BYTE; }
435 public:
436  Load4BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::BYTE)
437    : VectorLoadNode(c,mem,adr,at,vect_type(ti,4)) {}
438  virtual int Opcode() const;
439  virtual int store_Opcode() const { return Op_Store4B; }
440  virtual uint length() const { return 4; }
441};
442
443//------------------------------Load8CNode--------------------------------------
444// Vector load of 8 chars (16bits unsigned) from memory
445class Load8CNode : public VectorLoadNode {
446 protected:
447  virtual BasicType elt_basic_type() const { return T_CHAR; }
448 public:
449  Load8CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::CHAR)
450    : VectorLoadNode(c,mem,adr,at,vect_type(ti,8)) {}
451  virtual int Opcode() const;
452  virtual int store_Opcode() const { return Op_Store8C; }
453  virtual uint length() const { return 8; }
454};
455
456//------------------------------Load4CNode--------------------------------------
457// Vector load of 4 chars (16bits unsigned) from memory
458class Load4CNode : public VectorLoadNode {
459 protected:
460  virtual BasicType elt_basic_type() const { return T_CHAR; }
461 public:
462  Load4CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::CHAR)
463    : VectorLoadNode(c,mem,adr,at,vect_type(ti,4)) {}
464  virtual int Opcode() const;
465  virtual int store_Opcode() const { return Op_Store4C; }
466  virtual uint length() const { return 4; }
467};
468
469//------------------------------Load2CNode--------------------------------------
470// Vector load of 2 chars (16bits unsigned) from memory
471class Load2CNode : public VectorLoadNode {
472 protected:
473  virtual BasicType elt_basic_type() const { return T_CHAR; }
474 public:
475  Load2CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::CHAR)
476    : VectorLoadNode(c,mem,adr,at,vect_type(ti,2)) {}
477  virtual int Opcode() const;
478  virtual int store_Opcode() const { return Op_Store2C; }
479  virtual uint length() const { return 2; }
480};
481
482//------------------------------Load8SNode--------------------------------------
483// Vector load of 8 shorts (16bits signed) from memory
484class Load8SNode : public VectorLoadNode {
485 protected:
486  virtual BasicType elt_basic_type() const { return T_SHORT; }
487 public:
488  Load8SNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::SHORT)
489    : VectorLoadNode(c,mem,adr,at,vect_type(ti,8)) {}
490  virtual int Opcode() const;
491  virtual int store_Opcode() const { return Op_Store8C; }
492  virtual uint length() const { return 8; }
493};
494
495//------------------------------Load4SNode--------------------------------------
496// Vector load of 4 shorts (16bits signed) from memory
497class Load4SNode : public VectorLoadNode {
498 protected:
499  virtual BasicType elt_basic_type() const { return T_SHORT; }
500 public:
501  Load4SNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::SHORT)
502    : VectorLoadNode(c,mem,adr,at,vect_type(ti,4)) {}
503  virtual int Opcode() const;
504  virtual int store_Opcode() const { return Op_Store4C; }
505  virtual uint length() const { return 4; }
506};
507
508//------------------------------Load2SNode--------------------------------------
509// Vector load of 2 shorts (16bits signed) from memory
510class Load2SNode : public VectorLoadNode {
511 protected:
512  virtual BasicType elt_basic_type() const { return T_SHORT; }
513 public:
514  Load2SNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::SHORT)
515    : VectorLoadNode(c,mem,adr,at,vect_type(ti,2)) {}
516  virtual int Opcode() const;
517  virtual int store_Opcode() const { return Op_Store2C; }
518  virtual uint length() const { return 2; }
519};
520
521//------------------------------Load4INode--------------------------------------
522// Vector load of 4 integers (32bits signed) from memory
523class Load4INode : public VectorLoadNode {
524 protected:
525  virtual BasicType elt_basic_type() const { return T_INT; }
526 public:
527  Load4INode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::INT)
528    : VectorLoadNode(c,mem,adr,at,vect_type(ti,4)) {}
529  virtual int Opcode() const;
530  virtual int store_Opcode() const { return Op_Store4I; }
531  virtual uint length() const { return 4; }
532};
533
534//------------------------------Load2INode--------------------------------------
535// Vector load of 2 integers (32bits signed) from memory
536class Load2INode : public VectorLoadNode {
537 protected:
538  virtual BasicType elt_basic_type() const { return T_INT; }
539 public:
540  Load2INode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::INT)
541    : VectorLoadNode(c,mem,adr,at,vect_type(ti,2)) {}
542  virtual int Opcode() const;
543  virtual int store_Opcode() const { return Op_Store2I; }
544  virtual uint length() const { return 2; }
545};
546
547//------------------------------Load2LNode--------------------------------------
548// Vector load of 2 longs (64bits signed) from memory
549class Load2LNode : public VectorLoadNode {
550 protected:
551  virtual BasicType elt_basic_type() const { return T_LONG; }
552 public:
553  Load2LNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeLong *tl = TypeLong::LONG)
554    : VectorLoadNode(c,mem,adr,at,vect_type(tl,2)) {}
555  virtual int Opcode() const;
556  virtual int store_Opcode() const { return Op_Store2L; }
557  virtual uint length() const { return 2; }
558};
559
560//------------------------------Load4FNode--------------------------------------
561// Vector load of 4 floats (32bits) from memory
562class Load4FNode : public VectorLoadNode {
563 protected:
564  virtual BasicType elt_basic_type() const { return T_FLOAT; }
565 public:
566  Load4FNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const Type *t = Type::FLOAT)
567    : VectorLoadNode(c,mem,adr,at,vect_type(t,4)) {}
568  virtual int Opcode() const;
569  virtual int store_Opcode() const { return Op_Store4F; }
570  virtual uint length() const { return 4; }
571};
572
573//------------------------------Load2FNode--------------------------------------
574// Vector load of 2 floats (32bits) from memory
575class Load2FNode : public VectorLoadNode {
576 protected:
577  virtual BasicType elt_basic_type() const { return T_FLOAT; }
578 public:
579  Load2FNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const Type *t = Type::FLOAT)
580    : VectorLoadNode(c,mem,adr,at,vect_type(t,2)) {}
581  virtual int Opcode() const;
582  virtual int store_Opcode() const { return Op_Store2F; }
583  virtual uint length() const { return 2; }
584};
585
586//------------------------------Load2DNode--------------------------------------
587// Vector load of 2 doubles (64bits) from memory
588class Load2DNode : public VectorLoadNode {
589 protected:
590  virtual BasicType elt_basic_type() const { return T_DOUBLE; }
591 public:
592  Load2DNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const Type *t = Type::DOUBLE)
593    : VectorLoadNode(c,mem,adr,at,vect_type(t,2)) {}
594  virtual int Opcode() const;
595  virtual int store_Opcode() const { return Op_Store2D; }
596  virtual uint length() const { return 2; }
597};
598
599
600//------------------------------VectorStoreNode--------------------------------------
601// Vector Store to memory
602class VectorStoreNode : public StoreNode {
603  virtual uint size_of() const { return sizeof(*this); }
604
605 protected:
606  virtual BasicType elt_basic_type()  const = 0; // Vector element basic type
607
608 public:
609  VectorStoreNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
610    : StoreNode(c,mem,adr,at,val) {
611      init_flags(Flag_is_Vector);
612  }
613  virtual int Opcode() const;
614
615  virtual uint  length() const = 0; // Vector length
616
617  // Element and vector type
618  const Type* elt_type()  const { return Type::get_const_basic_type(elt_basic_type()); }
619  const Type* vect_type() const { return VectorNode::vect_type(elt_basic_type(), length()); }
620
621  virtual uint ideal_reg() const  { return Matcher::vector_ideal_reg(); }
622  virtual BasicType memory_type() const { return T_VOID; }
623  virtual int memory_size() const { return length()*type2aelembytes[elt_basic_type()]; }
624
625  // Vector opcode from scalar opcode
626  static int opcode(int sopc, uint vlen);
627
628  static VectorStoreNode* make(Compile* C, int opc, Node* ctl, Node* mem,
629                               Node* adr, const TypePtr* atyp, VectorNode* val,
630                               uint vlen);
631};
632
633//------------------------------Store16BNode--------------------------------------
634// Vector store of 16 bytes (8bits signed) to memory
635class Store16BNode : public VectorStoreNode {
636 protected:
637  virtual BasicType elt_basic_type() const { return T_BYTE; }
638 public:
639  Store16BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
640    : VectorStoreNode(c,mem,adr,at,val) {}
641  virtual int Opcode() const;
642  virtual uint length() const { return 16; }
643};
644
645//------------------------------Store8BNode--------------------------------------
646// Vector store of 8 bytes (8bits signed) to memory
647class Store8BNode : public VectorStoreNode {
648 protected:
649  virtual BasicType elt_basic_type() const { return T_BYTE; }
650 public:
651  Store8BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
652    : VectorStoreNode(c,mem,adr,at,val) {}
653  virtual int Opcode() const;
654  virtual uint length() const { return 8; }
655};
656
657//------------------------------Store4BNode--------------------------------------
658// Vector store of 4 bytes (8bits signed) to memory
659class Store4BNode : public VectorStoreNode {
660 protected:
661  virtual BasicType elt_basic_type() const { return T_BYTE; }
662 public:
663  Store4BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
664    : VectorStoreNode(c,mem,adr,at,val) {}
665  virtual int Opcode() const;
666  virtual uint length() const { return 4; }
667};
668
669//------------------------------Store8CNode--------------------------------------
670// Vector store of 8 chars (16bits signed/unsigned) to memory
671class Store8CNode : public VectorStoreNode {
672 protected:
673  virtual BasicType elt_basic_type() const { return T_CHAR; }
674 public:
675  Store8CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
676    : VectorStoreNode(c,mem,adr,at,val) {}
677  virtual int Opcode() const;
678  virtual uint length() const { return 8; }
679};
680
681//------------------------------Store4CNode--------------------------------------
682// Vector store of 4 chars (16bits signed/unsigned) to memory
683class Store4CNode : public VectorStoreNode {
684 protected:
685  virtual BasicType elt_basic_type() const { return T_CHAR; }
686 public:
687  Store4CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
688    : VectorStoreNode(c,mem,adr,at,val) {}
689  virtual int Opcode() const;
690  virtual uint length() const { return 4; }
691};
692
693//------------------------------Store2CNode--------------------------------------
694// Vector store of 2 chars (16bits signed/unsigned) to memory
695class Store2CNode : public VectorStoreNode {
696 protected:
697  virtual BasicType elt_basic_type() const { return T_CHAR; }
698 public:
699  Store2CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
700    : VectorStoreNode(c,mem,adr,at,val) {}
701  virtual int Opcode() const;
702  virtual uint length() const { return 2; }
703};
704
705//------------------------------Store4INode--------------------------------------
706// Vector store of 4 integers (32bits signed) to memory
707class Store4INode : public VectorStoreNode {
708 protected:
709  virtual BasicType elt_basic_type() const { return T_INT; }
710 public:
711  Store4INode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
712    : VectorStoreNode(c,mem,adr,at,val) {}
713  virtual int Opcode() const;
714  virtual uint length() const { return 4; }
715};
716
717//------------------------------Store2INode--------------------------------------
718// Vector store of 2 integers (32bits signed) to memory
719class Store2INode : public VectorStoreNode {
720 protected:
721  virtual BasicType elt_basic_type() const { return T_INT; }
722 public:
723  Store2INode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
724    : VectorStoreNode(c,mem,adr,at,val) {}
725  virtual int Opcode() const;
726  virtual uint length() const { return 2; }
727};
728
729//------------------------------Store2LNode--------------------------------------
730// Vector store of 2 longs (64bits signed) to memory
731class Store2LNode : public VectorStoreNode {
732 protected:
733  virtual BasicType elt_basic_type() const { return T_LONG; }
734 public:
735  Store2LNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
736    : VectorStoreNode(c,mem,adr,at,val) {}
737  virtual int Opcode() const;
738  virtual uint length() const { return 2; }
739};
740
741//------------------------------Store4FNode--------------------------------------
742// Vector store of 4 floats (32bits) to memory
743class Store4FNode : public VectorStoreNode {
744 protected:
745  virtual BasicType elt_basic_type() const { return T_FLOAT; }
746 public:
747  Store4FNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
748    : VectorStoreNode(c,mem,adr,at,val) {}
749  virtual int Opcode() const;
750  virtual uint length() const { return 4; }
751};
752
753//------------------------------Store2FNode--------------------------------------
754// Vector store of 2 floats (32bits) to memory
755class Store2FNode : public VectorStoreNode {
756 protected:
757  virtual BasicType elt_basic_type() const { return T_FLOAT; }
758 public:
759  Store2FNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
760    : VectorStoreNode(c,mem,adr,at,val) {}
761  virtual int Opcode() const;
762  virtual uint length() const { return 2; }
763};
764
765//------------------------------Store2DNode--------------------------------------
766// Vector store of 2 doubles (64bits) to memory
767class Store2DNode : public VectorStoreNode {
768 protected:
769  virtual BasicType elt_basic_type() const { return T_DOUBLE; }
770 public:
771  Store2DNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
772    : VectorStoreNode(c,mem,adr,at,val) {}
773  virtual int Opcode() const;
774  virtual uint length() const { return 2; }
775};
776
777//=========================Promote_Scalar_to_Vector====================================
778
779//------------------------------Replicate16BNode---------------------------------------
780// Replicate byte scalar to be vector of 16 bytes
781class Replicate16BNode : public VectorNode {
782 protected:
783  virtual BasicType elt_basic_type() const { return T_BYTE; }
784 public:
785  Replicate16BNode(Node* in1) : VectorNode(in1, 16) {}
786  virtual int Opcode() const;
787};
788
789//------------------------------Replicate8BNode---------------------------------------
790// Replicate byte scalar to be vector of 8 bytes
791class Replicate8BNode : public VectorNode {
792 protected:
793  virtual BasicType elt_basic_type() const { return T_BYTE; }
794 public:
795  Replicate8BNode(Node* in1) : VectorNode(in1, 8) {}
796  virtual int Opcode() const;
797};
798
799//------------------------------Replicate4BNode---------------------------------------
800// Replicate byte scalar to be vector of 4 bytes
801class Replicate4BNode : public VectorNode {
802 protected:
803  virtual BasicType elt_basic_type() const { return T_BYTE; }
804 public:
805  Replicate4BNode(Node* in1) : VectorNode(in1, 4) {}
806  virtual int Opcode() const;
807};
808
809//------------------------------Replicate8CNode---------------------------------------
810// Replicate char scalar to be vector of 8 chars
811class Replicate8CNode : public VectorNode {
812 protected:
813  virtual BasicType elt_basic_type() const { return T_CHAR; }
814 public:
815  Replicate8CNode(Node* in1) : VectorNode(in1, 8) {}
816  virtual int Opcode() const;
817};
818
819//------------------------------Replicate4CNode---------------------------------------
820// Replicate char scalar to be vector of 4 chars
821class Replicate4CNode : public VectorNode {
822 protected:
823  virtual BasicType elt_basic_type() const { return T_CHAR; }
824 public:
825  Replicate4CNode(Node* in1) : VectorNode(in1, 4) {}
826  virtual int Opcode() const;
827};
828
829//------------------------------Replicate2CNode---------------------------------------
830// Replicate char scalar to be vector of 2 chars
831class Replicate2CNode : public VectorNode {
832 protected:
833  virtual BasicType elt_basic_type() const { return T_CHAR; }
834 public:
835  Replicate2CNode(Node* in1) : VectorNode(in1, 2) {}
836  virtual int Opcode() const;
837};
838
839//------------------------------Replicate8SNode---------------------------------------
840// Replicate short scalar to be vector of 8 shorts
841class Replicate8SNode : public VectorNode {
842 protected:
843  virtual BasicType elt_basic_type() const { return T_SHORT; }
844 public:
845  Replicate8SNode(Node* in1) : VectorNode(in1, 8) {}
846  virtual int Opcode() const;
847};
848
849//------------------------------Replicate4SNode---------------------------------------
850// Replicate short scalar to be vector of 4 shorts
851class Replicate4SNode : public VectorNode {
852 protected:
853  virtual BasicType elt_basic_type() const { return T_SHORT; }
854 public:
855  Replicate4SNode(Node* in1) : VectorNode(in1, 4) {}
856  virtual int Opcode() const;
857};
858
859//------------------------------Replicate2SNode---------------------------------------
860// Replicate short scalar to be vector of 2 shorts
861class Replicate2SNode : public VectorNode {
862 protected:
863  virtual BasicType elt_basic_type() const { return T_SHORT; }
864 public:
865  Replicate2SNode(Node* in1) : VectorNode(in1, 2) {}
866  virtual int Opcode() const;
867};
868
869//------------------------------Replicate4INode---------------------------------------
870// Replicate int scalar to be vector of 4 ints
871class Replicate4INode : public VectorNode {
872 protected:
873  virtual BasicType elt_basic_type() const { return T_INT; }
874 public:
875  Replicate4INode(Node* in1) : VectorNode(in1, 4) {}
876  virtual int Opcode() const;
877};
878
879//------------------------------Replicate2INode---------------------------------------
880// Replicate int scalar to be vector of 2 ints
881class Replicate2INode : public VectorNode {
882 protected:
883  virtual BasicType elt_basic_type() const { return T_INT; }
884 public:
885  Replicate2INode(Node* in1) : VectorNode(in1, 2) {}
886  virtual int Opcode() const;
887};
888
889//------------------------------Replicate2LNode---------------------------------------
890// Replicate long scalar to be vector of 2 longs
891class Replicate2LNode : public VectorNode {
892 protected:
893  virtual BasicType elt_basic_type() const { return T_LONG; }
894 public:
895  Replicate2LNode(Node* in1) : VectorNode(in1, 2) {}
896  virtual int Opcode() const;
897};
898
899//------------------------------Replicate4FNode---------------------------------------
900// Replicate float scalar to be vector of 4 floats
901class Replicate4FNode : public VectorNode {
902 protected:
903  virtual BasicType elt_basic_type() const { return T_FLOAT; }
904 public:
905  Replicate4FNode(Node* in1) : VectorNode(in1, 4) {}
906  virtual int Opcode() const;
907};
908
909//------------------------------Replicate2FNode---------------------------------------
910// Replicate float scalar to be vector of 2 floats
911class Replicate2FNode : public VectorNode {
912 protected:
913  virtual BasicType elt_basic_type() const { return T_FLOAT; }
914 public:
915  Replicate2FNode(Node* in1) : VectorNode(in1, 2) {}
916  virtual int Opcode() const;
917};
918
919//------------------------------Replicate2DNode---------------------------------------
920// Replicate double scalar to be vector of 2 doubles
921class Replicate2DNode : public VectorNode {
922 protected:
923  virtual BasicType elt_basic_type() const { return T_DOUBLE; }
924 public:
925  Replicate2DNode(Node* in1) : VectorNode(in1, 2) {}
926  virtual int Opcode() const;
927};
928
929//========================Pack_Scalars_into_a_Vector==============================
930
931//------------------------------PackNode---------------------------------------
932// Pack parent class (not for code generation).
933class PackNode : public VectorNode {
934 public:
935  PackNode(Node* in1)  : VectorNode(in1, 1) {}
936  PackNode(Node* in1, Node* n2)  : VectorNode(in1, n2, 2) {}
937  virtual int Opcode() const;
938
939  void add_opd(Node* n) {
940    add_req(n);
941    _length++;
942    assert(_length == req() - 1, "vector length matches edge count");
943  }
944
945  // Create a binary tree form for Packs. [lo, hi) (half-open) range
946  Node* binaryTreePack(Compile* C, int lo, int hi);
947
948  static PackNode* make(Compile* C, Node* s, const Type* elt_t);
949};
950
951//------------------------------PackBNode---------------------------------------
952// Pack byte scalars into vector
953class PackBNode : public PackNode {
954 protected:
955  virtual BasicType elt_basic_type() const { return T_BYTE; }
956 public:
957  PackBNode(Node* in1)  : PackNode(in1) {}
958  virtual int Opcode() const;
959};
960
961//------------------------------PackCNode---------------------------------------
962// Pack char scalars into vector
963class PackCNode : public PackNode {
964 protected:
965  virtual BasicType elt_basic_type() const { return T_CHAR; }
966 public:
967  PackCNode(Node* in1)  : PackNode(in1) {}
968  virtual int Opcode() const;
969};
970
971//------------------------------PackSNode---------------------------------------
972// Pack short scalars into a vector
973class PackSNode : public PackNode {
974 protected:
975  virtual BasicType elt_basic_type() const { return T_SHORT; }
976 public:
977  PackSNode(Node* in1)  : PackNode(in1) {}
978  virtual int Opcode() const;
979};
980
981//------------------------------PackINode---------------------------------------
982// Pack integer scalars into a vector
983class PackINode : public PackNode {
984 protected:
985  virtual BasicType elt_basic_type() const { return T_INT; }
986 public:
987  PackINode(Node* in1)  : PackNode(in1) {}
988  PackINode(Node* in1, Node* in2) : PackNode(in1, in2) {}
989  virtual int Opcode() const;
990};
991
992//------------------------------PackLNode---------------------------------------
993// Pack long scalars into a vector
994class PackLNode : public PackNode {
995 protected:
996  virtual BasicType elt_basic_type() const { return T_LONG; }
997 public:
998  PackLNode(Node* in1)  : PackNode(in1) {}
999  PackLNode(Node* in1, Node* in2) : PackNode(in1, in2) {}
1000  virtual int Opcode() const;
1001};
1002
1003//------------------------------PackFNode---------------------------------------
1004// Pack float scalars into vector
1005class PackFNode : public PackNode {
1006 protected:
1007  virtual BasicType elt_basic_type() const { return T_FLOAT; }
1008 public:
1009  PackFNode(Node* in1)  : PackNode(in1) {}
1010  PackFNode(Node* in1, Node* in2) : PackNode(in1, in2) {}
1011  virtual int Opcode() const;
1012};
1013
1014//------------------------------PackDNode---------------------------------------
1015// Pack double scalars into a vector
1016class PackDNode : public PackNode {
1017 protected:
1018  virtual BasicType elt_basic_type() const { return T_DOUBLE; }
1019 public:
1020  PackDNode(Node* in1)  : PackNode(in1) {}
1021  PackDNode(Node* in1, Node* in2) : PackNode(in1, in2) {}
1022  virtual int Opcode() const;
1023};
1024
1025// The Pack2xN nodes assist code generation.  They are created from
1026// Pack4C, etc. nodes in final_graph_reshape in the form of a
1027// balanced, binary tree.
1028
1029//------------------------------Pack2x1BNode-----------------------------------------
1030// Pack 2 1-byte integers into vector of 2 bytes
1031class Pack2x1BNode : public PackNode {
1032 protected:
1033  virtual BasicType elt_basic_type() const { return T_BYTE; }
1034 public:
1035  Pack2x1BNode(Node *in1, Node* in2) : PackNode(in1, in2) {}
1036  virtual int Opcode() const;
1037  virtual uint ideal_reg() const { return Op_RegI; }
1038};
1039
1040//------------------------------Pack2x2BNode---------------------------------------
1041// Pack 2 2-byte integers into vector of 4 bytes
1042class Pack2x2BNode : public PackNode {
1043 protected:
1044  virtual BasicType elt_basic_type() const { return T_CHAR; }
1045 public:
1046  Pack2x2BNode(Node *in1, Node* in2) : PackNode(in1, in2) {}
1047  virtual int Opcode() const;
1048  virtual uint ideal_reg() const { return Op_RegI; }
1049};
1050
1051//========================Extract_Scalar_from_Vector===============================
1052
1053//------------------------------ExtractNode---------------------------------------
1054// Extract a scalar from a vector at position "pos"
1055class ExtractNode : public Node {
1056 public:
1057  ExtractNode(Node* src, ConINode* pos) : Node(NULL, src, (Node*)pos) {
1058    assert(in(2)->get_int() >= 0, "positive constants");
1059  }
1060  virtual int Opcode() const;
1061  uint  pos() const { return in(2)->get_int(); }
1062
1063  static Node* make(Compile* C, Node* v, uint position, const Type* opd_t);
1064};
1065
1066//------------------------------ExtractBNode---------------------------------------
1067// Extract a byte from a vector at position "pos"
1068class ExtractBNode : public ExtractNode {
1069 public:
1070  ExtractBNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
1071  virtual int Opcode() const;
1072  virtual const Type *bottom_type() const { return TypeInt::INT; }
1073  virtual uint ideal_reg() const { return Op_RegI; }
1074};
1075
1076//------------------------------ExtractCNode---------------------------------------
1077// Extract a char from a vector at position "pos"
1078class ExtractCNode : public ExtractNode {
1079 public:
1080  ExtractCNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
1081  virtual int Opcode() const;
1082  virtual const Type *bottom_type() const { return TypeInt::INT; }
1083  virtual uint ideal_reg() const { return Op_RegI; }
1084};
1085
1086//------------------------------ExtractSNode---------------------------------------
1087// Extract a short from a vector at position "pos"
1088class ExtractSNode : public ExtractNode {
1089 public:
1090  ExtractSNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
1091  virtual int Opcode() const;
1092  virtual const Type *bottom_type() const { return TypeInt::INT; }
1093  virtual uint ideal_reg() const { return Op_RegI; }
1094};
1095
1096//------------------------------ExtractINode---------------------------------------
1097// Extract an int from a vector at position "pos"
1098class ExtractINode : public ExtractNode {
1099 public:
1100  ExtractINode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
1101  virtual int Opcode() const;
1102  virtual const Type *bottom_type() const { return TypeInt::INT; }
1103  virtual uint ideal_reg() const { return Op_RegI; }
1104};
1105
1106//------------------------------ExtractLNode---------------------------------------
1107// Extract a long from a vector at position "pos"
1108class ExtractLNode : public ExtractNode {
1109 public:
1110  ExtractLNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
1111  virtual int Opcode() const;
1112  virtual const Type *bottom_type() const { return TypeLong::LONG; }
1113  virtual uint ideal_reg() const { return Op_RegL; }
1114};
1115
1116//------------------------------ExtractFNode---------------------------------------
1117// Extract a float from a vector at position "pos"
1118class ExtractFNode : public ExtractNode {
1119 public:
1120  ExtractFNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
1121  virtual int Opcode() const;
1122  virtual const Type *bottom_type() const { return Type::FLOAT; }
1123  virtual uint ideal_reg() const { return Op_RegF; }
1124};
1125
1126//------------------------------ExtractDNode---------------------------------------
1127// Extract a double from a vector at position "pos"
1128class ExtractDNode : public ExtractNode {
1129 public:
1130  ExtractDNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
1131  virtual int Opcode() const;
1132  virtual const Type *bottom_type() const { return Type::DOUBLE; }
1133  virtual uint ideal_reg() const { return Op_RegD; }
1134};
1135