1 /*
  2  * Copyright (c) 2023, Red Hat, Inc. All rights reserved.
  3  * Copyright (c) 2024, Oracle and/or its affiliates. All rights reserved.
  4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  5  *
  6  * This code is free software; you can redistribute it and/or modify it
  7  * under the terms of the GNU General Public License version 2 only, as
  8  * published by the Free Software Foundation.
  9  *
 10  * This code is distributed in the hope that it will be useful, but WITHOUT
 11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 13  * version 2 for more details (a copy is included in the LICENSE file that
 14  * accompanied this code).
 15  *
 16  * You should have received a copy of the GNU General Public License version
 17  * 2 along with this work; if not, write to the Free Software Foundation,
 18  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 19  *
 20  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 21  * or visit www.oracle.com if you need additional information or have any
 22  * questions.
 23  */
 24 
 25 package compiler.c2.irTests;
 26 
 27 import compiler.lib.ir_framework.*;
 28 import jdk.test.lib.Utils;
 29 import jdk.test.whitebox.WhiteBox;
 30 import jdk.internal.misc.Unsafe;
 31 import java.util.Random;
 32 import java.util.Arrays;
 33 import java.nio.ByteOrder;
 34 
 35 /*
 36  * @test
 37  * @bug 8300258
 38  * @key randomness
 39  * @summary C2: vectorization fails on simple ByteBuffer loop
 40  * @modules java.base/jdk.internal.misc
 41  * @library /test/lib /
 42  * @build jdk.test.whitebox.WhiteBox
 43  * @run driver jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox
 44  * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI compiler.c2.irTests.TestVectorizationMismatchedAccess
 45  */
 46 
 47 public class TestVectorizationMismatchedAccess {
 48     private static final Unsafe UNSAFE = Unsafe.getUnsafe();
 49     private static final Random RANDOM = Utils.getRandomInstance();
 50     private final static WhiteBox wb = WhiteBox.getWhiteBox();
 51 
 52     public static void main(String[] args) {
 53         Object alignVector = wb.getVMFlag("AlignVector");
 54         if (alignVector != null && !((Boolean)alignVector)) {
 55             if (ByteOrder.nativeOrder() != ByteOrder.LITTLE_ENDIAN) {
 56                 throw new RuntimeException("fix test that was written for a little endian platform");
 57             }
 58             TestFramework.runWithFlags("--add-modules", "java.base", "--add-exports", "java.base/jdk.internal.misc=ALL-UNNAMED");
 59         }
 60     }
 61 
 62     static int size = 1024;
 63     static byte[] byteArray = new byte[size * 8];
 64     static long[] longArray = new long[size];
 65     static byte[] verifyByteArray = new byte[size * 8];
 66     static long[] verifyLongArray = new long[size];
 67     static long baseOffset = 0;
 68     static long baseOffHeap = UNSAFE.allocateMemory(size * 8);
 69 
 70 
 71     static {
 72         for (int i = 0; i < verifyByteArray.length; i++) {
 73             verifyByteArray[i] = (byte)RANDOM.nextInt(Byte.MAX_VALUE);
 74         }
 75         for (int i = 0; i < verifyLongArray.length; i++) {
 76             verifyLongArray[i] = 0;
 77             for (int j = 0; j < 8; j++) {
 78                 verifyLongArray[i] = verifyLongArray[i] | (((long)verifyByteArray[8 * i + j]) << 8 * j);
 79             }
 80         }
 81     }
 82 
 83     static private void runAndVerify(Runnable test, int offset) {
 84         System.arraycopy(verifyLongArray, 0, longArray, 0, longArray.length);
 85         Arrays.fill(byteArray, (byte)0);
 86         test.run();
 87         int i;
 88         for (i = 0; i < Math.max(offset, 0); i++) {
 89             if (byteArray[i] != 0) {
 90                 throw new RuntimeException("Incorrect result at " + i + " " + byteArray[i] + " != 0");
 91             }
 92         }
 93         for (; i < Math.min(byteArray.length + offset, byteArray.length); i++) {
 94             if (byteArray[i] != verifyByteArray[i - offset]) {
 95                 throw new RuntimeException("Incorrect result at " + i + " " + byteArray[i] + " != " + verifyByteArray[i-offset]);
 96             }
 97         }
 98         for (; i < byteArray.length; i++) {
 99             if (byteArray[i] != 0) {
100                 throw new RuntimeException("Incorrect result at " + i + " " + byteArray[i] + " != 0");
101             }
102         }
103     }
104 
105     static private void runAndVerify2(Runnable test, int offset) {
106         System.arraycopy(verifyByteArray, 0, byteArray, 0, byteArray.length);
107         test.run();
108         int i;
109         for (i = 0; i < Math.max(offset, 0); i++) {
110             if (byteArray[i] != verifyByteArray[i]) {
111                 throw new RuntimeException("Incorrect result at " + i + " " + byteArray[i] + " != " + verifyByteArray[i]);
112             }
113         }
114         for (; i < Math.min(byteArray.length + offset, byteArray.length); i++) {
115             int val = offset > 0 ? verifyByteArray[(i-offset) % 8] : verifyByteArray[i-offset];
116             if (byteArray[i] != val) {
117                 throw new RuntimeException("Incorrect result at " + i + " " + byteArray[i] + " != " + verifyByteArray[i-offset]);
118             }
119         }
120         for (; i < byteArray.length; i++) {
121             if (byteArray[i] != verifyByteArray[i]) {
122                 throw new RuntimeException("Incorrect result at " + i + " " + byteArray[i] + " != " + verifyByteArray[i]);
123             }
124         }
125     }
126 
127 
128     static private void runAndVerify3(Runnable test, int offset) {
129         System.arraycopy(verifyLongArray, 0, longArray, 0, longArray.length);
130         for (int i = 0; i < size * 8; i++) {
131             UNSAFE.putByte(null, baseOffHeap + i, (byte)0);
132         }
133         test.run();
134         int i;
135         for (i = 0; i < Math.max(offset, 0); i++) {
136             if (UNSAFE.getByte(null, baseOffHeap + i) != 0) {
137                 throw new RuntimeException("Incorrect result at " + i + " " + byteArray[i] + " != 0");
138             }
139         }
140         for (; i < Math.min(size * 8 + offset, size * 8); i++) {
141             if (UNSAFE.getByte(null, baseOffHeap + i) != verifyByteArray[i - offset]) {
142                 throw new RuntimeException("Incorrect result at " + i + " " + byteArray[i] + " != " + verifyByteArray[i-offset]);
143             }
144         }
145         for (; i < byteArray.length; i++) {
146             if (UNSAFE.getByte(null, baseOffHeap + i) != 0) {
147                 throw new RuntimeException("Incorrect result at " + i + " " + byteArray[i] + " != 0");
148             }
149         }
150     }
151 
152     @Test
153     @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
154         applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true"},
155         applyIfPlatform = {"64-bit", "true"})

