1 /*
   2  * Copyright (c) 2020, 2025, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "ci/ciSymbols.hpp"
  26 #include "classfile/vmSymbols.hpp"
  27 #include "opto/library_call.hpp"
  28 #include "opto/runtime.hpp"
  29 #include "opto/vectornode.hpp"
  30 #include "prims/vectorSupport.hpp"
  31 #include "runtime/stubRoutines.hpp"
  32 
  33 #ifdef ASSERT
  34 static bool is_vector(ciKlass* klass) {
  35   return klass->is_subclass_of(ciEnv::current()->vector_VectorPayload_klass());
  36 }
  37 
  38 static bool check_vbox(const TypeInstPtr* vbox_type) {
  39   assert(vbox_type->klass_is_exact(), "");
  40 
  41   ciInstanceKlass* ik = vbox_type->instance_klass();
  42   assert(is_vector(ik), "not a vector");
  43 
  44   ciField* fd1 = ik->get_field_by_name(ciSymbols::ETYPE_name(), ciSymbols::class_signature(), /* is_static */ true);
  45   assert(fd1 != nullptr, "element type info is missing");
  46 
  47   ciConstant val1 = fd1->constant_value();
  48   BasicType elem_bt = val1.as_object()->as_instance()->java_mirror_type()->basic_type();
  49   assert(is_java_primitive(elem_bt), "element type info is missing");
  50 
  51   ciField* fd2 = ik->get_field_by_name(ciSymbols::VLENGTH_name(), ciSymbols::int_signature(), /* is_static */ true);
  52   assert(fd2 != nullptr, "vector length info is missing");
  53 
  54   ciConstant val2 = fd2->constant_value();
  55   assert(val2.as_int() > 0, "vector length info is missing");
  56 
  57   return true;
  58 }
  59 #endif
  60 
  61 #define log_if_needed(...)        \
  62   if (C->print_intrinsics()) {    \
  63     tty->print_cr(__VA_ARGS__);   \
  64   }
  65 
  66 #ifndef PRODUCT
  67 #define non_product_log_if_needed(...) log_if_needed(__VA_ARGS__)
  68 #else
  69 #define non_product_log_if_needed(...)
  70 #endif
  71 
  72 static bool is_vector_mask(ciKlass* klass) {
  73   return klass->is_subclass_of(ciEnv::current()->vector_VectorMask_klass());
  74 }
  75 
  76 bool LibraryCallKit::arch_supports_vector_rotate(int opc, int num_elem, BasicType elem_bt,
  77                                                  VectorMaskUseType mask_use_type, bool has_scalar_args) {
  78   bool is_supported = true;
  79 
  80   // has_scalar_args flag is true only for non-constant scalar shift count,
  81   // since in this case shift needs to be broadcasted.
  82   if (!Matcher::match_rule_supported_vector(opc, num_elem, elem_bt) ||
  83        (has_scalar_args && !arch_supports_vector(Op_Replicate, num_elem, elem_bt, VecMaskNotUsed))) {
  84     is_supported = false;
  85   }
  86 
  87   if (is_supported) {
  88     // Check if mask unboxing is supported, this is a two step process which first loads the contents
  89     // of boolean array into vector followed by either lane expansion to match the lane size of masked
  90     // vector operation or populate the predicate register.
  91     if ((mask_use_type & VecMaskUseLoad) != 0) {
  92       if (!Matcher::match_rule_supported_vector(Op_VectorLoadMask, num_elem, elem_bt) ||
  93           !Matcher::match_rule_supported_vector(Op_LoadVector, num_elem, T_BOOLEAN)) {
  94         non_product_log_if_needed("  ** Rejected vector mask loading (%s,%s,%d) because architecture does not support it",
  95                                   NodeClassNames[Op_VectorLoadMask], type2name(elem_bt), num_elem);
  96         return false;
  97       }
  98     }
  99 
 100     if ((mask_use_type & VecMaskUsePred) != 0) {
 101       if (!Matcher::has_predicated_vectors() ||
 102           !Matcher::match_rule_supported_vector_masked(opc, num_elem, elem_bt)) {
 103         non_product_log_if_needed("Rejected vector mask predicate using (%s,%s,%d) because architecture does not support it",
 104                                   NodeClassNames[opc], type2name(elem_bt), num_elem);
 105         return false;
 106       }
 107     }
 108   }
 109 
 110   int lshiftopc, rshiftopc;
 111   switch(elem_bt) {
 112     case T_BYTE:
 113       lshiftopc = Op_LShiftI;
 114       rshiftopc = Op_URShiftB;
 115       break;
 116     case T_SHORT:
 117       lshiftopc = Op_LShiftI;
 118       rshiftopc = Op_URShiftS;
 119       break;
 120     case T_INT:
 121       lshiftopc = Op_LShiftI;
 122       rshiftopc = Op_URShiftI;
 123       break;
 124     case T_LONG:
 125       lshiftopc = Op_LShiftL;
 126       rshiftopc = Op_URShiftL;
 127       break;
 128     default: fatal("Unexpected type: %s", type2name(elem_bt));
 129   }
 130   int lshiftvopc = VectorNode::opcode(lshiftopc, elem_bt);
 131   int rshiftvopc = VectorNode::opcode(rshiftopc, elem_bt);
 132   if (!is_supported &&
 133       arch_supports_vector(lshiftvopc, num_elem, elem_bt, VecMaskNotUsed, has_scalar_args) &&
 134       arch_supports_vector(rshiftvopc, num_elem, elem_bt, VecMaskNotUsed, has_scalar_args) &&
 135       arch_supports_vector(Op_OrV, num_elem, elem_bt, VecMaskNotUsed)) {
 136     is_supported = true;
 137   }
 138   return is_supported;
 139 }
 140 
 141 Node* GraphKit::box_vector(Node* vector, const TypeInstPtr* vbox_type, BasicType elem_bt, int num_elem, bool deoptimize_on_exception) {
 142   assert(EnableVectorSupport, "");
 143 
 144   PreserveReexecuteState preexecs(this);
 145   jvms()->set_should_reexecute(true);
 146 
 147   VectorBoxAllocateNode* alloc = new VectorBoxAllocateNode(C, vbox_type);
 148   set_edges_for_java_call(alloc, /*must_throw=*/false, /*separate_io_proj=*/true);
 149   make_slow_call_ex(alloc, env()->Throwable_klass(), /*separate_io_proj=*/true, deoptimize_on_exception);
 150   set_i_o(gvn().transform( new ProjNode(alloc, TypeFunc::I_O) ));
 151   set_all_memory(gvn().transform( new ProjNode(alloc, TypeFunc::Memory) ));
 152   Node* ret = gvn().transform(new ProjNode(alloc, TypeFunc::Parms));
 153 
 154   assert(check_vbox(vbox_type), "");
 155   const TypeVect* vt = TypeVect::make(elem_bt, num_elem, is_vector_mask(vbox_type->instance_klass()));
 156   VectorBoxNode* vbox = new VectorBoxNode(C, ret, vector, vbox_type, vt);
 157   return gvn().transform(vbox);
 158 }
 159 
 160 Node* GraphKit::unbox_vector(Node* v, const TypeInstPtr* vbox_type, BasicType elem_bt, int num_elem) {
 161   assert(EnableVectorSupport, "");
 162   const TypeInstPtr* vbox_type_v = gvn().type(v)->isa_instptr();
 163   if (vbox_type_v == nullptr || vbox_type->instance_klass() != vbox_type_v->instance_klass()) {
 164     return nullptr; // arguments don't agree on vector shapes
 165   }
 166   if (vbox_type_v->maybe_null()) {
 167     return nullptr; // no nulls are allowed
 168   }
 169   assert(check_vbox(vbox_type), "");
 170   const TypeVect* vt = TypeVect::make(elem_bt, num_elem, is_vector_mask(vbox_type->instance_klass()));
 171   Node* unbox = gvn().transform(new VectorUnboxNode(C, vt, v, merged_memory()));
 172   return unbox;
 173 }
 174 
 175 Node* GraphKit::vector_shift_count(Node* cnt, int shift_op, BasicType bt, int num_elem) {
 176   assert(bt == T_INT || bt == T_LONG || bt == T_SHORT || bt == T_BYTE, "byte, short, long and int are supported");
 177   juint mask = (type2aelembytes(bt) * BitsPerByte - 1);
 178   Node* nmask = gvn().transform(ConNode::make(TypeInt::make(mask)));
 179   Node* mcnt = gvn().transform(new AndINode(cnt, nmask));
 180   return gvn().transform(VectorNode::shift_count(shift_op, mcnt, num_elem, bt));
 181 }
 182 
 183 bool LibraryCallKit::arch_supports_vector(int sopc, int num_elem, BasicType type, VectorMaskUseType mask_use_type, bool has_scalar_args) {
 184   // Check that the operation is valid.
 185   if (sopc <= 0) {
 186     non_product_log_if_needed("  ** Rejected intrinsification because no valid vector op could be extracted");
 187     return false;
 188   }
 189 
 190   if (VectorNode::is_vector_rotate(sopc)) {
 191     if(!arch_supports_vector_rotate(sopc, num_elem, type, mask_use_type, has_scalar_args)) {
 192       non_product_log_if_needed("  ** Rejected vector op (%s,%s,%d) because architecture does not support variable vector shifts",
 193                                 NodeClassNames[sopc], type2name(type), num_elem);
 194       return false;
 195     }
 196   } else if (VectorNode::is_vector_integral_negate(sopc)) {
 197     if (!VectorNode::is_vector_integral_negate_supported(sopc, num_elem, type, false)) {
 198       non_product_log_if_needed("  ** Rejected vector op (%s,%s,%d) because architecture does not support integral vector negate",
 199                                 NodeClassNames[sopc], type2name(type), num_elem);
 200       return false;
 201     }
 202   } else {
 203     // Check that architecture supports this op-size-type combination.
 204     if (!Matcher::match_rule_supported_vector(sopc, num_elem, type)) {
 205       non_product_log_if_needed("  ** Rejected vector op (%s,%s,%d) because architecture does not support it",
 206                                 NodeClassNames[sopc], type2name(type), num_elem);
 207       return false;
 208     } else {
 209       assert(Matcher::match_rule_supported(sopc), "must be supported");
 210     }
 211   }
 212 
 213   if (num_elem == 1) {
 214     if (mask_use_type != VecMaskNotUsed) {
 215       non_product_log_if_needed("  ** Rejected vector mask op (%s,%s,%d) because architecture does not support it",
 216                                 NodeClassNames[sopc], type2name(type), num_elem);
 217       return false;
 218     }
 219 
 220     if (sopc != 0) {
 221       if (sopc != Op_LoadVector && sopc != Op_StoreVector) {
 222         non_product_log_if_needed("  ** Not a svml call or load/store vector op (%s,%s,%d)",
 223                                   NodeClassNames[sopc], type2name(type), num_elem);
 224         return false;
 225       }
 226     }
 227   }
 228 
 229   if (!has_scalar_args && VectorNode::is_vector_shift(sopc) &&
 230       Matcher::supports_vector_variable_shifts() == false) {
 231     log_if_needed("  ** Rejected vector op (%s,%s,%d) because architecture does not support variable vector shifts",
 232                   NodeClassNames[sopc], type2name(type), num_elem);
 233     return false;
 234   }
 235 
 236   // Check if mask unboxing is supported, this is a two step process which first loads the contents
 237   // of boolean array into vector followed by either lane expansion to match the lane size of masked
 238   // vector operation or populate the predicate register.
 239   if ((mask_use_type & VecMaskUseLoad) != 0) {
 240     if (!Matcher::match_rule_supported_vector(Op_VectorLoadMask, num_elem, type) ||
 241         !Matcher::match_rule_supported_vector(Op_LoadVector, num_elem, T_BOOLEAN)) {
 242       non_product_log_if_needed("  ** Rejected vector mask loading (%s,%s,%d) because architecture does not support it",
 243                                 NodeClassNames[Op_VectorLoadMask], type2name(type), num_elem);
 244       return false;
 245     }
 246   }
 247 
 248   // Check if mask boxing is supported, this is a two step process which first stores the contents
 249   // of mask vector / predicate register into a boolean vector followed by vector store operation to
 250   // transfer the contents to underlined storage of mask boxes which is a boolean array.
 251   if ((mask_use_type & VecMaskUseStore) != 0) {
 252     if (!Matcher::match_rule_supported_vector(Op_VectorStoreMask, num_elem, type) ||
 253         !Matcher::match_rule_supported_vector(Op_StoreVector, num_elem, T_BOOLEAN)) {
 254       non_product_log_if_needed("Rejected vector mask storing (%s,%s,%d) because architecture does not support it",
 255                                 NodeClassNames[Op_VectorStoreMask], type2name(type), num_elem);
 256       return false;
 257     }
 258   }
 259 
 260   if ((mask_use_type & VecMaskUsePred) != 0) {
 261     bool is_supported = false;
 262     if (Matcher::has_predicated_vectors()) {
 263       if (VectorNode::is_vector_integral_negate(sopc)) {
 264         is_supported = VectorNode::is_vector_integral_negate_supported(sopc, num_elem, type, true);
 265       } else {
 266         is_supported = Matcher::match_rule_supported_vector_masked(sopc, num_elem, type);
 267       }
 268     }
 269     is_supported |= Matcher::supports_vector_predicate_op_emulation(sopc, num_elem, type);
 270 
 271     if (!is_supported) {
 272       non_product_log_if_needed("Rejected vector mask predicate using (%s,%s,%d) because architecture does not support it",
 273                                 NodeClassNames[sopc], type2name(type), num_elem);
 274       return false;
 275     }
 276   }
 277 
 278   return true;
 279 }
 280 
 281 static bool is_klass_initialized(const TypeInstPtr* vec_klass) {
 282   if (vec_klass->const_oop() == nullptr) {
 283     return false; // uninitialized or some kind of unsafe access
 284   }
 285   assert(vec_klass->const_oop()->as_instance()->java_lang_Class_klass() != nullptr, "klass instance expected");
 286   ciInstanceKlass* klass =  vec_klass->const_oop()->as_instance()->java_lang_Class_klass()->as_instance_klass();
 287   return klass->is_initialized();
 288 }
 289 
 290 // public static
 291 // <V extends Vector<E>,
 292 //  M extends VectorMask<E>,
 293 //  E>
 294 // V unaryOp(int oprId, Class<? extends V> vmClass, Class<? extends M> maskClass, Class<E> elementType,
 295 //           int length, V v, M m,
 296 //           UnaryOperation<V, M> defaultImpl)
 297 //
 298 // public static
 299 // <V,
 300 //  M extends VectorMask<E>,
 301 //  E>
 302 // V binaryOp(int oprId, Class<? extends V> vmClass, Class<? extends M> maskClass, Class<E> elementType,
 303 //            int length, V v1, V v2, M m,
 304 //            BinaryOperation<V, M> defaultImpl)
 305 //
 306 // public static
 307 // <V extends Vector<E>,
 308 //  M extends VectorMask<E>,
 309 //  E>
 310 // V ternaryOp(int oprId, Class<? extends V> vmClass, Class<? extends M> maskClass, Class<E> elementType,
 311 //             int length, V v1, V v2, V v3, M m,
 312 //             TernaryOperation<V, M> defaultImpl)
 313 //
 314 bool LibraryCallKit::inline_vector_nary_operation(int n) {
 315   const TypeInt*     opr          = gvn().type(argument(0))->isa_int();
 316   const TypeInstPtr* vector_klass = gvn().type(argument(1))->isa_instptr();
 317   const TypeInstPtr* mask_klass   = gvn().type(argument(2))->isa_instptr();
 318   const TypeInstPtr* elem_klass   = gvn().type(argument(3))->isa_instptr();
 319   const TypeInt*     vlen         = gvn().type(argument(4))->isa_int();
 320 
 321   if (opr          == nullptr || !opr->is_con() ||
 322       vector_klass == nullptr || vector_klass->const_oop() == nullptr ||
 323       elem_klass   == nullptr || elem_klass->const_oop()   == nullptr ||
 324       vlen         == nullptr || !vlen->is_con()) {
 325     log_if_needed("  ** missing constant: opr=%s vclass=%s etype=%s vlen=%s",
 326                     NodeClassNames[argument(0)->Opcode()],
 327                     NodeClassNames[argument(1)->Opcode()],
 328                     NodeClassNames[argument(3)->Opcode()],
 329                     NodeClassNames[argument(4)->Opcode()]);
 330     return false; // not enough info for intrinsification
 331   }
 332 
 333   ciType* elem_type = elem_klass->const_oop()->as_instance()->java_mirror_type();
 334   if (!elem_type->is_primitive_type()) {
 335     log_if_needed("  ** not a primitive bt=%d", elem_type->basic_type());
 336     return false; // should be primitive type
 337   }
 338   if (!is_klass_initialized(vector_klass)) {
 339     log_if_needed("  ** klass argument not initialized");
 340     return false;
 341   }
 342 
 343   // "argument(n + 5)" should be the mask object. We assume it is "null" when no mask
 344   // is used to control this operation.
 345   const Type* vmask_type = gvn().type(argument(n + 5));
 346   bool is_masked_op = vmask_type != TypePtr::NULL_PTR;
 347   if (is_masked_op) {
 348     if (mask_klass == nullptr || mask_klass->const_oop() == nullptr) {
 349       log_if_needed("  ** missing constant: maskclass=%s", NodeClassNames[argument(2)->Opcode()]);
 350       return false; // not enough info for intrinsification
 351     }
 352 
 353     if (!is_klass_initialized(mask_klass)) {
 354       log_if_needed("  ** mask klass argument not initialized");
 355       return false;
 356     }
 357 
 358     if (vmask_type->maybe_null()) {
 359       log_if_needed("  ** null mask values are not allowed for masked op");
 360       return false;
 361     }
 362   }
 363 
 364   BasicType elem_bt = elem_type->basic_type();
 365   bool has_scalar_op = VectorSupport::has_scalar_op(opr->get_con());
 366   bool is_unsigned = VectorSupport::is_unsigned_op(opr->get_con());
 367 
 368   int num_elem = vlen->get_con();
 369   int opc = VectorSupport::vop2ideal(opr->get_con(), elem_bt);
 370   int sopc = has_scalar_op ? VectorNode::opcode(opc, elem_bt) : opc;
 371   if (sopc == 0 || num_elem == 1) {
 372     log_if_needed("  ** operation not supported: arity=%d opc=%s[%d] vlen=%d etype=%s",
 373                     n, NodeClassNames[opc], opc, num_elem, type2name(elem_bt));
 374     return false; // operation not supported
 375   }
 376   ciKlass* vbox_klass = vector_klass->const_oop()->as_instance()->java_lang_Class_klass();
 377   const TypeInstPtr* vbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, vbox_klass);
 378 
 379   if (is_vector_mask(vbox_klass)) {
 380     assert(!is_masked_op, "mask operations do not need mask to control");
 381   }
 382 
 383   // When using mask, mask use type needs to be VecMaskUseLoad.
 384   VectorMaskUseType mask_use_type = is_vector_mask(vbox_klass) ? VecMaskUseAll
 385                                       : is_masked_op ? VecMaskUseLoad : VecMaskNotUsed;
 386   if (!arch_supports_vector(sopc, num_elem, elem_bt, mask_use_type)) {
 387     log_if_needed("  ** not supported: arity=%d opc=%d vlen=%d etype=%s ismask=%d is_masked_op=%d",
 388                     n, sopc, num_elem, type2name(elem_bt),
 389                     is_vector_mask(vbox_klass) ? 1 : 0, is_masked_op ? 1 : 0);
 390     return false; // not supported
 391   }
 392 
 393   // Return true if current platform has implemented the masked operation with predicate feature.
 394   bool use_predicate = is_masked_op && arch_supports_vector(sopc, num_elem, elem_bt, VecMaskUsePred);
 395   if (is_masked_op && !use_predicate && !arch_supports_vector(Op_VectorBlend, num_elem, elem_bt, VecMaskUseLoad)) {
 396     log_if_needed("  ** not supported: arity=%d opc=%d vlen=%d etype=%s ismask=0 is_masked_op=1",
 397                     n, sopc, num_elem, type2name(elem_bt));
 398     return false;
 399   }
 400 
 401   Node* opd1 = nullptr; Node* opd2 = nullptr; Node* opd3 = nullptr;
 402   switch (n) {
 403     case 3: {
 404       opd3 = unbox_vector(argument(7), vbox_type, elem_bt, num_elem);
 405       if (opd3 == nullptr) {
 406         log_if_needed("  ** unbox failed v3=%s",
 407                         NodeClassNames[argument(7)->Opcode()]);
 408         return false;
 409       }
 410       // fall-through
 411     }
 412     case 2: {
 413       opd2 = unbox_vector(argument(6), vbox_type, elem_bt, num_elem);
 414       if (opd2 == nullptr) {
 415         log_if_needed("  ** unbox failed v2=%s",
 416                         NodeClassNames[argument(6)->Opcode()]);
 417         return false;
 418       }
 419       // fall-through
 420     }
 421     case 1: {
 422       opd1 = unbox_vector(argument(5), vbox_type, elem_bt, num_elem);
 423       if (opd1 == nullptr) {
 424         log_if_needed("  ** unbox failed v1=%s",
 425                         NodeClassNames[argument(5)->Opcode()]);
 426         return false;
 427       }
 428       break;
 429     }
 430     default: fatal("unsupported arity: %d", n);
 431   }
 432 
 433   Node* mask = nullptr;
 434   if (is_masked_op) {
 435     ciKlass* mbox_klass = mask_klass->const_oop()->as_instance()->java_lang_Class_klass();
 436     assert(is_vector_mask(mbox_klass), "argument(2) should be a mask class");
 437     const TypeInstPtr* mbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, mbox_klass);
 438     mask = unbox_vector(argument(n + 5), mbox_type, elem_bt, num_elem);
 439     if (mask == nullptr) {
 440       log_if_needed("  ** unbox failed mask=%s",
 441                       NodeClassNames[argument(n + 5)->Opcode()]);
 442       return false;
 443     }
 444   }
 445 
 446   Node* operation = nullptr;
 447   const TypeVect* vt = TypeVect::make(elem_bt, num_elem, is_vector_mask(vbox_klass));
 448   switch (n) {
 449     case 1:
 450     case 2: {
 451       operation = VectorNode::make(sopc, opd1, opd2, vt, is_vector_mask(vbox_klass), VectorNode::is_shift_opcode(opc), is_unsigned);
 452       break;
 453     }
 454     case 3: {
 455       operation = VectorNode::make(sopc, opd1, opd2, opd3, vt);
 456       break;
 457     }
 458     default: fatal("unsupported arity: %d", n);
 459   }
 460 
 461   if (is_masked_op && mask != nullptr) {
 462     if (use_predicate) {
 463       operation->add_req(mask);
 464       operation->add_flag(Node::Flag_is_predicated_vector);
 465     } else {
 466       operation->add_flag(Node::Flag_is_predicated_using_blend);
 467       operation = gvn().transform(operation);
 468       operation = new VectorBlendNode(opd1, operation, mask);
 469     }
 470   }
 471   operation = gvn().transform(operation);
 472 
 473   // Wrap it up in VectorBox to keep object type information.
 474   Node* vbox = box_vector(operation, vbox_type, elem_bt, num_elem);
 475   set_result(vbox);
 476   C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
 477   return true;
 478 }
 479 
 480 // public static
 481 // <V extends Vector<E>, E>
 482 // V libraryUnaryOp(long address, Class<? extends V> vClass, Class<E> elementType, int length, String debugName,
 483 //                  V v,
 484 //                  UnaryOperation<V, ?> defaultImpl)
 485 //
 486 // public static
 487 // <V extends VectorPayload, E>
 488 // V libraryBinaryOp(long address, Class<? extends V> vClass, Class<E> elementType, int length, String debugName,
 489 //            V v1, V v2,
 490 //            BinaryOperation<V, ?> defaultImpl)
 491 bool LibraryCallKit::inline_vector_call(int arity) {
 492   assert(Matcher::supports_vector_calling_convention(), "required");
 493 
 494   const TypeLong*    entry          = gvn().type(argument(0))->isa_long();
 495   const TypeInstPtr* vector_klass   = gvn().type(argument(2))->isa_instptr();
 496   const TypeInstPtr* elem_klass     = gvn().type(argument(3))->isa_instptr();
 497   const TypeInt*     vlen           = gvn().type(argument(4))->isa_int();
 498   const TypeInstPtr* debug_name_oop = gvn().type(argument(5))->isa_instptr();
 499 
 500   if (entry        == nullptr   || !entry->is_con() ||
 501       vector_klass == nullptr   || vector_klass->const_oop() == nullptr ||
 502       elem_klass   == nullptr   || elem_klass->const_oop() == nullptr ||
 503       vlen         == nullptr   || !vlen->is_con() ||
 504       debug_name_oop == nullptr || debug_name_oop->const_oop() == nullptr) {
 505     log_if_needed("  ** missing constant: opr=%s vclass=%s etype=%s vlen=%s debug_name=%s",
 506                   NodeClassNames[argument(0)->Opcode()],
 507                   NodeClassNames[argument(2)->Opcode()],
 508                   NodeClassNames[argument(3)->Opcode()],
 509                   NodeClassNames[argument(4)->Opcode()],
 510                   NodeClassNames[argument(5)->Opcode()]);
 511     return false; // not enough info for intrinsification
 512   }
 513 
 514   if (entry->get_con() == 0) {
 515     log_if_needed("  ** missing entry point");
 516     return false;
 517   }
 518 
 519   ciType* elem_type = elem_klass->const_oop()->as_instance()->java_mirror_type();
 520   if (!elem_type->is_primitive_type()) {
 521     log_if_needed("  ** not a primitive bt=%d", elem_type->basic_type());
 522     return false; // should be primitive type
 523   }
 524   if (!is_klass_initialized(vector_klass)) {
 525     log_if_needed("  ** klass argument not initialized");
 526     return false;
 527   }
 528 
 529   BasicType elem_bt = elem_type->basic_type();
 530   int num_elem = vlen->get_con();
 531   if (!Matcher::vector_size_supported(elem_bt, num_elem)) {
 532     log_if_needed("  ** vector size (vlen=%d, etype=%s) is not supported",
 533                   num_elem, type2name(elem_bt));
 534     return false;
 535   }
 536 
 537   ciKlass* vbox_klass = vector_klass->const_oop()->as_instance()->java_lang_Class_klass();
 538   const TypeInstPtr* vbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, vbox_klass);
 539 
 540   Node* opd1 = unbox_vector(argument(6), vbox_type, elem_bt, num_elem);
 541   if (opd1 == nullptr) {
 542     log_if_needed("  ** unbox failed v1=%s", NodeClassNames[argument(6)->Opcode()]);
 543     return false;
 544   }
 545 
 546   Node* opd2 = nullptr;
 547   if (arity > 1) {
 548     opd2 = unbox_vector(argument(7), vbox_type, elem_bt, num_elem);
 549     if (opd2 == nullptr) {
 550       log_if_needed("  ** unbox failed v2=%s", NodeClassNames[argument(7)->Opcode()]);
 551       return false;
 552     }
 553   }
 554   assert(arity == 1 || arity == 2, "arity %d not supported", arity);
 555   const TypeVect* vt = TypeVect::make(elem_bt, num_elem);
 556   const TypeFunc* call_type = OptoRuntime::Math_Vector_Vector_Type(arity, vt, vt);
 557   address entry_addr = (address)entry->get_con();
 558 
 559   const char* debug_name = "<unknown>";
 560   if (!debug_name_oop->const_oop()->is_null_object()) {
 561     size_t buflen = 100;
 562     char* buf = NEW_ARENA_ARRAY(C->comp_arena(), char, buflen);
 563     debug_name = debug_name_oop->const_oop()->as_instance()->java_lang_String_str(buf, buflen);
 564   }
 565   Node* vcall = make_runtime_call(RC_VECTOR,
 566                                   call_type,
 567                                   entry_addr,
 568                                   debug_name,
 569                                   TypePtr::BOTTOM,
 570                                   opd1,
 571                                   opd2);
 572 
 573   vcall = gvn().transform(new ProjNode(gvn().transform(vcall), TypeFunc::Parms));
 574 
 575   // Wrap it up in VectorBox to keep object type information.
 576   Node* vbox = box_vector(vcall, vbox_type, elem_bt, num_elem);
 577   set_result(vbox);
 578   C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
 579   return true;
 580 }
 581 
 582 // <E, M>
 583 // long maskReductionCoerced(int oper, Class<? extends M> maskClass, Class<?> elemClass,
 584 //                          int length, M m, VectorMaskOp<M> defaultImpl)
 585 bool LibraryCallKit::inline_vector_mask_operation() {
 586   const TypeInt*     oper       = gvn().type(argument(0))->isa_int();
 587   const TypeInstPtr* mask_klass = gvn().type(argument(1))->isa_instptr();
 588   const TypeInstPtr* elem_klass = gvn().type(argument(2))->isa_instptr();
 589   const TypeInt*     vlen       = gvn().type(argument(3))->isa_int();
 590   Node*              mask       = argument(4);
 591 
 592   if (mask_klass == nullptr || mask_klass->const_oop() == nullptr ||
 593       elem_klass == nullptr || elem_klass->const_oop() == nullptr ||
 594       vlen       == nullptr || !vlen->is_con() ||
 595       oper       == nullptr || !oper->is_con() ||
 596       mask->is_top()) {
 597     return false; // dead code
 598   }
 599 
 600   if (!is_klass_initialized(mask_klass)) {
 601     log_if_needed("  ** klass argument not initialized");
 602     return false;
 603   }
 604 
 605   int num_elem = vlen->get_con();
 606   ciType* elem_type = elem_klass->const_oop()->as_instance()->java_mirror_type();
 607   BasicType elem_bt = elem_type->basic_type();
 608 
 609   int mopc = VectorSupport::vop2ideal(oper->get_con(), elem_bt);
 610   if (!arch_supports_vector(mopc, num_elem, elem_bt, VecMaskUseLoad)) {
 611     log_if_needed("  ** not supported: arity=1 op=cast#%d/3 vlen2=%d etype2=%s",
 612                     mopc, num_elem, type2name(elem_bt));
 613     return false; // not supported
 614   }
 615 
 616   ciKlass* mbox_klass = mask_klass->const_oop()->as_instance()->java_lang_Class_klass();
 617   const TypeInstPtr* mask_box_type = TypeInstPtr::make_exact(TypePtr::NotNull, mbox_klass);
 618   Node* mask_vec = unbox_vector(mask, mask_box_type, elem_bt, num_elem);
 619   if (mask_vec == nullptr) {
 620     log_if_needed("  ** unbox failed mask=%s",
 621                       NodeClassNames[argument(4)->Opcode()]);
 622     return false;
 623   }
 624 
 625   if (mask_vec->bottom_type()->isa_vectmask() == nullptr) {
 626     mask_vec = gvn().transform(VectorStoreMaskNode::make(gvn(), mask_vec, elem_bt, num_elem));
 627   }
 628   const Type* maskoper_ty = mopc == Op_VectorMaskToLong ? (const Type*)TypeLong::LONG : (const Type*)TypeInt::INT;
 629   Node* maskoper = gvn().transform(VectorMaskOpNode::make(mask_vec, maskoper_ty, mopc));
 630   if (mopc != Op_VectorMaskToLong) {
 631     maskoper = ConvI2L(maskoper);
 632   }
 633   set_result(maskoper);
 634 
 635   C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
 636   return true;
 637 }
 638 
 639 // public static
 640 // <M,
 641 //  S extends VectorSpecies<E>,
 642 //  E>
 643 // M fromBitsCoerced(Class<? extends M> vmClass, Class<E> elementType, int length,
 644 //                    long bits, int mode, S s,
 645 //                    BroadcastOperation<M, E, S> defaultImpl)
 646 bool LibraryCallKit::inline_vector_frombits_coerced() {
 647   const TypeInstPtr* vector_klass = gvn().type(argument(0))->isa_instptr();
 648   const TypeInstPtr* elem_klass   = gvn().type(argument(1))->isa_instptr();
 649   const TypeInt*     vlen         = gvn().type(argument(2))->isa_int();
 650   const TypeLong*    bits_type    = gvn().type(argument(3))->isa_long();
 651   // Mode argument determines the mode of operation it can take following values:-
 652   // MODE_BROADCAST for vector Vector.broadcast and VectorMask.maskAll operations.
 653   // MODE_BITS_COERCED_LONG_TO_MASK for VectorMask.fromLong operation.
 654   const TypeInt*     mode         = gvn().type(argument(5))->isa_int();
 655 
 656   if (vector_klass == nullptr || vector_klass->const_oop() == nullptr ||
 657       elem_klass   == nullptr || elem_klass->const_oop()   == nullptr ||
 658       vlen         == nullptr || !vlen->is_con() ||
 659       bits_type    == nullptr ||
 660       mode         == nullptr || !mode->is_con()) {
 661     log_if_needed("  ** missing constant: vclass=%s etype=%s vlen=%s bitwise=%s",
 662                     NodeClassNames[argument(0)->Opcode()],
 663                     NodeClassNames[argument(1)->Opcode()],
 664                     NodeClassNames[argument(2)->Opcode()],
 665                     NodeClassNames[argument(5)->Opcode()]);
 666     return false; // not enough info for intrinsification
 667   }
 668 
 669   if (!is_klass_initialized(vector_klass)) {
 670     log_if_needed("  ** klass argument not initialized");
 671     return false;
 672   }
 673   ciType* elem_type = elem_klass->const_oop()->as_instance()->java_mirror_type();
 674   if (!elem_type->is_primitive_type()) {
 675     log_if_needed("  ** not a primitive bt=%d", elem_type->basic_type());
 676     return false; // should be primitive type
 677   }
 678   BasicType elem_bt = elem_type->basic_type();
 679   int num_elem = vlen->get_con();
 680   ciKlass* vbox_klass = vector_klass->const_oop()->as_instance()->java_lang_Class_klass();
 681   const TypeInstPtr* vbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, vbox_klass);
 682 
 683   bool is_mask = is_vector_mask(vbox_klass);
 684   int  bcast_mode = mode->get_con();
 685   VectorMaskUseType checkFlags = (VectorMaskUseType)(is_mask ? VecMaskUseAll : VecMaskNotUsed);
 686   int opc = bcast_mode == VectorSupport::MODE_BITS_COERCED_LONG_TO_MASK ? Op_VectorLongToMask : Op_Replicate;
 687 
 688   if (!arch_supports_vector(opc, num_elem, elem_bt, checkFlags, true /*has_scalar_args*/)) {
 689     // If the input long sets or unsets all lanes and Replicate is supported,
 690     // generate a MaskAll or Replicate instead.
 691 
 692     // The "maskAll" API uses the corresponding integer types for floating-point data.
 693     BasicType maskall_bt = elem_bt == T_DOUBLE ? T_LONG : (elem_bt == T_FLOAT ? T_INT: elem_bt);
 694     if (!(opc == Op_VectorLongToMask &&
 695           VectorNode::is_maskall_type(bits_type, num_elem) &&
 696           arch_supports_vector(Op_Replicate, num_elem, maskall_bt, checkFlags, true /*has_scalar_args*/))) {
 697       log_if_needed("  ** not supported: arity=0 op=broadcast vlen=%d etype=%s ismask=%d bcast_mode=%d",
 698                       num_elem, type2name(elem_bt),
 699                       is_mask ? 1 : 0,
 700                       bcast_mode);
 701       return false; // not supported
 702     }
 703   }
 704 
 705   Node* broadcast = nullptr;
 706   Node* bits = argument(3);
 707   Node* elem = bits;
 708 
 709   if (opc == Op_VectorLongToMask) {
 710     const TypeVect* vt = TypeVect::makemask(elem_bt, num_elem);
 711     if (vt->isa_vectmask()) {
 712       broadcast = gvn().transform(new VectorLongToMaskNode(elem, vt));
 713     } else {
 714       const TypeVect* mvt = TypeVect::make(T_BOOLEAN, num_elem);
 715       broadcast = gvn().transform(new VectorLongToMaskNode(elem, mvt));
 716       broadcast = gvn().transform(new VectorLoadMaskNode(broadcast, vt));
 717     }
 718   } else {
 719     switch (elem_bt) {
 720       case T_BOOLEAN: // fall-through
 721       case T_BYTE:    // fall-through
 722       case T_SHORT:   // fall-through
 723       case T_CHAR:    // fall-through
 724       case T_INT: {
 725         elem = gvn().transform(new ConvL2INode(bits));
 726         break;
 727       }
 728       case T_DOUBLE: {
 729         elem = gvn().transform(new MoveL2DNode(bits));
 730         break;
 731       }
 732       case T_FLOAT: {
 733         bits = gvn().transform(new ConvL2INode(bits));
 734         elem = gvn().transform(new MoveI2FNode(bits));
 735         break;
 736       }
 737       case T_LONG: {
 738         // no conversion needed
 739         break;
 740       }
 741       default: fatal("%s", type2name(elem_bt));
 742     }
 743     broadcast = VectorNode::scalar2vector(elem, num_elem, elem_bt, is_mask);
 744     broadcast = gvn().transform(broadcast);
 745   }
 746 
 747   Node* box = box_vector(broadcast, vbox_type, elem_bt, num_elem);
 748   set_result(box);
 749   C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
 750   return true;
 751 }
 752 
 753 static bool elem_consistent_with_arr(BasicType elem_bt, const TypeAryPtr* arr_type, bool mismatched_ms) {
 754   assert(arr_type != nullptr, "unexpected");
 755   BasicType arr_elem_bt = arr_type->elem()->array_element_basic_type();
 756   if (elem_bt == arr_elem_bt) {
 757     return true;
 758   } else if (elem_bt == T_SHORT && arr_elem_bt == T_CHAR) {
 759     // Load/store of short vector from/to char[] is supported
 760     return true;
 761   } else if (elem_bt == T_BYTE && arr_elem_bt == T_BOOLEAN) {
 762     // Load/store of byte vector from/to boolean[] is supported
 763     return true;
 764   } else {
 765     return mismatched_ms;
 766   }
 767 }
 768 
 769 //  public static
 770 //  <C,
 771 //   VM extends VectorPayload,
 772 //   E,
 773 //   S extends VectorSpecies<E>>
 774 //  VM load(Class<? extends VM> vmClass, Class<E> eClass,
 775 //          int length,
 776 //          Object base, long offset,            // Unsafe addressing
 777 //          boolean fromSegment,
 778 //          C container, long index, S s,        // Arguments for default implementation
 779 //          LoadOperation<C, VM, S> defaultImpl) {
 780 //  public static
 781 //  <C,
 782 //   V extends VectorPayload>
 783 //  void store(Class<?> vClass, Class<?> eClass,
 784 //             int length,
 785 //             Object base, long offset,        // Unsafe addressing
 786 //             boolean fromSegment,
 787 //             V v, C container, long index,    // Arguments for default implementation
 788 //             StoreVectorOperation<C, V> defaultImpl) {
 789 bool LibraryCallKit::inline_vector_mem_operation(bool is_store) {
 790   const TypeInstPtr* vector_klass = gvn().type(argument(0))->isa_instptr();
 791   const TypeInstPtr* elem_klass   = gvn().type(argument(1))->isa_instptr();
 792   const TypeInt*     vlen         = gvn().type(argument(2))->isa_int();
 793   const TypeInt*     from_ms      = gvn().type(argument(6))->isa_int();
 794 
 795   if (vector_klass == nullptr || vector_klass->const_oop() == nullptr ||
 796       elem_klass   == nullptr || elem_klass->const_oop()   == nullptr ||
 797       vlen         == nullptr || !vlen->is_con() ||
 798       from_ms      == nullptr || !from_ms->is_con()) {
 799     log_if_needed("  ** missing constant: vclass=%s etype=%s vlen=%s from_ms=%s",
 800                     NodeClassNames[argument(0)->Opcode()],
 801                     NodeClassNames[argument(1)->Opcode()],
 802                     NodeClassNames[argument(2)->Opcode()],
 803                     NodeClassNames[argument(6)->Opcode()]);
 804     return false; // not enough info for intrinsification
 805   }
 806   if (!is_klass_initialized(vector_klass)) {
 807     log_if_needed("  ** klass argument not initialized");
 808     return false;
 809   }
 810 
 811   ciType* elem_type = elem_klass->const_oop()->as_instance()->java_mirror_type();
 812   if (!elem_type->is_primitive_type()) {
 813     log_if_needed("  ** not a primitive bt=%d", elem_type->basic_type());
 814     return false; // should be primitive type
 815   }
 816   BasicType elem_bt = elem_type->basic_type();
 817   int num_elem = vlen->get_con();
 818 
 819   // TODO When mask usage is supported, VecMaskNotUsed needs to be VecMaskUseLoad.
 820   if (!arch_supports_vector(is_store ? Op_StoreVector : Op_LoadVector, num_elem, elem_bt, VecMaskNotUsed)) {
 821     log_if_needed("  ** not supported: arity=%d op=%s vlen=%d etype=%s ismask=no",
 822                     is_store, is_store ? "store" : "load",
 823                     num_elem, type2name(elem_bt));
 824     return false; // not supported
 825   }
 826 
 827   ciKlass* vbox_klass = vector_klass->const_oop()->as_instance()->java_lang_Class_klass();
 828   bool is_mask = is_vector_mask(vbox_klass);
 829 
 830   Node* base = argument(3);
 831   Node* offset = ConvL2X(argument(4));
 832 
 833   // Save state and restore on bailout
 834   SavedState old_state(this);
 835 
 836   Node* addr = make_unsafe_address(base, offset, (is_mask ? T_BOOLEAN : elem_bt), true);
 837 
 838   // The memory barrier checks are based on ones for unsafe access.
 839   // This is not 1-1 implementation.
 840   const Type *const base_type = gvn().type(base);
 841 
 842   const TypePtr *addr_type = gvn().type(addr)->isa_ptr();
 843   const TypeAryPtr* arr_type = addr_type->isa_aryptr();
 844 
 845   const bool in_native = TypePtr::NULL_PTR == base_type; // base always null
 846   const bool in_heap   = !TypePtr::NULL_PTR->higher_equal(base_type); // base never null
 847 
 848   const bool is_mixed_access = !in_heap && !in_native;
 849 
 850   const bool is_mismatched_access = in_heap && (addr_type->isa_aryptr() == nullptr);
 851 
 852   const bool needs_cpu_membar = is_mixed_access || is_mismatched_access;
 853 
 854   // For non-masked mismatched memory segment vector read/write accesses, intrinsification can continue
 855   // with unknown backing storage type and compiler can skip inserting explicit reinterpretation IR after
 856   // loading from or before storing to backing storage which is mandatory for semantic correctness of
 857   // big-endian memory layout.
 858   bool mismatched_ms = LITTLE_ENDIAN_ONLY(false)
 859       BIG_ENDIAN_ONLY(from_ms->get_con() && !is_mask && arr_type != nullptr &&
 860                       arr_type->elem()->array_element_basic_type() != elem_bt);
 861   BasicType mem_elem_bt = mismatched_ms ? arr_type->elem()->array_element_basic_type() : elem_bt;
 862   if (!is_java_primitive(mem_elem_bt)) {
 863     log_if_needed("  ** non-primitive array element type");
 864     return false;
 865   }
 866   int mem_num_elem = mismatched_ms ? (num_elem * type2aelembytes(elem_bt)) / type2aelembytes(mem_elem_bt) : num_elem;
 867   if (arr_type != nullptr && !is_mask && !elem_consistent_with_arr(elem_bt, arr_type, mismatched_ms)) {
 868     log_if_needed("  ** not supported: arity=%d op=%s vlen=%d etype=%s atype=%s ismask=no",
 869                     is_store, is_store ? "store" : "load",
 870                     num_elem, type2name(elem_bt), type2name(arr_type->elem()->array_element_basic_type()));
 871     return false;
 872   }
 873 
 874   // In case of mismatched memory segment accesses, we need to double check that the source type memory operations are supported by backend.
 875   if (mismatched_ms) {
 876     if (is_store) {
 877       if (!arch_supports_vector(Op_StoreVector, num_elem, elem_bt, VecMaskNotUsed)
 878           || !arch_supports_vector(Op_VectorReinterpret, mem_num_elem, mem_elem_bt, VecMaskNotUsed)) {
 879         log_if_needed("  ** not supported: arity=%d op=%s vlen=%d*8 etype=%s/8 ismask=no",
 880                         is_store, "store",
 881                         num_elem, type2name(elem_bt));
 882         return false; // not supported
 883       }
 884     } else {
 885       if (!arch_supports_vector(Op_LoadVector, mem_num_elem, mem_elem_bt, VecMaskNotUsed)
 886           || !arch_supports_vector(Op_VectorReinterpret, num_elem, elem_bt, VecMaskNotUsed)) {
 887         log_if_needed("  ** not supported: arity=%d op=%s vlen=%d*8 etype=%s/8 ismask=no",
 888                         is_store, "load",
 889                         mem_num_elem, type2name(mem_elem_bt));
 890         return false; // not supported
 891       }
 892     }
 893   }
 894   if (is_mask) {
 895     if (!is_store) {
 896       if (!arch_supports_vector(Op_LoadVector, num_elem, elem_bt, VecMaskUseLoad)) {
 897         return false; // not supported
 898       }
 899     } else {
 900       if (!arch_supports_vector(Op_StoreVector, num_elem, elem_bt, VecMaskUseStore)) {
 901         return false; // not supported
 902       }
 903     }
 904   }
 905 
 906   const TypeInstPtr* vbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, vbox_klass);
 907 
 908   if (needs_cpu_membar) {
 909     insert_mem_bar(Op_MemBarCPUOrder);
 910   }
 911 
 912   if (is_store) {
 913     Node* val = unbox_vector(argument(7), vbox_type, elem_bt, num_elem);
 914     if (val == nullptr) {
 915       return false; // operand unboxing failed
 916     }
 917     set_all_memory(reset_memory());
 918 
 919     // In case the store needs to happen to byte array, reinterpret the incoming vector to byte vector.
 920     int store_num_elem = num_elem;
 921     if (mismatched_ms) {
 922       store_num_elem = mem_num_elem;
 923       const TypeVect* to_vect_type = TypeVect::make(mem_elem_bt, store_num_elem);
 924       val = gvn().transform(new VectorReinterpretNode(val, val->bottom_type()->is_vect(), to_vect_type));
 925     }
 926     if (is_mask) {
 927       val = gvn().transform(VectorStoreMaskNode::make(gvn(), val, elem_bt, num_elem));
 928     }
 929     Node* vstore = gvn().transform(StoreVectorNode::make(0, control(), memory(addr), addr, addr_type, val, store_num_elem));
 930     set_memory(vstore, addr_type);
 931   } else {
 932     // When using byte array, we need to load as byte then reinterpret the value. Otherwise, do a simple vector load.
 933     Node* vload = nullptr;
 934     if (mismatched_ms) {
 935       vload = gvn().transform(LoadVectorNode::make(0, control(), memory(addr), addr, addr_type, mem_num_elem, mem_elem_bt));
 936       const TypeVect* to_vect_type = TypeVect::make(elem_bt, num_elem);
 937       vload = gvn().transform(new VectorReinterpretNode(vload, vload->bottom_type()->is_vect(), to_vect_type));
 938     } else {
 939       // Special handle for masks
 940       if (is_mask) {
 941         vload = gvn().transform(LoadVectorNode::make(0, control(), memory(addr), addr, addr_type, num_elem, T_BOOLEAN));
 942         vload = gvn().transform(new VectorLoadMaskNode(vload, TypeVect::makemask(elem_bt, num_elem)));
 943       } else {
 944         vload = gvn().transform(LoadVectorNode::make(0, control(), memory(addr), addr, addr_type, num_elem, elem_bt));
 945       }
 946     }
 947     Node* box = box_vector(vload, vbox_type, elem_bt, num_elem);
 948     set_result(box);
 949   }
 950 
 951   old_state.discard();
 952 
 953   if (needs_cpu_membar) {
 954     insert_mem_bar(Op_MemBarCPUOrder);
 955   }
 956 
 957   C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
 958   return true;
 959 }
 960 
 961 //  public static
 962 //  <C,
 963 //   V extends Vector<?>,
 964 //   E,
 965 //   S extends VectorSpecies<E>,
 966 //   M extends VectorMask<E>>
 967 //  V loadMasked(Class<? extends V> vClass, Class<M> mClass, Class<E> eClass,
 968 //               int length, Object base, long offset,          // Unsafe addressing
 969 //               boolean fromSegment,
 970 //               M m, int offsetInRange,
 971 //               C container, long index, S s,                  // Arguments for default implementation
 972 //               LoadVectorMaskedOperation<C, V, S, M> defaultImpl) {
 973 //  public static
 974 //  <C,
 975 //   V extends Vector<E>,
 976 //   M extends VectorMask<E>,
 977 //   E>
 978 //  void storeMasked(Class<? extends V> vClass, Class<M> mClass, Class<E> eClass,
 979 //                   int length,
 980 //                   Object base, long offset,                  // Unsafe addressing
 981 //                   boolean fromSegment,
 982 //                   V v, M m, C container, long index,         // Arguments for default implementation
 983 //                   StoreVectorMaskedOperation<C, V, M> defaultImpl) {
 984 
 985 bool LibraryCallKit::inline_vector_mem_masked_operation(bool is_store) {
 986   const TypeInstPtr* vector_klass = gvn().type(argument(0))->isa_instptr();
 987   const TypeInstPtr* mask_klass   = gvn().type(argument(1))->isa_instptr();
 988   const TypeInstPtr* elem_klass   = gvn().type(argument(2))->isa_instptr();
 989   const TypeInt*     vlen         = gvn().type(argument(3))->isa_int();
 990   const TypeInt*     from_ms      = gvn().type(argument(7))->isa_int();
 991 
 992   if (vector_klass == nullptr || vector_klass->const_oop() == nullptr ||
 993       mask_klass   == nullptr || mask_klass->const_oop()   == nullptr ||
 994       elem_klass   == nullptr || elem_klass->const_oop()   == nullptr ||
 995       vlen         == nullptr || !vlen->is_con() ||
 996       from_ms      == nullptr || !from_ms->is_con()) {
 997     log_if_needed("  ** missing constant: vclass=%s mclass=%s etype=%s vlen=%s from_ms=%s",
 998                     NodeClassNames[argument(0)->Opcode()],
 999                     NodeClassNames[argument(1)->Opcode()],
1000                     NodeClassNames[argument(2)->Opcode()],
1001                     NodeClassNames[argument(3)->Opcode()],
1002                     NodeClassNames[argument(7)->Opcode()]);
1003     return false; // not enough info for intrinsification
1004   }
1005   if (!is_klass_initialized(vector_klass)) {
1006     log_if_needed("  ** klass argument not initialized");
1007     return false;
1008   }
1009 
1010   if (!is_klass_initialized(mask_klass)) {
1011     log_if_needed("  ** mask klass argument not initialized");
1012     return false;
1013   }
1014 
1015   ciType* elem_type = elem_klass->const_oop()->as_instance()->java_mirror_type();
1016   if (!elem_type->is_primitive_type()) {
1017     log_if_needed("  ** not a primitive bt=%d", elem_type->basic_type());
1018     return false; // should be primitive type
1019   }
1020 
1021   BasicType elem_bt = elem_type->basic_type();
1022   int num_elem = vlen->get_con();
1023 
1024   Node* base = argument(4);
1025   Node* offset = ConvL2X(argument(5));
1026 
1027   // Save state and restore on bailout
1028   SavedState old_state(this);
1029 
1030   Node* addr = make_unsafe_address(base, offset, elem_bt, true);
1031   const TypePtr *addr_type = gvn().type(addr)->isa_ptr();
1032   const TypeAryPtr* arr_type = addr_type->isa_aryptr();
1033 
1034   bool mismatched_ms = from_ms->get_con() && arr_type != nullptr && arr_type->elem()->array_element_basic_type() != elem_bt;
1035   BIG_ENDIAN_ONLY(if (mismatched_ms) return false;)
1036   // If there is no consistency between array and vector element types, it must be special byte array case
1037   if (arr_type != nullptr && !elem_consistent_with_arr(elem_bt, arr_type, mismatched_ms)) {
1038     log_if_needed("  ** not supported: arity=%d op=%s vlen=%d etype=%s atype=%s",
1039                     is_store, is_store ? "storeMasked" : "loadMasked",
1040                     num_elem, type2name(elem_bt), type2name(arr_type->elem()->array_element_basic_type()));
1041     return false;
1042   }
1043 
1044   int mem_num_elem = mismatched_ms ? num_elem * type2aelembytes(elem_bt) : num_elem;
1045   BasicType mem_elem_bt = mismatched_ms ? T_BYTE : elem_bt;
1046   bool supports_predicate = arch_supports_vector(is_store ? Op_StoreVectorMasked : Op_LoadVectorMasked,
1047                                                 mem_num_elem, mem_elem_bt, VecMaskUseLoad);
1048 
1049   // If current arch does not support the predicated operations, we have to bail
1050   // out when current case uses the predicate feature.
1051   if (!supports_predicate) {
1052     bool needs_predicate = false;
1053     if (is_store) {
1054       // Masked vector store always uses the predicated store.
1055       needs_predicate = true;
1056     } else {
1057       // Masked vector load with IOOBE always uses the predicated load.
1058       const TypeInt* offset_in_range = gvn().type(argument(9))->isa_int();
1059       if (!offset_in_range->is_con()) {
1060         log_if_needed("  ** missing constant: offsetInRange=%s",
1061                         NodeClassNames[argument(8)->Opcode()]);
1062         return false;
1063       }
1064       needs_predicate = (offset_in_range->get_con() == 0);
1065     }
1066 
1067     if (needs_predicate) {
1068       log_if_needed("  ** not supported: op=%s vlen=%d etype=%s mismatched_ms=%d",
1069                       is_store ? "storeMasked" : "loadMasked",
1070                       num_elem, type2name(elem_bt), mismatched_ms ? 1 : 0);
1071       return false;
1072     }
1073   }
1074 
1075   // This only happens for masked vector load. If predicate is not supported, then check whether
1076   // the normal vector load and blend operations are supported by backend.
1077   if (!supports_predicate && (!arch_supports_vector(Op_LoadVector, mem_num_elem, mem_elem_bt, VecMaskNotUsed) ||
1078       !arch_supports_vector(Op_VectorBlend, mem_num_elem, mem_elem_bt, VecMaskUseLoad))) {
1079     log_if_needed("  ** not supported: op=loadMasked vlen=%d etype=%s mismatched_ms=%d",
1080                     num_elem, type2name(elem_bt), mismatched_ms ? 1 : 0);
1081     return false;
1082   }
1083 
1084   // Since we are using byte array, we need to double check that the vector reinterpret operation
1085   // with byte type is supported by backend.
1086   if (mismatched_ms) {
1087     if (!arch_supports_vector(Op_VectorReinterpret, mem_num_elem, T_BYTE, VecMaskNotUsed)) {
1088       log_if_needed("  ** not supported: arity=%d op=%s vlen=%d etype=%s mismatched_ms=1",
1089                       is_store, is_store ? "storeMasked" : "loadMasked",
1090                       num_elem, type2name(elem_bt));
1091       return false;
1092     }
1093   }
1094 
1095   // Since it needs to unbox the mask, we need to double check that the related load operations
1096   // for mask are supported by backend.
1097   if (!arch_supports_vector(Op_LoadVector, num_elem, elem_bt, VecMaskUseLoad)) {
1098     log_if_needed("  ** not supported: arity=%d op=%s vlen=%d etype=%s",
1099                       is_store, is_store ? "storeMasked" : "loadMasked",
1100                       num_elem, type2name(elem_bt));
1101     return false;
1102   }
1103 
1104   // Can base be null? Otherwise, always on-heap access.
1105   bool can_access_non_heap = TypePtr::NULL_PTR->higher_equal(gvn().type(base));
1106   if (can_access_non_heap) {
1107     insert_mem_bar(Op_MemBarCPUOrder);
1108   }
1109 
1110   ciKlass* vbox_klass = vector_klass->const_oop()->as_instance()->java_lang_Class_klass();
1111   ciKlass* mbox_klass = mask_klass->const_oop()->as_instance()->java_lang_Class_klass();
1112   assert(!is_vector_mask(vbox_klass) && is_vector_mask(mbox_klass), "Invalid class type");
1113   const TypeInstPtr* vbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, vbox_klass);
1114   const TypeInstPtr* mbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, mbox_klass);
1115 
1116   Node* mask = unbox_vector(is_store ? argument(9) : argument(8), mbox_type, elem_bt, num_elem);
1117   if (mask == nullptr) {
1118     log_if_needed("  ** unbox failed mask=%s",
1119                     is_store ? NodeClassNames[argument(9)->Opcode()]
1120                              : NodeClassNames[argument(8)->Opcode()]);
1121     return false;
1122   }
1123 
1124   if (is_store) {
1125     Node* val = unbox_vector(argument(8), vbox_type, elem_bt, num_elem);
1126     if (val == nullptr) {
1127       log_if_needed("  ** unbox failed vector=%s",
1128                       NodeClassNames[argument(8)->Opcode()]);
1129       return false; // operand unboxing failed
1130     }
1131     set_all_memory(reset_memory());
1132 
1133     if (mismatched_ms) {
1134       // Reinterpret the incoming vector to byte vector.
1135       const TypeVect* to_vect_type = TypeVect::make(mem_elem_bt, mem_num_elem);
1136       val = gvn().transform(new VectorReinterpretNode(val, val->bottom_type()->is_vect(), to_vect_type));
1137       // Reinterpret the vector mask to byte type.
1138       const TypeVect* from_mask_type = TypeVect::makemask(elem_bt, num_elem);
1139       const TypeVect* to_mask_type = TypeVect::makemask(mem_elem_bt, mem_num_elem);
1140       mask = gvn().transform(new VectorReinterpretNode(mask, from_mask_type, to_mask_type));
1141     }
1142     Node* vstore = gvn().transform(new StoreVectorMaskedNode(control(), memory(addr), addr, val, addr_type, mask));
1143     set_memory(vstore, addr_type);
1144   } else {
1145     Node* vload = nullptr;
1146 
1147     if (mismatched_ms) {
1148       // Reinterpret the vector mask to byte type.
1149       const TypeVect* from_mask_type = TypeVect::makemask(elem_bt, num_elem);
1150       const TypeVect* to_mask_type = TypeVect::makemask(mem_elem_bt, mem_num_elem);
1151       mask = gvn().transform(new VectorReinterpretNode(mask, from_mask_type, to_mask_type));
1152     }
1153 
1154     if (supports_predicate) {
1155       // Generate masked load vector node if predicate feature is supported.
1156       const TypeVect* vt = TypeVect::make(mem_elem_bt, mem_num_elem);
1157       vload = gvn().transform(new LoadVectorMaskedNode(control(), memory(addr), addr, addr_type, vt, mask));
1158     } else {
1159       // Use the vector blend to implement the masked load vector. The biased elements are zeros.
1160       Node* zero = gvn().transform(gvn().zerocon(mem_elem_bt));
1161       zero = gvn().transform(VectorNode::scalar2vector(zero, mem_num_elem, mem_elem_bt));
1162       vload = gvn().transform(LoadVectorNode::make(0, control(), memory(addr), addr, addr_type, mem_num_elem, mem_elem_bt));
1163       vload = gvn().transform(new VectorBlendNode(zero, vload, mask));
1164     }
1165 
1166     if (mismatched_ms) {
1167       const TypeVect* to_vect_type = TypeVect::make(elem_bt, num_elem);
1168       vload = gvn().transform(new VectorReinterpretNode(vload, vload->bottom_type()->is_vect(), to_vect_type));
1169     }
1170 
1171     Node* box = box_vector(vload, vbox_type, elem_bt, num_elem);
1172     set_result(box);
1173   }
1174 
1175   old_state.discard();
1176 
1177   if (can_access_non_heap) {
1178     insert_mem_bar(Op_MemBarCPUOrder);
1179   }
1180 
1181   C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
1182   return true;
1183 }
1184 
1185 //
1186 //  <C,
1187 //   V extends Vector<?>,
1188 //   W extends Vector<Integer>,
1189 //   S extends VectorSpecies<E>,
1190 //   M extends VectorMask<E>,
1191 //   E>
1192 //   V loadWithMap(Class<? extends V> vClass, Class<M> mClass, Class<E> eClass, int length,
1193 //                 Class<? extends Vector<Integer>> vectorIndexClass, int indexLength,
1194 //                 Object base, long offset,
1195 //                 W indexVector1, W indexVector2, W indexVector3, W indexVector4,
1196 //                 M m, C container, int index, int[] indexMap, int indexM, S s,
1197 //                 LoadVectorOperationWithMap<C, V, S, M> defaultImpl)
1198 //
1199 //  <C,
1200 //   V extends Vector<E>,
1201 //   W extends Vector<Integer>,
1202 //   M extends VectorMask<E>,
1203 //   E>
1204 //   void storeWithMap(Class<? extends V> vClass, Class<M> mClass, Class<E> eClass, int length,
1205 //                     Class<? extends Vector<Integer>> vectorIndexClass, int indexLength,
1206 //                     Object base, long offset, // Unsafe addressing
1207 //                     W indexVector, V v, M m,
1208 //                     C container, int index, int[] indexMap, int indexM, // Arguments for default implementation
1209 //                     StoreVectorOperationWithMap<C, V, M> defaultImpl)
1210 //
1211 bool LibraryCallKit::inline_vector_gather_scatter(bool is_scatter) {
1212   const TypeInstPtr* vector_klass     = gvn().type(argument(0))->isa_instptr();
1213   const TypeInstPtr* mask_klass       = gvn().type(argument(1))->isa_instptr();
1214   const TypeInstPtr* elem_klass       = gvn().type(argument(2))->isa_instptr();
1215   const TypeInt*     vlen             = gvn().type(argument(3))->isa_int();
1216   const TypeInstPtr* vector_idx_klass = gvn().type(argument(4))->isa_instptr();
1217   const TypeInt*     idx_vlen         = gvn().type(argument(5))->isa_int();
1218 
1219   if (vector_klass     == nullptr || vector_klass->const_oop()     == nullptr ||
1220       elem_klass       == nullptr || elem_klass->const_oop()       == nullptr ||
1221       vlen             == nullptr || !vlen->is_con() ||
1222       vector_idx_klass == nullptr || vector_idx_klass->const_oop() == nullptr ||
1223       idx_vlen         == nullptr || !idx_vlen->is_con()) {
1224     log_if_needed("  ** missing constant: vclass=%s etype=%s vlen=%s viclass=%s idx_vlen=%s",
1225                     NodeClassNames[argument(0)->Opcode()],
1226                     NodeClassNames[argument(2)->Opcode()],
1227                     NodeClassNames[argument(3)->Opcode()],
1228                     NodeClassNames[argument(4)->Opcode()],
1229                     NodeClassNames[argument(5)->Opcode()]);
1230     return false; // not enough info for intrinsification
1231   }
1232 
1233   if (!is_klass_initialized(vector_klass) || !is_klass_initialized(vector_idx_klass)) {
1234     log_if_needed("  ** klass argument not initialized");
1235     return false;
1236   }
1237 
1238   ciType* elem_type = elem_klass->const_oop()->as_instance()->java_mirror_type();
1239   if (!elem_type->is_primitive_type()) {
1240     log_if_needed("  ** not a primitive bt=%d", elem_type->basic_type());
1241     return false; // should be primitive type
1242   }
1243 
1244   BasicType elem_bt = elem_type->basic_type();
1245   int num_elem = vlen->get_con();
1246   int idx_num_elem = idx_vlen->get_con();
1247 
1248   Node* m = is_scatter ? argument(11) : argument(13);
1249   const Type* vmask_type = gvn().type(m);
1250   bool is_masked_op = vmask_type != TypePtr::NULL_PTR;
1251   if (is_masked_op) {
1252     if (mask_klass == nullptr || mask_klass->const_oop() == nullptr) {
1253       log_if_needed("  ** missing constant: maskclass=%s", NodeClassNames[argument(1)->Opcode()]);
1254       return false; // not enough info for intrinsification
1255     }
1256 
1257     if (!is_klass_initialized(mask_klass)) {
1258       log_if_needed("  ** mask klass argument not initialized");
1259       return false;
1260     }
1261 
1262     if (vmask_type->maybe_null()) {
1263       log_if_needed("  ** null mask values are not allowed for masked op");
1264       return false;
1265     }
1266 
1267     // Check whether the predicated gather/scatter node is supported by architecture.
1268     VectorMaskUseType mask = (VectorMaskUseType) (VecMaskUseLoad | VecMaskUsePred);
1269     if (!arch_supports_vector(is_scatter ? Op_StoreVectorScatterMasked : Op_LoadVectorGatherMasked, num_elem, elem_bt, mask)) {
1270       log_if_needed("  ** not supported: arity=%d op=%s vlen=%d etype=%s is_masked_op=1",
1271                       is_scatter, is_scatter ? "scatterMasked" : "gatherMasked",
1272                       num_elem, type2name(elem_bt));
1273       return false; // not supported
1274     }
1275   } else {
1276     // Check whether the normal gather/scatter node is supported for non-masked operation.
1277     if (!arch_supports_vector(is_scatter ? Op_StoreVectorScatter : Op_LoadVectorGather, num_elem, elem_bt, VecMaskNotUsed)) {
1278       log_if_needed("  ** not supported: arity=%d op=%s vlen=%d etype=%s is_masked_op=0",
1279                       is_scatter, is_scatter ? "scatter" : "gather",
1280                       num_elem, type2name(elem_bt));
1281       return false; // not supported
1282     }
1283   }
1284 
1285   // Check that the vector holding indices is supported by architecture
1286   // For sub-word gathers expander receive index array.
1287   if (!is_subword_type(elem_bt) && !arch_supports_vector(Op_LoadVector, idx_num_elem, T_INT, VecMaskNotUsed)) {
1288     log_if_needed("  ** not supported: arity=%d op=%s/loadindex vlen=%d etype=int is_masked_op=%d",
1289                   is_scatter, is_scatter ? "scatter" : "gather",
1290                   idx_num_elem, is_masked_op ? 1 : 0);
1291     return false; // not supported
1292   }
1293 
1294   Node* base = argument(6);
1295   Node* offset = ConvL2X(argument(7));
1296 
1297   // Save state and restore on bailout
1298   SavedState old_state(this);
1299 
1300   Node* addr = nullptr;
1301   if (!is_subword_type(elem_bt)) {
1302     addr = make_unsafe_address(base, offset, elem_bt, true);
1303   } else {
1304     assert(!is_scatter, "Only supports gather operation for subword types now");
1305     uint header = arrayOopDesc::base_offset_in_bytes(elem_bt);
1306     assert(offset->is_Con() && offset->bottom_type()->is_long()->get_con() == header,
1307            "offset must be the array base offset");
1308     Node* index = argument(15);
1309     addr = array_element_address(base, index, elem_bt);
1310   }
1311 
1312   const TypePtr* addr_type = gvn().type(addr)->isa_ptr();
1313   const TypeAryPtr* arr_type = addr_type->isa_aryptr();
1314 
1315   // The array must be consistent with vector type
1316   if (arr_type == nullptr || (arr_type != nullptr && !elem_consistent_with_arr(elem_bt, arr_type, false))) {
1317     log_if_needed("  ** not supported: arity=%d op=%s vlen=%d etype=%s atype=%s ismask=no",
1318                     is_scatter, is_scatter ? "scatter" : "gather",
1319                     num_elem, type2name(elem_bt), type2name(arr_type->elem()->array_element_basic_type()));
1320     return false;
1321   }
1322 
1323   ciKlass* vbox_klass = vector_klass->const_oop()->as_instance()->java_lang_Class_klass();
1324   const TypeInstPtr* vbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, vbox_klass);
1325   ciKlass* vbox_idx_klass = vector_idx_klass->const_oop()->as_instance()->java_lang_Class_klass();
1326   if (vbox_idx_klass == nullptr) {
1327     return false;
1328   }
1329 
1330   // Get the indexes for gather/scatter.
1331   Node* indexes = nullptr;
1332   const TypeInstPtr* vbox_idx_type = TypeInstPtr::make_exact(TypePtr::NotNull, vbox_idx_klass);
1333   if (is_subword_type(elem_bt)) {
1334     Node* indexMap = argument(16);
1335     Node* indexM   = argument(17);
1336     indexes = array_element_address(indexMap, indexM, T_INT);
1337   } else {
1338     // Get the first index vector.
1339     indexes = unbox_vector(argument(9), vbox_idx_type, T_INT, idx_num_elem);
1340     if (indexes == nullptr) {
1341       return false;
1342     }
1343   }
1344 
1345   // Get the vector mask value.
1346   Node* mask = nullptr;
1347   if (is_masked_op) {
1348     ciKlass* mbox_klass = mask_klass->const_oop()->as_instance()->java_lang_Class_klass();
1349     const TypeInstPtr* mbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, mbox_klass);
1350     mask = unbox_vector(m, mbox_type, elem_bt, num_elem);
1351     if (mask == nullptr) {
1352       log_if_needed("  ** unbox failed mask=%s", NodeClassNames[m->Opcode()]);
1353       return false;
1354     }
1355   }
1356 
1357   const TypeVect* vector_type = TypeVect::make(elem_bt, num_elem);
1358   if (is_scatter) {
1359     Node* val = unbox_vector(argument(10), vbox_type, elem_bt, num_elem);
1360     if (val == nullptr) {
1361       return false; // operand unboxing failed
1362     }
1363     set_all_memory(reset_memory());
1364 
1365     Node* vstore = nullptr;
1366     if (mask != nullptr) {
1367       vstore = gvn().transform(new StoreVectorScatterMaskedNode(control(), memory(addr), addr, addr_type, val, indexes, mask));
1368     } else {
1369       vstore = gvn().transform(new StoreVectorScatterNode(control(), memory(addr), addr, addr_type, val, indexes));
1370     }
1371     set_memory(vstore, addr_type);
1372   } else {
1373     Node* vload = nullptr;
1374     if (mask != nullptr) {
1375       vload = gvn().transform(new LoadVectorGatherMaskedNode(control(), memory(addr), addr, addr_type, vector_type, indexes, mask));
1376     } else {
1377       vload = gvn().transform(new LoadVectorGatherNode(control(), memory(addr), addr, addr_type, vector_type, indexes));
1378     }
1379     Node* box = box_vector(vload, vbox_type, elem_bt, num_elem);
1380     set_result(box);
1381   }
1382 
1383   old_state.discard();
1384   C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
1385   return true;
1386 }
1387 
1388 // public static
1389 // <V extends Vector<E>,
1390 //  M extends VectorMask<E>,
1391 //  E>
1392 // long reductionCoerced(int oprId, Class<? extends V> vectorClass, Class<? extends M> maskClass,
1393 //                       Class<E> elementType, int length, V v, M m,
1394 //                       ReductionOperation<V, M> defaultImpl)
1395 bool LibraryCallKit::inline_vector_reduction() {
1396   const TypeInt*     opr          = gvn().type(argument(0))->isa_int();
1397   const TypeInstPtr* vector_klass = gvn().type(argument(1))->isa_instptr();
1398   const TypeInstPtr* mask_klass   = gvn().type(argument(2))->isa_instptr();
1399   const TypeInstPtr* elem_klass   = gvn().type(argument(3))->isa_instptr();
1400   const TypeInt*     vlen         = gvn().type(argument(4))->isa_int();
1401 
1402   if (opr          == nullptr || !opr->is_con() ||
1403       vector_klass == nullptr || vector_klass->const_oop() == nullptr ||
1404       elem_klass   == nullptr || elem_klass->const_oop()   == nullptr ||
1405       vlen         == nullptr || !vlen->is_con()) {
1406     log_if_needed("  ** missing constant: opr=%s vclass=%s etype=%s vlen=%s",
1407                     NodeClassNames[argument(0)->Opcode()],
1408                     NodeClassNames[argument(1)->Opcode()],
1409                     NodeClassNames[argument(3)->Opcode()],
1410                     NodeClassNames[argument(4)->Opcode()]);
1411     return false; // not enough info for intrinsification
1412   }
1413   if (!is_klass_initialized(vector_klass)) {
1414     log_if_needed("  ** klass argument not initialized");
1415     return false;
1416   }
1417   ciType* elem_type = elem_klass->const_oop()->as_instance()->java_mirror_type();
1418   if (!elem_type->is_primitive_type()) {
1419     log_if_needed("  ** not a primitive bt=%d", elem_type->basic_type());
1420     return false; // should be primitive type
1421   }
1422 
1423   const Type* vmask_type = gvn().type(argument(6));
1424   bool is_masked_op = vmask_type != TypePtr::NULL_PTR;
1425   if (is_masked_op) {
1426     if (mask_klass == nullptr || mask_klass->const_oop() == nullptr) {
1427       log_if_needed("  ** missing constant: maskclass=%s", NodeClassNames[argument(2)->Opcode()]);
1428       return false; // not enough info for intrinsification
1429     }
1430 
1431     if (!is_klass_initialized(mask_klass)) {
1432       log_if_needed("  ** mask klass argument not initialized");
1433       return false;
1434     }
1435 
1436     if (vmask_type->maybe_null()) {
1437       log_if_needed("  ** null mask values are not allowed for masked op");
1438       return false;
1439     }
1440   }
1441 
1442   BasicType elem_bt = elem_type->basic_type();
1443   int num_elem = vlen->get_con();
1444   int opc  = VectorSupport::vop2ideal(opr->get_con(), elem_bt);
1445   int sopc = ReductionNode::opcode(opc, elem_bt);
1446 
1447   // Ensure reduction operation for lanewise operation
1448   // When using mask, mask use type needs to be VecMaskUseLoad.
1449   if (sopc == opc || !arch_supports_vector(sopc, num_elem, elem_bt, is_masked_op ? VecMaskUseLoad : VecMaskNotUsed)) {
1450     log_if_needed("  ** not supported: arity=1 op=%d/reduce vlen=%d etype=%s is_masked_op=%d",
1451                     sopc, num_elem, type2name(elem_bt), is_masked_op ? 1 : 0);
1452     return false;
1453   }
1454 
1455   // Return true if current platform has implemented the masked operation with predicate feature.
1456   bool use_predicate = is_masked_op && arch_supports_vector(sopc, num_elem, elem_bt, VecMaskUsePred);
1457   if (is_masked_op && !use_predicate && !arch_supports_vector(Op_VectorBlend, num_elem, elem_bt, VecMaskUseLoad)) {
1458     log_if_needed("  ** not supported: arity=1 op=%d/reduce vlen=%d etype=%s is_masked_op=1",
1459                     sopc, num_elem, type2name(elem_bt));
1460     return false;
1461   }
1462 
1463   ciKlass* vbox_klass = vector_klass->const_oop()->as_instance()->java_lang_Class_klass();
1464   const TypeInstPtr* vbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, vbox_klass);
1465 
1466   Node* opd = unbox_vector(argument(5), vbox_type, elem_bt, num_elem);
1467   if (opd == nullptr) {
1468     return false; // operand unboxing failed
1469   }
1470 
1471   Node* mask = nullptr;
1472   if (is_masked_op) {
1473     ciKlass* mbox_klass = mask_klass->const_oop()->as_instance()->java_lang_Class_klass();
1474     assert(is_vector_mask(mbox_klass), "argument(2) should be a mask class");
1475     const TypeInstPtr* mbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, mbox_klass);
1476     mask = unbox_vector(argument(6), mbox_type, elem_bt, num_elem);
1477     if (mask == nullptr) {
1478       log_if_needed("  ** unbox failed mask=%s",
1479                       NodeClassNames[argument(6)->Opcode()]);
1480       return false;
1481     }
1482   }
1483 
1484   Node* init = ReductionNode::make_identity_con_scalar(gvn(), opc, elem_bt);
1485   Node* value = opd;
1486 
1487   assert(mask != nullptr || !is_masked_op, "Masked op needs the mask value never null");
1488   if (mask != nullptr && !use_predicate) {
1489     Node* reduce_identity = gvn().transform(VectorNode::scalar2vector(init, num_elem, elem_bt));
1490     value = gvn().transform(new VectorBlendNode(reduce_identity, value, mask));
1491   }
1492 
1493   // Make an unordered Reduction node. This affects only AddReductionVF/VD and MulReductionVF/VD,
1494   // as these operations are allowed to be associative (not requiring strict order) in VectorAPI.
1495   value = ReductionNode::make(opc, nullptr, init, value, elem_bt, /* requires_strict_order */ false);
1496 
1497   if (mask != nullptr && use_predicate) {
1498     value->add_req(mask);
1499     value->add_flag(Node::Flag_is_predicated_vector);
1500   }
1501 
1502   value = gvn().transform(value);
1503 
1504   Node* bits = nullptr;
1505   switch (elem_bt) {
1506     case T_BYTE:
1507     case T_SHORT:
1508     case T_INT: {
1509       bits = gvn().transform(new ConvI2LNode(value));
1510       break;
1511     }
1512     case T_FLOAT: {
1513       value = gvn().transform(new MoveF2INode(value));
1514       bits  = gvn().transform(new ConvI2LNode(value));
1515       break;
1516     }
1517     case T_DOUBLE: {
1518       bits = gvn().transform(new MoveD2LNode(value));
1519       break;
1520     }
1521     case T_LONG: {
1522       bits = value; // no conversion needed
1523       break;
1524     }
1525     default: fatal("%s", type2name(elem_bt));
1526   }
1527   set_result(bits);
1528   C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
1529   return true;
1530 }
1531 
1532 // public static <V> boolean test(int cond, Class<?> vectorClass, Class<?> elementType, int vlen,
1533 //                                V v1, V v2,
1534 //                                BiFunction<V, V, Boolean> defaultImpl)
1535 //
1536 bool LibraryCallKit::inline_vector_test() {
1537   const TypeInt*     cond         = gvn().type(argument(0))->isa_int();
1538   const TypeInstPtr* vector_klass = gvn().type(argument(1))->isa_instptr();
1539   const TypeInstPtr* elem_klass   = gvn().type(argument(2))->isa_instptr();
1540   const TypeInt*     vlen         = gvn().type(argument(3))->isa_int();
1541 
1542   if (cond         == nullptr || !cond->is_con() ||
1543       vector_klass == nullptr || vector_klass->const_oop() == nullptr ||
1544       elem_klass   == nullptr || elem_klass->const_oop()   == nullptr ||
1545       vlen         == nullptr || !vlen->is_con()) {
1546     log_if_needed("  ** missing constant: cond=%s vclass=%s etype=%s vlen=%s",
1547                     NodeClassNames[argument(0)->Opcode()],
1548                     NodeClassNames[argument(1)->Opcode()],
1549                     NodeClassNames[argument(2)->Opcode()],
1550                     NodeClassNames[argument(3)->Opcode()]);
1551     return false; // not enough info for intrinsification
1552   }
1553   if (!is_klass_initialized(vector_klass)) {
1554     log_if_needed("  ** klass argument not initialized");
1555     return false;
1556   }
1557   ciType* elem_type = elem_klass->const_oop()->as_instance()->java_mirror_type();
1558   if (!elem_type->is_primitive_type()) {
1559     log_if_needed("  ** not a primitive bt=%d", elem_type->basic_type());
1560     return false; // should be primitive type
1561   }
1562   BasicType elem_bt = elem_type->basic_type();
1563   int num_elem = vlen->get_con();
1564   BoolTest::mask booltest = (BoolTest::mask)cond->get_con();
1565   ciKlass* vbox_klass = vector_klass->const_oop()->as_instance()->java_lang_Class_klass();
1566   const TypeInstPtr* vbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, vbox_klass);
1567 
1568   if (!arch_supports_vector(Op_VectorTest, num_elem, elem_bt, is_vector_mask(vbox_klass) ? VecMaskUseLoad : VecMaskNotUsed)) {
1569     log_if_needed("  ** not supported: arity=2 op=test/%d vlen=%d etype=%s ismask=%d",
1570                     cond->get_con(), num_elem, type2name(elem_bt),
1571                     is_vector_mask(vbox_klass));
1572     return false;
1573   }
1574 
1575   Node* opd1 = unbox_vector(argument(4), vbox_type, elem_bt, num_elem);
1576   Node* opd2;
1577   if (Matcher::vectortest_needs_second_argument(booltest == BoolTest::overflow,
1578                                                 opd1->bottom_type()->isa_vectmask())) {
1579     opd2 = unbox_vector(argument(5), vbox_type, elem_bt, num_elem);
1580   } else {
1581     opd2 = opd1;
1582   }
1583   if (opd1 == nullptr || opd2 == nullptr) {
1584     return false; // operand unboxing failed
1585   }
1586 
1587   Node* cmp = gvn().transform(new VectorTestNode(opd1, opd2, booltest));
1588   BoolTest::mask test = Matcher::vectortest_mask(booltest == BoolTest::overflow,
1589                                                  opd1->bottom_type()->isa_vectmask(), num_elem);
1590   Node* bol = gvn().transform(new BoolNode(cmp, test));
1591   Node* res = gvn().transform(new CMoveINode(bol, gvn().intcon(0), gvn().intcon(1), TypeInt::BOOL));
1592 
1593   set_result(res);
1594   C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
1595   return true;
1596 }
1597 
1598 // public static
1599 // <V extends Vector<E>,
1600 //  M extends VectorMask<E>,
1601 //  E>
1602 // V blend(Class<? extends V> vectorClass, Class<M> maskClass, Class<E> elementType, int vlen,
1603 //         V v1, V v2, M m,
1604 //         VectorBlendOp<V, M, E> defaultImpl)
1605 bool LibraryCallKit::inline_vector_blend() {
1606   const TypeInstPtr* vector_klass = gvn().type(argument(0))->isa_instptr();
1607   const TypeInstPtr* mask_klass   = gvn().type(argument(1))->isa_instptr();
1608   const TypeInstPtr* elem_klass   = gvn().type(argument(2))->isa_instptr();
1609   const TypeInt*     vlen         = gvn().type(argument(3))->isa_int();
1610 
1611   if (mask_klass == nullptr || vector_klass == nullptr || elem_klass == nullptr || vlen == nullptr) {
1612     return false; // dead code
1613   }
1614   if (mask_klass->const_oop() == nullptr || vector_klass->const_oop() == nullptr ||
1615       elem_klass->const_oop() == nullptr || !vlen->is_con()) {
1616     log_if_needed("  ** missing constant: vclass=%s mclass=%s etype=%s vlen=%s",
1617                     NodeClassNames[argument(0)->Opcode()],
1618                     NodeClassNames[argument(1)->Opcode()],
1619                     NodeClassNames[argument(2)->Opcode()],
1620                     NodeClassNames[argument(3)->Opcode()]);
1621     return false; // not enough info for intrinsification
1622   }
1623   if (!is_klass_initialized(vector_klass) || !is_klass_initialized(mask_klass)) {
1624     log_if_needed("  ** klass argument not initialized");
1625     return false;
1626   }
1627   ciType* elem_type = elem_klass->const_oop()->as_instance()->java_mirror_type();
1628   if (!elem_type->is_primitive_type()) {
1629     log_if_needed("  ** not a primitive bt=%d", elem_type->basic_type());
1630     return false; // should be primitive type
1631   }
1632   BasicType elem_bt = elem_type->basic_type();
1633   BasicType mask_bt = elem_bt;
1634   int num_elem = vlen->get_con();
1635 
1636   if (!arch_supports_vector(Op_VectorBlend, num_elem, elem_bt, VecMaskUseLoad)) {
1637     log_if_needed("  ** not supported: arity=2 op=blend vlen=%d etype=%s ismask=useload",
1638                     num_elem, type2name(elem_bt));
1639     return false; // not supported
1640   }
1641   ciKlass* vbox_klass = vector_klass->const_oop()->as_instance()->java_lang_Class_klass();
1642   const TypeInstPtr* vbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, vbox_klass);
1643 
1644   ciKlass* mbox_klass = mask_klass->const_oop()->as_instance()->java_lang_Class_klass();
1645   const TypeInstPtr* mbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, mbox_klass);
1646 
1647   Node* v1   = unbox_vector(argument(4), vbox_type, elem_bt, num_elem);
1648   Node* v2   = unbox_vector(argument(5), vbox_type, elem_bt, num_elem);
1649   Node* mask = unbox_vector(argument(6), mbox_type, mask_bt, num_elem);
1650 
1651   if (v1 == nullptr || v2 == nullptr || mask == nullptr) {
1652     return false; // operand unboxing failed
1653   }
1654 
1655   Node* blend = gvn().transform(new VectorBlendNode(v1, v2, mask));
1656 
1657   Node* box = box_vector(blend, vbox_type, elem_bt, num_elem);
1658   set_result(box);
1659   C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
1660   return true;
1661 }
1662 
1663 //  public static
1664 //  <V extends Vector<E>,
1665 //   M extends VectorMask<E>,
1666 //   E>
1667 //  M compare(int cond, Class<? extends V> vectorClass, Class<M> maskClass, Class<E> elementType, int vlen,
1668 //            V v1, V v2, M m,
1669 //            VectorCompareOp<V,M> defaultImpl)
1670 bool LibraryCallKit::inline_vector_compare() {
1671   const TypeInt*     cond         = gvn().type(argument(0))->isa_int();
1672   const TypeInstPtr* vector_klass = gvn().type(argument(1))->isa_instptr();
1673   const TypeInstPtr* mask_klass   = gvn().type(argument(2))->isa_instptr();
1674   const TypeInstPtr* elem_klass   = gvn().type(argument(3))->isa_instptr();
1675   const TypeInt*     vlen         = gvn().type(argument(4))->isa_int();
1676 
1677   if (cond == nullptr || vector_klass == nullptr || mask_klass == nullptr || elem_klass == nullptr || vlen == nullptr) {
1678     return false; // dead code
1679   }
1680   if (!cond->is_con() || vector_klass->const_oop() == nullptr || mask_klass->const_oop() == nullptr ||
1681       elem_klass->const_oop() == nullptr || !vlen->is_con()) {
1682     log_if_needed("  ** missing constant: cond=%s vclass=%s mclass=%s etype=%s vlen=%s",
1683                     NodeClassNames[argument(0)->Opcode()],
1684                     NodeClassNames[argument(1)->Opcode()],
1685                     NodeClassNames[argument(2)->Opcode()],
1686                     NodeClassNames[argument(3)->Opcode()],
1687                     NodeClassNames[argument(4)->Opcode()]);
1688     return false; // not enough info for intrinsification
1689   }
1690   if (!is_klass_initialized(vector_klass) || !is_klass_initialized(mask_klass)) {
1691     log_if_needed("  ** klass argument not initialized");
1692     return false;
1693   }
1694   ciType* elem_type = elem_klass->const_oop()->as_instance()->java_mirror_type();
1695   if (!elem_type->is_primitive_type()) {
1696     log_if_needed("  ** not a primitive bt=%d", elem_type->basic_type());
1697     return false; // should be primitive type
1698   }
1699 
1700   int num_elem = vlen->get_con();
1701   BasicType elem_bt = elem_type->basic_type();
1702   BasicType mask_bt = elem_bt;
1703 
1704   if ((cond->get_con() & BoolTest::unsigned_compare) != 0) {
1705     if (!Matcher::supports_vector_comparison_unsigned(num_elem, elem_bt)) {
1706       log_if_needed("  ** not supported: unsigned comparison op=comp/%d vlen=%d etype=%s ismask=usestore",
1707                       cond->get_con() & (BoolTest::unsigned_compare - 1), num_elem, type2name(elem_bt));
1708       return false;
1709     }
1710   }
1711 
1712   if (!arch_supports_vector(Op_VectorMaskCmp, num_elem, elem_bt, VecMaskUseStore)) {
1713     log_if_needed("  ** not supported: arity=2 op=comp/%d vlen=%d etype=%s ismask=usestore",
1714                     cond->get_con(), num_elem, type2name(elem_bt));
1715     return false;
1716   }
1717 
1718   ciKlass* vbox_klass = vector_klass->const_oop()->as_instance()->java_lang_Class_klass();
1719   const TypeInstPtr* vbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, vbox_klass);
1720 
1721   ciKlass* mbox_klass = mask_klass->const_oop()->as_instance()->java_lang_Class_klass();
1722   const TypeInstPtr* mbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, mbox_klass);
1723 
1724   Node* v1 = unbox_vector(argument(5), vbox_type, elem_bt, num_elem);
1725   Node* v2 = unbox_vector(argument(6), vbox_type, elem_bt, num_elem);
1726 
1727   bool is_masked_op = argument(7)->bottom_type() != TypePtr::NULL_PTR;
1728   Node* mask = is_masked_op ? unbox_vector(argument(7), mbox_type, elem_bt, num_elem) : nullptr;
1729   if (is_masked_op && mask == nullptr) {
1730     log_if_needed("  ** not supported: mask = null arity=2 op=comp/%d vlen=%d etype=%s ismask=usestore is_masked_op=1",
1731                     cond->get_con(), num_elem, type2name(elem_bt));
1732     return false;
1733   }
1734 
1735   bool use_predicate = is_masked_op && arch_supports_vector(Op_VectorMaskCmp, num_elem, elem_bt, VecMaskUsePred);
1736   if (is_masked_op && !use_predicate && !arch_supports_vector(Op_AndV, num_elem, elem_bt, VecMaskUseLoad)) {
1737     log_if_needed("  ** not supported: arity=2 op=comp/%d vlen=%d etype=%s ismask=usestore is_masked_op=1",
1738                     cond->get_con(), num_elem, type2name(elem_bt));
1739     return false;
1740   }
1741 
1742   if (v1 == nullptr || v2 == nullptr) {
1743     return false; // operand unboxing failed
1744   }
1745   BoolTest::mask pred = (BoolTest::mask)cond->get_con();
1746   ConINode* pred_node = (ConINode*)gvn().makecon(cond);
1747 
1748   const TypeVect* vmask_type = TypeVect::makemask(mask_bt, num_elem);
1749   Node* operation = new VectorMaskCmpNode(pred, v1, v2, pred_node, vmask_type);
1750 
1751   if (is_masked_op) {
1752     if (use_predicate) {
1753       operation->add_req(mask);
1754       operation->add_flag(Node::Flag_is_predicated_vector);
1755     } else {
1756       operation = gvn().transform(operation);
1757       operation = VectorNode::make(Op_AndV, operation, mask, vmask_type);
1758     }
1759   }
1760 
1761   operation = gvn().transform(operation);
1762 
1763   Node* box = box_vector(operation, mbox_type, mask_bt, num_elem);
1764   set_result(box);
1765   C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
1766   return true;
1767 }
1768 
1769 // public static
1770 // <V extends Vector<E>,
1771 //  Sh extends VectorShuffle<E>,
1772 //  M extends VectorMask<E>,
1773 //  E>
1774 // V rearrangeOp(Class<? extends V> vectorClass, Class<Sh> shuffleClass, Class<M> maskClass, Class<E> elementType, int vlen,
1775 //               V v1, Sh sh, M m,
1776 //               VectorRearrangeOp<V, Sh, M, E> defaultImpl)
1777 bool LibraryCallKit::inline_vector_rearrange() {
1778   const TypeInstPtr* vector_klass  = gvn().type(argument(0))->isa_instptr();
1779   const TypeInstPtr* shuffle_klass = gvn().type(argument(1))->isa_instptr();
1780   const TypeInstPtr* mask_klass    = gvn().type(argument(2))->isa_instptr();
1781   const TypeInstPtr* elem_klass    = gvn().type(argument(3))->isa_instptr();
1782   const TypeInt*     vlen          = gvn().type(argument(4))->isa_int();
1783 
1784   if (vector_klass == nullptr  || shuffle_klass == nullptr ||  elem_klass == nullptr || vlen == nullptr) {
1785     return false; // dead code
1786   }
1787   if (shuffle_klass->const_oop() == nullptr ||
1788       vector_klass->const_oop()  == nullptr ||
1789       elem_klass->const_oop()    == nullptr ||
1790       !vlen->is_con()) {
1791     log_if_needed("  ** missing constant: vclass=%s sclass=%s etype=%s vlen=%s",
1792                     NodeClassNames[argument(0)->Opcode()],
1793                     NodeClassNames[argument(1)->Opcode()],
1794                     NodeClassNames[argument(3)->Opcode()],
1795                     NodeClassNames[argument(4)->Opcode()]);
1796     return false; // not enough info for intrinsification
1797   }
1798   if (!is_klass_initialized(vector_klass)  ||
1799       !is_klass_initialized(shuffle_klass)) {
1800     log_if_needed("  ** klass argument not initialized");
1801     return false;
1802   }
1803   ciType* elem_type = elem_klass->const_oop()->as_instance()->java_mirror_type();
1804   if (!elem_type->is_primitive_type()) {
1805     log_if_needed("  ** not a primitive bt=%d", elem_type->basic_type());
1806     return false; // should be primitive type
1807   }
1808 
1809   BasicType elem_bt = elem_type->basic_type();
1810   BasicType shuffle_bt = elem_bt;
1811   if (shuffle_bt == T_FLOAT) {
1812     shuffle_bt = T_INT;
1813   } else if (shuffle_bt == T_DOUBLE) {
1814     shuffle_bt = T_LONG;
1815   }
1816 
1817   int num_elem = vlen->get_con();
1818   bool need_load_shuffle = Matcher::vector_rearrange_requires_load_shuffle(shuffle_bt, num_elem);
1819 
1820   if (need_load_shuffle && !arch_supports_vector(Op_VectorLoadShuffle, num_elem, shuffle_bt, VecMaskNotUsed)) {
1821     if (C->print_intrinsics()) {
1822       tty->print_cr("  ** not supported: arity=0 op=load/shuffle vlen=%d etype=%s ismask=no",
1823                     num_elem, type2name(shuffle_bt));
1824     }
1825     return false; // not supported
1826   }
1827 
1828   bool is_masked_op = argument(7)->bottom_type() != TypePtr::NULL_PTR;
1829   bool use_predicate = is_masked_op;
1830   if (is_masked_op &&
1831       (mask_klass == nullptr ||
1832        mask_klass->const_oop() == nullptr ||
1833        !is_klass_initialized(mask_klass))) {
1834     log_if_needed("  ** mask_klass argument not initialized");
1835   }
1836   if (!arch_supports_vector(Op_AndV, num_elem, elem_bt, VecMaskNotUsed)) {
1837     log_if_needed("  ** not supported: arity=2 op=and vlen=%d etype=%s ismask=no",
1838                       num_elem, type2name(elem_bt));
1839     return false;
1840   }
1841   VectorMaskUseType checkFlags = (VectorMaskUseType)(is_masked_op ? (VecMaskUseLoad | VecMaskUsePred) : VecMaskNotUsed);
1842   if (!arch_supports_vector(Op_VectorRearrange, num_elem, elem_bt, checkFlags)) {
1843     use_predicate = false;
1844     if(!is_masked_op ||
1845        (!arch_supports_vector(Op_VectorRearrange, num_elem, elem_bt, VecMaskNotUsed) ||
1846         !arch_supports_vector(Op_VectorBlend, num_elem, elem_bt, VecMaskUseLoad)     ||
1847         !arch_supports_vector(Op_Replicate, num_elem, elem_bt, VecMaskNotUsed))) {
1848       log_if_needed("  ** not supported: arity=2 op=shuffle/rearrange vlen=%d etype=%s ismask=no",
1849                       num_elem, type2name(elem_bt));
1850       return false; // not supported
1851     }
1852   }
1853   ciKlass* vbox_klass = vector_klass->const_oop()->as_instance()->java_lang_Class_klass();
1854   const TypeInstPtr* vbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, vbox_klass);
1855 
1856   ciKlass* shbox_klass = shuffle_klass->const_oop()->as_instance()->java_lang_Class_klass();
1857   const TypeInstPtr* shbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, shbox_klass);
1858 
1859   Node* v1 = unbox_vector(argument(5), vbox_type, elem_bt, num_elem);
1860   Node* shuffle = unbox_vector(argument(6), shbox_type, shuffle_bt, num_elem);
1861   const TypeVect* st = TypeVect::make(shuffle_bt, num_elem);
1862 
1863   if (v1 == nullptr || shuffle == nullptr) {
1864     return false; // operand unboxing failed
1865   }
1866 
1867   assert(is_power_of_2(num_elem), "wrapping invalid");
1868   Node* wrapping_mask_elem = gvn().makecon(TypeInteger::make(num_elem - 1, num_elem - 1, Type::WidenMin, shuffle_bt == T_LONG ? T_LONG : T_INT));
1869   Node* wrapping_mask = gvn().transform(VectorNode::scalar2vector(wrapping_mask_elem, num_elem, shuffle_bt));
1870   shuffle = gvn().transform(new AndVNode(shuffle, wrapping_mask, st));
1871 
1872   Node* mask = nullptr;
1873   if (is_masked_op) {
1874     ciKlass* mbox_klass = mask_klass->const_oop()->as_instance()->java_lang_Class_klass();
1875     const TypeInstPtr* mbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, mbox_klass);
1876     mask = unbox_vector(argument(7), mbox_type, elem_bt, num_elem);
1877     if (mask == nullptr) {
1878       log_if_needed("  ** not supported: arity=3 op=shuffle/rearrange vlen=%d etype=%s ismask=useload is_masked_op=1",
1879                       num_elem, type2name(elem_bt));
1880       return false;
1881     }
1882   }
1883 
1884   if (need_load_shuffle) {
1885     shuffle = gvn().transform(new VectorLoadShuffleNode(shuffle, st));
1886   }
1887 
1888   Node* rearrange = new VectorRearrangeNode(v1, shuffle);
1889   if (is_masked_op) {
1890     if (use_predicate) {
1891       rearrange->add_req(mask);
1892       rearrange->add_flag(Node::Flag_is_predicated_vector);
1893     } else {
1894       rearrange = gvn().transform(rearrange);
1895       Node* zero = gvn().makecon(Type::get_zero_type(elem_bt));
1896       Node* zerovec = gvn().transform(VectorNode::scalar2vector(zero, num_elem, elem_bt));
1897       rearrange = new VectorBlendNode(zerovec, rearrange, mask);
1898     }
1899   }
1900   rearrange = gvn().transform(rearrange);
1901 
1902   Node* box = box_vector(rearrange, vbox_type, elem_bt, num_elem);
1903   set_result(box);
1904   C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
1905   return true;
1906 }
1907 
1908 //    public static
1909 //    <V extends Vector<E>,
1910 //     M  extends VectorMask<E>,
1911 //     E>
1912 //    V selectFromOp(Class<? extends V> vClass, Class<M> mClass, Class<E> eClass,
1913 //                   int length, V v1, V v2, M m,
1914 //                   VectorSelectFromOp<V, M> defaultImpl)
1915 bool LibraryCallKit::inline_vector_select_from() {
1916   const TypeInstPtr* vector_klass  = gvn().type(argument(0))->isa_instptr();
1917   const TypeInstPtr* mask_klass    = gvn().type(argument(1))->isa_instptr();
1918   const TypeInstPtr* elem_klass    = gvn().type(argument(2))->isa_instptr();
1919   const TypeInt*     vlen          = gvn().type(argument(3))->isa_int();
1920 
1921   if (vector_klass == nullptr  || elem_klass == nullptr || vlen == nullptr ||
1922       vector_klass->const_oop()  == nullptr ||
1923       elem_klass->const_oop()    == nullptr ||
1924       !vlen->is_con()) {
1925     log_if_needed("  ** missing constant: vclass=%s etype=%s vlen=%s",
1926                     NodeClassNames[argument(0)->Opcode()],
1927                     NodeClassNames[argument(2)->Opcode()],
1928                     NodeClassNames[argument(3)->Opcode()]);
1929     return false; // not enough info for intrinsification
1930   }
1931   if (!is_klass_initialized(vector_klass)) {
1932     log_if_needed("  ** klass argument not initialized");
1933     return false;
1934   }
1935   ciType* elem_type = elem_klass->const_oop()->as_instance()->java_mirror_type();
1936   if (!elem_type->is_primitive_type()) {
1937     log_if_needed("  ** not a primitive bt=%d", elem_type->basic_type());
1938     return false; // should be primitive type
1939   }
1940   BasicType elem_bt = elem_type->basic_type();
1941   int num_elem = vlen->get_con();
1942   if (!is_power_of_2(num_elem)) {
1943     log_if_needed("  ** vlen not power of two=%d", num_elem);
1944     return false;
1945   }
1946 
1947   BasicType shuffle_bt = elem_bt;
1948   if (shuffle_bt == T_FLOAT) {
1949     shuffle_bt = T_INT;
1950   } else if (shuffle_bt == T_DOUBLE) {
1951     shuffle_bt = T_LONG;
1952   }
1953   bool need_load_shuffle = Matcher::vector_rearrange_requires_load_shuffle(shuffle_bt, num_elem);
1954 
1955   int cast_vopc = VectorCastNode::opcode(-1, elem_bt); // from vector of type elem_bt
1956   if ((need_load_shuffle && !arch_supports_vector(Op_VectorLoadShuffle, num_elem, elem_bt, VecMaskNotUsed)) ||
1957       (elem_bt != shuffle_bt && !arch_supports_vector(cast_vopc, num_elem, shuffle_bt, VecMaskNotUsed))     ||
1958       !arch_supports_vector(Op_AndV, num_elem, shuffle_bt, VecMaskNotUsed) ||
1959       !arch_supports_vector(Op_Replicate, num_elem, shuffle_bt, VecMaskNotUsed)) {
1960     log_if_needed("  ** not supported: arity=0 op=selectFrom vlen=%d etype=%s ismask=no",
1961                     num_elem, type2name(elem_bt));
1962     return false; // not supported
1963   }
1964 
1965   bool is_masked_op = argument(6)->bottom_type() != TypePtr::NULL_PTR;
1966   bool use_predicate = is_masked_op;
1967   if (is_masked_op &&
1968       (mask_klass == nullptr ||
1969        mask_klass->const_oop() == nullptr ||
1970        !is_klass_initialized(mask_klass))) {
1971     log_if_needed("  ** mask_klass argument not initialized");
1972     return false; // not supported
1973   }
1974   VectorMaskUseType checkFlags = (VectorMaskUseType)(is_masked_op ? (VecMaskUseLoad | VecMaskUsePred) : VecMaskNotUsed);
1975   if (!arch_supports_vector(Op_VectorRearrange, num_elem, elem_bt, checkFlags)) {
1976     use_predicate = false;
1977     if(!is_masked_op ||
1978        (!arch_supports_vector(Op_VectorRearrange, num_elem, elem_bt, VecMaskNotUsed) ||
1979         !arch_supports_vector(Op_VectorBlend, num_elem, elem_bt, VecMaskUseLoad)     ||
1980         !arch_supports_vector(Op_Replicate, num_elem, elem_bt, VecMaskNotUsed))) {
1981       log_if_needed("  ** not supported: op=selectFrom vlen=%d etype=%s is_masked_op=%d",
1982                       num_elem, type2name(elem_bt), is_masked_op);
1983       return false; // not supported
1984     }
1985   }
1986   ciKlass* vbox_klass = vector_klass->const_oop()->as_instance()->java_lang_Class_klass();
1987   const TypeInstPtr* vbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, vbox_klass);
1988 
1989   // v1 is the index vector
1990   Node* v1 = unbox_vector(argument(4), vbox_type, elem_bt, num_elem);
1991   // v2 is the vector being rearranged
1992   Node* v2 = unbox_vector(argument(5), vbox_type, elem_bt, num_elem);
1993 
1994   if (v1 == nullptr) {
1995     log_if_needed("  ** unbox failed v1=%s", NodeClassNames[argument(4)->Opcode()]);
1996     return false; // operand unboxing failed
1997   }
1998 
1999   if (v2 == nullptr) {
2000     log_if_needed("  ** unbox failed v2=%s", NodeClassNames[argument(5)->Opcode()]);
2001     return false; // operand unboxing failed
2002   }
2003 
2004   Node* mask = nullptr;
2005   if (is_masked_op) {
2006     ciKlass* mbox_klass = mask_klass->const_oop()->as_instance()->java_lang_Class_klass();
2007     const TypeInstPtr* mbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, mbox_klass);
2008     mask = unbox_vector(argument(6), mbox_type, elem_bt, num_elem);
2009     if (mask == nullptr) {
2010       log_if_needed("  ** unbox failed mask=%s", NodeClassNames[argument(6)->Opcode()]);
2011       return false;
2012     }
2013   }
2014 
2015   // cast index vector from elem_bt vector to byte vector
2016   const TypeVect* shuffle_vt = TypeVect::make(shuffle_bt, num_elem);
2017   Node* shuffle = v1;
2018 
2019   if (shuffle_bt != elem_bt) {
2020     shuffle = gvn().transform(VectorCastNode::make(cast_vopc, v1, shuffle_bt, num_elem));
2021   }
2022 
2023   // wrap the byte vector lanes to (num_elem - 1) to form the shuffle vector where num_elem is vector length
2024   // this is a simple AND operation as we come here only for power of two vector length
2025   Node* mod_val = gvn().makecon(TypeInteger::make(num_elem - 1, num_elem - 1, Type::WidenMin, shuffle_bt == T_LONG ? T_LONG : T_INT));
2026   Node* bcast_mod = gvn().transform(VectorNode::scalar2vector(mod_val, num_elem, shuffle_bt));
2027   shuffle = gvn().transform(VectorNode::make(Op_AndV, shuffle, bcast_mod, shuffle_vt));
2028 
2029   // load the shuffle to use in rearrange
2030   if (need_load_shuffle) {
2031     shuffle = gvn().transform(new VectorLoadShuffleNode(shuffle, shuffle_vt));
2032   }
2033 
2034   // and finally rearrange
2035   Node* rearrange = new VectorRearrangeNode(v2, shuffle);
2036   if (is_masked_op) {
2037     if (use_predicate) {
2038       // masked rearrange is supported so use that directly
2039       rearrange->add_req(mask);
2040       rearrange->add_flag(Node::Flag_is_predicated_vector);
2041     } else {
2042       // masked rearrange is not supported so emulate usig blend
2043       const TypeVect* vt = v1->bottom_type()->is_vect();
2044       rearrange = gvn().transform(rearrange);
2045 
2046       // create a zero vector with each lane element set as zero
2047       Node* zero = gvn().makecon(Type::get_zero_type(elem_bt));
2048       Node* zerovec = gvn().transform(VectorNode::scalar2vector(zero, num_elem, elem_bt));
2049 
2050       // For each lane for which mask is set, blend in the rearranged lane into zero vector
2051       rearrange = new VectorBlendNode(zerovec, rearrange, mask);
2052     }
2053   }
2054   rearrange = gvn().transform(rearrange);
2055 
2056   // box the result
2057   Node* box = box_vector(rearrange, vbox_type, elem_bt, num_elem);
2058   set_result(box);
2059 
2060   C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
2061   return true;
2062 }
2063 
2064 //  public static
2065 //  <V extends Vector<E>,
2066 //   M extends VectorMask<E>,
2067 //   E>
2068 //  V broadcastInt(int opr, Class<? extends V> vectorClass, Class<? extends M> maskClass,
2069 //                 Class<E> elementType, int length,
2070 //                 V v, int n, M m,
2071 //                 VectorBroadcastIntOp<V, M> defaultImpl)
2072 bool LibraryCallKit::inline_vector_broadcast_int() {
2073   const TypeInt*     opr          = gvn().type(argument(0))->isa_int();
2074   const TypeInstPtr* vector_klass = gvn().type(argument(1))->isa_instptr();
2075   const TypeInstPtr* mask_klass   = gvn().type(argument(2))->isa_instptr();
2076   const TypeInstPtr* elem_klass   = gvn().type(argument(3))->isa_instptr();
2077   const TypeInt*     vlen         = gvn().type(argument(4))->isa_int();
2078 
2079   if (opr == nullptr || vector_klass == nullptr || elem_klass == nullptr || vlen == nullptr) {
2080     return false; // dead code
2081   }
2082   if (!opr->is_con() || vector_klass->const_oop() == nullptr || elem_klass->const_oop() == nullptr || !vlen->is_con()) {
2083     log_if_needed("  ** missing constant: opr=%s vclass=%s etype=%s vlen=%s",
2084                     NodeClassNames[argument(0)->Opcode()],
2085                     NodeClassNames[argument(1)->Opcode()],
2086                     NodeClassNames[argument(3)->Opcode()],
2087                     NodeClassNames[argument(4)->Opcode()]);
2088     return false; // not enough info for intrinsification
2089   }
2090   if (!is_klass_initialized(vector_klass)) {
2091     log_if_needed("  ** klass argument not initialized");
2092     return false;
2093   }
2094 
2095   const Type* vmask_type = gvn().type(argument(7));
2096   bool is_masked_op = vmask_type != TypePtr::NULL_PTR;
2097   if (is_masked_op) {
2098     if (mask_klass == nullptr || mask_klass->const_oop() == nullptr) {
2099       log_if_needed("  ** missing constant: maskclass=%s", NodeClassNames[argument(2)->Opcode()]);
2100       return false; // not enough info for intrinsification
2101     }
2102 
2103     if (!is_klass_initialized(mask_klass)) {
2104       log_if_needed("  ** mask klass argument not initialized");
2105       return false;
2106     }
2107 
2108     if (vmask_type->maybe_null()) {
2109       log_if_needed("  ** null mask values are not allowed for masked op");
2110       return false;
2111     }
2112   }
2113 
2114   ciType* elem_type = elem_klass->const_oop()->as_instance()->java_mirror_type();
2115   if (!elem_type->is_primitive_type()) {
2116     log_if_needed("  ** not a primitive bt=%d", elem_type->basic_type());
2117     return false; // should be primitive type
2118   }
2119 
2120   int num_elem = vlen->get_con();
2121   BasicType elem_bt = elem_type->basic_type();
2122   int opc = VectorSupport::vop2ideal(opr->get_con(), elem_bt);
2123 
2124   bool is_shift  = VectorNode::is_shift_opcode(opc);
2125   bool is_rotate = VectorNode::is_rotate_opcode(opc);
2126 
2127   if (opc == 0 || (!is_shift && !is_rotate)) {
2128     log_if_needed("  ** operation not supported: op=%d bt=%s", opr->get_con(), type2name(elem_bt));
2129     return false; // operation not supported
2130   }
2131 
2132   int sopc = VectorNode::opcode(opc, elem_bt);
2133   if (sopc == 0) {
2134     log_if_needed("  ** operation not supported: opc=%s bt=%s", NodeClassNames[opc], type2name(elem_bt));
2135     return false; // operation not supported
2136   }
2137 
2138   Node* cnt  = argument(6);
2139   const TypeInt* cnt_type = cnt->bottom_type()->isa_int();
2140 
2141   ciKlass* vbox_klass = vector_klass->const_oop()->as_instance()->java_lang_Class_klass();
2142   const TypeInstPtr* vbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, vbox_klass);
2143 
2144   // If CPU supports vector constant rotate instructions pass it directly
2145   bool is_const_rotate = is_rotate && cnt_type && cnt_type->is_con() &&
2146                          Matcher::supports_vector_constant_rotates(cnt_type->get_con());
2147   bool has_scalar_args = is_rotate ? !is_const_rotate : true;
2148 
2149   VectorMaskUseType checkFlags = (VectorMaskUseType)(is_masked_op ? (VecMaskUseLoad | VecMaskUsePred) : VecMaskNotUsed);
2150   bool use_predicate = is_masked_op;
2151 
2152   if (!arch_supports_vector(sopc, num_elem, elem_bt, checkFlags, has_scalar_args)) {
2153     use_predicate = false;
2154     if (!is_masked_op ||
2155         (!arch_supports_vector(sopc, num_elem, elem_bt, VecMaskNotUsed, has_scalar_args) ||
2156          !arch_supports_vector(Op_VectorBlend, num_elem, elem_bt, VecMaskUseLoad))) {
2157 
2158       log_if_needed("  ** not supported: arity=0 op=int/%d vlen=%d etype=%s is_masked_op=%d",
2159                       sopc, num_elem, type2name(elem_bt), is_masked_op ? 1 : 0);
2160       return false; // not supported
2161     }
2162   }
2163 
2164   Node* opd1 = unbox_vector(argument(5), vbox_type, elem_bt, num_elem);
2165   Node* opd2 = nullptr;
2166   if (is_shift) {
2167     opd2 = vector_shift_count(cnt, opc, elem_bt, num_elem);
2168   } else {
2169     assert(is_rotate, "unexpected operation");
2170     if (!is_const_rotate) {
2171       cnt = elem_bt == T_LONG ? gvn().transform(new ConvI2LNode(cnt)) : cnt;
2172       opd2 = gvn().transform(VectorNode::scalar2vector(cnt, num_elem, elem_bt));
2173     } else {
2174       // Constant shift value.
2175       opd2 = cnt;
2176     }
2177   }
2178 
2179   if (opd1 == nullptr || opd2 == nullptr) {
2180     return false;
2181   }
2182 
2183   Node* mask = nullptr;
2184   if (is_masked_op) {
2185     ciKlass* mbox_klass = mask_klass->const_oop()->as_instance()->java_lang_Class_klass();
2186     const TypeInstPtr* mbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, mbox_klass);
2187     mask = unbox_vector(argument(7), mbox_type, elem_bt, num_elem);
2188     if (mask == nullptr) {
2189       log_if_needed("  ** unbox failed mask=%s", NodeClassNames[argument(7)->Opcode()]);
2190       return false;
2191     }
2192   }
2193 
2194   Node* operation = VectorNode::make(opc, opd1, opd2, num_elem, elem_bt);
2195   if (is_masked_op && mask != nullptr) {
2196     if (use_predicate) {
2197       operation->add_req(mask);
2198       operation->add_flag(Node::Flag_is_predicated_vector);
2199     } else {
2200       operation = gvn().transform(operation);
2201       operation = new VectorBlendNode(opd1, operation, mask);
2202     }
2203   }
2204   operation = gvn().transform(operation);
2205   Node* vbox = box_vector(operation, vbox_type, elem_bt, num_elem);
2206   set_result(vbox);
2207   C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
2208   return true;
2209 }
2210 
2211 // public static <VOUT extends VectorPayload,
2212 //                 VIN extends VectorPayload,
2213 //                   S extends VectorSpecies>
2214 // VOUT convert(int oprId,
2215 //           Class<?> fromVectorClass, Class<?> fromElementType, int fromVLen,
2216 //           Class<?>   toVectorClass, Class<?>   toElementType, int   toVLen,
2217 //           VIN v, S s,
2218 //           VectorConvertOp<VOUT, VIN, S> defaultImpl)
2219 //
2220 bool LibraryCallKit::inline_vector_convert() {
2221   const TypeInt*     opr               = gvn().type(argument(0))->isa_int();
2222 
2223   const TypeInstPtr* vector_klass_from = gvn().type(argument(1))->isa_instptr();
2224   const TypeInstPtr* elem_klass_from   = gvn().type(argument(2))->isa_instptr();
2225   const TypeInt*     vlen_from         = gvn().type(argument(3))->isa_int();
2226 
2227   const TypeInstPtr* vector_klass_to   = gvn().type(argument(4))->isa_instptr();
2228   const TypeInstPtr* elem_klass_to     = gvn().type(argument(5))->isa_instptr();
2229   const TypeInt*     vlen_to           = gvn().type(argument(6))->isa_int();
2230 
2231   if (opr == nullptr ||
2232       vector_klass_from == nullptr || elem_klass_from == nullptr || vlen_from == nullptr ||
2233       vector_klass_to   == nullptr || elem_klass_to   == nullptr || vlen_to   == nullptr) {
2234     return false; // dead code
2235   }
2236   if (!opr->is_con() ||
2237       vector_klass_from->const_oop() == nullptr || elem_klass_from->const_oop() == nullptr || !vlen_from->is_con() ||
2238       vector_klass_to->const_oop() == nullptr || elem_klass_to->const_oop() == nullptr || !vlen_to->is_con()) {
2239     log_if_needed("  ** missing constant: opr=%s vclass_from=%s etype_from=%s vlen_from=%s vclass_to=%s etype_to=%s vlen_to=%s",
2240                     NodeClassNames[argument(0)->Opcode()],
2241                     NodeClassNames[argument(1)->Opcode()],
2242                     NodeClassNames[argument(2)->Opcode()],
2243                     NodeClassNames[argument(3)->Opcode()],
2244                     NodeClassNames[argument(4)->Opcode()],
2245                     NodeClassNames[argument(5)->Opcode()],
2246                     NodeClassNames[argument(6)->Opcode()]);
2247     return false; // not enough info for intrinsification
2248   }
2249   if (!is_klass_initialized(vector_klass_from) || !is_klass_initialized(vector_klass_to)) {
2250     log_if_needed("  ** klass argument not initialized");
2251     return false;
2252   }
2253 
2254   assert(opr->get_con() == VectorSupport::VECTOR_OP_CAST  ||
2255          opr->get_con() == VectorSupport::VECTOR_OP_UCAST ||
2256          opr->get_con() == VectorSupport::VECTOR_OP_REINTERPRET, "wrong opcode");
2257   bool is_cast = (opr->get_con() == VectorSupport::VECTOR_OP_CAST || opr->get_con() == VectorSupport::VECTOR_OP_UCAST);
2258   bool is_ucast = (opr->get_con() == VectorSupport::VECTOR_OP_UCAST);
2259 
2260   ciKlass* vbox_klass_from = vector_klass_from->const_oop()->as_instance()->java_lang_Class_klass();
2261   ciKlass* vbox_klass_to = vector_klass_to->const_oop()->as_instance()->java_lang_Class_klass();
2262 
2263   bool is_mask = is_vector_mask(vbox_klass_from);
2264 
2265   ciType* elem_type_from = elem_klass_from->const_oop()->as_instance()->java_mirror_type();
2266   if (!elem_type_from->is_primitive_type()) {
2267     return false; // should be primitive type
2268   }
2269   BasicType elem_bt_from = elem_type_from->basic_type();
2270   ciType* elem_type_to = elem_klass_to->const_oop()->as_instance()->java_mirror_type();
2271   if (!elem_type_to->is_primitive_type()) {
2272     return false; // should be primitive type
2273   }
2274   BasicType elem_bt_to = elem_type_to->basic_type();
2275 
2276   int num_elem_from = vlen_from->get_con();
2277   int num_elem_to = vlen_to->get_con();
2278 
2279   // Check whether we can unbox to appropriate size. Even with casting, checking for reinterpret is needed
2280   // since we may need to change size.
2281   if (!arch_supports_vector(Op_VectorReinterpret,
2282                             num_elem_from,
2283                             elem_bt_from,
2284                             is_mask ? VecMaskUseAll : VecMaskNotUsed)) {
2285     log_if_needed("  ** not supported: arity=1 op=%s/1 vlen1=%d etype1=%s ismask=%d",
2286                     is_cast ? "cast" : "reinterpret",
2287                     num_elem_from, type2name(elem_bt_from), is_mask);
2288     return false;
2289   }
2290 
2291   // Check whether we can support resizing/reinterpreting to the new size.
2292   if (!arch_supports_vector(Op_VectorReinterpret,
2293                             num_elem_to,
2294                             elem_bt_to,
2295                             is_mask ? VecMaskUseAll : VecMaskNotUsed)) {
2296     log_if_needed("  ** not supported: arity=1 op=%s/2 vlen2=%d etype2=%s ismask=%d",
2297                     is_cast ? "cast" : "reinterpret",
2298                     num_elem_to, type2name(elem_bt_to), is_mask);
2299     return false;
2300   }
2301 
2302   // At this point, we know that both input and output vector registers are supported
2303   // by the architecture. Next check if the casted type is simply to same type - which means
2304   // that it is actually a resize and not a cast.
2305   if (is_cast && elem_bt_from == elem_bt_to) {
2306     is_cast = false;
2307   }
2308 
2309   const TypeInstPtr* vbox_type_from = TypeInstPtr::make_exact(TypePtr::NotNull, vbox_klass_from);
2310 
2311   Node* opd1 = unbox_vector(argument(7), vbox_type_from, elem_bt_from, num_elem_from);
2312   if (opd1 == nullptr) {
2313     return false;
2314   }
2315 
2316   const TypeVect* src_type = TypeVect::make(elem_bt_from, num_elem_from, is_mask);
2317   const TypeVect* dst_type = TypeVect::make(elem_bt_to, num_elem_to, is_mask);
2318 
2319   // Safety check to prevent casting if source mask is of type vector
2320   // and destination mask of type predicate vector and vice-versa.
2321   // From X86 standpoint, this case will only arise over KNL target,
2322   // where certain masks (depending on the species) are either propagated
2323   // through a vector or predicate register.
2324   if (is_mask &&
2325       ((src_type->isa_vectmask() == nullptr && dst_type->isa_vectmask()) ||
2326        (dst_type->isa_vectmask() == nullptr && src_type->isa_vectmask()))) {
2327     return false;
2328   }
2329 
2330   Node* op = opd1;
2331   if (is_cast) {
2332     assert(!is_mask || num_elem_from == num_elem_to, "vector mask cast needs the same elem num");
2333     int cast_vopc = VectorCastNode::opcode(-1, elem_bt_from, !is_ucast);
2334 
2335     // Make sure that vector cast is implemented to particular type/size combination if it is
2336     // not a mask casting.
2337     if (!is_mask && !arch_supports_vector(cast_vopc, num_elem_to, elem_bt_to, VecMaskNotUsed)) {
2338       log_if_needed("  ** not supported: arity=1 op=cast#%d/3 vlen2=%d etype2=%s ismask=%d",
2339                       cast_vopc, num_elem_to, type2name(elem_bt_to), is_mask);
2340       return false;
2341     }
2342 
2343     if (num_elem_from < num_elem_to) {
2344       // Since input and output number of elements are not consistent, we need to make sure we
2345       // properly size. Thus, first make a cast that retains the number of elements from source.
2346       int num_elem_for_cast = num_elem_from;
2347 
2348       // It is possible that arch does not support this intermediate vector size
2349       // TODO More complex logic required here to handle this corner case for the sizes.
2350       if (!arch_supports_vector(cast_vopc, num_elem_for_cast, elem_bt_to, VecMaskNotUsed)) {
2351         log_if_needed("  ** not supported: arity=1 op=cast#%d/4 vlen1=%d etype2=%s ismask=%d",
2352                         cast_vopc,
2353                         num_elem_for_cast, type2name(elem_bt_to), is_mask);
2354         return false;
2355       }
2356 
2357       op = gvn().transform(VectorCastNode::make(cast_vopc, op, elem_bt_to, num_elem_for_cast));
2358       // Now ensure that the destination gets properly resized to needed size.
2359       op = gvn().transform(new VectorReinterpretNode(op, op->bottom_type()->is_vect(), dst_type));
2360     } else if (num_elem_from > num_elem_to) {
2361       // Since number of elements from input is larger than output, simply reduce size of input
2362       // (we are supposed to drop top elements anyway).
2363       int num_elem_for_resize = num_elem_to;
2364 
2365       // It is possible that arch does not support this intermediate vector size
2366       // TODO More complex logic required here to handle this corner case for the sizes.
2367       if (!arch_supports_vector(Op_VectorReinterpret,
2368                                 num_elem_for_resize,
2369                                 elem_bt_from,
2370                                 VecMaskNotUsed)) {
2371         log_if_needed("  ** not supported: arity=1 op=cast/5 vlen2=%d etype1=%s ismask=%d",
2372                         num_elem_for_resize, type2name(elem_bt_from), is_mask);
2373         return false;
2374       }
2375 
2376       const TypeVect* resize_type = TypeVect::make(elem_bt_from, num_elem_for_resize);
2377       op = gvn().transform(new VectorReinterpretNode(op, src_type, resize_type));
2378       op = gvn().transform(VectorCastNode::make(cast_vopc, op, elem_bt_to, num_elem_to));
2379     } else { // num_elem_from == num_elem_to
2380       if (is_mask) {
2381         // Make sure that cast for vector mask is implemented to particular type/size combination.
2382         if (!arch_supports_vector(Op_VectorMaskCast, num_elem_to, elem_bt_to, VecMaskNotUsed)) {
2383           log_if_needed("  ** not supported: arity=1 op=maskcast vlen2=%d etype2=%s ismask=%d",
2384                           num_elem_to, type2name(elem_bt_to), is_mask);
2385           return false;
2386         }
2387         op = gvn().transform(new VectorMaskCastNode(op, dst_type));
2388       } else {
2389         // Since input and output number of elements match, and since we know this vector size is
2390         // supported, simply do a cast with no resize needed.
2391         op = gvn().transform(VectorCastNode::make(cast_vopc, op, elem_bt_to, num_elem_to));
2392       }
2393     }
2394   } else if (!Type::equals(src_type, dst_type)) {
2395     assert(!is_cast, "must be reinterpret");
2396     op = gvn().transform(new VectorReinterpretNode(op, src_type, dst_type));
2397   }
2398 
2399   const TypeInstPtr* vbox_type_to = TypeInstPtr::make_exact(TypePtr::NotNull, vbox_klass_to);
2400   Node* vbox = box_vector(op, vbox_type_to, elem_bt_to, num_elem_to);
2401   set_result(vbox);
2402   C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem_to * type2aelembytes(elem_bt_to))));
2403   return true;
2404 }
2405 
2406 //  public static
2407 //  <V extends Vector<E>,
2408 //   E>
2409 //  V insert(Class<? extends V> vectorClass, Class<E> elementType, int vlen,
2410 //           V vec, int ix, long val,
2411 //           VecInsertOp<V> defaultImpl)
2412 bool LibraryCallKit::inline_vector_insert() {
2413   const TypeInstPtr* vector_klass = gvn().type(argument(0))->isa_instptr();
2414   const TypeInstPtr* elem_klass   = gvn().type(argument(1))->isa_instptr();
2415   const TypeInt*     vlen         = gvn().type(argument(2))->isa_int();
2416   const TypeInt*     idx          = gvn().type(argument(4))->isa_int();
2417 
2418   if (vector_klass == nullptr || elem_klass == nullptr || vlen == nullptr || idx == nullptr) {
2419     return false; // dead code
2420   }
2421   if (vector_klass->const_oop() == nullptr || elem_klass->const_oop() == nullptr || !vlen->is_con() || !idx->is_con()) {
2422     log_if_needed("  ** missing constant: vclass=%s etype=%s vlen=%s idx=%s",
2423                     NodeClassNames[argument(0)->Opcode()],
2424                     NodeClassNames[argument(1)->Opcode()],
2425                     NodeClassNames[argument(2)->Opcode()],
2426                     NodeClassNames[argument(4)->Opcode()]);
2427     return false; // not enough info for intrinsification
2428   }
2429   if (!is_klass_initialized(vector_klass)) {
2430     log_if_needed("  ** klass argument not initialized");
2431     return false;
2432   }
2433   ciType* elem_type = elem_klass->const_oop()->as_instance()->java_mirror_type();
2434   if (!elem_type->is_primitive_type()) {
2435     log_if_needed("  ** not a primitive bt=%d", elem_type->basic_type());
2436     return false; // should be primitive type
2437   }
2438   BasicType elem_bt = elem_type->basic_type();
2439   int num_elem = vlen->get_con();
2440   if (!arch_supports_vector(Op_VectorInsert, num_elem, elem_bt, VecMaskNotUsed)) {
2441     log_if_needed("  ** not supported: arity=1 op=insert vlen=%d etype=%s ismask=no",
2442                     num_elem, type2name(elem_bt));
2443     return false; // not supported
2444   }
2445 
2446   ciKlass* vbox_klass = vector_klass->const_oop()->as_instance()->java_lang_Class_klass();
2447   const TypeInstPtr* vbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, vbox_klass);
2448 
2449   Node* opd = unbox_vector(argument(3), vbox_type, elem_bt, num_elem);
2450   if (opd == nullptr) {
2451     return false;
2452   }
2453 
2454   Node* insert_val = argument(5);
2455   assert(gvn().type(insert_val)->isa_long() != nullptr, "expected to be long");
2456 
2457   // Convert insert value back to its appropriate type.
2458   switch (elem_bt) {
2459     case T_BYTE:
2460       insert_val = gvn().transform(new ConvL2INode(insert_val, TypeInt::BYTE));
2461       break;
2462     case T_SHORT:
2463       insert_val = gvn().transform(new ConvL2INode(insert_val, TypeInt::SHORT));
2464       break;
2465     case T_INT:
2466       insert_val = gvn().transform(new ConvL2INode(insert_val));
2467       break;
2468     case T_FLOAT:
2469       insert_val = gvn().transform(new ConvL2INode(insert_val));
2470       insert_val = gvn().transform(new MoveI2FNode(insert_val));
2471       break;
2472     case T_DOUBLE:
2473       insert_val = gvn().transform(new MoveL2DNode(insert_val));
2474       break;
2475     case T_LONG:
2476       // no conversion needed
2477       break;
2478     default: fatal("%s", type2name(elem_bt)); break;
2479   }
2480 
2481   Node* operation = gvn().transform(VectorInsertNode::make(opd, insert_val, idx->get_con(), gvn()));
2482 
2483   Node* vbox = box_vector(operation, vbox_type, elem_bt, num_elem);
2484   set_result(vbox);
2485   C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
2486   return true;
2487 }
2488 
2489 //  public static
2490 //  <VM extends VectorPayload,
2491 //   E>
2492 //  long extract(Class<? extends VM> vClass, Class<E> eClass,
2493 //               int length,
2494 //               VM vm, int i,
2495 //               VecExtractOp<VM> defaultImpl)
2496 bool LibraryCallKit::inline_vector_extract() {
2497   const TypeInstPtr* vector_klass = gvn().type(argument(0))->isa_instptr();
2498   const TypeInstPtr* elem_klass   = gvn().type(argument(1))->isa_instptr();
2499   const TypeInt*     vlen         = gvn().type(argument(2))->isa_int();
2500   const TypeInt*     idx          = gvn().type(argument(4))->isa_int();
2501 
2502   if (vector_klass == nullptr || vector_klass->const_oop() == nullptr ||
2503       elem_klass   == nullptr || elem_klass->const_oop()   == nullptr ||
2504       vlen         == nullptr || !vlen->is_con() ||
2505       idx          == nullptr || !idx->is_con()) {
2506     log_if_needed("  ** missing constant: vclass=%s etype=%s vlen=%s",
2507                     NodeClassNames[argument(0)->Opcode()],
2508                     NodeClassNames[argument(1)->Opcode()],
2509                     NodeClassNames[argument(2)->Opcode()]);
2510     return false; // not enough info for intrinsification
2511   }
2512   if (!is_klass_initialized(vector_klass)) {
2513     log_if_needed("  ** klass argument not initialized");
2514     return false;
2515   }
2516   ciType* elem_type = elem_klass->const_oop()->as_instance()->java_mirror_type();
2517   if (!elem_type->is_primitive_type()) {
2518     log_if_needed("  ** not a primitive bt=%d", elem_type->basic_type());
2519     return false; // should be primitive type
2520   }
2521   BasicType elem_bt = elem_type->basic_type();
2522   int num_elem = vlen->get_con();
2523 
2524   ciKlass* vbox_klass = vector_klass->const_oop()->as_instance()->java_lang_Class_klass();
2525   const TypeInstPtr* vbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, vbox_klass);
2526 
2527   Node* opd = nullptr;
2528 
2529   if (is_vector_mask(vbox_klass)) {
2530     // vbox_klass is mask. This is used for VectorMask.laneIsSet(int).
2531 
2532     Node* pos = argument(4); // can be variable
2533     if (arch_supports_vector(Op_ExtractUB, num_elem, elem_bt, VecMaskUseAll)) {
2534       // Transform mask to vector with type of boolean and utilize ExtractUB node.
2535       opd = unbox_vector(argument(3), vbox_type, elem_bt, num_elem);
2536       if (opd == nullptr) {
2537         return false;
2538       }
2539       opd = gvn().transform(VectorStoreMaskNode::make(gvn(), opd, elem_bt, num_elem));
2540       opd = gvn().transform(new ExtractUBNode(opd, pos));
2541       opd = gvn().transform(new ConvI2LNode(opd));
2542     } else if (arch_supports_vector(Op_VectorMaskToLong, num_elem, elem_bt, VecMaskUseLoad)) {
2543       opd = unbox_vector(argument(3), vbox_type, elem_bt, num_elem);
2544       if (opd == nullptr) {
2545         return false;
2546       }
2547       // VectorMaskToLongNode requires the input is either a mask or a vector with BOOLEAN type.
2548       if (opd->bottom_type()->isa_vectmask() == nullptr) {
2549         opd = gvn().transform(VectorStoreMaskNode::make(gvn(), opd, elem_bt, num_elem));
2550       }
2551       // ((toLong() >>> pos) & 1L
2552       opd = gvn().transform(new VectorMaskToLongNode(opd, TypeLong::LONG));
2553       opd = gvn().transform(new URShiftLNode(opd, pos));
2554       opd = gvn().transform(new AndLNode(opd, gvn().makecon(TypeLong::ONE)));
2555     } else {
2556       log_if_needed("  ** Rejected mask extraction because architecture does not support it");
2557       return false; // not supported
2558     }
2559   } else {
2560     // vbox_klass is vector. This is used for Vector.lane(int).
2561     if (!idx->is_con()) {
2562       log_if_needed("  ** missing constant: idx=%s", NodeClassNames[argument(4)->Opcode()]);
2563       return false; // not enough info for intrinsification
2564     }
2565 
2566     int vopc = ExtractNode::opcode(elem_bt);
2567     if (!arch_supports_vector(vopc, num_elem, elem_bt, VecMaskNotUsed)) {
2568       log_if_needed("  ** not supported: arity=1 op=extract vlen=%d etype=%s ismask=no",
2569                       num_elem, type2name(elem_bt));
2570       return false; // not supported
2571     }
2572 
2573     opd = unbox_vector(argument(3), vbox_type, elem_bt, num_elem);
2574     if (opd == nullptr) {
2575       return false;
2576     }
2577     ConINode* idx_con = gvn().intcon(idx->get_con())->as_ConI();
2578 
2579     opd = gvn().transform(ExtractNode::make(opd, idx_con, elem_bt));
2580     switch (elem_bt) {
2581       case T_BYTE:
2582       case T_SHORT:
2583       case T_INT: {
2584         opd = gvn().transform(new ConvI2LNode(opd));
2585         break;
2586       }
2587       case T_FLOAT: {
2588         opd = gvn().transform(new MoveF2INode(opd));
2589         opd = gvn().transform(new ConvI2LNode(opd));
2590         break;
2591       }
2592       case T_DOUBLE: {
2593         opd = gvn().transform(new MoveD2LNode(opd));
2594         break;
2595       }
2596       case T_LONG: {
2597         // no conversion needed
2598         break;
2599       }
2600       default: fatal("%s", type2name(elem_bt));
2601     }
2602   }
2603   set_result(opd);
2604   return true;
2605 }
2606 
2607 static Node* LowerSelectFromTwoVectorOperation(PhaseGVN& phase, Node* index_vec, Node* src1, Node* src2, const TypeVect* vt) {
2608   int num_elem = vt->length();
2609   BasicType elem_bt = vt->element_basic_type();
2610 
2611   // Lower selectFrom operation into its constituent operations.
2612   //   SelectFromTwoVectorNode =
2613   //     (VectorBlend
2614   //         (VectorRearrange SRC1 (WRAPED_INDEX AND (VLEN-1))
2615   //         (VectorRearrange SRC2 (WRAPED_INDEX AND (VLEN-1))
2616   //      MASK)
2617   // Where
2618   //   WRAPED_INDEX are computed by wrapping incoming indexes
2619   //   to two vector index range [0, VLEN*2) and
2620   //   MASK = WRAPED_INDEX < VLEN
2621   //
2622   // IR lowering prevents intrinsification failure and associated argument
2623   // boxing penalties.
2624   //
2625 
2626   BasicType shuffle_bt = elem_bt;
2627   if (shuffle_bt == T_FLOAT) {
2628     shuffle_bt = T_INT;
2629   } else if (shuffle_bt == T_DOUBLE) {
2630     shuffle_bt = T_LONG;
2631   }
2632   const TypeVect* st = TypeVect::make(shuffle_bt, num_elem);
2633 
2634   // Cast index vector to the corresponding bit type
2635   if (elem_bt != shuffle_bt) {
2636     int cast_vopc = VectorCastNode::opcode(0, elem_bt, true);
2637     index_vec = phase.transform(VectorCastNode::make(cast_vopc, index_vec, shuffle_bt, num_elem));
2638   }
2639 
2640   // Wrap indexes into two vector index range [0, VLEN * 2)
2641   Node* two_vect_lane_cnt_m1 = phase.makecon(TypeInteger::make(2 * num_elem - 1, 2 * num_elem - 1, Type::WidenMin, shuffle_bt == T_LONG ? T_LONG : T_INT));
2642   Node* bcast_two_vect_lane_cnt_m1_vec = phase.transform(VectorNode::scalar2vector(two_vect_lane_cnt_m1, num_elem,
2643                                                                                    shuffle_bt, false));
2644   index_vec = phase.transform(VectorNode::make(Op_AndV, index_vec, bcast_two_vect_lane_cnt_m1_vec, st));
2645 
2646   // Compute the blend mask for merging two independently permitted vectors
2647   // using shuffle index in two vector index range [0, VLEN * 2).
2648   BoolTest::mask pred = BoolTest::le;
2649   ConINode* pred_node = phase.makecon(TypeInt::make(pred))->as_ConI();
2650   const TypeVect* vmask_type = TypeVect::makemask(shuffle_bt, num_elem);
2651   Node* lane_cnt_m1 = phase.makecon(TypeInteger::make(num_elem - 1, num_elem - 1, Type::WidenMin, shuffle_bt == T_LONG ? T_LONG : T_INT));
2652   Node* bcast_lane_cnt_m1_vec = phase.transform(VectorNode::scalar2vector(lane_cnt_m1, num_elem, shuffle_bt, false));
2653   Node* mask = phase.transform(new VectorMaskCmpNode(pred, index_vec, bcast_lane_cnt_m1_vec, pred_node, vmask_type));
2654 
2655   // Rearrange expects the indexes to lie within single vector index range [0, VLEN).
2656   Node* wrapped_index_vec = phase.transform(VectorNode::make(Op_AndV, index_vec, bcast_lane_cnt_m1_vec, st));
2657 
2658   // Load indexes from byte vector and appropriately transform them to target
2659   // specific permutation index format.
2660   if (Matcher::vector_rearrange_requires_load_shuffle(shuffle_bt, num_elem)) {
2661     wrapped_index_vec = phase.transform(new VectorLoadShuffleNode(wrapped_index_vec, st));
2662   }
2663 
2664   vmask_type = TypeVect::makemask(elem_bt, num_elem);
2665   mask = phase.transform(new VectorMaskCastNode(mask, vmask_type));
2666 
2667   Node* p1 = phase.transform(new VectorRearrangeNode(src1, wrapped_index_vec));
2668   Node* p2 = phase.transform(new VectorRearrangeNode(src2, wrapped_index_vec));
2669 
2670   return new VectorBlendNode(p2, p1, mask);
2671 }
2672 
2673 //  public static
2674 //  <V extends Vector<E>,
2675 //   E>
2676 //  V selectFromTwoVectorOp(Class<? extends V> vClass, Class<E> eClass, int length,
2677 //                          V v1, V v2, V v3,
2678 //                          SelectFromTwoVector<V> defaultImpl)
2679 bool LibraryCallKit::inline_vector_select_from_two_vectors() {
2680   const TypeInstPtr* vector_klass = gvn().type(argument(0))->isa_instptr();
2681   const TypeInstPtr* elem_klass = gvn().type(argument(1))->isa_instptr();
2682   const TypeInt* vlen = gvn().type(argument(2))->isa_int();
2683 
2684   if (vector_klass == nullptr || elem_klass == nullptr || vlen == nullptr || vector_klass->const_oop() == nullptr ||
2685       elem_klass->const_oop() == nullptr ||!vlen->is_con()) {
2686     log_if_needed("  ** missing constant: vclass=%s etype=%s vlen=%s",
2687                     NodeClassNames[argument(0)->Opcode()],
2688                     NodeClassNames[argument(1)->Opcode()],
2689                     NodeClassNames[argument(2)->Opcode()]);
2690     return false; // not enough info for intrinsification
2691   }
2692 
2693   if (!is_klass_initialized(vector_klass)) {
2694     log_if_needed("  ** klass argument not initialized");
2695     return false;
2696   }
2697 
2698   ciType* elem_type = elem_klass->const_oop()->as_instance()->java_mirror_type();
2699   if (!elem_type->is_primitive_type()) {
2700     log_if_needed("  ** not a primitive bt=%d", elem_type->basic_type());
2701     return false; // should be primitive type
2702   }
2703 
2704   int num_elem = vlen->get_con();
2705   if (!is_power_of_2(num_elem)) {
2706     log_if_needed("  ** vlen is not power of two=%d", num_elem);
2707     return false;
2708   }
2709 
2710   BasicType elem_bt = elem_type->basic_type();
2711   BasicType index_elem_bt = elem_bt;
2712   if (elem_bt == T_FLOAT) {
2713     index_elem_bt = T_INT;
2714   } else if (elem_bt == T_DOUBLE) {
2715     index_elem_bt = T_LONG;
2716   }
2717 
2718   // Check if the platform requires a VectorLoadShuffle node to be generated
2719   bool need_load_shuffle = Matcher::vector_rearrange_requires_load_shuffle(index_elem_bt, num_elem);
2720 
2721   bool lowerSelectFromOp = false;
2722   if (!arch_supports_vector(Op_SelectFromTwoVector, num_elem, elem_bt, VecMaskNotUsed)) {
2723     int cast_vopc = VectorCastNode::opcode(-1, elem_bt, true);
2724     if ((elem_bt != index_elem_bt && !arch_supports_vector(cast_vopc, num_elem, index_elem_bt, VecMaskNotUsed)) ||
2725         !arch_supports_vector(Op_VectorMaskCmp, num_elem, index_elem_bt, VecMaskNotUsed)     ||
2726         !arch_supports_vector(Op_AndV, num_elem, index_elem_bt, VecMaskNotUsed)              ||
2727         !arch_supports_vector(Op_VectorMaskCast, num_elem, elem_bt, VecMaskNotUsed)          ||
2728         !arch_supports_vector(Op_VectorBlend, num_elem, elem_bt, VecMaskUseLoad)             ||
2729         !arch_supports_vector(Op_VectorRearrange, num_elem, elem_bt, VecMaskNotUsed)         ||
2730         (need_load_shuffle && !arch_supports_vector(Op_VectorLoadShuffle, num_elem, index_elem_bt, VecMaskNotUsed)) ||
2731         !arch_supports_vector(Op_Replicate, num_elem, index_elem_bt, VecMaskNotUsed)) {
2732       log_if_needed("  ** not supported: opc=%d vlen=%d etype=%s ismask=useload",
2733                     Op_SelectFromTwoVector, num_elem, type2name(elem_bt));
2734       return false; // not supported
2735     }
2736     lowerSelectFromOp = true;
2737   }
2738 
2739   int cast_vopc = VectorCastNode::opcode(-1, elem_bt, true);
2740   if (!lowerSelectFromOp) {
2741     if (!arch_supports_vector(Op_AndV, num_elem, index_elem_bt, VecMaskNotUsed)      ||
2742         !arch_supports_vector(Op_Replicate, num_elem, index_elem_bt, VecMaskNotUsed) ||
2743         (is_floating_point_type(elem_bt) &&
2744          !arch_supports_vector(cast_vopc, num_elem, index_elem_bt, VecMaskNotUsed))) {
2745       log_if_needed("  ** index wrapping not supported: vlen=%d etype=%s" ,
2746                      num_elem, type2name(elem_bt));
2747       return false; // not supported
2748     }
2749   }
2750 
2751   ciKlass* vbox_klass = vector_klass->const_oop()->as_instance()->java_lang_Class_klass();
2752   const TypeInstPtr* vbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, vbox_klass);
2753 
2754   Node* opd1 = unbox_vector(argument(3), vbox_type, elem_bt, num_elem);
2755   if (opd1 == nullptr) {
2756     log_if_needed("  ** unbox failed v1=%s",
2757                   NodeClassNames[argument(3)->Opcode()]);
2758     return false;
2759   }
2760   Node* opd2 = unbox_vector(argument(4), vbox_type, elem_bt, num_elem);
2761   if (opd2 == nullptr) {
2762     log_if_needed("  ** unbox failed v2=%s",
2763                   NodeClassNames[argument(4)->Opcode()]);
2764     return false;
2765   }
2766   Node* opd3 = unbox_vector(argument(5), vbox_type, elem_bt, num_elem);
2767   if (opd3 == nullptr) {
2768     log_if_needed("  ** unbox failed v3=%s",
2769                   NodeClassNames[argument(5)->Opcode()]);
2770     return false;
2771   }
2772 
2773   const TypeVect* vt = TypeVect::make(elem_bt, num_elem);
2774 
2775   Node* operation = nullptr;
2776   if (lowerSelectFromOp) {
2777     operation = gvn().transform(LowerSelectFromTwoVectorOperation(gvn(), opd1, opd2, opd3, vt));
2778   } else {
2779     if (index_elem_bt != elem_bt) {
2780       opd1 = gvn().transform(VectorCastNode::make(cast_vopc, opd1, index_elem_bt, num_elem));
2781     }
2782     int indexRangeMask = 2 * num_elem - 1;
2783     Node* wrap_mask = gvn().makecon(TypeInteger::make(indexRangeMask, indexRangeMask, Type::WidenMin, index_elem_bt != T_LONG ? T_INT : index_elem_bt));
2784     Node* wrap_mask_vec = gvn().transform(VectorNode::scalar2vector(wrap_mask, num_elem, index_elem_bt, false));
2785     opd1 = gvn().transform(VectorNode::make(Op_AndV, opd1, wrap_mask_vec, opd1->bottom_type()->is_vect()));
2786     operation = gvn().transform(VectorNode::make(Op_SelectFromTwoVector, opd1, opd2, opd3, vt));
2787   }
2788 
2789   // Wrap it up in VectorBox to keep object type information.
2790   Node* vbox = box_vector(operation, vbox_type, elem_bt, num_elem);
2791   set_result(vbox);
2792   C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
2793   return true;
2794 }
2795 
2796 // public static
2797 // <V extends Vector<E>,
2798 //  M extends VectorMask<E>,
2799 //  E>
2800 //  V compressExpandOp(int opr,
2801 //                    Class<? extends V> vClass, Class<? extends M> mClass, Class<E> eClass,
2802 //                    int length, V v, M m,
2803 //                    CompressExpandOperation<V, M> defaultImpl)
2804 bool LibraryCallKit::inline_vector_compress_expand() {
2805   const TypeInt*     opr          = gvn().type(argument(0))->isa_int();
2806   const TypeInstPtr* vector_klass = gvn().type(argument(1))->isa_instptr();
2807   const TypeInstPtr* mask_klass   = gvn().type(argument(2))->isa_instptr();
2808   const TypeInstPtr* elem_klass   = gvn().type(argument(3))->isa_instptr();
2809   const TypeInt*     vlen         = gvn().type(argument(4))->isa_int();
2810 
2811   if (opr          == nullptr || !opr->is_con() ||
2812       vector_klass == nullptr || vector_klass->const_oop() == nullptr ||
2813       mask_klass   == nullptr || mask_klass->const_oop()   == nullptr ||
2814       elem_klass   == nullptr || elem_klass->const_oop()   == nullptr ||
2815       vlen         == nullptr || !vlen->is_con()) {
2816     log_if_needed("  ** missing constant: opr=%s vclass=%s mclass=%s etype=%s vlen=%s",
2817                     NodeClassNames[argument(0)->Opcode()],
2818                     NodeClassNames[argument(1)->Opcode()],
2819                     NodeClassNames[argument(2)->Opcode()],
2820                     NodeClassNames[argument(3)->Opcode()],
2821                     NodeClassNames[argument(4)->Opcode()]);
2822     return false; // not enough info for intrinsification
2823   }
2824 
2825   if (!is_klass_initialized(vector_klass) || !is_klass_initialized(mask_klass)) {
2826     log_if_needed("  ** klass argument not initialized");
2827     return false;
2828   }
2829 
2830   ciType* elem_type = elem_klass->const_oop()->as_instance()->java_mirror_type();
2831   if (!elem_type->is_primitive_type()) {
2832     log_if_needed("  ** not a primitive bt=%d", elem_type->basic_type());
2833     return false; // should be primitive type
2834   }
2835 
2836   int num_elem = vlen->get_con();
2837   BasicType elem_bt = elem_type->basic_type();
2838   int opc = VectorSupport::vop2ideal(opr->get_con(), elem_bt);
2839 
2840   if (!arch_supports_vector(opc, num_elem, elem_bt, VecMaskUseLoad)) {
2841     log_if_needed("  ** not supported: opc=%d vlen=%d etype=%s ismask=useload",
2842                     opc, num_elem, type2name(elem_bt));
2843     return false; // not supported
2844   }
2845 
2846   Node* opd1 = nullptr;
2847   const TypeInstPtr* vbox_type = nullptr;
2848   if (opc != Op_CompressM) {
2849     ciKlass* vbox_klass = vector_klass->const_oop()->as_instance()->java_lang_Class_klass();
2850     vbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, vbox_klass);
2851     opd1 = unbox_vector(argument(5), vbox_type, elem_bt, num_elem);
2852     if (opd1 == nullptr) {
2853       log_if_needed("  ** unbox failed vector=%s",
2854                       NodeClassNames[argument(5)->Opcode()]);
2855       return false;
2856     }
2857   }
2858 
2859   ciKlass* mbox_klass = mask_klass->const_oop()->as_instance()->java_lang_Class_klass();
2860   assert(is_vector_mask(mbox_klass), "argument(6) should be a mask class");
2861   const TypeInstPtr* mbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, mbox_klass);
2862 
2863   Node* mask = unbox_vector(argument(6), mbox_type, elem_bt, num_elem);
2864   if (mask == nullptr) {
2865     log_if_needed("  ** unbox failed mask=%s",
2866                     NodeClassNames[argument(6)->Opcode()]);
2867     return false;
2868   }
2869 
2870   const TypeVect* vt = TypeVect::make(elem_bt, num_elem, opc == Op_CompressM);
2871   Node* operation = gvn().transform(VectorNode::make(opc, opd1, mask, vt));
2872 
2873   // Wrap it up in VectorBox to keep object type information.
2874   const TypeInstPtr* box_type = opc == Op_CompressM ? mbox_type : vbox_type;
2875   Node* vbox = box_vector(operation, box_type, elem_bt, num_elem);
2876   set_result(vbox);
2877   C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
2878   return true;
2879 }
2880 
2881 // public static
2882 // <V extends Vector<E>,
2883 //  E,
2884 //  S extends VectorSpecies<E>>
2885 //  V indexVector(Class<? extends V> vClass, Class<E> eClass,
2886 //                int length,
2887 //                V v, int step, S s,
2888 //                IndexOperation<V, S> defaultImpl)
2889 bool LibraryCallKit::inline_index_vector() {
2890   const TypeInstPtr* vector_klass = gvn().type(argument(0))->isa_instptr();
2891   const TypeInstPtr* elem_klass   = gvn().type(argument(1))->isa_instptr();
2892   const TypeInt*     vlen         = gvn().type(argument(2))->isa_int();
2893 
2894   if (vector_klass == nullptr || vector_klass->const_oop() == nullptr ||
2895       elem_klass   == nullptr || elem_klass->const_oop()   == nullptr ||
2896       vlen         == nullptr || !vlen->is_con() ) {
2897     log_if_needed("  ** missing constant: vclass=%s etype=%s vlen=%s",
2898                     NodeClassNames[argument(0)->Opcode()],
2899                     NodeClassNames[argument(1)->Opcode()],
2900                     NodeClassNames[argument(2)->Opcode()]);
2901     return false; // not enough info for intrinsification
2902   }
2903 
2904   if (!is_klass_initialized(vector_klass)) {
2905     log_if_needed("  ** klass argument not initialized");
2906     return false;
2907   }
2908 
2909   ciType* elem_type = elem_klass->const_oop()->as_instance()->java_mirror_type();
2910   if (!elem_type->is_primitive_type()) {
2911     log_if_needed("  ** not a primitive bt=%d", elem_type->basic_type());
2912     return false; // should be primitive type
2913   }
2914 
2915   int num_elem = vlen->get_con();
2916   BasicType elem_bt = elem_type->basic_type();
2917 
2918   // Check whether the iota index generation op is supported by the current hardware
2919   if (!arch_supports_vector(Op_VectorLoadConst, num_elem, elem_bt, VecMaskNotUsed)) {
2920     log_if_needed("  ** not supported: vlen=%d etype=%s", num_elem, type2name(elem_bt));
2921     return false; // not supported
2922   }
2923 
2924   int mul_op = VectorSupport::vop2ideal(VectorSupport::VECTOR_OP_MUL, elem_bt);
2925   int vmul_op = VectorNode::opcode(mul_op, elem_bt);
2926   bool needs_mul = true;
2927   Node* scale = argument(4);
2928   const TypeInt* scale_type = gvn().type(scale)->isa_int();
2929   // Multiply is not needed if the scale is a constant "1".
2930   if (scale_type && scale_type->is_con() && scale_type->get_con() == 1) {
2931     needs_mul = false;
2932   } else {
2933     // Check whether the vector multiply op is supported by the current hardware
2934     if (!arch_supports_vector(vmul_op, num_elem, elem_bt, VecMaskNotUsed)) {
2935       log_if_needed("  ** not supported: vlen=%d etype=%s", num_elem, type2name(elem_bt));
2936       return false; // not supported
2937     }
2938 
2939     // Check whether the scalar cast op is supported by the current hardware
2940     if (is_floating_point_type(elem_bt) || elem_bt == T_LONG) {
2941       int cast_op = elem_bt == T_LONG ? Op_ConvI2L :
2942                     elem_bt == T_FLOAT? Op_ConvI2F : Op_ConvI2D;
2943       if (!Matcher::match_rule_supported(cast_op)) {
2944         log_if_needed("  ** Rejected op (%s) because architecture does not support it",
2945                         NodeClassNames[cast_op]);
2946         return false; // not supported
2947       }
2948     }
2949   }
2950 
2951   ciKlass* vbox_klass = vector_klass->const_oop()->as_instance()->java_lang_Class_klass();
2952   const TypeInstPtr* vbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, vbox_klass);
2953   Node* opd = unbox_vector(argument(3), vbox_type, elem_bt, num_elem);
2954   if (opd == nullptr) {
2955     log_if_needed("  ** unbox failed vector=%s",
2956                     NodeClassNames[argument(3)->Opcode()]);
2957     return false;
2958   }
2959 
2960   int add_op = VectorSupport::vop2ideal(VectorSupport::VECTOR_OP_ADD, elem_bt);
2961   int vadd_op = VectorNode::opcode(add_op, elem_bt);
2962   bool needs_add = true;
2963   // The addition is not needed if all the element values of "opd" are zero
2964   if (VectorNode::is_all_zeros_vector(opd)) {
2965     needs_add = false;
2966   } else {
2967     // Check whether the vector addition op is supported by the current hardware
2968     if (!arch_supports_vector(vadd_op, num_elem, elem_bt, VecMaskNotUsed)) {
2969       log_if_needed("  ** not supported: vlen=%d etype=%s", num_elem, type2name(elem_bt));
2970       return false; // not supported
2971     }
2972   }
2973 
2974   // Compute the iota indice vector
2975   const TypeVect* vt = TypeVect::make(elem_bt, num_elem);
2976   Node* index = gvn().transform(new VectorLoadConstNode(gvn().makecon(TypeInt::ZERO), vt));
2977 
2978   // Broadcast the "scale" to a vector, and multiply the "scale" with iota indice vector.
2979   if (needs_mul) {
2980     switch (elem_bt) {
2981       case T_BOOLEAN: // fall-through
2982       case T_BYTE:    // fall-through
2983       case T_SHORT:   // fall-through
2984       case T_CHAR:    // fall-through
2985       case T_INT: {
2986         // no conversion needed
2987         break;
2988       }
2989       case T_LONG: {
2990         scale = gvn().transform(new ConvI2LNode(scale));
2991         break;
2992       }
2993       case T_FLOAT: {
2994         scale = gvn().transform(new ConvI2FNode(scale));
2995         break;
2996       }
2997       case T_DOUBLE: {
2998         scale = gvn().transform(new ConvI2DNode(scale));
2999         break;
3000       }
3001       default: fatal("%s", type2name(elem_bt));
3002     }
3003     scale = gvn().transform(VectorNode::scalar2vector(scale, num_elem, elem_bt));
3004     index = gvn().transform(VectorNode::make(vmul_op, index, scale, vt));
3005   }
3006 
3007   // Add "opd" if addition is needed.
3008   if (needs_add) {
3009     index = gvn().transform(VectorNode::make(vadd_op, opd, index, vt));
3010   }
3011   Node* vbox = box_vector(index, vbox_type, elem_bt, num_elem);
3012   set_result(vbox);
3013   C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
3014   return true;
3015 }
3016 
3017 // public static
3018 // <E,
3019 //  M extends VectorMask<E>>
3020 // M indexPartiallyInUpperRange(Class<? extends M> mClass, Class<E> eClass, int length,
3021 //                              long offset, long limit,
3022 //                              IndexPartiallyInUpperRangeOperation<E, M> defaultImpl)
3023 bool LibraryCallKit::inline_index_partially_in_upper_range() {
3024   const TypeInstPtr* mask_klass   = gvn().type(argument(0))->isa_instptr();
3025   const TypeInstPtr* elem_klass   = gvn().type(argument(1))->isa_instptr();
3026   const TypeInt*     vlen         = gvn().type(argument(2))->isa_int();
3027 
3028   if (mask_klass == nullptr || mask_klass->const_oop() == nullptr ||
3029       elem_klass == nullptr || elem_klass->const_oop() == nullptr ||
3030       vlen       == nullptr || !vlen->is_con()) {
3031     log_if_needed("  ** missing constant: mclass=%s etype=%s vlen=%s",
3032                     NodeClassNames[argument(0)->Opcode()],
3033                     NodeClassNames[argument(1)->Opcode()],
3034                     NodeClassNames[argument(2)->Opcode()]);
3035     return false; // not enough info for intrinsification
3036   }
3037 
3038   if (!is_klass_initialized(mask_klass)) {
3039     log_if_needed("  ** klass argument not initialized");
3040     return false;
3041   }
3042 
3043   ciType* elem_type = elem_klass->const_oop()->as_instance()->java_mirror_type();
3044   if (!elem_type->is_primitive_type()) {
3045     log_if_needed("  ** not a primitive bt=%d", elem_type->basic_type());
3046     return false; // should be primitive type
3047   }
3048 
3049   int num_elem = vlen->get_con();
3050   BasicType elem_bt = elem_type->basic_type();
3051 
3052   // Check whether the necessary ops are supported by current hardware.
3053   bool supports_mask_gen = arch_supports_vector(Op_VectorMaskGen, num_elem, elem_bt, VecMaskUseStore);
3054   if (!supports_mask_gen) {
3055     if (!arch_supports_vector(Op_VectorLoadConst, num_elem, elem_bt, VecMaskNotUsed) ||
3056         !arch_supports_vector(Op_Replicate, num_elem, elem_bt, VecMaskNotUsed) ||
3057         !arch_supports_vector(Op_VectorMaskCmp, num_elem, elem_bt, VecMaskUseStore)) {
3058       log_if_needed("  ** not supported: vlen=%d etype=%s", num_elem, type2name(elem_bt));
3059       return false; // not supported
3060     }
3061 
3062     // Check whether the scalar cast operation is supported by current hardware.
3063     if (elem_bt != T_LONG) {
3064       int cast_op = is_integral_type(elem_bt) ? Op_ConvL2I
3065                                               : (elem_bt == T_FLOAT ? Op_ConvL2F : Op_ConvL2D);
3066       if (!Matcher::match_rule_supported(cast_op)) {
3067         log_if_needed("  ** Rejected op (%s) because architecture does not support it",
3068                         NodeClassNames[cast_op]);
3069         return false; // not supported
3070       }
3071     }
3072   }
3073 
3074   Node* offset = argument(3);
3075   Node* limit = argument(5);
3076   if (offset == nullptr || limit == nullptr) {
3077     log_if_needed("  ** offset or limit argument is null");
3078     return false; // not supported
3079   }
3080 
3081   ciKlass* box_klass = mask_klass->const_oop()->as_instance()->java_lang_Class_klass();
3082   assert(is_vector_mask(box_klass), "argument(0) should be a mask class");
3083   const TypeInstPtr* box_type = TypeInstPtr::make_exact(TypePtr::NotNull, box_klass);
3084 
3085   // We assume "offset > 0 && limit >= offset && limit - offset < num_elem".
3086   // So directly get indexLimit with "indexLimit = limit - offset".
3087   Node* indexLimit = gvn().transform(new SubLNode(limit, offset));
3088   Node* mask = nullptr;
3089   if (supports_mask_gen) {
3090     mask = gvn().transform(VectorMaskGenNode::make(indexLimit, elem_bt, num_elem));
3091   } else {
3092     // Generate the vector mask based on "mask = iota < indexLimit".
3093     // Broadcast "indexLimit" to a vector.
3094     switch (elem_bt) {
3095       case T_BOOLEAN: // fall-through
3096       case T_BYTE:    // fall-through
3097       case T_SHORT:   // fall-through
3098       case T_CHAR:    // fall-through
3099       case T_INT: {
3100         indexLimit = gvn().transform(new ConvL2INode(indexLimit));
3101         break;
3102       }
3103       case T_DOUBLE: {
3104         indexLimit = gvn().transform(new ConvL2DNode(indexLimit));
3105         break;
3106       }
3107       case T_FLOAT: {
3108         indexLimit = gvn().transform(new ConvL2FNode(indexLimit));
3109         break;
3110       }
3111       case T_LONG: {
3112         // no conversion needed
3113         break;
3114       }
3115       default: fatal("%s", type2name(elem_bt));
3116     }
3117     indexLimit = gvn().transform(VectorNode::scalar2vector(indexLimit, num_elem, elem_bt));
3118 
3119     // Load the "iota" vector.
3120     const TypeVect* vt = TypeVect::make(elem_bt, num_elem);
3121     Node* iota = gvn().transform(new VectorLoadConstNode(gvn().makecon(TypeInt::ZERO), vt));
3122 
3123     // Compute the vector mask with "mask = iota < indexLimit".
3124     ConINode* pred_node = (ConINode*)gvn().makecon(TypeInt::make(BoolTest::lt));
3125     const TypeVect* vmask_type = TypeVect::makemask(elem_bt, num_elem);
3126     mask = gvn().transform(new VectorMaskCmpNode(BoolTest::lt, iota, indexLimit, pred_node, vmask_type));
3127   }
3128   Node* vbox = box_vector(mask, box_type, elem_bt, num_elem);
3129   set_result(vbox);
3130   C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
3131   return true;
3132 }
3133 
3134 #undef non_product_log_if_needed
3135 #undef log_if_needed