/*

 * 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

#ifndef SHARE_VM_OPTO_VECTORNODE_HPP

#define SHARE_VM_OPTO_VECTORNODE_HPP

#include "opto/matcher.hpp"

#include "opto/memnode.hpp"

#include "opto/node.hpp"

#include "opto/opcodes.hpp"

//------------------------------VectorNode--------------------------------------

// Vector Operation

  }

  virtual int Opcode() const;

  static VectorNode* scalar2vector(Compile* C, Node* s, uint vlen, const Type* opd_t);

};

//===========================Vector=ALU=Operations====================================

//------------------------------AddVBNode---------------------------------------

// Vector add byte

class AddVBNode : public VectorNode {

 public:

  virtual int Opcode() const;

};

//------------------------------AddVSNode---------------------------------------

class AddVSNode : public VectorNode {

 public:

  virtual int Opcode() const;

};

//------------------------------AddVINode---------------------------------------

// Vector add int

class AddVINode : public VectorNode {

 public:

  virtual int Opcode() const;

};

//------------------------------AddVLNode---------------------------------------

// Vector add long

class AddVLNode : public VectorNode {

 public:

  virtual int Opcode() const;

};

//------------------------------AddVFNode---------------------------------------

// Vector add float

class AddVFNode : public VectorNode {

 public:

  virtual int Opcode() const;

};

//------------------------------AddVDNode---------------------------------------

// Vector add double

class AddVDNode : public VectorNode {

 public:

  virtual int Opcode() const;

};

//------------------------------SubVBNode---------------------------------------

// Vector subtract byte

class SubVBNode : public VectorNode {

 public:

  virtual int Opcode() const;

};

//------------------------------SubVSNode---------------------------------------

// Vector subtract short

class SubVSNode : public VectorNode {

 public:

  virtual int Opcode() const;

};

//------------------------------SubVINode---------------------------------------

// Vector subtract int

class SubVINode : public VectorNode {

 public:

  virtual int Opcode() const;

};

//------------------------------SubVLNode---------------------------------------

// Vector subtract long

class SubVLNode : public VectorNode {

 public:

  virtual int Opcode() const;

};

//------------------------------SubVFNode---------------------------------------

// Vector subtract float

class SubVFNode : public VectorNode {

 public:

  virtual int Opcode() const;

};

//------------------------------SubVDNode---------------------------------------

// Vector subtract double

class SubVDNode : public VectorNode {

 public:

  virtual int Opcode() const;

};

//------------------------------MulVFNode---------------------------------------

// Vector multiply float

class MulVFNode : public VectorNode {

 public:

  virtual int Opcode() const;

};

//------------------------------MulVDNode---------------------------------------

// Vector multiply double

class MulVDNode : public VectorNode {

 public:

  virtual int Opcode() const;

};

//------------------------------DivVFNode---------------------------------------

// Vector divide float

class DivVFNode : public VectorNode {

 public:

  virtual int Opcode() const;

};

//------------------------------DivVDNode---------------------------------------

// Vector Divide double

class DivVDNode : public VectorNode {

 public:

  virtual int Opcode() const;

};

//------------------------------LShiftVBNode---------------------------------------

// Vector lshift byte

class LShiftVBNode : public VectorNode {

 public:

  virtual int Opcode() const;

};

//------------------------------LShiftVSNode---------------------------------------

// Vector lshift shorts

class LShiftVSNode : public VectorNode {

 public:

  virtual int Opcode() const;

};

//------------------------------LShiftVINode---------------------------------------

// Vector lshift ints

class LShiftVINode : public VectorNode {

 public:

  virtual int Opcode() const;

};

//------------------------------URShiftVBNode---------------------------------------

// Vector urshift bytes

 public:

  virtual int Opcode() const;

};

//------------------------------URShiftVSNode---------------------------------------

// Vector urshift shorts

 public:

  virtual int Opcode() const;

};

//------------------------------URShiftVINode---------------------------------------

// Vector urshift ints

 public:

  virtual int Opcode() const;

};

//------------------------------AndVNode---------------------------------------

// Vector and

class AndVNode : public VectorNode {

 public:

  virtual int Opcode() const;

};

//------------------------------OrVNode---------------------------------------

// Vector or

class OrVNode : public VectorNode {

 public:

  virtual int Opcode() const;

};

//------------------------------XorVNode---------------------------------------

// Vector xor

class XorVNode : public VectorNode {

 public:

  virtual int Opcode() const;

};

  }

  virtual int Opcode() const;

  virtual BasicType memory_type() const { return T_VOID; }

};

 public:

  virtual int Opcode() const;

                               Node* adr, const TypePtr* atyp, Node* val,

                               uint vlen);

};

 public:

  virtual int Opcode() const;

};

 public:

  virtual int Opcode() const;

};

 public:

  virtual int Opcode() const;

};

 public:

  virtual int Opcode() const;

};

 public:

  virtual int Opcode() const;

};

 public:

  virtual int Opcode() const;

};

//------------------------------PackNode---------------------------------------

// Pack parent class (not for code generation).

class PackNode : public VectorNode {

 public:

  virtual int Opcode() const;

  }

  // Create a binary tree form for Packs. [lo, hi) (half-open) range

  Node* binaryTreePack(Compile* C, int lo, int hi);

};

//------------------------------PackBNode---------------------------------------

// Pack byte scalars into vector

class PackBNode : public PackNode {

 public:

  virtual int Opcode() const;

};

//------------------------------PackSNode---------------------------------------

// Pack short scalars into a vector

class PackSNode : public PackNode {

 public:

  virtual int Opcode() const;

};

//------------------------------PackINode---------------------------------------

// Pack integer scalars into a vector

class PackINode : public PackNode {

 public:

  virtual int Opcode() const;

};

//------------------------------PackLNode---------------------------------------

// Pack long scalars into a vector

class PackLNode : public PackNode {

 public:

  virtual int Opcode() const;

};

//------------------------------PackFNode---------------------------------------

// Pack float scalars into vector

class PackFNode : public PackNode {

 public:

  virtual int Opcode() const;

};

//------------------------------PackDNode---------------------------------------

// Pack double scalars into a vector

class PackDNode : public PackNode {

 public:

  virtual int Opcode() const;

};

 public:

  virtual int Opcode() const;

};

//========================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(); }

};

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