提交 c345ae6c 编写于 作者: L lana

Merge

......@@ -247,10 +247,6 @@ class AdapterMethodHandle extends BoundMethodHandle {
MethodType needConversion = MethodType.methodType(needReturn, haveReturn);
adjustReturn = MethodHandles.identity(needReturn).asType(needConversion);
}
if (!canCollectArguments(adjustReturn.type(), target.type(), 0, false)) {
assert(MethodHandleNatives.workaroundWithoutRicochetFrames()); // this code is deprecated
throw new InternalError("NYI");
}
return makeCollectArguments(adjustReturn, target, 0, false);
}
......
因为 它太大了无法显示 source diff 。你可以改为 查看blob
/*
* 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
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* 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.
*/
package java.lang.invoke;
import static java.lang.invoke.MethodHandleStatics.*;
import static java.lang.invoke.MethodHandles.Lookup.IMPL_LOOKUP;
/**
* Unary function composition, useful for many small plumbing jobs.
* The invoke method takes a single reference argument, and returns a reference
* Internally, it first calls the {@code filter} method on the argument,
* Making up the difference between the raw method type and the
* final method type is the responsibility of a JVM-level adapter.
* @author jrose
*/
class FilterOneArgument extends BoundMethodHandle {
protected final MethodHandle filter; // Object -> Object
protected final MethodHandle target; // Object -> Object
@Override
String debugString() {
return target.toString();
}
protected Object invoke(Object argument) throws Throwable {
Object filteredArgument = filter.invokeExact(argument);
return target.invokeExact(filteredArgument);
}
private static final MethodHandle INVOKE;
static {
try {
INVOKE =
IMPL_LOOKUP.findVirtual(FilterOneArgument.class, "invoke",
MethodType.genericMethodType(1));
} catch (ReflectiveOperationException ex) {
throw uncaughtException(ex);
}
}
protected FilterOneArgument(MethodHandle filter, MethodHandle target) {
super(INVOKE);
this.filter = filter;
this.target = target;
}
static {
assert(MethodHandleNatives.workaroundWithoutRicochetFrames()); // this class is deprecated
}
public static MethodHandle make(MethodHandle filter, MethodHandle target) {
if (filter == null) return target;
if (target == null) return filter;
return new FilterOneArgument(filter, target);
}
// MethodHandle make(MethodHandle filter1, MethodHandle filter2, MethodHandle target) {
// MethodHandle filter = make(filter1, filter2);
// return make(filter, target);
// }
}
......@@ -391,13 +391,4 @@ class MethodHandleNatives {
throw err;
}
}
/**
* This assertion marks code which was written before ricochet frames were implemented.
* Such code will go away when the ports catch up.
*/
static boolean workaroundWithoutRicochetFrames() {
assert(!HAVE_RICOCHET_FRAMES) : "this code should not be executed if `-XX:+UseRicochetFrames is enabled";
return true;
}
}
......@@ -27,6 +27,7 @@ package java.lang.invoke;
import java.lang.reflect.*;
import sun.invoke.WrapperInstance;
import java.util.ArrayList;
/**
* This class consists exclusively of static methods that help adapt
......@@ -134,14 +135,19 @@ public class MethodHandleProxies {
//
public static
<T> T asInterfaceInstance(final Class<T> intfc, final MethodHandle target) {
// POC implementation only; violates the above contract several ways
final Method sm = getSingleMethod(intfc);
if (sm == null)
if (!intfc.isInterface() || !Modifier.isPublic(intfc.getModifiers()))
throw new IllegalArgumentException("not a public interface: "+intfc.getName());
final Method[] methods = getSingleNameMethods(intfc);
if (methods == null)
throw new IllegalArgumentException("not a single-method interface: "+intfc.getName());
MethodType smMT = MethodType.methodType(sm.getReturnType(), sm.getParameterTypes());
MethodHandle checkTarget = target.asType(smMT); // make throw WMT
checkTarget = checkTarget.asType(checkTarget.type().changeReturnType(Object.class));
final MethodHandle vaTarget = checkTarget.asSpreader(Object[].class, smMT.parameterCount());
final MethodHandle[] vaTargets = new MethodHandle[methods.length];
for (int i = 0; i < methods.length; i++) {
Method sm = methods[i];
MethodType smMT = MethodType.methodType(sm.getReturnType(), sm.getParameterTypes());
MethodHandle checkTarget = target.asType(smMT); // make throw WMT
checkTarget = checkTarget.asType(checkTarget.type().changeReturnType(Object.class));
vaTargets[i] = checkTarget.asSpreader(Object[].class, smMT.parameterCount());
}
return intfc.cast(Proxy.newProxyInstance(
intfc.getClassLoader(),
new Class[]{ intfc, WrapperInstance.class },
......@@ -152,13 +158,15 @@ public class MethodHandleProxies {
throw new AssertionError();
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
for (int i = 0; i < methods.length; i++) {
if (method.equals(methods[i]))
return vaTargets[i].invokeExact(args);
}
if (method.getDeclaringClass() == WrapperInstance.class)
return getArg(method.getName());
if (method.equals(sm))
return vaTarget.invokeExact(args);
if (isObjectMethod(method))
return callObjectMethod(this, method, args);
throw new InternalError();
return callObjectMethod(proxy, method, args);
throw new InternalError("bad proxy method: "+method);
}
}));
}
......@@ -241,17 +249,20 @@ public class MethodHandleProxies {
}
private static
Method getSingleMethod(Class<?> intfc) {
if (!intfc.isInterface()) return null;
Method sm = null;
Method[] getSingleNameMethods(Class<?> intfc) {
ArrayList<Method> methods = new ArrayList<Method>();
String uniqueName = null;
for (Method m : intfc.getMethods()) {
int mod = m.getModifiers();
if (Modifier.isAbstract(mod)) {
if (sm != null && !isObjectMethod(sm))
return null; // too many abstract methods
sm = m;
}
if (isObjectMethod(m)) continue;
if (!Modifier.isAbstract(m.getModifiers())) continue;
String mname = m.getName();
if (uniqueName == null)
uniqueName = mname;
else if (!uniqueName.equals(mname))
return null; // too many abstract methods
methods.add(m);
}
return sm;
if (uniqueName == null) return null;
return methods.toArray(new Method[methods.size()]);
}
}
......@@ -1995,16 +1995,8 @@ System.out.println((int) f0.invokeExact("x", "y")); // 2
// lambda( arg...) { target(arg...) } )
MethodType newType = targetType.changeReturnType(filterType.returnType());
MethodHandle result = null;
if (AdapterMethodHandle.canCollectArguments(filterType, targetType, 0, false)) {
result = AdapterMethodHandle.makeCollectArguments(filter, target, 0, false);
if (result != null) return result;
}
// FIXME: Too many nodes here.
assert(MethodHandleNatives.workaroundWithoutRicochetFrames()); // this class is deprecated
MethodHandle returner = dropArguments(filter, filterValues, targetType.parameterList());
result = foldArguments(returner, target);
assert(result.type().equals(newType));
return result;
assert(AdapterMethodHandle.canCollectArguments(filterType, targetType, 0, false));
return AdapterMethodHandle.makeCollectArguments(filter, target, 0, false);
}
/**
......
......@@ -56,10 +56,6 @@ class MethodTypeForm {
/*lazy*/ MethodType primsAtEnd; // reorder primitives to the end
// Cached adapter information:
/*lazy*/ ToGeneric toGeneric; // convert cs. with prims to w/o
/*lazy*/ FromGeneric fromGeneric; // convert cs. w/o prims to with
/*lazy*/ SpreadGeneric[] spreadGeneric; // expand one argument to many
/*lazy*/ FilterGeneric filterGeneric; // convert argument(s) on the fly
/*lazy*/ MethodHandle genericInvoker; // hook for inexact invoke
public MethodType erasedType() {
......
......@@ -127,12 +127,8 @@ public abstract class RenderingEngine {
try {
Class cls = Class.forName(ductusREClass);
return cls.newInstance();
} catch (ClassNotFoundException x) {
} catch (ReflectiveOperationException ignored) {
// not found
} catch (IllegalAccessException x) {
// should not reach here
} catch (InstantiationException x) {
// should not reach here
}
}
......
......@@ -30,6 +30,8 @@
extern "C" {
#endif
#include <stddef.h>
#include "java_awt_AlphaComposite.h"
#include "SurfaceData.h"
......@@ -484,7 +486,9 @@ extern struct _CompositeTypes {
#define ArraySize(A) (sizeof(A) / sizeof(A[0]))
#define PtrAddBytes(p, b) ((void *) (((intptr_t) (p)) + (b)))
#define PtrCoord(p, x, xinc, y, yinc) PtrAddBytes(p, (y)*(yinc) + (x)*(xinc))
#define PtrCoord(p, x, xinc, y, yinc) PtrAddBytes(p, \
((ptrdiff_t)(y))*(yinc) + \
((ptrdiff_t)(x))*(xinc))
/*
* The function to call with an array of NativePrimitive structures
......
......@@ -347,6 +347,11 @@ public class FontConfigManager {
name = name.toLowerCase();
initFontConfigFonts(false);
if (fontConfigFonts == null) {
// This avoids an immediate NPE if fontconfig look up failed
// but doesn't guarantee this is a recoverable situation.
return null;
}
FcCompFont fcInfo = null;
for (int i=0; i<fontConfigFonts.length; i++) {
......
......@@ -69,6 +69,7 @@ public class JavaDocExamplesTest {
testDropArguments();
testFilterArguments();
testFoldArguments();
testFoldArguments2();
testMethodHandlesSummary();
testAsSpreader();
testAsCollector();
......@@ -490,6 +491,47 @@ assertEquals("hodmet", (String) worker.invokeExact("met", "hod"));
}}
}
@Test public void testFoldArguments2() throws Throwable {
{{
{} /// JAVADOC
// argument-based dispatch for methods of the form boolean x.___(y: String)
Lookup lookup = publicLookup();
// first, a tracing hack:
MethodHandle println = lookup.findVirtual(java.io.PrintStream.class, "println", methodType(void.class, String.class));
MethodHandle arrayToString = lookup.findStatic(Arrays.class, "toString", methodType(String.class, Object[].class));
MethodHandle concat = lookup.findVirtual(String.class, "concat", methodType(String.class, String.class));
MethodHandle arrayToString_DIS = filterReturnValue(arrayToString, concat.bindTo("DIS:"));
MethodHandle arrayToString_INV = filterReturnValue(arrayToString, concat.bindTo("INV:"));
MethodHandle printArgs_DIS = filterReturnValue(arrayToString_DIS, println.bindTo(System.out)).asVarargsCollector(Object[].class);
MethodHandle printArgs_INV = filterReturnValue(arrayToString_INV, println.bindTo(System.out)).asVarargsCollector(Object[].class);
// metaobject protocol:
MethodType mtype = methodType(boolean.class, String.class);
MethodHandle findVirtual = lookup.findVirtual(Lookup.class,
"findVirtual", methodType(MethodHandle.class, Class.class, String.class, MethodType.class));
MethodHandle getClass = lookup.findVirtual(Object.class,
"getClass", methodType(Class.class));
MethodHandle dispatch = findVirtual;
dispatch = filterArguments(dispatch, 1, getClass);
dispatch = insertArguments(dispatch, 3, mtype);
dispatch = dispatch.bindTo(lookup);
assertEquals(methodType(MethodHandle.class, Object.class, String.class), dispatch.type());
MethodHandle invoker = invoker(mtype.insertParameterTypes(0, Object.class));
// wrap tracing around the dispatch and invoke steps:
dispatch = foldArguments(dispatch, printArgs_DIS.asType(dispatch.type().changeReturnType(void.class)));
invoker = foldArguments(invoker, printArgs_INV.asType(invoker.type().changeReturnType(void.class)));
invoker = dropArguments(invoker, 2, String.class); // ignore selector
// compose the dispatcher and the invoker:
MethodHandle invokeDispatched = foldArguments(invoker, dispatch);
Object x = "football", y = new java.util.Scanner("bar");
assert( (boolean) invokeDispatched.invokeExact(x, "startsWith", "foo"));
assert(!(boolean) invokeDispatched.invokeExact(x, "startsWith", "#"));
assert( (boolean) invokeDispatched.invokeExact(x, "endsWith", "all"));
assert(!(boolean) invokeDispatched.invokeExact(x, "endsWith", "foo"));
assert( (boolean) invokeDispatched.invokeExact(y, "hasNext", "[abc]+[rst]"));
assert(!(boolean) invokeDispatched.invokeExact(y, "hasNext", "[123]+[789]"));
}}
}
/* ---- TEMPLATE ----
@Test public void testFoo() throws Throwable {
{{
......
......@@ -82,6 +82,7 @@ public class RicochetTest {
testLongSpreads();
testIntCollects();
testReturns();
testRecursion();
}
@Test
......@@ -371,6 +372,61 @@ public class RicochetTest {
//System.out.println("faultCount="+faultCount);
}
@Test
public void testRecursion() throws Throwable {
if (!startTest("testRecursion")) return;
final int LIMIT = 10;
for (int i = 0; i < LIMIT; i++) {
RFCB rfcb = new RFCB(i);
Object x = "x", y = "y";
Object result = rfcb.recursiveFunction(x, y);
verbose(1, result);
}
}
/** Recursive Function Control Block */
private static class RFCB {
java.util.Random random;
final MethodHandle[] fns;
int depth;
RFCB(int seed) throws Throwable {
this.random = new java.util.Random(seed);
this.fns = new MethodHandle[Math.max(29, (1 << MAX_DEPTH-2)/3)];
java.util.Arrays.fill(fns, lookup().bind(this, "recursiveFunction", genericMethodType(2)));
for (int i = 5; i < fns.length; i++) {
switch (i % 4) {
case 0: fns[i] = filterArguments(fns[i - 5], 0, insertArguments(fns[i - 4], 1, ".")); break;
case 1: fns[i] = filterArguments(fns[i - 5], 1, insertArguments(fns[i - 3], 1, ".")); break;
case 2: fns[i] = filterReturnValue(fns[i - 5], insertArguments(fns[i - 2], 1, ".")); break;
}
}
}
Object recursiveFunction(Object x, Object y) throws Throwable {
depth++;
try {
final int ACTION_COUNT = 11;
switch (random.nextInt(ACTION_COUNT)) {
case 1:
Throwable ex = new RuntimeException();
ex.fillInStackTrace();
if (VERBOSITY >= 2) ex.printStackTrace();
x = "ST; " + x;
break;
case 2:
System.gc();
x = "GC; " + x;
break;
}
boolean isLeaf = (depth >= MAX_DEPTH);
if (isLeaf) {
return Arrays.asList(x, y).toString();
}
return fns[random.nextInt(fns.length)].invokeExact(x, y);
} finally {
depth--;
}
}
}
private static MethodHandle sequence(MethodHandle mh1, MethodHandle... mhs) {
MethodHandle res = mh1;
for (MethodHandle mh2 : mhs)
......@@ -536,6 +592,7 @@ public class RicochetTest {
}
// stress modes:
private static final int MAX_DEPTH = getProperty("MAX_DEPTH", 5);
private static final int REPEAT = getProperty("REPEAT", 0);
private static final int STRESS = getProperty("STRESS", 0);
private static /*v*/ int STRESS_COUNT;
......
/*
* 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. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* 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 unit tests for method handles which permute their arguments
* @run junit test.java.lang.invoke.ThrowExceptionsTest
*/
package test.java.lang.invoke;
import org.junit.*;
import java.util.*;
import java.lang.reflect.*;
import java.lang.invoke.*;
import static java.lang.invoke.MethodHandles.*;
import static java.lang.invoke.MethodType.*;
public class ThrowExceptionsTest {
private static final Class CLASS = ThrowExceptionsTest.class;
private static final Lookup LOOKUP = lookup();
public static void main(String argv[]) throws Throwable {
new ThrowExceptionsTest().testAll((argv.length == 0 ? null : Arrays.asList(argv).toString()));
}
@Test
public void testWMT() throws Throwable {
// mostly call testWMTCallee, but sometimes call its void-returning variant
MethodHandle mh = testWMTCallee();
MethodHandle mh1 = mh.asType(mh.type().changeReturnType(void.class));
assert(mh1 != mh);
testWMT(mh, mh1, 1000);
}
@Test
public void testBoundWMT() throws Throwable {
// mostly call exactInvoker.bindTo(testWMTCallee), but sometimes call its void-returning variant
MethodHandle callee = testWMTCallee();
MethodHandle callee1 = callee.asType(callee.type().changeReturnType(void.class));
MethodHandle invoker = exactInvoker(callee.type());
MethodHandle mh = invoker.bindTo(callee);
MethodHandle mh1 = invoker.bindTo(callee1);
testWMT(mh, mh1, 1000);
}
@Test
public void testFoldWMT() throws Throwable {
// mostly call exactInvoker.fold(constant(testWMTCallee)), but sometimes call its void-returning variant
MethodHandle callee = testWMTCallee();
MethodHandle callee1 = callee.asType(callee.type().changeReturnType(void.class));
MethodHandle invoker = exactInvoker(callee.type());
MethodHandle mh = foldArguments(invoker, constant(MethodHandle.class, callee));
MethodHandle mh1 = foldArguments(invoker, constant(MethodHandle.class, callee1));
testWMT(mh, mh1, 1000);
}
@Test
public void testFoldCCE() throws Throwable {
MethodHandle callee = testWMTCallee();
MethodHandle callee1 = callee.asType(callee.type().changeParameterType(1, Number.class)).asType(callee.type());
MethodHandle invoker = exactInvoker(callee.type());
MethodHandle mh = foldArguments(invoker, constant(MethodHandle.class, callee));
MethodHandle mh1 = foldArguments(invoker, constant(MethodHandle.class, callee1));
testWMT(mh, mh1, 1000);
}
@Test
public void testStackOverflow() throws Throwable {
MethodHandle callee = testWMTCallee();
MethodHandle callee1 = makeStackOverflow().asType(callee.type());
MethodHandle invoker = exactInvoker(callee.type());
MethodHandle mh = foldArguments(invoker, constant(MethodHandle.class, callee));
MethodHandle mh1 = foldArguments(invoker, constant(MethodHandle.class, callee1));
for (int i = 0; i < REPEAT; i++) {
try {
testWMT(mh, mh1, 1000);
} catch (StackOverflowError ex) {
// OK, try again
}
}
}
private static MethodHandle makeStackOverflow() {
MethodType cellType = methodType(void.class);
MethodHandle[] cell = { null }; // recursion point
MethodHandle getCell = insertArguments(arrayElementGetter(cell.getClass()), 0, cell, 0);
MethodHandle invokeCell = foldArguments(exactInvoker(cellType), getCell);
assert(invokeCell.type() == cellType);
cell[0] = invokeCell;
// make it conformable to any type:
invokeCell = dropArguments(invokeCell, 0, Object[].class).asVarargsCollector(Object[].class);
return invokeCell;
}
static int testCases;
private void testAll(String match) throws Throwable {
testCases = 0;
Lookup lookup = lookup();
for (Method m : CLASS.getDeclaredMethods()) {
String name = m.getName();
if (name.startsWith("test") &&
(match == null || match.contains(name.substring("test".length()))) &&
m.getParameterTypes().length == 0 &&
Modifier.isPublic(m.getModifiers()) &&
!Modifier.isStatic(m.getModifiers())) {
System.out.println("["+name+"]");
int tc = testCases;
try {
m.invoke(this);
} catch (Throwable ex) {
System.out.println("*** "+ex);
ex.printStackTrace();
}
if (testCases == tc) testCases++;
}
}
if (testCases == 0) throw new RuntimeException("no test cases found");
System.out.println("ran a total of "+testCases+" test cases");
}
private static MethodHandle findStatic(String name) {
return findMethod(name, true);
}
private static MethodHandle findVirtual(String name) {
return findMethod(name, false);
}
private static MethodHandle findMethod(String name, boolean isStatic) {
MethodHandle mh = null;
for (Method m : CLASS.getDeclaredMethods()) {
if (m.getName().equals(name) &&
Modifier.isStatic(m.getModifiers()) == isStatic) {
if (mh != null)
throw new RuntimeException("duplicate methods: "+name);
try {
mh = LOOKUP.unreflect(m);
} catch (ReflectiveOperationException ex) {
throw new RuntimeException(ex);
}
}
}
if (mh == null)
throw new RuntimeException("no method: "+name);
return mh;
}
int testWMTCallee;
private int testWMTCallee(String x) {
return testWMTCallee++;
}
private static MethodHandle testWMTCallee() {
MethodHandle callee = findVirtual("testWMTCallee");
// FIXME: should not have to retype callee
callee = callee.asType(callee.type().changeParameterType(0, Object.class));
return callee;
}
private Exception testWMT(MethodHandle[] mhs, int reps) throws Throwable {
testCases += 1;
testWMTCallee = 0;
int catches = 0;
Exception savedEx = null;
for (int i = 0; i < reps; i++) {
MethodHandle mh = mhs[i % mhs.length];
int n;
try {
// FIXME: should not have to retype this
n = (int) mh.invokeExact((Object)this, "x");
assertEquals(n, i - catches);
// Using the exact type for this causes endless deopt due to
// 'non_cached_result' in SystemDictionary::find_method_handle_invoke.
// The problem is that the compiler thread needs to access a cached
// invoke method, but invoke methods are not cached if one of the
// component types is not on the BCP.
} catch (Exception ex) {
savedEx = ex;
catches++;
}
}
//VERBOSE: System.out.println("reps="+reps+" catches="+catches);
return savedEx;
}
private static final int REPEAT = Integer.getInteger(CLASS.getSimpleName()+".REPEAT", 10);
private Exception testWMT(MethodHandle mh, MethodHandle mh1, int reps) throws Throwable {
//VERBOSE: System.out.println("mh="+mh+" mh1="+mh1);
MethodHandle[] mhs = new MethodHandle[100];
Arrays.fill(mhs, mh);
int patch = mhs.length-1;
Exception savedEx = null;
for (int i = 0; i < REPEAT; i++) {
mhs[patch] = mh;
testWMT(mhs, 10000);
mhs[patch] = mh1;
savedEx = testWMT(mhs, reps);
}
return savedEx;
}
private static void assertEquals(Object x, Object y) {
if (x == y || x != null && x.equals(y)) return;
throw new RuntimeException(x+" != "+y);
}
}
Markdown is supported
0% .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑!
想要评论请 注册