UvmInterpreterSpec.scala

package uvm.refimpl.itpr

import org.scalatest._
import java.io.FileReader
import uvm._
import uvm.types._
import uvm.ssavariables._
import uvm.refimpl._
import uvm.refimpl.itpr._
import uvm.refimpl.mem._
import MemoryOrder._
import AtomicRMWOptr._
import uvm.refimpl.mem.TypeSizes.Word
import uvm.refimpl.TrapHandlerResult.{ ThreadExit, Rebind }
import uvm.refimpl.HowToResume.{ PassValues, ThrowExc }

import ch.qos.logback.classic.Level._

class UvmInterpreterSpec extends UvmBundleTesterBase {

  setLogLevels(
    ROOT_LOGGER_NAME -> INFO,
    //"uvm.refimpl.mem.simpleimmix.SimpleImmixCollector$" -> DEBUG,
    "uvm.refimpl.itpr" -> DEBUG)

  override def makeMicroVM = new MicroVM(heapSize = 8L * 1024L * 1024L)

  preloadBundles("tests/uvm-refimpl-test/primitives.uir",
    "tests/uvm-refimpl-test/basic-tests.uir")

  "The constant pool" should "contain appropriate constant values" in {
    def gvb(name: String) = microVM.constantPool.getGlobalVarBox(microVM.globalBundle.globalVarNs(name))

    gvb("@TRUE").asUInt(1) shouldBe 1
    gvb("@FALSE").asUInt(1) shouldBe 0

    gvb("@I32_1").asUInt(32) shouldBe 1
    gvb("@I32_2").asUInt(32) shouldBe 2
    gvb("@I32_7").asUInt(32) shouldBe 7

    gvb("@I64_5").asUInt(64) shouldBe 5
  }

  "Binary operations" should "work on int<32>" in {
    val ctx = microVM.newContext()

    val func = ctx.func("@binops32")
    val arg0 = ctx.i32(42)
    val arg1 = ctx.i32(3)

    testFunc(ctx, func, Seq(arg0, arg1)) { (ctx, th, st, wp) =>
      val Seq(add, sub, mul, udiv, sdiv, urem, srem, shl, lshr, ashr, and, or, xor) = ctx.dumpKeepalives(st, 0)

      add.vb.asSInt(32) shouldEqual 45
      sub.vb.asSInt(32) shouldEqual 39
      mul.vb.asSInt(32) shouldEqual 126
      udiv.vb.asUInt(32) shouldEqual 14
      sdiv.vb.asSInt(32) shouldEqual 14
      urem.vb.asUInt(32) shouldEqual 0
      srem.vb.asSInt(32) shouldEqual 0
      shl.vb.asSInt(32) shouldEqual 336
      lshr.vb.asUInt(32) shouldEqual 5
      ashr.vb.asSInt(32) shouldEqual 5
      and.vb.asSInt(32) shouldEqual 2
      or.vb.asSInt(32) shouldEqual 43
      xor.vb.asSInt(32) shouldEqual 41

      Rebind(st, PassValues(Seq()))
    }

    val arg2 = ctx.handleFromInt(-100, 32)
    val arg3 = ctx.handleFromInt(6, 32)

    testFunc(ctx, func, Seq(arg2, arg3)) { (ctx, th, st, wp) =>
      val Seq(add, sub, mul, udiv, sdiv, urem, srem, shl, lshr, ashr, and, or, xor) = ctx.dumpKeepalives(st, 0)
      sdiv.vb.asSInt(32) shouldEqual -16
      srem.vb.asSInt(32) shouldEqual -4
      lshr.vb.asUInt(32) shouldEqual 67108862
      ashr.vb.asSInt(32) shouldEqual -2

      Rebind(st, PassValues(Seq()))
    }

    val arg4 = ctx.handleFromInt(42, 32)
    val arg5 = ctx.handleFromInt(-15, 32)

    testFunc(ctx, func, Seq(arg4, arg5)) { (ctx, th, st, wp) =>
      val Seq(add, sub, mul, udiv, sdiv, urem, srem, shl, lshr, ashr, and, or, xor) = ctx.dumpKeepalives(st, 0)
      sdiv.vb.asSInt(32) shouldEqual -2
      srem.vb.asSInt(32) shouldEqual 12

      Rebind(st, PassValues(Seq()))
    }

    ctx.closeContext()
  }

