refactor module out of frame

Author: Guannan Wei

src/main/scala/wasm/MiniWasm.scala

@@ -11,11 +11,12 @@ import Console.{GREEN, RED, RESET, YELLOW_B, UNDERLINED}
 case class Trap() extends Exception
 
 case class ModuleInstance(
-    types: List[FuncType],
-    funcs: HashMap[Int, WIR],
-    memory: List[RTMemory] = List(RTMemory()),
-    globals: List[RTGlobal] = List(),
-    exports: List[Export] = List()
+  defs: List[Definition],
+  types: List[FuncType],
+  funcs: HashMap[Int, WIR],
+  memory: List[RTMemory] = List(RTMemory()),
+  globals: List[RTGlobal] = List(),
+  exports: List[Export] = List()
 )
 
 object ModuleInstance {
@@ -52,7 +53,7 @@ object ModuleInstance {
       })
       .toList
 
-    ModuleInstance(types, module.funcEnv, memory, globals, exports)
+    ModuleInstance(module.definitions, types, module.funcEnv, memory, globals, exports)
   }
 }
 
@@ -199,8 +200,8 @@ object Primtives {
       }
   }
 
-  def memOutOfBound(frame: Frame, memoryIndex: Int, offset: Int, size: Int) = {
-    val memory = frame.module.memory(memoryIndex)
+  def memOutOfBound(module: ModuleInstance, memoryIndex: Int, offset: Int, size: Int) = {
+    val memory = module.memory(memoryIndex)
     offset + size > memory.size
   }
 
@@ -217,22 +218,21 @@ object Primtives {
   }
 }
 
-case class Frame(module: ModuleInstance, locals: ArrayBuffer[Value])
+case class Frame(locals: ArrayBuffer[Value])
 
