src/share/vm/opto/vectornode.cpp
Index Unified diffs Context diffs Sdiffs Wdiffs Patch New Old Previous File Next File hotspot Sdiff src/share/vm/opto

src/share/vm/opto/vectornode.cpp

Print this page




 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 
src/share/vm/opto/vectornode.cpp
Index Unified diffs Context diffs Sdiffs Wdiffs Patch New Old Previous File Next File