  "Binary operations" should "work on int<64>" in {
    val ctx = microVM.newContext()

    val func = ctx.func("@binops64")
    val arg0 = ctx.i64(42)
    val arg1 = ctx.i64(3)

    testFunc(ctx, func, Seq(arg0, arg1)) { (ctx, th, st, wp) =>
      val Seq(add, sub, mul, udiv, sdiv, urem, srem, shl, lshr, ashr, and, or, xor) = ctx.dumpKeepalives(st, 0)

      add.vb.asSInt(64) shouldEqual 45
      sub.vb.asSInt(64) shouldEqual 39
      mul.vb.asSInt(64) shouldEqual 126
      udiv.vb.asUInt(64) shouldEqual 14
      sdiv.vb.asSInt(64) shouldEqual 14
      urem.vb.asUInt(64) shouldEqual 0
      srem.vb.asSInt(64) shouldEqual 0
      shl.vb.asSInt(64) shouldEqual 336
      lshr.vb.asUInt(64) shouldEqual 5
      ashr.vb.asSInt(64) shouldEqual 5
      and.vb.asSInt(64) shouldEqual 2
      or.vb.asSInt(64) shouldEqual 43
      xor.vb.asSInt(64) shouldEqual 41

      Rebind(st, PassValues(Seq()))
    }

    val arg2 = ctx.i64(-0x8000000000000000L)
    val arg3 = ctx.i64(-1L)

    testFunc(ctx, func, Seq(arg2, arg3)) { (ctx, th, st, wp) =>
      val Seq(add, sub, mul, udiv, sdiv, urem, srem, shl, lshr, ashr, and, or, xor) = ctx.dumpKeepalives(st, 0)

      sdiv.vb.asSInt(64) shouldEqual -0x8000000000000000L
      srem.vb.asSInt(64) shouldEqual 0

      Rebind(st, PassValues(Seq()))
    }

    val arg4 = ctx.i64(13)
    val arg5 = ctx.i64(63)
    val arg6 = ctx.i64(64)
    val arg7 = ctx.i64(65)

    testFunc(ctx, func, Seq(arg4, arg5)) { (ctx, th, st, wp) =>
      val Seq(add, sub, mul, udiv, sdiv, urem, srem, shl, lshr, ashr, and, or, xor) = ctx.dumpKeepalives(st, 0)

      shl.vb.asUInt(64) shouldEqual BigInt("8000000000000000", 16)
      lshr.vb.asUInt(64) shouldEqual 0
      ashr.vb.asSInt(64) shouldEqual 0

      Rebind(st, PassValues(Seq()))
    }

    testFunc(ctx, func, Seq(arg4, arg6)) { (ctx, th, st, wp) =>
      val Seq(add, sub, mul, udiv, sdiv, urem, srem, shl, lshr, ashr, and, or, xor) = ctx.dumpKeepalives(st, 0)

      shl.vb.asUInt(64) shouldEqual 13
      lshr.vb.asUInt(64) shouldEqual 13
      ashr.vb.asSInt(64) shouldEqual 13

      Rebind(st, PassValues(Seq()))
    }

    testFunc(ctx, func, Seq(arg4, arg7)) { (ctx, th, st, wp) =>
      val Seq(add, sub, mul, udiv, sdiv, urem, srem, shl, lshr, ashr, and, or, xor) = ctx.dumpKeepalives(st, 0)

      shl.vb.asUInt(64) shouldEqual 26
      lshr.vb.asUInt(64) shouldEqual 6
      ashr.vb.asSInt(64) shouldEqual 6

      Rebind(st, PassValues(Seq()))
    }

    ctx.closeContext()
  }

  "Binary operations" should "safely handle integer division by zero" in {
    val ctx = microVM.newContext()

    val func = ctx.func("@binops64_div0")
    val a = ctx.i64(42)
    val one = ctx.i64(1)
    val zero = ctx.i64(0)

    testFunc(ctx, func, Seq(a, zero, one, one, one)) { (ctx, th, st, wp) =>
      nameOf(ctx.curInst(st, 0)) shouldBe "@binops64_div0.v1.exc.trapexc"
      Rebind(st, PassValues(Seq()))
    }
    testFunc(ctx, func, Seq(a, one, zero, one, one)) { (ctx, th, st, wp) =>
      nameOf(ctx.curInst(st, 0)) shouldBe "@binops64_div0.v1.exc.trapexc"
      Rebind(st, PassValues(Seq()))
    }
    testFunc(ctx, func, Seq(a, one, one, zero, one)) { (ctx, th, st, wp) =>
      nameOf(ctx.curInst(st, 0)) shouldBe "@binops64_div0.v1.exc.trapexc"
      Rebind(st, PassValues(Seq()))
    }
    testFunc(ctx, func, Seq(a, one, one, one, zero)) { (ctx, th, st, wp) =>
      nameOf(ctx.curInst(st, 0)) shouldBe "@binops64_div0.v1.exc.trapexc"
      Rebind(st, PassValues(Seq()))
    }

    ctx.closeContext()
  }

  "Binary operations" should "work on float" in {
    val ctx = microVM.newContext()

    val func = ctx.func("@binops_f")
    val arg0 = ctx.handleFromFloat(45.0f)
    val arg1 = ctx.handleFromFloat(4.0f)

    testFunc(ctx, func, Seq(arg0, arg1)) { (ctx, th, st, wp) =>
      val Seq(fadd, fsub, fmul, fdiv, frem) = ctx.dumpKeepalives(st, 0)

      fadd.vb.asFloat shouldEqual 49.0f
      fsub.vb.asFloat shouldEqual 41.0f
      fmul.vb.asFloat shouldEqual 180.0f
      fdiv.vb.asFloat shouldEqual 11.25f
      frem.vb.asFloat shouldEqual 1.0f

      Rebind(st, PassValues(Seq()))
    }

    val arg2 = ctx.handleFromFloat(Float.NaN)

    testFunc(ctx, func, Seq(arg0, arg2)) { (ctx, th, st, wp) =>
      val Seq(fadd, fsub, fmul, fdiv, frem) = ctx.dumpKeepalives(st, 0)

      fadd.vb.asFloat.isNaN shouldEqual true
      fsub.vb.asFloat.isNaN shouldEqual true
      fmul.vb.asFloat.isNaN shouldEqual true
      fdiv.vb.asFloat.isNaN shouldEqual true
      frem.vb.asFloat.isNaN shouldEqual true

      Rebind(st, PassValues(Seq()))
    }

    ctx.closeContext()
  }

