| /* |
| * 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; } |
| }; |