31 import static jdk.vm.ci.hotspot.test.TestHelper.getResolvedJavaField;
32 import static jdk.vm.ci.hotspot.test.TestHelper.INSTANCE_STABLE_FIELDS_MAP;
33 import static jdk.vm.ci.hotspot.test.TestHelper.INSTANCE_FIELDS_MAP;
34 import static jdk.vm.ci.hotspot.test.TestHelper.STABLE_ARRAYS_MAP;
35 import static jdk.vm.ci.hotspot.test.TestHelper.STABLE_ARRAY_ARRAYS_MAP;
36
37 import java.lang.reflect.Field;
38 import java.util.LinkedList;
39 import java.util.List;
40 import java.util.Map;
41 import java.util.stream.Stream;
42
43 import jdk.vm.ci.meta.JavaConstant;
44 import org.testng.annotations.DataProvider;
45 import jdk.internal.misc.Unsafe;
46 import jdk.vm.ci.meta.ResolvedJavaField;
47
48 public class ReadConstantArrayElementDataProvider {
49
50 // Non-stable array fields names mapped to their base offsets and index scale
51 private static final List<ArrayFieldParams> NON_STABLE_ARRAY_NAMES
52 = new LinkedList<>();
53
54 static {
55 NON_STABLE_ARRAY_NAMES.add(
56 new ArrayFieldParams("booleanArrayWithValues", Unsafe.ARRAY_BOOLEAN_BASE_OFFSET,
57 Unsafe.ARRAY_BOOLEAN_INDEX_SCALE));
58 NON_STABLE_ARRAY_NAMES.add(new ArrayFieldParams("byteArrayWithValues",
59 Unsafe.ARRAY_BYTE_BASE_OFFSET,
60 Unsafe.ARRAY_BYTE_INDEX_SCALE));
61 NON_STABLE_ARRAY_NAMES.add(new ArrayFieldParams("shortArrayWithValues",
62 Unsafe.ARRAY_SHORT_BASE_OFFSET,
63 Unsafe.ARRAY_SHORT_INDEX_SCALE));
64 NON_STABLE_ARRAY_NAMES.add(new ArrayFieldParams("charArrayWithValues",
65 Unsafe.ARRAY_CHAR_BASE_OFFSET,
66 Unsafe.ARRAY_CHAR_INDEX_SCALE));
67 NON_STABLE_ARRAY_NAMES.add(new ArrayFieldParams("intArrayWithValues",
68 Unsafe.ARRAY_INT_BASE_OFFSET,
69 Unsafe.ARRAY_INT_INDEX_SCALE));
70 NON_STABLE_ARRAY_NAMES.add(new ArrayFieldParams("longArrayWithValues",
71 Unsafe.ARRAY_LONG_BASE_OFFSET,
72 Unsafe.ARRAY_LONG_INDEX_SCALE));
92 Unsafe.ARRAY_OBJECT_BASE_OFFSET,
93 Unsafe.ARRAY_OBJECT_INDEX_SCALE));
94 NON_STABLE_ARRAY_NAMES.add(new ArrayFieldParams("intArrayArrayWithValues",
95 Unsafe.ARRAY_OBJECT_BASE_OFFSET,
96 Unsafe.ARRAY_OBJECT_INDEX_SCALE));
97 NON_STABLE_ARRAY_NAMES.add(new ArrayFieldParams("longArrayArrayWithValues",
98 Unsafe.ARRAY_OBJECT_BASE_OFFSET,
99 Unsafe.ARRAY_OBJECT_INDEX_SCALE));
100 NON_STABLE_ARRAY_NAMES.add(new ArrayFieldParams("floatArrayArrayWithValues",
101 Unsafe.ARRAY_OBJECT_BASE_OFFSET,
102 Unsafe.ARRAY_OBJECT_INDEX_SCALE));
103 NON_STABLE_ARRAY_NAMES.add(new ArrayFieldParams("doubleArrayArrayWithValues",
104 Unsafe.ARRAY_OBJECT_BASE_OFFSET,
105 Unsafe.ARRAY_OBJECT_INDEX_SCALE));
106 NON_STABLE_ARRAY_NAMES.add(new ArrayFieldParams("objectArrayArrayWithValues",
107 Unsafe.ARRAY_OBJECT_BASE_OFFSET,
108 Unsafe.ARRAY_OBJECT_INDEX_SCALE));
109 }
110
111 // Stable array fields names mapped to their base offsets and index scale
112 private static final List<ArrayFieldParams> STABLE_ARRAY_NAMES
113 = new LinkedList<>();
114
115 static {
116 NON_STABLE_ARRAY_NAMES.stream().forEach((entry) -> {
117 String nsFieldName = entry.name;
118 char firstChar = nsFieldName.charAt(0);
119 char newFirstChar = Character.toUpperCase(firstChar);
120 String sFieldName = nsFieldName.replaceFirst("" + firstChar,
121 "" + newFirstChar);
122 sFieldName = "stable" + sFieldName;
123 STABLE_ARRAY_NAMES.add(new ArrayFieldParams(sFieldName, entry.offsetBase, entry.scale));
124 });
125 }
126
127 @DataProvider(name = "readConstantArrayElementDataProvider")
128 public static Object[][] readConstantArrayElementDataProvider() {
129 LinkedList<Object[]> cfgSet = new LinkedList<>();
130 for (int i : new int[]{0, 1}) {
131 NON_STABLE_ARRAY_NAMES.stream().forEach((entry) -> {
132 String fieldName = entry.name;
133 cfgSet.add(new Object[]{
134 readFieldValue(fieldName),
135 i,
136 null,
137 "array field \"" + fieldName + "\" for index " + i});
138 });
139 STABLE_ARRAY_NAMES.stream().forEach((entry) -> {
140 String fieldName = entry.name;
141 cfgSet.add(new Object[]{
142 readFieldValue(fieldName),
143 i,
144 i == 0 ? getJavaConstant(fieldName) : null,
145 "array field \"" + fieldName + "\" for index " + i});
146 });
147 }
148 Stream<Map.Entry<ResolvedJavaField, JavaConstant>> arraysStream1
149 = Stream.concat(ARRAYS_MAP.entrySet().stream(),
150 ARRAY_ARRAYS_MAP.entrySet().stream());
151 Stream<Map.Entry<ResolvedJavaField, JavaConstant>> arraysStream2
152 = Stream.concat(STABLE_ARRAYS_MAP.entrySet().stream(),
153 STABLE_ARRAY_ARRAYS_MAP.entrySet().stream());
154 Stream.concat(arraysStream1, arraysStream2).forEach((array) -> {
155 for (int i : new int[]{-1, 2}) {
156 cfgSet.add(new Object[]{
157 array.getValue(),
158 i,
159 null,
160 "array field \"" + array.getKey() + "\" for index " + i});
161 }
162 });
163 cfgSet.add(new Object[]{null, 0, null, "null"});
164 cfgSet.add(new Object[]{JavaConstant.NULL_POINTER, 0, null, "JavaConstant.NULL_POINTER"});
165 INSTANCE_FIELDS_MAP.values().forEach((constant) -> {
166 cfgSet.add(new Object[]{constant, 0, null, "non-stable non-array field"});
167 });
168 INSTANCE_STABLE_FIELDS_MAP.values().forEach((constant) -> {
169 cfgSet.add(new Object[]{constant, 0, null, "stable non-array field"});
170 });
171 return cfgSet.toArray(new Object[0][0]);
172 }
|
31 import static jdk.vm.ci.hotspot.test.TestHelper.getResolvedJavaField;
32 import static jdk.vm.ci.hotspot.test.TestHelper.INSTANCE_STABLE_FIELDS_MAP;
33 import static jdk.vm.ci.hotspot.test.TestHelper.INSTANCE_FIELDS_MAP;
34 import static jdk.vm.ci.hotspot.test.TestHelper.STABLE_ARRAYS_MAP;
35 import static jdk.vm.ci.hotspot.test.TestHelper.STABLE_ARRAY_ARRAYS_MAP;
36
37 import java.lang.reflect.Field;
38 import java.util.LinkedList;
39 import java.util.List;
40 import java.util.Map;
41 import java.util.stream.Stream;
42
43 import jdk.vm.ci.meta.JavaConstant;
44 import org.testng.annotations.DataProvider;
45 import jdk.internal.misc.Unsafe;
46 import jdk.vm.ci.meta.ResolvedJavaField;
47
48 public class ReadConstantArrayElementDataProvider {
49
50 // Non-stable array fields names mapped to their base offsets and index scale
51 private static final List<ArrayFieldParams> NON_STABLE_ARRAY_NAMES = new LinkedList<>();
52
53 static {
54 NON_STABLE_ARRAY_NAMES.add(
55 new ArrayFieldParams("booleanArrayWithValues", Unsafe.ARRAY_BOOLEAN_BASE_OFFSET,
56 Unsafe.ARRAY_BOOLEAN_INDEX_SCALE));
57 NON_STABLE_ARRAY_NAMES.add(new ArrayFieldParams("byteArrayWithValues",
58 Unsafe.ARRAY_BYTE_BASE_OFFSET,
59 Unsafe.ARRAY_BYTE_INDEX_SCALE));
60 NON_STABLE_ARRAY_NAMES.add(new ArrayFieldParams("shortArrayWithValues",
61 Unsafe.ARRAY_SHORT_BASE_OFFSET,
62 Unsafe.ARRAY_SHORT_INDEX_SCALE));
63 NON_STABLE_ARRAY_NAMES.add(new ArrayFieldParams("charArrayWithValues",
64 Unsafe.ARRAY_CHAR_BASE_OFFSET,
65 Unsafe.ARRAY_CHAR_INDEX_SCALE));
66 NON_STABLE_ARRAY_NAMES.add(new ArrayFieldParams("intArrayWithValues",
67 Unsafe.ARRAY_INT_BASE_OFFSET,
68 Unsafe.ARRAY_INT_INDEX_SCALE));
69 NON_STABLE_ARRAY_NAMES.add(new ArrayFieldParams("longArrayWithValues",
70 Unsafe.ARRAY_LONG_BASE_OFFSET,
71 Unsafe.ARRAY_LONG_INDEX_SCALE));
91 Unsafe.ARRAY_OBJECT_BASE_OFFSET,
92 Unsafe.ARRAY_OBJECT_INDEX_SCALE));
93 NON_STABLE_ARRAY_NAMES.add(new ArrayFieldParams("intArrayArrayWithValues",
94 Unsafe.ARRAY_OBJECT_BASE_OFFSET,
95 Unsafe.ARRAY_OBJECT_INDEX_SCALE));
96 NON_STABLE_ARRAY_NAMES.add(new ArrayFieldParams("longArrayArrayWithValues",
97 Unsafe.ARRAY_OBJECT_BASE_OFFSET,
98 Unsafe.ARRAY_OBJECT_INDEX_SCALE));
99 NON_STABLE_ARRAY_NAMES.add(new ArrayFieldParams("floatArrayArrayWithValues",
100 Unsafe.ARRAY_OBJECT_BASE_OFFSET,
101 Unsafe.ARRAY_OBJECT_INDEX_SCALE));
102 NON_STABLE_ARRAY_NAMES.add(new ArrayFieldParams("doubleArrayArrayWithValues",
103 Unsafe.ARRAY_OBJECT_BASE_OFFSET,
104 Unsafe.ARRAY_OBJECT_INDEX_SCALE));
105 NON_STABLE_ARRAY_NAMES.add(new ArrayFieldParams("objectArrayArrayWithValues",
106 Unsafe.ARRAY_OBJECT_BASE_OFFSET,
107 Unsafe.ARRAY_OBJECT_INDEX_SCALE));
108 }
109
110 // Stable array fields names mapped to their base offsets and index scale
111 private static final List<ArrayFieldParams> STABLE_ARRAY_NAMES = new LinkedList<>();
112
113 static {
114 NON_STABLE_ARRAY_NAMES.stream().forEach((entry) -> {
115 String nsFieldName = entry.name;
116 char firstChar = nsFieldName.charAt(0);
117 char newFirstChar = Character.toUpperCase(firstChar);
118 String sFieldName = nsFieldName.replaceFirst("" + firstChar,
119 "" + newFirstChar);
120 sFieldName = "stable" + sFieldName;
121 STABLE_ARRAY_NAMES.add(new ArrayFieldParams(sFieldName, entry.offsetBase, entry.scale));
122 });
123 }
124
125 @DataProvider(name = "readConstantArrayElementDataProvider")
126 public static Object[][] readConstantArrayElementDataProvider() {
127 LinkedList<Object[]> cfgSet = new LinkedList<>();
128 for (int i : new int[]{0, 1}) {
129 NON_STABLE_ARRAY_NAMES.stream().forEach((entry) -> {
130 String fieldName = entry.name;
131 cfgSet.add(new Object[]{
132 readFieldValue(fieldName),
133 i,
134 null,
135 "array field \"" + fieldName + "\" for index " + i});
136 });
137 STABLE_ARRAY_NAMES.stream().forEach((entry) -> {
138 String fieldName = entry.name;
139 cfgSet.add(new Object[]{
140 readFieldValue(fieldName),
141 i,
142 i == 0 ? getJavaConstant(fieldName) : null,
143 "array field \"" + fieldName + "\" for index " + i});
144 });
145 }
146 Stream<Map.Entry<ResolvedJavaField, JavaConstant>> arraysStream1 = Stream.concat(ARRAYS_MAP.entrySet().stream(),
147 ARRAY_ARRAYS_MAP.entrySet().stream());
148 Stream<Map.Entry<ResolvedJavaField, JavaConstant>> arraysStream2 = Stream.concat(STABLE_ARRAYS_MAP.entrySet().stream(),
149 STABLE_ARRAY_ARRAYS_MAP.entrySet().stream());
150 Stream.concat(arraysStream1, arraysStream2).forEach((array) -> {
151 for (int i : new int[]{-1, 2}) {
152 cfgSet.add(new Object[]{
153 array.getValue(),
154 i,
155 null,
156 "array field \"" + array.getKey() + "\" for index " + i});
157 }
158 });
159 cfgSet.add(new Object[]{null, 0, null, "null"});
160 cfgSet.add(new Object[]{JavaConstant.NULL_POINTER, 0, null, "JavaConstant.NULL_POINTER"});
161 INSTANCE_FIELDS_MAP.values().forEach((constant) -> {
162 cfgSet.add(new Object[]{constant, 0, null, "non-stable non-array field"});
163 });
164 INSTANCE_STABLE_FIELDS_MAP.values().forEach((constant) -> {
165 cfgSet.add(new Object[]{constant, 0, null, "stable non-array field"});
166 });
167 return cfgSet.toArray(new Object[0][0]);
168 }
|