8329077: C2 SuperWord: Add MoveD2L, MoveL2D, MoveF2I, MoveI2F

src/hotspot/share/opto/superword.cpp

@@ -1632,6 +1632,8 @@ bool SuperWord::implemented(const Node_List* pack, const uint size) const {
       retValue = ReductionNode::implemented(opc, size, arith_type->basic_type());
     } else if (VectorNode::is_convert_opcode(opc)) {
       retValue = VectorCastNode::implemented(opc, size, velt_basic_type(p0->in(1)), velt_basic_type(p0));
+    } else if (VectorNode::is_reinterpret_opcode(opc)) {
+      retValue = Matcher::match_rule_supported_auto_vectorization(Op_VectorReinterpret, size, velt_basic_type(p0));
     } else if (VectorNode::is_minmax_opcode(opc) && is_subword_type(velt_basic_type(p0))) {
       // Java API for Math.min/max operations supports only int, long, float
       // and double types. Thus, avoid generating vector min/max nodes for

src/hotspot/share/opto/vectornode.cpp

@@ -992,6 +992,10 @@ bool VectorNode::is_vector_bitwise_not_pattern(Node* n) {
 
 bool VectorNode::is_reinterpret_opcode(int opc) {
   switch (opc) {
+    case Op_MoveF2I:
+    case Op_MoveD2L:
+    case Op_MoveL2D:
+    case Op_MoveI2F:
     case Op_ReinterpretHF2S:
     case Op_ReinterpretS2HF:
       return true;

test/hotspot/jtreg/compiler/loopopts/superword/TestCompatibleUseDefTypeSize.java

@@ -395,7 +395,7 @@ static Object[] test4(int[] a, int[] b) {
     // In theory, one would expect this to be a simple 4byte -> 4byte conversion.
     // But there is a CmpF and CMove here because we check for isNaN. Plus a MoveF2I.
     //
-    // Would be nice to vectorize: Missing support for CmpF, CMove and MoveF2I.
+    // Would be nice to vectorize: Missing support for CmpF and CMove.
     static Object[] test5(int[] a, float[] b) {
         for (int i = 0; i < a.length; i++) {
             a[i] = Float.floatToIntBits(b[i]);
@@ -404,10 +404,11 @@ static Object[] test5(int[] a, float[] b) {
     }
 
     @Test
-    @IR(counts = {IRNode.STORE_VECTOR, "= 0"},
+    @IR(counts = {IRNode.LOAD_VECTOR_F, "> 0",
+                  IRNode.STORE_VECTOR, "> 0",
+                  IRNode.VECTOR_REINTERPRET, "> 0"},
         applyIfPlatform = {"64-bit", "true"},
         applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true", "rvv", "true"})
-    // Missing support for MoveF2I
     static Object[] test6(int[] a, float[] b) {
         for (int i = 0; i < a.length; i++) {
             a[i] = Float.floatToRawIntBits(b[i]);
@@ -416,10 +417,11 @@ static Object[] test6(int[] a, float[] b) {
     }
 
     @Test
-    @IR(counts = {IRNode.STORE_VECTOR, "= 0"},
+    @IR(counts = {IRNode.LOAD_VECTOR_I, "> 0",
+                  IRNode.STORE_VECTOR, "> 0",
+                  IRNode.VECTOR_REINTERPRET, "> 0"},
         applyIfPlatform = {"64-bit", "true"},
         applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true", "rvv", "true"})
-    // Missing support for MoveI2F
     static Object[] test7(int[] a, float[] b) {
         for (int i = 0; i < a.length; i++) {
             b[i] = Float.intBitsToFloat(a[i]);
@@ -431,7 +433,7 @@ static Object[] test7(int[] a, float[] b) {
     @IR(counts = {IRNode.STORE_VECTOR, "= 0"},
         applyIfPlatform = {"64-bit", "true"},
         applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true", "rvv", "true"})
-    // Missing support for Needs CmpD, CMove and MoveD2L
+    // Missing support to vectorize CmpD and CMove
     static Object[] test8(long[] a, double[] b) {
         for (int i = 0; i < a.length; i++) {
             a[i] = Double.doubleToLongBits(b[i]);
@@ -440,10 +442,11 @@ static Object[] test8(long[] a, double[] b) {
     }
 
     @Test
-    @IR(counts = {IRNode.STORE_VECTOR, "= 0"},
+    @IR(counts = {IRNode.LOAD_VECTOR_D, "> 0",
+                  IRNode.STORE_VECTOR, "> 0",
+                  IRNode.VECTOR_REINTERPRET, "> 0"},
         applyIfPlatform = {"64-bit", "true"},
         applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true", "rvv", "true"})
-    // Missing support for MoveD2L
     static Object[] test9(long[] a, double[] b) {
         for (int i = 0; i < a.length; i++) {
             a[i] = Double.doubleToRawLongBits(b[i]);
@@ -452,10 +455,11 @@ static Object[] test9(long[] a, double[] b) {
     }
 
     @Test
-    @IR(counts = {IRNode.STORE_VECTOR, "= 0"},
+    @IR(counts = {IRNode.LOAD_VECTOR_L, "> 0",
+                  IRNode.STORE_VECTOR, "> 0",
+                  IRNode.VECTOR_REINTERPRET, "> 0"},
         applyIfPlatform = {"64-bit", "true"},
         applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true", "rvv", "true"})
-    // Missing support for MoveL2D
     static Object[] test10(long[] a, double[] b) {
         for (int i = 0; i < a.length; i++) {
             b[i] = Double.longBitsToDouble(a[i]);

test/micro/org/openjdk/bench/vm/compiler/TypeVectorOperations.java

@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2019, 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2025 IBM Corporation. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -262,13 +263,41 @@ public void convertD2L() {
         }
     }
 
+    @Benchmark
+    public void convertD2LBits() {
+        for (int i = 0; i < COUNT; i++) {
+            resL[i] = Double.doubleToLongBits(doubles[i]);
+        }
+    }
+
+    @Benchmark
+    public void convertD2LBitsRaw() {
+        for (int i = 0; i < COUNT; i++) {
+            resL[i] = Double.doubleToRawLongBits(doubles[i]);
+        }
+    }
+
     @Benchmark
     public void convertF2I() {
         for (int i = 0; i < COUNT; i++) {
             resI[i] = (int) floats[i];
         }
     }
 
+    @Benchmark
+    public void convertF2IBits() {
+        for (int i = 0; i < COUNT; i++) {
+            resI[i] = Float.floatToIntBits(floats[i]);
+        }
+    }
+
+    @Benchmark
+    public void convertF2IBitsRaw() {
+        for (int i = 0; i < COUNT; i++) {
+            resI[i] = (int) Float.floatToRawIntBits(floats[i]);
+        }
+    }
+
     @Benchmark
     public void convertF2B() {
         for (int i = 0; i < COUNT; i++) {
@@ -304,6 +333,13 @@ public void convertI2F() {
         }
     }
 
+    @Benchmark
+    public void convertIBits2F() {
+        for (int i = 0; i < COUNT; i++) {
+            resF[i] = Float.intBitsToFloat(ints[i]);
+        }
+    }
+
     @Benchmark
     public void convertI2D() {
         for (int i = 0; i < COUNT; i++) {
@@ -325,6 +361,13 @@ public void convertL2D() {
         }
     }
 
+    @Benchmark
+    public void convertLBits2D() {
+        for (int i = 0; i < COUNT; i++) {
+            resD[i] = Double.longBitsToDouble(longs[i]);
+        }
+    }
+
     @Benchmark
     public void convertL2B() {
         for (int i = 0; i < COUNT; i++) {