Mercurial > hg > graal-compiler
view src/share/vm/opto/vectornode.hpp @ 731:aa92a90b1cc6
6833951: Extra ":" Causes Testcase in CR 6589834 "Parse Exception: Invalid tag: summary:"
Summary: Remove the colon
Reviewed-by: never
author | cfang |
---|---|
date | Fri, 24 Apr 2009 09:14:39 -0700 |
parents | d1605aabd0a1 |
children | c18cbe5936b8 |
line wrap: on
line source
/* * Copyright 2007-2008 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; } };