60 }
61 ShouldNotReachHere();
62 case Op_SubL:
63 assert(bt == T_LONG, "must be");
64 return Op_SubVL;
65 case Op_SubF:
66 assert(bt == T_FLOAT, "must be");
67 return Op_SubVF;
68 case Op_SubD:
69 assert(bt == T_DOUBLE, "must be");
70 return Op_SubVD;
71 case Op_MulI:
72 switch (bt) {
73 case T_BOOLEAN:
74 case T_BYTE: return 0; // Unimplemented
75 case T_CHAR:
76 case T_SHORT: return Op_MulVS;
77 case T_INT: return Op_MulVI;
78 }
79 ShouldNotReachHere();
80 case Op_MulF:
81 assert(bt == T_FLOAT, "must be");
82 return Op_MulVF;
83 case Op_MulD:
84 assert(bt == T_DOUBLE, "must be");
85 return Op_MulVD;
86 case Op_DivF:
87 assert(bt == T_FLOAT, "must be");
88 return Op_DivVF;
89 case Op_DivD:
90 assert(bt == T_DOUBLE, "must be");
91 return Op_DivVD;
92 case Op_LShiftI:
93 switch (bt) {
94 case T_BOOLEAN:
95 case T_BYTE: return Op_LShiftVB;
96 case T_CHAR:
97 case T_SHORT: return Op_LShiftVS;
98 case T_INT: return Op_LShiftVI;
99 }
250 int vopc = VectorNode::opcode(opc, bt);
251 // This method should not be called for unimplemented vectors.
252 guarantee(vopc > 0, err_msg_res("Vector for '%s' is not implemented", NodeClassNames[opc]));
253 switch (vopc) {
254 case Op_AddVB: return new AddVBNode(n1, n2, vt);
255 case Op_AddVS: return new AddVSNode(n1, n2, vt);
256 case Op_AddVI: return new AddVINode(n1, n2, vt);
257 case Op_AddVL: return new AddVLNode(n1, n2, vt);
258 case Op_AddVF: return new AddVFNode(n1, n2, vt);
259 case Op_AddVD: return new AddVDNode(n1, n2, vt);
260
261 case Op_SubVB: return new SubVBNode(n1, n2, vt);
262 case Op_SubVS: return new SubVSNode(n1, n2, vt);
263 case Op_SubVI: return new SubVINode(n1, n2, vt);
264 case Op_SubVL: return new SubVLNode(n1, n2, vt);
265 case Op_SubVF: return new SubVFNode(n1, n2, vt);
266 case Op_SubVD: return new SubVDNode(n1, n2, vt);
267
268 case Op_MulVS: return new MulVSNode(n1, n2, vt);
269 case Op_MulVI: return new MulVINode(n1, n2, vt);
270 case Op_MulVF: return new MulVFNode(n1, n2, vt);
271 case Op_MulVD: return new MulVDNode(n1, n2, vt);
272
273 case Op_DivVF: return new DivVFNode(n1, n2, vt);
274 case Op_DivVD: return new DivVDNode(n1, n2, vt);
275
276 case Op_LShiftVB: return new LShiftVBNode(n1, n2, vt);
277 case Op_LShiftVS: return new LShiftVSNode(n1, n2, vt);
278 case Op_LShiftVI: return new LShiftVINode(n1, n2, vt);
279 case Op_LShiftVL: return new LShiftVLNode(n1, n2, vt);
280
281 case Op_RShiftVB: return new RShiftVBNode(n1, n2, vt);
282 case Op_RShiftVS: return new RShiftVSNode(n1, n2, vt);
283 case Op_RShiftVI: return new RShiftVINode(n1, n2, vt);
284 case Op_RShiftVL: return new RShiftVLNode(n1, n2, vt);
285
286 case Op_URShiftVB: return new URShiftVBNode(n1, n2, vt);
287 case Op_URShiftVS: return new URShiftVSNode(n1, n2, vt);
288 case Op_URShiftVI: return new URShiftVINode(n1, n2, vt);
289 case Op_URShiftVL: return new URShiftVLNode(n1, n2, vt);
446 case Op_AddI:
447 assert(bt == T_INT, "must be");
448 vopc = Op_AddReductionVI;
449 break;
450 case Op_AddL:
451 assert(bt == T_LONG, "must be");
452 vopc = Op_AddReductionVL;
453 break;
454 case Op_AddF:
455 assert(bt == T_FLOAT, "must be");
456 vopc = Op_AddReductionVF;
457 break;
458 case Op_AddD:
459 assert(bt == T_DOUBLE, "must be");
460 vopc = Op_AddReductionVD;
461 break;
462 case Op_MulI:
463 assert(bt == T_INT, "must be");
464 vopc = Op_MulReductionVI;
465 break;
466 case Op_MulF:
467 assert(bt == T_FLOAT, "must be");
468 vopc = Op_MulReductionVF;
469 break;
470 case Op_MulD:
471 assert(bt == T_DOUBLE, "must be");
472 vopc = Op_MulReductionVD;
473 break;
474 // TODO: add MulL for targets that support it
475 default:
476 break;
477 }
478 return vopc;
479 }
480
481 // Return the appropriate reduction node.
482 ReductionNode* ReductionNode::make(int opc, Node *ctrl, Node* n1, Node* n2, BasicType bt) {
483
484 int vopc = opcode(opc, bt);
485
486 // This method should not be called for unimplemented vectors.
487 guarantee(vopc != opc, err_msg_res("Vector for '%s' is not implemented", NodeClassNames[opc]));
488
489 switch (vopc) {
490 case Op_AddReductionVI: return new AddReductionVINode(ctrl, n1, n2);
491 case Op_AddReductionVL: return new AddReductionVLNode(ctrl, n1, n2);
492 case Op_AddReductionVF: return new AddReductionVFNode(ctrl, n1, n2);
493 case Op_AddReductionVD: return new AddReductionVDNode(ctrl, n1, n2);
494 case Op_MulReductionVI: return new MulReductionVINode(ctrl, n1, n2);
495 case Op_MulReductionVF: return new MulReductionVFNode(ctrl, n1, n2);
496 case Op_MulReductionVD: return new MulReductionVDNode(ctrl, n1, n2);
497 }
498 fatal(err_msg_res("Missed vector creation for '%s'", NodeClassNames[vopc]));
499 return NULL;
500 }
501
502 bool ReductionNode::implemented(int opc, uint vlen, BasicType bt) {
503 if (is_java_primitive(bt) &&
504 (vlen > 1) && is_power_of_2(vlen) &&
505 Matcher::vector_size_supported(bt, vlen)) {
506 int vopc = ReductionNode::opcode(opc, bt);
507 return vopc != opc && Matcher::match_rule_supported(vopc);
508 }
509 return false;
510 }
511
|
60 }
61 ShouldNotReachHere();
62 case Op_SubL:
63 assert(bt == T_LONG, "must be");
64 return Op_SubVL;
65 case Op_SubF:
66 assert(bt == T_FLOAT, "must be");
67 return Op_SubVF;
68 case Op_SubD:
69 assert(bt == T_DOUBLE, "must be");
70 return Op_SubVD;
71 case Op_MulI:
72 switch (bt) {
73 case T_BOOLEAN:
74 case T_BYTE: return 0; // Unimplemented
75 case T_CHAR:
76 case T_SHORT: return Op_MulVS;
77 case T_INT: return Op_MulVI;
78 }
79 ShouldNotReachHere();
80 case Op_MulL:
81 assert(bt == T_LONG, "must be");
82 return Op_MulVL;
83 case Op_MulF:
84 assert(bt == T_FLOAT, "must be");
85 return Op_MulVF;
86 case Op_MulD:
87 assert(bt == T_DOUBLE, "must be");
88 return Op_MulVD;
89 case Op_DivF:
90 assert(bt == T_FLOAT, "must be");
91 return Op_DivVF;
92 case Op_DivD:
93 assert(bt == T_DOUBLE, "must be");
94 return Op_DivVD;
95 case Op_LShiftI:
96 switch (bt) {
97 case T_BOOLEAN:
98 case T_BYTE: return Op_LShiftVB;
99 case T_CHAR:
100 case T_SHORT: return Op_LShiftVS;
101 case T_INT: return Op_LShiftVI;
102 }
253 int vopc = VectorNode::opcode(opc, bt);
254 // This method should not be called for unimplemented vectors.
255 guarantee(vopc > 0, err_msg_res("Vector for '%s' is not implemented", NodeClassNames[opc]));
256 switch (vopc) {
257 case Op_AddVB: return new AddVBNode(n1, n2, vt);
258 case Op_AddVS: return new AddVSNode(n1, n2, vt);
259 case Op_AddVI: return new AddVINode(n1, n2, vt);
260 case Op_AddVL: return new AddVLNode(n1, n2, vt);
261 case Op_AddVF: return new AddVFNode(n1, n2, vt);
262 case Op_AddVD: return new AddVDNode(n1, n2, vt);
263
264 case Op_SubVB: return new SubVBNode(n1, n2, vt);
265 case Op_SubVS: return new SubVSNode(n1, n2, vt);
266 case Op_SubVI: return new SubVINode(n1, n2, vt);
267 case Op_SubVL: return new SubVLNode(n1, n2, vt);
268 case Op_SubVF: return new SubVFNode(n1, n2, vt);
269 case Op_SubVD: return new SubVDNode(n1, n2, vt);
270
271 case Op_MulVS: return new MulVSNode(n1, n2, vt);
272 case Op_MulVI: return new MulVINode(n1, n2, vt);
273 case Op_MulVL: return new MulVLNode(n1, n2, vt);
274 case Op_MulVF: return new MulVFNode(n1, n2, vt);
275 case Op_MulVD: return new MulVDNode(n1, n2, vt);
276
277 case Op_DivVF: return new DivVFNode(n1, n2, vt);
278 case Op_DivVD: return new DivVDNode(n1, n2, vt);
279
280 case Op_LShiftVB: return new LShiftVBNode(n1, n2, vt);
281 case Op_LShiftVS: return new LShiftVSNode(n1, n2, vt);
282 case Op_LShiftVI: return new LShiftVINode(n1, n2, vt);
283 case Op_LShiftVL: return new LShiftVLNode(n1, n2, vt);
284
285 case Op_RShiftVB: return new RShiftVBNode(n1, n2, vt);
286 case Op_RShiftVS: return new RShiftVSNode(n1, n2, vt);
287 case Op_RShiftVI: return new RShiftVINode(n1, n2, vt);
288 case Op_RShiftVL: return new RShiftVLNode(n1, n2, vt);
289
290 case Op_URShiftVB: return new URShiftVBNode(n1, n2, vt);
291 case Op_URShiftVS: return new URShiftVSNode(n1, n2, vt);
292 case Op_URShiftVI: return new URShiftVINode(n1, n2, vt);
293 case Op_URShiftVL: return new URShiftVLNode(n1, n2, vt);
450 case Op_AddI:
451 assert(bt == T_INT, "must be");
452 vopc = Op_AddReductionVI;
453 break;
454 case Op_AddL:
455 assert(bt == T_LONG, "must be");
456 vopc = Op_AddReductionVL;
457 break;
458 case Op_AddF:
459 assert(bt == T_FLOAT, "must be");
460 vopc = Op_AddReductionVF;
461 break;
462 case Op_AddD:
463 assert(bt == T_DOUBLE, "must be");
464 vopc = Op_AddReductionVD;
465 break;
466 case Op_MulI:
467 assert(bt == T_INT, "must be");
468 vopc = Op_MulReductionVI;
469 break;
470 case Op_MulL:
471 assert(bt == T_LONG, "must be");
472 vopc = Op_MulReductionVL;
473 break;
474 case Op_MulF:
475 assert(bt == T_FLOAT, "must be");
476 vopc = Op_MulReductionVF;
477 break;
478 case Op_MulD:
479 assert(bt == T_DOUBLE, "must be");
480 vopc = Op_MulReductionVD;
481 break;
482 // TODO: add MulL for targets that support it
483 default:
484 break;
485 }
486 return vopc;
487 }
488
489 // Return the appropriate reduction node.
490 ReductionNode* ReductionNode::make(int opc, Node *ctrl, Node* n1, Node* n2, BasicType bt) {
491
492 int vopc = opcode(opc, bt);
493
494 // This method should not be called for unimplemented vectors.
495 guarantee(vopc != opc, err_msg_res("Vector for '%s' is not implemented", NodeClassNames[opc]));
496
497 switch (vopc) {
498 case Op_AddReductionVI: return new AddReductionVINode(ctrl, n1, n2);
499 case Op_AddReductionVL: return new AddReductionVLNode(ctrl, n1, n2);
500 case Op_AddReductionVF: return new AddReductionVFNode(ctrl, n1, n2);
501 case Op_AddReductionVD: return new AddReductionVDNode(ctrl, n1, n2);
502 case Op_MulReductionVI: return new MulReductionVINode(ctrl, n1, n2);
503 case Op_MulReductionVL: return new MulReductionVLNode(ctrl, n1, n2);
504 case Op_MulReductionVF: return new MulReductionVFNode(ctrl, n1, n2);
505 case Op_MulReductionVD: return new MulReductionVDNode(ctrl, n1, n2);
506 }
507 fatal(err_msg_res("Missed vector creation for '%s'", NodeClassNames[vopc]));
508 return NULL;
509 }
510
511 bool ReductionNode::implemented(int opc, uint vlen, BasicType bt) {
512 if (is_java_primitive(bt) &&
513 (vlen > 1) && is_power_of_2(vlen) &&
514 Matcher::vector_size_supported(bt, vlen)) {
515 int vopc = ReductionNode::opcode(opc, bt);
516 return vopc != opc && Matcher::match_rule_supported(vopc);
517 }
518 return false;
519 }
520
|