156     // 32-bit: offsets are badly aligned (UNSAFE.ARRAY_BYTE_BASE_OFFSET is 4 byte aligned, but not 8 byte aligned).
157     //         might get fixed with JDK-8325155.
158     public static void testByteLong1a(byte[] dest, long[] src) {
159         for (int i = 0; i < src.length; i++) {
160             UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * i, src[i]);
161         }
162     }
163 
164     @Test
165     @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
166         applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true"},
167         applyIfPlatform = {"64-bit", "true"})

168     // 32-bit: address has ConvL2I for cast of long to address, not supported.
169     public static void testByteLong1b(byte[] dest, long[] src) {
170         for (int i = 0; i < src.length; i++) {
171             UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * i, src[i]);
172         }
173     }
174 
175     @Test
176     @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
177         applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true"})

178     public static void testByteLong1c(byte[] dest, long[] src) {
179         long base = 64; // make sure it is big enough and 8 byte aligned (required for 32-bit)
180         for (int i = 0; i < src.length - 8; i++) {
181             UNSAFE.putLongUnaligned(dest, base + 8 * i, src[i]);
182         }
183     }
184 
185     @Test
186     @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
187         applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true"},
188         applyIfPlatform = {"64-bit", "true"})

189     // 32-bit: address has ConvL2I for cast of long to address, not supported.
190     public static void testByteLong1d(byte[] dest, long[] src) {
191         long base = 64; // make sure it is big enough and 8 byte aligned (required for 32-bit)
192         for (int i = 0; i < src.length - 8; i++) {
193             UNSAFE.putLongUnaligned(dest, base + 8L * i, src[i]);
194         }
195     }
196 
197     @Run(test = {"testByteLong1a", "testByteLong1b", "testByteLong1c", "testByteLong1d"})
198     public static void testByteLong1_runner() {
199         runAndVerify(() -> testByteLong1a(byteArray, longArray), 0);
200         runAndVerify(() -> testByteLong1b(byteArray, longArray), 0);
201         testByteLong1c(byteArray, longArray);
202         testByteLong1d(byteArray, longArray);
203     }
204 
205     @Test
206     @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
207         applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true"},
208         applyIfPlatform = {"64-bit", "true"})

