move transforms out of RunUtils.scala

src/main/scala/analysis/Cfg.scala

@@ -502,7 +502,7 @@ class ProgramCfgFactory:
             val targetProc: Procedure = dCall.target
             funcEntryNode.callers.add(procToCfg(targetProc)._1)
 
-            val callNode = CfgJumpNode(dCall, block, funcEntryNode)
+            val callNode : CfgJumpNode = s.asInstanceOf[CfgJumpNode]
 
             // Branch to this call
             cfg.addEdge(precNode, callNode)
@@ -523,7 +523,7 @@ class ProgramCfgFactory:
             Logger.debug(s"Indirect call found: $iCall in ${proc.name}")
             var precNode = prevNode
 
-            val jmpNode = CfgJumpNode(iCall, block, funcEntryNode)
+            val jmpNode = s.asInstanceOf[CfgJumpNode]
             // Branch to this call
             cfg.addEdge(precNode, jmpNode)
 

src/main/scala/analysis/IDEAnalysis.scala

@@ -1,6 +1,6 @@
 package analysis
 
-import ir.{CFGPosition, Command, DirectCall, GoTo, IndirectCall, Procedure, Program}
+import ir.{CFGPosition, Command, DirectCall, GoTo, Return, IndirectCall, Procedure, Program}
 
 final case class Lambda()
 
@@ -55,6 +55,6 @@ trait IDEAnalysis[E, EE, C, R, D, T, L <: Lattice[T]] {
 }
 
 // IndirectCall in these is because they are returns so that can be further tightened in future
-trait ForwardIDEAnalysis[D, T, L <: Lattice[T]] extends IDEAnalysis[Procedure, IndirectCall, DirectCall, Command, D, T, L]
+trait ForwardIDEAnalysis[D, T, L <: Lattice[T]] extends IDEAnalysis[Procedure, Return, DirectCall, Command, D, T, L]
 
-trait BackwardIDEAnalysis[D, T, L <: Lattice[T]] extends IDEAnalysis[IndirectCall, Procedure, Command, DirectCall, D, T, L]
+trait BackwardIDEAnalysis[D, T, L <: Lattice[T]] extends IDEAnalysis[Return, Procedure, Command, DirectCall, D, T, L]

src/main/scala/analysis/InterLiveVarsAnalysis.scala

@@ -1,7 +1,7 @@
 package analysis
 
 import analysis.solvers.BackwardIDESolver