  "Binary operations" should "work on double" in {
    val ctx = microVM.newContext()

    val func = ctx.func("@binops_d")
    val arg0 = ctx.handleFromDouble(45.0d)
    val arg1 = ctx.handleFromDouble(4.0d)

    testFunc(ctx, func, Seq(arg0, arg1)) { (ctx, th, st, wp) =>
      val Seq(fadd, fsub, fmul, fdiv, frem) = ctx.dumpKeepalives(st, 0)

      fadd.vb.asDouble shouldEqual 49.0d
      fsub.vb.asDouble shouldEqual 41.0d
      fmul.vb.asDouble shouldEqual 180.0d
      fdiv.vb.asDouble shouldEqual 11.25d
      frem.vb.asDouble shouldEqual 1.0d

      Rebind(st, PassValues(Seq()))
    }

    val arg2 = ctx.handleFromDouble(Double.NaN)

    testFunc(ctx, func, Seq(arg0, arg2)) { (ctx, th, st, wp) =>
      val Seq(fadd, fsub, fmul, fdiv, frem) = ctx.dumpKeepalives(st, 0)

      fadd.vb.asDouble.isNaN shouldEqual true
      fsub.vb.asDouble.isNaN shouldEqual true
      fmul.vb.asDouble.isNaN shouldEqual true
      fdiv.vb.asDouble.isNaN shouldEqual true
      frem.vb.asDouble.isNaN shouldEqual true

      Rebind(st, PassValues(Seq()))
    }

    ctx.closeContext()
  }

  "Binary operations" should "work on vector types" in {
    val ctx = microVM.newContext()

    val func = ctx.func("@binops_vec")

    val a0 = ctx.handleFromConst("@4xI32_V3")
    val a1 = ctx.handleFromConst("@4xI32_V4")
    val a2 = ctx.handleFromConst("@4xF_V3")
    val a3 = ctx.handleFromConst("@4xF_V4")
    val a4 = ctx.handleFromConst("@2xD_V3")
    val a5 = ctx.handleFromConst("@2xD_V4")

    testFunc(ctx, func, Seq(a0, a1, a2, a3, a4, a5)) { (ctx, th, st, wp) =>
      val Seq(addi, subi, addf, subf, addd, subd) = ctx.dumpKeepalives(st, 0)

      addi.vb.asVec.map(_.asSInt(32)) shouldEqual Seq(11, 22, 33, 44)
      subi.vb.asVec.map(_.asSInt(32)) shouldEqual Seq(-9, -18, -27, -36)
      addf.vb.asVec.map(_.asFloat) shouldEqual Seq(11.0f, 22.0f, 33.0f, 44.0f)
      subf.vb.asVec.map(_.asFloat) shouldEqual Seq(-9.0f, -18.0f, -27.0f, -36.0f)
      addd.vb.asVec.map(_.asDouble) shouldEqual Seq(11.0d, 22.0d)
      subd.vb.asVec.map(_.asDouble) shouldEqual Seq(-9.0d, -18.0d)

      Rebind(st, PassValues(Seq()))
    }

    ctx.closeContext()
  }

  "Comparing operations" should "work on int<64>" in {
    val ctx = microVM.newContext()

    val func = ctx.func("@cmp64")

    val a0 = ctx.i64(1)
    val a1 = ctx.i64(2)

    testFunc(ctx, func, Seq(a0, a1)) { (ctx, th, st, wp) =>
      val Seq(eq, ne, ult, ule, ugt, uge, slt, sle, sgt, sge) = ctx.dumpKeepalives(st, 0)

      eq.vb.asUInt(1) shouldEqual 0
      ne.vb.asUInt(1) shouldEqual 1
      ult.vb.asUInt(1) shouldEqual 1
      ule.vb.asUInt(1) shouldEqual 1
      ugt.vb.asUInt(1) shouldEqual 0
      uge.vb.asUInt(1) shouldEqual 0
      slt.vb.asUInt(1) shouldEqual 1
      sle.vb.asUInt(1) shouldEqual 1
      sgt.vb.asUInt(1) shouldEqual 0
      sge.vb.asUInt(1) shouldEqual 0

      Rebind(st, PassValues(Seq()))
    }

    testFunc(ctx, func, Seq(a0, a0)) { (ctx, th, st, wp) =>
      val Seq(eq, ne, ult, ule, ugt, uge, slt, sle, sgt, sge) = ctx.dumpKeepalives(st, 0)

      eq.vb.asUInt(1) shouldEqual 1
      ne.vb.asUInt(1) shouldEqual 0
      ult.vb.asUInt(1) shouldEqual 0
      ule.vb.asUInt(1) shouldEqual 1
      ugt.vb.asUInt(1) shouldEqual 0
      uge.vb.asUInt(1) shouldEqual 1
      slt.vb.asUInt(1) shouldEqual 0
      sle.vb.asUInt(1) shouldEqual 1
      sgt.vb.asUInt(1) shouldEqual 0
      sge.vb.asUInt(1) shouldEqual 1

      Rebind(st, PassValues(Seq()))
    }

    val a2 = ctx.i64(-3)

    testFunc(ctx, func, Seq(a0, a2)) { (ctx, th, st, wp) =>
      val Seq(eq, ne, ult, ule, ugt, uge, slt, sle, sgt, sge) = ctx.dumpKeepalives(st, 0)

      eq.vb.asUInt(1) shouldEqual 0
      ne.vb.asUInt(1) shouldEqual 1
      slt.vb.asUInt(1) shouldEqual 0
      sle.vb.asUInt(1) shouldEqual 0
      sgt.vb.asUInt(1) shouldEqual 1
      sge.vb.asUInt(1) shouldEqual 1

      Rebind(st, PassValues(Seq()))
    }

    ctx.closeContext()
  }

