Add ApplicationBlockGraph, ml deps

Author: emnigma

buildSrc/src/main/kotlin/Versions.kt

@@ -8,6 +8,7 @@ object Versions {
     const val mockk = "1.13.4"
     const val junitParams = "5.9.3"
     const val logback = "1.4.8"
+    const val onnxruntime = "1.15.1"
 
     // versions for jvm samples
     const val samplesLombok = "1.18.20"

buildSrc/src/main/kotlin/usvm.kotlin-conventions.gradle.kts

@@ -19,6 +19,7 @@ dependencies {
 
     implementation(kotlin("stdlib-jdk8"))
     implementation(kotlin("reflect"))
+    implementation("com.microsoft.onnxruntime", "onnxruntime", Versions.onnxruntime)
     implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:${Versions.coroutines}")
 
     testImplementation(kotlin("test"))

settings.gradle.kts

@@ -4,3 +4,4 @@ include("usvm-core")
 include("usvm-jvm")
 include("usvm-util")
 include("usvm-sample-language")
+include("usvm-path-selection")

usvm-path-selection/build.gradle

@@ -0,0 +1,10 @@
+plugins {
+    id("usvm.kotlin-conventions")
+}
+
+dependencies {
+    implementation(project(":usvm-core"))
+    implementation(project(":usvm-jvm"))
+
+    implementation("org.jacodb:jacodb-analysis:${Versions.jcdb}")
+}

usvm-path-selection/src/main/kotlin/org/usvm/ApplicationBlockGraph.kt

@@ -0,0 +1,9 @@
+package org.usvm
+
+import org.usvm.statistics.ApplicationGraph
+
+interface ApplicationBlockGraph<Method, BasicBlock, Statement> : ApplicationGraph<Method, BasicBlock> {
+    fun block(stmt: Statement): BasicBlock
+    fun instructions(block: BasicBlock): Sequence<Statement>
+    fun blocks(): Sequence<BasicBlock>
+}

usvm-path-selection/src/main/kotlin/org/usvm/jvm/JcApplicationBlockGraph.kt

@@ -0,0 +1,54 @@
+package org.usvm.jvm
+
+import org.jacodb.api.JcMethod
+import org.jacodb.api.cfg.JcBasicBlock
+import org.jacodb.api.cfg.JcBlockGraph
+import org.jacodb.api.cfg.JcGraph
+import org.jacodb.api.cfg.JcInst
+import org.jacodb.impl.cfg.JcBlockGraphImpl
+import org.usvm.ApplicationBlockGraph
+import org.usvm.machine.JcApplicationGraph
+
+class JcApplicationBlockGraph(jcGraph: JcGraph) :
+    ApplicationBlockGraph<JcMethod, JcBasicBlock, JcInst> {
+    private val jcBlockGraphImpl: JcBlockGraph = JcBlockGraphImpl(jcGraph)
+    private val jcApplicationGraph: JcApplicationGraph = JcApplicationGraph(jcGraph.classpath)
+    override fun predecessors(node: JcBasicBlock): Sequence<JcBasicBlock> =
+        jcBlockGraphImpl.predecessors(node).asSequence()
+
+    override fun successors(node: JcBasicBlock): Sequence<JcBasicBlock> = jcBlockGraphImpl.successors(node).asSequence()
+
+    override fun callees(node: JcBasicBlock): Sequence<JcMethod> {
+        return jcBlockGraphImpl.instructions(node)
+            .map { jcApplicationGraph.callees(it) }
+            .reduce { acc, sequence -> acc + sequence }
+            .toSet()
+            .asSequence()
+    }
+
+    override fun callers(method: JcMethod): Sequence<JcBasicBlock> {
+        return jcApplicationGraph
+            .callers(method)
+            .map { stmt -> block(stmt) }
+            .toSet()
+            .asSequence()
+    }
+
+    override fun entryPoints(method: JcMethod): Sequence<JcBasicBlock> = jcBlockGraphImpl.entries.asSequence()
+
+    override fun exitPoints(method: JcMethod): Sequence<JcBasicBlock> = jcBlockGraphImpl.exits.asSequence()
+
+    override fun methodOf(node: JcBasicBlock): JcMethod = jcBlockGraphImpl.instructions(node).first().location.method
+
+    override fun statementsOf(method: JcMethod): Sequence<JcBasicBlock> {
+        return jcApplicationGraph
+            .statementsOf(method)
+            .map { stmt -> block(stmt) }
+            .toSet()
+            .asSequence()
+    }
+
+    override fun block(stmt: JcInst): JcBasicBlock = jcBlockGraphImpl.block(stmt)
+    override fun instructions(block: JcBasicBlock): Sequence<JcInst> = jcBlockGraphImpl.instructions(block).asSequence()
+    override fun blocks(): Sequence<JcBasicBlock> = jcBlockGraphImpl.asSequence()
+}