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