209     // 32-bit: offsets are badly aligned (UNSAFE.ARRAY_BYTE_BASE_OFFSET is 4 byte aligned, but not 8 byte aligned).
210     //         might get fixed with JDK-8325155.
211     public static void testByteLong2a(byte[] dest, long[] src) {
212         for (int i = 1; i < src.length; i++) {
213             UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * (i - 1), src[i]);
214         }
215     }
216 
217     @Test
218     @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
219         applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true"},
220         applyIfPlatform = {"64-bit", "true"})

221     // 32-bit: address has ConvL2I for cast of long to address, not supported.
222     public static void testByteLong2b(byte[] dest, long[] src) {
223         for (int i = 1; i < src.length; i++) {
224             UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * (i - 1), src[i]);
225         }
226     }
227 
228     @Run(test = {"testByteLong2a", "testByteLong2b"})
229     public static void testByteLong2_runner() {
230         runAndVerify(() -> testByteLong2a(byteArray, longArray), -8);
231         runAndVerify(() -> testByteLong2b(byteArray, longArray), -8);
232     }
233 
234     @Test
235     @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
236         applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true"},
237         applyIfPlatform = {"64-bit", "true"})

238     // 32-bit: offsets are badly aligned (UNSAFE.ARRAY_BYTE_BASE_OFFSET is 4 byte aligned, but not 8 byte aligned).
239     //         might get fixed with JDK-8325155.
240     public static void testByteLong3a(byte[] dest, long[] src) {
241         for (int i = 0; i < src.length - 1; i++) {
242             UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * (i + 1), src[i]);
243         }
244     }
245 
246     @Test
247     @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
248         applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true"},
249         applyIfPlatform = {"64-bit", "true"})

250     // 32-bit: address has ConvL2I for cast of long to address, not supported.
251     public static void testByteLong3b(byte[] dest, long[] src) {
252         for (int i = 0; i < src.length - 1; i++) {
253             UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * (i + 1), src[i]);
254         }
255     }
256 
257     @Run(test = {"testByteLong3a", "testByteLong3b"})
258     public static void testByteLong3_runner() {
259         runAndVerify(() -> testByteLong3a(byteArray, longArray), 8);
260         runAndVerify(() -> testByteLong3b(byteArray, longArray), 8);
261     }
262 
263     @Test
264     @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
265         applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true"},
266         applyIfPlatform = {"64-bit", "true"})
267     // 32-bit: offsets are badly aligned (UNSAFE.ARRAY_BYTE_BASE_OFFSET is 4 byte aligned, but not 8 byte aligned).
268     //         might get fixed with JDK-8325155.
269     public static void testByteLong4a(byte[] dest, long[] src, int start, int stop) {
270         for (int i = start; i < stop; i++) {
271             UNSAFE.putLongUnaligned(dest, 8 * i + baseOffset, src[i]);
272         }
273     }
274 
275     @Test
276     @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
277         applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true"},
278         applyIfPlatform = {"64-bit", "true"})
279     // 32-bit: address has ConvL2I for cast of long to address, not supported.
280     public static void testByteLong4b(byte[] dest, long[] src, int start, int stop) {
281         for (int i = start; i < stop; i++) {
282             UNSAFE.putLongUnaligned(dest, 8L * i + baseOffset, src[i]);
283         }
284     }
285 
286     @Run(test = {"testByteLong4a", "testByteLong4b"})
287     public static void testByteLong4_runner() {
288         baseOffset = UNSAFE.ARRAY_BYTE_BASE_OFFSET;
289         runAndVerify(() -> testByteLong4a(byteArray, longArray, 0, size), 0);
290         runAndVerify(() -> testByteLong4b(byteArray, longArray, 0, size), 0);
291     }
292 
293     @Test
294     @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
295         applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true"},
296         applyIfPlatform = {"64-bit", "true"})

