More fixes for real applications

buildSrc/src/main/kotlin/Dependencies.kt

@@ -6,7 +6,7 @@ object Versions {
     const val clikt = "5.0.0"
     const val detekt = "1.23.7"
     const val ini4j = "0.5.4"
-    const val jacodb = "4ff7243d3a"
+    const val jacodb = "5889d3c784"
     const val juliet = "1.3.2"
     const val junit = "5.9.3"
     const val kotlin = "2.1.0"

usvm-ts/src/main/kotlin/org/usvm/machine/TsContext.kt

@@ -6,6 +6,8 @@
 import org.jacodb.ets.model.EtsAnyType
 import org.jacodb.ets.model.EtsArrayType
 import org.jacodb.ets.model.EtsBooleanType
+import org.jacodb.ets.model.EtsEnumValueType
+import org.jacodb.ets.model.EtsGenericType
 import org.jacodb.ets.model.EtsNullType
 import org.jacodb.ets.model.EtsNumberType
 import org.jacodb.ets.model.EtsRefType
@@ -29,10 +31,12 @@
 import org.usvm.api.typeStreamOf
 import org.usvm.collection.field.UFieldLValue
 import org.usvm.isTrue
+import org.usvm.machine.Constants.Companion.MAGIC_OFFSET
 import org.usvm.machine.expr.TsUndefinedSort
 import org.usvm.machine.expr.TsUnresolvedSort
 import org.usvm.machine.expr.TsVoidSort
 import org.usvm.machine.expr.TsVoidValue
+import org.usvm.machine.expr.tctx
 import org.usvm.machine.interpreter.TsStepScope
 import org.usvm.machine.types.EtsFakeType
 import org.usvm.memory.UReadOnlyMemory
@@ -76,6 +80,16 @@
         is EtsAnyType -> unresolvedSort
         is EtsUnknownType -> unresolvedSort
         is EtsAliasType -> typeToSort(type.originalType)
+        is EtsEnumValueType -> unresolvedSort
+
+        is EtsGenericType -> {
+            if (type.constraint == null && type.defaultType == null) {
+                unresolvedSort
+            } else {
+                TODO("Not yet implemented")
+            }
+        }
+
         else -> TODO("${type::class.simpleName} is not yet supported: $type")
     }
 
@@ -152,6 +166,22 @@
         }
     }
 
+    fun UHeapRef.unwrapRef(scope: TsStepScope): UHeapRef {
+        if (isFakeObject()) {
+            return extractRef(scope)
+        }
+        return this
+    }
+
+    fun UHeapRef.unwrapRefWithPathConstraint(scope: TsStepScope): UHeapRef = with(tctx) {
+        if (this@unwrapRefWithPathConstraint.isFakeObject()) {
+            scope.assert(getFakeType(scope).refTypeExpr)
+            extractRef(scope)
+        } else {
+            asExpr(addressSort)
+        }
+    }
+
     fun createFakeObjectRef(): UConcreteHeapRef {
         val address = mkAddressCounter().freshAllocatedAddress() + MAGIC_OFFSET
         return mkConcreteHeapRef(address)
@@ -235,7 +265,13 @@
     }
 }
 
-const val MAGIC_OFFSET = 1000000
+class Constants {
+    companion object {
+        const val STATIC_METHODS_FORK_LIMIT = 5
+        const val MAGIC_OFFSET = 1000000
+    }
+}
+
 
 enum class IntermediateLValueField {
     BOOL, FP, REF

usvm-ts/src/main/kotlin/org/usvm/machine/TsInterpreterObserver.kt

@@ -24,7 +24,7 @@ interface TsInterpreterObserver : UInterpreterObserver {
 
     fun onCallWithUnresolvedArguments(
         simpleValueResolver: TsSimpleValueResolver,
-        stmt: EtsCallExpr,
+        expr: EtsCallExpr,
         scope: TsStepScope,
     ) {
         // default empty implementation

usvm-ts/src/main/kotlin/org/usvm/machine/TsMachine.kt

@@ -26,7 +26,9 @@ import org.usvm.statistics.collectors.TargetsReachedStatesCollector
 import org.usvm.statistics.constraints.SoftConstraintsObserver
 import org.usvm.statistics.distances.CfgStatisticsImpl
 import org.usvm.statistics.distances.PlainCallGraphStatistics
+import org.usvm.stopstrategies.StopStrategy
 import org.usvm.stopstrategies.createStopStrategy
+import org.usvm.util.TsStateVisualizer
 import org.usvm.util.humanReadableSignature
 import kotlin.time.Duration.Companion.seconds
 
@@ -95,20 +97,36 @@ class TsMachine(
         val observers = mutableListOf<UMachineObserver<TsState>>(coverageStatistics)
         observers.add(statesCollector)
 
+        if (tsOptions.enableVisualization) {
+            observers += TsStateVisualizer()
+        }
+
         if (options.useSoftConstraints) {
             observers.add(SoftConstraintsObserver())
         }
 
         val stepsStatistics = StepsStatistics<EtsMethod, TsState>()
 
-        val stopStrategy = createStopStrategy(
-            options,
-            targets,
-            timeStatisticsFactory = { timeStatistics },
-            stepsStatisticsFactory = { stepsStatistics },
-            coverageStatisticsFactory = { coverageStatistics },
-            getCollectedStatesCount = { statesCollector.collectedStates.size }
-        )
+        val stopStrategy = object : StopStrategy {
+            val strategy = createStopStrategy(
+                options,
+                targets,
+                timeStatisticsFactory = { timeStatistics },
+                stepsStatisticsFactory = { stepsStatistics },
+                coverageStatisticsFactory = { coverageStatistics },
+                getCollectedStatesCount = { statesCollector.collectedStates.size },
+            )
+
+            override fun shouldStop(): Boolean {
+                val result = strategy.shouldStop()
+
+                if (result) {
+                    logger.warn { "Stop strategy finished execution: ${strategy.stopReason()}" }
+                }
+
+                return result
+            }
+        }
 
         observers.add(timeStatistics)
         observers.add(stepsStatistics)

usvm-ts/src/main/kotlin/org/usvm/machine/TsOptions.kt

@@ -2,4 +2,5 @@ package org.usvm.machine
 
 data class TsOptions(
     val interproceduralAnalysis: Boolean = true,
+    val enableVisualization: Boolean = false,
 )