1 /* 2 * Copyright (c) 1999, 2024, 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 java.io.IOException; 29 import java.lang.classfile.*; 30 import java.lang.classfile.attribute.ExceptionsAttribute; 31 import java.lang.classfile.constantpool.*; 32 import java.lang.constant.ClassDesc; 33 import java.lang.constant.MethodTypeDesc; 34 import java.nio.file.Files; 35 import java.nio.file.Path; 36 import java.util.ArrayList; 37 import java.util.LinkedHashMap; 38 import java.util.List; 39 import java.util.ListIterator; 40 import java.util.Map; 41 import java.util.Objects; 42 import jdk.internal.constant.ConstantUtils; 43 import jdk.internal.constant.MethodTypeDescImpl; 44 import jdk.internal.constant.ReferenceClassDescImpl; 45 import sun.security.action.GetBooleanAction; 46 47 import static java.lang.classfile.ClassFile.*; 48 import java.lang.classfile.attribute.StackMapFrameInfo; 49 import java.lang.classfile.attribute.StackMapTableAttribute; 50 51 import static java.lang.constant.ConstantDescs.*; 52 import static jdk.internal.constant.ConstantUtils.*; 53 54 /** 55 * ProxyGenerator contains the code to generate a dynamic proxy class 56 * for the java.lang.reflect.Proxy API. 57 * <p> 58 * The external interface to ProxyGenerator is the static 59 * "generateProxyClass" method. 60 */ 61 final class ProxyGenerator { 62 63 private static final ClassFile CF_CONTEXT = 64 ClassFile.of(ClassFile.StackMapsOption.DROP_STACK_MAPS); 65 66 private static final ClassDesc 67 CD_ClassLoader = ReferenceClassDescImpl.ofValidated("Ljava/lang/ClassLoader;"), 68 CD_Class_array = ReferenceClassDescImpl.ofValidated("[Ljava/lang/Class;"), 69 CD_ClassNotFoundException = ReferenceClassDescImpl.ofValidated("Ljava/lang/ClassNotFoundException;"), 70 CD_NoClassDefFoundError = ReferenceClassDescImpl.ofValidated("Ljava/lang/NoClassDefFoundError;"), 71 CD_IllegalAccessException = ReferenceClassDescImpl.ofValidated("Ljava/lang/IllegalAccessException;"), 72 CD_InvocationHandler = ReferenceClassDescImpl.ofValidated("Ljava/lang/reflect/InvocationHandler;"), 73 CD_Method = ReferenceClassDescImpl.ofValidated("Ljava/lang/reflect/Method;"), 74 CD_NoSuchMethodError = ReferenceClassDescImpl.ofValidated("Ljava/lang/NoSuchMethodError;"), 75 CD_NoSuchMethodException = ReferenceClassDescImpl.ofValidated("Ljava/lang/NoSuchMethodException;"), 76 CD_Object_array = ReferenceClassDescImpl.ofValidated("[Ljava/lang/Object;"), 77 CD_Proxy = ReferenceClassDescImpl.ofValidated("Ljava/lang/reflect/Proxy;"), 78 CD_UndeclaredThrowableException = ReferenceClassDescImpl.ofValidated("Ljava/lang/reflect/UndeclaredThrowableException;"); 79 80 private static final MethodTypeDesc 81 MTD_boolean = MethodTypeDescImpl.ofValidated(CD_boolean), 82 MTD_void_InvocationHandler = MethodTypeDescImpl.ofValidated(CD_void, CD_InvocationHandler), 83 MTD_void_String = MethodTypeDescImpl.ofValidated(CD_void, CD_String), 84 MTD_void_Throwable = MethodTypeDescImpl.ofValidated(CD_void, CD_Throwable), 85 MTD_Class = MethodTypeDescImpl.ofValidated(CD_Class), 86 MTD_Class_String_boolean_ClassLoader = MethodTypeDescImpl.ofValidated(CD_Class, CD_String, CD_boolean, CD_ClassLoader), 87 MTD_ClassLoader = MethodTypeDescImpl.ofValidated(CD_ClassLoader), 88 MTD_Method_String_Class_array = MethodTypeDescImpl.ofValidated(CD_Method, CD_String, CD_Class_array), 89 MTD_MethodHandles$Lookup = MethodTypeDescImpl.ofValidated(CD_MethodHandles_Lookup), 90 MTD_MethodHandles$Lookup_MethodHandles$Lookup = MethodTypeDescImpl.ofValidated(CD_MethodHandles_Lookup, CD_MethodHandles_Lookup), 91 MTD_Object_Object_Method_ObjectArray = MethodTypeDescImpl.ofValidated(CD_Object, CD_Object, CD_Method, CD_Object_array), 92 MTD_String = MethodTypeDescImpl.ofValidated(CD_String); 93 94 private static final String NAME_LOOKUP_ACCESSOR = "proxyClassLookup"; 95 96 private static final Class<?>[] EMPTY_CLASS_ARRAY = new Class<?>[0]; 97 98 /** 99 * name of field for storing a proxy instance's invocation handler 100 */ 101 private static final String NAME_HANDLER_FIELD = "h"; 102 103 /** 104 * debugging flag for saving generated class files 105 */ 106 @SuppressWarnings("removal") 107 private static final boolean SAVE_GENERATED_FILES = 108 java.security.AccessController.doPrivileged( 109 new GetBooleanAction( 110 "jdk.proxy.ProxyGenerator.saveGeneratedFiles")); 111 112 /* Preloaded ProxyMethod objects for methods in java.lang.Object */ 113 private static final Method OBJECT_HASH_CODE_METHOD; 114 private static final Method OBJECT_EQUALS_METHOD; 115 private static final Method OBJECT_TO_STRING_METHOD; 116 117 private static final String OBJECT_HASH_CODE_SIG; 118 private static final String OBJECT_EQUALS_SIG; 119 private static final String OBJECT_TO_STRING_SIG; 120 121 static { 122 try { 123 OBJECT_HASH_CODE_METHOD = Object.class.getMethod("hashCode"); 124 OBJECT_HASH_CODE_SIG = OBJECT_HASH_CODE_METHOD.toShortSignature(); 125 OBJECT_EQUALS_METHOD = Object.class.getMethod("equals", Object.class); 126 OBJECT_EQUALS_SIG = OBJECT_EQUALS_METHOD.toShortSignature(); 127 OBJECT_TO_STRING_METHOD = Object.class.getMethod("toString"); 128 OBJECT_TO_STRING_SIG = OBJECT_TO_STRING_METHOD.toShortSignature(); 129 } catch (NoSuchMethodException e) { 130 throw new NoSuchMethodError(e.getMessage()); 131 } 132 } 133 134 private final ConstantPoolBuilder cp; 135 private final List<StackMapFrameInfo.VerificationTypeInfo> classLoaderLocal, throwableStack; 136 private final NameAndTypeEntry exInit; 137 private final ClassEntry objectCE, proxyCE, uteCE, classCE; 138 private final FieldRefEntry handlerField; 139 private final InterfaceMethodRefEntry invocationHandlerInvoke; 140 private final MethodRefEntry uteInit, classGetMethod, classForName, throwableGetMessage; 141 142 143 /** 144 * ClassEntry for this proxy class 145 */ 146 private final ClassEntry thisClassCE; 147 148 /** 149 * Proxy interfaces 150 */ 151 private final List<Class<?>> interfaces; 152 153 /** 154 * Proxy class access flags 155 */ 156 private final int accessFlags; 157 158 /** 159 * Maps method signature string to list of ProxyMethod objects for 160 * proxy methods with that signature. 161 * Kept in insertion order to make it easier to compare old and new. 162 */ 163 private final Map<String, List<ProxyMethod>> proxyMethods = new LinkedHashMap<>(); 164 165 /** 166 * Ordinal of next ProxyMethod object added to proxyMethods. 167 * Indexes are reserved for hashcode(0), equals(1), toString(2). 168 */ 169 private int proxyMethodCount = 3; 170 171 /** 172 * Construct a ProxyGenerator to generate a proxy class with the 173 * specified name and for the given interfaces. 174 * <p> 175 * A ProxyGenerator object contains the state for the ongoing 176 * generation of a particular proxy class. 177 */ 178 private ProxyGenerator(String className, List<Class<?>> interfaces, 179 int accessFlags) { 180 this.cp = ConstantPoolBuilder.of(); 181 this.thisClassCE = cp.classEntry(ConstantUtils.binaryNameToDesc(className)); 182 this.interfaces = interfaces; 183 this.accessFlags = accessFlags; 184 var throwable = cp.classEntry(CD_Throwable); 185 this.classLoaderLocal = List.of(StackMapFrameInfo.ObjectVerificationTypeInfo.of(cp.classEntry(CD_ClassLoader))); 186 this.throwableStack = List.of(StackMapFrameInfo.ObjectVerificationTypeInfo.of(throwable)); 187 this.exInit = cp.nameAndTypeEntry(INIT_NAME, MTD_void_String); 188 this.objectCE = cp.classEntry(CD_Object); 189 this.proxyCE = cp.classEntry(CD_Proxy); 190 this.classCE = cp.classEntry(CD_Class); 191 this.handlerField = cp.fieldRefEntry(proxyCE, cp.nameAndTypeEntry(NAME_HANDLER_FIELD, CD_InvocationHandler)); 192 this.invocationHandlerInvoke = cp.interfaceMethodRefEntry(CD_InvocationHandler, "invoke", MTD_Object_Object_Method_ObjectArray); 193 this.uteCE = cp.classEntry(CD_UndeclaredThrowableException); 194 this.uteInit = cp.methodRefEntry(uteCE, cp.nameAndTypeEntry(INIT_NAME, MTD_void_Throwable)); 195 this.classGetMethod = cp.methodRefEntry(classCE, cp.nameAndTypeEntry("getMethod", MTD_Method_String_Class_array)); 196 this.classForName = cp.methodRefEntry(classCE, cp.nameAndTypeEntry("forName", MTD_Class_String_boolean_ClassLoader)); 197 this.throwableGetMessage = cp.methodRefEntry(throwable, cp.nameAndTypeEntry("getMessage", MTD_String)); 198 } 199 200 /** 201 * Generate a proxy class given a name and a list of proxy interfaces. 202 * 203 * @param name the class name of the proxy class 204 * @param interfaces proxy interfaces 205 * @param accessFlags access flags of the proxy class 206 */ 207 @SuppressWarnings("removal") 208 static byte[] generateProxyClass(ClassLoader loader, 209 final String name, 210 List<Class<?>> interfaces, 211 int accessFlags) { 212 Objects.requireNonNull(interfaces); 213 ProxyGenerator gen = new ProxyGenerator(name, interfaces, accessFlags); 214 final byte[] classFile = gen.generateClassFile(); 215 216 if (SAVE_GENERATED_FILES) { 217 java.security.AccessController.doPrivileged( 218 new java.security.PrivilegedAction<Void>() { 219 public Void run() { 220 try { 221 int i = name.lastIndexOf('.'); 222 Path path; 223 if (i > 0) { 224 Path dir = Path.of(name.substring(0, i).replace('.', '/')); 225 Files.createDirectories(dir); 226 path = dir.resolve(name.substring(i + 1) + ".class"); 227 } else { 228 path = Path.of(name + ".class"); 229 } 230 Files.write(path, classFile); 231 return null; 232 } catch (IOException e) { 233 throw new InternalError( 234 "I/O exception saving generated file: " + e); 235 } 236 } 237 }); 238 } 239 240 return classFile; 241 } 242 243 /** 244 * {@return the entries of the given type} 245 * @param types the {@code Class} objects, not primitive types nor array types 246 */ 247 private static List<ClassEntry> toClassEntries(ConstantPoolBuilder cp, List<Class<?>> types) { 248 var ces = new ArrayList<ClassEntry>(types.size()); 249 for (var t : types) 250 ces.add(cp.classEntry(ConstantUtils.binaryNameToDesc(t.getName()))); 251 return ces; 252 } 253 254 /** 255 * For a given set of proxy methods with the same signature, check 256 * that their return types are compatible according to the Proxy 257 * specification. 258 * 259 * Specifically, if there is more than one such method, then all 260 * of the return types must be reference types, and there must be 261 * one return type that is assignable to each of the rest of them. 262 */ 263 private static void checkReturnTypes(List<ProxyMethod> methods) { 264 /* 265 * If there is only one method with a given signature, there 266 * cannot be a conflict. This is the only case in which a 267 * primitive (or void) return type is allowed. 268 */ 269 if (methods.size() < 2) { 270 return; 271 } 272 273 /* 274 * List of return types that are not yet known to be 275 * assignable from ("covered" by) any of the others. 276 */ 277 List<Class<?>> uncoveredReturnTypes = new ArrayList<>(1); 278 279 nextNewReturnType: 280 for (ProxyMethod pm : methods) { 281 Class<?> newReturnType = pm.returnType; 282 if (newReturnType.isPrimitive()) { 283 throw new IllegalArgumentException( 284 "methods with same signature " + 285 pm.shortSignature + 286 " but incompatible return types: " + 287 newReturnType.getName() + " and others"); 288 } 289 boolean added = false; 290 291 /* 292 * Compare the new return type to the existing uncovered 293 * return types. 294 */ 295 ListIterator<Class<?>> liter = uncoveredReturnTypes.listIterator(); 296 while (liter.hasNext()) { 297 Class<?> uncoveredReturnType = liter.next(); 298 299 /* 300 * If an existing uncovered return type is assignable 301 * to this new one, then we can forget the new one. 302 */ 303 if (newReturnType.isAssignableFrom(uncoveredReturnType)) { 304 assert !added; 305 continue nextNewReturnType; 306 } 307 308 /* 309 * If the new return type is assignable to an existing 310 * uncovered one, then should replace the existing one 311 * with the new one (or just forget the existing one, 312 * if the new one has already be put in the list). 313 */ 314 if (uncoveredReturnType.isAssignableFrom(newReturnType)) { 315 // (we can assume that each return type is unique) 316 if (!added) { 317 liter.set(newReturnType); 318 added = true; 319 } else { 320 liter.remove(); 321 } 322 } 323 } 324 325 /* 326 * If we got through the list of existing uncovered return 327 * types without an assignability relationship, then add 328 * the new return type to the list of uncovered ones. 329 */ 330 if (!added) { 331 uncoveredReturnTypes.add(newReturnType); 332 } 333 } 334 335 /* 336 * We shouldn't end up with more than one return type that is 337 * not assignable from any of the others. 338 */ 339 if (uncoveredReturnTypes.size() > 1) { 340 ProxyMethod pm = methods.getFirst(); 341 throw new IllegalArgumentException( 342 "methods with same signature " + 343 pm.shortSignature + 344 " but incompatible return types: " + uncoveredReturnTypes); 345 } 346 } 347 348 /** 349 * Given the exceptions declared in the throws clause of a proxy method, 350 * compute the exceptions that need to be caught from the invocation 351 * handler's invoke method and rethrown intact in the method's 352 * implementation before catching other Throwables and wrapping them 353 * in UndeclaredThrowableExceptions. 354 * 355 * The exceptions to be caught are returned in a List object. Each 356 * exception in the returned list is guaranteed to not be a subclass of 357 * any of the other exceptions in the list, so the catch blocks for 358 * these exceptions may be generated in any order relative to each other. 359 * 360 * Error and RuntimeException are each always contained by the returned 361 * list (if none of their superclasses are contained), since those 362 * unchecked exceptions should always be rethrown intact, and thus their 363 * subclasses will never appear in the returned list. 364 * 365 * The returned List will be empty if java.lang.Throwable is in the 366 * given list of declared exceptions, indicating that no exceptions 367 * need to be caught. 368 */ 369 private static List<Class<?>> computeUniqueCatchList(Class<?>[] exceptions) { 370 List<Class<?>> uniqueList = new ArrayList<>(); 371 // unique exceptions to catch 372 373 uniqueList.add(Error.class); // always catch/rethrow these 374 uniqueList.add(RuntimeException.class); 375 376 nextException: 377 for (Class<?> ex : exceptions) { 378 if (ex.isAssignableFrom(Throwable.class)) { 379 /* 380 * If Throwable is declared to be thrown by the proxy method, 381 * then no catch blocks are necessary, because the invoke 382 * can, at most, throw Throwable anyway. 383 */ 384 uniqueList.clear(); 385 break; 386 } else if (!Throwable.class.isAssignableFrom(ex)) { 387 /* 388 * Ignore types that cannot be thrown by the invoke method. 389 */ 390 continue; 391 } 392 /* 393 * Compare this exception against the current list of 394 * exceptions that need to be caught: 395 */ 396 for (int j = 0; j < uniqueList.size(); ) { 397 Class<?> ex2 = uniqueList.get(j); 398 if (ex2.isAssignableFrom(ex)) { 399 /* 400 * if a superclass of this exception is already on 401 * the list to catch, then ignore this one and continue; 402 */ 403 continue nextException; 404 } else if (ex.isAssignableFrom(ex2)) { 405 /* 406 * if a subclass of this exception is on the list 407 * to catch, then remove it; 408 */ 409 uniqueList.remove(j); 410 } else { 411 j++; // else continue comparing. 412 } 413 } 414 // This exception is unique (so far): add it to the list to catch. 415 uniqueList.add(ex); 416 } 417 return uniqueList; 418 } 419 420 /** 421 * Add to the given list all of the types in the "from" array that 422 * are not already contained in the list and are assignable to at 423 * least one of the types in the "with" array. 424 * <p> 425 * This method is useful for computing the greatest common set of 426 * declared exceptions from duplicate methods inherited from 427 * different interfaces. 428 */ 429 private static void collectCompatibleTypes(Class<?>[] from, 430 Class<?>[] with, 431 List<Class<?>> list) { 432 for (Class<?> fc : from) { 433 if (!list.contains(fc)) { 434 for (Class<?> wc : with) { 435 if (wc.isAssignableFrom(fc)) { 436 list.add(fc); 437 break; 438 } 439 } 440 } 441 } 442 } 443 444 /** 445 * Generate a class file for the proxy class. This method drives the 446 * class file generation process. 447 * 448 * If a proxy interface references any value classes, the value classes 449 * are listed in the loadable descriptors attribute of the interface class. The 450 * classes that are referenced by the proxy interface have already 451 * been loaded before the proxy class. Hence the proxy class is 452 * generated with no loadable descriptors attributes as it essentially has no effect. 453 */ 454 private byte[] generateClassFile() { 455 /* 456 * Add proxy methods for the hashCode, equals, 457 * and toString methods of java.lang.Object. This is done before 458 * the methods from the proxy interfaces so that the methods from 459 * java.lang.Object take precedence over duplicate methods in the 460 * proxy interfaces. 461 */ 462 addProxyMethod(new ProxyMethod(OBJECT_HASH_CODE_METHOD, OBJECT_HASH_CODE_SIG, "m0")); 463 addProxyMethod(new ProxyMethod(OBJECT_EQUALS_METHOD, OBJECT_EQUALS_SIG, "m1")); 464 addProxyMethod(new ProxyMethod(OBJECT_TO_STRING_METHOD, OBJECT_TO_STRING_SIG, "m2")); 465 466 /* 467 * Accumulate all of the methods from the proxy interfaces. 468 */ 469 for (Class<?> intf : interfaces) { 470 for (Method m : intf.getMethods()) { 471 if (!Modifier.isStatic(m.getModifiers())) { 472 addProxyMethod(m, intf); 473 } 474 } 475 } 476 477 /* 478 * For each set of proxy methods with the same signature, 479 * verify that the methods' return types are compatible. 480 */ 481 for (List<ProxyMethod> sigmethods : proxyMethods.values()) { 482 checkReturnTypes(sigmethods); 483 } 484 485 return CF_CONTEXT.build(thisClassCE, cp, clb -> { 486 clb.withSuperclass(proxyCE); 487 clb.withFlags(accessFlags); 488 clb.withInterfaces(toClassEntries(cp, interfaces)); 489 generateConstructor(clb); 490 491 for (List<ProxyMethod> sigmethods : proxyMethods.values()) { 492 for (ProxyMethod pm : sigmethods) { 493 // add static field for the Method object 494 clb.withField(pm.methodFieldName, CD_Method, ACC_PRIVATE | ACC_STATIC | ACC_FINAL); 495 496 // Generate code for proxy method 497 pm.generateMethod(clb); 498 } 499 } 500 501 generateStaticInitializer(clb); 502 generateLookupAccessor(clb); 503 }); 504 } 505 506 /** 507 * Add another method to be proxied, either by creating a new 508 * ProxyMethod object or augmenting an old one for a duplicate 509 * method. 510 * 511 * "fromClass" indicates the proxy interface that the method was 512 * found through, which may be different from (a subinterface of) 513 * the method's "declaring class". Note that the first Method 514 * object passed for a given name and descriptor identifies the 515 * Method object (and thus the declaring class) that will be 516 * passed to the invocation handler's "invoke" method for a given 517 * set of duplicate methods. 518 */ 519 private void addProxyMethod(Method m, Class<?> fromClass) { 520 Class<?> returnType = m.getReturnType(); 521 Class<?>[] exceptionTypes = m.getSharedExceptionTypes(); 522 523 String sig = m.toShortSignature(); 524 List<ProxyMethod> sigmethods = proxyMethodsFor(sig); 525 for (ProxyMethod pm : sigmethods) { 526 if (returnType == pm.returnType) { 527 /* 528 * Found a match: reduce exception types to the 529 * greatest set of exceptions that can be thrown 530 * compatibly with the throws clauses of both 531 * overridden methods. 532 */ 533 List<Class<?>> legalExceptions = new ArrayList<>(); 534 collectCompatibleTypes( 535 exceptionTypes, pm.exceptionTypes, legalExceptions); 536 collectCompatibleTypes( 537 pm.exceptionTypes, exceptionTypes, legalExceptions); 538 pm.exceptionTypes = legalExceptions.toArray(EMPTY_CLASS_ARRAY); 539 return; 540 } 541 } 542 sigmethods.add(new ProxyMethod(m, sig, returnType, 543 exceptionTypes, fromClass, "m" + proxyMethodCount++)); 544 } 545 546 private List<ProxyMethod> proxyMethodsFor(String sig) { 547 return proxyMethods.computeIfAbsent(sig, _ -> new ArrayList<>(3)); 548 } 549 550 /** 551 * Add an existing ProxyMethod (hashcode, equals, toString). 552 * 553 * @param pm an existing ProxyMethod 554 */ 555 private void addProxyMethod(ProxyMethod pm) { 556 proxyMethodsFor(pm.shortSignature).add(pm); 557 } 558 559 /** 560 * Generate the constructor method for the proxy class. 561 */ 562 private void generateConstructor(ClassBuilder clb) { 563 clb.withMethodBody(INIT_NAME, MTD_void_InvocationHandler, ACC_PUBLIC, cob -> cob 564 .aload(0) 565 .aload(1) 566 .invokespecial(cp.methodRefEntry(proxyCE, 567 cp.nameAndTypeEntry(INIT_NAME, MTD_void_InvocationHandler))) 568 .return_()); 569 } 570 571 /** 572 * Generate the class initializer. 573 * Discussion: Currently, for Proxy to work with SecurityManager, 574 * we rely on the parameter classes of the methods to be computed 575 * from Proxy instead of via user code paths like bootstrap method 576 * lazy evaluation. That might change if we can pass in the live 577 * Method objects directly.. 578 */ 579 private void generateStaticInitializer(ClassBuilder clb) { 580 clb.withMethodBody(CLASS_INIT_NAME, MTD_void, ACC_STATIC, cob -> { 581 // Put ClassLoader at local variable index 0, used by 582 // Class.forName(String, boolean, ClassLoader) calls 583 cob.ldc(thisClassCE) 584 .invokevirtual(cp.methodRefEntry(classCE, 585 cp.nameAndTypeEntry("getClassLoader", MTD_ClassLoader))) 586 .astore(0); 587 var ts = cob.newBoundLabel(); 588 for (List<ProxyMethod> sigmethods : proxyMethods.values()) { 589 for (ProxyMethod pm : sigmethods) { 590 pm.codeFieldInitialization(cob); 591 } 592 } 593 cob.return_(); 594 var c1 = cob.newBoundLabel(); 595 var nsmError = cp.classEntry(CD_NoSuchMethodError); 596 cob.exceptionCatch(ts, c1, c1, CD_NoSuchMethodException) 597 .new_(nsmError) 598 .dup_x1() 599 .swap() 600 .invokevirtual(throwableGetMessage) 601 .invokespecial(cp.methodRefEntry(nsmError, exInit)) 602 .athrow(); 603 var c2 = cob.newBoundLabel(); 604 var ncdfError = cp.classEntry(CD_NoClassDefFoundError); 605 cob.exceptionCatch(ts, c1, c2, CD_ClassNotFoundException) 606 .new_(ncdfError) 607 .dup_x1() 608 .swap() 609 .invokevirtual(throwableGetMessage) 610 .invokespecial(cp.methodRefEntry(ncdfError, exInit)) 611 .athrow(); 612 cob.with(StackMapTableAttribute.of(List.of( 613 StackMapFrameInfo.of(c1, classLoaderLocal, throwableStack), 614 StackMapFrameInfo.of(c2, classLoaderLocal, throwableStack)))); 615 616 }); 617 } 618 619 /** 620 * Generate the static lookup accessor method that returns the Lookup 621 * on this proxy class if the caller's lookup class is java.lang.reflect.Proxy; 622 * otherwise, IllegalAccessException is thrown 623 */ 624 private void generateLookupAccessor(ClassBuilder clb) { 625 clb.withMethod(NAME_LOOKUP_ACCESSOR, 626 MTD_MethodHandles$Lookup_MethodHandles$Lookup, 627 ACC_PRIVATE | ACC_STATIC, 628 mb -> mb.with(ExceptionsAttribute.of(List.of(mb.constantPool().classEntry(CD_IllegalAccessException)))) 629 .withCode(cob -> { 630 Label failLabel = cob.newLabel(); 631 ClassEntry mhl = cp.classEntry(CD_MethodHandles_Lookup); 632 ClassEntry iae = cp.classEntry(CD_IllegalAccessException); 633 cob.aload(0) 634 .invokevirtual(cp.methodRefEntry(mhl, cp.nameAndTypeEntry("lookupClass", MTD_Class))) 635 .ldc(proxyCE) 636 .if_acmpne(failLabel) 637 .aload(0) 638 .invokevirtual(cp.methodRefEntry(mhl, cp.nameAndTypeEntry("hasFullPrivilegeAccess", MTD_boolean))) 639 .ifeq(failLabel) 640 .invokestatic(CD_MethodHandles, "lookup", MTD_MethodHandles$Lookup) 641 .areturn() 642 .labelBinding(failLabel) 643 .new_(iae) 644 .dup() 645 .aload(0) 646 .invokevirtual(cp.methodRefEntry(mhl, cp.nameAndTypeEntry("toString", MTD_String))) 647 .invokespecial(cp.methodRefEntry(iae, exInit)) 648 .athrow() 649 .with(StackMapTableAttribute.of(List.of( 650 StackMapFrameInfo.of(failLabel, 651 List.of(StackMapFrameInfo.ObjectVerificationTypeInfo.of(mhl)), 652 List.of())))); 653 })); 654 } 655 656 /** 657 * A ProxyMethod object represents a proxy method in the proxy class 658 * being generated: a method whose implementation will encode and 659 * dispatch invocations to the proxy instance's invocation handler. 660 */ 661 private class ProxyMethod { 662 663 private final Method method; 664 private final String shortSignature; 665 private final Class<?> fromClass; 666 private final Class<?> returnType; 667 private final String methodFieldName; 668 private Class<?>[] exceptionTypes; 669 private final FieldRefEntry methodField; 670 671 private ProxyMethod(Method method, String sig, 672 Class<?> returnType, Class<?>[] exceptionTypes, 673 Class<?> fromClass, String methodFieldName) { 674 this.method = method; 675 this.shortSignature = sig; 676 this.returnType = returnType; 677 this.exceptionTypes = exceptionTypes; 678 this.fromClass = fromClass; 679 this.methodFieldName = methodFieldName; 680 this.methodField = cp.fieldRefEntry(thisClassCE, 681 cp.nameAndTypeEntry(methodFieldName, CD_Method)); 682 } 683 684 private Class<?>[] parameterTypes() { 685 return method.getSharedParameterTypes(); 686 } 687 688 /** 689 * Create a new specific ProxyMethod with a specific field name 690 * 691 * @param method The method for which to create a proxy 692 */ 693 private ProxyMethod(Method method, String sig, String methodFieldName) { 694 this(method, sig, method.getReturnType(), 695 method.getSharedExceptionTypes(), method.getDeclaringClass(), methodFieldName); 696 } 697 698 /** 699 * Generate this method, including the code and exception table entry. 700 */ 701 private void generateMethod(ClassBuilder clb) { 702 var desc = methodTypeDesc(returnType, parameterTypes()); 703 int accessFlags = (method.isVarArgs()) ? ACC_VARARGS | ACC_PUBLIC | ACC_FINAL 704 : ACC_PUBLIC | ACC_FINAL; 705 clb.withMethod(method.getName(), desc, accessFlags, mb -> 706 mb.with(ExceptionsAttribute.of(toClassEntries(cp, List.of(exceptionTypes)))) 707 .withCode(cob -> { 708 var catchList = computeUniqueCatchList(exceptionTypes); 709 cob.aload(cob.receiverSlot()) 710 .getfield(handlerField) 711 .aload(cob.receiverSlot()) 712 .getstatic(methodField); 713 Class<?>[] parameterTypes = parameterTypes(); 714 if (parameterTypes.length > 0) { 715 // Create an array and fill with the parameters converting primitives to wrappers 716 cob.loadConstant(parameterTypes.length) 717 .anewarray(objectCE); 718 for (int i = 0; i < parameterTypes.length; i++) { 719 cob.dup() 720 .loadConstant(i); 721 codeWrapArgument(cob, parameterTypes[i], cob.parameterSlot(i)); 722 cob.aastore(); 723 } 724 } else { 725 cob.aconst_null(); 726 } 727 728 cob.invokeinterface(invocationHandlerInvoke); 729 730 if (returnType == void.class) { 731 cob.pop() 732 .return_(); 733 } else { 734 codeUnwrapReturnValue(cob, returnType); 735 } 736 if (!catchList.isEmpty()) { 737 var c1 = cob.newBoundLabel(); 738 for (var exc : catchList) { 739 cob.exceptionCatch(cob.startLabel(), c1, c1, referenceClassDesc(exc)); 740 } 741 cob.athrow(); // just rethrow the exception 742 var c2 = cob.newBoundLabel(); 743 cob.exceptionCatchAll(cob.startLabel(), c1, c2) 744 .new_(uteCE) 745 .dup_x1() 746 .swap() 747 .invokespecial(uteInit) 748 .athrow() 749 .with(StackMapTableAttribute.of(List.of( 750 StackMapFrameInfo.of(c1, List.of(), throwableStack), 751 StackMapFrameInfo.of(c2, List.of(), throwableStack)))); 752 } 753 })); 754 } 755 756 /** 757 * Generate code for wrapping an argument of the given type 758 * whose value can be found at the specified local variable 759 * index, in order for it to be passed (as an Object) to the 760 * invocation handler's "invoke" method. 761 */ 762 private void codeWrapArgument(CodeBuilder cob, Class<?> type, int slot) { 763 if (type.isPrimitive()) { 764 cob.loadLocal(TypeKind.from(type).asLoadable(), slot); 765 PrimitiveTypeInfo prim = PrimitiveTypeInfo.get(type); 766 cob.invokestatic(prim.wrapperMethodRef(cp)); 767 } else { 768 cob.aload(slot); 769 } 770 } 771 772 /** 773 * Generate code for unwrapping a return value of the given 774 * type from the invocation handler's "invoke" method (as type 775 * Object) to its correct type. 776 */ 777 private void codeUnwrapReturnValue(CodeBuilder cob, Class<?> type) { 778 if (type.isPrimitive()) { 779 PrimitiveTypeInfo prim = PrimitiveTypeInfo.get(type); 780 781 cob.checkcast(prim.wrapperClass) 782 .invokevirtual(prim.unwrapMethodRef(cp)) 783 .return_(TypeKind.from(type).asLoadable()); 784 } else { 785 cob.checkcast(referenceClassDesc(type)) 786 .areturn(); 787 } 788 } 789 790 /** 791 * Generate code for initializing the static field that stores 792 * the Method object for this proxy method. A class loader is 793 * anticipated at local variable index 0. 794 * The generated code must be run in an AccessController.doPrivileged 795 * block if a SecurityManager is present, as otherwise the code 796 * cannot pass {@code null} ClassLoader to forName. 797 */ 798 private void codeFieldInitialization(CodeBuilder cob) { 799 var cp = cob.constantPool(); 800 codeClassForName(cob, fromClass); 801 802 Class<?>[] parameterTypes = parameterTypes(); 803 cob.ldc(method.getName()) 804 .loadConstant(parameterTypes.length) 805 .anewarray(classCE); 806 807 // Construct an array with the parameter types mapping primitives to Wrapper types 808 for (int i = 0; i < parameterTypes.length; i++) { 809 cob.dup() 810 .loadConstant(i); 811 if (parameterTypes[i].isPrimitive()) { 812 PrimitiveTypeInfo prim = PrimitiveTypeInfo.get(parameterTypes[i]); 813 cob.getstatic(prim.typeFieldRef(cp)); 814 } else { 815 codeClassForName(cob, parameterTypes[i]); 816 } 817 cob.aastore(); 818 } 819 // lookup the method 820 cob.invokevirtual(classGetMethod) 821 .putstatic(methodField); 822 } 823 824 /* 825 * =============== Code Generation Utility Methods =============== 826 */ 827 828 /** 829 * Generate code to invoke the Class.forName with the name of the given 830 * class to get its Class object at runtime. The code is written to 831 * the supplied stream. Note that the code generated by this method 832 * may cause the checked ClassNotFoundException to be thrown. A class 833 * loader is anticipated at local variable index 0. 834 */ 835 private void codeClassForName(CodeBuilder cob, Class<?> cl) { 836 if (cl == Object.class) { 837 cob.ldc(objectCE); 838 } else { 839 cob.ldc(cl.getName()) 840 .iconst_0() // false 841 .aload(0)// classLoader 842 .invokestatic(classForName); 843 } 844 } 845 846 @Override 847 public String toString() { 848 return method.toShortString(); 849 } 850 } 851 852 /** 853 * A PrimitiveTypeInfo object contains bytecode-related information about 854 * a primitive type in its instance fields. The struct for a particular 855 * primitive type can be obtained using the static "get" method. 856 */ 857 private enum PrimitiveTypeInfo { 858 BYTE(byte.class, CD_byte, CD_Byte), 859 CHAR(char.class, CD_char, CD_Character), 860 DOUBLE(double.class, CD_double, CD_Double), 861 FLOAT(float.class, CD_float, CD_Float), 862 INT(int.class, CD_int, CD_Integer), 863 LONG(long.class, CD_long, CD_Long), 864 SHORT(short.class, CD_short, CD_Short), 865 BOOLEAN(boolean.class, CD_boolean, CD_Boolean); 866 867 /** 868 * wrapper class 869 */ 870 private final ClassDesc wrapperClass; 871 /** 872 * wrapper factory method type 873 */ 874 private final MethodTypeDesc wrapperMethodType; 875 /** 876 * wrapper class method name for retrieving primitive value 877 */ 878 private final String unwrapMethodName; 879 /** 880 * wrapper class method type for retrieving primitive value 881 */ 882 private final MethodTypeDesc unwrapMethodType; 883 884 PrimitiveTypeInfo(Class<?> primitiveClass, ClassDesc baseType, ClassDesc wrapperClass) { 885 assert baseType.isPrimitive(); 886 this.wrapperClass = wrapperClass; 887 this.wrapperMethodType = MethodTypeDescImpl.ofValidated(wrapperClass, baseType); 888 this.unwrapMethodName = primitiveClass.getName() + "Value"; 889 this.unwrapMethodType = MethodTypeDescImpl.ofValidated(baseType); 890 } 891 892 public static PrimitiveTypeInfo get(Class<?> cl) { 893 // Uses if chain for speed: 8284880 894 if (cl == int.class) return INT; 895 if (cl == long.class) return LONG; 896 if (cl == boolean.class) return BOOLEAN; 897 if (cl == short.class) return SHORT; 898 if (cl == byte.class) return BYTE; 899 if (cl == char.class) return CHAR; 900 if (cl == float.class) return FLOAT; 901 if (cl == double.class) return DOUBLE; 902 throw new AssertionError(cl); 903 } 904 905 public MethodRefEntry wrapperMethodRef(ConstantPoolBuilder cp) { 906 return cp.methodRefEntry(wrapperClass, "valueOf", wrapperMethodType); 907 } 908 909 public MethodRefEntry unwrapMethodRef(ConstantPoolBuilder cp) { 910 return cp.methodRefEntry(wrapperClass, unwrapMethodName, unwrapMethodType); 911 } 912 913 public FieldRefEntry typeFieldRef(ConstantPoolBuilder cp) { 914 return cp.fieldRefEntry(wrapperClass, "TYPE", CD_Class); 915 } 916 } 917 } --- EOF ---