21 * questions.
22 */
23 package org.graalvm.compiler.core.test.ea;
24
25 import jdk.vm.ci.meta.JavaConstant;
26
27 import org.junit.Assert;
28 import org.junit.Test;
29
30 import org.graalvm.compiler.nodes.PhiNode;
31 import org.graalvm.compiler.nodes.ValuePhiNode;
32 import org.graalvm.compiler.nodes.java.LoadFieldNode;
33
34 public class UnsafeEATest extends EATestBase {
35
36 public static int zero = 0;
37
38 private static final long fieldOffset1;
39 private static final long fieldOffset2;
40
41 static {
42 try {
43 long localFieldOffset1 = UNSAFE.objectFieldOffset(TestClassInt.class.getField("x"));
44 // Make the fields 8 byte aligned (Required for testing setLong on Architectures which
45 // does not support unaligned memory access
46 if (localFieldOffset1 % 8 == 0) {
47 fieldOffset1 = localFieldOffset1;
48 fieldOffset2 = UNSAFE.objectFieldOffset(TestClassInt.class.getField("y"));
49 } else {
50 fieldOffset1 = UNSAFE.objectFieldOffset(TestClassInt.class.getField("y"));
51 fieldOffset2 = UNSAFE.objectFieldOffset(TestClassInt.class.getField("z"));
52 }
53 assert fieldOffset2 == fieldOffset1 + 4;
54 } catch (Exception e) {
55 throw new RuntimeException(e);
56 }
57 }
58
59 @Test
60 public void testSimpleInt() {
61 testEscapeAnalysis("testSimpleIntSnippet", JavaConstant.forInt(101), false);
62 }
63
64 public static int testSimpleIntSnippet() {
65 TestClassInt x = new TestClassInt();
66 UNSAFE.putInt(x, fieldOffset1, 101);
67 return UNSAFE.getInt(x, fieldOffset1);
68 }
69
70 @Test
71 public void testMaterializedInt() {
72 test("testMaterializedIntSnippet");
73 }
178 }
179 return x;
180 }
181
182 @Test
183 public void testDeoptLongConstant() {
184 test("testDeoptLongConstantSnippet");
185 }
186
187 public static TestClassInt testDeoptLongConstantSnippet() {
188 TestClassInt x = new TestClassInt();
189 UNSAFE.putLong(x, fieldOffset1, 0x2222222210123L);
190 longField2 = 123;
191 try {
192 longField = UNSAFE.getLong(x, fieldOffset1) / zero;
193 } catch (RuntimeException e) {
194 return x;
195 }
196 return x;
197 }
198 }
|
21 * questions.
22 */
23 package org.graalvm.compiler.core.test.ea;
24
25 import jdk.vm.ci.meta.JavaConstant;
26
27 import org.junit.Assert;
28 import org.junit.Test;
29
30 import org.graalvm.compiler.nodes.PhiNode;
31 import org.graalvm.compiler.nodes.ValuePhiNode;
32 import org.graalvm.compiler.nodes.java.LoadFieldNode;
33
34 public class UnsafeEATest extends EATestBase {
35
36 public static int zero = 0;
37
38 private static final long fieldOffset1;
39 private static final long fieldOffset2;
40
41 private static final long byteArrayBaseOffset;
42 private static final long intArrayBaseOffset;
43 private static final long longArrayBaseOffset;
44
45 static {
46 try {
47 long localFieldOffset1 = UNSAFE.objectFieldOffset(TestClassInt.class.getField("x"));
48 // Make the fields 8 byte aligned (Required for testing setLong on Architectures which
49 // does not support unaligned memory access
50 if (localFieldOffset1 % 8 == 0) {
51 fieldOffset1 = localFieldOffset1;
52 fieldOffset2 = UNSAFE.objectFieldOffset(TestClassInt.class.getField("y"));
53 } else {
54 fieldOffset1 = UNSAFE.objectFieldOffset(TestClassInt.class.getField("y"));
55 fieldOffset2 = UNSAFE.objectFieldOffset(TestClassInt.class.getField("z"));
56 }
57 assert fieldOffset2 == fieldOffset1 + 4;
58 byteArrayBaseOffset = UNSAFE.arrayBaseOffset(byte[].class);
59 intArrayBaseOffset = UNSAFE.arrayBaseOffset(int[].class);
60 longArrayBaseOffset = UNSAFE.arrayBaseOffset(long[].class);
61 } catch (Exception e) {
62 throw new RuntimeException(e);
63 }
64 }
65
66 @Test
67 public void testSimpleInt() {
68 testEscapeAnalysis("testSimpleIntSnippet", JavaConstant.forInt(101), false);
69 }
70
71 public static int testSimpleIntSnippet() {
72 TestClassInt x = new TestClassInt();
73 UNSAFE.putInt(x, fieldOffset1, 101);
74 return UNSAFE.getInt(x, fieldOffset1);
75 }
76
77 @Test
78 public void testMaterializedInt() {
79 test("testMaterializedIntSnippet");
80 }
185 }
186 return x;
187 }
188
189 @Test
190 public void testDeoptLongConstant() {
191 test("testDeoptLongConstantSnippet");
192 }
193
194 public static TestClassInt testDeoptLongConstantSnippet() {
195 TestClassInt x = new TestClassInt();
196 UNSAFE.putLong(x, fieldOffset1, 0x2222222210123L);
197 longField2 = 123;
198 try {
199 longField = UNSAFE.getLong(x, fieldOffset1) / zero;
200 } catch (RuntimeException e) {
201 return x;
202 }
203 return x;
204 }
205
206 public static int testWriteIntToByteArraySnippet() {
207 byte[] array = new byte[4];
208 UNSAFE.putInt(array, byteArrayBaseOffset, 0x01020304);
209 return array[0];
210 }
211
212 @Test
213 public void testWriteIntToByteArray() {
214 test("testWriteIntToByteArraySnippet");
215 }
216
217 public static byte testWriteSignedExtendedByteToByteArraySnippet(byte b) {
218 byte[] array = new byte[4];
219 array[0] = 0x01;
220 array[1] = 0x02;
221 array[2] = 0x03;
222 array[3] = 0x04;
223 UNSAFE.putInt(array, byteArrayBaseOffset, b);
224 return array[3];
225 }
226
227 @Test
228 public void testWriteSignedExtendedByteToByteArray() {
229 test("testWriteSignedExtendedByteToByteArraySnippet", (byte) 0);
230 }
231
232 public static int testWriteLongToIntArraySnippet() {
233 int[] array = new int[2];
234 UNSAFE.putLong(array, intArrayBaseOffset, 0x0102030405060708L);
235 return array[0];
236 }
237
238 @Test
239 public void testWriteLongToIntArray() {
240 test("testWriteLongToIntArraySnippet");
241 }
242
243 public static int testWriteByteToIntArraySnippet() {
244 int[] array = new int[1];
245 array[0] = 0x01020304;
246 UNSAFE.putByte(array, intArrayBaseOffset, (byte) 0x05);
247 return array[0];
248 }
249
250 @Test
251 public void testWriteByteToIntArray() {
252 test("testWriteByteToIntArraySnippet");
253 }
254
255 public static long testWriteIntToLongArraySnippet() {
256 long[] array = new long[1];
257 array[0] = 0x0102030405060708L;
258 UNSAFE.putInt(array, longArrayBaseOffset, 0x04030201);
259 return array[0];
260 }
261
262 @Test
263 public void testWriteIntToLongArray() {
264 test("testWriteIntToLongArraySnippet");
265 }
266
267 public static float testWriteFloatToIntArraySnippet() {
268 float[] array = new float[1];
269 UNSAFE.putInt(array, intArrayBaseOffset, Float.floatToRawIntBits(0.5f));
270 return array[0];
271 }
272
273 @Test
274 public void testWriteFloatToIntArray() {
275 test("testWriteFloatToIntArraySnippet");
276 }
277
278 }
|