add simple interpreter functions

asl_xdsl/interpreters/asl.py

@@ -0,0 +1,40 @@
+from typing import Any
+
+from xdsl.interpreter import (
+    Interpreter,
+    InterpreterFunctions,
+    PythonValues,
+    ReturnedValues,
+    TerminatorValue,
+    impl,
+    impl_callable,
+    impl_terminator,
+    register_impls,
+)
+
+from asl_xdsl.dialects import asl
+
+
+@register_impls
+class ASLFunctions(InterpreterFunctions):
+    @impl_terminator(asl.ReturnOp)
+    def run_return(
+        self, interpreter: Interpreter, op: asl.ReturnOp, args: tuple[Any, ...]
+    ) -> tuple[TerminatorValue, PythonValues]:
+        return ReturnedValues(args), ()
+
+    @impl_callable(asl.FuncOp)
+    def call_func(
+        self, interpreter: Interpreter, op: asl.FuncOp, args: tuple[Any, ...]
+    ):
+        if (first_block := op.body.blocks.first) is None or not first_block.ops:
+            return interpreter.call_external(op.sym_name.data, op, args)
+        else:
+            return interpreter.run_ssacfg_region(op.body, args, op.sym_name.data)
+
+    @impl(asl.ConstantIntOp)
+    def run_constant(
+        self, interpreter: Interpreter, op: asl.ConstantIntOp, args: PythonValues
+    ) -> PythonValues:
+        value = op.value
+        return (value.data,)

asl_xdsl/tools/asl_opt.py

@@ -1,6 +1,8 @@
 from typing import IO
 
+from xdsl.dialects.builtin import ModuleOp
 from xdsl.parser import Input
+from xdsl.traits import CallableOpInterface
 from xdsl.xdsl_opt_main import xDSLOptMain
 
 from asl_xdsl.dialects.asl import ASLDialect
@@ -16,7 +18,31 @@ def register_all_passes(self):
         return super().register_all_passes()
 
     def register_all_targets(self):
-        return super().register_all_targets()
+        super().register_all_targets()
+
+        def interpret_target(module: ModuleOp, output: IO[str]):
+            from xdsl.interpreter import Interpreter
+
+            from asl_xdsl.interpreters.asl import ASLFunctions
+
+            interpreter = Interpreter(module, file=output)
+            interpreter.register_implementations(ASLFunctions())
+            op = interpreter.get_op_for_symbol("main")
+            trait = op.get_trait(CallableOpInterface)
+            assert trait is not None
+
+            result = interpreter.call_op(op)
+            if result:
+                if len(result) == 1:
+                    print(f"result: {result[0]}", file=output)
+                else:
+                    print("result: (", file=output)
+                    print(",\n".join(f"    {res}" for res in result), file=output)
+                    print(")", file=output)
+            else:
+                print("result: ()", file=output)
+
+        self.available_targets["exec"] = interpret_target
 
     def register_all_frontends(self):
         super().register_all_frontends()

tests/filecheck/exec/exec_simple.asl

@@ -0,0 +1,8 @@
+// RUN: asl-opt --t exec %s | filecheck %s
+
+func main() => integer
+begin
+    return 42;
+end;
+
+// CHECK: result: 42