a test entry that compile btree cases

Author: butterunderflow

src/main/scala/wasm/StagedConcolicMiniWasm.scala

@@ -152,6 +152,21 @@ trait StagedWasmEvaluator extends SAIOps {
     ()
   }
 
+  def evalSymbolic(ty: ValueType,
+                   rest: List[Instr],
+                   kont: Context => Rep[Cont[Unit]],
+                   mkont: Rep[MCont[Unit]],
+                   trail: Trail[Unit])(implicit ctx: Context) = {
+      Stack.popC(ty)
+      val id = Stack.popS(ty)
+      val symVal = id.makeSymbolic(ty)
+      val num = SymEnv.read(symVal.s)
+      Stack.pushC(StagedConcreteNum(ty, num))
+      Stack.pushS(symVal)
+      val newCtx = ctx.pop()._2.push(ty)
+      eval(rest, kont, mkont, trail)(newCtx)
+  }
+
   def eval(insts: List[Instr],
            kont: Context => Rep[Cont[Unit]],
            mkont: Rep[MCont[Unit]],
@@ -174,15 +189,7 @@ trait StagedWasmEvaluator extends SAIOps {
         Stack.pushS(toStagedSymbolicNum(num))
         val newCtx = ctx.push(num.tipe(module))
         eval(rest, kont, mkont, trail)(newCtx)
-      case Symbolic(ty) =>
-        Stack.popC(ty)
-        val id = Stack.popS(ty)
-        val symVal = id.makeSymbolic(ty)
-        val num = SymEnv.read(symVal.s)
-        Stack.pushC(StagedConcreteNum(ty, num))
-        Stack.pushS(symVal)
-        val newCtx = ctx.pop()._2.push(ty)
-        eval(rest, kont, mkont, trail)(newCtx)
+      case Symbolic(ty) => evalSymbolic(ty, rest, kont, mkont, trail)(ctx)
       case LocalGet(i) =>
         Stack.pushC(Frames.getC(i))
         Stack.pushS(Frames.getS(i))
@@ -530,7 +537,15 @@ trait StagedWasmEvaluator extends SAIOps {
         val s = Stack.popS(ty)
         runtimeAssert(v.toInt != 0)
         eval(rest, kont, mkont, trail)(newCtx)
-      case Import(_, _, _) => throw new Exception(s"Unknown import at $funcIndex")
+      case Import("i32", "symbolic", _) =>
+        evalSymbolic(NumType(I32Type), rest, kont, mkont, trail)(ctx)
+      case Import("i32", "sym_assume", _) =>
+        // TODO: implement sym_assume
+        eval(rest, kont, mkont, trail)(ctx.pop()._2)
+      case Import("i32", "sym_assert", _) =>
+        // TODO: implement sym_assert
+        eval(rest, kont, mkont, trail)(ctx.pop()._2)
+      case Import(m, f, _) => throw new Exception(s"Unknown import $m.$f at $funcIndex")
       case _               => throw new Exception(s"Definition at $funcIndex is not callable")
     }
   }

src/test/scala/genwasym/TestBenchmarkBtree.scala

@@ -0,0 +1,63 @@
+package gensym.wasm
+
+import org.scalatest.FunSuite
+
+import lms.core.stub.Adapter
+
+import gensym.wasm.miniwasm.{ModuleInstance}
+import gensym.wasm.parser._
+import gensym.wasm.stagedconcolicminiwasm._
+
+// This 'test file' is not intended to test functionality, but to generate compiled code for btree benchmarks
+class TestBenchmarkBtree extends FunSuite {
+  def compileToCpp(filename: String,
+                   main: Option[String] = None) = {
+    import sys.process._
+
+    println(s"Compiling $filename to C++")
+    val moduleInst = ModuleInstance(Parser.parseFile(filename))
+    val cppFile = s"$filename.cpp"
+    val generated = WasmToCppCompiler.compile(moduleInst, main, false)
+
+    val code = generated.source
+    val writer = new java.io.PrintWriter(new java.io.File(cppFile))
+    try {
+      writer.write(code)
+    } finally {
+      writer.close()
+    }
+  }
+
+  def compileDirToCpp(dir: String,
+                      main: Option[String] = None) = {
+    import java.io.File
+    val d = new File(dir)
+    d.listFiles().filter(_.getName.endsWith(".wat")).foreach { file =>
+      compileToCpp(file.getAbsolutePath, main)
+    }
+  }
+
+  // only test concrete execution and its result
+  def testFileConcreteCpp(filename: String, main: Option[String] = None, expect: Option[List[Float]] = None) = {
+    val moduleInst = ModuleInstance(Parser.parseFile(filename))
+    val cppFile = s"$filename.cpp"
+    val exe = s"$cppFile.exe"
+    WasmToCppCompiler.compileToExe(moduleInst, main, cppFile, exe, true, optimizeLevel=0, "NO_INFO", "RUN_ONCE", "USE_IMM")
+
+    import sys.process._
+    val result = s"./$exe".!!
+    println(result)
+
+    expect.map(vs => {
+      val stackValues = result
+        .split("Stack contents: \n")(1)
+        .split("\n")
+        .map(_.toFloat)
+        .toList
+      assert(vs == stackValues)
+    })
+  }
+
+  test("compile-btree-benchmarks") { compileDirToCpp("./benchmarks/pldi2026/btree/", Some("main")) }
+
+}