Forloop

benchmarks/wasm/for_loop.wat

@@ -0,0 +1,41 @@
+(module
+  (func $for_loop (result i32)
+    (local i32)
+    (local i32)
+
+    for
+       (
+        ;; init
+        i32.const 0
+        local.set 0
+        i32.const 0
+        local.set 1
+        |
+        ;; cond
+        local.get 1
+        i32.const 10
+        i32.gt_s
+        i32.eqz
+        |
+        ;; post
+        local.get 1
+        i32.const 1
+        i32.add
+        local.set 1
+        )
+
+        ;; es
+        local.get 0
+        local.get 1
+        i32.add
+        local.set 0
+
+     local.get 0
+
+
+     )
+
+     (export "for_loop" (func 0))
+
+  )
+

grammar/WatLexer.g4

@@ -59,6 +59,8 @@ UNREACHABLE: 'unreachable' ;
 DROP: 'drop' ;
 BLOCK: 'block' ;
 LOOP: 'loop' ;
+FOR : 'for';
+VBAR: '|';
 END: 'end' ;
 BR: 'br' ;
 BR_IF: 'br_if' ;

grammar/WatParser.g4

@@ -129,6 +129,11 @@ instr
   | blockInstr
   | foldedInstr
   | resumeInstr
+  | forLoop
+  ;
+
+forLoop
+  : 'for' '(' instrList '|' instrList '|' instrList ')' instrList
   ;
 
 plainInstr

src/main/java/wasm/WatParserBaseListener.java

