xref: /XiangShan/src/main/scala/xiangshan/backend/decode/VecExceptionGen.scala (revision 1e1ca94a164206ee6cf7295c0be8f3d49e89268a) 
1package xiangshan.backend.decode
2
3import org.chipsalliance.cde.config.Parameters
4import chisel3._
5import chisel3.util._
6import freechips.rocketchip.rocket.Instructions._
7import freechips.rocketchip.util.uintToBitPat
8import utility._
9import utils._
10import xiangshan._
11import xiangshan.backend.Bundles.{DecodedInst, DynInst, StaticInst}
12import xiangshan.backend.fu.FuType
13import xiangshan.backend.fu.vector.Bundles._
14import xiangshan.backend.decode.isa.bitfield.{InstVType, XSInstBitFields}
15
16object RegNumNotAlign {
17  def apply(reg: UInt, emul: UInt): Bool = {
18    emul === "b101".U && reg(0) =/= 0.U || emul === "b110".U && reg(1, 0) =/= 0.U || emul === "b111".U && reg(2, 0) =/= 0.U
19  }
20}
21
22object NFtoLmul {
23  def apply(nf: UInt): UInt = {
24    LookupTree(nf, List(
25      "b000".U -> 4.U,
26      "b001".U -> 5.U,
27      "b011".U -> 6.U,
28      "b111".U -> 7.U
29    ))
30  }
31}
32
33object LmultoRegNum {
34  def apply(lmul: UInt): UInt = {
35    val numPow = Mux(lmul(2).asBool, lmul(1, 0), 0.U(2.W))
36    val regNum = 1.U << numPow
37    regNum
38  }
39}
40
41class VecExceptionGen(implicit p: Parameters) extends XSModule{
42  val io = IO(new Bundle(){
43    val inst = Input(UInt(32.W))
44    val decodedInst = Input(new DecodedInst)
45    val vtype = Input(new VType)
46
47    val illegalInst = Output(Bool())
48  })
49
50  private val inst: XSInstBitFields = io.inst.asTypeOf(new XSInstBitFields)
51  private val isVArithMem = FuType.isVArithMem(io.decodedInst.fuType)
52  private val isVset = FuType.isVset(io.decodedInst.fuType)
53
54  private val SEW = io.vtype.vsew(1, 0)
55  private val LMUL = Cat(~io.vtype.vlmul(2), io.vtype.vlmul(1, 0))
56
57  private val lsStrideInst = Seq(
58    VLE8_V, VLE16_V, VLE32_V, VLE64_V, VSE8_V, VSE16_V, VSE32_V, VSE64_V,
59    VLSE8_V, VLSE16_V, VLSE32_V, VLSE64_V, VSSE8_V, VSSE16_V, VSSE32_V, VSSE64_V,
60    VLE8FF_V, VLE16FF_V, VLE32FF_V, VLE64FF_V
61  ).map(_ === inst.ALL).reduce(_ || _)
62
63  private val lsMaskInst = Seq(
64    VLM_V, VSM_V
65  ).map(_ === inst.ALL).reduce(_ || _)
66
67  private val lsIndexInst = Seq(
68    VLUXEI8_V, VLUXEI16_V, VLUXEI32_V, VLUXEI64_V, VLOXEI8_V, VLOXEI16_V, VLOXEI32_V, VLOXEI64_V,
69    VSUXEI8_V, VSUXEI16_V, VSUXEI32_V, VSUXEI64_V, VSOXEI8_V, VSOXEI16_V, VSOXEI32_V, VSOXEI64_V
70  ).map(_ === inst.ALL).reduce(_ || _)
71
72  private val lsWholeInst = Seq(
73    VL1RE8_V, VL1RE16_V, VL1RE32_V, VL1RE64_V,
74    VL2RE8_V, VL2RE16_V, VL2RE32_V, VL2RE64_V,
75    VL4RE8_V, VL4RE16_V, VL4RE32_V, VL4RE64_V,
76    VL8RE8_V, VL8RE16_V, VL8RE32_V, VL8RE64_V,
77    VS1R_V, VS2R_V, VS4R_V, VS8R_V
78  ).map(_ === inst.ALL).reduce(_ || _)
79
80  private val vdWideningInst = Seq(
81    //int
82    VWADD_VV, VWADD_VX, VWADD_WV, VWADD_WX, VWADDU_VV, VWADDU_VX, VWADDU_WV, VWADDU_WX,
83    VWMACC_VV, VWMACC_VX, VWMACCSU_VV, VWMACCSU_VX, VWMACCU_VV, VWMACCU_VX, VWMACCUS_VX,
84    VWMUL_VV, VWMUL_VX, VWMULSU_VV, VWMULSU_VX, VWMULU_VV, VWMULU_VX,
85    VWSUB_VV, VWSUB_VX, VWSUB_WV, VWSUB_WX, VWSUBU_VV, VWSUBU_VX, VWSUBU_WV, VWSUBU_WX,
86    //fp
87    VFWADD_VF, VFWADD_VV, VFWADD_WF, VFWADD_WV, VFWSUB_VF, VFWSUB_VV, VFWSUB_WF, VFWSUB_WV,
88    VFWMUL_VF, VFWMUL_VV,
89    VFWMACC_VF, VFWMACC_VV, VFWMSAC_VF, VFWMSAC_VV, VFWNMACC_VF, VFWNMACC_VV, VFWNMSAC_VF, VFWNMSAC_VV,
90    VFWCVT_F_F_V, VFWCVT_F_X_V, VFWCVT_F_XU_V, VFWCVT_RTZ_X_F_V, VFWCVT_RTZ_XU_F_V, VFWCVT_X_F_V, VFWCVT_XU_F_V
91  ).map(_ === inst.ALL).reduce(_ || _)
92
93  private val vs2WideningInst = Seq(
94    //int
95    VWADD_WV, VWADD_WX, VWADDU_WV, VWADDU_WX,
96    VWSUB_WV, VWSUB_WX, VWSUBU_WV, VWSUBU_WX,
97    //fp
98    VFWADD_WF, VFWADD_WV, VFWSUB_WF, VFWSUB_WV
99  ).map(_ === inst.ALL).reduce(_ || _)
100
101  private val narrowingInst = Seq(
102    //int
103    VNCLIP_WI, VNCLIP_WV, VNCLIP_WX, VNCLIPU_WI, VNCLIPU_WV, VNCLIPU_WX,
104    VNSRA_WI, VNSRA_WV, VNSRA_WX, VNSRL_WI, VNSRL_WV, VNSRL_WX,
105    //fp
106    VFNCVT_F_F_W, VFNCVT_F_X_W, VFNCVT_F_XU_W, VFNCVT_ROD_F_F_W, VFNCVT_RTZ_X_F_W, VFNCVT_RTZ_XU_F_W, VFNCVT_X_F_W, VFNCVT_XU_F_W
107  ).map(_ === inst.ALL).reduce(_ || _)
108
109  private val intExtInst = Seq(
110    VSEXT_VF2, VSEXT_VF4, VSEXT_VF8, VZEXT_VF2, VZEXT_VF4, VZEXT_VF8
111  ).map(_ === inst.ALL).reduce(_ || _)
112
113  private val acsbInst = Seq(
114    VMADC_VI, VMADC_VIM, VMADC_VV, VMADC_VVM, VMADC_VX, VMADC_VXM,
115    VMSBC_VV, VMSBC_VVM, VMSBC_VX, VMSBC_VXM
116  ).map(_ === inst.ALL).reduce(_ || _)
117
118  private val cmpInst = Seq(
119    //int
120    VMSEQ_VI, VMSEQ_VV, VMSEQ_VX,
121    VMSGT_VI, VMSGT_VX, VMSGTU_VI, VMSGTU_VX,
122    VMSLE_VI, VMSLE_VV, VMSLE_VX, VMSLEU_VI, VMSLEU_VV, VMSLEU_VX,
123    VMSLT_VV, VMSLT_VX, VMSLTU_VV, VMSLTU_VX,
124    VMSNE_VI, VMSNE_VV, VMSNE_VX,
125    //fp
126    VMFEQ_VF, VMFEQ_VV, VMFNE_VF, VMFNE_VV,
127    VMFGE_VF, VMFGT_VF, VMFLE_VF, VMFLE_VV, VMFLT_VF, VMFLT_VV
128  ).map(_ === inst.ALL).reduce(_ || _)
129
130  private val redInst = Seq(
131    VREDAND_VS, VREDMAX_VS, VREDMAXU_VS, VREDMIN_VS, VREDMINU_VS, VREDOR_VS, VREDSUM_VS, VREDXOR_VS,
132    VFREDMAX_VS, VFREDMIN_VS, VFREDOSUM_VS, VFREDUSUM_VS
133  ).map(_ === inst.ALL).reduce(_ || _)
134
135  private val redWideningInst = Seq(
136    VWREDSUM_VS, VWREDSUMU_VS,
137    VFWREDOSUM_VS, VFWREDUSUM_VS
138  ).map(_ === inst.ALL).reduce(_ || _)
139
140  private val maskLogicalInst = Seq(
141    VMAND_MM, VMNAND_MM, VMANDN_MM, VMXOR_MM, VMOR_MM, VMNOR_MM, VMORN_MM, VMXNOR_MM
142  ).map(_ === inst.ALL).reduce(_ || _)
143
144  private val maskArithmeticInst = Seq(
145    VCPOP_M, VFIRST_M, VMSBF_M, VMSIF_M, VMSOF_M
146  ).map(_ === inst.ALL).reduce(_ || _) || maskLogicalInst
147
148  private val maskIndexInst = Seq(
149    VIOTA_M, VID_V
150  ).map(_ === inst.ALL).reduce(_ || _)
151
152  private val vmvSingleInst = Seq(
153    VMV_X_S, VMV_S_X, VFMV_F_S, VFMV_S_F
154  ).map(_ === inst.ALL).reduce(_ || _)
155
156  private val vmvWholeInst = Seq(
157    VMV1R_V, VMV2R_V, VMV4R_V, VMV8R_V
158  ).map(_ === inst.ALL).reduce(_ || _)
159
160  private val vrgather16 = VRGATHEREI16_VV === inst.ALL
161  private val vcompress = VCOMPRESS_VM === inst.ALL
162  private val intExt2 = Seq(VSEXT_VF2, VZEXT_VF2).map(_ === inst.ALL).reduce(_ || _)
163  private val intExt4 = Seq(VSEXT_VF4, VZEXT_VF4).map(_ === inst.ALL).reduce(_ || _)
164  private val intExt8 = Seq(VSEXT_VF8, VZEXT_VF8).map(_ === inst.ALL).reduce(_ || _)
165
166  private val notDependVtypeInst = Seq(VSETVLI, VSETIVLI, VSETVL).map(_ === inst.ALL).reduce(_ || _) || lsWholeInst
167
168
169  // 1. inst Illegal
170  private val instIllegal = maskLogicalInst && inst.VM === 0.U
171
172  // 2. vill Illegal
173  private val villIllegal = io.vtype.illegal && isVArithMem && !notDependVtypeInst
174
175  // 3. EEW Illegal
176  private val doubleFpInst = Seq(
177    VFWCVT_F_X_V, VFWCVT_F_XU_V, VFNCVT_RTZ_X_F_W, VFNCVT_RTZ_XU_F_W, VFNCVT_X_F_W, VFNCVT_XU_F_W
178  ).map(_ === inst.ALL).reduce(_ || _)
179  private val fpEewIllegal = FuType.isVecOPF(io.decodedInst.fuType) && !doubleFpInst && SEW === 0.U
180
181  private val intExtEewIllegal = intExt2 && SEW === 0.U ||
182                                 intExt4 && SEW <= 1.U ||
183                                 intExt8 && SEW <= 2.U
184
185  private val wnEewIllegal = (vdWideningInst || narrowingInst || redWideningInst) && SEW === 3.U
186
187  private val eewIllegal = fpEewIllegal || intExtEewIllegal || wnEewIllegal
188
189  // 4. EMUL Illegal
190  private val lsEmulIllegal = (lsStrideInst || lsIndexInst) && (LMUL +& inst.WIDTH(1, 0) < SEW +& 1.U || LMUL +& inst.WIDTH(1, 0) > SEW +& 7.U)
191
192  private val intExtEmulIllegal = intExt2 && LMUL === 1.U ||
193                                  intExt4 && LMUL <= 2.U ||
194                                  intExt8 && LMUL <= 3.U
195
196  private val wnEmulIllegal = (vdWideningInst || narrowingInst || redWideningInst) && LMUL === 7.U
197
198  private val gather16EmulIllegal = vrgather16 && (LMUL < SEW || LMUL > SEW +& 6.U)
199
200  private val NFIELDS = inst.NF +& 1.U
201  private val segEmul = Mux(lsIndexInst, LMUL, LMUL +& inst.WIDTH(1, 0) - SEW)
202  private val emulNumPow = Mux(segEmul(2), segEmul(1, 0), 0.U(2.W))
203  private val segRegNum = NFIELDS << emulNumPow
204  private val segRegMax = inst.VD +& segRegNum
205
206  private val lsSegIllegal = (lsStrideInst || lsIndexInst) && inst.NF =/= 0.U && (segRegNum > 8.U || segRegMax > 32.U)
207
208  private val emulIllegal = lsEmulIllegal || intExtEmulIllegal || wnEmulIllegal || gather16EmulIllegal || lsSegIllegal
209
210  // 5. Reg Number Align
211  private val vs1IsMask = maskArithmeticInst || vcompress
212  private val vs1IsSingleElem = redInst || redWideningInst
213  private val vs1Eew = Mux(vrgather16, "b01".U, SEW)
214  private val vs1Emul = Mux(vs1IsMask || vs1IsSingleElem, "b100".U, Mux(vrgather16, LMUL +& 1.U - SEW, LMUL))
215  private val vs1NotAlign = SrcType.isVp(io.decodedInst.srcType(0)) && RegNumNotAlign(inst.VS1, vs1Emul)
216
217  private val vs2IsMask = maskArithmeticInst || maskIndexInst
218  private val vs2IsSingleElem = vmvSingleInst
219  private val vs2EewSel = Cat(lsIndexInst, (vs2WideningInst || narrowingInst || redWideningInst), intExt2, intExt4, intExt8)
220  private val vs2Eew = LookupTreeDefault(vs2EewSel, SEW, List(
221    "b10000".U  -> inst.WIDTH(1, 0),
222    "b01000".U  -> (SEW + 1.U),
223    "b00100".U  -> (SEW - 1.U),
224    "b00010".U  -> (SEW - 2.U),
225    "b00001".U  -> (SEW - 3.U)
226  ))
227  private val vs2EmulSel = Cat((vs2IsMask || vs2IsSingleElem), (vs2WideningInst || narrowingInst), vmvWholeInst, (intExtInst || lsIndexInst))
228  private val vs2Emul = LookupTreeDefault(vs2EmulSel, LMUL, List(
229    "b1000".U  -> "b100".U,
230    "b0100".U  -> (LMUL + 1.U),
231    "b0010".U  -> NFtoLmul(inst.NF),
232    "b0001".U  -> (LMUL +& vs2Eew - SEW)
233  ))
234  private val vs2NotAlign = SrcType.isVp(io.decodedInst.srcType(1)) && RegNumNotAlign(inst.VS2, vs2Emul)
235
236  private val vdIsMask = lsMaskInst || acsbInst || cmpInst || maskArithmeticInst
237  private val vdIsSingleElem = redInst || redWideningInst || vmvSingleInst
238  private val vdEew = Mux(lsStrideInst, inst.WIDTH(1, 0), Mux(vdWideningInst || redWideningInst, SEW + 1.U, SEW))
239  private val vdEmulSel = Cat((vdIsMask || vdIsSingleElem), vdWideningInst, (lsWholeInst || vmvWholeInst), lsStrideInst)
240  private val vdEmul = LookupTreeDefault(vdEmulSel, LMUL, List(
241    "b1000".U  -> "b100".U,
242    "b0100".U  -> (LMUL + 1.U),
243    "b0010".U  -> NFtoLmul(inst.NF),
244    "b0001".U  -> (LMUL +& vdEew - SEW)
245  ))
246  private val vdNotAlign = (SrcType.isVp(io.decodedInst.srcType(2)) || io.decodedInst.vecWen) && RegNumNotAlign(inst.VD, vdEmul)
247
248  private val regNumIllegal = isVArithMem && (vs1NotAlign || vs2NotAlign || vdNotAlign)
249
250  // 6. v0 Overlap
251  private val v0AllowOverlap = (vdIsMask || vdIsSingleElem) && !Seq(VMSBF_M, VMSIF_M, VMSOF_M).map(_ === inst.ALL).reduce(_ || _)
252  private val v0Overlap = isVArithMem && io.decodedInst.vecWen && inst.VM === 0.U && inst.VD === 0.U && !v0AllowOverlap
253
254  // 7. Src Reg Overlap
255  private val vs1RegLo = inst.VS1
256  private val vs1RegHi = inst.VS1 +& LmultoRegNum(vs1Emul) - 1.U
257  private val vs2RegLo = inst.VS2
258  private val vs2RegHi = inst.VS2 +& LmultoRegNum(vs2Emul) - 1.U
259  private val vdRegLo = inst.VD
260  private val vdRegHi = Mux(lsStrideInst || lsIndexInst, segRegMax - 1.U, inst.VD + LmultoRegNum(vdEmul) - 1.U)
261
262  private val notAllowOverlapInst = lsIndexInst && inst.NF =/= 0.U || Seq(VMSBF_M, VMSIF_M, VMSOF_M, VIOTA_M,
263                                    VSLIDEUP_VX, VSLIDEUP_VI, VSLIDE1UP_VX, VFSLIDE1UP_VF, VRGATHER_VV, VRGATHEREI16_VV, VRGATHER_VX, VRGATHER_VI, VCOMPRESS_VM).map(_ === inst.ALL).reduce(_ || _)
264
265  //vs1
266  private val vs1vdRegNotOverlap = vs1RegHi < vdRegLo || vdRegHi < vs1RegLo
267  private val vs1Constraint1 = vs1IsMask && vdIsMask || !vs1IsMask && !vdIsMask && vs1Eew === vdEew
268  private val vs1Constraint2 = (vdIsMask && !vs1IsMask || !vs1IsMask && !vdIsMask && vs1Eew > vdEew) && vdRegLo === vs1RegLo && vdRegHi <= vs1RegHi
269  private val vs1Constraint3 = (!vdIsMask && vs1IsMask || !vs1IsMask && !vdIsMask && vs1Eew < vdEew) && vs1Emul >= "b100".U && vdRegHi === vs1RegHi && vdRegLo <= vs1RegLo
270  private val vs1AllowOverlap = (vs1Constraint1 || vs1Constraint2 || vs1Constraint3 || vdIsSingleElem) && !notAllowOverlapInst
271  private val vs1vdOverlap = (SrcType.isVp(io.decodedInst.srcType(0)) && io.decodedInst.vecWen) && !vs1vdRegNotOverlap && !vs1AllowOverlap
272  //vs2
273  private val vs2vdRegNotOverlap = vs2RegHi < vdRegLo || vdRegHi < vs2RegLo
274  private val vs2Constraint1 = vs2IsMask && vdIsMask || !vs2IsMask && !vdIsMask && vs2Eew === vdEew
275  private val vs2Constraint2 = (vdIsMask && !vs2IsMask || !vs2IsMask && !vdIsMask && vs2Eew > vdEew) && vdRegLo === vs2RegLo && vdRegHi <= vs2RegHi
276  private val vs2Constraint3 = (!vdIsMask && vs2IsMask || !vs2IsMask && !vdIsMask && vs2Eew < vdEew) && vs2Emul >= "b100".U && vdRegHi === vs2RegHi && vdRegLo <= vs2RegLo
277  private val vs2AllowOverlap = (vs2Constraint1 || vs2Constraint2 || vs2Constraint3 || vdIsSingleElem) && !notAllowOverlapInst
278  private val vs2vdOverlap = (SrcType.isVp(io.decodedInst.srcType(1)) && io.decodedInst.vecWen) && !vs2vdRegNotOverlap && !vs2AllowOverlap
279
280  private val regOverlapIllegal = v0Overlap || vs1vdOverlap || vs2vdOverlap
281
282  io.illegalInst := instIllegal || villIllegal || eewIllegal || emulIllegal || regNumIllegal || regOverlapIllegal
283  dontTouch(instIllegal)
284  dontTouch(villIllegal)
285  dontTouch(eewIllegal)
286  dontTouch(emulIllegal)
287  dontTouch(regNumIllegal)
288  dontTouch(regOverlapIllegal)
289  dontTouch(notDependVtypeInst)
290}