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// The "SRT4DividerDataModule" in this file is a scala rewrite of SRT4 divider 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 chipsalliance.rocketchip.config.Parameters 24import chisel3._ 25import chisel3.util._ 26import utils.SignExt 27import xiangshan.backend.fu.util.CSA3_2 28 29/** A Radix-4 SRT Integer Divider 30 * 31 * 2 ~ (5 + (len+3)/2) cycles are needed for each division. 32 */ 33class SRT4DividerDataModule(len: Int) extends Module { 34 val io = IO(new Bundle() { 35 val src = Vec(2, Input(UInt(len.W))) 36 val valid, sign, kill_w, kill_r, isHi, isW = Input(Bool()) 37 val in_ready = Output(Bool()) 38 val out_valid = Output(Bool()) 39 val out_data = Output(UInt(len.W)) 40 val out_ready = Input(Bool()) 41 }) 42 43 // consts 44 val lzc_width = log2Up(len) 45 val itn_len = 1 + len + 2 + 1 46 require(lzc_width == 6) 47 48 val (a, d, sign, valid, kill_w, kill_r, isHi, isW) = 49 (io.src(0), io.src(1), io.sign, io.valid, io.kill_w, io.kill_r, io.isHi, io.isW) 50 val in_fire = valid && io.in_ready 51 val out_fire = io.out_ready && io.out_valid 52 val newReq = in_fire 53 val startHandShake = io.in_ready && valid 54 val s_idle :: s_pre_0 :: s_pre_1 :: s_iter :: s_post_0 :: s_post_1 :: s_finish :: Nil = Enum(7) 55 56 val state = RegInit(UIntToOH(s_idle, 7)) 57 58 val quot_neg_2 :: quot_neg_1 :: quot_0 :: quot_pos_1 :: quot_pos_2 :: Nil = Enum(5) 59 60 val finished = state(s_finish) 61 62 // reused wire declarations 63 val aIsZero = Wire(Bool()) 64 val dIsZero = Wire(Bool()) 65 val aTooSmall = Wire(Bool()) // this is output of reg! 66 val noIter = Wire(Bool()) // this is output of reg! 67 val finalIter = Wire(Bool()) 68 val aLZC = Wire(UInt((lzc_width + 1).W)) 69 val dLZC = Wire(UInt((lzc_width + 1).W)) 70 val aNormAbs = Wire(UInt((len + 1).W)) 71 val dNormAbs = Wire(UInt((len + 1).W)) 72 val aInverter = Wire(UInt(len.W)) // results of global inverter 73 val dInverter = Wire(UInt(len.W)) 74 75 val rPreShifted = Wire(UInt((len + 1).W)) 76 77 val quotIter = Wire(UInt(len.W)) 78 val quotM1Iter = Wire(UInt(len.W)) 79 val qIterEnd = Wire(UInt(5.W)) 80 81 val rNext = Wire(UInt(itn_len.W)) 82 val rNextPd = Wire(UInt(itn_len.W)) // non-redundant remainder plus d, 68, 67 83 //reused ctrl regs 84 85 //reused other regs 86 val aNormAbsReg = RegEnable(aNormAbs, startHandShake | state(s_pre_0) | state(s_post_0)) // reg for normalized a & d and rem & rem+d 87 val dNormAbsReg = RegEnable(dNormAbs, startHandShake | state(s_pre_0) | state(s_post_0)) 88 val quotIterReg = RegEnable(quotIter, state(s_pre_1) | state(s_iter) | state(s_post_0)) 89 val quotM1IterReg = RegEnable(quotM1Iter, state(s_pre_1) | state(s_iter) | state(s_post_0)) 90 91 when(kill_r) { 92 state := UIntToOH(s_idle, 7) 93 } .elsewhen(state(s_idle) && in_fire && !kill_w) { 94 state := UIntToOH(s_pre_0, 7) 95 } .elsewhen(state(s_pre_0)) { // leading zero detection 96 state := UIntToOH(s_pre_1, 7) 97 } .elsewhen(state(s_pre_1)) { // shift a/b 98 state := Mux(dIsZero | aTooSmall | noIter, UIntToOH(s_post_0, 7), UIntToOH(s_iter, 7)) 99 } .elsewhen(state(s_iter)) { // (ws[j+1], wc[j+1]) = 4(ws[j],wc[j]) - q(j+1)*d 100 state := Mux(finalIter, UIntToOH(s_post_0, 7), UIntToOH(s_iter, 7)) 101 } .elsewhen(state(s_post_0)) { // if rem < 0, rem = rem + d 102 state := UIntToOH(s_post_1, 7) 103 } .elsewhen(state(s_post_1)) { 104 state := UIntToOH(s_finish, 7) 105 } .elsewhen(state(s_finish) && out_fire) { 106 state := UIntToOH(s_idle, 7) 107 } .otherwise { 108 state := state 109 } 110 111 // First cycle: 112 // State is idle, we gain absolute value of a and b, using global inverter 113 114 io.in_ready := state(s_idle) 115 116 aInverter := -Mux(state(s_idle), a, quotIterReg) // 64, 0 117 dInverter := -Mux(state(s_idle), d, quotM1IterReg) // 64, 0 118 119 val aSign = io.sign && a(len - 1) // 1 120 val dSign = io.sign && d(len - 1) 121 122 val aAbs = Mux(aSign, aInverter, a) // 64, 0 123 val dAbs = Mux(dSign, dInverter, d) 124 val aNorm = (aNormAbsReg(len - 1, 0) << aLZC(lzc_width - 1, 0))(len - 1, 0) // 64, 65 125 val dNorm = (dNormAbsReg(len - 1, 0) << dLZC(lzc_width - 1, 0))(len - 1, 0) 126 127 aNormAbs := Mux1H(Seq( 128 state(s_idle) -> Cat(0.U(1.W), aAbs), // 65, 0 129 state(s_pre_0) -> Cat(0.U(1.W), aNorm), // 65, 0 130 state(s_post_0) -> rNext(len + 3, 3) // remainder 65, 64. highest is sign bit 131 )) 132 dNormAbs := Mux1H(Seq( 133 state(s_idle) -> Cat(0.U(1.W), dAbs), 134 state(s_pre_0) -> Cat(0.U(1.W), dNorm), 135 state(s_post_0) -> rNextPd(len + 3, 3) 136 )) 137 138 // Second cycle, state is pre_0 139 // calculate lzc and move div* and lzc diff check if no_iter_needed 140 141 aLZC := PriorityEncoder(aNormAbsReg(len - 1, 0).asBools().reverse) 142 dLZC := PriorityEncoder(dNormAbsReg(len - 1, 0).asBools().reverse) 143 val aLZCReg = RegEnable(aLZC, state(s_pre_0)) // 7, 0 144 val dLZCReg = RegEnable(dLZC, state(s_pre_0)) 145 146 147 148 val lzcWireDiff = Cat(0.U(1.W), dLZC(lzc_width - 1, 0)) - Cat(0.U(1.W), aLZC(lzc_width - 1, 0)) // 7, 0 149 val lzcRegDiff = Cat(0.U(1.W), dLZCReg(lzc_width - 1, 0)) - Cat(0.U(1.W), aLZCReg(lzc_width - 1, 0)) 150 val lzcDiff = Mux(state(s_pre_0), lzcWireDiff, lzcRegDiff) 151 aIsZero := aLZC(lzc_width) // this is state pre_0 152 dIsZero := dLZCReg(lzc_width) // this is pre_1 and all stages after 153 val dIsOne = dLZC(lzc_width - 1, 0).andR() // this is pre_0 154 val noIterReg = RegEnable(dIsOne & aNormAbsReg(len - 1), state(s_pre_0)) // This means dividend has lzc 0 so iter is 17 155 noIter := noIterReg 156 val aTooSmallReg = RegEnable(aIsZero | lzcDiff(lzc_width), state(s_pre_0)) // a is zero or a smaller than d 157 aTooSmall := aTooSmallReg 158 159 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 160 val rSign = aSign 161 val quotSignReg = RegEnable(quotSign, startHandShake | (state(s_pre_1) & dIsZero)) 162 val rSignReg = RegEnable(rSign, startHandShake) 163 164 val rShift = lzcDiff(0) // odd lzc diff, for SRT4 165 val rightShifted = Wire(UInt(len.W)) 166 val rSumInit = Mux(aTooSmallReg | aIsZero, Cat(0.U(1.W), rightShifted, 0.U(3.W)), // right shift the dividend (which is already l-shifted) 167 Mux(noIterReg, 0.U(itn_len.W), // 168 Cat(0.U(3.W), 169 Mux(rShift, Cat(0.U(1.W), aNormAbsReg(len - 1, 0)), Cat(aNormAbsReg(len - 1, 0), 0.U(1.W))) 170 ) // Normal init value. 68, 67; For even lzcDiff, 0.001xxx0; for odd lzcDiff 0.0001xxx 171 ) 172 ) // state is s_pre_1 173 val rCarryInit = 0.U(itn_len.W) 174 175 val rightShifter = Module(new RightShifter(len, lzc_width)) 176 rightShifter.io.in := Mux(state(s_pre_1), aNormAbsReg(len - 1, 0), rPreShifted(len - 1, 0)) 177 rightShifter.io.shiftNum := Mux(state(s_pre_1), aLZCReg, 178 Mux(aTooSmallReg | dIsZero, 0.U(lzc_width.W), dLZCReg)) 179 rightShifter.io.msb := state(s_post_1) & rSignReg & rPreShifted(len) 180 rightShifted := rightShifter.io.out 181 182 // obtaining 1st quotient 183 val rSumInitTrunc = Cat(0.U(1.W), rSumInit(itn_len - 4, itn_len - 4 - 4 + 1)) // 0.00___ 184 val mInitPos1 = MuxLookup(dNormAbsReg(len - 2, len - 2 - 3 + 1), "b00100".U(5.W), 185 Array( 186 0.U -> "b00100".U(5.W), 187 1.U -> "b00100".U(5.W), 188 2.U -> "b00100".U(5.W), 189 3.U -> "b00110".U(5.W), 190 4.U -> "b00110".U(5.W), 191 5.U -> "b00110".U(5.W), 192 6.U -> "b00110".U(5.W), 193 7.U -> "b01000".U(5.W), 194 ) 195 ) 196 val mInitPos2 = MuxLookup(dNormAbsReg(len - 2, len - 2 - 3 + 1), "b01100".U(5.W), 197 Array( 198 0.U -> "b01100".U(5.W), 199 1.U -> "b01110".U(5.W), 200 2.U -> "b01111".U(5.W), 201 3.U -> "b10000".U(5.W), 202 4.U -> "b10010".U(5.W), 203 5.U -> "b10100".U(5.W), 204 6.U -> "b10110".U(5.W), 205 7.U -> "b10110".U(5.W), 206 ) 207 ) 208 val initCmpPos1 = rSumInitTrunc >= mInitPos1 209 val initCmpPos2 = rSumInitTrunc >= mInitPos2 210 val qInit = Mux(initCmpPos2, UIntToOH(quot_pos_2, 5), Mux(initCmpPos1, UIntToOH(quot_pos_1, 5), UIntToOH(quot_0, 5))) 211 val qPrev = Mux(state(s_pre_1), qInit, qIterEnd) 212 val qPrevReg = RegEnable(qPrev, state(s_pre_1) | state(s_iter)) 213 val specialDivisorReg = RegEnable(dNormAbsReg(len - 2, len - 2 - 3 + 1) === 0.U, state(s_pre_1)) // d=0.1000xxx 214 215 // rCarry and rSum in Iteration 216 val qXd = Mux1H(Seq( 217 qPrevReg(quot_neg_2) -> Cat(dNormAbsReg(len - 1, 0), 0.U(4.W)), // 68, 67 1.xxxxx0000 218 qPrevReg(quot_neg_1) -> Cat(0.U(1.W), dNormAbsReg(len - 1, 0), 0.U(3.W)), // 0.1xxxxx000 219 qPrevReg(quot_0) -> 0.U(itn_len.W), 220 qPrevReg(quot_pos_1) -> ~Cat(0.U(1.W), dNormAbsReg(len - 1, 0), 0.U(3.W)), // don't forget to plus 1 later 221 qPrevReg(quot_pos_2) -> ~Cat(dNormAbsReg(len - 1, 0), 0.U(4.W)) // don't forget to plus 1 later 222 )) 223 val csa = Module(new CSA3_2(itn_len)) 224 225 val rSumIter = csa.io.out(0) 226 val rCarryIter = Cat(csa.io.out(1)(itn_len - 2, 0), qPrevReg(quot_pos_1) | qPrevReg(quot_pos_2)) 227 val rSumReg = RegEnable(Mux(state(s_pre_1), rSumInit, rSumIter), state(s_pre_1) | state(s_iter)) // 68, 67 228 val rCarryReg = RegEnable(Mux(state(s_pre_1), rCarryInit, rCarryIter), state(s_pre_1) | state(s_iter)) 229 csa.io.in(0) := rSumReg << 2 230 csa.io.in(1) := rCarryReg << 2 231 csa.io.in(2) := qXd 232 233 val qds = Module(new SRT4QDS(len, itn_len)) 234 qds.io.remSum := rSumReg 235 qds.io.remCarry := rCarryReg 236 qds.io.d := dNormAbsReg(len - 1, 0) // Maybe optimize here to lower power consumption? 237 qds.io.specialDivisor := specialDivisorReg 238 qds.io.qPrev := qPrevReg 239 qIterEnd := qds.io.qIterEnd 240 241 //on the fly conversion 242 val quotIterNext = Wire(UInt(len.W)) 243 val quotIterM1Next = Wire(UInt(len.W)) 244 quotIterNext := Mux1H(Seq( 245 qPrevReg(quot_pos_2) -> (quotIterReg << 2 | "b10".U), 246 qPrevReg(quot_pos_1) -> (quotIterReg << 2 | "b01".U), 247 qPrevReg(quot_0) -> (quotIterReg << 2 | "b00".U), 248 qPrevReg(quot_neg_1) -> (quotM1IterReg << 2 | "b11".U), 249 qPrevReg(quot_neg_2) -> (quotM1IterReg << 2 | "b10".U) 250 )) 251 quotIterM1Next := Mux1H(Seq( 252 qPrevReg(quot_pos_2) -> (quotIterReg << 2 | "b01".U), 253 qPrevReg(quot_pos_1) -> (quotIterReg << 2 | "b00".U), 254 qPrevReg(quot_0) -> (quotM1IterReg << 2 | "b11".U), 255 qPrevReg(quot_neg_1) -> (quotM1IterReg << 2 | "b10".U), 256 qPrevReg(quot_neg_2) -> (quotM1IterReg << 2 | "b01".U) 257 )) 258 259 260 quotIter := Mux(state(s_pre_1), 261 Mux(dIsZero, VecInit(Seq.fill(len)(true.B)).asUInt, 262 Mux(noIterReg, aNormAbsReg(len - 1, 0), 0.U(len.W))), 263 Mux(state(s_iter), quotIterNext, 264 Mux(quotSignReg, aInverter, quotIterReg))) 265 quotM1Iter := Mux(state(s_pre_1), 266 0.U(len.W), Mux(state(s_iter), quotIterM1Next, 267 Mux(quotSignReg, dInverter, quotM1IterReg))) 268 269 270 // iter num 271 val iterNum = Wire(UInt((lzc_width - 1).W)) 272 val iterNumReg = RegEnable(iterNum, state(s_pre_1) | state(s_iter)) 273 274 iterNum := Mux(state(s_pre_1), lzcDiff(lzc_width - 1, 1) +% lzcDiff(0), iterNumReg -% 1.U) 275 finalIter := iterNumReg === 0.U 276 277 // Post Process 278 279 when(rSignReg) { 280 rNext := ~rSumReg + ~rCarryReg + 2.U 281 rNextPd := ~rSumReg + ~rCarryReg + ~Cat(0.U(1.W), dNormAbsReg(len - 1, 0), 0.U(3.W)) + 3.U 282 } .otherwise { 283 rNext := rSumReg + rCarryReg 284 rNextPd := rSumReg + rCarryReg + Cat(0.U(1.W), dNormAbsReg(len - 1, 0), 0.U(3.W)) 285 } 286 287 val r = aNormAbsReg 288 val rPd = dNormAbsReg 289 val rIsZero = ~(r.orR()) 290 val needCorr = (~dIsZero & ~noIterReg) & Mux(rSignReg, ~r(len) & ~rIsZero, r(len)) // when we get pos rem for d<0 or neg rem for d>0 291 rPreShifted := Mux(needCorr, rPd, r) 292 val rFinal = RegEnable(rightShifted, state(s_post_1))// right shifted remainder. shift by the number of bits divisor is shifted 293 val qFinal = Mux(needCorr, quotM1IterReg, quotIterReg) 294 295 val res = Mux(isHi, rFinal, qFinal) 296 io.out_data := Mux(isW, 297 SignExt(res(31, 0), len), 298 res 299 ) 300 io.in_ready := state(s_idle) 301 io.out_valid := state(s_finish) // state === s_finish 302} 303 304class RightShifter(len: Int, lzc_width: Int) extends Module { 305 val io = IO(new Bundle() { 306 val shiftNum = Input(UInt(lzc_width.W)) 307 val in = Input(UInt(len.W)) 308 val msb = Input(Bool()) 309 val out = Output(UInt(len.W)) 310 }) 311 require(len == 64 || len == 32) 312 val shift = io.shiftNum 313 val msb = io.msb 314 val s0 = Mux(shift(0), Cat(VecInit(Seq.fill(1)(msb)).asUInt, io.in(len - 1, 1)), io.in) 315 val s1 = Mux(shift(1), Cat(VecInit(Seq.fill(2)(msb)).asUInt, s0(len - 1, 2)), s0) 316 val s2 = Mux(shift(2), Cat(VecInit(Seq.fill(4)(msb)).asUInt, s1(len - 1, 4)), s1) 317 val s3 = Mux(shift(3), Cat(VecInit(Seq.fill(8)(msb)).asUInt, s2(len - 1, 8)), s2) 318 val s4 = Mux(shift(4), Cat(VecInit(Seq.fill(16)(msb)).asUInt, s3(len - 1, 16)), s3) 319 val s5 = Wire(UInt(len.W)) 320 if (len == 64) { 321 s5 := Mux(shift(5), Cat(VecInit(Seq.fill(32)(msb)).asUInt, s4(len - 1, 32)), s4) 322 } else if (len == 32) { 323 s5 := s4 324 } 325 io.out := s5 326} 327 328object mLookUpTable { 329 // Usage : 330 // result := decoder(QMCMinimizer, index, mLookupTable.xxx) 331 val minus_m = Seq( 332 Array( // -m[-1] 333 0.U -> "b00_11010".U, 334 1.U -> "b00_11110".U, 335 2.U -> "b01_00000".U, 336 3.U -> "b01_00100".U, 337 4.U -> "b01_00110".U, 338 5.U -> "b01_01010".U, 339 6.U -> "b01_01100".U, 340 7.U -> "b01_10000".U 341 ), 342 Array( // -m[0] 343 0.U -> "b000_0101".U, 344 1.U -> "b000_0110".U, 345 2.U -> "b000_0110".U, 346 3.U -> "b000_0110".U, 347 4.U -> "b000_1001".U, 348 5.U -> "b000_1000".U, 349 6.U -> "b000_1000".U, 350 7.U -> "b000_1000".U 351 ), 352 Array( //-m[1] 353 0.U -> "b111_1101".U, 354 1.U -> "b111_1100".U, 355 2.U -> "b111_1100".U, 356 3.U -> "b111_1100".U, 357 4.U -> "b111_1011".U, 358 5.U -> "b111_1010".U, 359 6.U -> "b111_1010".U, 360 7.U -> "b111_1010".U 361 ), 362 Array( //-m[2] 363 0.U -> "b11_01000".U, 364 1.U -> "b11_00100".U, 365 2.U -> "b11_00010".U, 366 3.U -> "b10_11110".U, 367 4.U -> "b10_11100".U, 368 5.U -> "b10_11000".U, 369 6.U -> "b10_10110".U, 370 7.U -> "b10_10010".U 371 )) 372} 373 374class SRT4QDS(len: Int, itn_len: Int) extends Module { 375 // srt4 quotientr digit selection 376 val io = IO(new Bundle() { 377 val remSum = Input(UInt(itn_len.W)) // 68, 67 378 val remCarry = Input(UInt(itn_len.W)) 379 val d = Input(UInt(len.W)) // 64, 64 380 val specialDivisor = Input(Bool()) 381 val qPrev = Input(UInt(5.W)) 382 val qIterEnd = Output(UInt(5.W)) 383 }) 384 val remSumX16 = io.remSum << 4 // 72, 67 Top 2 bits unused 385 val remCarryX16 = io.remCarry << 4 386 def trunc25(rem: UInt): UInt = {rem(itn_len, itn_len - 7 + 1)} 387 def trunc34(rem: UInt): UInt = {rem(itn_len + 1, itn_len + 1 - 7 + 1)} 388 389 val quot_neg_2 :: quot_neg_1 :: quot_0 :: quot_pos_1 :: quot_pos_2 :: Nil = Enum(5) 390 391 val d = Cat(0.U(1.W), io.d, 0.U(3.W)) // 68, 67 392 val (dX4, dX8, dXNeg4, dXNeg8) = (d << 2, d(itn_len - 2, 0) << 3, ~(d << 2), ~(d(itn_len - 2, 0) << 3)) // 70, 67 393 val dForLookup = io.d(len - 2, len - 2 - 3 + 1) 394 395 val dXq = Mux1H(Seq( 396 io.qPrev(quot_neg_2) -> dX8, 397 io.qPrev(quot_neg_1) -> dX4, 398 io.qPrev(quot_0) -> 0.U((itn_len + 2).W), 399 io.qPrev(quot_pos_1) -> dXNeg4, 400 io.qPrev(quot_pos_2) -> dXNeg8 401 )) 402 val signs = VecInit(Seq.tabulate(4){ // -1 0 1 2 403 i => { 404 val csa1 = Module(new CSA3_2(7)) 405 val csa2 = Module(new CSA3_2(7)) 406 if (i == 1 || i == 2) { 407 csa1.io.in(0) := trunc34(remSumX16) 408 csa1.io.in(1) := trunc34(remCarryX16) 409 csa2.io.in(2) := trunc34(dXq) 410 } else { 411 csa1.io.in(0) := trunc25(remSumX16) 412 csa1.io.in(1) := trunc25(remCarryX16) 413 csa2.io.in(2) := trunc25(dXq) 414 } 415 csa1.io.in(2) := MuxLookup(dForLookup, "b0000000".U, mLookUpTable.minus_m(i)) 416 csa2.io.in(0) := csa1.io.out(0) 417 csa2.io.in(1) := csa1.io.out(1)(5, 0) << 1 418 (csa2.io.out(0) + (csa2.io.out(1)(5, 0) << 1))(6) 419 } 420 }) 421 val qVec = Wire(Vec(5, Bool())) 422 qVec(quot_neg_2) := signs(0) && signs(1) && signs(2) 423 qVec(quot_neg_1) := ~signs(0) && signs(1) && signs(2) 424 qVec(quot_0) := signs(2) && ~signs(1) 425 qVec(quot_pos_1) := signs(3) && ~signs(2) && ~signs(1) 426 qVec(quot_pos_2) := ~signs(3) && ~signs(2) && ~signs(1) 427 io.qIterEnd := qVec.asUInt 428 // assert(PopCount(qVec) === 1.U) 429} 430 431 432class SRT4Divider(len: Int)(implicit p: Parameters) extends AbstractDivider(len) { 433 434 val newReq = io.in.fire() 435 436 val uop = io.in.bits.uop 437 val uopReg = RegEnable(uop, newReq) 438 val ctrlReg = RegEnable(ctrl, newReq) 439 440 val divDataModule = Module(new SRT4DividerDataModule(len)) 441 442 val kill_w = uop.roqIdx.needFlush(io.redirectIn, io.flushIn) 443 val kill_r = !divDataModule.io.in_ready && uopReg.roqIdx.needFlush(io.redirectIn, io.flushIn) 444 445 divDataModule.io.src(0) := io.in.bits.src(0) 446 divDataModule.io.src(1) := io.in.bits.src(1) 447 divDataModule.io.valid := io.in.valid 448 divDataModule.io.sign := sign 449 divDataModule.io.kill_w := kill_w 450 divDataModule.io.kill_r := kill_r 451 divDataModule.io.isHi := ctrlReg.isHi 452 divDataModule.io.isW := ctrlReg.isW 453 divDataModule.io.out_ready := io.out.ready 454 455 io.in.ready := divDataModule.io.in_ready 456 io.out.valid := divDataModule.io.out_valid 457 io.out.bits.data := divDataModule.io.out_data 458 io.out.bits.uop := uopReg 459} 460