src/hotspot/share/opto/type.cpp

@@ -72,10 +72,11 @@
    { Bad,             T_ILLEGAL,    "vectord:",      false, Op_RegL,              relocInfo::none          },  // VectorD
    { Bad,             T_ILLEGAL,    "vectorx:",      false, 0,                    relocInfo::none          },  // VectorX
    { Bad,             T_ILLEGAL,    "vectory:",      false, 0,                    relocInfo::none          },  // VectorY
    { Bad,             T_ILLEGAL,    "vectorz:",      false, 0,                    relocInfo::none          },  // VectorZ
  #else // all other
+   { Bad,             T_ILLEGAL,    "vectora:",      false, Op_VecA,              relocInfo::none          },  // VectorA.
    { Bad,             T_ILLEGAL,    "vectors:",      false, Op_VecS,              relocInfo::none          },  // VectorS
    { Bad,             T_ILLEGAL,    "vectord:",      false, Op_VecD,              relocInfo::none          },  // VectorD
    { Bad,             T_ILLEGAL,    "vectorx:",      false, Op_VecX,              relocInfo::none          },  // VectorX
    { Bad,             T_ILLEGAL,    "vectory:",      false, Op_VecY,              relocInfo::none          },  // VectorY
    { Bad,             T_ILLEGAL,    "vectorz:",      false, Op_VecZ,              relocInfo::none          },  // VectorZ

@@ -644,10 +645,14 @@
    _zero_type[T_VOID]        = Type::TOP;         // the only void value is no value at all
  
    // get_zero_type() should not happen for T_CONFLICT
    _zero_type[T_CONFLICT]= NULL;
  
+   if (Matcher::supports_scalable_vector()) {
+     TypeVect::VECTA = TypeVect::make(T_BYTE, Matcher::scalable_vector_reg_size(T_BYTE));
+   }
+ 
    // Vector predefined types, it needs initialized _const_basic_type[].
    if (Matcher::vector_size_supported(T_BYTE,4)) {
      TypeVect::VECTS = TypeVect::make(T_BYTE,4);
    }
    if (Matcher::vector_size_supported(T_FLOAT,2)) {

@@ -660,10 +665,12 @@
      TypeVect::VECTY = TypeVect::make(T_FLOAT,8);
    }
    if (Matcher::vector_size_supported(T_FLOAT,16)) {
      TypeVect::VECTZ = TypeVect::make(T_FLOAT,16);
    }
+ 
+   mreg2type[Op_VecA] = TypeVect::VECTA;
    mreg2type[Op_VecS] = TypeVect::VECTS;
    mreg2type[Op_VecD] = TypeVect::VECTD;
    mreg2type[Op_VecX] = TypeVect::VECTX;
    mreg2type[Op_VecY] = TypeVect::VECTY;
    mreg2type[Op_VecZ] = TypeVect::VECTZ;

@@ -979,10 +986,11 @@
    Bad,          // NarrowOop - handled in v-call
    Bad,          // NarrowKlass - handled in v-call
  
    Bad,          // Tuple - handled in v-call
    Bad,          // Array - handled in v-call
+   Bad,          // VectorA - handled in v-call
    Bad,          // VectorS - handled in v-call
    Bad,          // VectorD - handled in v-call
    Bad,          // VectorX - handled in v-call
    Bad,          // VectorY - handled in v-call
    Bad,          // VectorZ - handled in v-call

@@ -1879,11 +1887,10 @@
  const TypeTuple *TypeTuple::INT_PAIR;
  const TypeTuple *TypeTuple::LONG_PAIR;
  const TypeTuple *TypeTuple::INT_CC_PAIR;
  const TypeTuple *TypeTuple::LONG_CC_PAIR;
  
- 
  //------------------------------make-------------------------------------------
  // Make a TypeTuple from the range of a method signature
  const TypeTuple *TypeTuple::make_range(ciSignature* sig) {
    ciType* return_type = sig->return_type();
    uint arg_cnt = return_type->size();

@@ -2250,24 +2257,26 @@
    return false;
  }
  
  //==============================TypeVect=======================================
  // Convenience common pre-built types.
+ const TypeVect *TypeVect::VECTA = NULL; // vector length agnostic
  const TypeVect *TypeVect::VECTS = NULL; //  32-bit vectors
  const TypeVect *TypeVect::VECTD = NULL; //  64-bit vectors
  const TypeVect *TypeVect::VECTX = NULL; // 128-bit vectors
  const TypeVect *TypeVect::VECTY = NULL; // 256-bit vectors
  const TypeVect *TypeVect::VECTZ = NULL; // 512-bit vectors
  
  //------------------------------make-------------------------------------------
  const TypeVect* TypeVect::make(const Type *elem, uint length) {
    BasicType elem_bt = elem->array_element_basic_type();
    assert(is_java_primitive(elem_bt), "only primitive types in vector");
-   assert(length > 1 && is_power_of_2(length), "vector length is power of 2");
    assert(Matcher::vector_size_supported(elem_bt, length), "length in range");
    int size = length * type2aelembytes(elem_bt);
    switch (Matcher::vector_ideal_reg(size)) {
+   case Op_VecA:
+     return (TypeVect*)(new TypeVectA(elem, length))->hashcons();
    case Op_VecS:
      return (TypeVect*)(new TypeVectS(elem, length))->hashcons();
    case Op_RegL:
    case Op_VecD:
    case Op_RegD:

@@ -2295,11 +2304,11 @@
    case Bottom:                  // Ye Olde Default
      return t;
  
    default:                      // All else is a mistake
      typerr(t);
- 
+   case VectorA:
    case VectorS:
    case VectorD:
    case VectorX:
    case VectorY:
    case VectorZ: {                // Meeting 2 vectors?

@@ -2350,10 +2359,12 @@
  
  //------------------------------dump2------------------------------------------
  #ifndef PRODUCT
  void TypeVect::dump2(Dict &d, uint depth, outputStream *st) const {
    switch (base()) {
+   case VectorA:
+     st->print("vectora["); break;
    case VectorS:
      st->print("vectors["); break;
    case VectorD:
      st->print("vectord["); break;
    case VectorX: