- mainAlignedSigC.eq(extComplSigC >>> CAlignDist)
- localparam CGrainAlign = (sigSumWidth - sigWidth - 1) & 3;
- wire [(sigWidth + CGrainAlign):0] grainAlignedSigC = sigC<<CGrainAlign;
- wire [(sigWidth + CGrainAlign)/4:0] reduced4SigC;
- compressBy4#(sigWidth + 1 + CGrainAlign)
- compressBy4_sigC(grainAlignedSigC, reduced4SigC);
- localparam CExtraMaskHiBound = (sigSumWidth - 1)/4;
- localparam CExtraMaskLoBound = (sigSumWidth - sigWidth - 1)/4;
- wire [(CExtraMaskHiBound - CExtraMaskLoBound - 1):0] CExtraMask;
- lowMaskHiLo#(clog2(sigSumWidth) - 2, CExtraMaskHiBound, CExtraMaskLoBound)
- lowMask_CExtraMask(CAlignDist[(clog2(sigSumWidth) - 1):2], CExtraMask);
- wire reduced4CExtra = |(reduced4SigC & CExtraMask);
- wire [(sigSumWidth - 1):0] alignedSigC =
- {mainAlignedSigC>>3,
- doSubMags ? (&mainAlignedSigC[2:0]) && !reduced4CExtra
- : (|mainAlignedSigC[2:0]) || reduced4CExtra};
- /*------------------------------------------------------------------------
- *------------------------------------------------------------------------*/
- wire isNaNAOrB = isNaNA || isNaNB;
- wire isNaNAny = isNaNAOrB || isNaNC;
- wire isInfAOrB = isInfA || isInfB;
- wire invalidProd = (isInfA && isZeroB) || (isZeroA && isInfB);
- wire notSigNaN_invalidExc =
- invalidProd || (!isNaNAOrB && isInfAOrB && isInfC && doSubMags);
- wire invalidExc =
- isSigNaNA || isSigNaNB || isSigNaNC || notSigNaN_invalidExc;
- wire notNaN_addZeros = (isZeroA || isZeroB) && isZeroC;
- wire specialCase = isNaNAny || isInfAOrB || isInfC || notNaN_addZeros;
- wire specialNotNaN_signOut =
- (isInfAOrB && signProd) || (isInfC && opSignC)
- || (notNaN_addZeros && !roundingMode_min && signProd && opSignC)
- || (notNaN_addZeros && roundingMode_min && (signProd || opSignC));
- `ifdef HardFloat_propagateNaNPayloads
- wire signNaN;
- wire [(sigWidth - 2):0] fractNaN;
- propagateFloatNaN_mulAdd#(sigWidth)
- propagateNaN(
- control,
- op,
- isNaNA,
- signA,
- sigA[(sigWidth - 2):0],
- isNaNB,
- signB,
- sigB[(sigWidth - 2):0],
- invalidProd,
- isNaNC,
- signC,
- sigC[(sigWidth - 2):0],
- signNaN,
- fractNaN
- );
- wire isNaNOut = isNaNAny || notSigNaN_invalidExc;
- wire special_signOut =
- isNaNAny || notSigNaN_invalidExc ? signNaN : specialNotNaN_signOut;
- `else
- wire special_signOut = specialNotNaN_signOut;
- `endif
- /*------------------------------------------------------------------------
- *------------------------------------------------------------------------*/
- assign mulAddA = sigA;
- assign mulAddB = sigB;
- assign mulAddC = alignedSigC[prodWidth:1];
- assign intermed_compactState =
- {specialCase,
- invalidExc || (!specialCase && signProd ),
- `ifdef HardFloat_propagateNaNPayloads
- isNaNOut || (!specialCase && doSubMags ),
- `else
- isNaNAny || (!specialCase && doSubMags ),
- `endif
- isInfAOrB || isInfC || (!specialCase && CIsDominant ),
- notNaN_addZeros || (!specialCase && alignedSigC[0]),
- special_signOut};
- assign intermed_sExp = sExpSum;
- assign intermed_CDom_CAlignDist = CAlignDist[(clog2(sigWidth + 1) - 1):0];
- assign intermed_highAlignedSigC =
- `ifdef HardFloat_propagateNaNPayloads
- isNaNOut ? fractNaN :
- `endif
+ mainAlignedSigC.eq(extComplSigC >>> CAlignDist),
+ grainAlignedSigC.eq(sigC<<CGrainAlign),
+ compressBy4_sigC.in.eq(grainAlignedSigC),
+ reduced4SigC.eq(compressBy4_sigC.out),
+ lowMaskHiLo.in.eq(CAlignDist[2:(clog2(sigSumWidth)]),
+ CExtraMask.eq(lowMaskHiLo.out),
+ reduced4CExtra.eq((reduced4SigC & CExtraMask).bool()),
+ alignedSigC = Cat(
+ Mux(doSubMags, (mainAlignedSigC[:3]=0b111) & ~reduced4CExtra,
+ (mainAlignedSigC[:3].bool()) | reduced4CExtra),
+ mainAlignedSigC>>3)
+ ]
+ #/*-------------------------------------------------------------------
+ #*-------------------------------------------------------------------*/
+ isNaNAOrB = Signal(reset_less=True)
+ isNaNAny = Signal(reset_less=True)
+ isInfAOrB = Signal(reset_less=True)
+ invalidProd = Signal(reset_less=True)
+ notSigNaN_invalidExc = Signal(reset_less=True)
+ invalidExc = Signal(reset_less=True)
+ notNaN_addZeros = Signal(reset_less=True)
+ specialCase = Signal(reset_less=True)
+ specialNotNaN_signOut = Signal(reset_less=True)
+ comb += [
+ isNaNAOrB.eq(isNaNA | isNaNB),
+ isNaNAny.eq(isNaNAOrB | isNaNC),
+ isInfAOrB.eq(isInfA | isInfB),
+ invalidProd.eq((isInfA & isZeroB) | (isZeroA & isInfB)),
+ notSigNaN_invalidExc.eq(
+ invalidProd | (!isNaNAOrB & isInfAOrB & isInfC & doSubMags)),
+ invalidExc.eq(
+ isSigNaNA | isSigNaNB | isSigNaNC | notSigNaN_invalidExc),
+ notNaN_addZeros.eq((isZeroA | isZeroB) && isZeroC),
+ specialCase.eq(isNaNAny | isInfAOrB | isInfC | notNaN_addZeros),
+ specialNotNaN_signOut.eq(
+ (isInfAOrB & signProd) | (isInfC & opSignC)
+ | (notNaN_addZeros & !roundingMode_min & signProd & opSignC)
+ | (notNaN_addZeros & roundingMode_min & (signProd | opSignC)))
+ ]
+
+ special_signOut = specialNotNaN_signOut;
+ #/*-------------------------------------------------------------------
+ # *-------------------------------------------------------------------*/
+ mulAddA = sigA;
+ mulAddB = sigB;
+ mulAddC = Signal(prodWidth, reset_less=True)
+ intermed_compactState = Signal(6, reset_less=True)
+
+ comb += mulAddC.eq(alignedSigC[1:prodWidth+1])
+ comb += intermed_compactState.eq(Cat(
+ special_signOut,
+ notNaN_addZeros | (~specialCase & alignedSigC[0]),
+ isInfAOrB | isInfC | (~specialCase & CIsDominant ),
+ isNaNAny | (~specialCase & doSubMags ),
+ invalidExc | (~specialCase & signProd ),
+ specialCase,))
+ intermed_sExp = sExpSum;
+ intermed_CDom_CAlignDist = CAlignDist[(clog2(sigWidth + 1) - 1):0];
+ intermed_highAlignedSigC =