8342489: compiler/c2/irTests/TestVectorizationMismatchedAccess.java fails on big-endian platforms

offamitkumar · MBaesken · commit 37c05c05c197 · 2024-11-13T10:12:53.000Z
Backport-of: b6f745d
diff --git a/test/hotspot/jtreg/compiler/c2/irTests/TestVectorizationMismatchedAccess.java b/test/hotspot/jtreg/compiler/c2/irTests/TestVectorizationMismatchedAccess.java
@@ -50,9 +50,6 @@ public class TestVectorizationMismatchedAccess {
     private final static WhiteBox wb = WhiteBox.getWhiteBox();
 
     public static void main(String[] args) {
-        if (ByteOrder.nativeOrder() != ByteOrder.LITTLE_ENDIAN) {
-            throw new RuntimeException("fix test that was written for a little endian platform");
-        }
         TestFramework.runWithFlags("--add-modules", "java.base", "--add-exports", "java.base/jdk.internal.misc=ALL-UNNAMED");
     }
 
@@ -77,6 +74,14 @@ public static void main(String[] args) {
         }
     }
 
+    // Method to adjust the value for the native byte order
+    static private long handleByteOrder(long value) {
+        if (ByteOrder.nativeOrder() != ByteOrder.LITTLE_ENDIAN) {
+            value = Long.reverseBytes(value);
+        }
+        return value;
+    }
+
     static private void runAndVerify(Runnable test, int offset) {
         System.arraycopy(verifyLongArray, 0, longArray, 0, longArray.length);
         Arrays.fill(byteArray, (byte)0);
@@ -154,7 +159,7 @@ static private void runAndVerify3(Runnable test, int offset) {
     //         might get fixed with JDK-8325155.
     public static void testByteLong1a(byte[] dest, long[] src) {
         for (int i = 0; i < src.length; i++) {
-            UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * i, src[i]);
+            UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * i, handleByteOrder(src[i]));
         }
     }
 
@@ -165,7 +170,7 @@ public static void testByteLong1a(byte[] dest, long[] src) {
     // 32-bit: address has ConvL2I for cast of long to address, not supported.
     public static void testByteLong1b(byte[] dest, long[] src) {
         for (int i = 0; i < src.length; i++) {
-            UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * i, src[i]);
+            UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * i, handleByteOrder(src[i]));
         }
     }
 
@@ -175,7 +180,7 @@ public static void testByteLong1b(byte[] dest, long[] src) {
     public static void testByteLong1c(byte[] dest, long[] src) {
         long base = 64; // make sure it is big enough and 8 byte aligned (required for 32-bit)
         for (int i = 0; i < src.length - 8; i++) {
-            UNSAFE.putLongUnaligned(dest, base + 8 * i, src[i]);
+            UNSAFE.putLongUnaligned(dest, base + 8 * i, handleByteOrder(src[i]));
         }
     }
 
@@ -187,7 +192,7 @@ public static void testByteLong1c(byte[] dest, long[] src) {
     public static void testByteLong1d(byte[] dest, long[] src) {
         long base = 64; // make sure it is big enough and 8 byte aligned (required for 32-bit)
         for (int i = 0; i < src.length - 8; i++) {
-            UNSAFE.putLongUnaligned(dest, base + 8L * i, src[i]);
+            UNSAFE.putLongUnaligned(dest, base + 8L * i, handleByteOrder(src[i]));
         }
     }
 
@@ -207,7 +212,7 @@ public static void testByteLong1_runner() {
     //         might get fixed with JDK-8325155.
     public static void testByteLong2a(byte[] dest, long[] src) {
         for (int i = 1; i < src.length; i++) {
-            UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * (i - 1), src[i]);
+            UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * (i - 1), handleByteOrder(src[i]));
         }
     }
 
@@ -218,7 +223,7 @@ public static void testByteLong2a(byte[] dest, long[] src) {
     // 32-bit: address has ConvL2I for cast of long to address, not supported.
     public static void testByteLong2b(byte[] dest, long[] src) {
         for (int i = 1; i < src.length; i++) {
-            UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * (i - 1), src[i]);
+            UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * (i - 1), handleByteOrder(src[i]));
         }
     }
 
