< prev index next >

src/share/vm/opto/vectornode.hpp

Print this page




  38     init_class_id(Class_Vector);
  39     init_req(1, n1);
  40   }
  41   VectorNode(Node* n1, Node* n2, const TypeVect* vt) : TypeNode(vt, 3) {
  42     init_class_id(Class_Vector);
  43     init_req(1, n1);
  44     init_req(2, n2);
  45   }
  46 
  47   VectorNode(Node* n1, Node* n2, Node* n3, const TypeVect* vt) : TypeNode(vt, 4) {
  48     init_class_id(Class_Vector);
  49     init_req(1, n1);
  50     init_req(2, n2);
  51     init_req(3, n3);
  52   }
  53 
  54   const TypeVect* vect_type() const { return type()->is_vect(); }
  55   uint length() const { return vect_type()->length(); } // Vector length
  56   uint length_in_bytes() const { return vect_type()->length_in_bytes(); }
  57 
  58   virtual int Opcode() const;
  59 
  60   virtual uint ideal_reg() const { return Matcher::vector_ideal_reg(vect_type()->length_in_bytes()); }
  61 
  62   static VectorNode* scalar2vector(Node* s, uint vlen, const Type* opd_t);
  63   static VectorNode* shift_count(Node* shift, Node* cnt, uint vlen, BasicType bt);
  64   static VectorNode* make(int opc, Node* n1, Node* n2, uint vlen, BasicType bt);
  65 
  66   static int  opcode(int opc, BasicType bt);
  67   static bool implemented(int opc, uint vlen, BasicType bt);
  68   static bool is_shift(Node* n);
  69   static bool is_invariant_vector(Node* n);
  70   // [Start, end) half-open range defining which operands are vectors
  71   static void vector_operands(Node* n, uint* start, uint* end);
  72 };
  73 
  74 //===========================Vector=ALU=Operations=============================
  75 
  76 //------------------------------AddVBNode--------------------------------------
  77 // Vector add byte
  78 class AddVBNode : public VectorNode {
  79  public:
  80   AddVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
  81   virtual int Opcode() const;
  82 };
  83 
  84 //------------------------------AddVSNode--------------------------------------
  85 // Vector add char/short
  86 class AddVSNode : public VectorNode {
  87  public:
  88   AddVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
  89   virtual int Opcode() const;
  90 };
  91 
  92 //------------------------------AddVINode--------------------------------------
  93 // Vector add int
  94 class AddVINode : public VectorNode {
  95  public:
  96   AddVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
  97   virtual int Opcode() const;
  98 };
  99 
 100 //------------------------------AddVLNode--------------------------------------
 101 // Vector add long
 102 class AddVLNode : public VectorNode {
 103 public:
 104   AddVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {}
 105   virtual int Opcode() const;
 106 };
 107 
 108 //------------------------------AddVFNode--------------------------------------
 109 // Vector add float
 110 class AddVFNode : public VectorNode {
 111 public:
 112   AddVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {}
 113   virtual int Opcode() const;
 114 };
 115 
 116 //------------------------------AddVDNode--------------------------------------
 117 // Vector add double
 118 class AddVDNode : public VectorNode {
 119 public:
 120   AddVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {}
 121   virtual int Opcode() const;
 122 };
 123 
 124 //------------------------------ReductionNode------------------------------------
 125 // Perform reduction of a vector
 126 class ReductionNode : public Node {
 127  public:
 128   ReductionNode(Node *ctrl, Node* in1, Node* in2) : Node(ctrl, in1, in2) {}
 129 
 130   static ReductionNode* make(int opc, Node *ctrl, Node* in1, Node* in2, BasicType bt);
 131   static int  opcode(int opc, BasicType bt);
 132   static bool implemented(int opc, uint vlen, BasicType bt);
 133 };
 134 
 135 //------------------------------AddReductionVINode--------------------------------------
 136 // Vector add int as a reduction
 137 class AddReductionVINode : public ReductionNode {
 138 public:
 139   AddReductionVINode(Node * ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}
 140   virtual int Opcode() const;
 141   virtual const Type* bottom_type() const { return TypeInt::INT; }
 142   virtual uint ideal_reg() const { return Op_RegI; }
 143 };
 144 
 145 //------------------------------AddReductionVLNode--------------------------------------
 146 // Vector add long as a reduction
 147 class AddReductionVLNode : public ReductionNode {
 148 public:
 149   AddReductionVLNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}
 150   virtual int Opcode() const;
 151   virtual const Type* bottom_type() const { return TypeLong::LONG; }
 152   virtual uint ideal_reg() const { return Op_RegL; }
 153 };
 154 
 155 //------------------------------AddReductionVFNode--------------------------------------
 156 // Vector add float as a reduction
 157 class AddReductionVFNode : public ReductionNode {
 158 public:
 159   AddReductionVFNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}
 160   virtual int Opcode() const;
 161   virtual const Type* bottom_type() const { return Type::FLOAT; }
 162   virtual uint ideal_reg() const { return Op_RegF; }
 163 };
 164 
 165 //------------------------------AddReductionVDNode--------------------------------------
 166 // Vector add double as a reduction
 167 class AddReductionVDNode : public ReductionNode {
 168 public:
 169   AddReductionVDNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}
 170   virtual int Opcode() const;
 171   virtual const Type* bottom_type() const { return Type::DOUBLE; }
 172   virtual uint ideal_reg() const { return Op_RegD; }
 173 };
 174 
 175 //------------------------------SubVBNode--------------------------------------
 176 // Vector subtract byte
 177 class SubVBNode : public VectorNode {
 178  public:
 179   SubVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 180   virtual int Opcode() const;
 181 };
 182 
 183 //------------------------------SubVSNode--------------------------------------
 184 // Vector subtract short
 185 class SubVSNode : public VectorNode {
 186  public:
 187   SubVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 188   virtual int Opcode() const;
 189 };
 190 
 191 //------------------------------SubVINode--------------------------------------
 192 // Vector subtract int
 193 class SubVINode : public VectorNode {
 194  public:
 195   SubVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 196   virtual int Opcode() const;
 197 };
 198 
 199 //------------------------------SubVLNode--------------------------------------
 200 // Vector subtract long
 201 class SubVLNode : public VectorNode {
 202  public:
 203   SubVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 204   virtual int Opcode() const;
 205 };
 206 
 207 //------------------------------SubVFNode--------------------------------------
 208 // Vector subtract float
 209 class SubVFNode : public VectorNode {
 210  public:
 211   SubVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 212   virtual int Opcode() const;
 213 };
 214 
 215 //------------------------------SubVDNode--------------------------------------
 216 // Vector subtract double
 217 class SubVDNode : public VectorNode {
 218  public:
 219   SubVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 220   virtual int Opcode() const;
 221 };
 222 
 223 //------------------------------MulVSNode--------------------------------------
 224 // Vector multiply short
 225 class MulVSNode : public VectorNode {
 226  public:
 227   MulVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 228   virtual int Opcode() const;
 229 };
 230 
 231 //------------------------------MulVINode--------------------------------------
 232 // Vector multiply int
 233 class MulVINode : public VectorNode {
 234  public:
 235   MulVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 236   virtual int Opcode() const;
 237 };
 238 
 239 //------------------------------MulVLNode--------------------------------------
 240 // Vector multiply long
 241 class MulVLNode : public VectorNode {
 242 public:
 243   MulVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {}
 244   virtual int Opcode() const;
 245 };
 246 
 247 //------------------------------MulVFNode--------------------------------------
 248 // Vector multiply float
 249 class MulVFNode : public VectorNode {
 250 public:
 251   MulVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {}
 252   virtual int Opcode() const;
 253 };
 254 
 255 //------------------------------MulVDNode--------------------------------------
 256 // Vector multiply double
 257 class MulVDNode : public VectorNode {
 258 public:
 259   MulVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {}
 260   virtual int Opcode() const;
 261 };
 262 
 263 //------------------------------CMoveVDNode--------------------------------------
 264 // Vector multiply double
 265 class CMoveVDNode : public VectorNode {
 266 public:
 267   CMoveVDNode(Node* in1, Node* in2, Node* in3, const TypeVect* vt) : VectorNode(in1, in2, in3, vt) {}
 268   virtual int Opcode() const;
 269 };
 270 
 271 //------------------------------MulReductionVINode--------------------------------------
 272 // Vector multiply int as a reduction
 273 class MulReductionVINode : public ReductionNode {
 274 public:
 275   MulReductionVINode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}
 276   virtual int Opcode() const;
 277   virtual const Type* bottom_type() const { return TypeInt::INT; }
 278   virtual uint ideal_reg() const { return Op_RegI; }
 279 };
 280 
 281 //------------------------------MulReductionVLNode--------------------------------------
 282 // Vector multiply int as a reduction
 283 class MulReductionVLNode : public ReductionNode {
 284 public:
 285   MulReductionVLNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}
 286   virtual int Opcode() const;
 287   virtual const Type* bottom_type() const { return TypeLong::LONG; }
 288   virtual uint ideal_reg() const { return Op_RegI; }
 289 };
 290 
 291 //------------------------------MulReductionVFNode--------------------------------------
 292 // Vector multiply float as a reduction
 293 class MulReductionVFNode : public ReductionNode {
 294 public:
 295   MulReductionVFNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}
 296   virtual int Opcode() const;
 297   virtual const Type* bottom_type() const { return Type::FLOAT; }
 298   virtual uint ideal_reg() const { return Op_RegF; }
 299 };
 300 
 301 //------------------------------MulReductionVDNode--------------------------------------
 302 // Vector multiply double as a reduction
 303 class MulReductionVDNode : public ReductionNode {
 304 public:
 305   MulReductionVDNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}
 306   virtual int Opcode() const;
 307   virtual const Type* bottom_type() const { return Type::DOUBLE; }
 308   virtual uint ideal_reg() const { return Op_RegD; }
 309 };
 310 
 311 //------------------------------DivVFNode--------------------------------------
 312 // Vector divide float
 313 class DivVFNode : public VectorNode {
 314  public:
 315   DivVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 316   virtual int Opcode() const;
 317 };
 318 
 319 //------------------------------DivVDNode--------------------------------------
 320 // Vector Divide double
 321 class DivVDNode : public VectorNode {
 322  public:
 323   DivVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 324   virtual int Opcode() const;
 325 };
 326 
 327 //------------------------------AbsVFNode--------------------------------------
 328 // Vector Abs float
 329 class AbsVFNode : public VectorNode {
 330  public:
 331   AbsVFNode(Node* in, const TypeVect* vt) : VectorNode(in,vt) {}
 332   virtual int Opcode() const;
 333 };
 334 
 335 //------------------------------AbsVDNode--------------------------------------
 336 // Vector Abs double
 337 class AbsVDNode : public VectorNode {
 338  public:
 339   AbsVDNode(Node* in, const TypeVect* vt) : VectorNode(in,vt) {}
 340   virtual int Opcode() const;
 341 };
 342 
 343 //------------------------------NegVFNode--------------------------------------
 344 // Vector Neg float
 345 class NegVFNode : public VectorNode {
 346  public:
 347   NegVFNode(Node* in, const TypeVect* vt) : VectorNode(in,vt) {}
 348   virtual int Opcode() const;
 349 };
 350 
 351 //------------------------------NegVDNode--------------------------------------
 352 // Vector Neg double
 353 class NegVDNode : public VectorNode {
 354  public:
 355   NegVDNode(Node* in, const TypeVect* vt) : VectorNode(in,vt) {}
 356   virtual int Opcode() const;
 357 };
 358 
 359 //------------------------------SqrtVDNode--------------------------------------
 360 // Vector Sqrt double
 361 class SqrtVDNode : public VectorNode {
 362  public:
 363   SqrtVDNode(Node* in, const TypeVect* vt) : VectorNode(in,vt) {}
 364   virtual int Opcode() const;
 365 };
 366 
 367 //------------------------------LShiftVBNode-----------------------------------
 368 // Vector left shift bytes
 369 class LShiftVBNode : public VectorNode {
 370  public:
 371   LShiftVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 372   virtual int Opcode() const;
 373 };
 374 
 375 //------------------------------LShiftVSNode-----------------------------------
 376 // Vector left shift shorts
 377 class LShiftVSNode : public VectorNode {
 378  public:
 379   LShiftVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 380   virtual int Opcode() const;
 381 };
 382 
 383 //------------------------------LShiftVINode-----------------------------------
 384 // Vector left shift ints
 385 class LShiftVINode : public VectorNode {
 386  public:
 387   LShiftVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 388   virtual int Opcode() const;
 389 };
 390 
 391 //------------------------------LShiftVLNode-----------------------------------
 392 // Vector left shift longs
 393 class LShiftVLNode : public VectorNode {
 394  public:
 395   LShiftVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 396   virtual int Opcode() const;
 397 };
 398 
 399 //------------------------------RShiftVBNode-----------------------------------
 400 // Vector right arithmetic (signed) shift bytes
 401 class RShiftVBNode : public VectorNode {
 402  public:
 403   RShiftVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 404   virtual int Opcode() const;
 405 };
 406 
 407 //------------------------------RShiftVSNode-----------------------------------
 408 // Vector right arithmetic (signed) shift shorts
 409 class RShiftVSNode : public VectorNode {
 410  public:
 411   RShiftVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 412   virtual int Opcode() const;
 413 };
 414 
 415 //------------------------------RShiftVINode-----------------------------------
 416 // Vector right arithmetic (signed) shift ints
 417 class RShiftVINode : public VectorNode {
 418  public:
 419   RShiftVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 420   virtual int Opcode() const;
 421 };
 422 
 423 //------------------------------RShiftVLNode-----------------------------------
 424 // Vector right arithmetic (signed) shift longs
 425 class RShiftVLNode : public VectorNode {
 426  public:
 427   RShiftVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 428   virtual int Opcode() const;
 429 };
 430 
 431 //------------------------------URShiftVBNode----------------------------------
 432 // Vector right logical (unsigned) shift bytes
 433 class URShiftVBNode : public VectorNode {
 434  public:
 435   URShiftVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 436   virtual int Opcode() const;
 437 };
 438 
 439 //------------------------------URShiftVSNode----------------------------------
 440 // Vector right logical (unsigned) shift shorts
 441 class URShiftVSNode : public VectorNode {
 442  public:
 443   URShiftVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 444   virtual int Opcode() const;
 445 };
 446 
 447 //------------------------------URShiftVINode----------------------------------
 448 // Vector right logical (unsigned) shift ints
 449 class URShiftVINode : public VectorNode {
 450  public:
 451   URShiftVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 452   virtual int Opcode() const;
 453 };
 454 
 455 //------------------------------URShiftVLNode----------------------------------
 456 // Vector right logical (unsigned) shift longs
 457 class URShiftVLNode : public VectorNode {
 458  public:
 459   URShiftVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 460   virtual int Opcode() const;
 461 };
 462 
 463 //------------------------------LShiftCntVNode---------------------------------
 464 // Vector left shift count
 465 class LShiftCntVNode : public VectorNode {
 466  public:
 467   LShiftCntVNode(Node* cnt, const TypeVect* vt) : VectorNode(cnt,vt) {}
 468   virtual int Opcode() const;
 469   virtual uint ideal_reg() const { return Matcher::vector_shift_count_ideal_reg(vect_type()->length_in_bytes()); }
 470 };
 471 
 472 //------------------------------RShiftCntVNode---------------------------------
 473 // Vector right shift count
 474 class RShiftCntVNode : public VectorNode {
 475  public:
 476   RShiftCntVNode(Node* cnt, const TypeVect* vt) : VectorNode(cnt,vt) {}
 477   virtual int Opcode() const;
 478   virtual uint ideal_reg() const { return Matcher::vector_shift_count_ideal_reg(vect_type()->length_in_bytes()); }
 479 };
 480 
 481 
 482 //------------------------------AndVNode---------------------------------------
 483 // Vector and integer
 484 class AndVNode : public VectorNode {
 485  public:
 486   AndVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 487   virtual int Opcode() const;
 488 };
 489 
 490 //------------------------------OrVNode---------------------------------------
 491 // Vector or integer
 492 class OrVNode : public VectorNode {
 493  public:
 494   OrVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 495   virtual int Opcode() const;
 496 };
 497 
 498 //------------------------------XorVNode---------------------------------------
 499 // Vector xor integer
 500 class XorVNode : public VectorNode {
 501  public:
 502   XorVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 503   virtual int Opcode() const;
 504 };
 505 
 506 //================================= M E M O R Y ===============================
 507 
 508 //------------------------------LoadVectorNode---------------------------------
 509 // Load Vector from memory
 510 class LoadVectorNode : public LoadNode {
 511  public:
 512   LoadVectorNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeVect* vt, ControlDependency control_dependency = LoadNode::DependsOnlyOnTest)
 513     : LoadNode(c, mem, adr, at, vt, MemNode::unordered, control_dependency) {
 514     init_class_id(Class_LoadVector);
 515   }
 516 
 517   const TypeVect* vect_type() const { return type()->is_vect(); }
 518   uint length() const { return vect_type()->length(); } // Vector length
 519 
 520   virtual int Opcode() const;
 521 
 522   virtual uint ideal_reg() const  { return Matcher::vector_ideal_reg(memory_size()); }
 523   virtual BasicType memory_type() const { return T_VOID; }
 524   virtual int memory_size() const { return vect_type()->length_in_bytes(); }
 525 
 526   virtual int store_Opcode() const { return Op_StoreVector; }
 527 
 528   static LoadVectorNode* make(int opc, Node* ctl, Node* mem,
 529                               Node* adr, const TypePtr* atyp,
 530                               uint vlen, BasicType bt,
 531                               ControlDependency control_dependency = LoadNode::DependsOnlyOnTest);
 532   uint element_size(void) { return type2aelembytes(vect_type()->element_basic_type()); }
 533 };
 534 
 535 //------------------------------StoreVectorNode--------------------------------
 536 // Store Vector to memory
 537 class StoreVectorNode : public StoreNode {
 538  public:
 539   StoreVectorNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
 540     : StoreNode(c, mem, adr, at, val, MemNode::unordered) {
 541     assert(val->is_Vector() || val->is_LoadVector(), "sanity");
 542     init_class_id(Class_StoreVector);
 543   }
 544 
 545   const TypeVect* vect_type() const { return in(MemNode::ValueIn)->bottom_type()->is_vect(); }
 546   uint length() const { return vect_type()->length(); } // Vector length
 547 
 548   virtual int Opcode() const;
 549 
 550   virtual uint ideal_reg() const  { return Matcher::vector_ideal_reg(memory_size()); }
 551   virtual BasicType memory_type() const { return T_VOID; }
 552   virtual int memory_size() const { return vect_type()->length_in_bytes(); }
 553 
 554   static StoreVectorNode* make(int opc, Node* ctl, Node* mem,
 555                                Node* adr, const TypePtr* atyp, Node* val,
 556                                uint vlen);
 557 
 558   uint element_size(void) { return type2aelembytes(vect_type()->element_basic_type()); }
 559 };
 560 
 561 
 562 //=========================Promote_Scalar_to_Vector============================
 563 
 564 //------------------------------ReplicateBNode---------------------------------
 565 // Replicate byte scalar to be vector
 566 class ReplicateBNode : public VectorNode {
 567  public:
 568   ReplicateBNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
 569   virtual int Opcode() const;
 570 };
 571 
 572 //------------------------------ReplicateSNode---------------------------------
 573 // Replicate short scalar to be vector
 574 class ReplicateSNode : public VectorNode {
 575  public:
 576   ReplicateSNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
 577   virtual int Opcode() const;
 578 };
 579 
 580 //------------------------------ReplicateINode---------------------------------
 581 // Replicate int scalar to be vector
 582 class ReplicateINode : public VectorNode {
 583  public:
 584   ReplicateINode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
 585   virtual int Opcode() const;
 586 };
 587 
 588 //------------------------------ReplicateLNode---------------------------------
 589 // Replicate long scalar to be vector
 590 class ReplicateLNode : public VectorNode {
 591  public:
 592   ReplicateLNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
 593   virtual int Opcode() const;
 594 };
 595 
 596 //------------------------------ReplicateFNode---------------------------------
 597 // Replicate float scalar to be vector
 598 class ReplicateFNode : public VectorNode {
 599  public:
 600   ReplicateFNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
 601   virtual int Opcode() const;
 602 };
 603 
 604 //------------------------------ReplicateDNode---------------------------------
 605 // Replicate double scalar to be vector
 606 class ReplicateDNode : public VectorNode {
 607  public:
 608   ReplicateDNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
 609   virtual int Opcode() const;
 610 };
 611 
 612 //========================Pack_Scalars_into_a_Vector===========================
 613 
 614 //------------------------------PackNode---------------------------------------
 615 // Pack parent class (not for code generation).
 616 class PackNode : public VectorNode {
 617  public:
 618   PackNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
 619   PackNode(Node* in1, Node* n2, const TypeVect* vt) : VectorNode(in1, n2, vt) {}
 620   virtual int Opcode() const;
 621 
 622   void add_opd(Node* n) {
 623     add_req(n);
 624   }
 625 
 626   // Create a binary tree form for Packs. [lo, hi) (half-open) range
 627   PackNode* binary_tree_pack(int lo, int hi);
 628 
 629   static PackNode* make(Node* s, uint vlen, BasicType bt);
 630 };
 631 
 632 //------------------------------PackBNode--------------------------------------
 633 // Pack byte scalars into vector
 634 class PackBNode : public PackNode {
 635  public:
 636   PackBNode(Node* in1, const TypeVect* vt)  : PackNode(in1, vt) {}
 637   virtual int Opcode() const;
 638 };
 639 
 640 //------------------------------PackSNode--------------------------------------
 641 // Pack short scalars into a vector
 642 class PackSNode : public PackNode {
 643  public:
 644   PackSNode(Node* in1, const TypeVect* vt)  : PackNode(in1, vt) {}
 645   PackSNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
 646   virtual int Opcode() const;
 647 };
 648 
 649 //------------------------------PackINode--------------------------------------
 650 // Pack integer scalars into a vector
 651 class PackINode : public PackNode {
 652  public:
 653   PackINode(Node* in1, const TypeVect* vt)  : PackNode(in1, vt) {}
 654   PackINode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
 655   virtual int Opcode() const;
 656 };
 657 
 658 //------------------------------PackLNode--------------------------------------
 659 // Pack long scalars into a vector
 660 class PackLNode : public PackNode {
 661  public:
 662   PackLNode(Node* in1, const TypeVect* vt)  : PackNode(in1, vt) {}
 663   PackLNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
 664   virtual int Opcode() const;
 665 };
 666 
 667 //------------------------------Pack2LNode-------------------------------------
 668 // Pack 2 long scalars into a vector
 669 class Pack2LNode : public PackNode {
 670  public:
 671   Pack2LNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
 672   virtual int Opcode() const;
 673 };
 674 
 675 //------------------------------PackFNode--------------------------------------
 676 // Pack float scalars into vector
 677 class PackFNode : public PackNode {
 678  public:
 679   PackFNode(Node* in1, const TypeVect* vt)  : PackNode(in1, vt) {}
 680   PackFNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
 681   virtual int Opcode() const;
 682 };
 683 
 684 //------------------------------PackDNode--------------------------------------
 685 // Pack double scalars into a vector
 686 class PackDNode : public PackNode {
 687  public:
 688   PackDNode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {}
 689   PackDNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
 690   virtual int Opcode() const;
 691 };
 692 
 693 //------------------------------Pack2DNode-------------------------------------
 694 // Pack 2 double scalars into a vector
 695 class Pack2DNode : public PackNode {
 696  public:
 697   Pack2DNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
 698   virtual int Opcode() const;
 699 };
 700 
 701 
 702 //========================Extract_Scalar_from_Vector===========================
 703 
 704 //------------------------------ExtractNode------------------------------------
 705 // Extract a scalar from a vector at position "pos"
 706 class ExtractNode : public Node {
 707  public:
 708   ExtractNode(Node* src, ConINode* pos) : Node(NULL, src, (Node*)pos) {
 709     assert(in(2)->get_int() >= 0, "positive constants");
 710   }
 711   virtual int Opcode() const;
 712   uint  pos() const { return in(2)->get_int(); }
 713 
 714   static Node* make(Node* v, uint position, BasicType bt);
 715 };
 716 
 717 //------------------------------ExtractBNode-----------------------------------
 718 // Extract a byte from a vector at position "pos"
 719 class ExtractBNode : public ExtractNode {
 720  public:
 721   ExtractBNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
 722   virtual int Opcode() const;
 723   virtual const Type *bottom_type() const { return TypeInt::INT; }
 724   virtual uint ideal_reg() const { return Op_RegI; }
 725 };
 726 
 727 //------------------------------ExtractUBNode----------------------------------
 728 // Extract a boolean from a vector at position "pos"
 729 class ExtractUBNode : public ExtractNode {
 730  public:
 731   ExtractUBNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
 732   virtual int Opcode() const;
 733   virtual const Type *bottom_type() const { return TypeInt::INT; }
 734   virtual uint ideal_reg() const { return Op_RegI; }
 735 };
 736 
 737 //------------------------------ExtractCNode-----------------------------------
 738 // Extract a char from a vector at position "pos"
 739 class ExtractCNode : public ExtractNode {
 740  public:
 741   ExtractCNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
 742   virtual int Opcode() const;
 743   virtual const Type *bottom_type() const { return TypeInt::INT; }
 744   virtual uint ideal_reg() const { return Op_RegI; }
 745 };
 746 
 747 //------------------------------ExtractSNode-----------------------------------
 748 // Extract a short from a vector at position "pos"
 749 class ExtractSNode : public ExtractNode {
 750  public:
 751   ExtractSNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
 752   virtual int Opcode() const;
 753   virtual const Type *bottom_type() const { return TypeInt::INT; }
 754   virtual uint ideal_reg() const { return Op_RegI; }
 755 };
 756 
 757 //------------------------------ExtractINode-----------------------------------
 758 // Extract an int from a vector at position "pos"
 759 class ExtractINode : public ExtractNode {
 760  public:
 761   ExtractINode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
 762   virtual int Opcode() const;
 763   virtual const Type *bottom_type() const { return TypeInt::INT; }
 764   virtual uint ideal_reg() const { return Op_RegI; }
 765 };
 766 
 767 //------------------------------ExtractLNode-----------------------------------
 768 // Extract a long from a vector at position "pos"
 769 class ExtractLNode : public ExtractNode {
 770  public:
 771   ExtractLNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
 772   virtual int Opcode() const;
 773   virtual const Type *bottom_type() const { return TypeLong::LONG; }
 774   virtual uint ideal_reg() const { return Op_RegL; }
 775 };
 776 
 777 //------------------------------ExtractFNode-----------------------------------
 778 // Extract a float from a vector at position "pos"
 779 class ExtractFNode : public ExtractNode {
 780  public:
 781   ExtractFNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
 782   virtual int Opcode() const;
 783   virtual const Type *bottom_type() const { return Type::FLOAT; }
 784   virtual uint ideal_reg() const { return Op_RegF; }
 785 };
 786 
 787 //------------------------------ExtractDNode-----------------------------------
 788 // Extract a double from a vector at position "pos"
 789 class ExtractDNode : public ExtractNode {
 790  public:
 791   ExtractDNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
 792   virtual int Opcode() const;
 793   virtual const Type *bottom_type() const { return Type::DOUBLE; }
 794   virtual uint ideal_reg() const { return Op_RegD; }
 795 };
 796 
 797 //------------------------------SetVectMaskINode-------------------------------
 798 // Provide a mask for a vector predicate machine
 799 class SetVectMaskINode : public Node {
 800 public:
 801   SetVectMaskINode(Node *c, Node *in1) : Node(c, in1) {}
 802   virtual int Opcode() const;
 803   const Type *bottom_type() const { return TypeInt::INT; }
 804   virtual uint ideal_reg() const { return Op_RegI; }
 805   virtual const Type *Value(PhaseGVN *phase) const { return TypeInt::INT; }
 806 };
 807 
 808 #endif // SHARE_VM_OPTO_VECTORNODE_HPP


  38     init_class_id(Class_Vector);
  39     init_req(1, n1);
  40   }
  41   VectorNode(Node* n1, Node* n2, const TypeVect* vt) : TypeNode(vt, 3) {
  42     init_class_id(Class_Vector);
  43     init_req(1, n1);
  44     init_req(2, n2);
  45   }
  46 
  47   VectorNode(Node* n1, Node* n2, Node* n3, const TypeVect* vt) : TypeNode(vt, 4) {
  48     init_class_id(Class_Vector);
  49     init_req(1, n1);
  50     init_req(2, n2);
  51     init_req(3, n3);
  52   }
  53 
  54   const TypeVect* vect_type() const { return type()->is_vect(); }
  55   uint length() const { return vect_type()->length(); } // Vector length
  56   uint length_in_bytes() const { return vect_type()->length_in_bytes(); }
  57 
  58   virtual uint Opcode() const;
  59 
  60   virtual uint ideal_reg() const { return Matcher::vector_ideal_reg(vect_type()->length_in_bytes()); }
  61 
  62   static VectorNode* scalar2vector(Node* s, uint vlen, const Type* opd_t);
  63   static VectorNode* shift_count(Node* shift, Node* cnt, uint vlen, BasicType bt);
  64   static VectorNode* make(int opc, Node* n1, Node* n2, uint vlen, BasicType bt);
  65 
  66   static int  opcode(int opc, BasicType bt);
  67   static bool implemented(int opc, uint vlen, BasicType bt);
  68   static bool is_shift(Node* n);
  69   static bool is_invariant_vector(Node* n);
  70   // [Start, end) half-open range defining which operands are vectors
  71   static void vector_operands(Node* n, uint* start, uint* end);
  72 };
  73 
  74 //===========================Vector=ALU=Operations=============================
  75 
  76 //------------------------------AddVBNode--------------------------------------
  77 // Vector add byte
  78 class AddVBNode : public VectorNode {
  79  public:
  80   AddVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
  81   virtual uint Opcode() const;
  82 };
  83 
  84 //------------------------------AddVSNode--------------------------------------
  85 // Vector add char/short
  86 class AddVSNode : public VectorNode {
  87  public:
  88   AddVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
  89   virtual uint Opcode() const;
  90 };
  91 
  92 //------------------------------AddVINode--------------------------------------
  93 // Vector add int
  94 class AddVINode : public VectorNode {
  95  public:
  96   AddVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
  97   virtual uint Opcode() const;
  98 };
  99 
 100 //------------------------------AddVLNode--------------------------------------
 101 // Vector add long
 102 class AddVLNode : public VectorNode {
 103 public:
 104   AddVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {}
 105   virtual uint Opcode() const;
 106 };
 107 
 108 //------------------------------AddVFNode--------------------------------------
 109 // Vector add float
 110 class AddVFNode : public VectorNode {
 111 public:
 112   AddVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {}
 113   virtual uint Opcode() const;
 114 };
 115 
 116 //------------------------------AddVDNode--------------------------------------
 117 // Vector add double
 118 class AddVDNode : public VectorNode {
 119 public:
 120   AddVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {}
 121   virtual uint Opcode() const;
 122 };
 123 
 124 //------------------------------ReductionNode------------------------------------
 125 // Perform reduction of a vector
 126 class ReductionNode : public Node {
 127  public:
 128   ReductionNode(Node *ctrl, Node* in1, Node* in2) : Node(ctrl, in1, in2) {}
 129 
 130   static ReductionNode* make(int opc, Node *ctrl, Node* in1, Node* in2, BasicType bt);
 131   static int  opcode(int opc, BasicType bt);
 132   static bool implemented(int opc, uint vlen, BasicType bt);
 133 };
 134 
 135 //------------------------------AddReductionVINode--------------------------------------
 136 // Vector add int as a reduction
 137 class AddReductionVINode : public ReductionNode {
 138 public:
 139   AddReductionVINode(Node * ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}
 140   virtual uint Opcode() const;
 141   virtual const Type* bottom_type() const { return TypeInt::INT; }
 142   virtual uint ideal_reg() const { return Op_RegI; }
 143 };
 144 
 145 //------------------------------AddReductionVLNode--------------------------------------
 146 // Vector add long as a reduction
 147 class AddReductionVLNode : public ReductionNode {
 148 public:
 149   AddReductionVLNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}
 150   virtual uint Opcode() const;
 151   virtual const Type* bottom_type() const { return TypeLong::LONG; }
 152   virtual uint ideal_reg() const { return Op_RegL; }
 153 };
 154 
 155 //------------------------------AddReductionVFNode--------------------------------------
 156 // Vector add float as a reduction
 157 class AddReductionVFNode : public ReductionNode {
 158 public:
 159   AddReductionVFNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}
 160   virtual uint Opcode() const;
 161   virtual const Type* bottom_type() const { return Type::FLOAT; }
 162   virtual uint ideal_reg() const { return Op_RegF; }
 163 };
 164 
 165 //------------------------------AddReductionVDNode--------------------------------------
 166 // Vector add double as a reduction
 167 class AddReductionVDNode : public ReductionNode {
 168 public:
 169   AddReductionVDNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}
 170   virtual uint Opcode() const;
 171   virtual const Type* bottom_type() const { return Type::DOUBLE; }
 172   virtual uint ideal_reg() const { return Op_RegD; }
 173 };
 174 
 175 //------------------------------SubVBNode--------------------------------------
 176 // Vector subtract byte
 177 class SubVBNode : public VectorNode {
 178  public:
 179   SubVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 180   virtual uint Opcode() const;
 181 };
 182 
 183 //------------------------------SubVSNode--------------------------------------
 184 // Vector subtract short
 185 class SubVSNode : public VectorNode {
 186  public:
 187   SubVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 188   virtual uint Opcode() const;
 189 };
 190 
 191 //------------------------------SubVINode--------------------------------------
 192 // Vector subtract int
 193 class SubVINode : public VectorNode {
 194  public:
 195   SubVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 196   virtual uint Opcode() const;
 197 };
 198 
 199 //------------------------------SubVLNode--------------------------------------
 200 // Vector subtract long
 201 class SubVLNode : public VectorNode {
 202  public:
 203   SubVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 204   virtual uint Opcode() const;
 205 };
 206 
 207 //------------------------------SubVFNode--------------------------------------
 208 // Vector subtract float
 209 class SubVFNode : public VectorNode {
 210  public:
 211   SubVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 212   virtual uint Opcode() const;
 213 };
 214 
 215 //------------------------------SubVDNode--------------------------------------
 216 // Vector subtract double
 217 class SubVDNode : public VectorNode {
 218  public:
 219   SubVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 220   virtual uint Opcode() const;
 221 };
 222 
 223 //------------------------------MulVSNode--------------------------------------
 224 // Vector multiply short
 225 class MulVSNode : public VectorNode {
 226  public:
 227   MulVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 228   virtual uint Opcode() const;
 229 };
 230 
 231 //------------------------------MulVINode--------------------------------------
 232 // Vector multiply int
 233 class MulVINode : public VectorNode {
 234  public:
 235   MulVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 236   virtual uint Opcode() const;
 237 };
 238 
 239 //------------------------------MulVLNode--------------------------------------
 240 // Vector multiply long
 241 class MulVLNode : public VectorNode {
 242 public:
 243   MulVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {}
 244   virtual uint Opcode() const;
 245 };
 246 
 247 //------------------------------MulVFNode--------------------------------------
 248 // Vector multiply float
 249 class MulVFNode : public VectorNode {
 250 public:
 251   MulVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {}
 252   virtual uint Opcode() const;
 253 };
 254 
 255 //------------------------------MulVDNode--------------------------------------
 256 // Vector multiply double
 257 class MulVDNode : public VectorNode {
 258 public:
 259   MulVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {}
 260   virtual uint Opcode() const;
 261 };
 262 
 263 //------------------------------CMoveVDNode--------------------------------------
 264 // Vector multiply double
 265 class CMoveVDNode : public VectorNode {
 266 public:
 267   CMoveVDNode(Node* in1, Node* in2, Node* in3, const TypeVect* vt) : VectorNode(in1, in2, in3, vt) {}
 268   virtual uint Opcode() const;
 269 };
 270 
 271 //------------------------------MulReductionVINode--------------------------------------
 272 // Vector multiply int as a reduction
 273 class MulReductionVINode : public ReductionNode {
 274 public:
 275   MulReductionVINode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}
 276   virtual uint Opcode() const;
 277   virtual const Type* bottom_type() const { return TypeInt::INT; }
 278   virtual uint ideal_reg() const { return Op_RegI; }
 279 };
 280 
 281 //------------------------------MulReductionVLNode--------------------------------------
 282 // Vector multiply int as a reduction
 283 class MulReductionVLNode : public ReductionNode {
 284 public:
 285   MulReductionVLNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}
 286   virtual uint Opcode() const;
 287   virtual const Type* bottom_type() const { return TypeLong::LONG; }
 288   virtual uint ideal_reg() const { return Op_RegI; }
 289 };
 290 
 291 //------------------------------MulReductionVFNode--------------------------------------
 292 // Vector multiply float as a reduction
 293 class MulReductionVFNode : public ReductionNode {
 294 public:
 295   MulReductionVFNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}
 296   virtual uint Opcode() const;
 297   virtual const Type* bottom_type() const { return Type::FLOAT; }
 298   virtual uint ideal_reg() const { return Op_RegF; }
 299 };
 300 
 301 //------------------------------MulReductionVDNode--------------------------------------
 302 // Vector multiply double as a reduction
 303 class MulReductionVDNode : public ReductionNode {
 304 public:
 305   MulReductionVDNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}
 306   virtual uint Opcode() const;
 307   virtual const Type* bottom_type() const { return Type::DOUBLE; }
 308   virtual uint ideal_reg() const { return Op_RegD; }
 309 };
 310 
 311 //------------------------------DivVFNode--------------------------------------
 312 // Vector divide float
 313 class DivVFNode : public VectorNode {
 314  public:
 315   DivVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 316   virtual uint Opcode() const;
 317 };
 318 
 319 //------------------------------DivVDNode--------------------------------------
 320 // Vector Divide double
 321 class DivVDNode : public VectorNode {
 322  public:
 323   DivVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 324   virtual uint Opcode() const;
 325 };
 326 
 327 //------------------------------AbsVFNode--------------------------------------
 328 // Vector Abs float
 329 class AbsVFNode : public VectorNode {
 330  public:
 331   AbsVFNode(Node* in, const TypeVect* vt) : VectorNode(in,vt) {}
 332   virtual uint Opcode() const;
 333 };
 334 
 335 //------------------------------AbsVDNode--------------------------------------
 336 // Vector Abs double
 337 class AbsVDNode : public VectorNode {
 338  public:
 339   AbsVDNode(Node* in, const TypeVect* vt) : VectorNode(in,vt) {}
 340   virtual uint Opcode() const;
 341 };
 342 
 343 //------------------------------NegVFNode--------------------------------------
 344 // Vector Neg float
 345 class NegVFNode : public VectorNode {
 346  public:
 347   NegVFNode(Node* in, const TypeVect* vt) : VectorNode(in,vt) {}
 348   virtual uint Opcode() const;
 349 };
 350 
 351 //------------------------------NegVDNode--------------------------------------
 352 // Vector Neg double
 353 class NegVDNode : public VectorNode {
 354  public:
 355   NegVDNode(Node* in, const TypeVect* vt) : VectorNode(in,vt) {}
 356   virtual uint Opcode() const;
 357 };
 358 
 359 //------------------------------SqrtVDNode--------------------------------------
 360 // Vector Sqrt double
 361 class SqrtVDNode : public VectorNode {
 362  public:
 363   SqrtVDNode(Node* in, const TypeVect* vt) : VectorNode(in,vt) {}
 364   virtual uint Opcode() const;
 365 };
 366 
 367 //------------------------------LShiftVBNode-----------------------------------
 368 // Vector left shift bytes
 369 class LShiftVBNode : public VectorNode {
 370  public:
 371   LShiftVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 372   virtual uint Opcode() const;
 373 };
 374 
 375 //------------------------------LShiftVSNode-----------------------------------
 376 // Vector left shift shorts
 377 class LShiftVSNode : public VectorNode {
 378  public:
 379   LShiftVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 380   virtual uint Opcode() const;
 381 };
 382 
 383 //------------------------------LShiftVINode-----------------------------------
 384 // Vector left shift ints
 385 class LShiftVINode : public VectorNode {
 386  public:
 387   LShiftVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 388   virtual uint Opcode() const;
 389 };
 390 
 391 //------------------------------LShiftVLNode-----------------------------------
 392 // Vector left shift longs
 393 class LShiftVLNode : public VectorNode {
 394  public:
 395   LShiftVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 396   virtual uint Opcode() const;
 397 };
 398 
 399 //------------------------------RShiftVBNode-----------------------------------
 400 // Vector right arithmetic (signed) shift bytes
 401 class RShiftVBNode : public VectorNode {
 402  public:
 403   RShiftVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 404   virtual uint Opcode() const;
 405 };
 406 
 407 //------------------------------RShiftVSNode-----------------------------------
 408 // Vector right arithmetic (signed) shift shorts
 409 class RShiftVSNode : public VectorNode {
 410  public:
 411   RShiftVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 412   virtual uint Opcode() const;
 413 };
 414 
 415 //------------------------------RShiftVINode-----------------------------------
 416 // Vector right arithmetic (signed) shift ints
 417 class RShiftVINode : public VectorNode {
 418  public:
 419   RShiftVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 420   virtual uint Opcode() const;
 421 };
 422 
 423 //------------------------------RShiftVLNode-----------------------------------
 424 // Vector right arithmetic (signed) shift longs
 425 class RShiftVLNode : public VectorNode {
 426  public:
 427   RShiftVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 428   virtual uint Opcode() const;
 429 };
 430 
 431 //------------------------------URShiftVBNode----------------------------------
 432 // Vector right logical (unsigned) shift bytes
 433 class URShiftVBNode : public VectorNode {
 434  public:
 435   URShiftVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 436   virtual uint Opcode() const;
 437 };
 438 
 439 //------------------------------URShiftVSNode----------------------------------
 440 // Vector right logical (unsigned) shift shorts
 441 class URShiftVSNode : public VectorNode {
 442  public:
 443   URShiftVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 444   virtual uint Opcode() const;
 445 };
 446 
 447 //------------------------------URShiftVINode----------------------------------
 448 // Vector right logical (unsigned) shift ints
 449 class URShiftVINode : public VectorNode {
 450  public:
 451   URShiftVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 452   virtual uint Opcode() const;
 453 };
 454 
 455 //------------------------------URShiftVLNode----------------------------------
 456 // Vector right logical (unsigned) shift longs
 457 class URShiftVLNode : public VectorNode {
 458  public:
 459   URShiftVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 460   virtual uint Opcode() const;
 461 };
 462 
 463 //------------------------------LShiftCntVNode---------------------------------
 464 // Vector left shift count
 465 class LShiftCntVNode : public VectorNode {
 466  public:
 467   LShiftCntVNode(Node* cnt, const TypeVect* vt) : VectorNode(cnt,vt) {}
 468   virtual uint Opcode() const;
 469   virtual uint ideal_reg() const { return Matcher::vector_shift_count_ideal_reg(vect_type()->length_in_bytes()); }
 470 };
 471 
 472 //------------------------------RShiftCntVNode---------------------------------
 473 // Vector right shift count
 474 class RShiftCntVNode : public VectorNode {
 475  public:
 476   RShiftCntVNode(Node* cnt, const TypeVect* vt) : VectorNode(cnt,vt) {}
 477   virtual uint Opcode() const;
 478   virtual uint ideal_reg() const { return Matcher::vector_shift_count_ideal_reg(vect_type()->length_in_bytes()); }
 479 };
 480 
 481 
 482 //------------------------------AndVNode---------------------------------------
 483 // Vector and integer
 484 class AndVNode : public VectorNode {
 485  public:
 486   AndVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 487   virtual uint Opcode() const;
 488 };
 489 
 490 //------------------------------OrVNode---------------------------------------
 491 // Vector or integer
 492 class OrVNode : public VectorNode {
 493  public:
 494   OrVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 495   virtual uint Opcode() const;
 496 };
 497 
 498 //------------------------------XorVNode---------------------------------------
 499 // Vector xor integer
 500 class XorVNode : public VectorNode {
 501  public:
 502   XorVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 503   virtual uint Opcode() const;
 504 };
 505 
 506 //================================= M E M O R Y ===============================
 507 
 508 //------------------------------LoadVectorNode---------------------------------
 509 // Load Vector from memory
 510 class LoadVectorNode : public LoadNode {
 511  public:
 512   LoadVectorNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeVect* vt, ControlDependency control_dependency = LoadNode::DependsOnlyOnTest)
 513     : LoadNode(c, mem, adr, at, vt, MemNode::unordered, control_dependency) {
 514     init_class_id(Class_LoadVector);
 515   }
 516 
 517   const TypeVect* vect_type() const { return type()->is_vect(); }
 518   uint length() const { return vect_type()->length(); } // Vector length
 519 
 520   virtual uint Opcode() const;
 521 
 522   virtual uint ideal_reg() const  { return Matcher::vector_ideal_reg(memory_size()); }
 523   virtual BasicType memory_type() const { return T_VOID; }
 524   virtual int memory_size() const { return vect_type()->length_in_bytes(); }
 525 
 526   virtual uint store_Opcode() const { return Op_StoreVector; }
 527 
 528   static LoadVectorNode* make(int opc, Node* ctl, Node* mem,
 529                               Node* adr, const TypePtr* atyp,
 530                               uint vlen, BasicType bt,
 531                               ControlDependency control_dependency = LoadNode::DependsOnlyOnTest);
 532   uint element_size(void) { return type2aelembytes(vect_type()->element_basic_type()); }
 533 };
 534 
 535 //------------------------------StoreVectorNode--------------------------------
 536 // Store Vector to memory
 537 class StoreVectorNode : public StoreNode {
 538  public:
 539   StoreVectorNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
 540     : StoreNode(c, mem, adr, at, val, MemNode::unordered) {
 541     assert(val->is_Vector() || val->is_LoadVector(), "sanity");
 542     init_class_id(Class_StoreVector);
 543   }
 544 
 545   const TypeVect* vect_type() const { return in(MemNode::ValueIn)->bottom_type()->is_vect(); }
 546   uint length() const { return vect_type()->length(); } // Vector length
 547 
 548   virtual uint Opcode() const;
 549 
 550   virtual uint ideal_reg() const  { return Matcher::vector_ideal_reg(memory_size()); }
 551   virtual BasicType memory_type() const { return T_VOID; }
 552   virtual int memory_size() const { return vect_type()->length_in_bytes(); }
 553 
 554   static StoreVectorNode* make(int opc, Node* ctl, Node* mem,
 555                                Node* adr, const TypePtr* atyp, Node* val,
 556                                uint vlen);
 557 
 558   uint element_size(void) { return type2aelembytes(vect_type()->element_basic_type()); }
 559 };
 560 
 561 
 562 //=========================Promote_Scalar_to_Vector============================
 563 
 564 //------------------------------ReplicateBNode---------------------------------
 565 // Replicate byte scalar to be vector
 566 class ReplicateBNode : public VectorNode {
 567  public:
 568   ReplicateBNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
 569   virtual uint Opcode() const;
 570 };
 571 
 572 //------------------------------ReplicateSNode---------------------------------
 573 // Replicate short scalar to be vector
 574 class ReplicateSNode : public VectorNode {
 575  public:
 576   ReplicateSNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
 577   virtual uint Opcode() const;
 578 };
 579 
 580 //------------------------------ReplicateINode---------------------------------
 581 // Replicate int scalar to be vector
 582 class ReplicateINode : public VectorNode {
 583  public:
 584   ReplicateINode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
 585   virtual uint Opcode() const;
 586 };
 587 
 588 //------------------------------ReplicateLNode---------------------------------
 589 // Replicate long scalar to be vector
 590 class ReplicateLNode : public VectorNode {
 591  public:
 592   ReplicateLNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
 593   virtual uint Opcode() const;
 594 };
 595 
 596 //------------------------------ReplicateFNode---------------------------------
 597 // Replicate float scalar to be vector
 598 class ReplicateFNode : public VectorNode {
 599  public:
 600   ReplicateFNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
 601   virtual uint Opcode() const;
 602 };
 603 
 604 //------------------------------ReplicateDNode---------------------------------
 605 // Replicate double scalar to be vector
 606 class ReplicateDNode : public VectorNode {
 607  public:
 608   ReplicateDNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
 609   virtual uint Opcode() const;
 610 };
 611 
 612 //========================Pack_Scalars_into_a_Vector===========================
 613 
 614 //------------------------------PackNode---------------------------------------
 615 // Pack parent class (not for code generation).
 616 class PackNode : public VectorNode {
 617  public:
 618   PackNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
 619   PackNode(Node* in1, Node* n2, const TypeVect* vt) : VectorNode(in1, n2, vt) {}
 620   virtual uint Opcode() const;
 621 
 622   void add_opd(Node* n) {
 623     add_req(n);
 624   }
 625 
 626   // Create a binary tree form for Packs. [lo, hi) (half-open) range
 627   PackNode* binary_tree_pack(int lo, int hi);
 628 
 629   static PackNode* make(Node* s, uint vlen, BasicType bt);
 630 };
 631 
 632 //------------------------------PackBNode--------------------------------------
 633 // Pack byte scalars into vector
 634 class PackBNode : public PackNode {
 635  public:
 636   PackBNode(Node* in1, const TypeVect* vt)  : PackNode(in1, vt) {}
 637   virtual uint Opcode() const;
 638 };
 639 
 640 //------------------------------PackSNode--------------------------------------
 641 // Pack short scalars into a vector
 642 class PackSNode : public PackNode {
 643  public:
 644   PackSNode(Node* in1, const TypeVect* vt)  : PackNode(in1, vt) {}
 645   PackSNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
 646   virtual uint Opcode() const;
 647 };
 648 
 649 //------------------------------PackINode--------------------------------------
 650 // Pack integer scalars into a vector
 651 class PackINode : public PackNode {
 652  public:
 653   PackINode(Node* in1, const TypeVect* vt)  : PackNode(in1, vt) {}
 654   PackINode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
 655   virtual uint Opcode() const;
 656 };
 657 
 658 //------------------------------PackLNode--------------------------------------
 659 // Pack long scalars into a vector
 660 class PackLNode : public PackNode {
 661  public:
 662   PackLNode(Node* in1, const TypeVect* vt)  : PackNode(in1, vt) {}
 663   PackLNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
 664   virtual uint Opcode() const;
 665 };
 666 
 667 //------------------------------Pack2LNode-------------------------------------
 668 // Pack 2 long scalars into a vector
 669 class Pack2LNode : public PackNode {
 670  public:
 671   Pack2LNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
 672   virtual uint Opcode() const;
 673 };
 674 
 675 //------------------------------PackFNode--------------------------------------
 676 // Pack float scalars into vector
 677 class PackFNode : public PackNode {
 678  public:
 679   PackFNode(Node* in1, const TypeVect* vt)  : PackNode(in1, vt) {}
 680   PackFNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
 681   virtual uint Opcode() const;
 682 };
 683 
 684 //------------------------------PackDNode--------------------------------------
 685 // Pack double scalars into a vector
 686 class PackDNode : public PackNode {
 687  public:
 688   PackDNode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {}
 689   PackDNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
 690   virtual uint Opcode() const;
 691 };
 692 
 693 //------------------------------Pack2DNode-------------------------------------
 694 // Pack 2 double scalars into a vector
 695 class Pack2DNode : public PackNode {
 696  public:
 697   Pack2DNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
 698   virtual uint Opcode() const;
 699 };
 700 
 701 
 702 //========================Extract_Scalar_from_Vector===========================
 703 
 704 //------------------------------ExtractNode------------------------------------
 705 // Extract a scalar from a vector at position "pos"
 706 class ExtractNode : public Node {
 707  public:
 708   ExtractNode(Node* src, ConINode* pos) : Node(NULL, src, (Node*)pos) {
 709     assert(in(2)->get_int() >= 0, "positive constants");
 710   }
 711   virtual uint Opcode() const;
 712   uint  pos() const { return in(2)->get_int(); }
 713 
 714   static Node* make(Node* v, uint position, BasicType bt);
 715 };
 716 
 717 //------------------------------ExtractBNode-----------------------------------
 718 // Extract a byte from a vector at position "pos"
 719 class ExtractBNode : public ExtractNode {
 720  public:
 721   ExtractBNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
 722   virtual uint Opcode() const;
 723   virtual const Type *bottom_type() const { return TypeInt::INT; }
 724   virtual uint ideal_reg() const { return Op_RegI; }
 725 };
 726 
 727 //------------------------------ExtractUBNode----------------------------------
 728 // Extract a boolean from a vector at position "pos"
 729 class ExtractUBNode : public ExtractNode {
 730  public:
 731   ExtractUBNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
 732   virtual uint Opcode() const;
 733   virtual const Type *bottom_type() const { return TypeInt::INT; }
 734   virtual uint ideal_reg() const { return Op_RegI; }
 735 };
 736 
 737 //------------------------------ExtractCNode-----------------------------------
 738 // Extract a char from a vector at position "pos"
 739 class ExtractCNode : public ExtractNode {
 740  public:
 741   ExtractCNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
 742   virtual uint Opcode() const;
 743   virtual const Type *bottom_type() const { return TypeInt::INT; }
 744   virtual uint ideal_reg() const { return Op_RegI; }
 745 };
 746 
 747 //------------------------------ExtractSNode-----------------------------------
 748 // Extract a short from a vector at position "pos"
 749 class ExtractSNode : public ExtractNode {
 750  public:
 751   ExtractSNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
 752   virtual uint Opcode() const;
 753   virtual const Type *bottom_type() const { return TypeInt::INT; }
 754   virtual uint ideal_reg() const { return Op_RegI; }
 755 };
 756 
 757 //------------------------------ExtractINode-----------------------------------
 758 // Extract an int from a vector at position "pos"
 759 class ExtractINode : public ExtractNode {
 760  public:
 761   ExtractINode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
 762   virtual uint Opcode() const;
 763   virtual const Type *bottom_type() const { return TypeInt::INT; }
 764   virtual uint ideal_reg() const { return Op_RegI; }
 765 };
 766 
 767 //------------------------------ExtractLNode-----------------------------------
 768 // Extract a long from a vector at position "pos"
 769 class ExtractLNode : public ExtractNode {
 770  public:
 771   ExtractLNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
 772   virtual uint Opcode() const;
 773   virtual const Type *bottom_type() const { return TypeLong::LONG; }
 774   virtual uint ideal_reg() const { return Op_RegL; }
 775 };
 776 
 777 //------------------------------ExtractFNode-----------------------------------
 778 // Extract a float from a vector at position "pos"
 779 class ExtractFNode : public ExtractNode {
 780  public:
 781   ExtractFNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
 782   virtual uint Opcode() const;
 783   virtual const Type *bottom_type() const { return Type::FLOAT; }
 784   virtual uint ideal_reg() const { return Op_RegF; }
 785 };
 786 
 787 //------------------------------ExtractDNode-----------------------------------
 788 // Extract a double from a vector at position "pos"
 789 class ExtractDNode : public ExtractNode {
 790  public:
 791   ExtractDNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
 792   virtual uint Opcode() const;
 793   virtual const Type *bottom_type() const { return Type::DOUBLE; }
 794   virtual uint ideal_reg() const { return Op_RegD; }
 795 };
 796 
 797 //------------------------------SetVectMaskINode-------------------------------
 798 // Provide a mask for a vector predicate machine
 799 class SetVectMaskINode : public Node {
 800 public:
 801   SetVectMaskINode(Node *c, Node *in1) : Node(c, in1) {}
 802   virtual uint Opcode() const;
 803   const Type *bottom_type() const { return TypeInt::INT; }
 804   virtual uint ideal_reg() const { return Op_RegI; }
 805   virtual const Type *Value(PhaseGVN *phase) const { return TypeInt::INT; }
 806 };
 807 
 808 #endif // SHARE_VM_OPTO_VECTORNODE_HPP
< prev index next >