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