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 }