/*

 * Copyright (c) 2007, 2014, Oracle and/or its affiliates. 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 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

class VectorNode : public TypeNode {

 public:

  VectorNode(Node* n1, const TypeVect* vt) : TypeNode(vt, 2) {

    init_class_id(Class_Vector);

    init_req(1, n1);

  }

  VectorNode(Node* n1, Node* n2, const TypeVect* vt) : TypeNode(vt, 3) {

    init_class_id(Class_Vector);

    init_req(1, n1);

    init_req(2, n2);

  }

  VectorNode(Node* n1, Node* n2, Node* n3, const TypeVect* vt) : TypeNode(vt, 4) {

    init_class_id(Class_Vector);

    init_req(1, n1);

    init_req(2, n2);

    init_req(3, n3);

  }

  const TypeVect* vect_type() const { return type()->is_vect(); }

  uint length() const { return vect_type()->length(); } // Vector length

  uint length_in_bytes() const { return vect_type()->length_in_bytes(); }

  virtual int Opcode() const;

  virtual uint ideal_reg() const { return Matcher::vector_ideal_reg(vect_type()->length_in_bytes()); }

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

  static VectorNode* shift_count(Node* shift, Node* cnt, uint vlen, BasicType bt);

  static VectorNode* make(int opc, Node* n1, Node* n2, uint vlen, BasicType bt);

  static int  opcode(int opc, BasicType bt);

  static bool implemented(int opc, uint vlen, BasicType bt);

  static bool is_shift(Node* n);

  static bool is_invariant_vector(Node* n);

  // [Start, end) half-open range defining which operands are vectors

  static void vector_operands(Node* n, uint* start, uint* end);

};

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

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

// Vector add byte

class AddVBNode : public VectorNode {

 public:

  AddVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

  virtual int Opcode() const;

};

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

// Vector add char/short

class AddVSNode : public VectorNode {

 public:

  AddVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

  virtual int Opcode() const;

};

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

// Vector add int

class AddVINode : public VectorNode {

 public:

  AddVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

  virtual int Opcode() const;

};

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

// Vector add long

class AddVLNode : public VectorNode {

public:

  AddVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {}

  virtual int Opcode() const;

};

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

// Vector add float

class AddVFNode : public VectorNode {

public:

  AddVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {}

  virtual int Opcode() const;

};

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

// Vector add double

class AddVDNode : public VectorNode {

public:

  AddVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {}

  virtual int Opcode() const;

};

//------------------------------ReductionNode------------------------------------

// Perform reduction of a vector

class ReductionNode : public Node {

 public:

  ReductionNode(Node *ctrl, Node* in1, Node* in2) : Node(ctrl, in1, in2) {}

  static ReductionNode* make(int opc, Node *ctrl, Node* in1, Node* in2, BasicType bt);

  static int  opcode(int opc, BasicType bt);

  static bool implemented(int opc, uint vlen, BasicType bt);

};

//------------------------------AddReductionVINode--------------------------------------

// Vector add int as a reduction

class AddReductionVINode : public ReductionNode {

public:

  AddReductionVINode(Node * ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}

  virtual int Opcode() const;

  virtual const Type* bottom_type() const { return TypeInt::INT; }

  virtual uint ideal_reg() const { return Op_RegI; }

};

//------------------------------AddReductionVLNode--------------------------------------

// Vector add long as a reduction

class AddReductionVLNode : public ReductionNode {

public:

  AddReductionVLNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}

  virtual int Opcode() const;

  virtual const Type* bottom_type() const { return TypeLong::LONG; }

  virtual uint ideal_reg() const { return Op_RegL; }

};

//------------------------------AddReductionVFNode--------------------------------------

// Vector add float as a reduction

class AddReductionVFNode : public ReductionNode {

public:

  AddReductionVFNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}

  virtual int Opcode() const;

  virtual const Type* bottom_type() const { return Type::FLOAT; }

  virtual uint ideal_reg() const { return Op_RegF; }

};

//------------------------------AddReductionVDNode--------------------------------------

// Vector add double as a reduction

class AddReductionVDNode : public ReductionNode {

public:

  AddReductionVDNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}

  virtual int Opcode() const;

  virtual const Type* bottom_type() const { return Type::DOUBLE; }

  virtual uint ideal_reg() const { return Op_RegD; }

};

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

// Vector subtract byte

class SubVBNode : public VectorNode {

 public:

  SubVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

  virtual int Opcode() const;

};

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

// Vector subtract short

class SubVSNode : public VectorNode {

 public:

  SubVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

  virtual int Opcode() const;

};

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

// Vector subtract int

class SubVINode : public VectorNode {

 public:

  SubVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

  virtual int Opcode() const;

};

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

// Vector subtract long

class SubVLNode : public VectorNode {

 public:

  SubVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

  virtual int Opcode() const;

};

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

// Vector subtract float

class SubVFNode : public VectorNode {

 public:

  SubVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

  virtual int Opcode() const;

};

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

// Vector subtract double

class SubVDNode : public VectorNode {

 public:

  SubVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

  virtual int Opcode() const;

};

//------------------------------MulVSNode--------------------------------------

// Vector multiply short

class MulVSNode : public VectorNode {

 public:

  MulVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

  virtual int Opcode() const;

};

//------------------------------MulVINode--------------------------------------

// Vector multiply int

class MulVINode : public VectorNode {

 public:

  MulVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

  virtual int Opcode() const;

};

//------------------------------MulVLNode--------------------------------------

// Vector multiply long

class MulVLNode : public VectorNode {

public:

  MulVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {}

  virtual int Opcode() const;

};

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

// Vector multiply float

class MulVFNode : public VectorNode {

public:

  MulVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {}

  virtual int Opcode() const;

};

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

// Vector multiply double

class MulVDNode : public VectorNode {

public:

  MulVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {}

  virtual int Opcode() const;

};

//------------------------------CMoveVDNode--------------------------------------

// Vector multiply double

class CMoveVDNode : public VectorNode {

public:

  CMoveVDNode(Node* in1, Node* in2, Node* in3, const TypeVect* vt) : VectorNode(in1, in2, in3, vt) {}

  virtual int Opcode() const;

};

//------------------------------MulReductionVINode--------------------------------------

// Vector multiply int as a reduction

class MulReductionVINode : public ReductionNode {

public:

  MulReductionVINode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}

  virtual int Opcode() const;

  virtual const Type* bottom_type() const { return TypeInt::INT; }

  virtual uint ideal_reg() const { return Op_RegI; }

};

//------------------------------MulReductionVLNode--------------------------------------

// Vector multiply int as a reduction

class MulReductionVLNode : public ReductionNode {

public:

  MulReductionVLNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}

  virtual int Opcode() const;

  virtual const Type* bottom_type() const { return TypeLong::LONG; }

  virtual uint ideal_reg() const { return Op_RegI; }

};

//------------------------------MulReductionVFNode--------------------------------------

// Vector multiply float as a reduction

class MulReductionVFNode : public ReductionNode {

public:

  MulReductionVFNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}

  virtual int Opcode() const;

  virtual const Type* bottom_type() const { return Type::FLOAT; }

  virtual uint ideal_reg() const { return Op_RegF; }

};

//------------------------------MulReductionVDNode--------------------------------------

// Vector multiply double as a reduction

class MulReductionVDNode : public ReductionNode {

public:

  MulReductionVDNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {}

  virtual int Opcode() const;

  virtual const Type* bottom_type() const { return Type::DOUBLE; }

  virtual uint ideal_reg() const { return Op_RegD; }

};

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

// Vector divide float

class DivVFNode : public VectorNode {

 public:

  DivVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

  virtual int Opcode() const;

};

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

// Vector Divide double

class DivVDNode : public VectorNode {

 public:

  DivVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

  virtual int Opcode() const;

};

//------------------------------AbsVFNode--------------------------------------

// Vector Abs float

class AbsVFNode : public VectorNode {

 public:

  AbsVFNode(Node* in, const TypeVect* vt) : VectorNode(in,vt) {}

  virtual int Opcode() const;

};

//------------------------------AbsVDNode--------------------------------------

// Vector Abs double

class AbsVDNode : public VectorNode {

 public:

  AbsVDNode(Node* in, const TypeVect* vt) : VectorNode(in,vt) {}

  virtual int Opcode() const;

};

//------------------------------NegVFNode--------------------------------------

// Vector Neg float

class NegVFNode : public VectorNode {

 public:

  NegVFNode(Node* in, const TypeVect* vt) : VectorNode(in,vt) {}

  virtual int Opcode() const;

};

//------------------------------NegVDNode--------------------------------------

// Vector Neg double

class NegVDNode : public VectorNode {

 public:

  NegVDNode(Node* in, const TypeVect* vt) : VectorNode(in,vt) {}

  virtual int Opcode() const;

};

//------------------------------SqrtVDNode--------------------------------------

// Vector Sqrt double

class SqrtVDNode : public VectorNode {

 public:

  SqrtVDNode(Node* in, const TypeVect* vt) : VectorNode(in,vt) {}

  virtual int Opcode() const;

};

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

// Vector left shift bytes

class LShiftVBNode : public VectorNode {

 public:

  LShiftVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

  virtual int Opcode() const;

};

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

// Vector left shift shorts

class LShiftVSNode : public VectorNode {

 public:

  LShiftVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

  virtual int Opcode() const;

};

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

// Vector left shift ints

class LShiftVINode : public VectorNode {

 public:

  LShiftVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

  virtual int Opcode() const;

};

//------------------------------LShiftVLNode-----------------------------------

// Vector left shift longs

class LShiftVLNode : public VectorNode {

 public:

  LShiftVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

  virtual int Opcode() const;

};

//------------------------------RShiftVBNode-----------------------------------

// Vector right arithmetic (signed) shift bytes

class RShiftVBNode : public VectorNode {

 public:

  RShiftVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

  virtual int Opcode() const;

};

//------------------------------RShiftVSNode-----------------------------------

// Vector right arithmetic (signed) shift shorts

class RShiftVSNode : public VectorNode {

 public:

  RShiftVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

  virtual int Opcode() const;

};

//------------------------------RShiftVINode-----------------------------------

// Vector right arithmetic (signed) shift ints

class RShiftVINode : public VectorNode {

 public:

  RShiftVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

  virtual int Opcode() const;

};

//------------------------------RShiftVLNode-----------------------------------

// Vector right arithmetic (signed) shift longs

class RShiftVLNode : public VectorNode {

 public:

  RShiftVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

  virtual int Opcode() const;

};

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

// Vector right logical (unsigned) shift bytes

class URShiftVBNode : public VectorNode {

 public:

  URShiftVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

  virtual int Opcode() const;

};

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

// Vector right logical (unsigned) shift shorts

class URShiftVSNode : public VectorNode {

 public:

  URShiftVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

  virtual int Opcode() const;

};

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

// Vector right logical (unsigned) shift ints

class URShiftVINode : public VectorNode {

 public:

  URShiftVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

  virtual int Opcode() const;

};

//------------------------------URShiftVLNode----------------------------------

// Vector right logical (unsigned) shift longs

class URShiftVLNode : public VectorNode {

 public:

  URShiftVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

  virtual int Opcode() const;

};

//------------------------------LShiftCntVNode---------------------------------

// Vector left shift count

class LShiftCntVNode : public VectorNode {

 public:

  LShiftCntVNode(Node* cnt, const TypeVect* vt) : VectorNode(cnt,vt) {}

  virtual int Opcode() const;

  virtual uint ideal_reg() const { return Matcher::vector_shift_count_ideal_reg(vect_type()->length_in_bytes()); }

};

//------------------------------RShiftCntVNode---------------------------------

// Vector right shift count

class RShiftCntVNode : public VectorNode {

 public:

  RShiftCntVNode(Node* cnt, const TypeVect* vt) : VectorNode(cnt,vt) {}

  virtual int Opcode() const;

  virtual uint ideal_reg() const { return Matcher::vector_shift_count_ideal_reg(vect_type()->length_in_bytes()); }

};

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

// Vector and integer

class AndVNode : public VectorNode {

 public:

  AndVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

  virtual int Opcode() const;

};

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

// Vector or integer

class OrVNode : public VectorNode {

 public:

  OrVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

  virtual int Opcode() const;