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