src/share/vm/opto/vectornode.cpp

*** 241,250 ****
--- 241,252 ----
  
  // Return the vector version of a scalar operation node.
  VectorNode* VectorNode::make(Compile* C, int opc, Node* n1, Node* n2, uint vlen, BasicType bt) {
    const TypeVect* vt = TypeVect::make(bt, vlen);
    int vopc = VectorNode::opcode(opc, bt);
+   // This method should not be called for unimplemented vectors.
+   guarantee(vopc > 0, err_msg_res("Vector for '%s' is not implemented", NodeClassNames[opc]));
  
    switch (vopc) {
    case Op_AddVB: return new (C) AddVBNode(n1, n2, vt);
    case Op_AddVS: return new (C) AddVSNode(n1, n2, vt);
    case Op_AddVI: return new (C) AddVINode(n1, n2, vt);
*** 284,294 ****
  
    case Op_AndV: return new (C) AndVNode(n1, n2, vt);
    case Op_OrV:  return new (C) OrVNode (n1, n2, vt);
    case Op_XorV: return new (C) XorVNode(n1, n2, vt);
    }
!   ShouldNotReachHere();
    return NULL;
  
  }
  
  // Scalar promotion
--- 286,296 ----
  
    case Op_AndV: return new (C) AndVNode(n1, n2, vt);
    case Op_OrV:  return new (C) OrVNode (n1, n2, vt);
    case Op_XorV: return new (C) XorVNode(n1, n2, vt);
    }
!   fatal(err_msg_res("Missed vector creation for '%s'", NodeClassNames[vopc]));
    return NULL;
  
  }
  
  // Scalar promotion
*** 310,323 ****
    case T_FLOAT:
      return new (C) ReplicateFNode(s, vt);
    case T_DOUBLE:
      return new (C) ReplicateDNode(s, vt);
    }
!   ShouldNotReachHere();
    return NULL;
  }
  
  // Return initial Pack node. Additional operands added with add_opd() calls.
  PackNode* PackNode::make(Compile* C, Node* s, uint vlen, BasicType bt) {
    const TypeVect* vt = TypeVect::make(bt, vlen);
    switch (bt) {
    case T_BOOLEAN:
--- 312,343 ----
    case T_FLOAT:
      return new (C) ReplicateFNode(s, vt);
    case T_DOUBLE:
      return new (C) ReplicateDNode(s, vt);
    }
!   fatal(err_msg_res("Type '%s' is not supported for vectors", type2name(bt)));
    return NULL;
  }
  
+ VectorNode* VectorNode::shift_count(Compile* C, Node* shift, Node* cnt, uint vlen, BasicType bt) {
+   assert(VectorNode::is_shift(shift) && !cnt->is_Con(), "only variable shift count");
+   // Match shift count type with shift vector type.
+   const TypeVect* vt = TypeVect::make(bt, vlen);
+   switch (shift->Opcode()) {
+   case Op_LShiftI:
+   case Op_LShiftL:
+     return new (C) LShiftCntVNode(cnt, vt);
+   case Op_RShiftI:
+   case Op_RShiftL:
+   case Op_URShiftI:
+   case Op_URShiftL:
+     return new (C) RShiftCntVNode(cnt, vt);
+   }
+   fatal(err_msg_res("Missed vector creation for '%s'", NodeClassNames[shift->Opcode()]));
+   return NULL;
+ }
+ 
  // Return initial Pack node. Additional operands added with add_opd() calls.
  PackNode* PackNode::make(Compile* C, Node* s, uint vlen, BasicType bt) {
    const TypeVect* vt = TypeVect::make(bt, vlen);
    switch (bt) {
    case T_BOOLEAN:
*** 333,343 ****
    case T_FLOAT:
      return new (C) PackFNode(s, vt);
    case T_DOUBLE:
      return new (C) PackDNode(s, vt);
    }
!   ShouldNotReachHere();
    return NULL;
  }
  
  // Create a binary tree form for Packs. [lo, hi) (half-open) range
  PackNode* PackNode::binary_tree_pack(Compile* C, int lo, int hi) {
--- 353,363 ----
    case T_FLOAT:
      return new (C) PackFNode(s, vt);
    case T_DOUBLE:
      return new (C) PackDNode(s, vt);
    }
!   fatal(err_msg_res("Type '%s' is not supported for vectors", type2name(bt)));
    return NULL;
  }
  
  // Create a binary tree form for Packs. [lo, hi) (half-open) range
  PackNode* PackNode::binary_tree_pack(Compile* C, int lo, int hi) {
*** 369,389 ****
      case T_FLOAT:
        return new (C) PackDNode(n1, n2, TypeVect::make(T_DOUBLE, 2));
      case T_DOUBLE:
        return new (C) Pack2DNode(n1, n2, TypeVect::make(T_DOUBLE, 2));
      }
!     ShouldNotReachHere();
    }
    return NULL;
  }
  
  // Return the vector version of a scalar load node.
  LoadVectorNode* LoadVectorNode::make(Compile* C, int opc, Node* ctl, Node* mem,
                                       Node* adr, const TypePtr* atyp, uint vlen, BasicType bt) {
    const TypeVect* vt = TypeVect::make(bt, vlen);
    return new (C) LoadVectorNode(ctl, mem, adr, atyp, vt);
-   return NULL;
  }
  
  // Return the vector version of a scalar store node.
  StoreVectorNode* StoreVectorNode::make(Compile* C, int opc, Node* ctl, Node* mem,
                                         Node* adr, const TypePtr* atyp, Node* val,
--- 389,408 ----
      case T_FLOAT:
        return new (C) PackDNode(n1, n2, TypeVect::make(T_DOUBLE, 2));
      case T_DOUBLE:
        return new (C) Pack2DNode(n1, n2, TypeVect::make(T_DOUBLE, 2));
      }
!     fatal(err_msg_res("Type '%s' is not supported for vectors", type2name(bt)));
    }
    return NULL;
  }
  
  // Return the vector version of a scalar load node.
  LoadVectorNode* LoadVectorNode::make(Compile* C, int opc, Node* ctl, Node* mem,
                                       Node* adr, const TypePtr* atyp, uint vlen, BasicType bt) {
    const TypeVect* vt = TypeVect::make(bt, vlen);
    return new (C) LoadVectorNode(ctl, mem, adr, atyp, vt);
  }
  
  // Return the vector version of a scalar store node.
  StoreVectorNode* StoreVectorNode::make(Compile* C, int opc, Node* ctl, Node* mem,
                                         Node* adr, const TypePtr* atyp, Node* val,
*** 411,419 ****
    case T_FLOAT:
      return new (C) ExtractFNode(v, pos);
    case T_DOUBLE:
      return new (C) ExtractDNode(v, pos);
    }
!   ShouldNotReachHere();
    return NULL;
  }
  
--- 430,438 ----
    case T_FLOAT:
      return new (C) ExtractFNode(v, pos);
    case T_DOUBLE:
      return new (C) ExtractDNode(v, pos);
    }
!   fatal(err_msg_res("Type '%s' is not supported for vectors", type2name(bt)));
    return NULL;
  }