-object Evaluator {
+case class Evaluator(module: ModuleInstance) {
   import Primtives._
 
   type Cont[A] = List[Value] => A
 
-  def getFuncType(module: ModuleInstance, ty: BlockType): FuncType = {
+  def getFuncType(ty: BlockType): FuncType =
     ty match {
       case VarBlockType(_, None) =>
         ??? // TODO: fill this branch until we handle type index correctly
       case VarBlockType(_, Some(tipe)) => tipe
       case ValBlockType(Some(tipe))    => FuncType(List(), List(), List(tipe))
       case ValBlockType(None)          => FuncType(List(), List(), List())
     }
-  }
 
   def evalCall[Ans](rest: List[Instr],
                     stack: List[Value],
@@ -241,12 +241,12 @@ object Evaluator {
                     trail: List[Cont[Ans]],
                     funcIndex: Int,
                     isTail: Boolean): Ans = {
-    frame.module.funcs(funcIndex) match {
+    module.funcs(funcIndex) match {
       case FuncDef(_, FuncBodyDef(ty, _, locals, body)) =>
         val args = stack.take(ty.inps.size).reverse
         val newStack = stack.drop(ty.inps.size)
         val frameLocals = args ++ locals.map(zero(_))
-        val newFrame = Frame(frame.module, ArrayBuffer(frameLocals: _*))
+        val newFrame = Frame(ArrayBuffer(frameLocals: _*))
         if (isTail)
           // when tail call, share the continuation for returning with the callee
           eval(body, List(), newFrame, kont, List(kont))
@@ -296,21 +296,21 @@ object Evaluator {
         frame.locals(i) = value
         eval(rest, stack, frame, kont, trail)
       case GlobalGet(i) =>
-        eval(rest, frame.module.globals(i).value :: stack, frame, kont, trail)
+        eval(rest, module.globals(i).value :: stack, frame, kont, trail)
       case GlobalSet(i) =>
         val value :: newStack = stack
-        frame.module.globals(i).ty match {
+        module.globals(i).ty match {
           case GlobalType(tipe, true) if value.tipe == tipe =>
-            frame.module.globals(i).value = value
+            module.globals(i).value = value
           case GlobalType(_, true) => throw new Exception("Invalid type")
           case _                   => throw new Exception("Cannot set immutable global")
         }
         eval(rest, newStack, frame, kont, trail)
       case MemorySize =>
-        eval(rest, I32V(frame.module.memory.head.size) :: stack, frame, kont, trail)
+        eval(rest, I32V(module.memory.head.size) :: stack, frame, kont, trail)
       case MemoryGrow =>
         val I32V(delta) :: newStack = stack
-        val mem = frame.module.memory.head
+        val mem = module.memory.head
         val oldSize = mem.size
         mem.grow(delta) match {
           case Some(e) =>
@@ -320,18 +320,18 @@ object Evaluator {
         }
       case MemoryFill =>
         val I32V(value) :: I32V(offset) :: I32V(size) :: newStack = stack
-        if (memOutOfBound(frame, 0, offset, size))
+        if (memOutOfBound(module, 0, offset, size))
           throw new Exception("Out of bounds memory access") // GW: turn this into a `trap`?
         else {
-          frame.module.memory.head.fill(offset, size, value.toByte)
+          module.memory.head.fill(offset, size, value.toByte)
           eval(rest, newStack, frame, kont, trail)
         }
       case MemoryCopy =>
         val I32V(n) :: I32V(src) :: I32V(dest) :: newStack = stack
-        if (memOutOfBound(frame, 0, src, n) || memOutOfBound(frame, 0, dest, n))
+        if (memOutOfBound(module, 0, src, n) || memOutOfBound(module, 0, dest, n))
           throw new Exception("Out of bounds memory access")
         else {
-          frame.module.memory.head.copy(dest, src, n)
+          module.memory.head.copy(dest, src, n)
           eval(rest, newStack, frame, kont, trail)
         }
       case Const(n) => eval(rest, n :: stack, frame, kont, trail)
@@ -349,17 +349,17 @@ object Evaluator {
         eval(rest, evalTestOp(op, v) :: newStack, frame, kont, trail)
       case Store(StoreOp(align, offset, ty, None)) =>
         val I32V(v) :: I32V(addr) :: newStack = stack
-        frame.module.memory(0).storeInt(addr + offset, v)
+        module.memory(0).storeInt(addr + offset, v)
         eval(rest, newStack, frame, kont, trail)
       case Load(LoadOp(align, offset, ty, None, None)) =>
         val I32V(addr) :: newStack = stack
-        val value = frame.module.memory(0).loadInt(addr + offset)
+        val value = module.memory(0).loadInt(addr + offset)
         eval(rest, I32V(value) :: newStack, frame, kont, trail)
       case Nop =>
         eval(rest, stack, frame, kont, trail)
       case Unreachable => throw Trap()
       case Block(ty, inner) =>
-        val funcTy = getFuncType(frame.module, ty)
+        val funcTy = getFuncType(ty)
         val (inputs, restStack) = stack.splitAt(funcTy.inps.size)
         val restK: Cont[Ans] = (retStack) =>
           eval(rest, retStack.take(funcTy.out.size) ++ restStack, frame, kont, trail)
@@ -368,15 +368,15 @@ object Evaluator {
         // We construct two continuations, one for the break (to the begining of the loop),
         // and one for fall-through to the next instruction following the syntactic structure
         // of the program.
-        val funcTy = getFuncType(frame.module, ty)
+        val funcTy = getFuncType(ty)
         val (inputs, restStack) = stack.splitAt(funcTy.inps.size)
         val restK: Cont[Ans] = (retStack) =>
           eval(rest, retStack.take(funcTy.out.size) ++ restStack, frame, kont, trail)
         def loop(retStack: List[Value]): Ans =
           eval(inner, retStack.take(funcTy.inps.size), frame, restK, loop _ :: trail)
         loop(inputs)
       case If(ty, thn, els) =>
-        val funcTy = getFuncType(frame.module, ty)
+        val funcTy = getFuncType(ty)
         val I32V(cond) :: newStack = stack
         val inner = if (cond != 0) thn else els
         val (inputs, restStack) = newStack.splitAt(funcTy.inps.size)
@@ -422,38 +422,33 @@ object Evaluator {
 
   // If `main` is given, then we use that function as the entry point of the program;
   // otherwise, we look up the top-level `start` instruction to locate the entry point.
-  def evalTop[Ans](module: Module, halt: Cont[Ans], main: Option[String] = None): Ans = {
+  def evalTop[Ans](halt: Cont[Ans], main: Option[String] = None): Ans = {
     val instrs = main match {
       case Some(func_name) =>
-        module.definitions.flatMap({
+        module.defs.flatMap({
           case Export(`func_name`, ExportFunc(fid)) =>
             println(s"Entering function $main")
-            module.funcEnv(fid) match {
+            module.funcs(fid) match {
               case FuncDef(_, FuncBodyDef(_, _, _, body)) => body
-              case _ =>
-                throw new Exception("Entry function has no concrete body")
+              case _ => throw new Exception("Entry function has no concrete body")
             }
           case _ => List()
         })
       case None =>
-        module.definitions.flatMap({
+        module.defs.flatMap({
           case Start(id) =>
             println(s"Entering unnamed function $id")
-            module.funcEnv(id) match {
+            module.funcs(id) match {
               case FuncDef(_, FuncBodyDef(_, _, _, body)) => body
               case _ =>
                 throw new Exception("Entry function has no concrete body")
             }
           case _ => List()
         })
     }
-
     if (instrs.isEmpty) println("Warning: nothing is executed")
-
-    val moduleInst = ModuleInstance(module)
-
-    Evaluator.eval(instrs, List(), Frame(moduleInst, ArrayBuffer(I32V(0))), halt, List(halt))
+    eval(instrs, List(), Frame(ArrayBuffer(I32V(0))), halt, List(halt))
   }
 
-  def evalTop(m: Module): Unit = evalTop(m, stack => ())
+  def evalTop(m: ModuleInstance): Unit = evalTop(stack => ())
 }

src/main/scala/wasm/MiniWasmScript.scala

@@ -10,7 +10,7 @@ sealed class ScriptRunner {
 
   def getInstance(instName: Option[String]): ModuleInstance = {
     instName match {
-	  case Some(name) => instanceMap(name)
+	    case Some(name) => instanceMap(name)
       case None => instances.head
     }
   }
@@ -28,7 +28,8 @@ sealed class ScriptRunner {
           case FuncDef(_, FuncBodyDef(ty, _, locals, body)) => body
         }
         val k = (retStack: List[Value]) => retStack
-        val actual = Evaluator.eval(instrs, List(), Frame(module, ArrayBuffer(args: _*)), k, List(k))
+        val evaluator = Evaluator(module)
+        val actual = evaluator.eval(instrs, List(), Frame(ArrayBuffer(args: _*)), k, List(k))
         assert(actual == expect)
     }
   }

src/test/scala/genwasym/TestEval.scala

@@ -24,15 +24,16 @@ class TestEval extends FunSuite {
   def testFile(filename: String, main: Option[String] = None, expected: ExpResult = Ignore) = {
     val module = Parser.parseFile(filename)
     //println(module)
-    val haltK: Evaluator.Cont[Unit] = stack => {
+    val evaluator = Evaluator(ModuleInstance(module))
+    val haltK: evaluator.Cont[Unit] = stack => {
       println(s"halt cont: $stack")
       expected match {
         case ExpInt(e) => assert(stack(0) == I32V(e))
         case ExpStack(e) => assert(stack == e)
         case Ignore    => ()
       }
     }
-    Evaluator.evalTop(module, haltK, main)
+    evaluator.evalTop(haltK, main)
   }
 
   // TODO: the power test can be used to test the stack
@@ -79,7 +80,7 @@ class TestEval extends FunSuite {
     testFile("./benchmarks/wasm/wasmfx/cont1-stripped.wat")
   }
 
-  // can parse this file, 
+  // can parse this file,
   // but there's no support for ref.func, cont.new, suspend, resume to run it yet
   // test("gen") {
   //   testFile("./benchmarks/wasm/wasmfx/gen-stripped.wat")