*** old/src/share/vm/opto/vectornode.hpp	Thu Jul 26 18:06:28 2012
--- new/src/share/vm/opto/vectornode.hpp	Thu Jul 26 18:06:28 2012

*** 44,53 ****
--- 44,54 ----
      init_req(2, n2);
    }
  
    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()); }
  

*** 55,65 ****
--- 56,67 ----
  
    static VectorNode* make(Compile* C, int opc, Node* n1, Node* n2, uint vlen, BasicType bt);
  
    static int  opcode(int opc, uint vlen, BasicType bt);
    static bool implemented(int opc, uint vlen, BasicType bt);
  
+   static bool is_shift(Node* n);
+   static bool is_invariant_vector(Node* n);
  };
  
  //===========================Vector=ALU=Operations====================================
  
  //------------------------------AddVBNode---------------------------------------

*** 156,165 ****
--- 158,183 ----
   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;
+ };
+ 
  //------------------------------MulVFNode---------------------------------------
  // Vector multiply float
  class MulVFNode : public VectorNode {
   public:
    MulVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}

*** 189,263 ****
--- 207,330 ----
    DivVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
    virtual int Opcode() const;
  };
  
  //------------------------------LShiftVBNode---------------------------------------
! // Vector lshift byte
! // 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 lshift shorts
! // 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 lshift ints
! // 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;
  };
  
! //------------------------------URShiftVBNode---------------------------------------
! // Vector urshift bytes
! //------------------------------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;
  };
  
- //------------------------------URShiftVSNode---------------------------------------
! // Vector urshift shorts
! // 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;
  };
  
- //------------------------------URShiftVINode---------------------------------------
! // Vector urshift ints
! // 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;
+ };
+ 
+ 
  //------------------------------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;
  };
  
  //------------------------------XorVNode---------------------------------------
! // Vector xor integer
  class XorVNode : public VectorNode {
   public:
    XorVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {}
    virtual int Opcode() const;
  };