1 # IEEE Floating Point Adder (Single Precision)
2 # Copyright (C) Jonathan P Dawson 2013
5 from nmigen
import Module
, Signal
, Cat
6 from nmigen
.cli
import main
, verilog
8 from fpbase
import FPNumIn
, FPNumOut
, FPOp
, Overflow
, FPBase
11 class FPState(FPBase
):
12 def __init__(self
, state_from
):
13 self
.state_from
= state_from
15 def set_inputs(self
, inputs
):
17 for k
,v
in inputs
.items():
20 def set_outputs(self
, outputs
):
21 self
.outputs
= outputs
22 for k
,v
in outputs
.items():
26 class FPGetOpA(FPState
):
29 self
.get_op(m
, self
.in_a
, self
.a
, "get_b")
32 class FPGetOpB(FPState
):
35 self
.get_op(m
, self
.in_b
, self
.b
, "special_cases")
38 class FPAddSpecialCases(FPState
):
42 m
.d
.comb
+= s_nomatch
.eq(self
.a
.s
!= self
.b
.s
)
45 m
.d
.comb
+= m_match
.eq(self
.a
.m
== self
.b
.m
)
47 # if a is NaN or b is NaN return NaN
48 with m
.If(self
.a
.is_nan | self
.b
.is_nan
):
50 m
.d
.sync
+= self
.z
.nan(1)
52 # XXX WEIRDNESS for FP16 non-canonical NaN handling
55 ## if a is zero and b is NaN return -b
56 #with m.If(a.is_zero & (a.s==0) & b.is_nan):
58 # m.d.sync += z.create(b.s, b.e, Cat(b.m[3:-2], ~b.m[0]))
60 ## if b is zero and a is NaN return -a
61 #with m.Elif(b.is_zero & (b.s==0) & a.is_nan):
63 # m.d.sync += z.create(a.s, a.e, Cat(a.m[3:-2], ~a.m[0]))
65 ## if a is -zero and b is NaN return -b
66 #with m.Elif(a.is_zero & (a.s==1) & b.is_nan):
68 # m.d.sync += z.create(a.s & b.s, b.e, Cat(b.m[3:-2], 1))
70 ## if b is -zero and a is NaN return -a
71 #with m.Elif(b.is_zero & (b.s==1) & a.is_nan):
73 # m.d.sync += z.create(a.s & b.s, a.e, Cat(a.m[3:-2], 1))
75 # if a is inf return inf (or NaN)
76 with m
.Elif(self
.a
.is_inf
):
78 m
.d
.sync
+= self
.z
.inf(self
.a
.s
)
79 # if a is inf and signs don't match return NaN
80 with m
.If(self
.b
.exp_128
& s_nomatch
):
81 m
.d
.sync
+= self
.z
.nan(1)
83 # if b is inf return inf
84 with m
.Elif(self
.b
.is_inf
):
86 m
.d
.sync
+= self
.z
.inf(self
.b
.s
)
88 # if a is zero and b zero return signed-a/b
89 with m
.Elif(self
.a
.is_zero
& self
.b
.is_zero
):
91 m
.d
.sync
+= self
.z
.create(self
.a
.s
& self
.b
.s
, self
.b
.e
,
94 # if a is zero return b
95 with m
.Elif(self
.a
.is_zero
):
97 m
.d
.sync
+= self
.z
.create(self
.b
.s
, self
.b
.e
, self
.b
.m
[3:-1])
99 # if b is zero return a
100 with m
.Elif(self
.b
.is_zero
):
102 m
.d
.sync
+= self
.z
.create(self
.a
.s
, self
.a
.e
, self
.a
.m
[3:-1])
104 # if a equal to -b return zero (+ve zero)
105 with m
.Elif(s_nomatch
& m_match
& (self
.a
.e
== self
.b
.e
)):
107 m
.d
.sync
+= self
.z
.zero(0)
109 # Denormalised Number checks
111 m
.next
= "denormalise"
114 class FPAddDeNorm(FPState
):
117 # Denormalised Number checks
119 self
.denormalise(m
, self
.a
)
120 self
.denormalise(m
, self
.b
)
123 class FPAddAlignMulti(FPState
):
126 # NOTE: this does *not* do single-cycle multi-shifting,
127 # it *STAYS* in the align state until exponents match
129 # exponent of a greater than b: shift b down
130 with m
.If(self
.a
.e
> self
.b
.e
):
131 m
.d
.sync
+= self
.b
.shift_down()
132 # exponent of b greater than a: shift a down
133 with m
.Elif(self
.a
.e
< self
.b
.e
):
134 m
.d
.sync
+= self
.a
.shift_down()
135 # exponents equal: move to next stage.
140 class FPAddAlignSingle(FPState
):
143 # This one however (single-cycle) will do the shift
146 # XXX TODO: the shifter used here is quite expensive
147 # having only one would be better
149 ediff
= Signal((len(self
.a
.e
), True), reset_less
=True)
150 ediffr
= Signal((len(self
.a
.e
), True), reset_less
=True)
151 m
.d
.comb
+= ediff
.eq(self
.a
.e
- self
.b
.e
)
152 m
.d
.comb
+= ediffr
.eq(self
.b
.e
- self
.a
.e
)
153 with m
.If(ediff
> 0):
154 m
.d
.sync
+= self
.b
.shift_down_multi(ediff
)
155 # exponent of b greater than a: shift a down
156 with m
.Elif(ediff
< 0):
157 m
.d
.sync
+= self
.a
.shift_down_multi(ediffr
)
162 class FPAddStage0(FPState
):
165 """ First stage of add. covers same-sign (add) and subtract
166 special-casing when mantissas are greater or equal, to
167 give greatest accuracy.
170 m
.d
.sync
+= self
.z
.e
.eq(self
.a
.e
)
171 # same-sign (both negative or both positive) add mantissas
172 with m
.If(self
.a
.s
== self
.b
.s
):
174 self
.tot
.eq(Cat(self
.a
.m
, 0) + Cat(self
.b
.m
, 0)),
175 self
.z
.s
.eq(self
.a
.s
)
177 # a mantissa greater than b, use a
178 with m
.Elif(self
.a
.m
>= self
.b
.m
):
180 self
.tot
.eq(Cat(self
.a
.m
, 0) - Cat(self
.b
.m
, 0)),
181 self
.z
.s
.eq(self
.a
.s
)
183 # b mantissa greater than a, use b
186 self
.tot
.eq(Cat(self
.b
.m
, 0) - Cat(self
.a
.m
, 0)),
187 self
.z
.s
.eq(self
.b
.s
)
193 def __init__(self
, width
, single_cycle
=False):
194 FPBase
.__init
__(self
)
196 self
.single_cycle
= single_cycle
198 self
.in_a
= FPOp(width
)
199 self
.in_b
= FPOp(width
)
200 self
.out_z
= FPOp(width
)
202 def get_fragment(self
, platform
=None):
203 """ creates the HDL code-fragment for FPAdd
208 a
= FPNumIn(self
.in_a
, self
.width
)
209 b
= FPNumIn(self
.in_b
, self
.width
)
210 z
= FPNumOut(self
.width
, False)
212 m
.submodules
.fpnum_a
= a
213 m
.submodules
.fpnum_b
= b
214 m
.submodules
.fpnum_z
= z
217 tot
= Signal(w
, reset_less
=True) # sticky/round/guard, {mantissa} result, 1 overflow
220 m
.submodules
.overflow
= of
222 geta
= FPGetOpA("get_a")
223 geta
.set_inputs({"in_a": self
.in_a
})
224 geta
.set_outputs({"a": a
})
225 m
.d
.comb
+= a
.v
.eq(self
.in_a
.v
) # links in_a to a
227 getb
= FPGetOpB("get_b")
228 getb
.set_inputs({"in_b": self
.in_b
})
229 getb
.set_outputs({"b": b
})
230 m
.d
.comb
+= b
.v
.eq(self
.in_b
.v
) # links in_b to b
232 sc
= FPAddSpecialCases("special_cases")
233 sc
.set_inputs({"a": a
, "b": b
})
234 sc
.set_outputs({"z": z
})
236 dn
= FPAddDeNorm("denormalise")
237 dn
.set_inputs({"a": a
, "b": b
})
238 dn
.set_outputs({"a": a
, "b": b
}) # XXX outputs same as inputs
240 if self
.single_cycle
:
241 alm
= FPAddAlignSingle("align")
243 alm
= FPAddAlignMulti("align")
244 alm
.set_inputs({"a": a
, "b": b
})
245 alm
.set_outputs({"a": a
, "b": b
}) # XXX outputs same as inputs
247 add0
= FPAddStage0("add_0")
248 add0
.set_inputs({"a": a
, "b": b
})
249 add0
.set_outputs({"z": z
, "tot": tot
})
256 with m
.State("get_a"):
262 with m
.State("get_b"):
263 #self.get_op(m, self.in_b, b, "special_cases")
267 # special cases: NaNs, infs, zeros, denormalised
268 # NOTE: some of these are unique to add. see "Special Operations"
269 # https://steve.hollasch.net/cgindex/coding/ieeefloat.html
271 with m
.State("special_cases"):
277 with m
.State("denormalise"):
283 with m
.State("align"):
287 # First stage of add. covers same-sign (add) and subtract
288 # special-casing when mantissas are greater or equal, to
289 # give greatest accuracy.
291 with m
.State("add_0"):
295 # Second stage of add: preparation for normalisation.
296 # detects when tot sum is too big (tot[27] is kinda a carry bit)
298 with m
.State("add_1"):
299 m
.next
= "normalise_1"
300 # tot[27] gets set when the sum overflows. shift result down
306 of
.round_bit
.eq(tot
[2]),
307 of
.sticky
.eq(tot
[1] | tot
[0]),
316 of
.round_bit
.eq(tot
[1]),
321 # First stage of normalisation.
323 with m
.State("normalise_1"):
324 self
.normalise_1(m
, z
, of
, "normalise_2")
327 # Second stage of normalisation.
329 with m
.State("normalise_2"):
330 self
.normalise_2(m
, z
, of
, "round")
335 with m
.State("round"):
336 self
.roundz(m
, z
, of
, "corrections")
341 with m
.State("corrections"):
342 self
.corrections(m
, z
, "pack")
347 with m
.State("pack"):
348 self
.pack(m
, z
, "put_z")
353 with m
.State("put_z"):
354 self
.put_z(m
, z
, self
.out_z
, "get_a")
359 if __name__
== "__main__":
360 alu
= FPADD(width
=32)
361 main(alu
, ports
=alu
.in_a
.ports() + alu
.in_b
.ports() + alu
.out_z
.ports())
364 # works... but don't use, just do "python fname.py convert -t v"
365 #print (verilog.convert(alu, ports=[
366 # ports=alu.in_a.ports() + \
367 # alu.in_b.ports() + \