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, "OopHandle"); 68 Constant wrappedKlassPointer = ((HotSpotResolvedObjectType) runtime.fromClass(TestClass.class)).klass(); 69 // this doesn't work. what is this? 70 return new Object[][]{new Object[]{JavaKind.Object, wrappedKlassPointer, (long) offset, TEST_CLASS_CONSTANT, 0}}; 71 } 72 73 @DataProvider(name = "positivePrimitive") 74 public static Object[][] getPositivePrimitiveJavaKinds() { 75 List<Object[]> result = new ArrayList<>(); 76 for (KindData k : PRIMITIVE_KIND_DATA) { 77 result.add(new Object[] {k.kind, TEST_CONSTANT, k.instanceFieldOffset, k.instanceFieldValue, Math.max(8, k.kind.getBitCount())}); 78 result.add(new Object[] {k.kind, TEST_CLASS_CONSTANT, k.staticFieldOffset, k.staticFieldValue, Math.max(8, k.kind.getBitCount())}); 79 } 80 return result.toArray(new Object[result.size()][]); 81 } 82 83 @DataProvider(name = "outOfBoundsInstanceFields") 84 public static Object[][] getOutOfBoundsStaticFieldReads() { 85 long instanceSize = WHITE_BOX.getObjectSize(TEST_OBJECT); 86 List<Object[]> result = new ArrayList<>(); 87 for (KindData k : PRIMITIVE_KIND_DATA) { 88 long lastValidOffset = instanceSize - (k.kind.getByteCount()); 89 result.add(new Object[] {k.kind, TEST_CONSTANT, lastValidOffset, false}); 90 result.add(new Object[] {k.kind, TEST_CONSTANT, (long) -1, true}); 91 result.add(new Object[] {k.kind, TEST_CONSTANT, lastValidOffset + 1, true}); 92 result.add(new Object[] {k.kind, TEST_CONSTANT, lastValidOffset + 100, true}); 93 } 94 return result.toArray(new Object[result.size()][]); 95 } 96 97 @DataProvider(name = "outOfBoundsStaticFields") 98 public static Object[][] getOutOfBoundsInstanceFieldReads() { 99 long staticsSize = WHITE_BOX.getObjectSize(TEST_OBJECT.getClass()); 100 List<Object[]> result = new ArrayList<>(); 101 for (KindData k : PRIMITIVE_KIND_DATA) { 102 long lastValidOffset = staticsSize - (k.kind.getByteCount()); 103 result.add(new Object[] {k.kind, TEST_CLASS_CONSTANT, lastValidOffset, false}); 104 result.add(new Object[] {k.kind, TEST_CLASS_CONSTANT, (long) -1, true}); 105 result.add(new Object[] {k.kind, TEST_CLASS_CONSTANT, lastValidOffset + 1, true}); 106 result.add(new Object[] {k.kind, TEST_CLASS_CONSTANT, lastValidOffset + 100, true}); 107 } 108 return result.toArray(new Object[result.size()][]); 109 } 110 111 @DataProvider(name = "negative") 112 public static Object[][] getNegativeJavaKinds() { 113 return new Object[][]{ 114 new Object[]{JavaKind.Void, JavaConstant.NULL_POINTER}, 115 new Object[]{JavaKind.Illegal, JavaConstant.INT_1}}; 116 } 117 118 119 private static class TestClass { 120 public final boolean booleanField = true; 121 public final byte byteField = 2; 122 public final short shortField = 3; 123 public final int intField = 4; 124 public final long longField = 5L; 125 public final double doubleField = 6.0d; 126 public final float floatField = 7.0f; 127 public final char charField = 'a'; 128 public final String objectField = "abc"; 129 130 public static final boolean booleanStaticField = true; 131 public static final byte byteStaticField = 2; 132 public static final short shortStaticField = 3; 133 public static final int intStaticField = 4; 134 public static final long longStaticField = 5L; 135 public static final double doubleStaticField = 6.0d; 136 public static final float floatStaticField = 7.0f; 137 public static final char charStaticField = 'a'; 138 public static final String objectStaticField = "abc"; 139 } 140 141 142 static class KindData { 143 final JavaKind kind; 144 final Field instanceField; 145 final Field staticField; 146 final long instanceFieldOffset; 147 final long staticFieldOffset; 148 final JavaConstant instanceFieldValue; 149 final JavaConstant staticFieldValue; 150 KindData(JavaKind kind, Object testObject) { 151 this.kind = kind; 152 try { 153 Class<?> c = testObject.getClass(); 154 instanceField = c.getDeclaredField(kind.getJavaName() + "Field"); 155 staticField = c.getDeclaredField(kind.getJavaName() + "StaticField"); 156 instanceField.setAccessible(true); 157 staticField.setAccessible(true); 158 instanceFieldOffset = UNSAFE.objectFieldOffset(instanceField); 159 staticFieldOffset = UNSAFE.staticFieldOffset(staticField); 160 instanceFieldValue = JavaConstant.forBoxedPrimitive(instanceField.get(testObject)); 161 staticFieldValue = JavaConstant.forBoxedPrimitive(staticField.get(null)); 162 } catch (Exception e) { 163 throw new Error("TESTBUG for kind " + kind, e); 164 } 165 } 166 } 167 }