1/*************************************************************************************** 2* Copyright (c) 2020-2021 Institute of Computing Technology, Chinese Academy of Sciences 3* Copyright (c) 2020-2021 Peng Cheng Laboratory 4* 5* XiangShan is licensed under Mulan PSL v2. 6* You can use this software according to the terms and conditions of the Mulan PSL v2. 7* You may obtain a copy of Mulan PSL v2 at: 8* http://license.coscl.org.cn/MulanPSL2 9* 10* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, 11* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, 12* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. 13* 14* See the Mulan PSL v2 for more details. 15***************************************************************************************/ 16 17// This file contains components originally written by Yifei He, see 18// https://github.com/OpenXiangShan/XS-Verilog-Library/tree/main/int_div_radix_4_v1 19// Email of original author: [email protected] 20 21package xiangshan.backend.fu 22 23import org.chipsalliance.cde.config.Parameters 24import chisel3._ 25import chisel3.util._ 26import utils._ 27import utility._ 28import xiangshan._ 29import xiangshan.backend.fu.util.CSA3_2 30 31class SRT16DividerDataModule(len: Int) extends Module { 32 val io = IO(new Bundle() { 33 val src = Vec(2, Input(UInt(len.W))) 34 val valid, sign, kill_w, kill_r, isHi, isW = Input(Bool()) 35 val in_ready = Output(Bool()) 36 val out_valid = Output(Bool()) 37 val out_data = Output(UInt(len.W)) 38 val out_ready = Input(Bool()) 39 }) 40 41 // consts 42 val lzc_width = log2Up(len) 43 val itn_len = 1 + len + 2 + 1 44 45 val (a, d, sign, valid, kill_w, kill_r, isHi, isW) = 46 (io.src(0), io.src(1), io.sign, io.valid, io.kill_w, io.kill_r, io.isHi, io.isW) 47 val in_fire = valid && io.in_ready 48 val out_fire = io.out_ready && io.out_valid 49 val newReq = in_fire 50 val s_idle :: s_pre_0 :: s_pre_1 :: s_iter :: s_post_0 :: s_post_1 :: s_finish :: Nil = Enum(7) 51 val quot_neg_2 :: quot_neg_1 :: quot_0 :: quot_pos_1 :: quot_pos_2 :: Nil = Enum(5) 52 53 54 val state = RegInit((1 << s_idle.litValue.toInt).U(7.W)) 55 56 // reused wires 57// val aNormAbs = Wire(UInt((len + 1).W)) // Inputs of xNormAbs regs below 58// val dNormAbs = Wire(UInt((len + 1).W)) 59 val quotIter = Wire(UInt(len.W)) 60 val quotM1Iter = Wire(UInt(len.W)) 61 val aLZC = Wire(UInt((lzc_width + 1).W)) 62 val dLZC = Wire(UInt((lzc_width + 1).W)) 63 64 val rNext = Wire(UInt(itn_len.W)) 65 val rNextPd = Wire(UInt(itn_len.W)) 66 67 val aInverter = Wire(UInt(len.W)) // results of global inverter 68 val dInverter = Wire(UInt(len.W)) 69 70 val finalIter = Wire(Bool()) 71 val special = Wire(Bool()) 72 73 // reused regs 74// val aNormAbsReg = RegEnable(aNormAbs, newReq | state(s_pre_0) | state(s_post_0)) // reg for normalized a & d and rem & rem+d 75// val dNormAbsReg = RegEnable(dNormAbs, newReq | state(s_pre_0) | state(s_post_0)) 76 val quotIterReg = RegEnable(quotIter, state(s_pre_1) | state(s_iter) | state(s_post_0)) 77 val quotM1IterReg = RegEnable(quotM1Iter, state(s_pre_1) | state(s_iter) | state(s_post_0)) 78 val specialReg = RegEnable(special, state(s_pre_1)) 79 val aReg = RegEnable(a, in_fire) 80 81 when(kill_r) { 82 state := UIntToOH(s_idle, 7) 83 } .elsewhen(state(s_idle) && in_fire && !kill_w) { 84 state := UIntToOH(s_pre_0, 7) 85 } .elsewhen(state(s_pre_0)) { // leading zero detection 86 state := UIntToOH(s_pre_1, 7) 87 } .elsewhen(state(s_pre_1)) { // shift a/b 88 state := Mux(special, UIntToOH(s_post_1, 7), UIntToOH(s_iter, 7)) 89 } .elsewhen(state(s_iter)) { // (ws[j+1], wc[j+1]) = 4(ws[j],wc[j]) - q(j+1)*d 90 state := Mux(finalIter, UIntToOH(s_post_0, 7), UIntToOH(s_iter, 7)) 91 } .elsewhen(state(s_post_0)) { // if rem < 0, rem = rem + d 92 state := UIntToOH(s_post_1, 7) 93 } .elsewhen(state(s_post_1) && out_fire) { 94 state := UIntToOH(s_finish, 7) 95 } .elsewhen(state(s_finish)) { 96 state := UIntToOH(s_idle, 7) 97 } .otherwise { 98 state := state 99 } 100 101 io.in_ready := state(s_idle) 102 aInverter := -Mux(state(s_idle), a, quotIterReg) // 64, 0 103 dInverter := -Mux(state(s_idle), d, quotM1IterReg) // 64, 0 104 105 val aSign = io.sign && a(len - 1) // 1 106 val dSign = io.sign && d(len - 1) 107 val dSignReg = RegEnable(dSign, newReq) 108 109 val aAbs = Mux(aSign, aInverter, a) // 64, 0 110 val dAbs = Mux(dSign, dInverter, d) 111 val aAbsReg = RegEnable(aAbs, newReq) 112 val dAbsReg = RegEnable(dAbs, newReq) 113 114 val aNorm = (aAbsReg(len - 1, 0) << aLZC(lzc_width - 1, 0))(len - 1, 0) // 64, 65 115 val dNorm = (dAbsReg(len - 1, 0) << dLZC(lzc_width - 1, 0))(len - 1, 0) 116 117 val aNormReg = RegEnable(aNorm, state(s_pre_0)) 118 val dNormReg = RegEnable(dNorm, state(s_pre_0)) 119 120// aNormAbs := Mux1H(Seq( 121// state(s_idle) -> Cat(0.U(1.W), aAbs), // 65, 0 122// state(s_pre_0) -> Cat(0.U(1.W), aNorm), // 65, 0 123// state(s_post_0) -> rNext(len + 3, 3) // remainder 65, 64. highest is sign bit 124// )) 125// dNormAbs := Mux1H(Seq( 126// state(s_idle) -> Cat(0.U(1.W), dAbs), 127// state(s_pre_0) -> Cat(0.U(1.W), dNorm), 128// state(s_post_0) -> rNextPd(len + 3, 3) 129// )) 130 131 // Second cycle, state is pre_0 132 // calculate lzc and move div* and lzc diff check if no_iter_needed 133 134 aLZC := PriorityEncoder(aAbsReg(len - 1, 0).asBools.reverse) 135 dLZC := PriorityEncoder(dAbsReg(len - 1, 0).asBools.reverse) 136 val aLZCReg = RegEnable(aLZC, state(s_pre_0)) // 7, 0 137 val dLZCReg = RegEnable(dLZC, state(s_pre_0)) 138 139 val lzcWireDiff = Cat(0.U(1.W), dLZC(lzc_width - 1, 0)) - Cat(0.U(1.W), aLZC(lzc_width - 1, 0)) // 7, 0 140 val lzcRegDiff = Cat(0.U(1.W), dLZCReg(lzc_width - 1, 0)) - Cat(0.U(1.W), aLZCReg(lzc_width - 1, 0)) 141// val lzcDiff = Mux(state(s_pre_0), lzcWireDiff, lzcRegDiff) 142 143 // special case: 144 // divisor is 1 or -1; dividend has less bits than divisor; divisor is zero 145 // s_pre_0: 146 val dIsOne = dLZC(lzc_width - 1, 0).andR 147 val dIsZero = ~dNormReg.orR 148 val aIsZero = RegEnable(aLZC(lzc_width), state(s_pre_0)) 149 val aTooSmall = RegEnable(aLZC(lzc_width) | lzcWireDiff(lzc_width), state(s_pre_0)) 150 special := dIsOne | dIsZero | aTooSmall 151 152 val quotSpecial = Mux(dIsZero, VecInit(Seq.fill(len)(true.B)).asUInt, 153 Mux(aTooSmall, 0.U, 154 Mux(dSignReg, -aReg, aReg) // signed 2^(len-1) 155 )) 156 val remSpecial = Mux(dIsZero || aTooSmall, aReg, 0.U) 157 val quotSpecialReg = RegEnable(quotSpecial, state(s_pre_1)) 158 val remSpecialReg = RegEnable(remSpecial, state(s_pre_1)) 159 160 // s_pre_1 161 val quotSign = Mux(state(s_idle), aSign ^ dSign, true.B) // if not s_idle then must be s_pre_1 & dIsZero, and that we have 162 val rSign = aSign 163 val quotSignReg = RegEnable(quotSign, in_fire | (state(s_pre_1) & dIsZero)) 164 val rSignReg = RegEnable(rSign, in_fire) 165 166 val rShift = lzcRegDiff(0) 167 val oddIter = lzcRegDiff(1) ^ lzcRegDiff(0) 168 val iterNum = Wire(UInt((lzc_width - 2).W)) 169 val iterNumReg = RegEnable(iterNum, state(s_pre_1) | state(s_iter)) 170 iterNum := Mux(state(s_pre_1), (lzcRegDiff + 1.U) >> 2, iterNumReg -% 1.U) 171 finalIter := iterNumReg === 0.U 172 173 val rSumInit = Cat(0.U(3.W), Mux(rShift, Cat(0.U(1.W), aNormReg), Cat(aNormReg, 0.U(1.W)))) //(1, 67), 0.001xxx 174 val rCarryInit = 0.U(itn_len.W) 175 176 val rSumInitTrunc = Cat(0.U(1.W), rSumInit(itn_len - 4, itn_len - 4 - 4 + 1)) // 0.00___ 177 val mInitPos1 = MuxLookup(dNormReg(len-2, len-4), "b00100".U(5.W))( 178 Array( 179 0.U -> "b00100".U(5.W), 180 1.U -> "b00100".U(5.W), 181 2.U -> "b00100".U(5.W), 182 3.U -> "b00110".U(5.W), 183 4.U -> "b00110".U(5.W), 184 5.U -> "b00110".U(5.W), 185 6.U -> "b00110".U(5.W), 186 7.U -> "b01000".U(5.W), 187 ) 188 ) 189 val mInitPos2 = MuxLookup(dNormReg(len-2, len-4), "b01100".U(5.W))( 190 Array( 191 0.U -> "b01100".U(5.W), 192 1.U -> "b01110".U(5.W), 193 2.U -> "b01111".U(5.W), 194 3.U -> "b10000".U(5.W), 195 4.U -> "b10010".U(5.W), 196 5.U -> "b10100".U(5.W), 197 6.U -> "b10110".U(5.W), 198 7.U -> "b10110".U(5.W), 199 ) 200 ) 201 val initCmpPos1 = rSumInitTrunc >= mInitPos1 202 val initCmpPos2 = rSumInitTrunc >= mInitPos2 203 val qInit = Mux(initCmpPos2, UIntToOH(quot_pos_2, 5), Mux(initCmpPos1, UIntToOH(quot_pos_1, 5), UIntToOH(quot_0, 5))) 204 205 // in pre_1 we also obtain m_i + 16u * d for all u 206 // udNeg -> (rud, r2ud) -> (rudPmNeg, r2udPmNeg) 207 val dPos = Cat(0.U(1.W), dNormReg) // +d, 0.1xxx, (1, 64) 208 val dNeg = -Cat(0.U(1.W), dNormReg) // -d, 1.xxxx, (1, 64) 209 // val m = Wire(Vec(4, UInt(7.W))) // we have to sigext them to calculate rqd-m_k 210 211 // index 0 is for q=-2 and 4 is for q=2!!! 212 val mNeg = Wire(Vec(4, UInt(12.W))) // selected m, extended to (6, 6) bits 213 val rudNeg = Wire(Vec(5, UInt(10.W))) // (4, 6) 214 val r2udNeg = Wire(Vec(5, UInt(12.W))) // (6, 6) 215 216 // Selection Block with improved timing 217 val rudPmNeg = Wire(Vec(5, Vec(4, UInt(10.W)))) // -(r*u*d+m_k), (5, 5) bits 218 val r2ws = Wire(UInt(10.W)) // r^2*ws (5, 5) bits 219 val r2wc = Wire(UInt(10.W)) 220 // calculating exact values of w 221 val udNeg = Wire(Vec(5, UInt(itn_len.W))) // (3, 65), 1 signExt'ed Bit 222 // val r3udNeg = Wire(Vec(5, UInt(13.W))) 223 224 // Speculative Block 225 val r2udPmNeg = Wire(Vec(5, Vec(4, UInt(13.W)))) // -(r^2*d*d+m_k), (7, 6) bits. 1st index for q 2nd for m 226 val r3ws = Wire(UInt(13.W)) // r^3*ws, (7, 6) bits 227 val r3wc = Wire(UInt(13.W)) 228 val qSpec = Wire(Vec(5, UInt(5.W))) // 5 speculative results of qNext2 229 // output wires 230 val qNext = Wire(UInt(5.W)) 231 val qNext2 = Wire(UInt(5.W)) 232 val rCarryIter = Wire(UInt(itn_len.W)) // (1, 67) 233 val rSumIter = Wire(UInt(itn_len.W)) 234 // val r3wsIter = Wire(UInt(13.W)) 235 // val r3wcIter = Wire(UInt(13.W)) 236 // Input Regs of whole Spec + Sel + sum adder block 237 val qPrevReg = RegEnable(Mux(state(s_pre_1), qInit, qNext2), state(s_pre_1) | state(s_iter)) 238 val rSumReg = RegEnable(Mux(state(s_pre_1), rSumInit, rSumIter), state(s_pre_1) | state(s_iter)) // (1, 67) 239 val rCarryReg = RegEnable(Mux(state(s_pre_1), rCarryInit, rCarryIter), state(s_pre_1) | state(s_iter)) 240 241 // Give values to the regs and wires above... 242 val dForLookup = dPos(len-2, len-4) 243 mNeg := VecInit(Cat(SignExt(MuxLookup(dNormReg(len-2, len-4), "b00000000".U(7.W))(mLookUpTable2.minus_m(0)), 11), 0.U(1.W)), // (2, 5) -> (6, 6) 244 Cat(SignExt(MuxLookup(dNormReg(len-2, len-4), "b00000000".U(7.W))(mLookUpTable2.minus_m(1)), 10) ,0.U(2.W)), // (3, 4) -> (6, 6) 245 Cat(SignExt(MuxLookup(dNormReg(len-2, len-4), "b00000000".U(7.W))(mLookUpTable2.minus_m(2)), 10) ,0.U(2.W)), 246 Cat(SignExt(MuxLookup(dNormReg(len-2, len-4), "b00000000".U(7.W))(mLookUpTable2.minus_m(3)), 11) ,0.U(1.W)) 247 ) 248 udNeg := VecInit( Cat(SignExt(dPos, 66), 0.U(2.W)), 249 Cat(SignExt(dPos, 67), 0.U(1.W)), 250 0.U, 251 Cat(SignExt(dNeg, 67), 0.U(1.W)), 252 Cat(SignExt(dNeg, 66), 0.U(2.W)) 253 ) 254 255 rudNeg := VecInit(Seq.tabulate(5){i => udNeg(i)(itn_len-2, itn_len-11)}) 256 r2udNeg := VecInit(Seq.tabulate(5){i => udNeg(i)(itn_len-2, itn_len-13)}) 257 // r3udNeg := VecInit(Seq.tabulate(5){i => udNeg(i)(itn_len-2, itn_len-13)}) 258 rudPmNeg := VecInit(Seq.tabulate(5){i => VecInit(Seq.tabulate(4){ j => SignExt(rudNeg(i)(9, 1), 10) + mNeg(j)(10, 1)})}) 259 r2udPmNeg := VecInit(Seq.tabulate(5){i => VecInit(Seq.tabulate(4){ j => SignExt(r2udNeg(i), 13) + SignExt(mNeg(j), 13)})}) 260 r3ws := rSumReg(itn_len-1, itn_len-13) 261 r3wc := rCarryReg(itn_len-1, itn_len-13) 262 263 r2ws := rSumReg(itn_len-1, itn_len-10) 264 r2wc := rCarryReg(itn_len-1, itn_len-10) 265 266 val udNegReg = RegEnable(udNeg, state(s_pre_1)) 267// val rudNegReg = RegEnable(rudNeg, state(s_pre_1)) 268 val rudPmNegReg = RegEnable(rudPmNeg, state(s_pre_1)) 269 val r2udPmNegReg = RegEnable(r2udPmNeg, state(s_pre_1)) 270 271 def DetectSign(signs: UInt, name: String): UInt = { 272 val qVec = Wire(Vec(5, Bool())).suggestName(name) 273 qVec(quot_neg_2) := signs(0) && signs(1) && signs(2) 274 qVec(quot_neg_1) := ~signs(0) && signs(1) && signs(2) 275 qVec(quot_0) := signs(2) && ~signs(1) 276 qVec(quot_pos_1) := signs(3) && ~signs(2) && ~signs(1) 277 qVec(quot_pos_2) := ~signs(3) && ~signs(2) && ~signs(1) 278 qVec.asUInt 279 } 280 // Selection block 281 val signs = VecInit(Seq.tabulate(4){ i => { 282 val csa = Module(new CSA3_2(10)).suggestName(s"csa_sel_${i}") 283 csa.io.in(0) := r2ws 284 csa.io.in(1) := r2wc 285 csa.io.in(2) := Mux1H(qPrevReg, rudPmNegReg.toSeq)(i) // rudPmNeg(OHToUInt(qPrevReg))(i) 286 287 (csa.io.out(0) + (csa.io.out(1)(8, 0) << 1))(9) 288 }}) 289 qNext := DetectSign(signs.asUInt, s"sel_q") 290 val csaWide1 = Module(new CSA3_2(itn_len)).suggestName("csa_sel_wide_1") 291 val csaWide2 = Module(new CSA3_2(itn_len)).suggestName("csa_sel_wide_2") 292 csaWide1.io.in(0) := rSumReg << 2 293 csaWide1.io.in(1) := rCarryReg << 2 294 csaWide1.io.in(2) := Mux1H(qPrevReg, udNegReg.toSeq) << 2//udNeg(OHToUInt(qPrevReg)) << 2 295 csaWide2.io.in(0) := csaWide1.io.out(0) << 2 296 csaWide2.io.in(1) := (csaWide1.io.out(1) << 1)(itn_len-1, 0) << 2 297 csaWide2.io.in(2) := Mux1H(qNext, udNegReg.toSeq) << 2 // udNeg(OHToUInt(qNext)) << 2 298 rSumIter := Mux(~oddIter & finalIter, csaWide1.io.out(0), csaWide2.io.out(0)) 299 rCarryIter := Mux(~oddIter & finalIter, (csaWide1.io.out(1) << 1)(itn_len-1, 0), (csaWide2.io.out(1) << 1)(itn_len-1, 0)) 300 // r3wsIter := r3udNeg(OHToUInt(qNext)) 301 // r3wcIter := (csaWide1.io.out(0)(itn_len-3, itn_len-16) + (csaWide1.io.out(1) << 1)(itn_len-3, itn_len-16))(13,1) 302 // Speculative block 303 qSpec := VecInit(Seq.tabulate(5){ q_spec => { 304 val csa1 = Module(new CSA3_2(13)).suggestName(s"csa_spec_${q_spec}") 305 csa1.io.in(0) := r3ws 306 csa1.io.in(1) := r3wc 307 csa1.io.in(2) := SignExt(udNegReg(q_spec)(itn_len-2, itn_len-11), 13) // (4, 6) -> (7, 6) 308 val signs2 = VecInit(Seq.tabulate(4){ i => { 309 val csa2 = Module(new CSA3_2(13)).suggestName(s"csa_spec_${q_spec}_${i}") 310 csa2.io.in(0) := csa1.io.out(0) 311 csa2.io.in(1) := (csa1.io.out(1) << 1)(12, 0) 312 csa2.io.in(2) := Mux1H(qPrevReg, r2udPmNegReg.toSeq)(i) // r2udPmNeg(OHToUInt(qPrevReg))(i) 313 (csa2.io.out(0) + (csa2.io.out(1)(11, 0) << 1))(12) 314 }}) 315 val qVec2 = DetectSign(signs2.asUInt, s"spec_q_${q_spec}") 316 qVec2 317 }}) 318 // qNext2 := qSpec(OHToUInt(qNext)) // TODO: Use Mux1H!! 319 320 qNext2 := Mux1H(qNext, qSpec.toSeq) 321 322 // on the fly quotient conversion 323 val quotHalfIter = Wire(UInt(64.W)) 324 val quotM1HalfIter = Wire(UInt(64.W)) 325 val quotIterNext = Wire(UInt(64.W)) 326 val quotM1IterNext = Wire(UInt(64.W)) 327 def OTFC(q: UInt, quot: UInt, quotM1: UInt): (UInt, UInt) = { 328 val quotNext = Mux1H(Seq( 329 q(quot_pos_2) -> (quot << 2 | "b10".U), 330 q(quot_pos_1) -> (quot << 2 | "b01".U), 331 q(quot_0) -> (quot << 2 | "b00".U), 332 q(quot_neg_1) -> (quotM1 << 2 | "b11".U), 333 q(quot_neg_2) -> (quotM1 << 2 | "b10".U) 334 )) 335 val quotM1Next = Mux1H(Seq( 336 q(quot_pos_2) -> (quot << 2 | "b01".U), 337 q(quot_pos_1) -> (quot << 2 | "b00".U), 338 q(quot_0) -> (quotM1 << 2 | "b11".U), 339 q(quot_neg_1) -> (quotM1 << 2 | "b10".U), 340 q(quot_neg_2) -> (quotM1 << 2 | "b01".U) 341 )) 342 (quotNext(len-1, 0), quotM1Next(len-1, 0)) 343 } 344 quotHalfIter := OTFC(qPrevReg, quotIterReg, quotM1IterReg)._1 345 quotM1HalfIter := OTFC(qPrevReg, quotIterReg, quotM1IterReg)._2 346 quotIterNext := Mux(~oddIter && finalIter, quotHalfIter, OTFC(qNext, quotHalfIter, quotM1HalfIter)._1) 347 quotM1IterNext := Mux(~oddIter && finalIter, quotM1HalfIter, OTFC(qNext, quotHalfIter, quotM1HalfIter)._2) 348 // quotIter := Mux(state(s_pre_1), 0.U(len.W), 349 // Mux(state(s_iter), quotIterNext, 350 // Mux(quotSignReg, aInverter, quotIterReg))) 351 // quotM1Iter := Mux(state(s_pre_1), 352 // 0.U(len.W), Mux(state(s_iter), quotM1IterNext, 353 // Mux(quotSignReg, dInverter, quotM1IterReg))) 354 355 quotIter := Mux(state(s_iter), quotIterNext, 356 Mux(state(s_pre_1), 0.U(len.W), 357 Mux(quotSignReg, aInverter, quotIterReg))) 358 quotM1Iter := Mux(state(s_iter), quotM1IterNext, 359 Mux(state(s_pre_1), 0.U(len.W), 360 Mux(quotSignReg, dInverter, quotM1IterReg))) 361 // finally, to the recovery stages! 362 363 when(rSignReg) { 364 rNext := ~rSumReg + ~rCarryReg + 2.U 365 rNextPd := ~rSumReg + ~rCarryReg + ~Cat(0.U(1.W), dNormReg, 0.U(3.W)) + 3.U 366 } .otherwise { 367 rNext := rSumReg + rCarryReg 368 rNextPd := rSumReg + rCarryReg + Cat(0.U(1.W), dNormReg, 0.U(3.W)) 369 } 370 val rNextReg = RegEnable(rNext(len + 3, 3), state(s_post_0)) 371 val rNextPdReg = RegEnable(rNextPd(len + 3, 3), state(s_post_0)) 372 dontTouch(rNextReg) 373 // post_1 374 val r = rNextReg 375 val rPd = rNextPdReg 376 val rIsZero = ~(r.orR) 377 val needCorr = Mux(rSignReg, ~r(len) & r.orR, r(len)) // when we get pos rem for a<0 or neg rem for a>0 378 val rPreShifted = Mux(needCorr, rPd, r) 379 val rightShifter = Module(new RightShifter(len, lzc_width)) 380 rightShifter.io.in := rPreShifted 381 rightShifter.io.shiftNum := dLZCReg 382 rightShifter.io.msb := Mux(~(rPreShifted.orR), 0.U, rSignReg) 383 val rShifted = rightShifter.io.out 384 val rFinal = RegEnable(Mux(specialReg, remSpecialReg, rShifted), state(s_post_1))// right shifted remainder. shift by the number of bits divisor is shifted 385 val qFinal = RegEnable(Mux(specialReg, quotSpecialReg, Mux(needCorr, quotM1IterReg, quotIterReg)), state(s_post_1)) 386 val res = Mux(isHi, rFinal, qFinal) 387 io.out_data := Mux(isW, 388 SignExt(res(31, 0), len), 389 res 390 ) 391 io.in_ready := state(s_idle) 392 io.out_valid := state(s_post_1) 393 394} 395 396object mLookUpTable2 { 397 // Usage : 398 // result := decoder(QMCMinimizer, index, mLookupTable.xxx) 399 val minus_m = Seq( 400 Array( // -m[-1] 401 0.U -> "b00_11010".U(7.W), 402 1.U -> "b00_11110".U(7.W), 403 2.U -> "b01_00000".U(7.W), 404 3.U -> "b01_00100".U(7.W), 405 4.U -> "b01_00110".U(7.W), 406 5.U -> "b01_01010".U(7.W), 407 6.U -> "b01_01100".U(7.W), 408 7.U -> "b01_10000".U(7.W) 409 ), 410 Array( // -m[0] 411 0.U -> "b000_0100".U(7.W), 412 1.U -> "b000_0110".U(7.W), 413 2.U -> "b000_0110".U(7.W), 414 3.U -> "b000_0110".U(7.W), 415 4.U -> "b000_1000".U(7.W), 416 5.U -> "b000_1000".U(7.W), 417 6.U -> "b000_1000".U(7.W), 418 7.U -> "b000_1000".U(7.W) 419 ), 420 Array( //-m[1] 421 0.U -> "b111_1101".U(7.W), 422 1.U -> "b111_1100".U(7.W), 423 2.U -> "b111_1100".U(7.W), 424 3.U -> "b111_1100".U(7.W), 425 4.U -> "b111_1011".U(7.W), 426 5.U -> "b111_1010".U(7.W), 427 6.U -> "b111_1010".U(7.W), 428 7.U -> "b111_1010".U(7.W) 429 ), 430 Array( //-m[2] 431 0.U -> "b11_01000".U(7.W), 432 1.U -> "b11_00100".U(7.W), 433 2.U -> "b11_00010".U(7.W), 434 3.U -> "b10_11110".U(7.W), 435 4.U -> "b10_11100".U(7.W), 436 5.U -> "b10_11000".U(7.W), 437 6.U -> "b10_10110".U(7.W), 438 7.U -> "b10_10010".U(7.W) 439 )) 440} 441 442class SRT16Divider(len: Int)(implicit p: Parameters) extends AbstractDivider(len) { 443 444 val newReq = io.in.fire 445 446 val uop = io.in.bits.uop 447 val uopReg = RegEnable(uop, newReq) 448 val ctrlReg = RegEnable(ctrl, newReq) 449 450 val divDataModule = Module(new SRT16DividerDataModule(len)) 451 452 val kill_w = uop.robIdx.needFlush(io.redirectIn) 453 val kill_r = !divDataModule.io.in_ready && uopReg.robIdx.needFlush(io.redirectIn) 454 455 divDataModule.io.src(0) := io.in.bits.src(0) 456 divDataModule.io.src(1) := io.in.bits.src(1) 457 divDataModule.io.valid := io.in.valid 458 divDataModule.io.sign := sign 459 divDataModule.io.kill_w := kill_w 460 divDataModule.io.kill_r := kill_r 461 divDataModule.io.isHi := ctrlReg.isHi 462 divDataModule.io.isW := ctrlReg.isW 463 divDataModule.io.out_ready := io.out.ready 464 465 io.in.ready := divDataModule.io.in_ready 466 io.out.valid := divDataModule.io.out_valid 467 io.out.bits.data := divDataModule.io.out_data 468 io.out.bits.uop := uopReg 469} 470 471class DividerWrapper(len: Int)(implicit p: Parameters) extends FunctionUnit(len) { 472 val div = Module(new SRT16Divider(len)) 473 474 div.io <> io 475 476 val func = io.in.bits.uop.ctrl.fuOpType 477 val (src1, src2) = ( 478 io.in.bits.src(0)(XLEN - 1, 0), 479 io.in.bits.src(1)(XLEN - 1, 0) 480 ) 481 482 val isW = MDUOpType.isW(func) 483 val isH = MDUOpType.isH(func) 484 val isDivSign = MDUOpType.isDivSign(func) 485 val divInputFunc = (x: UInt) => Mux( 486 isW, 487 Mux(isDivSign, 488 SignExt(x(31, 0), XLEN), 489 ZeroExt(x(31, 0), XLEN) 490 ), 491 x 492 ) 493 div.io.in.bits.src(0) := divInputFunc(src1) 494 div.io.in.bits.src(1) := divInputFunc(src2) 495 div.ctrl.isHi := isH 496 div.ctrl.isW := isW 497 div.ctrl.sign := isDivSign 498} 499