1 /*
   2  * Copyright (c) 2007, 2010, 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 #ifndef SHARE_VM_OPTO_VECTORNODE_HPP
  25 #define SHARE_VM_OPTO_VECTORNODE_HPP
  26 
  27 #include "opto/matcher.hpp"
  28 #include "opto/memnode.hpp"
  29 #include "opto/node.hpp"
  30 #include "opto/opcodes.hpp"
  31 
  32 //------------------------------VectorNode--------------------------------------
  33 // Vector Operation
  34 class VectorNode : public Node {
  35   virtual uint size_of() const { return sizeof(*this); }
  36  protected:
  37   uint _length; // vector length
  38   virtual BasicType elt_basic_type() const = 0; // Vector element basic type
  39 
  40   static const Type* vect_type(BasicType elt_bt, uint len);
  41   static const Type* vect_type(const Type* elt_type, uint len) {
  42     return vect_type(elt_type->array_element_basic_type(), len);
  43   }
  44 
  45  public:
  46   friend class VectorLoadNode;  // For vect_type
  47   friend class VectorStoreNode; // ditto.
  48 
  49   VectorNode(Node* n1, uint vlen) : Node(NULL, n1), _length(vlen) {
  50     init_class_id(Class_Vector);

  51   }
  52   VectorNode(Node* n1, Node* n2, uint vlen) : Node(NULL, n1, n2), _length(vlen) {
  53     init_class_id(Class_Vector);


  54   }
  55   virtual int Opcode() const;
  56 
  57   uint length() const { return _length; } // Vector length

  58 
  59   static uint max_vlen(BasicType bt) { // max vector length
  60     return (uint)(Matcher::vector_width_in_bytes() / type2aelembytes(bt));
  61   }
  62 
  63   // Element and vector type
  64   const Type* elt_type()  const { return Type::get_const_basic_type(elt_basic_type()); }
  65   const Type* vect_type() const { return vect_type(elt_basic_type(), length()); }
  66 
  67   virtual const Type *bottom_type() const { return vect_type(); }
  68   virtual uint        ideal_reg()   const { return Matcher::vector_ideal_reg(); }
  69 
  70   // Vector opcode from scalar opcode
  71   static int opcode(int sopc, uint vlen, const Type* opd_t);
  72 
  73   static VectorNode* scalar2vector(Compile* C, Node* s, uint vlen, const Type* opd_t);
  74 
  75   static VectorNode* make(Compile* C, int sopc, Node* n1, Node* n2, uint vlen, const Type* elt_t);
  76 



  77 };
  78 
  79 //===========================Vector=ALU=Operations====================================
  80 
  81 //------------------------------AddVBNode---------------------------------------
  82 // Vector add byte
  83 class AddVBNode : public VectorNode {
  84  protected:
  85   virtual BasicType elt_basic_type() const { return T_BYTE; }
  86  public:
  87   AddVBNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
  88   virtual int Opcode() const;
  89 };
  90 
  91 //------------------------------AddVCNode---------------------------------------
  92 // Vector add char
  93 class AddVCNode : public VectorNode {
  94  protected:
  95   virtual BasicType elt_basic_type() const { return T_CHAR; }
  96  public:
  97   AddVCNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
  98   virtual int Opcode() const;
  99 };
 100 
 101 //------------------------------AddVSNode---------------------------------------
 102 // Vector add short
 103 class AddVSNode : public VectorNode {
 104  protected:
 105   virtual BasicType elt_basic_type() const { return T_SHORT; }
 106  public:
 107   AddVSNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
 108   virtual int Opcode() const;
 109 };
 110 
 111 //------------------------------AddVINode---------------------------------------
 112 // Vector add int
 113 class AddVINode : public VectorNode {
 114  protected:
 115   virtual BasicType elt_basic_type() const { return T_INT; }
 116  public:
 117   AddVINode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
 118   virtual int Opcode() const;
 119 };
 120 
 121 //------------------------------AddVLNode---------------------------------------
 122 // Vector add long
 123 class AddVLNode : public VectorNode {
 124  protected:
 125   virtual BasicType elt_basic_type() const { return T_LONG; }
 126  public:
 127   AddVLNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
 128   virtual int Opcode() const;
 129 };
 130 
 131 //------------------------------AddVFNode---------------------------------------
 132 // Vector add float
 133 class AddVFNode : public VectorNode {
 134  protected:
 135   virtual BasicType elt_basic_type() const { return T_FLOAT; }
 136  public:
 137   AddVFNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
 138   virtual int Opcode() const;
 139 };
 140 
 141 //------------------------------AddVDNode---------------------------------------
 142 // Vector add double
 143 class AddVDNode : public VectorNode {
 144  protected:
 145   virtual BasicType elt_basic_type() const { return T_DOUBLE; }
 146  public:
 147   AddVDNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
 148   virtual int Opcode() const;
 149 };
 150 
 151 //------------------------------SubVBNode---------------------------------------
 152 // Vector subtract byte
 153 class SubVBNode : public VectorNode {
 154  protected:
 155   virtual BasicType elt_basic_type() const { return T_BYTE; }
 156  public:
 157   SubVBNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
 158   virtual int Opcode() const;
 159 };
 160 
 161 //------------------------------SubVCNode---------------------------------------
 162 // Vector subtract char
 163 class SubVCNode : public VectorNode {
 164  protected:
 165   virtual BasicType elt_basic_type() const { return T_CHAR; }
 166  public:
 167   SubVCNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
 168   virtual int Opcode() const;
 169 };
 170 
 171 //------------------------------SubVSNode---------------------------------------
 172 // Vector subtract short
 173 class SubVSNode : public VectorNode {
 174  protected:
 175   virtual BasicType elt_basic_type() const { return T_SHORT; }
 176  public:
 177   SubVSNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
 178   virtual int Opcode() const;
 179 };
 180 
 181 //------------------------------SubVINode---------------------------------------
 182 // Vector subtract int
 183 class SubVINode : public VectorNode {
 184  protected:
 185   virtual BasicType elt_basic_type() const { return T_INT; }
 186  public:
 187   SubVINode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
 188   virtual int Opcode() const;
 189 };
 190 
 191 //------------------------------SubVLNode---------------------------------------
 192 // Vector subtract long
 193 class SubVLNode : public VectorNode {
 194  protected:
 195   virtual BasicType elt_basic_type() const { return T_LONG; }
 196  public:
 197   SubVLNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
 198   virtual int Opcode() const;
 199 };
 200 
 201 //------------------------------SubVFNode---------------------------------------
 202 // Vector subtract float
 203 class SubVFNode : public VectorNode {
 204  protected:
 205   virtual BasicType elt_basic_type() const { return T_FLOAT; }
 206  public:
 207   SubVFNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
 208   virtual int Opcode() const;
 209 };
 210 
 211 //------------------------------SubVDNode---------------------------------------
 212 // Vector subtract double
 213 class SubVDNode : public VectorNode {
 214  protected:
 215   virtual BasicType elt_basic_type() const { return T_DOUBLE; }
 216  public:
 217   SubVDNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
 218   virtual int Opcode() const;
 219 };
 220 
 221 //------------------------------MulVFNode---------------------------------------
 222 // Vector multiply float
 223 class MulVFNode : public VectorNode {
 224  protected:
 225   virtual BasicType elt_basic_type() const { return T_FLOAT; }
 226  public:
 227   MulVFNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
 228   virtual int Opcode() const;
 229 };
 230 
 231 //------------------------------MulVDNode---------------------------------------
 232 // Vector multiply double
 233 class MulVDNode : public VectorNode {
 234  protected:
 235   virtual BasicType elt_basic_type() const { return T_DOUBLE; }
 236  public:
 237   MulVDNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
 238   virtual int Opcode() const;
 239 };
 240 
 241 //------------------------------DivVFNode---------------------------------------
 242 // Vector divide float
 243 class DivVFNode : public VectorNode {
 244  protected:
 245   virtual BasicType elt_basic_type() const { return T_FLOAT; }
 246  public:
 247   DivVFNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
 248   virtual int Opcode() const;
 249 };
 250 
 251 //------------------------------DivVDNode---------------------------------------
 252 // Vector Divide double
 253 class DivVDNode : public VectorNode {
 254  protected:
 255   virtual BasicType elt_basic_type() const { return T_DOUBLE; }
 256  public:
 257   DivVDNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
 258   virtual int Opcode() const;
 259 };
 260 
 261 //------------------------------LShiftVBNode---------------------------------------
 262 // Vector lshift byte
 263 class LShiftVBNode : public VectorNode {
 264  protected:
 265   virtual BasicType elt_basic_type() const { return T_BYTE; }
 266  public:
 267   LShiftVBNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
 268   virtual int Opcode() const;
 269 };
 270 
 271 //------------------------------LShiftVCNode---------------------------------------
 272 // Vector lshift chars
 273 class LShiftVCNode : public VectorNode {
 274  protected:
 275   virtual BasicType elt_basic_type() const { return T_CHAR; }
 276  public:
 277   LShiftVCNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
 278   virtual int Opcode() const;
 279 };
 280 
 281 //------------------------------LShiftVSNode---------------------------------------
 282 // Vector lshift shorts
 283 class LShiftVSNode : public VectorNode {
 284  protected:
 285   virtual BasicType elt_basic_type() const { return T_SHORT; }
 286  public:
 287   LShiftVSNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
 288   virtual int Opcode() const;
 289 };
 290 
 291 //------------------------------LShiftVINode---------------------------------------
 292 // Vector lshift ints
 293 class LShiftVINode : public VectorNode {
 294  protected:
 295   virtual BasicType elt_basic_type() const { return T_INT; }
 296  public:
 297   LShiftVINode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
 298   virtual int Opcode() const;
 299 };
 300 
 301 //------------------------------URShiftVBNode---------------------------------------
 302 // Vector urshift bytes
 303 class URShiftVBNode : public VectorNode {
 304  protected:
 305   virtual BasicType elt_basic_type() const { return T_BYTE; }
 306  public:
 307   URShiftVBNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
 308   virtual int Opcode() const;
 309 };
 310 
 311 //------------------------------URShiftVCNode---------------------------------------
 312 // Vector urshift char
 313 class URShiftVCNode : public VectorNode {
 314  protected:
 315   virtual BasicType elt_basic_type() const { return T_SHORT; }
 316  public:
 317   URShiftVCNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
 318   virtual int Opcode() const;
 319 };
 320 
 321 //------------------------------URShiftVSNode---------------------------------------
 322 // Vector urshift shorts
 323 class URShiftVSNode : public VectorNode {
 324  protected:
 325   virtual BasicType elt_basic_type() const { return T_SHORT; }
 326  public:
 327   URShiftVSNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
 328   virtual int Opcode() const;
 329 };
 330 
 331 //------------------------------URShiftVINode---------------------------------------
 332 // Vector urshift ints
 333 class URShiftVINode : public VectorNode {
 334  protected:
 335   virtual BasicType elt_basic_type() const { return T_INT; }
 336  public:
 337   URShiftVINode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
 338   virtual int Opcode() const;
 339 };
 340 
 341 //------------------------------AndVNode---------------------------------------
 342 // Vector and
 343 class AndVNode : public VectorNode {
 344  protected:
 345   BasicType _bt;
 346   virtual BasicType elt_basic_type() const { return _bt; }
 347  public:
 348   AndVNode(Node* in1, Node* in2, uint vlen, BasicType bt) : VectorNode(in1,in2,vlen), _bt(bt) {}
 349   virtual int Opcode() const;
 350 };
 351 
 352 //------------------------------OrVNode---------------------------------------
 353 // Vector or
 354 class OrVNode : public VectorNode {
 355  protected:
 356   BasicType _bt;
 357   virtual BasicType elt_basic_type() const { return _bt; }
 358  public:
 359   OrVNode(Node* in1, Node* in2, uint vlen, BasicType bt) : VectorNode(in1,in2,vlen), _bt(bt) {}
 360   virtual int Opcode() const;
 361 };
 362 
 363 //------------------------------XorVNode---------------------------------------
 364 // Vector xor
 365 class XorVNode : public VectorNode {
 366  protected:
 367   BasicType _bt;
 368   virtual BasicType elt_basic_type() const { return _bt; }
 369  public:
 370   XorVNode(Node* in1, Node* in2, uint vlen, BasicType bt) : VectorNode(in1,in2,vlen), _bt(bt) {}
 371   virtual int Opcode() const;
 372 };
 373 
 374 //================================= M E M O R Y ==================================
 375 
 376 
 377 //------------------------------VectorLoadNode--------------------------------------
 378 // Vector Load from memory
 379 class VectorLoadNode : public LoadNode {
 380   virtual uint size_of() const { return sizeof(*this); }
 381 
 382  protected:
 383   virtual BasicType elt_basic_type()  const = 0; // Vector element basic type
 384   // For use in constructor
 385   static const Type* vect_type(const Type* elt_type, uint len) {
 386     return VectorNode::vect_type(elt_type, len);
 387   }
 388 
 389  public:
 390   VectorLoadNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const Type *rt)
 391     : LoadNode(c,mem,adr,at,rt) {
 392     init_class_id(Class_VectorLoad);
 393   }
 394   virtual int Opcode() const;
 395 
 396   virtual uint  length() const = 0; // Vector length

 397 
 398   // Element and vector type
 399   const Type* elt_type()  const { return Type::get_const_basic_type(elt_basic_type()); }
 400   const Type* vect_type() const { return VectorNode::vect_type(elt_basic_type(), length()); }
 401 
 402   virtual uint ideal_reg() const  { return Matcher::vector_ideal_reg(); }
 403   virtual BasicType memory_type() const { return T_VOID; }
 404   virtual int memory_size() const { return length()*type2aelembytes(elt_basic_type()); }
 405 
 406   // Vector opcode from scalar opcode
 407   static int opcode(int sopc, uint vlen);
 408 
 409   static VectorLoadNode* make(Compile* C, int opc, Node* ctl, Node* mem,
 410                               Node* adr, const TypePtr* atyp, uint vlen);
 411 };
 412 
 413 //------------------------------Load16BNode--------------------------------------
 414 // Vector load of 16 bytes (8bits signed) from memory
 415 class Load16BNode : public VectorLoadNode {
 416  protected:
 417   virtual BasicType elt_basic_type() const { return T_BYTE; }
 418  public:
 419   Load16BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::BYTE)
 420     : VectorLoadNode(c,mem,adr,at,vect_type(ti,16)) {}
 421   virtual int Opcode() const;
 422   virtual int store_Opcode() const { return Op_Store16B; }
 423   virtual uint length() const { return 16; }
 424 };
 425 
 426 //------------------------------Load8BNode--------------------------------------
 427 // Vector load of 8 bytes (8bits signed) from memory
 428 class Load8BNode : public VectorLoadNode {
 429  protected:
 430   virtual BasicType elt_basic_type() const { return T_BYTE; }
 431  public:
 432   Load8BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::BYTE)
 433     : VectorLoadNode(c,mem,adr,at,vect_type(ti,8)) {}
 434   virtual int Opcode() const;
 435   virtual int store_Opcode() const { return Op_Store8B; }
 436   virtual uint length() const { return 8; }
 437 };
 438 
 439 //------------------------------Load4BNode--------------------------------------
 440 // Vector load of 4 bytes (8bits signed) from memory
 441 class Load4BNode : public VectorLoadNode {
 442  protected:
 443   virtual BasicType elt_basic_type() const { return T_BYTE; }
 444  public:
 445   Load4BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::BYTE)
 446     : VectorLoadNode(c,mem,adr,at,vect_type(ti,4)) {}
 447   virtual int Opcode() const;
 448   virtual int store_Opcode() const { return Op_Store4B; }
 449   virtual uint length() const { return 4; }
 450 };
 451 
 452 //------------------------------Load8CNode--------------------------------------
 453 // Vector load of 8 chars (16bits unsigned) from memory
 454 class Load8CNode : public VectorLoadNode {
 455  protected:
 456   virtual BasicType elt_basic_type() const { return T_CHAR; }
 457  public:
 458   Load8CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::CHAR)
 459     : VectorLoadNode(c,mem,adr,at,vect_type(ti,8)) {}
 460   virtual int Opcode() const;
 461   virtual int store_Opcode() const { return Op_Store8C; }
 462   virtual uint length() const { return 8; }
 463 };
 464 
 465 //------------------------------Load4CNode--------------------------------------
 466 // Vector load of 4 chars (16bits unsigned) from memory
 467 class Load4CNode : public VectorLoadNode {
 468  protected:
 469   virtual BasicType elt_basic_type() const { return T_CHAR; }
 470  public:
 471   Load4CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::CHAR)
 472     : VectorLoadNode(c,mem,adr,at,vect_type(ti,4)) {}
 473   virtual int Opcode() const;
 474   virtual int store_Opcode() const { return Op_Store4C; }
 475   virtual uint length() const { return 4; }
 476 };
 477 
 478 //------------------------------Load2CNode--------------------------------------
 479 // Vector load of 2 chars (16bits unsigned) from memory
 480 class Load2CNode : public VectorLoadNode {
 481  protected:
 482   virtual BasicType elt_basic_type() const { return T_CHAR; }
 483  public:
 484   Load2CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::CHAR)
 485     : VectorLoadNode(c,mem,adr,at,vect_type(ti,2)) {}
 486   virtual int Opcode() const;
 487   virtual int store_Opcode() const { return Op_Store2C; }
 488   virtual uint length() const { return 2; }
 489 };
 490 
 491 //------------------------------Load8SNode--------------------------------------
 492 // Vector load of 8 shorts (16bits signed) from memory
 493 class Load8SNode : public VectorLoadNode {
 494  protected:
 495   virtual BasicType elt_basic_type() const { return T_SHORT; }
 496  public:
 497   Load8SNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::SHORT)
 498     : VectorLoadNode(c,mem,adr,at,vect_type(ti,8)) {}
 499   virtual int Opcode() const;
 500   virtual int store_Opcode() const { return Op_Store8C; }
 501   virtual uint length() const { return 8; }
 502 };
 503 
 504 //------------------------------Load4SNode--------------------------------------
 505 // Vector load of 4 shorts (16bits signed) from memory
 506 class Load4SNode : public VectorLoadNode {
 507  protected:
 508   virtual BasicType elt_basic_type() const { return T_SHORT; }
 509  public:
 510   Load4SNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::SHORT)
 511     : VectorLoadNode(c,mem,adr,at,vect_type(ti,4)) {}
 512   virtual int Opcode() const;
 513   virtual int store_Opcode() const { return Op_Store4C; }
 514   virtual uint length() const { return 4; }
 515 };
 516 
 517 //------------------------------Load2SNode--------------------------------------
 518 // Vector load of 2 shorts (16bits signed) from memory
 519 class Load2SNode : public VectorLoadNode {
 520  protected:
 521   virtual BasicType elt_basic_type() const { return T_SHORT; }
 522  public:
 523   Load2SNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::SHORT)
 524     : VectorLoadNode(c,mem,adr,at,vect_type(ti,2)) {}
 525   virtual int Opcode() const;
 526   virtual int store_Opcode() const { return Op_Store2C; }
 527   virtual uint length() const { return 2; }
 528 };
 529 
 530 //------------------------------Load4INode--------------------------------------
 531 // Vector load of 4 integers (32bits signed) from memory
 532 class Load4INode : public VectorLoadNode {
 533  protected:
 534   virtual BasicType elt_basic_type() const { return T_INT; }
 535  public:
 536   Load4INode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::INT)
 537     : VectorLoadNode(c,mem,adr,at,vect_type(ti,4)) {}
 538   virtual int Opcode() const;
 539   virtual int store_Opcode() const { return Op_Store4I; }
 540   virtual uint length() const { return 4; }
 541 };
 542 
 543 //------------------------------Load2INode--------------------------------------
 544 // Vector load of 2 integers (32bits signed) from memory
 545 class Load2INode : public VectorLoadNode {
 546  protected:
 547   virtual BasicType elt_basic_type() const { return T_INT; }
 548  public:
 549   Load2INode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::INT)
 550     : VectorLoadNode(c,mem,adr,at,vect_type(ti,2)) {}
 551   virtual int Opcode() const;
 552   virtual int store_Opcode() const { return Op_Store2I; }
 553   virtual uint length() const { return 2; }
 554 };
 555 
 556 //------------------------------Load2LNode--------------------------------------
 557 // Vector load of 2 longs (64bits signed) from memory
 558 class Load2LNode : public VectorLoadNode {
 559  protected:
 560   virtual BasicType elt_basic_type() const { return T_LONG; }
 561  public:
 562   Load2LNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeLong *tl = TypeLong::LONG)
 563     : VectorLoadNode(c,mem,adr,at,vect_type(tl,2)) {}
 564   virtual int Opcode() const;
 565   virtual int store_Opcode() const { return Op_Store2L; }
 566   virtual uint length() const { return 2; }
 567 };
 568 
 569 //------------------------------Load4FNode--------------------------------------
 570 // Vector load of 4 floats (32bits) from memory
 571 class Load4FNode : public VectorLoadNode {
 572  protected:
 573   virtual BasicType elt_basic_type() const { return T_FLOAT; }
 574  public:
 575   Load4FNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const Type *t = Type::FLOAT)
 576     : VectorLoadNode(c,mem,adr,at,vect_type(t,4)) {}
 577   virtual int Opcode() const;
 578   virtual int store_Opcode() const { return Op_Store4F; }
 579   virtual uint length() const { return 4; }
 580 };
 581 
 582 //------------------------------Load2FNode--------------------------------------
 583 // Vector load of 2 floats (32bits) from memory
 584 class Load2FNode : public VectorLoadNode {
 585  protected:
 586   virtual BasicType elt_basic_type() const { return T_FLOAT; }
 587  public:
 588   Load2FNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const Type *t = Type::FLOAT)
 589     : VectorLoadNode(c,mem,adr,at,vect_type(t,2)) {}
 590   virtual int Opcode() const;
 591   virtual int store_Opcode() const { return Op_Store2F; }
 592   virtual uint length() const { return 2; }
 593 };
 594 
 595 //------------------------------Load2DNode--------------------------------------
 596 // Vector load of 2 doubles (64bits) from memory
 597 class Load2DNode : public VectorLoadNode {
 598  protected:
 599   virtual BasicType elt_basic_type() const { return T_DOUBLE; }
 600  public:
 601   Load2DNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const Type *t = Type::DOUBLE)
 602     : VectorLoadNode(c,mem,adr,at,vect_type(t,2)) {}
 603   virtual int Opcode() const;
 604   virtual int store_Opcode() const { return Op_Store2D; }
 605   virtual uint length() const { return 2; }
 606 };
 607 
 608 
 609 //------------------------------VectorStoreNode--------------------------------------
 610 // Vector Store to memory
 611 class VectorStoreNode : public StoreNode {
 612   virtual uint size_of() const { return sizeof(*this); }
 613 
 614  protected:
 615   virtual BasicType elt_basic_type()  const = 0; // Vector element basic type
 616 
 617  public:
 618   VectorStoreNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
 619     : StoreNode(c,mem,adr,at,val) {
 620     init_class_id(Class_VectorStore);
 621   }
 622   virtual int Opcode() const;
 623 
 624   virtual uint  length() const = 0; // Vector length
 625 
 626   // Element and vector type
 627   const Type* elt_type()  const { return Type::get_const_basic_type(elt_basic_type()); }
 628   const Type* vect_type() const { return VectorNode::vect_type(elt_basic_type(), length()); }
 629 
 630   virtual uint ideal_reg() const  { return Matcher::vector_ideal_reg(); }
 631   virtual BasicType memory_type() const { return T_VOID; }
 632   virtual int memory_size() const { return length()*type2aelembytes(elt_basic_type()); }
 633 
 634   // Vector opcode from scalar opcode
 635   static int opcode(int sopc, uint vlen);
 636 
 637   static VectorStoreNode* make(Compile* C, int opc, Node* ctl, Node* mem,
 638                                Node* adr, const TypePtr* atyp, Node* val,
 639                                uint vlen);
 640 };
 641 
 642 //------------------------------Store16BNode--------------------------------------
 643 // Vector store of 16 bytes (8bits signed) to memory
 644 class Store16BNode : public VectorStoreNode {
 645  protected:
 646   virtual BasicType elt_basic_type() const { return T_BYTE; }
 647  public:
 648   Store16BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
 649     : VectorStoreNode(c,mem,adr,at,val) {}
 650   virtual int Opcode() const;
 651   virtual uint length() const { return 16; }
 652 };
 653 
 654 //------------------------------Store8BNode--------------------------------------
 655 // Vector store of 8 bytes (8bits signed) to memory
 656 class Store8BNode : public VectorStoreNode {
 657  protected:
 658   virtual BasicType elt_basic_type() const { return T_BYTE; }
 659  public:
 660   Store8BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
 661     : VectorStoreNode(c,mem,adr,at,val) {}
 662   virtual int Opcode() const;
 663   virtual uint length() const { return 8; }
 664 };
 665 
 666 //------------------------------Store4BNode--------------------------------------
 667 // Vector store of 4 bytes (8bits signed) to memory
 668 class Store4BNode : public VectorStoreNode {
 669  protected:
 670   virtual BasicType elt_basic_type() const { return T_BYTE; }
 671  public:
 672   Store4BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
 673     : VectorStoreNode(c,mem,adr,at,val) {}
 674   virtual int Opcode() const;
 675   virtual uint length() const { return 4; }
 676 };
 677 
 678 //------------------------------Store8CNode--------------------------------------
 679 // Vector store of 8 chars (16bits signed/unsigned) to memory
 680 class Store8CNode : public VectorStoreNode {
 681  protected:
 682   virtual BasicType elt_basic_type() const { return T_CHAR; }
 683  public:
 684   Store8CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
 685     : VectorStoreNode(c,mem,adr,at,val) {}
 686   virtual int Opcode() const;
 687   virtual uint length() const { return 8; }
 688 };
 689 
 690 //------------------------------Store4CNode--------------------------------------
 691 // Vector store of 4 chars (16bits signed/unsigned) to memory
 692 class Store4CNode : public VectorStoreNode {
 693  protected:
 694   virtual BasicType elt_basic_type() const { return T_CHAR; }
 695  public:
 696   Store4CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
 697     : VectorStoreNode(c,mem,adr,at,val) {}
 698   virtual int Opcode() const;
 699   virtual uint length() const { return 4; }
 700 };
 701 
 702 //------------------------------Store2CNode--------------------------------------
 703 // Vector store of 2 chars (16bits signed/unsigned) to memory
 704 class Store2CNode : public VectorStoreNode {
 705  protected:
 706   virtual BasicType elt_basic_type() const { return T_CHAR; }
 707  public:
 708   Store2CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
 709     : VectorStoreNode(c,mem,adr,at,val) {}
 710   virtual int Opcode() const;
 711   virtual uint length() const { return 2; }
 712 };
 713 
 714 //------------------------------Store4INode--------------------------------------
 715 // Vector store of 4 integers (32bits signed) to memory
 716 class Store4INode : public VectorStoreNode {
 717  protected:
 718   virtual BasicType elt_basic_type() const { return T_INT; }
 719  public:
 720   Store4INode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
 721     : VectorStoreNode(c,mem,adr,at,val) {}
 722   virtual int Opcode() const;
 723   virtual uint length() const { return 4; }
 724 };
 725 
 726 //------------------------------Store2INode--------------------------------------
 727 // Vector store of 2 integers (32bits signed) to memory
 728 class Store2INode : public VectorStoreNode {
 729  protected:
 730   virtual BasicType elt_basic_type() const { return T_INT; }
 731  public:
 732   Store2INode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
 733     : VectorStoreNode(c,mem,adr,at,val) {}
 734   virtual int Opcode() const;
 735   virtual uint length() const { return 2; }
 736 };
 737 
 738 //------------------------------Store2LNode--------------------------------------
 739 // Vector store of 2 longs (64bits signed) to memory
 740 class Store2LNode : public VectorStoreNode {
 741  protected:
 742   virtual BasicType elt_basic_type() const { return T_LONG; }
 743  public:
 744   Store2LNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
 745     : VectorStoreNode(c,mem,adr,at,val) {}
 746   virtual int Opcode() const;
 747   virtual uint length() const { return 2; }
 748 };
 749 
 750 //------------------------------Store4FNode--------------------------------------
 751 // Vector store of 4 floats (32bits) to memory
 752 class Store4FNode : public VectorStoreNode {
 753  protected:
 754   virtual BasicType elt_basic_type() const { return T_FLOAT; }
 755  public:
 756   Store4FNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
 757     : VectorStoreNode(c,mem,adr,at,val) {}
 758   virtual int Opcode() const;
 759   virtual uint length() const { return 4; }
 760 };
 761 
 762 //------------------------------Store2FNode--------------------------------------
 763 // Vector store of 2 floats (32bits) to memory
 764 class Store2FNode : public VectorStoreNode {
 765  protected:
 766   virtual BasicType elt_basic_type() const { return T_FLOAT; }
 767  public:
 768   Store2FNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
 769     : VectorStoreNode(c,mem,adr,at,val) {}
 770   virtual int Opcode() const;
 771   virtual uint length() const { return 2; }
 772 };
 773 
 774 //------------------------------Store2DNode--------------------------------------
 775 // Vector store of 2 doubles (64bits) to memory
 776 class Store2DNode : public VectorStoreNode {
 777  protected:
 778   virtual BasicType elt_basic_type() const { return T_DOUBLE; }
 779  public:
 780   Store2DNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
 781     : VectorStoreNode(c,mem,adr,at,val) {}
 782   virtual int Opcode() const;
 783   virtual uint length() const { return 2; }
 784 };
 785 
 786 //=========================Promote_Scalar_to_Vector====================================
 787 
 788 //------------------------------Replicate16BNode---------------------------------------
 789 // Replicate byte scalar to be vector of 16 bytes
 790 class Replicate16BNode : public VectorNode {
 791  protected:
 792   virtual BasicType elt_basic_type() const { return T_BYTE; }
 793  public:
 794   Replicate16BNode(Node* in1) : VectorNode(in1, 16) {}
 795   virtual int Opcode() const;
 796 };
 797 
 798 //------------------------------Replicate8BNode---------------------------------------
 799 // Replicate byte scalar to be vector of 8 bytes
 800 class Replicate8BNode : public VectorNode {
 801  protected:
 802   virtual BasicType elt_basic_type() const { return T_BYTE; }
 803  public:
 804   Replicate8BNode(Node* in1) : VectorNode(in1, 8) {}
 805   virtual int Opcode() const;
 806 };
 807 
 808 //------------------------------Replicate4BNode---------------------------------------
 809 // Replicate byte scalar to be vector of 4 bytes
 810 class Replicate4BNode : public VectorNode {
 811  protected:
 812   virtual BasicType elt_basic_type() const { return T_BYTE; }
 813  public:
 814   Replicate4BNode(Node* in1) : VectorNode(in1, 4) {}
 815   virtual int Opcode() const;
 816 };
 817 
 818 //------------------------------Replicate8CNode---------------------------------------
 819 // Replicate char scalar to be vector of 8 chars
 820 class Replicate8CNode : public VectorNode {
 821  protected:
 822   virtual BasicType elt_basic_type() const { return T_CHAR; }
 823  public:
 824   Replicate8CNode(Node* in1) : VectorNode(in1, 8) {}
 825   virtual int Opcode() const;
 826 };
 827 
 828 //------------------------------Replicate4CNode---------------------------------------
 829 // Replicate char scalar to be vector of 4 chars
 830 class Replicate4CNode : public VectorNode {
 831  protected:
 832   virtual BasicType elt_basic_type() const { return T_CHAR; }
 833  public:
 834   Replicate4CNode(Node* in1) : VectorNode(in1, 4) {}
 835   virtual int Opcode() const;
 836 };
 837 
 838 //------------------------------Replicate2CNode---------------------------------------
 839 // Replicate char scalar to be vector of 2 chars
 840 class Replicate2CNode : public VectorNode {
 841  protected:
 842   virtual BasicType elt_basic_type() const { return T_CHAR; }
 843  public:
 844   Replicate2CNode(Node* in1) : VectorNode(in1, 2) {}
 845   virtual int Opcode() const;
 846 };
 847 
 848 //------------------------------Replicate8SNode---------------------------------------
 849 // Replicate short scalar to be vector of 8 shorts
 850 class Replicate8SNode : public VectorNode {
 851  protected:
 852   virtual BasicType elt_basic_type() const { return T_SHORT; }
 853  public:
 854   Replicate8SNode(Node* in1) : VectorNode(in1, 8) {}
 855   virtual int Opcode() const;
 856 };
 857 
 858 //------------------------------Replicate4SNode---------------------------------------
 859 // Replicate short scalar to be vector of 4 shorts
 860 class Replicate4SNode : public VectorNode {
 861  protected:
 862   virtual BasicType elt_basic_type() const { return T_SHORT; }
 863  public:
 864   Replicate4SNode(Node* in1) : VectorNode(in1, 4) {}
 865   virtual int Opcode() const;
 866 };
 867 
 868 //------------------------------Replicate2SNode---------------------------------------
 869 // Replicate short scalar to be vector of 2 shorts
 870 class Replicate2SNode : public VectorNode {
 871  protected:
 872   virtual BasicType elt_basic_type() const { return T_SHORT; }
 873  public:
 874   Replicate2SNode(Node* in1) : VectorNode(in1, 2) {}
 875   virtual int Opcode() const;
 876 };
 877 
 878 //------------------------------Replicate4INode---------------------------------------
 879 // Replicate int scalar to be vector of 4 ints
 880 class Replicate4INode : public VectorNode {
 881  protected:
 882   virtual BasicType elt_basic_type() const { return T_INT; }
 883  public:
 884   Replicate4INode(Node* in1) : VectorNode(in1, 4) {}
 885   virtual int Opcode() const;
 886 };
 887 
 888 //------------------------------Replicate2INode---------------------------------------
 889 // Replicate int scalar to be vector of 2 ints
 890 class Replicate2INode : public VectorNode {
 891  protected:
 892   virtual BasicType elt_basic_type() const { return T_INT; }
 893  public:
 894   Replicate2INode(Node* in1) : VectorNode(in1, 2) {}
 895   virtual int Opcode() const;
 896 };
 897 
 898 //------------------------------Replicate2LNode---------------------------------------
 899 // Replicate long scalar to be vector of 2 longs
 900 class Replicate2LNode : public VectorNode {
 901  protected:
 902   virtual BasicType elt_basic_type() const { return T_LONG; }
 903  public:
 904   Replicate2LNode(Node* in1) : VectorNode(in1, 2) {}
 905   virtual int Opcode() const;
 906 };
 907 
 908 //------------------------------Replicate4FNode---------------------------------------
 909 // Replicate float scalar to be vector of 4 floats
 910 class Replicate4FNode : public VectorNode {
 911  protected:
 912   virtual BasicType elt_basic_type() const { return T_FLOAT; }
 913  public:
 914   Replicate4FNode(Node* in1) : VectorNode(in1, 4) {}
 915   virtual int Opcode() const;
 916 };
 917 
 918 //------------------------------Replicate2FNode---------------------------------------
 919 // Replicate float scalar to be vector of 2 floats
 920 class Replicate2FNode : public VectorNode {
 921  protected:
 922   virtual BasicType elt_basic_type() const { return T_FLOAT; }
 923  public:
 924   Replicate2FNode(Node* in1) : VectorNode(in1, 2) {}
 925   virtual int Opcode() const;
 926 };
 927 
 928 //------------------------------Replicate2DNode---------------------------------------
 929 // Replicate double scalar to be vector of 2 doubles
 930 class Replicate2DNode : public VectorNode {
 931  protected:
 932   virtual BasicType elt_basic_type() const { return T_DOUBLE; }
 933  public:
 934   Replicate2DNode(Node* in1) : VectorNode(in1, 2) {}
 935   virtual int Opcode() const;
 936 };
 937 
 938 //========================Pack_Scalars_into_a_Vector==============================
 939 
 940 //------------------------------PackNode---------------------------------------
 941 // Pack parent class (not for code generation).
 942 class PackNode : public VectorNode {
 943  public:
 944   PackNode(Node* in1)  : VectorNode(in1, 1) {}
 945   PackNode(Node* in1, Node* n2)  : VectorNode(in1, n2, 2) {}
 946   virtual int Opcode() const;
 947 
 948   void add_opd(Node* n) {
 949     add_req(n);
 950     _length++;
 951     assert(_length == req() - 1, "vector length matches edge count");
 952   }
 953 
 954   // Create a binary tree form for Packs. [lo, hi) (half-open) range
 955   Node* binaryTreePack(Compile* C, int lo, int hi);
 956 
 957   static PackNode* make(Compile* C, Node* s, const Type* elt_t);
 958 };
 959 
 960 //------------------------------PackBNode---------------------------------------
 961 // Pack byte scalars into vector
 962 class PackBNode : public PackNode {
 963  protected:
 964   virtual BasicType elt_basic_type() const { return T_BYTE; }
 965  public:
 966   PackBNode(Node* in1)  : PackNode(in1) {}
 967   virtual int Opcode() const;
 968 };
 969 
 970 //------------------------------PackCNode---------------------------------------
 971 // Pack char scalars into vector
 972 class PackCNode : public PackNode {
 973  protected:
 974   virtual BasicType elt_basic_type() const { return T_CHAR; }
 975  public:
 976   PackCNode(Node* in1)  : PackNode(in1) {}
 977   virtual int Opcode() const;
 978 };
 979 
 980 //------------------------------PackSNode---------------------------------------
 981 // Pack short scalars into a vector
 982 class PackSNode : public PackNode {
 983  protected:
 984   virtual BasicType elt_basic_type() const { return T_SHORT; }
 985  public:
 986   PackSNode(Node* in1)  : PackNode(in1) {}

 987   virtual int Opcode() const;
 988 };
 989 
 990 //------------------------------PackINode---------------------------------------
 991 // Pack integer scalars into a vector
 992 class PackINode : public PackNode {
 993  protected:
 994   virtual BasicType elt_basic_type() const { return T_INT; }
 995  public:
 996   PackINode(Node* in1)  : PackNode(in1) {}
 997   PackINode(Node* in1, Node* in2) : PackNode(in1, in2) {}
 998   virtual int Opcode() const;
 999 };
1000 
1001 //------------------------------PackLNode---------------------------------------
1002 // Pack long scalars into a vector
1003 class PackLNode : public PackNode {
1004  protected:
1005   virtual BasicType elt_basic_type() const { return T_LONG; }
1006  public:
1007   PackLNode(Node* in1)  : PackNode(in1) {}
1008   PackLNode(Node* in1, Node* in2) : PackNode(in1, in2) {}
1009   virtual int Opcode() const;
1010 };
1011 








1012 //------------------------------PackFNode---------------------------------------
1013 // Pack float scalars into vector
1014 class PackFNode : public PackNode {
1015  protected:
1016   virtual BasicType elt_basic_type() const { return T_FLOAT; }
1017  public:
1018   PackFNode(Node* in1)  : PackNode(in1) {}
1019   PackFNode(Node* in1, Node* in2) : PackNode(in1, in2) {}
1020   virtual int Opcode() const;
1021 };
1022 
1023 //------------------------------PackDNode---------------------------------------
1024 // Pack double scalars into a vector
1025 class PackDNode : public PackNode {
1026  protected:
1027   virtual BasicType elt_basic_type() const { return T_DOUBLE; }
1028  public:
1029   PackDNode(Node* in1)  : PackNode(in1) {}
1030   PackDNode(Node* in1, Node* in2) : PackNode(in1, in2) {}
1031   virtual int Opcode() const;
1032 };
1033 
1034 // The Pack2xN nodes assist code generation.  They are created from
1035 // Pack4C, etc. nodes in final_graph_reshape in the form of a
1036 // balanced, binary tree.
1037 
1038 //------------------------------Pack2x1BNode-----------------------------------------
1039 // Pack 2 1-byte integers into vector of 2 bytes
1040 class Pack2x1BNode : public PackNode {
1041  protected:
1042   virtual BasicType elt_basic_type() const { return T_BYTE; }
1043  public:
1044   Pack2x1BNode(Node *in1, Node* in2) : PackNode(in1, in2) {}
1045   virtual int Opcode() const;
1046   virtual uint ideal_reg() const { return Op_RegI; }
1047 };
1048 
1049 //------------------------------Pack2x2BNode---------------------------------------
1050 // Pack 2 2-byte integers into vector of 4 bytes
1051 class Pack2x2BNode : public PackNode {
1052  protected:
1053   virtual BasicType elt_basic_type() const { return T_CHAR; }
1054  public:
1055   Pack2x2BNode(Node *in1, Node* in2) : PackNode(in1, in2) {}
1056   virtual int Opcode() const;
1057   virtual uint ideal_reg() const { return Op_RegI; }
1058 };
1059 
1060 //========================Extract_Scalar_from_Vector===============================
1061 
1062 //------------------------------ExtractNode---------------------------------------
1063 // Extract a scalar from a vector at position "pos"
1064 class ExtractNode : public Node {
1065  public:
1066   ExtractNode(Node* src, ConINode* pos) : Node(NULL, src, (Node*)pos) {
1067     assert(in(2)->get_int() >= 0, "positive constants");
1068   }
1069   virtual int Opcode() const;
1070   uint  pos() const { return in(2)->get_int(); }
1071 
1072   static Node* make(Compile* C, Node* v, uint position, const Type* opd_t);
1073 };
1074 
1075 //------------------------------ExtractBNode---------------------------------------
1076 // Extract a byte from a vector at position "pos"
1077 class ExtractBNode : public ExtractNode {
1078  public:
1079   ExtractBNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
1080   virtual int Opcode() const;
1081   virtual const Type *bottom_type() const { return TypeInt::INT; }
1082   virtual uint ideal_reg() const { return Op_RegI; }
1083 };
1084 
1085 //------------------------------ExtractCNode---------------------------------------
1086 // Extract a char from a vector at position "pos"
1087 class ExtractCNode : public ExtractNode {
1088  public:
1089   ExtractCNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
1090   virtual int Opcode() const;
1091   virtual const Type *bottom_type() const { return TypeInt::INT; }
1092   virtual uint ideal_reg() const { return Op_RegI; }

   1 /*
   2  * Copyright (c) 2007, 2012, 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 #ifndef SHARE_VM_OPTO_VECTORNODE_HPP
  25 #define SHARE_VM_OPTO_VECTORNODE_HPP
  26 
  27 #include "opto/matcher.hpp"
  28 #include "opto/memnode.hpp"
  29 #include "opto/node.hpp"
  30 #include "opto/opcodes.hpp"
  31 
  32 //------------------------------VectorNode--------------------------------------
  33 // Vector Operation
  34 class VectorNode : public TypeNode {










  35  public:


  36 
  37   VectorNode(Node* n1, const TypeVect* vt) : TypeNode(vt, 2) {
  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   const TypeVect* vect_type() const { return type()->is_vect(); }
  48   uint length() const { return vect_type()->length(); } // Vector length
  49 
  50   virtual int Opcode() const;


  51 
  52   virtual uint ideal_reg() const { return Matcher::vector_ideal_reg(vect_type()->length_in_bytes()); }


  53 






  54   static VectorNode* scalar2vector(Compile* C, Node* s, uint vlen, const Type* opd_t);
  55 
  56   static VectorNode* make(Compile* C, int opc, Node* n1, Node* n2, uint vlen, BasicType bt);
  57 
  58   static int  opcode(int opc, uint vlen, BasicType bt);
  59   static bool implemented(int opc, uint vlen, BasicType bt);
  60 
  61 };
  62 
  63 //===========================Vector=ALU=Operations====================================
  64 
  65 //------------------------------AddVBNode---------------------------------------
  66 // Vector add byte
  67 class AddVBNode : public VectorNode {


  68  public:
  69   AddVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
  70   virtual int Opcode() const;
  71 };
  72 
  73 //------------------------------AddVCNode---------------------------------------
  74 // Vector add char
  75 class AddVCNode : public VectorNode {


  76  public:
  77   AddVCNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
  78   virtual int Opcode() const;
  79 };
  80 
  81 //------------------------------AddVSNode---------------------------------------
  82 // Vector add short
  83 class AddVSNode : public VectorNode {


  84  public:
  85   AddVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
  86   virtual int Opcode() const;
  87 };
  88 
  89 //------------------------------AddVINode---------------------------------------
  90 // Vector add int
  91 class AddVINode : public VectorNode {


  92  public:
  93   AddVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
  94   virtual int Opcode() const;
  95 };
  96 
  97 //------------------------------AddVLNode---------------------------------------
  98 // Vector add long
  99 class AddVLNode : public VectorNode {


 100  public:
 101   AddVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 102   virtual int Opcode() const;
 103 };
 104 
 105 //------------------------------AddVFNode---------------------------------------
 106 // Vector add float
 107 class AddVFNode : public VectorNode {


 108  public:
 109   AddVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 110   virtual int Opcode() const;
 111 };
 112 
 113 //------------------------------AddVDNode---------------------------------------
 114 // Vector add double
 115 class AddVDNode : public VectorNode {


 116  public:
 117   AddVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 118   virtual int Opcode() const;
 119 };
 120 
 121 //------------------------------SubVBNode---------------------------------------
 122 // Vector subtract byte
 123 class SubVBNode : public VectorNode {


 124  public:
 125   SubVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 126   virtual int Opcode() const;
 127 };
 128 
 129 //------------------------------SubVCNode---------------------------------------
 130 // Vector subtract char
 131 class SubVCNode : public VectorNode {


 132  public:
 133   SubVCNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 134   virtual int Opcode() const;
 135 };
 136 
 137 //------------------------------SubVSNode---------------------------------------
 138 // Vector subtract short
 139 class SubVSNode : public VectorNode {


 140  public:
 141   SubVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 142   virtual int Opcode() const;
 143 };
 144 
 145 //------------------------------SubVINode---------------------------------------
 146 // Vector subtract int
 147 class SubVINode : public VectorNode {


 148  public:
 149   SubVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 150   virtual int Opcode() const;
 151 };
 152 
 153 //------------------------------SubVLNode---------------------------------------
 154 // Vector subtract long
 155 class SubVLNode : public VectorNode {


 156  public:
 157   SubVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 158   virtual int Opcode() const;
 159 };
 160 
 161 //------------------------------SubVFNode---------------------------------------
 162 // Vector subtract float
 163 class SubVFNode : public VectorNode {


 164  public:
 165   SubVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 166   virtual int Opcode() const;
 167 };
 168 
 169 //------------------------------SubVDNode---------------------------------------
 170 // Vector subtract double
 171 class SubVDNode : public VectorNode {


 172  public:
 173   SubVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 174   virtual int Opcode() const;
 175 };
 176 
 177 //------------------------------MulVFNode---------------------------------------
 178 // Vector multiply float
 179 class MulVFNode : public VectorNode {


 180  public:
 181   MulVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 182   virtual int Opcode() const;
 183 };
 184 
 185 //------------------------------MulVDNode---------------------------------------
 186 // Vector multiply double
 187 class MulVDNode : public VectorNode {


 188  public:
 189   MulVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 190   virtual int Opcode() const;
 191 };
 192 
 193 //------------------------------DivVFNode---------------------------------------
 194 // Vector divide float
 195 class DivVFNode : public VectorNode {


 196  public:
 197   DivVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 198   virtual int Opcode() const;
 199 };
 200 
 201 //------------------------------DivVDNode---------------------------------------
 202 // Vector Divide double
 203 class DivVDNode : public VectorNode {


 204  public:
 205   DivVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 206   virtual int Opcode() const;
 207 };
 208 
 209 //------------------------------LShiftVBNode---------------------------------------
 210 // Vector lshift byte
 211 class LShiftVBNode : public VectorNode {


 212  public:
 213   LShiftVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 214   virtual int Opcode() const;
 215 };
 216 
 217 //------------------------------LShiftVCNode---------------------------------------
 218 // Vector lshift chars
 219 class LShiftVCNode : public VectorNode {


 220  public:
 221   LShiftVCNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 222   virtual int Opcode() const;
 223 };
 224 
 225 //------------------------------LShiftVSNode---------------------------------------
 226 // Vector lshift shorts
 227 class LShiftVSNode : public VectorNode {


 228  public:
 229   LShiftVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 230   virtual int Opcode() const;
 231 };
 232 
 233 //------------------------------LShiftVINode---------------------------------------
 234 // Vector lshift ints
 235 class LShiftVINode : public VectorNode {


 236  public:
 237   LShiftVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 238   virtual int Opcode() const;
 239 };
 240 
 241 //------------------------------URShiftVBNode---------------------------------------
 242 // Vector urshift bytes
 243 class RShiftVBNode : public VectorNode {


 244  public:
 245   RShiftVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 246   virtual int Opcode() const;
 247 };
 248 
 249 //------------------------------URShiftVCNode---------------------------------------
 250 // Vector urshift char
 251 class RShiftVCNode : public VectorNode {


 252  public:
 253   RShiftVCNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 254   virtual int Opcode() const;
 255 };
 256 
 257 //------------------------------URShiftVSNode---------------------------------------
 258 // Vector urshift shorts
 259 class RShiftVSNode : public VectorNode {


 260  public:
 261   RShiftVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 262   virtual int Opcode() const;
 263 };
 264 
 265 //------------------------------URShiftVINode---------------------------------------
 266 // Vector urshift ints
 267 class RShiftVINode : public VectorNode {


 268  public:
 269   RShiftVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 270   virtual int Opcode() const;
 271 };
 272 
 273 //------------------------------AndVNode---------------------------------------
 274 // Vector and
 275 class AndVNode : public VectorNode {



 276  public:
 277   AndVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 278   virtual int Opcode() const;
 279 };
 280 
 281 //------------------------------OrVNode---------------------------------------
 282 // Vector or
 283 class OrVNode : public VectorNode {



 284  public:
 285   OrVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 286   virtual int Opcode() const;
 287 };
 288 
 289 //------------------------------XorVNode---------------------------------------
 290 // Vector xor
 291 class XorVNode : public VectorNode {



 292  public:
 293   XorVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
 294   virtual int Opcode() const;
 295 };
 296 
 297 //================================= M E M O R Y ===============================
 298 
 299 //------------------------------LoadVectorNode---------------------------------
 300 // Load Vector from memory
 301 class LoadVectorNode : public LoadNode {










 302  public:
 303   LoadVectorNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeVect* vt)
 304     : LoadNode(c, mem, adr, at, vt) {
 305     init_class_id(Class_LoadVector);
 306   }

 307 
 308   const TypeVect* vect_type() const { return type()->is_vect(); }
 309   uint length() const { return vect_type()->length(); } // Vector length
 310 
 311   virtual int Opcode() const;


 312 
 313   virtual uint ideal_reg() const  { return Matcher::vector_ideal_reg(memory_size()); }
 314   virtual BasicType memory_type() const { return T_VOID; }
 315   virtual int memory_size() const { return vect_type()->length_in_bytes(); }
 316 
 317   virtual int store_Opcode() const { return Op_StoreVector; }

 318 
 319   static LoadVectorNode* make(Compile* C, int opc, Node* ctl, Node* mem,
 320                               Node* adr, const TypePtr* atyp, uint vlen, BasicType bt);
 321 };
 322 
 323 //------------------------------StoreVectorNode--------------------------------
 324 // Store Vector to memory
 325 class StoreVectorNode : public StoreNode {


 326  public:
 327   StoreVectorNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
 328     : StoreNode(c, mem, adr, at, val) {
 329     assert(val->is_Vector() || val->is_LoadVector(), "sanity");
 330     init_class_id(Class_StoreVector);
 331   }

 332 
 333   const TypeVect* vect_type() const { return in(MemNode::ValueIn)->bottom_type()->is_vect(); }
 334   uint length() const { return vect_type()->length(); } // Vector length










 335 








 336   virtual int Opcode() const;



 337 
 338   virtual uint ideal_reg() const  { return Matcher::vector_ideal_reg(memory_size()); }


















































































































































































 339   virtual BasicType memory_type() const { return T_VOID; }
 340   virtual int memory_size() const { return vect_type()->length_in_bytes(); }
 341 
 342   static StoreVectorNode* make(Compile* C, int opc, Node* ctl, Node* mem,



 343                                Node* adr, const TypePtr* atyp, Node* val,
 344                                uint vlen);
 345 };
 346 











 347 
 348 //=========================Promote_Scalar_to_Vector============================










 349 
 350 //------------------------------ReplicateBNode---------------------------------
 351 // Replicate byte scalar to be vector
 352 class ReplicateBNode : public VectorNode {


 353  public:
 354   ReplicateBNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}

 355   virtual int Opcode() const;

 356 };
 357 
 358 //------------------------------ReplicateCNode---------------------------------
 359 // Replicate char scalar to be vector
 360 class ReplicateCNode : public VectorNode {


 361  public:
 362   ReplicateCNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}

 363   virtual int Opcode() const;

 364 };
 365 
 366 //------------------------------ReplicateSNode---------------------------------
 367 // Replicate short scalar to be vector
 368 class ReplicateSNode : public VectorNode {


 369  public:
 370   ReplicateSNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}

 371   virtual int Opcode() const;

 372 };
 373 
 374 //------------------------------ReplicateINode---------------------------------
 375 // Replicate int scalar to be vector
 376 class ReplicateINode : public VectorNode {


 377  public:
 378   ReplicateINode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}

 379   virtual int Opcode() const;

 380 };
 381 
 382 //------------------------------ReplicateLNode---------------------------------
 383 // Replicate long scalar to be vector
 384 class ReplicateLNode : public VectorNode {


 385  public:
 386   ReplicateLNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}

 387   virtual int Opcode() const;

 388 };
 389 
 390 //------------------------------ReplicateFNode---------------------------------
 391 // Replicate float scalar to be vector
 392 class ReplicateFNode : public VectorNode {


 393  public:
 394   ReplicateFNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}

 395   virtual int Opcode() const;

 396 };
 397 
 398 //------------------------------ReplicateDNode---------------------------------
 399 // Replicate double scalar to be vector
 400 class ReplicateDNode : public VectorNode {


 401  public:
 402   ReplicateDNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}

 403   virtual int Opcode() const;

 404 };
 405 
 406 //========================Pack_Scalars_into_a_Vector===========================










 407 


















































































































































































 408 //------------------------------PackNode---------------------------------------
 409 // Pack parent class (not for code generation).
 410 class PackNode : public VectorNode {
 411  public:
 412   PackNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
 413   PackNode(Node* in1, Node* n2, const TypeVect* vt) : VectorNode(in1, n2, vt) {}
 414   virtual int Opcode() const;
 415 
 416   void add_opd(uint i, Node* n) {
 417     init_req(i+1, n);


 418   }
 419 
 420   // Create a binary tree form for Packs. [lo, hi) (half-open) range
 421   Node* binaryTreePack(Compile* C, int lo, int hi);
 422 
 423   static PackNode* make(Compile* C, Node* s, uint vlen, BasicType bt);
 424 };
 425 
 426 //------------------------------PackBNode---------------------------------------
 427 // Pack byte scalars into vector
 428 class PackBNode : public PackNode {


 429  public:
 430   PackBNode(Node* in1, const TypeVect* vt)  : PackNode(in1, vt) {}
 431   virtual int Opcode() const;
 432 };
 433 
 434 //------------------------------PackCNode---------------------------------------
 435 // Pack char scalars into vector
 436 class PackCNode : public PackNode {


 437  public:
 438   PackCNode(Node* in1, const TypeVect* vt)  : PackNode(in1, vt) {}
 439   virtual int Opcode() const;
 440 };
 441 
 442 //------------------------------PackSNode---------------------------------------
 443 // Pack short scalars into a vector
 444 class PackSNode : public PackNode {


 445  public:
 446   PackSNode(Node* in1, const TypeVect* vt)  : PackNode(in1, vt) {}
 447   PackSNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
 448   virtual int Opcode() const;
 449 };
 450 
 451 //------------------------------PackINode---------------------------------------
 452 // Pack integer scalars into a vector
 453 class PackINode : public PackNode {


 454  public:
 455   PackINode(Node* in1, const TypeVect* vt)  : PackNode(in1, vt) {}
 456   PackINode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
 457   virtual int Opcode() const;
 458 };
 459 
 460 //------------------------------PackLNode---------------------------------------
 461 // Pack long scalars into a vector
 462 class PackLNode : public PackNode {


 463  public:
 464   PackLNode(Node* in1, const TypeVect* vt)  : PackNode(in1, vt) {}
 465   PackLNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
 466   virtual int Opcode() const;
 467 };
 468 
 469 //------------------------------Pack2LNode--------------------------------------
 470 // Pack 2 long scalars into a vector
 471 class Pack2LNode : public PackNode {
 472  public:
 473   Pack2LNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
 474   virtual int Opcode() const;
 475 };
 476 
 477 //------------------------------PackFNode---------------------------------------
 478 // Pack float scalars into vector
 479 class PackFNode : public PackNode {


 480  public:
 481   PackFNode(Node* in1, const TypeVect* vt)  : PackNode(in1, vt) {}
 482   PackFNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
 483   virtual int Opcode() const;
 484 };
 485 
 486 //------------------------------PackDNode---------------------------------------
 487 // Pack double scalars into a vector
 488 class PackDNode : public PackNode {


 489  public:
 490   PackDNode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {}
 491   PackDNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
 492   virtual int Opcode() const;
 493 };
 494 
 495 //------------------------------Pack2DNode--------------------------------------
 496 // Pack 2 double scalars into a vector
 497 class Pack2DNode : public PackNode {






 498  public:
 499   Pack2DNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
 500   virtual int Opcode() const;

 501 };
 502 










 503 
 504 //========================Extract_Scalar_from_Vector===============================
 505 
 506 //------------------------------ExtractNode---------------------------------------
 507 // Extract a scalar from a vector at position "pos"
 508 class ExtractNode : public Node {
 509  public:
 510   ExtractNode(Node* src, ConINode* pos) : Node(NULL, src, (Node*)pos) {
 511     assert(in(2)->get_int() >= 0, "positive constants");
 512   }
 513   virtual int Opcode() const;
 514   uint  pos() const { return in(2)->get_int(); }
 515 
 516   static Node* make(Compile* C, Node* v, uint position, BasicType bt);
 517 };
 518 
 519 //------------------------------ExtractBNode---------------------------------------
 520 // Extract a byte from a vector at position "pos"
 521 class ExtractBNode : public ExtractNode {
 522  public:
 523   ExtractBNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
 524   virtual int Opcode() const;
 525   virtual const Type *bottom_type() const { return TypeInt::INT; }
 526   virtual uint ideal_reg() const { return Op_RegI; }
 527 };
 528 
 529 //------------------------------ExtractCNode---------------------------------------
 530 // Extract a char from a vector at position "pos"
 531 class ExtractCNode : public ExtractNode {
 532  public:
 533   ExtractCNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
 534   virtual int Opcode() const;
 535   virtual const Type *bottom_type() const { return TypeInt::INT; }
 536   virtual uint ideal_reg() const { return Op_RegI; }