  "Comparing operations" should "work on float" in {
    val ctx = microVM.newContext()

    val func = ctx.func("@cmp_f")

    val a0 = ctx.handleFromFloat(1.0f)
    val a1 = ctx.handleFromFloat(2.0f)

    testFunc(ctx, func, Seq(a0, a1)) { (ctx, th, st, wp) =>
      val Seq(ftrue, ffalse, ford, foeq, fone, folt, fole, fogt, foge, funo, fueq, fune, fult, fule, fugt, fuge) = ctx.dumpKeepalives(st, 0)

      ftrue.vb.asUInt(1) shouldEqual 1
      ffalse.vb.asUInt(1) shouldEqual 0
      ford.vb.asUInt(1) shouldEqual 1
      foeq.vb.asUInt(1) shouldEqual 0
      fone.vb.asUInt(1) shouldEqual 1
      folt.vb.asUInt(1) shouldEqual 1
      fole.vb.asUInt(1) shouldEqual 1
      fogt.vb.asUInt(1) shouldEqual 0
      foge.vb.asUInt(1) shouldEqual 0
      funo.vb.asUInt(1) shouldEqual 0
      fueq.vb.asUInt(1) shouldEqual 0
      fune.vb.asUInt(1) shouldEqual 1
      fult.vb.asUInt(1) shouldEqual 1
      fule.vb.asUInt(1) shouldEqual 1
      fugt.vb.asUInt(1) shouldEqual 0
      fuge.vb.asUInt(1) shouldEqual 0

      Rebind(st, PassValues(Seq()))
    }

    testFunc(ctx, func, Seq(a0, a0)) { (ctx, th, st, wp) =>
      val Seq(ftrue, ffalse, ford, foeq, fone, folt, fole, fogt, foge, funo, fueq, fune, fult, fule, fugt, fuge) = ctx.dumpKeepalives(st, 0)

      ftrue.vb.asUInt(1) shouldEqual 1
      ffalse.vb.asUInt(1) shouldEqual 0
      ford.vb.asUInt(1) shouldEqual 1
      foeq.vb.asUInt(1) shouldEqual 1
      fone.vb.asUInt(1) shouldEqual 0
      folt.vb.asUInt(1) shouldEqual 0
      fole.vb.asUInt(1) shouldEqual 1
      fogt.vb.asUInt(1) shouldEqual 0
      foge.vb.asUInt(1) shouldEqual 1
      funo.vb.asUInt(1) shouldEqual 0
      fueq.vb.asUInt(1) shouldEqual 1
      fune.vb.asUInt(1) shouldEqual 0
      fult.vb.asUInt(1) shouldEqual 0
      fule.vb.asUInt(1) shouldEqual 1
      fugt.vb.asUInt(1) shouldEqual 0
      fuge.vb.asUInt(1) shouldEqual 1

      Rebind(st, PassValues(Seq()))
    }

    val a2 = ctx.handleFromFloat(Float.NaN)

    testFunc(ctx, func, Seq(a0, a2)) { (ctx, th, st, wp) =>
      val Seq(ftrue, ffalse, ford, foeq, fone, folt, fole, fogt, foge, funo, fueq, fune, fult, fule, fugt, fuge) = ctx.dumpKeepalives(st, 0)

      ftrue.vb.asUInt(1) shouldEqual 1
      ffalse.vb.asUInt(1) shouldEqual 0
      ford.vb.asUInt(1) shouldEqual 0
      foeq.vb.asUInt(1) shouldEqual 0
      fone.vb.asUInt(1) shouldEqual 0
      folt.vb.asUInt(1) shouldEqual 0
      fole.vb.asUInt(1) shouldEqual 0
      fogt.vb.asUInt(1) shouldEqual 0
      foge.vb.asUInt(1) shouldEqual 0
      funo.vb.asUInt(1) shouldEqual 1
      fueq.vb.asUInt(1) shouldEqual 1
      fune.vb.asUInt(1) shouldEqual 1
      fult.vb.asUInt(1) shouldEqual 1
      fule.vb.asUInt(1) shouldEqual 1
      fugt.vb.asUInt(1) shouldEqual 1
      fuge.vb.asUInt(1) shouldEqual 1

      Rebind(st, PassValues(Seq()))
    }
    ctx.closeContext()
  }

