< prev index next >

src/hotspot/share/opto/vectorIntrinsics.cpp

Print this page

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()) {

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));

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);

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 //      mask_klass       == nullptr || mask_klass->const_oop()       == nullptr ||
1221       elem_klass       == nullptr || elem_klass->const_oop()       == nullptr ||
1222       vlen             == nullptr || !vlen->is_con() ||
1223       vector_idx_klass == nullptr || vector_idx_klass->const_oop() == nullptr ||
1224       idx_vlen         == nullptr || !idx_vlen->is_con()) {
1225     log_if_needed("  ** missing constant: vclass=%s etype=%s vlen=%s viclass=%s idx_vlen=%s",
1226                     NodeClassNames[argument(0)->Opcode()],
1227                     NodeClassNames[argument(2)->Opcode()],
1228                     NodeClassNames[argument(3)->Opcode()],
1229                     NodeClassNames[argument(4)->Opcode()],
1230                     NodeClassNames[argument(5)->Opcode()]);
1231     return false; // not enough info for intrinsification
1232   }
1233 
1234   if (!is_klass_initialized(vector_klass) || !is_klass_initialized(vector_idx_klass)) {
1235     log_if_needed("  ** klass argument not initialized");
1236     return false;
1237   }
1238 
1239   ciType* elem_type = elem_klass->const_oop()->as_instance()->java_mirror_type();
1240   if (!elem_type->is_primitive_type()) {

1385   C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
1386   return true;
1387 }
1388 
1389 // public static
1390 // <V extends Vector<E>,
1391 //  M extends VectorMask<E>,
1392 //  E>
1393 // long reductionCoerced(int oprId, Class<? extends V> vectorClass, Class<? extends M> maskClass,
1394 //                       Class<E> elementType, int length, V v, M m,
1395 //                       ReductionOperation<V, M> defaultImpl)
1396 bool LibraryCallKit::inline_vector_reduction() {
1397   const TypeInt*     opr          = gvn().type(argument(0))->isa_int();
1398   const TypeInstPtr* vector_klass = gvn().type(argument(1))->isa_instptr();
1399   const TypeInstPtr* mask_klass   = gvn().type(argument(2))->isa_instptr();
1400   const TypeInstPtr* elem_klass   = gvn().type(argument(3))->isa_instptr();
1401   const TypeInt*     vlen         = gvn().type(argument(4))->isa_int();
1402 
1403   if (opr          == nullptr || !opr->is_con() ||
1404       vector_klass == nullptr || vector_klass->const_oop() == nullptr ||
1405 //      mask_klass   == nullptr || mask_klass->const_oop()   == nullptr ||
1406       elem_klass   == nullptr || elem_klass->const_oop()   == nullptr ||
1407       vlen         == nullptr || !vlen->is_con()) {
1408     log_if_needed("  ** missing constant: opr=%s vclass=%s etype=%s vlen=%s",
1409                     NodeClassNames[argument(0)->Opcode()],
1410                     NodeClassNames[argument(1)->Opcode()],
1411                     NodeClassNames[argument(3)->Opcode()],
1412                     NodeClassNames[argument(4)->Opcode()]);
1413     return false; // not enough info for intrinsification
1414   }
1415   if (!is_klass_initialized(vector_klass)) {
1416     log_if_needed("  ** klass argument not initialized");
1417     return false;
1418   }
1419   ciType* elem_type = elem_klass->const_oop()->as_instance()->java_mirror_type();
1420   if (!elem_type->is_primitive_type()) {
1421     log_if_needed("  ** not a primitive bt=%d", elem_type->basic_type());
1422     return false; // should be primitive type
1423   }
1424 
1425   const Type* vmask_type = gvn().type(argument(6));

2484 
2485   Node* vbox = box_vector(operation, vbox_type, elem_bt, num_elem);
2486   set_result(vbox);
2487   C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
2488   return true;
2489 }
2490 
2491 //  public static
2492 //  <VM extends VectorPayload,
2493 //   E>
2494 //  long extract(Class<? extends VM> vClass, Class<E> eClass,
2495 //               int length,
2496 //               VM vm, int i,
2497 //               VecExtractOp<VM> defaultImpl)
2498 bool LibraryCallKit::inline_vector_extract() {
2499   const TypeInstPtr* vector_klass = gvn().type(argument(0))->isa_instptr();
2500   const TypeInstPtr* elem_klass   = gvn().type(argument(1))->isa_instptr();
2501   const TypeInt*     vlen         = gvn().type(argument(2))->isa_int();
2502   const TypeInt*     idx          = gvn().type(argument(4))->isa_int();
2503 
2504   if (vector_klass == nullptr || elem_klass == nullptr || vlen == nullptr || idx == nullptr) {
2505     return false; // dead code
2506   }
2507   if (vector_klass->const_oop() == nullptr || elem_klass->const_oop() == nullptr || !vlen->is_con() || !idx->is_con()) {
2508     log_if_needed("  ** missing constant: vclass=%s etype=%s vlen=%s",
2509                     NodeClassNames[argument(0)->Opcode()],
2510                     NodeClassNames[argument(1)->Opcode()],
2511                     NodeClassNames[argument(2)->Opcode()]);
2512     return false; // not enough info for intrinsification
2513   }
2514   if (!is_klass_initialized(vector_klass)) {
2515     log_if_needed("  ** klass argument not initialized");
2516     return false;
2517   }
2518   ciType* elem_type = elem_klass->const_oop()->as_instance()->java_mirror_type();
2519   if (!elem_type->is_primitive_type()) {
2520     log_if_needed("  ** not a primitive bt=%d", elem_type->basic_type());
2521     return false; // should be primitive type
2522   }
2523   BasicType elem_bt = elem_type->basic_type();
2524   int num_elem = vlen->get_con();
2525 
2526   ciKlass* vbox_klass = vector_klass->const_oop()->as_instance()->java_lang_Class_klass();
2527   const TypeInstPtr* vbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, vbox_klass);
< prev index next >