1 /*
2 * Copyright (c) 2007, 2017, 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 #include "precompiled.hpp"
25 #include "memory/allocation.inline.hpp"
26 #include "opto/connode.hpp"
27 #include "opto/cfgnode.hpp"
28 #include "opto/vectornode.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");
47 return Op_AddVL;
48 case Op_AddF:
49 assert(bt == T_FLOAT, "must be");
50 return Op_AddVF;
51 case Op_AddD:
52 assert(bt == T_DOUBLE, "must be");
53 return Op_AddVD;
54 case Op_SubI:
55 switch (bt) {
56 case T_BOOLEAN:
57 case T_BYTE: return Op_SubVB;
58 case T_CHAR:
59 case T_SHORT: return Op_SubVS;
60 case T_INT: return Op_SubVI;
61 default: ShouldNotReachHere(); return 0;
62 }
63 case Op_SubL:
64 assert(bt == T_LONG, "must be");
65 return Op_SubVL;
66 case Op_SubF:
67 assert(bt == T_FLOAT, "must be");
68 return Op_SubVF;
69 case Op_SubD:
70 assert(bt == T_DOUBLE, "must be");
71 return Op_SubVD;
72 case Op_MulI:
73 switch (bt) {
74 case T_BOOLEAN:
75 case T_BYTE: return Op_MulVB;
76 case T_CHAR:
77 case T_SHORT: return Op_MulVS;
78 case T_INT: return Op_MulVI;
79 default: ShouldNotReachHere(); return 0;
80 }
81 case Op_MulL:
82 assert(bt == T_LONG, "must be");
83 return Op_MulVL;
84 case Op_MulF:
85 assert(bt == T_FLOAT, "must be");
86 return Op_MulVF;
87 case Op_MulD:
88 assert(bt == T_DOUBLE, "must be");
89 return Op_MulVD;
90 case Op_FmaD:
91 assert(bt == T_DOUBLE, "must be");
92 return Op_FmaVD;
93 case Op_FmaF:
94 assert(bt == T_FLOAT, "must be");
95 return Op_FmaVF;
96 case Op_CMoveF:
97 assert(bt == T_FLOAT, "must be");
98 return Op_CMoveVF;
99 case Op_CMoveD:
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_MinI:
109 switch (bt) {
110 case T_BOOLEAN:
111 case T_CHAR: return 0;
112 case T_BYTE:
113 case T_SHORT:
114 case T_INT: return Op_MinV;
115 default: ShouldNotReachHere(); return 0;
116 }
117 case Op_MinL:
118 assert(bt == T_LONG, "must be");
119 return Op_MinV;
120 case Op_MinF:
121 assert(bt == T_FLOAT, "must be");
122 return Op_MinV;
123 case Op_MinD:
124 assert(bt == T_DOUBLE, "must be");
125 return Op_MinV;
126 case Op_MaxI:
127 switch (bt) {
128 case T_BOOLEAN:
129 case T_CHAR: return 0;
130 case T_BYTE:
131 case T_SHORT:
132 case T_INT: return Op_MaxV;
133 default: ShouldNotReachHere(); return 0;
134 }
135 case Op_MaxL:
136 assert(bt == T_LONG, "must be");
137 return Op_MaxV;
138 case Op_MaxF:
139 assert(bt == T_FLOAT, "must be");
140 return Op_MaxV;
141 case Op_MaxD:
142 assert(bt == T_DOUBLE, "must be");
143 return Op_MaxV;
144 case Op_AbsI:
145 switch (bt) {
146 case T_BOOLEAN:
147 case T_CHAR: return 0; // abs does not make sense for unsigned
148 case T_BYTE:
149 case T_SHORT:
150 case T_INT:
151 case T_LONG: return Op_AbsV;
152 default: ShouldNotReachHere(); return 0;
153 }
154 case Op_AbsF:
155 assert(bt == T_FLOAT, "must be");
156 return Op_AbsVF;
157 case Op_AbsD:
158 assert(bt == T_DOUBLE, "must be");
159 return Op_AbsVD;
160 case Op_NegI:
161 assert(bt == T_INT, "must be");
162 return Op_NegVI;
163 case Op_NegF:
164 assert(bt == T_FLOAT, "must be");
165 return Op_NegVF;
166 case Op_NegD:
167 assert(bt == T_DOUBLE, "must be");
168 return Op_NegVD;
169 case Op_SqrtF:
170 assert(bt == T_FLOAT, "must be");
171 return Op_SqrtVF;
172 case Op_SqrtD:
173 assert(bt == T_DOUBLE, "must be");
174 return Op_SqrtVD;
175 case Op_Not:
176 return Op_NotV;
177 case Op_PopCountI:
178 if (bt == T_INT) {
179 return Op_PopCountVI;
180 }
181 // Unimplemented for subword types since bit count changes
182 // depending on size of lane (and sign bit).
183 return 0;
184 case Op_LShiftI:
185 switch (bt) {
186 case T_BOOLEAN:
187 case T_BYTE: return Op_LShiftVB;
188 case T_CHAR:
189 case T_SHORT: return Op_LShiftVS;
190 case T_INT: return Op_LShiftVI;
191 default: ShouldNotReachHere(); return 0;
192 }
193 case Op_LShiftL:
194 assert(bt == T_LONG, "must be");
195 return Op_LShiftVL;
196 case Op_RShiftI:
197 switch (bt) {
198 case T_BOOLEAN:return Op_URShiftVB; // boolean is unsigned value
199 case T_CHAR: return Op_URShiftVS; // char is unsigned value
200 case T_BYTE: return Op_RShiftVB;
201 case T_SHORT: return Op_RShiftVS;
202 case T_INT: return Op_RShiftVI;
203 default: ShouldNotReachHere(); return 0;
204 }
205 case Op_RShiftL:
206 assert(bt == T_LONG, "must be");
207 return Op_RShiftVL;
208 case Op_URShiftI:
209 switch (bt) {
210 case T_BOOLEAN:return Op_URShiftVB;
211 case T_CHAR: return Op_URShiftVS;
212 case T_BYTE:
213 case T_SHORT: return 0; // Vector logical right shift for signed short
214 // values produces incorrect Java result for
215 // negative data because java code should convert
216 // a short value into int value with sign
217 // extension before a shift.
218 case T_INT: return Op_URShiftVI;
219 default: ShouldNotReachHere(); return 0;
220 }
221 case Op_URShiftL:
222 assert(bt == T_LONG, "must be");
223 return Op_URShiftVL;
224 case Op_AndI:
225 case Op_AndL:
226 return Op_AndV;
227 case Op_OrI:
228 case Op_OrL:
229 return Op_OrV;
230 case Op_XorI:
231 case Op_XorL:
232 return Op_XorV;
233
234 case Op_LoadB:
235 case Op_LoadUB:
236 case Op_LoadUS:
237 case Op_LoadS:
238 case Op_LoadI:
239 case Op_LoadL:
240 case Op_LoadF:
241 case Op_LoadD:
242 return Op_LoadVector;
243
244 case Op_StoreB:
245 case Op_StoreC:
246 case Op_StoreI:
247 case Op_StoreL:
248 case Op_StoreF:
249 case Op_StoreD:
250 return Op_StoreVector;
251
252 case Op_AddVB:
253 case Op_AddVS:
254 case Op_AddVI:
255 case Op_AddVL:
256 case Op_AddVF:
257 case Op_AddVD:
258 case Op_SubVB:
259 case Op_SubVS:
260 case Op_SubVI:
261 case Op_SubVL:
262 case Op_SubVF:
263 case Op_SubVD:
264 case Op_MulVB:
265 case Op_MulVS:
266 case Op_MulVI:
267 case Op_MulVL:
268 case Op_MulVF:
269 case Op_MulVD:
270 case Op_DivVF:
271 case Op_DivVD:
272 case Op_MinV:
273 case Op_MaxV:
274 case Op_AbsV:
275 case Op_AbsVF:
276 case Op_AbsVD:
277 case Op_NegVI:
278 case Op_NegVF:
279 case Op_NegVD:
280 case Op_SqrtVF:
281 case Op_SqrtVD:
282 case Op_NotV:
283 case Op_LShiftVB:
284 case Op_LShiftVS:
285 case Op_LShiftVI:
286 case Op_LShiftVL:
287 case Op_RShiftVB:
288 case Op_RShiftVS:
289 case Op_RShiftVI:
290 case Op_RShiftVL:
291 case Op_URShiftVB:
292 case Op_URShiftVS:
293 case Op_URShiftVI:
294 case Op_URShiftVL:
295 case Op_AndV:
296 case Op_OrV:
297 case Op_XorV:
298 case Op_VectorBlend:
299 case Op_VectorReinterpret:
300 case Op_VectorTest:
301 case Op_VectorMaskCmp:
302 case Op_VectorCastB2X:
303 case Op_VectorCastS2X:
304 case Op_VectorCastI2X:
305 case Op_VectorCastL2X:
306 case Op_VectorCastF2X:
307 case Op_VectorCastD2X:
308 // When op is already vectorized, return that directly.
309 return sopc;
310
311 default:
312 return 0; // Unimplemented
313 }
314 }
315
316 int VectorNode::replicate_opcode(BasicType bt) {
317 switch(bt) {
318 case T_BOOLEAN:
319 case T_BYTE:
320 return Op_ReplicateB;
321 case T_SHORT:
322 case T_CHAR:
323 return Op_ReplicateS;
324 case T_INT:
325 return Op_ReplicateI;
326 case T_LONG:
327 return Op_ReplicateL;
328 case T_FLOAT:
329 return Op_ReplicateF;
330 case T_DOUBLE:
331 return Op_ReplicateD;
332 default:
333 break;
334 }
335
336 return 0;
337 }
338
339 // Also used to check if the code generator
340 // supports the vector operation.
341 bool VectorNode::implemented(int opc, uint vlen, BasicType bt) {
342 if (is_java_primitive(bt) &&
343 (vlen > 1) && is_power_of_2(vlen) &&
344 Matcher::vector_size_supported(bt, vlen)) {
345 int vopc = VectorNode::opcode(opc, bt);
346 return vopc > 0 && Matcher::match_rule_supported_vector(vopc, vlen, bt);
347 }
348 return false;
349 }
350
351 bool VectorNode::is_shift(Node* n) {
352 switch (n->Opcode()) {
353 case Op_LShiftI:
354 case Op_LShiftL:
355 case Op_RShiftI:
356 case Op_RShiftL:
357 case Op_URShiftI:
358 case Op_URShiftL:
359 return true;
360 default:
361 return false;
362 }
363 }
364
365 // Check if input is loop invariant vector.
366 bool VectorNode::is_invariant_vector(Node* n) {
367 // Only Replicate vector nodes are loop invariant for now.
368 switch (n->Opcode()) {
369 case Op_ReplicateB:
370 case Op_ReplicateS:
371 case Op_ReplicateI:
372 case Op_ReplicateL:
373 case Op_ReplicateF:
374 case Op_ReplicateD:
375 return true;
376 default:
377 return false;
378 }
379 }
380
381 // [Start, end) half-open range defining which operands are vectors
382 void VectorNode::vector_operands(Node* n, uint* start, uint* end) {
383 switch (n->Opcode()) {
384 case Op_LoadB: case Op_LoadUB:
385 case Op_LoadS: case Op_LoadUS:
386 case Op_LoadI: case Op_LoadL:
387 case Op_LoadF: case Op_LoadD:
388 case Op_LoadP: case Op_LoadN:
389 *start = 0;
390 *end = 0; // no vector operands
391 break;
392 case Op_StoreB: case Op_StoreC:
393 case Op_StoreI: case Op_StoreL:
394 case Op_StoreF: case Op_StoreD:
395 case Op_StoreP: case Op_StoreN:
396 *start = MemNode::ValueIn;
397 *end = MemNode::ValueIn + 1; // 1 vector operand
398 break;
399 case Op_LShiftI: case Op_LShiftL:
400 case Op_RShiftI: case Op_RShiftL:
401 case Op_URShiftI: case Op_URShiftL:
402 *start = 1;
403 *end = 2; // 1 vector operand
404 break;
405 case Op_AddI: case Op_AddL: case Op_AddF: case Op_AddD:
406 case Op_SubI: case Op_SubL: case Op_SubF: case Op_SubD:
407 case Op_MulI: case Op_MulL: case Op_MulF: case Op_MulD:
408 case Op_DivF: case Op_DivD:
409 case Op_AndI: case Op_AndL:
410 case Op_OrI: case Op_OrL:
411 case Op_XorI: case Op_XorL:
412 *start = 1;
413 *end = 3; // 2 vector operands
414 break;
415 case Op_CMoveI: case Op_CMoveL: case Op_CMoveF: case Op_CMoveD:
416 *start = 2;
417 *end = n->req();
418 break;
419 case Op_FmaD:
420 case Op_FmaF:
421 *start = 1;
422 *end = 4; // 3 vector operands
423 break;
424 default:
425 *start = 1;
426 *end = n->req(); // default is all operands
427 }
428 }
429
430 // Return the vector version of a scalar operation node.
431 VectorNode* VectorNode::make(int opc, Node* n1, Node* n2, uint vlen, BasicType bt) {
432 const TypeVect* vt = TypeVect::make(bt, vlen);
433 int vopc = VectorNode::opcode(opc, bt);
434 // This method should not be called for unimplemented vectors.
435 guarantee(vopc > 0, "Vector for '%s' is not implemented", NodeClassNames[opc]);
436 switch (vopc) {
437 case Op_AddVB: return new AddVBNode(n1, n2, vt);
438 case Op_AddVS: return new AddVSNode(n1, n2, vt);
439 case Op_AddVI: return new AddVINode(n1, n2, vt);
440 case Op_AddVL: return new AddVLNode(n1, n2, vt);
441 case Op_AddVF: return new AddVFNode(n1, n2, vt);
442 case Op_AddVD: return new AddVDNode(n1, n2, vt);
443
444 case Op_SubVB: return new SubVBNode(n1, n2, vt);
445 case Op_SubVS: return new SubVSNode(n1, n2, vt);
446 case Op_SubVI: return new SubVINode(n1, n2, vt);
447 case Op_SubVL: return new SubVLNode(n1, n2, vt);
448 case Op_SubVF: return new SubVFNode(n1, n2, vt);
449 case Op_SubVD: return new SubVDNode(n1, n2, vt);
450
451 case Op_MulVB: return new MulVBNode(n1, n2, vt);
452 case Op_MulVS: return new MulVSNode(n1, n2, vt);
453 case Op_MulVI: return new MulVINode(n1, n2, vt);
454 case Op_MulVL: return new MulVLNode(n1, n2, vt);
455 case Op_MulVF: return new MulVFNode(n1, n2, vt);
456 case Op_MulVD: return new MulVDNode(n1, n2, vt);
457
458 case Op_DivVF: return new DivVFNode(n1, n2, vt);
459 case Op_DivVD: return new DivVDNode(n1, n2, vt);
460
461 case Op_MinV: return new MinVNode(n1, n2, vt);
462 case Op_MaxV: return new MaxVNode(n1, n2, vt);
463
464 case Op_AbsV: return new AbsVNode(n1, vt);
465 case Op_AbsVF: return new AbsVFNode(n1, vt);
466 case Op_AbsVD: return new AbsVDNode(n1, vt);
467
468 case Op_NegVI: return new NegVINode(n1, vt);
469 case Op_NegVF: return new NegVFNode(n1, vt);
470 case Op_NegVD: return new NegVDNode(n1, vt);
471
472 case Op_SqrtVF: return new SqrtVFNode(n1, vt);
473 case Op_SqrtVD: return new SqrtVDNode(n1, vt);
474
475 case Op_PopCountVI: return new PopCountVINode(n1, vt);
476 case Op_NotV: return new NotVNode(n1, vt);
477
478 case Op_LShiftVB: return new LShiftVBNode(n1, n2, vt);
479 case Op_LShiftVS: return new LShiftVSNode(n1, n2, vt);
480 case Op_LShiftVI: return new LShiftVINode(n1, n2, vt);
481 case Op_LShiftVL: return new LShiftVLNode(n1, n2, vt);
482
483 case Op_RShiftVB: return new RShiftVBNode(n1, n2, vt);
484 case Op_RShiftVS: return new RShiftVSNode(n1, n2, vt);
485 case Op_RShiftVI: return new RShiftVINode(n1, n2, vt);
486 case Op_RShiftVL: return new RShiftVLNode(n1, n2, vt);
487
488 case Op_URShiftVB: return new URShiftVBNode(n1, n2, vt);
489 case Op_URShiftVS: return new URShiftVSNode(n1, n2, vt);
490 case Op_URShiftVI: return new URShiftVINode(n1, n2, vt);
491 case Op_URShiftVL: return new URShiftVLNode(n1, n2, vt);
492
493 case Op_AndV: return new AndVNode(n1, n2, vt);
494 case Op_OrV: return new OrVNode (n1, n2, vt);
495 case Op_XorV: return new XorVNode(n1, n2, vt);
496
497 case Op_VectorCastB2X: return new VectorCastB2XNode(n1, vt);
498 case Op_VectorCastS2X: return new VectorCastS2XNode(n1, vt);
499 case Op_VectorCastI2X: return new VectorCastI2XNode(n1, vt);
500 case Op_VectorCastL2X: return new VectorCastL2XNode(n1, vt);
501 case Op_VectorCastF2X: return new VectorCastF2XNode(n1, vt);
502 case Op_VectorCastD2X: return new VectorCastD2XNode(n1, vt);
503
504 default:
505 fatal("Missed vector creation for '%s'", NodeClassNames[vopc]);
506 return NULL;
507 }
508 }
509
510 VectorNode* VectorNode::make(int opc, Node* n1, Node* n2, Node* n3, uint vlen, BasicType bt) {
511 const TypeVect* vt = TypeVect::make(bt, vlen);
512 int vopc = VectorNode::opcode(opc, bt);
513 // This method should not be called for unimplemented vectors.
514 guarantee(vopc > 0, "Vector for '%s' is not implemented", NodeClassNames[opc]);
515 switch (vopc) {
516 case Op_FmaVD: return new FmaVDNode(n1, n2, n3, vt);
517 case Op_FmaVF: return new FmaVFNode(n1, n2, n3, vt);
518 default:
519 fatal("Missed vector creation for '%s'", NodeClassNames[vopc]);
520 return NULL;
521 }
522 }
523
524 // Scalar promotion
525 VectorNode* VectorNode::scalar2vector(Node* s, uint vlen, const Type* opd_t) {
526 BasicType bt = opd_t->array_element_basic_type();
527 const TypeVect* vt = opd_t->singleton() ? TypeVect::make(opd_t, vlen)
528 : TypeVect::make(bt, vlen);
529 switch (bt) {
530 case T_BOOLEAN:
531 case T_BYTE:
532 return new ReplicateBNode(s, vt);
533 case T_CHAR:
534 case T_SHORT:
535 return new ReplicateSNode(s, vt);
536 case T_INT:
537 return new ReplicateINode(s, vt);
538 case T_LONG:
539 return new ReplicateLNode(s, vt);
540 case T_FLOAT:
541 return new ReplicateFNode(s, vt);
542 case T_DOUBLE:
543 return new ReplicateDNode(s, vt);
544 default:
545 fatal("Type '%s' is not supported for vectors", type2name(bt));
546 return NULL;
547 }
548 }
549
550 VectorNode* VectorNode::shift_count(int opc, Node* cnt, uint vlen, BasicType bt) {
551 assert(!cnt->is_Con(), "only variable shift count");
552 // Match shift count type with shift vector type.
553 const TypeVect* vt = TypeVect::make(bt, vlen);
554 switch (opc) {
555 case Op_LShiftI:
556 case Op_LShiftL:
557 return new LShiftCntVNode(cnt, vt);
558 case Op_RShiftI:
559 case Op_RShiftL:
560 case Op_URShiftI:
561 case Op_URShiftL:
562 return new RShiftCntVNode(cnt, vt);
563 default:
564 fatal("Missed vector creation for '%s'", NodeClassNames[opc]);
565 return NULL;
566 }
567 }
568
569 // Return initial Pack node. Additional operands added with add_opd() calls.
570 PackNode* PackNode::make(Node* s, uint vlen, BasicType bt) {
571 const TypeVect* vt = TypeVect::make(bt, vlen);
572 switch (bt) {
573 case T_BOOLEAN:
574 case T_BYTE:
575 return new PackBNode(s, vt);
576 case T_CHAR:
577 case T_SHORT:
578 return new PackSNode(s, vt);
579 case T_INT:
580 return new PackINode(s, vt);
581 case T_LONG:
582 return new PackLNode(s, vt);
583 case T_FLOAT:
584 return new PackFNode(s, vt);
585 case T_DOUBLE:
586 return new PackDNode(s, vt);
587 default:
588 fatal("Type '%s' is not supported for vectors", type2name(bt));
589 return NULL;
590 }
591 }
592
593 // Create a binary tree form for Packs. [lo, hi) (half-open) range
594 PackNode* PackNode::binary_tree_pack(int lo, int hi) {
595 int ct = hi - lo;
596 assert(is_power_of_2(ct), "power of 2");
597 if (ct == 2) {
598 PackNode* pk = PackNode::make(in(lo), 2, vect_type()->element_basic_type());
599 pk->add_opd(in(lo+1));
600 return pk;
601 } else {
602 int mid = lo + ct/2;
603 PackNode* n1 = binary_tree_pack(lo, mid);
604 PackNode* n2 = binary_tree_pack(mid, hi );
605
606 BasicType bt = n1->vect_type()->element_basic_type();
607 assert(bt == n2->vect_type()->element_basic_type(), "should be the same");
608 switch (bt) {
609 case T_BOOLEAN:
610 case T_BYTE:
611 return new PackSNode(n1, n2, TypeVect::make(T_SHORT, 2));
612 case T_CHAR:
613 case T_SHORT:
614 return new PackINode(n1, n2, TypeVect::make(T_INT, 2));
615 case T_INT:
616 return new PackLNode(n1, n2, TypeVect::make(T_LONG, 2));
617 case T_LONG:
618 return new Pack2LNode(n1, n2, TypeVect::make(T_LONG, 2));
619 case T_FLOAT:
620 return new PackDNode(n1, n2, TypeVect::make(T_DOUBLE, 2));
621 case T_DOUBLE:
622 return new Pack2DNode(n1, n2, TypeVect::make(T_DOUBLE, 2));
623 default:
624 fatal("Type '%s' is not supported for vectors", type2name(bt));
625 return NULL;
626 }
627 }
628 }
629
630 // Return the vector version of a scalar load node.
631 LoadVectorNode* LoadVectorNode::make(int opc, Node* ctl, Node* mem,
632 Node* adr, const TypePtr* atyp,
633 uint vlen, BasicType bt,
634 ControlDependency control_dependency) {
635 const TypeVect* vt = TypeVect::make(bt, vlen);
636 return new LoadVectorNode(ctl, mem, adr, atyp, vt, control_dependency);
637 }
638
639 // Return the vector version of a scalar store node.
640 StoreVectorNode* StoreVectorNode::make(int opc, Node* ctl, Node* mem,
641 Node* adr, const TypePtr* atyp, Node* val,
642 uint vlen) {
643 return new StoreVectorNode(ctl, mem, adr, atyp, val);
644 }
645
646 // Extract a scalar element of vector.
647 Node* ExtractNode::make(Node* v, uint position, BasicType bt) {
648 assert((int)position < Matcher::max_vector_size(bt), "pos in range");
649 ConINode* pos = ConINode::make((int)position);
650 switch (bt) {
651 case T_BOOLEAN:
652 return new ExtractUBNode(v, pos);
653 case T_BYTE:
654 return new ExtractBNode(v, pos);
655 case T_CHAR:
656 return new ExtractCNode(v, pos);
657 case T_SHORT:
658 return new ExtractSNode(v, pos);
659 case T_INT:
660 return new ExtractINode(v, pos);
661 case T_LONG:
662 return new ExtractLNode(v, pos);
663 case T_FLOAT:
664 return new ExtractFNode(v, pos);
665 case T_DOUBLE:
666 return new ExtractDNode(v, pos);
667 default:
668 fatal("Type '%s' is not supported for vectors", type2name(bt));
669 return NULL;
670 }
671 }
672
673 int ReductionNode::opcode(int opc, BasicType bt) {
674 int vopc = opc;
675 switch (opc) {
676 case Op_AddI:
677 switch (bt) {
678 case T_BOOLEAN:
679 case T_CHAR: return 0;
680 case T_BYTE:
681 case T_SHORT:
682 case T_INT:
683 vopc = Op_AddReductionVI;
684 break;
685 default: ShouldNotReachHere(); return 0;
686 }
687 break;
688 case Op_AddL:
689 assert(bt == T_LONG, "must be");
690 vopc = Op_AddReductionVL;
691 break;
692 case Op_AddF:
693 assert(bt == T_FLOAT, "must be");
694 vopc = Op_AddReductionVF;
695 break;
696 case Op_AddD:
697 assert(bt == T_DOUBLE, "must be");
698 vopc = Op_AddReductionVD;
699 break;
700 case Op_MulI:
701 assert(bt == T_INT, "must be");
702 vopc = Op_MulReductionVI;
703 break;
704 case Op_MulL:
705 assert(bt == T_LONG, "must be");
706 vopc = Op_MulReductionVL;
707 break;
708 case Op_MulF:
709 assert(bt == T_FLOAT, "must be");
710 vopc = Op_MulReductionVF;
711 break;
712 case Op_MulD:
713 assert(bt == T_DOUBLE, "must be");
714 vopc = Op_MulReductionVD;
715 break;
716 case Op_AndI:
717 switch (bt) {
718 case T_BOOLEAN:
719 case T_CHAR: return 0;
720 case T_BYTE:
721 case T_SHORT:
722 case T_INT:
723 vopc = Op_AndReductionV;
724 break;
725 default: ShouldNotReachHere(); return 0;
726 }
727 break;
728 case Op_AndL:
729 assert(bt == T_LONG, "must be");
730 vopc = Op_AndReductionV;
731 break;
732 case Op_OrI:
733 assert(bt == T_INT, "must be");
734 vopc = Op_OrReductionV;
735 break;
736 case Op_OrL:
737 assert(bt == T_LONG, "must be");
738 vopc = Op_OrReductionV;
739 break;
740 case Op_XorI:
741 assert(bt == T_INT, "must be");
742 vopc = Op_XorReductionV;
743 break;
744 case Op_XorL:
745 assert(bt == T_LONG, "must be");
746 vopc = Op_XorReductionV;
747 break;
748 case Op_SubI:
749 assert(bt == T_INT, "must be");
750 vopc = Op_SubReductionV;
751 break;
752 case Op_SubL:
753 assert(bt == T_LONG, "must be");
754 vopc = Op_SubReductionV;
755 break;
756 // TODO: add MulL for targets that support it
757 default:
758 break;
759 }
760 return vopc;
761 }
762
763 // Return the appropriate reduction node.
764 ReductionNode* ReductionNode::make(int opc, Node *ctrl, Node* n1, Node* n2, BasicType bt) {
765
766 int vopc = opcode(opc, bt);
767
768 // This method should not be called for unimplemented vectors.
769 guarantee(vopc != opc, "Vector for '%s' is not implemented", NodeClassNames[opc]);
770
771 switch (vopc) {
772 case Op_AddReductionVI: return new AddReductionVINode(ctrl, n1, n2);
773 case Op_AddReductionVL: return new AddReductionVLNode(ctrl, n1, n2);
774 case Op_AddReductionVF: return new AddReductionVFNode(ctrl, n1, n2);
775 case Op_AddReductionVD: return new AddReductionVDNode(ctrl, n1, n2);
776 case Op_MulReductionVI: return new MulReductionVINode(ctrl, n1, n2);
777 case Op_MulReductionVL: return new MulReductionVLNode(ctrl, n1, n2);
778 case Op_MulReductionVF: return new MulReductionVFNode(ctrl, n1, n2);
779 case Op_MulReductionVD: return new MulReductionVDNode(ctrl, n1, n2);
780 case Op_AndReductionV: return new AndReductionVNode(ctrl, n1, n2);
781 case Op_OrReductionV: return new OrReductionVNode(ctrl, n1, n2);
782 case Op_XorReductionV: return new XorReductionVNode(ctrl, n1, n2);
783 case Op_SubReductionV: return new SubReductionVNode(ctrl, n1, n2);
784 default:
785 fatal("Missed vector creation for '%s'", NodeClassNames[vopc]);
786 return NULL;
787 }
788 }
789
790 Node* ReductionNode::make_reduction_input(PhaseGVN& gvn, int opc, BasicType bt) {
791 int vopc = opcode(opc, bt);
792 guarantee(vopc != opc, "Vector reduction for '%s' is not implemented", NodeClassNames[opc]);
793
794 switch (vopc) {
795 case Op_AndReductionV:
796 switch (bt) {
797 case T_BYTE:
798 case T_SHORT:
799 case T_INT:
800 return gvn.makecon(TypeInt::MINUS_1);
801 case T_LONG:
802 return gvn.makecon(TypeLong::MINUS_1);
803 default:
804 fatal("Missed vector creation for '%s' as the basic type is not correct.", NodeClassNames[vopc]);
805 return NULL;
806 }
807 break;
808 case Op_AddReductionVI: // fallthrough
809 case Op_AddReductionVL: // fallthrough
810 case Op_AddReductionVF: // fallthrough
811 case Op_AddReductionVD:
812 case Op_OrReductionV:
813 case Op_XorReductionV:
814 case Op_SubReductionV:
815 return gvn.zerocon(bt);
816 case Op_MulReductionVI:
817 return gvn.makecon(TypeInt::ONE);
818 case Op_MulReductionVL:
819 return gvn.makecon(TypeLong::ONE);
820 case Op_MulReductionVF:
821 return gvn.makecon(TypeF::ONE);
822 case Op_MulReductionVD:
823 return gvn.makecon(TypeD::ONE);
824 default:
825 fatal("Missed vector creation for '%s'", NodeClassNames[vopc]);
826 return NULL;
827 }
828 }
829
830 bool ReductionNode::implemented(int opc, uint vlen, BasicType bt) {
831 if (is_java_primitive(bt) &&
832 (vlen > 1) && is_power_of_2(vlen) &&
833 Matcher::vector_size_supported(bt, vlen)) {
834 int vopc = ReductionNode::opcode(opc, bt);
835 return vopc != opc && Matcher::match_rule_supported(vopc);
836 }
837 return false;
838 }
839
840 #ifndef PRODUCT
841 void VectorBoxAllocateNode::dump_spec(outputStream *st) const {
842 CallStaticJavaNode::dump_spec(st);
843 }
844
845 void VectorMaskCmpNode::dump_spec(outputStream *st) const {
846 st->print(" %d #", _predicate); _type->dump_on(st);
847 }
848 #endif // PRODUCT
849
850 Node* VectorUnboxNode::Identity(PhaseGVN *phase) {
851 Node* n = obj()->uncast();
852 if (n->Opcode() == Op_VectorBox) {
853 return n->in(VectorBoxNode::Value);
854 }
855 return this;
856 }
857
858 const TypeFunc* VectorBoxNode::vec_box_type(const TypeInstPtr* box_type) {
859 const Type** fields = TypeTuple::fields(0);
860 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms, fields);
861
862 fields = TypeTuple::fields(1);
863 fields[TypeFunc::Parms+0] = box_type;
864 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
865
866 return TypeFunc::make(domain, range);
867 }
868
869 Node* SubReductionVNode::Ideal(PhaseGVN* phase, bool can_reshape) {
870 Node* ctrl = in(0);
871 Node* in1 = in(1);
872 Node* in2 = in(2);
873
874 if (phase->type(in1)->isa_int()) {
875 assert(phase->type(in2)->is_vect()->element_type()->is_int(), "must be consistent");
876 return new NegINode(phase->transform(new AddReductionVINode(ctrl,in1,in2)));
877 } else if (phase->type(in1)->isa_long()) {
878 return new NegLNode(phase->transform(new AddReductionVLNode(ctrl,in1,in2)));
879 } else {
880 Unimplemented();
881 return NULL;
882 }
883 }