  "Comparing operations" should "work on double" in {
    val ctx = microVM.newContext()

    val func = ctx.func("@cmp_d")

    val a0 = ctx.handleFromDouble(1.0d)
    val a1 = ctx.handleFromDouble(2.0d)

    testFunc(ctx, func, Seq(a0, a1)) { (ctx, th, st, wp) =>
      val Seq(ftrue, ffalse, ford, foeq, fone, folt, fole, fogt, foge, funo, fueq, fune, fult, fule, fugt, fuge) = ctx.dumpKeepalives(st, 0)

      ftrue.vb.asUInt(1) shouldEqual 1
      ffalse.vb.asUInt(1) shouldEqual 0
      ford.vb.asUInt(1) shouldEqual 1
      foeq.vb.asUInt(1) shouldEqual 0
      fone.vb.asUInt(1) shouldEqual 1
      folt.vb.asUInt(1) shouldEqual 1
      fole.vb.asUInt(1) shouldEqual 1
      fogt.vb.asUInt(1) shouldEqual 0
      foge.vb.asUInt(1) shouldEqual 0
      funo.vb.asUInt(1) shouldEqual 0
      fueq.vb.asUInt(1) shouldEqual 0
      fune.vb.asUInt(1) shouldEqual 1
      fult.vb.asUInt(1) shouldEqual 1
      fule.vb.asUInt(1) shouldEqual 1
      fugt.vb.asUInt(1) shouldEqual 0
      fuge.vb.asUInt(1) shouldEqual 0

      Rebind(st, PassValues(Seq()))
    }

    testFunc(ctx, func, Seq(a0, a0)) { (ctx, th, st, wp) =>
      val Seq(ftrue, ffalse, ford, foeq, fone, folt, fole, fogt, foge, funo, fueq, fune, fult, fule, fugt, fuge) = ctx.dumpKeepalives(st, 0)

      ftrue.vb.asUInt(1) shouldEqual 1
      ffalse.vb.asUInt(1) shouldEqual 0
      ford.vb.asUInt(1) shouldEqual 1
      foeq.vb.asUInt(1) shouldEqual 1
      fone.vb.asUInt(1) shouldEqual 0
      folt.vb.asUInt(1) shouldEqual 0
      fole.vb.asUInt(1) shouldEqual 1
      fogt.vb.asUInt(1) shouldEqual 0
      foge.vb.asUInt(1) shouldEqual 1
      funo.vb.asUInt(1) shouldEqual 0
      fueq.vb.asUInt(1) shouldEqual 1
      fune.vb.asUInt(1) shouldEqual 0
      fult.vb.asUInt(1) shouldEqual 0
      fule.vb.asUInt(1) shouldEqual 1
      fugt.vb.asUInt(1) shouldEqual 0
      fuge.vb.asUInt(1) shouldEqual 1

      Rebind(st, PassValues(Seq()))
    }

    val a2 = ctx.handleFromDouble(Double.NaN)

    testFunc(ctx, func, Seq(a0, a2)) { (ctx, th, st, wp) =>
      val Seq(ftrue, ffalse, ford, foeq, fone, folt, fole, fogt, foge, funo, fueq, fune, fult, fule, fugt, fuge) = ctx.dumpKeepalives(st, 0)

      ftrue.vb.asUInt(1) shouldEqual 1
      ffalse.vb.asUInt(1) shouldEqual 0
      ford.vb.asUInt(1) shouldEqual 0
      foeq.vb.asUInt(1) shouldEqual 0
      fone.vb.asUInt(1) shouldEqual 0
      folt.vb.asUInt(1) shouldEqual 0
      fole.vb.asUInt(1) shouldEqual 0
      fogt.vb.asUInt(1) shouldEqual 0
      foge.vb.asUInt(1) shouldEqual 0
      funo.vb.asUInt(1) shouldEqual 1
      fueq.vb.asUInt(1) shouldEqual 1
      fune.vb.asUInt(1) shouldEqual 1
      fult.vb.asUInt(1) shouldEqual 1
      fule.vb.asUInt(1) shouldEqual 1
      fugt.vb.asUInt(1) shouldEqual 1
      fuge.vb.asUInt(1) shouldEqual 1

      Rebind(st, PassValues(Seq()))
    }
    ctx.closeContext()
  }

  "Comparing operations" should "work on vectors" in {
    val ctx = microVM.newContext()

    val func = ctx.func("@cmp_vec")

    val a0 = ctx.handleFromConst("@4xI32_V5")
    val a1 = ctx.handleFromConst("@4xI32_V6")
    val a2 = ctx.handleFromConst("@4xF_V5")
    val a3 = ctx.handleFromConst("@4xF_V6")
    val a4 = ctx.handleFromConst("@2xD_V5")
    val a5 = ctx.handleFromConst("@2xD_V6")

    testFunc(ctx, func, Seq(a0, a1, a2, a3, a4, a5)) { (ctx, th, st, wp) =>
      val Seq(eq, slt, foeqf, fultf, foeqd, fultd) = ctx.dumpKeepalives(st, 0)

      eq.vb.asVec.map(_.asUInt(1)) shouldEqual Seq(1, 0, 0, 1)
      slt.vb.asVec.map(_.asUInt(1)) shouldEqual Seq(0, 1, 0, 0)
      foeqf.vb.asVec.map(_.asUInt(1)) shouldEqual Seq(1, 0, 0, 1)
      fultf.vb.asVec.map(_.asUInt(1)) shouldEqual Seq(0, 1, 0, 0)
      foeqd.vb.asVec.map(_.asUInt(1)) shouldEqual Seq(0, 1)
      fultd.vb.asVec.map(_.asUInt(1)) shouldEqual Seq(1, 0)

      Rebind(st, PassValues(Seq()))
    }

    val a6 = ctx.handleFromConst("@4xF_V7")
    val a7 = ctx.handleFromConst("@2xD_V7")

    testFunc(ctx, func, Seq(a0, a1, a2, a6, a4, a7)) { (ctx, th, st, wp) =>
      val Seq(eq, slt, foeqf, fultf, foeqd, fultd) = ctx.dumpKeepalives(st, 0)

      foeqf.vb.asVec.map(_.asUInt(1)) shouldEqual Seq(0, 0, 0, 0)
      fultf.vb.asVec.map(_.asUInt(1)) shouldEqual Seq(1, 1, 1, 1)
      foeqd.vb.asVec.map(_.asUInt(1)) shouldEqual Seq(0, 0)
      fultd.vb.asVec.map(_.asUInt(1)) shouldEqual Seq(1, 1)

      Rebind(st, PassValues(Seq()))
    }
    ctx.closeContext()
  }

