1 /*

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

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 package java.lang.reflect;

    27 

    28 import java.io.ByteArrayOutputStream;

    29 import java.io.DataOutputStream;

    30 import java.io.File;

    31 import java.io.IOException;

    32 import java.io.OutputStream;

    33 import java.nio.file.Files;

    34 import java.nio.file.Path;

    35 import java.util.ArrayList;

    36 import java.util.HashMap;

    37 import java.util.LinkedHashMap;

    38 import java.util.LinkedList;

    39 import java.util.List;

    40 import java.util.ListIterator;

    41 import java.util.Map;

    42 import sun.security.action.GetBooleanAction;

    43 

    44 /**

    45  * ProxyGenerator contains the code to generate a dynamic proxy class

    46  * for the java.lang.reflect.Proxy API.

    47  *

    48  * The external interfaces to ProxyGenerator is the static

    49  * "generateProxyClass" method.

    50  *

    51  * @author      Peter Jones

    52  * @since       1.3

    53  */

    54 class ProxyGenerator_v49 {

    55     /*

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

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

    58      * version of The Java Language Specification, unless otherwise

    59      * specified.

    60      */

    61 

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

    63     private static final int CLASSFILE_MAJOR_VERSION = 49;

    64     private static final int CLASSFILE_MINOR_VERSION = 0;

    65 

    66     /*

    67      * beginning of constants copied from

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

    69      */

    70 

    71     /* constant pool tags */

    72     private static final int CONSTANT_UTF8              = 1;

    73     private static final int CONSTANT_UNICODE           = 2;

    74     private static final int CONSTANT_INTEGER           = 3;

    75     private static final int CONSTANT_FLOAT             = 4;

    76     private static final int CONSTANT_LONG              = 5;

    77     private static final int CONSTANT_DOUBLE            = 6;

    78     private static final int CONSTANT_CLASS             = 7;

    79     private static final int CONSTANT_STRING            = 8;

    80     private static final int CONSTANT_FIELD             = 9;

    81     private static final int CONSTANT_METHOD            = 10;

    82     private static final int CONSTANT_INTERFACEMETHOD   = 11;

    83     private static final int CONSTANT_NAMEANDTYPE       = 12;

    84 

    85     /* access and modifier flags */

    86     private static final int ACC_PUBLIC                 = 0x00000001;

    87     private static final int ACC_PRIVATE                = 0x00000002;

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

    89     private static final int ACC_STATIC                 = 0x00000008;

    90     private static final int ACC_FINAL                  = 0x00000010;

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

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

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

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

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

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

    97     private static final int ACC_SUPER                  = 0x00000020;

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

    99 

   100     /* opcodes */

   101 //  private static final int opc_nop                    = 0;

   102     private static final int opc_aconst_null            = 1;

   103 //  private static final int opc_iconst_m1              = 2;

   104     private static final int opc_iconst_0               = 3;

   105 //  private static final int opc_iconst_1               = 4;

   106 //  private static final int opc_iconst_2               = 5;

   107 //  private static final int opc_iconst_3               = 6;

   108 //  private static final int opc_iconst_4               = 7;

   109 //  private static final int opc_iconst_5               = 8;

   110 //  private static final int opc_lconst_0               = 9;

   111 //  private static final int opc_lconst_1               = 10;

   112 //  private static final int opc_fconst_0               = 11;

   113 //  private static final int opc_fconst_1               = 12;

   114 //  private static final int opc_fconst_2               = 13;

   115 //  private static final int opc_dconst_0               = 14;

   116 //  private static final int opc_dconst_1               = 15;

   117     private static final int opc_bipush                 = 16;

   118     private static final int opc_sipush                 = 17;

   119     private static final int opc_ldc                    = 18;

   120     private static final int opc_ldc_w                  = 19;

   121 //  private static final int opc_ldc2_w                 = 20;

   122     private static final int opc_iload                  = 21;

   123     private static final int opc_lload                  = 22;

   124     private static final int opc_fload                  = 23;

   125     private static final int opc_dload                  = 24;

   126     private static final int opc_aload                  = 25;

   127     private static final int opc_iload_0                = 26;

   128 //  private static final int opc_iload_1                = 27;

   129 //  private static final int opc_iload_2                = 28;

   130 //  private static final int opc_iload_3                = 29;

   131     private static final int opc_lload_0                = 30;

   132 //  private static final int opc_lload_1                = 31;

   133 //  private static final int opc_lload_2                = 32;

   134 //  private static final int opc_lload_3                = 33;

   135     private static final int opc_fload_0                = 34;

   136 //  private static final int opc_fload_1                = 35;

   137 //  private static final int opc_fload_2                = 36;

   138 //  private static final int opc_fload_3                = 37;

   139     private static final int opc_dload_0                = 38;

   140 //  private static final int opc_dload_1                = 39;

   141 //  private static final int opc_dload_2                = 40;

   142 //  private static final int opc_dload_3                = 41;

   143     private static final int opc_aload_0                = 42;

   144 //  private static final int opc_aload_1                = 43;

   145 //  private static final int opc_aload_2                = 44;

   146 //  private static final int opc_aload_3                = 45;

   147 //  private static final int opc_iaload                 = 46;

   148 //  private static final int opc_laload                 = 47;

   149 //  private static final int opc_faload                 = 48;

   150 //  private static final int opc_daload                 = 49;

   151 //  private static final int opc_aaload                 = 50;

   152 //  private static final int opc_baload                 = 51;

   153 //  private static final int opc_caload                 = 52;

   154 //  private static final int opc_saload                 = 53;

   155 //  private static final int opc_istore                 = 54;

   156 //  private static final int opc_lstore                 = 55;

   157 //  private static final int opc_fstore                 = 56;

   158 //  private static final int opc_dstore                 = 57;

   159     private static final int opc_astore                 = 58;

   160 //  private static final int opc_istore_0               = 59;

   161 //  private static final int opc_istore_1               = 60;

   162 //  private static final int opc_istore_2               = 61;

   163 //  private static final int opc_istore_3               = 62;

   164 //  private static final int opc_lstore_0               = 63;

   165 //  private static final int opc_lstore_1               = 64;

   166 //  private static final int opc_lstore_2               = 65;

   167 //  private static final int opc_lstore_3               = 66;

   168 //  private static final int opc_fstore_0               = 67;

   169 //  private static final int opc_fstore_1               = 68;

   170 //  private static final int opc_fstore_2               = 69;

   171 //  private static final int opc_fstore_3               = 70;

   172 //  private static final int opc_dstore_0               = 71;

   173 //  private static final int opc_dstore_1               = 72;

   174 //  private static final int opc_dstore_2               = 73;

   175 //  private static final int opc_dstore_3               = 74;

   176     private static final int opc_astore_0               = 75;

   177 //  private static final int opc_astore_1               = 76;

   178 //  private static final int opc_astore_2               = 77;

   179 //  private static final int opc_astore_3               = 78;

   180 //  private static final int opc_iastore                = 79;

   181 //  private static final int opc_lastore                = 80;

   182 //  private static final int opc_fastore                = 81;

   183 //  private static final int opc_dastore                = 82;

   184     private static final int opc_aastore                = 83;

   185 //  private static final int opc_bastore                = 84;

   186 //  private static final int opc_castore                = 85;

   187 //  private static final int opc_sastore                = 86;

   188     private static final int opc_pop                    = 87;

   189 //  private static final int opc_pop2                   = 88;

   190     private static final int opc_dup                    = 89;

   191 //  private static final int opc_dup_x1                 = 90;

   192 //  private static final int opc_dup_x2                 = 91;

   193 //  private static final int opc_dup2                   = 92;

   194 //  private static final int opc_dup2_x1                = 93;

   195 //  private static final int opc_dup2_x2                = 94;

   196 //  private static final int opc_swap                   = 95;

   197 //  private static final int opc_iadd                   = 96;

   198 //  private static final int opc_ladd                   = 97;

   199 //  private static final int opc_fadd                   = 98;

   200 //  private static final int opc_dadd                   = 99;

   201 //  private static final int opc_isub                   = 100;

   202 //  private static final int opc_lsub                   = 101;

   203 //  private static final int opc_fsub                   = 102;

   204 //  private static final int opc_dsub                   = 103;

   205 //  private static final int opc_imul                   = 104;

   206 //  private static final int opc_lmul                   = 105;

   207 //  private static final int opc_fmul                   = 106;

   208 //  private static final int opc_dmul                   = 107;

   209 //  private static final int opc_idiv                   = 108;

   210 //  private static final int opc_ldiv                   = 109;

   211 //  private static final int opc_fdiv                   = 110;

   212 //  private static final int opc_ddiv                   = 111;

   213 //  private static final int opc_irem                   = 112;

   214 //  private static final int opc_lrem                   = 113;

   215 //  private static final int opc_frem                   = 114;

   216 //  private static final int opc_drem                   = 115;

   217 //  private static final int opc_ineg                   = 116;

   218 //  private static final int opc_lneg                   = 117;

   219 //  private static final int opc_fneg                   = 118;

   220 //  private static final int opc_dneg                   = 119;

   221 //  private static final int opc_ishl                   = 120;

   222 //  private static final int opc_lshl                   = 121;

   223 //  private static final int opc_ishr                   = 122;

   224 //  private static final int opc_lshr                   = 123;

   225 //  private static final int opc_iushr                  = 124;

   226 //  private static final int opc_lushr                  = 125;

   227 //  private static final int opc_iand                   = 126;

   228 //  private static final int opc_land                   = 127;

   229 //  private static final int opc_ior                    = 128;

   230 //  private static final int opc_lor                    = 129;

   231 //  private static final int opc_ixor                   = 130;

   232 //  private static final int opc_lxor                   = 131;

   233 //  private static final int opc_iinc                   = 132;

   234 //  private static final int opc_i2l                    = 133;

   235 //  private static final int opc_i2f                    = 134;

   236 //  private static final int opc_i2d                    = 135;

   237 //  private static final int opc_l2i                    = 136;

   238 //  private static final int opc_l2f                    = 137;

   239 //  private static final int opc_l2d                    = 138;

   240 //  private static final int opc_f2i                    = 139;

   241 //  private static final int opc_f2l                    = 140;

   242 //  private static final int opc_f2d                    = 141;

   243 //  private static final int opc_d2i                    = 142;

   244 //  private static final int opc_d2l                    = 143;

   245 //  private static final int opc_d2f                    = 144;

   246 //  private static final int opc_i2b                    = 145;

   247 //  private static final int opc_i2c                    = 146;

   248 //  private static final int opc_i2s                    = 147;

   249 //  private static final int opc_lcmp                   = 148;

   250 //  private static final int opc_fcmpl                  = 149;

   251 //  private static final int opc_fcmpg                  = 150;

   252 //  private static final int opc_dcmpl                  = 151;

   253 //  private static final int opc_dcmpg                  = 152;

   254 //  private static final int opc_ifeq                   = 153;

   255 //  private static final int opc_ifne                   = 154;

   256 //  private static final int opc_iflt                   = 155;

   257 //  private static final int opc_ifge                   = 156;

   258 //  private static final int opc_ifgt                   = 157;

   259 //  private static final int opc_ifle                   = 158;

   260 //  private static final int opc_if_icmpeq              = 159;

   261 //  private static final int opc_if_icmpne              = 160;

   262 //  private static final int opc_if_icmplt              = 161;

   263 //  private static final int opc_if_icmpge              = 162;

   264 //  private static final int opc_if_icmpgt              = 163;

   265 //  private static final int opc_if_icmple              = 164;

   266 //  private static final int opc_if_acmpeq              = 165;

   267 //  private static final int opc_if_acmpne              = 166;

   268 //  private static final int opc_goto                   = 167;

   269 //  private static final int opc_jsr                    = 168;

   270 //  private static final int opc_ret                    = 169;

   271 //  private static final int opc_tableswitch            = 170;

   272 //  private static final int opc_lookupswitch           = 171;

   273     private static final int opc_ireturn                = 172;

   274     private static final int opc_lreturn                = 173;

   275     private static final int opc_freturn                = 174;

   276     private static final int opc_dreturn                = 175;

   277     private static final int opc_areturn                = 176;

   278     private static final int opc_return                 = 177;

   279     private static final int opc_getstatic              = 178;

   280     private static final int opc_putstatic              = 179;

   281     private static final int opc_getfield               = 180;

   282 //  private static final int opc_putfield               = 181;

   283     private static final int opc_invokevirtual          = 182;

   284     private static final int opc_invokespecial          = 183;

   285     private static final int opc_invokestatic           = 184;

   286     private static final int opc_invokeinterface        = 185;

   287     private static final int opc_new                    = 187;

   288 //  private static final int opc_newarray               = 188;

   289     private static final int opc_anewarray              = 189;

   290 //  private static final int opc_arraylength            = 190;

   291     private static final int opc_athrow                 = 191;

   292     private static final int opc_checkcast              = 192;

   293 //  private static final int opc_instanceof             = 193;

   294 //  private static final int opc_monitorenter           = 194;

   295 //  private static final int opc_monitorexit            = 195;

   296     private static final int opc_wide                   = 196;

   297 //  private static final int opc_multianewarray         = 197;

   298 //  private static final int opc_ifnull                 = 198;

   299 //  private static final int opc_ifnonnull              = 199;

   300 //  private static final int opc_goto_w                 = 200;

   301 //  private static final int opc_jsr_w                  = 201;

   302 

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

   304 

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

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

   307 

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

   309     private static final String handlerFieldName = "h";

   310 

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

   312     private static final boolean saveGeneratedFiles =

   313         java.security.AccessController.doPrivileged(

   314             new GetBooleanAction(

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

   316 

   317     /**

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

   319      */

   320     static byte[] generateProxyClass(final String name,

   321                                      List<Class<?>> interfaces) {

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

   323     }

   324 

   325     /**

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

   327      *

   328      * @param name        the class name of the proxy class

   329      * @param interfaces  proxy interfaces

   330      * @param accessFlags access flags of the proxy class

   331     */

   332     static byte[] generateProxyClass(final String name,

   333                                      List<Class<?>> interfaces,

   334                                      int accessFlags)

   335     {

   336         ProxyGenerator_v49 gen = new ProxyGenerator_v49(name, interfaces, accessFlags);

   337         final byte[] classFile = gen.generateClassFile();

   338 

   339         if (saveGeneratedFiles) {

   340             java.security.AccessController.doPrivileged(

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

   342                 public Void run() {

   343                     try {

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

   345                         Path path;

   346                         if (i > 0) {

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

   348                             Files.createDirectories(dir);

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

   350                         } else {

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

   352                         }

   353                         Files.write(path, classFile);

   354                         return null;

   355                     } catch (IOException e) {

   356                         throw new InternalError(

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

   358                     }

   359                 }

   360             });

   361         }

   362 

   363         return classFile;

   364     }

   365 

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

   367     private static Method hashCodeMethod;

   368     private static Method equalsMethod;

   369     private static Method toStringMethod;

   370     static {

   371         try {

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

   373             equalsMethod =

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

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

   376         } catch (NoSuchMethodException e) {

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

   378         }

   379     }

   380 

   381     /** name of proxy class */

   382     private String className;

   383 

   384     /** proxy interfaces */

   385     private List<Class<?>> interfaces;

   386 

   387     /** proxy class access flags */

   388     private int accessFlags;

   389 

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

   391     private ConstantPool cp = new ConstantPool();

   392 

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

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

   395 

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

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

   398 

   399     /**

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

   401      * proxy methods with that signature

   402      */

   403     private Map<String, List<ProxyMethod>> proxyMethods = new LinkedHashMap<>();

   404 

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

   406     private int proxyMethodCount = 0;

   407 

   408     /**

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

   410      * specified name and for the given interfaces.

   411      *

   412      * A ProxyGenerator object contains the state for the ongoing

   413      * generation of a particular proxy class.

   414      */

   415     ProxyGenerator_v49(String className, List<Class<?>> interfaces, int accessFlags) {

   416         this.className = className;

   417         this.interfaces = interfaces;

   418         this.accessFlags = accessFlags;

   419     }

   420 

   421     /**

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

   423      * class file generation process.

   424      */

   425     private byte[] generateClassFile() {

   426 

   427         /* ============================================================

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

   429          * generate proxy dispatching code for.

   430          */

   431 

   432         /*

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

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

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

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

   437          * proxy interfaces.

   438          */

   439         addProxyMethod(hashCodeMethod, Object.class);

   440         addProxyMethod(equalsMethod, Object.class);

   441         addProxyMethod(toStringMethod, Object.class);

   442 

   443         /*

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

   445          * earlier interfaces precedence over later ones with duplicate

   446          * methods.

   447          */

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

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

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

   451                     addProxyMethod(m, intf);

   452                 }

   453             }

   454         }

   455 

   456         /*

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

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

   459          */

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

   461             checkReturnTypes(sigmethods);

   462         }

   463 

   464         /* ============================================================

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

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

   467          */

   468         try {

   469             methods.add(generateConstructor());

   470 

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

   472                 for (ProxyMethod pm : sigmethods) {

   473 

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

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

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

   477                          ACC_PRIVATE | ACC_STATIC));

   478 

   479                     // generate code for proxy method and add it

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

   481                 }

   482             }

   483 

   484             methods.add(generateStaticInitializer());

   485 

   486         } catch (IOException e) {

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

   488         }

   489 

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

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

   492         }

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

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

   495         }

   496 

   497         /* ============================================================

   498          * Step 3: Write the final class file.

   499          */

   500 

   501         /*

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

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

   504          */

   505         cp.getClass(dotToSlash(className));

   506         cp.getClass(superclassName);

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

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

   509         }

   510 

   511         /*

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

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

   514          */

   515         cp.setReadOnly();

   516 

   517         ByteArrayOutputStream bout = new ByteArrayOutputStream();

   518         DataOutputStream dout = new DataOutputStream(bout);

   519 

   520         try {

   521             /*

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

   523              * See JVMS section 4.1.

   524              */

   525                                         // u4 magic;

   526             dout.writeInt(0xCAFEBABE);

   527                                         // u2 minor_version;

   528             dout.writeShort(CLASSFILE_MINOR_VERSION);

   529                                         // u2 major_version;

   530             dout.writeShort(CLASSFILE_MAJOR_VERSION);

   531 

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

   533 

   534                                         // u2 access_flags;

   535             dout.writeShort(accessFlags);

   536                                         // u2 this_class;

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

   538                                         // u2 super_class;

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

   540 

   541                                         // u2 interfaces_count;

   542             dout.writeShort(interfaces.size());

   543                                         // u2 interfaces[interfaces_count];

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

   545                 dout.writeShort(cp.getClass(

   546                     dotToSlash(intf.getName())));

   547             }

   548 

   549                                         // u2 fields_count;

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

   551                                         // field_info fields[fields_count];

   552             for (FieldInfo f : fields) {

   553                 f.write(dout);

   554             }

   555 

   556                                         // u2 methods_count;

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

   558                                         // method_info methods[methods_count];

   559             for (MethodInfo m : methods) {

   560                 m.write(dout);

   561             }

   562 

   563                                          // u2 attributes_count;

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

   565 

   566         } catch (IOException e) {

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

   568         }

   569 

   570         return bout.toByteArray();

   571     }

   572 

   573     /**

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

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

   576      * method.

   577      *

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

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

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

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

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

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

   584      * set of duplicate methods.

   585      */

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

   587         String name = m.getName();

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

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

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

   591 

   592         String sig = name + getParameterDescriptors(parameterTypes);

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

   594         if (sigmethods != null) {

   595             for (ProxyMethod pm : sigmethods) {

   596                 if (returnType == pm.returnType) {

   597                     /*

   598                      * Found a match: reduce exception types to the

   599                      * greatest set of exceptions that can thrown

   600                      * compatibly with the throws clauses of both

   601                      * overridden methods.

   602                      */

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

   604                     collectCompatibleTypes(

   605                         exceptionTypes, pm.exceptionTypes, legalExceptions);

   606                     collectCompatibleTypes(

   607                         pm.exceptionTypes, exceptionTypes, legalExceptions);

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

   609                     pm.exceptionTypes =

   610                         legalExceptions.toArray(pm.exceptionTypes);

   611                     return;

   612                 }

   613             }

   614         } else {

   615             sigmethods = new ArrayList<>(3);

   616             proxyMethods.put(sig, sigmethods);

   617         }

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

   619                                        exceptionTypes, fromClass));

   620     }

   621 

   622     /**

   623      * For a given set of proxy methods with the same signature, check

   624      * that their return types are compatible according to the Proxy

   625      * specification.

   626      *

   627      * Specifically, if there is more than one such method, then all

   628      * of the return types must be reference types, and there must be

   629      * one return type that is assignable to each of the rest of them.

   630      */

   631     private static void checkReturnTypes(List<ProxyMethod> methods) {

   632         /*

   633          * If there is only one method with a given signature, there

   634          * cannot be a conflict.  This is the only case in which a

   635          * primitive (or void) return type is allowed.

   636          */

   637         if (methods.size() < 2) {

   638             return;

   639         }

   640 

   641         /*

   642          * List of return types that are not yet known to be

   643          * assignable from ("covered" by) any of the others.

   644          */

   645         LinkedList<Class<?>> uncoveredReturnTypes = new LinkedList<>();

   646 

   647     nextNewReturnType:

   648         for (ProxyMethod pm : methods) {

   649             Class<?> newReturnType = pm.returnType;

   650             if (newReturnType.isPrimitive()) {

   651                 throw new IllegalArgumentException(

   652                     "methods with same signature " +

   653                     getFriendlyMethodSignature(pm.methodName,

   654                                                pm.parameterTypes) +

   655                     " but incompatible return types: " +

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

   657             }

   658             boolean added = false;

   659 

   660             /*

   661              * Compare the new return type to the existing uncovered

   662              * return types.

   663              */

   664             ListIterator<Class<?>> liter = uncoveredReturnTypes.listIterator();

   665             while (liter.hasNext()) {

   666                 Class<?> uncoveredReturnType = liter.next();

   667 

   668                 /*

   669                  * If an existing uncovered return type is assignable

   670                  * to this new one, then we can forget the new one.

   671                  */

   672                 if (newReturnType.isAssignableFrom(uncoveredReturnType)) {

   673                     assert !added;

   674                     continue nextNewReturnType;

   675                 }

   676 

   677                 /*

   678                  * If the new return type is assignable to an existing

   679                  * uncovered one, then should replace the existing one

   680                  * with the new one (or just forget the existing one,

   681                  * if the new one has already be put in the list).

   682                  */

   683                 if (uncoveredReturnType.isAssignableFrom(newReturnType)) {

   684                     // (we can assume that each return type is unique)

   685                     if (!added) {

   686                         liter.set(newReturnType);

   687                         added = true;

   688                     } else {

   689                         liter.remove();

   690                     }

   691                 }

   692             }

   693 

   694             /*

   695              * If we got through the list of existing uncovered return

   696              * types without an assignability relationship, then add

   697              * the new return type to the list of uncovered ones.

   698              */

   699             if (!added) {

   700                 uncoveredReturnTypes.add(newReturnType);

   701             }

   702         }

   703 

   704         /*

   705          * We shouldn't end up with more than one return type that is

   706          * not assignable from any of the others.

   707          */

   708         if (uncoveredReturnTypes.size() > 1) {

   709             ProxyMethod pm = methods.get(0);

   710             throw new IllegalArgumentException(

   711                 "methods with same signature " +

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

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

   714         }

   715     }

   716 

   717     /**

   718      * A FieldInfo object contains information about a particular field

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

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

   721      */

   722     private class FieldInfo {

   723         public int accessFlags;

   724         public String name;

   725         public String descriptor;

   726 

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

   728             this.name = name;

   729             this.descriptor = descriptor;

   730             this.accessFlags = accessFlags;

   731 

   732             /*

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

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

   735              */

   736             cp.getUtf8(name);

   737             cp.getUtf8(descriptor);

   738         }

   739 

   740         public void write(DataOutputStream out) throws IOException {

   741             /*

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

   743              * See JVMS section 4.5.

   744              */

   745                                         // u2 access_flags;

   746             out.writeShort(accessFlags);

   747                                         // u2 name_index;

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

   749                                         // u2 descriptor_index;

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

   751                                         // u2 attributes_count;

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

   753         }

   754     }

   755 

   756     /**

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

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

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

   760      */

   761     private static class ExceptionTableEntry {

   762         public short startPc;

   763         public short endPc;

   764         public short handlerPc;

   765         public short catchType;

   766 

   767         public ExceptionTableEntry(short startPc, short endPc,

   768                                    short handlerPc, short catchType)

   769         {

   770             this.startPc = startPc;

   771             this.endPc = endPc;

   772             this.handlerPc = handlerPc;

   773             this.catchType = catchType;

   774         }

   775     };

   776 

   777     /**

   778      * A MethodInfo object contains information about a particular method

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

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

   781      */

   782     private class MethodInfo {

   783         public int accessFlags;

   784         public String name;

   785         public String descriptor;

   786         public short maxStack;

   787         public short maxLocals;

   788         public ByteArrayOutputStream code = new ByteArrayOutputStream();

   789         public List<ExceptionTableEntry> exceptionTable =

   790             new ArrayList<ExceptionTableEntry>();

   791         public short[] declaredExceptions;

   792 

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

   794             this.name = name;

   795             this.descriptor = descriptor;

   796             this.accessFlags = accessFlags;

   797 

   798             /*

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

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

   801              */

   802             cp.getUtf8(name);

   803             cp.getUtf8(descriptor);

   804             cp.getUtf8("Code");

   805             cp.getUtf8("Exceptions");

   806         }

   807 

   808         public void write(DataOutputStream out) throws IOException {

   809             /*

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

   811              * See JVMS section 4.6.

   812              */

   813                                         // u2 access_flags;

   814             out.writeShort(accessFlags);

   815                                         // u2 name_index;

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

   817                                         // u2 descriptor_index;

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

   819                                         // u2 attributes_count;

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

   821 

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

   823 

   824                                         // u2 attribute_name_index;

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

   826                                         // u4 attribute_length;

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

   828                                         // u2 max_stack;

   829             out.writeShort(maxStack);

   830                                         // u2 max_locals;

   831             out.writeShort(maxLocals);

   832                                         // u2 code_length;

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

   834                                         // u1 code[code_length];

   835             code.writeTo(out);

   836                                         // u2 exception_table_length;

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

   838             for (ExceptionTableEntry e : exceptionTable) {

   839                                         // u2 start_pc;

   840                 out.writeShort(e.startPc);

   841                                         // u2 end_pc;

   842                 out.writeShort(e.endPc);

   843                                         // u2 handler_pc;

   844                 out.writeShort(e.handlerPc);

   845                                         // u2 catch_type;

   846                 out.writeShort(e.catchType);

   847             }

   848                                         // u2 attributes_count;

   849             out.writeShort(0);

   850 

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

   852 

   853                                         // u2 attribute_name_index;

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

   855                                         // u4 attributes_length;

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

   857                                         // u2 number_of_exceptions;

   858             out.writeShort(declaredExceptions.length);

   859                         // u2 exception_index_table[number_of_exceptions];

   860             for (short value : declaredExceptions) {

   861                 out.writeShort(value);

   862             }

   863         }

   864 

   865     }

   866 

   867     /**

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

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

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

   871      */

   872     private class ProxyMethod {

   873 

   874         public String methodName;

   875         public Class<?>[] parameterTypes;

   876         public Class<?> returnType;

   877         public Class<?>[] exceptionTypes;

   878         public Class<?> fromClass;

   879         public String methodFieldName;

   880 

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

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

   883                             Class<?> fromClass)

   884         {

   885             this.methodName = methodName;

   886             this.parameterTypes = parameterTypes;

   887             this.returnType = returnType;

   888             this.exceptionTypes = exceptionTypes;

   889             this.fromClass = fromClass;

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

   891         }

   892 

   893         /**

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

   895          * the code and exception table entry.

   896          */

   897         private MethodInfo generateMethod() throws IOException {

   898             String desc = getMethodDescriptor(parameterTypes, returnType);

   899             MethodInfo minfo = new MethodInfo(methodName, desc,

   900                 ACC_PUBLIC | ACC_FINAL);

   901 

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

   903             int nextSlot = 1;

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

   905                 parameterSlot[i] = nextSlot;

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

   907             }

   908             int localSlot0 = nextSlot;

   909             short pc, tryBegin = 0, tryEnd;

   910 

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

   912 

   913             code_aload(0, out);

   914 

   915             out.writeByte(opc_getfield);

   916             out.writeShort(cp.getFieldRef(

   917                 superclassName,

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

   919 

   920             code_aload(0, out);

   921 

   922             out.writeByte(opc_getstatic);

   923             out.writeShort(cp.getFieldRef(

   924                 dotToSlash(className),

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

   926 

   927             if (parameterTypes.length > 0) {

   928 

   929                 code_ipush(parameterTypes.length, out);

   930 

   931                 out.writeByte(opc_anewarray);

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

   933 

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

   935 

   936                     out.writeByte(opc_dup);

   937 

   938                     code_ipush(i, out);

   939 

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

   941 

   942                     out.writeByte(opc_aastore);

   943                 }

   944             } else {

   945 

   946                 out.writeByte(opc_aconst_null);

   947             }

   948 

   949             out.writeByte(opc_invokeinterface);

   950             out.writeShort(cp.getInterfaceMethodRef(

   951                 "java/lang/reflect/InvocationHandler",

   952                 "invoke",

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

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

   955             out.writeByte(4);

   956             out.writeByte(0);

   957 

   958             if (returnType == void.class) {

   959 

   960                 out.writeByte(opc_pop);

   961 

   962                 out.writeByte(opc_return);

   963 

   964             } else {

   965 

   966                 codeUnwrapReturnValue(returnType, out);

   967             }

   968 

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

   970 

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

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

   973 

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

   975                     minfo.exceptionTable.add(new ExceptionTableEntry(

   976                         tryBegin, tryEnd, pc,

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

   978                 }

   979 

   980                 out.writeByte(opc_athrow);

   981 

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

   983 

   984                 minfo.exceptionTable.add(new ExceptionTableEntry(

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

   986 

   987                 code_astore(localSlot0, out);

   988 

   989                 out.writeByte(opc_new);

   990                 out.writeShort(cp.getClass(

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

   992 

   993                 out.writeByte(opc_dup);

   994 

   995                 code_aload(localSlot0, out);

   996 

   997                 out.writeByte(opc_invokespecial);

   998 

   999                 out.writeShort(cp.getMethodRef(

  1000                     "java/lang/reflect/UndeclaredThrowableException",

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

  1002 

  1003                 out.writeByte(opc_athrow);

  1004             }

  1005 

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

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

  1008             }

  1009 

  1010             minfo.maxStack = 10;

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

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

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

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

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

  1016             }

  1017 

  1018             return minfo;

  1019         }

  1020 

  1021         /**

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

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

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

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

  1026          * to the supplied stream.

  1027          */

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

  1029                                       DataOutputStream out)

  1030             throws IOException

  1031         {

  1032             if (type.isPrimitive()) {

  1033                 PrimitiveTypeInfo prim = PrimitiveTypeInfo.get(type);

  1034 

  1035                 if (type == int.class ||

  1036                     type == boolean.class ||

  1037                     type == byte.class ||

  1038                     type == char.class ||

  1039                     type == short.class)

  1040                 {

  1041                     code_iload(slot, out);

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

  1043                     code_lload(slot, out);

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

  1045                     code_fload(slot, out);

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

  1047                     code_dload(slot, out);

  1048                 } else {

  1049                     throw new AssertionError();

  1050                 }

  1051 

  1052                 out.writeByte(opc_invokestatic);

  1053                 out.writeShort(cp.getMethodRef(

  1054                     prim.wrapperClassName,

  1055                     "valueOf", prim.wrapperValueOfDesc));

  1056 

  1057             } else {

  1058 

  1059                 code_aload(slot, out);

  1060             }

  1061         }

  1062 

  1063         /**

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

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

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

  1067          * supplied stream.

  1068          */

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

  1070             throws IOException

  1071         {

  1072             if (type.isPrimitive()) {

  1073                 PrimitiveTypeInfo prim = PrimitiveTypeInfo.get(type);

  1074 

  1075                 out.writeByte(opc_checkcast);

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

  1077 

  1078                 out.writeByte(opc_invokevirtual);

  1079                 out.writeShort(cp.getMethodRef(

  1080                     prim.wrapperClassName,

  1081                     prim.unwrapMethodName, prim.unwrapMethodDesc));

  1082 

  1083                 if (type == int.class ||

  1084                     type == boolean.class ||

  1085                     type == byte.class ||

  1086                     type == char.class ||

  1087                     type == short.class)

  1088                 {

  1089                     out.writeByte(opc_ireturn);

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

  1091                     out.writeByte(opc_lreturn);

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

  1093                     out.writeByte(opc_freturn);

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

  1095                     out.writeByte(opc_dreturn);

  1096                 } else {

  1097                     throw new AssertionError();

  1098                 }

  1099 

  1100             } else {

  1101 

  1102                 out.writeByte(opc_checkcast);

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

  1104 

  1105                 out.writeByte(opc_areturn);

  1106             }

  1107         }

  1108 

  1109         /**

  1110          * Generate code for initializing the static field that stores

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

  1112          * to the supplied stream.

  1113          */

  1114         private void codeFieldInitialization(DataOutputStream out)

  1115             throws IOException

  1116         {

  1117             codeClassForName(fromClass, out);

  1118 

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

  1120 

  1121             code_ipush(parameterTypes.length, out);

  1122 

  1123             out.writeByte(opc_anewarray);

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

  1125 

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

  1127 

  1128                 out.writeByte(opc_dup);

  1129 

  1130                 code_ipush(i, out);

  1131 

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

  1133                     PrimitiveTypeInfo prim =

  1134                         PrimitiveTypeInfo.get(parameterTypes[i]);

  1135