1 /*
   2  * Copyright (c) 2001, 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 jdk.internal.reflect;
  27 
  28 import java.io.Externalizable;
  29 import java.io.ObjectInputStream;
  30 import java.io.ObjectOutputStream;
  31 import java.io.ObjectStreamClass;
  32 import java.io.OptionalDataException;
  33 import java.io.Serializable;
  34 import java.lang.invoke.MethodHandle;
  35 import java.lang.invoke.MethodHandles;
  36 import java.lang.reflect.Field;
  37 import java.lang.reflect.Executable;
  38 import java.lang.reflect.InvocationTargetException;
  39 import java.lang.reflect.Method;
  40 import java.lang.reflect.Constructor;
  41 import java.lang.reflect.Modifier;
  42 import java.security.PrivilegedAction;
  43 import java.util.Objects;
  44 import java.util.Properties;
  45 
  46 import jdk.internal.misc.VM;
  47 import sun.reflect.misc.ReflectUtil;
  48 import sun.security.action.GetPropertyAction;
  49 import sun.security.util.SecurityConstants;
  50 
  51 /** <P> The master factory for all reflective objects, both those in
  52     java.lang.reflect (Fields, Methods, Constructors) as well as their
  53     delegates (FieldAccessors, MethodAccessors, ConstructorAccessors).
  54     </P>
  55 
  56     <P> The methods in this class are extremely unsafe and can cause
  57     subversion of both the language and the verifier. For this reason,
  58     they are all instance methods, and access to the constructor of
  59     this factory is guarded by a security check, in similar style to
  60     {@link jdk.internal.misc.Unsafe}. </P>
  61 */
  62 
  63 public class ReflectionFactory {
  64 
  65     private static boolean initted = false;
  66     private static final ReflectionFactory soleInstance = new ReflectionFactory();
  67     // Provides access to package-private mechanisms in java.lang.reflect
  68     private static volatile LangReflectAccess langReflectAccess;
  69 
  70     /* Method for static class initializer <clinit>, or null */
  71     private static volatile Method hasStaticInitializerMethod;
  72 
  73     //
  74     // "Inflation" mechanism. Loading bytecodes to implement
  75     // Method.invoke() and Constructor.newInstance() currently costs
  76     // 3-4x more than an invocation via native code for the first
  77     // invocation (though subsequent invocations have been benchmarked
  78     // to be over 20x faster). Unfortunately this cost increases
  79     // startup time for certain applications that use reflection
  80     // intensively (but only once per class) to bootstrap themselves.
  81     // To avoid this penalty we reuse the existing JVM entry points
  82     // for the first few invocations of Methods and Constructors and
  83     // then switch to the bytecode-based implementations.
  84     //
  85     // Package-private to be accessible to NativeMethodAccessorImpl
  86     // and NativeConstructorAccessorImpl
  87     private static boolean noInflation        = false;
  88     private static int     inflationThreshold = 15;
  89 
  90     // true if deserialization constructor checking is disabled
  91     private static boolean disableSerialConstructorChecks = false;
  92 
  93     private ReflectionFactory() {
  94     }
  95 
  96     /**
  97      * A convenience class for acquiring the capability to instantiate
  98      * reflective objects.  Use this instead of a raw call to {@link
  99      * #getReflectionFactory} in order to avoid being limited by the
 100      * permissions of your callers.
 101      *
 102      * <p>An instance of this class can be used as the argument of
 103      * <code>AccessController.doPrivileged</code>.
 104      */
 105     public static final class GetReflectionFactoryAction
 106         implements PrivilegedAction<ReflectionFactory> {
 107         public ReflectionFactory run() {
 108             return getReflectionFactory();
 109         }
 110     }
 111 
 112     /**
 113      * Provides the caller with the capability to instantiate reflective
 114      * objects.
 115      *
 116      * <p> First, if there is a security manager, its
 117      * <code>checkPermission</code> method is called with a {@link
 118      * java.lang.RuntimePermission} with target
 119      * <code>"reflectionFactoryAccess"</code>.  This may result in a
 120      * security exception.
 121      *
 122      * <p> The returned <code>ReflectionFactory</code> object should be
 123      * carefully guarded by the caller, since it can be used to read and
 124      * write private data and invoke private methods, as well as to load
 125      * unverified bytecodes.  It must never be passed to untrusted code.
 126      *
 127      * @exception SecurityException if a security manager exists and its
 128      *             <code>checkPermission</code> method doesn't allow
 129      *             access to the RuntimePermission "reflectionFactoryAccess".  */
 130     public static ReflectionFactory getReflectionFactory() {
 131         SecurityManager security = System.getSecurityManager();
 132         if (security != null) {
 133             security.checkPermission(
 134                 SecurityConstants.REFLECTION_FACTORY_ACCESS_PERMISSION);
 135         }
 136         return soleInstance;
 137     }
 138 
 139     /**
 140      * Returns an alternate reflective Method instance for the given method
 141      * intended for reflection to invoke, if present.
 142      *
 143      * A trusted method can define an alternate implementation for a method `foo`
 144      * by defining a method named "reflected$foo" that will be invoked
 145      * reflectively.
 146      */
 147     private static Method findMethodForReflection(Method method) {
 148         String altName = "reflected$" + method.getName();
 149         try {
 150            return method.getDeclaringClass()
 151                         .getDeclaredMethod(altName, method.getParameterTypes());
 152         } catch (NoSuchMethodException ex) {
 153             return null;
 154         }
 155     }
 156 
 157     //--------------------------------------------------------------------------
 158     //
 159     // Routines used by java.lang.reflect
 160     //
 161     //
 162 
 163     /** Called only by java.lang.reflect.Modifier's static initializer */
 164     public void setLangReflectAccess(LangReflectAccess access) {
 165         langReflectAccess = access;
 166     }
 167 
 168     /**
 169      * Note: this routine can cause the declaring class for the field
 170      * be initialized and therefore must not be called until the
 171      * first get/set of this field.
 172      * @param field the field
 173      * @param override true if caller has overridden accessibility
 174      */
 175     public FieldAccessor newFieldAccessor(Field field, boolean override) {
 176         checkInitted();
 177 
 178         Field root = langReflectAccess().getRoot(field);
 179         if (root != null) {
 180             // FieldAccessor will use the root unless the modifiers have
 181             // been overrridden
 182             if (root.getModifiers() == field.getModifiers() || !override) {
 183                 field = root;
 184             }
 185         }
 186         return UnsafeFieldAccessorFactory.newFieldAccessor(field, override);
 187     }
 188 
 189     public MethodAccessor newMethodAccessor(Method method) {
 190         checkInitted();
 191 
 192         if (Reflection.isCallerSensitive(method)) {
 193             Method altMethod = findMethodForReflection(method);
 194             if (altMethod != null) {
 195                 method = altMethod;
 196             }
 197         }
 198 
 199         // use the root Method that will not cache caller class
 200         Method root = langReflectAccess().getRoot(method);
 201         if (root != null) {
 202             method = root;
 203         }
 204 
 205         if (noInflation && !ReflectUtil.isVMAnonymousClass(method.getDeclaringClass())) {
 206             return new MethodAccessorGenerator().
 207                 generateMethod(method.getDeclaringClass(),
 208                                method.getName(),
 209                                method.getParameterTypes(),
 210                                method.getReturnType(),
 211                                method.getExceptionTypes(),
 212                                method.getModifiers());
 213         } else {
 214             NativeMethodAccessorImpl acc =
 215                 new NativeMethodAccessorImpl(method);
 216             DelegatingMethodAccessorImpl res =
 217                 new DelegatingMethodAccessorImpl(acc);
 218             acc.setParent(res);
 219             return res;
 220         }
 221     }
 222 
 223     public ConstructorAccessor newConstructorAccessor(Constructor<?> c) {
 224         checkInitted();
 225 
 226         Class<?> declaringClass = c.getDeclaringClass();
 227         if (Modifier.isAbstract(declaringClass.getModifiers())) {
 228             return new InstantiationExceptionConstructorAccessorImpl(null);
 229         }
 230         if (declaringClass == Class.class) {
 231             return new InstantiationExceptionConstructorAccessorImpl
 232                 ("Can not instantiate java.lang.Class");
 233         }
 234 
 235         // use the root Constructor that will not cache caller class
 236         Constructor<?> root = langReflectAccess().getRoot(c);
 237         if (root != null) {
 238             c = root;
 239         }
 240 
 241         // Bootstrapping issue: since we use Class.newInstance() in
 242         // the ConstructorAccessor generation process, we have to
 243         // break the cycle here.
 244         if (Reflection.isSubclassOf(declaringClass,
 245                                     ConstructorAccessorImpl.class)) {
 246             return new BootstrapConstructorAccessorImpl(c);
 247         }
 248 
 249         if (noInflation && !ReflectUtil.isVMAnonymousClass(c.getDeclaringClass())) {
 250             return new MethodAccessorGenerator().
 251                 generateConstructor(c.getDeclaringClass(),
 252                                     c.getParameterTypes(),
 253                                     c.getExceptionTypes(),
 254                                     c.getModifiers());
 255         } else {
 256             NativeConstructorAccessorImpl acc =
 257                 new NativeConstructorAccessorImpl(c);
 258             DelegatingConstructorAccessorImpl res =
 259                 new DelegatingConstructorAccessorImpl(acc);
 260             acc.setParent(res);
 261             return res;
 262         }
 263     }
 264 
 265     //--------------------------------------------------------------------------
 266     //
 267     // Routines used by java.lang
 268     //
 269     //
 270 
 271     /** Creates a new java.lang.reflect.Field. Access checks as per
 272         java.lang.reflect.AccessibleObject are not overridden. */
 273     public Field newField(Class<?> declaringClass,
 274                           String name,
 275                           Class<?> type,
 276                           int modifiers,
 277                           int slot,
 278                           String signature,
 279                           byte[] annotations)
 280     {
 281         return langReflectAccess().newField(declaringClass,
 282                                             name,
 283                                             type,
 284                                             modifiers,
 285                                             slot,
 286                                             signature,
 287                                             annotations);
 288     }
 289 
 290     /** Creates a new java.lang.reflect.Method. Access checks as per
 291         java.lang.reflect.AccessibleObject are not overridden. */
 292     public Method newMethod(Class<?> declaringClass,
 293                             String name,
 294                             Class<?>[] parameterTypes,
 295                             Class<?> returnType,
 296                             Class<?>[] checkedExceptions,
 297                             int modifiers,
 298                             int slot,
 299                             String signature,
 300                             byte[] annotations,
 301                             byte[] parameterAnnotations,
 302                             byte[] annotationDefault)
 303     {
 304         return langReflectAccess().newMethod(declaringClass,
 305                                              name,
 306                                              parameterTypes,
 307                                              returnType,
 308                                              checkedExceptions,
 309                                              modifiers,
 310                                              slot,
 311                                              signature,
 312                                              annotations,
 313                                              parameterAnnotations,
 314                                              annotationDefault);
 315     }
 316 
 317     /** Creates a new java.lang.reflect.Constructor. Access checks as
 318         per java.lang.reflect.AccessibleObject are not overridden. */
 319     public Constructor<?> newConstructor(Class<?> declaringClass,
 320                                          Class<?>[] parameterTypes,
 321                                          Class<?>[] checkedExceptions,
 322                                          int modifiers,
 323                                          int slot,
 324                                          String signature,
 325                                          byte[] annotations,
 326                                          byte[] parameterAnnotations)
 327     {
 328         return langReflectAccess().newConstructor(declaringClass,
 329                                                   parameterTypes,
 330                                                   checkedExceptions,
 331                                                   modifiers,
 332                                                   slot,
 333                                                   signature,
 334                                                   annotations,
 335                                                   parameterAnnotations);
 336     }
 337 
 338     /** Gets the MethodAccessor object for a java.lang.reflect.Method */
 339     public MethodAccessor getMethodAccessor(Method m) {
 340         return langReflectAccess().getMethodAccessor(m);
 341     }
 342 
 343     /** Sets the MethodAccessor object for a java.lang.reflect.Method */
 344     public void setMethodAccessor(Method m, MethodAccessor accessor) {
 345         langReflectAccess().setMethodAccessor(m, accessor);
 346     }
 347 
 348     /** Gets the ConstructorAccessor object for a
 349         java.lang.reflect.Constructor */
 350     public ConstructorAccessor getConstructorAccessor(Constructor<?> c) {
 351         return langReflectAccess().getConstructorAccessor(c);
 352     }
 353 
 354     /** Sets the ConstructorAccessor object for a
 355         java.lang.reflect.Constructor */
 356     public void setConstructorAccessor(Constructor<?> c,
 357                                        ConstructorAccessor accessor)
 358     {
 359         langReflectAccess().setConstructorAccessor(c, accessor);
 360     }
 361 
 362     /** Makes a copy of the passed method. The returned method is a
 363         "child" of the passed one; see the comments in Method.java for
 364         details. */
 365     public Method copyMethod(Method arg) {
 366         return langReflectAccess().copyMethod(arg);
 367     }
 368 
 369     /** Makes a copy of the passed method. The returned method is NOT
 370      * a "child" but a "sibling" of the Method in arg. Should only be
 371      * used on non-root methods. */
 372     public Method leafCopyMethod(Method arg) {
 373         return langReflectAccess().leafCopyMethod(arg);
 374     }
 375 
 376 
 377     /** Makes a copy of the passed field. The returned field is a
 378         "child" of the passed one; see the comments in Field.java for
 379         details. */
 380     public Field copyField(Field arg) {
 381         return langReflectAccess().copyField(arg);
 382     }
 383 
 384     /** Makes a copy of the passed constructor. The returned
 385         constructor is a "child" of the passed one; see the comments
 386         in Constructor.java for details. */
 387     public <T> Constructor<T> copyConstructor(Constructor<T> arg) {
 388         return langReflectAccess().copyConstructor(arg);
 389     }
 390 
 391     /** Gets the byte[] that encodes TypeAnnotations on an executable.
 392      */
 393     public byte[] getExecutableTypeAnnotationBytes(Executable ex) {
 394         return langReflectAccess().getExecutableTypeAnnotationBytes(ex);
 395     }
 396 
 397     public Class<?>[] getExecutableSharedParameterTypes(Executable ex) {
 398         return langReflectAccess().getExecutableSharedParameterTypes(ex);
 399     }
 400 
 401     public <T> T newInstance(Constructor<T> ctor, Object[] args, Class<?> caller)
 402         throws IllegalAccessException, InstantiationException, InvocationTargetException
 403     {
 404         return langReflectAccess().newInstance(ctor, args, caller);
 405     }
 406 
 407     //--------------------------------------------------------------------------
 408     //
 409     // Routines used by serialization
 410     //
 411     //
 412 
 413     public final Constructor<?> newConstructorForExternalization(Class<?> cl) {
 414         if (!Externalizable.class.isAssignableFrom(cl)) {
 415             return null;
 416         }
 417         try {
 418             Constructor<?> cons = cl.getConstructor();
 419             cons.setAccessible(true);
 420             return cons;
 421         } catch (NoSuchMethodException ex) {
 422             return null;
 423         }
 424     }
 425 
 426     public final Constructor<?> newConstructorForSerialization(Class<?> cl,
 427                                                                Constructor<?> constructorToCall)
 428     {
 429         if (constructorToCall.getDeclaringClass() == cl) {
 430             constructorToCall.setAccessible(true);
 431             return constructorToCall;
 432         }
 433         return generateConstructor(cl, constructorToCall);
 434     }
 435 
 436     /**
 437      * Given a class, determines whether its superclass has
 438      * any constructors that are accessible from the class.
 439      * This is a special purpose method intended to do access
 440      * checking for a serializable class and its superclasses
 441      * up to, but not including, the first non-serializable
 442      * superclass. This also implies that the superclass is
 443      * always non-null, because a serializable class must be a
 444      * class (not an interface) and Object is not serializable.
 445      *
 446      * @param cl the class from which access is checked
 447      * @return whether the superclass has a constructor accessible from cl
 448      */
 449     private boolean superHasAccessibleConstructor(Class<?> cl) {
 450         Class<?> superCl = cl.getSuperclass();
 451         assert Serializable.class.isAssignableFrom(cl);
 452         assert superCl != null;
 453         if (packageEquals(cl, superCl)) {
 454             // accessible if any non-private constructor is found
 455             for (Constructor<?> ctor : superCl.getDeclaredConstructors()) {
 456                 if ((ctor.getModifiers() & Modifier.PRIVATE) == 0) {
 457                     return true;
 458                 }
 459             }
 460             if (Reflection.areNestMates(cl, superCl)) {
 461                 return true;
 462             }
 463             return false;
 464         } else {
 465             // sanity check to ensure the parent is protected or public
 466             if ((superCl.getModifiers() & (Modifier.PROTECTED | Modifier.PUBLIC)) == 0) {
 467                 return false;
 468             }
 469             // accessible if any constructor is protected or public
 470             for (Constructor<?> ctor : superCl.getDeclaredConstructors()) {
 471                 if ((ctor.getModifiers() & (Modifier.PROTECTED | Modifier.PUBLIC)) != 0) {
 472                     return true;
 473                 }
 474             }
 475             return false;
 476         }
 477     }
 478 
 479     /**
 480      * Returns a constructor that allocates an instance of cl and that then initializes
 481      * the instance by calling the no-arg constructor of its first non-serializable
 482      * superclass. This is specified in the Serialization Specification, section 3.1,
 483      * in step 11 of the deserialization process. If cl is not serializable, returns
 484      * cl's no-arg constructor. If no accessible constructor is found, or if the
 485      * class hierarchy is somehow malformed (e.g., a serializable class has no
 486      * superclass), null is returned.
 487      *
 488      * @param cl the class for which a constructor is to be found
 489      * @return the generated constructor, or null if none is available
 490      */
 491     public final Constructor<?> newConstructorForSerialization(Class<?> cl) {
 492         Class<?> initCl = cl;
 493         while (Serializable.class.isAssignableFrom(initCl)) {
 494             Class<?> prev = initCl;
 495             if ((initCl = initCl.getSuperclass()) == null ||
 496                 (!disableSerialConstructorChecks && !superHasAccessibleConstructor(prev))) {
 497                 return null;
 498             }
 499         }
 500         Constructor<?> constructorToCall;
 501         try {
 502             constructorToCall = initCl.getDeclaredConstructor();
 503             int mods = constructorToCall.getModifiers();
 504             if ((mods & Modifier.PRIVATE) != 0 ||
 505                     ((mods & (Modifier.PUBLIC | Modifier.PROTECTED)) == 0 &&
 506                             !packageEquals(cl, initCl))) {
 507                 return null;
 508             }
 509         } catch (NoSuchMethodException ex) {
 510             return null;
 511         }
 512         return generateConstructor(cl, constructorToCall);
 513     }
 514 
 515     private final Constructor<?> generateConstructor(Class<?> cl,
 516                                                      Constructor<?> constructorToCall) {
 517 
 518 
 519         ConstructorAccessor acc = new MethodAccessorGenerator().
 520             generateSerializationConstructor(cl,
 521                                              constructorToCall.getParameterTypes(),
 522                                              constructorToCall.getExceptionTypes(),
 523                                              constructorToCall.getModifiers(),
 524                                              constructorToCall.getDeclaringClass());
 525         Constructor<?> c = newConstructor(constructorToCall.getDeclaringClass(),
 526                                           constructorToCall.getParameterTypes(),
 527                                           constructorToCall.getExceptionTypes(),
 528                                           constructorToCall.getModifiers(),
 529                                           langReflectAccess().
 530                                           getConstructorSlot(constructorToCall),
 531                                           langReflectAccess().
 532                                           getConstructorSignature(constructorToCall),
 533                                           langReflectAccess().
 534                                           getConstructorAnnotations(constructorToCall),
 535                                           langReflectAccess().
 536                                           getConstructorParameterAnnotations(constructorToCall));
 537         setConstructorAccessor(c, acc);
 538         c.setAccessible(true);
 539         return c;
 540     }
 541 
 542     public final MethodHandle readObjectForSerialization(Class<?> cl) {
 543         return findReadWriteObjectForSerialization(cl, "readObject", ObjectInputStream.class);
 544     }
 545 
 546     public final MethodHandle readObjectNoDataForSerialization(Class<?> cl) {
 547         return findReadWriteObjectForSerialization(cl, "readObjectNoData", ObjectInputStream.class);
 548     }
 549 
 550     public final MethodHandle writeObjectForSerialization(Class<?> cl) {
 551         return findReadWriteObjectForSerialization(cl, "writeObject", ObjectOutputStream.class);
 552     }
 553 
 554     private final MethodHandle findReadWriteObjectForSerialization(Class<?> cl,
 555                                                                    String methodName,
 556                                                                    Class<?> streamClass) {
 557         if (!Serializable.class.isAssignableFrom(cl)) {
 558             return null;
 559         }
 560 
 561         try {
 562             Method meth = cl.getDeclaredMethod(methodName, streamClass);
 563             int mods = meth.getModifiers();
 564             if (meth.getReturnType() != Void.TYPE ||
 565                     Modifier.isStatic(mods) ||
 566                     !Modifier.isPrivate(mods)) {
 567                 return null;
 568             }
 569             meth.setAccessible(true);
 570             return MethodHandles.lookup().unreflect(meth);
 571         } catch (NoSuchMethodException ex) {
 572             return null;
 573         } catch (IllegalAccessException ex1) {
 574             throw new InternalError("Error", ex1);
 575         }
 576     }
 577 
 578     /**
 579      * Returns a MethodHandle for {@code writeReplace} on the serializable class
 580      * or null if no match found.
 581      * @param cl a serializable class
 582      * @returnss the {@code writeReplace} MethodHandle or {@code null} if not found
 583      */
 584     public final MethodHandle writeReplaceForSerialization(Class<?> cl) {
 585         return getReplaceResolveForSerialization(cl, "writeReplace");
 586     }
 587 
 588     /**
 589      * Returns a MethodHandle for {@code readResolve} on the serializable class
 590      * or null if no match found.
 591      * @param cl a serializable class
 592      * @returns the {@code writeReplace} MethodHandle or {@code null} if not found
 593      */
 594     public final MethodHandle readResolveForSerialization(Class<?> cl) {
 595         return getReplaceResolveForSerialization(cl, "readResolve");
 596     }
 597 
 598     /**
 599      * Lookup readResolve or writeReplace on a class with specified
 600      * signature constraints.
 601      * @param cl a serializable class
 602      * @param methodName the method name to find
 603      * @returns a MethodHandle for the method or {@code null} if not found or
 604      *       has the wrong signature.
 605      */
 606     private MethodHandle getReplaceResolveForSerialization(Class<?> cl,
 607                                                            String methodName) {
 608         if (!Serializable.class.isAssignableFrom(cl)) {
 609             return null;
 610         }
 611 
 612         Class<?> defCl = cl;
 613         while (defCl != null) {
 614             try {
 615                 Method m = defCl.getDeclaredMethod(methodName);
 616                 if (m.getReturnType() != Object.class) {
 617                     return null;
 618                 }
 619                 int mods = m.getModifiers();
 620                 if (Modifier.isStatic(mods) | Modifier.isAbstract(mods)) {
 621                     return null;
 622                 } else if (Modifier.isPublic(mods) | Modifier.isProtected(mods)) {
 623                     // fall through
 624                 } else if (Modifier.isPrivate(mods) && (cl != defCl)) {
 625                     return null;
 626                 } else if (!packageEquals(cl, defCl)) {
 627                     return null;
 628                 }
 629                 try {
 630                     // Normal return
 631                     m.setAccessible(true);
 632                     return MethodHandles.lookup().unreflect(m);
 633                 } catch (IllegalAccessException ex0) {
 634                     // setAccessible should prevent IAE
 635                     throw new InternalError("Error", ex0);
 636                 }
 637             } catch (NoSuchMethodException ex) {
 638                 defCl = defCl.getSuperclass();
 639             }
 640         }
 641         return null;
 642     }
 643 
 644     /**
 645      * Returns true if the given class defines a static initializer method,
 646      * false otherwise.
 647      */
 648     public final boolean hasStaticInitializerForSerialization(Class<?> cl) {
 649         Method m = hasStaticInitializerMethod;
 650         if (m == null) {
 651             try {
 652                 m = ObjectStreamClass.class.getDeclaredMethod("hasStaticInitializer",
 653                         new Class<?>[]{Class.class});
 654                 m.setAccessible(true);
 655                 hasStaticInitializerMethod = m;
 656             } catch (NoSuchMethodException ex) {
 657                 throw new InternalError("No such method hasStaticInitializer on "
 658                         + ObjectStreamClass.class, ex);
 659             }
 660         }
 661         try {
 662             return (Boolean) m.invoke(null, cl);
 663         } catch (InvocationTargetException | IllegalAccessException ex) {
 664             throw new InternalError("Exception invoking hasStaticInitializer", ex);
 665         }
 666     }
 667 
 668     /**
 669      * Return the accessible constructor for OptionalDataException signaling eof.
 670      * @returns the eof constructor for OptionalDataException
 671      */
 672     public final Constructor<OptionalDataException> newOptionalDataExceptionForSerialization() {
 673         try {
 674             Constructor<OptionalDataException> boolCtor =
 675                     OptionalDataException.class.getDeclaredConstructor(Boolean.TYPE);
 676             boolCtor.setAccessible(true);
 677             return boolCtor;
 678         } catch (NoSuchMethodException ex) {
 679             throw new InternalError("Constructor not found", ex);
 680         }
 681     }
 682 
 683     //--------------------------------------------------------------------------
 684     //
 685     // Internals only below this point
 686     //
 687 
 688     static int inflationThreshold() {
 689         return inflationThreshold;
 690     }
 691 
 692     /** We have to defer full initialization of this class until after
 693         the static initializer is run since java.lang.reflect.Method's
 694         static initializer (more properly, that for
 695         java.lang.reflect.AccessibleObject) causes this class's to be
 696         run, before the system properties are set up. */
 697     private static void checkInitted() {
 698         if (initted) return;
 699 
 700         // Defer initialization until module system is initialized so as
 701         // to avoid inflation and spinning bytecode in unnamed modules
 702         // during early startup.
 703         if (!VM.isModuleSystemInited()) {
 704             return;
 705         }
 706 
 707         Properties props = GetPropertyAction.privilegedGetProperties();
 708         String val = props.getProperty("sun.reflect.noInflation");
 709         if (val != null && val.equals("true")) {
 710             noInflation = true;
 711         }
 712 
 713         val = props.getProperty("sun.reflect.inflationThreshold");
 714         if (val != null) {
 715             try {
 716                 inflationThreshold = Integer.parseInt(val);
 717             } catch (NumberFormatException e) {
 718                 throw new RuntimeException("Unable to parse property sun.reflect.inflationThreshold", e);
 719             }
 720         }
 721 
 722         disableSerialConstructorChecks =
 723             "true".equals(props.getProperty("jdk.disableSerialConstructorChecks"));
 724 
 725         initted = true;
 726     }
 727 
 728     static LangReflectAccess langReflectAccess() {
 729         if (langReflectAccess == null) {
 730             // Call a static method to get class java.lang.reflect.Modifier
 731             // initialized. Its static initializer will cause
 732             // setLangReflectAccess() to be called from the context of the
 733             // java.lang.reflect package.
 734             Modifier.isPublic(Modifier.PUBLIC);
 735         }
 736         return langReflectAccess;
 737     }
 738 
 739     /**
 740      * Returns true if classes are defined in the classloader and same package, false
 741      * otherwise.
 742      * @param cl1 a class
 743      * @param cl2 another class
 744      * @returns true if the two classes are in the same classloader and package
 745      */
 746     private static boolean packageEquals(Class<?> cl1, Class<?> cl2) {
 747         assert !cl1.isArray() && !cl2.isArray();
 748 
 749         if (cl1 == cl2) {
 750             return true;
 751         }
 752 
 753         return cl1.getClassLoader() == cl2.getClassLoader() &&
 754                 Objects.equals(cl1.getPackageName(), cl2.getPackageName());
 755     }
 756 
 757 }