diff --git a/src/share/classes/java/lang/invoke/CallSite.java b/src/share/classes/java/lang/invoke/CallSite.java index 465cd779be6bac091178686c5be8f6a60afc2e0f..9bc2033c6f5ed534fe130387a19474c61137044b 100644 --- a/src/share/classes/java/lang/invoke/CallSite.java +++ b/src/share/classes/java/lang/invoke/CallSite.java @@ -266,7 +266,7 @@ public class CallSite { /*package-private*/ void setTargetNormal(MethodHandle newTarget) { - target = newTarget; + MethodHandleNatives.setCallSiteTargetNormal(this, newTarget); } /*package-private*/ MethodHandle getTargetVolatile() { @@ -274,7 +274,7 @@ public class CallSite { } /*package-private*/ void setTargetVolatile(MethodHandle newTarget) { - unsafe.putObjectVolatile(this, TARGET_OFFSET, newTarget); + MethodHandleNatives.setCallSiteTargetVolatile(this, newTarget); } // this implements the upcall from the JVM, MethodHandleNatives.makeDynamicCallSite: diff --git a/src/share/classes/java/lang/invoke/MethodHandleNatives.java b/src/share/classes/java/lang/invoke/MethodHandleNatives.java index e01d9b1bf45a61c01268abfe728a479fc471f100..9670cfe4cccd9878163772345a8e33aa244d11b9 100644 --- a/src/share/classes/java/lang/invoke/MethodHandleNatives.java +++ b/src/share/classes/java/lang/invoke/MethodHandleNatives.java @@ -61,15 +61,6 @@ class MethodHandleNatives { /** Initialize a method type, once per form. */ static native void init(MethodType self); - /** Tell the JVM about a class's bootstrap method. */ - static native void registerBootstrap(Class caller, MethodHandle bootstrapMethod); - - /** Ask the JVM about a class's bootstrap method. */ - static native MethodHandle getBootstrap(Class caller); - - /** Tell the JVM that we need to change the target of an invokedynamic. */ - static native void setCallSiteTarget(CallSite site, MethodHandle target); - /** Fetch the vmtarget field. * It will be sanitized as necessary to avoid exposing non-Java references. * This routine is for debugging and reflection. @@ -122,6 +113,12 @@ class MethodHandleNatives { static final boolean COUNT_GWT; + /// CallSite support + + /** Tell the JVM that we need to change the target of a CallSite. */ + static native void setCallSiteTargetNormal(CallSite site, MethodHandle target); + static native void setCallSiteTargetVolatile(CallSite site, MethodHandle target); + private static native void registerNatives(); static { registerNatives(); diff --git a/test/java/lang/invoke/CallSiteTest.java b/test/java/lang/invoke/CallSiteTest.java new file mode 100644 index 0000000000000000000000000000000000000000..89b05068893c0c514343a48e35693fb475d44422 --- /dev/null +++ b/test/java/lang/invoke/CallSiteTest.java @@ -0,0 +1,161 @@ +/* + * Copyright (c) 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. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +/** + * @test + * @summary smoke tests for CallSite + * + * @build indify.Indify + * @compile CallSiteTest.java + * @run main/othervm + * indify.Indify + * --expand-properties --classpath ${test.classes} + * --java test.java.lang.invoke.CallSiteTest + */ + +package test.java.lang.invoke; + +import static org.junit.Assert.*; + +import java.io.*; + +import java.lang.invoke.*; +import static java.lang.invoke.MethodHandles.*; +import static java.lang.invoke.MethodType.*; + +public class CallSiteTest { + private final static Class CLASS = CallSiteTest.class; + + private static CallSite mcs; + private static CallSite vcs; + private static MethodHandle mh_foo; + private static MethodHandle mh_bar; + + static { + try { + mh_foo = lookup().findStatic(CLASS, "foo", methodType(int.class, int.class, int.class)); + mh_bar = lookup().findStatic(CLASS, "bar", methodType(int.class, int.class, int.class)); + mcs = new MutableCallSite(mh_foo); + vcs = new VolatileCallSite(mh_foo); + } catch (Exception e) { + e.printStackTrace(); + } + } + + public static void main(String... av) throws Throwable { + testMutableCallSite(); + testVolatileCallSite(); + } + + private final static int N = Integer.MAX_VALUE / 100; + private final static int RESULT1 = 762786192; + private final static int RESULT2 = -21474836; + + private static void testMutableCallSite() throws Throwable { + // warm-up + for (int i = 0; i < 20000; i++) { + mcs.setTarget(mh_foo); + } + // run + for (int n = 0; n < 2; n++) { + mcs.setTarget(mh_foo); + for (int i = 0; i < 5; i++) { + assertEquals(RESULT1, runMutableCallSite()); + } + mcs.setTarget(mh_bar); + for (int i = 0; i < 5; i++) { + assertEquals(RESULT2, runMutableCallSite()); + } + } + } + private static void testVolatileCallSite() throws Throwable { + // warm-up + for (int i = 0; i < 20000; i++) { + vcs.setTarget(mh_foo); + } + // run + for (int n = 0; n < 2; n++) { + vcs.setTarget(mh_foo); + for (int i = 0; i < 5; i++) { + assertEquals(RESULT1, runVolatileCallSite()); + } + vcs.setTarget(mh_bar); + for (int i = 0; i < 5; i++) { + assertEquals(RESULT2, runVolatileCallSite()); + } + } + } + + private static int runMutableCallSite() throws Throwable { + int sum = 0; + for (int i = 0; i < N; i++) { + sum += (int) INDY_mcs().invokeExact(i, i+1); + } + return sum; + } + private static int runVolatileCallSite() throws Throwable { + int sum = 0; + for (int i = 0; i < N; i++) { + sum += (int) INDY_vcs().invokeExact(i, i+1); + } + return sum; + } + + static int foo(int a, int b) { return a + b; } + static int bar(int a, int b) { return a - b; } + + private static MethodType MT_bsm() { + shouldNotCallThis(); + return methodType(CallSite.class, Lookup.class, String.class, MethodType.class); + } + + private static CallSite bsm_mcs(Lookup caller, String name, MethodType type) throws ReflectiveOperationException { + return mcs; + } + private static MethodHandle MH_bsm_mcs() throws ReflectiveOperationException { + shouldNotCallThis(); + return lookup().findStatic(lookup().lookupClass(), "bsm_mcs", MT_bsm()); + } + private static MethodHandle INDY_mcs() throws Throwable { + shouldNotCallThis(); + return ((CallSite) MH_bsm_mcs().invoke(lookup(), "foo", methodType(int.class, int.class, int.class))).dynamicInvoker(); + } + + private static CallSite bsm_vcs(Lookup caller, String name, MethodType type) throws ReflectiveOperationException { + return vcs; + } + private static MethodHandle MH_bsm_vcs() throws ReflectiveOperationException { + shouldNotCallThis(); + return lookup().findStatic(lookup().lookupClass(), "bsm_vcs", MT_bsm()); + } + private static MethodHandle INDY_vcs() throws Throwable { + shouldNotCallThis(); + return ((CallSite) MH_bsm_vcs().invoke(lookup(), "foo", methodType(int.class, int.class, int.class))).dynamicInvoker(); + } + + private static void shouldNotCallThis() { + // if this gets called, the transformation has not taken place + throw new AssertionError("this code should be statically transformed away by Indify"); + } +}