vm/opto/vectornode.hpp

	vectornode.hpp revision 0
fc9bee101f530464b5da5a9602697f40a91c5c50Diego Colantoni/*
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell * Copyright 2007 Sun Microsystems, Inc.  All Rights Reserved.
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell *
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell * This code is free software; you can redistribute it and/or modify it
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell * under the terms of the GNU General Public License version 2 only, as
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell * published by the Free Software Foundation.
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell *
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell * This code is distributed in the hope that it will be useful, but WITHOUT
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell * version 2 for more details (a copy is included in the LICENSE file that
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell * accompanied this code).
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell *
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell * You should have received a copy of the GNU General Public License version
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell * 2 along with this work; if not, write to the Free Software Foundation,
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott *
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott * CA 95054 USA or visit www.sun.com if you need additional information or
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell * have any questions.
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott */
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott//------------------------------VectorNode--------------------------------------
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott// Vector Operation
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshottclass VectorNode : public Node {
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott protected:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  uint _length; // vector length
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell  virtual BasicType elt_basic_type() const = 0; // Vector element basic type
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  static const Type* vect_type(BasicType elt_bt, uint len);
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  static const Type* vect_type(const Type* elt_type, uint len) {
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott    return vect_type(elt_type->array_element_basic_type(), len);
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  }
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell public:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  friend class VectorLoadNode;  // For vect_type
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  friend class VectorStoreNode; // ditto.
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  VectorNode(Node* n1, uint vlen) : Node(NULL, n1), _length(vlen) {
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott    init_flags(Flag_is_Vector);
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  }
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  VectorNode(Node* n1, Node* n2, uint vlen) : Node(NULL, n1, n2), _length(vlen) {
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott    init_flags(Flag_is_Vector);
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  }
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual int Opcode() const;
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  uint length() const { return _length; } // Vector length
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  static uint max_vlen(BasicType bt) { // max vector length
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott    return (uint)(Matcher::vector_width_in_bytes() / type2aelembytes[bt]);
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  }
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  // Element and vector type
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  const Type* elt_type()  const { return Type::get_const_basic_type(elt_basic_type()); }
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  const Type* vect_type() const { return vect_type(elt_basic_type(), length()); }
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual const Type *bottom_type() const { return vect_type(); }
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual uint        ideal_reg()   const { return Matcher::vector_ideal_reg(); }
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  // Vector opcode from scalar opcode
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  static int opcode(int sopc, uint vlen, const Type* opd_t);
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  static VectorNode* scalar2vector(Compile* C, Node* s, uint vlen, const Type* opd_t);
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  static VectorNode* make(Compile* C, int sopc, Node* n1, Node* n2, uint vlen, const Type* elt_t);
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott};
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott//===========================Vector=ALU=Operations====================================
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell//------------------------------AddVBNode---------------------------------------
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell// Vector add byte
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnellclass AddVBNode : public VectorNode {
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell protected:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual BasicType elt_basic_type() const { return T_BYTE; }
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott public:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  AddVBNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual int Opcode() const;
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott};
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott//------------------------------AddVCNode---------------------------------------
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott// Vector add char
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshottclass AddVCNode : public VectorNode {
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott protected:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual BasicType elt_basic_type() const { return T_CHAR; }
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott public:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  AddVCNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual int Opcode() const;
fc9bee101f530464b5da5a9602697f40a91c5c50Diego Colantoni};
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott//------------------------------AddVSNode---------------------------------------
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott// Vector add short
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshottclass AddVSNode : public VectorNode {
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott protected:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual BasicType elt_basic_type() const { return T_SHORT; }
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott public:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  AddVSNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual int Opcode() const;
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott};
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott//------------------------------AddVINode---------------------------------------
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell// Vector add int
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnellclass AddVINode : public VectorNode {
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott protected:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual BasicType elt_basic_type() const { return T_INT; }
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott public:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  AddVINode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual int Opcode() const;
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott};
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott//------------------------------AddVLNode---------------------------------------
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott// Vector add long
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshottclass AddVLNode : public VectorNode {
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell protected:
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell  virtual BasicType elt_basic_type() const { return T_LONG; }
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell public:
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell  AddVLNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell  virtual int Opcode() const;
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott};
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott//------------------------------AddVFNode---------------------------------------
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott// Vector add float
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshottclass AddVFNode : public VectorNode {
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott protected:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual BasicType elt_basic_type() const { return T_FLOAT; }
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott public:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  AddVFNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual int Opcode() const;
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott};
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott//------------------------------AddVDNode---------------------------------------
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott// Vector add double
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshottclass AddVDNode : public VectorNode {
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott protected:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual BasicType elt_basic_type() const { return T_DOUBLE; }
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott public:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  AddVDNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual int Opcode() const;
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott};
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott//------------------------------SubVBNode---------------------------------------
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott// Vector subtract byte
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshottclass SubVBNode : public VectorNode {
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott protected:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual BasicType elt_basic_type() const { return T_BYTE; }
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott public:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  SubVBNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual int Opcode() const;
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott};
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott//------------------------------SubVCNode---------------------------------------
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott// Vector subtract char
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshottclass SubVCNode : public VectorNode {
465ea459a87d4605e145d8f45b6a9c104b696e3bCraig McDonnell protected:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual BasicType elt_basic_type() const { return T_CHAR; }
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott public:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  SubVCNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual int Opcode() const;
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott};
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott//------------------------------SubVSNode---------------------------------------
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott// Vector subtract short
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshottclass SubVSNode : public VectorNode {
465ea459a87d4605e145d8f45b6a9c104b696e3bCraig McDonnell protected:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual BasicType elt_basic_type() const { return T_SHORT; }
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott public:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  SubVSNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual int Opcode() const;
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott};
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott//------------------------------SubVINode---------------------------------------
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott// Vector subtract int
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshottclass SubVINode : public VectorNode {
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott protected:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual BasicType elt_basic_type() const { return T_INT; }
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott public:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  SubVINode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual int Opcode() const;
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott};
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott//------------------------------SubVLNode---------------------------------------
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott// Vector subtract long
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshottclass SubVLNode : public VectorNode {
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott protected:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual BasicType elt_basic_type() const { return T_LONG; }
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott public:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  SubVLNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual int Opcode() const;
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott};
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott//------------------------------SubVFNode---------------------------------------
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott// Vector subtract float
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshottclass SubVFNode : public VectorNode {
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott protected:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual BasicType elt_basic_type() const { return T_FLOAT; }
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott public:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  SubVFNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual int Opcode() const;
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott};
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott//------------------------------SubVDNode---------------------------------------
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott// Vector subtract double
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshottclass SubVDNode : public VectorNode {
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott protected:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual BasicType elt_basic_type() const { return T_DOUBLE; }
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott public:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  SubVDNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual int Opcode() const;
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott};
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott//------------------------------MulVFNode---------------------------------------
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott// Vector multiply float
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshottclass MulVFNode : public VectorNode {
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott protected:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual BasicType elt_basic_type() const { return T_FLOAT; }
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott public:
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell  MulVFNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell  virtual int Opcode() const;
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott};
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott//------------------------------MulVDNode---------------------------------------
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott// Vector multiply double
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshottclass MulVDNode : public VectorNode {
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott protected:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual BasicType elt_basic_type() const { return T_DOUBLE; }
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott public:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  MulVDNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual int Opcode() const;
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott};
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott//------------------------------DivVFNode---------------------------------------
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott// Vector divide float
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshottclass DivVFNode : public VectorNode {
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott protected:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual BasicType elt_basic_type() const { return T_FLOAT; }
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott public:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  DivVFNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual int Opcode() const;
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott};
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott//------------------------------DivVDNode---------------------------------------
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott// Vector Divide double
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshottclass DivVDNode : public VectorNode {
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell protected:
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell  virtual BasicType elt_basic_type() const { return T_DOUBLE; }
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott public:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  DivVDNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell  virtual int Opcode() const;
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell};
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell//------------------------------LShiftVBNode---------------------------------------
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell// Vector lshift byte
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshottclass LShiftVBNode : public VectorNode {
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott protected:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual BasicType elt_basic_type() const { return T_BYTE; }
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott public:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  LShiftVBNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual int Opcode() const;
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott};
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott//------------------------------LShiftVCNode---------------------------------------
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott// Vector lshift chars
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshottclass LShiftVCNode : public VectorNode {
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott protected:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual BasicType elt_basic_type() const { return T_CHAR; }
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott public:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  LShiftVCNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual int Opcode() const;
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott};
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott//------------------------------LShiftVSNode---------------------------------------
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott// Vector lshift shorts
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshottclass LShiftVSNode : public VectorNode {
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott protected:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual BasicType elt_basic_type() const { return T_SHORT; }
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott public:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  LShiftVSNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual int Opcode() const;
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott};
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott//------------------------------LShiftVINode---------------------------------------
465ea459a87d4605e145d8f45b6a9c104b696e3bCraig McDonnell// Vector lshift ints
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshottclass LShiftVINode : public VectorNode {
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott protected:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual BasicType elt_basic_type() const { return T_INT; }
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott public:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  LShiftVINode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual int Opcode() const;
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott};
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott//------------------------------URShiftVBNode---------------------------------------
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott// Vector urshift bytes
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshottclass URShiftVBNode : public VectorNode {
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott protected:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual BasicType elt_basic_type() const { return T_BYTE; }
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott public:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  URShiftVBNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual int Opcode() const;
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott};
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott//------------------------------URShiftVCNode---------------------------------------
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell// Vector urshift char
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnellclass URShiftVCNode : public VectorNode {
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott protected:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual BasicType elt_basic_type() const { return T_SHORT; }
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott public:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  URShiftVCNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual int Opcode() const;
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott};
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott//------------------------------URShiftVSNode---------------------------------------
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott// Vector urshift shorts
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshottclass URShiftVSNode : public VectorNode {
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott protected:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual BasicType elt_basic_type() const { return T_SHORT; }
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott public:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  URShiftVSNode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual int Opcode() const;
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott};
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott//------------------------------URShiftVINode---------------------------------------
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott// Vector urshift ints
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshottclass URShiftVINode : public VectorNode {
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott protected:
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell  virtual BasicType elt_basic_type() const { return T_INT; }
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell public:
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  URShiftVINode(Node* in1, Node* in2, uint vlen) : VectorNode(in1,in2,vlen) {}
721bb987c406979bcfe705fa1ca8d54497d40fcbRobert Wapshott  virtual int Opcode() const;
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell};
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell//------------------------------AndVNode---------------------------------------
415243fbc81341293a852ff6aa14e9608d08685cCraig McDonnell// 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; }
};