233 case Op_XorI: case Op_XorL:
234 *start = 1;
235 *end = 3; // 2 vector operands
236 break;
237 case Op_CMoveI: case Op_CMoveL: case Op_CMoveF: case Op_CMoveD:
238 *start = 2;
239 *end = n->req();
240 break;
241 default:
242 *start = 1;
243 *end = n->req(); // default is all operands
244 }
245 }
246
247 // Return the vector version of a scalar operation node.
248 VectorNode* VectorNode::make(int opc, Node* n1, Node* n2, uint vlen, BasicType bt) {
249 const TypeVect* vt = TypeVect::make(bt, vlen);
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
254 switch (vopc) {
255 case Op_AddVB: return new AddVBNode(n1, n2, vt);
256 case Op_AddVS: return new AddVSNode(n1, n2, vt);
257 case Op_AddVI: return new AddVINode(n1, n2, vt);
258 case Op_AddVL: return new AddVLNode(n1, n2, vt);
259 case Op_AddVF: return new AddVFNode(n1, n2, vt);
260 case Op_AddVD: return new AddVDNode(n1, n2, vt);
261
262 case Op_SubVB: return new SubVBNode(n1, n2, vt);
263 case Op_SubVS: return new SubVSNode(n1, n2, vt);
264 case Op_SubVI: return new SubVINode(n1, n2, vt);
265 case Op_SubVL: return new SubVLNode(n1, n2, vt);
266 case Op_SubVF: return new SubVFNode(n1, n2, vt);
267 case Op_SubVD: return new SubVDNode(n1, n2, vt);
268
269 case Op_MulVS: return new MulVSNode(n1, n2, vt);
270 case Op_MulVI: return new MulVINode(n1, n2, vt);
271 case Op_MulVF: return new MulVFNode(n1, n2, vt);
272 case Op_MulVD: return new MulVDNode(n1, n2, vt);
273
424 return new ExtractUBNode(v, pos);
425 case T_BYTE:
426 return new ExtractBNode(v, pos);
427 case T_CHAR:
428 return new ExtractCNode(v, pos);
429 case T_SHORT:
430 return new ExtractSNode(v, pos);
431 case T_INT:
432 return new ExtractINode(v, pos);
433 case T_LONG:
434 return new ExtractLNode(v, pos);
435 case T_FLOAT:
436 return new ExtractFNode(v, pos);
437 case T_DOUBLE:
438 return new ExtractDNode(v, pos);
439 }
440 fatal(err_msg_res("Type '%s' is not supported for vectors", type2name(bt)));
441 return NULL;
442 }
443
|
233 case Op_XorI: case Op_XorL:
234 *start = 1;
235 *end = 3; // 2 vector operands
236 break;
237 case Op_CMoveI: case Op_CMoveL: case Op_CMoveF: case Op_CMoveD:
238 *start = 2;
239 *end = n->req();
240 break;
241 default:
242 *start = 1;
243 *end = n->req(); // default is all operands
244 }
245 }
246
247 // Return the vector version of a scalar operation node.
248 VectorNode* VectorNode::make(int opc, Node* n1, Node* n2, uint vlen, BasicType bt) {
249 const TypeVect* vt = TypeVect::make(bt, vlen);
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
423 return new ExtractUBNode(v, pos);
424 case T_BYTE:
425 return new ExtractBNode(v, pos);
426 case T_CHAR:
427 return new ExtractCNode(v, pos);
428 case T_SHORT:
429 return new ExtractSNode(v, pos);
430 case T_INT:
431 return new ExtractINode(v, pos);
432 case T_LONG:
433 return new ExtractLNode(v, pos);
434 case T_FLOAT:
435 return new ExtractFNode(v, pos);
436 case T_DOUBLE:
437 return new ExtractDNode(v, pos);
438 }
439 fatal(err_msg_res("Type '%s' is not supported for vectors", type2name(bt)));
440 return NULL;
441 }
442
443 int ReductionNode::opcode(int opc, BasicType bt) {
444 int vopc = opc;
445 switch (opc) {
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
|