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