2  * Copyright (c) 1999, 2018, Oracle and/or its affiliates. All rights reserved.

     2  * Copyright (c) 1999, 2019, Oracle and/or its affiliates. All rights reserved.

    28 import java.io.ByteArrayOutputStream;

    28 import jdk.internal.org.objectweb.asm.ClassWriter;

    29 import java.io.DataOutputStream;

    29 import jdk.internal.org.objectweb.asm.Label;

    30 import java.io.File;

    30 import jdk.internal.org.objectweb.asm.MethodVisitor;

    31 import jdk.internal.org.objectweb.asm.Opcodes;

    32 import sun.security.action.GetBooleanAction;

    33 

    32 import java.io.OutputStream;

    35 import java.lang.invoke.MethodType;

    33 import java.lang.reflect.Array;

    34 import java.lang.reflect.Method;

    43 import sun.security.action.GetBooleanAction;

    46 

    47 import static jdk.internal.org.objectweb.asm.Opcodes.*;

    48  *

    52  * <p>

    49  * The external interfaces to ProxyGenerator is the static

    53  * The external interface to ProxyGenerator is the static

    55 class ProxyGenerator {

    56 final class ProxyGenerator extends ClassWriter {

    56     /*

    57 

    57      * In the comments below, "JVMS" refers to The Java Virtual Machine

    58     private static final String JL_CLASS = "java/lang/Class";

    58      * Specification Second Edition and "JLS" refers to the original

    59     private static final String JL_OBJECT = "java/lang/Object";

    59      * version of The Java Language Specification, unless otherwise

    60     private static final String JL_THROWABLE = "java/lang/Throwable";

    60      * specified.

    61     private static final String JL_CLASS_NOT_FOUND_EX = "java/lang/ClassNotFoundException";

    61      */

    62     private static final String JL_NO_CLASS_DEF_FOUND_ERROR = "java/lang/NoClassDefFoundError";

    62 

    63     private static final String JL_NO_SUCH_METHOD_EX = "java/lang/NoSuchMethodException";

    63     /* generate 1.5-era class file version */

    64     private static final String JL_NO_SUCH_METHOD_ERROR = "java/lang/NoSuchMethodError";

    64     private static final int CLASSFILE_MAJOR_VERSION = 49;

    65 

    65     private static final int CLASSFILE_MINOR_VERSION = 0;

    66     private static final String JLR_INVOCATION_HANDLER = "java/lang/reflect/InvocationHandler";

    66 

    67     private static final String JLR_PROXY = "java/lang/reflect/Proxy";

    67     /*

    68     private static final String JLR_UNDECLARED_THROWABLE_EX = "java/lang/reflect/UndeclaredThrowableException";

    68      * beginning of constants copied from

    69 

    69      * sun.tools.java.RuntimeConstants (which no longer exists):

    70     private static final String LJL_CLASS = "Ljava/lang/Class;";

    70      */

    71     private static final String LJLR_METHOD = "Ljava/lang/reflect/Method;";

    71 

    72     private static final String LJLR_INVOCATION_HANDLER = "Ljava/lang/reflect/InvocationHandler;";

    72     /* constant pool tags */

    73 

    73     private static final int CONSTANT_UTF8              = 1;

    74     private static final String MJLR_INVOCATIONHANDLER = "(Ljava/lang/reflect/InvocationHandler;)V";

    74     private static final int CONSTANT_UNICODE           = 2;

    75 

    75     private static final int CONSTANT_INTEGER           = 3;

    76     private static final String NAME_CTOR = "<init>";

    76     private static final int CONSTANT_FLOAT             = 4;

    77     private static final String NAME_CLINIT = "<clinit>";

    77     private static final int CONSTANT_LONG              = 5;

    78 

    78     private static final int CONSTANT_DOUBLE            = 6;

    79     private static final Class<?>[] EMPTY_CLASS_ARRAY = new Class<?>[0];

    79     private static final int CONSTANT_CLASS             = 7;

    80 

    80     private static final int CONSTANT_STRING            = 8;

    81     /**

    81     private static final int CONSTANT_FIELD             = 9;

    82      * name of field for storing a proxy instance's invocation handler

    82     private static final int CONSTANT_METHOD            = 10;

    83      */

    83     private static final int CONSTANT_INTERFACEMETHOD   = 11;

    84     private static final int CONSTANT_NAMEANDTYPE       = 12;

    85 

    86     /* access and modifier flags */

    87     private static final int ACC_PUBLIC                 = 0x00000001;

    88     private static final int ACC_PRIVATE                = 0x00000002;

    89 //  private static final int ACC_PROTECTED              = 0x00000004;

    90     private static final int ACC_STATIC                 = 0x00000008;

    91     private static final int ACC_FINAL                  = 0x00000010;

    92 //  private static final int ACC_SYNCHRONIZED           = 0x00000020;

    93 //  private static final int ACC_VOLATILE               = 0x00000040;

    94 //  private static final int ACC_TRANSIENT              = 0x00000080;

    95 //  private static final int ACC_NATIVE                 = 0x00000100;

    96 //  private static final int ACC_INTERFACE              = 0x00000200;

    97 //  private static final int ACC_ABSTRACT               = 0x00000400;

    98     private static final int ACC_SUPER                  = 0x00000020;

    99 //  private static final int ACC_STRICT                 = 0x00000800;

   100 

   101     /* opcodes */

   102 //  private static final int opc_nop                    = 0;

   103     private static final int opc_aconst_null            = 1;

   104 //  private static final int opc_iconst_m1              = 2;

   105     private static final int opc_iconst_0               = 3;

   106 //  private static final int opc_iconst_1               = 4;

   107 //  private static final int opc_iconst_2               = 5;

   108 //  private static final int opc_iconst_3               = 6;

   109 //  private static final int opc_iconst_4               = 7;

   110 //  private static final int opc_iconst_5               = 8;

   111 //  private static final int opc_lconst_0               = 9;

   112 //  private static final int opc_lconst_1               = 10;

   113 //  private static final int opc_fconst_0               = 11;

   114 //  private static final int opc_fconst_1               = 12;

   115 //  private static final int opc_fconst_2               = 13;

   116 //  private static final int opc_dconst_0               = 14;

   117 //  private static final int opc_dconst_1               = 15;

   118     private static final int opc_bipush                 = 16;

   119     private static final int opc_sipush                 = 17;

   120     private static final int opc_ldc                    = 18;

   121     private static final int opc_ldc_w                  = 19;

   122 //  private static final int opc_ldc2_w                 = 20;

   123     private static final int opc_iload                  = 21;

   124     private static final int opc_lload                  = 22;

   125     private static final int opc_fload                  = 23;

   126     private static final int opc_dload                  = 24;

   127     private static final int opc_aload                  = 25;

   128     private static final int opc_iload_0                = 26;

   129 //  private static final int opc_iload_1                = 27;

   130 //  private static final int opc_iload_2                = 28;

   131 //  private static final int opc_iload_3                = 29;

   132     private static final int opc_lload_0                = 30;

   133 //  private static final int opc_lload_1                = 31;

   134 //  private static final int opc_lload_2                = 32;

   135 //  private static final int opc_lload_3                = 33;

   136     private static final int opc_fload_0                = 34;

   137 //  private static final int opc_fload_1                = 35;

   138 //  private static final int opc_fload_2                = 36;

   139 //  private static final int opc_fload_3                = 37;

   140     private static final int opc_dload_0                = 38;

   141 //  private static final int opc_dload_1                = 39;

   142 //  private static final int opc_dload_2                = 40;

   143 //  private static final int opc_dload_3                = 41;

   144     private static final int opc_aload_0                = 42;

   145 //  private static final int opc_aload_1                = 43;

   146 //  private static final int opc_aload_2                = 44;

   147 //  private static final int opc_aload_3                = 45;

   148 //  private static final int opc_iaload                 = 46;

   149 //  private static final int opc_laload                 = 47;

   150 //  private static final int opc_faload                 = 48;

   151 //  private static final int opc_daload                 = 49;

   152 //  private static final int opc_aaload                 = 50;

   153 //  private static final int opc_baload                 = 51;

   154 //  private static final int opc_caload                 = 52;

   155 //  private static final int opc_saload                 = 53;

   156 //  private static final int opc_istore                 = 54;

   157 //  private static final int opc_lstore                 = 55;

   158 //  private static final int opc_fstore                 = 56;

   159 //  private static final int opc_dstore                 = 57;

   160     private static final int opc_astore                 = 58;

   161 //  private static final int opc_istore_0               = 59;

   162 //  private static final int opc_istore_1               = 60;

   163 //  private static final int opc_istore_2               = 61;

   164 //  private static final int opc_istore_3               = 62;

   165 //  private static final int opc_lstore_0               = 63;

   166 //  private static final int opc_lstore_1               = 64;

   167 //  private static final int opc_lstore_2               = 65;

   168 //  private static final int opc_lstore_3               = 66;

   169 //  private static final int opc_fstore_0               = 67;

   170 //  private static final int opc_fstore_1               = 68;

   171 //  private static final int opc_fstore_2               = 69;

   172 //  private static final int opc_fstore_3               = 70;

   173 //  private static final int opc_dstore_0               = 71;

   174 //  private static final int opc_dstore_1               = 72;

   175 //  private static final int opc_dstore_2               = 73;

   176 //  private static final int opc_dstore_3               = 74;

   177     private static final int opc_astore_0               = 75;

   178 //  private static final int opc_astore_1               = 76;

   179 //  private static final int opc_astore_2               = 77;

   180 //  private static final int opc_astore_3               = 78;

   181 //  private static final int opc_iastore                = 79;

   182 //  private static final int opc_lastore                = 80;

   183 //  private static final int opc_fastore                = 81;

   184 //  private static final int opc_dastore                = 82;

   185     private static final int opc_aastore                = 83;

   186 //  private static final int opc_bastore                = 84;

   187 //  private static final int opc_castore                = 85;

   188 //  private static final int opc_sastore                = 86;

   189     private static final int opc_pop                    = 87;

   190 //  private static final int opc_pop2                   = 88;

   191     private static final int opc_dup                    = 89;

   192 //  private static final int opc_dup_x1                 = 90;

   193 //  private static final int opc_dup_x2                 = 91;

   194 //  private static final int opc_dup2                   = 92;

   195 //  private static final int opc_dup2_x1                = 93;

   196 //  private static final int opc_dup2_x2                = 94;

   197 //  private static final int opc_swap                   = 95;

   198 //  private static final int opc_iadd                   = 96;

   199 //  private static final int opc_ladd                   = 97;

   200 //  private static final int opc_fadd                   = 98;

   201 //  private static final int opc_dadd                   = 99;

   202 //  private static final int opc_isub                   = 100;

   203 //  private static final int opc_lsub                   = 101;

   204 //  private static final int opc_fsub                   = 102;

   205 //  private static final int opc_dsub                   = 103;

   206 //  private static final int opc_imul                   = 104;

   207 //  private static final int opc_lmul                   = 105;

   208 //  private static final int opc_fmul                   = 106;

   209 //  private static final int opc_dmul                   = 107;

   210 //  private static final int opc_idiv                   = 108;

   211 //  private static final int opc_ldiv                   = 109;

   212 //  private static final int opc_fdiv                   = 110;

   213 //  private static final int opc_ddiv                   = 111;

   214 //  private static final int opc_irem                   = 112;

   215 //  private static final int opc_lrem                   = 113;

   216 //  private static final int opc_frem                   = 114;

   217 //  private static final int opc_drem                   = 115;

   218 //  private static final int opc_ineg                   = 116;

   219 //  private static final int opc_lneg                   = 117;

   220 //  private static final int opc_fneg                   = 118;

   221 //  private static final int opc_dneg                   = 119;

   222 //  private static final int opc_ishl                   = 120;

   223 //  private static final int opc_lshl                   = 121;

   224 //  private static final int opc_ishr                   = 122;

   225 //  private static final int opc_lshr                   = 123;

   226 //  private static final int opc_iushr                  = 124;

   227 //  private static final int opc_lushr                  = 125;

   228 //  private static final int opc_iand                   = 126;

   229 //  private static final int opc_land                   = 127;

   230 //  private static final int opc_ior                    = 128;

   231 //  private static final int opc_lor                    = 129;

   232 //  private static final int opc_ixor                   = 130;

   233 //  private static final int opc_lxor                   = 131;

   234 //  private static final int opc_iinc                   = 132;

   235 //  private static final int opc_i2l                    = 133;

   236 //  private static final int opc_i2f                    = 134;

   237 //  private static final int opc_i2d                    = 135;

   238 //  private static final int opc_l2i                    = 136;

   239 //  private static final int opc_l2f                    = 137;

   240 //  private static final int opc_l2d                    = 138;

   241 //  private static final int opc_f2i                    = 139;

   242 //  private static final int opc_f2l                    = 140;

   243 //  private static final int opc_f2d                    = 141;

   244 //  private static final int opc_d2i                    = 142;

   245 //  private static final int opc_d2l                    = 143;

   246 //  private static final int opc_d2f                    = 144;

   247 //  private static final int opc_i2b                    = 145;

   248 //  private static final int opc_i2c                    = 146;

   249 //  private static final int opc_i2s                    = 147;

   250 //  private static final int opc_lcmp                   = 148;

   251 //  private static final int opc_fcmpl                  = 149;

   252 //  private static final int opc_fcmpg                  = 150;

   253 //  private static final int opc_dcmpl                  = 151;

   254 //  private static final int opc_dcmpg                  = 152;

   255 //  private static final int opc_ifeq                   = 153;

   256 //  private static final int opc_ifne                   = 154;

   257 //  private static final int opc_iflt                   = 155;

   258 //  private static final int opc_ifge                   = 156;

   259 //  private static final int opc_ifgt                   = 157;

   260 //  private static final int opc_ifle                   = 158;

   261 //  private static final int opc_if_icmpeq              = 159;

   262 //  private static final int opc_if_icmpne              = 160;

   263 //  private static final int opc_if_icmplt              = 161;

   264 //  private static final int opc_if_icmpge              = 162;

   265 //  private static final int opc_if_icmpgt              = 163;

   266 //  private static final int opc_if_icmple              = 164;

   267 //  private static final int opc_if_acmpeq              = 165;

   268 //  private static final int opc_if_acmpne              = 166;

   269 //  private static final int opc_goto                   = 167;

   270 //  private static final int opc_jsr                    = 168;

   271 //  private static final int opc_ret                    = 169;

   272 //  private static final int opc_tableswitch            = 170;

   273 //  private static final int opc_lookupswitch           = 171;

   274     private static final int opc_ireturn                = 172;

   275     private static final int opc_lreturn                = 173;

   276     private static final int opc_freturn                = 174;

   277     private static final int opc_dreturn                = 175;

   278     private static final int opc_areturn                = 176;

   279     private static final int opc_return                 = 177;

   280     private static final int opc_getstatic              = 178;

   281     private static final int opc_putstatic              = 179;

   282     private static final int opc_getfield               = 180;

   283 //  private static final int opc_putfield               = 181;

   284     private static final int opc_invokevirtual          = 182;

   285     private static final int opc_invokespecial          = 183;

   286     private static final int opc_invokestatic           = 184;

   287     private static final int opc_invokeinterface        = 185;

   288     private static final int opc_new                    = 187;

   289 //  private static final int opc_newarray               = 188;

   290     private static final int opc_anewarray              = 189;

   291 //  private static final int opc_arraylength            = 190;

   292     private static final int opc_athrow                 = 191;

   293     private static final int opc_checkcast              = 192;

   294 //  private static final int opc_instanceof             = 193;

   295 //  private static final int opc_monitorenter           = 194;

   296 //  private static final int opc_monitorexit            = 195;

   297     private static final int opc_wide                   = 196;

   298 //  private static final int opc_multianewarray         = 197;

   299 //  private static final int opc_ifnull                 = 198;

   300 //  private static final int opc_ifnonnull              = 199;

   301 //  private static final int opc_goto_w                 = 200;

   302 //  private static final int opc_jsr_w                  = 201;

   303 

   304     // end of constants copied from sun.tools.java.RuntimeConstants

   305 

   306     /** name of the superclass of proxy classes */

   307     private static final String superclassName = "java/lang/reflect/Proxy";

   308 

   309     /** name of field for storing a proxy instance's invocation handler */

   312     /** debugging flag for saving generated class files */

    86     /**

    87      * debugging flag for saving generated class files

    88      */

   314         java.security.AccessController.doPrivileged(

    90             java.security.AccessController.doPrivileged(

   315             new GetBooleanAction(

    91                     new GetBooleanAction(

   316                 "jdk.proxy.ProxyGenerator.saveGeneratedFiles")).booleanValue();

    92                             "jdk.proxy.ProxyGenerator.saveGeneratedFiles"));

   317 

    93 

   318     /**

    94     /* Preloaded ProxyMethod objects for methods in java.lang.Object */

   319      * Generate a public proxy class given a name and a list of proxy interfaces.

    95     private final static ProxyMethod hashCodeMethod;

   320      */

    96     private final static ProxyMethod equalsMethod;

   321     static byte[] generateProxyClass(final String name,

    97     private final static ProxyMethod toStringMethod;

   322                                      Class<?>[] interfaces) {

    98 

   323         return generateProxyClass(name, interfaces, (ACC_PUBLIC | ACC_FINAL | ACC_SUPER));

    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;

   332     */

   164      */

   333     static byte[] generateProxyClass(final String name,

   165     static byte[] generateProxyClass(ClassLoader loader,

   334                                      Class<?>[] interfaces,

   166                                      final String name,

   335                                      int accessFlags)

   167                                      List<Class<?>> interfaces,

   336     {

   168                                      int accessFlags) {

   337         ProxyGenerator gen = new ProxyGenerator(name, interfaces, accessFlags);

   169         ProxyGenerator gen = new ProxyGenerator(loader, name, interfaces, accessFlags);

   342             new java.security.PrivilegedAction<Void>() {

   174                     new java.security.PrivilegedAction<Void>() {

   343                 public Void run() {

   175                         public Void run() {

   344                     try {

   176                             try {

   345                         int i = name.lastIndexOf('.');

   177                                 int i = name.lastIndexOf('.');

   346                         Path path;

   178                                 Path path;

   347                         if (i > 0) {

   179                                 if (i > 0) {

   348                             Path dir = Path.of(name.substring(0, i).replace('.', File.separatorChar));

   180                                     Path dir = Path.of(dotToSlash(name.substring(0, i)));

   349                             Files.createDirectories(dir);

   181                                     Files.createDirectories(dir);

   350                             path = dir.resolve(name.substring(i+1, name.length()) + ".class");

   182                                     path = dir.resolve(name.substring(i + 1) + ".class");

   351                         } else {

   183                                 } else {

   352                             path = Path.of(name + ".class");

   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                             }

   354                         Files.write(path, classFile);

   193                     });

   355                         return null;

   356                     } catch (IOException e) {

   357                         throw new InternalError(

   358                             "I/O exception saving generated file: " + e);

   359                     }

   360                 }

   361             });

   367     /* preloaded Method objects for methods in java.lang.Object */

   199     /**

   368     private static Method hashCodeMethod;

   200      * Return an array of the type names from an array of Classes.

   369     private static Method equalsMethod;

   370     private static Method toStringMethod;

   371     static {

   372         try {

   373             hashCodeMethod = Object.class.getMethod("hashCode");

   374             equalsMethod =

   375                 Object.class.getMethod("equals", new Class<?>[] { Object.class });

   376             toStringMethod = Object.class.getMethod("toString");

   377         } catch (NoSuchMethodException e) {

   378             throw new NoSuchMethodError(e.getMessage());

   379         }

   380     }

   381 

   382     /** name of proxy class */

   383     private String className;

   384 

   385     /** proxy interfaces */

   386     private Class<?>[] interfaces;

   387 

   388     /** proxy class access flags */

   389     private int accessFlags;

   390 

   391     /** constant pool of class being generated */

   392     private ConstantPool cp = new ConstantPool();

   393 

   394     /** FieldInfo struct for each field of generated class */

   395     private List<FieldInfo> fields = new ArrayList<>();

   396 

   397     /** MethodInfo struct for each method of generated class */

   398     private List<MethodInfo> methods = new ArrayList<>();

   399 

   400     /**

   401      * maps method signature string to list of ProxyMethod objects for

   402      * proxy methods with that signature

   403      */

   404     private Map<String, List<ProxyMethod>> proxyMethods = new HashMap<>();

   405 

   406     /** count of ProxyMethod objects added to proxyMethods */

   407     private int proxyMethodCount = 0;

   408 

   409     /**

   410      * Construct a ProxyGenerator to generate a proxy class with the

   411      * specified name and for the given interfaces.

   413      * A ProxyGenerator object contains the state for the ongoing

   202      * @param classes an array of classes or interfaces

   414      * generation of a particular proxy class.

   203      * @return the array of class names; or null if there are no classes

   415      */

   204      */

   416     private ProxyGenerator(String className, Class<?>[] interfaces, int accessFlags) {

   205     private static String[] typeNames(List<Class<?>> classes) {

   417         this.className = className;

   206         if (classes == null || classes.size() == 0)

   418         this.interfaces = interfaces;

   207             return null;

   419         this.accessFlags = accessFlags;

   208         int size = classes.size();

   420     }

   209         String[] ifaces = new String[size];

   421 

   210         for (int i = 0; i < size; i++)

   422     /**

   211             ifaces[i] = dotToSlash(classes.get(i).getName());

   423      * Generate a class file for the proxy class.  This method drives the

   212         return ifaces;

   424      * class file generation process.

   425      */

   426     private byte[] generateClassFile() {

   427 

   428         /* ============================================================

   429          * Step 1: Assemble ProxyMethod objects for all methods to

   430          * generate proxy dispatching code for.

   431          */

   432 

   433         /*

   434          * Record that proxy methods are needed for the hashCode, equals,

   435          * and toString methods of java.lang.Object.  This is done before

   436          * the methods from the proxy interfaces so that the methods from

   437          * java.lang.Object take precedence over duplicate methods in the

   438          * proxy interfaces.

   439          */

   440         addProxyMethod(hashCodeMethod, Object.class);

   441         addProxyMethod(equalsMethod, Object.class);

   442         addProxyMethod(toStringMethod, Object.class);

   443 

   444         /*

   445          * Now record all of the methods from the proxy interfaces, giving

   446          * earlier interfaces precedence over later ones with duplicate

   447          * methods.

   448          */

   449         for (Class<?> intf : interfaces) {

   450             for (Method m : intf.getMethods()) {

   451                 if (!Modifier.isStatic(m.getModifiers())) {

   452                     addProxyMethod(m, intf);

   453                 }

   454             }

   455         }

   456 

   457         /*

   458          * For each set of proxy methods with the same signature,

   459          * verify that the methods' return types are compatible.

   460          */

   461         for (List<ProxyMethod> sigmethods : proxyMethods.values()) {

   462             checkReturnTypes(sigmethods);

   463         }

   464 

   465         /* ============================================================

   466          * Step 2: Assemble FieldInfo and MethodInfo structs for all of

   467          * fields and methods in the class we are generating.

   468          */

   469         try {

   470             methods.add(generateConstructor());

   471 

   472             for (List<ProxyMethod> sigmethods : proxyMethods.values()) {

   473                 for (ProxyMethod pm : sigmethods) {

   474 

   475                     // add static field for method's Method object

   476                     fields.add(new FieldInfo(pm.methodFieldName,

   477                         "Ljava/lang/reflect/Method;",

   478                          ACC_PRIVATE | ACC_STATIC));

   479 

   480                     // generate code for proxy method and add it

   481                     methods.add(pm.generateMethod());

   482                 }

   483             }

   484 

   485             methods.add(generateStaticInitializer());

   486 

   487         } catch (IOException e) {

   488             throw new InternalError("unexpected I/O Exception", e);

   489         }

   490 

   491         if (methods.size() > 65535) {

   492             throw new IllegalArgumentException("method limit exceeded");

   493         }

   494         if (fields.size() > 65535) {

   495             throw new IllegalArgumentException("field limit exceeded");

   496         }

   497 

   498         /* ============================================================

   499          * Step 3: Write the final class file.

   500          */

   501 

   502         /*

   503          * Make sure that constant pool indexes are reserved for the

   504          * following items before starting to write the final class file.

   505          */

   506         cp.getClass(dotToSlash(className));

   507         cp.getClass(superclassName);

   508         for (Class<?> intf: interfaces) {

   509             cp.getClass(dotToSlash(intf.getName()));

   510         }

   511 

   512         /*

   513          * Disallow new constant pool additions beyond this point, since

   514          * we are about to write the final constant pool table.

   515          */

   516         cp.setReadOnly();

   517 

   518         ByteArrayOutputStream bout = new ByteArrayOutputStream();

   519         DataOutputStream dout = new DataOutputStream(bout);

   520 

   521         try {

   522             /*

   523              * Write all the items of the "ClassFile" structure.

   524              * See JVMS section 4.1.

   525              */

   526                                         // u4 magic;

   527             dout.writeInt(0xCAFEBABE);

   528                                         // u2 minor_version;

   529             dout.writeShort(CLASSFILE_MINOR_VERSION);

   530                                         // u2 major_version;

   531             dout.writeShort(CLASSFILE_MAJOR_VERSION);

   532 

   533             cp.write(dout);             // (write constant pool)

   534 

   535                                         // u2 access_flags;

   536             dout.writeShort(accessFlags);

   537                                         // u2 this_class;

   538             dout.writeShort(cp.getClass(dotToSlash(className)));

   539                                         // u2 super_class;

   540             dout.writeShort(cp.getClass(superclassName));

   541 

   542                                         // u2 interfaces_count;

   543             dout.writeShort(interfaces.length);

   544                                         // u2 interfaces[interfaces_count];

   545             for (Class<?> intf : interfaces) {

   546                 dout.writeShort(cp.getClass(

   547                     dotToSlash(intf.getName())));

   548             }

   549 

   550                                         // u2 fields_count;

   551             dout.writeShort(fields.size());

   552                                         // field_info fields[fields_count];

   553             for (FieldInfo f : fields) {

   554                 f.write(dout);

   555             }

   556 

   557                                         // u2 methods_count;

   558             dout.writeShort(methods.size());

   559                                         // method_info methods[methods_count];

   560             for (MethodInfo m : methods) {

   561                 m.write(dout);

   562             }

   563 

   564                                          // u2 attributes_count;

   565             dout.writeShort(0); // (no ClassFile attributes for proxy classes)

   566 

   567         } catch (IOException e) {

   568             throw new InternalError("unexpected I/O Exception", e);

   569         }

   570 

   571         return bout.toByteArray();

   572     }

   573 

   574     /**

   575      * Add another method to be proxied, either by creating a new

   576      * ProxyMethod object or augmenting an old one for a duplicate

   577      * method.

   578      *

   579      * "fromClass" indicates the proxy interface that the method was

   580      * found through, which may be different from (a subinterface of)

   581      * the method's "declaring class".  Note that the first Method

   582      * object passed for a given name and descriptor identifies the

   583      * Method object (and thus the declaring class) that will be

   584      * passed to the invocation handler's "invoke" method for a given

   585      * set of duplicate methods.

   586      */

   587     private void addProxyMethod(Method m, Class<?> fromClass) {

   588         String name = m.getName();

   589         Class<?>[] parameterTypes = m.getParameterTypes();

   590         Class<?> returnType = m.getReturnType();

   591         Class<?>[] exceptionTypes = m.getExceptionTypes();

   592 

   593         String sig = name + getParameterDescriptors(parameterTypes);

   594         List<ProxyMethod> sigmethods = proxyMethods.get(sig);

   595         if (sigmethods != null) {

   596             for (ProxyMethod pm : sigmethods) {

   597                 if (returnType == pm.returnType) {

   598                     /*

   599                      * Found a match: reduce exception types to the

   600                      * greatest set of exceptions that can thrown

   601                      * compatibly with the throws clauses of both

   602                      * overridden methods.

   603                      */

   604                     List<Class<?>> legalExceptions = new ArrayList<>();

   605                     collectCompatibleTypes(

   606                         exceptionTypes, pm.exceptionTypes, legalExceptions);

   607                     collectCompatibleTypes(

   608                         pm.exceptionTypes, exceptionTypes, legalExceptions);

   609                     pm.exceptionTypes = new Class<?>[legalExceptions.size()];

   610                     pm.exceptionTypes =

   611                         legalExceptions.toArray(pm.exceptionTypes);

   612                     return;

   613                 }

   614             }

   615         } else {

   616             sigmethods = new ArrayList<>(3);

   617             proxyMethods.put(sig, sigmethods);

   618         }

   619         sigmethods.add(new ProxyMethod(name, parameterTypes, returnType,

   620                                        exceptionTypes, fromClass));

   648     nextNewReturnType:

   240         nextNewReturnType:

   653                     "methods with same signature " +

   245                         "methods with same signature " +

   654                     getFriendlyMethodSignature(pm.methodName,

   246                                 pm.shortSignature +

   655                                                pm.parameterTypes) +

   247                                 " but incompatible return types: " +

   656                     " but incompatible return types: " +

   248                                 newReturnType.getName() + " and others");

   657                     newReturnType.getName() + " and others");

   712                 "methods with same signature " +

   303                     "methods with same signature " +

   713                 getFriendlyMethodSignature(pm.methodName, pm.parameterTypes) +

   304                             pm.shortSignature +

   714                 " but incompatible return types: " + uncoveredReturnTypes);

   305                             " but incompatible return types: " + uncoveredReturnTypes);

   715         }

   716     }

   717 

   718     /**

   719      * A FieldInfo object contains information about a particular field

   720      * in the class being generated.  The class mirrors the data items of

   721      * the "field_info" structure of the class file format (see JVMS 4.5).

   722      */

   723     private class FieldInfo {

   724         public int accessFlags;

   725         public String name;

   726         public String descriptor;

   727 

   728         public FieldInfo(String name, String descriptor, int accessFlags) {

   729             this.name = name;

   730             this.descriptor = descriptor;

   731             this.accessFlags = accessFlags;

   732 

   733             /*

   734              * Make sure that constant pool indexes are reserved for the

   735              * following items before starting to write the final class file.

   736              */

   737             cp.getUtf8(name);

   738             cp.getUtf8(descriptor);

   739         }

   740 

   741         public void write(DataOutputStream out) throws IOException {

   742             /*

   743              * Write all the items of the "field_info" structure.

   744              * See JVMS section 4.5.

   745              */

   746                                         // u2 access_flags;

   747             out.writeShort(accessFlags);

   748                                         // u2 name_index;

   749             out.writeShort(cp.getUtf8(name));

   750                                         // u2 descriptor_index;

   751             out.writeShort(cp.getUtf8(descriptor));

   752                                         // u2 attributes_count;

   753             out.writeShort(0);  // (no field_info attributes for proxy classes)

   754         }

   755     }

   756 

   757     /**

   758      * An ExceptionTableEntry object holds values for the data items of

   759      * an entry in the "exception_table" item of the "Code" attribute of

   760      * "method_info" structures (see JVMS 4.7.3).

   761      */

   762     private static class ExceptionTableEntry {

   763         public short startPc;

   764         public short endPc;

   765         public short handlerPc;

   766         public short catchType;

   767 

   768         public ExceptionTableEntry(short startPc, short endPc,

   769                                    short handlerPc, short catchType)

   770         {

   771             this.startPc = startPc;

   772             this.endPc = endPc;

   773             this.handlerPc = handlerPc;

   774             this.catchType = catchType;

   775         }

   776     };

   777 

   778     /**

   779      * A MethodInfo object contains information about a particular method

   780      * in the class being generated.  This class mirrors the data items of

   781      * the "method_info" structure of the class file format (see JVMS 4.6).

   782      */

   783     private class MethodInfo {

   784         public int accessFlags;

   785         public String name;

   786         public String descriptor;

   787         public short maxStack;

   788         public short maxLocals;

   789         public ByteArrayOutputStream code = new ByteArrayOutputStream();

   790         public List<ExceptionTableEntry> exceptionTable =

   791             new ArrayList<ExceptionTableEntry>();

   792         public short[] declaredExceptions;

   793 

   794         public MethodInfo(String name, String descriptor, int accessFlags) {

   795             this.name = name;

   796             this.descriptor = descriptor;

   797             this.accessFlags = accessFlags;

   798 

   799             /*

   800              * Make sure that constant pool indexes are reserved for the

   801              * following items before starting to write the final class file.

   802              */

   803             cp.getUtf8(name);

   804             cp.getUtf8(descriptor);

   805             cp.getUtf8("Code");

   806             cp.getUtf8("Exceptions");

   807         }

   808 

   809         public void write(DataOutputStream out) throws IOException {

   810             /*

   811              * Write all the items of the "method_info" structure.

   812              * See JVMS section 4.6.

   813              */

   814                                         // u2 access_flags;

   815             out.writeShort(accessFlags);

   816                                         // u2 name_index;

   817             out.writeShort(cp.getUtf8(name));

   818                                         // u2 descriptor_index;

   819             out.writeShort(cp.getUtf8(descriptor));

   820                                         // u2 attributes_count;

   821             out.writeShort(2);  // (two method_info attributes:)

   822 

   823             // Write "Code" attribute. See JVMS section 4.7.3.

   824 

   825                                         // u2 attribute_name_index;

   826             out.writeShort(cp.getUtf8("Code"));

   827                                         // u4 attribute_length;

   828             out.writeInt(12 + code.size() + 8 * exceptionTable.size());

   829                                         // u2 max_stack;

   830             out.writeShort(maxStack);

   831                                         // u2 max_locals;

   832             out.writeShort(maxLocals);

   833                                         // u2 code_length;

   834             out.writeInt(code.size());

   835                                         // u1 code[code_length];

   836             code.writeTo(out);

   837                                         // u2 exception_table_length;

   838             out.writeShort(exceptionTable.size());

   839             for (ExceptionTableEntry e : exceptionTable) {

   840                                         // u2 start_pc;

   841                 out.writeShort(e.startPc);

   842                                         // u2 end_pc;

   843                 out.writeShort(e.endPc);

   844                                         // u2 handler_pc;

   845                 out.writeShort(e.handlerPc);

   846                                         // u2 catch_type;

   847                 out.writeShort(e.catchType);

   848             }

   849                                         // u2 attributes_count;

   850             out.writeShort(0);

   851 

   852             // write "Exceptions" attribute.  See JVMS section 4.7.4.

   853 

   854                                         // u2 attribute_name_index;

   855             out.writeShort(cp.getUtf8("Exceptions"));

   856                                         // u4 attributes_length;

   857             out.writeInt(2 + 2 * declaredExceptions.length);

   858                                         // u2 number_of_exceptions;

   859             out.writeShort(declaredExceptions.length);

   860                         // u2 exception_index_table[number_of_exceptions];

   861             for (short value : declaredExceptions) {

   862                 out.writeShort(value);

   863             }

   864         }

   865 

   866     }

   867 

   868     /**

   869      * A ProxyMethod object represents a proxy method in the proxy class

   870      * being generated: a method whose implementation will encode and

   871      * dispatch invocations to the proxy instance's invocation handler.

   872      */

   873     private class ProxyMethod {

   874 

   875         public String methodName;

   876         public Class<?>[] parameterTypes;

   877         public Class<?> returnType;

   878         public Class<?>[] exceptionTypes;

   879         public Class<?> fromClass;

   880         public String methodFieldName;

   881 

   882         private ProxyMethod(String methodName, Class<?>[] parameterTypes,

   883                             Class<?> returnType, Class<?>[] exceptionTypes,

   884                             Class<?> fromClass)

   885         {

   886             this.methodName = methodName;

   887             this.parameterTypes = parameterTypes;

   888             this.returnType = returnType;

   889             this.exceptionTypes = exceptionTypes;

   890             this.fromClass = fromClass;

   891             this.methodFieldName = "m" + proxyMethodCount++;

   892         }

   893 

   894         /**

   895          * Return a MethodInfo object for this method, including generating

   896          * the code and exception table entry.

   897          */

   898         private MethodInfo generateMethod() throws IOException {

   899             String desc = getMethodDescriptor(parameterTypes, returnType);

   900             MethodInfo minfo = new MethodInfo(methodName, desc,

   901                 ACC_PUBLIC | ACC_FINAL);

   902 

   903             int[] parameterSlot = new int[parameterTypes.length];

   904             int nextSlot = 1;

   905             for (int i = 0; i < parameterSlot.length; i++) {

   906                 parameterSlot[i] = nextSlot;

   907                 nextSlot += getWordsPerType(parameterTypes[i]);

   908             }

   909             int localSlot0 = nextSlot;

   910             short pc, tryBegin = 0, tryEnd;

   911 

   912             DataOutputStream out = new DataOutputStream(minfo.code);

   913 

   914             code_aload(0, out);

   915 

   916             out.writeByte(opc_getfield);

   917             out.writeShort(cp.getFieldRef(

   918                 superclassName,

   919                 handlerFieldName, "Ljava/lang/reflect/InvocationHandler;"));

   920 

   921             code_aload(0, out);

   922 

   923             out.writeByte(opc_getstatic);

   924             out.writeShort(cp.getFieldRef(

   925                 dotToSlash(className),

   926                 methodFieldName, "Ljava/lang/reflect/Method;"));

   927 

   928             if (parameterTypes.length > 0) {

   929 

   930                 code_ipush(parameterTypes.length, out);

   931 

   932                 out.writeByte(opc_anewarray);

   933                 out.writeShort(cp.getClass("java/lang/Object"));

   934 

   935                 for (int i = 0; i < parameterTypes.length; i++) {

   936 

   937                     out.writeByte(opc_dup);

   938 

   939                     code_ipush(i, out);

   940 

   941                     codeWrapArgument(parameterTypes[i], parameterSlot[i], out);

   942 

   943                     out.writeByte(opc_aastore);

   944                 }

   945             } else {

   946 

   947                 out.writeByte(opc_aconst_null);

   948             }

   949 

   950             out.writeByte(opc_invokeinterface);

   951             out.writeShort(cp.getInterfaceMethodRef(

   952                 "java/lang/reflect/InvocationHandler",

   953                 "invoke",

   954                 "(Ljava/lang/Object;Ljava/lang/reflect/Method;" +

   955                     "[Ljava/lang/Object;)Ljava/lang/Object;"));

   956             out.writeByte(4);

   957             out.writeByte(0);

   958 

   959             if (returnType == void.class) {

   960 

   961                 out.writeByte(opc_pop);

   962 

   963                 out.writeByte(opc_return);

   964 

   965             } else {

   966 

   967                 codeUnwrapReturnValue(returnType, out);

   968             }

   969 

   970             tryEnd = pc = (short) minfo.code.size();

   971 

   972             List<Class<?>> catchList = computeUniqueCatchList(exceptionTypes);

   973             if (catchList.size() > 0) {

   974 

   975                 for (Class<?> ex : catchList) {

   976                     minfo.exceptionTable.add(new ExceptionTableEntry(

   977                         tryBegin, tryEnd, pc,

   978                         cp.getClass(dotToSlash(ex.getName()))));

   979                 }

   980 

   981                 out.writeByte(opc_athrow);

   982 

   983                 pc = (short) minfo.code.size();

   984 

   985                 minfo.exceptionTable.add(new ExceptionTableEntry(

   986                     tryBegin, tryEnd, pc, cp.getClass("java/lang/Throwable")));

   987 

   988                 code_astore(localSlot0, out);

   989 

   990                 out.writeByte(opc_new);

   991                 out.writeShort(cp.getClass(

   992                     "java/lang/reflect/UndeclaredThrowableException"));

   993 

   994                 out.writeByte(opc_dup);

   995 

   996                 code_aload(localSlot0, out);

   997 

   998                 out.writeByte(opc_invokespecial);

   999 

  1000                 out.writeShort(cp.getMethodRef(

  1001                     "java/lang/reflect/UndeclaredThrowableException",

  1002                     "<init>", "(Ljava/lang/Throwable;)V"));

  1003 

  1004                 out.writeByte(opc_athrow);

  1005             }

  1006 

  1007             if (minfo.code.size() > 65535) {

  1008                 throw new IllegalArgumentException("code size limit exceeded");

  1009             }

  1010 

  1011             minfo.maxStack = 10;

  1012             minfo.maxLocals = (short) (localSlot0 + 1);

  1013             minfo.declaredExceptions = new short[exceptionTypes.length];

  1014             for (int i = 0; i < exceptionTypes.length; i++) {

  1015                 minfo.declaredExceptions[i] = cp.getClass(

  1016                     dotToSlash(exceptionTypes[i].getName()));

  1017             }

  1018 

  1019             return minfo;

  1020         }

  1021 

  1022         /**

  1023          * Generate code for wrapping an argument of the given type

  1024          * whose value can be found at the specified local variable

  1025          * index, in order for it to be passed (as an Object) to the

  1026          * invocation handler's "invoke" method.  The code is written

  1027          * to the supplied stream.

  1028          */

  1029         private void codeWrapArgument(Class<?> type, int slot,

  1030                                       DataOutputStream out)

  1031             throws IOException

  1032         {

  1033             if (type.isPrimitive()) {

  1034                 PrimitiveTypeInfo prim = PrimitiveTypeInfo.get(type);

  1035 

  1036                 if (type == int.class ||

  1037                     type == boolean.class ||

  1038                     type == byte.class ||

  1039                     type == char.class ||

  1040                     type == short.class)

  1041                 {

  1042                     code_iload(slot, out);

  1043                 } else if (type == long.class) {

  1044                     code_lload(slot, out);

  1045                 } else if (type == float.class) {

  1046                     code_fload(slot, out);

  1047                 } else if (type == double.class) {

  1048                     code_dload(slot, out);

  1049                 } else {

  1050                     throw new AssertionError();

  1051                 }

  1052 

  1053                 out.writeByte(opc_invokestatic);

  1054                 out.writeShort(cp.getMethodRef(

  1055                     prim.wrapperClassName,

  1056                     "valueOf", prim.wrapperValueOfDesc));

  1057 

  1058             } else {

  1059 

  1060                 code_aload(slot, out);

  1061             }

  1062         }

  1063 

  1064         /**

  1065          * Generate code for unwrapping a return value of the given

  1066          * type from the invocation handler's "invoke" method (as type

  1067          * Object) to its correct type.  The code is written to the

  1068          * supplied stream.

  1069          */

  1070         private void codeUnwrapReturnValue(Class<?> type, DataOutputStream out)

  1071             throws IOException

  1072         {

  1073             if (type.isPrimitive()) {

  1074                 PrimitiveTypeInfo prim = PrimitiveTypeInfo.get(type);

  1075 

  1076                 out.writeByte(opc_checkcast);

  1077                 out.writeShort(cp.getClass(prim.wrapperClassName));

  1078 

  1079                 out.writeByte(opc_invokevirtual);

  1080                 out.writeShort(cp.getMethodRef(

  1081                     prim.wrapperClassName,

  1082                     prim.unwrapMethodName, prim.unwrapMethodDesc));

  1083 

  1084                 if (type == int.class ||

  1085                     type == boolean.class ||

  1086                     type == byte.class ||

  1087                     type == char.class ||

  1088                     type == short.class)

  1089                 {

  1090                     out.writeByte(opc_ireturn);

  1091                 } else if (type == long.class) {

  1092                     out.writeByte(opc_lreturn);

  1093                 } else if (type == float.class) {

  1094                     out.writeByte(opc_freturn);

  1095                 } else if (type == double.class) {

  1096                     out.writeByte(opc_dreturn);

  1097                 } else {

  1098                     throw new AssertionError();

  1099                 }

  1100 

  1101             } else {

  1102 

  1103                 out.writeByte(opc_checkcast);

  1104                 out.writeShort(cp.getClass(dotToSlash(type.getName())));

  1105 

  1106                 out.writeByte(opc_areturn);

  1107             }

  1108         }

  1109 

  1110         /**

  1111          * Generate code for initializing the static field that stores

  1112          * the Method object for this proxy method.  The code is written

  1113          * to the supplied stream.

  1114          */

  1115         private void codeFieldInitialization(DataOutputStream out)

  1116             throws IOException

  1117         {

  1118             codeClassForName(fromClass, out);

  1119 

  1120             code_ldc(cp.getString(methodName), out);

  1121 

  1122             code_ipush(parameterTypes.length, out);

  1123 

  1124             out.writeByte(opc_anewarray);

  1125             out.writeShort(cp.getClass("java/lang/Class"));

  1126 

  1127             for (int i = 0; i < parameterTypes.length; i++) {

  1128 

  1129                 out.writeByte(opc_dup);

  1130 

  1131                 code_ipush(i, out);

  1132 

  1133                 if (parameterTypes[i].isPrimitive()) {

  1134                     PrimitiveTypeInfo prim =

  1135                         PrimitiveTypeInfo.get(parameterTypes[i]);

  1136 

  1137                     out.writeByte(opc_getstatic);

  1138                     out.writeShort(cp.getFieldRef(

  1139                         prim.wrapperClassName, "TYPE", "Ljava/lang/Class;"));

  1140