jdk-sandbox: comparison jdk/src/share/classes/java/dyn/CallSite.java

equal deleted inserted replaced

-:9e2483e6cfab
+:3b891698c4ec
 /*
-* Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 printArgs = lookup.findStatic(thisClass,
 "printArgs", MethodType.methodType(void.class, Object[].class));
 }
 private static CallSite bootstrapDynamic(MethodHandles.Lookup caller, String name, MethodType type) {
 // ignore caller and name, but match the type:
-return new ConstantCallSite(MethodHandles.collectArguments(printArgs, type));
+return new ConstantCallSite(printArgs.asType(type));
 }
 </pre></blockquote>
 * @author John Rose, JSR 292 EG
 */
 abstract
 public class CallSite {
 private static final Access IMPL_TOKEN = Access.getToken();
+static { MethodHandleImpl.initStatics(); }
 // Fields used only by the JVM.  Do not use or change.
 private MemberName vmmethod; // supplied by the JVM (ref. to calling method)
 private int        vmindex;  // supplied by the JVM (BCI within calling method)
 target.type();  // null check
 this.target = target;
 }
 /**
-* Report the type of this call site's target.
+* Returns the type of this call site's target.
-* Although targets may change, the call site's type can never change.
+* Although targets may change, any call site's type is permanent, and can never change to an unequal type.
 * The {@code setTarget} method enforces this invariant by refusing any new target that does
 * not have the previous target's type.
 * @return the type of the current target, which is also the type of any future target
 */
 public MethodType type() {
 this.vmindex  = callerBCI;
 this.vmmethod = callerMethod;
 }
 /**
-* Report the current linkage state of the call site, a value which may change over time.
+* Returns the target method of the call site, according to the
-* <p>
+* behavior defined by this call site's specific class.
-* If a {@code CallSite} object is returned
+* The immediate subclasses of {@code CallSite} document the
-* from the bootstrap method of the {@code invokedynamic} instruction,
+* class-specific behaviors of this method.
-* the {@code CallSite} is permanently bound to that instruction.
+*
-* When the {@code invokedynamic} instruction is executed, the target method
-* of its associated call site object is invoked directly.
-* It is as if the instruction calls {@code getTarget} and then
-* calls {@link MethodHandle#invokeExact invokeExact} on the result.
-* <p>
-* Unless specified differently by a subclass,
-* the interactions of {@code getTarget} with memory are the same
-* as of a read from an ordinary variable, such as an array element or a
-* non-volatile, non-final field.
-* <p>
-* In particular, the current thread may choose to reuse the result
-* of a previous read of the target from memory, and may fail to see
-* a recent update to the target by another thread.
-* <p>
-* In a {@linkplain ConstantCallSite constant call site}, the {@code getTarget} method behaves
-* like a read from a {@code final} field of the {@code CallSite}.
-* <p>
-* In a {@linkplain VolatileCallSite volatile call site}, the {@code getTarget} method behaves
-* like a read from a {@code volatile} field of the {@code CallSite}.
-* <p>
-* This method may not be overridden by application code.
 * @return the current linkage state of the call site, its target method handle
 * @see ConstantCallSite
 * @see VolatileCallSite
 * @see #setTarget
-*/
+* @see ConstantCallSite#getTarget
-public final MethodHandle getTarget() {
+* @see MutableCallSite#getTarget
-return getTarget0();
+* @see VolatileCallSite#getTarget
-}
+*/
+public abstract MethodHandle getTarget();
-/**
-* Privileged implementations can override this to force final or volatile semantics on getTarget.
+/**
-*/
+* Updates the target method of this call site, according to the
-/*package-private*/
+* behavior defined by this call site's specific class.
-MethodHandle getTarget0() {
+* The immediate subclasses of {@code CallSite} document the
-return target;
+* class-specific behaviors of this method.
-}
-/**
-* Set the target method of this call site.
 * <p>
-* Unless a subclass of CallSite documents otherwise,
+* The type of the new target must be {@linkplain MethodType#equals equal to}
-* the interactions of {@code setTarget} with memory are the same
+* the type of the old target.
-* as of a write to an ordinary variable, such as an array element or a
+*
-* non-volatile, non-final field.
-* <p>
-* In particular, unrelated threads may fail to see the updated target
-* until they perform a read from memory.
-* Stronger guarantees can be created by putting appropriate operations
-* into the bootstrap method and/or the target methods used
-* at any given call site.
 * @param newTarget the new target
 * @throws NullPointerException if the proposed new target is null
 * @throws WrongMethodTypeException if the proposed new target
 *         has a method type that differs from the previous target
-* @throws UnsupportedOperationException if the call site is
+* @see CallSite#getTarget
-*         in fact a {@link ConstantCallSite}
+* @see ConstantCallSite#setTarget
-*/
+* @see MutableCallSite#setTarget
-public void setTarget(MethodHandle newTarget) {
+* @see VolatileCallSite#setTarget
-checkTargetChange(this.target, newTarget);
+*/
-setTargetNormal(newTarget);
+public abstract void setTarget(MethodHandle newTarget);
-}
 void checkTargetChange(MethodHandle oldTarget, MethodHandle newTarget) {
 MethodType oldType = oldTarget.type();
 MethodType newType = newTarget.type();  // null check!
 if (!newType.equals(oldType))
 }
 /**
 * Produce a method handle equivalent to an invokedynamic instruction
 * which has been linked to this call site.
-* <p>If this call site is a {@linkplain ConstantCallSite constant call site},
+* <p>
-* this method simply returns the call site's target, since that will never change.
+* This method is equivalent to the following code:
-* <p>Otherwise, this method is equivalent to the following code:
+* <blockquote><pre>
-* <p><blockquote><pre>
 * MethodHandle getTarget, invoker, result;
-* getTarget = MethodHandles.lookup().bind(this, "getTarget", MethodType.methodType(MethodHandle.class));
+* getTarget = MethodHandles.publicLookup().bind(this, "getTarget", MethodType.methodType(MethodHandle.class));
 * invoker = MethodHandles.exactInvoker(this.type());
 * result = MethodHandles.foldArguments(invoker, getTarget)
 * </pre></blockquote>
+*
 * @return a method handle which always invokes this call site's current target
 */
-public final MethodHandle dynamicInvoker() {
+public abstract MethodHandle dynamicInvoker();
-if (this instanceof ConstantCallSite) {
-return getTarget0();  // will not change dynamically
+/*non-public*/ MethodHandle makeDynamicInvoker() {
-}
 MethodHandle getTarget = MethodHandleImpl.bindReceiver(IMPL_TOKEN, GET_TARGET, this);
 MethodHandle invoker = MethodHandles.exactInvoker(this.type());
 return MethodHandles.foldArguments(invoker, getTarget);
 }
 private static final MethodHandle GET_TARGET;
 static {
 try {
 GET_TARGET = MethodHandles.Lookup.IMPL_LOOKUP.
 findVirtual(CallSite.class, "getTarget", MethodType.methodType(MethodHandle.class));

changeset 8346	3b891698c4ec
parent 7562	a0ad195efe2c
child 8347	e5daa5772ffd