1 /*
2 * Copyright (c) 1999, 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. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package java.lang.reflect;
27
28 import jdk.internal.org.objectweb.asm.ClassWriter;
29 import jdk.internal.org.objectweb.asm.Label;
30 import jdk.internal.org.objectweb.asm.MethodVisitor;
31 import jdk.internal.org.objectweb.asm.Opcodes;
32 import sun.security.action.GetBooleanAction;
33
34 import java.io.IOException;
35 import java.lang.invoke.MethodType;
36 import java.nio.file.Files;
37 import java.nio.file.Path;
38 import java.util.ArrayList;
39 import java.util.Arrays;
40 import java.util.HashMap;
41 import java.util.LinkedHashMap;
42 import java.util.LinkedList;
43 import java.util.List;
44 import java.util.ListIterator;
45 import java.util.Map;
46
47 import static jdk.internal.org.objectweb.asm.Opcodes.*;
48
49 /**
50 * ProxyGenerator contains the code to generate a dynamic proxy class
51 * for the java.lang.reflect.Proxy API.
52 * <p>
53 * The external interface to ProxyGenerator is the static
54 * "generateProxyClass" method.
55 */
56 final class ProxyGenerator extends ClassWriter {
57
58 private static final String JL_CLASS = "java/lang/Class";
59 private static final String JL_OBJECT = "java/lang/Object";
60 private static final String JL_THROWABLE = "java/lang/Throwable";
61 private static final String JL_CLASS_NOT_FOUND_EX = "java/lang/ClassNotFoundException";
62 private static final String JL_NO_CLASS_DEF_FOUND_ERROR = "java/lang/NoClassDefFoundError";
63 private static final String JL_NO_SUCH_METHOD_EX = "java/lang/NoSuchMethodException";
64 private static final String JL_NO_SUCH_METHOD_ERROR = "java/lang/NoSuchMethodError";
65
66 private static final String JLR_INVOCATION_HANDLER = "java/lang/reflect/InvocationHandler";
67 private static final String JLR_PROXY = "java/lang/reflect/Proxy";
68 private static final String JLR_UNDECLARED_THROWABLE_EX = "java/lang/reflect/UndeclaredThrowableException";
69
70 private static final String LJL_CLASS = "Ljava/lang/Class;";
71 private static final String LJLR_METHOD = "Ljava/lang/reflect/Method;";
72 private static final String LJLR_INVOCATION_HANDLER = "Ljava/lang/reflect/InvocationHandler;";
73
74 private static final String MJLR_INVOCATIONHANDLER = "(Ljava/lang/reflect/InvocationHandler;)V";
75
76 private static final String NAME_CTOR = "<init>";
77 private static final String NAME_CLINIT = "<clinit>";
78
79 private static final Class<?>[] EMPTY_CLASS_ARRAY = new Class<?>[0];
80
81 /**
82 * name of field for storing a proxy instance's invocation handler
83 */
84 private static final String handlerFieldName = "h";
85
86 /**
87 * debugging flag for saving generated class files
88 */
89 private static final boolean saveGeneratedFiles =
90 java.security.AccessController.doPrivileged(
91 new GetBooleanAction(
92 "jdk.proxy.ProxyGenerator.saveGeneratedFiles"));
93
94 /* Preloaded ProxyMethod objects for methods in java.lang.Object */
95 private final static ProxyMethod hashCodeMethod;
96 private final static ProxyMethod equalsMethod;
97 private final static ProxyMethod toStringMethod;
98
99 static {
100 try {
101 hashCodeMethod = new ProxyMethod(Object.class.getMethod("hashCode"), "m0");
102 equalsMethod = new ProxyMethod(Object.class.getMethod("equals", Object.class), "m1");
103 toStringMethod = new ProxyMethod(Object.class.getMethod("toString"), "m2");
104 } catch (NoSuchMethodException e) {
105 throw new NoSuchMethodError(e.getMessage());
106 }
107 }
108
109 /**
110 * Class loader
111 */
112 private final ClassLoader loader;
113
114 /**
115 * Name of proxy class
116 */
117 private final String className;
118
119 /**
120 * Proxy interfaces
121 */
122 private final List<Class<?>> interfaces;
123
124 /**
125 * Proxy class access flags
126 */
127 private final int accessFlags;
128
129 /**
130 * Maps method signature string to list of ProxyMethod objects for
131 * proxy methods with that signature.
132 * Kept in insertion order to make it easier to compare old and new.
133 */
134 private final Map<String, List<ProxyMethod>> proxyMethods = new LinkedHashMap<>();
135
136 /**
137 * Ordinal of next ProxyMethod object added to proxyMethods.
138 * Indexes are reserved for hashcode(0), equals(1), toString(2).
139 */
140 private int proxyMethodCount = 3;
141
142 /**
143 * Construct a ProxyGenerator to generate a proxy class with the
144 * specified name and for the given interfaces.
145 * <p>
146 * A ProxyGenerator object contains the state for the ongoing
147 * generation of a particular proxy class.
148 */
149 private ProxyGenerator(ClassLoader loader, String className, List<Class<?>> interfaces,
150 int accessFlags) {
151 super(ClassWriter.COMPUTE_FRAMES);
152 this.loader = loader;
153 this.className = className;
154 this.interfaces = interfaces;
155 this.accessFlags = accessFlags;
156 }
157
158 /**
159 * Generate a proxy class given a name and a list of proxy interfaces.
160 *
161 * @param name the class name of the proxy class
162 * @param interfaces proxy interfaces
163 * @param accessFlags access flags of the proxy class
164 */
165 static byte[] generateProxyClass(ClassLoader loader,
166 final String name,
167 List<Class<?>> interfaces,
168 int accessFlags) {
169 ProxyGenerator gen = new ProxyGenerator(loader, name, interfaces, accessFlags);
170 final byte[] classFile = gen.generateClassFile();
171
172 if (saveGeneratedFiles) {
173 java.security.AccessController.doPrivileged(
174 new java.security.PrivilegedAction<Void>() {
175 public Void run() {
176 try {
177 int i = name.lastIndexOf('.');
178 Path path;
179 if (i > 0) {
180 Path dir = Path.of(dotToSlash(name.substring(0, i)));
181 Files.createDirectories(dir);
182 path = dir.resolve(name.substring(i + 1) + ".class");
183 } else {
184 path = Path.of(name + ".class");
185 }
186 Files.write(path, classFile);
187 return null;
188 } catch (IOException e) {
189 throw new InternalError(
190 "I/O exception saving generated file: " + e);
191 }
192 }
193 });
194 }
195
196 return classFile;
197 }
198
199 /**
200 * Return an array of the type names from an array of Classes.
201 *
202 * @param classes an array of classes or interfaces
203 * @return the array of class names; or null if there are no classes
204 */
205 private static String[] typeNames(List<Class<?>> classes) {
206 if (classes == null || classes.size() == 0)
207 return null;
208 int size = classes.size();
209 String[] ifaces = new String[size];
210 for (int i = 0; i < size; i++)
211 ifaces[i] = dotToSlash(classes.get(i).getName());
212 return ifaces;
213 }
214
215 /**
216 * For a given set of proxy methods with the same signature, check
217 * that their return types are compatible according to the Proxy
218 * specification.
219 *
220 * Specifically, if there is more than one such method, then all
221 * of the return types must be reference types, and there must be
222 * one return type that is assignable to each of the rest of them.
223 */
224 private static void checkReturnTypes(List<ProxyMethod> methods) {
225 /*
226 * If there is only one method with a given signature, there
227 * cannot be a conflict. This is the only case in which a
228 * primitive (or void) return type is allowed.
229 */
230 if (methods.size() < 2) {
231 return;
232 }
233
234 /*
235 * List of return types that are not yet known to be
236 * assignable from ("covered" by) any of the others.
237 */
238 LinkedList<Class<?>> uncoveredReturnTypes = new LinkedList<>();
239
240 nextNewReturnType:
241 for (ProxyMethod pm : methods) {
242 Class<?> newReturnType = pm.returnType;
243 if (newReturnType.isPrimitive()) {
244 throw new IllegalArgumentException(
245 "methods with same signature " +
246 pm.shortSignature +
247 " but incompatible return types: " +
248 newReturnType.getName() + " and others");
249 }
250 boolean added = false;
251
252 /*
253 * Compare the new return type to the existing uncovered
254 * return types.
255 */
256 ListIterator<Class<?>> liter = uncoveredReturnTypes.listIterator();
257 while (liter.hasNext()) {
258 Class<?> uncoveredReturnType = liter.next();
259
260 /*
261 * If an existing uncovered return type is assignable
262 * to this new one, then we can forget the new one.
263 */
264 if (newReturnType.isAssignableFrom(uncoveredReturnType)) {
265 assert !added;
266 continue nextNewReturnType;
267 }
268
269 /*
270 * If the new return type is assignable to an existing
271 * uncovered one, then should replace the existing one
272 * with the new one (or just forget the existing one,
273 * if the new one has already be put in the list).
274 */
275 if (uncoveredReturnType.isAssignableFrom(newReturnType)) {
276 // (we can assume that each return type is unique)
277 if (!added) {
278 liter.set(newReturnType);
279 added = true;
280 } else {
281 liter.remove();
282 }
283 }
284 }
285
286 /*
287 * If we got through the list of existing uncovered return
288 * types without an assignability relationship, then add
289 * the new return type to the list of uncovered ones.
290 */
291 if (!added) {
292 uncoveredReturnTypes.add(newReturnType);
293 }
294 }
295
296 /*
297 * We shouldn't end up with more than one return type that is
298 * not assignable from any of the others.
299 */
300 if (uncoveredReturnTypes.size() > 1) {
301 ProxyMethod pm = methods.get(0);
302 throw new IllegalArgumentException(
303 "methods with same signature " +
304 pm.shortSignature +
305 " but incompatible return types: " + uncoveredReturnTypes);
306 }
307 }
308
309 /**
310 * Given the exceptions declared in the throws clause of a proxy method,
311 * compute the exceptions that need to be caught from the invocation
312 * handler's invoke method and rethrown intact in the method's
313 * implementation before catching other Throwables and wrapping them
314 * in UndeclaredThrowableExceptions.
315 *
316 * The exceptions to be caught are returned in a List object. Each
317 * exception in the returned list is guaranteed to not be a subclass of
318 * any of the other exceptions in the list, so the catch blocks for
319 * these exceptions may be generated in any order relative to each other.
320 *
321 * Error and RuntimeException are each always contained by the returned
322 * list (if none of their superclasses are contained), since those
323 * unchecked exceptions should always be rethrown intact, and thus their
324 * subclasses will never appear in the returned list.
325 *
326 * The returned List will be empty if java.lang.Throwable is in the
327 * given list of declared exceptions, indicating that no exceptions
328 * need to be caught.
329 */
330 private static List<Class<?>> computeUniqueCatchList(Class<?>[] exceptions) {
331 List<Class<?>> uniqueList = new ArrayList<>();
332 // unique exceptions to catch
333
334 uniqueList.add(Error.class); // always catch/rethrow these
335 uniqueList.add(RuntimeException.class);
336
337 nextException:
338 for (Class<?> ex : exceptions) {
339 if (ex.isAssignableFrom(Throwable.class)) {
340 /*
341 * If Throwable is declared to be thrown by the proxy method,
342 * then no catch blocks are necessary, because the invoke
343 * can, at most, throw Throwable anyway.
344 */
345 uniqueList.clear();
346 break;
347 } else if (!Throwable.class.isAssignableFrom(ex)) {
348 /*
349 * Ignore types that cannot be thrown by the invoke method.
350 */
351 continue;
352 }
353 /*
354 * Compare this exception against the current list of
355 * exceptions that need to be caught:
356 */
357 for (int j = 0; j < uniqueList.size(); ) {
358 Class<?> ex2 = uniqueList.get(j);
359 if (ex2.isAssignableFrom(ex)) {
360 /*
361 * if a superclass of this exception is already on
362 * the list to catch, then ignore this one and continue;
363 */
364 continue nextException;
365 } else if (ex.isAssignableFrom(ex2)) {
366 /*
367 * if a subclass of this exception is on the list
368 * to catch, then remove it;
369 */
370 uniqueList.remove(j);
371 } else {
372 j++; // else continue comparing.
373 }
374 }
375 // This exception is unique (so far): add it to the list to catch.
376 uniqueList.add(ex);
377 }
378 return uniqueList;
379 }
380
381 /**
382 * Convert a fully qualified class name that uses '.' as the package
383 * separator, the external representation used by the Java language
384 * and APIs, to a fully qualified class name that uses '/' as the
385 * package separator, the representation used in the class file
386 * format (see JVMS section 4.2).
387 */
388 private static String dotToSlash(String name) {
389 return name.replace('.', '/');
390 }
391
392 /**
393 * Return the number of abstract "words", or consecutive local variable
394 * indexes, required to contain a value of the given type. See JVMS
395 * section 3.6.1.
396 * <p>
397 * Note that the original version of the JVMS contained a definition of
398 * this abstract notion of a "word" in section 3.4, but that definition
399 * was removed for the second edition.
400 */
401 private static int getWordsPerType(Class<?> type) {
402 if (type == long.class || type == double.class) {
403 return 2;
404 } else {
405 return 1;
406 }
407 }
408
409 /**
410 * Add to the given list all of the types in the "from" array that
411 * are not already contained in the list and are assignable to at
412 * least one of the types in the "with" array.
413 * <p>
414 * This method is useful for computing the greatest common set of
415 * declared exceptions from duplicate methods inherited from
416 * different interfaces.
417 */
418 private static void collectCompatibleTypes(Class<?>[] from,
419 Class<?>[] with,
420 List<Class<?>> list) {
421 for (Class<?> fc : from) {
422 if (!list.contains(fc)) {
423 for (Class<?> wc : with) {
424 if (wc.isAssignableFrom(fc)) {
425 list.add(fc);
426 break;
427 }
428 }
429 }
430 }
431 }
432
433 /**
434 * Returns the {@link ClassLoader} to be used by the default implementation of {@link
435 * #getCommonSuperClass(String, String)}, that of this {@link ClassWriter}'s runtime type by
436 * default.
437 *
438 * @return ClassLoader
439 */
440 protected ClassLoader getClassLoader() {
441 return loader;
442 }
443
444 /**
445 * Generate a class file for the proxy class. This method drives the
446 * class file generation process.
447 */
448 private byte[] generateClassFile() {
449 visit(V15, accessFlags, dotToSlash(className), null,
450 JLR_PROXY, typeNames(interfaces));
451
452 /*
453 * Add proxy methods for the hashCode, equals,
454 * and toString methods of java.lang.Object. This is done before
455 * the methods from the proxy interfaces so that the methods from
456 * java.lang.Object take precedence over duplicate methods in the
457 * proxy interfaces.
458 */
459 addProxyMethod(hashCodeMethod);
460 addProxyMethod(equalsMethod);
461 addProxyMethod(toStringMethod);
462
463 /*
464 * Accumulate all of the methods from the proxy interfaces.
465 */
466 for (Class<?> intf : interfaces) {
467 for (Method m : intf.getMethods()) {
468 if (!Modifier.isStatic(m.getModifiers())) {
469 addProxyMethod(m, intf);
470 }
471 }
472 }
473
474 /*
475 * For each set of proxy methods with the same signature,
476 * verify that the methods' return types are compatible.
477 */
478 for (List<ProxyMethod> sigmethods : proxyMethods.values()) {
479 checkReturnTypes(sigmethods);
480 }
481
482 generateConstructor();
483
484 for (List<ProxyMethod> sigmethods : proxyMethods.values()) {
485 for (ProxyMethod pm : sigmethods) {
486 // add static field for the Method object
487 visitField(Modifier.PRIVATE | Modifier.STATIC, pm.methodFieldName,
488 LJLR_METHOD, null, null);
489
490 // Generate code for proxy method
491 pm.generateMethod(this, className);
492 }
493 }
494
495 generateStaticInitializer();
496
497 return toByteArray();
498 }
499
500 /**
501 * Add another method to be proxied, either by creating a new
502 * ProxyMethod object or augmenting an old one for a duplicate
503 * method.
504 *
505 * "fromClass" indicates the proxy interface that the method was
506 * found through, which may be different from (a subinterface of)
507 * the method's "declaring class". Note that the first Method
508 * object passed for a given name and descriptor identifies the
509 * Method object (and thus the declaring class) that will be
510 * passed to the invocation handler's "invoke" method for a given
511 * set of duplicate methods.
512 */
513 private void addProxyMethod(Method m, Class<?> fromClass) {
514 Class<?> returnType = m.getReturnType();
515 Class<?>[] exceptionTypes = m.getExceptionTypes();
516
517 String sig = m.toShortSignature();
518 List<ProxyMethod> sigmethods = proxyMethods.computeIfAbsent(sig,
519 (f) -> new ArrayList<>(3));
520 for (ProxyMethod pm : sigmethods) {
521 if (returnType == pm.returnType) {
522 /*
523 * Found a match: reduce exception types to the
524 * greatest set of exceptions that can be thrown
525 * compatibly with the throws clauses of both
526 * overridden methods.
527 */
528 List<Class<?>> legalExceptions = new ArrayList<>();
529 collectCompatibleTypes(
530 exceptionTypes, pm.exceptionTypes, legalExceptions);
531 collectCompatibleTypes(
532 pm.exceptionTypes, exceptionTypes, legalExceptions);
533 pm.exceptionTypes = legalExceptions.toArray(EMPTY_CLASS_ARRAY);
534 return;
535 }
536 }
537 sigmethods.add(new ProxyMethod(m, sig, m.getParameterTypes(), returnType,
538 exceptionTypes, fromClass,
539 "m" + proxyMethodCount++));
540 }
541
542 /**
543 * Add an existing ProxyMethod (hashcode, equals, toString).
544 *
545 * @param pm an existing ProxyMethod
546 */
547 private void addProxyMethod(ProxyMethod pm) {
548 String sig = pm.shortSignature;
549 List<ProxyMethod> sigmethods = proxyMethods.computeIfAbsent(sig,
550 (f) -> new ArrayList<>(3));
551 sigmethods.add(pm);
552 }
553
554 /**
555 * Generate the constructor method for the proxy class.
556 */
557 private void generateConstructor() {
558 MethodVisitor ctor = visitMethod(Modifier.PUBLIC, NAME_CTOR,
559 MJLR_INVOCATIONHANDLER, null, null);
560 ctor.visitParameter(null, 0);
561 ctor.visitCode();
562 ctor.visitVarInsn(ALOAD, 0);
563 ctor.visitVarInsn(ALOAD, 1);
564 ctor.visitMethodInsn(INVOKESPECIAL, JLR_PROXY, NAME_CTOR,
565 MJLR_INVOCATIONHANDLER, false);
566 ctor.visitInsn(RETURN);
567
568 // Maxs computed by ClassWriter.COMPUTE_FRAMES, these arguments ignored
569 ctor.visitMaxs(-1, -1);
570 ctor.visitEnd();
571 }
572
573 /**
574 * Generate the static initializer method for the proxy class.
575 */
576 private void generateStaticInitializer() {
577
578 MethodVisitor mv = visitMethod(Modifier.STATIC, NAME_CLINIT,
579 "()V", null, null);
580 mv.visitCode();
581 Label L_startBlock = new Label();
582 Label L_endBlock = new Label();
583 Label L_NoMethodHandler = new Label();
584 Label L_NoClassHandler = new Label();
585
586 mv.visitTryCatchBlock(L_startBlock, L_endBlock, L_NoMethodHandler,
587 JL_NO_SUCH_METHOD_EX);
588 mv.visitTryCatchBlock(L_startBlock, L_endBlock, L_NoClassHandler,
589 JL_CLASS_NOT_FOUND_EX);
590
591 mv.visitLabel(L_startBlock);
592 for (List<ProxyMethod> sigmethods : proxyMethods.values()) {
593 for (ProxyMethod pm : sigmethods) {
594 pm.codeFieldInitialization(mv, className);
595 }
596 }
597 mv.visitInsn(RETURN);
598 mv.visitLabel(L_endBlock);
599 // Generate exception handler
600
601 mv.visitLabel(L_NoMethodHandler);
602 mv.visitVarInsn(ASTORE, 1);
603 mv.visitTypeInsn(Opcodes.NEW, JL_NO_SUCH_METHOD_ERROR);
604 mv.visitInsn(DUP);
605 mv.visitVarInsn(ALOAD, 1);
606 mv.visitMethodInsn(INVOKEVIRTUAL, JL_THROWABLE,
607 "getMessage", "()Ljava/lang/String;", false);
608 mv.visitMethodInsn(INVOKESPECIAL, JL_NO_SUCH_METHOD_ERROR,
609 "<init>", "(Ljava/lang/String;)V", false);
610 mv.visitInsn(ATHROW);
611
612 mv.visitLabel(L_NoClassHandler);
613 mv.visitVarInsn(ASTORE, 1);
614 mv.visitTypeInsn(Opcodes.NEW, JL_NO_CLASS_DEF_FOUND_ERROR);
615 mv.visitInsn(DUP);
616 mv.visitVarInsn(ALOAD, 1);
617 mv.visitMethodInsn(INVOKEVIRTUAL, JL_THROWABLE,
618 "getMessage", "()Ljava/lang/String;", false);
619 mv.visitMethodInsn(INVOKESPECIAL, JL_NO_CLASS_DEF_FOUND_ERROR,
620 "<init>", "(Ljava/lang/String;)V", false);
621 mv.visitInsn(ATHROW);
622
623 // Maxs computed by ClassWriter.COMPUTE_FRAMES, these arguments ignored
624 mv.visitMaxs(-1, -1);
625 mv.visitEnd();
626 }
627
628 /**
629 * A ProxyMethod object represents a proxy method in the proxy class
630 * being generated: a method whose implementation will encode and
631 * dispatch invocations to the proxy instance's invocation handler.
632 */
633 private static class ProxyMethod {
634
635 private final Method method;
636 private final String shortSignature;
637 private final Class<?> fromClass;
638 private final Class<?>[] parameterTypes;
639 private final Class<?> returnType;
640 private final String methodFieldName;
641 private Class<?>[] exceptionTypes;
642
643 private ProxyMethod(Method method, String sig, Class<?>[] parameterTypes,
644 Class<?> returnType, Class<?>[] exceptionTypes,
645 Class<?> fromClass, String methodFieldName) {
646 this.method = method;
647 this.shortSignature = sig;
648 this.parameterTypes = parameterTypes;
649 this.returnType = returnType;
650 this.exceptionTypes = exceptionTypes;
651 this.fromClass = fromClass;
652 this.methodFieldName = methodFieldName;
653 }
654
655 /**
656 * Create a new specific ProxyMethod with a specific field name
657 *
658 * @param method The method for which to create a proxy
659 * @param methodFieldName the fieldName to generate
660 */
661 private ProxyMethod(Method method, String methodFieldName) {
662 this(method, method.toShortSignature(),
663 method.getParameterTypes(), method.getReturnType(),
664 method.getExceptionTypes(), method.getDeclaringClass(), methodFieldName);
665 }
666
667 /**
668 * Generate this method, including the code and exception table entry.
669 */
670 private void generateMethod(ClassWriter cw, String className) {
671 MethodType mt = MethodType.methodType(returnType, parameterTypes);
672 String desc = mt.toMethodDescriptorString();
673 MethodVisitor mv = cw.visitMethod(ACC_PUBLIC | ACC_FINAL,
674 method.getName(), desc, null,
675 typeNames(Arrays.asList(exceptionTypes)));
676
677 int[] parameterSlot = new int[parameterTypes.length];
678 int nextSlot = 1;
679 for (int i = 0; i < parameterSlot.length; i++) {
680 parameterSlot[i] = nextSlot;
681 nextSlot += getWordsPerType(parameterTypes[i]);
682 }
683
684 mv.visitCode();
685 Label L_startBlock = new Label();
686 Label L_endBlock = new Label();
687 Label L_RuntimeHandler = new Label();
688 Label L_ThrowableHandler = new Label();
689
690 List<Class<?>> catchList = computeUniqueCatchList(exceptionTypes);
691 if (catchList.size() > 0) {
692 for (Class<?> ex : catchList) {
693 mv.visitTryCatchBlock(L_startBlock, L_endBlock, L_RuntimeHandler,
694 dotToSlash(ex.getName()));
695 }
696
697 mv.visitTryCatchBlock(L_startBlock, L_endBlock, L_ThrowableHandler,
698 JL_THROWABLE);
699 }
700 mv.visitLabel(L_startBlock);
701
702 mv.visitVarInsn(ALOAD, 0);
703 mv.visitFieldInsn(GETFIELD, JLR_PROXY, handlerFieldName,
704 LJLR_INVOCATION_HANDLER);
705 mv.visitVarInsn(ALOAD, 0);
706 mv.visitFieldInsn(GETSTATIC, dotToSlash(className), methodFieldName,
707 LJLR_METHOD);
708
709 if (parameterTypes.length > 0) {
710 // Create an array and fill with the parameters converting primitives to wrappers
711 emitIconstInsn(mv, parameterTypes.length);
712 mv.visitTypeInsn(Opcodes.ANEWARRAY, JL_OBJECT);
713 for (int i = 0; i < parameterTypes.length; i++) {
714 mv.visitInsn(DUP);
715 emitIconstInsn(mv, i);
716 codeWrapArgument(mv, parameterTypes[i], parameterSlot[i]);
717 mv.visitInsn(Opcodes.AASTORE);
718 }
719 } else {
720 mv.visitInsn(Opcodes.ACONST_NULL);
721 }
722
723 mv.visitMethodInsn(INVOKEINTERFACE, JLR_INVOCATION_HANDLER,
724 "invoke",
725 "(Ljava/lang/Object;Ljava/lang/reflect/Method;" +
726 "[Ljava/lang/Object;)Ljava/lang/Object;", true);
727
728 if (returnType == void.class) {
729 mv.visitInsn(POP);
730 mv.visitInsn(RETURN);
731 } else {
732 codeUnwrapReturnValue(mv, returnType);
733 }
734
735 mv.visitLabel(L_endBlock);
736
737 // Generate exception handler
738 mv.visitLabel(L_RuntimeHandler);
739 mv.visitInsn(ATHROW); // just rethrow the exception
740
741 mv.visitLabel(L_ThrowableHandler);
742 mv.visitVarInsn(ASTORE, 1);
743 mv.visitTypeInsn(Opcodes.NEW, JLR_UNDECLARED_THROWABLE_EX);
744 mv.visitInsn(DUP);
745 mv.visitVarInsn(ALOAD, 1);
746 mv.visitMethodInsn(INVOKESPECIAL, JLR_UNDECLARED_THROWABLE_EX,
747 "<init>", "(Ljava/lang/Throwable;)V", false);
748 mv.visitInsn(ATHROW);
749 // Maxs computed by ClassWriter.COMPUTE_FRAMES, these arguments ignored
750 mv.visitMaxs(-1, -1);
751 mv.visitEnd();
752 }
753
754 /**
755 * Generate code for wrapping an argument of the given type
756 * whose value can be found at the specified local variable
757 * index, in order for it to be passed (as an Object) to the
758 * invocation handler's "invoke" method.
759 */
760 private void codeWrapArgument(MethodVisitor mv, Class<?> type, int slot) {
761 if (type.isPrimitive()) {
762 PrimitiveTypeInfo prim = PrimitiveTypeInfo.get(type);
763
764 if (type == int.class ||
765 type == boolean.class ||
766 type == byte.class ||
767 type == char.class ||
768 type == short.class) {
769 mv.visitVarInsn(ILOAD, slot);
770 } else if (type == long.class) {
771 mv.visitVarInsn(LLOAD, slot);
772 } else if (type == float.class) {
773 mv.visitVarInsn(FLOAD, slot);
774 } else if (type == double.class) {
775 mv.visitVarInsn(DLOAD, slot);
776 } else {
777 throw new AssertionError();
778 }
779 mv.visitMethodInsn(INVOKESTATIC, prim.wrapperClassName, "valueOf",
780 prim.wrapperValueOfDesc, false);
781 } else {
782 mv.visitVarInsn(ALOAD, slot);
783 }
784 }
785
786 /**
787 * Generate code for unwrapping a return value of the given
788 * type from the invocation handler's "invoke" method (as type
789 * Object) to its correct type.
790 */
791 private void codeUnwrapReturnValue(MethodVisitor mv, Class<?> type) {
792 if (type.isPrimitive()) {
793 PrimitiveTypeInfo prim = PrimitiveTypeInfo.get(type);
794
795 mv.visitTypeInsn(CHECKCAST, prim.wrapperClassName);
796 mv.visitMethodInsn(INVOKEVIRTUAL,
797 prim.wrapperClassName,
798 prim.unwrapMethodName, prim.unwrapMethodDesc, false);
799
800 if (type == int.class ||
801 type == boolean.class ||
802 type == byte.class ||
803 type == char.class ||
804 type == short.class) {
805 mv.visitInsn(IRETURN);
806 } else if (type == long.class) {
807 mv.visitInsn(LRETURN);
808 } else if (type == float.class) {
809 mv.visitInsn(FRETURN);
810 } else if (type == double.class) {
811 mv.visitInsn(DRETURN);
812 } else {
813 throw new AssertionError();
814 }
815 } else {
816 String internalName = dotToSlash(type.getName());
817 if (type.isInlineClass() && !type.isIndirectType()) {
818 internalName = 'Q' + internalName + ";";
819 }
820 mv.visitTypeInsn(CHECKCAST, internalName);
821 mv.visitInsn(ARETURN);
822 }
823 }
824
825 /**
826 * Generate code for initializing the static field that stores
827 * the Method object for this proxy method.
828 */
829 private void codeFieldInitialization(MethodVisitor mv, String className) {
830 codeClassForName(mv, fromClass);
831
832 mv.visitLdcInsn(method.getName());
833
834 emitIconstInsn(mv, parameterTypes.length);
835
836 mv.visitTypeInsn(Opcodes.ANEWARRAY, JL_CLASS);
837
838 // Construct an array with the parameter types mapping primitives to Wrapper types
839 for (int i = 0; i < parameterTypes.length; i++) {
840 mv.visitInsn(DUP);
841 emitIconstInsn(mv, i);
842
843 if (parameterTypes[i].isPrimitive()) {
844 PrimitiveTypeInfo prim =
845 PrimitiveTypeInfo.get(parameterTypes[i]);
846 mv.visitFieldInsn(GETSTATIC,
847 prim.wrapperClassName, "TYPE", LJL_CLASS);
848 } else {
849 codeClassForName(mv, parameterTypes[i]);
850 }
851 mv.visitInsn(Opcodes.AASTORE);
852 }
853 // lookup the method
854 mv.visitMethodInsn(INVOKEVIRTUAL,
855 JL_CLASS,
856 "getMethod",
857 "(Ljava/lang/String;[Ljava/lang/Class;)Ljava/lang/reflect/Method;",
858 false);
859
860 mv.visitFieldInsn(PUTSTATIC,
861 dotToSlash(className),
862 methodFieldName, LJLR_METHOD);
863 }
864
865 /*
866 * =============== Code Generation Utility Methods ===============
867 */
868
869 /**
870 * Generate code to invoke the Class.forName with the name of the given
871 * class to get its Class object at runtime. And also generate code
872 * to invoke Class.asPrimaryType if the class is regular value type.
873 *
874 * The code is written to the supplied stream. Note that the code generated
875 * by this method may caused the checked ClassNotFoundException to be thrown.
876 */
877 private void codeClassForName(MethodVisitor mv, Class<?> cl) {
878 mv.visitLdcInsn(cl.getName());
879 mv.visitMethodInsn(INVOKESTATIC,
880 JL_CLASS,
881 "forName", "(Ljava/lang/String;)Ljava/lang/Class;", false);
882 if (cl.isInlineClass() && cl == cl.asPrimaryType()) {
883 mv.visitMethodInsn(INVOKEVIRTUAL,
884 JL_CLASS,
885 "asPrimaryType", "()Ljava/lang/Class;", false);
886 }
887 }
888
889 /**
890 * Visit a bytecode for a constant.
891 *
892 * @param mv The MethodVisitor
893 * @param cst The constant value
894 */
895 private void emitIconstInsn(MethodVisitor mv, final int cst) {
896 if (cst >= -1 && cst <= 5) {
897 mv.visitInsn(Opcodes.ICONST_0 + cst);
898 } else if (cst >= Byte.MIN_VALUE && cst <= Byte.MAX_VALUE) {
899 mv.visitIntInsn(Opcodes.BIPUSH, cst);
900 } else if (cst >= Short.MIN_VALUE && cst <= Short.MAX_VALUE) {
901 mv.visitIntInsn(Opcodes.SIPUSH, cst);
902 } else {
903 mv.visitLdcInsn(cst);
904 }
905 }
906
907 @Override
908 public String toString() {
909 return method.toShortString();
910 }
911 }
912
913 /**
914 * A PrimitiveTypeInfo object contains assorted information about
915 * a primitive type in its public fields. The struct for a particular
916 * primitive type can be obtained using the static "get" method.
917 */
918 private static class PrimitiveTypeInfo {
919
920 private static Map<Class<?>, PrimitiveTypeInfo> table = new HashMap<>();
921
922 static {
923 add(byte.class, Byte.class);
924 add(char.class, Character.class);
925 add(double.class, Double.class);
926 add(float.class, Float.class);
927 add(int.class, Integer.class);
928 add(long.class, Long.class);
929 add(short.class, Short.class);
930 add(boolean.class, Boolean.class);
931 }
932
933 /**
934 * name of corresponding wrapper class
935 */
936 private String wrapperClassName;
937 /**
938 * method descriptor for wrapper class "valueOf" factory method
939 */
940 private String wrapperValueOfDesc;
941 /**
942 * name of wrapper class method for retrieving primitive value
943 */
944 private String unwrapMethodName;
945 /**
946 * descriptor of same method
947 */
948 private String unwrapMethodDesc;
949
950 private PrimitiveTypeInfo(Class<?> primitiveClass, Class<?> wrapperClass) {
951 assert primitiveClass.isPrimitive();
952
953 /**
954 * "base type" used in various descriptors (see JVMS section 4.3.2)
955 */
956 String baseTypeString =
957 Array.newInstance(primitiveClass, 0)
958 .getClass().getName().substring(1);
959 wrapperClassName = dotToSlash(wrapperClass.getName());
960 wrapperValueOfDesc =
961 "(" + baseTypeString + ")L" + wrapperClassName + ";";
962 unwrapMethodName = primitiveClass.getName() + "Value";
963 unwrapMethodDesc = "()" + baseTypeString;
964 }
965
966 private static void add(Class<?> primitiveClass, Class<?> wrapperClass) {
967 table.put(primitiveClass,
968 new PrimitiveTypeInfo(primitiveClass, wrapperClass));
969 }
970
971 public static PrimitiveTypeInfo get(Class<?> cl) {
972 return table.get(cl);
973 }
974 }
975 }