297     // 32-bit: offsets are badly aligned (UNSAFE.ARRAY_BYTE_BASE_OFFSET is 4 byte aligned, but not 8 byte aligned).
298     //         might get fixed with JDK-8325155.
299     public static void testByteLong5a(byte[] dest, long[] src, int start, int stop) {
300         for (int i = start; i < stop; i++) {
301             UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * (i + baseOffset), src[i]);
302         }
303     }
304 
305     @Test
306     @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
307         applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true"},
308         applyIfPlatform = {"64-bit", "true"})

309     // 32-bit: address has ConvL2I for cast of long to address, not supported.
310     public static void testByteLong5b(byte[] dest, long[] src, int start, int stop) {
311         for (int i = start; i < stop; i++) {
312             UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * (i + baseOffset), src[i]);
313         }
314     }
315 
316     @Run(test = {"testByteLong5a", "testByteLong5b"})
317     public static void testByteLong5_runner() {
318         baseOffset = 1;
319         runAndVerify(() -> testByteLong5a(byteArray, longArray, 0, size-1), 8);
320         runAndVerify(() -> testByteLong5b(byteArray, longArray, 0, size-1), 8);
321     }
322 
323     @Test
324     @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
325         applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true"},
326         applyIfPlatform = {"64-bit", "true"})

327     // 32-bit: offsets are badly aligned (UNSAFE.ARRAY_BYTE_BASE_OFFSET is 4 byte aligned, but not 8 byte aligned).
328     //         might get fixed with JDK-8325155.
329     public static void testByteByte1a(byte[] dest, byte[] src) {
330         for (int i = 0; i < src.length / 8; i++) {
331             UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * i, UNSAFE.getLongUnaligned(src, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * i));
332         }
333     }
334 
335     @Test
336     @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
337         applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true"},
338         applyIfPlatform = {"64-bit", "true"})

