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/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");
48 return Op_AddVL;
49 case Op_AddF:
50 assert(bt == T_FLOAT, "must be");
51 return Op_AddVF;
52 case Op_AddD:
53 assert(bt == T_DOUBLE, "must be");
54 return Op_AddVD;
55 case Op_SubI:
56 switch (bt) {
57 case T_BOOLEAN:
58 case T_BYTE: return Op_SubVB;
59 case T_CHAR:
60 case T_SHORT: return Op_SubVS;
61 case T_INT: return Op_SubVI;
62 default: ShouldNotReachHere(); return 0;
63 }
64 case Op_SubL:
65 assert(bt == T_LONG, "must be");
66 return Op_SubVL;
67 case Op_SubF:
68 assert(bt == T_FLOAT, "must be");
69 return Op_SubVF;
70 case Op_SubD:
71 assert(bt == T_DOUBLE, "must be");
72 return Op_SubVD;
73 case Op_MulI:
74 switch (bt) {
75 case T_BOOLEAN:return 0;
76 case T_BYTE: return Op_MulVB;
77 case T_CHAR:
78 case T_SHORT: return Op_MulVS;
79 case T_INT: return Op_MulVI;
80 default: ShouldNotReachHere(); return 0;
81 }
82 case Op_MulL:
83 assert(bt == T_LONG, "must be");
84 return Op_MulVL;
85 case Op_MulF:
86 assert(bt == T_FLOAT, "must be");
87 return Op_MulVF;
88 case Op_MulD:
89 assert(bt == T_DOUBLE, "must be");
90 return Op_MulVD;
91 case Op_FmaD:
92 assert(bt == T_DOUBLE, "must be");
93 return Op_FmaVD;
94 case Op_FmaF:
95 assert(bt == T_FLOAT, "must be");
96 return Op_FmaVF;
97 case Op_CMoveF:
98 assert(bt == T_FLOAT, "must be");
99 return Op_CMoveVF;
100 case Op_CMoveD:
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
314 bool VectorNode::is_type_transition_to_int(Node* n) {
315 return is_type_transition_short_to_int(n);
316 }
317
318 bool VectorNode::is_muladds2i(Node* n) {
319 if (n->Opcode() == Op_MulAddS2I) {
320 return true;
321 }
322 return false;
323 }
324
325 bool VectorNode::is_roundopD(Node *n) {
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:
398 case Op_LoadS: case Op_LoadUS:
399 case Op_LoadI: case Op_LoadL:
400 case Op_LoadF: case Op_LoadD:
401 case Op_LoadP: case Op_LoadN:
402 *start = 0;
403 *end = 0; // no vector operands
404 break;
405 case Op_StoreB: case Op_StoreC:
406 case Op_StoreI: case Op_StoreL:
407 case Op_StoreF: case Op_StoreD:
408 case Op_StoreP: case Op_StoreN:
409 *start = MemNode::ValueIn;
410 *end = MemNode::ValueIn + 1; // 1 vector operand
411 break;
412 case Op_LShiftI: case Op_LShiftL:
413 case Op_RShiftI: case Op_RShiftL:
414 case Op_URShiftI: case Op_URShiftL:
415 *start = 1;
416 *end = 2; // 1 vector operand
417 break;
418 case Op_AddI: case Op_AddL: case Op_AddF: case Op_AddD:
419 case Op_SubI: case Op_SubL: case Op_SubF: case Op_SubD:
420 case Op_MulI: case Op_MulL: case Op_MulF: case Op_MulD:
421 case Op_DivF: case Op_DivD:
422 case Op_AndI: case Op_AndL:
423 case Op_OrI: case Op_OrL:
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;
620 default:
621 return false;
622 }
623 }
624
625 bool VectorNode::is_vector_shift_count(int opc) {
626 assert(opc > _last_machine_leaf && opc < _last_opcode, "invalid opcode");
627 switch (opc) {
628 case Op_RShiftCntV:
629 case Op_LShiftCntV:
630 return true;
631 default:
632 return false;
633 }
634 }
635
636 static bool is_con_M1(Node* n) {
637 if (n->is_Con()) {
638 const Type* t = n->bottom_type();
639 if (t->isa_int() && t->is_int()->get_con() == -1) {
640 return true;
641 }
642 if (t->isa_long() && t->is_long()->get_con() == -1) {
643 return true;
644 }
645 }
646 return false;
647 }
648
649 bool VectorNode::is_all_ones_vector(Node* n) {
650 switch (n->Opcode()) {
651 case Op_ReplicateB:
652 case Op_ReplicateS:
653 case Op_ReplicateI:
654 case Op_ReplicateL:
655 return is_con_M1(n->in(1));
656 default:
657 return false;
658 }
659 }
660
661 bool VectorNode::is_vector_bitwise_not_pattern(Node* n) {
662 if (n->Opcode() == Op_XorV) {
663 return is_all_ones_vector(n->in(1)) ||
664 is_all_ones_vector(n->in(2));
665 }
666 return false;
667 }
668
669 // Return initial Pack node. Additional operands added with add_opd() calls.
670 PackNode* PackNode::make(Node* s, uint vlen, BasicType bt) {
671 const TypeVect* vt = TypeVect::make(bt, vlen);
672 switch (bt) {
673 case T_BOOLEAN:
674 case T_BYTE:
675 return new PackBNode(s, vt);
676 case T_CHAR:
677 case T_SHORT:
678 return new PackSNode(s, vt);
679 case T_INT:
680 return new PackINode(s, vt);
681 case T_LONG:
682 return new PackLNode(s, vt);
683 case T_FLOAT:
684 return new PackFNode(s, vt);
685 case T_DOUBLE:
686 return new PackDNode(s, vt);
687 default:
688 fatal("Type '%s' is not supported for vectors", type2name(bt));
689 return NULL;
690 }
691 }
692
693 // Create a binary tree form for Packs. [lo, hi) (half-open) range
694 PackNode* PackNode::binary_tree_pack(int lo, int hi) {
695 int ct = hi - lo;
696 assert(is_power_of_2(ct), "power of 2");
697 if (ct == 2) {
698 PackNode* pk = PackNode::make(in(lo), 2, vect_type()->element_basic_type());
699 pk->add_opd(in(lo+1));
700 return pk;
701 } else {
702 int mid = lo + ct/2;
703 PackNode* n1 = binary_tree_pack(lo, mid);
704 PackNode* n2 = binary_tree_pack(mid, hi );
705
706 BasicType bt = n1->vect_type()->element_basic_type();
707 assert(bt == n2->vect_type()->element_basic_type(), "should be the same");
708 switch (bt) {
709 case T_BOOLEAN:
710 case T_BYTE:
711 return new PackSNode(n1, n2, TypeVect::make(T_SHORT, 2));
712 case T_CHAR:
713 case T_SHORT:
714 return new PackINode(n1, n2, TypeVect::make(T_INT, 2));
715 case T_INT:
716 return new PackLNode(n1, n2, TypeVect::make(T_LONG, 2));
717 case T_LONG:
718 return new Pack2LNode(n1, n2, TypeVect::make(T_LONG, 2));
719 case T_FLOAT:
720 return new PackDNode(n1, n2, TypeVect::make(T_DOUBLE, 2));
721 case T_DOUBLE:
722 return new Pack2DNode(n1, n2, TypeVect::make(T_DOUBLE, 2));
723 default:
724 fatal("Type '%s' is not supported for vectors", type2name(bt));
725 return NULL;
726 }
727 }
728 }
729
730 // Return the vector version of a scalar load node.
731 LoadVectorNode* LoadVectorNode::make(int opc, Node* ctl, Node* mem,
732 Node* adr, const TypePtr* atyp,
733 uint vlen, BasicType bt,
734 ControlDependency control_dependency) {
735 const TypeVect* vt = TypeVect::make(bt, vlen);
736 return new LoadVectorNode(ctl, mem, adr, atyp, vt, control_dependency);
737 }
738
739 // Return the vector version of a scalar store node.
740 StoreVectorNode* StoreVectorNode::make(int opc, Node* ctl, Node* mem,
741 Node* adr, const TypePtr* atyp, Node* val,
742 uint vlen) {
743 return new StoreVectorNode(ctl, mem, adr, atyp, val);
744 }
745
746 int ExtractNode::opcode(BasicType bt) {
747 switch (bt) {
748 case T_BOOLEAN:
749 return Op_ExtractUB;
750 case T_BYTE:
751 return Op_ExtractB;
752 case T_CHAR:
753 return Op_ExtractC;
754 case T_SHORT:
755 return Op_ExtractS;
756 case T_INT:
757 return Op_ExtractI;
758 case T_LONG:
759 return Op_ExtractL;
760 case T_FLOAT:
761 return Op_ExtractF;
762 case T_DOUBLE:
763 return Op_ExtractD;
764 default:
765 fatal("Type '%s' is not supported for vectors", type2name(bt));
766 return 0;
767 }
768 }
769
770 // Extract a scalar element of vector.
771 Node* ExtractNode::make(Node* v, uint position, BasicType bt) {
772 assert((int)position < Matcher::max_vector_size(bt), "pos in range");
773 ConINode* pos = ConINode::make((int)position);
774 switch (bt) {
775 case T_BOOLEAN:
776 return new ExtractUBNode(v, pos);
777 case T_BYTE:
778 return new ExtractBNode(v, pos);
779 case T_CHAR:
780 return new ExtractCNode(v, pos);
781 case T_SHORT:
782 return new ExtractSNode(v, pos);
783 case T_INT:
784 return new ExtractINode(v, pos);
785 case T_LONG:
786 return new ExtractLNode(v, pos);
787 case T_FLOAT:
788 return new ExtractFNode(v, pos);
789 case T_DOUBLE:
790 return new ExtractDNode(v, pos);
791 default:
792 fatal("Type '%s' is not supported for vectors", type2name(bt));
793 return NULL;
794 }
795 }
796
797 int ReductionNode::opcode(int opc, BasicType bt) {
798 int vopc = opc;
799 switch (opc) {
800 case Op_AddI:
801 switch (bt) {
802 case T_BOOLEAN:
803 case T_CHAR: return 0;
804 case T_BYTE:
805 case T_SHORT:
806 case T_INT:
807 vopc = Op_AddReductionVI;
808 break;
809 default: ShouldNotReachHere(); return 0;
810 }
811 break;
812 case Op_AddL:
813 assert(bt == T_LONG, "must be");
814 vopc = Op_AddReductionVL;
815 break;
816 case Op_AddF:
817 assert(bt == T_FLOAT, "must be");
818 vopc = Op_AddReductionVF;
819 break;
820 case Op_AddD:
821 assert(bt == T_DOUBLE, "must be");
822 vopc = Op_AddReductionVD;
823 break;
824 case Op_MulI:
825 switch (bt) {
826 case T_BOOLEAN:
827 case T_CHAR: return 0;
828 case T_BYTE:
829 case T_SHORT:
830 case T_INT:
831 vopc = Op_MulReductionVI;
832 break;
833 default: ShouldNotReachHere(); return 0;
834 }
835 break;
836 case Op_MulL:
837 assert(bt == T_LONG, "must be");
838 vopc = Op_MulReductionVL;
839 break;
840 case Op_MulF:
841 assert(bt == T_FLOAT, "must be");
842 vopc = Op_MulReductionVF;
843 break;
844 case Op_MulD:
845 assert(bt == T_DOUBLE, "must be");
846 vopc = Op_MulReductionVD;
847 break;
848 case Op_MinI:
849 switch (bt) {
850 case T_BOOLEAN:
851 case T_CHAR: return 0;
852 case T_BYTE:
853 case T_SHORT:
854 case T_INT:
855 vopc = Op_MinReductionV;
856 break;
857 default: ShouldNotReachHere(); return 0;
858 }
859 break;
860 case Op_MinL:
861 assert(bt == T_LONG, "must be");
862 vopc = Op_MinReductionV;
863 break;
864 case Op_MinF:
865 assert(bt == T_FLOAT, "must be");
866 vopc = Op_MinReductionV;
867 break;
868 case Op_MinD:
869 assert(bt == T_DOUBLE, "must be");
870 vopc = Op_MinReductionV;
871 break;
872 case Op_MaxI:
873 switch (bt) {
874 case T_BOOLEAN:
875 case T_CHAR: return 0;
876 case T_BYTE:
877 case T_SHORT:
878 case T_INT:
879 vopc = Op_MaxReductionV;
880 break;
881 default: ShouldNotReachHere(); return 0;
882 }
883 break;
884 case Op_MaxL:
885 assert(bt == T_LONG, "must be");
886 vopc = Op_MaxReductionV;
887 break;
888 case Op_MaxF:
889 assert(bt == T_FLOAT, "must be");
890 vopc = Op_MaxReductionV;
891 break;
892 case Op_MaxD:
893 assert(bt == T_DOUBLE, "must be");
894 vopc = Op_MaxReductionV;
895 break;
896 case Op_AndI:
897 switch (bt) {
898 case T_BOOLEAN:
899 case T_CHAR: return 0;
900 case T_BYTE:
901 case T_SHORT:
902 case T_INT:
903 vopc = Op_AndReductionV;
904 break;
905 default: ShouldNotReachHere(); return 0;
906 }
907 break;
908 case Op_AndL:
909 assert(bt == T_LONG, "must be");
910 vopc = Op_AndReductionV;
911 break;
912 case Op_OrI:
913 switch(bt) {
914 case T_BOOLEAN:
915 case T_CHAR: return 0;
916 case T_BYTE:
917 case T_SHORT:
918 case T_INT:
919 vopc = Op_OrReductionV;
920 break;
921 default: ShouldNotReachHere(); return 0;
922 }
923 break;
924 case Op_OrL:
925 assert(bt == T_LONG, "must be");
926 vopc = Op_OrReductionV;
927 break;
928 case Op_XorI:
929 switch(bt) {
930 case T_BOOLEAN:
931 case T_CHAR: return 0;
932 case T_BYTE:
933 case T_SHORT:
934 case T_INT:
935 vopc = Op_XorReductionV;
936 break;
937 default: ShouldNotReachHere(); return 0;
938 }
939 break;
940 case Op_XorL:
941 assert(bt == T_LONG, "must be");
942 vopc = Op_XorReductionV;
943 break;
944 default:
945 break;
946 }
947 return vopc;
948 }
949
950 // Return the appropriate reduction node.
951 ReductionNode* ReductionNode::make(int opc, Node *ctrl, Node* n1, Node* n2, BasicType bt) {
952
953 int vopc = opcode(opc, bt);
954
955 // This method should not be called for unimplemented vectors.
956 guarantee(vopc != opc, "Vector for '%s' is not implemented", NodeClassNames[opc]);
957
958 switch (vopc) {
959 case Op_AddReductionVI: return new AddReductionVINode(ctrl, n1, n2);
960 case Op_AddReductionVL: return new AddReductionVLNode(ctrl, n1, n2);
961 case Op_AddReductionVF: return new AddReductionVFNode(ctrl, n1, n2);
962 case Op_AddReductionVD: return new AddReductionVDNode(ctrl, n1, n2);
963 case Op_MulReductionVI: return new MulReductionVINode(ctrl, n1, n2);
964 case Op_MulReductionVL: return new MulReductionVLNode(ctrl, n1, n2);
965 case Op_MulReductionVF: return new MulReductionVFNode(ctrl, n1, n2);
966 case Op_MulReductionVD: return new MulReductionVDNode(ctrl, n1, n2);
967 case Op_MinReductionV: return new MinReductionVNode(ctrl, n1, n2);
968 case Op_MaxReductionV: return new MaxReductionVNode(ctrl, n1, n2);
969 case Op_AndReductionV: return new AndReductionVNode(ctrl, n1, n2);
970 case Op_OrReductionV: return new OrReductionVNode(ctrl, n1, n2);
971 case Op_XorReductionV: return new XorReductionVNode(ctrl, n1, n2);
972 default:
973 fatal("Missed vector creation for '%s'", NodeClassNames[vopc]);
974 return NULL;
975 }
976 }
977
978 VectorCastNode* VectorCastNode::make(int vopc, Node* n1, BasicType bt, uint vlen) {
979 const TypeVect* vt = TypeVect::make(bt, vlen);
980 switch (vopc) {
981 case Op_VectorCastB2X: return new VectorCastB2XNode(n1, vt);
982 case Op_VectorCastS2X: return new VectorCastS2XNode(n1, vt);
983 case Op_VectorCastI2X: return new VectorCastI2XNode(n1, vt);
984 case Op_VectorCastL2X: return new VectorCastL2XNode(n1, vt);
985 case Op_VectorCastF2X: return new VectorCastF2XNode(n1, vt);
986 case Op_VectorCastD2X: return new VectorCastD2XNode(n1, vt);
987 default: fatal("unknown node: %s", NodeClassNames[vopc]);
988 }
989 return NULL;
990 }
991
992 int VectorCastNode::opcode(BasicType bt) {
993 switch (bt) {
994 case T_BYTE: return Op_VectorCastB2X;
995 case T_SHORT: return Op_VectorCastS2X;
996 case T_INT: return Op_VectorCastI2X;
997 case T_LONG: return Op_VectorCastL2X;
998 case T_FLOAT: return Op_VectorCastF2X;
999 case T_DOUBLE: return Op_VectorCastD2X;
1000 default: Unimplemented();
1001 }
1002 return 0;
1003 }
1004
1005 Node* ReductionNode::make_reduction_input(PhaseGVN& gvn, int opc, BasicType bt) {
1006 int vopc = opcode(opc, bt);
1007 guarantee(vopc != opc, "Vector reduction for '%s' is not implemented", NodeClassNames[opc]);
1008
1009 switch (vopc) {
1010 case Op_AndReductionV:
1011 switch (bt) {
1012 case T_BYTE:
1013 case T_SHORT:
1014 case T_INT:
1015 return gvn.makecon(TypeInt::MINUS_1);
1016 case T_LONG:
1017 return gvn.makecon(TypeLong::MINUS_1);
1018 default:
1019 fatal("Missed vector creation for '%s' as the basic type is not correct.", NodeClassNames[vopc]);
1020 return NULL;
1021 }
1022 break;
1023 case Op_AddReductionVI: // fallthrough
1024 case Op_AddReductionVL: // fallthrough
1025 case Op_AddReductionVF: // fallthrough
1026 case Op_AddReductionVD:
1027 case Op_OrReductionV:
1028 case Op_XorReductionV:
1029 return gvn.zerocon(bt);
1030 case Op_MulReductionVI:
1031 return gvn.makecon(TypeInt::ONE);
1032 case Op_MulReductionVL:
1033 return gvn.makecon(TypeLong::ONE);
1034 case Op_MulReductionVF:
1035 return gvn.makecon(TypeF::ONE);
1036 case Op_MulReductionVD:
1037 return gvn.makecon(TypeD::ONE);
1038 case Op_MinReductionV:
1039 switch (bt) {
1040 case T_BYTE:
1041 case T_SHORT:
1042 case T_INT:
1043 return gvn.makecon(TypeInt::MAX);
1044 case T_LONG:
1045 return gvn.makecon(TypeLong::MAX);
1046 case T_FLOAT:
1047 return gvn.makecon(TypeF::POS_INF);
1048 case T_DOUBLE:
1049 return gvn.makecon(TypeD::POS_INF);
1050 default: Unimplemented(); return NULL;
1051 }
1052 break;
1053 case Op_MaxReductionV:
1054 switch (bt) {
1055 case T_BYTE:
1056 case T_SHORT:
1057 case T_INT:
1058 return gvn.makecon(TypeInt::MIN);
1059 case T_LONG:
1060 return gvn.makecon(TypeLong::MIN);
1061 case T_FLOAT:
1062 return gvn.makecon(TypeF::NEG_INF);
1063 case T_DOUBLE:
1064 return gvn.makecon(TypeD::NEG_INF);
1065 default: Unimplemented(); return NULL;
1066 }
1067 break;
1068 default:
1069 fatal("Missed vector creation for '%s'", NodeClassNames[vopc]);
1070 return NULL;
1071 }
1072 }
1073
1074 bool ReductionNode::implemented(int opc, uint vlen, BasicType bt) {
1075 if (is_java_primitive(bt) &&
1076 (vlen > 1) && is_power_of_2(vlen) &&
1077 Matcher::vector_size_supported(bt, vlen)) {
1078 int vopc = ReductionNode::opcode(opc, bt);
1079 return vopc != opc && Matcher::match_rule_supported(vopc);
1080 }
1081 return false;
1082 }
1083
1084 #ifndef PRODUCT
1085 void VectorMaskCmpNode::dump_spec(outputStream *st) const {
1086 st->print(" %d #", _predicate); _type->dump_on(st);
1087 }
1088 #endif // PRODUCT
1089
1090 Node* VectorReinterpretNode::Identity(PhaseGVN *phase) {
1091 Node* n = in(1);
1092 if (n->Opcode() == Op_VectorReinterpret) {
1093 if (Type::cmp(bottom_type(), n->in(1)->bottom_type()) == 0) {
1094 return n->in(1);
1095 }
1096 }
1097 return this;
1098 }
1099
1100 Node* VectorInsertNode::make(Node* vec, Node* new_val, int position) {
1101 assert(position < (int)vec->bottom_type()->is_vect()->length(), "pos in range");
1102 ConINode* pos = ConINode::make(position);
1103 return new VectorInsertNode(vec, new_val, pos, vec->bottom_type()->is_vect());
1104 }
1105
1106 Node* VectorUnboxNode::Identity(PhaseGVN *phase) {
1107 Node* n = obj()->uncast();
1108 if (EnableVectorReboxing && n->Opcode() == Op_VectorBox) {
1109 if (Type::cmp(bottom_type(), n->in(VectorBoxNode::Value)->bottom_type()) == 0) {
1110 return n->in(VectorBoxNode::Value);
1111 }
1112 }
1113 return this;
1114 }
1115
1116 const TypeFunc* VectorBoxNode::vec_box_type(const TypeInstPtr* box_type) {
1117 const Type** fields = TypeTuple::fields(0);
1118 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms, fields);
1119
1120 fields = TypeTuple::fields(1);
1121 fields[TypeFunc::Parms+0] = box_type;
1122 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
1123
1124 return TypeFunc::make(domain, range);
1125 }
1126
1127 #ifndef PRODUCT
1128 void VectorBoxAllocateNode::dump_spec(outputStream *st) const {
1129 CallStaticJavaNode::dump_spec(st);
1130 }
1131 #endif // !PRODUCT
1132
1133 MacroLogicVNode* MacroLogicVNode::make(PhaseGVN& gvn, Node* in1, Node* in2, Node* in3,
1134 uint truth_table, const TypeVect* vt) {
1135 assert(truth_table <= 0xFF, "invalid");
1136 assert(in1->bottom_type()->is_vect()->length_in_bytes() == vt->length_in_bytes(), "mismatch");
1137 assert(in2->bottom_type()->is_vect()->length_in_bytes() == vt->length_in_bytes(), "mismatch");
1138 assert(in3->bottom_type()->is_vect()->length_in_bytes() == vt->length_in_bytes(), "mismatch");
1139 Node* fn = gvn.intcon(truth_table);
1140 return new MacroLogicVNode(in1, in2, in3, fn, vt);
1141 }
1142