-import ir.{Assert, Assume, GoTo, CFGPosition, Command, DirectCall, IndirectCall, Assign, MemoryAssign, Procedure, Program, Variable, toShortString}
+import ir.{Assert, Assume, Block, GoTo, CFGPosition, Command, DirectCall, IndirectCall, Assign, MemoryAssign, Halt, Return, Procedure, Program, Variable, toShortString}
 
 /**
  * Micro-transfer-functions for LiveVar analysis
@@ -19,7 +19,7 @@ trait LiveVarsAnalysisFunctions extends BackwardIDEAnalysis[Variable, TwoElement
   val edgelattice: EdgeFunctionLattice[TwoElement, TwoElementLattice] = EdgeFunctionLattice(valuelattice)
   import edgelattice.{IdEdge, ConstEdge}
 
-  def edgesCallToEntry(call: Command, entry: IndirectCall)(d: DL): Map[DL, EdgeFunction[TwoElement]] = {
+  def edgesCallToEntry(call: Command, entry: Return)(d: DL): Map[DL, EdgeFunction[TwoElement]] = {
     Map(d -> IdEdge())
   }
 
@@ -74,7 +74,11 @@ trait LiveVarsAnalysisFunctions extends BackwardIDEAnalysis[Variable, TwoElement
         d match
           case Left(value) => if value != variable then Map(d -> IdEdge()) else Map()
           case Right(_) => Map(d -> IdEdge(), Left(variable) -> ConstEdge(TwoElementTop))
-      case _ => Map(d -> IdEdge())
+      case r: Return => Map(d -> IdEdge())
+      case h: Halt => Map(d -> IdEdge())
+      case c: DirectCall => Map(d -> IdEdge())
+      case c: Block => Map(d -> IdEdge())
+      case c: GoTo => Map(d -> IdEdge())
 
   }
 }

src/main/scala/analysis/IntraLiveVarsAnalysis.scala

@@ -1,7 +1,7 @@
 package analysis
 
 import analysis.solvers.SimpleWorklistFixpointSolver
-import ir.{Assert, Assume, Block, CFGPosition, Call, DirectCall, GoTo, IndirectCall, Jump, Assign, MemoryAssign, NOP, Procedure, Program, Statement, Variable}
+import ir.{Assert, Assume, Block, CFGPosition, Call, DirectCall, GoTo, IndirectCall, Jump, Assign, MemoryAssign, NOP, Procedure, Program, Statement, Variable, Return, Halt}
 
 abstract class LivenessAnalysis(program: Program) extends Analysis[Any]:
   val lattice: MapLattice[CFGPosition, Set[Variable], PowersetLattice[Variable]] = MapLattice(PowersetLattice())
@@ -18,6 +18,8 @@ abstract class LivenessAnalysis(program: Program) extends Analysis[Any]:
       case IndirectCall(variable, _) => s + variable
       case c: DirectCall => s
       case g: GoTo => s
+      case r: Return => s
+      case r: Halt => s
       case _ => ???
     }
   }

src/main/scala/analysis/VSA.scala

@@ -172,7 +172,7 @@ trait ValueSetAnalysis(program: Program,
     if (IRWalk.procedure(n) == n) {
       mmm.pushContext(n.asInstanceOf[Procedure].name)
       s
-    } else if (IRWalk.procedure(n).end == n) {
+    } else if (IRWalk.lastInProc(IRWalk.procedure(n)) == n) {
       mmm.popContext()
       s
     } else n match

src/main/scala/analysis/solvers/IDESolver.scala

@@ -1,7 +1,7 @@
 package analysis.solvers
 
 import analysis.{BackwardIDEAnalysis, Dependencies, EdgeFunction, EdgeFunctionLattice, ForwardIDEAnalysis, IDEAnalysis, IRInterproceduralBackwardDependencies, IRInterproceduralForwardDependencies, Lambda, Lattice, MapLattice}
-import ir.{CFGPosition, Command, DirectCall, GoTo, IRWalk, IndirectCall, InterProcIRCursor, Procedure, Program, end, isAfterCall, Halt, Statement, Jump}
+import ir.{CFGPosition, Command, DirectCall, GoTo, IRWalk, IndirectCall, Return, InterProcIRCursor, Procedure, Program, isAfterCall, Halt, Statement, Jump}
 import util.Logger
 
 import scala.collection.immutable.Map
@@ -208,10 +208,10 @@ abstract class IDESolver[E <: Procedure | Command, EE <: Procedure | Command, C
 
 
 abstract class ForwardIDESolver[D, T, L <: Lattice[T]](program: Program)
-  extends IDESolver[Procedure, IndirectCall, DirectCall, Command, D, T, L](program, program.mainProcedure),
+  extends IDESolver[Procedure, Return, DirectCall, Command, D, T, L](program, program.mainProcedure),
     ForwardIDEAnalysis[D, T, L], IRInterproceduralForwardDependencies {
 
-  protected def entryToExit(entry: Procedure): IndirectCall = entry.end.asInstanceOf[IndirectCall]
+  protected def entryToExit(entry: Procedure): Return = IRWalk.lastInProc(entry).asInstanceOf[Return]
 
   protected def exitToEntry(exit: IndirectCall): Procedure = IRWalk.procedure(exit)
 
@@ -222,7 +222,10 @@ abstract class ForwardIDESolver[D, T, L <: Lattice[T]](program: Program)
     case r: Jump => ret.parent.statements.last.asInstanceOf[DirectCall]
   }
 
-  protected def getCallee(call: DirectCall): Procedure = call.target
+  protected def getCallee(call: DirectCall): Procedure = {
+    require(isCall(call))
+    call.target
+  }
 
   protected def isCall(call: CFGPosition): Boolean =
     call match
@@ -232,41 +235,46 @@ abstract class ForwardIDESolver[D, T, L <: Lattice[T]](program: Program)
   protected def isExit(exit: CFGPosition): Boolean =
     exit match
       // only looking at functions with statements
-      case command: Command => IRWalk.procedure(command).end == command
+      case command: Command => IRWalk.lastInProc(IRWalk.procedure(command)) == command
       case _ => false
 
   protected def getAfterCalls(exit: IndirectCall): Set[Command] =
     InterProcIRCursor.succ(exit).filter(_.isInstanceOf[Command]).map(_.asInstanceOf[Command])
-
 }
 
 
 abstract class BackwardIDESolver[D, T, L <: Lattice[T]](program: Program)
-  extends IDESolver[IndirectCall, Procedure, Command, DirectCall, D, T, L](program, program.mainProcedure.end),
+  extends IDESolver[Return, Procedure, Command, DirectCall, D, T, L](program, IRWalk.lastInProc(program.mainProcedure)),
     BackwardIDEAnalysis[D, T, L], IRInterproceduralBackwardDependencies {
 
-  protected def entryToExit(entry: IndirectCall): Procedure = IRWalk.procedure(entry)
+  protected def entryToExit(entry: Return): Procedure = IRWalk.procedure(entry)
 
-  protected def exitToEntry(exit: Procedure): IndirectCall = exit.end.asInstanceOf[IndirectCall]
+  protected def exitToEntry(exit: Procedure): Return = exit.returnBlock.get.jump.asInstanceOf[Return]
 
-  protected def callToReturn(call: Command): DirectCall = call match {
-    case ret: Statement => ret.parent.statements.getPrev(ret).asInstanceOf[DirectCall]
-    case r: Jump => r.parent.statements.last.asInstanceOf[DirectCall]
+  protected def callToReturn(call: Command): DirectCall =  {
+    IRWalk.prevCommandInBlock(call) match {
+      case Some(x : DirectCall) => x
+      case p => throw Exception(s"Not a return/aftercall node $call  .... prev = $p")
+    }
   }
 
   protected def returnToCall(ret: DirectCall): Command = ret.successor
 
-  protected def getCallee(call: Command): IndirectCall = callToReturn(call: Command).target.end.asInstanceOf[IndirectCall]
+  protected def getCallee(call: Command): Return = {
+    require(isCall(call))
+    val procCalled = callToReturn(call).target
+    procCalled.returnBlock.getOrElse(throw Exception(s"No return node for procedure ${procCalled}")).jump.asInstanceOf[Return]
+  }
 
   protected def isCall(call: CFGPosition): Boolean =
     call match
-      case directCall: DirectCall => (!directCall.successor.isInstanceOf[Halt])
+      case c : Command => isAfterCall(c) && IRWalk.prevCommandInBlock(c).map(_.isInstanceOf[DirectCall]).getOrElse(false)
       case _ => false
 
   protected def isExit(exit: CFGPosition): Boolean =
     exit match
-      case procedure: Procedure => procedure.blocks.nonEmpty
+      case procedure: Procedure => true
       case _ => false
 
-  protected def getAfterCalls(exit: Procedure): Set[DirectCall] = InterProcIRCursor.pred(exit).filter(_.isInstanceOf[DirectCall]).map(_.asInstanceOf[DirectCall])
+  protected def getAfterCalls(exit: Procedure): Set[DirectCall] = exit.incomingCalls().toSet
 }