339     // 32-bit: address has ConvL2I for cast of long to address, not supported.
340     public static void testByteByte1b(byte[] dest, byte[] src) {
341         for (int i = 0; i < src.length / 8; i++) {
342             UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * i, UNSAFE.getLongUnaligned(src, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * i));
343         }
344     }
345 
346     @Run(test = {"testByteByte1a", "testByteByte1b"})
347     public static void testByteByte1_runner() {
348         runAndVerify2(() -> testByteByte1a(byteArray, byteArray), 0);
349         runAndVerify2(() -> testByteByte1b(byteArray, byteArray), 0);
350     }
351 
352     @Test
353     // It would be legal to vectorize this one but it's not currently
354     //@IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
355     //    applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true"},
356     //    applyIfPlatform = {"64-bit", "true"})
357     // 32-bit: offsets are badly aligned (UNSAFE.ARRAY_BYTE_BASE_OFFSET is 4 byte aligned, but not 8 byte aligned).
358     //         might get fixed with JDK-8325155.
359     public static void testByteByte2a(byte[] dest, byte[] src) {
360         for (int i = 1; i < src.length / 8; i++) {
361             UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * (i - 1), UNSAFE.getLongUnaligned(src, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * i));
362         }
363     }
364 
365     @Test
366     // It would be legal to vectorize this one but it's not currently
367     //@IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
368     //    applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true"},
369     //    applyIfPlatform = {"64-bit", "true"})
370     // 32-bit: address has ConvL2I for cast of long to address, not supported.
371     public static void testByteByte2b(byte[] dest, byte[] src) {
372         for (int i = 1; i < src.length / 8; i++) {
373             UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * (i - 1), UNSAFE.getLongUnaligned(src, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * i));
374         }
375     }
376 
377     @Run(test = {"testByteByte2a", "testByteByte2b"})
378     public static void testByteByte2_runner() {
379         runAndVerify2(() -> testByteByte2a(byteArray, byteArray), -8);
380         runAndVerify2(() -> testByteByte2b(byteArray, byteArray), -8);
381     }
382 
383     @Test
384     @IR(failOn = { IRNode.LOAD_VECTOR_L, IRNode.STORE_VECTOR })
385     public static void testByteByte3a(byte[] dest, byte[] src) {
386         for (int i = 0; i < src.length / 8 - 1; i++) {
387             UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * (i + 1), UNSAFE.getLongUnaligned(src, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * i));
388         }
389     }
390 
391     @Test
392     @IR(failOn = { IRNode.LOAD_VECTOR_L, IRNode.STORE_VECTOR })
393     public static void testByteByte3b(byte[] dest, byte[] src) {
394         for (int i = 0; i < src.length / 8 - 1; i++) {
395             UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * (i + 1), UNSAFE.getLongUnaligned(src, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * i));
396         }
397     }
398 
399     @Run(test = {"testByteByte3a", "testByteByte3b"})
400     public static void testByteByte3_runner() {
401         runAndVerify2(() -> testByteByte3a(byteArray, byteArray), 8);
402         runAndVerify2(() -> testByteByte3b(byteArray, byteArray), 8);
403     }
404 
405     @Test
406     @IR(failOn = { IRNode.LOAD_VECTOR_L, IRNode.STORE_VECTOR })
407     public static void testByteByte4a(byte[] dest, byte[] src, int start, int stop) {
408         for (int i = start; i < stop; i++) {
409             UNSAFE.putLongUnaligned(dest, 8 * i + baseOffset, UNSAFE.getLongUnaligned(src, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * i));
410         }
411     }
412 
413     @Test
414     @IR(failOn = { IRNode.LOAD_VECTOR_L, IRNode.STORE_VECTOR })
415     public static void testByteByte4b(byte[] dest, byte[] src, int start, int stop) {
416         for (int i = start; i < stop; i++) {
417             UNSAFE.putLongUnaligned(dest, 8L * i + baseOffset, UNSAFE.getLongUnaligned(src, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * i));
418         }
419     }
420 
421     @Run(test = {"testByteByte4a", "testByteByte4b"})
422     public static void testByteByte4_runner() {
423         baseOffset = UNSAFE.ARRAY_BYTE_BASE_OFFSET;
424         runAndVerify2(() -> testByteByte4a(byteArray, byteArray, 0, size), 0);
425         runAndVerify2(() -> testByteByte4b(byteArray, byteArray, 0, size), 0);
426     }
427 
428     @Test
429     @IR(failOn = { IRNode.LOAD_VECTOR_L, IRNode.STORE_VECTOR })
430     public static void testByteByte5a(byte[] dest, byte[] src, int start, int stop) {
431         for (int i = start; i < stop; i++) {
432             UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * (i + baseOffset), UNSAFE.getLongUnaligned(src, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * i));
433         }
434     }
435 
436     @Test
437     @IR(failOn = { IRNode.LOAD_VECTOR_L, IRNode.STORE_VECTOR })
438     public static void testByteByte5b(byte[] dest, byte[] src, int start, int stop) {
439         for (int i = start; i < stop; i++) {
440             UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * (i + baseOffset), UNSAFE.getLongUnaligned(src, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * i));
441         }
442     }
443 
444     @Run(test = {"testByteByte5a", "testByteByte5b"})
445     public static void testByteByte5_runner() {
446         baseOffset = 1;
447         runAndVerify2(() -> testByteByte5a(byteArray, byteArray, 0, size-1), 8);
448         runAndVerify2(() -> testByteByte5b(byteArray, byteArray, 0, size-1), 8);
449     }
450 
451     @Test
452     @IR(counts = { IRNode.LOAD_VECTOR_L, "=0", IRNode.STORE_VECTOR, "=0" }) // temporary
453     // @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" })
454     // FAILS: adr is CastX2P(dest + 8 * (i + int_con))
455     // See: JDK-8331576
456     public static void testOffHeapLong1a(long dest, long[] src) {
457         for (int i = 0; i < src.length; i++) {
458             UNSAFE.putLongUnaligned(null, dest + 8 * i, src[i]);
459         }
460     }
461 
462     @Test
463     @IR(counts = { IRNode.LOAD_VECTOR_L, "=0", IRNode.STORE_VECTOR, "=0" }) // temporary
464     // @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" })
465     // FAILS: adr is CastX2P(dest + 8L * (i + int_con))
466     // See: JDK-8331576
467     public static void testOffHeapLong1b(long dest, long[] src) {
468         for (int i = 0; i < src.length; i++) {
469             UNSAFE.putLongUnaligned(null, dest + 8L * i, src[i]);
470         }
471     }
472 
473     @Run(test = {"testOffHeapLong1a", "testOffHeapLong1b"})
474     public static void testOffHeapLong1_runner() {
475         runAndVerify3(() -> testOffHeapLong1a(baseOffHeap, longArray), 0);
476         runAndVerify3(() -> testOffHeapLong1b(baseOffHeap, longArray), 0);
477     }
478 
479     @Test
480     @IR(counts = { IRNode.LOAD_VECTOR_L, "=0", IRNode.STORE_VECTOR, "=0" }) // temporary
481     // @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" })
482     // FAILS: adr is CastX2P
483     // See: JDK-8331576
484     public static void testOffHeapLong2a(long dest, long[] src) {
485         for (int i = 1; i < src.length; i++) {
486             UNSAFE.putLongUnaligned(null, dest + 8 * (i - 1), src[i]);
487         }
488     }
489 
490     @Test
491     @IR(counts = { IRNode.LOAD_VECTOR_L, "=0", IRNode.STORE_VECTOR, "=0" }) // temporary
492     // @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" })
493     // FAILS: adr is CastX2P
494     // See: JDK-8331576
495     public static void testOffHeapLong2b(long dest, long[] src) {
496         for (int i = 1; i < src.length; i++) {
497             UNSAFE.putLongUnaligned(null, dest + 8L * (i - 1), src[i]);
498         }
499     }
500 
501     @Run(test = {"testOffHeapLong2a", "testOffHeapLong2b"})
502     public static void testOffHeapLong2_runner() {
503         runAndVerify3(() -> testOffHeapLong2a(baseOffHeap, longArray), -8);
504         runAndVerify3(() -> testOffHeapLong2b(baseOffHeap, longArray), -8);
505     }
506 
507     @Test
508     @IR(counts = { IRNode.LOAD_VECTOR_L, "=0", IRNode.STORE_VECTOR, "=0" }) // temporary
509     // @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" })
510     // FAILS: adr is CastX2P
511     // See: JDK-8331576
512     public static void testOffHeapLong3a(long dest, long[] src) {
513         for (int i = 0; i < src.length - 1; i++) {
514             UNSAFE.putLongUnaligned(null, dest + 8 * (i + 1), src[i]);
515         }
516     }
517 
518     @Test
519     @IR(counts = { IRNode.LOAD_VECTOR_L, "=0", IRNode.STORE_VECTOR, "=0" }) // temporary
520     // @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" })
521     // FAILS: adr is CastX2P
522     // See: JDK-8331576
523     public static void testOffHeapLong3b(long dest, long[] src) {
524         for (int i = 0; i < src.length - 1; i++) {
525             UNSAFE.putLongUnaligned(null, dest + 8L * (i + 1), src[i]);
526         }
527     }
528 
529     @Run(test = {"testOffHeapLong3a", "testOffHeapLong3b"})
530     public static void testOffHeapLong3_runner() {
531         runAndVerify3(() -> testOffHeapLong3a(baseOffHeap, longArray), 8);
532         runAndVerify3(() -> testOffHeapLong3b(baseOffHeap, longArray), 8);
533     }
534 
535     @Test
536     @IR(counts = { IRNode.LOAD_VECTOR_L, "=0", IRNode.STORE_VECTOR, "=0" }) // temporary
537     // @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" })
538     // FAILS: adr is CastX2P
539     // See: JDK-8331576
540     public static void testOffHeapLong4a(long dest, long[] src, int start, int stop) {
541         for (int i = start; i < stop; i++) {
542             UNSAFE.putLongUnaligned(null, dest + 8 * i + baseOffset, src[i]);
543         }
544     }
545 
546     @Test
547     @IR(counts = { IRNode.LOAD_VECTOR_L, "=0", IRNode.STORE_VECTOR, "=0" }) // temporary
548     // @IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" })
549     // FAILS: adr is CastX2P
550     // See: JDK-8331576
551     public static void testOffHeapLong4b(long dest, long[] src, int start, int stop) {
552         for (int i = start; i < stop; i++) {
553             UNSAFE.putLongUnaligned(null, dest + 8L * i + baseOffset, src[i]);
554         }
555     }
556 
557     @Run(test = {"testOffHeapLong4a", "testOffHeapLong4b"})
558     public static void testOffHeapLong4_runner() {
559         baseOffset = 8;
560         runAndVerify3(() -> testOffHeapLong4a(baseOffHeap, longArray, 0, size-1), 8);
561         runAndVerify3(() -> testOffHeapLong4b(baseOffHeap, longArray, 0, size-1), 8);
562     }
563 }
--- EOF ---