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