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
25 package org.graalvm.compiler.replacements.test.classfile;
26
27 import static org.graalvm.compiler.bytecode.Bytecodes.ALOAD;
28 import static org.graalvm.compiler.bytecode.Bytecodes.ANEWARRAY;
29 import static org.graalvm.compiler.bytecode.Bytecodes.ASTORE;
30 import static org.graalvm.compiler.bytecode.Bytecodes.BIPUSH;
31 import static org.graalvm.compiler.bytecode.Bytecodes.CHECKCAST;
32 import static org.graalvm.compiler.bytecode.Bytecodes.DLOAD;
33 import static org.graalvm.compiler.bytecode.Bytecodes.DSTORE;
34 import static org.graalvm.compiler.bytecode.Bytecodes.FLOAD;
35 import static org.graalvm.compiler.bytecode.Bytecodes.FSTORE;
36 import static org.graalvm.compiler.bytecode.Bytecodes.GETFIELD;
37 import static org.graalvm.compiler.bytecode.Bytecodes.GETSTATIC;
38 import static org.graalvm.compiler.bytecode.Bytecodes.GOTO;
39 import static org.graalvm.compiler.bytecode.Bytecodes.GOTO_W;
40 import static org.graalvm.compiler.bytecode.Bytecodes.IFEQ;
41 import static org.graalvm.compiler.bytecode.Bytecodes.IFGE;
42 import static org.graalvm.compiler.bytecode.Bytecodes.IFGT;
43 import static org.graalvm.compiler.bytecode.Bytecodes.IFLE;
44 import static org.graalvm.compiler.bytecode.Bytecodes.IFLT;
45 import static org.graalvm.compiler.bytecode.Bytecodes.IFNE;
46 import static org.graalvm.compiler.bytecode.Bytecodes.IFNONNULL;
47 import static org.graalvm.compiler.bytecode.Bytecodes.IFNULL;
48 import static org.graalvm.compiler.bytecode.Bytecodes.IF_ACMPEQ;
49 import static org.graalvm.compiler.bytecode.Bytecodes.IF_ACMPNE;
50 import static org.graalvm.compiler.bytecode.Bytecodes.IF_ICMPEQ;
51 import static org.graalvm.compiler.bytecode.Bytecodes.IF_ICMPGE;
52 import static org.graalvm.compiler.bytecode.Bytecodes.IF_ICMPGT;
53 import static org.graalvm.compiler.bytecode.Bytecodes.IF_ICMPLE;
54 import static org.graalvm.compiler.bytecode.Bytecodes.IF_ICMPLT;
55 import static org.graalvm.compiler.bytecode.Bytecodes.IF_ICMPNE;
56 import static org.graalvm.compiler.bytecode.Bytecodes.ILOAD;
57 import static org.graalvm.compiler.bytecode.Bytecodes.INSTANCEOF;
58 import static org.graalvm.compiler.bytecode.Bytecodes.INVOKEDYNAMIC;
59 import static org.graalvm.compiler.bytecode.Bytecodes.INVOKEINTERFACE;
60 import static org.graalvm.compiler.bytecode.Bytecodes.INVOKESPECIAL;
61 import static org.graalvm.compiler.bytecode.Bytecodes.INVOKESTATIC;
62 import static org.graalvm.compiler.bytecode.Bytecodes.INVOKEVIRTUAL;
63 import static org.graalvm.compiler.bytecode.Bytecodes.ISTORE;
64 import static org.graalvm.compiler.bytecode.Bytecodes.JSR;
65 import static org.graalvm.compiler.bytecode.Bytecodes.JSR_W;
66 import static org.graalvm.compiler.bytecode.Bytecodes.LDC;
67 import static org.graalvm.compiler.bytecode.Bytecodes.LDC2_W;
68 import static org.graalvm.compiler.bytecode.Bytecodes.LDC_W;
69 import static org.graalvm.compiler.bytecode.Bytecodes.LLOAD;
70 import static org.graalvm.compiler.bytecode.Bytecodes.LOOKUPSWITCH;
71 import static org.graalvm.compiler.bytecode.Bytecodes.LSTORE;
72 import static org.graalvm.compiler.bytecode.Bytecodes.MULTIANEWARRAY;
73 import static org.graalvm.compiler.bytecode.Bytecodes.NEW;
74 import static org.graalvm.compiler.bytecode.Bytecodes.NEWARRAY;
75 import static org.graalvm.compiler.bytecode.Bytecodes.PUTFIELD;
76 import static org.graalvm.compiler.bytecode.Bytecodes.PUTSTATIC;
77 import static org.graalvm.compiler.bytecode.Bytecodes.RET;
78 import static org.graalvm.compiler.bytecode.Bytecodes.SIPUSH;
79 import static org.graalvm.compiler.bytecode.Bytecodes.TABLESWITCH;
80
81 import java.io.File;
82 import java.io.IOException;
83 import java.lang.reflect.Executable;
84 import java.lang.reflect.Method;
85 import java.util.Enumeration;
86 import java.util.Formatter;
87 import java.util.zip.ZipEntry;
88 import java.util.zip.ZipFile;
89
90 import org.junit.Assert;
91 import org.junit.Assume;
92 import org.junit.Test;
93
94 import org.graalvm.compiler.api.replacements.SnippetReflectionProvider;
95 import org.graalvm.compiler.api.test.Graal;
96 import org.graalvm.compiler.bytecode.Bytecode;
97 import org.graalvm.compiler.bytecode.BytecodeDisassembler;
98 import org.graalvm.compiler.bytecode.BytecodeLookupSwitch;
99 import org.graalvm.compiler.bytecode.BytecodeStream;
100 import org.graalvm.compiler.bytecode.BytecodeSwitch;
101 import org.graalvm.compiler.bytecode.BytecodeTableSwitch;
102 import org.graalvm.compiler.bytecode.Bytecodes;
103 import org.graalvm.compiler.bytecode.ResolvedJavaMethodBytecode;
104 import org.graalvm.compiler.core.test.GraalCompilerTest;
105 import org.graalvm.compiler.phases.VerifyPhase;
106 import org.graalvm.compiler.phases.util.Providers;
107 import org.graalvm.compiler.replacements.classfile.ClassfileBytecode;
108 import org.graalvm.compiler.replacements.classfile.ClassfileBytecodeProvider;
109 import org.graalvm.compiler.runtime.RuntimeProvider;
110
111 import jdk.vm.ci.meta.ConstantPool;
112 import jdk.vm.ci.meta.JavaField;
113 import jdk.vm.ci.meta.JavaMethodProfile.ProfiledMethod;
114 import jdk.vm.ci.meta.JavaType;
115 import jdk.vm.ci.meta.MetaAccessProvider;
116 import jdk.vm.ci.meta.ResolvedJavaField;
117 import jdk.vm.ci.meta.ResolvedJavaMethod;
118 import jdk.vm.ci.meta.ResolvedJavaType;
119
120 /**
121 * Tests that bytecode exposed via {@link ClassfileBytecode} objects is the same as the bytecode
122 * (modulo minor differences in constant pool resolution) obtained directly from
123 * {@link ResolvedJavaMethod} objects.
124 */
125 public class ClassfileBytecodeProviderTest extends GraalCompilerTest {
126
127 private static boolean shouldProcess(String classpathEntry) {
128 if (classpathEntry.endsWith(".jar")) {
129 String name = new File(classpathEntry).getName();
130 return name.contains("jvmci") || name.contains("graal");
131 }
132 return false;
133 }
134
135 @Test
136 public void test() {
137 RuntimeProvider rt = Graal.getRequiredCapability(RuntimeProvider.class);
138 Providers providers = rt.getHostBackend().getProviders();
139 MetaAccessProvider metaAccess = providers.getMetaAccess();
140
141 Assume.assumeTrue(VerifyPhase.class.desiredAssertionStatus());
142
143 String propertyName = Java8OrEarlier ? "sun.boot.class.path" : "jdk.module.path";
144 String bootclasspath = System.getProperty(propertyName);
145 Assert.assertNotNull("Cannot find value of " + propertyName, bootclasspath);
146
147 for (String path : bootclasspath.split(File.pathSeparator)) {
148 if (shouldProcess(path)) {
149 try {
150 final ZipFile zipFile = new ZipFile(new File(path));
151 for (final Enumeration<? extends ZipEntry> entry = zipFile.entries(); entry.hasMoreElements();) {
152 final ZipEntry zipEntry = entry.nextElement();
153 String name = zipEntry.getName();
154 if (name.endsWith(".class") && !name.equals("module-info.class") && !name.startsWith("META-INF/versions/")) {
155 String className = name.substring(0, name.length() - ".class".length()).replace('/', '.');
156 if (isInNativeImage(className)) {
157 /*
158 * Native image requires non-graalsdk classes to be present in the
159 * classpath.
160 */
161 continue;
162 }
163 try {
164 checkClass(metaAccess, getSnippetReflection(), className);
165 } catch (ClassNotFoundException e) {
166 throw new AssertionError(e);
167 }
168 }
169 }
170 } catch (IOException ex) {
171 Assert.fail(ex.toString());
172 }
173 }
174 }
175 }
176
177 private static boolean isInNativeImage(String className) {
178 return className.startsWith("org.graalvm.nativeimage");
179 }
180
181 protected void checkClass(MetaAccessProvider metaAccess, SnippetReflectionProvider snippetReflection, String className) throws ClassNotFoundException {
182 Class<?> c = Class.forName(className, true, getClass().getClassLoader());
183 ClassfileBytecodeProvider cbp = new ClassfileBytecodeProvider(metaAccess, snippetReflection);
184 for (Method method : c.getDeclaredMethods()) {
185 checkMethod(cbp, metaAccess, method);
186 }
187 }
188
189 private static void checkMethod(ClassfileBytecodeProvider cbp, MetaAccessProvider metaAccess, Executable executable) {
190 ResolvedJavaMethod method = metaAccess.lookupJavaMethod(executable);
191 if (method.hasBytecodes()) {
192 ResolvedJavaMethodBytecode expected = new ResolvedJavaMethodBytecode(method);
193 Bytecode actual = getBytecode(cbp, method);
194 new BytecodeComparer(expected, actual).compare();
195 }
196 }
197
198 protected static Bytecode getBytecode(ClassfileBytecodeProvider cbp, ResolvedJavaMethod method) {
199 try {
200 return cbp.getBytecode(method);
201 } catch (Throwable e) {
202 throw new AssertionError(String.format("Error getting bytecode for %s", method.format("%H.%n(%p)")), e);
203 }
204 }
205
206 static class BytecodeComparer {
207
208 private Bytecode expected;
209 private Bytecode actual;
210 private ConstantPool eCp;
211 private ConstantPool aCp;
212 BytecodeStream eStream;
213 BytecodeStream aStream;
214 int bci = -1;
215
216 BytecodeComparer(Bytecode expected, Bytecode actual) {
217 this.expected = expected;
218 this.actual = actual;
219 this.eCp = expected.getConstantPool();
220 this.aCp = actual.getConstantPool();
221 Assert.assertEquals(expected.getMethod().toString(), expected.getCodeSize(), actual.getCodeSize());
222 this.eStream = new BytecodeStream(expected.getCode());
223 this.aStream = new BytecodeStream(actual.getCode());
224 }
225
226 public void compare() {
227 try {
228 compare0();
229 } catch (Throwable e) {
230 BytecodeDisassembler dis = new BytecodeDisassembler(true, false);
231 Formatter msg = new Formatter();
232 msg.format("Error comparing bytecode for %s", expected.getMethod().format("%H.%n(%p)"));
233 if (bci >= 0) {
234 msg.format("%nexpected: %s", dis.disassemble(expected, bci, eStream.nextBCI() - 1));
235 msg.format("%nactual: %s", dis.disassemble(actual, bci, aStream.nextBCI() - 1));
236 }
237 throw new AssertionError(msg.toString(), e);
238 }
239 }
240
241 public void compare0() {
242 int opcode = eStream.currentBC();
243 ResolvedJavaMethod method = expected.getMethod();
244 while (opcode != Bytecodes.END) {
245 bci = eStream.currentBCI();
246 int actualOpcode = aStream.currentBC();
247 if (opcode != actualOpcode) {
248 Assert.assertEquals(opcode, actualOpcode);
249 }
250 if (eStream.nextBCI() > bci + 1) {
251 switch (opcode) {
252 case BIPUSH:
253 Assert.assertEquals(eStream.readByte(), aStream.readByte());
254 break;
255 case SIPUSH:
256 Assert.assertEquals(eStream.readShort(), aStream.readShort());
257 break;
258 case NEW:
259 case CHECKCAST:
260 case INSTANCEOF:
261 case ANEWARRAY: {
262 ResolvedJavaType e = lookupType(eCp, eStream.readCPI(), opcode);
263 ResolvedJavaType a = lookupType(aCp, aStream.readCPI(), opcode);
264 assertEqualTypes(e, a);
265 break;
266 }
267 case GETSTATIC:
268 case PUTSTATIC:
269 case GETFIELD:
270 case PUTFIELD: {
271 ResolvedJavaField e = lookupField(eCp, eStream.readCPI(), method, opcode);
272 ResolvedJavaField a = lookupField(aCp, aStream.readCPI(), method, opcode);
273 assertEqualFields(e, a);
274 break;
275 }
276 case INVOKEVIRTUAL:
277 case INVOKESPECIAL:
278 case INVOKESTATIC: {
279 ResolvedJavaMethod e = lookupMethod(eCp, eStream.readCPI(), opcode);
280 ResolvedJavaMethod a = lookupMethodOrNull(aCp, aStream.readCPI(), opcode);
281 assertEqualMethods(e, a);
282 break;
283 }
284 case INVOKEINTERFACE: {
285 ResolvedJavaMethod e = lookupMethod(eCp, eStream.readCPI(), opcode);
286 ResolvedJavaMethod a = lookupMethod(aCp, aStream.readCPI(), opcode);
287 assertEqualMethods(e, a);
288 break;
289 }
290 case INVOKEDYNAMIC: {
291 // INVOKEDYNAMIC is not supported by ClassfileBytecodeProvider
292 return;
293 }
294 case LDC:
295 case LDC_W:
296 case LDC2_W: {
297 Object e = lookupConstant(eCp, eStream.readCPI(), opcode);
298 Object a = lookupConstant(aCp, aStream.readCPI(), opcode);
299 assertEqualsConstants(e, a);
300 break;
301 }
302 case RET:
303 case ILOAD:
304 case LLOAD:
305 case FLOAD:
306 case DLOAD:
307 case ALOAD:
308 case ISTORE:
309 case LSTORE:
310 case FSTORE:
311 case DSTORE:
312 case ASTORE: {
313 Assert.assertEquals(eStream.readLocalIndex(), aStream.readLocalIndex());
314 break;
315 }
316 case IFEQ:
317 case IFNE:
318 case IFLT:
319 case IFGE:
320 case IFGT:
321 case IFLE:
322 case IF_ICMPEQ:
323 case IF_ICMPNE:
324 case IF_ICMPLT:
325 case IF_ICMPGE:
326 case IF_ICMPGT:
327 case IF_ICMPLE:
328 case IF_ACMPEQ:
329 case IF_ACMPNE:
330 case GOTO:
331 case JSR:
332 case IFNULL:
333 case IFNONNULL:
334 case GOTO_W:
335 case JSR_W: {
336 Assert.assertEquals(eStream.readBranchDest(), aStream.readBranchDest());
337 break;
338 }
339 case LOOKUPSWITCH:
340 case TABLESWITCH: {
341 BytecodeSwitch e = opcode == LOOKUPSWITCH ? new BytecodeLookupSwitch(eStream, bci) : new BytecodeTableSwitch(eStream, bci);
342 BytecodeSwitch a = opcode == LOOKUPSWITCH ? new BytecodeLookupSwitch(aStream, bci) : new BytecodeTableSwitch(aStream, bci);
343 Assert.assertEquals(e.numberOfCases(), a.numberOfCases());
344 for (int i = 0; i < e.numberOfCases(); i++) {
345 Assert.assertEquals(e.keyAt(i), a.keyAt(i));
346 Assert.assertEquals(e.targetAt(i), a.targetAt(i));
347 }
348 Assert.assertEquals(e.defaultTarget(), a.defaultTarget());
349 Assert.assertEquals(e.defaultOffset(), a.defaultOffset());
350 break;
351 }
352 case NEWARRAY: {
353 Assert.assertEquals(eStream.readLocalIndex(), aStream.readLocalIndex());
354 break;
355 }
356 case MULTIANEWARRAY: {
357 ResolvedJavaType e = lookupType(eCp, eStream.readCPI(), opcode);
358 ResolvedJavaType a = lookupType(aCp, aStream.readCPI(), opcode);
359 Assert.assertEquals(e, a);
360 break;
361 }
362 }
363 }
364 eStream.next();
365 aStream.next();
366 opcode = eStream.currentBC();
367 }
368 }
369
370 static Object lookupConstant(ConstantPool cp, int cpi, int opcode) {
371 cp.loadReferencedType(cpi, opcode);
372 return cp.lookupConstant(cpi);
373 }
374
375 static ResolvedJavaField lookupField(ConstantPool cp, int cpi, ResolvedJavaMethod method, int opcode) {
376 cp.loadReferencedType(cpi, opcode);
377 return (ResolvedJavaField) cp.lookupField(cpi, method, opcode);
378 }
379
380 static ResolvedJavaMethod lookupMethod(ConstantPool cp, int cpi, int opcode) {
381 cp.loadReferencedType(cpi, opcode);
382 return (ResolvedJavaMethod) cp.lookupMethod(cpi, opcode);
383 }
384
385 static ResolvedJavaMethod lookupMethodOrNull(ConstantPool cp, int cpi, int opcode) {
386 try {
387 return lookupMethod(cp, cpi, opcode);
388 } catch (NoSuchMethodError e) {
389 // A method hidden to reflection
390 return null;
391 }
392 }
393
394 static ResolvedJavaType lookupType(ConstantPool cp, int cpi, int opcode) {
395 cp.loadReferencedType(cpi, opcode);
396 return (ResolvedJavaType) cp.lookupType(cpi, opcode);
397 }
398
399 static void assertEqualsConstants(Object e, Object a) {
400 if (!e.equals(a)) {
401 Assert.assertEquals(String.valueOf(e), String.valueOf(a));
402 }
403 }
404
405 static void assertEqualFields(JavaField e, JavaField a) {
406 if (!e.equals(a)) {
407 Assert.assertEquals(e.format("%H.%n %T"), a.format("%H.%n %T"));
408 }
409 }
410
411 static void assertEqualTypes(JavaType e, JavaType a) {
412 if (!e.equals(a)) {
413 Assert.assertEquals(e.toJavaName(), a.toJavaName());
414 }
415 }
416
417 static void assertEqualMethods(ResolvedJavaMethod e, ResolvedJavaMethod a) {
418 if (a != null) {
419 if (!e.equals(a)) {
420 if (!e.equals(a)) {
421 if (!e.getDeclaringClass().equals(a.getDeclaringClass())) {
422
423 if (!typesAreRelated(e, a)) {
424 throw new AssertionError(String.format("%s and %s are unrelated", a.getDeclaringClass().toJavaName(), e.getDeclaringClass().toJavaName()));
425 }
426 }
427 Assert.assertEquals(e.getName(), a.getName());
428 Assert.assertEquals(e.getSignature(), a.getSignature());
429 } else {
430 Assert.assertEquals(e, a);
431 }
432 }
433 }
434 }
435
436 /**
437 * The VM can resolve references to methods not available via reflection. For example, the
438 * javap output for {@link ProfiledMethod#toString()} includes:
439 *
440 * <pre>
441 * 16: invokeinterface #40, 1 // InterfaceMethod jdk/vm/ci/meta/ResolvedJavaMethod.getName:()Ljava/lang/String;
442 * </pre>
443 *
444 * When resolving via {@code HotSpotConstantPool}, we get:
445 *
446 * <pre>
447 * 16: invokeinterface#4, 1 // jdk.vm.ci.meta.ResolvedJavaMethod.getName:()java.lang.String
448 * </pre>
449 *
450 * However resolving via {@code ClassfileConstantPool}, we get:
451 *
452 * <pre>
453 * 16: invokeinterface#40, 1 // jdk.vm.ci.meta.JavaMethod.getName:()java.lang.String
454 * </pre>
455 *
456 * since the latter relies on {@link ResolvedJavaType#getDeclaredMethods()} which only
457 * returns methods originating from class files.
458 *
459 * We accept such differences for the purpose of this test if the declaring class of two
460 * otherwise similar methods are related (i.e. one is a subclass of the other).
461 */
462 protected static boolean typesAreRelated(ResolvedJavaMethod e, ResolvedJavaMethod a) {
463 return a.getDeclaringClass().isAssignableFrom(e.getDeclaringClass()) || e.getDeclaringClass().isAssignableFrom(a.getDeclaringClass());
464 }
465 }
466 }