@@ -236,7 +241,7 @@ public static void testByteLong2_runner() {
     //         might get fixed with JDK-8325155.
     public static void testByteLong3a(byte[] dest, long[] src) {
         for (int i = 0; i < src.length - 1; i++) {
-            UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * (i + 1), src[i]);
+            UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * (i + 1), handleByteOrder(src[i]));
         }
     }
 
@@ -247,7 +252,7 @@ public static void testByteLong3a(byte[] dest, long[] src) {
     // 32-bit: address has ConvL2I for cast of long to address, not supported.
     public static void testByteLong3b(byte[] dest, long[] src) {
         for (int i = 0; i < src.length - 1; i++) {
-            UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * (i + 1), src[i]);
+            UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * (i + 1), handleByteOrder(src[i]));
         }
     }
 
@@ -267,7 +272,7 @@ public static void testByteLong3_runner() {
     // AlignVector cannot guarantee that invar is aligned.
     public static void testByteLong4a(byte[] dest, long[] src, int start, int stop) {
         for (int i = start; i < stop; i++) {
-            UNSAFE.putLongUnaligned(dest, 8 * i + baseOffset, src[i]);
+            UNSAFE.putLongUnaligned(dest, 8 * i + baseOffset, handleByteOrder(src[i]));
         }
     }
 
@@ -280,7 +285,7 @@ public static void testByteLong4a(byte[] dest, long[] src, int start, int stop)
     // AlignVector cannot guarantee that invar is aligned.
     public static void testByteLong4b(byte[] dest, long[] src, int start, int stop) {
         for (int i = start; i < stop; i++) {
-            UNSAFE.putLongUnaligned(dest, 8L * i + baseOffset, src[i]);
+            UNSAFE.putLongUnaligned(dest, 8L * i + baseOffset, handleByteOrder(src[i]));
         }
     }
 
@@ -299,7 +304,7 @@ public static void testByteLong4_runner() {
     //         might get fixed with JDK-8325155.
     public static void testByteLong5a(byte[] dest, long[] src, int start, int stop) {
         for (int i = start; i < stop; i++) {
-            UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * (i + baseOffset), src[i]);
+            UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * (i + baseOffset), handleByteOrder(src[i]));
         }
     }
 
@@ -310,7 +315,7 @@ public static void testByteLong5a(byte[] dest, long[] src, int start, int stop)
     // 32-bit: address has ConvL2I for cast of long to address, not supported.
     public static void testByteLong5b(byte[] dest, long[] src, int start, int stop) {
         for (int i = start; i < stop; i++) {
-            UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * (i + baseOffset), src[i]);
+            UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * (i + baseOffset), handleByteOrder(src[i]));
         }
     }
 
