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 // When op is already vectorized, return that directly.
299 return sopc;
300
301 default:
302 return 0; // Unimplemented
303 }
304 }
305
306 int VectorNode::replicate_opcode(BasicType bt) {
307 switch(bt) {
308 case T_BOOLEAN:
309 case T_BYTE:
310 return Op_ReplicateB;
311 case T_SHORT:
312 case T_CHAR:
313 return Op_ReplicateS;
314 case T_INT:
315 return Op_ReplicateI;
316 case T_LONG:
317 return Op_ReplicateL;
318 case T_FLOAT:
319 return Op_ReplicateF;
320 case T_DOUBLE:
321 return Op_ReplicateD;
322 default:
323 break;
324 }
325
326 return 0;
327 }
328
329 // Also used to check if the code generator
330 // supports the vector operation.
331 bool VectorNode::implemented(int opc, uint vlen, BasicType bt) {
332 if (is_java_primitive(bt) &&
333 (vlen > 1) && is_power_of_2(vlen) &&
334 Matcher::vector_size_supported(bt, vlen)) {
335 int vopc = VectorNode::opcode(opc, bt);
336 return vopc > 0 && Matcher::match_rule_supported_vector(vopc, vlen, bt);
337 }
338 return false;
339 }
340
341 bool VectorNode::is_shift(Node* n) {
342 switch (n->Opcode()) {
343 case Op_LShiftI:
344 case Op_LShiftL:
345 case Op_RShiftI:
346 case Op_RShiftL:
347 case Op_URShiftI:
348 case Op_URShiftL:
349 return true;
350 default:
351 return false;
352 }
353 }
354
355 // Check if input is loop invariant vector.
356 bool VectorNode::is_invariant_vector(Node* n) {
357 // Only Replicate vector nodes are loop invariant for now.
358 switch (n->Opcode()) {
359 case Op_ReplicateB:
360 case Op_ReplicateS:
361 case Op_ReplicateI:
362 case Op_ReplicateL:
363 case Op_ReplicateF:
364 case Op_ReplicateD:
365 return true;
366 default:
367 return false;
368 }
369 }
370
371 // [Start, end) half-open range defining which operands are vectors
372 void VectorNode::vector_operands(Node* n, uint* start, uint* end) {
373 switch (n->Opcode()) {
374 case Op_LoadB: case Op_LoadUB:
375 case Op_LoadS: case Op_LoadUS:
376 case Op_LoadI: case Op_LoadL:
377 case Op_LoadF: case Op_LoadD:
378 case Op_LoadP: case Op_LoadN:
379 *start = 0;
380 *end = 0; // no vector operands
381 break;
382 case Op_StoreB: case Op_StoreC:
383 case Op_StoreI: case Op_StoreL:
384 case Op_StoreF: case Op_StoreD:
385 case Op_StoreP: case Op_StoreN:
386 *start = MemNode::ValueIn;
387 *end = MemNode::ValueIn + 1; // 1 vector operand
388 break;
389 case Op_LShiftI: case Op_LShiftL:
390 case Op_RShiftI: case Op_RShiftL:
391 case Op_URShiftI: case Op_URShiftL:
392 *start = 1;
393 *end = 2; // 1 vector operand
394 break;
395 case Op_AddI: case Op_AddL: case Op_AddF: case Op_AddD:
396 case Op_SubI: case Op_SubL: case Op_SubF: case Op_SubD:
397 case Op_MulI: case Op_MulL: case Op_MulF: case Op_MulD:
398 case Op_DivF: case Op_DivD:
399 case Op_AndI: case Op_AndL:
400 case Op_OrI: case Op_OrL:
401 case Op_XorI: case Op_XorL:
402 *start = 1;
403 *end = 3; // 2 vector operands
404 break;
405 case Op_CMoveI: case Op_CMoveL: case Op_CMoveF: case Op_CMoveD:
406 *start = 2;
407 *end = n->req();
408 break;
409 case Op_FmaD:
410 case Op_FmaF:
411 *start = 1;
412 *end = 4; // 3 vector operands
413 break;
414 default:
415 *start = 1;
416 *end = n->req(); // default is all operands
417 }
418 }
419
420 // Return the vector version of a scalar operation node.
421 VectorNode* VectorNode::make(int opc, Node* n1, Node* n2, uint vlen, BasicType bt) {
422 const TypeVect* vt = TypeVect::make(bt, vlen);
423 int vopc = VectorNode::opcode(opc, bt);
424 // This method should not be called for unimplemented vectors.
425 guarantee(vopc > 0, "Vector for '%s' is not implemented", NodeClassNames[opc]);
426 switch (vopc) {
427 case Op_AddVB: return new AddVBNode(n1, n2, vt);
428 case Op_AddVS: return new AddVSNode(n1, n2, vt);
429 case Op_AddVI: return new AddVINode(n1, n2, vt);
430 case Op_AddVL: return new AddVLNode(n1, n2, vt);
431 case Op_AddVF: return new AddVFNode(n1, n2, vt);
432 case Op_AddVD: return new AddVDNode(n1, n2, vt);
433
434 case Op_SubVB: return new SubVBNode(n1, n2, vt);
435 case Op_SubVS: return new SubVSNode(n1, n2, vt);
436 case Op_SubVI: return new SubVINode(n1, n2, vt);
437 case Op_SubVL: return new SubVLNode(n1, n2, vt);
438 case Op_SubVF: return new SubVFNode(n1, n2, vt);
439 case Op_SubVD: return new SubVDNode(n1, n2, vt);
440
441 case Op_MulVB: return new MulVBNode(n1, n2, vt);
442 case Op_MulVS: return new MulVSNode(n1, n2, vt);
443 case Op_MulVI: return new MulVINode(n1, n2, vt);
444 case Op_MulVL: return new MulVLNode(n1, n2, vt);
445 case Op_MulVF: return new MulVFNode(n1, n2, vt);
446 case Op_MulVD: return new MulVDNode(n1, n2, vt);
447
448 case Op_DivVF: return new DivVFNode(n1, n2, vt);
449 case Op_DivVD: return new DivVDNode(n1, n2, vt);
450
451 case Op_MinV: return new MinVNode(n1, n2, vt);
452 case Op_MaxV: return new MaxVNode(n1, n2, vt);
453
454 case Op_AbsV: return new AbsVNode(n1, vt);
455 case Op_AbsVF: return new AbsVFNode(n1, vt);
456 case Op_AbsVD: return new AbsVDNode(n1, vt);
457
458 case Op_NegVI: return new NegVINode(n1, vt);
459 case Op_NegVF: return new NegVFNode(n1, vt);
460 case Op_NegVD: return new NegVDNode(n1, vt);
461
462 case Op_SqrtVF: return new SqrtVFNode(n1, vt);
463 case Op_SqrtVD: return new SqrtVDNode(n1, vt);
464
465 case Op_PopCountVI: return new PopCountVINode(n1, vt);
466 case Op_NotV: return new NotVNode(n1, vt);
467
468 case Op_LShiftVB: return new LShiftVBNode(n1, n2, vt);
469 case Op_LShiftVS: return new LShiftVSNode(n1, n2, vt);
470 case Op_LShiftVI: return new LShiftVINode(n1, n2, vt);
471 case Op_LShiftVL: return new LShiftVLNode(n1, n2, vt);
472
473 case Op_RShiftVB: return new RShiftVBNode(n1, n2, vt);
474 case Op_RShiftVS: return new RShiftVSNode(n1, n2, vt);
475 case Op_RShiftVI: return new RShiftVINode(n1, n2, vt);
476 case Op_RShiftVL: return new RShiftVLNode(n1, n2, vt);
477
478 case Op_URShiftVB: return new URShiftVBNode(n1, n2, vt);
479 case Op_URShiftVS: return new URShiftVSNode(n1, n2, vt);
480 case Op_URShiftVI: return new URShiftVINode(n1, n2, vt);
481 case Op_URShiftVL: return new URShiftVLNode(n1, n2, vt);
482
483 case Op_AndV: return new AndVNode(n1, n2, vt);
484 case Op_OrV: return new OrVNode (n1, n2, vt);
485 case Op_XorV: return new XorVNode(n1, n2, vt);
486
487 case Op_ConvertVF2VD:
488 if (bt == T_DOUBLE) {
489 return new ConvertVF2VDNode(n1, vt);
490 }
491 default:
492 fatal("Missed vector creation for '%s'", NodeClassNames[vopc]);
493 return NULL;
494 }
495 }
496
497 VectorNode* VectorNode::make(int opc, Node* n1, Node* n2, Node* n3, uint vlen, BasicType bt) {
498 const TypeVect* vt = TypeVect::make(bt, vlen);
499 int vopc = VectorNode::opcode(opc, bt);
500 // This method should not be called for unimplemented vectors.
501 guarantee(vopc > 0, "Vector for '%s' is not implemented", NodeClassNames[opc]);
502 switch (vopc) {
503 case Op_FmaVD: return new FmaVDNode(n1, n2, n3, vt);
504 case Op_FmaVF: return new FmaVFNode(n1, n2, n3, vt);
505 default:
506 fatal("Missed vector creation for '%s'", NodeClassNames[vopc]);
507 return NULL;
508 }
509 }
510
511 // Scalar promotion
512 VectorNode* VectorNode::scalar2vector(Node* s, uint vlen, const Type* opd_t) {
513 BasicType bt = opd_t->array_element_basic_type();
514 const TypeVect* vt = opd_t->singleton() ? TypeVect::make(opd_t, vlen)
515 : TypeVect::make(bt, vlen);
516 switch (bt) {
517 case T_BOOLEAN:
518 case T_BYTE:
519 return new ReplicateBNode(s, vt);
520 case T_CHAR:
521 case T_SHORT:
522 return new ReplicateSNode(s, vt);
523 case T_INT:
524 return new ReplicateINode(s, vt);
525 case T_LONG:
526 return new ReplicateLNode(s, vt);
527 case T_FLOAT:
528 return new ReplicateFNode(s, vt);
529 case T_DOUBLE:
530 return new ReplicateDNode(s, vt);
531 default:
532 fatal("Type '%s' is not supported for vectors", type2name(bt));
533 return NULL;
534 }
535 }
536
537 VectorNode* VectorNode::shift_count(int opc, Node* cnt, uint vlen, BasicType bt) {
538 assert(!cnt->is_Con(), "only variable shift count");
539 // Match shift count type with shift vector type.
540 const TypeVect* vt = TypeVect::make(bt, vlen);
541 switch (opc) {
542 case Op_LShiftI:
543 case Op_LShiftL:
544 return new LShiftCntVNode(cnt, vt);
545 case Op_RShiftI:
546 case Op_RShiftL:
547 case Op_URShiftI:
548 case Op_URShiftL:
549 return new RShiftCntVNode(cnt, vt);
550 default:
551 fatal("Missed vector creation for '%s'", NodeClassNames[opc]);
552 return NULL;
553 }
554 }
555
556 // Return initial Pack node. Additional operands added with add_opd() calls.
557 PackNode* PackNode::make(Node* s, uint vlen, BasicType bt) {
558 const TypeVect* vt = TypeVect::make(bt, vlen);
559 switch (bt) {
560 case T_BOOLEAN:
561 case T_BYTE:
562 return new PackBNode(s, vt);
563 case T_CHAR:
564 case T_SHORT:
565 return new PackSNode(s, vt);
566 case T_INT:
567 return new PackINode(s, vt);
568 case T_LONG:
569 return new PackLNode(s, vt);
570 case T_FLOAT:
571 return new PackFNode(s, vt);
572 case T_DOUBLE:
573 return new PackDNode(s, vt);
574 default:
575 fatal("Type '%s' is not supported for vectors", type2name(bt));
576 return NULL;
577 }
578 }
579
580 // Create a binary tree form for Packs. [lo, hi) (half-open) range
581 PackNode* PackNode::binary_tree_pack(int lo, int hi) {
582 int ct = hi - lo;
583 assert(is_power_of_2(ct), "power of 2");
584 if (ct == 2) {
585 PackNode* pk = PackNode::make(in(lo), 2, vect_type()->element_basic_type());
586 pk->add_opd(in(lo+1));
587 return pk;
588 } else {
589 int mid = lo + ct/2;
590 PackNode* n1 = binary_tree_pack(lo, mid);
591 PackNode* n2 = binary_tree_pack(mid, hi );
592
593 BasicType bt = n1->vect_type()->element_basic_type();
594 assert(bt == n2->vect_type()->element_basic_type(), "should be the same");
595 switch (bt) {
596 case T_BOOLEAN:
597 case T_BYTE:
598 return new PackSNode(n1, n2, TypeVect::make(T_SHORT, 2));
599 case T_CHAR:
600 case T_SHORT:
601 return new PackINode(n1, n2, TypeVect::make(T_INT, 2));
602 case T_INT:
603 return new PackLNode(n1, n2, TypeVect::make(T_LONG, 2));
604 case T_LONG:
605 return new Pack2LNode(n1, n2, TypeVect::make(T_LONG, 2));
606 case T_FLOAT:
607 return new PackDNode(n1, n2, TypeVect::make(T_DOUBLE, 2));
608 case T_DOUBLE:
609 return new Pack2DNode(n1, n2, TypeVect::make(T_DOUBLE, 2));
610 default:
611 fatal("Type '%s' is not supported for vectors", type2name(bt));
612 return NULL;
613 }
614 }
615 }
616
617 // Return the vector version of a scalar load node.
618 LoadVectorNode* LoadVectorNode::make(int opc, Node* ctl, Node* mem,
619 Node* adr, const TypePtr* atyp,
620 uint vlen, BasicType bt,
621 ControlDependency control_dependency) {
622 const TypeVect* vt = TypeVect::make(bt, vlen);
623 return new LoadVectorNode(ctl, mem, adr, atyp, vt, control_dependency);
624 }
625
626 // Return the vector version of a scalar store node.
627 StoreVectorNode* StoreVectorNode::make(int opc, Node* ctl, Node* mem,
628 Node* adr, const TypePtr* atyp, Node* val,
629 uint vlen) {
630 return new StoreVectorNode(ctl, mem, adr, atyp, val);
631 }
632
633 // Extract a scalar element of vector.
634 Node* ExtractNode::make(Node* v, uint position, BasicType bt) {
635 assert((int)position < Matcher::max_vector_size(bt), "pos in range");
636 ConINode* pos = ConINode::make((int)position);
637 switch (bt) {
638 case T_BOOLEAN:
639 return new ExtractUBNode(v, pos);
640 case T_BYTE:
641 return new ExtractBNode(v, pos);
642 case T_CHAR:
643 return new ExtractCNode(v, pos);
644 case T_SHORT:
645 return new ExtractSNode(v, pos);
646 case T_INT:
647 return new ExtractINode(v, pos);
648 case T_LONG:
649 return new ExtractLNode(v, pos);
650 case T_FLOAT:
651 return new ExtractFNode(v, pos);
652 case T_DOUBLE:
653 return new ExtractDNode(v, pos);
654 default:
655 fatal("Type '%s' is not supported for vectors", type2name(bt));
656 return NULL;
657 }
658 }
659
660 int ReductionNode::opcode(int opc, BasicType bt) {
661 int vopc = opc;
662 switch (opc) {
663 case Op_AddI:
664 switch (bt) {
665 case T_BOOLEAN:
666 case T_CHAR: return 0;
667 case T_BYTE:
668 case T_SHORT:
669 case T_INT:
670 vopc = Op_AddReductionVI;
671 break;
672 default: ShouldNotReachHere(); return 0;
673 }
674 break;
675 case Op_AddL:
676 assert(bt == T_LONG, "must be");
677 vopc = Op_AddReductionVL;
678 break;
679 case Op_AddF:
680 assert(bt == T_FLOAT, "must be");
681 vopc = Op_AddReductionVF;
682 break;
683 case Op_AddD:
684 assert(bt == T_DOUBLE, "must be");
685 vopc = Op_AddReductionVD;
686 break;
687 case Op_MulI:
688 assert(bt == T_INT, "must be");
689 vopc = Op_MulReductionVI;
690 break;
691 case Op_MulL:
692 assert(bt == T_LONG, "must be");
693 vopc = Op_MulReductionVL;
694 break;
695 case Op_MulF:
696 assert(bt == T_FLOAT, "must be");
697 vopc = Op_MulReductionVF;
698 break;
699 case Op_MulD:
700 assert(bt == T_DOUBLE, "must be");
701 vopc = Op_MulReductionVD;
702 break;
703 case Op_AndI:
704 switch (bt) {
705 case T_BOOLEAN:
706 case T_CHAR: return 0;
707 case T_BYTE:
708 case T_SHORT:
709 case T_INT:
710 vopc = Op_AndReductionV;
711 break;
712 default: ShouldNotReachHere(); return 0;
713 }
714 break;
715 case Op_AndL:
716 assert(bt == T_LONG, "must be");
717 vopc = Op_AndReductionV;
718 break;
719 case Op_OrI:
720 assert(bt == T_INT, "must be");
721 vopc = Op_OrReductionV;
722 break;
723 case Op_OrL:
724 assert(bt == T_LONG, "must be");
725 vopc = Op_OrReductionV;
726 break;
727 case Op_XorI:
728 assert(bt == T_INT, "must be");
729 vopc = Op_XorReductionV;
730 break;
731 case Op_XorL:
732 assert(bt == T_LONG, "must be");
733 vopc = Op_XorReductionV;
734 break;
735 case Op_SubI:
736 assert(bt == T_INT, "must be");
737 vopc = Op_SubReductionV;
738 break;
739 case Op_SubL:
740 assert(bt == T_LONG, "must be");
741 vopc = Op_SubReductionV;
742 break;
743 // TODO: add MulL for targets that support it
744 default:
745 break;
746 }
747 return vopc;
748 }
749
750 // Return the appropriate reduction node.
751 ReductionNode* ReductionNode::make(int opc, Node *ctrl, Node* n1, Node* n2, BasicType bt) {
752
753 int vopc = opcode(opc, bt);
754
755 // This method should not be called for unimplemented vectors.
756 guarantee(vopc != opc, "Vector for '%s' is not implemented", NodeClassNames[opc]);
757
758 switch (vopc) {
759 case Op_AddReductionVI: return new AddReductionVINode(ctrl, n1, n2);
760 case Op_AddReductionVL: return new AddReductionVLNode(ctrl, n1, n2);
761 case Op_AddReductionVF: return new AddReductionVFNode(ctrl, n1, n2);
762 case Op_AddReductionVD: return new AddReductionVDNode(ctrl, n1, n2);
763 case Op_MulReductionVI: return new MulReductionVINode(ctrl, n1, n2);
764 case Op_MulReductionVL: return new MulReductionVLNode(ctrl, n1, n2);
765 case Op_MulReductionVF: return new MulReductionVFNode(ctrl, n1, n2);
766 case Op_MulReductionVD: return new MulReductionVDNode(ctrl, n1, n2);
767 case Op_AndReductionV: return new AndReductionVNode(ctrl, n1, n2);
768 case Op_OrReductionV: return new OrReductionVNode(ctrl, n1, n2);
769 case Op_XorReductionV: return new XorReductionVNode(ctrl, n1, n2);
770 case Op_SubReductionV: return new SubReductionVNode(ctrl, n1, n2);
771 default:
772 fatal("Missed vector creation for '%s'", NodeClassNames[vopc]);
773 return NULL;
774 }
775 }
776
777 Node* ReductionNode::make_reduction_input(PhaseGVN& gvn, int opc, BasicType bt) {
778 int vopc = opcode(opc, bt);
779 guarantee(vopc != opc, "Vector reduction for '%s' is not implemented", NodeClassNames[opc]);
780
781 switch (vopc) {
782 case Op_AndReductionV:
783 switch (bt) {
784 case T_BYTE:
785 case T_SHORT:
786 case T_INT:
787 return gvn.makecon(TypeInt::MINUS_1);
788 case T_LONG:
789 return gvn.makecon(TypeLong::MINUS_1);
790 default:
791 fatal("Missed vector creation for '%s' as the basic type is not correct.", NodeClassNames[vopc]);
792 return NULL;
793 }
794 break;
795 case Op_AddReductionVI: // fallthrough
796 case Op_AddReductionVL: // fallthrough
797 case Op_AddReductionVF: // fallthrough
798 case Op_AddReductionVD:
799 case Op_OrReductionV:
800 case Op_XorReductionV:
801 case Op_SubReductionV:
802 return gvn.zerocon(bt);
803 case Op_MulReductionVI:
804 return gvn.makecon(TypeInt::ONE);
805 case Op_MulReductionVL:
806 return gvn.makecon(TypeLong::ONE);
807 case Op_MulReductionVF:
808 return gvn.makecon(TypeF::ONE);
809 case Op_MulReductionVD:
810 return gvn.makecon(TypeD::ONE);
811 default:
812 fatal("Missed vector creation for '%s'", NodeClassNames[vopc]);
813 return NULL;
814 }
815 }
816
817 bool ReductionNode::implemented(int opc, uint vlen, BasicType bt) {
818 if (is_java_primitive(bt) &&
819 (vlen > 1) && is_power_of_2(vlen) &&
820 Matcher::vector_size_supported(bt, vlen)) {
821 int vopc = ReductionNode::opcode(opc, bt);
822 return vopc != opc && Matcher::match_rule_supported(vopc);
823 }
824 return false;
825 }
826
827 #ifndef PRODUCT
828 void VectorBoxAllocateNode::dump_spec(outputStream *st) const {
829 CallStaticJavaNode::dump_spec(st);
830 }
831
832 void VectorMaskCmpNode::dump_spec(outputStream *st) const {
833 st->print(" %d #", _predicate); _type->dump_on(st);
834 }
835 #endif // PRODUCT
836
837 Node* VectorUnboxNode::Identity(PhaseGVN *phase) {
838 Node* n = obj()->uncast();
839 if (n->Opcode() == Op_VectorBox) {
840 return n->in(VectorBoxNode::Value);
841 }
842 return this;
843 }
844
845 const TypeFunc* VectorBoxNode::vec_box_type(const TypeInstPtr* box_type) {
846 const Type** fields = TypeTuple::fields(0);
847 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms, fields);
848
849 fields = TypeTuple::fields(1);
850 fields[TypeFunc::Parms+0] = box_type;
851 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
852
853 return TypeFunc::make(domain, range);
854 }
855
856 Node* SubReductionVNode::Ideal(PhaseGVN* phase, bool can_reshape) {
857 Node* ctrl = in(0);
858 Node* in1 = in(1);
859 Node* in2 = in(2);
860
861 if (phase->type(in1)->isa_int()) {
862 assert(phase->type(in2)->is_vect()->element_type()->is_int(), "must be consistent");
863 return new NegINode(phase->transform(new AddReductionVINode(ctrl,in1,in2)));
864 } else if (phase->type(in1)->isa_long()) {
865 return new NegLNode(phase->transform(new AddReductionVLNode(ctrl,in1,in2)));
866 } else {
867 Unimplemented();
868 return NULL;
869 }
870 }