  "Comparing operations" should "work on general reference types" in {
    val ctx = microVM.newContext()

    val func = ctx.func("@cmp_ref")

    val a0 = ctx.newFixed("@i64")
    val a1 = ctx.newFixed("@i64")
    val a2 = ctx.handleFromGlobal("@dummy_global1")
    val a3 = ctx.handleFromGlobal("@dummy_global2")
    val a4 = ctx.func("@dummy_func1")
    val a5 = ctx.func("@dummy_func2")
    val a6 = ctx.newStack(a4)
    val a7 = ctx.newStack(a5)

    testFunc(ctx, func, Seq(a0, a0, a2, a2, a4, a4, a6, a6)) { (ctx, th, st, wp) =>
      val Seq(req, rne, ieq, ine, feq, fne, seq, sne) = ctx.dumpKeepalives(st, 0)

      req.vb.asUInt(1) shouldEqual 1
      rne.vb.asUInt(1) shouldEqual 0
      ieq.vb.asUInt(1) shouldEqual 1
      ine.vb.asUInt(1) shouldEqual 0
      feq.vb.asUInt(1) shouldEqual 1
      fne.vb.asUInt(1) shouldEqual 0
      seq.vb.asUInt(1) shouldEqual 1
      sne.vb.asUInt(1) shouldEqual 0

      Rebind(st, PassValues(Seq()))
    }

    testFunc(ctx, func, Seq(a0, a1, a2, a3, a4, a5, a6, a7)) { (ctx, th, st, wp) =>
      val Seq(req, rne, ieq, ine, feq, fne, seq, sne) = ctx.dumpKeepalives(st, 0)

      req.vb.asUInt(1) shouldEqual 0
      rne.vb.asUInt(1) shouldEqual 1
      ieq.vb.asUInt(1) shouldEqual 0
      ine.vb.asUInt(1) shouldEqual 1
      feq.vb.asUInt(1) shouldEqual 0
      fne.vb.asUInt(1) shouldEqual 1
      seq.vb.asUInt(1) shouldEqual 0
      sne.vb.asUInt(1) shouldEqual 1

      Rebind(st, PassValues(Seq()))
    }

    val nr = ctx.handleFromConst("@NULLREF_I64")
    val ni = ctx.handleFromConst("@NULLIREF_I64")
    val nf = ctx.handleFromConst("@NULLFUNC")
    val ns = ctx.handleFromConst("@NULLSTACK")

    testFunc(ctx, func, Seq(nr, nr, ni, ni, nf, nf, ns, ns)) { (ctx, th, st, wp) =>
      val Seq(req, rne, ieq, ine, feq, fne, seq, sne) = ctx.dumpKeepalives(st, 0)

      req.vb.asUInt(1) shouldEqual 1
      rne.vb.asUInt(1) shouldEqual 0
      ieq.vb.asUInt(1) shouldEqual 1
      ine.vb.asUInt(1) shouldEqual 0
      feq.vb.asUInt(1) shouldEqual 1
      fne.vb.asUInt(1) shouldEqual 0
      seq.vb.asUInt(1) shouldEqual 1
      sne.vb.asUInt(1) shouldEqual 0

      Rebind(st, PassValues(Seq()))
    }

    testFunc(ctx, func, Seq(a0, nr, a2, ni, a4, nf, a6, ns)) { (ctx, th, st, wp) =>
      val Seq(req, rne, ieq, ine, feq, fne, seq, sne) = ctx.dumpKeepalives(st, 0)

      req.vb.asUInt(1) shouldEqual 0
      rne.vb.asUInt(1) shouldEqual 1
      ieq.vb.asUInt(1) shouldEqual 0
      ine.vb.asUInt(1) shouldEqual 1
      feq.vb.asUInt(1) shouldEqual 0
      fne.vb.asUInt(1) shouldEqual 1
      seq.vb.asUInt(1) shouldEqual 0
      sne.vb.asUInt(1) shouldEqual 1

      Rebind(st, PassValues(Seq()))
    }

    ctx.closeContext()
  }

