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