fix #316

Author: ailrst

src/main/scala/analysis/WriteToAnalysis.scala

@@ -1,48 +1,26 @@
 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)
 
-  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.name == "malloc" =>
-            writtenTo.add(mallocRegister)
-          case d: DirectCall if program.procedures.contains(d.target) =>
-            writtenTo.addAll(getWritesTos(d.target))
-          case _ =>
-        }
-    }
+  val overApprox = ((0 to 31).toSet -- (19 to 28).toSet).map(i => Register(s"R${i}", 64)).toSet
 
-      writesTo.update(proc, writtenTo.toSet)
-      writesTo(proc)
+  def getWritesTos(proc: Procedure): Set[Register] = {
+    result.get(proc).map {
+      case Some(r) => r.writes.collect {
+        case reg: Register => reg
+      }.toSet
+      case None => overApprox
+    }.toSet.flatten
   }
 
   def analyze(): Map[Procedure, Set[Register]] =
-    program.procedures.foreach(getWritesTos)
-    writesTo.toMap
+    result.keySet.map(p => p -> getWritesTos(p)).toMap
 }