  "Conversions" should "work on scalar types" in {
    val ctx = microVM.newContext()

    val func = ctx.func("@conv")

    val a0 = ctx.i32(0xfedcba98L)
    val a1 = ctx.i64(0x123456789abcdef0L)
    val a2 = ctx.handleFromFloat(1.5f)
    val a3 = ctx.handleFromDouble(6.25d)

    testFunc(ctx, func, Seq(a0, a1, a2, a3)) { (ctx, th, st, wp) =>
      val kas = ctx.dumpKeepalives(st, 0)

      val Seq(trunc, zext, sext, fptrunc, fpext, fptoui1, fptosi1, fptoui2, fptosi2, uitofp, sitofp) = kas.take(11)
      val Seq(bitcast1, bitcast2, bitcast3, bitcast4, ptrcast1, ptrcast2, ptrcast3, ptrcast4, ptrcast5, ptrcast6) = kas.drop(11)

      trunc.vb.asUInt(32) shouldBe 0x9abcdef0L
      zext.vb.asUInt(64) shouldBe 0xfedcba98L
      sext.vb.asUInt(64) shouldBe BigInt("fffffffffedcba98", 16)

      fptrunc.vb.asFloat shouldBe 6.25f
      fpext.vb.asDouble shouldBe 1.5d

      fptoui1.vb.asSInt(64) shouldBe 6
      fptosi1.vb.asSInt(64) shouldBe 6
      fptoui2.vb.asSInt(32) shouldBe 1
      fptosi2.vb.asSInt(32) shouldBe 1
      uitofp.vb.asDouble shouldBe 0x123456789abcdef0L.doubleValue()
      sitofp.vb.asDouble shouldBe 0x123456789abcdef0L.doubleValue()

      bitcast1.vb.asSInt(32) shouldBe java.lang.Float.floatToRawIntBits(1.5f)
      bitcast2.vb.asSInt(64) shouldBe java.lang.Double.doubleToRawLongBits(6.25d)
      bitcast3.vb.asFloat shouldBe 1.5f
      bitcast4.vb.asDouble shouldBe 6.25d

      ptrcast1.vb.asPointer shouldBe 0x123456789abcdef0L
      ptrcast2.vb.asPointer shouldBe 0x123456789abcdef0L
      ptrcast3.vb.asSInt(64) shouldBe 0x123456789abcdef0L

      ptrcast4.vb.asSInt(64) shouldBe 0xdeadbeef13572468L
      ptrcast5.vb.asPointer shouldBe 0x55aa55aa5a5a5a5aL
      ptrcast6.vb.asInt shouldBe 0x13572468L

      Rebind(st, PassValues(Seq()))
    }
    val a5 = ctx.i64(-0x123456789abcdef0L)

    testFunc(ctx, func, Seq(a0, a5, a2, a3)) { (ctx, th, st, wp) =>
      val kas = ctx.dumpKeepalives(st, 0)

      val Seq(trunc, zext, sext, fptrunc, fpext, fptoui1, fptosi1, fptoui2, fptosi2, uitofp, sitofp) = kas.take(11)
      val Seq(bitcast1, bitcast2, bitcast3, bitcast4, ptrcast1, ptrcast2, ptrcast3, ptrcast4, ptrcast5, ptrcast6) = kas.drop(11)

      sitofp.vb.asDouble shouldBe (-0x123456789abcdef0L).doubleValue()

      ptrcast1.vb.asPointer shouldBe -0x123456789abcdef0L
      ptrcast2.vb.asPointer shouldBe -0x123456789abcdef0L
      ptrcast3.vb.asSInt(64) shouldBe -0x123456789abcdef0L

      Rebind(st, PassValues(Seq()))
    }

    ctx.closeContext()
  }

  "Conversions" should "work on vector types" in {
    val ctx = microVM.newContext()

    val func = ctx.func("@conv_vec")

    val a0 = ctx.handleFromConst("@4xI32_ABNORMALV1")
    val a1 = ctx.handleFromConst("@4xF_ABNORMALV1")
    val a2 = ctx.handleFromConst("@2xD_ABNORMALV1")

    testFunc(ctx, func, Seq(a0, a1, a2)) { (ctx, th, st, wp) =>
      val Seq(trunc, zext, sext, fptrunc, fpext) = ctx.dumpKeepalives(st, 0)

      trunc.vb.asVec.map(_.asUInt(16)) shouldBe Seq(0x5678L, 0xdef0L, 0xba98L, 0x3210L)
      zext.vb.asVec.map(_.asUInt(64)) shouldBe Seq(0x12345678L, 0x9abcdef0L, 0xfedcba98L, 0x76543210L)
      sext.vb.asVec.map(_.asUInt(64)) shouldBe Seq(0x12345678L, BigInt("ffffffff9abcdef0", 16), BigInt("fffffffffedcba98", 16), 0x76543210L)

      fptrunc.vb.asVec.map(_.asFloat) shouldBe Seq(1.0f, 1.5f)
      fpext.vb.asVec.map(_.asDouble) shouldBe Seq(1.0d, 1.5d, 2.0d, 2.5d)

      Rebind(st, PassValues(Seq()))
    }

    ctx.closeContext()
  }

  "The SELECT instruction" should "work on both scalars and vectors and allow per-element select" in {
    val ctx = microVM.newContext()

    val func = ctx.func("@select")

    testFunc(ctx, func, Seq()) { (ctx, th, st, wp) =>
      val Seq(sel1, sel2, sel3, sel4, sel5) = ctx.dumpKeepalives(st, 0)

      sel1.vb.asSInt(64) shouldBe 2
      sel2.vb.asSInt(64) shouldBe 3

      sel3.vb.asVec.map(_.asSInt(32)) shouldBe Seq(0, 5, 6, 3)

      sel4.vb.asVec.map(_.asSInt(32)) shouldBe Seq(0, 1, 2, 3)
      sel5.vb.asVec.map(_.asSInt(32)) shouldBe Seq(4, 5, 6, 7)

      Rebind(st, PassValues(Seq()))
    }

    ctx.closeContext()
  }

