aoqi@0: /*
aoqi@0:  * Copyright (c) 2007, 2012, Oracle and/or its affiliates. All rights reserved.
aoqi@0:  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
aoqi@0:  *
aoqi@0:  * This code is free software; you can redistribute it and/or modify it
aoqi@0:  * under the terms of the GNU General Public License version 2 only, as
aoqi@0:  * published by the Free Software Foundation.
aoqi@0:  *
aoqi@0:  * This code is distributed in the hope that it will be useful, but WITHOUT
aoqi@0:  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
aoqi@0:  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
aoqi@0:  * version 2 for more details (a copy is included in the LICENSE file that
aoqi@0:  * accompanied this code).
aoqi@0:  *
aoqi@0:  * You should have received a copy of the GNU General Public License version
aoqi@0:  * 2 along with this work; if not, write to the Free Software Foundation,
aoqi@0:  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
aoqi@0:  *
aoqi@0:  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
aoqi@0:  * or visit www.oracle.com if you need additional information or have any
aoqi@0:  * questions.
aoqi@0:  */
aoqi@0: 
aoqi@0: #ifndef SHARE_VM_OPTO_VECTORNODE_HPP
aoqi@0: #define SHARE_VM_OPTO_VECTORNODE_HPP
aoqi@0: 
aoqi@0: #include "opto/matcher.hpp"
aoqi@0: #include "opto/memnode.hpp"
aoqi@0: #include "opto/node.hpp"
aoqi@0: #include "opto/opcodes.hpp"
aoqi@0: 
aoqi@0: //------------------------------VectorNode-------------------------------------
aoqi@0: // Vector Operation
aoqi@0: class VectorNode : public TypeNode {
aoqi@0:  public:
aoqi@0: 
aoqi@0:   VectorNode(Node* n1, const TypeVect* vt) : TypeNode(vt, 2) {
aoqi@0:     init_class_id(Class_Vector);
aoqi@0:     init_req(1, n1);
aoqi@0:   }
aoqi@0:   VectorNode(Node* n1, Node* n2, const TypeVect* vt) : TypeNode(vt, 3) {
aoqi@0:     init_class_id(Class_Vector);
aoqi@0:     init_req(1, n1);
aoqi@0:     init_req(2, n2);
aoqi@0:   }
aoqi@0: 
aoqi@0:   const TypeVect* vect_type() const { return type()->is_vect(); }
aoqi@0:   uint length() const { return vect_type()->length(); } // Vector length
aoqi@0:   uint length_in_bytes() const { return vect_type()->length_in_bytes(); }
aoqi@0: 
aoqi@0:   virtual int Opcode() const;
aoqi@0: 
aoqi@0:   virtual uint ideal_reg() const { return Matcher::vector_ideal_reg(vect_type()->length_in_bytes()); }
aoqi@0: 
aoqi@0:   static VectorNode* scalar2vector(Compile* C, Node* s, uint vlen, const Type* opd_t);
aoqi@0:   static VectorNode* shift_count(Compile* C, Node* shift, Node* cnt, uint vlen, BasicType bt);
aoqi@0:   static VectorNode* make(Compile* C, int opc, Node* n1, Node* n2, uint vlen, BasicType bt);
aoqi@0: 
aoqi@0:   static int  opcode(int opc, BasicType bt);
aoqi@0:   static bool implemented(int opc, uint vlen, BasicType bt);
aoqi@0:   static bool is_shift(Node* n);
aoqi@0:   static bool is_invariant_vector(Node* n);
aoqi@0:   // [Start, end) half-open range defining which operands are vectors
aoqi@0:   static void vector_operands(Node* n, uint* start, uint* end);
aoqi@0: };
aoqi@0: 
aoqi@0: //===========================Vector=ALU=Operations=============================
aoqi@0: 
aoqi@0: //------------------------------AddVBNode--------------------------------------
aoqi@0: // Vector add byte
aoqi@0: class AddVBNode : public VectorNode {
aoqi@0:  public:
aoqi@0:   AddVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------AddVSNode--------------------------------------
aoqi@0: // Vector add char/short
aoqi@0: class AddVSNode : public VectorNode {
aoqi@0:  public:
aoqi@0:   AddVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------AddVINode--------------------------------------
aoqi@0: // Vector add int
aoqi@0: class AddVINode : public VectorNode {
aoqi@0:  public:
aoqi@0:   AddVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------AddVLNode--------------------------------------
aoqi@0: // Vector add long
aoqi@0: class AddVLNode : public VectorNode {
aoqi@0:  public:
aoqi@0:   AddVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------AddVFNode--------------------------------------
aoqi@0: // Vector add float
aoqi@0: class AddVFNode : public VectorNode {
aoqi@0:  public:
aoqi@0:   AddVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------AddVDNode--------------------------------------
aoqi@0: // Vector add double
aoqi@0: class AddVDNode : public VectorNode {
aoqi@0:  public:
aoqi@0:   AddVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------SubVBNode--------------------------------------
aoqi@0: // Vector subtract byte
aoqi@0: class SubVBNode : public VectorNode {
aoqi@0:  public:
aoqi@0:   SubVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------SubVSNode--------------------------------------
aoqi@0: // Vector subtract short
aoqi@0: class SubVSNode : public VectorNode {
aoqi@0:  public:
aoqi@0:   SubVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------SubVINode--------------------------------------
aoqi@0: // Vector subtract int
aoqi@0: class SubVINode : public VectorNode {
aoqi@0:  public:
aoqi@0:   SubVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------SubVLNode--------------------------------------
aoqi@0: // Vector subtract long
aoqi@0: class SubVLNode : public VectorNode {
aoqi@0:  public:
aoqi@0:   SubVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------SubVFNode--------------------------------------
aoqi@0: // Vector subtract float
aoqi@0: class SubVFNode : public VectorNode {
aoqi@0:  public:
aoqi@0:   SubVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------SubVDNode--------------------------------------
aoqi@0: // Vector subtract double
aoqi@0: class SubVDNode : public VectorNode {
aoqi@0:  public:
aoqi@0:   SubVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------MulVSNode--------------------------------------
aoqi@0: // Vector multiply short
aoqi@0: class MulVSNode : public VectorNode {
aoqi@0:  public:
aoqi@0:   MulVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------MulVINode--------------------------------------
aoqi@0: // Vector multiply int
aoqi@0: class MulVINode : public VectorNode {
aoqi@0:  public:
aoqi@0:   MulVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------MulVFNode--------------------------------------
aoqi@0: // Vector multiply float
aoqi@0: class MulVFNode : public VectorNode {
aoqi@0:  public:
aoqi@0:   MulVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------MulVDNode--------------------------------------
aoqi@0: // Vector multiply double
aoqi@0: class MulVDNode : public VectorNode {
aoqi@0:  public:
aoqi@0:   MulVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------DivVFNode--------------------------------------
aoqi@0: // Vector divide float
aoqi@0: class DivVFNode : public VectorNode {
aoqi@0:  public:
aoqi@0:   DivVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------DivVDNode--------------------------------------
aoqi@0: // Vector Divide double
aoqi@0: class DivVDNode : public VectorNode {
aoqi@0:  public:
aoqi@0:   DivVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------LShiftVBNode-----------------------------------
aoqi@0: // Vector left shift bytes
aoqi@0: class LShiftVBNode : public VectorNode {
aoqi@0:  public:
aoqi@0:   LShiftVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------LShiftVSNode-----------------------------------
aoqi@0: // Vector left shift shorts
aoqi@0: class LShiftVSNode : public VectorNode {
aoqi@0:  public:
aoqi@0:   LShiftVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------LShiftVINode-----------------------------------
aoqi@0: // Vector left shift ints
aoqi@0: class LShiftVINode : public VectorNode {
aoqi@0:  public:
aoqi@0:   LShiftVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------LShiftVLNode-----------------------------------
aoqi@0: // Vector left shift longs
aoqi@0: class LShiftVLNode : public VectorNode {
aoqi@0:  public:
aoqi@0:   LShiftVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------RShiftVBNode-----------------------------------
aoqi@0: // Vector right arithmetic (signed) shift bytes
aoqi@0: class RShiftVBNode : public VectorNode {
aoqi@0:  public:
aoqi@0:   RShiftVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------RShiftVSNode-----------------------------------
aoqi@0: // Vector right arithmetic (signed) shift shorts
aoqi@0: class RShiftVSNode : public VectorNode {
aoqi@0:  public:
aoqi@0:   RShiftVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------RShiftVINode-----------------------------------
aoqi@0: // Vector right arithmetic (signed) shift ints
aoqi@0: class RShiftVINode : public VectorNode {
aoqi@0:  public:
aoqi@0:   RShiftVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------RShiftVLNode-----------------------------------
aoqi@0: // Vector right arithmetic (signed) shift longs
aoqi@0: class RShiftVLNode : public VectorNode {
aoqi@0:  public:
aoqi@0:   RShiftVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------URShiftVBNode----------------------------------
aoqi@0: // Vector right logical (unsigned) shift bytes
aoqi@0: class URShiftVBNode : public VectorNode {
aoqi@0:  public:
aoqi@0:   URShiftVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------URShiftVSNode----------------------------------
aoqi@0: // Vector right logical (unsigned) shift shorts
aoqi@0: class URShiftVSNode : public VectorNode {
aoqi@0:  public:
aoqi@0:   URShiftVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------URShiftVINode----------------------------------
aoqi@0: // Vector right logical (unsigned) shift ints
aoqi@0: class URShiftVINode : public VectorNode {
aoqi@0:  public:
aoqi@0:   URShiftVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------URShiftVLNode----------------------------------
aoqi@0: // Vector right logical (unsigned) shift longs
aoqi@0: class URShiftVLNode : public VectorNode {
aoqi@0:  public:
aoqi@0:   URShiftVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------LShiftCntVNode---------------------------------
aoqi@0: // Vector left shift count
aoqi@0: class LShiftCntVNode : public VectorNode {
aoqi@0:  public:
aoqi@0:   LShiftCntVNode(Node* cnt, const TypeVect* vt) : VectorNode(cnt,vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0:   virtual uint ideal_reg() const { return Matcher::vector_shift_count_ideal_reg(vect_type()->length_in_bytes()); }
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------RShiftCntVNode---------------------------------
aoqi@0: // Vector right shift count
aoqi@0: class RShiftCntVNode : public VectorNode {
aoqi@0:  public:
aoqi@0:   RShiftCntVNode(Node* cnt, const TypeVect* vt) : VectorNode(cnt,vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0:   virtual uint ideal_reg() const { return Matcher::vector_shift_count_ideal_reg(vect_type()->length_in_bytes()); }
aoqi@0: };
aoqi@0: 
aoqi@0: 
aoqi@0: //------------------------------AndVNode---------------------------------------
aoqi@0: // Vector and integer
aoqi@0: class AndVNode : public VectorNode {
aoqi@0:  public:
aoqi@0:   AndVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------OrVNode---------------------------------------
aoqi@0: // Vector or integer
aoqi@0: class OrVNode : public VectorNode {
aoqi@0:  public:
aoqi@0:   OrVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------XorVNode---------------------------------------
aoqi@0: // Vector xor integer
aoqi@0: class XorVNode : public VectorNode {
aoqi@0:  public:
aoqi@0:   XorVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //================================= M E M O R Y ===============================
aoqi@0: 
aoqi@0: //------------------------------LoadVectorNode---------------------------------
aoqi@0: // Load Vector from memory
aoqi@0: class LoadVectorNode : public LoadNode {
aoqi@0:  public:
aoqi@0:   LoadVectorNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeVect* vt)
aoqi@0:     : LoadNode(c, mem, adr, at, vt, MemNode::unordered) {
aoqi@0:     init_class_id(Class_LoadVector);
aoqi@0:   }
aoqi@0: 
aoqi@0:   const TypeVect* vect_type() const { return type()->is_vect(); }
aoqi@0:   uint length() const { return vect_type()->length(); } // Vector length
aoqi@0: 
aoqi@0:   virtual int Opcode() const;
aoqi@0: 
aoqi@0:   virtual uint ideal_reg() const  { return Matcher::vector_ideal_reg(memory_size()); }
aoqi@0:   virtual BasicType memory_type() const { return T_VOID; }
aoqi@0:   virtual int memory_size() const { return vect_type()->length_in_bytes(); }
aoqi@0: 
aoqi@0:   virtual int store_Opcode() const { return Op_StoreVector; }
aoqi@0: 
aoqi@0:   static LoadVectorNode* make(Compile* C, int opc, Node* ctl, Node* mem,
aoqi@0:                               Node* adr, const TypePtr* atyp, uint vlen, BasicType bt);
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------StoreVectorNode--------------------------------
aoqi@0: // Store Vector to memory
aoqi@0: class StoreVectorNode : public StoreNode {
aoqi@0:  public:
aoqi@0:   StoreVectorNode(Node* c, Node* mem, Node* adr, const TypePtr* at, Node* val)
aoqi@0:     : StoreNode(c, mem, adr, at, val, MemNode::unordered) {
aoqi@0:     assert(val->is_Vector() || val->is_LoadVector(), "sanity");
aoqi@0:     init_class_id(Class_StoreVector);
aoqi@0:   }
aoqi@0: 
aoqi@0:   const TypeVect* vect_type() const { return in(MemNode::ValueIn)->bottom_type()->is_vect(); }
aoqi@0:   uint length() const { return vect_type()->length(); } // Vector length
aoqi@0: 
aoqi@0:   virtual int Opcode() const;
aoqi@0: 
aoqi@0:   virtual uint ideal_reg() const  { return Matcher::vector_ideal_reg(memory_size()); }
aoqi@0:   virtual BasicType memory_type() const { return T_VOID; }
aoqi@0:   virtual int memory_size() const { return vect_type()->length_in_bytes(); }
aoqi@0: 
aoqi@0:   static StoreVectorNode* make(Compile* C, int opc, Node* ctl, Node* mem,
aoqi@0:                                Node* adr, const TypePtr* atyp, Node* val,
aoqi@0:                                uint vlen);
aoqi@0: };
aoqi@0: 
aoqi@0: 
aoqi@0: //=========================Promote_Scalar_to_Vector============================
aoqi@0: 
aoqi@0: //------------------------------ReplicateBNode---------------------------------
aoqi@0: // Replicate byte scalar to be vector
aoqi@0: class ReplicateBNode : public VectorNode {
aoqi@0:  public:
aoqi@0:   ReplicateBNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------ReplicateSNode---------------------------------
aoqi@0: // Replicate short scalar to be vector
aoqi@0: class ReplicateSNode : public VectorNode {
aoqi@0:  public:
aoqi@0:   ReplicateSNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------ReplicateINode---------------------------------
aoqi@0: // Replicate int scalar to be vector
aoqi@0: class ReplicateINode : public VectorNode {
aoqi@0:  public:
aoqi@0:   ReplicateINode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------ReplicateLNode---------------------------------
aoqi@0: // Replicate long scalar to be vector
aoqi@0: class ReplicateLNode : public VectorNode {
aoqi@0:  public:
aoqi@0:   ReplicateLNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------ReplicateFNode---------------------------------
aoqi@0: // Replicate float scalar to be vector
aoqi@0: class ReplicateFNode : public VectorNode {
aoqi@0:  public:
aoqi@0:   ReplicateFNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------ReplicateDNode---------------------------------
aoqi@0: // Replicate double scalar to be vector
aoqi@0: class ReplicateDNode : public VectorNode {
aoqi@0:  public:
aoqi@0:   ReplicateDNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //========================Pack_Scalars_into_a_Vector===========================
aoqi@0: 
aoqi@0: //------------------------------PackNode---------------------------------------
aoqi@0: // Pack parent class (not for code generation).
aoqi@0: class PackNode : public VectorNode {
aoqi@0:  public:
aoqi@0:   PackNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {}
aoqi@0:   PackNode(Node* in1, Node* n2, const TypeVect* vt) : VectorNode(in1, n2, vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: 
aoqi@0:   void add_opd(Node* n) {
aoqi@0:     add_req(n);
aoqi@0:   }
aoqi@0: 
aoqi@0:   // Create a binary tree form for Packs. [lo, hi) (half-open) range
aoqi@0:   PackNode* binary_tree_pack(Compile* C, int lo, int hi);
aoqi@0: 
aoqi@0:   static PackNode* make(Compile* C, Node* s, uint vlen, BasicType bt);
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------PackBNode--------------------------------------
aoqi@0: // Pack byte scalars into vector
aoqi@0: class PackBNode : public PackNode {
aoqi@0:  public:
aoqi@0:   PackBNode(Node* in1, const TypeVect* vt)  : PackNode(in1, vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------PackSNode--------------------------------------
aoqi@0: // Pack short scalars into a vector
aoqi@0: class PackSNode : public PackNode {
aoqi@0:  public:
aoqi@0:   PackSNode(Node* in1, const TypeVect* vt)  : PackNode(in1, vt) {}
aoqi@0:   PackSNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------PackINode--------------------------------------
aoqi@0: // Pack integer scalars into a vector
aoqi@0: class PackINode : public PackNode {
aoqi@0:  public:
aoqi@0:   PackINode(Node* in1, const TypeVect* vt)  : PackNode(in1, vt) {}
aoqi@0:   PackINode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------PackLNode--------------------------------------
aoqi@0: // Pack long scalars into a vector
aoqi@0: class PackLNode : public PackNode {
aoqi@0:  public:
aoqi@0:   PackLNode(Node* in1, const TypeVect* vt)  : PackNode(in1, vt) {}
aoqi@0:   PackLNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------Pack2LNode-------------------------------------
aoqi@0: // Pack 2 long scalars into a vector
aoqi@0: class Pack2LNode : public PackNode {
aoqi@0:  public:
aoqi@0:   Pack2LNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------PackFNode--------------------------------------
aoqi@0: // Pack float scalars into vector
aoqi@0: class PackFNode : public PackNode {
aoqi@0:  public:
aoqi@0:   PackFNode(Node* in1, const TypeVect* vt)  : PackNode(in1, vt) {}
aoqi@0:   PackFNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------PackDNode--------------------------------------
aoqi@0: // Pack double scalars into a vector
aoqi@0: class PackDNode : public PackNode {
aoqi@0:  public:
aoqi@0:   PackDNode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {}
aoqi@0:   PackDNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------Pack2DNode-------------------------------------
aoqi@0: // Pack 2 double scalars into a vector
aoqi@0: class Pack2DNode : public PackNode {
aoqi@0:  public:
aoqi@0:   Pack2DNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0: };
aoqi@0: 
aoqi@0: 
aoqi@0: //========================Extract_Scalar_from_Vector===========================
aoqi@0: 
aoqi@0: //------------------------------ExtractNode------------------------------------
aoqi@0: // Extract a scalar from a vector at position "pos"
aoqi@0: class ExtractNode : public Node {
aoqi@0:  public:
aoqi@0:   ExtractNode(Node* src, ConINode* pos) : Node(NULL, src, (Node*)pos) {
aoqi@0:     assert(in(2)->get_int() >= 0, "positive constants");
aoqi@0:   }
aoqi@0:   virtual int Opcode() const;
aoqi@0:   uint  pos() const { return in(2)->get_int(); }
aoqi@0: 
aoqi@0:   static Node* make(Compile* C, Node* v, uint position, BasicType bt);
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------ExtractBNode-----------------------------------
aoqi@0: // Extract a byte from a vector at position "pos"
aoqi@0: class ExtractBNode : public ExtractNode {
aoqi@0:  public:
aoqi@0:   ExtractBNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0:   virtual const Type *bottom_type() const { return TypeInt::INT; }
aoqi@0:   virtual uint ideal_reg() const { return Op_RegI; }
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------ExtractUBNode----------------------------------
aoqi@0: // Extract a boolean from a vector at position "pos"
aoqi@0: class ExtractUBNode : public ExtractNode {
aoqi@0:  public:
aoqi@0:   ExtractUBNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0:   virtual const Type *bottom_type() const { return TypeInt::INT; }
aoqi@0:   virtual uint ideal_reg() const { return Op_RegI; }
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------ExtractCNode-----------------------------------
aoqi@0: // Extract a char from a vector at position "pos"
aoqi@0: class ExtractCNode : public ExtractNode {
aoqi@0:  public:
aoqi@0:   ExtractCNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0:   virtual const Type *bottom_type() const { return TypeInt::INT; }
aoqi@0:   virtual uint ideal_reg() const { return Op_RegI; }
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------ExtractSNode-----------------------------------
aoqi@0: // Extract a short from a vector at position "pos"
aoqi@0: class ExtractSNode : public ExtractNode {
aoqi@0:  public:
aoqi@0:   ExtractSNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0:   virtual const Type *bottom_type() const { return TypeInt::INT; }
aoqi@0:   virtual uint ideal_reg() const { return Op_RegI; }
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------ExtractINode-----------------------------------
aoqi@0: // Extract an int from a vector at position "pos"
aoqi@0: class ExtractINode : public ExtractNode {
aoqi@0:  public:
aoqi@0:   ExtractINode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0:   virtual const Type *bottom_type() const { return TypeInt::INT; }
aoqi@0:   virtual uint ideal_reg() const { return Op_RegI; }
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------ExtractLNode-----------------------------------
aoqi@0: // Extract a long from a vector at position "pos"
aoqi@0: class ExtractLNode : public ExtractNode {
aoqi@0:  public:
aoqi@0:   ExtractLNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0:   virtual const Type *bottom_type() const { return TypeLong::LONG; }
aoqi@0:   virtual uint ideal_reg() const { return Op_RegL; }
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------ExtractFNode-----------------------------------
aoqi@0: // Extract a float from a vector at position "pos"
aoqi@0: class ExtractFNode : public ExtractNode {
aoqi@0:  public:
aoqi@0:   ExtractFNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0:   virtual const Type *bottom_type() const { return Type::FLOAT; }
aoqi@0:   virtual uint ideal_reg() const { return Op_RegF; }
aoqi@0: };
aoqi@0: 
aoqi@0: //------------------------------ExtractDNode-----------------------------------
aoqi@0: // Extract a double from a vector at position "pos"
aoqi@0: class ExtractDNode : public ExtractNode {
aoqi@0:  public:
aoqi@0:   ExtractDNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {}
aoqi@0:   virtual int Opcode() const;
aoqi@0:   virtual const Type *bottom_type() const { return Type::DOUBLE; }
aoqi@0:   virtual uint ideal_reg() const { return Op_RegD; }
aoqi@0: };
aoqi@0: 
aoqi@0: #endif // SHARE_VM_OPTO_VECTORNODE_HPP