xref: /XiangShan/src/main/scala/xiangshan/backend/issue/OthersEntry.scala (revision 0c7ebb58175b51109677230e8cbab09e73166956) 
1package xiangshan.backend.issue
2
3import org.chipsalliance.cde.config.Parameters
4import chisel3._
5import chisel3.util._
6import utility.HasCircularQueuePtrHelper
7import utils.{MathUtils, OptionWrapper}
8import xiangshan._
9import xiangshan.backend.Bundles._
10import xiangshan.backend.fu.FuType
11import xiangshan.backend.datapath.DataSource
12import xiangshan.backend.rob.RobPtr
13import xiangshan.mem.{MemWaitUpdateReq, SqPtr, LqPtr}
14
15
16class OthersEntryIO(implicit p: Parameters, params: IssueBlockParams) extends XSBundle {
17  //input
18  val enq = Flipped(ValidIO(new EntryBundle))
19  val flush = Flipped(ValidIO(new Redirect))
20  val wakeUpFromWB: MixedVec[ValidIO[IssueQueueWBWakeUpBundle]] = Flipped(params.genWBWakeUpSinkValidBundle)
21  val wakeUpFromIQ: MixedVec[ValidIO[IssueQueueIQWakeUpBundle]] = Flipped(params.genIQWakeUpSinkValidBundle)
22  val og0Cancel = Input(ExuOH(backendParams.numExu))
23  val og1Cancel = Input(ExuOH(backendParams.numExu))
24  val ldCancel = Vec(backendParams.LduCnt + backendParams.HyuCnt, Flipped(new LoadCancelIO))
25  val deqSel = Input(Bool())
26  val transSel = Input(Bool())
27  val issueResp = Flipped(ValidIO(new EntryDeqRespBundle))
28  val deqPortIdxWrite = Input(UInt(1.W))
29  //output
30  val valid = Output(Bool())
31  val canIssue = Output(Bool())
32  val clear = Output(Bool())
33  val fuType = Output(FuType())
34  val dataSource = Output(Vec(params.numRegSrc, DataSource()))
35  val srcWakeUpL1ExuOH = OptionWrapper(params.hasIQWakeUp, Output(Vec(params.numRegSrc, ExuOH())))
36  val srcTimer = OptionWrapper(params.hasIQWakeUp, Output(Vec(params.numRegSrc, UInt(3.W))))
37  val isFirstIssue = Output(Bool())
38  val entry = ValidIO(new EntryBundle)
39  val robIdx = Output(new RobPtr)
40  val uopIdx = OptionWrapper(params.isVecMemIQ, Output(UopIdx()))
41  val deqPortIdxRead = Output(UInt(1.W))
42  val issueTimerRead = Output(UInt(2.W))
43  // mem only
44  val fromMem = if(params.isMemAddrIQ) Some(new Bundle {
45    val stIssuePtr = Input(new SqPtr)
46    val memWaitUpdateReq = Flipped(new MemWaitUpdateReq)
47  }) else None
48  // vector mem only
49  val fromLsq = OptionWrapper(params.isVecMemIQ, new Bundle {
50    val sqDeqPtr = Input(new SqPtr)
51    val lqDeqPtr = Input(new LqPtr)
52  })
53  // debug
54  val cancel = OptionWrapper(params.hasIQWakeUp, Output(Bool()))
55
56  def wakeup = wakeUpFromWB ++ wakeUpFromIQ
57}
58
59class OthersEntry(implicit p: Parameters, params: IssueBlockParams) extends XSModule {
60  val io = IO(new OthersEntryIO)
61
62  val validReg = RegInit(false.B)
63  val entryReg = Reg(new EntryBundle)
64
65  val validRegNext = Wire(Bool())
66  val entryRegNext = Wire(new EntryBundle)
67  val flushed = Wire(Bool())
68  val clear = Wire(Bool())
69  val deqSuccess = Wire(Bool())
70  val srcWakeUp = Wire(Vec(params.numRegSrc, Bool()))
71  val srcWakeUpByWB = Wire(Vec(params.numRegSrc, Bool()))
72  val srcCancelVec = OptionWrapper(params.hasIQWakeUp, Wire(Vec(params.numRegSrc, Bool())))
73  val srcLoadCancelVec = OptionWrapper(params.hasIQWakeUp, Wire(Vec(params.numRegSrc, Bool())))
74  val srcWakeUpByIQVec = Wire(Vec(params.numRegSrc, Vec(params.numWakeupFromIQ, Bool())))
75  val srcWakeUpByIQWithoutCancel = Wire(Vec(params.numRegSrc, Vec(params.numWakeupFromIQ, Bool())))
76  val srcWakeUpL1ExuOHOut = OptionWrapper(params.hasIQWakeUp, Wire(Vec(params.numRegSrc, ExuVec())))
77  val srcLoadDependencyOut = OptionWrapper(params.hasIQWakeUp, Wire(Vec(params.numRegSrc, Vec(LoadPipelineWidth, UInt(3.W)))))
78  val srcWakeUpButCancel = Wire(Vec(params.numRegSrc, Vec(params.numWakeupFromIQ, Bool())))
79  val wakeupLoadDependencyByIQVec = Wire(Vec(params.numWakeupFromIQ, Vec(LoadPipelineWidth, UInt(3.W))))
80  val shiftedWakeupLoadDependencyByIQVec = Wire(Vec(params.numWakeupFromIQ, Vec(LoadPipelineWidth, UInt(3.W))))
81  val shiftedWakeupLoadDependencyByIQBypassVec = Wire(Vec(params.numWakeupFromIQ, Vec(LoadPipelineWidth, UInt(3.W))))
82  val cancelVec = OptionWrapper(params.hasIQWakeUp, Wire(Vec(params.numRegSrc, Bool())))
83
84  //Reg
85  validReg := validRegNext
86  entryReg := entryRegNext
87
88  //Wire
89  flushed := entryReg.status.robIdx.needFlush(io.flush)
90  clear := flushed || deqSuccess
91  deqSuccess := io.issueResp.valid && io.issueResp.bits.respType === RSFeedbackType.fuIdle && !srcLoadCancelVec.map(_.reduce(_ || _)).getOrElse(false.B)
92  srcWakeUpByWB := io.wakeUpFromWB.map(bundle => bundle.bits.wakeUp(entryReg.status.psrc zip entryReg.status.srcType, bundle.valid)).transpose.map(x => VecInit(x.toSeq).asUInt.orR).toSeq
93  srcWakeUp := srcWakeUpByWB.zip(srcWakeUpByIQVec).map { case (x, y) => x || y.asUInt.orR }
94
95  shiftedWakeupLoadDependencyByIQVec
96    .zip(wakeupLoadDependencyByIQVec)
97    .zip(params.wakeUpInExuSources.map(_.name)).foreach {
98    case ((deps, originalDeps), name) => deps.zip(originalDeps).zipWithIndex.foreach {
99      case ((dep, originalDep), deqPortIdx) =>
100        if (params.backendParam.getLdExuIdx(params.backendParam.allExuParams.find(_.name == name).get) == deqPortIdx)
101          dep := (originalDep << 2).asUInt | 2.U
102        else
103          dep := originalDep << 1
104    }
105  }
106  shiftedWakeupLoadDependencyByIQBypassVec
107    .zip(wakeupLoadDependencyByIQVec)
108    .zip(params.wakeUpInExuSources.map(_.name)).foreach {
109    case ((deps, originalDeps), name) => deps.zip(originalDeps).zipWithIndex.foreach {
110      case ((dep, originalDep), deqPortIdx) =>
111        if (params.backendParam.getLdExuIdx(params.backendParam.allExuParams.find(_.name == name).get) == deqPortIdx)
112          dep := (originalDep << 2).asUInt | 2.U
113        else
114          dep := originalDep << 1
115    }
116  }
117
118  when(io.enq.valid && io.transSel) {
119    validRegNext := true.B
120  }.elsewhen(clear) {
121    validRegNext := false.B
122  }.otherwise {
123    validRegNext := validReg
124  }
125
126  if (params.hasIQWakeUp) {
127    srcCancelVec.get.zip(srcLoadCancelVec.get).zip(srcWakeUpByIQWithoutCancel).zipWithIndex.foreach { case (((srcCancel, srcLoadCancel), wakeUpByIQVec), srcIdx) =>
128      val ldTransCancel = Mux1H(wakeUpByIQVec, wakeupLoadDependencyByIQVec.map(dep => LoadShouldCancel(Some(dep), io.ldCancel)))
129      srcLoadCancel := LoadShouldCancel(entryReg.status.srcLoadDependency.map(_(srcIdx)), io.ldCancel)
130      srcCancel := srcLoadCancel || ldTransCancel
131    }
132    cancelVec.get.foreach(_ := false.B)
133  }
134
135  if (io.wakeUpFromIQ.isEmpty) {
136    srcWakeUpByIQVec := 0.U.asTypeOf(srcWakeUpByIQVec)
137    wakeupLoadDependencyByIQVec := 0.U.asTypeOf(wakeupLoadDependencyByIQVec)
138  } else {
139    val wakeupVec: Seq[Seq[Bool]] = io.wakeUpFromIQ.map((bundle: ValidIO[IssueQueueIQWakeUpBundle]) =>
140      bundle.bits.wakeUp(entryReg.status.psrc zip entryReg.status.srcType, bundle.valid)
141    ).toSeq.transpose
142    val cancelSel = params.wakeUpSourceExuIdx.zip(io.wakeUpFromIQ).map{ case (x, y) => io.og0Cancel(x) && y.bits.is0Lat}
143    srcWakeUpByIQVec := wakeupVec.map(x => VecInit(x.zip(cancelSel).map { case (wakeup, cancel) => wakeup && !cancel }))
144    srcWakeUpButCancel := wakeupVec.map(x => VecInit(x.zip(cancelSel).map { case (wakeup, cancel) => wakeup && cancel }))
145    srcWakeUpByIQWithoutCancel := wakeupVec.map(x => VecInit(x))
146    wakeupLoadDependencyByIQVec := io.wakeUpFromIQ.map(_.bits.loadDependency).toSeq
147  }
148
149  val regSrcWakeUpL1ExuOH = OptionWrapper(params.hasIQWakeUp, Wire(Vec(params.numRegSrc, ExuVec())))
150  if (params.hasIQWakeUp) {
151    regSrcWakeUpL1ExuOH.get.zip(entryReg.status.srcWakeUpL1ExuOH.get).foreach {
152      case (exuOH, regExuOH) =>
153        exuOH := 0.U.asTypeOf(exuOH)
154        params.wakeUpSourceExuIdx.foreach(x => exuOH(x) := regExuOH(x))
155    }
156  }
157
158  when(io.enq.valid && io.transSel) {
159    entryRegNext := io.enq.bits
160  }.otherwise {
161    //update status
162    entryRegNext.status.srcState.zip(entryReg.status.srcState).zip(srcWakeUp).zipWithIndex.foreach { case (((stateNext, state), wakeup), srcIdx) =>
163      val cancel = srcCancelVec.map(_ (srcIdx)).getOrElse(false.B)
164      stateNext := Mux(cancel, false.B, wakeup | state)
165      if (params.hasIQWakeUp) {
166        cancelVec.get(srcIdx) := cancel
167      }
168    }
169    entryRegNext.status.dataSources.zip(entryReg.status.dataSources).zip(srcWakeUpByIQVec).foreach {
170      case ((dataSourceNext: DataSource, dataSource: DataSource), wakeUpByIQOH: Vec[Bool]) =>
171        when(wakeUpByIQOH.asUInt.orR) {
172          dataSourceNext.value := DataSource.bypass
173        }.otherwise {
174          dataSourceNext.value := DataSource.reg
175        }
176    }
177    if (params.hasIQWakeUp) {
178      entryRegNext.status.srcWakeUpL1ExuOH.get.zip(srcWakeUpByIQVec).zip(srcWakeUp).zipWithIndex.foreach {
179        case (((exuOH: Vec[Bool], wakeUpByIQOH: Vec[Bool]), wakeUp: Bool), srcIdx) =>
180          val origExuOH = 0.U.asTypeOf(exuOH)
181          when(wakeUpByIQOH.asUInt.orR) {
182            origExuOH := VecInit(Mux1H(wakeUpByIQOH, params.wakeUpSourceExuIdx.toSeq.map(x => MathUtils.IntToOH(x).U(backendParams.numExu.W))).asBools)
183          }.elsewhen(wakeUp) {
184            origExuOH := 0.U.asTypeOf(origExuOH)
185          }.otherwise {
186            origExuOH := regSrcWakeUpL1ExuOH.get(srcIdx)
187          }
188          exuOH := 0.U.asTypeOf(exuOH)
189          params.wakeUpSourceExuIdx.foreach(x => exuOH(x) := origExuOH(x))
190      }
191      entryRegNext.status.srcTimer.get.zip(entryReg.status.srcTimer.get).zip(srcWakeUpByIQVec).zipWithIndex.foreach {
192        case (((srcIssuedTimerNext, srcIssuedTimer), wakeUpByIQOH: Vec[Bool]), srcIdx) =>
193          srcIssuedTimerNext := MuxCase(3.U, Seq(
194            // T0: waked up by IQ, T1: reset timer as 1
195            wakeUpByIQOH.asUInt.orR -> 2.U,
196            // do not overflow
197            srcIssuedTimer.andR -> srcIssuedTimer,
198            // T2+: increase if the entry is valid, the src is ready, and the src is woken up by iq
199            (validReg && SrcState.isReady(entryReg.status.srcState(srcIdx)) && regSrcWakeUpL1ExuOH.get(srcIdx).asUInt.orR) -> (srcIssuedTimer + 1.U)
200          ))
201      }
202      entryRegNext.status.srcLoadDependency.get.zip(entryReg.status.srcLoadDependency.get).zip(srcWakeUpByIQVec).zip(srcWakeUp).foreach {
203        case (((loadDependencyNext, loadDependency), wakeUpByIQVec), wakeup) =>
204          loadDependencyNext :=
205            Mux(wakeup,
206              Mux1H(wakeUpByIQVec, shiftedWakeupLoadDependencyByIQVec),
207              Mux(validReg && loadDependency.asUInt.orR, VecInit(loadDependency.map(i => i(i.getWidth - 2, 0) << 1)), loadDependency)
208            )
209      }
210    }
211    when (io.deqSel) {
212      entryRegNext.status.issueTimer := 0.U
213      entryRegNext.status.deqPortIdx := io.deqPortIdxWrite
214    }.elsewhen (entryReg.status.issued) {
215      entryRegNext.status.issueTimer := entryReg.status.issueTimer + 1.U
216      entryRegNext.status.deqPortIdx := entryReg.status.deqPortIdx
217    }.otherwise {
218      entryRegNext.status.issueTimer := "b10".U
219      entryRegNext.status.deqPortIdx := 0.U
220    }
221    entryRegNext.status.psrc := entryReg.status.psrc
222    entryRegNext.status.srcType := entryReg.status.srcType
223    entryRegNext.status.fuType := entryReg.status.fuType
224    entryRegNext.status.robIdx := entryReg.status.robIdx
225    entryRegNext.status.uopIdx.foreach(_ := entryReg.status.uopIdx.get)
226    when(srcLoadCancelVec.map(_.reduce(_ || _)).getOrElse(false.B) || srcWakeUpButCancel.map(_.fold(false.B)(_ || _)).fold(false.B)(_ || _)) {
227      entryRegNext.status.issued := false.B
228    }.elsewhen(io.deqSel) {
229      entryRegNext.status.issued := true.B
230    }.elsewhen(io.issueResp.valid && RSFeedbackType.isBlocked(io.issueResp.bits.respType)) {
231      entryRegNext.status.issued := false.B
232    }.elsewhen(!entryReg.status.srcReady) {
233      entryRegNext.status.issued := false.B
234    }.otherwise {
235      entryRegNext.status.issued := entryReg.status.issued
236    }
237    entryRegNext.status.firstIssue := io.deqSel || entryReg.status.firstIssue
238    entryRegNext.status.blocked := false.B //todo
239    //remain imm and payload
240    entryRegNext.imm.foreach(_ := entryReg.imm.get)
241    entryRegNext.payload := entryReg.payload
242  }
243
244  //output
245  val canIssue = entryReg.status.canIssue && validReg && !srcCancelVec.getOrElse(false.B).asUInt.orR
246  val canIssueBypass = validReg && !entryReg.status.issued && !entryReg.status.blocked &&
247    VecInit(entryReg.status.srcState.zip(srcWakeUpByIQWithoutCancel).zipWithIndex.map { case ((state, wakeupVec), srcIdx) =>
248      val cancel = srcCancelVec.map(_ (srcIdx)).getOrElse(false.B)
249      Mux(cancel, false.B, wakeupVec.asUInt.orR | state)
250    }).asUInt.andR
251  io.dataSource.zip(entryReg.status.dataSources).zip(srcWakeUpByIQVec).zip(srcWakeUp).foreach {
252    case (((dataSourceOut: DataSource, dataSource: DataSource), wakeUpByIQOH: Vec[Bool]), wakeUpAll) =>
253      when(wakeUpByIQOH.asUInt.orR) {
254        dataSourceOut.value := DataSource.forward
255      }.otherwise {
256        dataSourceOut.value := dataSource.value
257      }
258  }
259  if (params.hasIQWakeUp) {
260    srcWakeUpL1ExuOHOut.get.zip(srcWakeUpByIQWithoutCancel).zip(srcWakeUp).zipWithIndex.foreach {
261      case (((exuOH: Vec[Bool], wakeUpByIQOH: Vec[Bool]), wakeUp: Bool), srcIdx) =>
262        val origExuOH = 0.U.asTypeOf(exuOH)
263        when(wakeUpByIQOH.asUInt.orR) {
264          origExuOH := VecInit(Mux1H(wakeUpByIQOH, params.wakeUpSourceExuIdx.map(x => MathUtils.IntToOH(x).U(backendParams.numExu.W)).toSeq).asBools)
265        }.otherwise {
266          origExuOH := regSrcWakeUpL1ExuOH.get(srcIdx)
267        }
268        exuOH := 0.U.asTypeOf(exuOH)
269        params.wakeUpSourceExuIdx.foreach(x => exuOH(x) := origExuOH(x))
270    }
271    srcLoadDependencyOut.get.zip(entryReg.status.srcLoadDependency.get).zip(srcWakeUpByIQVec).zip(srcWakeUp).foreach {
272      case (((loadDependencyOut, loadDependency), wakeUpByIQVec), wakeup) =>
273        loadDependencyOut := Mux1H(wakeUpByIQVec, shiftedWakeupLoadDependencyByIQBypassVec)
274    }
275    io.srcTimer.get.zip(entryReg.status.srcTimer.get).zip(srcWakeUpByIQWithoutCancel).zip(srcWakeUp).foreach {
276      case (((srcTimerOut, srcTimer), wakeUpByIQOH: Vec[Bool]), wakeUpAll) =>
277        when(wakeUpByIQOH.asUInt.orR) {
278          srcTimerOut := Mux1H(wakeUpByIQOH, io.wakeUpFromIQ.map(_.bits.is0Lat).toSeq).asUInt
279        }.otherwise {
280          srcTimerOut := srcTimer
281        }
282    }
283    io.srcWakeUpL1ExuOH.get := Mux(canIssueBypass && !canIssue, srcWakeUpL1ExuOHOut.get, regSrcWakeUpL1ExuOH.get).map(_.asUInt)
284  }
285  io.canIssue := (canIssue || canIssueBypass) && !flushed
286  io.clear := clear
287  io.fuType := entryReg.status.fuType
288  io.valid := validReg
289  io.isFirstIssue := !entryReg.status.firstIssue
290  io.entry.valid := validReg
291  io.entry.bits := entryReg
292  io.entry.bits.status.srcLoadDependency.foreach(_ := Mux(canIssueBypass && !canIssue, srcLoadDependencyOut.get, entryReg.status.srcLoadDependency.get))
293  io.robIdx := entryReg.status.robIdx
294  io.uopIdx.foreach(_ := entryReg.status.uopIdx.get)
295  io.issueTimerRead := entryReg.status.issueTimer
296  io.deqPortIdxRead := entryReg.status.deqPortIdx
297  io.cancel.foreach(_ := cancelVec.get.asUInt.orR)
298}
299
300class OthersEntryMem()(implicit p: Parameters, params: IssueBlockParams) extends OthersEntry
301  with HasCircularQueuePtrHelper {
302
303  val fromMem = io.fromMem.get
304
305  val memStatus = entryReg.status.mem.get
306  val memStatusNext = entryRegNext.status.mem.get
307  // load cannot be issued before older store, unless meet some condition
308  val blockedByOlderStore = isAfter(memStatusNext.sqIdx, fromMem.stIssuePtr)
309
310  val deqFailedForStdInvalid = io.issueResp.valid && io.issueResp.bits.respType === RSFeedbackType.dataInvalid
311
312  val staWaitedReleased = Cat(
313    fromMem.memWaitUpdateReq.robIdx.map(x => x.valid && x.bits.value === memStatusNext.waitForRobIdx.value)
314  ).orR
315  val stdWaitedReleased = Cat(
316    fromMem.memWaitUpdateReq.sqIdx.map(x => x.valid && x.bits.value === memStatusNext.waitForSqIdx.value)
317  ).orR
318  val olderStaNotViolate = staWaitedReleased && !memStatusNext.strictWait
319  val olderStdReady = stdWaitedReleased && memStatusNext.waitForStd
320  val waitStd = !olderStdReady
321  val waitSta = !olderStaNotViolate
322
323  when(io.enq.valid && io.transSel) {
324    memStatusNext.waitForSqIdx := io.enq.bits.status.mem.get.waitForSqIdx
325    // update by lfst at dispatch stage
326    memStatusNext.waitForRobIdx := io.enq.bits.status.mem.get.waitForRobIdx
327    // new load inst don't known if it is blocked by store data ahead of it
328    memStatusNext.waitForStd := false.B
329    // update by ssit at rename stage
330    memStatusNext.strictWait := io.enq.bits.status.mem.get.strictWait
331    memStatusNext.sqIdx := io.enq.bits.status.mem.get.sqIdx
332  }.elsewhen(deqFailedForStdInvalid) {
333    // Todo: check if need assign statusNext.block
334    memStatusNext.waitForSqIdx := io.issueResp.bits.dataInvalidSqIdx
335    memStatusNext.waitForRobIdx := memStatus.waitForRobIdx
336    memStatusNext.waitForStd := true.B
337    memStatusNext.strictWait := memStatus.strictWait
338    memStatusNext.sqIdx := memStatus.sqIdx
339  }.otherwise {
340    memStatusNext := memStatus
341  }
342
343  val shouldBlock = Mux(io.enq.valid && io.transSel, io.enq.bits.status.blocked, entryReg.status.blocked)
344  val blockNotReleased = waitStd || waitSta
345  val respBlock = deqFailedForStdInvalid
346  entryRegNext.status.blocked := shouldBlock && blockNotReleased && blockedByOlderStore || respBlock
347}
348
349class OthersEntryVecMemAddr()(implicit p: Parameters, params: IssueBlockParams) extends OthersEntryMem {
350
351  require(params.isVecMemAddrIQ, "OthersEntryVecMemAddr can only be instance of VecMemAddr IQ")
352
353  val vecMemStatus = entryReg.status.vecMem.get
354  val vecMemStatusNext = entryRegNext.status.vecMem.get
355  val fromLsq = io.fromLsq.get
356
357  when(io.enq.valid && io.transSel) {
358    vecMemStatusNext.sqIdx := io.enq.bits.status.vecMem.get.sqIdx
359    vecMemStatusNext.lqIdx := io.enq.bits.status.vecMem.get.lqIdx
360  }.otherwise {
361    vecMemStatusNext := vecMemStatus
362  }
363
364  val isLsqHead = {
365    // if (params.isVecLdAddrIQ)
366      entryRegNext.status.vecMem.get.lqIdx <= fromLsq.lqDeqPtr &&
367    // else
368      entryRegNext.status.vecMem.get.sqIdx <= fromLsq.sqDeqPtr
369  }
370  dontTouch(shouldBlock)
371  dontTouch(blockNotReleased)
372  dontTouch(blockedByOlderStore)
373  dontTouch(respBlock)
374  dontTouch(isLsqHead)
375  dontTouch(waitStd)
376  dontTouch(waitSta)
377  dontTouch(memStatusNext)
378  dontTouch(fromMem)
379  dontTouch(io.issueResp)
380  dontTouch(isLsqHead)
381
382  entryRegNext.status.blocked := shouldBlock && blockNotReleased && blockedByOlderStore || respBlock || !isLsqHead
383}
384
385class OthersEntryVecMemData()(implicit p: Parameters, params: IssueBlockParams) extends OthersEntry
386  with HasCircularQueuePtrHelper {
387
388  require(params.isVecStDataIQ, "OthersEntryVecMemData can only be instance of VecMemData IQ")
389
390  val vecMemStatus = entryReg.status.vecMem.get
391  val vecMemStatusNext = entryRegNext.status.vecMem.get
392  val fromLsq = io.fromLsq.get
393
394  when(io.enq.valid && io.transSel) {
395    vecMemStatusNext.sqIdx := io.enq.bits.status.vecMem.get.sqIdx
396    vecMemStatusNext.lqIdx := io.enq.bits.status.vecMem.get.lqIdx
397  }.otherwise {
398    vecMemStatusNext := vecMemStatus
399  }
400
401  val isLsqHead = entryRegNext.status.vecMem.get.sqIdx.value === fromLsq.sqDeqPtr.value
402
403  entryRegNext.status.blocked := !isLsqHead
404}
405
406object OthersEntry {
407  def apply(implicit p: Parameters, iqParams: IssueBlockParams): OthersEntry = {
408    iqParams.schdType match {
409      case IntScheduler() => new OthersEntry()
410      case MemScheduler() =>
411        if (iqParams.isLdAddrIQ || iqParams.isStAddrIQ || iqParams.isHyAddrIQ) new OthersEntryMem()
412        else if (iqParams.isVecMemAddrIQ) new OthersEntryVecMemAddr()
413        else if (iqParams.isVecStDataIQ) new OthersEntryVecMemData()
414        else new OthersEntry()
415      case VfScheduler() => new OthersEntry()
416      case _ => null
417    }
418  }
419}