1 /*
2 * Copyright (c) 2007, 2014, 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
34 class VectorNode : public TypeNode {
35 public:
36
37 VectorNode(Node* n1, const TypeVect* vt) : TypeNode(vt, 2) {
38 init_class_id(Class_Vector);
39 init_req(1, n1);
40 }
41 VectorNode(Node* n1, Node* n2, const TypeVect* vt) : TypeNode(vt, 3) {
42 init_class_id(Class_Vector);
43 init_req(1, n1);
44 init_req(2, n2);
45 }
46
47 const TypeVect* vect_type() const { return type()->is_vect(); }
48 uint length() const { return vect_type()->length(); } // Vector length
49 uint length_in_bytes() const { return vect_type()->length_in_bytes(); }
50
51 virtual int Opcode() const;
52
53 virtual uint ideal_reg() const { return Matcher::vector_ideal_reg(vect_type()->length_in_bytes()); }
54
55 static VectorNode* scalar2vector(Node* s, uint vlen, const Type* opd_t);
56 static VectorNode* shift_count(Node* shift, Node* cnt, uint vlen, BasicType bt);
57 static VectorNode* make(int opc, Node* n1, Node* n2, uint vlen, BasicType bt);
58
59 static int opcode(int opc, BasicType bt);
60 static bool implemented(int opc, uint vlen, BasicType bt);
61 static bool is_shift(Node* n);
62 static bool is_invariant_vector(Node* n);
63 // [Start, end) half-open range defining which operands are vectors
64 static void vector_operands(Node* n, uint* start, uint* end);
65 };
66
67 //===========================Vector=ALU=Operations=============================
68
69 //------------------------------AddVBNode--------------------------------------
70 // Vector add byte
71 class AddVBNode : public VectorNode {
72 public:
73 AddVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
74 virtual int Opcode() const;
75 };
76
77 //------------------------------AddVSNode--------------------------------------
78 // Vector add char/short
79 class AddVSNode : public VectorNode {
80 public:
81 AddVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
82 virtual int Opcode() const;
83 };
84
85 //------------------------------AddVINode--------------------------------------
86 // Vector add int
87 class AddVINode : public VectorNode {
88 public:
89 AddVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
90 virtual int Opcode() const;
91 };
92
93 //------------------------------AddVLNode--------------------------------------
94 // Vector add long
95 class AddVLNode : public VectorNode {
96 public:
97 AddVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {}
98 virtual int Opcode() const;
99 };
100
101 //------------------------------AddVFNode--------------------------------------
102 // Vector add float
103 class AddVFNode : public VectorNode {
104 public:
105 AddVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {}
106 virtual int Opcode() const;
107 };
108
109 //------------------------------AddVDNode--------------------------------------
110 // Vector add double
111 class AddVDNode : public VectorNode {
112 public:
113 AddVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {}
114 virtual int Opcode() const;
115 };
116
117 //------------------------------ReductionNode------------------------------------
118 // Perform reduction of a vector
119 class ReductionNode : public Node {
120 public:
121 ReductionNode(Node *ctrl, Node* in1, Node* in2) : Node(ctrl, in1, in2) {}
122
123 static ReductionNode* make(int opc, Node *ctrl, Node* in1, Node* in2, BasicType bt);
124 static int opcode(int opc, BasicType bt);
125 static bool implemented(int opc, uint vlen, BasicType bt);
126 };
127
128 //------------------------------AddReductionVINode--------------------------------------
129 // Vector add int as a reduction
130 class AddReductionVINode : public ReductionNode {
131 public:
132 AddReductionVINode(Node * ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}
133 virtual int Opcode() const;
134 virtual const Type* bottom_type() const { return TypeInt::INT; }
135 virtual uint ideal_reg() const { return Op_RegI; }
136 };
137
138 //------------------------------AddReductionVLNode--------------------------------------
139 // Vector add long as a reduction
140 class AddReductionVLNode : public ReductionNode {
141 public:
142 AddReductionVLNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}
143 virtual int Opcode() const;
144 virtual const Type* bottom_type() const { return TypeLong::LONG; }
145 virtual uint ideal_reg() const { return Op_RegL; }
146 };
147
148 //------------------------------AddReductionVFNode--------------------------------------
149 // Vector add float as a reduction
150 class AddReductionVFNode : public ReductionNode {
151 public:
152 AddReductionVFNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}
153 virtual int Opcode() const;
154 virtual const Type* bottom_type() const { return Type::FLOAT; }
155 virtual uint ideal_reg() const { return Op_RegF; }
156 };
157
158 //------------------------------AddReductionVDNode--------------------------------------
159 // Vector add double as a reduction
160 class AddReductionVDNode : public ReductionNode {
161 public:
162 AddReductionVDNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}
163 virtual int Opcode() const;
164 virtual const Type* bottom_type() const { return Type::DOUBLE; }
165 virtual uint ideal_reg() const { return Op_RegD; }
166 };
167
168 //------------------------------SubVBNode--------------------------------------
169 // Vector subtract byte
170 class SubVBNode : public VectorNode {
171 public:
172 SubVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
173 virtual int Opcode() const;
174 };
175
176 //------------------------------SubVSNode--------------------------------------
177 // Vector subtract short
178 class SubVSNode : public VectorNode {
179 public:
180 SubVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
181 virtual int Opcode() const;
182 };
183
184 //------------------------------SubVINode--------------------------------------
185 // Vector subtract int
186 class SubVINode : public VectorNode {
187 public:
188 SubVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
189 virtual int Opcode() const;
190 };
191
192 //------------------------------SubVLNode--------------------------------------
193 // Vector subtract long
194 class SubVLNode : public VectorNode {
195 public:
196 SubVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
197 virtual int Opcode() const;
198 };
199
200 //------------------------------SubVFNode--------------------------------------
201 // Vector subtract float
202 class SubVFNode : public VectorNode {
203 public:
204 SubVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
205 virtual int Opcode() const;
206 };
207
208 //------------------------------SubVDNode--------------------------------------
209 // Vector subtract double
210 class SubVDNode : public VectorNode {
211 public:
212 SubVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
213 virtual int Opcode() const;
214 };
215
216 //------------------------------MulVSNode--------------------------------------
217 // Vector multiply short
218 class MulVSNode : public VectorNode {
219 public:
220 MulVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
221 virtual int Opcode() const;
222 };
223
224 //------------------------------MulVINode--------------------------------------
225 // Vector multiply int
226 class MulVINode : public VectorNode {
227 public:
228 MulVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
229 virtual int Opcode() const;
230 };
231
232 //------------------------------MulVLNode--------------------------------------
233 // Vector multiply long
234 class MulVLNode : public VectorNode {
235 public:
236 MulVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {}
237 virtual int Opcode() const;
238 };
239
240 //------------------------------MulVFNode--------------------------------------
241 // Vector multiply float
242 class MulVFNode : public VectorNode {
243 public:
244 MulVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {}
245 virtual int Opcode() const;
246 };
247
248 //------------------------------MulVDNode--------------------------------------
249 // Vector multiply double
250 class MulVDNode : public VectorNode {
251 public:
252 MulVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {}
253 virtual int Opcode() const;
254 };
255
256 //------------------------------MulReductionVINode--------------------------------------
257 // Vector multiply int as a reduction
258 class MulReductionVINode : public ReductionNode {
259 public:
260 MulReductionVINode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}
261 virtual int Opcode() const;
262 virtual const Type* bottom_type() const { return TypeInt::INT; }
263 virtual uint ideal_reg() const { return Op_RegI; }
264 };
265
266 //------------------------------MulReductionVLNode--------------------------------------
267 // Vector multiply int as a reduction
268 class MulReductionVLNode : public ReductionNode {
269 public:
270 MulReductionVLNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}
271 virtual int Opcode() const;
272 virtual const Type* bottom_type() const { return TypeLong::LONG; }
273 virtual uint ideal_reg() const { return Op_RegI; }
274 };
275
276 //------------------------------MulReductionVFNode--------------------------------------
277 // Vector multiply float as a reduction
278 class MulReductionVFNode : public ReductionNode {
279 public:
280 MulReductionVFNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}
281 virtual int Opcode() const;
282 virtual const Type* bottom_type() const { return Type::FLOAT; }
283 virtual uint ideal_reg() const { return Op_RegF; }
284 };
285
286 //------------------------------MulReductionVDNode--------------------------------------
287 // Vector multiply double as a reduction
288 class MulReductionVDNode : public ReductionNode {
289 public:
290 MulReductionVDNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}
291 virtual int Opcode() const;
292 virtual const Type* bottom_type() const { return Type::DOUBLE; }
293 virtual uint ideal_reg() const { return Op_RegD; }
294 };
295
296 //------------------------------DivVFNode--------------------------------------
297 // Vector divide float
298 class DivVFNode : public VectorNode {
299 public:
300 DivVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
301 virtual int Opcode() const;
302 };
303
304 //------------------------------DivVDNode--------------------------------------
305 // Vector Divide double
306 class DivVDNode : public VectorNode {
307 public:
308 DivVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
309 virtual int Opcode() const;
310 };
311
312 //------------------------------AbsVFNode--------------------------------------
313 // Vector Abs float
314 class AbsVFNode : public VectorNode {
315 public:
316 AbsVFNode(Node* in, const TypeVect* vt) : VectorNode(in,vt) {}
317 virtual int Opcode() const;
318 };
319
320 //------------------------------AbsVDNode--------------------------------------
321 // Vector Abs double
322 class AbsVDNode : public VectorNode {
323 public:
324 AbsVDNode(Node* in, const TypeVect* vt) : VectorNode(in,vt) {}
325 virtual int Opcode() const;
326 };
327
328 //------------------------------NegVFNode--------------------------------------
329 // Vector Neg float
330 class NegVFNode : public VectorNode {
331 public:
332 NegVFNode(Node* in, const TypeVect* vt) : VectorNode(in,vt) {}
333 virtual int Opcode() const;
334 };
335
336 //------------------------------NegVDNode--------------------------------------
337 // Vector Neg double
338 class NegVDNode : public VectorNode {
339 public:
340 NegVDNode(Node* in, const TypeVect* vt) : VectorNode(in,vt) {}
341 virtual int Opcode() const;
342 };
343
344 //------------------------------SqrtVDNode--------------------------------------
345 // Vector Sqrt double
346 class SqrtVDNode : public VectorNode {
347 public:
348 SqrtVDNode(Node* in, const TypeVect* vt) : VectorNode(in,vt) {}
349 virtual int Opcode() const;
350 };
351
352 //------------------------------LShiftVBNode-----------------------------------
353 // Vector left shift bytes
354 class LShiftVBNode : public VectorNode {
355 public:
356 LShiftVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
357 virtual int Opcode() const;
358 };
359
360 //------------------------------LShiftVSNode-----------------------------------
361 // Vector left shift shorts
362 class LShiftVSNode : public VectorNode {
363 public:
364 LShiftVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
365 virtual int Opcode() const;
366 };
367
368 //------------------------------LShiftVINode-----------------------------------
369 // Vector left shift ints
370 class LShiftVINode : public VectorNode {
371 public:
372 LShiftVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
373 virtual int Opcode() const;
374 };
375
376 //------------------------------LShiftVLNode-----------------------------------
377 // Vector left shift longs
378 class LShiftVLNode : public VectorNode {
379 public:
380 LShiftVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
381 virtual int Opcode() const;
382 };
383
384 //------------------------------RShiftVBNode-----------------------------------
385 // Vector right arithmetic (signed) shift bytes
386 class RShiftVBNode : public VectorNode {
387 public:
388 RShiftVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
389 virtual int Opcode() const;
390 };
391
392 //------------------------------RShiftVSNode-----------------------------------
393 // Vector right arithmetic (signed) shift shorts
394 class RShiftVSNode : public VectorNode {
395 public:
396 RShiftVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
397 virtual int Opcode() const;
398 };
399
400 //------------------------------RShiftVINode-----------------------------------
401 // Vector right arithmetic (signed) shift ints
402 class RShiftVINode : public VectorNode {
403 public:
404 RShiftVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
405 virtual int Opcode() const;
406 };
407
408 //------------------------------RShiftVLNode-----------------------------------
409 // Vector right arithmetic (signed) shift longs
410 class RShiftVLNode : public VectorNode {
411 public:
412 RShiftVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
413 virtual int Opcode() const;
414 };
415
416 //------------------------------URShiftVBNode----------------------------------
417 // Vector right logical (unsigned) shift bytes
418 class URShiftVBNode : public VectorNode {
419 public:
420 URShiftVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
421 virtual int Opcode() const;
422 };
423
424 //------------------------------URShiftVSNode----------------------------------
425 // Vector right logical (unsigned) shift shorts
426 class URShiftVSNode : public VectorNode {
427 public:
428 URShiftVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
429 virtual int Opcode() const;
430 };
431
432 //------------------------------URShiftVINode----------------------------------
433 // Vector right logical (unsigned) shift ints
434 class URShiftVINode : public VectorNode {
435 public:
436 URShiftVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
437 virtual int Opcode() const;
438 };
439
440 //------------------------------URShiftVLNode----------------------------------
441 // Vector right logical (unsigned) shift longs
442 class URShiftVLNode : public VectorNode {
443 public:
444 URShiftVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
445 virtual int Opcode() const;
446 };
447
448 //------------------------------LShiftCntVNode---------------------------------
449 // Vector left shift count
450 class LShiftCntVNode : public VectorNode {
451 public:
452 LShiftCntVNode(Node* cnt, const TypeVect* vt) : VectorNode(cnt,vt) {}
453 virtual int Opcode() const;
454 virtual uint ideal_reg() const { return Matcher::vector_shift_count_ideal_reg(vect_type()->length_in_bytes()); }
455 };
456
457 //------------------------------RShiftCntVNode---------------------------------
458 // Vector right shift count
459 class RShiftCntVNode : public VectorNode {
460 public:
461 RShiftCntVNode(Node* cnt, const TypeVect* vt) : VectorNode(cnt,vt) {}
462 virtual int Opcode() const;
463 virtual uint ideal_reg() const { return Matcher::vector_shift_count_ideal_reg(vect_type()->length_in_bytes()); }
464 };
465
466
467 //------------------------------AndVNode---------------------------------------
468 // Vector and integer
469 class AndVNode : public VectorNode {
470 public:
471 AndVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
472 virtual int Opcode() const;
473 };
474
475 //------------------------------OrVNode---------------------------------------
476 // Vector or integer
477 class OrVNode : public VectorNode {
478 public:
479 OrVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
480 virtual int Opcode() const;
481 };
482
483 //------------------------------XorVNode---------------------------------------
484 // Vector xor integer
485 class XorVNode : public VectorNode {
486 public:
487 XorVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
488 virtual int Opcode() const;
489 };
490
491 //================================= M E M O R Y ===============================
492
493 //------------------------------LoadVectorNode---------------------------------
494 // Load Vector from memory
495 class LoadVectorNode : public LoadNode {
496 public:
497 LoadVectorNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeVect* vt, ControlDependency control_dependency = LoadNode::DependsOnlyOnTest)
498 : LoadNode(c, mem, adr, at, vt, MemNode::unordered, control_dependency) {
499 init_class_id(Class_LoadVector);
500 }
501
502 const TypeVect* vect_type() const { return type()->is_vect(); }
503 uint length() const { return vect_type()->length(); } // Vector length
504
505 virtual int Opcode() const;
506
507 virtual uint ideal_reg() const { return Matcher::vector_ideal_reg(memory_size()); }
508 virtual BasicType memory_type() const { return T_VOID; }
509 virtual int memory_size() const { return vect_type()->length_in_bytes(); }
510
511 virtual int store_Opcode() const { return Op_StoreVector; }
512
513 static LoadVectorNode* make(int opc, Node* ctl, Node* mem,
514 Node* adr, const TypePtr* atyp,
515 uint vlen, BasicType bt,
516 ControlDependency control_dependency = LoadNode::DependsOnlyOnTest);
517 };
518
519 //------------------------------StoreVectorNode--------------------------------
520 // Store Vector to memory
521 class StoreVectorNode : public StoreNode {
522 public:
523 StoreVectorNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
524 : StoreNode(c, mem, adr, at, val, MemNode::unordered) {
525 assert(val->is_Vector() || val->is_LoadVector(), "sanity");
526 init_class_id(Class_StoreVector);
527 }
528
529 const TypeVect* vect_type() const { return in(MemNode::ValueIn)->bottom_type()->is_vect(); }
530 uint length() const { return vect_type()->length(); } // Vector length
531
532 virtual int Opcode() const;
533
534 virtual uint ideal_reg() const { return Matcher::vector_ideal_reg(memory_size()); }
535 virtual BasicType memory_type() const { return T_VOID; }
536 virtual int memory_size() const { return vect_type()->length_in_bytes(); }
537
538 static StoreVectorNode* make(int opc, Node* ctl, Node* mem,
539 Node* adr, const TypePtr* atyp, Node* val,
540 uint vlen);
541 };
542
543
544 //=========================Promote_Scalar_to_Vector============================
545
546 //------------------------------ReplicateBNode---------------------------------
547 // Replicate byte scalar to be vector
548 class ReplicateBNode : public VectorNode {
549 public:
550 ReplicateBNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
551 virtual int Opcode() const;
552 };
553
554 //------------------------------ReplicateSNode---------------------------------
555 // Replicate short scalar to be vector
556 class ReplicateSNode : public VectorNode {
557 public:
558 ReplicateSNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
559 virtual int Opcode() const;
560 };
561
562 //------------------------------ReplicateINode---------------------------------
563 // Replicate int scalar to be vector
564 class ReplicateINode : public VectorNode {
565 public:
566 ReplicateINode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
567 virtual int Opcode() const;
568 };
569
570 //------------------------------ReplicateLNode---------------------------------
571 // Replicate long scalar to be vector
572 class ReplicateLNode : public VectorNode {
573 public:
574 ReplicateLNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
575 virtual int Opcode() const;
576 };
577
578 //------------------------------ReplicateFNode---------------------------------
579 // Replicate float scalar to be vector
580 class ReplicateFNode : public VectorNode {
581 public:
582 ReplicateFNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
583 virtual int Opcode() const;
584 };
585
586 //------------------------------ReplicateDNode---------------------------------
587 // Replicate double scalar to be vector
588 class ReplicateDNode : public VectorNode {
589 public:
590 ReplicateDNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
591 virtual int Opcode() const;
592 };
593
594 //========================Pack_Scalars_into_a_Vector===========================
595
596 //------------------------------PackNode---------------------------------------
597 // Pack parent class (not for code generation).
598 class PackNode : public VectorNode {
599 public:
600 PackNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
601 PackNode(Node* in1, Node* n2, const TypeVect* vt) : VectorNode(in1, n2, vt) {}
602 virtual int Opcode() const;
603
604 void add_opd(Node* n) {
605 add_req(n);
606 }
607
608 // Create a binary tree form for Packs. [lo, hi) (half-open) range
609 PackNode* binary_tree_pack(int lo, int hi);
610
611 static PackNode* make(Node* s, uint vlen, BasicType bt);
612 };
613
614 //------------------------------PackBNode--------------------------------------
615 // Pack byte scalars into vector
616 class PackBNode : public PackNode {
617 public:
618 PackBNode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {}
619 virtual int Opcode() const;
620 };
621
622 //------------------------------PackSNode--------------------------------------
623 // Pack short scalars into a vector
624 class PackSNode : public PackNode {
625 public:
626 PackSNode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {}
627 PackSNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
628 virtual int Opcode() const;
629 };
630
631 //------------------------------PackINode--------------------------------------
632 // Pack integer scalars into a vector
633 class PackINode : public PackNode {
634 public:
635 PackINode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {}
636 PackINode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
637 virtual int Opcode() const;
638 };
639
640 //------------------------------PackLNode--------------------------------------
641 // Pack long scalars into a vector
642 class PackLNode : public PackNode {
643 public:
644 PackLNode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {}
645 PackLNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
646 virtual int Opcode() const;
647 };
648
649 //------------------------------Pack2LNode-------------------------------------
650 // Pack 2 long scalars into a vector
651 class Pack2LNode : public PackNode {
652 public:
653 Pack2LNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
654 virtual int Opcode() const;
655 };
656
657 //------------------------------PackFNode--------------------------------------
658 // Pack float scalars into vector
659 class PackFNode : public PackNode {
660 public:
661 PackFNode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {}
662 PackFNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
663 virtual int Opcode() const;
664 };
665
666 //------------------------------PackDNode--------------------------------------
667 // Pack double scalars into a vector
668 class PackDNode : public PackNode {
669 public:
670 PackDNode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {}
671 PackDNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
672 virtual int Opcode() const;
673 };
674
675 //------------------------------Pack2DNode-------------------------------------
676 // Pack 2 double scalars into a vector
677 class Pack2DNode : public PackNode {
678 public:
679 Pack2DNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
680 virtual int Opcode() const;
681 };
682
683
684 //========================Extract_Scalar_from_Vector===========================
685
686 //------------------------------ExtractNode------------------------------------
687 // Extract a scalar from a vector at position "pos"
688 class ExtractNode : public Node {
689 public:
690 ExtractNode(Node* src, ConINode* pos) : Node(NULL, src, (Node*)pos) {
691 assert(in(2)->get_int() >= 0, "positive constants");
692 }
693 virtual int Opcode() const;
694 uint pos() const { return in(2)->get_int(); }
695
696 static Node* make(Node* v, uint position, BasicType bt);
697 };
698
699 //------------------------------ExtractBNode-----------------------------------
700 // Extract a byte from a vector at position "pos"
701 class ExtractBNode : public ExtractNode {
702 public:
703 ExtractBNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
704 virtual int Opcode() const;
705 virtual const Type *bottom_type() const { return TypeInt::INT; }
706 virtual uint ideal_reg() const { return Op_RegI; }
707 };
708
709 //------------------------------ExtractUBNode----------------------------------
710 // Extract a boolean from a vector at position "pos"
711 class ExtractUBNode : public ExtractNode {
712 public:
713 ExtractUBNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
714 virtual int Opcode() const;
715 virtual const Type *bottom_type() const { return TypeInt::INT; }
716 virtual uint ideal_reg() const { return Op_RegI; }
717 };
718
719 //------------------------------ExtractCNode-----------------------------------
720 // Extract a char from a vector at position "pos"
721 class ExtractCNode : public ExtractNode {
722 public:
723 ExtractCNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
724 virtual int Opcode() const;
725 virtual const Type *bottom_type() const { return TypeInt::INT; }
726 virtual uint ideal_reg() const { return Op_RegI; }
727 };
728
729 //------------------------------ExtractSNode-----------------------------------
730 // Extract a short from a vector at position "pos"
731 class ExtractSNode : public ExtractNode {
732 public:
733 ExtractSNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
734 virtual int Opcode() const;
735 virtual const Type *bottom_type() const { return TypeInt::INT; }
736 virtual uint ideal_reg() const { return Op_RegI; }
737 };
738
739 //------------------------------ExtractINode-----------------------------------
740 // Extract an int from a vector at position "pos"
741 class ExtractINode : public ExtractNode {
742 public:
743 ExtractINode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
744 virtual int Opcode() const;
745 virtual const Type *bottom_type() const { return TypeInt::INT; }
746 virtual uint ideal_reg() const { return Op_RegI; }
747 };
748
749 //------------------------------ExtractLNode-----------------------------------
750 // Extract a long from a vector at position "pos"
751 class ExtractLNode : public ExtractNode {
752 public:
753 ExtractLNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
754 virtual int Opcode() const;
755 virtual const Type *bottom_type() const { return TypeLong::LONG; }
756 virtual uint ideal_reg() const { return Op_RegL; }
757 };
758
759 //------------------------------ExtractFNode-----------------------------------
760 // Extract a float from a vector at position "pos"
761 class ExtractFNode : public ExtractNode {
762 public:
763 ExtractFNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
764 virtual int Opcode() const;
765 virtual const Type *bottom_type() const { return Type::FLOAT; }
766 virtual uint ideal_reg() const { return Op_RegF; }
767 };
768
769 //------------------------------ExtractDNode-----------------------------------
770 // Extract a double from a vector at position "pos"
771 class ExtractDNode : public ExtractNode {
772 public:
773 ExtractDNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
774 virtual int Opcode() const;
775 virtual const Type *bottom_type() const { return Type::DOUBLE; }
776 virtual uint ideal_reg() const { return Op_RegD; }
777 };
778
779 #endif // SHARE_VM_OPTO_VECTORNODE_HPP