1 /*
2 * Copyright (c) 2015, 2019, 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 /**
25 * @test
26 * @requires vm.jvmci & (vm.simpleArch == "x64" | vm.simpleArch == "sparcv9")
27 * @library /
28 * @modules jdk.internal.vm.ci/jdk.vm.ci.hotspot
29 * jdk.internal.vm.ci/jdk.vm.ci.meta
30 * jdk.internal.vm.ci/jdk.vm.ci.code
31 * jdk.internal.vm.ci/jdk.vm.ci.code.site
32 * jdk.internal.vm.ci/jdk.vm.ci.runtime
33 * jdk.internal.vm.ci/jdk.vm.ci.amd64
34 * jdk.internal.vm.ci/jdk.vm.ci.sparc
35 * @compile CodeInstallationTest.java DebugInfoTest.java TestAssembler.java TestHotSpotVMConfig.java amd64/AMD64TestAssembler.java sparc/SPARCTestAssembler.java
36 * @run junit/othervm -XX:+UnlockExperimentalVMOptions -XX:+EnableJVMCI -XX:-UseJVMCICompiler jdk.vm.ci.code.test.VirtualObjectDebugInfoTest
37 */
38
39 package jdk.vm.ci.code.test;
40
41 import jdk.vm.ci.code.Register;
42 import jdk.vm.ci.code.VirtualObject;
43 import jdk.vm.ci.hotspot.HotSpotConstant;
44 import jdk.vm.ci.meta.JavaConstant;
45 import jdk.vm.ci.meta.JavaKind;
46 import jdk.vm.ci.meta.JavaValue;
47 import jdk.vm.ci.meta.ResolvedJavaField;
48 import jdk.vm.ci.meta.ResolvedJavaType;
49 import org.junit.Assert;
50 import org.junit.Test;
51
52 import java.util.ArrayList;
53 import java.util.Objects;
54
55 public class VirtualObjectDebugInfoTest extends DebugInfoTest {
56
57 private static class TestClass {
58
59 private long longField;
60 private int intField;
61 private float floatField;
62 private Object[] arrayField;
63
64 TestClass() {
65 this.longField = 8472;
66 this.intField = 42;
67 this.floatField = 3.14f;
68 this.arrayField = new Object[]{Integer.valueOf(58), this, null, Integer.valueOf(17), "Hello, World!"};
69 }
70
71 @Override
72 public boolean equals(Object o) {
73 if (!(o instanceof TestClass)) {
74 return false;
75 }
76
77 TestClass other = (TestClass) o;
78 if (this.longField != other.longField || this.intField != other.intField || this.floatField != other.floatField || this.arrayField.length != other.arrayField.length) {
79 return false;
80 }
81
82 for (int i = 0; i < this.arrayField.length; i++) {
83 // break cycle
84 if (this.arrayField[i] == this && other.arrayField[i] == other) {
85 continue;
86 }
87
88 if (!Objects.equals(this.arrayField[i], other.arrayField[i])) {
89 return false;
90 }
91 }
92
93 return true;
94 }
95
96 @Override
97 public int hashCode() {
98 return super.hashCode();
99 }
100 }
101
102 public static TestClass buildObject() {
103 return new TestClass();
104 }
105
106 public static TestClass buildObjectStack() {
107 return new TestClass();
108 }
109
110 boolean storeToStack;
111
112 private VirtualObject[] compileBuildObject(TestAssembler asm, JavaValue[] values) {
113 TestClass template = new TestClass();
114 ArrayList<VirtualObject> vobjs = new ArrayList<>();
115
116 ResolvedJavaType retType = metaAccess.lookupJavaType(TestClass.class);
117 VirtualObject ret = VirtualObject.get(retType, vobjs.size());
118 vobjs.add(ret);
119 values[0] = ret;
120
121 ResolvedJavaType arrayType = metaAccess.lookupJavaType(Object[].class);
122 VirtualObject array = VirtualObject.get(arrayType, vobjs.size());
123 vobjs.add(array);
124
125 // build array for ret.arrayField
126 ResolvedJavaType integerType = metaAccess.lookupJavaType(Integer.class);
127 JavaValue[] arrayContent = new JavaValue[template.arrayField.length];
128 JavaKind[] arrayKind = new JavaKind[template.arrayField.length];
129 for (int i = 0; i < arrayContent.length; i++) {
130 arrayKind[i] = JavaKind.Object;
131 if (template.arrayField[i] == null) {
132 arrayContent[i] = JavaConstant.NULL_POINTER;
133 } else if (template.arrayField[i] == template) {
134 arrayContent[i] = ret;
135 } else if (template.arrayField[i] instanceof Integer) {
136 int value = (Integer) template.arrayField[i];
137 VirtualObject boxed = VirtualObject.get(integerType, vobjs.size());
138 vobjs.add(boxed);
139 arrayContent[i] = boxed;
140 boxed.setValues(new JavaValue[]{JavaConstant.forInt(value)}, new JavaKind[]{JavaKind.Int});
141 } else if (template.arrayField[i] instanceof String) {
142 String value = (String) template.arrayField[i];
143 Register reg = asm.emitLoadPointer((HotSpotConstant) constantReflection.forString(value));
144 if (storeToStack) {
145 arrayContent[i] = asm.emitPointerToStack(reg);
146 } else {
147 arrayContent[i] = reg.asValue(asm.getValueKind(JavaKind.Object));
148 }
149 } else {
150 Assert.fail("unexpected value");
151 }
152 }
153 array.setValues(arrayContent, arrayKind);
154
155 // build return object
156 ResolvedJavaField[] fields = retType.getInstanceFields(true);
157 JavaValue[] retContent = new JavaValue[fields.length];
158 JavaKind[] retKind = new JavaKind[fields.length];
159 for (int i = 0; i < fields.length; i++) {
160 retKind[i] = fields[i].getJavaKind();
161 switch (retKind[i]) {
162 case Long: // template.longField
163 retContent[i] = JavaConstant.forLong(template.longField);
164 break;
165 case Int: // template.intField
166 Register intReg = asm.emitLoadInt(template.intField);
167 retContent[i] = asm.emitIntToStack(intReg);
168 break;
169 case Float: // template.floatField
170 Register fReg = asm.emitLoadFloat(template.floatField);
171 retContent[i] = fReg.asValue(asm.getValueKind(JavaKind.Float));
172 break;
173 case Object: // template.arrayField
174 retContent[i] = array;
175 break;
176 default:
177 Assert.fail("unexpected field");
178 }
179 }
180 ret.setValues(retContent, retKind);
181
182 return vobjs.toArray(new VirtualObject[0]);
183 }
184
185 @Test
186 public void testBuildObject() {
187 storeToStack = false;
188 test(this::compileBuildObject, getMethod("buildObject"), 7, JavaKind.Object);
189 }
190
191 @Test
192 public void testBuildObjectStack() {
193 storeToStack = true;
194 test(this::compileBuildObject, getMethod("buildObjectStack"), 7, JavaKind.Object);
195 }
196 }