1 /* 2 * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 */ 23 24 package jdk.vm.ci.hotspot.test; 25 26 import java.lang.reflect.Field; 27 28 import org.testng.annotations.DataProvider; 29 30 import sun.hotspot.WhiteBox; 31 import jdk.internal.misc.Unsafe; 32 import jdk.vm.ci.hotspot.HotSpotConstantReflectionProvider; 33 import jdk.vm.ci.hotspot.HotSpotJVMCIRuntimeProvider; 34 import jdk.vm.ci.hotspot.HotSpotResolvedObjectType; 35 import jdk.vm.ci.hotspot.HotSpotVMConfigAccess; 36 import jdk.vm.ci.meta.Constant; 37 import jdk.vm.ci.meta.JavaConstant; 38 import jdk.vm.ci.meta.JavaKind; 39 import jdk.vm.ci.runtime.JVMCI; 40 import java.util.List; 41 import java.util.ArrayList; 42 import java.util.Map; 43 import java.util.HashMap; 44 45 public class MemoryAccessProviderData { 46 private static final Unsafe UNSAFE = Unsafe.getUnsafe(); 47 private static final HotSpotConstantReflectionProvider CONSTANT_REFLECTION = (HotSpotConstantReflectionProvider) JVMCI.getRuntime().getHostJVMCIBackend().getConstantReflection(); 48 private static final TestClass TEST_OBJECT = new TestClass(); 49 private static final JavaConstant TEST_CONSTANT = CONSTANT_REFLECTION.forObject(TEST_OBJECT); 50 private static final JavaConstant TEST_CLASS_CONSTANT = CONSTANT_REFLECTION.forObject(TestClass.class); 51 private static KindData[] PRIMITIVE_KIND_DATA = { 52 new KindData(JavaKind.Boolean, TEST_OBJECT), 53 new KindData(JavaKind.Byte, TEST_OBJECT), 54 new KindData(JavaKind.Char, TEST_OBJECT), 55 new KindData(JavaKind.Short, TEST_OBJECT), 56 new KindData(JavaKind.Int, TEST_OBJECT), 57 new KindData(JavaKind.Float, TEST_OBJECT), 58 new KindData(JavaKind.Long, TEST_OBJECT), 59 new KindData(JavaKind.Double, TEST_OBJECT) 60 }; 61 private static final WhiteBox WHITE_BOX = WhiteBox.getWhiteBox(); 62 63 64 @DataProvider(name = "positiveObject") 65 public static Object[][] getPositiveObjectJavaKind() { 66 HotSpotJVMCIRuntimeProvider runtime = (HotSpotJVMCIRuntimeProvider) JVMCI.getRuntime(); 67 int offset = new HotSpotVMConfigAccess(runtime.getConfigStore()).getFieldOffset("Klass::_java_mirror", Integer.class, "oop"); 68 Constant wrappedKlassPointer = ((HotSpotResolvedObjectType) runtime.fromClass(TestClass.class)).klass(); 69 return new Object[][]{new Object[]{JavaKind.Object, wrappedKlassPointer, (long) offset, TEST_CLASS_CONSTANT, 0}}; 70 } 71 72 @DataProvider(name = "positivePrimitive") 73 public static Object[][] getPositivePrimitiveJavaKinds() { 74 List<Object[]> result = new ArrayList<>(); 75 for (KindData k : PRIMITIVE_KIND_DATA) { 76 result.add(new Object[] {k.kind, TEST_CONSTANT, k.instanceFieldOffset, k.instanceFieldValue, Math.max(8, k.kind.getBitCount())}); 77 result.add(new Object[] {k.kind, TEST_CLASS_CONSTANT, k.staticFieldOffset, k.staticFieldValue, Math.max(8, k.kind.getBitCount())}); 78 } 79 return result.toArray(new Object[result.size()][]); 80 } 81 82 @DataProvider(name = "outOfBoundsInstanceFields") 83 public static Object[][] getOutOfBoundsStaticFieldReads() { 84 long instanceSize = WHITE_BOX.getObjectSize(TEST_OBJECT); 85 List<Object[]> result = new ArrayList<>(); 86 for (KindData k : PRIMITIVE_KIND_DATA) { 87 long lastValidOffset = instanceSize - (k.kind.getByteCount()); 88 result.add(new Object[] {k.kind, TEST_CONSTANT, lastValidOffset, false}); 89 result.add(new Object[] {k.kind, TEST_CONSTANT, (long) -1, true}); 90 result.add(new Object[] {k.kind, TEST_CONSTANT, lastValidOffset + 1, true}); 91 result.add(new Object[] {k.kind, TEST_CONSTANT, lastValidOffset + 100, true}); 92 } 93 return result.toArray(new Object[result.size()][]); 94 } 95 96 @DataProvider(name = "outOfBoundsStaticFields") 97 public static Object[][] getOutOfBoundsInstanceFieldReads() { 98 long staticsSize = WHITE_BOX.getObjectSize(TEST_OBJECT.getClass()); 99 List<Object[]> result = new ArrayList<>(); 100 for (KindData k : PRIMITIVE_KIND_DATA) { 101 long lastValidOffset = staticsSize - (k.kind.getByteCount()); 102 result.add(new Object[] {k.kind, TEST_CLASS_CONSTANT, lastValidOffset, false}); 103 result.add(new Object[] {k.kind, TEST_CLASS_CONSTANT, (long) -1, true}); 104 result.add(new Object[] {k.kind, TEST_CLASS_CONSTANT, lastValidOffset + 1, true}); 105 result.add(new Object[] {k.kind, TEST_CLASS_CONSTANT, lastValidOffset + 100, true}); 106 } 107 return result.toArray(new Object[result.size()][]); 108 } 109 110 @DataProvider(name = "negative") 111 public static Object[][] getNegativeJavaKinds() { 112 return new Object[][]{ 113 new Object[]{JavaKind.Void, JavaConstant.NULL_POINTER}, 114 new Object[]{JavaKind.Illegal, JavaConstant.INT_1}}; 115 } 116 117 118 private static class TestClass { 119 public final boolean booleanField = true; 120 public final byte byteField = 2; 121 public final short shortField = 3; 122 public final int intField = 4; 123 public final long longField = 5L; 124 public final double doubleField = 6.0d; 125 public final float floatField = 7.0f; 126 public final char charField = 'a'; 127 public final String objectField = "abc"; 128 129 public static final boolean booleanStaticField = true; 130 public static final byte byteStaticField = 2; 131 public static final short shortStaticField = 3; 132 public static final int intStaticField = 4; 133 public static final long longStaticField = 5L; 134 public static final double doubleStaticField = 6.0d; 135 public static final float floatStaticField = 7.0f; 136 public static final char charStaticField = 'a'; 137 public static final String objectStaticField = "abc"; 138 } 139 140 141 static class KindData { 142 final JavaKind kind; 143 final Field instanceField; 144 final Field staticField; 145 final long instanceFieldOffset; 146 final long staticFieldOffset; 147 final JavaConstant instanceFieldValue; 148 final JavaConstant staticFieldValue; 149 KindData(JavaKind kind, Object testObject) { 150 this.kind = kind; 151 try { 152 Class<?> c = testObject.getClass(); 153 instanceField = c.getDeclaredField(kind.getJavaName() + "Field"); 154 staticField = c.getDeclaredField(kind.getJavaName() + "StaticField"); 155 instanceField.setAccessible(true); 156 staticField.setAccessible(true); 157 instanceFieldOffset = UNSAFE.objectFieldOffset(instanceField); 158 staticFieldOffset = UNSAFE.staticFieldOffset(staticField); 159 instanceFieldValue = JavaConstant.forBoxedPrimitive(instanceField.get(testObject)); 160 staticFieldValue = JavaConstant.forBoxedPrimitive(staticField.get(null)); 161 } catch (Exception e) { 162 throw new Error("TESTBUG for kind " + kind, e); 163 } 164 } 165 } 166 }