Added tail call optimization to TruffleMumbler.

Author: cesquivias

graal/src/mumbler/truffle/Reader.java

@@ -120,6 +120,7 @@ private MumblerNode toSpecialForm() {
                 for (Convertible bodyConv : this.list.subList(2, this.list.size())) {
                     bodyNodes.add(bodyConv.convert());
                 }
+                bodyNodes.get(bodyNodes.size() - 1).setIsTail();
                 frameDescriptors.pop();
                 MumblerFunction function = MumblerFunction.create(
                         formalParameters.toArray(new FrameSlot[] {}),

graal/src/mumbler/truffle/TruffleMumblerMain.java

@@ -15,6 +15,7 @@
 import mumbler.truffle.node.builtin.NowBuiltinNodeFactory;
 import mumbler.truffle.node.builtin.PrintlnBuiltinNodeFactory;
 import mumbler.truffle.node.builtin.SubBuiltinNodeFactory;
+import mumbler.truffle.node.call.TailCallException;
 import mumbler.truffle.type.MumblerFunction;
 import mumbler.truffle.type.MumblerList;
 
@@ -73,9 +74,14 @@ private static Object execute(MumblerList<MumblerNode> nodes,
                 frameDescriptor);
         DirectCallNode directCallNode = Truffle.getRuntime()
                 .createDirectCallNode(function.callTarget);
-        return directCallNode.call(
-                topFrame,
-                new Object[] {topFrame.materialize()});
+
+        try {
+            return directCallNode.call(
+                    topFrame,
+                    new Object[] {topFrame.materialize()});
+        } catch (TailCallException e) {
+            return e.call(topFrame);
+        }
     }
 
     private static VirtualFrame createTopFrame(FrameDescriptor frameDescriptor) {

graal/src/mumbler/truffle/node/MumblerNode.java

@@ -8,6 +8,7 @@
 import mumbler.truffle.type.MumblerList;
 import mumbler.truffle.type.MumblerSymbol;
 
+import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
 import com.oracle.truffle.api.dsl.TypeSystemReference;
 import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.nodes.Node;
@@ -17,6 +18,17 @@
 @TypeSystemReference(MumblerTypes.class)
 @NodeInfo(language = "Mumbler Language", description = "The abstract base node for all expressions")
 public abstract class MumblerNode extends Node {
+    @CompilationFinal
+    private boolean isTail = false;
+
+    public boolean isTail() {
+        return this.isTail;
+    }
+
+    public void setIsTail() {
+        this.isTail = true;
+    }
+
     public abstract Object execute(VirtualFrame virtualFrame);
 
     public long executeLong(VirtualFrame virtualFrame)

graal/src/mumbler/truffle/node/MumblerRootNode.java

@@ -2,6 +2,7 @@
 
 import java.util.Arrays;
 
+import mumbler.truffle.node.call.TailCallException;
 import mumbler.truffle.node.special.DefineNodeFactory;
 
 import com.oracle.truffle.api.CompilerAsserts;

graal/src/mumbler/truffle/node/call/InvokeNode.java

@@ -39,15 +39,25 @@ public Object execute(VirtualFrame virtualFrame) {
 
         if (this.callNode == null)  {
             CompilerDirectives.transferToInterpreterAndInvalidate();
-            this.callNode = this.insert(Truffle.getRuntime().createDirectCallNode(function.callTarget));
+            this.callNode = this.insert(Truffle.getRuntime()
+                    .createDirectCallNode(function.callTarget));
         }
 
         if (function.callTarget != this.callNode.getCallTarget()) {
             CompilerDirectives.transferToInterpreterAndInvalidate();
-            throw new UnsupportedOperationException("need to implement a proper inline cache.");
+            throw new UnsupportedOperationException(
+                    "Need to implement a proper inline cache.");
         }
 
-        return this.callNode.call(virtualFrame, argumentValues);
+        if (this.isTail()) {
+            throw new TailCallException(this.callNode, argumentValues);
+        } else {
+            try {
+                return this.callNode.call(virtualFrame, argumentValues);
+            } catch (TailCallException e) {
+                return e.call(virtualFrame);
+            }
+        }
     }
 
     private MumblerFunction evaluateFunction(VirtualFrame virtualFrame) {

graal/src/mumbler/truffle/node/call/TailCallException.java

@@ -0,0 +1,34 @@
+package mumbler.truffle.node.call;
+
+import com.oracle.truffle.api.frame.VirtualFrame;
+import com.oracle.truffle.api.nodes.ControlFlowException;
+import com.oracle.truffle.api.nodes.DirectCallNode;
+
+public class TailCallException extends ControlFlowException {
+    private static final long serialVersionUID = 1L;
+
+    private final DirectCallNode callNode;
+    private final Object[] arguments;
+    public boolean outOfFunction = false;
+
+    public TailCallException(DirectCallNode callNode, Object[] arguments) {
+        this.callNode = callNode;
+        this.arguments = arguments;
+    }
+
+    public Object call(VirtualFrame virtualFrame) {
+        TailCallException tailCall = null;
+        try {
+            return this.callNode.call(virtualFrame, this.arguments);
+        } catch (TailCallException e) {
+            tailCall = e;
+        }
+        do {
+            try {
+                return tailCall.callNode.call(virtualFrame, tailCall.arguments);
+            } catch (TailCallException e) {
+                tailCall = e;
+            }
+        } while (true);
+    }
+}

graal/src/mumbler/truffle/node/special/IfNode.java

@@ -31,6 +31,13 @@ public Object execute(VirtualFrame virtualFrame) {
         }
     }
 
+    @Override
+    public void setIsTail() {
+        super.setIsTail();
+        this.thenNode.setIsTail();
+        this.elseNode.setIsTail();
+    }
+
     private boolean testResult(VirtualFrame virtualFrame) {
         try {
             return this.testNode.executeBoolean(virtualFrame);