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