duke@435: /*
duke@435:  * Copyright 2007 Sun Microsystems, Inc.  All Rights Reserved.
duke@435:  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
duke@435:  *
duke@435:  * This code is free software; you can redistribute it and/or modify it
duke@435:  * under the terms of the GNU General Public License version 2 only, as
duke@435:  * published by the Free Software Foundation.
duke@435:  *
duke@435:  * This code is distributed in the hope that it will be useful, but WITHOUT
duke@435:  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
duke@435:  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
duke@435:  * version 2 for more details (a copy is included in the LICENSE file that
duke@435:  * accompanied this code).
duke@435:  *
duke@435:  * You should have received a copy of the GNU General Public License version
duke@435:  * 2 along with this work; if not, write to the Free Software Foundation,
duke@435:  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
duke@435:  *
duke@435:  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
duke@435:  * CA 95054 USA or visit www.sun.com if you need additional information or
duke@435:  * have any questions.
duke@435:  */
duke@435: 
duke@435: //------------------------------VectorNode--------------------------------------
duke@435: // Vector Operation
duke@435: class VectorNode : public Node {
duke@435:  protected:
duke@435:   uint _length; // vector length
duke@435:   virtual BasicType elt_basic_type() const = 0; // Vector element basic type
duke@435: 
duke@435:   static const Type* vect_type(BasicType elt_bt, uint len);
duke@435:   static const Type* vect_type(const Type* elt_type, uint len) {
duke@435:     return vect_type(elt_type->array_element_basic_type(), len);
duke@435:   }
duke@435: 
duke@435:  public:
duke@435:   friend class VectorLoadNode;  // For vect_type
duke@435:   friend class VectorStoreNode; // ditto.
duke@435: 
duke@435:   VectorNode(Node* n1, uint vlen) : Node(NULL, n1), _length(vlen) {
duke@435:     init_flags(Flag_is_Vector);
duke@435:   }
duke@435:   VectorNode(Node* n1, Node* n2, uint vlen) : Node(NULL, n1, n2), _length(vlen) {
duke@435:     init_flags(Flag_is_Vector);
duke@435:   }
duke@435:   virtual int Opcode() const;
duke@435: 
duke@435:   uint length() const { return _length; } // Vector length
duke@435: 
duke@435:   static uint max_vlen(BasicType bt) { // max vector length
kvn@464:     return (uint)(Matcher::vector_width_in_bytes() / type2aelembytes(bt));
duke@435:   }
duke@435: 
duke@435:   // Element and vector type
duke@435:   const Type* elt_type()  const { return Type::get_const_basic_type(elt_basic_type()); }
duke@435:   const Type* vect_type() const { return vect_type(elt_basic_type(), length()); }
duke@435: 
duke@435:   virtual const Type *bottom_type() const { return vect_type(); }
duke@435:   virtual uint        ideal_reg()   const { return Matcher::vector_ideal_reg(); }
duke@435: 
duke@435:   // Vector opcode from scalar opcode
duke@435:   static int opcode(int sopc, uint vlen, const Type* opd_t);
duke@435: 
duke@435:   static VectorNode* scalar2vector(Compile* C, Node* s, uint vlen, const Type* opd_t);
duke@435: 
duke@435:   static VectorNode* make(Compile* C, int sopc, Node* n1, Node* n2, uint vlen, const Type* elt_t);
duke@435: 
duke@435: };
duke@435: 
duke@435: //===========================Vector=ALU=Operations====================================
duke@435: 
duke@435: //------------------------------AddVBNode---------------------------------------
duke@435: // Vector add byte
duke@435: class AddVBNode : public VectorNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_BYTE; }
duke@435:  public:
duke@435:   AddVBNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------AddVCNode---------------------------------------
duke@435: // Vector add char
duke@435: class AddVCNode : public VectorNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_CHAR; }
duke@435:  public:
duke@435:   AddVCNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------AddVSNode---------------------------------------
duke@435: // Vector add short
duke@435: class AddVSNode : public VectorNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_SHORT; }
duke@435:  public:
duke@435:   AddVSNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------AddVINode---------------------------------------
duke@435: // Vector add int
duke@435: class AddVINode : public VectorNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_INT; }
duke@435:  public:
duke@435:   AddVINode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------AddVLNode---------------------------------------
duke@435: // Vector add long
duke@435: class AddVLNode : public VectorNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_LONG; }
duke@435:  public:
duke@435:   AddVLNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------AddVFNode---------------------------------------
duke@435: // Vector add float
duke@435: class AddVFNode : public VectorNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_FLOAT; }
duke@435:  public:
duke@435:   AddVFNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------AddVDNode---------------------------------------
duke@435: // Vector add double
duke@435: class AddVDNode : public VectorNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_DOUBLE; }
duke@435:  public:
duke@435:   AddVDNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------SubVBNode---------------------------------------
duke@435: // Vector subtract byte
duke@435: class SubVBNode : public VectorNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_BYTE; }
duke@435:  public:
duke@435:   SubVBNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------SubVCNode---------------------------------------
duke@435: // Vector subtract char
duke@435: class SubVCNode : public VectorNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_CHAR; }
duke@435:  public:
duke@435:   SubVCNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------SubVSNode---------------------------------------
duke@435: // Vector subtract short
duke@435: class SubVSNode : public VectorNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_SHORT; }
duke@435:  public:
duke@435:   SubVSNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------SubVINode---------------------------------------
duke@435: // Vector subtract int
duke@435: class SubVINode : public VectorNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_INT; }
duke@435:  public:
duke@435:   SubVINode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------SubVLNode---------------------------------------
duke@435: // Vector subtract long
duke@435: class SubVLNode : public VectorNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_LONG; }
duke@435:  public:
duke@435:   SubVLNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------SubVFNode---------------------------------------
duke@435: // Vector subtract float
duke@435: class SubVFNode : public VectorNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_FLOAT; }
duke@435:  public:
duke@435:   SubVFNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------SubVDNode---------------------------------------
duke@435: // Vector subtract double
duke@435: class SubVDNode : public VectorNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_DOUBLE; }
duke@435:  public:
duke@435:   SubVDNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------MulVFNode---------------------------------------
duke@435: // Vector multiply float
duke@435: class MulVFNode : public VectorNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_FLOAT; }
duke@435:  public:
duke@435:   MulVFNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------MulVDNode---------------------------------------
duke@435: // Vector multiply double
duke@435: class MulVDNode : public VectorNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_DOUBLE; }
duke@435:  public:
duke@435:   MulVDNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------DivVFNode---------------------------------------
duke@435: // Vector divide float
duke@435: class DivVFNode : public VectorNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_FLOAT; }
duke@435:  public:
duke@435:   DivVFNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------DivVDNode---------------------------------------
duke@435: // Vector Divide double
duke@435: class DivVDNode : public VectorNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_DOUBLE; }
duke@435:  public:
duke@435:   DivVDNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------LShiftVBNode---------------------------------------
duke@435: // Vector lshift byte
duke@435: class LShiftVBNode : public VectorNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_BYTE; }
duke@435:  public:
duke@435:   LShiftVBNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------LShiftVCNode---------------------------------------
duke@435: // Vector lshift chars
duke@435: class LShiftVCNode : public VectorNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_CHAR; }
duke@435:  public:
duke@435:   LShiftVCNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------LShiftVSNode---------------------------------------
duke@435: // Vector lshift shorts
duke@435: class LShiftVSNode : public VectorNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_SHORT; }
duke@435:  public:
duke@435:   LShiftVSNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------LShiftVINode---------------------------------------
duke@435: // Vector lshift ints
duke@435: class LShiftVINode : public VectorNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_INT; }
duke@435:  public:
duke@435:   LShiftVINode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------URShiftVBNode---------------------------------------
duke@435: // Vector urshift bytes
duke@435: class URShiftVBNode : public VectorNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_BYTE; }
duke@435:  public:
duke@435:   URShiftVBNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------URShiftVCNode---------------------------------------
duke@435: // Vector urshift char
duke@435: class URShiftVCNode : public VectorNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_SHORT; }
duke@435:  public:
duke@435:   URShiftVCNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------URShiftVSNode---------------------------------------
duke@435: // Vector urshift shorts
duke@435: class URShiftVSNode : public VectorNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_SHORT; }
duke@435:  public:
duke@435:   URShiftVSNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------URShiftVINode---------------------------------------
duke@435: // Vector urshift ints
duke@435: class URShiftVINode : public VectorNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_INT; }
duke@435:  public:
duke@435:   URShiftVINode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------AndVNode---------------------------------------
duke@435: // Vector and
duke@435: class AndVNode : public VectorNode {
duke@435:  protected:
duke@435:   BasicType _bt;
duke@435:   virtual BasicType elt_basic_type() const { return _bt; }
duke@435:  public:
duke@435:   AndVNode(Node* in1, Node* in2, uint vlen, BasicType bt) : VectorNode(in1,in2,vlen), _bt(bt) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------OrVNode---------------------------------------
duke@435: // Vector or
duke@435: class OrVNode : public VectorNode {
duke@435:  protected:
duke@435:   BasicType _bt;
duke@435:   virtual BasicType elt_basic_type() const { return _bt; }
duke@435:  public:
duke@435:   OrVNode(Node* in1, Node* in2, uint vlen, BasicType bt) : VectorNode(in1,in2,vlen), _bt(bt) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------XorVNode---------------------------------------
duke@435: // Vector xor
duke@435: class XorVNode : public VectorNode {
duke@435:  protected:
duke@435:   BasicType _bt;
duke@435:   virtual BasicType elt_basic_type() const { return _bt; }
duke@435:  public:
duke@435:   XorVNode(Node* in1, Node* in2, uint vlen, BasicType bt) : VectorNode(in1,in2,vlen), _bt(bt) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //================================= M E M O R Y ==================================
duke@435: 
duke@435: 
duke@435: //------------------------------VectorLoadNode--------------------------------------
duke@435: // Vector Load from memory
duke@435: class VectorLoadNode : public LoadNode {
duke@435:   virtual uint size_of() const { return sizeof(*this); }
duke@435: 
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type()  const = 0; // Vector element basic type
duke@435:   // For use in constructor
duke@435:   static const Type* vect_type(const Type* elt_type, uint len) {
duke@435:     return VectorNode::vect_type(elt_type, len);
duke@435:   }
duke@435: 
duke@435:  public:
duke@435:   VectorLoadNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const Type *rt)
duke@435:     : LoadNode(c,mem,adr,at,rt) {
duke@435:       init_flags(Flag_is_Vector);
duke@435:   }
duke@435:   virtual int Opcode() const;
duke@435: 
duke@435:   virtual uint  length() const = 0; // Vector length
duke@435: 
duke@435:   // Element and vector type
duke@435:   const Type* elt_type()  const { return Type::get_const_basic_type(elt_basic_type()); }
duke@435:   const Type* vect_type() const { return VectorNode::vect_type(elt_basic_type(), length()); }
duke@435: 
duke@435:   virtual uint ideal_reg() const  { return Matcher::vector_ideal_reg(); }
duke@435:   virtual BasicType memory_type() const { return T_VOID; }
kvn@464:   virtual int memory_size() const { return length()*type2aelembytes(elt_basic_type()); }
duke@435: 
duke@435:   // Vector opcode from scalar opcode
duke@435:   static int opcode(int sopc, uint vlen);
duke@435: 
duke@435:   static VectorLoadNode* make(Compile* C, int opc, Node* ctl, Node* mem,
duke@435:                               Node* adr, const TypePtr* atyp, uint vlen);
duke@435: };
duke@435: 
duke@435: //------------------------------Load16BNode--------------------------------------
duke@435: // Vector load of 16 bytes (8bits signed) from memory
duke@435: class Load16BNode : public VectorLoadNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_BYTE; }
duke@435:  public:
duke@435:   Load16BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::BYTE)
duke@435:     : VectorLoadNode(c,mem,adr,at,vect_type(ti,16)) {}
duke@435:   virtual int Opcode() const;
duke@435:   virtual int store_Opcode() const { return Op_Store16B; }
duke@435:   virtual uint length() const { return 16; }
duke@435: };
duke@435: 
duke@435: //------------------------------Load8BNode--------------------------------------
duke@435: // Vector load of 8 bytes (8bits signed) from memory
duke@435: class Load8BNode : public VectorLoadNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_BYTE; }
duke@435:  public:
duke@435:   Load8BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::BYTE)
duke@435:     : VectorLoadNode(c,mem,adr,at,vect_type(ti,8)) {}
duke@435:   virtual int Opcode() const;
duke@435:   virtual int store_Opcode() const { return Op_Store8B; }
duke@435:   virtual uint length() const { return 8; }
duke@435: };
duke@435: 
duke@435: //------------------------------Load4BNode--------------------------------------
duke@435: // Vector load of 4 bytes (8bits signed) from memory
duke@435: class Load4BNode : public VectorLoadNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_BYTE; }
duke@435:  public:
duke@435:   Load4BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::BYTE)
duke@435:     : VectorLoadNode(c,mem,adr,at,vect_type(ti,4)) {}
duke@435:   virtual int Opcode() const;
duke@435:   virtual int store_Opcode() const { return Op_Store4B; }
duke@435:   virtual uint length() const { return 4; }
duke@435: };
duke@435: 
duke@435: //------------------------------Load8CNode--------------------------------------
duke@435: // Vector load of 8 chars (16bits unsigned) from memory
duke@435: class Load8CNode : public VectorLoadNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_CHAR; }
duke@435:  public:
duke@435:   Load8CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::CHAR)
duke@435:     : VectorLoadNode(c,mem,adr,at,vect_type(ti,8)) {}
duke@435:   virtual int Opcode() const;
duke@435:   virtual int store_Opcode() const { return Op_Store8C; }
duke@435:   virtual uint length() const { return 8; }
duke@435: };
duke@435: 
duke@435: //------------------------------Load4CNode--------------------------------------
duke@435: // Vector load of 4 chars (16bits unsigned) from memory
duke@435: class Load4CNode : public VectorLoadNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_CHAR; }
duke@435:  public:
duke@435:   Load4CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::CHAR)
duke@435:     : VectorLoadNode(c,mem,adr,at,vect_type(ti,4)) {}
duke@435:   virtual int Opcode() const;
duke@435:   virtual int store_Opcode() const { return Op_Store4C; }
duke@435:   virtual uint length() const { return 4; }
duke@435: };
duke@435: 
duke@435: //------------------------------Load2CNode--------------------------------------
duke@435: // Vector load of 2 chars (16bits unsigned) from memory
duke@435: class Load2CNode : public VectorLoadNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_CHAR; }
duke@435:  public:
duke@435:   Load2CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::CHAR)
duke@435:     : VectorLoadNode(c,mem,adr,at,vect_type(ti,2)) {}
duke@435:   virtual int Opcode() const;
duke@435:   virtual int store_Opcode() const { return Op_Store2C; }
duke@435:   virtual uint length() const { return 2; }
duke@435: };
duke@435: 
duke@435: //------------------------------Load8SNode--------------------------------------
duke@435: // Vector load of 8 shorts (16bits signed) from memory
duke@435: class Load8SNode : public VectorLoadNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_SHORT; }
duke@435:  public:
duke@435:   Load8SNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::SHORT)
duke@435:     : VectorLoadNode(c,mem,adr,at,vect_type(ti,8)) {}
duke@435:   virtual int Opcode() const;
duke@435:   virtual int store_Opcode() const { return Op_Store8C; }
duke@435:   virtual uint length() const { return 8; }
duke@435: };
duke@435: 
duke@435: //------------------------------Load4SNode--------------------------------------
duke@435: // Vector load of 4 shorts (16bits signed) from memory
duke@435: class Load4SNode : public VectorLoadNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_SHORT; }
duke@435:  public:
duke@435:   Load4SNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::SHORT)
duke@435:     : VectorLoadNode(c,mem,adr,at,vect_type(ti,4)) {}
duke@435:   virtual int Opcode() const;
duke@435:   virtual int store_Opcode() const { return Op_Store4C; }
duke@435:   virtual uint length() const { return 4; }
duke@435: };
duke@435: 
duke@435: //------------------------------Load2SNode--------------------------------------
duke@435: // Vector load of 2 shorts (16bits signed) from memory
duke@435: class Load2SNode : public VectorLoadNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_SHORT; }
duke@435:  public:
duke@435:   Load2SNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::SHORT)
duke@435:     : VectorLoadNode(c,mem,adr,at,vect_type(ti,2)) {}
duke@435:   virtual int Opcode() const;
duke@435:   virtual int store_Opcode() const { return Op_Store2C; }
duke@435:   virtual uint length() const { return 2; }
duke@435: };
duke@435: 
duke@435: //------------------------------Load4INode--------------------------------------
duke@435: // Vector load of 4 integers (32bits signed) from memory
duke@435: class Load4INode : public VectorLoadNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_INT; }
duke@435:  public:
duke@435:   Load4INode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::INT)
duke@435:     : VectorLoadNode(c,mem,adr,at,vect_type(ti,4)) {}
duke@435:   virtual int Opcode() const;
duke@435:   virtual int store_Opcode() const { return Op_Store4I; }
duke@435:   virtual uint length() const { return 4; }
duke@435: };
duke@435: 
duke@435: //------------------------------Load2INode--------------------------------------
duke@435: // Vector load of 2 integers (32bits signed) from memory
duke@435: class Load2INode : public VectorLoadNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_INT; }
duke@435:  public:
duke@435:   Load2INode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt *ti = TypeInt::INT)
duke@435:     : VectorLoadNode(c,mem,adr,at,vect_type(ti,2)) {}
duke@435:   virtual int Opcode() const;
duke@435:   virtual int store_Opcode() const { return Op_Store2I; }
duke@435:   virtual uint length() const { return 2; }
duke@435: };
duke@435: 
duke@435: //------------------------------Load2LNode--------------------------------------
duke@435: // Vector load of 2 longs (64bits signed) from memory
duke@435: class Load2LNode : public VectorLoadNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_LONG; }
duke@435:  public:
duke@435:   Load2LNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeLong *tl = TypeLong::LONG)
duke@435:     : VectorLoadNode(c,mem,adr,at,vect_type(tl,2)) {}
duke@435:   virtual int Opcode() const;
duke@435:   virtual int store_Opcode() const { return Op_Store2L; }
duke@435:   virtual uint length() const { return 2; }
duke@435: };
duke@435: 
duke@435: //------------------------------Load4FNode--------------------------------------
duke@435: // Vector load of 4 floats (32bits) from memory
duke@435: class Load4FNode : public VectorLoadNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_FLOAT; }
duke@435:  public:
duke@435:   Load4FNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const Type *t = Type::FLOAT)
duke@435:     : VectorLoadNode(c,mem,adr,at,vect_type(t,4)) {}
duke@435:   virtual int Opcode() const;
duke@435:   virtual int store_Opcode() const { return Op_Store4F; }
duke@435:   virtual uint length() const { return 4; }
duke@435: };
duke@435: 
duke@435: //------------------------------Load2FNode--------------------------------------
duke@435: // Vector load of 2 floats (32bits) from memory
duke@435: class Load2FNode : public VectorLoadNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_FLOAT; }
duke@435:  public:
duke@435:   Load2FNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const Type *t = Type::FLOAT)
duke@435:     : VectorLoadNode(c,mem,adr,at,vect_type(t,2)) {}
duke@435:   virtual int Opcode() const;
duke@435:   virtual int store_Opcode() const { return Op_Store2F; }
duke@435:   virtual uint length() const { return 2; }
duke@435: };
duke@435: 
duke@435: //------------------------------Load2DNode--------------------------------------
duke@435: // Vector load of 2 doubles (64bits) from memory
duke@435: class Load2DNode : public VectorLoadNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_DOUBLE; }
duke@435:  public:
duke@435:   Load2DNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const Type *t = Type::DOUBLE)
duke@435:     : VectorLoadNode(c,mem,adr,at,vect_type(t,2)) {}
duke@435:   virtual int Opcode() const;
duke@435:   virtual int store_Opcode() const { return Op_Store2D; }
duke@435:   virtual uint length() const { return 2; }
duke@435: };
duke@435: 
duke@435: 
duke@435: //------------------------------VectorStoreNode--------------------------------------
duke@435: // Vector Store to memory
duke@435: class VectorStoreNode : public StoreNode {
duke@435:   virtual uint size_of() const { return sizeof(*this); }
duke@435: 
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type()  const = 0; // Vector element basic type
duke@435: 
duke@435:  public:
duke@435:   VectorStoreNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
duke@435:     : StoreNode(c,mem,adr,at,val) {
duke@435:       init_flags(Flag_is_Vector);
duke@435:   }
duke@435:   virtual int Opcode() const;
duke@435: 
duke@435:   virtual uint  length() const = 0; // Vector length
duke@435: 
duke@435:   // Element and vector type
duke@435:   const Type* elt_type()  const { return Type::get_const_basic_type(elt_basic_type()); }
duke@435:   const Type* vect_type() const { return VectorNode::vect_type(elt_basic_type(), length()); }
duke@435: 
duke@435:   virtual uint ideal_reg() const  { return Matcher::vector_ideal_reg(); }
duke@435:   virtual BasicType memory_type() const { return T_VOID; }
kvn@464:   virtual int memory_size() const { return length()*type2aelembytes(elt_basic_type()); }
duke@435: 
duke@435:   // Vector opcode from scalar opcode
duke@435:   static int opcode(int sopc, uint vlen);
duke@435: 
duke@435:   static VectorStoreNode* make(Compile* C, int opc, Node* ctl, Node* mem,
duke@435:                                Node* adr, const TypePtr* atyp, VectorNode* val,
duke@435:                                uint vlen);
duke@435: };
duke@435: 
duke@435: //------------------------------Store16BNode--------------------------------------
duke@435: // Vector store of 16 bytes (8bits signed) to memory
duke@435: class Store16BNode : public VectorStoreNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_BYTE; }
duke@435:  public:
duke@435:   Store16BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
duke@435:     : VectorStoreNode(c,mem,adr,at,val) {}
duke@435:   virtual int Opcode() const;
duke@435:   virtual uint length() const { return 16; }
duke@435: };
duke@435: 
duke@435: //------------------------------Store8BNode--------------------------------------
duke@435: // Vector store of 8 bytes (8bits signed) to memory
duke@435: class Store8BNode : public VectorStoreNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_BYTE; }
duke@435:  public:
duke@435:   Store8BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
duke@435:     : VectorStoreNode(c,mem,adr,at,val) {}
duke@435:   virtual int Opcode() const;
duke@435:   virtual uint length() const { return 8; }
duke@435: };
duke@435: 
duke@435: //------------------------------Store4BNode--------------------------------------
duke@435: // Vector store of 4 bytes (8bits signed) to memory
duke@435: class Store4BNode : public VectorStoreNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_BYTE; }
duke@435:  public:
duke@435:   Store4BNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
duke@435:     : VectorStoreNode(c,mem,adr,at,val) {}
duke@435:   virtual int Opcode() const;
duke@435:   virtual uint length() const { return 4; }
duke@435: };
duke@435: 
duke@435: //------------------------------Store8CNode--------------------------------------
duke@435: // Vector store of 8 chars (16bits signed/unsigned) to memory
duke@435: class Store8CNode : public VectorStoreNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_CHAR; }
duke@435:  public:
duke@435:   Store8CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
duke@435:     : VectorStoreNode(c,mem,adr,at,val) {}
duke@435:   virtual int Opcode() const;
duke@435:   virtual uint length() const { return 8; }
duke@435: };
duke@435: 
duke@435: //------------------------------Store4CNode--------------------------------------
duke@435: // Vector store of 4 chars (16bits signed/unsigned) to memory
duke@435: class Store4CNode : public VectorStoreNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_CHAR; }
duke@435:  public:
duke@435:   Store4CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
duke@435:     : VectorStoreNode(c,mem,adr,at,val) {}
duke@435:   virtual int Opcode() const;
duke@435:   virtual uint length() const { return 4; }
duke@435: };
duke@435: 
duke@435: //------------------------------Store2CNode--------------------------------------
duke@435: // Vector store of 2 chars (16bits signed/unsigned) to memory
duke@435: class Store2CNode : public VectorStoreNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_CHAR; }
duke@435:  public:
duke@435:   Store2CNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
duke@435:     : VectorStoreNode(c,mem,adr,at,val) {}
duke@435:   virtual int Opcode() const;
duke@435:   virtual uint length() const { return 2; }
duke@435: };
duke@435: 
duke@435: //------------------------------Store4INode--------------------------------------
duke@435: // Vector store of 4 integers (32bits signed) to memory
duke@435: class Store4INode : public VectorStoreNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_INT; }
duke@435:  public:
duke@435:   Store4INode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
duke@435:     : VectorStoreNode(c,mem,adr,at,val) {}
duke@435:   virtual int Opcode() const;
duke@435:   virtual uint length() const { return 4; }
duke@435: };
duke@435: 
duke@435: //------------------------------Store2INode--------------------------------------
duke@435: // Vector store of 2 integers (32bits signed) to memory
duke@435: class Store2INode : public VectorStoreNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_INT; }
duke@435:  public:
duke@435:   Store2INode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
duke@435:     : VectorStoreNode(c,mem,adr,at,val) {}
duke@435:   virtual int Opcode() const;
duke@435:   virtual uint length() const { return 2; }
duke@435: };
duke@435: 
duke@435: //------------------------------Store2LNode--------------------------------------
duke@435: // Vector store of 2 longs (64bits signed) to memory
duke@435: class Store2LNode : public VectorStoreNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_LONG; }
duke@435:  public:
duke@435:   Store2LNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
duke@435:     : VectorStoreNode(c,mem,adr,at,val) {}
duke@435:   virtual int Opcode() const;
duke@435:   virtual uint length() const { return 2; }
duke@435: };
duke@435: 
duke@435: //------------------------------Store4FNode--------------------------------------
duke@435: // Vector store of 4 floats (32bits) to memory
duke@435: class Store4FNode : public VectorStoreNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_FLOAT; }
duke@435:  public:
duke@435:   Store4FNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
duke@435:     : VectorStoreNode(c,mem,adr,at,val) {}
duke@435:   virtual int Opcode() const;
duke@435:   virtual uint length() const { return 4; }
duke@435: };
duke@435: 
duke@435: //------------------------------Store2FNode--------------------------------------
duke@435: // Vector store of 2 floats (32bits) to memory
duke@435: class Store2FNode : public VectorStoreNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_FLOAT; }
duke@435:  public:
duke@435:   Store2FNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
duke@435:     : VectorStoreNode(c,mem,adr,at,val) {}
duke@435:   virtual int Opcode() const;
duke@435:   virtual uint length() const { return 2; }
duke@435: };
duke@435: 
duke@435: //------------------------------Store2DNode--------------------------------------
duke@435: // Vector store of 2 doubles (64bits) to memory
duke@435: class Store2DNode : public VectorStoreNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_DOUBLE; }
duke@435:  public:
duke@435:   Store2DNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
duke@435:     : VectorStoreNode(c,mem,adr,at,val) {}
duke@435:   virtual int Opcode() const;
duke@435:   virtual uint length() const { return 2; }
duke@435: };
duke@435: 
duke@435: //=========================Promote_Scalar_to_Vector====================================
duke@435: 
duke@435: //------------------------------Replicate16BNode---------------------------------------
duke@435: // Replicate byte scalar to be vector of 16 bytes
duke@435: class Replicate16BNode : public VectorNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_BYTE; }
duke@435:  public:
duke@435:   Replicate16BNode(Node* in1) : VectorNode(in1, 16) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------Replicate8BNode---------------------------------------
duke@435: // Replicate byte scalar to be vector of 8 bytes
duke@435: class Replicate8BNode : public VectorNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_BYTE; }
duke@435:  public:
duke@435:   Replicate8BNode(Node* in1) : VectorNode(in1, 8) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------Replicate4BNode---------------------------------------
duke@435: // Replicate byte scalar to be vector of 4 bytes
duke@435: class Replicate4BNode : public VectorNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_BYTE; }
duke@435:  public:
duke@435:   Replicate4BNode(Node* in1) : VectorNode(in1, 4) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------Replicate8CNode---------------------------------------
duke@435: // Replicate char scalar to be vector of 8 chars
duke@435: class Replicate8CNode : public VectorNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_CHAR; }
duke@435:  public:
duke@435:   Replicate8CNode(Node* in1) : VectorNode(in1, 8) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------Replicate4CNode---------------------------------------
duke@435: // Replicate char scalar to be vector of 4 chars
duke@435: class Replicate4CNode : public VectorNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_CHAR; }
duke@435:  public:
duke@435:   Replicate4CNode(Node* in1) : VectorNode(in1, 4) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------Replicate2CNode---------------------------------------
duke@435: // Replicate char scalar to be vector of 2 chars
duke@435: class Replicate2CNode : public VectorNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_CHAR; }
duke@435:  public:
duke@435:   Replicate2CNode(Node* in1) : VectorNode(in1, 2) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------Replicate8SNode---------------------------------------
duke@435: // Replicate short scalar to be vector of 8 shorts
duke@435: class Replicate8SNode : public VectorNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_SHORT; }
duke@435:  public:
duke@435:   Replicate8SNode(Node* in1) : VectorNode(in1, 8) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------Replicate4SNode---------------------------------------
duke@435: // Replicate short scalar to be vector of 4 shorts
duke@435: class Replicate4SNode : public VectorNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_SHORT; }
duke@435:  public:
duke@435:   Replicate4SNode(Node* in1) : VectorNode(in1, 4) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------Replicate2SNode---------------------------------------
duke@435: // Replicate short scalar to be vector of 2 shorts
duke@435: class Replicate2SNode : public VectorNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_SHORT; }
duke@435:  public:
duke@435:   Replicate2SNode(Node* in1) : VectorNode(in1, 2) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------Replicate4INode---------------------------------------
duke@435: // Replicate int scalar to be vector of 4 ints
duke@435: class Replicate4INode : public VectorNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_INT; }
duke@435:  public:
duke@435:   Replicate4INode(Node* in1) : VectorNode(in1, 4) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------Replicate2INode---------------------------------------
duke@435: // Replicate int scalar to be vector of 2 ints
duke@435: class Replicate2INode : public VectorNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_INT; }
duke@435:  public:
duke@435:   Replicate2INode(Node* in1) : VectorNode(in1, 2) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------Replicate2LNode---------------------------------------
duke@435: // Replicate long scalar to be vector of 2 longs
duke@435: class Replicate2LNode : public VectorNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_LONG; }
duke@435:  public:
duke@435:   Replicate2LNode(Node* in1) : VectorNode(in1, 2) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------Replicate4FNode---------------------------------------
duke@435: // Replicate float scalar to be vector of 4 floats
duke@435: class Replicate4FNode : public VectorNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_FLOAT; }
duke@435:  public:
duke@435:   Replicate4FNode(Node* in1) : VectorNode(in1, 4) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------Replicate2FNode---------------------------------------
duke@435: // Replicate float scalar to be vector of 2 floats
duke@435: class Replicate2FNode : public VectorNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_FLOAT; }
duke@435:  public:
duke@435:   Replicate2FNode(Node* in1) : VectorNode(in1, 2) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------Replicate2DNode---------------------------------------
duke@435: // Replicate double scalar to be vector of 2 doubles
duke@435: class Replicate2DNode : public VectorNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_DOUBLE; }
duke@435:  public:
duke@435:   Replicate2DNode(Node* in1) : VectorNode(in1, 2) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //========================Pack_Scalars_into_a_Vector==============================
duke@435: 
duke@435: //------------------------------PackNode---------------------------------------
duke@435: // Pack parent class (not for code generation).
duke@435: class PackNode : public VectorNode {
duke@435:  public:
duke@435:   PackNode(Node* in1)  : VectorNode(in1, 1) {}
duke@435:   PackNode(Node* in1, Node* n2)  : VectorNode(in1, n2, 2) {}
duke@435:   virtual int Opcode() const;
duke@435: 
duke@435:   void add_opd(Node* n) {
duke@435:     add_req(n);
duke@435:     _length++;
duke@435:     assert(_length == req() - 1, "vector length matches edge count");
duke@435:   }
duke@435: 
duke@435:   // Create a binary tree form for Packs. [lo, hi) (half-open) range
duke@435:   Node* binaryTreePack(Compile* C, int lo, int hi);
duke@435: 
duke@435:   static PackNode* make(Compile* C, Node* s, const Type* elt_t);
duke@435: };
duke@435: 
duke@435: //------------------------------PackBNode---------------------------------------
duke@435: // Pack byte scalars into vector
duke@435: class PackBNode : public PackNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_BYTE; }
duke@435:  public:
duke@435:   PackBNode(Node* in1)  : PackNode(in1) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------PackCNode---------------------------------------
duke@435: // Pack char scalars into vector
duke@435: class PackCNode : public PackNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_CHAR; }
duke@435:  public:
duke@435:   PackCNode(Node* in1)  : PackNode(in1) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------PackSNode---------------------------------------
duke@435: // Pack short scalars into a vector
duke@435: class PackSNode : public PackNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_SHORT; }
duke@435:  public:
duke@435:   PackSNode(Node* in1)  : PackNode(in1) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------PackINode---------------------------------------
duke@435: // Pack integer scalars into a vector
duke@435: class PackINode : public PackNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_INT; }
duke@435:  public:
duke@435:   PackINode(Node* in1)  : PackNode(in1) {}
duke@435:   PackINode(Node* in1, Node* in2) : PackNode(in1, in2) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------PackLNode---------------------------------------
duke@435: // Pack long scalars into a vector
duke@435: class PackLNode : public PackNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_LONG; }
duke@435:  public:
duke@435:   PackLNode(Node* in1)  : PackNode(in1) {}
duke@435:   PackLNode(Node* in1, Node* in2) : PackNode(in1, in2) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------PackFNode---------------------------------------
duke@435: // Pack float scalars into vector
duke@435: class PackFNode : public PackNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_FLOAT; }
duke@435:  public:
duke@435:   PackFNode(Node* in1)  : PackNode(in1) {}
duke@435:   PackFNode(Node* in1, Node* in2) : PackNode(in1, in2) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: //------------------------------PackDNode---------------------------------------
duke@435: // Pack double scalars into a vector
duke@435: class PackDNode : public PackNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_DOUBLE; }
duke@435:  public:
duke@435:   PackDNode(Node* in1)  : PackNode(in1) {}
duke@435:   PackDNode(Node* in1, Node* in2) : PackNode(in1, in2) {}
duke@435:   virtual int Opcode() const;
duke@435: };
duke@435: 
duke@435: // The Pack2xN nodes assist code generation.  They are created from
duke@435: // Pack4C, etc. nodes in final_graph_reshape in the form of a
duke@435: // balanced, binary tree.
duke@435: 
duke@435: //------------------------------Pack2x1BNode-----------------------------------------
duke@435: // Pack 2 1-byte integers into vector of 2 bytes
duke@435: class Pack2x1BNode : public PackNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_BYTE; }
duke@435:  public:
duke@435:   Pack2x1BNode(Node *in1, Node* in2) : PackNode(in1, in2) {}
duke@435:   virtual int Opcode() const;
duke@435:   virtual uint ideal_reg() const { return Op_RegI; }
duke@435: };
duke@435: 
duke@435: //------------------------------Pack2x2BNode---------------------------------------
duke@435: // Pack 2 2-byte integers into vector of 4 bytes
duke@435: class Pack2x2BNode : public PackNode {
duke@435:  protected:
duke@435:   virtual BasicType elt_basic_type() const { return T_CHAR; }
duke@435:  public:
duke@435:   Pack2x2BNode(Node *in1, Node* in2) : PackNode(in1, in2) {}
duke@435:   virtual int Opcode() const;
duke@435:   virtual uint ideal_reg() const { return Op_RegI; }
duke@435: };
duke@435: 
duke@435: //========================Extract_Scalar_from_Vector===============================
duke@435: 
duke@435: //------------------------------ExtractNode---------------------------------------
duke@435: // Extract a scalar from a vector at position "pos"
duke@435: class ExtractNode : public Node {
duke@435:  public:
duke@435:   ExtractNode(Node* src, ConINode* pos) : Node(NULL, src, (Node*)pos) {
duke@435:     assert(in(2)->get_int() >= 0, "positive constants");
duke@435:   }
duke@435:   virtual int Opcode() const;
duke@435:   uint  pos() const { return in(2)->get_int(); }
duke@435: 
duke@435:   static Node* make(Compile* C, Node* v, uint position, const Type* opd_t);
duke@435: };
duke@435: 
duke@435: //------------------------------ExtractBNode---------------------------------------
duke@435: // Extract a byte from a vector at position "pos"
duke@435: class ExtractBNode : public ExtractNode {
duke@435:  public:
duke@435:   ExtractBNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
duke@435:   virtual int Opcode() const;
duke@435:   virtual const Type *bottom_type() const { return TypeInt::INT; }
duke@435:   virtual uint ideal_reg() const { return Op_RegI; }
duke@435: };
duke@435: 
duke@435: //------------------------------ExtractCNode---------------------------------------
duke@435: // Extract a char from a vector at position "pos"
duke@435: class ExtractCNode : public ExtractNode {
duke@435:  public:
duke@435:   ExtractCNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
duke@435:   virtual int Opcode() const;
duke@435:   virtual const Type *bottom_type() const { return TypeInt::INT; }
duke@435:   virtual uint ideal_reg() const { return Op_RegI; }
duke@435: };
duke@435: 
duke@435: //------------------------------ExtractSNode---------------------------------------
duke@435: // Extract a short from a vector at position "pos"
duke@435: class ExtractSNode : public ExtractNode {
duke@435:  public:
duke@435:   ExtractSNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
duke@435:   virtual int Opcode() const;
duke@435:   virtual const Type *bottom_type() const { return TypeInt::INT; }
duke@435:   virtual uint ideal_reg() const { return Op_RegI; }
duke@435: };
duke@435: 
duke@435: //------------------------------ExtractINode---------------------------------------
duke@435: // Extract an int from a vector at position "pos"
duke@435: class ExtractINode : public ExtractNode {
duke@435:  public:
duke@435:   ExtractINode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
duke@435:   virtual int Opcode() const;
duke@435:   virtual const Type *bottom_type() const { return TypeInt::INT; }
duke@435:   virtual uint ideal_reg() const { return Op_RegI; }
duke@435: };
duke@435: 
duke@435: //------------------------------ExtractLNode---------------------------------------
duke@435: // Extract a long from a vector at position "pos"
duke@435: class ExtractLNode : public ExtractNode {
duke@435:  public:
duke@435:   ExtractLNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
duke@435:   virtual int Opcode() const;
duke@435:   virtual const Type *bottom_type() const { return TypeLong::LONG; }
duke@435:   virtual uint ideal_reg() const { return Op_RegL; }
duke@435: };
duke@435: 
duke@435: //------------------------------ExtractFNode---------------------------------------
duke@435: // Extract a float from a vector at position "pos"
duke@435: class ExtractFNode : public ExtractNode {
duke@435:  public:
duke@435:   ExtractFNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
duke@435:   virtual int Opcode() const;
duke@435:   virtual const Type *bottom_type() const { return Type::FLOAT; }
duke@435:   virtual uint ideal_reg() const { return Op_RegF; }
duke@435: };
duke@435: 
duke@435: //------------------------------ExtractDNode---------------------------------------
duke@435: // Extract a double from a vector at position "pos"
duke@435: class ExtractDNode : public ExtractNode {
duke@435:  public:
duke@435:   ExtractDNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
duke@435:   virtual int Opcode() const;
duke@435:   virtual const Type *bottom_type() const { return Type::DOUBLE; }
duke@435:   virtual uint ideal_reg() const { return Op_RegD; }
duke@435: };