*** old/src/share/vm/opto/vectornode.hpp	Tue Sep 25 18:37:43 2012
--- new/src/share/vm/opto/vectornode.hpp	Tue Sep 25 18:37:43 2012

*** 51,61 ****
--- 51,61 ----
    virtual int Opcode() const;
  
    virtual uint ideal_reg() const { return Matcher::vector_ideal_reg(vect_type()->length_in_bytes()); }
  
    static VectorNode* scalar2vector(Compile* C, Node* s, uint vlen, const Type* opd_t);
  
+   static VectorNode* shift_count(Compile* C, Node* shift, Node* cnt, uint vlen, BasicType bt);
    static VectorNode* make(Compile* C, 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);

*** 62,72 ****
--- 62,72 ----
    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====================================
! //===========================Vector=ALU=Operations==============================
  
  //------------------------------AddVBNode---------------------------------------
  // Vector add byte
  class AddVBNode : public VectorNode {
   public:

*** 208,313 ****
--- 208,331 ----
   public:
    DivVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
    virtual int Opcode() const;
  };
  
! //------------------------------LShiftVBNode---------------------------------------
! //------------------------------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---------------------------------------
! //------------------------------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---------------------------------------
! //------------------------------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---------------------------------------
! //------------------------------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---------------------------------------
! //------------------------------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---------------------------------------
! //------------------------------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---------------------------------------
! //------------------------------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---------------------------------------
! //------------------------------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---------------------------------------
! //------------------------------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---------------------------------------
! //------------------------------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---------------------------------------
! //------------------------------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---------------------------------------
! //------------------------------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: