From f80ab05dfac0d060acb20a324d9fec67ff639e39 Mon Sep 17 00:00:00 2001 From: Charles Oliver Nutter Date: Sun, 22 Jan 2012 15:48:48 -0600 Subject: [PATCH] Start using invokebinder to build method handle chains. --- build.xml | 3 + build_lib/invokebinder.jar | Bin 0 -> 15581 bytes shared.iml | 9 + .../invokedynamic/InvocationLinker.java | 396 +++++------------- 4 files changed, 126 insertions(+), 282 deletions(-) create mode 100644 build_lib/invokebinder.jar diff --git a/build.xml b/build.xml index 81261de41e9..8e573a339c5 100644 --- a/build.xml +++ b/build.xml @@ -370,6 +370,7 @@ + @@ -473,6 +474,7 @@ + @@ -628,6 +630,7 @@ + diff --git a/build_lib/invokebinder.jar b/build_lib/invokebinder.jar new file mode 100644 index 0000000000000000000000000000000000000000..e8dd2d1fd2c80b24503eefe6544911d09dda1439 GIT binary patch literal 15581 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 literal 0 HcmV?d00001 diff --git a/shared.iml b/shared.iml index b13a81faa1a..8849eeba126 100644 --- a/shared.iml +++ b/shared.iml @@ -487,6 +487,15 @@ + + + + + + + + + diff --git a/src/org/jruby/runtime/invokedynamic/InvocationLinker.java b/src/org/jruby/runtime/invokedynamic/InvocationLinker.java index b9b41274731..5d289fdbd38 100644 --- a/src/org/jruby/runtime/invokedynamic/InvocationLinker.java +++ b/src/org/jruby/runtime/invokedynamic/InvocationLinker.java @@ -37,6 +37,8 @@ import java.lang.invoke.SwitchPoint; import java.math.BigInteger; import java.util.Arrays; + +import com.headius.invoke.binder.Binder; import org.jruby.Ruby; import org.jruby.RubyBasicObject; import org.jruby.RubyBoolean; @@ -45,6 +47,7 @@ import org.jruby.RubyFloat; import org.jruby.RubyInstanceConfig; import org.jruby.RubyModule; +import org.jruby.RubyObject; import org.jruby.RubyString; import org.jruby.exceptions.JumpException; import org.jruby.exceptions.RaiseException; @@ -1345,11 +1348,6 @@ private static MethodHandle createRubyHandle(JRubyCallSite site, DynamicMethod m DynamicMethod.NativeCall nativeCall = method.getNativeCall(); try { - nativeTarget = site.lookup().findStatic( - nativeCall.getNativeTarget(), - nativeCall.getNativeName(), - methodType(nativeCall.getNativeReturn(), - nativeCall.getNativeSignature())); Object scriptObject; if (method instanceof CompiledMethod) { scriptObject = ((CompiledMethod)method).getScriptObject(); @@ -1358,28 +1356,14 @@ private static MethodHandle createRubyHandle(JRubyCallSite site, DynamicMethod m } else { throw new RuntimeException("invalid method for ruby handle: " + method); } - - nativeTarget = insertArguments(nativeTarget, 0, scriptObject); - - // juggle args into correct places + int argCount = getRubyArgCount(nativeCall.getNativeSignature()); - switch (argCount) { - case 0: - nativeTarget = permuteArguments(nativeTarget, STANDARD_NATIVE_TYPE_BLOCK, new int[] {0, 2, 3}); - break; - case -1: - case 1: - nativeTarget = permuteArguments(nativeTarget, STANDARD_NATIVE_TYPE_1ARG_BLOCK, new int[] {0, 2, 3, 4}); - break; - case 2: - nativeTarget = permuteArguments(nativeTarget, STANDARD_NATIVE_TYPE_2ARG_BLOCK, new int[] {0, 2, 3, 4, 5}); - break; - case 3: - nativeTarget = permuteArguments(nativeTarget, STANDARD_NATIVE_TYPE_3ARG_BLOCK, new int[] {0, 2, 3, 4, 5, 6}); - break; - default: - throw new RuntimeException("unknown arg count: " + argCount); - } + + nativeTarget = Binder + .from(STANDARD_NATIVE_TYPES_BLOCK[Math.abs(argCount)]) + .permute(TC_SELF_ARGS_BLOCK_PERMUTES[Math.abs(argCount)]) + .insert(0, scriptObject) + .invokeStaticQuiet(site.lookup(), nativeCall.getNativeTarget(), nativeCall.getNativeName()); method.setHandle(nativeTarget); return nativeTarget; @@ -1480,32 +1464,29 @@ public static DynamicMethod getMethod(CacheEntry entry) { return entry.method; } - private static final MethodHandle PGC = dropArguments( - dropArguments( - findStatic(InvokeDynamicSupport.class, "pollAndGetClass", - methodType(RubyClass.class, ThreadContext.class, IRubyObject.class)), - 1, - IRubyObject.class), - 0, - CacheEntry.class); - - private static final MethodHandle PGC2 = dropArguments( - findStatic(InvokeDynamicSupport.class, "pollAndGetClass", - methodType(RubyClass.class, ThreadContext.class, IRubyObject.class)), - 1, - IRubyObject.class); - - private static final MethodHandle TEST_GENERATION = dropArguments( - findStatic(InvocationLinker.class, "testGeneration", - methodType(boolean.class, int.class, IRubyObject.class)), - 1, - ThreadContext.class, IRubyObject.class); - - private static final MethodHandle TEST_METACLASS = dropArguments( - findStatic(InvocationLinker.class, "testMetaclass", - methodType(boolean.class, RubyModule.class, IRubyObject.class)), - 1, - ThreadContext.class, IRubyObject.class); + private static final MethodHandle PGC = Binder + .from(RubyClass.class, CacheEntry.class, ThreadContext.class, IRubyObject.class, IRubyObject.class) + .permute(1, 3) + .invokeStaticQuiet(lookup(), InvokeDynamicSupport.class, "pollAndGetClass"); + + private static final MethodHandle PGC2 = Binder + .from(RubyClass.class, ThreadContext.class, IRubyObject.class, IRubyObject.class) + .drop(1) + .invokeStaticQuiet(lookup(), InvokeDynamicSupport.class, "pollAndGetClass"); + + private static final Binder test_binder = Binder + .from(boolean.class, int.class, ThreadContext.class, IRubyObject.class, IRubyObject.class) + .drop(1, 2); + + private static final MethodHandle TEST_GENERATION = Binder + .from(boolean.class, int.class, ThreadContext.class, IRubyObject.class, IRubyObject.class) + .drop(1, 2) + .invokeStaticQuiet(lookup(), InvocationLinker.class, "testGeneration"); + + private static final MethodHandle TEST_METACLASS = Binder + .from(boolean.class, RubyModule.class, ThreadContext.class, IRubyObject.class, IRubyObject.class) + .drop(1, 2) + .invokeStaticQuiet(lookup(), InvocationLinker.class, "testMetaclass"); private static final MethodHandle TEST = RubyInstanceConfig.INVOKEDYNAMIC_INVOCATION_SWITCHPOINT ? @@ -1590,295 +1571,146 @@ private static MethodHandle dropArgs(MethodHandle original, int index, int count // Support handles for DynamicMethod.call paths //////////////////////////////////////////////////////////////////////////// - private static final MethodHandle PGC_0 = dropNameAndArgs(PGC, 4, 0, false); - private static final MethodHandle PGC2_0 = dropNameAndArgs(PGC2, 3, 0, false); - private static final MethodHandle GETMETHOD_0 = dropNameAndArgs(GETMETHOD, 5, 0, false); private static final MethodHandle TEST_0 = dropArgs(TEST, 4, 0, false); - private static final MethodHandle TARGET_0; - static { - MethodHandle target = findVirtual(DynamicMethod.class, "call", - methodType(IRubyObject.class, ThreadContext.class, IRubyObject.class, RubyModule.class, String.class)); - target = explicitCastArguments(target, methodType(IRubyObject.class, DynamicMethod.class, ThreadContext.class, IRubyObject.class, RubyClass.class, String.class)); - target = permuteArguments( - target, - methodType(IRubyObject.class, DynamicMethod.class, RubyClass.class, CacheEntry.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, String.class), - new int[] {0,3,5,1,6}); - // IRubyObject, DynamicMethod, RubyClass, CacheEntry, ThreadContext, IRubyObject, IRubyObject, String - target = foldArguments(target, GETMETHOD_0); - // IRubyObject, RubyClass, CacheEntry, ThreadContext, IRubyObject, IRubyObject, String - target = foldArguments(target, PGC_0); - // IRubyObject, CacheEntry, ThreadContext, IRubyObject, IRubyObject, String - TARGET_0 = target; - } + private static final MethodHandle TARGET_0 = Binder + .from(IRubyObject.class, CacheEntry.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, String.class) + .fold(dropNameAndArgs(PGC, 4, 0, false)) + .fold(dropNameAndArgs(GETMETHOD, 5, 0, false)) + .permute(0, 3, 5, 1, 6) + .cast(IRubyObject.class, DynamicMethod.class, ThreadContext.class, IRubyObject.class, RubyModule.class, String.class) + .invokeVirtualQuiet(lookup(), "call"); + private static final MethodHandle FALLBACK_0 = findStatic(InvocationLinker.class, "invocationFallback", methodType(IRubyObject.class, JRubyCallSite.class, ThreadContext.class, IRubyObject.class, IRubyObject.class)); private static final MethodHandle FAIL_0 = findStatic(InvocationLinker.class, "fail", methodType(IRubyObject.class, JRubyCallSite.class, ThreadContext.class, IRubyObject.class, IRubyObject.class)); - private static final MethodHandle PGC_1 = dropNameAndArgs(PGC, 4, 1, false); - private static final MethodHandle PGC2_1 = dropNameAndArgs(PGC2, 3, 1, false); - private static final MethodHandle GETMETHOD_1 = dropNameAndArgs(GETMETHOD, 5, 1, false); private static final MethodHandle TEST_1 = dropArgs(TEST, 4, 1, false); - private static final MethodHandle TARGET_1; - static { - MethodHandle target = findVirtual(DynamicMethod.class, "call", - methodType(IRubyObject.class, ThreadContext.class, IRubyObject.class, RubyModule.class, String.class, IRubyObject.class)); - // IRubyObject, DynamicMethod, ThreadContext, IRubyObject, RubyModule, String, IRubyObject - target = explicitCastArguments(target, methodType(IRubyObject.class, DynamicMethod.class, ThreadContext.class, IRubyObject.class, RubyClass.class, String.class, IRubyObject.class)); - // IRubyObject, DynamicMethod, ThreadContext, IRubyObject, RubyClass, String, IRubyObject - target = permuteArguments( - target, - methodType(IRubyObject.class, DynamicMethod.class, RubyClass.class, CacheEntry.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, String.class, IRubyObject.class), - new int[] {0,3,5,1,6,7}); - // IRubyObject, DynamicMethod, RubyClass, CacheEntry, ThreadContext, IRubyObject, IRubyObject, String, IRubyObject - target = foldArguments(target, GETMETHOD_1); - // IRubyObject, RubyClass, CacheEntry, ThreadContext, IRubyObject, IRubyObject, String, IRubyObject - target = foldArguments(target, PGC_1); - // IRubyObject, CacheEntry, ThreadContext, IRubyObject, IRubyObject, String, IRubyObject - TARGET_1 = target; - } + private static final MethodHandle TARGET_1 = Binder + .from(IRubyObject.class, CacheEntry.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, String.class, IRubyObject.class) + .fold(dropNameAndArgs(PGC, 4, 1, false)) + .fold(dropNameAndArgs(GETMETHOD, 5, 1, false)) + .permute(0, 3, 5, 1, 6, 7) + .cast(IRubyObject.class, DynamicMethod.class, ThreadContext.class, IRubyObject.class, RubyModule.class, String.class, IRubyObject.class) + .invokeVirtualQuiet(lookup(), "call"); + private static final MethodHandle FALLBACK_1 = findStatic(InvocationLinker.class, "invocationFallback", methodType(IRubyObject.class, JRubyCallSite.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, IRubyObject.class)); private static final MethodHandle FAIL_1 = findStatic(InvocationLinker.class, "fail", methodType(IRubyObject.class, JRubyCallSite.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, IRubyObject.class)); - private static final MethodHandle PGC_2 = dropNameAndArgs(PGC, 4, 2, false); - private static final MethodHandle GETMETHOD_2 = dropNameAndArgs(GETMETHOD, 5, 2, false); private static final MethodHandle TEST_2 = dropArgs(TEST, 4, 2, false); - private static final MethodHandle TARGET_2; - static { - MethodHandle target = findVirtual(DynamicMethod.class, "call", - methodType(IRubyObject.class, ThreadContext.class, IRubyObject.class, RubyModule.class, String.class, IRubyObject.class, IRubyObject.class)); - target = explicitCastArguments(target, methodType(IRubyObject.class, DynamicMethod.class, ThreadContext.class, IRubyObject.class, RubyClass.class, String.class, IRubyObject.class, IRubyObject.class)); - target = permuteArguments( - target, - methodType(IRubyObject.class, DynamicMethod.class, RubyClass.class, CacheEntry.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, String.class, IRubyObject.class, IRubyObject.class), - new int[] {0,3,5,1,6,7,8}); - // IRubyObject, DynamicMethod, RubyClass, CacheEntry, ThreadContext, IRubyObject, IRubyObject, String, args - target = foldArguments(target, GETMETHOD_2); - // IRubyObject, RubyClass, CacheEntry, ThreadContext, IRubyObject, IRubyObject, String, args - target = foldArguments(target, PGC_2); - // IRubyObject, CacheEntry, ThreadContext, IRubyObject, IRubyObject, String, args - TARGET_2 = target; - } + private static final MethodHandle TARGET_2 = Binder + .from(IRubyObject.class, CacheEntry.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, String.class, IRubyObject.class, IRubyObject.class) + .fold(dropNameAndArgs(PGC, 4, 2, false)) + .fold(dropNameAndArgs(GETMETHOD, 5, 2, false)) + .permute(0, 3, 5, 1, 6, 7, 8) + .cast(IRubyObject.class, DynamicMethod.class, ThreadContext.class, IRubyObject.class, RubyModule.class, String.class, IRubyObject.class, IRubyObject.class) + .invokeVirtualQuiet(lookup(), "call"); + private static final MethodHandle FALLBACK_2 = findStatic(InvocationLinker.class, "invocationFallback", methodType(IRubyObject.class, JRubyCallSite.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, IRubyObject.class, IRubyObject.class)); private static final MethodHandle FAIL_2 = findStatic(InvocationLinker.class, "fail", methodType(IRubyObject.class, JRubyCallSite.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, IRubyObject.class, IRubyObject.class)); - private static final MethodHandle PGC_3 = dropNameAndArgs(PGC, 4, 3, false); - private static final MethodHandle GETMETHOD_3 = dropNameAndArgs(GETMETHOD, 5, 3, false); private static final MethodHandle TEST_3 = dropArgs(TEST, 4, 3, false); - private static final MethodHandle TARGET_3; - static { - MethodHandle target = findVirtual(DynamicMethod.class, "call", - methodType(IRubyObject.class, ThreadContext.class, IRubyObject.class, RubyModule.class, String.class, IRubyObject.class, IRubyObject.class, IRubyObject.class)); - target = explicitCastArguments(target, methodType(IRubyObject.class, DynamicMethod.class, ThreadContext.class, IRubyObject.class, RubyClass.class, String.class, IRubyObject.class, IRubyObject.class, IRubyObject.class)); - target = permuteArguments( - target, - methodType(IRubyObject.class, DynamicMethod.class, RubyClass.class, CacheEntry.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, String.class, IRubyObject.class, IRubyObject.class, IRubyObject.class), - new int[] {0,3,5,1,6,7,8,9}); - // IRubyObject, DynamicMethod, RubyClass, CacheEntry, ThreadContext, IRubyObject, IRubyObject, String, args - target = foldArguments(target, GETMETHOD_3); - // IRubyObject, RubyClass, CacheEntry, ThreadContext, IRubyObject, IRubyObject, String, args - target = foldArguments(target, PGC_3); - // IRubyObject, CacheEntry, ThreadContext, IRubyObject, IRubyObject, String, args - TARGET_3 = target; - } + private static final MethodHandle TARGET_3 = Binder + .from(IRubyObject.class, CacheEntry.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, String.class, IRubyObject.class, IRubyObject.class, IRubyObject.class) + .fold(dropNameAndArgs(PGC, 4, 3, false)) + .fold(dropNameAndArgs(GETMETHOD, 5, 3, false)) + .permute(0, 3, 5, 1, 6, 7, 8, 9) + .cast(IRubyObject.class, DynamicMethod.class, ThreadContext.class, IRubyObject.class, RubyModule.class, String.class, IRubyObject.class, IRubyObject.class, IRubyObject.class) + .invokeVirtualQuiet(lookup(), "call"); + private static final MethodHandle FALLBACK_3 = findStatic(InvocationLinker.class, "invocationFallback", methodType(IRubyObject.class, JRubyCallSite.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, IRubyObject.class, IRubyObject.class, IRubyObject.class)); private static final MethodHandle FAIL_3 = findStatic(InvocationLinker.class, "fail", methodType(IRubyObject.class, JRubyCallSite.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, IRubyObject.class, IRubyObject.class, IRubyObject.class)); - private static final MethodHandle PGC_N = dropNameAndArgs(PGC, 4, -1, false); - private static final MethodHandle GETMETHOD_N = dropNameAndArgs(GETMETHOD, 5, -1, false); private static final MethodHandle TEST_N = dropArgs(TEST, 4, -1, false); - private static final MethodHandle TARGET_N; - static { - MethodHandle target = findVirtual(DynamicMethod.class, "call", - methodType(IRubyObject.class, ThreadContext.class, IRubyObject.class, RubyModule.class, String.class, IRubyObject[].class)); - target = explicitCastArguments(target, methodType(IRubyObject.class, DynamicMethod.class, ThreadContext.class, IRubyObject.class, RubyClass.class, String.class, IRubyObject[].class)); - target = permuteArguments( - target, - methodType(IRubyObject.class, DynamicMethod.class, RubyClass.class, CacheEntry.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, String.class, IRubyObject[].class), - new int[] {0,3,5,1,6,7}); - // IRubyObject, DynamicMethod, RubyClass, CacheEntry, ThreadContext, IRubyObject, IRubyObject, String, args - target = foldArguments(target, GETMETHOD_N); - // IRubyObject, RubyClass, CacheEntry, ThreadContext, IRubyObject, IRubyObject, String, args - target = foldArguments(target, PGC_N); - // IRubyObject, CacheEntry, ThreadContext, IRubyObject, IRubyObject, String, args - TARGET_N = target; - } + private static final MethodHandle TARGET_N = Binder + .from(IRubyObject.class, CacheEntry.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, String.class, IRubyObject[].class) + .fold(dropNameAndArgs(PGC, 4, -1, false)) + .fold(dropNameAndArgs(GETMETHOD, 5, -1, false)) + .permute(0, 3, 5, 1, 6, 7) + .cast(IRubyObject.class, DynamicMethod.class, ThreadContext.class, IRubyObject.class, RubyModule.class, String.class, IRubyObject[].class) + .invokeVirtualQuiet(lookup(), "call"); + private static final MethodHandle FALLBACK_N = findStatic(InvocationLinker.class, "invocationFallback", methodType(IRubyObject.class, JRubyCallSite.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, IRubyObject[].class)); private static final MethodHandle FAIL_N = findStatic(InvocationLinker.class, "fail", methodType(IRubyObject.class, JRubyCallSite.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, IRubyObject[].class)); - private static final MethodHandle BREAKJUMP; - static { - MethodHandle breakJump = findStatic( - InvokeDynamicSupport.class, - "handleBreakJump", - methodType(IRubyObject.class, JumpException.BreakJump.class, ThreadContext.class)); - // BreakJump, ThreadContext - breakJump = permuteArguments( - breakJump, - methodType(IRubyObject.class, JumpException.BreakJump.class, CacheEntry.class, ThreadContext.class, IRubyObject.class, IRubyObject.class), - new int[] {0,2}); - // BreakJump, CacheEntry, ThreadContext, IRubyObject, IRubyObject - BREAKJUMP = breakJump; - } - - private static final MethodHandle RETRYJUMP; - static { - MethodHandle retryJump = findStatic( - InvokeDynamicSupport.class, - "retryJumpError", - methodType(IRubyObject.class, ThreadContext.class)); - // ThreadContext - retryJump = permuteArguments( - retryJump, - methodType(IRubyObject.class, JumpException.RetryJump.class, CacheEntry.class, ThreadContext.class, IRubyObject.class, IRubyObject.class), - new int[] {2}); - // RetryJump, CacheEntry, ThreadContext, IRubyObject, IRubyObject - RETRYJUMP = retryJump; - } - - private static final MethodHandle PGC_0_B = dropNameAndArgs(PGC, 4, 0, true); - private static final MethodHandle GETMETHOD_0_B = dropNameAndArgs(GETMETHOD, 5, 0, true); private static final MethodHandle TEST_0_B = dropArgs(TEST, 4, 0, true); - private static final MethodHandle TARGET_0_B; - static { - MethodHandle target = findVirtual(DynamicMethod.class, "call", - methodType(IRubyObject.class, ThreadContext.class, IRubyObject.class, RubyModule.class, String.class, Block.class)); - target = explicitCastArguments(target, methodType(IRubyObject.class, DynamicMethod.class, ThreadContext.class, IRubyObject.class, RubyClass.class, String.class, Block.class)); - target = permuteArguments( - target, - methodType(IRubyObject.class, DynamicMethod.class, RubyClass.class, CacheEntry.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, String.class, Block.class), - new int[] {0,3,5,1,6,7}); - // IRubyObject, DynamicMethod, RubyClass, CacheEntry, ThreadContext, IRubyObject, IRubyObject, String, args - target = foldArguments(target, GETMETHOD_0_B); - // IRubyObject, RubyClass, CacheEntry, ThreadContext, IRubyObject, IRubyObject, String, args - target = foldArguments(target, PGC_0_B); - // IRubyObject, CacheEntry, ThreadContext, IRubyObject, IRubyObject, String, args - - TARGET_0_B = target; - } + private static final MethodHandle TARGET_0_B = Binder + .from(IRubyObject.class, CacheEntry.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, String.class, Block.class) + .fold(dropNameAndArgs(PGC, 4, 0, true)) + .fold(dropNameAndArgs(GETMETHOD, 5, 0, true)) + .permute(0, 3, 5, 1, 6, 7) + .cast(IRubyObject.class, DynamicMethod.class, ThreadContext.class, IRubyObject.class, RubyModule.class, String.class, Block.class) + .invokeVirtualQuiet(lookup(), "call"); + private static final MethodHandle FALLBACK_0_B = findStatic(InvocationLinker.class, "invocationFallback", methodType(IRubyObject.class, JRubyCallSite.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, Block.class)); private static final MethodHandle FAIL_0_B = findStatic(InvocationLinker.class, "fail", methodType(IRubyObject.class, JRubyCallSite.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, Block.class)); - private static final MethodHandle FAIL_ITER_0_B = findStatic(InvocationLinker.class, "failIter", - methodType(IRubyObject.class, JRubyCallSite.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, Block.class)); - private static final MethodHandle PGC_1_B = dropNameAndArgs(PGC, 4, 1, true); - private static final MethodHandle GETMETHOD_1_B = dropNameAndArgs(GETMETHOD, 5, 1, true); private static final MethodHandle TEST_1_B = dropArgs(TEST, 4, 1, true); - private static final MethodHandle TARGET_1_B; - static { - MethodHandle target = findVirtual(DynamicMethod.class, "call", - methodType(IRubyObject.class, ThreadContext.class, IRubyObject.class, RubyModule.class, String.class, IRubyObject.class, Block.class)); - target = explicitCastArguments(target, methodType(IRubyObject.class, DynamicMethod.class, ThreadContext.class, IRubyObject.class, RubyClass.class, String.class, IRubyObject.class, Block.class)); - target = permuteArguments( - target, - methodType(IRubyObject.class, DynamicMethod.class, RubyClass.class, CacheEntry.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, String.class, IRubyObject.class, Block.class), - new int[] {0,3,5,1,6,7,8}); - // IRubyObject, DynamicMethod, RubyClass, CacheEntry, ThreadContext, IRubyObject, IRubyObject, String, args - target = foldArguments(target, GETMETHOD_1_B); - // IRubyObject, RubyClass, CacheEntry, ThreadContext, IRubyObject, IRubyObject, String, args - target = foldArguments(target, PGC_1_B); - // IRubyObject, CacheEntry, ThreadContext, IRubyObject, IRubyObject, String, args - - TARGET_1_B = target; - } + private static final MethodHandle TARGET_1_B = Binder + .from(IRubyObject.class, CacheEntry.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, String.class, IRubyObject.class, Block.class) + .fold(dropNameAndArgs(PGC, 4, 1, true)) + .fold(dropNameAndArgs(GETMETHOD, 5, 1, true)) + .permute(0, 3, 5, 1, 6, 7, 8) + .cast(IRubyObject.class, DynamicMethod.class, ThreadContext.class, IRubyObject.class, RubyModule.class, String.class, IRubyObject.class, Block.class) + .invokeVirtualQuiet(lookup(), "call"); + private static final MethodHandle FALLBACK_1_B = findStatic(InvocationLinker.class, "invocationFallback", methodType(IRubyObject.class, JRubyCallSite.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, IRubyObject.class, Block.class)); private static final MethodHandle FAIL_1_B = findStatic(InvocationLinker.class, "fail", methodType(IRubyObject.class, JRubyCallSite.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, IRubyObject.class, Block.class)); - private static final MethodHandle FAIL_ITER_1_B = findStatic(InvocationLinker.class, "failIter", - methodType(IRubyObject.class, JRubyCallSite.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, IRubyObject.class, Block.class)); - private static final MethodHandle PGC_2_B = dropNameAndArgs(PGC, 4, 2, true); - private static final MethodHandle GETMETHOD_2_B = dropNameAndArgs(GETMETHOD, 5, 2, true); private static final MethodHandle TEST_2_B = dropArgs(TEST, 4, 2, true); - private static final MethodHandle TARGET_2_B; - static { - MethodHandle target = findVirtual(DynamicMethod.class, "call", - methodType(IRubyObject.class, ThreadContext.class, IRubyObject.class, RubyModule.class, String.class, IRubyObject.class, IRubyObject.class, Block.class)); - target = explicitCastArguments(target, methodType(IRubyObject.class, DynamicMethod.class, ThreadContext.class, IRubyObject.class, RubyClass.class, String.class, IRubyObject.class, IRubyObject.class, Block.class)); - target = permuteArguments( - target, - methodType(IRubyObject.class, DynamicMethod.class, RubyClass.class, CacheEntry.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, String.class, IRubyObject.class, IRubyObject.class, Block.class), - new int[] {0,3,5,1,6,7,8,9}); - // IRubyObject, DynamicMethod, RubyClass, CacheEntry, ThreadContext, IRubyObject, IRubyObject, String, args - target = foldArguments(target, GETMETHOD_2_B); - // IRubyObject, RubyClass, CacheEntry, ThreadContext, IRubyObject, IRubyObject, String, args - target = foldArguments(target, PGC_2_B); - // IRubyObject, CacheEntry, ThreadContext, IRubyObject, IRubyObject, String, args - - TARGET_2_B = target; - } + private static final MethodHandle TARGET_2_B = Binder + .from(IRubyObject.class, CacheEntry.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, String.class, IRubyObject.class, IRubyObject.class, Block.class) + .fold(dropNameAndArgs(PGC, 4, 2, true)) + .fold(dropNameAndArgs(GETMETHOD, 5, 2, true)) + .permute(0, 3, 5, 1, 6, 7, 8, 9) + .cast(IRubyObject.class, DynamicMethod.class, ThreadContext.class, IRubyObject.class, RubyModule.class, String.class, IRubyObject.class, IRubyObject.class, Block.class) + .invokeVirtualQuiet(lookup(), "call"); + private static final MethodHandle FALLBACK_2_B = findStatic(InvocationLinker.class, "invocationFallback", methodType(IRubyObject.class, JRubyCallSite.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, IRubyObject.class, IRubyObject.class, Block.class)); private static final MethodHandle FAIL_2_B = findStatic(InvocationLinker.class, "fail", methodType(IRubyObject.class, JRubyCallSite.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, IRubyObject.class, IRubyObject.class, Block.class)); - private static final MethodHandle FAIL_ITER_2_B = findStatic(InvocationLinker.class, "failIter", - methodType(IRubyObject.class, JRubyCallSite.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, IRubyObject.class, IRubyObject.class, Block.class)); - private static final MethodHandle PGC_3_B = dropNameAndArgs(PGC, 4, 3, true); - private static final MethodHandle GETMETHOD_3_B = dropNameAndArgs(GETMETHOD, 5, 3, true); private static final MethodHandle TEST_3_B = dropArgs(TEST, 4, 3, true); - private static final MethodHandle TARGET_3_B; - static { - MethodHandle target = findVirtual(DynamicMethod.class, "call", - methodType(IRubyObject.class, ThreadContext.class, IRubyObject.class, RubyModule.class, String.class, IRubyObject.class, IRubyObject.class, IRubyObject.class, Block.class)); - target = explicitCastArguments(target, methodType(IRubyObject.class, DynamicMethod.class, ThreadContext.class, IRubyObject.class, RubyClass.class, String.class, IRubyObject.class, IRubyObject.class, IRubyObject.class, Block.class)); - target = permuteArguments( - target, - methodType(IRubyObject.class, DynamicMethod.class, RubyClass.class, CacheEntry.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, String.class, IRubyObject.class, IRubyObject.class, IRubyObject.class, Block.class), - new int[] {0,3,5,1,6,7,8,9,10}); - // IRubyObject, DynamicMethod, RubyClass, CacheEntry, ThreadContext, IRubyObject, IRubyObject, String, args - target = foldArguments(target, GETMETHOD_3_B); - // IRubyObject, RubyClass, CacheEntry, ThreadContext, IRubyObject, IRubyObject, String, args - target = foldArguments(target, PGC_3_B); - // IRubyObject, CacheEntry, ThreadContext, IRubyObject, IRubyObject, String, args - - TARGET_3_B = target; - } + private static final MethodHandle TARGET_3_B = Binder + .from(IRubyObject.class, CacheEntry.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, String.class, IRubyObject.class, IRubyObject.class, IRubyObject.class, Block.class) + .fold(dropNameAndArgs(PGC, 4, 3, true)) + .fold(dropNameAndArgs(GETMETHOD, 5, 3, true)) + .permute(0, 3, 5, 1, 6, 7, 8, 9, 10) + .cast(IRubyObject.class, DynamicMethod.class, ThreadContext.class, IRubyObject.class, RubyModule.class, String.class, IRubyObject.class, IRubyObject.class, IRubyObject.class, Block.class) + .invokeVirtualQuiet(lookup(), "call"); + private static final MethodHandle FALLBACK_3_B = findStatic(InvocationLinker.class, "invocationFallback", methodType(IRubyObject.class, JRubyCallSite.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, IRubyObject.class, IRubyObject.class, IRubyObject.class, Block.class)); private static final MethodHandle FAIL_3_B = findStatic(InvocationLinker.class, "fail", methodType(IRubyObject.class, JRubyCallSite.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, IRubyObject.class, IRubyObject.class, IRubyObject.class, Block.class)); - private static final MethodHandle FAIL_ITER_3_B = findStatic(InvocationLinker.class, "failIter", - methodType(IRubyObject.class, JRubyCallSite.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, IRubyObject.class, IRubyObject.class, IRubyObject.class, Block.class)); - private static final MethodHandle PGC_N_B = dropNameAndArgs(PGC, 4, -1, true); - private static final MethodHandle GETMETHOD_N_B = dropNameAndArgs(GETMETHOD, 5, -1, true); private static final MethodHandle TEST_N_B = dropArgs(TEST, 4, -1, true); - private static final MethodHandle TARGET_N_B; - static { - MethodHandle target = findVirtual(DynamicMethod.class, "call", - methodType(IRubyObject.class, ThreadContext.class, IRubyObject.class, RubyModule.class, String.class, IRubyObject[].class, Block.class)); - target = explicitCastArguments(target, methodType(IRubyObject.class, DynamicMethod.class, ThreadContext.class, IRubyObject.class, RubyClass.class, String.class, IRubyObject[].class, Block.class)); - target = permuteArguments( - target, - methodType(IRubyObject.class, DynamicMethod.class, RubyClass.class, CacheEntry.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, String.class, IRubyObject[].class, Block.class), - new int[] {0,3,5,1,6,7,8}); - // IRubyObject, DynamicMethod, RubyClass, CacheEntry, ThreadContext, IRubyObject, IRubyObject, String, args - target = foldArguments(target, GETMETHOD_N_B); - // IRubyObject, RubyClass, CacheEntry, ThreadContext, IRubyObject, IRubyObject, String, args - target = foldArguments(target, PGC_N_B); - // IRubyObject, CacheEntry, ThreadContext, IRubyObject, IRubyObject, String, args - - TARGET_N_B = target; - } + private static final MethodHandle TARGET_N_B = Binder + .from(IRubyObject.class, CacheEntry.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, String.class, IRubyObject[].class, Block.class) + .fold(dropNameAndArgs(PGC, 4, -1, true)) + .fold(dropNameAndArgs(GETMETHOD, 5, -1, true)) + .permute(0, 3, 5, 1, 6, 7, 8) + .cast(IRubyObject.class, DynamicMethod.class, ThreadContext.class, IRubyObject.class, RubyModule.class, String.class, IRubyObject[].class, Block.class) + .invokeVirtualQuiet(lookup(), "call"); + private static final MethodHandle FALLBACK_N_B = findStatic(InvocationLinker.class, "invocationFallback", methodType(IRubyObject.class, JRubyCallSite.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, IRubyObject[].class, Block.class)); private static final MethodHandle FAIL_N_B = findStatic(InvocationLinker.class, "fail", methodType(IRubyObject.class, JRubyCallSite.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, IRubyObject[].class, Block.class)); - private static final MethodHandle FAIL_ITER_N_B = findStatic(InvocationLinker.class, "failIter", - methodType(IRubyObject.class, JRubyCallSite.class, ThreadContext.class, IRubyObject.class, IRubyObject.class, IRubyObject[].class, Block.class)); - + private static final MethodHandle[] TESTS = new MethodHandle[] { TEST_0, TEST_1,