/*

 * 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)) {}