make GTIRB input optional instead of replacing the BAP input

src/main/scala/Main.scala

@@ -16,8 +16,8 @@ object Main {
 
   @main(name = "BASIL")
   case class Config(
-      @arg(name = "adt", short = 'a', doc = "BAP ADT file name.")
-      adtFileName: String,
+      @arg(name = "input", short = 'i', doc = "BAP .adt file or Gtirb/ASLi .gts file")
+      inputFileName: String,
       @arg(name = "relf", short = 'r', doc = "Name of the file containing the output of 'readelf -s -r -W'.")
       relfFileName: String,
       @arg(name = "spec", short = 's', doc = "BASIL specification file.")
@@ -67,7 +67,7 @@ object Main {
     }
 
     val q = BASILConfig(
-      loading = ILLoadingConfig(conf.adtFileName, conf.relfFileName, conf.specFileName, conf.dumpIL, conf.mainProcedureName, conf.procedureDepth),
+      loading = ILLoadingConfig(conf.inputFileName, conf.relfFileName, conf.specFileName, conf.dumpIL, conf.mainProcedureName, conf.procedureDepth),
       runInterpret = conf.interpret.value,
       staticAnalysis = if conf.analyse.value then Some(StaticAnalysisConfig(conf.dumpIL, conf.analysisResults, conf.analysisResultsDot)) else None,
       boogieTranslation = BoogieGeneratorConfig(if conf.lambdaStores.value then BoogieMemoryAccessMode.LambdaStoreSelect else BoogieMemoryAccessMode.SuccessiveStoreSelect),

src/main/scala/util/BASILConfig.scala

@@ -1,6 +1,6 @@
 package util
 
-case class ILLoadingConfig(adtFile: String, relfFile: String, specFile: Option[String] = None, dumpIL: Option[String] = None, mainProcedureName: String = "main", procedureTrimDepth: Int = Int.MaxValue)
+case class ILLoadingConfig(inputFile: String, relfFile: String, specFile: Option[String] = None, dumpIL: Option[String] = None, mainProcedureName: String = "main", procedureTrimDepth: Int = Int.MaxValue)
 case class BoogieGeneratorConfig(memoryFunctionType: BoogieMemoryAccessMode = BoogieMemoryAccessMode.SuccessiveStoreSelect, coalesceConstantMemory: Boolean = true)
 case class StaticAnalysisConfig(dumpILToPath: Option[String] = None, analysisResultsPath: Option[String] = None, analysisDotPath: Option[String] = None)
 enum BoogieMemoryAccessMode:

src/main/scala/util/RunUtils.scala

@@ -44,45 +44,43 @@ object RunUtils {
   // constants
   private val exitRegister: Variable = Register("R30", BitVecType(64))
 
-  def loadBAP(fileName: String, mainAddress: Int): Program = {
-    // // BAP LOGIC
-    // val ADTLexer = BAP_ADTLexer(CharStreams.fromFileName(fileName))
-    // val tokens = CommonTokenStream(ADTLexer)
-    // val parser = BAP_ADTParser(tokens)
+  def loadBAP(fileName: String): BAPProgram = {
+    val ADTLexer = BAP_ADTLexer(CharStreams.fromFileName(fileName))
+    val tokens = CommonTokenStream(ADTLexer)
+    val parser = BAP_ADTParser(tokens)
 
-    // parser.setBuildParseTree(true)
-
-    // BAPLoader.visitProject(parser.project())
+    parser.setBuildParseTree(true)
 
+    BAPLoader.visitProject(parser.project())
+  }
 
-    // GTIRB LOGIC
-    var fIn = new FileInputStream(fileName)
+  def loadGtirb(fileName: String, mainAddress: Int): Program = {
+    val fIn = FileInputStream(fileName)
     val ir = IR.parseFrom(fIn)
     val mods = ir.modules
     val cfg = ir.cfg.get
 
-    val semantics = mods.map(_.auxData("ast").data.toStringUtf8.parseJson.convertTo[Map[String, Array[Array[String]]]]);
+    val semantics = mods.map(_.auxData("ast").data.toStringUtf8.parseJson.convertTo[Map[String, Array[Array[String]]]])
 
-    def parse_insn (f: String) : StmtContext = {
+    def parse_insn(f: String): StmtContext = {
       try {
         val semanticsLexer = SemanticsLexer(CharStreams.fromString(f))
         val tokens = CommonTokenStream(semanticsLexer)
         val parser = SemanticsParser(tokens)
-        parser.setErrorHandler(new BailErrorStrategy())
-        parser.setBuildParseTree(true)     
-        return parser.stmt()
+        parser.setErrorHandler(BailErrorStrategy())
+        parser.setBuildParseTree(true)
+        parser.stmt()
       } catch {
         case e: org.antlr.v4.runtime.misc.ParseCancellationException =>
-          println(f)
-          throw new RuntimeException(e)
+          Logger.error(f)
+          throw RuntimeException(e)
       }
     }
 
-    val parserMap = semantics.map(_.map(((k: String,v: Array[Array[String]]) => (k, v.map(_.map(parse_insn(_)))))))
+    val parserMap = semantics.map(_.map((k: String, v: Array[Array[String]]) => (k, v.map(_.map(parse_insn)))))
 
-    val GtirbConverter = new GtirbToIR(mods, parserMap.flatten.toMap, cfg, mainAddress)
-    val program = GtirbConverter.createIR()
-    return program
+    val GtirbConverter = GtirbToIR(mods, parserMap.flatten.toMap, cfg, mainAddress)
+    GtirbConverter.createIR()
   }
 
   def loadReadELF(fileName: String, config: ILLoadingConfig): (Set[ExternalFunction], Set[SpecGlobal], Map[BigInt, BigInt], Int) = {
@@ -116,21 +114,20 @@ object RunUtils {
   }
 
   def loadAndTranslate(q: BASILConfig): BProgram = {
-
     /** Loading phase
       */
+    val (externalFunctions, globals, globalOffsets, mainAddress) = loadReadELF(q.loading.relfFile, q.loading)
+
+    var IRProgram: Program = if (q.loading.inputFile.endsWith(".adt")) {
+      val bapProgram = loadBAP(q.loading.inputFile)
+      val IRTranslator = BAPToIR(bapProgram, mainAddress)
+      IRTranslator.translate
+    } else if (q.loading.inputFile.endsWith(".gts")) {
+      loadGtirb(q.loading.inputFile, mainAddress)
+    } else {
+      throw Exception(s"input file name ${q.loading.inputFile} must be an .adt or .gst file")
+    }
 
-
-    // GTIRB LOGIC
-    val (externalFunctions, globals, globalOffsets, mainAddress) = loadReadELF(q.loading.relfFile, q.loading) 
-    var IRProgram = loadBAP(q.loading.adtFile, mainAddress) 
-
-    // // BAP LOGIC
-    // val bapProgram = loadBAP(q.loading.adtFile, 12121) 
-    // val (externalFunctions, globals, globalOffsets, mainAddress) = loadReadELF(q.loading.relfFile, q.loading)
-    // val IRTranslator = BAPToIR(bapProgram, mainAddress)
-    // var IRProgram = IRTranslator.translate
-
     val specification = loadSpecification(q.loading.specFile, IRProgram, globals)
 
     /** Analysis Phase

src/test/scala/MemoryRegionAnalysisMiscTest.scala

@@ -19,7 +19,7 @@ class MemoryRegionAnalysisMiscTest extends AnyFunSuite with OneInstancePerTest {
     RunUtils.loadAndTranslate(
       BASILConfig(
         loading = ILLoadingConfig(
-          adtFile = examplesPath + s"$name/$name.adt",
+          inputFile = examplesPath + s"$name/$name.adt",
           relfFile = examplesPath + s"$name/$name.relf",
           specFile = None,
           dumpIL = None,

src/test/scala/SystemTests.scala

@@ -34,7 +34,7 @@ class SystemTests extends AnyFunSuite {
     val variations = getSubdirectories(path)
     variations.foreach(t =>
       test("correct/" + p + "/" + t) {
-        runTest(correctPath, p, t, true)
+        runTest(correctPath, p, t, true, true)
       }
     )
   }
@@ -44,7 +44,7 @@ class SystemTests extends AnyFunSuite {
     val variations = getSubdirectories(path)
     variations.foreach(t =>
       test("incorrect/" + p + "/" + t) {
-        runTest(incorrectPath, p, t, false)
+        runTest(incorrectPath, p, t, false, true)
       }
     )
   }
@@ -72,18 +72,17 @@ class SystemTests extends AnyFunSuite {
     log(summaryHeader + System.lineSeparator() + summaryRow, testPath + "summary.csv")
   }
 
-
-  def runTest(path: String, name: String, variation: String, shouldVerify: Boolean): Unit= {
+  def runTest(path: String, name: String, variation: String, shouldVerify: Boolean, useADT: Boolean): Unit= {
     val directoryPath = path + "/" + name + "/"
     val variationPath = directoryPath + variation + "/" + name
     val specPath = directoryPath + name + ".spec"
     val outPath = variationPath + ".bpl"
-        val ADTPath = variationPath + ".gts"
+    val inputPath = if useADT then variationPath + ".adt" else variationPath + ".gts"
     val RELFPath = variationPath + ".relf"
     Logger.info(outPath)
     val timer = PerformanceTimer(s"test $name/$variation")
 
-    val args = mutable.ArrayBuffer("--adt", ADTPath, "--relf", RELFPath, "--output", outPath)
+    val args = mutable.ArrayBuffer("--input", inputPath, "--relf", RELFPath, "--output", outPath)
     if (File(specPath).exists) args ++= Seq("--spec", specPath)
 
     Main.main(args.toArray)

src/test/scala/ir/InterpreterTests.scala

@@ -18,17 +18,16 @@ class InterpreterTests extends AnyFunSuite with BeforeAndAfter {
 
 
     val loading = ILLoadingConfig(
-      adtFile = s"examples/$name/$name.adt",
+      inputFile = s"examples/$name/$name.adt",
       relfFile = s"examples/$name/$name.relf",
       specFile = None,
-      dumpIL = None,
-      mainProcedureName = "main",
+      dumpIL = None
     )
 
+    val bapProgram = loadBAP(loading.inputFile)
     val (externalFunctions, globals, _, mainAddress) = loadReadELF(loading.relfFile, loading)
-    var IRProgram = loadBAP(loading.adtFile, mainAddress)
-    // val IRTranslator = BAPToIR(bapProgram, mainAddress)
-    // var IRProgram = IRTranslator.translate
+    val IRTranslator = BAPToIR(bapProgram, mainAddress)
+    var IRProgram = IRTranslator.translate
     IRProgram = ExternalRemover(externalFunctions.map(e => e.name)).visitProgram(IRProgram)
     IRProgram = Renamer(Set("free")).visitProgram(IRProgram)
     IRProgram.stripUnreachableFunctions()