move of = Overflow() out of FPADD, use chain

diff --git a/src/add/nmigen_add_experiment.py b/src/add/nmigen_add_experiment.py
index 884630e465a68535e99ad5578e65d14326ab83fb..d7e6a594abb2d82fca59d759e351254204319fa1 100644 (file)
--- a/src/add/nmigen_add_experiment.py
+++ b/src/add/nmigen_add_experiment.py
@@ -303,8 +303,8 @@ class FPAddStage1Mod(FPState):
 
     def elaborate(self, platform):
         m = Module()
+        m.submodules.add1_out_overflow = self.out_of
         #m.submodules.norm1_in_overflow = self.in_of
-        #m.submodules.norm1_out_overflow = self.out_of
         #m.submodules.norm1_in_z = self.in_z
         #m.submodules.norm1_out_z = self.out_z
         m.d.comb += self.out_z.copy(self.in_z)
@@ -339,7 +339,7 @@ class FPAddStage1(FPState):
         self.out_of = Overflow()
 
     def action(self, m):
-        m.d.sync += self.of.copy(self.out_of)
+        #m.d.sync += self.of.copy(self.out_of)
         m.d.sync += self.z.copy(self.out_z)
         m.next = "normalise_1"
 
@@ -395,7 +395,7 @@ class FPNorm1(FPState):
         self.out_of = Overflow()
 
     def action(self, m):
-        m.d.sync += self.of.copy(self.out_of)
+        #m.d.sync += self.of.copy(self.out_of)
         m.d.sync += self.z.copy(self.out_z)
         with m.If(~self.out_norm):
             m.next = "normalise_2"
@@ -451,7 +451,8 @@ class FPNorm2(FPState):
         self.out_of = Overflow()
 
     def action(self, m):
-        m.d.sync += self.of.copy(self.out_of)
+        m.submodules.norm_of = self.out_of
+        #m.d.sync += self.of.copy(self.out_of)
         m.d.sync += self.z.copy(self.out_z)
         with m.If(~self.out_norm):
             m.next = "round"
@@ -603,9 +604,6 @@ class FPADD:
 
         w = z.m_width + 4
 
-        of = Overflow()
-        m.submodules.overflow = of
-
         geta = self.add_state(FPGetOpA(self.in_a, self.width))
         #geta.set_inputs({"in_a": self.in_a})
         #geta.set_outputs({"a": a})
@@ -643,26 +641,26 @@ class FPADD:
 
         add1 = self.add_state(FPAddStage1(self.width))
         add1.set_inputs({"tot": add0.out_tot, "z": add0.out_z})
-        add1.set_outputs({"z": z, "of": of})  # XXX Z as output
+        add1.set_outputs({"z": z})  # XXX Z as output
         add1.mod.setup(m, add0.out_tot, z, add1.out_z, add1.out_of)
         m.submodules.add1 = add1.mod
 
         n1 = self.add_state(FPNorm1(self.width))
-        n1.set_inputs({"z": z, "of": of})  # XXX Z as output
+        n1.set_inputs({"z": z, "of": add1.out_of})  # XXX Z as output
         n1.set_outputs({"z": z})  # XXX Z as output
-        n1.mod.setup(m, z, n1.out_z, of, n1.out_of, n1.out_norm)
+        n1.mod.setup(m, z, n1.out_z, add1.out_of, n1.out_of, n1.out_norm)
         m.submodules.normalise_1 = n1.mod
 
         n2 = self.add_state(FPNorm2(self.width))
-        n2.set_inputs({"z": n1.out_z, "of": of})
+        n2.set_inputs({"z": n1.out_z, "of": n1.out_of})
         n2.set_outputs({"z": z})
-        n2.mod.setup(m, n1.out_z, n2.out_z, of, n2.out_of, n2.out_norm)
+        n2.mod.setup(m, n1.out_z, n2.out_z, n1.out_of, n2.out_of, n2.out_norm)
         m.submodules.normalise_2 = n2.mod
 
         rn = self.add_state(FPRound(self.width))
-        rn.set_inputs({"z": n2.out_z, "of": of})
+        rn.set_inputs({"z": n2.out_z, "of": n2.out_of})
         rn.set_outputs({"z": z})
-        rn.mod.setup(m, n2.out_z, rn.out_z, of)
+        rn.mod.setup(m, n2.out_z, rn.out_z, n2.out_of)
         m.submodules.roundz = rn.mod
 
         cor = self.add_state(FPCorrections(self.width))