@@ -454,7 +459,7 @@ public static void testByteByte5_runner() {
     // See: JDK-8331576
     public static void testOffHeapLong1a(long dest, long[] src) {
         for (int i = 0; i < src.length; i++) {
-            UNSAFE.putLongUnaligned(null, dest + 8 * i, src[i]);
+            UNSAFE.putLongUnaligned(null, dest + 8 * i, handleByteOrder(src[i]));
         }
     }
 
@@ -465,7 +470,7 @@ public static void testOffHeapLong1a(long dest, long[] src) {
     // See: JDK-8331576
     public static void testOffHeapLong1b(long dest, long[] src) {
         for (int i = 0; i < src.length; i++) {
-            UNSAFE.putLongUnaligned(null, dest + 8L * i, src[i]);
+            UNSAFE.putLongUnaligned(null, dest + 8L * i, handleByteOrder(src[i]));
         }
     }
 
@@ -482,7 +487,7 @@ public static void testOffHeapLong1_runner() {
     // See: JDK-8331576
     public static void testOffHeapLong2a(long dest, long[] src) {
         for (int i = 1; i < src.length; i++) {
-            UNSAFE.putLongUnaligned(null, dest + 8 * (i - 1), src[i]);
+            UNSAFE.putLongUnaligned(null, dest + 8 * (i - 1), handleByteOrder(src[i]));
         }
     }
 
@@ -493,7 +498,7 @@ public static void testOffHeapLong2a(long dest, long[] src) {
     // See: JDK-8331576
     public static void testOffHeapLong2b(long dest, long[] src) {
         for (int i = 1; i < src.length; i++) {
-            UNSAFE.putLongUnaligned(null, dest + 8L * (i - 1), src[i]);
+            UNSAFE.putLongUnaligned(null, dest + 8L * (i - 1), handleByteOrder(src[i]));
         }
     }
 
@@ -510,7 +515,7 @@ public static void testOffHeapLong2_runner() {
     // See: JDK-8331576
     public static void testOffHeapLong3a(long dest, long[] src) {
         for (int i = 0; i < src.length - 1; i++) {
-            UNSAFE.putLongUnaligned(null, dest + 8 * (i + 1), src[i]);
+            UNSAFE.putLongUnaligned(null, dest + 8 * (i + 1), handleByteOrder(src[i]));
         }
     }
 
@@ -521,7 +526,7 @@ public static void testOffHeapLong3a(long dest, long[] src) {
     // See: JDK-8331576
     public static void testOffHeapLong3b(long dest, long[] src) {
         for (int i = 0; i < src.length - 1; i++) {
-            UNSAFE.putLongUnaligned(null, dest + 8L * (i + 1), src[i]);
+            UNSAFE.putLongUnaligned(null, dest + 8L * (i + 1), handleByteOrder(src[i]));
         }
     }
 
@@ -540,7 +545,7 @@ public static void testOffHeapLong3_runner() {
     // AlignVector cannot guarantee that invar is aligned.
     public static void testOffHeapLong4a(long dest, long[] src, int start, int stop) {
         for (int i = start; i < stop; i++) {
-            UNSAFE.putLongUnaligned(null, dest + 8 * i + baseOffset, src[i]);
+            UNSAFE.putLongUnaligned(null, dest + 8 * i + baseOffset, handleByteOrder(src[i]));
         }
     }
 
@@ -553,7 +558,7 @@ public static void testOffHeapLong4a(long dest, long[] src, int start, int stop)
     // AlignVector cannot guarantee that invar is aligned.
     public static void testOffHeapLong4b(long dest, long[] src, int start, int stop) {
         for (int i = start; i < stop; i++) {
-            UNSAFE.putLongUnaligned(null, dest + 8L * i + baseOffset, src[i]);
+            UNSAFE.putLongUnaligned(null, dest + 8L * i + baseOffset, handleByteOrder(src[i]));
         }
     }
 

Original file line number	Diff line number	Diff line change
`@@ -50,9 +50,6 @@ public class TestVectorizationMismatchedAccess {`
`50`	`50`	`private final static WhiteBox wb = WhiteBox.getWhiteBox();`
`51`	`51`
`52`	`52`	`public static void main(String[] args) {`
`53`		`- if (ByteOrder.nativeOrder() != ByteOrder.LITTLE_ENDIAN) {`
`54`		`- throw new RuntimeException("fix test that was written for a little endian platform");`
`55`		`- }`
`56`	`53`	`TestFramework.runWithFlags("--add-modules", "java.base", "--add-exports", "java.base/jdk.internal.misc=ALL-UNNAMED");`
`57`	`54`	`}`
`58`	`55`
`@@ -77,6 +74,14 @@ public static void main(String[] args) {`
`77`	`74`	`}`
`78`	`75`	`}`
`79`	`76`
	`77`	`+ // Method to adjust the value for the native byte order`
	`78`	`+ static private long handleByteOrder(long value) {`
	`79`	`+ if (ByteOrder.nativeOrder() != ByteOrder.LITTLE_ENDIAN) {`
	`80`	`+ value = Long.reverseBytes(value);`
	`81`	`+ }`
	`82`	`+ return value;`
	`83`	`+ }`
	`84`	`+`
`80`	`85`	`static private void runAndVerify(Runnable test, int offset) {`
`81`	`86`	`System.arraycopy(verifyLongArray, 0, longArray, 0, longArray.length);`
`82`	`87`	`Arrays.fill(byteArray, (byte)0);`
`@@ -154,7 +159,7 @@ static private void runAndVerify3(Runnable test, int offset) {`
`154`	`159`	`// might get fixed with JDK-8325155.`
`155`	`160`	`public static void testByteLong1a(byte[] dest, long[] src) {`
`156`	`161`	`for (int i = 0; i < src.length; i++) {`
`157`		`- UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * i, src[i]);`
	`162`	`+ UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * i, handleByteOrder(src[i]));`
`158`	`163`	`}`
`159`	`164`	`}`
`160`	`165`
`@@ -165,7 +170,7 @@ public static void testByteLong1a(byte[] dest, long[] src) {`
`165`	`170`	`// 32-bit: address has ConvL2I for cast of long to address, not supported.`
`166`	`171`	`public static void testByteLong1b(byte[] dest, long[] src) {`
`167`	`172`	`for (int i = 0; i < src.length; i++) {`
`168`		`- UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * i, src[i]);`
	`173`	`+ UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * i, handleByteOrder(src[i]));`
`169`	`174`	`}`
`170`	`175`	`}`
`171`	`176`
`@@ -175,7 +180,7 @@ public static void testByteLong1b(byte[] dest, long[] src) {`
`175`	`180`	`public static void testByteLong1c(byte[] dest, long[] src) {`
`176`	`181`	`long base = 64; // make sure it is big enough and 8 byte aligned (required for 32-bit)`
`177`	`182`	`for (int i = 0; i < src.length - 8; i++) {`
`178`		`- UNSAFE.putLongUnaligned(dest, base + 8 * i, src[i]);`
	`183`	`+ UNSAFE.putLongUnaligned(dest, base + 8 * i, handleByteOrder(src[i]));`
`179`	`184`	`}`
`180`	`185`	`}`
`181`	`186`
`@@ -187,7 +192,7 @@ public static void testByteLong1c(byte[] dest, long[] src) {`
`187`	`192`	`public static void testByteLong1d(byte[] dest, long[] src) {`
`188`	`193`	`long base = 64; // make sure it is big enough and 8 byte aligned (required for 32-bit)`
`189`	`194`	`for (int i = 0; i < src.length - 8; i++) {`
`190`		`- UNSAFE.putLongUnaligned(dest, base + 8L * i, src[i]);`
	`195`	`+ UNSAFE.putLongUnaligned(dest, base + 8L * i, handleByteOrder(src[i]));`
`191`	`196`	`}`
`192`	`197`	`}`
`193`	`198`
`@@ -207,7 +212,7 @@ public static void testByteLong1_runner() {`
`207`	`212`	`// might get fixed with JDK-8325155.`
`208`	`213`	`public static void testByteLong2a(byte[] dest, long[] src) {`
`209`	`214`	`for (int i = 1; i < src.length; i++) {`
`210`		`- UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * (i - 1), src[i]);`
	`215`	`+ UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * (i - 1), handleByteOrder(src[i]));`
`211`	`216`	`}`
`212`	`217`	`}`
`213`	`218`
`@@ -218,7 +223,7 @@ public static void testByteLong2a(byte[] dest, long[] src) {`
`218`	`223`	`// 32-bit: address has ConvL2I for cast of long to address, not supported.`
`219`	`224`	`public static void testByteLong2b(byte[] dest, long[] src) {`
`220`	`225`	`for (int i = 1; i < src.length; i++) {`
`221`		`- UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * (i - 1), src[i]);`
	`226`	`+ UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * (i - 1), handleByteOrder(src[i]));`
`222`	`227`	`}`
`223`	`228`	`}`
`224`	`229`
`@@ -236,7 +241,7 @@ public static void testByteLong2_runner() {`
`236`	`241`	`// might get fixed with JDK-8325155.`
`237`	`242`	`public static void testByteLong3a(byte[] dest, long[] src) {`
`238`	`243`	`for (int i = 0; i < src.length - 1; i++) {`
`239`		`- UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * (i + 1), src[i]);`
	`244`	`+ UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * (i + 1), handleByteOrder(src[i]));`
`240`	`245`	`}`
`241`	`246`	`}`
`242`	`247`
`@@ -247,7 +252,7 @@ public static void testByteLong3a(byte[] dest, long[] src) {`
`247`	`252`	`// 32-bit: address has ConvL2I for cast of long to address, not supported.`
`248`	`253`	`public static void testByteLong3b(byte[] dest, long[] src) {`
`249`	`254`	`for (int i = 0; i < src.length - 1; i++) {`
`250`		`- UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * (i + 1), src[i]);`
	`255`	`+ UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * (i + 1), handleByteOrder(src[i]));`
`251`	`256`	`}`
`252`	`257`	`}`
`253`	`258`
`@@ -267,7 +272,7 @@ public static void testByteLong3_runner() {`
`267`	`272`	`// AlignVector cannot guarantee that invar is aligned.`
`268`	`273`	`public static void testByteLong4a(byte[] dest, long[] src, int start, int stop) {`
`269`	`274`	`for (int i = start; i < stop; i++) {`
`270`		`- UNSAFE.putLongUnaligned(dest, 8 * i + baseOffset, src[i]);`
	`275`	`+ UNSAFE.putLongUnaligned(dest, 8 * i + baseOffset, handleByteOrder(src[i]));`
`271`	`276`	`}`
`272`	`277`	`}`
`273`	`278`
`@@ -280,7 +285,7 @@ public static void testByteLong4a(byte[] dest, long[] src, int start, int stop)`
`280`	`285`	`// AlignVector cannot guarantee that invar is aligned.`
`281`	`286`	`public static void testByteLong4b(byte[] dest, long[] src, int start, int stop) {`
`282`	`287`	`for (int i = start; i < stop; i++) {`
`283`		`- UNSAFE.putLongUnaligned(dest, 8L * i + baseOffset, src[i]);`
	`288`	`+ UNSAFE.putLongUnaligned(dest, 8L * i + baseOffset, handleByteOrder(src[i]));`
`284`	`289`	`}`
`285`	`290`	`}`
`286`	`291`
`@@ -299,7 +304,7 @@ public static void testByteLong4_runner() {`
`299`	`304`	`// might get fixed with JDK-8325155.`
`300`	`305`	`public static void testByteLong5a(byte[] dest, long[] src, int start, int stop) {`
`301`	`306`	`for (int i = start; i < stop; i++) {`
`302`		`- UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * (i + baseOffset), src[i]);`
	`307`	`+ UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * (i + baseOffset), handleByteOrder(src[i]));`
`303`	`308`	`}`
`304`	`309`	`}`
`305`	`310`
`@@ -310,7 +315,7 @@ public static void testByteLong5a(byte[] dest, long[] src, int start, int stop)`
`310`	`315`	`// 32-bit: address has ConvL2I for cast of long to address, not supported.`
`311`	`316`	`public static void testByteLong5b(byte[] dest, long[] src, int start, int stop) {`
`312`	`317`	`for (int i = start; i < stop; i++) {`
`313`		`- UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * (i + baseOffset), src[i]);`
	`318`	`+ UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * (i + baseOffset), handleByteOrder(src[i]));`
`314`	`319`	`}`
`315`	`320`	`}`
`316`	`321`
`@@ -454,7 +459,7 @@ public static void testByteByte5_runner() {`
`454`	`459`	`// See: JDK-8331576`
`455`	`460`	`public static void testOffHeapLong1a(long dest, long[] src) {`
`456`	`461`	`for (int i = 0; i < src.length; i++) {`
`457`		`- UNSAFE.putLongUnaligned(null, dest + 8 * i, src[i]);`
	`462`	`+ UNSAFE.putLongUnaligned(null, dest + 8 * i, handleByteOrder(src[i]));`
`458`	`463`	`}`
`459`	`464`	`}`
`460`	`465`
`@@ -465,7 +470,7 @@ public static void testOffHeapLong1a(long dest, long[] src) {`
`465`	`470`	`// See: JDK-8331576`
`466`	`471`	`public static void testOffHeapLong1b(long dest, long[] src) {`
`467`	`472`	`for (int i = 0; i < src.length; i++) {`
`468`		`- UNSAFE.putLongUnaligned(null, dest + 8L * i, src[i]);`
	`473`	`+ UNSAFE.putLongUnaligned(null, dest + 8L * i, handleByteOrder(src[i]));`
`469`	`474`	`}`
`470`	`475`	`}`
`471`	`476`
`@@ -482,7 +487,7 @@ public static void testOffHeapLong1_runner() {`
`482`	`487`	`// See: JDK-8331576`
`483`	`488`	`public static void testOffHeapLong2a(long dest, long[] src) {`
`484`	`489`	`for (int i = 1; i < src.length; i++) {`
`485`		`- UNSAFE.putLongUnaligned(null, dest + 8 * (i - 1), src[i]);`
	`490`	`+ UNSAFE.putLongUnaligned(null, dest + 8 * (i - 1), handleByteOrder(src[i]));`
`486`	`491`	`}`
`487`	`492`	`}`
`488`	`493`
`@@ -493,7 +498,7 @@ public static void testOffHeapLong2a(long dest, long[] src) {`
`493`	`498`	`// See: JDK-8331576`
`494`	`499`	`public static void testOffHeapLong2b(long dest, long[] src) {`
`495`	`500`	`for (int i = 1; i < src.length; i++) {`
`496`		`- UNSAFE.putLongUnaligned(null, dest + 8L * (i - 1), src[i]);`
	`501`	`+ UNSAFE.putLongUnaligned(null, dest + 8L * (i - 1), handleByteOrder(src[i]));`
`497`	`502`	`}`
`498`	`503`	`}`
`499`	`504`
`@@ -510,7 +515,7 @@ public static void testOffHeapLong2_runner() {`
`510`	`515`	`// See: JDK-8331576`
`511`	`516`	`public static void testOffHeapLong3a(long dest, long[] src) {`
`512`	`517`	`for (int i = 0; i < src.length - 1; i++) {`
`513`		`- UNSAFE.putLongUnaligned(null, dest + 8 * (i + 1), src[i]);`
	`518`	`+ UNSAFE.putLongUnaligned(null, dest + 8 * (i + 1), handleByteOrder(src[i]));`
`514`	`519`	`}`
`515`	`520`	`}`
`516`	`521`
`@@ -521,7 +526,7 @@ public static void testOffHeapLong3a(long dest, long[] src) {`
`521`	`526`	`// See: JDK-8331576`
`522`	`527`	`public static void testOffHeapLong3b(long dest, long[] src) {`
`523`	`528`	`for (int i = 0; i < src.length - 1; i++) {`
`524`		`- UNSAFE.putLongUnaligned(null, dest + 8L * (i + 1), src[i]);`
	`529`	`+ UNSAFE.putLongUnaligned(null, dest + 8L * (i + 1), handleByteOrder(src[i]));`
`525`	`530`	`}`
`526`	`531`	`}`
`527`	`532`
`@@ -540,7 +545,7 @@ public static void testOffHeapLong3_runner() {`
`540`	`545`	`// AlignVector cannot guarantee that invar is aligned.`
`541`	`546`	`public static void testOffHeapLong4a(long dest, long[] src, int start, int stop) {`
`542`	`547`	`for (int i = start; i < stop; i++) {`
`543`		`- UNSAFE.putLongUnaligned(null, dest + 8 * i + baseOffset, src[i]);`
	`548`	`+ UNSAFE.putLongUnaligned(null, dest + 8 * i + baseOffset, handleByteOrder(src[i]));`
`544`	`549`	`}`
`545`	`550`	`}`
`546`	`551`
`@@ -553,7 +558,7 @@ public static void testOffHeapLong4a(long dest, long[] src, int start, int stop)`
`553`	`558`	`// AlignVector cannot guarantee that invar is aligned.`
`554`	`559`	`public static void testOffHeapLong4b(long dest, long[] src, int start, int stop) {`
`555`	`560`	`for (int i = start; i < stop; i++) {`
`556`		`- UNSAFE.putLongUnaligned(null, dest + 8L * i + baseOffset, src[i]);`
	`561`	`+ UNSAFE.putLongUnaligned(null, dest + 8L * i + baseOffset, handleByteOrder(src[i]));`
`557`	`562`	`}`
`558`	`563`	`}`
`559`	`564`