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 #include "precompiled.hpp"
25 #include "memory/allocation.inline.hpp"
26 #include "opto/connode.hpp"
27 #include "opto/vectornode.hpp"
28 #include "utilities/powerOfTwo.hpp"
29
30 //------------------------------VectorNode--------------------------------------
31
32 // Return the vector operator for the specified scalar operation
33 // and vector length.
34 int VectorNode::opcode(int sopc, BasicType bt) {
35 switch (sopc) {
36 case Op_AddI:
37 switch (bt) {
38 case T_BOOLEAN:
39 case T_BYTE: return Op_AddVB;
40 case T_CHAR:
41 case T_SHORT: return Op_AddVS;
42 case T_INT: return Op_AddVI;
43 default: ShouldNotReachHere(); return 0;
44 }
45 case Op_AddL:
46 assert(bt == T_LONG, "must be");
100 assert(bt == T_DOUBLE, "must be");
101 return Op_CMoveVD;
102 case Op_DivF:
103 assert(bt == T_FLOAT, "must be");
104 return Op_DivVF;
105 case Op_DivD:
106 assert(bt == T_DOUBLE, "must be");
107 return Op_DivVD;
108 case Op_AbsI:
109 switch (bt) {
110 case T_BOOLEAN:
111 case T_CHAR: return 0; // abs does not make sense for unsigned
112 case T_BYTE: return Op_AbsVB;
113 case T_SHORT: return Op_AbsVS;
114 case T_INT: return Op_AbsVI;
115 default: ShouldNotReachHere(); return 0;
116 }
117 case Op_AbsL:
118 assert(bt == T_LONG, "must be");
119 return Op_AbsVL;
120 case Op_AbsF:
121 assert(bt == T_FLOAT, "must be");
122 return Op_AbsVF;
123 case Op_AbsD:
124 assert(bt == T_DOUBLE, "must be");
125 return Op_AbsVD;
126 case Op_NegF:
127 assert(bt == T_FLOAT, "must be");
128 return Op_NegVF;
129 case Op_NegD:
130 assert(bt == T_DOUBLE, "must be");
131 return Op_NegVD;
132 case Op_RoundDoubleMode:
133 assert(bt == T_DOUBLE, "must be");
134 return Op_RoundDoubleModeV;
135 case Op_SqrtF:
136 assert(bt == T_FLOAT, "must be");
137 return Op_SqrtVF;
138 case Op_SqrtD:
139 assert(bt == T_DOUBLE, "must be");
140 return Op_SqrtVD;
141 case Op_PopCountI:
142 if (bt == T_INT) {
143 return Op_PopCountVI;
144 }
145 // Unimplemented for subword types since bit count changes
146 // depending on size of lane (and sign bit).
147 return 0;
148 case Op_LShiftI:
149 switch (bt) {
150 case T_BOOLEAN:
151 case T_BYTE: return Op_LShiftVB;
152 case T_CHAR:
153 case T_SHORT: return Op_LShiftVS;
154 case T_INT: return Op_LShiftVI;
155 default: ShouldNotReachHere(); return 0;
156 }
157 case Op_LShiftL:
158 assert(bt == T_LONG, "must be");
159 return Op_LShiftVL;
160 case Op_RShiftI:
161 switch (bt) {
162 case T_BOOLEAN:return Op_URShiftVB; // boolean is unsigned value
163 case T_CHAR: return Op_URShiftVS; // char is unsigned value
164 case T_BYTE: return Op_RShiftVB;
165 case T_SHORT: return Op_RShiftVS;
166 case T_INT: return Op_RShiftVI;
167 default: ShouldNotReachHere(); return 0;
168 }
169 case Op_RShiftL:
170 assert(bt == T_LONG, "must be");
171 return Op_RShiftVL;
172 case Op_URShiftI:
173 switch (bt) {
174 case T_BOOLEAN:return Op_URShiftVB;
175 case T_CHAR: return Op_URShiftVS;
176 case T_BYTE:
177 case T_SHORT: return 0; // Vector logical right shift for signed short
178 // values produces incorrect Java result for
179 // negative data because java code should convert
180 // a short value into int value with sign
181 // extension before a shift.
182 case T_INT: return Op_URShiftVI;
183 default: ShouldNotReachHere(); return 0;
184 }
185 case Op_URShiftL:
186 assert(bt == T_LONG, "must be");
187 return Op_URShiftVL;
188 case Op_AndI:
189 case Op_AndL:
190 return Op_AndV;
191 case Op_OrI:
192 case Op_OrL:
193 return Op_OrV;
194 case Op_XorI:
195 case Op_XorL:
196 return Op_XorV;
197 case Op_MinF:
198 assert(bt == T_FLOAT, "must be");
199 return Op_MinV;
200 case Op_MinD:
201 assert(bt == T_DOUBLE, "must be");
202 return Op_MinV;
203 case Op_MaxF:
204 assert(bt == T_FLOAT, "must be");
205 return Op_MaxV;
206 case Op_MaxD:
207 assert(bt == T_DOUBLE, "must be");
208 return Op_MaxV;
209
210 case Op_LoadB:
211 case Op_LoadUB:
212 case Op_LoadUS:
213 case Op_LoadS:
214 case Op_LoadI:
215 case Op_LoadL:
216 case Op_LoadF:
217 case Op_LoadD:
218 return Op_LoadVector;
219
220 case Op_StoreB:
221 case Op_StoreC:
222 case Op_StoreI:
223 case Op_StoreL:
224 case Op_StoreF:
225 case Op_StoreD:
226 return Op_StoreVector;
227 case Op_MulAddS2I:
228 return Op_MulAddVS2VI;
229
230 default:
231 return 0; // Unimplemented
232 }
233 }
234
235 // Also used to check if the code generator
236 // supports the vector operation.
237 bool VectorNode::implemented(int opc, uint vlen, BasicType bt) {
238 if (is_java_primitive(bt) &&
239 (vlen > 1) && is_power_of_2(vlen) &&
240 Matcher::vector_size_supported(bt, vlen)) {
241 int vopc = VectorNode::opcode(opc, bt);
242 return vopc > 0 && Matcher::match_rule_supported_vector(vopc, vlen, bt);
243 }
244 return false;
245 }
246
247 bool VectorNode::is_type_transition_short_to_int(Node* n) {
248 switch (n->Opcode()) {
249 case Op_MulAddS2I:
250 return true;
251 }
252 return false;
253 }
254
267 if (n->Opcode() == Op_RoundDoubleMode) {
268 return true;
269 }
270 return false;
271 }
272
273 bool VectorNode::is_shift(Node* n) {
274 switch (n->Opcode()) {
275 case Op_LShiftI:
276 case Op_LShiftL:
277 case Op_RShiftI:
278 case Op_RShiftL:
279 case Op_URShiftI:
280 case Op_URShiftL:
281 return true;
282 default:
283 return false;
284 }
285 }
286
287 // Check if input is loop invariant vector.
288 bool VectorNode::is_invariant_vector(Node* n) {
289 // Only Replicate vector nodes are loop invariant for now.
290 switch (n->Opcode()) {
291 case Op_ReplicateB:
292 case Op_ReplicateS:
293 case Op_ReplicateI:
294 case Op_ReplicateL:
295 case Op_ReplicateF:
296 case Op_ReplicateD:
297 return true;
298 default:
299 return false;
300 }
301 }
302
303 // [Start, end) half-open range defining which operands are vectors
304 void VectorNode::vector_operands(Node* n, uint* start, uint* end) {
305 switch (n->Opcode()) {
306 case Op_LoadB: case Op_LoadUB:
333 case Op_XorI: case Op_XorL:
334 case Op_MulAddS2I:
335 *start = 1;
336 *end = 3; // 2 vector operands
337 break;
338 case Op_CMoveI: case Op_CMoveL: case Op_CMoveF: case Op_CMoveD:
339 *start = 2;
340 *end = n->req();
341 break;
342 case Op_FmaD:
343 case Op_FmaF:
344 *start = 1;
345 *end = 4; // 3 vector operands
346 break;
347 default:
348 *start = 1;
349 *end = n->req(); // default is all operands
350 }
351 }
352
353 // Return the vector version of a scalar operation node.
354 VectorNode* VectorNode::make(int opc, Node* n1, Node* n2, uint vlen, BasicType bt) {
355 const TypeVect* vt = TypeVect::make(bt, vlen);
356 int vopc = VectorNode::opcode(opc, bt);
357 // This method should not be called for unimplemented vectors.
358 guarantee(vopc > 0, "Vector for '%s' is not implemented", NodeClassNames[opc]);
359 switch (vopc) {
360 case Op_AddVB: return new AddVBNode(n1, n2, vt);
361 case Op_AddVS: return new AddVSNode(n1, n2, vt);
362 case Op_AddVI: return new AddVINode(n1, n2, vt);
363 case Op_AddVL: return new AddVLNode(n1, n2, vt);
364 case Op_AddVF: return new AddVFNode(n1, n2, vt);
365 case Op_AddVD: return new AddVDNode(n1, n2, vt);
366
367 case Op_SubVB: return new SubVBNode(n1, n2, vt);
368 case Op_SubVS: return new SubVSNode(n1, n2, vt);
369 case Op_SubVI: return new SubVINode(n1, n2, vt);
370 case Op_SubVL: return new SubVLNode(n1, n2, vt);
371 case Op_SubVF: return new SubVFNode(n1, n2, vt);
372 case Op_SubVD: return new SubVDNode(n1, n2, vt);
373
374 case Op_MulVB: return new MulVBNode(n1, n2, vt);
375 case Op_MulVS: return new MulVSNode(n1, n2, vt);
376 case Op_MulVI: return new MulVINode(n1, n2, vt);
377 case Op_MulVL: return new MulVLNode(n1, n2, vt);
378 case Op_MulVF: return new MulVFNode(n1, n2, vt);
379 case Op_MulVD: return new MulVDNode(n1, n2, vt);
380
381 case Op_DivVF: return new DivVFNode(n1, n2, vt);
382 case Op_DivVD: return new DivVDNode(n1, n2, vt);
383
384 case Op_AbsVB: return new AbsVBNode(n1, vt);
385 case Op_AbsVS: return new AbsVSNode(n1, vt);
386 case Op_AbsVI: return new AbsVINode(n1, vt);
387 case Op_AbsVL: return new AbsVLNode(n1, vt);
388 case Op_AbsVF: return new AbsVFNode(n1, vt);
389 case Op_AbsVD: return new AbsVDNode(n1, vt);
390
391 case Op_NegVF: return new NegVFNode(n1, vt);
392 case Op_NegVD: return new NegVDNode(n1, vt);
393
394 case Op_SqrtVF: return new SqrtVFNode(n1, vt);
395 case Op_SqrtVD: return new SqrtVDNode(n1, vt);
396
397 case Op_PopCountVI: return new PopCountVINode(n1, vt);
398
399 case Op_LShiftVB: return new LShiftVBNode(n1, n2, vt);
400 case Op_LShiftVS: return new LShiftVSNode(n1, n2, vt);
401 case Op_LShiftVI: return new LShiftVINode(n1, n2, vt);
402 case Op_LShiftVL: return new LShiftVLNode(n1, n2, vt);
403
404 case Op_RShiftVB: return new RShiftVBNode(n1, n2, vt);
405 case Op_RShiftVS: return new RShiftVSNode(n1, n2, vt);
406 case Op_RShiftVI: return new RShiftVINode(n1, n2, vt);
407 case Op_RShiftVL: return new RShiftVLNode(n1, n2, vt);
408
409 case Op_URShiftVB: return new URShiftVBNode(n1, n2, vt);
410 case Op_URShiftVS: return new URShiftVSNode(n1, n2, vt);
411 case Op_URShiftVI: return new URShiftVINode(n1, n2, vt);
412 case Op_URShiftVL: return new URShiftVLNode(n1, n2, vt);
413
414 case Op_AndV: return new AndVNode(n1, n2, vt);
415 case Op_OrV: return new OrVNode (n1, n2, vt);
416 case Op_XorV: return new XorVNode(n1, n2, vt);
417
418 case Op_MinV: return new MinVNode(n1, n2, vt);
419 case Op_MaxV: return new MaxVNode(n1, n2, vt);
420
421 case Op_RoundDoubleModeV: return new RoundDoubleModeVNode(n1, n2, vt);
422
423 case Op_MulAddVS2VI: return new MulAddVS2VINode(n1, n2, vt);
424 default:
425 fatal("Missed vector creation for '%s'", NodeClassNames[vopc]);
426 return NULL;
427 }
428 }
429
430 VectorNode* VectorNode::make(int opc, Node* n1, Node* n2, Node* n3, uint vlen, BasicType bt) {
431 const TypeVect* vt = TypeVect::make(bt, vlen);
432 int vopc = VectorNode::opcode(opc, bt);
433 // This method should not be called for unimplemented vectors.
434 guarantee(vopc > 0, "Vector for '%s' is not implemented", NodeClassNames[opc]);
435 switch (vopc) {
436 case Op_FmaVD: return new FmaVDNode(n1, n2, n3, vt);
437 case Op_FmaVF: return new FmaVFNode(n1, n2, n3, vt);
438 default:
439 fatal("Missed vector creation for '%s'", NodeClassNames[vopc]);
440 return NULL;
441 }
442 }
443
444 // Scalar promotion
445 VectorNode* VectorNode::scalar2vector(Node* s, uint vlen, const Type* opd_t) {
446 BasicType bt = opd_t->array_element_basic_type();
447 const TypeVect* vt = opd_t->singleton() ? TypeVect::make(opd_t, vlen)
448 : TypeVect::make(bt, vlen);
449 switch (bt) {
450 case T_BOOLEAN:
451 case T_BYTE:
452 return new ReplicateBNode(s, vt);
453 case T_CHAR:
454 case T_SHORT:
455 return new ReplicateSNode(s, vt);
456 case T_INT:
457 return new ReplicateINode(s, vt);
458 case T_LONG:
459 return new ReplicateLNode(s, vt);
460 case T_FLOAT:
461 return new ReplicateFNode(s, vt);
462 case T_DOUBLE:
463 return new ReplicateDNode(s, vt);
464 default:
465 fatal("Type '%s' is not supported for vectors", type2name(bt));
466 return NULL;
467 }
468 }
469
470 VectorNode* VectorNode::shift_count(Node* shift, Node* cnt, uint vlen, BasicType bt) {
471 assert(VectorNode::is_shift(shift), "sanity");
472 // Match shift count type with shift vector type.
473 const TypeVect* vt = TypeVect::make(bt, vlen);
474 switch (shift->Opcode()) {
475 case Op_LShiftI:
476 case Op_LShiftL:
477 return new LShiftCntVNode(cnt, vt);
478 case Op_RShiftI:
479 case Op_RShiftL:
480 case Op_URShiftI:
481 case Op_URShiftL:
482 return new RShiftCntVNode(cnt, vt);
483 default:
484 fatal("Missed vector creation for '%s'", NodeClassNames[shift->Opcode()]);
485 return NULL;
486 }
487 }
488
489 bool VectorNode::is_vector_shift(int opc) {
490 assert(opc > _last_machine_leaf && opc < _last_opcode, "invalid opcode");
491 switch (opc) {
492 case Op_LShiftVB:
493 case Op_LShiftVS:
494 case Op_LShiftVI:
495 case Op_LShiftVL:
496 case Op_RShiftVB:
497 case Op_RShiftVS:
498 case Op_RShiftVI:
499 case Op_RShiftVL:
500 case Op_URShiftVB:
501 case Op_URShiftVS:
502 case Op_URShiftVI:
503 case Op_URShiftVL:
504 return true;
578 }
579 }
580 }
581
582 // Return the vector version of a scalar load node.
583 LoadVectorNode* LoadVectorNode::make(int opc, Node* ctl, Node* mem,
584 Node* adr, const TypePtr* atyp,
585 uint vlen, BasicType bt,
586 ControlDependency control_dependency) {
587 const TypeVect* vt = TypeVect::make(bt, vlen);
588 return new LoadVectorNode(ctl, mem, adr, atyp, vt, control_dependency);
589 }
590
591 // Return the vector version of a scalar store node.
592 StoreVectorNode* StoreVectorNode::make(int opc, Node* ctl, Node* mem,
593 Node* adr, const TypePtr* atyp, Node* val,
594 uint vlen) {
595 return new StoreVectorNode(ctl, mem, adr, atyp, val);
596 }
597
598 // Extract a scalar element of vector.
599 Node* ExtractNode::make(Node* v, uint position, BasicType bt) {
600 assert((int)position < Matcher::max_vector_size(bt), "pos in range");
601 ConINode* pos = ConINode::make((int)position);
602 switch (bt) {
603 case T_BOOLEAN:
604 return new ExtractUBNode(v, pos);
605 case T_BYTE:
606 return new ExtractBNode(v, pos);
607 case T_CHAR:
608 return new ExtractCNode(v, pos);
609 case T_SHORT:
610 return new ExtractSNode(v, pos);
611 case T_INT:
612 return new ExtractINode(v, pos);
613 case T_LONG:
614 return new ExtractLNode(v, pos);
615 case T_FLOAT:
616 return new ExtractFNode(v, pos);
617 case T_DOUBLE:
618 return new ExtractDNode(v, pos);
619 default:
620 fatal("Type '%s' is not supported for vectors", type2name(bt));
621 return NULL;
622 }
623 }
624
625 int ReductionNode::opcode(int opc, BasicType bt) {
626 int vopc = opc;
627 switch (opc) {
628 case Op_AddI:
629 assert(bt == T_INT, "must be");
630 vopc = Op_AddReductionVI;
631 break;
632 case Op_AddL:
633 assert(bt == T_LONG, "must be");
634 vopc = Op_AddReductionVL;
635 break;
636 case Op_AddF:
637 assert(bt == T_FLOAT, "must be");
638 vopc = Op_AddReductionVF;
639 break;
640 case Op_AddD:
641 assert(bt == T_DOUBLE, "must be");
642 vopc = Op_AddReductionVD;
643 break;
644 case Op_MulI:
645 assert(bt == T_INT, "must be");
646 vopc = Op_MulReductionVI;
647 break;
648 case Op_MulL:
649 assert(bt == T_LONG, "must be");
650 vopc = Op_MulReductionVL;
651 break;
652 case Op_MulF:
653 assert(bt == T_FLOAT, "must be");
654 vopc = Op_MulReductionVF;
655 break;
656 case Op_MulD:
657 assert(bt == T_DOUBLE, "must be");
658 vopc = Op_MulReductionVD;
659 break;
660 case Op_MinF:
661 assert(bt == T_FLOAT, "must be");
662 vopc = Op_MinReductionV;
663 break;
664 case Op_MinD:
665 assert(bt == T_DOUBLE, "must be");
666 vopc = Op_MinReductionV;
667 break;
668 case Op_MaxF:
669 assert(bt == T_FLOAT, "must be");
670 vopc = Op_MaxReductionV;
671 break;
672 case Op_MaxD:
673 assert(bt == T_DOUBLE, "must be");
674 vopc = Op_MaxReductionV;
675 break;
676 case Op_AndI:
677 assert(bt == T_INT, "must be");
678 vopc = Op_AndReductionV;
679 break;
680 case Op_AndL:
681 assert(bt == T_LONG, "must be");
682 vopc = Op_AndReductionV;
683 break;
684 case Op_OrI:
685 assert(bt == T_INT, "must be");
686 vopc = Op_OrReductionV;
687 break;
688 case Op_OrL:
689 assert(bt == T_LONG, "must be");
690 vopc = Op_OrReductionV;
691 break;
692 case Op_XorI:
693 assert(bt == T_INT, "must be");
694 vopc = Op_XorReductionV;
695 break;
696 case Op_XorL:
697 assert(bt == T_LONG, "must be");
698 vopc = Op_XorReductionV;
699 break;
700 default:
701 break;
702 }
703 return vopc;
704 }
705
706 // Return the appropriate reduction node.
707 ReductionNode* ReductionNode::make(int opc, Node *ctrl, Node* n1, Node* n2, BasicType bt) {
708
709 int vopc = opcode(opc, bt);
710
711 // This method should not be called for unimplemented vectors.
712 guarantee(vopc != opc, "Vector for '%s' is not implemented", NodeClassNames[opc]);
713
714 switch (vopc) {
715 case Op_AddReductionVI: return new AddReductionVINode(ctrl, n1, n2);
716 case Op_AddReductionVL: return new AddReductionVLNode(ctrl, n1, n2);
717 case Op_AddReductionVF: return new AddReductionVFNode(ctrl, n1, n2);
718 case Op_AddReductionVD: return new AddReductionVDNode(ctrl, n1, n2);
719 case Op_MulReductionVI: return new MulReductionVINode(ctrl, n1, n2);
720 case Op_MulReductionVL: return new MulReductionVLNode(ctrl, n1, n2);
721 case Op_MulReductionVF: return new MulReductionVFNode(ctrl, n1, n2);
722 case Op_MulReductionVD: return new MulReductionVDNode(ctrl, n1, n2);
723 case Op_MinReductionV: return new MinReductionVNode(ctrl, n1, n2);
724 case Op_MaxReductionV: return new MaxReductionVNode(ctrl, n1, n2);
725 case Op_AndReductionV: return new AndReductionVNode(ctrl, n1, n2);
726 case Op_OrReductionV: return new OrReductionVNode(ctrl, n1, n2);
727 case Op_XorReductionV: return new XorReductionVNode(ctrl, n1, n2);
728 default:
729 fatal("Missed vector creation for '%s'", NodeClassNames[vopc]);
730 return NULL;
731 }
732 }
733
734 bool ReductionNode::implemented(int opc, uint vlen, BasicType bt) {
735 if (is_java_primitive(bt) &&
736 (vlen > 1) && is_power_of_2(vlen) &&
737 Matcher::vector_size_supported(bt, vlen)) {
738 int vopc = ReductionNode::opcode(opc, bt);
739 return vopc != opc && Matcher::match_rule_supported(vopc);
740 }
741 return false;
742 }
|
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 #include "precompiled.hpp"
25 #include "memory/allocation.inline.hpp"
26 #include "opto/connode.hpp"
27 #include "opto/subnode.hpp"
28 #include "opto/vectornode.hpp"
29 #include "utilities/powerOfTwo.hpp"
30
31 //------------------------------VectorNode--------------------------------------
32
33 // Return the vector operator for the specified scalar operation
34 // and vector length.
35 int VectorNode::opcode(int sopc, BasicType bt) {
36 switch (sopc) {
37 case Op_AddI:
38 switch (bt) {
39 case T_BOOLEAN:
40 case T_BYTE: return Op_AddVB;
41 case T_CHAR:
42 case T_SHORT: return Op_AddVS;
43 case T_INT: return Op_AddVI;
44 default: ShouldNotReachHere(); return 0;
45 }
46 case Op_AddL:
47 assert(bt == T_LONG, "must be");
101 assert(bt == T_DOUBLE, "must be");
102 return Op_CMoveVD;
103 case Op_DivF:
104 assert(bt == T_FLOAT, "must be");
105 return Op_DivVF;
106 case Op_DivD:
107 assert(bt == T_DOUBLE, "must be");
108 return Op_DivVD;
109 case Op_AbsI:
110 switch (bt) {
111 case T_BOOLEAN:
112 case T_CHAR: return 0; // abs does not make sense for unsigned
113 case T_BYTE: return Op_AbsVB;
114 case T_SHORT: return Op_AbsVS;
115 case T_INT: return Op_AbsVI;
116 default: ShouldNotReachHere(); return 0;
117 }
118 case Op_AbsL:
119 assert(bt == T_LONG, "must be");
120 return Op_AbsVL;
121 case Op_MinI:
122 switch (bt) {
123 case T_BOOLEAN:
124 case T_CHAR: return 0;
125 case T_BYTE:
126 case T_SHORT:
127 case T_INT: return Op_MinV;
128 default: ShouldNotReachHere(); return 0;
129 }
130 case Op_MinL:
131 assert(bt == T_LONG, "must be");
132 return Op_MinV;
133 case Op_MinF:
134 assert(bt == T_FLOAT, "must be");
135 return Op_MinV;
136 case Op_MinD:
137 assert(bt == T_DOUBLE, "must be");
138 return Op_MinV;
139 case Op_MaxI:
140 switch (bt) {
141 case T_BOOLEAN:
142 case T_CHAR: return 0;
143 case T_BYTE:
144 case T_SHORT:
145 case T_INT: return Op_MaxV;
146 default: ShouldNotReachHere(); return 0;
147 }
148 case Op_MaxL:
149 assert(bt == T_LONG, "must be");
150 return Op_MaxV;
151 case Op_MaxF:
152 assert(bt == T_FLOAT, "must be");
153 return Op_MaxV;
154 case Op_MaxD:
155 assert(bt == T_DOUBLE, "must be");
156 return Op_MaxV;
157 case Op_AbsF:
158 assert(bt == T_FLOAT, "must be");
159 return Op_AbsVF;
160 case Op_AbsD:
161 assert(bt == T_DOUBLE, "must be");
162 return Op_AbsVD;
163 case Op_NegI:
164 assert(bt == T_INT, "must be");
165 return Op_NegVI;
166 case Op_NegF:
167 assert(bt == T_FLOAT, "must be");
168 return Op_NegVF;
169 case Op_NegD:
170 assert(bt == T_DOUBLE, "must be");
171 return Op_NegVD;
172 case Op_RoundDoubleMode:
173 assert(bt == T_DOUBLE, "must be");
174 return Op_RoundDoubleModeV;
175 case Op_SqrtF:
176 assert(bt == T_FLOAT, "must be");
177 return Op_SqrtVF;
178 case Op_SqrtD:
179 assert(bt == T_DOUBLE, "must be");
180 return Op_SqrtVD;
181 case Op_Not:
182 return Op_NotV;
183 case Op_PopCountI:
184 if (bt == T_INT) {
185 return Op_PopCountVI;
186 }
187 // Unimplemented for subword types since bit count changes
188 // depending on size of lane (and sign bit).
189 return 0;
190 case Op_LShiftI:
191 switch (bt) {
192 case T_BOOLEAN:
193 case T_BYTE: return Op_LShiftVB;
194 case T_CHAR:
195 case T_SHORT: return Op_LShiftVS;
196 case T_INT: return Op_LShiftVI;
197 default: ShouldNotReachHere(); return 0;
198 }
199 case Op_LShiftL:
200 assert(bt == T_LONG, "must be");
201 return Op_LShiftVL;
202 case Op_RShiftI:
203 switch (bt) {
204 case T_BOOLEAN:return Op_URShiftVB; // boolean is unsigned value
205 case T_CHAR: return Op_URShiftVS; // char is unsigned value
206 case T_BYTE: return Op_RShiftVB;
207 case T_SHORT: return Op_RShiftVS;
208 case T_INT: return Op_RShiftVI;
209 default: ShouldNotReachHere(); return 0;
210 }
211 case Op_RShiftL:
212 assert(bt == T_LONG, "must be");
213 return Op_RShiftVL;
214 case Op_URShiftB:
215 assert(bt == T_BYTE, "must be");
216 return Op_URShiftVB;
217 case Op_URShiftS:
218 assert(bt == T_SHORT, "must be");
219 return Op_URShiftVS;
220 case Op_URShiftI:
221 switch (bt) {
222 case T_BOOLEAN:return Op_URShiftVB;
223 case T_CHAR: return Op_URShiftVS;
224 case T_BYTE:
225 case T_SHORT: return 0; // Vector logical right shift for signed short
226 // values produces incorrect Java result for
227 // negative data because java code should convert
228 // a short value into int value with sign
229 // extension before a shift.
230 case T_INT: return Op_URShiftVI;
231 default: ShouldNotReachHere(); return 0;
232 }
233 case Op_URShiftL:
234 assert(bt == T_LONG, "must be");
235 return Op_URShiftVL;
236 case Op_AndI:
237 case Op_AndL:
238 return Op_AndV;
239 case Op_OrI:
240 case Op_OrL:
241 return Op_OrV;
242 case Op_XorI:
243 case Op_XorL:
244 return Op_XorV;
245
246 case Op_LoadB:
247 case Op_LoadUB:
248 case Op_LoadUS:
249 case Op_LoadS:
250 case Op_LoadI:
251 case Op_LoadL:
252 case Op_LoadF:
253 case Op_LoadD:
254 return Op_LoadVector;
255
256 case Op_StoreB:
257 case Op_StoreC:
258 case Op_StoreI:
259 case Op_StoreL:
260 case Op_StoreF:
261 case Op_StoreD:
262 return Op_StoreVector;
263 case Op_MulAddS2I:
264 return Op_MulAddVS2VI;
265
266 default:
267 return 0; // Unimplemented
268 }
269 }
270
271 int VectorNode::replicate_opcode(BasicType bt) {
272 switch(bt) {
273 case T_BOOLEAN:
274 case T_BYTE:
275 return Op_ReplicateB;
276 case T_SHORT:
277 case T_CHAR:
278 return Op_ReplicateS;
279 case T_INT:
280 return Op_ReplicateI;
281 case T_LONG:
282 return Op_ReplicateL;
283 case T_FLOAT:
284 return Op_ReplicateF;
285 case T_DOUBLE:
286 return Op_ReplicateD;
287 default:
288 break;
289 }
290
291 return 0;
292 }
293
294 // Also used to check if the code generator
295 // supports the vector operation.
296 bool VectorNode::implemented(int opc, uint vlen, BasicType bt) {
297 if (is_java_primitive(bt) &&
298 (vlen > 1) && is_power_of_2(vlen) &&
299 Matcher::vector_size_supported(bt, vlen)) {
300 int vopc = VectorNode::opcode(opc, bt);
301 return vopc > 0 && Matcher::match_rule_supported_vector(vopc, vlen, bt);
302 }
303 return false;
304 }
305
306 bool VectorNode::is_type_transition_short_to_int(Node* n) {
307 switch (n->Opcode()) {
308 case Op_MulAddS2I:
309 return true;
310 }
311 return false;
312 }
313
326 if (n->Opcode() == Op_RoundDoubleMode) {
327 return true;
328 }
329 return false;
330 }
331
332 bool VectorNode::is_shift(Node* n) {
333 switch (n->Opcode()) {
334 case Op_LShiftI:
335 case Op_LShiftL:
336 case Op_RShiftI:
337 case Op_RShiftL:
338 case Op_URShiftI:
339 case Op_URShiftL:
340 return true;
341 default:
342 return false;
343 }
344 }
345
346 bool VectorNode::is_vshift(Node* n) {
347 switch (n->Opcode()) {
348 case Op_LShiftVB:
349 case Op_LShiftVS:
350 case Op_LShiftVI:
351 case Op_LShiftVL:
352
353 case Op_RShiftVB:
354 case Op_RShiftVS:
355 case Op_RShiftVI:
356 case Op_RShiftVL:
357
358 case Op_URShiftVB:
359 case Op_URShiftVS:
360 case Op_URShiftVI:
361 case Op_URShiftVL:
362 return true;
363 default:
364 return false;
365 }
366 }
367
368 bool VectorNode::is_vshift_cnt(Node* n) {
369 switch (n->Opcode()) {
370 case Op_LShiftCntV:
371 case Op_RShiftCntV:
372 return true;
373 default:
374 return false;
375 }
376 }
377
378 // Check if input is loop invariant vector.
379 bool VectorNode::is_invariant_vector(Node* n) {
380 // Only Replicate vector nodes are loop invariant for now.
381 switch (n->Opcode()) {
382 case Op_ReplicateB:
383 case Op_ReplicateS:
384 case Op_ReplicateI:
385 case Op_ReplicateL:
386 case Op_ReplicateF:
387 case Op_ReplicateD:
388 return true;
389 default:
390 return false;
391 }
392 }
393
394 // [Start, end) half-open range defining which operands are vectors
395 void VectorNode::vector_operands(Node* n, uint* start, uint* end) {
396 switch (n->Opcode()) {
397 case Op_LoadB: case Op_LoadUB:
424 case Op_XorI: case Op_XorL:
425 case Op_MulAddS2I:
426 *start = 1;
427 *end = 3; // 2 vector operands
428 break;
429 case Op_CMoveI: case Op_CMoveL: case Op_CMoveF: case Op_CMoveD:
430 *start = 2;
431 *end = n->req();
432 break;
433 case Op_FmaD:
434 case Op_FmaF:
435 *start = 1;
436 *end = 4; // 3 vector operands
437 break;
438 default:
439 *start = 1;
440 *end = n->req(); // default is all operands
441 }
442 }
443
444 // Make a vector node for binary operation
445 VectorNode* VectorNode::make(int vopc, Node* n1, Node* n2, const TypeVect* vt) {
446 // This method should not be called for unimplemented vectors.
447 guarantee(vopc > 0, "vopc must be > 0");
448 switch (vopc) {
449 case Op_AddVB: return new AddVBNode(n1, n2, vt);
450 case Op_AddVS: return new AddVSNode(n1, n2, vt);
451 case Op_AddVI: return new AddVINode(n1, n2, vt);
452 case Op_AddVL: return new AddVLNode(n1, n2, vt);
453 case Op_AddVF: return new AddVFNode(n1, n2, vt);
454 case Op_AddVD: return new AddVDNode(n1, n2, vt);
455
456 case Op_SubVB: return new SubVBNode(n1, n2, vt);
457 case Op_SubVS: return new SubVSNode(n1, n2, vt);
458 case Op_SubVI: return new SubVINode(n1, n2, vt);
459 case Op_SubVL: return new SubVLNode(n1, n2, vt);
460 case Op_SubVF: return new SubVFNode(n1, n2, vt);
461 case Op_SubVD: return new SubVDNode(n1, n2, vt);
462
463 case Op_MulVB: return new MulVBNode(n1, n2, vt);
464 case Op_MulVS: return new MulVSNode(n1, n2, vt);
465 case Op_MulVI: return new MulVINode(n1, n2, vt);
466 case Op_MulVL: return new MulVLNode(n1, n2, vt);
467 case Op_MulVF: return new MulVFNode(n1, n2, vt);
468 case Op_MulVD: return new MulVDNode(n1, n2, vt);
469
470 case Op_DivVF: return new DivVFNode(n1, n2, vt);
471 case Op_DivVD: return new DivVDNode(n1, n2, vt);
472
473 case Op_MinV: return new MinVNode(n1, n2, vt);
474 case Op_MaxV: return new MaxVNode(n1, n2, vt);
475
476 case Op_AbsV: return new AbsVNode(n1, vt);
477 case Op_AbsVF: return new AbsVFNode(n1, vt);
478 case Op_AbsVD: return new AbsVDNode(n1, vt);
479 case Op_AbsVB: return new AbsVBNode(n1, vt);
480 case Op_AbsVS: return new AbsVSNode(n1, vt);
481 case Op_AbsVI: return new AbsVINode(n1, vt);
482 case Op_AbsVL: return new AbsVLNode(n1, vt);
483
484 case Op_NegVI: return new NegVINode(n1, vt);
485 case Op_NegVF: return new NegVFNode(n1, vt);
486 case Op_NegVD: return new NegVDNode(n1, vt);
487
488 case Op_SqrtVF: return new SqrtVFNode(n1, vt);
489 case Op_SqrtVD: return new SqrtVDNode(n1, vt);
490
491 case Op_PopCountVI: return new PopCountVINode(n1, vt);
492 case Op_NotV: return new NotVNode(n1, vt);
493
494 case Op_LShiftVB: return new LShiftVBNode(n1, n2, vt);
495 case Op_LShiftVS: return new LShiftVSNode(n1, n2, vt);
496 case Op_LShiftVI: return new LShiftVINode(n1, n2, vt);
497 case Op_LShiftVL: return new LShiftVLNode(n1, n2, vt);
498
499 case Op_RShiftVB: return new RShiftVBNode(n1, n2, vt);
500 case Op_RShiftVS: return new RShiftVSNode(n1, n2, vt);
501 case Op_RShiftVI: return new RShiftVINode(n1, n2, vt);
502 case Op_RShiftVL: return new RShiftVLNode(n1, n2, vt);
503
504 case Op_URShiftVB: return new URShiftVBNode(n1, n2, vt);
505 case Op_URShiftVS: return new URShiftVSNode(n1, n2, vt);
506 case Op_URShiftVI: return new URShiftVINode(n1, n2, vt);
507 case Op_URShiftVL: return new URShiftVLNode(n1, n2, vt);
508
509 // Variable shift left
510 case Op_VLShiftV: return new VLShiftVNode(n1, n2, vt);
511 case Op_VRShiftV: return new VRShiftVNode(n1, n2, vt);
512 case Op_VURShiftV: return new VURShiftVNode(n1, n2, vt);
513
514 case Op_AndV: return new AndVNode(n1, n2, vt);
515 case Op_OrV: return new OrVNode (n1, n2, vt);
516 case Op_XorV: return new XorVNode(n1, n2, vt);
517
518 case Op_RoundDoubleModeV: return new RoundDoubleModeVNode(n1, n2, vt);
519
520 case Op_MulAddVS2VI: return new MulAddVS2VINode(n1, n2, vt);
521 default:
522 fatal("Missed vector creation for '%s'", NodeClassNames[vopc]);
523 return NULL;
524 }
525 }
526
527 // Return the vector version of a scalar binary operation node.
528 VectorNode* VectorNode::make(int opc, Node* n1, Node* n2, uint vlen, BasicType bt) {
529 const TypeVect* vt = TypeVect::make(bt, vlen);
530 int vopc = VectorNode::opcode(opc, bt);
531 // This method should not be called for unimplemented vectors.
532 guarantee(vopc > 0, "Vector for '%s' is not implemented", NodeClassNames[opc]);
533 return make(vopc, n1, n2, vt);
534 }
535
536 // Make a vector node for ternary operation
537 VectorNode* VectorNode::make(int vopc, Node* n1, Node* n2, Node* n3, const TypeVect* vt) {
538 // This method should not be called for unimplemented vectors.
539 guarantee(vopc > 0, "vopc must be > 0");
540 switch (vopc) {
541 case Op_FmaVD: return new FmaVDNode(n1, n2, n3, vt);
542 case Op_FmaVF: return new FmaVFNode(n1, n2, n3, vt);
543 default:
544 fatal("Missed vector creation for '%s'", NodeClassNames[vopc]);
545 return NULL;
546 }
547 }
548
549 // Return the vector version of a scalar ternary operation node.
550 VectorNode* VectorNode::make(int opc, Node* n1, Node* n2, Node* n3, uint vlen, BasicType bt) {
551 const TypeVect* vt = TypeVect::make(bt, vlen);
552 int vopc = VectorNode::opcode(opc, bt);
553 // This method should not be called for unimplemented vectors.
554 guarantee(vopc > 0, "Vector for '%s' is not implemented", NodeClassNames[opc]);
555 return make(vopc, n1, n2, n3, vt);
556 }
557
558 // Scalar promotion
559 VectorNode* VectorNode::scalar2vector(Node* s, uint vlen, const Type* opd_t) {
560 BasicType bt = opd_t->array_element_basic_type();
561 const TypeVect* vt = opd_t->singleton() ? TypeVect::make(opd_t, vlen)
562 : TypeVect::make(bt, vlen);
563 switch (bt) {
564 case T_BOOLEAN:
565 case T_BYTE:
566 return new ReplicateBNode(s, vt);
567 case T_CHAR:
568 case T_SHORT:
569 return new ReplicateSNode(s, vt);
570 case T_INT:
571 return new ReplicateINode(s, vt);
572 case T_LONG:
573 return new ReplicateLNode(s, vt);
574 case T_FLOAT:
575 return new ReplicateFNode(s, vt);
576 case T_DOUBLE:
577 return new ReplicateDNode(s, vt);
578 default:
579 fatal("Type '%s' is not supported for vectors", type2name(bt));
580 return NULL;
581 }
582 }
583
584 VectorNode* VectorNode::shift_count(int opc, Node* cnt, uint vlen, BasicType bt) {
585 // Match shift count type with shift vector type.
586 const TypeVect* vt = TypeVect::make(bt, vlen);
587 switch (opc) {
588 case Op_LShiftI:
589 case Op_LShiftL:
590 return new LShiftCntVNode(cnt, vt);
591 case Op_RShiftI:
592 case Op_RShiftL:
593 case Op_URShiftB:
594 case Op_URShiftS:
595 case Op_URShiftI:
596 case Op_URShiftL:
597 return new RShiftCntVNode(cnt, vt);
598 default:
599 fatal("Missed vector creation for '%s'", NodeClassNames[opc]);
600 return NULL;
601 }
602 }
603
604 bool VectorNode::is_vector_shift(int opc) {
605 assert(opc > _last_machine_leaf && opc < _last_opcode, "invalid opcode");
606 switch (opc) {
607 case Op_LShiftVB:
608 case Op_LShiftVS:
609 case Op_LShiftVI:
610 case Op_LShiftVL:
611 case Op_RShiftVB:
612 case Op_RShiftVS:
613 case Op_RShiftVI:
614 case Op_RShiftVL:
615 case Op_URShiftVB:
616 case Op_URShiftVS:
617 case Op_URShiftVI:
618 case Op_URShiftVL:
619 return true;
693 }
694 }
695 }
696
697 // Return the vector version of a scalar load node.
698 LoadVectorNode* LoadVectorNode::make(int opc, Node* ctl, Node* mem,
699 Node* adr, const TypePtr* atyp,
700 uint vlen, BasicType bt,
701 ControlDependency control_dependency) {
702 const TypeVect* vt = TypeVect::make(bt, vlen);
703 return new LoadVectorNode(ctl, mem, adr, atyp, vt, control_dependency);
704 }
705
706 // Return the vector version of a scalar store node.
707 StoreVectorNode* StoreVectorNode::make(int opc, Node* ctl, Node* mem,
708 Node* adr, const TypePtr* atyp, Node* val,
709 uint vlen) {
710 return new StoreVectorNode(ctl, mem, adr, atyp, val);
711 }
712
713 int ExtractNode::opcode(BasicType bt) {
714 switch (bt) {
715 case T_BOOLEAN:
716 return Op_ExtractUB;
717 case T_BYTE:
718 return Op_ExtractB;
719 case T_CHAR:
720 return Op_ExtractC;
721 case T_SHORT:
722 return Op_ExtractS;
723 case T_INT:
724 return Op_ExtractI;
725 case T_LONG:
726 return Op_ExtractL;
727 case T_FLOAT:
728 return Op_ExtractF;
729 case T_DOUBLE:
730 return Op_ExtractD;
731 default:
732 fatal("Type '%s' is not supported for vectors", type2name(bt));
733 return 0;
734 }
735 }
736
737 // Extract a scalar element of vector.
738 Node* ExtractNode::make(Node* v, uint position, BasicType bt) {
739 assert((int)position < Matcher::max_vector_size(bt), "pos in range");
740 ConINode* pos = ConINode::make((int)position);
741 switch (bt) {
742 case T_BOOLEAN:
743 return new ExtractUBNode(v, pos);
744 case T_BYTE:
745 return new ExtractBNode(v, pos);
746 case T_CHAR:
747 return new ExtractCNode(v, pos);
748 case T_SHORT:
749 return new ExtractSNode(v, pos);
750 case T_INT:
751 return new ExtractINode(v, pos);
752 case T_LONG:
753 return new ExtractLNode(v, pos);
754 case T_FLOAT:
755 return new ExtractFNode(v, pos);
756 case T_DOUBLE:
757 return new ExtractDNode(v, pos);
758 default:
759 fatal("Type '%s' is not supported for vectors", type2name(bt));
760 return NULL;
761 }
762 }
763
764 int ReductionNode::opcode(int opc, BasicType bt) {
765 int vopc = opc;
766 switch (opc) {
767 case Op_AddI:
768 switch (bt) {
769 case T_BOOLEAN:
770 case T_CHAR: return 0;
771 case T_BYTE:
772 case T_SHORT:
773 case T_INT:
774 vopc = Op_AddReductionVI;
775 break;
776 default: ShouldNotReachHere(); return 0;
777 }
778 break;
779 case Op_AddL:
780 assert(bt == T_LONG, "must be");
781 vopc = Op_AddReductionVL;
782 break;
783 case Op_AddF:
784 assert(bt == T_FLOAT, "must be");
785 vopc = Op_AddReductionVF;
786 break;
787 case Op_AddD:
788 assert(bt == T_DOUBLE, "must be");
789 vopc = Op_AddReductionVD;
790 break;
791 case Op_MulI:
792 switch (bt) {
793 case T_BOOLEAN:
794 case T_CHAR: return 0;
795 case T_BYTE:
796 case T_SHORT:
797 case T_INT:
798 vopc = Op_MulReductionVI;
799 break;
800 default: ShouldNotReachHere(); return 0;
801 }
802 break;
803 case Op_MulL:
804 assert(bt == T_LONG, "must be");
805 vopc = Op_MulReductionVL;
806 break;
807 case Op_MulF:
808 assert(bt == T_FLOAT, "must be");
809 vopc = Op_MulReductionVF;
810 break;
811 case Op_MulD:
812 assert(bt == T_DOUBLE, "must be");
813 vopc = Op_MulReductionVD;
814 break;
815 case Op_MinI:
816 switch (bt) {
817 case T_BOOLEAN:
818 case T_CHAR: return 0;
819 case T_BYTE:
820 case T_SHORT:
821 case T_INT:
822 vopc = Op_MinReductionV;
823 break;
824 default: ShouldNotReachHere(); return 0;
825 }
826 break;
827 case Op_MinL:
828 assert(bt == T_LONG, "must be");
829 vopc = Op_MinReductionV;
830 break;
831 case Op_MinF:
832 assert(bt == T_FLOAT, "must be");
833 vopc = Op_MinReductionV;
834 break;
835 case Op_MinD:
836 assert(bt == T_DOUBLE, "must be");
837 vopc = Op_MinReductionV;
838 break;
839 case Op_MaxI:
840 switch (bt) {
841 case T_BOOLEAN:
842 case T_CHAR: return 0;
843 case T_BYTE:
844 case T_SHORT:
845 case T_INT:
846 vopc = Op_MaxReductionV;
847 break;
848 default: ShouldNotReachHere(); return 0;
849 }
850 break;
851 case Op_MaxL:
852 assert(bt == T_LONG, "must be");
853 vopc = Op_MaxReductionV;
854 break;
855 case Op_MaxF:
856 assert(bt == T_FLOAT, "must be");
857 vopc = Op_MaxReductionV;
858 break;
859 case Op_MaxD:
860 assert(bt == T_DOUBLE, "must be");
861 vopc = Op_MaxReductionV;
862 break;
863 case Op_AndI:
864 switch (bt) {
865 case T_BOOLEAN:
866 case T_CHAR: return 0;
867 case T_BYTE:
868 case T_SHORT:
869 case T_INT:
870 vopc = Op_AndReductionV;
871 break;
872 default: ShouldNotReachHere(); return 0;
873 }
874 break;
875 case Op_AndL:
876 assert(bt == T_LONG, "must be");
877 vopc = Op_AndReductionV;
878 break;
879 case Op_OrI:
880 switch(bt) {
881 case T_BOOLEAN:
882 case T_CHAR: return 0;
883 case T_BYTE:
884 case T_SHORT:
885 case T_INT:
886 vopc = Op_OrReductionV;
887 break;
888 default: ShouldNotReachHere(); return 0;
889 }
890 break;
891 case Op_OrL:
892 assert(bt == T_LONG, "must be");
893 vopc = Op_OrReductionV;
894 break;
895 case Op_XorI:
896 switch(bt) {
897 case T_BOOLEAN:
898 case T_CHAR: return 0;
899 case T_BYTE:
900 case T_SHORT:
901 case T_INT:
902 vopc = Op_XorReductionV;
903 break;
904 default: ShouldNotReachHere(); return 0;
905 }
906 break;
907 case Op_XorL:
908 assert(bt == T_LONG, "must be");
909 vopc = Op_XorReductionV;
910 break;
911 default:
912 break;
913 }
914 return vopc;
915 }
916
917 // Return the appropriate reduction node.
918 ReductionNode* ReductionNode::make(int opc, Node *ctrl, Node* n1, Node* n2, BasicType bt) {
919
920 int vopc = opcode(opc, bt);
921
922 // This method should not be called for unimplemented vectors.
923 guarantee(vopc != opc, "Vector for '%s' is not implemented", NodeClassNames[opc]);
924
925 switch (vopc) {
926 case Op_AddReductionVI: return new AddReductionVINode(ctrl, n1, n2);
927 case Op_AddReductionVL: return new AddReductionVLNode(ctrl, n1, n2);
928 case Op_AddReductionVF: return new AddReductionVFNode(ctrl, n1, n2);
929 case Op_AddReductionVD: return new AddReductionVDNode(ctrl, n1, n2);
930 case Op_MulReductionVI: return new MulReductionVINode(ctrl, n1, n2);
931 case Op_MulReductionVL: return new MulReductionVLNode(ctrl, n1, n2);
932 case Op_MulReductionVF: return new MulReductionVFNode(ctrl, n1, n2);
933 case Op_MulReductionVD: return new MulReductionVDNode(ctrl, n1, n2);
934 case Op_MinReductionV: return new MinReductionVNode(ctrl, n1, n2);
935 case Op_MaxReductionV: return new MaxReductionVNode(ctrl, n1, n2);
936 case Op_AndReductionV: return new AndReductionVNode(ctrl, n1, n2);
937 case Op_OrReductionV: return new OrReductionVNode(ctrl, n1, n2);
938 case Op_XorReductionV: return new XorReductionVNode(ctrl, n1, n2);
939 default:
940 fatal("Missed vector creation for '%s'", NodeClassNames[vopc]);
941 return NULL;
942 }
943 }
944
945 VectorCastNode* VectorCastNode::make(int vopc, Node* n1, BasicType bt, uint vlen) {
946 const TypeVect* vt = TypeVect::make(bt, vlen);
947 switch (vopc) {
948 case Op_VectorCastB2X: return new VectorCastB2XNode(n1, vt);
949 case Op_VectorCastS2X: return new VectorCastS2XNode(n1, vt);
950 case Op_VectorCastI2X: return new VectorCastI2XNode(n1, vt);
951 case Op_VectorCastL2X: return new VectorCastL2XNode(n1, vt);
952 case Op_VectorCastF2X: return new VectorCastF2XNode(n1, vt);
953 case Op_VectorCastD2X: return new VectorCastD2XNode(n1, vt);
954 default: fatal("unknown node: %s", NodeClassNames[vopc]);
955 }
956 return NULL;
957 }
958
959 int VectorCastNode::opcode(BasicType bt) {
960 switch (bt) {
961 case T_BYTE: return Op_VectorCastB2X;
962 case T_SHORT: return Op_VectorCastS2X;
963 case T_INT: return Op_VectorCastI2X;
964 case T_LONG: return Op_VectorCastL2X;
965 case T_FLOAT: return Op_VectorCastF2X;
966 case T_DOUBLE: return Op_VectorCastD2X;
967 default: Unimplemented();
968 }
969 return 0;
970 }
971
972 Node* ReductionNode::make_reduction_input(PhaseGVN& gvn, int opc, BasicType bt) {
973 int vopc = opcode(opc, bt);
974 guarantee(vopc != opc, "Vector reduction for '%s' is not implemented", NodeClassNames[opc]);
975
976 switch (vopc) {
977 case Op_AndReductionV:
978 switch (bt) {
979 case T_BYTE:
980 case T_SHORT:
981 case T_INT:
982 return gvn.makecon(TypeInt::MINUS_1);
983 case T_LONG:
984 return gvn.makecon(TypeLong::MINUS_1);
985 default:
986 fatal("Missed vector creation for '%s' as the basic type is not correct.", NodeClassNames[vopc]);
987 return NULL;
988 }
989 break;
990 case Op_AddReductionVI: // fallthrough
991 case Op_AddReductionVL: // fallthrough
992 case Op_AddReductionVF: // fallthrough
993 case Op_AddReductionVD:
994 case Op_OrReductionV:
995 case Op_XorReductionV:
996 return gvn.zerocon(bt);
997 case Op_MulReductionVI:
998 return gvn.makecon(TypeInt::ONE);
999 case Op_MulReductionVL:
1000 return gvn.makecon(TypeLong::ONE);
1001 case Op_MulReductionVF:
1002 return gvn.makecon(TypeF::ONE);
1003 case Op_MulReductionVD:
1004 return gvn.makecon(TypeD::ONE);
1005 case Op_MinReductionV:
1006 switch (bt) {
1007 case T_BYTE:
1008 case T_SHORT:
1009 case T_INT:
1010 return gvn.makecon(TypeInt::MAX);
1011 case T_LONG:
1012 return gvn.makecon(TypeLong::MAX);
1013 case T_FLOAT:
1014 return gvn.makecon(TypeF::POS_INF);
1015 case T_DOUBLE:
1016 return gvn.makecon(TypeD::POS_INF);
1017 default: Unimplemented(); return NULL;
1018 }
1019 break;
1020 case Op_MaxReductionV:
1021 switch (bt) {
1022 case T_BYTE:
1023 case T_SHORT:
1024 case T_INT:
1025 return gvn.makecon(TypeInt::MIN);
1026 case T_LONG:
1027 return gvn.makecon(TypeLong::MIN);
1028 case T_FLOAT:
1029 return gvn.makecon(TypeF::NEG_INF);
1030 case T_DOUBLE:
1031 return gvn.makecon(TypeD::NEG_INF);
1032 default: Unimplemented(); return NULL;
1033 }
1034 break;
1035 default:
1036 fatal("Missed vector creation for '%s'", NodeClassNames[vopc]);
1037 return NULL;
1038 }
1039 }
1040
1041 bool ReductionNode::implemented(int opc, uint vlen, BasicType bt) {
1042 if (is_java_primitive(bt) &&
1043 (vlen > 1) && is_power_of_2(vlen) &&
1044 Matcher::vector_size_supported(bt, vlen)) {
1045 int vopc = ReductionNode::opcode(opc, bt);
1046 return vopc != opc && Matcher::match_rule_supported(vopc);
1047 }
1048 return false;
1049 }
1050
1051 #ifndef PRODUCT
1052 void VectorMaskCmpNode::dump_spec(outputStream *st) const {
1053 st->print(" %d #", _predicate); _type->dump_on(st);
1054 }
1055 #endif // PRODUCT
1056
1057 Node* VectorReinterpretNode::Identity(PhaseGVN *phase) {
1058 Node* n = in(1);
1059 if (n->Opcode() == Op_VectorReinterpret) {
1060 if (Type::cmp(bottom_type(), n->in(1)->bottom_type()) == 0) {
1061 return n->in(1);
1062 }
1063 }
1064 return this;
1065 }
1066
1067 Node* VectorInsertNode::make(Node* vec, Node* new_val, int position) {
1068 assert(position < (int)vec->bottom_type()->is_vect()->length(), "pos in range");
1069 ConINode* pos = ConINode::make(position);
1070 return new VectorInsertNode(vec, new_val, pos, vec->bottom_type()->is_vect());
1071 }
1072
|