8317763: Follow-up to AVX512 intrinsics for Arrays.sort() PR

make/modules/java.base/Lib.gmk

@@ -227,7 +227,7 @@ ifeq ($(ENABLE_FALLBACK_LINKER), true)
       NAME := fallbackLinker, \
       CFLAGS := $(CFLAGS_JDKLIB) $(LIBFFI_CFLAGS), \
       LDFLAGS := $(LDFLAGS_JDKLIB) \
-                  $(call SET_SHARED_LIBRARY_ORIGIN), \
+                 $(call SET_SHARED_LIBRARY_ORIGIN), \
       LIBS := $(LIBFFI_LIBS), \
       LIBS_windows := $(LIBFFI_LIBS) ws2_32.lib, \
   ))

src/hotspot/cpu/x86/stubGenerator_x86_64.cpp

@@ -4173,7 +4173,7 @@ void StubGenerator::generate_compiler_stubs() {
   }
 
   // Load x86_64_sort library on supported hardware to enable avx512 sort and partition intrinsics
-  if (UseAVX > 2 && VM_Version::supports_avx512dq()) {
+  if (VM_Version::is_intel() && VM_Version::supports_avx512dq()) {
     void *libsimdsort = nullptr;
     char ebuf_[1024];
     char dll_name_simd_sort[JVM_MAXPATHLEN];

src/java.base/linux/native/libsimdsort/avx512-common-qsort.h

@@ -57,9 +57,18 @@
 #include <cmath>
 #include <cstdint>
 #include <cstring>
-#include <immintrin.h>
 #include <limits>
 
+/*
+Workaround for the bug in GCC12 (that was fixed in GCC 12.3.1).
+More details are available at: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105593
+*/
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#pragma GCC diagnostic ignored "-Wuninitialized"
+#include <immintrin.h>
+#pragma GCC diagnostic pop
+
 #define X86_SIMD_SORT_INFINITY std::numeric_limits<double>::infinity()
 #define X86_SIMD_SORT_INFINITYF std::numeric_limits<float>::infinity()
 #define X86_SIMD_SORT_INFINITYH 0x7c00

src/java.base/share/classes/java/util/DualPivotQuicksort.java

@@ -166,9 +166,9 @@ interface PartitionOperation<A> {
         /**
          * Partitions the specified range of the array using the given pivots.
          *
-         * @param a the array to be sorted
-         * @param low the index of the first element, inclusive, to be sorted
-         * @param high the index of the last element, exclusive, to be sorted
+         * @param a the array to be partitioned
+         * @param low the index of the first element, inclusive, to be partitioned
+         * @param high the index of the last element, exclusive, to be partitioned
          * @param pivotIndex1 the index of pivot1, the first pivot
          * @param pivotIndex2 the index of pivot2, the second pivot
          */
@@ -178,13 +178,13 @@ interface PartitionOperation<A> {
     /**
      * Partitions the specified range of the array using the two pivots provided.
      *
-     * @param elemType the class of the array to be sorted
-     * @param array the array to be sorted
+     * @param elemType the class of the array to be partitioned
+     * @param array the array to be partitioned
      * @param offset the relative offset, in bytes, from the base address of
      * the array to partition, otherwise if the array is {@code null},an absolute
      * address pointing to the first element to partition from.
-     * @param low the index of the first element, inclusive, to be sorted
-     * @param high the index of the last element, exclusive, to be sorted
+     * @param low the index of the first element, inclusive, to be partitioned
+     * @param high the index of the last element, exclusive, to be partitioned
      * @param pivotIndex1 the index of pivot1, the first pivot
      * @param pivotIndex2 the index of pivot2, the second pivot
      * @param po the method reference for the fallback implementation
@@ -569,6 +569,7 @@ private static int[] partitionSinglePivot(int[] a, int low, int high, int pivotI
      * @param low the index of the first element, inclusive, to be sorted
      * @param high the index of the last element, exclusive, to be sorted
      */
+    @ForceInline
     private static void mixedInsertionSort(int[] a, int low, int high) {
         int size = high - low;
         int end = high - 3 * ((size >> 5) << 3);
@@ -684,6 +685,7 @@ private static void mixedInsertionSort(int[] a, int low, int high) {
      * @param low the index of the first element, inclusive, to be sorted
      * @param high the index of the last element, exclusive, to be sorted
      */
+    @ForceInline
     private static void insertionSort(int[] a, int low, int high) {
         for (int i, k = low; ++k < high; ) {
             int ai = a[i = k];
@@ -1371,6 +1373,7 @@ private static int[] partitionSinglePivot(long[] a, int low, int high, int pivot
      * @param low the index of the first element, inclusive, to be sorted
      * @param high the index of the last element, exclusive, to be sorted
      */
+    @ForceInline
     private static void mixedInsertionSort(long[] a, int low, int high) {
         int size = high - low;
         int end = high - 3 * ((size >> 5) << 3);
@@ -1486,6 +1489,7 @@ private static void mixedInsertionSort(long[] a, int low, int high) {
      * @param low the index of the first element, inclusive, to be sorted
      * @param high the index of the last element, exclusive, to be sorted
      */
+    @ForceInline
     private static void insertionSort(long[] a, int low, int high) {
         for (int i, k = low; ++k < high; ) {
             long ai = a[i = k];
@@ -2959,6 +2963,7 @@ private static int[] partitionSinglePivot(float[] a, int low, int high, int pivo
      * @param low the index of the first element, inclusive, to be sorted
      * @param high the index of the last element, exclusive, to be sorted
      */
+    @ForceInline
     private static void mixedInsertionSort(float[] a, int low, int high) {
         int size = high - low;
         int end = high - 3 * ((size >> 5) << 3);
@@ -3074,6 +3079,7 @@ private static void mixedInsertionSort(float[] a, int low, int high) {
      * @param low the index of the first element, inclusive, to be sorted
      * @param high the index of the last element, exclusive, to be sorted
      */
+    @ForceInline
     private static void insertionSort(float[] a, int low, int high) {
         for (int i, k = low; ++k < high; ) {
             float ai = a[i = k];
@@ -3812,6 +3818,7 @@ private static int[] partitionSinglePivot(double[] a, int low, int high, int piv
      * @param low the index of the first element, inclusive, to be sorted
      * @param high the index of the last element, exclusive, to be sorted
      */
+    @ForceInline
     private static void mixedInsertionSort(double[] a, int low, int high) {
         int size = high - low;
         int end = high - 3 * ((size >> 5) << 3);
@@ -3927,6 +3934,7 @@ private static void mixedInsertionSort(double[] a, int low, int high) {
      * @param low the index of the first element, inclusive, to be sorted
      * @param high the index of the last element, exclusive, to be sorted
      */
+    @ForceInline
     private static void insertionSort(double[] a, int low, int high) {
         for (int i, k = low; ++k < high; ) {
             double ai = a[i = k];