  "Branching" should "work" in {
    val ctx = microVM.newContext()

    val func = ctx.func("@branch")

    val a0 = ctx.i64(0)
    val a1 = ctx.i64(1)

    testFunc(ctx, func, Seq(a0)) { (ctx, th, st, wp) =>
      nameOf(ctx.curInst(st, 0)) shouldBe "@branch.v1.iftrue.traptrue"
      Rebind(st, PassValues(Seq()))
    }

    testFunc(ctx, func, Seq(a1)) { (ctx, th, st, wp) =>
      nameOf(ctx.curInst(st, 0)) shouldBe "@branch.v1.iffalse.trapfalse"
      Rebind(st, PassValues(Seq()))
    }

    ctx.closeContext()
  }

  "SWTICH" should "work" in {
    val ctx = microVM.newContext()

    val func = ctx.func("@switch")

    val a0 = ctx.i64(0)
    val a1 = ctx.i64(1)
    val a2 = ctx.i64(2)
    val a3 = ctx.i64(3)

    def expectFlow(midTrapName: String, phiValue: BigInt): TrapHandlerFunction = { (ctx, th, st, wp) =>
      val M = midTrapName
      nameOf(ctx.curInst(st, 0)) match {
        case M => {}
        case "@switch.v1.exit.trapend" => {
          val Seq(v) = ctx.dumpKeepalives(st, 0)
          v.vb.asSInt(64) shouldBe phiValue
        }
        case trapName => fail("Trap %s should not be reached. Should reach %s.".format(trapName))
      }
      Rebind(st, PassValues(Seq()))
    }

    testFunc(ctx, func, Seq(a0))(expectFlow("@switch.v1.def.trapdef", 4))
    testFunc(ctx, func, Seq(a1))(expectFlow("@switch.v1.one.trapone", 5))
    testFunc(ctx, func, Seq(a2))(expectFlow("@switch.v1.two.traptwo", 6))
    testFunc(ctx, func, Seq(a3))(expectFlow("@switch.v1.three.trapthree", 7))

    ctx.closeContext()
  }

  "Parameters of a basic block" should "be assigned at the same time in CFG edges" in {
    val ctx = microVM.newContext()

    val func = ctx.func("@edge_asgn_test")

    testFunc(ctx, func, Seq()) { (ctx, th, st, wp) =>
      val Seq(x, y) = ctx.dumpKeepalives(st, 0)

      ctx.handleToSInt(x.asInstanceOf[MuIntValue]) shouldEqual 2
      ctx.handleToSInt(y.asInstanceOf[MuIntValue]) shouldEqual 1

      Rebind(st, PassValues(Seq()))
    }

    ctx.closeContext()
  }

  "CALL and RET" should "work for normal returns" in {
    val ctx = microVM.newContext()

    val func = ctx.func("@call_ret")

    val a0 = ctx.i64(3)
    val a1 = ctx.i64(4)

    testFunc(ctx, func, Seq(a0, a1)) { (ctx, th, st, wp) =>
      val Seq(ss) = ctx.dumpKeepalives(st, 0)

      ss.vb.asInt shouldEqual 25

      Rebind(st, PassValues(Seq()))
    }
    ctx.closeContext()
  }

  "CALL, THROW and the exception parameter" should "handle exceptions" in {
    val ctx = microVM.newContext()

    val func = ctx.func("@call_throw")

    val a0 = ctx.i64(3)

    testFunc(ctx, func, Seq(a0)) { (ctx, th, st, wp) =>
      nameOf(ctx.curInst(st, 0)) match {
        case "@call_throw.v1.nor.trapnor" => {
          val Seq(rv) = ctx.dumpKeepalives(st, 0)
          rv.vb.asInt shouldEqual 3
        }
        case "@call_throw.v1.exctrapexc" => {
          fail("Should not receive exception")
        }
      }

      Rebind(st, PassValues(Seq()))
    }

    val a1 = ctx.i64(0)

    testFunc(ctx, func, Seq(a1)) { (ctx, th, st, wp) =>
      nameOf(ctx.curInst(st, 0)) match {
        case "@call_throw.v1.nor.trapnor" => {
          fail("Should not return normally")
        }
        case "@call_throw.v1.exc.trapexc" => {
          val Seq(theExc) = ctx.dumpKeepalives(st, 0)
          theExc.vb.asRef shouldEqual 0L
        }
      }

      Rebind(st, PassValues(Seq()))
    }
    ctx.closeContext()
  }

  "CALL" should "be able to receive multiple return values or no return values" in {
    val ctx = microVM.newContext()

    val func = ctx.func("@call_multi_return")

    var checkpointReached = false

    testFunc(ctx, func, Seq()) { (ctx, th, st, wp) =>
      nameOf(ctx.curInst(st, 0)) match {
        case "@checkpoint.v1.entry.trap" => {
          checkpointReached = true
        }
        case "@call_multi_return.v1.entry.trap" => {
          val Seq(a, b) = ctx.dumpKeepalives(st, 0)
          a.asSInt(64) shouldEqual 8
          b.asSInt(64) shouldEqual 7
          Rebind(st, PassValues(Seq()))
        }
      }

      Rebind(st, PassValues(Seq()))
    }

    checkpointReached shouldBe true

    ctx.closeContext()
  }

  "EXTRACTVALUE and INSERTVALUE" should "work" in {
    val ctx = microVM.newContext()

    val func = ctx.func("@aggregate_struct")

    testFunc(ctx, func, Seq()) { (ctx, th, st, wp) =>
      val Seq(f1, f12) = ctx.dumpKeepalives(st, 0)

      f1.vb.asSInt(64) shouldEqual 2
      f12.vb.asSInt(64) shouldEqual 7