fix #316

src/main/scala/analysis/WriteToAnalysis.scala

@@ -1,47 +1,32 @@
 package analysis
+import ir.transforms.ReadWriteAnalysis.*
+import ir.transforms.ReadWriteAnalysis
 
 import ir.{DirectCall, LocalAssign, MemoryLoad, MemoryStore, Procedure, Program, Register}
 
 import scala.collection.mutable
 
 class WriteToAnalysis(program: Program) extends Analysis[Map[Procedure, Set[Register]]] {
 
-  val writesTo: mutable.Map[Procedure, Set[Register]] = mutable.Map()
-  val mallocRegister = Register("R0", 64)
-  val paramRegisters: Set[Register] = Set(
-    mallocRegister,
-    Register("R1", 64),
-    Register("R2", 64),
-    Register("R3", 64),
-    Register("R4", 64),
-    Register("R5", 64),
-    Register("R6", 64),
-    Register("R7", 64)
-  )
+  lazy val result = ir.transforms.ReadWriteAnalysis.readWriteSets(program)
+
+  val paramRegisters = ((0 to 7).toSet).map(i => Register(s"R${i}", 64)).toSet
+  val overApprox = ((0 to 31).toSet -- (19 to 28).toSet).map(i => Register(s"R${i}", 64)).toSet
 
   def getWritesTos(proc: Procedure): Set[Register] = {
-    if writesTo.contains(proc) then writesTo(proc)
-    else
-      val writtenTo: mutable.Set[Register] = mutable.Set()
-      proc.blocks.foreach { block =>
-        block.statements.foreach {
-          case LocalAssign(variable: Register, _, _) if paramRegisters.contains(variable) =>
-            writtenTo.add(variable)
-          case MemoryLoad(lhs: Register, _, _, _, _, _) if paramRegisters.contains(lhs) =>
-            writtenTo.add(lhs)
-          case DirectCall(target, _, _, _) if target.procName == "malloc" =>
-            writtenTo.add(mallocRegister)
-          case d: DirectCall if program.procedures.contains(d.target) =>
-            writtenTo.addAll(getWritesTos(d.target))
-          case _ =>
-        }
+    result
+      .get(proc)
+      .map {
+        case Some(r) =>
+          r.writes.collect { case reg: Register =>
+            reg
+          }.toSet
+        case None => overApprox
       }
-
-      writesTo.update(proc, writtenTo.toSet)
-      writesTo(proc)
+      .toSet
+      .flatten
   }
 
   def analyze(): Map[Procedure, Set[Register]] =
-    program.procedures.foreach(getWritesTos)
-    writesTo.toMap
+    result.keySet.map(p => p -> getWritesTos(p)).toMap
 }