Mercurial Mercurial > jdk-sandbox / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
jdk/src/share/classes/java/lang/invoke/MethodHandleNatives.java
changeset 16118 9f3390f42157
parent 16110 2ce1c415475b
child 16121 49db59536470
equal deleted inserted replaced
16117:3c521ba54a81 16118:9f3390f42157 
   391      * I.e., does it call Reflection.getCallerClass or a similer method
 
   391      * I.e., does it call Reflection.getCallerClass or a similer method
 
   392      * to ask about the identity of its caller?
 
   392      * to ask about the identity of its caller?
 
   393      */
 
   393      */
 
   394     // FIXME: Replace this pattern match by an annotation @sun.reflect.CallerSensitive.
 
   394     // FIXME: Replace this pattern match by an annotation @sun.reflect.CallerSensitive.
 
   395     static boolean isCallerSensitive(MemberName mem) {
 
   395     static boolean isCallerSensitive(MemberName mem) {
 
   396         assert(mem.isInvocable());
 
   396         if (!mem.isInvocable())  return false;  // fields are not caller sensitive
 
   397         Class<?> defc = mem.getDeclaringClass();
 
   397         Class<?> defc = mem.getDeclaringClass();
 
   398         switch (mem.getName()) {
 
   398         switch (mem.getName()) {
 
   399         case "doPrivileged":
 
   399         case "doPrivileged":
 
       
   400         case "doPrivilegedWithCombiner":
 
   400             return defc == java.security.AccessController.class;
 
   401             return defc == java.security.AccessController.class;
 
       
   402         case "checkMemberAccess":
 
       
   403             return canBeCalledVirtual(mem, java.lang.SecurityManager.class);
 
   401         case "getUnsafe":
 
   404         case "getUnsafe":
 
   402             return defc == sun.misc.Unsafe.class;
 
   405             return defc == sun.misc.Unsafe.class;
 
   403         case "lookup":
 
   406         case "lookup":
 
   404             return defc == java.lang.invoke.MethodHandles.class;
 
   407             return defc == java.lang.invoke.MethodHandles.class;
 
   405         case "invoke":
 
   408         case "invoke":
 
   453             if (defc == java.util.concurrent.atomic.AtomicIntegerFieldUpdater.class)  return true;
 
   456             if (defc == java.util.concurrent.atomic.AtomicIntegerFieldUpdater.class)  return true;
 
   454             if (defc == java.util.concurrent.atomic.AtomicLongFieldUpdater.class)  return true;
 
   457             if (defc == java.util.concurrent.atomic.AtomicLongFieldUpdater.class)  return true;
 
   455             if (defc == java.util.concurrent.atomic.AtomicReferenceFieldUpdater.class)  return true;
 
   458             if (defc == java.util.concurrent.atomic.AtomicReferenceFieldUpdater.class)  return true;
 
   456             break;
 
   459             break;
 
   457         case "getContextClassLoader":
 
   460         case "getContextClassLoader":
 
   458             return defc == java.lang.Thread.class;
 
   461             return canBeCalledVirtual(mem, java.lang.Thread.class);
 
   459         case "getPackage":
 
   462         case "getPackage":
 
   460         case "getPackages":
 
   463         case "getPackages":
 
   461             return defc == java.lang.Package.class;
 
   464             return defc == java.lang.Package.class;
 
   462         case "getParent":
 
   465         case "getParent":
 
   463         case "getSystemClassLoader":
 
   466         case "getSystemClassLoader":
 
   471             if (defc == sun.reflect.Reflection.class)  return true;
 
   474             if (defc == sun.reflect.Reflection.class)  return true;
 
   472             if (defc == java.lang.System.class)  return true;
 
   475             if (defc == java.lang.System.class)  return true;
 
   473             break;
 
   476             break;
 
   474         case "getCallerClassLoader":
 
   477         case "getCallerClassLoader":
 
   475             return defc == java.lang.ClassLoader.class;
 
   478             return defc == java.lang.ClassLoader.class;
 
       
   479         case "registerAsParallelCapable":
 
       
   480             return canBeCalledVirtual(mem, java.lang.ClassLoader.class);
 
   476         case "getProxyClass":
 
   481         case "getProxyClass":
 
   477         case "newProxyInstance":
 
   482         case "newProxyInstance":
 
   478             return defc == java.lang.reflect.Proxy.class;
 
   483             return defc == java.lang.reflect.Proxy.class;
 
   479         case "asInterfaceInstance":
 
   484         case "asInterfaceInstance":
 
   480             return defc == java.lang.invoke.MethodHandleProxies.class;
 
   485             return defc == java.lang.invoke.MethodHandleProxies.class;
 
   492                                  MethodHandleNatives.class.getClassLoader());
 
   497                                  MethodHandleNatives.class.getClassLoader());
 
   493         } catch (ClassNotFoundException e) {
 
   498         } catch (ClassNotFoundException e) {
 
   494             throw new InternalError(e);
 
   499             throw new InternalError(e);
 
   495         }
 
   500         }
 
   496     }
 
   501     }
 
       
   502     static boolean canBeCalledVirtual(MemberName symbolicRef, Class<?> definingClass) {
 
       
   503         Class<?> symbolicRefClass = symbolicRef.getDeclaringClass();
 
       
   504         if (symbolicRefClass == definingClass)  return true;
 
       
   505         if (symbolicRef.isStatic() || symbolicRef.isPrivate())  return false;
 
       
   506         return (definingClass.isAssignableFrom(symbolicRefClass) ||  // Msym overrides Mdef
 
       
   507                 symbolicRefClass.isInterface());                     // Mdef implements Msym
 
       
   508     }
 
   497 }
 
   509 }
jdk-sandbox