From 78dddcd218b596e369a6953e630959f5e557de7f Mon Sep 17 00:00:00 2001 From: alexzerntev Date: Fri, 26 Jan 2024 23:19:49 +0200 Subject: [PATCH] format --- .../truffle/compiler/SnapiTruffleEmitter.java | 4 +- ...vokeWithNamesNode.java => InvokeNode.java} | 38 ++---------- .../ast/expressions/function/InvokeNodes.java | 62 +++++++++++++++++++ .../ast/expressions/function/LambdaNode.java | 9 ++- 4 files changed, 74 insertions(+), 39 deletions(-) rename snapi-truffle/src/main/java/raw/runtime/truffle/ast/expressions/function/{InvokeWithNamesNode.java => InvokeNode.java} (55%) create mode 100644 snapi-truffle/src/main/java/raw/runtime/truffle/ast/expressions/function/InvokeNodes.java diff --git a/snapi-truffle/src/main/java/raw/compiler/snapi/truffle/compiler/SnapiTruffleEmitter.java b/snapi-truffle/src/main/java/raw/compiler/snapi/truffle/compiler/SnapiTruffleEmitter.java index 76b1cdb92..b44f6f723 100644 --- a/snapi-truffle/src/main/java/raw/compiler/snapi/truffle/compiler/SnapiTruffleEmitter.java +++ b/snapi-truffle/src/main/java/raw/compiler/snapi/truffle/compiler/SnapiTruffleEmitter.java @@ -39,7 +39,7 @@ import raw.runtime.truffle.ast.expressions.binary.MultNodeGen; import raw.runtime.truffle.ast.expressions.binary.SubNodeGen; import raw.runtime.truffle.ast.expressions.function.ClosureNode; -import raw.runtime.truffle.ast.expressions.function.InvokeWithNamesNode; +import raw.runtime.truffle.ast.expressions.function.InvokeNode; import raw.runtime.truffle.ast.expressions.function.LambdaNode; import raw.runtime.truffle.ast.expressions.function.MethodNode; import raw.runtime.truffle.ast.expressions.literals.*; @@ -394,7 +394,7 @@ case FunApp fa when tipe(fa.f()) instanceof PackageEntryType -> { case FunApp fa -> { String[] argNames = JavaConverters.asJavaCollection(fa.args()).stream().map(a -> a.idn().isDefined() ? a.idn().get() : null).toArray(String[]::new); ExpressionNode[] exps = JavaConverters.asJavaCollection(fa.args()).stream().map(a -> recurseExp(a.e())).toArray(ExpressionNode[]::new); - yield new InvokeWithNamesNode(recurseExp(fa.f()), argNames, exps); + yield new InvokeNode(recurseExp(fa.f()), argNames, exps); } default -> throw new RawTruffleInternalErrorException("Unknown expression type"); }; diff --git a/snapi-truffle/src/main/java/raw/runtime/truffle/ast/expressions/function/InvokeWithNamesNode.java b/snapi-truffle/src/main/java/raw/runtime/truffle/ast/expressions/function/InvokeNode.java similarity index 55% rename from snapi-truffle/src/main/java/raw/runtime/truffle/ast/expressions/function/InvokeWithNamesNode.java rename to snapi-truffle/src/main/java/raw/runtime/truffle/ast/expressions/function/InvokeNode.java index 5ab427ff7..b91a12bad 100644 --- a/snapi-truffle/src/main/java/raw/runtime/truffle/ast/expressions/function/InvokeWithNamesNode.java +++ b/snapi-truffle/src/main/java/raw/runtime/truffle/ast/expressions/function/InvokeNode.java @@ -19,30 +19,13 @@ import com.oracle.truffle.api.nodes.ExplodeLoop; import com.oracle.truffle.api.nodes.NodeInfo; import raw.runtime.truffle.ExpressionNode; -import raw.runtime.truffle.runtime.function.FunctionExecuteNodes; -import raw.runtime.truffle.runtime.function.FunctionExecuteNodesFactory; -import raw.runtime.truffle.runtime.function.Lambda; @NodeInfo(shortName = "InvokeWithNames") -public final class InvokeWithNamesNode extends ExpressionNode { +public final class InvokeNode extends ExpressionNode { @Child private ExpressionNode functionNode; - @Child - private FunctionExecuteNodes.FunctionExecuteWithNames functionExecWithNames = - FunctionExecuteNodesFactory.FunctionExecuteWithNamesNodeGen.create(); - - @Child - private FunctionExecuteNodes.FunctionExecuteZero functionExecZero = - FunctionExecuteNodesFactory.FunctionExecuteZeroNodeGen.create(); - - @Child - private FunctionExecuteNodes.FunctionExecuteOne functionExecOne = - FunctionExecuteNodesFactory.FunctionExecuteOneNodeGen.create(); - - @Child - private FunctionExecuteNodes.FunctionExecuteTwo functionExecTwo = - FunctionExecuteNodesFactory.FunctionExecuteTwoNodeGen.create(); + @Child private InvokeNodes.Invoke invoke = InvokeNodesFactory.InvokeNodeGen.create(); @Children private final ExpressionNode[] argumentNodes; @@ -50,7 +33,7 @@ public final class InvokeWithNamesNode extends ExpressionNode { private final String[] argNames; - public InvokeWithNamesNode( + public InvokeNode( ExpressionNode functionNode, String[] argNames, ExpressionNode[] argumentNodes) { this.functionNode = functionNode; assert (argNames.length == argumentNodes.length); @@ -64,23 +47,10 @@ public InvokeWithNamesNode( public Object executeGeneric(VirtualFrame frame) { CompilerAsserts.compilationConstant(argumentNodes.length); Object function = functionNode.executeGeneric(frame); - if (function instanceof Lambda) { - if (argNames.length == 0) { - return functionExecZero.execute(this, function); - } else if (argNames.length == 1) { - return functionExecOne.execute(this, function, argumentNodes[0].executeGeneric(frame)); - } else if (argNames.length == 2) { - return functionExecTwo.execute( - this, - function, - argumentNodes[0].executeGeneric(frame), - argumentNodes[1].executeGeneric(frame)); - } - } for (int i = 0; i < argumentNodes.length; i++) { argumentValues[i] = argumentNodes[i].executeGeneric(frame); } - return functionExecWithNames.execute(this, function, argNames, argumentValues); + return invoke.execute(this, function, argNames, argumentValues); } @Override diff --git a/snapi-truffle/src/main/java/raw/runtime/truffle/ast/expressions/function/InvokeNodes.java b/snapi-truffle/src/main/java/raw/runtime/truffle/ast/expressions/function/InvokeNodes.java new file mode 100644 index 000000000..31097a698 --- /dev/null +++ b/snapi-truffle/src/main/java/raw/runtime/truffle/ast/expressions/function/InvokeNodes.java @@ -0,0 +1,62 @@ +package raw.runtime.truffle.ast.expressions.function; + +import com.oracle.truffle.api.dsl.*; +import com.oracle.truffle.api.nodes.Node; +import com.oracle.truffle.api.nodes.NodeInfo; +import raw.runtime.truffle.runtime.function.FunctionExecuteNodes; +import raw.runtime.truffle.runtime.function.Lambda; + +public class InvokeNodes { + @NodeInfo(shortName = "Invoke") + @GenerateUncached + @GenerateInline + public abstract static class Invoke extends Node { + + public abstract Object execute( + Node node, Object function, String[] argNames, Object[] argumentValues); + + @Specialization(guards = "argumentValues.length == 0") + static Object execZero( + Node node, + Lambda function, + String[] argNames, + Object[] argumentValues, + @Bind("$node") Node thisNode, + @Cached Lambda.LambdaExecuteZeroNode functionExecZero) { + return functionExecZero.execute(thisNode, function); + } + + @Specialization(guards = "argumentValues.length == 1") + static Object execOne( + Node node, + Lambda function, + String[] argNames, + Object[] argumentValues, + @Bind("$node") Node thisNode, + @Cached Lambda.LambdaExecuteOneNode functionExecOne) { + return functionExecOne.execute(thisNode, function, argumentValues[0]); + } + + @Specialization(guards = "argumentValues.length == 1") + static Object execTwo( + Node node, + Lambda function, + String[] argNames, + Object[] argumentValues, + @Bind("$node") Node thisNode, + @Cached Lambda.LambdaExecuteTwoNode functionExecOne) { + return functionExecOne.execute(thisNode, function, argumentValues[0], argumentValues[1]); + } + + @Specialization + static Object execTwo( + Node node, + Object function, + String[] argNames, + Object[] argumentValues, + @Bind("$node") Node thisNode, + @Cached FunctionExecuteNodes.FunctionExecuteWithNames functionExecOne) { + return functionExecOne.execute(thisNode, function, argNames, argumentValues); + } + } +} diff --git a/snapi-truffle/src/main/java/raw/runtime/truffle/ast/expressions/function/LambdaNode.java b/snapi-truffle/src/main/java/raw/runtime/truffle/ast/expressions/function/LambdaNode.java index 0d50060a3..23d29ad39 100644 --- a/snapi-truffle/src/main/java/raw/runtime/truffle/ast/expressions/function/LambdaNode.java +++ b/snapi-truffle/src/main/java/raw/runtime/truffle/ast/expressions/function/LambdaNode.java @@ -9,8 +9,8 @@ import raw.runtime.truffle.runtime.function.Lambda; public class LambdaNode extends ExpressionNode { - - @CompilerDirectives.CompilationFinal private final RootCallTarget callTarget; + private final RootCallTarget callTarget; + @CompilerDirectives.CompilationFinal private Lambda lambda; public LambdaNode(Function f) { callTarget = f.getCallTarget(); @@ -19,6 +19,9 @@ public LambdaNode(Function f) { @Override @ExplodeLoop public Object executeGeneric(VirtualFrame virtualFrame) { - return new Lambda(callTarget, virtualFrame); + if (lambda == null) { + lambda = new Lambda(callTarget, virtualFrame); + } + return lambda; } }