Basil 138 program generator

src/main/scala/Main.scala

@@ -43,6 +43,7 @@ object Main {
   )
 
   def main(args: Array[String]): Unit = {
+
     val parser = ParserForClass[Config]
     val parsed = parser.constructEither(args.toSeq)
 

src/main/scala/ir/Interpreter.scala

@@ -70,23 +70,23 @@ class Interpreter() {
           case BVSHL    => smt_bvshl(left, right)
           case BVLSHR   => smt_bvlshr(left, right)
           case BVULT    => smt_bvult(left, right)
-          case BVNAND   => ???
-          case BVNOR    => ???
-          case BVXOR    => ???
-          case BVXNOR   => ???
+          case BVNAND   => smt_bvnand(left, right)
+          case BVNOR    => smt_bvnor(left, right)
+          case BVXOR    => smt_bvxor(left, right)
+          case BVXNOR   => smt_bvxnor(left, right)
           case BVCOMP   => smt_bvcomp(left, right)
           case BVSUB    => smt_bvsub(left, right)
           case BVSDIV   => smt_bvsdiv(left, right)
           case BVSREM   => smt_bvsrem(left, right)
-          case BVSMOD   => ???
+          case BVSMOD   => smt_bvsmod(left, right)
           case BVASHR   => smt_bvashr(left, right)
           case BVULE    => smt_bvule(left, right)
-          case BVUGT    => ???
-          case BVUGE    => ???
+          case BVUGT    => smt_bvugt(left, right)
+          case BVUGE    => smt_bvuge(left, right)
           case BVSLT    => smt_bvslt(left, right)
           case BVSLE    => smt_bvsle(left, right)
-          case BVSGT    => ???
-          case BVSGE    => ???
+          case BVSGT    => smt_bvsgt(left, right)
+          case BVSGE    => smt_bvsge(left, right)
           case BVEQ     => smt_bveq(left, right)
           case BVNEQ    => smt_bvneq(left, right)
           case BVCONCAT => smt_concat(left, right)

src/main/scala/util/ProgramGenerator.scala

@@ -0,0 +1,48 @@
+package util
+
+import scala.collection.mutable.ArrayBuffer
+
+object ProgramGenerator {
+
+  private val operatorList = Array("+", "-", "*", "/", "|", "^", "&")
+  def generateProgram(): String = {
+    "#include <stdio.h>\n" +
+      "void computeValue() {\n" +
+      generateBody() +
+      "\n}\n\n" +
+      "void main() {\n" +
+      "\tcomputeValue()\n" +
+      "}\n"
+
+
+  }
+  def generateBody(): String = {
+    var programBody = ""
+    val rand = new scala.util.Random
+    val variables = rand.between(1, 100)
+
+    for (countVars <- 1 to variables) {
+
+      val terms: ArrayBuffer[String] = ArrayBuffer()
+      for (generatedVar <- 1 until countVars) {
+        terms.addOne("variable" + generatedVar)
+      }
+
+      val numberOfConstants = rand.between(1, 100)
+      for (i <- 1 to numberOfConstants) {
+        terms.addOne(rand.between(1,500).toString)
+      }
+      val shuffledTerms = rand.shuffle(terms)
+      var generatedLine = "\tint variable" + countVars + " ="
+      for ((t, i) <- shuffledTerms.zipWithIndex) {
+        if (i != 0) {
+          generatedLine += operatorList(rand.nextInt(operatorList.length))
+        }
+        generatedLine += " " + t + " "
+      }
+
+      programBody += generatedLine + "\n"
+    }
+    programBody + "\n\tprintf(\"%d\", variable" + variables + ")"
+  }
+}

src/test/scala/ir/InterpreterTests.scala

@@ -5,7 +5,7 @@ import org.scalatest.funsuite.AnyFunSuite
 import org.scalatest.BeforeAndAfter
 import specification.SpecGlobal
 import translating.BAPToIR
-import util.{LogLevel, Logger}
+import util.{LogLevel, Logger, ProgramGenerator}
 import util.RunUtils.{loadBAP, loadReadELF}
 
 class InterpreterTests extends AnyFunSuite with BeforeAndAfter {
@@ -26,7 +26,9 @@ class InterpreterTests extends AnyFunSuite with BeforeAndAfter {
 
     (IRProgram, globals)
   }
-
+  def generateProgram(): String = {
+    ProgramGenerator.generateProgram()
+  }
   def testInterpret(name: String, expected: Map[String, Int]): Unit = {
     val (program, globals) = getProgram(name)
     val regs = i.interpret(program)
@@ -58,6 +60,7 @@ class InterpreterTests extends AnyFunSuite with BeforeAndAfter {
     i = Interpreter()
   }
 
+
   test("getMemory in LittleEndian") {
     i.mems(0) = BitVecLiteral(BigInt("0D", 16), 8)
     i.mems(1) = BitVecLiteral(BigInt("0C", 16), 8)
@@ -190,4 +193,8 @@ class InterpreterTests extends AnyFunSuite with BeforeAndAfter {
     )
     testInterpret("no_interference_update_y", expected)
   }
+
+  test("Generate Test Program") {
+    assert(generateProgram().nonEmpty)
+  }
 }