From 19380d74e437c17c4d8292e2adfd0fb20f059bb0 Mon Sep 17 00:00:00 2001
From: quadhier <quadhier@163.com>
Date: Wed, 12 Apr 2023 17:08:26 +0000
Subject: [PATCH] 8305324: C2: Wrong execution of vectorizing
 Interger.reverseBytes

Reviewed-by: kvn, pli
---
 src/hotspot/share/opto/superword.cpp          | 13 +++--
 .../TestNarrowedIntegerReverseBytes.java      | 56 +++++++++++++++++++
 2 files changed, 63 insertions(+), 6 deletions(-)
 create mode 100644 test/hotspot/jtreg/compiler/vectorization/TestNarrowedIntegerReverseBytes.java

diff --git a/src/hotspot/share/opto/superword.cpp b/src/hotspot/share/opto/superword.cpp
index fac643b9d22..a782fedfec5 100644
--- a/src/hotspot/share/opto/superword.cpp
+++ b/src/hotspot/share/opto/superword.cpp
@@ -3934,14 +3934,15 @@ void SuperWord::compute_vector_element_type() {
           }
           if (same_type) {
             // In any Java arithmetic operation, operands of small integer types
-            // (boolean, byte, char & short) should be promoted to int first. As
-            // vector elements of small types don't have upper bits of int, for
-            // RShiftI or AbsI operations, the compiler has to know the precise
-            // signedness info of the 1st operand. These operations shouldn't be
-            // vectorized if the signedness info is imprecise.
+            // (boolean, byte, char & short) should be promoted to int first.
+            // During narrowed integer type backward propagation, for some operations
+            // like RShiftI, Abs, and ReverseBytesI,
+            // the compiler has to know the higher order bits of the 1st operand,
+            // which will be lost in the narrowed type. These operations shouldn't
+            // be vectorized if the higher order bits info is imprecise.
             const Type* vt = vtn;
             int op = in->Opcode();
-            if (VectorNode::is_shift_opcode(op) || op == Op_AbsI) {
+            if (VectorNode::is_shift_opcode(op) || op == Op_AbsI || op == Op_ReverseBytesI) {
               Node* load = in->in(1);
               if (load->is_Load() && in_bb(load) && (velt_type(load)->basic_type() == T_INT)) {
                 // Only Load nodes distinguish signed (LoadS/LoadB) and unsigned
diff --git a/test/hotspot/jtreg/compiler/vectorization/TestNarrowedIntegerReverseBytes.java b/test/hotspot/jtreg/compiler/vectorization/TestNarrowedIntegerReverseBytes.java
new file mode 100644
index 00000000000..934922cd64a
--- /dev/null
+++ b/test/hotspot/jtreg/compiler/vectorization/TestNarrowedIntegerReverseBytes.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2023, Oracle and/or its affiliates. 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/* @test
+ * @bug 8305324
+ * @summary C2: Wrong execution of vectorizing Interger.reverseBytes
+ * @run main/othervm -Xcomp -XX:-TieredCompilation -XX:CompileCommand=compileonly,compiler.vectorization.TestNarrowedIntegerReverseBytes::* compiler.vectorization.TestNarrowedIntegerReverseBytes
+ */
+
+package compiler.vectorization;
+
+public class TestNarrowedIntegerReverseBytes {
+
+    static final int LEN = 33;
+    static byte byteArray[] = new byte[LEN];
+
+    static void test() {
+        for (int i = 0; i < LEN; i++) {
+            byteArray[i] = (byte) Integer.reverseBytes(i);
+        }
+    }
+
+    public static void main(String[] strArr) {
+        for (int i = 0; i < 2; i++) {
+            test();
+        }
+        for (int i = 0; i < byteArray.length; i++) {
+            if (byteArray[i] != 0) {
+                System.err.println("FAILED: all the elements should be zero");
+                System.exit(1);
+            }
+        }
+        System.out.println("PASSED");
+    }
+
+}