src/share/vm/opto/type.cpp

rev 8344 : 8076276: Add support for AVX512
Reviewed-by: kvn, roland
Contributed-by: michael.c.berg@intel.com

*** 66,85 ****
--- 66,88 ----
  #ifdef SPARC
    { Bad,             T_ILLEGAL,    "vectors:",      false, 0,                    relocInfo::none          },  // VectorS
    { Bad,             T_ILLEGAL,    "vectord:",      false, Op_RegD,              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
  #elif defined(PPC64)
    { Bad,             T_ILLEGAL,    "vectors:",      false, 0,                    relocInfo::none          },  // VectorS
    { 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,    "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
  #endif
    { Bad,             T_ADDRESS,    "anyptr:",       false, Op_RegP,              relocInfo::none          },  // AnyPtr
    { Bad,             T_ADDRESS,    "rawptr:",       false, Op_RegP,              relocInfo::none          },  // RawPtr
    { Bad,             T_OBJECT,     "oop:",          true,  Op_RegP,              relocInfo::oop_type      },  // OopPtr
    { Bad,             T_OBJECT,     "inst:",         true,  Op_RegP,              relocInfo::oop_type      },  // InstPtr
*** 501,514 ****
--- 504,521 ----
      TypeVect::VECTX = TypeVect::make(T_FLOAT,4);
    }
    if (Matcher::vector_size_supported(T_FLOAT,8)) {
      TypeVect::VECTY = TypeVect::make(T_FLOAT,8);
    }
+   if (Matcher::vector_size_supported(T_FLOAT,16)) {
+     TypeVect::VECTZ = TypeVect::make(T_FLOAT,16);
+   }
    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;
  
    // Restore working type arena.
    current->set_type_arena(save);
    current->set_type_dict(NULL);
  }
*** 796,805 ****
--- 803,813 ----
    Bad,          // Array - 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
  
    Bad,          // AnyPtr - handled in v-call
    Bad,          // RawPtr - handled in v-call
    Bad,          // OopPtr - handled in v-call
    Bad,          // InstPtr - handled in v-call
*** 2049,2058 ****
--- 2057,2067 ----
  // Convenience common pre-built types.
  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");
*** 2068,2077 ****
--- 2077,2088 ----
      return (TypeVect*)(new TypeVectD(elem, length))->hashcons();
    case Op_VecX:
      return (TypeVect*)(new TypeVectX(elem, length))->hashcons();
    case Op_VecY:
      return (TypeVect*)(new TypeVectY(elem, length))->hashcons();
+   case Op_VecZ:
+     return (TypeVect*)(new TypeVectZ(elem, length))->hashcons();
    }
   ShouldNotReachHere();
    return NULL;
  }
  
*** 2091,2101 ****
      typerr(t);
  
    case VectorS:
    case VectorD:
    case VectorX:
!   case VectorY: {                // Meeting 2 vectors?
      const TypeVect* v = t->is_vect();
      assert(  base() == v->base(), "");
      assert(length() == v->length(), "");
      assert(element_basic_type() == v->element_basic_type(), "");
      return TypeVect::make(_elem->xmeet(v->_elem), _length);
--- 2102,2113 ----
      typerr(t);
  
    case VectorS:
    case VectorD:
    case VectorX:
!   case VectorY:
!   case VectorZ: {                // Meeting 2 vectors?
      const TypeVect* v = t->is_vect();
      assert(  base() == v->base(), "");
      assert(length() == v->length(), "");
      assert(element_basic_type() == v->element_basic_type(), "");
      return TypeVect::make(_elem->xmeet(v->_elem), _length);
*** 2149,2158 ****
--- 2161,2172 ----
      st->print("vectord["); break;
    case VectorX:
      st->print("vectorx["); break;
    case VectorY:
      st->print("vectory["); break;
+   case VectorZ:
+     st->print("vectorz["); break;
    default:
      ShouldNotReachHere();
    }
    st->print("%d]:{", _length);
    _elem->dump2(d, depth, st);