@@ -240,6 +240,18 @@ public class WatParserBaseListener implements WatParserListener {
 	 * <p>The default implementation does nothing.</p>
 	 */
 	@Override public void exitInstr(WatParser.InstrContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterForLoop(WatParser.ForLoopContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitForLoop(WatParser.ForLoopContext ctx) { }
 	/**
 	 * {@inheritDoc}
 	 *

src/main/java/wasm/WatParserBaseVisitor.java

@@ -145,6 +145,13 @@ public class WatParserBaseVisitor<T> extends AbstractParseTreeVisitor<T> impleme
 	 * {@link #visitChildren} on {@code ctx}.</p>
 	 */
 	@Override public T visitInstr(WatParser.InstrContext ctx) { return visitChildren(ctx); }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation returns the result of calling
+	 * {@link #visitChildren} on {@code ctx}.</p>
+	 */
+	@Override public T visitForLoop(WatParser.ForLoopContext ctx) { return visitChildren(ctx); }
 	/**
 	 * {@inheritDoc}
 	 *

src/main/java/wasm/WatParserListener.java

@@ -197,6 +197,16 @@ public interface WatParserListener extends ParseTreeListener {
 	 * @param ctx the parse tree
 	 */
 	void exitInstr(WatParser.InstrContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link WatParser#forLoop}.
+	 * @param ctx the parse tree
+	 */
+	void enterForLoop(WatParser.ForLoopContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link WatParser#forLoop}.
+	 * @param ctx the parse tree
+	 */
+	void exitForLoop(WatParser.ForLoopContext ctx);
 	/**
 	 * Enter a parse tree produced by {@link WatParser#plainInstr}.
 	 * @param ctx the parse tree

src/main/java/wasm/WatParserVisitor.java

@@ -124,6 +124,12 @@ public interface WatParserVisitor<T> extends ParseTreeVisitor<T> {
 	 * @return the visitor result
 	 */
 	T visitInstr(WatParser.InstrContext ctx);
+	/**
+	 * Visit a parse tree produced by {@link WatParser#forLoop}.
+	 * @param ctx the parse tree
+	 * @return the visitor result
+	 */
+	T visitForLoop(WatParser.ForLoopContext ctx);
 	/**
 	 * Visit a parse tree produced by {@link WatParser#plainInstr}.
 	 * @param ctx the parse tree

src/main/scala/wasm/AST.scala

@@ -65,6 +65,7 @@ case class Select(ty: Option[List[ValueType]]) extends Instr
 case class Block(ty: BlockType, instrs: List[Instr]) extends Instr
 case class IdBlock(id: Int, ty: BlockType, instrs: List[Instr]) extends Instr
 case class Loop(ty: BlockType, instrs: List[Instr]) extends Instr
+case class ForLoop(init:List[Instr], cond: List[Instr], post: List[Instr], body: List[Instr]) extends Instr
 case class IdLoop(id: Int, ty: BlockType, instrs: List[Instr]) extends Instr
 case class If(ty: BlockType, thenInstrs: List[Instr], elseInstrs: List[Instr]) extends Instr
 case class IdIf(ty: BlockType, thenInstrs: IdBlock, elseInstrs: IdBlock) extends Instr

src/main/scala/wasm/MiniWasm.scala

@@ -282,9 +282,12 @@ case class Evaluator(module: ModuleInstance) {
                 trail: List[Cont[Ans]]): Ans = {
     if (insts.isEmpty) return kont(stack)
 
+
+
     val inst = insts.head
     val rest = insts.tail
 
+
     // println(s"inst: ${inst} \t | ${frame.locals} | ${stack.reverse}" )
 
     inst match {
@@ -383,6 +386,30 @@ case class Evaluator(module: ModuleInstance) {
         def loop(retStack: List[Value]): Ans =
           eval(inner, retStack.take(funcTy.inps.size), frame, restK, loop _ :: trail)
         loop(inputs)
+
+        case ForLoop(init, cond, post, body) =>
+        val restK: Cont[Ans] = retStack =>
+          eval(rest, retStack, frame, kont, trail)
+
+        def forloop(retStack: List[Value]): Ans = {
+
+          eval(cond, retStack, frame, {
+
+            case I32V(0) :: _ =>
+
+              restK(retStack)
+            case (_: I32V) :: _ =>
+              eval(body, retStack, frame, newStack => {
+                eval(post, newStack, frame, postStack => {
+                  forloop(postStack)
+                }, trail)
+              } , trail)
+            case _ =>
+              throw new RuntimeException("Condition did not return I32V as expected")
+          }, trail)
+        }
+          eval(init, stack, frame, forloop, trail)
+
       case If(ty, thn, els) =>
         val funcTy = getFuncType(ty)
         val I32V(cond) :: newStack = stack
@@ -437,7 +464,8 @@ case class Evaluator(module: ModuleInstance) {
         })
     }
     if (instrs.isEmpty) println("Warning: nothing is executed")
-    eval(instrs, List(), Frame(ArrayBuffer(I32V(0))), halt, List(halt))
+
+    eval(instrs, List(), Frame(ArrayBuffer(I32V(0),I32V(0))), halt, List(halt))
   }
 
   def evalTop(m: ModuleInstance): Unit = evalTop(stack => ())

src/main/scala/wasm/Parser.scala

@@ -84,6 +84,14 @@ class GSWasmVisitor extends WatParserBaseVisitor[WIR] {
   def toNumType(t: String): NumType = NumType(toNumKind(t))
 
   /* Overriding visitors */
+  override def visitForLoop(ctx:ForLoopContext): Instr = {
+    val InstrList(init) = visit(ctx.instrList(0))
+    val InstrList(cond) = visit(ctx.instrList(1))
+    val InstrList(post) = visit(ctx.instrList(2))
+    val InstrList(body) = visit(ctx.instrList(3))
+    ForLoop(init,cond,post,body)
+
+  }
 
   override def visitModule(ctx: ModuleContext): WIR = {
     if (ctx.module_() != null) return visit(ctx.module_())

src/test/scala/genwasym/TestEval.scala

@@ -36,6 +36,7 @@ class TestEval extends FunSuite {
     evaluator.evalTop(haltK, main)
   }
 
+
   // TODO: the power test can be used to test the stack
   // For now: 2^10 works, 2^100 results in 0 (TODO: why?),
   // and 2^1000 results in a stack overflow
@@ -74,6 +75,9 @@ class TestEval extends FunSuite {
   test("loop block - poly br") {
     testFile("./benchmarks/wasm/loop_poly.wat", None, ExpStack(List(2, 1)))
   }
+  test("for loop") {
+    testFile("./benchmarks/wasm/for_loop.wat", Some("for_loop"), ExpInt(55))
+  }
 
   // just for parsing
   test("fx types") {
@@ -90,4 +94,6 @@ class TestEval extends FunSuite {
   //test("tribonacci-ret") { testFile("./benchmarks/wasm/tribonacci_ret.wat", None, Some(504)) }
 
   // TODO: add wasm spec tests? How to utilize wast files?
+
 }
+