1package xiangshan.backend.datapath 2 3import chipsalliance.rocketchip.config.Parameters 4import chisel3._ 5import chisel3.util._ 6import difftest.{DifftestArchFpRegState, DifftestArchIntRegState, DifftestArchVecRegState} 7import freechips.rocketchip.diplomacy.{LazyModule, LazyModuleImp} 8import utility._ 9import utils.SeqUtils._ 10import xiangshan._ 11import xiangshan.backend.BackendParams 12import xiangshan.backend.Bundles._ 13import xiangshan.backend.decode.ImmUnion 14import xiangshan.backend.datapath.DataConfig._ 15import xiangshan.backend.datapath.RdConfig._ 16import xiangshan.backend.issue.{ImmExtractor, IntScheduler, MemScheduler, VfScheduler} 17import xiangshan.backend.regfile._ 18 19class DataPath(params: BackendParams)(implicit p: Parameters) extends LazyModule { 20 private implicit val dpParams: BackendParams = params 21 lazy val module = new DataPathImp(this) 22 23 println(s"[DataPath] Preg Params: ") 24 println(s"[DataPath] Int R(${params.getRfReadSize(IntData())}), W(${params.getRfWriteSize(IntData())}) ") 25 println(s"[DataPath] Vf R(${params.getRfReadSize(VecData())}), W(${params.getRfWriteSize(VecData())}) ") 26} 27 28class DataPathImp(override val wrapper: DataPath)(implicit p: Parameters, params: BackendParams) 29 extends LazyModuleImp(wrapper) with HasXSParameter { 30 31 private val VCONFIG_PORT = params.vconfigPort 32 33 val io = IO(new DataPathIO()) 34 35 private val (fromIntIQ, toIntIQ, toIntExu) = (io.fromIntIQ, io.toIntIQ, io.toIntExu) 36 private val (fromMemIQ, toMemIQ, toMemExu) = (io.fromMemIQ, io.toMemIQ, io.toMemExu) 37 private val (fromVfIQ , toVfIQ , toVfExu ) = (io.fromVfIQ , io.toVfIQ , io.toFpExu) 38 private val (fromIntExus, fromVfExus) = (io.fromIntExus, io.fromVfExus) 39 40 println(s"[DataPath] IntIQ(${fromIntIQ.size}), MemIQ(${fromMemIQ.size})") 41 println(s"[DataPath] IntExu(${fromIntIQ.map(_.size).sum}), MemExu(${fromMemIQ.map(_.size).sum})") 42 43 // just refences for convience 44 private val fromIQ = fromIntIQ ++ fromVfIQ ++ fromMemIQ 45 46 private val toIQs = toIntIQ ++ toVfIQ ++ toMemIQ 47 48 private val toExu = toIntExu ++ toVfExu ++ toMemExu 49 50 private val fromExus = fromIntExus ++ fromVfExus 51 52 private val fromFlattenIQ: Seq[DecoupledIO[IssueQueueIssueBundle]] = fromIQ.flatten 53 54 private val toFlattenExu: Seq[DecoupledIO[ExuInput]] = toExu.flatten 55 56 private val intWbBusyArbiter = Module(new IntRFWBCollideChecker(backendParams)) 57 private val vfWbBusyArbiter = Module(new VfRFWBCollideChecker(backendParams)) 58 private val intRFReadArbiter = Module(new IntRFReadArbiter(backendParams)) 59 private val vfRFReadArbiter = Module(new VfRFReadArbiter(backendParams)) 60 61 private val og0FailedVec2: MixedVec[Vec[Bool]] = Wire(MixedVec(fromIQ.map(x => Vec(x.size, Bool())))) 62 private val og1FailedVec2: MixedVec[Vec[Bool]] = Wire(MixedVec(fromIQ.map(x => Vec(x.size, Bool())))) 63 64 // port -> win 65 private val intRdArbWinner: Seq2[MixedVec[Bool]] = intRFReadArbiter.io.in.map(_.map(x => MixedVecInit(x.map(_.ready)))) 66 private val vfRdArbWinner: Seq2[MixedVec[Bool]] = vfRFReadArbiter.io.in.map(_.map(x => MixedVecInit(x.map(_.ready)))) 67 private val intWbNotBlock: Seq[MixedVec[Bool]] = intWbBusyArbiter.io.in.map(x => MixedVecInit(x.map(_.ready))) 68 private val vfWbNotBlock: Seq[MixedVec[Bool]] = vfWbBusyArbiter.io.in.map(x => MixedVecInit(x.map(_.ready))) 69 70 private val intRdNotBlock: Seq2[Bool] = intRdArbWinner.map(_.map(_.asUInt.andR)) 71 private val vfRdNotBlock: Seq2[Bool] = vfRdArbWinner.map(_.map(_.asUInt.andR)) 72 73 private val intRFReadReq: Seq3[ValidIO[RfReadPortWithConfig]] = fromIQ.map(x => x.map(xx => xx.bits.getIntRfReadValidBundle(xx.valid))) 74 75 intRFReadArbiter.io.in.zip(intRFReadReq).zipWithIndex.foreach { case ((arbInSeq2, inRFReadReqSeq2), iqIdx) => 76 arbInSeq2.zip(inRFReadReqSeq2).zipWithIndex.foreach { case ((arbInSeq, inRFReadReqSeq), exuIdx) => 77 val srcIndices: Seq[Int] = fromIQ(iqIdx)(exuIdx).bits.exuParams.getRfReadSrcIdx(IntData()) 78 for (srcIdx <- 0 until fromIQ(iqIdx)(exuIdx).bits.exuParams.numRegSrc) { 79 if (srcIndices.contains(srcIdx) && inRFReadReqSeq.isDefinedAt(srcIdx)) { 80 arbInSeq(srcIdx).valid := inRFReadReqSeq(srcIdx).valid 81 arbInSeq(srcIdx).bits.addr := inRFReadReqSeq(srcIdx).bits.addr 82 } else { 83 arbInSeq(srcIdx).valid := false.B 84 arbInSeq(srcIdx).bits.addr := 0.U 85 } 86 } 87 } 88 } 89 90 private val vfRFReadReq: Seq3[ValidIO[RfReadPortWithConfig]] = fromIQ.map(x => x.map(xx => xx.bits.getVfRfReadValidBundle(xx.valid))) 91 92 vfRFReadArbiter.io.in.zip(vfRFReadReq).zipWithIndex.foreach { case ((arbInSeq2, inRFReadReqSeq2), iqIdx) => 93 arbInSeq2.zip(inRFReadReqSeq2).zipWithIndex.foreach { case ((arbInSeq, inRFReadReqSeq), exuIdx) => 94 val srcIndices: Seq[Int] = VfRegSrcDataSet.flatMap(data => fromIQ(iqIdx)(exuIdx).bits.exuParams.getRfReadSrcIdx(data)).toSeq.sorted 95 for (srcIdx <- 0 until fromIQ(iqIdx)(exuIdx).bits.exuParams.numRegSrc) { 96 if (srcIndices.contains(srcIdx) && inRFReadReqSeq.isDefinedAt(srcIdx)) { 97 arbInSeq(srcIdx).valid := inRFReadReqSeq(srcIdx).valid 98 arbInSeq(srcIdx).bits.addr := inRFReadReqSeq(srcIdx).bits.addr 99 } else { 100 arbInSeq(srcIdx).valid := false.B 101 arbInSeq(srcIdx).bits.addr := 0.U 102 } 103 } 104 } 105 } 106 107 private val intRFWriteReq: Seq2[Bool] = fromIQ.map(x => x.map(xx => xx.valid && xx.bits.common.rfWen.getOrElse(false.B))) 108 private val vfRFWriteReq: Seq2[Bool] = fromIQ.map(x => x.map(xx => xx.valid && xx.bits.common.getVfWen.getOrElse(false.B))) 109 110 intWbBusyArbiter.io.in.zip(intRFWriteReq).foreach { case (arbInSeq, inRFWriteReqSeq) => 111 arbInSeq.zip(inRFWriteReqSeq).foreach { case (arbIn, inRFWriteReq) => 112 arbIn.valid := inRFWriteReq 113 } 114 } 115 116 vfWbBusyArbiter.io.in.zip(vfRFWriteReq).foreach { case (arbInSeq, inRFWriteReqSeq) => 117 arbInSeq.zip(inRFWriteReqSeq).foreach { case (arbIn, inRFWriteReq) => 118 arbIn.valid := inRFWriteReq 119 } 120 } 121 122 private val intSchdParams = params.schdParams(IntScheduler()) 123 private val vfSchdParams = params.schdParams(VfScheduler()) 124 private val memSchdParams = params.schdParams(MemScheduler()) 125 126 private val numIntRfReadByExu = intSchdParams.numIntRfReadByExu + memSchdParams.numIntRfReadByExu 127 private val numVfRfReadByExu = vfSchdParams.numVfRfReadByExu + memSchdParams.numVfRfReadByExu 128 // Todo: limit read port 129 private val numIntR = numIntRfReadByExu 130 private val numVfR = numVfRfReadByExu 131 println(s"[DataPath] RegFile read req needed by Exu: Int(${numIntRfReadByExu}), Vf(${numVfRfReadByExu})") 132 println(s"[DataPath] RegFile read port: Int(${numIntR}), Vf(${numVfR})") 133 134 private val schdParams = params.allSchdParams 135 136 private val intRfRaddr = Wire(Vec(params.numPregRd(IntData()), UInt(intSchdParams.pregIdxWidth.W))) 137 private val intRfRdata = Wire(Vec(params.numPregRd(IntData()), UInt(intSchdParams.rfDataWidth.W))) 138 private val intRfWen = Wire(Vec(io.fromIntWb.length, Bool())) 139 private val intRfWaddr = Wire(Vec(io.fromIntWb.length, UInt(intSchdParams.pregIdxWidth.W))) 140 private val intRfWdata = Wire(Vec(io.fromIntWb.length, UInt(intSchdParams.rfDataWidth.W))) 141 142 private val vfRfSplitNum = VLEN / XLEN 143 private val vfRfRaddr = Wire(Vec(params.numPregRd(VecData()), UInt(vfSchdParams.pregIdxWidth.W))) 144 private val vfRfRdata = Wire(Vec(params.numPregRd(VecData()), UInt(vfSchdParams.rfDataWidth.W))) 145 private val vfRfWen = Wire(Vec(vfRfSplitNum, Vec(io.fromVfWb.length, Bool()))) 146 private val vfRfWaddr = Wire(Vec(io.fromVfWb.length, UInt(vfSchdParams.pregIdxWidth.W))) 147 private val vfRfWdata = Wire(Vec(io.fromVfWb.length, UInt(vfSchdParams.rfDataWidth.W))) 148 149 private val intDebugRead: Option[(Vec[UInt], Vec[UInt])] = 150 if (env.AlwaysBasicDiff || env.EnableDifftest) { 151 Some(Wire(Vec(32, UInt(intSchdParams.pregIdxWidth.W))), Wire(Vec(32, UInt(XLEN.W)))) 152 } else { None } 153 private val vfDebugRead: Option[(Vec[UInt], Vec[UInt])] = 154 if (env.AlwaysBasicDiff || env.EnableDifftest) { 155 Some(Wire(Vec(32 + 32 + 1, UInt(vfSchdParams.pregIdxWidth.W))), Wire(Vec(32 + 32 + 1, UInt(VLEN.W)))) 156 } else { None } 157 158 private val fpDebugReadData: Option[Vec[UInt]] = 159 if (env.AlwaysBasicDiff || env.EnableDifftest) { 160 Some(Wire(Vec(32, UInt(XLEN.W)))) 161 } else { None } 162 private val vecDebugReadData: Option[Vec[UInt]] = 163 if (env.AlwaysBasicDiff || env.EnableDifftest) { 164 Some(Wire(Vec(64, UInt(64.W)))) // v0 = Cat(Vec(1), Vec(0)) 165 } else { None } 166 private val vconfigDebugReadData: Option[UInt] = 167 if (env.AlwaysBasicDiff || env.EnableDifftest) { 168 Some(Wire(UInt(64.W))) 169 } else { None } 170 171 172 fpDebugReadData.foreach(_ := vfDebugRead 173 .get._2 174 .slice(0, 32) 175 .map(_(63, 0)) 176 ) // fp only used [63, 0] 177 vecDebugReadData.foreach(_ := vfDebugRead 178 .get._2 179 .slice(32, 64) 180 .map(x => Seq(x(63, 0), x(127, 64))).flatten 181 ) 182 vconfigDebugReadData.foreach(_ := vfDebugRead 183 .get._2(64)(63, 0) 184 ) 185 186 io.debugVconfig.foreach(_ := vconfigDebugReadData.get) 187 188 IntRegFile("IntRegFile", intSchdParams.numPregs, intRfRaddr, intRfRdata, intRfWen, intRfWaddr, intRfWdata, 189 debugReadAddr = intDebugRead.map(_._1), 190 debugReadData = intDebugRead.map(_._2)) 191 VfRegFile("VfRegFile", vfSchdParams.numPregs, vfRfSplitNum, vfRfRaddr, vfRfRdata, vfRfWen, vfRfWaddr, vfRfWdata, 192 debugReadAddr = vfDebugRead.map(_._1), 193 debugReadData = vfDebugRead.map(_._2)) 194 195 intRfWaddr := io.fromIntWb.map(_.addr) 196 intRfWdata := io.fromIntWb.map(_.data) 197 intRfWen := io.fromIntWb.map(_.wen) 198 199 for (portIdx <- intRfRaddr.indices) { 200 if (intRFReadArbiter.io.out.isDefinedAt(portIdx)) 201 intRfRaddr(portIdx) := intRFReadArbiter.io.out(portIdx).bits.addr 202 else 203 intRfRaddr(portIdx) := 0.U 204 } 205 206 vfRfWaddr := io.fromVfWb.map(_.addr) 207 vfRfWdata := io.fromVfWb.map(_.data) 208 vfRfWen.foreach(_.zip(io.fromVfWb.map(_.wen)).foreach { case (wenSink, wenSource) => wenSink := wenSource } )// Todo: support fp multi-write 209 210 for (portIdx <- vfRfRaddr.indices) { 211 if (vfRFReadArbiter.io.out.isDefinedAt(portIdx)) 212 vfRfRaddr(portIdx) := vfRFReadArbiter.io.out(portIdx).bits.addr 213 else 214 vfRfRaddr(portIdx) := 0.U 215 } 216 217 vfRfRaddr(VCONFIG_PORT) := io.vconfigReadPort.addr 218 io.vconfigReadPort.data := vfRfRdata(VCONFIG_PORT) 219 220 intDebugRead.foreach { case (addr, _) => 221 addr := io.debugIntRat.get 222 } 223 224 vfDebugRead.foreach { case (addr, _) => 225 addr := io.debugFpRat.get ++ io.debugVecRat.get :+ io.debugVconfigRat.get 226 } 227 println(s"[DataPath] " + 228 s"has intDebugRead: ${intDebugRead.nonEmpty}, " + 229 s"has vfDebugRead: ${vfDebugRead.nonEmpty}") 230 231 val s1_addrOHs = Reg(MixedVec( 232 fromIQ.map(x => MixedVec(x.map(_.bits.addrOH.cloneType))) 233 )) 234 val s1_toExuValid: MixedVec[MixedVec[Bool]] = Reg(MixedVec( 235 toExu.map(x => MixedVec(x.map(_.valid.cloneType))) 236 )) 237 val s1_toExuData: MixedVec[MixedVec[ExuInput]] = Reg(MixedVec(toExu.map(x => MixedVec(x.map(_.bits.cloneType))))) 238 val s1_toExuReady = Wire(MixedVec(toExu.map(x => MixedVec(x.map(_.ready.cloneType))))) // Todo 239 val s1_srcType: MixedVec[MixedVec[Vec[UInt]]] = MixedVecInit(fromIQ.map(x => MixedVecInit(x.map(xx => RegEnable(xx.bits.srcType, xx.fire))))) 240 241 val s1_intPregRData: MixedVec[MixedVec[Vec[UInt]]] = Wire(MixedVec(toExu.map(x => MixedVec(x.map(_.bits.src.cloneType))))) 242 val s1_vfPregRData: MixedVec[MixedVec[Vec[UInt]]] = Wire(MixedVec(toExu.map(x => MixedVec(x.map(_.bits.src.cloneType))))) 243 244 val rfrPortConfigs = schdParams.map(_.issueBlockParams).flatten.map(_.exuBlockParams.map(_.rfrPortConfigs)) 245 246 println(s"[DataPath] s1_intPregRData.flatten.flatten.size: ${s1_intPregRData.flatten.flatten.size}, intRfRdata.size: ${intRfRdata.size}") 247 s1_intPregRData.foreach(_.foreach(_.foreach(_ := 0.U))) 248 s1_intPregRData.zip(rfrPortConfigs).foreach { case (iqRdata, iqCfg) => 249 iqRdata.zip(iqCfg).foreach { case (iuRdata, iuCfg) => 250 val realIuCfg = iuCfg.map(x => if(x.size > 1) x.filter(_.isInstanceOf[IntRD]) else x).flatten 251 assert(iuRdata.size == realIuCfg.size, "iuRdata.size != realIuCfg.size") 252 iuRdata.zip(realIuCfg) 253 .filter { case (_, rfrPortConfig) => rfrPortConfig.isInstanceOf[IntRD] } 254 .foreach { case (sink, cfg) => sink := intRfRdata(cfg.port) } 255 } 256 } 257 258 println(s"[DataPath] s1_vfPregRData.flatten.flatten.size: ${s1_vfPregRData.flatten.flatten.size}, vfRfRdata.size: ${vfRfRdata.size}") 259 s1_vfPregRData.foreach(_.foreach(_.foreach(_ := 0.U))) 260 s1_vfPregRData.zip(rfrPortConfigs).foreach{ case(iqRdata, iqCfg) => 261 iqRdata.zip(iqCfg).foreach{ case(iuRdata, iuCfg) => 262 val realIuCfg = iuCfg.map(x => if(x.size > 1) x.filter(_.isInstanceOf[VfRD]) else x).flatten 263 assert(iuRdata.size == realIuCfg.size, "iuRdata.size != realIuCfg.size") 264 iuRdata.zip(realIuCfg) 265 .filter { case (_, rfrPortConfig) => rfrPortConfig.isInstanceOf[VfRD] } 266 .foreach { case (sink, cfg) => sink := vfRfRdata(cfg.port) } 267 } 268 } 269 270 for (i <- fromIQ.indices) { 271 for (j <- fromIQ(i).indices) { 272 // IQ(s0) --[Ctrl]--> s1Reg ---------- begin 273 // refs 274 val s1_valid = s1_toExuValid(i)(j) 275 val s1_ready = s1_toExuReady(i)(j) 276 val s1_data = s1_toExuData(i)(j) 277 val s1_addrOH = s1_addrOHs(i)(j) 278 val s0 = fromIQ(i)(j) // s0 279 val notBlock = intRdNotBlock(i)(j) && intWbNotBlock(i)(j) && vfRdNotBlock(i)(j) && vfWbNotBlock(i)(j) 280 val s1_flush = s0.bits.common.robIdx.needFlush(Seq(io.flush, RegNextWithEnable(io.flush))) 281 val s1_cancel = og1FailedVec2(i)(j) 282 val s1_ldCancel = LoadShouldCancel(s0.bits.common.loadDependency, io.ldCancel) 283 when (s0.fire && !s1_flush && notBlock && !s1_cancel && !s1_ldCancel) { 284 s1_valid := s0.valid 285 s1_data.fromIssueBundle(s0.bits) // no src data here 286 s1_addrOH := s0.bits.addrOH 287 }.otherwise { 288 s1_valid := false.B 289 } 290 s0.ready := (s1_ready || !s1_valid) && notBlock 291 // IQ(s0) --[Ctrl]--> s1Reg ---------- end 292 293 // IQ(s0) --[Data]--> s1Reg ---------- begin 294 // imm extract 295 when (s0.fire && !s1_flush && notBlock) { 296 if (s1_data.params.immType.nonEmpty && s1_data.src.size > 1) { 297 // rs1 is always int reg, rs2 may be imm 298 when(SrcType.isImm(s0.bits.srcType(1))) { 299 s1_data.src(1) := ImmExtractor( 300 s0.bits.common.imm, 301 s0.bits.immType, 302 s1_data.params.dataBitsMax, 303 s1_data.params.immType.map(_.litValue) 304 ) 305 } 306 } 307 if (s1_data.params.hasJmpFu) { 308 when(SrcType.isPc(s0.bits.srcType(0))) { 309 s1_data.src(0) := SignExt(s0.bits.jmp.get.pc, XLEN) 310 } 311 } else if (s1_data.params.hasVecFu) { 312 // Fuck off riscv vector imm!!! Why not src1??? 313 when(SrcType.isImm(s0.bits.srcType(0))) { 314 s1_data.src(0) := ImmExtractor( 315 s0.bits.common.imm, 316 s0.bits.immType, 317 s1_data.params.dataBitsMax, 318 s1_data.params.immType.map(_.litValue) 319 ) 320 } 321 } else if (s1_data.params.hasLoadFu) { 322 // dirty code for fused_lui_load 323 when(SrcType.isImm(s0.bits.srcType(0))) { 324 s1_data.src(0) := SignExt(ImmUnion.U.toImm32(s0.bits.common.imm(s0.bits.common.imm.getWidth - 1, ImmUnion.I.len)), XLEN) 325 } 326 } 327 } 328 // IQ(s0) --[Data]--> s1Reg ---------- end 329 } 330 } 331 332 private val fromIQFire = fromIQ.map(_.map(_.fire)) 333 private val toExuFire = toExu.map(_.map(_.fire)) 334 toIQs.zipWithIndex.foreach { 335 case(toIQ, iqIdx) => 336 toIQ.zipWithIndex.foreach { 337 case (toIU, iuIdx) => 338 // IU: issue unit 339 val og0resp = toIU.og0resp 340 og0FailedVec2(iqIdx)(iuIdx) := fromIQ(iqIdx)(iuIdx).valid && (!fromIQFire(iqIdx)(iuIdx)) 341 og0resp.valid := og0FailedVec2(iqIdx)(iuIdx) 342 og0resp.bits.respType := RSFeedbackType.rfArbitFail 343 og0resp.bits.robIdx := fromIQ(iqIdx)(iuIdx).bits.common.robIdx 344 og0resp.bits.rfWen := fromIQ(iqIdx)(iuIdx).bits.common.rfWen.getOrElse(false.B) 345 og0resp.bits.fuType := fromIQ(iqIdx)(iuIdx).bits.common.fuType 346 347 val og1resp = toIU.og1resp 348 og1FailedVec2(iqIdx)(iuIdx) := s1_toExuValid(iqIdx)(iuIdx) && !toExuFire(iqIdx)(iuIdx) 349 og1resp.valid := s1_toExuValid(iqIdx)(iuIdx) 350 og1resp.bits.respType := Mux(!og1FailedVec2(iqIdx)(iuIdx), 351 if (toIU.issueQueueParams.isMemAddrIQ) RSFeedbackType.fuUncertain else RSFeedbackType.fuIdle, 352 RSFeedbackType.fuBusy) 353 og1resp.bits.robIdx := s1_toExuData(iqIdx)(iuIdx).robIdx 354 og1resp.bits.rfWen := s1_toExuData(iqIdx)(iuIdx).rfWen.getOrElse(false.B) 355 og1resp.bits.fuType := s1_toExuData(iqIdx)(iuIdx).fuType 356 } 357 } 358 359 io.og0CancelVec.zip(io.og1CancelVec).zipWithIndex.foreach { case ((og0Cancel, og1Cancel), i) => 360 og0Cancel := fromFlattenIQ(i).valid && !fromFlattenIQ(i).fire 361 og1Cancel := toFlattenExu(i).valid && !toFlattenExu(i).fire 362 } 363 364 io.cancelToBusyTable.zipWithIndex.foreach { case (cancel, i) => 365 cancel.valid := fromFlattenIQ(i).valid && !fromFlattenIQ(i).fire && { 366 if (fromFlattenIQ(i).bits.common.rfWen.isDefined) 367 fromFlattenIQ(i).bits.common.rfWen.get && fromFlattenIQ(i).bits.common.pdest =/= 0.U 368 else 369 true.B 370 } 371 cancel.bits.rfWen := fromFlattenIQ(i).bits.common.rfWen.getOrElse(false.B) 372 cancel.bits.fpWen := fromFlattenIQ(i).bits.common.fpWen.getOrElse(false.B) 373 cancel.bits.vecWen := fromFlattenIQ(i).bits.common.vecWen.getOrElse(false.B) 374 cancel.bits.pdest := fromFlattenIQ(i).bits.common.pdest 375 } 376 377 for (i <- toExu.indices) { 378 for (j <- toExu(i).indices) { 379 // s1Reg --[Ctrl]--> exu(s1) ---------- begin 380 // refs 381 val sinkData = toExu(i)(j).bits 382 // assign 383 toExu(i)(j).valid := s1_toExuValid(i)(j) 384 s1_toExuReady(i)(j) := toExu(i)(j).ready 385 sinkData := s1_toExuData(i)(j) 386 // s1Reg --[Ctrl]--> exu(s1) ---------- end 387 388 // s1Reg --[Data]--> exu(s1) ---------- begin 389 // data source1: preg read data 390 for (k <- sinkData.src.indices) { 391 val srcDataTypeSet: Set[DataConfig] = sinkData.params.getSrcDataType(k) 392 393 val readRfMap: Seq[(Bool, UInt)] = (Seq(None) :+ 394 (if (s1_intPregRData(i)(j).isDefinedAt(k) && srcDataTypeSet.intersect(IntRegSrcDataSet).nonEmpty) 395 Some(SrcType.isXp(s1_srcType(i)(j)(k)) -> s1_intPregRData(i)(j)(k)) 396 else None) :+ 397 (if (s1_vfPregRData(i)(j).isDefinedAt(k) && srcDataTypeSet.intersect(VfRegSrcDataSet).nonEmpty) 398 Some(SrcType.isVfp(s1_srcType(i)(j)(k))-> s1_vfPregRData(i)(j)(k)) 399 else None) 400 ).filter(_.nonEmpty).map(_.get) 401 if (readRfMap.nonEmpty) 402 sinkData.src(k) := Mux1H(readRfMap) 403 } 404 405 // data source2: extracted imm and pc saved in s1Reg 406 if (sinkData.params.immType.nonEmpty && sinkData.src.size > 1) { 407 when(SrcType.isImm(s1_srcType(i)(j)(1))) { 408 sinkData.src(1) := s1_toExuData(i)(j).src(1) 409 } 410 } 411 if (sinkData.params.hasJmpFu) { 412 when(SrcType.isPc(s1_srcType(i)(j)(0))) { 413 sinkData.src(0) := s1_toExuData(i)(j).src(0) 414 } 415 } else if (sinkData.params.hasVecFu) { 416 when(SrcType.isImm(s1_srcType(i)(j)(0))) { 417 sinkData.src(0) := s1_toExuData(i)(j).src(0) 418 } 419 } else if (sinkData.params.hasLoadFu) { 420 when(SrcType.isImm(s1_srcType(i)(j)(0))) { 421 sinkData.src(0) := s1_toExuData(i)(j).src(0) 422 } 423 } 424 // s1Reg --[Data]--> exu(s1) ---------- end 425 } 426 } 427 428 if (env.AlwaysBasicDiff || env.EnableDifftest) { 429 val delayedCnt = 2 430 val difftestArchIntRegState = Module(new DifftestArchIntRegState) 431 difftestArchIntRegState.io.clock := clock 432 difftestArchIntRegState.io.coreid := io.hartId 433 difftestArchIntRegState.io.gpr := DelayN(intDebugRead.get._2, delayedCnt) 434 435 val difftestArchFpRegState = Module(new DifftestArchFpRegState) 436 difftestArchFpRegState.io.clock := clock 437 difftestArchFpRegState.io.coreid := io.hartId 438 difftestArchFpRegState.io.fpr := DelayN(fpDebugReadData.get, delayedCnt) 439 440 val difftestArchVecRegState = Module(new DifftestArchVecRegState) 441 difftestArchVecRegState.io.clock := clock 442 difftestArchVecRegState.io.coreid := io.hartId 443 difftestArchVecRegState.io.vpr := DelayN(vecDebugReadData.get, delayedCnt) 444 } 445} 446 447class DataPathIO()(implicit p: Parameters, params: BackendParams) extends XSBundle { 448 // params 449 private val intSchdParams = params.schdParams(IntScheduler()) 450 private val vfSchdParams = params.schdParams(VfScheduler()) 451 private val memSchdParams = params.schdParams(MemScheduler()) 452 private val exuParams = params.allExuParams 453 // bundles 454 val hartId = Input(UInt(8.W)) 455 456 val flush: ValidIO[Redirect] = Flipped(ValidIO(new Redirect)) 457 458 // Todo: check if this can be removed 459 val vconfigReadPort = new RfReadPort(XLEN, PhyRegIdxWidth) 460 461 val wbConfictRead = Input(MixedVec(params.allSchdParams.map(x => MixedVec(x.issueBlockParams.map(x => x.genWbConflictBundle()))))) 462 463 val fromIntIQ: MixedVec[MixedVec[DecoupledIO[IssueQueueIssueBundle]]] = 464 Flipped(MixedVec(intSchdParams.issueBlockParams.map(_.genIssueDecoupledBundle))) 465 466 val fromMemIQ: MixedVec[MixedVec[DecoupledIO[IssueQueueIssueBundle]]] = 467 Flipped(MixedVec(memSchdParams.issueBlockParams.map(_.genIssueDecoupledBundle))) 468 469 val fromVfIQ = Flipped(MixedVec(vfSchdParams.issueBlockParams.map(_.genIssueDecoupledBundle))) 470 471 val toIntIQ = MixedVec(intSchdParams.issueBlockParams.map(_.genOGRespBundle)) 472 473 val toMemIQ = MixedVec(memSchdParams.issueBlockParams.map(_.genOGRespBundle)) 474 475 val toVfIQ = MixedVec(vfSchdParams.issueBlockParams.map(_.genOGRespBundle)) 476 477 val og0CancelVec = Output(ExuVec(backendParams.numExu)) 478 479 val og1CancelVec = Output(ExuVec(backendParams.numExu)) 480 481 val ldCancel = Vec(backendParams.LduCnt, Flipped(new LoadCancelIO)) 482 483 val cancelToBusyTable = Vec(backendParams.numExu, ValidIO(new CancelSignal)) 484 485 val toIntExu: MixedVec[MixedVec[DecoupledIO[ExuInput]]] = intSchdParams.genExuInputBundle 486 487 val toFpExu: MixedVec[MixedVec[DecoupledIO[ExuInput]]] = MixedVec(vfSchdParams.genExuInputBundle) 488 489 val toMemExu: MixedVec[MixedVec[DecoupledIO[ExuInput]]] = memSchdParams.genExuInputBundle 490 491 val fromIntWb: MixedVec[RfWritePortWithConfig] = MixedVec(params.genIntWriteBackBundle) 492 493 val fromVfWb: MixedVec[RfWritePortWithConfig] = MixedVec(params.genVfWriteBackBundle) 494 495 val fromIntExus = Flipped(intSchdParams.genExuOutputValidBundle) 496 497 val fromVfExus = Flipped(intSchdParams.genExuOutputValidBundle) 498 499 val debugIntRat = if (params.debugEn) Some(Input(Vec(32, UInt(intSchdParams.pregIdxWidth.W)))) else None 500 val debugFpRat = if (params.debugEn) Some(Input(Vec(32, UInt(vfSchdParams.pregIdxWidth.W)))) else None 501 val debugVecRat = if (params.debugEn) Some(Input(Vec(32, UInt(vfSchdParams.pregIdxWidth.W)))) else None 502 val debugVconfigRat = if (params.debugEn) Some(Input(UInt(vfSchdParams.pregIdxWidth.W))) else None 503 val debugVconfig = if (params.debugEn) Some(Output(UInt(XLEN.W))) else None 504} 505