jruby · Dec 23, 2014 · Dec 23, 2014 · Dec 23, 2014
diff --git a/core/src/main/java/org/jruby/ir/IRBuilder.java b/core/src/main/java/org/jruby/ir/IRBuilder.java
@@ -987,7 +987,7 @@ public Operand buildCall(CallNode callNode, IRScope s) {
         List<Operand> args         = setupCallArgs(callArgsNode, s);
         Operand       block        = setupCallClosure(callNode.getIterNode(), s);
         Variable      callResult   = s.createTemporaryVariable();
-        CallInstr     callInstr    = CallInstr.create(callResult, callNode.getName(), receiver, args.toArray(new Operand[args.size()]), block);
+        CallInstr     callInstr    = (CallInstr)CallInstr.create(callResult, callNode.getName(), receiver, args.toArray(new Operand[args.size()]), block).specializeForInterpretation();
 
         // This is to support the ugly Proc.new with no block, which must see caller's frame
         if (
@@ -2204,7 +2204,7 @@ public Operand buildFCall(FCallNode fcallNode, IRScope s) {
         List<Operand> args         = setupCallArgs(callArgsNode, s);
         Operand       block        = setupCallClosure(fcallNode.getIterNode(), s);
         Variable      callResult   = s.createTemporaryVariable();
-        CallInstr     callInstr    = CallInstr.create(CallType.FUNCTIONAL, callResult, fcallNode.getName(), s.getSelf(), args.toArray(new Operand[args.size()]), block);
+        CallInstr     callInstr    = (CallInstr)CallInstr.create(CallType.FUNCTIONAL, callResult, fcallNode.getName(), s.getSelf(), args.toArray(new Operand[args.size()]), block).specializeForInterpretation();
         receiveBreakException(s, block, callInstr);
         return callResult;
     }
@@ -3381,7 +3381,7 @@ public Operand buildVAlias(VAliasNode valiasNode, IRScope s) {
 
     public Operand buildVCall(VCallNode node, IRScope s) {
         Variable callResult = s.createTemporaryVariable();
-        Instr    callInstr  = CallInstr.create(CallType.VARIABLE, callResult, node.getName(), s.getSelf(), NO_ARGS, null);
+        Instr    callInstr  = CallInstr.create(CallType.VARIABLE, callResult, node.getName(), s.getSelf(), NO_ARGS, null).specializeForInterpretation();
         addInstr(s, callInstr);
         return callResult;
     }

diff --git a/core/src/main/java/org/jruby/ir/IRVisitor.java b/core/src/main/java/org/jruby/ir/IRVisitor.java
@@ -5,6 +5,10 @@
 import org.jruby.ir.instructions.boxing.*;
 import org.jruby.ir.instructions.defined.GetErrorInfoInstr;
 import org.jruby.ir.instructions.defined.RestoreErrorInfoInstr;
+import org.jruby.ir.instructions.specialized.OneFixnumArgNoBlockCallInstr;
+import org.jruby.ir.instructions.specialized.OneFloatArgNoBlockCallInstr;
+import org.jruby.ir.instructions.specialized.OneOperandArgNoBlockCallInstr;
+import org.jruby.ir.instructions.specialized.ZeroOperandArgNoBlockCallInstr;
 import org.jruby.ir.operands.*;
 import org.jruby.ir.operands.Boolean;
 
@@ -75,6 +79,9 @@ private void error(Object object) {
     public void NonlocalReturnInstr(NonlocalReturnInstr nonlocalreturninstr) { error(nonlocalreturninstr); }
     public void NopInstr(NopInstr nopinstr) { error(nopinstr); }
     public void NoResultCallInstr(NoResultCallInstr noresultcallinstr) { error(noresultcallinstr); }
+    public void OneFixnumArgNoBlockCallInstr(OneFixnumArgNoBlockCallInstr oneFixnumArgNoBlockCallInstr) { error(oneFixnumArgNoBlockCallInstr); }
+    public void OneFloatArgNoBlockCallInstr(OneFloatArgNoBlockCallInstr oneFloatArgNoBlockCallInstr) { error(oneFloatArgNoBlockCallInstr); }
+    public void OneOperandArgNoBlockCallInstr(OneOperandArgNoBlockCallInstr oneOperandArgNoBlockCallInstr) { error(oneOperandArgNoBlockCallInstr); }
     public void OptArgMultipleAsgnInstr(OptArgMultipleAsgnInstr optargmultipleasgninstr) { error(optargmultipleasgninstr); }
     public void PopBindingInstr(PopBindingInstr popbindinginstr) { error(popbindinginstr); }
     public void PopFrameInstr(PopFrameInstr popframeinstr) { error(popframeinstr); }
@@ -111,6 +118,7 @@ private void error(Object object) {
     public void UndefMethodInstr(UndefMethodInstr undefmethodinstr) { error(undefmethodinstr); }
     public void UnresolvedSuperInstr(UnresolvedSuperInstr unresolvedsuperinstr) { error(unresolvedsuperinstr); }
     public void YieldInstr(YieldInstr yieldinstr) { error(yieldinstr); }
+    public void ZeroOperandArgNoBlockCallInstr(ZeroOperandArgNoBlockCallInstr zeroOperandArgNoBlockCallInstr) { error(zeroOperandArgNoBlockCallInstr); }
     public void ZSuperInstr(ZSuperInstr zsuperinstr) { error(zsuperinstr); }
 
     // "defined" instructions

diff --git a/core/src/main/java/org/jruby/ir/Operation.java b/core/src/main/java/org/jruby/ir/Operation.java
@@ -68,6 +68,7 @@ public enum Operation {
 
     /* specialized calls */
     CALL_1F(OpFlags.f_has_side_effect | OpFlags.f_is_call | OpFlags.f_can_raise_exception),
+    CALL_1D(OpFlags.f_has_side_effect | OpFlags.f_is_call | OpFlags.f_can_raise_exception),
     CALL_1O(OpFlags.f_has_side_effect | OpFlags.f_is_call | OpFlags.f_can_raise_exception),
     CALL_1OB(OpFlags.f_has_side_effect | OpFlags.f_is_call | OpFlags.f_can_raise_exception),
     CALL_0O(OpFlags.f_has_side_effect | OpFlags.f_is_call | OpFlags.f_can_raise_exception),

diff --git a/core/src/main/java/org/jruby/ir/instructions/CallBase.java b/core/src/main/java/org/jruby/ir/instructions/CallBase.java
@@ -4,6 +4,7 @@
 import org.jruby.ir.IRScope;
 import org.jruby.ir.Operation;
 import org.jruby.ir.operands.*;
+import org.jruby.ir.operands.Float;
 import org.jruby.ir.runtime.IRRuntimeHelpers;
 import org.jruby.ir.transformations.inlining.CloneInfo;
 import org.jruby.parser.StaticScope;
@@ -149,6 +150,14 @@ public boolean isAllFixnums() {
         return true;
     }
 
+    public boolean isAllFloats() {
+        for (Operand argument : arguments) {
+            if (!(argument instanceof Float)) return false;
+        }
+
+        return true;
+    }
+
     @Override
     public boolean computeScopeFlags(IRScope scope) {
         boolean modifiedScope = false;

diff --git a/core/src/main/java/org/jruby/ir/instructions/CallInstr.java b/core/src/main/java/org/jruby/ir/instructions/CallInstr.java
@@ -3,6 +3,7 @@
 import org.jruby.ir.IRVisitor;
 import org.jruby.ir.Operation;
 import org.jruby.ir.instructions.specialized.OneFixnumArgNoBlockCallInstr;
+import org.jruby.ir.instructions.specialized.OneFloatArgNoBlockCallInstr;
 import org.jruby.ir.instructions.specialized.OneOperandArgBlockCallInstr;
 import org.jruby.ir.instructions.specialized.OneOperandArgNoBlockCallInstr;
 import org.jruby.ir.instructions.specialized.ZeroOperandArgNoBlockCallInstr;
@@ -62,6 +63,7 @@ public CallBase specializeForInterpretation() {
                 return hasClosure() ? this : new ZeroOperandArgNoBlockCallInstr(this);
             case 1:
                 if (isAllFixnums() && !hasClosure()) return new OneFixnumArgNoBlockCallInstr(this);
+                if (isAllFloats() && !hasClosure()) return new OneFloatArgNoBlockCallInstr(this);
 
                 return hasClosure() ? new OneOperandArgBlockCallInstr(this) : new OneOperandArgNoBlockCallInstr(this);
         }

diff --git a/core/src/main/java/org/jruby/ir/instructions/specialized/OneFixnumArgNoBlockCallInstr.java b/core/src/main/java/org/jruby/ir/instructions/specialized/OneFixnumArgNoBlockCallInstr.java
@@ -1,5 +1,6 @@
 package org.jruby.ir.instructions.specialized;
 
+import org.jruby.ir.IRVisitor;
 import org.jruby.ir.Operation;
 import org.jruby.ir.instructions.CallInstr;
 import org.jruby.ir.operands.Fixnum;
@@ -34,4 +35,9 @@ public Object interpret(ThreadContext context, StaticScope currScope, DynamicSco
         IRubyObject object = (IRubyObject) receiver.retrieve(context, self, currScope, dynamicScope, temp);
         return getCallSite().call(context, self, object, fixNum);
     }
+
+    @Override
+    public void visit(IRVisitor visitor) {
+        visitor.OneFixnumArgNoBlockCallInstr(this);
+    }
 }
diff --git a/core/src/main/java/org/jruby/ir/instructions/specialized/OneFloatArgNoBlockCallInstr.java b/core/src/main/java/org/jruby/ir/instructions/specialized/OneFloatArgNoBlockCallInstr.java
@@ -0,0 +1,42 @@
+package org.jruby.ir.instructions.specialized;
+
+import org.jruby.ir.IRVisitor;
+import org.jruby.ir.Operation;
+import org.jruby.ir.instructions.CallInstr;
+import org.jruby.ir.operands.Float;
+import org.jruby.parser.StaticScope;
+import org.jruby.runtime.DynamicScope;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+public class OneFloatArgNoBlockCallInstr extends CallInstr {
+    private final double flote;
+
+    public OneFloatArgNoBlockCallInstr(CallInstr call) {
+        super(Operation.CALL_1D, call);
+
+        assert getCallArgs().length == 1;
+
+        this.flote = ((Float) getCallArgs()[0]).value;
+    }
+
+    @Override
+    public String toString() {
+        return super.toString() + "{1F}";
+    }
+
+    public double getFloatArg() {
+        return flote;
+    }
+
+    @Override
+    public Object interpret(ThreadContext context, StaticScope currScope, DynamicScope dynamicScope, IRubyObject self, Object[] temp) {
+        IRubyObject object = (IRubyObject) receiver.retrieve(context, self, currScope, dynamicScope, temp);
+        return getCallSite().call(context, self, object, flote);
+    }
+
+    @Override
+    public void visit(IRVisitor visitor) {
+        visitor.OneFloatArgNoBlockCallInstr(this);
+    }
+}
diff --git a/core/src/main/java/org/jruby/ir/instructions/specialized/OneOperandArgNoBlockCallInstr.java b/core/src/main/java/org/jruby/ir/instructions/specialized/OneOperandArgNoBlockCallInstr.java
@@ -1,5 +1,6 @@
 package org.jruby.ir.instructions.specialized;
 
+import org.jruby.ir.IRVisitor;
 import org.jruby.ir.Operation;
 import org.jruby.ir.instructions.CallInstr;
 import org.jruby.ir.operands.Operand;
@@ -28,4 +29,9 @@ public Object interpret(ThreadContext context, StaticScope currScope, DynamicSco
         IRubyObject arg1 = (IRubyObject) getCallArgs()[0].retrieve(context, self, currScope, dynamicScope, temp);
         return getCallSite().call(context, self, object, arg1);
     }
+
+    @Override
+    public void visit(IRVisitor visitor) {
+        visitor.OneOperandArgNoBlockCallInstr(this);
+    }
 }
diff --git a/core/src/main/java/org/jruby/ir/instructions/specialized/ZeroOperandArgNoBlockCallInstr.java b/core/src/main/java/org/jruby/ir/instructions/specialized/ZeroOperandArgNoBlockCallInstr.java
@@ -1,8 +1,8 @@
 package org.jruby.ir.instructions.specialized;
 
+import org.jruby.ir.IRVisitor;
 import org.jruby.ir.Operation;
 import org.jruby.ir.instructions.CallInstr;
-import org.jruby.ir.operands.Operand;
 import org.jruby.parser.StaticScope;
 import org.jruby.runtime.DynamicScope;
 import org.jruby.runtime.ThreadContext;
@@ -24,4 +24,9 @@ public Object interpret(ThreadContext context, StaticScope currScope, DynamicSco
 
         return getCallSite().call(context, self, object);
     }
+
+    @Override
+    public void visit(IRVisitor visitor) {
+        visitor.ZeroOperandArgNoBlockCallInstr(this);
+    }
 }
diff --git a/core/src/main/java/org/jruby/ir/interpreter/Interpreter.java b/core/src/main/java/org/jruby/ir/interpreter/Interpreter.java
@@ -273,6 +273,13 @@ private static void processCall(ThreadContext context, Instr instr, Operation op
             setResult(temp, currDynScope, call.getResult(), result);
             break;
         }
+        case CALL_1D: {
+            OneFloatArgNoBlockCallInstr call = (OneFloatArgNoBlockCallInstr)instr;
+            IRubyObject r = (IRubyObject)retrieveOp(call.getReceiver(), context, self, currDynScope, currScope, temp);
+            result = call.getCallSite().call(context, self, r, call.getFloatArg());
+            setResult(temp, currDynScope, call.getResult(), result);
+            break;
+        }
         case CALL_1O: {
             OneOperandArgNoBlockCallInstr call = (OneOperandArgNoBlockCallInstr)instr;
             IRubyObject r = (IRubyObject)retrieveOp(call.getReceiver(), context, self, currDynScope, currScope, temp);

diff --git a/core/src/main/java/org/jruby/ir/runtime/IRRuntimeHelpers.java b/core/src/main/java/org/jruby/ir/runtime/IRRuntimeHelpers.java
@@ -28,6 +28,7 @@
 import org.jruby.parser.StaticScope;
 import org.jruby.runtime.*;
 import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.callsite.FunctionalCachingCallSite;
 import org.jruby.util.ByteList;
 import org.jruby.util.DefinedMessage;
 import org.jruby.util.RegexpOptions;
@@ -1292,4 +1293,9 @@ public static RaiseException newRequiredKeywordArgumentError(ThreadContext conte
     public static void pushExitBlock(ThreadContext context, Block blk) {
         context.runtime.pushExitBlock(context.runtime.newProc(Block.Type.LAMBDA, blk));
     }
+
+    @JIT
+    public static FunctionalCachingCallSite newFunctionalCachingCallSite(String name) {
+        return new FunctionalCachingCallSite(name);
+    }
 }
diff --git a/core/src/main/java/org/jruby/ir/targets/IRBytecodeAdapter.java b/core/src/main/java/org/jruby/ir/targets/IRBytecodeAdapter.java
@@ -275,6 +275,24 @@ public org.objectweb.asm.Label newLabel() {
      */
     public abstract void invokeOther(String name, int arity, boolean hasClosure);
 
+    /**
+     * Invoke a fixnum-receiving method on an object other than self.
+     *
+     * Stack required: context, self, receiver (fixnum will be handled separately)
+     *
+     * @param name name of the method to invoke
+     */
+    public abstract void invokeOtherOneFixnum(String name, long fixnum);
+
+    /**
+     * Invoke a float-receiving method on an object other than self.
+     *
+     * Stack required: context, self, receiver (float will be handled separately)
+     *
+     * @param name name of the method to invoke
+     */
+    public abstract void invokeOtherOneFloat(String name, double flote);
+
 
     /**
      * Invoke a method on self.

diff --git a/core/src/main/java/org/jruby/ir/targets/IRBytecodeAdapter6.java b/core/src/main/java/org/jruby/ir/targets/IRBytecodeAdapter6.java
@@ -254,10 +254,8 @@ public void invokeOther(String name, int arity, boolean hasClosure) {
         Label doCall = new Label();
         adapter2.ifnonnull(doCall);
         adapter2.pop();
-        adapter2.newobj(p(FunctionalCachingCallSite.class));
-        adapter2.dup();
         adapter2.ldc(name);
-        adapter2.invokespecial(p(FunctionalCachingCallSite.class), "<init>", sig(void.class, String.class));
+        adapter2.invokestatic(p(IRRuntimeHelpers.class), "newFunctionalCachingCallSite", sig(FunctionalCachingCallSite.class, String.class));
         adapter2.dup();
         adapter2.putstatic(getClassData().clsName, methodName, ci(CachingCallSite.class));
 
@@ -322,6 +320,94 @@ public static void buildArrayFromLocals(SkinnyMethodAdapter adapter2, int base,
         }
     }
 
+    public void invokeOtherOneFixnum(String name, long fixnum) {
+        SkinnyMethodAdapter adapter2;
+        String incomingSig = sig(JVM.OBJECT, params(ThreadContext.class, JVM.OBJECT, JVM.OBJECT));
+        String outgoingSig = sig(JVM.OBJECT, params(ThreadContext.class, JVM.OBJECT, JVM.OBJECT, long.class));
+
+        String methodName = "invokeOtherOneFixnum" + getClassData().callSiteCount.getAndIncrement() + ":" + JavaNameMangler.mangleMethodName(name);
+
+        adapter2 = new SkinnyMethodAdapter(
+                adapter.getClassVisitor(),
+                Opcodes.ACC_PRIVATE | Opcodes.ACC_STATIC | Opcodes.ACC_SYNTHETIC,
+                methodName,
+                incomingSig,
+                null,
+                null);
+
+        // call site object field
+        adapter.getClassVisitor().visitField(Opcodes.ACC_PRIVATE | Opcodes.ACC_STATIC, methodName, ci(CachingCallSite.class), null, null).visitEnd();
+
+        // lazily construct it
+        adapter2.getstatic(getClassData().clsName, methodName, ci(CachingCallSite.class));
+        adapter2.dup();
+        Label doCall = new Label();
+        adapter2.ifnonnull(doCall);
+        adapter2.pop();
+        adapter2.ldc(name);
+        adapter2.invokestatic(p(IRRuntimeHelpers.class), "newFunctionalCachingCallSite", sig(FunctionalCachingCallSite.class, String.class));
+        adapter2.dup();
+        adapter2.putstatic(getClassData().clsName, methodName, ci(CachingCallSite.class));
+
+        // use call site to invoke
+        adapter2.label(doCall);
+        adapter2.aload(0); // context
+        adapter2.aload(1); // caller
+        adapter2.aload(2); // target
+        adapter2.ldc(fixnum); // fixnum
+
+        adapter2.invokevirtual(p(CachingCallSite.class), "call", outgoingSig);
+        adapter2.areturn();
+        adapter2.end();
+
+        // now call it
+        adapter.invokestatic(getClassData().clsName, methodName, incomingSig);
+    }
+
+    public void invokeOtherOneFloat(String name, double flote) {
+        SkinnyMethodAdapter adapter2;
+        String incomingSig = sig(JVM.OBJECT, params(ThreadContext.class, JVM.OBJECT, JVM.OBJECT));
+        String outgoingSig = sig(JVM.OBJECT, params(ThreadContext.class, JVM.OBJECT, JVM.OBJECT, double.class));
+
+        String methodName = "invokeOtherOneFloat" + getClassData().callSiteCount.getAndIncrement() + ":" + JavaNameMangler.mangleMethodName(name);
+
+        adapter2 = new SkinnyMethodAdapter(
+                adapter.getClassVisitor(),
+                Opcodes.ACC_PRIVATE | Opcodes.ACC_STATIC | Opcodes.ACC_SYNTHETIC,
+                methodName,
+                incomingSig,
+                null,
+                null);
+
+        // call site object field
+        adapter.getClassVisitor().visitField(Opcodes.ACC_PRIVATE | Opcodes.ACC_STATIC, methodName, ci(CachingCallSite.class), null, null).visitEnd();
+
+        // lazily construct it
+        adapter2.getstatic(getClassData().clsName, methodName, ci(CachingCallSite.class));
+        adapter2.dup();
+        Label doCall = new Label();
+        adapter2.ifnonnull(doCall);
+        adapter2.pop();
+        adapter2.ldc(name);
+        adapter2.invokestatic(p(IRRuntimeHelpers.class), "newFunctionalCachingCallSite", sig(FunctionalCachingCallSite.class, String.class));
+        adapter2.dup();
+        adapter2.putstatic(getClassData().clsName, methodName, ci(CachingCallSite.class));
+
+        // use call site to invoke
+        adapter2.label(doCall);
+        adapter2.aload(0); // context
+        adapter2.aload(1); // caller
+        adapter2.aload(2); // target
+        adapter2.ldc(flote); // float
+
+        adapter2.invokevirtual(p(CachingCallSite.class), "call", outgoingSig);
+        adapter2.areturn();
+        adapter2.end();
+
+        // now call it
+        adapter.invokestatic(getClassData().clsName, methodName, incomingSig);
+    }
+
     public void invokeSelf(String name, int arity, boolean hasClosure) {
         if (arity > MAX_ARGUMENTS) throw new NotCompilableException("call to `" + name + "' has more than " + MAX_ARGUMENTS + " arguments");
 

diff --git a/core/src/main/java/org/jruby/ir/targets/IRBytecodeAdapter7.java b/core/src/main/java/org/jruby/ir/targets/IRBytecodeAdapter7.java
@@ -136,6 +136,30 @@ public void invokeOther(String name, int arity, boolean hasClosure) {
         }
     }
 
+    public void invokeOtherOneFixnum(String name, long fixnum) {
+        String signature = sig(IRubyObject.class, params(ThreadContext.class, IRubyObject.class, IRubyObject.class));
+
+        adapter.invokedynamic(
+                "fixnumOperator:" + JavaNameMangler.mangleMethodName(name),
+                signature,
+                InvokeDynamicSupport.getFixnumOperatorHandle(),
+                fixnum,
+                "",
+                0);
+    }
+
+    public void invokeOtherOneFloat(String name, double flote) {
+        String signature = sig(IRubyObject.class, params(ThreadContext.class, IRubyObject.class, IRubyObject.class));
+
+        adapter.invokedynamic(
+            "floatOperator:" + JavaNameMangler.mangleMethodName(name),
+            signature,
+            InvokeDynamicSupport.getFloatOperatorHandle(),
+            flote,
+            "",
+            0);
+    }
+
     public void invokeSelf(String name, int arity, boolean hasClosure) {
         if (arity > MAX_ARGUMENTS) throw new NotCompilableException("call to `" + name + "' has more than " + MAX_ARGUMENTS + " arguments");