InvocationMethodFactory.java

  1. /***** BEGIN LICENSE BLOCK *****
  2.  * Version: EPL 1.0/GPL 2.0/LGPL 2.1
  3.  *
  4.  * The contents of this file are subject to the Eclipse Public
  5.  * License Version 1.0 (the "License"); you may not use this file
  6.  * except in compliance with the License. You may obtain a copy of
  7.  * the License at http://www.eclipse.org/legal/epl-v10.html
  8.  *
  9.  * Software distributed under the License is distributed on an "AS
  10.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  11.  * implied. See the License for the specific language governing
  12.  * rights and limitations under the License.
  13.  * 
  14.  * Copyright (C) 2006 The JRuby Community <www.jruby.org>
  15.  * Copyright (C) 2006 Ola Bini <ola@ologix.com>
  16.  * 
  17.  * Alternatively, the contents of this file may be used under the terms of
  18.  * either of the GNU General Public License Version 2 or later (the "GPL"),
  19.  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  20.  * in which case the provisions of the GPL or the LGPL are applicable instead
  21.  * of those above. If you wish to allow use of your version of this file only
  22.  * under the terms of either the GPL or the LGPL, and not to allow others to
  23.  * use your version of this file under the terms of the EPL, indicate your
  24.  * decision by deleting the provisions above and replace them with the notice
  25.  * and other provisions required by the GPL or the LGPL. If you do not delete
  26.  * the provisions above, a recipient may use your version of this file under
  27.  * the terms of any one of the EPL, the GPL or the LGPL.
  28.  ***** END LICENSE BLOCK *****/
  29. package org.jruby.internal.runtime.methods;

  31. import java.io.PrintWriter;
  32. import java.lang.reflect.Modifier;
  33. import java.util.Arrays;
  34. import java.util.List;

  36. import org.jruby.Ruby;
  37. import org.jruby.RubyInstanceConfig;
  38. import org.jruby.RubyKernel;
  39. import org.jruby.parser.StaticScope;
  40. import org.jruby.runtime.Helpers;
  41. import org.objectweb.asm.ClassWriter;
  42. import org.objectweb.asm.Opcodes;
  43. import org.jruby.RubyModule;
  44. import org.jruby.RubyString;
  45. import org.jruby.anno.JRubyMethod;
  46. import org.jruby.anno.JavaMethodDescriptor;
  47. import org.jruby.anno.TypePopulator;
  48. import org.jruby.compiler.impl.SkinnyMethodAdapter;
  49. import org.jruby.exceptions.JumpException;
  50. import org.jruby.exceptions.RaiseException;
  51. import org.jruby.lexer.yacc.ISourcePosition;
  52. import org.jruby.runtime.Arity;
  53. import org.jruby.runtime.Block;
  54. import org.jruby.runtime.CompiledBlockCallback;
  55. import org.jruby.runtime.CompiledBlockCallback19;
  56. import org.jruby.runtime.MethodFactory;
  57. import org.jruby.runtime.ThreadContext;
  58. import org.jruby.runtime.Visibility;
  59. import org.jruby.runtime.builtin.IRubyObject;
  60. import org.jruby.util.CodegenUtils;
  61. import static org.jruby.util.CodegenUtils.*;
  62. import static java.lang.System.*;
  63. import org.jruby.util.ClassDefininngJRubyClassLoader;
  64. import org.objectweb.asm.ClassReader;
  65. import org.objectweb.asm.Label;
  66. import org.objectweb.asm.util.CheckClassAdapter;
  67. import org.jruby.util.log.Logger;
  68. import org.jruby.util.log.LoggerFactory;

  70. /**
  71.  * In order to avoid the overhead with reflection-based method handles, this
  72.  * MethodFactory uses ASM to generate tiny invoker classes. This allows for
  73.  * better performance and more specialization per-handle than can be supported
  74.  * via reflection. It also allows optimizing away many conditionals that can
  75.  * be determined once ahead of time.
  76.  * 
  77.  * When running in secured environments, this factory may not function. When
  78.  * this can be detected, MethodFactory will fall back on the reflection-based
  79.  * factory instead.
  80.  * 
  81.  * @see org.jruby.runtime.MethodFactory
  82.  */
  83. public class InvocationMethodFactory extends MethodFactory implements Opcodes {

  85.     private static final Logger LOG = LoggerFactory.getLogger("InvocationMethodFactory");

  87.     private static final boolean DEBUG = false;

  89.     /** The class used for the super class of compiled Ruby method handles. */
  90.     private final static Class COMPILED_SUPER_CLASS = CompiledMethod.class;
  91.     
  92.     /** The pathname of the super class for compiled Ruby method handles. */ 
  93.     private final static String COMPILED_SUPER_CLASS_NAME = p(COMPILED_SUPER_CLASS);

  95.     /** The class used for the super class of compiled Ruby block handles. */
  96.     private static final Class<CompiledBlockCallback> COMPILED_BLOCK_SUPER_CLASS = CompiledBlockCallback.class;

  98.     /** The pathname of the super class for compiled Ruby block handles. */
  99.     private static final String COMPILED_BLOCK_SUPER_CLASS_NAME = p(COMPILED_BLOCK_SUPER_CLASS);

  101.     /** The interface used for compiled Ruby 1.9+ block handles. */
  102.     public static final Class<CompiledBlockCallback19> COMPILED_BLOCK_19_INTERFACE = CompiledBlockCallback19.class;

  104.     /** The pathname of the interface for compiled Ruby block handles. */
  105.     public static final String COMPILED_BLOCK_19_INTERFACE_NAME = p(COMPILED_BLOCK_19_INTERFACE);
  106.     
  107.     /** The outward call signature for compiled Ruby method handles. */
  108.     private final static String COMPILED_CALL_SIG = sig(IRubyObject.class,
  109.             params(ThreadContext.class, IRubyObject.class, RubyModule.class, String.class, IRubyObject[].class));
  110.     
  111.     /** The outward call signature for compiled Ruby method handles. */
  112.     private final static String COMPILED_CALL_SIG_BLOCK = sig(IRubyObject.class,
  113.             params(ThreadContext.class, IRubyObject.class, RubyModule.class, String.class, IRubyObject[].class, Block.class));
  114.     
  115.     /** The outward arity-zero call-with-block signature for compiled Ruby method handles. */
  116.     private final static String COMPILED_CALL_SIG_ZERO_BLOCK = sig(IRubyObject.class,
  117.             params(ThreadContext.class, IRubyObject.class, RubyModule.class, String.class, Block.class));
  118.     
  119.     /** The outward arity-zero call-with-block signature for compiled Ruby method handles. */
  120.     private final static String COMPILED_CALL_SIG_ZERO = sig(IRubyObject.class,
  121.             params(ThreadContext.class, IRubyObject.class, RubyModule.class, String.class));
  122.     
  123.     /** The outward arity-zero call-with-block signature for compiled Ruby method handles. */
  124.     private final static String COMPILED_CALL_SIG_ONE_BLOCK = sig(IRubyObject.class,
  125.             params(ThreadContext.class, IRubyObject.class, RubyModule.class, String.class, IRubyObject.class, Block.class));
  126.     
  127.     /** The outward arity-zero call-with-block signature for compiled Ruby method handles. */
  128.     private final static String COMPILED_CALL_SIG_ONE = sig(IRubyObject.class,
  129.             params(ThreadContext.class, IRubyObject.class, RubyModule.class, String.class, IRubyObject.class));
  130.     
  131.     /** The outward arity-zero call-with-block signature for compiled Ruby method handles. */
  132.     private final static String COMPILED_CALL_SIG_TWO_BLOCK = sig(IRubyObject.class,
  133.             params(ThreadContext.class, IRubyObject.class, RubyModule.class, String.class, IRubyObject.class, IRubyObject.class, Block.class));
  134.     
  135.     /** The outward arity-zero call-with-block signature for compiled Ruby method handles. */
  136.     private final static String COMPILED_CALL_SIG_TWO = sig(IRubyObject.class,
  137.             params(ThreadContext.class, IRubyObject.class, RubyModule.class, String.class, IRubyObject.class, IRubyObject.class));
  138.     
  139.     /** The outward arity-zero call-with-block signature for compiled Ruby method handles. */
  140.     private final static String COMPILED_CALL_SIG_THREE_BLOCK = sig(IRubyObject.class,
  141.             params(ThreadContext.class, IRubyObject.class, RubyModule.class, String.class, IRubyObject.class, IRubyObject.class, IRubyObject.class, Block.class));
  142.     
  143.     /** The outward arity-zero call-with-block signature for compiled Ruby method handles. */
  144.     private final static String COMPILED_CALL_SIG_THREE = sig(IRubyObject.class,
  145.             params(ThreadContext.class, IRubyObject.class, RubyModule.class, String.class, IRubyObject.class, IRubyObject.class, IRubyObject.class));

  147.     private final static String BLOCK_CALL_SIG = sig(RubyKernel.IRUBY_OBJECT, params(
  148.             ThreadContext.class, RubyKernel.IRUBY_OBJECT, IRubyObject.class, Block.class));
  149.     private final static String BLOCK_CALL_SIG19 = sig(RubyKernel.IRUBY_OBJECT, params(
  150.             ThreadContext.class, IRubyObject.class, IRubyObject[].class, Block.class));
  151.     
  152.     /** The super constructor signature for Java-based method handles. */
  153.     private final static String JAVA_SUPER_SIG = sig(Void.TYPE, params(RubyModule.class, Visibility.class));
  154.     
  155.     /** The lvar index of "this" */
  156.     public static final int THIS_INDEX = 0;
  157.     
  158.     /** The lvar index of the passed-in ThreadContext */
  159.     public static final int THREADCONTEXT_INDEX = 1;
  160.     
  161.     /** The lvar index of the method-receiving object */
  162.     public static final int RECEIVER_INDEX = 2;
  163.     
  164.     /** The lvar index of the RubyClass being invoked against */
  165.     public static final int CLASS_INDEX = 3;
  166.     
  167.     /** The lvar index method name being invoked */
  168.     public static final int NAME_INDEX = 4;
  169.     
  170.     /** The lvar index of the method args on the call */
  171.     public static final int ARGS_INDEX = 5;
  172.     
  173.     /** The lvar index of the passed-in Block on the call */
  174.     public static final int BLOCK_INDEX = 6;

  176.     /** The classloader to use for code loading */
  177.     protected final ClassDefininngJRubyClassLoader classLoader;
  178.     
  179.     /** An object to sync against when loading classes, to avoid dups */
  180.     protected final Object syncObject;
  181.     
  182.     /**
  183.      * Whether this factory has seen undefined methods already. This is used to
  184.      * detect likely method handle collisions when we expect to create a new
  185.      * handle for each call.
  186.      */
  187.     private boolean seenUndefinedClasses = false;

  189.     /**
  190.      * Whether we've informed the user that we've seen undefined methods; this
  191.      * is to avoid a flood of repetitive information.
  192.      */
  193.     private boolean haveWarnedUser = false;
  194.     
  195.     /**
  196.      * Construct a new InvocationMethodFactory using the specified classloader
  197.      * to load code. If the target classloader is not an instance of
  198.      * JRubyClassLoader, it will be wrapped with one.
  199.      * 
  200.      * @param classLoader The classloader to use, or to wrap if it is not a
  201.      * JRubyClassLoader instance.
  202.      */
  203.     public InvocationMethodFactory(ClassLoader classLoader) {
  204.         // use the given classloader as our sync, regardless of whether we wrap it
  205.         this.syncObject = classLoader;
  206.         
  207.         if (classLoader instanceof ClassDefininngJRubyClassLoader) {
  208.             this.classLoader = (ClassDefininngJRubyClassLoader)classLoader;
  209.         } else {
  210.             this.classLoader = new ClassDefininngJRubyClassLoader(classLoader);
  211.         }
  212.     }

  214.     /**
  215.      * Use code generation to provide a method handle for a compiled Ruby method.
  216.      * 
  217.      * @see org.jruby.runtime.MethodFactory#getCompiledMethod
  218.      */
  219.     public DynamicMethod getCompiledMethodLazily(
  220.             RubyModule implementationClass,
  221.             String rubyName,
  222.             String javaName,
  223.             Arity arity,
  224.             Visibility visibility,
  225.             StaticScope scope,
  226.             Object scriptObject,
  227.             CallConfiguration callConfig,
  228.             ISourcePosition position,
  229.             String parameterDesc,
  230.             MethodNodes methodNodes) {

  232.         return new CompiledMethod.LazyCompiledMethod(
  233.                 implementationClass,
  234.                 rubyName,
  235.                 javaName,
  236.                 arity,
  237.                 visibility,
  238.                 scope,
  239.                 scriptObject,
  240.                 callConfig,
  241.                 position,
  242.                 parameterDesc,
  243.                 new InvocationMethodFactory(classLoader),
  244.                 methodNodes);
  245.     }

  247.     public static String getCompiledCallbackName(String typePath, String method) {
  248.         return (typePath + "$" + method).replaceAll("/", "\\$");
  249.     }

  251.     /**
  252.      * Use code generation to provide a method handle for a compiled Ruby method.
  253.      * 
  254.      * @see org.jruby.runtime.MethodFactory#getCompiledMethod
  255.      */
  256.     public DynamicMethod getCompiledMethod(
  257.             RubyModule implementationClass,
  258.             String rubyName,
  259.             String javaName,
  260.             Arity arity,
  261.             Visibility visibility,
  262.             StaticScope scope,
  263.             Object scriptObject,
  264.             CallConfiguration callConfig,
  265.             ISourcePosition position,
  266.             String parameterDesc,
  267.             MethodNodes methodNodes) {
  268.         
  269.         Class scriptClass = scriptObject.getClass();
  270.         String typePath = p(scriptClass);
  271.         String invokerPath = getCompiledCallbackName(typePath, javaName);
  272.         Class generatedClass = null;
  273.         boolean tryLoad = false;

  275.         try {
  276.             byte[] invokerBytes = getCompiledMethodOffline(
  277.                     rubyName,
  278.                     javaName,
  279.                     typePath,
  280.                     invokerPath,
  281.                     arity,
  282.                     scope,
  283.                     callConfig,
  284.                     position.getFile(),
  285.                     position.getLine(),
  286.                     methodNodes);
  287.             generatedClass = endCallWithBytes(invokerBytes, invokerPath);
  288.         } catch (LinkageError le) {
  289.             tryLoad = true;
  290.         } catch (SecurityException se) {
  291.             tryLoad = true;
  292.         }

  294.         if (tryLoad) {
  295.             // failed to define a new class, try loading existing
  296.             generatedClass = tryClass(invokerPath, scriptClass, COMPILED_SUPER_CLASS);
  297.             if (generatedClass == null) {
  298.                 throw implementationClass.getRuntime().newLoadError("failed to generate or load invoker for " + invokerPath);
  299.             }
  300.         }

  302.         CompiledMethod compiledMethod;
  303.         try {
  304.             compiledMethod = (CompiledMethod)generatedClass.newInstance();
  305.         } catch (Exception e) {
  306.             e.printStackTrace();
  307.             throw implementationClass.getRuntime().newLoadError(e.getMessage());
  308.         }

  310.         compiledMethod.init(implementationClass, arity, visibility, scope, scriptObject, callConfig, position, parameterDesc);

  312.         Class[] params;
  313.         if (arity.isFixed() && scope.getRequiredArgs() < 4) {
  314.             params = Helpers.getStaticMethodParams(scriptClass, scope.getRequiredArgs());
  315.         } else {
  316.             params = Helpers.getStaticMethodParams(scriptClass, 4);
  317.         }
  318.         compiledMethod.setNativeCall(scriptClass, javaName, IRubyObject.class, params, true);

  320.         return compiledMethod;
  321.     }

  323.     /**
  324.      * Use code generation to provide a method handle for a compiled Ruby method.
  325.      *
  326.      * @see org.jruby.runtime.MethodFactory#getCompiledMethod
  327.      */
  328.     @Override
  329.     public byte[] getCompiledMethodOffline(
  330.             String RubyName, String method, String className, String invokerPath, Arity arity,
  331.             StaticScope scope, CallConfiguration callConfig, String filename, int line,
  332.             MethodNodes methodNodes) {
  333.         String sup = COMPILED_SUPER_CLASS_NAME;
  334.         ClassWriter cw;
  335.         cw = createCompiledCtor(invokerPath, invokerPath, sup);
  336.         SkinnyMethodAdapter mv = null;
  337.         String signature = null;
  338.         boolean specificArity = false;

  340.         // if trace, need to at least populate a backtrace frame
  341.         if (RubyInstanceConfig.FULL_TRACE_ENABLED) {
  342.             switch (callConfig) {
  343.             case FrameNoneScopeDummy:
  344.                 callConfig = CallConfiguration.FrameBacktraceScopeDummy;
  345.                 break;
  346.             case FrameNoneScopeFull:
  347.                 callConfig = CallConfiguration.FrameBacktraceScopeFull;
  348.                 break;
  349.             case FrameNoneScopeNone:
  350.                 callConfig = CallConfiguration.FrameBacktraceScopeNone;
  351.                 break;
  352.             }
  353.         }

  355.         if (scope.getRestArg() >= 0 || scope.getOptionalArgs() > 0 || scope.getRequiredArgs() > 3) {
  356.             signature = COMPILED_CALL_SIG_BLOCK;
  357.             mv = new SkinnyMethodAdapter(cw, ACC_PUBLIC, "call", signature, null, null);
  358.         } else {
  359.             specificArity = true;

  361.             mv = new SkinnyMethodAdapter(cw, ACC_PUBLIC, "call", COMPILED_CALL_SIG_BLOCK, null, null);
  362.             mv.start();

  364.             // check arity
  365.             mv.aloadMany(0, 1, 4, 5); // method, context, name, args, required
  366.             mv.pushInt(scope.getRequiredArgs());
  367.             mv.invokestatic(p(JavaMethod.class), "checkArgumentCount", sig(void.class, JavaMethod.class, ThreadContext.class, String.class, IRubyObject[].class, int.class));

  369.             mv.aloadMany(0, 1, 2, 3, 4);
  370.             for (int i = 0; i < scope.getRequiredArgs(); i++) {
  371.                 mv.aload(5);
  372.                 mv.ldc(i);
  373.                 mv.arrayload();
  374.             }
  375.             mv.aload(6);

  377.             switch (scope.getRequiredArgs()) {
  378.             case 0:
  379.                 signature = COMPILED_CALL_SIG_ZERO_BLOCK;
  380.                 break;
  381.             case 1:
  382.                 signature = COMPILED_CALL_SIG_ONE_BLOCK;
  383.                 break;
  384.             case 2:
  385.                 signature = COMPILED_CALL_SIG_TWO_BLOCK;
  386.                 break;
  387.             case 3:
  388.                 signature = COMPILED_CALL_SIG_THREE_BLOCK;
  389.                 break;
  390.             }

  392.             mv.invokevirtual(invokerPath, "call", signature);
  393.             mv.areturn();
  394.             mv.end();

  396.             // Define a second version that doesn't take a block, so we have unique code paths for both cases.
  397.             switch (scope.getRequiredArgs()) {
  398.             case 0:
  399.                 signature = COMPILED_CALL_SIG_ZERO;
  400.                 break;
  401.             case 1:
  402.                 signature = COMPILED_CALL_SIG_ONE;
  403.                 break;
  404.             case 2:
  405.                 signature = COMPILED_CALL_SIG_TWO;
  406.                 break;
  407.             case 3:
  408.                 signature = COMPILED_CALL_SIG_THREE;
  409.                 break;
  410.             }
  411.             mv = new SkinnyMethodAdapter(cw, ACC_PUBLIC, "call", signature, null, null);
  412.             mv.start();

  414.             mv.aloadMany(0, 1, 2, 3, 4);
  415.             for (int i = 1; i <= scope.getRequiredArgs(); i++) {
  416.                 mv.aload(4 + i);
  417.             }
  418.             mv.getstatic(p(Block.class), "NULL_BLOCK", ci(Block.class));

  420.             switch (scope.getRequiredArgs()) {
  421.             case 0:
  422.                 signature = COMPILED_CALL_SIG_ZERO_BLOCK;
  423.                 break;
  424.             case 1:
  425.                 signature = COMPILED_CALL_SIG_ONE_BLOCK;
  426.                 break;
  427.             case 2:
  428.                 signature = COMPILED_CALL_SIG_TWO_BLOCK;
  429.                 break;
  430.             case 3:
  431.                 signature = COMPILED_CALL_SIG_THREE_BLOCK;
  432.                 break;
  433.             }

  435.             mv.invokevirtual(invokerPath, "call", signature);
  436.             mv.areturn();
  437.             mv.end();

  439.             mv = new SkinnyMethodAdapter(cw, ACC_PUBLIC, "call", signature, null, null);
  440.         }

  442.         mv.start();

  444.         boolean heapScoped = callConfig.scoping() != Scoping.None;
  445.         boolean framed = callConfig.framing() != Framing.None;

  447.         // save off callNumber if framed or scoped, for non-local returns
  448.         int callNumberIndex = -1;
  449.         if (framed || heapScoped) {
  450.             mv.aload(1);
  451.             mv.getfield(p(ThreadContext.class), "callNumber", ci(int.class));
  452.             if (specificArity) {
  453.                 switch (scope.getRequiredArgs()) {
  454.                 case -1:
  455.                     callNumberIndex = ARGS_INDEX + 1/*args*/ + 1/*block*/ + 1;
  456.                     break;
  457.                 case 0:
  458.                     callNumberIndex = ARGS_INDEX + 1/*block*/ + 1;
  459.                     break;
  460.                 default:
  461.                     callNumberIndex = ARGS_INDEX + scope.getRequiredArgs() + 1/*block*/ + 1;
  462.                 }
  463.             } else {
  464.                 callNumberIndex = ARGS_INDEX + 1/*block*/ + 1;
  465.             }
  466.             mv.istore(callNumberIndex);
  467.         }

  469.         // invoke pre method stuff
  470.         if (!callConfig.isNoop() || RubyInstanceConfig.FULL_TRACE_ENABLED) {
  471.             if (specificArity) {
  472.                 invokeCallConfigPre(mv, COMPILED_SUPER_CLASS_NAME, scope.getRequiredArgs(), true, callConfig);
  473.             } else {
  474.                 invokeCallConfigPre(mv, COMPILED_SUPER_CLASS_NAME, -1, true, callConfig);
  475.             }
  476.         }

  478.         // pre-call trace
  479.         int traceBoolIndex = -1;
  480.         if (RubyInstanceConfig.FULL_TRACE_ENABLED) {
  481.             // load and store trace enabled flag
  482.             if (specificArity) {
  483.                 switch (scope.getRequiredArgs()) {
  484.                 case -1:
  485.                     traceBoolIndex = ARGS_INDEX + 1/*args*/ + 1/*block*/ + 2;
  486.                     break;
  487.                 case 0:
  488.                     traceBoolIndex = ARGS_INDEX + 1/*block*/ + 2;
  489.                     break;
  490.                 default:
  491.                     traceBoolIndex = ARGS_INDEX + scope.getRequiredArgs() + 1/*block*/ + 2;
  492.                 }
  493.             } else {
  494.                 traceBoolIndex = ARGS_INDEX + 1/*block*/ + 2;
  495.             }

  497.             mv.aload(1);
  498.             mv.invokevirtual(p(ThreadContext.class), "getRuntime", sig(Ruby.class));
  499.             mv.invokevirtual(p(Ruby.class), "hasEventHooks", sig(boolean.class));
  500.             mv.istore(traceBoolIndex);
  501.             // tracing pre
  502.             invokeTraceCompiledPre(mv, COMPILED_SUPER_CLASS_NAME, traceBoolIndex, filename, line);
  503.         }

  505.         Label tryBegin = new Label();
  506.         Label tryEnd = new Label();
  507.         Label doFinally = new Label();
  508.         Label doReturnFinally = new Label();
  509.         Label doRedoFinally = new Label();
  510.         Label catchReturnJump = new Label();
  511.         Label catchRedoJump = new Label();

  513.         if (framed || heapScoped)   mv.trycatch(tryBegin, tryEnd, catchReturnJump, p(JumpException.ReturnJump.class));
  514.         if (framed)                 mv.trycatch(tryBegin, tryEnd, catchRedoJump, p(JumpException.RedoJump.class));
  515.         if (framed || heapScoped)   mv.trycatch(tryBegin, tryEnd, doFinally, null);
  516.         if (framed || heapScoped)   mv.trycatch(catchReturnJump, doReturnFinally, doFinally, null);
  517.         if (framed)                 mv.trycatch(catchRedoJump, doRedoFinally, doFinally, null);
  518.         if (framed || heapScoped)   mv.label(tryBegin);

  520.         // main body
  521.         {
  522.             mv.aload(0);
  523.             // FIXME we want to eliminate these type casts when possible
  524.             mv.getfield(invokerPath, "$scriptObject", ci(Object.class));
  525.             mv.checkcast(className);
  526.             mv.aloadMany(THREADCONTEXT_INDEX, RECEIVER_INDEX);
  527.             if (specificArity) {
  528.                 for (int i = 0; i < scope.getRequiredArgs(); i++) {
  529.                     mv.aload(ARGS_INDEX + i);
  530.                 }
  531.                 mv.aload(ARGS_INDEX + scope.getRequiredArgs());
  532.                 mv.invokestatic(className, method, Helpers.getStaticMethodSignature(className, scope.getRequiredArgs()));
  533.             } else {
  534.                 mv.aloadMany(ARGS_INDEX, BLOCK_INDEX);
  535.                 mv.invokestatic(className, method, Helpers.getStaticMethodSignature(className, 4));
  536.             }
  537.         }
  538.         if (framed || heapScoped) {
  539.             mv.label(tryEnd);
  540.         }

  542.         // normal exit, perform finally and return
  543.         {
  544.             if (RubyInstanceConfig.FULL_TRACE_ENABLED) {
  545.                 invokeTraceCompiledPost(mv, COMPILED_SUPER_CLASS_NAME, traceBoolIndex);
  546.             }
  547.             if (!callConfig.isNoop()) {
  548.                 invokeCallConfigPost(mv, COMPILED_SUPER_CLASS_NAME, callConfig);
  549.             }
  550.             mv.visitInsn(ARETURN);
  551.         }

  553.         // return jump handling
  554.         if (framed || heapScoped) {
  555.             mv.label(catchReturnJump);
  556.             {
  557.                 mv.aload(0);
  558.                 mv.swap();
  559.                 mv.aload(1);
  560.                 mv.swap();
  561.                 mv.iload(callNumberIndex);
  562.                 mv.invokevirtual(COMPILED_SUPER_CLASS_NAME, "handleReturn", sig(IRubyObject.class, ThreadContext.class, JumpException.ReturnJump.class, int.class));
  563.                 mv.label(doReturnFinally);

  565.                 // finally
  566.                 if (RubyInstanceConfig.FULL_TRACE_ENABLED) {
  567.                     invokeTraceCompiledPost(mv, COMPILED_SUPER_CLASS_NAME, traceBoolIndex);
  568.                 }
  569.                 if (!callConfig.isNoop()) {
  570.                     invokeCallConfigPost(mv, COMPILED_SUPER_CLASS_NAME, callConfig);
  571.                 }

  573.                 // return result if we're still good
  574.                 mv.areturn();
  575.             }
  576.         }

  578.         if (framed) {
  579.             // redo jump handling
  580.             mv.label(catchRedoJump);
  581.             {
  582.                 // clear the redo
  583.                 mv.pop();

  585.                 // get runtime, create jump error, and throw it
  586.                 mv.aload(1);
  587.                 mv.invokevirtual(p(ThreadContext.class), "getRuntime", sig(Ruby.class));
  588.                 mv.invokevirtual(p(Ruby.class), "newRedoLocalJumpError", sig(RaiseException.class));
  589.                 mv.label(doRedoFinally);

  591.                 // finally
  592.                 if (RubyInstanceConfig.FULL_TRACE_ENABLED) {
  593.                     invokeTraceCompiledPost(mv, COMPILED_SUPER_CLASS_NAME, traceBoolIndex);
  594.                 }
  595.                 if (!callConfig.isNoop()) {
  596.                     invokeCallConfigPost(mv, COMPILED_SUPER_CLASS_NAME, callConfig);
  597.                 }

  599.                 // throw redo error if we're still good
  600.                 mv.athrow();
  601.             }
  602.         }

  604.         // finally handling for abnormal exit
  605.         if (framed || heapScoped) {
  606.             mv.label(doFinally);

  608.             //call post method stuff (exception raised)
  609.             if (RubyInstanceConfig.FULL_TRACE_ENABLED) {
  610.                 invokeTraceCompiledPost(mv, COMPILED_SUPER_CLASS_NAME, traceBoolIndex);
  611.             }
  612.             if (!callConfig.isNoop()) {
  613.                 invokeCallConfigPost(mv, COMPILED_SUPER_CLASS_NAME, callConfig);
  614.             }

  616.             // rethrow exception
  617.             mv.athrow(); // rethrow it
  618.         }
  619.         mv.end();

  621.         return endCallOffline(cw);
  622.     }
  623.     
  624.     static class DescriptorInfo {
  625.         private int min;
  626.         private int max;
  627.         private boolean frame;
  628.         private boolean scope;
  629.         private boolean rest;
  630.         private boolean block;
  631.         private String parameterDesc;
  632.         
  633.         private static final boolean RICH_NATIVE_METHOD_PARAMETERS = false;
  634.         
  635.         public DescriptorInfo(List<JavaMethodDescriptor> descs) {
  636.             min = Integer.MAX_VALUE;
  637.             max = 0;
  638.             frame = false;
  639.             scope = false;
  640.             rest = false;
  641.             block = false;
  642.             boolean first = true;
  643.             boolean lastBlock = false;

  645.             for (JavaMethodDescriptor desc: descs) {
  646.                 // make sure we don't have some methods with blocks and others without
  647.                 // the handle generation logic can't handle such cases yet
  648.                 if (first) {
  649.                     first = false;
  650.                 } else {
  651.                     if (lastBlock != desc.hasBlock) {
  652.                         throw new RuntimeException("Mismatched block parameters for method " + desc.declaringClassName + "." + desc.name);
  653.                     }
  654.                 }
  655.                 lastBlock = desc.hasBlock;
  656.                 
  657.                 int specificArity = -1;
  658.                 if (desc.hasVarArgs) {
  659.                     if (desc.optional == 0 && !desc.rest && desc.required == 0) {
  660.                         throw new RuntimeException("IRubyObject[] args but neither of optional or rest specified for method " + desc.declaringClassName + "." + desc.name);
  661.                     }
  662.                     rest = true;
  663.                     if (descs.size() == 1) {
  664.                         min = -1;
  665.                     }
  666.                 } else {
  667.                     if (desc.optional == 0 && !desc.rest) {
  668.                         if (desc.required == 0) {
  669.                             // No required specified, check actual number of required args
  670.                             if (desc.actualRequired <= 3) {
  671.                                 // actual required is less than 3, so we use specific arity
  672.                                 specificArity = desc.actualRequired;
  673.                             } else {
  674.                                 // actual required is greater than 3, raise error (we don't support actual required > 3)
  675.                                 throw new RuntimeException("Invalid specific-arity number of arguments (" + desc.actualRequired + ") on method " + desc.declaringClassName + "." + desc.name);
  676.                             }
  677.                         } else if (desc.required >= 0 && desc.required <= 3) {
  678.                             if (desc.actualRequired != desc.required) {
  679.                                 throw new RuntimeException("Specified required args does not match actual on method " + desc.declaringClassName + "." + desc.name);
  680.                             }
  681.                             specificArity = desc.required;
  682.                         }
  683.                     }

  685.                     if (specificArity < min) {
  686.                         min = specificArity;
  687.                     }

  689.                     if (specificArity > max) {
  690.                         max = specificArity;
  691.                     }
  692.                 }

  694.                 if (frame && !desc.anno.frame()) throw new RuntimeException("Unbalanced frame property on method " + desc.declaringClassName + "." + desc.name);
  695.                 if (scope && !desc.anno.scope()) throw new RuntimeException("Unbalanced scope property on method " + desc.declaringClassName + "." + desc.name);
  696.                 frame |= desc.anno.frame();
  697.                 scope |= desc.anno.scope();
  698.                 block |= desc.hasBlock;
  699.             }
  700.             
  701.             // Core methods currently only show :req's for fixed-arity or a single
  702.             // :rest if it's variable arity. I have filed a bug to improve this
  703.             // (using the skipped logic below, when the time comes) but for now
  704.             // we follow suit. See https://bugs.ruby-lang.org/issues/8088
  705.             
  706.             StringBuilder descBuilder = new StringBuilder();
  707.             if (min == max) {
  708.                 int i = 0;
  709.                 for (; i < min; i++) {
  710.                     if (i > 0) descBuilder.append(';');
  711.                     descBuilder.append("q");
  712.                 }
  713.                // variable arity
  714.             } else if (RICH_NATIVE_METHOD_PARAMETERS) {
  715.                 int i = 0;
  716.                 for (; i < min; i++) {
  717.                     if (i > 0) descBuilder.append(';');
  718.                     descBuilder.append("q");
  719.                 }

  721.                 for (; i < max; i++) {
  722.                     if (i > 0) descBuilder.append(';');
  723.                     descBuilder.append("o");
  724.                 }

  726.                 if (rest) {
  727.                     if (i > 0) descBuilder.append(';');
  728.                     descBuilder.append("r");
  729.                 }
  730.             } else {
  731.                 descBuilder.append("r");
  732.             }
  733.             
  734.             parameterDesc = descBuilder.toString();
  735.         }

  737.         @Deprecated
  738.         public boolean isBacktrace() {
  739.             return false;
  740.         }

  742.         public boolean isFrame() {
  743.             return frame;
  744.         }

  746.         public int getMax() {
  747.             return max;
  748.         }

  750.         public int getMin() {
  751.             return min;
  752.         }

  754.         public boolean isScope() {
  755.             return scope;
  756.         }
  757.         
  758.         public boolean isRest() {
  759.             return rest;
  760.         }
  761.         
  762.         public boolean isBlock() {
  763.             return block;
  764.         }
  765.         
  766.         public String getParameterDesc() {
  767.             return parameterDesc;
  768.         }
  769.     }

  771.     /**
  772.      * Use code generation to provide a method handle based on an annotated Java
  773.      * method.
  774.      * 
  775.      * @see org.jruby.runtime.MethodFactory#getAnnotatedMethod
  776.      */
  777.     public DynamicMethod getAnnotatedMethod(RubyModule implementationClass, List<JavaMethodDescriptor> descs) {
  778.         JavaMethodDescriptor desc1 = descs.get(0);
  779.         JRubyMethod anno = desc1.anno;
  780.         String javaMethodName = desc1.name;
  781.         
  782.         if (DEBUG) out.println("Binding multiple: " + desc1.declaringClassName + "." + javaMethodName);

  784.         try {
  785.             Class c = getAnnotatedMethodClass(descs);

  787.             DescriptorInfo info = new DescriptorInfo(descs);
  788.             if (DEBUG) out.println(" min: " + info.getMin() + ", max: " + info.getMax());

  790.             JavaMethod ic = (JavaMethod)c.getConstructor(new Class[]{RubyModule.class, Visibility.class}).newInstance(new Object[]{implementationClass, desc1.anno.visibility()});

  792.             TypePopulator.populateMethod(
  793.                     ic,
  794.                     Arity.optional().getValue(),
  795.                     javaMethodName,
  796.                     desc1.isStatic,
  797.                     CallConfiguration.getCallConfigByAnno(anno),
  798.                     desc1.anno.notImplemented(),
  799.                     desc1.getDeclaringClass(),
  800.                     desc1.name,
  801.                     desc1.getReturnClass(),
  802.                     desc1.getParameterClasses(),
  803.                     CallConfiguration.getCallerCallConfigByAnno(anno));
  804.             return ic;
  805.         } catch(Exception e) {
  806.             e.printStackTrace();
  807.             throw implementationClass.getRuntime().newLoadError(e.getMessage());
  808.         }
  809.     }

  811.     /**
  812.      * Use code generation to provide a method handle based on an annotated Java
  813.      * method. Return the resulting generated or loaded class.
  814.      * 
  815.      * @see org.jruby.runtime.MethodFactory#getAnnotatedMethod
  816.      */
  817.     public Class getAnnotatedMethodClass(List<JavaMethodDescriptor> descs) throws Exception {
  818.         JavaMethodDescriptor desc1 = descs.get(0);

  820.         if (!Modifier.isPublic(desc1.getDeclaringClass().getModifiers())) {
  821.             LOG.warn("warning: binding non-public class {}; reflected handles won't work", desc1.declaringClassName);
  822.         }
  823.         
  824.         String javaMethodName = desc1.name;
  825.         
  826.         if (DEBUG) {
  827.             if (descs.size() > 1) {
  828.                 out.println("Binding multiple: " + desc1.declaringClassName + "." + javaMethodName);
  829.             } else {
  830.                 out.println("Binding single: " + desc1.declaringClassName + "." + javaMethodName);
  831.             }
  832.         }
  833.         
  834.         String generatedClassName = CodegenUtils.getAnnotatedBindingClassName(javaMethodName, desc1.declaringClassName, desc1.isStatic, desc1.actualRequired, desc1.optional, descs.size() > 1, desc1.anno.frame());
  835.         if (RubyInstanceConfig.FULL_TRACE_ENABLED) {
  836.             // in debug mode we append _DBG to class name to force it to regenerate (or use pre-generated debug version)
  837.             generatedClassName += "_DBG";
  838.         }
  839.         String generatedClassPath = generatedClassName.replace('.', '/');

  841.         DescriptorInfo info = new DescriptorInfo(descs);

  843.         Class superclass = determineSuperclass(info);

  845.         Class c = tryClass(generatedClassName, desc1.getDeclaringClass(), superclass);
  846.         if (c == null) {
  847.             synchronized (syncObject) {
  848.                 // try again
  849.                 c = tryClass(generatedClassName, desc1.getDeclaringClass(), superclass);
  850.                 if (c == null) {
  851.                     if (DEBUG) out.println("Generating " + generatedClassName + ", min: " + info.getMin() + ", max: " + info.getMax() + ", hasBlock: " + info.isBlock() + ", rest: " + info.isRest());

  853.                     String superClassString = p(superclass);
  854.                     
  855.                     ClassWriter cw = createJavaMethodCtor(generatedClassPath, superClassString, info.getParameterDesc());

  857.                     addAnnotatedMethodInvoker(cw, "call", superClassString, descs);

  859.                     c = endClass(cw, generatedClassName);
  860.                 }
  861.             }
  862.         }

  864.         return c;
  865.     }

  867.     private Class determineSuperclass(DescriptorInfo info) {
  868.         Class superClass;
  869.         if (info.getMin() == -1) {
  870.             // normal all-rest method
  871.             if (info.isBlock()) {
  872.                 superClass = JavaMethod.JavaMethodNBlock.class;
  873.             } else {
  874.                 superClass = JavaMethod.JavaMethodN.class;
  875.             }
  876.         } else {
  877.             if (info.isRest()) {
  878.                 if (info.isBlock()) {
  879.                     superClass = JavaMethod.BLOCK_REST_METHODS[info.getMin()][info.getMax()];
  880.                 } else {
  881.                     superClass = JavaMethod.REST_METHODS[info.getMin()][info.getMax()];
  882.                 }
  883.             } else {
  884.                 if (info.isBlock()) {
  885.                     superClass = JavaMethod.BLOCK_METHODS[info.getMin()][info.getMax()];
  886.                 } else {
  887.                     superClass = JavaMethod.METHODS[info.getMin()][info.getMax()];
  888.                 }
  889.             }
  890.         }

  892.         if (superClass == null) throw new RuntimeException("invalid multi combination");
  893.         return superClass;
  894.     }

  896.     /**
  897.      * Use code generation to provide a method handle based on an annotated Java
  898.      * method.
  899.      * 
  900.      * @see org.jruby.runtime.MethodFactory#getAnnotatedMethod
  901.      */
  902.     public DynamicMethod getAnnotatedMethod(RubyModule implementationClass, JavaMethodDescriptor desc) {
  903.         String javaMethodName = desc.name;

  905.         try {
  906.             Class c = getAnnotatedMethodClass(Arrays.asList(desc));

  908.             JavaMethod ic = (JavaMethod)c.getConstructor(new Class[]{RubyModule.class, Visibility.class}).newInstance(new Object[]{implementationClass, desc.anno.visibility()});

  910.             TypePopulator.populateMethod(
  911.                     ic,
  912.                     Arity.fromAnnotation(desc.anno, desc.actualRequired).getValue(),
  913.                     javaMethodName,
  914.                     desc.isStatic,
  915.                     CallConfiguration.getCallConfigByAnno(desc.anno),
  916.                     desc.anno.notImplemented(),
  917.                     desc.getDeclaringClass(),
  918.                     desc.name,
  919.                     desc.getReturnClass(),
  920.                     desc.getParameterClasses(),
  921.                     CallConfiguration.getCallerCallConfigByAnno(desc.anno));
  922.             return ic;
  923.         } catch(Exception e) {
  924.             e.printStackTrace();
  925.             throw implementationClass.getRuntime().newLoadError(e.getMessage());
  926.         }
  927.     }

  929.     public static String getBlockCallbackName(String typePathString, String method) {
  930.         return (typePathString + "$" + method).replaceAll("/", "\\$");
  931.     }

  933.     public CompiledBlockCallback getBlockCallback(String method, String file, int line, Object scriptObject) {
  934.         Class typeClass = scriptObject.getClass();
  935.         String typePathString = p(typeClass);
  936.         String mname = getBlockCallbackName(typePathString, method);
  937.         try {
  938.             Class c = tryBlockCallbackClass(mname, COMPILED_BLOCK_SUPER_CLASS);
  939.             if (c == null) {
  940.                 synchronized (syncObject) {
  941.                     c = tryBlockCallbackClass(mname, COMPILED_BLOCK_SUPER_CLASS);
  942.                     if (c == null) {
  943.                         if (RubyInstanceConfig.JIT_LOADING_DEBUG) {
  944.                             LOG.debug("no generated handle in classloader for: {}", mname);
  945.                         }
  946.                         byte[] bytes = getBlockCallbackOffline(method, file, line, typePathString);
  947.                         c = endClassWithBytes(bytes, mname);
  948.                     } else {
  949.                         if (RubyInstanceConfig.JIT_LOADING_DEBUG) {
  950.                             LOG.debug("found generated handle in classloader for: {}", mname);
  951.                         }
  952.                     }
  953.                 }
  954.             }
  955.                 
  956.             CompiledBlockCallback ic = (CompiledBlockCallback) c.getConstructor(Object.class).newInstance(scriptObject);
  957.             return ic;
  958.         } catch (IllegalArgumentException e) {
  959.             throw e;
  960.         } catch (Exception e) {
  961.             throw new IllegalArgumentException(e.getMessage());
  962.         }
  963.     }

  965.     @Override
  966.     public byte[] getBlockCallbackOffline(String method, String file, int line, String classname) {
  967.         String mname = getBlockCallbackName(classname, method);
  968.         ClassWriter cw = createBlockCtor(mname, classname);
  969.         SkinnyMethodAdapter mv = startBlockCall(cw);
  970.         mv.aload(0);
  971.         mv.getfield(mname, "$scriptObject", "L" + classname + ";");
  972.         mv.aloadMany(1, 2, 3, 4);
  973.         mv.invokestatic(classname, method, sig(
  974.                 IRubyObject.class, "L" + classname + ";", ThreadContext.class,
  975.                         IRubyObject.class, IRubyObject.class, Block.class));
  976.         mv.areturn();
  977.         mv.end();

  979.         mv = new SkinnyMethodAdapter(cw, ACC_PUBLIC, "getFile", sig(String.class), null, null);
  980.         mv.start();
  981.         mv.ldc(file);
  982.         mv.areturn();
  983.         mv.end();

  985.         mv = new SkinnyMethodAdapter(cw, ACC_PUBLIC, "getLine", sig(int.class), null, null);
  986.         mv.start();
  987.         mv.ldc(line);
  988.         mv.ireturn();
  989.         mv.end();

  991.         return endCallOffline(cw);
  992.     }

  994.     public CompiledBlockCallback19 getBlockCallback19(String method, String file, int line, Object scriptObject) {
  995.         Class typeClass = scriptObject.getClass();
  996.         String typePathString = p(typeClass);
  997.         String mname = getBlockCallbackName(typePathString, method);
  998.         try {
  999.             Class c = tryBlockCallback19Class(mname, COMPILED_BLOCK_19_INTERFACE);
  1000.             if (c == null) {
  1001.                 synchronized (syncObject) {
  1002.                     c = tryBlockCallback19Class(mname, COMPILED_BLOCK_19_INTERFACE);
  1003.                     if (c == null) {
  1004.                         if (RubyInstanceConfig.JIT_LOADING_DEBUG) {
  1005.                             LOG.debug("no generated handle in classloader for: {}", mname);
  1006.                         }
  1007.                         byte[] bytes = getBlockCallback19Offline(method, file, line, typePathString);
  1008.                         c = endClassWithBytes(bytes, mname);
  1009.                     } else {
  1010.                         if (RubyInstanceConfig.JIT_LOADING_DEBUG) {
  1011.                             LOG.debug("found generated handle in classloader for: {}", mname);
  1012.                         }
  1013.                     }
  1014.                 }
  1015.             }
  1016.                 
  1017.             CompiledBlockCallback19 ic = (CompiledBlockCallback19) c.getConstructor(Object.class).newInstance(scriptObject);
  1018.             return ic;
  1019.         } catch (IllegalArgumentException e) {
  1020.             throw e;
  1021.         } catch (Exception e) {
  1022.             throw new IllegalArgumentException(e.getMessage());
  1023.         }
  1024.     }

  1026.     @Override
  1027.     public byte[] getBlockCallback19Offline(String method, String file, int line, String classname) {
  1028.         String mnamePath = getBlockCallbackName(classname, method);
  1029.         ClassWriter cw = createBlockCtor19(mnamePath, classname);
  1030.         SkinnyMethodAdapter mv = startBlockCall19(cw);
  1031.         mv.aload(0);
  1032.         mv.getfield(mnamePath, "$scriptObject", "L" + classname + ";");
  1033.         mv.aloadMany(1, 2, 3, 4);
  1034.         mv.invokestatic(classname, method, sig(
  1035.                 IRubyObject.class, "L" + classname + ";", ThreadContext.class,
  1036.                         IRubyObject.class, IRubyObject[].class, Block.class));
  1037.         mv.areturn();
  1038.         mv.end();

  1040.         mv = new SkinnyMethodAdapter(cw, ACC_PUBLIC, "getFile", sig(String.class), null, null);
  1041.         mv.start();
  1042.         mv.ldc(file);
  1043.         mv.areturn();
  1044.         mv.end();

  1046.         mv = new SkinnyMethodAdapter(cw, ACC_PUBLIC, "getLine", sig(int.class), null, null);
  1047.         mv.start();
  1048.         mv.ldc(line);
  1049.         mv.ireturn();
  1050.         mv.end();
  1051.         
  1052.         return endCallOffline(cw);
  1053.     }

  1055.     private SkinnyMethodAdapter startBlockCall(ClassWriter cw) {
  1056.         SkinnyMethodAdapter mv = new SkinnyMethodAdapter(cw, ACC_PUBLIC | ACC_SYNTHETIC | ACC_FINAL, "call", BLOCK_CALL_SIG, null, null);

  1058.         mv.visitCode();
  1059.         return mv;
  1060.     }

  1062.     private SkinnyMethodAdapter startBlockCall19(ClassWriter cw) {
  1063.         SkinnyMethodAdapter mv = new SkinnyMethodAdapter(cw, ACC_PUBLIC | ACC_SYNTHETIC | ACC_FINAL, "call", BLOCK_CALL_SIG19, null, null);

  1065.         mv.visitCode();
  1066.         return mv;
  1067.     }

  1069.     private ClassWriter createBlockCtor(String namePath, String classname) {
  1070.         String ciClassname = "L" + classname + ";";
  1071.         ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS | ClassWriter.COMPUTE_FRAMES);
  1072.         cw.visit(RubyInstanceConfig.JAVA_VERSION, ACC_PUBLIC + ACC_SUPER, namePath, null, COMPILED_BLOCK_SUPER_CLASS_NAME, null);
  1073.         cw.visitSource(namePath, null);
  1074.         cw.visitField(ACC_PRIVATE | ACC_FINAL, "$scriptObject", ciClassname, null, null);
  1075.         SkinnyMethodAdapter mv = new SkinnyMethodAdapter(cw, ACC_PUBLIC, "<init>", sig(Void.TYPE, params(Object.class)), null, null);
  1076.         mv.start();
  1077.         mv.aload(0);
  1078.         mv.invokespecial(p(CompiledBlockCallback.class), "<init>", sig(void.class));
  1079.         mv.aloadMany(0, 1);
  1080.         mv.checkcast(classname);
  1081.         mv.putfield(namePath, "$scriptObject", ciClassname);
  1082.         mv.voidreturn();
  1083.         mv.end();

  1085.         return cw;
  1086.     }

  1088.     private ClassWriter createBlockCtor19(String namePath, String classname) {
  1089.         String ciClassname = "L" + classname + ";";
  1090.         ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS | ClassWriter.COMPUTE_FRAMES);
  1091.         cw.visit(RubyInstanceConfig.JAVA_VERSION, ACC_PUBLIC + ACC_SUPER, namePath, null, p(Object.class), new String[] {COMPILED_BLOCK_19_INTERFACE_NAME});
  1092.         cw.visitSource(namePath, null);
  1093.         cw.visitField(ACC_PRIVATE | ACC_FINAL, "$scriptObject", ciClassname, null, null);
  1094.         SkinnyMethodAdapter mv = new SkinnyMethodAdapter(cw, ACC_PUBLIC, "<init>", sig(Void.TYPE, params(Object.class)), null, null);
  1095.         mv.start();
  1096.         mv.aload(0);
  1097.         mv.invokespecial(p(Object.class), "<init>", sig(void.class));
  1098.         mv.aloadMany(0, 1);
  1099.         mv.checkcast(classname);
  1100.         mv.putfield(namePath, "$scriptObject", ciClassname);
  1101.         mv.voidreturn();
  1102.         mv.end();

  1104.         return cw;
  1105.     }

  1107.     /**
  1108.      * Use code generation to provide a method handle based on an annotated Java
  1109.      * method.
  1110.      * 
  1111.      * @see org.jruby.runtime.MethodFactory#getAnnotatedMethod
  1112.      */
  1113.     public void prepareAnnotatedMethod(RubyModule implementationClass, JavaMethod javaMethod, JavaMethodDescriptor desc) {
  1114.         String javaMethodName = desc.name;
  1115.         
  1116.         javaMethod.setArity(Arity.fromAnnotation(desc.anno, desc.actualRequired));
  1117.         javaMethod.setJavaName(javaMethodName);
  1118.         javaMethod.setSingleton(desc.isStatic);
  1119.         javaMethod.setCallConfig(CallConfiguration.getCallConfigByAnno(desc.anno));
  1120.     }

  1122.     /**
  1123.      * Emit code to check the arity of a call to a Java-based method.
  1124.      * 
  1125.      * @param jrubyMethod The annotation of the called method
  1126.      * @param method The code generator for the handle being created
  1127.      */
  1128.     private void checkArity(JRubyMethod jrubyMethod, SkinnyMethodAdapter method, int specificArity) {
  1129.         Label arityError = new Label();
  1130.         Label noArityError = new Label();
  1131.         
  1132.         switch (specificArity) {
  1133.         case 0:
  1134.         case 1:
  1135.         case 2:
  1136.         case 3:
  1137.             // for zero, one, two, three arities, JavaMethod.JavaMethod*.call(...IRubyObject[] args...) will check
  1138.             return;
  1139.         default:
  1140.             boolean checkArity = false;
  1141.             if (jrubyMethod.rest()) {
  1142.                 if (jrubyMethod.required() > 0) {
  1143.                     // just confirm minimum args provided
  1144.                     method.aload(ARGS_INDEX);
  1145.                     method.arraylength();
  1146.                     method.ldc(jrubyMethod.required());
  1147.                     method.if_icmplt(arityError);
  1148.                     checkArity = true;
  1149.                 }
  1150.             } else if (jrubyMethod.optional() > 0) {
  1151.                 if (jrubyMethod.required() > 0) {
  1152.                     // confirm minimum args provided
  1153.                     method.aload(ARGS_INDEX);
  1154.                     method.arraylength();
  1155.                     method.ldc(jrubyMethod.required());
  1156.                     method.if_icmplt(arityError);
  1157.                 }

  1159.                 // confirm maximum not greater than optional
  1160.                 method.aload(ARGS_INDEX);
  1161.                 method.arraylength();
  1162.                 method.ldc(jrubyMethod.required() + jrubyMethod.optional());
  1163.                 method.if_icmpgt(arityError);
  1164.                 checkArity = true;
  1165.             } else {
  1166.                 // just confirm args length == required
  1167.                 method.aload(ARGS_INDEX);
  1168.                 method.arraylength();
  1169.                 method.ldc(jrubyMethod.required());
  1170.                 method.if_icmpne(arityError);
  1171.                 checkArity = true;
  1172.             }

  1174.             if (checkArity) {
  1175.                 method.go_to(noArityError);

  1177.                 // Raise an error if arity does not match requirements
  1178.                 method.label(arityError);
  1179.                 method.aload(THREADCONTEXT_INDEX);
  1180.                 method.invokevirtual(p(ThreadContext.class), "getRuntime", sig(Ruby.class));
  1181.                 method.aload(ARGS_INDEX);
  1182.                 method.ldc(jrubyMethod.required());
  1183.                 method.ldc(jrubyMethod.required() + jrubyMethod.optional());
  1184.                 method.invokestatic(p(Arity.class), "checkArgumentCount", sig(int.class, Ruby.class, IRubyObject[].class, int.class, int.class));
  1185.                 method.pop();

  1187.                 method.label(noArityError);
  1188.             }
  1189.         }
  1190.     }

  1192.     private ClassWriter createCompiledCtor(String namePath, String shortPath, String sup) {
  1193.         ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS | ClassWriter.COMPUTE_FRAMES);
  1194.         cw.visit(RubyInstanceConfig.JAVA_VERSION, ACC_PUBLIC + ACC_SUPER, namePath, null, sup, null);
  1195.         cw.visitSource(shortPath, null);
  1196.         SkinnyMethodAdapter mv = new SkinnyMethodAdapter(cw, ACC_PUBLIC, "<init>", "()V", null, null);
  1197.         mv.visitCode();
  1198.         mv.aload(0);
  1199.         mv.visitMethodInsn(INVOKESPECIAL, sup, "<init>", "()V");
  1200.         mv.voidreturn();
  1201.         mv.end();

  1203.         return cw;
  1204.     }

  1206.     private ClassWriter createJavaMethodCtor(String namePath, String sup, String parameterDesc) throws Exception {
  1207.         ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS | ClassWriter.COMPUTE_FRAMES);
  1208.         String sourceFile = namePath.substring(namePath.lastIndexOf('/') + 1) + ".gen";
  1209.         cw.visit(RubyInstanceConfig.JAVA_VERSION, ACC_PUBLIC + ACC_SUPER, namePath, null, sup, null);
  1210.         cw.visitSource(sourceFile, null);
  1211.         SkinnyMethodAdapter mv = new SkinnyMethodAdapter(cw, ACC_PUBLIC, "<init>", JAVA_SUPER_SIG, null, null);
  1212.         mv.start();
  1213.         mv.aloadMany(0, 1, 2);
  1214.         mv.visitMethodInsn(INVOKESPECIAL, sup, "<init>", JAVA_SUPER_SIG);
  1215.         mv.aload(0);
  1216.         mv.ldc(parameterDesc);
  1217.         mv.invokevirtual(p(JavaMethod.class), "setParameterDesc", sig(void.class, String.class));
  1218.         mv.voidreturn();
  1219.         mv.end();
  1220.         
  1221.         return cw;
  1222.     }

  1224.     private void invokeCallConfigPre(SkinnyMethodAdapter mv, String superClass, int specificArity, boolean block, CallConfiguration callConfig) {
  1225.         // invoke pre method stuff
  1226.         if (callConfig.isNoop()) return;

  1228.         prepareForPre(mv, specificArity, block, callConfig);
  1229.         mv.invokevirtual(superClass, getPreMethod(callConfig), getPreSignature(callConfig));
  1230.     }

  1232.     private void invokeCallConfigPost(SkinnyMethodAdapter mv, String superClass, CallConfiguration callConfig) {
  1233.         if (callConfig.isNoop()) return;

  1235.         mv.aload(1);
  1236.         mv.invokestatic(superClass, getPostMethod(callConfig), sig(void.class, params(ThreadContext.class)));
  1237.     }

  1239.     private void prepareForPre(SkinnyMethodAdapter mv, int specificArity, boolean block, CallConfiguration callConfig) {
  1240.         if (callConfig.isNoop()) return;
  1241.         
  1242.         mv.aloadMany(0, THREADCONTEXT_INDEX);
  1243.         
  1244.         switch (callConfig.framing()) {
  1245.         case Full:
  1246.             mv.aloadMany(RECEIVER_INDEX, NAME_INDEX); // self, name
  1247.             loadBlockForPre(mv, specificArity, block);
  1248.             break;
  1249.         case Backtrace:
  1250.             mv.aload(NAME_INDEX); // name
  1251.             break;
  1252.         case None:
  1253.             break;
  1254.         default: throw new RuntimeException("Unknown call configuration");
  1255.         }
  1256.     }

  1258.     private String getPreMethod(CallConfiguration callConfig) {
  1259.         switch (callConfig) {
  1260.         case FrameFullScopeFull: return "preFrameAndScope";
  1261.         case FrameFullScopeDummy: return "preFrameAndDummyScope";
  1262.         case FrameFullScopeNone: return "preFrameOnly";
  1263.         case FrameBacktraceScopeFull: return "preBacktraceAndScope";
  1264.         case FrameBacktraceScopeDummy: return "preBacktraceDummyScope";
  1265.         case FrameBacktraceScopeNone:  return "preBacktraceOnly";
  1266.         case FrameNoneScopeFull: return "preScopeOnly";
  1267.         case FrameNoneScopeDummy: return "preNoFrameDummyScope";
  1268.         case FrameNoneScopeNone: return "preNoop";
  1269.         default: throw new RuntimeException("Unknown call configuration");
  1270.         }
  1271.     }

  1273.     private String getPreSignature(CallConfiguration callConfig) {
  1274.         switch (callConfig) {
  1275.         case FrameFullScopeFull: return sig(void.class, params(ThreadContext.class, IRubyObject.class, String.class, Block.class));
  1276.         case FrameFullScopeDummy: return sig(void.class, params(ThreadContext.class, IRubyObject.class, String.class, Block.class));
  1277.         case FrameFullScopeNone: return sig(void.class, params(ThreadContext.class, IRubyObject.class, String.class, Block.class));
  1278.         case FrameBacktraceScopeFull: return sig(void.class, params(ThreadContext.class, String.class));
  1279.         case FrameBacktraceScopeDummy: return sig(void.class, params(ThreadContext.class, String.class));
  1280.         case FrameBacktraceScopeNone:  return sig(void.class, params(ThreadContext.class, String.class));
  1281.         case FrameNoneScopeFull: return sig(void.class, params(ThreadContext.class));
  1282.         case FrameNoneScopeDummy: return sig(void.class, params(ThreadContext.class));
  1283.         case FrameNoneScopeNone: return sig(void.class);
  1284.         default: throw new RuntimeException("Unknown call configuration");
  1285.         }
  1286.     }

  1288.     public static String getPostMethod(CallConfiguration callConfig) {
  1289.         switch (callConfig) {
  1290.         case FrameFullScopeFull: return "postFrameAndScope";
  1291.         case FrameFullScopeDummy: return "postFrameAndScope";
  1292.         case FrameFullScopeNone: return "postFrameOnly";
  1293.         case FrameBacktraceScopeFull: return "postBacktraceAndScope";
  1294.         case FrameBacktraceScopeDummy: return "postBacktraceDummyScope";
  1295.         case FrameBacktraceScopeNone:  return "postBacktraceOnly";
  1296.         case FrameNoneScopeFull: return "postScopeOnly";
  1297.         case FrameNoneScopeDummy: return "postNoFrameDummyScope";
  1298.         case FrameNoneScopeNone: return "postNoop";
  1299.         default: throw new RuntimeException("Unknown call configuration");
  1300.         }
  1301.     }

  1303.     private void loadArguments(SkinnyMethodAdapter mv, JavaMethodDescriptor desc, int specificArity) {
  1304.         switch (specificArity) {
  1305.         default:
  1306.         case -1:
  1307.             mv.aload(ARGS_INDEX);
  1308.             break;
  1309.         case 0:
  1310.             // no args
  1311.             break;
  1312.         case 1:
  1313.             loadArgumentWithCast(mv, 1, desc.argumentTypes[0]);
  1314.             break;
  1315.         case 2:
  1316.             loadArgumentWithCast(mv, 1, desc.argumentTypes[0]);
  1317.             loadArgumentWithCast(mv, 2, desc.argumentTypes[1]);
  1318.             break;
  1319.         case 3:
  1320.             loadArgumentWithCast(mv, 1, desc.argumentTypes[0]);
  1321.             loadArgumentWithCast(mv, 2, desc.argumentTypes[1]);
  1322.             loadArgumentWithCast(mv, 3, desc.argumentTypes[2]);
  1323.             break;
  1324.         }
  1325.     }

  1327.     private void loadArgumentWithCast(SkinnyMethodAdapter mv, int argNumber, Class coerceType) {
  1328.         mv.aload(ARGS_INDEX + (argNumber - 1));
  1329.         if (coerceType != IRubyObject.class && coerceType != IRubyObject[].class) {
  1330.             if (coerceType == RubyString.class) {
  1331.                 mv.invokeinterface(p(IRubyObject.class), "convertToString", sig(RubyString.class));
  1332.             } else {
  1333.                 throw new RuntimeException("Unknown coercion target: " + coerceType);
  1334.             }
  1335.         }
  1336.     }

  1338.     /** load block argument for pre() call.  Since we have fixed-arity call
  1339.      * paths we need calculate where the last var holding the block is.
  1340.      *
  1341.      * is we don't have a block we setup NULL_BLOCK as part of our null pattern
  1342.      * strategy (we do not allow null in any field which accepts block).
  1343.      */
  1344.     private void loadBlockForPre(SkinnyMethodAdapter mv, int specificArity, boolean getsBlock) {
  1345.         if (!getsBlock) {            // No block so load null block instance
  1346.             mv.getstatic(p(Block.class), "NULL_BLOCK", ci(Block.class));
  1347.             return;
  1348.         }

  1350.         loadBlock(mv, specificArity, getsBlock);
  1351.     }

  1353.     /** load the block argument from the correct position.  Since we have fixed-
  1354.      * arity call paths we need to calculate where the last var holding the
  1355.      * block is.
  1356.      * 
  1357.      * If we don't have a block then this does nothing.
  1358.      */
  1359.     private void loadBlock(SkinnyMethodAdapter mv, int specificArity, boolean getsBlock) {
  1360.         if (!getsBlock) return;         // No block so nothing more to do
  1361.         
  1362.         switch (specificArity) {        // load block since it accepts a block
  1363.         case 0: case 1: case 2: case 3: // Fixed arities signatures
  1364.             mv.aload(BLOCK_INDEX - 1 + specificArity);
  1365.             break;
  1366.         default: case -1:
  1367.             mv.aload(BLOCK_INDEX);      // Generic arity signature
  1368.             break;
  1369.         }
  1370.     }

  1372.     private void loadReceiver(String typePath, JavaMethodDescriptor desc, SkinnyMethodAdapter mv) {
  1373.         // load target for invocations
  1374.         if (Modifier.isStatic(desc.modifiers)) {
  1375.             if (desc.hasContext) {
  1376.                 mv.aload(THREADCONTEXT_INDEX);
  1377.             }
  1378.             
  1379.             // load self object as IRubyObject, for recv param
  1380.             mv.aload(RECEIVER_INDEX);
  1381.         } else {
  1382.             // load receiver as original type for virtual invocation
  1383.             mv.aload(RECEIVER_INDEX);
  1384.             mv.checkcast(typePath);
  1385.             
  1386.             if (desc.hasContext) {
  1387.                 mv.aload(THREADCONTEXT_INDEX);
  1388.             }
  1389.         }
  1390.     }

  1392.     private Class tryClass(String name, Class targetClass, Class expectedSuperclass) {
  1393.         Class c;
  1394.         try {
  1395.             if (classLoader == null) {
  1396.                 c = Class.forName(name, true, classLoader);
  1397.             } else {
  1398.                 c = classLoader.loadClass(name);
  1399.             }
  1400.         } catch(Exception e) {
  1401.             seenUndefinedClasses = true;
  1402.             return null;
  1403.         }

  1405.         // For JRUBY-5038, ensure loaded class has superclass from same classloader as current JRuby
  1406.         if (c.getSuperclass() == expectedSuperclass) {
  1407.             if (seenUndefinedClasses && !haveWarnedUser) {
  1408.                 haveWarnedUser = true;
  1409.                 System.err.println("WARNING: while creating new bindings for " + targetClass + ",\n" +
  1410.                         "found an existing binding; you may want to run a clean build.");
  1411.             }

  1413.             return c;
  1414.         } else {
  1415.             seenUndefinedClasses = true;
  1416.             return null;
  1417.         }
  1418.     }

  1420.     private Class tryBlockCallbackClass(String name, Class expectedSuperclass) {
  1421.         try {
  1422.             Class c = classLoader.loadClass(name);

  1424.             // For JRUBY-5038, ensure loaded class has superclass from same classloader as current JRuby
  1425.             if (c.getSuperclass() == expectedSuperclass) {
  1426.                 return c;
  1427.             } else {
  1428.                 return null;
  1429.             }
  1430.         } catch (Exception e) {
  1431.             return null;
  1432.         }
  1433.     }

  1435.     private Class tryBlockCallback19Class(String name, Class expectedInterface) {
  1436.         try {
  1437.             Class c = classLoader.loadClass(name);

  1439.             // For JRUBY-5038, ensure loaded class has superclass from same classloader as current JRuby
  1440.             Class<?>[] interfaces = c.getInterfaces();
  1441.             if (interfaces.length == 1 && interfaces[0] == expectedInterface) {
  1442.                 return c;
  1443.             } else {
  1444.                 return null;
  1445.             }
  1446.         } catch (Exception e) {
  1447.             return null;
  1448.         }
  1449.     }

  1451.     protected Class endCall(ClassWriter cw, String name) {
  1452.         return endClass(cw, name);
  1453.     }

  1455.     protected Class endCallWithBytes(byte[] classBytes, String name) {
  1456.         return endClassWithBytes(classBytes, name);
  1457.     }

  1459.     protected byte[] endCallOffline(ClassWriter cw) {
  1460.         return endClassOffline(cw);
  1461.     }

  1463.     protected Class endClass(ClassWriter cw, String name) {
  1464.         cw.visitEnd();
  1465.         byte[] code = cw.toByteArray();
  1466.         if (DEBUG) CheckClassAdapter.verify(new ClassReader(code), false, new PrintWriter(System.err));
  1467.          
  1468.         return classLoader.defineClass(name, code);
  1469.     }

  1471.     protected Class endClassWithBytes(byte[] code, String name) {
  1472.         return classLoader.defineClass(name, code);
  1473.     }

  1475.     protected byte[] endClassOffline(ClassWriter cw) {
  1476.         cw.visitEnd();
  1477.         byte[] code = cw.toByteArray();
  1478.         if (DEBUG) CheckClassAdapter.verify(new ClassReader(code), false, new PrintWriter(System.err));

  1480.         return code;
  1481.     }
  1482.     
  1483.     private SkinnyMethodAdapter beginMethod(ClassWriter cw, String methodName, int specificArity, boolean block) {
  1484.         switch (specificArity) {
  1485.         default:
  1486.         case -1:
  1487.             if (block) {
  1488.                 return new SkinnyMethodAdapter(cw, ACC_PUBLIC, methodName, COMPILED_CALL_SIG_BLOCK, null, null);
  1489.             } else {
  1490.                 return new SkinnyMethodAdapter(cw, ACC_PUBLIC, methodName, COMPILED_CALL_SIG, null, null);
  1491.             }
  1492.         case 0:
  1493.             if (block) {
  1494.                 return new SkinnyMethodAdapter(cw, ACC_PUBLIC, methodName, COMPILED_CALL_SIG_ZERO_BLOCK, null, null);
  1495.             } else {
  1496.                 return new SkinnyMethodAdapter(cw, ACC_PUBLIC, methodName, COMPILED_CALL_SIG_ZERO, null, null);
  1497.             }
  1498.         case 1:
  1499.             if (block) {
  1500.                 return new SkinnyMethodAdapter(cw, ACC_PUBLIC, methodName, COMPILED_CALL_SIG_ONE_BLOCK, null, null);
  1501.             } else {
  1502.                 return new SkinnyMethodAdapter(cw, ACC_PUBLIC, methodName, COMPILED_CALL_SIG_ONE, null, null);
  1503.             }
  1504.         case 2:
  1505.             if (block) {
  1506.                 return new SkinnyMethodAdapter(cw, ACC_PUBLIC, methodName, COMPILED_CALL_SIG_TWO_BLOCK, null, null);
  1507.             } else {
  1508.                 return new SkinnyMethodAdapter(cw, ACC_PUBLIC, methodName, COMPILED_CALL_SIG_TWO, null, null);
  1509.             }
  1510.         case 3:
  1511.             if (block) {
  1512.                 return new SkinnyMethodAdapter(cw, ACC_PUBLIC, methodName, COMPILED_CALL_SIG_THREE_BLOCK, null, null);
  1513.             } else {
  1514.                 return new SkinnyMethodAdapter(cw, ACC_PUBLIC, methodName, COMPILED_CALL_SIG_THREE, null, null);
  1515.             }
  1516.         }
  1517.     }

  1519.     private void addAnnotatedMethodInvoker(ClassWriter cw, String callName, String superClass, List<JavaMethodDescriptor> descs) {
  1520.         for (JavaMethodDescriptor desc: descs) {
  1521.             int specificArity = -1;
  1522.             if (desc.optional == 0 && !desc.rest) {
  1523.                 if (desc.required == 0) {
  1524.                     if (desc.actualRequired <= 3) {
  1525.                         specificArity = desc.actualRequired;
  1526.                     } else {
  1527.                         specificArity = -1;
  1528.                     }
  1529.                 } else if (desc.required >= 0 && desc.required <= 3) {
  1530.                     specificArity = desc.required;
  1531.                 }
  1532.             }

  1534.             boolean hasBlock = desc.hasBlock;
  1535.             SkinnyMethodAdapter mv = null;

  1537.             mv = beginMethod(cw, callName, specificArity, hasBlock);
  1538.             mv.visitCode();

  1540.             createAnnotatedMethodInvocation(desc, mv, superClass, specificArity, hasBlock);

  1542.             mv.end();
  1543.         }
  1544.     }

  1546.     private void createAnnotatedMethodInvocation(JavaMethodDescriptor desc, SkinnyMethodAdapter method, String superClass, int specificArity, boolean block) {
  1547.         String typePath = desc.declaringClassPath;
  1548.         String javaMethodName = desc.name;

  1550.         checkArity(desc.anno, method, specificArity);
  1551.         
  1552.         CallConfiguration callConfig = CallConfiguration.getCallConfigByAnno(desc.anno);
  1553.         if (!callConfig.isNoop()) {
  1554.             invokeCallConfigPre(method, superClass, specificArity, block, callConfig);
  1555.         }

  1557.         int traceBoolIndex = -1;
  1558.         if (RubyInstanceConfig.FULL_TRACE_ENABLED) {
  1559.             // load and store trace enabled flag
  1560.             switch (specificArity) {
  1561.             case -1:
  1562.                 traceBoolIndex = ARGS_INDEX + (block ? 1 : 0) + 1;
  1563.                 break;
  1564.             case 0:
  1565.                 traceBoolIndex = ARGS_INDEX + (block ? 1 : 0);
  1566.                 break;
  1567.             default:
  1568.                 traceBoolIndex = ARGS_INDEX + specificArity + (block ? 1 : 0) + 1;
  1569.             }

  1571.             method.aload(1);
  1572.             method.invokevirtual(p(ThreadContext.class), "getRuntime", sig(Ruby.class));
  1573.             method.invokevirtual(p(Ruby.class), "hasEventHooks", sig(boolean.class));
  1574.             method.istore(traceBoolIndex);

  1576.             // call trace
  1577.             invokeCCallTrace(method, traceBoolIndex);
  1578.         }

  1580.         Label tryBegin = new Label();
  1581.         Label tryEnd = new Label();
  1582.         Label doFinally = new Label();

  1584.         if (!callConfig.isNoop()) {
  1585.             method.trycatch(tryBegin, tryEnd, doFinally, null);
  1586.         }
  1587.         
  1588.         method.label(tryBegin);
  1589.         {
  1590.             loadReceiver(typePath, desc, method);
  1591.             
  1592.             loadArguments(method, desc, specificArity);
  1593.             
  1594.             loadBlock(method, specificArity, block);

  1596.             if (Modifier.isStatic(desc.modifiers)) {
  1597.                 // static invocation
  1598.                 method.invokestatic(typePath, javaMethodName, desc.signature);
  1599.             } else {
  1600.                 // virtual invocation
  1601.                 method.invokevirtual(typePath, javaMethodName, desc.signature);
  1602.             }

  1604.             if (desc.getReturnClass() == void.class) {
  1605.                 // void return type, so we need to load a nil for returning below
  1606.                 method.aload(THREADCONTEXT_INDEX);
  1607.                 method.getfield(p(ThreadContext.class), "nil", ci(IRubyObject.class));
  1608.             }
  1609.         }
  1610.         method.label(tryEnd);
  1611.         
  1612.         // normal finally and exit
  1613.         {
  1614.             if (RubyInstanceConfig.FULL_TRACE_ENABLED) {
  1615.                 invokeCReturnTrace(method, traceBoolIndex);
  1616.             }
  1617.             
  1618.             if (!callConfig.isNoop()) {
  1619.                 invokeCallConfigPost(method, superClass, callConfig);
  1620.             }

  1622.             // return
  1623.             method.visitInsn(ARETURN);
  1624.         }
  1625.         
  1626.         // these are only needed if we have a non-noop call config
  1627.         if (!callConfig.isNoop()) {
  1628.             // finally handling for abnormal exit
  1629.             {
  1630.                 method.label(doFinally);
  1631.                 
  1632.                 if (RubyInstanceConfig.FULL_TRACE_ENABLED) {
  1633.                     invokeCReturnTrace(method, traceBoolIndex);
  1634.                 }

  1636.                 //call post method stuff (exception raised)
  1637.                 if (!callConfig.isNoop()) {
  1638.                     invokeCallConfigPost(method, superClass, callConfig);
  1639.                 }

  1641.                 // rethrow exception
  1642.                 method.athrow(); // rethrow it
  1643.             }
  1644.         }
  1645.     }

  1647.     private void invokeCCallTrace(SkinnyMethodAdapter method, int traceBoolIndex) {
  1648.         method.aloadMany(0, 1); // method, threadContext
  1649.         method.iload(traceBoolIndex); // traceEnable
  1650.         method.aload(4); // invokedName
  1651.         method.invokevirtual(p(JavaMethod.class), "callTrace", sig(void.class, ThreadContext.class, boolean.class, String.class));
  1652.     }
  1653.     
  1654.     private void invokeCReturnTrace(SkinnyMethodAdapter method, int traceBoolIndex) {
  1655.         method.aloadMany(0, 1); // method, threadContext
  1656.         method.iload(traceBoolIndex); // traceEnable
  1657.         method.aload(4); // invokedName
  1658.         method.invokevirtual(p(JavaMethod.class), "returnTrace", sig(void.class, ThreadContext.class, boolean.class, String.class));
  1659.     }

  1661.     private void invokeTraceCompiledPre(SkinnyMethodAdapter mv, String superClass, int traceBoolIndex, String filename, int line) {
  1662.         mv.aloadMany(0, 1); // method, threadContext
  1663.         mv.iload(traceBoolIndex); // traceEnable
  1664.         mv.aload(4); // invokedName
  1665.         mv.ldc(filename);
  1666.         mv.ldc(line);
  1667.         mv.invokevirtual(superClass, "callTraceCompiled", sig(void.class, ThreadContext.class, boolean.class, String.class, String.class, int.class));
  1668.     }

  1670.     private void invokeTraceCompiledPost(SkinnyMethodAdapter mv, String superClass, int traceBoolIndex) {
  1671.         mv.aloadMany(0, 1); // method, threadContext
  1672.         mv.iload(traceBoolIndex); // traceEnable
  1673.         mv.aload(4); // invokedName
  1674.         mv.invokevirtual(superClass, "returnTraceCompiled", sig(void.class, ThreadContext.class, boolean.class, String.class));
  1675.     }
  1676. }
Created with JaCoCo 0.7.3.201501050207