1 /*
   2  * Copyright (c) 2001, 2013, 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 sun.reflect;
  27 
  28 import java.lang.reflect.Field;
  29 import java.lang.reflect.Executable;
  30 import java.lang.reflect.Method;
  31 import java.lang.reflect.Constructor;
  32 import java.lang.reflect.Modifier;
  33 import java.security.AccessController;
  34 import java.security.Permission;
  35 import java.security.PrivilegedAction;
  36 import sun.reflect.misc.ReflectUtil;
  37 
  38 /** <P> The master factory for all reflective objects, both those in
  39     java.lang.reflect (Fields, Methods, Constructors) as well as their
  40     delegates (FieldAccessors, MethodAccessors, ConstructorAccessors).
  41     </P>
  42 
  43     <P> The methods in this class are extremely unsafe and can cause
  44     subversion of both the language and the verifier. For this reason,
  45     they are all instance methods, and access to the constructor of
  46     this factory is guarded by a security check, in similar style to
  47     {@link sun.misc.Unsafe}. </P>
  48 */
  49 
  50 public class ReflectionFactory {
  51 
  52     private static boolean initted = false;
  53     private static final Permission reflectionFactoryAccessPerm
  54         = new RuntimePermission("reflectionFactoryAccess");
  55     private static final ReflectionFactory soleInstance = new ReflectionFactory();
  56     // Provides access to package-private mechanisms in java.lang.reflect
  57     private static volatile LangReflectAccess langReflectAccess;
  58 
  59     //
  60     // "Inflation" mechanism. Loading bytecodes to implement
  61     // Method.invoke() and Constructor.newInstance() currently costs
  62     // 3-4x more than an invocation via native code for the first
  63     // invocation (though subsequent invocations have been benchmarked
  64     // to be over 20x faster). Unfortunately this cost increases
  65     // startup time for certain applications that use reflection
  66     // intensively (but only once per class) to bootstrap themselves.
  67     // To avoid this penalty we reuse the existing JVM entry points
  68     // for the first few invocations of Methods and Constructors and
  69     // then switch to the bytecode-based implementations.
  70     //
  71     // Package-private to be accessible to NativeMethodAccessorImpl
  72     // and NativeConstructorAccessorImpl
  73     private static boolean noInflation        = false;
  74     private static int     inflationThreshold = 15;
  75 
  76     private ReflectionFactory() {
  77     }
  78 
  79     /**
  80      * A convenience class for acquiring the capability to instantiate
  81      * reflective objects.  Use this instead of a raw call to {@link
  82      * #getReflectionFactory} in order to avoid being limited by the
  83      * permissions of your callers.
  84      *
  85      * <p>An instance of this class can be used as the argument of
  86      * <code>AccessController.doPrivileged</code>.
  87      */
  88     public static final class GetReflectionFactoryAction
  89         implements PrivilegedAction<ReflectionFactory> {
  90         public ReflectionFactory run() {
  91             return getReflectionFactory();
  92         }
  93     }
  94 
  95     /**
  96      * Provides the caller with the capability to instantiate reflective
  97      * objects.
  98      *
  99      * <p> First, if there is a security manager, its
 100      * <code>checkPermission</code> method is called with a {@link
 101      * java.lang.RuntimePermission} with target
 102      * <code>"reflectionFactoryAccess"</code>.  This may result in a
 103      * security exception.
 104      *
 105      * <p> The returned <code>ReflectionFactory</code> object should be
 106      * carefully guarded by the caller, since it can be used to read and
 107      * write private data and invoke private methods, as well as to load
 108      * unverified bytecodes.  It must never be passed to untrusted code.
 109      *
 110      * @exception SecurityException if a security manager exists and its
 111      *             <code>checkPermission</code> method doesn't allow
 112      *             access to the RuntimePermission "reflectionFactoryAccess".  */
 113     public static ReflectionFactory getReflectionFactory() {
 114         SecurityManager security = System.getSecurityManager();
 115         if (security != null) {
 116             // TO DO: security.checkReflectionFactoryAccess();
 117             security.checkPermission(reflectionFactoryAccessPerm);
 118         }
 119         return soleInstance;
 120     }
 121 
 122     //--------------------------------------------------------------------------
 123     //
 124     // Routines used by java.lang.reflect
 125     //
 126     //
 127 
 128     /** Called only by java.lang.reflect.Modifier's static initializer */
 129     public void setLangReflectAccess(LangReflectAccess access) {
 130         langReflectAccess = access;
 131     }
 132 
 133     /**
 134      * Note: this routine can cause the declaring class for the field
 135      * be initialized and therefore must not be called until the
 136      * first get/set of this field.
 137      * @param field the field
 138      * @param override true if caller has overridden accessibility
 139      */
 140     public FieldAccessor newFieldAccessor(Field field, boolean override) {
 141         checkInitted();
 142         return UnsafeFieldAccessorFactory.newFieldAccessor(field, override);
 143     }
 144 
 145     public MethodAccessor newMethodAccessor(Method method) {
 146         checkInitted();
 147 
 148         if (noInflation && !ReflectUtil.isVMAnonymousClass(method.getDeclaringClass())) {
 149             return new MethodAccessorGenerator().
 150                 generateMethod(method.getDeclaringClass(),
 151                                method.getName(),
 152                                method.getParameterTypes(),
 153                                method.getReturnType(),
 154                                method.getExceptionTypes(),
 155                                method.getModifiers());
 156         } else {
 157             NativeMethodAccessorImpl acc =
 158                 new NativeMethodAccessorImpl(method);
 159             DelegatingMethodAccessorImpl res =
 160                 new DelegatingMethodAccessorImpl(acc);
 161             acc.setParent(res);
 162             return res;
 163         }
 164     }
 165 
 166     public ConstructorAccessor newConstructorAccessor(Constructor<?> c) {
 167         checkInitted();
 168 
 169         Class<?> declaringClass = c.getDeclaringClass();
 170         if (Modifier.isAbstract(declaringClass.getModifiers())) {
 171             return new InstantiationExceptionConstructorAccessorImpl(null);
 172         }
 173         if (declaringClass == Class.class) {
 174             return new InstantiationExceptionConstructorAccessorImpl
 175                 ("Can not instantiate java.lang.Class");
 176         }
 177         // Bootstrapping issue: since we use Class.newInstance() in
 178         // the ConstructorAccessor generation process, we have to
 179         // break the cycle here.
 180         if (Reflection.isSubclassOf(declaringClass,
 181                                     ConstructorAccessorImpl.class)) {
 182             return new BootstrapConstructorAccessorImpl(c);
 183         }
 184 
 185         if (noInflation && !ReflectUtil.isVMAnonymousClass(c.getDeclaringClass())) {
 186             return new MethodAccessorGenerator().
 187                 generateConstructor(c.getDeclaringClass(),
 188                                     c.getParameterTypes(),
 189                                     c.getExceptionTypes(),
 190                                     c.getModifiers());
 191         } else {
 192             NativeConstructorAccessorImpl acc =
 193                 new NativeConstructorAccessorImpl(c);
 194             DelegatingConstructorAccessorImpl res =
 195                 new DelegatingConstructorAccessorImpl(acc);
 196             acc.setParent(res);
 197             return res;
 198         }
 199     }
 200 
 201     //--------------------------------------------------------------------------
 202     //
 203     // Routines used by java.lang
 204     //
 205     //
 206 
 207     /** Creates a new java.lang.reflect.Field. Access checks as per
 208         java.lang.reflect.AccessibleObject are not overridden. */
 209     public Field newField(Class<?> declaringClass,
 210                           String name,
 211                           Class<?> type,
 212                           int modifiers,
 213                           int slot,
 214                           String signature,
 215                           byte[] annotations)
 216     {
 217         return langReflectAccess().newField(declaringClass,
 218                                             name,
 219                                             type,
 220                                             modifiers,
 221                                             slot,
 222                                             signature,
 223                                             annotations);
 224     }
 225 
 226     /** Creates a new java.lang.reflect.Method. Access checks as per
 227         java.lang.reflect.AccessibleObject are not overridden. */
 228     public Method newMethod(Class<?> declaringClass,
 229                             String name,
 230                             Class<?>[] parameterTypes,
 231                             Class<?> returnType,
 232                             Class<?>[] checkedExceptions,
 233                             int modifiers,
 234                             int slot,
 235                             String signature,
 236                             byte[] annotations,
 237                             byte[] parameterAnnotations,
 238                             byte[] annotationDefault)
 239     {
 240         return langReflectAccess().newMethod(declaringClass,
 241                                              name,
 242                                              parameterTypes,
 243                                              returnType,
 244                                              checkedExceptions,
 245                                              modifiers,
 246                                              slot,
 247                                              signature,
 248                                              annotations,
 249                                              parameterAnnotations,
 250                                              annotationDefault);
 251     }
 252 
 253     /** Creates a new java.lang.reflect.Constructor. Access checks as
 254         per java.lang.reflect.AccessibleObject are not overridden. */
 255     public Constructor<?> newConstructor(Class<?> declaringClass,
 256                                          Class<?>[] parameterTypes,
 257                                          Class<?>[] checkedExceptions,
 258                                          int modifiers,
 259                                          int slot,
 260                                          String signature,
 261                                          byte[] annotations,
 262                                          byte[] parameterAnnotations)
 263     {
 264         return langReflectAccess().newConstructor(declaringClass,
 265                                                   parameterTypes,
 266                                                   checkedExceptions,
 267                                                   modifiers,
 268                                                   slot,
 269                                                   signature,
 270                                                   annotations,
 271                                                   parameterAnnotations);
 272     }
 273 
 274     /** Gets the MethodAccessor object for a java.lang.reflect.Method */
 275     public MethodAccessor getMethodAccessor(Method m) {
 276         return langReflectAccess().getMethodAccessor(m);
 277     }
 278 
 279     /** Sets the MethodAccessor object for a java.lang.reflect.Method */
 280     public void setMethodAccessor(Method m, MethodAccessor accessor) {
 281         langReflectAccess().setMethodAccessor(m, accessor);
 282     }
 283 
 284     /** Gets the ConstructorAccessor object for a
 285         java.lang.reflect.Constructor */
 286     public ConstructorAccessor getConstructorAccessor(Constructor<?> c) {
 287         return langReflectAccess().getConstructorAccessor(c);
 288     }
 289 
 290     /** Sets the ConstructorAccessor object for a
 291         java.lang.reflect.Constructor */
 292     public void setConstructorAccessor(Constructor<?> c,
 293                                        ConstructorAccessor accessor)
 294     {
 295         langReflectAccess().setConstructorAccessor(c, accessor);
 296     }
 297 
 298     /** Makes a copy of the passed method. The returned method is a
 299         "child" of the passed one; see the comments in Method.java for
 300         details. */
 301     public Method copyMethod(Method arg) {
 302         return langReflectAccess().copyMethod(arg);
 303     }
 304 
 305     /** Makes a copy of the passed field. The returned field is a
 306         "child" of the passed one; see the comments in Field.java for
 307         details. */
 308     public Field copyField(Field arg) {
 309         return langReflectAccess().copyField(arg);
 310     }
 311 
 312     /** Makes a copy of the passed constructor. The returned
 313         constructor is a "child" of the passed one; see the comments
 314         in Constructor.java for details. */
 315     public <T> Constructor<T> copyConstructor(Constructor<T> arg) {
 316         return langReflectAccess().copyConstructor(arg);
 317     }
 318 
 319     /** Gets the byte[] that encodes TypeAnnotations on an executable.
 320      */
 321     public byte[] getExecutableTypeAnnotationBytes(Executable ex) {
 322         return langReflectAccess().getExecutableTypeAnnotationBytes(ex);
 323     }
 324 
 325     /** Compares parameter types of two Methods */
 326     public boolean methodParameterTypesEquals(Method method1, Method method2) {
 327         return langReflectAccess().methodParameterTypesEquals(method1, method2);
 328     }
 329 
 330     /** Returns hashCode for parameter types of a Method */
 331     public int methodParameterTypesHashCode(Method method) {
 332         return langReflectAccess().methodParameterTypesHashCode(method);
 333     }
 334 
 335     //--------------------------------------------------------------------------
 336     //
 337     // Routines used by serialization
 338     //
 339     //
 340 
 341     public Constructor<?> newConstructorForSerialization
 342         (Class<?> classToInstantiate, Constructor<?> constructorToCall)
 343     {
 344         // Fast path
 345         if (constructorToCall.getDeclaringClass() == classToInstantiate) {
 346             return constructorToCall;
 347         }
 348 
 349         ConstructorAccessor acc = new MethodAccessorGenerator().
 350             generateSerializationConstructor(classToInstantiate,
 351                                              constructorToCall.getParameterTypes(),
 352                                              constructorToCall.getExceptionTypes(),
 353                                              constructorToCall.getModifiers(),
 354                                              constructorToCall.getDeclaringClass());
 355         Constructor<?> c = newConstructor(constructorToCall.getDeclaringClass(),
 356                                           constructorToCall.getParameterTypes(),
 357                                           constructorToCall.getExceptionTypes(),
 358                                           constructorToCall.getModifiers(),
 359                                           langReflectAccess().
 360                                           getConstructorSlot(constructorToCall),
 361                                           langReflectAccess().
 362                                           getConstructorSignature(constructorToCall),
 363                                           langReflectAccess().
 364                                           getConstructorAnnotations(constructorToCall),
 365                                           langReflectAccess().
 366                                           getConstructorParameterAnnotations(constructorToCall));
 367         setConstructorAccessor(c, acc);
 368         return c;
 369     }
 370 
 371     //--------------------------------------------------------------------------
 372     //
 373     // Internals only below this point
 374     //
 375 
 376     static int inflationThreshold() {
 377         return inflationThreshold;
 378     }
 379 
 380     /** We have to defer full initialization of this class until after
 381         the static initializer is run since java.lang.reflect.Method's
 382         static initializer (more properly, that for
 383         java.lang.reflect.AccessibleObject) causes this class's to be
 384         run, before the system properties are set up. */
 385     private static void checkInitted() {
 386         if (initted) return;
 387         AccessController.doPrivileged(
 388             new PrivilegedAction<Void>() {
 389                 public Void run() {
 390                     // Tests to ensure the system properties table is fully
 391                     // initialized. This is needed because reflection code is
 392                     // called very early in the initialization process (before
 393                     // command-line arguments have been parsed and therefore
 394                     // these user-settable properties installed.) We assume that
 395                     // if System.out is non-null then the System class has been
 396                     // fully initialized and that the bulk of the startup code
 397                     // has been run.
 398 
 399                     if (System.out == null) {
 400                         // java.lang.System not yet fully initialized
 401                         return null;
 402                     }
 403 
 404                     String val = System.getProperty("sun.reflect.noInflation");
 405                     if (val != null && val.equals("true")) {
 406                         noInflation = true;
 407                     }
 408 
 409                     val = System.getProperty("sun.reflect.inflationThreshold");
 410                     if (val != null) {
 411                         try {
 412                             inflationThreshold = Integer.parseInt(val);
 413                         } catch (NumberFormatException e) {
 414                             throw new RuntimeException("Unable to parse property sun.reflect.inflationThreshold", e);
 415                         }
 416                     }
 417 
 418                     initted = true;
 419                     return null;
 420                 }
 421             });
 422     }
 423 
 424     private static LangReflectAccess langReflectAccess() {
 425         if (langReflectAccess == null) {
 426             // Call a static method to get class java.lang.reflect.Modifier
 427             // initialized. Its static initializer will cause
 428             // setLangReflectAccess() to be called from the context of the
 429             // java.lang.reflect package.
 430             Modifier.isPublic(Modifier.PUBLIC);
 431         }
 432         return langReflectAccess;
 433     }
 434 }